Vous êtes sur la page 1sur 61

Institut Préparatoire aux Etudes d’Ingénieurs de Sfax (IPEIS), Université de Sfax

Révision Semestre 1
Introduction à la programmation
Python

Matière : INFORMATIQUE
Sections : MP/PC/PT – 1ère Année

Fatma Ben Saïd


fatma.ben.said@ipeis.usf.tn
© 2020
ANNEXE 2 : Révision
Correction Devoirs, Examens

Cours
ANNEXE 2 2
Introduction à la programmation Python
Partie 1 :

Système de numération

Cours
ANNEXE 2 3
Introduction à la programmation Python
Système de numération Révision S1

Exercice 1 :
1. Quelles sont les valeurs minimales et maximales qu'on peut représenter en entier naturel
(entier non signé), en signe valeur absolue (SVA) et en complément à 2 (C2) sur 8 bits.
2. Soit le mot binaire 11001011 représenté sur 8 bits. A quel nombre décimal correspond-il
si l’on considère qu’il est écrit en utilisant :
a. la représentation non signée (entier naturel).
b. la représentation signée en signe valeur absolue.
c. la représentation signée en complément à deux.
3. Effectuer les opérations d’additions suivantes tout en utilisant la représentation en
complément à deux sur 1 octet. Indiquer dans les deux cas s’il y a une retenue ou un
dépassement (débordement).
X=-53-75 et Y=53+75
Cours
ANNEXE 2 4
Introduction à la programmation Python
Système de numération (suite) Révision S1

Exercice 1 :
1. Quelles sont les valeurs minimales et maximales qu'on peut représenter en entier
naturel (entier non signé), en signe valeur absolue (SVA) et en complément à 2 (C2) sur
8 bits.
Valeur minimale Valeur maximale
entier naturel 0 255=28-1
signe valeur absolue (SVA) -127 127=27-1
complément à 2 (C2) -128 127

2. Le nombre décimal qui correspond à 11001011 (représenté sur 8 bits) :


représentation non signée représentation signée en représentation signée en
(entier naturel) signe valeur absolue complément à deux
203 -75 -53
Cours
ANNEXE 2 5
Introduction à la programmation Python
Système de numération (suite) Révision S1

Exercice 1 :
utilisons la représentation en complément à deux sur 1 octet pour
effectuer les opérations d’additions suivantes : X=-53-75 , Y=53+75

X=-53-75
53 : 00110101 75 : 01001011
-53 : 11001011 -75 : 10110101
X2 Retenue Dépassement
1 1 1 1 1 1 1
10000000 1 0
-53 11001011
-75 10110101
110000000
Pas de dépassement ; le 8ème bit est 1 donc le signe du résultat est
Il y a une retenue
négatif qui est le même que les signes des deux nombres.
Cours
ANNEXE 2 6
Introduction à la programmation Python
Système de numération (suite) Révision S1

Exercice 1 :
utilisons la représentation en complément à deux sur 1 octet pour
effectuer les opérations d’additions suivantes : X=-53-75 , Y=53+75

Y=53+75
53 : 00110101 75 : 01001011
X2 Retenue Dépassement
1 1 1 1 1 1 1
10000000 0 1
53 00110101
75 01001011
10000000
Il y a un dépassement ; le 8ème bit est 1 donc le signe du résultat est
Pas de retenue
négatif qui est différent des signes des deux nombres.
Cours
ANNEXE 2 7
Introduction à la programmation Python
Système de numération Révision S1

Exercice 2 :
1. Convertissez les nombres réels suivants en valeurs IEEE-754 à
virgule flottante simple précision (32bits) : A= –32.75 et B=18.125
2. Quelle est la valeur décimale de chacune des représentations
binaires (sur 32bits en simple précision) suivantes :
a) 0100 0000 1111 0000 0000 0000 0000 0000
b) 1100 0010 0000 1110 0000 0000 0000 0000

Cours
ANNEXE 2 8
Introduction à la programmation Python
Système de numération (suite) Révision S1

Exercice 2 :
1. Convertissez les nombres réels suivants en valeurs IEEE-754 à virgule
flottante simple précision (32bits) : A= –32.75 et B=18.125

A=(-32.75)10 B=(18.125)10
=(-100000,11)2 =(10010,001)2
=-1,0000 011 25 =1,0010 001 24
• Signe<0 • Signe>0
• Eb = E+127 = 5+127 = (132)10 =(1000100)2 • Eb= E+127= 4+127= (131)10 =(10000011)2

