1) La somme des diviseurs d'un entier X sauf (X) :

Fonction som_diviseurs ( x : entier) : entier def som_diviseurs ( x ):

Début S = 0;
S 0 for i in range (1, x // 2 + 1 ):
Pour i de 1 à x div 2 faire if x % i == 0 :
Si x mod i = 0 Alors S=S+i
SS+i
FinSi
FinPour return S
Retourner S Fin
2) Factorielle de X : X! = X * (X-1) * (X-2) * ... *2*1 ; ex : 5! = 5*4*3*2*1 = 120
Fonction facto ( x : entier) : entier def facto ( x ) : récursive
Début P=1 Fonction facto ( x : entier) : entier
P 1 for i in range (1, x+1 ) : Début
Pour i de 1 à x faire P=P*i Si x=0 alors
PP*i Retourner 1
FinPour sinon
Retourner P return P Retourner x*facto(x-1)
Fin Fin
3) Puissance (x , n) / xn = x*x*x....*x (n fois)
Fonction puiss ( x : réel ; n : entier) : réel def puiss ( x , n ) : recursive
Début P=1
def puiss ( x , n ) :
P 1 for i in range (1, abs(n)+1 ) :
if n==0 :
Pour i de 1 à abs (n) faire P=P*x
return 1
PP*x if n < 0 :
if n >0 :
FinPour P = 1/P
return x*puiss(x,n-1)
Si n <0 Alors P  1/P FinSi return P
else :
Retourner P
return 1/x*puiss(x,n+1)
Fin

4) Vérifier si un nombre x est premier (x est premier s'il admet uniquement 2 diviseurs, 1 et lui-même)
Fonction premier (x : entier) : booléen Fonction premier ( x : entier) : booléen def premier ( x ):
Début Début S = 0;
i2, ok true S 0 for i in range (1 , x +1 ) :
tant que (ok) et (i<= x div 2)faire Pour i de 1 à x faire if x % i == 0 :
ok x mod i = 0 Si x mod i = 0 Alors S=S+1
i i + 1 SS+1
fin tant que FinSi return (S==2)
Retourner ok Fin FinPour
Retourner (S = 2)

5) Les facteurs premiers d'un entier X :

Fonction fact_prem ( x : entier) : chaîne def fact_prem ( x ):
Début i = 2;
i 2 , ch = "" while x != 1 :
répéter if x % i == 0 :
Si x mod i = 0 Alors x = x // i
x  x div i ch = ch + str ( i ) + "*"
ch  ch + convch(i)+"*" else :
Sinon i=i+1
ii+1
FinSi return ch[ :-1]
Jusqu'à ( x = 1) # x = 60
Retourner ( souschaine(ch,0,long(ch) ) Fin # ch = "2*2*3*5*"
6) PGCD (a , b ) // méthode euclidienne et méthode de la différence
Fonction pgcd ( a , b : entier) : entier Fonction pgcd ( a , b : entier) : entier def pgcd ( a , b ):
Début Début while a != b :
Repeter Tanque a ≠b Faire if a > b :
r a mod b Si a > b Alors a=a-b
ab a=a-b else :
br Sinon b=b-a
jusqu’à b=0 bb-a
Retourner ( a ) FinSi return a
Fin Retourner ( a )
Fin

1
 7) PPCM (a , b )
