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):

[FONT=Courier New] var
  x : Integer;

begin
  x:= 1;
 
  While x <= 10 do
  begin
[/FONT]
[FONT=Courier New]ShowMessage(IntToStr(x));
x := x + 1;[/FONT]
[FONT=Courier New]   end;
end;[/FONT]

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.

[kanonenfutter]

Hab folgende Idee für ne While-Do:

Ich lass den rechner 2 zufallszahlen erzeugen, welche der benutzer dann addieren und die summe in ein fenster eingeben muss. Jetzt kommt der befehl "solange das ergebnis falsch ist, wird ein bestimmter text ausgegeben" - also while ergebnis not = Benutzereingabe do ausgebe eine textes.

Würde das funzen??? Hab das so oder so ähnlich schon mal probiert, allerdings wird bei mir kein text ausgegeben, wenn das ergebnis richtig ist (while ergebnis = benutzereingabe do ausgabe text). Andernfalls hab ich nur ne endlosschleife kreiert.

Bitte um hilfe!!!!!

[tobsen]

Also das Beispiel finde ich nicht so toll, vor allem für einen Vortrag. Schleifen sollen ja dazu da sein um z.b.ein Array zu durchlaufen oder andere Operationen zu wiederholen, solange eine Bedingung wahr ist. In deinem Beispiel kann ja nichts wirklich "durchlaufen" werden. Theoretisch kann man sowas schon machen mit einer Schleife, indem man die Schleife endlos laufen lässt, und falls das ergebnis richtig ist, springt man raus, also:

while(true) {
if(eingabe == ergebnis) {
System.out.println("Das Ergebnis ist richtig!");
break;
}

System.out.println("Das Ergebnis ist falsch!");
}

Aber schön finde ich sowas nicht! Man macht sowas normalerweise z.b. mit Events, aber das ist eine ganz andere geschichte

\\ EDIT

Ein Beispiel was mir spontan einfällt (rein zur Illustration der SChleife):
(DELPHI - PSEUDO)

 
Fritz = hungrig;

while (Fritz ist hungrig)  DO
Begin
Fritz isst etwas;
End

[kanonenfutter]

Na gut - dann macht mal einfach umzusetzende (für amateure) vorschläge - thx bis hierhin!

[redfalcon]

Zitat von kanonenfutter

Hab folgende Idee für ne While-Do:

Ich lass den rechner 2 zufallszahlen erzeugen, welche der benutzer dann addieren und die summe in ein fenster eingeben muss. Jetzt kommt der befehl "solange das ergebnis falsch ist, wird ein bestimmter text ausgegeben" - also while ergebnis not = Benutzereingabe do ausgebe eine textes.

Würde das funzen??? Hab das so oder so ähnlich schon mal probiert, allerdings wird bei mir kein text ausgegeben, wenn das ergebnis richtig ist (while ergebnis = benutzereingabe do ausgabe text). Andernfalls hab ich nur ne endlosschleife kreiert.

Bitte um hilfe!!!!!

Warum sollte das nicht funzen? Probier es doch einfach aus. Wenn du spezifische Probleme mit dem Code hast frag einfach. Wie sollen wir ohne Code wissen, wo der Fehler ist?


/Edit:

Ich weiss ja nicht, vor wem du den Vortrag halten sollst. Wenn aber Lehrer dabei sind, die etwas Ahnung von Informatik haben, würde ich nicht so ein triviales Beispiel wie "Lese-Elemente-aus-Array" nehmen, sondern eben irgendwas bekanntes, was anspruchsvoller ist (Die obengenannten Fakultäten oder Fibonacci-Zahlen, gibt bestimmt noch mehr in die Richtung).

[kanonenfutter]

Sitz grad und probier die fibonacci zahlen - kann mir mal jemand sagen, wie ich in delphi indizes vergebén kann??

Ich will das folgendermaßen machen:
a1:=0;
a2:=1;
for i:=1 to n do an:=a(n-2)+a(n-1);

Heißt also, dass die ersten beiden glieder sich zu 0 und 1 ergeben (1 und 2 bei a1 und a2 sollen als indize herhalten). Dann soll bei Eingabe von n (n-tes glied der kette) das entsprechende Glied ausgegeben werden -> a(n-2)+a(n-1) - wobei (n-2) und(n-1) wieder als indize gehandhabt werden sollen.

Ich hoffe ich konnte meine absicht einigermaßen verständlich rüberbringen - hat jemand ne idee was die indizes angeht???

[tobsen]

Zitat von redfalcon

