x017.h

Go to the documentation of this file.

#pragma once

#include "x011.h"
#include <random>

namespace nmx::apps::x017 {

using nmx::apps::x011::Rational;

template<class T>
class TestGenerator
{
public:
    enum class Ops { plus, minus, mul, div };
    //Synonym: Speicher für Zahlen
    using DataC = std::vector<T>;
    //Synonym: Speicher für mathematische Operationen
    using OpsC = std::array<Ops, 4>;
    //Synonym: Testfrage
    using Question = std::tuple<T, T, Ops>;

private:
    //rationale Zahlen
    DataC _data;
    //mathematische Operationen
    OpsC _types;
    //Anzahl der Fragen in einem Test
    size_t _maxQuestions;
    size_t _eIdx, _tIdx;

    void shuffle_data() {
        //erzeuge Startwert für den Zufallsgenerator
        std::random_device rd;

        //Pseudo-Zufallsgenerator
        std::default_random_engine g(rd());
        std::shuffle(_data.begin(), _data.end(), g);

        //Index hat ungültigen Wert!
        _eIdx = _data.size();
    }

    auto next_item() {
        //wenn der Index einen ungültigen Wert hat erhält er den Wert 0
        // sonst rückt er eine Position weiter
        _eIdx = (_eIdx == _data.size()) ? 0 : _eIdx + 1;
        return _data[_eIdx];
    }

    void shuffle_ops() {
        //erzeuge Startwert für den Zufallsgenerator
        std::random_device rd;

        //Pseudo-Zufallsgenerator
        std::default_random_engine g(rd());
        std::shuffle(_types.begin(), _types.end(), g);
        _tIdx = _types.size();
    }

    auto next_op() {
        //bei ungültigem Wert setze den Wert auf 0
        _tIdx = (_tIdx == _types.size()) ? 0 : _tIdx + 1;
        return _types[_tIdx];
    }

public:
    TestGenerator(size_t maxq, const DataC &data) {
        _data = data; //kopiere Zahlen
        shuffle_data(); //mische Container mit Zahlen

        //Anzahl der Fragen im Test (Startwert).
        //Wird nach einer neu gestellten Frage um 1 reduziert
        _maxQuestions = maxq;

        //initialisiere Container mit Operatoren
        _types = { Ops::plus, Ops::minus, Ops::mul, Ops::div };

        //mische Container mit  Operatoren
        shuffle_ops();
    }

    auto next_question() {
        //Anzahl der noch zu stellenden Fragen
        _maxQuestions--;
        //generiere Frage
        return std::make_tuple(next_item(), next_item(), next_op());
    }

    bool has_questions() { return _maxQuestions != 0; }

    static T calc_result(const Question &q) {
        //lese erste Zahl
        auto r1 = std::get<0>(q);
        //lese zweite Zahl
        auto r2 = std::get<1>(q);
        //das Ergebnis
        T r;
        //welcher Operator ?
        switch (std::get<2>(q)) {
        case Ops::plus: {
            r = r1 + r2;
        } break;
        case Ops::minus: {
            r = r1 - r2;
        } break;
        case Ops::mul: {
            r = r1 * r2;
        } break;
        case Ops::div: {
            r = r1 / r2;
        } break;
        }
        return r;
    }
}; //TestGenerator

class TestUI
{
public:
    using Rational = nmx::apps::x017::Rational;
    using Test = nmx::apps::x017::TestGenerator<Rational>;

    //Testgenerator
    Test test;
    //algebraische Operationen
    static const std::array<std::string, 4> ops;
    //Anzahl der richtigen Anttworten
    size_t _score = 0;
    //maximale Punktzahl
    const size_t _maxScore;

public:
    TestUI(size_t maxq, const Test::DataC &data)
        : test{ maxq, data }
        , _maxScore{ maxq } {}

    void run() {
        while (test.has_questions()) {
            try {
                std::string answer;
                //generiere Frage
                const auto q = test.next_question();
                //zeige Frage auf dem Bildschirm
                std::cout << "q: ";
                std::cout << to_string(q) << "=?" << std::endl;
                //lese Antwort als Zeichenkette
                std::cout << "a:";
                getline(std::cin, answer);
                //berechne korrekte Antwort
                auto cresult = Test::calc_result(q);
                auto uresult = read(answer);
                if (cresult == uresult) {
                    std::cout << "OK" << std::endl;
                    _score++;
                } else {
                    std::cout << "correct answer is:" //
                              << cresult << std::endl;
                }
            } catch (const std::out_of_range &err) {
                std::cout << "wrong input format" << std::endl;
                std::cout << "input must be like a/b" << std::endl;
                std::cout << err.what() << std::endl;
            } catch (const std::invalid_argument &err) {
                std::cout << "wrong input format" << std::endl;
                std::cout << "input must be like a/b" << std::endl;
                std::cout << err.what() << std::endl;
            } catch (const std::runtime_error &err) {
                std::cout << "wrong input format" << std::endl;
                std::cout << "input must be like a/b" << std::endl;
                std::cout << err.what() << std::endl;
            }
        }

        const auto score = static_cast<double>(_score) / static_cast<double>(_maxScore) * 100;
        std::cout << "score:" << score << "%" << std::endl;
    }
    inline static std::string to_string(const Test::Question &q) {
        std::stringstream sstream;
        // Frage hat die Form {rationale Zahl, rationale Zahl,Operator}
        sstream << std::get<0>(q) // lese erste rationale Zahle
                << ops[static_cast<size_t>(std::get<2>(q))] // operator
                << std::get<1>(q); // lese zweite rationale Zahl
        return sstream.str();
    }

    inline Rational read(const std::string &answer) {
        size_t l;
        //extrahiere Zähler z.B. 2 von 2/3
        long long num = std::stoll(answer, &l);
        //l zeigt auf /
        if (l == answer.size() || answer.at(l) != '/') {
            throw std::runtime_error("expected /");
        }
        //Rest der Zeichenkette z.B. /3
        auto part2 = answer.substr(l + 1);
        //extrahiere Nenner
        long long den = std::stoll(part2, &l, 10);
        if (l != part2.size()) {
            throw std::runtime_error("syntax error");
        }
        return { num, den };
    }
}; //TestUI

inline const std::array<std::string, 4> TestUI::ops{ "+", "-", "*", "/" };

inline void ex1() {
    //Erzeuge einen Container mit rationalen Zahlen
    //lege den größten Nenner fest.
    auto fn = [](long long lmaxden) {
        std::vector<TestUI::Rational> data;
        for (long long idx = 1; idx < lmaxden; idx++) {
            for (long long jdx = idx + 1; jdx < lmaxden; jdx++) {
                data.push_back({ idx, jdx });
            }
        }
        return data;
    };
    //Instanz eines Tests
    TestUI quiz{ 5, fn(10) };
    //starte Test
    quiz.run();
}

} // namespace nmx::apps::x017