RECUEIL D'EXERCICES CORRIGÉS DE PROGRAMMES EN LANGAGE C

Leila Zemmouchi-Ghomari

► To cite this version:

Leila Zemmouchi-Ghomari. RECUEIL D'EXERCICES CORRIGÉS DE PROGRAMMES EN LANGAGE C. Licence. Recueil d'exercices corrigés de programmes en langage C, Algérie. 2021, pp.50. hal-04577481

HAL Id: hal-04577481

https://hal.science/hal-04577481

Submitted on 16 May 2024

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons Attribution 4.0 International License
RECUEIL D'EXERCICES CORRIGÉS DE PROGRAMMES EN LANGAGE C

Leila Zemmouchi-Ghomari

► To cite this version:

Leila Zemmouchi-Ghomari. RECUEIL D'EXERCICES CORRIGÉS DE PROGRAMMES EN LANGAGE C. Licence. Recueil d'exercices corrigés de programmes en langage C, Algérie. 2021, pp.50. hal-04577481

HAL Id: hal-04577481

https://hal.science/hal-04577481v1

Submitted on 16 May 2024

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons Attribution 4.0 International License
<figure><img src="image_2.png" /></figure>

RECUEIL D'EXERCICES
CORRIGÉS DE PROGRAMMES
EN LANGAGE C

Par Dr. Leila Zemmouchi-Ghomari, GIM, ENST

Janvier 2021
<figure><img src="image_2.png" /></figure>

RECUEIL D'EXERCICES
CORRIGÉS DE PROGRAMMES
EN LANGAGE C

Par Dr. Leila Zemmouchi-Ghomari, GIM, ENST

Janvier 2021
Résumé

Ce recueil de programmes en langage C inclut des exercices qui couvrent l'essentiel des volets
à maîtriser dans un langage de programmation, à savoir : les opérations de base (lecture, écriture
et affectation), les structures conditionnelles, les structures itératives, les structures statiques
(tableaux et matrices), les fonctions, la récursivité, les structures dynamiques ou à pointeurs (les
listes chainées), les enregistrements et les fichiers.

Le contenu de ce recueil est conforme au programme de première année des filières relatives
au domaine ST, Sciences et Technologies et des premières années classe préparatoire des
grandes Ecoles spécialisées en Technologie.

La totalité des programmes contenues dans ce recueil ont été testés et sont bien commentés.

Mots-clés :

Programmation, langage C, exercices corrigés
Résumé

Ce recueil de programmes en langage C inclut des exercices qui couvrent l'essentiel des volets
à maîtriser dans un langage de programmation, à savoir : les opérations de base (lecture, écriture
et affectation), les structures conditionnelles, les structures itératives, les structures statiques
(tableaux et matrices), les fonctions, la récursivité, les structures dynamiques ou à pointeurs (les
listes chainées), les enregistrements et les fichiers.

Le contenu de ce recueil est conforme au programme de première année des filières relatives
au domaine ST, Sciences et Technologies et des premières années classe préparatoire des
grandes Ecoles spécialisées en Technologie.

La totalité des programmes contenues dans ce recueil ont été testés et sont bien commentés.

Mots-clés :

Programmation, langage C, exercices corrigés
# Introduction

Le langage C, est un langage de programmation à la base de nombreux autres langages tels que C++, C# et Java. Les étudiants qui maîtrisent ce langage n'auront aucun mal à se familiariser avec les syntaxes des autres langages de programmation.

Le langage C permet également de manipuler des pointeurs, des variables qui stockent des adresses mémoire. De ce fait, il est possible de créer et de manipuler des structures dynamiques telles que les listes, les files et les piles.

Il offre également la possibilité de créer et de manipuler des structures permanentes de données, à savoir, les fichiers.

Ce document propose des exercices qui couvrent l'essentiel des volets à maîtriser dans un langage de programmation, à savoir : les opérations de base (lecture, écriture et affectation), les structures conditionnelles, les structures itératives, les structures statiques (tableaux et matrices), les fonctions, la récursivité, les enregistrements et les fichiers.

Le contenu de ce recueil est conforme au programme de première année des filières relatives au domaine ST, Sciences et Technologies et des premières années classe préparatoire des grandes Ecoles spécialisées en Technologie.

La totalité des exercices contenues dans ce recueil sont corrigés et bien documentés.

Nous rappelons, ici, **les objectifs** visés par la matière INF2, à savoir :

* Être capable de traduire un algorithme en programme exécutable par une machine

* Maîtriser un langage de programmation, en l'occurrence, le langage C

Enfin, voici **deux éditeurs** pour la saisie, la compilation et l'exécution des programmes en C:

* **DevC++** : https://sourceforge.net/projects/orwelldevcpp/files/latest/download

* **CodeBlocks** : http://www.codeblocks.org/downloads

**Prérequis** : Des connaissances en algorithmique faciliteraient grandement la résolution des exercices de ce recueil.

**Avertissement** : la révision du cours est nécessaire avant de tenter de résoudre les exercices qui suivent.
## Introduction

Le langage C, est un langage de programmation à la base de nombreux autres langages tels que C++, C# et Java. Les étudiants qui maîtrisent ce langage n'auront aucun mal à se familiariser avec les syntaxes des autres langages de programmation.

Le langage C permet également de manipuler des pointeurs, des variables qui stockent des adresses mémoire. De ce fait, il est possible de créer et de manipuler des structures dynamiques telles que les listes, les files et les piles.

Il offre également la possibilité de créer et de manipuler des structures permanentes de données, à savoir, les fichiers.

Ce document propose des exercices qui couvrent l'essentiel des volets à maîtriser dans un langage de programmation, à savoir : les opérations de base (lecture, écriture et affectation), les structures conditionnelles, les structures itératives, les structures statiques (tableaux et matrices), les fonctions, la récursivité, les enregistrements et les fichiers.

Le contenu de ce recueil est conforme au programme de première année des filières relatives au domaine ST, Sciences et Technologies et des premières années classe préparatoire des grandes Ecoles spécialisées en Technologie.

La totalité des exercices contenues dans ce recueil sont corrigés et bien documentés.

Nous rappelons, ici, les **objectifs** visés par la matière INF2, à savoir :

* Être capable de traduire un algorithme en programme exécutable par une machine

* Maîtriser un langage de programmation, en l'occurrence, le langage C

Enfin, voici **deux éditeurs** pour la saisie, la compilation et l'exécution des programmes en C:

* **DevC++** : https://sourceforge.net/projects/orwelldevcpp/files/latest/download

* **CodeBlocks** : http://www.codeblocks.org/downloads

**Prérequis** : Des connaissances en algorithmique faciliteraient grandement la résolution des exercices de ce recueil.

**Avertissement** : la révision du cours est nécessaire avant de tenter de résoudre les exercices qui suivent.
## Table des matières

<table><tr><td>1. Opérations de base – Structures Conditionnelles ou de contrôle– Structures Itératives</td><td>1</td></tr><tr><td>2. Tableaux et Matrices</td><td>9</td></tr><tr><td>3. Fonctions et récursivité</td><td>19</td></tr><tr><td>4. Enregistrements ou structures de données</td><td>27</td></tr><tr><td>5. Listes Chainées</td><td>35</td></tr><tr><td>6. Fichiers</td><td>42</td></tr></table>
## Table des matières

<table><tr><td>1. Opérations de base – Structures Conditionnelles ou de contrôle– Structures Itératives</td><td>1</td></tr><tr><td>2. Tableaux et Matrices</td><td>9</td></tr><tr><td>3. Fonctions et récursivité</td><td>19</td></tr><tr><td>4. Enregistrements ou structures de données</td><td>27</td></tr><tr><td>5. Listes Chainées</td><td>35</td></tr><tr><td>6. Fichiers</td><td>42</td></tr></table>
# Opérations de base
Structures Conditionnelles
Structures Itératives

## Rappel de quelques notions du cours:

```c
#include <stdio.h>
main()
{
    //fonction principale
    int i; float x; char ch; char chaine[20]; //déclaration des variables
    printf("Donnez la valeur de i :"); scanf("%d",&i); //écriture et lecture d'un entier
    printf("Donnez la valeur de x :"); scanf("%f",&x); // écriture et lecture d'un réel
    printf("Donnez la valeur de ch :"); scanf("%c",&ch); //écriture et lecture d'un caractère
    printf("Donnez la valeur de chaine :"); scanf("%s",chaine); } // écriture et lecture d'une chaine de
    caractères
```

```c
if (N%2==0) {
    // si N est divisible par 0 alors
    printf("N est pair\n"); }
else {
    // sinon
    printf("N est impair\n"); }
```

```c
for (init ; cond ; evol) {
    //valeur initiale; condition; pas ou évolution
    <séquence d'instructions;>
}

while ( <expression logique>) {
    séquence d'instructions;
}
do {
    <séquence d'instructions;>
} While ( <expression logique>);
```
# Opérations de base
Structures Conditionnelles
Structures Itératives

## Rappel de quelques notions du cours:

```c
#include <stdio.h>
main()
{
    //fonction principale
    int i; float x; char ch; char chaine[20]; //déclaration des variables
    printf("Donnez la valeur de i :"); scanf("%d",&i); //écriture et lecture d'un entier
    printf("Donnez la valeur de x :"); scanf("%f",&x); // écriture et lecture d'un réel
    printf("Donnez la valeur de ch :"); scanf("%c",&ch); //écriture et lecture d'un caractère
    printf("Donnez la valeur de chaine :"); scanf("%s",chaine); } // écriture et lecture d'une chaine de
    caractères
```

```c
if (N%2==0) {
    // si N est divisible par 0 alors
    printf("N est pair\n"); }
else {
    // sinon
    printf("N est impair\n"); }
```

```c
for (init ; cond ; evol) {
    //valeur initiale; condition; pas ou évolution
    <séquence d'instructions;>
}

while ( <expression logique>) {
    séquence d'instructions;
}
do {
    <séquence d'instructions;>
} While ( <expression logique>);
```
## Exercice 1

Qu'affiche le programme suivant ? Exécuter le programme pour vérifier vos réponses.

```c
#include <stdio.h>
#include <windows.h>
int main()
{
    int i=3, y, z, b, c; float x;

    y= 3*i +27; printf("la valeur de y est : %d \n ", y); /* commentaire*/
    z= 3*(i+27); printf("la valeur de z est : %d \n", z);

    b= (10>5) || (-1>=-2) && (4<3) ; printf("la valeur de b est : %d \n", b);
    c= ((10>5)||(-1>=-2)) && (4<3) ; printf("la valeur de c est : %d \n", c);

    y=++i*4 ; printf("La pr%c-incr%c cmentation donne y=%d et i=%d \n", 130, 130, y, i);
    i=3 ; y=i++ *4 ; printf("La post-incr%c cmentation donne y=%d et i=%d \n", 130, y, i);

    x=i/z ; printf("La valeur de x est :%f \n", x);
    x=(float) i/z ; printf("La valeur de x est :%f \n", x);
    system("color 1F"); //couleur de fonds : bleu foncé, Couleur de police: blanc
    return 0 ; }
```

### Solution

<figure><img src="image_3.png" /></figure>

## Exercice 2

Ecrire un programme pour résoudre chacun des problèmes suivants :

a) Calculer le minimum de trois nombres réels donnés par l'utilisateur.

b) Ordonner trois nombres entiers donnés par l'utilisateur.

### Solution

a) Calculer le minimum de trois nombres réels donnés par l'utilisateur.

```c
#include <stdio.h>
#include <stdlib.h>
main ()
{
    float a,b,c;
    printf("donner les trois valeurs");
```
## Exercice 1

Qu'affiche le programme suivant ? Exécuter le programme pour vérifier vos réponses.

```c
#include <stdio.h>
#include <windows.h>
int main()
{
    int i=3, y, z, b, c; float x;

    y= 3*i +27; printf("la valeur de y est : %d \n ", y); /* commentaire*/
    z= 3*(i+27); printf("la valeur de z est : %d \n", z);

    b= (10>5) || (-1>=-2) && (4<3) ; printf("la valeur de b est : %d \n", b);
    c= ((10>5)||(-1>=-2)) && (4<3) ; printf("la valeur de c est : %d \n", c);

    y=++i*4 ; printf("La pr%c-incr%c cmentation donne y=%d et i=%d \n", 130, 130, y, i);
    i=3 ; y=i++ *4 ; printf("La post-incr%c cmentation donne y=%d et i=%d \n", 130, y, i);

    x=i/z ; printf("La valeur de x est :%f \n", x) ;
    x=(float) i/z ; printf("La valeur de x est :%f \n", x) ;
    system("color 1F"); //couleur de fonds : bleu foncé, Couleur de police: blanc
    return 0 ; }
```

### Solution

<figure><img src="image_3.png" /></figure>

## Exercice 2

Ecrire un programme pour résoudre chacun des problèmes suivants :

a) Calculer le minimum de trois nombres réels donnés par l'utilisateur.

b) Ordonner trois nombres entiers donnés par l'utilisateur.

### Solution

a) Calculer le minimum de trois nombres réels donnés par l'utilisateur.

```c
#include <stdio.h>
#include <stdlib.h>
main ()
{
    float a,b,c;
    printf("donner les trois valeurs");
```
```c
scanf("%f %f %f",&a,&b,&c);
```

```c
if(a<b)
```

```c
if(c<a) printf("le minimum est %f", c);
```

```c
else printf("le minimum est %f", a);
```

```c
else
```

```c
if(c<b) printf("le minimum est %f", c);
```

```c
else printf("le minimum est %f", b);
```

```c
system("pause");
}
```

### c) Ordonner trois nombres entiers donnés par l'utilisateur.

```c
#include <stdio.h>
```

```c
#include <stdlib.h>
```

```c
main ()
```

```c
{int a,b,c;
```

```c
printf("donner les trois valeurs");
```

```c
scanf("%d %d %d",&a,&b,&c);
```

```c
if(a<b)
```

```c
if(b<c) printf("le tri est %d %d %d", a,b,c);
```

```c
else
```

```c
if(a<c) printf("le tri est %d %d %d", a,c,b);
```

```c
else
```

```c
printf("le tri est %d %d %d", c,a,b);
```

```c
else
```

```c
if(c<b) printf("le tri est %d %d %d", c,b,a);
```

```c
else if(a<c) printf("le tri est %d %d %d", b,a,c);
```

```c
else
```

```c
printf("le tri est %d %d %d", b,c,a);
```

```c
system("pause");
```

```c
}
```

## Exercice 3

Ecrire un programme en utilisant l'instruction `switch` pour résoudre le problème suivant : l'âge d'une personne est donné en entrée, le programme doit l'informer de sa catégorie :

* Poussin de 6 à 7 ans

* Pupille de 8 à 9 ans

* Minime de 10 à 11 ans

* Cadet de 12 à 15 ans

* Junior de 16 à 18 ans

* Senior 19 ans et plus.

## Solution

```c
#include <stdio.h>
```

```c
#include <stdlib.h>
```

```c
int main()
```

```c
{
```
```c
scanf("%f %f %f",&a,&b,&c);
if(a<b)
    if(c<a) printf("le minimum est %f", c);
    else printf("le minimum est %f", a);
else
    if(c<b) printf("le minimum est %f", c);
    else printf("le minimum est %f", b);
system("pause");
}
```

c) Ordonner trois nombres entiers donnés par l'utilisateur.

