Informatique – 2ème Année IPEIN 2021/2022

TD0 - Série de révision

Problème 1 :
Un nombre premier est un entier qui n’est divisible que par 1 et par lui-même. On se propose d’écrire un
programme qui établit la liste de tous les nombres premiers compris entre 1 et 100, en utilisant la méthode du
crible d’Eratosthène :
 Créer une liste de 100 éléments, chacun initialisé à la valeur 1,
 Parcourir cette liste à partir de l’élément d’indice 2: si l’élément analysé possède la valeur une, mettez à
zéro tous les autres éléments de la liste, dont les indices sont les multiples de l’indice auquel vous êtes
arrivé.
Lorsque vous aurez parcouru toute la liste, les indices des éléments restés à 1 seront les nombres premiers
recherchés.
En effet : à partir de l’indice 2, vous annulez tous les éléments d’indices pairs 4, 6,8…Avec l’indice 3, vous
annulez les éléments d’indices 6,9….et ainsi de suite. Seul resteront à 1 les éléments dont les indices sont
effectivement des nombres premiers.
1. Ecrire une fonction Init permettant d’initialiser une liste de 100 éléments à un.
2. Ecrire une fonction Multiple permettant de mettre à zéro les éléments dont l’indice est un multiple d’un
entier donné comme paramètre.
3. Ecrire une fonction Suivant qui à partir d’un indice donné retourne le premier indice dont l’élément
correspondant est différent de zéro.
4. Ecrire une fonction Crible permettant d’appliquer la méthode présentée par le crible d’Eratosthène pour
retourner une liste qui contient les nombres premiers (il suffit d’étirer jusqu’à la racine entière de 100).
5. Ecrire une fonction récursive Crible_recursive permettant d’appliquer la méthode présentée pour
retourner la liste initiale après les modifications.
6. Donner le schéma d’exécution de la fonction précédente (si on veut déterminer les entiers premiers qui sont
<10).
7. Ecrire un programme qui fait appel aux fonctions déjà définies afin d’afficher les entiers premiers compris
entre 1 et 100.
Problème 2 :
On définit une suite de polynôme SP par :
(x) = P(x)
(x) = - (x)
= Q(x)*
Avec : P(x) un polynôme de degré n (n≠0) tel que : P(x)=
(x) le polynôme dérivé de degré n-1 tel que : (x)=
Q(x) est le produit des deux polynômes (x)
Tout polynôme de degré « n » sera représenté sous forme d’une liste de taille « n+1 » tel que les coefficients sont
les éléments et les degrés sont les indices.
Exemple : La liste correspondante au polynôme P(x)= 1 + x - 5 + + est : L=[1,1,-5,1,-2,0,6]
On désire déterminer à partir de la suite ci-dessus le polynôme (x) avec m>=2.
1. Ecrire une fonction appelée Saisie_deg qui permet de saisir un entier strictement positif.
2. Ecrire une fonction appelée Saisie_poly permettant de saisir la représentation d’un polynôme P(x) de degré
« n » dans une liste.
3. Ecrire une fonction appelée Derive permettant de déterminer la représentation du polynôme dérivé d’un
polynôme, représenté par une liste, le résultat sera une liste.
4. Ecrire une fonction appelée Opp_poly permettant de déterminer la représentation du polynôme opposé,
représenté par une liste, le résultat sera une liste.
5. Ecrire une fonction appelée Add_poly qui prend comme paramètres deux polynômes P1 et P2 ainsi que
leur degrés et retourne la représentation du polynôme P1+P2.
6. Ecrire une fonction appelée Mul_poly qui prend comme paramètres deux polynômes P1 et P2 ainsi que
leur degrés et retourne la représentation du polynôme P1*P2.
Sachant que si P1(x)= et P2(x)=

TD0 : Série de révision https://www.facebook.com/groups/ipein.info Page 1 sur 2

 Informatique – 2ème Année IPEIN 2021/2022

Alors le produit est P1(x)*P2(x)= avec

