Vous êtes sur la page 1sur 5

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

Vous aimerez peut-être aussi