Fonction ppcm ( a , b : entier) : entier def ppcm ( a , b ):
Début x=a
x=a while x % b != 0 :
Tanque a mod b ≠0 Faire a=a+x
a=a+x return a
Retourner ( a )
Fin
8) Décomposition d'un entier en chiffres : ex : somme des chiffres d'un entier
Fonction somme_chiffres ( x : entier) : def somme_chiffres ( x ): def somme_chiffres ( x ):
entier ch = str ( x ) s=0
Début L= len ( ch ) while x != 0 :
ch convch ( x ) S=0 x =x//10
S 0 for i in range (0 , L ) : return x
Pour i de 0 à (lon (ch )-1) faire S = S + int ( ch[i] )
S  S + valeur (ch[i]) return ( S )
FinPour
Retourner ( S )
Fin
9) Suite récurrente : { ex : Suite de la forme Un = Un-1 + Un-2 avec U0 et U1 données; le calcul des termes s'arrête si la
différence entre deux termes consécutifs devient inférieur à Eps donné .
Fonction suite ( U0 , U1 : entier) : entier def suite ( a , b ):
Début # T[0] =U0 ; T[1] = U1 stop = False
Répéter # i = 1 Répéter while stop == False :
U  U1 + U0 #i=i+1 U = U1 + U0
U0  U1 # T[i] = T[i-1] + T[i-2] U0 = U1
U1  U # jusqu 'à abs(T[i]–T[i-1]) <= Eps U1 = U0
Jusqu'à (abs (U – U0) <= Eps stop = (abs (U – U0) <= Eps)
Retourner ( U ) # Rétourner T[i] return ( U )
Fin
10) Fonction vérif (vérifier que ch est alphabétique)
Fonction verifch :chaine) :booleen def verif(ch):
Début i=0
i0 ok=True
okvrai while ok and i<len(ch):
Tant que (ok) and(i<len(ch)): ok=’A’<=ch[i].upper()<=’Z’
ok=(″A″<=majus(ch[i])) et (majus(ch[i])<=″Z″) i=i+1
i=i+1 return ok
Retourner ok
Fin
Les Tableaux Remplir un tableau :
Procédure remplir (@ T:tab ; n : entier) def remplir (T , n ):
Début for i in range (n) :
Pour i de 0 à (n-1) Faire ok = False
Répéter while ok == False :
Ecrire ("entrer T" + convch(i)+"]:") T[i] = ....... (input ("T["+str(i)+"]:"))
Lire (T[i]) ok = (condition (T[i] )
Jusqu'à ( condition(T[i]) )
Fin
● Remplir avec des lettres majuscules au hasard : from random import *
for i in range ( n ) :
Pour i de 0 à (n-1) Faire T[i] = chr (randint (65 , 90) )
T[i]  chr (aléa (ord("A", ord("Z") )

K=0
● Remplir le tableau V avec les voyelles du tableau T: Voy = "OIYEAU"
K0 for i in range ( n ) :
Voy  "OIYEAU" if [Link](T[i].upper( ) ) != -1 :
Pour i de 0 à (n-1) faire V[K] = T[i]
Si position (majus(T[i]) , Voy) ≠-1 Alors K=K+1
V[K]  T[i] #---------------------PP
KK+1 N=saisi()
FinSi T=array([int()]*n ) #tableau d’entier
FinPour #T=array([str()]*n) tableau de caractère
T=array([str)]*n) #tableau de chaine
Remplir(T,n)

2
 1) Chercher une valeur X dans un tableau T de n éléments : vérifier l'existence de X dans T
Fonction verif (x : caractère ; T:tab ; n : entier):booléen / def verif (X, T , n ):
entier Test = False
Début # T est un tableau de n caractères while Test == False and P ==-1 and i<n :
Test Faux i=i+1
P  -1 if T[i] == X :
i  -1 Test = True
Répéter P=i
i i +1
Si T[i] = X Alors return Test # return P
Test Vrai
Pi
FinSi
Jusqu'à (Test = Vrai) ou (P > -1) ou (i = n - 1)
Retourner Test # Retourner P
Fin
● Fréquence (nombre d'occurrence) de X dans T F=0
for i in range ( n ) :
F 0 if T[i] == X :
Pour i de 0 à (n-1) faire F=F+1
Si T[i] = X Alors
FF+1 return F
FinSi
FinPour
2) Première position de la valeur maximale dans un tableau T de n éléments.
Fonction posmax (T:tab ; n : entier) : entier def posmax (X, T , n ):
Début m = T[0]
P0 P=0
m  T[0] for i in range (1 , n ) :
Pour i de 0 à (n-1) faire if T[i] > m :
Si T[i] > m Alors m = T[i]
m  T[i] P=i
Pi
FinSi return P # return m
FinPour
Retourner P # Retourner m
Fin
3) Supprimer l'élément d'indice P d'un tableau T de n éléments :
Procédure supprimer (p: entier; @T:tab ; @ n : entier) def supprimer (p, T , n ):
Début for i in range (p , n-1 ) :
Pour i de p à (n-2) faire T[i] = T[i + 1]
T[i]  T[i+1] n=n–1
FinPour
nn-1
Fin
5) Insérer X à la position P dans un tableau T de n éléments :
Procédure insérer (X,p: entier; @T:tab ; @ n : entier) def insérer (X, p, T , n ):
Début for i in range (n , p, -1 ) :
Pour i de n à (p) faire T[i] = T[i-1]
T[i]  T[i-1] T[p] = X
T[p]  X n=n+1
FinPour
nn+1
Fin
6) Inverser l'ordre des éléments d'un tableau T de n éléments :
Procédure inverser ( @T:tab ; n : entier) def inverser (T , n ):
Début for i in range (0 , n //2 + 1 ) :
Pour i de 0 à (n div 2) faire aux = T[i]
aux  T[i] T[i] = T[n - i - 1]
T[i]  T[n-i-1] T[n – i -1 ] = aux
T[n-i-1]  aux
FinPour
Fin
7) Tri d'un tableau T de n éléments : (tri à bulles)
procédure Tri_bulles ( @T:tab ; n : entier) def Tri_bulles (T , n ):
Début Permut = False
Répéter while Permut ==False

