Wieso funktioniert dieser simple Code nicht?

[moccajoghurt]

Hi, habe eine Aufgabe meines Java-Kurses bearbeitet und eigentlich müsste sie meines Wissens nach gelöst sein... anscheinend habe ich aber einen Fehler im Code, den ich einfach nicht finden kann. Normalerweise würde ich nicht so etwas fragen, aber ich habe wirklich mind. eine Stunde überlegt und den Fehler nicht finden können.
Die Aufgabe lautet:

Aufgabe 8:
Eine Natürliche Zahl heißt potent, wenn sie sich als Summe von Potenzen (>= 1) ihrer Ziffern darstellen lässt. Beispielsweise ist 24 wegen 2^3 + 4^2 = 24 potent. Schreiben Sie ein Java-Programm, das alle zweistelligen potenten Zahlen ausgibt.

Mein Lösungsansatz:

public class potenteZahlen {
	public static void main(String[] args) {
		long x = 99;
		while (x > 9) { // gehe alle Zahlen von 99-10 durch
			long ziffer1 = 0;
			long ziffer2 = 0;
			ziffer1 = x % 10; // erzeuge Ziffer1
			ziffer2 = (x/10) % 10; // erzeuge Ziffer2
			if (potent(ziffer1, ziffer2, x)) { // ist Zahl potent?
				System.out.println(x); // zeige Zahl
				}
			x--;
		}
	}	
	static boolean potent(long ziffer1, long ziffer2, long zahl) {
		long a = ziffer1;
		long b = ziffer2;
		for (int x = 1; x <=9; x++) { // potenziere die Ziffer 9 mal
			if (x != 1) { // bei Ziffer^1 keine Potenzierung
			ziffer1*=a; // Ziffer1 * Ziffer1 * ....
			}			
			for (int y = 1; y <=9; y++) { // potenziere die Ziffer 9 mal
				if (y != 1) { // bei Ziffer^1 keine Potenzierung
				ziffer2*=b; // Ziffer2 * Ziffer2 * ....
				}
				if (ziffer1 + ziffer2 == zahl) { // wenn sich aus den Potenzen Zahl ergibt, dann true
					return true;
				}
			}
		}
		return false;
	}
}

Die Funktion ergibt niemals true. Wo liegt mein Fehler??

Gruß

 

[faetzminator]

Hab jetzt mehrere Methoden zur Berechnung des Problems überlegt, aber es kommt nichts simpels und sehr sinnvolles dabei raus. Auf alle Fälle gehts wohl nicht so einfach, wie du das versuchst 😀 Geht wohl eher in Richtung Combinatorics (ausser da gäbts eine Formel).

 

[XHelp]

Auf den ersten Blick würde ich vermuten, dass du in der potent-Methode am Ende der jeweiligen Schleife ziffer1 und ziffer2 mit a unb b zurückbelegen musst, sonst werden die ja immer größer.
Bau dir paar sysouts rein und guck, warum das Ergebnis nicht hinhaut.

 

[XHelp]

Jepp. Vor Zeile 22 gehört noch

ziffer2=b;

rein und dann funktioniert alles.
Generell stimmt bei dir das Ergebnis, aber da fehlen dennoch ein paar Abbruchbedingungen. for-Schleifen eignen sich dafür nicht wirklich, denn:
mal angenommen du hast die Zahl 55... schon bei 5^3 kommst du auf 125, rechnest aber dennoch weiter und überprüfst sogar die 2. Zahl komplett, obwohl die Summe von 125 und x>=0 nie kleiner sein wird.

Ich hätte es wie folgt gemacht (die Potenzbildung ist ziemlich redundand, deswegen kann es so nicht bleiben, aber der Grundgedanke sollte klar sein):

public static boolean checkPontent(int number) {
		if ((number>9) && (number<100)) {
			int n2 = number%10;
			int n1 = (number-n2)/10;
			int p1=1;
			int p2;
			while (Math.pow(n1, p1)<=number) {
				p2=1;
				while (Math.pow(n2, p2)<=(number-(Math.pow(n1, p1)))) {
					if (Math.pow(n1, p1)+Math.pow(n2, p2)==number) {
						System.out.println(n1+"^"+p1+" + "+n2+"^"+p2+" = "+number);
						return true;
					}
					if ((n2==0)|| (n2==1)) {
						break;
					}
					p2++;
				}
				if ((n1==0)|| (n1==1)) {
					break;
				}
				p1++;
			}
		}
		return false;
	}

