Comment puis-je réduire les numéros de rand()?

Le code suivant renvoie un nombre aléatoire à chaque seconde:

int main ()
{
    srand(time(NULL)); //Seeds number generator with execution time.

    while (true)
    {
        int rawRand = rand();

        std::cout << rawRand << std::endl;

        sleep(1);
    }
}

Comment pourrais-je taille ces chiffres vers le bas de sorte qu'ils sont toujours dans la gamme de 0 à 100?

  • int GetRandom() { return 59; /*A parfaitement choisi au hasard le numéro de*/}
  • Serait-ce un xkcd référence vois-je? 😛
  • naah, vu dans beaucoup trop d'endroits à-dire la source exacte, et être capable de s'abstenir de m'écrire que.
  • le temps de sommeil est exprimé en millisecondes, de l'utilisation de sleep(1000) pour dormir pendant une seconde.
  • Pas dans la mise en œuvre que j'utilise, il n'est pas. Comment étrange.
  • ses aussi un de Dilbert de référence
  • Pourriez-vous s'il vous plaît activer la accepté de répondre à celui-ci?
  • Génial, merci beaucoup! Je suis sûr que Justin sauront l'apprécier. 🙂

InformationsquelleAutor Maxpm | 2010-11-16
  1. 77

    Si vous êtes à l'aide de C++ et que vous êtes inquiet au sujet de la bonne distribution, vous pouvez utiliser TR1 de C++11 <random>.

    #include <random>

std::random_device rseed;
std::mt19937 rgen(rseed()); //mersenne_twister
std::uniform_int_distribution<int> idist(0,100); //[0,100]

std::cout << idist(rgen) << std::endl;
    • Alors que ce est la bonne façon d'obtenir une distribution uniforme de nombres aléatoires, ce n'est pas la réponse à MaxPM de la question qui demande rien au sujet de l'obtention d'une bonne distribution, mais s'interroge: "Comment puis-je réduire les numéros de rand()".
    • random_device ne fonctionne pas toujours: Il retuns 34992116121 à chaque fois, dans mon cas.
    • C'est malheureux, quel compilateur/version utilisez-vous? Vous pourriez voir la même question que le cette autre DONC, la question.
    • Je suis en utilisant gcc 4.9.1 (version 64 bits). Merci pour le lien.
    • Je n'ai pas 4.9.1 de tester, mais je sais que ça fonctionne sur gcc 4.8.1 et Visual C++ 2010 et 2013. J'ai googlé pour les problèmes avec gcc et std::random_device mais rien trouvé, désolé.
    • merci. J'ai testé un peu plus. Je ne sais pas ce qui est différent, mais maintenant ça marche... Désolé d'avoir cette place.
    • Ce n'est pas une bonne façon d'amorcer une mt19937, de vous donner uniquement 32 bits d'entropie, mais il peut prendre beaucoup plus. La bonne façon serait de faire une int[mt19937::state_size], à l'aide de generate_n avec un random_device de le remplir avec de l'aléatoire, de faire un seed_seq à partir de ce tableau, puis la construction de la mersenne twister moteur de cette seed_seq.

    InformationsquelleAutor Blastfurnace
  2. 30

    Tous les exemples affichés jusqu'à présent réellement donner mal distribués résultats. Exécuter le code souvent et créer des statistiques pour voir comment les valeurs deviennent asymétriques.

    Une meilleure façon de générer un réel uniforme de nombres aléatoires de distribution dans tout l'intervalle [0, N] est le suivant (en supposant que rand effectivement suit une distribution uniforme, ce qui est loin d'être évident):

    unsigned result;
