Tirer aléatoirement un nombre à partir d'un ensemble d'entiers !

Version imprimable

15/10/2007, 00h07
condor_01

Tirer aléatoirement un nombre à partir d'un ensemble d'entiers !

Bonjour,
Je veux faire une boucle pour tirer à chaque itération un nombre d'un ensemble d'entiers.
Je ne veux pas qu'un entier se répète. Donc à chaque itération je vais supprimer l'entier sorti de l'ensemble.

Est ce que dans fonction rand() on peut spécifier l'ensemble d'entiers à partir duquel on va faire le tirage ?
15/10/2007, 00h11
Skyounet

Citation:

Envoyé par condor_01

Bonjour,
Je veux faire une boucle pour tirer à chaque itération un nombre d'un ensemble d'entiers.
Je ne veux pas qu'un entier se répète. Donc à chaque itération je vais supprimer l'entier sorti de l'ensemble.

Est ce que dans fonction rand() on peut spécifier l'ensemble d'entiers à partir duquel on va faire le tirage ?

Non malheureusement pas.
http://c.developpez.com/faq/?page=no..._random_bornes
Mais je pense pas que ce soit ce que tu cherches.
15/10/2007, 00h19
condor_01

:cry:
15/10/2007, 00h48
Skyounet

Ben solution, tu fais un tableau contenant les éléments de ton ensemble, et tu rand un nombre entre 0 et le nombre d'éléments de ton tableau.

Ca te donne un indice pour ton tableau.
15/10/2007, 02h49
condor_01

ça semble une bonne idée ;)
merci
15/10/2007, 18h09
Franck.H

Citation:

Envoyé par condor_01

ça semble une bonne idée ;)
merci

Ca semble être la seule idée possible de toute façon. Le problème, c'est que tu ne peux pas supprimer un élément de ton tableau donc, si tes chiffres sont strictement positifs, tu peux mettre l'indice tiré après utilisation sur par exemple -1 ou bien, faire un second tableau de concordance. Dans ce tableau, dès que tu tires au sort un numéro, tu met sur le même indice la valeur sur 1, la valeur par défaut étant 0 alors !

Ca te permet de garder ton tableau de chiffres intacte tout en sachant lesquels ont étés tirés ;)
15/10/2007, 18h19
Jean-Marc.Bourguet

Tu fais un tableau que tu initialises avec les nombres autorises. Ensuite, tu generes une permutation de ce tableau (tu echanges chaque element du tableau avec un autre tire au hasard parmi ceux qui le suivent). Enfin, tu prends les elements du tableau permute dans l'ordre.

generer la permutation n'est pas forcement un probleme simple

tu peux aussi prendre ton tableau [1,2,3,4,5,6]
Code:

1 2 3 4 5 6 7 8 while() { rand() /* entre 0 et taille-1 (mettons 2 pour l'exemple, taille = 6) */ resultat = tableau[2] tableau[2]=tableau[taille-1] taille-- }

Citation:

Envoyé par condor_01

Bonjour,
Je veux faire une boucle pour tirer à chaque itération un nombre d'un ensemble d'entiers.
Je ne veux pas qu'un entier se répète. Donc à chaque itération je vais supprimer l'entier sorti de l'ensemble.

Est ce que dans fonction rand() on peut spécifier l'ensemble d'entiers à partir duquel on va faire le tirage ?

Je ne vois pas trop où est le problème...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
#include <limits.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#include "ed/inc/random.h"
 
/* choisir une valeur hors de l'ensemble ... */
#define TIRE INT_MAX
 
static void tirage (int const a[], size_t nb)
{
 
   int *ensemble = malloc (sizeof *ensemble * nb);
   if (ensemble != NULL)
   {
      size_t i;
      memcpy (ensemble, a, sizeof *ensemble * nb);
 
      for (i = 0; i < nb; i++)
      {
         int n;
         do
         {
            n = random (nb);
         }
         while (ensemble[n] == TIRE);
         {
            int x = ensemble[n];
            ensemble[n] = TIRE;
            printf ("%4d", x);
         }
      }
      printf ("\n");
      free (ensemble), ensemble = NULL;
   }
}
 
