\documentclass[a4paper,10pt,ngerman]{scrartcl}
\usepackage{babel}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage[a4paper,margin=2.5cm,footskip=0.5cm]{geometry}
\DeclareUnicodeCharacter{25CB}{$\circ$}

% Die nächsten drei Felder bitte anpassen:
\newcommand{\Aufgabe}{Aufgabe 2: Rechenrätsel} % Aufgabennummer und Aufgabennamen angeben
\newcommand{\TeilnahmeId}{60813}                  % Teilnahme-ID angeben
\newcommand{\Name}{Marcel Zinkel}             % Name des Bearbeiter / der Bearbeiterin dieser Aufgabe angeben


% Kopf- und Fußzeilen
\usepackage{scrlayer-scrpage, lastpage}
\setkomafont{pageheadfoot}{\large\textrm}
\lohead{\Aufgabe}
\rohead{Teilnahme-ID: \TeilnahmeId}
\cfoot*{\thepage{}/\pageref{LastPage}}

% Position des Titels
\usepackage{titling}
\setlength{\droptitle}{-1.0cm}

% Für mathematische Befehle und Symbole
\usepackage{amsmath}
\usepackage{amssymb}

% Für Bilder
\usepackage{graphicx}

% Für Algorithmen
\usepackage{algpseudocode}

% Für Quelltext
\usepackage{minted}
\usepackage{color}
\definecolor{mygreen}{rgb}{0,0.6,0}
\definecolor{mygray}{rgb}{0.5,0.5,0.5}
\definecolor{mymauve}{rgb}{0.58,0,0.82}

% Anführungszeichen
\usepackage{csquotes}

% Diese beiden Pakete müssen zuletzt geladen werden
%\usepackage{hyperref} % Anklickbare Links im Dokument
\usepackage{cleveref}

% Daten für die Titelseite
\title{\textbf{\Huge\Aufgabe}}
\author{\LARGE Teilnahme-ID: \LARGE \TeilnahmeId \\\\
	    \LARGE Bearbeiter/-in dieser Aufgabe: \\ 
	    \LARGE \Name\\\\}
\date{\LARGE\today}

\begin{document}

\maketitle
\tableofcontents

\vspace{0.5cm}

\section{Lösungsidee}
\subsection{Allgemeines}
Der Beweis, ob ein Rechenrätsel eindeutig lösbar ist, ist ein
Entscheidungsproblem mit NP-Schwere. Eine mögliche Lösung ist, eine interessante
Ziffernfolge zufällig zu wählen und alle möglichen Kombinationen von Operatoren
auszuprobieren. Kommt ein Ergebnis nur einmal vor, wurde ein eindeutig lösbares
Rätsel gefunden, was in der Regel der Fall sein sollte, ansonsten muss der
Vorgang mit anderen Ziffern wiederholt werden.

Theoretisch wäre es möglich, dass die Operanden immer
zufällig so gewählt werden, dass es kein interessantes und eindeutiges Rätsel
gibt und das Programm somit nie zu einem Ergebnis kommt. Allerdings läuft die
Wahrscheinlichkeit dafür gegen null.

Die beschriebene Brute-Force\footnote{Alle Möglichkeiten werden ausprobiert.}
Operation dauert allerdings bei zunehmender Anzahl der Operatoren exponentiell länger. Die Anzahl
der Möglichkeiten $|\Omega|$ kann in Abhängigkeit von der Operatorenanzahl $n$
berechnet werden: $|\Omega|=4^{n}$. Dabei gilt es zu beachten, dass dies der
Maximalwert ist, da die Division oft im Vorhinein ausgeschlossen werden kann,
weil diese eine nicht ganze Zahl ergibt. Das Programm sollte Rätsel mit mindestens 15
Operatoren erstellen können, da dies in der Aufgabenstellung als Richtwert
angegeben wird. Für $n=15$ gilt $|\Omega|=4^{15}=1073741824\approx10^{6}$. So
viele Möglichkeiten können noch mit einer guten Laufzeit berechnet werden.

\subsection{Die Null als Operand?}

