# Mein erstes Programm/Spiel



## Leon.tr3x (20. Mrz 2021)

Hallo zusammen,
Ich habe aktuell die Hausaufgabe in Informatik ein Programm bzw. Spiel zu schreiben welches Aufgaben zum kleinen 1*1 stellt.
Da ich etwas Langeweile hatte habe ich das Programm etwas erweitert. Da es mein erstes Programm ist gibt es mit Sicherheit einiges zu verbessern oder zu vereinfachen. Vielleicht hat ja jemand Lust und Zeit sich den Code mal anzuschauen und mir eventuell Tipps zu geben 

Hier der Code:


```
import java.io.*;       // Importiert die io Methoden, für die Eingabe.

import java.util.*;     // Importiert die until Methoden, für die Ausgabe bzw. erstellung zufälliger Zahlen.

/**

* Ein Programm um Aufgaben zum kleinem 1*1 zu berechnen.

*/

public class KleinesEinMalEins

{

    public void main() throws IOException

    {



        int [] ErgebnissSpeicher;              // Array welches die Ergebnisse Speichert wird definiert.

        ErgebnissSpeicher = new int [100000];



        int[] Mtspeicher;               // Array welches den Wert vom Multiplikant Speichert wird definiert.

        Mtspeicher = new int [100000];



        int [] Mdspeicher;              // Array welches den Wert vom Multiplikator Speichert wird definiert.

        Mdspeicher = new int [100000];



        String [] RoF;                 // Array welches speichert ob die Eingabe des Benutzer Richtig oder Falsch war.

        RoF = new String [100000];



        int [] BenutzerEingabe;        // Array welches die Eingabe des Benutzer speichert.

        BenutzerEingabe = new int [100000];



        int AufgabenZähler=1; // Zählervariable für die Ausgabe, der richtigen Ergebnisse.

        int Ergebniss;        // Ergebnis der Mal-Aufgabe.

        int grenze=1;         // Kontrolliert die Runden, wenn grenze=g ist gibt es eine neue Runde.

        int Rundenazahl=1;    // Einfacher Runden zähler.

        int Multiplikator;    // Kriegt später einen Zufälligen Wert zugewiesen.

        int Multiplikand;     // Kriegt später ebenfalls einen Zufälligen Wert zugewiesen.

        Random zufall = new Random(); // Die Variable "zufall" kann nun zufällige Werte anehmen.

        int Anzahl= ErgebnissSpeicher.length; // Greift die länge des Arrays ErgebnissSpeicher ab.

        java.util.Scanner input = new java.util.Scanner(System.in); // Die Eingabe durch einen Scanner wird ermöglicht.



        System.out.println ("Willkommen beim kleinem 1*1 Spiel, geben sie eine 1 ein um zu starten."); // Spielstart Ausgabe.

        System.out.println ("Mit der Eingabe der Zahl 0 beenden sie das Spiel.");



        int start;

        start = input.nextInt();  // Der Nutzer wird aufgefordert eine 1 einzugeben welche in der Variablen start gespeichert wird.



        if (start<1 || start>1)

        {  System.out.println ("Bitte geben sie die Zahl 1 ein um zu beginnen"); // Falsche Eingabe, Nutzer wird erneut aufgefordert 1 einzugeben.

        }



        if(start==1) // Wenn die Eingabe 1 ist, startet das Spiel.

        {

            for(int g=1;g==grenze;g++)

            {   int Score=0;          // Zählt den Score.

                for(int i=1;i<Anzahl;i++) // i = Aufgabe, heißt bei der 7.Aufgabe ist i=7.

                {



                    Ergebniss=0;

                    Multiplikator = zufall.nextInt(10)+1; // Der Multiplikator bekommt hier einen zufälligen Wert zwischen 1-10 zugewiesen.

                    Multiplikand = zufall.nextInt(10)+1;  // Der Multiplikand bekommt hier einen zufälligen Wert zwischen 1-10 zugewiesen.

                    Ergebniss=Multiplikator*Multiplikand; // Die Berechnung der Aufgabe erfolgt.

                    ErgebnissSpeicher[i]=Ergebniss;       // Hier wird das Ergebniss im Array eingetragen.

                    Mtspeicher[i]=Multiplikator;          // Hier wird der Multiplikator in den Array eingetragen.

                    Mdspeicher[i]=Multiplikand;           // Hier wird der Multiplikand in den Array eingetragen.



                    System.out.println("Löse folgende Aufgabe: ");           

                    System.out.println(Multiplikator+" * "+Multiplikand+ " ergibt: ");    // Ausgabe der Aufgabenstellung.



                    int EingabeBenutzer;

                    EingabeBenutzer = input.nextInt();                                    // Eingabe des Ergebniss erfolgt und wird in der Variable str gespeichert.

                    BenutzerEingabe[i]=EingabeBenutzer;                                   // Eingabe des Benutzers wird im Array gespeichert.

                    if(EingabeBenutzer==Ergebniss)

                    { 

                        System.out.println("Diese Aufgabe hast du richtig gelöst. Super!");  // Die Ausgabe, wenn das eingegebene Ergebniss richtig ist.

                        System.out.println();

                        RoF[i]="Richtig";

                        Score++; // Der Score zählt um einen Hoch, da das Ergebniss richtig war.

                    }



                    if(EingabeBenutzer>Ergebniss || EingabeBenutzer<Ergebniss )

                    { 

                        System.out.println("Diese Aufgabe hast du leider nicht richtig gelöst. Das richtige Ergebnis wäre "+ Ergebniss); // Die Ausgabe, wenn das eingegebene Ergebniss falsch ist.

                        System.out.println();

                        RoF[i]="Falsch";

                        Score--; // Der Score zählt um einen runter, da ein falsches Ergebniss eingegeben wurde.

                    }



                    if(EingabeBenutzer==0)

                    {

                        System.out.println();

                        System.out.println();

                        System.out.println("Das Programm wurde beendet! Es folgen die Ergebnisse.");   // Ausgabe, nachdem das Programm durch die Eingabe 0 beendet.

                        System.out.println();

                        for(int u=0;u<Anzahl;u++)

                        {

                            if(ErgebnissSpeicher[u]>0)

                            {

                                System.out.println("Das Ergebnis der " +AufgabenZähler+". Aufgabe ("+Mtspeicher[u]+"*"+Mdspeicher[u]+") lautet: " + ErgebnissSpeicher[u]+"."); // Die richtigen Ergebnisse werden ausgegeben.

                                System.out.println("Dein Ergebnis war "+BenutzerEingabe[u]+", es war also "+RoF[u]+".");

                                System.out.println();

                                AufgabenZähler++;

                            }

                        }

                        Score++;

                        System.out.println("Dein Score beträgt: "+ Score ); // Der Score wird ausgegeben.

                        System.out.println();

                        System.out.println("Wenn du erneut spielen möchtest, gebe eine 1 ein.");



                        int NeueRunde;

                        NeueRunde = input.nextInt();

                        if(NeueRunde==1)

                        {

                            grenze++;

                            Rundenazahl++;

                            System.out.println();

                            System.out.println("Willkomen zur "+Rundenazahl+". Runde !");

                            System.out.println();

                        }

                    }

                }

            } 

        }

    }

}
```


