Array sortieren mit Permutationen..

[Ducksoul]

Hi,

der Topicname ist mal wieder äußerst nichtsaussagend, daher mal eine kurze Erläuterung:

Ich habe ein Array mit folgendem Aufbau:

Delphi-Quellcode:

  jobArray: Array of TJob; 

// wobei:
  TJob = record
          j_id: integer;              // Job-ID --> Prozessintern
          j_prio: integer;            // Priorität
          j_color: string;            // Farbe
          j_name: string;             // Name
          j_proc: Array of integer;   // Prozesszeit pro Maschine

Nach dem Füllen dieses Arrays, sollen die TJob's nach ihrer Prioriät (TJob.j_prio) absteigend sortiert werden. Dies habe ich über folgenden Quicksort Algorithmus gelöst:

Delphi-Quellcode:

procedure QuickSort(var A: array of TJob; iLo, iHi: Integer) ;
var
  Lo, Hi, Pivot: Integer;
  T: TJob;
begin
  Lo := iLo;
  Hi := iHi;
  Pivot := A[(Lo + Hi) div 2].j_prio;
  repeat
    while A[Lo].j_prio > Pivot do Inc(Lo) ;
    while A[Hi].j_prio < Pivot do Dec(Hi) ;
    if Lo <= Hi then
    begin
      T := A[Hi];
      A[Hi] := A[Lo];
      A[Lo] := T;
      Inc(Lo) ;
      Dec(Hi) ;
    end;
  until Lo > Hi;
  if Hi > iLo then QuickSort(A, iLo, Hi) ;
  if Lo < iHi then QuickSort(A, Lo, iHi) ;
end;  // Quicksort

Mein Problem: Ich brauche alle möglichen Permutationen, wenn Jobs mit gleichen Prioritäten vorhanden sind. Hab mir nun so gedacht, dass ich nich das Array an sich speicher, sondern ein neues Array anlege mit den ID's der Jobs in jeweils sortierter Reihenfolge.

Aber wie bekomme ich alle möglichen Permutationen raus? Mit dem rekursiven Quicksort wird das schlecht gehen.


Gruß

[Codewalker]

Permutationen über was? Du kannst (wenn du alle haben willst) nur über einer endlichen Menge die Permutationen bilden. Wenn du also Job + Prio nimmst, müsstest du noch sagen, auf welcher Skala die Zahlen sich bewegen. Und dann heißt es, alle Möglichkeiten auflisten.
Und das werden sehr schnell sehr viele. Die Anzahl der k-stelligen Permutationen über einer n-elementigen Menge sind: n! / (n-k)! .

[Khabarakh]

Funktionen, um gesamte Listen zu permutieren, sollten sich zur Genüge finden lassen, also würde ich erst einmal Jobs mit gleicher Priorität zusammenfassen. Danach setzt du die einzelnen Permutationen wieder zu den ganzen Listen zusammen.

[Ducksoul]

Vielen Dank für den Hinweis.

In Java habe ich das gelöste Problem bereits. Aber da mir in Delphi keine ArrayList zur Verfügung steht fiel mir die Portierung nicht ganz so einfach :)

[Khabarakh]

Na dann solltest du doch über T(Object)List<T> schnell zum Ziel kommen :) .

[Ducksoul]

Ich bin jetzt über mehrdimensionale Arrays gegangen. Ich weiß nun aber nicht wie ich weitermachen soll, bzw. wie ich die Permutationen erzeugen und in das Array schreiben soll.

Bis jetzt erstelle ich ein array EqualPrios (zweidimensional), bei welchem zu jeder Priorität (erste Dimension) die entsprechenden Jobs zu finden sind. Nun möchte ich ja die einzelnen Jobs (vom Typ TJob) untereinander kombinieren.
Dazu habe ich jetzt ein dreidimensionales Array angelegt: 1. Dimension entspricht Prioritär, 2. Dimension sind die Anzahl der möglichen Kombinationen (also Anzahl der Jobs Fakultät) und in der dritten Dimension sollen dann die Jobs immer rein in der jeweiligen Reihenfolge.