P.S. Klassennamen sollte man groß schreiben

 

[Wortraum]

Noch ein paar kleine Tips, die Du beherzigen solltest:
1) Parametern sollte man nichts zuweisen.
2) Unnötige Bedingungen wie die, ob eine Zahl 1 ist, machen den Text schwerer nachvollziehbar und blähen ihn auf.
3) Eine Variable mit 0 zu initialisieren und gleich darauf etwas neues zuzuweisen, ist sinnfrei.
4) Eine private Methode sollte privat sein.
5) Statt mit einer While-Schleife zu zählen, sollte man eine For-Schleife verwenden.
6) Ein long ist für eine Ziffer ziemlich hoch gegriffen; das ist aber im Gegensatz zu den anderen Punkten nahezu unwichtig.

public static void main(String[] args) {
    for (int i = 99; i > 9; --i) {
        int ziffer1 = i % 10;
        int ziffer2 = (i / 10) % 10;
        if (potent(ziffer1, ziffer2, i)) {
            System.out.println(i);
        }
    }
}

private static boolean potent(int ziffer1, int ziffer2, int zahl) {
    int a = ziffer1;
    for (int x = 1; x <= 9; ++x) {
        a *= ziffer1;
        int b = ziffer2; /* das Zurücksetzen fehlte bei Dir */
        for (int y = 1; y <= 9; ++y) {
            b *= ziffer2;
            if (a + b == zahl) {
                return true;
            }
        }
    }
    return false;
}

@XHelp: Die While-Schleifen können auch bei Dir problemlos for-Schleifen sein, und die If-Bedingungen in den While-Schleifen sind deplaziert, weil sich die Bedingung innerhalb der Schleife niemals ändert.

 

[Besucherin88]

Ich hätte noch eine Anmerkung...

[Java=18]for (int x = 1; x <=9; x++) { // potenziere die Ziffer 9 mal
[/Java]
[Java=22]for (int y = 1; y <=9; y++) { // potenziere die Ziffer 9 mal
[/Java]

Setze die Grenze auf 6, das hat folgenden Grund:
Die höchste mögliche Potenz ergibt sich aus der höchsten möglichen Potenz der kleinsten Zahl, welche ihr Ergebnis bei Erhöhung der Potenz ändert. D.h. die höchstmögliche Potenz ergibt sich aus der 2. Gehst du diese durch lässt sich feststellen, dass bei einer Potenz von 7 die Grenze von 100 bereits überschritten wird. Das heißt für dich, dass du beim Schleifendurchlauf von x und y ab dem Wert 7 NIE ein Ergebnis erhalten wirst (außer eventuell mit 0 und 1 als Basis).

 

[XHelp]

@XHelp: Die While-Schleifen können auch bei Dir problemlos for-Schleifen sein

for-Schleifen machen, imho, nur Sinn, wenn ich vorher den Logarithmus berechne, ansonsten kann ich mir da nichts sinnvolles vorstellen.

 

[moccajoghurt]

Danke euch, der Thread hat mir sehr weitergeholfen.

 

[Wortraum]

for-Schleifen machen, imho, nur Sinn, wenn ich vorher den Logarithmus berechne, ansonsten kann ich mir da nichts sinnvolles vorstellen.

Wieso den Logarithmus? Deine While-Schleifen machen auch nichts anderes als hochzuzählen, nur daß man am Anfang für die Initialisierung von p1 sorgen und am Ende p1 hochzählen muß – also genau das, wofür man normalerweise eine For-Schleife verwendet.

for (int p1 = 1; Math.pow(n1, p1) <= number, ++p1) { … }

Wenn man möchte, kann man das zwar mit der While-Schleife machen, aber daß eine For-Schleife dafür ungeeignet sei, ist falsch.

 

[XHelp]

achso. ja gut, war dann ein Denkfehler von mir.
Und warum Logarithmus: weil man da bestimmen kann, bis zur welcher Potenz man gehen muss, z.B.:
56
nehmen wir 5:
log_5(56)=2.5 (gerundet)
als braucht man die 5 nur bis zum exponent <=2 untersuchen, denn ab da wird das Ergebnis größer (5^3=125)
Bei der 2. Schleife genau das gleiche, nur dass man da als Logarithmand den Rest nimmt.