Neue Werte für gleiche Array-Indexe

[KoelOpa]

Also Leute, folgendes Programm:

class Lottozahlen
{
  int[] lottozahlen = new int[6];
  public void getLottozahlen()
  {
    int superzahl = (int)(Math.random()*9);
    System.out.println("Superzahl:\t" + superzahl);
    System.out.print("Lottozahlen:\t");
    for(int i = 0; i < lottozahlen.length; i++)
    {
      lottozahlen[i] = (int)(Math.random()*49) + 1;
      getTausch(lottozahlen[i]);    //indes
    }
    for(int i = 0; i < lottozahlen.length; i++)  System.out.print(" " + lottozahlen[i]);
    System.out.println("");
  }
  
  public int[] getTausch(int n)
  {
    for(int j = 0; j < lottozahlen.length; j++)
      while(lottozahlen[j] == n)
        lottozahlen[j] = (int)(Math.random()*49) + 1;
    return lottozahlen;
  }
}

die int[] getTausch(int n) ist dafür da, dass sie nach 2 identischen Werten im Array lottozahlen sucht und denjenigem ArrayIndex an dessen Stelle der Wert (identisch) gefunden wurde, neu füllen soll.

Aber das Programm will nicht so as ik so will.

in der getLottozahlen() habe ich getTausch den Wert von lottozahlen (z.B. die 0.stelle) übergeben, dann muss er mir doch eigtl. in der getTausch(int n) selber dann suchen, ob diese 0.stelle identisch mit nem anderen Index des Arrays ist, falls ja, bitte randomize it, ansonsten gib mir die lottozahlen god damn it.

Aber es will nicht, wieso?

 

[SlaterB]

grob betrachtet scheint das Programm auch genau das zu tun,
was lässt dich denn vermuten, dass es nicht so ist?

mache doch einfache jede Menge Ausgaben, dann weißt du, was Schritt für Schritt abläuft:

public int[] getTausch(int n)
  {
System.out.println("tausche für n = "+n);
    for(int j = 0; j < lottozahlen.length; j++) {
        Syste.out.println("bin bei j = "+j+" -> "+lottozahlen[j]);
        while(lottozahlen[j] == n) {
          lottozahlen[j] = (int)(Math.random()*49) + 1;
          System.out.println("neue Zahl für j = "+j+" -> "+lottozahlen[j]);
        }
    }
    return lottozahlen;
  }

usw.

warum liefert getTausch einen Rückgabewert?
den benutzt du nicht und das Array ist eh Exemlarvariable

--------

die Operation macht keinen Sinn,
wenn du 1,2,3,3 hat, dann kann passieren:
1. tausch: 1 wird zu 2 -> 2,2,3,3
2. tausch: 2 wird zu 1 und 3 -> 1,3,3,3
3. tausch: 3 wird zu 1, 2 und 2 -> 1,1,2,2

bist du dann besser dran?

-------------

du müsstest bei jeder Zahlzuweisung das ganze Array durchlaufen,
ob nicht die gleiche Zahl schon vorhanden ist,
dann reicht auch ein Durchgang, weil auf jeden Fall nur korrekte Zahl ins Array reinkommen

das kann allerdings recht aufwendig werden:
wenn schon 48 korrekte Zahlen drin sind,
dann musst du für die letzte verbleibende Zahl wahrscheinlich sehr oft eine Zufallszahl generieren und die 48 bisherigen Zahlen vergleichen,

(edit: ok, man hat ja eh nur 6 Zahlen)
-----------

viel einfacher: fülle das Array mit den Zahlen 1-49 in Reihenfolge
und benutze Collections.shuffe(list) oder eine eigene Durchmischungsoperation:
wähle eine Zufallszahl x zwischen 0 und 48 und vertausche das erste Element mit dem x-ten,
wähle eine Zufallszahl x zwischen 0 und 48 und vertausche das zweite Element mit dem x-ten,
49x: wähle eine Zufallszahl x zwischen 0 und 48 und vertausche das i.te Element mit dem x-ten,

achte auf die Grenzen: wirklich alle Zahlen im Array einmal mischen und wirklich alle Positionen möglich machen,
nicht dass x nur von 1-48 geht oder so

(edit: ok, du brauchst nur 6 Zahlen, dann wäre das etwas aufwending, ginge aber auch: am Ende nur die ersten 6 Zahlen nehmen)
-----------

fange mit Zufallszahlen 1-6 an, nicht mit 1-49!

 

