résumé algorithmique python fenni 2025.pdf

résumé algorithmique python fenni 2025

1. 1
Pensée computationnelle et programmation (résumé) Prof : FENNI-S




1. La forme générale d’un algorithme
ALGORITHME Nom
DEBUT
Instruction 1
Instruction 2
Instruction N
FIN

N.B.
L’écriture de l’algorithme doit obligatoirement respecter l’indentation.

2. Les types de données simples
En Algorithmique En Python
Entier int()
Réel float ()
Booléen bool ()
Caractère str ()
Chaîne de caractères str ()

3. Déclaration des objets de type simple, en algorithmique
Tableau de déclaration des objets (T.D.O.)
Objets Type/Nature
Nom_Constante Constante = Valeur de la constante
Nom_Variable Type_Variable

Exemples :
T.D.O.
Objets Type/Nature
Pi
e
Heure
Moy
Phrase
Test
C
Constante = 3.14
Constante = 2.718
Entier
Réel
Chaîne de caractères
Booléen
Caractère

N.B.
• En python, Il n'y a pas de mot-clé pour la définition d'une variable. Celle- ci est définie/créée lors de sa
première affectation. Ainsi, son type sera défini en fonction du type de la valeur qui lui a été attribuée.
• L’identificateur d’une variable est sensible à la casse, ce qui signifie que les variables AGE, age ou Age
sont différentes.

Pensée computationnelle &
Programmation
Définition :
Un algorithme est une suite ordonnée et
finie d’instructions permettant de résoudre
un problème donné.

2. 2
Pensée computationnelle et programmation (résumé) Prof : FENNI-S



4. Déclaration d’un tableau à une dimension
Déclaration en Algorithmique :
 1
ère
méthode :


 2
ème
méthode :
Tableau de déclaration des nouveaux types (T.D.N.T)
Nom_Type_Tableau = Tableau de taille et de type_éléments
Exemple : Tab = Tableau de 50 chaînes de caractères







Déclaration en Python en utilisant la bibliothèque Numpy :

Déclaration dans le cas général
from numpy import array
Nom_Tableau = array ([Type_élément( )] * N )
Ou bien
Nom_Tableau = array ([Valeur_initiale] * N )

Exemples de déclarations en python
Déclaration Explication
from numpy import array
T = array ([int( )] * 8)
Déclarer un tableau T de 8 entiers et initialisé par des zéros.

Pour une telle déclaration, on peut prévoir le tableau suivant :

T 45 13 -7 0 84 -3 34 2
0 1 2 3 4 5 6 7

from numpy import array
T = array ([float( )] * 100)
Déclarer un tableau T de 100 réels et initialisé par des zéros.
from numpy import array
T = array ([str] * 50)
Déclarer un tableau T de 50 chaînes de caractères
from numpy import array
T = array ([str()] * 10)
Déclarer un tableau T de 10 caractères et initialisé par le
caractère vide.
from numpy import array
T = array ([""] * 10 , dtype = "U20")
Déclarer un tableau T de 10 éléments initialisés par une chaîne vide. Chaque élément peut contenir 20 caractères au maximum.


N.B. :
• L’indice de la 1ère case d’un tableau est, par défaut, égal à Zéro ;
• Pour accéder à un élément d’indice « i » d’un tableau : Nom_Tableau [ i ] ;
• Tous les éléments dans un numpy.array sont de même type (entier, réel, caractère,...) ;
• La taille du tableau est constante (il n’est pas possible d’insérer ou de supprimer un élément).

Tableau de déclaration des objets (T.D.O)
Objet Type/Nature
Nom_Tableau Tableau de taille et de type_éléments
Exemple : T Tableau de 100 réels
Tableau de déclaration des objets (T.D.O)
Objet Type/Nature
Nom_Tableau Nom_Type_Tableau
Exemple : T Tab

3. 3
Pensée computationnelle et programmation (résumé) Prof : FENNI-S


5. Les opérateurs arithmétiques
Opération
Opérateur en
algorithmique
Opérateur en
python
Exemples Type du résultat
Addition + +
6 + 4.5 = 10.5
"BA" + "C" = "BAC"
Réel
Chaîne de caractères
Soustraction - - 6 - 4 = 2 Entier
Multiplication * *
6 * 4 = 24
1.2 * 3 = 3.6
3 * "AB" = "ABABAB"
Entier
Réel
Chaîne de caractères
Division / / 6 / 4 = 1.5 Réel
Division entière DIV // 6 // 4 = 1 Entier
Reste de la
division entière
MOD % 6 % 4 = 2 Entier

6. Les opérateurs logiques
Opération
Opérateur en
algorithmique
Opérateur en
python
Exemples en Python
Négation non not
not True = False
not False = True
Conjonction et and
True and False = False
True and True = True
False and False = False
Disjonction ou or
True or False = True
False or False = False
True or True = True

7. Les opérateurs de comparaisons
Tout comme les opérateurs logiques, les opérateurs de comparaison renvoient une valeur booléenne
"Vrai" ou "Faux". Les opérateurs de comparaisons s'appliquent sur tous les types de base.
Opération
Opérateur en
algorithmique
Opérateur en
python
Exemples
en Python
Résultats
Egal = = = 6 = = 6.0 True
Différent ≠ != "a" != "A" True
Strictement supérieur > > "FAMILLE"> "FAMILY" False
Strictement inférieur < < 5 < 5 False
Inférieur ou égal ≤ <= 4 <= 6 True
Supérieur ou égal ≥ >= 3 >= 4 False
Appartient
(entier, caractère)

in
20 in range(0,10)
"b" in {"a","b","e","k"}
False
True

