Download Algorithmic and Programming Exam: Master BioInformatique, December 2013 and more Exercises Algorithms and Programming in PDF only on Docsity!
Master BioInformatique
Ann´ee : 2013/2014 Semestre de d´ecembre 2013
PARCOURS : Master 1 UE J1BS7202 : Algorithmique et Programmation Epreuve :^ ´ Examen Date : Jeudi 19 d´ecembre 2013 Heure : 9 heures Dur´ee : 2 heures Documents : autoris´es Epreuve de M. Alain´ Griffault
SUJET + CORRIGE
Avertissement
- La plupart des questions sont ind´ependantes.
- A` chaque question, vous pouvez au choix r´epondre par un algorithme ou bien par un programme python.
- Les indentations des fonctions ´ecrites en Python doivent ˆetre respect´ees.
- L’espace laiss´e pour les r´eponses est suffisant (sauf si vous utilisez ces feuilles comme brouillon, ce qui est fortement d´econseill´e).
Question Points Score Mise en bouche 7 Algorithmes de rang 14 Liste doublement chain´ee 9 Total: 30
Exercice 1 : Mise en bouche (7 points)
(a) (1 point) Deux nombres sont oppos´es si leur somme est ´egale a 0. Deux nombres sont inverses si leur produit est ´egala 1. Ecrire un algorithme´ sontInvOuOpp(a,b) o`u a et b sont deux nombres, qui retourne Vrai si a et b sont inverses ou oppos´es, Faux sinon.
Solution: Deux solutions parmi d’autres.
def sontInvOuOpp ( a , b ) : return a+b==0 or a∗b==
Algorithme 1: SontInvOuOpp(a,b) Donn´ees : Deux nombres a et b retourner (a+b=0) OU (a*b=1);
(b) (2 points) Ecrire un algorithme´ existeInvOuOppConsecutifs(T) o`u T est un tableau de nombres, qui retourne Vrai si T contient deux nombres cons´ecutifs oppos´es ou inverses, Faux sinon.
Solution: Deux solutions parmi d’autres.
def e x i s t e I n v O u O p p C o n s e c u t i f s (T ) : for i in range ( l e n (T) −1): i f sontInvOuOpp (T[ i ] ,T[ i + 1 ] ) : return True return F a l s e
Algorithme 2: ExisteInvOuOppConsecutifs(T) Donn´ees : Un tableau T de nombres pour i=0 `a len(T)-2 faire si sontInvOuOpp(T[i],T[i+1]) alors retourner True;
retourner False;
(c) (2 points) Ecrire un algorithme´ existeInvOuOpp(T) o`u T est un tableau de nombres, qui retourne Vrai si T contient deux nombres, ayant des indices diff´erents, oppos´es ou inverses, Faux sinon.
Solution: Deux solutions parmi d’autres.
def existeInvOuOpp (T ) : for i in range ( l e n (T) −1): for j in range ( i +1, l e n (T ) ) : i f sontInvOuOpp (T[ i ] ,T[ j ] ) : return True return F a l s e
Algorithme 3: ExisteInvOuOpp(T) Donn´ees : Un tableau T de nombres pour i=0 a len(T)-2 faire pour j=i+1a len(T)-1 faire si sontInvOuOpp(T[i],T[j]) alors retourner True;
retourner False;
(d) (2 points) Ecrire un algorithme´ nbInvOuOpp(T) o`u T est un tableau de nombres, qui retourne le nombre de paires d’indices (i,j) telles que : d’une part i<j ; d’autre part T[i] et T[j] soient des nombres oppos´es ou inverses.
Solution: Deux solutions parmi d’autres.
def nbInvOuOpp (T ) : nb = 0 for i in range ( l e n (T) −1): for j in range ( i +1, l e n (T ) ) : i f sontInvOuOpp (T[ i ] ,T[ j ] ) : nb = nb+ return nb
Algorithme 4: NbInvOuOpp(T) Donn´ees : Un tableau T de nombres nb ← 0; pour i=0 a len(T)-2 faire pour j=i+1a len(T)-1 faire si sontInvOuOpp(T[i],T[j]) alors nb ← nb+1;
retourner nb;
Exercice 2 : Algorithmes de rang (14 points)
Le probleme de la s´election consistea trouver dans un tableau de nombres l’´el´ement dit de rang i.
Pour cet exercice, du fait que les indices d’un tableau T sont compris entre 0 et longueur(T)-1, nous admettrons que l’´el´ement de rang 0 est le plus petit ´el´ement du tableau, et que l’´el´ement de rang longueur(T)-1 est le plus grand.
Exemple : Soit T = [8, 6 , 53 , 8 , 2 , 9 , 3 , 10], alors :
- Les ´el´ements de rang < 0 sont ind´efinis.
- L’´el´ement de rang 0 est 2.
- L’´el´ement de rang 1 est 3.
- L’´el´ement de rang 2 est 6.
- L’´el´ement de rang 3 est 8.
- L’´el´ement de rang 4 est 8.
- L’´el´ement de rang 5 est 9.
- L’´el´ement de rang 6 est 10.
- L’´el´ement de rang 7 est 53.
- Les ´el´ements de rang > 7 sont ind´efinis.
i. (2 points) Ecrire un algorithme´ rangSelection(T,r) fortement inspir´e de l’algorithme ou du programme python triSelection(T) qui r´esout le probleme de la s´election. Ne pas oublier de s’assurer que le rang d´esir´e corresponda un indice du tableau.
Solution: Deux solutions parmi d’autres.
def r a n g S e l e c t i o n (T, r ) : i f r < 0 or r>=l e n (T ) : return None for i in range ( r +1): iMin = i for j in range ( i +1, l e n (T ) ) : i f T[ j ]<T[ iMin ] : iMin = j i f iMin != i : echange (T, i , iMin ) return T[ r ]
Algorithme 8: RangSelection(T,r) Donn´ees : Un tableau T de nombres, et un indice r R´esultat : L’´el´ement de rang r du tableau T si r<0 OU r ≥ longueur(T) alors retourner nil; pour i=0 a r faire iMin ← i; pour j=i+1a longueur(T)-1 faire si T[j] <T [iMin] alors iMin ← j;
si i 6 = iMin alors Echange(T,i,iMin);
retourner T[r];
ii. (1 point) Compl´eter le tableau des complexit´es en fonction de n=longueur(T) et du rang r. Rappel : Les complexit´es ne d´ependent pas de valeurs particulieres des parametres n et r, mais de valeurs particuli`eres contenues dans le tableau.
Solution: TriSelection(T) RangSelection(T,r) Temps (meilleur des cas) Ω(n^2 ) Ω(n × r) Temps (pire des cas) O(n^2 ) O(n × r) Espace (meilleur des cas) Ω(1) Ω(1) Espace (pire des cas) O(1) O(1)
Non demand´e : Il est facile d’am´eliorer (un peu) la solution en s´electionnant les valeurs minimales (comme ici) lorsque r < n/2, et en s´electionnant les valeurs maximales lorsque r ≥ n/2. Les complexit´es s’expriment alors en rempla¸cant r par min(r, n − r).
(b) Solution adapt´ee du tri `a bulle vu en cours.
def t r i B u l l e (T ) : for i in range ( l e n (T) −1 ,0 , −1): for j in range ( i ) : i f T[ j ]>T[ j + 1 ] : echange (T, j , j +1)
Algorithme 9: TriBulle(T) Donn´ees : Un tableau T de nombres R´esultat : Le tableau T tri´e en ordre croissant pour i=len(T)-1 a 1 decroissant faire pour j=0a i-1 faire si T[j] >T [j+1] alors Echange(T,j,j+1);
Il semble ´evident qu’une fois la valeur d´esir´ee bien plac´ee dans le tableau, il est inutile de continuer le tri. i. (2 points) Ecrire un algorithme´ rangBulle(T,r) fortement inspir´e de l’algorithme ou du programme python triBulle(T) qui r´esout le probleme de la s´election. Ne pas oublier de s’assurer que le rang d´esir´e corresponda un indice du tableau.
Solution: Deux solutions parmi d’autres.
def r a n g B u l l e (T, r ) : i f r < 0 or r>=l e n (T ) : return None for i in range ( l e n (T) −1 , r −1 , −1): for j in range ( i ) : i f T[ j ]>T[ j + 1 ] : echange (T, j , j +1) return T[ r ]
Algorithme 10: RangBulle(T,r) Donn´ees : Un tableau T de nombres et un indice r R´esultat : L’´el´ement de rang r du tableau T si r<0 OU r ≥ longueur(T) alors retourner nil; pour i=len(T)-1 a r, decroissant faire pour j=0a i-1 faire si T[j] >T [j+1] alors Echange(T,j,j+1);
retourner T[r];
ii. (1 point) Compl´eter le tableau des complexit´es en fonction de n=longueur(T) et du rang r.
Solution: TriBulle(T) RangBulle(T,r) Temps (meilleur des cas) Ω(n^2 ) Ω(n × (n − r)) Temps (pire des cas) O(n^2 ) O(n × (n − r)) Espace (meilleur des cas) Ω(1) Ω(1) Espace (pire des cas) O(1) O(1) Non demand´e : Il est facile d’am´eliorer (un peu) la solution en faisant monter les grosses bulles (comme ici) lorsque r ≥ n/2, et en faisant descendre les petites bulles lorsque r < n/2. Les complexit´es s’expriment alors en rempla¸cant n − r par min(r, n − r).
(c) Solution adapt´ee du tri rapide vu en cours. Soit la variante suivante de l’algorithme de partition bas´ee sur l’algorithme du drapeau Hollandais vu en cours.
Cet algorithme partitionne le tableau en trois zones : la premiere contient des valeurs strictement inf´erieuresa la valeur du pivot ; la seconde contient des valeurs ´egales a la valeur du pivot ; et la troisieme des valeurs strictement sup´erieures `a la valeur du pivot.
ii. (2 points) Cette version am´elior´ee du tri rapide tire profit des trois zones, en ne faisant pas d’appel r´ecursif sur la zone interm´ediaire, car les valeurs de cette zone sont correctement plac´ees.
def t r i R a p i d e R e c (T, g , d ) : i f g < d : i , j , k = t r o i s P a r t i t i o n n e r (T, g , d ) t r i R a p i d e R e c (T, g , i −1) t r i R a p i d e R e c (T, k+1,d )
def t r i R a p i d e (T ) : t r i R a p i d e R e c (T, 0 , l e n (T) −1)
Algorithme 12: TriRapide- Rec(T,g,d) Donn´ees : Un tableau T de nombres, et deux indices g et d R´esultat : Le tableau T[g..d] tri´e en ordre croissant si g<d alors (i,j,k) ← troisPartitionner(T,g,d); TriRapideRec(T,g,i-1); TriRapideRec(T,k+1,d);
Algorithme 13: TriRapide(T) Donn´ees : Un tableau T de nombres R´esultat : Le tableau T tri´e en ordre croissant TriRapideRec(T,0,longueur(T)-1);
Ecrire des algorithmes´ rangRapide(T,r) et rangRapideRec(T,g,d,r) fortement inspir´es des algorithmes triRapide(T) et triRapideRec(T,g,d), qui r´esolvent le probleme de la s´election. Ne pas oublier de s’assurer que le rang d´esir´e corresponda un indice du tableau.
Solution: Deux solutions parmi d’autres.
def rangRapideRec (T, g , d , r ) : i f g<d : i , j , k = t r o i s P a r t i t i o n n e r (T, g , d ) i f r<i : rangRapideRec (T, g , i −1, r ) e l i f r>k : rangRapideRec (T, k+1,d , r )
def rangRapide (T, r ) : i f r < 0 or r>=l e n (T ) : return None rangRapideRec (T, 0 , l e n (T) −1 , r ) return T[ r ]
Algorithme 14: RangRapideRec(T,g,d,r) Donn´ees : Un tableau T de nombres, trois indices g, d et r R´esultat : Positionne l’´el´ement de rang r du tableau T si g<d alors (i,j,k) ← troisPartitionner(T,g,d); si r<i alors RangRapideRec(T,g,i-1,r); sinon si r>k alors RangRapideRec(T,k+1,d,r);
Algorithme 15: RangRapide(T,r) Donn´ees : Un tableau T de nombres, et un indice r R´esultat : L’´el´ement de rang r du tableau T si r<0 OU r ≥ longueur(T) alors retourner nil; RangRapideRec(T,0,longueur(T)-1,r); retourner T[r];
iii. (1 point) Compl´eter le tableau des complexit´es en fonction de n=longueur(T) et du rang r.
Solution: TriRapide(T) RangRapide(T,r) Temps (meilleur des cas) Ω(n) Ω(n) (Toutes les valeurs identiques) Temps (pire des cas) O(n^2 ) O(n × r) (tableau tri´e) Espace (meilleur des cas) Ω(1) Ω(1) Espace (pire des cas) O(n) O(r)
(d) La solution naturelle au probleme de s´election bas´e sur le tri rapide est une solution r´ecursive. En examinant le d´eroulement de votre programme, vous devez vous apercevoir qu’aucun calcul pertinant n’est r´ealis´e des que l’on commence a d´epiler les appels r´ecursifs de la pile d’ex´ecution. Dans de tel cas, il est assez facile de transformer une solution r´ecusrsive en une solution it´erative. i. (2 points) Ecrire un algorithme´ rangRapideIteratif(T,r) obtenua partir de votre solution `a la question pr´ec´edente.
Solution: Deux solutions parmi d’autres.
def r a n g R a p i d e I t e r a t i f (T, r ) : i f r < 0 or r>=l e n (T ) : return None g = 0 d = l e n (T)− 1 while True : i , j , k = t r o i s P a r t i t i o n n e r (T, g , d ) i f r<i : d = i − 1 e l i f r>k : g = k+ e l s e : return T[ r ]
Algorithme 16: RangRapideIteratif(T,r) Donn´ees : Un tableau T de nombres, et un indice r R´esultat : L’´el´ement de rang r du tableau T si r<0 OU r≥longueur(T) alors retourner nil; g ← 0; d ← longueur(T)-1; tant que True faire (i,j,k) ← troisPartitionner(T,g,d); si r<i alors d ← i-1; sinon si r>k alors g ← k+1; sinon retourner T[r];
ii. (1 point) Compl´eter le tableau des complexit´es en fonction de n=longueur(T) et du rang r.
Solution: TriRapide(T) RangRapideIteratif(T,r) Temps (meilleur des cas) Ω(n) Ω(n) (Toutes les valeurs identiques) Temps (pire des cas) O(n^2 ) O(n × r) (tableau tri´e) Espace (meilleur des cas) Ω(1) Ω(1) Espace (pire des cas) O(n) O(1) Non demand´e : En r´ealit´e le pire des cas est soit un tableau tri´e, ce qui donne une complexit´e en O(n × r), soit un tableau tri´e en ordre d´ecroissant qui donne une complexit´e en O(n × (n − r)). Ainsi la complexit´e dans le pire des cas est en O(n × max(r, n − r)).
C. pred = P i f P. s u c c !=None : C. s u c c = P. s u c c P. s u c c. pred = C P. s u c c = C
(c) (2 points) Ecrire l’algorithme de la primitive´ Inserer_Tete(L,X).
Solution: def i n s e r e r T e t e (L ,X ) : # change L , i l f a u t r e t o u r n e r l a n o u v e l l e v a l e u r C = c r e e r L i s t e D C (X) i f L!=None : C. s u c c = L L. pred = C return C
(d) (3 points) Ecrire l’algorithme de la primitive´ Concatener(L1,L2).
Solution: def c o n c a t e n e r ( L1 , L2 ) : # p e u t changer L1 , i l f a u t r e t o u r n e r l a v a l e u r i f L1!=None : i f L2!=None : Aux = d e r n i e r e C e l l u l e ( L1 ) Aux. s u c c = L L2. pred = Aux return L e l s e : return L
