Nom et prénom………………………………………………………………………………………………………………Classe :…………………………

Testez Vos Pré-Acquis

Exercice1 : Pour chacune des séquences, cocher la bonne réponse.
Séquences d’instructions Questions
i0 Pour afficher successivement les valeurs 2,4, 6 et 8,
{A} l’instruction ii+2 doit être ajoutée dans l’emplacement :
Répéter
{B}  A
Ecrire(i)  B
{C}
Jusqu’à i mod 8 = 0  C
n10 Après exécution de cette séquence, les valeurs de i et n
i1 seront :
TantQue (n div i ≠0) Faire
n n div i  i=2  n=0
ii+1  i=3  n=1
Fin TantQue
 i=4  n=5
 i=11  n=10
Fonction Somme (T :tab, a ,b :entier) :Entier Après l’exécution de la fonction et pour a=4 et b=9, l’action
Début SS+T[i] est exécuter un nombre de fois égal à :
S0
Pour i de a à b faire  4
SS+T[i]  5
Fin pour
Retourner S  6
Fin
Procédure Affiche( a,b :entier) Après l’exécution de la procédure, l’instruction Ecrire est
Début exécuter un nombre de fois égal à :
Pour i de 1 à 3 faire
Pour j de 2 à 4 faire  6
aa+1  9
Ecrire(a)
FinPour  12
bb+1
Ecrire(b)
FinPour
Fin
Fonction Premier1 (N :entier) : booléen Quelle(s) est (sont) la (les) fonction(s) qui permet(tent) de
Début vérifier la primalité :
d2
TantQue (d ≤ N div 2) et (N mod d ≠0)  Premier1 seulement
Faire  Premier2 seulement
dd+1
Fin TantQue  Premier1 et Premier2

Fin
Retourner N mod d ≠ 0
 Aucune
Fonction Premier2 (N :entier) : booléen
Quelle est la fonction qui permet de vérifier la primalité d’une
Début
manière optimale.
nb2
Pour i de 2 à N-1 faire  Premier1
Si N mod i = 0 alors
nbnb+1  Premier2
Fin Si
Fin Pour
Retourner Nb=2
Fin

1
Nom et prénom………………………………………………………………………………………………………………Classe :…………………………

Exercice2 :
Un nombre N est dit sociable d’ordre P, lorsqu’il permet de former une Chaine Amiable.
Une chaine amiable est une séquence de P entiers dans laquelle chaque nombre est la somme des diviseurs
propres (sans lui-même) du nombre précédent.
Le premier nombre N de la séquence est dit nombre sociable s’il est égal à la somme de ses diviseurs
propres du dernier nombre de cette séquence.
Exemple :
12496 est un nombre sociable d’ordre 5, les nombres formants la chaine amiable sont :
12496-14288-15472-14536-14264
Nombre de Diviseurs propres Somme des
la diviseurs
séquence
12496 1,2,4,8,11,16,22,44,71,88,142,176,284,568,781,1136,1562,3124,6248 14288
14288 1,2,4,8,16,19,38,47,76,94,152,188,304,376,752,893,1786,3572,7144 15472
15472 1,2,4,8,16,967,1934,3868,7736 14536
14536 1,2,4,8,23,46,79,92,158,184,316,632,1817,3634,7268 14264
14264 1,2,4,8,1783,3566,7132 12496
1) Ecrire un module appelé SomDiviseur qui permet de calculer la somme des diviseurs d’un
nombre m.
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
2) Ecrire un module appelé Sociable qui permet de faire l’appel au module SomDiviseur pour
afficher :
 La liste des nombres formants la chaine amiable ainsi son ordre si un N est sociable, sinon.
 N est non sociable si l’ordre P dépasse 10.
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
3) Ecrire l’algorithme du programme principal qui permet de saisir une chaine de caractère
purement numérique puis de déterminer et afficher si le nombre est amiable ou non.
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

2
Nom et prénom………………………………………………………………………………………………………………Classe :…………………………

Problème :
La transformation de SYRACUSE
Il s’agit d’une séquence d’opérations sur un nombre entier positif qui ramène toujours au nombre 1, selon
l’approche suivante :
 si le nombre N est impair on le gonfle c-à-d : N=3N+1
 s'il est pair on l'amorti c-à-d : N=N div 2
