Corrig du test algorithmique n1

E XERCICE 1 : D EUX

CALCULS SIMPLES

Deux boucles itratives simples, avec un accumulateur pour contenir les rsultats intermdiaires.
1)

(a) Par dfinition, nk = 1 n n. On en dduit lalgorithme :

|
{z
}


k facteurs n

fonction puissance ( n , k : e n t i e r s ) : e n t i e r ;
// puissance ( n , k ) c a l c u l e l e n t i e r n^k
// acc : e n t i e r contenant l e s produits
intermdiaires
// i : e n t i e r compteur de boucle

acc < 1
// aprs l i t r a t i o n n i , acc c o n t i e n t n^ i
pour i de 1 k f a i r e acc < acc n
retourner acc

Pour vrifier que cet algorithme effectue le bon calcul, il suffit de constater qu litration i, acc
contient ni .
(b) Le corps de boucle est excut pour toutes les valeurs de i entre 1 et k, donc k fois. On effectue
donc k multiplications.
On pourrait faire une multiplication de moins en initialisant acc n, mais alors on perdrait le
cas o k = 0.
2)

(a) Cest le mme algorithme, seuls les calculs changent :


fonction f a c t o r i e l l e ( n : e n t i e r ) : e n t i e r ;

// f a c t o r i e l l e ( n ) c a l c u l e n ! = 1 2 . . . n
// acc : e n t i e r contenant l e s produits
intermdiaires
// i : e n t i e r compteur de boucle

acc < 1
// aprs l i t r a t i o n n i , acc c o n t i e n t i !
pour i de 1 n f a i r e acc < acc i
retourner acc

Il est facile de voir qu litration i, acc contient i!.

(b) Encore une fois, le corps de boucle est excut n fois, donc on effectue n multiplications.

E XERCICE 2 : P LUS

HAUTE MARCHE

1) Lalgorithme consiste calculer les diffrences entre deux lments conscutifs, et trouver la plus
grande. Cest un exercice de recherche de maximum. tableau est le type du tableau daltitudes.



fonction haut_max (m : tableau ) : e n t i e r ;
// haut_max (m) renvoie l a plus grande d i f f r e n c e entre deux
// cases conscutives du tableau d e n t i e r s m.
// hm : e n t i e r contenant l a plus grande hauteur rencontre
// i : e n t i e r compteur de boucle

hm < m[ 1 ] // on dmarre de 0
pour i de 2 n f a i r e
// aprs l a i me i t r a t i o n , hm c o n t i e n t l a plus grande
// d i f f r e n c e trouve dans l e tableau m entre l e s i n d i c e s
// 1 e t i .
hm < max(hm,m[ i ]m[ i 1])
retourner hm

2) Les comparaisons sont effectues lors de lexcution des instructions max. On en effectue une par
passage dans la boucle, soit N 1. Il en est de mme du nombre de soustractions.
3) Dans cet algorithme, il faut la fois se souvenir de la hauteur maximale dj rencontre, comme
prcdemment, et de lindice correspondant.


fonction ind_haut_max (m : tableau ) : e n t i e r ;
// ind_haut_max (m) renvoie l i n d i c e de dpart de l a plus
// grande d i f f r e n c e entre deux cases conscutives du tableau
m.

// hm e t i comme prcdemment .
// im : e n t i e r contenant l i n d i c e de l a hauteur maximale .
hm < m[ 1 ]
im < 0
// i n d i c e du p o i n t de dpart du plus grand pas
pour i de 2 n f a i r e
h < m[ i ] m[ i 1]
// h est l a hauteur du pas courant
s i h > hm a l o r s
hm < h
im < i 1
// hm correspond m[ im+1]m[ im ]
retourner im

E XERCICE 3 : R ECHERCHE

DANS UN TABLEAU , DANS UNE MATRICE

Dans tout cet exercice, le type des tableaux une dimension sera not tableau, celui des tableaux
deux dimensions matrice.
1) Exploration itrative du tableau et de la matrice
(a) Encore une fois, on explore entirement un tableau, une boucle pour et un compteur devraient
faire laffaire.


fonction nb_zero_tableau ( t : tableau ) : e n t i e r ;
// nb_zero_tableau ( t ) renvoie l e nombre de cases du tableau
t
// contenant 0.
// nbzero : e n t i e r contenant l e nombre de zros au cours de
// l e x p l o r a t i o n .
// i : e n t i e r compteur de boucle .

nbzero <
pour i de
si t [ i ] =
nbzero
retourner

0
1 N faire
0 alors
< nbzero + 1
nbzero

(b) Le corps de boucle, contenant une comparaison, est effectu N fois, on fait donc N comparaisons.
(c) Pour une matrice, on emploie une paire de boucles imbriques, ce nest pas beaucoup plus
compliqu que pour un tableau une dimension.


