1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.
Dismiss Notice
Welcome to our Education website, plz like our page facebook to support us. Thank You and wish you good navigation

fonction recursive en c exercice corrigé: recursivité en c

abdelouafiMay 28, 2017

    1. abdelouafi

      abdelouafi Administrator Staff Member

      Messages:
      295
      Likes Received:
      9
      Trophy Points:
      18
      Joined
      Sep 13, 2016
      L'objectif de ces exercices est de maîtriser la récursivité en c.

      Exercice 1:

      Ecrire un programme qui permet d'afficher, de façon récursive, les 20 premiers nombres:

      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20


      Exerice 2:

      Ecrire un programme en C qui permet de calculer la somme des nombres de 1 à n en utilisant la récursivité?

      Exemple d'exécution:

      Donnez votre nombre n: 5

      La somme est: 15



      Exercice 3 :

      Ecrire un programme en c qui affiche la série de Fibonacci en utilisant la récursivité ?

      Exemple d’exécution :

      Donnez le nombre des termes de la suite : 10

      mso-bidi-font-family:"Times New Roman";color:black">Le programme affichera : 1 1 2 3 5 8 13 21 34 55

      Exercice 4

      En utilisant la récursivité, écrire un programme en c qui permet d’afficher les éléments d’un tableau

      Donnez la taille du tableau : 4

      Donnez les éléments de ce tableau :

      Element 0 : 15

      Elément 1 : 4

      Elément 2 : 5

      Elément 3 : 8

      Les éléments de ce tableau : 15 4 5 8

      Exercice 5 :

      Ecrire un programme en c qui permet de Compter les chiffres d'un nombre donné

      Donnez un nombre : 21

      Le nombre de chiffre dans ce nombre est : 2

      Exercice 6:
      Ecrire un programme en c qui permet de calculer la somme des chiffres d'un nombre donné

      Donnez un nombre : 21

      La somme des chiffres dans ce nombre est : 3


      Exercice 7:
      Ecrire un programme qui détermine le PGCD de deux nombre mais en utilisant la récursivité?
      Exemple d'exécution:
      Donnez le premier nombre: 10
      Donnez le deuxième nombre: 40
      Le PGCD de 10 et 40 est : 10

      Exercice 8:
      Ecrire un programme qui détermine le plus grand élément dans un tableau en utilisant la récursivité?
      Exemple d'exécution:
      Donnez la taille du tableau : 3
      Donnez les 3 éléments de ce tableau:
      Elément 0 : 6
      Elément 1: 18
      Elément 2: 45

      L'élément le plus grand est : 45

      Exercice 9:
      Ecrire un programme qui permet d'inverser une chaîne de caractère?
      Exemple d'exécution:
      Donnez une chaîne de caractère: Exam
      L'inverse est : maxE

      Exercice 10:

      Ecrire un programme qui permet de calculer le factoriel(n!) d'un nombre n?
      Exemple d'exécution:
      Donnez un nombre: 4
      Son factoriel est: 24

       
      Last edited: May 31, 2017
      Loading...
      Exercice 1:
      Code:
      #include<stdio.h>
      int  fct(int);
      int main()
      {
          int n = 1;
          printf("\n\n fonction récursive :\n");
      
          printf(" Les 20 premiers nombres sont :");
          fct(n);
          printf("\n\n");
          return 0;
      }
      int fct(int n)
      {
          if(n<=50)
          {
               printf(" %d ",n);
               fct(n+1);
          }
      }
      Exercice 2:
      Code:
      #include<stdio.h>
      int somme(int);
      int main()
      {
         int n1;
         int s;
          p
         printf(" Donnez votre nombre n : ");
         scanf("%d", &n1);
         s = somme(n1);
         printf("\n La somme de 1 à %d est: %d\n\n", n1, s);
         return (0);
      }
      int somme(int n1)
      {
         int res;
         if (n1 == 1)
         {
            return (1);
         } else
         {
            res = n1 + somme(n1 - 1); //appel récursive de la fonction somme
         }
         return (res);
      }
      Exercice 3:
      Code:
      #include<stdio.h>
      int T;
      int fibonacci(int n, int num);
      void main()
      {
         static int n = 0, num = 1;
      
         printf(" Donnez le nombre de termes : ");
         scanf("%d", &T);
      printf("Les séries sont:\n");
         printf(" 1  ");
         fibonacci(n, num);
          printf("\n\n");
      }
      int fibonacci(int n, int num)
      {
         static int i = 1;
         int nsuiv;
         if (i == T)
            return (0);
         else
         {
            nsuiv = n + num;
            n = num;
            num = nsuiv;
            printf("%d  ", nsuiv);
            i++;
            fibonacci(n, num); //ici la récursivité
         }
         return (0);
      }
      
      
      Exercice 4:
      Code:
      #include <stdio.h>
      #define MAX 100
      
      void Tab(int t1[], int st, int l);
      int main()
      {
          int t1[MAX];
          int n, i;
      
      
          printf(" donnez la taille de ce tableau :");
          scanf("%d",&n);
      
          printf(" donnez l’élément %d du tableau :\n",n);
          for(i=0;i<n;i++)
              {
                printf(" element - %d : ",i);
                scanf("%d",&t1[i]);
              }
      
          printf(" Les elements de ce tableaux sont : ");
          Tab(t1, 0, n);
          printf("\n\n");
          return 0;
      }
      
      void Tab(int t1[], int st, int l)
      {
          if(st >= l)
              return;
       
              printf("%d  ", t1[st]);
      
              Tab(t1, st+1, l);//ici la récursivité
      }
      
      
      Exercice 5:
      Code:
      #include<stdio.h>
      
      int chiffre(int n1);
      int main()
      {
        int n1,nbr;
      
          printf(" donnez un nombre : ");
          scanf("%d",&n1);
      
          nbr = chiffre(n1);
      
          printf(" Le nombre de chiffre dans ce nombre est :  %d \n\n",nbr);
          return 0;
      }
      
      int chiffre(int n1)
      {
          static int nbr=0;
      
           if(n1!=0)
           {
                nbr++;
               chiffre(n1/10); // ici la récursivité
          }
      
          return nbr;
      }
      
      
      Exercice 6:
      Code:
      #include <stdio.h>
      int Somme(int num);
      int main()
      {
          int n1, sum;
      
          printf(" Donnez un nombre: ");
          scanf("%d", &n1);
       
          sum = Somme(n1);//appel de la function somme
       
          printf(" La somme des chiffre de %d = %d\n\n", n1, sum);
       
          return 0;
      }
      
      int Somme(int n1)
      {
          if(n1 == 0)
              return 0;
           
          return ((n1 % 10) + Somme(n1 / 10));//récursivité
      }
      
      
      Exercice 7:
      Code:
      #include<stdio.h>
      
      int PGCD(int a,int b);
      int main()
      {
        int a,b,gcd;
      
      
        printf(" Donnez le premier nombre : ");
        scanf("%d",&a);
        printf(" Donnez le deuxième nombre: ");
        scanf("%d",&b);
      
        gcd = PGCD(a,b);
        printf("\n Le PGCD de %d et %d est: %d\n\n",a,b,gcd);
        return 0;
      }
      
      int PGCD(int a,int b)
      {
           while(a!=b)
           {
                if(a>b)
                    return PGCD(a-b,b); //récursivité
                else
                   return PGCD(a,b-a); //récursivité
           }
           return a;
      }
      
      
      Exercice 8:
      Code:
      #include<stdio.h>
      #define MAX 100
      
      int Plusgrand(int []);
      int n;
      
      int main()
      {
          int tab[MAX],a,i;
       
      
            printf(" Donnez la taile de ce tableau :");
             scanf("%d",&n);
       
             printf(" Donnez les  %d éléments de ce tableau :\n",n);
             for(i=0;i<n;i++)
              {
                printf(" Elément - %d : ",i);
                scanf("%d",&tab[i]);
              } 
          a=Plusgrand(tab);//appel de la fonction element
          printf(" Le plus grand element est: %d\n\n",a);
          return 0;
      }
      int Plusgrand(int tab[])
      {
          static int i=0,a =-9999;
          if(i < n)
          {
               if(a<tab[i])
                 a=tab[i];
            i++;
            Plusgrand(tab);//récursivité
          }
          return a;
      }
      
      
      Exercice 9:
      Code:
      #include<stdio.h>
      #define MAX 100
      char* Inverse(char[]);
      
      int main()
      {
      
          char str1[MAX],*str2;
        
        
      
          printf(" Donnez la chaîne de caractère: ");
          scanf("%s",str1);
      
          str2 = Inverse(str1
      
          printf(" Son inverse est: %s\n\n",str2);
          return 0;
      }
      char* Inverse(char str1[])
      {
          static int i=0;
          static char str2[MAX];
          if(*str1)
          {
               Inverse(str1+1);//ici la récursivité
               str2[i++] = *str1;
          }
          return str2;
      }
      
      
      Exercice 10:
      Code:
      #include<stdio.h>
      int factoriel(int);
      
      int main()
      {
        int n1,f;
         
           
        printf(" Donnez un nombre : ");
        scanf("%d",&n1);
        f=factoriel(n1);
        printf(" Le factoriel de %d est : %d\n\n",n1,f);
        return 0;
      }
      
      int factoriel(int n)
      {
         if(n==1)
             return 1;
         else
             return(n*factoriel(n-1));// récursivité
      }
      
      

Share This Page

Share