Persistance multiplicative

46

Persistance multiplicative

  1. Multiplie tous les chiffres d'un nombre
  2. Répéter jusqu'à ce qu'il ne reste qu'un seul chiffre

Comme expliqué par Numberphile :

Exemple

  1. 277777788888899 → 2x7x7x7x7x7x7x8x8x8x8x8x8x9x9 = 4996238671872
  2. 4996238671872 → 4x9x9x6x2x3x8x6x7x1x8x7x2 = 438939648
  3. 438939648 → 4x3x8x9x3x9x6x4x8 = 4478976
  4. 4478976 → 4x4x7x8x9x7x6 = 338688
  5. 338688 → 3x3x8x6x8x8 = 27648
  6. 27648 → 2x7x6x4x8 = 2688
  7. 2688 → 2x6x8x8 = 768
  8. 768 → 7x6x8 = 336
  9. 336 → 3x3x6 = 54
  10. 54 → 5x4 = 20
  11. 20 → 2x0 = 0

Au fait, il s’agit de l’enregistrement actuel: le plus petit nombre avec le plus grand nombre de pas.

Le golf

Un programme qui prend un nombre entier en entrée puis affiche le résultat de chaque étape, en commençant par l'entrée elle-même, jusqu'à atteindre un seul chiffre. Pour 277777788888899, la sortie doit être

277777788888899
4996238671872
438939648
4478976
338688
27648
2688
768
336
54
20
0

(Compter le nombre d'étapes est laissé à l'utilisateur comme un exercice).

Plus d'exemples

De A003001 :

25
10
0

De A003001 aussi:

68889
27648
2688
768
336
54
20
0

De la vidéo Numberphile :

327
42
8

Il y a donc eu une question à propos de la persistance additive , mais il s'agit de la persistance multiplicative. En outre, cette question demande le nombre d'étapes en sortie, alors que je suis intéressé à voir les résultats intermédiaires.

code-golf math arithmetic repeated-transformation SQB
la source
Bonus: trouver un nouveau record: le plus petit nombre avec le plus grand nombre de pas. Mise en garde: la conjecture veut que 11 soit le plus grand possible.
SQB
7
Vous devriez probablement inclure quelques cas de tests supplémentaires ne se terminant pas par . 0
Arnauld
Entré pour faire ce post, trouvé déjà existant, gg
cat
une entrée à un chiffre est-elle valide?
dzaima
1
Matt Parker, dans la vidéo Numberphile, indique que des recherches portant sur plusieurs centaines de chiffres ont été effectuées.
HardScale

Réponses:

7

Gelée , 4 octets

DP$Ƭ

Essayez-le en ligne!

Explication

D    | convert to decimal digits
 P   | take the product
  $  | previous two links as a monad
   Ƭ | loop until no change, collecting all intermediate results

En bonus, voici un TIO qui trouvera les numéros avec le plus grand nombre d'étapes pour une plage donnée de nombres de chiffres. Il évolue bien même sur TIO.

Nick Kennedy
la source
15

TI-BASIC (TI-84), 30 32 31 octets

-1 octet grâce à @SolomonUcko!

