You are on page 1of 76

REPUBLIQUE TUNISIENNE

MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE
LA RECHERCHE SCIENTIFIQUES ET TECHNOLOGIQUES

UNIVERSITE DE JENDOUBA
FACULTE DES SCIENCES JURIDIQUES, ECONOMIQUES ET DE GESTION DE JENDOUBA

FASCICULE DE Cours et TPs

Atelier de Programmation I
Adressé aux étudiants de 1ère année Licence Fondamentale en
Informatique Appliquée à la Gestion

Riadh BOUSLIMI
Assistant en Informatique

Année Universitaire : 2009-2010

FICHE MATIÈRE

Objectifs généraux
Il s'agit d'un cours d'initiation au langage C. Ce cours s'adresse aux débutants en
programmation. Il a pour but de:
- Découvrir l'environnement de programmation C.
- Etre capable d'écrire ses premiers programmes dans le langage de programmation C.
- Acquérir les notions principales pour apprendre rapidement d'autres langages de
programmation
- Savoir réagir devant un problème de programmation.

Pré-requis
Algorithmiques et structures de données

Public-cible
Ce cours est destiné essentiellement aux étudiants de la première année Licence fondamentale
en Informatique appliquée à la Gestion, semestre1

Volume horaire
Ce cours est présenté, de manière hebdomadaire, comme suit:
- 45mn du cours intégré en séance de TD
- 1h30mn de Travaux pratiques pour chaque groupe
Soit en total : 31.5h

Moyens pédagogiques
- Tableau
- Condensé du cours
- Salle de TD - Laboratoire d'informatique
- Polycopies des Travaux pratiques
- L'environnement de programmation C : Turbo C++

Evaluation
- Coefficient : 1.5
- Note du contrôle continu : 30%
- Note d'examen : 70%
2/76

Table des matières
Chapitre 1 : ELEMENTS DE LANGAGE C.....................................................................................................................6
1.
INTRODUCTION ........................................................................................................................................6
2.
ETAPES PERMETTANT L'EDITION, LA MISE AU POINT, L'EXECUTION D'UN
PROGRAMME ........................................................................................................................................................6
3.
LES DIFFERENTS TYPES DE VARIABLES..........................................................................................7
4.
LES INITIALISATIONS.............................................................................................................................9
5.
SORTIES DE NOMBRES OU DE TEXTE A L'ECRAN.......................................................................10
6.
LES OPERATEURS ..................................................................................................................................12
7.
LES CONVERSIONS DE TYPES ............................................................................................................13
Chapitre 2 : SAISIE DE NOMBRES ET DE CARACTERES AU CLAVIER.............................................................15
1.
LA FONCTION GETCH...........................................................................................................................15
2.
LA FONCTION SCANF............................................................................................................................15
3.
LA FONCTION GETCHAR.....................................................................................................................16
Chapitre 3 : LES STRUCTURES CONDITIONNELLES ET LES BOUCLES ..........................................................17
1.
L'INSTRUCTION SI ... ALORS ... SINON ... .........................................................................................17
2.
LES OPERATEURS LOGIQUES ............................................................................................................18
3.
L'INSTRUCTION AU CAS OU ... FAIRE ... ..........................................................................................19
4.
LA BOUCLE TANT QUE ... FAIRE .......................................................................................................20
5.
L'INSTRUCTION POUR .........................................................................................................................21
6.
L'INSTRUCTION REPETER ... TANT QUE ........................................................................................22
Chapitre 4 : LES TABLEAUX ET LES CHAINES DE CARACTERES .....................................................................24
1.
LES TABLEAUX DE NOMBRES (INT ou FLOAT) .............................................................................24
2.
INITIALISATION DES TABLEAUX......................................................................................................25
3.
LES CHAINES DE CARACTERES ........................................................................................................25
4.
FONCTIONS SUR LES CHAINES DE CARACTERES .......................................................................26
Chapitre 5 : LES FONCTIONS........................................................................................................................................27
1.
INTRODUCTION ......................................................................................................................................27
2.
DECLARATION ........................................................................................................................................27
3.
FONCTIONS SANS PASSAGE D'ARGUMENTS ET NE RENVOYANT RIEN AU
PROGRAMME. .....................................................................................................................................................28
4.
FONCTION RENVOYANT UNE VALEUR AU PROGRAMME ET SANS PASSAGE
D'ARGUMENTS....................................................................................................................................................31
5.
FONCTIONS AVEC PASSAGE D'ARGUMENTS ................................................................................31
6.
RESUME SUR VARIABLES ET FONCTIONS.....................................................................................32
7.
LE PASSAGE DE PARAMETRES ENTRE FONCTIONS OU ENTRE FONCTIONS ET
PROGRAMME PRINCIPAL ...............................................................................................................................32
TP n°1..................................................................................................................................................................................34
Exercice 1 ................................................................................................................................................................34
Exercice 2 ................................................................................................................................................................34
Exercice 3 ................................................................................................................................................................34
Exercice 4 ................................................................................................................................................................34
Exercice 5 ................................................................................................................................................................34
Correction du TP n°1.........................................................................................................................................................35
Exercice 1 ................................................................................................................................................................35
Exercice 2 ................................................................................................................................................................35
Exercice 3 ................................................................................................................................................................35
Exercice 4 ................................................................................................................................................................36
Exercice 5 ................................................................................................................................................................36
TP n°2..................................................................................................................................................................................37
Exercice 1 ................................................................................................................................................................37
Exercice 2 ................................................................................................................................................................38
Exercice 3 ................................................................................................................................................................38
Exercice 4 ................................................................................................................................................................38
Exercice 5 ................................................................................................................................................................38
Exercice 6 ................................................................................................................................................................38
Exercice 7 ................................................................................................................................................................38
Exercice 8 ................................................................................................................................................................39
Exercice 9 ................................................................................................................................................................39
3/76

................................................................................................................................................................................................................................45 Exercice 3 ...............................................................................................................................................54 Exercice n°5 ...........................................................................................................................................................................................................................................44 TP n°3........................................................................45 Exercice 6 ....................................................................................................................................47 Exercice 3 ..........................................................................45 Exercice 4 ........................................64 Exercice n°4 ................................................................................................................................47 Exercice 2 .....64 Exercice n°1 ..............................................................................................................................................................................66 Exercice n°2 ............................46 Exercice 9 ................................46 Exercice 7 ....................................55 Exercice n°8 .........................................................40 Exercice 3 .......................................................................................50 Exercice 8 ...................................64 Exercice n°5 .................................................................................................................................................................55 Exercice n°9 ...........................................45 Exercice 1 ...........................................60 Exercice n°6 .....................................................................................................................................................................................................................65 Correction du TP n°5......................51 TP n°4............................................................................................58 Exercice n°5 ..........................................................49 Exercice 6 ..........................................................................................................................................................................48 Exercice 4 ...........................................................................................................55 Exercice n°10 ..................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................58 Exercice n°4 ...........................................................................66 Exercice n°3 ...................................................................57 Exercice n°2 ................................................40 Exercice 2 .........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................55 Exercice n°7 .............................................................................................................61 Exercice n°7 ...............................................................................................................................................................54 Exercice n°3 .............................................................................................................43 Exercice 8 .........................................................................................................................54 Exercice n°4 ..............................................................................................................62 Exercice n°9 ...................................................................49 Exercice 7 ...................................................63 Exercice n°11 ..................................................................55 Exercice n°11 .....66 Exercice n°1 ......................................................................................................................................................................................................................................................................................................................................................................................................45 Exercice 5 ............................................................................................42 Exercice 6 ...........................46 Exercice 8 ....................................................................................................................................................................................................................................................................................46 Correction du TP n°3.......40 Exercice 1 .........................................................................................................................................................................41 Exercice 4 ............................................................................................................47 Exercice 1 ...........................................57 Exercice n°1 ............................................................................................................................................................................................................................................67 4/76 ............................................................................................................................45 Exercice 2 ................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................67 Exercice n°4 ............................................................................................................................................................................................................................................................................................................................................................................................53 Exercice n°1 .............................................Correction du TP n°2..........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................43 Exercice 7 ............................................62 Exercice n°10 .................................................55 CORRECTION DU TP N°4 ........................63 TP n°5..........................................................................................................................................................................................................57 Exercice n°3 ................................................................................................................................................64 Exercice n°2 ...................................................................................................64 Exercice n°3 ...............................................................................................................................48 Exercice 5 ...................................................................................54 Exercice n°6 ...........................41 Exercice 5 .............................................................................................................................................................................................................51 Exercice 9 ..........................................................................................................43 Exercice 9 .............................................................................................................................................................................................................................................................................................................................61 Exercice n°8 .........................................................................................................................................................................

................Exercice n°5 ...................................................................................................................................................................................................................................68 Examen session principale (Janvier 2009) ..............................................................................................................................................................................................70 Examen session de contrôle (Juin 2009) .....76 5/76 ........69 Correction d’examen session principale..................................................................................................................................................................................................................................74 Bibliographie ..........................................73 Correction d’examen session contrôle ....................................................................................................

il fait par contre appel à des bibliothèques. appelé fichier executable: EXI_1.Editions de liens: Le code machine des fonctions-bibliothèque est chargé. appelé fichier objet: EXI_1.OBJ (commande « compile »).CPP (menu « edit »).h : bibliothèque de fonctions mathématiques stdio. non listable.EXE (commande « build all »). le compiler et l'exécuter. à l'aide d'un éditeur (traitement de textes). assez proche du langage machine destiné à des applications de contrôle de processus (gestion d'entrées/sorties.. 2.Edition du programme source. Les compilateurs Borland C++ ou TurboC++ permettent de compiler et exécuter des programmes c et ils offrent la documentation nécessaire.CPP. LA MISE AU POINT. non listable. exemples: math.Compilation du programme source. Savoir utiliser les Bibliothèques. applications temps réel . d'ajouter à un programme des unités déjà compilées . Le nom du fichier contient l'extension . création d'un fichier binaire. 4. INTRODUCTION Le langage C est un langage évolué et structuré.Exécution du programme (commande « flèche jaune »). Savoir convertir un type de données vers un autre. 6/76 . 1.h : bibliothèque d'entrées/sorties standard On ne saurait développer un programme en C sans se munir de la documentation concernant ces bibliothèques. Le compilateur indique les erreurs de syntaxe mais ignore les fonctionsbibliothèque appelées par le programme. L'EXECUTION D'UN PROGRAMME 1. fournies en plus ou moins grand nombre avec le compilateur.). c'est à dire création des codes machine destinés au microprocesseur utilisé. Les compilateurs permettent en général de construire des programmes composés de plusieurs fichiers sources. Le langage C possède assez peu d'instructions. 2..Chapitre 1 ELEMENTS DE LANGAGE C Objectifs spécifiques:        Manipuler les types standard. Le compilateur génère un fichier binaire. Savoir écrire un programme C. exemple: EXI_1.. 3. Savoir les opérateurs de base du langage c. ETAPES PERMETTANT L'EDITION. Savoir afficher et utiliser les formats de sorties des variables. Déclarer des variables..

h> /* bibliotheque d'entrees-sorties standard */ #include <conio. Ces variables sont rangées dans la mémoire vive de l’ordinateur.h> void main() { printf("BONJOUR"). /* affectation */ somme = (a + b)*2 . . printf("Pour continuer frapper une touche. On a introduit dans ce programme la notion d’interface homme/machine (IHM). .h> /* bibliotheque d'entrees-sorties standard */ #include <conio. Les mots réservés du langage C doivent être écrits en minuscules. /* affectation et opérateurs */ printf("Voici le resultat : %d\n ".L’utilisateur visualise une information sur l’écran. somme .La notion de déclaration de variables : les variables sont les données que manipulera le programme lors de son exécution. Exemple 2 #include <stdio. getch(). /* déclaration de 3 variables */ printf("BONJOUR").h> void main() { int a.La notion d’opération. b. /* utilisation d'une fonction-bibliotheque */ a = 10 . on introduit 3 nouveaux concepts : . fournit une information au programme.. par une action sur le clavier. 3.Exemple 1 #include <stdio."). /* Attente d'une saisie clavier */ } Résultat après compilation et exécution: Dans ce programme.. getch()..La notion d’affectation. des majuscules.. /* affectation* / b = 50 . symbolisée par le signe =. . /* utilisation d'une fonction-bibliotheque */ printf("Pour continuer frapper une touche. ."). somme) . LES DIFFERENTS TYPES DE VARIABLES 7/76 . Elles doivent être déclarées au début du programme. /* Attente d'une saisie clavier */ } Résultat après compilation et exécution: Le langage C distingue les minuscules.L’utilisateur.