[KoelOpa]

Ich komme und komme einfach nicht drauf.

public boolean arrayFuell(boolean[] b, int index)
  {
    try{
      if(b[index]) return false;
      else b[index] = true;
    }
    catch(ArrayIndexOutOfBoundsException e)   {}
    return true;
  }
  
  public boolean pruefeArray()
  {
    for(byte i = 0; i < lottozahl.length; i++)
    {
      boolean[] arr = new boolean[6];
      if(!arrayFuell(arr, lottozahl[i]-1)) return false;
    }
    
    return true; //kein Fehler, also keine doppelte Zahl
  }

Habe diese beiden Methoden geschrieben, damit ich nach einer doppelten Zahl suche und gegebenfalls das ausbesser. Aber es will nicht!!!!!!!!!!!!!!!!!

Kann mir keiner einen Code schreiben, der mit sagt ob im Array 2 gleiche Zahlen sind und wenn ja, dann soll er mir die gefundene (letztere Zahl ausbessern...) ?...

 

[Guest]

Hast Du den Post von SlaterB gelesen? Seine Lösung ist einfach und sauber:

viel einfacher: fülle das Array mit den Zahlen 1-49 in Reihenfolge
und benutze Collections.shuffe(list) [...] am Ende nur die ersten 6 Zahlen nehmen

Ich habe das eben kurz implementiert, so schaut's aus:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Lottozahlen
{
	private static final int ZIEHEN = 6;
	private static final int INSGESAMT = 49;

	public static void main(String[] args)
	{
		// Die Zahlen 1-49 in einer Liste abspeichern
		List<Integer> zahlen = new ArrayList<Integer>(INSGESAMT);
		for (int i = 1; i <= INSGESAMT; ++i)
			zahlen.add(i);

		// Sicherstellen, dass man die richtigen Zahlen drin hat
		assert !zahlen.contains(0);
		assert zahlen.contains(1);
		assert zahlen.contains(49);
		assert !zahlen.contains(50);

		// Die Liste durchmischen
		Collections.shuffle(zahlen);

		// Die ersten sechs Zahlen übernehmen und sortieren
		int[] lottozahlen = new int[ZIEHEN];
		for (int i = 0; i < ZIEHEN; ++i)
			lottozahlen[i] = zahlen.get(i);
		Arrays.sort(lottozahlen);

		// Und das Ergebnis auf dem Bildschirm ausgeben
		for (int l : lottozahlen)
			System.out.println(l);
	}
}

Fred

 

[Leroy42]

import java.util.*;


public class Lottozahlen {
	static final int ANZ=6;
	static final Random rand = new Random();
	int[] ziehung() {
		int[] zahlen = new int[ANZ];
		boolean nochmal;
		for (int i=0; i < ANZ; ++i) {
			do {
				zahlen[i] = rand.nextInt(49)+1;
				nochmal = false;
				for (int j=0; j < i; ++j)
					if (zahlen[j] == zahlen[i]) {
						nochmal = true;
						break;
					}
			} while (nochmal);
		}
		return zahlen;
	}
	public static void main(String[] args) {
		System.out.println(Arrays.toString(new Lottozahlen().ziehung()));
	}
}

Zum Testen kannst du ja mal

zahlen[i] = rand.nextInt(49)+1;

durch

zahlen[i] = rand.nextInt(6)+1;

ersetzen.

 

[Guest]

Was würdest Du sagen: welcher der beiden Lösungsvorschläge ist einfacher lesbar und weniger fehleranfällig?

 

[Leroy42]

Was würdest Du sagen: welcher der beiden Lösungsvorschläge ist einfacher lesbar

Geschmackssache. Gast's Lösung finde ich persönlich ein
wenig overdosed.

und weniger fehleranfällig?

LOL! Da brauch ich wohl nichts dazu sagen.

 

[Leroy42]

Bei 1 000 000 maligen Durchlauf benötigt mein Code im
Durchschnitt 2.142 Millisekunden, Gast's Code (ohne asserts)
14.051 Millisekunden; ist also fast 7-mal so langsam

 

[Leroy42]

Bei 1 000 000 maligen Durchlauf benötigt mein Code im
Durchschnitt 952 Mikrosekunden, Gast's Code (ohne asserts)
14.051 Millisekunden; ist also 14-mal so langsam

 

[Guest]

Bei 1 000 000 maligen Durchlauf benötigt mein Code im
Durchschnitt 2.142 Millisekunden, Gast's Code (ohne asserts)
14.051 Millisekunden; ist also fast 7-mal so langsam

