Sommaire

1- Module puissance : 2
Schéma: 2
Analyse : 2
Algorithme : 2
1- Module nb_pos (nombre de position) : 2
Schéma : 2
Analyse : 3
Algorithme : 3
2- Module aj_pos : 3
Schéma : 3
Analyse : 3
Algorithme : 4
3- Module compose : 4
Schéma : 4
Analyse : 4
Algorithme : 4
4- Module freq : 5
Schéma : 5
Analyse : 5
Algorithme : 5
5- Module concat : 6
Schéma : 6
Analyse : 6
Algorithme : 6
6- Module croissant : 7
Schéma : 7
 Analyse : 7
Algorithme : 7
7- Module décroissant : 8
Schéma : 8
Analyse : 8
Algorithme : 8
8- Module inv : 9
Schéma : 9
Analyse : 9
Algorithme : 9
10- Module swap : 10
Schéma : 10
Analyse : 10
Algorithme : 10
11-Module ext_pos : 10
Schéma : 10
Analyse : 11
Algorithme : 11
12-Module permutt : 11
Schéma : 11
Analyse : 11
Algorithme : 11
13- Module facto : 12
Schéma : 12
Analyse : 12
Algorithme : 12
14- Module pgcd : 12
Schéma : 12
 Analyse : 12
Algorithme : 13
15-Module poids_f : 13
Schéma : 13
Analyse : 13
Algorithme : 14
16-Module ppcm : 14
Schéma : 14
Analyse : 14
Algorithme : 14
17-Module prem : 15
Schéma : 15
Analyse : 15
Algorithme : 15
18-Module prod_ch : 15
Schéma : 15
Analyse : 16
Algorithme : 16
19-Module som_ch : 16
Schéma : 16
Analyse : 16
Algorithme : 17
20-Module som_div : 17
Schéma : 17
Analyse : 17
Algorithme : 18
21-Module supp_pos : 18
Schéma : 18
 Analyse : 18
Algorithme : 18
22-Module ver : 19
Schéma : 19
Analyse : 19
Algorithme : 19
23- Module aj_nb : 19
Schéma : 19
Analyse : 20
Algorithme : 20
24-Module supp_nb : 20
Schéma : 20
Analyse : 20
Algorithme : 21
25-Module devl_pol : 21
Schéma : 21
Analyse : 21
26- Module conv_de_dec: 22
Schéma : 22
Analyse : 22
Algorithme : 22
27- Module conv : 23
Schéma : 23
Analyse : 23
Algorithme : 23
28- Module arrang : 23
Schéma : 23
Analyse : 24
 Algorithme : 24
29- Module comb: 24
Schéma: 24
Analyse: 24
Algorithme: 24
30- Module eq: 24
Schéma: 24
Analyse: 25
Algorithme: 25
31- Module tress : 26
Schéma : 26
Analyse : 26
Algorithme : 26
32- module supp_ch : 26
Schéma : 26
Analyse : 27
Algorithme : 27
Module ent : 28
Schéma : 28
Analyse : 28
Analyse : 28
Module ad_bin : 28
Schéma : 28
Analyse : 29
Algorithme : 29
Module decal_g : 30
Schéma : 30
Analyse : 30
 Algorithme : 30
Module decal_d : 30
Schéma : 30
Analyse : 30
Algorithme : 31
Module max_ch : 31
Schéma : 31
Analyse : 31
Algorithme : 31
Module min_ch : 32
Schéma : 32
Analyse : 32
Algorithme : 32
Module permutch : 32
Schéma : 32
Analyse : 33
Algorithme : 33
Module sym : 33
Schéma : 33
Analyse : 33
Algorithme : 33
 1- Module puissance :

Schéma:

Analyse :
- Pour i variant de 1 à P on multiplie Nb par N (Nb est initialement à 1).
Algorithme :
Fonction puiss (N, P : entier) : entier
Var Nb, i : entier
DEBUT
Nb 1
Pour i allant de 1 à p faire nb nb*n
Puiss nb
FIN