A : 1 10000100 00000110000000000000000 B : 0 10000011 00100010000000000000000

Cours
ANNEXE 2 9
Introduction à la programmation Python
Système de numération (suite) Révision S1

Exercice 2 :
2. La valeur décimale de chacune des représentations binaires (sur 32bits
en simple précision) suivante :

a) C = 0100 0000 1111 0000 0000 0000 0000 0000 b) D = 1100 0010 0000 1110 0000 0000 0000 0000

Signe = 0  C>0 Signe = 1  D<0


Eb=(10000001)=129 donc E=2 Eb=10000100=132 donc E=5
C = 1,111 22 D = -1,000111 25
C = 111,1 D = -100011,1
C = 7,5 D = -35,5

Cours
ANNEXE 2 10
Introduction à la programmation Python
Système de numération Révision S1

Exercice 3 :
1- Soit les deux mots binaires suivants : 11111111 et 10110110.
Donnez leur représentation décimale sachant qu’ils sont codés sur 8 bits signés en complément à
deux.
2- Soit les deux nombres suivant N1=(-1)10 et N2=(-74)10.
a) Calculer en binaire en complément à deux, sur un octet, l’opération d’addition N1+N2.
b) Indiquer s’il y a une retenue et un dépassement tout en justifiant vos réponses.
c) Calculer la valeur décimale du résultat binaire trouvé.

3- Soit le nombre entier négatif suivant : -(80)10.


a) On souhaite le coder sur 8 bits signés en complément à deux.
Donnez sa représentation binaire et puis sa représentation hexadécimale.
b) On souhaite le coder sur 16 bits signés en complément à deux.
Donnez sa représentation binaire et puis sa représentation hexadécimale.

Cours
ANNEXE 2 11
Introduction à la programmation Python
Système de numération (suite) Révision S1

Exercice 3 :
1- Soit les deux mots binaires suivants : 11111111 et 10110110.
Donnez leur représentation décimale sachant qu’ils sont codés sur 8 bits
signés en complément à deux.

11111111 : Le 8ème bit est 1 donc le nombre est <0


Complément à 2 (C2) de 1111111 : -0000001  N=-1

10110110 : Le 8ème bit est 1 donc le nombre est <0


Complément à 2 de 0110110 : -1001010  N=-74

Cours
ANNEXE 2 12
Introduction à la programmation Python
Système de numération (suite) Révision S1

Exercice 3 :
2. N1=(-1)10 et N2=(-74)10.
a. Calculer en binaire en complément à deux, sur un octet, l’opération d’addition N1+N2
b. Indiquer s’il y a une retenue et un dépassement tout en justifiant vos réponses.
c. Calculer la valeur décimale du résultat binaire trouvé.
Soit R le résultat de l’addition N1 +N2 :
C2(R)=10110101  C2(C2) : 01001011  R=(-75)10

Cours
ANNEXE 2 13
Introduction à la programmation Python
Système de numération (suite) Révision S1

Exercice 3 :
3. Soit le nombre entier négatif suivant : -(80)10.
a) On souhaite le coder sur 8 bits signés en complément à deux.
Donnez sa représentation binaire et puis sa représentation hexadécimale.
b) On souhaite le coder sur 16 bits signés en complément à deux.
Donnez sa représentation binaire et puis sa représentation hexadécimale.

Soit A = 8010 = 10100002


a. Sur 8 bits A = 010100002
C2(A) = 101100002 = B016

b. Sur 16 bits A = 00000000010100002


C2(A) = 11111111101100002 = FFB016

Cours
ANNEXE 2 14
Introduction à la programmation Python
Système de numération Révision S1

Exercice 4 :
Soient les 2 nombres codés suivant la norme IEEE 754 simple
précision et représentés en Hexadécimal 3EE00000 et 3D800000.
1- Calculer les valeurs décimales correspondantes.
2- Calculer la somme des deux nombres décimaux trouvés.
3- Donnez la représentation binaire sous forme IEEE 754 simple
précision de la somme calculée.
4- En déduire sa représentation hexadécimale.

Cours
ANNEXE 2 15
Introduction à la programmation Python
Système de numération (suite) Révision S1

Exercice 4 :
A = 3EE00000 et B = 3D800000
NB. A et B codés suivant la norme IEEE754 (32bit), représentés en base 16.
1. Calculer les valeurs décimales correspondantes

