$\text{Überprüfen}$

$\text{Neuer Versuch}$

$\text\bold{Neue Aufgabe}$

\textsf{Multipliziere den 1. Faktoren\\einmal mit der Zehnerziffer und\\einmal mit der Einerziffer des 2. Faktors.\\Vergiss dabei nicht auf den Übertrag!

No selection allowed for all input boxes

Selection allowed for all input boxes

\text{Führe die schriftliche Multiplikation aus!\Setze anschließend das Komma passend.

Fix position and allow selection for all text objects

Empty all input boxes

#EDEDED

\text{Text for just the correct answer.}

\underline\text{Helper scripts for template}

\underline\text{Helper scripts for authors}

\text{This hint is for typical misconceptions of\students. It is shown after any wrong answer\that shows the typical error.}

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

$b=$

\textsf{\vphantom{Äg}Achtung: In jedes Eingabefeld gehört nur eine Ziffer!

\textsf{\vphantom{Äg}Addiere die Zwischenergebnisse.}

|
|
|
|
|
|
|
|
|
|
|
|
|
|

\textsf{---------------------------------------------------------------------------------------------------------------

\textsf{Setze das Komma, indem du\den Schieberegler bewegst.

\textsf{,}

\textsf{,}

$\textsf{SetCorrect}$

\textsf\colorbox{ebe7f8}{Du hast das Komma falsch gesetzt.\
Überprüfe deine Überschlagsrechnung.

\textsf\colorbox{ebe7f8}{Multipliziere so, wie du es von\den natürlichen Zahlen kennst.}

\textsf{,}

\textsf{,}

\textsf\colorbox{ebe7f8}{Das Produkt hat genau so viele\vphantom{Öj}
\Nachkommastellen, wie die Dezimalzahl.\vphantom{Öj}}

fixedkomma = true
ub2 = NaN
ub1 = NaN
ua2 = NaN
ua1 = NaN
c5 = NaN
b5 = NaN
a5 = NaN
o = false
c4 = NaN
c3 = NaN
c2 = NaN
c1 = NaN
c0 = NaN
b4 = NaN
b3 = NaN
b2 = NaN
b1 = NaN
b0 = NaN
a4 = NaN (slider from -5 to 20)
a3 = NaN
a2 = NaN
a1 = NaN
a0 = NaN
isTypicalError: a0 > 9 ∨ a1 > 9 ∨ a2 > 9 ∨ a3 > 9 ∨ a4 > 9 ∨ a5 > 9 ∨ b0 > 9 ∨ b1 > 9 ∨ b2 > 9 ∨ b3 > 9 ∨ b4 > 9 ∨ b5 > 9 ∨ c0 > 9 ∨ c1 > 9 ∨ c2 > 9 ∨ c3 > 9 ∨ c4 > 9 ∨ c5 > 9 ∨ ua1 > 9 ∨ ua2 > 9 ∨ ub1 > 9 ∨ ub2 > 9
posKomma0 = 6 (slider from 2 to 6, step 1)
randomNosN2 = Join({{5}, Join[Sequence[Shuffle[{1, 2, 3, 4, 5, 6, 7, 8, 9}], m, 1, 30]]})
randomNosN1 = Join({{2}, Join[Sequence[Shuffle[{1, 2, 3, 4, 5, 6, 7, 8, 9}], m, 1, 30]]})
correctB0: b0 ≟ 0 ∨ (¬Defined[b0])
questionCount = 0 (slider from 0 to 100, step 1)
n2: randomNosN2(Mod[questionCount, 100] + 1)
n1: randomNosN1(Mod[questionCount, 100] + 1)
n: (10 * n1) + n2
randomNosM3 = Join({{RandomElement[{2, 3, 4, 5}]}, Join[Sequence[Shuffle[{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}], m, 1, 30]]})
m3: randomNosM3(Mod[questionCount, 100] + 1)
randomNosM2 = Join({{RandomElement[{1, 2, 3, 4, 5, 6, 7, 8, 9}]}, Join[Sequence[Shuffle[{1, 2, 3, 4, 5, 6, 7, 8, 9}], m, 1, 30]]})
m2: randomNosM2(Mod[questionCount, 100] + 1)
randomNosM1 = Join({{RandomElement[{1, 2, 3, 4}]}, Join[Sequence[Shuffle[{0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}], m, 1, 30]]})
m1: randomNosM1(Mod[questionCount, 100] + 1)
m: (100 * m1) + (10 * m2) + m3
ccorrect: (m * n)
bcorrect: (m * n2)
numCcorrect: {floor(ccorrect / 10000), floor(ccorrect / 1000 - (10 * floor(ccorrect / 10000))), floor(ccorrect / 100 - (100 * floor(ccorrect / 10000)) - (10 * floor(ccorrect / 1000 - (10 * floor(ccorrect / 10000))))), floor(ccorrect / 10 - (1000 * floor(ccorrect / 10000)) - (100 * floor(ccorrect / 1000 - (10 * floor(ccorrect / 10000)))) - (10 * floor(ccorrect / 100 - (100 * floor(ccorrect / 10000)) - (10 * floor(ccorrect / 1000 - (10 * floor(ccorrect / 10000))))))), floor(bcorrect - (1000 * floor(bcorrect / 1000)) - (100 * floor(bcorrect / 100 - (10 * floor(bcorrect / 1000)))) - (10 * floor(bcorrect / 10 - (100 * floor(bcorrect / 1000)) - (10 * floor(bcorrect / 100 - (10 * floor(bcorrect / 1000)))))))}
correctC0 = If(numCcorrect(1) ≟ 0, c0 ≟ 0 ∨ (¬Defined[c0]), c0 ≟ numCcorrect(1))
correctC1 = If(numCcorrect(2) ≟ 0, c1 ≟ 0 ∨ (¬Defined[c1]), c1 ≟ numCcorrect(2))
correctC2: c2 ≟ numCcorrect(2 + 1)
correctC3: c3 ≟ numCcorrect(3 + 1)
correctC4: c4 ≟ numCcorrect(4 + 1)
numBcorrect: {0, floor(bcorrect / 1000), floor(bcorrect / 100 - (10 * floor(bcorrect / 1000))), floor(bcorrect / 10 - (100 * floor(bcorrect / 1000)) - (10 * floor(bcorrect / 100 - (10 * floor(bcorrect / 1000))))), floor(bcorrect - (1000 * floor(bcorrect / 1000)) - (100 * floor(bcorrect / 100 - (10 * floor(bcorrect / 1000)))) - (10 * floor(bcorrect / 10 - (100 * floor(bcorrect / 1000)) - (10 * floor(bcorrect / 100 - (10 * floor(bcorrect / 1000)))))))}
correctB2 = If(numBcorrect(3) ≟ 0, b2 ≟ 0 ∨ (¬Defined[b2]), b2 ≟ numBcorrect(2 + 1))
correctB3: b3 ≟ numBcorrect(3 + 1)
correctB4: b4 ≟ numBcorrect(4 + 1)
correctB1 = If(numBcorrect(2) ≟ 0, b1 ≟ 0 ∨ (¬Defined[b1]), b1 ≟ numBcorrect(1 + 1))
acorrect: ((m * n1) * 10)
numAcorrect: {floor(acorrect / 10000), floor(acorrect / 1000 - (10 * floor(acorrect / 10000))), floor(acorrect / 100 - (100 * floor(acorrect / 10000)) - (10 * floor(acorrect / 1000 - (10 * floor(acorrect / 10000))))), floor(acorrect / 10 - (1000 * floor(acorrect / 10000)) - (100 * floor(acorrect / 1000 - (10 * floor(acorrect / 10000)))) - (10 * floor(acorrect / 100 - (100 * floor(acorrect / 10000)) - (10 * floor(acorrect / 1000 - (10 * floor(acorrect / 10000))))))), 0}
correctA1 = If(numAcorrect(2) ≟ 0, a1 ≟ 0 ∨ (¬Defined[a1]), a1 ≟ numAcorrect(2))
correctA2: a2 ≟ numAcorrect(3)
correctA3: a3 ≟ numAcorrect(4)
correctA4: a4 ≟ numAcorrect(5) ∨ (¬Defined[a4])
correctA0 = If(numAcorrect(1) ≟ 0, a0 ≟ 0 ∨ (¬Defined[a0]), a0 ≟ numAcorrect(1))
randomPosKomma = Zip(If[m ≟ 0, 3, RandomElement[{1, 2, 3}]], m, randomNosM1)
posKomma1: randomPosKomma(Mod[questionCount, 100] + 1)
correctKomma: posKomma0 ≟ posKomma1 + 2
E = (-2.746861376457034, 6.833935559307187)
dxUberschlag = 0.8 (slider from -5 to 5, step 0.01)
dyUberschlag = 0.78 (slider from -5 to 5, step 0.01)
D = (-1.8080165451784451, 5.05754755811773)
FA = (-3.833519472503994, 6.431046238645048)
FB = Point(Line[FA, yAxis])
dxFB1 = 0.9 (slider from -5 to 5, step 0.01)
dxStrich = 4.98 (slider from -5 to 10, step 0.01)
A = (-4.02698, 5.1)
lengthSolution = -3.45 (slider from -5 to 5, step 0.01)
ua2correct: floor((((m2 * n1) * 10) + (m3 * n1)) / 100)
ua1correct: floor((m3 * n1 / 10))
ub2correct: floor((((m2 * n2) * 10) + (m3 * n2)) / 100)
ub1correct: floor((m3 * n2 / 10))
Blue = (-5.32, 4.5)
Green = (-5.28, 3.68)
Orange = (-5.2, 2.86)
Red = (-5.32, 2.04)
Purple = (-5.34, 1.12)
Gray = (-5.34, 0.32)
GrayDark = (-5.36, -0.7)
validate = false
showanswer = false
showsolution = false
attemptCount = 0
correctCount: 0
textCountCorrect: "\text{Richtig gelöste Aufgaben: " + (LaTeX[correctCount]) + " }"
showButtonNew = false
showButtonTryAgain = false
showButtonValidate = true
showhint = false
aInput: NaN
bInput: NaN
correct: correctKomma ∧ correctA0 ∧ correctA1 ∧ correctA2 ∧ correctA3 ∧ correctA4 ∧ correctB0 ∧ correctB1 ∧ correctB2 ∧ correctB3 ∧ correctB4 ∧ correctC0 ∧ correctC1 ∧ correctC2 ∧ correctC3 ∧ correctC4
showcorrecttext = false
PtopLeftCornerFeedback = (2.6067617209494607, 0.5708155149326831)
PbottomRightCornerFeedback = (4.7949729669636785, -0.5327218468978517)
PtopRightCornerFeedback: (x(PbottomRightCornerFeedback), y(PtopLeftCornerFeedback))
PbottomLeftCornerFeedback: (x(PtopLeftCornerFeedback), y(PbottomRightCornerFeedback))
rectangleCorrect, ptopleftcornerfeedback, ptoprightcornerfeedback, pbottomrightcornerfeedback, pbottomleftcornerfeedback = Polygon(PtopLeftCornerFeedback, PtopRightCornerFeedback, PbottomRightCornerFeedback, PbottomLeftCornerFeedback)
showhinttypicalerror = false
allowCountIncrement = true
InputBoxA1 = Textfield(a1)
InputBoxA2 = Textfield(a2)
InputBoxA3 = Textfield(a3)
InputBoxA4 = Textfield(a4)
InputBoxA5 = Textfield(a5)
InputBoxB0 = Textfield(b0)
InputBoxB1 = Textfield(b1)
InputBoxB2 = Textfield(b2)
InputBoxB3 = Textfield(b3)
InputBoxB4 = Textfield(b4)
InputBoxB5 = Textfield(b5)
InputBoxC0 = Textfield(c0)
InputBoxC1 = Textfield(c1)
InputBoxC2 = Textfield(c2)
InputBoxC3 = Textfield(c3)
InputBoxC4 = Textfield(c4)
InputBoxC5 = Textfield(c5)
InputBoxUA1 = Textfield(ua1)
InputBoxUA2 = Textfield(ua2)
InputBoxUB1 = Textfield(ub1)
InputBoxUB2 = Textfield(ub2)
InputBoxA0 = Textfield(a0)
Text2: "\textsf{" + (LaTeX[acorrect]) + "\\" + (LaTeX[bcorrect]) + "\\" + (LaTeX[ccorrect]) + ""
correctUA2 = If(ua1correct ≟ 0, (¬Defined[ua2]) ∨ ua2 ≟ 0, ua2 ≟ ua1correct)
correctUA1 = If(ua2correct ≟ 0, (¬Defined[ua1]) ∨ ua1 ≟ 0, ua1 ≟ ua2correct)
correctUB1 = If(ub2correct ≟ 0, (¬Defined[ub1]) ∨ ub1 ≟ 0, ub1 ≟ ub2correct)
correctUB2 = If(ub1correct ≟ 0, (¬Defined[ub2]) ∨ ub2 ≟ 0, ub2 ≟ ub1correct)
fa = Flatten(Sequence[Sequence[FA + (m * (dxFB1, 0)) + (j * (0, 1)), m, 0, 5], j, 0, 1])
va0, f, g, h, i = Polygon(fa(1), fa(2), fa(8), fa(7))
va1, j, k, l, p = Polygon(fa(2), fa(3), fa(9), fa(8))
va2, q, r, s, t = Polygon(fa(3), fa(4), fa(10), fa(9))
va3, a, b, c, d = Polygon(fa(4), fa(5), fa(11), fa(10))
va4, e, f_1, g_1, h_1 = Polygon(fa(5), fa(6), fa(12), fa(11))
fb = Flatten(Sequence[Sequence[FB + (m * (dxFB1, 0)) + (j * (0, 1)), m, 0, 5], j, 0, 1])
vb0, i_1, j_1, k_1, l_1 = Polygon(fb(1), fb(2), fb(8), fb(7))
vb1, m_1, n_1, p_1, q_1 = Polygon(fb(3), fb(2), fb(8), fb(9))
vb2, r_1, s_1, t_1, a_1 = Polygon(fb(3), fb(4), fb(10), fb(9))
vb3, b_1, c_1, d_1, e_1 = Polygon(fb(4), fb(5), fb(11), fb(10))
vb4, f_2, g_2, h_2, i_2 = Polygon(fb(5), fb(6), fb(12), fb(11))
FC = Point(Line[FA, yAxis])
fc = Flatten(Sequence[Sequence[FC + (m * (dxFB1, 0)) + (j * (0, 1)), m, 0, 5], j, 0, 1])
vc0, j_2, k_2, l_2, m_2 = Polygon(fc(1), fc(2), fc(8), fc(7))
vc1, n_2, p_2, q_2, r_2 = Polygon(fc(3), fc(2), fc(8), fc(9))
vc2, s_2, t_2, a_2, b_2 = Polygon(fc(3), fc(4), fc(10), fc(9))
vc3, c_2, d_2, e_2, f_3 = Polygon(fc(4), fc(5), fc(11), fc(10))
vc4, g_3, h_3, i_3, j_3 = Polygon(fc(5), fc(6), fc(12), fc(11))
fua = Flatten(Sequence[Sequence[E + (m * (dxUberschlag, 0)) + (j * (0, dyUberschlag)), m, 0, 2], j, 0, 1])
vua1, k_3, l_3, m_3, n_3 = Polygon(fua(1), fua(2), fua(5), fua(4))
vua2, p_3, q_3, r_3, s_3 = Polygon(fua(2), fua(3), fua(6), fua(5))
solutionText: "\textsf{\setlength{\tabcolsep}{" + (LaTeX[lengthSolution]) + "}
\small{Lösung:}\\\begin{tabular}{rrrrrrrrrr}" + (LaTeX[If[posKomma1 ≟ 1, "0", "\hphantom{0}"]]) + "&" + (LaTeX[If[m < 100, "", ("" * m1)]]) + "&" + (LaTeX[m2]) + "&" + (LaTeX[m3]) + "&\cdot&   {" + (LaTeX[n1]) + "}&" + (LaTeX[n2]) + "\\\\\hline\\" + (LaTeX[If[Defined[numAcorrect(1)] ∧ numAcorrect(1) > 0, ("" * numAcorrect(1)), ""]]) + "&" + (LaTeX[numAcorrect(2)]) + "&^" + (LaTeX[ua2correct]) + "" + (LaTeX[numAcorrect(3)]) + "&^" + (LaTeX[ua1correct]) + "" + (LaTeX[numAcorrect(4)]) + "&\\" + (LaTeX[If[Defined[numBcorrect(1)] ∧ numBcorrect(1) > 0, ("" * numBcorrect(1)), ""]]) + "&" + (LaTeX[numBcorrect(2)]) + "&" + (LaTeX[numBcorrect(3)]) + "&^" + (LaTeX[ub2correct]) + "" + (LaTeX[numBcorrect(4)]) + "&^" + (LaTeX[ub1correct]) + "" + (LaTeX[numBcorrect(5)]) + "\\\\
\hline\\" + (LaTeX[If[Defined[numCcorrect(1)] ∧ numCcorrect(1) > 0, ("" * numCcorrect(1)), "\hphantom{0}"]]) + "&" + (LaTeX[numCcorrect(2)]) + "&" + (LaTeX[numCcorrect(3)]) + "&" + (LaTeX[numCcorrect(4)]) + "&" + (LaTeX[numCcorrect(5)]) + "
\end{tabular}}"
tabOrder: {questionText, InputBoxA3, InputBoxUA2, InputBoxA2, InputBoxUA1, InputBoxA1, InputBoxA0, InputBoxA4, InputBoxB4, InputBoxUB2, InputBoxB3, InputBoxUB1, InputBoxB2, InputBoxB1, InputBoxB0, InputBoxC4, InputBoxC3, InputBoxC2, InputBoxC1, InputBoxC0, btnValidate, btnTryAgain, solutionText, btnNew}
correct0Partial: correctA0 ∨ correctA1 ∨ correctA2 ∨ correctA3 ∨ correctA4 ∨ correctB0 ∨ correctB1 ∨ correctB2 ∨ correctB3 ∨ correctB4 ∨ correctC0 ∨ correctC1 ∨ correctC2 ∨ correctC3 ∨ correctC4
B: A + (dxStrich, 0)
h_4 = Segment(A, B)
dy = 0.5 (slider from -5 to 5, step 0.01)
dx = 6 (slider from -5 to 10, step 0.01)
C = (-3.745706207735622, 7.266441692693384)
PosE1 = Sequence(C + (i * (dxFB1, 0)), i, 0, 6)
dyEingabefeld1 = -1.15 (slider from -5 to 5, step 0.01)
PosE2 = Translate(PosE1, (0, dyEingabefeld1))
dyEingabefeld2 = -1.32 (slider from -5 to 5, step 0.01)
PosE3 = Translate(PosE2, (0, dyEingabefeld2))
correctEingabe1: correctA0 ∧ correctA1 ∧ correctA2 ∧ correctA3 ∧ correctA4
correctEingabe2: correctB0 ∧ correctB1 ∧ correctB2 ∧ correctB3 ∧ correctB4
correctEingabe3: correctC0 ∧ correctC1 ∧ correctC2 ∧ correctC3 ∧ correctC4
FB1: {Polygon[fa(1), fa(6), fa(12), fa(7)]}
FB2: {Polygon[fb(1), fb(6), fb(12), fb(7)]}
FB3: {Polygon[fc(1), fc(6), fc(12), fc(7)]}
correctText: "\text{" + (LaTeX[If[(¬correct) ∧ (correctEingabe1 ∨ correctEingabe2 ∨ correctEingabe3), "✘ Teilweise Richtig", If[correct, "✓ Richtig", "✘ Falsch"]]]) + "}"
txtHintMultiplikationEinerstelle: "\textsf{\vphantom{Äg}Multipliziere " + (LaTeX[n2]) + " mit " + (LaTeX[m]) + "}"
hintAddition: correctEingabe1 ∧ correctEingabe2 ∧ (¬correctEingabe3)
hint1Zwischenergebnis: ¬correctEingabe1
hint2Zwischenergebnis: ¬correctEingabe2
showHint1Zwischenergebnis = false
showHintAddition = false
showHint2Zwischenergebnis = false
Tools: false
resy: 600
F = (-4.150507734782893, 4.515020484355431)
abskomma = 0.91 (slider from 0 to 2, step 0.01)
listPosKomma0 = Sequence(F + (m * (abskomma, 0)), m, 0, 5)
PosKomma0: listPosKomma0(posKomma0)
G = (-3.3022104170735305, 8.086799534995338)
listPosKomma1 = Sequence(G + (m * (abskomma, 0)), m, 0, 2)
PosKomma1: listPosKomma1(posKomma1)
showhintKomma = false
m4: 0
l1 = Zip(If[m ≟ 0, 3, RandomElement[{1, 2, 3}]], m, randomNosM1)
Text1: "\textsf{
\setlength{\tabcolsep}{" + (LaTeX[dx]) + "}
\renewcommand{\arraystretch}{" + (LaTeX[dy]) + "}

\begin{tabular}{ccccccccc} " + (LaTeX[If[posKomma1 ≟ 1, ("" * m4), "\hphantom{1}"]]) + "\vphantom{Äg}&" + (LaTeX[If[m1 ≟ 0, "", ("" * m1)]]) + "&" + (LaTeX[m2]) + "&" + (LaTeX[m3]) + "&\cdot&" + (LaTeX[n1]) + "&" + (LaTeX[n2]) + "\\\hline \end{tabular}}"
fixed: posKomma0 < 6 ∧ Defined[((((((a2 * a3) * b3) * b4) * c2) * c3) * c4)] ∧ (¬isTypicalError) ∨ o
stellenA = If(acorrect ≥ 10000, 5, If[acorrect ≥ 1000, 4, If[acorrect ≥ 100, 3, If[acorrect ≥ 10, 2, 1]]])
stellenB = If(bcorrect ≥ 10000, 5, If[bcorrect ≥ 1000, 4, If[bcorrect ≥ 100, 3, If[bcorrect ≥ 10, 2, 1]]])
stellenC = If(ccorrect ≥ 10000, 5, If[ccorrect ≥ 1000, 4, If[ccorrect ≥ 100, 3, If[ccorrect ≥ 10, 2, 1]]])
listHasToBeDefined: {a3, a2, If[stellenA ≥ 4, a1, 0], If[stellenA ≥ 5, a0, 0], b4, b3, If[stellenB ≥ 3, b2, 0], If[stellenB ≥ 4, b1, 0], c4, c3, c2, If[stellenC ≥ 4, c1, 0], If[stellenC ≥ 5, c0, 0]}
showSlider: Length[listHasToBeDefined] ≟ Length[RemoveUndefined[listHasToBeDefined]]
H = (2.679411170272006, 7.747305394375752)
abskomma2 = 0.55 (slider from -5 to 5, step 0.01)
listPosKomma2 = Sequence(H + (0.4, -0.7) + (m * (abskomma2, 0)), m, 0, 2)
listPosKomma3 = Sequence(H + (0.4, -2.95) + (m * (abskomma2, 0)), m, 0, 3)
PosKomma2: listPosKomma2(posKomma1)
PosKomma3: listPosKomma3(posKomma1 + 1)
showhintOnlyKomma = false