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:

procedure Perm(ex: Integer); // ex entspricht der ordnungszahl.
var
  i   : Byte;
  anz : Integer;

  procedure Switch(x,y: Byte);
  var
    tmp : Byte;
  begin
    tmp := permAr[x];
    permAr[x] := permAr[y];
    permAr[y] := tmp;
  end;

  procedure permint(n: Byte);
  var
    k : Byte;
  begin
    if n=0 then
    begin
      inc(anz);
      if anz >= ex then exit; // das bricht entsprechend dem zähler ab.
    end
    else
      for k:=n downto 1 do
      begin
        Switch(k,n);
        permint(n-1);
        if anz >= ex then exit; // das bricht entsprechend dem zähler ab.
        Switch(k,n);
      end;
  end;

begin
  anz := 0;
  for i:=1 to 9 do permAr[i] := i;
  permint(9);
end;					

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

function BruteForce(cNb: Cardinal; Const sCh: String): String;   
begin   
  Result := '';   
  while cNb > Length(sCh) do begin   
    dec(cNb);   
    Result := sCh[cNb mod Length(sCh) + 1] + Result;   
    cNb := cNb div Length(sCh);   
    end;   

  if cNb > 0 then   
    Result := sCh[cNb] + Result;   
end;					

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

Function NthPermutation (aString : String; aCount : Integer) : String;
Var
  d : Array Of Integer;
  g, i, n : Integer;

Begin
  n := Length (aString);
  setlength (d, n);
  d[1] := 1;
  For i := 2 to n - 1 do d[i] := i * d[i-1];
  Result := '';
  for i := n-1 downto 1 do begin
    g := (aCount div d[i]) + 1;
    Result  := Result  + aString[g];
    delete (aString, g, 1);
    aCount := aCount mod d[i];
    End;
  Result := Result  + aString;
End;					

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

Function NthPermutation (const aString : AnsiString; aCount : Integer) : AnsiString;
Var
  pos, i, n : Integer;// bei cardinal wurde 64Bit gerechnet 
  chTemp : char;
Begin
  n := Length(aString);
  result := aString;

  for i := n downto 2 do
    begin
    n := acount DIV i;   // n ist ja ab jetzt frei fuer was anderes
    pos := acount-n*i +1;//acount mod i +1
    acount := n;
    //switch
    chTemp := result[i];
    result[i] := result[Pos];
    result[Pos] := chTemp;

    acount :=  acount div i;
    End;
End;					

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

Function NthPermutation (const aString : AnsiString; aCount : NativeInt) : AnsiString;
Var
  pos, i, n : NativeInt;
  chTemp : char;
Begin
  result := aString;
  n := Length(aString);
  for i := n downto 2 do
    begin
    // acount= acount DIV i && Pos = acount mod i
    DivMod(acount,i,acount,pos);
    //swap
    chTemp := result[i];
    result[i] := result[Pos+1];
    result[Pos] := chTemp;
    End;
End;					

1:
2:

P3 1400 C  PM 1500 C  P4 1600 A  P4 2800 E  XP 2500+  Opteron 240
   517         384         488         291         409         525      ms