A = 3EE00000
• Signe = 0  A >0
• Eb=(01111101)2 = (125)10
donc E = Eb - 127 = -2
• A = 1,11.2-2
= 0,0111
= (0,4375)10
Cours
ANNEXE 2 16
Introduction à la programmation Python
Système de numération (suite) Révision S1

Exercice 4 :
A = 3EE00000 et B = 3D800000
NB. A et B codés suivant la norme IEEE754 (32bit), représentés en base 16.
1. Calculer les valeurs décimales correspondantes

B = 3D800000
• Signe = 0  A >0
• Eb = (01111011)2 = (123)10
donc E = Eb - 127 = -4
• B = 1,0.2-4
= 0,0001
= (0,0625)10
Cours
ANNEXE 2 17
Introduction à la programmation Python
Système de numération (suite) Révision S1

Exercice 4 :
2- Calculer la somme des deux nombres décimaux trouvés.
R = A + B = 0.4375 + 0.0625 = 0.5
3- Donnez la représentation binaire sous forme IEEE 754 simple précision de la somme
calculée.
R = (0.5)10 • Eb = 127 - 1 • Signe >0
= (0.1)2 = (126)10
= 1.0*2-1 = (01111110)2

4- En déduire sa représentation hexadécimale.

Cours
ANNEXE 2 18
Introduction à la programmation Python
Système de numération Révision S1

Exercice 5 :
Dans cet exercice on utilisera la représentation en complément à 2.
1- Quelles sont les valeurs minimales et maximales qu'on peut représenter
sur 1 octet.
2- Donner la valeur décimale des mots binaires : 11001101 et 01001101
3- Soit les 2 entiers relatifs a = (-15)10 et b= (125)10
a- Donner le codage de ces nombres sur un octet.
b- Effectuer en binaire l’opération (a+b) et justifier s’il y a une retenue ou
un dépassement.

Cours
ANNEXE 2 19
Introduction à la programmation Python
Système de numération (suite) Révision S1

Exercice 5 :
1-Les valeurs minimales et maximales qu'on peut représenter sur 1 octet.
Valeur minimale = -28-1 = -128 et Valeur maximale = 28-1 – 1 = 127
2-La valeur décimale des mots binaires 11001101 et 01001101 :
• C2(1001101) = 0110011 = -(1+2+16+32) = (-51)10
• 01001101 = (77)10
3-Soit les 2 entiers relatifs a = (-15)10 et b= (125)10
a- le codage des nombres sur un octet.
a = (11110001)2 et b = (01111101)2

b- Calcul en binaire l’opération (a+b)

Cours
ANNEXE 2 20
Introduction à la programmation Python
Système de numération Révision S1

Exercice 6 :
Codage des réels suivant la norme IEEE 754 simple précision (32 bits)

1- Quelle est la valeur décimale de la représentation binaire suivante, codée en


virgule flottante : 0100 0000 1111 0000 0000 0000 0000 0000

2- Quel est la représentation binaire de la valeur décimale suivante : -11.0625.

En déduire la représentation hexadécimale et octale.

Cours
ANNEXE 2 21
Introduction à la programmation Python
Système de numération (suite) Révision S1

Exercice 6 :
1- Quelle est la valeur décimale de la représentation binaire suivante, codée
en virgule flottante : soit A = 0100 0000 1111 0000 0000 0000 0000 0000
• S = 0  A est >0
• Eb = 10000001 = 129
• E = Eb - 127 = 129 - 127 = 2
• M = 1,111 * 22 = 111,1 = (7,5)10

2- la représentation binaire de la valeur décimale : -11.0625.


1100 0001 0011 0001 0000 0000 0000 0000
 la représentation hexadécimale : (C1310000)16
 la représentation octale : (30114200000)8
Cours
ANNEXE 2 22
Introduction à la programmation Python
Partie 2 :

Programmation python, conteneurs

Cours
ANNEXE 2 23
Introduction à la programmation Python
Programmation python, conteneurs Révision S1

Exercice 1 :
Soit la suite Un définie par :

Cette suite aboutit au cycle redondant formé par les trois termes 4,2,1 à partir d’un certain rang.
Exemple :
Pour U0=3 : U1=10, U2=5, U3=16, U4=8, U5=4, U6=2, U7=1, U8=4, U9=2, U10=1.
Donc la suite U entre dans un cycle redondant 4,2,1 à partir du 6ème terme (rang=6).
Ecrire un programme Python permettant de :
- Saisir un entier 3≤U0≤40
- Déterminer le rang à partir duquel la suite aboutit au cycle redondant 4,2 et 1.
Cours
ANNEXE 2 24
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 1 :