----------



## Robert Zenz (20. Mrz 2021)

Leon.tr3x hat gesagt.:


> ```
> import java.io.*;
> ```


Ich mag Wildcard-Imports nicht, da sie es um einiges erschweren zu erkennen woher eine Klasse kommt, inbesondere wenn man gerade keine IDE zu Hand hat (Code-Review auf Github/Gitlab zum Beispiel). Deine IDE sollte in der Lage sein die Imports automatisch zu verwalten, also du hast nicht mehr Aufwand damit. Desweiteren minimiert man dadurch Doppeldeutigkeit wenn man explizite Importe hat.



Leon.tr3x hat gesagt.:


> ```
> int [] ErgebnissSpeicher; // Array welches die Ergebnisse Speichert wird definiert.
> ErgebnissSpeicher = new int [100000];
> ```


Java ist nicht C (in Uralt-Variante) wo Deklaration und Zuweisung nicht auf der selben Zeile sein konnten.
Ergebnis schreibt man nur mit einem "s".

In Java ist es ueblich das Variablen lowerCamelCase sind.


Leon.tr3x hat gesagt.:


> ```
> int[] Mtspeicher;
> ```


Kuerze Namen nicht nur weil du kannst, es macht den Code schwerer zu lesen, verstehen und warten. Du sparst dir nichts in dem du die Namen abkuerzt.