Wen interessiert denn die Geschwindigkeit? Geht es darum, eine Millionen Lottoziehungen zu machen? Wer würde sowas tun? Hier ist es wirklich sinnvoller, lesbaren Code zu produzieren.

Aber bitte, Du hast es nicht anders gewollt Folgende Lösung ist nochmal 25% schneller als Deine:

import java.util.Random;

public class Lottozahlen
{
	private static final int ZIEHEN = 6;
	private static final int INSGESAMT = 49;
	private static final int DURCHLÄUFE = 1000000;

	public static void main(String[] args)
	{
		int zahlen[] = new int[INSGESAMT];
		for (int i = 0; i < INSGESAMT; ++i)
			zahlen[i] = i + 1;

		int[] lottozahlen = new int[ZIEHEN];
		Random rand = new Random();
		Benchmark bm = new Benchmark();

		bm.start();
		for (int n = 0; n < DURCHLÄUFE; ++n)
		{
			for (int i = 0; i < ZIEHEN; ++i)
			{
				int s = rand.nextInt(INSGESAMT - i) + i;
				int t = zahlen[i];
				lottozahlen[i] = zahlen[i] = zahlen[s];
				zahlen[s] = t;
			}
		}
		bm.stop("Fred");

		for (int l : lottozahlen)
			System.out.println(l);

		bm.start();
		for (int n = 0; n < DURCHLÄUFE; ++n)
		{
			boolean nochmal;
			for (int i = 0; i < ZIEHEN; ++i)
			{
				do
				{
					lottozahlen[i] = rand.nextInt(INSGESAMT) + 1;
					nochmal = false;
					for (int j = 0; j < i; ++j)
						if (lottozahlen[j] == lottozahlen[i])
						{
							nochmal = true;
							break;
						}
				} while (nochmal);
			}
		}
		bm.stop("Leroy");

		for (int l : lottozahlen)
			System.out.println(l);
	}
}

*** Fred: 464 ms
23
34
3
22
10
47
*** Leroy: 582 ms
3
5
48
42
31
27

Wichtig: das Array mit den 49 Elementen wird nur 1x gefüllt und nicht 1.000.000 Mal! Sonst wäre der Overhead zu gross und der Vorsprung weg.

Je mehr Zahlen man zieht, desto besser ist meine Lösung im Vergleich zu Deiner. Bei 49 aus 49 (was natürlich Schwachsinn ist) ist das Verhältnis 3 Sekunden zu 30 Sekunden.

Fred

 

[Leroy42]

...

LOL

Haben wir an einem Samstag-Nachmittag, bei diesem Wetter, wirklich
nichts besseres zu tun, als uns die Mikrosekunden um die Ohren zu schlagen?


Aber ich gebe zu, das die Nutzung von "overdosed" Methoden bei
solch einer Mini-Aufgabe doch Sinn macht.

Kann zu meiner Entschuldigung nur vorbringen, das ich noch
aus einer Zeit stamme, wo Code-Schnipsel wie

String s = "irgendwas";
for (int i=0; i < s.length(); i++)
    ...

mir von meine Prof um die Ohren gehauen worden wäre.

Irgendwas ist wohl hängengeblieben; der obige Code
bereitet mir zumindest noch Bauchgrummeln.

 

[Guest]

Kann zu meiner Entschuldigung nur vorbringen, das ich noch aus einer Zeit stamme, wo Code-Schnipsel wie [...] mir von meine Prof um die Ohren gehauen worden wäre.

Und mit welcher Begründung? Das es ineffizient ist, sich jedesmal die Länge zu holen? Dann schreibt man halt:

for (int i = 0, n = s.length(); i < n; ++i)

Aber auch das ist eine lächerliche Optimierung, die den Code schwieriger lesbar macht. OK, der Overhead ist bei einer leeren Schleife gute 50%, aber ein leerer Schleifenkörper ist ja schon mal arg unrealistisch. Wenn man im Schleifenkörper irgendwas sinnvolles macht, z.B. das aktuelle Zeichen zu einer Variable aufaddiert, etwa so:

for (int i = 0; i < s.length(); ++i)
{
	x = x + s.charAt(i);
}

dann geht der Unterschied schon auf 25% runter. Und jetzt nimm eine Schleife mit 10 Anweisungen im Körper, da spürst Du vom Overhead gar nichts mehr.

Wer es besonders schnell und unleserlich mag verwendet folgende Variante:

