Année 2008-2009

1ère année PET

Durée : 2h

Examen de programmation et algorithmes

Tous documents interdits, calculatrice interdite

Remarques
• Les questions sont indépendantes dans une large mesure. Vous pouvez utiliser les fonctions écrites dans les questions
précédentes sans les réécrire.
• Si une question vous semble pouvoir être interprétée de plusieurs manières, indiquez celle que vous avez choisie.
• Toutes les fonctions et programmes doivent être rédigés en langage C.

Question 1 1 point
Ecrire un programme qui affiche à l’écran la moyenne de 3 réels double précision qui seront lus au clavier

Question 2 1 point
Ecrire la fonction : double moyenne(double tab[], int nb, int debut, int fin) qui
retourne la moyenne des éléments dont les indices sont compris entre debut et fin. Le tableau tab est un
tableau contenant nb réels double précision.

Question 3 2 points
Ecrire la fonction : void lecture(char* fic, double tab[], int nb) qui lit les nb
éléments du tableau tab de réels double précision dans le fichier texte dont le nom est fic. Le fichier fic
contient les nb réels les uns à la suite des autres. Par exemple, un fichier de 3 éléments aura l’allure
suivante :
3.8 2.9 5.2

Question 4 1 point
En utilisant les 2 fonctions précédentes et en supposant que la fonction void affiche(double
tab[], int nb) qui affiche un tableau existe, écrire un programme qui réalise les actions suivantes :
1. Lecture au clavier du nombre d’éléments contenu dans le fichier
2. Lecture du tableau dans le fichier "donnees.txt"
3. Affichage de ce tableau
4. Calcul puis affichage de la moyenne des éléments de ce tableau

Question 5 1 point
Ecrire la fonction qui échange deux réels double précision.

Question 6 1 point
En utilisant la fonction de la question 5, écrire un programme qui :
1. lit deux réels au clavier
2. affiche ces deux réels
3. échange les deux réels
4. affiche à nouveau ces deux réels

Question 7 1 point
En utilisant la fonction de la question 5, écrire la fonction qui effectue une permutation circulaire de trois
réels double précision.

Question 8 1 point
Ecrire la fonction int indiceval(double val, double tab[], int nb) qui recherche la
valeur val dans le tableau tab de nb réels double précision. Cette fonction retourne l’indice du premier
élément du tableau égal à val, ou –1 si cette valeur n’existe pas dans le tableau.

- 1/5-
Question 9 1 point
Ecrire la fonction double* adresseval(double val, double tab[], int nb) qui
recherche la valeur val dans le tableau tab de nb réels double précision. Cette fonction retourne l’adresse
du premier élément du tableau égal à val, ou NULL si cette valeur n’existe pas dans le tableau.

Question 10 1 point
Ecrire la fonction double* creation(int nb) qui alloue dynamiquement un tableau de nb réels
double précision. Toutes les valeurs du tableau seront mises à –1. Cette fonction retourne l’adresse du
tableau créé ou NULL en cas d’échec d’allocation.

Question 11 1 point
En utilisant la fonction de la question 5, écrire la fonction void echangetab(double tab1[],
double tab2[], int nb) qui échange les nb valeurs des tableaux tab1 et tab2 de réels.
ATTENTION : vous utiliserez ici des pointeurs pour parcourir les tableaux. Vous ne devez pas utiliser
d’indices entiers dans cette fonction.

Question 12 2 points
En utilisant les fonctions précédentes, écrire un programme qui réalise les actions suivantes :
1. Lecture du nombre d’éléments au clavier
2. Création dynamique de 2 tableaux t1 et t2 dont la taille vient d’être lue au clavier.
3. Lecture du tableau t1 dans le fichier "donnees1.txt"
4. Lecture du tableau t2 dans le fichier "donnees2.txt"
5. Echange des valeurs des tableaux t1 et t2
6. Recherche de l’adresse du premier élément nul de t1
7. Remplacer cet élément par la moyenne du tableau t2

Question 13 2 points
Il y a 4 erreurs dans ce programme. Indiquez quelles sont les lignes qui sont incorrectes et pourquoi.
(1) #include <stdio.h>
(2) #include <stdlib.h>
(3) main() { int i;
(4) int* p=NULL;
(5) int t1[20], t2[20], t3[20], t4[];

(7) for(i=0; i<20; i++) t1[i]=i;

(8) for(i=0; i<20; i++) p[i]=i*i;
(9) t3 = t2;
(10) if (t2 == t1)
(11) printf("les valeurs des tableaux sont identiques");
(12) else
(13) printf("les valeurs des tableaux sont differents");
(14) p = t2;
(15) for (p=t2; p<t2+20; p++) printf("%d ",*p);
(16) }

Question 14 2 points
Ecrire un programme qui calcule Pi comme la limite de la somme de la série :
π 1 1 1 1 1
= 1 − + − + − + ...
4 3 5 7 9 11