do {
    result = rand();
} while (result > N);

    Bien sûr, cette méthode est lente, mais elle ne produire une bonne distribution. Un peu plus intelligente façon de le faire est de trouver le plus grand multiple de N qui est plus petit que RAND_MAX et en utilisant ce que la limite supérieure. Après cela, on peut prendre en toute sécurité le result % (N + 1).

    Pour une explication pourquoi le naïf module méthode est mauvaise et pourquoi le ci-dessus est mieux, reportez-vous à la Julienne de l'excellent article sur à l'aide de rand.

    • En fait, qu'un PRNG rendements distribués de manière uniforme les chiffres devraient être en somethnig vous pouvez supposer. Légèrement plus intelligentes peuvent être trouvés dans java.util.Random#nextInt(int) par exemple.
    • Vous pouvez facilement faire beaucoup, beaucoup mieux en faisant while(result > (RAND_MAX - RAND_MAX % N)) et en divisant par RAND_MAX/N. Vous jetez beaucoup moins de numéros pour les petits N, mais de garder la distribution uniforme.
    • la Java manière est incroyablement intelligent, mais un peu difficile à expliquer et je ne m'attends pas à un débutant (ou même intermédiaire) programmeur avec aucune connaissance particulière dans les statistiques de la comprendre. Je pense que ma façon d'être, tout en donnant une bonne distribution, est encore assez facile à expliquer et à mettre en œuvre.
    • C'est le “un peu mieux” que j'ai expliqué, sans donner le code. Je ne comprends pas, par contre, pourquoi vous diviserez par RAND_MAX/N. Juste à l'aide de % (N+1) doit sûrement être bien?
    • comme expliqué dans le Java docs: si le sous-jacent aléatoire de la source est un LCG, comme c'est souvent le cas, alors son moins-bits significatifs ont plus de la corrélation et de la baisse de la période de sa plus-bits significatifs. Mise à l'échelle s'assure que la plus-bits significatifs ont un "plus" d'effet sur le résultat. Le module conserve autant moins de bits significatifs que le nombre de fois le diviseur est divisible par 2. Si la source sous-jacente étaient aléatoires, alors il ne serait pas question.
    • oh vrai, oublié celui-là.
    • Tout cela est certainement vrai; l'effet est très léger. RAND_MAX est au moins 32677 et sur ma machine, 2 147 483 647. Pour le minimum de RAND_MAX cela signifie que chaque nombre dans la plage de 0-77 se produit 327 fois bien que les chiffres dans 78-99 se produire seulement 326 fois les rendant 0.3% de chances en moins. Pour ma machine RAND_MAX la différence, c'est les numéros de 0-47 sont à 0,000 005% plus susceptibles que les numéros de 48-99. Pour la plupart des besoins (par exemple, en dehors de graves modélisation Monte Carlo) un simple module fonctionne très bien.
    • Je pense que vous voulez prendre le "plus grand multiple de N+1", pas un multiple de N?
    • Le lien vers "l'aide rand" (eternallyconfuzzled dot com) est cassé et maintenant les points à un spam de blog à propos de l'achat de vues sur Youtube.
    • Merci, je l'ai remplacé par une copie archivée.

    InformationsquelleAutor Konrad Rudolph
  3. 26

    int rawRand = rand() % 101;

    Voir (pour plus de détails):

    rand - C++ de Référence

    D'autres ont également souligné que cela ne va pas vous donner la meilleure répartition des nombres aléatoires possibles. Si ce genre de chose qui est important dans votre code, vous devrez faire:

    int rawRand = (rand() * 1.0 / RAND_MAX) * 100;

    MODIFIER

    Trois ans, je suis en train de faire un montage. Comme d'autres l'ont mentionné, rand() a beaucoup de questions. Évidemment, je ne peux pas recommander son utilisation lorsqu'il y a de meilleures alternatives à l'avenir. Vous pouvez lire tous les détails et les recommandations ici:

    rand() Considéré comme Nocif | GoingNative 2013

    • S'il vous plaît ne pas utiliser cette méthode dans la pratique – c'est mauvais.
    • Notez que vous aurez un peu inégale répartition de cette. Les numéros les plus bas se produire un peu plus souvent de cette façon. Une bonne façon de résoudre cela, jetez un oeil à java.util.Random#nextInt(int).
    • Comme je l'ai dit avant, en utilisant le modulo méthode n'est pas tout à fait un parfait hasard. 100 numéros, et uint a 648 gammes complètes de 0 à 100, et une gamme de 0-87. Les numéros de 0-87 ont donc légèrement plus de chances de se produire que le nombre de 88-100.
    • Notez que rawRand fera preuve d'une certaine partialité si vous utilisez cette technique (en supposant que 101 n'est pas un facteur de RAND_MAX).
    • Pour les personnes qui ont BESOIN de nombres aléatoires, ils ne seront pas à l'aide de rand pour les générer. les distorsions introduites par le module et sa mise à l'échelle de la gamme des ajustements ne sont significatives que si vous aviez en fait une distribution aléatoire en premier lieu.
    • (rand() / RAND_MAX) effectue une partie intégrante de la division. Depuis RAND_MAX >= rand(), cette valeur est égale à 1 ou à 0 (très probable 0), donc cela ne fera que produire les valeurs 0 ou 100. Pour corriger cela, vous devez faire l'un des opérandes un double par un moulage.
    • -1. Vous aurez toujours obtenir une distribution non uniforme. rand() a RAND_MAX+1 valeurs; sauf si c'est un multiple de 101 (ce qui n'est probablement pas), il n'existe aucun moyen de les attribuer à 101 seaux sans que l'un d'entre eux étant plus grand.
    • réponse de l'ressemble presque comme du TSL. J'ai donné un upvote pour que l'on (pas celui-ci).
    • Ce soin à personne de m'éclairer à ce que l'enfer vient de se passer? J'ai voulu supprimer la réponse à jamais, mais ne peut pas car il est accepté. J'admets volontiers que ce n'est pas la meilleure solution.
    • STL parler sur les GoingNative 2013 qui s'est passé. Il y a un lien vers un site où la vidéo sera téléchargée à bientôt.
    • Viens de voir le lien. En attendant la vidéo (même si on m'a dit il y a longtemps exactement pourquoi j'étais mal...même si l'OP n'ont pas fait mention de la distribution). Je changerais la réponse, mais que bien sûr, est la mauvaise solution. Bonjour marteau et l'enclume, heureux d'être coincé entre vous.
    • Depuis votre edit, ce n'est pas vraiment une réponse, pas plus. Vous avez besoin de proposer une alternative de mise en œuvre vous-même.
    • J'ai demandé à Maxpm pour passer réponses et il a gracieusement accepté. Vous pouvez supprimer cette réponse souhaitée maintenant. Vous avez de la chance d'être le centre d'attention. 😉

    InformationsquelleAutor Justin Niessner
  4. 6

    Vous pouvez faire 

    cout << rawRand % 100 << endl; //Outputs between 0 and 99

