wie kann ich beim ziehen von 6 randomzahlen verhindern dass eine zahl 2 mal gezogen wird daber aber nicht immer wieder zwischen 1 und 49 ziehen? (weil beim normalen lotto zieht man ja auch zwischen 1 und 49)

verlangt ist also dass die bereits gezogene zahl aus der randomfunktion sozusagen abgezogen wird, sodass man 48 verschiedene ziehmöglichkeiten hat(die zahlen aber im endeffekt trotzdem von 1 bis 49 gehen, nur dass die bereits gezogene zahl nicht mehr drin ist)

lg lolo

std::vector<int> vec;
// alle Werte ablegen
for (int i = 1; i <= 49; ++i)
   vec.push_back(i);

// durchwürfeln
srand(time(NULL));
std::random_shuffle(vec.begin(), vec.end());

// neuer vector fürs Ergebnis
std::vector<int> result;
result.resize(6);

// die ersten 6 Elemente des ersten in den zweiten Vector kopieren und sortieren
std::copy(vec.begin(), vec.begin() + 6, result.begin());
std::sort(result.begin(), result.end());

// ausgeben
for (std::vector<int>::iterator iter = result.begin(); iter != result.end(); ++iter)
   std::cout << *iter << " ";
std::cout << std::endl;

...

// neuer vector fürs Ergebnis
std::vector<int> result;
result.resize(6);

// die ersten 6 Elemente des ersten in den zweiten Vector kopieren und sortieren
std::copy(vec.begin(), vec.begin() + 6, result.begin());

...

Das könnte man noch abkürzen:

std::vector<int> result (vec.begin(),vec.begin()+6);

#include<vector>
#include<iostream>
#include<cstdlib>
#include<cstddef>
#include<ctime>

using namespace std;

const int minimum = 1;
const int maximum = 49;
const size_t anzahl = 6;

int main()
{
  // Abbildung zwischen Zufallswerten und gezogenen Zahlen
  vector<int> zahlen;

  // Füllen:
  for (int i=minimum; i<=maximum; ++i) zahlen.push_back(i);

  // Zufallszahlen ziehen:
  srand ( time(0) );
  for (size_t i=0; i<anzahl; ++i)
    {
      // Zufallszahl im Intervall [0, zahlen.size()]
      int random = rand() % (zahlen.size()); 
      cout << i+1 << ". Zahl: " << zahlen[random] <<endl;
      // Gezogenes Element aus der Liste löschen:
      zahlen[random] = zahlen.back(); 
      zahlen.pop_back();
    }
}

Wie wäre es die Zahlen einfach in einem std::set zuspeichern, das läst nur einzigartige Werte zu.
Und dann ziehst du einfach so lange Zahlen, bis die Größe gleich 6 ist.
http://www.cplusplus.com/reference/stl/set/

Das kann aber im worst case unendlich lange dauern.

Das kann aber im worst case unendlich lange dauern.

Formal gesehen richtig, aber welche Zahl muss man an srand übergeben damit rand immer die gleiche Zahl liefert?

Und wäre das nicht ein Paradoxon des Zufalls, dass der Zufall zufällig regelmäßig ist?

SeppJ schrieb:

Und wäre das nicht ein Paradoxon des Zufalls, dass der Zufall zufällig regelmäßig ist?

Nein, das wäre sogar außergewöhnlich, wenn es nie vorkäme.

Nein, das wäre sogar außergewöhnlich, wenn es nie vorkäme.

ja stimmt ist mir auch aufgefallen.

Aber könnte man nicht alle X Fehlziehungen nochmal srand mit der aktuellen Zeit aufrufen um dieses Problem zu lösen?

SeppJ schrieb:

Nein, das wäre sogar außergewöhnlich, wenn es nie vorkäme.

ja stimmt ist mir auch aufgefallen.

Aber könnte man nicht alle X Fehlziehungen nochmal srand mit der aktuellen Zeit aufrufen um dieses Problem zu lösen?

kann man - aber was spricht denn gegen die schon gepostete lösung?