Nach Aufgabenstellung ist jeder Operand nur eine Ziffer. Bei den gegebenen
Beispielen kommt jede Ziffer vor außer der Null, allerdings wird auch nicht
ausdrücklich gesagt, dass man sie nicht verwenden darf. Die Addition und
Subtraktion einer Null kann in einem Rätsel nicht verwendet werden, da beide
Operationen das gleiche Ergebnis haben und das Rätsel damit uneindeutig wäre. Da
die Division durch Null nicht definiert ist, bleibt nur noch die Multiplikation
übrig. Es ergibt jedoch wenig Sinn ein Rätsel zu stellen, wo bereits zu Beginn
ein Teil der Lösung bekannt ist. Dies gilt insbesondere, da die Rätsel nach
Aufgabenstellung \enquote{richtig schwer} sein sollen. Also wird die Null in
meiner Lösung nicht als Operand benutzt.

\subsection{Interessante Rätsel}
Die Aufgabenstellung gibt nicht genau vor, wie ein Rätsel, das \enquote{interessant und
unterschiedlich} ist, zu sein hat. Allerdings wird ein Beispiel gegeben, wie ein
Rätsel aussehen kann. Das Beispielrätsel habe ich mit einer leicht modifizierten
Version meines Programms lösen lassen:
\begin{minted}{text}
Rätsel: 4 ○ 3 ○ 2 ○ 6 ○ 3 ○ 9 ○ 7 ○ 8 ○ 2 ○ 9 ○ 4 ○ 4 ○ 6 ○ 4 ○ 4 ○ 5 = 4792
Lösung: 4 * 3 * 2 * 6 * 3 * 9 + 7 * 8 : 2 * 9 * 4 - 4 * 6 - 4 * 4 * 5 = 4792
\end{minted}
Es fällt auf das jeder Operator mindestens einmal vorkommt, wobei die
Multiplikation überwiegt. Außerdem ist das Ergebnis noch relativ klein im
Vergleich zu anderen eindeutig lösbaren Rätseln, wie ich beim Vergleich mit der
ungefilterten Ausgabe meines Programms festgestellt habe. Zudem kommen einige
verschiedene Ziffern vor. Meine Regeln für ein interessantes Rätsel sind noch
etwas strenger, da in dem Beispiel schon recht oft die Multiplikation vertreten
ist. Diese lauten wie folgt:
\begin{enumerate}
	\item Sei $n$ die Anzahl der Operatoren und $m_i$, die Anzahl, mit der
		der jeweilige Operator vorkommt. Dann soll gelten:
		\begin{align}
			\frac{n}{10} - 1 < m_i \leq \frac{n}{2} + 1
		\end{align}
		Die Division ist oft nicht möglich, da das Ergebnis keine ganze
		Zahl ist. Deshalb muss die Untergrenze relativ klein sein, damit
		für die Division die Bedingung noch erfüllt werden kann. Die
		Formel wurde so gewählt, dass bei Rätsel mit zwei Operatoren
		noch zweimal derselbe Operator gewählt werden darf. Allerdings
		finde ich es bei Rätseln mit drei Operatoren nicht interessant,
		jedes Mal denselben Operator zu haben. Darum habe ich die Formel
		so gewählt, dass in diesem Fall die Obergrenze nicht erfüllt
		ist.
	\item Sei $n$ die Anzahl der Ziffern und $m_i$, die Anzahl mit der die
		jeweilige Ziffer vorkommt. Dann soll gelten:
		\begin{align}
			\frac{n}{18} - 1 < m_i \leq \frac{2}{9} \cdot n + 1
		\end{align}
		Für diese Untergrenze habe ich mich entschieden, damit, wenn
		durchschnittlich jede Ziffer der neun Ziffern zweimal vorkommen sollte,
		mindestens eine vorhanden ist. Aus einem ähnlichen Grund habe
		ich auch die Obergrenze so gewählt, dass $\lim_{n \to \infty}
		\frac{2}{9} \cdot n + 1 = \lim_{n \to \infty} \frac{2}{9} \cdot n$
\end{enumerate}
In der Regel werden viele interessante Rätsel gefunden. Da das Beispielrätsel
ein kleines Ergebnis hat und kleinere Ergebnisse auch eleganter sind, wird
von allen interessanten Rätseln, das mit dem kleinsten Ergebnis ausgewählt.