Remarques :
• Lors de l’évaluation d’une expression, il faut tenir compte des règles de priorité entre les opérateurs
utilisés :
En algorithmique En Python
1) les parenthèses (…) (…)
2) les opérateurs unaires - (l’opposé) ; NON - ; not
3) les opérateurs multiplicatifs * ; / ; DIV ; MOD ; ET * ; / ; // ; % ; and
4) les opérateurs additifs + ; - ; OU + ; - ; or
5) les opérateurs relationnels
= ; < ; <= ; > ; >= ; ≠ ;
= ; < ; <= ; > ; >= ; ! = ; in

4. 4
Pensée computationnelle et programmation (résumé) Prof : FENNI-S

• Deux opérateurs ayant la même priorité, doivent être évalués de gauche à droite.

8. Les fonctions prédéfinies sur les types arithmétiques
Algorithmique Python Rôles Exemples en Python
NArrondi (x) N = round (x)
Retourne l’entier le plus proche
de x
N = round (3.5)  N=4
N = round (2.5)  N=2
N = round (2.8)  N=3
N = round (2.2)  N=2
NRacineCarré (x)
from math import*
N = sqrt (x)
Retourne la racine carrée de x
N = sqrt (25)  N=5
N = sqrt(-4)  Erreur
NAléa (vi, vf)
from random import*
N = randint (vi, vf)
Retourne un entier aléatoire de
l’intervalle [vi, vf]
N = randint (2,5)
N pourra avoir 2 ou 3 ou 4 ou 5
NEnt (x) N = int (x) Retourne la partie entière de x N = int (4.25)  N=4
NAbs (x) N = abs (x) Retourne la valeur absolue de x N = abs (-5)  N=5

9. Les fonctions prédéfinies sur les chaînes de caractères
Algorithmique Python Rôles Exemples en python
L  Long (ch) L=len (ch)
Retourne le nombre de
caractères de la chaîne ch
L = len("L'info")
 L = 6
P  Pos (ch1, ch2) P=ch2.find (ch1)
Retourne la première
position de la chaîne ch1
dans la chaîne ch2
ch = 'Bonjour'
x = ch.find ('o')  x = 1
y = ch.find ('no')  y = -1
ch  Convch (x) ch=str (x)
Retourne la conversion d’un
nombre x en une chaîne
ch = str (17.2)  ch = '17.2'
test  Estnum (ch)
test=ch.isdecimal ()
Ou bien
test=ch.isnumeric ()
Retourne Vrai si la chaîne ch
est convertible en une
valeur numérique, elle
retourne Faux sinon
ch = "154"
test = ch.isdecimal ()
 test = True
ch = "9ab3"
test = ch.isdecimal()
 test = False
test = "-5".isdecimal()
 test = False
N  Valeur (ch)
N=int(ch)
Ou bien
N=float(ch)
Retourne la conversion
d’une chaîne ch en une
valeur numérique, si c’est
possible
x = int ("12")  x = 12
y = float ("13.25")  y = 13.25
z = int ("13.25")  Erreur
ch1  Sous_chaîne (ch, d, f) ch1=ch [d : f]
Retourne une partie de la
chaîne ch à partir de la
position d jusqu’à la position
f (f exclue)
ch = "Bonjour"
• ch1 = ch [0:3]
 ch1 = 'Bon'
• ch2 = ch [3:len(ch)]
 ch2 = 'jour'
ch  Effacer (ch, d, f) ch=ch [ : d] + ch [f : ]
Efface des caractères de la
chaîne ch à partir de la
position d jusqu’à la position
f (f exclue)
ch = "Bonjour"
• ch = ch [:1] + ch[4:]
 ch = 'Bour'
• ch = ch [:0] + ch[3:]
⇔ ch = ch [3:]  ch = 'jour'
• ch = ch [:3] + ch[len(ch):]
⇔ ch = ch [:3]  ch = 'Bon'
ch  Majus (ch) ch=ch.upper( )
Convertit la chaîne ch en
majuscule
ch = "jour"
ch = ch.upper()  ch = 'JOUR'
c = "a".upper()  c = 'A'

5. 5
Pensée computationnelle et programmation (résumé) Prof : FENNI-S


10. Les fonctions prédéfinies sur les caractères
Algorithmique Python Rôles Exemples en python
Cod  Ord (c) Cod = ord (c) Retourne le code ASCII du caractère c Cod = ord("A")  Cod= 65
Car  Chr (d) Car = chr (d) Retourne le caractère dont le code ASCII est d Car = chr(98)  Car= 'b'

11. Les actions élémentaires simples
Actions En algorithmique En Python
L’action
d’affectation
Objet  Expression Objet = Expression
Exemples :
• a  2
• b  5 + a * a
• ville  "La chebba"
Exemples :
• a = 2
• b = 5 + a * a
• ville = "La chebba"
L’action
d’entrée

Lire (Objet)



Objet = input()

N.B. : Par défaut, la valeur saisie est de type
chaîne de caractères.
Exemples :
• Ecrire_nl ("saisir une chaîne"), Lire (ch)
• Ecrire ("saisir un entier"), Lire (n)
• Ecrire ("saisir un réel"), Lire (x)
Exemples :
• ch = input ("saisir une chaîne \n")
• n = int (input ("saisir un entier"))
• x = float (input ("saisir un réel"))
L’action
de sortie

• Ecrire ("message", objet, expression) • print ("message", objet, expression)
Exemples :
• Ecrire ("Saisir un entier : ")
• Ecrire ("Les notes : ", n1, n2, n3)
• Ecrire ( 5 + 4 * 2 )
• Ecrire_nl()
Exemples :
• print ("Saisir un entier : ", end="" )
• print (" Les notes :", n1, n2, n3, sep=" \n")
• print ( 5 + 4 * 2 )
• print() # ligne vide avec retour à la ligne

Remarques :
- Objet est une variable de type simple (entier, réel, booléen, caractère et chaîne de caractères).
- « print » fait un retour à la ligne automatique.
- "\n" permet d’ajouter un retour à la ligne.
- Le paramètre « end="" » évite le retour à la ligne.
- Le paramètre « sep="\n" » permet d'afficher les valeurs de manière séparée par une nouvelle ligne.


