FOR-Schleifen Problem

[delphinub23]

Guten Tag Community,

ich bin neu in der Welt der Programmierung und versuche mir gerade Grundwissen anzueignen.

Nun zu meinem Problem:
Ich möchte ein paar Zahlen zufällig generieren lassen. Danach soll eine Ausgabe der generierten Zahlen ausgegeben werden. Zusätzlich soll vermieden werden, dass gleiche Zahlen generiert werden.

Um die Random() Funktion nutzen zu können, muss ich einmal Randomize rufen (?)

Delphi-Quellcode:

procedure TFmMain.FormCreate(Sender: TObject);
begin
  // Nur einmal rufen
  Randomize;
end;

Und hier meine Schleife

Delphi-Quellcode:

procedure TFmMain.btnGenClick(Sender: TObject);
var
  // Hier sollen die Zahlen zwischengespeichert werden
  rZahl: array[0..15] of integer; 
  temp, i: integer;
begin
  // Fehler: Schleife wird mit dem Startwert 16 abwärts durchlaufen
  for i := Low(rZahl) to High(rZahl) do
  begin
    temp := Random(16);

    // aktuelle Zahl mit dem Vorgänger vergleichen
    while (rZahl[i] = rZahl[i-1]) do
    begin
      // Neu generieren
      temp := Random(16);
      rZahl[i] := temp;
    end;
    // Ausgabe
    txtRandoms.Text := txtRandoms.Text + IntToStr(rZahl[i]) + '; ';
  end;
end;

ich hoffe ihr könnt mir helfen :)

Beste Grüße,
dnub

[Luckie]

Und wo ist jetzt der Fehler? Dass die Schleife rückwärts durchlaufen wird ist eine Optimierung des Compilers.

[delphinub23]

Achso! Das habe ich nicht gewusst :oops:
Nur leider kommt totaler Quark raus wenn die Ausgabe erfolgt.
Was habe ich falsch gemacht?

[guinnes]

Zitat:

Zitat von Luckie (Beitrag 1091968)

Und wo ist jetzt der Fehler? Dass die Schleife rückwärts durchlaufen wird ist eine Optimierung des Compilers.

Dürfte wohl eine Zugriffsverletzung sein, oder ?
Womit willst du die 1. Zahl vergleichen ?

[delphinub23]

Nein, eine Zugriffverletzung tritt nicht auf. Das liegt sicherlich an dem Startwert 16 oder? Ich möchte die aktuelle Zahl mit der vorherigen vergleichen um auszuschließen, dass keine nochmal auftritt.

[rollstuhlfahrer]

Natürlich kommt da Quark raus. Du hast ein unbestimmtes Array und fängst an, dieses zu prüfen. Meckert Delphi nicht, dass da Variablen nicht initialisiert wurden und deshalb unbestimmt sind?

Bernhard

[guinnes]

Zitat:

Zitat von delphinub23 (Beitrag 1091975)

Das liegt sicherlich an dem Startwert 16 oder? Ich möchte die aktuelle Zahl mit der vorherigen vergleichen um auszuschließen, dass keine nochmal auftritt.

Das ist mir schon klar. Meine Frage war: Womit vergleichst du bei I = 0 ?
Richtig, mit rZahl[-1] und das gibt es nicht
Setze ausserhalb der Schleife den Zufallswert von rZahl[0] und lass die Schleife von Low(rzahl) + 1 bis High(rzahl) laufen

edit
Dazu kann es natürlich immer noch vorkommen, dass Zahlen doppelt sind, weil du ja immer nur mit der letzten Zahl vergleichst

[delphinub23]

Ok. Das macht Sinn.

So bekomme ich generierte Zahlen:

Delphi-Quellcode:

procedure TFmMain.btnGenClick(Sender: TObject);
var
  rZahl: array[0..15] of integer;
  LastIndex, temp, i: integer;
begin
  // Generate randoms
  for i := Low(rZahl)+1 to High(rZahl) do
  begin
    temp := Random(16);
    rZahl[i] := temp;
    txtRandoms.Text := txtRandoms.Text + IntToStr(rZahl[i]) + '; ';
  end;
end;

Aber so kommen einige Zahlen mehrfach vor und das will ich unterbinden.
Gibt es noch einen besseren Ansatz, als meinen Quark?

[rollstuhlfahrer]

Nimm eine Liste (z.B. TList) und lasse diese nach dem Zufallsprinzip sortieren. Dann hast du deine Zahlen immer in unterschiedlicher Reihenfolge.

Bernhard