\section{Umsetzung}
\subsection{Umgebung und Bibliotheken}
Die Lösungsidee wird in Rust nightly implementiert, da Trait Aliase noch nicht
in Rust stable sind. Jeder Typ, der ein Trait implementiert, muss bestimmte
Methoden haben. Traits sind daher für Generics essenziell. Trait Aliase machen es
nun möglich für mehrere Traits einen Alias zu erstellen, was Schreibarbeit
spart. Außerdem werden einige crates, also Abhängigkeiten in Rust, verwendet:
\begin{itemize}
	\item Mit rand werden zufällige Ziffern als Operanden erstellt.
	\item Mit clap werden die Kommandozeilenargumente verarbeitet.
	\item Zudem werden noch einige crates des rust-num Teams genutzt.
		Dabei wird nicht das meta-crate num verwendet, sondern die
		sub-crates werden einzeln verwendet, um die Abhängigkeiten
		kleinzuhalten. num-traits ist dabei u. a. für die Konvertierung
		eines bestimmten Integer-Typs zu einen generischen Integer-Typ
		zuständig. num-derive stellt Macros zur Verfügung, die es
		erlauben Integers zu Enums zu konvertieren. Mit num-integer
		können arithmetischen Operationen generisch für verschiedene
		Integer-Typen implementiert werden.
\end{itemize}

\subsection{Benutzung}
Mit der Option -c kann die Anzahl der Operatoren angegeben werden. Der
Standartwert ist 5. Allerdings können maximal Rätsel mit 32 Operatoren berechnet
werden, da die verwendeten Operatoren eines Rätsels in 64 Bit Integers
gespeichert werden. Da es vier Grundrechenarten gibt brauchen wir für jeden
Operator 2 Bits, um diesen darzustellen. Da $64/2=32$ können also maximal 32
Operatoren verwendet werden. Mit dem flag -s kann man die Ausgabe der Lösung zu dem
Rätsel einschalten. Schließlich können optional mit -d die Operanden angegeben werden, z.
B. : \mintinline{text}|-d={1,4,5,8}|. Dies ist sehr nützlich zu Testzwecken. Wenn man die
Operanden nicht angibt, werden automatisch interessante gewählt.

\subsection{Implementierungsart}

In der main-Funktion befindet sich direkt eine while-Schleife, die solange läuft
bis ein interessantes Rätsel gefunden wurde. In der Regel wird die Schleife nur einmal
durchlaufen, weil sich für die erste ausgewählte Operandenkombination normalerweise
auch ein interessantes und eindeutiges Rätsel ergibt.

Wenn der Nutzer keine
Operanden angibt, werden diese zufällig ausgewählt. Dabei befinden sich die
Ziffern in einem Vector\footnote{Implementierung von Arrays mit
dynamischer Größe aus Rusts Standartbibliothek} und werden daraus
zufällig gewählt. Damit die minimale und maximale Anzahl aller Ziffern
garantiert werden kann, sodass das Rätsel interessant ist, werden in Laufe der
Auswahl Ziffern aus dem Vector entfernt.

Danach wird die Funktion \mintinline{rs}|calc_results| mit diesen Operanden
aufgerufen. Diese kann durch Generics alle Integertypen für die
(Zwischen)ergebnisse verwenden. Das größte Ergebnis für die Operanden wird
berechnet, indem sie alle miteinander multipliziert werden. Wenn dieses zu groß
ist für 64 Bit Integers, werden 128 Bit Integers verwendet, ansonsten 64 Bit
Integers. Dafür habe ich mich entschieden, da mit 64 Bit Rechnern schneller mit
64 Bit Integers gerechnet werden kann. Jedoch kann man trotzdem Rätsel berechnen,
die 128 Bit Integers erfordern.

Innerhalb der Funktion \mintinline{rs}|calc_results| gibt es eine for-Schleife,
die über alle Möglichkeiten, Operanden mit Punkt- bzw. Strichrechnung zu wählen,
iteriert. Dabei wird die Variablen \mintinline{rs}|dm_as_map| nach jedem
Durchlauf um eins erhöht. Jedes Bit der Variable steht dabei für Punkt- oder
Strichrechnung, wobei das least significant Bit für den Operatoren ganz links
steht.