12. Les structures de contrôle conditionnelles

12.1 La structure conditionnelle simple
Notation Algorithmique Notation en Python

Si Condition
Alors Traitement
FinSi

if Condition :
Traitement

6. 6
Pensée computationnelle et programmation (résumé) Prof : FENNI-S


12.2 La structure conditionnelle complète
Notation Algorithmique Notation en Python

Si Condition
Alors Traitement1
Sinon Traitement2
FinSi

if Condition :
Traitement1
else :
Traitement2

12.3 La structure conditionnelle généralisée (Si imbriquée)
Notation Algorithmique Notation en Python

Si Condition1
Alors Traitement1
Sinon Si Condition2
Alors Traitement2
Sinon Si Condition3
Alors Traitement3
Sinon TraitementN
FinSi

if Condition1 :
Traitement1
elif Condition2 :
Traitement2
elif Condition3 :
Traitemnt3
else :
TraitementN

12.4 La structure conditionnelle à choix multiples
Notation Algorithmique Notation en Python (Version ≥ 3.10)

Selon Sélecteur
Val1 : Traitement1
Val2, Val3, Val4 : Traitement2
Val5 .. Val9 : Traitement3
…
Sinon TraitementN
FinSelon

match Sélecteur :
case Val1 : Traitement1
case Val2|Val3|Val4 : Traitement2
case Sélecteur if Val5 <= Sélecteur <= Val9 : Traitemnt3
case _ : TraitementN

7. 7
Pensée computationnelle et programmation (résumé) Prof : FENNI-S


13. Les structures de contrôle itératives
13.1 La structure de contrôle itérative complète (La boucle POUR … FAIRE …)
En algorithmique En Python

Pour Compteur de Début à Fin [Pas = valeur_pas] Faire
Traitement
Fin Pour

for Compteur in range (Début, Fin+1 [, pas]) :
Traitement
Remarques :
• Le nombre de répétitions est connu avant le
traitement et il est égal à |Fin – Début |+ 1.
• Le Pas peut être Positif ou Négatif.
• Par défaut, le Pas est égal à 1 .
• La boucle tourne seulement si :
o Début < Fin, avec un pas positif
o Début > Fin, avec un pas négatif

• range (0, 5) ou range(5) : le compteur
prendra les valeurs suivantes : 0, 1, 2, 3, 4
• range (2, 8) : le compteur prendra les
valeurs suivantes : 2, 3, 4, 5, 6, 7
• range (1 , 9, 2) : le compteur prendra les
valeurs suivantes : 1 , 3, 5, 7

•
range (6 , 0, -1) : le compteur prendra les
valeurs suivantes : 6, 5 , 4, 3, 2, 1

Exemples :
# afficher 100 fois le mot « Bonjour »
• Pour i de 1 à 100 Faire
Ecrire ("Bonjour")
Fin pour
# afficher les nombres de 1 à 20 en ordre décroissant
• Pour k de 20 à 1 [pas=-1] Faire
Ecrire (k)
Fin pour

Exemples :
• for i in range (1,101) :
print("Bonjour")
• for i in range (100) :
print("Bonjour")

• for k in range (20, 0, - 1) :
print(k)


13.2 La structure de contrôle itérative à condition d’arrêt (La boucle TANT QUE … FAIRE …)
Syntaxe en algorithmique Syntaxe en Python
Initialisation
Tant que Condition Faire
Traitement
Fin tant que
Initialisation
while Condition :
Traitement
Exemple
som  0
Tant que som < 100 Faire
Ecrire ("Donner un entier"), Lire (x)
Som  som + x
Fin tant que
Exemple
som = 0
while som < 100 :
x = int (input ('Donner un entier'))
som = som + x
Remarque : Le nombre de répétitions n’est pas connu à l’avance et le traitement peut ne pas se faire.
13.3 La structure de contrôle itérative à condition d’arrêt (REPETER … JUSQU’A …)
Syntaxe en algorithmique Syntaxe en Python

Répéter
Traitement
Jusqu’à C ondition d’arrêt
Pas de correspondance. Toutefois, on peut utiliser :
valide= False
while not valide : # while valide==False :
Traitement
valide = Condition d’arrêt

8. 8
Pensée computationnelle et programmation (résumé) Prof : FENNI-S

Exemple
Répéter
Ecrire ("Donner un entier positif ")
Lire(x)
Jusqu’à x>0
Exemple
valide=False
while not valide :
x = int (input ('Donner un entier positif'))
valide= x>0
Remarque : Le nombre de répétitions n’est pas connu à l’avance et le traitement se fait au moins une fois.


14. Les modules
14.1. Les fonctions
14.1.1. La définition d’une fonction
Une fonction est un sous-programme qui permet la résolution d’un sous-problème précis et retourne (renvoie)
un seul résultat de type simple (entier, caractère, réel, booléen, chaîne) au programme appelant.

En algorithmique En Python
FONCTION Nom_fonction (pf 1:type1, …, pfn:typen) : Type_Résultat
DEBUT
Instruction 1
Instruction 2
Instruction N
Retourner R ésultat
FIN
def Nom_fonction ( pf 1 , … , pfn ) :
Instruction 1
Instruction 2
Instruction N
return Résultat



14.1.2. L’appel d’une fonction
En Algorithmique En Python
Objet  Nom_fonction (pe1, …, pen) Objet = Nom_fonction (pe1, …, pen)
Exemples, pour de fonctions prédéfinies
• Ch2  Majus(ch)
• Si Pos (ch1, ch2) ≠ 0 Alors ............
• y  5 * RacineCarré(x+3)
• Ecrire (Long(ch))
• Ch2 = ch.upper()
• if ch2.find(ch1) !=0 : …………………
• y = 5 * sqrt (x+3)
• print ( len(ch))

