Interrogation dAinformatique no3. Corrigé. Exercice A. Interpolation

Interrogation d’informatique no 3. Corrigé.
Exercice A. Interpolation de Lagrange par les polynômes de Newton
1) a)
def produit(a,P) :
n = len(P) ; Q = zeros(n+1)
Q[0] = -a*P[0]
for i in range(1,n) :
Q[i] = P[i-1]-a*P[i]
Q[n] = P[n-1]
return Q
b)
def newton(A) :
N = zeros(1) ; N[0] = 1
M = zeros((n,n))
for j in range(n) :
for i in range(j+1) :
M[i][j] = N[i]
N = produit(A[j],N)
return M
c)
def coeff(C,A) :
M = newton(A)
return dot(M,C)
d) La complexité de newton(A) est en O(n2 ): Il en est de même de coeff(C,A).
2) a)
def LagrangeNewton(A,Y) :
n = len(A)
if n ==0 :
return zeros(0)
Y2 = [ (Y[i]-Y[0])/(A[i]-A[0]) for i in range(1,n) ]
A2 = [ A[i] for i in range(1,n) ]
Q = LagrangeNewton(A2,Y2) :
C2 = produit(A,Q)
C = zeros(n)
C[0] = Y[0]
for i in range(1,n) :
return(C)
b)
def Lagrange(A,y) :
C[i] = C2[i-1]
C = LagrangeNewton(A,Y)
return coeff(C,A)
La complexité c(n) de LagrangeNewton(A,Y)véri…e c(n) = c(n
1) + O(n), donc O(n2 ):
Donc Lagrange(A,Y) est en O(n2 ).
Exercice B. Codes
1) def prefixe(x,y) :
p = len(x) ; q = len(y)
if q < p :
return False
for i in range(p) :
if x[i] != y[i] :
return False
return True
2) def plusPetit(x,y) :
p = len(x) ; q = len(y)
i = 0
while i<p and i<q and x[i]==y[i] :
if q <= i or x[i] > y[i] :
i += 1
return False
return True
3) On propose ici le tri par sélection.
def ordre(L) :
n = len(L)
for i in range(n-1)
k = i
for j in range(i+1,n)
if PlusPetit(L[j],L[k]) :
k=j
L[i],L[k] = L[k],L[i]
4) La liste est supposée triée selon l’ordre lexicographique
:
Dans ce cas, une liste qui n’est pas un code comporte nécessairement deux mots consécutifs dont le premier est pré…xe
du second. En e¤et, une liste qui n’est pas un code contient deux mots distincts x et y tels que x est pré…xe de y:
On a x
y, et tout mot compris entre x et y admet x comme pré…xe. Donc x est nécessairement un pré…xe du mot
qui le suit dans la liste considérée.
def code(L) :
n = len(L)
for i in range(n-1) :
if prefixe(L[i],L[i+1]) :
return True
return False
La complexité est O(n) appels à la fonction prefixe, donc O(np) comparaisons (de bits 0-1).
Remarque : Compte tenu du fait qu’on peut trier une liste en O(n log n) comparaisons de mots, on obtient ainsi un
test de code de complexité O(np log n), au lieu de O(n2 p) si on utilise un tri par sélections.