Funktion mit n! verschiedenen Möglichkeiten durchführen

[Leonidas]

Dann kopier eben im Schleifenkörper ``b`` in, sagen wir mal ``c`` und modifiziere es. Das wird dann in der nächsten Iteration verworfen und du hast wieder dein ursprüngliches ``b``.

[Daniel_SGe]

hmmm... also wenn ich b kopiere (c=b) hab ich dasselbe Problem wieder... vll. ist ja nicht ganz irrelevant, dass die schleife nur indirekt von b abhängt (nämliche eigentlich for a in f(b, d))...

Die Schleife sieht im Moment so aus:

Code: Alles auswählen

for a in f(b, d)
  c = b
  do ...
 c[a]=[]

Diese Änderung von c bleibt auch beim nächsten Durchlauf...

[BlackJack]

*Achtung*: Bei ``c = b`` wird nichts kopiert, sondern einfach nur der Name `c` an das selbe Objekt gebunden, an das auch `b` gebunden ist! Du hast dann immer noch nur *ein* Objekt, das halt über die beiden Namen ansprechbar ist.

[Daniel_SGe]

Okay, Danke!

Das funktioniert jetzt...

Hab aber nun ein weiteres Problem:

Ich möchte meine Ergebnisreihe, die ich nun erhalte natürlich auch auswerten und schließlich auf die richtige Reihenfolge schließen können.
Dies wäre am einfachsten wenn eine liste "folge" für jede Ebene auch um eine neue Unterebene erweitert werden würde...
Also für die dritte Ebene:

Code: Alles auswählen

folge = [a, [a, [a , b], b, [a, b]], b[...]]
Wenn sich
folge[1][1][0] 

als Ergebnis rausstellen sollte, müsste ich schließlich nur doch die funktionswerte für die jeweiligen schritte angeben...

Ich stolper im Moment darüber, dass ich mit folge[x].append(bla) nur die oberste ebene erreiche. Ist es möglich [x] in abhängigkeit von der Ebene zu betrachten?... (z.b. folge[x1][x2])

[Daniel_SGe]

keiner eine Idee?...

Ich wüsste sonst nicht, wie ich das ganze auswerten soll... Reih ich die Listen einfach normal aneinander erhalte ich pro Rekursionstiefe (n-1) nicht eine Liste der Länge n!*n, sondern etwas weniger... Damit lässt sich eben wenig anfangen... Daher die idee mti den verschachtelten Listen...

[snafu]

Ich stolper im Moment darüber, dass ich mit folge[x].append(bla) nur die oberste ebene erreiche. Ist es möglich [x] in abhängigkeit von der Ebene zu betrachten?... (z.b. folge[x1][x2])

Meinst du einfach nur so?

Code: Alles auswählen

>>> liste = ['a', 'b', 'c', ['x', 'y', 'z']]
>>> liste[3].append('foo')
>>> liste
['a', 'b', 'c', ['x', 'y', 'z', 'foo']]

[Daniel_SGe]

ja, genau... das ganze aber auch noch auf eine rekursive Funktion übertragen... Wenn die Ebene also immer tiefer wird.. z.b. irgendwann liste[1][3][5] usw...

[Daniel_SGe]

So, habs jetzt endlich hinbekommen. Scheint auch soweit jetzt ganz gut zu funktionieren...

Hab jetzt auch schon eine erste Näherungsfunktion geschrieben.
Je nachdem wie groß n ist werden nicht n! sondern n!/(n-var)! möglichkeiten durchprobiert... anschließend wird n um var vberringert und das ganze beginnt von vorne bis n=0 ist...
Wie genau ist so eine Näherung? Es wurde ja bereits angesprochen... Aber wie kann ich wenigstens auch nur ungefähr bestimmen wie groß die Abweichung ist?

//Edit: Nach ein paar Testläufen kann man ganz schön feststellen, was für Abweichungen das sind, je nachdem wie ich eben var festlege. Leider aber auch in der Zeit. Mein letzter Testlauf hat 15% mehr Abweichung gehabt. Leider hat sich dafür die Zeit aber auch vervielfacht... Gibt es Möglichkeiten eventuell dadran zu drehen? Lohnt sich Parallellisierung? bzw. überhaupt umsetzbar?