Selon la règle suivante :
Au cours des itérations, le nombre va osciller en croissant et décroissant, mais il finira toujours par la
valeur 1. Ainsi on peut calculer le temps de vol d’un nombre (le nombre des nombres jusqu’à avoir
1) après la transformation de SYRACUSE :
 20 : [10, 5, 16, 8, 4, 2, 1] : Temps du vol de 20 est 7
 13 : [40, 20, 10, 5, 16, 8, 4, 2, 1] : Temps du vol de 13 est 9
 22 : [22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1] : Temps du vol de 22 est 15
 33 : [40, 20, 10, 5, 16, 8, 4, 2, 1] : Temps du vol de 22 est 9

Exemple :
T 11 28 16 13 20 30
0 1 2 3 4 5
Après le calcul du temps du vol :
TV 14 18 4 9 7 18
0 1 2 3 4 5
Les nombres sont :
28 : [14, 7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]
30 : [15, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1]

Travail demandé : En utilisant la modularité, écrire un programme qui permet de :

 Remplir un tableau T avec N nombres entiers positifs à deux chiffres, avec 5< N <20.
 Calculer le temps de vol de chaque nombre : le nombre des nombres au cours de l’oscillation.
 Afficher le(s) nombre(s) qui a (ont) le maximum du temps du vol ainsi sa(leurs) suite.

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

3
Nom et prénom………………………………………………………………………………………………………………Classe :…………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

4
 Rappels sur les éléments de base

Structures CONDITIONNELLES « SI...alors… SINON... »

Une condition est une comparaison entre :
 une variable et une valeur
 ou entre deux variables
Algo Python Description Algo Python Description

x<y x …… y x inférieur à y x>y x …... y x supérieur à y

x=y x …… y x égal à y x≠y x ……y x différent de y

x≤y x …….y x inférieur ou égal à y x≥y x ……y x supérieur ou égal à y

in Exemple : ………………………………………………………
……….
in range Exemple : ………………………………………………………

Les opérateurs appliqués avec le type booléen

Opération Algorithme Python Table de vérité

Négation non not A B NOT A A AND B A OR B
Disjonction et and True True False True True
Conjonction ou or True False False False True
False True True False True
False False True False False

Les Structures itératives (les boucles)

1. La boucle complète Pour … Faire :

En Algorithme En python
Pour i de vi à vf [pas=valeur_pas] faire
instruction 1 for i in range(vi, vf+1) :
instruction 2 instruction 1
……. instruction 2
instruction n …….
Fin pour instruction n
Remarque: Nombre répétitions = |vf-vi|+1
Exemple1: Exécution:
Ch’’Bac2024’’ ch=‘’Bac2024’’
Pour i de 0 à long(ch)-1 [pas=1] Faire for i in range(0, len(ch )):
Ecrire(Ch[i]) print(ch[i])
Fin pour
Exemple2: Exécution:
Pour i de 0 à 3 [pas=1] Faire for i in range( 4) :
Ecrire(i) print(i)
Fin pour

5
 Rappels sur les éléments de base
Exemple3 : Exécution:
Pour i de 6 à 3 Faire [pas=-1] for i in range(6,2,-1) :
Ecrire(i) print(i)
Fin pour

Exemple4: Exécution:
Pour i de 0 à 9 [pas=2] Faire for i in range(0,10,2) :
Ecrire(i) print(i, end=‘** ‘)
Fin pour

2. La boucle à condition d’arrêt Tant que…. faire:

En Algorithme En python
…….. …
Tant que « condition » faire while « condition » :
instruction 1 instruction 1
instruction 2 instruction 2
……. …….
instruction n instruction n
Fin Tant que
Remarque1: la boucle s’arrête lorsque la condition donne Faux
Exemple: i=10 Exécution:
i10 while i >=5 :
Tant que i >=5 faire print(i)
Ecrire(i) i=i-1
ii -1
Fin Tant que
Remarque2: Attention à la boucle infinie

3. La boucle à condition d’arrêt Répéter …Jusqu’à:

En Algorithme En python
…….. ……
Répéter while not(condition):
instruction 1 instruction1
instruction 2 instruction2
…… …..
instruction n instruction n
Jusqu’à condition
Remarque: la boucle s’arrête lorsque la condition donne vrai
Exemple: i=10 Exécution:
i10 while not(i <5) :
Répéter print(i)
Ecrire(i) i=i-1
ii -1
Jusqu’à i<5 i=10
while i >=5 :
print(i)
i=i -1
Remarque: Attention à la boucle infinie