3
 Permut  Faux Permut = False
Pour i de 0 à n-2 faire for i in range (0 , n - 1 ) :
Si T[i] > T[i+1] Alors if T[i] > T[i+1]
aux  T[i] aux = T[i]
T[i]  T[i+1] T[i] = T[ i + 1]
T[i+1]  aux T[i + 1 ] = aux
Permut  Vrai Permut = True
FinSi
FinPour
Fin
8) Placer les mots d'une phrase dans un tableau T :
Procédure ph_tableau ( ph: chaîne; @T:tab ; @ n : entier) def ph_tableau ( ph , T , n )
Début ph = ph + " "
ph  ph + " " n=0
n0 p=0
Répéter while p != -1 :
P  position (" ", ph) p = [Link](" ")
Si p ≠ -1 Alors if p != -1
mot  sous_chaine (ph, 0 , p ) mot = ph [ 0 : p ]
T[n]  mot if mot != "" :
n=n+1 T[ n ] = mot
Efface (ph , 0 , p+1] n=n+1
FinSi ph = ph [p+1 : ]
Jusqu'à ( p = -1)
Fin
Procédure ph_tableau ( ph: chaîne; @T:tab ; @ n : entier) def ph_tableau ( ph , T , n )
Début ph = ph + " "
ph  ph + " " n=0
n0 mot = ""
mot  "" for i in range ( len (ph) ) :
pour i de 0 à long( ph ) – 1 Faire if ph [ i ] != " " :
Si ph[i] ≠" " Alors mot = mot + ph [ i ]
mot mot + ph[i] else :
Sinon if mot != "" :
Si mot ≠"" Alors T[ n ] = mot
T[n]  mot n=n+1
nn+1 mot = ""
mot  ""
FinSi
Fin
9) Tri d'un tableau T de n éléments : (tri à sélection , insertion et shell)
procédure tri_selection(n:entier; Procédure tri_insertion(n:entier; @ Procédure tri_shel(n:entier; @ T:tab)
@ t:tab) T:tab) Debut
début Début P0
Pour i de 0 à N-2 Faire Pour I de 1 à N-1 Faire Tant que p<= n faire
PM i AUXT[I] PP*3+1
Pour j de i+1 à N-1 Faire K I Fin tantque
Si T[PM]< T[j] alors Tant que (K>0) et (aux<T[K-1]) Répéter
PM j Faire P P div 3
Fin Si T[K]T[K-1] Pour I de P à N-1 Faire
Si PM# i Alors KK-1 AUXT[I]
Aux  T[i] Fin Tant que K I
T[i]t[PM] T[K]AUX Tant que (K>=P)et(AUX<T[K-P])
T[PM]Aux Fin Pour Faire
Fin Si Fin T[K]T[K-P]
Fin Pour KK-P
Fin Fin Tant que
T[K]AUX
Fin Pour
Jusqu'à P=1
Fin
Conversion entre les bases
Conversion de la base B vers la base 10
Fonnction convb_d (b:entier; ch:chaine):entier def convb_d (b,ch):
debut S=0
S0 P=1
P1 for i in range(len(ch)-1,-1,-1) :

