Wie kann man in Java nach Arrays auf Duplikate prüfen

[developer2013]

Hallo miteinander,

ich habe ein Array erstellt, der 3 Integer-Werte abspeichern soll. Diese Integer-Werte sollen nicht 2 mal den gleichen Wert haben. Sollte dies dennoch so sein, dann soll zum Beispiel der Index 1 oder 2 einen neuen Wert generieren und erneut prüfen, ob dieser Doppelt ist. Wenn nein, dann soll die Schleife weiterlaufen, wenn ja, dann soll ein neuer Wert generiert werden und das soll so lange passieren, bis der Wert noch gar nicht existiert.

Code:

import java.util.Arrays;

public class Test {
    
    public static void main(String[] args) {
        
        int[] zahlen = new int[3];
        
        for(int i = 0; i<zahlen.length; i++) {
            zahlen[i] = (int) (Math.random()*3+1);
        }
        
        System.out.println(Arrays.toString(zahlen));
        
    }
    
    
}

 

[KonradN]

Dann überlege doch erst einmal, wie Du das machen würdest.

Du hast einen Würfel und Du sollst 3 unterschiedliche Würfelergebnisse aufschreiben. Kriegst Du das hin? Was hast Du gemacht?

 

[developer2013]

Dann überlege doch erst einmal, wie Du das machen würdest.

Du hast einen Würfel und Du sollst 3 unterschiedliche Würfelergebnisse aufschreiben. Kriegst Du das hin? Was hast Du gemacht?

Ich habe es mal probiert so wie du es gesagt hast. Hinbekommen habe ich es, aber nicht wie du es dir gewünscht hast. Da stehe ich vor dem gleichen Problem.

Das was ich auskommentiert habe, mit "//if(wurfversuce ==)". Das wäre meine Vermutung, dass man dort einen Abgleich macht und dann die Schleife neustartet mit Continue oder sowas ähnliches. Vielleicht kann man dort auch eine Methode starten, sowas ähnliches wie .equals oder sowas, wie man es auch kennt, wenn man Objekte abgleicht.

import java.util.Arrays;

public class Test {
    public static void main (String[] args) {
        
        int wuerfelseiten = 6;
        int[] wurfversuce = new int [3];
        
        for(int i=0; i<wurfversuce.length; i++) {

            wurfversuce[i] = (int) (Math.random()*wuerfelseiten+1);
            
            //if(wurfversuce[i] ==)
            
        }
        
        System.out.println(Arrays.toString(wurfversuce));
        
    }
}

 

[Jw456]

Erstelle eine Methode die das Array übergeben bekommt und den neu erstellten Wert.
In der Methode gehst du das Array durch und gibst wenn der Wert in dem Array ist True zurück.
Wenn nicht dann False.

Du musst schon nach jedem Würfel das Array erneut prüfen. Deshalb eine Neue Methode.

 

[KonradN]

Bei meiner Frage ging es ja erst einmal um eine Beschreibung. Vergiss den Code!

Du musst erst einmal schauen: kriegst Du das hin? Dazu einfach einen Würfel nehmen und machen!

Dann nachdenken: Was hast Du genau gemacht? Und das beschreibst Du in Worten!

Dann kommt etwas raus wie:
1 Du hast einen Zettel auf den Du die Zahlen schreiben kannst (jetzt 3)
2 Du würfelst und bekommst so eine Augenzahl.
3 Du schaust: Ist diese Augenzahl bereits auf dem Zettel? Wenn ja, dann wieder zu Schritt 2.
4 Du schreibst die Augenzahl auf
5 Du schaust: Hast du die gewünschten 3 Zahlen erwürfelt? Wenn nein, dann weiter zu Schritt 2.

Oder Du überlegst es Dir von oben herab in dem Du die Schritte abstrahiert aufschreibst
--> mache 3 Mal:
-----> Würfel so lange, bis Du eine Augenzahl hast, die noch nicht auf dem Zettel steht
-----> schreibe die Augenzahl auf.

Und dann merkst Du: Den Schritt mit dem "Würfel so lange, bis Du eine Augenzahl hast, die noch nicht auf dem Zettel steht" muss man noch einmal beschreiben. Da hast Du dann eine weitere Beschreibung.

