Schriftliche Division

[St.Pauli]

Hi,

ich bin dabei so Sachen wie schriftliche Addition, Multiplikation, etc. zu implentieren. So weit so gut. Alles klappt nur jetzt hänge ich bei der Division und weiß wirklich nicht mehr weiter.

Hier ist die Ausgangssituation. Ich habe 2 Arrays von 1..x bestehend aus 0..9. Nun will ich die beiden dividieren.
+, - und * waren einfach doch jetzt sitzte ich auf dem Trockenen.

Wie kann/muss ich da ran gehen?

PS: Suche hat mich nicht weitergebracht

[Christian18]

meinst du so???

Delphi-Quellcode:

zahl1 div zahl2

das gibts auch nocht

Delphi-Quellcode:

zahl1 / zahl2

die variablen kannst du auch durch arrays ersetzen. musst bloß den index dann richtig angeben.

[ManuMF]

Hallo,

mit MOD kannst du den "Rest" berechnen.

Gruß,
ManuMF

[St.Pauli]

Erstmal THX. Das ist mir schon klar, aber ich weiss nicht, wie ich das konkret anwenden muss...

Oder sitze ich gerade auf dem Schlauch?

[Kinimod8]

Entschuldingung, aber was meinst du mit "schriftliche Division". Das kenne ich nur auf dem Papier, nicht im Computer :gruebel:

[Christian18]

hie mal ein bsp mit deinen arrays

Delphi-Quellcode:

for i:=0 to 9 do
  begin
    a[i]:=b[i] div c[i];  // wenn du eine ganze Zahl raus haben willst
    a[i]:=b[i] / c[i];  // wenn du eine komma zahl haben willst --> genaue ergebnis
  end;

in array a wird immer das ergebnis aus der division von array b und c gespeichernt.

ich hoffe ich konnte dir weiter helfen.

mfg christian18

[DGL-luke]

ähm.. er will doch "schriftlich", also so wie als mensch, dividieren.

Also(Ich führe jetzt hier mal einen "Stack" ein, wenn auf den gepusht wird, heisst das, dass zu seinem wert addiert wird; ergebnis ist immer das ergebnis aus einer vorherigen operation):

-Vom Dividenden so viele ziffern auf den shiften(=vom anfang nehmen), bis die daraus sich ergebende zahl größer als der divisor ist, diese zahl auf den stack pushen
-stack durch divisor teilen, ergebnis brunden, ergebnis zum Ergebnisarray dazu, selbes ergebnis * divisor, ergebnis vom stack abziehen
-wieder vom dividenden shiften, auf den stack pushen bis stackwert größer als divisor
-wieder teilen

usw., bis du nicht mehr shiften kannst. das was dann noch im "Dividendenstack" übrig bleibt, ist dein rest.

ich werde das mal in code fassen, das ist ja hier eher wirr....

[St.Pauli]

Zitat:

Zitat von DGL-luke

-stack durch divisor teilen

Das wär schon das erste Problem. Ich kann nicht eine Zahl durch eine Zahl teilen, wenn ich gerade erst die Funktion dazu schreibe. :mrgreen: Das mag jetzt ein bisschen wirr vorkommen, aber wenn der Divisor zum Beispiel 51431435415415251541566240261341656264134313421323 12321468671795... wäre, bekäme ich mit den herkömmlichen Variabeln und Funktionen Probleme.

Hier mal der Ausgang. Zwei Zahlen vom Typ BigInt...

Delphi-Quellcode:

type
  Zahl   = 0..9; // Eine Dezimalstelle...
  BigInt = array [1..BigIntSize] of Zahl;

... wobei jede Stelle des arrays auch die Dezimalstelle der Zahl darstellt. Nun will ich 2 Zahlen vom Typ BigInt dividieren.

Also, nur noch mal kurz die Vorhergehensweise zusammengefasst:

• Als Grungerüst benutzte ich eine repeat-Schleife, bis der Zähler i null erreicht (?)
• Ich hole mir eine Zahl, beginnend von der größten Dezimalstelle ab, und füge die in ein Zwischen-Array ab. Hier stoße ich schon auf technische Umsetztungs-Probleme. :gruebel:
• Dann probiere ich in einer neuen Schleife, wie lange ich brauche, bis der Divisor größer ist als der Dividend. Die Anzahl der Schritte ist mein Zwischenergebnis. Der Dividend - den erhhöhten Divisor ist mein Rest.
• Dann muss ich wieder so lange Zahlen vom Dividend herunter holen, bis ich wieder teilen kann...

Habt ihr eine Idee, wie ich die Teile nun umsetzten kann? :gruebel:

[gfjs]

Vorschlag eines Anfängers (Pseudocode):

Aufgabe: x := a/b;

a,b,x : Double;
aInt,bInt,Rest, : Integer;
aStr,a1Str,a2Str,bStr,xStr : string;
n : integer (Anzahl der gewünschten Nachkommastellen des Ergebnisses)

aStr := FloatToStr(a); bStr := Float to Str(b);
Nachkommastellen von b ermitteln und in aStr den Dezimalpunkt um die entsprechenden Stellen nach rechts verschieben (evtl. mit Nullen auffüllen)
aStr aufteilen in a1Str(=Vorkomma-Anteil) und a2Str(=Nachkomma-Anteil)
aInt := IntToStr(a1String); bInt := IntToStr(bStr);
xStr := IntToStr(aInt DIV bInt) + '.'; // ergibt den ganzzahligen Anteil von x
Rest := aInt MOD bInt;
zum Rest solange die nächste Nachkommastelle (aus a2Str) bzw. eine Null anhängen, bis Rest DIV bInt > 0, Ergebis an xStr anhängen
und das ganze wieder von vorne, bis die gewünschte Zahl der Nachkommastellen von x erreicht ist.

Das sollte klappen - ich kann's aber nicht ausprobieren, da ich im Büro kein Delphi installiert habe.

mfg gfjs

[DGL-luke]

naja... also zwischendrin benutze ich ganz normal div und mod, das jetzt auhc noch selbstzuschrieben, wäre wohl ein wenig overdosed. ich häng mal den von mir produzierten Code an.

Leider ungetestet, da ich die Umwandlung von Zahl in Array noch nicht raus hab.