$\textsf{Los geht's!}$

$\textsf{Weiter}$

$\textsf{Zurück}$

\textsf{Du kannst die beiden Brüche durch Erweitern oder Kürzen\vphantom{p}\mit gleichen Nennern darstellen.\vphantom{p}\
Manchmal ist der gemeinsame Nenner nicht gleich erkennbar.}

$\textsf{Lösung anzeigen}$

#EDEDED

$\textsf{Lösung anzeigen}$

\textsf{Die beiden Summanden sind nun \bold{gleichnamig}.\Du kannst sie daher \bold{wie gewohnt addieren}.}

\textsf{= \frac{       }{\textcolor{FFFFFF}{24}}

$\textsf{Lösung anzeigen}$

\textsf{=        \frac{       }{\textcolor{FFFFFF}{24}}

\textsf\colorbox{#ebe7f8}{Addieren von ungleichnamigen Brüchen:\\
Erweitere oder kürze auf den gleichen                      \\
Addiere anschließend die  \\}

#b3d2cd

#e7b3bd

FFFFFF

$\textsf{Neue Aufgabe}$

$\textsf{Lösung anzeigen}$

\textsf{+}

\textsf{=}

\textsf{Toll gemacht! Du kannst das Addieren weiter üben.}

$\textsf{Unterteilung verfeinern}$

abstandX: 0.3
P1: (-4, -1)
questionCount = 1
bspNenner2: {5, 4, 6, 6, 3}
randomBsp = Join({{1, 2}, Shuffle[{3, 4, 5}]})
bsp = Element(randomBsp, Mod[questionCount, 100])
bspNenner1: {2, 3, 4, 9, 5}
A1: (-4, -1)
B1: (x(A1 + 2), y(A1))
Points1_1 = Sequence(A1 + (i * Vector[A1, B1] / bspNenner1(bsp)), i, 0, bspNenner1(bsp))
P3: Points1_1(bspNenner1(bsp)) + (2, 0)
A2: (x(P3), y(P3))
B2: (x(A2 + 2), y(A2))
Points2_1 = Sequence(A2 + (i * Vector[A2, B2] / bspNenner2(bsp)), i, 0, bspNenner2(bsp))
P4: (x(P3), y(P3) - 2)
C2: (x(A2), y(A2) - 2)
D2: (x(B2), y(C2))
Points2_2 = Sequence(C2 + (i * Vector[C2, D2] / bspNenner2(bsp)), i, 0, bspNenner2(bsp))
bspZaehler2: {2, 3, 1, 3, 2}
nenner = NaN
zaehler = NaN
move = 1
bspZaehler1: {1, 2, 3, 5, 4}
bspKgv: {10, 12, 12, 18, 15}
aInput = NaN
c5: nenner ≟ aInput
c1: aInput ≟ bspKgv(bsp)
bInput = NaN
c2: (aInput / bspNenner1(bsp) * bspZaehler1(bsp)) ≟ bInput
cInput = NaN
c4: zaehler ≟ bInput + cInput
cor2: c4 ∧ c5
c3: (aInput / bspNenner2(bsp) * bspZaehler2(bsp)) ≟ cInput
cor1: c2 ∧ c3
A = (-4, 1.9)
B = (-1, 1.9)
C = (11.64, 6.06)
D = (11.7, -9)
E = (-0.86, 3.78)
poly1_{1} = SpeechBubbleLeft(E - (0, 0.8), 10, 1.7)
loesZaehler: {19, 11, 7, 17, 22}
loesGanzezahl: {0, 1, 0, 1, 1}
text2: "\textsf{\frac{" + (LaTeX[bspZaehler1(bsp)]) + "}{" + (LaTeX[bspNenner1(bsp)]) + "} + \frac{" + (LaTeX[bspZaehler2(bsp)]) + "}{" + (LaTeX[bspNenner2(bsp)]) + "} =}"
F = (8.08, 1.68)
G = (11.08, 1.68)
H = (8, 3)
text4: "\textsf{\frac{" + (LaTeX[bspZaehler1(bsp)]) + "}{" + (LaTeX[bspNenner1(bsp)]) + "} + \frac{" + (LaTeX[bspZaehler2(bsp)]) + "}{" + (LaTeX[bspNenner2(bsp)]) + "} =}"
InputBox1 = Textfield(aInput)
totalAttempts = 0
poly3_{1} = SpeechBubbleRight(H, 10.2, 1)
InputBox2 = Textfield(bInput)
InputBox3 = Textfield(cInput)
poly4 = SpeechBubbleRight(H, 9, 1.5)
InputBox4 = Textfield(zaehler)
InputBox5 = Textfield(nenner)
bspMitGanz = If(loesGanzezahl(bsp) ≠ 0, true, false)
dInput = NaN
zaehler2 = NaN
nenner2 = NaN
InputBox6 = Textfield(dInput)
InputBox7 = Textfield(zaehler2)
InputBox8 = Textfield(nenner2)
c6: dInput ≟ loesGanzezahl(bsp)
c7: zaehler2 ≟ zaehler - (loesGanzezahl(bsp) * aInput)
c8: nenner2 ≟ aInput
cor3: c6 ∧ c7 ∧ c8
I = (8.28, 4.7)
J = (9.12, 5.02)
l1: {"$\textsf{Wähle aus!}$", "$\textsf{Zähler}$", "$\textsf{Nenner}$"}
l2: {"$\textsf{Wähle aus!}$", "$\textsf{Zähler}$", "$\textsf{Nenner}$"}
d1: SelectedIndex[l1] ≟ 3
d2: SelectedIndex[l2] ≟ 2
index1 = SelectedIndex(l1)
index2 = SelectedIndex(l2)
btnLatex_{1}: "\textsf{" + (LaTeX[If[questionCount < 5, "Neue Aufgabe", "Nochmal!"]]) + "}"
cor4: d1 ∧ d2
fixedNeu: move ≟ 7 ∧ cor4 ∧ questionCount ≟ 1 ∨ move ≟ 6 ∧ questionCount ≠ 1
verfeinern = false
text14: "" + (LaTeX[SelectedElement[l2]]) + " ."
text13: "" + (LaTeX[SelectedElement[l1]]) + "  ."
abstandY: 2
P2: (x(P1), y(P1) - 2)
C1: (x(A1), y(A1) - 2)
Points1_2 = Sequence(C1 + (i * Vector[A1, B1] / bspNenner1(bsp)), i, 0, bspNenner1(bsp))
segs1 = Sequence(Segment[Points1_1(i), Points1_2(i)], i, 1, bspNenner1(bsp) + 1)
segs2 = Sequence(Segment[Points2_1(i), Points2_2(i)], i, 1, bspNenner2(bsp) + 1)
f = Segment(P1, Points1_1(bspNenner1(bsp) + 1))
g = Segment(P2, Points1_2(bspNenner1(bsp) + 1))
h = Segment(P3, Points2_1(bspNenner2(bsp) + 1))
i = Segment(P4, Points2_2(bspNenner2(bsp) + 1))
poly1: {Polygon[P1, Points1_1(bspZaehler1(bsp) + 1), Points1_2(bspZaehler1(bsp) + 1), P2]}
poly2: {Polygon[P3, Points2_1(bspZaehler2(bsp) + 1), Points2_2(bspZaehler2(bsp) + 1), P4]}
anzahlTeile: bspKgv(bsp) / bspNenner1(bsp)
kgV1_1 = Sequence(P1 + (i / anzahlTeile * (P2 - P1)), i, 1, anzahlTeile - 1)
kgV1_2 = Sequence(Points1_1(bspNenner1(bsp) + 1) + (i / anzahlTeile * (P2 - P1)), i, 1, anzahlTeile - 1)
anzahlTeile2: bspKgv(bsp) / bspNenner2(bsp)
kgV2_1 = Sequence(P3 + (i / anzahlTeile2 * (P4 - P3)), i, 1, anzahlTeile2 - 1)
kgV2_2 = Sequence(Points2_1(bspNenner2(bsp) + 1) + (i / anzahlTeile2 * (P4 - P3)), i, 1, anzahlTeile2 - 1)
segsKgv1 = Sequence(Segment[kgV1_1(i), kgV1_2(i)], i, 1, anzahlTeile - 1)
segsKgv2 = Sequence(Segment[kgV2_1(i), kgV2_2(i)], i, 1, anzahlTeile2 - 1)
P5: Points2_1(bspNenner2(bsp)) + (2.3, 0)
P6: (x(P5), y(P5) - 2)
A3: (x(P5), y(P5))
B3: (x(A3 + 2), y(A3))
Points3_1 = Sequence(A3 + (i * Vector[A3, B3] / bspNenner1(bsp)), i, 0, bspNenner1(bsp))
C3: (x(A3), y(A3) - 2)
D3: (x(B3), y(C3))
Points3_2 = Sequence(C3 + (i * Vector[C3, D3] / bspNenner1(bsp)), i, 0, bspNenner1(bsp))
segs3 = Sequence(Segment[Points3_1(i), Points3_2(i)], i, 1, bspNenner1(bsp) + 1)
j = Segment(P5, Points3_1(bspNenner1(bsp) + 1))
k = Segment(P6, Points3_2(bspNenner1(bsp) + 1))
kgV3_1 = Sequence(P5 + (i / anzahlTeile * (P6 - P5)), i, 1, anzahlTeile - 1)
kgV3_2 = Sequence(Points3_1(bspNenner1(bsp) + 1) + (i / anzahlTeile * (P6 - P5)), i, 1, anzahlTeile - 1)
segsKgv3 = Sequence(Segment[kgV3_1(i), kgV3_2(i)], i, 1, anzahlTeile - 1)
P7: Points3_1(bspNenner1(bsp)) + (1, 0)
P8: (x(P7), y(P7) - 2)
A4: (x(P7), y(P7))
B4: (x(A4 + 2), y(A4))
Points4_1 = Sequence(A4 + (i * Vector[A4, B4] / bspNenner1(bsp)), i, 0, bspNenner1(bsp))
C4: (x(A4), y(A4) - 2)
D4: (x(B4), y(C4))
Points4_2 = Sequence(C4 + (i * Vector[C4, D4] / bspNenner1(bsp)), i, 0, bspNenner1(bsp))
segs4 = Sequence(Segment[Points4_1(i), Points4_2(i)], i, 1, bspNenner1(bsp) + 1)
l = Segment(P7, Points4_1(bspNenner1(bsp) + 1))
m = Segment(P8, Points4_2(bspNenner1(bsp) + 1))
kgV4_1 = Sequence(P7 + (i / anzahlTeile * (P8 - P7)), i, 1, anzahlTeile - 1)
kgV4_2 = Sequence(Points4_1(bspNenner1(bsp) + 1) + (i / anzahlTeile * (P8 - P7)), i, 1, anzahlTeile - 1)
segsKgv4 = Sequence(Segment[kgV4_1(i), kgV4_2(i)], i, 1, anzahlTeile - 1)
poly3: {Polygon[P5, Points3_1(bspZaehler1(bsp) + 1), Points3_2(bspZaehler1(bsp) + 1), P6]}
text7: "\textsf{\frac{" + (LaTeX[bspZaehler1(bsp)]) + "}{" + (LaTeX[bspNenner1(bsp)]) + "} + \frac{" + (LaTeX[bspZaehler2(bsp)]) + "}{" + (LaTeX[bspNenner2(bsp)]) + "} = \frac{       }{" + (LaTeX[aInput]) + "} + \frac{       }{" + (LaTeX[aInput]) + "}}"
rectangleCorrect1: {Polygon[(-1.5, 0.3), (-1.5, 1.8), (-0.45, 1.8), (-0.45, 0.3)]}
rectangleCorrect2: {Polygon[(0.28, 0.3), (0.28, 1.8), (1.33, 1.8), (1.33, 0.3)]}
rectangleCorrect3: {Polygon[(2.28, -0.07), (2.28, 1.85), (3.33, 1.85), (3.33, -0.07)]}
rectangleCorrect4: {Polygon[(5.26, -0.07), (5.26, 1.85), (6.31, 1.85), (6.31, -0.07)]}
K = (8.1, 3.22)
poly5 = SpeechBubbleRight(K, 9.5, 1)
text1: "\textsf{Lass uns gemeinsam" + (LaTeX[If[questionCount > 1, " noch weitere ", " "]]) + "ungleichnamige Brüche addieren!}"
poly6 = SpeechBubbleLeft(E - (0, 0.8), 11.7, 1.7)
poly7 = SpeechBubbleRight(K, 10.3, 1.3)
text5: "\textsf{\bold{Finde das kleinste gemeinsames Vielfaches der Nenner " + (LaTeX[bspNenner1(bsp)]) + " und " + (LaTeX[bspNenner2(bsp)]) + ".}\\\\\\
Das kleinste gemeinsame Vielfache von " + (LaTeX[bspNenner1(bsp)]) + " und " + (LaTeX[bspNenner2(bsp)]) + " ist:"
PBubble = (7.74, 3.08)
poly8 = SpeechBubbleRight(PBubble, 10.8, 1.8)
saveInput = NaN
text19: "\textsf\colorbox{ebe7f8}{" + (LaTeX[saveInput]) + " ist ein Vielfaches von " + (LaTeX[bspNenner1(bsp)]) + " und " + (LaTeX[bspNenner2(bsp)]) + ".\vphantom{p}\\Versuche das kleinste gemeinsame\\Vielfache zu finden.}"
text6: "\textsf{Erweitere die Brüche so, dass sie den Nenner " + (LaTeX[aInput]) + " haben.}"
text12: "\textsf\bold{Überlege dir, wie viele Ganze in \frac{" + (LaTeX[zaehler]) + "}{" + (LaTeX[nenner]) + "} noch enthalten sind.}"
fixed: move ≟ 2 ∨ move ≟ 3 ∧ c1 ∧ (verfeinern ∧ bsp < 3 ∨ bsp > 2) ∨ move ≟ 4 ∧ cor1 ∨ move ≟ 5 ∧ cor2 ∧ (¬bspMitGanz) ∨ move ≟ 5 ∧ cor3 ∧ bspMitGanz ∨ move ≟ 6
text18: "\textsf{Aus der Addition ungleichnamiger Brüche haben wir\\gemeinsam die Addition gleichnamiger Brüche gemacht.\\" + (LaTeX[If[move ≟ 7, "\bold{Vervollständige den Merktext.}", ""]]) + "}"
poly9 = SpeechBubbleRight(K - (0, 0.5), 10.3, 1.8)
D1: (x(B1), y(C1))
PPlus = Midpoint(P1 + (2, 0), P3)
PGleich = Midpoint(P3 + (2, 0), P5)
btnLatex: "\textsf{" + (LaTeX[If[questionCount ≟ 1, "Los geht's!", "Weiter geht's!"]]) + "}"
text20: "\textsf{" + (LaTeX[questionCount]) + "/5}"
l9: {Polygon[Points3_1(3), Points3_1(4), Points3_2(4), Points3_2(3)]}
l10: {Polygon[Points4_1(1), Points4_1(3), (x(Points4_1(3)), y(kgV4_1(1))), (x(Points4_1(2)), y(kgV4_1(1))), Points4_2(2), Points4_2(1)]}
l6: {Polygon[Points3_1(2), Points3_1(3), (x(Points3_2(3)), y(kgV3_2(4))), (x(Points3_2(2)), y(kgV3_1(4)))]}

Tool: SpeechBubbleLeft
SpeechBubbleLeft(<Point>,<width>,<hight>)
Input: C, width, hight
Output: poly1

width: 5
hight: 2
C: (-2, 2)
BLLC: (x(C) + 0.2, y(C) + 1)
BLC = Rotate(BLLC, -40°, C)
BRC: (x(BLC) + width, y(BLC))
TLC: (x(BLLC), y(BLLC) + hight)
TRC: (x(BRC), y(TLC))
poly1, c, bllc, tlc, trc, brc, blc = Polygon(C, BLLC, TLC, TRC, BRC, BLC)

Tool: SpeechBubbleRight
SpeechBubbleRight(<Point>,<width>,<hight>)
Input: C, width, hight
Output: poly1

width: 5
hight: 2
C: (-2, 2)
BLLC: (x(C) - 0.2, y(C) + 1)
BLC = Rotate(BLLC, 40°, C)
BRC: (x(BLC) - width, y(BLC))
TLC: (x(BLLC), y(BLLC) + hight)
TRC: (x(BRC), y(TLC))
poly1, c, bllc, tlc, trc, brc, blc = Polygon(C, BLLC, TLC, TRC, BRC, BLC)