algorithme pascal

Modules de révision ]

algorithme pascal

0) DEF PROC saisie ( var n :entier) 1) Répéter

Ecrire('' n='') Lire(n)

Jusqu’à ( n dans [10..25]) 2) Fin remplir

RQ : la condition de la boucle répéter.. jusqu’à dépend de l’énoncé.

Exple : n strictement positif et pair ( n >0) et (n mod 2 =0)

Procedure saisie (var n :integer) ; Begin

Repeat

Writeln('n=') ; Readln(n) ;

Until( n in [10..25]) ; End ;

( n >0) and (n mod 2 =0)

Remplissage d’un tableau par n entiers composé de 3 chiffres

algorithme pascal

0) DEF PROC remplir ( var T :tab ; n :entier) 1) Pour i de 1 à n faire

Répéter

Ecrire(''T['',i, '']= '') Lire(T[i])

Jusqu’à ( T[i] dans [100..999]) Fin pour

2) Fin remplir

TDOL

Objet Nature/type rôle

i Var/entier compteur

RQ : la condition de la boucle répéter.. jusqu’à dépend de l’énoncé (le contenu des éléments de T)

Procedure remplir( Var T :tab ; N :integer) ; Var i :integer ;

Begin

For i :=1 to n do Repeat

Writeln('T[',i, ']= ') ; Readln(T[i]) ;

Until(T[i] in [100..999]) ; End ;

Remplissage d’un tableau aléatoirement (au hasard) par n entiers composé de 4 chiffres

algorithme pascal

0) DEF PROC remplir ( var T :tab ; n :entier) 1) Pour i de 1 à n faire

T[i] 1000+aléa(9000) Fin pour

2) Fin remplir

TDOL

Objet Nature/type rôle

i Var/entier compteur

Procedure remplir( Var T :tab ; N :integer) ; Var i :integer ;

Begin

For i :=1 to n do Begin

Randomize ;

T[i] := 1000+ random(9000) ; End ;

End ;

Remplissage d’un tableau aléatoirement (au hasard) par n lettres alphabétiques majuscules

algorithme pascal

0) DEF PROC remplir ( var T :tab ; n :entier) 1) Pour i de 1 à n faire

T[i] chr(65+aléa(26)) Fin pour

2) Fin remplir

TDOL

Procedure remplir( Var T :tab ; N :integer) ; Var i :integer ;

Begin

For i :=1 to n do Begin

Randomize ;

Objet Nature/type rôle

i Var/entier compteur

T[i] := chr(65+random(26)) ; End ;

End ;

Remplissage d’un tableau par n entiers dans l’ordre croissant

algorithme pascal

0) DEF PROC remplir ( var T :tab ; n :entier) Ecrire(''T[1]= ''), Lire(T[1])

1) Pour i de 2 à n faire Répéter

Ecrire(''T['',i, '']= '') Lire(T[i])

Jusqu’à ( T[i] >T[i-1]) Fin pour

2) Fin remplir

TDOL

Objet Nature/type rôle

i Var/entier compteur

Procedure remplir( Var T :tab ; N :unteger) ; Var i :integer ;

Begin

Writeln('T[1]= ') ; Readln(T[1]) ; For i :=1 to n do Repeat

Writeln('T[',i, ']= ') ; Readln(T[i]) ; Until(T[i] >T[i-1]) ; End ;

Vérification de la validité d’une chaine(chaine qui contient que des chiffres et de longueur 15)

algorithme pascal

0) DEF FN valide (ch :chaine) :booléen 1) Testvrai

2) J0 3) Répéter Jj+1

Si(non(ch[j] dans[''0''.. ''9''])) alors testfaux Finsi

Jusqu’à((test=faux) ou(j=long(ch))) 4) Validetest et (long(ch)=15)

5) Fin valide

TDOL

Objet Nature/type rôle J

test Var/entier

Var/booléen Compteur résultat

Function valide(ch :string) :boolean ; Var j :integer ;

Test :boolean ; Begin

Test :=true ; J :=0 ; Repeat J :=j+1 ;

If(not(ch[j] in['0'.. '9'])) then test := false ; Until((test=false) or(j=length(ch))) ; Valide := test and(length(ch)=15) ; End ;

