Zahlen von einem Array mit zahlen von zweitem Array vergleichen

[eduwei1]

In einem durch "Random" erstellten Array soll mindestens eine Zahl aus einem zweiten (mit festgesetzten Zahlen) Array vorkommen. Klappt leider nicht , vermutlich Vergleich ist nicht richtig geschrieben. der Code:

public class Zahlen8 {
private static final int ANZAHL = 8;
public static void main(String[] args) {
int[] bums = new int[ANZAHL];
int[] bums2 = {5, 10, 18, 23, 32, 33, 34, 35};
Random zufall = new Random();
for (int i = 0; i <bums.length; i++) {
bums = zufall.nextInt(50) + 1;
for (int j = 0; j < i; j++) {
if (bums[j] == bums) { //die Zahlen sollen sich nicht wiederholen
i--;
break;
}
}
if (bums == bums2) { //mindestens 1 Zahl aus lotto2 muss dabei sein
}
}
Arrays.sort(bums);
for (int i = 0; i < bums.length; i++)
System.out.printf("%3d", bums);
}
}

 

[drose_1]

Nochmal fürs Verständnis: Du willst nachschauen ob eine Zahl aus bums2 in bums vorkommt?

 

[eduwei1]

Nochmal fürs Verständnis: Du willst nachschauen ob eine Zahl aus bums2 in bums vorkommt?

ja

 

[drose_1]

okay dann würde ich das jetzt auf schnell so machen:
eine for-schleife mit der du bums mit zufälligen zahlen füllst, die hast du ja bereits.
und dann geschachtelte for-schleifen:
die erste iteriert durch bums und die 2 durch bums2 und dann vergleichst du einfach die zahlen am gegeben Index :

for(int i = 0; i < bums.length; i++) {
    for (int j = 0; j < bums2.length; j++) {
        if (bums[i] == bums2[j]) {
            break;
        }
    }
}

So sollte der Vergleich zumindest klappen, aber garantieren das eine Zahl aus bum2 immer in bum vorkommt tut es nicht.

 

[eduwei1]

Aber genau darum ging's ,dass mindestens 1Zahl vorkommen soll. Trozdem Danke für schnelle Antwort.

 

[mihe7]

1. Setze das erste Element des Zielarrays auf ein beliebig (zufällig?) gewähltes Element des übergebenen Arrays
2. Fülle die restlichen Elemente des Zielarrays mit Zufallszahlen auf.

Fertig.

 

[Xyz1]

Oder der ganz einfache Weg:

public static int[] getInts(int[] a) {
	return IntStream.range(0, a.length)
			.flatMap(e -> IntStream.of(e == 0 ? a[new Random().nextInt(a.length)] : new Random().nextInt(Arrays.stream(a).max().getAsInt())))
			.mapToObj(Integer::valueOf)
			.collect(Collectors.collectingAndThen(
				Collectors.toCollection(ArrayList::new),
				e -> { Collections.shuffle(e); return e; }))
			.stream()
			.mapToInt(e -> e.intValue())
			.toArray();
}

aufzurufen mit:

System.out.println(Arrays.toString(getInts(new int[] { 1, 2, 100 })));

Es ist (an einer zufälligen Stelle) immer entweder 1, 2 oder 100 enthalten - und die übrigen Werte sind zufällig gewählt. Das entspräche genau der Aufgabe.

 

[mihe7]

Das entspräche genau der Aufgabe.

Wobei mir gerade auffällt, dass nirgendwo steht, dass die Zahlen selbst Zufallszahlen sein müssen. Einfach das Zielarray mit zufällig aus dem übergebenen Array gewählten Zahlen füllen -> done.

 

[Xyz1]

dass nirgendwo steht, dass die Zahlen selbst Zufallszahlen sein müssen

Einfach das Zielarray mit zufällig aus dem übergebenen Array gewählten Zahlen füllen

Naja, das ließe sich ja janz einfach ummogeln.

 

[eduwei1]

Oder der ganz einfache Weg:

public static int[] getInts(int[] a) {
    return IntStream.range(0, a.length)
            .flatMap(e -> IntStream.of(e == 0 ? a[new Random().nextInt(a.length)] : new Random().nextInt(Arrays.stream(a).max().getAsInt())))
            .mapToObj(Integer::valueOf)
            .collect(Collectors.collectingAndThen(
                Collectors.toCollection(ArrayList::new),
                e -> { Collections.shuffle(e); return e; }))
            .stream()
            .mapToInt(e -> e.intValue())
            .toArray();
}