N.B.
Les paramètres effectifs (pe 1,…, pen) et les paramètres formels (pf 1, …, pfn) doivent s’accorder de point
de vue ordre , nombre et type.

14.2. Les procédures
14.2.1. La définition d’une procédure
Une procédure est un sous-programme qui permet la résolution d’un sous-problème précis et qui peut
transmettre de zéro à plusieurs résultats au programme appelant.

En algorithmique En Python
PROCEDURE Nom_procédure (pf 1 : type1, …, pf2 : typen)
Début
Instruction 1
Instruction 2
Instruction N
Fin
def Nom_procédure (pf 1, …, pfn) :
Instruction 1
Instruction 2
Instruction N

9. 9
Pensée computationnelle et programmation (résumé) Prof : FENNI-S

14.2.2. L’appel d’une procédure
En algorithmique En Python
Nom_procédure (pe1, …, pen) Nom_procédure (pe1, …, pen)
Exemples, pour de procédures prédéfinies
Lire (x)
Ecrire (a, b)
x = input()
print(a, b)

N.B. :
 Le passage de paramètres par adresse (par référence) permet au programme appelant (PP) de
transmettre une valeur à la procédure appelée (SP) et vice versa. Dans ce cas, le paramètre formel est
précédé par le symbole « @ ». Par exemple : PROCEDURE TRAITEMENT( c : Réel ; @ a, b :Entier).
 Toute modification d'un paramètre formel dans le sous-programme appelé entraîne
(automatiquement) au moment du retour à l'appelant une modification de la valeur du paramètre
effectif correspondant.
 En python, le paramètre de type tableau est par défaut passé par référence.
 La portée des variables en python :
• Toute variable déclarée au sein d’un module a une portée locale.
• Toute variable déclarée au sein d’un module précédée par le mot clé global a une portée globale.
Par conséquent, elle ne devra pas figurer parmi les paramètres de ce module.


L’exemple ci-dessous illustre le passage par adresse en algorithmique et en Python.
En algorithmique
Déclaration de la procédure "Saisir" L’appel de la procédure "Saisir"
Procédure Saisir (@ m : Entier)
Début
Répéter
Ecrire ("Saisir un entier entre 5 et 20")
Lire (m)
Jusqu’à (5 ≤ m ≤ 20)
Fin
Saisir (n)

En Python (1
ère
démarche)
Déclaration de la procédure "Saisir" L’appel de la procédure "Saisir"
def Saisir () :
global m
valide = False
while not valide :
m = int (input ("Saisir un entier entre 5 et 20"))
valide = (5 <= m <= 20)
Saisir ()
n = m
En Python (2
ème
démarche)
Déclaration de la procédure "Saisir" L’appel de la procédure "Saisir"
def Saisir () :
valide = False
while not valide :
m = int (input ("Saisir un entier entre 5 et 20"))
valide = (5 <= m <= 20)
return m
n = Saisir ()



Paramètre formel
Paramètre effectif

10. 10
Pensée computationnelle et programmation (résumé) Prof : FENNI-S

Problème : Remplir puis afficher un tableau T par N entiers (avec 5 ≤ n ≤ 10)
Exemple d’une solution modulaire
En Algorithmique En Python
# Algorithme du programme principal
ALGORITHME Exemple
DEBUT
Saisie (N)
Remplir (N, T)
Affichage (N, T)
FIN
T.D.N.T.
Type
TAB = Tableau de 10 entiers

Tableau de déclaration des objets globaux
Objet Type/nature
N Entier
T TAB
Saisie Procédure
Remplir Procédure
Affichage Procédure

# Algorithme de la procédure Saisie
PROCEDURE Saisie ( @ m : Entier )
Début
Répéter
Ecrire ("Donner un entier entre 5 et 10")
Lire (m)
Jusqu’à (5 ≤ m ≤ 10)
Fin
# Algorithme de la procédure Remplir
PROCEDURE Remplir ( m : Entier ; @ V : TAB )
Début
Pour i de 0 à m-1 Faire
Ecrire ("T[",i,"]=")
Lire (V[i])
Finpour
Fin
T.D.O. locaux
Objet Type/Nature
i Entier
# Algorithme de la procédure Affichage
PROCEDURE Affichage ( m : Entier ; V : TAB )
Début
Pour i de 0 à m -1 Faire
Ecrire (V[i])
Finpour
Fin
T.D.O. locaux
Objet Type/Nature
i Entier


from numpy import array
T = array ([int()]*10)

def Saisie () :
valide = False
while not valide :
m = int(input("Donner un entier entre 5 et 10"))
valide = (5<=m<=10)
return m

def Remplir (m, V) :
for i in range(m) :
V[i]= int(input("T["+str(i)+"]="))

def Affichage (m, V) :
for i in range(m) :
print(V[i], end=" ")

#Programme principal
N = Saisie ()
Remplir (N, T)
Affichage (N, T)


Nb :
Pour tab :
Dans l’algo fin=taille -1
Dans python fin= taille

11. 11
Pensée computationnelle et programmation (résumé) Prof : FENNI-S


Les modules usuels

Les procédures
Algorithme Python Appel
# Saisir un entier positif

Procédure Saisir (@ x : entier)
Début
Répéter
Ecrire ("Donner un entier positif ")
Lire(x)
Jusqu’à x ≥ 0
Fin









def Saisir () :
global x
valide = False
while not valide :
x = int(input ("Donner un entier positif "))
valide = (x >= 0)

algorithme
Saisir(n)


python
Saisir()
n = x

def Saisir () :
valide = False
while not valide :
x = int(input ("Donner un entier positif "))
valide = (x >= 0)
return x

algorithme
Saisir(n)
python
n = Saisir()
# Saisir une chaîne de caractères formée uniquement de lettres majuscules