In der Schleife wird die Funktion \mintinline{rs}|multiplicate_divide| mit einer Sequenz von
Operanden, zwischen denen nur Punktrechnung vorkommt, aufgerufen. Diese ruft
sich selber doppelt rekursiv auf, wobei einmal multipliziert und einmal
dividiert wird. Die Division wird ausgelassen, wenn das Zwischenergebnis keine
ganze Zahl ist. Wenn das Ende der Sequenz erreicht ist, werden die verwendeten
Operatoren in einer Hashmap mit dem Zwischenergebnis als Schüssel abgespeichert.
Wenn das Zwischenergebnis bereits einmal vorkam, wird unter dem Ergebnis
\mintinline{rs}|None| abspeichert und das Zwischenergebnis somit als uneindeutig
markiert. Die Hashmaps mit den möglichen Zwischenergebnissen werden zusammen in
einem Vector \mintinline{rs}|results_multiplicate| gespeichert. Zusätzlich
werden die Operanden, die nicht Teil einer Punktrechnungssequenz sind, einfach
in den Vector übernommen, indem eine Hashmap mit nur einem möglichen
Zwischenergebnis erstellt wird.

In der rekursiven Funktion \mintinline{rs}|add_sub| wird mit einer for-Schleife
über alle möglichen Zwischenergebnisse iteriert. Innerhalb der Schleife ruft
sich die Funktion pro Durchlauf zweimal auf, wobei einmal addiert und einmal
subtrahiert wird. Dies passiert solange, bis die letzte Hashmap mit möglichen
Ergebnissen erreicht wurde. Dann wird das Ergebnis mit den verwendeten
Operatoren mithilfe der Struktur \mintinline{rs}|ResultStore| gespeichert, wobei
es auch passieren kann, dass das Ergebnis direkt als uneindeutig markiert wird, da
schon eines der Zwischenergebnisse uneindeutig war.

Die Struktur \mintinline{rs}|ResultStore| besteht aus einer Hashmap mit den
Operatoren als Wert und den dazugehörigen Ergebnissen als Schüssel. Außerdem hat
sie noch ein weiters Attribut, ein Hashset, mit den Ergebnissen für die das
Rätsel uneindeutig ist. Die Methode \mintinline{rs}|store| hat als Parameter
das Ergebnis und eine Option von Operatoren. Wenn die Option
\mintinline{rs}|None| ist, wird das Ergebnis in das Hashset der uneindeutigen
Ergebnisse aufgenommen. Wenn das Ergebnis weder in der Hashmap noch in dem
Hashset ist, wird das Rätsel in der Hashmap gespeichert. Wenn es bereits in der
Hashmap ist, wird es als uneindeutig im Hashset gespeichert.

Schließlich wird über alle Schlüssel-Werte-Paare der Hashmap einer Instanz der
\mintinline{rs}|ResultStore| Struktur iteriert. Es wird gezählt wie oft welche
Operatoren verwendet wurden und überprüft, ob die Anzahl innerhalb des Bereiches
liegt, in dem das Rätsel als interessant befunden wird. Von allen interessanten
und uneindeutigen Rätseln wird bestimmt, welches das kleinste Ergebnis hat, und
dieses wird ausgegeben. Wenn kein interessantes Rätsel gefunden wurde, muss die
while-Schleife der main-Funktion noch einmal durchlaufen werden.

\section{Beispiele}
Im Ordner \enquote{ergebnisdateien} findet man die Beispielausgaben nummeriert
nach der Operatorenanzahl.

\input{|./ergebnis-latex.sh}

\section{Quellcode}
\begin{minted}[breaklines,fontsize=\footnotesize]{rs}
#![feature(trait_alias)] // aktiviert Trait Aliase

// Importe
use clap::Parser;
use std::collections::{HashSet, HashMap};
use rand::distributions::{Distribution, Uniform};
use num_derive::FromPrimitive;
use num_traits::FromPrimitive;
use num_integer::Integer;
use std::hash::Hash;
use std::fmt::Display;
use num_traits::bounds::Bounded;

