La Question du Dimanche (II) !

[Marge]

@C.Ret

@ledudu
Après avoir lu la réponse de Marge à ton message, j'ai comme un doute. Est-il encore en train de chercher ?

Non, je n'ai pas cherché et ne cherche pas, j'ai la tête en vacances.

[Ben]

Une petite statistique qui ne sert à rien (qui est donc tout à fait indispensable )

Le C-128 a calculé le nombre de "pas" pour les nombres jusqu'à 100.000

Code : Tout sélectionner

SERIE DE 10 A 100000
 1= 33862 2= 37459 3= 16917 4= 8947 5= 2409 6= 377 7= 20

Il a tout de même mis 18308.6667 sec (5,08h)

[C.Ret]

Non non cela ne sert pas à rien.

Il me permet de vérifier mes propres comptages.

Pour compter de 0 à 100000, il me faut sur mon C128D environ 3h20min et j'obtiens des résultats peu différents:

Code : Tout sélectionner

Racine p=0    p=1    p=2    p=3    p=4    p=5    p=6    p=7    p=8  TOTAL  
 r=0     1  33571  34544  10620   2008   1262    377     20      0  82403 
 r=1     1      4      0      0      0      0      0      0      0      5
 r=2     1     14    377   2172    579     70      0      0      0   3213    
 r=3     1     14      0      0      0      0      0      0      0     15
 r=4     1     34     40    543    276      0      0      0      0    894     
 r=5     1     14     40    316    134    102      0      0      0    607     
 r=6     1     54    266   1924   3623    975      0      0      0   6843
 r=7     1     14      0      0      0      0      0      0      0     15    
 r=8     1     69    655   2779   2467      0      0      0      0   5971    
 r=9     1     34      0      0      0      0      0      0      0     35   
TOTAL   10  33822  35922  18354   9087   2409    377     20      0 100001

La racine de n est tout simplement le chiffre sur lequel abouti la suite lorsque l'on commence avec n.

Par exemple, la racine de 3927 est 6, en effet la série de décompositions issues de 3927 abouti à 6 :
. .
Le nombre 3927 fait donc partie des 975 nombres décomptés à la ligne r=6 et à la colonne p=5 du tableau ci-dessus.

Le code utilisé pour le comptage tient en un seule ligne :

Code : Tout sélectionner

10 TI$="000000":DIM N(9,11):FOR N=0 TO 1E5:I=N:P%=0:DO WHILE I>9:P%=P%+1:X=I:I=1
:DO WHILE X:X%=X/10:I=I*(X-10*X%):X=X%:LOOP:LOOP:N(I,P%)=1+N(I,P%):NEXT:PRINT TI
$

Ah! La puissance du BASIC Microsoft 7.0 pour CBM !
Il faut cependant entrer cette ligne en utilisant un point d'interrogation pour abréger la saisie de PRINT sinon l'interpréteur du Commodore se plaint.

Le code pour afficher le tableau N(,) comme ci-dessus est à peine plus compliqué.


Sauriez-vous trouver les 20 nombres N inférieurs à 100000 dont les décompositions multiplicatives aboutissent à la racine R=0 en exactement P=7 étapes ?

A zut, nous ne sommes pas dimanche !
J'ai loupé mon rendez-vous avec les QdD

[Ben]

Sauriez-vous trouver les 20 nombres N inférieurs à 100000 dont les décompositions multiplicatives aboutissent à la racine R=0 en exactement P=7 étapes ?

Il n'y a que des 6, des 8 et des 9

[C.Ret]

OUI, tout à fait, en fait un seul 6, un triplet de 8 et un seul 9.

Code : Tout sélectionner

0:
20:
54:
336:
768:
2688:
27648:
 68889 68898 68988 69888
 86889 86898 86988 
 88689 88698 88869 88896 88968 88986
 89688 89868 89886 
 96888 98688 98868 98886

Après avoir écrit quelques programmes pour décomposer les nombres en produit et ainsi déterminer leur persistance multiplicative.
J'ai trouvé bien plus rigolo de faire des programmes qui font l'inverse.

Je leur donne la value d'un radical et ils déterminent les nombres dont la décomposition multiplicative donne justement cette valeur.

Par exemple à parti de la racine 5 et en se limitant aux nombres inférieurs à 1000.

Code : Tout sélectionner

   5:  15:  35:  57.
                 75: 355.
                     535.
                     553.
                157.
                175: 557.
                     575.
                     755.
                517.
                571.
                715.
                751.
            53.
           135: 359.
                395.
                539.
                593.
                935.
                953.
           153.
           315: 579.
                597.
                759.
                795.
                957.
                975.
           351.
           513.
           531.
       51.
      115.
      151.
      511.
RECORD: P=4  355-755
DONE IN 00:01'16"

[bernouilli92]

En RPL, on peut gagner 5,5 octets en remplaçant 10 par 1 ALOG.

Du coup on passe à 85 octets :

Code : Tout sélectionner

<<
  WHILE DUP 9 >
  REPEAT
    DUP 1 
    WHILE OVER 9 >
    REPEAT
      OVER 1 ALOG MOD * 
      SWAP 1 ALOG / FLOOR SWAP
    END
    *
  END
>>

[C.Ret]

Comme à mon habitude, je programme sur HP28S en utilisant l'instruction LAST et donc en jouant sur le contenu de la pile, j'obtiens un code très similaire et fortuitement un tout petit peu plus court.

Code : Tout sélectionner

<<                                       «
  WHILE DUP 9 >                            WHILE DUP 9 >
  REPEAT                                   REPEAT
    DUP 1                                     1 OVER
    WHILE OVER 9 >                            WHILE DUP
    REPEAT                                    REPEAT
      OVER 1 ALOG MOD *                          10 / LAST MOD ROT   
      SWAP 1 ALOG / FLOOR SWAP                   * SWAP IP
    END                                       END
    *                                         DROP
  END                                      END
>>                                       »

Si on donne 3927 comme argument à ce code, celui-ci remplit la pile de cette façon:

Code : Tout sélectionner

6:                 3927
5:                  378
4:                  168
3:                   48
2:                   32
1:                    6

Le fait que 3927 soit au ,niveau 6: de la pile indique que sa persistance est P=5.

Pour être honnête, ce n'est pas celui que j'utilise. J'ai ajouté quelques instructions pur obtenir les décompositions sous la forme d'une liste précédée de la persistance :

Code : Tout sélectionner

« { } 
  WHILE OVER 9 >
  REPEAT
    OVER + 1 ROT
    WHILE DUP
    REPEAT
      10 / LAST MOD ROT * SWAP IP
    END
    DROP SWAP
  END
  SIZE LAST ROT + »

Par exemple:

Code : Tout sélectionner

3:
2:
1:
89688  QDD2 

renvoi:

Code : Tout sélectionner

3:
2:                    7
1: { 89688 27648 2688  
   768 336 54 20 0 }

Dans le même esprit, j'ai un petit pbout de code pour HP-15C qui mémorise les élémentsde la décomposition dans une matrice. ce qui est bien pratique pour les afficher à volonté.

P.S.:
J'oubliai de donner le code SHARP PC-1211 qui a permis de réaliser les impressions:

Code : Tout sélectionner

1:" "AREAD N:P=-1
2:PRINT N:P=P+1,X=N,N=1:IF X<=9PRINT "P=";P:END
3:A=INT .1X,N=N*(X-10A,X=A:GOTO 2+SGN X