Loop für 3^9 möglichkeiten schreiben

hm ...
eine innere schleife ueber die meoglichkeiten und eine auessere ueber die ereignisse.
so simple ist es doch bestimmt nicht, oder?!?

sollte genau so simpel sein
könnte auch nur eine schleife für 9 ereignisse mit 3 if abfragen innerhalb der schleife sein, wenn es eindeutig beschränkte Bereiche gibt.
Du müsstest die Ereignisse und Möglichkeiten genauer definieren damit man dir helfen kann.

Die Aufgabe interessiert mich auch. Gib bitte ein paar mehr Hintergrund Informationen. Könnte man bestimmt auch rekursive realisieren.

Ich hab es dann gelöst bekommen.
Es ging um eine simulation von der bundesligatabelle.
Leider bin ich bei der restlichen Tabelle schon bei 3^36 möglichkeiten. Das krieg ich hier nicht berechnet

der code sieht optisch haesslich aus und daher ist auch meist irgendwas falsch

warum machste das denn nicht mit for schleifen?

1. for statt while (und wenns das nicht gibt, hast du ne ranzige Sprache gewählt).

2. <= 3 und < 4 ist das Gleiche.

3. for(int i = 1; i <= 3^9; i++). 3^9 darfst in die Sprache deiner Wahl übersetzen oder alternativ einfach vorher von Hand ausrechnen. Das Ergebnis interpretierst dann als Zahl zur Basis 3 und schaust dir die einzelnen Stellen an, um rauszufinden, wie dein Zustand so aussieht.

4. Wenn du bei 3^36 für jedes einzelne Ereignis auch nur einen Takt rechnest, dauert das grob nen Tag. Lass die Finger von der Zahl.

Ohne die Problemstellung genau zu kennen vermute ich zudem, dass man nicht über alle Möglichkeiten brute forcen muss, sondern Symmetrien ausnutzen kann, so dass nur ein kleiner Teil reicht.

@OP: Was ist/war denn die genaue Fragestellung?

1. wie schaff ich es mit "For" den vorherigen wieder auf 0 zu setzen.
2. <=3 und <4 ist das gleiche..in meiner vorlage stand <=x..zu erst hab ichs kopiert und dann war ich zu faul und hab umgestellt auf <4
3. das versteh ich nicht
----
4. ich wollte wahrscheinlichkeiten für verschiedene tabellensituationen am ende der bundesliga saison simulieren

Zu 1: Du kannst auch die Schleifenvariable einer for-Schleife in der Schleife selber modifizieren. Also so was wie

for(int i = 0; i < j; i++) {
i = 1;
}

ist durchaus erlaubt (auch wenn in dem Beispiel nicht sonderlich sinnvoll).

Zu 3: Alle deine unterschiedlichen Ereignisse haben so ne Form: 010200112, also 9x eine der drei verschiedenen Möglichkeiten. Das kannst du als Zahl zur Basis 3 (also Ziffern von 0 bis 2, ganz rechte Stelle sind 1er, dann 3er, 9er, usw) betrachten. Wenn du jetzt alle Zahlen (zur Basis 10 ;)) von 0 bis 3^9 durchgehst, dann nummeriert dir das die möglichen Ereignisse durch. Jede dieser Nummer ist aber, in der Basis 3 betrachtet, auch direkt eine Darstellung des Ereignisses selber.
Jetzt musst du nur noch wissen, wie du die einzelnen Ziffern ausliest. Wie funktionierts in Basis 10? n-te Stelle (von rechts) kriegt man, indem man erst durch 10^(n-1) teilt (das schneidet dir die ganzen Stellen danach weg) und dann Modulo 10 rechnest (das schneidet dir die Stellen davor weg). Also für Basis 3: /3^(n-1)%3.

Mein Vorschlag also insgesamt:

for(int i = 0; i < 3^9; i++) {
  for(int n = 1; n <= 9; n++) {
    // Möglichkeit von Ereignis n
    m = i/3^(n-1)%3;
  }
}

Alles ungetestet, kann also auch noch n paar Bugs haben, aber das Prinzip sollt funktionieren...

Zu 4: Ja, schon klar. Trotzdem ist das so dann nicht wirklich machbar.

Wobei ich die Basenumrechnung eher so ähnlich machen würde

for(int i = 0; i < 3^9; i++) {
  m = i;
  while (m > 0) {
    ergebnis = m % 3;
    m = m/3; // das muss eine Integerdivision sein, also 5/2 = 2. In C mit m Integer wäre es so.
  }
}

4. ich wollte wahrscheinlichkeiten für verschiedene tabellensituationen am ende der bundesliga saison simuliere

Die Ereignisse sind also sowas wie Heimmanschaft gewinnt / verliert / spielt unentschieden? Verstehe trotzdem nicht, warum man da über alle Möglichkeiten iterieren sollte. Hört sich eher wie etwas an, was man mit Markovketten machen könnte.

Klar, ist noch mal effizienter so. Meins war halt auf die Schnelle zum zeigen (und wäre sonst halt brauchbar, falls er ein spezielles Ereignis haben will).

Den Sinn seh ich aber ehrlich gesagt auch nicht. Gegen Ende der Tabelle ok, wenn man sich alle noch möglichen Tabellenkonstellationen generieren will. Aber am Anfang?

Ich hab vor langer Zeit Programmiert und bei Optimierungen gelernt daß man solche Schleifenbedingungen
for(int i = 0; i < 3^9; i++) nicht machen soll, da die Compiler bei jedem überprüfen die 3^9 jedesmal neu ausrechnen.
Können die neueren Compiler das direkt erkennen daß das eine fixe Zahl ist ?

Bei dem, was so ein optimierender Compiler alles kann, würde mich das sehr wundern, wenn nicht. Und Wiki gibt mir recht: https://en.wikipedia.org/wiki/Constant_folding

Wenns wirklich schnell werden soll könnte der Compiler die Schleife auch direkt entfernen und die Befehle entsprechend of hintereinander ausführen (oder zumindest den Rumpf ein paar mal öfter wiederholen): https://de.wikipedia.org/wiki/Loop_unrolling (Zu dem Thema muss ich einfach noch den Link bringen, einfach weil ich den Code damals so pervers fand, als ich das mal gesehen hab: https://de.wikipedia.org/wiki/Duff%E2%80%99s_Device)

Es könnte allerdings problematisch werden, wenn es für die Potenz keinen Operator gibt und man auf Funktionen zurückgreifen muss. Wobei ich mir auch da vorstellen könnte, dass das der ein oder andere Compiler unterstützt.