// definiert einen Trait Alias, da diese Traits öfter gemeinsam benötigt werden
trait BasicInteger = Integer + Hash + Copy;

// Enum für die vier Grundoperatoren
#[derive(FromPrimitive)] // Durch FromPrimitive können ganze Zahlen zu Enums konvertiert werden.
enum Operator {
    Add,
    Subtract,
    Multiplicate,
    Divide,
}

// Enum für Punkt- oder Strichrechnung
#[derive(FromPrimitive, PartialEq, Clone, Copy)]
enum AddSubOrMultiplicateDivide {
    AddSub,
    MultiplicateDivide,
}

// Struktur für die Kommandozeilenargumente
#[derive(Parser)]
struct Args {
    /// Anzahl der Operatoren
    #[clap(short, long, default_value_t = 5)]
    count: u8,

    /// zeigt die Lösung an
    #[clap(short, long)]
    solution_print: bool,

    /// nutzt vorgegebene Ziffern zur Erstellung des Rätsels (für reproduzierbare Testfälle)
    #[clap(short, long)]
    digits: Vec<u8>,
}

struct PartOperation<T> {

    // mögliche Zwischenergebnisse eines Teils der Rechnung, der nur Punktrechnung enthält.
    results: HashMap<T, Option<u64>>,
    last_operator: Option<usize>, // der Operator, der vor dieser Rechnungsteil steht
}

// Struktur, die eindeutige Ergebnisse speichert
struct ResultStore<T> {
    riddles: HashMap<T, u64>, // speichert eindeutige Rätsel

    // speichert Ergebnisse, für die es bereits mehrere Operatorenkombinationen gibt
    results_already_taken: HashSet<T>,
}

impl<T: Eq + Hash> ResultStore<T> {

    // erstellt einen neuen, leere ResultStore
    fn new() -> Self {
        Self {
            riddles: HashMap::new(),
            results_already_taken: HashSet::new(),
        }
    }

    /* Methode, zum Speichern eines neuen Ergebnisses.
     * Ist der Parameter operators == None, so ist das Ergebnis uneindeutig. */
    fn store(&mut self, result: T, operators: Option<u64>) {

        // Wenn das Ergebnis bereits uneindeutig ist, wird nichts gemacht.
        if self.results_already_taken.contains(&result) {return;}

        // Wenn es das Ergebnis bereits gibt, ...
        if match operators {
            None => true,
            Some(_x) => self.riddles.contains_key(&result),
        } {
            // ... dann wird es von den eindeutigen Rätseln entfernt ...
            self.riddles.remove(&result);
            self.results_already_taken.insert(result); // ... und zu den uneindeutigen hinzugefügt.
        }
        // Ist es eindeutig, wird zu den eindeutigen hinzugefügt.
        else {self.riddles.insert(result, operators.unwrap());}
    }
}


