Enoncé exercice 1

Ecrire un programme C qui lit un entier n, puis n autres entiers positifs dans un tableau, l’affiche puis calcul la somme, le max, et le min de ses éléments.

Correction exercice 1

On commence par la déclaration du tableau en précisant une taille suffisante, ici 100 (ligne 5). Puis on demande à l’utilisateur d’entrer le nombre n d’éléments avec lesquels il souhaite travailler. Bien évidement cette valeur ne doit pas dépasser la taille du tableau.

On rappelle ici pour la suite, que la manipulation des tableaux et similaire à celle des variables. Puisque chaque élément t[i] d’un tableau t est considéré comme une variable dont le type est celui du tableau.

Dans cet exercice, on va se servir d’un tableau t de type int. Pour laa lecture du tableau, on aura à lire n variables: t[0], t[1], …, t[n-1] (l’indexage des tableaux en C commence par 0). Pour cet effet, on utilisera une boucle for, puisqu’elle est la plus adaptée à cette tâche (lignes 9-13).

Après la lecture du tableau t on procédera à l’affichage du tableau et le calcul des quantités demandées. Pour ce faire, et après l’initialisation des trois variables som, max et min (lignes 14-16), on se servira d’une autre boucle for pour parcourir le tableau t (ligne 17).

A chaque itération de cette boucle on affiche l’élément courant t[i] (ligne 19), on l’ajoute à la variable som (ligne 20) et on actualise le max et le min s’il est nécessaire (lignes 21-22).

Directement après la sortie de cette dernière boucle, on affiche les quantités demandées (lignes 25-27).

Solution exercice 1

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int t[100];
    int i,n,som,max,min;
    printf("Donnez le nombre des elements du tableau:\n");
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
       printf("Donnez l'element %d:\n",i+1);
       scanf("%d",&t[i]);
    }
    som=0;
    min=t[0];
    max=t[0];
    for(i=0;i<n;i++)
    {
       printf("%d ",t[i]);
       som+=t[i];
       if(t[i]>max) max=t[i];
       if(t[i]<min) min=t[i];
    }
    printf("\n");
    printf("La somme est: %d\n",som);
    printf("Le max est: %d\n",max);
    printf("Le min est: %d\n",min);
    system("pause");
    return 0;
}

Enoncé exercice 2

Ecrire un programme C qui lit un entier n, puis n autres éléments dans un tableau. Et, affiche ce dernier avant et après la suppression de toutes les occurrences d’un nombre entré par l’utilisateur.

Correction exercice 2

On demande à l’utilisateur d’entrer le nombre des éléments du tableau, qu’on va lire dans la variable n (lignes 7-8). Puis on lit les n éléments dans un tableau t à l’aide d’une boucle for (lignes 9-13). Une fois le tableau lu, on va procéder à son affichage en utilisant une deuxième boucle for (ligne 14). On rappelle à cette occasion que lorsqu’on utilise une boucle sans accolades, seule l’instruction qui la suit directement est prise en compte par la boucle.

On demande ensuite l’entrée de la valeur à supprimer du tableau qu’on va mettre dans la variable a. On parcourt ensuite le tableau t, par une première boucle for (ligne 19). Et, à chaque fois qu’on rencontre un élément du tableau d’indice i qui est égale à a, on décale les éléments du tableau dont l’indice est supérieur à i d’une seule case dans le sens des indices décroissants (lignes 23-24). Et de cette façon, on va écraser l’élément qui se trouvait à la case i.

Cette suppression va entraîner la diminution du nombre des éléments du tableau par un, il faudra donc décrémenter la valeur de n par 1 (ligne 25).

Le nouvel élément qui occupe la position i n’est pas encore examiné. Et si on laisse les choses comme elles le sont, il ne sera jamais traité, puisque le compteur i sera incrémenté pour passer à l’itération suivante. Pour régler ce problème, il suffira juste de décrémenter le i (ligne 26). Cette décrémentation en plus de l’incrémentation automatique vont ne permettre de ne laisser aucun élément du tableau sans examen.

On termine on réaffichant le tableau (lignes 29-30).

