Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Sammoud
EXERCICES DE REVISION
PROGRAMMATION I
1
ESTI 2008-2009 M. Sammoud
L’objectif de ces exercices est la manipulation des chaînes de caractères en utilisant les
fonctions offertes par la bibliothèque <string.h>
Exercice 1
Pour tester ces sous programmes on vous demande d’écrire un programme principal qui
permet de saisir un texte (supposée ne pas dépasser 132 caractères), on utilisera les tableaux
dynamiques pour la déclaration du texte et la fonction gets pour saisir le texte qui doit se
terminer par return. Quelle est la différence entre scanf et gets (pour répondre, testez
avec les deux)
Faites appel à toutes les fonctions et procédures implémentées au dessus dans votre main.
/*******************************************************
CORRECTION
AUTEUR : M. SAMMOUD
1ERE ANNEE INFORMATIQUE APPLIQUEE (ESTI)
*********************************************************/
Exercice 1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
/* Exercice 1
a) en utilisant la fonction strchr
2
ESTI 2008-2009 M. Sammoud
int nbre=0;
while((adr=strchr(adr,CAR))!= NULL)
/*strchr retourne un pointeur vers la première occurrence de CAR, on teste
si c'est Différent de NULL on continu l'itération sinon on sort de la
boucle */
{
nbre++;
adr++;
return nbre;
}
// c) affichage à l'envers
// programme principal
void main()
{
int cmpt=0;
char * texte=(char*)malloc(LGMAX*sizeof(char));
// Saisir le texte
gets(texte);//
// question a)
//Question b)
supprimer_apparition_car (texte);
printf ("\n Voici votre texte prive des caractères %c \n ",CAR) ;
puts(texte);
3
ESTI 2008-2009 M. Sammoud
//Question c)
afficher_envers (texte);
Exercice 2
Ecrire une procédure qui lit un verbe du premier groupe et qui en affiche la conjugaison au
présent de l'indicatif, sous la forme :
Je programme
Tu programmes
Il programme
Nous programmons
Vous programmez
Ils programment
Le programme devra vérifier que le mot fourni se termine bien par ''er". On supposera qu'il ne
peut comporter plus de 26 lettres et qu'il s'agit d'un verbe régulier. Autrement dit, on
admettra que l'utilisateur ne fournira pas un verbe tel que "manger" (le programme
afficherait alors : ''nous mangons" !).
Testez cette procédure en implémentant un programme principal.
Exercice 2
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define LGMAX 26
/* Exercice 2*/
adr_fin=verbe+strlen(verbe)-2;
for(i=0;i<6;i++)
{
strcpy(adr_fin,terminaison[i]);
printf("\n %s %s \n", deb[i], verbe);
}
void main()
{
char * verbe=(char*)malloc(LGMAX*sizeof(char));
4
ESTI 2008-2009 M. Sammoud
char *fin;
// Saisir le verbe
do
{
printf("\n Donnez un verbe du premier groupe \n");
gets(verbe);
fin=verbe+strlen(verbe)-2;
}while(strcmp(fin,"er"));
conjuger( verbe);
Exercice 2 (3 points)
boolean test ( )
{
int i, nbre;
boolean Ok;
do
{
printf (" donnez un nombre entier compris entre 0 et
100") ;
scanf ("%d", &nbre) ;
}while((nbre<0)||(nbre>100)) ;
/* initialisation du traitement */
/* initialisation de l’avancement */
i=2 ;
/* initialisation de l’arret */
Ok=TRUE;
while ((i<nbre) && (Ok==TRUE))
{
if ((nbre % i) ==0) /*arret*/
Ok=FALSE;
else
i++; /* traitement et avancement*/
}
return Ok;
}
5
ESTI 2008-2009 M. Sammoud
6
ESTI 2008-2009 M. Sammoud
7
ESTI 2008-2009 M. Sammoud
Un nombre complexe est défini par une partie réelle et une partie imaginaire. (Exemple : 3.5+5*i est
un nombre complexe) On se propose dans cet exercice d’effectuer quelques opérations sur ces
nombres.
1) Définir une structure de données en C permettant de représenter un nombre
complexe. (1 point)
Un nombre complexe peut être représenté en utilisant les enregistrements : 0.5
point
struct Complexe
{
float reel ;
float imaginaire ;
} ; 0.5 point
2) Que doit on ajouter à cette structure de données pour qu’elle devienne un type ?
On ajoute l’instruction typedef pour que complexe se comporte comme un type.
(0.5 point)
3) Pour saisir un nombre complexe on vous demande d’écrire une procédure
appelée Saisir_Complexe. En supposant qu’on a définit un type tComplex
voici des propositions de prototypes pour cette procédure, une seule est correcte
indiquez laquelle, en justifiant votre réponse et en indiquant quels sont les erreurs
dans les trois propositions fausses. (2.5 points)
a) tComplex Saisir_Complexe( ) ;
b) void Saisir_Complexe( ) ;
c) void Saisir_Complexe(tComplex C1) ;
d) void Saisir_Complexe(tComplex * C1) ;
d) void Saisir_Complexe(tComplex * C1) ;est le prototype
correcte (0.5 point), c’est une procédure et le passage de
paramètre est par adresse donc tout changement sera sauvegardé
(0.5 point)
e) tComplex Saisir_Complexe( ) ; on demande
d’implémenter une procédure et e) est une
fonction puisqu’elle a une valeur de retour (0.5
point)
8
ESTI 2008-2009 M. Sammoud
}
5) implémenter les fonctions suivantes :
a) est_reel_pure : retourne 0 (ou faux) si le complexe possède une
partie imaginaire différente de 0 (0.25 point)
9
ESTI 2008-2009 M. Sammoud
return Res ;
}
6) proposez un programme principal qui testera toutes les fonctions et les procédures
décrites au dessus, on utilisera le menu suivant : (2 points)
Indication :
- utilisez la structure conditionnelle switch…case pour le menu.
- Le programme ne s’arrête que si le choix entré est 6, utilisez la boucle adéquate.
void main()
{
int choix ;
tComplex C1,C2, som, dif ;
do
{
Printf("\n 1- Saisir un nombre complexe\n
\n 2- Comparer deux nombres complexes\n
\n 3- Réel pure\n
\n 4- Somme\n
\n 5- Soustraction\n
\n 6- Quitter\n
\n \t\t\t\tDONNEZ VOTRE CHOIX : ") ;
Scanf("%d",&choix) ;0.25
switch (choix)
{
10
ESTI 2008-2009 M. Sammoud
case 1 :
Saisir_Complexe(& C1) ;
break ;
case 2 :
{
Saisir_Complexe(& C2) ;
if(est_egale(C1,C2)==1)
printf("les deux nombre complexes sont egaux") ;
else
printf("les deux nombre complexes ne sont pas egaux") ;
break ;
}
case 3 :
if(est_reel_pure(C1)==1)
printf("le nombre complexes %d + %d*i est reel pure",
C1.reel, C1.imaginaire) ;
else
printf("le nombre complexes %d + %d*i n’est pas
reel pure", C1.reel, C1.imaginaire) ;
break ;
case 4 :
som= additionner (C1,C2);
printf("la somme de (%d + %d*i) et (%d + %d*i)est (%d +
%d*i)", C1.reel, C1.imaginaire, C2.reel,C2.imaginaire, som.reel,
som.imaginaire) ;
break ;
case 5 :
dif=soustraire (C1,C2);
printf("la soustraction de (%d + %d*i) et (%d + %d*i)est
(%d + %d*i)", C1.reel, C1.imaginaire, C2.reel, C2.imaginaire,
som.reel, som.imaginaire) ;
break ;
}
}while(choix !=6) ;0.25
}
11
ESTI 2008-2009 M. Sammoud
Les Tableaux
Exercice 1 :
Ecrire une fonction qui permet de rechercher le nombre le plus proche d'un nombre donné x
dans un tableau de 20 entiers donné tab.
Correction :
#include<stdlib>
#define MAX 20
int chercher ( int x, int tab [ MAX])
{
int i, buff,diff;
diff =abs(x-tab[0]);
for( i=1;i<MAX;i++)
{
if ( abs(x-tab[i])<= diff)
{
diff= abs(x-tab[i]);
buff=tab[i];
}
}
return buff;
}
Exercice 2
Afficher les entiers n'apparaissant qu'une fois dans un tableau d'entiers donné tab de
longueur ltab (1000 ≥ ltab ≥ 1).
12
ESTI 2008-2009 M. Sammoud
do
{
Printf(″donnez la taille du tableau″) ;
Scanf(″%d″,&n) ;
}while ((n>1000)||(n<1)) ;
Exercice 3
Ecrire une fonction permettant de vérifier l'équivalence de deux tableaux d'entiers (mêmes val
suivant le même ordre)
Exercice 4
Soit t un tableau de 6 nombres entiers, initialisé avec le mois et l’année de VOTRE date de
naissance (mmaaaa). Par exemple, si vous êtes n´e(e) en avril 1995, le tableau t contient :
0 4 1 9 9 5.
On suppose :
- que la fonction afficher(t,n) affiche sur une même ligne les n éléments du tableau t séparés
par un espace ;
- que la fonction permuter(t,i,j) permute les éléments d’indices i et j du tableau t ;
- que les variables i, j, k représentent des nombres entiers.
Rappel : si i et j sont deux entiers, la valeur de i%j est le reste de la division entière de i par j.
Décrire les affichages produits lorsque l’on exécute les instructions suivantes :
afficher(t,6) ;
for (i=0;i<6;i++) t[i] = t[i]%4 ;
afficher(t,6) ;
for (i=0 ; i<5 ; i++)
{
k=i;
for (j=i+1 ; j<6 ; j++)
13
ESTI 2008-2009 M. Sammoud
{
if (t[j] > t[k])
k=j;
}
permuter (t,i,k) ;
afficher(t,6) ;
}
A partir de deux dates la fonction Diff calcul le nombre de jours qui séparent ces deux dates,
en tenant compte des années bissextiles.
if (M == 1)
{
D = J;
}
else
{
for (i = 0; i < (M-1); i++)
{
D += Mois[i];
}
D+=J;
}
if ((M > 2) && (Bissextile(A)))
{
D++;
}
return D;
}
/*la fonction diff proprement dite*/
int Diff (int j1, int m1, int a1, int j2, int m2, int a2)
{
int NJ = 0, NJ1, NJ2, i;
14
ESTI 2008-2009 M. Sammoud
if (Bissextile (a1+i))
{
NJ++;
}
}
NJ -= NJ1;
NJ += NJ2+1;
}
return NJ;
}
15
ESTI 2008-2009 M. Sammoud
Comparateur de dates
Cette fonction permet de comparer deux dates sous forme de chaînes de caractères
d = 0.0;
if (Precision <= 0)
Puissance = 16;
else
Puissance = Precision;
break ;
}
}
}
return d;
}
16
ESTI 2008-2009 M. Sammoud
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
if (ct)
{
int i;
if (ct)
{
int i;
17
ESTI 2008-2009 M. Sammoud
#include <stdio.h>
#include <math.h>
while (i < d)
{
if (nbr % i == 0)
{
return 0;
}
i += 2;
}
return 1;
}
18
ESTI 2008-2009 M. Sammoud
int main(void)
{
int i;
Exemple :
Division euclidienne de 20 par 3
20 = 3 * 6 + 2
avec
0 <= 2< 3
En utilisant des divisions euclidiennes successives, on peut trouver le PGCD de deux entiers
relatifs.
unsigned long pgcd(long a, long b, int voirAlgorithme)
{
long dividende = labs(a); /* le dividende contient la valeur
absolue de a */
long diviseur = labs(b); /* le diviseur contient la valeur
absolue de b */
long quotient;
long reste;
int fin = 0;
/*
* on ne calcule le pgcd de deux nombres que s'ils sont différents
de zéro
*/
if(a != 0 && b != 0)
{
while(!fin)
{
/* On applique la division euclidienne */
reste = dividende % diviseur;
19
ESTI 2008-2009 M. Sammoud
/*
* Si l'affichage de l'algorithme est souhaité,
* on affiche chaque ligne
*/
if (voirAlgorithme)
{
printf (
"%ld = %ld * %ld + %ld\n",
dividende, diviseur, quotient, reste
);
}
return diviseur;
}
20