Cours
ANNEXE 2 25
Introduction à la programmation Python
Programmation python, conteneurs Révision S1

Exercice 2 :

Cours
ANNEXE 2 26
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1
Exercice 2 :
Algorithme Calcul
Constante eps = 0.000001
Variable A, S, x : réel ; n : entier
Début
Répéter
Écrire(“ donner un réel compris entre -1 et 1“)
Lire(x)
Jusqu’à Abs(x) < 1
A←1;S←1;n←0
Répéter
A ← - A*x*(2*n+1)/(2*n+2)
S←S+A
n←n+1
Jusqu’à Abs(A) < eps
Écrire(“ la valeur de y est :“, S)
Fin
Cours
ANNEXE 2 27
Introduction à la programmation Python
Programmation python, conteneurs Révision S1

Exercice 3 :
Ecrire un algorithme
permettant :
- La saisie d’une
valeur x introduite au
clavier.
- Le calcul de la
probabilité P,
sachant que le calcul
est arrêté lorsque le
dernier terme de la
série est inférieur à
une précision eps =
0.000001.
- L’affichage de la
valeur de P.
Cours
ANNEXE 2 28
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 3 :
Algorithme CalculProba
Constante eps=0.000001
Pi=3.14
Variable A, S, x : réel
n : entier
Début
Ecrire(« donner x »)
Lire(x)
A ← -SQR(x)/2 ; S← x ;
n← 0 ;t←1
Répéter
n← n+1
t← t*A/ n
S ← S +t*x/(2*n+1)
jusqu'à t*x/(2*n+1)<eps
Ecrire(‘’la valeur approximative de P =’’ , S/sqrt(2*Pi))
Fin

Cours
ANNEXE 2 29
Introduction à la programmation Python
Programmation python, conteneurs Révision S1

Exercice 4 :
Ecrire un programme Python qui choisit un nombre entier au hasard entre 0 et 1000 et qui
demande à l’utilisateur de le deviner. A chaque proposition faite par le joueur, le programme
répondra en situant le nombre proposé par rapport à celui à deviner (plus grand, plus petit ou gagné).
Le jeu s’arrête lorsque le joueur devine le nombre choisi, ou lorsqu’il dépasse un nombre maximal de
coups (Dans notre cas le nombre maximal de coups est égale à 10).
NB : La méthode randint(inf, sup) du module random retourne un entier aléatoire compris entre inf et sup.
Exemple
Devinez le nombre que j’ai choisi (entre 1 et 1000)
Votre proposition : 500
-------trop grand
Votre proposition : 100
-------trop petit
Votre proposition : 200
-------trop grand
Votre proposition : 180
-------trop petit
Votre proposition : 185
*************vous avez gagné en 5 coups

Cours
ANNEXE 2 30
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 4 :
from random import randrange
aleat=randrange(0,1000)
coups=0
print(" Deviner le nombre que j’ai choisi (entre 1 et 1000)")
trouv=False
while trouv ==False and coups<10:
proposition=int (input(" votre proposition : "))
if proposition <aleat:
print("---------trop petite")
elif proposition >aleat:
print("---------trop grande")
else:
trouv = True
print("**** vous avez gagné en ", coups,"coups\n")
coups+=1
if coups==10:
print("*****vous avez perdu*****") Cours
ANNEXE 2 31
Introduction à la programmation Python
Programmation python, conteneurs Révision S1

Exercice 5 :
Il existe une méthode de détermination de nombres premiers connue sous le nom de « Crible
d’Eratosthène ». Elle permet d’obtenir tous les nombres premiers inférieurs à une valeur donnée n.
La méthode (manuelle) consiste à dresser une liste des nombres considérés (de 1 à n) et à y
supprimer tous les nombres multiples d’autres entiers (de tels nombres sont nécessairement non
premiers). Plus précisément, on procède ainsi :
1-On supprime le 1 (qui, par définition, n’est pas un nombre premier).
2-On recherche, à partir du dernier nombre premier considéré le premier nombre non supprimé qui
devient à son tour, le dernier nombre premier à considérer et on supprime tous ses multiples.
3-On répète le point 2 jusqu’à ce que le nombre premier considéré soit supérieur à la racine carrée de
n. On peut alors montrer que tous les nombres non premiers ont été supprimés de la liste.
Ecrire un programme Python basé sur cette méthode qui recherche tous les nombres premiers
compris entre 1 et n (la valeur de n étant donnée par l’utilisateur).
NB : • La méthode sqrt(n) du module math retourne la racine carrée de n
• La méthode del L[i] permet de supprimer l’éliment i de la liste L.
Cours
ANNEXE 2 32
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 5 :
from math import sqrt
n= int( input('donner un nembre entier: '))
liste= list(range(1,n+1))
del liste[0]
for i in range (len (liste)):
if liste[i]> int( sqrt(n)):
break
for j in range (i+1, len(liste)):
if j< len(liste) and liste[j]%liste[i]==0:
del liste[j]
print( liste)

