Exercices dalgorithmique : Correction

Une bonne facon de comprendre les algorithmes presentes dans la suite est dessayer, avec
de petites valeurs pour les param`etres, de simuler lexecution du programme. Cela permet de
comprendre `
a quoi servent les variables du programme, en observant les differentes valeurs prises
durant une execution.

Suite de Fibonacci

Voici deux facons de calculer la suite de les elements de la suite de Fibonacci. La premi`ere
remplit un tableau T contenant toutes les valeurs de la suite, la seconde nutilise que deux
variables a (pour stocker fn1 ) et b (pour fn ).
function b = f ibo0 (n)

function res = f ibo(n)

T = zeros(1, n);
T (1) = 1;
T (2) = 1;
for i = 3 : n

a = 1;
b = 1;
for i = 3 : n
c = a + b;
a = b;
b = c;
end

T (i) = T (i 1) + T (i 2);
end
res = T (n);

Pourquoi ces algorithmes sont-ils corrects ?

Dans f ibo0 par exemple, on peut prouver par recurrence qu`a la fin dune boucle i, la variable
a contient fi1 et la variable b contient fi . Pour les cas de bases n = 1 et n = 2, b contient fn
avant la boucle.

Nombres binaires

Lalgorithme suivant renvoie un tableau de deux cases, la premi`ere contient le quotient et

la seconde le reste de la division euclidienne.
function T = div euclide(a, b)
q = 0;
r = a;
% commentaire ici
while r > b
q = q + 1;
r = r b;
% et ici aussi
end
T (1) = q;
T (2) = r;
1

Cet algorithme renvoie bien le quotient et le reste de la division euclidienne de a par b.

En effet, on peut prouver (par recurrence encore) quau niveau des commentaires, lequation
a = b q + r est verifiee. Or lalgorithme ne sort de la boucle while que si r est plus petit que
b, la deuxi`eme condition pour la division euclidienne est alors verifiee.
Il existe plusieurs facons de traduire un nombre binaire decrit par un X
tableau de 0 et de 1
en un nombre decimal. Une premi`ere facon consiste `a simuler la formule
ai 2(i1) .
16i6n

function d = bin to dec(B)

n = length(B);
d = 0;
for i = 1 : n
d = d + B(i) 2(i1) ;
end
Soit n un nombre, la suite des divisions euclidiennes par 2 donne :
n
q1
q2
qn2
qn1

q1 2
q2 2
q3 2
...
= qn1 2
=
02

=
=
=

+
+
+

a1
a2
a3

+ an1
+ an

avec les ai < 2, do`

u
n = (((. . . (an 2 + an1 ) 2 + . . .) 2 + a3 ) 2 + a2 ) 2 + a1
Cela inspire un autre algorithme nutilisant pas la fonction puissance :
function d = bin to dec0 (B)
n = length(B);
d = 0;
for i = n : 1
d = d 2 + B(i);
end
En developpant la precedente egalite, on obtient
n = an 2n1 + an 2n1 + . . . + a3 22 + a2 21 + a1 20
et donc la formule voulue pour la decomposition en binaire de n. La suite de divisions euclidiennes par 2 nous donne donc une methode pour lalgorithme traduisant un nombre dans sa
representation binaire.
function B = dec to bin(d)
i = 1;
T = [ a 0 ];
while T (1) > 0
T = div euclide(q, 2);
B(i) = T (2);
i = i + 1;
end
2

Enfin, il est possible de sommer 2 nombres binaires contenus dans des tableaux de meme
taille n dans un tableau de taille n + 1.
function B = somme bin(B1, B2)
n = length(B1);
% ret correspond `
a la retenue
ret = 0;
for i = 1 : n
% On somme chaque colonne sans oublier la retenue.
% La division euclidienne nous permet dobtenir
% le chiffre et la retenue qui est propag
ee.
T = div euclide(B1(i) + B2(i) + ret, 2)
B(i) = T (2);
ret = T (1);
end
B(n + 1) = ret;

Maximum et Tri

Les fonctions calculant le maximum (ou lindice du maximum) dun tableau sont simples :
il suffit de parcourir tout le tableau et, `a chaque nouvelle plus grande valeur, mettre `a jour le
resultat.
function m = max(T )
function j = max indice(T )
n = length(T );
n = length(T );
m = T (1);
j = 1;
for i = 2 : n
for i = 2 : n
if m < T (i)
if T (j) < T (i)
m = T (i)
j=i
end
end
end
end
La fonction de tri utilise une fonction qui echange deux valeurs dun tableau. Lalgorithme
consiste `a trouver le plus nombre, et a` lechanger avec le premier element du tableau, puis de
recommencer sur le reste du tableau.
function T = tri(T )
% On cherche le i-`
eme plus petit
% dans le reste du tableau.
for i = 1 : (n 1)
pp = i;
for j = (i + 1) : n
if T (j) < T (pp);
pp = j
end
end
% pp est lindice du plus petit
%
el
ement du tableau [T(i) ... T(n)].
T = echange(T, i, pp);
% le tableau [T(1) ... T(i)]
% est maintenant tri
e.
end
end
3

function T = echange(T, i, j)
temp = T (i);
T (i) = T (j);
T (j) = temp;

Deux algorithmes cherchant un nombre dans un tableau (si lelement est present, on renvoie
son indice, sinon on renvoie 1) sont presentes en parall`ele. Le premier cherche dans un tableau
non trie en parcourant tous les elements. On sarrete si lelement a ete trouve ou si tous les
elements ont ete parcourus. Le deuxi`eme cherche de facon dichotomique : g et d represente les
bornes gauche et droite du sous-tableau o`
u x est cherche. A chaque etape, on regarde le milieu
de cet intervalle, en le comparant avec x on sait alors dans quelle partie du tableau chercher.
function p = present(T, x)

function b = present tri(T, x)

g = 1;
d = length(T );
i = f loor((g + d)/2);
while T (i) = x && g <= d
if x < T (i)
d = i 1;
else
g = i + 1;
end
i = f loor((g + d)/2);
end
if g > d
p = 1;
else
p = i;
end

i = 1;
while T (i) = x && i <= n

i = i + 1;
end
if i > n
p = 1;
else
p = i;
end

Les tests a` la fin determinent de quelle facon est-on sorti de la boucle while : dans un cas x
nest pas present (on renvoie 1), dans lautre on connait son indice.