Zufallszahlen ohne Wiederholung

[battlefire]

Hallo liebe Leute,
ich bin nicht der Javakünstler mit den großen Kenntnissen, daher bräuchte ich etwas Hilfe. Das Problem ist, dass im Topf Zahlen doppelt vorkommen dürfen, aber bei der Ziehung soll er, falls er bei einer Ziehung (6 Zahlen) eine Zahl mit dem gleichen Wert zieht, soll diese wieder verworfen werden und nachträglich noch eine weitere ziehen. Es ist sozusagen "6 Zahlen ziehen und wenn eine doppelt gezogen wird(oder mehr), dann zieh noch eine und verwerfe die doppelt gezogene"

import java.util.Random;

import java.util.Random;

class Lottoshuffle
{
  public static void main(String args[])
  {
    int[] solutionArray = {1,2,3,4,5,6,7,8,9,
                          1,2,3,4,5,6,7,8,9,
                          10,11,12,13,14,15,
                          10,11,12,13,14,15,
                          22,23,24,25,26,27,
                          28,29,30,31,32,33,
                          34,35,36,37,38,39,
                          40,41,42,43,
                          46,47,48,
                          46,47,48};


    for (int x = 0; x <=10; x++) {
    shuffleArray(solutionArray);
    for (int i = 0; i < 6; i++)
        {
        System.out.print(solutionArray + " ");
        }
    System.out.println();
    }

System.out.println();
}

  // Implementing Fisher–Yates shuffle
  static void shuffleArray(int[] ar)
  {
    // If running on Java 6 or older, use `new Random()` on RHS here
    Random rnd = new Random();
    for (int i = ar.length - 1; i > 0; i--)
    {
      int index = rnd.nextInt(i + 1);
      // Simple swap
      int a = ar[index];
      ar[index] = ar;
      ar = a;
    }
  }
}

 

[JCODA]

Wenn du nicht viel verändern möchtest, könntest du alle gezogenen zu einem HashSet hinzufügen, und solange ziehen bis die gewünschte Anzahl im Hashset ist.

Ansonsten kannst du mit ner zweiten For-Schleife testen, ob gezogene Zahl schon vorhanden, falls ja, neue Ziehen.

 

[battlefire]

Könntest Du das am meinem Code mit dem HashSet mir zeigen?
Ich würde das mal mit der 2. Schleife probieren und gucken, ob ich da eine Lösung finde.

 

[JCODA]

Du hattest da bei dem Tauschen noch etwas falsch ...

Hier meine HashSet-Variante:

import java.util.HashSet;
import java.util.Random;

class Lottoshuffle {
    public static void main(String args[]) {
        int[] solutionArray = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7,
                8, 9, 10, 11, 12, 13, 14, 15, 10, 11, 12, 13, 14, 15, 22, 23,
                24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
                40, 41, 42, 43, 46, 47, 48, 46, 47, 48 };

        final int toDraw = 6;

        for (int x = 0; x <= 10; x++) {
            shuffleArray(solutionArray);
            HashSet<Integer> drawn = new HashSet<>();
            for (int k = 0; drawn.size() < toDraw && k < solutionArray.length; k++) {
                drawn.add(solutionArray[k]);
            }
            System.out.println(drawn + " ");

            // System.out.println();
        }

        System.out.println();
    } // Implementing Fisher–Yates shuffle

    static void shuffleArray(int[] ar) {
        // If running on Java 6 or older, use `new Random()` on RHS here
        Random rnd = new Random();
        for (int i = ar.length - 1; i > 0; i--) {
            int index = rnd.nextInt(i + 1);
            // Simple swap
            int a = ar[i];
            ar[i] = ar[index];
            ar[index] = a;
        }
    }
}

Achso und mit einem TreeSet wäre die Ausgabe noch automatisch sortiert:

Spoiler: Click

import java.util.Random;
import java.util.TreeSet;


class Lottoshuffle {
    public static void main(String args[]) {
        int[] solutionArray = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7,
                8, 9, 10, 11, 12, 13, 14, 15, 10, 11, 12, 13, 14, 15, 22, 23,
                24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
                40, 41, 42, 43, 46, 47, 48, 46, 47, 48 };

        final int toDraw = 6;

        for (int x = 0; x <= 10; x++) {
            shuffleArray(solutionArray);
            TreeSet<Integer> drawn = new TreeSet<>();
            for (int k = 0; drawn.size() < toDraw && k < solutionArray.length; k++) {
                drawn.add(solutionArray[k]);
            }
            System.out.println(drawn + " ");

            // System.out.println();
        }

        System.out.println();
    } // Implementing Fisher–Yates shuffle

    static void shuffleArray(int[] ar) {
        // If running on Java 6 or older, use `new Random()` on RHS here
        Random rnd = new Random();
        for (int i = ar.length - 1; i > 0; i--) {
            int index = rnd.nextInt(i + 1);
            // Simple swap
            int a = ar[i];
            ar[i] = ar[index];
            ar[index] = a;
        }
    }
}

 

[battlefire]

Sehr Gut! Danke! Damit hast Du mir heute Abend noch zu einer besseren Lösung verholfen!
Ich hätte jetzt noch probiert die Ergebnisse ohne doppelte Zahlen in ein 2. Array zu kopieren.

 

[JCODA]

Am besten und einfachsten ist die zweite for-Schleife. Das HashSet/TreeSet sind hier schon ein bisschen Overkill und ich vermute auch nicht Sinn der Aufgabe 😉

 

[battlefire]

Naja, die Aufgabe habe ich mir ja selber gestellt, damit ich etwas mit Java lerne umzugehen, aber die HashSet sind noch Neuland für mich 🙄

 

[JCODA]

Dann versuch es mit der zweiten For-Schleife. Damit lernst du eher was, als mit dem Hashset 😉

 

[battlefire]

OK! Ich werde erst mal so noch mit rumspielen und gucken, wie mir das nützlich ist bzw. erweitern kann🙂Die 2. Schleife folgt noch!
Dir noch eine gute Nacht und Danke nochmal!

 

[thecain]

http://www.java-forum.org/thema/lottozahlen.171761/#post-1081025

Und viele andere antworten in dem thread

 

[Xyz1]

Oder hier:
http://www.java-forum.org/thema/lotto-google-caliper-benchmark.173960/

Wollte gerade ein Benchmark mit google caliper schreiben, aber das gestaltet sich schwieriger, als zunächst angenommen. 😱