```c
#include <stdio.h>
#include <stdlib.h>
main ()
{
    int a,b,c;
    printf("donner les trois valeurs");
    scanf("%d %d %d",&a,&b,&c);
    if(a<b)
        if(b<c) printf("le tri est %d %d %d", a,b,c);
        else
            if(a<c) printf("le tri est %d %d %d", a,c,b);
            else
                printf("le tri est %d %d %d", c,a,b);
    else
        if(c<b) printf("le tri est %d %d %d", c,b,a);
        else if(a<c) printf("le tri est %d %d %d", b,a,c);
        else
            printf("le tri est %d %d %d", b,c,a);
    system("pause");
}
```

## Exercice 3

Ecrire un programme en utilisant l'instruction `switch` pour résoudre le problème suivant :
l'âge d'une personne est donné en entrée, le programme doit l'informer de sa catégorie :

* Poussin de 6 à 7 ans

* Pupille de 8 à 9 ans

* Minime de 10 à 11 ans

* Cadet de 12 à 15 ans

* Junior de 16 à 18 ans

* Senior 19 ans et plus.

## Solution

```c
#include <stdio.h>
#include <stdlib.h>
int main()
{
```
```c
int age;
printf("Quelle age a l'anfant ?");
scanf("%d", &age);
switch(age)
{
    case 6 ... 7:
        printf("poussin");
        break;
    case 8 ... 9:
        printf("Pupille ");
        break;
    case 10 ... 11:
        printf("Minime ");
        break;
    case 12 ... 15:
        printf("Cadet ");
        break;
    case 16 ... 18:
        printf("Junior ");
        break;
    case 19 ... 100:
        printf("Senior");
        break;

    default: printf("age ne convient pas");
}

return 0; }
```

## Exercice 4

Ecrire un programme qui saisit une facture et qui calcule son total : (soignez l'affichage)

* Demander le nombre de produits

* Demander le prix, la TVA (Taxe sur la Valeur Ajoutée) et la quantité de chaque produit

* Calculer et afficher le total de la facture

### Solution

```c
#include <stdio.h>

int main() {
    int n, qte, i;
    float prix, tva, somme=0;

    printf("\n Donnez le nombre de produits : ");
    scanf("%d", &n);

    for(i=1; i<=n; i++) {
```
```c
int age;
printf("Quelle age a l'anfant ?");
scanf("%d", &age);
switch(age)
{
    case 6 ... 7:
        printf("poussin");
        break;
    case 8 ... 9:
        printf("Pupille ");
        break;
    case 10 ... 11:
        printf("Minime ");
        break;
    case 12 ... 15:
        printf("Cadet ");
        break;
    case 16 ... 18:
        printf("Junior ");
        break;
    case 19 ... 100:
        printf("Senior");
        break;

    default: printf("age ne convient pas");
}

return 0; }
```

## Exercice 4

Ecrire un programme qui saisit une facture et qui calcule son total : (soignez l'affichage)

* Demander le nombre de produits

* Demander le prix, la TVA (Taxe sur la Valeur Ajoutée) et la quantité de chaque produit

* Calculer et afficher le total de la facture

### Solution

```c
#include <stdio.h>

int main() {
    int n, qte, i;
    float prix, tva, somme=0;

    printf("\n Donnez le nombre de produits : ");
    scanf("%d", &n);

    for(i=1; i<=n; i++) {
```
```c
printf("\n Donner le prix du produit %d : ", i);
scanf("%f", &prix);
printf("\n Donner la tva de ce produit en pourcentage : ");
scanf("%f", &tva);
printf("\n Donner la quantite de ce produit : ");
scanf("%d", &qte);
printf("\n******************************\n");
somme =somme+ (qte*prix*(1+tva/100));
}
printf("\n le total de la facture est : %.2f\n", somme);
return 0; }
```

## Exercice 5

Ecrire un programme pour résoudre chacun des problèmes suivants :

* Soit N nombres entiers quelconques, calculer le nombre de valeurs positives, le nombre de valeurs négatives et celui des valeurs nulles.

* Déterminer tous les diviseurs d'un entier X donné, et déterminer si un nombre entier X est premier ou non.

### Solution

* Soit N nombres entiers quelconques, calculer le nombre de valeurs positives, le nombre de valeurs négatives et celui des valeurs nulles.

```c
#include <stdio.h>
#include <stdlib.h>
int main() {
    int x,n,i;
    int nb1=0, nb2=0, nb3=0;
    printf("donner n\n");scanf("%d",&n);
    for ( i=0;i<n;i++)
    {printf("donner une valeur \n");
     scanf("%d",&x);
     if (x<0)nb1++;
     else if (x==0) nb2++;
     else nb3++;
    }
    printf("le nombre de val negatives est %d nulles %d positives %d\n",nb1,nb2,nb3);
    system("PAUSE");
    return 0; }
```

* Soit N caractères quelconques, calculer le nombre d'occurrences des caractères 'E' et le nombre d'occurrences de 'e'.

```c
#include <stdio.h>
#include <stdlib.h>
```
```c
printf("\n Donner le prix du produit %d : ", i);
scanf("%f", &prix);
printf("\n Donner la tva de ce produit en pourcentage : ");
scanf("%f", &tva);
printf("\n Donner la quantite de ce produit : ");
scanf("%d", &qte);
printf("\n******************************\n");
somme =somme+ (qte*prix*(1+tva/100));
printf("\n le total de la facture est : %.2f\n", somme);
return 0; }
```

## Exercice 5

Ecrire un programme pour résoudre chacun des problèmes suivants :

* Soit N nombres entiers quelconques, calculer le nombre de valeurs positives, le nombre de valeurs négatives et celui des valeurs nulles.

* Déterminer tous les diviseurs d'un entier X donné, et déterminer si un nombre entier X est premier ou non.

### Solution

* Soit N nombres entiers quelconques, calculer le nombre de valeurs positives, le nombre de valeurs négatives et celui des valeurs nulles.

```c
#include <stdio.h>
#include <stdlib.h>
int main() {
    int x,n,i;
    int nb1=0, nb2=0, nb3=0;
    printf("donner n\n");scanf("%d",&n);
    for ( i=0;i<n;i++)
    {printf("donner une valeur \n");
     scanf("%d",&x);
     if (x<0)nb1++;
     else if (x==0) nb2++;
     else nb3++;
    }
    printf("le nombre de val negatives est %d nulles %d positives %d\n",nb1,nb2,nb3);
    system("PAUSE");
    return 0; }
```

* Soit N caractères quelconques, calculer le nombre d'occurrences des caractères 'E' et le nombre d'occurrences de 'e'.

```c
#include <stdio.h>
#include <stdlib.h>
```
```c
int main ()
{
    int i,cpt1,n,cpt2;
    char c;
    cpt1= 0;
    cpt2=0;
    printf("Donner n\n");
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        printf("Donner un caractere");scanf(" %c",&c);
        if (c== 'e') cpt1++;
        else if(c== 'E')cpt2++;
    }
    printf("le nombre de fois que le caractere e apparait est: %d \n", cpt1) ;
    printf("le nombre de fois que le caractere E apparait est: %d\n", cpt2) ;
    system("PAUSE") ;
    return 0;
}
```

* Déterminer tous les diviseurs d'un entier X donné.

* Déterminer si un nombre entier X est premier ou non.

```c
#include <stdio.h>
#include <stdlib.h>
int main ()
{
    int x, i, nb=0;
    do
    {
        printf ("choisissez un nombre entier positif \n");
        scanf("%d",&x);}while ( x <= 0);
        printf ("les diviseurs de %d sont :\n",x);
        printf ("%d\n",1);
        printf ("%d\n",x);
        i = 2;
        while ( i <= x/2)
        {
            if ( x % i == 0)
            {
                nb++;
                printf ("%d\n",i);
            }
            i = i + 1;
        }
        if (nb==0)printf ("%d est premier\n",x);
        else printf ("%d n'est pas premier\n",x);
        system("PAUSE") ;
        return 0; }
```

Exercice 6
```c
int main ()
{
    int i,cpt1,n,cpt2;
    char c;
    cpt1= 0;
    cpt2=0;
    printf("Donner n\n");
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        printf("Donner un caractere");scanf(" %c",&c);
        if (c== 'e') cpt1++;
        else if(c== 'E')cpt2++;
    }
    printf("le nombre de fois que le caractere e apparait est: %d \n", cpt1) ;
    printf("le nombre de fois que le caractere E apparait est: %d\n", cpt2) ;
    system("PAUSE") ;
    return 0;
}
```

* Déterminer tous les diviseurs d'un entier X donné.

* Déterminer si un nombre entier X est premier ou non.

```c
#include <stdio.h>
#include <stdlib.h>
int main ()
{
    int x, i, nb=0;
    do
    {
        printf("choisissez un nombre entier positif \n");
        scanf("%d",&x);}while ( x <= 0);
        printf("les diviseurs de %d sont :\n",x);
        printf("%d\n",1);
        printf("%d\n",x);
        i = 2;
        while ( i <= x/2)
        {
            if ( x % i == 0)
            {
                nb++;
                printf("%d\n",i);
            }
            i = i + 1;
        }
        if (nb==0)printf("%d est premier\n",x);
        else printf("%d n'est pas premier\n",x);
        system("PAUSE") ;
        return 0; }
```

Exercice 6
Écrire un programme qui demande à l'utilisateur de saisir un entier. Il doit afficher le nombre de chiffres de ce dernier, le nombre de chiffres pairs et le nombre de chiffres impairs, la somme (la somme des chiffres) et l'inverse. Par exemple : si l'utilisateur saisit 123456, le programme affiche le message suivant:

Le chiffre 123456 contient 6 chiffres : 3 chiffres pairs et 3 chiffres impairs, la somme : 21 et l'inverse : 654321.

## Solution

```c
#include <stdio.h>
int main() {
    int i, inv=0, n=1111122, reste,somme=0, pair=0, impair=0;

    while(n!=0) {
        reste=n%10;
        if(reste%2==0)
            pair++;
        else
            impair++;
        somme+=reste;
        inv=inv*10+reste;

        n=n/10; }

printf("\n l'inverse est : %d et la somme est : %d \n le nombre de chiffres est %d , %d pairs, %d impairs.\n", inv, somme, impair+pair, pair, impair);

return 0; }
```

## Exercice 7

Ecrire un programme qui permette de dessiner la figure suivante :

*
***
*****
******
********
**********

## Solution

```c
#include <stdio.h>
int main() {
```
Écrire un programme qui demande à l'utilisateur de saisir un entier. Il doit afficher le nombre de chiffres de ce dernier, le nombre de chiffres pairs et le nombre de chiffres impairs, la somme (la somme des chiffres) et l'inverse. Par exemple : si l'utilisateur saisit 123456, le programme affiche le message suivant:

Le chiffre 123456 contient 6 chiffres : 3 chiffres pairs et 3 chiffres impairs, la somme : 21 et l'inverse : 654321.

## Solution

```c
#include <stdio.h>
int main() {
    int i, inv=0, n=1111122, reste,somme=0, pair=0, impair=0;

    while(n!=0) {
        reste=n%10;
        if(reste%2==0)
            pair++;
        else
            impair++;
        somme+=reste;
        inv=inv*10+reste;

        n=n/10; }

printf("\n l'inverse est : %d et la somme est : %d \n le nombre de chiffres est %d , %d pairs, %d impairs.\n", inv, somme, impair+pair, pair, impair);

return 0; }
```

## Exercice 7

Ecrire un programme qui permette de dessiner la figure suivante :

*
***
*****
******
********
**********

## Solution

```c
#include <stdio.h>
int main() {
```
```c
int i,j,n=8,k=7,l=1;
for(i=1;i<=n;i++){
    for(j=1;j<=k;j++){
        printf(" ");
    }
    k--;
    for(j=1;j<=l;j++){
        printf("* ");
    }
    l=l+2;
    printf("\n");
}
return 0;
}
```
```c
int i,j,n=8,k=7,l=1;
for(i=1;i<=n;i++){
    for(j=1;j<=k;j++){
        printf(" ");
    }
    k--;
    for(j=1;j<=l;j++){
        printf("* ");
    }
    l=l+2;
    printf("\n");
}
return 0;
}
```
# Tableaux et Matrices

## Rappel de quelques notions du cours:

**Déclaration d'un tableau à une dimension:**

<TypeSimple> <NomTableau> [<Dimension>];

Exemple: tableau de 25 entiers: int A[25];

**Lecture et écriture d'un élément du tableau:**

printf("%d", A[i]); scanf(" %d ",&A[i]);

**Déclaration d'un tableau à 2 dimensions (matrice):**

<TypeSimple> <NomTabl> [<DimLigne>] [<DimCol>];

Exemple: matrice carrée de 10 lignes et 10 colonnes: int A[10][10];

Saisie d'une matrice d'entiers de m lignes et n colonnes:

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

for(j=0; j<n; j++){

printf("\n Donnez un element mat[%d][%d] = ", i,j);

scanf("%d", &mat[i][j]); }

}
# Tableaux et Matrices

## Rappel de quelques notions du cours:

**Déclaration d'un tableau à une dimension:**

<TypeSimple> <NomTableau> [<Dimension>];

Exemple: tableau de 25 entiers: int A[25];

**Lecture et écriture d'un élément du tableau:**

printf("%d", A[i]); scanf(" %d ",&A[i]);

**Déclaration d'un tableau à 2 dimensions (matrice):**

<TypeSimple> <NomTabl> [<DimLigne>] [<DimCol>];

Exemple: matrice carrée de 10 lignes et 10 colonnes: int A[10][10];

Saisie d'une matrice d'entiers de m lignes et n colonnes:

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

for(j=0; j<n; j++){

printf("\n Donnez un element mat[%d][%d] = ", i,j);

scanf("%d", &mat[i][j]); }

}
Exercice 1

Saisir puis afficher un tableau d'entiers de taille n donné par l'utilisateur.

Solution

```c
#include <stdio.h>

int main() {
    int T[20];
    int i, n;

    printf("\n Donner la taille du tableau : ");
    scanf("%d", &n);
    //Saisie du tableau
    for(i=0; i<n; i++) {
        printf("\n T[%d] = ", i);
        scanf("%d", &T[i]);
    }
    //Affichage du tableau
    printf("\n le tableau est : 
    ");
    for(i=0; i<n; i++) {
        printf("\n T[%d] = %d", i, T[i]);
    }
    return 0;
}
```

Exercice 2

Donnez le nombre d'éléments positifs, le nombre d'éléments négatifs, le nombre d'éléments nuls, le min, le max et la moyenne du tableau.

Solution

```c
#include <stdio.h>
#include <conio.h>

main () {
    int tab[10];
    int i, cpt = 0, cpt_nul = 0, cpt_pos = 0;
    int min, max;
    float somme=0;

    for (i=0; i<=9; i++) {
        printf("Entrer le %d %c1%cment du tableau: ", i+1, 130, 130);
        scanf("%d", &tab[i]);
    }

    min = max = tab[0];
    printf("\n\n");
    for (i=0; i<=9; i++) {
        somme +=tab[i];
        if (tab[i]<0) cpt谓++;
```
Exercice 1

Saisir puis afficher un tableau d'entiers de taille n donné par l'utilisateur.

Solution