Auch solltest du Variablen in dem engsten Scope definieren in dem sie verwendet werden. Wenn du zum Beispiel eine Variable in einer Schleife verwendest, und nur dort, sollte sie auch in der Schleife definiert sein. Performance-Thema zwecks vorher Variable definieren vs. immer neu definieren in der Schleife gibt es nicht in Java (ist gelogen, gibt es schon, aber wenn du auf so etwas achten musst bist du in einem so spezialisierten Feld dass du weiszt was du tust...oder dein projekt geht hops).


Leon.tr3x hat gesagt.:


> ```
> Random zufall = new Random(); // Die Variable "zufall" kann nun zufällige Werte anehmen.
> ```


Sei dir immer bewusst wie deine Zufallsquellen intialisiert werden, das kann zum Beispiel ein Problem sein wenn du mehrere erstellst. Bei Java wird in "Random" alles dafuer getan dass du auch bei mehrfachen Instanzen welche zur gleichen Zeit erstellt werden du andere Zahlen bekommst. In .NET war es zum Beispiel lange so dass der Default-Konstruktor von "Random" die aktuelle Systemzeit mit Sekundengenauigkeit als Seed verwendet hat, damit hatte man dann immer gleiche Zahlen wenn die "Random" Instanzen in der selben Sekunde erstellt wurden.


Leon.tr3x hat gesagt.:


> ```
> for(int g=1;g==grenze;g++)
> ```


Ich weisz, ich stehe so gut wie alleine da mit der Meinung, aber ich finde man darf einbuchstabige Variablennamen nur verwenden wenn es sich um Dimensionen handelt (x, y, z, vielleicht noch w). Bei Schleifen sollte man immer Namen waehlen welche passen, zum Beispiel "index", "counter" und so weiter. Demonstration? Schnell ohne zu spicken, was enthaelt "RoF"? Wofuer wird "u" verwendet?

Sehr gutes Beispiel dafuer sit dass du in Kommentaren stehen hast wofuer eine Variable verwendet wird. Das sollte aus dem Variablennamen hervorgehen.

Die Schleifenwahl hier ist etwas seltsam, eine "while(weiterspielen)" wo "weiterspielen" ein boolean ist waere vermutlich leichter zu verstehen als eine "for" in welcher die Bedingung geaendert wird.

Betreffend der gesamten Konstruktion. Wenn ich das richtig sehe ist es relativ unnoetig dass du alle Ergebnisse aund Aufgaben immer mit fuehrst, du willst dem Benutzer ja nur Fragen um Fragen stellen, und dann am End ein Ergebnis praesentieren. Wenn du jetzt nicht alle Aufgaben wieder anzeigen willst, ist es unnoetig hier diese groszen Arrays mitzuschleifen, du kannst dir ja einfach nur zwei "int"s halten, einen Zaehler wieviele Aufgaben bis jetzt beantwortet wurden, und einen wieviele davon richtig waren.

Auch solltest du probieren einzelne Teile in Funktionen auszulagern, waere eine gute Uebung.


----------



## mihe7 (20. Mrz 2021)

Das ist nicht ganz einfach, weil wir Deinen Stand nicht kennen. 

Grundsätzlich wäre es zu empfehlen, sich an die Benennungskonventionen von Java zu halten, d. h. Namen von Variablen, Methoden und Parametern werden in lowerCamelCase geschrieben, Namen von Typen (Klassen etc.) in UpperCamelCase. Auf Umlaute sollte man möglichst verzichten.

Jetzt kommt etwas, das ggf. Deiner Schule widerspricht: Kommentare dienen nicht dazu, den Code auf Deutsch zu übersetzen. Dafür haben wir den Code und wählen sprechende Bezeichner.

Beispiel:

```
int [] ErgebnissSpeicher;              // Array welches die Ergebnisse Speichert wird definiert.
```
Vom Tippfehler (Ergebnis, nicht Ergebniss) einmal abgesehen, steht im Kommentar rechts nichts anderes als eine Übersetzung des Codes links. Braucht man nicht. Dein Code erschlägt einen vor lauter Kommentaren.

Bzgl. der Wahl der Variablennamen: dass eine Variable oder gar ein Array ein Speicher ist, muss man nicht nochmal erwähnen. Wähle lieber vernfünftige Namen. Beispiel:

