Komma / Punkt

\textcolor{#ffffff}

\textcolor{#ff0000}

\textcolor{#00ffff}

Schriftliche Addition

Werner Knobloch, 2013

\mathbf {Hinweis:\;} VStellen_{max} = 0 \text  { lässt ausnahmsweise den Vorstellenwert 1 zu, wenn die Nachkommastellen alle 0 sind.}

F9: neue Aufgabe

Addition / Subtraktion

Schriftliche Subtraktion

Trennlängenfaktor = 0.7
NStellen_{max} = 6 (slider from 0 to 6, step 1)
N = 9 (slider from 2 to 12, step 1)
NListe1Stellenzahl = Sequence(Random[0, NStellen_{max}], j, 1, N)
NListe2 = Sequence(Random[1, 10^(Element[NListe1Stellenzahl, j])] - 1, j, 1, N)
NListeZähler1 = Sequence(Length[Text[Element[NListe2, j]]], j, 1, N)
NListe5 = Sequence(Reverse[Sequence[Mod[Div[Element[NListe2, k], 10^(Element[NListeZähler1, k] - j)], 10], j, 1, Element[NListeZähler1, k]]], k, 1, N)
NListe6 = Sequence(Sequence["\;" + (Element[Element[NListe5, j], k]), k, 1, Element[NListeZähler1, j]], j, 1, N)
NListe7 = Sequence(Sum[Element[NListe6, j]], j, 1, N)
Startliste = Sequence(If[Element[NListe2, j]  <  1, 1, 0], j, 1, N)
Komma = true
Zeichen = If(Komma, ",", ".")
VStellen_{max} = 4 (slider from 0 to 5, step 1)
VListe1Stellenzahl = Sequence(Random[0, VStellen_{max}], j, 1, N)
VListe2 = Sequence(Random[Element[Startliste, j], Element[Startliste, j] + 10^(Element[VListe1Stellenzahl, j]) - 1], j, 1, N)
VListe4 = Sequence(Text[Element[VListe2, j]], j, 1, N)
VListeZähler1 = Sequence(Length[Text[Element[VListe4, j]]], j, 1, N)
VListe5 = Sequence(Sequence[Mod[Div[Element[VListe2, k], 10^(Element[VListeZähler1, k] - j)], 10], j, 1, Element[VListeZähler1, k]], k, 1, N)
VListe6 = Sequence(Sequence["\;" + (Element[Element[VListe5, k], j]), j, 1, Element[VListeZähler1, k]], k, 1, N)
VListe7 = Sequence(Sum[Element[VListe6, j]], j, 1, N)
SummandenListe = Sequence(If[Element[NListe1Stellenzahl, k]  <  1, Element[VListe7, k], Sum[{Element[VListe7, k], Zeichen, Element[NListe7, k]}]], k, 1, N)
VStellen_{Min} = Max(VStellen_{max}, 1)
Startspalte = 5
MÜbertragTeilfolgen = Sequence(Sequence[Cell[j, 10], j, 1, k], k, 1, Startspalte + VStellen_{max})
MÜbertragTeilsummen = Sequence(Sum[Element[MÜbertragTeilfolgen, j]], j, 1, Startspalte + VStellen_{max})
MVornullen_Ü = CountIf(x  <  1, MÜbertragTeilsummen)
MVorkommaLänge_Ü: Startspalte + VStellen_{Min} - MVornullen_Ü
VorkommaEnde: Startspalte + VStellen_{Min}
MVorkommaListe_{Ü0} = Sequence(Cell[j, 10], j, 1, VorkommaEnde)
MVorkommaListe_{Ü1} = Last(MVorkommaListe_{Ü0}, MVorkommaLänge_Ü)
MEntfVorkommaÜ = Sequence(If[Element[MVorkommaListe_{Ü1}, k]  <  1, ColorWhite, ""], k, 1, MVorkommaLänge_Ü)
FüllstellenAdd = Max(NListeZähler1 - Startliste)
ErgebnisTeilfolgen = Sequence(Sequence[Cell[j, 5], j, 1, k], k, 1, Startspalte + VStellen_{max})
ErgebnisTeilsummen = Sequence(Sum[Element[ErgebnisTeilfolgen, j]], j, 1, Startspalte + VStellen_{max})
Vornullen_E = CountIf(x  <  1, ErgebnisTeilsummen)
VorkommaLänge_E = Max(Startspalte + VStellen_{Min} - Vornullen_E, 1)
VorkommaLänge_Ü = Max(VorkommaLänge_E, 1)
NachkommaE_1: Startspalte + VStellen_{Min} + FüllstellenAdd
NachkommaE_0: Startspalte + VStellen_{Min} + 1
NÜLänge = Max(NachkommaE_1 - NachkommaE_0 + 1, 1)
MNachkommaListe_{Ü1} = Sequence(Cell[j, 10], j, NachkommaE_0, NachkommaE_1)
MEntfNachkommaÜ = Sequence(If[Element[MNachkommaListe_{Ü1}, k]  <  1, ColorWhite, ""], k, 1, NÜLänge)
MNachkommaText_{Ü0} = Sequence("\;" + (Element[MEntfNachkommaÜ, k]) + (Element[MNachkommaListe_{Ü1}, k]), k, 1, NÜLänge)
MNachkommaText_Ü = If(NStellen_{max}  <  2, Element[MNachkommaText_{Ü0}, 1], Sum[MNachkommaText_{Ü0}])
VorkommaListe_{Ü0} = Sequence(Cell[j, 3], j, 1, VorkommaEnde)
VorkommaListe_{Ü1} = Last(VorkommaListe_{Ü0}, VorkommaLänge_Ü)
EntfVorkommaÜ = Sequence(If[Element[VorkommaListe_{Ü1}, k]  <  1, ColorWhite, ""], k, 1, VorkommaLänge_Ü)
MVorkommaText_{Ü0} = Sequence("\;" + (Element[MEntfVorkommaÜ, k]) + (Element[MVorkommaListe_{Ü1}, k]), k, 1, MVorkommaLänge_Ü)
MVorkommaText_Ü = Sum(MVorkommaText_{Ü0})
NFüll_{max} = Sum(Sequence["\;0", j, 1, NStellen_{max}])
NStellenzahlMinuend = Random(0, FüllstellenAdd)
NStellenMinuend = Random(0, 10^(NStellenzahlMinuend) - 1)
MNListe5 = Reverse(Sequence[Mod[Div[NStellenMinuend, 10^(NStellenzahlMinuend - j)], 10], j, 1, NStellenzahlMinuend])
NListe7F = Sequence(First[Element[NListe7, j] + NFüll_{max}, (3 * FüllstellenAdd)], j, 1, N)
NFüller = Sequence(0, j, 1, NStellen_{max})
MNListe5F = First(Join[{MNListe5, NFüller}], FüllstellenAdd)
MNListe6F = Sequence("\;" + (Element[MNListe5F, k]), k, 1, FüllstellenAdd)
MNTexfF = Sum(MNListe6F)
DErgebnisTeilfolgen = Sequence(Sequence[Cell[j, 16], j, 1, k], k, 1, Startspalte + VStellen_{max})
DErgebnisTeilsummen = Sequence(Sum[Element[DErgebnisTeilfolgen, j]], j, 1, Startspalte + VStellen_{max})
Vornullen_D = CountIf(x  <  1, DErgebnisTeilsummen)
ProvSumme: Sum[VListe2] + 10
ProvMinuend: ProvSumme + N + Random[1, ProvSumme]
VMinuendZähler = Length(Text[ProvMinuend])
MVListe5 = Sequence(Mod[Div[ProvMinuend, 10^(VMinuendZähler - j)], 10], j, 1, VMinuendZähler)
MVListe6 = Sequence("\;" + (Element[MVListe5, k]), k, 1, VMinuendZähler)
MVText = Sum(MVListe6)
MTextF = If(FüllstellenAdd  <  1, MVText, MVText + Zeichen + MNTexfF)
MTrennLänge2: (Trennlängenfaktor * (Div[Length[MTextF], 3] + 3))
MTrenn2 = Sum(Sequence[" -", j, 1, MTrennLänge2])
MSummandenListeF = Sequence(If[(NStellen_{max} * FüllstellenAdd)  <  1, ColorRed + "{" + (Element[VListe7, k]) + "}", ColorRed + "{" + (Element[VListe7, k]) + Zeichen + (Element[NListe7F, k]) + "}"], k, 1, N)
VorkommaLänge_D = Max(Startspalte + VStellen_{Min} - Vornullen_D, 1)
NachkommaText_D = If(NStellen_{max}  <  1, "", Sum[Sequence[Text[("\;" * Cell[j, 16])], j, NachkommaE_0, NachkommaE_1]])
MÜbertragText_0 = If((NStellen_{max} * FüllstellenAdd)  <  1, {MVorkommaText_Ü}, {MVorkommaText_Ü, (ColorWhite * Zeichen), MNachkommaText_Ü})
MÜbertragText: ColorZyan + "{" + (Sum[MÜbertragText_0]) + "}"
VorkommaListe_{D0} = Sequence(Cell[j, 16], j, 1, VorkommaEnde)
VorkommaListe_{D1} = Last(VorkommaListe_{D0}, VorkommaLänge_D)
VorkommaText_{D0} = Sequence(Text[("\;" * Element[VorkommaListe_{D1}, j])], j, 1, VorkommaLänge_D)
VorkommaText_D = Sum(VorkommaText_{D0})
DErgebnisText_0 = If((NStellen_{max} * FüllstellenAdd)  <  1, {VorkommaText_D}, {VorkommaText_D, Zeichen, NachkommaText_D})
DErgebnisText = Sum(DErgebnisText_0)
Startfüllung = Sequence(0, j, 1, Startspalte)
MVDummy = Sequence(0, j, 1, Startspalte + VStellen_{max})
VFüller = Sequence(0, j, 1, VStellen_{max} + 1)
Zeilenlänge: Max[VStellen_{max}, 1] + FüllstellenAdd
Nachlistegefüllt = Sequence(First[Join[{Element[NListe5, j], NFüller}], FüllstellenAdd], j, 1, N)
Vorlistegefüllt = Sequence(Last[Join[{VFüller, Element[VListe5, j]}], VStellen_{Min}], j, 1, N)
GeneratorNeu = Sequence(Join[{Element[Vorlistegefüllt, j], Element[Nachlistegefüllt, j]}], j, 1, N)
Spaltensummen_0 = Sequence(Sum[Sequence[Element[GeneratorNeu, j, k], j, 1, N]], k, 1, Zeilenlänge)
MVListe5b = Last(Flatten[Append[MVDummy, MVListe5]], VorkommaEnde)
Zwanzig = 20
Endlistenlänge: Zwanzig - Zeilenlänge - Startspalte
Endliste = Sequence(0, j, 1, Endlistenlänge)
Spaltensummen_1 = Flatten(Append[Append[Startfüllung, Spaltensummen_0], Endliste])
MNDummy = Sequence(0, j, 1, Zwanzig - Startspalte - VStellen_{max})
MNListe5b = First(Flatten[Append[MNListe5, MNDummy]], Zwanzig - VorkommaEnde)
MListeZwanzig = Flatten(Append[MVListe5b, MNListe5b])
A1 = 1
B1: A1 + 1
C1: B1 + 1
D1: C1 + 1
D9 = Element(Spaltensummen_1, D1)
E1: D1 + 1
E9 = Element(Spaltensummen_1, E1)
E7 = Element(MListeZwanzig, E1)
F1: E1 + 1
F9 = Element(Spaltensummen_1, F1)
F7 = Element(MListeZwanzig, F1)
G1: F1 + 1
G9 = Element(Spaltensummen_1, G1)
G7 = Element(MListeZwanzig, G1)
H1: G1 + 1
H9 = Element(Spaltensummen_1, H1)
H7 = Element(MListeZwanzig, H1)
I1: H1 + 1
I9 = Element(Spaltensummen_1, I1)
I7 = Element(MListeZwanzig, I1)
J1: I1 + 1
J9 = Element(Spaltensummen_1, J1)
J7 = Element(MListeZwanzig, J1)
K1: J1 + 1
K9 = Element(Spaltensummen_1, K1)
K7 = Element(MListeZwanzig, K1)
L1: K1 + 1
L9 = Element(Spaltensummen_1, L1)
L7 = Element(MListeZwanzig, L1)
M1: L1 + 1
M9 = Element(Spaltensummen_1, M1)
M7 = Element(MListeZwanzig, M1)
N1: M1 + 1
N9 = Element(Spaltensummen_1, N1)
N7 = Element(MListeZwanzig, N1)
O1: N1 + 1
O9 = Element(Spaltensummen_1, O1)
O7 = Element(MListeZwanzig, O1)
P1: O1 + 1
P9 = Element(Spaltensummen_1, P1)
P7 = Element(MListeZwanzig, P1)
Q1: P1 + 1
Q9 = Element(Spaltensummen_1, Q1)
Q7 = Element(MListeZwanzig, Q1)
R1: Q1 + 1
R9 = Element(Spaltensummen_1, R1)
R7 = Element(MListeZwanzig, R1)
S1: R1 + 1
S9 = Element(Spaltensummen_1, S1)
S7 = Element(MListeZwanzig, S1)
T1: S1 + 1
T9 = Element(Spaltensummen_1, T1)
T7 = Element(MListeZwanzig, T1)
T10 = 0
T11: T10 + T9
T14: (Div[T11, 10] * 10)
T15: T14 + 10
T12 = Mod(T11, 10)
T13 = If(T12 ≤ T7, T14, T15)
S10: T13 / 10
S11: S10 + S9
S14: (Div[S11, 10] * 10)
S15: S14 + 10
S12 = Mod(S11, 10)
S13 = If(S12 ≤ S7, S14, S15)
R10: S13 / 10
R11: R10 + R9
R14: (Div[R11, 10] * 10)
R15: R14 + 10
R12 = Mod(R11, 10)
R13 = If(R12 ≤ R7, R14, R15)
Q10: R13 / 10
Q11: Q10 + Q9
Q14: (Div[Q11, 10] * 10)
Q15: Q14 + 10
Q12 = Mod(Q11, 10)
Q13 = If(Q12 ≤ Q7, Q14, Q15)
P10: Q13 / 10
P11: P10 + P9
P14: (Div[P11, 10] * 10)
P15: P14 + 10
P12 = Mod(P11, 10)
P13 = If(P12 ≤ P7, P14, P15)
O10: P13 / 10
O11: O10 + O9
O14: (Div[O11, 10] * 10)
O15: O14 + 10
O12 = Mod(O11, 10)
O13 = If(O12 ≤ O7, O14, O15)
N10: O13 / 10
N11: N10 + N9
N14: (Div[N11, 10] * 10)
N15: N14 + 10
N12 = Mod(N11, 10)
N13 = If(N12 ≤ N7, N14, N15)
M10: N13 / 10
M11: M10 + M9
M14: (Div[M11, 10] * 10)
M15: M14 + 10
M12 = Mod(M11, 10)
M13 = If(M12 ≤ M7, M14, M15)
L10: M13 / 10
L11: L10 + L9
L14: (Div[L11, 10] * 10)
L15: L14 + 10
L12 = Mod(L11, 10)
L13 = If(L12 ≤ L7, L14, L15)
K10: L13 / 10
K11: K10 + K9
K14: (Div[K11, 10] * 10)
K15: K14 + 10
K12 = Mod(K11, 10)
K13 = If(K12 ≤ K7, K14, K15)
J10: K13 / 10
J11: J10 + J9
J14: (Div[J11, 10] * 10)
J15: J14 + 10
J12 = Mod(J11, 10)
J13 = If(J12 ≤ J7, J14, J15)
I10: J13 / 10
I11: I10 + I9
I14: (Div[I11, 10] * 10)
I15: I14 + 10
I12 = Mod(I11, 10)
I13 = If(I12 ≤ I7, I14, I15)
H10: I13 / 10
H11: H10 + H9
H14: (Div[H11, 10] * 10)
H15: H14 + 10
H12 = Mod(H11, 10)
H13 = If(H12 ≤ H7, H14, H15)
G10: H13 / 10
G11: G10 + G9
G14: (Div[G11, 10] * 10)
G15: G14 + 10
G12 = Mod(G11, 10)
G13 = If(G12 ≤ G7, G14, G15)
F10: G13 / 10
F11: F10 + F9
F14: (Div[F11, 10] * 10)
F15: F14 + 10
F12 = Mod(F11, 10)
F13 = If(F12 ≤ F7, F14, F15)
E10: F13 / 10
E11: E10 + E9
E14: (Div[E11, 10] * 10)
E15: E14 + 10
E12 = Mod(E11, 10)
E13 = If(E12 ≤ E7, E14, E15)
D10: E13 / 10
D11: D10 + D9
C7 = Element(MListeZwanzig, C1)
D7 = Element(MListeZwanzig, D1)
D12 = Mod(D11, 10)
B9 = Element(Spaltensummen_1, B1)
D14: (Div[D11, 10] * 10)
D15: D14 + 10
D13 = If(D12 ≤ D7, D14, D15)
C10: D13 / 10
C9 = Element(Spaltensummen_1, C1)
C11: C10 + C9
C12 = Mod(C11, 10)
C14: (Div[C11, 10] * 10)
C15: C14 + 10
C13 = If(C12 ≤ C7, C14, C15)
B10: C13 / 10
B11: B10 + B9
B14: (Div[B11, 10] * 10)
B15: B14 + 10
B12 = Mod(B11, 10)
B7 = Element(MListeZwanzig, B1)
VorkommaListe_{E0} = Sequence(Cell[j, 5], j, 1, VorkommaEnde)
VorkommaListe_{E1} = Last(VorkommaListe_{E0}, VorkommaLänge_E)
VorkommaText_{E0} = Sequence(Text[("\;" * Element[VorkommaListe_{E1}, j])], j, 1, VorkommaLänge_E)
VorkommaText_E = Sum(VorkommaText_{E0})
VorkommaText_{Ü0} = Sequence("\;" + (Element[EntfVorkommaÜ, k]) + (Element[VorkommaListe_{Ü1}, k]), k, 1, VorkommaLänge_Ü)
VorkommaText_Ü = Sum(VorkommaText_{Ü0})
NachkommaListe_{Ü1} = Sequence(Cell[j, 3], j, NachkommaE_0, NachkommaE_1)
EntfNachkommaÜ = Sequence(If[Element[NachkommaListe_{Ü1}, k]  <  1, ColorWhite, ""], k, 1, NÜLänge)
NachkommaText_{Ü0} = Sequence("\;" + (Element[EntfNachkommaÜ, k]) + (Element[NachkommaListe_{Ü1}, k]), k, 1, NÜLänge)
NachkommaText_Ü = If(NStellen_{max}  <  2, Element[NachkommaText_{Ü0}, 1], Sum[NachkommaText_{Ü0}])
ÜbertragText_0 = If((NStellen_{max} * FüllstellenAdd)  <  1, {VorkommaText_Ü}, {VorkommaText_Ü, (ColorWhite * Zeichen), NachkommaText_Ü})
ÜbertragText: "" + ColorZyan + "{" + (Sum[ÜbertragText_0]) + "}"
NachkommaText_E = If(NStellen_{max}  <  1, "", Sum[Sequence[Text[("\;" * Cell[j, 5])], j, NachkommaE_0, NachkommaE_1]])
ErgebnisText_0 = If((NStellen_{max} * FüllstellenAdd)  <  1, {VorkommaText_E}, {VorkommaText_E, Zeichen, NachkommaText_E})
ErgebnisText = Sum(ErgebnisText_0)
TrennLänge2: (Trennlängenfaktor * (Length[ErgebnisText] / 2 - 2))
Trenn2 = Sum(Sequence[" -", j, 1, TrennLänge2])
TrennLänge: (Trennlängenfaktor * (Max[Sequence[Length[Element[SummandenListe, j]], j, 1, N]] / 2 - 1))
SummandenListeF = Sequence(If[(NStellen_{max} * FüllstellenAdd)  <  1, Element[VListe7, k], Element[VListe7, k] + Zeichen + (Element[NListe7F, k])], k, 1, N)
Trenn = Sum(Sequence[" -", j, 1, TrennLänge])
T3 = 0
T4: Element[Spaltensummen_1, T1] + T3
T5 = Mod(T4, 10)
S3: (T4 - T5) / 10
S4: Element[Spaltensummen_1, S1] + S3
S5 = Mod(S4, 10)
R3: (S4 - S5) / 10
R4: Element[Spaltensummen_1, R1] + R3
R5 = Mod(R4, 10)
Q3: (R4 - R5) / 10
Q4: Element[Spaltensummen_1, Q1] + Q3
Q5 = Mod(Q4, 10)
P3: (Q4 - Q5) / 10
P4: Element[Spaltensummen_1, P1] + P3
P5 = Mod(P4, 10)
O3: (P4 - P5) / 10
O4: Element[Spaltensummen_1, O1] + O3
O5 = Mod(O4, 10)
N3: (O4 - O5) / 10
N4: Element[Spaltensummen_1, N1] + N3
N5 = Mod(N4, 10)
M3: (N4 - N5) / 10
M4: Element[Spaltensummen_1, M1] + M3
M5 = Mod(M4, 10)
L3: (M4 - M5) / 10
L4: Element[Spaltensummen_1, L1] + L3
L5 = Mod(L4, 10)
K3: (L4 - L5) / 10
K4: Element[Spaltensummen_1, K1] + K3
K5 = Mod(K4, 10)
J3: (K4 - K5) / 10
J4: Element[Spaltensummen_1, J1] + J3
J5 = Mod(J4, 10)
I3: (J4 - J5) / 10
I4: Element[Spaltensummen_1, I1] + I3
I5 = Mod(I4, 10)
H3: (I4 - I5) / 10
H4: Element[Spaltensummen_1, H1] + H3
H5 = Mod(H4, 10)
G3: (H4 - H5) / 10
G4: Element[Spaltensummen_1, G1] + G3
G5 = Mod(G4, 10)
F3: (G4 - G5) / 10
F4: Element[Spaltensummen_1, F1] + F3
F5 = Mod(F4, 10)
E3: (F4 - F5) / 10
E4: Element[Spaltensummen_1, E1] + E3
E5 = Mod(E4, 10)
D3: (E4 - E5) / 10
D4: Element[Spaltensummen_1, D1] + D3
D5 = Mod(D4, 10)
C3: (D4 - D5) / 10
C4: Element[Spaltensummen_1, C1] + C3
j = 1 (slider from -5 to 5, step 1)
k = 1 (slider from -5 to 5, step 1)
Kolonne_0 = Append(SummandenListe, Trenn)
Text1 = TableText({Kolonne_0}, "vr")
Tab_1 = Sequence(k, k, 1, VStellen_{Min})
Tab_2 = Sequence((-k), k, 1, NStellen_{max})
Stellenposition = Flatten(Append[Append[Append[Startfüllung, Tab_1], Tab_2], Endliste])
A2 = Element(Stellenposition, A1)
B2 = Element(Stellenposition, B1)
C2 = Element(Stellenposition, C1)
D2 = Element(Stellenposition, D1)
E2 = Element(Stellenposition, E1)
F2 = Element(Stellenposition, F1)
G2 = Element(Stellenposition, G1)
H2 = Element(Stellenposition, H1)
I2 = Element(Stellenposition, I1)
J2 = Element(Stellenposition, J1)
K2 = Element(Stellenposition, K1)
L2 = Element(Stellenposition, L1)
M2 = Element(Stellenposition, M1)
N2 = Element(Stellenposition, N1)
O2 = Element(Stellenposition, O1)
P2 = Element(Stellenposition, P1)
Q2 = Element(Stellenposition, Q1)
R2 = Element(Stellenposition, R1)
S2 = Element(Stellenposition, S1)
T2 = Element(Stellenposition, T1)
C5 = Mod(C4, 10)
B3: (C4 - C5) / 10
B4: Element[Spaltensummen_1, B1] + B3
B5 = Mod(B4, 10)
A3: (B4 - B5) / 10
A4: Element[Spaltensummen_1, C1] + C3
A5 = Mod(C4, 10)
Kolonne_2 = Append(Append[SummandenListeF, Trenn], ErgebnisText)
Übertrag = true
Lösung = true
Kolonne_1 = Append(Append[Append[SummandenListeF, ÜbertragText], Trenn2], ErgebnisText)
ÜRelevanz = Sum(Join[{VorkommaListe_{Ü1}, NachkommaListe_{Ü1}}])
Text2 = TableText({If[Übertrag ∧ (ÜRelevanz > 0), Kolonne_1, Kolonne_2]}, "vr")
MNListe6 = Sequence("\;" + (Element[MNListe5, k]), k, 1, NStellenzahlMinuend)
MNText = Sum(MNListe6)
MText = If(NStellenzahlMinuend  <  1, MVText, MVText + Zeichen + MNText)
A7 = Element(MListeZwanzig, A1)
A8 = Element(Stellenposition, A1)
B8 = Element(Stellenposition, B1)
C8 = Element(Stellenposition, C1)
D8 = Element(Stellenposition, D1)
E8 = Element(Stellenposition, E1)
F8 = Element(Stellenposition, F1)
G8 = Element(Stellenposition, G1)
H8 = Element(Stellenposition, H1)
I8 = Element(Stellenposition, I1)
J8 = Element(Stellenposition, J1)
K8 = Element(Stellenposition, K1)
L8 = Element(Stellenposition, L1)
M8 = Element(Stellenposition, M1)
N8 = Element(Stellenposition, N1)
O8 = Element(Stellenposition, O1)
P8 = Element(Stellenposition, P1)
Q8 = Element(Stellenposition, Q1)
R8 = Element(Stellenposition, R1)
S8 = Element(Stellenposition, S1)
T8 = Element(Stellenposition, T1)
A9 = Element(Spaltensummen_1, A1)
B13 = If(B12 ≤ B7, B14, B15)
A10: B13 / 10
A11: S10 + S9
A14: (Div[S11, 10] * 10)
A15: S14 + 10
A13 = If(S12 ≤ S7, S14, S15)
G16: G13 + G7 - G11
A16: A13 + A7 - A11
B16: B13 + B7 - B11
C16: C13 + C7 - C11
D16: D13 + D7 - D11
E16: E13 + E7 - E11
F16: F13 + F7 - F11
H16: H13 + H7 - H11
I16: I13 + I7 - I11
J16: J13 + J7 - J11
K16: K13 + K7 - K11
L16: L13 + L7 - L11
M16: M13 + M7 - M11
N16: N13 + N7 - N11
O16: O13 + O7 - O11
P16: P13 + P7 - P11
R16: R13 + R7 - R11
S16: S13 + S7 - S11
Q16: Q13 + Q7 - Q11
A12 = Mod(A11, 10)
T16: T13 + T7 - T11
MSummandenListe = Sequence(If[Element[NListe1Stellenzahl, k]  <  1, ColorRed + "{" + (Element[VListe7, k]) + "}", ColorRed + "{" + (Element[VListe7, k]) + Zeichen + (Element[NListe7, k]) + "}"], k, 1, N)
MTrennLänge: (Trennlängenfaktor * (Div[Max[Length[MText], Max[Sequence[Length[Element[SummandenListe, j]], j, 1, N]]], 3] + 3))
MTrenn = Sum(Sequence[" -", j, 1, MTrennLänge])
MKolonne_0 = Append(MText, Append[MSummandenListe, MTrenn])
MKolonne_2 = Append(MTextF, Append[Append[MSummandenListeF, MTrenn2], DErgebnisText])
Text6 = TableText({MKolonne_0}, "vr")
DÜRelevanz = Sum(Join[{MVorkommaListe_{Ü1}, MNachkommaListe_{Ü1}}])
MKolonne_1 = Append(MTextF, Append[Append[Append[MSummandenListeF, MÜbertragText], MTrenn2], DErgebnisText])
Text19 = TableText({If[Übertrag ∧ (DÜRelevanz > 0), MKolonne_1, MKolonne_2]}, "vr")
MListe = Join({MVListe5, MNListe5F})
KontrollSumme: (Sum[Sequence[Sum[Sequence[(Element[GeneratorNeu, k, j] * 10^(Zeilenlänge - j)), j, 1, Zeilenlänge]], k, 1, N]] * 10^((-FüllstellenAdd)))
MLänge = Length(MListe)
KontrollMinuend: (Sum[Sequence[(Element[MListe, j] * 10^(MLänge - j)), j, 1, MLänge]] * 10^((-FüllstellenAdd)))
KontrollDifferenz: KontrollMinuend - KontrollSumme
Text20 = TableText({{LaTeX[KontrollMinuend, true, true]}, {LaTeX[KontrollSumme, true, true]}, {LaTeX[KontrollDifferenz, true, true]}})
Text23 = LaTeX(KontrollSumme, true, true)
Addition = false
Hinweis = true