Schleifen

[netscanner]

Hi Leute,
ich muss ein Programm programmieren, welches den folgenden Zahlencode in einem Memo Feld ausgibt:
1,2,3,4,5,6,7,8,9,10,10,9,8,7,6,4,3,2,1,1,2,3,4,5, 6,7,8,9,10,10,9,8,7,6,4,3,2,1
Also von 1-10 dann von 10 - 1 und das ganze nocheinmal.
Dass Programm soll mit einer einzigen for-Schleife und mit einer einzigen if - Abfrage realisiert werden...
Über Ideen wäre ich sehr dankbar - ich vbin nämlich ratlos :(


Gruß netscanner

[sakura]

Da wir hier keine Hausaufgaben lösen (siehe Kodex) wäre es gut, wenn Du wenigstens auch posten würdest, was Du bis jetzt schon geschafft hast.

...:cat:...

[netscanner]

ich habe es bissher nur so geschafft, dass ich mehrere for schleifen (2 stück) verwendet habe...
desshalb ist es auch recht sinnlos den code zu posten

[ichbins]

hat er doch geschrieben: er hat keinen Plan ;)

ich schreib dir jetzt zwar keinen fertigen Code hin (viel zu faul :stupid:)

Aber du könntest eine for-schleife von 1-40 machen, und dann noch eine variable, in der der aktuelle wert (erst 1 dann 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 9...) gespeichert ist, und dann auch noch eine variable, in der gespeichert wird, ob der wert gerade hoch- oder runtergezählt wird (-1 oder +1). in der for-schleife erhöhst du den aktuellen wert um den in der anderen Variable.

Zusätzlich tust du in die for-schleife noch eine if-abfrage, die die hoch-runter-Variable umkehrt, falls du die Grenzwerte erreicht hast.

[netscanner]

danke erstmal für deinen beitrag aber wie soll ich das mit dem +1 bzw. -1 mit einer for-schleife machen?
dazu benötigt man doch eine repeat schleife oder?
sorry für die blöde frage aber schleifen sind echt nicht mein ding...

[supermuckl]

eventuell so?

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
zahl,i,switch:integer;
begin
  zahl := 0;
  switch := 1;
  for i := 1 to 21 do begin
    inc(zahl,switch);
    if (zahl > 10) then switch := -1 else memo1.Lines.Add(inttostr(zahl));
  end;
end;

[Khabarakh]

Die Aufgabe ist interessant ^^ . Die "mathematische Lösung": Für die n-te Zahl (mit 0 beginnend) gilt

Delphi-Quellcode:

Round(10.5 - Abs(10.5 - n mod 20 - 1));

[netscanner]

noch ne kleine frage bei dem Code von supermuckl:
Der Code gibt nur einmal von 1-10 und rückwerts aus....
Ich brauch das ganze aber 2 mal hintereinander...
wie kieg ich das ohne zusätzliche schleife und if abfrage hin?

[monta]

mal ein anderer Weg:

Code:

drei Variablen, eine für die Richtung [+1/-1], eine für die for schleife, eine für die Ausgabe;

Richtung entspricht -1

for-Schleife welche bis 40 hochzählt

  in die Schleife die if Abfrage, welche prüft ob die Zählvariable restlos durch 10 teilbar ist, wenn ja wird die Richtung einfach mittels * -1 umgedreht

  Ausgabe entspricht dann Ausgabe + Richtung

Ende der for-Schleife

[netscanner]

wenn ich den code dann aber so programmiere macht er es auch nur einmal durch oder is daran was falsch?

Code:

var a,i,c :integer ;
begin
a := -1; //richtung
i := 0; //zähler
//c Ausgabe
for i := 1 to 80 do
if i mod 10 = 0 then a := -1
else  a := 1;
i := c * a ;
memo1.seltext := (inttostr (i));

end;

end.

[netscanner]

äh wrong coe :

Delphi-Quellcode:

var a,i,c :integer ;
begin
a := -1; //richtung
i := 0; //zähler
//c Ausgabe
for i := 1 to 80 do
if i mod 10 = 0 then a := -1
else  a := 1;
c := c * a ;
memo1.seltext := (inttostr (c));

end;

end.

[xaromz]

Hallo,

Dein Code hat ein paar Fehler:

Delphi-Quellcode:

