Les sous programmes

Activité1 :
Ecrire un algorithme puis un programme intitulé factorielle qui permet de saisir un entier
(a ) puis de calculer et afficher le factorielle de ce nombre .
A !=1*2*3*…….*A
Exemple : A=4
A !=1*2*3*4=24
Solution :
Algorithme Programme en python
Algorithme factorielle a=int(input('donner un entier a'))
début f=1
Lire(a) for i in range(2,a+1):
[f1]pour i de 2 à a faire f=f*i
ff*i print('a!=',f)
fin pour
Ecrire('a!=',f)
fin

Activité 2 :
Ecrire un algorithme et son implémentation en Python d’un programme qui permet de calculer
puis d’afficher le nombre de combinaison de P objets parmi N.

;
N, P sont deux entiers strictement positifs avec N≥P
Remarque
On constate que le calcul de N !, P ! et (N-P) ! se fait de la même manière et le traitement qui
calcule la factorielle se répète trois fois et bien sur le programme dévient très long.

Donc on a besoin de définir un nouvel outil pour éliminer cette redondance.

I les FONCTIONS
Vocabulaire et syntaxe :
En algorithmique
Fonction Nom_fonction (pf1: type1, pf2: type2, … , pfn : typen) : Type_résultat
DEBUT
<Traitement>
Retourner Résultat
FIN

Implémentation en python
def Nom_fonction (pf1, pf2 , … , pfn ) :
<Traitement>
return Résultat
Solution

Algorithme Implémentation en python

Algorithme combinaison def fact(a):
Début f=1
Répéter for i in range(2,a+1):
Lire(n) f=f*i
Lire(p) return(f)
Jusqu'à(n>p>0) n=int(input('donner n '))
Cfact(n)/(fact(p)*fact(n-p)) p=int(input('donner p'))
Ecrire(‘c=’ ,C) while not(n>p>0):
Fin n=int(input('donner n'))
p=int(input('donner p'))
TDO globaux c=fact(n)/(fact(p)*fact(n-p))
Objet type print('C=',c)
n,p,c Entier
exemple d’exécution :
Fonction fact(a :entier) :entier
début
[f1]pour i de 2 à a faire
ff*i
fin pour
retourner(f)
fin
TDO locaux
Objet type
I,f entier

Caractéristiques d’une fonction

 Une fonction est un sous programme qui retourne une valeur d’un type identique à celui de
la fonction.
 Une fonction a un type simple (entier, réel,…).
 Une fonction comporte des paramètres autres que le résultat.
 Une fonction est essentiellement un module de calcul qui renvoie une seule valeur d’un type
simple.
Remarque :
 Tout nouvel objet utilisé dans une fonction est appelé objet local.
 Tout objet déclaré dans le programme principal est appelé objet global.
 L’appel d’une fonction peut être effectué au niveau du programme principal ou au niveau
d’un module appelant.
 Les paramètres formels figurent dans l’entête de la déclaration de la fonction
 Les paramètres effectifs utilisés dans l’instruction d’appel de la fonction sont substitués aux
paramètres formels au moment de l’appel.
 Evitez d’y insérer les actions d’entrée et de sortie.
 Application :