for (int i = s.length(); --i >=0;)
{
	x = x + s.charAt(i);
}

Aber: Lesbar und wartbar ist fast immer wichtiger als 1% schneller!

Fred

 

[Guest]

Ach so, am besten leserlich finde ich folgende Möglichkeit:

for (char c : s.toCharArray())
{
	x = x + c;
}

Die braucht 4x so lange wie die schnellste Variante (weil das dem String zugrundeliegende char-Array kopiert werden muss), ist dafür meines Erachtens aber besser lesbar und weniger fehleranfällig.

Noch schöner wäre es natürlich, wenn String das Interface Iterable<Char> implementieren würde, dann könnte man einfach schreiben:

for (char c : s)
{
	x = x + c;
}

Schade, dass es so nicht geht. Ah man can dream though... a man can dream.

Fred

 

[Leroy42]

Wenn man im Schleifenkörper irgendwas sinnvolles macht, z.B. das aktuelle Zeichen zu einer Variable aufaddiert, etwa so:

for (int i = 0; i < s.length(); ++i)
{
	x = x + s.charAt(i);
}

Das nennst du sinnvoll? :shock:

x = x + s.charAt(i);

Wenn du die Effizienz schon in so einem kleinen Beispiel-Code vernachlässigst, dann
will ich nicht wissen, was du in größeren Programmen so zusammencodest. ???:L

besser lesbar und weniger fehleranfällig.

Weshalb schiebst du immer weniger fehleranfällig aufs Trapez. :shock:

Ein Code muss fehlerfrei und nicht weniger fehleranfällig sein! :meld:

 

[Guest]

Wenn du die Effizienz schon in so einem kleinen Beispiel-Code vernachlässigst, dann
will ich nicht wissen, was du in größeren Programmen so zusammencodest. ???:L

Das ist ja gerade der springende Punkt. In großen Projekten sind solche Mikro-Optimierungen mit linearem Zeitfaktor irrelevant. Hier kommt es in erster Linie auf die Wahl der richtigen Datenstrukturen und Algorithmen an. Wenn Du ein Problem von O(n) auf O(log n) bringen kannst ist sowas wie "4x schneller" nicht mehr relevant.

Code in großen Projekten muss a) verstanden und b) erweitert werden. Da sind unleserliche Mikro-Optimierungen nur hinderlich. Außerdem: 90% der Prozessorzeit werden in 10% des Codes verbraucht. Deswegen lohnt es sich nicht, manhours in die Optimierung von Code zu stecken, der fast nie ausgeführt wird.

Wenn die Messung zeit, dass irgendwo in Deinem System ein Flaschenhals ist, dann solltest Du den entsprechenden Code NATÜRLICH optimieren. Aber eben nicht vorher.

Premature Optimization is the root of all evil.

Ein Code muss fehlerfrei und nicht weniger fehleranfällig sein! :meld:

Ich meine fehleranfällig in Bezug auf Wartbarkeit.

Fred

 

[KoelOpa]

Schön und gut, aber kann ich da nicht ne Methode ich selber schreiben (und jetzt nicht schreiben, ja dann machs doch :roll: würds ja gern, aber geht nicht...). Denn ein Paket importieren und dann das damit zu machen is ja wohl die simpelste Version...

 

[Guest]

Denn ein Paket importieren und dann das damit zu machen is ja wohl die simpelste Version...

Ich hatte doch schon einen brauchbaren Quelltext gepostet. Aber gut, hier ist er noch ausgefeilter, extra für Dich:

import java.util.Random;

public class Lottozahlen
{
	private static final int ZIEHEN = 6;
	private static final int INSGESAMT = 49;

	private static final int[] kugeln;
	private static final Random rand;
	
	static
	{
		kugeln  = new int[INSGESAMT];
		for (int i = 0; i < INSGESAMT; ++i)
			kugeln[i] = i + 1;
		rand = new Random();
	}

	public static int[] zieheLottozahlen()
	{
		int[] lottozahlen = new int[ZIEHEN];

		for (int i = 0; i < ZIEHEN; ++i)
		{
			int swap = rand.nextInt(INSGESAMT - i) + i;
			int temp = kugeln[i];
			lottozahlen[i] = kugeln[i] = kugeln[swap];
			kugeln[swap] = temp;
		}
		return lottozahlen;
	}

	public static void main(String[] args)
	{
		for (int x : zieheLottozahlen())
			System.out.println(x);
	}
}

Gruss,
Fred