fn main() {
    // Methode des crates clap, die die Kommandozeilenargumente einliest.
    let args = Args::parse();

    /* Rätsel für größere Operatorenanzahlen können nicht berechnet werden, da die verwendeten
     * Operatoren als u64 gespeichert werden müssen und für jeden Operator zwei Bits benötigt
     * werden. Natürlich ist die praktische Grenze laufzeitbedingt schon vorher erreicht. */
    if args.count > 32 {
        println!("Es können maximal Rätsel mit 32 Operatoren erstellt werden.");
        return;
    }
    let mut continue_searching = true;
    let mut digits = args.digits;

    // Wenn keine Ziffern bzw. Operanden vorgegeben wurden, werden diese zufällig ausgewählt.
    let random_digits = digits.is_empty();
    while continue_searching {
        if random_digits {
            digits = vec!(0; (args.count + 1) as usize); // erstellt einen neuen Vektor für die Ziffern

            /* die Ziffern, die noch zur Auswahl stehen. Dabei steht jedes Element des Vektors für
             * die Ziffer, die um eins größer ist. */
            let mut selectable_digits: Vec<u8> = Vec::from_iter(0..9);
            let mut digits_count: [u8; 9] = [0; 9]; // Counter wie oft die jeweiligen Ziffern vorkommen
            let min: u8 = digits.len() as u8 / 18; // minmale Anzahl der jeweiligen Ziffern
            let max: u8 = digits.len() as u8 * 2 / 9 + 1; // maximale Anzahl

            /* Anzahl der Operanden, die verwendet werden können ohne, dass dadurch der Erfüllung
             * der minimalen Anzahl der Ziffern nähergekommen wird. */
            let mut left_for_non_min: u8 = digits.len() as u8 - 9 * min;

            /* die Ziffern, die bereits in der minimalen Anzahl vorhanden sind.
             * Es sei denn die minimale Anzahl ist Null, dann ist das Hashset leer. */
            let mut digits_min_statisfied: HashSet<u8> = HashSet::with_capacity(9);
            for digit in digits.iter_mut() {

                // Eine zufällige Ziffer wird aus den übrig bleibenden ausgewählt.
                let rand_i = Uniform::new(0, selectable_digits.len()).sample(&mut rand::thread_rng());
                let rand_number = selectable_digits[rand_i];

                digits_count[rand_number as usize] += 1; // erhöht den Zifferncounter
                let digit_used = digits_count[rand_number as usize];
                if digit_used == min {
                    if left_for_non_min == 0 { // Wenn keine Operanden frei sind, ...
                        selectable_digits.remove(rand_i); // ... wird die Ziffer aus den ausgewählbaren entfernt.
                    } else {digits_min_statisfied.insert(rand_number);}
                }
                if digit_used > min { // wird die Ziffern öfter als notwendig verwendet
                    left_for_non_min -= 1;

                    /* Wenn die restlichen Operanden gebraucht werden, um die minimale Anzahl der
                     * übrigen Ziffern zu erfüllen, werden die Ziffern die bereits genug vorkommen,
                     * aus den auswählbaren entfernt. */
                    if left_for_non_min == 0 {
                        selectable_digits.retain(|x| !digits_min_statisfied.contains(x));
                    }
                }
                // Kommt eine Ziffer oft genug vor, wird diese aus den auswählbaren entfernt.
                if digit_used == max {selectable_digits.remove(rand_i);}

                /* weist die zufällig ausgewählte Ziffer zu. Diese wird zuvor noch um eins erhöht,
                 * da die Zufallszahl im Bereich von null bis acht liegt. */
                *digit = rand_number + 1;
            }
        }
        // berechnet das maximale Ergebnis durch die Multiplikation aller Operanden
        let mut max_result: u128 = 1;
        for digit in &digits {
            max_result *= *digit as u128;
        }
        /* nutzt 64 Bit Integers wenn möglich und 128 Bit Integers das maximale Ergebnis zu groß für
         * 64 Bit Integers ist. */
        continue_searching = if max_result <= i64::MAX as u128 {
            calc_results::<i64>(args.solution_print, &digits)
        } else {calc_results::<i128>(args.solution_print, &digits)};

        // Wenn die Ziffern vom Nutzer festgelegt sind, wird es nicht nochmal mit anderen versucht.
        if !random_digits {break;}
    }
}

/* Funktion, die eindeutige Rätsel mit den vorgegebenen Operanden berechnet und eins davon ausgibt.
 * Dabei kann der Integer-Typ der für die (Zwischen)ergebnisse verwendet mit Generics angegeben werden. */
