Print_combn

Bonjour,

Je voudrais écrire une fonction qui affiche toutes les différentes combinaisons de n chiffres dans l'ordre croissant.
* n sera tel que : 0 < n < 10.
* Si n = 2, cela donne quelque chose comme ça :
01, 02, 03, ..., 09, 12, ..., 79, 89
* Le prototype de la fonction doit être :
void print_combn(int n);

Alors j'ai penser comme logique :

calculer v valeur maximum du nombre traité suivant n (ex pour n = 3 v = 999)

boucler de 0 à v

construire une chaine c de n caractères à partir de la valeur en cours (valeur justifiée à droite remplie de 0 à gauche si nécessaire)

parcourir c et tester que les caractères sont croissants

si c'est le cas afficher c

J'ai donc commencer à écrire ça comme bout de code mais je n'arrive pas à continuer ...


void print_combn(int n)
{
int vmax = 10;
int i = 1;

while (i < n)
{
vmax *= 10;
i++;
}
i = 1;
while (i < vmax)
{
char tab[n];

i++;
}
}

Voilà, so help plz !!! :3

ps : la seule fonction que j'ai le droit d'utiliser est putchar.

2 réponses

  • Votes
  • Date
  • Date décroissante
  1. Salut, et merci d'avoir répondue
    Oui je l'ai déjà fait avec 3 chiffres, mais le pb c'est quand je connais pas le nbr de chiffres ... donc j'ai bien penser à faire un tableaux comme ça j'ai le nbr de variable qu'il me faut mais c'est pour la suite que je coince ...

    ma fonction pour 3 chiffres:


    void print_comb()
    {
    char a;
    char b;
    char c;

    a = '0';
    b = '0';
    c = '0';
    while(a <= '9')
    {
    while(b <= '9')
    {
    while(c <= '9')
    {
    if(a < b && b < c)
    {
    ft_putchar(a);
    ft_putchar(b);
    ft_putchar(c);
    ft_putchar(' ');
    }
    c++;
    }
    c = '0';
    b++;
    }
    b = '0';
    a++;
    }
    ft_putchar('\n');
    }

    1. Contributeur
      Relis mon poste ^^.

      Reste à trouver l'astuce pour les n boucles for, pour les variables i,j,k (indice : tableau).
      Donc déjà remplace a par tab[0], b par tab[1], c par tab[2].

      while(b <= '9')
      C'est pas ce que j'ai dit... J'ai dit :
      Pour la 2nde, tu fais de i à 9 (variable j) et tu affiches j donc :
      for(b=a; b<10; b++) ou plutôt for(tab[1]=tab[0]; tab[1]<10; tab[1]++)
      Et là tu remarque que c'est toujours de la forme : for(tab[i]=tab[i-1]; tab[i]<10; tab[i]++)
      reste à savoir dans quoi mettre ta boucle for.
      Etc.
    2. Contributeur
      Je viens d'essayer pour voir.
      Ca se fait très bien avec la récursivité (si tu connais).
    3. ben justement oui je pensais à la récursivité, mais je suis vraiment pas à l'aise avec le concept ...
      j'ai vraiment du mal, la seule fonction que j'ai faite en récursivité, c'est la fonction factoriel donc ^^

      mais je vais essayer quand même ... on va voir ce que ça donne mais je suis pas sûr du résultat x)
    4. Contributeur
      Beh c'est l'occasion de progresser :-p.
      En argument de la fonction, tu fais passer le nombre de chiffres. Si le nombre est 1 chiffre, tu peux faire l'affichage.
      Ensuite tu trouves la relation entre un nombre de n chiffres et de n-1 chiffres (boucle for). Et le tour est joué.
      Si tu n'y arrives vraiment pas, tu peux partir de ce prototype :
      void parcours(char * const unit, const int depth, const int deb, const int taille)
      unit c'est le tableau qui contient les chiffres
      depth c'est la profondeur
      deb c'est le chiffre à partir duquel on va afficher
      taille c'est le nombre de chiffres entré par l'utilisateur au début.