[C++] Losowanie bez powtórzeń

Siemka piszę program i chciałem się dowiedzieć jak zaprogramować żeby przypisywało mi losowo do kolejnych zmiennych np. a,b,c liczby z zakresu od 2 do 53 przy czym liczby te nie mogą się powtarzać a tych zmiennych ma być 10 czyli powiedzmy a = 13, b=42, ..., j=29. Próbowałem użyć do tego funkcji rand() ale ona za każdym razem losuje z tego samego zakresu. Może ktoś zna jakąś funkcję na losowę przestawienie elementów zbioru czyli zbiór liczb całkowitych od 2 do 53. Wtedy pierwsze dziesięć elementów zapisać do zmiennych i już. Proszę o odpowiedź .

Najprostsze co mi przychodzi do głowy to losować dopóki się nie powtarza z żadna inną.

było, ale nie mogę zaleźć:

std::vector<int> losujBezPow(int ile, int z) {
      std::vector<int> result;
      for(int i = 0; i<ile; ++i) {
           int x = rand()%z;
           while(std::count(result.begin(), result.end(), x) != 0) {
                x = rand()%z; //losuj ponownie jeśli liczba już była
           }
           result.push_back(x);
      }

      return result;
}

sposobów jest więcej i mają one swoje zalety i wady. Powyższy sposób jest ok, gdy ile jest dużo mniejsze od z.

Mam jeszcze pytanko: Czy w deklaracji jakiejś nowej funkcji mogę używać innych funkcji przykładowo funkcji min()? Bo jakoś jak próbuję to nie mogę tego zrobić bez błędu. I drugie pytanie czy funkcje w c++ które wykrywają najmniejszą i największą liczbę z podanych to odpowiednio:
min(int a, int b)
max(int a,int b)?

1. Tak
2. Tak: w <algorithm>
   http://www.cplusplus.com/reference/algorithm/max/
   http://www.cplusplus.com/reference/algorithm/min/
   przy czym korzystają z operatora<()

Dzięki za odpowiedź, napisałem teraz taką funkcję i w każdej linice kodu z fukcją min_element jest jakiś błąd wyskakuje komentarz no matching function for call to `min_element(int&, int&, int&, int&, int&)' Chciałbym żeby ktoś napisał gdzie jest błąd i wytłumaczył.

int poker(int a,int b,int c,int d,int e) {
int uklad=0;
int aa=a%13;
int bb=b%13;
int cc=c%13;
int dd=d%13;
int ee=e%13;
int sila;
if (aa==bb) { uklad+=1000;}
if (aa==cc) { uklad+=1000;}
if (aa==dd) { uklad+=1000;}
if (aa==ee) { uklad+=1000;}
if (cc==bb) { uklad+=1000;}
if (dd==bb) { uklad+=1000;}
if (ee==bb) { uklad+=1000;}
if (cc==dd) { uklad+=1000;}
if (cc==dd) { uklad+=1000;}
if (dd==ee) { uklad+=1000;}
if( (min_element(aa,bb,cc,dd,ee)=0)&&(aa+bb+cc+dd+ee==34)&&(uklad=0)&&((aa==1)||(bb==1)||(cc==1)||(dd==1)||(ee==1))) {uklad+=3500;}
if ((min_element(aa,bb,cc,dd,ee)=1)&&(aa+bb+cc+dd+ee==15)&&(uklad=0)) {uklad+=3500;}
if ((min_element(aa,bb,cc,dd,ee)=2)&&(aa+bb+cc+dd+ee==20)&&(uklad=0)) {uklad+=3500;}
if ((min_element(aa,bb,cc,dd,ee)=3)&&(aa+bb+cc+dd+ee==25)&&(uklad=0)) {uklad+=3500;}
if ((min_element(aa,bb,cc,dd,ee)=4)&&(aa+bb+cc+dd+ee==30)&&(uklad=0)) {uklad+=3500;}
if ((min_element(aa,bb,cc,dd,ee)=5)&&(aa+bb+cc+dd+ee==35)&&(uklad=0)) {uklad+=3500;}
if ((min_element(aa,bb,cc,dd,ee)=6)&&(aa+bb+cc+dd+ee==40)&&(uklad=0)) {uklad+=3500;}
if ((min_element(aa,bb,cc,dd,ee)=7)&&(aa+bb+cc+dd+ee==45)&&(uklad=0)) {uklad+=3500;}
if ((min_element(aa,bb,cc,dd,ee)=8)&&(aa+bb+cc+dd+ee==50)&&(uklad=0)) {uklad+=3500;}
if ((min_element(aa,bb,cc,dd,ee)=0)&&(aa+bb+cc+dd+ee==42)&&(uklad=0)) {uklad+=3500;};

}

A łaskawie nie potrafisz rzucić okiem w dokumentacje, do której podałem link?
min_element() ma dwa argumenty -> iterator na początek i na koniec przeszukiwanej "tablicy", a nie żadne 4 wartości.

Ja bym zaczął od nauki odróżniania '=' od '=='.

A ja bym Ci powiedział, że bazując na moim doświadczaniu, zastanów się z kim niby będziesz grać w tego pokera ??
Sztuczną inteligencje trudno napisać, chyba, że wszystko przesz na rand() między 3 ruchami Pas/Call/Rerise...

;]

Ja bym zaczął od nauki odróżniania '=' od '=='.

Przestań.. pascalowego myślenia trudno się pozbyć.

Yures chyba nie bardzo rozumiesz o jaki program mi chodzi. Chodzi mi o program, który liczyłby prawdopodobieństwo wygranej, czyli taki kalkulatorek. Takie kalkulatorki są dostępne dla odmiany pokera jaką jest Hold'em. Ale ja oprócz hold'em chce żeby mój program liczył omahe. Przybliże problem i podam przykład. Przypuśćmy, że w Hold'em dostałem QQ i przeszedłem z dwoma do następnej rundy. Po sposobie gry mogę mniej więcej domyślać się jakie mają karty. Jeśli sami przebijali mogą mieć bardzo dobre karty, dużo zależy od wcześniejszych obserwacji czyli jak często ktoś przebijał przed flopem. Jeśli to ja przebijałem również mogą mieć dobre karty, a w teorii pokera potrzeba lepszych kart do sprawdzenia przebicia niż do przebijania samemu. W każdym razie chciałbym zrobić program który po wpisaniu trzech dwukartowych układów i flopu (lub bez) obliczy mi prawdopodobieństwo wygranej.