Beispiele für Schleifen gesucht

[kanonenfutter]

Hallo leutz
Ich brauch je ein Anwendungsbeispiel für ne For-To-/While-Do- und Repeat-Until-Schleife. Sollten nach Möglichkeit einfache Beispiele sein, die auch ein Amateur programmieren könnte - speziell für Delphi.

Ich brauch das für nen Vortrag, mir fallen nur absolut keine ein, da die Bsp. nich ausm Netz sein sollen - deshalb setz ich auf euch mir zu helfen.

thx für jeden post.

[redfalcon]

Fakultäten (!n) und Fibonaccizahlen würden mir spontan einfallen.

[kanonenfutter]

Kannste das noch nen bissl genauer beschreiben - so mit eigenen Worten was im quelltext stehen müsste (Anweisung,Bedingung) - thx erstmal.

[redfalcon]

Naja Fakultäten sind noch relativ einfach. !5 (Fakultät von 5) wäre z.B. 5*4*3*2*1 = 120.

In Java/Pseudocode würde das so aussehen:

variable input;
variable ergebnis = 1;

   Ausgabe("Zahl eingeben: ");
   input=Usereingabe

   
    wenn(input==1){
      Ausgabe("Fakultät von 1 ist 1")
    }
    sonst {
        für (variable temp=input; temp > 0; temp--) {
             ergebnis = ergebnis * temp;
        }
     Ausgabe("Fakultaet von "+input+" ist "+ergebnis+".");
    }

Fibonaccizahlen hab ich aber nie gemacht, hat nur unser Infolehrer mal im Zusammenhang mit Rekursion erwähnt. Für Delphi hab ich hier was gefunden.

[EoN]

fib(x) = fib(x-1) + fib(x-2) für n>=2
fib(1) = 1 und fib(2) = 1

Wobei ne Schleife != Rekursion ist. Es lässt sich zwar (fast) jede Schleife in ne Rekursion umwandeln und umgekehrt, allerdings muss man es anders implementieren.

[daPR]

vll. was gaanz schlichtes: ne trenn"linie"
zB als Funktion, bei der man die anzahl der striche(länge) angeben kann. (hier C++)

void linie (int leange)
{
     int i;
     for (i=0,i<leange,i++) 
     {
          cout <<"-";
      }
      cout << endl;
}

oder, für php essentiell, das abfragen (in diesem fall auflisten) von Datenbankeinträgen.

$query=mysql_query("select id,name from user order by name desc");  // Welche Einträge

while ($user=mysql_fetch_assoc($query)) {                                    // alles in den Array $user schreiben
      echo $user['id'].'&nbsp;'.$user['name'].'<br />';                         // Ausgeben
}

was hälts von was viel besserem?

Is von meiner schule:

http://www.lenne-schule.de/partner/links/delphi/

[kanonenfutter]

Klingt schon mal sehr interessant - daher vielen dank an alle. Das problem ist nur, ich meinte das mehr für amateure - also etwas, dass man mit einfachsten kenntnissen programmieren kann.

Für eine For-To schleife könnt ich ja z.B. eine bestimmte Zahl der Fibonaccizahlen berechnen lassen.

Aber für die beiden anderen (while-do und Repeat-Until) fällt mir nix ein. Hab ma was probiert - und meinen rechner in ne endlosschleife geschickt...

[tobsen]

Alle folgenden Beispiele machen das gleiche: Es werden die Zahlen 0 bis 10 ausgegeben.



Beispiel für While Schleife: (Java)

int x = 1 ; 

while(x <= 10) {
System.out.println(x);
x = x + 1;
}

Beispiel für While-DO Schleife: (Java)

int x = 0;

do {
System.out.println(x);
x = x + 1;
} while(x <= 10);

Beispiel While-DO Schleige (Delphi):

 var
  x : Integer;

begin
  x:= 1;
 
  While x <= 10 do
  begin
ShowMessage(IntToStr(x));
x := x + 1;
   end;
end;

Beispiel für Repeat-Until: (Pascal)

VAR x:integer;
BEGIN
x:=0

Repeat
write(x);
x := x + 1;
UNTIL x>10
END