PS: Tipp: TList.Sort()

[guinnes]

Zitat:

Zitat von delphinub23 (Beitrag 1091979)

Gibt es noch einen besseren Ansatz, als meinen Quark?

Klar. Nimm ein Array of Boolean, initialisiere es ändere die While-Schleife so, dass du die neu gezogene Zahl als Index in das Array benutzt und schau nach, ob da schon ein True drinsteht, wenn ja-> neue Zahl ziehen, wenn nein -> das Feld im Array auf true setzen.

[delphinub23]

Danke für eure Hilfe! Ich probiere es mal mit dem Boolean-Array.

[Aphton]

Ich habe einen einfacheren und leichter nachvollziehbaren Vorschlag für dich:
Zuerst - du benutzt Random(16) - dh es wird ein Zufallswert zwischen 0 und 15 zurückgeliefert. Nennen wir diese Zahl X um alles variabel zu halten. (X=16)
Übrigens muss X >= Länge von rZahl sein, damit keine Zahl doppelt vorkommt! (dh es müssen genug Zahlen vorhanden sein)

- Erstelle ein dynamisches Array der Länge X
- Fülle diese mit den Indexwerten (Also DynArr[0] := 0; DynArr[1] := 1, ..)
- Gehe alle Elemente von rZahl durch (i)
- ermittle ein Zufallsindexwert j := Random(Length(DynArr))
- führe folgende Zuweisung durch: rZahl[i] := DynArr[j]
- Lösche Element j aus DynArr

[guinnes]

Das macht aber nur dann Sinn, wenn du x Zahlen aus y Möglichkeiten ziehen willst. Willst du jede Zahl einmal haben, ist der Vorschlag mit der Liste natürlich besser

[Aphton]

Wenn x = y dann hast du denselben Effekt!
Edit: Und in seinem Fall entspricht X (16) der Länge des Array rZahl (0..15 = 16)

[Sir Rufo]

Ist natürlich nicht wirklich performant.
So eine Zufallszahlen-Liste ist schneller mit einer zufälligen Sortierung erreicht.

Aber hier mal dein Ansatz komplettiert:

Delphi-Quellcode:

var
  rZahl :   array [0 .. 15] of Integer;
  temp, i : Integer;
  Unique :  Boolean;
  j :       Integer;
begin
  // Erste Zufalls-Zahl setzen (die ist per Definition auch einzigartig im Array)
  rZahl[ low( rZahl )] := Random( 16 );

  // Wir Starten mit dem 2. Array-Eintrag
  i := low( rZahl ) + 1;

  while i <= high( rZahl ) do
    begin

      repeat

        // Unique-Flag
        Unique := True;
        // Neue Zufallszahl ermitteln
        temp := Random( 16 );
        // mit allen bisherigen Zufallszahlen vergleichen
        for j := low( rZahl ) to i - 1 do
          // Wenn es die schon gibt, dann ...
          if rZahl[j] = temp
          then
            begin
              // ... ist die also nicht mehr einzigartig
              Unique := False;
              // und wir können diese For-Schleife auch schon verlassen
              Break;
            end;

        // solange wiederholen, bis wir eine einzigartige Zufallszahl erhalten haben
      until Unique;

      // Zufalls-Zahl dem Array zuweisen
      rZahl[i] := temp;

      // Ausgabe der Zahl
      txtRandoms.Text := txtRandoms.Text + IntToStr(rZahl[i]) + '; ';

      // und zum nächsten Array-Eintrag hüpfen :-)
      inc( i );
    end;
end;

[Aphton]

Da wir schon Snippets posten

Delphi-Quellcode:

var
  rZahl: Array[0..15] of Integer;
  i, j, k: Integer;
  a: Array of Integer;
begin
  SetLength(a, Length(rZahl));
  for i := 0 to High(a) do
    a[i] := i;
  k := Length(a);
  for i := 0 to High(rZahl) do
  begin
    j := Random(k);
    rZahl[i] := a[j];
    a[j] := a[k-1];
    dec( k );
    txtRandoms.Text := txtRandoms.Text + IntToStr( rZahl[i] ) + '; ';
  end;
end;

[rollstuhlfahrer]