While Ans>9:Disp Ans:prod(int(10fPart(Ans10^(seq(-X-1,X,0,log(Ans:End:Ans

L'entrée est en Ans.
La sortie est affichée en tant que demandes de challenge. La fin Ansest nécessaire pour imprimer la dernière étape.

Je dois admettre que je n’ai pas pensé à cette formule moi-même, mais que je l’ai trouvée ici et que je l’ai modifiée pour mieux relever le défi.

EDIT: En relisant le défi, je me suis rendu compte que le programme doit se terminer si le produit est à un chiffre. Par conséquent, 2 octets devaient être ajoutés pour expliquer cela.

Exemple:

24456756
        24456756
prgmCDGF8
        24456756
          201600
               0
11112
           11112
prgmCDGF8
           11112
               2

Explication:

While Ans>9               ;loop until the product is one digit
Disp Ans                  ;display the current product
prod(                     ;get the product of...
 int(                     ; the integer part of...
  10fPart(                ; ten times the fractional part of...
  Ans                     ; each element in the following list times the
                          ;  current product
  10^(                    ; multiplied by the list generated by using each
                          ;  element of the following list as an exponent
                          ;  for 10^n
   seq(-X-1),X,0,log(Ans  ; generate a list of exponents from -1 to -L where
                          ;  L = the length of the current product
End
Ans                       ;leave the final product in "Ans" and implicitly
                          ; print it

Modèle visuel:
Ans commence comme 125673.
Ce modèle ne couvre que la logique qui sous-tend la multiplication des chiffres; tout le reste est plus facile à comprendre.

seq(-X-1,X,0,log(Ans  =>  seq(-X-1,X,0,5.0992
   {-1 -2 -3 -4 -5 -6}
10^(...
   {.1 .01 .001 1E-4 1E-5 1E-6}
Ans...
   {12567.3 1256.73 125.673 12.5673 1.25673 .125673}
fPart(...
   {.3 .73 .673 .5673 .25673 .125673}
10...
   {3 7.3 6.73 5.673 2.5673 1.25673}
int(...
   {3 7 6 5 2 1}
   (the digits of the number, reversed)
prod(...
   1260
   (process is repeated again)

seq(-X-1,X,0,log(Ans  =>  seq(-X-1,X,0,3.1004
   {-1 -2 -3 -4}
10^(...
   {.1 .01 .001 1E-4}
Ans...
   {126 12.6 1.26 .126}
fPart(...
   {0 .6 .26 .126}
10...
   {0 6 2.6 1.26}
int(...
   {0 6 2 1}
prod(...
   0
   (product is less than 10.  loop ends)

Remarques:

TI-BASIC est un langage à jeton. Le nombre de caractères ne correspond pas au nombre d'octets.

10^(est ce jeton d'un octet .

Ce programme ne fournira pas la séquence correcte de produits avec des nombres entiers supérieurs à 14 chiffres en raison des limites de précision décimale sur les calculatrices TI.

Tau
la source
Pouvez-vous sauvegarder un octet en déplaçant 10^(dehors seq(et en omettant la parenthèse fermante?
Solomon Ucko
Oui je crois bien!
Tau
11

K (ngn / k) , 9 octets

{*/.'$x}\

Essayez-le en ligne!

{ }\ continue à appliquer la fonction entre accolades jusqu'à ce que la séquence converge

$x formate l'argument sous forme de chaîne (liste de caractères)

.'évaluer chacun (les autres dialectes de k nécessitent un colon, .:')

*/ fois, à savoir le produit

ngn
la source
8

R , 59 octets

n=scan();while(print(n)>9)n=prod(n%/%10^(nchar(n):1-1)%%10)

Essayez-le en ligne!

Puisque print invisiblyrenvoie son entrée, nous pouvons utiliser print(n)à l'intérieur de la whileboucle pour simuler une do-whileboucle. Ceci est inspiré par l' un de mes conseils pour jouer au golf dans R .

L'en-tête aide à empêcher l'impression de grands nombres en notation scientifique.

Giuseppe
la source
8

05AB1E , 7 4 octets

Δ=SP

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

Δ     # Loop until the number no longer changes:
 =    #  Print the number with trailing newline (without popping the number itself)
      #  (which will be the implicit input in the first iteration)
  SP  #  Convert the number to a list of digits, and calculate its product
Kevin Cruijssen
la source
7

Python 2 ,  46  43 octets

-3 grâce à xnor (comparaison chaînée)

def f(n):print n;n>9>f(eval('*'.join(`n`)))

Essayez-le en ligne!

Jonathan Allan
la source
Vous pouvez faire >à la place de and.
Xnor
@xnor merci, facile d'oublier que cela fonctionnera.
Jonathan Allan
5

PowerShell , 54 octets

for($a=$args;$a-gt9){$a;$a=("$a"|% t*y)-join"*"|iex}$a

Essayez-le en ligne!

Méthode itérative qui écrit d'abord l'argument d'entrée, puis le convertit en chaîne et le redirige vers un tableau de caractères. Ce tableau est rejoint par un seul astérisque et exécuté en tant que commande avec l'alias d'expression invoke. Etant donné que cela écrit le nombre de départ jusqu'au dernier nombre supérieur à 0 (20 dans le scénario de test donné), j'ajoute un final $aà la fin de la sortie.

KGlasier
la source
5

C # (compilateur interactif Visual C #) , 79 74 68 octets

void f(int a){Print(a);if(a>9)f((a+"").Aggregate(1,(j,k)=>k%48*j));}

J'essaie d'éviter la récursion en C # en raison de la longueur de la déclaration de la méthode, mais dans ce cas, cela économise par rapport à une boucle.

Essayez-le en ligne!

Incarnation de l'ignorance
la source
5

PHP , 63 octets

<?=$n=$argn;while($n>9)echo"
",$n=array_product(str_split($n));

Version itérative, appel avec php -nFentrée de STDIN.

Essayez-le en ligne!

PHP ,72 71 octets

function h($n){echo"$n
",($n=array_product(str_split($n)))>9?h($n):$n;}

Essayez-le en ligne!

Version récursive, en fonction.

Entrée: 277777788888899

277777788888899
4996238671872
438939648
4478976
338688
27648
2688
768
336
54
20
0

Entrée: 23

23
6
640 Ko
la source
5

Python 2 , 61 62 59 octets

def f(n):print n;n>9and f(reduce(int.__mul__,map(int,`n`)))

Essayez-le en ligne!

-3 octets, merci à Jonathan Allan

TFeld
la source
Ne fonctionne pas pour les entrées qui ne finissent pas par un 0 lors de leur dernière itération, par exemple 23
Incarnation de l'Ignorance
int.__mul__est trois octets moins quelambda a,b:a*b
Jonathan Allan
@ JonathanAllan Merci! Je savais qu'il devait y avoir quelque chose comme ça
TFeld
Changez f(reduce(int.__mul__,map(int,`n`)))pour f(eval('*'.join(`n`)))enregistrer 13 octets.
mypetlion
@ mypetlion ... je l'ai déjà fait dans un autre post.
Jonathan Allan
5

perl 5 (-n -M5.01 ), 32 30 25 octets

say$_=eval;s/\B/*/g&&redo

25 octets

30 octets

32 octets

Nahuel Fouilleul
la source
Vous devriez mentionner que cela utilise-lpF//
Grimmy
1
@ Grimy je pourrais économiser 2 octets sans utiliser -lpF//, mettre à jour
Nahuel Fouilleul
5

MathGolf , 9 à 10 octets

h(ôo▒ε*h(→

Essayez-le en ligne!

Maintenant, il gère correctement les entrées à un chiffre. Pas parfait, mais au moins c'est correct.

Explication

h(            check length of input number and decrease by 1
  ö       →   while true with pop using the next 6 operators
   p          print with newline
    ▒         split to list of chars/digits
     ε*       reduce list by multiplication
       h(     length of TOS without popping, subtracted by 1 (exits when len(TOS) == 1)
maxb
la source
Le résultat pour une saisie à un chiffre doit être une copie du numéro - précisé dans les commentaires
dzaima
@dzaima J'examinerai la question et mettrai à jour la réponse lorsqu'elle sera résolue
maxb
4

JavaScript (ES6), 45 octets

Retourne un tableau d'entiers.

f=n=>[n,...n>9?f(eval([...n+''].join`*`)):[]]

Essayez-le en ligne!

Arnauld
la source
4

APL (NARS), 19 caractères, 38 octets

{⍵≤9:⍵⋄∇×/⍎¨⍕⍵⊣⎕←⍵}

tester:

   f←{⍵≤9:⍵⋄∇×/⍎¨⍕⍵⊣⎕←⍵}
   f 23     
23
6
   f 27648     
27648
2688
768
336
54
20
0
RosLuP
la source
4

Japt -R , 9 octets

Horriblement inefficace - n'essayez même pas d'exécuter le premier test!

_ì ×}hN â

L'essayer

_ì ×}hN â     :Implicit input of integer U
      N       :Starting with the array of inputs (i.e., [U])
     h        :Do the following U times, pushing the result to N each time
_             :Take the last element in N and pass it through the following function
 ì            :  Convert to digit array
   ×          :  Reduce by multiplication
    }         :End function
        â     :Deduplicate N
              :Implicitly join with newlines and output
Hirsute
la source
3

Brachylog , 7 octets

ẉ?Ḋ|ẹ×↰

Essayez-le en ligne!

Explication

ẉ          Write the input followed by a linebreak
 ?Ḋ        If the input is a single digit, then it's over
   |       Otherwise
    ẹ      Split the input into a list of digits
     ×     Multiply them together
      ↰    Recursive call with the result of the multiplication as input
Fataliser
la source
Je l'ai essayé moi-même. Oublié le. Le reste j'ai eu le même.
Kroppeb
3

JavaScript (Babel Node) , 46 octets

f=a=>a>9?[a,...f(eval([...a+''].join`*`))]:[a]

Essayez-le en ligne!

JavaScript (Babel Node) , 44 octets

Si l'entrée peut être prise comme chaîne

f=a=>a>9?[a,...f(''+eval([...a].join`*`))]:a

Essayez-le en ligne!

Luis Felipe De Jesus Munoz
la source
@Arnauld Oui, je viens d'éditer et d'ajouter le mauvais code. Im toujours à la recherche de quelque chose en utilisant uniquement des chaînes plutôt que des tableaux
Luis De Jesus Munoz felipe
3

PowerShell , 64 59 octets

for($a="$args";9-lt$a){$a;$a="$(($a|% t*y)-join'*'|iex)"}$a

Essayez-le en ligne!

Méthode itérative. Prend une entrée et la stocke dans $a, puis entre dans une forboucle tant que la longueur $aest de deux ou plus (c'est-à-dire qu'elle est plus grande que 9). À l'intérieur de la boucle, nous produisons la sortie $a, puis nous la recalculons en la convertissant avec toCharArra y, en la combinant joinavec *, puis iex(en abrégé Invoke-Expressionet similaire à eval). Une fois que nous sommes sortis de la boucle, il ne reste plus qu'un chiffre à imprimer, nous nous retrouvons $adans le pipeline.

-5 octets grâce à KGlasier.

AdmBorkBork
la source
Vous pouvez utiliser la comparaison 9-lt$aau lieu de $a.length-1pour économiser 5 octets. Et si vous ne vous en teniez pas aux cordes tout le temps, vous pourriez couper un morceau décent. Regarde ma tentative PowerShell si tu veux!
KGlasier
3

Charbon de bois , 13 octets

θＷ⊖Ｌθ«≔ＩΠθθ⸿θ

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

θ

Imprimer la saisie pour la première fois.

Ｗ⊖Ｌθ«

Répétez l'opération tant que la longueur de l'entrée n'est pas 1.

≔ＩΠθθ

Remplacez l’entrée par la conversion numérique du produit en chaîne.

⸿θ

Imprimer l'entrée sur une nouvelle ligne.

Neil
la source
3

Retina , 24 octets

.+~(\`

.
$&$*
^
.+¶$$.(

Essayez-le en ligne! Explication:

.+~(\`

Imprimez la valeur actuelle sur sa propre ligne au début de chaque boucle jusqu'à ce qu'elle arrête de changer et n'imprime pas la valeur inchangée deux fois. Évaluez la valeur actuelle à la fin de chaque boucle.

.
$&$*

Ajoutez un *après chaque chiffre.

^
.+¶$$.(

Terminez la transformation de l'entrée en une expression qui correspond au produit numérique.

Pour mémoire, Retina peut le faire en une seule ligne (25 octets):

.+"¶"<~[".+¶$.("|'*]'*L`.
Neil
la source
3

C (gcc) , 58 octets

f(n,t){for(;n=printf("%d\n",t=n)>2;)for(;n*=t%10,t/=10;);}

Essayez-le en ligne!

L'approche itérative s'avère être plus courte d'un octet.

f(n,t){
    for(;n=printf("%d\n",t=n)   //print and update current number
            >2;)                //until only one digit is printed
        for(;n*=t%10,t/=10;);   //n*= product of digits of t (step)
}

C (gcc) , 61 59 octets (récursif)

f(n){printf("%d\n",n)>2&&f(p(n));}p(n){n=n?n%10*p(n/10):1;}

Essayez-le en ligne!

La récursion semble être plus courte que l'itération pour l'impression et l'étape ...

attinat
la source