Ich bin inzwischen soweit:

Delphi-Quellcode:

    // Anzahl möglicher Kombinationen finden
  SetLength(arr_Kombis, Length(arr_EqualPrios));
  for i := 0 to Length(arr_Kombis) - 1 do
  begin
    SetLength(arr_Kombis[i], getFactorial(Length(arr_EqualPrios[i])));
    CreatePerms(arr_EqualPrios[i], arr_Kombis[i]);
    {for j := 0 to Length(arr_Kombis[i]) - 1 do
    begin
      SetLength(arr_Kombis[i,j], Length(arr_EqualPrios[i]));

    end;}
  end;

Um das ganze n bissl übersichtlicher zu gestalten wollte ich die Elemente und die 2.Dimension des Kombi Arrays in eine Prozedur übergeben, dort in dieses Teilarray die möglichen Kombinationen reinschreiben und fertig.
Aber erstens geht es wohl nicht so wie ich mir das gedacht habe (Übergabe 2-dimensionales Array) und zweitens habe ich zwar nen Algorithmus gefunden, welcher Zahlen permutieren kann (siehe hier), jedoch weiß ich nicht wie ich ihn auf mein Problem anpassen kann.

Über konstruktive Vorschläge wäre ich sehr dankbar.

Gruß

[Khabarakh]

Ich habe gedacht, du hättest das Problem in Java bereits gelöst :?: Dann solltest du es doch 1:1 übernehmen können, wahrscheinlich mit einer TList<TList<TJob>>.

PS: Zur Versicherung, dass ich das Problem überhaupt richtig verstehe - aus einer Liste wie

Code:

(A,3);(B,3);(C,2);(D,1);(E,1) // jeweils (ID,Prio)

willst du die Kombinationen

Code:

ABCDE
BACDE
ABCED
BACED

haben?

[Ducksoul]

Ja, in Java sieht das ganze so aus:

Delphi-Quellcode:

// 5. Generiere Permutationen einer jeden neuen ArrayList
      List<List<List<TJob>>> prio_list = new ArrayList<List<List<TJob>>>();
      for (int i = 0; i < equalPrio_list.size(); i++) {
         int[] indices;
         List<TJob> elements = equalPrio_list.get(i);
         List<List<TJob>> li = new ArrayList<List<TJob>>();
         PermutationGenerator x = new PermutationGenerator(elements.size());
         while (x.hasMore()) {
            indices = x.getNext();
            List<TJob> tj_list = new ArrayList<TJob>(10);
            for (int j = 0; j < indices.length; j++)
               tj_list.add(elements.get(indices[j]));
            li.add(tj_list);
         }
         prio_list.add(li);
      }

Und die Klasse zum Generieren von Permutationen:

Delphi-Quellcode:

//--------------------------------------
// Systematically generate permutations. 
// [url]http://www.merriampark.com/perm.htm[/url]
//--------------------------------------

import java.math.BigInteger;

public class PermutationGenerator {

  private int[] a;
  private BigInteger numLeft;
  private BigInteger total;

  //-----------------------------------------------------------
  // Constructor. WARNING: Don't make n too large.
  // Recall that the number of permutations is n!
  // which can be very large, even when n is as small as 20 --
  // 20! = 2,432,902,008,176,640,000 and
  // 21! is too big to fit into a Java long, which is
  // why we use BigInteger instead.
  //----------------------------------------------------------

  public PermutationGenerator (int n) {
    if (n < 1) {
      throw new IllegalArgumentException ("Min 1");
    }
    a = new int[n];
    total = getFactorial (n);
    reset ();
  }

  //------
  // Reset
  //------

  public void reset () {
    for (int i = 0; i < a.length; i++) {
      a[i] = i;
    }
    numLeft = new BigInteger (total.toString ());
  }

