Le mathématicien fou possède une vaste collection de nombres, et donc l'espace qu'il a laissé est assez limité. Pour en sauver, il doit plier ses entiers, mais malheureusement il est vraiment paresseux. Votre tâche, si vous souhaitez l'aider, est de créer une fonction / programme qui plie un entier positif donné pour notre maniaque des nombres.

Comment plier un entier?

S'il est divisible par la somme de ses chiffres, divisez-le par la somme de ses chiffres. S'il ne répond pas à cette exigence, prenez son reste lorsqu'il est divisé par la somme de ses chiffres. Répétez le processus jusqu'à ce que le résultat atteigne 1. L'entier replié est le nombre d'opérations que vous avez dû effectuer. Prenons un exemple (disons 1782):

1. Obtenez la somme de ses chiffres: 1 + 7 + 8 + 2 = 18. 1782est divisible par 18, donc le nombre suivant est 1782 / 18 = 99.

2. 99n'est pas divisibles par 9 + 9 = 18, d' où nous prenons le reste: 99 % 18 = 9.

3. 9est évidemment divisible par 9, donc nous le divisons et obtenons 1.

Le résultat est 3, car 3 opérations ont été nécessaires pour atteindre 1.

Règles et spécifications

• Certains nombres entiers peuvent avoir la somme de chiffres égaux à 1, tels que 10ou 100. Votre programme n'a pas besoin de gérer de tels cas. Cela signifie que vous serez assuré que l'entier donné en entrée n'a pas la somme des chiffres égale à 1, et qu'aucune opération avec l'entier donné ne donnera un nombre dont la somme des chiffres est 1(sauf pour 1lui-même, qui est le " cible"). Par exemple, vous ne recevrez jamais 10ou 20en entrée.

• L'entrée sera un entier positif supérieur à 1.

• Les échappatoires par défaut s'appliquent.

• Vous pouvez prendre des entrées et fournir des sorties par n'importe quel moyen standard .

Cas de test

Entrée -> Sortie

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

Voici un programme qui vous permet de visualiser le processus et d'essayer plus de cas de test.

C'est le code-golf , donc le code le plus court dans chaque langue (marqué en octets) gagne!

05AB1E , 13 12 octets

[¼DSO‰0Kθ©#®

Essayez-le en ligne!

Explication

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

-1 grâce à totalementhumain
-1 grâce à M. Xcoder
-4 grâce à reffu

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

Essayez-le en ligne!

Haskell, 85 78 octets

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

Enregistré 7 octets grâce à Bruce Forte.

Essayez-le en ligne.

JavaScript (ES6), 66 58 51 49 octets

Prend l'entrée comme un entier. Renvoie falsepour 0ou 1et renvoie une erreur de débordement lorsqu'il rencontre un nombre dont les chiffres s'additionnent 1.

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

• 8 octets enregistrés avec l'aide de Justin .

Essaye-le

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>

Husk , 12 octets

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

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

Fonction lambda qui prend et retourne un entier.

Japt , 22 19 17 octets

-3 octets grâce à @Shaggy.
-2 octets grâce à @ETHproductions

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

Essayez-le en ligne!

Rétine , 100 octets

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

Essayez-le en ligne! Link ne comprend que des cas de test plus petits car les plus grands prennent trop de temps.

Mathematica, 73 octets

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

sortie unaire:

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

sortie décimale, 73 + 1 octets:

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

Exécuter en tant que pipe avec -nRou l' essayer en ligne .

L'opérateur Elvis nécessite PHP 5.3 ou une version ultérieure. Pour les anciens PHP, remplacez ?:par ?$n%$s:(+5 octets).

Rubis, 46 octets

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

Haskell , 94 93 89 88 octets

Cela semble vraiment long ..

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

Essayez-le en ligne!

Merci @Laikoni & @nimi pour avoir joué 1 octet chacun!

C (gcc) , 83 81 76 73 octets

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

Essayez-le en ligne!

Gelée , 12 octets

dDS$Ṛȯ/µÐĿL’

Essayez-le en ligne!

Pyth, 20 14 octets

tl.ue-.DNsjNT0

Essayez-le ici.

Perl, 71 octets, 64 octets, 63 octets

-pl

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

Essayez-le en ligne

EDIT: enregistré 7 octets, grâce au commentaire de Xcali

-p

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

EDIT: depuis 5.14 substitution non destructive s /// r

-pl

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

Dyalog APL, 36 octets

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

Essayez-le en ligne!

Comment?

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

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

Essayez-le en ligne!

Explication

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

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

Les entrées doivent être données à la fonction sous la forme d'une chaîne, telle que X ('152').

La fonction fonctionne en bouclant et en incrémentant d. lex=y; ligne était nécessaire pour éviter une erreur de Matlab essayant de lire et d'écraser une valeur de variable en même temps, apparemment, ce qui était nouveau pour moi.

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

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

Essayez-le en ligne! Basé sur la réponse de w0lf .

R , 85 octets

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

Fonction anonyme qui renvoie la sortie requise.

Vérifiez tous les cas de test!