#include <iostream>
#include <vector>
#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <set>

class CZufall {
public:
    void initialisiere(int s) {
        srand(s);
    }

    int wert(int a, int b) {
        return a + rand() % (b - a + 1);
    }

    void test(int a, int b, int N) {
        std::vector<int> haeufigkeiten(b - a + 1, 0);
        for (int i = 0; i < N; ++i) {
            int zahl = wert(a, b);
            haeufigkeiten[zahl - a]++;
        }
        for (int i = 0; i < haeufigkeiten.size(); ++i) {
            std::cout << a + i << ": " << haeufigkeiten[i] << std::endl;
        }
    }

    void test_falsch(int a, int b, int N) {
        std::vector<int> haeufigkeiten(b - a + 1, 0);
        for (int i = 0; i < N; ++i) {
            initialisiere(time(NULL));
            int zahl = wert(a, b);
            haeufigkeiten[zahl - a]++;
        }
        for (int i = 0; i < haeufigkeiten.size(); ++i) {
            std::cout << a + i << ": " << haeufigkeiten[i] << std::endl;
        }
    }
};

class CLotto {
private:
    int k, n;
    std::vector<int> tippzettel;
    CZufall zufall;

public:
    CLotto(int k, int n, int s) : k(k), n(n) {
        if (s < 0) {
            zufall.initialisiere(time(NULL));
        } else {
            zufall.initialisiere(s);
        }
    }

    void setzeTippzettel(const std::vector<int>& tipp) {
        tippzettel = tipp;
    }

    std::vector<int> ziehung() {
        std::set<int> unique_numbers;
        while (unique_numbers.size() < k) {
            int zahl = zufall.wert(1, n);
            unique_numbers.insert(zahl);
        }
        return std::vector<int>(unique_numbers.begin(), unique_numbers.end());
    }

    int anzahlRichtige(const std::vector<int>& ziehung) {
        int richtige = 0;
        for (int zahl : ziehung) {
            if (std::find(tippzettel.begin(), tippzettel.end(), zahl) != tippzettel.end()) {
                richtige++;
            }
        }
        return richtige;
    }

    double monteCarloSimulation(int r, int N, bool gleicherTippzettel) {
        int treffer = 0;
        for (int i = 0; i < N; ++i) {
            if (!gleicherTippzettel) {
                setzeTippzettel(ziehung());
            }
            std::vector<int> aktuelleZiehung = ziehung();
            if (anzahlRichtige(aktuelleZiehung) == r) {
                treffer++;
            }
        }
        return static_cast<double>(treffer) / N;
    }
};

int main() {
    // Aufgabe 1: Testen der Klasse CZufall
    CZufall zufall;
    zufall.initialisiere(42);
    zufall.test(3, 7, 10000);
    zufall.test_falsch(3, 7, 10000);

    // Aufgabe 2: Testen der Klasse CLotto
    CLotto lotto(8, 38, -1);
    std::vector<int> tippzettel = {1, 2, 3, 4, 5, 6, 7, 8};
    lotto.setzeTippzettel(tippzettel);
    std::vector<int> ziehung = lotto.ziehung();
    std::cout << "Anzahl Richtige: " << lotto.anzahlRichtige(ziehung) << std::endl;

    // Monte-Carlo-Simulation
    double wahrscheinlichkeit = lotto.monteCarloSimulation(2, 10000, true);
    double wahrscheinlichkeit2 = lotto.monteCarloSimulation(2, 10000, false);
    std::cout << "Wahrscheinlichkeit für genau 3 Richtige: " << wahrscheinlichkeit << std::endl;
    std::cout << "Wahrscheinlichkeit für genau 3 Richtige: " << wahrscheinlichkeit2 << std::endl;


    return 0;
}