O matemático louco possui uma grande coleção de números e, portanto, o espaço que resta é bastante limitado. Para economizar alguns, ele deve dobrar seus números inteiros, mas infelizmente ele é realmente preguiçoso. Sua tarefa, se você deseja ajudá-lo, é criar uma função / programa que dobre um número inteiro positivo para o nosso número maníaco.

Como dobrar um número inteiro?

Se é igualmente divisível pela soma de seus dígitos, divida-o pela soma de seus dígitos. Se não atender a esse requisito, pegue o restante quando dividido pela soma de seus dígitos. Repita o processo até o resultado chegar 1. O número inteiro dobrado é o número de operações que você teve que executar. Vamos dar um exemplo (digamos 1782):

1. Obter a soma de seus dígitos: 1 + 7 + 8 + 2 = 18. 1782é igualmente divisível por 18, então o próximo número é 1782 / 18 = 99.

2. 99não é divisível por 9 + 9 = 18, por conseguinte, tomamos o restante: 99 % 18 = 9.

3. 9é obviamente divisível por 9, então dividimos e obtemos 1.

O resultado é que 3foram necessárias três operações para alcançar 1.

Regras e especificações

• Alguns números inteiros podem ter a soma dos dígitos iguais a 1, como 10ou 100. Seu programa não precisa lidar com esses casos. Isso significa que você terá a garantia de que o número inteiro fornecido como entrada não tem a soma dos dígitos igual a 1, e nenhuma operação com o número inteiro especificado resultará em um número cuja soma dos dígitos seja 1(exceto 1ela mesma, que é o " alvo"). Por exemplo, você nunca receberá 10ou 20como entrada.

• A entrada será um número inteiro positivo maior que 1.

• Aplicam-se lacunas padrão .

• Você pode receber e fornecer saída por qualquer média padrão .

Casos de teste

Entrada -> Saída

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

Aqui está um programa que permite visualizar o processo e tentar mais casos de teste.

Isso é código-golfe , então o código mais curto em cada idioma (marcado em bytes) vence!

05AB1E , 13 12 bytes

[¼DSO‰0Kθ©#®

Experimente online!

Explicação

[               # 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 bytes

-1 graças a totalmente humano
-1 graças a Mr. Xcoder
-4 graças a reffu

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

Experimente online!

Haskell, 85 78 bytes

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

Economizou 7 bytes graças a Bruce Forte.

Experimente online.

JavaScript (ES6), 66 58 51 49 bytes

Recebe a entrada como um número inteiro. Retorna falsepara 0ou 1e gera um erro de estouro quando encontra qualquer número cujos dígitos sejam somados 1.

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

• 8 bytes salvos com a ajuda de Justin .

Teste-o

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>

Casca , 12 bytes

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

Experimente online!

Explicação

←€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 bytes

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

Experimente online!

Função Lambda que pega e retorna um número inteiro.

Japonês , 22 19 17 bytes

-3 bytes graças a @Shaggy.
-2 bytes graças a @ETHproductions

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

Experimente online!

Retina , 100 bytes

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

Experimente online! O link inclui apenas casos de teste menores, pois os maiores demoram muito.

Mathematica, 73 bytes

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

saída unária:

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

saída decimal, 73 + 1 bytes:

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

Execute como pipe -nRou experimente online .

O operador Elvis requer PHP 5.3 ou posterior. Para PHP antigo, substitua ?:por ?$n%$s:(+5 bytes).

Ruby, 46 bytes

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

Haskell , 94 93 89 88 bytes

Isso parece muito longo ..

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

Experimente online!

Obrigado @Laikoni & @nimi por jogar golfe com 1 byte cada!

C (gcc) , 83 81 76 73 bytes

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

Experimente online!

Gelatina , 12 bytes

dDS$Ṛȯ/µÐĿL’

Experimente online!

Pitão, 20 14 bytes

tl.ue-.DNsjNT0

Experimente aqui.

Perl, 71 bytes, 64 bytes, 63 bytes

-pl

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

Experimente online

EDIT: salvou 7 bytes, graças ao comentário de Xcali

-p

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

EDIT: desde 5.14 substituição não destrutiva s /// r

-pl

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

Dyalog APL, 36 bytes

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

Experimente online!

Quão?

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

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

Experimente online!

Explicação

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

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

As entradas devem ser fornecidas para a função como uma string, como X ('152').

A função funciona enquanto faz loop e incrementa d. A x=y;linha era necessária para evitar um erro do Matlab ao tentar ler e substituir um valor de variável ao mesmo tempo, aparentemente, o que era novo para mim.

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 bytes

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

Experimente online! Com base na resposta de w0lf .

R , 85 bytes

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

Função anônima que retorna a saída necessária.

Verifique todos os casos de teste!