aufzurufen mit:

System.out.println(Arrays.toString(getInts(new int[] { 1, 2, 100 })));

Es ist (an einer zufälligen Stelle) immer entweder 1, 2 oder 100 enthalten - und die übrigen Werte sind zufällig gewählt. Das entspräche genau der Aufgabe.

 

[eduwei1]

Der Weg mag einfach zu sein für den, der es versteht, aber mir(blutiger Anfänger) ist hier nicht ersichtlich wo ich meine 8 Zahlen kriege, wenn ich den ganzen Code ersetze oder soll ich ihn irgendwo dazwischen reinbringen. Danke für die Mühe!

 

[ocsme]

public static int[] getInts(int[] a) { return IntStream.range(0, a.length) .flatMap(e -> IntStream.of(e == 0 ? a[new Random().nextInt(a.length)] : new Random().nextInt(Arrays.stream(a).max().getAsInt()))) .mapToObj(Integer::valueOf) .collect(Collectors.collectingAndThen( Collectors.toCollection(ArrayList::new), e -> { Collections.shuffle(e); return e; })) .stream() .mapToInt(e -> e.intValue()) .toArray(); }

Das sollte für einen Anfänger auch zu schwer sein. Was @Tobias-nrw in einem 1 Zeiler hin schreibt ist ein Stream die es Zeit Java 8 gibt (Lambda und Streams). Mehr dazu findest du unter:

Javabeginners - Streams

javabeginners.de

Besondere Typen der Java SE

Wobei mir gerade auffällt, dass nirgendwo steht, dass die Zahlen selbst Zufallszahlen sein müssen. Einfach das Zielarray mit zufällig aus dem übergebenen Array gewählten Zahlen füllen -> done.

An diese Möglichkeit dachte ich auch doch er sortiert doch oben das bums array wieder. Dann wäre bums = bums2 oder?

So wie ich das sehe soll das eine Art Lotto sein! Er könnte doch einfach 7 komplett zufällige Zahlen füllen dann durchlaufen und schauen gibt es eine der Zufälligen Zahlen im Array bums2? Wenn Ja dann erzeuge die 8te Zufallszahl wenn nein nimm einen zufälligen Index aus bum2 und kopiere die Zahl zu bums. Das würde ich ganz nett finden

LG

 

[Xyz1]

aber mir(blutiger Anfänger) ist hier nicht ersichtlich wo ich meine 8 Zahlen kriege

Das ist ja das Schöne an Java 8, das ist niemandem ersichtlich.

Ich habe mich nur an die Frage gehalten - es mag sein das die Aufgabe eine ganz andere ist. Aber niemand kann Gedanken lesen und meine Glaskugel ist auch schon etwas abgenutzt. Also versuche nochmal genau den "Usecase" darzulegen. Was wann wo wofür...

 

[ocsme]

@Tobias-nrw da werde ich wenn ich meine Zusammenfassung zu JavaFX fertig habe euch auch noch Löschern zu den Lambdas und zu JavaFX damit tu ich mir unendlich schwer!

Eine Frage hätte ich hier noch zum Aufgabensteller ist der Programmcode (Rahmen) so vorgegeben wie du Ihn oben gepostet hast?

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

public class Zahlen8 {
    private static final int ANZAHL = 8;

    public static void main(String[] args) {
        int[] lotto = new int[ANZAHL];
        int[] lotto2 = { 5, 10, 18, 23, 32, 33, 34, 35 };
        Random zufall = new Random();
        for (int i = 0; i < lotto.length; i++) {
            lotto[i] = zufall.nextInt(50) + 1;
            for (int j = 0; j < i; j++) {
                if (lotto[j] == lotto[i]) { // die Zahlen sollen sich nicht wiederholen
                    i--;
                    break;
                }
            }
            if (lotto[i] == lotto2[i]) { // mindestens 1 Zahl aus lotto2 muss dabei sein
                continue;
            }
        }
        Arrays.sort(lotto);
        for (int i = 0; i < lotto.length; i++)
            System.out.printf("%3d", lotto[i]);
    }
}

 