```c
#include <stdio.h>

int main() {
    int T[20];
    int i, n;

    printf("\n Donner la taille du tableau : ");
    scanf("%d", &n);
    //Saisie du tableau
    for(i=0; i<n; i++) {
        printf("\n T[%d] = ", i);
        scanf("%d", &T[i]);
    }
    //Affichage du tableau
    printf("\n le tableau est : 
    ");
    for(i=0; i<n; i++) {
        printf("\n T[%d] = %d", i, T[i]);
    }
    return 0;
}
```

Exercice 2

Donnez le nombre d'éléments positifs, le nombre d'éléments négatifs, le nombre d'éléments nuls, le min, le max et la moyenne du tableau.

Solution

```c
#include <stdio.h>
#include <conio.h>

main() {
    int tab[10];
    int i, cpt = 0, cpt_nul = 0, cpt_pos = 0;
    int min, max;
    float somme=0;

    for (i=0; i<=9; i++) {
        printf("Entrer le %d %c1%cment du tableau: ", i+1, 130, 130);
        scanf("%d", &tab[i]);
    }

    min = max = tab[0];
    printf("\n\n");
    for (i=0; i<=9; i++) {
        somme +=tab[i];
        if (tab[i]<0) cpt谓++;
    }
```
```c
else if (tab[i] == 0) cpt_nul++;
else cpt_pos++;
if (tab[i] < min)
min = tab[i];
if (tab[i] > max)
max = tab[i];
}
printf("Le nombre d'\%cl\%cments positifs est: %d\n", 130, 130, cpt_pos);
printf("Le nombre d'\%cl\%cments n\%cgatifs est: %d\n", 130, 130, 130, cpt谓);;
printf("Le nombre d'\%cl\%cments nuls est: %d\n", 130, 130, cpt_nul);
printf("\n");
printf("Le minimum est le: %d", min);
printf("\n");
printf("La moyenne du tableau est : %.2f", somme/10);
printf("\n");
printf("Le maximum est le: %d", max);
getch();}
```

## Exercice 3

Triez un tableau d'entiers **par permutation**, afficher la configuration initiale et après chaque itération de la boucle de tri puis insérez une valeur VAL donné par l'utilisateur tout en maintenant le tableau trié:

Exemple :

<figure><img src="image_4.png" /></figure>

## Solution

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

int main() {
    int i, n=4, j, X, k;
    int T[5]={-33,-2,0, 1,65};

    printf("\n configuration initiale : ");
    for(k=0;k<=4;k++){
```
```c
else if (tab[i] == 0) cpt_nul++;
else cpt_pos++;
if (tab[i] < min)
min = tab[i];
if (tab[i] > max)
max = tab[i];
}
printf("Le nombre d'\%cl\%cments positifs est: %d\n", 130, 130, cpt_pos);
printf("Le nombre d'\%cl\%cments n\%cgatifs est: %d\n", 130, 130, 130, cptproneg);
printf("Le nombre d'\%cl\%cments nuls est: %d\n", 130, 130, cpt_nul);
printf("\n");
printf("Le minimum est le: %d", min);
printf("\n");
printf("La moyenne du tableau est : %.2f", somme/10);
printf("\n");
printf("Le maximum est le: %d", max);
getch();}
```

## Exercice 3

Triez un tableau d'entiers **par permutation**, afficher la configuration initiale et après chaque itération de la boucle de tri puis insérez une valeur VAL donné par l'utilisateur tout en maintenant le tableau trié:

Exemple :

<figure><img src="image_4.png" /></figure>

## Solution

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

int main() {
    int i, n=4, j, X, k;
    int T[5]={-33,-2,0, 1,65};

    printf("\n configuration initiale : ");
    for(k=0;k<=4;k++){
```
printf(" %d ", T[k]);
}
printf("\n");

for(i=0;i<=4;i++) {
    for(j=0;j<=n-i;j++) {
        if(T[j]>T[j+1]) {
            X=T[j];
            T[j]=T[j+1];
            T[j+1]=X;
        }
    }
    printf("\n apres un passage : ");
    for(k=0;k<=4;k++) {
        printf(" %d ", T[k]);
    }
    printf("\n");
}

//INSERTION
printf("\n Donner la valeur %c ins%crer : ", 133, 130);
scanf("%d", &val);

while(T[i]<val) {i++;}

if(i>n) j=n; //position à insérer
else j=i;

k=n;

while(k>j) {
    //décalage
    T[k]=T[k-1];
    k--;
}
T[j]=val; //insertion

printf("\n apr%cs insertion de la valeur %d : \n\n",138, val);
for(i=0;i<=n;i++) {
    printf("\t%d",T[i]);
}
printf("\n");
return 0;}

Exercice 4
printf(" %d ", T[k]);
}
printf("\n");

for(i=0;i<=4;i++){
    for(j=0;j<=n-i;j++){
        if(T[j]>T[j+1]){
            X=T[j];
            T[j]=T[j+1];
            T[j+1]=X;
        }
    }
    printf("\n apres un passage : ");
    for(k=0;k<=4;k++){
        printf(" %d ", T[k]);
    }
    printf("\n");
}

//INSERTION
printf("\n Donner la valeur %c ins%crer : ", 133, 130);
scanf("%d", &val);

while(T[i]<val) {i++;}

if(i>n) j=n; //position à insérer
else j=i;

k=n;

while(k>j){ //décalage
    T[k]=T[k-1];
    k--;
}
T[j]=val; //insertion

printf("\n apr%cs insertion de la valeur %d : \n\n",138, val);
for(i=0;i<=n;i++){
    printf("\t%d",T[i]);
}
printf("\n");
return 0;}

Exercice 4
Utilisez le tableau dans la solution de l'exercice précédent et appliquer le programme **de tri par sélection** avec affichage de chaque itération du tri. Essayez ces deux programmes de tri avec plusieurs exemples et comparez le nombre d'itérations nécessaires.

## Solution

```c
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

int main() {

    int i, N=4, j, x, k, pos;
    int T[5] = {0,-2,1,65,-33};

    printf("\n configuration initiale : ");
    for(k=0;k<=4;k++) {
        printf(" %d ", T[k]);
    }
    printf("\n");

    for(i=1;i<=4;i++) { pos=0;
        while(T pos<T[i]) pos(pos+1); // t[i] : valeur pivot
            if(pos!=i) {
                x=T[i]; j=i; // récupérer la valeur pivot à recaser avec son indice
                while(j>=pos+1) {
                    T[j]=T[j-1]; /* décaler les valeurs pour libérer une case*/
                    j=j-1;
                }
                T pos=x;
            }
        printf("\n apres un passage : ");
        for(k=0;k<=4;k++) {
            printf(" %d ", T[k]);
        }
        printf("\n");
    }

    system("color F0");
    return 0;
}
```
Utilisez le tableau dans la solution de l'exercice précédent et appliquer le programme **de tri par sélection** avec affichage de chaque itération du tri. Essayez ces deux programmes de tri avec plusieurs exemples et comparez le nombre d'itérations nécessaires.

## Solution

```c
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

int main() {

    int i, N=4, j, x, k, pos;
    int T[5] = {0,-2,1,65,-33};

    printf("\n configuration initiale : ");
    for(k=0;k<=4;k++) {
        printf(" %d ", T[k]);
    }
    printf("\n");

    for(i=1;i<=4;i++) { pos=0;
        while(T pos<T[i]) pos(pos+1); // t[i] : valeur pivot
        if(pos!=i) {
            x=T[i]; j=i; // récupérer la valeur pivot à recaser avec son indice
            while(j>=pos+1) {
                T[j]=T[j-1]; /* décaler les valeurs pour libérer une case*/
                j=j-1;
            }
            T pos=x;
        }
        printf("\n apres un passage : ");
        for(k=0;k<=4;k++) {
            printf(" %d ", T[k]);
        }
        printf("\n");
    }

    system("color F0");
    return 0;
}
```
<figure><img src="image_5.png" /></figure>

Exercice 5

Ecrire un programme pour vérifier si un mot est palindrome (se lit de droite comme de gauche), exemples : « elle », « ici » sont des mots palindromes

Solution

```c
#include<stdio.h>
#include stdlib.h
#include <string.h>
main()
{
    int i,cpt,b=1;
    char ch[40];

    printf("donner la phrase a test%cr: ",130);
    scanf("%s",ch); //ou gets(ch)
    i=0;
    cpt=strlen(ch); //la taille du mot

    for(i=0;i<cpt/2 && b==1;i++) { // teste si le mot est palindrome
        if(ch[i] !=ch[cpt-i-1])
            b=0;
    }

    if(b==1) printf("le mot est palindrome\n\n");
    else printf("le mot n'est pas palindrome\n\n");

    system("pause");
}
```

Exercice 6

Ecrire un programme C qui détermine le nombre et les positions d'une chaîne **SousCH** dans une autre chaîne **CH**. Sauvegardez les positions trouvées dans un tableau **POS** de taille maximale égale à Taille(CH)/Taille(SousCH).

**Exemple** : La chaîne ON se trouve 2 fois dans la chaîne FONCTION, en positions 2 et 7.

Solution
<figure><img src="image_5.png" /></figure>

Exercice 5

Ecrire un programme pour vérifier si un mot est palindrome (se lit de droite comme de gauche), exemples : « elle », « ici » sont des mots palindromes

Solution

```c
#include<stdio.h>
#include<stdlib.h>
#include <string.h>
main()
{
    int i,cpt,b=1;
    char ch[40];

    printf("donner la phrase a test%cr: ",130);
    scanf("%s",ch); //ou gets(ch)
    i=0;
    cpt=strlen(ch); //la taille du mot

    for(i=0;i<cpt/2 && b==1;i++) { // teste si le mot est palindrome
        if(ch[i] !=ch[cpt-i-1])
            b=0;
    }

    if(b==1) printf("le mot est palindrome\n\n");
    else printf("le mot n'est pas palindrome\n\n");

    system("pause");
}
```

Exercice 6

Ecrire un programme C qui détermine le nombre et les positions d'une chaîne **SousCH** dans une autre chaîne **CH**. Sauvegardez les positions trouvées dans un tableau **POS** de taille maximale égale à Taille(CH)/Taille(SousCH).

**Exemple** : La chaîne ON se trouve 2 fois dans la chaîne FONCTION, en positions 2 et 7.

Solution
```c
#include <stdio.h>
#include<conio.h>
#include <string.h>
main()
{
    char ch[20]; char souch[10]; int pos[10]; int i,j,k,n_ch,n_sch,cpt=0;
    printf("entrer la chaine:");
    gets(ch);
    printf("entrer la sous chaine:");
    gets(souch);
    n_ch=strlen(ch);
    n_sch=strlen(souch);
    i=0;j=0;k=0;
    while (i<=n_ch){
        if (ch[i==souch[j]]){
            pos[k]=i+1; //le tableau qui stocke les positions
            k++;
            while (ch[i==souch[j]]){
                i++;
                j++;
            }
            if (j<n_sch) k=k-1; //dans la cas où c'est juste une partie
        }
        //de la sous-chaine qui correspond
        j=0;
        i++;
    }
    printf("le nombre de fois est: %d\n", k);
    if (k!=0){
        printf("les positions sont:");
        for (i=0;i<k;i++){
            printf("%d ",pos[i]);
        }
    }
    getch();
}
```

## Exercice 7

Saisir une matrice mat d'entiers de 3 lignes et 2 colonnes puis l'afficher.

### Solution

```c
#include <stdio.h>
int main(){
    int mat[3][2];
    int i,j;

    for(i=0; i<3; i++){
        for(j=0; j<2; j++){
            printf("\n mat[%d][%d] =", i,j);
            scanf("%d", &mat[i][j]);
        }
    }
}
```
```c
#include <stdio.h>
#include<conio.h>
#include <string.h>
main()
{
    char ch[20]; char souch[10]; int pos[10]; int i,j,k,n_ch,n_sch,cpt=0;
    printf("entrer la chaine:");
    gets(ch);
    printf("entrer la sous chaine:");
    gets(souch);
    n_ch=strlen(ch);
    n_sch=strlen(souch);
    i=0;j=0;k=0;
    while (i<=n_ch){
        if (ch[i==souch[j]]){
            pos[k]=i+1; //le tableau qui stocke les positions
            k++;
            while (ch[i==souch[j]]){
                i++;
                j++;
            }
            if (j<n_sch) k=k-1; //dans la cas où c'est juste une partie
        }
        //de la sous-chaine qui correspond
        j=0;
        i++;
    }
    printf("le nombre de fois est: %d\n", k);
    if (k!=0){
        printf("les positions sont:");
        for (i=0;i<k;i++){
            printf("%d ",pos[i]);
        }
    }
    getch();
}
```

## Exercice 7

Saisir une matrice mat d'entiers de 3 lignes et 2 colonnes puis l'afficher.

### Solution

```c
#include <stdio.h>
int main(){
    int mat[3][2];
    int i,j;

    for(i=0; i<3; i++){
        for(j=0; j<2; j++){
            printf("\n mat[%d][%d] =", i,j);
            scanf("%d", &mat[i][j]);
        }
    }
}
```
```c
printf("\n la matrice est : \n");
for(i=0; i<3;i++){
    for(j=0; j<2;j++){
        printf("\t%d", mat[i][j]);
    }
    printf("\n");
}
return 0;
}
```

## Exercice 8

Soit une matrice mat d'entiers de 5 lignes et 5 colonnes. Initialisez la matrice par des valeurs aléatoires dans le programme.

Afficher le somme de chaque ligne et le produit de chaque colonne. Permuter les deux diagonales.

### Solution

```c
#include <stdio.h>
int main() {
    int s,p;
    int i,j;
    int mat[5][5]={{1,6,-9,6,3},{6,3,-9,6,3},{1,6,-9,6,3},{1,6,-9,6,3},{-9,3,1,6,3}};
    int x;

    //somme ligne
    for (i=0; i<=4; i++) {
        s=0;
        for (j=0; j<=4; j++) {
            s=s+mat[i][j];
        }
        printf("la somme de la ligne %d est: %d\n", i+1, s);
    }

    printf("\n");
    //produit colonne
    for (j=0; j<=4; j++) {
        p=1;
        for (i=0; i<=4; i++) {
            p=p*mat[i][j];
        }
        printf("le produit de la colonne %d est: %d\n", j+1, p);
    }

    printf("\n affichage avant permutation\n\n");
    for (i=0; i<=4; i++) {
        for (j=0; j<=4; j++) {
```
```c
printf("\n la matrice est : \n");
for(i=0; i<3;i++){
    for(j=0; j<2;j++){
        printf("\t%d", mat[i][j]);
    }
    printf("\n");
}
return 0;
}
```

## Exercice 8

Soit une matrice mat d'entiers de 5 lignes et 5 colonnes. Initialisez la matrice par des valeurs aléatoires dans le programme.

Afficher le somme de chaque ligne et le produit de chaque colonne. Permuter les deux diagonales.

### Solution