```
int[] Mtspeicher;               // Array welches den Wert vom Multiplikant Speichert wird definiert.
```
Hier hast Du einen Namen "Mtspeicher". Hier kürzt Du mit einer faslchen Abkürzung (Mt) weg, dass hier Multiplikanden (mit d) abgelegt werden, damit Du die völlig uninteressante Information, dass es sich um einen Speicher handelt, anfügen kannst.

Besser:

```
int[] multiplikanden;
        multiplikanden = new int[100000];
```

Das Splitten von Deklaration und Zuweisung ist in einigen Fällen gut, hier aber völlig überflüssig und sorgt nur dafür, dass der Code unnötig lang und schwerer zu lesen wird.

Besser:

```
int[] ergebnisse = new int[100000];
        int[] multiplikanden = new int[100000];
        // usw.
```
 
Als nächtes hätten wir Magic Numbers: die 100000 ist eine Zahl, die eine Bedeutung hat, die im Code nicht sofort ersichtlich ist. Sie steht für die maximale Anzahl an (spielbaren) Aufgaben, die Du für jedes Array wiederholst. Wenn Du dafür eine Konstante einführst, brauchst Du nur noch diese zu ändern. Tatsächlich hast Du so etwas ähnliches schon im Code, nur andersrum:

```
int Anzahl= ErgebnissSpeicher.length; // Greift die länge des Arrays ErgebnissSpeicher ab.
```
Besser:

```
private static final int MAX_AUFGABEN = 100_000; 

// und in main():
int[] ergebnisse = new int[MAX_AUFGABEN];
...
```
Auf die Variable Anzahl kannst Du dann verzichten. Wie Du hier übrigens siehst, erlaubt Java auch die Gruppierung von Zahlen mit Unterstrichen.

Das hier:

```
if (start<1 || start>1) {  
            System.out.println ("Bitte geben sie die Zahl 1 ein um zu beginnen"); // Falsche Eingabe, Nutzer wird erneut aufgefordert 1 einzugeben.          
        }

        if(start==1) { // Wenn die Eingabe 1 ist, startet das Spiel.
```
wäre identisch zu

```
if (start<1 || start>1) {  
            System.out.println ("Bitte geben sie die Zahl 1 ein um zu beginnen"); // Falsche Eingabe, Nutzer wird erneut aufgefordert 1 einzugeben.          
        } else {
```
Allerdings ist es so, dass das Programm endet, wenn jemand keine 1 eingibt. In dem Fall würde ich dort tatsächlich ein return einfügen. Dann kannst Du auf das else verzichten und sparst Dir eine Einrückung.

```
if (start<1 || start>1) {  
            System.out.println ("Bitte geben sie die Zahl 1 ein um zu beginnen"); // Falsche Eingabe, Nutzer wird erneut aufgefordert 1 einzugeben.          
            return;
        }
        for(int g=1;g==grenze;g++) {
```

Dabei will ich es für den Moment belassen. Die Logik Deines Programms ist auch nicht ganz stimmig. Das g wird erst nach 100.000 Eingaben erhöht. In der Zeit kann der Benutzer ja zig Runden gestartet haben, so dass das Programm beendet wird. Auch wird die 0 immer als Versuch ausgewertet. Vielleicht solltest Du hier die Reihenfolge der Prüfungen überdenken.


----------



## Blender3D (21. Mrz 2021)

Leon.tr3x hat gesagt.:


> Vielleicht hat ja jemand Lust und Zeit sich den Code mal anzuschauen und mir eventuell Tipps zu geben


Abgesehen von den *guten Tipps* von  *@mihe7* *@kneitzel*   Hier ein Beispiel wie man das Ganze strukturierter gestalten kann.

Das Programm benutzt 2 Klassen. Die Klasse _*Multiplication *_bildete eine Aufgabe ab. Dadurch ist das Hauptprogramm, viel einfacher zu realisieren.
Im Hauptprogramm, der Klasse _*TimesTableTest*_, verwende ich außerdem Funktionen, um die Lesbarkeit noch mehr zu verbessern.
Das sind  2 Konzepte ( Objektorientierung und Strukturierte Programmierung ) .
*Teste den Code und versuche ihn zu verstehen.* Vor allem aber vergleiche ihn mit deinem Code.

*Fragen dazu kannst du gerne hier stellen.   *

[CODE lang="java" title="TimesTableTest" highlight="8-18,22-25,29-40,48-58"]import java.util.Scanner;