6
 Rappels sur les éléments de base

Les fonctions prédéfinies : entier/réel

Algorithme Python Rôles Exemples

Z=round(2.5)
Retourne l’entier le plus # On affecte à Z la valeur ….
Arrondi (x) round(x)
proche de la valeur de x. Z=round(2.51)
# On affecte à Z la valeur ….
Retourne la racine carrée Z=sqrt(16)
RacineCarré(x) sqrt(x)
d’un nombre x positif. # On affecte à Z le réel ….
from random import randint
Retourne un entier aléatoire Z=randint(0,10)
Aléa (vi, vf) randint(vi,vf)
de l’intervalle [vi, vf]. # On affecte à Z une valeur
………………………………
Z=int(3.14)
int(x)
Ou bien
ou bien Retourne la partie entière de
Ent (x) from math import *
trunc(x) du x.
Z=trunc(3.14)
module math
# On affecte à Z l’entier …..
Z= abs(-2)
Retourne la valeur absolue # On affecte à Z l’entier ….
Abs(x) Abs(x)
de x Z= abs(-2.3)
# On affecte à Z le réel ….

En python on trouve des fonctions prédéfinies dont certaines appartiennent à des modules
comme le module random, turtle, numpy….

1ère Méthode 2ème méthode 3ème méthode

import math from math import * from math import sqrt
y=math.sqrt(x) y=sqrt(x) y=sqrt(x)

Les fonctions et les opérateurs appliquées sur le type chaîne de caractère :

Opérateurs Exemples Explications

Ch ‘Bon’+’jour’ La concaténation de deux

+
Ch contient ………………. chaines
Ch ‘Ha’*3
* La duplication d'une chaine
Ch contient ……………….
x ‘B’ in ‘Bonbon’ Test d'appartenance renvoie
in / not in
x contient ………………. True ou False
X  ‘A’>’a’ Opérateurs de comparaisons
>,<,<=,>=,!=, ==
X contient ………………. renvoie True ou False

7
 Rappels sur les éléments de base

Algorithme Rôles Exemples

Retourne un ENTIER représentant la L Long ( "Bac 2024" )

Long ( Ch )
longueur de la chaîne Ch. L contient ……

PPos ("RO" , "PROF_PRO" )

Retourne la première position de la
P contient ……
Pos( Ch1 , Ch2 ) chaîne ch1 dans la chaîne ch2. Et -1
PPos ("ro" , "PROF_PRO" )
si Ch1 est inexistante
P contient ……

N123
Retourne la conversion d’un nombre Chconvch(N)
Convch (x)
x en une chaîne de caractères. Ch contient ……..

Retourne Vrai si la chaîne ch est b Estnum("2022" )

Estnum (Ch) convertible en une valeur numérique b contient ……..
entière , elle retourne Faux sinon.

Ch"123.5"
Retourne la conversion d’une chaîne
xvaleur(Ch)
Valeur (Ch) ch en une valeur numérique, si c’est
X contient ………….
possible.

Retourne une partie de la chaîne ch ChSous_chaine("Devoirs" ,2,6)

Sous_chaine (Ch, d, f) à partir de la position d jusqu’à la Ch contient ……………….
position f (f exclue).

