Il folle matematico possiede una vasta collezione di numeri, e quindi lo spazio che ha lasciato è piuttosto limitato. Per salvarne un po ', deve piegare i suoi numeri interi, ma sfortunatamente è davvero pigro. Il tuo compito, se desideri aiutarlo, è creare una funzione / programma che pieghi un dato intero positivo per il nostro maniaco numerico.

Come piegare un numero intero?

Se è uniformemente divisibile per la somma delle sue cifre, dividerlo per la somma delle sue cifre. Se non soddisfa tale requisito, prendi il resto quando diviso per la somma delle sue cifre. Ripeti il ​​processo fino a quando il risultato non raggiunge 1. Il numero intero piegato è il numero di operazioni che è stato necessario eseguire. Facciamo un esempio (diciamo 1782):

1. Ottenere la somma delle sue cifre: 1 + 7 + 8 + 2 = 18. 1782è uniformemente divisibile per 18, quindi il numero successivo è 1782 / 18 = 99.

2. 99Non è divisibile per 9 + 9 = 18, quindi prendiamo il resto: 99 % 18 = 9.

3. 9è ovviamente divisibile per 9, quindi lo dividiamo e otteniamo 1.

Il risultato è 3perché sono necessarie 3 operazioni per raggiungere 1.

Regole e specifiche

• Alcuni numeri interi possono avere la somma di cifre pari a 1, come 10o 100. Non è necessario che il tuo programma gestisca tali casi. Ciò significa che ti verrà garantito che il numero intero indicato come input non ha la somma delle cifre uguale a 1, e nessuna operazione con il numero intero dato si tradurrà in un numero la cui somma delle cifre è 1(tranne che per 1se stesso, che è il " bersaglio"). Ad esempio, non riceverai mai 10o 20come input.

• L'input sarà un numero intero positivo maggiore di 1.

• Si applicano le lacune predefinite .

• Puoi prendere input e fornire output con qualsiasi media standard .

Casi test

Ingresso -> Uscita

2 -> 1
5 -> 1
9 -> 1
18 -> 2
72 -> 2
152790 -> 2
152 -> 3
666 -> 3
777 -> 3
2010 -> 3
898786854 -> 4

Ecco un programma che ti consente di visualizzare il processo e provare altri casi di test.

Questo è code-golf , quindi vince il codice più corto in ogni lingua (segnato in byte)!

05AB1E , 13 12 byte

