1:

schluessel := 9^0 * Anzahl_Karten_Typ1 + 9^1 * Anzahl_Karten_Typ2 + 9^2 * Anzahl_Karten_Typ3 + ...					

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

1..8 => 0..7
Die "größte" Kombination: 8/7/6/5/4 ist dann 7/6/5/4/3 =32099
wenn es nur 7 Karten gibt 6/6/5/4/3 = 29027 => 3829 Byte, aber 4096  sind wohl auch zu ertragen ;-)
//Eintüten
j := 0;
For i := 4 downto 0 do
  j := j*8+Perm[i];//j shl 3+ 
PermFeld[permCount]:= j;
...
//Auspacken
j:= PermFeld[permpos];
For i := 0 to 4 do
  Perm:= j AND 7;
  j := j div 8;//shr 3
  end;					

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

testeZuege(Verfuegbare Züge)
wenn (roboter tot)
       // breche ab
sonst wenn #Verfügbare Zuge = 3
      // Berechne heuristischen Wert der erreichten Stellung, wenn > max. bisher gefundener Wert:
      // Speichere Permutation, die hierher geführt hat, und zugehörigen Wert
sonst
       für jeden verfügbaren Zug
              hänge diesen Zug an aktuelle Lösung an, entferne ihn aus "Verfügbare Züge"
              rufe dich rekursiv auf
              hänge den Zug wieder ein					

1:
2:
3:

x
---
o					

1:
2:
3:
4:
5:

  o
 / \
o   o
 \ /
  o					

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:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:

program Perm5aus8;
{$IFDEF FPC}
  {$mode Delphi}
  {$DEBUGINFO-}
  {$R- $V- $O-}
  {$Optimization ON}
  {$Optimization regvar}
  {$Optimization PEEPHOLE}
  {$Optimization CSE}
  {$Optimization ASMCSE}
{$ELSE}
  {$APPTYPE CONSOLE}
{$ENDIF}

const
  cMaxCardsOnDeck = 8;
  CMaxCardsUsed   = 5;
type
  tDeckIndex = 0..cMaxCardsOnDeck-1;
  tSequenceIndex = 0..CMaxCardsUsed-1;

  tDiffCardCount = 0..6;

  tMengenElem     = record
                      Elemcount : tDeckIndex;
                      Elem  : tDiffCardCount;
                    end;

  tMenge          = record
                      maxElem   : word;//= SizeOf(tMengenElem) -1..High(tDeckIndex);
                      RestMenge : array [low(tDiffCardCount)..High(tDiffCardCount)] of tMengenElem;
                    end;

  tRestmengen     = array [low(tSequenceIndex)..High(tSequenceIndex)+1] of tMenge;

  tAuswahlStapel  = array [low(tDeckIndex)..High(tDeckIndex)] of tDiffCardCount;
  tCardSequence   = array [low(tSequenceIndex)..High(tSequenceIndex)] of tDiffCardCount;
  tPermRec        = packed record 
                      permTiefe : byte;// Stelle der Änderung gegenüber Vorgängerpermutation
                      permCardSequence :tCardSequence ;
                    end;   
  tPermArray      = array of tPermRec;

  tPropArray      = array of tDiffCardCount;
//Erzeugen aller moeglichen Ziehungen ohne Beachtung der Reihenfolge
  tCardStr = String[4];
const
  //alphabetisch geordnet, aber unwichtig
  cCardText : array[tDiffCardCount] of tCardStr =
               ('MB','MF 1','MF 2','MF 3','RL','RR','RU');
{ Karten
Titel   Anzahl   Wahrscheinlichkeit
Bewegung 3 Felder vorwärts   0.071 (1/14)
Bewegung 2 F. vorwärts     0.143     (2/14)
Bewegung 1 F. vorwärts      0.214     (3/14)
Bewegung 1 F. rückwärts   0.071
Nach links drehen (90 Grad)   0.214
Nach rechts drehen (90 Grad)   0.214
Umdrehen (180 Grad)   0.071               }
  cCardprop : array[tDiffCardCount] of integer = (1,3,2,1,3,3,1);

var
  PermCount  : integer;

 // globale Variable, um Stelle der Änderung gegenüber der
 // Vorgänger permutation festzuhalten
  mindepth   : integer;

  AusgangsMenge : tMenge;
  Restmengen: tRestmengen;
  PropArray : tPropArray;
  PermFeld  : tPermarray;

  CardSequence :tCardSequence;

