Keine doppelten Zufallszahlen mehr

[Khabarakh]

Jetzt ist meine Variante im Vorteil :

Delphi-Quellcode:

procedure RandomArray(var AArray: array of Integer; const AStart, AStep, ACount: Integer);
var
  List: TList;
  i, Index: Integer;
begin
  if ACount < Length(AArray) then
    raise EInvalidArgument.Create('ACount muss größer/gleich der Länge von AArray sein');
  List := TList.Create;
  try
    i := AStart;

    repeat          // erst alle Werte in die Liste packen, ...
      List.Add(Pointer(i));
      Inc(i, AStep);
    until i = AStart + AStep * ACount;

    for i := Low(AArray) to High(AArray) do  // ...dann zufällig einen rauspicken
    begin
      Index := Random(List.Count);
      AArray[i] := Integer(List.Items[Index]);
      List.Delete(Index);
    end;

  finally
    List.Free;
  end;
end;

(EInvalidArguement ist in "Math" deklariert)
Falls niemand wieder einen Super-Algorithmus vorlegt, werde ich diesen Code morgen in den Library-Thread posten .

[Flocke]

@Khabarakh: Deine Methode hat den Nachteil, dass die Werte immer denselben Abstand haben, also nicht wirkliche Zufallszahlen zwischen 1 und 100 sind, sondern z.B. 12, 22, 32, 42 usw.

Der Algorithmus von alzaimar war IMHO besser, allerdings hat er die Veränderung an der falschen Stelle eingebaut.

Delphi-Quellcode:

Const 
  Count = 100;  // <-- hier 100
Var 
  A : Array[0..Count-1] of Integer; 
  I, J, T : Integer; 
begin 
  For I := 0 to Count-1 do 
    A[I] := I;  // <-- hier lassen 
  For I := 0 to Count-1 do 
  begin 
    J := I+random(Count-I); 
    T := A[J]; 
    A[J] := A[I]; 
    A[I] := T; 
  end; 
  // und dann einfach nur die ersten 10 Elemente aus dem Array nehmen!
end;

[kurtm1]

@alzaimar: deine variante funzt eh

Zitat von alzaimar:

aha

Delphi-Quellcode:

Var
  l : Array [0..9] Of Integer;
  r,i : Integer;

Begin
  For i := 0 to 9 do 
    Repeat
      a[i] := Random (100);                        // Randomzahl einfügen
      j := 0;  
      while a[j]<>a[i] do inc (j);             // Die gleiche Zahl suchen
    Until i=j; // Wenn die gleiche Zahl an Pos i steht, ist sie eindeutig
// Hier sind in a[0..9] eindeutige Zufallszahlen.
End;

Diese Variante funktioniert dafür aber perfekt

[alzaimar]

@Khabarakh: Deine Version verwendet zu viele Klassen (äh, Eine ) Bäh
@Flocke: Gut gesehen

Fazit: Flockes Modifizierung liefert den schnellsten Algorithmus, da O(n). Meiner und der von Khabarakh sind O(n^2).