cout << rawRand % 101 << endl; //outputs between 0 and 100

    Pour les personnes downvoting; remarque une minute après que cela a été posté j'ai laissé le commentaire:

    De http://www.cplusplus.com/reference/clibrary/cstdlib/rand "Notez tout de même que ce modulo opération ne génère pas vraiment de chiffre aléatoire uniformément distribué dans l'espace (comme dans la plupart des cas, les nombres inférieurs sont légèrement plus probable), mais il est généralement une bonne approximation pour de courtes portées."

    Avec 64-bit ints et à l'aide de 100 numéros de la sortie, les chiffres de 0 à 16 sont représentés avec 1.00000000000000000455 % des effectifs (soit une précision relative à identiquement distribuées de 1% par environ 10-18), tandis que le nombre 17-99 sont représentés avec 0.99999999999999999913 % des effectifs. Oui, parfaitement distribuées, mais une très bonne approximation pour les petites amplitudes.

    Noter également, d'où l'OP demander identiquement distribuées numéros? Pour tous nous savons que ces sommes soient utilisées à des fins où un petits écarts n'a pas d'importance (p. ex., rien d'autre que la cryptographie -- et si ils sont en utilisant les numéros de cryptographie à cette question est beaucoup trop naïf pour eux d'écrire leur propre cryptographie).

    MODIFIER - Pour les personnes qui sont véritablement intéressés à avoir une distribution uniforme de nombres aléatoires le code suivant fonctionne. Remarque ce n'est pas nécessairement la solution optimale qu'avec la version 64 bits aléatoires entiers, il faudra deux appels de rand() une fois tous les 10^18 appels.

    unsigned N = 100; //want numbers 0-99
unsigned long randTruncation = (RAND_MAX / N) * N; 
//include every number the N times by ensuring rawRand is between 0 and randTruncation - 1 or regenerate.
unsigned long rawRand = rand();

