MAT231 Feuille de TP n 1. Exemples de programmes en réponse aux exercices

Dimension: px

Commencer à balayer dès la page:

Download "MAT231 Feuille de TP n 1. Exemples de programmes en réponse aux exercices"

Marin Breton
il y a 9 ans
Total affichages :

1 MAT231 Feuille de TP n 1 Eléments de réponses aux exercices mat231_tp01_exemples_programmes.mws (MAPLE 6) Exemples de programmes en réponse aux exercices Exercice 1 (cacul de factorielle n) Donner une procédure pour calculer factorielle n (y compris pour n=0). Solution élémentaire fact:=proc(n::integer) local a,k; # On spécifie que n doit être un entier if n=0 then 1 ; else a:=1 ; for k from 1 to n do a:=a*k od; fi; fact(0); fact(5); fact(5.1); 120 Error, fact expects its 1st argument, n, to be of type integer, but received Solution utilisant la récursivité restart; fact1:=proc(n::integer); if n=0 then 1; else n*fact1(n-1) fi fact1(0); fact1(5); fact1(1.5); 120 Error, fact1 expects its 1st argument, n, to be of type integer, but received 1.5 1

Solution élémentaire fact:=proc(n::integer) local a,k; # On spécifie que n doit être un entier if n=0 then 1 ; else a:=1 ; for k from 1 to n do a:=a*k od; fi; fact(0); fact(5); fact(5.

2 Cas des grands entiers Si n est très grand, Maple peut retourner un message d'erreur fact1(2000); Error, (in fact1) too many levels of recursion La version ci-dessous, qui utilise l'option remember, permet de faire le calcul de proche en proche. restart: fact2:=proc(n::integer); if n=0 then 1; else n*fact2(n-1) fi fact2(500); fact2(1000); \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \

$restart: fact2:=proc(n::integer); if n=0 then 1; else n*fact2(n-1) fi fact2(500); fact2(1000); 12201368259911100687012387854230469262535743428031928421924135883\$

3 \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Exercice 2 (Nombres s)

$20800026168315102734182797770478463586817016436502415369139828126\ 48102130927612448963599287051149649754199093422215668325720808213\$

4 Ecrire des programmes pour déterminer les nombres s inférieurs ou égaux à un nombre donné N : (i) programme utilisant la fonction isprime de MAPLE (cf aide en ligne) ; (ii) programme simulant le crible d'eratosthène ; (iii) programme utilisant irem mais pas isprime. Algorithme utilisant la fonction isprime # Affiche des N s nombres s avec "isprime" nbs_prem1:=proc(n) local S,p: S:={2}; for p from 3 to N by 2 do if isprime(p) then S:=[op(S), p]; fi; od; RETURN(S); nbs_prem1(100); [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97 ] Crible d'ératosthène erath1:=proc(n::integer) local A,m,i,j,k,P: for i from 2 to N do A[i]:=true od: m:=floor(sqrt(n)): # Ici on utilise le fait qu'il suffit de tester les # nombres jusqu'à sqrt(n) seulement. for i from 2 to m do if A[i] then for j from 2 to iquo(n,i) do A[i*j]:=false od: fi: od: for i from 2 to N do if A[i] then print(i, ``) fi: od: erath1(100); 2, 3, 5, 7,

$Algorithme utilisant la fonction isprime # Affiche des N s nombres s avec "isprime" nbs_prem1:=proc(n) local S,p: S:={2}; for p from 3 to N by 2 do if isprime(p) then S:=[op(S), p]; fi; od;$

5 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, Avec la fonction irem # Affichage des N s nombres s # crible d'eratosthène amélioré nbs_prem3:=proc(n) local S,p,q,m,a: S:={2}:a:= ceil(sqrt(n)): for p from 3 to N by 2 do q:=1; for m in S do if (m <= a) then if (irem(p,m)=0) then q:=q*0; else q:=q*1; fi; fi; od; if (q=1) then S:=[op(S), p]; fi; od; RETURN(S);

