In einem Projekt, an dem ich gerade arbeite, habe ich ungefähr 80% dessen implementiert, was mein Programm tun soll, und ich bin sehr zufrieden mit den Ergebnissen.

In den verbleibenden 20% stehe ich vor einem Problem, das mich ein wenig verwirrt, wie ich es lösen soll. Hier ist es:

Ich habe mir eine Liste mit Listen ausgedacht, die mehrere Zahlen enthalten (beliebige Länge). Zum Beispiel:

listElement[0] = [1, 2, 3]
listElement[1] = [3, 6, 8]
listElement[2] = [4, 9]
listElement[4] = [6, 11]
listElement[n] = [x, y, z...]

wo n bis zu 40.000 oder so erreichen könnte.

Angenommen, jedes Listenelement ist eine Menge von Zahlen (im mathematischen Sinne), dann möchte ich alle Kombinationen von sich gegenseitig ausschließenden Mengen ableiten. das heißt, wie das Powerset der obigen Listenelemente, jedoch mit Ausnahme aller nicht disjunkt gesetzten Elemente.

Um das Beispiel mit n = 4 fortzusetzen, möchte ich eine Liste mit den folgenden Kombinationen erstellen:

newlistElement[0] = [1, 2, 3]
newlistElement[1] = [3, 6, 8]
newlistElement[2] = [4, 9]
newlistElement[4] = [6, 11] 
newlistElement[5] = [[1, 2, 3], [4, 9]]
newlistElement[6] = [[1, 2, 3], [6, 11]]
newlistElement[7] = [[1, 2, 3], [4, 9], [6, 11]]
newlistElement[8] = [[3, 6, 8], [4, 9]]
newlistElement[9] = [[4, 9], [6, 11]

Ein ungültiger Fall wäre beispielsweise die Kombination [[1, 2, 3], [3, 6, 8]], da 3 in zwei Elementen gemeinsam ist. Gibt es eine elegante Möglichkeit, dies zu tun? Für jede Rückmeldung wäre ich sehr dankbar.

Ich muss auch angeben, dass ich die Powerset-Funktion nicht ausführen möchte, da die anfängliche Liste eine große Anzahl von Elementen enthalten kann (wie ich bereits sagte, n kann bis zu 40000 Elemente umfassen), und wenn das Powerset mit so vielen Elementen verwendet wird, wird es niemals beendet .