[Xyz1]

@Tobias-nrw da werde ich wenn ich meine Zusammenfassung zu JavaFX fertig habe euch auch noch Löschern zu den Lambdas und zu JavaFX

Also das ist jetzt für mich nur sehr schwer zu verstehen.

 

[eduwei1]

@Tobias-nrw da werde ich wenn ich meine Zusammenfassung zu JavaFX fertig habe euch auch noch Löschern zu den Lambdas und zu JavaFX damit tu ich mir unendlich schwer!

Eine Frage hätte ich hier noch zum Aufgabensteller ist der Programmcode (Rahmen) so vorgegeben wie du Ihn oben gepostet hast?

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

public class Zahlen8 {
    private static final int ANZAHL = 8;

    public static void main(String[] args) {
        int[] lotto = new int[ANZAHL];
        int[] lotto2 = { 5, 10, 18, 23, 32, 33, 34, 35 };
        Random zufall = new Random();
        for (int i = 0; i < lotto.length; i++) {
            lotto[i] = zufall.nextInt(50) + 1;
            for (int j = 0; j < i; j++) {
                if (lotto[j] == lotto[i]) { // die Zahlen sollen sich nicht wiederholen
                    i--;
                    break;
                }
            }
            if (lotto[i] == lotto2[i]) { // mindestens 1 Zahl aus lotto2 muss dabei sein
                continue;
            }
        }
        Arrays.sort(lotto);
        for (int i = 0; i < lotto.length; i++)
            System.out.printf("%3d", lotto[i]);
    }
}

 

[Xyz1]

Was sollen diese Beiträge die nur full quotes enthalten? Spielregeln! @eduwei1

 

[eduwei1]

Danke für die Frage. Die letzte if - Anweisung habe ich dazu geschrieben mit dem Gedanken die kommende Zufahlszahlen so zu beeinflüssen,(bzw Random weiter laufenlassen) dass unter diesen mindestens eine von vorgegebenen aus einem anderen Array vorkommt.Das war auch keine Aufgabe in dem Sinne, nur ein Gedankenspiel - Ausgabe von Zufahlszahlen mit bestimmten Bedingungen zu bestimmten Ergebnissen zwingen zu lassen!

 

[ocsme]

Danke für die Frage. Die letzte if - Anweisung habe ich dazu geschrieben mit dem Gedanken die kommende Zufahlszahlen so zu beeinflüssen,(bzw Random weiter laufenlassen) dass unter diesen mindestens eine von vorgegebenen aus einem anderen Array vorkommt.Das war auch keine Aufgabe in dem Sinne, nur ein Gedankenspiel - Ausgabe von Zufahlszahlen mit bestimmten Bedingungen zu bestimmten Ergebnissen zwingen zu lassen!

Also ist das keine "wichtige" Aufgabe für dich sondern nur so zum Spaß
Mein Lösungsvorschlaf wäre dieser hier. Finde das zwar überhaupt nicht schön da man 2x break drin hat aber naja!
Ob der 100% richtig ist weiß ich nicht das war nur meine Idee

Spoiler: ...

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

public class Zahlen8 {
    private static final int ANZAHL = 8;

    public static void main(String[] args) {
        int[] lotto = new int[ANZAHL];
        int[] lotto2 = { 5, 10, 18, 23, 32, 33, 34, 35};
        Random zufall = new Random();
        for (int i = 0; i < lotto.length; i++) {
            lotto[i] = zufall.nextInt(50) + 1;
            for (int j = 0; j < i; j++) {
                if (lotto[j] == lotto[i]) { // die Zahlen sollen sich nicht wiederholen
                    i--;
                    break;
                }
            }
            if(i == lotto.length-1) {
                for(int k = 0; k<i;k++)
                    if(lotto[k] == lotto2[k])
                        break;
                    else {
                        
                        lotto[i] = lotto2[(int) (Math.random()*7)];
                    }
            }
        }
        Arrays.sort(lotto);
        for (int i = 0; i < lotto.length; i++)
            System.out.printf("%3d", lotto[i]);
    }
}

Also das ist jetzt für mich nur sehr schwer zu verstehen.

Jeder fängt doch mal klein an aber dann kann ich ja hier wieder meine 1000 Fragen los werden