Solution exercice 2

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int t[100];
    int i,j,n,a;
    printf("Donnez le nombre des elements du tableau:\n");
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
       printf("Donnez l'element %d:\t",i+1);
       scanf("%d",&t[i]);
    }
    for(i=0;i<n;i++)
       printf("%d ",t[i]);
    printf("\n");
    printf("Donnez l'element a supprimer du tableau:\n");
    scanf("%d",&a);
    for(i=0;i<n;i++)
    {
       if(t[i]==a)
       {
          for(j=i;j<n-1;j++)
            t[j]=t[j+1];
          n--;
          i--;
       }
    }
    for(i=0;i<n;i++)
       printf("%d ",t[i]);
    printf("\n");
    system("pause");
    return 0;
}

Enoncé exercice 3

Ecrire un programme C qui lit un entier n. Puis n autres entiers inférieurs à 100, dans un tableau. Et affiche le nombre d’occurrences de chaque élément du tableau de la façon suivante:

Si le tableau est: 1 2 5 2 1 2, on affiche:

1 est répété 2 fois.
2 est répété 3 fois.
5 est répété 1 fois.

Pas nécessairement dans un ordre précis, mais chaque élément ne doit être cité qu’une seule fois.

Correction exercice 3

Dans cet exercice on aura besoin de deux tableaux d’entiers, un tableau t pour contenir les entiers entrés par l’utilisateur, et un autre tableau occ qui sera rempli de telle façon que chaque case d’indice i contient à la fin du programme le nombre de fois que la valeur i a apparue dans le tableau t.

A noter que la taille du tableau occ dépend de la plus grande valeur que peut contenir t. C’est pourquoi les entrées ont été limitées à 100.

On commence donc en demandant le nombre d’éléments à l’utilisateur. Puis on enchaîne par leur lecture vers le tableau t (lignes 7-11).

On initialise ensuite les cases de occ par des zéros, pour dire qu’on n’a pas encore procédé au parcourt de t. Ceci est réalisé à l’aide d’une boucle for (lignes 12-13).

Pour calculer le nombre d’occurrences de chaque élément de t, on va parcourir ce dernier par une boucle for (ligne 14). Et dans chaque itération i de la boucle, on va incrémenter la valeur de la case du tableau occ dont l’indice est t[i] par 1. Et ceci pour prendre en compte la nouvelle occurence de t[i] dans le tableau t (ligne 15).

Pour l’affichage, on va traverser le tableau occ, on ne s’intéressant qu’aux éléments non nuls, car, une valeur de zéro pour occ[i] veut dire que i ne se trouve pas dans t (lignes 16-20).

Solution exercice 3

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int t[100],occ[100];
    int i,n;
    printf("Donnez la taille du tableau:\n");
    scanf("%d",&n);
    printf("Entrez %d element(s):\n",n);
    for(i=0;i<n;i++)
       scanf("%d",&t[i]);
    for(i=0;i<100;i++)
       occ[i]=0;
    for(i=0;i<n;i++)
       occ[t[i]]++;
    for(i=0;i<100;i++)
    {
       if(occ[i]!=0)
          printf("%d est repete %d fois.\n",i,occ[i]);
    }
    system("pause");
    return 0;
}

Enoncé exercice 4

Ecrire un programme C qui construit la table de multiplication des entiers entre 1 et 9 puis l’affiche.

Correction exercice 4

Dans ce programme on n’aura pas besoin d’informations de la part de l’utilisateur, ce qui justifie l’absence de la fonction scanf.

D’une autre part, on utilisera un tableau t à deux dimensions, constitué de neuf lignes et de neuf colonnes pour contenir le produit des différents entiers (ligne 5). Ce tableau sera rempli à l’aide de deux boucles for imbriquées, en suivant la démarche suivante: on parcourt les lignes du tableau avec une première boucle for de compteur i (ligne 7), à l’intérieur de laquelle on va utiliser une deuxième boucle for de compteur j pour parcourir les cases de la ligne i (ligne 9). En faisant ça, on va affecter à chaque case t[i][j] du tableau le produit (i+1)*(j+1) et non pas i*j, puisque l’indexage commence par zéro et on est intéressé seulement par le produit des entiers non nuls (ligne 11).