  //------------------------------------------------
  // Return number of permutations not yet generated
  //------------------------------------------------

  public BigInteger getNumLeft () {
    return numLeft;
  }

  //------------------------------------
  // Return total number of permutations
  //------------------------------------

  public BigInteger getTotal () {
    return total;
  }

  //-----------------------------
  // Are there more permutations?
  //-----------------------------

  public boolean hasMore () {
    return numLeft.compareTo (BigInteger.ZERO) == 1;
  }

  //------------------
  // Compute factorial
  //------------------

  private static BigInteger getFactorial (int n) {
    BigInteger fact = BigInteger.ONE;
    for (int i = n; i > 1; i--) {
      fact = fact.multiply (new BigInteger (Integer.toString (i)));
    }
    return fact;
  }

  //--------------------------------------------------------
  // Generate next permutation (algorithm from Rosen p. 284)
  //--------------------------------------------------------

  public int[] getNext () {

    if (numLeft.equals (total)) {
      numLeft = numLeft.subtract (BigInteger.ONE);
      return a;
    }

    int temp;

    // Find largest index j with a[j] < a[j+1]

    int j = a.length - 2;
    while (a[j] > a[j+1]) {
      j--;
    }

    // Find index k such that a[k] is smallest integer
    // greater than a[j] to the right of a[j]

    int k = a.length - 1;
    while (a[j] > a[k]) {
      k--;
    }

    // Interchange a[j] and a[k]

    temp = a[k];
    a[k] = a[j];
    a[j] = temp;

    // Put tail end of permutation after jth position in increasing order

    int r = a.length - 1;
    int s = j + 1;

    while (r > s) {
      temp = a[s];
      a[s] = a[r];
      a[r] = temp;
      r--;
      s++;
    }

    numLeft = numLeft.subtract (BigInteger.ONE);
    return a;

  }

}

Allerdings weiß ich nich wie ich das auf Delphi portieren soll :(

Ich bin nu auch nich so der dolle Programmierer. Und wenns um OO geht, sieht das ganze noch n bissl düsterer aus.


Edit:
Um auf deine Frage zu antworten:

Ich habe ein Array mit TJobs (was Records, welche verschiedene Daten enthalten, sind). Und ich hätte dann wenn ich ein Array

arr ( job1, job2, job3) habe gerne alle 6 möglichen Kombinationen. :)

Gruß


Edit2: Um nicht die Lorbeeren einzuheimsen: Der Javacode ist nicht von mir. Lediglich der Delphicode den ich bis jetzt habe sind meine Ergüsse *g*

[Ducksoul]

Ich habe, weil mein AdHoc Programmieren nichts gebracht hat, nun nochmal von vorne angenfangen und mich auch ein wenig zur TObjectList belesen.

Mein Plan:
1. Erstelle eine Klasse TPriolist mit prio: integer; arr_jobs: array of TJob
2. Für alle Prioritäten erstelle eine Priolist vom Typ TPriolist, gebe prio die Priorität und füge arr_jobs alle Jobs mit dieser Priorität hinzu.
3. Speichere jede Priolist in ol vom Typ TObjectlist
etc...

Das funktioniert auch ganz gut, bis auf dass er die Jobs nicht speichert. Also nachdem ich fertig bin ist in jeder Priolist die Prio gespeichert, die Länge des arr_jobs richtig, aber im Array sind alle Variablen des Jobs 0.

Was hab ich nu schon wieder falsch?

Delphi-Quellcode:

    // verschiedene Prios in Priolist speichern
  for i := 0 to Length(arr) - 1 do
  begin
    contains := false;
    for j := 0 to ol.Count - 1 do
    begin
      Priolist := ol[j] as TPriolist;
      if arr[i].j_prio = Priolist.prio then
        contains := true;
    end;

    if contains = false then
    begin
      Priolist := TPriolist.Create;
      Priolist.prio := arr[i].j_prio;

      for j := 0 to Length(arr) - 1 do
      begin
        size := Length(Priolist.arr_jobs);
        if arr[j].j_prio = Priolist.prio then
        if not subListsContain(Priolist, arr[j]) then
        begin
          Inc(size);
          SetLength(Priolist.arr_jobs, size);
          Priolist.arr_jobs[size] := arr[j];
        end;
      end;
      ol.Add(Priolist);
    end;
  end;

