Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Zahlen von einem Array mit zahlen von zweitem Array vergleichen
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);
}
}
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 :
Code:
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.
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.
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.
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.
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.
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!
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:
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
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...
@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?
Java:
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]);
}
}
@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?
Java:
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]);
}
}
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!
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
Java:
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]);
}
}
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
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.
Java:
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 :/
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!!!
@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
eine gezogene Kugel nicht zurück in die Lostrommel gelegt wird und
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.
Java:
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):
Java:
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...
Java:
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.
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