Le caractère 127 a pour valeur 127. Quelques constantes caractères: ________________________________________________________________ CARACTERE VALEUR (code ASCII) NOM ASCII ________________________________________________________________ '\n' interligne 0x0a LF '\t' tabulation horizontale 0x09 HT '\v' tabulation verticale 0x0b VT '\r' retour charriot 0x0d CR '\f' saut de page 0x0c FF '\\' backslash 0x5c \ '\'' cote 0x2c ' '\"' guillemets 0x22 " _______________________________________________________________ 8/76 . le bit de poids fort est perdu). Le caractère 257 a pour valeur 1 (ce nombre s'écrit sur 9 bits.231 ≤ n ≤231-1 4 octets: 0 ≤ n ≤ 232 short unsigned short entier court signé entier court non signé 2 octets: .a) Les entiers Le langage C distingue plusieurs types d'entiers: ___________________________________________________________ TYPE DESCRIPTION TAILLE MEMOIRE ___________________________________________________________ int unsigned int entier standard signé entier positif 4 octets: . précédés de 0x en hexadécimal.215 ≤ n ≤ 215-1 2 octets: 0 ≤≤n ≤ 216 char caractère signé 1 octet : . Remarque: En langage C. exemple: 127 en décimal s'écrit 0x7f en hexadécimal.27 ≤≤n ≤ 27-1 unsigned char caractère non signé 1 octet : 0 ≤n ≤ 28 _____________________________________________________________ Numération: En décimal les nombres s'écrivent tels que. Le caractère 22 a pour valeur 22. le type char est un cas particulier du type entier: un caractère est un entier de 8 bits Exemples: Les caractères alphanumériques s'écrivent entre ‘ ‘ Le caractère 'b' a pour valeur 98 (son code ASCII).

u) . printf("BONJOUR").d'une mantisse .u) . char.. printf(« 2éme affichage de v: %c\n ». getch(). Cette règle s'applique à tous les nombres. est équivalent à int i = 50. calcul = (a + b)*2 . 9/76 . /* affectation */ u = 65 . int. calcul) .. /* déclaration de 3 variables */ char u. /* affectation et opérateurs */ printf(« Voici le resultat : %d\n »."). /* affectation* / b = 50 . Le langage C distingue 2 types de réels: _________________________________________________________ TYPE DESCRIPTION TAILLE MEMOIRE _________________________________________________________ float réel standard 4 octets double réel double précision 8 octets __________________________________________________________ 4. float . puts("Pour continuer frapper une touche.. printf(« 1er affichage de u: %d\n ». int i. b..h> /* bibliotheque d'entrees-sorties standard */ #include <conio.Exemple 3 #include <stdio. v. c = 'A'. /* Attente d'une saisie clavier */ } Résultat après compilation et exécution: b) Les réels Un réel est composé . LES INITIALISATIONS Le langage C permet l'initialisation des variables dans la zône des déclarations: char c. printf(« 1er affichage de u : %d\n ». i = 50. est équivalent à char c = 'A'.v) . v = ‘A’ .v) .d'un signe . /* utilisation d'une fonction-bibliotheque */ a = 10 .d'un exposant Un nombre de bits est réservé en mémoire pour chaque élément. calcul .h> void main() { int a. printf(« 2ème affichage de v : %c\n ».

printf("BONJOUR\n"). /* affichage du caractère */ /* et retour à la ligne */ printf("Pour continuer frapper une touche. getch().. SORTIES DE NOMBRES OU DE TEXTE A L'ECRAN c) LA FONCTION PRINTF Ce n'est pas une instruction du langage C. Exemple: affichage d'un texte: printf("BONJOUR"). /* c est le caractere alphanumerique A */ /* affichage du code ASCII en decimal */ /* et retour … à la ligne */ printf("%o\n". /* pas de retour à la ligne du curseur après l'affichage. c =66.h> void main() { printf("BONJOUR ").c). /* equivalent à puts("BONJOUR". /* affichage du code ASCII en base huit /* et retour … à la ligne */ printf("%x\n".h> void main() { char c. Exemple 5 Affichage d'une variable de type char: #include <stdio.. */ printf("BONNES VACANCES"). */ /* affichage du texte.c).5. /* affichage du code ASCII en hexadecimal /* et retour … à la ligne */ printf("%c\n".nom_de_variable). printf("IL FAIT BEAU\n"). /* Attente d'une saisie clavier */ } Résultat après compilation et exécution: La fonction printf exige l'utilisation de formats de sortie.. avec la structure suivante: printf("%format". /* Attente d'une saisie clavier */ } 10/76 .c). puis retour à la ligne du curseur. getch()..").c). printf("Pour continuer frapper une touche. */ Exemple 4 #include <stdio."). mais une fonction de la bibliothèque stdio.h.h> #include <conio. printf("%d\n".h> #include <conio.

a = -21430 b = 4782.. et en soignant l’interface homme/machine. a*b. /* c est le caractere alphanumerique A */ printf("decimal = %d ASCII = %c\n". a%b en format décimal.a+b). printf("Pour continuer frapper une touche. printf("A sur B = %d\n"..h> void main() { char c.a-b). a%b donne le reste de la division. calculer et afficher a+b. affichage en décimal (entiers de type unsigned int). formatn". a/b..h> #include <conio. a/b donne le quotient de la division. getch().... .").variablen). getch().h> #include <conio. printf("A x B = %d\n". Exercice d'application n°1 Soit a et b sont des entiers.. /* Attente d'une saisie clavier */ } Résultat après compilation et exécution: Formats de sortie pour les entiers: %d %x %u affichage en décimal (entiers de type int).a*b).variable2. a= -21430..b.c.Résultat après compilation et exécution: Affichage multiple de structure: printf("format1 format2 .a/b).B = %d\n". /* Attente d'une saisie clavier */ } 11/76 . c ='A'. printf("A mod B = %d\n"..")... affichage en hexadécimal (entiers de type int).c).. a-b.. puts("Pour continuer frapper une touche. printf("A + B = %d\n". Solution #include <stdio. b= 4782. printf("A ..a%b).variable1. Exemple 6 #include <stdio.h> void main() { int a.

a = -21.Exercice d'application n°2 Soit a et b sont des réels.* / (quotient de la division) % (reste de la division) avec la hiérarchie habituelle.h> #include <conio. en soignant l’interface homme/machine.").. Sur cet exemple. printf("A . getch(). Opérateurs arithmétiques sur les entiers: + . Opérateurs logiques sur les entiers: & ET | OU ^ OU EXCLUSIF ~ COMPLEMENT A UN » DECALAGE A DROITE.b. p = n » 3.d. non formatées. on peut donc effectuer des opérations.43.782. printf("A + B = %f\n". printf("Pour continuer frapper une touche.* / avec la hiérarchie habituelle. d = c+'a'-'A'. b= 4. a*b. Il vaut mieux utiliser puts et putchar si cela est possible.B = %f\n".c). a/b. /* Attente d'une saisie clavier */ } d) AUTRES FONCTIONS DE SORTIES Affichage d'un caractère: La fonction putchar permet d'afficher un caractère: c étant une variable de type char.a*b)..43 b = 4. est équivalente à printf("bonjour\n"). on transforme la lettre majuscule G en la lettre minuscule g. et nécessitent moins de place en mémoire lors de leur chargement. l'écriture putchar(c). printf("A x B = %f\n".a-b). 6.a/b). a-b. est équivalente à printf("%c\n". ces fonctions. « DECALAGE A GAUCHE /* p est égale à n décalé de 3 bits à gauche */ /* p est égale à n décalé de 3 bits à droite */ 12/76 . c = 'G'. LES OPERATEURS Opérateurs arithmétiques sur les réels: + . sont d'exécution plus rapide. Exemples: p = n « 3.h> void main() { float a. printf("A sur B = %f\n". calculer et afficher a+b. Affichage d'un texte: La fonction puts permet d'afficher un texte: l'écriture puts("bonjour"). NB : Pour le format de sortie pour les réels c'est : %f Solution #include <stdio.782. Exemple particulier: char c. Les caractères sont des entiers sur 8 bits.a+b). a= -21.

Ces écritures sont à éviter lorsque l'on débute l'étude du langage C car elles nuisent à la lisibilité du programme. mais ce n'est pas une obligation. .14159. OPERATEURS COMBINES Le langage C autorise des écritures simplifiées lorsqu'une même variable est utilisée de chaque côté du signe = d'une affectation..14159. dont la valeur sera constante pour tout le programme: Exemple: void main() { const float PI = 3. a = a+b. LES CONVERSIONS DE TYPES Le langage C permet d'effectuer des opérations de conversion de type: On utilise pour cela l'opérateur de "cast"(). .. void main() { float perimetre. } Dans ce cas. 1ere méthode: déclaration d'une variable. a = a-b.. 13/76 . perimetre = 2*rayon*PI. Exemple: #define PI = 3. pour la variable pi.rayon = 8. } Le compilateur ne réserve pas de place en mémoire. mais dont on ne peut changer la valeur.7. LES DECLARATIONS DE CONSTANTES Le langage C autorise 2 méthodes pour définir des constantes.7.. est équivalent à a+= b. perimetre = 2*rayon*PI. a = a & b. 7. est équivalent à a&= b. float perimetre.. i = i-1. Les constantes déclarées par #define s'écrivent traditionnellement en majuscules. 2ème méthode: définition d'un symbole à l'aide de la directive de compilation #define. est équivalent à i++.INCREMENTATION . est équivalent à i--. est équivalent à a-= b.DECREMENTATION Le langage C autorise des écritures simplifiées pour l'incrémentation et la décrémentation de variables: i = i+1.. le compilateur réserve de la place en mémoire (ici 4 octets).rayon = 8.

Exemple : #include <stdio.i.s).h> #include <conio. printf("Conversion float -> char: %5. j = (int)r.e).h> void main() { int i=0x1234.i. printf("Conversion int -> char: %x -> %x\n".67. e = (char)r. d = (char)i.s.r.2f -> %d\n". float r=89. printf("Conversion int -> float: %d -> %5. s = (float)i. char d.2f -> %d\n". printf("Conversion float -> int: %5.j.r.d). printf("Pour sortir frapper une touche ").2f\n". getch().j).e. } Résultat après compilation et exécution: 14/76 .

h. printf("\nVOICI CE CARACTERE: %c". float r. printf("ENTRER UN CARACTERE (ATTENTION PAS DE RETURN) "). On peut utiliser getch de deux façons: .&i). permet la saisie clavier de n'importe quel type de variable.&alpha).alpha).&r). . scanf("%c".h permet la saisie clavier d'un caractère alphanumérique. Les variables à saisir sont formatées. scanf("%d". LA FONCTION GETCH La fonction getch.&i). 2. La saisie s'arrête dès que le caractère a été frappé. appartenant à la bibliothèque conio. le nom de la variable est précédé du symbole & désignant l'adresse de la variable. Exemples: char alpha. int i. LA FONCTION SCANF La fonction scanf. alpha = getch(). Les parenthèses vides de getch() signifient qu'aucun paramètre n'est passé à cette fonction par le programme. scanf("%f". appartenant à la bibliothèque stdio. getch().sans retour de variable au programme: Exemple: printf("POUR CONTINUER FRAPPER UNE TOUCHE "). /* saisie d'un caractère */ /* saisie d'un nombre entier en décimal */ /* saisie d'un nombre entier en hexadécimal*/ /* saisie d'un nombre réel */ 15/76 .avec retour de variable au programme: Exemple: char alpha. scanf("%x".Chapitre 2 SAISIE DE NOMBRES ET DE CARACTERES AU CLAVIER Objectifs spécifiques:   Manipuler les fonctions d'entrée de base Savoir la différence entre les fonctions d'entrée et leurs lieux d'utilisation 1.

&alpha).h. Exemple: 3. 16/76 .&c). LA FONCTION GETCHAR La fonction getchar pemet la saisie d'un caractère (char). Les 2 écritures suivantes sont équivalentes: char c. char alpha. scanf("%d". Il vaut mieux l'utiliser quand cela est possible. c = getchar(). Aucune erreur n'est générée. sa saisie est ignorée. Elle appartient à la bibliothèque stdio.Remarque: Si l'utilisateur ne respecte pas le format indiqué dans scanf. la saisie est ignorée. Si l'utilisateur saisie 97 tout va bien. char c. alpha devient le caractère dont le code ASCII vaut 97. La fonction getchar est moins gourmande en place mémoire que scanf. Si l'utilisateur saisie a. printf("ENTRER UN CARACTERE: "). scanf("%c". printf("ENTRER UN CARACTERE: "). getchar utilise le flux d'entrée exactement comme scanf.

... ........ } else { .... Choisir la forme adéquate des structures de contrôle conditionnelles..Chapitre 3 LES STRUCTURES CONDITIONNELLES ET LES BOUCLES Objectifs spécifiques:      Savoir les structures conditionnelles ainsi que ces différentes formes. ALORS .. .......... 1............. ...... Savoir les structures itératives ainsi que ces différentes formes.... SINON ....... } /* bloc 1 d'instructions */ /* bloc 2 d'instructions */ 17/76 ....... Il s'agit de l'instruction: si (expression conditionnelle vraie) alors {BLOC 1 D'INSTRUCTIONS} sinon {BLOC 2 D'INSTRUCTIONS} Organigramme: oui non condition vraie bloc 1 d' instructions bloc 2 d' instructions suite du programme Syntaxe en C: if (expression) { ........ Choisir la forme adéquate des structures itératives...... .... Savoir combiner deux ou plusieurs conditions........ L'INSTRUCTION SI .

.Le bloc "sinon" est optionnel: si (expression vraie) alors {BLOC D'INSTRUCTIONS} oui non condition vraie bloc d' instructions suite du programme Syntaxe en C: if (expression) { .............. .. 2.... } /* bloc d'instructions */ Remarque: les {} ne sont pas nécessaires lorsque les blocs ne comportent qu'une seule instruction.. ........... LES OPERATEURS LOGIQUES test d'égalité: if (a==b) " si a égal b " test de non égalité: if (a!=b) " si a différent de b " tests de relation d'ordre: if (a<b) if (a<=b) test de ET LOGIQUE: if ((expression1) && (expression2)) " si l'expression1 ET l'expression2 sont vraies " test de OU LOGIQUE if ((expression1) || (expression2)) " si l'expression1 OU l'expression2 est vraie " test de NON LOGIQUE if (!(expression1)) " si l'expression1 est fausse " 18/76 if (a>b) if (a>=b) ........

L'INSTRUCTION AU CAS OU . etc . . d'instructions..... else printf("TANT-PIS"\n)... L’instruction switch correspond à une cascade d’instructions if . printf("Voulez-vous jouer ?").... Syntaxe: switch(variable de type char ou int) au cas où la variable vaut: { case valeur1: . else printf("TANT-PIS"\n).. break... default: ..cette valeur1: executer ce bloc d'instructions.cette valeur2: executer ce bloc d'instructions..... .... Le langage C admet des écritures contractées dans les expressions de test: char reponse.aucune des valeurs précédentes: executer ce bloc . reponse = getchar().. .... valeur2:. if(reponse == 'o') printf("BONJOUR\n").. . } le bloc "default" n'est pas obligatoire. ... if((reponse = getchar()) =='o') printf("BONJOUR\n"). L'instruction switch permet des choix multiples uniquement sur des entiers (int) ou des caractères (char)...... pas de "break" ici.Toutes les combinaisons sont possibles entre ces tests. break... FAIRE . . ............ 3. printf("Voulez-vous jouer ?")... est équivalent à char reponse...else 19/76 . ....

...... printf("LISTE PAR GROUPE TAPER 1\n").. FAIRE . break. LA BOUCLE TANT QUE .. . printf("\nCE CHOIX N'EST PAS PREVU ")..... printf("POUR SORTIR TAPER S\n")..... ."). } /* bloc d'instructions */ 20/76 .. choix = getchar().... ...........Exemple: Cette instruction est commode pour fabriquer des "menus": char choix....... break........ .. printf("LISTE ALPHABETIQUE TAPER 2\n").. Il s'agit de l'instruction: tant que (expression vraie) faire{BLOC D'INSTRUCTIONS} Organigramme: oui condition vraie non bloc d' instructions Syntaxe en C: while (expression) { ....... /* pas de break ici */ } 4..... case '2': ....... break... case 'S': printf("\nFIN DU PROGRAMME .... default. switch(choix) { case '1': .... printf("\nVOTRE CHOIX: ").

5.... condition de continuité .modification) {BLOC D'INSTRUCTIONS} Organigramme: initialisation condition de continuité vraie non oui bloc d'instructions modification suite du programme Syntaxe en C: for(initialisation .. modification) { .... On peut rencontrer la construction suivante: while (expression).. le bloc d'instructions n'est pas forcément exécuté. et sans la présence du bloc d'instructions... Une instruction peut être omise... Remarque: - les {} ne sont pas nécessaires lorsque le bloc ne comporte qu'une seule instruction... mais pas les .. Il s'agit de l'instruction: pour (initialisation. . Les 3 instructions du for ne portent pas forcément sur la même variable.Le test se fait d'abord.... } Remarques: Les {} ne sont pas nécessaires lorsque le bloc ne comporte qu'une seule instruction. /* bloc d'instructions */ . Cette construction signifie: "tant que l'expression est vraie attendre"............ L'INSTRUCTION POUR .. condition de continuité vraie..... 21/76 ..... terminée par un .

.....) { . .. ... for(i = 0 ........... i++) { .... Il s'agit de l'instruction: répéter{BLOC D'INSTRUCTIONS} tant que (expression vraie) 22/76 .... Utilisation de variables différentes: resultat = 0. resultat<30 .. } correspond à l'organigramme suivant: i = 0 non i < 10 oui bloc d'instructions suite du programme i=i+1 La boucle for(............ ....................Exemples: for(i = 0 .. L'INSTRUCTION REPETER .. resultat = resultat + 2*i..... TANT QUE .. } Exercice: Ecrire un programme C qui permet de saisir un entier puis calcule sa factoriel........................ i<10 ... i++) { .... } /* bloc d'instructions */ est une boucle infinie (répétition infinie du bloc d'instructions)... 6.. /* bloc d'instructions */ .. /* bloc d'instructions */ .. ...................

.Organigramme: bloc d' instructions oui condition vraie non suite du programme Syntaxe en C: do { . le bloc est exécuté au moins une fois.... Le test se faisant après...... } while (expression). /* bloc d'instructions */ .......... Remarque: les {} ne sont pas nécessaires lorsque le bloc ne comporte qu'une seule instruction. .................. 23/76 ..

Manipuler des chaînes de caractères.Chapitre 4 LES TABLEAUX ET LES CHAINES DE CARACTERES Objectifs spécifiques:      Comprendre l'utilisation du type tableau. Manipuler des tableaux à une ou deux dimensions. Savoir déclarer un tableau. Les indices maximum sont donc dim1-1. printf("%d". Les tableaux à plusieurs dimensions: Tableaux à deux dimensions: Déclaration: type nom[dim1][dim2]. LES TABLEAUX DE NOMBRES (INT ou FLOAT) Les tableaux correspondent aux matrices en mathématiques. L'indice maximum est donc dim-1. Appel: nom[indice] Exemples: compteur[2] = 5. Appel: nom[indice1][indice2] Exemples: compteur[2][4] = 5.&nombre[i][j]).compteur[i][j]). 1. 24/76 . Les tableaux à une dimension: Exemples: Déclaration: type nom[dim]. Exemples: int compteur[4][5]. Manipuler les fonctions sur les chaines de caractères.&nombre[i]). scanf("%f". Utilisation: Un élément du tableau est repéré par ses indices. scanf("%f".compteur[i]).789. dim2-1. printf("%d". float nombre[20]. En langage C les tableaux commencent à l'indice 0. nombre[i][j] = 6. float nombre[2][10]. En langage C les tableaux commencent aux indices 0. Utilisation: Un élément du tableau est repéré par son indice. Un tableau est caractérisé par sa taille et par ses éléments. nombre[i] = 6. int compteur[10].789.

On utilisera si possible la fonction puts non formatée: puts(texte).32. est équivalent à gets(texte). on n'écrit pas le symbole &. scanf("%s".texte).128. Le compilateur réserve (dim-1) places en mémoire pour la chaîne de caractères: En effet. est équivalent à printf("%s\n".16.64. char texte[10].texte).4. LES CHAINES DE CARACTERES En langage C. INITIALISATION DES TABLEAUX On peut initialiser les tableaux au moment de leur déclaration: Exemples: int liste[10] = {1. Exemple: char texte[10]. il ajoute toujours le caractère NUL ('\0') à la fin de la chaîne en mémoire.5. float nombre[4] = {2. les chaînes de caractères sont des tableaux de caractères.98.texte).0. /* 2 lignes et 3 colonnes */ 3.2.7}. printf("ENTRER UN TEXTE: ").8. Leur manipulation est donc analogue à celle d'un tableau à une dimension: Déclaration: char nom[dim]. printf("VOICI LE TEXTE: %s\n".09}. int x[2][3] = {{1.3}}.{8.256.4.67.5. Une chaîne étant un pointeur.2. char TXT[10] = "BONJOUR !". 25/76 .528}. On utilisera de préférence la fonction gets non formatée. Saisie: On peut utiliser la fonction scanf et le format %s. Affichage à l'écran: On peut utiliser la fonction printf et le format %s: char texte[10] = "BONJOUR".-8.

le compilateur ajoute '\0' en mémoire après le dernier caractère. <t>. - La fonction strcmp est dépendante du code de caractères et peut fournir différents résultats sur différentes machines. - La concaténation de chaînes de caractères en C ne se fait pas par le symbole '+' comme en langage algorithmique ou en Pascal. on ne peut pas 'affecter' une autre chaîne au nom d'un tableau: Il faut bien copier la chaîne caractère par caractère ou utiliser la fonction strcpy respectivement strncpy: strcpy(A. A l'issue de la saisie d'une chaîne de caractères. 26/76 . il faut utiliser gets. Il faut ou bien copier la deuxième chaîne caractère par caractère ou bien utiliser la fonction strcat ou strncat. <t>. <t>) strcat(<s>. FONCTIONS SUR LES CHAINES DE CARACTERES La bibliothèque <string> fournit une multitude de fonctions pratiques pour le traitement de chaînes de caractères. 4. Voici quelques fonctions les plus fréquemment utilisées: Fonctions pour le traitement de chaînes de caractères strlen(<s>) fournit la longueur de la chaîne sans compter le '\0' final copie <t> vers <s> ajoute <t> à la fin de <s> compare <s> et <t> lexicographiquement et fournit un résultat: négatif si <s> précède <t> zéro si <s> est égal à <t> positif si <s> suit <t> strncpy(<s>. <n>) copie au plus <n> caractères de <t> vers <s> strncat(<s>. <t>) strcmp(<s>. "Hello"). Pour saisir une chaîne de type "il fait beau". <t>) Remarques - Comme le nom d'une chaîne de caractères représente une adresse fixe en mémoire. <n>) ajoute au plus <n> caractères de <t> à la fin de <s> strcpy(<s>.Remarque: scanf ne permet pas la saisie d'une chaîne comportant des espaces: les caractères saisis à partir de l'espace ne sont pas pris en compte (l'espace est un délimiteur au même titre que LF) mais rangés dans le tampon d'entrée.

mais éventuellement plusieurs points de sortie (à l'aide du mot return). b=5 . typen argn) { déclaration variables locales . programmer et utiliser les fonctions.. . expression est évaluée lors de l’instruction return (expression) .b . return a*x+b . } type est le type de la valeur renvoyée par la fonction. type2 arg2. return expression . L'imbrication de fonctions n'est pas autorisée en C: une fonction ne peut pas être déclarée à l'intérieur d'une autre fonction.. Une variable connue uniquement d'une fonction ou de main() est une variable locale. c’est la valeur que renvoie la fonction quand elle est appelée depuis main(). type1 est le type du 1er argument arg1 . INTRODUCTION En langage C les sous-programmes s'appellent des fonctions. 1.. Les variables locales sont des variables qui ne sont connues qu’à l’intérieur de la fonction. /* valeur renvoyée par la fonction */ } 27/76 ... Une variable connue de tout le programme est une variable globale. Cette dernière doit être déclarée avant celle qui l'appelle. DECLARATION On déclare une fonction ainsi : type nom( type1 arg1 . Par contre. Une fonction possède un et un seul point d'entrée. Exemple de fonction : float affine( float x ) { /* la fonction ’affine’ prend 1 argument réel */ /* et renvoie un argument réel */ int a. a=3 .. . une fonction peut appeler une autre fonction.Chapitre 5 LES FONCTIONS Objectifs spécifiques:   Comprendre l'intérêt des fonctions Savoir déclarer. 2. instructions .

FONCTIONS SANS PASSAGE D'ARGUMENTS ET NE RENVOYANT RIEN AU PROGRAMME. 28/76 . Exemple 2 #include <stdio.h> #include <conio. }  Dans cette exemple on traite le cas ou une fonction fait appel à une autre fonction. getch(). } void main() /* programme principal */ { coucou().h> #include <conio. Une fonction ne renvoyant rien au programme est une fonction de type void. }  Dans cette exemple le programme principal appel une fonction bonjour qui se charge d'affichage du message "Bonjour" mais cette dernière ne renvoie rien en retour. } void coucou() /* declaration de la fonction */ { bonjour(). /* appel de la fonction */ printf("POUR CONTINUER FRAPPER UNE TOUCHE: ").3. Exemple1 #include <stdio.h> void bonjour() /* declaration de la fonction */ { printf("bonjour\n"). /* appel de la fonction */ printf("POUR CONTINUER FRAPPER UNE TOUCHE: "). /* appel d'une fonction dans une fonction */ printf("coucou\n"). } void main() /* programme principal */ { bonjour().h> void bonjour() /* declaration de la fonction */ { printf("bonjour\n"). getch().

&choix). printf("VOICI SON CARRE: %d\n". getch(). 29/76 . } void cube() /* declaration de la fonction */ { int n.n2).h> void carre() /* declaration de la fonction */ { int n.&n). n3 = n*n*n. n2. scanf("%d".&n). /* variables locales a cube */ printf("ENTRER UN NOMBRE: ").n2). scanf("%d". Exemple 4 #include <stdio. scanf("%c". } void main() /* programme principal */ { carre(). printf("CALCUL DU CUBE TAPER 3 \n").n3). printf("VOICI SON CUBE: %d\n". /* variables locales à carre */ printf("ENTRER UN NOMBRE: "). printf("VOICI SON CARRE: %d\n". n2 = n*n . printf("\nVOTRE CHOIX: "). } Constatation Les variables n et n2 ne sont connues que de la fonction carré on les appels des variables locaux.&n). /* appel de la fonction */ printf("POUR CONTINUER FRAPPER UNE TOUCHE: "). } void main() /* programme principal */ { char choix.h> #include <conio.h> void carre() /* declaration de la fonction */ { int n. scanf("%d".n2. n2 = n*n. /* variables locales a carre */ printf("ENTRER UN NOMBRE: "). /* variable locale a main() */ printf("CALCUL DU CARRE TAPER 2 \n").Exemple 3 #include <stdio. n3.h> #include <conio.

printf("VOICI SON CUBE: %d\n".break.break. scanf("%d".break. switch(choix) { case '2':carre().switch(choix) { case '2':carre().&choix).n2). /* variable locale a main() */ printf("CALCUL DU CARRE TAPER 2\n"). La variable locale choix n'est connue que de main(). scanf("%c".&n).h> int n. } 30/76 . getch(). printf("CALCUL DU CUBE TAPER 3\n"). } printf("\nPOUR CONTINUER FRAPPER UNE TOUCHE: "). } printf("\nPOUR CONTINUER FRAPPER UNE TOUCHE: "). } void cube() /* declaration de la fonction */ { int n3. /* variable locale */ printf("ENTRER UN NOMBRE: "). getch(). connue de tout le programme */ void carre() /* declaration de la fonction */ { int n2. printf("VOICI SON CARRE: %d\n". n3 = n*n*n.h> #include <conio.break. } void main() /* programme principal */ { char choix.&n). /* variable locale */ printf("ENTRER UN NOMBRE: "). /* variable globale. Exemple 5 #include <stdio. scanf("%d". case '3':cube(). } Constatations Les 2 variables locales n sont indépendantes l'une de l'autre. case '3':cube(). n2 = n*n.n3). printf("\nVOTRE CHOIX: ").

n). /* resultat prend la valeur retournee par le sous-programme */ printf("La Taille saisie est : %d \n". getch(). /* variable locale */ x2 = x*x.h> #include <conio. 4.h> int carre(int x) /* declaration de la fonction */ { /* x est un parametre*/ int x2. Exemple 7 #include <stdio. FONCTIONS AVEC PASSAGE D'ARGUMENTS Ce paragraphe traite directement du cas général: fonctions de type void ou non (renvoyant une valeur ou non). Ces fonctions utilisent les valeurs de certaines variables du programme les ayant appelé: on passe ces valeurs au moyen d'arguments déclarés avec la fonction.h> int TailleTableau() /* declaration de la fonction */ { int Taille. printf("POUR SORTIR FRAPPER UNE TOUCHE "). La valeur retournée est spécifiée à l'aide du mot réservé return. Le type de cette valeur est déclaré avec la fonction. Exemple 6 #include <stdio. n= TailleTableau().&Taille). la fonction. La variable locale choix n'est connue que de main().Constatations La variable globale n est connue de tout le programme (fonctions et main()). /* variable locale */ do{ printf("Entre Taille entre 1 et 20 : "). après exécution. }while((Taille>1) && (Taille<=20)) return(Taille). } 31/76 . renvoie une valeur. FONCTION RENVOYANT UNE VALEUR AU PROGRAMME ET SANS PASSAGE D'ARGUMENTS Dans ce cas. } void main() { int n. Un programme bien construit possède peu de variables globales. return(x2). scanf("%d".h> #include <conio. } 5. Le fichier d’en-tête n’a pas changé.

int y) void fonction2(int a. char c) 6. LE PASSAGE DE PARAMETRES ENTRE FONCTIONS OU ENTRE FONCTIONS ET PROGRAMME PRINCIPAL En langage C. printf("ENTRER UN AUTRE NOMBRE: ").void main() { int n1. le passage de paramètre se fait uniquement par adresse. x est un paramètre. n2. printf("POUR SORTIR FRAPPER UNE TOUCHE: "). On peut allonger la durée de vie d'une variable locale en la déclarant static.&n2). une fonction ne peut pas modifier la valeur des variables locales à main() ou à une autre fonction. float b. Une variable static est initialisée à 0 lors du premier appel à la fonction. 7. res2. il faut respecter la syntaxe suivante: Exemples: void fonction1(int x. Lors d'un nouvel appel à la fonction. Elle ne peut modifier que le contenu de l'adresse de cette variable. sauf si on les initialise à une autre valeur. ou argument: ce n'est pas une variable du programme. getch(). devient static int i. RESUME SUR VARIABLES ET FONCTIONS On a donc vu qu'une variable globale est déclarée au début du programme et qu'elle est connue de tout le programme. Les variables globales sont initialisées à 0 au début de l'exécution du programme. res1. Les variables locales ne sont pas initialisées (sauf si on le fait dans le programme) et elles perdent leur valeur à chaque appel à la fonction. printf("VOICI LEURS CARRES: %d %d\n\n". res2 = carre(n2).&n1).res1. /* variables locales */ printf("ENTRER UN NOMBRE: "). res1 = carre(n1). Exemple: int i. On a vu aussi qu'une variable locale (déclarée au début d'une fonction ou de main()) n'est connue que de cette fonction ou de main(). Autrement dit. } On peut ainsi appeler la fonction carre autant de fois que l'on veut avec des variables différentes. Une variable locale est encore appelée automatique. S'il y a plusieurs arguments à passer. scanf("%d". scanf("%d". res2). la variable garde la valeur obtenue à la fin de l'exécution précédente. 32/76 .

Exemple: Fonction permettant d'échanger la valeur de 2 variables: Syntaxe qui conduit à une erreur: #include <stdio. } PASSAGE DES PARAMETRES PAR VALEUR Syntaxe correcte: #include <stdio. Le problème ne se pose pas lorsque le paramètre est un pointeur ou un tableau. } PASSAGE DES PARAMETRES PAR ADRESSE a et b sont des variables locales à main(). printf("b=%d\n". ech(&a. *x = *y. les adresses x et y (programme de droite). y = tampon. 33/76 . } void main() { int a = 5 . afficher dans main() les adresses de a et de b et dans ech les adresses de x et de y (programme de gauche). noter les résultats obtenus. b = 8. b) . Dans un deuxième temps. int *y) { int tampon. x = y. Expérimenter ces deux exemples.h> void ech(int x.&b). printf("a=%d\n". tampon = *x. b) . tampon = x. printf("a=%d\n". ech(a. printf("b=%d\n". La fonction ech ne peut donc pas modifier leur valeur.h> void ech(int *x. int y) { int tampon. *y = tampon. On le fait donc en passant par l'adresse de ces variables. } void main() { int a = 5 . a) . b = 8 .b). a) .

Exercice 2 Ecrire un programme qui demande à l’utilisateur de donner le rayon d’un cercle et lui retourne sa surface et son périmètre. le produit et le quotient de ces 2 entiers. Exercice 5 Ecrire un programme qui saisit un caractère c puis affiche son code ASCII en décimal. Exercice 3 Ecrire un programme qui saisit deux entiers a et b et permute la valeur de ces deux entiers. 34/76 .REPUBLIQUE TUNISIENNE MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE SCIENTIFIQUES ET TECHNOLOGIQUES UNIVERSITE DE JENDOUBA FACULTE DES SCIENCES JURIDIQUES. ECONOMIQUES ET DE GESTION DE JENDOUBA Année Universitaire : 2009/2010 Module : Atelier de programmation I Semestre : 1 Classe : 1ère année LFIAG Enseignant : Riadh BOUSLIMI TP n°1 Exercice 1 Ecrire un programme qui saisit 2 entiers et affiche successivement la somme. en octal(base huit) et en hexadécimal(base seize). Exercice 4 Ecrire un programme qui saisit un réel x et un entier n et affiche x à la puissance n. la différence.

Pi*r*r). b=tampon.tampon.h> #include<conio.h> void main() { /* il faut utiliser une variable tampon pour l'echange */ int a. a=b. getch(). difference de %d et %d vaut %d". scanf("%d %d".&r).. /* Attente d'une saisie clavier */ } 35/76 .h> #define Pi 4*atan(1) void main() { float r. printf("La surface du cercle vaut %f \n".b.a*b). quotient de %d et %d vaut %f\n". printf("Pour continuer frapper une touche.a.&b)."). printf("Entrer deux nombres entiers :"). scanf("%f"..h> #include<conio.b.&a. getch(). /* Attente d'une saisie clavier */ } Exercice 2 #include<stdio.a-b).. printf("Pour continuer frapper une touche. produit de %d et %d vaut %d".&b)..h> #include<math.b.a.b.b.b).(float)a/(float)b)..Correction du TP n°1 Exercice 1 #include<stdio. getch(). printf("b vaut maintenant %d\n".h> void main() { int a.a).a+b). scanf("%d %d". printf("Le perimetre du cercle vaut %f\n".2*Pi*r). printf("\nLa printf("\nLa printf("\nLe printf("\nLe somme de %d et %d vaut %d"..a. printf("Entrer 2 entiers a et b:").").b. printf("Pour continuer frapper une touche.&a.h> #include<conio."). tampon=a.a. printf("a vaut maintenant %d\n". printf("Entrer le rayon du cercle :"). /* Attente d'une saisie clavier */ } Exercice 3 #include<stdio.

n)).h> void main() { int n. printf("%d\n"..h> void main() { char c.Exercice 4 #include<stdio. printf("Entrer un caractère :")..").. getch(). getch().h> #include<conio. printf("\nEntrer un reel :"). printf("Pour continuer frapper une touche. printf("Entrer une puissance entiere:"). /* Attente d'une saisie clavier */ } 36/76 .").&n).pow(x. /* affichage du code ASCII en base huit /* et retour … à la ligne */ printf("%x\n".h> #include <conio. printf("%f a la puissance %d vaut %f\n". /* affichage du code ASCII en hexadecimal /* et retour … à la ligne */ printf("Pour continuer frapper une touche. float x.&c).c).. scanf("%d".h> #include<math. scanf("%c".c). /* affichage du code ASCII en decimal */ /* et retour … à la ligne */ printf("%o\n".n.x. /* Attente d'une saisie clavier */ } Exercice 5 #include <stdio.c). scanf("%f".&x).

REPUBLIQUE TUNISIENNE
MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE
LA RECHERCHE SCIENTIFIQUES ET TECHNOLOGIQUES

UNIVERSITE DE JENDOUBA
FACULTE DES SCIENCES JURIDIQUES, ECONOMIQUES ET DE GESTION DE JENDOUBA

Année Universitaire : 2009/2010
Module : Atelier de programmation I

Semestre : 1
ère
Classe : 1 année LFIAG
Enseignant : Riadh BOUSLIMI

TP n°2
Objectifs de ce TP c'est d'utiliser la forme adéquate des structures de contrôle conditionnelles pour
résoudre des problèmes.

Exercice 1
Considérez la séquence d'instructions suivante:
if (A>B) printf ("premier choix \n");else
if (A>10) printf ("deuxième choix \n");
if (B<10) printf ("troisième choix \n");
else printf ("quatrième choix \n");

a) Copiez la séquence d'instructions en utilisant des tabulateurs pour marquer les blocs if - else
appartenant ensemble.
b) Déterminez les réponses du programme pour chacun des couples de nombres suivants et
vérifiez à l'aide de l'ordinateur. 

A=10 et B=5 

A=5 et B=5 

A=5 et B=10 

A=10 et B=10 

A=20 et B=10 

A=20 et B=20

37/76

Exercice 2
Considérez la séquence d'instructions suivante:
if (A>B)
if (A>10)
printf ("premier choix \n"); else if (B<10)
printf ("deuxième choix \n"); else
if (A==B) printf ("troisième choix \n");
else printf ("quatrième choix \n");

a) Copiez la séquence d'instructions en utilisant des tabulateurs pour marquer les blocs if - else
appartenant ensemble.
b) Pour quelles valeurs de A et B obtient-on les résultats:
premier choix, deuxième choix, ... sur l'écran?
c) Pour quelles valeurs de A et B n'obtient-on pas de réponse sur l'écran?
d) Notez vos réponses et choisissez vous-mêmes des valeurs pour A et B pour les vérifier l'aide
de l'ordinateur.

Exercice 3
Ecrivez un programme qui saisit un caractère, et qui teste s'il s'agit d'une lettre majuscule, si oui il
renvoie cette lettre en minuscule, sinon il renvoie un message d'erreur.

Exercice 4
Ecrivez un programme qui lit trois valeurs entières (A, B et C) au clavier et qui affiche la plus grande
des trois valeurs, en utilisant:
a) if - else et une variable d'aide MAX
b) if - else if - ... - else sans variable d'aide
c) les opérateurs conditionnels et une variable d'aide MAX
d) les opérateurs conditionnels sans variable d'aide