Cours
ANNEXE 2 33
Introduction à la programmation Python
Programmation python, conteneurs Révision S1

Exercice 6 :
Principe :
-Si le rang d’une lettre dans l’alphabet est impair, on la code par la lettre qui se trouve à 4 lettres plus
loin dans l’alphabet. Par exemple, la lettre J sera codée par la lettre N.
-Si le rang d’une lettre dans l’alphabet est pair, on la code par la lettre qui se trouve 6 lettres plus loin
dans l’alphabet. Par exemple, la lettre A sera codée par la lettre G.
NB : • Le rang de la lettre A est 0.
• Il faut rester dans l’alphabet : la lettre X sera codée par la lettre B.
Ecrire un programme Python qui permet de coder un mot selon la méthode déjà proposée ci-
dessus. Pour cela, on vous demande de :
-créer la chaine ALPHABET qui contient les 26 lettres de l’alphabet en majuscule.
ALPHABET ='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-demander à l’utilisateur de donner un mot composé uniquement de lettres en majuscule (vérifier qu’il
a bien respecté la consigne sinon il doit refaire la saisie).
-créer et afficher le mot crypté (utiliser la chaine ALPHABET).
Cours
ANNEXE 2 34
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 6 :
Alphabet='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
while True:
correct= False
while not correct:
mot= input('Donner le mot à crypter :')
correct= True
for c in mot:
if c not in Alphabet:
print( " Le mot ne doit contenir que des lettres en majuscule")
correct= False
break

Cours
ANNEXE 2 35
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 6 :
motcryp=""
for c in mot:
for i in range (len (Alphabet)):
if c ==Alphabet[i]:
if i %2==1:
icry=i+4
if icry>25:
icry=icry-26
else :
icry=i+6
if icry>25:
icry=icry-26
motcryp=motcryp+Alphabet[icry]
print ('Le code de',mot,' est', motcryp)
Cours
ANNEXE 2 36
Introduction à la programmation Python
Programmation python, conteneurs Révision S1
Exercice 7 :
Soit L1 une liste de taille N (0<N<=50) dont les éléments sont des entiers non nuls triés dans l’ordre
décroissant et L2 une liste de la même taille N contenant des éléments dont la valeur ne peut être
que 0 ou 1.
La compression de L1 par L2 donne une liste C.
La liste C est remplie par les éléments de la liste L1. Un élément i de la liste L1 est ajouté à la liste C
à condition que L2[i]=1.
Les éléments apparaissent dans le même ordre dans les deux listes L1 et C (voir l’exemple).
Exemple :
Soient L1 et L2 deux listes initiales :
L1=[89,47,25,9,4,2,-2]
L2=[0,1,1,0,1,0,1]
La liste C résultat de compression de la liste L1 par L2 est la suivante :
C =[47,25,4,-2]
Ecrire un programme python permettant de :
• Saisir N, la liste L1 et la liste L2 (faire le contrôle de saisie nécessaire).
• Remplir la liste C.
• Afficher par ordre croissant la liste C.
Cours
ANNEXE 2 37
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1
Exercice 7 :
#Saisir N
while(True):
N=int(input("saisir la taille de L1 et L2"))
if 0<N<=50:
break
#Saisir la liste L1
# 1ère solution # 2ème solution
L1=[ ] L1=[ ]
for i in range(N): x=int(input("Saisir le premier élément de L1"))
while(True): L1.append(x)
x=int(input("Donner l'élément de L1")) for i in range(1,N):
if x!=0: while(True):
break y=int(input("Donner un élément de L1"))
L1.append(x) if y<L1[i-1]:
L1.sort(reverse=True) break
L1.append(y)
Cours
ANNEXE 2 38
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 7 :

