Skip to main content

Java Übung 23: So kannst du Zahlen umkehren

In dieser Java Übung geht es darum, dass du mittels Schleifen, Zahlen umkehrst.

Was meine ich damit?
Die Zahl 71 umgekehrt, ergibt die Zahl 17.
Und genau so ein kleines Java Programm sollst du jetzt schreiben.

Lege dazu eine neue Klasse, namens „ZahlUmdrehen“ an.
In dieser Klasse befindet sich die main-Methode zum Starten des Programmes.
Innerhalb der main-Methode legst du dann die Programmstrukturen an.

Und zwar:
Soll das Programm dich auffordern eine ganze Zahl (Integer) einzugeben.
Du brauchst somit ein Scanner-Objekt.

Das Programm liest die Zahl von links nach rechts und kehrt diese dann um.
Die umgedrehte Zahl wird dann als Konsolenausgabe zurückgegeben.

Probiere das Programm einmal aus und übergib die Zahl 21765.


Wie könntest du dieses Problem lösen?

Die Zahl 21765 kannst du auch so umschreiben:
20.000 +1.000 +700 +60 +5

Oder so: 2*10000 +1*1000 +7*100 +6*10 +5*1

Java Übung Zahlen Umkehren Algorithmus finden

Und wenn du jetzt die Zahl umdrehen willst, brauchst du einen Algorithmus:
Und dieser rechnet dann.
5*10000 +6*1000 +7*100 +1*10 +2*1
Java Übung Zahlen umkehren Aufschlüsselung

Wie gehst du nun am besten vor?
Als Erstes brauchst du die Anzahl der Ziffern.
Denn diese entsprechen den Zehnerpotenzen.
Und diese Zehner-potenzen sind die Faktoren für die einzelnen Ziffern.
Java Übung Zahlen Umdrehen 10 Potenzen

Die Zahl 21.765 hat 5 Ziffern bzw. 4 Tausenderstellen.
Das bedeutet:

  • dass die erste Zahl von 21.765 – die 5- mit 10 hoch 4 multipliziert werden muss.
  • die zweite Zahl – die 6 muss mit 10 hoch 3 multipliziert werden.
  • die dritte Zahl -die 7 muss mit 10 hoch 2 multipliziert werden.
  • die vierte Zahl -die 1 muss mit 10 hoch 1 multipliziert werden.
  • Und die letzte Zahl wird mit 10 hoch 0 multiplziert. (Alles hoch null ist 1)

Und dann berechnest du die Summe aus allen Multiplikationen.

Ich unterteile die Lösung dieser Java Übung in drei Blöcke.

Und zwar benötigst du drei Schleifen.

  • Schleife 1: Soll die Anzahl der Ziffern zählen, welche die ursprünglich übergebene Zahl (21765) hat.
  • Schleife 2: Soll auf Grundlage dieser Anzahl die Zehnerpotenzen bilden.
  • Schleife 3: Wird dann mittels der Zehnerpotenz die entsprechenden Zahlen berechnen.
    Und dann die Summe aus allen Zahlen bilden.

Und so geht’s.
Zuerst die Variablen.
Du benötigst eine Variable, in welcher du die Konsoleneingabe speicherst.

Außerdem benötigst du eine Variable welche die Anzahl der Ziffern zählt.


public class ZahlUmdrehen {

	public static void main(String[] args) {
		
		Scanner eingabe = new Scanner (System.in);
		System.out.println("Gib Zahl ein!");
		int zahl=eingabe.nextInt();//Speichert die Konsoleneingabe
		int zaehler=0; //Zähler für die Anzahl der Ziffern
		
	}
}

Dann kann es losgehen…

So kannst du die Anzahl der Ziffern zählen lassen.

Wie schon erwähnt – du brauchst eine Schleife.

Da die Anzahl der Schleifendurchläufe ungewiss ist, bietet sich eine while-Schleife an.

