Apprendre Maple

[Guimzo]

Bonjour,

Je cherche à fabriquer une séquence qui pour un nombre n donné donnerait sous forme détaillée, la liste ordonnée de la somme des puissances de 2 qui compose ce nombre n :

Exemple :

n = 17
res : = [2^4+2^0]

Autre exemple :

n=13
res:= [2^3+2^2+2^0]

Donc le résultat est ordonné.

Voici ce que j'ai déjà fait, mais je pense que c'est vraiment pas bon : (


n:=n:
Res:=a:
do res: =[ round(log2(n)) - n] while a>0 ; end do: print("res:=a");

[Guimzo]

Bonjour,

Zozo si tu es dans les parages, pourrais-tu m'aider s'il te plaît, je crois que ALS est en vacances jusqu'au 4 novembre...

Voici ce que j'ai refait :

=====================

restart;
Decomposition := proc (n)
local a, b, c :
a := evalf(log[2](n)):
b := floor(a):
c := n-2^b:
if c = 0 then print(Decomposition = 2 puissance(b)):
end if:
end proc:
Decomposition(128);

=====================

La séquence est un début ; je pense qu'il manque l'instruction "ELSE" quand c>0, mais je ne vois pas comment l'introduire et comment rappeler l'ensemble des puissances en résultat...?
Donc du coup ça ne fonctionne que quand n est lui même de la forme 2^n, ce qui revient à calculer tout simplement 2^n...

[Guimzo]

Bonjour,

Voici une formulation possible pour une séquence de décomposition en somme de puissance de 2 d'un nombre ; formulation avec l'aide d'un internaute @Tryss :

====================

restart;
Dec := proc (n)
local a, b, c;
c := n;
while 0 < c do a := log[2](c);
b := floor(a); printf("2^%d ", b);
c := c-2^b end do end proc;
Dec(291)

=====================

Alors Maple renvoie éffectivement les différentes puissances de 2 qui composent un nombre n donné, mais il reste finalement à inclure ces résultats dans une liste ordonnée c'est à dire avec l'outil "Convert(a,set)...

[zozo]

Algorithme pour décomposer a en base b :

[Guimzo]

[zozo]

[Guimzo]

Bonjour Zozo,

Excellent ton programme, merci beaucoup
Ce programme je devais l'inclure en fait dans une séquence de factorisation, que j'ai fait, mais si tu peux regarder s'il te plaît où ça cloche, plus précisément au niveau du "CHOOSE" qui a du mal quand on lui demande de combiner beaucoup d'éléments d'un ensemble pourtant =(n-1) éléments.

C'est à dire quand je fais un
"
a:[seq(2**n,n=0..164)]:
with(combinat):
b := choose(a, 164);"

ça prend du temps alors que c'est simplement une combinaison de 164 éléments pris dans 165 éléments : et donc qu'il n'y à que C(164,165)= 165 possibilités.

Comment améliorer le programme, pour éviter que Maple rame, parce qu'il ne semble pas reconnaître que C(164,165) = 165.....??

Voilà la sequence entière :


=====================================

restart;
Digits := 1000;
p := 2537;
length(p);
a := [seq(2^n, n = 0 .. 5)];
with(combinat);
b := choose(a, 4);
N := nops(b);
with(ListTools);
c := {seq(convert(b[i], `+`), i = 1 .. N)};
s := seq(p/r, r = c);
select(proc (x) options operator, arrow; type(x, posint) end proc, [s]);

=======================================

Donc là, il n'y aucun probléme avec un "choose(a,4)" mais des que je demande à Maple un choose(a,164), en ayant pris le soin de faire monter "n" à 165 ; là Maple rame, alors qu'il n'y à pourtant moins de 200 possibilités...??

[ALS]

Bonjour,
très rapidement, voici ce que l'on peut écrire:

[Guimzo]

Bonjour ALS,

J'espère que vous avez passé de bonnes vacances, il me tardait de vous revoir sur le forum : ) Mais comme vous m'aviez dit le 4 novembre j'attendais encore : )
Je pense que vous seriez plutôt fier de "votre élève", j'ai fait la séquence tout seul, avec tout ce que vous m'avez déjà appris : )
Merci pour la séquence je vais l'essayer de suite : )
À bientôt : )

[Guimzo]