```c
#include <stdio.h>
int main() {
    int s,p;
    int i,j;
    int mat[5][5]={{1,6,-9,6,3},{6,3,-9,6,3},{1,6,-9,6,3},{1,6,-9,6,3},{-9,3,1,6,3}};
    int x;

    //somme ligne
    for (i=0; i<=4; i++) {
        s=0;
        for (j=0; j<=4; j++) {
            s=s+mat[i][j];
        }
        printf("la somme de la ligne %d est: %d\n", i+1, s);
    }

    printf("\n");
    //produit colonne
    for (j=0; j<=4; j++) {
        p=1;
        for (i=0; i<=4; i++) {
            p=p*mat[i][j];
        }
        printf("le produit de la colonne %d est: %d\n", j+1, p);
    }

    printf("\n affichage avant permutation\n\n");
    for (i=0; i<=4; i++) {
        for (j=0; j<=4; j++) {
```
```c
printf("%d\t", mat[i][j]);
}
printf("\n");
}
printf("\n");

//permutation

j=4;
for (i=0; i<=4; i++) {
    x=mat[i][i];
    mat[i][i]=mat[i][j];
    mat[i][j]=x;
    j--;
}
printf("\n affichage apres permutation\n\n");
for (i=0; i<=4; i++) {
    for (j=0; j<=4; j++) {
        printf("%d\t", mat[i][j]);
    }
    printf("\n");
}
printf("\n");

return 0; }
```

## Exercice 9

Soit une matrice de nombres entiers A(N,M), (N<=50, M<=100). Chaque ligne contient des éléments triés dans l'ordre croissant.

Ecrire un programme C qui insère une valeur VAL donnée dans chaque ligne de la matrice si elle n'existe pas déjà. L'insertion doit préserver l'ordre croissant des éléments. En cas d'insertion, la dernière valeur de la ligne sera perdue.

### Solution

```c
#include <stdio.h>
main()
{
    int i,j,val, k;
    int mat[4][3]={{-9,1,3},{-1,6,10},{1,6,9},{11,16,19}};

    printf("Entrer la valeur de val:");
    scanf("%d", &val);
    i=0;
    k=0;

    while (i<4) {
        j=0;
        while (mat[i][j]<val && j<3) j++;
```
```c
printf("%d\t", mat[i][j]);
}
printf("\n");
}
printf("\n");

//permutation

j=4;
for (i=0; i<=4; i++) {
    x=mat[i][i];
    mat[i][i]=mat[i][j];
    mat[i][j]=x;
    j--;
}
printf("\n affichage apres permutation\n\n");
for (i=0; i<=4; i++) {
    for (j=0; j<=4; j++) {
        printf("%d\t", mat[i][j]);
    }
    printf("\n");
}
printf("\n");

return 0; }
```

## Exercice 9

Soit une matrice de nombres entiers A(N,M), (N<=50, M<=100). Chaque ligne contient des éléments triés dans l'ordre croissant.

Ecrire un programme C qui insère une valeur VAL donnée dans chaque ligne de la matrice si elle n'existe pas déjà. L'insertion doit préserver l'ordre croissant des éléments. En cas d'insertion, la dernière valeur de la ligne sera perdue.

### Solution

```c
#include <stdio.h>
main()
{
    int i,j,val, k;
    int mat[4][3]={{-9,1,3},{-1,6,10},{1,6,9},{11,16,19}};

    printf("Entrer la valeur de val:");
    scanf("%d", &val);
    i=0;
    k=0;

    while (i<4) {
        j=0;
        while (mat[i][j]<val && j<3) j++;
```
```c
if (mat[i][2]<val) mat[i][2]=val; //la dernière valeur est plus petite que val

if (mat[i][j]>val) {
    k=2;
    while (k>j) {
        mat[i][k]=mat[i][k-1]; //décalage des valeurs
        k--;
    }
    mat[i][j]=val; //insertion de val
}

i++;
}

// affichage

for (i=0; i<4; i++) {
    for (j=0; j<3; j++) {
        printf("%d\t", mat[i][j]);
    }
    printf("\n");
}

return 0;
}
```
```c
if (mat[i][2]<val) mat[i][2]=val; //la dernière valeur est plus petite que val

if (mat[i][j]>val) {
    k=2;
    while (k>j) {
        mat[i][k]=mat[i][k-1]; //décalage des valeurs
        k--;
    }
    mat[i][j]=val; //insertion de val
}

i++;
}

// affichage

for (i=0; i<4; i++) {
    for (j=0; j<3; j++) {
        printf("%d\t", mat[i][j]);
    }
    printf("\n");
}

return 0;
}
```
# Fonctions et Récursivité

## Rappel de quelques notions du cours:

Une procédure est un sous-programme qui ne retourne rien :

```c
#include <stdio.h>
#include <conio.h>
void nom_procedure( Liste d'arguments)
{
    /*
     Liste d'instructions et de
     déclarations de variables
     locales
    */
}

Void main()
{
    ............
```

Une fonction est un sous-programme qui retourne toujours un résultat :

```c
#include <stdio.h>
#include <conio.h>
Type retour nom_fonction( Liste d'arguments)
{
    /*
     Liste d'instructions et de
     déclarations de variables
     locales
    */
    Return (valeur_à_renvoyer);
}

Void main()
{
    ............
```

## Exemple de fonction récursive : s'auto appelle

```c
1   #include <stdio.h>
2   #include <stdlib.h>
3
4   int factoriel(int n)
5   {
6       if(n==0)
7       {
8           return 1
9       }
10      return n*factoriel(n-1);
11   }
```
# Fonctions et Récursivité

## Rappel de quelques notions du cours:

Une procédure est un sous-programme qui ne retourne rien :

```c
#include <stdio.h>
#include <conio.h>
void nom_procedure( Liste d'arguments)
{
    /*
     Liste d'instructions et de
     déclarations de variables
     locales
    */
}

Void main()
{
    .........
```

Une fonction est un sous-programme qui retourne toujours un résultat :

```c
#include <stdio.h>
#include <conio.h>
Type retour nom_fonction( Liste d'arguments)
{
    /*
     Liste d'instructions et de
     déclarations de variables
     locales
    */
    Return (valeur_à_renvoyer);
}

Void main()
{
    .........
```

## Exemple de fonction récursive : s'auto appelle

```c
1   #include <stdio.h>
2   #include <stdlib.h>
3
4   int factoriel(int n)
5   {
6       if(n==0)
7       {
8           return 1
9       }
10      return n*factoriel(n-1);
11   }
```
Exercice 1

Qu'affichent les programmes suivants ? (pour le prgm 3, x vaut « ENST » par exemple)

```c
1 void calculer_puissances(float x, float* ptrCarre, float* ptrCube);
2 void main(void)
3 {
4     double a = 6.3, carre_a, cube_a;
5     calculer_puissances(a, &carre_a, &cube_a);
6     printf("\n a=%lf - a au carré=%lf - a au cube=%lf", a, carre_a, cube_a);
7 }
8 void calculer_puissances(double x, double* ptrCarre, double* ptrCube)
9 {
10     *ptrCarre = x * x;
11     *ptrCube = x * x * x;
12 }
```

```c
1 void permute(double* ptrX, double* ptrY); /*prototype de la fonction*/
2 void main(void)
3 {
4     double a=10., b=20.;
5     printf(" a=%lf et b=%lf avant la permutation", a, b);
6     permute(&a, &b);
7     printf("\n a=%lf et b=%lf apres la permutation", a, b);
8 }
9 void permute( double* ptrX, double* ptrY)
10 {
11     double tampon;
12     tampon = *ptrX;
13     *ptrX = *ptrY;
14     *ptrY = tampon;
15 }
```

```c
1 #include <stdio.h>
2 #include <stdlib.h>
3
4 char x[10];
5
6 int l=0;
7 int main(int argc, char *argv[]) {
8 printf("entrer une chaine:");
9 gets(x);
10
11 do{
12     l++;
13
14 } while(x[1] != '\0');
15
16 printf("la langueur de %s est: %d \n",x,1);
17
18
19
20
21
22 }
```
Exercice 1

Qu'affichent les programmes suivants ? (pour le prgm 3, x vaut « ENST » par exemple)

```c
1 void calculer_puissances(float x, float* ptrCarre, float* ptrCube);
2 void main(void)
3 {
4     double a = 6.3, carre_a, cube_a;
5     calculer_puissances(a, &carre_a, &cube_a);
6     printf("\n a=%lf - a au carré=%lf - a au cube=%lf", a, carre_a, cube_a);
7 }
8 void calculer_puissances(double x, double* ptrCarre, double* ptrCube)
9 {
10     *ptrCarre = x * x;
11     *ptrCube = x * x * x;
12 }
```

```c
1 void permute(double* ptrX, double* ptrY); /*prototype de la fonction*/
2 void main(void)
3 {
4     double a=10., b=20.;
5     printf(" a=%lf et b=%lf avant la permutation", a, b);
6     permute(&a, &b);
7     printf("\n a=%lf et b=%lf apres la permutation", a, b);
8 }
9 void permute( double* ptrX, double* ptrY)
10 {
11     double tampon;
12     tampon = *ptrX;
13     *ptrX = *ptrY;
14     *ptrY = tampon;
15 }
```

```c
1 #include <stdio.h>
2 #include <stdlib.h>
3
4 char x[10];
5
6 int l=0;
7 int main(int argc, char *argv[]) {
8     printf("entrer une chaine:");
9     gets(x);
10
11 do{
12     l++;
13
14 } while(x[1] != '\0');
15
16 printf("la langueur de %s est: %d \n",x,1);
17
18
19
20
21
22 }
```
## Solution

### Programme 1 affiche :

a=6.3 – a au carre=39.69 – a au cube=250.047

### Programme 2 affiche :

a=10 et b=20 avant la permutation

a=20 et b=10 apres la permutation

### programme 3 affiche :

la longueur de ENST est : 4

## Exercice 2

Écrire les actions paramétrées (procédure ou fonction) permettant de résoudre les problèmes suivants :

a. Calculer la moyenne de deux nombres réels donnés par l'utilisateur

b. Réaliser une permutation circulaire de 3 variables entières A, B, C (ex : A=1, B=2, C=3 après permutation : A=3, B=1, C=2).

c. Inverser un tableau T d'entiers de taille N.