1- Module nb_pos (nombre de position) :

Schéma :
Analyse :
- On décompose N chiffre par chiffre et pour chaque chiffre on fait
Nb​ ​Nb+1 (Nb est initialement à 0).
Algorithme :
Fonction nb_pos (N : Entier) : Entier
Var Nb : Entier
DEBUT
Nb 0
Tant que n<>0 faire
DTQ
Nb Nb+1
N N div 10
FTQ
Nb_pos Nb
FIN

2- Module aj_pos :

Schéma :

Analyse :
On compose le nouveau nombre en concaténant de droite à gauche les
positions de N inférieures à pos, puis le chiffre c, puis les autres positions de N.
Algorithme :
Fonction aj_pos (N, C, Pos : Entier) : Entier
Var P : Entier
Fonction puiss ( n, p : Entier) : Entier
DEBUT
P puiss (10, pos-1)
Aj_pos N mod P+C*P+N div P*P*10
FIN

3- Module compose :

Schéma :

Analyse :
- Pour i allant de 1 à B on fait N​ ​10*N+A.

Algorithme :
Fonction compose (A, B : Entier) : Entier
Var i, N : Entier
Début
N 0
Pour i 1 à B faire N 10*N+A
Compose N
Fin
 4- Module freq :

Schéma :

Analyse :
- On décompose N chiffre par chiffre et pour chaque chiffre de N on vérifie
s’il est égal à C alors cpt​ ​cpt+1 (cpt est initialement à 0).
Algorithme :
Fonction freq (N, C : Entier) : Entier
Var cpt : Entier
Début
Cpt 0
Tant que N<>0 faire
DTQ
Si N mod 10=C alors cpt cpt+1
N n div 10
FTQ
Freq cpt
Fin
 5- Module concat :

Schéma :

Analyse :
On multiplie A par 10 puissance le nombre de chiffres de B, et faire sa
somme avec B.
Algorithme :
Fonction concat (A, B : Entier) : Entier
Fonction puiss (N, M : Entier) : Entier
Fonction nb_pos (n : Entier) : Entier
Début
Concat a*puiss (10, nb_pos(B)) +B
Fin
 6- Module croissant :

Schéma :

Analyse :
On génère des chiffres i de 1 à 9 et pour chaque chiffre i on fait :

On compte freq le nombre d’apparition de i dans N.

On calcule le nombre M qui est composé du chiffre i répété ‘’freq’’ fois.

On concatène m à droite de N1 (N1 est initialement à 0).

Algorithme :
Fonction croissant (N : entier) : Entier
Var i, N1, M: Entier
Fonction puiss (A, B : Entier) : Entier
Fonction compose (i, m : Entier) : entier
Fonction freq (n, i : Entier) : Entier
Début
Pour i allant de 1 à 9 faire
DPOUR
M compose (i, freq (N, i))
N1 N1+M*puiss(10,freq(N, i))
FPOUR
Croissant N1
Fin
 7- Module décroissant :

Schéma :

Analyse :
On génère des chiffres i de 9 descendants à 0, pour chaque nombre i on fait :

On compte freq le nombre d’apparition de i dans N.

On compte le nombre M qui est composé du chiffre i répété (freq) fois.

On compose m à droite de N1 ( N1 est initialement à 0).

Algorithme :
Fonction décroissant (N : Entier) : Entier
Var M, N1, i : Entier
Fonction freq ( n, i : Entier ) : Entier
Fonction compose (A, B : Entier) : Entier
Fonction puiss (A, B : Entier) : Entier
Début
I 9
Tant que i>=0 faire
DTQ
M compose (i, freq(N, i))
N1 N1*puiss(10,freq(n,i))+M
I i-1
FTQ
Décroissant N1
Fin
 8- Module inv :

Schéma :

Analyse :
- On décompose N chiffre par chiffre en le divisant successivement par 10,
et à chaque fois on compose N1 de gauche à droite par les restes.