[daywalker9]

Also aufjedenfall erstmal das rausschmeißen:

Delphi-Quellcode:

  if contains = false then

Und dadurch ersetzten:

Delphi-Quellcode:

  if not contains then

Dazu gab es schon etliche Beiträge hier im Forum

[Ducksoul]

hm ja, habe ich letzte Woche sogar schon einen von durchgelesen. Aber an meinem Programmierstil gibts eh noch ne Menge macken. Habe ja effektiv erst zu Beginn meines Praktikums angefangen umfangreichere Sachen zu programmieren (und muss mich zügeln nich jeden Tag dumme Fragen hier ins Forum zu hauen *g*).

Hab das jetzt auch brav geändert. War jedoch nicht die Wurzel des Übels.

Gruß

Edit: Oh man.. Ganze Sätze zu schreiben is schon schwierig ^^

[DeddyH]

Zitat:

Delphi-Quellcode:

for j :=  0 to ol.Count - 1 do
    begin
      Priolist := ol[j] as TPriolist;
      if arr[i].j_prio = Priolist.prio then
        contains := true;
    end;

Auf diese Weise kannst Du Dir die Schleife eigentlich sparen und gleich den letzten Wert nehmen. Du müsstest also nachdem contains ggf. true wird aus der Schleife springen. Das geht entweder mit break oder indem Du statt der for-Schleife eine while-Schleife mit 2 Bedingungen nimmst.

[Ducksoul]

Delphi-Quellcode:

for j :=  0 to ol.Count - 1 do
    begin
      Priolist := ol[j] as TPriolist;
      if Priolist.prio = arr[i].j_prio then
      begin
        contains := true;
        break;
      end;
    end;

So meinst du, oder? Also dass wenn ich merke dass bereits eine Prioliste für eine Priorität besteht die Schleife abgebrochen wird und nicht auch noch die restlichen Listen durchforstet werden.


Edit:

Aber um nochmal auf ein Problem zurückzukommen.

In meiner Testumgebung habe ich 6 Jobs:

Delphi-Quellcode:

Job1: id=0, prio=7
Job2: id=1, prio=7
Job3: id=2, prio=7
Job4: id=3, prio=5
Job5: id=4, prio=3
Job6: id=5, prio=3

Soll-Ergebnis meiner Funktion wäre

Delphi-Quellcode:

ol[0] --> prio7, arr_jobs(Job1, Job2, Job3)
ol[1] --> prio5, arr_jobs(Job4)
ol[2] --> prio3, arr_jobs(Job5, Job6)

Ist-Ergebnis meiner Funktion wäre

Delphi-Quellcode:

ol[0] --> prio7, arr_jobs(leererJob, leererJob, leererJob)
ol[1] --> prio5, arr_jobs(leererJob)
ol[2] --> prio3, arr_jobs(leererJob, leererJob)

Soll heißen: Es werden Jobs in die Liste eingefügt, welche dann aber alle nil sind :-/
Was mach ich hier falsch?

[Khabarakh]

Wir kennen deine Funktion subListsContain nicht, aber ich kann dir auch so sagen, dass du zu kompliziert denkst und vor allem quadratische Laufzeit fabriziert, hast, wo auch O(n) möglich wäre.

Delphi-Quellcode:

// arr : TList<TJob>
ol := TList<TPrioList>.Create;

for Job in arr do
  prioList := bestehende TPrioList aus ol mit Prio = arr.Prio oder TPrioList.Create;
  prioList.Add(Job);

Das ist der ganze Zauber ;) .

