Kleine Rekursion

[Levitas]

Servus Leute,

ich bin im Moment dabei ein bisschen mich mit Rekursion vertraut zu machen. Habe auch schon die geläufigen Rekursionen durchgemacht und eigentlich gut verstanden (Fibonacci, Hanoi, Quersumme ...).
Ich habe mir nun folgende Aufgabe gestellt:

Eine Methode

static boolean istNur2 (int n)

soll true liefern, wenn eine Ziffernfolge ausschliesslich aus 2en besteht. Also z.B. 222 oder 22. Wenn z.B. 252 oder so kommt soll als Rückgabe false erscheinen.

Hab auch schon mir einen kleinen Algorithmus geschaffen, der aber noch nicht ganz funktioniert. Das Problem ist, wenn eine "richtige" zahl kommt (z.B. 222) liefert es zwar true, wenn aber eine "falsche" zahl kommt wie 2345 kommt ein java.lang.StackOverflowError (was ja denke ich mal auf ne Endlosschleife oder sowas in der Art hinweist).

Hier mal mein Code:

public class RekursionNur2 {
	
	
	static boolean istNur2 (int n)
	{	
		//wenn n den wert 2 hat
		if (n == 2)
			return true;
		
		//wenn n nicht 2 ist und noch einstellig ist
		else if(n != 2 && n < 10)
			return false;
		
		//wenn n zweistellig ist
		else if(n > 9){
			int result = n%10;
			if(result == 2){
				return istNur2(n);
			}
			else
				return false;
		}
		return true;		
	}
	
	
	public static void main(String[] args)
	{
		int n = 2245;
		System.out.println(istNur2(n));
	}

}

Ich hoff ihr findet das Problem

Grüße

Levitas

 

[Sonecc]

bei mir läuft dein Code nur bei einer richtigen Zahl (getestet 2222) nicht richtig durch

Ich denke es liegt daran, dass du die Zahl unverändert wieder an die Methode zurück gibst.
Dadurch macht das Programm bei jedem aufruf nichts neues, es wird immer 2222 getestet

 

[SlaterB]

Zeile 18: return istNur2(n);
mit unveränderten Parameter n kann ja nur exakt dasselbe nochmal rechnen,
wenn es je dazu kommt, ist eine Endlosschleife sicher

 

[eRaaaa]

also ich denke, es wird eher andersherum sein ;D false zeigt er dir an, true aber nicht.

problem ist hier:

            int result = n%10;
            if(result == 2){
                return istNur2(n);
            }

du rufst die methode mit dem gleichen n auf, welches du auch vorher schon der methode übergeben hast ;D

und noch als kleiner zusatz:

else if(n != 2 && n < 10)

das != 2 brauchst du eig. nicht abfragen, das muss es ja sein, weil sonst würde er garnicht zum else if gelangen *g*

/edit: lahme ente ^^

 

[Levitas]

ah shit stimmt... ihr habt recht!
werds mir nochmal anschauen und dann bescheid geben wie ichs (hoffentlich) gelöst hab =)

 

[Levitas]

lol ich sitz voll auf der leitung...

also nehmen wir mal an ich hab die zahl 132:

wenn die letzte Stelle auf ihre Richtigkeit überprüft worden ist und in diesem Fall true ist und dann wieder die Rekursion wieder weitergeht muss ja 13 weiterüberprüft werden. Also 13 muss der Methode wieder übergeben werden. Aber durch welche Operation bekomm ich denn 13? :bahnhof:

Ich lieg doch soweit richtig oder?

 

[faetzminator]

Mit [c]n / 10[/c].

 

[Sonecc]

n/10 statt n übergeben

aus 132 / 10 = 13,2 macht Java nämlich (wegen int) dann 13

da war ich dann zu langsam^^

 

[Levitas]

ha ich wollte n/10 nehmen, aber hab mir dann gedacht: na dann hab ich ne kommazahl! aber na klar da wird ja gerundet!

Suuuupa:toll:

 

[JohannisderKaeufer]

Wenn man den Programmablauf etwas umsortiert, kann man sich einige if-Abfragen sparen.

public class Main {

	public static boolean nurZweier(int n) {
		if (n < 10) {
			return n == 2;
		} else {
			int zehntel = n / 10;
			return nurZweier(n - (zehntel*10)) && nurZweier(zehntel);
		}
	}

	public static void main(String[] args) {
		int[] zahlen = {2,22,222,2222,22222,21,1,0,4,212,211,2112};
		for(int i:zahlen){
			System.out.println(i+" "+nurZweier(i));
		}
	}
}

 

[Landei]

Wie wäre es damit:

    public static boolean nurZweier(int n) {
       return n % 10 == 2 && (n < 10 || nurZweier(n / 10));
    }

 

[ign0rant]

Wie wäre es damit:

Den Code auf eine Zeile quetschen, damit er besonders unleserlich wird? Eher nicht.

 

[Sonecc]

besonders unleserlich ist das allerdings nicht