Quersum.-Berechnung

[Problemmacher]

Schönen Abend Liebe User!

Ich wollte euch darum bitten mir in der Hinsicht zu helfen,
wie ich eine Quersummenberechnung ohne Schleifen
realisieren könnte. Mit Schleifen hab ich schon vielerlei Lösungen
gesehen, doch ich würde gerne auch diesen sicherlich auch
eher umständlichen Weg versuchen und wissen wie sowas zu lösen wäre ...

Würde mich über Hilfe sehr freuen!

Liebe Grüße :)

[mkinzler]

Wenn du eine unbestimmte anzahl von Elementen hast, wirst du nicht ohne Schleife auskommen.

[jfheins]

Wie ich in dem anderen Thread schon gesagt habe, sind rekurive und iterative ansätze equivalent, du kannst das also beides verwenden. Falls du also keine Schleifen (iterativ) habn möchtest, probiers mal mit Rekursion ;)

[Problemmacher]

Da ich ziemlicher Anfänger in Delphi bin muss ich gestehen
unter Rekursion mir jetzt "programmtechnisch" nichts wirklich
erdenken zu können, was mir bei der Lösung des Problems helfen könnte.

Ich weiß nur das es so viel wie Zurücklaufen bedeutet, also das man
ein Problem "von hinten" angeht ... aber wie ich das in Delphi an
diesem Beispiel umsetze ... das weiß ich nicht :pale:

[jakobwenzel]

Für den Anfänger sind Schleifen einfacher als Rekursion, und ich sehe keinen Grund, hier keine Schleifen zu verwenden.

[alzaimar]

Rekursion bedeutet eher "Selbstbeinhaltung".

Also:

Code:

Quersumme einer Zahl:
  Wenn die Zahl = 0 dann 
     ist die Quersumme = 0
  sonst
     ist die Quersumme = Einerziffer der Zahl + Quersumme der Zahl ohne die Einerstelle

Wie Du siehst, enthält die Formulierung der Problemlösung den Lösungsansatz selbst, Rekursion zieht sich quasi an den eigenen Haaren aus dem Sumpf.

Versuch mal, diese rekursive Funktion zu implementieren. Dazu musst Du erst einmal zwei Fragen beantworten:
1. Wie bekomme ich die Einerziffer einer Zahl
2. Wie bekomme ich den Rest der Zahl (ohne Einerziffer)

Der Rest ist eigentlich nur eine Übersetzung des o.g. Algorithmus ins Englische... :zwinker:

[Cöster]

Zurücklaufen ist schon eine recht gute Übersetzung. Damit meint man aber, dass eine Funktion oder Prozedur sich selbst in ihrer Implementierung wieder aufruft. Dadurch "läuft" man also wieder an den Anfang der Methode "zurück", allerdings in einem anderen, neuen Aufruf.

[Problemmacher]

Naja ... mein Ansatz ist lediglich folgendes ...

Zahl DIV 10 ... dann hab ich die erste Ziffer raus
Zahl MOD 10 DIV 10 ... dann hab ich die zweite Ziffer raus

Aber mehr fällt mir dann auch nicht ein, woher soll man ohne Schleife
wissen wie viele Ziffern enthalten sind und wie verfahre ich nun
im weiteren wenn es um das Herausfinden der dritten Zahl etc. geht?

[Flare]

Du machst es so, wie es alzaimer gesagt hat :zwinker:

Zuerst prüfst du in deiner Funktion ob die Zahl größer als 10 ist, wenn nicht, dann brauchst du auch keine Quersumme zu bilden! Wenn sie größer als 10 ist, dann rechnest du (zahl mod 10) + deine_funktion(zahl div 10). Die Funktion deine_funktion ist natürlich der name deiner Quersummenfunktion und dort ist auch gleichzeitig die Rekursion! Du übergibst nämlich beim neuen Aufruf nur noch alle Stellen, außer die letzte. Und wenn du das ganze zu ende überlegst müsstest du dann wissen was am Ende rauskommt :wink:


Flare

[capo]

Delphi-Quellcode:

 function QuerSumme(strNumber : String): Longint;
var 
  chTmp : Char;   // Einzelnes Zeichen des Textes 
  i,                // Laufvariable für die Schleife 
  iLen,             // Länge des Textes 
  iTmp,             // Zwischenspeicher für den Zahlwet der einzelnen Zahlen 
  iSumme : Longint; // QuerSumme
begin
  // Summe auf Null setzen 
  iSumme := 0; 
  // Länge des Text ermitteln 
  iLen  := Length(strNumber); 
  // Try except zur Sicherheit, den bei einem Text wie :'123A' würde ohne
  // try except das Programm abstürzen.
  try 
    // jedes Zeichen des Textes einzelnd in eine Zahl umwandeln und summieren 
    For i:= 1 to iLen do begin 
      // das Zeichen an der Position i im Text ermitten 
      chTmp := strNumber[i]; 
      iTmp  := StrtoInt(chTmp); 
      // Wert auf die Summe addieren 
      inc(iSumme,iTmp); // ist das Gleiche wie : iSumme := iSumme + iTmp; nur schneller 
    end; 
    result := iSumme; 
  except 
    // falls ein Fehler beim umwandeln vom Text in eine Zahl auftritt wird 
    // dieser hier abgefangen. Je nach Compilereinstellungen siehst Du im 
    // in Delphi noch eine Exception, aber in der Compilierten Exe wird keine 
    // Exception mehr ausgegeben 
    result := 0; 
  end; 
end;

Das hilft dir mit Sicherheit weiter.

Grüße
capo