Re-bonjour ALS,


La ligne " b:=[seq(subsop(165-k=NULL,a),k=0..164)]; " est excellente par rapport à choose : )
Merci merci merci : )


Mais quand je veux utiliser un nombre plus petit par rapport aux combinaisons, je ne sais pas comment il faudrait faire ; je m'explique :
Par exemple, je prends le nombre 85073, je sais qu'il a que deux facteurs premiers dont 241 et 353 ; d'autre part je sais que 353 = [`2^8`+ `2^6`+`2^5`+ `2^0`]

Donc en tout, 353 = la somme de 4 puissance de 2 allant 2^0 à 2^8
Donc il me faudrait choisir 4 éléments dans 9 éléments,

Alors comment régler la séquence dans ce cas, et dans les autres cas par rapport au nombre d'éléments que je veux combiner, et du nombre d'éléments de l'ensemble où je les prends :


Voici la séquence :


==========================
restart;
Digits := 1000;
p := (85073);
length(p);
a := [seq(2^n, n = 0 .. 8 )] :
b := [seq(subsop(9-k = NULL, a), k = 0 .. 4)] :
N := nops(b):
with(ListTools):
c := {seq(convert(b[i], `+`), i = 1 .. N)};
C := nops(c);
s := seq(p/r, r = c);
select(proc (x) options operator, arrow; type(x, posint) end proc, [s]);

===================================

En fait, dans ce cas ci, vu que 353 = la somme de la combinaison de 4 puissances de 2, avec la plus haute puissance qui égal à 8; il faudrait donc, que la ligne "b" fasse comme un "choose(a,4)"....?


L'autre séquence qui marche avec choose, mais qui rame des que l'on met un grand nombre p, avec un n en conséquence :

================================

restart;
Digits := 1000;
p := 85073;
length(p);
a := [seq(2^n, n = 0 .. 8 )]:
with(combinat):
b := choose(a, 4):
N := nops(b):
with(ListTools):
c := {seq(convert(b[i], `+`), i = 1 .. N)};
C := nops(c);
s := seq(p/r, r = c):
select(proc (x) options operator, arrow; type(x, posint) end proc, [s]);

================================

[ALS]

Ma ligne b:=[seq(subsop(N+1-k=NULL,a),k=0..N)] ne marche que pour une combinaison de N éléments parmi N+1 éléments.
Pour choisir p éléments parmi N, il faut utiliser choose quand 1<p<N.

D'autre part, convert(b[i], `+`) fait la somme de tous les éléments de b[i], c'est bien ce que vous cherchiez à faire?

[Guimzo]

Re ALS,


Mais comment expliquer que Maple ait du mal à calculer cette séquence, alors qu'il n'y à qu'à peine une centaine de possibilités....??

================

restart; a := [seq(2^n, n = 0 .. 160)]:
with(combinat):
b := choose(a, 160);

================

[ALS]

Effectivement, je ne me l'explique pas non plus !

[Guimzo]

Existerait-il un moyen de contourner ce "bug" de Maple, de former des groupes de p éléments pris dans n éléments, quand le nombres n et p sont au dessus de 50....?

Sinon je vais essayer de voir dans Mathematica ce que ça donne un

"a:=[seq(n,n=1..50)] :with(combinat): b:=choose(a,48 ) ; "
Merci ALS, j'espère vous revoir bientôt s'il vous plaît, pour l'autre séquence avec les multiplications...

[Guimzo]

Re-bonsoir ALS,


Pourriez-vous m'aider s'il vous plaît à corriger la séquence suivante :

=========================

restart;
Digits := 155;
p := 85073;
a := [seq(2^n, n = 0 .. 10)];
with(combinat);
b := choose(a, 2);
N := nops(b);
with(ListTools);
c := {seq(convert(b[i], `-`), i = 1 .. N)};
M := nops(c);
for x in c do r := (sqrt(g*g+4*p)+g)*(1/2) :
if type(r, integer) then break end if end do; print("FACTEUR r =", r);

======================================

C'est la ligne 9 que je voudrais corriger :
" c := {seq(convert(b[i], `-`), i = 1 .. N)}; "

En fait je voudrais fabriquer un ensemble "c" qui soit composé des différentes soustractions des 2 nombres qui composent les binômes (b:=choose(a,2))......?