Exercice 5
Ecrivez un programme qui lit trois valeurs entières (A, B et C) au clavier. Triez les valeurs A, B et C
par échanges successifs de manière à obtenir :
val(A) val(B) val(C)
Affichez les trois valeurs.

Exercice 6
Ecrivez un programme qui lit deux valeurs entières (A et B) au clavier et qui affiche le signe du
produit de A et B sans faire la multiplication.

Exercice 7
Ecrivez un programme qui lit deux valeurs entières (A et B) au clavier et qui affiche le signe de la
somme de A et B sans faire l'addition. Utilisez la fonction fabs de la bibliothèque <math.h> qui
renvoie la valeur absolue d'un flottant.

38/76

Exercice 8
Ecrivez un programme qui calcule les solutions réelles d'une équation du second degré ax2+bx+c =
0 en discutant la formule:

Utilisez une variable d'aide D pour la valeur du discriminant b2-4ac et décidez à l'aide de D, si
l'équation a une, deux ou aucune solution réelle.
Utilisez des variables du type int pour A, B et C.
Considérez aussi les cas où l'utilisateur entre des valeurs nulles pour A; pour A et B; pour A, B et C.
Affichez les résultats et les messages nécessaires sur l'écran.

Exercice 9
Ecrivez un programme qui permet de saisir un entier entre 1 et 7 et affiche en toutes lettres le nom du
jour de la semaine qui lui correspond.