d. Vérifier l'existence d'une valeur VAL (donné par l'utilisateur) dans un tableau T d'entiers de taille N.

e. Afficher le maximum de chaque ligne d'une matrice MAT (NxM) de réels.

## Solution

a. La moyenne de deux nombres réels

```c
#include <stdio.h>
float moyenne(float a, float b){
    return ((a+b)/2);}
int main() {
    float x,y;
    printf("\n Donner 2 réels : ");
    scanf("%f %f", &x,&y);
    printf("\n la moyenne des 2 réels est : %.2f ", moyenne(x,y));
    return 0;}
```

b. Permutation circulaire de 3 entiers :

```c
#include <stdio.h>
void permuter(int *a, int *b, int *c){
    int temp;
    temp=*a;
```
## Solution

### Programme 1 affiche :

a=6.3 – a au carre=39.69 – a au cube=250.047

### Programme 2 affiche :

a=10 et b=20 avant la permutation

a=20 et b=10 apres la permutation

### programme 3 affiche :

la longueur de ENST est : 4

## Exercice 2

Écrire les actions paramétrées (procédure ou fonction) permettant de résoudre les problèmes suivants :

a. Calculer la moyenne de deux nombres réels donnés par l'utilisateur

b. Réaliser une permutation circulaire de 3 variables entières A, B, C (ex : A=1, B=2, C=3 après permutation : A=3, B=1, C=2).

c. Inverser un tableau T d'entiers de taille N.

d. Vérifier l'existence d'une valeur VAL (donné par l'utilisateur) dans un tableau T d'entiers de taille N.

e. Afficher le maximum de chaque ligne d'une matrice MAT (NxM) de réels.

## Solution

a. La moyenne de deux nombres réels

```c
#include <stdio.h>
float moyenne(float a, float b){
    return ((a+b)/2);}
int main() {
    float x,y;
    printf("\n Donner 2 réels : ");
    scanf("%f %f", &x,&y);
    printf("\n la moyenne des 2 réels est : %.2f ", moyenne(x,y));
    return 0;}
```

b. Permutation circulaire de 3 entiers :

```c
#include <stdio.h>
void permuter(int *a, int *b, int *c){
    int temp;
    temp=*a;
```
*a=*c;
*c=*b;
*b=&temp;}
int main() {
    int x,y,z;
    printf("\n Donner 3 entiers : ");
    scanf("%d %d %d", &x,&y,&z);
    permuter(&x,&y,&z);
    printf("\n les nouvelles valeurs sont : x = %d, y = %d, z = %d ", x,y,z);
    return 0; }

c. Inverser un tableau T d'entiers de taille N

#include <stdio.h>
void InverseTableau(int T[], int n){
    int i, temp;
    for(i=0;i<n/2;i++){
        temp=T[i];
        T[i]=T[n-i-1];
        T[n-i-1]=temp;}}
int main() {
    int T[10],i,n;
    printf("\n Donner la taille du tableau : ");
    scanf("%d", &n);
    for(i=0;i<n;i++) {
        printf("\n T[%d] = ",i);
        scanf("%d",&T[i]);}
    InverseTableau(T,n);
    printf("\n apres inversion :\n");
    for(i=0;i<n;i++) {
        printf("\n T[%d] = %d",i,T[i] );}
    return 0; }

d. Vérifier l'existence de VAL dans T

#include <stdio.h>
int Existence(int T[], int n, int VAL){
    int i;
    for(i=0;i<n;i++){
        if(T[i)==VAL) return 1;}
    return 0;}
int main() {
    int T[10],i,n, VAL;
    printf("\n Donner la taille du tableau : ");
    scanf("%d", &n);
    for(i=0;i<n;i++) {
        printf("\n T[%d] = ",i);
        scanf("%d",&T[i]);}
        printf("\n Donner la valeur a chercher : ");
        scanf("%d", &VAL);
        if(Existence(T,n,VAL)==1) printf("\n la valeur %d existe dans le tableau ",VAL);
*a=*c;
*c=*b;
*b=&temp;}
int main() {
    int x,y,z;
    printf("\n Donner 3 entiers : ");
    scanf("%d %d %d", &x,&y,&z);
    permuter(&x,&y,&z);
    printf("\n les nouvelles valeurs sont : x = %d, y = %d, z = %d ", x,y,z);
    return 0; }

c. Inverser un tableau T d'entiers de taille N

#include <stdio.h>
void InverseTableau(int T[], int n){
    int i, temp;
    for(i=0;i<n/2;i++){
        temp=T[i];
        T[i]=T[n-i-1];
        T[n-i-1]=temp;}}
int main() {
    int T[10],i,n;
    printf("\n Donner la taille du tableau : ");
    scanf("%d", &n);
    for(i=0;i<n;i++) {
        printf("\n T[%d] = ",i);
        scanf("%d",&T[i]);}
    InverseTableau(T,n);
    printf("\n apres inversion :\n");
    for(i=0;i<n;i++) {
        printf("\n T[%d] = %d",i,T[i] );}
    return 0; }

d. Vérifier l'existence de VAL dans T

#include <stdio.h>
int Existence(int T[], int n, int VAL){
    int i;
    for(i=0;i<n;i++){
        if(T[i==VAL]) return 1;}
    return 0;}
int main() {
    int T[10],i,n, VAL;
    printf("\n Donner la taille du tableau : ");
    scanf("%d", &n);
    for(i=0;i<n;i++) {
        printf("\n T[%d] = ",i);
        scanf("%d",&T[i]);}
        printf("\n Donner la valeur a chercher : ");
        scanf("%d", &VAL);
        if(Existence(T,n,VAL)==1) printf("\n la valeur %d existe dans le tableau ",VAL);
else printf("\n la valeur %d n'existe pas dans le tableau ",VAL);
return 0; }

e. Maximum de chaque ligne d'une matrice

#include <stdio.h>
int maximum(int M[] [10], int i, int m) {
int j,maxi=M[i][0];
for(j=0; j<m; j++) {
if(M[i][j]>maxi) maxi=M[i][j];}
return maxi;}
int main() {
int i,j,n,m, M[20][10];
printf("\n Donner le nombre de lignes : ");
scanf("%d", &n);
printf("\n Donner le nombre de colonnes : ");
scanf("%d", &m);
for(i=0; i<n; i++) {
for(j=0; j<m; j++) {
printf("\n M[%d][%d] = ",i,j);
scanf("%d", &M[i][j]); }
}
for(i=0; i<n; i++) {
printf("\n le maximum de la ligne %d est : %d ", i, maximum(M,i,m)); }
return 0; }

Exercice 3

Résoudre les problèmes suivants de 2 façons : avec **une fonction itérative et une fonction récursive équivalente** :

a. Calculer le factoriel de N (N !).

b. Calculer le PGCD de deux nombres entiers strictement positifs tels que : a>b>0.

c. Vérifier si une chaine de caractères est palindrome (exemple : « LAVAL »)

d. Inverser une chaine de caractères (ex : « CODE » inverse « EDOC »)

e. Calculer le nième terme de la suite de Fibonacci (n donné par l'utilisateur)

$F_0 = 0$

$F_1 = 1$

$F_n = F_{n-2} + F_{n-1} \text{ pour } n \ge 2.$

Solution

a. Calculer le factoriel de N :
```c
else printf("\n la valeur %d n'existe pas dans le tableau ",VAL);
return 0; }
```

e. Maximum de chaque ligne d'une matrice

```c
#include <stdio.h>

int maximum(int M[] [10], int i, int m) {
    int j, maxi=M[i][0];
    for(j=0; j<m; j++) {
        if(M[i][j] > maxi) maxi=M[i][j];
    }
    return maxi;
}

int main() {
    int i,j,n,m, M[20][10];
    printf("\n Donner le nombre de lignes : ");
    scanf("%d", &n);
    printf("\n Donner le nombre de colonnes : ");
    scanf("%d", &m);
    for(i=0; i<n; i++) {
        for(j=0; j<m; j++) {
            printf("\n M[%d][%d] = ",i,j);
            scanf("%d", &M[i][j]); }
        }
        for(i=0; i<n; i++) {
            printf("\n le maximum de la ligne %d est : %d ", i, maximum(M,i,m));
        }
        return 0; }
```

## Exercice 3

Résoudre les problèmes suivants de 2 façons : avec **une fonction itérative et une fonction récursive équivalente** :

a. Calculer le factoriel de N (N !).

b. Calculer le PGCD de deux nombres entiers strictement positifs tels que : a>b>0.

c. Vérifier si une chaine de caractères est palindrome (exemple : « LAVAL »)

d. Inverser une chaine de caractères (ex : « CODE » inverse « EDOC »)

e. Calculer le nième terme de la suite de Fibonacci (n donné par l'utilisateur)

$$F_0 = 0$$

$$F_1 = 1$$

$$F_n = F_{n-2} + F_{n-1} \quad \text{pour } n \ge 2.$$

## Solution

a. Calculer le factoriel de N :
```c
#include <stdio.h>
//version itérative
int factITER(int x){
    int i,f=1;
    if(x==0) return 1;
    for(i=1; i<=x; i++){
        f*=i;}
    return f;}

//version récursive
int factRECUR(int x){
    if (x==0)
        return 1;
    else
        return (x*fact(x-1));}

int main() {
    int n;
    //gestion des cas d'erreurs
    do{
        printf("\n le chiffre doit etre positif!!\n");
        printf("Donnez le n: ");
        scanf("%d", &n);
    }while(n<0);
    printf("\n Version Iterative: le factoriel de %d est: %d\n", n, factITER(n));
    printf("\n Version Recursive: le factoriel de %d est: %d\n", n, factRECUR(n));
    return 0;}
```

## b. Calculer le PGCD :

```c
#include <stdio.h>
int pgcd_iter(int a, int b) {
    int c;
    while (b!=0) {
        c=a % b;
        a=b;
        b=c;
    }
    return a;}

int pgcd_rec(int a, int b) {
    if (b == 0) {
        return a;}
    else {return pgcd_rec(b, a%b);}}

int main() {
    int a,b;
    printf("\ndonner deux entiers a,b positifs tels que a>b>0 ");
    scanf("%d %d", &a,&b);
    printf("\n le PGCD avec la fonction iterative est : %d", pgcd_iter(a,b));
    printf("\n le PGCD avec la fonction recursive est : %d", pgcd_rec(a,b));
    return 0;}
```
```c
#include <stdio.h>
//version itérative
int factITER(int x){
    int i,f=1;
    if(x==0) return 1;
    for(i=1; i<=x; i++){
        f*=i;}
    return f;}

//version récursive
int factRECUR(int x){
    if (x==0)
        return 1;
    else
        return (x*fact(x-1));}

int main(){
    int n;
    //gestion des cas d'erreurs
    do{
        printf("\n le chiffre doit etre positif!!\n");
        printf("Donnez le n: ");
        scanf("%d", &n);
    }while(n<0);
    printf("\n Version Iterative: le factoriel de %d est: %d\n", n, factITER(n));
    printf("\n Version Recursive: le factoriel de %d est: %d\n", n, factRECUR(n));
    return 0;}
```

b. Calculer le PGCD :

```c
#include <stdio.h>
int pgcd_iter(int a, int b) {
    int c;
    while (b!=0) {
        c=a % b;
        a=b;
        b=c;
    }
    return a;}

int pgcd_rec(int a, int b) {
    if (b == 0) {
        return a;}
    else {return pgcd_rec(b, a%b);}}

int main() {
    int a,b;
    printf("\ndonner deux entiers a,b positifs tels que a>b>0 ");
    scanf("%d %d", &a,&b);
    printf("\n le PGCD avec la fonction iterative est : %d", pgcd_iter(a,b));
    printf("\n le PGCD avec la fonction recursive est : %d", pgcd_rec(a,b));
    return 0;}
```
### c. Vérifier si une chaîne est palindromes

```c
#include <stdio.h>
#include <string.h>

int palind_recur(char ch[], int i, int j){

    if(i==j || i>j) //mot palindrome, longueur du mot impair i=j, pair i>j
        return 1;
    else{
        if(ch[i] != ch[j]) return -1;
        else
            i++;
        j--;
        return palind_recur(ch, i, j); //ou directement return palind_recur(ch, i+1, j-1) ;
    }

    int palind_iter(char ch[]){
        int i,cpt;
        cpt=strlen(ch); //la taille du mot
        for(i=0;i<cpt/2;i++) { // teste si le mot est palindrome
            if(ch[i] != ch[cpt-i-1])
                return 0;
        }
        return 1;
    }

    int main(){
        char ch[20];
        printf("donner la phrase a test%cr: ",130);
        gets(ch);
        int n=strlen(ch);
        int i=0, j=n-1;

        if(palind_recur(ch,i,j)==1)
            printf("\n VERSION RECURSIVE : le mot est palindrome ");
        else
            printf("\n VERSION RECURSIVE : le mot n'est pas palindrome ");

        if(palind_iter(ch)==1) printf("\n VERSION ITERATIVE : le mot est palindrome\n");
        else printf("\n VERSION ITERATIVE : le mot n'est pas palindrome\n");
        return 0; }
```

### d. Inverser une chaîne de caractères

```c
#include <string.h>
#include <stdio.h>

char inv[20];
int k=0;

char* inverser_recur(char ch[], int j){
    if(j== -1)
```
### c. Vérifier si une chaîne est palindromes

```c
#include <stdio.h>
#include <string.h>

int palind_recur(char ch[], int i, int j){

    if(i==j || i>j) //mot palindrome, longueur du mot impair i=j, pair i>j
        return 1;
    else{
        if(ch[i] != ch[j]) return -1;
        else
            i++;
        j--;
        return palind_recur(ch, i, j); //ou directement return palind_recur(ch, i+1, j-1);
    }

    int palind_iter(char ch[]){
        int i,cpt;
        cpt=strlen(ch); //la taille du mot
        for(i=0;i<cpt/2;i++) { // teste si le mot est palindrome
            if(ch[i] != ch[cpt-i-1])
                return 0;
        }
        return 1;
    }

    int main(){
        char ch[20];
        printf("donner la phrase a test%cr: ",130);
        gets(ch);
        int n=strlen(ch);
        int i=0, j=n-1;

        if(palind_recur(ch,i,j)==1)
            printf("\n VERSION RECURSIVE : le mot est palindrome ");
        else
            printf("\n VERSION RECURSIVE : le mot n'est pas palindrome ");

        if(palind_iter(ch)==1) printf("\n VERSION ITERATIVE : le mot est palindrome\n");
        else printf("\n VERSION ITERATIVE : le mot n'est pas palindrome\n");
        return 0;
    }
```

### d. Inverser une chaîne de caractères

```c
#include <string.h>
#include <stdio.h>

char inv[20];
int k=0;

char* inverser_recur(char ch[], int j){
    if(j== -1)
```
```c
return inv;
else{
    inv[k]=ch[j];
    k++;
    j--;
    return inverser_recur(ch,j);}}

void inverser_iter(char ch[]){
    int i, temp, n=strlen(ch);
    for(i=0;i<n/2;i++){
        temp=ch[i];
        ch[i]=ch[n-i-1];
        ch[n-i-1]=temp;}}

int main(){
    char ch[20];
    printf("\n Donnez la chaine : ");
    gets(ch);
    int n=strlen(ch);
    int i=0,j=n-1;
    printf("\n le resultat de l'inversion (recursivement) est : %s\n", inverser_recur(ch,j));
    inverser_iter(ch);
    printf("\n le resultat de l'inversion (iterativement) est : %s\n",ch );
    return 0;}
```

## e. Calculer le nième terme de Fibonacci

```c
#include <stdio.h>
int fibonacci_rec(int n) {
    if(n==0) return 0; //lorsqu'il y a un return la fonction s'arrête de s'exécuter
    if(n==1) return 1; //donc, inutile de mettre des else
    return fibonacci_rec(n-1) + fibonacci_rec(n-2);}

int fibonacci_iter(int n){
    int i, t1=0,t2=1,t3;
    if(n==0) return 0;
    if(n==1) return 1;
    for(i=0;i<n-1;i++){
        t3=t1+t2;
        t1=t2;
        t2=t3;}
    return t3;}

int main() {
    int n;
    printf("\n Donner le rang de l'element a calculer : ");
    scanf("%d", &n);
    printf("\n le terme %d de la suite est (iterativement): %d \n", n, fibonacci_iter(n));
    printf("\n le terme %d de la suite est (recursivement): %d \n", n, fibonacci_rec(n));
    return 0;}
```
```c
return inv;
else{
    inv[k]=ch[j];
    k++;
    j--;
    return inverser_recur(ch,j);}}

void inverser_iter(char ch[]){
    int i, temp, n=strlen(ch);
    for(i=0;i<n/2;i++){
        temp=ch[i];
        ch[i]=ch[n-i-1];
        ch[n-i-1]=temp;}}

int main() {
    char ch[20];
    printf("\n Donnez la chaine : ");
    gets(ch);
    int n=strlen(ch);
    int i=0,j=n-1;
    printf("\n le resultat de l'inversion (recursivement) est : %s\n", inverser_recur(ch,j));
    inverser_iter(ch);
    printf("\n le resultat de l'inversion (iterativement) est : %s\n",ch );
    return 0;}
```

## e. Calculer le nième terme de Fibonacci

```c
#include <stdio.h>
int fibonacci_rec(int n) {
    if(n==0) return 0; //lorsqu'il y a un return la fonction s'arrête de s'exécuter
    if(n==1) return 1; //donc, inutile de mettre des else
    return fibonacci_rec(n-1) + fibonacci_rec(n-2);}

int fibonacci_iter(int n){
    int i, t1=0,t2=1,t3;
    if(n==0) return 0;
    if(n==1) return 1;
    for(i=0;i<n-1;i++){
        t3=t1+t2;
        t1=t2;
        t2=t3;}
    return t3;}

int main() {
    int n;
    printf("\n Donner le rang de l'element a calculer : ");
    scanf("%d", &n);
    printf("\n le terme %d de la suite est (iterativement): %d \n", n, fibonacci_iter(n));
    printf("\n le terme %d de la suite est (recursivement): %d \n", n, fibonacci_rec(n));
    return 0;}
```
# Enregistrements ou Structures de données

## Rappel de quelques notions du cours:

Une structure (ou enregistrement) permet de regrouper plusieurs variables de types différents (appelées champs) et de leur donner un nom.

```c
//la structure comme un type
typedef struct { 
    type-1 champ-1 ;
    type-2 champ-2 ;
    ...
    type-n champ-n
} <nom du type de la structure>;
```

## Exemple :

```c
typedef struct {
    char Nom[20];
    int Age;
    float Taille; } personne ;

Main(){
    personne p1,p2; //2 personnes
    personne T[100]; //tableau de 100 personnes
}
```

Autre façon de déclarer une structure :
# Enregistrements ou Structures de données

## Rappel de quelques notions du cours:

Une structure (ou enregistrement) permet de regrouper plusieurs variables de types différents (appelées champs) et de leur donner un nom.

```c
//la structure comme un type
typedef struct { type-1 champ-1 ;
                  type-2 champ-2 ;
                  ...
                  type-n champ-n
              } <nom du type de la structure>;
```

## Exemple :

```c
typedef struct
{
    char Nom[20];
    int Age;
    float Taille; } personne ;

Main()
    personne p1,p2; //2 personnes
    personne T[100]; //tableau de 100 personnes
```

Autre façon de déclarer une structure :
```c
#include <stdio.h>
#include <string.h>

int main()
{
    struct Etudiant{
        // une seule structure
        char NomPrenom[30];
        char Matricule[10];
    };

    strcpy(E.NomPrenom, "Alili Ali");
    strcpy(E.Matricule, "002134");

    printf("\n Nom Prenom et Matricule d'un etudiant : \n");
    puts(E.NomPrenom);
    puts(E.Matricule);

    return 0;
}
```
```c
#include <stdio.h>
#include <string.h>

int main()
{
    struct Etudiant{
        // une seule structure
        char NomPrenom[30];
        char Matricule[10];
    };

    strcpy(E.NomPrenom, "Alili Ali");
    strcpy(E.Matricule, "002134");

    printf("\n Nom Prenom et Matricule d'un etudiant : \n");
    puts(E.NomPrenom);
    puts(E.Matricule);

    return 0;
}
```
## Exercice 1

Une menuiserie industrielle gère un stock de panneaux de bois. Chaque panneau possède une **largeur**, une **longueur** et une **épaisseur** en millimètres, ainsi que le **type de bois** qui peut être un pin (code 0), un chêne (code 1) ou un hêtre (code 2).

1) Définir une structure *panneau* contenant toutes les informations relatives à un panneau de bois

2) Ecrire les **fonctions de saisie et d'affichage** d'un panneau de bois (saisie numérique pour le type de bois (ex : 0), affichage en caractères du type de bois (ex : pin))

3) Ecrire **une fonction qui calcule le volume** en mètres cube d'un panneau ((épaisseur*largeur*longueur)/10⁹)

<figure><img src="image_6.png" /></figure>

## Solution Exercice 1

