Methoden "Fröhliche Zahl" true | false

[WI'ler]

Ich stehe mal wieder vor einem lästigen Problem.

Aufgabenstellung hier

Teil a) habe ich so gelöst:

class multierg {
    
    public static void main(String[] args) {

    	System.out.print(summeDerZiffernquadrate(19));

    }
    
    public static int summeDerZiffernquadrate(int n)
    {
    	
    	int ergebnis = 0;
    	
    	ergebnis = (n / 10) * (n / 10);
    	n = n % 10;
    	ergebnis = ergebnis + n * n;
       	
    	return ergebnis;
    }
}

Für Teil b) habe ich noch weniger Platz. Wie soll das klappen? Hätte jemand einen Lösungsansatz?

 

[Kevin94]

Wieso weniger Platz? Wenn der Platz nicht ausreicht, gibts noch ne Rückseite... (in der Klausur sollte man dann aber über einen einfacheren Weg nachdenken)

Du brauchst aber tatsächlich nicht viel Platz, da die Methode, wenn du die Methode aus Teilaufgabe a) und Rekursion nutzt, ein einfacher Dreizeiler ist.

 

[jgh]

Ich stehe mal wieder vor einem lästigen Problem.
....
Für Teil b) habe ich noch weniger Platz. Wie soll das klappen? Hätte jemand einen Lösungsansatz?

na ja, wenn das schon lästig ist, dann solltest du dir evtl. ein andere Studienrichtung suchen? Nicht abwertend gemeint, sondern nur ehrlich!


Deine Methode [c]summeDerZiffernquadrate(int n)[/c] ist nicht korrekt. So wird bspw für die Zahl [c]111[/c] die als Summe der Ziffernquadrate

3

zurückliefern sollte, von deiner Methode

122

returned. Für 2-stellige Zahlen scheint deine Methode zu funktionieren, für größere Zahlen scheint dieses nicht der Fall zu sein! Hier mal eine korrekte, wenn auch nicht schöne, Lösung für die

summeDerZiffernquadrate(int n)

public static int summeDerZiffernquadrate(int n) {

		int ergebnis = 0;
		String help = n + "";
		for (int i = 0; i < help.length(); i++) {
			ergebnis += Integer.parseInt(help.charAt(i) + "")
					* Integer.parseInt(help.charAt(i) + "");
		}

		return ergebnis;
	}

Was meinst du mit "noch weniger Platz?" Ist die Zahl der LoC´s begrenzt, oder bez. des Platzes auf einem Aufgabenzettel?

Hast du denn schon einen Lösungsansatz für die fröhliche Zahl?

[edit] ein Dreizeiler? na dann lass ich mal überraschen [/edit]

 

[WI'ler]

Mit der Fachrichtung Informatik liege ich schon richtig, wobei ich Wirtschaftsinformatik studiere.

Mir macht es bloß keinen Spaß beim Lernen solche unnützigen Funktionen programmieren zu müssen. Ich habe es lieber, wenn es praxisbezogen ist, was mir auch das Lernen erleichtert. Deshalb hatte ich mich auch entschlossen an einer FH zu studieren und nicht an der Uni.

Die String-Methode finde ich nicht so toll, da es nicht dafür gedacht ist. Außerdem dürfen wir während der Klausur nicht auf die JAVA-Klassenbibliothek zurückgreifen.

Mit weniger Platz war wirklich der kleine Spalt auf dem Zettel gemeint, der für die Lösung ausdienen soll. Dieser Platz soll wirklich ausreichend sein (andernfalls würde ein Hinweis daneben stehen, dass wir ein Zusatzblatt dafür zur Verfügung haben).

Ich setze mich mal wieder ran. Mal sehen, was ich sonst noch Schönes zusammenstellen kann.

 

[Pippl]

Deine Methode [c]summeDerZiffernquadrate(int n)[/c] ist nicht korrekt. So wird bspw für die Zahl [c]111[/c] die als Summe der Ziffernquadrate

3

zurückliefern sollte, von deiner Methode

122

returned.

Du hast Recht die Methode ist nicht richtig, aber dein Ergebnis auch nicht

        n = n % 10;
        ergebnis = ergebnis + n * n;

Hast du vergessen noch dazu zu rechnen, also zu den

122

noch

144 * 144

Aber das nur nebenbei .. zu deiner Lösung ist nicht hinzuzufügen, funktioniert ja fürs erste und man kann sich davon langsam an eine andere Lösung rantasten.

Die String-Methode finde ich nicht so toll, da es nicht dafür gedacht ist. Außerdem dürfen wir während der Klausur nicht auf die JAVA-Klassenbibliothek zurückgreifen.

Verwende doch atm die String Methode um dich an eine Lösung ohne den nicht erlaubten Methoden/Klassen heranzutasten.

 

[jgh]

wie mein ergebnis ist nicht richtig???

 

[WI'ler]

Ich habe jetzt ziemlich lange gegoogelt und die meisten sind sich einig, dass es 3 Algorithmen gibt, die sich anbieten würden.

1) String-Methode - gefällt mir persönlich nicht, da wie schon von meinem Vorredner gesagt, kein guter Programmierstil
2) %10 & /10 - hab ich ja versucht, muss ich ausbessern
3) Logarithmus 10 - gefällt mir am besten, leider mit JKB.

int wert = 12345;
 
// hier noch wert = 0 abfangen! ...
 
// Länge des Integerwertes.
int d = (int) Math.log10( Math.abs(wert) ) + 1;
 
// Rückgabearray mit den einzelnen Ziffern.
int[] ziffern = new int[d];
 
