Série de révision pour rattrapage

Ecrire un programme en langage C qui :

Exercice 1 :
permet de calculer le factoriel d’un nombre saisi au clavier. Trouvez la valeur maximale
pouvant être calculée.

Exercice 2 :
donne à l'utilisateur de saisir une série des nombres jusqu'à N entiers et qui affiche leur
somme, leur produit et leur moyenne. Le nombre N est à entrer au clavier.
a) avec la boucle while.
b) avec la boucle do - while.
c) avec la boucle for.
d) Laquelle des trois variantes est la plus naturelle pour ce problème?

Exercice 3 :
permet de calculer la somme, le produit et la moyenne d'une suite de chiffres non nuls
entrés au clavier, sachant que la suite est terminée par zéro. Retenez seulement les chiffres
(0, 1, 2 ... 9) lors de l'entrée des données et effectuez un signal sonore si les données sortent
de ce domaine.

Exercice 4 :
permet de calculer les soustractions successives le quotient entier et le reste de la division
entière de deux nombres entiers entrés par l'utilisateur.

Exercice 5 :
Ecrire un programme en langage C qui permet de saisir un nombre entier positif et
d’afficher la suite 1,2,3,4,…,n (avec while).

Exercice 6 :
refaire l'exercice précédent en Algorithme et sa traduction en langage C mais avec la boucle
do…while.

Exercice 7 :
refaire l'exercice précédent en Algorithme et sa traduction en langage C mais avec la boucle
for.

Exercice 8 :
Ecrire un programme en langage C qui permet desaisir un nombre entier positif et
d’afficher la suite n, n-1, n-2,…4, 3, 2, 1, 0 (avec while).

Exercice 9 :
refaire l'exercice précédent en langage C mais avec la boucle do…while.

Exercice 10 :
refaire l'exercice précédent en Algorithme et sa traduction en langage C mais avec la boucle
for.

Exercice 11 :
Ecrire un programme en langage C qui permet de calculer le factoriel d’un nombre entier
positif saisir par l'utilisateur. (avec while).

Exercice 12 :
refaire l'exercice précédent en Algorithme et sa traduction en langage C, C++,C# et Java,
mais avec la boucle do…while.

Exercice 13 :
refaire l'exercice précédent en Algorithme et sa traduction en langage C mais avec la boucle
for.

Exercice 14 :
Ecrire un programme en langage C qui permet de calculer la somme des N premiers termes
de la série harmonique suivant : 1 + 1/2 + 1/3 + 1/4 + ... + 1/N.

Exercice 15 :
Ecrire un programme en langage C qui permet d’afficher la table de multiplication d’un
nombre saisir par l’utilisateur comme suit :
4*1=4
4*2=8
...
4 * 9 = 36
(avec while).

Exercice 16 :
refaire l'exercice précédent en Algorithme et sa traduction en langage C mais avec la boucle
do…while.

Exercice 17 :
refaire l'exercice précédent en Algorithme et sa traduction en langage C, C++, C# et Java
mais avec la boucle for.

Exercice 18 :
Ecrire un programme en langage C qui permet d’afficher la table de multiplication d’un
interval [I1 , I2] (vérifier la validité).

Exercice 19 :
Ecrire un programme en langage C qui permet de calculer le factoriel de N nombres entiers
positifs mais cela à volonté de l’utilisateur.

Exercice 20 :
Ecrire un programme en langage C qui permet de calculer la valeur absolue de N nombres
réels mais à volonté de l’utilisateur.

Exercice 21 :
Ecrire un programme en langage C qui permet de calculer le N-ième terme UN de la suite
de FIBONACCI qui est donnée par la relation de récurrence:
U1=1
U2=1
Un=Un-1 + Un-2 (pour N>2)
Déterminez le rang N et la valeur UN du terme maximal que l'on peut calculer si on utilise
pour Un :
- le type int
- le type double.

Exercice 22 : Décomposition de nombres :

On se propose d'écrire un programme en langage C qui permet de déterminer et d'afficher
toutes les représentations sous forme de sommes d'entiers consécutifs d'un nombre entier
n donné.
Exemple :
Donnez un nombre entier : 45
Les sommes consécutives sont :
45 = 1+2+3+4+5+6+7+8+9
45 = 5+6+7+8+9+10
45 = 7+8+9+10+11
45 = 14+15+16
45 = 22+23

Exercice 23 : Nombre heureux :