while (rawRand >= randTruncation) {
    rawRand = rand();  
//with 64-bit int and range of 0-99 will need to generate two random numbers
//about 1 in every (2^63)/16 ~ 10^18 times (1 million million times)

//with 32-bit int and range of 0-99 will need to generate two random numbers 
//once every 46 million times.

}
cout << rawRand % N << stdl::endl;
    • À partir de cplusplus.com/reference/clibrary/cstdlib/rand Notez tout de même que ce modulo opération ne génère pas vraiment de chiffre aléatoire uniformément distribué dans l'espace (comme dans la plupart des cas, les nombres inférieurs sont légèrement plus probable), mais il est généralement une bonne approximation pour de courtes portées."
    InformationsquelleAutor dr jimbob
  5. 4

    Voir man 3 rand -- vous avez besoin à l'échelle en divisant par RAND_MAX pour obtenir l'intervalle [0, 1], après quoi vous pouvez multiplier par 100 pour votre fourchette cible.

    • Intéressant. Cette méthode ont des avantages par rapport à la taille du module méthode?
    • Il rendements statistiquement "mieux" les valeurs que l'utilisation de modulo.
    • Eh bien, selon la façon dont les ordures rand() est de commencer. Il est généralement assez nul, si.
    • Pas de. L'inégalité est juste réparties différemment. Mais vous obtenez toujours des nombres plus souvent que d'autres.
    • +1 et je suis un peu surpris c'est la seule réponse à suggérer la division par RAND_MAX plutôt que % module.
    • le point est qu'il évite le plus odieux des mauvais comportements qui sont vus dans la pratique. Par exemple LCGs où le bit le moins significatif suppléants sur les échantillons. Donc, si vous prenez un module avec un même nombre, vos valeurs ont la même propriété. Si la mise à l'échelle, ils vont au moins esquiver la balle. La chose à retenir à propos de rand() est qu'il est permis à un atroce PRNG. Toute utilisation, il est suspect si bon nombres aléatoires sont nécessaires, mais certains sont encore plus suspect que les autres.

    InformationsquelleAutor Dirk Eddelbuettel
  6. 0

    Pour la gamme min à max (inclus), utilisation: int result = rand() % (max - min + 1) + min;

    InformationsquelleAutor Jake Petroules
  7. -4

    Combien de temps une réponse vous souhaitez.

    le plus simple est de convertir en utilisant le reste quand il est divisé en 101:

    int value = rawRand % 101;

    Un semipurist serait le redimensionner à l'aide de doubles:

    double dbl = 100 * ((double)rawRand / RAND_MAX);
int ivalue = (int)(dbl + 0.5);   //round up for above 0.5

    Et un puriste dirais que rand ne pas produire des nombres aléatoires.

    Pour votre info, la qualité de nombres aléatoires est mesurée par la prise d'une séquence de nombres et calcul de la probabilité mathématique que la source de cette séquence est aléatoire. Le simple hack en utilisant le reste est un très mauvais choix si vous êtes après l'aléatoire.

    InformationsquelleAutor Michael Shaw
  8. -4

    Certaines personnes ont affiché le code suivant comme exemple:

    int rawRand = (rand() / RAND_MAX) * 100;

    C'est une défaillance des moyens de résoudre le problème, à la fois comme rand() et RAND_MAX sont des nombres entiers. En C++, il en résulte partie intégrante de la division, qui va tronquer les résultats des points décimaux. Comme RAND_MAX >= rand(), le résultat de cette opération est soit 1, soit 0, ce qui signifie rawRand ne peut être que 0 ou 100. Une bonne façon de le faire serait le suivant:

    int rawRand = (rand() / static_cast<double>(RAND_MAX)) * 100;

    Puisque l'un des opérandes est maintenant un double, floating point de la division est utilisé, qui doit retourner une valeur entre 0 et 1.

    • Ce n'est qu'en partie vrai, et encore ne génère pas uniformément distribués nombre, pour rawRand == 100 est très peu probable puisque seulement RAND_MAX "produit" il.
    InformationsquelleAutor tyree731
  9. -5

    rawRand % 101 donnerait [0-100], inclusivement.

    • Cela leur laisserait non-aléatoire. Uniformité de la distribution de ces tests échoue à moins modulo est effectuée sur une plage appropriée, ou le diviseur est de l'ordre d'une puissance de 2.
    InformationsquelleAutor Costique