salut
voila j'ai besoin de générer une suite de nombres entiers aléatoires tous différents, j'ai essayé d'utiliser une boucle while mais je m'y suis perdue un petit peu.....voila ou j'en suis:

je stock les nombres générés dans un vecteur
ensuite j'utilise une boucle infini du type (while (1=1)) et dans cette boucle je vérifie que la nouvelle valeur générée est différentes de toutes celles stocké dans le vecteur
si elle est effectivement différente alors je sors de la boucle avec un (break)

mais pour le moment ça ne marche pas et je n'arrive pas à arranger ça

type
  TIntegerList = class(TList)
  protected
    function GetItem(Index: Integer): Integer;
    procedure SetItem(Index: Integer; AInteger: Integer);
  public
    property Items[Index: Integer]: Integer read GetItem write SetItem; default;
    function First: Integer;
    function Last: Integer;
    function Add(AInteger: Integer): Integer;
    procedure Insert(Index: Integer; AInteger: Integer);
    function IndexOf(AInteger: Integer): Integer;
    function Extract(Item: Integer): Integer;
    function Remove(AInteger: Integer): Integer;
  end;

{ TIntegerList }

function TIntegerList.Add(AInteger: Integer): Integer;
begin
  Result := inherited Add(pointer(AInteger));
end;

function TIntegerList.Extract(Item: Integer): Integer;
begin
  Result := Integer(inherited Extract(Pointer(Item)));
end;

function TIntegerList.First: Integer;
begin
  Result := Integer(inherited First);
end;

function TIntegerList.GetItem(Index: Integer): Integer;
begin
  Result := Integer(inherited Items[Index]);
end;

function TIntegerList.IndexOf(AInteger: Integer): Integer;
begin
  Result := Integer(inherited IndexOf(Pointer(AInteger)));
end;

procedure TIntegerList.Insert(Index: Integer; AInteger: Integer);
begin
  inherited Insert(Index, pointer(AInteger));
end;

function TIntegerList.Last: Integer;
begin
  Result := Integer(inherited Last);
end;

function TIntegerList.Remove(AInteger: Integer): Integer;
begin
  Result := inherited Remove(Pointer(AInteger));
end;

procedure TIntegerList.SetItem(Index: Integer; AInteger: Integer);
begin
  inherited Items[Index] := Pointer(AInteger);
end;


{ ------ }

{ convert an IntegerList to StringList
}
procedure IntegerListToStringList(IntList: TIntegerList; StrList: TStrings);
var N : integer;
begin
  StrList.BeginUpdate;
  try
    StrList.Clear;
    for N := 0 to IntList.Count-1 do
      StrList.Add(IntToStr(IntList.Items[N]));
  finally
    StrList.EndUpdate;
  end;
end;

{ Generate list of random number in range 0..ATo-1

  parameters :
    ATo       [i] integer, max value of random number
    ACount    [i] integer, max generated number
    List      [i] TIntegerList, List of generated number
    Duplicate [i] boolean, true for accept duplicate entrie

  return :  
    integer, total count of generated number
}
function GenerateRandomInt(const ATo, ACount: integer; List: TIntegerList;
                           const Duplicate: boolean=false) : integer;
var C,R: integer;
begin
  List.Clear;

  if ACount > ATo then
    result := ATo
  else
    result := ACount;

  C := 0;
  repeat
    if duplicate then
      R := Random(ATo)
    else
      repeat
        R := Random(ATo);
      until List.IndexOf(R) = -1;
    List.Add(R);
    inc(C);
  until C = result;
  result := C;
end;

{ ------ }

procedure TForm3.Button1Click(Sender: TObject);
var iList : TIntegerList;
begin
  iList := TIntegerList.Create;
  try
    GenerateRandomInt(1000000,10,iList);
    IntegerListToStringList(iList, ListBox1.Items);
  finally
    iList.Free;
  end;
end;

---

ce sera peut etre plus performant (et surement plus gourmand) en utilisant un tableau de pointeurs vers la valeur precedente.

type
  Entier = cardinal;
var
 Valeurs: Array[Entier] of Pointer;
  DerniereValeur: Entier;

procedure AddEntier(AEntier: Entier): Boolean;
begin
  if Assigned(Valeurs[AEntier]) then
    Result := false
  else
  begin
    Result := true;
    Valeurs[AEntier] := @Valeurs[DerniereValeur];
    DerniereValeur := AEntier;
  end;
end;

ce bout de code n'est qu'une ebauche pas forcement fonctionnelle, mais ca peut te donner une idee.
la notion importante est que  tu peux directement savoir si un chiffre est pris en verifiant le pointeur à son adresse.
tu peux lister les elements deja utilises en parcourant recursivement les pointeurs.

ça c'est une réponse "à la Foxi" !  :-D

cependant:
until C = result;
result := C;

Je crois que la seconde ligne n'est pas utile.

aussi, j'ajouterais un test pour éviter les freez lors des appel stupide genre "1'000 valeurs, val max = 30, no duplicate"

@Guillemouze:
les list chaînée d'entier, c'est pas très performant, vu que les pointeurs sont eux-même des entiers. Donc, je vois pas bien le gain...

Sinon, c'est vrai qu'un tableau alloué en une fois serait plus performant (mais moins flexible) qu'une TIntegerList.

bon week-end,

Loda

---

Se poser les bonnes questions est le premier pas pour trouver les bonnes réponses.

merci beaucoup pour ces réponses
mais y a t'il un autre moyen plus simple parceque je ne métrise pas vraiment la notion de pointeur et j'ai peur de m'y perdre.

merci encore et bon week end

voila ou j'en suis:


procedure TForm1.Button1Click(Sender: TObject);
var
alea, egale:boolean;
i,n,k,g,nb:integer;
H:array [0..50] of integer;
begin
n:=StrToInt(edit1.Text);
SG1.RowCount:=n;
randomize;
H[0]:= randomrange(1,n+1);
nb:=0;
alea:=false;
egale:=false;
        while (1=1)and (not alea) do
            begin
                  g:=RandomRange(1,n+1);
                  for i:=0 to nb do
                  begin
                      if g = H[i] then
                              begin
                              egale:=true;
                              break;
                              end;
                  end;
                  if (i=nb)and (not egale) then
                      begin
                        alea:= true;
                        H[i+1]:=g;
                      end;
           end;
end;

mais pour le moment ça ne marche pas .....je crois que mon test d'arrêt n'est pas satisfait