Procédure Saisie (@ ch : Chaîne)
Début
Répéter
Ecrire ("Saisir une chaîne "), Lire(ch)
Jusqu’à verif (ch)
Fin
Fonction verif (ch : chaîne) : booléen
Début
i← 0
test←Vrai
Tant que ( test=Vrai) ET (i ≠long(ch)- 1) Faire
Si non (ch[i]∈["A".."Z"])
Alors test← Faux
Finsi
i ← i+1
Fin Tant que
Retourner test
Fin

Solution2
Procédure Saisie (@ ch : Chaîne)
Début
Répéter
Ecrire ("Saisir une chaîne "), Lire(ch)
i ← -1
Répéter
i ← i+1
Jusqu'à non (ch[i]∈["A".."Z"]) OU (i = Long(ch)- 1)
Jusqu’à (i = Long(ch)- 1)
Fin




def Saisir() :
ch=input("Saisir une chaîne")
while not verif (ch) :
ch=input("Saisir une chaîne")
return ch

def verif (ch) :
i=0
test=True
while (test==True) and (i != len(ch)- 1) :
if not ("A" <= ch[i] <= "Z") :
test =False
i=i+1
return test





Solution2
def Saisir() :
verif = False
while verif ==False :
ch=input("Saisir une chaîne")
i=0
while ("A" <= ch[i] <= "Z") and (i != len(ch)- 1) :
i=i+1
verif = ( i==len(ch)- 1)

return ch


algorithme
Saisir(ch)
python
ch=Saisir()

12. 12
Pensée computationnelle et programmation (résumé) Prof : FENNI-S

# Remplir un tableau T par N entiers en ordre croissant (avec 10 ≤ N ≤ 100)

Procédure remplir (@ T : tab ; n : entier)
Début
Ecrire ("T[0] : "), Lire(T[0])
Pour i de 1 à (n-1) Faire
Répéter
Ecrire ("T[", i, "] : "), Lire (T[i])
Jusqu’à T[i] > T[i-1]
Fin Pour
Fin

TDOL
objet type/nature
i Entier

from numpy import array
V = array( [int()]*100)

def remplir (T, n) :
T[0] = int(input("T[0] :"))
for i in range (1, n) :
while T[i] <= T[i-1] :
T[i] = int(input("T["+ str(i) + "] :"))






algorithme
remplir (V, n)
python
remplir(V, n)

# Remplir un tableau T par N entiers de deux chiffres

Procédure remplir (@ T : tab ; n : entier)
Début
Pour i de 0 à n-1 Faire
Répéter
Ecrire ("T[ ", i, "] =" )
Lire(T[i])
Jusqu’à (10 ≤ T[i] ≤ 99)
FinPour
Fin

TDOL
objet type/nature
i Entier

from numpy import array
V = array( [int()]*100)

def remplir (T, n) :
for i in range(n) :
valide = False
while not valide :
T[i] = int (input ("T["+ str(i) + "]="))
valide = (10<=T[i] <=99)




algorithme
remplir (V, n)
python
remplir(V, n)

# Remplir un tableau T par N entiers distincts

Procédure Saisie (n : Entier ; @ T : Tab)
Début
Pour i de 0 à n-1 Faire
Répéter
Ecrire (''Saisir la case '', i), Lire (T[i])
j ← 0
Tant que T[i] ≠ T[j] Faire
j ← j+1
Fin Tant que
Jusqu’à (j = i)
Fin Pour
Fin

from numpy import array
V = array( [int()]*100)
def Saisie (n, T) :
for i in range(n) :
verif = False
while not verif :
T[i ] = int(input("Saisir la case"+ str(i)))
j=0
while T[i] != T[j] :
j=j+1
verif = (i==j)





algorithme
Saisie (n, V)




python
Saisie (n, V)

# Remplir un tableau T par N entiers au hasard entre [a, b]

Procédure Remplir (@ t : Tab ; n, a, b : Entier)
Début
Pour i de 0 à n-1 Faire
t [i] ← Aléa (a, b)
Fin Pour
Fin
Une lettre majuscule au hazard
t[i] ← chr (65 + Aléa(0, 25))

from numpy import array
v = array( [int()]*100)
def Remplir (t, n, a, b) :
from random import randint
for i in range(n) :
t [i] = randint (a, b)

Une lettre majuscule au hazard
t[i] = chr (65 + randint(0, 25))




algorithme
Remplir (v, n,
a, b)
python
Remplir (v, n,
a, b)

13. 13
Pensée computationnelle et programmation (résumé) Prof : FENNI-S

# Affichage d’un tableau T de N éléments

Procédure afficher (T: tab ; n : entier)
Début
Pour i de 0 à n-1 Faire
Ecrire (T[i])
FinPour
Fin

…………………………
from numpy import array
v = array( [int()]*100)

def afficher (T, n) : …
for i in range(n) : …
print (T[i], end=" ")
……
algorithme
afficher (v, n)


python
afficher (v, n)
# Ranger les valeurs négatifs d’un tableau T à gauche et les valeurs positifs à droite

Procédure Ranger (@ t : tab ; n : entier)
Début
k ← 0
Pour i de 0 à n-1 Faire
Si t[i] < 0
Alors aux ← t[i]
t[i] ← t[k]
t[k] ← aux
k ← k +1
Fin Si
Fin Pour
Fin

TDOL
objet type/nature
i, k Entier

from numpy import array
v = array( [int()]*100)
def Ranger (t, n) :
k=0
for i in range(n) :
if t[i] < 0 :
aux = t[i]
t[i] = t[k]
t[k] = aux
k = k +1



algorithme
Ranger (v, n)
python
Ranger (v, n)
# Transférer les éléments pairs d’un tableau T, dans T1 et les impairs dans T2

