Comment générer de façon aléatoire un int en C?

La rand() fonction dans <stdlib.h> renvoie une pseudo-aléatoire entier compris entre 0 et RAND_MAX. Vous pouvez utiliser srand(unsigned int seed) pour définir une graine.

Il est de pratique courante d'utiliser les % opérateur en conjonction avec rand() pour obtenir une autre gamme (bien garder à l'esprit que cela déclenche l'uniformité un peu). Par exemple:

/* random int between 0 and 19 */
int r = rand() % 20;

Si vous vraiment de soins au sujet de l'uniformité, vous pouvez faire quelque chose comme ceci:

/* Returns an integer in the range [0, n).
 *
 * Uses rand(), and so is affected-by/affects the same seed.
 */
int randint(int n) {
  if ((n - 1) == RAND_MAX) {
    return rand();
  } else {
    //Supporting larger values for n would requires an even more
    //elaborate implementation that combines multiple calls to rand()
    assert (n <= RAND_MAX)

    //Chop off all of the values that would cause skew...
    int end = RAND_MAX / n; //truncate skew
    assert (end > 0);
    end *= n;

    //... and ignore results from rand() that fall above that limit.
    //(Worst case the loop condition should succeed 50% of the time,
    //so we can expect to bail out of this loop pretty quickly.)
    int r;
    while ((r = rand()) >= end);

    return r % n;
  }
}

Permet de passer à travers cela. Nous avons d'abord utiliser le srand() la fonction de semences de l'aléatoire. Fondamentalement, l'ordinateur peut générer des nombres aléatoires sur la base du nombre qui est alimenté à srand(). Si vous vous êtes donné la même valeur de départ, puis les mêmes nombres aléatoires générées à chaque fois.

Par conséquent, nous avons à la graine aléatoire avec une valeur qui est toujours en train de changer. Nous le faisons en le nourrissant à la valeur de l'heure actuelle avec la fonction time ().

Maintenant, quand nous appelons rand(), un nouveau nombre aléatoire sera produit à chaque fois.

#include <stdio.h>

int random_number(int min_num, int max_num);

int main(void)
{
    printf("Min : 1 Max : 40 %d\n", random_number(1,40));
    printf("Min : 100 Max : 1000 %d\n",random_number(100,1000));
    return 0;
}

int random_number(int min_num, int max_num)
{
    int result = 0, low_num = 0, hi_num = 0;

    if (min_num < max_num)
    {
        low_num = min_num;
        hi_num = max_num + 1; //include max_num in output
    } else {
        low_num = max_num + 1; //include max_num in output
        hi_num = min_num;
    }

    srand(time(NULL));
    result = (rand() % (hi_num - low_num)) + low_num;
    return result;
}

La norme fonction C est rand(). C'est assez bon pour traiter les cartes de solitaire, mais c'est horrible. De nombreuses implémentations de rand() cycle au moyen d'une courte liste de nombres, et les bits de poids faible ont des cycles plus courts. La façon que certains programmes d'appel rand() est terrible, et le calcul d'une bonne semence de passer à srand() est dur.

La meilleure façon de générer des nombres aléatoires en C, c'est d'utiliser une bibliothèque tierce, comme OpenSSL. Par exemple,

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <openssl/rand.h>

/* Random integer in [0, limit) */
unsigned int random_uint(unsigned int limit) {
    union {
        unsigned int i;
        unsigned char c[sizeof(unsigned int)];
    } u;

    do {
        if (!RAND_bytes(u.c, sizeof(u.c))) {
            fprintf(stderr, "Can't get random bytes!\n");
            exit(1);
        }
    } while (u.i < (-limit % limit)); /* u.i < (2**size % limit) */
    return u.i % limit;
}

/* Random double in [0.0, 1.0) */
double random_double() {
    union {
        uint64_t i;
        unsigned char c[sizeof(uint64_t)];
    } u;

    if (!RAND_bytes(u.c, sizeof(u.c))) {
        fprintf(stderr, "Can't get random bytes!\n");
        exit(1);
    }
    /* 53 bits /2**53 */
    return (u.i >> 11) * (1.0/9007199254740992.0);
}

int main() {
    printf("Dice: %d\n", (int)(random_uint(6) + 1));
    printf("Double: %f\n", random_double());
    return 0;
}