Was soll die Schleife genau tun?
Die Zahl, welche du in die Konsole eingibst wird durchlaufen.
Und mit Durchlaufen meine ich ein Komma von rechts nach links zu schieben.

Um ein Komma von rechts nach links zu schieben, musst du die Zahl durch 10 dividieren.
Am Beispiel:

  • 21765 / 10 = 2176,5
  • 2176,5 / 10 = 217,65
  • 217,65 / 10 = 21,765
  • 21,765 /10 = 2,1765
  • 2,1765 /10 = 0,21765 und dies wäre dann im Zahlenbereich Integer Null.
    Für Java ist dann 0,21765 = 0.

Wir haben somit 5-mal durch 10 rechnen müssen bis die Zahl null ist.
Und das bedeutet, dass diese Zahl 5 Ziffern hat.

Und das bedeutet für die Schleifenanweisung:
Dividiere solange durch 10 bis die Zahl 0 ist.
Was übersetzt heißt:
Verschiebe das Komma solange nach links bis du am Ende der Zahl angekommen bist.

Im Schleifenkopf lautet somit die Abbruchbedingung: zahl!=0

Im Rumpf wird dann die Zahl immer wieder durch 10 dividiert. zahl=zahl/10
Und der Schleifenzähler wird bei jedem Durchlauf um eins erhöht.


import java.util.Scanner;

public class ZahlUmdrehen {

	public static void main(String[] args) {
		
		Scanner eingabe = new Scanner (System.in);
		System.out.println("Gib Zahl ein!");
		int zahl=eingabe.nextInt(); //Speichert die übegebene Zahl 21765
		int zaehler=0;//Anzahl der Ziffern der 21765

		while (zahl!=0){
			zahl=zahl/10;//Komma wird nach rechts verschoben
			zaehler++;//Anzahl der Ziffern wird erhöht
		}
		System.out.println(zahl);//Aus Kontrollzwecken 21765: =0
		System.out.println(zaehler);//Aus Kontrollzwecken 21765:=5
	}
}

An so einem Punkt macht es Sinn das Ganze zu testen.
Deshalb habe ich im Test die Zahl 21765 übergeben.

Der Zähler hat den Wert 5.
Das ist die Anzahl der Ziffern der Zahl 21765.
Also alles gut.

Nur die übergebene Zahl ist jetzt nicht mehr 21765 sondern null.
Da im Schleifenrumpf diese Zahl immer wieder verändert wurde.

Und das ist blöd. 🙂
Du musst also eine weitere Variable anlegen, welche ein Zwischenergebnis speichert und nicht die übergebene Zahl ändert.

Und so geht’s.


import java.util.Scanner;

public class ZahlUmdrehen{

	public static void main(String[] args) {
		
		Scanner eingabe = new Scanner (System.in);
		System.out.println("Gib Zahl ein!");
		int zahl=eingabe.nextInt();
		int zaehler=0;
		int zwErgeb=0;//Variable zum Zwischenspeichern
		zwErgeb=zahl;//Variable bekommt den Wert der Zahl

		while (zwErgeb!=0){
			zwErgeb=zwErgeb/10; //Zwischenergebnis wird verändert
			zaehler++;
		}
		System.out.println(zahl);//Aus Kontrollzwecken 21765: =21765
		System.out.println(zaehler);//Aus Kontrollzwecken 21765:=5
	}
}

Die zweite Schleife soll die Zehnerpotenz ermitteln.

Du kennst jetzt die Anzahl der Ziffern.
Und somit weißt du, dass bei 5 Ziffern die erste Multiplikation mit 10.000 sein muss.

Java Übung Zahlen Umdrehen 10 Potenzen
.
Und die nächste Zahl wird mit 1000 multipliziert usw.

Es bringt aber nichts, wenn du es weißt.
Denn dein Java Programm muss es auch wissen.

Und deshalb muss jetzt eine Schleife her, welche die entsprechende Start-10-er-Potenz findet.