Algorithme :
Fonction inv (N : Entier) : Entier
Var N1 : Entier
Début
N1 0
Tant que N<>0 faire
DTQ
N1 10*N1+N mod 10
N N div 10
FTQ
Inv N1
Fin
 10- Module swap :

Schéma :

Analyse :
- swap​ ​N+(poids faible-poids fort)*10 (puissance le nombre de chiffre de
N-1)+poids fort-poids faible.
Algorithme :
Fonction swap (N : Entier) : Entier
Var pf, pfb ,p: Entier
Fonction puiss( N : Entier) : Entier
Fonction nb_pos( N : Entier) : Entier
Début
Pfb n mod 10
P puiss(10,nb_pos(n)-1)
Pf n mod p
Swap N+p*(pfb-pf)+pf-pfb
Fin

11-Module ext_pos :

Schéma :
Analyse :
- Ext_pos​ ​ N divisé par (10 puissance (pos-1)) modulo (10 puissance k).
Algorithme :
Fonction ext_pos (N, pos : Entier) : Entier
Fonction puiss( N : Entier) : Entier
Début
Ext_pos N div puiss(10,pos-1) mod puiss(10,k)
Fin

12-Module permutt :

Schéma :

Analyse :
On sauvegarde la valeur de A dans une variable intermédiaire X, et on donne la
valeur B à A, puis on donne la valeur de X à B.

Algorithme :
Procédure permutt(var : A, B : Entier)
Var x : Entier
Début
X A
A B
B X
Fin
13- Module facto :

Schéma :

Analyse :
On génère des nombres i de 1 à N, pour chaque nombre i on fait Nb Nb*i (Nb
est initialement à 1).
Algorithme :
Fonction facto (N : Entier) : Entier
Var Nb, i : Entier
Début
Nb 1
Pour i 1 à N faire Nb Nb*i
Facto Nb
Fin

14- Module pgcd :

Schéma :
Analyse :
- Si A<B on permute entre A et B.
- On utilise l’algorithme d’Euclide :
On divise successivement A par B et à chaque fois on fait
● On sauvegarde A dans X.
● A​ B​
● B​ ​ le reste de la division de X par B
Ce processus s’arrête lorsque B =0. Et donc le pgcd est A.
- Pour les nombre négatif on prend la valeur absolue.
Algorithme :
Fonction pgcd (A, B : Entier) : Entier
Var x : Entier
Procédure permut (var : A, B : Entier)
Début
A abs(A)
B abs(b)
Si A<B alors permutt(A,B)
Répéter
X A mod B
A B
B X
Jusqu’à b=0
Pgcd A
Fin

15-Module poids_f :

Schéma :
Analyse :
On divise N par 10 puissance ( nb_pos(n)-1) et le quotient représente le poids
fort de N.

Algorithme :
Fonction poids_f (N : Entier) : Entier
Fonction nb_pos (N : entier) : Entier
Fonction puiss ( a,b : entier) : entier
Début
Poids_f N div puiss(10,nb_pos(N)-1)
Fin ;

16-Module ppcm :

Schéma :

Analyse :
- On génère des nombre i à partir de 1, et on arrête le processus quand a*i
est divisible par B.
- Le ppcm est a*i.
- Pour les nombres négatifs on fait la valeur absolue.
Algorithme :
Fonction ppcm (A, B : Entier) : Entier
Var i : Entier
Début
I 1
Tant que a*i mod b<>0 faire i i+1
Ppcm a*i
Fin

17-Module prem :

Schéma :

Analyse :
- On génère des diviseurs d à partir de 2, et on arrête le processus lorsque
(d> N div 2) ou N mod d=0.
- Si (d>N div 2) et (N>1) alors N est premier, sinon il ne l’est pas.

Algorithme :
Fonction prem ( N : Entier) : booléen
var d : Entier
Début
d 2
tant que (d<=N div 2) et (N mod d<>0) faire d d+1
Prem (d>N div 2) et (N>1)
Fin ;
18-Module prod_ch :

