Algorithmique Avancée et Programmation -

Corrigés des TP en C
Table des matières
Algorithmique Avancée et Programmation - Corrigés des TP en C............................................... 1
Série d'exercices n°1 .............................................................................................................................. 1
Exercice 2 ....................................................................................................................................... 1
Exercice 3 ....................................................................................................................................... 2
Exercice 4 ....................................................................................................................................... 3
Exercice 5 ....................................................................................................................................... 4
Exercice 6 ....................................................................................................................................... 5
Exercice 7 ....................................................................................................................................... 6
Exercice 8 ....................................................................................................................................... 7
Série d'exercices n°2 .............................................................................................................................. 8
Exercice 1 ....................................................................................................................................... 8
Exercice 2 ..................................................................................................................................... 12
Exercice 3 ..................................................................................................................................... 14
Exercice 4 ..................................................................................................................................... 18
Exercice 5 ..................................................................................................................................... 19
Série d'exercices n°3 ............................................................................................................................ 21
Exercice 1 ..................................................................................................................................... 21
Exercice 2 ..................................................................................................................................... 23
Exercice 3 ..................................................................................................................................... 24

Série d'exercices n°1

Exercice 2

#include <stdio.h>

int main() {

int a;

char p[20],n[20];
 printf("Quelle est ton année d'étude ?");

scanf("%d",&a);

printf("Quel est ton [prénom nom] ?");

scanf("%s %s",&p,&n);

printf("Bonjour\nJe suis en ING%d.\nJe m'appelle %s %s\nJe suis très content de faire du

C.\n",a,p,n);

Exercice 3

#include <stdio.h>

int main() {

int a1, a2, a3;

int max, min, mil; //max, min et le nombre du milieu

printf("Entrez le nombre 1 ");

scanf("%d", &a1);

printf("Entrez le nombre 2 ");

scanf("%d", &a2);

printf("Entrez le nombre 3 ");

scanf("%d", &a3);

/* on commence les comparaisons

on compare le 1er et le 2eme */

if (a1 > a2) {

max = a1;

mil = a2;

} else {

mil = a1;
 max = a2;

/* on compare le plus grand (entre le 1er et le 2eme) et a3 */

if (max > a3) /* on compare le milieu et a3 */ {

if (mil > a3) {

min = a3;

} else {

int perm;

perm = mil;

mil = a3;

min = perm;

} else {

min = mil;

mil = max;

max = a3;

printf("Les 3 nombres dans l'ordre croissant sont : %d %d %d", min, mil, max);

Exercice 4

#include <stdio.h>

#include <stdlib.h>

int main() {

float note, max=-5, min=21;

 float somme = 0.0;

int nbVal = 0;

printf("Donnez une note ");

scanf("%f", &note);

while (note != -1) {

if (note >= 0 && note <= 20) {

nbVal++;

if (note > max) {

max = note;

if (note < min) {

min = note;

somme = somme + note;

} else {

printf("La note saisie n'a pas été prise en compte (hors de [0;20])\n");

printf("Donnez une note ");

scanf("%f", &note); // placé à la fin de la boucle pour ne pas avoir à gérer -1 comme une note

printf("%d notes ont été entrées. La note la plus élevée (%f) et la note la plus basse (%f) ont été
retirées.\n", nbVal, max, min);

somme = somme - max - min;

printf("La moyenne olympique est : %f", (somme / (nbVal - 2)));

Exercice 5

#include <stdio.h>
#include <stdlib.h>

int main() {

int taille, ligne, colonne;

printf("Entrez la taille du motif ");

scanf("%d",&taille);

for (ligne = 1; ligne <= taille; ligne++) {

for (colonne = 1; colonne <= ligne; colonne++) {

printf("*");

printf("\n");

Exercice 6

#include <stdio.h>

#include <stdlib.h>

int main() {

int taille, ligne, colonne, espace;

printf("Entrez la taille du motif ");

scanf("%d",&taille);

for (ligne = 1; ligne <= taille; ligne++) {

for (espace = 1; espace <= taille - ligne; espace++) {

printf(" ");

for (colonne = 1; colonne <= 2*ligne-1; colonne++) {

printf("*");

}
 printf("\n");

Exercice 7

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

int main() {

int n, i, est_premier;

char nvNbre = 'O';

while (nvNbre=='O') {

printf("Entrez un entier ");

scanf("%d",&n);

est_premier = 1;

for (i = 2; i <= sqrt(n); i++) {

if ((n % i) == 0)

est_premier = 0;

printf("%d n'est pas premier, il est divisible par %d\n",n,i);

break;

}
 if (est_premier==1) {

printf("%d est premier\n",n);

printf("Voulez-vous essayer un autre nombre? (O/N) ");

fflush(stdin); // à utiliser avant de scanner un %c au clavier, sans quoi c'est le passage à la ligne
précédent qui sera lu

scanf("%c",&nvNbre);

Exercice 8

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

int main() {

// k! dépasse rapidement les limites mémoire, il ne faut donc pas calculer k!

double epsilon=1e-15, x;

printf("x=? ");

scanf("%lf",&x);

double sinx=x,ajout=x;

int nbpassages=1;

while (fabs(ajout)>=epsilon){

ajout=ajout*pow(x,2)/((2*nbpassages)*(2*nbpassages+1)); //on évite le calcul de nbpassages!

sinx=sinx+pow(-1,nbpassages)*ajout;

nbpassages++;

}
 printf("On trouve : sin(x)=%.17g\nLa bibliothèque : sin(x)=%.17g\n",sinx,sin(x));

Série d'exercices n°2

Exercice 1

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

void afficher(int tab[], int taille){

printf("Tableau : [ ");

for (int i = 0; i < taille; i++) {

printf("%d ",tab[i]);

printf("]\n");

void afficherPair(int tab[], int taille){

int i=0;

printf("Eléments pairs : [ ");

while (i < taille) {

if(tab[i]%2==0){

printf("%d ",tab[i]);

i++;

printf("]\n");
}

float calculerMoyenne(int tab[], int taille){

int i=0,s=0;

while (i < taille) {

s+=tab[i];

i++;

return (float)s/taille;

int trouverMin(int tab[], int taille){

int min=tab[0];

for (int i = 1; i < taille; i++) {

if (tab[i]<min){

min=tab[i];

return min;

// Effacement du tableau

void inverserTableau(int tab[], int taille){

int tmp;

for (int i = 0; i < taille/2; i++) {

tmp=tab[taille-i-1];

tab[taille-i-1]=tab[i];
 tab[i]=tmp;

// Solution la plus simple pour conserver une copie du tableau

void inverserCopieTableauV1(int tab[], int tab2[], int taille){

for (int i = 0; i < taille; i++) {

tab2[taille-i-1]=tab[i];

// Allocation dynamique de mémoire pour retourner un pointeur

int* inverserCopieTableauV2(int tab[], int taille){

int* tab2=malloc(taille*sizeof(int));

for (int i = 0; i < taille; i++) {

tab2[taille-i-1]=tab[i];

return tab2;

int main() {

srand(time(0)); // initialisation du générateur de rand suivant l'heure PC

int taille=10;

int tab[taille];

for (int i = 0; i < taille; i++) {

tab[i]=rand()%11;

}
afficher(tab,taille);

printf("\n");

afficherPair(tab,taille);

printf("\n");

float m=calculerMoyenne(tab,taille);

printf("Moyenne : %f\n",m);

printf("Minimum : %d\n", trouverMin(tab,taille));

int tabb[taille];

inverserCopieTableauV1(tab,tabb,taille);

printf("Inversion v1 - ");

afficher(tabb,taille);

printf("\n");

int* tabb2;

tabb2=inverserCopieTableauV2(tab,taille);

printf("Inversion v2 - ");

afficher(tabb2,taille);

printf("\n");

free(tabb2);

inverserTableau(tab,taille);

printf("Inversion bis - ");

afficher(tab,taille);
}

Exercice 2

#include <stdio.h>

#include <stdlib.h>

char* chiffreCesar(char phrase[], int taille){

char abc[]="abcdefghijklmnopqrstuvwxyz";

char abcdecale[]="defghijklmnopqrstuvwxyzabc";

char *codee;

codee = malloc(taille * sizeof(char));

for(int i=0;i<taille;i++){

for(int j=0;j<26;j++){

if (phrase[i]==abc[j]){

codee[i]=abcdecale[j];

break;

else

codee[i]=phrase[i];

return codee;

char* dechiffreCesar(char phrase[], int taille){

char abcdecale[]="abcdefghijklmnopqrstuvwxyz";

char abc[]="defghijklmnopqrstuvwxyzabc";

char *codee;
 codee = malloc(taille * sizeof(char));

for(int i=0;i<taille;i++){

for(int j=0;j<26;j++){

if (phrase[i]==abc[j]){

codee[i]=abcdecale[j];

break;

else

codee[i]=phrase[i];

return codee;

char* chiffreCesarBis(char* phrase, int deplacement){

int longabc=26, taille=strlen(phrase);

char *codee = (char*) malloc(taille * sizeof(char));

for(int i=0;i<taille;i++){

if (phrase[i]>='a' && phrase[i]<='z'){

codee[i]=(phrase[i]-'a'+deplacement)%longabc+'a'; // conversions ASCII

else

codee[i]=phrase[i];

return codee;

}
char* dechiffreCesarBis(char* phrase, int deplacement){

int longabc=26, taille=strlen(phrase);

char *codee = (char*) malloc(taille * sizeof(char));

for(int i=0;i<taille;i++){

if (phrase[i]>='a' && phrase[i]<='z'){

codee[i]=(longabc+phrase[i]-'a'-deplacement)%longabc+'a'; //ajout de longabc car le modulo

peut avoir des valeurs négatives

else

codee[i]=phrase[i];

return codee;

int main() {

char phrase[]="abc def, ghijkl. mnopqrs tuvwxyz!?";

int taille=sizeof(phrase)/sizeof(char); // strlen() fonctionnerait aussi

printf(chiffreCesar(phrase,taille));

printf("\n%s",dechiffreCesar(phrase,taille));

printf("\n%s",chiffreCesarBis(phrase,7));

printf("\n%s",dechiffreCesarBis(phrase,5));

Exercice 3

#include <stdio.h>

#include <stdlib.h>

#include <time.h>
void afficheMatrice(int** matrice, int taille1, int taille2){

for (int i = 0; i < taille1; i++) {

for (int j = 0; j < taille2; j++) {

printf("%d ",matrice[i][j]);

printf("\n");

void permutecolonnes(int** matrice, int taille1, int taille2, int colonne1, int colonne2){

int tmp;

for (int i = 0; i < taille1; i++) {

tmp=matrice[i][colonne2];

matrice[i][colonne2]=matrice[i][colonne1];

matrice[i][colonne1]=tmp;

int** transposition(int** matrice, int taille1, int taille2){

int **mat2; // la transposée aura taille1 colonnes et taille2 lignes

mat2 = malloc(taille2 * sizeof(int*));

for (int i = 0 ; i < taille2 ; i++){

mat2[i] = malloc(taille1 * sizeof(int));

for (int i = 0; i < taille1; i++) {

for (int j = 0; j < taille2; j++) {

 mat2[j][i]=matrice[i][j];

return mat2;

int main () {

srand(time(NULL));

int taille = 10,i;

int **mat;

mat = malloc(taille * sizeof(int*));//on attribue un emplacement mémoire pour un tableau de

pointeurs

for (i = 0 ; i < taille ; i++){

mat[i] = malloc(taille * sizeof(int));//on attribue l'emplacement pour chacun de ces pointeurs :

des emplacements pour des tableaux d'entiers

for (i = 0; i < taille; i++) {

for (int j = 0; j < taille; j++) {

mat[i][j]=0;

if (i==j){

mat[i][j]=1;

afficheMatrice(mat,taille,taille);

for (i = 0 ; i < taille ; i++){

 free(mat[i]);

free(mat);

int taille2;

printf("nombre de lignes ? ");

scanf("%d",&taille);

printf("nombre de colonnes ? ");

scanf("%d",&taille2);

int **mat2;

mat2 = malloc(taille * sizeof(int*));

for (i = 0 ; i < taille ; i++){

mat2[i] = malloc(taille2 * sizeof(int));//dans notre représentation, mat2[i] est une ligne, c'est un
tableau de taille2 entiers.

for (i = 0; i < taille; i++) {

for (int j = 0; j < taille2; j++) {

mat2[i][j]=rand()%10;

afficheMatrice(mat2,taille,taille2);

printf("Permutation\n");

permutecolonnes(mat2,taille,taille2,0,1);

afficheMatrice(mat2,taille,taille2);

printf("Transposition\n");

afficheMatrice( transposition(mat2,taille,taille2) ,taille2,taille);

for (i = 0 ; i < taille ; i++){

free(mat2[i]);
 }

free(mat2);

Exercice 4

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

int main() {

srand(time(NULL));

int tab[100];

int longueur = 0, longueurmax = 0, indicemax = 0;

for (int k = 0; k < sizeof(tab)/sizeof(int); k++) {

tab[k] = rand()%2;

if (tab[k] == 0) {

longueur++;

if (longueur > longueurmax) {

longueurmax = longueur;

indicemax = k;

} else longueur = 0;

printf("Tableau : [ ");

for (int i = 0; i < sizeof(tab)/sizeof(int); i++) {

printf("%d ",tab[i]);

}
 printf("]\n");

printf("Première plus longue suite de zéros de taille : %d pour l'indice de départ :

%d",longueurmax,(indicemax-longueurmax+1));

Exercice 5

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

int indiceMax(int tab[], int taille)

int indicemax=0;

for(int i=1; i < taille; i++)

if(tab[i] > tab[indicemax])

indicemax = i;

return indicemax;

void tritab(int tab[], int taille){

int tmp, ind;

for(int i=0;i<taille;i++){

ind=indiceMax(tab,taille-i); // position du max

tmp=tab[taille-i-1]; // on enregistre dernière valeur de la partie non triée

tab[taille-i-1]=tab[ind]; // on place le maximum en cette dernière position

tab[ind]=tmp; // on replace la valeur enregistrée dans l'ancienne position du max

}
}

int main() {

srand(time(NULL));

int taille=11;

int de1, de2, i;

int frequence[taille];

for (i=0; i<taille ; i++){

frequence[i]=0;

for (i = 0; i < 36000; i++) {

de1 = rand()%6 + 1;

de2 = rand()%6 + 1;

frequence[de1 + de2 - 2]++; //quand somme des dés = 2 incrémente en position 0, somme = 3
incrémente en position 1...

for (i = 0; i < taille; i++) {

printf("%d tirages de %d soit %f %%\n",frequence[i],i+2,(float) frequence[i] / 360);

int tabtmp[taille];

for (i=0;i<taille;i++){

tabtmp[i]=frequence[i];

tritab(frequence, taille); // frequence est trié, tabtmp est une copie non triée de frequence

printf("\nDans l'ordre des plus souvent tirés :\n");

for (i = taille - 1; i >= 0; i--) { // affichage décroissant

 for (int j = 0; j< taille; j++){

if(tabtmp[j]==frequence[i]){

printf("Tirages de %d : %f %%\n",j+2,(float) tabtmp[j] / 360);

Série d'exercices n°3

Exercice 1

#include <stdio.h>

#include <stdlib.h>

struct complexe {

float reel;

float imag;

};

struct complexe scanfComplexe() {

struct complexe result;

printf("entrez votre nombre complexe (sous la forme a+bi) : ");

scanf("%f+%fi",&result.reel,&result.imag);

return result;

}
void printfComplexe(struct complexe nbc) {

printf("%f + %f i",nbc.reel,nbc.imag);

struct complexe sommeComplexe(struct complexe nbc1,struct complexe nbc2) {

struct complexe result;

result.reel=nbc1.reel+nbc2.reel;

result.imag=nbc1.imag+nbc2.imag;

return result;

struct complexe produitComplexe(struct complexe nbc1,struct complexe nbc2) {

struct complexe result;

result.reel=nbc1.reel*nbc2.reel-nbc1.imag*nbc2.imag;

result.imag=nbc1.imag*nbc2.reel+nbc1.reel*nbc2.imag;

return result;

int main() {

struct complexe nbcomp1;

struct complexe nbcomp2;

nbcomp1=scanfComplexe();

nbcomp2=scanfComplexe();

printf("Somme : ");

printfComplexe(sommeComplexe(nbcomp1,nbcomp2));

printf("\nProduit : ");
 printfComplexe(produitComplexe(nbcomp1,nbcomp2));

Exercice 2

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

double carre(double x) {

return x*x;

double integrale(double (*f)(double), double min, double max, double pas) {

double x, integ;

for(x=min;x<=max;x+=pas){

integ+=((*f)(x)+(*f)(x+pas))*pas/2;

return integ;

int main() {

double (*f)(double)=sin;

printf("intégrale sinus entre 0.5 et 1 : %f\n", integrale(f, 0.5, 1, 0.001));

printf("vérification théorique : cos(0.5)-cos(1) = %f\n", cos(0.5)-cos(1));

f=carre;

printf("intégrale x->x^2 entre 0 et 10 : %f\n", integrale(f, 0, 10, 0.001));

printf("vérification théorique : 10^3/3 = %f\n", pow(10,3)/3);

}

Exercice 3

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

void creation() {

FILE* fichier = NULL;

char nomeleve[20];

char prenomeleve[20];

char nomfichier[20];

printf("Nom de fichier ?\n");

scanf("%s", &nomfichier);

fichier = fopen(nomfichier, "w");

while (1) {

printf("Ajoutez un eleve au format Nom Prenom (-1 -1 pour arreter) : ");

scanf("%s %s", &nomeleve, &prenomeleve);

if (strcmp(nomeleve, "-1") == 0 || strcmp(prenomeleve, "-1") == 0) break;

fprintf(fichier, "%s %s\r\nNotes : \r\n", nomeleve, prenomeleve); // \r : sous Windows, il faut

faire \r en plus de \n pour passer à la ligne dans un fichier

fclose(fichier);

}
void recopiefichier(FILE* fichier1, FILE* fichier2) {//copie fichier1 (à partir de la position courante)
dans fichier2 (à partir de la position courante)

int nbcopies = 0;

char car;

while (1) {

car = fgetc(fichier1);

nbcopies++;

if (car == EOF) break;

fprintf(fichier2, "%c", car);

fseek(fichier1, -nbcopies, SEEK_CUR); // on retourne à l'endroit où on a commencé à copier

fseek(fichier2, -nbcopies + 1, SEEK_CUR); // on retourne à l'endroit où la recopie commence

void remplissage() {

FILE* fichier = NULL;

FILE* fichiercopie = NULL;

char nomeleve[20];

char prenomeleve[20];

int note;

char nomfichier[20];

printf("Nom de fichier ?\n");

scanf("%s", &nomfichier);

fichier = fopen(nomfichier, "r+");

if (fichier == NULL) {

printf("Fichier inexistant\n");
 return; // sortie de la fonction

while (fscanf(fichier, "%s %s", nomeleve, prenomeleve) == 2) {

while (fgetc(fichier) != '\n'); // on passe le premier passage à la ligne

while (fgetc(fichier) != '\n'); // on passe "Notes : " et les notes éventuellement déjà rentrées

fseek(fichier, -1, SEEK_CUR); // on remonte le "\n" pour se placer à la fin de la ligne des notes

// on a besoin de sauvegarder la suite du fichier dans un fichier temporaire

fichiercopie = fopen("fichiertmp.txt", "w+");

recopiefichier(fichier, fichiercopie);

// ajout des notes (**remplace** le texte qui se trouve ensuite)

printf("Ajoutez les notes de %s %s (-1 pour arreter) : ", prenomeleve, nomeleve);

while (1) {

scanf("%d", &note);

if (note == -1) break;

fprintf(fichier, "%d ", note);

fprintf(fichier, "\r\n");

// récupération de la sauvegarde

recopiefichier(fichiercopie, fichier);

fclose(fichier);

fclose(fichiercopie);
 remove("fichiertmp.txt");

void affichage() {

FILE* fichier = NULL;

char nomeleve[20] ;

char prenomeleve[20] ;

char nomlu[20] ;

char prenomlu[20] ;

char* notes;

int flag = 0;

char nomfichier[20];

printf("Nom de fichier ?\n");

scanf("%s", &nomfichier);

fichier = fopen(nomfichier, "r");

if (fichier == NULL) {

printf("Fichier inexistant\n");

return; // sortie de la fonction

printf("Nom de l'eleve ? (Format : Nom Prenom) ");

scanf("%s %s", nomeleve, prenomeleve);

while (fscanf(fichier, "%s %s", nomlu, prenomlu) == 2) {

if (strcmp(nomeleve, nomlu) == 0 && strcmp(prenomeleve, prenomlu) == 0) {

fseek(fichier, 2, SEEK_CUR);

printf("%s", fgets(notes, 1000, fichier)); //lit et affiche la ligne

 flag = 1;

break;

if (flag == 0) {

printf("L'élève n'est pas dans la liste\n");

fclose(fichier);

void moyenne() {

FILE* fichier = NULL;

char nomlu[20] = "";

char prenomlu[20] = "";

int moy, note, nbnotes = 0;

char nomfichier[20];

printf("Nom de fichier ?\n");

scanf("%s", &nomfichier);

fichier = fopen(nomfichier, "r");

if (fichier == NULL) {

printf("Fichier inexistant\n");

return; // sortie de la fonction

while (fscanf(fichier, "%s %s", nomlu, prenomlu) == 2) {

printf("Moyenne de %s %s : ", prenomlu, nomlu);

 moy = 0;

nbnotes = 0;

while (fgetc(fichier) != ':');

fgetc(fichier); //on arrive au début de la liste de notes

while (fscanf(fichier, "%d", &note) == 1) {

moy = moy + note;

nbnotes++;

printf("%f\n", (float) moy / nbnotes);

fclose(fichier);

int main() {

int choixmenu = 1;

while (choixmenu != 0) {

printf("Menu :\n1 - Creation fichier\n2 - Ajout de notes\n3 - Affichage de notes\n4 - Affichage

des moyennes\n0 - Quitter\n");

scanf("%d", &choixmenu);

switch (choixmenu) {

case 0:

break;

case 1: creation();

break;

case 2: remplissage();
 break;

case 3: affichage();

break;

case 4: moyenne();

break;

default: printf("Erreur de saisie\n");

break;