Un nombre heureux est un entier qui, lorsqu'on ajoute les carrés de chacun de ses chiffres,
puis les carres des chiffres de ce résultat et ainsi de suite jusqu'a l'obtention d'un nombre a
un seul chiffre, donne 1 pour résultat.
Ainsi, 7 est heureux, puisque :
72 = 49
42 + 92 = 97
92 + 72 =130
12 + 32 + 02 =10
12 + 02 = 1 (on est arrivée à un nombre d'un seul chiffre = 1, donc 7 est heureux)
Ecrire le programme en langage C qui permet de déterminer si le nombre entrer par
l'utilisateur est un nombre heureux.

Exercice 24 : Un nombre abcd est divisible par 7 :

Un nombre abcd est divisible par 7 si |abc-2*d| est divisible son tour par 7.
Exemple :
Pour n = 7241
|724 – 2*1| = 722 on doit tester si 722 est divisible par 7
|72- 2*2| =68
|6-2*8|= 10
|1-2*0|= 1 d’où 7241 n’est pas divisible par 7
Pour n = 30086
|3008 – 2*6| = 2996
|299- 2*6| =287
|28-2*7|= 14
|1-2*4|= 7 d’où 30086 est divisible par 7
Pour n = 147
|14-2*7|= 0 d’où 147 est divisible par 7
Ecrire un programme en langage C qui permet de déterminer si le nombre entrer par
l'utilisateur est divisible par 7.

Exercice 25 :
Ecrire un programme en langage C qui permet de calculer la somme des N premiers termes
de la série harmonique : 1 + 1/2 + 1/3 + ... + 1/N

Exercice 26 :
Ecrire un programme en langage C qui permet de calculer le nombre lu à rebours d'un
nombre positif entré au clavier en supposant que le fichier d'entrée standard contient le
nombre à inverser.
Exemple:
Entrée: 5689
Affichage: 9865

Exercice 27 :
Ecrire un programme en langage C qui permet de saisir 2 nombres entiers x et (n positif) et
de déterminer x^n (sans calculer la puissance).
Exercice 28 :
refaire l'exercice précédent mais en utilisant cette fois la fonction prédéfinie pow( ).

Exercice 29 :
Ecrire un programme en langage C qui permet de calculer le moyenne de n notes (0 <= note
<= 20) (2 chiffres après virgule).
a- Avec la boucle while.
b- Avec la boucle do…while.
c- Avec la boucle for.
d- utilisez les instructions de branchements inconditionnels break, continue, goto.

Exercice 30 :
Ecrire un programme en langage C qui permet de calculer la moyenne de notes terminées
par une note négative puis d’afficher le nombre de notes traités.

Exercice 31 :
Ecrire un programme en langage C qui permet de saisir un nombre entier positif et afficher
tous les nombres pairs qui lui sont inferieurs (sauf 0)

Exercice 32 :
Ecrire un programme en langage C qui permet d’afficher la somme des entiers entre [d , f]
(d, f données à vérifier qu’elles sont dans le bon ordre).

Exercice 33 :
Ecrire un programme en langage C qui permet de calculer la racine carrée X d'un nombre
réel positif A par approximations successives en utilisant la relation de récurrence suivante:
XJ+1 = (XJ + A/XJ) / 2 X1 = A
La précision du calcul J est à entrer par l'utilisateur.
b) Assurez-vous lors de l'introduction des données que la valeur pour A est un réel positif et
que J est un entier naturel positif, plus petit que 50.
c) Affichez lors du calcul toutes les approximations calculées :
La 1ère approximation de la racine carrée de ... est ...
La 2e approximation de la racine carrée de ... est ...
La 3e approximation de la racine carrée de ... est ...
...

Exercice 34 :
Ecrire un programme en langage C qui permet d'afficher le tableau suivant de N ligne (N est
fourni au clavier) :
1 1 1 1 0
1 1 1 0 -1
 1 1 0 -1 -1
1 0 -1 -1 -1
0 -1 -1 -1 -1

Exercice 35 :
Ecrire un programme en langage C qui permet d'afficher le triangle isocèle formé d'étoiles
de N lignes (N est fourni au clavier):
Nombre de ligne : 8
*
***
*****
*******
*********
***********
*************
***************

Exercice 36 :
Ecrire un programme en langage C qui permet d'afficher le triangle isocèle formé d'étoiles
de N lignes (N impaire) :
Nombre de ligne : 7
*
***
*****
*******
*****
***
*

Exercice 37 :
Ecrire un programme en langage C qui permet d'afficher le tableau sémitrique de N ligne (N
est fourni au clavier):
0 1 2 3
1 0 3 4
2 3 0 5
3 4 5 0
Exercice 38 :
Ecrire un programme en langage C qui permet d’afficher :
2 3 4 5
3 4 5 6
4 5 6 7
5 6 7 8
6 7 8 9

Exercice 39 :
Ecrire un programme en langage C qui permet d'afficher la table des produits pour N
variant de 1 à 10 :
X*Y I 0 1 2 3 4 5 6 7 8 9 10
-------------------------------------------------------------
0 I 0 0 0 0 0 0 0 0 0 0 0
1 I 0 1 2 3 4 5 6 7 8 9 10
2 I 0 2 4 6 8 10 12 14 16 18 20
3 I 0 3 6 9 12 15 18 21 24 27 30
4 I 0 4 8 12 16 20 24 28 32 36 40
5 I 0 5 10 15 20 25 30 35 40 45 50
6 I 0 6 12 18 24 30 36 42 48 54 60
7 I 0 7 14 21 28 35 42 49 56 63 70
8 I 0 8 16 24 32 40 48 56 64 72 80
9 I 0 9 18 27 36 45 54 63 72 81 90
10 I 0 10 20 30 40 50 60 70 80 90 100

Exercice 40 :
Ecrire un programme en langage C qui permet de calcule et l’affichage suivant :

1*8*1=9
12 * 8 * 1 = 98
123 * 8 * 1 = 987
1234 * 8 * 1 = 9876
12345 * 8 * 1 = 98765
 123456 * 8 * 1 = 987654
1234567 * 8 * 1 = 9876543
12345678 * 8 * 1 = 98765432
123456789 * 8 * 1 = 987654321

Pour télécharger les corrigés en algorithme et sa traduction en langage C, C++, C#, Java,
Vb.Net et Pascal sur les structures répétitives ( les boucles ) et les instructions de
branchements inconditionnels - Cliquez sur le lien suivant :