4
 Pour i de long(ch)-1 à 0 (pas=-1) faire if ″0″<=ch[i] <=″9″ :
Si ch[i] dans [″ 0″..″9″] alors nb=int(ch[i])
nbval(ch[i]) else :
sinon nb=ord(ch[i])-55
nbord(ch[i])-55 s=s+nb*P
fin si P=P*b
ss+nb*P retourner s
PP*b
fin pour
retourner S
Fin
Conversion de la base 10 vers la base B
fonction convD_b (b:entier; x :entier):chaine def convb_d (b,x):
début ch=″″
Ch'' while x !=0 :
Tantque x ≠0 faire r=x % b
rx mod b if r<=9 :
si r<=9 alors c=str(r)
cconvch(r) else :
sinon c=chr(55+r)
cchr(55+r) ch=c+ch
fin si x=x // b
chc+ch return ch
xx div b
fin tant que
retourner ch
Fin
Conversion de la base 2 vers la base 16 Conversion de la base 16 vers la base 2
Fonction fn Bin_Hex (CH : chaine de caractère):
Fonction Hexa-Binai (ch: chaine) :chaine
chaine
Début
Début
Bin  " "
Tant que Long (CH) Mod 4 = 0 alors Pour i de 0 à long (ch) faire
Ch  "0"+CH Si ch[i] ∈ ["0".."9"]) alors
Fin Tant que XValeur(Ch[i])
X  Long (CH) div 4 Sinon
Hex  "" X Ord (C)-55
Pour i de 1 à X faire Fin si
z  Sous_Chaîne (CH,0,4) B  "0000"
ch Sous_Chaîne (CH,4,long(ch)) j  3
s0 Répéter
p1 Y  X mod 2
Pour j de 3 à 0 (pas=-1) faire rConvCh (Y)
nbValeur(z[i]) B[j]  Res
s s+ nb*p X  X div 2
pp*2 j  j-1
Fin Pour Jusqu’à X=0
Si s >9 alors Bin  Bin + B
c  chr( s+ 55) Fin Pour
Si non Retourner Bin
cConvch (s) Fin
Fin Si
Hex  Hex+c
Fin Pour
retourner hex
Fin

Rq : pour la base 2 vers 8 ou la conversion 8 vers 2, on remplace le 4 par 3, le 3 par 2 et le "0000" par "000"

5
 Les fichiers Remplissage d’un fichier texte par N chaine alphabétique