Question 15 4 points
Le principe du tri bulle consiste à comparer les valeurs adjacentes d'un tableau et à les échanger si le
premier des deux éléments est supérieur au second.
L'algorithme se déroule ainsi : les deux premiers éléments du tableau sont comparés et ils sont échangés
si le premier élément est supérieur au second. Ensuite, on compare le 2ième et le 3ième et ils sont échangés si le
2ième est supérieur au 3ième, puis comparer le 3ième et le 4ième, etc. jusqu’à comparer le n-1ième et nième inclus.

- 2/5-
 Une fois cette étape achevée, il est certain que le dernier élément du tableau est le plus grand. Il suffit
donc de recommencer la même chose en s’arrêtant au n-1ième et les deux derniers éléments du tableau seront
triés : l'algorithme reprend donc pour classer les (n-1) éléments qui restent, puis pour classer les n-2 restants,
… jusqu’à ce qu’il ne reste plus d’éléments à trier.
Ecrire la fonction void tritab(double tab[], int nb) qui trie le tableau tab de nb réels en
utilisant l’algorithme précédent.

- 3/5-
 Résumé de la syntaxe du langage C
Structure d’un programme
int main() {
déclaration des variables ;
instructions ;
}

Déclaration des variables : type_de_variable nom_de_variables ;

Exemples : int i ; double x ; char c ; char s1[256] ; int* p1 ; double* p2 ;

Entrées : scanf("%d ",&i) ; scanf("%lf", &x) ; scanf("%c", &c) ; scanf("%s", s1) ;

Sorties: printf("%d ",i) ; printf("%lf", x) ; printf("%c", c) ; printf("%s", s1) ;

Boucle POUR:
for (<initialisation>; <test_continuation>; <incrementation>) {
<instructions_a_repeter> ;
}
Exemple : for (i=0 ; i< 100 ; i++) { t1[i] = 2*i ; }

Boucle TANTQUE:
<initialisation>
while (<test_continuation>) {
<instructions_a_repeter> ;
<incrementation> ;
}
Exemple : while ( i< 100 ) { t1[i] = 2*i ; i= i+1 ;}

Boucle FAIRE..TANTQUE:
<initialisation>
do {
<instructions_a_repeter> ;
<incrementation> ;
} while (<test_continuation>) ;
Exemple : do { t1[i] = 2*i ; i= i+1 ;} while ( i< 100 ) ;

Instruction condionnelle if : if (test) { instructions_si_test_est_vrai ; } else { instructions_si_test_est_faux; }

Exemple : if (a !=0) { c = b/a ; } else { printf("La division est interdite\n") ; }

Fonctions : déclaration
type_retourné nom_de_la_fonction(declaration des parametres de la fonction) {
Declaration des variables ;
Instructions de la fonction ;
}
Exemple :
double max( double a, double b) { double c ;
if (a>b) c =a ;
else c=b ;
return c ;
}

Tableau 1D: déclaration : type_des_elements nom_du_tableau[Nombre d’element] ;

Exemple : int t1[100] ; double x1[256] ;
Le nom du tableau est son adresse
L’adresse d’un élément du tableau s’écrit &t[i] ou t+i

Tableau 2D: déclaration : type_des_elements nom_du_tableau[Nombre_d’element][Nombre d’element] ;

Exemple : int t2d[100] [20]; double x2d[256] [3];

- 4/5-
Déclaration d’un type structure : struct nom_de_la_structure { déclarations des champs ; } ;
Déclaration d’une variable de type structuré: struct nom_de_la_structure nom_de_la_variable;
Exemple : struct complex { double reel ; double imaginaire ; } ; /* Un type complexe*/
struct complex x ; /* x est une variable de type complexe */

Déclaration d’un nouveau type : typedef ancien_type nouveau_type ;

Exemple : typedef struct complex MesComplexes ;

Fichiers :
Declaration d’une variable : FILE* nom_de_variable ;
Ouverture :
FILE* fopen(char* nom_du_fichier_a_ouvrir, char* mode_d’ouverture) ;

Lecture fichier texte :

int fscanf(FILE* variable_fichier, char* format des données a lire, adresses des données) ;

Ecriture fichier texte :

int fprintf(FILE* variable_fichier, char* format des variables a ecrire , variables_a_ecrire) ;

Lecture fichier binaire :

int fread(void* adresse_donnes, int taille_d’un_element, int nombre_d’element, FILE* variable_fichier_dans
lequel on lit) ;

Ecriture fichier binaire :

int fwrite(void* adresse_donnes, int taille_d’un_element, int nombre_d’element, FILE*
variable_fichier_dans lequel on ecrit) ;

Allocation dynamique
Allocation d’un espace :
void* calloc(int nombre_d’element_a_allouer, int taille_d’un_element) ;

Libération mémoire :
void free(void* adresse_de_la_zone_a_allouer) ;

- 5/5-