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

procedure Check (x: integer);
//sei x die Zahl, die gezogen wurde
begin
  if x>max then
    max:=x //auf den rechten Stapel
  else
    counter:=counter+1; //auf den linken Stapel
end;                    

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

Left           Right
27.9415706     4.0584294
27.9426821     4.0573179
27.9421349     4.0578651
27.9422340     4.0577660
27.9422853     4.0577147                    

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:

procedure TForm1.Button1Click(Sender: TObject);
Var
  Demo: TArray;
  i,j, maxlauf,AnzStLeft,AnzStRight,StRight  :integer;
begin
Memo1.Lines.Add('Karten');
AnzStLeft:=0; AnzStRight:=0;
maxlauf:=StrToint(edit1.text);
SetLength(Demo,32); // Feldgröße festlegen
For j:=1 to maxlauf do
Begin;
  StRight:=0;
  FillArray(Demo,1); // mit aufsteigenden Werten ab 1 belegen
  ShuffleFisherYates(Demo); // mischen
  for i := Low(Demo) to High(Demo) do
  begin;
    If Demo[i]> StRight then
    begin;
      StRight:=Demo[i];
      inc(AnzStRight);
    end
    else
      inc(AnzStLeft);
  end;

End;
left.Caption:=floattostr(AnzStLeft/maxlauf);
right.Caption:=floattostr((AnzStright/maxlauf));                    

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

for i := Low(Demo) to High(Demo) do
    begin
    If Demo[i]> StRight then
      begin;
      StRight:=Demo[i];
      IF Stright = 32 then
        break;
      inc(AnzStRight);
      end
    end;//for i 
  end;//maxlauf 
AnzStLeft := maxlauf*32                    

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

1,2,3,4,..30,31,32: links  0 rechts 32 0!-fach
1,2,3,4,..30,32,31: links  1 rechts 31 1!-fach
1,2,3,4,..32,30,31: links  2 rechts 30 2!-fach Permution der hinteren beiden
...      
1,32,2,3,  ..30,31: links 31 rechts 1 30!-fach Permution von 2..31
32,1,2,3,  ..30,31: links 32 rechts 0 31!-fach Permution von 1..31                    

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

1,2,3,4,..30,31,32: links  0 rechts 32 0!-fach
1,2,3,4,..30,32,31: links  1 rechts 31 1!-fach
1,2,3,4,..32,30,31: links  2 rechts 30 2!-fach Permutation der hinteren beiden
...      
1,32,2,3,  ..30,31: links 31 rechts 1 30!-fach Permution von 2..31
32,1,2,3,  ..30,31: links 32 rechts 0 31!-fach Permution von 1..31                    

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:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:

private void button1_Click(object sender, EventArgs e)
        {
            int counter=int.Parse(textBox1.Text);
            int highcard;
            int drwawncard;
            int gewaehlterindex;
            int counter2 = 0;
            int a=0, b=0;

            for (int x = 0; x < counter; x++)
            {
                counter2 = 0;
                List<int> Karten =new List<int>{};

                for(int x1=1;x1<=32;x1++)
                {
                    Karten.Add(x1);
                }
                gewaehlterindex = rd.Next(1, Karten.Count + 1);
                highcard =Karten[gewaehlterindex-1];
                Karten.Remove(highcard);

                while (Karten.Count != 0)
                {
                    gewaehlterindex = rd.Next(0, Karten.Count);
                    drwawncard = Karten[gewaehlterindex];
                    Karten.RemoveAt(gewaehlterindex);

                    if (drwawncard < highcard)
                    {
                        counter2++;
                    }
                    else
                    {
                        highcard = drwawncard;
                    }
                }
                a = a + counter2;
                Karten.Clear();
                label2.Text = (((long)a / ((double)x)).ToString());
                label2.Refresh();
            }
            
        }                    

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

// perfektes Mischen nach Fisher-Yates (angelehnt an einen Vorschlag von alzaimar)
procedure ShuffleFisherYates(var aArray: TArray);
  var
    i,j: Integer;
    tmp: TArrayElement;
begin
  // alle Elemente des Feldes durchlaufen
  for i := Low(aArray) to High(aArray) do begin
    // neue, zufällig Position bestimmen
    j := i +Random(Length(aArray) -i +Low(aArray));
    // Element Nr. i mit Nr. j vertauschen (3ecks-Tausch)
    tmp := aArray[j];
    aArray[j] := aArray[i];
    aArray[i] := tmp;
  end;
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:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:

{$Apptype console}
uses
  sysutils;
const
  Runden = 100000000;// 1e8
var
  T1,T0: TDateTime;
  Karten : array[0..31] of integer;
  i,j,tp,MaxBisher,AnzRechts,cnt: integer;

procedure swap(i,j:integer);
var
  tmp : integer;
begin
  tmp:= Karten[i];
  Karten[i]:=Karten[j];
  Karten[j]:=tmp;
end;

begin
  T0 := time;
  randomize;
  For i := 0 to 31 do
    Karten[i] := i;
  AnzRechts:= 0;
  cnt := 0;
  For j := 1 to Runden do
    begin
    i := 31;
    tp := random(i+1);
    swap(tp,i);
    inc(cnt);
    inc(AnzRechts);
    MaxBisher := Karten[i];
    while MaxBisher <> 31 do
      begin
      inc(cnt);
      tp := random(i+1);
      swap(tp,i);
      IF  MaxBisher< Karten[i] then
        begin
        MaxBisher:= Karten[i];
        inc(AnzRechts);
        end;
      dec(i);
      end;
    end;
  T1 := time;
  writeln('Karten rechts     ',AnzRechts/Runden:10:7);
  writeln('Karten links      ',32-AnzRechts/Runden:10:7);
  writeln('Karten bis 32 kam ', cnt/Runden:10:7);
  writeln;
  writeln('Zeitdauer ',FormatdateTime('hh:mm:ss.zzz',T1-T0));
  readln;
end.
{
Karten rechts      4.0586284
Karten links      27.9413716
Karten bis 32 kam 16.9848054 // Sollte das nicht 16 sein? 

Zeitdauer 00:00:20.500}                    

1:
2:
3:

type
  TArrayElement = Integer;
  TArray = array of TArrayElement;