Persistenza moltiplicativa

1. Moltiplica tutte le cifre per un numero
2. Ripeti finché non ti rimane una sola cifra

Come spiegato da Numberphile :

• Numberphile "Cosa c'è di speciale in 277777788888899?"
• Numberphile "Persistenza moltiplicativa (filmati extra)"

Esempio

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

Questo è il record attuale, tra l'altro: il numero più piccolo con il maggior numero di passaggi.

Golf

Un programma che accetta qualsiasi numero intero come input e quindi emette il risultato di ogni passaggio, iniziando con l'input stesso, fino a quando non si preme una singola cifra. Per 277777788888899 l'output dovrebbe essere

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

(Il conteggio del numero di passaggi viene lasciato come esercizio all'utente).

Altri esempi

Da A003001 :

25
10
0

Anche da A003001:

68889
27648
2688
768
336
54
20
0

Dal video di Numberphile :

327
42
8

Quindi c'è stata una domanda sulla persistenza additiva , ma questa è la persistenza moltiplicativa. Inoltre, questa domanda richiede il numero di passaggi come output, mentre sono interessato a vedere i risultati intermedi.

Gelatina , 4 byte

DP$Ƭ

Provalo online!

Spiegazione

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

Come bonus, ecco un TIO che troverà i numeri con il maggior numero di passaggi per un determinato intervallo di numeri di cifre. Ridimensiona bene anche su TIO.

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

-1 byte grazie a @SolomonUcko!

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

L'ingresso è in Ans.
L'output viene visualizzato come richieste di sfida. Il trailing Ansè necessario per stampare l'ultimo passaggio.

Devo ammettere che non ho pensato io stesso a questa formula, piuttosto l'ho trovata qui e modificata per adattarla meglio alla sfida.

EDIT: Dopo aver riletto la sfida, mi sono reso conto che il programma deve terminare se il prodotto è composto da una cifra. Quindi, 2 byte dovevano essere aggiunti per tenere conto di ciò.

Esempio:

24456756
        24456756
prgmCDGF8
        24456756
          201600
               0
11112
           11112
prgmCDGF8
           11112
               2

Spiegazione:

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

Visual Model:
Ans inizia come 125673.
Questo modello copre solo la logica dietro la moltiplicazione delle cifre; tutto il resto è più facile da capire.

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)

Appunti:

TI-BASIC è un linguaggio tokenizzato. Il conteggio dei caratteri non equivale al conteggio dei byte.