(Gut, mit TList ist es immer noch quadratisch...)

[Ducksoul]

Räusper...

Ich habe die Jobs immer außerhalb des Arrays geschrieben:

Ursprünglich:

Delphi-Quellcode:

Priolist.arr_jobs[size] := arr[j];

Richtig:

Delphi-Quellcode:

Priolist.Jobs[size-1] := arr[j];

@Kabarakh:
Irgendwie is dein Code mir zu einfach. Der will sich mir nich erschließen :-D

[Ducksoul]

Hallo, ich hoffe das is nu die letzte Frage zu diesem Thema:

Ich habe jetzt alle Permutationen pro Prio, möchte die nun zusammenführen.

Also angenommen:

Delphi-Quellcode:

Prio1:
Kombi (J1, J2), (J2, J1)

Prio2:
Kombi (J3)

Prio3:
Kombi (J4, J4, (J5, J4)

--->
resultarray:
J1, J2, J3, J4, J5
J2, J1, J3, J4, J5
J1, J2, J3, J5, J4
J2, J1, J3, J5, J4

Ich habe jetzt probiert das über folgenden Code zu realisieren:

Delphi-Quellcode:

  kz := 0;
  while kz < count do
  begin
    sz := 0;
    for i := 0 to ol.Count - 1 do
    begin
      Priolist := ol[i] as TPriolist;
      for j := 0 to Length(Priolist.Jobs) - 1 do
      begin
        arr_finkombis[kz,sz] := Priolist.Kombis[Priolist.counter, j];
        Inc(sz);
      end;

      Inc(Priolist.counter);
      if Priolist.counter >= Length(Priolist.Kombis) then
        Priolist.counter := 0;
    end;
    Inc(kz);
  end;

kz zählt die Zeile des resultarray
sz zählt die Spalte des resultarray
Jedes mal wenn eine Kombi einer Prio durchgelaufen ist wird ein Zähler hochgezählt, so dass beim nächsten mal die darauffolgende Kombi genommen wird.
Wurden alle Kombis der Prio einmal durchgelaufen, so wird der Zähler wieder null gesetzt und die Kombiliste der Prio wird neu durchlaufen.


Aber das Problem ist, dass ich ja den Counter einer Prioliste erst höher setzen darf, wenn alle kleineren Listen einmal durchgelaufen sind. Ich habe mir gedacht Ne .change Variable in die Klasse Priolist integrieren und wenn ne Liste durchgelaufen is setze ich change auf true.
Und wenn alle kleineren Listen change auf true sind, dann gehe ich erst zur nächsten Kombination.

Ist das ein praktikabler Weg oder gehts evtl. besser?

Gruß

[Khabarakh]

Das dürfte rekursiv leichter zu lösen sein:

Code:

function Kombis(kz, sz, i : Integer) : Integer
  if i = ol.Length then
    Exit(1)

  nPerms := ol[i].Permutationen.Length
  for j = 0 to nPerms - 1 do
    nUnterkombis := Kombis(kz+j, sz + nPerms, i + 1)
    for kz' = kz + j to kz + nUnterkombis - 1 do
      Kopiere permutation nach [kz',sz]

  Exit(nPerms * nUnterkombis)

Keine Ahnung, ob das verständlich ist, also mal ein Beispiel ;) :
Wir haben zwei Priolisten [a,b] und [c,d]. Wir beginnen bei Kombis(0, 0, 0): nPerms von [a,b] ist 2, die erste Permutation der ersten Liste ist [a,b] und wir rufen Kombis(0, 2, 1) auf.
Darin ist nPerms wieder 2, die erste Permutation [c,d]. Für diese rufen wir Kombis(0, 4, 2) = 1 auf, kopieren [c,d] also nur nach [kz+j=0, 2].
Für [d,c] ist kz+j = 1, unterkombis wieder 1, also wird nach [1,2] kopiert.

Code:

- - c d
- - d c
- - - -
- - - -

Wir kehren mit dem Ergebnis 2 * 1 zu i = 0 zurück, [a,b] wird also nach [0+0,0] und [0+1,0] kopiert.

Code:

a b c d
a b d c
- - - -
- - - -

Weiter geht's mit [b,a]...

[Ducksoul]

Huhu,

danke für deinen Tipp, aber das löst mein Problem nicht so recht. Also die Prios in mein Array schreiben und so klappt ja, aber ich muss irgendwie die die Kombinationen tauschen, um alle Möglichkeiten zu erhalten.

In meinem jetzigen Verfahren, bei dem:

Prio1: J1, J2, J3
Prio2: J4,
Prio3: J5, J6

erhalte ich folgendes:

Code:

012345
021354
102345
120354
201345
210354

Und zwar 2x

Fehlen tut:

Code:

012354
021345
102354
120345
201354
210345

Ich weiß aber nichtmal wie die universelle mathematische Lösung dieses Problems wäre. Da macht sich das schlecht diese auch noch in Code umzusetzen *g*

Code bisher:

Delphi-Quellcode:

    // Kombiniere die Kombis der einzelnen Prioritäten
  SetLength(arr_finKombis, count);
  for i := 0 to Length(arr_finKombis) - 1 do
    SetLength(arr_finKombis[i], jobCount);

  for i := 0 to ol.Count - 1 do
  begin
    Priolist := ol[i] as TPriolist;
    kz := 0;
    loops := count div Length(Priolist.Kombis);

    j := 0;
    while j < loops do
    begin
      for k := 0 to Length(Priolist.Kombis) - 1 do
      begin
        sz := 0;
        for l := 0 to ol.Count - 1 do
        begin
          pt := ol[l] as TPriolist;
          if pt.prio = Priolist.prio then
            Break;
          sz := sz + Length(pt.Jobs);
        end;

        for l := 0 to Length(Priolist.Kombis[k]) -1 do
        begin
          arr_finKombis[kz,sz] := Priolist.Kombis[k,l];
          Inc(sz);
        end;
        Inc(kz);
      end;
      Inc(j);
    end;

Is nich so schön kurz und prägnat wie dein Code, aber er macht auch was er soll. :)