Pourquoi autant de code? D'autres langages comme Java et Ruby ont des fonctions aléatoires entiers ou des flotteurs. OpenSSL ne donne que des octets aléatoires, donc j'essaie d'imiter la façon dont Java ou Ruby serait de les transformer en nombres entiers ou des flotteurs.

Pour les entiers, nous voulons éviter modulo biais. Supposons que nous avons eu quelques aléatoire à 4 chiffres entiers de rand() % 10000, mais rand() ne peut retourner 0 à 32767 (comme il le fait dans Microsoft Windows). Chaque nombre de 0 à 2767 apparaît plus souvent que chaque numéro de 2768 à 9999. Pour supprimer les biais, on peut réessayer rand() alors que la valeur est en dessous de 2768, parce que les 30000 valeurs de 2768 à 32767 carte uniformément sur les 10000 valeurs de 0 à 9999.

Pour des flotteurs, nous voulons 53 bits aléatoires, car un double détient 53 bits de précision (en supposant que c'est une norme IEEE double). Si nous utilisons plus de 53 bits, on obtient l'arrondissement de biais. Certains programmeurs d'écrire du code comme rand() /(double)RAND_MAX, mais rand() pourrait revenir seulement 31 bits, ou seulement 15 bits dans Windows.

OpenSSL est RAND_bytes() graines de lui-même, peut-être par la lecture de /dev/urandom dans Linux. Si nous avons besoin de beaucoup de nombres aléatoires, ce serait trop lent pour lire à partir d' /dev/urandom, parce qu'ils doivent être copiés à partir du noyau. Il est plus rapide pour permettre OpenSSL pour générer plus de nombres aléatoires à partir d'une graine.

Plus à propos de nombres aléatoires:

• Perl Perl_seed() est un exemple de comment calculer une graine en C pour srand(). Il mélange les bits de l'heure actuelle, l'ID de processus, et de quelques conseils, si il ne peut pas lire /dev/urandom.
• OpenBSD arc4random_uniform() explique modulo biais.
• API Java pour java.util.Aléatoire décrit les algorithmes de suppression des biais d'entiers aléatoires, et l'emballage de 53 bits au hasard des flotteurs.

STL n'existe pas en C. Vous devez appeler rand, ou mieux encore, random. Elles sont déclarées dans la bibliothèque standard de l'en-tête stdlib.h. rand est POSIX, random est un BSD spec fonction.

La différence entre rand et random est que random renvoie beaucoup plus utilisable 32 bits nombre aléatoire, et rand renvoie généralement un nombre sur 16 bit. Le BSD pages de manuel montrent que les bits de poids faible de rand sont cyclique et prévisible, de sorte rand est potentiellement inutiles pour les petits nombres.

C'est un bon moyen pour obtenir un nombre aléatoire entre deux numéros de votre choix.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

    #define randnum(min, max) \
        ((rand() % (int)(((max) + 1) - (min))) + (min))

int main()
{
    srand(time(NULL));

    printf("%d\n", randnum(1, 70));
}

La sortie de la première heure: 39

La sortie de la seconde heure: 61

De sortie pour la troisième fois: 65

Vous pouvez modifier les valeurs après randnum à ce que les numéros que vous choisissez, et il va générer un nombre aléatoire entre ces deux nombres.

FWIW, la réponse est que oui, il y a un stdlib.h fonction appelée rand; cette fonction est réglée principalement pour la vitesse et de la distribution, pas pour de l'imprévisibilité. Presque tous les intégrés dans les fonctions aléatoires de diverses langues et des cadres de l'utilisation de cette fonction par défaut. Il y a aussi "cryptographique" générateurs de nombres aléatoires qui sont beaucoup moins prévisibles, mais beaucoup plus lentement. Elles devraient être utilisées dans toute sorte de sécurité liées à l'application.

Bien, STL C++, pas du C, donc je ne sais pas ce que vous voulez. Si vous voulez C, cependant, il est la rand() et srand() fonctions:

int rand(void);

void srand(unsigned seed);

Ce sont à la fois partie de la norme ANSI C. Il y a aussi le random() fonction:

long random(void);

Mais aussi loin que je peux dire, random() n'est pas la norme ANSI C. Une bibliothèque tierce, peut-être pas une mauvaise idée, mais tout dépend de l'aléatoire d'un numéro que vous avez vraiment besoin de générer.

rand() est le moyen le plus pratique pour générer des nombres aléatoires.

Vous pouvez également assister à un nombre aléatoire à partir de n'importe quel service en ligne comme random.org.

#include <stdio.h>
#include <dos.h>

int random(int range);

int main(void)
{
    printf("%d", random(10));
    return 0;
}

int random(int range)
{
    struct time t;
    int r;

    gettime(&t);
    r = t.ti_sec % range;
    return r;
}

Audience une bonne explication de pourquoi à l'aide de rand() pour produire de l'aléatoire uniformément distribué des nombres dans une plage donnée est une mauvaise idée, j'ai décidé de prendre un coup d'oeil à la façon biaisée, la sortie est en réalité. Mon cas de test était juste de dés à jeter. Voici le code C:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(int argc, char *argv[])
{
    int i;
    int dice[6];

    for (i = 0; i < 6; i++) 
      dice[i] = 0;
    srand(time(NULL));

    const int TOTAL = 10000000;
    for (i = 0; i < TOTAL; i++)
      dice[(rand() % 6)] += 1;

    double pers = 0.0, tpers = 0.0;
    for (i = 0; i < 6; i++) {
      pers = (dice[i] * 100.0) / TOTAL;
      printf("\t%1d  %5.2f%%\n", dice[i], pers);
      tpers += pers;
    }
    printf("\ttotal:  %6.2f%%\n", tpers);
}

et voici sa sortie:

 $ gcc -o t3 t3.c
 $ ./t3 
        1666598  16.67%     
        1668630  16.69%
        1667682  16.68%
        1666049  16.66%
        1665948  16.66%
        1665093  16.65%
        total:  100.00%
 $ ./t3     
        1667634  16.68%
        1665914  16.66%
        1665542  16.66%
        1667828  16.68%
        1663649  16.64%
        1669433  16.69%
        total:  100.00%

Je ne sais pas comment uniforme vous avez besoin de vos nombres aléatoires, mais le ci-dessus apparaît uniforme suffisant pour la plupart des besoins.

Edit: ce serait une bonne idée pour initialiser le GÉNÉRATEUR avec quelque chose de mieux que time(NULL).

En dépit de toutes les personnes suggestion rand() ici, vous ne voulez pas utiliser rand(), sauf si vous avez! Les numéros aléatoires qui rand() produit sont souvent très mauvais. Pour citer le Linux homme page:

Les versions de rand() et srand() dans le Linux de la Bibliothèque C utiliser le même générateur de nombre aléatoire comme random(3) et srandom(3), de sorte que les bits de niveau inférieur doit être aussi aléatoire que le plus élevé de bits d'ordre. Cependant, sur les anciens rand() de mise en œuvre, sur les implémentations actuelles sur les différents systèmes, les bits de niveau inférieur sont beaucoup moins aléatoire que l'ordre supérieur bits. N'utilisez pas cette fonction dans les applications destinées à être portable, quand le bien de l'aléatoire est nécessaire. (Utilisation random(3) à la place.)

Concernant la portabilité, random() est aussi défini par la norme POSIX pour un certain temps maintenant. rand() est vieux, il est apparu déjà dans la première POSIX.1 spec (IEEE Std 1003.1-1988), alors que random() est d'abord apparu dans POSIX.1-2001 (IEEE Std 1003.1-2001), et pourtant le standard POSIX est déjà POSIX.1-2008 date (IEEE Std 1003.1-2008), qui a reçu une mise à jour, il y a un an (IEEE Std 1003.1-2008, 2016 Édition). Donc je ne considère random() être très portable.

POSIX.1-2001 a également introduit le lrand48() et mrand48() fonctions, voir ici:

Cette famille de fonctions est de générer des nombres pseudo-aléatoires à l'aide d'une congruence linéaire de l'algorithme et 48-bit arithmétique entière.

Et un assez bon pseudo-aléatoire de la source est le arc4random() fonction qui est disponible sur de nombreux systèmes. Pas partie d'une norme officielle, est apparue dans BSD autour de 1997, mais vous pouvez le trouver sur des systèmes comme Linux et macOS/iOS.

Essayer cela, je l'ai mis ensemble à partir de certains des concepts déjà référencé ci-dessus:

/*    
Uses the srand() function to seed the random number generator based on time value,
then returns an integer in the range 1 to max. Call this with random(n) where n is an integer, and you get an integer as a return value.
 */

int random(int max) {
    srand((unsigned) time(NULL));
    return (rand() % max) + 1;
}