Institut Supérieur d'Informatique Année Universitaire : 2020-2021

Mahdia (ISIMA) Enseignante : Maroua ABDELHAFIDH

Département d’Informatique Filière : D-LCE

Correction TP3 : Programmation Python

Exercice 1 :
Ecrire une fonction qui permet de vérifier si un nombre positif contient des chiffres qui se
répètent ou non.
Exp : le nombre 1584 ne contient pas des chiffres qui se répètent
Le nombre 1556 contient des chiffres qui se répètent

Exercice 2 :
Ecrire une fonction récursive qui permet de trouver le maximum dans un tableau.

Exercice 3 :
Soit le polynôme suivant : P=X3−10X2−2610X+ 84.
1- Ecrire une fonction qui retourne la valeur de ce polynôme en entier x.
2- Ecrire un programme qui affiche le minimum et l’indice de la valeur prise par ce
polynôme pour les entiers appartenant à l’intervalle [−20,25].
def polynome(x):
return x**3-10*(x**2)-2610*x+84
min=polynome(-20)
indice=-20
for i in range(-20,25):
if polynome(i)<min:
min=polynome(i)
indice=i
print("la valeur minimale est",min)
print("elle est en indice",indice)

3- Ecrire une fonction qui prend en argument un entier x, et retourne la valeur d

(x(4x2−1))/3.
 4- Ecrire une fonction somme_carre qui prend en argument un entier x, et retourne la
valeur de la somme suivante : s = ∑ (2 − 1)
5- Ecrire une fonction test qui vérifie si la formule définie dans (3) permet de calculer la
somme dans (4) pour tout entier x compris entre 1 et N.
def polynome1(n):
return n*(4*n*n-1)/3
def somme_carre(n):
res=0
for i in range (1,n+1):
res+=(2*i-1)**2
return res

def test_formule(N):
res=True
for i in range(1, N+1):
if polynome1(i)!=somme_carre(i):
res=False
return res

Exercice 4 :
1- Ecrire une fonction qui prend en argument une liste L composée de quatre entiers n1,
n2, n3, 4. A l’aide d’un nombre aléatoire n inférieur à 100, cette fonction retourne un
caractère de la façon suivante :
a si n<n1
b si n1<= n < n1+n2
c si n1+n2<= n < n1+n2+n3
d sinon
N.B : utiliserez la librairie random pour générer les nombre aléatoirement
2- Ecrire une fonction qui prend en argument un entier Net une liste L= [n1, n2, n3, n4] de
quatre entiers, et qui retourne une chaîne de caractères formée par N caractères définis à l’aide
de la fonction précédente.
import random
p1=int(input("donner le premier element"))
p2=int(input("donner le deuxieme element"))
p3=int(input("donner le troisieme element"))
p4=int(input("donner le quatrieme element"))
L=[p1,p2,p3,p4]
N=int(input("donner N"))
def genere_char(L):
x=random.randrange(100)
if(x<L[0]):
return 'a'
elif (x<L[0]+L[1]):
return'b'
elif (x<L[0]+L[1]+L[2]):
return 'c'
else:
return 'd'
def genere(N,L):
t=" "
for i in range(N):
t+=genere_char(L)
return t
char=genere_char(L)
a=genere(N,L)
print(char)
print(a)
Exercice 5:
Soit deux caractères ‘e’ et ‘a’ sont inversé dans une chaine de caractères par erreur.
1- Ecrire une fonction inverse qui prend en argument une chaine de caractères et qui
corrige la faute tout en remplaçant les occurrences du caractère ’e’ par ’a’, de façon
réciproque.
2- Ecrire une fonction qui prend en argument une chaine de caractères chaine et qui la
retourne en corrigeant les occurrences de ’ae’ en les remplaçant par ‘ea’.

def echange(chaine):
new=" "
for c in chaine:
if (c=="a"):
new+="e"
elif (c=="e"):
new+="a"
else:
new+=c
return new

def corrige_chaine(chaine):
new= " “
i=0
while i<len(chaine)-1:
if (chaine[i:i+2]=='ae'):

new+=chaine[i:i+2].replace('ae', 'ea')
i=i+2
else:
new += chaine[i]
i=i+1

return new
#chaine2=echange(chaine)
chaine1=input("donner la chaine")
chaine3=corrige_chaine(chaine1)
#print(chaine2)
print(chaine3)
Exercice :

#3.1
t1 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31]
t2 =
['Janvier','Février','Mars','Avril','Mai','Juin',"Juillet",'Août','Septembr
e','Octobre','Novembre','Décembre']
t3=[]
a=0
b=len(t1)
while a<b:
t3.append(t2[a])
t3.append(t1[a])
a+=1
print (t3)

#3.2 (1 ere solution)

print("le plus grand élement de cette liste a la valeur "+str(max(t1)))
#3.2 (2 eme solution)
max = 0
# Examen de tous les éléments :
i = 0
while i < len(t1):
if t1[i] > max:
max = t1[i] # mémorisation d'un nouveau maximum
i = i + 1
# Affichage :
print ("Le plus grand élément de cette liste a la valeur", max)

#3.3
pairs = []
impairs = []
for i in t1:
if (i % 2 == 0 and i not in pairs) :
pairs.append(i)
if (i% 2 != 0 and i not in impairs):
impairs.append(i)

print ("Nombres pairs :"+ str(pairs))

print ("Nombres impairs :"+ str(impairs))

#3.4

liste1=[]
liste2=[]
for i in t2:
if (len(i) <6) :
liste1.append(i)
else:
liste2.append(i)
print (liste1)
print (liste2)