fn calc_results<T: BasicInteger + 'static + FromPrimitive + Display + Bounded>
(solution_print: bool, digits: &[u8]) -> bool {
    let number_operators = digits.len() - 1;
    let mut results = ResultStore::new(); // Hier werden die Rätsel gespeichert.

    // Bei dm_as_map steht jedes Bit für Punkt- oder Strichrechnung.
    for dm_as_map in 0..2u32.pow(number_operators as u32) {

        // enthält die Zwischenergebnisse mit bereits durchgeführter Punktrechnung
        let mut results_multiplicate: Vec<PartOperation<T>> = Vec::new();
        {
            let mut last_i: usize = 0;
            let mut i: usize;
            let mut state = AddSubOrMultiplicateDivide::from_u32(dm_as_map & 1).unwrap();
            while last_i < number_operators {
                i = last_i;

                // bestimmt das Ende einer Sequenz, die nur aus Punkt- oder Strichrechnung besteht
                while i < number_operators && dm_as_map >> i & 1 == state as u32 {

                    /* In einer Strichrechnungssequenz können die Operanden direkt als
                     * Zwischenergebnisse verwendet werden. */
                    if state == AddSubOrMultiplicateDivide::AddSub {
                        results_multiplicate.push(insert_digit(digits, i));
                    }
                    i += 1;
                }
                if state == AddSubOrMultiplicateDivide::MultiplicateDivide {

                    // speichert die Ergebnisse einer Punktrechnungssequenz
                    let mut part_results: HashMap<T, Option<u64>> = HashMap::new();
                    i += 1;
                    let mut digits_calc = digits[last_i .. i].iter(); // Slice mit den Operanden der Sequenz

                    // der erste Operand der Sequenz
                    let first_digit = T::from_u8(*digits_calc.next().unwrap()).unwrap();
                    
                    // berechnet die Zwischenergebnisse
                    multiplicate_divide(digits_calc, &mut part_results, last_i as u8 * 2, first_digit, 0);

                    // speichert die Zwischenergebnisse
                    results_multiplicate.push(PartOperation{
                        results: part_results,
                        last_operator: last_operator_helper(last_i),
                    });
                }
                /* Nachdem eine Punkt- oder Strichrechnungssequenz fertig, ist kommt eine Sequenz
                 * der anderen Rechenart. */
                state = match state {
                    AddSubOrMultiplicateDivide::MultiplicateDivide => AddSubOrMultiplicateDivide::AddSub,
                    AddSubOrMultiplicateDivide::AddSub => AddSubOrMultiplicateDivide::MultiplicateDivide,
                };
                last_i = i;
            }
            /* Wenn der letzte Operator eine Strichrechnung ist, muss der letzte Operand noch als
             * Zwischenergebnis hinzugefügt werden. */
            if dm_as_map >> number_operators - 1 & 1 == AddSubOrMultiplicateDivide::AddSub as u32 {
                results_multiplicate.push(insert_digit(digits, digits.len() - 1));
            }
            {
                // führt die Strichrechnung mit den Zwischenergebnissen durch
                let mut iter = results_multiplicate.iter();
                for (part_result, operators) in &iter.next().unwrap().results {
                    add_sub(iter.clone(), &mut results, *part_result, *operators);
                }
            }
        }
    }
    let mut best_riddle_operators: Option<u64> = None; // die Operatoren des endgültig ausgewählten Rätsel

    /* das Ergebnis des ausgewählten Rätsels. Zu Beginn wird der maximale Wert verwendet, damit die
     * Bedingung, dass das Ergebnis des Rätsels kleiner ist, in beim ersten Rätsel erfüllt ist. */
    let mut smallest_result = T::max_value();
    for (result, operators) in results.riddles {
        let mut operator_count: [u8; 4] = [0; 4]; // Anzahlen der Operatoren

        // zählt die Operatoren
        for i in 0..number_operators {
            operator_count[(operators as usize) >> 2 * i & 3] += 1;
        }

        /* überprüft, ob alle Operatorenanzahlen innerhalb eines Bereiches liegen und das Rätsel
         * somit interessant ist. */
        let mut interessing_riddle = true;
        for count in operator_count {
            interessing_riddle &= number_operators as u8 / 10 <= count && count <= number_operators as u8 / 2 + 1;
        }

        /* Ist das Rätsel interessant und das Ergebnis kleiner als das aktuelle Rätsel, dann wird
         * dieses als vorläufig bestes Rätsel gespeichert. */
        if interessing_riddle && result < smallest_result {
            smallest_result = result;
            best_riddle_operators = Some(operators);
        }
    }
    match best_riddle_operators {
        /* wurde kein Rätsel gefunden wird true zurückgeben und die Suche wird wiederholt, da der
         * Rückwert als Bedingung in der while-Schleife genutzt wird. */
        None => true,
        Some(operators) => {
	    // Wenn ein Rätsel gefunden wurde, wird es ausgegeben. (siehe Quelltext)
            false
        }
    }
}

/* rekursive Funktion, die Punktrechnung auf einer Sequenz der Operanden durchführt und die
 * Ergebnisse in einer Hashmap speichert. */
