# einmalige Zufallszahlen erstellen



## drveni88 (30. Nov 2009)

Hallo ich möchte gern ein Array mit zufälligen Zahlen erstellen um es später sortieren zu können. Jetzt möchte ich aber das jede zufällige Zahl nur ein einziges mal vorkommt. 
Hab das mal selber versucht, aber irgendwie kommen einige Zahlen doch öfter vor als nur einmal 

Ihr wisst doch bestimmt wieso 
Also könnte jemand bitte sagen wo mein Fehler ist, oder wie ich das ganze etwas eleganter Programmieren könnte.

[Java]
class ZufallsReihung {
	private final int maxZahl= 200;

    public final int[] getZufallsZahlen(int anzahl){
		 int[] zufall_reihung = new int[anzahl];
		 Random zahlen = new Random();

		 for(int i=0; i<zufall_reihung.length; i++){
			 for (int k=0; k<=i; k++){
				 if (zahlen.nextInt(maxZahl)!=zufall_reihung[k]){
					 zufall_reihung_ = zahlen.nextInt(maxZahl);
				 }else{
					 i--;
				 }
			 }
	 	 }
	    return zufall_reihung;
    }// Ende zufallszahlen
} // class ZufallsReihung[/code]

mfg_


----------



## eRaaaa (30. Nov 2009)

drveni88 hat gesagt.:


> oder wie ich das ganze etwas eleganter Programmieren könnte.



hmm, keine ahnung, vllt mit nem hashset ?

[Java]
	public static void main(String... args) {
		for (int i : getZufallsZahlen(20, 200)) {
			System.out.println(i);
		}
	}

	public static Integer[] getZufallsZahlen(int anzahl, int max) {
		Set<Integer> tmpSet = new HashSet<Integer>();
		Random r = new Random(); 
		while (tmpSet.size() != anzahl) {
			tmpSet.add(r.nextInt(max) + 1);
		}
		return tmpSet.toArray(new Integer[anzahl]);
	}
[/code]


----------



## Prismapanda (30. Nov 2009)

wenn der maximalwert nicht allzu groß ist, geht vielleicht auch folgendes:


```
List<Integer> ints = new ArrayList<Integer>();
//Liste aller möglichen Zahlen aufbauen
for (int i = 0; i <= max; i++ {
   ints.add(i);
}
//Liste shufflen
Collections.shuffle(ints);

//Array mit Werten füllen
int[] target = new int[anzahl];
for (int i = 0; i < anzahl; i++) {
   target[i] = ints.get(i);
}

return target;
```

mal so locker hingeschrieben und ungetestet...

EDIT: ahja, dein Fehler liegt in der Abfrage in Zeile 10. So, wie du es schreibst reicht es, wenn ein Element der Liste nicht gleich dem neuen Zufallswert ist (wobei der Zufallswert  bei jeder Abfrage auch immer ein anderer ist oO), um die Stelle k zu setzen.Du müsstest halt einen Zufallswert generieren lassen und dann im Array schauen, ob er nicht drin ist und erst dann (!) wenn kein Element gleich dem generierten Zufallselement ist, darf das Element reingesetzt werden. Eine Liste würde sich für diese Umsetzung besser eigenen, da sie z.B. die Methode contains beinhaltet, die genau das schon macht. Aber performancetechnisch besser wäre das genannte HashSet


----------



## javimka (1. Dez 2009)

Du könntest die Zahlen schön in einer Reihenfolge aufschreiben und dann mit dem Zufallsgenerator jeweils Paare von Zahlen miteinander vertauschen. Wenn dein maxZahl 200 ist, kannst du ja kein soooo grosses Array haben. Ist nicht so kompliziert zu programmieren, wird schnell laufen und erfüllt seinen Zweck. Quick-and-dirty


----------



## drveni88 (1. Dez 2009)

Dankeschön, sind ja richtig schöne Ideen.


----------



## Marco13 (1. Dez 2009)

Insbesondere ist das letzte auch ... determiniert (das erste haut's raus, wenn die erste Zahl größer ist als die zweite  )


----------



## eRaaaa (1. Dez 2009)

Marco13 hat gesagt.:


> das erste haut's raus, wenn die erste Zahl größer ist als die zweite



autsch, das hab ich nicht bedacht 
naja spätestens beim 2. test hätte man sich gefragt, wieso das kein ende nimmt :bae:


----------



## Marco13 (1. Dez 2009)

Selbst wenn man diesen Fall abfragt: Wenn man z.B. 999999 zufällige Zahlen von 1000000 möglichen haben will, wird er früher oder später (eher später) 999998 Zahlen haben, und bis er dann die letzte (der beiden noch möglichen zufälligen) Zahlen gewählt hat, kann es schon sein, dass er ein paar Millionen mal (!) eine Zahl wählt, die schon in der Ergebnismenge enthalten ist.... und man kann nicht mal beweisen, DASS er überhaupt irgendwann diese Zahlen finden wird.

Ich glaube, rein formal ist es alles andere als einfach, dafür einen determinierten Algorithmus zu schreiben. Wenn man k einmalige Zahlen aus einer Menge von n möglichen Zahlen auswählen will (mit k<=n), kann man 
- Die n Zahlen speichern, shufflen und k stück auswählen -> Braucht viel (O(n)) speicher, schlecht bei großen n
- Zufällige Zahlen wählen und in ein Set packen, bis es k Stück sind -> Braucht potentiell unendlich lange (und umso länger, je näher k an n liegt)

:bahnhof:


----------



## bygones (1. Dez 2009)

Marco13 hat gesagt.:


> - Die n Zahlen speichern, shufflen und k stück auswählen -> Braucht viel (O(n)) speicher, schlecht bei großen n
> - Zufällige Zahlen wählen und in ein Set packen, bis es k Stück sind -> Braucht potentiell unendlich lange (und umso länger, je näher k an n liegt)
> 
> :bahnhof:


wobei speicher meistens das geringere problem gg laufzeit ist.


----------



## Schrubber (1. Dez 2009)

```
import java.io.*;

public class Sortieren {
	
	public static void main(String[] args) throws IOException 
	{
		Eingabe();
		Sortieren();
		Ausgabe();
	}

	static void Eingabe()
	{
BufferedReader in = new BufferedReader(
new InputStreamReader(System.in));

System.out.println("Wieviele Zahlen sollen generiert werden?");
int anzahl = Integer.parseInt(in.readLine());
int [] zahl = new int [anzahl];
for(int i=0;i<anzahl.length-1;i++)
{
zahl[i] = Math.random();
}

	}
	
	static void Sortieren()
	{
		int h;
		
		for (int i = 0; i < Zahl.length-1;i++)
		{
			if (Zahl[i] > Zahl[i+1])
			{
				h = Zahl[i+1];
				Zahl[i+1] = Zahl[i];
				Zahl[i] = h;
				i = -1;
			}
		}
	}
	static void Ausgabe()
	{
		System.out.println("Zahlen sortiert: ");
		for (int i = 0; i < Zahl.length; i++)
		{
			System.out.print(Zahl[i] + ", ");
		}
	}
}
```

Das sollte eigentlich soviele Zufallszahlen erstellen, wie vorher eingegeben und diese dann folgend sortieren und ausgeben. Falls dort irgendwelche Fehler drin sein sollten, bitte sagen. Hab das Script ausm Kopf geschrieben :S


----------



## Marco13 (1. Dez 2009)

Abgesehen davon, dass die Zahlen nicht einmalig und die Sortierung langsam und umständlich ist... Ja...


----------