[¼DSO‰0Kθ©#®

Provalo online!

Spiegazione

[               # start loop
 ¼              # increment counter
  D             # duplicate current value
   SO           # sum the digits in the copy
     ‰          # divmod the current value by its digit-sum
      0K        # remove 0 from the resulting list
        θ       # pop the last element
         ©      # store a copy in register
          #     # if the current value is 1, break
           ®    # push the copy from register
                # implicitly output counter

Python 2 , 63 57 byte

-1 grazie a totalmente umano
-1 grazie a Mr. Xcoder
-4 grazie a reffu

def f(n):a=sum(map(int,`n`));return n>1and-~f(n%a or n/a)

Provalo online!

Haskell, 85 78 byte

f 1=0
f n|r<1=1+f(n`div`s)|1<2=1+f r where s=sum(read.pure<$>show n);r=n`rem`s

Risparmiato 7 byte grazie a Bruce Forte.

Provalo online.

JavaScript (ES6), 66 58 51 49 byte

Accetta l'input come numero intero. Restituisce falseper 0o 1e genera un errore di overflow quando rileva un numero le cui cifre si sommano 1.

f=n=>n>1&&f(n%(x=eval([...""+n].join`+`))||n/x)+1

• 8 byte salvati con l'aiuto di Justin .

Provalo

o.innerText=(

f=n=>n>1&&f(n%(x=eval([...""+n].join`+`))||n/x)+1

)(i.value=898786854);oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o>

Buccia , 12 byte

←€1¡Ṡ§|÷%oΣd

Provalo online!

Spiegazione

←€1¡Ṡ§|÷%oΣd  Implicit input, e.g. n=1782
    Ṡ§|÷%oΣd  This part defines the transformation.
         oΣ   Sum of
           d  digits: s=18
    Ṡ   %     n mod s: 0
     §|       or (take this branch if last result was 0)
       ÷      n divided by s: 99
   ¡          Iterate the transformation: [1782,99,9,1,1,1,...
 €1           Index of 1 (1-based): 4
←             Decrement: 3
              Print implicitly.

C # (.NET Core) , 87 byte

n=>{int i=0,k,l;for(;n>1;++i){for(l=n,k=0;l>0;l/=10)k+=l%10;n=n%k>0?n%k:n/k;}return i;}

Provalo online!

Funzione lambda che accetta e restituisce un numero intero.

Japt , 22 19 17 byte

-3 byte grazie a @Shaggy.
-2 byte grazie a @ETHproductions

ìx
>1©1+ßU%VªU/V

Provalo online!

Retina , 100 byte

$
;
{`(.+);
$1$*1;$&
(?<=;.*)\d(?=.*;)
$*
.*;1;(.*)
$.1
r`(1)*(\3)*;(1+);
$#1;$#2;1
0;(.*);|;.*;
$1;

Provalo online! Il collegamento include solo casi di test più piccoli poiché quelli più grandi impiegano troppo tempo.

Mathematica, 73 byte

(t=#;For[r=0,t>1,r++,If[(s=Mod[t,g=Tr@IntegerDigits@t])<1,t=t/g,t=s]];r)&

PHP, 68 + 1 byte

uscita unaria:

for($n=$argn;$n>1;$n=$n%($s=array_sum(str_split($n)))?:$n/$s)echo 1;

uscita decimale, 73 + 1 byte:

for($n=$argn;$n>1;$i++)$n=$n%($s=array_sum(str_split($n)))?:$n/$s;echo$i;

Esegui come pipe con -nRo provalo online .

L'operatore Elvis richiede PHP 5.3 o successivo. Per PHP più vecchi, sostituiscili ?:con ?$n%$s:(+5 byte).

Rubino, 46 ​​byte

f=->n{s=n.digits.sum;n<2?0:1+f[n%s<1?n/s:n%s]}

Haskell , 94 93 89 88 byte

Sembra molto lungo ..

length.fst.span(/=1).iterate g
g x|(d,m)<-x`divMod`sum[read[d]|d<-show x]=last$m:[d|m<1]

Provalo online!

Grazie @Laikoni & @nimi per il golf off da 1 byte ciascuno!

C (gcc) , 83 81 76 73 byte

i,k,s;f(n){k=n;for(i=0;k>1;i++,n=k=k%s?:k/s)for(s=0;n;n/=10)s+=n%10;n=i;}

Provalo online!

Gelatina , 12 byte

dDS$Ṛȯ/µÐĿL’

Provalo online!

Pyth, 20 14 byte

tl.ue-.DNsjNT0

Provalo qui.

Perl, 71 byte, 64 byte, 63 byte

-pl

$c=0;while($_>1){$s=0;$s+=$_ for/./g;$_=$_%$s?$_%$s:$_/$s;++$c};$_=$c

Provalo online

EDIT: salvato 7 byte, grazie al commento di Xcali

-p

while($_>1){$s=0;$s+=$_ for/./g;$_=$_%$s?$_%$s:$_/$s;++$c}$_=$c

EDIT: da 5.14 sostituzione non distruttiva s /// r

-pl

while($_>1){$s=eval s/\B/+/gr;$_=$_%$s?$_%$s:$_/$s;++$c}$_=$c

Dyalog APL, 36 byte

{x←+/⍎¨⍕⍵⋄1=⍵:0⋄0=x|⍵:1+∇⍵÷x⋄1+∇x|⍵}

Provalo online!

Come?

{
   x←+/⍎¨⍕⍵      ⍝ x = digit sum
   1=⍵:0         ⍝ if arg = 1: bye
   0=x|⍵:1+∇⍵÷x  ⍝ if arg divisible by x: recurse with arg/x
   1+∇x|⍵        ⍝ recurse with arg mod x
}

Gaia , 13 byte

-@{:ΣZ¤∨)‡}°\

Provalo online!

Spiegazione

-              Push -1 (this will be the counter)
 @             Push input (the starting number)
  {:ΣZ¤∨)‡}°   Repeat this block until the results of 2 consecutive runs are the same:
   :            Copy the number
    Σ           Digital sum
     Z          Divmod number by digital sum
      ¤         Swap
       ∨        Logical or: left-most non-zero out of (number mod sum, number div sum)
        )‡      Increment the counter
            \  Delete the final 1, implicitly print the counter

Matlab, 150 byte

function[d]=X(x) 
d=0;while ~strcmp(x,'1')z='sum(str2num(x(:)))';a=eval(['rem(',x,',',z,')']);y=num2str(a*(a>0)+eval([x,'/',z])*(a==0));x=y;d=d+1;end

Gli input dovrebbero essere dati alla funzione come una stringa, come X ('152').

La funzione funziona durante il ciclo e l'incremento d. Ilx=y; riga era necessaria per evitare un errore di Matlab nel tentativo di leggere e sovrascrivere un valore variabile allo stesso tempo, apparentemente, che era nuovo per me.

Ungolfed:

function[d]=X(x) 
d=0;
while ~strcmp(x,'1')
    z='sum(str2num(x(:)))';
    a=eval(['rem(',x,',',z,')']);
    y=num2str(a*(a>0)+eval([x,'/',z])*(a==0));
    x=y;
    d=d+1;
end

Haskell , 68 byte

f 1=0
f n=1+[f x|x<-[mod n,div n]<*>[sum$read.pure<$>show n],x>0]!!0

Provalo online! Basato sulla risposta di w0lf .

R , 85 byte

function(n){while(n>1){n="if"(x<-n%%(d=sum(n%/%10^(nchar(n):0)%%10)),x,n/d)
F=F+1}
F}

Funzione anonima che restituisce l'output richiesto.

Verifica tutti i casi di test!