Programmation procédure

NOMBRES - Curiosités, théorie et usages Accueil DicoNombre Rubriques Nouveautés Édition du: 22/03/2017 Orientation générale DicoMot Math Atlas Références M'écrire Barre de recherche DicoCulture Index alphabétique
	Informatique
Débutants Programmation	Programmation			Glossaire Algorithme
INDEX Programmation Algorithmes Multimédia	<<< Chiffres	Procédure	Palindrome >>>
		Sommaire de cette page >>> Ma première procédure >>> Somme des chiffres >>> Calcul avec résultat d'une procédure >>> Extraction des chiffres d'un nombre >>> Cubes en …99 >>> Bilan

Procédures

Revoyez la page précédente, nous avons dû répéter souvent les mêmes instructions. Peut-on simplifier?

Oui! Nous pouvons regrouper ce jeu d'instructions sous un nom et le rendre autonome.

Il s'agit d'un sous programme que nous pourrons appeler par son nom, chaque fois que nous le souhaitons. Ce type de sous-programme est une procédure.

Ma première procédure
Nous allons écrire une procédure (Mul11) qui retourne le produit d'un nombre (n) par 11. La déclaration de la procédure est simple: nom de la procédure Mul11 signe d'affectation := instruction proc avec la variable d'entrée n, appelée argument de la procédure. déclaration des variables utilisées dans la procédure, variables locales. C'est utile pour être tranquille quant à l'existence de variables de même nom ailleurs. sans oublier d'indiquer la fin de la procédure par end proc ou end Il suffit alors de taper la nouvelle instruction Mul11(7) pour obtenir, par exemple, le produit de 7 par 11 = 77. Une boucle permet d'obtenir les multiples de 11 (de 10 à 15 dans cet exemple)	> Mul11:= proc(n) local M: *M:=n11: lprint(M): end: > Mul11(7); 77 En effet, 11 x 7 = 77 > for i from 10 to 15 do Mul11(i): od:** 110 121 132 143 154 165 En effet, 11 x 10 = 110 11 x 11 = 121, etc.
La procédure n'est pas limitée à un seul argument. Par exemple, la procédure Mul(n,m) , avec deux arguments m et n, effectue la multiplication de n par m.	> Mul:= proc(n,m) local M: *M:=nm: lprint(M): end: > Mul(15,6);** 90

Somme des chiffres

Nous reprenons le principe de la recherche des chiffres déjà vu.

Nous l'englobons dans une procédure SoCh qui va calculer la somme des chiffres d'un nombre donné n.

En appelant cette procédure pour n = 1234, elle nous retourne 10 qui est bien 1 + 2 + 3 + 4.

Remarque: nous avons pris la peine de ne pas perturber la valeur de n dans la procédure. Nous avons utilisé nn, variable à laquelle nous pouvons faire subir tous nos calculs internes.

> SoCh:=proc(n)

local Somme, nn, q, r;

Somme:=0: nn:=n:

q:= iquo(nn,10):

r:= irem(nn,10):

while 0<nn do Somme:=Somme+r;

nn:=iquo(nn,10):r:=irem(nn,10)

od:

lprint(Somme):

end:

> SoCh(1234);

SoCh(123456789);

Calcul avec résultat d'une procédure

Comment utiliser le retour d'une procédure dans un calcul?

Il faut prévoir cette utilisation dans la procédure au moyen de l'instruction return.

Alors le retour de la procédure peut être utilisé comme n'importe quel nombre.

> SoCh:=proc(n)

local Somme, nn, q, r;

Somme:=0: nn:=n:

q:= iquo(nn,10):

r:= irem(nn,10):

while 0<nn do Somme:=Somme+r;

nn:=iquo(nn,10):r:=irem(nn,10)

od:

return(Somme):

end:

> a:=SoCh(123456789):

b:=SoCh(123):

c:=SoCh(456):

d:=SoCh(789):

e:=b+c+d:

lprint(a,b,c,d,e):

45, 6, 15, 24, 45

Extraction des chiffres d'un nombre

Nous reprenons le programme vu précédemment.

Nous l'englobons dans une procédure nommée Ch(n).

L'appel de la procédure donne la liste des chiffres du nombre.

> Ch:=proc(n)

local C,nn, q, i,R:

nn:=n:

C:=[]:

while nn>0 do

C:=[op(C),irem(nn,10)];

nn:= iquo(nn,10):

od:

q:=nops(C):R:=[]:

for i from 1 to q do

R:=[op(R),C[q-i+1]]

od:

print(R):

end:

> Ch (123);

Ch(9876006789);

Cubes en …99

Nous reprenons le programme ci-dessus en modifiant la sortie:

au lieu de demander une impression, nous demandons un retour (return) du résultat pour utilisation dans un autre programme.

Avec cette procédure qui retourne les chiffres d'un nombre, nous nous proposons de chercher les nombres dont le cube se termine par 99.

boucle jusqu'à 1000

calcul du cube ( ^ veut dire puissance)

appel à la procédure Chiffre et résultat dans la liste CC.

q est la quantité de chiffres

les unités du nombre sont en position q et les dizaines en position q-1.

impression du nombre et des chiffres de son cube si celui-ci se termine par 99.

Nous détectons une propriété:

Le cube de tous les nombres se terminant par 99 se termine aussi par 99, et que ceux-là.

Procédure extraction des chiffres

> Chiffre:=proc(n)

local C,nn, q, i,R:

nn:=n:

C:=[]:

while nn>0 do

C:=[op(C),irem(nn,10)];

nn:= iquo(nn,10):

od:

q:=nops(C):R:=[]:

for i from 1 to q do

R:=[op(R),C[q-i+1]]

od:

return (R):

end:

> for Nb from 1 to 1000 do

Cube:=Nb^3:

CC:= Chiffre (Cube):

q:= nops(CC):

if CC[q]=9 and CC[q-1]=9 then

lprint (Nb,CC):

fi:

od:

99, [9, 7, 0, 2, 9, 9]

199, [7, 8, 8, 0, 5, 9, 9]

299, [2, 6, 7, 3, 0, 8, 9, 9]

399, [6, 3, 5, 2, 1, 1, 9, 9]

499, [1, 2, 4, 2, 5, 1, 4, 9, 9]

599, [2, 1, 4, 9, 2, 1, 7, 9, 9]

699, [3, 4, 1, 5, 3, 2, 0, 9, 9]

799, [5, 1, 0, 0, 8, 2, 3, 9, 9]

899, [7, 2, 6, 5, 7, 2, 6, 9, 9]

999, [9, 9, 7, 0, 0, 2, 9, 9, 9]

Ce que nous avons appris

Nous savons créer des sous-programmes, dit procédures qui agissent comme de nouvelles instructions.

Une procédure est doublement pratique:

elle permet de ne pas répéter les instructions, et

elle rend plus claire l'écriture d'un programme.

Suite	Palindrome Procédure de recherche du plus grand facteur d'un nombre Procédure de tri à bulles
Voir	Menu en en-tête Programmation – Index
Aussi	Programmation – En savoir un peu plus
Cette page	http://villemin.gerard.free.fr/aInforma/09Proced.htm