Vérification de la validité d’une chaine(chaine qui contient que des chiffres et de longueur 9)

RQ : on peut utiliser la fonction précédente juste modifier la valeur de la condition de la longueur par 9.

Cette fonction n’est valable que pour une chaine de longueur inférieure ou égale à 9.

algorithme pascal

0) DEF FN valide (ch :chaine) :booléen 1) Valeur (ch,x,e)

2) Valide(e=0)et (long(ch)=9) 3) Fin valide

TDOL

Objet Nature/type rôle

x

e Var/entier long

Var/entier Valeur de ch erreur

Function valide(ch :string) :boolean ; Var x :longint;

e :integer ; Begin Val(ch,x,e) ;

Valide := (e=0) and(length(ch)=9) ; End ;

Vérification de la validité d’une chaine(chaine non vide qui contient que des lettres alphabétiques et se termine par « . »)

algorithme pascal

0) DEF FN valide (ch :chaine) :booléen 1) Testvrai

2) J0 3) Répéter Jj+1

Si(non(ch[j] dans[''a''.. ''z'', ''A''.. ''Z''])) alors testfaux Finsi

Jusqu’à((test=faux) ou(j=long(ch)-1)) 4) Validetest et (long(ch)>0)et(ch[long(ch)]= ''.'') 5) Fin valide

TDOL

Objet Nature/type rôle J

test Var/entier

Var/booléen Compteur résultat

Function valide(ch :string) :boolean ; Var j :integer ;

Test :boolean ; Begin

Test :=true ; J :=0 ; Repeat J :=j+1 ;

If(not(ch[j] in['a'.. 'z', 'A'.. 'Z'])) then test :=

false ;

Until((test=false) or(j=length(ch)-1)) ; Valide := test

and(length(ch)>)and(ch[length(ch)]= '.';

End ;

Remplissage d’un tableau par n chaines qui contiennent que des lettres alphabétiques majuscules et espaces

algorithme pascal

0) DEF PROC remplir ( var T :tab ; n :entier) 1) Pour i de 1 à n faire

Répéter

Ecrire(''T['',i, '']= '') Lire(T[i])

Jusqu’à ( FN valide(T[i]) Fin pour

2) Fin remplir

TDOL

Objet Nature/type rôle I

valide Var/entier

fonction Compteur Vérifier la validité de la chaine Algorithme de la fonction valide 0) DEF FN valide (ch :chaine) :booléen 1) Testvrai

2) J0 3) Répéter Jj+1

Si(non(ch[j] dans[''A''.. ''Z'', '' ''])) alors testfaux Finsi

Jusqu’à((test=faux) ou(j=long(ch))) 4) Validetest et (long(ch)=15)

5) Fin valide

TDOL

Objet Nature/type rôle J

test Var/entier

Var/booléen Compteur résultat RQ : la condition de la fonction valide dépend de l’énoncé (test demandé)

Function valide(ch :string) :boolean ; Var j :integer ;

Test :boolean ; Begin

Test :=true ; J :=0 ; Repeat J :=j+1 ;

If(not(ch[j] in['A'.. 'Z', ' '])) then test := false ; Until((test=false) or(j=length(ch))) ;

Valide := test and(length(ch)=15) ; End ;

Procedure remplir( Var T :tab ; N :integer) ; Var i :integer ;

Begin

For i :=1 to n do Repeat

Writeln('T[',i, ']= ') ; Readln(T[i]) ; Until(valide(T[i])) ; End ;

RQ : la fonction valide doit être

développée dans la partie déclarative des objets locaux de la procédure remplir(càd entre var et begin de la procédure)

ou bien

elle être développée avant la procédure remplir.

Somme des chiffres d’un entier X (1

méthode)

algorithme pascal

0) DEF FN Somme (x :entier) :entier

1) S0

2) Convch(x,ch)

3) Pour i de 1 à long(ch) faire Valeur(ch[i],y,e)

SS+y 4) Fin pour

5) SommeS

6) Fin Somme

TDOL

Objet Nature/type rôle i

S y e ch

Var/entier Var/entier Var/entier Var/entier Var/chaine

Compteur Résultat Chiffre de x

Erreur Valeur de x

Function somme(x :integer) :integer ; Var i,s,y,e :integer ;