7. Ecrire le programme principal permettant de :
- saisir le degré « n » d’un polynôme,
- saisir la liste qui représente le polynôme P,
- déterminer et afficher la liste D relative à la dérivée du polynôme P,
- déterminer et afficher la liste O relative à l’opposé du polynôme P,
- déterminer et afficher la liste A relative à l’addition de P et sa dérivée,
- déterminer et afficher la liste M relative à la multiplication de P avec sa dérivée.
Problème 3 :
L’objectif de ce problème est d’écrire un programme de gestion de livres d’une bibliothèque (saisie, emprunt,
affichage,…).
Chaque livre est caractérisé par un numéro un titre et un nombre d’exemplaires. Les caractéristiques relatives à tous
les livres sont représentées par les trois listes suivantes :
 Lnum pour tous les numéros des livres [num1,num2,….]
 Ltitre pour tous les titres des livres [T1,T2,……]
 Lexp pour tous les nombres des exemplaires [nb1,nb2,…..]
Le livre dont le numéro est Lnum[k] a pour titre Ltitre[k] et un nombre d’exemplaires disponibles Lexp[k].
Chaque numéro de livre et nombre d’exemplaires est un entier strictement positif, chaque titre est une chaîne de
caractères.
Pour la gestion des emprunts des livres, on utilise la liste de listes LE où chaque sous_liste correspond à un
emprunt avec chaque sous_liste contient sept éléments selon cet ordre :
 CIN : un entier strictement positif composé de 8 chiffres,
 Num : un numéro de livre qui doit correspondre à un numéro de livre existant dans la bibliothèque,
 JE : le jour de l’emprunt,
 ME : le mois de l’emprunt,
 JR : le jour de retour prévu après 10 jours de la date de l’emprunt,
 MR : le mois de retour,
 P : indique si un emprunteur est pénalisé (P prend la valeur 1) ou non (P prend la valeur 0).
Pour la gestion des pénalités, on utilise une liste LP contenant les identifiants des emprunteurs pénalisés ayant
rendu leurs livres.
Hypothèse de travail :
 Un emprunteur n’a pas le droit d’emprunter plus qu’un livre à la fois,
 Un emprunteur pénalisé n’a pas le droit à un nouvel emprunt,
 On suppose que l’année est non bissextile (février contient 28 jours).
Travail demandé
1. Ecrire une fonction Saisie permettant de saisir un entier strictement positif.
2. Ecrire une fonction ajout_titre qui saisit un numéro de livre à ajouter, son titre et le nombre des
exemplaires en faisant les contrôles nécessaires.
3. Ecrire une fonction Etat_biblio, qui affiche pour chaque livre son titre ainsi que le nombre d’exemplaires
restants.
4. Ecrire une fonction aut_emprunt qui à partir du CIN d’un étudiant, vérifie s’il est autorisé d’emprunter un
livre.
5. Ecrire une fonction calcul_date qui calcule la date de retour prévue.
6. Ecrire une fonction emprunt qui saisit le CIN de l’emprunteur et vérifier s’il est autorisé à emprunter, dans
le cas de non pénalité saisir le numéro du livre. Si le livre est disponible en stock on doit saisir la date de
l’emprunt, réduire le stock et mettre à jour la liste des emprunts.
7. Ecrire une fonction MAJ_penalite qui à partir d’une date donnée met à jour la liste des emprunts ayant
dépassé cette date limite de retour puis fait la mise à jour de la liste des pénalités en y ajoutant les CIN des
emprunteurs pénalisés.
8. Ecrire une fonction retour permettant de faire les mises à jour nécessaire en cas de retour d’un livre.

TD0 : Série de révision https://www.facebook.com/groups/ipein.info Page 2 sur 2

Informatique – 2ème Année IPEIN 2021/2022
TD0 - Série révision - Corrigé
Problème 1 :

1- Fonction Init permettant d’initialiser la liste :

1. from math import sqrt

2. def Init():
3. return [1]*100

2- Fonction Multiple :

1. def Multiple(L,ind):
2. for i in range(ind+1,len(L)):
3. if i%ind == 0:
4. L[i] = 0

3- Fonction Suivant :

1. def Suivant(L,ind):
2. i = ind + 1
3. while L[i] == 0:
4. i += 1
5. return i

4- Fonction Crible :

1. def Crible(L):
2. i = 2
3. while i<= int(sqrt(100)):
4. multiple(L,i)
5. i = Suivant(L,i)
6. print(L)
7. premier = []
8. for i in range(2,len(L)):
9. if L[i] == 1:
10. premier.append(i)
11. return premier