Efface des caractères de la chaîne ch ChEffacer(("Devoirs" ,2,6)

Effacer (Ch, d, f) à partir de la position d jusqu’à la Ch contient ……………….
position f (f exclue).

ChMajus("Bonjour le Monde." )
Convertit la chaîne Ch en
Majus (Ch) Ch contient "BONJOUR LE MONDE."
majuscules.

Non mutabilité des strings EN PYTHON

En Python, les chaines de caractères sont non mutables (ou immuables).
Exemple :
>>> ch = "bonjour"
>>> ch[0] = "d"
TypeError: 'str' object does not support item assignment

 Si on veut remplacer le 1èr caractère de Ch par ‘d’

En algorithme En python
ch[0] ’d’ ch = ‘d’+Ch[1:]

8
 Rappels sur les éléments de base

L y c é e M e g d i c h S f a x
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

Syntaxe Exemples Explications

Ch[i] Ch[0] est ………………. Accès au caractère d’indice i
Ch[len(Ch)-1] Ch[len(Ch)-1] est ………… Accès au dernier caractère

Ch[i:j] ou Ch[6:13] est ……………… Extraire la sous-chaîne de l’élément i (inclus) à

Ch[i:j:1] l’élément j (exclu) . Le pas par défaut égal à 1
Ch[i:j:k] Ch[6:13:2] est ……………… Extraire la sous-chaîne de l’élément i (inclus) à
l’élément j (exclu) . Le pas égal à k
Ch[i:] Ch[14:] est ……………… Extraire la sous-chaîne depuis l’élément i (inclus)
jusqu'à la fin de la chaine.
Ch[:j] Ch[:5] est ………………. Extraire la sous-chaîne de début indice 0 jusqu'à
l'indice j (exclu).
Ch[:] Ch[:] Extraire la sous-chaîne de début jusqu'à la fin de
……………….………………. la chaine

Comment implémenter les méthodes sur les chaines en python ?

Algorithme Python

XPos( Ch1 , Ch2 ) X = Ch2.find( ch1)

Y = Ch.isdecimal()
YEstnum (Ch) Y= Ch.isdigit()
Y= Ch.isnumeric()
Ch = Ch.upper()
Ch Majus (Ch)

Comment implémenter les fonctions sur les chaines en python ?

Algorithme Python

XLong ( Ch ) X = len(ch)

X= int(ch)
XValeur (Ch)
X= float(ch)

ChConvch (x) Ch = str(x)

L ord (c) L = ord(c)

Z  chr(y) Z= chr(y)

9
 Rappels sur les éléments de base

Slicing Python?
Algorithme
ChSous_chaine (Ch, d, f)
Ch Effacer (Ch, d, f)
Python
Ch = Ch[ d : f ]
Ch = Ch[:d]+Ch[f:]

Les opérateurs et les fonctions prédéfinies appliquées avec le type

caractère
Une variable de type caractère aura pour valeur un et un seul caractère, spécifié entre
apostrophes. Tous ces caractères sont ordonnés selon leur code ASCII.

Algo/Python Rôles Exemples

ord(c) Retourne le code ASCII du X’D’
caractère c. Y ord(X)
Y contient ……………..
chr(d) Retourne le caractère dont le X100
code ASCII est d. Y chr(X)
Y contient ……………..
Remarque :
En python une variable de type caractère n’est qu’une chaine de caractère (str) de longueur 1.

10
 Rappels sur les éléments de base

Applications
Exercice1 :
Compléter les affectations suivantes par une valeur ou un opérateur permettant d’obtenir la valeur
booléenne de B voulue.
AFFECTATIONS Valeur de B
B = sqrt(9) == ………………… False
B = randint(0, 4) ……………5 True
B = round(64.5) …………8 == 0 False
B = 47668 % 1000 // 10 == ………… True
B = trunc ( sqrt(100)) !=……………. False
B =( 'A' <= 'a'.upper( )<= 'Z' ) and (1 <= ………<=10) True

Exercice2 :
Compléter dans chaque ligne, la dernière colonne par :
 Une affectation : utiliser toutes les données fournies et la (les) fonction(s) adéquates.
 Le type de chaque résultat.

Données

Résultat Affectation en python

M N X Y

A = ord (M [ len (M) - 1] )

Exemple "NEZ" 90 A est de type entier

B =………………………………..
Ligne1 "Ci" "Sciences" -1 ……………………………………

C =…………………………………
Ligne2 "Année " "2023" 10 …………………………………….

D =……………………………….
Ligne3 "Ramadhan" "Mars" 23 "Ramadhan23Mars" ……………………………………

E =...………………………………
Ligne4 "*Mars2023*" "*MARS2023*" ……………………………………

F =.. ………………………………
Ligne5 "14.25" False ……………………………………

G =..………………………………
Ligne6 "14" "6" 10 30 ……………………………………

H =..………………………………
Ligne7 "Memoire" 2 5 "moi" ……………………………………

L =…………………………………
Ligne8 "60" 5 "A" ……………………………………

11
 Rappels sur les éléments de base

Exercice3 : Soit le TDO suivant :

Objets Type/ Nature
x,y,i,a,b Entier
ch, mot Chaine de caractère
C Caractère
Compléter le tableau ci-après par l’appel d’une fonction prédéfinie de la liste suivante : abs, sous-
chaine, pos, estnum , effacer en spécifiant les paramètres d’appel pour chaque cas.
Séquence algorithmique Appel de la fonction prédéfinie
Si x ≥ 0 alors
Y x
Sinon
Y  -x
Fin si
Ch  ″″
Pour i de a à b-1 faire
Ch  Ch + mot[i]
Fin pour
p  -1
i 0
Répéter
Si ch[i] = c alors
pi
sinon
i i+1
Finsi
Jusqu’à (i>long(ch)-1) ou (p ≠ -1)
Exercice 4 :
Une chaine de caractères ch est dite « distincte » si elle est composée par des caractères différents.
Exemple :
 Ch="BacSvt" est dite distincte, car elle est formée par des caractères différents.
 Ch="BacMath" est dite non distincte, car on a deux fois la lettre a .

Séquence 1 Séquence 2 Séquence 3

Pour i de 0 à long(ch)-1 faire Ok  vrai i0
Si pos(ch[i], ch)=i alors Répéter ok  vrai
Ok  vrai aux  ch[0] Tant que (ok =vrai) et (i<long(ch) ) Faire
Sinon Ch  effacer(ch, 0 , 1) Ok  pos(ch[i], ch) = i
Ok  faux Si pos (aux, ch ) ≠ -1 alors ii+1
Finsi Ok  faux Fin tant que
Fin pour Fin si
Jusqu’à (ok =faux) ou (long(ch) =1)
Questions :
1) Compléter le tableau ci-dessous par la valeur de la variable ok après exécution de chaque
séquence, et ce pour ch="Sweet".
Valeur de la variable ok
Séquence 1
Séquence 2
Séquence 3

