Examen - Analyse d'algorithmes - 2, Examens de Application informatique. Ecole des Ingénieurs de la Ville de Paris
Christophe
Christophe

Examen - Analyse d'algorithmes - 2, Examens de Application informatique. Ecole des Ingénieurs de la Ville de Paris

3 pages
486Numéro de visites
Description
Exercices de mathématique - examen - analyse d'algorithmes 2. Les principaux thèmes abordés sont les suivants: exercices.
20 points
Points de téléchargement necessaire pour télécharger
ce document
Télécharger le document
Aperçu3 pages / 3
Télécharger le document

ENSEIRB 2007-2008 - Département informatique - Première année IF105 - Analyse d’algorithmes

Examen (session 2)

Veillez à soigner la rédaction de vos solutions, particulièrement vos justifications et vos preuves. Soyez précis et concis. Les coefficients relatifs des exercices sont donnés à titre indi- catif. Seule une feuille A4 de notes manuscrites est autorisée. Bon courage et bonne chance !

Exercice 1 (7 points)

Prouvez, à l’aide du calcul de Hoare, que les triplets suivants sont valides. Vous présenterez vos calculs de preuve détaillés.

1. {3 = 3}x := 3 {x = 3} 2. {true}x := 3 {x = 3} 3. {(t ≥ 0) ∧ (z > 0)} y := 4 ∗ z − t;x := y/2 {x ≤ 2 ∗ z}

4. {(T[l− 1] < x) ∧ (x < T[r + 1]) ∧ sorted(T) ∧ (l ≤ p ≤ r) ∧ (x 6= T[p])} if (x < T[p]) then

r := p-1

else

l := p+1

endif

{(T[l− 1] < x) ∧ (x < T[r + 1]) ∧ sorted(T)}

où sorted(T) signifie que le tableau T est trié :

sorted(T) ≡ ∀i ∈ [0..length(T)− 1[, T[i] ≤ T[i + 1]

5. {(x ∈ R≥0) ∧ (ε ∈ R>0) ∧ (a = x) ∧ (b = 1)} while (|b-a| > ε) do

b := (b+a)/2;

a := x/b

endwhile

{b− ε ≤ √ x ≤ b + ε}

Cet algorithme s’appuie sur le principe suivant :

r2 = x ⇒ 2r2 = r2 + x ⇒ r = r 2 + x

2r ⇒ r = 1

2

( r +

x

r

) dont on déduit la série : ri+1 =

1 2

( ri +

x ri

) .

Exercice 2 (7 points)

Indiquez si les affirmations suivantes sont vraies ou fausses en justifiant votre réponse.

1. Il existe des algorithmes dont nous ne pouvons pas prouver la terminaison par la méthode des ensembles bien fondés

1

2. Le calcul de Hoare ne permet pas de prouver la correction de tous les algorithmes, d’ailleurs il n’existe aucune méthode qui le permet

3. Nous avons bon espoir de trouver un jour une méthode permettant de prouver la ter- minaison de n’importe quel algorithme

4. Pour tout problème de décision il existe une machine de Turing qui le décide

5. Tout problème dont la solution appartient à un ensemble non dénombrable (par exemple, R) peut être résolu par une machine de Turing

6. Une machine de Turing qui utilise un espace mémoire polynômial est nécessairement de complexité temporelle polynômiale

7. La classe de complexité NP est celle des problèmes non-polynômiaux

Exercice 3 (7 points)

On considère l’algorithme ci-dessous qui indique si deux tableaux d’entiers positifs ou nuls T et T’ contiennent les mêmes éléments, et en même nombre, auquel cas T = T′.

1 {(C = countelm(T)) ∧ (C′ = countelm(T′)) ∧ (0 ≤ min(T) ≤ max(T)) ∧ (0 ≤ min(T′) ≤ max(T′))} 2 if (( length(T) = length(T’)) ∧ (max(T) = max(T’))) then 3 i := 0;

4 while ((i ≤ max(T)) ∧ (C[i] = C’[i])) do 5 i := i+1

6 endwhile;

7 if (i > max(T)) then

8 r := true

9 else

10 r := false

11 endif

12 else

13 r := false

14 endif

15 {T = T′ ↔ r = true}

– countelm(T) est une fonction qui calcule un vecteur indicé de 0 à max(T) dont l’élément de rang k est égal au nombre d’occurrences de l’entier k dans T

2 5 3 0 2 3 0 3T 0 1 2 3 4 5

2 0 2 3 0 1countelm(T)

Notons que C = countelm(T) implique length(C) = max(T) + 1 et C est indicé de 0 à max(T).

– same(T, T′, i) signifie que les tableaux T et T’ sont identiques jusqu’au rang i :

same(T, T′, i) ≡ ∀j ∈ [0; i], T[j] = T′[j]

– max(T) et min(T) correspondent respectivement au plus grand et au plus petit entiers qui apparâıssent dans le tableau T

Répondez aux questions suivantes en justifiant vos réponses.

1. On propose l’invariant de boucle suivant. Justifiez la présence et le rôle de chacune de ses trois sous-formules

same(C, C′, i− 1) ∧ (C = countelm(T)) ∧ (C′ = countelm(T′))

2

2. Prouvez la validité des obligations de preuve suivantes générées par adhoc.

(C=countelm(T)) /\ (C’=countelm(T’)) /\ (0<=min(T)<=max(T))

/\ (0<=min(T’)<=max(T’))

[0] ------------------- implies -------------------

(((length(T)=length(T’)) /\ (max(T)=max(T’))) -> same(C,C’,0-1)

/\ (C=countelm(T)) /\ (C’=countelm(T’)) /\ (0<=max(T)+1))

/\ (!((length(T)=length(T’)) /\ (max(T)=max(T’))) -> (T=T’<->false=true))

same(C,C’,i-1) /\ (C=countelm(T)) /\ (C’=countelm(T’))

/\ (i<=max(T)+1) /\ (i<=max(T)) /\ (C[i]=C’[i])

[1] ------------------- implies -------------------

same(C,C’,(i+1)-1) /\ (C=countelm(T)) /\ (C’=countelm(T’))

/\ (i+1<=max(T)+1)

same(C,C’,i-1) /\ (C=countelm(T)) /\ (C’=countelm(T’))

/\ (i<=max(T)+1) /\ !((i<=max(T))/\ (C[i]=C’[i]))

[2] ------------------- implies -------------------

((i>max(T)) -> (T=T’<->true=true))

/\ (!(i>max(T)) -> (T=T’<->false=true))

3. Calculez les complexités asymptotiques temporelle et spatiale de cet algorithme, en prenant en compte le coût de calcul de countelm(T), countelm(T’), max(T) et max(T’) pour lesquels vous proposerez des méthodes efficaces. On fera l’hypothèse que max(T) et max(T’) ne sont calculées qu’une seule fois. On comptera le nombre d’affectations et de comparaisons (complexité temporelle) et le nombre d’entiers (complexité spatiale).

A Règles de Hoare

Règle de conséquence :

P ′ ⇒ P , {P}S {Q} , Q ⇒ Q′ {P ′}S {Q′}

Règle d’affectation :

{P [e/x]}x:=e {P} Règle de séquence :

{P}S1 {Q} , {Q}S2 {R} {P}S1;S2 {R}

Règle du if : {P ∧ B}S1 {R} , {P ∧ ¬B}S2 {R} {P} if B then S1 else S2 endif {R}

Règle du while :

{P ∧ B}S {P} {P} while (B) do S endwhile {P ∧ ¬B}

3

Aucun commentaire n'a été pas fait
Télécharger le document