39/76

else printf ("quatrième choix \n").Correction du TP n°2 Exercice 1 if (A>B) printf ("premier choix \n"). else printf ("quatrième choix \n"). else if (B<10) printf ("deuxième choix \n"). if (A>B) if (A>10) printf ("premier choix \n"). if (B<10) printf ("troisième choix \n"). else printf ("quatrième choix \n"). A=10 et B=5 : premier choix troisième choix A=5 et B=5 : troisième choix A=5 et B=10 : quatrième choix A=10 et B=10 : quatrième choix A=20 et B=10 : premier choix quatrième choix A=20 et B=20 : deuxième choix quatrième choix Exercice 2 Considérez la séquence d'instructions suivante: if (A>B) if (A>10) printf ("premier choix \n"). if (B<10) printf ("troisième choix \n"). else if (A==B) printf ("troisième choix \n"). else if (B<10) printf ("deuxième choix \n"). else printf ("quatrième choix \n").else appartenant ensemble. a) Copiez la séquence d'instructions en utilisant des tabulateurs pour marquer les blocs if . if (A>B) printf ("premier choix \n"). else if (A>10) printf ("deuxième choix \n"). b) Déterminez les réponses du programme pour chacun des couples de nombres suivants et vérifiez à l'aide de l'ordinateur. a) Copiez la séquence d'instructions en utilisant des tabulateurs pour marquer les blocs if . else if (A>10) printf ("deuxième choix \n"). else if (A==B) printf ("troisième choix \n").else appartenant ensemble. 40/76 .

} Exercice 4 a) if . printf("POUR CONTINUER FRAPPER UNE TOUCHE "). else MAX=B. else printf("CE N'EST PAS UNE LETTRE MAJUSCULE\n"). c = getchar(). printf("Introduisez trois nombres entiers :").else if . if (A>B) MAX=A. Si (A>B) alors la construction if . C. MAX).. scanf("%d %d %d".h> #include <conio. printf("La valeur maximale est %d\n".else garantit que toutes les combinations sont traitées et fournissent un résultat. if (C>MAX) MAX=C. &A.h> void main() { int A. &C). B.b) Le résultat: "premier choix" apparaît pour (A>B) et (A>10) "deuxième choix" apparaît pour (10A>B) "troisième choix" apparaît pour (10A>B10) et (A=B) 10>10 impossible A>B et A=B impossible "quatrième choix" => "troisième choix" n'apparaît jamais apparaît pour (10A>B10) et (AB) 10>10 impossible => "quatrième choix" n'apparaît jamais c) On n'obtient pas de réponses pour (AB). getch(). int MAX. printf("ENTRER UNE LETTRE:"). if((c>='A') && (c<='Z')) printf("CETTE LETTRE EN MINUSCULE: %c\n". printf("Tapez une touche pour continuer…").h> #include <conio..else et une variable d'aide MAX #include <stdio. &B.h> void main() { char c. Exercice 3 #include <stdio. getch(). . } 41/76 ..c).

} printf("Après le tri : \tA = %d\tB = %d\tC = %d\n". printf("Introduisez trois nombres entiers :"). . C. printf("La valeur maximale est "). } if (A<C) { AIDE = A. B = C. printf("Introduisez trois nombres entiers :"). &B. C. &A.. &B. printf("Avant le tri : \tA = %d\tB = %d\tC = %d\n". A. scanf("%d %d %d". C = AIDE. MAX = (MAX>C) ? MAX : C. scanf("%d %d %d". printf("La valeur maximale est %i\n". C = AIDE.. printf("La valeur maximale est %d\n". } 42/76 . Exercice 5 #include <stdio. C). AIDE. c) opérateurs conditionnels et une variable d'aide MAX int A. B. B.h> void main() { /* Tri par ordre décroissant de trois entiers en échangeant les valeurs */ int A. scanf("%d %d %d". &A.. &C). if (A>B && A>C) printf("%d\n".C). A.else sans variable d'aide int A. &A.A).B). printf("Introduisez trois nombres entiers :").b) if . C. &A. (A>((B>C)?B:C)) ? A : ((B>C)?B:C)). &C). &B. C. /* Valeur maximale -> A */ if (A<B) { AIDE = A. C). &C). else printf("%d\n". printf("Tapez une touche pour continuer…"). A = C. B = AIDE. B. int MAX. } /* trier B et C */ if (B<C) { AIDE = B. scanf("%d %d %d". else if (B>C) printf("%d\n". &C).h> #include <conio. B. B. getch(). &B. printf("Introduisez trois nombres entiers :"). MAX = (A>B) ? A : B. B. MAX). A = B. d) opérateurs conditionnels sans variable d'aide int A.else if .

&A. /* Calcul du discriminant b^2-4ac */ D = pow(B.h> #include <conio. et c : "). &B. getch(). B).Exercice 6 #include <stdio. B. if ((A>0 && B>0) || (A<0 && B>0 && fabs(A)<fabs(B)) || (A>0 && B<0 && fabs(A)>fabs(B))) printf("Le signe de la somme %d + %d est positif\n".B). scanf("%d %d %d". &A. B). printf("Introduisez deux nombres entiers :").h> #include <math.h> void main() { /* Calcul des solutions réelles d'une équation du second degré */ int A. if ((A>0 && B>0) || (A<0 && B<0)) printf("Le signe du produit %d * %d est positif\n". printf("\n Tapez une touche pour continuer…"). float D.B). else printf("La somme %d + %d est zéro\n".4. /* Discriminant */ printf("Calcul des solutions réelles d'une équation du second \n"). printf("degré de la forme ax^2 + bx + c = 0 \n\n"). A. C.h> #include <conio.A. } Exercice 8 #include <stdio. scanf("%d %d". B). &A. B. printf("Introduisez deux nombres entiers :").A.2) . A. &B). B.h> void main() { /* Afficher le signe du produit de deux entiers sans faire la multiplication */ int A. else printf("Le produit %d * %d est zéro\n". B). &C).0*A*C.h> #include <conio. else if ((A<0 && B<0) || (A<0 && B>0 && fabs(A)>fabs(B)) || (A>0 && B<0 && fabs(A)<fabs(B))) printf("Le signe de la somme %d + %d est négatif\n".h> void main() { /* Afficher le signe de la somme de deux entiers sans faire l'addition */ int A. A. b. printf("Introduisez les valeurs pour a. } Exercice 7 #include <stdio.h> #include <math. getch(). scanf("%d %d". else if ((A<0 && B>0) || (A>0 && B<0)) printf("Le signe du produit %d * %d est négatif\n". &B). A. printf("Tapez une touche pour continuer…"). 43/76 .

case 2: jour="Mardi".break.h> void main() { int N. (-B-sqrt(D))/(2*A)). case 3: jour="Mercredi". default: printf("\n Jour Incorrect").h> #include <conio. printf(" x1 = %f\n". printf(" x2 = %f\n". printf("Introduisez le numéro du jour entre 1 et 7 :").\n"). (-B+sqrt(D))/(2*A)). N. &N). printf(" x = %f\n". case 5: jour="Vendredi". case 7: jour="Dimanche". } else if (D<0) /* b^2-4ac < 0 */ printf("Cette équation n'a pas de solutions réelles. scanf("%d".break. getch(). } 44/76 . case 4: jour="Jeudi".\n"). printf(" x = %f\n". switch(N) { case 1: jour="Lundi". case 6: jour="Samedi". } Exercice 9 #include <stdio. -B/(2*A)). getch(). else if (D==0) /* b^2-4ac = 0 */ { printf("Cette équation a une seule solution réelle :\n").break. } /* pas de break ici */ printf("Le jour de la semaine de %d est %s :".break. else if (A==0 && B==0) /* Contradiction: c # 0 et c = 0 */ printf("Cette équation ne possède pas de solutions. string jour[]. jour)./* Distinction des différents cas */ if (A==0 && B==0 && C==0) /* 0x = 0 */ printf("Tout réel est une solution de cette équation. } else /* b^2-4ac > 0 */ { printf("Les solutions réelles de cette équation sont :\n").break.\n"). } printf("\n tapez une touche pour continuer…").break. -C/B). else if (A==0) /* bx + c = 0 */ { printf("La solution de cette équation du premier degré est :\n"). printf("Tapez une touche pour continuer…").break.

compter et afficher le nombre de lettres e et d'espaces. c) en utilisant for.. a) en utilisant while. Utiliser les propriétés du tampon. Exercice 1 Saisir une suite de caractères. Choisissez un type approprié pour les valeurs à afficher.. ECONOMIQUES ET DE GESTION DE JENDOUBA Année Universitaire : 2009/2010 Module : Atelier de programmation I Semestre : 1 ère Classe : 1 année LFIAG Enseignant : Riadh BOUSLIMI TP n°3 Objectifs de ce TP c'est la manipulation des structures itératives et savoir distinguer entre les différentes formes (structure itérative complète et structure itérative à condition d'arrêt). + 1/N 45/76 .REPUBLIQUE TUNISIENNE MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE SCIENTIFIQUES ET TECHNOLOGIQUES UNIVERSITE DE JENDOUBA FACULTE DES SCIENCES JURIDIQUES. Résolvez ce problème.while. Le nombre N est à entrer au clavier. Exercice 2 Ecrivez un programme qui lit N nombres entiers au clavier et qui affiche leur somme. leur produit et leur moyenne. Exercice 3 Calculez par des soustractions successives le quotient entier et le reste de la division entière de deux entiers entrés au clavier. Exercice 5 Calculez la somme des N premiers termes de la série harmonique : 1 + 1/2 + 1/3 + . b) en utilisant do . Exercice 4 Calculez par multiplications successives XN de deux entiers naturels X et N entrés au clavier.

1 . Exercice 7 Calculez le nombre lu à rebours d'un nombre positif entré au clavier en supposant que le fichier d'entrée standard contient une suite de chiffres non nuls. 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. Exemple: Entrée: 1 2 3 4 0 Affichage: 4321 Exercice 8 Calculez le nombre lu à rebours d'un nombre positif entré au clavier en supposant que le fichier d'entrée standard contient le nombre à inverser..Exercice 6 Calculez la somme. Retenez seulement les chiffres (0. Exemple: Entrée: 1234 Affichage: 4321 Exercice 9 Calculez 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. terminée par zéro (Contrôlez s'il s'agit vraiment de chiffres). 46/76 . 9) lors de l'entrée des données et effectuez un signal sonore si les données sortent de ce domaine.

SOM=0. while(I<=N) { printf("%d. SOM). (float)SOM/N). PROD). while((c=getchar())!='\n') { if(c=='e')compt_e++. getchar ne prend en compte que le 1er caractere les autres sont ranges dans le tampon if(c==' ')compt_espace++. } Exercice 2 a) en utilisant while. &N). N.compt_espace). %d nombres est %f\n". &NOMB). N. } b) en utilisant do . /* /* /* /* /* */ */ */ et recuperes par getchar lors */ des autres passages */ lors du 1er passage.h> void main() { int N. printf("NOMBRE D'ESPACE: %d\n".h> #include <conio. Remplacez le bloc de traitement (en gras) de (a) par : SOM=0.compt_e).Correction du TP n°3 Exercice 1 #include <stdio. printf("POUR SORTIR FRAPPER UNE TOUCHE "). nombre : ".h> void main() { char c. I++. do 47/76 .compt_e= 0. PROD=1. int compt_espace= 0. %d nombres est %ld \n".while. %d nombres est %f\n". /* nombre courant */ int I. /* la somme des nombres entrés */ double PROD. I=1. I=1. FRAPPER UNE TOUCHE "). } printf("NOMBRE DE e: %d\n". scanf("%d". /* le produit des nombres entrés */ printf("Nombre de données : "). getch(). SOM += NOMB. /* compteur */ long SOM. printf("ENTRER UNE PHRASE:\n"). PROD *= NOMB. scanf("%d". } printf("La somme des printf("Le produit des printf("La moyenne des printf("POUR CONTINUER getch().h> #include <conio. #include <stdio. N. I). PROD=1. /* nombre de données */ int NOMB.

while(RES>=DEN) { RES-=DEN. &X). Remplacez le bloc de traitement (en gras) de (a) par : for (SOM=0.h> #include <conio. scanf("%d". */ do { printf("Entrez l'entier naturel X : "). SOM += NOMB. PROD *= NOMB.h> void { int int int int main() NUM. } /* ou mieux encore : */ for (RES=NUM. &NUM). /* Le compteur */ double RESU. DEN. RES. scanf("%d". RES>=DEN . scanf("%d". I=1 . I++) { printf("%d. printf("Introduisez le dénominateur : "). getch(). RES). N. DIV=0 .h> void main() { int X. } Exercice 3 #include <stdio. c) en utilisant for. DIV. I++. RES=NUM. /* /* /* /* numérateur de la division entière */ dénominateur de la division entière */ résultat de la division entière */ reste de la division entière */ printf("Introduisez le numérateur : "). I). &NOMB). PROD *= NOMB. &DEN). &NOMB).{ printf("%d. scanf("%d". I). I<=N . DIV++) RES-=DEN. SOM += NOMB. DIV=0. DEN. */ printf(" %d divisé par %d est %d reste %d\n". } while(I<=N). printf("POUR CONTINUER FRAPPER UNE TOUCHE "). } Exercice 4 #include <stdio. nombre : ". scanf("%d".h> #include <conio. nombre : ". /* Les données */ int I. /* Type double à cause de la */ /* grandeur du résultat. PROD=1. NUM. } while (X>=0). 48/76 . DIV. DIV++.

Type long à */ cause de la grandeur du résultat.h> #include <conio. printf("POUR CONTINUER FRAPPER UNE TOUCHE "). I<=N . scanf ("%d". 0^0 n'est pas défini */ if (N==0 && X==0) printf("zéro exposant zéro n'est pas défini !\n"). le résultat sera automatiquement X^0=1 */ for (RESU=1. /* Type float à cause de la précision du résultat.h> #include <conio.do { printf("Entrez l'exposant scanf("%d". /* Attention: Pour X=0 et N=0 .0. &N). I++) RESU*=X. getch(). I=1 . } Exercice 6 Solution (une de plusieurs solutions possibles) : #include <stdio. int SOM=0. for (SOM=0. } while (N<0). do { printf ("Nombre de termes: "). printf("POUR CONTINUER FRAPPER UNE TOUCHE "). N : "). printf("La somme des %d premiers termes est %f \n". } while (N>=1). /* Pour N=0. X. RESU). I=1 . /* /* /* /* /* Le chiffre courant */ Le compteur des données */ La somme actuelle */ Le produit actuel .h> void main() { int N. /* compteur pour la boucle */ float SOM. } Exercice 5 #include <stdio.0f\n". &N). N. I++) SOM += (float)1/I. else printf("Résultat : %d ^ %d = %. int N=0. N. I<=N . getch(). /* nombre de termes à calculer */ int I. */ 49/76 */ .0.h> void main() { int X. SOM). long PROD=1.

else if (X) { N++. (N+1). int N=0. /* /* /* /* Le chiffre courant */ Le compteur des décimales */ Valeur de la position décimale courante */ Le nombre résultat */ do { printf("Entrez le %d%s chiffre : ". getch(). (N+1).h> #include <conio. if (X<0||X>9) printf("\a"). SOM+=X. printf("Le produit des chiffres est %ld\n". long VALD=1. &X). printf("La moyenne des chiffres est %f \n". par 50/76 .do { /* Saisie des données (pour perfectionnistes) */ printf("Entrez le %d%s chiffre : ". SOM). VALD *= 10. PROD). &X). scanf("%d". (N)?"e":"er"). printf("POUR CONTINUER FRAPPER UNE TOUCHE "). } Remarque : En remplaçant la ligne NOMB += VALD*X. getch(). N++. } else if (!X && N>0) {/* Seulement si au moins un chiffre a été accepté */ printf("La somme des chiffres est %d \n". long NOMB=0. } else printf("La valeur du nombre renversé est %ld\n". (float)SOM/N). NOMB). (N)?"e":"er"). printf("POUR CONTINUER FRAPPER UNE TOUCHE ").h> void main() { int X. PROD*=X. } Exercice 7 #include <stdio. if (X>=0 && X<=9) printf("\a"). } while (X). scanf("%d". else if (X) { NOMB += VALD*X. } } while (X).

h> #include <conio. on n'a plus besoin de la variable VALD. Exercice 8 #include <stdio. scanf("%d". NINV += NOMB%10. scanf("%d".h> void main() { int NOMB. I++) { UN = U1+U2. printf("POUR CONTINUER FRAPPER UNE TOUCHE "). while(NOMB>0) { NINV *= 10. Finalement. /* Le nombre inversé */ /* Attention: en utilisant le type int.h> void { int int int do { main() U1.NOMB += pow(10. cette variante est plus lente et plus volumineuse que la première. /* Le nombre à inverser */ int NINV. } while (NOMB<0 || NOMB>9999).. U1=U2=1. U1 = U2. getch(). D'autre part. I<=N . } /* Autre possibilité : */ /* for (NINV=0 . U2. NOMB>0 .. /* pour parcourir la suite */ /* rang du terme demandé */ /* compteur pour la boucle */ printf("Rang du terme demandé : "). &N). le calcul de 10N serait alors répété à chaque exécution de la boucle. N. NINV). } Exercice 9 #include <stdio. UN. Il faut cependant inclure les fonctions de la bibliothèque <math>. NOMB /= 10. 51/76 . il est impossible */ /* d'inverser correctement des nombres comme 10033 .h> #include <conio. */ printf("Le nombre 'inversé' est : %d\n". I. NOMB). &NOMB). else{ for (I=3 . N)*X. } while(N<1). */ do { printf("Entrez un nombre positif (<10000) : ". NOMB/=10) NINV = NINV*10 + NOMB%10. NINV=0. else if (N==2) UN=U2. /* Initialisation des deux premiers termes */ if (N==1) UN=U1.

getch(). U2. UN). } Rang et terme maximal calculable en utilisant les déclarations : int U1. UN. printf("POUR CONTINUER FRAPPER UNE TOUCHE "). } } printf("Valeur du terme de rang %d : %d\n".U2 = UN. (spéc. de format : %d) U23 = 28657 52/76 . N.

caractère) void *strrchr(chaine.caractère) void *strstr(chaîne.h):  void *strcat(char *chaine1. char *chaine2)     concatène les 2 chaînes. ECONOMIQUES ET DE GESTION DE JENDOUBA Année Universitaire : 2009/2010 Module : Atelier de programmation I Semestre : 1 Classe : 1ère année LFIAG Enseignant : Riadh BOUSLIMI TP n°4 Objectifs de ce TP c'est la manipulation des tableaux et les chaînes de caractères. Bibliothèque (stdlib.    void *strchr(chaine. sinon le pointeur NULL (c'est à dire le pointeur de valeur 0 ou encore le pointeur faux). recherche la sous-chaine dans la chaîne. void *strrev(char *chaine) inverse la chaîne et.char *chaine2) recopie chaine2 dans chaine1 et renvoie l'adresse de chaîne1.char *chaine2) renvoie un nombre: o positif si la chaîne1 est supérieure à la chaine2 (au sens de l'ordre alphabétique) o négatif si la chaîne1 est inférieure à la chaîne2 o nul si les chaînes sont identiques. Ce qu'il faut retenir Bibliothèque (string.REPUBLIQUE TUNISIENNE MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE SCIENTIFIQUES ET TECHNOLOGIQUES UNIVERSITE DE JENDOUBA FACULTE DES SCIENCES JURIDIQUES. Ces fonctions renvoient l'adresse de l'information recherchée en cas de succès. renvoie l'adresse de chaine1. /* affiche 123 si texte vaut "123" */ /* affiche 0 si texte vaut "bonjour" */ 53/76 . n = atoi(texte) . idem en commençant par la fin. et utiliser les fonctions prédéfinies pour résoudre des problèmes. printf("%d". renvoie l'adresse de la chaine inversée. int strlen(char *chaine) renvoie la longueur de la chaine ('\0' non comptabilisé).sous-chaîne) recherche le caractère dans la chaîne. gets(texte).n). résultat dans chaine1. int strcmp(char *chaine1.h):   int atoi(char *chaîne) float atof(char *chaine) exemple: convertit la chaîne en entier convertit la chaîne en réel printf("ENTRER UN TEXTE: "). void *strcpy(char *chaine1.

Exercice n°2 Écrire un programme qui calcule le produit scalaire de deux vecteurs d'entiers U et V (de même dimension). void *itoa(int n. Question: Quel est l'avantage de la recherche dichotomique ? Exercice n°5 Ecrire un programme qui demande l'introduction du nom et du prénom de l'utilisateur et qui affiche alors la longueur totale du nom sans compter les espaces. Calculer et afficher ensuite la somme des éléments du tableau. aura la valeur 1 aussi longtemps que VAL n'a pas été trouvée. Employer la fonction strlen. sinon afficher un message correspondant. continuer la recherche dans le demi-tableau à droite de la position actuelle. Écrire le programme pour le cas où le tableau A est trié par ordre croissant.char *chaîne.  s'il y a égalité ou si le tableau est épuisé.  si la valeur recherchée suit la valeur actuelle du tableau. le programme retiendra la position du premier maximum ou minimum rencontré. continuer la recherche dans le demi-tableau à gauche de la position actuelle. Si le tableau contient plusieurs maxima ou minima. cette fonction renvoie l'adresse de la chaîne. La valeur POS qui est utilisée pour mémoriser la position de la valeur dans le tableau.  si la valeur recherchée précède la valeur actuelle du tableau. exemple: itoa(12.int base) convertit un entier en chaîne: base: base dans laquelle est exprimé le nombre. 54/76 . Afficher la position de VAL si elle se trouve dans le tableau. b) La recherche dichotomique Condition: Le tableau A doit être trié Comparer le nombre recherché à la valeur au milieu du tableau. remplit le tableau par des valeurs entrées au clavier et affiche le tableau.texte. texte vaut "12" Exercice n°1 Écrire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50 composantes). Exercice n°4 Problème: Rechercher dans un tableau d'entiers A une valeur VAL entrée au clavier. Afficher ensuite la valeur et la position du maximum et du minimum. arrêter le traitement avec un message correspondant. Implémenter deux versions: a) La recherche séquentielle Comparer successivement les valeurs du tableau avec la valeur donnée.10). Exemple: / | 3 \ 2 \ / -4 | * | 2 / \ -3 \ 5 | = 3*2+2*(-3)+(-4)*5 = -20 / Exercice n°3 Écrire un programme qui détermine la plus grande et la plus petite valeur dans un tableau d'entiers A.

les compare lexicographiquement et affiche le résultat: Exemple: Introduisez la première chaîne: ABC Introduisez la deuxième chaîne: abc "ABC" précède "abc" Exercice n°11 55/76 . Ctt lign contint qulqus lttrs .Exemple: Introduisez votre nom et votre prénom: HSINI Sana Bonjour HSINI Sana ! Votre nom est composé de 9 lettres. mais dans l'ordre inverse. Les mots sont mémorisés dans 5 variables M1. sans changer le contenu de la variable TXT. Exemple voici une petite phrase ! ! phrase petite une voici Exercice n°7 Écrire un programme qui lit une ligne de texte (ne dépassant pas 200 caractères) la mémorise dans une variable TXT et affiche ensuite: a) la longueur L de la chaîne. c) toute la phrase à rebours. Contrôlez s'il s'agit bien d'un verbe en "er" avant de conjuguer. Exercice n°6 Écrire un programme qui lit 5 mots. Exercice n°9 Ecrire un programme qui lit un verbe régulier en "er" au clavier et qui en affiche la conjugaison au présent de l'indicatif de ce verbe.M5. séparés par des espaces et qui les affiche ensuite dans une ligne. strcat et strlen.. après avoir inversé l'ordre des caractères dans TXT: Exemple : voici une petite phrase ! ! esarhp etitep enu iciov Exercice n°8 Ecrire un programme qui lit un texte TXT (de moins de 200 caractères) et qui enlève toutes les apparitions du caractère 'e' en tassant les éléments restants. puts. Exemple: Verbe : fêter je fête tu fêtes il fête nous fêtons vous fêtez ils fêtent Exercice n°10 Ecrire un programme qui lit deux chaînes de caractères CH1 et CH2. Les modifications se feront dans la même variable TXT.. b) le nombre de 'e' contenus dans le texte. Exemple: Cette ligne contient quelques lettres e. d) toute la phrase à rebours. Utiliser les fonctions gets. . .

La taille maximale du mot est 30 caractères. Un mot est dit palindrome si la lecture du mot se fait à gauche et à droite.Écrire un programme qui permet de vérifier si un mot saisit est un palindrome. Exemple : “aziza” 56/76 .

h> #include<conio. } /* Affichage du tableau */ printf("Tableau donné :\n"). /* tableaux donnés */ int N. /* dimension */ int I. &U[I]). SOM).50) : "). printf("\n Tapez une touche pour continuer…"). I<N. */ /* Saisie des données */ do{ printf("Dimension du tableau (max. /* tableau donné */ int N. scanf("%d". I). }while(N>=1 && N<=50). scanf("%d". for (I=0. /* Edition du résultat */ printf("Somme de éléments : %ld\n". }while(N>=1 && N<=50). I++) { printf("Elément %d : ". V[50]. I++) SOM += T[I]. &N ).50) : "). I). for (I=0. for (I=0. I). /* indice courant */ long SOM. I<N. 57/76 . printf("** Premier tableau **\n").CORRECTION DU TP N°4 Exercice n°1 #include<stdio.h> #include<conio. /* Calcul de la somme */ for (SOM=0. scanf("%d".h> void main() { /* Déclarations */ int U[50]. for (I=0. &T[I]). /* indice courant */ long PS. scanf("%d".type long à cause */ /* de la grandeur prévisible du résultat. getch(). I++) { printf("Elément %d : ". T[I]).h> void main() { /* Déclarations */ int T[50]. &N ). I++) { printf("Elément %d : ". /* somme des éléments . I=0. /* produit scalaire */ /* Saisie des données */ do{ printf("Dimension du tableau (max. printf("\n"). I<N. I<N. } printf("** Deuxième tableau **\n"). I<N. } Exercice n°2 #include<stdio. I++) printf("%d ". /* dimension */ int I.

PS).h> #include<conio. /* position du minimum */ int MAX. /* Recherche du maximum et du minimum */ MIN=0. I<N. } Exercice n°3 #include<stdio. I=0. I++) printf("%d ". I++) { if(A[I]>A[MAX]) MAX=I. &V[I]). #include<stdio. MAX). /* tableau donné */ int N. printf("\n Tapez une touche pour continuer…").h> #include<conio.50) : "). /* indice courant */ int MIN. for (I=0. I). getch(). A[I]). printf("Valeur du minimum : %d\n". I++) { printf("Elément %d : ". I<N. printf("\n"). } Exercice n°4 a) La recherche séquentielle : Comparer successivement les valeurs du tableau avec la valeur donnée. MIN). /* dimension */ int I. I<N. A[MAX]). /* Edition du résultat */ printf("Produit scalaire : %ld\n". } /* Affichage du tableau */ printf("Tableau donné :\n"). getch(). }while(N>=1 && N<=50). printf("Valeur du maximum : %d\n". /* position du maximum */ /* Saisie des données */ do{ printf("Dimension du tableau (max. I++) PS += (long)U[I]*V[I]. scanf("%d".scanf("%d". for (I=0. /* position de la valeur */ 58/76 . if(A[I]<A[MIN]) MIN=I. for (I=0. scanf("%d". &N ). } /* Edition du résultat */ printf("Position du minimum : %d\n". MAX=0.h> void main() { /* Déclarations */ int A[50]. printf("Position du maximum : %d\n". /* tableau donné */ int VAL. printf("\n Tapez une touche pour continuer…"). A[MIN]). /* valeur à rechercher */ int POS. } /* Calcul du produit scalaire */ for (PS=0. &A[I]).h> void main() { /* Déclarations */ int A[50]. I<N.

I<N. I++) printf("%d ". for (I=0. I<N. &A[I]). MIL. /* dimension */ int I. scanf("%d".50) : "). } printf("Elément à rechercher : "). /* Recherche de la position de la valeur */ 59/76 . getch(). /* Recherche de la position de la valeur */ POS = -1. for (I=0. &A[I]). VAL. &VAL ). printf("\n").h> void main() { /* Déclarations */ int A[50]. &N ). I++) printf("%d ". /* Affichage du tableau */ printf("Tableau donné : \n"). scanf("%d". /* Affichage du tableau */ printf("Tableau donné : \n"). /* indice courant */ int INF. /* Initialisation des limites du domaine de recherche */ INF=0. }while(N>=1 && N<=50).h> #include<conio. for (I=0 . /* position de la valeur */ int N. printf("\n Tapez une touche pour continuer…"). scanf("%d". I<N. A[I]). A[I]). for (I=0. I++) { printf("Elément %d : ". I<N. int I. /* tableau donné */ int VAL. for (I=0. scanf("%d". \n". &N ). /* Edition du résultat */ if (POS==-1) printf("La valeur recherchée ne se trouve pas " "dans le tableau. }while(N>=1 && N<=50). I++) { printf("Elément %d : ". printf("\n").int N. else printf("La valeur %d se trouve à la position %d. (I<N)&&(POS==-1) . } b) La recherche dichotomique #include<stdio. &VAL ). I). /* limites du champ de recherche */ /* Saisie des données */ do{ printf("Dimension du tableau (max. /* dimension */ /* indice courant */ /* Saisie des données */ do{ printf("Dimension du tableau (max. } printf("Elément à rechercher : "). SUP. I). /* valeur à rechercher */ int POS. scanf("%d". I++) if (A[I]==VAL) POS=I. SUP=N-1.\n").50) : "). POS). scanf("%d".