[Khabarakh]

Zitat:

Zitat von Ducksoul

danke für deinen Tipp, aber das löst mein Problem nicht so recht.

Ääh, doch? Wenn ich meinen Algorithmus weiterlaufen lasse, ist das Ergebnis

Code:

a b c d
a b d c
b a c d
b a d c

Das ist doch wohl eine Lösung für dein Problem, oder etwa nicht?

[Ducksoul]

Ja bei jeweils 2 Permutationen funktioniert es bei mir auch.

Versuch mal P1(J1, J2, J3) und P2(J4, J5). Da kommen bei mir nach der Hälfte nochmal die gleichen Endkombinationen raus, da ich mit P2 in umgekehrter Reihenfolge beginnen müsste.
Oder hab ich da grad nen ganz argen Denkfehler?

Gruß

EEEDIT: Ne warte mal. Dein Code macht das ja doch anders... Ich editiere dann nochmal, wenn ich deinen Tipp zu Ende durchdacht habe. ^^

Edit 2: Boah ich hab schon keine reine Informatik studiert, weil ich Mathe und so ne Logikprobleme hasse und nu schon wieder sowas... (Offtopic, um meinen Verfassungszustand ma n bissl zu schildern x-p)

Hier mein Zwischenstand:

Delphi-Quellcode:

function KombiGenerator(kz, sz, i: integer) : integer;
var
  nPerms, nUnterkombis, j, kz_, jobs, k: integer;
  Priolist: TPriolist;
