Mit fpc direkte, iteraive, rekursive Funktion darstellen.

19/03/2009 - 22:23 von count zero | Report spam
Ist Folgendes nach einmaligem
(maximal zweimaligem) lesen
(leicht) verstàndlich?



Program Zinseszins;

// fpc Zinseszins.pas

(*
Demonstation von unmittelbarer, sich wiederholender, sich aufrufender
Funktion.
Falls möglich wird als Lösung
die direkte Funktion bevorzugt,
dann die iterative Funktion,
und am Schluss die rekursive Funktion.
*)

uses math; // Funktion x^y; power(x,y)

var
Geld: Currency;
Zins: real; // Zins als % angeben
Zinsanzahl: byte;

procedure eingabe;
begin
// Noch offen Bereich der Eingabe prüfen.
writeln('Der Punkt ist das Dezimaltrennzeichen.');
write('Anfangskapital = '); readln(Geld);
write('Zins in % = ' ); readln(Zins);
write('Anzahl der Zinsen von von 0 bis 255 = '); readln(Zinsanzahl);
end;

function endkapital(K0:currency; p:real; n:byte): Currency;
begin
endkapital:=K0*power(1+p/100, n);
end;

function endkapital_iterativ(K0:currency; p:real; n:byte): Currency;
var
i: byte;
begin
endkapital_iterativ:=K0; //Anfagswert
for i:=n downto 1 do //Schleife
endkapital_iterativ:=endkapital_iterativ*(1+p/100); //iterieren
end;

function endkapital_rekursiv(K0:currency; p:real; n:byte): Currency;
begin
endkapital_rekursiv:=K0;
//Anfangswert
if n>=1 then
//Abbruchbedingung
endkapital_rekursiv:=endkapital_rekursiv(K0, p, n-1)*(1+p/100);
//rekursieren
end;

begin
writeln;
eingabe;
writeln('');
writeln('In einem Zug ausgerechnet');
writeln(endkapital(Geld, Zins, Zinsanzahl):15:4);
writeln('Geld[Zinsanzahl] := Geld[0]*(1+Zins/100)^Zinsanzahl');
writeln('');
writeln('Als iterative Schleife mit "for downto do" gerechnet.');
writeln('Von Zinsanzahl = ', Zinsanzahl, ' hinunter bis 1.');
writeln(endkapital_iterativ(Geld, Zins, Zinsanzahl):15:4);
write('Geld[Zinszahl] := Geld[Zinsanzahl]*(1+Zins/100)');
writeln(' wiederholte sich ', Zinsanzahl, ' mal.');
writeln('');
writeln('Als rekursive Funktion geschrieben.');
writeln('Von Zinsanzahl = ', Zinsanzahl, ' hinunter bis 1.');
writeln(endkapital_rekursiv(Geld, Zins, Zinsanzahl):15:4);
write('Geld[Zinsanzahl] := Geld[Zinsanzahl-1]*(1+Zins/100)');
writeln(' rief sich ', Zinsanzahl, ' mal auf.');
writeln('');
end.



ln -s /dev/cerebro /dev/null is full
Was ich denke ist leer und es quillt über.
Pseudonym...count.zero
 

Lesen sie die antworten

#1 Markus Wichmann
20/03/2009 - 13:21 | Warnen spam
count zero wrote:


Ist Folgendes nach einmaligem
(maximal zweimaligem) lesen
(leicht) verstàndlich?




Kommt auf die... àh... "Lesart" an. Ich gucke bspw. immer erst ins
Hauptprogramm und dann erst in die Prozeduren. Und da sehe ich:


Program Zinseszins;

// fpc Zinseszins.pas

(*
Demonstation von unmittelbarer, sich wiederholender, sich aufrufender
Funktion.
Falls möglich wird als Lösung
die direkte Funktion bevorzugt,
dann die iterative Funktion,
und am Schluss die rekursive Funktion.
*)

uses math; // Funktion x^y; power(x,y)

