Gerando números aleatórios no Objective-C

Sou principalmente Java, e quero uma maneira de gerar um número pseudo-aleatório entre 0 e 74. Em Java, usaria o método:

Random.nextInt(74)

Não estou interessado em uma discussão sobre sementes ou verdadeira aleatoriedade, exatamente como você realiza a mesma tarefa no Objective-C. Eu vasculhei o Google e parece haver muitas informações diferentes e conflitantes.

Você deve usar a arc4random_uniform()função Ele usa um algoritmo superior para rand. Você nem precisa colocar uma semente.

#include <stdlib.h>
// ...
// ...
int r = arc4random_uniform(74);

A arc4randompágina do manual:

NAME
     arc4random, arc4random_stir, arc4random_addrandom -- arc4 random number generator

LIBRARY
     Standard C Library (libc, -lc)

SYNOPSIS
     #include <stdlib.h>

     u_int32_t
     arc4random(void);

     void
     arc4random_stir(void);

     void
     arc4random_addrandom(unsigned char *dat, int datlen);

DESCRIPTION
     The arc4random() function uses the key stream generator employed by the arc4 cipher, which uses 8*8 8
     bit S-Boxes.  The S-Boxes can be in about (2**1700) states.  The arc4random() function returns pseudo-
     random numbers in the range of 0 to (2**32)-1, and therefore has twice the range of rand(3) and
     random(3).

     The arc4random_stir() function reads data from /dev/urandom and uses it to permute the S-Boxes via
     arc4random_addrandom().

     There is no need to call arc4random_stir() before using arc4random(), since arc4random() automatically
     initializes itself.

EXAMPLES
     The following produces a drop-in replacement for the traditional rand() and random() functions using
     arc4random():

           #define foo4random() (arc4random() % ((unsigned)RAND_MAX + 1))

Use a arc4random_uniform(upper_bound)função para gerar um número aleatório dentro de um intervalo. A seguir, será gerado um número entre 0 e 73, inclusive.

arc4random_uniform(74)

arc4random_uniform(upper_bound)evita viés de módulo, conforme descrito na página de manual:

arc4random_uniform () retornará um número aleatório uniformemente distribuído menor que upper_bound. O arc4random_uniform () é recomendado em construções como `` arc4random ()% upper_bound '', pois evita " viés de módulo " quando o limite superior não é uma potência de dois.

O mesmo que C, você faria

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

(supondo que você quis dizer incluindo 0, mas excluindo 74, que é o que seu exemplo de Java faz)

Edit: Sinta-se livre para substituir random()ou arc4random()para rand()(o que é, como outros apontaram, muito sucky).

Eu pensei que poderia adicionar um método que eu uso em muitos projetos.

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

Se eu acabar usando em muitos arquivos, normalmente declaro uma macro como

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

Por exemplo

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

Nota: Apenas para iOS 4.3 / OS X v10.7 (Lion) e posterior

Isso fornecerá um número de ponto flutuante entre 0 e 47

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

Ou simplesmente

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

Os limites inferior e superior também podem ser negativos . O código de exemplo abaixo fornece um número aleatório entre -35,76 e +12,09

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

Converta o resultado em um valor inteiro mais redondo :

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

De acordo com a página de manual para rand (3), a família de funções rand foi obsoleta por acaso (3). Isso se deve ao fato de os 12 bits inferiores de rand () passarem por um padrão cíclico. Para obter um número aleatório, basta propagar o gerador chamando srandom () com uma semente não assinada e, em seguida, chame random (). Portanto, o equivalente ao código acima seria

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

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

Você só precisará chamar srandom () uma vez no seu programa, a menos que queira alterar sua semente. Embora você tenha dito que não queria uma discussão sobre valores verdadeiramente aleatórios, rand () é um gerador de números aleatórios bastante ruim, e random () ainda sofre com o viés do módulo, pois gera um número entre 0 e RAND_MAX. Portanto, por exemplo, se RAND_MAX é 3 e você deseja um número aleatório entre 0 e 2, é duas vezes mais provável que você obtenha um 0 que um 1 ou um 2.

Melhor usar arc4random_uniform. No entanto, isso não está disponível abaixo do iOS 4.3. Felizmente, o iOS vincula esse símbolo no tempo de execução, não no tempo de compilação (portanto, não use a diretiva #if pré-processador para verificar se está disponível).

A melhor maneira de determinar se arc4random_uniformestá disponível é fazer algo assim:

#include <stdlib.h>

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

Eu escrevi minha própria classe de utilitário de número aleatório apenas para ter algo que funcionasse um pouco mais como Math.random () em Java. Ele tem apenas duas funções, e tudo é feito em C.

Arquivo de cabeçalho:

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

Arquivo de implementação:

//Random.m
static unsigned long seed;

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

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

É uma maneira bastante clássica de gerar pseudo-randoms. No delegado do meu aplicativo, eu chamo:

#import "Random.h"

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

Depois, apenas digo:

float myRandomNumber = nextRandomFloat() * 74;

Observe que esse método retorna um número aleatório entre 0,0f (inclusive) e 1,0f (exclusivo).

Já existem respostas ótimas e articuladas, mas a pergunta pede um número aleatório entre 0 e 74. Use:

arc4random_uniform(75)

No iOS 9 e OS X 10.11, você pode usar as novas classes GameplayKit para gerar números aleatórios de várias maneiras.

Você tem quatro tipos de fonte para escolher: uma fonte aleatória geral (sem nome, até o sistema escolher o que faz), congruencial linear, ARC4 e Mersenne Twister. Isso pode gerar entradas, flutuadores e bools aleatórios.

No nível mais simples, você pode gerar um número aleatório a partir da fonte aleatória interna do sistema, como esta:

NSInteger rand = [[GKRandomSource sharedRandom] nextInt];

Isso gera um número entre -2.147.483.648 e 2.147.483.647. Se você deseja um número entre 0 e um limite superior (exclusivo), use este:

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

O GameplayKit possui alguns construtores de conveniência incorporados para trabalhar com dados. Por exemplo, você pode rolar um dado de seis lados assim:

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

Além disso, você pode moldar a distribuição aleatória usando coisas como GKShuffledDistribution.

Gere um número aleatório entre 0 e 99:

int x = arc4random()%100;

Gere um número aleatório entre 500 e 1000:

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

// O exemplo a seguir vai gerar um número entre 0 e 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);

Resultado:

• número aleatório: 72

• número aleatório passo 2: 52

Para desenvolvedores de jogos, use random () para gerar randoms. Provavelmente pelo menos 5x mais rápido do que usar arc4random (). O viés do módulo não é um problema, especialmente para jogos, ao gerar randoms usando toda a gama aleatória (). Certifique-se de semear primeiro. Chame srandomdev () no AppDelegate. Aqui estão algumas funções auxiliares:

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;}