rekursives spiel programmieren

[Lehmannsche]

Hallo,
hab folgende aufgabe bei der ich nicht weiterkomme:
von einem haufen kieselsteine dürfen in einem zug entweder 3 oder 7 steine entfernt werden. man hat das spiel gewonnen, wenn keine steine mehr übrig sind und man hat verloren, wenn ein oder zwei steine noch liegen.
jetzt soll ich eine rekursive mehtode schreiben, die für eine zahl n von kieselsteinen prüft, ob die aufgabe lösbar ist oder nicht.

mein problem ist, wie ich das formuliere und das dann auch noch rekursiv.
ich hatte das bis jetzt nur so formuliert:

public class RekursivesSpiel1
{
   public static void main (String [] args) {
       
       int n = 13;
       
       System.out.println (spiel (n));
    }
    static boolean spiel ( int n ) {
        if (n==0) {
            return false;
        }
        
        else {
            if (n%3==0 || n%7==0) {
                return true;
            }
            else {
                return false;
            }
        }
    }
}

aber damit prüfe ich ja nur, ob die zahl ein vielfaches von 3 oder 7 ist.
ich muss es ja so formulieren, dass er die zahl abzieht und dann guckt, ob er noch mal eine zahl abziehen kann.
z.B. bei der zahl n=16, müsste das programm ja erst 7 abziehen und dann sehen, dass man nochmal 3 mal 3 abziehen kann und nicht nochmal 7 abziehen und bei 2 enden.
find das ganz schön kompliziert und hoffe mir kann jemand dabei helfen.

 

[SlaterB]

dabei soll man doch so einfach denken:

1. starte Denken/ starte Methode:
2. wieviel Steine habe ich,
3.1 wenn 0 dann Erfolg (Rückgabewert),
3.2 wenn 1-2 dann Misserfolg (Rückgabewert),
4 anderenfalls (> 2 Steine)
4.1 drei Steine abziehen + wieder 1. (rekursiver Aufruf),
4.2 wenn da Erfolg zurückkommt, dann selber Erfolg (Rückgabewert),
5 .. was könnte hier stehen?

versuche es zumindest erstmal soweit, also praktisch vereinfachte Regel 'man darf nur 3 abziehen',
ohne modulo

 

[Lehmannsche]

also müste das gleiche mit der sieben auch passieren?
ich versteh das irgendwie noch nicht ganz.
1. zahl eingaben
2. wenn zahl gleich 0 dann return ???true???
3. wenn zahl gleich 1 oder 2 dann return false
4. wenn zahl größer als 2 -> 3 abziehen
(das besondere an rekursion ist doch, dass er jetzt wieder in diese methode reingeht und nochmal 3 abzieht,oder?)
5. wenn dann irgendwann 0 rauskommt dann return true
6. wenn nicht dann false

aber wie kommt jetzt die 7 ins spiel?

 

[Landei]

  public static boolean kieselstein(int n) {
    if (n < 3) {
      return n == 0;
    } else if(kieselstein(n-3)) {
      System.out.print("3,");
      return true;
    } else if(kieselstein(n-7)) {
      System.out.print("7,");
      return true;
    } else {
      return false;
    }
  }

Übrigens sieht man leicht, dass das Spiel für alle Zahlen ab 14 gewonnen werden kann:
- Ist die Zahl durch 3 teilbar, ziehe immer Dreien ab
- Läßt die Zahl bei Division durch 3 den Rest 1, ziehe einmal 7 ab, dann immer Dreien
- Läßt die Zahl bei Division durch 3 den Rest 2, ziehe zweimal 7 ab, dann immer Dreien

 

[Lehmannsche]

danke für die hilfe....
langsam vesteh ich es auch!