> restart;

VI.1

> estparfait:=proc(n::integer)
local S,i;
S:=0;
for i to n-1 do if irem(n,i)=0 then S:=S+i
fi;
od;
evalb(S=n);
end;

> estparfait(496);

> estparfait(6);

> estparfait(497);

> listeparfait:=proc(n::integer)
local k,L;
L:=[];
for k to n do
if estparfait(k) then L:=[op(L),k] fi;
od;
L;
end;

> listeparfait(500);

> restart;

VI.2

> syracuse:=proc(n::integer)
local k,nn;
nn:=n;
for k from 1 while nn<>1
do
if irem(nn,2)=0 then nn:=nn/2
else nn:=3*nn+1
fi;
od;
k;
end;

> syracuse(1234567890);

> L:=NULL:for k from 1 to 50 do L:=L,[k,syracuse(k)] od: L;

> restart;

VI.3

> fibo1:=proc(n::integer)
local resultat,u,v,k,garage;
#Initialisation
u:=1;v:=1;
#Calcul des termes successifs
if n=0 then resultat:=u
elif n=1 then resultat:=v
else for k from 2 to n
do
garage:=v;
v:=u+v;
u:=garage;
resultat:=v;
od;
fi;
# On peut arranger la procédure et supprimer # resultat.
resultat;
end;

> fibo1(1);

> fibo1(9);

> fibo2:=proc(n::integer)
option remember;
if n=0 then 1
elif n=1 then 1
else fibo2(n-1)+fibo2(n-2)
fi;
end;

> fibo2(9);

> restart;

VI.4

Par un procédé itératif

> Tn_2:=1:Tn_1:=X:
for k from 2 to 11
do
T:=2*X*Tn_1-Tn_2;
garage:=Tn_1;
Tn_1:=T;Tn_2:=garage;
od:

> collect(T,X);

Avec l'option remembe r

> T:=proc(n::integer)
option remember;
if n=0 then 1
elif n=1 then X
else sort(simplify(2*X*T(n-1)-T(n-2)))
fi;
end;

> T(11);

> time(T(50));

> time(T(100));

> time(T(200));

> time(T(200));

> time(T(210));

> restart;

Sans l'option remembe r

> T2:=proc(n::integer)
if n=0 then 1
elif n=1 then X
else sort(simplify(2*X*T2(n-1)-T2(n-2)))
fi;
end;

> T2(11);

> time(T2(25));

> restart;

VI.5

> binom:=proc(n::integer,k::integer)
option remember;
if k>n then 0
elif k=0 or k=n then 1
else binom(n-1,k)+binom(n-1,k-1);
fi;
end;

> binom(10,2);

> restart;

VI.6

On commence par écrire une procédure qui calcule la somme de tous les diviseurs propres d'un entier n.

> `somme des diviseurs`:=proc(n::integer)
local s,i;
s:=1;
for i from 2 to n-1
do
if irem(n,i)=0
then s:=s+i
fi
od;
s;
end;

> amiable:=proc(n::integer)
local i,j,sol; # On va créer une séquence de liste qui seront les solutions.
sol:=NULL; # initialisation de la séquence à vide
for i from 3 to n # boucle pour parcourir tous les entiers
do
j:=`somme des diviseurs`(i); # Le seul candidat pour être amiable avec i est j
if j>=i
and # Pour éviter d'avoir 2 fois la même solution
`somme des diviseurs`(j)=i
then sol:=sol,[i,j];
fi
od;
sol;
end;

> amiable(30);

> amiable(300);

> amiable(1500);

> restart;

VI.7

> menu:=proc(jour::string)
if jour="lundi" then "Flageolet et gigot d'agneau"
elif jour="mardi" then "Poulet-frites"
elif jour="mercredi" then "Haricots verts et paupiette d'autruche"
elif jour="jeudi" then "citrouille de Halloween"
elif jour="vendredi" then "Filet de sole et sauce à l'oseille"
else "Désolé, nous serons fermé ce week-end"
fi;
end:

>