LG

 

[Xyz1]

aber dann kann ich ja hier wieder meine 1000 Fragen los werden

Tu es

 

[ocsme]

Meine Lösung ist Käse
Hab es mal laufen lassen. Es entstehen so z. B. auch Dupplikate die man wieder entfernen muss indem man durch das lotto Array läuft und schaut ob die Zufallszahl schon drin ist wenn ja dann nächste Zufallszahl! Das ganze wird schnell Komplexer netter Übungsaufgabe

Vielleicht macht es ja jemand noch komplett Fertig
LG

 

[ocsme]

So sollte es gehen aber ohne den Vorgegeben Rahmen.
Das Array füllen und prüfen ob die Zahl von Lotto2 vorhanden sind wenn nein füge an eine Random Stelle eine Random Zahl aus Lotto2 ein.

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

public class Zahlen8 {
    private static final int ANZAHL = 8;

    public static void main(String[] args) {
        int[] lotto = new int[ANZAHL];
        int[] lotto2 = { 5, 10, 15, 20, 25, 30, 35, 40 };
        Random zufall = new Random();
        boolean isDrin = false;
        for (int i = 0; i < lotto.length; i++) {
            lotto[i] = zufall.nextInt(50) + 1;
            for (int j = 0; j < i; j++) {
                if (lotto[j] == lotto[i]) { // die Zahlen sollen sich nicht wiederholen
                    i--;
                    break;
                }
            }
        }
        
        for(int i = 0; i < lotto.length; i++)
            for(int j = 0; j < lotto2.length; j++)
                if(lotto[i] == lotto2[j])
                    isDrin = true;

        if(!isDrin)
            lotto[(int) (Math.random()*lotto.length-1)] = lotto2[(int) (Math.random()*lotto2.length-1)];
        
        Arrays.sort(lotto);
        for (int i = 0; i < lotto.length; i++)
            System.out.printf("%3d", lotto[i]);
    }
}

Nicht schön aber selten

Vielleicht kann es ja jemand noch mit dem Programm Rahmen lösen. Dafür fehlt mir jetzt die Zeit :/

LG

 

[mihe7]

Vielleicht macht es ja jemand noch komplett Fertig

Mich macht es tatsächlich komplett fertig

 

[Xyz1]

Vielleicht kann es ja jemand noch mit dem Programm Rahmen lösen. Dafür fehlt mir jetzt die Zeit

Wenn ich wüsste wie diese Lottozahlenziehung genau sein soll...

 

[ocsme]

Ja ich hab das ja nur weiter gemacht weil ich wieder ein paar Tage nicht viel Programmiert habe und die Übung ganz nett finde
Werde nun auch wieder weiter arbeiten und später mich hier wieder melden und euch Löschern!!!

LG

 

[mihe7]

@eduwei1 Nachdem das hier alles etwas aus dem Ruder gelaufen ist nochmal von vorne und hoffentlich einfach nachvollziehbar.

Soweit ich das Problem verstanden habe, haben wir 50 Kugeln, die mit den Zahlen 1 bis 50 beschriftet sind. Außerdem haben wir eine Menge z von natürlicher Zahlen, die ebenfalls zwischen 1 und 50 liegen (das könnten z. B. die Zahlen einer früheren Ziehung sein). Die Kugeln befinden sich in einer Lostrommel. Die Aufgabe besteht nun darin, n Kugeln zu ziehen, wobei

1. eine gezogene Kugel nicht zurück in die Lostrommel gelegt wird und
2. die Zahl wenigstens einer gezogenen Kugel in z enthalten ist

Kommen wir zur Umsetzung. Die Kugeln können wir unmittelbar als Zahlen (int), die Lostrommel als int-Array darstellen. Zu Beginn der Ziehung enthält die Lostrommel alle Zahlen zwischen 1 und 50.

int[] lostrommel = new int[50];
for (int i = 0; i < lostrommel.length; i++) {
    lostrommel[i] = i+1;
}

Da wir die Lostrommel als Array darstellen, stellen wir uns diese einmal nicht als Kugel sondern als Reihe vor, sozusagen eine "Losreihe". Konkret könnte man sich das als Brett vorstellen, das 50 Mulden hat, in jeder Mulde liegt zu Beginn eine Kugel.