Somme des diviseurs
Écrire un algorithme et une implémentation en python d’un programme nommé
diviseurs qui saisit un entier n et retourne la somme de ses diviseurs stricts
c'est à dire : La somme de ses diviseurs hormis lui même.
Exemple d'exécution :
Veuillez entrer un entier :126
186
Solution
En algorithmique Implémentation en python
Algorithme diviseurs
Début def Somme_diviseurs(p):
somme=0
Ecrire(‘donner un entier n’),lire(n) for i in range(1,p,1):
asomme_diviseurs(n) if p%i==0:
Ecrire(a) somme=somme+i
Fin return somme
TDO globaux
n=int(input("Veuillez entrer un
Objet type entier :"))
n,a Entier

Fonction somme_diviseurs(p :entier) :entier a=Somme_diviseurs(n)

Début print(a)
somme0
Pour i de 1 à p -1 faire
Si p mod i=0 alors
sommesomme+i
Finsi
Fin pour
Retourner somme
Fin
TDO locaux
Objet type
i,somme entier

Nombres amicaux
a et b deux entiers positifs sont dits amicaux ou amiables ou aimables si chacun des
deux nombres est égal à la somme des diviseurs stricts(diviseurs autres que lui-
même) de l'autre .
Exemple :
 la somme des diviseurs de 220 (en excluant 220) :
1+2+4+5+10+11+20+22+44+55+110=284
 la somme des diviseurs de 284 (en excluant 284) : 1+2+4+71+142=220
Écrire un algorithme et une implémentation en python d’un programme nommé Amicaux qui
permet de saisir deux entiers m et n et affiche s’ils sont amicaux ou non amicaux
Exemple d'exécution :
Veuillez entrer un entier n1 : 220
Veuillez entrer un entier n2 : 284
Nombres amicaux
Solution
En algorithmique Implémentation en python
Algorithme amicaux def Somme_diviseurs(p):
Début somme=0
for i in range(1,p,1):
Ecrire (‘donner un entier n’), lire(n) if p%i==0:
Ecrire (‘donner un entier m’), lire(m) somme=somme+i
Si nombres_amicaux(n,m) alors return somme
Ecrire(‘nombres amicaux’)
Sinon def nombres_amicaux(p,q):
a=Somme_diviseurs(p)
Ecrire(‘nombres non amicaux’)
b=Somme_diviseurs(q)
Fin si if a==q and b==p:
Fin return True
TDO globaux else:
Objet type return False
n,m Entier
Fonction nombres_amicaux(p,q :entier) :booleén n=int(input("Veuillez entrer un
Début entier n :"))
asomme_diviseurs(p) m=int(input("Veuillez entrer un
b somme_diviseurs(q) entier m :"))
if nombres_amicaux(n,m):
si a=q et b=p alors
print(‘nombres amicaux’)
retourner vrai else:
sinon print(‘nombres non amicaux’)
retourner faux
fin si
fin
TDO locaux
Objet type
a,b entier

Fonction somme_diviseurs(p :entier) :entier
Début
somme0
Pour i de 1 à p -1 faire
Si p mod i=0 alors
sommesomme+i
Finsi
Fin pour
Retourner somme
Fin
TDO locaux
Objet type
i,somme entier
II les procédures
Activité 2 :
Ecrire un algorithme et son implémentation en Python d’un programme intitulé affiche qui permet
de saisir 3 entiers a, b et c puis les affichés avec a suivi de a étoiles et b suivi de b étoiles et c suivi
de c étoiles.
Remarque :
On ne peut pas utiliser des fonctions comme solution
Car, en algorithmique, une fonction est qui renvoie un sel résultat de type simple.
Donc on a besoin de définir une autre manière de décomposition.
Les procédures
2. Vocabulaire et syntaxe :
La déclaration

Procédure Nom_procédure (pf1: type1, pf2: type2, … , pfn: typen)

DEBUT
Traitement
FIN
L’appel

Nom_procédure (pe1, pe2, … , pen)

En algorithmique Implémentation en python

Algorithme affiche
Début def etoile(p:int):
print(p,end='')
Ecrire(‘donner un entier x’),lire(x) for i in range(p):
Ecrire(‘donner un entier y’),lire(y) print('*',end='')
Ecrire(‘donner un entier z’),lire(z) x=int(input('donner un entier'))
Etoile(x) y=int(input('donner un entier'))
Etoile(y) z=int(input('donner un entier'))
etoile(x)
Etoile(z)
etoile(y)
Fin etoile(z)
TDO globaux
Objet type exemple :
X,y,z Entier

Procédure etoile(p :entier) 
Début
Ecrire(p)
Pour i de 1 à p faire
Ecrire(‘*’)
Fin pour
Fin
TDO locaux
Objet type
i entier
4. Remarque :

 Tout nouvel objet utilisé dans une procédure est appelé objet local.
 Tout objet déclaré dans le programme principal est appelé objet global.
 L’appel d’une procédure peut être effectué au niveau du programme principal ou au niveau d’un
module appelant.

5. Les paramètres :

a. Les types de paramètres :

Il existe deux types de paramètres :
Les paramètres formels qui figurent dans l’en tête de la déclaration de la procédure
Les paramètres effectifs utilisés dans l’instruction d’appel de la procédure et sont substitués
aux paramètres formels au moment de l’appel.

b. Les modes de passages des paramètres :

La substitution des paramètres effectifs aux paramètres formels s’appelle mode de passage de
paramètres. Il existe deux modes de passages de paramètres :
Passage par valeur :

Dans ce cas, Le transfert de l'information se fait du programme appelant vers le programme

appelé.
Passage par variable :

Dans ce cas, le transfert d'information entre le programme appelant et le programme appelé se fait
dans le 2 sens.
c. Remarque :
 Avec les fonctions on utilise toujours le passage de paramètre par valeur.
 Comment choisir le mode de passage de paramètre ?
Si le paramètre est modifié par la procédure (lecture ou affectation) alors on choisit le passage
par variable.
Si le paramètre n'est pas modifié par la procédure (affichage ou le paramètre est utilisé
comme donné pour faire un traitement quelconque) alors on utilise le passage par valeur.
 Si le mode de passage est par variable (par référence, par adresse), on ajoutera le symbole @
avant le nom du paramètre.
 Application
Ecrire un algorithme et son implémentation en python d’un
programme intitulé transfert_premiers qui permet de :
 Saisir un entier n(10<=n<=20)
 Remplir un tableau T par n entier de deux chiffres chacun
 Transférer les nombres premiers de T vers un tableau TP et
les nombre non premiers vers un tableau TNP
 Afficher TP

Algorithme
Procédure saisir(@n :entier)
Début
Répéter
Lire(n)
Jusqu’à 10<=n<=20)
Procédure remplir(@t :tab)
Début
Pour i de 0 à n-1 faire
Répéter
Lire(t[i])
Jusqu’à ( 10<=t[i]<=20)
Fin pour
TDO locaux
Objet type
i entier
Procédure transfert(t1,@t2,@t3:tab,@k,@j:entier)
Début
Pour i de 0 à n-1 faire 
Si premier(t1[i]) alors
jj+1
t2[j]t1[i]
sinon
kk+1
t3[k]t1[i]
fin si
fin pour
fin
fonction premier(x :entier) :booléen
debut
i=2
tantque(i<=x div 2) et (x mod i≠0) faire
ii+1
fin tantque
si i> x div2
retourner(vrai)
sinon retourner (faux)
finsi
fin
TDO locaux
Objet type
i entier

Procédure afficher(t :tab)
Début
Pour i de 0 à n-1 faire
Ecrire(t[i])
Fin pour
Fin

Algorithme transfert_premiers
Début
Saisir(n)
Remplir(t)
Transfert(t,tp,tnp,k,j)
Afficher(tp)
Fin
TDNT
type
Tab=tableau de 20 entier

TDO globaux
objets type
T,tp,tnp Tab
N,j,k entier
 Implémentation en python
def remplir(tt:list):
for i in range(n):
x=int(input('donner x'))
while not(10<=x<=99):
x=int(input('donner un entier x'))
tt.append(x)
def premier(x:int):
i=2
while(i<= x//2 and x%i!=0):
i=i+1
if i>x//2:
return(True)
else:
return(False)
def transfert(t1,t2,t3:list):
for i in range(n):
if premier(t1[i]):
t2.append(t1[i])
else:
t3.append(t1[i])
n=int(input('donner un entier n'))
while not(10<=n<=20):
n=int(input('donner n'))
t=[]
remplir(t)
tp=[]
tnp=[]
transfert(t,tp,tnp)
print(tp)

Exemple d’exécution
donner un entier n 10
donner x 12
donner x 14
donner x 47
donner x 25
donner x 17
donner x 19
donner x 16
donner x 17
donner x 12
donner x 14
[47, 17, 19, 17]