Wie könnte diese Schleife jetzt aussehen?
Die Anzahl der Schleifendurchläufe ist für diese 10-er Potenz Schleife bekannt.
Die Testzahl 21765 hat 5 Stellen.
Wir benötigen somit 4 Durchläufe (10000-er Stellen).

Und die Anzahl der Ziffern ist bereits in der Variable „zaehler“ (aus der while-Schleife) gespeichert.
Du kannst somit eine Abbruchbedingung von i < zaehler definieren.

Im Schleifenrumpf brauchst du eine neue Variable, welche die 10-er Zahl speichert.
Diese Variable "faktorZehn" legst du außerhalb der Schleife an und weist dieser den Wert 1 zu.

Der Startwert muss eins sein, da 0*10 wieder null ist.

Im Schleifenrumpf wird dann der Multiplikator immer wieder mit 10 multipliziert.


import java.util.Scanner;

public class ZahlUmdrehen {

	public static void main(String[] args) {

		Scanner eingabe = new Scanner(System.in);
		System.out.println("Gib Zahl ein!");
		int zahl = eingabe.nextInt();
		int zwErgeb = 0;
		int zaehler = 0;
		int faktorZehn = 1;
		zwErgeb = zahl;
		
		//Ermittlung der Anzahl der Ziffern
		while (zwErgeb != 0) {
			zwErgeb = zwErgeb / 10;
			zaehler++;
		}

		//Ermittlung der 10-Potenz
		for (int i = 1; i < zaehler; i++) {
			faktorZehn = faktorZehn * 10;
		}
		System.out.println(faktorZehn);//21765 = 10000
	}
}

Und auch an dieser Stelle, solltest du den bisherigen Code einmal ausprobieren.
Übergib die Zahl 21765.
Als "faktorZehn" sollte jetzt die Zahl 10.000 erscheinen.

Also ab in die dritte Schleife.

Schleife drei wird die Zahl umdrehen.

Jetzt fängst du von hinten an, die Zahl zu drehen.

Und zwar mit dem Modulo-Operator:
Denn der Modulo Operator liefert dir den Rest einer Division zu den Zehnerpotenzen.

  • 21765 % 10=2176 Rest 5
  • 2176 % 10=217 Rest 6
  • 217 % 10 = 21 Rest 7
  • 21 % 10 = 2 Rest 1
  • 2 % 10 = 0 Rest 2

Du siehst der Restwert einer Division durch 10, ist immer die letzte Ziffer der Zahl.
Und wenn du dir die Restwerte anschaust, ergibt das 56712.
Und 56712 ist die Umkehrung von 21765.

Du musst also die Restwerte mit 10000, 1000, 100, 10 und 1 multiplizieren.

Ganz allgemein gesagt müsste die Schleife folgendes tun:

  • Die letzte Ziffer bestimmen.
    (zwErgebnis % 10)
  • Die letzte Ziffer mit 10.000 (faktorZehn) multiplizieren.
    (zwErgebnis % 10)*faktorZehn
  • Diese Zahl zwischenspeichern. (in einer neuen Variablen)
  • Dann die letzte Zahl streichen.
    zwErgebnis/10
  • Die 10.000 in eine 1000 verwandeln.
    faktorZehn/10
  • Und von vorn beginnen.

Lass es uns endlich tun. 🙂


import java.util.Scanner;

public class ZahlUmdrehen {