Après la création de la table de multiplication, on l’affiche à l’aide de deux autres boucles for imbriquées, une toujours pour parcourir les lignes (ligne 14) et l’autre les colonnes (ligne 16). Il est à noter qu’on peut réutiliser sans aucun problème les deux compteurs précédents i et j, puisque les deux premières boucles sont indépendantes des deux dernières.

Afin d’éviter d’avoir un décalage des colonnes dû à la différence des nombres de chiffres, on va afficher toutes les valeurs du tableau en utilisant le %2d dans printf (ligne 18).

Le retour à la ligne utilisé, permet lors de l’affichage du tableau sur la console de revenir à la ligne après l’affichage d’une ligne complète du tableau (ligne 20).

Solution exercice 4

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int t[9][9];
    int i,j;
    for(i=0;i<9;i++)
    {
       for(j=0;j<9;j++)
       {
          t[i][j]=(i+1)*(j+1);
       }
    }
    for(i=0;i<9;i++)
    {
       for(j=0;j<9;j++)
       {
          printf("%2d ",t[i][j]);
       }
       printf("\n");
    }
    system("pause");
    return 0;
}

Enoncé exercice 5

Ecrire un programme C qui lit un entier n inférieur à 10, et une matrice (tableau à deux dimensions) carrée nxn. Puis l’affiche et vérifie si tous les entiers entre 1 et n² y sont présents ou non.

Ex: la matrice 3×3 suivante vérifie cette contrainte.

2 5 3
1 9 6
7 4 8

Correction exercice 5

Après la déclaration et la lecture du tableau à deux dimensions t, il sera temps de vérifier si tous les entiers entre 1 et n² y sont présents. Pour ce faire, on va utiliser un tableau à une dimension appelé existe, qu’on va remplir de telle façon à ce que si un entier i existe dans t, alors existe[i] doit être égale à 1, et à 0 dans le cas contraire.

Ce traitement sera fait en parallèle avec l’affichage de la matrice (lignes 19-27). Mais avant ça, on supposera qu’aucun des entiers n’existe dans t, en initialisant les cases du tableau existe par des zéros (ligne 18).

En parcourant donc le tableau t, et pour chaque élément t[i][j] on va mettre à 1 la case du tableau existe portant le même indice (ligne 24).

Pour vérifier maintenant si la matrice contient tous les nombres de 1 à n², on va parcourir le tableau existe de la case 1 à n² à la recherche des valeurs nulles. Et si on en trouve une, on peut directement conclure qu’au moins un nombre de l’intervalle souhaitée ne figure pas dans la matrice t. On le signale alors en mettant la variable k à 0 (ligne 33) (k doit être initialisée par 1 avant d’entrer dans la boucle, ce qui veut dire qu’on a supposé que tous les entiers sont présents dans t). Dans ce cas on est pas obligé de continuer la recherche dans la tableau existe et on peut quitter la boucle en utilisant l’instruction break (ligne 33).

Enfin et selon la valeur de de la variable k on affiche le message correspondant (lignes 36-37).

Solution exercice 5

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int t[10][10],existe[101];
    int i,j,n,k;
    printf("Donnez un entier inferieur a 10:\n");
    scanf("%d",&n);
    printf("Entrez les elements de la matrice:\n");
    for(i=0;i<n;i++)
    {
       for(j=0;j<n;j++)
       {
          printf("t[%d][%d] = ",i,j);
          scanf("%d",&t[i][j]);
       }
    }   
    for(i=1;i<=n*n;i++) existe[i]=0;
    for(i=0;i<n;i++)
    {
       for(j=0;j<n;j++)
       {
          printf("%d ",t[i][j]);
          existe[t[i][j]]=1;
       }
       printf("\n");
    }
    k=1;
    for(i=1;i<=n*n;i++)
    {
       if(existe[i]==0)
       {
          k=0; break;
       }
    }
    if(k==0) printf("les entiers de 1 a %d ne sont pas tous dans la matrice.\n",n*n);
    else printf("tous les entiers de 1 a %d se trouvent dans la matrice.\n",n*n);
    system("pause");
    return 0;
}