Procédure Transfert (t : tab ; n : entier ; @ t1, t2 : tab ;
@ c1, c2 : entier)
Début
c1 ← 0 ; c2 ← 0
Pour i de 0 à n-1 Faire
Si t[i] mod 2 = 0
Alors c1← c1 +1
t1[c1] ←t[i]
Sinon c2← c2 +1
t2[c2] ← t[i]
Fin Si
Fin Pour
Fin

TDOL
objet type/nature
i Entier

from numpy import array
v = array( [int()]*100)
v1 = array( [int()]*100)
v2 = array( [int()]*100)

def Transfert (t, n, t1, t2) :
c1=0 ; c2=0
for i in range (n) :
if t[i] % 2 == 0 :
t1[c1] = t[i]
c1 = c1 +1
else :
t2[c2] = t[i]
c2 = c2 +1
return c1, c2






algorithme
Transfert (v,
m, v1, v2, k1,
k2)


python
k1, k2 =
Transfert (v,
m, v1, v2)
# Permutation de deux variables

Procédure Permut (@ a, b : Réel)
Début
aux ← a
a ← b
b ← aux
Fin

TDOL
objet type/nature
aux Réel

def Permut(a,b) :
aux = a
a = b
b = aux
return a, b







algorithme
Permut (x, y)
python
x,y =
Permut(x,y)

14. 14
Pensée computationnelle et programmation (résumé) Prof : FENNI-S

# Insertion d’un élément X dans un tableau T à une position p

Procédure Insertion (@ t : tab ; n, x, p : entier)
Début
Pour i de n à (p-1) [pas=-1] Faire
t[i] ← t[i-1]
Fin Pour
t[p] ← x
Fin

from numpy import array
v = array( [int()]*100)

def Insertion (t, n, x, p) :
for i in range (n, p-1, -1) :
t[i] = t[i-1]
t[p]=x

algorithme
Insertion (v, n, x, p) python
Insertion (v, n, x, p)

# Trier un tableau T de N entiers, par ordre croissant, en utilisant la méthode de tri à bulles.

PROCEDURE TRI_BULLES (N:entier ; @ T:Tab)
Début
Répéter
Permutfaux
Pour i de 0 à N-2 Faire
Si T[i] > T[i+1]
Alors auxT[i]
T[i]T[i+1]
T[i+1] aux
Permut Vrai
FinSi
FinPour
N  N-1
Jusqu'à (Permut=Faux) OU (N=0)
Fin


def tri_bulles (n, t):
permut = True
while not (permut== False or n==0):
permut = False
for i in range(0, n-1):
if t[i] > t[i+1]:
aux=t[i]
t[i] =t[i+1]
t[i+1]=aux
permut = True
n=n-1



algorithme
tri_bulles(n,t)

python
tri_bulles(n,t)

15. 15
Pensée computationnelle et programmation (résumé) Prof : FENNI-S

Les fonctions
Algorithme Python Appel
# PGCD de 2 entiers (méthode de la différence)

Fonction PGCD (a, b : entier) : entier
Début
Tant que (a ≠ b) Faire
Si a > b
Alors a ← a-b
Sinon b ← b-a
FinSi
Fin Tant que
Retourner a
Fin

def PGCD (a, b ) :
while ( a != b) :
if a > b :
a = a-b
else :
b = b-a

return a




algorithme
pg ← PGCD (x, y)
python
pg = PGCD (x, y)

# PGCD de 2 entiers (méthode d’Euclide)

Fonction PGCD (a, b : entier) : entier
Début
Tant que (b ≠ 0) Faire
r ← a mod b
a ← b
b ← r
Fin Tant que
Retourner a
Fin

def PGCD (a, b ) :
while (b != 0) :
r = a % b
a = b
b = r

return a


# PPCM de 2 entiers

Fonction PPCM ( a, b : entier) : entier
Début
i ← 1
Tant que ((a*i) mod b) ≠ 0 Faire
i ← i + 1
Fin Tant que
Retourner (a*i)
Fin

def PPCM (a, b ) :
i = 1
while ((a*i) % b) != 0 :
i = i + 1

return (a*i)


algorithme
pp ← PPCM (x, y)
python
pp = PPCM (x, y)
# Calcul de X
n


Fonction puissance(x, n : entier) : réel
Début
p←1
Pour i de 1 à abs(n) Faire
p ←p*x
FinPour
Si n<0
Alors p ←1/ p
FinSi
Retourner p
Fin

def puissance (x, n ) :
p=1
for i in range(1, abs(n)+1) :
p = p * x
if n<0 :
p = 1/p

return p

algorithme
ps ← puissance(x, n)
python
ps = puissance(x, n)

# Factoriel d’un entier N (N! = 1*2*3*…*n)

Fonction fact (n : entier) : entier ……
Début
f ← 1
Pour i de 2 à n Faire
f ← f*i
FinPour
Retourner f
Fin

def fact (n ) :
f=1
for i in range (2, n+1) :
f = f * i

return f


algorithme
x ← fact(n)
python
x = fact(n)

16. 16
Pensée computationnelle et programmation (résumé) Prof : FENNI-S

# Vérifier si un nombre est premier (le nombre de ses diviseurs =2)

Fonction premier (n : entier) : booléen
Début
nb ← 1
Pour i de 1 à (n div 2) Faire
Si (n mod i) = 0
Alors nb ← nb + 1
FinSi
FinPour
Retourner nb = 2
Fin