10^(è questo token a un byte .

Questo programma non fornirà la corretta sequenza di prodotti con numeri interi superiori a 14 cifre a causa delle limitazioni della precisione decimale sui calcolatori TI.

K (ngn / k) , 9 byte

{*/.'$x}\

Provalo online!

{ }\ continua ad applicare la funzione tra parentesi graffe fino a quando la sequenza non converge

$x formatta l'argomento come una stringa (elenco di caratteri)

.'valutare ciascuno (altri dialetti di k richiedono i due punti .:')

*/ più volte, cioè prodotto

dzaima / APL , 14 11 byte

∪{×/⍎¨⍕⍵}⍡≡

Provalo online!

R , 59 byte

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

Provalo online!

Poiché print invisiblyrestituisce il suo input, possiamo usare print(n)all'interno del whileloop per simulare un do-whileloop. Questo è ispirato da uno dei miei suggerimenti per giocare a golf in R .

L'intestazione aiuta a impedire la stampa di grandi numeri in notazione scientifica.

05AB1E , 7 4 byte

Δ=SP

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Wolfram Language (Mathematica) , 47 byte

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

Provalo online!

Wolfram Language (Mathematica) , 45 byte

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

Provalo online!

Perl 6 , 23 byte

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

Provalo online!

Python 2 ,  46  43 byte

-3 grazie a xnor (confronto incatenato)

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

Provalo online!

PowerShell , 54 byte

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

Provalo online!

Metodo iterativo che prima scrive l'argomento di input, quindi lo converte in una stringa e lo convoglia in una matrice di caratteri. Questo array è unito da un singolo asterisco ed eseguito come comando con l'alias dell'espressione invoke. Poiché questo scrive il numero iniziale fino all'ultimo numero maggiore di 0, (20, nello scenario di test indicato), aggiungo un finale $aalla fine all'output.

C # (compilatore interattivo Visual C #) , 79 74 68 byte

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

Cerco di stare lontano dalla ricorsione in C # a causa di quanto tempo è la dichiarazione del metodo, ma in questo caso salva rispetto a un ciclo.

Provalo online!

PHP , 63 byte

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

Versione iterativa, chiamata con php -nFinput da STDIN.

Provalo online!

PHP ,72 71 byte

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

Provalo online!

Versione ricorsiva, come funzione.

Ingresso: 277777788888899

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

Ingresso: 23

23
6

Python 2 , 61 62 59 byte

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

Provalo online!

_{-3 byte, grazie a Jonathan Allan}

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

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

25 byte

30 byte

32 byte

MathGolf , 9 10 byte

h(ôo▒ε*h(→

Provalo online!

Ora gestisce correttamente input composti da singole cifre. Non perfetto, ma almeno è corretto.

Spiegazione

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)

Julia 0.7 , 36 33 byte

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

Provalo online!

Grazie a H.PWiz per -3 byte.

JavaScript (ES6), 45 byte

Restituisce una matrice di numeri interi.

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

Provalo online!

PowerShell , 51 byte

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

Provalo online!

APL (NARS), 19 caratteri, 38 byte

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

test:

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

Haskell, 45 byte

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

Provalo online!

J , 16 byte

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

Provalo online!

Rubino , 38 35 34 byte

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

Provalo online!

1 byte salvato da G B.

Japt -R , 9 byte

Orribilmente inefficiente: non provare nemmeno a eseguire il primo caso di test!

_ì ×}hN â

Provalo

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

Brachylog , 7 byte

ẉ?Ḋ|ẹ×↰

Provalo online!

Spiegazione

ẉ          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

JavaScript (Babel Node) , 46 byte

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

Provalo online!

JavaScript (Babel Node) , 44 byte

Se l'input può essere preso come stringa

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

Provalo online!

PowerShell , 64 59 byte

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

Provalo online!

Metodo iterativo. Prende l'input e lo memorizza $a, quindi entra in un forloop fintanto che la lunghezza di $aè due o più (cioè è più grande di 9). All'interno del loop viene emesso $ae quindi ricalcolato convertendolo in toCharArra y, ingloppandolo joincon *, e quindi iex(abbreviazione di Invoke-Expressione simile a eval). Una volta che siamo fuori dal giro, ci resta una sola cifra da stampare, quindi ci posizioniamo $anuovamente sulla pipeline.

-5 byte grazie a KGlasier.

Carbone , 13 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

θ

Stampa l'input per la prima volta.

Ｗ⊖Ｌθ«

Ripetere finché la lunghezza dell'ingresso non è 1.

≔ＩΠθθ

Sostituisci l'input con il cast del suo prodotto digitale su stringa.

⸿θ

Stampa l'input su una nuova riga.

Retina , 24 byte

.+~(\`

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

Provalo online! Spiegazione:

.+~(\`

Stampa il valore corrente su una riga all'inizio di ogni ciclo fino a quando non si interrompe e non stampa due volte il valore invariato. Valuta il valore corrente alla fine di ogni ciclo.

.
$&$*

Aggiungi un *dopo ogni cifra.

^
.+¶$$.(

Termina di trasformare l'input in un'espressione che valuta il prodotto digitale.

Solo per la cronaca, Retina può farlo in una riga (25 byte):

.+"¶"<~[".+¶$.("|'*]'*L`.

C (gcc) , 58 byte

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

Provalo online!

L'approccio iterativo risulta essere 1 byte più breve.

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 byte (ricorsivo)

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

Provalo online!

La ricorsione sembra essere più breve dell'iterazione sia per la stampa che per il passaggio ...