Ch :string ; Begin S :=0 ; Str(x,ch) ;

For i :=1 to length(ch) do Begin

Val(ch[i],y,e) ; S :=S+y ; End ;

Somme :=S ; End ;

Somme des chiffres d’un entier X ( 2

méthode)

algorithme pascal

0) DEF FN Somme (x :entier) :entier

1) S0

2) Répéter

SS+( x mod 10) X x div 10 Jusqu’à( x=0)

3) Somme S 4) Fin Somme

TDOL

Objet Nature/type rôle

S Var/entier Résultat

Function somme(x :integer) :integer ; Var S :integer ;

Begin S :=0 ; Repeat

S := s+ (x mod 10) ; X := x div 10 ; Until( x=0) ; Somme :=S ; End ;

La factorielle d’un entier x donné.

algorithme pascal

0) DEF FN factorielle(x :entier) :entier long 1) f1

2) pour i de 2 à x faire ff*i

fin pour 3) factorielle f 4) Fin factorielle

TDOL

Objet Nature/type rôle

f

i Var/entier long

Var/entier Résultat compteur

Function Factorielle(x :integer) :longint ; Var i :integer ;

F :longint ; Begin S :=1 ;

For i :=2 to x do F :=f*i ;

Factorielle :=f ; End ;

La puissance d’un entier x donné (x

).

algorithme pascal

0) DEF FN puissance(x ,y:entier) :entier long 1) p1

2) pour i de 1 à y faire pp*x

fin pour 3) factorielle p 4) Fin puissance

TDOL

Objet Nature/type rôle

p i

Var/entier long Var/entier

Résultat compteur

Function puissance(x ,y:integer) :longint ; Var i :integer ;

p :longint ; Begin p :=1 ;

For i := 1 to y do P :=p*x ;

Puissance :=p ; End ;

RQ : le paramètre x peut être de type réel

Somme des diviseurs d’un entier x sauf lui même

algorithme pascal

0) DEF FN somme_div(x :entier) :entier 1) S0

2) pour i de 1 à (x div 2) faire si ( x mod i=0) alors SS+i finsi fin pour

3) somme_div S 4) Fin somme_div

TDOL

Objet Nature/type rôle

S

i Var/entier

Var/entier Résultat compteur

Function somme_div(x :integer) :integer ; Var S,i :integer ;

Begin S :=0 ;

For i :=1 to ( x div 2 ) do If( x mod i =0) then s :=s+i ; Somme :=S ;

End ;

Nombre de voyelles dans une chaine ch

algorithme pascal

0) DEF FN nb_voyelle(ch :chaine) :entier 1) nbv0

2) pour i de 1 à long(ch) faire

si ( majus(ch[i]) dans[''A'', 'E'', ''O'', ''U'', ''I'', ''Y''])alors nbvnbv+1

finsi

fin pour

3) nb_voyellenbv 4) Fin nb_voyelle

TDOL

Objet Nature/type rôle

nbv

i Var/entier

Var/entier Résultat compteur

Function nb_voyelle(ch :string) :integer ; Var nbv,i :integer ;

Begin nbv:=0 ;

For i :=1 to length(ch)do

If (upcase(ch[i]) in ['A', 'E', 'O', 'U', 'I', 'Y']) Then nbv :=nbv+1 ;

Nb_voyelle :=nbv ; End ;

PGCD (plus grand commun diviseur) de deux entiers A et B (méthode de différence)

algorithme pascal

0) DEF FN PGCD_diff(A,B :entier) :entier 1) Tant que (A≠B) faire

Si(A>B) alors AA-B Sinon BB-A

Finsi

Fin tant que 2) PGCD_diffA 3) Fin PGCD_diff

Function PGCD_diff(A,B :integer) :integer ; Begin

While(A<>B) do If(A>B) then A :=A-B Else B :=B-A ;

PGCD_diff :=A ; End ;

PGCD (plus grand commun diviseur) de deux entiers A et B (méthode d’euclide)

algorithme pascal

0) DEF FN PGCD_Euclide(A,B :entier) :entier 1) Tant que((A≠B)et(B ≠0))faire

RA mod B AB

BR

Fin tant que

2) PGCD_EuclideA 3) Fin PGCD_Euclide

