Discussion :

[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 ?

[Skyounet]

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.

[condor_01]

[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.

[condor_01]

ça semble une bonne idée
merci

[Franck.H]

ç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

[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.

[screetch]

generer la permutation n'est pas forcement un probleme simple

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Emmanuel Delahaye]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Thierry Chappuis]

Voilà comment je ferais:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[screetch]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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é