5- Fonction récursive Crible_recursive

1. def crible_recursive(L,ind=2):
2. if ind > int(sqrt(100)): #condition d’arrêt
3. return L
4. else:
5. Multiple(L,ind)
6. return crible_recursive(L,suivant(L,ind))

TD0 – Corrigé https://www.facebook.com/groups/ipein.info Page 1 sur 5

Informatique – 2ème Année IPEIN 2021/2022

6- Schéma d’exécution de la fonction récursive pour N = 10

L=[1,1,1,1,1,1,1,1,1,1]
crible_recursive(L,2):
Multiple(L,2)
L
crible_recurcive(L,3)

L=[1,1,1,1,0,1,0,1,0,1]
crible_recursive(L,3):
Multiple(L,3)
crible_recurcive(L,5)
L

L=[1,1,1,1,0,1,0,1,0,0]
crible_recursive(L,5):
return L

7- Programme principal
1. #Avec function non recursive
2. def main():
3. L = Init()
4. print("\n", L)
5. p = Crible(L)
6. print(p)

1. #Avec fonction récursive

2. def main():
3. L = Init()
4. crible_recursive(L)
5. premier = []
6. for i in range(2,len(L)):
7. if L[i] == 1:
8. premier.append(i)
9. print("\n", primier)
Problème 2 :

1- La function Saisie_deg :
1. def Saisie_deg():
2. while True:
3. try:
4. n = int(input("donner le degre du polynome :"))
5. if type(n) == int and n>0:
6. Break #fin de while
7. except ValueError:
8. Continue #suite de while
9. return n

2- Fonction Saisie_poly:
1. def Saisie_poly(deg):
2. LP = []
3. for i in range(deg+1):
4. while True:
5. try:
6. print("donner coefficient a",i)

TD0 – Corrigé https://www.facebook.com/groups/ipein.info Page 2 sur 5

Informatique – 2ème Année IPEIN 2021/2022
7. c = float(input())
8. if type(c) == float :
9. break
10. except ValueError:
11. continue
12. LP.append(c)
13. return LP
3- Fonction Derive:
1. def Derive(LP,deg):
2. DP = []
3. for i in range(1,deg+1):
4. DP.append(i*LP[i])
5. return DP
4- Fonction Opp_poly:
1. def opp_poly(LP,deg):
2. OP = []
3. for i in range(deg+1):
4. OP.append(-LP[i])
5. return OP
5- Fonction Add_poly :
1. def Add_poly(P1,P2,deg1,deg2):
2. S = []
3. m = min(deg1,deg2)
4. for i in range(m+1):
5. S.append(P1[i]+P2[i])
6. if m == deg1:
7. S = S+P2[m+1:]
8. if m == deg2:
9. S = S+P1[m+1:]
10. return S
6- Fonction Mul_poly :
1. def Mul_poly(P1,P2,deg1,deg2):
2. P=[]
3. for k in range(deg1+deg2+1):
4. # calcul de ck
5. c=0
6. for i in range(deg1+1):
7. for j in range(deg2+1):
8. if k == i+j:
9. c += P1[i]*P2[j]
10. P.append(c)
11. return P
7- Programme principal
1. deg = Saisie_deg()
2. P = Saisie_poly(deg)
3. print("P = ", P)
4. D = Derive(P,deg)
5. print("D = ", D)
6. O = opp_poly(P,deg)
7. print("O = ", O)
8. A = Add_poly(P,D,deg,deg-1)
9. print("A = ", A)
10. M = Mul_poly(P,D,len(P)-1,len(D)-1)
11. print("M = ", M)
Problème 3 :

1. Fonction Saisie permettant de saisir un entier strictement positif :

1. def Saisie():
2. while True:

TD0 – Corrigé https://www.facebook.com/groups/ipein.info Page 3 sur 5

Informatique – 2ème Année IPEIN 2021/2022
3. try:
4. n=int(input("donner un entier strictement positif"))
5. if n>0: break
6. else: print("Erreur 01:", n, "n’est pas entier > 0")
7. except ValueError:
8. print("Erreur 02 : Saisie incorrecte... ")
9. continue
10. return n
2. Fonction ajout_titre qui saisit un numéro de livre à ajouter, son titre et le nombre des
exemplaires en faisant les contrôles nécessaires :