local S,p,q,m,a: S:={2}:a:= ceil(sqrt(n)): for p from 3 to N by 2 do q:=1; for m in S do if (m <=

6 nbs_prem3(100); [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97 ] Exercice 3 (Décomposition en facteurs s) Ecrire un programme factorisant un nombre donné N en facteurs s en utilisant la fonction nextprime de Maple. Décomposition en facteurs s decomp:=proc(n::integer) local A,M,a,n,q,B,E,C: with(linalg): A:= matrix([[nb_],[exposant]]): # N:=11*13: M:=N: # N:=2^2*3^7*11*2*17*19^2:M:=N: M:=N: a:=2: n:=1: while ((M < 1) and (a^2 <= N)) do if (irem(m,a) = 0) then q:=1: while (irem(m,a) = 0) do M:=M/a: q:=q+1: od: B:= matrix([[a],[q-1]]): A:=augment(A,B): fi: a:=nextprime(a): n:=n+1: od: E:=matrix([[M],[1]]): if M<1 then A:=augment(A,E) fi: C:=matrix([[Nb,N],[Decomp,ifactor(N)]]): A:=augment(A,C): decomp(2^5*3^7*11*2*17*19^3*503); Nb_, 2, 3, 11, 17, 19, 503, Nb, Exposant, 6, 7, 1, 1, 3, 1, Decomp, ( 2 ) 6 ( 3) 7 ( 11 ) ( 17 ) ( 19) 3 ( 503 ) Exercice 4 (Division euclidienne) (i) Ecrire un programme donnant le quotient et le reste de la division euclidienne de a par b

Décomposition en facteurs s decomp:=proc(n::integer) local A,M,a,n,q,B,E,C: with(linalg): A:= matrix([[nb_],[exposant]]): # N:=11*13: M:=N: # N:=2^2*3^7*11*2*17*19^2:M:=N: M:=N: a:=2: n:=1: while ((M

7 et vérifiez vos résultats à l'aide des fonctions Maple iquo(a,b) et irem(a,b). (ii) Ecrire ce programme sous forme de procédure. Introduire un contrôle de temps d'exécution en utilisant la fontion Maple time(). (iii) On suppose que le nombre a est très grand devant le nombre b (par exemple a/b ). Donner une estimation du nombre d'opérations (addition / soustractions / multiplications) nécessaires pour exécuter votre procédure. [Réponse : O(a) opérations] Division euclidienne, version soustractive (procédure avec contrôle de temps d'exécution) #division euclidienne / par soustration div_euc1:=proc(a,b) local k,q,r,u,t; r:=a : q:= 0:t:=time(): while (r = b) do r:=r-b: q:=q+1: od: u:=array(1..2,1..5,[[nombre_a, Nombre_b, Quotient, Reste, Temps],[a,b,q,r,time()-t]]): print(u): div_euc1(1597,27); div_euc1( ,567); div_euc1( ,567); Nombre_a Nombre_b Quotient Reste Temps Exercice 5 (Division euclidienne revisitée) Pour réduire le temps de calcul dans l'algorithme de division euclidienne, on cherche le quotient q de la division euclidienne de a par b sous forme binaire. 1. Donner un algorithme mettant en oeuvre cette idée. 2. Donner une estimation du nombre d'opérations nécessaires. Version par dichotomie binaire (procédure et avec contrôle de temps d'exécution)

Donner une estimation du nombre d'opérations (addition / soustractions / multiplications) nécessaires pour exécuter votre procédure.

8 # Division euclidienne par dichotomie binaire (non optimisée) div_euc3:=proc(a,b) local q,r,n,p,k,u,v,w,t; r:=a : q:=0 : n:=0 : v:=b: t:= time() : while (v <= a) do v:= 2*v : n:=n+1 : od: # A la fin de cette étape : r vaut a ; # q vaut 0 ; n vaut p tel que v vaut 2^p*b # et 2^(p-1)*b =< a < 2^p*b ; # On va écrire q, "en base 2", sous la forme # q = 2^(p-1) +... p:=n : w:=array(1..p) : w[p]:=1 : while (n0) do v:=v/2 : n:=n-1 : if (r<v) then w[n+1]:=0 : else w[n+1]:=1 : r:=r-v : fi: od: q:= sum(w[k]*2^(k-1),k=1..p) : r:= a-b*q : u:=array(1..2,1..5,[[nombre_a, Nombre_b, Quotient, Reste, Temps],[a,b,q,r,time()-t]]): print(u); div_euc3(1597,27); div_euc3( ,567); div_euc3( ,567); Nombre_a Nombre_b Quotient Reste Temps Estimation du nombre d'opérations : O(log(a)²) Version par dichotomie binaire (procédure, méthode de Hörner, contrôle de temps d'exécution) # Division euclidienne par dichotomie binaire + Hörner

.p) : w[p]:=1 : while (n0) do v:=v/2 : n:=n-1 : if (r<v) then w[n+1]:=0 : else w[n+1]:=1 : r:=r-v : fi: od: q:= sum(w[k]*2^(k-1),k=1..p) : r:= a-b*q : u:=array(1..2,1.

9 div_euc4:=proc(a,b) local q,r,n,u,v,t; r:=a : q:=0 : n:=0 : v:=b: t:= time() : while (v <= a) do v:= 2*v : n:=n+1 : od: # A la fin de cette étape, on a r vaut a ; # q vaut 0 ; n vaut p tel que v vaut 2^p*b et # 2^(p-1)*b =< a < 2^p*b ; while (n0) do v:=v/2 : n:=n-1 : if (r<v) then q:=2*q : else q:=2*q+1:r:=r-v: fi: od: # Dans cette étape, on a calculé q en utilisant la # méthode de Hörner u:=array(1..2,1..5,[[nombre_a, Nombre_b, Quotient, Reste, Temps],[a,b,q,r,time()-t]]): print(u); div_euc4(1597,27); div_euc4( ,567); div_euc4( ,567); Nombre_a Nombre_b Quotient Reste Temps Estimation du nombre d'opérations : O(log(a))

utilisant la # méthode de Hörner u:=array(1..2,1.

Documents pareils

Représentation d un entier en base b

Représentation d un entier en base b 13 octobre 2012 1 Prérequis Les bases de la programmation en langage sont supposées avoir été travaillées L écriture en base b d un entier est ainsi défini à partir