POS=-1. printf("\n Tapez une touche pour continuer…"). il faut traverser tout le tableau avant de trouver la valeur ou avant d'être sûr qu'une valeur ne se trouve pas dans le tableau. scanf("%s %s". \n". PRENOM[40]. if (VAL < A[MIL]) SUP=MIL-1. . printf("\nBonjour %s %s !\n". PRENOM). while ((INF<=SUP) && (POS==-1)) { MIL=(SUP+INF)/2.h> #include<conio.le pire des cas pour la recherche séquentielle peut entraîner 1 048 576 exécutions de la boucle.h> void main(){ { char NOM[40]. Lors de la recherche dichotomique. on élimine la moitié des éléments du tableau à chaque exécution de la boucle.le pire des cas pour la recherche dichotomique peut entraîner 10 exécutions de la boucle. printf("Votre nom est composé de %d lettres.\n". Lors de la recherche dans un tableau de 1 048 576 éléments: . VAL.\n"). } /* Edition du résultat */ if (POS==-1) printf("La valeur recherchée ne se trouve pas " "dans le tableau.h> #include<string.\n".le pire des cas pour la recherche séquentielle peut entraîner 1024 exécutions de la boucle.. } Question: Quel est l'avantage de la recherche dichotomique? Dans le pire des cas d'une recherche séquentielle.PRENOM)))."). printf("Introduisez votre nom et votre prénom: \n"). NOM. getch(). Ainsi.le pire des cas pour la recherche dichotomique peut entraîner 20 exécutions de la boucle.. 60/76 . */ printf("Tapez une touche pour continuer. strlen(strcat(NOM. else printf("La valeur %d se trouve à la position %d. /* ou bien printf("Votre nom est composé de %d lettres. la recherche se termine beaucoup plus rapidement. . else if (VAL > A[MIL]) INF=MIL+1. getch(). Exercice n°5 #include<stdio. else POS=MIL. Exemple: Lors de la recherche dans un tableau de 1024 éléments: . PRENOM). strlen(NOM) + strlen(PRENOM)). POS). La recherche dichotomique devient extrêmement avantageuse pour la recherche dans de grands tableaux (triés) : L'avantage de la recherche dichotomique par rapport à la recherche séquentielle monte alors exponentiellement avec la grandeur du tableau à trier. NOM.

I++.TXT[I]). /* ou printf("%c". } 61/76 . /* c) Afficher la phrase à l'envers */ for (I=L-1. M2[30]. getch(). } Exercice n°7 #include<stdio. /* indices courants */ int L. scanf ("%s %s %s %s %s"..h> #include <conio.h> #include<conio. */ /* a) Compter les caractères */ /* La marque de fin de chaîne '\0' est */ /* utilisée comme condition d'arrêt.L). } puts(TXT).J. printf("Le texte est composé de %d caractères.J=L-1 .h> void main() { /* Déclarations */ char TXT[201]..TXT). I++) if (TXT[I]=='e') C++. M4. /* ou printf("\n"). /* L'utilisation de scanf est impossible pour */ /* lire une phrase contenant un nombre variable de mots. I>=0.. I<J . gets(TXT). /* pour l'échange des caractères */ /* Saisie des données */ printf("Entrez une ligne de texte (max."). TXT[I].\n".\n". /* b) Compter les lettres 'e' dans le texte */ C=0. /* ou printf("%s\n". printf("Tapez une touche pour continuer. M4. */ for (L=0. M1. I--) putchar(TXT[I])."). /* compteur des lettres 'e' */ int AIDE.M5. M2.. L++) . TXT[I]=TXT[J].C). M1). printf("%s %s %s %s %s\n". */ /* d) Inverser l'ordre des caractères */ for (I=0. getch(). TXT[J]=AIDE.} Exercice n°6 #include <stdio.J--) { AIDE=TXT[I]. for (I=0. /* longueur de la chaîne */ int C. M5). M4[30]. M5[30]. */ printf("Tapez une touche pour continuer. M3. M2. TXT[L]. printf("Le texte contient %d lettres 'e'. printf("Entrez 5 mots. séparés par des espaces :\n").200 caractères) :\n"). M3.h> void main() { char M1[30]. */ putchar('\n'). /* chaîne donnée */ int I. M3[30].

/* longueur de la chaîne */ /* Saisie des données */ printf("Verbe : ").J.h> #include<conio. strcat(AFFI. */ N=strlen(TXT). "je "). getch(). "e"). } I++. else { /* Couper la terminaison 'er'. . while(I<N) { if (TXT[I] != 'e'){ TXT[J] = TXT[I].!"). puts(AFFI). /* chaîne donnée */ int I.Exercice n°8 #include <stdio. /* chaîne contenant le verbe */ char AFFI[30]. /* Conjuguer . . . J++. if ((VERB[L-2]!='e') || (VERB[L-1]!='r')) puts("\aCe n'est pas un verbe du premier groupe. strcat(AFFI... printf("Tapez une touche pour continuer.").h> #include<string.N. } Exercice n°9 #include<stdio.. /* Eliminer les lettres 'e' et comprimer : */ /* Copier les caractères de I vers J et incrémenter J */ /* seulement pour les caractères différents de 'e'. /* chaîne pour l'affichage */ int L.. I=0.h> #include<conio. */ AFFI[0]='\0'.200 caractères) :\n"). VERB). /* Contrôler s'il s'agit d'un verbe en 'er' */ L=strlen(VERB). J=0. /* Edition du résultat */ puts(TXT).h> #include<string. gets(VERB). } /* Terminer la chaîne !! */ TXT[J]='\0'. */ VERB[L-2]='\0'.h> void main() { /* Déclarations */ char TXT[201]. /* indices courants */ /* Saisie des données */ printf("Entrez une ligne de texte (max. gets(TXT). 62/76 . strcat(AFFI.h> void main() { /* Déclarations */ char VERB[20].

VERB). "ils "). printf("Entrer un mot:").. /*initialisation*/ do{ i++. else if (RES>0) printf("\"%s\" précède \"%s\"\n". else printf("Le mot %s n'est pas palindrome \n". */ if(mot[i]==mot[n-i]) printf("Le mot %s est palindrome \n".mot). else printf("\"%s\" est égal à \"%s\"\n".CH1.i. if (RES<0) printf("\"%s\" précède \"%s\"\n".h> void main(){ /* Déclarations */ char mot[30]. } Exercice n°10 #include<stdio."). puts(AFFI). /*incrementation*/ }while((mot[i]!=mot[n-i]) || (i==(n/2))). strcat(AFFI. return 0. /* résultat de la fonction strcmp */ printf("Introduisez la première chaîne de caractères : "). n=strlen(mot)-1.h> #include<string. strcat(AFFI. "ent"). /* chaînes entrées */ int RES. int n. gets(CH2).h> void main() { /* Déclarations */ char CH1[200]. } /* //2ème solution i=-1. } printf("Tapez une touche pour continuer.h> #include<conio.mot).AFFI[0]='\0'. //1ere solution i=0. } Exercice n°11 #include<stdio. getch().mot). /* Comparaison et affichage du résultat */ RES = strcmp(CH1.CH2 . getch().CH2). CH2). while((mot[i]==mot[n-i]) && (i<=(n/2))){ i++. gets(CH1)."). printf("Introduisez la deuxième chaîne de caractères : ")... printf("Tapez une touche pour continuer.h> #include<conio.CH2). } 63/76 . CH2[200].. scanf("%s".CH1 .h> #include<string.CH1). strcat(AFFI.

La fonction retourne vrai si c'est le cas et faux sinon. Écrire le programme principale permettant de saisir deux chaînes et de faire appel à la fonction AJOUT_CH. ECONOMIQUES ET DE GESTION DE JENDOUBA Année Universitaire : 2009/2010 Module : Atelier de programmation I Semestre : 1 Classe : 1ère année LFIAG Enseignant : Riadh BOUSLIMI TP n°5 Objectifs de ce TP c'est l'utilisation des fonctions pour résoudre des problèmes. Exercice n°3 Écrire la fonction AJOUTE_CH à deux paramètres CH1 et CH2 qui copie la chaîne de caractères CH2 à la fin de la chaîne CH1 sans utiliser de variable d'aide. Écrire un programme se servant des fonctions MIN et MAX pour déterminer le minimum et le maximum de quatre nombres réels entrés au clavier. Comment déclarer une fonction et comment se fait l'appel de cette dernière? Exercice n°1 Écrire un programme se servant d'une fonction MOYENNE du type float pour afficher la moyenne arithmétique de deux nombres réels entrés au clavier. Exercice n°2 Écrire une fonction MIN et une fonction MAX qui déterminent le minimum et le maximum de deux nombres réels. 64/76 . Exercice n°4 Écrire la fonction IsPalindrome qui permet de vérifier si le nom en paramètre est palindrome ou non. Écrire le programme principale permettant de saisir un nom et de faire appel à la fonction IsPalindrome.REPUBLIQUE TUNISIENNE MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE SCIENTIFIQUES ET TECHNOLOGIQUES UNIVERSITE DE JENDOUBA FACULTE DES SCIENCES JURIDIQUES.

NB : Le programme doit comporter au minimum une fonction et deux procédures. 65/76 .Exercice n°5 Écrire un programme qui permet de remplir un tableau d’entiers de dimension N (tel que N≤50) et d’afficher les nombres impairs.

D.B.B)). printf("Le maximum des 4 réels est %f \n". MIN(C. A. } void main() { /* Variables locales */ double A. else return Y. } void main() { /* Variables locales */ float A.D)) ). printf("Le minimum des 4 réels est %f \n". double Y) { if (X<Y) return X. printf("La moyenne arithmétique de %f et %f est %f\n". getch(). } Exercice n°2 #include <stdio.B). &A.B).h> double MIN(double X. MAX( MAX(A. printf("Tapez une touche pour continuer…"). scanf("%lf %lf %lf %lf".h> #include<conio. double Y) { if (X>Y) return X. scanf("%f %f".Correction du TP n°5 Exercice n°1 #include<stdio. MIN( MIN(A.h> float MOYENNE(float X. /* Traitements */ printf("Introduire 4 réels : "). } 66/76 .h> #include<conio. /* Traitements */ printf("Introduire deux nombres : ").D)) ). getch().C. &D). B. &A. &B). &B. float Y) { return (X+Y)/2. else return Y.B. MAX(C. MOYENNE(A. &C. printf("Tapez une touche pour continuer…"). } double MAX(double X.

else return 1. printf("Entrer chaine n°1:"). nom). if(isPalindrome(nom)==0) printf("Le nom n'est pas palindrome"). CH1++. char Chaine2[30]. /* terminer la chaîne CH1 */ } void AJOUTE_CH1(char *CH1. /* Traitements */ printf("Introduire votre nom : ").h> #include<conio.Chaine1).i++) { CH1[i+n1]=CH2[i].h> #include<string. char *CH2) { int i. n1=strlen(CH1). printf("Tapez une touche pour continuer…"). printf("La nouvelle est chaine 1 est :%s".h> #include<conio. } if(LeNom[i]!= LeNom[n-i+1]) return 0. AJOUTE_CH(Chaine1. while((LeNom[i]!= LeNom[n-i+1]) && (i<=n/2)) { i++. CH2++. getch(). } void main() { /* Variable locale */ char nom[50].n2. } void main() { char Chaine1[30]. else printf("Le nom est palindrome"). char *CH2) { while (*CH1) /* chercher la fin de CH1 */ CH1++. } Exercice n°4 #include <stdio. gets(Chaine1). while (*CH2) /* copier CH2 à la fin de CH1 */ { *CH1 = *CH2.n. } *CH1='\0'.Chaine2).h> void AJOUTE_CH(char *CH1. n2=strlen(CH2).h> int isPalindrome(char LeNom[]) { int i. gets(Chaine2).h> Ou aussi #include<string. n = strlen(LeNom)-1. } 67/76 . i=0.Exercice n°3 #include<stdio.i<n2. scanf("%s". printf("Entrer chaine n°2:"). } CH1[n1+n2]='\0'.n1. for(i=0.

Remplissage(N. return Taille. do { printf("Taille du tableau (N<=50) =").. getch(). Affichage(N.&T).int *TAB) /* fonction remplissage du tableau */ { int i. }while(Taille<0 || Taille>50).T). } } void main() { int N. int TAB[]) { int i. scanf("%d".i++) { printf("Elément n° %d :". for(i=0.i<Taille. scanf("%d". for(i=0.i++) { if(TAB[i] % 2 !=0) printf("% d ".").Exercice n°5 #include<stdio.i<Taille. } void Remplissage(int Taille. int T[50]. N=TailleTableau().h> #include<conio.&Taille).&TAB[i]).h> int TailleTableau() /* fonction qui retourne la taille du tableau */ { int Taille. } } void Affichage(int Taille.i+1). } 68/76 .TAB[i]).. printf("Tapez une touche pour continuer.

pour extraire le jour.n). Economiques et de Gestion de Jendouba Classe 1ère année Licence Fondamentale en Informatique Appliquée à la Gestion Matière Atelier de programmation I Enseignant Riadh BOUSLIMI Session Principale (Janvier 2010) Durée 2 heures Documents Non autorisés EXAMEN Exercice n°1 (4 points) Écrire un programme qui permet de saisir deux chaines CH1 et CH2. printf("%d". n = atoi(texte) .Université de Jendouba Faculté des Sciences Juridiques. Exemple: CH1=être bon en algorithmique est équivalent à être bon en atelier de programmation. CH2=être bon Le nombre d’occurrences est : 2 Bonne Chance 69/76 .h) qui permet de convertir une chaine en entier. Exemple: Date1=19/12/2008 Date2=05/06/2009 Le nombre de jours de différence est : 168 jours NB : Les deux dates sont de types char de 10 caractères. /* affiche 12 si texte vaut "12" */ Exercice n°3 (9 points) Écrire un programme qui lit deux chaines CH1 et CH2.  int atoi(char *chaîne) convertit la chaîne en entier exemple: printf("ENTRER UN TEXTE: "). Exemple: CH1=TRAVAILLER PLUS CH2=GAGNER PLUS CH3=TRAVAILLER PLUSGAGNER PLUS Exercice n°2 (7 points) Écrire un programme qui permet de saisir deux chaines dates Date1 et Date2 de la forme JJ/MM/AA. de compter et d’afficher le nombre d’occurrences de CH2 dans CH1. de les concaténer ensembles et d’afficher la nouvelle chaine CH3 obtenue. On suppose que ces dernières sont deux dates valides et que Date1≤Date2. Déterminer et afficher le nombre de jours de différence entre ces deux dates. le mois et l’année vous devez employer la fonction prédéfinie atoi de la bibliothèque (stdlib. gets(texte).

h> void main(){ char ch1[30].break.gets(ch2).i++) ch3[i]=ch1[i].h> int GetNombreJoursDuMois(int Mois.break.break. } Exercice n°2 (4pts) #include<stdio. } 70/76 . char ch3[60].ch3). printf("\n La nouvelle chaine : %s \n".j.break. char ch2[30].. LongeurCh1=strlen(ch1).LongeurCh1.break.j++) ch3[j+i]=ch2[j]. printf("Chaine 1=").Correction d’examen session principale Module : Atelier de programmation I – 1LFIAG Enseignant : Riadh BOUSLIMI Exercice n°1 (4pts) #include<stdio.break.h> #include<stdlib. int i.break..LongeurCh2.i<LongeurCh1. getch(). case 2 : if ((Annee % 4) == 0) nbJours=29.break. case 5 : nbJours=31. } return nbJours. case 11 : nbJours=30.gets(ch1). //copie de la première chaine for(i=0. printf("Chaine 2="). //fin de la chaine ch3[j+i]='\0'. case 12 : nbJours=31. break.j<LongeurCh2. case 4 : nbJours=30. case 6 : nbJours=30.h> #include<conio. case 10 : nbJours=31."). printf("Tapez une touche pour continuer. case 9 : nbJours=30. case 7 : nbJours=31.int Annee){ int nbJours. else nbJours=28. case 3 : nbJours=31.break.break. case 8 : nbJours=31. //copie de la deuxième chaine for(j=0. LongeurCh2=strlen(ch2).h> #include<conio.break.h> #include<string. switch (Mois){ case 1 : nbJours=31.

} } else { //nb jours du mois suivant jusqu'à la fin de l'année de Date1 for(i=MM1+1. C1_MM[0]=Date1[3].NombreDeJours.i++) NombreDeJours=NombreDeJours+GetNombreJoursDuMois(i.MM2=atoi(C2_MM). } } //nb jours du mois de janvier jusqu'à le mois précédent de Date2 for(i=MM2-1.nbAnnee.MM1=atoi(C1_MM).i<=MM2-1.NombreDeJours).AAAA1)-JJ1.i++) NombreDeJours=NombreDeJours+GetNombreJoursDuMois(i.MM2.AAAA1).C1_AAAA[3]=Date1[9]. } 71/76 . printf("Tapez une touche pour continuer.C1_AAAA[1]=Date1[7]."). int i. C2_AAAA[0]=Date2[6].C2_AAAA[1]=Date2[7]..C2_AAAA[4]='\0'.AAAA1)-JJ1.C2_JJ[1]=Date2[1]. else { for(i=MM1+1. C2_MM[0]=Date2[3].C1_MM[2]='\0'.C2_MM[2]='\0'.i--) NombreDeJours=NombreDeJours+GetNombreJoursDuMois(i. NombreDeJours=NombreDeJours+JJ2+GetNombreJoursDuMois(MM1. //Extraction du Jour. nbAnnee=AAAA2-AAAA1.i++) NombreDeJours=NombreDeJours+GetNombreJoursDuMois(i.void main(){ char Date1[10].j<=AAAA2-1. } printf("\n Le nombre de jours de différences est %d \n".i>=1. C1_AAAA[0]=Date1[6]. C1_AAAA[2]=Date1[8].j++) { for(i=1.C1_MM[1]=Date1[4]. printf("Date2="). int JJ1. if (AAAA2==AAAA1) { if (MM1==MM2) NombreDeJours=JJ2-JJ1.C2_AAAA[5].i<=12. char Date2[10]. printf("Date1="). NombreDeJours=NombreDeJours+JJ2+GetNombreJoursDuMois(MM1.gets(Date1).MM1. //Conversion en entier JJ1=atoi(C1_JJ).j). getch().AAAA2).C1_AAAA[5].AAAA1). char C2_JJ[3]..C1_AAAA[4]='\0'.C1_JJ[2]='\0'. //nb jours du mois de différences entre AAAA+1 et AAAA2-1 if (nbAnnee!=1) { for(j=AAAA1+1.AAAA2=atoi(C2_AAAA).C1_MM[3]. du mois et de l'année de Date2 C2_JJ[0]=Date2[0].AAAA1.C2_JJ[2]='\0'.C1_JJ[1]=Date1[1].C2_MM[3].C2_MM[1]=Date2[4]. du mois et de l'année de Date1 C1_JJ[0]=Date1[0]. C2_AAAA[2]=Date2[8]. int JJ2.i<=12.AAAA2.AAAA1=atoi(C1_AAAA).gets(Date2).j. //Extraction du Jour. char C1_JJ[3]. NombreDeJours=0. JJ2=atoi(C2_JJ).C2_AAAA[3]=Date2[9].

} if (j==LongeurCh2) nbOcc++. getch().j.ch2. } printf("\n Le nombre d'occurrences de %s dans %s est : %d\n". int LongeurCh1. printf("Tapez une touche pour continuer…").h> #include<conio. } 72/76 . printf("Entrer ch2:"). char ch2[100]. while((ch1[i]!=ch2[j]) && (i<LongeurCh1)) i++.h> #include<string.nbOcc.gets(ch2). nbOcc=0. printf("Entrer ch1:"). LongeurCh2=strlen(ch2). int i.ch1.gets(ch1). i=0.LongeurCh2.h> void main(){ char ch1[100].Exercice n°3 (9pts) #include<stdio. while(i<LongeurCh1){ j=0. while((ch1[i]==ch2[j]) && (i<LongeurCh1) && (j<LongeurCh2)){ i++.nbOcc). j++. LongeurCh1=strlen(ch1).

Economiques et de Gestion de Jendouba Classe 1ère année Licence Fondamentale en Informatique Appliquée à la Gestion Matière Atelier de programmation I Enseignant Riadh BOUSLIMI Session Contrôle (Juin 2010) Durée 2 heures Documents Non autorisés EXAMEN Exercice n°1 (4 points) Écrire une fonction NbCarMajus qui permet de compter le nombre des lettres en majuscules. et d’afficher le résultat à l’écran. Exemple: CH1= "N5jrt23fe6K"  nb1 = 5236 CH2= "p3Y2"  nb2 = 32 La somme des deux nombres est : 5268 NB : vous devez employer la fonction prédéfinie atoi de la bibliothèque (stdlib. On suppose que les notes ont le même coefficient.h) qui permet de convertir une chaine en entier. dont la dimension du tableau est 5≤n≤30. d’effectuer la somme des deux nombres et enfin afficher le résultat à l’écran. Exemple: CH= "Faculte des Sciences Juridiques Economiques et de Gestion de Jendouba" N=5 Exercice n°2 (6 points) Écrire un programme qui permet de remplir un tableau contenant des notes (avec 0≤ note≤20). nb = atoi(ch) . /* nb=12 */ Bonne Chance 73/76 . d’extraire de ces dernières que les chiffres.5 0 1 2 3 4 T La moyenne est : 11. Ecrire le programme principal qui permet de saisir une chaine CH.Université de Jendouba Faculté des Sciences Juridiques.  int atoi(char *chaîne) convertit la chaîne en entier exemple: ch="12" .6 Exercice n°3 (10 points) Écrire un programme qui permet de saisir deux chaines CH1 et CH2.75 11.25 13.5 6. De calculer la moyenne et d’afficher le résultat à l’écran. Exemple: 14 12.

} void Remplissage(int *TAB. for(i=0.&taille). } 74/76 . }while((note<0) || (note>20)).i++) { do{ printf("Entre la note nّ %d:".i+1).int n) { int i. return taille. do{ printf("Entrer la taille du tableau:").h> int NbCarMajus(char ch[]) { int i. occ=0.n.Correction d’examen session contrôle Module : Atelier de programmation I – 1LFIAG Enseignant : Riadh BOUSLIMI Exercice n°1 (4pts) #include <stdio. printf("Taper une chaine:"). } Exercice n°2 (6pts) #include <stdio. for(i=0. printf("Le nombre des lettres majuscules : %d\n". getch(). scanf("%d".&note).i<n. scanf("%d". float som.int n) { int i.i<n.i++) som+=TAB[i]. } void main() { char ch[50]. return som/n. }while((taille<5) || (taille>30)).occ. printf("Pour sortir frapper une touche ").h> #include <conio.h> #include <string. TAB[i]=note.h> int TailleTab() { int taille.NbCarMajus(ch)).i++) { if((ch[i]>='A') && (ch[i]<='Z')) occ++. float note. /* initialisation du compteur des majuscules */ for(i=0. } } float calculer(int TAB[].h> #include <conio. n=strlen(ch). /* incrémentation du compteur */ } return occ.gets(ch).i<n.

som=somme(extraire(ch1).i++) /* parcours de la chaine */ { if(ch[i]>='0' && (ch[i]<='9')) { j++.h> <stdlib.j. /* Affectation de la taille du tableau */ Remplissage(&T.int nb2) { return nb1+nb2. printf("Entrer chaine ch1="). } void main() { char ch1[100]. /* Affichage de la somme */ printf("Pour sortir frapper une touche ").extraire(ch2)).h> <string. /* taille de la chaine */ j=-1. } 75/76 . nbr[j]=ch[i]. getch(). /* appel des deux fonctions */ printf("La somme est : %d\n".moy). /* Affichage de la moyenne */ printf("Pour sortir frapper une touche "). n=TailleTab(). } Exercice n°3 (10pts) #include #include #include #include <stdio.void main() { int n.gets(ch1). /* calcul et affectation de la moyenne */ printf("La moyenne est : %f\n". /* convertion du nombre en numérique */ } int somme(int nb1. getch(). char nbr[]. printf("Entrer chaine ch2="). float moy. /* remplissage du tableau */ moy=calculer(T. char ch2[100].i<n.n). int som. int n = strlen(ch). int T[100]. for(int i=0. /* ajout du nombre dans la nouvelle chaine nbr */ } } return atoi(nbr).h> int extraire(char ch[]) { int i.som).h> <conio.gets(ch2).n).

Avril 2002 Editions Dunod Peter Prinz et Ulla Kirch-Prinz C précis et concis .notions de programmation acquises par la pratique 2ème édition. 2004 Claude Delannoy Programmer en langage C . juin 2005 Editions O'Reilly 76/76 . 2ème édition.Initiation à la programmation Norme ANSI. Kernighan et Dennis M. Mars 2005 Editions Dunod Yves Mettier C en action. septembre 2004 Editions Dunod Brian W. Ritchie Le langage C .B ibliographie Achille Braquelaire Méthodologie de la programmation en C 2ème édition.Solutions et exemples pour les programmeurs en C 1 ère édition.Syntaxe et fondamentaux du langage C 4 ème édition.