UNIVERSITE DE KINSHASA

FACULTE POLYTECHNIQUE
COURS D’ALGORITHMIQUE ET PROGRAMMATION
Groupe 1 :

MBAYO MAKUMBU

MUHIYA MALIANI

TSHIBANGU KANKENZA

QUESTION 1
Pour que A soit meilleur que B, il faut que :

50n log(n) < 45n2 -> 45n2 - 50n log(n) > 0 -> n( 45n - 50 log(n) ) > 0

En outre, soit n>0 ou (45n - 50 log(n) ) > 0.

Considérons la seconde condition : (45n - 50 log(n) ) > 0 ;

45n - 50 log(n) > 0 -> 45n >50 log(n) <-> 1045n > n50 (*)

En itérant la relation (*), on constate que cela est vrai pour n compris dans {1,2,3,4,…}

Le n0 n’est rien d’autre que n0 = min( {1,2,3,4,…} ) -> n0 = 1

QUESTION 2

import matplotlib.pyplot as plt

x = []
for i in range(0,8):
x.append(i)
x.append(i+0.25)
x.append(i + 0.5)
x.append(i + 0.75)

f1 =[140*(i**2) for i in x ]
f2 = [29*(i**3) for i in x ]

plt.plot(x,f1, label="temps d'execution de 140 n²")

plt.plot(x,f2, label =" temps d'execution de29 n^3")
plt.legend()
plt.title("Graphique Temps d'execution")
plt.show()
On constate que ce n’est qu’à partir d’environ 4,822 que A est meilleur que B

Donc n0 = 5

QUESTION 3
De prime abord, supposons que le temps d’exécution du pire cas est O(f(n)).

Alors il existe une constante c telle que cf (n)>pire cas pour n> n0 et puisque le pire cas est
toujours supérieur à tous les autres cas (car étant donné que le temps d’exécution du pire cas
>= g(n) ) alors cf (n)>-pire cas> tous les autres cas A

Par transitivité, puisque a>b et b>c, alors a>c, du coup c (l’algorithme A) est O(f(n))

De deux,si le pire cas d’exécution est 0(f(n)), alors il existe une constante c telle que
(n)>pire cas pour n>n0

Or le pire cas est toujours supérieur à tous les autres cas, (car étant donné que le temps
d’exécution du pire cas >= g(n)) ; Alors cf (n)>=pire cas>= tous les autres cas .

Par transitivité, puisque a>b et b>c, alors a>c, ce qui signifie que c (l’algorithme A) est O(f(n))
QUESTION 4
Si d(n) vaut O(f(n)), il existe une constante telle que d(n) < cf (n) pour tout n>no.

En multipliant d(n) par a, on obtient ad (n)) < ac f(n) = c’f (n) Avec n>a*n

D’un autre côté, si d(n) vaut O(f(n)), alors il existe une constante telle que d(n) <= cf (n) pour
tout n>no. Multiplions d(n) par a, on obtient ad(n) <= ac f(n) = e’f (n) Avec n>a*no

QUESTION 5
Si d(n) vaut O(f(n)) et e(n) vaut O(g(n)), alors d(n) <= cf (n) pour n_f>n_fo et
e (n) < dg (n) pour n_e >n_e0

En conséquence, [d(n)e (n)] <= (cf (n)) * (dg (n)) et n_f*n_e >n _fo * n_e0

Ce qui signifie qu’il existe un nouveau n’ = n_f*n_e et no’ =n_fo*n_e0, et un

c’ = c*d tel que :

d(n)e(n) <= c’ (f(n)*g(n)) pour n’>no’, ce qui signifie que d(n)e(n) vaut O (f(n)g(n))

QUESTION 6
Si d(n) vaut O(f(n)) et e(n) vaut 0(g(n)), alors d(n) <= cf (n) pour n_f>n_fo et e(n) <= dg (n) pour
n_e>n_e0

Cela signifie que d (n)e(n) <- (cf (n)) + (dg (n)) et nn_fo + n_e0

Ce qui signifie qu’il existe un nouveau n’ = n_f + n_e et et no’ = n_fo + n_e0, tel que :

d(n) +e(n) <= cf (n) + dg (n) pour n>no ; cependant, cela ne satisfait toujours pas la notation O.

