Ermittlung der Anzahl fairer Würfel

1 Lösung

#322

Fortgeschrittener - C++ von hollst - 03.02.2021 um 13:01 Uhr

Zwei Würfel A und B nennt man fair, wenn im statistischen Mittel Würfel A gegenüber B genauso oft gewinnt wie umgekehrt. Das ist bei den normalen Spielwürfeln, deren sechs Spielflächen jeweils mit den Zahlen von 1 bis 6 belegt sind, in der Regel der Fall, wenn kein Würfel gezinkt ist (sei hier vorausgesetzt).

Wir nehmen jetzt den Fall an, dass die insgesamt zwölf Spielflächen der zwei Würfel nicht zweimal mit jeweils von 1 bis 6, sondern jeweils mit sechs unterschiedlichen Zahlen aus dem Intervall von 1 bis 12 belegt sind. D. h. hat man sich bei Würfel A für sechs verschiedenen Zahlen aus 1 ... 12 entschieden, so wird B mit den verbleibenden sechs Zahlen belegt. Damit gibt es sehr viele Fälle, bei denen keine zwei faire Würfel entstehen würden, bspw. wenn Würfel A mit 1 ... 6 und Würfel B mit 7 ... 12 belegt wären. In diesem Beispiel gewänne Würfel B immer gegen Würfel A. Würde man allerdings Würfel A mit 1, 2, 3, 10, 11, 12 und Würfel B mit 4 ... 9 belegen, so hätte man wieder ein faires Würfelpaar. Neben der gerade genannten zwei Flächenbelegungen gibt es allerdings weitere, die ebenfalls fair sind.

Die Programmieraufgabe bestehe darin, mittels Simulation alle Flächenbelegungen für zwei Würfel mit den Zahlen von 1 bis 12 zu ermitteln, bei denen die Würfel fair sind.

Bitte melden Sie sich an um zur Aufgabenbeschreibung eine Frage zu stellen.

Frage stellen

Bitte melden Sie sich an um eine Lösung einzureichen.

Lösung einreichen

von JKooP (18090 Punkte) - 23.05.2021 um 21:49 Uhr

C++ 17

C-Code

#include <iostream>
#include <map>
#include <vector>
#include <string>
#include <chrono>
#include <random>
#include <algorithm>
using namespace std;

int vector_sum(vector<int> v) {
    auto sum{ 0 };
    for (size_t i = 0; i < v.size(); i++)
        sum += v[i];
    return sum;
}

string vector_to_string(vector<int> v) {
    string s;
    for (const auto& i : v)
        s += to_string(i) + "-";
    s = s.substr(0, s.length() - 1);
    return s;
}
template<typename T>
bool map_contains_key(map<T, T> m, T compare) {
    for (const auto& k : m) 
        if (k.first == compare)
            return true;
    return false;
}

template<typename T>
bool map_contains_value(map<T, T> m, T compare) {
    for (const auto& v : m)
        if (v.second == compare)
            return true;
    return false;
}

template<typename T>
void vector_shuffle(vector<T>& v) {
    auto s{ (int)chrono::system_clock::now().time_since_epoch().count() };
    auto r{ default_random_engine(s) };
    shuffle(v.begin(), v.end(), r);
}

void vector_fill_range(vector<int>& v, int start, int end) {
    for (int i = start; i <= end; i++)
        v.push_back(i);
}

vector<int> vector_get_range(vector<int>& v, int start, int end) {
    vector<int> v2;
    for (int i = start; i <= end; i++)
        v2.push_back(v[i]);
    return v2;
}

int main()
{
    auto counter{ 0 };
    map<string, string> map_unique;
    vector<string> v_string_first_six;

    for (size_t i = 0; i < 10'000; i++)
    {
        vector<int> v_all{};
        string s_first_six;
        string s_last_six;

        vector_fill_range(v_all, 1, 12);
        vector_shuffle(v_all);

        vector<int> v_first_six{ vector_get_range(v_all, 0, 5) };
        vector<int> v_last_six{ vector_get_range(v_all, 6, 11) };

        if (vector_sum(v_first_six) == vector_sum(v_last_six))
        {
            sort(v_first_six.begin(), v_first_six.end());
            sort(v_last_six.begin(), v_last_six.end());

            string s_first_six{ vector_to_string(v_first_six) };
            string s_last_six{ vector_to_string(v_last_six) };

            auto contains_key{ map_contains_key(map_unique, s_first_six) };
            auto contains_value{ map_contains_value(map_unique, s_first_six) };

            if (!contains_key && !contains_value)
            {
                map_unique.emplace(s_first_six, s_last_six);
                counter++;
                v_string_first_six.push_back(s_first_six);
            }
        }
    }
    for (const auto& i : v_string_first_six)
        std::cout << "W1: " << i << "\tW2: " << map_unique[i] << " " << endl;

    std::cout << "\nAnzahl fairer Wuerfelpaare: " << counter << endl;
}