```c
#include <stdio.h>
#include <math.h>
#include <windows.h>
typedef struct panneau{
    float largeur, longueur, epaisseur;
    int typeBois; }panneau;

panneau saisie(){
    panneau p;
    printf("\n Entrer la largeur du panneau : ");
    scanf("%f",&plargeur);
    printf("\n Entrer la longueur du panneau : ");
    scanf("%f",&plongueur);
    printf("\n Entrer l'epaisseur du panneau : ");
    scanf("%f",&pepaisseur);
    printf("\n donner le type de bois : ");
    scanf("%d", &p.typeBois);
    return p;}
```
Exercice 1

Une menuiserie industrielle gère un stock de panneaux de bois. Chaque panneau possède une **largeur**, une **longueur** et une **épaisseur** en millimètres, ainsi que **le type de bois** qui peut être un pin (code 0), un chêne (code 1) ou un hêtre (code 2).

1) Définir une structure *panneau* contenant toutes les informations relatives à un panneau de bois

2) Ecrire les **fonctions de saisie et d'affichage** d'un panneau de bois (saisie numérique pour le type de bois (ex : 0), affichage en caractères du type de bois (ex : pin))

3) Ecrire **une fonction qui calcule le volume** en mètres cube d'un panneau
((épaisseur*largeur*longueur)/10⁹)

<figure><img src="image_6.png" /></figure>

Solution Exercice 1

```cpp
#include <stdio.h>
#include <math.h>
#include <windows.h>
typedef struct panneau{
    float largeur, longueur, epaisseur;
    int typeBois; }panneau;

panneau saisie(){
    panneau p;
    printf("\n Entrer la largeur du panneau : ");
    scanf("%f",&plargeur);
    printf("\n Entrer la longueur du panneau : ");
    scanf("%f",&plongueur);
    printf("\n Entrer l'epaisseur du panneau : ");
    scanf("%f",&pepaisseur);
    printf("\n donner le type de bois : ");
    scanf("%d", &p.typeBois);
    return p;}
```
```c
void affichage(panneau p){
    printf("\n largeur du panneau : %.2f", p.largeur );
    printf("\n longueur du panneau : %.2f", p.longueur );
    printf("\n epaisseur du panneau : %.2f", p.epaisseur );
    printf("\n type de bois : ");
    switch(p.typeBois){
        case 0: printf("pin\n");
                break;
        case 1: printf("chene\n");
                break;
        case 2: printf("hetre\n");
                break;
        default: printf("inconnu\n");
                break ;}
}
float volume(panneau p){
    return (p.largeur*p.longueur*p.epaisseur)/pow(10,9);
}

int main(){
    system("color F0");
    panneau p=saisie();
    affichage(p);
    printf("\n le volume du panneau est : %.2f metres cube\n", volume(p));
    return 0;}
```

## Exercice 2

Considérons les structures suivantes :

* Date définie par trois champs jour, mois et année
* Adresse définie par Numero, Rue, Commune, Wilaya, CodePostal
* Employé définie par NomPrenom, Residence, DateNaissance

1) Ecrire une fonction Employé SaisirEmployé() qui permet de saisir les informations d'un employé à partir du clavier.

2) Ecrire une fonction ... AnneeNaissance(...) qui permet de vérifier si un employé est né avant une année donnée.

3) Ecrire une fonction ... WilayaResidence(...) qui permet de vérifier si un employé est résidant dans une wilaya donnée.

4) En utilisant les fonctions ci-dessus, écrire un programme qui permet de :

a) Remplir un tableau appelé Département de N éléments de type Employé, avec N <= 100.

b) Afficher les noms et prénoms des employés résidants dans une wilaya donnée et nés avant une année donnée.
```c
void affichage(panneau p){
    printf("\n largeur du panneau : %.2f", plargeur );
    printf("\n longueur du panneau : %.2f", plongueur );
    printf("\n epaisseur du panneau : %.2f", pepaisseur );
    printf("\n type de bois : ");
    switch(p.typeBois){
        case 0: printf("pin\n");
                break;
        case 1: printf("chene\n");
                break;
        case 2: printf("hetre\n");
                break;
        default: printf("inconnu\n");
                break ;}
}
float volume(panneau p){
    return (plargeur*plongueur*pepaisseur)/pow(10,9);
}

int main(){
    system("color F0");
    panneau p=saisie();
    affichage(p);
    printf("\n le volume du panneau est : %.2f metres cube\n", volume(p));
    return 0;}
```

## Exercice 2

Considérons les structures suivantes :

* Date définie par trois champs jour, mois et année
* Adresse définie par Numero, Rue, Commune, Wilaya, CodePostal
* Employé définie par NomPrenom, Residence, DateNaissance

1) Ecrire une fonction Employé SaisirEmployé() qui permet de saisir les informations d'un employé à partir du clavier.

2) Ecrire une fonction ... AnneeNaissance(...) qui permet de vérifier si un employé est né avant une année donnée.

3) Ecrire une fonction ... WilayaResidence(...) qui permet de vérifier si un employé est résidant dans une wilaya donnée.

4) En utilisant les fonctions ci-dessus, écrire un programme qui permet de :

a) Remplir un tableau appelé Département de N éléments de type Employé, avec N <= 100.

b) Afficher les noms et prénoms des employés résidants dans une wilaya donnée et nés avant une année donnée.
Solution Exercice 2

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
    int jour, mois, annee;
} Date;
typedef struct {
    int Numero, CodePostal;
    char Rue[10], Commune[20], Wilaya[20];
} Adresse;
typedef struct {
    char Nom[20], Prenom[15];
} NP;
typedef struct {
    NP NomPrenom;
    Date DateNaissance;
    Adresse Residence;
} Employe;
Employe E;
Employe saisirEmploye() {
    printf("\n Nom de l'employe : ");
    scanf("%s", E.NomPrenom.Nom );
    printf("\n Prenom de l'employe : ");
    scanf("%s", E.NomPrenom.Prenom );
    printf("\n Date de naissance : \n");
    printf("Jour : ");
    scanf("%d", &E.DateNaissance.jour );
    printf("\n Mois : ");
    scanf("%d", &E.DateNaissance.mois );
    printf("\n Annee : ");
    scanf("%d", &E.DateNaissance.annee );
    printf("\n Residence de l'employe : \n");
    printf("Numero : ");
    scanf("%d", &E.Residence.Numero );
    printf("\nRue : ");
    scanf("%s", E.Residence.Rue );
    printf("\nCommune : ");
    scanf("%s", E.Residence.Commune );
    printf("\nWilaya : ");
    scanf("%s", E.Residence.Wilaya );
    printf("\nCode Postal : ");
    scanf("%d", &E.Residence.CodePostal );
    return (E);
}

/*int AnneeNaissance(int a) { //pour répondre à la question 2
    if(E.DateNaissance.annee<a)
        return 1;
```
Solution Exercice 2

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
    int jour, mois, annee;
} Date;
typedef struct {
    int Numero, CodePostal;
    char Rue[10], Commune[20], Wilaya[20];
} Adresse;
typedef struct {
    char Nom[20], Prenom[15];
} NP;
typedef struct {
    NP NomPrenom;
    Date DateNaissance;
    Adresse Residence;
} Employe;
Employe E;
Employe saisirEmploye() {
    printf("\n Nom de l'employe : ");
    scanf("%s", E.NomPrenom.Nom );
    printf("\n Prenom de l'employe : ");
    scanf("%s", E.NomPrenom.Prenom );
    printf("\n Date de naissance : \n");
    printf("Jour : ");
    scanf("%d", &E.DateNaissance.jour );
    printf("\n Mois : ");
    scanf("%d", &E.DateNaissance.mois );
    printf("\n Annee : ");
    scanf("%d", &E.DateNaissance.annee );
    printf("\n Residence de l'employe : \n");
    printf("Numero : ");
    scanf("%d", &E.Residence.Numero );
    printf("\nRue : ");
    scanf("%s", E.Residence.Rue );
    printf("\nCommune : ");
    scanf("%s", E.Residence.Commune );
    printf("\nWilaya : ");
    scanf("%s", E.Residence.Wilaya );
    printf("\nCode Postal : ");
    scanf("%d", &E.Residence.CodePostal );
    return (E);
}

/*int AnneeNaissance(int a) { //pour répondre à la question 2
    if(E.DateNaissance.annee<a)
        return 1;
```
```c
else
    return -1;
}
*/
/*
int WilayaResidence(char w[]) { // pour répondre à la question 3
    if strCMP(E.Residence.Wilaya, w) == 0)
        return 1;
    else
        return -1;
}
*/
int AnneeNaissance(Employe D[], int i, int aa) {
    if(D[i].DateNaissance.annee < aa)
        return (1);
    else
        return (-1);
}
int WilayaResidence(Employe D[], int i, char w[]) {
    if strCMP(D[i].Residence.Wilaya, w) == 0)
        return (1);
    else
        return (-1);
}
int main() {
    /* ici on répond à la Q1,2,3
       saisirEmploye();
    */
    int x = 1984;
    if (AnneeNaissance(x) == 1)
        printf("\n cet employe est ne avant l'annee %d ", x);
    else
        printf("\n cet employe est ne apres l'annee %d ", x);
    char w[] = "ALGER";
    if (WilayaResidence(w) == 1)
        printf("\n cet employe est residant dans la wilaya %s ", w);
    else
        printf("\n cet employe n'est pas residant dans la wilaya %s ", w);
}
 Employe Departement[100]; // ici on répond à la question 4
int i, n;
printf("\n Donner le nombre d'employes ");
scanf("%d", &n);
for (i = 0; i < n; i++) {
    Departement[i] = saisirEmploye(); // Q4.a
}
int aa = 1984;
char ww[] = "ALGER";
// strcpy(ww, "ALGER");
printf("\n les employes sont: \n");
for (i = 0; i < n; i++) {
```
```c
else
    return -1;
}
*/
/*
int WilayaResidence(char w[]) { // pour répondre à la question 3
    if strCMP(E.Residence.Wilaya, w) == 0)
        return 1;
    else
        return -1;
}
*/
int AnneeNaissance(Employe D[], int i, int aa) {
    if(D[i].DateNaissance.annee < aa)
        return (1);
    else
        return (-1);
}
int WilayaResidence(Employe D[], int i, char w[]) {
    if strCMP(D[i].Residence.Wilaya, w) == 0)
        return (1);
    else
        return (-1);
}
int main() {
    /* ici on répond à la Q1,2,3
        saisirEmploye();
    */
    int x = 1984;
    if (AnneeNaissance(x) == 1)
        printf("\n cet employe est ne avant l'annee %d ", x);
    else
        printf("\n cet employe est ne apres l'annee %d ", x);
    char w[] = "ALGER";
    if (WilayaResidence(w) == 1)
        printf("\n cet employe est residant dans la wilaya %s ", w);
    else
        printf("\n cet employe n'est pas residant dans la wilaya %s ", w);
}
 Employe Departement[100]; // ici on répond à la question 4
