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 lassen sich Java Arrays kopieren

Java Arrays kopieren

Java Arrays kopieren oder klonen…. Was heißt das eigentlich? Eine Kopie ist eine Reproduktion bzw. die Nachbildung eines Originals. Somit ist jede Fotographie – die Abbildung einer bestimmten optischen Wirklichkeit, zu einem festen Zeitpunkt. Die Kopie einer Buchseite ist das optische Abbild dieser spezifischen Buchseite – auch zu einem festen Zeitpunkt. Wichtig in diesem Zusammenhang […]

So kannst du in Java Und Verknüpfung anlegen und auswerten

Java Und

In Java stehen dir eine Menge Operatoren zur Verfügung. Einer dieser Operatoren ist der Und-Operator. Dies ist ein logischer Operator, da dieser sogenannte Wahrheitswerte mit einander verknüpft. Also…. Was erwartet dich in diesem Beitrag? Zuerst möchte ich dir die Aussagenlogik hinter dem Und-Operator zeigen. Also wann sind Aussagen wahr und wann sind diese falsch. Dann […]

Die mathematischen Grundlagen des Dezimalsystems für Java Programmierer

Java Dezimalsystem Mathematik Programmierer

Bei der Java Programmierung benötigst du Kenntnisse über das Dezimalsystem. Allein schon für die technische Umsetzung beim Runden einer Zahl. Oder du möchtest den Kehrwert bzw. den Umkehrwert einer Zahl im Programm bestimmen lassen. Aber auch für das Herausfinden des Stellenwertes – also wieviel Stellen hat eine Zahl – benötigst du das Grundwissen des Dezimalsystems. […]

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 kannst du Java Konstanten bei der Programmierung nutzen

Java Konstanten – was kann man sich darunter vorstellen? Du kennst Konstanten in der Mathematik. Die Kreiszahl Pi ist so eine konstante Zahl. Diese Zahl ändert sich niemals. Sie beträgt immer rund 3,141592. In der Physik gelten die Lichtgeschwindigkeit, der Erdradius oder der absolute Nullpunkt als konstant. Selbst die Geschwindigkeit mit der sich die Erde […]

Java Objekte leben auf dem Heap

Java-Objekte-Heap

Java hat eine interne Speicherverwaltung. Eigentlich ist es nicht nur eine. Es sind mehrere.   Uns interessieren nur zwei. Methoden und lokale Variablen werden auf dem Stack verwaltet. Und die Speicherverwaltung für Java Objekte und den Instanzvariablen findet auf dem Heap statt.   Ja wieso braucht Java eigentlich zwei Speichersysteme?   Es ist ganz einfach. […]

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 […]

Das Java Leben ist einfacher mit For-Schleife

Java For Schleife Aufbau

In einem anderen Artikeln habe ich bereits über Schleifen in Java gesprochen. In diesem Artikel möchte ich dir eine ganz besondere Schleife vorstellen. Warum ist diese so toll? Sie hat einen integrierten Schleifenzähler. Die Schleife zählt also bei jedem Durchlauf automatisch mit. Aber dazu gleich mehr…. Lass uns einmal so eine For Schleife anlegen.

Der bedeutende Unterschied zwischen Klassenvariablen und Instanzvariablen

Java Klassenvariablen

Bei der Java Programmierung unterscheidet man drei Arten von Variablen. Als erste Gruppe sind die lokalen Variablen zu nennen. Auf diese gehe ich in einem separaten Artikel ein. Mich interessieren die zwei anderen Variablentypen. Zum einen existieren Klassenvariablen. Und dann sind da noch die Instanzvariablen. Wo liegt der Unterschied? Instanzvariablen stehen einem Objekt zur Verfügung. […]

Verwalte deine Java Klassen in packages

java klassen verwalten

Es macht durchaus Sinn deine Java Klassen in verschiedenen Paketen zu organisieren. Wieso? Es sprechen mehrere Gründe dafür: Du kannst doppelte Klassennamen verwenden Du kannst deinen Code oder deine Klassen inhaltlich trennen Du kannst Hierarchien abbilden. Und genau um diese Dinge geht es in diesem Beitrag