function GetCPU_Time: int64;
type
  TCpu = record
            HiCpu,
            LoCpu : Dword;
         end;
var
  Cput : TCpu;
begin
  asm
  RDTSC;
  MOV Dword Ptr [CpuT.LoCpu],EAX
  MOV Dword Ptr [CpuT.HiCpu],EDX
  end;
  with Cput do
    result := int64(HiCPU) shl 32 + LoCpu;
  end;

//*****************************************************************************
function Fakultaet(i:integer): integer;
begin
  result := 1;
  while i > 1 do
    begin
    result := result * i;
    dec(i);
    end;
end;

function NueberK(n,k:byte):longint;
var
  i : longint;
begin
  {n ueber k ist = n ueber (n-k) , also kuerzere Version waehlen}
  If k > n div 2 then
    k := n-k;
  result := 1;
  If k<= n then
    For i := 1 to k do
      result := result*(n-i+1) div i;{geht immer  ohne Rest }
end;

procedure CardSequenceAusgeben(const inCards:tCardSequence);
var
  i : integer;
begin
  For i := low(tCardSequence) to High(tCardSequence) do
    write(cCardText[inCards[i]],' ');
  writeln;
end;

procedure Wahrscheinlichkeiten;
var
  i,j,
  maxcnt: integer;
begin
  maxCnt := 0;
  For i := low(cCardprop) to High(cCardprop) do
    inc(maxCnt,cCardprop[i]);
  setlength(PropArray,maxcnt);
  For i := low(cCardprop) to High(cCardprop) do
    For j := 1 to cCardprop[i] do
      begin
      dec(maxcnt);
      PropArray[maxCnt] := i;
      end;
end;

procedure MengeInit(var ioMenge:tMenge);
var
  i : integer;
begin
  with ioMenge do
    begin
    maxElem := High(tDiffCardCount);
    For i := Low(tDiffCardCount) to High(tDiffCardCount) do
      with RestMenge[i] do
        begin
        ElemCount := 0;
        Elem      := i;
        end;
    end;
end;

procedure MengeAusgeben(const inMenge:tMenge);
var
  i,j : integer;