int i, n;
printf("\n Donner le nombre d'employes ");
scanf("%d", &n);
for (i = 0; i < n; i++) {
    Departement[i] = saisirEmploye(); // Q4.a
}
int aa = 1984;
char ww[] = "ALGER";
// strcpy(ww, "ALGER");
printf("\n les employes sont: \n");
for (i = 0; i < n; i++) {
```
```c
if(AnneeNaissance(Departement, i, aa==1 && WilayaResidence(Departement, i,
ww==1) { // Q4.b
    printf("\n Nom : %s", Departement[i].NomPrenom.Nom);
    printf("\n Prenom : %s", Departement[i].NomPrenom.Prenom);
})
return 0;}
```

## Exercice 3

(pour cet exercice le choix d'utiliser des fonctions, est laissé à l'appréciation de chaque programmeur):

Une **Carte Chifa** est définie par :

* NumSC : numéro de sécurité sociale de l'assuré;

* NomAss : le nom de l'assuré ;

* PrenomAss : le prénom de l'assuré ;

* DateNaissAss : la date de naissance de l'assuré (jj/mm/aaaa) ;

* PourcentRemb : le pourcentage de remboursement, exemple 0,8 pour 80%.

Un **Médicament** est défini par :

* NomMedic : le nom du médicament ;

* PrixMedic : le prix unitaire du médicament ;

* QteMedic : la quantité du médicament (le nombre de boites).

1) Définir la structure de la **Carte Chifa** et la structure du **Médicament**,

2) Saisir et Afficher les données d'une **Carte Chifa**

3) Saisir les Médicaments d'une Ordonnance dans un Tableau (Medoc), le nombre de médicament (nbremedic) de l'ordonnance étant donné.

4) Calculer le montant à payer pour une ordonnance. Sachant que :
Le Montant à payer = Montant Total de l'ordonnance – Montant de Remboursement.

## Solution Exercice 3

```c
#include <stdio.h>
#include <stdlib.h>
typedef struct Date{
    int jour, mois, annee;
}Date;
typedef struct CartteChifa{
    char NumSC[12];
    char NomAss[20], PrenomAss[20];
    Date DateNaissAss;
    float PourcentRemb; //exemple 0.8 pour 80%
}CarteChifa;
typedef struct Medicament{
    char NomMedic[20];
```
```c
if(AnneeNaissance(Departement, i, aa==1 && WilayaResidence(Departement, i,
ww==1) { // Q4.b
    printf("\n Nom : %s", Departement[i].NomPrenom.Nom);
    printf("\n Prenom : %s", Departement[i].NomPrenom.Prenom);
})
return 0;}
```

## Exercice 3

(pour cet exercice le choix d'utiliser des fonctions, est laissé à l'appréciation de chaque programmeur):

Une **Carte Chifa** est définie par :

* NumSC : numéro de sécurité sociale de l'assuré;

* NomAss : le nom de l'assuré ;

* PrenomAss : le prénom de l'assuré ;

* DateNaissAss : la date de naissance de l'assuré (jj/mm/aaaa) ;

* PourcentRemb : le pourcentage de remboursement, exemple 0,8 pour 80%.

Un **Médicament** est défini par :

* NomMedic : le nom du médicament ;

* PrixMedic : le prix unitaire du médicament ;

* QteMedic : la quantité du médicament (le nombre de boites).

1) Définir la structure de la **Carte Chifa** et la structure du **Médicament**,

2) Saisir et Afficher les données d'une **Carte Chifa**

3) Saisir les Médicaments d'une Ordonnance dans un Tableau (Medoc), le nombre de médicament (nbremedic) de l'ordonnance étant donné.

4) Calculer le montant à payer pour une ordonnance. Sachant que :
Le Montant à payer = Montant Total de l'ordonnance – Montant de Remboursement.

## Solution Exercice 3

```c
#include <stdio.h>
#include <stdlib.h>
typedef struct Date{
    int jour, mois, annee;
}Date;
typedef struct CartteChifa{
    char NumSC[12];
    char NomAss[20], PrenomAss[20];
    Date DateNaissAss;
    float PourcentRemb; //exemple 0.8 pour 80%
}CarteChifa;
typedef struct Medicament{
    char NomMedic[20];
```
float PrixMedic;
int QteMedic;
}Medicament;
void affichage(CarteChifa Carte){
printf("\n Affichage des donnees de la carte chifa pour verification : \n");
printf("\n le numero de securite sociale: %s ", Carte.NumSC);
printf("\n le nom de l'assure: %s ", Carte.NomAss);
printf("\n le prenom de l'assure: %s ", Carte.PrenomAss);
printf("\n la date de naissance de l'assure : %d/%d/%d ", Carte.DateNaissAss.jour,
Carte.DateNaissAss.mois, Carte.DateNaissAss.annee);
printf("\n le pourcentage de remboursement: %.2f ", Carte.PourcentRemb);
printf("\n"); }
int main(){
CarteChifa Carte;
Medicament Medoc[10];
float S, PrixFinal;
int i, nbremedic;
printf("\n **************** SAISIE DES DONNEES DE LA CARTE CHIFFA
********************* \n");
printf("\n Donnez le numero de securite sociale: "); scanf("%s", Carte.NumSC);
printf("\n Donnez le nom de l'assure: "); scanf("%s", Carte.NomAss);
printf("\n Donnez le prenom de l'assure: "); scanf("%s", Carte.PrenomAss);
printf("\n Donnez le jour de naissance: "); scanf("%d", &Carte.DateNaissAss.jour);
printf("\n Donnez le mois de naissance: "); scanf("%d", &Carte.DateNaissAss.mois);
printf("\n Donnez l'annee : "); scanf("%d", &Carte.DateNaissAss.annee);
printf("\n Donnez le pourcentage de remboursement: "); scanf("%f", &Carte.PourcentRemb);
affichage(Carte);
printf("\n **************** SAISIE DES DONNEES DE L'ORDONNANCE
********************** \n");
printf("\n Donner le nombre de medicaments : ");
scanf("%d", &nbremedic);
for(i=0; i<nbremedic; i++){
printf("\n Donner le nom du medicament : ");
scanf("%s", Medoc[i].NomMedic);
printf("\n Donner le prix du medicament : ");
scanf("%f", &Medoc[i].PrixMedic);
printf("\n Donner la quantite du medicament : ");
scanf("%d", &Medoc[i].QteMedic); }
S=0;
for(i=0; i<nbremedic; i++){
S=S+ Medoc[i].PrixMedic * Medoc[i].QteMedic; }
PrixFinal=S-(S* Carte.PourcentRemb);
printf("\n\n le prix a payer est : %.2f \n", PrixFinal);
return 0;}
float PrixMedic;
int QteMedic;
}Medicament;
void affichage(CarteChifa Carte){
printf("\n Affichage des donnees de la carte chifa pour verification : \n");
printf("\n le numero de securite sociale: %s ", Carte.NumSC);
printf("\n le nom de l'assure: %s ", Carte.NomAss);
printf("\n le prenom de l'assure: %s ", Carte.PrenomAss);
printf("\n la date de naissance de l'assure : %d/%d/%d ", Carte.DateNaissAss.jour,
Carte.DateNaissAss.mois, Carte.DateNaissAss.annee);
printf("\n le pourcentage de remboursement: %.2f ", Carte.PourcentRemb);
printf("\n"); }
int main(){
CarteChifa Carte;
Medicament Medoc[10];
float S, PrixFinal;
int i, nbremedic;
printf("\n **************** SAISIE DES DONNEES DE LA CARTE CHIFFA
********************* \n");
printf("\n Donnez le numero de securite sociale: "); scanf("%s", Carte.NumSC);
printf("\n Donnez le nom de l'assure: "); scanf("%s", Carte.NomAss);
printf("\n Donnez le prenom de l'assure: "); scanf("%s", Carte.PrenomAss);
printf("\n Donnez le jour de naissance: "); scanf("%d", &Carte.DateNaissAss.jour);
printf("\n Donnez le mois de naissance: "); scanf("%d", &Carte.DateNaissAss.mois);
printf("\n Donnez l'annee : "); scanf("%d", &Carte.DateNaissAss.annee);
printf("\n Donnez le pourcentage de remboursement: "); scanf("%f", &Carte.PourcentRemb);
affichage(Carte);
printf("\n **************** SAISIE DES DONNEES DE L'ORDONNANCE
********************** \n");
printf("\n Donner le nombre de medicaments : ");
scanf("%d", &nbremedic);
for(i=0; i<nbremedic; i++){
printf("\n Donner le nom du medicament : ");
scanf("%s", Medoc[i].NomMedic);
printf("\n Donner le prix du medicament : ");
scanf("%f", &Medoc[i].PrixMedic);
printf("\n Donner la quantite du medicament : ");
scanf("%d", &Medoc[i].QteMedic); }
S=0;
for(i=0; i<nbremedic; i++){
S=S+ Medoc[i].PrixMedic * Medoc[i].QteMedic; }
PrixFinal=S-(S* Carte.PourcentRemb);
printf("\n\n le prix a payer est : %.2f \n", PrixFinal);
return 0;}
# Listes Chainées

## Rappel de quelques notions du cours:

### Déclaration d'une liste simplement chainée

<figure><img src="image_7.png" /></figure>

<figure><img src="image_8.png" /></figure>

### Accès à un élément d'une liste et création d'un nœud

<figure><img src="image_9.png" /></figure>

<figure><img src="image_10.png" /></figure>

### Parcours d'une liste :

<figure><img src="image_11.png" /></figure>
# Listes Chainées

## Rappel de quelques notions du cours:

### Déclaration d'une liste simplement chainée

<figure><img src="image_7.png" /></figure>

<figure><img src="image_8.png" /></figure>

### Accès à un élément d'une liste et création d'un nœud

<figure><img src="image_9.png" /></figure>

<figure><img src="image_10.png" /></figure>

### Parcours d'une liste :

<figure><img src="image_11.png" /></figure>
Attention, les files et les piles sont des cas particuliers de listes chainées, avec les contraintes d'ajout et de suppression suivantes:

Les piles (dernier arrivé, premier traité) :

* ajout/suppression au sommet de pile LIFO

Stacks

Les files (premier arrivé, premier traité) :

* ajout en **queue** de file
* suppression en **tête** de file

Queues

Les listes chaînées (ordre non chronologique) :

Chained

* accès par une **tête** de liste
* ajout/suppression n'importe où dans la liste

Lists

Exercice Arithmétique des Pointeurs

Soit le programme suivant : Quel sera le résultat de son exécution ?

```c
#include <stdio.h>
#include <windows.h>
int main()
{
    system("color F0");
    int *p;
    int A[5]={11,22,33,44,55};
    p=A;
    printf("\n *p = %u", *p);
    printf("\n ++*p = %u", ++*p);
    printf("\n *p = %u", *p);
    printf("\n");
    printf("\n *p = %u", *p);
    printf("\n *++p = %u", *++p);
    printf("\n *p = %u", *p);
    printf("\n");
    printf("\n *p = %u", *p);
    printf("\n *p++ = %u", *p++);
    printf("\n *p = %u", *p);
    printf("\n");
    printf("\n *p = %u", *p);
    printf("\n (*p)++ = %u et *p = %u", ((*p)++), *p);
    printf("\n *p = %u", *p);
    return 0;}
```
Attention, les files et les piles sont des cas particuliers de listes chainées, avec les contraintes d'ajout et de suppression suivantes:

Les piles (dernier arrivé, premier traité) :

* ajout/suppression au sommet de pile LIFO
Stacks

Les files (premier arrivé, premier traité) :

* ajout en **queue** de file
* suppression en **tête** de file
* FIFO

Les listes chaînées (ordre non chronologique) :
Chained

* accès par une **tête** de liste
* ajout/suppression n'importe où dans la liste

Exercice Arithmétique des Pointeurs

Soit le programme suivant : Quel sera le résultat de son exécution ?

```c
#include <stdio.h>
#include <windows.h>
int main()
{
    system("color F0");
    int *p;
    int A[5]={11,22,33,44,55};
    p=A;
    printf("\n *p = %u", *p);
    printf("\n ++*p = %u", ++*p);
    printf("\n *p = %u", *p);
    printf("\n");
    printf("\n *p = %u", *p);
    printf("\n *++p = %u", *++p);
    printf("\n *p = %u", *p);
    printf("\n");
    printf("\n *p = %u", *p);
    printf("\n *p++ = %u", *p++);
    printf("\n *p = %u", *p);
    printf("\n");
    printf("\n *p = %u", *p);
    printf("\n (*p)++ = %u et *p = %u", ((*p)++), *p);
    printf("\n *p = %u", *p);
    return 0;}
```
<figure><img src="image_12.png" /></figure>

"D:\C FILES\ArithmeticDesPointeurs.exe"

*p = 11
*++*p = 12
*p = 12

*p = 12
*++*p = 22
*p = 22

*p = 22
*p++ = 22
*p = 33

*p = 33
(*p)++ = 33 et *p = 33
*p = 34

Process returned 0 (0x0) execution time : 2.688 s
Press any key to continue.

Exercice Listes Chainées :

#include <stdio.h>

#include <stdlib.h> //pour l'allocation dynamique : malloc(), calloc(), exit()

//déclaration du type d'un élément d'une liste, ici, elt, contenant deux champs un entier val et un
pointeur vers l'élément suivant (la déclaration doit se faire en dehors de toutes les fonctions).

struct element {
    int val;
    struct element *suivant;
};

};

typedef struct element elt;

int main(){

elt *liste; //déclaration d'une liste de type elt

liste=NULL; //initialisation de la liste, à ce stade la liste est vide

//ici, faire l'appel des fonctions

return 0 ;}

A faire: Ecrire les fonctions qui permettent:

* d'Ajouter un élément en **fin** de liste, répéter cette opération plusieurs fois dans le main()
pour remplir la liste(comme dans les files).

* de Supprimer un élément en fin de liste
<figure><img src="image_12.png" /></figure>

"D:\C FILES\ArithmeticDesPointeurs.exe"

*p = 11
*++*p = 12
*p = 12

*p = 12
*++*p = 22
*p = 22

*p = 22
*p++ = 22
*p = 33

*p = 33
(*p)++ = 33 et *p = 33
*p = 34

Process returned 0 (0x0) execution time : 2.688 s
Press any key to continue.

Exercice Listes Chainées :

#include <stdio.h>

#include <stdlib.h> //pour l'allocation dynamique : malloc(), calloc(), exit()

//déclaration du type d'un élément d'une liste, ici, elt, contenant deux champs un entier val et un
pointeur vers l'élément suivant (la déclaration doit se faire en dehors de toutes les fonctions).

struct element {
    int val;
    struct element *suivant;
}

};

typedef struct element elt;

int main(){

elt *liste; //déclaration d'une liste de type elt

liste=NULL; //initialisation de la liste, à ce stade la liste est vide

//ici, faire l'appel des fonctions

return 0 ;}

A faire: Ecrire les fonctions qui permettent:

* d'Ajouter un élément en **fin** de liste, répéter cette opération plusieurs fois dans le main()
pour remplir la liste(comme dans les files).

* de Supprimer un élément en fin de liste
* de Rechercher un élément dans une liste et de retourner sa **position** ou son rang

* de retourner la **Taille** d'une liste (le nombre d'éléments de la liste)

**Remarque** : Afficher le contenu de la liste avec les adresses des différents nœuds après chaque opération (écrire une fonction d'affichage pour cela).

```
Affichage apres insertion de plusieurs elements en fin de liste

l'element 0 de la liste est : 11 , son adresse : 7083536
l'element 1 de la liste est : 22 , son adresse : 7083552
l'element 2 de la liste est : 33 , son adresse : 7088880
l'element 3 de la liste est : 44 , son adresse : 7088896
l'element 4 de la liste est : 55 , son adresse : 7088912
l'element 5 de la liste est : 66 , son adresse : 7088928
l'element 6 de la liste est : 77 , son adresse : 7088944
Affichage apres suppression de la queue de liste

l'element 0 de la liste est : 11 , son adresse : 7083536
l'element 1 de la liste est : 22 , son adresse : 7083552
l'element 2 de la liste est : 33 , son adresse : 7088880
l'element 3 de la liste est : 44 , son adresse : 7088896
l'element 4 de la liste est : 55 , son adresse : 7088912
l'element 5 de la liste est : 66 , son adresse : 7088928
Donner l'element a rechercher : 44
l'element recherche se trouve a la position 4 dans la liste

la taille de la liste est : 6
Process returned 0 (0x0) execution time : 3.141 s
Press any key to continue.
```

## Corrigé Exercice Listes Chainées

1. Insertion en fin de liste :

```c
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

//déclarations
struct element{
    int val;
    struct element *suivant;
};
typedef struct element elt;
```
* de Rechercher un élément dans une liste et de retourner sa **position** ou son rang

* de retourner la **Taille** d'une liste (le nombre d'éléments de la liste)

**Remarque** : Afficher le contenu de la liste avec les adresses des différents nœuds après chaque opération (écrire une fonction d'affichage pour cela).

Affichage apres insertion de plusieurs elements en fin de liste

l'element 0 de la liste est : 11 , son adresse : 7083536

l'element 1 de la liste est : 22 , son adresse : 7083552

l'element 2 de la liste est : 33 , son adresse : 7088880

l'element 3 de la liste est : 44 , son adresse : 7088896

l'element 4 de la liste est : 55 , son adresse : 7088912

l'element 5 de la liste est : 66 , son adresse : 7088928

l'element 6 de la liste est : 77 , son adresse : 7088944

Affichage apres suppression de la queue de liste

l'element 0 de la liste est : 11 , son adresse : 7083536

l'element 1 de la liste est : 22 , son adresse : 7083552

l'element 2 de la liste est : 33 , son adresse : 7088880

l'element 3 de la liste est : 44 , son adresse : 7088896

l'element 4 de la liste est : 55 , son adresse : 7088912

l'element 5 de la liste est : 66 , son adresse : 7088928

Donner l'element a rechercher : 44

l'element recherche se trouve a la position 4 dans la liste

la taille de la liste est : 6

Process returned 0 (0x0) execution time : 3.141 s

Press any key to continue.

## Corrigé Exercice Listes Chainées

1. Insertion en fin de liste :

#include <stdio.h>

#include <stdlib.h>

#include <windows.h>

//déclarations

struct element{

int val;

struct element *suivant;

};

typedef struct element elt;
//fonction insertion en début de liste

elt* insertionFin(int contenu, elt *l){
    elt *nouveau, *precedent, *courant;
    nouveau=(elt*)malloc(sizeof(elt));
    if(!nouveau){
        printf("\n erreur d'allocation..\n");
        exit(-1);
    }

    nouveau->val=contenu;
    nouveau->suivant=NULL;

//cas de la liste vide
if(l==NULL){
    l=nouveau;
}

else{
    courant=l;
    while(courant!=NULL){
        precedent=courant; //pour garder trace du dernier élément
courant=courant->suivant;
    }
    precedent->suivant=nouveau;
}

}

return l;
}

//fonction affichage des elements de la liste avec leurs adresses respectives

void Affichage(elt *l){

int i=0;
elt *p;
for(p=l;p!=NULL; p=p->suivant){

printf("\n l'element %d de la liste est : %d , son adresse : %d \n", i, p->val, p);
i++;

}

// Fonction de suppression d'un élément en fin de liste

elt* supprimerFin(elt *l){

elt *courant, *precedent;
courant=l;

while(courant->suivant!=NULL){
    precedent=courant;
//fonction insertion en début de liste

elt* insertionFin(int contenu, elt *l){
    elt *nouveau, *precedent, *courant;
    nouveau=(elt*)malloc(sizeof(elt));
    if(!nouveau){
        printf("\n erreur d'allocation..\n");
        exit(-1);
    }

    nouveau->val=contenu;
    nouveau->suivant=NULL;

    //cas de la liste vide
    if(l==NULL){
        l=nouveau;
    }

    else{
        courant=l;
        while(courant!=NULL){
            precedent=courant; //pour garder trace du dernier élément
courant=courant->suivant;
        }

        precedent->suivant=nouveau;
    }

    return l;
}

//fonction affichage des elements de la liste avec leurs adresses respectives

void Affichage(elt *l){

int i=0;

elt *p;

for(p=l;p!=NULL; p=p->suivant){

printf("\n l'element %d de la liste est : %d , son adresse : %d \n", i, p->val, p);
i++;

}

}

// Fonction de suppression d'un élément en fin de liste

elt* supprimerFin(elt *l){

elt *courant, *precedent;

courant=l;

while(courant->suivant!=NULL){
    precedent=courant;
}
courant=courant->suivant;
}
precedent->suivant=NULL; //l'élément à supprimer est en fin de liste
free(courant);

return 1;
}

//Fonction qui retourne la position de l'élément recherché

int recherche(elt *l, int w)

elt *p;
p=l;
int i=1;

while(p)

if(p->val==w){
    return i;
}

p=p->suivant;
i++;

} return 0;

}

int taille_liste(elt *l)

elt *p;
p=l;
int i=0;

while(p)

p=p->suivant;
i++;

return i;

}

system("color F0");

elt *liste;
liste=NULL;

liste=insertionFin(11,liste);
liste=insertionFin(22,liste);
liste=insertionFin(33,liste);
courant=courant->suivant;
}
precedent->suivant=NULL; //l'élément à supprimer est en fin de liste
free(courant);

return 1;
}

//Fonction qui retourne la position de l'élément recherché

int recherche(elt *l, int w)

elt *p;
p=l;
int i=1;

while(p)

if(p->val==w){
    return i;
}

p=p->suivant;
i++;

} return 0;

}

int taille_liste(elt *l)

elt *p;
p=l;
int i=0;

while(p)

p=p->suivant;
i++;

return i;

}

int main(){

system("color F0");

elt *liste;
liste=NULL;

liste=insertionFin(11,liste);
liste=insertionFin(22,liste);
liste=insertionFin(33,liste);
liste=insertionFin(44,liste);

liste=insertionFin(55,liste);

liste=insertionFin(66,liste);

liste=insertionFin(77,liste);

printf("\n Affichage apres insertion de plusieurs elements en fin de liste \n\n");

Affichage(liste);

liste=supprimerFin(liste);

printf("\n Affichage apres suppression de la queue de liste \n\n");

Affichage(liste);

int x;

printf("\n Donner l'element a rechercher : ");

scanf("%d", &x);

if(recherche(liste,x)==0)

printf("\n\n l'element recherche n'existe pas dans la liste \n\n");

else

printf("\n l'element recherche se trouve a la position %d dans la liste \n\n",
recherche(liste,x));

printf("\n la taille de la liste est : %d \n",taille_liste(liste));

return 0;

}
liste=insertionFin(44,liste);
liste=insertionFin(55,liste);
liste=insertionFin(66,liste);
liste=insertionFin(77,liste);

printf("\n Affichage apres insertion de plusieurs elements en fin de liste \n\n");

Affichage(liste);

liste=supprimerFin(liste);

printf("\n Affichage apres suppression de la queue de liste \n\n");
Affichage(liste);

int x;

printf("\n Donner l'element a rechercher : ");

scanf("%d", &x);

if(recherche(liste,x)==0)

printf("\n\n l'element recherche n'existe pas dans la liste \n\n");

else

printf("\n l'element recherche se trouve a la position %d dans la liste \n\n",
recherche(liste,x));

printf("\n la taille de la liste est : %d \n",taille_liste(liste));

return 0;

}
# Fichiers

## Rappel de quelques notions de cours :

Fichier: stocke des données sur un support permanent. Il y a 2 types de fichiers: binaire (lu et écrit via un programme), texte (lu et écrit à partir d'un éditeur de texte), c'est un cas particulier du fichier binaire.

Un Fichier possède un nom externe ou physique (lecteur-repertoire-nom-extension) et un nom interne au Fichier: nom logique (nom utilisé à l'intérieur du programme).

L'association entre les deux noms se fait avec la fonction: fopen, Nom_logique=fopen(nomphysique, mode)

## Déclaration d'un fichier : FILE *Nom_Fichier

## Exemple d'ouverture et de fermeture d'un fichier :

```c
void main(void)
{
    char Nom[13]; /* taille du nom physique du fichier */
    FILE* fic;
    printf("Entrez le nom du fichier (8 lettres maxi + extension): ");
    scanf("%12s", Nom);
    fic = fopen( Nom, "wt"); /* le fichier (texte) est créé en vue d'une écriture en accès texte */
    if ( fic==NULL )
    {
        printf("\n\n Ouverture du fichier impossible !");
        exit(0);          /*exit(0) EXIT_SUCCESS, exit(1) EXIT_FAILURE */
    }
    fclose( fic ); /* fermeture du fichier quand il n'est plus utile */
}
```
# Fichiers

## Rappel de quelques notions de cours :

Fichier: stocke des données sur un support permanent. Il y a 2 types de fichiers: binaire (lu et écrit via un programme), texte (lu et écrit à partir d'un éditeur de texte), c'est un cas particulier du fichier binaire.

Un Fichier possède un nom externe ou physique (lecteur-repertoire-nom-extension) et un nom interne au Fichier: nom logique (nom utilisé à l'intérieur du programme).

L'association entre les deux noms se fait avec la fonction: fopen, Nom_logique=fopen(nom, mode)

## Déclaration d'un fichier : FILE *Nom_Fichier

## Exemple d'ouverture et de fermeture d'un fichier :

```c
void main(void)
{
    char Nom[13]; /* taille du nom physique du fichier */
    FILE* fic;
    printf("Entrez le nom du fichier (8 lettres maxi + extension): ");
    scanf("%12s", Nom);
    fic = fopen( Nom, "wt"); /* le fichier (texte) est créé en vue d'une écriture en accès texte */
    if ( fic==NULL )
    {
        printf("\n\n Ouverture du fichier impossible !");
        exit(0);          /*exit(0) EXIT_SUCCESS, exit(1) EXIT_FAILURE */
    }
    fclose( fic ); /* fermeture du fichier quand il n'est plus utile */
}
```
Exercice Fichiers :

1) Ouvrir le traitement de texte bloc-notes et nommer le fichier « texte.txt », sauvegardez-
le sur le lecteur D, donc le nom physique est : « d:\texte.txt ». Saisir dedans du texte,
Les lignes seront supposées ne jamais comporter plus de 80 caractères. Puis, écrire un
programme permettant d'afficher le contenu de ce fichier texte.

<figure><img src="image_13.png" /></figure>

2) Ecrire un programme permettant de créer un **fichier d'enregistrements (binaire)** du personnel (par exemple, « d:\\personnel.dat<fnref n="1" /> »), comportant pour chaque employé :

• Nom (20 caractères maximum),

• Prénom (20 caractères maximum),

• Age (entier),

• Tel (12 caractères maximum).

Le programme devra permettre :

• La saisie des informations de n employés (n donné par l'utilisateur)

• L'affichage des informations de n employés.

* L'affichage des informations correspondant à un employé de Nom donné par l'utilisateur.

<footnote n="1">¹ Peu importe l'extension du fichier, ce fichier sera lu à partir du programme que vous écrirez, pas avec un traitement de texte ou n'importe quel autre éditeur</footnote>
--- Donner le nombre d'employes ---
2

Employe Num 1 :

Nom : MAHMOUDI

Prenom : MAHMOUD

Age : 33

Telephone : 213666554433

Employe Num 2 :

Nom : ALILI

Prenom : ALI

Age : 38

Telephone : 213555443322

--- Les informations sur les employes sont ---

Employe Num 1 :

Nom : MAHMOUDI

Prenom : MAHMOUD

Age : 33

Telephone : 213666554433

Employe Num 2 :

Nom : ALILI

Prenom : ALI

Age : 38

Telephone : 213555443322

Donnee le nom recherche : MOKHTARI

-- ce nom ne figure pas dans le fichier --

Process returned 0 (0x0) execution time : 69.082 s

Press any key to continue.

Corrigé Exercice Fichiers

1) Saisie et Affichage d'un fichier texte :

#include <stdio.h>

#include <windows.h>

int main()

{

system("color F0");

char nomfich[21]; /* nom physique du fichier */

FILE *entree; /* nom logique du fichier */

char ligne[81];

printf ("donnez le nom du fichier a lire : ");

gets(nomfich);

entree = fopen (nomfich, "r"); //ouverture du fichier en lecture
--- Donner le nombre d'employes ---
2

Employe Num 1 :

Nom : MAHMOUDI

Prenom : MAHMOUD

Age : 33

Telephone : 213666554433

Employe Num 2 :

Nom : ALILI

Prenom : ALI

Age : 38

Telephone : 213555443322

--- Les informations sur les employes sont ---

Employe Num 1 :

Nom : MAHMOUDI

Prenom : MAHMOUD

Age : 33

Telephone : 213666554433

Employe Num 2 :

Nom : ALILI

Prenom : ALI

Age : 38

Telephone : 213555443322

Donnee le nom recherche : MOKHTARI

-- ce nom ne figure pas dans le fichier --

Process returned 0 (0x0) execution time : 69.082 s

Press any key to continue.

Corrigé Exercice Fichiers

1) Saisie et Affichage d'un fichier texte :

#include <stdio.h>

#include <windows.h>

int main()

{

system("color F0");

char nomfich[21]; /* nom physique du fichier */

FILE *entree; /* nom logique du fichier */

char ligne[81];

printf ("donnez le nom du fichier a lire : ");

gets(nomfich);

entree = fopen (nomfich, "r"); //ouverture du fichier en lecture
printf ("
 **** Contenu du fichier %s ****\n\n", nomfich) ;

while ( fgets (ligne, 80 , entree) )
{
printf ("%s", ligne) ;
}
printf ("
") ;
CLOSEnez( entree) ;
return 0;
}

2) Et 3)

#include <stdio.h>
#include <string.h>

#define LGNOM 20 //longueur de la chaine de caractères (nom), déclarée comme constante
#define LGPRENOM 20
#define LGTEL 12

int main()
{
char nomfich[21] ; /* nom de fichier physique*/
int n,i;
FILE *sortie ; //nom de fichier logique
struct { //déclaration de la structure d'un employé
char nom[LGNOM+1] ; //tenir compte du caractère de fin de chaine
char prenom [LGPRENOM+1] ;
int age ;
char tel [LGTEL+1] ;
}employe;

strcpy(nomfich, "d:\\personnel.txt");
sortie = fopen(nomfich, "w") ; //ouverture du fichier en écriture

printf (" --- Donner le nombre d'employes ---\n") ;
scanf("%d", &n);

for (i=0;i<n;i++){
printf ("
 Employe Num %d : 
 ",i+1);
printf ("
 Nom : "); scanf(" %s", employe.nom);
printf ("
 Prenom : "); scanf(" %s", employe.prenom);
printf ("
 Age : ") ; scanf("%d", &employe.age) ;
printf ("
 Telephone : ") ; scanf(" %s", employe.tel);

ffwrite (&employe, sizeof(employe), 1, sortie) ;
/*écriture dans le fichier sortie les informations d'un employé*/
}

CLOSEnez( sortie) ; //fermeture du fichier
printf ("
 **** Contenu du fichier %s ****\n\n", nomfich) ;

while ( fgets (ligne, 80 , entree) )
{
printf ("%s", ligne) ;
}
printf ("
") ;
fclose (entree) ;
return 0;
}

2) Et 3)

#include <stdio.h>
#include <string.h>

#define LGNOM 20 //longueur de la chaine de caractères (nom), déclarée comme constante
#define LGPRENOM 20
#define LGTEL 12

int main()
{
char nomfich[21] ; /* nom de fichier physique*/
int n,i;
FILE *sortie ; //nom de fichier logique
struct { //déclaration de la structure d'un employé
char nom[LGNOM+1] ; //tenir compte du caractère de fin de chaine
char prenom [LGPRENOM+1] ;
int age ;
char tel [LGTEL+1] ;
}employe;

strcpy(nomfich, "d:\\personnel.txt") ;
sortie = fopen(nomfich, "w") ; //ouverture du fichier en écriture

printf (" --- Donner le nombre d'employes ---\n") ;
scanf("%d", &n);

for (i=0;i<n;i++){
printf ("
 Employe Num %d : 
 ",i+1) ;
printf ("
 Nom : "); scanf(" %s", employe.nom) ;
printf ("
 Prenom : ") ; scanf(" %s", employe.prenom) ;
printf ("
 Age : ") ; scanf("%d", &employe.age) ;
printf ("
 Telephone : ") ; scanf(" %s", employe.tel) ;

ffwrite (&employe, sizeof(employe), 1, sortie) ;
/*écriture dans le fichier sortie les informations d'un employé*/
}

CLOSE (sortie) ; //fermeture du fichier
sortie = fopen(nomfich, "r") ; //ouverture du fichier en lecture

printf (" 

--- Les informations sur les employes sont ---
") ;

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

fread (&employe, sizeof(employe), 1, sortie) ;

/*lecture des informations d'un employé à partir du fichier sortie*/

printf(" 
 Employe Num %d : 
 ",i+1);

printf ("
 Nom : %s", employe.nom);

printf ("
 Prenom : %s", employe.prenom);

printf ("
 Age : %d", employe.age) ;

printf ("
 Telephone : %s", employe.tel);

}

char nomEmploye[21]; int trouve=0;

printf(" 
 Donnee le nom recherche : ");

scanf("%s", nomEmploye); //saisir le no à rechercher

do

{ fread (&employe, sizeof(employe), 1, sortie) ;

if strcomp(nomEmploye,employe.nom)==0) trouve = 1 ;

}

while ( (!trouve) && (! feof (sortie))) ; //boucle de parcours du fichier en utilisant un booléen

if(trouve==1)

{ printf ("
 Prenom : %s
", employe.prenom) ;

printf ("
 Age : %d
", employe.age) ;

printf ("
 Telephone : %s
", employe.tel) ;

}

else printf ("
-- ce nom ne figure pas dans le fichier --
") ;

fclose (sortie) ; //fermeture du fichier sortie

return 0;

}
sortie = fopen(nomfich, "r") ; //ouverture du fichier en lecture

printf (" 

--- Les informations sur les employes sont ---
") ;

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

fread (&employe, sizeof(employe), 1, sortie) ;

/*lecture des informations d'un employé à partir du fichier sortie*/

printf(" 
 Employe Num %d : 
 ",i+1);

printf ("
 Nom : %s", employe.nom);

printf ("
 Prenom : %s", employe.prenom);

printf ("
 Age : %d", employe.age) ;

printf ("
 Telephone : %s", employe.tel);

}

char nomEmploye[21]; int trouve=0;

printf(" 
 Donnee le nom recherche : ");

scanf("%s", nomEmploye); //saisir le no à rechercher

do

{ fread (&employe, sizeof(employe), 1, sortie) ;

if strcomp(nomEmploye,employe.nom)==0) trouve = 1 ;

}

while ( (!trouve) && (! feof (sortie))) ; //boucle de parcours du fichier en utilisant un booléen

if(trouve==1)

{ printf ("
 Prenom : %s
", employe.prenom) ;

printf ("
 Age : %d
", employe.age) ;

printf ("
 Telephone : %s
", employe.tel) ;

}

else printf ("
-- ce nom ne figure pas dans le fichier --
") ;

fclose (sortie) ; //fermeture du fichier sortie

return 0;

}