#Saisir la liste L2
# 1 ère solution # 2ème solution
L2=[ ] L2=[ ]
for i in range(N): x=int(input("Saisir le premier élément de L2"))
while(True): L2.append(x)
x=int(input("saisir un élement de L2 = 0 ou for i in range(1,N):
1")) while(True):
if x==0 or x==1: y=int(input("Donner un élément de L2"))
break if y<L2[i-1]:
L2.append(x) break
L2.append(y)

Cours
ANNEXE 2 39
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 7 :
#Remplir la liste C (2 points)
C=[] # 2ème solution
# 1ère solution for i in range(N):
for e1,e2 in zip(L1,L2): if L2[i]==1:
if e2==1: C.append(L1[i])
C.append(e1)

# Afficher par ordre croissant la liste C (1 point)


print(C.sort())

Cours
ANNEXE 2 40
Introduction à la programmation Python
Programmation python, conteneurs Révision S1
Exercice 8 :
Ecrire un programme python qui permet de :
1. Saisir une chaine correspondante au mot de passe
2. Vérifier si la chaine ne contient pas des espaces, si la chaine contient des espaces on doit les
supprimer.
3. Calculer le nombre de caractères minuscules Nb_min.
4. Calculer le nombre de caractères majuscules Nb_max.
5. Calculer le nombre de caractères non alphabétiques Nb_NonAlph.
6. Calculer longueur de la plus longue séquence de lettres majuscules Long_Maj.
7. Calculer la longueur de la plus longue séquence de lettres minuscules Long_Min.
8. Calculer la somme des bonus, la somme des pénalités et le score de mot de passe sachant que :
le score = la somme des bonus – la somme des pénalités.
9. Afficher la force du mot de passe saisi selon la valeur du score.

Cours
ANNEXE 2 41
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 8 :

#1.Saisir une chaine correspondante au mot de passe


pwd=input("Saisir mot de passe: ")
#2.Vérifier si la chaine ne contient pas des espaces, si la chaine contient des
espaces on doit les supprimer.
#1ère solution #2ème solution #3ème solution
ch="" if " " in pwd: if " " in pwd:
for c in pwd: ch="" pwd=pwd.replace(" ","")
if c != " ": for c in pwd:
ch=ch+c if c != " ":
pwd=ch ch="".join([ch,c])
pwd=ch

Cours
ANNEXE 2 42
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 8 :
#3. Calculer le nombre de caractères minuscules Nb_min
Nb_Min=0
for c in pwd:
if 'a'<=c<='z':
Nb_Min+=1
print("Nb_Min=",Nb_Min)

#4. Calculer le nombre de caractères majuscules Nb_max


Nb_Max=0
for c in pwd:
if 'A'<=c<='Z':
Nb_Max+=1
print("Nb_Max=",Nb_Max)

Cours
ANNEXE 2 43
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 8 :
#5. Calculer le nombre de caractères non alphabétiques Nb_NonAlph.
Nb_NonAlph=len(pwd)-Nb_Min-Nb_Max
print("Nb_NonAlph=",Nb_NonAlph)

#6. Calculer longueur de la plus longue séquence de lettres majuscules Long_Maj.


Long_Maj=0
s=0
i=0
while i<len(pwd):
if 'A'<= pwd[i] <= 'Z':
s+=1
else:
if s>Long_Maj:
Long_Maj=s
s=0
i+=1
print("Long_Maj=",Long_Maj)
Cours
ANNEXE 2 44
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 8 :
#7 Calculer la longueur de la plus longue séquence de lettres minuscules Long_Min
Long_Min=0
s=0
i=0
while i<len(pwd):
if 'a'<= pwd[i] <= 'z':
s+=1
else:
if s>Long_Min:
Long_Min=s
s=0
i+=1
print("Long_Min=",Long_Min)

Cours
ANNEXE 2 45
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 8 :
#8 Calculer le score = la somme des bonus – la somme des pénalités
bonus=len(pwd)*4 + (len(pwd)-Nb_Max)*2 + (len(pwd)-Nb_Min)*3 + Nb_NonAlph*5
print("bonus=",bonus)

penalite=Long_Min*2 + Long_Maj*3
Score=bonus-penalite

#9. Afficher la force du mot de passe saisi selon la valeur du score


if Score<20:
print("Trés faile")
elif Score<40:
print("Faile")
elif Score<80:
print("Fort")
else:
print("Trés Fort")

Cours
ANNEXE 2 46
Introduction à la programmation Python
Programmation python, conteneurs Révision S1
Exercice 9 :
Ecrire un script python qui permet de :
1. Créer le dictionnaire D_Famille = {’eve’: [’tom’, ’lea’, ’luc’, ’kim’ ],’tom’: [’isa’, ’bob’],’lea’: [’ali’],’bob’:
[’bea’,’tim’ ],’luc’: [’sam’, ’jon’, ’lou’ ],’sam’: [’ana’, ’guy’ ],’guy’: [’ben’ ]}
2. Saisir une chaîne de caractères p, puis afficher les prénoms des enfants de p (si elle existe dans
le dictionnaire). Le message « p n’est pas une clé du dictionnaire » sera affiché dans le cas où p n’a
pas d’enfants.
Exemple d’affichage :
L’ensemble des enfants de ’eve’ sont ’kim’, ’lea’, ’tom’ et ’luc’
3. Saisir une chaîne de caractères x, puis afficher les petits enfants de x (si x a des petits
d’enfants). Le message « x n’à pas de petits-enfants » sera affiché dans le cas où x n’a pas de petits-
enfants.
Remarque : les petits-enfants de x sont les enfants des enfants de x.
Exemple d’Affichage :
Les petits enfants de ‘eve’ sont ’lou’, ’isa’, ’bob’, ’ali’, ’jon’ et ’sam’

Cours
ANNEXE 2 47
Introduction à la programmation Python
Programmation python, conteneurs Révision S1
Exercice 9 :
4. Saisir une chaîne de caractères y, puis afficher les parents de y (p est un parent de y
si y est un enfant de p). Si y n’a pas de parent on doit afficher le message « y n’a pas de
parent ».
Exemple d'affichage :
Le parent de tom est eve.
5. Soit l’ensemble X ={’tom’, ’lea’}. Afficher l’ensemble des prénoms de leurs enfants.
Exemple d’affichage :
Les enfants de {‘tom’,’lea’} sont : {’isa’, bob’,’ali’}

Cours
ANNEXE 2 48
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 9 :
#1. Créer le dictionnaire D_Famille .
D_Famille = {’eve’: [’tom’, ’lea’, ’luc’, ’kim’ ],’tom’: [’isa’, ’bob’],’lea’: [’ali’],’bob’: [’bea’,’tim’
],’luc’: [’sam’, ’jon’, ’lou’ ],’sam’: [’ana’, ’guy’ ],’guy’: [’ben’ ]}

#2. Saisir une chaîne de caractères p, puis afficher les prénoms des enfants de p
P = input("saisir un prenom :\n")
if p in D_Famille:
print("l'ensembe des enfants de",p,"est\n",D_Famille[p])
else:
print(p," n’est pas une clé du dictionnaire D_Famille\n")

Cours
ANNEXE 2 49
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 9 :
#3 Saisir une chaîne de caractères x, puis afficher les petits enfants de x
x = input("saisir un prenom d'un grand pere:\n")
test= True if x in D_Famille.keys():
if x in D_Famille: L1=[ D_Famille[x]]
for k in D_Famille[x]: else :
if k in D_Famille: print(x, " n'a pas d’enfant ")
print("Les petits enfants de ",x,"sont", for i in range L1:
D_Famille[k]) if L1[i] in D_Famille.keys():
test= False print(D_Famille[L1[i]])
if test:
print(x, "n'a pas de petits-enfant")

Cours
ANNEXE 2 50
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 9 :
#4. Saisir une chaîne de caractères y, puis #5.Soit l’ensemble
afficher les parents de y X={’tom’,’lea’}afficher l’ensemble des
prénoms de leurs enfants
y = input("saisir un prenom d'un enfant:\n")
test= True X={'tom','lea'}
for k in D_Famille: e=set()
if y in D_Famille[k]: for x in X:
print("le parent de",y,"est ", k) e=e|D_Famille[x]
test= False print("Les enfants de",X,"sont\n",e)
break
if test:
print(y, "n'a pas de parent")

Cours
ANNEXE 2 51
Introduction à la programmation Python
Programmation python, conteneurs Révision S1
Exercice 10 :
Youssef dispose de N cartes, sur chaque carte est écrit soit le chiffre 0, soit le chiffre 5.
Youssef peut choisir plusieurs cartes et les mettre dans une ligne de sorte à obtenir un
certain nombre.
Votre mission est d’écrire un programme Python pour aider Youssef à trouver le plus
grand nombre multiple de 90 qu’il peut avoir à partir des cartes qu'il dispose sachant qu’il
n'a pas besoin d'utiliser toutes les cartes. Vous supposez que les cartes sont placées dans
une liste (utiliser la liste sans faire la saisie) à N valeurs, lstCartes=[a1,…,aN] avec les ai
{0,5}. Si vous ne pouvez pas avoir un nombre qui est multiple de 90 à partir des cartes
qui sont à la disposition de Youssef, alors afficher -1.
Exemples :
1. Si lstCartes=[5, 0, 5, 0], alors votre programme doit afficher 0 qui est le seul multiple de 90 que
vous pouvez avoir à partir de lstCartes.
2. Si lstCartes=[5,0, 5, 5, 5, 5, 5, 5, 5,0, 5, 5], alors votre programme doit afficher 55555555500 qui
représente le plus grand multiple de 90 que vous pouvez avoir à partir de lstCartes.

Cours
ANNEXE 2 52
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 10 :
nbr0 =0
nbr5 =0
for x in lstCartes :
if x ==0: nbr0 +=1
else : nbr5 +=1
if nbr0 ==0: print ( -1)
else:
b= nbr5 //9
s=0
for i in range (b *9):
s=s *10+5
for i in range ( nbr0 ):
s=s*10
# ou bien
# s= int (’5’*b*9+ ’0 ’* nbr0 )
print (s)
Cours
ANNEXE 2 53
Introduction à la programmation Python
Programmation python, conteneurs Révision S1
Exercice 11 :

Cours
ANNEXE 2 54
Introduction à la programmation Python
Programmation python, conteneurs (suite) Révision S1

Exercice 11 :
#1. Saisir un entier N tel que 10<=N<=105
repeter
Lire (N)
Jusqu ’a N >=10 et N <=100000
#2.Calculer et afficher tous les ‘Stepping Number’ de l’intervalle [10,N].
pour i de 10 à N faire
x<--i
r<--x mod 10
x<--x div 10
b<-- vrai
Tant que b et x <> 0 faire
r1 <--r
r<-- x mod 10
x<-- x div 10
b<-- abs (r1 -r )=1
fin tant que
si b alors
ecrire (i)
fin si
fin pour
Cours
ANNEXE 2 55
Introduction à la programmation Python
Partie 3 :

Complexité algorithmique

Cours
ANNEXE 2 56
Introduction à la programmation Python
Complexité algorithmique Révision S1
Exercice 1 :
Donner les complexités des algorithmes suivants dans le pire des cas.
Algorithme1 Algorithme2 Algorithme3
Variable : s, n : entier Variable: n,x,i,j : entier Variable: n, i, j : entier
Début Début Début
s0 x=0 Pour i de 1 à n-2 faire
lire(n) Lire(n) Pour j de i+2 à n faire
Tant que n>0 faire i=n Ecrire (i*j)
nn div 2 Tant que i>1 faire Fin faire
ss+1 Pour j de 1 à n faire Fin faire
Fin tant que x=x+1 Fin
Fin Fin faire
i=i div 2
Fin Tant que
Fin
Cours
ANNEXE 2 57
Introduction à la programmation Python
Complexité algorithmique (suite) Révision S1

Exercice 1 :
Algorithme1 Algorithme2 Algorithme3
Variable : s, n : entier Variable :n,x,i,j : entier Variable :n, i, j : entier
Début Début Début
s0 x=0 Pour i de 1 à n-2 faire
lire(n) Lire(n) Pour j de i+2 à n faire
Tant que n>0 faire i=n Ecrire (i*j)
nn div 2 Tant que i>1 faire Fin faire
ss+1 Pour j de 1 à n faire Fin faire
Fin tant que x=x+1 Fin
Fin Fin faire
i=i div 2
Fin Tant que
Fin
O(log 2 n ) O(nlog 2 n ) O(n2)

Cours
ANNEXE 2 58
Introduction à la programmation Python
Complexité algorithmique (suite) Révision S1
Exercice 2 :

Calculer les
complexités des
algorithmes suivants
dans le pire des cas ?
Justifier votre
réponse.

Cours
ANNEXE 2 59
Introduction à la programmation Python
Complexité algorithmique (suite) Révision S1

Exercice 2 :

Cours
ANNEXE 2 60
Introduction à la programmation Python
Fin ANNEXE 2

Cours
ANNEXE 2 61
Introduction à la programmation Python

Vous aimerez peut-être aussi