Discussion :

[m0ul3sh0t]

Bonsoir,

je viens faire appel à vous parce que je reprends des "vieux" exo (qui datent d'il y a 3semaines) et je suis bloqué sur un exo (que je n'avais déjà pas réussit à faire).

L'énoncé est celui la:

Écrire une fonction qui affiche toutes les différentes combinaisons
de n chiffre(s), dans l'ordre croissant. Si n=2 on a :
"01, 02, 03, ..., 09, 12, ..., 79, 89"

Elle devra être prototypée de la façon suivante :

int my_aff_combn(int n);

j'avais le "même" exercice à faire avec 3 chiffres ("012, 013, 014, 015, 016, 017, 018, 019, 023, ..., 789") et je le faisais avec ce code:

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
int     my_aff_comb_secondary(char i, char j, char k)
{
  if (i == 55 && j == 56 && k == 57)
    {
      my_putchar(i);
      my_putchar(j);
      my_putchar(k);
    }
  else
    {
      my_putchar(i);
      my_putchar(j);
      my_putchar(k);
      my_putchar(',');
      my_putchar(' ');
    }
}
 
int     my_aff_comb()
{
  char  i;
  char  j;
  char  k;
 
  i = 48;
  while (i <= 55)
    {
      j = 49;
      while (j <= 56)
        {
          k = 50;
          while (k <= 57)
            {
              if (i != j && j != k && k != i && i < j && j < k)
                {
                  my_aff_comb_secondary(i, j, k);
                }
              k++;
            }
            }
          j++;
        }
      i++;
    }
}

Je ne vois pas du tout quel algorithme utiliser ou comment adapter mon exercice précédent pour y arriver.
Je ne demande pas un code mais un indice de réflexion

[PRomu@ld]

Une idée, bête et méchante : avoir un algo qui va générer toutes les permutations puis, dans une deuxième étape enlever toutes celles qui ne sont pas dans un ordre croissant. (ça peut se combiner)

Pour ce qui est de la génération des permutations, ça n'est pas une chose nouvelle, une petite recherche sur le forum pourra t'aider.

[pseudocode]

Pour ce qui est de la génération des permutations, ça n'est pas une chose nouvelle, une petite recherche sur le forum pourra t'aider.

J'ai posté un code dans "contribuez" qui fait ce que tu veux, meme si ce n'est pas son objectif premier... sauras-tu le retrouver ?

Elle devra être prototypée de la façon suivante :
int my_aff_combn(int n);

c'est quoi la spec pour la valeur de retour ?

[m0ul3sh0t]

c'est quoi la spec pour la valeur de retour ?

si j'ai bien comprit ta question, la fonction renvoie un entier
si non qu'entends tu par la spec?

http://www.developpez.net/forums/sho...d.php?t=429282

je suppose que tu parlais de ce post

Une idée, bête et méchante : avoir un algo qui va générer toutes les permutations puis, dans une deuxième étape enlever toutes celles qui ne sont pas dans un ordre croissant. (ça peut se combiner)

Pour ce qui est de la génération des permutations, ça n'est pas une chose nouvelle, une petite recherche sur le forum pourra t'aider.

qu'entends tu par permutation?
parce que ce qui me fait bloquer c'est la gestion des n chiffres.
Pour 2, 3, 4 chiffres je saurais le faire en déclarant 2, 3 ou 4 variables que j'incrémenterais l'une après l'autre

[Jean-Marc.Bourguet]

Deux pistes:
* utiliser la récursivité pour imbriquer N boucles
* faire une fonction auxilliaire: combinaison_suivante et l'appeler tant qu'il y a des combinaisons suivantes.

[pseudocode]

si j'ai bien comprit ta question, la fonction renvoie un entier
si non qu'entends tu par la spec?

je voulais savoir quelle etait la valeur de cet entier que la fonction doit renvoyer.

je suppose que tu parlais de ce post

yes.

parce que ce qui me fait bloquer c'est la gestion des n chiffres.
Pour 2, 3, 4 chiffres je saurais le faire en déclarant 2, 3 ou 4 variables que j'incrémenterais l'une après l'autre

Et oui... c'est pas possible de changer dynamiquement le nombre de boucles imbriquées. Comme le dit Jean-Marc.Bourguet, dans des cas comme ca tu as le choix entre la recursion ou l'iterateur. Dans les deux cas tu auras besoin de créer une fonction auxiliaire pour faire le travail.

NB: Le code dans mon post utilise la recursion, ce qui est sans doute le plus simple dans le cas présent (profondeur de recursion=nombre de chiffres)

[m0ul3sh0t]

je voulais savoir quelle etait la valeur de cet entier que la fonction doit renvoyer.

dans les deux autres exercises, on devait afficher une série de 3 chiffres (012) et une série de 4 chiffre (00 01). Je ne vois pas ce que tu entends par la valeur de cette entier
excuses moi je débute en langage C et j'ai pas mal de lacune encore :$

[pseudocode]

dans les deux autres exercises, on devait afficher une série de 3 chiffres (012) et une série de 4 chiffre (00 01). Je ne vois pas ce que tu entends par la valeur de cette entier
excuses moi je débute en langage C et j'ai pas mal de lacune encore :$

Vue que la fonction est censée renvoyer un "int" je voulais savoir quel etait ce "int". Ca pourrait etre le nombre de combinaison, ou autre chose...

C'est mon coté "integriste" de la programmation par contrat. Quand on definit une signature c'est parcequ'on en a besoin. Mais c'est pas grave. Oublie ma question.

[Trap D]

Autre possibilité, tu prends un tableau Comb de dimension n (n étant le nombre d'éléments des combinaisons, que tu initialises avec 0, 1 .. n-1, puis tu utilises un index ind de la façon suivante (on suppose que les indices du tableau varie entre 1 et n

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
ind = n
 
tant que ind > 0 faire
   editer la combinaison
   Comb(ind) <- Comb(ind) + 1
 
   % on teste si la valeur du tableau pointée par l'index est 10
   tant que si Comb(ind) > 9 alors
      ind <- ind - 1
 
      % on décrémente l'index tant que les valeurs du tableau sont consécutives
      tant que ind > 0 et Comb(ind) = Comb(ind + 1) - 1
         ind = ind - 1
      fin tant que
 
      % si on n'a pas terminé (index à 0) on incrémente
      % les valeurs du tableau en remontant l'index
      si ind > 0 alors
         Com(ind) <- Comb(ind) + 1
         faire
            Comb(ind+1) <- Comb(ind) + 1
            ind <- ind + 1
         tant que ind < n et Comb(ind) < 10
      fin si
    fin tant que
fin