Komma / Punkt

\textcolor{#ffffff}

\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

Trennlängenfaktor = 0.7
N = 10 (slider from 2 to 12, step 1)
NStellen_{max} = 5 (slider from 0 to 6, step 1)
NListe1Stellenzahl = Sequence(Random[0, NStellen_{max}], j, 1, N)
NListe2 = Sequence(Random[1, 10^(Element[NListe1Stellenzahl, j])] - 1, j, 1, N)
Startliste = Sequence(If[Element[NListe2, j]  <  1, 1, 0], 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)
VStellen_{max} = 5 (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)
Komma = true
Zeichen = If(Komma, ",", ".")
SummandenListe = Sequence(If[Element[NListe1Stellenzahl, k]  <  1, Element[VListe7, k], Sum[{Element[VListe7, k], Zeichen, Element[NListe7, k]}]], k, 1, N)
Startspalte = 5
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)
VStellen_{Min} = Max(VStellen_{max}, 1)
NachkommaE_0: Startspalte + VStellen_{Min} + 1
VorkommaLänge_E = Max(Startspalte + VStellen_{Min} - Vornullen_E, 1)
VorkommaLänge_Ü = Max(VorkommaLänge_E, 1)
VorkommaEnde: Startspalte + VStellen_{Min}
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})
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_Ü)
VorkommaText_{Ü0} = Sequence("\;" + (Element[EntfVorkommaÜ, k]) + (Element[VorkommaListe_{Ü1}, k]), k, 1, VorkommaLänge_Ü)
VorkommaText_Ü = Sum(VorkommaText_{Ü0})
NFüll_{max} = Sum(Sequence["\;0", j, 1, NStellen_{max}])
FüllstellenAdd = Max(NListeZähler1 - Startliste)
NListe7F = Sequence(First[Element[NListe7, j] + NFüll_{max}, (3 * FüllstellenAdd)], j, 1, N)
NachkommaE_1: Startspalte + VStellen_{Min} + FüllstellenAdd
NachkommaListe_{Ü1} = Sequence(Cell[j, 3], j, NachkommaE_0, NachkommaE_1)
NÜLänge = Max(NachkommaE_1 - NachkommaE_0 + 1, 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])
SummandenListeF = Sequence(If[(NStellen_{max} * FüllstellenAdd)  <  1, Element[VListe7, k], Element[VListe7, k] + Zeichen + (Element[NListe7F, k])], k, 1, N)
TrennLänge: (Trennlängenfaktor * (Max[Sequence[Length[Element[SummandenListe, j]], j, 1, N]] / 2 - 1))
VFüller = Sequence(0, j, 1, VStellen_{max} + 1)
Trenn = Sum(Sequence[" -", j, 1, TrennLänge])
Startfüllung = Sequence(0, j, 1, Startspalte)
MVDummy = Sequence(0, j, 1, Startspalte + VStellen_{max})
Zeilenlänge: Max[VStellen_{max}, 1] + FüllstellenAdd
NFüller = Sequence(0, j, 1, NStellen_{max})
Vorlistegefüllt = Sequence(Last[Join[{VFüller, Element[VListe5, j]}], VStellen_{Min}], j, 1, N)
Nachlistegefüllt = Sequence(First[Join[{Element[NListe5, j], NFüller}], FüllstellenAdd], j, 1, N)
GeneratorNeu = Sequence(Join[{Element[Vorlistegefüllt, j], Element[Nachlistegefüllt, j]}], j, 1, N)
Zwanzig = 20
Endlistenlänge: Zwanzig - Zeilenlänge - Startspalte
Endliste = Sequence(0, j, 1, Endlistenlänge)
MNDummy = Sequence(0, j, 1, Zwanzig - Startspalte - VStellen_{max})
A1 = 1
B1: A1 + 1
C1: B1 + 1
D1: C1 + 1
E1: D1 + 1
F1: E1 + 1
G1: F1 + 1
H1: G1 + 1
I1: H1 + 1
J1: I1 + 1
K1: J1 + 1
L1: K1 + 1
M1: L1 + 1
N1: M1 + 1
O1: N1 + 1
P1: O1 + 1
Q1: P1 + 1
R1: Q1 + 1
S1: R1 + 1
T1: S1 + 1
T3 = 0
Spaltensummen_0 = Sequence(Sum[Sequence[Element[GeneratorNeu, j, k], j, 1, N]], k, 1, Zeilenlänge)
Spaltensummen_1 = Flatten(Append[Append[Startfüllung, Spaltensummen_0], Endliste])
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")
KontrollSumme: (Sum[Sequence[Sum[Sequence[(Element[GeneratorNeu, k, j] * 10^(Zeilenlänge - j)), j, 1, Zeilenlänge]], k, 1, N]] * 10^((-FüllstellenAdd)))
Text6 = LaTeX(KontrollSumme, true, true)
Hinweis = true