$\text{Überprüfen}$

$\text{Neuer Versuch}$

$\text{Neue Aufgabe}$

\textsf{Zähle die Anzahl der orangen x\\und der blauen Punkte.

No selection allowed for all input boxes

Selection allowed for all input boxes

\text{Gib die Gleichung ein, die mit den \textcolor{1565C0}{blauen Punkten} und den \textcolor{DB6114}{orangen x} \\vphantom{Äg}dargestellt wird!\
\vphantom{Äg}Ein blauer Punkt steht für die Zahl 1.\
\vphantom{Äg}Ein oranges x steht für eine unbekannte Zahl.

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}

$a=$

$b=$

1

2

3

4

\text{{Stelle die linke Seite\der Gleichung auf der\linken Waagschale dar!}}

\textsf{\textcolor{}{Stelle die rechte Seite\der Gleichung auf der\rechten Seite dar!}}

\textsf{=}

Fixieren

SetzeFixiert

aInput(x) = ?
bInput(x) = ?
schnitt = Intersect(aInput, bInput, (0, 0))
test = Line(schnitt, schnitt + (0, 1))
B32: 4
B31: 3
B30: 2
C30: 6
C31: 7
C32: 8
A30: 1
A31: 1
A32: 1
M4: {{A30, B30, C30}, {A31, B31, C31}, {A32, B32, C32}}
B28: 3
B27: 1
B26: 2
C26: 5
C27: 7
C28: 6
A26: 1
A27: 2
A28: 1
M3: {{A26, B26, C26}, {A27, B27, C27}, {A28, B28, C28}}
B24: 2
B23: 2
B22: 4
C22: 6
C23: 8
C24: 6
A22: 1
A23: 3
A24: 2
M2: {{A22, B22, C22}, {A23, B23, C23}, {A24, B24, C24}}
B20: 4
B19: 2
B18: 2
C18: 3
C19: 5
C20: 6
A18: 1
A19: 3
A20: 2
M1: {{A18, B18, C18}, {A19, B19, C19}, {A20, B20, C20}}
questionCount = 10 (slider from 1 to 100, step 1)
ListeZahlen = Join(Sequence[Shuffle[{1, 2, 3}], i, 1, 33])
zahlen = Element(ListeZahlen, questionCount)
ListeSolution = Join(Sequence[Shuffle[{1, 2, 3, 4}], i, 1, 25])
solutionx = Element(ListeSolution, questionCount)
M = If(solutionx ≟ 1, M1, If[solutionx ≟ 2, M2, If[solutionx ≟ 3, M3, If[solutionx ≟ 4, M4]]])
c = Element(M, zahlen, 3)
b = Element(M, zahlen, 2)
a = Element(M, zahlen, 1)
sol2: b + (a * x) = c
sol1: (a * x) + b = c
sol3: c = (a * x) + b
sol4: c = b + (a * x)
ListeLayout = Join({{1}, Join[Sequence[Shuffle[{1, 2, 3, 4}], i, 1, 25]]})
layout = Element(ListeLayout, questionCount)
Sol = If(layout ≟ 1, sol1, layout ≟ 2, sol2, layout ≟ 3, sol3, layout ≟ 4, sol4)
SolList: {(a * x) + b = c, b + (a * x) = c, c = (a * x) + b, c = b + (a * x)}
StundAns: SolList(layout)
dx = 3.85 (slider from -5 to 15, step 0.01)
V11 = (-1.08698916070022, 4.996344400684625)
V14: V11 + (0, -3)
V12: V11 + (2.7, 0)
V13: V12 + (0, -3)
f2(x) = c
f1(x) = (a * x) + b
fcorrect1 = If(layout < 3, f1, f2)
fcorrect2 = If(layout > 2, f1, f2)
correctb1: fcorrect2 ≟ aInput
correcta: fcorrect1 ≟ aInput
correcta1: fcorrect1 ≟ bInput
correctb: fcorrect2 ≟ bInput
PbottomRightCornerFeedback = (1.9358887252032217, 6.300744906992284)
PtopLeftCornerFeedback = (-0.5661201185806002, 7.145823246764896)
V21: (2.5, y(PtopLeftCornerFeedback))
V23: (4.95, y(PbottomRightCornerFeedback))
V24: (x(V21), y(V23))
V22: (x(V23), y(V21))
v2, k, l, m, n = Polygon(Translate[V11, (dx, 0)], Translate[V12, (dx, 0)], Translate[V13, (dx, 0)], Translate[V14, (dx, 0)])
X4 = (-1.6902831551038207, 4.853948226017805)
X3 = (-2.4702831551038207, 4.853948226017805)
X2 = (-3.250283155103821, 4.853948226017805)
X1 = (-4.030283155103821, 4.853948226017805)
ListeX: {X1, X2, X3, X4}
AnzahlRechtsX = CountIf(A ∈ v2, A, ListeX)
B12 = (-1.6902831551038207, 2.5139482260178045)
B11 = (-2.4702831551038207, 2.5139482260178045)
B10 = (-3.250283155103821, 2.5139482260178045)
B9 = (-4.030283155103821, 2.5139482260178045)
B8 = (-1.6902831551038207, 3.293948226017805)
B7 = (-2.4702831551038207, 3.293948226017805)
B6 = (-3.250283155103821, 3.293948226017805)
B5 = (-4.030283155103821, 3.293948226017805)
B4 = (-1.6902831551038207, 4.073948226017805)
B3 = (-2.4702831551038207, 4.073948226017805)
B2 = (-3.250283155103821, 4.073948226017805)
B1 = (-4.030283155103821, 4.073948226017805)
ListeB: {B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12}
AnzahlRechtsB = CountIf(A ∈ v2, A, ListeB)
B11_{1}: 3
B10_{1}: 2
B9_{1}: 2
B7_{1}: 1
B6_{1}: 2
B5_{1}: 4
B3_{1}: 2
B2_{1}: 3
B1_{1}: 2
correctrechts = If(layout > 2, AnzahlRechtsB ≟ b ∧ AnzahlRechtsX ≟ a, AnzahlRechtsB ≟ c)
v1, b_1, c_1, d, e = Polygon(V11, V12, V13, V14)
AnzahlLinksX = CountIf(A ∈ v1, A, ListeX)
AnzahlLinksB = CountIf(A ∈ v1, A, ListeB)
correctlinks = If(layout < 3, AnzahlLinksB ≟ b ∧ AnzahlLinksX ≟ a, AnzahlLinksB ≟ c)
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
InputBox1 = Textfield(aInput)
InputBox2 = Textfield(bInput)
showcorrecttext = false
PbottomLeftCornerFeedback: (x(PtopLeftCornerFeedback), y(PbottomRightCornerFeedback))
PtopRightCornerFeedback: (x(PbottomRightCornerFeedback), y(PtopLeftCornerFeedback))
rectangleCorrect1, f, g, h, i = Polygon(PbottomLeftCornerFeedback, PtopLeftCornerFeedback, PtopRightCornerFeedback, PbottomRightCornerFeedback)
showhinttypicalerror = false
allowCountIncrement = true
WaageA = (-2.5097952619475694, -0.296145066777172)
WaageB: WaageA + (9, 0)
A = (-1.5543218247763997, -2.9617369371845292)
P11 = (-4.030283155103821, 4.853948226017805)
abstandx = 0.78 (slider from 0 to 3, step 0.01)
abstandy = 0.8 (slider from 0 to 5, step 0.01)
P12: P11 + (abstandx, 0)
P13: P12 + (abstandx, 0)
P14: P13 + (abstandx, 0)
P21: P11 + (0, (-abstandy))
P22: P12 + (0, (-abstandy))
P23: P13 + (0, (-abstandy))
P24: P14 + (0, (-abstandy))
P31: P21 + (0, (-abstandy))
P32: P22 + (0, (-abstandy))
P33: P23 + (0, (-abstandy))
P34: P24 + (0, (-abstandy))
P41: P31 + (0, (-abstandy))
P42: P32 + (0, (-abstandy))
P43: P33 + (0, (-abstandy))
P44: P34 + (0, (-abstandy))
R1: V21
R2: V22
R3: V23
R4: V24
rectangleCorrect2, b_2, c_2, d_1, e_1 = Polygon(R1, R2, R3, R4)
ListePunkte = Join({ListeX, ListeB})
ListePositionen: {P11, P12, P13, P14, P21, P22, P23, P24, P31, P32, P33, P34, P41, P42, P43, P44}
PunkteWeg: AnzahlLinksB + AnzahlLinksX + AnzahlRechtsB + AnzahlLinksB > 0
PS11: (-0.57202, 2.65)
abstandsx = 0.53 (slider from 0 to 5, step 0.01)
abstandsy = 0.65 (slider from 0 to 5, step 0.01)
PS12: PS11 + (abstandsx, 0)
PS13: PS12 + (abstandsx, 0)
PS14: PS13 + (abstandsx, 0)
PS21: PS11 + (0, abstandsy)
PS22: PS12 + (0, abstandsy)
PS23: PS13 + (0, abstandsy)
PS24: PS14 + (0, abstandsy)
PS31: PS21 + (0, abstandsy)
PS32: PS22 + (0, abstandsy)
PS33: PS23 + (0, abstandsy)
PS34: PS24 + (0, abstandsy)
PS112: (3.28992, 2.65)
PS122: PS112 + (abstandsx, 0)
PS132: PS122 + (abstandsx, 0)
PS142: PS132 + (abstandsx, 0)
PS212: PS112 + (0, abstandsy)
PS222: PS122 + (0, abstandsy)
PS232: PS132 + (0, abstandsy)
PS242: PS142 + (0, abstandsy)
PS312: PS212 + (0, abstandsy)
PS322: PS222 + (0, abstandsy)
PS332: PS232 + (0, abstandsy)
PS342: PS242 + (0, abstandsy)
PSLinks: {{PS31, PS32, PS33, PS34}, {PS21, PS22, PS23, PS24}, {PS11, PS12, PS13, PS14}}
PSRechts: {{PS312, PS322, PS332, PS342}, {PS212, PS222, PS232, PS242}, {PS112, PS122, PS132, PS142}}
PS2 = NaN
PS22D: PS22
PS21D: PS21
PS23D: PS23
PS211D: PS212
PS221D: PS222
PS231D: PS232
layouts = If(layout ∈ {1, 2}, 1, 2)
Text1: "\textsf{" + (LaTeX[a]) + " \cdot x + " + (LaTeX[b]) + " = " + (LaTeX[c]) + "}"
Text2: "\textsf{" + (LaTeX[b]) + " + " + (LaTeX[a]) + " \cdot x = " + (LaTeX[c]) + "}"
Text3: "\textsf{" + (LaTeX[c]) + " = " + (LaTeX[a]) + " \cdot x + " + (LaTeX[b]) + "}"
Text4: "\textsf{" + (LaTeX[c]) + " = " + (LaTeX[b]) + " + " + (LaTeX[a]) + " \cdot x}"
correctlinks1 = If(layout > 2, AnzahlLinksB ≟ b ∧ AnzahlLinksX ≟ a, AnzahlLinksB ≟ c)
correctrechts1 = If(layout < 3, AnzahlRechtsB ≟ b ∧ AnzahlRechtsX ≟ a, AnzahlRechtsB ≟ c)
correct1: correctlinks1 ∨ correctrechts1
isTypicalError: correct1
solutionText: "\text{Lösung:\\" + (LaTeX[If[layout ≟ 1, Text1, If[layout ≟ 2, Text2, If[layout ≟ 3, Text3, If[layout ≟ 4, Text4]]]]]) + "}"
abstand1: 0.25
vabstand11: ((-abstand1), (-abstand1))
vabstand12: (abstand1, (-abstand1))
BlauLinksAlle: {PS12, PS11, PS13, PS14, PS21, PS22, PS23, PS24, PS31, PS32, PS33, PS34}
BlauLinksB = KeepIf(IndexOf[V, BlauLinksAlle] ≤ b, V, BlauLinksAlle)
BlauLinksC = KeepIf(IndexOf[V, BlauLinksAlle] ≤ c, V, BlauLinksAlle)
BlauRechtsAlle: {PS122, PS112, PS132, PS142, PS212, PS222, PS232, PS242, PS312, PS322, PS332, PS342}
BlauRechtsB = KeepIf(IndexOf[V, BlauRechtsAlle] ≤ b, V, BlauRechtsAlle)
BlauRechtsC = KeepIf(IndexOf[V, BlauRechtsAlle] ≤ c, V, BlauRechtsAlle)
BlauLinks = If(layout < 3, BlauLinksB, BlauLinksC)
BlauRechts = If(layout < 3, BlauRechtsC, BlauRechtsB)
correct: test ≟ Sol
correctText: "\text{" + (LaTeX[If[correcta ∨ correct, "✓ Richtig", "✘ Falsch"]]) + "}"
gl1 = If(layout ≟ 1, Text1, If[layout ≟ 2, Text2, If[layout ≟ 3, Text3, If[layout ≟ 4, Text4]]])
test1 = Split(gl1, {""})
j = 21 (slider from -5 to 40, step 1)
studEq: aInput ≟ bInput
correctTextb: "\textsf{" + (LaTeX[If[correct, "✓ Richtig", "✘ Falsch"]]) + "}"
solutionText2: "\textsf{" + (LaTeX[ReplaceAll[solutionText, "1 \cdot ", ""]]) + "}"
tabOrder: {questionText, InputBox1, InputBox2, correctText, correctTextb, txtHint, txtHint2, txtHint3, solutionText2, textCountCorrect, btnValidate, btnTryAgain, btnNew}