Wichtig ist:
Ergebnis sind Beschreibungen, die ein Mensch, der die Aufgabe nicht kennt, lesen und ausführen kann und der macht dann genau das, was gefordert ist.

Erst wenn Du das hast, dann schreibst Du Code! Wenn Du mehrere Beschreibungen hast, dann wird jede Beschreibung eine Methode.

 

[developer2013]

Erstmal Danke für eure Hilfsbereitschaft. Die Erklärung von @JavaUndC-Prog im Beitrag: https://www.java-forum.org/thema/array-befuellen-auf-doppelte-werte-pruefen.154491/ kam ich zur Lösung. Die Lösung sieht nicht besonders schön aus, aber die hilft mir vorerst weiter. Daraus kann man gut eine Methode draus basteln.

Lösung:

import java.util.Arrays;



public class Test {
    public static void main(String[] args) {

        int[] zahlen = new int[3];

        for(int i = 0; i<zahlen.length; i++) {
            zahlen[i] = (int) (Math.random()*3+1);
            
        for(int j = 0; j < i; j++) {
                if(zahlen[i] == zahlen[j]) {
                    zahlen[i] = (int) (Math.random()*3+1);
                    i--;
                }
            }
        }
        System.out.println(Arrays.toString(zahlen));
    }
}

 

[Blender3D]

Erstmal Danke für eure Hilfsbereitschaft. Die Erklärung von @JavaUndC-Prog im Beitrag: https://www.java-forum.org/thema/array-befuellen-auf-doppelte-werte-pruefen.154491/ kam ich zur Lösung.

👍
Die Lösung ist in Ordnung. Ein Manko ist die laufende Variable, die erhöht und wieder reduziert wird.

Hier ein paar Hinweise, um den Code besser zu gestalten.
Der erste und wichtigste ist
1) Teile und Herrsche. Das bedeutet zerlege Dein zu lösendes Problem in kleiner Teilprobleme.
Diese sind leichter lösbar und führen zu wieder verwendbaren Code, für später zu lösende Problem.
Außerdem wird der Code dadurch viel übersichtlicher.
2) Benutze sprechende Variablen
Der Code wird lesbarer und das erspart viel Dokumentation.

Die Aufgabestellung lautet:
Erzeuge ein zufälliges Integer Array der Länge max ( max= 3 ) ohne doppelten Einträge.
Die Teilaufgaben die man daraus ableiten könnte sind:
1) Erzeuge eine Zufallszahl von 1 - max.

public static int rndInteger(int max)

2) Beinhaltet ein Integer Array einen bestimmten Wert?

public static boolean contains(int[] array, int number)

3) Erzeuge ein zufälliges Integer Array der Größe max ohne doppelten Einträge

public static int[] getRndArrayOfUniqueInt(int max)

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[] numbers = getRndArrayOfUniqueInt(3);
        System.out.println(Arrays.toString(numbers));
    }

    public static boolean contains(int[] array, int number) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == number)
                return true;
        }
        return false;
    }

    public static int[] getRndArrayOfUniqueInt(int max) {
        int[] numbers = new int[max];
        int id = 0;
        do {
            int num = rndInteger(max);
            if (!contains(numbers, num)) {
                numbers[id] = num;
                id++;
            }
        } while (id < max);
        return numbers;
    }

    public static int rndInteger(int max) {
        return (int) (Math.random() * max) + 1;
    }
}

 

[developer2013]

👍
Die Lösung ist in Ordnung. Ein Manko ist die laufende Variable, die erhöht und wieder reduziert wird.

Hier ein paar Hinweise, um den Code besser zu gestalten.
Der erste und wichtigste ist
1) Teile und Herrsche. Das bedeutet zerlege Dein zu lösendes Problem in kleiner Teilprobleme.
Diese sind leichter lösbar und führen zu wieder verwendbaren Code, für später zu lösende Problem.
Außerdem wird der Code dadurch viel übersichtlicher.
2) Benutze sprechende Variablen
Der Code wird lesbarer und das erspart viel Dokumentation.

Die Aufgabestellung lautet:
Erzeuge ein zufälliges Integer Array der Länge max ( max= 3 ) ohne doppelten Einträge.
Die Teilaufgaben die man daraus ableiten könnte sind:
1) Erzeuge eine Zufallszahl von 1 - max.

