Ist diese Aufgabe zu umständlich gelöst?

[moccajoghurt]

Hi,
die Aufgabe lautet wie folgt:

Aufgabe 18:
Schreiben Sie ein Java-Programm, das die Anzahl der Überträge beim Addieren zweier Zahlen berechnet.
Algorithmus: Zunächst sollen vom Benutzer zwei nicht negative Zahlen mit jeweils weniger als 10 Ziffern eingelesen werden. Sie können dazu die aus der Vorlesung bekannte Klasse IO verwenden. Anschließend soll die Anzahl an Überträgen beim
ziffernweisen Addieren der beiden Zahlen von rechts nach links berechnet werden. Zum Schluss soll die Anzahl an Überträgen auf den Bildschirm ausgegeben werden.
Beispiel:
Zahl: 123
Zahl: 594
Anzahl an Uebertraegen: 1

Kenne die Anweisungen: for, do, while, switch, if, break, continue, return... kann man es mit diesen Anweisungen einfacher lösen als so:

public class zahlenAddieren {
	
	static int zaehler1 = 0;
	static int zaehler2 = 0;
	static int zaehler3 = 0;
	static int zaehler4 = 0;
	static int zaehler5 = 0;
	static int zaehler6 = 0;
	static int zaehler7 = 0;
	static int zaehler8 = 0;
	static int zaehler9 = 0;
	
	static int zaehler1b = 0;
	static int zaehler2b = 0;
	static int zaehler3b = 0;
	static int zaehler4b = 0;
	static int zaehler5b = 0;
	static int zaehler6b = 0;
	static int zaehler7b = 0;
	static int zaehler8b = 0;
	static int zaehler9b = 0;
	
	static int uebertraege = 0;
	
	public static void main(String[] args) {
		
		System.out.println("Die Zahlen duerfen maximal 9-stellig sein!");
		long zahl1 = IO.readLong("1. Zahl: ");
		long zahl2 = IO.readLong("2. Zahl: ");
		
		// Ziffern von erster Zahl einlesen
		for (long i = zahl1; i % 10 != 0; i--) {
			zaehler1++;
		}
		for (long i = zahl1 - zaehler1; i % 100 != 0; i-=10) {
			zaehler2++;
		}		
		for (long i = zahl1 - zaehler1 - zaehler2 * 10; i % 1000 != 0; i-=100) {
			zaehler3++;
		}		
		for (long i = zahl1 - zaehler1 - zaehler2*10 - zaehler3*100; i % 10000 != 0; i-=1000) {
			zaehler4++;
		}		
		for (long i = zahl1 - zaehler1 - zaehler2*10 - zaehler3*100 - zaehler4*1000; i % 100000 != 0; i-=10000) {
			zaehler5++;
		}		
		for (long i = zahl1 - zaehler1 - zaehler2*10 - zaehler3*100 - zaehler4*1000 - zaehler5*10000; i % 1000000 != 0; i-=100000) {
			zaehler6++;
		}
		for (long i = zahl1 - zaehler1 - zaehler2*10 - zaehler3*100 - zaehler4*1000 - zaehler5*10000 - zaehler6*100000; i % 10000000 != 0; i-=1000000) {
			zaehler7++;
		}		
		for (long i = zahl1 - zaehler1 - zaehler2*10 - zaehler3*100 - zaehler4*1000 - zaehler5*10000 - zaehler6*100000 - zaehler7*1000000; i % 100000000 != 0; i-=10000000) {
			zaehler8++;
		}		
		for (long i = zahl1 - zaehler1 - zaehler2*10 - zaehler3*100 - zaehler4*1000 - zaehler5*10000 - zaehler6*100000 - zaehler7*1000000 - zaehler8*10000000; i % 1000000000 != 0; i-=100000000) {
			zaehler9++;
		}
		
		// Ziffern von zweiter Zahl einlesen		
		for (long i = zahl2; i % 10 != 0; i--) {
			zaehler1b++;
		}
		for (long i = zahl2 - zaehler1b; i % 100 != 0; i-=10) {
			zaehler2b++;
		}		
		for (long i = zahl2 - zaehler1b - zaehler2b * 10; i % 1000 != 0; i-=100) {
			zaehler3b++;
		}		
		for (long i = zahl2 - zaehler1b - zaehler2b*10 - zaehler3b*100; i % 10000 != 0; i-=1000) {
			zaehler4b++;
		}		
		for (long i = zahl2 - zaehler1b - zaehler2b*10 - zaehler3b*100 - zaehler4b*1000; i % 100000 != 0; i-=10000) {
			zaehler5b++;
		}		
		for (long i = zahl2 - zaehler1b - zaehler2b*10 - zaehler3b*100 - zaehler4b*1000 - zaehler5b*10000; i % 1000000 != 0; i-=100000) {
			zaehler6b++;
		}
		for (long i = zahl2 - zaehler1b - zaehler2b*10 - zaehler3b*100 - zaehler4b*1000 - zaehler5b*10000 - zaehler6b*100000; i % 10000000 != 0; i-=1000000) {
			zaehler7b++;
		}		
		for (long i = zahl2 - zaehler1b - zaehler2b*10 - zaehler3b*100 - zaehler4b*1000 - zaehler5b*10000 - zaehler6b*100000 - zaehler7b*1000000; i % 100000000 != 0; i-=10000000) {
			zaehler8b++;
		}		
		for (long i = zahl2 - zaehler1b - zaehler2b*10 - zaehler3b*100 - zaehler4b*1000 - zaehler5b*10000 - zaehler6b*100000 - zaehler7b*1000000 - zaehler8b*10000000; i % 1000000000 != 0; i-=100000000) {
			zaehler9b++;
		}				
		
		// Ziffern addieren
		if (zaehler1 + zaehler1b >= 10) {
			uebertraege++;
		}
		if (zaehler2 + zaehler2b >= 10) {
			uebertraege++;
		}
		if (zaehler3 + zaehler3b >= 10) {
			uebertraege++;
		}
		if (zaehler4 + zaehler4b >= 10) {
			uebertraege++;
		}
		if (zaehler5 + zaehler5b >= 10) {
			uebertraege++;
		}
		if (zaehler6 + zaehler6b >= 10) {
			uebertraege++;
		}
		if (zaehler7 + zaehler7b >= 10) {
			uebertraege++;
		}
		if (zaehler8 + zaehler8b >= 10) {
			uebertraege++;
		}
		if (zaehler9 + zaehler9b >= 10) {
			uebertraege++;
		}	
		// Ziffern ausgeben
		System.out.println();
		System.out.println(zahl1 + " + " + zahl2 + " haben " + uebertraege + " Uebertraege!");
		System.out.println();
		}
}

 

