SERIE D’EXERCICES SUR LES PROCEDURES ET LES FONCTIONS
Niveau 1ère année tranc commun MI
Exercice 1 (TD et TP)
Un nombre parfait est un entier positif supérieur à 1, égal à la somme de ses diviseurs ; on ne
compte pas comme diviseur le nombre lui-même.
Exemple : 6 est un nombre parfait puisque : 6 = 3 + 2 + 1.
Ecrire une procédure qui confirme si un entier est un nombre parfait ou nom.
Utiliser cette procédure pour chercher les nombres parfaits entre 1 et 10000.
Exercice 2 (TD et TP)
Ecrire une procédure qui prend pour arguments un entier n (la taille du tableau), le tableau de réels
T et affiche le plus grand élément du tableau T ainsi que sa position dans le tableau.
Exercice 3 (TD et TP)
Deux nombres sont opposés si leur somme est égale à 0. Deux nombres sont inverses si leur
produit est égal à 1. Ecrire deux procédures qui testent si deux nombres sont opposés ou non et si
sont inverses ou non.
Exercice 4 (A DOMICILE)
Ecrire une procédure qui permet d’entrer deux valeurs M et N et d’afficher toutes les valeurs pairs
entre M et N.
Exercice 5 (TD et TP)
Ecrire un programme qui calcule la partie entière d’un nombre positif à l’aide d’une fonction.
Exercice 6 (TD et TP)
Ecrire un programme (Algo + C) qui permet de synthétiser un tableau de N valeurs réels (N est
déterminé par l’utilisateur). Cette synthèse se repose sur l’utilisation des fonctions suivantes :
La fonction SommeTab (N,Tab) qui retourne la somme des N valeurs réelles stockées
dans le tableau Tab.
La fonction MoyenneTab (N,Tab) qui retourne la moyenne des N valeurs réelles stockées
dans le tableau Tab. Cette fonction devra impérativement utiliser la fonction SommeTab
écrite précédemment.
Les fonctions MaxTab(N,Tab) et MinTab(N,Tab) qui retournent respectivement la valeur
maximale et la valeur minimale des N valeurs réelles stockées dans le tableau Tab.
Exercice 7 (A DOMICILE)
Ecrire une fonction (Algo + C) qui calcule le factoriel d’un entier afin de l’utiliser pour calculer la
somme de la série : 1/1 ! + 2/2 !+………………+ n/n ! (n est déterminé par l’utilisateur)
Exercice 8 (TD et TP)
Soit le programme suivant :
#include <stdio.h>
void somcar(int a,int b, int z)
{
z=a*a+b*b;
return ;
}
int main()
{
int x,y,R;
printf ("donner x:");
scanf("%d",&x);
printf ("donner y:");
scanf("%d",&y);
r=0;
somcar(x,y,R);
printf ("la somme de %d^2 + %d^2 = %d \n",x,y,R);
return 0;
}
1- Ecrire son algorithme
2- Donner la valeur de R après l’exécution de ce programme pour les valeurs suivantes :
x=3, y=4
- Qu’est-ce que vous avez remarquez ? pourquoi ?
- Comment peut-on remédier ce problème
3- Substituer cette procédure par une fonction.
Exercice 9 (TD et TP)
On demande d'écrire un programme avec une fonction qui transforme un nombre fourni par
L’utilisateur dans une zone de saisie en sa valeur absolue (transformation réelle).
Exercice 10 (TD et TP)
La fonction d'Ackermann est la fonction récursive définie par :
A(0,n) = n+1;
m ≥ 1, A(m,0) = A(m-1,1);
m ≥ 1, n ≥ 1, A(m,n) = A(m-1,A(m,n-1)).
Ecrire un algorithme pour cette fonction et un programme C qui utilise cette fonction pour
1 <= m <= 2 et 1 <= n <= 10
Exercice 11 (TD et TP)
La suite de Fibonacci est définie par les formules suivantes :
Fib (0) = 0
Fib (1) = 1
Fib (n) = Fib (n−2) + Fib (n−1) pour n ≥ 2.
Ecrire un algorithme pour cette fonction et un programme C qui utilise cette fonction pour
calculer n’importe quel terme.
Exo1
Algorithme Nombre_parfait #include <stdio.h>
Variables void parfait(int a)
x : entier {
Procédure Parfait (a : entier) int i,somme;
Variables somme=0;
i, somme : entier ; for (i=1;i<a;i++)
Début if (a%i==0)
Somme ← 0 somme=somme+i;
Pour i Allant de 1 A a-1 Faire if (somme==a)
Si (a mod i)=0 Alors printf ("le nombre %d est parfait \n",a);
somme ←somme+i return ;
Fin si }
Fin Pour int main()
Si (somme = a) Alors {
Ecrire ( a,ʺ est un nombre parfaitʺ) int x;
FinSi for (x=1;x<=10000;x++)
Fin Procédure parfait(x);
Début return 0;
Pour x Allant de 1 A 10000 Faire }
Parfait(x)
Fin Pour
Fin
Exo2
Algorithme maximum #include <stdio.h>
Variables void Max_tableau (int n, float tab[])
i,a : entier {
X : tableau [] de réel int i, indice;
Procédure Max_tab (N : entier, TAB :tableau [ ] de réel) float max;
Variables max=tab[0]; indice=0;
i,indice : entier ; for (i=0;i<n;i++)
max : réel printf("%.2f \t",tab[i]);
Début printf("\n");
max ← TAB[0] for (i=1;i<n;i++)
indice ← 0 if (tab[i]>max)
Pour i=0 À N FAIRE {max=tab[i]; indice=i;}
Si (TAB[i] >max) Alors printf("le Max = %.2f et sa position = %d
max ← TAB[i] \n",max,indice+1);
indice ← i return ;
Fin si }
Fin pour int main()
Ecrire (‘Le max =’, max , ‘Avec l’indice =’,i) {
Fin Procédure int i,a;
Début printf(" Donner la dimension du tableau: ");
Ecrire (’Donner la dimension de votre tableau : ‘) scanf("%d",&a);
Lire (a) float X[a];
Pour i Allant de 0 A a-1 Faire printf("Introduiser les elements du tableau: \n ");
Lire (X[i]) for (i=0;i<a;i++)
Fin Pour { printf("tab[%d]:",i+1);
Max_tab(a, X) scanf("%f",&X[i]);}
Fin printf("\n");
Max_tableau(a,X);
return 0;
}
Exo 3
Algorithme test_nombre
Variables
x,y : entier
Procédure Oppose (a : entier, b:entier)
Début
Si (a + b = 0) Alors
Ecrire (a,’ et’, b,’ sont opposés)
Fin si
Fin Procédure
Procédure Inverse (a : entier, b : entier)
Début
Si (a * b = 1) Alors
Ecrire (a,’ et’, b,’ sont inverses)
Fin si
Fin Procédure
Début
Ecrire (‘Donner x :’)
Lire (x)
Ecrire (‘Donner y :’)
Lire (y)
Oppose (x, y)
Inverse (x, y)
Fin
Exo 5
Algorithme Partie_Entiere #include <stdio.h>
Variables int entiere (float x)
a : réel {
Fonction entiere (x : reel) : entier int y;
Variable y=0;
y : entier while (y<x)
Debut y=y+1;
y← 0 ; y=y-1;
Tantque (y < x) faire return y;
y←y + 1 }
FinTanque int main()
y ← y-1 {
return y float a;
Fin fonction printf ("donner a:");
Début scanf("%f",&a);
Lire (a) printf ("la partie entiere de %f = %d \n",a ,
Ecrire (entiere (a)) entiere (a));
Fin return 0;
}
Exo 6
Algorithme Synthese_TAB #include <stdio.h>
Variables float SommeTab( int N, float Tab [ ] )
Dim, i : entier {
X : tableau [] de réel int i ;
Fonction SommeTab (N : entier, TAB :tableau [ ] float somme =0;
de réel) : entier for ( i =0; i<N; i++)
Variables somme += Tab [ i ] ;
i : entier ; return somme ;
somme : réel }
Début float MoyenneTab( int N, float Tab [ ] )
Somme ← 0 {
Pour i=0 À N-1 FAIRE return (SommeTab(N,Tab)/N);
somme ← somme + TAB[i] }
Fin pour float MaxTab( int N, float Tab [ ] )
return somme {
Fin Fonction int i ;
Fonction MoyenneTab (N : entier, TAB :tableau [ float max = Tab [ 0 ] ;
] de réel) : entier for ( i =1; i<N; i++)
Début {
return (SommeTab(N,TAB)/N) if (Tab [ i ]> max )
Fin Fonction max = Tab [ i ] ;
Fonction MaxTab (N : entier, TAB :tableau [ ] de }
réel) : entier return max ;
Variables }
i : entier ; float MinTab( int N, float Tab [ ] )
Max : réel {
Début int i ;
Max ← TAB[0] float min = Tab [ 0 ] ;
Pour i=1 À N-1 FAIRE for ( i =1; i<N; i++)
Si (TAB [ i ]> max ) Alors {
Max ← TAB[i] if (Tab [ i ]< min )
Fin Si min = Tab [ i ] ;
Fin pour }
return Max return min ;
Fin Fonction }
Fonction MinTab (N : entier, TAB :tableau [ ] de int main()
{
réel) : entier
int i, Dim;
Variables
printf("Donner la dimension de votre tableau: ");
i : entier ;
scanf("%d",&Dim);
Min : réel
float X[Dim];
Début
for (i=0;i<Dim;i++) {
Min ← TAB[0]
printf("X[%d] =", i+1);
Pour i=1 À N-1 FAIRE
scanf("%f",&X[i]); }
Si (TAB [ i ] < Min ) Alors
printf("La somme des elements de ce tableau =
Min ← TAB[i]
%f\n",SommeTab (Dim,X));
Fin Si printf("La moyenne des elements de ce tableau =
Fin pour %f\n",MoyenneTab(Dim,X));
return Min
printf("Le Max dans ce tableau =
Fin Fonction %f\n",MaxTab(Dim,X));
printf("Le Min dans ce tableau =
Début %f\n",MinTab(Dim,X));
Lire (Dim)
return 0;
}
Pour i=0 À Dim-1 FAIRE
Lire (X[i])
Fin pour
Ecrire (‘La somme = ‘, SommeTab(Dim,X))
Ecrire (‘La Moyenne = ‘, MoyenneTab(Dim,X))
Ecrire (‘Le Max = ‘, MaxTab(Dim,X))
Ecrire (‘Le Min = ‘, MinTab(Dim,X))
Fin
Exo 8
Le passage du programme vers son algorithme peut être comme suit :
Algorithme Somme_carre
Variables
x,y,R :entier
Procédure somcar (a : entier, b : entier, z : entier)
Début
z=a*a+b*b
Fin Procédure
Début
Ecrire (ʺDonner x : ʺ )
Lier (x)
Ecrire (ʺDonner y : ʺ )
Lire (y)
r←0
somcar(x,y,R)
Ecrire (R)
Fin
Pour x=3 et y=4 on trouve que R =0 ? Parce que le mode de passage utilisé dans ce
programme est un mode de passage par valeur.
Nous pouvons remédier ce Pb par l’utilisation du mode de passage par adresse (par
variable). Dans ce cas la procédure doit être déclarée dans l’algorithme comme suit :
Procédure somcar (a : entier, b : entier, var z : entier)
Et le programme doit être changé comme suit :
#include <stdio.h>
void somcar (int a,int b, int *z) /* z doit être précédé par * pour désigner une variable */
/* adresse (Pointeur) */
{
*z=a*a+b*b;
return ;
}
int main()
{
int x,y,R;
printf ("donner x:");
scanf("%d",&x);
printf ("donner y:");
scanf("%d",&y);
R=0;
somcar(x,y, &R); /* R doit être précédé par & pour désigner qu'on utilise l'adresse de R */
printf ("la somme de %d^2 + %d^2 = %d \n",x,y,R);
return 0;
}
Nous pouvons substituer cette procédure par une fonction comme suit :
Fonction somcar (a : entier, b : entier) : entier
Variables z :entier
Début
z=a*a+b*b
Fin Fonction
int somcar (int a , intb)
{int z
z=a*a+b*b;
return z;
}
Exo 9
Algorithme val_absolue
Variables
x:entier
Fonction absolue (Var a : entier) : entier /* Var pour désigner le passage par variable (adresse)
Début
Si (a<0) alors
a← -a
Fin si
Fin fonction
Début
Ecrire (ʺDonner x : ʺ )
Lier (x)
x=absolue(x)
ecrire (‘ la valeur absolut de x=’,x)
Fin
Programme C
#include <stdio.h>
int absolut(int *a)
{
if (*a<0)
*a=-*a;
return *a;
}
int main()
{
int x;
printf ("donner x:");
scanf("%d",&x);
x=absolut(&x);
printf ("la valeur absolut de x = %d\n",x);
return 0;
}
Exo 10
Fonction Ackermann (n, m: entier): entier #include <stdio.h>
Var #include <stdlib.h>
résultat: entier; int Ackermann (int M,int N)
Début {
Si (m = 0) Alors if(M == 0) return N+1;
résultat := n + 1; else
Sinon {
Si (n = 0) Alors if(N == 0) return Ackermann(M-1,1);
résultat := Ackermann(m - 1, 1) else return Ackermann(M-1,(Ackermann(M,N-1)));
Sinon }
résultat := Ackermann(m - 1, }
Ackermann(m, n - 1)); int main()
FinSi {
Return résultat; int I,J;
Fin for(I=1;I<=2;I++) for(J=1;J<=10;J++) {
printf("Ackermann(%d,%d)=%d\n",I,J,Ackermann(I,J));
}
return 0;
}
Exo 11
