El loco matemático posee una amplia colección de números y, por lo tanto, el espacio que le queda es bastante limitado. Para salvar a algunos, debe doblar sus enteros, pero desafortunadamente es muy vago. Su tarea, si desea ayudarlo, es crear una función / programa que pliegue un entero positivo dado para nuestro número loco.

¿Cómo doblar un número entero?

Si es divisible por la suma de sus dígitos, divídalo por la suma de sus dígitos. Si no cumple con ese requisito, tome su resto cuando se divida por la suma de sus dígitos. Repita el proceso hasta que llegue el resultado 1. El número entero plegado es el número de operaciones que tuvo que realizar. Tomemos un ejemplo (digamos 1782):

1. Obtener la suma de sus dígitos: 1 + 7 + 8 + 2 = 18. 1782es divisible por 18, entonces el siguiente número es 1782 / 18 = 99.

2. 99No es divisible por 9 + 9 = 18, por lo tanto, tomamos el resto: 99 % 18 = 9.

3. 9obviamente es divisible por 9, entonces lo dividimos y obtenemos 1.

El resultado es 3, porque se necesitaron 3 operaciones para llegar 1.

Reglas y especificaciones

• Algunos enteros pueden tener la suma de dígitos igual a 1, como 10o 100. Su programa no necesita manejar tales casos. Eso significa que se le garantizará que el entero dado como entrada no tiene la suma de dígitos igual a 1, y ninguna operación con el entero dado dará como resultado un número cuya suma de dígitos es 1(a excepción de 1sí mismo, que es el " objetivo"). Por ejemplo, nunca recibirá 10ni 20como entrada.

• La entrada será un número entero positivo mayor que 1.

• Se aplican las lagunas predeterminadas .

• Puede tomar entrada y proporcionar salida por cualquier medio estándar .

Casos de prueba

Entrada -> Salida

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

Aquí hay un programa que le permite visualizar el proceso y probar más casos de prueba.

Este es el código de golf , por lo que gana el código más corto en cada idioma (puntuado en bytes).

05AB1E , 13 12 bytes

[¼DSO‰0Kθ©#®

Pruébalo en línea!

Explicación

[               # 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 gracias a totalmente humano
-1 gracias al Sr. Xcoder
-4 gracias a reffu

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

Pruébalo en línea!

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

Guardado 7 bytes gracias a Bruce Forte.

Pruébalo en línea.

JavaScript (ES6), 66 58 51 49 bytes

Toma la entrada como un entero. Las devoluciones falsede 0o 1y lanza un error de desbordamiento cuando se encuentra con cualquier número cuyos dígitos suman 1.

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

• 8 bytes guardados con la ayuda de Justin .

Pruébalo

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>

Casco , 12 bytes

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Función lambda que toma y devuelve un entero.

Japt , 22 19 17 bytes

-3 bytes gracias a @Shaggy.
-2 bytes gracias a @ETHproductions

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

Pruébalo en línea!

Retina , 100 bytes

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

Pruébalo en línea! Link solo incluye casos de prueba más pequeños, ya que los más grandes tardan demasiado.

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

salida unaria:

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

salida decimal, 73 + 1 bytes:

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

Ejecutar como tubería -nRo probarlo en línea .

El operador de Elvis requiere PHP 5.3 o posterior. Para PHP más antiguo, reemplace ?:con ?$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

Esto se siente muy largo ...

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

Pruébalo en línea!

¡Gracias @Laikoni y @nimi por jugar 1 byte cada uno!

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

Pruébalo en línea!

Jalea , 12 bytes

dDS$Ṛȯ/µÐĿL’

Pruébalo en línea!

Pyth, 20 14 bytes

tl.ue-.DNsjNT0

Pruébalo aquí

Perl, 71 bytes, 64 bytes, 63 bytes

-pl

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

Pruébalo en línea

EDITAR: guardado 7 bytes, gracias al comentario de Xcali

-p

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

EDITAR: desde 5.14 sustitución no destructiva 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|⍵}

Pruébalo en línea!

¿Cómo?

{
   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¤∨)‡}°\

Pruébalo en línea!

Explicación

-              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

Las entradas deben darse a la función como una cadena, como X ('152').

La función funciona mientras se repite e incrementa d. La x=y;línea era necesaria para evitar un error de Matlab al intentar leer y sobrescribir un valor variable al mismo tiempo, aparentemente, que era nuevo para mí.

Sin golf:

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

Pruébalo en línea! Basado en la respuesta 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}

Función anónima que devuelve la salida requerida.

¡Verifique todos los casos de prueba!