[EoN]

Zitat von kanonenfutter

Klingt schon mal sehr interessant - daher vielen dank an alle. Das problem ist nur, ich meinte das mehr für amateure - also etwas, dass man mit einfachsten kenntnissen programmieren kann.

Für eine For-To schleife könnt ich ja z.B. eine bestimmte Zahl der Fibonaccizahlen berechnen lassen.

Aber für die beiden anderen (while-do und Repeat-Until) fällt mir nix ein. Hab ma was probiert - und meinen rechner in ne endlosschleife geschickt...

Da kannst Du genau das gleiche programmieren. Jede For-Schleife lässt sich in ne while und do until Schleife umwandeln, musst nur die Bedinungen entsprechend anpassen:

for(i = 0, i < 10; i++)
{
...
}

macht das gleiche wie:

i = 0;
while(i < 10)
{
...
i++;
}

oder:

i = 0;
do
{
...
i++;
} until(i < 10)

Im letzten Fall wird die Bedingung erst geprüft nachdem die Schleife einmal durchlaufen wurde und die Zählvariable um eins inkrementiert wurde. Bei den anderen beiden wird vor dem Durchlauf der Schleife schon geprüft ob die Bedingung schon verletzt wurde. Bei den beiden oberen würden die Schleifen im Falle von (i == 11) gar nicht mehr durchlaufen werden. Bei der letzten Schleife schon, da erst nach dem Durchlauf geprüft wird, ob (i < 10) == true ist.
Das gleiche ließe sich auch durch eine Rekursion realisieren:

public test(int i)
{
...
if (i < 10) return test(i +1);
else return i;
}

Hier wird jetzt immer wieder die Methode test aufgerufen mit einem um 1 größeren i Wert. Sobald (i >= 10) == true ist wird der aktuelle i Wert zurück an das Ursprungsprogramm gegeben.

[kanonenfutter]

Wo besteht denn der unterschied zw. einer While und einer While-do schleife?

[EoN]

Zitat von kanonenfutter

Wo besteht denn der unterschied zw. einer While und einer While-do schleife?

Das sollte im Syntax der unterschiedlichen Programmiersprachen liegen. Hatte jetzt mit Pascal/Delphi die letzen 6-7 Jahre nichts mehr zu tun, daher sind die Beispiele oben eher an Javacode angelehnt. Glaub aber in Pascal war die while Schleife so definiert:

while(...)
do
...
loop

In Java ists:

while(...)
{
...
}

Aber such da am besten noch mal bei der Suchmaschine Deiner Wahl nach dem richtigen Syntax zu Pascal/Delphi.

[kanonenfutter]

Also besteht der unterschied nur zw. den programmiersprachen?!

[EoN]

Zitat von kanonenfutter

Also besteht der unterschied nur zw. den programmiersprachen?!

Der Unterschied besteht AFAIK im unterschiedlichen Syntax der Programmiersprachen - ja.

[tobsen]

Zitat von kanonenfutter

Also besteht der unterschied nur zw. den programmiersprachen?!

Das hat Dir Eon schon verraten:

Zitat von Eon

Im letzten Fall wird die Bedingung erst geprüft nachdem die Schleife einmal durchlaufen wurde und die Zählvariable um eins inkrementiert wurde. Bei den anderen beiden wird vor dem Durchlauf der Schleife schon geprüft ob die Bedingung schon verletzt wurde. Bei den beiden oberen würden die Schleifen im Falle von (i == 11) gar nicht mehr durchlaufen werden. Bei der letzten Schleife schon, da erst nach dem Durchlauf geprüft wird, ob (i < 10) == true ist.

WHILE: ERST wird geprüft, dann ausgeführt wenn Bedingung wahr.
DO-WHILE: Es wird IMMER zunächst einmal die SChleife durchlaufen, DANN wird erst geprüft. Falls die Bedingung wahr ist, dann wird die schleife wieder durchlaufen.

Unterschied: Bei DO_WHILE wird die Schleife IMMER mind. einmal durchlaufen. Bei WHILE evtl. gar nicht, wenn die Bedingung schon von Anfang an falsch ist.