Warum sollte das nicht funzen? Probier es doch einfach aus. Wenn du spezifische Probleme mit dem Code hast frag einfach. Wie sollen wir ohne Code wissen, wo der Fehler ist?


/Edit:

Ich weiss ja nicht, vor wem du den Vortrag halten sollst. Wenn aber Lehrer dabei sind, die etwas Ahnung von Informatik haben, würde ich nicht so ein triviales Beispiel wie "Lese-Elemente-aus-Array" nehmen, sondern eben irgendwas bekanntes, was anspruchsvoller ist (Die obengenannten Fakultäten oder Fibonacci-Zahlen, gibt bestimmt noch mehr in die Richtung).

Bin der gleichen Meinung. Nur hieß es nicht dass es möglichst elementar und einfachs ein soll?
Einfach: Zahlen von 0 bis 10 ausgeben
Attraktiver: Fibonacci, Fakultäten oder auch Primzahlen bis 100 ausgeben (verschachtelte SChleifen *hrhr* )

[kanonenfutter]

Glaub, dass mit den indizes (s.o.) hab ich jetzt raus. Mus einfach a[1], a[2] u.s.w schreiben für a[n] ergäbe sich dann:
a[n]:=a[n-2]+a[n-1];

Allerdings bekomm ich nur zahlen überhalb der hunderttausender ausgegeben...?! Außerdem kapier ich dieses Array-Zeug nich so wirklich, also wie ich damit meine variablen deklarieren muss etc.
Bei mir stehts im moment so da:

var n,z,i : Integer; (n=Zahl des Glieds | z=Auszugebende Zahl | i=Schleifenvariable)
a : array [1..10] of Integer;
begin
n:=StrToInt(Edit1.Text);
for i:=1 to n do begin
a[1]:=0;
a[2]:=1;
a[n]:=a[n-2]+a[n-1];
a[n]:=z;
Panel1.Caption:=IntToStr(z);
end;
end;

end.

Kompilieren tut er das ja auch - ausgegeben wird aber nur rotz...

[EoN]

Du musst wenn Du ein Array durchgehst, natürlich die Laufvariable der Schleife benutzen:

n = 10
for i:=1 to n do begin
a[1]:=1;
a[2]:=1;
a[i]:=a[i-2]+a[i-1];
z := a[i];
Panel1.Caption:=IntToStr(z);
end;

Für i ist beim ersten Durchlauf i = 1, beim zweiten Durchlauf ist i = 2.
Das Array kannst Du Dir dabei in etwa so vorstellen:
a[1] | a[2] | a[3] | a[4]
__1_|__1_ |__2__|__3 (Die Unterstriche dienen nur als Platzhalter).
Das Array ist quasi ein Karton in dem es mehrere Fächer mit den Namen 1,2,3,4 gibt. Im Fach mit dem Namen "1" liegt die 1. Im Fach mit dem Namen 4, die 3, etc..
Des Weiteren ist bei den Fibonaccizahlen fib(1) = 1 und nicht 0 wie von Dir in Deinem Code angegeben.
Zusätzlich steht die Variable der Du einen Wert zuweisen willst immer links. Die Variabel die den Wert hat, die der anderen zugewiesen werden soll demnach rechts.
Hab mal die Änderungen an Deinem Code farbig markiert.

[kanonenfutter]

Danke - werd ich gleich ma ausprobieren - meld mich gleich wieder.

THX EoN!
Hat aber nochn paar praxisproblemchen: Wenn ich 1 oder 2 eingebe, dann kommen ganz utopische zahlen wie 906251136 o.s.ä. - woran liegt das und wie kann ich das beheben. Andere zahlen so ab 3 bis 34 funzen, sobald ich allerdings auf über 50 o.s. gehe, dann werden die Zahlen extrem groß, was ja auch verständlich ist, allerdings ins negative?!

Hoffe du oder andere können mir nochma helfen...

Hey, schlaft ihr schon alle?
Ich brauch nochma eure hilfe:
1. siehe oberen beitrag
2. Wie müsste denn der quelltext für die Fakultät aussehen?? - Hab da ma was probiert - will aber nich richtig funzen?!

Thx an alle die schnell noch ma was posten, da ich das zeug voraussichtlich morgen brauch - THX

[redfalcon]

Keine Mehrfachposts! Dafür gibts ne Editfunktion.

"Hab da mal was probiert..."

Was denn? Poste doch einfach deinen Quelltext, sonst können wir dir nicht helfen. Außerdem sollst DU den Vortrag machen. Was nützt es dir denn, wenn wir hier Quelltext posten, und du ihn nicht verstehst? Den Pseudocode für Fakultätenberechnung hab ich dir oben schon gepostet.