TDOL

Objet Nature/type rôle

R Var/entier Reste de

division de A par B

Function

PGCD_Euclide(A,B :integer) :integer ; Begin

While((A<>B) and (B<>0)) do begin

R := A mod B ; A :=B ;

B :=R ; End ;

PGCD_diff :=A ; End ;

PGCD (plus grand commun diviseur) de deux entiers A et B (méthode d’euclide)

algorithme pascal

0) DEF FN PGCD_Euclide(A,B :entier) :entier 1) Tant que((A≠B)et(B ≠0))faire

RA mod B AB

BR

Fin tant que

2) PGCD_EuclideA 3) Fin PGCD_Euclide

TDOL

Objet Nature/type rôle

R Var/entier Reste de division de A par B

Function

PGCD_Euclide(A,B :integer) :integer ; Begin

While((A<>B) and (B<>0)) do begin

R := A mod B ; A :=B ;

B :=R ; End ;

PGCD_diff :=A ; End ;

PPCM (plus Petit Commun multiplicateur) de deux entiers A et B

algorithme pascal

0) DEF FN PPCM(A,B :entier) :entier 1) Si(A>B) alors maxA

Min B Sinon

MaxB MinA Finsi

2) Tant que( max mod min ≠0) faire Maxmax+(A+B-min)

Fin tant que

3) PPCMmax

4) Fin PGCD_Euclide TDOL

Objet Nature/type rôle

Max

min Var/entier

Var/entier Valeur max entre A et B Valeur min entre A et B

Function PPCM(A,B :integer) :integer ; Var max,min :integer ;

Begin

If(A>B) then begin max :=A ; Min :=B ; End

Else begin Max :=B ; Min :=A ; End ; While(A<>B) do

Max :=max+(A+B-min) ; PPCM :=max ;

End ;

Vérification si un entier x est premier ou non

algorithme pascal

0) DEF FN premier (A,B :entier) :booléen 1) Testvrai

2) J1

3) Tant que((test)et(j<x div 2)) faire Jj+1

Si( x mod j =0) alors test faux Finsi

Fin tant que 4) premiertest 5) Fin premier

TDOL

Objet Nature/type rôle

test

j Var/boléen

Var/entier résultat compteur

Nb :

Function premier(x :integer) :boolean ; Var test :boolean ;

J :integer ; Begin Test :=true ; J :=1 ;

While((test) and( j<x div 2))do Begin

J :=j+1 ;

If(x mod j=0) then test :=false ; End ;

Premier := test ; End ;

Décomposition en facteurs premiers : écriture d’un entier x sous forme de multiplication des nombres premiers. Exple : 54=2*3*3*3

Le module : une procédure qui retourne un tableau T de taille n suivant l’exemple

1 2 3 4

T 2 3 3 3

algorithme pascal

0) DEF proc fact_prem (var t :tab ;var n :entier ;x :entier)

1) n0 2) i2 3) répéter

si ( x mod i=0) alors nn+1 T[n]i xx div i Sinon ii+1

finsi

Jusqu’à(x=1) 4) Fin fact_prem

TDOL

Objet Nature/type rôle

i Var/entier compteur

Procedure fact_prem(var t :tab ;var n :integer ;x :integer)

Var i :integer ; Begin

n :=0 ; i :=2 ; repeat

if( x mod i=0) then begin n :=n+1 ; T[n] :=i ; X :=x div i ; End

Else i :=i+1 ; Until(x=1) ; End ;

Nombre d’occurrences d’un entier x dans un tableau T de n entiers

algorithme pascal

0) DEF FN occurrence(T :tab ;n,x :entier) :entier 1) nbocc0

2) pour i de 1 à n faire si ( x=t[i])alors nboccnbocc+1 finsi

fin pour

3) occurrencenbocc 4) Fin occurrence

TDOL

Objet Nature/type rôle

nbocc

i Var/entier

Var/entier Résultat compteur

Function

occurrence(t :tab ;n,x :integer) :integer ; Var nbocc,i :integer ;

Begin nbocc:=0 ; For i :=1 to ndo

If (t[i]=x) Then nbocc :=nbocc+1 ; occurrence :=nbocc ;

End ;