Procédure remplir (@ f : fichier texte ; n : Def remplir ( n ) :
entier) F=Ouvrir("[Link]",f, "w")
Début For i in range (n) :
Ouvrir("[Link]",f, "w") Ch=input("siasi une chaine")
Pour i de 0 à (n-1) Faire While not(verif(ch)) :
Répéter Ch=input("retaper une chaine")
Ecrire( "saisir ligne") [Link](ch+"\n")
Lire(ch) [Link]()
Jusqu’à verif(ch)
Ecrire_nl(f,ch)
Fin pour
Fermer(f) fin
Affichage
Procédure affch ( f : fichier texte ; n : entier) Def affich ( n ) :
Début F=Ouvrir("[Link]",f, "r")
Ouvrir("[Link]",f, "w") For i in range (n) :
Pour i de 0 à (n-1) Faire Ch=[Link]()[ :-1]
Lire_lignr(f,ch) Print(Ch)
Ecrire(ch) [Link]()
Fin pour Remarque : [ :-1] pour supprimer le "\n"
Fermer(f) fin
Remplir un fichier texte par des chaînes de caractères non vides. Le remplissage du fichier s’arrête lorsque l’utilisateur
répond par « N » à la question « Voulez-vous continuer la saisie O / N ?».
Procédure Remplissage_Fichier (@ f : fichier texte) def Remplissage_Fichier () :
Début f = open (nomphy, "w")
Ouvrir (nomphy, f , "w") stop=False
Répéter while (stop == False) :
Répéter valid=False
Ecrire ("Saisir votre chaîne : "), Lire (ch) Jusqu’à while valid == False :
ch ≠ "" ch = input("Saisir une phrase : ")
Ecrire_nl (f, ch) valid= (ch != "")
Ecrire ("continuer la saisie O / N ? "), Lire (rep) [Link] (ch+"\n")
Jusqu’à (majus (rep)= "N") rep = input("continuer la saisie O/N ? ")
Fermer (f) stop=[Link]( ) == "N"
Fin [Link]( )
Affichage de contenue de fichier avec leur taille est inconnue
Procédure affch ( f : fichier texte ) Def affich() :
Début f= open("[Link]", "r")
Ouvrir("[Link]",f, "r") ch = [Link]()[ :-1]
Tant que non fin de fichier (f) faire while ch != "" :
Lire_lignr(f,ch) print(ch)
Ecrire(ch) ch = [Link]()[ :-1]
Fin tant que [Link]()
Fermer(f) fin
Remplissage d’un fichier d’enregistrement par N eleve(nom, moyenne)
Procédure remplir (@f :fich ; n : entier) From pickle import dump,load
Début def Remplir (n) :
Ouvrir ("[Link]", f , "rb") f = open ("[Link]", "wb")
Pour i de 0 à n-1 Faire for i in range (0, n) :
Ecrire ("Saisir le nom de l’élève N° ", i) e = { "nom":"", "moy":0 } # ou bien e={}
Lire ([Link]) e["nom"]= input ("nom N°"+ str(i+1) +":")
Ecrire ("Saisir la moyenne de l’élève N° ", i) e["moy"]= float (input( "my N°"+tr(i+1)+":"))
Lire ([Link]) dump (e , f)
Ecrire (f, e) [Link]()
FinPour
Fermer (f)
Affichage d’un fichier d’enregistrement de N eleve
Procédure remplir (@f :fich ; n : entier) From pickle import dump,load
Début def affcih ( n) :
Ouvrir ("[Link]", f , "rb") f = open ("[Link]", "rb")
Pour i de 0 à n-1 Faire for i in range (0, n) :
lire (f, e) e=[Link]()
Ecrire (" le nom N° ", i, "=",e["nom"]) print (" le nom N° ", i, "=",e["nom"])
Ecrire ("moyenne N° ", i, "=",e["moy"]) print ("moyenne N° ", i, "=",e["moy"])
FinPour Fermer (f) [Link]()

6
 Parcours d’un fichier d’enregistrement avec N inconnue
Algo Python (solution 1) Python (solution 2)

Procédure affich (f :fich) def Affichage () : Au moment de remplissage on mettre un compteur

