Corrigé du TD I2 Programmation en Python

Lycée Bellevue – Toulouse
PCSI 2 – Informatique
Année 2016-2017
Corrigé du TD I2
Programmation en Python
Exercice 6 du cours I2.
# a.
def Somme(L):
"""renvoie la somme des éléments de la liste L."""
S=0
for k in range(len(L)):
S=S+L[k]
return S
# b.
def NbPositifs(L):
"""renvoie la nombre d’éléments positifs dans la liste L."""
c=0 # compteur
for a in L:
if a>=0:
c=c+1
return c
# c.
def Moyenne(L):
"""renvoie la moyenne des éléments de la liste L."""
return Somme(L)/len(L)
# d.
def MoyennePositifs(L):
"""renvoie la moyenne des éléments positifs de la liste L."""
S=0
c=0 # compteur
for a in L:
if a>=0:
S=S=a
c=c+1
if c>0:
return S/c
else:
return 0
page 1/13
PCSI 2 – Informatique
Corrigé du TDI2 - Programmation en Python
# e.
def TestAppartenance(x,L):
"""Teste si x est dans L."""
B=False # booléen
for a in L;
if a==x:
B=True
return B
Exercice 1.
a. La fonction NbSup renvoie le nombre d’éléments de la liste L strictement supérieurs
au nombre a. En effet, le compteur n est initialisé à 0 (ligne 3), puis incrémenté
(ligne 6) à chaque fois qu’un élément x de L est strictement supérieur à a (ligne 5).
b. On obtient la liste [6,5,4,3].
c. On obtient la liste [8,8,4,0].
d. La fonction trie la liste qu’elle reçoit dans l’ordre décroissant.
Exercice 2.
# a.
def Maximum(L):
"""renvoie le maximum de la liste de nombres L."""
mp=L[0] # maximum potentiel
for x in L:
if x>mp:
mp=x
return mp
# b.
def PositionMaximum(L):
"""renvoie la position du maximum de la liste de nombres L."""
mp=L[0] # maximum potentiel
i=0
# sa position
for k in range(len(L)):
if L[k]>mp:
mp=L[k]
i=k
return i
page 2/13
PCSI 2 – Informatique
Corrigé du TDI2 - Programmation en Python
Exercice 3.
def PremierNonNul(A):
"""Renvoie la position du premier entier non-nul de A,
ainsi que sa position.
A est supposée ne pas contenir que des zéros."""
k=0
while A[k]==0:
k=k+1
return k,A[k]
Exercice 4.
# a.
def TestPositifs(L):
"""Teste si la liste L ne contient que des nombres positifs."""
B=True # booléen
for a in L:
if a<0:
B=False
return B
# b.
def TestCroissante(L):
"""Teste si la liste L est rangée dans l’ordre croissant."""
B=True
for k in range(len(L)-1):
if L[k]>L[k+1]:
B=False
return B
# c.
def TestConstante(L):
"""Teste si la liste L est constante."""
B=True
for k in range(1,len(L)):
if L[k]!=L[0]:
# tous les éléments doivent être égaux au premier
B=False
return B
page 3/13
PCSI 2 – Informatique
Corrigé du TDI2 - Programmation en Python
# d.
def Testdistincts(L):
"""Teste si la liste L ne contient que des éléments distincts."""
B=True
for k in range(len(L)-1):
for j in range(k+1,len(L)):
if L[k]==L[j]: # chaque élément est comparé à tous les suivants
B=False
return B
Exercice 5.
# a:
def Moyenne(S):
"""renvoie la moyenne de la série statistique S."""
Somme=0
for a in S:
Somme=Somme+a
return Somme/len(S)
# b:
def EcartType(S):
"""renvoie l’écart-type de la série statistique S."""
Somme=0
m=Moyenne(S)
for a in S:
Somme=Somme+(a-m)**2
return (Somme/len(S))**(1/2)
# c:
def Mode(S):
"""renvoie le mode de la série statistique S."""
nma=0
# nombre maximum d’apparition d’un élément de S
for a in L:
# Comptage du nombre d’apparitions de a
c=0
# compteur
for b in L:
if a==b:
c=c+1
# a est-il le plus fréquent des nombres déjà rencontrés ?
if c>nma:
nma=c
m=a
# a est le mode
return m
page 4/13
PCSI 2 – Informatique
Corrigé du TDI2 - Programmation en Python
# d:
def Mediane(S):
"""renvoie la médiane de la série statistique S."""
L=sorted(S)
# tri de S
n=len(L)
if n%2==1:
return L[n//2]
else:
return (L[n//2-1]+L[n//2])/2
Exercice 6.
# a:
def u(n):
"""renvoie le terme n de la suite définie par
u(0)=2 et u(n+1)=(u(n)**2+1)/(2*u(n)+3))."""
u=2
# initialisation
for k in range(n):
u = (u**2+1) / (2*u+3)
return u
# b:
def U(n):
"""renvoie la liste des n premiers termes de la suite définie par
u(0)=2 et u(n+1)=(u(n)**2+1)/(2*u(n)+3))."""
u=2
# initialisation de la suite
U=[u] # initialisation de la liste
for k in range(n):
u = (u**2+1) / (2*u+3)
U.append(u)
return U
Exercice 7.
# a:
def TestConvergence(U):
"""Teste si la suite U est convergente,
ie si ses 100 derniers termes sont égaux au dernier à 1e-3 près."""
lim=U[-1]
# limite potentielle de la suite
CV=True
# booléen, vrai si U est convergente
for k in range(100):
if abs(U[-1-k]-lim)>1e-3:
CV=False
return CV
page 5/13
PCSI 2 – Informatique
Corrigé du TDI2 - Programmation en Python
# b.
# On suppose que U est convergente, vers une limite non-nulle.
lim=U[-1]
ps=0.01
# limite de la suite
# pourcentage de stabilité
k=len(U)-1 # on part de la fin
while k>=0 and abs((U[k]-lim)/lim)<ps:
k=k-1
print("La stabililité est obtenue à partir du terme d’indice",k+1,".")
Exercice 8.
# a:
A=float(input("A="))
S=0
n=0
# Variable d’accumulation
while S<A:
n=n+1
S=S+1/n
print("Sn est supérieur à",A,"à partir du rang",n)
Pour la question b, on calcule que un − un−1 =
1
n
n
− ln n−1
·
Cette différence est stockée dans la variable a. Lorsqu’elle est inférieure à ε2 on considère
que le terme un (stocké dans la variable u) est assez proche de sa limite γ.
# b: Calcul de gamma
from math import log
n=1
u=1
a=1
# premier terme (d’indice 1)
# contiendra u(n)-u(n-1)
while abs(a)>eps**2:
n=n+1
a=1/n-log(n/(n-1))
u=u+a
print("gamma =",u,"
(à",eps,"près)")
page 6/13
PCSI 2 – Informatique
Corrigé du TDI2 - Programmation en Python
Exercice 9.
# a:
def Nom(S):
"""Reçoit un symbole chimique et renvoie le nom qu’il représente."""
for k in range(len(CPE)):
if CPE[k]==S:
return Elements[k]
# b:
P=[2,8,8,18,18,32,32]
def Configuration(Z):
"""renvoie la configuration de l’élément de numéro atomique Z."""
L=[]
# Initialisation
e=Z
# nombre d’électrons à placer
k=0
# numéro de la première couche à remplir
while e>P[k]:
L=L+[P[k]]
e=e-P[k]
k=k+1
L=L+[e] # les derniers électrons sont placés sur la dernière couche
return L
Exercice 10.
# a:
m=Tournoi[0][2]+1 # temps le plus court
for L in Tournoi:
if L[2]<m:
m=L[2]
Nom=L[0]
Dossard=L[1]
print("Le gagnant est :",Nom)
print("Son numéro de dossard :",Dossard)
# b:
def Indice(d):
"""renvoie l’indice dans la liste Tournoi du skieur portant
le dossard d."""
for k in range(len(Tournoi)):
if Tournoi[k][1]==d:
return k
page 7/13
PCSI 2 – Informatique
Corrigé du TDI2 - Programmation en Python
# b:
def Classement(d):
"""renvoie le classement du skieur portant le dossard d."""
k=Indice(d)
t=Tournoi[k][2] # temps du skieur d
c=1
# son classement
for L in Tournoi:
if L[2]<t: # un skieur a fait un meilleur temps
c=c+1
# le classement augmente donc
return c
Exercice 11.
# a:
def Crypt(L,c):
"""renvoie une liste M cryptant la liste L selon la clef c."""
M=[]
for a in L:
M=M+[(a*c)%256]
return M
# b:
def Clef(M):
"""reçoit une liste M cryptant une liste commençant par 1.
Renvoie la clef de décryptage."""
b=M[0] # premier élément de M. Cet élément doit être envoyé sur a
for k in range(1,256,2):
if (k*b)%256==1:
d=k
return d
Exercice 12.
# a:
def decompression(M):
"""renvoie la décompression de la liste M."""
a=M[0]
L=[]
for k in range(1,len(M)):
for i in range(M[k]):
L.append(a)
a=1-a # inverse 0 et 1
return L
page 8/13
PCSI 2 – Informatique
Corrigé du TDI2 - Programmation en Python
# b:
def compression(L):
"""renvoie la compression de la liste L."""
M=[L[0]]
c=1 # compteur d’occurrences
for k in range(1,len(L)):
if L[k]==L[k-1]:
c=c+1
else:
M=M+[c]
c=1
M=M+[c]
return M
Exercice 13.
# a:
def Suivante(L):
"""Renvoie la ligne suivant la ligne L."""
M=[]
a=L[0]
c=1 # compteur d’occurrences
for k in range(1,len(L)):
if L[k]==a:
c=c+1
else:
M=M+[c,a]
a=L[k]
c=1
M=M+[c,a]
return M
L=[1]
print(L)
for k in range(10):
L=Suivante(L)
print(L)
# b:
def Precedente(M):
"""Renvoie la ligne précédant la ligne M."""
L=[]
for k in range(len(M)//2):
for i in range(M[2*k]):
L=L+[M[2*k+1]]
return L
page 9/13
PCSI 2 – Informatique
Corrigé du TDI2 - Programmation en Python
Exercice 14.
# a:
L="ACGT"
def TestADN(C):
"""Teste si la chaîne de caractères C ne contient que les caractères
A, C, G, T."""
for c in C:
if not c in L:
return False
return True
# b:
def NbId(C,D):
"""Compte le nombre de caractères communs dans les chaînes C et D."""
c=0
for k in range(min(len(C),len(D))):
if C[k]==D[k]:
c=c+1
return c
# c:
def TestInclusion(D,C):
"""Teste si la chaîne D est incluse dans la chaîne C."""
m=len(D)
n=len(C)
for k in range(n-m+1):
if D==C[k:k+m]:
return True
return False
Exercice 15.
Couleur=["pique","coeur","carreau","trèfle"]
Valeur=[str(k) for k in range(2,11)]+["valet","dame","roi","as"]
from random import randint
# a:
Jeu=[]
for i in range(4):
for j in range(13):
Jeu=Jeu+[[i,j]]
page 10/13
PCSI 2 – Informatique
Corrigé du TDI2 - Programmation en Python
# b:
def Main(Jeu):
"""renvoie une main de 5 cartes."""
M=[]
J=Jeu[:]
for k in range(5):
i=randint(0,len(J)-1)
M=M+[J[i]]
J[i:i+1]=[]
return M
# c:
def Distribution(n,jeu):
"""renvoie une liste de n mains prelevées dans Jeu."""
D=[]
J=Jeu[:]
for m in range(n):
M=[]
for k in range(5):
i=randint(0,len(J)-1)
M=M+[J[i]]
J[i:i+1]=[]
D=D+[M]
return D
# d:
def Tableaux(M):
"""renvoie le nombre de cartes de chaque couleur et le nombre de
cartes de chaque valeur dans la main M."""
C=[0]*4 # Couleurs
V=[0]*13 # Valeurs
for m in M:
C[m[0]]+=1
V[m[1]]+=1
return C,V
# e:
# Une définition préalable :
def NbOc(a,L):
"""Compte le nombre d’occurrences de a dans L."""
c=0 # compteur
for x in L:
if x==a:
c=c+1
return c
page 11/13
PCSI 2 – Informatique
Corrigé du TDI2 - Programmation en Python
On définit les tests pour toutes les combinaisons :
def Coul(M):
"""Teste si la main M contient une couleur."""
C,V=Tableaux(M)
return max(C)==5
def Carre(M):
"""Teste si la main M contient un carré."""
C,V=Tableaux(M)
return max(V)==4
def Full(M):
"""Teste si la main M contient un full."""
C,V=Tableaux(M)
return max(V)==3 and NbOc(0,V)==11
def Brelan(M):
"""Teste si la main M contient un brelan."""
C,V=Tableaux(M)
return max(V)==3 and NbOc(0,V)==10
def Suite(M):
"""Teste si la main M contient une suite."""
C,V=Tableaux(M)
W=[0]*9 # contiendra, en position k, le nombre de cartes de valeurs
# comprises entre k et k+4
for k in range(9):
for i in range(5):
W[k]+=V[k+i]
return max(W)==5
def SuiteRoyale(M):
"""Teste si la main M contient une suite royale."""
C,V=Tableaux(M)
return Suite(M) & max(C)==5
def Paire(M):
"""Teste si la main M contient une paire."""
C,V=Tableaux(M)
return max(V)==2 and NbOc(0,V)==9
def DoublePaire(M):
"""Teste si la main M contient une double paire."""
C,V=Tableaux(M)
return max(V)==2 and NbOc(0,V)==10
page 12/13
PCSI 2 – Informatique
Corrigé du TDI2 - Programmation en Python
# f:
def Force(M):
"""renvoie la force d’une main."""
C,V=Tableaux(M) # Il est préféreable de réécrire toutes les fonctions
# pour ne pas évaluer Tableaux de multiples fois."""
if max(V)==4:
# carré
return 7
if max(V)==3:
if NbOc(0,V)==11: # full
return 6
else:
# brelan
return 3
if max(V)==2:
if NbOc(0,V)==10 : # double paire
return 2
else:
# paire
return 1
W=[0]*9 # Liste pour les suites
for k in range(9):
for i in range(5):
W[k]+=V[k+i]
if max(W)==5:
if max(C)==5:
# suite royale
return 8
else:
# suite
return 4
if max(C)==5:
# couleur
return 5
return 0
Quelques tests :
def AffichageMain(M):
"""Affiche la main M en français."""
for C in M:
print(Valeur[C[1]],"de",Couleur[C[0]])
Combinaisons=["Aucune","Paire","Double paire","Brelan","Suite","Couleur",
"Full","Carré","Suite royale"]
mini=7
# à modifier
N=100000
for k in range(N):
M=Main(Jeu)
f=Force(M)
if f>=mini:
AffichageMain(M)
print("Combinaison :",Combinaisons[Force(M)],end="\n\n")
page 13/13