public class TimesTableTest {
    private final static int MAX_FACTOR = 9;
    private static Scanner input = new Scanner(System.in);

    public static void main(String[] args) {
        printSeperator();
        System.out.println("\tKleines Einmaleins Test");
        printSeperator();
        int num = inputInt("Wieviele Aufgaben?");
        printSeperator();
        Multiplication[] test = createTest(num);
        for (int i = 0; i < test.length; i++) {
            int answer = inputInt((i + 1) + ".\t" + test_);
            test.setAnswer(answer);
        }
        printTest(test);
    }

    private static Multiplication[] createTest(int num) {
        Multiplication[] test = new Multiplication[num];
        for (int i = 0; i < test.length; i++)
            test = new Multiplication(MAX_FACTOR);
        return test;
    }

    private static int inputInt(String label) {
        int value = 0;
        boolean ok = false;
        do {
            System.out.print(label + " > ");
            try {
                value = Integer.parseInt(input.next());
                ok = true;
            } catch (Exception e) {
                System.out.println("Bitte nur ganze Zahlen eingeben!");
            }
        } while (!ok);
        return value;
    }

    public static void printSeperator() {
        System.out.println("---------------------------------------");
    }

    private static void printTest(Multiplication[] test) {
        int correct = 0;
        printSeperator();
        for (int i = 0; i < test.length; i++) {
            System.out.println((i + 1) + ".\t" + test);
            if (test.isCorrect())
                correct++;
        }
        printSeperator();
        System.out.println("\tRichtig: [" + correct + "]\tFalsch [" + (test.length - correct) + "]");
        printSeperator();
    }
}
[/CODE]
[CODE lang="java" title="Multiplication"]import java.util.Random;

public class Multiplication {
    private static Random rnd = new Random(System.currentTimeMillis());
    public final int a;
    public final int b;
    private Integer answer = null;

    /**
     * Creates random multiplication.
     *
     * @param maxFactor
     *            Maximum allowed factor. Minimum factor is 1.
     */
    public Multiplication(int maxFactor) {
        a = rnd.nextInt(maxFactor) + 1;
        b = rnd.nextInt(maxFactor) + 1;
    }

    public boolean isAnswerSet() {
        return answer != null;
    }

    public boolean isCorrect() {
        return answer == result();
    }

    public int result() {
        return a * b;
    }

    public void setAnswer(int answer) {
        if (isAnswerSet())
            return;
        this.answer = answer;
    }

    @Override
    public String toString() {
        String result = answer == null ? "" : answer + "\t(" + (result() == answer) + ")";
        return a + " x " + b + " = " + result;
    }
}
[/CODE]_


----------



## Leon.tr3x (21. Mrz 2021)

Erstmal vielen Dank an euch drei für das Feedback.

Habe einige Punkte übernommen bzw. verändert wie z.b die ganzen Kommentare weggelassen, die Variablennamen passender gemacht und dem Java Standard angepasst, die Deklaration der Arrays überarbeitet und die If-Bedingung welche das eigentliche Spiel startet mit einer Else Verzweigung versehen. Generell habe ich das Spiel noch etwas erweitert, sodass es jetzt verschiedene Runden mit verschiedenen Schwierigkeiten gibt.

Einige Punkte von euch wie z.b die konkreten Importe oder das Auslagern der spielbaren Aufgaben Begrenzung habe ich erstmal weggelassen, da mir dazu noch das Verständnis fehlt oder es mir von vorne rein so vorgegeben wurde (Importe z.b).

Den Code des richtigen Spieles in eine Do-while Schleife zu setzen hatte ich am Anfang, erfolglos, versucht, sodass ich mich für eine, mir mehr vertraute, For-Schleife entschieden habe.

Die Konstruktion von @Blender3D hab ich mir mal angeschaut, muss aber ehrlich gesagt sagen, dass es mir noch viel zu advanced ist, trotzdem natürlich Danke 

Das einzige Problem, das aktuell noch besteht ist, dass bei der Ausgabe der Runden bezogene Ergebnisse auch das Ergebnis der Aufgabe welche man mit 0 beendet hat angezeigt wird. Es wird zwar nicht mit in den Score berechnet, sieht aber natürlich nicht ganz so gut aus. Vielleicht hat da noch jemand eine Lösung zu, habe jetzt schon alles, was mir eingefallen ist probiert.