int main (void)
{
 
   int i;
   randomize ();
   for (i = 0; i < 10; i++)
   {
      int ensemble[] = { -4, -1, 2, 5, 8, 12, 34 };
      tirage (ensemble, sizeof ensemble / sizeof *ensemble);
   }
   return 0;
}

avec

http://emmanuel-delahaye.developpez....d/inc/random.h

Il n'y a rien à permuter...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
   5   8  -1  34   2  -4  12
   2  -4   5  12  34   8  -1
  -4   8  -1  12  34   5   2
   5   8  12  34  -1   2  -4
   5   2  34  -4  -1   8  12
   2  34  12  -4   5   8  -1
  -4  34   2   5  -1   8  12
  -4  12   5  -1   2   8  34
   8  -1   2  34  12  -4   5
  -4  12   5  34  -1   8   2
 
Press ENTER to continue.

Voilà comment je ferais:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
#define NB_ELEMS(a) ( sizeof (a) / sizeof *(a) )
int random_value(int n);
void shuffle_int_array(int *array, size_t size);
 
int main(void)
{
    int set[] = {1, 2, 3, 4, 5, 6, 7, 8};
    size_t i;
 
    srand((unsigned int) time(NULL));
 
    shuffle_int_array(set, NB_ELEMS(set));
 
    /* -tc- Il suffit maintenant de parcourir le tableau pour simuler ton tirage*/
    for (i = 0; i < NB_ELEMS(set); i++)
    {
        printf("%d ", set[i]);
    }
    printf("\n");
 
    return EXIT_SUCCESS;
}
 
/* -tc- Melange les elements du tableau en place. Base sur l'algorithme 
   de Fisher-Yates (Durstenfeld) */
void shuffle_int_array(int *array, size_t size)
{
    if (array != NULL && size > 1)
    {
        size_t i, k;
        int tmp;
 
        for (i = size - 1; i > 0; i--)
        {
            k = random_value(i);
            if (k != i)
            {
                tmp = array[i];
                array[i] = array[k];
                array[k] = tmp;
            }
        }
    }
}
 
/* -tc- tire de la FAQ-C */
int random_value(int n)
{
    int partSize = (n == RAND_MAX) ? 1 : 1 + (RAND_MAX - n) / (n + 1);
    int maxUsefull = partSize * n + (partSize - 1);
    int draw;
 
    do
    {
        draw = rand();
    }
    while (draw > maxUsefull);
 
    return draw / partSize;
}

Thierry

Citation:

Envoyé par Emmanuel Delahaye

Je ne vois pas trop où est le problème...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
#include <limits.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#include "ed/inc/random.h"
 
/* choisir une valeur hors de l'ensemble ... */
#define TIRE INT_MAX
 
static void tirage (int const a[], size_t nb)
{
 
   int *ensemble = malloc (sizeof *ensemble * nb);
   if (ensemble != NULL)
   {
      size_t i;
      memcpy (ensemble, a, sizeof *ensemble * nb);
 
      for (i = 0; i < nb; i++)
      {
         int n;
         do
         {
            n = random (nb);
         }
         while (ensemble[n] == TIRE);
         {
            int x = ensemble[n];
            ensemble[n] = TIRE;
            printf ("%4d", x);
         }
      }
      printf ("\n");
      free (ensemble), ensemble = NULL;
   }
}
 
int main (void)
{
 
   int i;
   randomize ();
   for (i = 0; i < 10; i++)
   {
      int ensemble[] = { -4, -1, 2, 5, 8, 12, 34 };
      tirage (ensemble, sizeof ensemble / sizeof *ensemble);
   }
   return 0;
}

ce code fini en un temps indeterminé