On peut absorber c et d dans leurs fonctions telles que d(n) e(n) <= f (en) + g (dn)

Pour absorber c, on note que n’’= cn’ , donc n’ = n’’/c, ce qui signifie que n’’/c>= no’’/c

De même pour d, n’’/cd >= no’’/cd

Il existe donc de nouvelles valeurs de no telles que

d(n) + e(n) <= (f(n)+d(n)) pour n> no’’, qui satisfait 0(f(n) conditions d (n))

QUESTION 7
Le point clé ici est que ce n’est pas parce que quelque chose est O(n) que cela doit être cette
fonction Par exemple, [(n) = 5 est O(n) est mathématiquement vrai, bien que ce soit une
mauvaise forme à dire donc par conséquent, si nous avons d(n) = n et e(n) = n avec f(n)n et
g(n) = n, alors nous satisfaisons d(n) <= c(f(n)) pour n>=0, et e(n) <= C2 (g(n)) pour n>=0

f(n)-g(n) = 0 et d(n) - e(n) = n

Il n’y a pas de valeur pour n>0 telle que 0>n, ce qui signifie que d(n) -e(n) n’est pas O(f(n)-g(n))

QUESTION 8

Si d (n) vaut 0 (f(n)) et f(n) vaut O(g(n)), alors d (n) <= cf (n) pour n_f>n_f0 et f(n) <= dg (n) pour
n_g >n_go

Si c’est vrai, alors d(n) <= cf (n) <= c(d (g(n))) = cd*g(n) = c’g(n) par substitution, ce qui est vrai
pour n_f *n_g>n_f0*n_g0, ou n>n0’

Ensemble, ceux-ci satisfont les conditions de d(n) est O(g(n))

QUESTION 9

L’algorithme D appelle l’algorithme E n fois.

Par conséquent, le temps d’exécution dans le pire des cas est 0 (D (n)) * (0(i)), ce qui semble
être O(n*1) = O(n) d’après la description

La notation O signifie qu’il existe une constante C telle que f(n) < Cg (n)

QUESTION 10.

La notation O signifie qu’il existe une constante C telle que f(n) < Cg (n)

Par conséquent, si tous les algorithmes fonctionnent mieux que A(nlogn) et que l’algorithme
de Bob fonctionne mieux que B(n-2), nous pouvons résoudre la valeur où Anlogn = Bn2, dont
nous savons qu’elle est vraie lorsque n=100.

Cela signifie que :

(A/B) = (100) / (log (100)) = 15.05

Cela signifie que tous le temps d’exécution sur une seule itération est 15 fois plus lent, mais
comme il effectue des opérations simple dans l’ensemble, il commence à mieux fonctionner à
de grandes valeurs de n

QUESTION 11.
def recherche_maximum(S,index):
if index == len(S)-1:
return S[index]
return max(S[index], recherche_maximum(S, index+1))

def maximum(S):
return recherche_maximum (S, 0)

print(maximum ([1,200,3,-40,50,-56,87,8]))

Le temps d’exécution est O(n) (N appels à la récursivité, chaque prise de) temps

L’espace est aussi O(n) puisqu’il faut appeler n activations

 Si j’avais passé dans une copie du sous-tableau, cela aurait pris l’espace O(n^2), bien que si je
venais de passer

Dans le sous-tableau (Stindex:]), il n’aurait pas dû le recopier et toujours être O(n).

QUESTION 12.
def min_max(S, index=0):
if index == len(S)-1:
return S[index], S[index] #The current min and max values
else:
min_c, max_c = min_max(S, index+1)
return min(S[index], min_c), max(S[index], max_c)
print(min_max([1,2,-305,40,-5,-60,-8,7,8]))

QUESTION 13.
VOWELLS = {'a','e','i','o','u','é','à','ô','ö'}
def acte(S, index = 0):
a = -1 if S[index] in VOWELLS else 1
if index == len(S)-1:
return a
else:
return (a+ acte(S, index +1))

def verification(S):
testeur = acte(S)
if testeur >0:
return (f'There are more consonants by { testeur }')
elif testeur <0:
return (f'There are more vowells by { testeur }')
else:
return (f'There are an equal number of each { testeur }')

liste_teste = ['Amour', 'Biere','Etude', 'Maison', 'Reussite', 'Algorithme']

for s in liste_teste:
print (verification (s), s)