Hier nochmal der aktualisierte Code:

```
import java.io.*;     
import java.util.*;     
/**
 * Ein Programm in welchem man Aufgaben zu Multiplikation üben kann.
 */
public class MatheSpiel
{   
    public void Main() throws IOException
    {
        int [] ergebnisse = new int [100];
        int[] multiplikanden = new int [100];
        int [] multiplikatoren = new int [100];
        String [] richtigfalsch = new String [100];
        int [] benutzereingabe = new int [100];   
      
        Random zufall = new Random();
        int Anzahl= ergebnisse.length;
        java.util.Scanner input = new java.util.Scanner(System.in);

        
        
        System.out.println ("Willkommen beim Mathe-Spiel.");                                                                         
        System.out.println ("Ihre Aufgabe wird es sein Mal Aufgaben zulösen.");
        System.out.println();
        System.out.println ("In Level 1 (Easy) werden die Aufgaben von 1*1 bis maximal bis 10*10 gehen.");
        System.out.println ("In Level 2 (Medium) werden die Aufgaben von 11*11 bis maximal 20*20.");
        System.out.println ("In Level 3 (Hard) werden die Aufgaben von 21*21 bis maximal 30*30");
        System.out.println();
        System.out.println ("Geben sie nun die Zahl 1 ein um mit Level 1 zu beginnen.");
        System.out.println ("Mit der Eingabe der Zahl 0 können sie das Level jederzeit beenden und ihre ergebnise einsehen.");

        int start;
        start = input.nextInt(); 
        
        int multiplikator=0;   
        int multiplikand=0;
        int ergebnis=0;   
        int runde=1;       
        int rundenazahl=1;   
        int score=0;
        int aufgabenzähler=1;
        
        if (start<1 || start>1)
        {  System.out.println ("Das Spiel wurde aufgrund einer falschen Eingabe beendet.");
        }
        else
        {
            for(int rundenzähler=1;rundenzähler==runde;rundenzähler++)
            {         
                for(int aufgabendurchgänge=1;aufgabendurchgänge<Anzahl;aufgabendurchgänge++)
                {
                    
                    if(runde==1)   
                    {
                        multiplikator = zufall.nextInt(10)+1;
                        multiplikand = zufall.nextInt(10)+1; 
                    }

                    if(runde==2) 
                    {
                        multiplikator = zufall.nextInt(20)+10;
                        multiplikand = zufall.nextInt(20)+10; 
                    }

                    if(runde==3)
                    {
                        multiplikator = zufall.nextInt(30)+20;
                        multiplikand = zufall.nextInt(30)+20;
                    }

                    ergebnis=multiplikator*multiplikand;

                    ergebnisse[aufgabendurchgänge]=ergebnis;     
                    multiplikanden[aufgabendurchgänge]=multiplikator;         
                    multiplikatoren[aufgabendurchgänge]=multiplikand;         
                    
                    System.out.println();
                    if(runde==1 && aufgabendurchgänge==1)
                    {
                        System.out.println("Willkomen zur 1. Runde !");   
                        System.out.println();
                    }
                    System.out.println("Lösen sie folgende Aufgabe: ");             
                    System.out.println(multiplikator+" * "+multiplikand+ " ergibt: ");   

                    int eingabebenutzer;
                    eingabebenutzer = input.nextInt();                                   
                    benutzereingabe[aufgabendurchgänge]=eingabebenutzer;                               

                    if(eingabebenutzer==ergebnis)
                    {   
                        System.out.println("Diese Aufgabe haben sie richtig gelöst. Super!");
                        System.out.println();
                        richtigfalsch[aufgabendurchgänge]="Richtig";
                        score++;
                    }

                    if(eingabebenutzer>ergebnis || eingabebenutzer<ergebnis )
                    {   
                        System.out.println("Diese Aufgabe haben sie leider nicht richtig gelöst. Das richtige ergebnis wäre "+ ergebnis); // Die Ausgabe, wenn das eingegebene ergebniss falsch ist.
                        System.out.println();
                        richtigfalsch[aufgabendurchgänge]="Falsch";
                        score--;
                    }

                    if(eingabebenutzer==0)
                    {
                        System.out.println();
                        System.out.println();
                        System.out.println("Das Level wurde beendet! Es folgen die ergebnisse.");   
                        System.out.println();
                        for(int aufgabenabfrage=0;aufgabenabfrage<Anzahl;aufgabenabfrage++)
                        {
                            if(ergebnisse[aufgabenabfrage]>0)
                            {
                                System.out.println("Das ergebnis der " +aufgabenzähler+". Aufgabe von Level "+runde+" ("+multiplikanden[aufgabenabfrage]+"*"+multiplikatoren[aufgabenabfrage]+") lautet: " + ergebnisse[aufgabenabfrage]+".");
                                System.out.println("Ihr ergebnis war "+benutzereingabe[aufgabenabfrage]+", es war also "+richtigfalsch[aufgabenabfrage]+".");
                                System.out.println();
                                aufgabenzähler++;
                            }
                        }
                        score++;
                        System.out.println("Dein score beträgt: "+ score );
                        System.out.println();

                        if(runde==3)   
                        {
                            System.out.println("Sie haben das letzte Level absolviert.");
                            System.out.println();
                            System.out.println("Wenn sie wieder von Level 1 anfangen möchten geben sie eine 1 ein.");
                            System.out.println("Wenn sie das Spiel beenden wollen, geben sie eine 0 ein.");
                        }
                        if(runde==1 || runde==2)
                        {
                            System.out.println("Wenn sie zum nächsten Level gehen möchten, geben sie eine 1 ein.");
                            System.out.println("Wenn sie das Spiel beenden wollen, geben sie eine 0 ein.");
                        }
                        
                        int neuerunde;
                        neuerunde = input.nextInt();
                        
                        if(neuerunde==0)
                        {
                            System.exit(0);
                        }
                        if(neuerunde==1)
                        {
                            if(runde==3) 
                            {
                                rundenzähler=0;runde=0;rundenazahl=0;
                            }
                            runde++;
                            rundenazahl++;
                            aufgabenzähler=1;
                            score=0; 
                            for(int aufgabereset=1;aufgabereset<Anzahl;aufgabereset++)
                                {
                                  multiplikanden[aufgabereset]=0;
                                  multiplikatoren[aufgabereset]=0;
                                  ergebnisse[aufgabereset]=0;
                                }
                            System.out.println();
                            System.out.println("Willkomen zur "+rundenazahl+". Runde !");
                            System.out.println();
                            if(runde==2)
                            {
                                System.out.println("Die Aufgaben werden schwieriger, ihnen werden nun Aufgaben bis maximal 20*20 gestellt.");
                            }
                            if(runde==3)
                            {
                                System.out.println("Die Aufgaben werden erneut schwieriger, ihnen werden nun Aufgaben bis maximal 30*30 gestellt.");
                            }
                            System.out.println();
                        }
                        }
                    }
                }   
        }
     }
}
```


