Les nombres aléatoires d'un ordinateur sont tous des nombres pseudo-aléatoires, c'est-à-dire qu'ils sont générés par une petite séquence polynomiale M. Chaque petite séquence générée possède une valeur initiale, à savoir la graine aléatoire. (Remarque : la période de la petite séquence polynomiale M est de 65535, c'est-à-dire que la période des nombres aléatoires générés à chaque fois à l'aide d'une graine aléatoire est de 65535. Lorsque vous obtenez 65535 nombres aléatoires, ils se répètent à nouveau.)
Nous savons que la fonction rand() peut être utilisée pour générer des nombres aléatoires, mais ce n'est pas un nombre aléatoire au sens propre ; c'est un nombre pseudo-aléatoire. Il s'agit d'une série de nombres calculés à partir d'un nombre (que nous pouvons appeler une graine) à l'aide d'une certaine formule de récurrence. Lorsque cette série de nombres est très grande, elle suit une distribution normale, ce qui équivaut donc à générer des nombres aléatoires, mais ce n'est pas un vrai nombre aléatoire. Lorsque l'ordinateur démarre normalement, la valeur de cette graine est fixe, à moins que vous ne cassiez le système.
1.rand()
Fonction :
Générateur de nombres aléatoires
Utilisation :
int rand(void)
Fichier d'en-tête :
stdlib.h
L'implémentation interne de rand() utilise la méthode de congruence linéaire. Ce n'est pas un vrai nombre aléatoire, mais comme sa période est particulièrement longue, il peut être considéré comme aléatoire dans une certaine plage.
rand() renvoie une valeur aléatoire dans l'intervalle allant de 0 à RAND_MAX. La plage de RAND_MAX est au moins 32767 (int). Avec unsigned int, elle est de 65535 pour deux octets, et la plage d'entiers est de 4294967295 pour quatre octets. Chaque nombre de 0 à RAND_MAX a la même probabilité d'être choisi.
Lorsque l'utilisateur ne définit pas la graine de nombres aléatoires, la graine de nombres aléatoires par défaut du système est 1.
rand() produit des nombres pseudo-aléatoires, qui sont les mêmes à chaque exécution ; pour les rendre différents, utilisez la fonction srand() pour l'initialiser.
2.srand()
Fonction :
Initialise le générateur de nombres aléatoires
Utilisation :
void srand(unsigned int seed)
Fichier d'en-tête :
stdlib.h
srand() sert à définir la graine de nombres aléatoires lorsque rand() génère des nombres aléatoires. Le paramètre seed doit être un entier. Si seed est défini sur la même valeur à chaque fois, le nombre aléatoire généré par rand() sera le même à chaque fois.
3. Utiliser l'horloge actuelle comme graine de nombres aléatoires
Les nombres aléatoires générés par rand() sont les mêmes qu'à l'exécution précédente à chaque fois qu'il s'exécute. Pour les rendre différents, utilisez la fonction srand() pour l'initialiser. Vous pouvez utiliser la méthode srand((unsigned int)(time(NULL)) pour générer différentes graines de nombres aléatoires, car l'heure de chaque exécution du programme est différente.
4. Utilisation pour générer des nombres aléatoires
- 1) Fournissez une graine à srand(), qui est de type unsigned int ;
- 2) Appelez rand(), qui renverra un nombre aléatoire (entre 0 et RAND_MAX) basé sur la valeur de graine fournie à srand() ;
- 3) Appelez rand() plusieurs fois selon les besoins, obtenant ainsi continuellement de nouveaux nombres aléatoires ;
- 4) À tout moment, vous pouvez fournir une nouvelle graine à srand(), ce qui permet de "randomiser" davantage la sortie de rand().
Programme pour des nombres aléatoires entre 0 et RAND_MAX
#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;
int main()
{
srand((unsigned)time(NULL));
for(int i = 0; i < 10;i++ )
cout << rand() << '/t';
cout << endl;
return 0;
}
5. Formule générale pour générer des nombres aléatoires dans une certaine plage
Pour obtenir un entier aléatoire dans [a,b), utilisez (rand() % (b-a)) + a ;
Pour obtenir un entier aléatoire dans [a,b], utilisez (rand() % (b-a+1)) + a ;
Pour obtenir un entier aléatoire dans (a,b], utilisez (rand() % (b-a)) + a + 1 ;
Formule générale : a + rand() % n ; où a est la valeur de départ et n est la plage d'entiers.
Pour obtenir un entier aléatoire entre a et b, une autre représentation : a + (int)b * rand() / (RAND_MAX + 1).
Pour obtenir un nombre à virgule flottante entre 0 et 1, vous pouvez utiliser rand() / double(RAND_MAX).
Lien original : https://blog.csdn.net/hgl868/article/details/7057843