Schéma :

Analyse :
- On décompose N chiffre par chiffre et pour chaque chiffre c de N on fait
pr​ ​pr*c (pr est initialement à 1).
Algorithme :
Fonction prod_ch (N : Entier) : Entier
Var pr : Entier
Début
Pr 1
Tant que n<>0 faire
DTQ
Pr Pr*N mod 10
N N div 10
FTO
Prod_ch pr
Fin

19-Module som_ch :

Schéma :
Analyse :
- On décompose N chiffre par chiffre et on cumule chaque chiffre c de N
dans : s​ ​s+c (s est initialement à 0).

Algorithme :
Fonction som_ch( N : Entier) : Entier
Var s :Entier
Début
S 0
Tant que n<>0 faire
DTQ
S S+N mod 10
N N div 10
FTQ
Som_ch S
Fin

20-Module som_div :

Schéma :

Analyse :
- On génère des nombre d entre 1 et N div 2, et pour chaque nombre d si
N mod d=0 alors s​ ​s+d.
Algorithme :
Fonction som_div( N :Entier) :Entier
Var d, s : Entier
Début
S 0
Pour d 1 à N div 2 faire
DPOUR
Si n mod d=0 alors s s+d
FPOUR
Som_div s
Fin

21-Module supp_pos :

Schéma :

Analyse :
Supp_pos le nombre composé des chiffres de N dont leur position est inférieur
à pos+(le nombre composé des chiffres de N dont leur position est supérieur à
pos)*10 puissance (pos-1).
Algorithme :
Fonction supp_pos (N, pos : entier) : entier
Var p : Entier
Fonction puiss (A, B : entier) : entier
Début
P puiss(10,pos-1)
Puiss N mod p+N div (p*10)*p
Fin

22-Module ver :

Schéma :

Analyse :
- On génère des chiffres i à partir de 0, et on arrête le processus si la
fréquence de i dans n est supérieur strictement à 1 ou lorsque i atteint le
9.
- Si freq(N,i)<=1 alors la condition est vérifiée sinon elle ne l’est pas.
Algorithme :
Fonction ver (N : Entier) : Entier
Var i : Entier
Fonction freq (N,i : Entier) : Entier
Début
I 0
Tant que (freq(N,i)<=1) et (i<9) faire i i+1
Ver freq(N,i)<=1
Fin ;
23- Module aj_nb :

Schéma :

Analyse :
- Aj_nb​ ​ la partie de chiffres de N dont leur position est inférieure à pos+
M*10​pos-1 ​+(la partie de chiffres de N dont leur position est supérieure à
pos)*10​pos+nb_pos(M)-1​.
Algorithme :
Fonction aj_nb (N, M, pos : Entier) : Entier
Var P : Entier
Fonction puiss (A, B : Entier) : Entier
Fonction nb_pos (N : Entier) : Entier
Début
P puiss (10, pos-1)
Aj_pos N mod P+M*P+N div P*P*puiss (10, nb_pos(M))
Fin

24-Module supp_nb :

Schéma :
Analyse :
- Supp_nb​ ​la partie de chiffres de N dont leur position est inférieure à
pos+(la partie de chiffres de N dont leur position est supérieurs à
pos+m-1)*10​pos-1​.

Algorithme :
Fonction supp_nb (N, Pos, M : Entier) : Entier
Var P : Entier
Fonction puiss (N : Entier) : Entier
Début
P puiss (10, pos-1)
Supp_nb N mod P+N div puiss (10, pos+M-1)*P
Fin

25-Module devl_pol :

Schéma :

Analyse :
- On décompose N chiffre par chiffre et pour chaque chiffre c on fait
de c -1 ​
● S​ ​S+c*b position
​ (S est initialement à 0).
Fonction devl_pol (N, b : Entier) : Entier
Var S, p : Entier
Début
S 0
P 1
Tant que N<>0 faire
DTQ
S S+ N mod 10*P
P P*b
N N div 10
FTQ
Devl_pol S
Fin