begin
  Priolist := ol[i] as TPriolist;

  if i = ol.Count-1 then
    Exit(1);

  jobs := Length(Priolist.Jobs);
  nPerms := Length(Priolist.Kombis);
  for j := 0 to jobs - 1 do
  begin
    nUnterkombis := KombiGenerator(kz+1, sz+jobs, i+1);
    for kz_ := (kz+j) to (kz+nUnterkombis) - 1 do
    begin
      for k := 0 to jobs - 1 do
        resultarray[kz_,sz] := Priolist.Kombis[j,k];
    end;
  end;
  Exit(jobs * nUnterkombis);

end;

Funktioniert so ja natürlich noch nicht. Ich hab nur erstmal deinen Pseudocode umgesetzt. Wenn ich weiter bin geb ich wieder bescheid.

[Ducksoul]

Ich habe das Problem jetzt gelöst.. Naja, hatte ich zumindest. Dann is die IDE abgestürzt und nu bekomm ich immer Access Violations die ich noch nicht ganz nachvollziehen kann.
Dazu mache ich dann aber einen neuen Thread ^^

Erstma zu dem Thema hier:

@Kabarhak: Dein Algorithmus war eine Lösung für einen Spezialfall: Es treten nur jeweils 2 gleiche Prios auf. Ansonsten war eine richtite Lösung nicht garantiert.

Meine Herangehensweise:
Berechne für jede Priolist die Anzahl der darauffolgenden möglichen Kombinationen und trage jede Kombi der Liste so oft ins Resultarray. Letztlich war die Lösung simpel.

Hier der Code:

Delphi-Quellcode:

 for i := 0 to jobCount - 1 do
  begin
    for j := 0 to wcCount - 1 do
    begin
      if (i = 0) and (j=0) then
      begin
        resultarray[x,i].j_st[j] := 0;
        resultarray[x,i].j_ft[j] := resultarray[x,i].j_proc[j];
      end else begin
        if (i = 0) and (j >= 1) then
        begin
          resultarray[x,i].j_st[j] := resultarray[x,i].j_ft[j - 1]
        end
        else if (j = 0) and (i >= 1) then
        begin
          resultarray[x,i].j_st[j] := resultarray[x,i - 1].j_ft[j]
        end
        else
        begin
          resultarray[x,i].j_st[j] := Max(resultarray[x,i].j_ft[j - 1], resultarray[x,i - 1].j_ft[j]);
        end;
        resultarray[x,i].j_ft[j] := resultarray[x,i].j_st[j] + resultarray[x,i].j_proc[j];
      end;
    end;
  end;

Lief ohne Exceptions bis zu meinem jetzigen Problem. Vielen Dank für die Hilfe an alle :)

Gruß
Franz

[Khabarakh]

Zitat:

Zitat von Ducksoul

Kabarhak

Danke.

Zitat:

Zitat von Ducksoul

Dein Algorithmus war eine Lösung für einen Spezialfall

Nö. Der Fehler in deinem Code ist die Variable jobs, die es in meinem überhaupt nicht gibt. /edit: Sind noch ein paar Abschreibfehler drin

Zitat:

Zitat von Ducksoul

Berechne für jede Priolist die Anzahl der darauffolgenden möglichen Kombinationen und trage jede Kombi der Liste so oft ins Resultarray. Letztlich war die Lösung simpel.

Ich verstehe deinen Code zwar nicht (was bei der Namensgebung kein großes Wunder ist - wcCount finde ich allerdings gut ;) ), aber das Prinzip kenne ich doch irgendwoher :gruebel: .

...

Naja, wenigstens läufts ;) .

[Ducksoul]

Der Code den ich da von dir abgeschustert hatte war nur ein halbherziger Versuch endlich weiterzukommen. Da ich aber zu dem Zeitpunkt noch nich wirklich hintergestiegen war was du meinst haben mir allerdings ein wenig Elan und Verständnis gefehlt ^^
Naja seis drum. Wie du schon sagst: Wenigstens läufts ^^

PS:

Zitat:

Zitat von Khabarakh

Zitat:

Zitat von Ducksoul

Kabarhak

Danke.

+h :hi:

[Horst_]

nichts