Häufigkeit von Zahlen ermitteln

[Hallo1234]

Hallo,
hier soll die Häufigkeit von Zufallszahlen im Bereich von 1 bis 6 ermittelt werden.
Ganz unten findet ihr meinen Ansatz dazu.

import java.util.Scanner;
public class Start {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        boolean quit = true;
        while(quit == true) {
        System.out.println("Wie viele Runden möchten Sie würfeln?: ");
        int runden = s.nextInt();
        
        
        if(runden < 3) {
            System.out.println("Sie müssen mindestens 3 Runden würfeln!");
            System.out.println("Bitte wiederholen Sie die eingabe.");
            quit = true;
        }else if(runden > 20) {
            System.out.println("Sie dürfen nicht mehr als 20 Runden würfeln!");
            System.out.println("Bitte wiederholen Sie die eingabe.");
            quit = true;
        }else if(runden >= 3 && runden <=20) {
            quit = false;
        }
        
        Wuerfel wuerfel = new Wuerfel(1,true);
        
        for(int i=1; i<=runden; i++) {
            System.out.print("Ergebnis aus Runde "+i+": ");
            wuerfel.wuerfeln();
        }
        System.out.println();
        haeufigkeitDerWuerfe();
        }
    }
    
    public static int[] haeufigkeitDerWuerfe() {
        int[] moeglicheZahlen = {1,2,3,4,5,6};
        
        return moeglicheZahlen;
    }

}

Das hier ist die Klasse, aus der die Zufallszahl kommt.

import java.util.Scanner;
public class Wuerfel {
    
    //Attribute (Eigenschaften)
    private int wert;
    private boolean gueltig;
    
    //Konstruktor
    public Wuerfel(int wert, boolean gueltig) {
        this.wert = wert;
        this.gueltig = gueltig;
    }
    
