Produire des nombres aléatoires dans L'objectif C

utilisez la fonction arc4random_uniform(upper_bound) pour générer un nombre aléatoire dans une plage. Ce qui suit générera un nombre compris entre 0 et 73 inclusivement.

arc4random_uniform(74)

arc4random_uniform(upper_bound) évite modulo biais comme décrit dans la page de man:

arc4random_uniform () retournera un nombre aléatoire uniformément distribué inférieur à upper_bound. arc4random_uniform() est recommandé sur les constructions comme `arc4random() % upper_bound" car il évite les " modulo biais " lorsque la limite supérieure n'est pas une puissance de deux.

même que C, Vous feriez

#include <time.h>
#include <stdlib.h>
...
srand(time(NULL));
int r = rand() % 74;

(en supposant que vous vouliez dire inclure 0 mais en excluant 74, ce qui est ce que fait votre exemple Java)

Edit: libre à vous de remplacer random() ou arc4random() pour rand() (qui est, comme d'autres l'ont souligné, tout à fait sucky).

j'ai pensé que je pourrais ajouter une méthode que j'utilise dans de nombreux projets.

- (NSInteger)randomValueBetween:(NSInteger)min and:(NSInteger)max {
    return (NSInteger)(min + arc4random_uniform(max - min + 1));
}

si je finis par l'utiliser dans de nombreux fichiers je déclare habituellement une macro comme

#define RAND_FROM_TO(min, max) (min + arc4random_uniform(max - min + 1))

E. G.

NSInteger myInteger = RAND_FROM_TO(0, 74) // 0, 1, 2,..., 73, 74

Note: uniquement pour ios 4.3/OS X v10.7 (Lion) et plus tard

cela vous donnera un floating point nombre entre 0 et 47

float low_bound = 0;      
float high_bound = 47;
float rndValue = (((float)arc4random()/0x100000000)*(high_bound-low_bound)+low_bound);

ou tout simplement

float rndValue = (((float)arc4random()/0x100000000)*47);

les limites inférieure et supérieure peuvent être négative ainsi. Le code d'exemple ci-dessous vous donne un nombre aléatoire entre -35.76 et + 12.09

float low_bound = -35.76;      
float high_bound = 12.09;
float rndValue = (((float)arc4random()/0x100000000)*(high_bound-low_bound)+low_bound);

Convertir résultat à un rond Integer valeur:

int intRndValue = (int)(rndValue + 0.5);

D'après la page de manuel de rand(3), la famille de fonctions rand a été obsolète au hasard(3). Ceci est dû au fait que les 12 bits inférieurs de rand() passent par un pattern cyclique. Pour obtenir un nombre aléatoire, il suffit de lancer le générateur en appelant srandom() avec une graine non signée, puis d'appeler random(). Ainsi, l'équivalent du code ci-dessus serait

#import <stdlib.h>
#import <time.h>

srandom(time(NULL));
random() % 74;

vous n'aurez besoin d'appeler srandom() qu'une seule fois dans votre programme à moins que vous ne vouliez changer votre graine. Bien que vous ayez dit que vous ne vouliez pas une discussion sur les valeurs vraiment aléatoires, rand() est un très mauvais générateur de nombres aléatoires, et random() souffre toujours de biais modulo, car il générera un nombre entre 0 et RAND_MAX. Donc, par exemple si RAND_MAX est 3, et que vous voulez un nombre aléatoire entre 0 et 2, Vous êtes deux fois plus susceptible d'obtenir un 0 qu'un 1 ou un 2.

mieux utiliser arc4random_uniform . Cependant, ce n'est pas disponible en dessous de ios 4.3. Heureusement, iOS liera ce symbole à l'exécution, pas à la compilation (n'utilisez donc pas la directive #if preprocessor pour vérifier si elle est disponible).

la meilleure façon de déterminer si arc4random_uniform est disponible est de faire quelque chose comme ceci:

#include <stdlib.h>

int r = 0;
if (arc4random_uniform != NULL)
    r = arc4random_uniform (74);
else
    r = (arc4random() % 74);

j'ai écrit ma propre classe d'utilité de nombres aléatoires juste pour avoir quelque chose qui fonctionnait un peu plus comme les mathématiques.random () en Java. Il n'a que deux fonctions, et tout est fait en C.

fichier d'en-Tête:

//Random.h
void initRandomSeed(long firstSeed);
float nextRandomFloat();

la mise en Œuvre de fichier:

//Random.m
static unsigned long seed;

void initRandomSeed(long firstSeed)
{ 
    seed = firstSeed;
}

float nextRandomFloat()
{
    return (((seed= 1664525*seed + 1013904223)>>16) / (float)0x10000);
}

c'est une façon assez classique de générer des pseudo-randoms. Dans mon délégué app j'appelle:

#import "Random.h"

- (void)applicationDidFinishLaunching:(UIApplication *)application
{
    initRandomSeed( (long) [[NSDate date] timeIntervalSince1970] );
    //Do other initialization junk.
}

plus tard je dis juste:

float myRandomNumber = nextRandomFloat() * 74;

cette méthode renvoie un nombre aléatoire compris entre 0,0 f (inclusivement) et 1,0 f (exclusif).

il y a déjà de grandes réponses articulées, mais la question demande un nombre aléatoire entre 0 et 74. Use:

arc4random_uniform(75)

depuis iOS 9 et OS X 10.11, vous pouvez utiliser les nouvelles classes GameplayKit pour générer des nombres aléatoires de différentes façons.

vous avez quatre types de sources à choisir: une source aléatoire générale (unnamed, down to the system to choose what it does), linéaire congruential, ARC4 et Mersenne Twister. Ceux-ci peuvent générer des entiers, des flotteurs et des booléens.

au niveau le plus simple, vous pouvez générer un nombre aléatoire à partir du système intégré random source:

NSInteger rand = [[GKRandomSource sharedRandom] nextInt];

qui génère un nombre entre -2.147.483.648 et 2.147.483.647. Si vous voulez un nombre entre 0 et une limite supérieure (exclusive) vous utiliserez ceci:

NSInteger rand6 = [[GKRandomSource sharedRandom] nextIntWithUpperBound:6];

GameplayKit a quelques constructeurs de commodité intégrés pour travailler avec des dés. Par exemple, vous pouvez rouler un dé à six faces comme ceci:

GKRandomDistribution *d6 = [GKRandomDistribution d6];
[d6 nextInt];

Plus vous pouvez façonner la distribution aléatoire en utilisant des choses comme GKShuffledDistribution .

génère un nombre aléatoire entre 0 et 99:

int x = arc4random()%100;

génère un nombre aléatoire entre 500 et 1000:

int x = (arc4random()%501) + 500;

//L'exemple suivant va générer un nombre entre 0 et 73.

int value;
value = (arc4random() % 74);
NSLog(@"random number: %i ", value);

//In order to generate 1 to 73, do the following:
int value1;
value1 = (arc4random() % 73) + 1;
NSLog(@"random number step 2: %i ", value1);

sortie:

• nombre aléatoire: 72

• nombre aléatoire étape 2: 52

Pour game dev utiliser random() pour générer des randoms. Probablement au moins 5 fois plus rapide que l'utilisation d'arc4random(). Le biais Modulo n'est pas un problème, surtout pour les jeux, quand on génère des random en utilisant toute la gamme de random(). Assurez-vous de graine en premier. Appel srandomdev() dans AppDelegate. Voici quelques fonctions d'aide:

static inline int random_range(int low, int high){ return (random()%(high-low+1))+low;}
static inline CGFloat frandom(){ return (CGFloat)random()/UINT32_C(0x7FFFFFFF);}
static inline CGFloat frandom_range(CGFloat low, CGFloat high){ return (high-low)*frandom()+low;}