[Bierhumpen]

Ist diese Aufgabe zu umständlich gelöst?

Ja

 

[Marco13]

Ich hätte so geantwortet wie Bierhumpen, aber so erweitere ich das mal um das Stichwort "Arrays"...

 

[faetzminator]

Ich hätte das ganze "etwas" mathematischer gelöst...

public static int getUebertraege(int x, int y) {
    int min = Math.min(x, y), max = Math.max(x, y);
    int uebertraege = 0, uebertrag = 0;
    while (min > 0 || uebertrag > 0) {
        int sum = min % 10 + max % 10 + uebertrag;
        if (sum >= 10) {
            uebertraege++;
        }
        uebertrag = sum / 10;
        min /= 10;
        max /= 10;
    }
    return uebertraege;
}

 

[moccajoghurt]

Ja

Es würde mir eher helfen zu wissen wie man es hätte weniger umständlich lösen können, als mir einfach nur zu bestätigen was ich bereits ahne.

Aber bitte berücksichtigen, dass andere Anweisungen als for, do, while, switch, if, break, continue, return für die Aufgabe nicht vorgesehen sind.

 

[faetzminator]

Aber bitte berücksichtigen, dass andere Anweisungen als for, do, while, switch, if, break, continue, return für die Aufgabe nicht vorgesehen sind.

Bezogen auf mein Beispiel: dann machst du dir schnell selber eine Methode [c]max()[/c] und [c]min()[/c] oder ignorierst diese Performanceverbesserung und rechnest gleich mit [c]x[/c] und [c]y[/c].

 

[moccajoghurt]

Bezogen auf mein Beispiel: dann machst du dir schnell selber eine Methode [c]max()[/c] und [c]min()[/c] oder ignorierst diese Performanceverbesserung und rechnest gleich mit [c]x[/c] und [c]y[/c].

Weiß leider nicht was das konkret bedeutet. Kannst du das vielleicht als Code darstellen? 😉

 

[faetzminator]

In meinem Beispiel oben könntest du in der Schleife [c]x[/c] und [c]y[/c] verwenden. Die Schleife wird dann Anzahl Stellen des ersten Wertes plus 0-... Mal (Überlauf) aufgerufen. Wenn du aber zwei Zahlen [c]456823[/c] und [c]7[/c] eingibst, muss diese Schleife nur zwei Mal betreten werden (7 selbst ist 1 Stelle gross und der Überlauf wird beim nächsten Aufruf "aufgegessen") - ohne min()/max() je nach Parameterreihenfolge wird diese unnötigerweise aber 6 Mal aufgerufen.

 

[LP_SE]

Math.max(x, y) und .min(x, y) liefern den Größten (Kleinsten) der Werte zurück. Das kann man, wenn man nur diese Anweisungen benutzen darf, sich auch schnell selbst schreiben:

public int max(int x, int y) {
    return x>y?x:y;
    // oder so:
    if(x>y) return x;
    else return y;
}

mit min geht es analog

 

[Shulyn]

Es würde mir eher helfen zu wissen wie man es hätte weniger umständlich lösen können, als mir einfach nur zu bestätigen was ich bereits ahne.

Aber bitte berücksichtigen, dass andere Anweisungen als for, do, while, switch, if, break, continue, return für die Aufgabe nicht vorgesehen sind.

Etwas "einfacher" machen...
Generell würde ich alles was sehr sehr ähnlich aussieht in eine Methode packen...
Hier ein kleines Beispiel.
[Java]
if (zaehler1 + zaehler1b >= 10) {
uebertraege++;
}
if (zaehler2 + zaehler2b >= 10) {
uebertraege++;
}
if (zaehler3 + zaehler3b >= 10) {
uebertraege++;
}
if (zaehler4 + zaehler4b >= 10) {
uebertraege++;
}


// Vllt so:

public int groesserZehn(int zahl1, int zahl2, int uebertraege) {
if (zahl1 + zahl2 >= 10) {
uebertraege++;
}
return uebertraege;
}
[/Java]
so musst du den code nicht x-mal schreiben. Und es wird klarer was du machst.