Funktion mit n! verschiedenen Möglichkeiten durchführen

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Leonidas
Administrator
Beiträge: 16024
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

Montag 15. September 2008, 21:58

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``.
My god, it's full of CARs! | Leonidasvoice vs Modvoice
Daniel_SGe
User
Beiträge: 28
Registriert: Montag 8. September 2008, 19:39

Dienstag 16. September 2008, 14:45

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

Dienstag 16. September 2008, 15:51

*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
User
Beiträge: 28
Registriert: Montag 8. September 2008, 19:39

Dienstag 16. September 2008, 18:19

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
User
Beiträge: 28
Registriert: Montag 8. September 2008, 19:39

Samstag 20. September 2008, 13:03

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...
Benutzeravatar
snafu
User
Beiträge: 5440
Registriert: Donnerstag 21. Februar 2008, 17:31
Wohnort: Gelsenkirchen

Samstag 20. September 2008, 15:01

Daniel_SGe hat geschrieben: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
User
Beiträge: 28
Registriert: Montag 8. September 2008, 19:39

Samstag 20. September 2008, 16:37

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
User
Beiträge: 28
Registriert: Montag 8. September 2008, 19:39

Mittwoch 24. September 2008, 18:25

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?
Antworten