12
 Rappels sur les éléments de base

2) Donner le numéro de la ou (les) séquence(s) qui permet(tent) de vérifier si la chaine est

«distincte»……
3) Réécrire l’une des séquences correctes dans un module.
4) Utiliser le module précédent pour saisir une chaine ch distinct ne contenant pas d’espace et
commençant par une lettre majuscule.
5) Implémenter en python ce module.
Exercice 5 :
Un nombre positif X supérieur à 10 est dit « homogène » si tous ces chiffres sont pairs ou impairs.
Exemples :
 1357 est homogène (car ses chiffres sont tous impairs)
 82460 est homogène (car ses chiffres sont tous pairs)
Questions :
1) Compléter l’algorithme d’une fonction « Homogène » permettant de vérifier si l’entier X est
homogène ou non.

Fonction Homogene (X : Entier) : ……………………………………

Début
R  X mod 2
Test  …………….………..
X  X div 10
Répéter
Si X mod 2 ……..… R Alors
Test  Faux
Sinon
…………………………………………
Fin Si
Jusqu'à ……………………………… ou …………………………………
……………………………………………………………………….
Fin
2) Valider chacune des réponses suivantes par «V» si elle est correcte et par «F» sinon.
a) L’objet X déclaré dans l’entête de la fonction est :
 une variable globale
 un paramètre effectif
 un paramètre formel

b) Lequel des appels suivants de cette fonction est incorrect :

 Si Homgene(1357)= Vrai Alors …….
 Homgene(1357)
 Ecrire(Homgene(1357))
3) Ecrire l’algorithme du module permettant d’afficher les entiers homogènes figurant dans un tableau
T (de type TAB) déjà remplit dans le programme principal par N entiers positifs supérieurs à 10. Si
aucun nombre homogène trouvé, afficher le message «Aucun nombre homogène trouvé».

……………………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………….…………..……………
……………………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………….…………..……………

13
 Modularité

Modularité : Fonctions / Procédures

Dans les exercices 1  3, utiliser une procédure qui permet de saisir un nombre supérieur à 10.
Exercice1
Ecrire une fonction qui permet de calculer la somme des chiffres d’un nombre.
Exercice2
Ecrire une fonction qui permet de calculer le factoriel d’un nombre.
Exercice3
Ecrire une fonction qui permet de vérifier que le nombre est parfait ou non.

Dans les exercices 4  5, utiliser une procédure qui permet de saisir A et B deux nombres positifs
et différents.
Exercice4
Ecrire une fonction qui permet de calculer le PGCD de deux nombres.
Exercice5
Ecrire une fonction qui permet de calculer la puissance AB.

………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….

14
 Modularité
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….

15
 Modularité