	public static void main(String[] args) {

		Scanner eingabe = new Scanner(System.in);
		System.out.println("Gib Zahl ein!");
		int zahl = eingabe.nextInt();
		int zwErgeb = 0;
		int zaehler = 0;
		int faktorZehn = 1;
		int umgedrehteZahl = 0;
		zwErgeb = zahl;
		
		//Ermittlung der Anzahl der Ziffern
		while (zwErgeb != 0) {
			zwErgeb = zwErgeb / 10;
			zaehler++;
		}

		//Ermittlung der 10-Potenz
		for (int i = 1; i < zaehler; i++) {
			faktorZehn = faktorZehn * 10;
		}

		//Zahl umdrehen
		zwErgeb = zahl; //Zahl wird wieder im Zwischenergebnis gespeichert
		while (zwErgeb != 0) {
			umgedrehteZahl = (zwErgeb % 10) * faktorZehn + umgedrehteZahl;
			zwErgeb = zwErgeb / 10;
			faktorZehn = faktorZehn / 10;
		}
		System.out.println(umgedrehteZahl);
	}
}

Und dies wäre die entgültige Lösung zu dieser Java Übung.

Lass uns jetzt gedanklich die letzte while Schleife durchgehen:
Die Schleife startet mit folgenden Werten:

  • umgedrehteZahl=0. Diese Variable wurde im Zuge dieser Schleife erst angelegt.
  • zwErgeb entspricht der übergebenen Zahl. Der Wert ist somit 21765.
  • Der faktorZehn kommt aus der For-schleife und ist 10.000.

Java Übung Zahlen umdrehen erster Durchlauf

Die Schleife beginnt.

  • zwErgeb % 10 ergibt 21.765 / 10 = 2176 und Rest 5.
  • Der Restwert 5 wird dann mit dem "faktorZehn" (Wert aus For-Schleife) multipliziert.
    5*10000 = 50000
  • Und dann wird der Wert aus der Variablen umgedrehteZahl=0 hinzuaddiert.
    Somit ergibt sich ein Wert für die umgedrehteZahl von 50000, nach dem ersten Durchlauf.
  • Der faktorZehn wird durch 10 dividiert und ist jetzt somit 1.000.
  • Ausserdem wird das Zwischenergebnis (zwErgebnis) durch 10 dividiert und ist somit (21765/10) 2176,5.

Java Übung Zahlen umkehren Endwerte erster Durchlauf

So Runde eins ist erledigt.
Der nächste Schleifendurchlauf startet mit folgenden Startwerten.

  • umgedrehteZahl=50000
  • zwErgeb ist 2176
  • Der faktorZehn ist 1000.

Java Übung Zahlen umkehren zweiter durchlauf

Die Schleife beginnt mit Runde 2.

  • zwErgeb % 10 ergibt 2176 / 10 = 217 und Rest 6.
  • Der Restwert 6 wird dann mit dem FaktorZehn (1000) multipliziert.
    6*1000 = 6000
  • Und dann wird der Wert aus der Variablen umgedrehteZahl=50000 hinzuaddiert.
    Somit ergibt sich ein neuer Wert für die umgedrehteZahl von 56000.
  • Der faktorZehn wird durch 10 dividiert und beträgt somit 100.
  • Ausserdem wird das Zwischenergebnis (zwErgebnis) durch 10 dividiert und ist somit (2176 /10) 217.

Java Übung Zahlen umkehren Endwerte zweiter Durchlauf

So Runde zwei ist erledigt.
Der nächste Schleifendurchlauf startet mit folgenden Startwerten.

  • umgedrehteZahl=56000
  • zwErgeb ist 217
  • Der faktorZehn ist 100.

Java Übung Zahlen umkehren Endwerte dritter Durchlauf

Also Runde 3.

  • zwErgeb % 10 ergibt 217 / 10 = 21 und Rest 7.
  • Der Restwert 7 wird dann mit dem FaktorZehn (100) multipliziert.
    7*100 = 700
  • Und dann wird der Wert aus der Variablen umgedrehteZahl=56000 hinzuaddiert.
    Somit ergibt sich ein Wert für die umgedrehteZahl von 56700, nach dem dritten Durchlauf.
  • Der faktorZehn wird durch 10 dividiert und beträgt jetzt 10.
  • Ausserdem wird das Zwischenergebnis (zwErgebnis) durch 10 dividiert und ist somit (217 /10) 21.

Java Übung Zahlen umdrehen endwerte dritter Durchlauf

Runde vier beginnt.

  • umgedrehteZahl=56700
  • zwErgeb ist 21
  • Der faktorZehn ist 10.

Java Übung Zahlen umkehren vierter Durchlauf

  • zwErgeb % 10 ergibt 21 / 10 = 2 und Rest 1.
  • Der Restwert 1 wird dann mit dem FaktorZehn (10) multipliziert.
    1*10 = 10
  • Und dann wird der Wert aus der Variablen umgedrehteZahl=56700 hinzuaddiert.
    Somit ergibt sich ein Wert für die umgedrehteZahl von 56710, nach dem vierten Durchlauf.
  • Der faktorZehn wird durch 10 dividiert und beträgt jetzt 1.
  • Ausserdem wird das Zwischenergebnis (zwErgebnis) durch 10 dividiert und ist somit (21 /10) 2.

Java Übung Zahlen umdrehen endwerte vierter Durchlauf

Die letzte Runde hat folgende Startwerte:

  • umgedrehteZahl=56710
  • zwErgeb ist 2
  • Der faktorZehn ist 1.

Java-Übung-Zahlen-umkehren-fünfter-Durchlauf

  • zwErgeb % 10 ergibt 2 / 10 = 0 und Rest 2. Denn (0*10=0 Rest 2)
  • Der Restwert 2 wird dann mit dem FaktorZehn (1) multipliziert.
    2*1 = 2
  • Und dann wird der Wert aus der Variablen umgedrehteZahl=56710 hinzuaddiert.
    Somit ergibt sich ein Wert für die umgedrehteZahl von 56712, nach dem fünften Durchlauf.
  • Der faktorZehn wird durch 10 dividiert und ist somit 0.
  • Ausserdem wird das Zwischenergebnis (zwErgebnis) durch 10 dividiert und ist somit (2 /10) 0. (Denke Integer 0,2 =0)

Java Übung Zahlen umkehren Endwerte fünfter Durchlauf

Den sechsten Durchlauf startet die Schleife nicht mehr,da die Schleifenbedingung zwErgebnis!=0 nicht erfüllt ist.
Die Zahl ist somit 56712.
Fertig.
Java Übung Zahlen Umdrehen 10 Potenzen


Ähnliche Beiträge

Sicherer Schleifendurchlauf mit Do while Schleife

Java Do While Schleife

Es ist doch eigentlich so: Immer wenn du die Anzahl der Schleifendurchläufe nicht kennst, nutzt du in deinen Java Programmen while Schleifen. Doch Java bietet dir neben der While Schleife einen weiteren Schleifentyp an. Diese nennt sich do while Schleife. Was kann die? Eigentlich genau das Gleiche, wie die while Schleife. Mit einem kleinen aber […]

Java Übung 18: Berechne die Fakultät

Java Übung Fakultät

In dieser Java Übung geht es um die Fakultät aufeinander folgender Zahlen. Für alle, bei denen der Mathe-Unterricht genauso lange her ist, wie bei mir: 🙂 Die Fakultät ist das Produkt aufeinander folgender natürlicher Zahlen. Zum Beispiel: Die Fakultät von 2 ist: 1*2=2 Die Fakultät von 5 ist: 1*2*3*4*5=120 So – ich hoffe, dass ich […]

So kannst du Java installieren

Java installieren

Bevor du loslegst und deine ersten Java Programme schreibst, benötigst du die entsprechende Arbeitsumgebung. Du solltest also Java installieren. Und diese Arbeitsumgebung beinhaltet dann Bibliotheken für die einzelnen Java-Standard-Klassen, Dateien um deine Programme auszuführen. Dateien um deine Programme zu packen, Logische Verzeichnisstrukturen

Polymorphie bringt Vorteile für Java Arrays

Java Polymorphie Arrays

Wenn Java Arrays, Schubladen oder Container sein sollen… Dann wäre der Gebrauch einer solchen Schublade ziemlich einseitig und festgefahren. Denn in jedes Array passen zwar mehrere Daten – aber immer nur vom gleichen Datentyp. Immer gleicher Datentyp? Also eine Schublade nur für Socken, Unterwäsche und der ganze andere Kram passt dann eben nicht hinein. Um […]

So implementierst du Instanzmethoden in deine Java Klasse

Java Instanzmethoden

In einen der letzten Beiträge habe ich dir gezeigt, wie du eine Klasse anlegen kannst. Ich habe die Klasse „Mensch“ oder „Human“ angelegt und wir haben die erste Instanzvariable implementiert. Dein Code sollte jetzt so aussehen: public class Human { int size=156;//size in centimeter } In diesem Beitrag werde ich dir zeigen, wie du Java […]

Das Java Vererbung Konzept in einem Rollenspiel

Java ist eine objektorientierte Programmiersprache. Und das bedeutet nicht nur, dass du Objekte einer Java Klasse erzeugen kannst. Es bedeutet auch, dass Java Klassen von anderen Klassen erben können. Wieso das Ganze? Stell dir einmal ein Rollenspiel vor. Wie würdest du ein Rollenspiel entwerfen? In einem Rollenspiel gibt es magische Gegenstände. Zauberringe, Zauberstäbe, welche bei […]

So kannst du dein Java Programm mit der main Methode ausführen

Auf zum ersten Java Programm. Vielleicht fragst du dich jetzt gerade: Na, was haben wir denn bisher gemacht? War das etwa kein Java Programm? Wir haben bisher nur eine Klasse „Human“ für ein zuküntfiges Mensch-Objekt erstellt. Diesem Objekt haben wir eine Instanzvariable, namens size (Größe) zugeordnet. Und wir haben eine Instanzmethode, namens grow (wachsen) geschrieben. […]

So verwendest du Inkrement und Dekrement Operatoren in deinen Java Programmen

Java Operatoren

In diesem Beitrag geht es um Java Operatoren. Ich möchte dir gern zwei neue Operatoren vorstellen. Diese nennen sich Inkrement und Dekrement. Ja was heißt das? Inkrementieren bedeutet eine schrittweise Erhöhung einer Zahl. Und dementsprechend bedeutet Dekrementieren: Die schrittweise Verminderung einer Zahl. Wozu brauchst du das? Stell dir vor. Du bekommst eine Liste mit Namen […]

So verwendest du den Java Oder Operator

Java Oder Operator

Kennst du das auch aus deiner Schulzeit? Du schreibst eine Klassenarbeit in irgendeinem Fach. Nehmen wir einfach mal an – Mathe. Jetzt bist gerade fertig mit deiner Arbeit. Und zu Hause wirst du gefragt: „Und wie lief es?“ Du antwortet:“ Ganz gut. Es wird bestimmt eine Eins oder eine Zwei.“ Drei oder vier Tage später […]

Drei Möglichkeiten um Java Objekte zu zerstören

Java Objekte zerstören

Java Objekte leben genau solange, wie eine Referenzvariable auf sie zeigt. Wenn dieser Zeiger nicht mehr existiert, wird dieses Objekt aufgeben. Und wenn dieses Objekt erst einmal aufgegeben wurde, dann kommt der Garbage Collector und entsorgt dieses. Aber wie kannst du nun am Sinnvollsten Objekte aufgeben? Lass es uns herausfinden.

So kannst du Java Arrays anlegen

Java Arrays anlegen

Java Arrays– Was ist das? Stell es dir einmal als ein Bücherregal vor. In einem Bücherregal befinden sich sämtliche Bücher. Und diese befinden sich schön nebeneinander. Jedes Buch hat seinen festen Platz. Du kannst die Bücher ganz genau lokalisieren. Zum Beispiel kannst du sagen. Das erste Buch von links Das dritte von rechts usw. Und […]