def premier (n) :
nb=1
for i in range(1, (n//2)+1) :
if n % i == 0 :
nb = nb + 1

return nb == 2



algorithme
ok ← premier(n)
python
ok = premier(n)

# Méthode2 : vérifier s’il y a un diviseur de n dans l’intervalle [2, (n div 2)]

Fonction premier (n : entier) : booléen
Début
i ← 2
verif ← Vrai
Tant que verif ET (i <= n div 2) Faire
Si (n mod i) = 0
Alors verif ← Faux
Sinon i ← i + 1
FinSi
Fin Tant que
Retourner verif
Fin

def premier(n):
i=2
verif=True
while verif and (i <= n // 2):
if (n % i == 0):
verif =False
else:
i=i+1

return verif

algorithme
ok ← premier(n)
python
ok = premier(n)

# Vérifier si un nombre est parfait ( n = somme de ses deviseurs sauf lui-même. exp : 6=1+2+3)

Fonction parfait (n : entier) : booléen
Début
s ← 0
Pour i de 1 à (n div 2) Faire
Si (n mod i) = 0
Alors s ← s + i
FinSi
FinPour
Retourner s = n
Fin

def parfait (n) :
s=0
for i in range(1, n//2+1) :
if (n%i) == 0 :
s = s + i

return s == n

algorithme
ok ← parfait(n)


python
ok = parfait(n)

# Calcul de la somme S = 1+2+3+4+…+N

Fonction Somme (n : entier) : entier
Début
S ← 0
Pour i de 1 à n Faire
S ← S + i
Fin Pour
Retourner S
Fin

def Somme(n) :
S= 0
for i in range(1, n+1) :
S = S + i

return S


algorithme
som ← Somme(n)

python
som = Somme(n)

# Calcul de la somme S = 1-2+3-4+…+(-1)
n+1
N

Fonction Somme (n : entier) : entier
Début
S ← 0 ; signe←1
Pour i de 1 à n Faire
S ← S + signe*i
signe ← -1
Fin Pour
Retourner S
Fin

def Somme(n) :
S= 0 ; signe=1
for i in range(1, n+1) :
S = S + signe * i
signe= -1

return S



algorithme
som ← Somme(n)
python
som = Somme(n)

17. 17
Pensée computationnelle et programmation (résumé) Prof : FENNI-S

# La somme de chiffres d’un entier

Fonction Som_chiff (n : entier) : entier
Début
S ← 0
Répéter
R ← n mod 10
S ← S + R
n ← n div 10
Jusqu’à (n = 0)
Retourner S
Fin

Solution 2 :
Fonction Som_chiff (n : entier) : entier
Début
C ← Convch(n)
S ← 0
Pour k de 0 à long(C)-1 Faire
S ← S + Valeur(C[k])
Finpour
Retourner S
Fin

def Som_chiff (n) :
S= 0
Valide = False
while not Valide :
R = n % 10
S = S + R
n = n // 10
Valide = (n==0)

return S

Solution 2 :
def Som_chiff (n) :
C=str(n)
S=0
for k in range (0, len(C)) :
S = S + int( C[k])
return S



algorithme
som ← Som_chiff(n)
python
som = Som_chiff(n)

# Décomposition d’un nombre en un produit de facteurs premiers ( exp : 36=2*2*3*3)

Fonction fact_premier (n : entier) : chaine
Début
ch←""
i←2
Tant que (n ≠ 1) Faire
Si n mod i = 0
Alors ch ← ch + convch(i) + "*"
n ← n div i
Sinon i ← i+1
FinSi
FinPour
Retourner Sous_chaine (ch, 0, long(ch)-1)
Fin

def fact_premier (n) :
ch = ""
i = 2
while (n != 1) :
if (n % i) == 0 :
ch = ch + str(i) + "*"
n = n // i
else :
i = i + 1

return ch[0 : len(ch)-1]

# La moyenne de n entiers dans un tableau V

Fonction Moyenne (T : tab ; n : entier) : réel
Début
Som← 0
Pour i de 0 à n-1 Faire
Som ← Som + T[i]
Fin Pour
Retourner Som/n
Fin
from numpy import array
v = array( [int()]*100)
def Moyenne(T, n) :
Som= 0
for i in range(n) :
Som = Som + T[i]

return Som/n


solution 2
def Moyenne(T) :
Som= 0
for i in T :
Som = Som + i

return Som/len(T)



algorithme
moy ←Moyenne(v, n)

python
moy = Moyenne(v, n)




solution 2
moy = Moyenne(v)

18. 18
Pensée computationnelle et programmation (résumé) Prof : FENNI-S

# Miroir (symétrique) d’un entier
Fonction Miroir (x : entier) : entier
Début
sym ← 0
Répéter
u ← x mod 10
sym ← sym * 10 + u
x ← x div 10
Jusqu’à x=0

Retourner sym
Fin
def Miroir (x) :
sym = 0
while (x != 0) :
u = x % 10
sym = sym * 10 + u
x = x // 10
return sym

# Vérifier si une chaîne est palindrome (exp : "AZIZA")
Fonction Palindrome (ch : chaîne) : Booléen
Début
i ← 0
Répéter
verif ← ch[i] = ch[long(ch) - i -1 ]
i ← i+1
Jusqu’à (verif=faux) ou (i = long(ch) div 2)

Retourner verif
Fin

#solution 2
Fonction Palindrome (ch : chaîne) : Booléen
Début
inv← ""
Pour i de 0 à long(ch)- 1 Faire
inv ← ch[i] + inv
Finpour

Retourner inv=ch
Fin
def Palindrome (ch) :
i = 0
verif = True
while verif and (i != len(ch) // 2):
verif = (ch[i] == ch[len(ch) - i -1])
i=i+1

return verif
#solution2
def Palindrome (ch) :
inv = ""
for i in range(len(ch)) :
inv = ch[i] + inv

return inv==ch

# Vérifier si une chaîne de caractères contient uniquement des lettres
Fonction verif (ch : chaine) : booléen
Début
i ← 0
test←Vrai
Répéter
Si non("A" ≤ Majus(ch[i]) ≤ "Z")
Alors test←Faux
Finsi
i ← i+1
Jusqu’à (test=Faux) ou (i = long(ch))

Retourner test
Fin
#solution 2
Fonction verif (ch : chaine) : booléen
Début
i ← -1
Répéter
i ← i+1
test ← "A" ≤ Majus(ch[i]) ≤ "Z"
Jusqu’à (test=Faux) ou (i = long(ch)-1)

Retourner test
Fin

def verif (ch ) :
test = True
i = 0
while not(test==False or i==len(ch)) :
if not ("A" <= ch[i].upper() <= "Z"):
test=False
i = i + 1

return test

#solution2
def verif (ch ) :
test = True
i = -1
while not(test==False or i==len(ch)-1) :
i = i + 1
test = "A" <= ch[i].upper() <= "Z"

return test

19. 19
Pensée computationnelle et programmation (résumé) Prof : FENNI-S

# Recherche de la première valeur minimum dans un tableau T de n réels

Fonction minimum (t : tab ; n : entier) : réel
Début
min ← t[0]
Pour i de 1 à (n-1) Faire
Si t[i] < min
Alors min ← t[i]
FinSi
FinPour

Retourner min
Fin


def minimum (t, n) :
min = t[0]
for i in range (1, n) :
if t[i] < min :
min = t[i]

return min


algorithme
mini ← minimum(t,n)
python
mini = minimum(t,n)

# Recherche de la dernière position d’un élément X dans un tableau T de n réels

Fonction Recherche (x : réel ; n : entier ; t : tab) : entier
Début
p ← -1 ; i ← n
Répéter
i ← i - 1
Si t[i] = x
Alors p ← i
FinSi
Jusqu’à (p ≠ -1) OU (i = 0 )

Retourner p
Fin


def Recherche (x, n, t) :
p = -1
i = n
valide=False
while not valide :
i = i - 1
if t[i] == x :
p = i
valide = (p != -1) or (i==0)

return p


algorithme
pos ←
Recherche(x, n, t )

python
pos =
Recherche(x, n, t )

# Fréquence d’un élément X dans un tableau T de N entiers

Fonction frequence (x, n : entier ; t:tab) : entier
Début
nb ← 0
Pour i de 0 à (n-1) Faire
Si t[i] = x
Alors nb ←nb + 1
FinSi
FinPour

Retourner nb
Fin


def frequence (x, n, t) :
nb = 0
for i in range(n) :
if t[i] == x :
nb = nb + 1

return nb


# Recherche d’un élément V dans un tableau T (méthode séquentielle)

Fonction Recherche (v, n : entier ; t:tab) : booléen
Début
i ← -1
Répéter
i ← i+1
Jusqu’à (t[i]=v) ou (i=n-1)

Retourner t[i]=v
Fin






def Recherche (v, n, t) :
i = 0
while not(t[i]==v or i==n-1) :
i =i+1

return t[i]==v

20. 20
Pensée computationnelle et programmation (résumé) Prof : FENNI-S

# Recherche d’un élément V dans un tableau T (méthode dichotomique)

Fonction Recherche (v, n : entier ; t:tab) : booléen
Début
g ← 0
d ← n-1
trv ← Faux
Répéter
m ← (g+d) div 2
Si V=T[m]
Alors trv ← Vrai
Sinon Si V<T[m]
Alors d ← m-1
Sinon g ← m+1
Finsi
Jusqu’à (trv=Vrai) ou (g>d)

Retourner trv
Fin

def Recherche (v, n ,T) :
g=0
d=n-1
trv=False
while not (trv==True or g>d) :
m=(g+d) // 2
if v==T[m] :
trv=True
elif v>T[m]:
g=m+1
else :
d=m -1

return trv


# Tri d’une chaîne en ordre croissant

Fonction Tri (ch : chaîne) : chaîne
Début
ch1 ← ""
Tant que long(ch) > 0 Faire
p ← 0
Pour i de 0 long(ch)- 1 Faire
Si ch[i] < ch[p]
Alors p ← i
Finsi
Finpour
ch1 ←ch1 + ch[p]
ch ← Effacer (ch, p, p+1)
Fin Tant que

Retourner ch1
Fin


def Tri (ch) :
ch1=""
while len(ch)>0 :
p=0
for i in range(len(ch)) :
if ch[i]<ch[p] :
p=i
ch1=ch1+ch[p]
ch=ch[:p]+ch[p+1:]

return ch1


# Supprimer les espaces superflus d’une chaîne (laisser un seul espace entre les mots)

Fonction Espace_superflus (ch : chaîne) : chaîne
Début
p ← pos(" ", ch) #position de 2 espaces dans ch
Tant que p ≠ -1 Faire
ch ← Effacer(ch,p,p+1)
p ← pos(" ", ch)
Fin Tant que
Si ch[0] = " "
Alors ch ← Effacer(ch,0,1)
Finsi
Si ch[long(ch)- 1] = " "
Alors ch ← Effacer(ch, long(ch)- 1, long(ch))
Finsi

Retourner ch
Fin


def Espace_superflus(ch):
p=ch.find(" ")
while p!=-1:
ch=ch[:p]+ch[p+1:]
p=ch.find(" ")
if ch[0]==" ":
ch=ch[1:len(ch)]
if ch[len(ch)- 1]==" ":
ch=ch[0:len(ch)- 1]

return ch

21. 21
Pensée computationnelle et programmation (résumé) Prof : FENNI-S

# Convertir une chaîne majuscule en minuscule

Fonction Minus (ch : chaîne) : chaîne
Début
chm ← ""
Pour i de 0 à long(ch)-1 Faire
ch m ← chm + chr ( ord (ch[i]) + 32)
Fin pour

Retourner c hm
Fin


def Minus(ch):
chm=""
for i in range (len (ch)):
chm = chm + chr ( ord (ch[i]) + 32)

return chm


# Rang alphabétique d’une lettre minuscule ou majuscule

Fonction Rang (let : Caractère) : entier
Début
Retourner ord(let) mod 32
Fin

Exemple : Si let = "B" alors rang=2


def Rang (let):
return ord(let) % 32