Additive Persistence

Question

The shortest code to pass all possibilities wins.

In mathematics, the persistence of a number measures how many times a certain operation must be applied to its digits until some certain fixed condition is reached. You can determine the additive persistence of a positive integer by adding the digits of the integer and repeating. You would keep adding the digits of the sum until a single digit number is found. The number of repetitions it took to reach that single digit number is the additive persistence of that number.

Example using 84523:

84523
8 +たす 4 +たす 5 +たす 2 +たす 3 =わ 22
2 +たす 2 =わ 4
It took two repetitions to find the single digit number.
So the additive persistence of 84523 is 2.

You will be given a sequence of positive integers that you have to calculate the additive persistence of. Each line will contain a different integer to process. Input may be in any standard I/O methods.

For each integer, you must output the integer, followed by a single space, followed by its additive persistence. Each integer processed must be on its own line.

Test Cases

---

Input Output

99999999999 3
10 1
8 0
19999999999999999999999 4
6234 2
74621 2
39 2
2677889 3
0 0

• Peter Taylor: Your test cases include some values which are over 2^64, and your spec says that the program only has to handle values up to 2^32. Might be worth clearing that up.
• Kevin Brown-Silva: @Peter Taylor, forgot to remove those limits. If a program can handle the input I have provided, it shouldn't have an issue with limits.
• Eelvex: Isn't 999999999999's persistence 2 instead of 3?
• Kevin Brown-Silva: @Evelex, that was an incorrect last minute change I guess. Fixed.
• Jesse Millikan: Several answers here aren't doing output on stdout but rather use J's "interactive" output by returning results after taking command line input. (This includes 2 other J answers and, I'm guessing, the K answer.) Is this considered legit? Because I can shed 18-ish characters if so.

Answer 1

Japt -mR, (削除) 21 (削除ここまで) (削除) 19 (削除ここまで) 15 bytes

+S+Uì Å£=ìxÃâ Ê

Try it

+S+Uì Å£=ìxÃâ Ê :Implicit map of each U in input array
+S+ :Append a space and
 Uì : Convert U to digit array
 Å : Slice off the first element
 £ : Map
 = : Reassign to U
 ìx : Convert to digit array and reduce by addition
 Ã : End map
 â : Deduplicate
 Ê : Length
 :Implicit output joined with newlines

Answer 2

Perl 5, 65 bytes

$b=0;$q=s/\n//r;$_=eval s/./+$&/gr while y///c>1&&++$b;say"$q $b"

Try it online!

Answer 3

Java (OpenJDK 8), 79 bytes

a->{int d=0;while(a/10>0){int c=0;d++;while(a>0){c+=a%10;a/=10;}a=c;}return d;}

Try it online!

There's probable potential to golf it further, but I'll look into that in the future, but for now, I'm pretty happy with this little result.

• Jonathan Frech: 70 bytes.
• ceilingcat: Building on @JonathanFrech 67 bytes

Answer 4

Python 3, 82 bytes

while 1:f=lambda n:n//10and 1+f(sum(map(int,str(n))));i=input();print(i,f(int(i)))

Answer 5

Japt, 28 bytes

Ë+S+(@D=X©A<D©ì x aD D<AÃa÷
Ë // Map over the inputs and return each, followed by
 +S+ // a space, followed by the number's persistence.
 D= ©ì x // To find it, fold the number up
 X©A<D aD // if we can (handles unfoldable cases),
 (@ D<AÃa // until it can't be folded up any further.
 ÷ // Then, join everything up with newlines.

Try it online!

Answer 6

PHP, 72+1 bytes

+1 for -R flag.

for($i=0,$a=$argn;$a>9;$i++)$a=array_sum(str_split($a));echo"$argn $i
";

Run as pipe with -R.

• running PHP as pipe will execute the code once for every input line
• but it does not unset variables inbetween; so $i must be initialized.
  (Also, it would print nothing instead of 0 for single digits without the initialization.)

Answer 7

Bash+coreutils, 83 bytes

[ 1ドル -le 9 ]&&exit 2ドル
let x=2ドル+1
for z in `fold -w1<<<1ドル`
do let y+=$z
done
a $y $x

Try it online!

Should be saved to a script called a and placed in the system's PATH, as it calls itself recursively. Takes input from command line, like a 1999. Returns by exit code.

TIO has some limitations on what you can do with a script, so there's some boilerplate code to make this run in the header.

Prints an error to stderr for input larger than bash integers can handle, but since the actual computation is done with strings, it still gives the right result anyway.

Answer 8

C (gcc), (削除) 87 (削除ここまで) 85 bytes

• Saved two bytes thanks to ceilingcat; pulling the t=s assignment forward and using (t=s)[1] ~ *((t=s)+1) ~ *(1+(t=s)) ~ 1[t=s].

f(n,p){char*t,s[99];for(p=0;sprintf(s,"%d",n),1[t=s];p++)for(n=0;*t;n+=*t++-48);n=p;}

Try it online!

• Jonathan Frech: @ceilingcat That is quite neat.

Answer 9

Python 2, 62 bytes

f=lambda x,i=0:f(`sum(int(i)for i in x)`,i+1)if len(x)>1else i

Answer 10

Python 3, 76 bytes

def f(n,i=0,p=0):p=p or n;f(sum(map(int,str(n))),i+1,p)if n>9else print(p,i)

Try it online!

---

Without I/O restrictions:

Python 3, 54 bytes

f=lambda n,i=0:f(sum(map(int,str(n))),i+1)if n>9else i

Try it online!

Answer 11

Python 3, 50 bytes

f=lambda n:0if n<10else-~f(eval('+'.join(str(n))))

Recursive function. Takes an integer, returns an integer.

Explanation:

# create a lambda function which takes one argument, and assign it to f
f=lambda n:\
 # if n is 0-9, it's persistence 0
 0if n<10\
 # otherwise, add one to the running total and recursively call f
 # ( ~ will invert the returned number, equivalent to -n-1)
 # (negating that gives you -(-n-1) = n+1)
 else-~f(
 # convert integet to string, join each character with a '+'
 # gives a string like '1+2+3+4+...+n'
 # evaluate the string as an expression, giving a new integer
 # pass that integer back into f
 eval('+'.join(str(n)))
 )

Answer 12

Pyth, 17 bytes

FG.Qs[Gdtl.usjNTG

Try it online!

If I can instead of values on different lines, take a list of numbers (in the format [9999999999, 10, 8, etc.]), then -1 byte by replacing .Q with Q

F # For
 G.Q # G in the complete input (split by newlines)
 s[ # join the list as string, create list from the following values:
 Gd # G, " " (for output formatting),
 tl # decrement length of
 .u G # List of all intermediate results until there's a returning result, with starting value G
 s # reduce on + (add all list elements) the list:
 j # convert to integer as list:
 N # The current value (implicit input to .u)
 T # in base 10 (T=10)

Answer 13

Swift 5, 106 bytes

func a(_ s:S,_ i:I)->(S,I){if s.count<=1{return(s,i)};return a(S(s.compactMap{I(S(0ドル))}.reduce(0,+)),i+1)}

Try it online!

Answer 14

><>, 36 bytes

0{:a(7$.0}\~1+!
~n
1:,a}+{%a:/?(1:-%

Try it online!

Answer 15

Nibbles, 7 bytes (14 nibbles)

:,ドル>>`.$/`@~$+

 # (implicitly map over input):
:$ # prepend input onto
 , # length 
 >> # (without first item) of
 `. # iterate while unique
 $ # starting with input number:
 `@~$ # convert to base-10 digits
 / # and fold over this list
 + # adding its elements

enter image description here

Answer 16

Go, 77 bytes

func f(n int)int{s:=0
if n<10{return 0}
for;n>0;n/=10{s+=n%10}
return 1+f(s)}

Attempt This Online!

Answer 17

Tcl, 94 bytes

proc P {v n\ 0} {set s $v
while \$s>9 {set s [expr [join [split $s ""] +]]
incr n}
list $v $n}

Try it online!

• fəˈnɛtɪk: Because the next newest answer is a full 6 years old, which i think is before TIO existed

Answer 18

AWK, 63 bytes

{for(;1<l=split(1,ドルa,X);i++){1ドル=0;for(j=0;j++<l;)1ドル+=a[j]}}0ドル=i

Attempt This Online!

Answer 19

Raku (Perl 6) (rakudo), 54 bytes

{my ($t,$c)=$^a,0;while $t>9 {$t=[+] $t.comb;$c++};$c}

Attempt This Online!