Revision; result überschreiben

[Mokus]

Bei der Folgende Function wird mein result immer überschrieben;

Delphi-Quellcode:

function TForm1.Fakulitaet(
  n        : integer;
  max      : integer;
  iErgebnis: integer): integer;
var
  I: integer;
begin
  if n <= max then
  begin
    iErgebnis := iErgebnis * n;
    n         := n + 1;
    result    := iErgebnis;
    self.Fakulitaet(n, max, iErgebnis);
  end;

end;

Er rechnet richtig, bei 5 120 etc.

Das result ist aber ständig eins ....

Wie kann man bei einer rekusiven Function das result nehmen, welches am letzten herausgefunden war.

[baumina]

Du rufst die Funktion procedural auf:

self.Fakulitaet(n, max, iErgebnis); statt

xxx := Fakulitaet(n, max, iErgebnis);

[Medium]

Delphi-Quellcode:

function TForm1.Fakultaet(
  n        : integer;
  max      : integer;
  iErgebnis: integer): integer;
begin
  if n <= max then
    result := Fakulitaet(n+1, max, iErgebnis*n);
end;

Die Fakulität heisst übrigens nur Fakultät, und die Revision im Titel soll vermutlich eine Rekursion sein

[Mokus]

Delphi-Quellcode:

function TForm1.Fakulitaet(
  n        : integer;
  max      : integer;
  iErgebnis: integer): integer;
begin
  if n <= max then
  begin
    iErgebnis := iErgebnis * n;
    n         := n + 1;
    result    := self.Fakulitaet(n, max, iErgebnis); // falsche zuweisung fehlte,
  end
  else
  begin
    result := iErgebnis; // damit auch richtiges ergebnis kommt
  end;

kleines else und ne result zuweisung haben gefehlt;
dank euch

[Uwe Raabe]

Entschuldige bitte die Kritik, aber das ist m.E. viel zu kompliziert implementiert, was auch zu einer schlechten Lesbarkeit und Fehleranfälligkeit führt.

Du führst unnötigerweise den Endwert und das Zwischenergebnis bei jedem Funktionsaufruf mit. Dabei wird unnütz viel Stack verbraucht. Bei der Fakultät wird zwar wohl erst der Integerüberlauf vor einem Stacküberlauf eintreten, aber man sollte doch seine Resourcen gerade bei Rekursionen nicht unnötig verschwenden.

Günstiger ist es hier, das Pferd von hinten aufzuzäumen:

Delphi-Quellcode:

function Fakultaet(n: Integer): Integer;
begin
  if n = 1 then
    result := 1
  else
    result := n*Fakultaet(n-1);
end;

[noisy_master]

Moin,

Zitat von Uwe Raabe:

...wird unnütz viel Stack verbraucht..... Stacküberlauf eintreten,

Günstiger ist es hier, das Pferd von hinten aufzuzäumen:

Delphi-Quellcode:

function Fakultaet(n: Integer): Integer;
begin
  if n = 1 then
    result := 1
  else
    result := n*Fakultaet(n-1);
end;

Dann sparen wir uns doch am besten die Rekursion komplett(spart noch mehr Stack) und frühstücken das ganze mit einer simplem loop ab....

Delphi-Quellcode:

function Fakultaet(n: Integer): Integer;
var i:integer;
begin
  result := 1;
  // just start at 2, because 0! and 1! is 1
  for i:= 2 to n do 
    result := result * i;
end;

P.S.: funktioniert natürlich so nur für die Fakultät von positiven Zahlen

[Der schöne Günther]

Da der rekursive Funktionsaufruf die letzte Anweisung der Methode war, würde ich so etwas eigentlich schon dem Compiler überlassen, dass dahingehend zu optimieren ("Tail Recursion").

Der Delphi Win32-Compiler optimiert das (glaube ich) zwar nicht dahingehend, aber das geht alles irgendwie auch schon weit über die ursprüngliche Frage hinaus

[Uwe Raabe]

Zitat von noisy_master:

Dann sparen wir uns doch am besten die Rekursion komplett(spart noch mehr Stack) und frühstücken das ganze mit einer simplem loop ab....

Ich weiß nicht, ob das hier der Fall ist, aber die Berechnung der Fakultät wird im Informatik-Unterricht gern als Beispiel für Rekursion genommen. Dazu möchte ich hier gern noch eine Anekdote aus dem Informatik-Unterricht (Pascal) meiner Tochter loswerden:

Zitat:

Lehrer: Wir nennen die Funktion mal FAK.
(Tosendes Gelächter im Klassenraum)
Lehrer: Na gut. Dann eben FAKU.

[himitsu]

Zitat von Mokus:

Delphi-Quellcode:

function TForm1.Fakulitaet(
  n        : integer;
  max      : integer;
  iErgebnis: integer): integer;
var
  I: integer;
begin
  if n <= max then
  begin
    iErgebnis := iErgebnis * n;
    n         := n + 1;
    result    := iErgebnis;
    self.Fakulitaet(n, max, iErgebnis);
  end;

end;

Dein Compiler gibt da nicht zufällig eine Warnung aus, bezüglich "Result sei nicht initialisiert"
(Nja, und "i wurde deklariert, aber nicht verwendet".)

Und daß du das Ergebnis von dem rekursiven Fakulitaet-Aufruf nicht auswertest, hatte hier schon jemand erwähnt.


PS: Seit 2009 kannst du auch beruhigt "Fakulität" schreiben.

[Uwe Raabe]

Zitat von himitsu:

PS: Seit 2009 kannst du auch beruhigt "Fakulität" schreiben.

Wäre aber auch nicht richtig...