Code beschleunigen

yogoo

Hallo, ich habe folgendes kleines Problem, der Code hier dauert ziemlich lange, wie kann ich ihn beschleunigen?
Und zwar macht der Code folgendes:
ich habe 2 Arrays, in die Zahlen eingefügt werden. Diese Zahlen, die ich mir generieren lasse, dürfen nicht an der selben Stelle in den Arrays stehen, wie neue, die ich mir generieren lasse
Kleines Beispiel dazu
Im Arrays stehen z.B.
xArray: 1,3,4,8
yArray: 1,5,6,8

jetzt sollen die nächsten Werte eingefügt werden und der Computer hat mir als nächstes 4,8 generiert, das darf aber so nicht rein, da ja genau diese Werte bereits zusammen an Position 2 der Arrays stehen.

Wie kann ich das jetzt beschleunigen, dass er schneller Werte generiert oder findet, die noch nicht in den Arrays zusammen enthalten sind?

Der Code schaut so aus:

int s = 100;
int arrayXwert[s];
int arrayYwert[s];

int zufallszahl(int min, int max) 
{ 
	srand((unsigned int)time(0));

	int zahl = min + (rand()%(max-min+1));
	Sleep(zufallszahl2(333, 1111));

	return zahl;
}

// Funktion zum Suchen von vorhanden Koordinaten in den Speicherarrays
bool suchen(int x_wert, int y_wert)
{
 for (int i = 0; i < arrayspeicherstelle; ++i) 
 {
  if (arrayXwert[i] == x_wert && arrayYwert[i] == y_wert) 

   return true;
 }

 return false;

}

void werte_einfuegen(int x_wert, int y_wert)
{
 arrayXwert[arrayspeicherstelle] = x_wert;
 arrayYwert[arrayspeicherstelle] = y_wert;
 arrayspeicherstelle++;
}

// Hauptfunktion, die sucht
bool pruefe_arrays(int x_wert, int y_wert)
{
 if (!suchen(x_wert, y_wert)) //also false
 {
  werte_einfuegen (x_wert, y_wert);
  return true;
 }
 else 
 {   
  return false;
 }

}

// Hauptfunktion zum die alles aufruft
void sucher()
{
 xWert = zufallszahl (1, 10); 
 yWert = zufallszahl(1, 10);

if(!pruefe_arrays(xWert, yWert)) //also Koordinaten sind schon beschossen, dann neue finden
 {

  // Werte neu bestimmen bis prufe_arrays true ergibt
  do
  {
	  if(xWert <= data->getDimension()
   xWert = zufallszahl(1, data->getDimension()); 
   yWert = zufallszahl(1, data->getDimension()); 
   wert =pruefe_arrays(xWert, yWert);
  }
  while(!wert);
  // also bis es true ist! und somit nicht in den Arrays enthalten
}

wenn jetzt viele Zahlenkombinationen schon vergeben sind, dauert das total lange, wie kann ich denn das beschleunigen, kennt jemand Abhilfe?

}

Ringding

yogoo schrieb:

xArray: 1,3,4,8
yArray: 1,5,6,8

jetzt sollen die nächsten Werte eingefügt werden und der Computer hat mir als nächstes 4,8 generiert, das darf aber so nicht rein, da ja genau diese Werte bereits zusammen an Position 2 der Arrays stehen.

Ponto

Es gibt ja maximal maxX*maxY paare. Du könntest ein zweidimensionales Array mitführen, das dir schnell anzeigt, ob ein paar bereits exisitiert. So ein Array bräuchte maxX*maxY/8 Bytes speicher.

Konfusius

da du ja in c++ programmierst kannst du auch stl-sets verwenden. da geht das aufsuchen eines eingetragenen elements auch recht schnell (wenn auch nicht so schnell, wie bei der von ponto beschriebenen metode).

außerdem vergrößern sets ihren speicher bei bedarf automatisch und sind einfach zu verwenden.

das eintragen eines neuen elements dauert allerdings etwas länger. da aber bei jedem auruf von sucher() nur ein element eingetragen wird, trägt das nicht zum anstieg der ausführungszeit bei.

#include<set>
#include<utility>

using namespace std;

set<pair<int,int> > koordinaten_set;

bool
pruefe_arrays (int x_wert, int y_wert)
{
  if(koordinaten_set.find(make_pair<x_wert,y_wert>)==koordinaten_set.end())
  {
    koordinaten_set.insert(make_pair<x_wert, y_wert>);
    return true;
  }
  else return false;
}