Telechargé par Mohammed reda Hadi

CNC 2020 - TSI-INFO

publicité
EXERCICE :
Q1
def somme(n):
s=0
for i in range(1,n+1):
s=s+i
return s
Q2
La boucle for execute des opérations de complexité constante n fois. D'où La complexité
est linéaire O(n).
Q3
def terme(k):
return k/somme(k)
Q4
La fonction fait un appel de la fonction somme(k) de complexité O(k) ainsi que des
opérations de complexité constante (return et /). D'ou la complexité est O(k)
Q5
def sigma(n):
s=0
for i in range(1,n+1):
s=s+terme(i)
return s
Partie I
Q1
def somme(f,a,h,n):
s=0
for i in range(1,n):
s=s+f(a+i*h)+2*f(a+i*h+h/2
return s
Q2
def integral_simpson(f,a,b,n):
h=(b-a)/n
C1 = (h/6)*(f(a)+4*f(a+h/2)+f(b))
C2 = (h/3)*somme(f,a,h,n
return C1+C2
Q3.a
import numpy as np
import matplotlib.pyplot as pl
def g(x):
return x**2 + 5*np.cos(1+x**2)*np.sin(np.exp(x)) - 1
Q3.b
X = np.linspace(-1,2,250
Y = g(X
pl.plot(X,Y
pl.show()
Q3.c
I = integral_simpson(g,-0.5,1.5,10**5)
print(I)
Partie II
Q1
Chaque étudiant passe une seule fois chaque matière, donc le couple (numC, codM) est
unique pour chaque ligne de Notes. D'où le coupe (numC, codM) est la clé primaire du
tableau Notes.
Q2
Q3
Méthode 1
SELECT numC, nom, prénom
FROM Notes N, Candidats C
WHERE N.numC = C.numéro AND codM = 'M' AND note >= 5
Méthode 2
SELECT numC, nom, prénom
FROM Notes N
JOIN Candidats C ON N.numC = C.numéro
WHERE codM = 'M' AND note >= 5
Q4
Méthode 1
SELECT nom, MAX(note), MIN(note)
FROM Notes N, Matières M
WHERE N.codM = M.code
GROUP BY code
ORDER BY AVG(note) DESC
Méthode 2
SELECT nom, MAX(note), MIN(note)
FROM Notes N
JOIN Matières M ON N.codM = M.code
GROUP BY code
ORDER BY AVG(note) DESC
Q5
SELECT COUNT(DISTINCT numC)
FROM Notes
WHERE note < 5
Q6
Méthode 1
SELECT numéro, C.nom, prénom, SUM (note * coeff) AS total
FROM Notes N, Matières M, Candidats C
WHERE N.numC = C.numéro AND M.code = N.codM AND numC NOT IN (SELECT numC
FROM Notes WHERE note < 5)
GROUP BY numéro
HAVING total > 1000
ORDER BY total DESC
Méthode 2
SELECT numéro, C.nom, prénom, SUM (note * coeff) AS total
FROM Notes N
JOIN Matières M ON M.code = N.codM
JOIN Candidats C ON N.numC = C.numéro
WHERE numC NOT IN (SELECT numC FROM Notes WHERE note < 5)
GROUP BY numéro
HAVING total > 1000
ORDER BY total DESC
Partie III
Q1
def rotation(T,p):
return T[p:]+T[:p
Q2
def liste_rotations(T):
L=[]
for p in range(len(T)):
L.append(rotation(T,p))
return L
Q3
def tri_rotations(R):
for i in range(len(R)-1):
k=i
for j in range(i+1,len(R)):
if R[j]<R[k]:
k=j
R[i],R[k]=R[k],R[i
Q4.a
def position(T,R):
d,a=0,len(R)-1
while d<=a
m=(a+d)//2
if R[m]==T
return m
elif T<R[m]:
a=m-1
else
d=m+1
Q4.b
L'algorithme de la recherche dichotomique dans une liste triée est d'une complexité
logarithmique. Or la boucle while ne contient pas d'opérations de complexité variable.
Donc la complexité est logarithmique.
Q5
def BWT(T):
R=liste_rotations(T)
tri_rotations(R)
p=position(T,R)
B=""
for ch in R:
B=B+ch[-1]
return (B,p)
Téléchargement