$\textsf{wahr}$

\textsf{Berechne!}

$\textsf{Überprüfen}$

\textsf{\colorbox{ebe7f8}{Hinweis}}

$\textsf{Weiter geht's!}$

$\textsf{Neuer Versuch}$

$\textsf{Nochmal!}$

\textsf{\frac{     }{     }

\textsf{\vphantom{Äg}
Gemeinsam mit Sir Mathspooky bist du im 
\\vphantom{Äg}Labyrinth der prozentuellen Veränderungen\gefangen. 
\\\vphantom{Äg}Berechne die prozentuellen Vermehrungen\
und Verminderungen (ohne Faktoren)
\und bahne dir den Weg nach draußen.
\\\vphantom{Äg}\bold{Verwende den Vollbildmodus.}
\\Viel Erfolg!}

$\textsf{Los geht's!}$

$\textsf{\bold{↑}}$

$\textsf{\bold{↓}}$

$\textsf{\bold{←}}$

$\textsf{\bold{→}}$

$\textsf{Weiter}$

\textsf{
Verwende die am unteren Rand eingeblendeten Pfeiltasten, 
\um Sir Mathspooky durch das Labyrinth zu navigieren.

}

\textsf{Ein Tischtennisschläger hat ursprünglich 20 € gekostet.\Der Preis wurde auf 15 € reduziert.\vphantom{g}\
Berechne, um wie viel Prozent der Preis des Tischtennisschlägers\reduziert wurde.\\\\

Der Preis wurde um ~~~~~~~~~~ \% reduziert.

\textsf{Vicky misst jedes Jahr an ihrem Geburtstag ihre Körpergröße.\
Vor 2 Jahren war Vicky 140 cm groß.\Heute ist Vicky 154 cm groß.\
Berechne, um wie viel Prozent Vickys Körpergröße innerhalb\der letzten 2 Jahre angestiegen ist.\\\\

Vickys Körpergröße ist um ~~~~~~~~~~\% angestiegen.

\textsf{Eine Gitarre hat ursprünglich 290 € gekostet.\Der Preis wurde auf 348 € erhöht.\
Berechne, um wie viel Prozent der Preis der Gitarre erhöht wurde.\\\

Der Preis wurde um ~~~~~~~~~~\% erhöht.

\textsf{Ein ursprünglicher Grundwert G = 67 wird auf den vermehrten\Grundwert G^+ = 134 erhöht.\vphantom{g}
\Berechne, um wie viel Prozent der ursprüngliche Grundwert\erhöht wurde.\\\

Der ursprüngliche Grundwert wurde um ~~~~~~~~~\% erhöht.

\textsf{Ein ursprünglicher Grundwert G = 132 wird auf den\verminderten Grundwert G^{--} = 99 verringert.\
Berechne, um wie viel Prozent der ursprüngliche\Grundwert verringert wurde. \\\
Der ursprüngliche Grundwert wurde um ~~~~~~~~~~\% verringert.

\textsf{In Zamirs Sparschwein sind 80 €.\An Zamirs Geburtstag kommen noch 24 € hinzu.\Berechne, um wie viel Prozent Zamirs Ersparnisse\angestiegen sind. 
\\\
Zamirs Ersparnisse sind um ~~~~~~~~~\% angestiegen.

\textsf{Flo ist 160 cm groß. Selina ist 120 cm groß.\
Flo ist 25 \% größer als Selina.\\\
Kreuze die richtige Antwort an.\\

\textsf{Flo ist 160 cm groß. Selina ist 120 cm groß.\Selina ist 25 \% kleiner als Flo.\\\
Kreuze die richtige Antwort an.

\textsf{Nick ist 200 cm groß. Liv ist 160 cm groß.\Nick ist 25 \% größer als Liv.\\\
Kreuze die richtige Antwort an.

\textsf{Nick ist 200 cm groß. Liv ist 160 cm groß.\
Liv ist 25 \% kleiner als Nick.\\\
Kreuze die richtige Antwort an.

$\textsf{falsch}$

$\textsf{Weiter}$

\textsf{Lösung:\\

20 - 5 = 15\vphantom{g}\
Der Preis wurde um 5 € reduziert.\vphantom{g}\
Der ursprüngliche Preis (20 €) entspricht dem Grundwert.\vphantom{g}\
5 sind 1 Viertel von 20, d.h. 5 € sind \bold{25 \%} von 20 €. 

\textsf{Lösung:\\
154 - 140 = 14\vphantom{g}\
Vickys Körpergröße ist um 14 cm angestiegen.\vphantom{g}\
Vickys ursprüngliche Körpergröße (140 cm) entspricht dem\vphantom{g}\Grundwert.\vphantom{g}\
14 sind 1 Zehntel von 140, d.h. 14 cm sind \bold{10 \%} von 140 cm. 

\textsf{Lösung:\\
348 - 290 = 58\vphantom{g}\
Der Preis wurde um 58 € erhöht.\vphantom{g}\
Der ursprüngliche Preis (290 €) entspricht dem Grundwert. \vphantom{g}\

10 \% von 290 sind 29.\vphantom{g}\
58 sind 29 \cdot 2.\vphantom{g}\
D.h. 58 € sind \bold{20 \%} von 290 €. 

\textsf{Lösung:\\
134 - 67 = 67\vphantom{g}\
Der Grundwert wurde um 67 erhöht. \vphantom{g}\
Die Erhöhung ist gleich groß wie der Grundwert G. \vphantom{g}\
D.h. der ursprüngliche Grundwert wurde um \bold{100 \%} erhöht.

\textsf{Lösung:\\
132 - 99 = 33\vphantom{g}\
Der Grundwert wurde um 33 vermindert.\vphantom{g}\
33 sind 1 Viertel von 132, d.h. 33 sind \bold{25 \%} von 132.

\textsf{Lösung:\\
160 - 120 = 40\vphantom{g}\
Flo ist 40 cm größer als Selina. Selinas Körpergröße (140 cm)\vphantom{g}\
entspricht dem Grundwert.\vphantom{g}\
40 sind 1 Drittel von 120, d.h. 40 cm sind rund \bold{33,33 \%} von\vphantom{g}\120 cm.

\textsf{Lösung:\\

160 - 120 = 40\vphantom{g}\
Selina ist 40 cm kleiner als Flo.\vphantom{g}\
Flos Körpergröße (160 cm) entspricht dem Grundwert.\vphantom{g}\
40 sind 1 Viertel von 160, d.h. 40 cm sind \bold{25 \%} von 160 cm.

\textsf{Lösung:\\
Zamirs Ersparnisse sind um 24 € angestiegen.\vphantom{g}\

Der ursprüngliche Inhalt des Sparschweins\vphantom{g}\(80 €) entspricht dem Grundwert. \vphantom{g}\
10 \% von 80 sind 8.\vphantom{g}\24 sind 8 \cdot 3.\vphantom{g}\D.h. 24 € sind \bold{30 \%} von 80 €.

\textsf{Lösung:\\
200 - 160 = 40\vphantom{g}\
Nick ist 40 cm größer als Liv.\vphantom{g}\
Livs Körpergröße (160 cm) entspricht dem Grundwert.\vphantom{g}\
40 sind 1 Viertel von 160, d.h. 40 cm sind \bold{25 \%} von 160 cm.

\textsf{Lösung:\\
200 - 160 = 40\vphantom{g}\
Liv ist 40 cm kleiner als Nick. \vphantom{g}\
Nicks Körpergröße (200 cm) entspricht dem Grundwert.\vphantom{g}\
10 \% von 200 sind 20.\vphantom{g}\40 sind 20 \cdot 2.\vphantom{g}\
D.h. 40 cm sind \bold{20 \%} von 200 cm.

questionCount = 0
randomNumbers = Shuffle(Sequence[10])
listSol2: {true, true, true, true, true, true, false, true, true, false}
inputtrue = false
studentAnswer01 = NaN
randomNumber = Element(randomNumbers, Mod[questionCount, Length[randomNumbers]] + 1)
listSol: {25, 10, 20, 100, 25, 30, 1, 1, 1, 1}
allSolutionsCalculated: {9 / 4, 2 / 8, 26 / 7, 6, 16 / 6, 3 / 4, 8 / 5, 14 / 8, 14 / 4, 3}
expectedSolutionValue = Element(allSolutionsCalculated, randomNumber)
studentAnswer02 = NaN
studentAnswer03 = NaN
allSolutionsSplitted: {{2, 1, 4}, {0, 1, 4}, {3, 5, 7}, {6, 0, 0}, {2, 2, 3}, {0, 3, 4}, {1, 3, 5}, {1, 3, 4}, {3, 1, 2}, {3, 0, 0}}
expectedSolutionGanze = Element(Element[allSolutionsSplitted, randomNumber], 1)
expectedSolutionNenner = Element(Element[allSolutionsSplitted, randomNumber], 3)
expectedSolutionZaehler = Element(Element[allSolutionsSplitted, randomNumber], 2)
needGanze: expectedSolutionGanze ≠ 0 ∨ expectedSolutionGanze ≟ 0 ∧ expectedSolutionZaehler ≟ 0
correctGanze: needGanze ∧ expectedSolutionGanze ≟ studentAnswer01
needBruch: expectedSolutionZaehler ≠ 0
correctNichtGekurzt: If[needGanze ∧ needBruch, studentAnswer01 + studentAnswer02 / studentAnswer03, needGanze, studentAnswer01, needBruch, studentAnswer02 / studentAnswer03] ≟ expectedSolutionValue
correctBruch: needBruch ∧ expectedSolutionZaehler / expectedSolutionNenner ≟ studentAnswer02 / studentAnswer03
start: (0, 0)
sizeWaagrecht: (0.5, 0)
sizeSenkrecht: (0, 0.5)
labyrinthW04: {Segment[start + (sizeWaagrecht * 2) + (sizeSenkrecht * 19), start + (sizeWaagrecht * 8) + (sizeSenkrecht * 19)], Segment[start + (sizeWaagrecht * 10) + (sizeSenkrecht * 19), start + (sizeWaagrecht * 11) + (sizeSenkrecht * 19)], Segment[start + (sizeWaagrecht * 12) + (sizeSenkrecht * 19), start + (sizeWaagrecht * 16) + (sizeSenkrecht * 19)], Segment[start + (sizeWaagrecht * 20) + (sizeSenkrecht * 19), start + (sizeWaagrecht * 23) + (sizeSenkrecht * 19)], Segment[start + (sizeWaagrecht * 2) + (sizeSenkrecht * 20), start + (sizeWaagrecht * 11) + (sizeSenkrecht * 20)], Segment[start + (sizeWaagrecht * 12) + (sizeSenkrecht * 20), start + (sizeWaagrecht * 17) + (sizeSenkrecht * 20)], Segment[start + (sizeWaagrecht * 18) + (sizeSenkrecht * 20), start + (sizeWaagrecht * 22) + (sizeSenkrecht * 20)], Segment[start + (sizeWaagrecht * 2) + (sizeSenkrecht * 21), start + (sizeWaagrecht * 6) + (sizeSenkrecht * 21)], Segment[start + (sizeWaagrecht * 8) + (sizeSenkrecht * 21), start + (sizeWaagrecht * 10) + (sizeSenkrecht * 21)], Segment[start + (sizeWaagrecht * 15) + (sizeSenkrecht * 21), start + (sizeWaagrecht * 16) + (sizeSenkrecht * 21)], Segment[start + (sizeWaagrecht * 19) + (sizeSenkrecht * 21), start + (sizeWaagrecht * 21) + (sizeSenkrecht * 21)], Segment[start + (sizeWaagrecht * 1) + (sizeSenkrecht * 22), start + (sizeWaagrecht * 3) + (sizeSenkrecht * 22)], Segment[start + (sizeWaagrecht * 4) + (sizeSenkrecht * 22), start + (sizeWaagrecht * 7) + (sizeSenkrecht * 22)], Segment[start + (sizeWaagrecht * 12) + (sizeSenkrecht * 22), start + (sizeWaagrecht * 13) + (sizeSenkrecht * 22)], Segment[start + (sizeWaagrecht * 17) + (sizeSenkrecht * 22), start + (sizeWaagrecht * 19) + (sizeSenkrecht * 22)], Segment[start + (sizeWaagrecht * 20) + (sizeSenkrecht * 22), start + (sizeWaagrecht * 22) + (sizeSenkrecht * 22)], Segment[start + (sizeWaagrecht * 0) + (sizeSenkrecht * 23), start + (sizeWaagrecht * 11) + (sizeSenkrecht * 23)], Segment[start + (sizeWaagrecht * 12) + (sizeSenkrecht * 23), start + (sizeWaagrecht * 23) + (sizeSenkrecht * 23)]}
labyrinthW03: {Segment[start + (sizeWaagrecht * 3) + (sizeSenkrecht * 12), start + (sizeWaagrecht * 6) + (sizeSenkrecht * 12)], Segment[start + (sizeWaagrecht * 10) + (sizeSenkrecht * 12), start + (sizeWaagrecht * 18) + (sizeSenkrecht * 12)], Segment[start + (sizeWaagrecht * 20) + (sizeSenkrecht * 12), start + (sizeWaagrecht * 22) + (sizeSenkrecht * 12)], Segment[start + (sizeWaagrecht * 2) + (sizeSenkrecht * 13), start + (sizeWaagrecht * 7) + (sizeSenkrecht * 13)], Segment[start + (sizeWaagrecht * 9) + (sizeSenkrecht * 13), start + (sizeWaagrecht * 10) + (sizeSenkrecht * 13)], Segment[start + (sizeWaagrecht * 11) + (sizeSenkrecht * 13), start + (sizeWaagrecht * 13) + (sizeSenkrecht * 13)], Segment[start + (sizeWaagrecht * 15) + (sizeSenkrecht * 13), start + (sizeWaagrecht * 16) + (sizeSenkrecht * 13)], Segment[start + (sizeWaagrecht * 17) + (sizeSenkrecht * 13), start + (sizeWaagrecht * 18) + (sizeSenkrecht * 13)], Segment[start + (sizeWaagrecht * 1) + (sizeSenkrecht * 14), start + (sizeWaagrecht * 4) + (sizeSenkrecht * 14)], Segment[start + (sizeWaagrecht * 5) + (sizeSenkrecht * 14), start + (sizeWaagrecht * 8) + (sizeSenkrecht * 14)], Segment[start + (sizeWaagrecht * 14) + (sizeSenkrecht * 14), start + (sizeWaagrecht * 15) + (sizeSenkrecht * 14)], Segment[start + (sizeWaagrecht * 0) + (sizeSenkrecht * 15), start + (sizeWaagrecht * 10) + (sizeSenkrecht * 15)], Segment[start + (sizeWaagrecht * 14) + (sizeSenkrecht * 15), start + (sizeWaagrecht * 15) + (sizeSenkrecht * 15)], Segment[start + (sizeWaagrecht * 22) + (sizeSenkrecht * 15), start + (sizeWaagrecht * 23) + (sizeSenkrecht * 15)], Segment[start + (sizeWaagrecht * 1) + (sizeSenkrecht * 16), start + (sizeWaagrecht * 2) + (sizeSenkrecht * 16)], Segment[start + (sizeWaagrecht * 6) + (sizeSenkrecht * 16), start + (sizeWaagrecht * 11) + (sizeSenkrecht * 16)], Segment[start + (sizeWaagrecht * 15) + (sizeSenkrecht * 16), start + (sizeWaagrecht * 16) + (sizeSenkrecht * 16)], Segment[start + (sizeWaagrecht * 18) + (sizeSenkrecht * 16), start + (sizeWaagrecht * 19) + (sizeSenkrecht * 16)], Segment[start + (sizeWaagrecht * 21) + (sizeSenkrecht * 16), start + (sizeWaagrecht * 22) + (sizeSenkrecht * 16)], Segment[start + (sizeWaagrecht * 2) + (sizeSenkrecht * 17), start + (sizeWaagrecht * 3) + (sizeSenkrecht * 17)], Segment[start + (sizeWaagrecht * 4) + (sizeSenkrecht * 17), start + (sizeWaagrecht * 8) + (sizeSenkrecht * 17)], Segment[start + (sizeWaagrecht * 9) + (sizeSenkrecht * 17), start + (sizeWaagrecht * 14) + (sizeSenkrecht * 17)], Segment[start + (sizeWaagrecht * 22) + (sizeSenkrecht * 17), start + (sizeWaagrecht * 23) + (sizeSenkrecht * 17)], Segment[start + (sizeWaagrecht * 8) + (sizeSenkrecht * 18), start + (sizeWaagrecht * 9) + (sizeSenkrecht * 18)], Segment[start + (sizeWaagrecht * 10) + (sizeSenkrecht * 18), start + (sizeWaagrecht * 12) + (sizeSenkrecht * 18)], Segment[start + (sizeWaagrecht * 13) + (sizeSenkrecht * 18), start + (sizeWaagrecht * 15) + (sizeSenkrecht * 18)], Segment[start + (sizeWaagrecht * 21) + (sizeSenkrecht * 18), start + (sizeWaagrecht * 22) + (sizeSenkrecht * 18)]}
labyrinthW01: {Segment[start + (sizeWaagrecht * 1) + (sizeSenkrecht * 0), start + (sizeWaagrecht * 23) + (sizeSenkrecht * 0)], Segment[start + (sizeWaagrecht * 1) + (sizeSenkrecht * 1), start + (sizeWaagrecht * 4) + (sizeSenkrecht * 1)], Segment[start + (sizeWaagrecht * 5) + (sizeSenkrecht * 1), start + (sizeWaagrecht * 6) + (sizeSenkrecht * 1)], Segment[start + (sizeWaagrecht * 8) + (sizeSenkrecht * 1), start + (sizeWaagrecht * 9) + (sizeSenkrecht * 1)], Segment[start + (sizeWaagrecht * 11) + (sizeSenkrecht * 1), start + (sizeWaagrecht * 19) + (sizeSenkrecht * 1)], Segment[start + (sizeWaagrecht * 20) + (sizeSenkrecht * 1), start + (sizeWaagrecht * 22) + (sizeSenkrecht * 1)], Segment[start + (sizeWaagrecht * 2) + (sizeSenkrecht * 2), start + (sizeWaagrecht * 9) + (sizeSenkrecht * 2)], Segment[start + (sizeWaagrecht * 11) + (sizeSenkrecht * 2), start + (sizeWaagrecht * 13) + (sizeSenkrecht * 2)], Segment[start + (sizeWaagrecht * 14) + (sizeSenkrecht * 2), start + (sizeWaagrecht * 19) + (sizeSenkrecht * 2)], Segment[start + (sizeWaagrecht * 22) + (sizeSenkrecht * 2), start + (sizeWaagrecht * 23) + (sizeSenkrecht * 2)], Segment[start + (sizeWaagrecht * 3) + (sizeSenkrecht * 3), start + (sizeWaagrecht * 4) + (sizeSenkrecht * 3)], Segment[start + (sizeWaagrecht * 6) + (sizeSenkrecht * 3), start + (sizeWaagrecht * 12) + (sizeSenkrecht * 3)], Segment[start + (sizeWaagrecht * 14) + (sizeSenkrecht * 3), start + (sizeWaagrecht * 16) + (sizeSenkrecht * 3)], Segment[start + (sizeWaagrecht * 17) + (sizeSenkrecht * 3), start + (sizeWaagrecht * 18) + (sizeSenkrecht * 3)], Segment[start + (sizeWaagrecht * 21) + (sizeSenkrecht * 3), start + (sizeWaagrecht * 22) + (sizeSenkrecht * 3)], Segment[start + (sizeWaagrecht * 4) + (sizeSenkrecht * 4), start + (sizeWaagrecht * 10) + (sizeSenkrecht * 4)], Segment[start + (sizeWaagrecht * 14) + (sizeSenkrecht * 4), start + (sizeWaagrecht * 16) + (sizeSenkrecht * 4)], Segment[start + (sizeWaagrecht * 18) + (sizeSenkrecht * 4), start + (sizeWaagrecht * 19) + (sizeSenkrecht * 4)], Segment[start + (sizeWaagrecht * 20) + (sizeSenkrecht * 4), start + (sizeWaagrecht * 22) + (sizeSenkrecht * 4)], Segment[start + (sizeWaagrecht * 3) + (sizeSenkrecht * 5), start + (sizeWaagrecht * 4) + (sizeSenkrecht * 5)], Segment[start + (sizeWaagrecht * 7) + (sizeSenkrecht * 5), start + (sizeWaagrecht * 10) + (sizeSenkrecht * 5)], Segment[start + (sizeWaagrecht * 13) + (sizeSenkrecht * 5), start + (sizeWaagrecht * 15) + (sizeSenkrecht * 5)], Segment[start + (sizeWaagrecht * 16) + (sizeSenkrecht * 5), start + (sizeWaagrecht * 21) + (sizeSenkrecht * 5)]}
labyrinthW02: {Segment[start + (sizeWaagrecht * 2) + (sizeSenkrecht * 6), start + (sizeWaagrecht * 3) + (sizeSenkrecht * 6)], Segment[start + (sizeWaagrecht * 9) + (sizeSenkrecht * 6), start + (sizeWaagrecht * 10) + (sizeSenkrecht * 6)], Segment[start + (sizeWaagrecht * 15) + (sizeSenkrecht * 6), start + (sizeWaagrecht * 20) + (sizeSenkrecht * 6)], Segment[start + (sizeWaagrecht * 1) + (sizeSenkrecht * 7), start + (sizeWaagrecht * 4) + (sizeSenkrecht * 7)], Segment[start + (sizeWaagrecht * 8) + (sizeSenkrecht * 7), start + (sizeWaagrecht * 12) + (sizeSenkrecht * 7)], Segment[start + (sizeWaagrecht * 14) + (sizeSenkrecht * 7), start + (sizeWaagrecht * 17) + (sizeSenkrecht * 7)], Segment[start + (sizeWaagrecht * 1) + (sizeSenkrecht * 8), start + (sizeWaagrecht * 5) + (sizeSenkrecht * 8)], Segment[start + (sizeWaagrecht * 9) + (sizeSenkrecht * 8), start + (sizeWaagrecht * 11) + (sizeSenkrecht * 8)], Segment[start + (sizeWaagrecht * 15) + (sizeSenkrecht * 8), start + (sizeWaagrecht * 16) + (sizeSenkrecht * 8)], Segment[start + (sizeWaagrecht * 17) + (sizeSenkrecht * 8), start + (sizeWaagrecht * 20) + (sizeSenkrecht * 8)], Segment[start + (sizeWaagrecht * 2) + (sizeSenkrecht * 9), start + (sizeWaagrecht * 3) + (sizeSenkrecht * 9)], Segment[start + (sizeWaagrecht * 4) + (sizeSenkrecht * 9), start + (sizeWaagrecht * 5) + (sizeSenkrecht * 9)], Segment[start + (sizeWaagrecht * 12) + (sizeSenkrecht * 9), start + (sizeWaagrecht * 15) + (sizeSenkrecht * 9)], Segment[start + (sizeWaagrecht * 16) + (sizeSenkrecht * 9), start + (sizeWaagrecht * 17) + (sizeSenkrecht * 9)], Segment[start + (sizeWaagrecht * 18) + (sizeSenkrecht * 9), start + (sizeWaagrecht * 22) + (sizeSenkrecht * 9)], Segment[start + (sizeWaagrecht * 0) + (sizeSenkrecht * 10), start + (sizeWaagrecht * 1) + (sizeSenkrecht * 10)], Segment[start + (sizeWaagrecht * 3) + (sizeSenkrecht * 10), start + (sizeWaagrecht * 4) + (sizeSenkrecht * 10)], Segment[start + (sizeWaagrecht * 5) + (sizeSenkrecht * 10), start + (sizeWaagrecht * 6) + (sizeSenkrecht * 10)], Segment[start + (sizeWaagrecht * 10) + (sizeSenkrecht * 10), start + (sizeWaagrecht * 11) + (sizeSenkrecht * 10)], Segment[start + (sizeWaagrecht * 13) + (sizeSenkrecht * 10), start + (sizeWaagrecht * 16) + (sizeSenkrecht * 10)], Segment[start + (sizeWaagrecht * 17) + (sizeSenkrecht * 10), start + (sizeWaagrecht * 18) + (sizeSenkrecht * 10)], Segment[start + (sizeWaagrecht * 20) + (sizeSenkrecht * 10), start + (sizeWaagrecht * 21) + (sizeSenkrecht * 10)], Segment[start + (sizeWaagrecht * 1) + (sizeSenkrecht * 11), start + (sizeWaagrecht * 3) + (sizeSenkrecht * 11)], Segment[start + (sizeWaagrecht * 10) + (sizeSenkrecht * 11), start + (sizeWaagrecht * 15) + (sizeSenkrecht * 11)], Segment[start + (sizeWaagrecht * 16) + (sizeSenkrecht * 11), start + (sizeWaagrecht * 17) + (sizeSenkrecht * 11)], Segment[start + (sizeWaagrecht * 18) + (sizeSenkrecht * 11), start + (sizeWaagrecht * 19) + (sizeSenkrecht * 11)], Segment[start + (sizeWaagrecht * 21) + (sizeSenkrecht * 11), start + (sizeWaagrecht * 23) + (sizeSenkrecht * 11)]}
labyrinthWaagrecht = Flatten({labyrinthW01, labyrinthW02, labyrinthW03, labyrinthW04})
labyrinthS01: {Segment[start + (sizeWaagrecht * 0) + (sizeSenkrecht * 0), start + (sizeWaagrecht * 0) + (sizeSenkrecht * 23)], Segment[start + (sizeWaagrecht * 1) + (sizeSenkrecht * 0), start + (sizeWaagrecht * 1) + (sizeSenkrecht * 1)], Segment[start + (sizeWaagrecht * 1) + (sizeSenkrecht * 2), start + (sizeWaagrecht * 1) + (sizeSenkrecht * 7)], Segment[start + (sizeWaagrecht * 1) + (sizeSenkrecht * 8), start + (sizeWaagrecht * 1) + (sizeSenkrecht * 10)], Segment[start + (sizeWaagrecht * 1) + (sizeSenkrecht * 11), start + (sizeWaagrecht * 1) + (sizeSenkrecht * 14)], Segment[start + (sizeWaagrecht * 1) + (sizeSenkrecht * 17), start + (sizeWaagrecht * 1) + (sizeSenkrecht * 22)], Segment[start + (sizeWaagrecht * 2) + (sizeSenkrecht * 2), start + (sizeWaagrecht * 2) + (sizeSenkrecht * 6)], Segment[start + (sizeWaagrecht * 2) + (sizeSenkrecht * 9), start + (sizeWaagrecht * 2) + (sizeSenkrecht * 13)], Segment[start + (sizeWaagrecht * 2) + (sizeSenkrecht * 16), start + (sizeWaagrecht * 2) + (sizeSenkrecht * 21)], Segment[start + (sizeWaagrecht * 3) + (sizeSenkrecht * 3), start + (sizeWaagrecht * 3) + (sizeSenkrecht * 5)], Segment[start + (sizeWaagrecht * 3) + (sizeSenkrecht * 15), start + (sizeWaagrecht * 3) + (sizeSenkrecht * 16)], Segment[start + (sizeWaagrecht * 3) + (sizeSenkrecht * 17), start + (sizeWaagrecht * 3) + (sizeSenkrecht * 18)], Segment[start + (sizeWaagrecht * 3) + (sizeSenkrecht * 22), start + (sizeWaagrecht * 3) + (sizeSenkrecht * 23)], Segment[start + (sizeWaagrecht * 4) + (sizeSenkrecht * 4), start + (sizeWaagrecht * 4) + (sizeSenkrecht * 7)], Segment[start + (sizeWaagrecht * 4) + (sizeSenkrecht * 9), start + (sizeWaagrecht * 4) + (sizeSenkrecht * 12)], Segment[start + (sizeWaagrecht * 4) + (sizeSenkrecht * 16), start + (sizeWaagrecht * 4) + (sizeSenkrecht * 17)], Segment[start + (sizeWaagrecht * 4) + (sizeSenkrecht * 18), start + (sizeWaagrecht * 4) + (sizeSenkrecht * 19)], Segment[start + (sizeWaagrecht * 5) + (sizeSenkrecht * 2), start + (sizeWaagrecht * 5) + (sizeSenkrecht * 4)], Segment[start + (sizeWaagrecht * 5) + (sizeSenkrecht * 5), start + (sizeWaagrecht * 5) + (sizeSenkrecht * 9)], Segment[start + (sizeWaagrecht * 5) + (sizeSenkrecht * 10), start + (sizeWaagrecht * 5) + (sizeSenkrecht * 11)], Segment[start + (sizeWaagrecht * 5) + (sizeSenkrecht * 15), start + (sizeWaagrecht * 5) + (sizeSenkrecht * 18)], Segment[start + (sizeWaagrecht * 6) + (sizeSenkrecht * 0), start + (sizeWaagrecht * 6) + (sizeSenkrecht * 1)], Segment[start + (sizeWaagrecht * 6) + (sizeSenkrecht * 5), start + (sizeWaagrecht * 6) + (sizeSenkrecht * 12)], Segment[start + (sizeWaagrecht * 6) + (sizeSenkrecht * 18), start + (sizeWaagrecht * 6) + (sizeSenkrecht * 19)], Segment[start + (sizeWaagrecht * 7) + (sizeSenkrecht * 1), start + (sizeWaagrecht * 7) + (sizeSenkrecht * 2)], Segment[start + (sizeWaagrecht * 7) + (sizeSenkrecht * 4), start + (sizeWaagrecht * 7) + (sizeSenkrecht * 13)], Segment[start + (sizeWaagrecht * 7) + (sizeSenkrecht * 17), start + (sizeWaagrecht * 7) + (sizeSenkrecht * 18)], Segment[start + (sizeWaagrecht * 7) + (sizeSenkrecht * 20), start + (sizeWaagrecht * 7) + (sizeSenkrecht * 22)], Segment[start + (sizeWaagrecht * 8) + (sizeSenkrecht * 5), start + (sizeWaagrecht * 8) + (sizeSenkrecht * 14)], Segment[start + (sizeWaagrecht * 8) + (sizeSenkrecht * 16), start + (sizeWaagrecht * 8) + (sizeSenkrecht * 17)], Segment[start + (sizeWaagrecht * 8) + (sizeSenkrecht * 18), start + (sizeWaagrecht * 8) + (sizeSenkrecht * 19)], Segment[start + (sizeWaagrecht * 8) + (sizeSenkrecht * 21), start + (sizeWaagrecht * 8) + (sizeSenkrecht * 23)]}
labyrinthS02: {Segment[start + (sizeWaagrecht * 9) + (sizeSenkrecht * 1), start + (sizeWaagrecht * 9) + (sizeSenkrecht * 2)], Segment[start + (sizeWaagrecht * 9) + (sizeSenkrecht * 8), start + (sizeWaagrecht * 9) + (sizeSenkrecht * 14)], Segment[start + (sizeWaagrecht * 9) + (sizeSenkrecht * 17), start + (sizeWaagrecht * 9) + (sizeSenkrecht * 18)], Segment[start + (sizeWaagrecht * 9) + (sizeSenkrecht * 19), start + (sizeWaagrecht * 9) + (sizeSenkrecht * 20)], Segment[start + (sizeWaagrecht * 9) + (sizeSenkrecht * 22), start + (sizeWaagrecht * 9) + (sizeSenkrecht * 23)], Segment[start + (sizeWaagrecht * 10) + (sizeSenkrecht * 1), start + (sizeWaagrecht * 10) + (sizeSenkrecht * 3)], Segment[start + (sizeWaagrecht * 10) + (sizeSenkrecht * 5), start + (sizeWaagrecht * 10) + (sizeSenkrecht * 6)], Segment[start + (sizeWaagrecht * 10) + (sizeSenkrecht * 9), start + (sizeWaagrecht * 10) + (sizeSenkrecht * 10)], Segment[start + (sizeWaagrecht * 10) + (sizeSenkrecht * 11), start + (sizeWaagrecht * 10) + (sizeSenkrecht * 12)], Segment[start + (sizeWaagrecht * 10) + (sizeSenkrecht * 13), start + (sizeWaagrecht * 10) + (sizeSenkrecht * 15)], Segment[start + (sizeWaagrecht * 10) + (sizeSenkrecht * 22), start + (sizeWaagrecht * 10) + (sizeSenkrecht * 23)], Segment[start + (sizeWaagrecht * 11) + (sizeSenkrecht * 1), start + (sizeWaagrecht * 11) + (sizeSenkrecht * 2)], Segment[start + (sizeWaagrecht * 11) + (sizeSenkrecht * 3), start + (sizeWaagrecht * 11) + (sizeSenkrecht * 7)], Segment[start + (sizeWaagrecht * 11) + (sizeSenkrecht * 8), start + (sizeWaagrecht * 11) + (sizeSenkrecht * 10)], Segment[start + (sizeWaagrecht * 11) + (sizeSenkrecht * 13), start + (sizeWaagrecht * 11) + (sizeSenkrecht * 16)], Segment[start + (sizeWaagrecht * 11) + (sizeSenkrecht * 19), start + (sizeWaagrecht * 11) + (sizeSenkrecht * 23)], Segment[start + (sizeWaagrecht * 12) + (sizeSenkrecht * 3), start + (sizeWaagrecht * 12) + (sizeSenkrecht * 4)], Segment[start + (sizeWaagrecht * 12) + (sizeSenkrecht * 5), start + (sizeWaagrecht * 12) + (sizeSenkrecht * 11)], Segment[start + (sizeWaagrecht * 12) + (sizeSenkrecht * 14), start + (sizeWaagrecht * 12) + (sizeSenkrecht * 17)], Segment[start + (sizeWaagrecht * 12) + (sizeSenkrecht * 18), start + (sizeWaagrecht * 12) + (sizeSenkrecht * 19)], Segment[start + (sizeWaagrecht * 12) + (sizeSenkrecht * 20), start + (sizeWaagrecht * 12) + (sizeSenkrecht * 21)], Segment[start + (sizeWaagrecht * 13) + (sizeSenkrecht * 2), start + (sizeWaagrecht * 13) + (sizeSenkrecht * 8)], Segment[start + (sizeWaagrecht * 13) + (sizeSenkrecht * 13), start + (sizeWaagrecht * 13) + (sizeSenkrecht * 16)], Segment[start + (sizeWaagrecht * 13) + (sizeSenkrecht * 17), start + (sizeWaagrecht * 13) + (sizeSenkrecht * 18)], Segment[start + (sizeWaagrecht * 13) + (sizeSenkrecht * 20), start + (sizeWaagrecht * 13) + (sizeSenkrecht * 22)], Segment[start + (sizeWaagrecht * 14) + (sizeSenkrecht * 2), start + (sizeWaagrecht * 14) + (sizeSenkrecht * 4)], Segment[start + (sizeWaagrecht * 14) + (sizeSenkrecht * 6), start + (sizeWaagrecht * 14) + (sizeSenkrecht * 8)], Segment[start + (sizeWaagrecht * 14) + (sizeSenkrecht * 12), start + (sizeWaagrecht * 14) + (sizeSenkrecht * 14)], Segment[start + (sizeWaagrecht * 14) + (sizeSenkrecht * 15), start + (sizeWaagrecht * 14) + (sizeSenkrecht * 16)], Segment[start + (sizeWaagrecht * 14) + (sizeSenkrecht * 21), start + (sizeWaagrecht * 14) + (sizeSenkrecht * 23)]}
labyrinthS03: {Segment[start + (sizeWaagrecht * 15) + (sizeSenkrecht * 5), start + (sizeWaagrecht * 15) + (sizeSenkrecht * 6)], Segment[start + (sizeWaagrecht * 15) + (sizeSenkrecht * 8), start + (sizeWaagrecht * 15) + (sizeSenkrecht * 9)], Segment[start + (sizeWaagrecht * 15) + (sizeSenkrecht * 10), start + (sizeWaagrecht * 15) + (sizeSenkrecht * 11)], Segment[start + (sizeWaagrecht * 15) + (sizeSenkrecht * 14), start + (sizeWaagrecht * 15) + (sizeSenkrecht * 15)], Segment[start + (sizeWaagrecht * 15) + (sizeSenkrecht * 16), start + (sizeWaagrecht * 15) + (sizeSenkrecht * 18)], Segment[start + (sizeWaagrecht * 15) + (sizeSenkrecht * 21), start + (sizeWaagrecht * 15) + (sizeSenkrecht * 22)], Segment[start + (sizeWaagrecht * 16) + (sizeSenkrecht * 9), start + (sizeWaagrecht * 16) + (sizeSenkrecht * 10)], Segment[start + (sizeWaagrecht * 16) + (sizeSenkrecht * 13), start + (sizeWaagrecht * 16) + (sizeSenkrecht * 19)], Segment[start + (sizeWaagrecht * 16) + (sizeSenkrecht * 21), start + (sizeWaagrecht * 16) + (sizeSenkrecht * 23)], Segment[start + (sizeWaagrecht * 17) + (sizeSenkrecht * 3), start + (sizeWaagrecht * 17) + (sizeSenkrecht * 5)], Segment[start + (sizeWaagrecht * 17) + (sizeSenkrecht * 7), start + (sizeWaagrecht * 17) + (sizeSenkrecht * 9)], Segment[start + (sizeWaagrecht * 17) + (sizeSenkrecht * 10), start + (sizeWaagrecht * 17) + (sizeSenkrecht * 11)], Segment[start + (sizeWaagrecht * 17) + (sizeSenkrecht * 13), start + (sizeWaagrecht * 17) + (sizeSenkrecht * 22)], Segment[start + (sizeWaagrecht * 18) + (sizeSenkrecht * 6), start + (sizeWaagrecht * 18) + (sizeSenkrecht * 7)], Segment[start + (sizeWaagrecht * 18) + (sizeSenkrecht * 9), start + (sizeWaagrecht * 18) + (sizeSenkrecht * 10)], Segment[start + (sizeWaagrecht * 18) + (sizeSenkrecht * 11), start + (sizeWaagrecht * 18) + (sizeSenkrecht * 12)], Segment[start + (sizeWaagrecht * 18) + (sizeSenkrecht * 13), start + (sizeWaagrecht * 18) + (sizeSenkrecht * 15)], Segment[start + (sizeWaagrecht * 18) + (sizeSenkrecht * 16), start + (sizeWaagrecht * 18) + (sizeSenkrecht * 21)], Segment[start + (sizeWaagrecht * 19) + (sizeSenkrecht * 1), start + (sizeWaagrecht * 19) + (sizeSenkrecht * 4)], Segment[start + (sizeWaagrecht * 19) + (sizeSenkrecht * 7), start + (sizeWaagrecht * 19) + (sizeSenkrecht * 8)], Segment[start + (sizeWaagrecht * 19) + (sizeSenkrecht * 9), start + (sizeWaagrecht * 19) + (sizeSenkrecht * 19)], Segment[start + (sizeWaagrecht * 19) + (sizeSenkrecht * 21), start + (sizeWaagrecht * 19) + (sizeSenkrecht * 22)]}
labyrinthS04: {Segment[start + (sizeWaagrecht * 20) + (sizeSenkrecht * 1), start + (sizeWaagrecht * 20) + (sizeSenkrecht * 5)], Segment[start + (sizeWaagrecht * 20) + (sizeSenkrecht * 6), start + (sizeWaagrecht * 20) + (sizeSenkrecht * 8)], Segment[start + (sizeWaagrecht * 20) + (sizeSenkrecht * 10), start + (sizeWaagrecht * 20) + (sizeSenkrecht * 19)], Segment[start + (sizeWaagrecht * 21) + (sizeSenkrecht * 1), start + (sizeWaagrecht * 21) + (sizeSenkrecht * 3)], Segment[start + (sizeWaagrecht * 21) + (sizeSenkrecht * 5), start + (sizeWaagrecht * 21) + (sizeSenkrecht * 9)], Segment[start + (sizeWaagrecht * 21) + (sizeSenkrecht * 12), start + (sizeWaagrecht * 21) + (sizeSenkrecht * 18)], Segment[start + (sizeWaagrecht * 21) + (sizeSenkrecht * 21), start + (sizeWaagrecht * 21) + (sizeSenkrecht * 22)], Segment[start + (sizeWaagrecht * 22) + (sizeSenkrecht * 4), start + (sizeWaagrecht * 22) + (sizeSenkrecht * 8)], Segment[start + (sizeWaagrecht * 22) + (sizeSenkrecht * 9), start + (sizeWaagrecht * 22) + (sizeSenkrecht * 11)], Segment[start + (sizeWaagrecht * 22) + (sizeSenkrecht * 13), start + (sizeWaagrecht * 22) + (sizeSenkrecht * 15)], Segment[start + (sizeWaagrecht * 22) + (sizeSenkrecht * 20), start + (sizeWaagrecht * 22) + (sizeSenkrecht * 22)], Segment[start + (sizeWaagrecht * 23) + (sizeSenkrecht * 0), start + (sizeWaagrecht * 23) + (sizeSenkrecht * 23)]}
labyrinthSenkrecht = Flatten({labyrinthS01, labyrinthS02, labyrinthS03, labyrinthS04})
labyrinth = Flatten({labyrinthSenkrecht, labyrinthWaagrecht})
A: (5.75, 11.75)
attemptCount = 1
correctCount = 0
correctValue: If[Defined[studentAnswer01], studentAnswer01, 0] + If[Defined[studentAnswer02] ∧ Defined[studentAnswer03], studentAnswer02 / studentAnswer03, 0] ≟ expectedSolutionValue
correct = If(randomNumber < 7, studentAnswer01 ≟ listSol(randomNumber), listSol2(randomNumber) ≟ inputtrue)
showBtnValidate = true
showBtnTryAgain = false
showBtnNew = false
showsolution = false
validate = false
showHint = false
showHintTypical = false
txtCorrectCount: "\textsf{Richtig gelöste Aufgaben: " + (LaTeX[correctCount]) + "}"
imgGoalA = (5.4787922417701065, 6.529532706659464)
imgGoalB = (8.978792241770096, 6.529532706659464)
showGoal = false
numberOfQuestions = Length(randomNumbers)
txtCounter: "\textsf{" + (LaTeX[Mod[questionCount, numberOfQuestions] + 1]) + "/" + (LaTeX[numberOfQuestions]) + "}"
imgLabyrinthA = (0, 0)
imgLabyrinthB = (11.538486722794085, -0.02598159452547962)
questionsPositions: {start + (sizeWaagrecht * 11) + (sizeSenkrecht * 19), start + (sizeWaagrecht * 16) + (sizeSenkrecht * 12), start + (sizeWaagrecht * 13) + (sizeSenkrecht * 16), start + (sizeWaagrecht * 10) + (sizeSenkrecht * 12), start + (sizeWaagrecht * 9) + (sizeSenkrecht * 10), start + (sizeWaagrecht * 8) + (sizeSenkrecht * 7), start + (sizeWaagrecht * 4) + (sizeSenkrecht * 14), start + (sizeWaagrecht * 3) + (sizeSenkrecht * 8), start + (sizeWaagrecht * 6) + (sizeSenkrecht * 5), start + (sizeWaagrecht * 0) + (sizeSenkrecht * 0)}
questionsRectangles = Sequence(Polygon[Element[questionsPositions, i], Element[questionsPositions, i] + sizeWaagrecht, Element[questionsPositions, i] + sizeWaagrecht + sizeSenkrecht, Element[questionsPositions, i] + sizeSenkrecht], i, 1, Length[questionsPositions])
actualQuestionNeeded = 1
showQuestion = IsInRegion(A, Element[questionsRectangles, actualQuestionNeeded])
inputBox01 = Textfield(studentAnswer01)
inputBox02 = Textfield(studentAnswer02)
inputBox03 = Textfield(studentAnswer03)
allTasks: {"\frac{3}{4} + 1 \frac{2}{4} = ", "\frac{6}{8} - \frac{3}{8} - \frac{1}{8} = ", "\frac{3}{7} + 3 \frac{3}{7} - \frac{1}{7} = ", "3 \frac{1}{2} + 2 \frac{1}{2} = ", "3 \frac{3}{6} - \frac{5}{6} = ", "\frac{3}{4} - \frac{1}{4} + \frac{2}{4} - \frac{1}{4} = ", "1 \frac{2}{5} - \frac{3}{5} + \frac{4}{5} = ", "2 - \frac{2}{8} = ", "3 \frac{3}{4} - \frac{1}{4} = ", "\frac{3}{4} + 1 \frac{1}{4} + \frac{1}{4} +\frac{3}{4} = "}
allSolutionsText: {"1 \frac{5}{4} = 2 \frac{1}{4}", "\frac{2}{8} = \frac{1}{4}", "3 \frac{6}{7} - \frac{1}{7} = 3 \frac{5}{7}", "5 \frac{2}{2} = 6", "2 \frac{9}{6} - \frac{5}{6} = 2 \frac{4}{6}", "\frac{3}{4}", "1 \frac{2}{5} + \frac{4}{5} - \frac{3}{5} = 1 \frac{6}{5} - \frac{3}{5} = 1 \frac{3}{5}", "\frac{16}{8} - \frac{2}{8} = \frac{14}{8} = 1 \frac{3}{4}", "3 \frac{2}{4}", "1 \frac{8}{4} = 3"}
txtTaskPosition: (5.3, 6.45)
txtTask = Text("\textsf{" + (ReplaceAll[Element[allTasks, randomNumber], "-", "\\minus"]) + "}", txtTaskPosition, true, true, -1, 0)
showStart = true
imgNeutralB = (12.501999883705066, 5.831029425397681)
clickableBtnValidate: (needGanze ∧ Defined[studentAnswer01] ∨ (¬needGanze)) ∧ (needBruch ∧ Defined[studentAnswer02] ∧ Defined[studentAnswer03] ∨ (¬needBruch))
pointStep: x(sizeWaagrecht)
nextPoints: {A + (0, (-(pointStep / 2))), A + (0, pointStep / 2), A + ((-(pointStep / 2)), 0), A + (pointStep / 2, 0)}
imgGeistEndeA = (2.606259432652757, 1.2424313054192906)
imgGeistEndeB = (8.926086879949022, 1.2424313054192906)
imgNeutralA: (6.17377, 5.83103)
imgNeutralSmallA: A + (-0.5, -0.4)
imgNeutralSmallB: A + (0.6, -0.4)
showInfo = false
imgPfeiltastenA: (2, 4)
imgPfeiltastenB: (7, 4)
questionNumberCorrect: {false, false, false, false, false, false, false, false, false, false}
correctPoint01: Element[questionsPositions, 1] + (0.25, 0.25)
correctPoint02: Element[questionsPositions, 2] + (0.25, 0.25)
correctPoint03: Element[questionsPositions, 3] + (0.25, 0.25)
correctPoint04: Element[questionsPositions, 4] + (0.25, 0.25)
correctPoint05: Element[questionsPositions, 5] + (0.25, 0.25)
correctPoint06: Element[questionsPositions, 6] + (0.25, 0.25)
correctPoint07: Element[questionsPositions, 7] + (0.25, 0.25)
correctPoint08: Element[questionsPositions, 8] + (0.25, 0.25)
correctPoint09: Element[questionsPositions, 9] + (0.25, 0.25)
correctPoint10: Element[questionsPositions, 10] + (0.25, 0.25)
actualTypicalHintAnswer: {2, 3, 2}
rectangleFeedbackGanze: {Polygon[(5.2, 5.95), (5.85, 5.95), (5.85, 6.8), (5.2, 6.8)]}
startPositionBruchXValue = If((¬needGanze) ∧ needBruch, 5.25, 5.95)
rectangleFeedbackBruch: {Polygon[(startPositionBruchXValue - 0.05, 5.5), (startPositionBruchXValue + 0.6, 5.5), (startPositionBruchXValue + 0.6, 7.25), (startPositionBruchXValue - 0.05, 7.25)]}
txtHintTypical: "\textsf{\fcolorbox{ffffff}{ebe7f8}{" + (LaTeX[If[Element[actualTypicalHintAnswer, 2] ≥ Element[actualTypicalHintAnswer, 3], "Wie viele Ganze sind noch in", "Du hast"]]) + " " + (LaTeX[If[Defined[Element[actualTypicalHintAnswer, 1]], Element[actualTypicalHintAnswer, 1] + " "]]) + "" + (LaTeX[If[Defined[Element[actualTypicalHintAnswer, 2]] ∧ Defined[Element[actualTypicalHintAnswer, 3]], "\frac{" + (Element[actualTypicalHintAnswer, 2]) + "}{" + (Element[actualTypicalHintAnswer, 3]) + "}"]]) + " " + (LaTeX[If[Element[actualTypicalHintAnswer, 2] ≥ Element[actualTypicalHintAnswer, 3], "enthalten?", "noch nicht vollständig vereinfacht."]]) + "}"
isTypicalError: correctValue ∧ (¬correct) ∧ abs(studentAnswer01 - expectedSolutionGanze) ≤ 1
txtSolution: "\textsf{Lösung: \\" + (LaTeX[txtTask]) + "" + (LaTeX[ReplaceAll[Element[allSolutionsText, randomNumber], "-", "\\minus"]]) + "}"
txtGoal: "\textsf{
\begin{array}{c}" + (LaTeX[If[correctCount ≥ 9, (((("Bravo, du " * correctCount) * " von ") * numberOfQuestions) * " Aufgaben\\richtig gelöst und dir so den Weg\\aus dem Labyrinth gebahnt!"), "\\\phantom{a}\\\qquad Du hast alle Aufgaben\qquad \\bearbeitet!"]]) + "

\end{array}
}"
PupupRectangleQuestion: {Polygon[(0.6, 2), (11.3, 2), (11.3, 8.8), (0.6, 8.8)]}
Text7: "\textsf{Lösung: " + (LaTeX[listSol(randomNumber)]) + " \%"
P1 = (4.253448501362938, 5.368808003055569)
P2 = (5.295547708097957, 4.830950347966527)
P3 = (4.303024346198347, 6.005817347815382)
P4 = (7.094009242301942, 5.520080468549362)
P5 = (7.161241449188072, 5.469656313384765)
P6 = (5.312355759819489, 5.469656313384765)
P = Element({P1, P2, P3, P4, P5, P6}, randomNumber)
inputfalse = false
fixed = If(randomNumber < 7, Defined[studentAnswer01], inputtrue ∨ inputfalse)
txtFeedback: "\textsf{" + (LaTeX[If[correct, "✓ Richtig\vphantom{✘}", "✘ Falsch\vphantom{✓}"]]) + "}"
B1 = (1.6650085362469274, 6.222625399536914)
B2: B1 + (0, -1)
fbx: 2.3
fby: -0.8
B = If(inputfalse, B2, B1)
fbrectangle: {Translate[Polygon[(0, 0), (fbx, 0), (fbx, fby), (0, fby)], B]}
Text12: "\textsf{" + (LaTeX[If[correct, "✓", "✘"]]) + ""
clickableBtnDown: (¬(true ∈ Sequence[Element[nextPoints, 1] ∈ Element[labyrinthWaagrecht, i], i, 1, Length[labyrinthWaagrecht]])) ∧ A ≠ (0.25, -0.25) ∧ (¬showQuestion) ∧ (¬showInfo)
clickableBtnLeft: (¬(true ∈ Sequence[Element[nextPoints, 3] ∈ Element[labyrinthSenkrecht, i], i, 1, Length[labyrinthSenkrecht]])) ∧ A ≠ (0.25, -0.25) ∧ A ≠ (5.75, 11.75) ∧ (¬showQuestion)
clickableBtnUp: (¬(true ∈ Sequence[Element[nextPoints, 2] ∈ Element[labyrinthWaagrecht, i], i, 1, Length[labyrinthWaagrecht]])) ∧ A ≠ (5.75, 11.75) ∧ (¬showQuestion)
clickableBtnRight: (¬(true ∈ Sequence[Element[nextPoints, 4] ∈ Element[labyrinthSenkrecht, i], i, 1, Length[labyrinthSenkrecht]])) ∧ A ≠ (0.25, -0.25) ∧ A ≠ (5.75, 11.75) ∧ (¬showQuestion)
PopupRectangleSolution: {Polygon[(0.6, 0.06), (11.3, 0.06), (11.3, 8.8), (0.6, 8.8)]}