Da finde ich die Listen-Variante doch besser, weil bei dieser (#15) Variante hier der Computer vor allem bei den letzten Feldern überproportional lange braucht (wirkt sich zwar erst bei viel viel mehr Zahlen aus, aber egal). Ein weiterer Punkt, der für die Listenvariante spricht ist, dass das Sortieren per Quicksort geschieht (also wunderbar schnell) und das Auftreten eventueller Fehler im Quelltext ist viel unwahrscheinlicher. Außerdem kann man bei einer Liste auch genau bestimmen, welche Elemente man haben will und welche nicht.

Bernhard

ADD: Dann auch ein Snippet von mir:

Delphi-Quellcode:

type
  TDasArray = array[0..15] of integer;

function Zufallsarray(): TDasArray;
  function RandomSort(Item1, Item2: Pointer): Integer;
  var
    DummyArray: array[0..1] of Integer; // Wird benötigt, da Delphi sonst nicht zurechtkommt (doppeldeutiger Funktionsaufruf)
  begin
    DummyArray := [-1, 1]; // Hoffe das geht so ;)
    Result := RandomFrom(DummyArray);
  end;

var
  Liste: TList;
  i: INteger;
begin
  Liste := TList.Create;
  try
    try
      // Füllen:
      for i := 0 to 15 do
        Liste.Add(Pointer(i+1));

      // "Sortieren"
      Liste.Sort(RandomSort);

      // Jetzt noch das Array füllen
      for i := 0 to 15 do
        Result[i] := Integer(Liste[i]);

    except
      on E: Exception do
      begin
        // Irgendwo ein Fehler passiert? - 0-Array zurückgeben
        ZeroMemory(@Result, SizeOf(Result));
        raise E; // Exception nach oben weiter geben (benötigt??)
      end;
    end;
  finally
    // Ganz wichtig: Nachher aufräumen!
    Liste.Free;
  end;
end;

Das ist jetzt auch mit Speicherschutzblöcken hoffentlich 100% korrekt.

[Aphton]

Erzeugt das Benutzen von Listen nicht mehr Overhead als ein dynamisches Array zu erstellen (siehe #16)?
Listen sind unnötig! Dessen Sortierung braucht man auch nicht!

[delphinub23]

Danke für alle Posts! Mir persönlich gefällt die Variante von Sir Rufo am besten.

[Aphton]

Diese Variante ist aber recht unperformant.
Mag dennoch verständlicher sein, als meine Variante!

[delphinub23]

So funktioniert es wie ich es brauche. Nur die Zuweisung des 1. Feldes muss mit in die Schleife, da sonst der 1.te eintrag bei der Ausgabe fehlt.

Danke Sir Rufo!

Delphi-Quellcode:

procedure TFmMain.btnGenClick(Sender: TObject);
var
  rZahl : array [0..9] of Integer;
  temp, i : Integer;
  Unique : Boolean;
  j : Integer;
begin
  txtRandoms.Clear;
  i := Low(rZahl);
  while i <= High(rZahl) do
  begin
    repeat
      Unique := True;
      temp := Random(10);
      for j := Low(rZahl) to Pred(i) do
        if rZahl[j] = temp then
        begin
          Unique := False;
          Break;
        end;
    until Unique;
    rZahl[i] := temp;
    txtRandoms.Text := txtRandoms.Text + IntToStr(rZahl[i]) + '; ';
    Inc(i);
  end;
end;

[himitsu]

Zitat:

Zitat von delphinub23 (Beitrag 1091975)

Nein, eine Zugriffverletzung tritt nicht auf.

Geh mal in die Projektoptionen und aktiviere dort die Überlauf- und die Bereichsprüfung.

Und schon kommt deine Zugriffsverletzung.
Du hast nur Glück, daß an der falschen stelle, wo zu zugreifst zufällig etwas anderes liegt und es somit nicht gleich knallt.

Zitat:

Delphi-Quellcode:

except
  on E: Exception do
  begin
    // Irgendwo ein Fehler passiert? - 0-Array zurückgeben
    ZeroMemory(@Result, SizeOf(Result));
    raise E; // Exception nach oben weiter geben (benötigt??)
  end;
end;

Beim ZeroMemory, muß beachtet werden, da es hier auf dieses statische Array angepaßt ist ... also je nach Typ, muß es anders gelöst werden.

Zitat:

(benötigt??)

is besser so, auch wenn man es kürzen kann.

Delphi-Quellcode:

except
  ZeroMemory(@Result, SizeOf(Result));
  raise;
end;

[rollstuhlfahrer]

Zitat:

Zitat von himitsu (Beitrag 1092016)

Beim ZeroMemory, muss beachtet werden, da es hier auf dieses statische Array angepaßt ist ... also je nach Typ, muß es anders gelöst werden.

Für dynamische Arrays würde ich ein

Delphi-Quellcode:

SetLength(<Array>, 0);

empfehlen.

Bernhard