Non répétition de nombres aléatoires en Objective-C

Il semble que vous voulez de brassage d'un ensemble plutôt que de "vrai" hasard. Il suffit de créer un tableau où toutes les positions correspondent aux numéros et initialiser un compteur:

num[ 0] =  0
num[ 1] =  1
: :
num[99] = 99
numNums = 100

Ensuite, chaque fois que vous voulez un nombre aléatoire, utilisez la méthode suivante:

idx = rnd (numNums);       //return value 0 through numNums-1
val = num[idx];            //get then number at that position.
num[idx] = val[numNums-1]; //remove it from pool by overwriting with highest
numNums--;                 //  and removing the highest position from pool.
return val;                //give it back to caller.

Cela renvoie une valeur aléatoire à partir d'une diminution de la piscine, garantissant pas de répétitions. Vous devez vous méfier de la piscine, descendant de la taille zéro, bien sûr, et intelligemment ré-initialiser la piscine.

C'est une solution déterministe que de garder une liste de numéros utilisés et de continuer à boucle jusqu'à ce que vous trouver un pas dans cette liste. La performance de ce type d'algorithme se dégrade à mesure que la piscine est petite.

Une fonction C à l'aide des valeurs statiques quelque chose comme cela devrait faire l'affaire. Appeler avec

int i = myRandom (200);

pour définir la piscine (avec n'importe quel nombre supérieure ou égale à zéro qui spécifie la taille) ou

int i = myRandom (-1);

pour obtenir le nombre suivant de la piscine (un nombre négatif suffit). Si la fonction ne peut pas allouer suffisamment de mémoire, il sera de retour -2. Si il n'y a pas de chiffres à gauche dans la piscine, il sera de retour -1 (à quel point vous pourriez re-initialiser la piscine si vous le souhaitez). Voici la fonction avec une unité de test principal pour vous d'essayer:

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

#define ERR_NO_NUM -1
#define ERR_NO_MEM -2

int myRandom (int size) {
    int i, n;
    static int numNums = 0;
    static int *numArr = NULL;

    //Initialize with a specific size.

    if (size >= 0) {
        if (numArr != NULL)
            free (numArr);
        if ((numArr = malloc (sizeof(int) * size)) == NULL)
            return ERR_NO_MEM;
        for (i = 0; i  < size; i++)
            numArr[i] = i;
        numNums = size;
    }

    //Error if no numbers left in pool.

    if (numNums == 0)
       return ERR_NO_NUM;

    //Get random number from pool and remove it (rnd in this
    //  case returns a number between 0 and numNums-1 inclusive).

    n = rand() % numNums;
    i = numArr[n];
    numArr[n] = numArr[numNums-1];
    numNums--;
    if (numNums == 0) {
        free (numArr);
        numArr = 0;
    }

    return i;
}

int main (void) {
    int i;

    srand (time (NULL));
    i = myRandom (20);
    while (i >= 0) {
        printf ("Number = %3d\n", i);
        i = myRandom (-1);
    }
    printf ("Final  = %3d\n", i);
    return 0;
}

Et voici la sortie d'un run:

Number =  19
Number =  10
Number =   2
Number =  15
Number =   0
Number =   6
Number =   1
Number =   3
Number =  17
Number =  14
Number =  12
Number =  18
Number =   4
Number =   9
Number =   7
Number =   8
Number =  16
Number =   5
Number =  11
Number =  13
Final  =  -1

Gardez à l'esprit que, parce qu'il utilise la statique, il n'est pas sûr d'appeler à partir de deux endroits différents, s'ils veulent maintenir leurs propres piscines séparées. Si c'était le cas, la statique serait remplacé par un tampon (en tenant comte et de la piscine) qui "appartiennent" à l'appelant (un double pointeur peut être transmis à cet effet).

Et, si vous êtes à la recherche pour les multiples "piscine" de la version, je l'inclus ici par souci d'exhaustivité.

#include <stdio.h>
#include <stdlib.h>
#define ERR_NO_NUM -1
#define ERR_NO_MEM -2
int myRandom (int size, int *ppPool[]) {
int i, n;
//Initialize with a specific size.
if (size >= 0) {
if (*ppPool != NULL)
free (*ppPool);
if ((*ppPool = malloc (sizeof(int) * (size + 1))) == NULL)
return ERR_NO_MEM;
(*ppPool)[0] = size;
for (i = 0; i  < size; i++) {
(*ppPool)[i+1] = i;
}
}
//Error if no numbers left in pool.
if (*ppPool == NULL)
return ERR_NO_NUM;
//Get random number from pool and remove it (rnd in this
//  case returns a number between 0 and numNums-1 inclusive).
n = rand() % (*ppPool)[0];
i = (*ppPool)[n+1];
(*ppPool)[n+1] = (*ppPool)[(*ppPool)[0]];
(*ppPool)[0]--;
if ((*ppPool)[0] == 0) {
free (*ppPool);
*ppPool = NULL;
}
return i;
}
int main (void) {
int i;
int *pPool;
srand (time (NULL));
pPool = NULL;
i = myRandom (20, &pPool);
while (i >= 0) {
printf ("Number = %3d\n", i);
i = myRandom (-1, &pPool);
}
printf ("Final  = %3d\n", i);
return 0;
}

Comme vous pouvez le voir à partir de la modification de la main(), vous devez d'abord initialiser un int pointeur vers NULL puis de les transmettre, à son adresse, à la myRandom() fonction. Cela permet à chaque client (emplacement dans le code) à avoir leur propre piscine qui est automatiquement attribué et libéré, bien que vous pouvez toujours partager des piscines si vous le souhaitez.

OriginalL'auteur paxdiablo

Vous avez besoin de garder une trace des numéros que vous avez déjà utilisé (par exemple, dans un tableau). Obtenir un nombre aléatoire, et le jeter si elle a déjà été utilisée.

OriginalL'auteur driis

La meilleure façon de le faire est de créer un tableau pour les numéros déjà utilisé. Après un nombre aléatoire a été créé, puis l'ajouter à la matrice. Ensuite, lorsque vous allez créer un autre nombre aléatoire, de s'assurer qu'il n'est pas dans le tableau des numéros utilisés.

OriginalL'auteur GaryDevenay