Vous êtes sur la page 1sur 5

USTHB Année :2011/2012

Faculté d’Electronique et d’Informatique Module : ALGO


Département d’Informatique Sections: A LIC-ACAD

Corrigé de l’examen - Algo2


Exercice 1 (1,5+1+1+3,5) (= 7 pts)

1/ int IDENTIQUE (char *m1, char *m2)


{ int i ; int l1 = strlen(m1); int l2 = strlen(m2);
if (l1!=l2) return (0);
for (i =0 ; m1[i]!=’\0’ ; i++) if (m1[i]!=m2[i]) return (0);
/* à la sortie de la boucle*/ return(1); }

2/ int VERIF (char *m)


{ int i ; int l = strlen(m);
if (m[l-2] = = ‘a’ && m[l-1] = = ‘l’) return (1); else return (0);}

3/ void MODIF (char *m)


{ int i ; int l = strlen(m); m[l-1] = ‘u’; m[l] = ‘x’; m[l+1] = ‘\0’; }

4/ void main()
{ char A[50][20]; int n, i, j, l; printf (“donnez le nombre de mots”); scanf (“%d”, &n) ;
// remplissage de la matrice
for (i =0 ; i<n ; i++)
{ printf (“donnez un mot à stocker dans la ligne %d de la matrice”, i); gets (A[i]) ;}
// initialisation du vecteur de mots
char *t[7] = {″aval″, ″bal″, ″bancal″, ″chacal″, ″carnaval″, ″cérémonial″ , ″festival″} ;
// modification des mots de la matrice
for (i =0 ; i<n ; i++)
if (VERIF (A[i]))
{ for (j =0 ; j<7 ; j++) // chercher si le mot existe dans le vecteur t
if (IDENTIQUE(A[i], t[j])) // le mot existe dans le vecteur t
{l = strlen(A[i]) ; A[i][l] = ‘s’ ; A[i][l+1] = ‘\0’; break;}
if (j == 7) MODIF (A[i]);}
// Affichage de la matrice
printf (“voici la matrice après modification”); for (i =0 ; i<n ; i++) puts (A[i]) };

Exercice 2 (14 pts)


Partie I (0.5+ 2+1+3)
typedef struct elt {int element ; int indice ; struct elt *svt; }liste;
liste *CONSTList (int *v, int n)
{ int i; liste *p, *q, *tete = NULL;
for (i =0 ; i<n ; i++)
if (t[i] != 0)
{ p = (liste *)malloc (sizeof(liste)) ; p->element= t[i]; p->indice = i;
if (tete = = NULL) // c’est le 1er élément
{tete = p ; q =p ;} else { q->svt = p ; q=p ;}}
// à la sortie de la boucle p ->svt = NULL ; return (tete) ; }

void AFFICHE (liste *tete)


{ for (p= tete ; p != NULL; p = p->svt) printf (“%d %d”, p->element, p->indice);}

liste *SOMME (liste *T1, liste *T2)


{ liste * p1, p2, p, q, T = NULL; p1 = T1 ; p2 = T2 ; int S ;
while (p1 != NULL && p2 != NULL)
{ p = (liste *)malloc (sizeof(liste)) ;

1 S.Boukhedouma
if (p1->indice < p2->indice)
{p->element= p1->element; p->indice = p1->indice; p1 = p1 ->svt;}
else if (p2->indice < p1->indice)
{p->element= p2->element; p->indice = p2->indice; p2 = p2 ->svt;}
else // égalité des indices
{S = p1->element + p2->element;
if (S!= 0) // s’assurer que la somme n’est pas nulle
{p->element= S; p->indice = p1->indice; p1 = p1 ->svt; p2 = p2 ->svt;}
else free (p); // libérer l’espace alloué car non utilisé
// mise à jour des chainages
if (T = = NULL) {T = p ; q =p ;} else { q->svt = p ; q=p ;}}
}
// à la sortie de la boucle
while (p1 != NULL) // s’il reste des éléments dans T1
{ p = (liste *)malloc (sizeof(liste)) ;
p->element= p1->element; p->indice = p1->indice; p1 = p1 ->svt;
q->svt = p ; q=p ;}

while (p2 != NULL) // s’il reste des éléments dans T2


{ p = (liste *)malloc (sizeof(liste)) ;
p->element= p2->element; p->indice = p2->indice; p2 = p2 ->svt;
q->svt = p ; q=p ;}
p->svt = NULL ; return (T) ; }

Partie II (0.5 + 1,5 + 2)

liste * Tab [100];


void CONSTstr (int A[100][], int n, int m, liste *Tab [])
{ int i ; liste *tete;
for (i =0 ; i<n ; i++)
{ tete = CONSTList (A[i], m); Tab [i] = tete; }}

void main()
{ int A[100][100], B[100][100]; liste * Tab1[100], *Tab2[100] ; int n, m, i, j ;
printf (“donnez les dimensions des matrices”); scanf (“%d %d”, &n, &m) ;
// remplissage des matrices
for (i =0 ; i<n ; i++) for (j =0 ; j<m ; j++) scanf (“%d”, &A[i][j]);
for (i =0 ; i<n ; i++) for (j =0 ; j<m ; j++) scanf (“%d”, &B[i][j]);
// construire les structures
CONSTStr (A, n, m, Tab1); CONSTStr (B,n, m, Tab2);
// la somme des deux matrices
liste * S[100] ; // le vecteur qui va pointer les sommes des lignes
for (i =0 ; i<n ; i++)
S[i] = SOMME (Tab1[i], Tab2[i]) ;
printf (“voici la structure somme des matrices A et B”); // Affichage
for (i =0 ; i<n ; i++) AFFICHE (S[i]); }

Partie III (0.5+ 1,5 +1,5)


Typedef struct eltp { liste *lien ; struct eltp *svt; }pile ;
void Empiler (pile **S, liste *x)
{ p = (pile *)malloc (sizeof(pile)) ; p -> lien = x; p->svt = *S; *S = p;}

pile * CONSTStr (int A[100][], int n, int m)


{ liste *tete; pile *S; Initpile (&S);
for (i =0 ; i<n ; i++)
{ tete = CONSTList (A[i], m); Empiler (&S, tete); }

2 S.Boukhedouma
return (S); }

2 S.Boukhedouma

Vous aimerez peut-être aussi