----------



## mihe7 (21. Mrz 2021)

Gut, wir nähern uns langsam aber sicher brauchbarem Code an. Nur bei den Kommentaren musst Du aufpassen: in der Schule kann das durchaus sein, dass es gewünscht ist, den Code mehr oder weniger ausführlich zu kommentieren. Klär das am besten mit Deinem Lehrer, ggf. musst Du am Ende noch ein paar Kommentare einfügen



Leon.tr3x hat gesagt.:


> das Auslagern der spielbaren Aufgaben Begrenzung


OK, dann dreh wenigstens die Anzahl um (übrigens: anzahl, nicht Anzahl):

Statt 

```
int [] ergebnisse = new int [100];
        int[] multiplikanden = new int [100];
        int [] multiplikatoren = new int [100];
        String [] richtigfalsch = new String [100];
        int [] benutzereingabe = new int [100];   
      
        Random zufall = new Random();
        int Anzahl= ergebnisse.length;
```
hast Du dann einfach:

```
int anzahl = 10;
        int [] ergebnisse = new int [anzahl];
        int[] multiplikanden = new int [anzahl];
        int [] multiplikatoren = new int [anzahl];
        String [] richtigfalsch = new String [anzahl];
        int [] benutzereingabe = new int [anzahl];   
      
        Random zufall = new Random();
```
Willst Du die Anzahl ändern, brauchst Du das nur noch in einer Zeile zu machen.

In Zeile 18 kannst Du "java.util." weglassen, dafür hast Du ja den Import.

Wenn Du Dir die Zeilen 53 bis 69 ansiehst, dann stellst Du fest, dass das nichts anderes als