1. def Ajout_titre(Ltitre,Lnum,Lexp):
2. t = input('Donner un titre :')
3. while True:
4. print("donner le numéro du livre :")
5. n = Saisie()
6. if n not in Lnum: break
7. else: print(n,”: Ce numéro existe”)
8. nexp = Saisie()
9. Ltitre.append(t)
10. Lnum.append(n)
11. Lexp.append(nexp)
3. Fonction Etat_biblio, qui affiche pour chaque livre son titre ainsi que le nombre
d’exemplaires restants :

1. def Etat_biblio(Ltitre,Lexp):
2. print("Titre \t Nbr. Exemplaires")
3. for i in range(len(Ltitre)):
4. print(“{0}\t{1}”.format(Ltitre[i],Lexp[i]))
4. Fonction aut_emprunt qui à partir du CIN d’un étudiant, vérifie s’il est autorisé
d’emprunter un livre :

1. def aut_emprunt(CIN, LE,LP):

2. # vérifier qu'il n'a pas déjà un livre à rendre
3. i = 0
4. B1 = False
5. while B1==False and i<len(LE):
6. if CIN==LE[i][0]:
7. B1=True
8. else:
9. i+=1
10. # Vérifier qu'il n'est pas pénalisé
11. B2 = CIN not in LP
12. return not B1 and B2
5. Fonction calcul_date qui calcule la date de retour prévue :

1. def calcul_date(j,m):
2. jr = j+10
3. mr = m
4. if jr>31 and m in [1,3,5,7,8,10,12]:
5. jr = jr-31
6. mr += 1
7. if mr == 13:
8. mr = 1
9. if jr>30 and m in [4,6,9,11]:
10. jr = jr-30
11. mr += 1
12. if jr>28 and m==2:
13. jr=jr-28
14. mr=3

TD0 – Corrigé https://www.facebook.com/groups/ipein.info Page 4 sur 5

Informatique – 2ème Année IPEIN 2021/2022
15. return(jr,mr)
6. Fonction emprunt qui saisie le CIN de l’emprunteur et vérifier s’il est autorisé à emprunter,
dans le cas de non pénalité saisir le numéro du livre. si le livre est disponible en stock on
doit saisir la date de l’emprunt, réduire le stock et mettre à jour la liste des emprunts :

1. def emprunt(LP,LE,Lexp,Lnum):
2. while True: #Saisie et vérification de CIN
3. try:
4. CIN = input("donner le CIN de l'emprunteur")
5. if len(CIN))== 8:
6. CIN = int(CIN)
7. break
8. except ValueError:
9. continue
10. if aut_emprunt(CIN,LE,LP):
11. while True:
12. print('saisir le numéro du livre'))
13. num = saisie()
14. if num in Lnum:
15. break
16. k = Lnum.index(num)
17. if Lexp[k]>0:
18. je = int(input("saisir la date de l'emprunt"))
19. me = int(input("saisir le mois de l'emprunt"))
20. Lexp[k]-=1
21. jr,mr = calcul_date(je,me)
22. LE.append([CIN,num,je,me,jr,mr,0])
23. else:
24. print(“Livre demandé n’est pas disponible”)
7. Fonction MAJ_penalite qui à partir d’une date donnée met à jour la liste des emprunts
ayant dépassé cette date limite de retour puis fait la mise à jour de la liste des pénalités en y
ajoutant les CIN des emprunteurs pénalisés :

1. def MAJ_penalite(LE,LP,j,m):
2. for L in LE:
3. if m>L[5] or m==L[5] and j>L[4]:
4. L[6]=1
5. if L[0] not in LP:
6. LP.append(L[0])
8. Fonction retour permettant de faire les mises à jour nécessaire en cas de retour d’un livre :

1. def retour(num,j,m,LE,Lexp,LP):
2. MAJ_penalite(LE,LP,j,m)
3. i = 0
4. while LE[i][1]!= num and i<len(LE):
5. i += 1
6. del LE[i]
7. k = Lexp.index(num)
8. Lexp[k]+=1

TD0 – Corrigé https://www.facebook.com/groups/ipein.info Page 5 sur 5