1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

//Speicher: TKarte;
//KartenNummer1, KartenNummer2: Byte; //mehr als 255 Karten wären zuviel :D
for i := 0 to 1000 do
begin
KartenNummer1:= Random( High(Karten) ) +1;
KartenNummer2:= Random( High(Karten) ) +1;
Speicher := Karten[ KartenNummer1 ];
Karten[ KartenNummer1 ] := Karten[ KartenNummer2 ];
Karten[ KartenNummer2 ] := Speicher;
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

//var ZwischenKarten: Array of TKarte;
//i und C sind Counter vom Typ Byte
{for i := 0 to 1000 do //wieder 100 mal "abheben"
begin
Anzahl := Random( High(Karten)-1 ) +2; //mindests 2 Karten abheben
setlength(ZwischenKarten, length(Karten))
 For C := Anzahl+1 to High(Karten) do
  ZwischenKarten[C-Anzahl] := Karten[C];
 For C := 1 to Anzahl do
  ZwischenKarten[C+Anzahl] := Karten[C];

For C:= 1 to High(Karten) do
 Karten[C] := ZwischenKarten[C];

setlength(ZwischenKarten, 0);
end;} //FALSCH ! nach der Beschreibung korrekt, aber bitte siehe Edit !					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

//var neuerHaufen: Array of TKarten;
//g: Byte; //von Oben genommen (g = genommen)
//n: Byte; //zu nehmenden karten (von oben auf neuen stapel);
//c, Anzahl: Byte // Counter für For-Schleife
For Anzahl := 1 to 1000 do //1000 mal haufen durchmischen
begin
setlength(neuerHaufen, Length(Karten));
g := 0;
repeat
n := Random( High(Karten) - g) +1;
For C:=1 to n do
 neuerHaufen[ High(neuerHaufen) - C +1] := Karten[C];
g := n;
until g>=(HighKarten-1);

//wieder in "andere Hand" legen
For C:=1 to High(Karten) do
 Karten[C] := neuerHaufen[C];
setlength(neuerHaufen, 0);
end;					

1:
2:
3:
4:
5:
6:
7:

    for i:=n-1 downto 0 do
    begin
      j:=random(n);
      h:=a[i];
      a[i]:=a[j];
      a[j]:=h;
    end;					

1:

while Kartenummer2=Kartenummer1 do randomAgain;					

1:
2:
3:
4:

Kartennummer2 := Random(High(Karten-1)+1; //-1 muss ergänzt werden, da sonst die Kartennummer2 über der Range des
//Arrays liegen kann !, falls man die range dann wieder abziehen würde wäre die Wahrscheinlichkeit für das 1ste Element doppelt so groß wie die auf die anderen!
//damit es also stochastisch korrekt bleibt: 
if Kartennummer2>=Kartennummer1 then inc(Kartenummer2)					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

procedure TStapel.Mischen;
var c, j, n: Byte;
    Karte1, Karte2: TKarte;
    gF: TFarbe;
    gW: TWert;
begin
Karte2 := Erste;
for c:=Anzahl downto 1 do
    begin
      j := random(Anzahl)+1;
      Karte1 := Erste;
      For n:=j downto 2 do
        Karte1 := Karte1.darunter;
      gF := Karte2.Farbe;
      gW := Karte2.Wert;
      Karte2.Farbe := Karte1.Farbe;
      Karte2.Wert := Karte1.Wert;
      Karte1.Farbe := gF;
      Karte1.Wert := gW;
    //if c>1 then
    Karte2 := Karte2.darunter;
    end;
end;					

1:
2:
3:
4:
5:
6:
7:

begin
KartenNummer1:= Random( High(Karten) ) +1;
KartenNummer2:= Random( High(Karten) ) +1;
Speicher := Karten[ KartenNummer1 ];
Karten[ KartenNummer1 ] := Karten[ KartenNummer2 ];
Karten[ KartenNummer2 ] := Speicher;
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:

type
  TKartenStapel = class(TObjectList)
  protected
    procedure Swap(a, b: Integer);
  public
    procedure Mischen;
  end;

implementation

procedure TKartenStapel.Swap(a, b: Integer);
var
  t: TObject;
begin
  if a <> b then
  begin
    t := Items[a];
    Items[a] := Items[b];
    Items[b] := t;
  end;
end;

procedure TKartenStapel.Mischen;
var
  n: Integer;
begin
  for n := Count - 1 downto 1 do
    Swap(n, Random(n + 1));
end;					

1:
2:
3:

For n := Count-1 downto 0 do
//oder
For n := Count downto 1 do					

1:
2:
3:

Random(Count) //bei index-begin = 0
//oder
Random(Count) +1 //bei index-begin = 1