    //Methoden (Fähigkeiten)
    public int wuerfeln() {
        int zahl = (int)((Math.random()) * 6 + 1);
        System.out.println(zahl);
        return zahl;
    }

Wie schaffe ich es, die Häufigkeit zu ermitteln?
Vielen Dank

 

[fhoffmann]

Deine Klasse Wuerfel hat eine Methode wuerfeln, die einen int zurückgibt. Diesen Rückgabewert musst du dir zunächst einmal beim Aufruf der Methode merken. (Das System.out.println(zahl); in wuerfeln würde ich dagegen weglassen.)

 

[Hallo1234]

Danke für den Tipp, aber wie soll ich die Variable zahl in die Methode haeufigkeitDerWuerfe() überführen?

 

[fhoffmann]

Du erzeugst ein Array mit den Häufigkeiten (am Anfang mit 0 initialisiert).
Jedesmal, wenn eine Zahl gewürfelt wird, zählst du den passenden Eintrag um eins hoch.

Aber beachte erst einmal meinen ersten Tipp.

 

[Hallo1234]

import java.util.Scanner;
public class Start {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        boolean quit = true;
        while(quit == true) {
            System.out.println("Wie viele Runden möchten Sie würfeln?: ");
            int runden = s.nextInt();


            if(runden < 3) {
                System.out.println("Sie müssen mindestens 3 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden > 20) {
                System.out.println("Sie dürfen nicht mehr als 20 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden >= 3 && runden <=20) {
                quit = false;
            }

            Wuerfel wuerfel = new Wuerfel(1,true);

            int[] zufallsZahlen = new int[1];
            for(int i=1; i<=runden; i++) {
                System.out.print("Ergebnis aus Runde "+i+": ");

                for(int j=0; j<zufallsZahlen.length; j++) {
                    wuerfel.wuerfeln();
                    int[] moeglicheZahlen = haeufigkeitDerWuerfe(zufallsZahlen, j);
                }
            }
        }
    }

    public static int[] haeufigkeitDerWuerfe(int[] zufallsZahlen, int durchlaeufe) {
        int[] moeglicheZahlen = {1,2,3,4,5,6};
        for(int i=0; i<moeglicheZahlen.length; i++) {
            if(zufallsZahlen[durchlaeufe] == moeglicheZahlen[i]) {
                System.out.println("Die Häufigkeit von "+moeglicheZahlen+" ist: "+i );
            }
        }

        return moeglicheZahlen;
    }

}

So habe ich die Main umgeschrieben. Es wird mir jedoch nichts ausgegeben, außer die Würfe an sich. Stimmt es denn von der Logik her?
Vielen Dank für die Tipps : )

 

[fhoffmann]

wuerfel.wuerfeln();

Du hast meinen ersten Tipp immer noch nicht berücksichtigt: Du musst den Rückgabewert erst einmal in einer lokalen Variablen speichern!
Dann sehen wir weiter.

 

[Hallo1234]

An dieser Stelle fehlt mir dann das Know-how. Wie speichere ich den Rückgabewert aus einer anderen Klasse in wuerfel.wuerfeln(); ?

 

[fhoffmann]

An dieser Stelle fehlt mir dann das Know-how. Wie speichere ich den Rückgabewert aus einer anderen Klasse in wuerfel.wuerfeln(); ?

Das solltest du aber gelernt haben:

int gewuerfelt = wuerfel.wuerfeln();

 

[Hallo1234]

import java.util.Scanner;
public class Start {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        boolean quit = true;
        while(quit == true) {
            System.out.println("Wie viele Runden möchten Sie würfeln?: ");
            int runden = s.nextInt();


            if(runden < 3) {
                System.out.println("Sie müssen mindestens 3 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden > 20) {
                System.out.println("Sie dürfen nicht mehr als 20 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden >= 3 && runden <=20) {
                quit = false;
            }

            Wuerfel wuerfel = new Wuerfel(1,true);

            int[] zufallsZahlen = new int[1];
            for(int i=1; i<=runden; i++) {
                System.out.print("Ergebnis aus Runde "+i+": ");

                for(int j=0; j<zufallsZahlen.length; j++) {
                    int gewuerfelt = wuerfel.wuerfeln(); //Neu!
                    int[] moeglicheZahlen = haeufigkeitDerWuerfe(zufallsZahlen, j);
                }
            }
        }
    }

    public static int[] haeufigkeitDerWuerfe(int[] zufallsZahlen, int durchlaeufe) {
        int[] moeglicheZahlen = {1,2,3,4,5,6};
        for(int i=0; i<moeglicheZahlen.length; i++) {
            if(zufallsZahlen[durchlaeufe] == moeglicheZahlen[i]) {
                System.out.println("Die Häufigkeit von "+moeglicheZahlen+" ist: "+i );
            }
        }

        return moeglicheZahlen;
    }

}

Dann habe ich etwas falsch verstanden. Aber die Zeile ist jetzt hinzugefügt.

 

[fhoffmann]

Das Wort "static" sollte in deinem Code nur vor der main-Funktion vorkommen.
Und deine main-Funktion macht viel zu viel.
Eine typische main-Funktion sieht so aus:

public class MeineKlasse {
  public static void main (String args) {
    MeineKlasse meineKlasse = new MeineKlasse();
    meineKlasse.tuWas();
  }
  public void tuWas() {
     // hier steht der Code, der vorher in der main stand
  }
}

Und die Abfrage, wieviele Runden gespielt werden sollen, würde ich auch in eine eigene Funktion auslagern:
Am besten schreibst du den Code als nächsten Schritt um zu:

import java.util.Scanner;

public class Start {
    public static void main(String[] args) {
        Start start = new Start();
        start.anzahlWuerfe();
    }

    public void anzahlWuerfe() {
        int runden = anzahlRundenAbfragen();
        System.out.println("Es werden " + runden + " Runden gewürfelt");
/*
     weiterer Code
*/
    }

