Académique Documents
Professionnel Documents
Culture Documents
Ap1 PDF
Ap1 PDF
Première
partie
Rappel du cours
HELLO_WORLD en C
#include <stdio.h>
|main()
|/* Notre premier programme en C */
|{
| printf("hello, world\n");
| return 0;
|}
Les noms des fonctions et des variables en C sont composés d'une suite de lettres et de chiffres. Le
premier caractère doit être une lettre. Le symbole '_' est aussi considéré comme une lettre.
{0,1,2,...,9,A,B,...,Z,_,a,b,...,z}
* Le premier caractère doit être une lettre (ou le symbole '_') - voir aussi Remarques -.
La fonction main est la fonction principale des programmes en C: Elle se trouve obligatoirement dans
tous les programmes. L'exécution d'un programme entraîne automatiquement l'appel de la
fonction main.
Exercice 1 :
Ecrire un programme qui affiche une date sous la forme jj/mm/aa en utilisant les fonctions de la
librairie standard C.
Exercice 2 :
int x = 9;
int y = x + 10;
printf("%d:%d:%d y", x, y, y );
a) 9:19:19:19
b) 9:19:19 y
c) %d:%d:%d y
Exercice 3 :
Ecrire un programme qui affiche la taille des types suivants : char, int, float, double, short et long.
Exercice 4 :
'/' = /
'\' = \
''' = '
'"' = "
Exercice 5 :
Correction de la Série1
Exercice 1 :
#include ‘’stdio.h’’
Void main()
{
/* declaration des variables*/
Int j,m,a;
/* saisie des donnees*/
printf("enter le jour");
scanf(”%i”,&j);
printf("enter le mois");
scanf(”%i”,&m);
printf("enter l’annee ");
scanf(”%i”,&a);
/* affichage du resultat */
printf(”la date est %2i/%2i/%2i”, j,m,a);
Exercice 2:
Le programme affiche “9:19:19 y”
Pour afficher un ensemble de variables il faut toujours mettre leurs types dans un message (exemple
%i %c ou %f), et puis les citer dans l’ordre
Exercice 3:
#include ‘’stdio.h’’
Void main()
{
printf("\nTaille des types:\n");
printf(" char : %d\n", sizeof(char));
printf(" int : %d\n", sizeof(int));
printf(" float : %d\n", sizeof(float));
printf(" double : %d\n", sizeof(double));
Atelier de programmation 1
Exercice 4 :
#include ‘’stdio.h’’
Void main()
{
printf("\'/\' = / \n");
printf("\'\\\' = \\ \n");
printf("\'\'\' = \' \n");
printf("\'\"\' = \" \n");
}
Exercice 5 :
#include ‘’stdio.h’’
Void main()
{
Rappel du cours
On appelle structure conditionnelle les instructions qui permettent de tester si une condition est vraie
ou non.
La structure alternative en langage algorithmique
si (<expression logique>)
alors
<bloc d'instructions 1>
sinon
<bloc d'instructions 2>
finssi
La structure alternative en C
les 'conditions' en C peuvent être des expressions quelconques qui fournissent un résultat
numérique. La valeur zéro correspond à la valeur logique faux et toute valeur différente de zéro est
considérée comme vrai.
if ( <expression> )
<bloc d'instructions 1>
else
<bloc d'instructions 2>
case Valeur2 :
Liste d'instructions;
break;
Default
Liste d'instructions;
}
Atelier de programmation 1
Les parenthèses qui suivent le mot clé switch indiquent une expression dont la valeur est testée
successivement par chacun des case. Lorsque l'expression testée est égale à une des valeurs
suivant uncase, la liste d'instructions qui suit celui-ci est exécutée. Le mot clé break indique la
sortie de la structure conditionnelle. Le mot clé default précède la liste d'instructions qui sera
exécutée si l'expression n'est jamais égale à une des valeurs.
N'oubliez pas d'insérer des instructions break entre chaque test, ce genre d'oubli est difficile à
détecter car aucune erreur n'est signalée...
En effet, lorsque l'on omet le break, l'exécution continue dans les blocs suivants !
Exercice 1 :
Ecrire un programme qui calcule, le maximum de 2 entiers a et b et qui affiche le résultat à l’écran.
Exercice 2 :
Ecrire un programme qui détermine si un entier x est pair.
Exercice 3 :
Le programme affichera comme résultat le vainqueur ainsi que son nombre de points.
Exercice 4 :
Ecrire un programme C qui perm et d'effectuer les opérations simples (+, -, *, /).
programme donnerait par exemple 5 + 11 = 15.
Exercice 5 :
Ecrire un programme qui permet de vérifier si une date est valide ou pas. On suppose que le jour,
le mois et l’année sont des entiers, et (1900< année <2050).
Atelier de programmation 1
Correction de la série 2
Exercice 1:
#include ‘stdio.h’
void main( )
{
int a,b;
printf("Entrez un entier a: ");
scanf("%d", &a);
printf("Entrez un entier b: ");
scanf("%d", &b);
if(a>b)
printf("\nLe maximum est: %d", a) ;
else if(b>a)
printf("\nLe maximum est: %d", b) ;
else
printf("\nles deux valeurs sont egales, Le maximum est
%d", a ) ;
}
Exercice 2:
#include ‘stdio.h’
void main( )
{
int a;
printf("Entrez un entier a: ");
/* l’operateur modulo % retourne le reste d’une division
entière*/
if(x%2==0)
printf("\nL’entier est pair ") ;
else
printf("("\nL’entier est impair ")
Atelier de programmation 1
Exercice 3:
#include ‘stdio.h’
void main( )
{
int valJ1,valJ2,som,nbpoints1,nbpoints2;
do{
printf("1er joueur :\n Donner un entier :");
scanf("%i",&valJ1);
}while(valJ1<0||valJ1>61);
do{
printf("\n 2eme joueur :\n Donner un entier :");
scanf("%i",&valJ2);
}while(valJ2<0||valJ2>61);
som=valJ1+valJ2;
//conversion en miniscule
if(som=='A'||som=='E'||som=='I'||som=='O'||som=='U'||som=='Y'
)
som=som+'a'-'A';
switch(som)
{
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
case 'y':
nbpoints1=26*som;
nbpoints2=10;
break;
case '0':
case '2':
case '4':
Atelier de programmation 1
case '6':
case '8':
nbpoints1=10;
nbpoints2=26*som;
break;
default:
if(valJ1>valJ2)
nbpoints1=som;
else
if(valJ2>valJ1)
nbpoints2=som;
else
{
nbpoints1=valJ1;
nbpoints2=valJ2;
}
}
if (nbpoints1>nbpoints2)
printf("Joueur1 est le vainqueur avec un score=%i
",nbpoints1);
else
if(nbpoints2>nbpoints1)
printf("Joueur2 est le vainqueur \n
score=%i",nbpoints2);
else
printf("Partie nulle ");
}
Exercice 4
#include ‘stdio.h’
void main( )
{
float x,y,res; char op;
int ind=0;
printf("Donner le 1er operande :");
Atelier de programmation 1
scanf("%f",&x);
printf("Donner l'operateur :");
scanf("%c",&op);
printf("Donner le 2eme operande :");
scanf("%f",&y);
switch(op)
{
case '+':
res=x+y;
break;
case '-':
res=x-y;
break;
case '*':
res=x*y;
break;
case '/':
if(y!=0)
res=x/y;
else
{
printf("diviseur nul
ind=1 ;
}
break;
default:
printf("operateur erronee’’) ;
}
Exercice 5 :
#include ‘stdio.h’
void main( )
{
int jour, mois, annee, valide=1;
do{
Atelier de programmation 1
printf("donner le jour");
scanf("%i", &jour);
printf("donner le mois");
scanf("%i", &mois);
printf("donner l'annee");
scanf("%i", &annee);
if((annee<1900)&&(annee>2050))
valide=0;
else
{
switch(mois)
{
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12: if(jour>31)
valide=0;
break;
case 4:
case 6:
case 9:
case 11: if (jour>30)
valide=0;
break;
case 2:
if
((jour>29)&&(((annee%4==0)&&(annee%100!=0))||(
annee%400==0)))
valide=0;
else if((jour!=28)&&(!(((
annee%4==0)&&(annee%100!=0))||(annee%400==0)))
)
valide=0;
break;
Atelier de programmation 1
default: valide=0;
}
if (valide==0)
printf("date invalide, saisissez une autre
date");
else
printf("date valide");
}
}
while (valide==0);
}
Atelier de programmation 1
Rappel du cours
En C, nous disposons de trois structures qui nous permettent la définition de boucles conditionnelles:
la structure : while
while ( <expression> )
<bloc d'instructions>
la structure : do – while
do
<bloc d'instructions>
while ( <expression> );
la structure : for
Le plus souvent, for est utilisé comme boucle de comptage (le nombre d’itérations est connu au
préalable) :
Exercice 1 :
Écrire un programme qui affiche la table de multiplication d’un entier n.
Par exemple, pour n=4, la fonction affichera :
1x4=4
2x4=8
3 x 4 = 12
4 x 4 = 16
…
10 x 4 = 40
Exercice 2 :
Ecrire la un programme qui permet d’afficher un ensemble d’étoiles sous cette forme (ici n vaut
*
**
***
****
*****
****
***
**
*
Exercice 3 :
Ecrire un programme qui affiche le minimum, le maximum et la moyenne d'une suite d'entiers positifs
entrés au clavier. On arrêtera la saisie quand le nombre -1 est entré, comme dans l'exemple suivant
:
Exercice 4 :
Ecrire un programme en C qui affiche tous les nombres premiers compris entre [10…99]. Il existe
Atelier de programmation 1
de nombreuses façons de savoir si un nombre est de la "taille" du nombre. Pour lintervalle [10,99]. il
suffit de tester si le nombre est divisible par 2, 3, 5, 7.
Atelier de programmation 1
Correction de la Série 3
Exercice 1 :
#include ‘stdio.h’
void main( )
{
int I,n;
printf (“donner un entire n’’) ;
scanf(“%i“, &n) ;
for (i=1; i<=10; i++)
{
printf("%d x %d = %d\n", i, n, i*n);
}
}
Exercice 2 :
#include ‘stdio.h’
void main( )
{
int I,n;
int j;
printf (“donner un entire n’’) ;
scanf(“%i“, &n) ;
printf("\n");
}
Atelier de programmation 1
printf("\n");
}
}
Exercice 3 :
#include ‘stdio.h’
void main( )
{
int sum = 0;
int count = 0;
int min = INT_MAX;
int max = INT_MIN;
int x=0;
while (x!=-1)
{
printf("Entrez un entier positif: ");
scanf("%d", &x);
if (x !=-1)
{
sum +=x;
count++;
if (x<min)
min = x;
if (x>max)
max= x;
}
}
float avg = 0;
Atelier de programmation 1
if (count>0)
avg=(float)sum/count;
Exercice 4 :
#include ‘stdio.h’
void main( )
{
for(int i=10; i<100; i++)
{
if((i%2!=0)&&(i%3!=0)&&(i%5!=0)&&(i%7!=0))
printf("%i \n", i);
}
}
Atelier de programmation 1
Un tableau (uni-dimensionnel) est une variable structurée formée d'un nombre entier N de
variables simples du même type, qui sont appelées les composantes du tableau. Le nombre
de composantes N est alors ladimension du tableau.
Déclaration de tableaux en C
<TypeSimple> <NomTableau>[<Dimension>];
Initialisation
nous avons défini un tableau A avec cinq composantes, auxquelles on peut accéder par:
A[0], A[1], ... , A[4]
main()
{
int A[5];
int I; /* Compteur */
for (I=0; I<5; I++)
scanf("%d", &A[I]);
return 0;
}
Exercice 1:
Ecrire un programme qui permet de fusionner deux tableaux triés dans le sens croissant dans un
nouveau tableau. Ce dernier doit de même être trié.
Exemple :
Atelier de programmation 1
Exercice 2:
Soit un tableau contenant une liste de N nombres entiers positifs, dont la valeur est comprise entre
1 et 100. Ecrire un programme en C qui calcule le nombre d’occurrences de chaque valeur
Contenue dans le tableau sachant qu’elle peut apparaitre plusieurs fois.
a) Ecrire une première version qui n’utilise qu’un seul tableau.
b) b) Ecrire une seconde version qui utilise deux tableaux. Le premier contiendra les données et
le deuxième les occurrences de chaque nombre entier.
Correction de la série 4
Exercice 1 :
#include <stdio.h>
Void main()
{
/* Déclarations */
/* Les tableaux et leurs dimensions */
int A[50], B[50], FUS[100];
int N, M;
int IA, IB, IFUS; /* indices courants */
printf("Tableau A :\n");
for (IA=0; IA<N; IA++)
printf("%d ", A[IA]);
printf("\n");
printf("Tableau B :\n");
for (IB=0; IB<M; IB++)
printf("%d ", B[IB]);
printf("\n");
IFUS++;
IB++;
}
/* Edition du résultat */
Exercice2:
a)
#include ‘stdio.h’
void main( )
{
int tab[100], nb=0,nbreElement=0,i,j, trouve, occurence=0;
while ((nb!=-1)&&(nb<100))
{
printf("entrez un entier positif (
scanf("%d",&nb);
if (nb>=0)
tab[nbreElement++]=nb;
}
for(i=0;i<nbreElement;i++)
{
trouve =0; j=0;
while((j<i)&&(trouve==0))
{
if (tab[i]==tab[j])
trouve=1;
else
j++;
}
Atelier de programmation 1
if(trouve==0)
{
occurence=1;
for(j=i+1;j<nbreElement;j++)
{
if (tab[i]==tab[j])
occurence ++;
}
printf("%d: %d occurence(s) \n",tab[i],occurence);
}
}
}
b)
#include ‘stdio.h’
void main( )
{
int tab[100],tab_Occ[100],
nb=0,nbreElement=0,i,j,occurence=0;
while ((nb!=-1)&&(nb<100))
{
printf("entrez un entier positif , (-1 pour finir)");
scanf("%d",&nb);
if (nb>=0)
{
tab[nbreElement]=nb;
nbreElement++;
}
}
for(i=0;i<100; i++)
{
tab_Occ[i]=0;
}
for(i=0;i<nbreElement;i++)
{
tab_Occ[tab[i]]=tab_Occ[tab[i]]+1;
}
Atelier de programmation 1
for(j=0;j<100; j++)
{
if (tab_Occ[j]!=0)
printf("%d: %d occurence(s)
}
}
}
Atelier de programmation 1
Il n'existe pas de type spécial chaîne ou string en C. Une chaîne de caractères est traitée comme
un tableau à une dimension de caractères (vecteur de caractères). Il existe quand même des notations
particulières et une bonne quantité de fonctions spéciales pour le traitement de tableaux de
caractères.
Lors de la déclaration, nous devons indiquer l'espace à réserver en mémoire pour le stockage de la
chaîne.
La représentation interne d'une chaîne de caractères est terminée par le symbole '\0'. Ainsi, pour un
texte de n caractères, nous devons prévoir n+1 octets.
En général, les tableaux sont initialisés par l'indication de la liste des éléments du tableau entre
accolades:
Pour le cas spécial des tableaux de caractères, nous pouvons utiliser une initialisation plus
confortable en indiquant simplement une chaîne de caractère constante:
Exercice 1 :
Écrire un programme qui recherche une sous-chaîne de caractères dans une chaîne de caractères.
Par exemple, si la chaîne de caractères contient la valeur "programme d'ordinateur" et que la sous-
chaîne recherchée est "gramme d'or", la procédure de recherche doit indiquer que la sous-chaîne
existe et l'indice retourné doit être égal à 3.
Atelier de programmation 1
Exercice 2 :
Un mot est dit Palindrome s'il se lit de la même manière dans le sens de lecture de droite à gauche
que dans le sens de gauche à droite. Par exemple, les mots "LAVAL" et "ADA" ''engage le jeu que
je le gagne '' sont des palindromes. Écrire un programme qui dit si une chaîne donnée est un
palindrome.
Exercice 3 :
Ecrire un programme qui permet de nettoyer un tableau de caractères en éliminant les espaces
superflus: chaque fois que l'on trouve une suite d'espaces, il faudra les éliminer tous sauf un. Sachant
que le premier caractère du tableau et le dernier caractère sont différents du caractère espace.
Exercice 4 :
Ecrire un programme en C qui permet de saisir deux chaines de caractères ch1 et ch2 et de déduire
si elles sont équivalentes. Deux chaines sont dites équivalentes si elles contiennent les mêmes lettres
mais pas nécessairement dans le même ordre.
a) On suppose qu’une chaine ne peut pas contenir la même lettre deux fois
b) On suppose qu’une chaine peut contenir la même lettre plusieurs fois
Exemple :
a) ch1= azerty, ch2= yterza (équivalente)
b) ch1= aazerty, tazeryy (non équivalentes)
Atelier de programmation 1
Correction de la série 5
Exercice 1 :
#include "stdio.h"
#include "string.h"
void main(int argc, char* argv[])
{
char ch[100], sch[100];
int i,j,pos,stop,existe;
Exercice2 :
#include "stdio.h"
#include "ctype.h" // toupper
#include "string.h"
taille=strlen(chaine);
i=0;
while((i<taille-1)&&(continuer==1))
{
if (toupper(chaine[i])==toupper(chaine[(taille-1)]))
{
i++;
taille--;
}
else
{ if (chaine[i]==' ')
i++;
else
if (chaine[(taille-1)]==' ')
taille--;
else
continuer=0;
Atelier de programmation 1
}
}
if(chaine[i]==chaine[(taille-1)])
printf("cette chaine est un palindrome!!\n");
else
printf("cette chaine n'est pas un palindrome!!!\n");
return 0;
}
Exercice 3 :
#include "stdio.h"
#include "string.h"
{
for (j=i+1; j<(N-1); j++)
{ch[j]=ch[j+1];}
N--;
Atelier de programmation 1
}
else
i++;
}
printf("La chaine de caracteres devient %s \n", ch);
}
Exercice4:
#include "stdio.h"
#include "string.h"
Void main()
{
char ch1[10], ch2[10];
int egaux=1, i=0;
printf("saisir ch1");
scanf("%s", ch1);
printf("saisir ch2");
scanf("%s", ch2);
if(strlen(ch1)!=strlen(ch2))
egaux=0;
else
{
while((egaux==1)&&(i<strlen(ch1)))
{
int j=0,trouve=0;
while((j<strlen(ch2)) && (trouve==0))
{ if (ch1[i]==ch2[j])
trouve=1;
else j++;
Atelier de programmation 1
}
if(trouve==0) egaux=0;
i++;
}
}
if(egaux==1)
printf("deux chaines equivalentes");
else
printf("non equivalentes");
}
b)
#include "stdio.h"
#include "string.h"
Void main()
{
if(strlen(ch1)!=strlen(ch2))
egaux=0;
else
{
while((egaux==1)&&(i<strlen(ch1)))
{
occ1=0; occ2=0;
Atelier de programmation 1
if(occ1!=occ2) egaux=0;
i++;
}
}
if(egaux==1)
printf("deux chaines equivalentes");
else
printf("non equivalentes");
}
Atelier de programmation 1
Rappel du cours
En C, un tableau à deux dimensions A est à interpréter comme un tableau (uni-dimensionnel) de
dimension L dont chaque composante est un tableau (uni-dimensionnel) de dimension C.
<TypeSimple> <NomTabl>[<DimLigne>][<DimCol>];
Initialisation
Lors de la déclaration d'un tableau, on peut initialiser les composantes du tableau, en indiquant la
liste des valeurs respectives entre accolades. A l'intérieur de la liste, les composantes de chaque ligne
du tableau sont encore une fois comprises entre accolades. Pour améliorer la lisibilité des
programmes, on peut indiquer les composantes dans plusieurs lignes.
Exemples
<NomTableau>[<Ligne>][<Colonne>]
les indices du tableau varient de 0 à L-1, respectivement de 0 à C-1.
Exercice 1
Écrire un programme permettant de transposer une matrice carrée (tableau à double dimension).
Exemple: 1 2 3 1 4 7
4 5 6 ==> 2 5 8
7 8 9 3 6 9
Exercice 2 :
Atelier de programmation 1
1 2 1 2 0 2 7 10 6 4
4 7 X 3 4 3 1 = 25 36 21 15
8 3 17 28 9 19
Exercice 3 :
Un carré magique est un arrangement de nombres avec n lignes et n colonnes. La somme des
valeurs dans chaque ligne, colonne et diagonale est la même. Par exemple, le carré suivant est
magique.
16 9 2 7
6 3 12 13
11 14 5 4
1 8 15 10
2) Une autre condition pour un arrangement de nombres avec n lignes et n colonnes d'être un vrai
carré magique est qu'il doit contenir tous les entiers 1, 2, ..., n2. Améliorer votre programme pour
qu'il vérifie également cette condition
Atelier de programmation 1
Correction de la série 6
Exercice1:
#include "stdio.h"
Void main()
int mat[100][100],
do{
scanf("%i",&n);
}while ((n>=100)||(n<1));
/*Remplissage de la matrice*/
for (i=0;i<n;i++)
for (j=0;j<n;j++)
scanf ("%d",&A[i][j]);
}
Atelier de programmation 1
for(i=0;i<n;i++)
for(j=0;j<i;j++)
if(i!=j)
x=mat[i][j];
mat[i][j]=mat[j][i];
mat[j][i]=x;
Exercice2:
#include "stdio.h"
Void main()
int i,j,k,m,n,p;
do{
scanf("%i",&m);
}while ((m>=100)||(m<1));
do{
scanf("%i",&n);
}while ((n>=100)||(n<1));
do{
scanf("%i",&p);
}while ((p>=100)||(p<1));
for (i=0;i<m;i++)
for (j=0;j<n;j++)
scanf ("%d",&A[i][j]);
for (i=0;i<n;i++)
for (j=0;j<p;j++)
Atelier de programmation 1
scanf ("%d",&B[i][j]);
for (i=0;i<m;i++)
for (j=0;j<p;j++)
C[i][j]=0;
for (i=0;i<m;i++)
for (j=0;j<p;j++)
for (k=0;k<n;k++)
C[i][j]=A[i][k]*B[k][j]+C[i][j];
for (i=0;i<m;i++)
for (j=0;j<p;j++)
printf ("%d\n",C[i][j]);
Exercice 3 :
1)
#include "stdio.h"
void main()
int n,magique,somL=0,somC=0,somD=0,somAD=0,som=0,i,k,j;
int tab[100][100] ;
do
scanf("%d",&n) ;
}while ((n<1)||(n>=100));
for (i=0;i<n;i++)
for (j=0;j<n;j++)
Atelier de programmation 1
scanf ("%d",&tab[i][j]);
magique=1; i=0 ;
do
if (i==0)
somD=somD+tab[j][j];
somAD=somAD+tab[j][n-j-1];
if (magique==1)
{ somL=0;
somL=somL+tab[i][k] ;
if (somL!=som) magique=0 ;
else
{ somC=0;
somC=somC+tab[k][i] ;
if (somC!=som) magique=0;
else i++;
}while((i<n)&&(magique==1));
if (magique==1)
printf("Carre magique");
else
2)
i=0;int trouver=0;
j=0;
if( tab[i][j]==k)
trouver=1;
Atelier de programmation 1
else
j++;
if (trouver==0)i++;
if (trouver==1)k++;
else continuer=0;
if (magique==1&&(k==(n*n)+1))
printf("Carre magique");
else
}
Atelier de programmation 1
Rappel du cours
La structuration de programmes en sous-programmes se fait en C à l'aide de fonctions. Nous avons
déjà utilisé des fonctions prédéfinies dans des bibliothèques standard
(printf de <stdio>, strlen de <string>, pow de <math>, etc.). Dans ce chapitre, nous allons
découvrir comment nous pouvons définir et utiliser nos propres fonctions
- le nom de la fonction
- le type, le nombre et les noms des paramètres de la fonction
- le type du résultat fourni par la fonction
- les données locales à la fonction
- les instructions à exécuter
Exemple
Avant de parler des détails, penchons-nous sur un exemple. Dans le programme suivant, la
fonction main utilise les deux fonctions:
- ENTREE qui lit un nombre entier au clavier et le fournit comme résultat. La fonction ENTREE n'a pas
de paramètres.
- MAX qui renvoie comme résultat le maximum de deux entiers fournis comme paramètres.
#include <stdio.h>
main()
{
/* Prototypes des fonctions appelées */
int ENTREE(void);
int MAX(int N1, int N2);
/* Déclaration des variables */
int A, B;
/* Traitement avec appel des fonctions */
A = ENTREE();
B = ENTREE();
printf("Le maximum est %d\n", MAX(A,B));
}
Atelier de programmation 1
int ENTREE(void)
{
int NOMBRE;
printf("Entrez un nombre entier : ");
scanf("%d", &NOMBRE);
return NOMBRE;
}
Ecrire un programme permettant de gérer un tableau d’entier en offrant les fonctionnalités suivantes
Ecrire une fonction void saisieClav( int tab[], int *N) qui permet de permet de faire le remplissage
d’un tableau de taille n
Ecrire une fonction void saisieAlea( int tab[], int *N) qui permet de remplir un tableau
aléatoirement par des entiers appartenant à [0 100].
Ecrire une fonction void affichage(int tab[], int N) qui permet d’afficher le contenu d’un tableau
Ecrire une fonction int max(int tab[], int N) qui retourne le maximum dans un tableau d’entier
Ecrire une fonction int min(int tab[], int N) qui retourne le minimum dans un tableau d’entier
Ecrire une fonction int modifier(int tab[], int *N, int ind) qui permet de modifier le contenu de la
case d’indice ind (par une nouvelle valeur). La fonction retourne 0 si l’indice est erroné et 1 sinon.
7. Ecrire une fonction int recherche(int tab[], int N, int x) qui permet chercher un entier dans un
tableau et retourner sa positon (0 s’il n’existe oas).
8. Ecrire une fonction int ajout(int tab[], int *N, int x, int pos) qui permet d’ajouter un entier a une
position donnée . la fonction retourne 1 si l’ajout est effectué avec succès, 0 sinon.
Atelier de programmation 1
9. Ecrire une fonction int suppression(int tab[], int *N, int x) qui permet de supprimer un entier
donné d’un tableau la fonction retourne 1 si la suppression est effectuée avec succès, 0 sinon.
10. Ecrire une fonction void tri(int tab[], int N) permet de trier les éléments du tableau dans le sens
croissant.
11. Ecrire une fonction int comparaison(int t1[], int N1, int t2[], int N2) qui retourne le nombre des
valeurs de t1 qui apparaissent dans t2 (On ne prend pas le nombre d’occurrence en considération)
12. Ecrire une fonction char menu() qui permet d’afficher un menu présentant 11 choix
correspondant au 11 fonctions présentées ci-dessus et retourne le choix de l’utilisateur.
Ecrire un programme principal qui affiche le menu ci-dessous et qui effectue le traitement adéquat
selon le choix de l’utilisateur. Le traitement se répète tant que le choix de l’utilisateur n’est pas de
quitter l’application
Atelier de programmation 1
Correction de la série 7
Corrigé
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void main()
{
char choix;
int T1[100],T2[100],ind,x,pos,N1,N2;
int res;
do{
choix=menu();
switch(choix)
{
case 'a': saisieClav(T1,&N1); break;
case 'b':
saisieAlea(T1,&N1);
Atelier de programmation 1
system("pause");
system("cls");
}while(choix!='l');
printf("a+\nFin de l'application....\n\n");
char menu()
{
char choix;
printf("selectionner un choix [a..l]\n");
printf("a. Saisie d’un tableau au clavier\n");
printf("b. Remplissage d’un tableau d’une manière
aléatoire\n");
printf("c. Affichage du contenu du tableau\n");
printf("d. Détermination du minimum\n"); printf("e.
Détermination du maximum\n");
printf("f. Modification d’une case étant donné son
indice\n");
printf("g. Recherche d’un entier x\n");
printf("h. Ajout d’un entier à une position donnée\n");
printf("i. Suppression d’un entier x donné s’il
existe\n"); printf("j. Tri du tableau\n");
printf("k. Comparaison de deux tableaux\n");
printf("l. Quitter\n");
do{
choix=getchar();
fflush(stdin);
}while(choix<'a'||choix>'l');
return choix;
}
Atelier de programmation 1
succe=0;
}
else
if((pos<1) || (pos > *N+1))
{
printf("position erronée\n");
succe=0;
}
else
{
for(i=*N;i>pos-1;i--)
tab[i]=tab[i-1];
tab[pos-1]=x;
(*N)++;
}
return succe;
}
{
printf("L'element %d n'appartient pas au
tableau...\n",x);
succe=0;
}
else
{
for(i=pos-1;i<*N-1;i++)
tab[i]=tab[i+1];
(*N)--;
}
}
return succe;
}
void tri(int tab[], int N)
{
int i,j,temp;
for(i=0;i<N-1;i++)
for(j=i+1;j<N;j++)
if(tab[j]<tab[i])
{
temp=tab[i]; tab[i]=tab[j]; tab[j]=temp;
}
}
Devoirs surveillés
Atelier de programmation 1
Exemple :
T1 5 10 80 7 T2 2 11 4 2
5 2 2 4 80 11 7 10
Exercice 2 (8 pt):
Ecrire un programme qui permet de calculer le nombre d’occurrences de tous les bigrammes qui
figurent dans un tableau de caractères. Le bigramme doit être composé de deux lettres différentes.
Le tableau est saisi par l’utilisateur, et les valeurs des cases ne doivent pas changer au cours du
programme.
Exemple :
a b b c r a b b c a b
Le programme affichera :
le bigramme ab figure 3 fois
le bigramme bc figure 2 fois
le bigramme cr figure 1 fois
le bigramme ra figure 1 fois
le bigramme ca figure 1 fois
Atelier de programmation 1
Exercice1 :
#include "stdafx.h"
#include "stdio.h"
int main(int argc, char* argv[])
{
int t1[100],t2[100];
int i,x,n,max,min;
do
scanf("%i",&n);
while(n>100 || n<0);
printf("\n saisir t1");
for(i=0;i<n;i++)
scanf("%i",&t1[i]);
printf("\n saisir t2");
for(i=0;i<n;i++)
scanf("%i",&t2[i]);
do
{ max=0;min=0;
for(i=1;i<n;i++)
{
if(t1[i]>t1[max])
max=i;
if(t2[i]<t2[min])
min=i;
}
if(t1[max]>t2[min])
{
x=t1[max];
t1[max]=t2[min];
t2[min]=x;
Atelier de programmation 1
}
while(t1[max]>t2[min]);
printf("t1=\n");
for(i=0;i<n;i++)
printf("%i ",t1[i]);
printf("\nt2=\n");
for(i=0;i<n;i++)
printf("%i ",t2[i]);
return 0;
}
Ex2 :
#include "stdafx.h"
#include "stdio.h"
int main(int argc, char* argv[])
{
char t[100];
int i,n,j,occ,trouve;
do
scanf("%i",&n);
while(n>100 || n<0);
printf("\n saisir t1");
scanf("%s",t);
for(i=0;i<n-1;i++)
{
if(t[i]!=t[i+1])
{
j=0; trouve=0;
while(j<i-1 && trouve==0)
{
if( (t[j]==t[i])&& (t[j+1]==t[i+1]))
{
Atelier de programmation 1
trouve=1;
}
j++;
}
if(trouve==0)
{
j=i+2; occ=1;
for(j=i+2; j<n-1;j++ )
{
if( (t[j]==t[i])&& (t[j+1]==t[i+1]))
{
occ++;
}
}
printf("\n le nbr d'occ de %c %c est
%i",t[i],t[i+1],occ);
return 0;
}
Atelier de programmation 1
Chaque case d’indice impair doit contenir une consonne, sinon on doit parcourir le reste du tableau
et permuter cette case avec la première consonne trouvée.
Chaque case d’indice pair doit contenir une voyelle, sinon on doit parcourir le reste du tableau et
permuter cette case avec la première voyelle trouvée.
Ce processus s’arrêtera lorsqu’on trouve plus de permutations possibles ou lorsqu’on termine tout le
tableau.
Exemple :
b r a s T e o i f
b a r e T o s i f
Exercice 2 (8pt):
Ecrire un programme qui permet de saisir un tableau d’entiers. Après avoir terminé la saisie, on doit
parcourir le tableau et afficher les éléments isolés. Un élément est qualifié comme non isolé s’il est
égal à la somme de deux autres entiers existants dans le même tableau.
Exemple :
5 2 8 14 3 10 88 2
Car 5 = 2+3
8 = 5+3
10= 8+2
Atelier de programmation 1
Exercice 1
#include "stdafx.h"
#include "stdio.h"
#include "string.h"
{
char t[100];
int i,n,j,trouve,x;
scanf("%s",t);
n=strlen(t);
for(i=0;i<n;i++)
if(i%2==0)
j=i,trouve=0;
while(j<n && trouve==0)
trouve=1;
x=t[i];
t[i]=t[j];
t[j]=x;
j++;
Atelier de programmation 1
if(i%2==1)
j=i,trouve=0;
trouve=1;
x=t[i];
t[i]=t[j];
t[j]=x;
}
j++;
}
}
}
for(i=0;i<n;i++)
printf("%c ",t[i]);
return 0;
Exercice 2
#include<stdio.h>
#include<stdlib.h>
Atelier de programmation 1
int main()
do
scanf("%i", &n);
}while ((n<=0)||n>100));
for(int i=0;i<n;i++)
scanf("%i", &t[i]);
for(int i=0;i<n;i++)
stop=0;
while (j<n)&&(stop==0)
while (k<n)&&(stop==0)
stop=1
else
k++;
j++;
Atelier de programmation 1
}
Atelier de programmation 1
Exercice 1 (6 points):
Ecrire un programme qui permet de:
- Saisir un tableau T d’entiers positifs,
- Effacer les éléments égaux à l’entier V du tableau T,
- Afficher le nouveau tableau T.
Exercice 2 (5 points):
Ecrire un programme qui permet de saisir un caractère « car » et d’indiquer qu’il s’agit d’une lettre
de l’alphabet ou non. Dans le premier cas, si le caractère « car » est une lettre de l’alphabet, le
programme doit afficher s’il s’agit d’une voyelle ou d’une consonne.
Exercice 3 (9 points):
On se propose d’écrire un programme en C permettant à l’utilisateur de créer son propre
dictionnaire de la manière suivante:
• L’utilisateur donne le nombre de mot à saisir
• L’insertion de chaque nouveau mot se fait de manière qu’il soit placé selon l’ordre alphabétique
• On ne doit pas accepter l’existence du même mot plus qu’une seule fois
• A la fin, il faut afficher le dictionnaire obtenu
Mot 2= ballon
b a l l o n \0
b e l l e \0
Mot 3= Arbre
a r b r e \0
b a l l o n \0
b e l l e \0
Atelier de programmation 1
Exercice 1: (6pts)
#include "stdio.h"
int main(int argc, _TCHAR* argv[])
{
int T[100];
int n,i,j, val,existe=0;
do{
printf("Donnez le nombre d'éléments");
scanf("%i",&n);
}while(n<1||n>100);
for(i=0;i<n;i++)
{
printf("Donnez le %i ème élément ", i+1);
do{
scanf("%i",&T[i]);
if(T[i]<0)
printf("Saisie incorrecte! Tapez un nombre
strictement positif");
}while(T[i]<0);
}
printf("Donnez une valeur à supprimer");
scanf("%d",&val);
for(i=0;i<n;i++)
{
if(T[i]==val)
{
existe=1;
for(j=i;j<n-1;j++)
T[j] = T[j+1];
n--;
}
}
if (!existe)
Atelier de programmation 1
printf("Impossible de supprimer");
else
{
printf("Aprés suppression, le tableau devient: \n");
for(i=0;i<n;i++)
printf("%i\t",T[i]);
}
return 0;
}
Exercice 2: (5pts)
#include "stdio.h"
int main(int argc, _TCHAR* argv[])
{
char car;
printf("Donnez un caractère");
scanf("%c",&car);
if((car>='a' && car<='z')||(car>='A'&&car<='Z'))
{
if(car=='o'||car=='i'||car=='e'||car=='a'||car=='u'||car
=='y'||car=='O'||car=='I'||car=='E'||car=='A'||car=='U'|
|car=='Y')
printf("Lettre voyelle");
else
printf("Lettre consonne");
}
else
printf("le caractère saisi n'est pas une lettre
de l'alphabet français");
return 0;
}
Exercice 3: (9pts)
#include "stdio.h"
#include "string.h"
int main(int argc, _TCHAR* argv[])
{
const int Tmax = 100;
Atelier de programmation 1
}
}while(trouve);
if(stop)
{
for(k=i;k>ind;k--)
strcpy(dic[k],dic[k-1]);
strcpy(dic[ind],Tmp);
}
else
strcpy(dic[i],Tmp);
}
printf("\n****************Le dictionnaire**************\n");
for(i=0;i<n;i++)
printf("%s \n", dic[i]);
return 0;
}
Page 70
Atelier de programmation 1
Soit T un tableau d’entiers distincts de taille logique N, et soit M une matrice d’entiers distincts de
taille (N x N), sachant que N est comprise entre 1 et 100. On se propose de tester si tous les
éléments de T apparaissent dans M dans le même ordre d’apparition dans T et d’afficher un
message selon le résultat du test.
Ecrire un programme en C qui permet de saisir le tableau T et la matrice M et d’afficher le
message correspondant au résultat du test.
Exemple :
Soit la matrice M (3,3) suivante :
1 10 5
4 9 6
11 2 7
1 5 9
5 1 9
1 3 4
Page 71
Atelier de programmation 1
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int t[100];
int M[100][100];
int n, i, j, k, stop, trouve, w;
// saisie de la taille logique entre 1 et 100 1.5 pt avec contrôle de saisie ; 0.5 pt sans contrôle
do{
printf("donner une taille logique N");
scanf("%i",&n);
}while((n<1)||(n>100));
// remplissage d’un tableau d’entiers distincts 2.5 pt si on vérifie la redondance ; 1 pt sinon
for(i=0;i<n;i++)
{do{
printf ("donner une valeur");
scanf("%i",&t[i]);
j=0; stop=0;
while((j<i)&&(stop==0))
{
if(t[j]==t[i])
stop=1;
else
j++;
}
}while(stop==1);
}
Page 72
Atelier de programmation 1
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
}
}
//affichage de la matrice
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{printf("%i \t", M[i][j]);
}
printf("\n");
}
//Recherche par ordre
i=0;j=0;k=0; stop=0;
while((i<n)&&(stop==0))// Parcours du tableau 1.5 pt
{trouve=0 ;
// Pour chaque valeur de t on continue la recherche à partir des indices de la valeur précédente
{if(k>=n) k=0;// On ne réinitialise l’indice des colonnes à 0 que si on parcourt toutes les colonnes de la
matrice pour un indice courant d’une ligne et pour chaque valeur de t . 0.5 pt
Page 73
Atelier de programmation 1
{
if(M[j][k]==t[i]) 1.5 pt
trouve=1;
k++;
}
if(k>=n) 1 pt
stop=1;
else
i++;
}
if((stop==0)) 0.5 pt
{
printf("le tableau existe dans la matrice");
}
else
{
printf("le tableau n'existe pas dans la matrice");
}
system("PAUSE");
return EXIT_SUCCESS;
}
Page 74
Atelier de programmation 1
Exercice 2: (8 pts)
Etant donné un mot, on se propose de le codifier où chaque lettre du mot sera précédé de son nombre
d’occurrences successives (égal à 1 ou 2). Par exemple le mot assassin son code sera la chaine
1a2s1a2s1i1n.
Ecrire un programme C qui demande à l’utilisateur de saisir une chaine et d’afficher son code.
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
char t[100];
int l, occ, i;
printf("donner le mot\n"); 1 pt, on peut aussi utiliser les fonctions scanf et gets
fflush(stdin);
occ=1;
i=0;
{if(t[i]==t[i+1])
{occ=2;
Page 75
Atelier de programmation 1
Else 1 pt pour le traitement des deux derniers caractères s’ils sont différents
occ=1;
i++;
else
if(t[i]==t[i+1]) 1.5 pt pour le traitement des autres caractères au milieu du tableau s’ils
sont identiques
{occ=2;
i=i+2;
Else 1.5 pt pour le traitement des autres caractères au milieu du tableau s’ils sont
différents
{occ=1;
i=i+1;
system("PAUSE");
return EXIT_SUCCESS; }
Page 76
Atelier de programmation 1
Troisième
partie
Les Projets
Page 77
Atelier de programmation 1
Description du problème :
Définition du problème du voyageur de commerce
Étant donné un ensemble fini de villes, il s'agit de trouver le plus court chemin qui relie toutes ces villes,
en passant une seule fois par chaque ville.
• Pour un problème de N villes, on disposera d'une matrice (MATRICE_DISTANCE N*N) de distances
donnant la distance entre chaque couple de villes.
• Il est à noter que cette distance est symétrique, c'est-à- dire distance(villea, villeb) = distance(villeb,
villea)
Méthode de résolution :
Heuristique (méthode) du plus proche voisin
Il ne s'agit pas ici de trouver le meilleur chemin possible, mais essayer de trouver un bon chemin. L'idée
est de lancer plusieurs voyageurs (NB_VOYAGEUR), chacun commençant à partir d'une ville différente.
Dans son parcours chaque voyageur se dirige vers la ville la plus proche qu'il n'a pas encore visitée.
Une fois tous les voyageurs auront terminé leurs parcours, le chemin le plus court sera affiché ainsi que
sa distance parcourue
Chaque voyageur devra donc enregistrer la liste des villes parcourus. On utilisera une autre
matrice(NB_VOYAGEUR * N) avec N le nombre de villes. Chaque ligne de cette matrice contient la
séquence des villes parcourues par le voyageur.
Travail demandé :
On vous demande d’écrire les programmes suivants :
• Init_Matrice Distance (MATRICE_DISTANCE), qui réinitialise la matrice distance avec
les distances réelles des villes tunisiennes.
• Placer_Voyageurs (NB_VOYAGEUR), qui permet de placer aléatoirement un nombre
de voyageurs sur des villes différentes
• Afficher_Meilleur_Parcours, qui affiche la séquence des villes qui correspond à la
distance minimale.
Page 78
Atelier de programmation 1
• Une interface graphique, permettant à l’utilisateur de placer les voyageurs sur la carte
de la Tunisie, et d’afficher leurs parcours est souhaitable.
• En l’absence d’interface graphique, l’utilisateur doit avoir la possibilité de saisir le
nombre de voyageur
PARTIE 2
Il est possible d’étudier quelques caractéristiques concernant l’image initiale à partir de cette matrice.
Pour cela, il faut calculer ce qu’on appelle la Matrice de Co-occurrences.
Cette matrice est de taille Ng*Ng (Ng étant le nombre de niveaux de gris figurant dans l’image).
Dans ce qui suit on ne traite que les images ayant les 4 niveaux de gris 0,1,2,3.
Pour le calcul de la matrice de co-occurrence, les paramètres généralement utilisés sont :
d : la distance entre les 2 pixels (en général c’est égal à 1)
θ : l'angle de la droite reliant ces 2 pixels (en général on utilise θ = 0° càd les deux
voisins horizontaux (celui de droite et celui de gauche)). Dans la suite on va considérer
(d = 1 et θ = 0° )
La première étape pour le calcul de matrice de co-occurrences, est de calculer la matrice relative aux
voisins de droite (MVD) et la matrice relative aux voisins de gauche (MVG). C'est-à-dire qu’on doit
Page 79
Atelier de programmation 1
étudier toutes les combinaisons entre les niveaux de gris. Dans notre exemple, on a 16 combinaisons
possibles (4*4) qui sont :
(0,0) (0,1) (0,2) (0,3)
(1,0) (1,1) (1,2) (1,3)
(2,0) (2,1) (2,2) (2,3)
(3,0) (3,1) (3,2) (3,3)
Les deux matrices MVD et MVG de l’exemple ci-dessus sont les suivants :
La valeur 2 (dans la cellule (1,2)) de MVD veut dire qu’il existe 2 cas dans la matrice M où un pixel=0
à un voisin droit =1 (cad les cases (1,2), (2,2) de M).
La valeur 3 (dans la cellule (3,3)) de MVG veut dire qu’il existe 3 cas où un pixel=2 a un voisin
gauche =2 (cad le pixel (3,3), (3,4), (4,2) de M). Une fois les deux matrices de voisinage calculées, la
deuxième étape est de symétriser (cad faire la somme des deux matrices MVD et MVG). Dans notre
exemple la matrice symétrisée (MS) est :
La dernière étape est la normalisation où on doit diviser la matrice symétrisée (MS) par la somme de
ses éléments (de telle sorte que la nouvelle somme soit égale à 1). Dans notre exemple, on divise par
24, et la matrice de co-occurrence (MC) est :
Page 80
Atelier de programmation 1
Travail demandé :
Soit M la matrice de niveaux de gris, voici l’algorithme principal qui permet de calculer la matrice de
co occurrences.
Algorithme CalculCoOccurrence
M, MDV, MDG, MS, MC (Tableau [1..4, 1..4] d’entiers)
Début
GenererMatriceGris (M)
CalculMatriceVoisins (M, MVD, MVG)
SymétrisationMatrice (MVD, MVG, MS)
NormalisationMatrice (MS, MC)
Fin
Page 81
Atelier de programmation 1
Les joueurs inscrivent tour à tour leur symbole sur une grille 3x3.
Chaque joueur va à tour de rôle inscrire son symbole sur l'une des 9 cases encore vide de la grille.
La partie se termine quand :
un des joueurs arrive le premier à aligner trois symboles identiques horizontalement ou
verticalement ou en diagonale.
Partie nulle.
Page 82
Atelier de programmation 1
Nota :
Pour mieux comprendre le principe de jeux Motus&Morpion, veuillez visiter les sites suivant :
http://motus.absolu-puzzle.com/index.php
http://www.jeuxjeuxjeux.fr/jeu/morpion/tic+tac+toe+2.html
Page 83
Atelier de programmation 1
Dans ce projet on se propose d'implémenter une application pour la gestion de prêt de livres d’une
bibliothèque. Un livre est caractérisé par numéro, un titre et le nombre d’exemplaires existants. Pour
la gestion des livres on propose de définir 3 tableaux : T_Nlivre pour les numéros des livres, T_Titre
pour les titres des livres et T_ Nbr_exp pour les nombres d’exemplaires des livres.
Pour la gestion des emprunts des livres on utilisera pour cela un tableau d’entier à deux dimensions
comme la montre la figure suivante:
N_CIN N_livre J1 M1 A J2 M2 A2
1
….. ….. … … … … … …
Page 84
Atelier de programmation 1
Comme la matrice ci-dessous le montre un emprunt est caractérisé par le Numéro de CIN (N_CIN) de
l’emprunteur le Numéro de livre (N_livre) , la date de l’emprunt (j 1/M1/A1) et la date de retour
prévue ((j2/M2/A2).
1. saisir un emprunt en vérifiant sa validité. Pour qu'un emprunt soit valide il faut que le livre soit
disponible.
2. supprimer un emprunt en précisant la N_CIN et le N_livre. Il est à préciser que la suppression doit
effectuer un décalage dans les tableaux afin d'éviter le gaspillage de mémoire.
3. supprimer un ensemble d’emprunts en précisant une date d’emprunt et une date de retour prévue.
Tous les emprunts appartenant à cette période doivent être supprimés
Remarque : Il est conseillé de remplir les données sur les livres pendant la déclaration des tableaux.
Page 85
Atelier de programmation 1
Quatrième
partie
Page 86
Atelier de programmation 1
int main (); int F1 (int *A, int * void F2 (int K, int
int F1 (int *A, int * B, int * C, int *D) L, int M, int N)
B, int * C, int *D); { {
void F2 (int K, int *B = 5+*B; K = 10;
L, int M, int N); F2 (*A, *B, *C, *D); M = 21;
int main () *A = *C; L = K + L;
{ int X, Y, Z, T; return (8); N = N;
X= 1; Y = 2; Z = 3; T } }
= 4;
Y = F1 (&X, &Y, &Z,
&T);
return (0);
}
Réponse :
X=3,Y=8, Z=3,T=4;
Exemple : Les points cols de la matrice ci-après sont : (0, 3) et (3, 3).
Page 87
Atelier de programmation 1
Réponse :
a.
void SaisirMatrice(int M[][100], int * L, int *C)
{
int i, j;
do {
printf ("Donnez L : ") ; scanf ("%d", L) ;
} while (*L <= 0) || (*L>=100)
do {
printf ("Donnez C : ") ; scanf ("%d", C) ;
} while (*C <= 0) || (*C>=100)
// Saisie de la matrice
for (i=0 ; i < *L; i++)
{
for (j=0 ; j < *C; j++)
{
printf ("Donnez M[%d][%d] : ", i, j) ;
scanf ("%d", &M[i][j]) ;
}
}
}
b.
int EstPointCol (int M[][100], int A, int B, int L, int C)
{
int Max, Min, i, j, trv ;
Max = M[A][B] ;
Min = M[A][B] ;
j =0 ; trv = 0 ;
while ((j < C) && (!trv))
{
if (M [A][j] > Max)
trv = 1 ;
else
j++ ;
}
i = 0 ;
Page 88
Atelier de programmation 1
trv = 1 ;
else
i++ ;
}
return (!trv) ;
}
c.
void TousPointsCol (int M[][100], int L, int C)
{
int i, j, n;
// Rechercher les points cols
n = 0 ;
for (i=0 ; i < L; i++)
{
for (j=0 ; j < C; j++)
{
if (EstPointCol (M, i, j, L, C))
{
if (n==0)
{printf ("Les points cols
de cette matrice sont : ") ;}
printf ("(%d, %d), ", i, j) ;
n ++ ;
}
}
}
if (n ==0)
printf ("Cette matrice ne contient pas de points cols") ;
}
d.
int main()
{
int M [100][100];
int L, C;
SaisirMartice (M, &L, &C) ;
TousPointsCol (M, L, C) ;
return (0) ;
}
Page 89
Atelier de programmation 1
Exercice 1: (8 points)
Soit un tableau d’entiers. On appelle un entier « valable » tout entier strictement supérieur aux entiers qui le
précèdent dans le tableau.
Écrire une fonction en C qui permet de compter le nombre d’entiers « valables » dans un tableau d’entiers
reçu en paramètre.
int FaussesJumelles(int** M1, int NL1, int NC1, int** M2, int NL2,
int NC2)
{
Page 90
Atelier de programmation 1
Page 91
Atelier de programmation 1
{
T2[0][n2]= x;
n2++;
}
}
}
Page 92
Atelier de programmation 1
Références
Page 93