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