![]() |
Permutation (mögliche Kombinationen)
Moin, moin,
Ich habe eine Menge von Teilen (max. 100 Stück), welche ich miteinander kombinieren will um zu testen ob bestimmte Kriterien eingehalten werden. Wenn ich mich so richtig erinnere hat dieses etwas mit Permutationen zu tun. Kennt einer einen brauchbaren Algorithmus, welcher alle möglichen Kombinationen ausgibt wenn N Werte zur Verfügung stehen. Wenn N z.B. 5 ist, sollen alle Kombinationen ausgegeben werden welche die Buchstaben ABCDE ergeben können. In jeder Kombination darf ein Buchstabe nur einmal vorkommen. |
AW: Permutation (mögliche Kombinationen)
|
AW: Permutation (mögliche Kombinationen)
Da gibt es n! Kombinationen.
Ich befürchte, daß mehr als n zwischen zehn und zwanzig aus Laufzeitgründen nicht mehr geht. |
AW: Permutation (mögliche Kombinationen)
Gibt's als Algorithmen bei Knuth.
Für Permutationen ![]() und für Kombinationen ![]() oder für Klick-Klack-Techniker von ![]() bzw ![]() |
AW: Permutation (mögliche Kombinationen)
@gammatester :-D (bezieht sich auf die ersten beiden links)
|
AW: Permutation (mögliche Kombinationen)
Das ist vielleicht ein schönes Thema für SQL (Daten-Mengen), Kreuzprodukte, ..
Sobald man 2. Mengen vereint und keine geeigneten Join Kriterien festlegt, permutiert es quasi von allein. :) |
AW: Permutation (mögliche Kombinationen)
Ich habe mir jetzt einmal einen Teil des Codes geladen und angepasst. Das Problem mit der Laufzeit bei Kombinationen mit mehr als 6 Zeichen ist da. Ich habe aber noch eine anderes Problem und zwar gibt es bei mehr als 11 Zeichen einen Integerüberlauf.
Delphi-Quellcode:
Ideen gesucht :cry:
procedure Form1.Button1Click(Sender: TObject);
{$APPTYPE CONSOLE} const anz_c : integer = 12; type TItem = char; TArray = array[0..12] of TItem; procedure Permutation(K: Integer; var A: TArray); var I, J : Integer; Tmp : TItem; begin for I:= 1 to (anz_c + 1) do begin J := K mod I; Tmp := A[J]; A[J] := A[I-1]; A[I-1]:= Tmp; K := K div I; end; end; var A : TArray; I, K, Count, anz : Integer; S, S1, S2 : ShortString; Source : TArray; begin for I := 0 to anz_c do source[i] := chr(65+i); Count:= 1; anz := 0; I:= Length(A); while I > 1 do begin Count:= Count * I; Dec(I); end; S:= ''; for K:= 0 to Count - 1 do begin A:= Source; Permutation(K, A); S1:= ''; for I:= 0 to anz_c do begin s2 := A[I]; S1:= S1 + S2; end; inc(anz); S:= S + ' ** ' + S1; if Length(S) > 40 then begin Writeln(S); S:= ''; end; end; if Length(S) > 0 then Writeln(S); writeln('Anz : ', anz); Readln; end; |
AW: Permutation (mögliche Kombinationen)
Zitat:
Ach, hier noch eine kleine Routine:
Delphi-Quellcode:
Diue Prozedure 'Log' musst Du selbst schreiben (Ausgabe in Memo, speichern in Stringlist o.ä.)
Procedure Perm (Const aString : String);
Procedure _Perm (Const aPrefix, aString : String); Var i,len : Integer; Begin len := Length (aString); If len = 1 Then Log (aPrefix+aString) Else For i:=1 to l do _Perm (aPrefix+aString[i], Copy (aString,1,i-1)+Copy (aString,i+1,l-i)); End; Begin _Perm ('',aString); End; |
AW: Permutation (mögliche Kombinationen)
@dejan vu:
Das ist eine Frage der Abbildung der Werte. Wenn alles in einem Feld steht, ist es eine blöde Frickelei. Ähnliche wie bei 27 For Schleifen mit Integer-Überlauf. Es ist vielleicht nicht Ressourcen schonend, aber bequem, schnell gemacht und flexibel. |
AW: Permutation (mögliche Kombinationen)
Je nach Art der Kriterien kannst du den Suchraum vielleicht auch einschränken. Da kommt es dann auf die Details an.
|
AW: Permutation (mögliche Kombinationen)
So richtig kann ich damit leider nichts anfangen.
Was ich suche ist eigentlich ein Generator der mir bei einer Vorgabe von n möglichen Eingangswerten alle möglichen Kombinationen dieser n Eingangswerte wiedergibt. Maximal können dieses 99 Eingangswerte sein. Bis 11 Eingangswerte ging dieses gut, aber dann gab es dieses Problem. |
AW: Permutation (mögliche Kombinationen)
Zitat:
Was soll bei drei Eingabewerten herauskommen, die die Werte A, B oder C annehmen können? Was erwartest Du eigentlich bei 99 Eingabewerten? Was machst Du mit den Ausgaben? Wie lange willst Du warten? |
AW: Permutation (mögliche Kombinationen)
Zitat:
|
AW: Permutation (mögliche Kombinationen)
Bei n=99 wird es ein Ergebnis von rund 93326215443944152681699238856267000000000000000000 00000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000 000000 Datensätzen geben (laut Windows Taschenrechner, und wenn ich bei den Nullen nicht 1-2 falsch gezählt habe - aber eh unwichtig). Wenn jedes der 99 Elemente ein Byte groß ist, wird das Ergebnis grob 84030901497958176291724381797125000000000000000000 00000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000 Terabyte umfassen. (Ebenfalls die gleiche Unsicherheit mit den Nullen, aber auch hier ziemlich egal.)
So. Selbst wenn man es so machen würde, dass man nicht alle Ergebnise vorab speichert (was diverse Erden an Gesamtkapazität aller je gebauten Speichermedien konsumieren dürfte...), müsste man diese dennoch alle durchprüfen. Selbst wenn man dies jetzt bloß auf den Datendurchsatz aktuellen DDR3 RAMs berechnen würde, kann ich mir gut vorstellen, dass man das Endergebnis der Auswertung ungefähr kurz vor der Supernova unserer Sonne ablesen könnte. So ganz grob geschätzt. Fazit: Entweder du kannst Einschränkungen machen, oder das Vorhaben ist von Anfang an komplett und vollständig, ohne Wenn und Aber, schlicht und ergreifend unmöglich. Ein Integer-Überlauf ist hier mit sicherheit das kleinste aller Probleme. |
AW: Permutation (mögliche Kombinationen)
Ist einleuchtend.
Danke für die Antwort. Vielleicht gibt es nächsten Jahrtausend eine Antwort darauf. Zwischenspeichern muss ich übrigens immer nur eine Variante (Kombination), da ich mit jeder Ausgabe einer Kombination teste ob sie bestimmte Kriterien erfüllt. Die Variante (Reihenfolge der Werte) die am dichtesten am Ziel liegt wird sich gemerkt. Wenn eine bessre gefunden ist, wird die alte überschrieben. |
AW: Permutation (mögliche Kombinationen)
|
AW: Permutation (mögliche Kombinationen)
Zitat:
Gehe ich recht in der Annahme, dass jedes Element in einer Kombination nur einmal auftauchen darf?
Code:
Wenn du die beste Kombination haben möchtest, warum willst du dann erst alle Kombinationen zusammenbauen?
Menge (1,2,3,4)
gültig sind (1,2), (1,3), (1,2,3) ungültig sind (1,1), (1,2,2) Wenn (1,2) die Kriterien nicht erfüllt und man weiß, dass diese Kombination auch nicht besser wird, wenn die mit einem anderen Element kombiniert wird, dann kann man diese Kombinationen schon mal komplett ausnehmen und spart sich eine Menge weiterer Prüfungen. |
AW: Permutation (mögliche Kombinationen)
Das nennt sich 'pruning', das der Traversierungsbaum beschnitten (engl: to prune) wird. Wenn man z.B. weiß, das (1,2) vollkommener Schrott ist und auch (1,2,x,y,z...) dann kann man getrost alle Derivate ignorieren. So wird in der klassischen Spieletheorie der Suchbaum (Schach z.B.) drastisch verkürzt.
Aber da der Fragesteller wohl selbst nicht weiß, was er will und Fragen nicht beantworten kann, soll er halt weiter friemeln. |
AW: Permutation (mögliche Kombinationen)
Vielleicht braucht man ja auch nicht suchen, sondern kann das Ergebnis konstruieren. Wer weiß?
Ohne ein wenig Details zu Bedingungen kann man noch nicht mal versuchen, eine ordentliche Vermutung anstellen. Wenn du wirklich nichts verraten willst oder das Problem zu kompliziert ist und das Problem nicht unbedingt mit Delphi lösen musst, kannst du dir mal ![]() |
AW: Permutation (mögliche Kombinationen)
Zitat:
Da Rekursion einer der zentralen Deklarationsmetapher von Prolog ist, dürfte die Implementierung auch alles andere als Obersuperoptimal sein, obwohl ein Prolog-Interpreter tail recursion iterativ auflösen sollte. Prolog wird teilweise bei Expertensystemen eingesetzt, sodass man hier prüfen müsste, inwieweit der TE ein derartiges System benötigt. |
AW: Permutation (mögliche Kombinationen)
Zitat:
|
AW: Permutation (mögliche Kombinationen)
Zitat:
|
AW: Permutation (mögliche Kombinationen)
Zu Beitrag 17
Nein ganz so einfach ist dieses nicht. Ich habe maximal 99 Teillängen. Diese will ich auf Paletten legen die eine Länge von 12 Metern haben. Mir geht es jetzt darum, dass ich diese Teile so kombiniere, dass ich möglichst wenige Paletten brauche. Hinzu kommt noch folgende Schwierigkeit dass ich in der Mitte eines Abstellung habe wo das letzte Teil von der 1. Hälfte der Belegung maximal um 40 cm überstehen darf. Teile, deren Länge > 6.4 m sind, fallen von vorne sowieso raus. :( |
AW: Permutation (mögliche Kombinationen)
![]() |
AW: Permutation (mögliche Kombinationen)
Zitat:
Rucksack-Problem sehe insgesamt auch nicht: Es sollen schließlich keine Teillängen zu hause bleiben und man hat mehrere Paletten. Mir sieht das eher nach der Optimierungsvariante von ![]() NP-schwer, aber die Approximationsalgorithmen sind nicht so schlecht. |
AW: Permutation (mögliche Kombinationen)
Zitat:
|
AW: Permutation (mögliche Kombinationen)
Zitat:
|
AW: Permutation (mögliche Kombinationen)
Zitat:
|
Alle Zeitangaben in WEZ +1. Es ist jetzt 22:48 Uhr. |
Powered by vBulletin® Copyright ©2000 - 2025, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz