Skip to main content

Java Übung 27 – Auf zur Mathe-Olympiade

In dieser Java Übung möchte ich mit dir ein Programm erstellen, welches ein Mathematik-Test oder eine Mathe-Olympiade simuliert.

Du kennst das vielleicht noch aus der Schule.
Matheolympiade- Da wurden aus allen vier Grundrechenarten, Aufgaben formuliert.

Die Schüler mussten diese Aufgaben lösen.
Die Lehrer kontrollierten die Lösungen.
Und der Schüler, welcher die wenigsten Fehler hatte – gewann die Olympiade.

Und genau so eine Matheolympiade werden wir jetzt simulieren.
Ziel soll es sein, dass du beim Programmstart zwei Werte eingibst.

  • Wert 1: Ist die Anzahl der Aufgaben, welche dir gestellt werden.
  • Wert 2: Ist der Wertebereich /Größenbereich, in welchem sich die Zahlen zu den Aufgaben befinden.

Und dann werden, anhand deiner Angabe zur Anzahl, Matheaufgaben gestellt.
Diese Aufgaben sind zufällige Aufgaben mit zufälligen Operationen.
Es wird somit ausgewürfelt, welche Rechenart (+, – , / , * ) gestellt wird.

Auch die Zahlen in den Aufgaben sind zufällig vom Programm ermittelt worden.

Um es einfach zu halten, sind alle Zahlen ganzzahlig – also ohne Komma.

Der Nutzer rechnet die ihm gestellte Aufgabe aus und gibt das Ergebnis in der Konsole ein.
Das Programm prüft die Lösung und zählt die Fehler.

Wenn alle Aufgaben durchgerechnet worden, erfolgt eine Konsolenausgabe.
In dieser steht dann:
„Die Anzahl der Fehler ist…..“

Hier ein kurzes Video dazu:


Aufgabenstellung:
Erstelle die Klasse „MatheOlympiade“
Und lege dann alle 8 Klassenmethoden an:

  • die main-Methode
  • starteProgramm()-Methode
  • generiereAufgaben()-Methode
  • addiere()-Methode
  • subtrahiere()-Methode
  • multipliziere()-Methode
  • dividiere()-Methode
  • gibInfo()-Methode

Die main-Methode ruft die statische, parameterlose „starteProgramm-Methode“ auf.

Die Methode „starteProgramm()“ fordert dich dann auf zwei Eingaben zu vollziehen.
Und zwar den Wertebereich („wertebereich“) und die Anzahl der Aufgaben („anzahlAufgaben“).

Wenn du beide Eingaben gemacht hast, soll die „starteProgramm()-Methode“ die „generiereAufgaben()-Methode“ aufrufen.
Beim Aufruf wird der Wertebereich übergeben.

Die „generiereAufgaben“-Methode ruft in zufälliger Reihenfolge die Rechenmethoden auf.

Java Übung Matheolympiade rechenmethoden

Alle Rechenmethoden sollen:

  1. Zufallszahlen generieren,
  2. Daraus Konsolenausgaben mit Rechenaufgaben erzeugen,
  3. Deine Eingabe speichern und überprüfen.
  4. Feedback, wie richtig oder falsch, geben.
  5. Falsche Ergebnisse zählen.

Wenn alle Aufgaben erledigt worden, ruft die generiereAufgaben-Methode – die gibInfo()-Methode auf.
Und die gibInfo()-Methode erzeugt eine Bildschirmausgabe mit der Anzahl der Fehler.

So alles klar?
Na dann…
Ich wünsche Dir viel Erfolg beim Lösen dieser Java Übung.


Beginne bei den Variablen

Das Grundgerüst der Klasse sieht so aus:

public class MatheOlympiade {
	
	static void starteProgramm(){
		
	}
	
	public static void main(String[] args) {
		starteProgramm(); //Aufruf der start-Methode 
	}
}

Jetzt meine Frage:
Welche Variablen braucht das Programm?

Klar, die Variablen um die Zufallszahlen zu speichern.
Nein diese meine ich nicht.
Diese Variablen sind lokal.
Sie werden somit direkt in den Methoden angelegt.
Und dies vollziehen wir auch erst dann, wenn wir die Methoden anlegen.

Was du aber zu Beginn brauchst, sind die Variablen um:

  • Den Wertebereich festzulegen
  • Die Fehleranzahl zu speichern
  • Und die Anzahl der Aufgaben zu speichern.

Wie sollten diese Variablen sein?
Oder anders gesagt: Welche Anforderungen stellt das Programm an diese Variablen?

Die Fehleranzahl soll von den Rechenmethoden genutzt werden.
Die einzelnen Methoden sollen den Wert der Variable um Eins erhöhen, sobald dein eingegebenes Ergebnis falsch ist.

Das bedeutet, dass alle vier Methoden auf ein- und dieselbe Variable zugreifen sollen.
Und das bedeutet wiederum, dass die Variable „fehlerAnzahl“ eine Klassenvariable sein sollte.
static int fehlerAnzahl;

Die Variable „werteBereich“ soll ebenfalls von allen Methoden genutzt werden.
In der Aufgabenstellung beschrieb ich aber, dass dieser abgefragt, gespeichert und übergeben wird.
Somit wird dieser als lokale Variable, innerhalb der Start-Methode, angelegt.

Und zwar so:

import java.util.Scanner;//Importanweisung für die Scanner-Klasse

public class MatheOlympiade {
	static int fehlerAnzahl;//Klassenvariable -somit haben alle Methoden Zugriff
	
	static void starteProgramm(){
		Scanner scanner = new Scanner (System.in);//neues Scanner-Objekt
		
		System.out.println("Gib den Wertebereich an!");//Konsolenaufforderung
		int werteBereich=scanner.nextInt();//Konsoleneingabe wird gespeichert

		//Wertebereich an generiereAufgaben-Methode übergeben
	}
	
	public static void main(String[] args) {
		starteProgramm();
	}
}

Was passiert hier?
Da du eine Konsoleneingabe speichern möchtest, benötigst du ein Objekt aus der Scannerklasse.
In diesem Beispielcode habe ich eine Referenzvariable, namens „scanner“ angelegt.
Diese Variable verweist auf das Scanner-Objekt.
Scanner scanner = new Scanner (System.in);

Dann erfolgt die Aufforderung zur Eingabe des Wertebereichs.
System.out.println("Gib den Wertebereich an!");

Und die Zahl, welche du dann in die Konsole eingibst, wird in der Variablen „werteBereich“ gespeichert.
int werteBereich=scanner.nextInt();
So einfach.

Eine Variable fehlt noch:
Die Anzahl der Aufgaben.

Der Wert dieser Variable soll ebenfalls in der Start-Methode vergeben werden.
Die „generieren-Methode“ soll aber den Wert der Variablen lesen.
Und dann dementspechend viele Aufrufe der Rechenmethoden erzeugen.

Im Klartext:
Die Variable sollte ebenfalls statisch, also eine Klassenvariable sein.

Das bedeutet:
Du legst diese auf Klassenebene an.
Den Wert bekommt sie aber erst in der Methode zugewiesen.


import java.util.Scanner;//Importanweisung für den Scanner

public class MatheOlympiade {
	static int fehlerAnzahl;//statisch-Wert kann von den Rechenmethoden verändert werden
	static int aufgabenAnzahl;//statisch-kann von Methode "generiereAufgaben" genutzt werden
	
	static void starteProgramm(){
		Scanner scanner = new Scanner (System.in);//Neues Scannerobjekt
		System.out.println("Wie viele Aufgaben willst du lösen?");
		aufgabenAnzahl=scanner.nextInt();//speichert die Aufgabenanzahl
		
		System.out.println("Gib den Wertebereich an!");
		int werteBereich=scanner.nextInt();//lokale Variable speichert den Wertebereich
		//hier kommt der Code zu generiereAufgaben(werteBereich);
	}
	public static void main(String[] args) {
		starteProgramm();
	}
}

So die erste Methode steht.
Später werden wir dann noch die generieren-Methode aufrufen und den Wertebereich übergeben.

Machen wir mit den Rechenmethoden weiter.
Diese sind eigentlich nicht kompliziert.
Sie unterscheiden sich aber an gewissen Stellen.

Was aber alle Rechenmethoden gemeinsam haben, sind die Zufallszahlen.
Und wie du diese erstellst, möchte ich dir jetzt zeigen.

So kannst du Zufallszahlen für deine Java Methoden anlegen.

Die 4 Rechenmethoden sollen Zufallszahlen generieren.
Und diese Zufallszahlen sollen ganzzahlig sein.

Also dann, lass uns Zufallszahlen anlegen.
Als Erstes muss diese Zufallszahl in einer Variablen gespeichert werden.

In meinem Beispiel-Code heißen die Variablen dafür „sumEins“ für den ersten Summanden.
Und „sumZwei“ für den zweiten Summanden.
Die Werte beider Variablen sollen ganzzahlig sein.
Deshalb speichere ich mir diese in einem Integer-Datentypen ab.


int sumEins = 0;
int sumZwei =0;

So die Variablen hast du.
Aber beide Variablen haben bis jetzt nur den Wert Null.

Wie bekommst du nun eine Zufallszahl da rein?
Die Java Klasse Math ist eine Standardklasse der Java API.
Und diese bietet eine Klassenmethode, namens Random an.

Die Methode erzeugt Zufallszahlen zwischen 0 und 1.

Also musst du in der Variablen den Rückgabewert der Random-Methode speichern.


int sumEins = Math.Random();
int sumZwei = Math.Random();

Jetzt steckt in den Variablen eine zufällige Kommazahl, zwischen 0 und 1.

Wenn du Zufallszahlen zwischen 0 und 100 haben möchtest, musst du diese Kommazahl mit 100 multiplizieren.
Das Ergebnis dieser Multiplikation ist dann irgendeine zufällige Kommazahl zwischen 0 und 100.

Am Beispiel:

  • Die Zufallszahl lautet 0,0.
    Du multiplizierst diese mit 100.
    Das Ergebnis ist 0,0.
  • Die Zufallszahl lautet 0,8764.
    Du multiplizierst mit 100.
    Das Ergebnis ist 87,64.
  • Oder die Zufallszahl ist 1,0 – multipliziert mit 100 ergibt dann 100,0

int sumEins = (Math.random()*100);
int sumZwei = (Math.random()*100);

Du siehst aus den eigentlichen Zufallszahlen, welche zwischen 0 und 1 liegen – lassen sich beliebig große Zufallszahlen generieren.
Der Schlüssel dazu liegt in der Multiplikation.

Da aber die Zufallszahl, welche dir die Math.Random() bereitstellt eine Kommazahl ist – musst du diese noch in eine ganze Zahl ändern.

Wieso?
Du willst bei der Matheolympiade keine Aufgaben wie:
32,65 / 4,765 gestellt bekommen.
Nein -die Aufgabe soll lauten: 32 / 4.

Also abändern.
Du musst die Kommazahl in einen Integer-Datentypen casten / umwandeln.
Dazu schreibst du einfach (int) vor den Methodenaufruf.


int sumEins =(int)(Math.random()*100);
int sumZwei = (int)(Math.random()*100);

Somit hast du auch die Zufallszahlen.
Und diesen Java Code kannst du in allen 4 Rechenmethoden verwenden.

Beginnen wir mit der einfachsten Rechenmethode – der Addition.

Kommen wir zu den Methoden.

So legst du die Additions-Methode an.

Summand + Summand = Summe
Die Elemente einer Addition heißen Summanden und das Ergebnis nennt man Summe.

Die Methode addiere() soll jetzt zwei zufällige Summanden finden, welche miteinander addiert werden.
Aber wir stellen eine Bedingung an die Zufallszahlen.
Diese sollen im Wertebereich liegen.

Dazu wird das Argument „werteBereich“ mit der Zufallszahl verrechnet.

Erinnere dich:
Der Wertebereich wird in der „starteProgramm-Methode“ abgefragt und auch dort festgelegt.
Dann wird dieser Wert an die „generiereAufgabe()-Methode“ weitergegeben.

Java Übung Matheolympiade Wertübergabe

Und die generieren-Methode soll die einzelnen Rechenmethoden zufällig aufrufen und ihnen den Wertebereich übergeben.
Java Übung Matheolympiade rechenmethoden

Wenn du beispielsweise nur Aufgaben im Zahlenbereich 100 rechnen möchtest, dann gibst du diesen Wertebereich an.
Java Übung Wertebereich wählen

Und es werden nur Zufallszahlen in diesem Zahlenbereich erzeugt.
Java-Übung-Mathe-Olympiade-Zufallszahl

So könnte die addieren-Methode aussehen:


import java.util.Scanner;

public class MatheOlympiade {
	static int fehlerAnzahl;
	static int aufgabenAnzahl;
	
	static void starteProgramm(){
		Scanner scanner = new Scanner (System.in);
		System.out.println("Wie viele Aufgaben willst du lösen?");
		aufgabenAnzahl=scanner.nextInt();
		
		System.out.println("Gib den Wertebereich an!");
		int werteBereich=scanner.nextInt();
		//generiereAufgaben(werteBereich);
	}

	static void addiere(int werteBereich){
		int sumEins =(int)(Math.random()*werteBereich);
		int sumZwei = (int)(Math.random()*werteBereich);
		int summe=sumEins+sumZwei;

		}
	
	public static void main(String[] args) {
		starteProgramm();
	}
}

Aber reicht das?
Ich denke nicht, denn…
Die Zufallszahl könnte für sumEins=70 und für sumZwei =60 sein.
Die Summe aus beiden Zufallszahlen wäre dann 130.

Und die Summe soll schließlich im Wertebereich liegen.

Java Übung Matheolympiade Summe

Du musst also, eine Programmstruktur schaffen, welche solange Zufallszahlen erzeugt bis die Summe aus beiden Zahlen gleich oder unter dem Wertebereich liegt.

Und das machst du mit einer Schleife.
Die Schleifenbedingung der while-Schleife lautet:
(summe >= werteBereich)

Im Rumpf der Schleife werden dann immer neue Zufallszahlen gebildet.
Und das macht die Schleife solange, bis die Abbruchbedingung der Schleife eintritt.


while (summe >= werteBereich){
			sumEins =(int)Math.random()*werteBereich;
			sumZwei = (int)Math.random()*werteBereich;
			summe=sumEins+sumZwei;

Kümmern wir uns um den Rest.
Wenn das Programm läuft, wirst du aufgefordert die Summe aus zwei Zufallszahlen zu berechnen.
Und dein Ergebnis sollst du eingeben.
Der Code zur Eingabe lautet so:
int eingabe = scanner.nextInt();

Und diese Eingabe soll überprüft werden.
Eine Überprüfung machst du mit if und else Blöcken.

Die Bedingung, wenn deine Eingabe mit dem tatsächlichen Ergebnis nicht übereinstimmt lautet:
(summe != eingabe)
Und diesem Fall springt das Programm in den if – Block und führt diesen aus.

Im Falle einer falschen Eingaben bekommst:
Du dies über die Konsole mitgeteilt. System.out.println("Falsch");
Und der Wert, welcher in der Klassenvariable „fehlerAnzahl“ steckt, wird erhöht. fehlerAnzahl++;

Und so würde dann die addiere-Methode als Ganzes aussehen:


static void addiere(int werteBereich) {
		int sumEins = (int) (Math.random() * werteBereich);//Zufallszahl im Wertebereich
		int sumZwei = (int) (Math.random() * werteBereich);//Zweiter Summand ist ebenfalls im Wertebereich
		int summe = sumEins + sumZwei;//Die Summe ist Summand + Summand
		Scanner scanner = new Scanner(System.in);//Scanner-Objekt für die spätere Konsoleneeingabe

		while (summe > werteBereich) { //solange die Summe größer als der Wertebereich ist, geht es in die Schleife
			sumEins = (int) Math.random() * werteBereich;//In der Schleife wird eine neue Zufallszahl erstellt
			sumZwei = (int) Math.random() * werteBereich;//Summand bekommt ebenfalls eine neue ZUfallszahl
			summe = sumEins + sumZwei;//Summe wird bei jedem Schleifendurchlauf berechnet
		}
		System.out.println(sumEins + "+" + sumZwei);//Diese Aufgabenstellung erscheint dann auf der Konsole
		int eingabe = scanner.nextInt();//Deine Eingabe wird gespeichert
		if (summe != eingabe) {
			fehlerAnzahl++;//Falls deine Eingabe nicht richtig ist wird der Wert erhöht
			System.out.println("Falsch");//Feedback wird auf der Konsole ausgegegeben
		} else {
			System.out.println("Richtig");//Feedback bei richtiger Eingabe
		}
	}

Die Multiplizieren-Methode kannst du anlog zur Addieren-Methode schreiben.

Faktor * Faktor = Produkt.
Auch hier wird das Ergebnis geprüft.

Java Übung Mathe Olympiade Multiplizieren

In diesem Fall soll sich das Produkt im Wertebereich befinden.

Der komplette Code zu dieser Java Methode sieht dann so aus:


static void multipliziere(int werteBereich) {
		int fakEins = (int) (Math.random() * werteBereich);//Zufallszahl Faktor 1 im Wertebereich
		int fakZwei = (int) (Math.random() * werteBereich);//Zufallszahl für Faktor 2 im Wertebereich
		int produkt = fakEins * fakZwei;//Berechnung des Produktes
		Scanner scanner = new Scanner(System.in);//Scanner-Objekt für die Konsoleneingabe

		while (produkt > werteBereich) { //Immer wenn das Produkt größer als der Wertebereich ist, gehts in die Schleife
			fakEins = (int) (Math.random() * werteBereich);//Neue Zufallszahl für Faktor Eins
			fakZwei = (int) (Math.random() * werteBereich);//Neue ZUfallszahl für Faktor Zwei
			produkt = fakEins * fakZwei;//Neuberechnung des Produktes
		}
		System.out.println(fakEins + "*" + fakZwei);//Aufforderung zur Berechnung - Erscheint bei der Ausführung
		int eingabe = scanner.nextInt();//Eingabe wird gespeichert
		if (eingabe != produkt) {
			System.out.println("Falsch");//Feedback, falls deine Eingabe falsch ist
			fehlerAnzahl++;//Klassenvariable wird auch hier um eins erhöht
		} else {
			System.out.println("Richtig");//Feedback falls die Eingabe richtig ist
		}
	}

Bei der Subtraktionsmethode ist es etwas anders.

Denn du musst jetzt das Ergebnis prüfen – Dieses darf nicht negativ sein.

Java Übung Mathe Olympiade Subtraktion

Somit muss der Minuend (erste Zahl) größer sein, als der Subtrahent.
Die Schleifenbedingung lautet somit:
subtrahent > minuend

Der Rest ist analog zu den beiden anderen Methoden.


	static void subtrahiere(int werteBereich) {
		int minuend = (int) (Math.random() * werteBereich);//Minuend im Wertebereich
		int subtrahent = (int) (Math.random() * werteBereich);//Subtrahent im Wertebereich
		int differenz = minuend - subtrahent;//Ermittlung der Differnz
		Scanner scanner = new Scanner(System.in);//Neues Scannerobjekt

		while (subtrahent > minuend) { //Solange der Subtrahent kleiner als der Minuend ist - gehts in die Schleife
			minuend = (int) (Math.random() * werteBereich);//neue Zufallszahl für den Minuend
			subtrahent = (int) (Math.random() * werteBereich);//neue Zufallszahl für den Subtrahent
			differenz = minuend - subtrahent;//Ermittlung der Differnz
		}
		System.out.println(minuend + "-" + subtrahent);//Aufforderung zur Berechnung
		int eingabe = scanner.nextInt();//Eingabe wird gespeichert
		if (eingabe != differenz) { //Eingabe wird verglichen
			System.out.println("Falsch");//Feedback falls EIngabe falsch
			fehlerAnzahl++; //Wert der Variablen erhöht sich
		} else {
			System.out.println("Richtig");//Feedback falls deine Eingabe richtig ist
		}
	}

Die letzte Rechenmethode ist die Division.

Auch hier wird das Ergebnis geprüft.

Java Übung Mathe Olympiade Dividieren

Eine Division durch null ist mathematisch nicht möglich.
Das Programm würde dann einen Fehler verursachen.

Das bedeutet, dass die Zufallszahl bei 1 beginnt.
int divisor = (int) (Math.random() * werteBereich) + 1;

Außerdem soll das Programm keine Rechenaufgaben erzeugen, bei denen das Ergebnis ein Bruch ist.
Somit lautet die Schleifenbedingung:
(divident % divisor != 0)

Der Rest ist analog zu den anderen Rechenmethoden.


	static void dividiere(int werteBereich) {
		int divident = (int) (Math.random() * werteBereich);//ZUfallszahl für den Divident
		int divisor = (int) (Math.random() * werteBereich) + 1;//Divisor 0 ist nicht möglich
		int quotient = divident / divisor;//Quotient wird ermittelt
		Scanner scanner = new Scanner(System.in);//Scanner-Objekt für spätere Eingabe

		while (divident % divisor != 0) {
			divident = (int) (Math.random() * werteBereich);//Neue ZUfallszahl für den Divident
			divisor = (int) (Math.random() * werteBereich) + 1;//Zufallszahl beginnt auch hier bei 1
			quotient = divident / divisor;//Quotient wird neu gespeichert
		}
		System.out.println(divident + "/" + divisor);//Aufgabenstellung für die Konsole
		int eingabe = scanner.nextInt();//Eingabe wird gespeichert
		if (eingabe != quotient) {
			System.out.println("Falsch");//Feedback falls Eingabe falsch
			fehlerAnzahl++;//Fehleranzahl wird um eins erhöht
		} else {
			System.out.println("Richtig");//Feedback falls Eingabe richtig ist
		}
	}

Das Herzstück des Programmes ist die generieren()-Methode.

Diese Methode soll dann alle 4 Rechenmethoden in einer zufälligen Reihenfolge aufrufen.
Und zwar sooft, wie es in der Klassen-Variablen „aufgabenAnzahl“ gespeichert wurde.

Wie könnte man dies jetzt umsetzen?
Vielleicht so…

  • Erzeugen einer Zufallszahl zwischen 0 und 3.
  • Wenn der Wert 0 ist dann wird die addieren-Methode ausgeführt.
  • Wenn der Wert 1 ist, dann die Subtraktion.
  • Bei 2 eben Multiplikation.
  • Und schließlich bei 3 die Division.

Gesagt getan… 🙂


	static void generiereAufgaben(int werteBereich) {
		int bereich = (int) (Math.random() * 3);//ZUfallszahl zwischen 0 und 3
			switch (bereich) {
			case 0:
				System.out.println("Addition");//Konsolenausgabe was gemacht werden soll
				addiere(werteBereich);//Aufruf der Addieren-Methode und Übergabe des Wertebereichs
				break;
			case 1:
				System.out.println("Subtraktion");
				subtrahiere(werteBereich);
				break;
			case 2:
				System.out.println("Multipliziere");
				multipliziere(werteBereich);
				break;
			default:
				System.out.println("Dividiere");
				dividiere(werteBereich);
				break;
			}
		}
	}

Jetzt würde das Ganze einmal stattfinden.
Es würde eine Zufallszahl zwischen 0 und 3 generiert werden.
Das Programm hakt in den entsprechenden Case ein.
Und es würde dann eine zufällige Rechenaufgabe gestellt werden.

Jetzt musst du nur noch ein Konstrukt schaffen, welches dies beliebig oft wiederholt.
Jawohl – Eine Schleife.

Und welche Art von Schleife?
Die Anzahl der Durchläufe ist bekannt.
Den Wert speicherst du in der Klassenvariablen „aufgabenAnzahl“.
Und wenn die Anzahl der Durchläufe bekannt ist, nutze immer eine for-Schleife.

Der Schleifenzähler könnte bei 0 starten.
Also int i =0.

Aber du könntest diesen auch bei 1 starten lassen.
Und bei jedem Durchlauf lässt du dir die Aufgabenanzahl (1.Aufgabe, 2.Aufgabe usw.) anzeigen.
Ist doch besser oder?

Die Abbruchbedingung der Schleife würde im Falle i=1 lauten:
i <= aufgabenAnzahl

Somit sieht der Kopf der Schleife so aus:
(int i = 1; i <= aufgabenAnzahl; i++)

Und im Rumpf kommen dann nur noch die switch case Anweisung, welche du bereits hast.
Also dann.

Der komplette Code der "generiereAufgaben"-Methode würde so aussehen.


	static void generiereAufgaben(int werteBereich) {
		int bereich = 0;//Lokale Variable mit Startwert 0
		for (int i = 1; i <= aufgabenAnzahl; i++) {
			bereich = (int) (Math.random() * 4);//Zufallszahl bei jedem Schleifendurchlauf
			System.out.println(i + ".Aufgabe");//Ausgabe der jeweiligen Aufgabe
			switch (bereich) {
			case 0:
				System.out.println("Addition");
				addiere(werteBereich);
				break;
			case 1:
				System.out.println("Subtraktion");
				subtrahiere(werteBereich);
				break;
			case 2:
				System.out.println("Multipliziere");
				multipliziere(werteBereich);
				break;
			default:
				System.out.println("Dividiere");
				dividiere(werteBereich);
				break;
			}
		}
		gibInfo();
	}

Du siehst es schon.
Nachdem die komplette Schleife durchlaufen wurde, wírd die gibInfo()-Methode aufgerufen.

Die letzte Methode soll nur Informationen geben.

Diese Methode nutzt die Klassenvariable "fehlerAnzahl".
Und gibt den Wert auf der Konsole aus.


static void gibInfo(){
		System.out.println("Fehleranzahl: "+fehlerAnzahl);
	}

So das wars.

Hier ist die komplette Lösung zu dieser Java Übung


import java.util.Scanner;//Importanweisung für Scanner

public class MatheOlympiade {
	static int fehlerAnzahl;//KLassenvariable soll von allen 4 Rechenmethoden genutzt werden
	static int aufgabenAnzahl;//Aufgabenanzahl wird in der Start-Methode festgelegt und in der generieren-Methode genutzt

	static void starteProgramm() {
		Scanner scanner = new Scanner(System.in);
		System.out.println("Wie viele Aufgaben willst du lösen?");
		aufgabenAnzahl = scanner.nextInt();//Anzahl der Aufgaben wird in Klassenvariable gespeichert

		System.out.println("Gib den Wertebereich an!");
		int werteBereich = scanner.nextInt();//Wertebereich wird in lokaler Variabler gespeichert
		generiereAufgaben(werteBereich);//Methode wird aufgerufen und Wertebereich wird übergeben
	}

	static void gibInfo() {
		System.out.println("Fehleranzahl: " + fehlerAnzahl);//Konsolenausgabe zur Klassenvariable Fehleranzahl
	}

	static void generiereAufgaben(int werteBereich) {
		int bereich = 0;//lokale Variable speichert die Zufallszahl

		for (int i = 1; i <= aufgabenAnzahl; i++) {
			bereich = (int) (Math.random() * 3);//Zufallszahl wird jedes Mal neu ermittelt
			System.out.println(i + ".Aufgabe");//Konsolenausgabe zur Aufgabenanzahl 1., 2., 3. usw.
			switch (bereich) {
			case 0:
				System.out.println("Addition");//Aufforderung zur Berechnung
				addiere(werteBereich);//addieren-Methode wird aufgerufen und Wertebereich wird übergeben
				break;
			case 1:
				System.out.println("Subtraktion");//Aufforderung zur Subtraktion
				subtrahiere(werteBereich);//subtrahieren-Methode wird aufgerufen und Wertebereich wird übergeben
				break;
			case 2:
				System.out.println("Multipliziere");//Aufforderung zur Multiplikation
				multipliziere(werteBereich);//multiplizieren-Methode wird aufgerufen und Wertebereich wird übergeben
				break;
			default:
				System.out.println("Dividiere");//Aufforderung zur Division
				dividiere(werteBereich);//Dividiere-Methode wird aufgerufen und Wertebereich wird übergeben
				break;
			}
		}
		gibInfo();//Nachdem Schleife komplett durchlaufen wurde, wird die gibInfo() Methode aufgerufen
	}

	static void addiere(int werteBereich) {
		int sumEins = (int) (Math.random() * werteBereich);//Zufallszahl für Summand Eins
		int sumZwei = (int) (Math.random() * werteBereich);//Zufallszahl für Summand Zwei
		int summe = sumEins + sumZwei;//Summe = Summand +  Summand
		Scanner scanner = new Scanner(System.in);//Scanner-Objekt mit Referenzvariable scanner

		while (summe >= werteBereich) {
			sumEins = (int) Math.random() * werteBereich;//neue Zufallszahl
			sumZwei = (int) Math.random() * werteBereich;//neue ZUfallszahl
			summe = sumEins + sumZwei;//neue Summe
		}
		System.out.println(sumEins + "+" + sumZwei);//Konsolenanweisung
		int eingabe = scanner.nextInt();//Eingabe wird durch die Referenzvariable Scanner gespeichert
		if (summe != eingabe) {
			fehlerAnzahl++;//Fehleranzahl wird erhöht
			System.out.println("Falsch");//Feedback falls Ergbebnis falsch ist
		} else {
			System.out.println("Richtig");//Feedback, falls Ergebnis richtig ist
		}
	}

	static void subtrahiere(int werteBereich) {
		int minuend = (int) (Math.random() * werteBereich);
		int subtrahent = (int) (Math.random() * werteBereich);
		int differenz = minuend - subtrahent;
		Scanner scanner = new Scanner(System.in);

		while (subtrahent > minuend) {
			minuend = (int) (Math.random() * werteBereich);
			subtrahent = (int) (Math.random() * werteBereich);
			differenz = minuend - subtrahent;
		}
		System.out.println(minuend + "-" + subtrahent);
		int eingabe = scanner.nextInt();
		if (eingabe != differenz) {
			System.out.println("Falsch");
			fehlerAnzahl++;
		} else {
			System.out.println("Richtig");
		}
	}

	static void multipliziere(int werteBereich) {
		int fakEins = (int) (Math.random() * werteBereich);
		int fakZwei = (int) (Math.random() * werteBereich);
		int produkt = fakEins * fakZwei;
		Scanner scanner = new Scanner(System.in);

		while (produkt > werteBereich) {
			fakEins = (int) (Math.random() * werteBereich);
			fakZwei = (int) (Math.random() * werteBereich);
			produkt = fakEins * fakZwei;
		}
		System.out.println(fakEins + "*" + fakZwei);
		int eingabe = scanner.nextInt();
		if (eingabe != produkt) {
			System.out.println("Falsch");
			fehlerAnzahl++;
		} else {
			System.out.println("Richtig");
		}
	}

	static void dividiere(int werteBereich) {
		int divident = (int) (Math.random() * werteBereich);
		int divisor = (int) (Math.random() * werteBereich) + 1;//Null als Zufallszahl wird ausgeschlossen
		int quotient = divident / divisor;
		Scanner scanner = new Scanner(System.in);

		while (divident % divisor != 0) {
			divident = (int) (Math.random() * werteBereich);
			divisor = (int) (Math.random() * werteBereich) + 1;//Zufallszahl ist größer Null
			quotient = divident / divisor;
		}
		System.out.println(divident + "/" + divisor);
		int eingabe = scanner.nextInt();
		if (eingabe != quotient) {
			System.out.println("Falsch");
			fehlerAnzahl++;
		} else {
			System.out.println("Richtig");
		}
	}

	public static void main(String[] args) {
		starteProgramm();
	}
}


Ähnliche Beiträge

So kannst du deine Eclipse Oberfläche anpassen

Eclipse anpassen

In diesem Beitrag möchte ich dir zwei ganz nette Features von Eclipse vorstellen. Es geht um Views und um Perspektiven. Wie du schon weißt, besteht Eclipse aus einer grafischen Oberfläche. Und in dieser Oberfläche stehen dir verschiedene Views zur Verfügung. Was ist so ein View?

Java Übung 31: Speichere deine Würfe im Array

Java Übung Array Würfelspiel

In dieser Java Übung soll ein Würfelspiel simuliert werden. Lege eine Klasse namens, Würfelspiel an. Diese Klasse enthält eine statische Methode, namens würfeln(). Diese Methode erwartet einen Parameter vom Datentyp Integer, namens „anzahlWuerfe“. Diese Variable/Parameter repräsentiert die Anzahl der Würfe. Nachdem der Methode die Anzahl der Würfe übergeben wurde, soll die Methode Zufallszahlen zwischen 1 […]

Java Binärzahl in Dezimalzahl umwandeln – So geht’s.

Java-Binärzahl-umrechnen

Erinnerst du dich? In einer der letzten Beiträge haben wir uns die Zusammenhänge zwischen dem dualen und dem dezimalen Zahlensystem angeschaut. Aber wir haben noch keine Java Binärzahl in eine Dezimalzahl verwandelt. Zumindestens nicht praktisch…. Stattdessen…. Haben wir festgestellt, dass beide Zahlensysteme im Grunde genommen sehr ähnlich sind. Beim Dezimalsystem spielt die Zahl 10, als […]

Nutze die Fernbedienung für deine Java Objekte

Auf Java Objekte greifst du mit einer Art Fernsteuerung zu. Diese bezeichnet man als Referenz oder als Verweis. Und diese Referenzvariablen möchte ich dir jetzt einmal vorstellen. Doch bevor wir loslegen, lass mich noch ein paar Dinge loswerden. 🙂 Ich habe es ja schon einmal in einem früheren Beitrag erwähnt. Java unterscheidet zwischen primitiven und […]

Zwei smarte Möglichkeiten eine Java Zufallszahl zu erzeugen

Java Zufallszahl

Java Zufallszahl – Wieso? In der Java Programmierung benötigst du immer wieder einmal Zufallszahlen. Du möchtest deine Software mit Daten testen und dir keine Zahlen ausdenken. Du benötigst Stichproben, welche ein reales Verhalten simulieren. Du hast ein Spiel entworfen und die Akteure sollen mit zufälligen aber unterschiedlichen Größen, Rüstungsleveln usw. auftreten. Die Einsatzmöglichkeiten für Zufallszahlen […]

So nutzt du getter und setter Methoden bei der Java Programmierung

Java Keyword private

In diesem Artikel möchte ich dir zeigen, wie du Instanzvariablen innerhalb der Java Klasse schützt. Und den Zugriff nur noch indirekt über getter und setter Methoden anbietest. Stell dir vor. Du hast ein Programm zur Lagerverwaltung geschrieben. Dieses Programm dient Möbelhäusern dazu, ihre Bestände zu verwalten. Und das Programm erwartet vom Nutzer gewisse Eingaben zu […]

Java Übung: Alles beginnt mit Hello World

Java Übung Hello World

Alles beginnt mit „Hello World“. Sämtliche Java Bücher beginnen mit diesem ersten Beispiel. Auch die Java Übungen sollen mit diesem ersten Programm starten. Definiere eine Klasse „Hello World“. Implementiere die Main Methode. Die Main Methode soll bei Programmaufruf die Bildschirmanzeige „Hallo Welt“ zurückgeben. Die Lösung zur Java Übung „Hallo Welt“ public class HelloWorld{ public static […]

Java Strings landen im String Constant Pool

Java-Strings-Pool

Du kennst das. Es ist abends. Du sitzt gemütlich vor dem Fernseher. Das Smartphone bimmelt. Kein Anruf. Nein – Eine Nachricht. Du liest die Nachricht sofort und antwortest darauf. Minuten später bekommst du die nächste Nachricht. Und auch auf diese antwortest du. Im Laufe des Abends entsteht daraus eine nette kleine Konversation. Und eh du […]

So kannst du Eclipse installieren

Eclipse installieren

Das Schöne an Eclipse ist, es läuft auf sämtlichen Betriebssystemen. Eclipse wird einfach auf der Webseite des Herstellers herunter geladen und kann dann installiert werden. Dabei stehen dir verschiedene Versionen zur Verfügung.

Java Exceptions Handling – Fehler- und Ausnahmenbehandlung in Java

Java Exceptions Handling

Java Exceptions Handling umfasst den richtigen Umgang mit Ausnahmen und Fehlern. Wie geht das? Und braucht man so etwas wirklich? Vielleicht sagst du jetzt: „Brauch ich nicht. Ich mache niemals Fehler.“ Doch… Bei der Java Fehlerbehandlung geht es nicht ausschließlich nur um deine Programmierfehler. Es geht auch um falsche Nutzereingaben, Hardware- und Ablauffehler. Und deshalb […]