public static int rndInteger(int max)

2) Beinhaltet ein Integer Array einen bestimmten Wert?

public static boolean contains(int[] array, int number)

3) Erzeuge ein zufälliges Integer Array der Größe max ohne doppelten Einträge

public static int[] getRndArrayOfUniqueInt(int max)

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[] numbers = getRndArrayOfUniqueInt(3);
        System.out.println(Arrays.toString(numbers));
    }

    public static boolean contains(int[] array, int number) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == number)
                return true;
        }
        return false;
    }

    public static int[] getRndArrayOfUniqueInt(int max) {
        int[] numbers = new int[max];
        int id = 0;
        do {
            int num = rndInteger(max);
            if (!contains(numbers, num)) {
                numbers[id] = num;
                id++;
            }
        } while (id < max);
        return numbers;
    }

    public static int rndInteger(int max) {
        return (int) (Math.random() * max) + 1;
    }
}

Vielen Dank für deine Ausführliche Erklärung und für das Schreiben des Codes! Das ist sehr großzügig von dir!

 

[RegExs]

ich habe ein Array erstellt, der 3 Integer-Werte abspeichern soll. Diese Integer-Werte sollen nicht 2 mal den gleichen Wert haben.

Das ist ja so ähnlich wie eine Lottoziehung... (zum Beispiel 6aus49)

So wäre ich es wahrscheinlich angegangen: 🙂

import java.util.Arrays;

public class Gen {
    public static int[] randomsWithoutDuplicates(int a, int b, int stepWidth, int n) {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            int x = (int) ((b - a + stepWidth) / stepWidth * Math.random()) * stepWidth + a;
            boolean contains = false;
            for (int j = 0; j < i; j++) {
                if (x == arr[j]) {
                    contains = true;
                    break;
                }
            }
            if (!contains) {
                arr[i] = x;
            } else {
                i--;
            }
        }
        return arr;
    }

    public static void main(String[] args) {
        System.out.println(Arrays.toString(randomsWithoutDuplicates(1, 3, 1, 3)));
        System.out.println(Arrays.toString(randomsWithoutDuplicates(2, 6, 2, 3)));
        System.out.println(Arrays.toString(randomsWithoutDuplicates(2, 11, 3, 4)));
    }
}

Das contains... solte man aber der besseren Lesbarkeit halber in eine Methode setzen...

 

[Marsupilami]

Auch ein netter Snippet um doppelt vorkommende Werte von vornherein auszuschließen;

package arrayaufgabe1;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;

public class arrayaufgabe1 {

    public static void main(String[] args)
    {
        System.out.println(Arrays.toString(zufallsarray(5)));
    }
public static int[] zufallsarray(int n)
{
    int[] zahlen = new int[n];
    ArrayList<Integer> zahlenliste = new ArrayList<Integer>();
    
    for(int i=1; i<(n+1); i++)
    {
        zahlenliste.add(i);
    }

    for(int i=0; i<zahlen.length; i++)
    {
        int zahlenlisteindex=new Random().nextInt(zahlenliste.size());
        zahlen[i]=zahlenliste.get(zahlenlisteindex); //Wert der zahlenliste wird dem array zugewiesen
        zahlenliste.remove(zahlenlisteindex);//Wert der Zahlenliste wird gelöscht damit er nicht doppelt auftritt.
    }
    return zahlen;
    
}
}

 

[RegExs]

Dann könnte man fast die Mische Funktion einsetzen, @Marsupilami

 

[Marsupilami]

Was meinst du mit Mische Funktion @RegExs ?

 

[KonradN]

Du hast die Idee, dass Du sozusagen ein Kartenspiel hast. Da nimmst Du dann zufällig eine Karte heraus. Damit ist die Karte nicht mehr im Stapel und Du kannst die damit kein zweites Mal ziehen.

Die Hinweis von @RegExs ist (So wie ich ihn verstanden habe): Das Kartenspiel kann man auch einfach mischen. Nach dem Mischen nimmt man dann einfach von oben die gewünschte Anzahl Karten.

(Hier einfach zum besseren Verständnis die Analogie zu einem Kartenspiel.)