Algorithme :

26- Module conv_de_dec:

Schéma :

Analyse :
On divise successivement N par b, et on compose S le nouveau nombre de
droite à gauche par les restes de la division.
Algorithme :
Fonction conv_de_dec (N, b : Entier) : Entier
Var S, p : Entier
Début
S 0
P 1
Tant que N<>0 faire
DTQ
S S+N mod b*P
P P*10
N N div b
FTQ
Cov_de_dec S
Fin

27- Module conv :

Schéma :

Analyse :
- Convertir N vers la base décimale.
- Puis, le convertir de la base 10 vers la base c.
Algorithme :
Fonction conv (N, b, c : Entier) : Entier
Fonction conv_de_dec (N, b : Entier) : Entier
Fonction devl_pol (N, b : Entier) : Entier
Début
Conv conv_de_dec(devl_pol(N, b), c)
Fin

28- Module arrang :

Schéma :

Analyse :
Arrang n!/p !

Algorithme :
Fonction arrang (n, p : Entier) : Entier
Fonction facto (n : entier) : Entier
Début
Arrang facto(n)/facto(p)
Fin

29- Module comb:

Schéma:
Analyse:
Comb n!/(p!*(n-p)!)

Algorithme:
Fonction comb (n, p: Entier): Entier
Fonction facto (n : Entier) : Entier
Début
Comb facto(n)/(facto(p)*facto(n-p))
Fin

30- Module eq:

Schéma:

Analyse:
- On calcule ∆.
Si ∆>0 alors
● X1​ ​(-b-sqr(∆))/(2*a)
● X2​ ​(-b+sqr(∆))/(2*a)
● N​ ​2
Si ∆=0 alors
● X1​ ​-b/(2a)
● X2​ ​x1
● N​ ​1
Si ∆<0 alors N​ ​0
Algorithme:
Procédure eq (a, b, c: Entier; var: x1, x2, n : Entier)
Var ∆ : Entier
Début
∆ b*b-4*a*c
X1 0
X2 0
Si ∆>0 alors
DSI
X1 (-b-sqrt(∆))/(2*a)
X2 (-b+sqrt(∆))/(2*a)
N 2
FSI
Si ∆=0 alors
DSI
X1 -b/(2a)
X2 x1
N 1
FSI
Si ∆<0 alors n 0
Fin

31- Module tress :

Schéma :
Analyse :
- on décompose n1 et n2 chiffre par chiffre, et on compose notre nombre
en concaténant un chiffre de n1, puis un chiffre de n2 et ainsi de suite
jusqu’à ce qu’un des deux nombres n1 et n2 s’annulent.
Algorithme :
fonction tress (n1, n2 : Entier) : entier
var n : entier
Début
N 0
Tant que (n1<>0) et (n2<>0) faire
DTQ
N n*100+n1 mod 10*10+n2 mod 10
N1 n1 div 10
N2 n2 div 10
FTQ
Tress n
Fin

32- module supp_ch :

Schéma :
Analyse :
- on décompose n chiffre par chiffre et pour chaque chiffre i de n on fait :
si i<>c alors nb​ ​10+i*p tel que p est une puissance de 10.

Algorithme :
Fonction supp_ch (n, c : entier) : entier
Var nb, p : entier
Début
Nb 0
P 1
Tant que n<>0 faire
DTQ
Si n mod 10<>c alors
dsi
nb nb+n mod 10*p
P p*10
fsi
N n div 10
FTQ
Supp_ch nb
Fin
Module ent :

Schéma :

Analyse :
- Si trunc(n)<=n alors trunc(n) est la partie entière de n.
- Sinon trunc(n)-1 est la partie entière de n.
Analyse :
Fonction ent ( n : réel) : entier
Début
Si trunc(n)<=n alors ent trunc(n)
Sinon ent trunc(n)-1
Fin

Module ad_bin :

