REPUBLIQUE TUNISIENNE الجمهورية التونسية
Ministère de l'Enseignement Supérieur,
de la Recherche Scientifique وزارة التعليم العالي والبحث العلمي
انمناظرات انىطنية نهدخىل
Concours Nationaux d’Entrée إنى مراحم تكىين انمهندسين
aux Cycles de Formation d’Ingénieurs 2020 دورة
Session 2020
Alternative de Correction Concours Mathématiques et Physique, Physique et Chimie et Technologie
Epreuve d’Informatique
Barème sur 100
PROBLEME 1 (65 pts)
Partie 1 :
1. 1.25 pt
Version 1:
Tinitial= lambda x: 0 if x==0 or x==L else 200
Version 2:
def Tinitial(x):
return 0 if x in (0,L) else 200
Version 3:
def Tinitial(x):
assert 0<=x<=L , 'longueur depassant la tige'
if x==0 or x==L :
return 0
else:
return 200
2. 1.25 pt
Version 1:
def Fn(x,n):
return Tinitial(x) * [Link]((n*[Link]*x)/L)
Version 2:
Fn=lambda x,n:Tinitial(x)*[Link](([Link]*n*x)/L)
3. 2.5 pts
def Dn(n):
Q=[Link](Fn,0,L,(n,))
return (2/L)*Q[0]
4. 5 pts
def SolutionAnalytique(x,t,eps):
n=1
s=0
while True:
t=Dn(n)*[Link](n*x*[Link]/L)*[Link]((-n*n*[Link]**2*alpha*t)/L**2)
s+=t
n+=1
Alternative de Correction Concours (MP PC T) - Session juillet 2020 Epreuve d’Informatique Page 1/6
if abs(t)< eps:
return s
Partie 2
5. 5 pts
Version 1:
def GenererA(N):
A=[Link]((N+1,N+1),'int')
for i in range(1,N+1):
A[i,i]=-2
A[i-1,i]=1
A[i,i-1]=1
A[0]=A[N]=[Link](N+1)
return A
Version 2:
def GenererA(N):
a=[Link]([-2 for i in range(0,N+1)])
b=[Link]([1 for i in range(0,N)],1)
c=[Link]([1 for i in range(0,N)],-1)
A=a+b+c
A[0,:]=A[N,:]=0
return A
Version 3:
def GenererA(N):
A=[Link]((N+1,N+1))
for i in range(1,N):
for j in range(N+1):
if i==j :
A[i,j]=-2
elif i==j+1 or i==j-1:
A[i,j]=1
return A
Version 4:
def GenererA(N):
L=[-2 for i in range(N+1)]
A=[Link](L)
A[0,0]=A[N,N]=0
for i in range(1,N):
for j in range(N+1):
if i==j+1 or i==j-1:
A[i,j]=1
return A
Version 5:
def GenererA(N):
fill = lambda i,j : -2 if i == j and i not in {0,N} else \
(1 if i in {j+1, j-1} and i not in {0,N} else 0)
return [Link]([Link](fill), (N+1,N+1))
6. 2.5 pts
O(N2), la fonction permet de remplir une matrice d’ordre (N+1)
Alternative de Correction Concours (MP PC T) - Session juillet 2020 Epreuve d’Informatique Page 2/6
7. 10 pts
Version 1 :
def SolutionNumerique(L,T,N,M,alpha):
vx=[Link](0,L,N+1)
dx=vx[1]-vx[0]
vt=[Link](0,T,M+1)
u0=[Link](N+1)
for i in range(1,N+1): #ou bien u0=[Link]([Tinitial(i) for i in vx])
u0[i]=Tinitial(vx[i])
A=GenererA(N)
k= lambda u,t: alpha/(dx*dx)*[Link](A,u)
U=[Link]([Link](k, u0, vt))
return U,vx,vt
Version 2 :
def SolutionNumerique(L,T,N,M,alpha):
vx, dx = [Link](0,L,N+1, retstep = True)
vt= [Link](0, T, M+1)
u0 = [Link](Tinitial)(vx)
A = GenererA(N)
k = lambda u, t : (alpha/dx**2)* ([Link](u))
U = [Link](k, u0, vt).T # ou bien [Link](k, u0, vt).transpose()
return (U, vx, vt)
Partie 3
8. 2.5 pts + 2.5 pts
class EqChaleur:
8.1 def __init__(self,L,T,N,M,alpha):
self.L=L
self.T=T
self.N=N
self.M=M
[Link]=alpha
8.2 def SolveEq(self):
return SolutionNumerique(self.L,self.T,self.N,self.M,[Link])
9.
class InterpolationBilinieaire:
9.1 5 pts
def __init__(self,U,vx,vt):
self.U = [Link]() # self.U=U
self.bornes_max = ([Link](), [Link]())
self.pas_v = (vx[1]-vx[0], vt[1]-vt[0])
9.2 2.5 pts
Version 1:
def __str__(self) :
motif = "F : [0, {}] x [0, {}] --> [{}, {}]"
bxmax, btmax = self.bornes_max
return [Link](bxmax, btmax, [Link](), [Link]())
Version 2:
def __str__(self):
xmax,tmax= self.bornes_max
Alternative de Correction Concours (MP PC T) - Session juillet 2020 Epreuve d’Informatique Page 3/6
Umin,Umax=[Link](),[Link]()
ch= 'F:[0,'+str(xmax)+']*[0,'+ str(tmax)+'] -->\
['+str(Umin)+','+str(Umax)+']'
return ch
9.3 2.5 pts
Version 1:
def __contains__(self,tup):
if 0< tup[0]< self. bornes_max [0] and 0< tup[1]< self. bornes_max [1]:
return True
else:
return False
Version 2:
def __contains__(self, tup):
x, t = tup
xmax, tmax = self.bornes_max
return 0 < x < xmax and 0 < t < tmax
9.4 2.5 pts
def get(self,tup):
return (tup[0]/self.pas_v[0],tup[1]/self.pas_v[1])
9.5 1.25 pts
Version 1:
def getlow(self,tup):
t1=[Link](tup)
t2= [Link](t1[0]),[Link](t1[1])
return t2
Version 2:
def get_low(self, tup):
return tuple([Link](x) for x in [Link](tup))
9.6 1.25 pts
Version 1:
def getup(self,tup):
t1=[Link](tup)
t2= [Link](t1[0]),[Link](t1[1])
return t2
Version 2:
def get_up(self, tup):
return tuple([Link](x) for x in [Link](tup))
9.7 10 pts
from [Link] import solve
Version 1:
def interpolate(self,tup):
if tup in self:
xlow,tlow=[Link](tup)
x_up,t_up=[Link](tup)
v=[Link]([1,tup[0],tup[1],tup[0]*tup[1]])
xl=xlow*self.pas_v[0]
xu=x_up*self.pas_v[0]
tl=tlow*self.pas_v[1]
tu=t_up*self.pas_v[1]
c1=[Link](4,'int')
c2=[Link]([xl,xl,xu,xu])
c3=[Link]([tl,tu,tl,tu])
Alternative de Correction Concours (MP PC T) - Session juillet 2020 Epreuve d’Informatique Page 4/6
B=[Link]([c1,c2,c3,c2*c3])
B=[Link](B)
b=[Link]([self.U[xlow,tlow],self.U[x_up,tlow],\
self.U[xlow,t_up],self.U[x_up,t_up]])
y=solve(B,b)
return [Link](y,v)
else:
return 'Erreur'
Version 2:
def interpolate(self, tup):
assert tup in self
x, t = tup
dx, dt = self.pas_v
x_low, t_low = self.get_low(tup)
x_up, t_up = self.get_up(tup)
v = [Link]([1, x, t, x * t ])
x_l, x_u, t_l, t_u = [Link]([x_low,x_up,t_low ,t_up]) * [dx,dx,dt,dt]
B = [Link]((4,4))
B[0,1] = B[1,1] = x_l
B[2,1] = B[3,1] = x_u
B[0,2] = B[2,2] = t_l
B[1, 2] = B[3,2] = t_u
B[:,-1] = B[:,-2] * B[:,-3]
b = [Link]([self.U[i,j] for i in (x_low, x_up) for j in (t_low,
t_up)])
y = solve(B,b)
return [Link](v)
10. 7.5 pts
chal=EqChaleur(L,T,N,M,alpha)
U,vx,vt=[Link]()
bil=InterpolationBilinieaire(U,vx,vt)
while 1:
try:
x=float(input('lire x'))
t=float(input('lire t'))
if x not in vx and t not in vt:
break
except:
print('saisir des réels')
print([Link]((x,t)))
PROBLEME 2
Partie 1
1. 2.5 pts
nom ( idEtab ' Libre ' et sec tion ' PC ' (Candidat ))
2. 2.5 pts
idC (Candidat ) - idC ( Evaluation)
Partie 2
3. 2.5 pts
update Epreuve set duree = 2 where nomEpr='Informatique' and section= 'T';
4. 2.5 pts
select DISTINCT [Link] from Etablissement E join candidat C on [Link] = [Link]
where [Link] =’BG’ and [Link] <> ‘Libre’
Alternative de Correction Concours (MP PC T) - Session juillet 2020 Epreuve d’Informatique Page 5/6
5. 3.75 pts
select section, sum(coeff) s from Epreuve group by section order by s desc;
6. 3.75 pts
SELECT IdC FROM Evaluation WHERE note >= 15 GROUP BY IdC Having count(*) >= 3;
ou
select idC, count(idEpr) s from evaluation where note >=15 group by idC having s>=3;
Partie 3 :
7. 2.5 pts
def Notes(cur,id):
[Link]('select note from Evaluation where idEpr=?’, [id])
L=[Link]()
return [i[0] for i in L]
8. 2.5 pts
def ecart_type(cur,id):
L=Notes(cur,id)
m= sum(L)/len(L)
s=0
for i in L:
s+=(i-m)**2
return [Link](s/len(L))
9. 2.5 pts
def Epreuves(cur,s):
[Link]('select idEpr from Epreuve where section=?', (s,))
L=[Link]()
return {i[0] for i in L}
10. 2.5 pts
def ecartypeEpreuves(cur,s):
req = """
SELECT nomEpr FROM Epreuve WHERE IdEpr = ?
"""
L=Epreuves(cur,s)
d_ecart={}
for i in L:
[Link](req, [i])
nom = [Link]()[0]
d_ecart[nom]=ecart_type(i)
return d_ecart
Alternative de Correction Concours (MP PC T) - Session juillet 2020 Epreuve d’Informatique Page 6/6
11. 5 pts
def discriminante(cur,s):
d=ecartypeEpreuves(cur,s)
m=-1
for i in d :
if d[i]>m:
m=d[i]
ep=i
return ep
Version 1
def discriminante(cur, s):
d = EcartTypeEpreuves(cur, s)
return max(d, key = lambda nomEpr : d[nomEpr])
version 2
def discriminante(cur, s):
d = EcartTypeEpreuves(cur, s)
ref = -1
res = None
for nomEpr in d:
if d[nomEpr] > ref:
ref = d[nomEpr]
res = nomEpr
return res
Version 3
def discriminante(cur, s):
d = EcartTypeEpreuves(cur, s)
ref = -1
res = None
for nomEpr, stdEpr in [Link]():
if stdEpr > ref:
ref = stdEpr
res = nomEpr
return res
Alternative de Correction Concours (MP PC T) - Session juillet 2020 Epreuve d’Informatique Page 7/6