Dans les exercices 6  9, utiliser une procédure qui permet de saisir une chaine de taille pair et ne
contenant pas d’espace.
Exercice6
Ecrire une fonction qui permet de déterminer l’inverser d’un mot.
Exercice7
Ecrire une fonction qui permet de calculer la somme des chiffres existants dans la chaine.
Exercice8
Ecrire une fonction qui permet de vérifier et d’afficher si la chaine est purement alphabétique.
Exercice9
Ecrire une fonction qui permet de calculer le poids d’un mot, sachant que le poids est la somme des codes
Ascii des voyelles.
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….

16
 Modularité
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….

17
 Modularité
Dans les exercices 10  14, utiliser une procédure qui permet de saisir un tableau de N entiers
positifs avec N>3.
Exercice10
Ecrire une fonction qui permet de calculer la somme de tous les éléments du tableau.
Exercice11
Ecrire une fonction qui permet de calculer la somme des éléments ayant un indice impair.
Exercice12
Ecrire une fonction qui permet de déterminer le maximum d’un tableau.
Exercice13
Ecrire une fonction qui permet de déterminer l’existence d’un nombre donné X dans le tableau.
Exercice14
Ecrire une procédure qui permet de calculer T[i]i pour chaque élément du tableau T et placer le résultat
dans un autre tableau D.
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….

18
 Modularité
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….

19
 Modularité
Dans les exercices 15  16, utiliser une procédure qui permet de saisir un tableau de N mots
majuscules non vides avec N>3.

Exercice15
Ecrire une procédure qui permet placer les chaines symétriques dans un autre tableau D.
Exercice16
Déterminer les modules nécessaires pour chercher et afficher la lettre dont le code ascii est maximal dans
tous les chaines du tableau, puis afficher les mots contenant cette lettre.
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

20
 Modularité
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….

21
 Modularité
Probleme 1 : Cryptage
Une phrase est une chaîne de caractères formée par des mots séparés deux à deux par un seul espace. Une
phrase ne doit pas contenir des espaces superflus (inutiles). En effet, un espace est dit superflus lorsqu’il
se trouve au début ou à la fin d’une phrase ou lorsqu’il est à côté d’un autre.

Une société de télécommunication crypte les messages de ses abonnés à fin qu’elle les sécurise sur ses
réseaux. Pour cela elle veut réaliser une application informatique permettant de réaliser les tâches
suivantes
 Saisir un message sous la forme d’une phrase non vide et sans espaces superflus.
 Entrer au hasard un chiffre entre 0 et 9.
 Transformer les caractères minuscules en majuscules et vice versa.
 Remplacer les caractères non alphabétiques (Sauf les espaces) par le chiffre trouvé au hasard.
 Effacer tous les espaces dans le message.
 Afficher le message crypté.
Exemple :
Message initial : "Bonsoir. Où sont les 7 merveilles ?" et Nombre au hasard est :5

Le programme affichera : Message crypté : bONSOIR5o5SONTLES5MERVEILLES5

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

22
 Modularité
Probleme 2 : Chiffre de chance
Pour chercher le chiffre de chance d'une personne, on procède comme suit :
On additionne les chiffres composants la date de naissance de la personne concernée. Au nombre obtenu,
on refait le même procède jusqu'a ce qu'on obtienne un nombre compose d'un seul chiffre. Ce nombre est
le chiffre de chance.
Exemple :
Soit la date de naissance suivante "29/09/1999"
 On additionne les chiffres de la date de naissance: 2+9+0+9+1+9+9+9= 48
 48 est compose de deux chiffres, on refait le même traitement: 4 + 8 = 12
 12 est compose de deux chiffres, on refait le même traitement: 1 + 2= 3
 3 est compose d'un seul chiffre et c'est le chiffre de chance recherche.

Ecrire un algorithme qui permet de saisir la date de naissance d'une personne sous la forme d'une
"jj/mm/aaaa ou j/m/aa ou autre…", puis d'appliquer la méthode citée ci-dessus et d'afficher le chiffre de
chance trouvé.
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….

23
 Modularité