Schéma :
Analyse :
- On décompose A et B chiffre par chiffre, et à chaque fois on fait :
● S ​ ​(A mod 10+B mod 10+R) mod 2
● R ​ ​(A mod 10+B mod 10+R) div 2
● C​ ​c+s*p (tel que c est initialisé à 0 et p est une puissance de 10)
- A la fin on fait c​ ​c+R*p

Algorithme :
Fonction ad_bin ( a, b : entier) : entier
Var c, s, r, p : entier
Début
C 0
R 0
S 0
P 1
Tant que (A<>0) ou (B<>0) faire
DTQ
S (A mod 10+B mod 10+R) mod 2
R (A mod 10+B mod 10+R) div 2
C C+S*P
P p*10
A A div 10
B B div 10
FTQ
Ad_bin C+R*P
Fin

Module decal_g :

Schéma :
Analyse :
Decal_g​ ​N mod 10​nb_pos-1​*10+poids_f(n)

Algorithme :
Fonction decal_g (n : entier) : entier
Fonction nb_pos (n : entier) : entier
Fonction puiss (a, b : entier) : entier
Var p : entier
Début
P puiss(10,nb_pos(n)-1)
Decal_g n mod p*10+n div p
Fin

Module decal_d :

Schéma :

Analyse :
- Decal_d​ ​n div 10+n mod 10* 10​nb_pos-1
Algorithme :
Fonction decal_d (n : entier) : entier
Fonction nb_pos (n : entier) : entier
Fonction puiss ( a,b : entier) : entier
Début
Decal_d n div 10+ n mod 10*puiss (10,nb_pos(n)-1)
Fin
Module max_ch :

Schéma :

Analyse :
- On décompose N chiffre par chiffre et pour chaque chiffre c de n si pg<c
alors pg​ ​c (pg est initialement à n mod 10)

Algorithme :
Fonction max_ch (n : entier) : entier
Var pg : entier
Début
Pg n mod 10
Tant que n<>0 faire
DTQ
Si pg<n mod 10 alors pg n mod 10
N n div 10
FTQ
Max_ch pg
Fin

Module min_ch :

Schéma :
Analyse :
- On décompose N chiffre par chiffre et pour chaque chiffre c de n si pp>c
alors pp​ ​c (pp est initialement à n mod 10)
Algorithme :
Fonction min_ch (n : entier) : entier
Var pp : entier
Début
Pp n mod 10
Tant que n<>0 faire
DTQ
Si pp>n mod 10 alors pp n mod 10
N n div 10
FTQ
Min_ch pp
Fin

Module permutch :

Schéma :

Analyse :
Permut_ch n+10​a-1​(chiffre(b)-chiffre(a))+10​b-1​(chiffre(a)-chiffre(b))
Algorithme :
Fonction permut_ch (n, a, b : entier) : entier
Var c : entier
Fonction puiss (d, e : entier) : entier
Fonction ext_pos (n, pos, k : entier) : entier
Début
C ext_pos(n,a,1)-ext_pos(n,b,1)
Permut_ch n+c*(puiss(10,b-1)-puiss(10,a-1))
Fin

Module sym :

Schéma :

Analyse :
- On vérifie le nombre n1 composé des chiffres de n dont leurs position est
inférieur ou égale à nb_pos div 2, et le nombre n2 composé de restes des
chiffres de n sont égaux.

Algorithme :
Fonction sym (n : entier) : booléen
Fonction nb_pos (n : entier) : entier
Fonction puiss (a, b : entier) : entier
Début
 Sym n mod puiss (10,nb_pos(n) div 2)=n div puiss(10, nb_pos(n) div2)
Fin

Module aleatoire:

Schéma:

Analyse:
- Aleatoire​ ​un nombre aléatoire inférieur à (b-a) + le nombre a.

Algorithme:
Fonction alea (a, b : entier) : entier
Début
Aleatoire randomize(b-a)+a
Fin

Remarque: on doit écrire "randomize" au début du programme dans lequel on

utilise cette fonction.