Correction CNC 2017

Partie I : Base de données et langage SQL

I. 1- Projection nomF(Selection tailleF >= 1024 et tailleF <=1048576 (Fichier))

I. 2- Select nomF, tailleF

From Fichier
Where nomF Like "%.doc" or nomF Like "%.docx"
Order by nomF

I. 3- Select nomF, A.format, type, (1-(tailleC*1.0)/(tailleF*1.0))*100 Taux

From Fichier F, Compression C, Algorithme A
Where F.numeroF = C.numeroF and A.format = C.format and Taux > 40
Order by F.numeroF

I. 4- Select A.format, count(*) Nbr

From Algorithme A, Compression C
Where A.format = C.format and type=0
Group by A.format
Having Nbr In (3,5,8)

I. 5- Select *
From ( Select (1-(tailleC*1.0)/(tailleF*1.0))*100 Taux
From Fichier F, Compression C
Where F.numeroF = C.numeroF
Order by Taux Desc
Limit 3 )
Order by Taux

I. 6-
import sqlite3
f = input("Donner le format de compression : ")
con = sqlite3.connect("C:/BDcompressions.sql")
cur = con.cursor()
r = "Select format From Algorithme Where format = ?"
cur.execute(r,(f,))
L=cur.fetchall()
if L==[]: print("Le format n'existe pas dans la BD")
else:
r = "Select avg((1-(tailleC*1.0)/(tailleF*1.0))*100) From Fichier F,
Compression C Where F.numeroF = C.numeroF And format = ?"
cur.execute(r,(f,))
t = cur.fetchone()
print(t[0])
con.close()

Page 1 sur 6
Partie II : La compression de HUFFMAN
II. 1- L’espace mémoire occupé par un entier naturel
Le plus grand nombre entier positif, avec signe, qu’on peut coder sur
12 bits est : 011111111111(2) = 211 -1 = 2047

II. 2- Écriture binaire d’un nombre décimale

def binaire(N):
if N==0: return ’0’
bin=’’
while N!=0:
bin= bin + str(N%2)
N=N//2
return bin

Complexité de la fonction binaire(N) :

La fonction binaire(n) effectue une boucle while, dans la quelle N est
divisé par 2, à chaque répétition. Donc elle est de complexité
logarithmique: O(log2(N))

def entier(B):
S,n=0,len(B)
for i in range(n-1, -1, -1):
S=2*S + int(B[i])
return S

II. 3- Liste des fréquences

def freq(L):
E=set(L)
F=[]
for i in E:
F.append((i,L.count(i)))
return F

II. 4- Tri de la liste des fréquences

Le tri par fusion est un tri de complexité quasi-linéaire dans le pire
et dans le meilleur cas.

def fusion(P,Q):
if P==[] or Q==[]: return P+Q
elif P[0][1] < Q[0][1]: return [P[0]]+fusion(P[1:],Q)
else: return [Q[0]]+fusion(P,Q[1:])

Page 2 sur 6
 def tri(F):
n=len(F)
if n<=1: return F
else : return fusion(tri(F[:n//2]),tri(F[n//2:]))

II. 5- Création de l’arbre binaire de Huffman

def insere(F,t):
i=len(F)-1
while i>=0 and F[i][1]>t[1]:
i=i-1
F=F[:i+1]+[t]+F[i+1 :] # ou F.insert(i+1,t)

def arbre_Huffman(F):
F=tri(F)
while len(F)>1:
X,Y=F.pop(0),F.pop(0)
if type(X[0])!=list and type(Y[0])!=list :
pere=([X[1]+Y[1],[X[0],[],[]],[Y[0],[],[]]], X[1]+Y[1])
elif type(X[0])==list and type(Y[0])==list:
pere=([X[1]+Y[1],X[0],Y[0]],X[1]+Y[1])
elif type(X[0])!=list and type(Y[0])==list:
pere=([X[1]+Y[1],[X[0],[],[]],Y[0]],X[1]+Y[1])
elif type(X[0])==list and type(Y[0])!=list:
pere=([X[1]+Y[1],X[0],[Y[0],[],[]]],X[1]+Y[1])
insere(F,pere)

return F[0][0]

II. 6- Construction du dictionnaire des codes de Huffman

def code_huffman(A,code,codesH):
if A[1]==[] and A[2]==[]:
code[A[0]]=code
else:
code_huffman(A[1],code+"0",codesH)
code_huffman(A[2],code+"1",codesH)

II. 7- Compression de la liste des entiers naturels

def compression(L, codesH):
S=""
for k in L:

Page 3 sur 6
 S=S+code[k]
return S

II. 8- Décompression de la chaine de caractères binaires :

def decompression(codesH,B):
R={codesH[k]:k for k in codeH}
A = []
tampon = ''
for b in B:
tampon = tampon+b
if tampon in R:
A.append(R[tampon])
tampon = ''
return A

Partie III : Calcul numérique

III. 1- Matrice inversible :
def inversible(M):
return np.linalg.det(M)!=0

III. 2- Matrice identité :

def identite(n):
E=np.zeros((n,n))
for i in range(n):
E[i][i]=1.
return E

ou :

def identite(n):
return np.eye(n)

III. 3- Transvection :
def transvection(M,p,q,r):
M[p]+= r*M[q]

III. 4- Échanger deux lignes d’une matrice :

def echange_lignes(M,p,q):
n=len(M)
for k in range(n):
M[p,k],M[q,k]=M[q,k],M[p,k]

Page 4 sur 6
III. 5- Rechercher la ligne du pivot
def ligne_pivot(M,c):
p=c
for i in range(c):
if abs(M[i,c])>abs(M[p,c]): p=i
return p

III. 6- Matrice triangulaire inférieure

def triangulaire_inf (M,E):
n=len(M)
for j in range(n-1,-1,-1):
p=ligne_pivot(M,j)
echange_lignes(M,p,j)
echange_lignes(E,p,j)
for i in range(j):
k=-M[i,j]/M[j,j]
M[i]=M[i]+k*M[j]
E[i]=E[i]+k*E[j]

III. 6- Matrice diagonale

def diagonale(M,E):
n=len(M)
for j in range(n):
for i in range(j+1n):
k=-M[i,j]/M[j,j]
M[i]=M[i]+k*M[j]
E[i]=E[i]+k*E[j]
III. 8- Matrice inverse
def inverse(M):
n=len(M)
E=identite(n)
Triangulaire_inf(M,E)
diagonale(M,E)
for i in range(n):
E[i]=E[i]/M[i,i]
M[i,i]=1
return E

III. 9- Matrice dans un fichier texte

def matrice_fichier(ch):
try:
f=open(ch,"r")
except FileNotFoundError:
print("Erreur d'accès au fichier")
else:
M=f.readlines()
f.close()

Page 5 sur 6
for i in range(len(M)):
M[i]=M[i].split()
M=np.array(M,float)
if inversible(M) : return(inverse(M))
print("Matrice non inversible")

Page 6 sur 6