fn multiplicate_divide<'a, T: BasicInteger + FromPrimitive>
(mut iter: impl Clone + Iterator<Item = &'a u8>, results: &mut HashMap<T, Option<u64>>,
operator_index: u8, part_result: T, operators: u64) {
    match iter.next() {
        /* Wenn keine Ziffern mehr übrig sind, werden die Operatoren in einer Hashmap abspeichert.
         * Wenn das gleiche Zwischenergebnis bereits durch andere Operatoren erreicht wurde ist
         * dieses uneindeutig und None wird in der Hashmap gespeichert. */
        None => {
            results.insert(part_result, if results.contains_key(&part_result)
                           {None} else {Some(operators)});
        }
        Some(next) => {
            let next_digit = T::from_u8(*next).unwrap();

            // führt Multiplikation und Division durch
            for operator in [Operator::Multiplicate, Operator::Divide] {
                multiplicate_divide(iter.clone(), results, operator_index + 2,
                    match operator {
                        Operator::Multiplicate => part_result * next_digit,
                        Operator::Divide => {
                            /* Ist das Ergebnis der Division keine ganze Zahl, wird diese
                             * abgebrochen. */
                            if part_result \% next_digit != T::zero() {continue;}
                            part_result / next_digit
                        }
                        /* wird nie ausgeführt. Nur vorhanden, da bei einer match-Anweisung
                         * alle möglichen Werte abgedeckt werden müssen. */
                        _ => T::zero(), // Methode returned eine Null des Typs T
                    },
                    // verwendeter Operator wird in einer Bitmap gespeichert.
                    operators | (operator as u64) << operator_index);
            }
        }
    }
}

/* rekursive Funktion, die Strichrechnung auf einer Sequenz der Zwischenergebnisse durchführt und
 * die Ergebnisse mithilfe der Struktur ResultStore speichert. */
fn add_sub<'a, T: BasicInteger + 'static>
(mut iter: impl Clone + Iterator<Item = &'a PartOperation<T>>,
results: &mut ResultStore<T>, part_result: T, operators: Option<u64>) {
    match iter.next() {
        None => {
            // speichert das Rätsel, wenn das Ergebnis eine natürliche Zahl ist
            if part_result > T::zero() {results.store(part_result, operators);}
        }
        Some(next) => {
            // für jedes mögliche Zwischenergebnis ...
            for (next_result, part_operators) in &next.results {
                // ... wird Addition und Subtraktion durchführt.
                for operator in [Operator::Add, Operator::Subtract] {
                    add_sub(iter.clone(), results,
                        match operator {
                            Operator::Add => part_result + *next_result,
                            Operator::Subtract => part_result - *next_result,

                            /* wird nie ausgeführt. Nur vorhanden, da bei einer match-Anweisung
                             * alle möglichen Werte abgedeckt werden müssen. */
                            _ => T::zero(),
                        },
                        /* Wenn mindestens einer der beiden verrechneten Zwischenergebnisse
                         * uneindeutig ist, ist das resultierende Ergebnis auch uneindeutig. */
                        if operators == None || *part_operators == None {None}
                        else {
                            // Ansonsten werden die Teiloperatoren zusammengefasst gespeichert.
                            Some(operators.unwrap() | part_operators.unwrap() |
                                (operator as u64) << 2 * next.last_operator.unwrap())
                        }
                    );
                }
            }
        }
    }
}

// gibt den Operatorenindex vor dem entsprechenden Operandenindex zurück
fn last_operator_helper(index: usize) -> Option<usize> {
    if index == 0 {None} else {Some(index as usize - 1)}
}

// Hilfsfunktion, um eine einzelne Ziffer als Zwischenergebnis hinzufügen
fn insert_digit<T: Eq + Hash + FromPrimitive>(digits: &[u8], i: usize) -> PartOperation<T> {
    let mut result_map: HashMap<T, Option<u64>> = HashMap::new();

    // Some(0) heißt, dass keine Operatoren verwendet wurden
    result_map.insert(T::from_u8(digits[i]).unwrap(), Some(0));
    PartOperation{
        results: result_map,
        last_operator: last_operator_helper(i),
    }
}
\end{minted}

\end{document}