var a,i,c :integer ; 
begin 
a := -1; //richtung 
i := 0; //zähler 
//c Ausgabe                           // 1)
for i := 1 to 80 do                   // 2)
if i mod 10 = 0 then a := -1          // 3)
else  a := 1; 
c := c * a ;                          // 4)
memo1.seltext := (inttostr (c)); 

end;

Ich hab mal die wichtigsten markiert.
1) c ist nicht initialisiert.
2) Du zählst zwar hoch, aber nur die if-Abfrage. Deine Schleife muss in einen begin..end-Block.
3) Dein Vorzeichen ist immer Positiv, außer die Zahl ist durch Zehn teilbar. Das Vorzeichen muss dann aber wechseln und bis zur nächsten Zehnerzahl so bleiben.
4) c wird nur einmal mit -1 malgenommen und das Ergebnis ausgegeben. Da c nicht initialisiert ist kommt irgendetwas raus.

so stimmts:

Delphi-Quellcode:

var
  a, i, c : Integer;
begin
  a := 1; //richtung
  i := 0; //zähler
  c := 0; //c Ausgabe
  for i := 1 to 40 do             // Zwei mal hoch und runter
  begin
    c := c + a;                   // Zahl um Eins erhöhen/vermindern

    memo1.seltext := IntToStr(c); // Zahl ausgeben

    if i mod 10 = 0 then          // wir müssen umdrehen
    begin
      c := c + a;                 // noch eins weitergehen, damit die nächste Zahl stimmt
      a := a * -1;                // Vorzeichen wechseln
    end;
  end;
end;

Gruß
xaromz

[netscanner]

erstmal danke...aber wenn ich den code compiliere zählt er mir auch nur ein mal hoch und runter :(

[monta]

das versteh ich nicht, hast du denn code von xaromz?

bei mir funtkioniert es einwandfrei :gruebel:

für die Übersichtlichkeit könnte man ja das memo.seltext auch durch:

Delphi-Quellcode:

memo1.Lines.Add(IntToStr(c));

ersetzen, ist ja aber eigentlich egal.

[netscanner]

jo hab ich aber bei mir zeigt er nur 1234567891010987654321 an
un d nicht 12345678910109876543211234567891010987654321

[netscanner]

hat sich erledigt - es geht :)

[Der_Unwissende]

Zitat:

Zitat von netscanner

danke erstmal für deinen beitrag aber wie soll ich das mit dem +1 bzw. -1 mit einer for-schleife machen?
dazu benötigt man doch eine repeat schleife oder?
sorry für die blöde frage aber schleifen sind echt nicht mein ding...

Hi,
ich wollte noch was zu deinem eigentlichen Problem loswerden, Schleifen. Die sind nämlich extrem wichtig, sie werden dir also sehr häufig begegnen (Dann ist vielleicht auch das mit +1 oder -1 klar)

Schleifen gehören zu den sogenannten Kontrollstrukturen. Die Idee von einem if ist dir sicherlich klar, du prüfst etwas (nennen wir es X) und wenn X wahr ist, machst du etwas sonst nicht. Jetzt gibt es aber viele Dinge die du gerne mehr als einmal machen möchtest. Da kommen dann Schleifen ins Spiel.

In Delphi gibt es verschiedene Möglichkeiten, du hast eine while ... do, eine repeat ... until und eine for .. to .. do.

Eine Schleife besteht immer aus zwei Teilen, einer Überprüfung und einem Schleifenkörper. Der Unterschied zwischen den drei Schleifen liegt hier in der Überprüfung (Zeitpunkt und Art).
Was welche Schleife macht muss du dir nicht kompliziert merken, dass geht recht gut aus den Namen hervor.

Die while-Schleife prüft direkt eine Bedingung. Ist diese erfüllt, wird der gesamte Schleifenkörper durchlaufen. Nach jedem duchlauf springt dein Programm wieder zu dieser Überprüfung und verfährt auf gleiche Art und Weise. Ist die Bedingung nicht erfüllt, so wird der gesamte Schleifenkörper übersprungen und in der nächsten Zeile fortgefahren.
Der Schleifenkörper sollte durch ein begin ... end umschlossen werden. Folgt dem do kein begin, besteht der Schleifenkörper nur aus der nächsten Zeile. Zu gutem Programmierstil gehört es jedoch auch für den einzeiligen Schleifenkörper ein begin und end zu verwenden (macht es leichter lesbar und weniger Fehleranfällig)
Ist also die Bedingung nie erfüllt, wird die Schleife nie durchlaufen.

