Persistance multiplicative

46

Persistance multiplicative

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

Comme expliqué par Numberphile :

Exemple

277777788888899 → 2x7x7x7x7x7x7x8x8x8x8x8x8x9x9 = 4996238671872
4996238671872 → 4x9x9x6x2x3x8x6x7x1x8x7x2 = 438939648
438939648 → 4x3x8x9x3x9x6x4x8 = 4478976
4478976 → 4x4x7x8x9x7x6 = 338688
338688 → 3x3x8x6x8x8 = 27648
27648 → 2x7x6x4x8 = 2688
2688 → 2x6x8x8 = 768
768 → 7x6x8 = 336
336 → 3x3x6 = 54
54 → 5x4 = 20
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

25
10
0

De A003001 aussi:

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
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

$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
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:

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
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
source

8

dzaima / APL , 14 à 11 octets

∪{×/⍎¨⍕⍵}⍡≡

Essayez-le en ligne!

— dzaima
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
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
source

7

Wolfram Language (Mathematica) , 47 octets

Most@FixedPointList[Times@@IntegerDigits@#&,#]&

Essayez-le en ligne!

— J42161217
source

7

Wolfram Language (Mathematica) , 45 octets

#//.x_/;x>9:>Times@@IntegerDigits@x&&Print@x&

Essayez-le en ligne!

— J42161217
source

42 octets si cela ne vous dérange pas d'utiliser Echo.

— Roman

7

Perl 6 , 23 octets

{$_,{[*] .comb}…10>*}

Essayez-le en ligne!

— Grimmy
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
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
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
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
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
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

— Nahuel Fouilleul
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
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

5

Julia 0.7 , 36 33 octets

f(n)=n>9?[n;f(prod(digits(n)))]:n

Essayez-le en ligne!

Merci à H.PWiz pour -3 octets.

— Kirill L.
source

Vous pouvez utiliser[n;f(prod(digits(n)))]

— H.PWiz le

4

JavaScript (ES6), 45 octets

Retourne un tableau d'entiers.

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

Essayez-le en ligne!

— Arnauld
source

4

PowerShell , 51 octets

filter f{$_
if($_-gt9){("$_"|% t*y)-join'*'|iex|f}}

Essayez-le en ligne!

— mazzy
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
source

4

Haskell, 45 octets

f n=n:[x|n>9,x<-f$product$read.pure<$>show n]

Essayez-le en ligne!

— nimi
source

4

J , 16 octets

([:*/,.&.":)^:a:

Essayez-le en ligne!

— Galen Ivanov
source

4

Ruby , 38 35 34 octets

f=->n{p(n)>9&&f[eval n.digits*?*]}

Essayez-le en ligne!

1 octet enregistré par G B.

— Kirill L.
source

4

Japt `-R` , 9 octets

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

_ì ×}hN â

_ì ×}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
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
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
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
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
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
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
source

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.

Licensed under cc by-sa 3.0 with attribution required.