début f = open (nomphy, "rb") pour déterminer la taille de fichier
Ouvrir ("[Link]", f , "rb") fin_fichier = False def remplir() :
Tantque Non Fin_Fichier (f) Faire while fin_fichier == False : f = open ("[Link]", "wb")
Lire (f, e) try : n=0
Ecrire_nl ([Link]) e= load (f) stop=False
Ecrire_nl ([Link]) print (e ["nom"]) while (stop == False) :
FinTantque print (e ["moy"]) e = { "nom":"", "moy":0 }
Fermer (f) except : e["nom"]= input ("nom =")
Fin fin_fichier = True e["moy"]= float (input( "moy=")
[Link] ( ) dump (e,f)
n=n+1
rep = input("continuer la saisie O/N ? ")
stop=[Link]( ) == "N"
[Link]() return n
Transfer d’un fichier vers un tableau et inversement (même travail pour fichier texte et donnée sauf le mode)
Transfer d’un fichier vers un tableau avec n inconnue Transfer d’un tableau vers un fichier avec n connue
Procédure aller (f :fich ; @t :tab ; @n :entier) Procédure aller (f :fich ; @t :tab ; n :entier)
début début
Ouvrir ("[Link]", f , "rb") Ouvrir ("[Link]", f , "rb")
n0 Pour i de 0 à n-1
Tantque Non (Fin_Fichier (f)) Faire Lire (f, t[i]) #pour le fichier texte lire_ligne(f,t[n])
Lire (f, t[n]) #pour le fichier texte lire_ligne(f,t[n]) Fin pour
nn+1 Fermer (f)
FinTantque Fin
Fermer (f) Fin
Transfer d’un tableau vers un fichier python
Procédure retour (@f :fich ; t :tab ; n :entier) Procédure retour (t,n )
début f = open ("[Link]", "wb")
Ouvrir ("[Link]", f , "wb") for i in range(n) :
Pour i de 0 à n-1 faire dump(f,t[i]) #[Link](str(t[i])+"\n") pour le fichier txt
ecire (f, t[i]) # ecri_nl(f,t[i]) pour le fichier texte [Link]()
Fin pour Fin
Fermer (f) Fin
Matrice-remplissage
algorithme python
Procédure remplir (@ m :mat ; n : entier) def remplir (M , n ):
Début for i in range (n) :
Pour i de 0 à (n-1) Faire for j in range (n) :
Pour j de 0 à (n-1) Faire ok = False
Répéter while ok == False :
Ecrire ("entrer un élément de M") M[i,j] = .. (input ("taper elmt de M"))
Lire (M[i,j]) ok = (condition (T[i] )
Jusqu'à ( condition(M[i]) )
Fin pour #-----------PP
Fin pour N=sais()
Fin M=array( [ [ int ( )] * N ] * N )
#------remplissage aléatoire # ou bien avec liste M=[ [0]*n for i in range(n)]
M[i,j]  aléà(Bi,Bs) Remplir(M,n)
Transfer d’une matrice vers un fichier texte ligne par ligne ou colonne par colonne
algorithme python
Procédure transfert (m :mat ; n : entier ; f :fichier texte) def transfer (M , n ):
Début f = open ("[Link]", "w")
Ouvrir ("[Link]", f , "w") for i in range (n) :
Pour i de 0 à (n-1) Faire ch="" # pour chercher la case max max=M[0,i]
ch"" # pour chercher la case max maxM[0,i] for j in range (n) :
Pour j de 0 à (n-1) Faire ch=ch+ M[i,j]
Ch ch +M[i,j] # si par colonne ch=ch+ M[j,i]
# si colonne par Ch ch +M[j,i] [Link](ch+"\n")
Fin pour N=sais()
Ecrire_nl(F,ch) M=array( [ [ int ( )] * N ] * N )
Fin pour Remplir(M,n)
Fin Transfer(M,n)

7
Transfer d’un fichier texte vers une matrice (le nombre de ligne de la matrice est la taille de fichier, le nombre des
colonnes désigne la plus long chaine de f)
algorithme python
Procédure transfert (m :mat ; n : entier ; f :fichier texte) def transfer (M , n ):
Début f = open ("[Link]", "w")
Ouvrir ("[Link]", f , "r") Ouvrir ("[Link]", f , "r")
Lnblign(f) L=nblign(f) #fonction qui détermine le nbr de ligne
Cnbcolonne C=nbcolonne #fonction qui détermine le nbr de colonne
Pour j de 0 à (L-1) Faire for i in range (L) :
Lire_ligne(f,ch) ch=[Link]()
Pour j de 0 à (long(ch)-1) Faire for j in range (len(ch)) :
M[i,j] ch[j] M[i,j] =ch[j]
Fin pour [Link]()
Fin pour Fin
Triangle de pascal
algorithme python
Procédure triangle (@m :mat ; n : entier ) def triangle (M , n ):
Début for i in range (n) :
Pour i de 0 à (n-1) Faire for j in range (0,i+1) :
Pour j de 0 à (i) Faire if Si i=j ou j=0 :
Si i=j ou j=0 alors M[i,j] =1
M[i,j] 1 Else :
Sinon M[i,j]= M[i-1,j]+ M[i-1,j-1]
M[i,j] M[i-1,j]+ M[i-1,j-1] #----PP
Fin pour N=sais()
Fin pour Fin M=array( [ [ int ( )] * N ] * N ) Triangle(m,n)
Approximation
Point fixe (algorithme) f(x)=√𝒙𝒙 + 𝟏𝟏 Valeur approché de π 2/6=1 +1/22 +1/32 +……à eps prés
Fonction pointfix(eps :réel) :réel Fonction euleur (eps :réel) :réel
Début Début
pa 1 S21, i2
répéter Répéter
pppa S1 S2
paraciné_carré(pp S2  S1 + 1/carré (i)
jusqu’à pa-pp<=eps i  i +1
retourner pa Jusqu’à (RacineCarrée (6*S2) - RacineCarrée (6*S1)) <eps
fin Retourner RacineCarrée (6*S2))
Fin
Calcul d’air et optimisation
Fonction Rectangles (a, b : Réel ; n : Entier) : Réel Fonction Trapèzes (a1, b1 : Réel ; n1 : Entier) : Réel
Début Début
h (b – a) / n h (b1- a1) / n1
xa xa1
S0 S 0
Pour k de 1 à n1 faire Pour k de 2 à n1 faire
S  S + (1/1+sqr(x)) S  S + (1/1+sqr(x))+ (1/1+sqr(x+h))
Xx+h xx+h
Fin Pour Fin Pour
Retourner S* h Fin retourner S * h/2 Fin
Le terrain de football est un rectangle de longueur L, de Optimisation
largeur D et de surface S. La piste d’athlétisme est de fonction Longueur_Max(eps, p:réel):réel
longueur P et former par les deux arrêts parallèles du début
terrain de football (de longueur 2*L) et les deux demi- Lopt  0
cercles de diamètre D (de longueur 𝝅𝝅 * D):Puisque S = L * Smax  0
D et P = 2 * L + 𝝅𝝅 * D Alors S = L * (P – 2 * L) / 𝝅𝝅 Etant Répéter
donné que L varie de 0 à P/2, écrire un algorithme d’une Lopt  Lopt+epsilon
fonction qui permet de déterminer, à eps près, la longueur S  Smax
optimale Lopt correspondante à la surface maximale Smax ← Lopt*(p-2*Lopt)/Pi
Smax du terrain, sachant que eps et P sont saisis dans Jusqu'à ((Smax - S) <=eps)ou(Lopt >=p/2)
l’algorithme du Retourner Lopt - epsilon
Fin

8
Règle de divisibilité
Divisibilité par 13
Exemple : Pour vérifié si le nombre 1612311857 est divisible par 13, on applique la règle de divisibilité par 13 décrite par
l’algorithme précédent :
- On regroupe les chiffres du nombre par des blocs de trois chiffres en commençant à partir des unités :
1 | 612 | 311 | 857
- On ajoute alternativement des "–" et des "+" entre les blocs en commençant par placer un "–" pour le premier bloc à droite : 1 –
612 + 311 – 857
- On effectue l’opération ainsi obtenue :1 – 612 + 311 – 857 = –1157
- La valeur absolue du résultat obtenu (1157) est divisible par 13 donc 1612311857 est divisible par 13.
Fonction ver_div_13(x :entier) :booléen Fonction ver_div_13(x ) :
Début ch = str(x)
ch  convch(x) while len(ch) % 3 != 0 :
tant que long(ch) mod 3 ≠ 0 faire ch =″0″+ch
ch ″0″+ch nb=len(ch) // 3
fin tant que sign=-1
nblong(ch) div 3 s=0
sign-1 for i in range (nb) :
s0 a= ch[len(ch)-3 :len(ch)] # a=ch[-3 :]
pour i de 0 à nb-1 faire ch= ch[0 :len(ch)-3] # ch=ch[ :-3]
a souschaine(ch,log(ch)-3,long(ch)) s=s+int(a)*sign
ch souschaine(ch,0,long(ch)-3) sign=-sign
ss+valeur(a)*sign return abs(s) % 13==0
sign-sign
fin pour
retourner abs(s) mod 13=0
fin

Les fonctions sur les types numériques

En Algorithmique En python
aArrondi(D) A=round(D)
bracineCarre(D) B=[Link](D) OU ( D**(1/2))
cAlea (VI, VF) C=[Link](VI,VF)
dEnt(X) D=int(x)
eAbs(x) E=abs(x)
fSin(x),cos(x),… F=[Link](), [Link](),…
Les fonctions sur les types caractère
Algorithmique Python Rôle
d ← ord (c) d = od (c) Retourne le code ASCII du caractère c.
c ← chr (d) c = chr (d) Retourne le caractère dont le code ASCII est d.

Les fonctions sur les types chaine caractère

Algo En Python Rôle Exemple
Long(ch) len(ch) Retourne le nombre de Caractères de Ch="Info"
la chaine Long(ch) donne 4
Pos(ch1,ch2) [Link](ch1) Retourne la première position de ch1 Ch1="fo"
dans ch2,sinon elle retourne -1. Ch2="info" Pos(ch1,ch2) Donne 2
Convch(x) str(x) Retourne la conversion d’un nombre x X=12
en une chaîne . Convch(x) Donne "12"
Estnum(ch) [Link]() Retourne Vrai si la chaîne ch est Ch="10"
[Link]() convertible en une valeur numérique, Estnum(ch)
[Link]() elle retourne Faux sinon. Donne Vrai
Valeur (ch) int(ch) float(ch) Retourne la conversion d’une chaîne Ch="15"
ch en une valeur numérique, si c’est Valeur(ch) Donner 15
possible.
Sous_chaine(ch,d,f) Ch[d:f] Retourne une partie de la chaîne ch à Ch="Algorithme"
partir de la position d jusqu’à la Sous_chaine(ch,2,6)
position f-1. Donne "gori"
Effacer (ch, d, f) Ch[:d]+ch[f:] Efface des caractères de ch à partir de Ch="Algorithme"
la position d jusqu’à la position f-1. Effacer(ch,2,6) Donne ch="Althme"
Majus (ch) [Link]() Convertit ch en majuscules. Ch="info2021"
Majus(ch) donne "INFO2021"
[Link]() Convertit ch en miniscule.
+ + Concaténer deux chaines "inf"+"2022" donne "info2022"

9
Exemple structure conditionnelle (selon (match))
Algorithme Nature while True:
Début c=input("c = ").upper()
Lire(c) if len(c)==1:
selon majus(c) break
"A".."Z" : match c:
si c ∈ {"A","E","U","I","O","Y"}alors case c if "A"<=c<="Z" :
Ecrire("Voyelle") if c in {"A","E","U","I","O","Y"}:
Sinon print("Voyelle")
Ecrire("Consonne") else:
"0".. "9" : print("Consonne")
Ecrire ("Chiffre") case c if "0"<=c<="9" :
Sinon print("Chiffre")
Ecrire ("Symbole") case _:
Fin Selon print("Symbole")
Fin
Matrice en python

from numpy import array

• Remplir une matrice de l lignes et c colonnes par • T=array([[int()]*c]*l) Matrice des entiers
des entiers aléatoire compris entre 5 et 20 • T=array([[float()]*c]*l) Matrice des réels
• T=array([[bool()]*c]*l) Matrice des booléens
Procédure remplir_Mat(@ M:Mat;l,c:entier) • T=array([str()]*c]*l) Matrice des caractères
Début • T=array([[str]*c]*l)) Matrice des chaines
Pour i de 0 à l-1 faire
Pour j de 0 à c-1 faire ---------numpy---------------------
M[i,j]Alea(5,20) from numpy import array
Fin pour from random import randint
Fin pour def remplir_Mat(l,c) :
Fin M=array([[int()]*c]*l)
for i in range(l) :
for j in range(c) :
M[i,j]=randint(5,20)
return M
--------------list ------------------
from random import randint
def remplir_Mat(l,c) :
M=[0]*l
for i in range(l) :
M[i]=[0]*c
for j in range(c) :
M[i][j]=randint(5,20)
return M
Enregistrement en python

Exemple : remplissage d’un tableau d’enregistrement par tableau d’enregistrement

N élevés. • from numpy import array
Procédure remplir_Eng(@T:Tab;N:entier) T=array([{}]*N)
Début # pour le liste list→ T=[{}]*N
Pour i de 0 à l-1 faire for i in range(N):
Lire(T[i].nom) T[i]={}
Lire(T[i].age) T[i]["nom"]=input("Nom = ")
Lire(T[i].moy) T[i]["age"]=int(input("Age = "))
Fin pour T[i]["moy"]=float(input("moyenne = "))
Fin

10