Die repeat-Schleife gleicht der while Schleife fast komplett. Der wichtige Unterschied liegt darin, dass diese Schleife erst nach dem Durchlauf die Bedingung prüft. Zudem steht der Schleifenkörper zwischen dem repeat und dem until. Die Schleife wird also einmal durchlaufen, dann wird geguckt ob die Schleifenbedingung erfüllt ist und ggf. die Schleife erneut durchlaufen.
Ist die Bedingung nie erfüllt, so wird die Schleife trotzdem einmal durchlaufen.

Die for-Schleife ist eine besondere Schleife. Während while und repeat eine allgemeine boolsche Bedingung überprüft handelt es sich bei der for-Schleife um eine Zählschleife. Wie der Name schon sagt, zählt diese Schleife. Genau genommen kannst du hier die Anzahl der Durchläufe festlegen.
Sie besteht aus einer Variable, die mit einem bestimmten Wert initialisiert wird, einem Zielwert und der Richtung (rauf- oder runterzählen). Dabei wird die Variable automatisch in jedem Schritt um 1 erhöht (abgesenkt)
Diese Schleife lässt sich wohl einfacher an einem Beispiel erklären:

Delphi-Quellcode:

var i : Integer;
begin
  // initialisiert i mit dem Wert 0
  // tut irgendwas bis i den Wert 10 hat
  for i := 0 to 10 do 
    begin
      // tue irgendwas
    end; 

   // initialisier i mit dem Wert 10 
   // tut irgendwas bis i den Wert 0 hat
   for i := 10 downto 0 do 
     begin
       // tue irgendwas
     end;
end;

Eine solche Schleife kann auch mit einer while (oder repeat) realisiert werden

Delphi-Quellcode:

var i : Integer;
begin
  // i initialisieren
  i := 0;
  while i <= 10 do 
    begin
      // tue irgendwas
      inc(i); // zähle i um eins hoch 
    end;
end;

Was du in den Schleifenkörper schreibst, ist deine Sache und hängt nicht von der Schleife ab. Zählschleifen eignen sich natürlich immer dann, wenn du wirklich mit einer Variable zählst (z.B. alle Elemente in einem Array). Es ist einfach schöner nicht selbst die Variable zu verändern.
Bei der repeat-Schleife solltest du immer berücksichtigen, dass die Schleife immer mindestens einmal durchlaufen wird. Analog solltest du bei der while berücksichtigen, dass diese Schleife überhaupt nur durchlaufen wird, wenn die Bedingung irgendwann war wird.

Ist eine Bedingung immer wahr, so hast du dir eine Endlosschleife gebaut. In einigen Situationen wirst du so etwas sicherlich mal unabsichtlich machen (dann musst du das Programm über die IDE zurücksetzen). Du kannst es aber auch absichtlich verwenden und eine Schleife (zu jedem Zeitpunkt) mit einem break verlassen.

Delphi-Quellcode:

begin
  // immer wahr -> Endlosschleife
  while True do 
    begin
      break; // verlässt die Schleife sofort
´   end;
end;

Mit Endlosschleifen, die mit break verlassen werden sollte man möglichst wenig arbeiten (besser gar nicht), es ist nicht so wirklich übersichtlich. Aber break kann auch wichtig sein, wenn du z.B. in einem Array einen bestimmten Wert suchst. Sobald du ihn gefunden hast, brauchst du ja den Rest des Feldes nicht mehr beachten.

Delphi-Quellcode:

var i : Integer;
    ints : Array of Integer;
    containsZero : Boolean;
begin
  // erstelle ints und schreib Werte rein
  setLength(ints, 10);
  ints[0] := ...;
  ...
  
  // schau nach ob ints den Wert 0 enthält
  containsZero := False;
  for i := 0 to length(ints) - 1 do 
    begin
      if ints[i] = 0 then
        begin
          containsZero := True;
          break;
        end; 
    end; 
end;

Wenn du dises Schleife durchläufst und ints[4] die erste Null in ints ist, dann würde die for Schleife nie für i = 5..9 durchlaufen werden. Ist deine Schleife nur groß genug lohnt sich das. Allerdings hast du keine Garantie, dass es nicht gar keine 0 gibt oder die erste bei i = 9 steht.

Ja, hoffe es hilft dir ein wenig

Gruß Der Unwissende