Wir wählen zufällig eine Mulde, d. h. wir bestimmen zufällig eine Zahl zwischen 1 und 50, sagen wir mal wir hätten zufällig die 4 ermittelt. Wir nehmen die Kugel aus der 4. Mulde. Das ist Kugel mit der Zahl 4.

Nachdem wir die Kugel aus der Mulde genommen haben, befinden sich nur noch 49 Kugeln im Spiel, die Zahl 4 kommt nicht mehr vor. An der vierten Stelle befindet sich nun aber eine Lücke.

Das ist schlecht, denn würden wir nochmal zufällig die 4 wählen, könnten wir keine Kugel ziehen, denn Mulde 4 ist ja leer. Wir können aber hergehen und die Lücke mit der letzten auf dem Brett verfügbaren Kugel auffüllen. Durch das Füllen der Lücke ist das Brett also bis zur letzten verfügbaren Kugel lückenlos gefüllt; das Brett leert sich also vom Ende her.

Für die Ziehung der zweiten Kugel stehen natürlich nur noch 49 Kugeln bzw. Mulden zur Verfügung, für die Ziehung der dritten nur noch 48 usw.

Wir wollen nun ANZAHL Kugeln ziehen (einmal sehr ausführlich):

int[] ziehung = new int[ANZAHL];
Random rand = new Random();
for (int i = 0; i < ziehung.length; i++) {
    int verfuegbareKugeln = lostrommel.length - i;
    int gewaehlteKugel = rand.nextInt(verfuegbareKugeln);
    int gezogeneZahl = lostrommel[gewaehlteKugel];
    ziehung[i] = gezogeneZahl;
    int letzteKugel = verfuegbareKugeln-1;    
    lostrommel[gewaehlteKugel] = lostrommel[letzteKugel];
}

Das war jetzt Teilaufgabe 1. Wie lösen wir nun Teilaufgabe 2?

Wir könnten z. B. erst einmal eine Kugel aus z Ziehen und diese aus der Lostrommel entfernen. Dann müssen wir nur noch die restlichen Kugeln aus der Lostrommel ziehen, so wie wir es gerade gemacht haben...

public class Zahlen {
    private static final int ANZAHL = 8; 
    public static void main(String[] args) {
        int[] ziehung = new int[ANZAHL];
        int[] zahlen = {5, 10, 18, 23, 32, 33, 34, 35};

        int[] lostrommel = new int[50];
        for (int i = 0; i < lostrommel.length; i++) {
            lostrommel[i] = i+1;
        }

        Random zufall = new Random(); 
        int gesicherteZahl = zahlen[zufall.nextInt(zahlen.length)];
        int kugelInLostrommel = gesicherteZahl-1; // wegen lostrommel[i] = i+1
        lostrommel[kugelInLostrommel] = lostrommel[lostrommel.length-1]; // Lücke füllen
        ziehung[0] = gesicherteZahl; // kommt garantiert in zahlen vor

        for (int i = 1; i < ziehung.length; i++) { // i beginnt jetzt bei 1, denn die erste Zahl wurde bereits ermittelt
            int verfuegbareKugeln = lostrommel.length - i;
            int gewaehlteKugel = zufall.nextInt(verfuegbareKugeln);
            ziehung[i] = lostrommel[gewaehlteKugel];
            lostrommel[gewaehlteKugel] = lostrommel[verfuegbareKugeln-1];
        }

        Arrays.sort(ziehung);
        System.out.println(Arrays.toString(ziehung));
}

Achtung: der Spaß kann Fehler enthalten, ich hab das nur hier im Editor bearbeitet.

 

[ocsme]

Mal wieder KLASSE @mihe7
Gute Erklärung und nette Umsetzung Mir sind dazu noch ein paar mehr "Implementierungen" eingefallen. Doch ich dachte ja auch zuerst wir dürfen denn Programm-Rahmen der vorgegeben war nicht ändern Dann wird das ganze etwas Komplexer

Daumen mal wieder HOCH

Hoffe @eduwei1 liest hier noch

LG

 

[Xyz1]

Hoffe @eduwei1 liest hier noch

Eher unwahrscheinlich

Eher wahrscheinlich: Er weiß nicht was das Programm soll... (Infolgedessen können wir auch nicht helfen)