begin
  with inMenge do
    begin
    write(MaxElem:3,'..');
    For i := 0 to MaxElem-1 do
      with RestMenge[i] do
        For j := 0 to ElemCount-1 do
          write(cCardText[Elem],',');
    end;
  //letztes Komma entfernen
  writeln(#8,' ');
end;

procedure MengeAufsteigendSortieren(var Ausgangsmenge:tMenge);
var
  Startmenge : tMenge;
  i,j,k : integer;
begin
Startmenge := Ausgangsmenge;

Ausgangsmenge.maxElem := 0;
repeat
  //Suche die maximale Mehrfachheit eines Elementes
  k := 0;
  with Startmenge do
    For i := low(tDiffCardCount) to high(tDiffCardCount) do
      with Restmenge[i] do
        if k< ElemCount then
          begin
          k := ElemCount;
          j := Elem;
          end;
  //Keins mehr vorhanden. Und tschuesz
  if k = 0 then
    break;
  // Eintragen in Ausgangsmenge
  with Ausgangsmenge do
    begin
    with Restmenge[maxElem] do
      begin
      ElemCount:= k;
      Elem := j;
      end;
    inc(MaxElem);
    end;
  //Entfernen aus Startmenge
  Startmenge.Restmenge[j].ElemCount :=0;
until false;

end;

procedure ZufallsMenge(var ioMenge:Tmenge);
var
  c,
  i : integer;
begin
  MengeInit(ioMenge);
  c := length(PropArray);
  For i := Low(tDeckIndex) to High(tDeckIndex) do
    inc(ioMenge.RestMenge[PropArray[random(c)]].ElemCount);
  MengeAufsteigendSortieren(ioMenge);
end;

procedure Permute(depth:integer);
var
  i : integer;
  pMengeElem : ^tMengenElem;
begin
  i := 0;
  pMengeElem := @RestMengen[depth].RestMenge[i];
  repeat
    if  pMengeElem^.Elemcount <> 0 then begin
        //Element entnehmen
        CardSequence[depth] := pMengeElem^.Elem;
        dec(pMengeElem^.ElemCount);
        IF depth = CMaxCardsUsed-1 then begin
          
         {write(RestMengen[depth].MaxElem:3,mindepth:2,'  ');
          CardSequenceAusgeben(Cardsequence);}
          
          with PermFeld[permCount] do begin
            permTiefe := mindepth;
            permCardSequence := CardSequence;
            end;
          inc(permCount);
          mindepth := depth;
          end
        else begin
          RestMengen[depth+1]:= RestMengen[depth];
          Permute(depth+1);
          //Element wieder einfuegen
          inc(pMengeElem^.ElemCount);
          dec(minDepth);
          end;
        end;
    inc(pMengeElem);
    inc(i);
  until i >=RestMengen[depth].MaxElem;
end;

procedure  Testlauf(const inMenge:tMenge);
var
  T1,T0 : int64;
begin
  PermCount := 0;
  Restmengen[0] := inMenge;
  MengeAusgeben(inMenge);

  T0 := GetCPU_Time;
  Permute(0);
  T1 := GetCPU_Time;
  
  writeln(permCount:8,' moegliche verschiedene Anordnungen.');
  Writeln((T1-T0):0,' Cpu-Takte gesamt.');
  Writeln((T1-T0)/permCount:0:0,' Cpu-Takte pro Anordnung.');
  writeln;  
end;

const
  Runden = 2000000;
var
  T1,T0 : int64;
  i,cnt :integer;
BEGIN
randomize;
Wahrscheinlichkeiten;

cnt := 0;
T0 := GetCPU_Time;
For i := 1 to Runden do
 begin
 ZufallsMenge(Ausgangsmenge);
 inc(cnt,Ausgangsmenge.maxElem);
 end;
T1 := GetCPU_Time;
writeln(cnt/Runden:0:5,' mittlere Anzahl an verschiedenen Karten');
Writeln((T1-T0)/Runden:0:0,' Cpu-Takte pro zufaelligem Kartendeck');

i := Fakultaet(cMaxCardsUsed)*NueberK(cMaxCardsOnDeck,cMaxCardsUsed);
writeln(i,' maximale Anzahl Perms');
writeln;
setlength(PermFeld,i);

// Kartendecks mit 7,6,5,4,3,2,1 veschiedenen Karten testen
For i := High(tDiffCardCount)+1 Downto 1 do
  begin
  repeat
    ZufallsMenge(Ausgangsmenge);
  until Ausgangsmenge.Maxelem = i;
  Testlauf(Ausgangsmenge);
  end;
//Aufraeumen
setlength(PermFeld,0);
readln;
END.

{freepascal 2.4.2
4.61482 mittlere Anzahl an verschiedenen Karten
1025 Cpu-Takte pro zufaelligem Kartendeck
6720 maximale Anzahl Perms

  7..RR,RR,MB,MF 1,MF 2,MF 3,RL,RU
    3720 moegliche verschiedene Anordnungen.
250529 Cpu-Takte gesamt.
67 Cpu-Takte pro Anordnung.

  6..RR,RR,RR,MF 1,MF 2,MF 3,RL,RU
    1520 moegliche verschiedene Anordnungen.
106279 Cpu-Takte gesamt.
70 Cpu-Takte pro Anordnung.

  5..MF 1,MF 1,MF 1,RR,RR,MB,MF 3,RL
     820 moegliche verschiedene Anordnungen.
54101 Cpu-Takte gesamt.
66 Cpu-Takte pro Anordnung.

  4..RL,RL,RL,MF 1,MF 1,RR,RR,MF 3
     440 moegliche verschiedene Anordnungen.
27337 Cpu-Takte gesamt.
62 Cpu-Takte pro Anordnung.

  3..RR,RR,RR,RR,RR,MF 1,MF 1,RL
      71 moegliche verschiedene Anordnungen.
6686 Cpu-Takte gesamt.
94 Cpu-Takte pro Anordnung.

  2..RR,RR,RR,RR,RR,RR,RR,MF 1
       6 moegliche verschiedene Anordnungen.
3096 Cpu-Takte gesamt.
516 Cpu-Takte pro Anordnung.

  1..RL,RL,RL,RL,RL,RL,RL,RL
       1 moegliche verschiedene Anordnungen.
533 Cpu-Takte gesamt.
533 Cpu-Takte pro Anordnung.}