```
multiplikator = zufall.nextInt(runde*10) + (runde-1)*10;
multiplikand = zufall.nextInt(runde*10) + (runde-1)*10;
```
ist.



Leon.tr3x hat gesagt.:


> Vielleicht hat da noch jemand eine Lösung zu, habe jetzt schon alles, was mir eingefallen ist probiert.


Vielleicht die Eingabe zuerst auf 0 prüfen und dann mit else if arbeiten?


----------



## Leon.tr3x (21. Mrz 2021)

Also, dein ersten Tipp haben ich jetzt umgesetzt.
In den Zeile 53-69 hatte ich zuvor sogar genau das, was du mir empfohlen hast, jedoch können der Multiplikand und der Multiplikator dann den Wert 0 annehmen was natürlich keinen Sinn macht, da 0 die Abbruch-Bedingung ist. Natürlich kann ich das dann theoretisch wieder abfangen aber dann habe ich ja gleich viel Code wie bei meiner bisherigen Lösung oder nicht ?

Hast du bei deinem letzteren Vorschlag eventuell ein Beispiel  ?
Egal wie oder wo ich versuche die Eingabe abzufangen, am Ende wird die Aufgabe ja als Ergebnis gezählt, da ja alle Werte (Multiplikand, Multiplikator und Ergebnis) bereits in ihren Arrays eingetragen sind. Die Abfrage müsste ja dementsprechend vor dem eintragen der Werte ins Array geschehen, was ja wiederum kein Sinn macht, da der Nutzer die Aufgabe ja erst durch genau diese Arrays erhält.


----------



## mihe7 (21. Mrz 2021)

Leon.tr3x hat gesagt.:


> In den Zeile 53-69 hatte ich zuvor sogar genau das, was du mir empfohlen hast, jedoch können der Multiplikand und der Multiplikator dann den Wert 0 annehmen was natürlich keinen Sinn macht, da 0 die Abbruch-Bedingung ist. Natürlich kann ich das dann theoretisch wieder abfangen aber dann habe ich ja gleich viel Code wie bei meiner bisherigen Lösung oder nicht ?


Sehr gut aufgepasst, das hatte ich übersehen. 

```
int untergrenze = (runde-1)*10;
if (untergrenze == 0) {
    untergrenze = 1;
}
// oder kurz z. B.
// int untergrenze = Math.max((runde-1)*10, 1);
multiplikator = zufall.nextInt(runde*10) + untergrenze;
multiplikand = zufall.nextInt(runde*10) + untergrenze;
```

Was die Menge des Codes betrifft: die ist nicht unbedingt ausschlaggebend. Wichtig ist, dass der Code lesbar und möglichst allgemein gehalten ist. Dein Code funktioniert nur für drei Runden, der Code oben für beliebig viele.



Leon.tr3x hat gesagt.:


> da ja alle Werte (Multiplikand, Multiplikator und Ergebnis) bereits in ihren Arrays eingetragen sind. Die Abfrage müsste ja dementsprechend vor dem eintragen der Werte ins Array geschehen, was ja wiederum kein Sinn macht, da der Nutzer die Aufgabe ja erst durch genau diese Arrays erhält.


Im Moment prüfst Du in der for-Schleife, ob das jeweilige Ergebnis größer als 0 ist. Das ist doch immer der Fall, Du willst an der Stelle eigentlich prüfen, ob die jeweilige Benutzereingabe größer als 0 war... Wir bauen das später ggf. alles noch etwas um, im Moment wollen wir aber erstmal die Bugs beheben.


----------



## Leon.tr3x (21. Mrz 2021)

Zum letzteren: 
Wenn wir von der gleichen Abfrage ab Zeile 114 sprechen, dann kann die Eingabe des Benutzer doch gar nicht größer als 0 sein, da man ja erst in die Bedingung reingeht, wenn der Benutzer die 0 eingibt. Oder hab ich da was falsch verstanden?


----------



## mihe7 (21. Mrz 2021)

In Zeile 88 speicherst Du die Benutzereingabe im Array ab und in der Schleife gibst Du nur die Zeilen aus, deren Benutzereingabe > 0 war (einfach Array benutzereingabe verwenden).


----------



## Leon.tr3x (22. Mrz 2021)

Oh dankeschön, das hatte ich komplett übersehen.


----------

