Der verrückte Mathematiker besitzt eine breite Sammlung von Zahlen, und deshalb ist der Platz, den er übrig hat, ziemlich begrenzt. Um einiges zu retten, muss er seine ganzen Zahlen falten, aber leider ist er wirklich faul. Wenn Sie ihm helfen möchten, müssen Sie eine Funktion / ein Programm erstellen, die / das eine bestimmte positive ganze Zahl für unseren Zahlenwahnsinnigen faltet.

Wie falte ich eine ganze Zahl?

Wenn es gleichmäßig durch die Summe seiner Ziffern teilbar ist, dividieren Sie es durch die Summe seiner Ziffern. Wenn dies nicht der Fall ist, teilen Sie den Rest durch die Summe der Ziffern. Wiederholen Sie den Vorgang, bis das Ergebnis erreicht ist 1. Die gefaltete Ganzzahl ist die Anzahl der Operationen, die Sie ausführen mussten. Nehmen wir ein Beispiel (sagen wir 1782):

1. Holen Sie die Summe ihrer Ziffern: 1 + 7 + 8 + 2 = 18. 1782ist gleichmäßig teilbar durch 18, die nächste Zahl ist also 1782 / 18 = 99.

2. 99nicht teilbar ist durch 9 + 9 = 18, daher nehmen wir den Rest: 99 % 18 = 9.

3. 9ist offensichtlich teilbar durch 9, also teilen wir es und erhalten 1.

Das Ergebnis ist 3, weil 3 Operationen erforderlich waren, um zu erreichen 1.

Regeln und Spezifikationen

• Bei einigen Ganzzahlen ist die Summe der Ziffern möglicherweise gleich 1, z. B. 10oder 100. Ihr Programm muss solche Fälle nicht behandeln. Das heißt, Sie werden garantiert, dass die als Eingabe angegebene Ganzzahl nicht die gleiche Ziffernsumme 1hat und keine Operation mit der angegebenen Ganzzahl zu einer Zahl führt, deren Ziffernsumme 1(mit Ausnahme von sich 1selbst, der " Ziel"). Zum Beispiel erhalten Sie nie 10oder 20als Eingabe.

• Die Eingabe ist eine positive Ganzzahl höher als 1.

• Es gelten Standardlücken .

• Sie können die Eingabe und Ausgabe mit jedem Standardmittelwert vornehmen .

Testfälle

Eingabe -> Ausgabe

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

Hier ist ein Programm , mit dem Sie den Prozess visualisieren und weitere Testfälle ausprobieren können.

Das ist Code-Golf , also gewinnt der kürzeste Code in jeder Sprache (in Bytes)!

05AB1E , 13 12 Bytes

[¼DSO‰0Kθ©#®

Probieren Sie es online!

Erläuterung

[               # 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 dank totalhuman
-1 dank Mr. Xcoder
-4 dank reffu

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

Probieren Sie es 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

7 Bytes gespart dank Bruce Forte.

Probieren Sie es online aus.

JavaScript (ES6), 66 58 51 49 Bytes

Übernimmt die Eingabe als Ganzzahl. Gibt falsefür 0oder zurück 1und löst einen Überlauffehler aus, wenn eine Zahl gefunden wird, deren Ziffern sich addieren 1.

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

• 8 Bytes mit Hilfe von Justin gespeichert .

Probier es aus

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>

Schale , 12 Bytes

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Lambda-Funktion, die eine Ganzzahl annimmt und zurückgibt.

Japt , 22 19 17 Bytes

-3 Bytes dank @Shaggy.
-2 Bytes dank @ETHproductions

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

Probieren Sie es online!

Retina , 100 Bytes

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

Probieren Sie es online! Link enthält nur kleinere Testfälle, da die größeren zu lange dauern.

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

unäre Ausgabe:

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

Dezimalausgabe, 73 + 1 Byte:

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

Laufen Sie als Pipe mit -nRoder versuchen Sie es online .

Der Elvis-Operator benötigt PHP 5.3 oder höher. Ersetzen Sie ?:bei älteren PHP-Versionen durch ?$n%$s:(+5 Byte).

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

Das fühlt sich wirklich lang an ..

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

Probieren Sie es online!

Vielen Dank an @Laikoni & @nimi für das Abschlagen von jeweils 1 Byte!

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

Probieren Sie es online!

Gelee , 12 Bytes

dDS$Ṛȯ/µÐĿL’

Probieren Sie es online!

Pyth, 20 bis 14 Bytes

tl.ue-.DNsjNT0

Probieren Sie es hier aus.

Perl, 71 Bytes, 64 Bytes, 63 Bytes

-pl

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

Probieren Sie es online aus

BEARBEITEN: 7 Bytes gespart, dank Xcalis Kommentar

-p

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

EDIT: seit 5.14 zerstörungsfreie Ersetzung 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|⍵}

Probieren Sie es online!

Wie?

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

Probieren Sie es online!

Erläuterung

-              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

Eingaben für die Funktion sollten als Zeichenfolge erfolgen, z. B. X ('152').

Die Funktion arbeitet während des Schleifens und Inkrementierens von d. Die x=y;Zeile war notwendig, um zu vermeiden, dass Matlab versuchte, einen Variablenwert gleichzeitig zu lesen und zu überschreiben, anscheinend ein neuer Wert für mich.

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

Probieren Sie es online! Basierend auf der Antwort von 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}

Anonyme Funktion, die die erforderliche Ausgabe zurückgibt.

Überprüfen Sie alle Testfälle!