var
Geld: Currency;
Zins: real; // Zins als % angeben
Zinsanzahl: byte;

procedure eingabe;
begin
// Noch offen Bereich der Eingabe prüfen.
writeln('Der Punkt ist das Dezimaltrennzeichen.');
write('Anfangskapital = '); readln(Geld);
write('Zins in % = ' ); readln(Zins);
write('Anzahl der Zinsen von von 0 bis 255 = '); readln(Zinsanzahl);
end;

function endkapital(K0:currency; p:real; n:byte): Currency;
begin
endkapital:=K0*power(1+p/100, n);
end;




Wer Ahnung von Zinsrechnung hat, sollte hiermit kein Problem haben.
Wenngleich ich Prozentangaben meistens sofort durch 100 teile (schon bei
der Eingabe), damit ich keine Probleme mehr habe, es in einer Funktion
einzusetzen. Also so hier:

procedure eingabe;
var
tmpZins: double;
begin
write('Anfangskapital = '); readln(Geld);
write('Zins in % = '); readln(tmpZins);
Zins := tmpZins / 100;
writeln('Anzahl der Perioden = '); readln(Zinsanzahl);
end;

function endkapital_iterativ(K0:currency; p:real; n:byte): Currency;
var
i: byte;
begin
endkapital_iterativ:=K0; //Anfagswert
for i:=n downto 1 do //Schleife
endkapital_iterativ:=endkapital_iterativ*(1+p/100); //iterieren
end;




Das ist böse, weil hier auf den Funktionswert lesend zugegriffen wird.
(Und der Datentyp "real" ist mir immer nicht so geheuer, nimm double,
"da weiß man, was man hat")

Mach lieber sowas hier:

function endkapital_iterativ(K0:currency; p:double; n:byte): Currency;
var
i: byte;
retval: Currency;
begin
retval := K0;
for i := 1 to n do
retval := retval * (1+p);
done
endkapital_iterativ := retval;
end;

function endkapital_rekursiv(K0:currency; p:real; n:byte): Currency;
begin
endkapital_rekursiv:=K0;
//Anfangswert
if n>=1 then
//Abbruchbedingung
endkapital_rekursiv:=endkapital_rekursiv(K0, p, n-1)*(1+p/100);
//rekursieren
end;




Das wiederum ist nett. Wenngleich ich rekursive Funktionen meistens so
schreibe, dass der Startwert unten steht, aber darüber ließe sich
streiten.

begin
writeln;
eingabe;
writeln('');
writeln('In einem Zug ausgerechnet');
writeln(endkapital(Geld, Zins, Zinsanzahl):15:4);
writeln('Geld[Zinsanzahl] := Geld[0]*(1+Zins/100)^Zinsanzahl');
writeln('');
writeln('Als iterative Schleife mit "for downto do" gerechnet.');



Wieso eigentlich "downto"? Die Richtung ist doch egal.

writeln('Von Zinsanzahl = ', Zinsanzahl, ' hinunter bis 1.');
writeln(endkapital_iterativ(Geld, Zins, Zinsanzahl):15:4);
write('Geld[Zinszahl] := Geld[Zinsanzahl]*(1+Zins/100)');
writeln(' wiederholte sich ', Zinsanzahl, ' mal.');
writeln('');
writeln('Als rekursive Funktion geschrieben.');
writeln('Von Zinsanzahl = ', Zinsanzahl, ' hinunter bis 1.');
writeln(endkapital_rekursiv(Geld, Zins, Zinsanzahl):15:4);
write('Geld[Zinsanzahl] := Geld[Zinsanzahl-1]*(1+Zins/100)');
writeln(' rief sich ', Zinsanzahl, ' mal auf.');
writeln('');
end.






Tschö,
Markus

GUI - ein Hintergrundbild und zwölf XTerms

vim -c "exec \"norm iwHFG#NABGURE#IVZ#UNPXRE\"|%s/#/ /g|norm g??g~~"

Ähnliche fragen