Examen Algorithme Avancé Avec Correction
Examen Algorithme Avancé Avec Correction
Examen Algorithme Avancé Avec Correction
Algorithmique II
Examen final
Corrigé
Où Numéro est le numéro d’ordre dans la liste, Code_Etudiant est le code de l’étudiant,
Nom est le nom de l’étudiant, Prénom est le prénom de l’étudiant, Moyenne est la
moyenne de l’étudiant et Mention est égale à :
”Ajourné” si Moyenne < 10
”Passable” si 10 ≤ Moyenne < 12
”A.Bien” si 12 ≤ Moyenne < 14
”Bien” si 14 ≤ Moyenne < 16
”T.Bien” si 16 ≤ Moyenne
Corrigé
1. Déclarations
Type Etudiant = Structure
Code_Etudiant : Caractere[1..8]
Nom : Caractere[1..15]
Prenom : Caractere[1..15]
Moyenne : Reel
Fin Structure
Var Filiere : Etudiant[1..N]
1
2.
Procedure Afficher_Resultat()
Var i, j : Entier
Debut
Ecrire(”\nNumero\t Code_Etudiant \t Nom \t Prenom \t Moyenne \t Mention”)
Pour (i1 a N) Faire
Ecrire(”\n”, i, ” \t ”, Filiere[i].Code_Etudiant, ” \t ”, Filiere[i].Nom, ” \t ”)
Ecrire(Filiere[i].Prenom, ” \t ”, Filiere[i].Moyenne, ” \t ”)
Si (Filiere[i].Moyenne < 10) Alors
Ecrire(”Ajourne”)
Sinon
Si (Filiere[i].Moyenne < 12 Et Filiere[i].Moyenne >= 10) Alors
Ecrire(”Passable”)
Sinon
Si (Filiere[i].Moyenne < 14 Et Filiere[i].Moyenne >= 12) Alors
Ecrire(”A.Bien”)
Sinon
Si (Filiere[i].Moyenne < 16 Et Filiere[i].Moyenne >= 14) Alors
Ecrire(”Bien”)
Sinon
Ecrire(”T.Bien”)
Fin Si
Fin Si
Fin Si
Fin Si
Fin Pour
Fin
2
Fin Si
Count 0
ii+1
ji
Fin Si
Fin Tant Que
Retourner MaxCount
Fin
1. Expliquez brièvement ce que fait la fonction Calcul
2. Déterminer la complexité temporelle dans le pire des cas de la fonction Calcul.
3. Ecrire une fonction Meilleur() faisant le même travail que la fonction Calcul et qui est
de complexité temporelle, dans le pire des cas, strictement inférieure à celle de la
fonction Calcul [indication : Vous pouvez exploiter un des algorithmes vus au cours,
sans donner sa description].
Corrigé
But de la fonction Calcul
Pour i=1, on effectue n passages dans la boucle tant que, ceci à la recherche du nombre
d’occurrences de A[1]. Après ces n passage, le nombre obtenu (valeur de Count) est affecté
à la variable MaxCount et une nouvelle série de passages dans la boucle tant que
commence avec i=2. Après n-1 passages on compare la valeur de Count (qui égal au
nombre d’occurrences de A[2] dans le tableau A[2..n]) ; si (Count>MaxCount) alors on
affecte à MaxCount la valeur de Count. On continue ainsi jusqu’à la sortie de la boucle
Tant que. La valeur retournée par la fonction Calcul est alors le nombre d’occurrences de
l’élément le plus fréquent du tableau A.
i =1
tcomp = ( n )
2
Fonction Meilleur()
Var i, j, count, MaxCount
Debut
//Trie du tableau A[1..n]
3
On applique l’algorithme Trie Rapide au tableau A[1..n]
//Calcul de la valeur de MaxCount
i1
MaxCount0
Tant que( i<n ) Faire
count0
ji
Tant que (j<=n et A[i]=A[j]) Faire
countcount+1
jj+1
Fin Tant que
Si (count>MaxCount) Alors
MaxCountcount
Fin Si
ij
Fin Tant que
Retourner MaxCount
Fin
i =1
k
= C 0 + C1 k + C 2 j i
i = 1
= (n)
Donc finalement, la complexité temporelle de la fonction Meilleur est (n log n) + (n) =
(n log n)
4
Corrigé
1. f(1,0) = f(0,1), d’après la deuxième égalité
= 2, d’après la première égalité
f(2,0) = f(1,1), d’après la deuxième égalité
= f(0,f(1,0)), d’après la troisième égalité
= f(1,0)+ 1, d’après la première égalité
=2+1=3
f(3,0) = f(2,1), d’après la deuxième égalité
= f(1,f(2,0)), d’après la troisième égalité
= f(1,3) = f(0,f(1,2)), d’après la troisième égalité
= f(1,2) + 1, d’après la première égalité
= f(0,f(1,1)) + 1, d’après la troisième égalité
= f(1,1) + 1 + 1, d’après la première égalité
= f(0,f(1,0)) + 2, d’après la troisième égalité
= f(1,0) + 1 + 2, d’après la première égalité
=2+3=5
2.
Fonction Ackerman(n : Entier, m : Entier) : Entier
Debut
Si (n<0 ou m<0) Alors
Retourner
Fin Si
Si ( n=0 ) Alors
Retourner (m+1)
Sinon
Si ( m=0 ) Alors
Retourner( Ackerman(n-1, 1) )
Sinon
Retourner( Ackerman(n-1, Ackerman(n, m-1)) )
Fin Si
Fin Si
Fin