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

Lassen wir Java rechnen – Die Rechenoperationen für Variablen

Java rechnen

Ich liebe Mathe. In der Biographie „Der Mann, der die Zahlen liebte“, stellt Paul Hoffmann das Mathematikgenie Paul Erdös vor. Erdös war eines der größten Genies des 20 Jahrhunderts. Er arbeitete mit zahlreichen Wissenschaftlern zusammen und verfasste durchschnittlich mehr Publikationen im Jahr, als andere Mathematiker im ganzen Leben. Da Erdös sich mit sehr vielen Theoremen […]

Java Übung 21 – Bestimme die Anzahl der Tage

Java Übung Tage

In dieser Java Übung möchte ich, dass du eine Methode schreibst, welche zwei Zahlen entgegennimmt. Und zwar soll die erste Zahl das Jahr sein. Die zweite Zahl soll eine Monatsangabe (1-12) repräsentieren. Was soll die Methode dann machen? Die Methode soll dir die Anzahl der Tage des jeweiligen Monats zurückgeben. Achte auf Schaltjahre.

Den Java Vererbungsbaum nach dem Ist-Es-Prinzip richtig entwerfen

Java Vererbungsbaum

Vererbungsbaum in Java – klingt erstmal komisch. Dennoch wird dies so bezeichnet. Gemeint sind damit – die einzelnen Hierarchiestufen oder Vererbungsebenen – von der Superklasse bis runter zu den Kindklassen. Wie sieht das nun konkret aus? Vererbung bedeutet: Du definierst einen allgemeinen Typen – zB. Möbel Und dann implementierst du eine Unterklasse, welche die Oberklasse […]

So kannst du zweidimensionale Java Arrays anlegen und nutzen

Java Arrays zweidimensional

Eines der bedeutendsten Instrumente in der Mathematik ist das Koordinatensystem. Die gedankliche Grundlage dieses Werkzeuges lieferte der französische Naturwissenschaftler und Philosoph Rene Descartes. Man muss sich einmal verdeutlichen, was dies für die damalige Zeit bedeutete. Bisher wurden mathematische Probleme lediglich durch Berechnungen gelöst. Denke an geometrische Figuren, wie Dreiecke und Vierecke. Der Umfang wurde lediglich […]

So nutzt du Methoden aus der Java String Klasse

Java Strings Methoden

In einen der letzten Beiträge haben wir darüber gesprochen, dass Java Strings – Objekte sind. Dass Strings in allen Programmen äußerst häufig vorkommen Und dass sich deshalb Referenzvariablen String-Objekte im String Pool teilen. Das Konzept hinter dem String-Pool ist die Teilung der Ressourcen. Und das bedeutet: Weniger Objekte – mehr Speicher Mehr Speicher – bessere […]

Java Konsolenausgaben mit formatierten Zahlen

Java Konsolenausgaben Zahlen

Java Konsolenausgaben erzeugst du mit der System.out.println()-Anweisung. Dies ist relativ einfach. Aber es ist mitunter nicht ganz praktisch. Und zwar immer dann, wenn Zahlen im Spiel sind. Die Zahlen welche dann auf deiner Java Konsole erscheinen, sind unformatiert. Sie haben zu viele Kommastellen. Oder für eine bessere Darstellung benötigst du den Tausenderpunkt. Vielleicht möchtest du […]

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

Heap & Stack – Die Speicherverwaltung in Java

Java Speicher

Java nutzt eine interne Speicherverwaltung. Eigentlich sind es mehrere. Uns interessieren lediglich zwei. Da das Thema Speicherverwaltung recht umfangreich ist, habe ich dir im Folgenden einmal die wichtigsten Artikel zusammengestellt. Die zwei Speichersysteme von Java Java Methoden werden auf dem Stack gestapelt. Der Speicher auf dem Java Methoden zu Hause sind, nennt sich Stack Speicher. […]