fonction nb_zero_matrice (m : matrice ) : e n t i e r ;
// nb_zero_matrice (m) renvoie l e nombre de cases de l a
matrice m
// contenant 0.
// nbzero : e n t i e r contenant l e nombre de zros au cours de
// l e x p l o r a t i o n .
// i : e n t i e r compteur de boucle , numro de l a l i g n e en cours
.
// j : e n t i e r compteur de boucle , numro de l a colonne en
cours .

nbzero < 0
// On explore l a matrice l i g n e par l i g n e
pour i de 1 N f a i r e
pour j de 1 M f a i r e
si t [ i ] = 0 alors
nbzero < nbzero + 1
retourner nbzero

La boucle interne fait M comparaisons, elle est elle-mme excute N fois, on effectue donc au
total NM comparaisons.
ltape (i,j) de la double boucle, nbzero contient le nombre de zro dans les i-1 premires
lignes, ainsi que dans les j premires cases de la ligne i.
2) Exploration conditionnelle du tableau et de la matrice
(a) La boucle est dsormais conditionnelle. On sarrte ds quon a atteint la fin du tableau, ou si
on a trouv le nombre demand de zros.


fonction au_moins_k_zero_tableau ( t : tableau ; k : e n t i e r ) :
boolen ;
// au_moins_k_zero_tableau ( t , k ) renvoie Vrai s i l e tableau t
// c o n t i e n t au moins k cases gales 0 , Faux sinon .

// nbzero e t i comme dans l a premire p a r t i e .

nbzero < 0
i < 1
// La c o n d i t i o n de s o r t i e :
// on est a r r i v l a f i n du tableau ( i >N )
// ou on a rencontr suffisamment de zros ( nbzero>=k ) .
tant_que ( i <= N) et ( nbzero < k ) f a i r e
s i t [ i ] = 0 a l o r s nbzero < nbzero + 1
i < i + 1
// On renvoie l e r s u l t a t du t e s t ( nbzero >= k ) .
renvoyer ( nbzero >= k )

(b) Comme le nombre de zro peut tre dj atteint ds le dpart (k=0), ou jamais atteint, on
ne peut prdire le nombre ditrations de la boucle lavance (cest--dire sans connatre le
rsultat !). On sait par contre que chaque itration demande trois comparaisons (les tests
i<=N et nbzero<k, et le test t[i]=0), on excutera de 2 comparaisons (cas o k=0) 3N+1
comparaisons (cas o on atteint la fin du tableau.
On pourrait effectuer un test chaque tape pour vrifier si il reste assez de cases pour remplir
la mission. Par exemple, si k=N, ds quon rencontre une case contenant autre chose quun
0, on sait quon ne peut plus compter suffisamment de cases gales 0. Mais cela alourdit le
corps de boucle, et ne peut donc tre envisag que si ce cas est suffisamment frquent. Seule
une tude statistique permet de vrifier si le gain attendu compense lallongement des calculs
chaque tape.
(c) Lcriture dune boucle conditionnelle pour explorer une matrice est un peu plus complique.
Voici un exemple parmi dautres :


fonction au_moins_k_zero_matrice (m : matrice ; k : e n t i e r ) :
boolen ;
// au_moins_k_zero_matrice (m, k ) renvoie Vrai s i l a matrice m
// c o n t i e n t au moins k cases gales 0 , Faux sinon .
// nbzero , i e t j comme prcdemment .

// I n i t i a l i s a t i o n .
nbzero < 0
i < 1
j < 1
// La matrice est explore l i g n e par l i g n e .
// Condition de s o r t i e :
// on est a r r i v l a f i n de l a matrice ( i >N, on a dpass la
// dernire l i g n e )
// ou on a rencontr suffisamment de zros ( nbzero>=k ) .
tant_que ( i <= N) et ( nbzero < k ) f a i r e
s i m[ i , j ] = 0 a lo r s nbzero < nbzero + 1
j < j + 1
// Cette p a r t i e c a l c u l e l e s coordonnes de
l a case
si j > M alors
// suivante . On augmente l i n d i c e de
colonne
j < 1
// moins qu on s o i t l a dernire colonne .
i < i +1
// ( i ,N ) > ( i +1 ,1) , ( i , j ) > i , j +1) s i j <
N.
// On renvoie l e r s u l t a t du t e s t ( nbzero >= k ) .
renvoyer ( nbzero >= k )

Comme indiqu, la matrice est explore ligne par ligne (i est le compteur de ligne, j le compteur
de colonne). La case suivant la case dindice [i,j] est la case [i,j+1] moins que j soit gal
M (fin de ligne), auquel cas on passe la ligne suivante et on rinitialise j 1. Le calcul se
termine lorsque i prend la valeur N+1, juste aprs avoir explor la case dindice N,M.