    int anzahlRundenAbfragen() {
        int runden = 0;
        Scanner s = new Scanner(System.in);
        boolean quit = true;
        while(quit == true) {
            System.out.println("Wie viele Runden möchten Sie würfeln?: ");
            runden = s.nextInt();
            if(runden < 3) {
                System.out.println("Sie müssen mindestens 3 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden > 20) {
                System.out.println("Sie dürfen nicht mehr als 20 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden >= 3 && runden <=20) {
                quit = false;
            }
        }
        return runden;
    }

}

 

[Hallo1234]

Ich habe es jetzt so umgeschrieben:

import java.util.Scanner;
public class Start {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        
        boolean quit = true;
        while(quit == true) {
            System.out.println("Wie viele Runden möchten Sie würfeln?: ");
            int runden = s.nextInt();

            if(runden < 3) {
                System.out.println("Sie müssen mindestens 3 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden > 20) {
                System.out.println("Sie dürfen nicht mehr als 20 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden >= 3 && runden <=20) {
                quit = false;
            }
            zufallsZahlen(runden);
        }
    }
        public static void zufallsZahlen(int runden) {
            Wuerfel wuerfel = new Wuerfel(1,true);
            int[] zufallsZahlen = new int[1];
            for(int i=1; i<=runden; i++) {
                System.out.print("Ergebnis aus Runde "+i+": ");

                for(int j=0; j<zufallsZahlen.length; j++) {
                    int gewuerfelt = wuerfel.wuerfeln();
                    int[] moeglicheZahlen = haeufigkeitDerWuerfe(zufallsZahlen, j);
                }
            }
        }
    public static int[] haeufigkeitDerWuerfe(int[] zufallsZahlen, int durchlaeufe) {
        int[] moeglicheZahlen = {1,2,3,4,5,6};
        for(int i=0; i<moeglicheZahlen.length; i++) {
            if(zufallsZahlen[durchlaeufe] == moeglicheZahlen[i]) {
                System.out.println("Die Häufigkeit von "+moeglicheZahlen+" ist: "+i );
            }
        }
        return moeglicheZahlen;
    }
}

Das entspricht nicht ganz deinem Vorschlag, denn in der Aufgabenstellung heißt es, dass die Klasse Start eben diese Funktionen übernehmen soll. Das mit static habe ich versucht zu ändern, jedoch erscheint dann eine Fehlermeldung beim Methodenaufruf. Aber woran liegt es, dass die Häufigkeit nicht ausgegeben wird? Etwa an dem static?

 

[fhoffmann]

Solange du noch "static" benutzt, ist dein Code nicht lesbar. Das hat auch nichts mit der "Aufgabenstellung" zu tun.
Erst wenn dieses blödsinnige "static" los wirst, ist die Aufgabe lösbar.

int gewuerfelt = wuerfel.wuerfeln();

Du machst ja nichts mit dem Ergebnis - was soll das ?

 

[Hallo1234]

Als kleines Update, aber es gibt noch einige Fehler:

import java.util.Scanner;
public class Start {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        Start start = new Start();
        boolean quit = true;
        while(quit == true) {
            System.out.println("Wie viele Runden möchten Sie würfeln?: ");
            int runden = s.nextInt();

            if(runden < 3) {
                System.out.println("Sie müssen mindestens 3 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden > 20) {
                System.out.println("Sie dürfen nicht mehr als 20 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden >= 3 && runden <=20) {
                quit = false;
            }
            start.zufallsZahlen(runden);
        }
    }
        public void zufallsZahlen(int runden) {
            Wuerfel wuerfel = new Wuerfel(1,true);
            
            int[] zufallsZahlen = new int[1];
            for(int i=1; i<=runden; i++) {
                System.out.print("Ergebnis aus Runde "+i+": ");
                int gewuerfelt = wuerfel.wuerfeln();
                haeufigkeitDerWuerfe(gewuerfelt);
            }
            
        }
    public int[] haeufigkeitDerWuerfe(int gewuerfelt) {
        int[] moeglicheZahlen = {1,2,3,4,5,6};
        for(int i=0; i<moeglicheZahlen.length; i++) {
            if(moeglicheZahlen[i]==gewuerfelt) {
                System.out.println("Die Häufigkeit von "+moeglicheZahlen[i]+" ist: "+i );
        }
    }
        return moeglicheZahlen;
    }
}

 

[fhoffmann]

haeufigkeitDerWuerfe(gewuerfelt);

Was erwartest du dir denn davon, diese Methode innerhalb der for-Schleife aufzurufen?

Du musst ein Array haben, in dem du dir Häufigkeit der Würfelung jeder Zahl speicherst.

int[] zufallsZahlen = new int[1];

Und was soll das sein?

 

[Hallo1234]

Was erwartest du dir denn davon, diese Methode innerhalb der for-Schleife aufzurufen?

Ich weiß, das sollte so nicht sein. Momentan habe ich aber keine Idee, wie es anders geht. Der Code ist sowieso ein einziges Durcheinander. Ein Neustart wäre vielleicht nicht schlecht.

Und was soll das sein?

Das gehörte nicht mehr zum Code, habe nur vergessen, es raus zu löschen.

Ich glaube, diese Aufgabe ist noch eine Nummer zu hoch für mich. Vielleicht probiere ich es morgen noch mal. Heute war es zu viel.
Vielen Dank für deine Tipps und deine Mühe : )

 

[kneitzel]

Vielleicht solltest Du Dir einfach einmal überlegen, wie du das machen würdest mit Stift und Papier?
Wie ist da der Ablauf?

Also ich gebe Dir einen Würfel und du sollst jetzt 20 Mal würfeln und mir dann am Ende sagen, wie oft jede Zahl gewürfelt wurde. Ist das etwas, das du irgendwie hin kriegen kannst?

 

[M.L.]

zu hoch

Das es -neben der Verwendung von Zettel und Stift- auch mit Java möglich ist, zeigt u.a. folgendes Beispiel mit Streams: https://farenda.com/java/java-8-count-frequency-of-numbers/ (jetzt gilt es zu recherchieren, was hinter den Kulissen der Streams passiert)

 

[kneitzel]

Wobei es aus meiner Sicht nicht wirklich zielführend ist, sich im frühen Stadium mit Streams zu beschäftigen.

Generell ist der erste Schritt immer, sich zu überlegen, wie man vorgehen sollte. Und wenn es Probleme gibt, sich etwas vorzustellen, dann ist Stift und Papier kaum zu übertreffen. (Wobei natürlich die Detailtiefe mit der Zeit immer geringer wird.)

 

[Hallo1234]

So noch einmal ein kleines Update. Habe die letzten zwei Methoden komplett neu gemacht. Ich denke, so kann man es lassen, oder gibt es noch Fehler? Wenn nicht, versuche ich mich an der Häufigkeitsanalyse.

import java.util.Scanner;
public class Start {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        Start start = new Start();

        boolean quit = true;
        while(quit == true) {
            System.out.println("Wie viele Runden möchten Sie würfeln?: ");
            int runden = s.nextInt();

            if(runden < 3) {
                System.out.println("Sie müssen mindestens 3 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden > 20) {
                System.out.println("Sie dürfen nicht mehr als 20 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden >= 3 && runden <=20) {
                quit = false;
            }
            start.zufallsZahlen(runden);

        }
    }

    public Wuerfel zufallsZahlen(int runden) {
        Wuerfel wuerfel = new Wuerfel(1,true);
        int[] gewuerfelteZahlen = new int[runden];
        for(int i=0; i<gewuerfelteZahlen.length; i++) {
            gewuerfelteZahlen[i] = wuerfel.wuerfeln();
        }
        for(int j=0; j<runden; j++) {
            System.out.println("Ergebnis aus Runde "+(j+1)+": "+gewuerfelteZahlen[j]);
        }
        haeufigkeitDerZahlen(gewuerfelteZahlen);
        return wuerfel;
    }
    
    /*public void haeufigkeitDerZahlen(int[] gewuerfelteZahlen) {
        int[] moeglicheZahlen = {1,2,3,4,5,6};
        for(int i=0; i<moeglicheZahlen.length; i++) {
            
        }
    }*/
}

Vielen Dank für eure Hilfe : )

 

[kneitzel]

Dann probiere es doch einmal aus. Gib z.B. 10000 Runden ein. Damm kommt die Fehlermeldung und es startet doch die Verarbeitung der Zufallszahlen. Das wird nicht das Verhalten sein, das Du willst.

Und dann ist quit doch true. Also musst Du es nicht immer wieder auf true setzen.

Und wenn quit bereits ein boolean ist, dann musst Du nicht quit==true prüfen. quit==true ist das Gleiche wie quit.

So Logik-Fehler wie den ersten, vermeidet man sehr gut, in dem man die Logik Teile verkleinert:

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        Start start = new Start();
        int runden = getNumberOfRounds();
        start.zufallsZahlen(runden);
    }

    public static int getNumberOfRounds() {
        Scanner s = new Scanner(System.in);
        while(true) {
            System.out.println("Wie viele Runden möchten Sie würfeln?: ");
            int runden = s.nextInt();

            if(runden < 3) {
                System.out.println("Sie müssen mindestens 3 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die Eingabe.");
            }else if(runden > 20) {
                System.out.println("Sie dürfen nicht mehr als 20 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die Eingabe.");
            }else if(runden >= 3 && runden <=20) {
                return runden;
            }
        }
    }

Also so Dinge einfach in eigene Methoden auslagern. So macht man den Code auch deutlich lesbarer. (Das war jetzt nur der Ansatz - das kann man noch deutlich weiter treiben....)

 

[Hallo1234]

Stimmt, es wird trotzdem verarbeitet. Ich habe es jetzt so gelöst und verändert, find ich etwas einfacher. Wenn ich den Code auslagere, würde die Main ja fast gar nichts mehr machen. Ich werde es aber trotzdem mit einer Extramethode probieren, zur Übung. Danke für den Tipp.

import java.util.Scanner;
public class Start {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        Start start = new Start();
        int runden = 0;
        boolean quit = true;
        while(quit) {
            System.out.println("Wie viele Runden möchten Sie würfeln?: ");
            runden = s.nextInt();

            if(runden < 3) {
                System.out.println("Sie müssen mindestens 3 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden > 20) {
                System.out.println("Sie dürfen nicht mehr als 20 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden >= 3 && runden <=20) {
                quit = false;
                start.zufallsZahlen(runden);
                System.out.println("Möchten Sie noch einmal? J->ja, N->nein: ");
                String antwort = s.next();
                if(antwort.equals("J")) {
                    quit = true;
                }else if(antwort.equals("N")) {
                    quit = false;
                }
            }
        }
    }

    public Wuerfel zufallsZahlen(int runden) {
        Wuerfel wuerfel = new Wuerfel(1,true);
        int[] gewuerfelteZahlen = new int[runden];
        for(int i=0; i<gewuerfelteZahlen.length; i++) {
            gewuerfelteZahlen[i] = wuerfel.wuerfeln();
        }
        for(int j=0; j<runden; j++) {
            System.out.println("Ergebnis aus Runde "+(j+1)+": "+gewuerfelteZahlen[j]);
        }
        haeufigkeitDerZahlen(gewuerfelteZahlen);
        return wuerfel;
    }
    
    /*public void haeufigkeitDerZahlen(int[] gewuerfelteZahlen) {
        int[] moeglicheZahlen = {1,2,3,4,5,6};
        for(int i=0; i<moeglicheZahlen.length; i++) {
            
        }
    }*/
}

 

[mihe7]

Wenn ich den Code auslagere, würde die Main ja fast gar nichts mehr machen.

Das ist Sinn und Zweck der Sache. Die main-Methode ist einfach der Programmeinstiegspunkt, nicht mehr, nicht weniger.

BTW: die Zeilen 28 und 29 kannst Du Dir sparen.

 

[Hallo1234]

Die main-Methode ist einfach der Programmeinstiegspunkt, nicht mehr, nicht weniger.

Gut zu wissen, danke.

Zeilen 28 und 29 kannst Du Dir sparen.

Ist schon gelöscht 👍

 

[Hallo1234]

Hallo, ich weiß jetzt wirklich nicht mehr weiter. Was muss ich verändern, dass die Häufigkeit der Zahlen ausgegeben wird?
Freue mich sehr über Hilfe.

import java.util.Scanner;
public class Start {

    public static void main(String[] args) {
        Start start = new Start();
        start.abfrageUndUeberpruefung();
    }

    public void abfrageUndUeberpruefung() {
        Start start = new Start();
        Scanner s = new Scanner(System.in);
        int runden = 0;
        boolean quit = true;
        while(quit) {
            System.out.println("Wie viele Runden möchten Sie würfeln?: ");
            runden = s.nextInt();

            if(runden < 3) {
                System.out.println("Sie müssen mindestens 3 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden > 20) {
                System.out.println("Sie dürfen nicht mehr als 20 Runden würfeln!");
                System.out.println("Bitte wiederholen Sie die eingabe.");
                quit = true;
            }else if(runden >= 3 && runden <=20) {
                quit = false;
                start.zufallsZahlen(runden);
                System.out.println("Möchten Sie noch einmal? J->ja, N->nein: ");
                String antwort = s.next();
                if(antwort.equals("J")) {
                    quit = true;
                }
            }
        }
    }

    public Wuerfel zufallsZahlen(int runden) {
        Wuerfel wuerfel = new Wuerfel(1,true);
        int[] gewuerfelteZahlen = new int[runden];
        for(int i=0; i<gewuerfelteZahlen.length; i++) {
            gewuerfelteZahlen[i] = wuerfel.wuerfeln();
        }
        for(int j=0; j<runden; j++) {
            System.out.println("Ergebnis aus Runde "+(j+1)+": "+gewuerfelteZahlen[j]);
        }
        haeufigkeitDerZahlen(gewuerfelteZahlen);
        return wuerfel;
    }

    public void haeufigkeitDerZahlen(int[] gewuerfelteZahlen) {
        int[] moeglicheZahlen = {1,2,3,4,5,6};
        int haeufigkeit = 0;
        for(int i=0; i<moeglicheZahlen.length; i++) {
            if(gewuerfelteZahlen[i] == i+1) {
                haeufigkeit = haeufigkeit + 1;
            }
            System.out.println("Die Häufigkeit für Zahl "+(i+1)+" ist: "+haeufigkeit);

        }
    }
}