while (wert != 0)
   {
   ziffern[--d] = wert % 10;
   wert /= 10;
   }
 
// ziffern[0] = 1
// ziffern[1] = 2
// ziffern[2] = 3
// ziffern[3] = 4
// ziffern[4] = 5

 

[Pippl]

3) Logarithmus 10 - gefällt mir am besten, leider mit JKB.

// Länge des Integerwertes.
int d = (int) Math.log10( Math.abs(wert) ) + 1;

Eine andere Möglichkeit die Länge des int werte zu bekommen

            boolean lengthFound = false; //flag um die schleife abzubrechen
            int number = 1003423; //die zu untersuchende zahl
            int temp = 1; 
            int oldTemp = 0;
            int length = 1; // die aktuelle länge
            while(!lengthFound)
            {
                temp = temp * 10;
                if (number < temp && number >= oldTemp)
                {
                    lengthFound = true;
                }
                oldTemp = temp;
                length++;
            }

[OT]jgh, sorry ich sollte das nächstemal noch weitere 5x nachrechnen :lol: oder genau schauen das % != / [/OT]

 

[WI'ler]

Ich hab mich entschlossen die String-Methode zu nehmen, da ich auf keine bessere Lösung komme.

Außerdem erleichtert mir diese auch den Teil B) zu lösen. Lösung folgt dann gleich noch.

 

[Kevin94]

Algorithmus 2 ist doch mit einer while-Schleife auch sehr einfach zu implementieren:

public int summeDerZiffernquadrate(int n)
    {
        
        int ergebnis = 0;
        while(n!=0) {
            ergebnis += (n % 10) * (n % 10);
            n /=  10;
        }
        return ergebnis;
    }

Funktioniert natürlich nur bei Ganzzahlen und nicht bei

double

's richtig.

 

[WI'ler]

Ich habe es so gelöst:

class multierg {
    
    public static void main(String[] args) {
 
        System.out.print(istFroehlicheZahl(99));
 
    }
    
    public static boolean istFroehlicheZahl(int n) {
 
        int ergebnis = 0;
        String result = "";					// Aufzählung aller Ergebnisse
        String check = "41637588914542204"; // sich wiederholender String bei nichtfröhlichen Zahlen
        String help = n + "";				// Konvertierung von n in String
        boolean tof = false;
        
        while(tof == false && !result.contains(check))	
        	// Wiederholen, solange tof = false | check-String nicht auftaucht
        {
        	ergebnis = 0;
        	for (int i = 0; i < help.length(); i++) {
            	ergebnis += Integer.parseInt(help.charAt(i) + "") * Integer.parseInt(help.charAt(i) + "");    
        	}
        	result = result + ergebnis;
        	help = ergebnis + "";
            if(ergebnis == 1)
            {
            	tof = true;
           	}
        }    
 		System.out.println(result);
        return tof;
    }
}

[EDIT]@Kevin94,

das ist natürlich die elegantere Lösung... werde ich mir jetzt auch nochmal für Teil B) anschauen...[/EDIT]

 

[Kevin94]

Ich will dich ja nicht nerven: Aber es geht ohne String's zu verwenden wesentlich einfacher und sicherer.
Deine Methode ist imo nicht sicher, da der check-String auch im result-String einer "Fröhlichen Zahl" vorkommen kann, das könnte man aber beheben, indem man die einzelnen Zahlen durch Leerzeichen trennt.

Aber warum schreibst du den Code aus a) nochmal ab, anstatt einfach die Methode zu verwenden (In der Klausur ist das sowieso schlauer, da du dann nicht den selben Fehler zweimal gewertest bekommst). Auserdem würde es den Code wesentlich übersichtlicher machen.

Und wie gesagt: Die Aufgabe lässt sich allein mit den rudimentären Operatoren/Konstrukten lösen und so wie du es angedeutet hast, ist diese Aufgabe eingentlich auch dazu gedacht so gelöst zu werden.

[EDIT]Ah ja, gut so.[/EDIT]

 

[WI'ler]

Wie könnte ich die Methode denn direkt implementieren? Beispiel?

 

[Kevin94]

Ohne String?
Egebnis mit der Methode in a) ausrechnen, in Hilfsvariable speichern und dann auf 1 oder 4 vergleichen wenn's keins davon ist eben per Rekursion das ganze von vorne mit dem Zwischenergebnis.

Hoffe das ist verstänlich, will jetzt nicht gleich den Code posten, ist aber wirklich in wenigen Zeilen lösbar (auch in einer, das wäre dann aber auch Spagetti Code), was jgh auch bestätigen kann.

 

[WI'ler]

In dem Fall finde ich es überflüssig/umständlich, weil der Code an sich schon kurz ist. ueh:

Vielen Dank für die Unterstützung und bis zur nächsten problematischen Aufgabe. :shock:

Endgültige Lösung: :toll:

public static boolean istFroehlicheZahl(int n) {
 
        int ergebnis = n;
        String result = "";                 // Aufzählung aller Ergebnisse
        String check = "41637588914542204"; // sich wiederholender String bei nichtfröhlichen Zahlen
        boolean tof = false;
        
        while(tof == false && !result.contains(check))  
            // Wiederholen, solange tof = false | check-String nicht auftaucht
        {
            n = ergebnis;
            ergebnis = 0;
            while(n!=0) 
            {
            	ergebnis += (n % 10) * (n % 10);
            	n /=  10;
        	}
            result = result + ergebnis;
            if(ergebnis == 1)
            {
                tof = true;
            }
        }    
        System.out.println(result);
        return tof;
    }