Problème 3: Palindrome
Un nombre palindrome est un entier qui reste le même qu’on lise de droite à gauche ou de gauche à droite.
Exemples : 47374, 101, 6 et 9449 sont des nombres palindromes.
Pour déterminer la suite palindromique associée à un entier N, on procède comme suit :
1. on inverse l’ordre des chiffres de N et on ajoute N à ce nombre inversé.
2. on recommence l’opération avec le nouveau nombre jusqu’au obtenir un palindrome.
Exemples :–
Pour N= 64, on inverse les chiffres on obtient 46 auquel on ajoute 64 on obtient 110. Comme 110 n’est
pas palindrome alors on continue le même traitement avec 110 ainsi en inversant les chiffres on aura 11
puis en faisant l’addition on obtient 121. On arrête puisque 121 est palindrome.
N Suite palindromique
13 13, 44
87 87,165, 726, 1353, 4884
196 196, 887, 1675, … suite infinie

écrire un algorithme /python qui à partir d’un entier N donnée (N>=10, et N un nombre non symétrique),
déterminer et afficher un tableau qui contient la suite palindromique de N. (Dans le cas où la taille du
tableau dépasse 10 termes sans trouver un terme palindrome le programme s’arrête)
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….

24
 Modularité

Problème4 :
Soient T un tableau de N entiers positifs saisis dans l’ordre croissant (5<=N<=30) et un entier K (1<K<N).
On se propose de former un tableau TS par les sommes des k éléments consécutifs du tableau T, de telle
façon que TS [i] contiendra la somme des K éléments consécutifs du tableau comptés à partir de l’ième
élément du T.
En utilisant la modularité, écrire un programme (algorithme /python) qui permet de remplir un tableau T
par N entiers positifs, de saisir aussi un entier K puis de former et d’afficher le tableau TS.
Exemple : N=6 et K=4 et
T 10 40 55 60 65 80
0 1 2 3 4 5

165 240 260

on obtient : TS

……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
…………………………………………………………………………………………………………….
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

25
 Modularité

Probleme5 : Traducteur (Recherche Séquentielle)

Un élève veut élaborer son propre carnet comme étant un dictionnaire Français/Anglais, pour l’utiliser afin de
traduire une phrase. Ce carnet est formé par N mots en français et par N mots en anglais en équivalence. Sachant
que chaque mot est une chaine non vide et purement alphabétique.
Après l’élaboration du carnet, on veut traduire une phrase donnée en français (formée seulement par des lettres et
pas d’espaces superflus) en anglais. Dans le cas où l’un des mots ne figure pas dans le carnet, le mot en français va
figurer entre deux accolades dans la phrase en anglais. Le programme affiche la phrase traduite suivie par un
message de succès ou un message d’échec, indiquant ainsi le nombre de mots non traduites.
Exemple : Pour N=5, le carnet sera présenté comme suit :
Fr ecole je libre suis un
0 1 2 3 4

Ag school i free am a
0 1 2 3 4

Pour la phrase : ecole libre Pour la phrase : je suis un etre libre

Le programme affichera : school free : Traduction Le programme affichera : i am a {etre} free :
Traduction partielle avec 1 mot non traduite
totale

Travail demandé : En utilisant la modularité, écrire un programme qui permet de saisir un tableau de N mots puis
traduire une phrase donnée, en tenant compte de toutes les contraintes mentionnées
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
………………………………………………………………………………………………..
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………..
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

26
 Modularité
……………………………………………………………………………………………………………
………………………………………………………………………………………………..
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………..
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
………………………………………………………………………………………………..
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………..
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

27
 Modularité

Applications
Exercice1 : Soit le script python de la fonction suivante :
Fonction quoi(n : entier) :entier 4)…………………………………………………
Début ……………………………………………………
a 0 ……………………………………………………
K 1 ……………………………………………………
Tantque n≠0 Faire ……………………………………………………
Si n mod 2 = alors ……………………………………………………
a a + n mod 10 *k ……………………………………………………
K k * 10 ……………………………………………………
Finsi ……………………………………………………
n n div 10 ……………………………………………………
Fin Tantque ……………………………………………………
Retourner a ……………………………………………………
Fin
Questions
1) Pour chacune des propositions suivantes, répondre par la lettre (V) si elle est juste ou la lettre (F)
sinon.
a) L’appel de la fonction quoi, dans le b) Le passage de paramètre utilisé dans la
programme principal peut être de la fonction quoi est :
forme :
quoi(12346) par valeur
ecrire (quoi(12346)) par adresse
X quoi ("12346") par valeur et adresse
c) L’objet n déclaré dans l’entête de la d) a et k utilisés dans le corps de la fonction
fonction quoi est : quoi sont des variables :
un paramètre effectif Visibles uniquement par la fonction
quoi
Visibles par quoi et le programme
un paramètre formel
principal
Visibles uniquement par le programme
une entrée de la fonction
principal

