Code schneller machen

[a400]

N'abend, ich hab da ein Problem mit meinem Code, der recht zäh arbeitet.

Und zwar geht es um folgendes. Ich generiere mir 2 Zahlen mittels der srand()-Funktion und prüfe dann, ob ich mir genau diese 2 Zahlen in dieser Kombination schon mal gegeben wurden. Dazu speichere ich mir jede erstellte Zahlenkombination in einem Array ab und durchsuche dieses dann nach den aktuell generierten Zahlen. Also kleines Beispiel,
In dem Array steht schon: 8/2, 3/5, 1/8, 5/8, 7/9, 2/6, ........
Jetzt hab ich mir die Zahlen generiert 5/8 --> Ergebnis ist, dass die Zahlen schon drin sind im Array, deshalb muss ich mir neue generieren. Da kommt jetzt das Problem auf, ich brauche immer Zahlen im Raum zwischen 1 bis 10 und da gibt es ja nun mal nur 100 Kombinationen und ich muss mindestens 95% Prozent der Kombinationen schaffen.
Also wie kann ich den Code hinsichtlich der Generierung schneller machen, wenn schon sehr viele Kombinationen vergeben sind? Kann mir da jemand helfen?

Ich poste hier mal ein bissle Code dazu

 // generiert Zufallszahl
 int zufallszahl(int min, int max) 
 { 
 	srand((unsigned int)time(0));
 
 	int zahl = min + (rand()%(max-min+1));
 	Sleep(zufallszahl2(333, 1111));
 		return zahl;
 
 //Pruefe das Array, ob die Zahlen schon drin sind
 bool pruefe_arrays(int x_wert, int y_wert)
 {
 // hier sucht er danach und liefert wenn gefunden true zurück, und false bei noch nicht enthalten
 }
 
 // Eigentliche Funktion, die alle Funktionen kombiniert
 void findeNeueZahlen()
 {
 // wie schaff ich es jetzt, dass er hier wenn ein Wert gefunden wurde, der schon vorhanden ist, nicht x mal neu generiert wird? Da das bei fortgeschrittener Zahlengenerierung schon einmal 3 Minuten dauern kann, bis eine Kombination gefunden wurde, die es noch nicht gibt
 			do
 			{
 				xWert = zufallszahl(1, 10); 
 				yWert = zufallszahl(1, 10); 
 				wert =pruefe_arrays(xWert, yWert);
 			}
 			while(!wert);
 }

 

[C Coder]

Wenn du das schneller haben willst, würde ich dir als Erstes raten das Sleep() in der Funktion zufallszahl() rauszunehmen.

Warum willst du das Array mit Zufallszahlen füllen? Geht nicht einfach eine Schleife (bzw 2)?

int counter=0;
for(int i=0;i<10;i++)
  for(int n=0;n<10;n++) 
  {
    x_Werte[counter]=i;
    y_Werte[counter]=n;
    counter++
  }

Dann hast du sicher alle Zahlenpaare!

 

[a400]

Hi ertsmal danke für die Antwort, aber das Sleep hat da seinen Grund, da ich die Zahlen mit Hilfe der Systemzeit generiere. Wenn ich da nicht die paar Milisekunden warte, liefert die Funktion immer wieder die gleichen Zahlenpaare zurück, da in der gleichen Sekunde die Funktion wieder aufgerufen wird. Durch das Sleep wird bewirkt, dass ein Bruchteil der Sekunde vergeht im Computer und somit eine neue Zeit generiert wird.

Diese Zahlen brauche ich, da es sich um Koordinaten handelt für eine Funktion für ein Schiffe-versenkenspiel, und wenn ich das zu logisch angehe, also einfach alle Zahlenkombinationen hochzähle, ist der Computer zu einfach zu durchschauen, wo er als nächstes hinschießen wird.... das ist das dumme.

 

[jsendrow]

Die ZUfallszahlen werden aber nicht zufälliger nur weil Du jedesmal eine neue Seed setzt. Es reicht im Grunde nur einmal srand aufzurufen, dann erzeugt rand in Folge eine pseudo-zufällige Zahlenkette. Da bei jedem Neustart eine andere Systemzeit für srand benutzt wird hast Du dann auch jedesmal eine andere Zahlenfolge.

 

[Nospherates]

Hi,
also Code kann ich nun nicht bieten aber vielleicht eine Idee. Ich hatte ein ähnliches Problem mal bei dem Versuch Spielpläne zu generieren (auch wenn das noch ein Stück komplexer war). Damit du nicht ständig die selben Zahlen erhälst solltest du vielleicht auf dynamische Speicherveraltung zurückgreifen. Verkettete Listen, Vectoren oder ähnliches.
Dann füllst du zu Beginn diesen Datencontainer mit den Koordinaten und anschließend lässt du jede Runde eine Schleife über alle Koordinaten laufen. Random setzt du nun nicht ein um die Koordinate direkt zu erwischen, sondern du sagst zB ich nehm einen Bereich von 1-100 und sobald die Zufallszahl 90 oder so erreicht wird, wird die Koordinate genommen die im aktuellen Schleifendurchgang angezogen wurde. Heißt du generierst jeden Schleifendurchgang eine Zahl, die dann darüber entscheidet ob die Koordinate genommen wird.
Wenn diese Koordinate nun genommen wird schmeißt du die Koordinate aus dem Container raus und die Schleife wird für den nächsten Zug um einen Durchlauf verringert. Dadurch hast du auf jedenfall bei jedem Treffer eine Koordinate die noch nicht verwendet wurde.
Hoffe das ist jetzt halbwegs verständlich gewesen, wäre mein Ansatz für die Sache.

Gruß

[Edit] Die Schleife sollte natürlich von vorne beginnen wenn keine Randomzahl erzielt wurde die der Bedingung entspricht [/Edit]

 

[a400]

Hi Nospherates,

danke für diesen Lösungsvorschlag, ich werd mal versuchen etwas in der Richtung hier zu erzeugen, mal schauen ob ich das hinbekomme. Danke