RQ : le type de x doit être égal au type des éléments de T. si T est un tableau de réel x doit être réel.

Valeur maximale dans un tableau T de n entiers

algorithme pascal

0) DEF FN max(T :tab ;n :entier) :entier 1) mT[1]

2) pour 2 de 1 à n faire si (t[i]>m)alors mT[i]

finsi

fin pour 3) occurrencem 4) Fin occurrence

TDOL

Objet Nature/type rôle

m

i Var/entier

Var/entier Résultat compteur

Function max(t :tab ;n :integer) :integer ; Var m,i :integer ;

Begin M :=t[1] ; For i :=2 to ndo

If (t[i]>m) Then m :=t[i] ; max :=m ;

End ;

RQ : le type de la variable m et par

conséquent le type de la fonction doit être égal au type des éléments de T. si T est un tableau de réella fonction doit être de type réel

Pour chercher le min du tableau il suffit de changer le signe de la condition si.

Recherche d’un entier x dans un tableau T de n entiers

algorithme pascal

0) DEF FN recherche(T :tab ;n,x :entier) :booléen 1) i0

2) testfaux 3) répeter

ii+1

si(t[i]=x) alors testvrai finsi

jusqu’à((test) ou(i=n)) 4) recherchetest 5) Fin recherche

TDOL

Objet Nature/type rôle

test

i Var/boléen

Var/entier Résultat compteur

Function

recherche(t :tab ;n,x :integer) :boolean ; Var i :integer ;

Test :boolean ; Begin

i:=0 ;

test :=false ; repeat i :=i+1 ;

if(t[i]=x) then test :=true ; until((test) or(i=n)) ; recherche:=test;

End ;

Recherche d’un entier x dans un tableau T de n entiers(version optimisée)

algorithme pascal

0) DEF FN recherche(T :tab ;n,x :entier) :booléen 1) i0

2) répeter ii+1

jusqu’à((t[i]=x) ou(i=n)) 3) recherche(t[i]=x) 4) Fin recherche

TDOL

Objet Nature/type rôle

i Var/entier compteur

RQ : le type de x doit être égal au type des éléments de T. si T est un tableau de réel x doit être réel.

Function

recherche(t :tab;n,x :integer) :boolean ; Var i :integer ;

Begin i:=0 ; repeat i :=i+1 ;

until((t[i]=x) or(i=n)) ; recherche:= (t[i]=x) ; End ;

Remplissage d’un tableau par n entiers distincts (différents)

algorithme pascal

3) DEF PROC remplir ( var T :tab ; n :entier) 4) Pour i de 1 à n faire

Répéter

Ecrire(''T['',i, '']= '') Lire(T[i])

Jusqu’à ( FN valide (T,i-1,T[i]) Fin pour

5) Fin remplir

TDOL

Objet Nature/type rôle i

valide Var/entier

fonction Compteur Vérifier si t[i]

existe dans la partie[1..i-1]

de T

Algorithme de la fonction recherche 0) DEF FN valide(T :tab ;n,x :entier) :booléen 1) Testvrai

2) j0

3) tant que((test) et(i<n)) faire jj+1

si(t[j]=x) alors testfaux finsi

fin tant que 4) validetest 5) Fin recherche

TDOL

Objet Nature/type rôle

J

test Var/entier

Var/booléen Compteur résultat La fonction valide c’est la fonction

précédente(recherche) mais qui retourne faux si x existe dans T et elle est développée en utilisant la boucle tant que ..faire car on n’a pas besoin de vérifier le premier élément de T.

Function valide(ch :string) :boolean ; Var j :integer ;

Test :boolean ; Begin

Test :=true ; J :=0 ;

While((test) and(j<n))do Begin

J :=j+1 ;

If(t[j]=x) then test := false ; End ;

Valide := test;

End ;

Procedure remplir( Var T :tab ; N :integer) ; Var i :integer ;

Begin

For i :=1 to n do Repeat

Writeln('T[',i, ']= ') ; Readln(T[i]) ;

Until(valide(T,i-,T[i])) ; End ;

RQ : la fonction valide doit être

développée dans la partie déclarative des objets locaux de la procédure remplir(càd entre var et begin de la procédure)

ou bien

elle être développée avant la procédure remplir.