2) Exécuter manuellement quoi(12346) en donnant les valeurs successives de a, n et k :

n
a
k

3) Déduire le rôle de cette fonction : …………………………………………………………………

4) Remplacer dans la fonction quoi la structure itérative à condition d’arrêt par une structure itérative
complète.
Exercice2
Soient le TDO global et l’entête de la procédure Traitement suivant ci-dessous :
Objet Type/Nature
N entier Procédure Traitement (@ x : réel , a :entier)
Y Réel
Traitement Procédure

Compléter le tableau ci-dessous par valide ou invalide, justifier la réponse pour les appels invalides.

28
 Modularité
Appel Valide/Invalide Justification

Traitement (Y , N)

Traitement (Y , N , 2)

Traitement (5.5 , N)

Traitement (Y , 3)

Exercice 3
Soient le tableau de déclaration des nouveaux types et les algorithmes des fonctions f1 et f2 suivants :
Nouveau Type
Tab = tableau de 50 entiers

Algorithme de f1 Algorithme de f2
Fonction f1(T :tab, n,x :entier) : entier Fonction f2(T : tab, n :entier) : entier
DEBUT DEBUT
Cpt  0 M  T[1]
Pour i de 1 à n Faire Pour i de 2 à n Faire
Si T[i]= x alors Si T[i] >M alors
Cpt  Cpt + 1 M  T[i]
Fin si TDOL Fin si TDOL
Fin pour Objet Type Fin pour Objet Type
Retourner Cpt Cpt , i entier Retourner M M,i entier
FIN FIN

Questions :
1) Pour le tableau T suivant :
T 5 6 3 3 2 8 6 2 6 3
1 2 3 4 5 6 7 8 9 10
a. Donner le résultat de chacun des appels ci-dessous de la fonction f1 :
f1(T, 10, 6) = …………………….. f1(T, 6,3) = ……………………..
b. Déduire le rôle de f1 :……………………………………………………………………………….
c. Donner le résultat de chacun des appels ci-dessous de la fonction f2 :
f2(T, 10) = …………………….. f2(T, 5) = ……………………..
d. Déduire le rôle de f2 :……………………………………………………………………………….
2) Ecrire l’algorithme d’un module intitulé Saisir qui permet le remplissage aléatoire de N cases
d’un tableau T, par des chiffres de 1 à 9 :
……………………………………………………………………………………………….
……………………………………………………………………………………………….
……………………………………………………………………………………………….
……………………………………………………………………………………………….
……………………………………………………………………………………………….
……………………………………………………………………………………………….

29
 Modularité
3) Ecrire l’algorithme d’un module intitulé Remplir qui qui permet de remplir un tableau V par le
nombre d’occurrences de chaque chiffre de 1 à 9 appartenant au tableau T.
NB : Faire l’appel de la fonction f1
Exemple : Pour N = 10
T 5 6 3 3 2 8 6 2 6 3
On obtient :
V 0 2 3 0 1 3 0 1 0
1 2 3 4 5 6 7 8 9
……………………………………………………………………………………………….
……………………………………………………………………………………………….
……………………………………………………………………………………………….
……………………………………………………………………………………………….
……………………………………………………………………………………………….
……………………………………………………………………………………………….
4) Ecrire l’algorithme d’un module intitulé Afficher qui qui permet d’afficher, à partir du tableau V,
le(s) indice(s) ayant le plus grand nombre d’occurrences dans le tableau T.
NB : Faire l’appel de la fonction f2
Exemple : Pour le tableau V :
V 0 2 3 0 1 3 0 1 0
1 2 3 4 5 6 7 8 9
L’affichage sera : Les chiffres les plus fréquents sont : 3 6
……………………………………………………………………………………………….
……………………………………………………………………………………………….
……………………………………………………………………………………………….
……………………………………………………………………………………………….
……………………………………………………………………………………………….
……………………………………………………………………………………………….
……………………………………………………………………………………………….

30
 Résolution de problème : La Modularité
……………………………………………………………………………………………………………
…………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
………………………………………………………………………………………………..
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………..
………….…………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

31