20
\$\begingroup\$

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
\$\endgroup\$
  • 1
    \$\begingroup\$ 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. \$\endgroup\$ – Peter Taylor Mar 25 '11 at 23:40
  • \$\begingroup\$ @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. \$\endgroup\$ – Kevin Brown Mar 25 '11 at 23:49
  • 5
    \$\begingroup\$ Isn't 999999999999's persistence 2 instead of 3? \$\endgroup\$ – Eelvex Mar 26 '11 at 2:13
  • \$\begingroup\$ @Evelex, that was an incorrect last minute change I guess. Fixed. \$\endgroup\$ – Kevin Brown Mar 26 '11 at 21:45
  • \$\begingroup\$ 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. \$\endgroup\$ – Jesse Millikan Mar 27 '11 at 1:29

38 Answers 38

6
\$\begingroup\$

K - 29 Chars

Input is a filename passed as an argument, 29 chars not including filename.

`0:{5:x,-1+#(+/10_vs)\x}'.:'0:"file"
  • 35 -> 31: Remove outside function.
  • 31 -> 29: Remove parens.
\$\endgroup\$
  • 1
    \$\begingroup\$ -1+# => #1_ \$\endgroup\$ – streetster Aug 6 at 11:24
4
\$\begingroup\$

Python 84 Chars

while 1:
 m=n=int(raw_input());c=0
 while n>9:c+=1;n=sum(map(int,str(n)))
 print m,c
\$\endgroup\$
  • \$\begingroup\$ Challenge case:06234 .. result successful challenge :-) \$\endgroup\$ – Quixotic Mar 26 '11 at 6:01
  • \$\begingroup\$ @Debanjan Thanks. Corrected. \$\endgroup\$ – fR0DDY Mar 26 '11 at 10:08
4
\$\begingroup\$

Haskell, 100 characters

p[d]=0
p d=1+(p.show.sum$map((-48+).fromEnum)d)
f n=n++' ':shows(p n)"\n"
main=interact$(f=<<).lines
\$\endgroup\$
  • \$\begingroup\$ You can save 6 bytes by using read.pure instead of (-48+).fromEnum, try it online! \$\endgroup\$ – ბიმო Apr 25 '18 at 15:17
4
\$\begingroup\$

Python (93 bytes)

f=lambda n,c:n>9and f(sum(map(int,str(n))),c+1)or c
while 1:n=int(raw_input());print n,f(n,0)
\$\endgroup\$
  • \$\begingroup\$ i think you can remove the space between 9 and err...and \$\endgroup\$ – st0le Mar 26 '11 at 8:52
  • \$\begingroup\$ @st0le:Thanks :-) \$\endgroup\$ – Quixotic Mar 28 '11 at 6:17
  • \$\begingroup\$ and input() instead of int(raw_input()).... \$\endgroup\$ – st0le Mar 28 '11 at 6:48
  • \$\begingroup\$ @st0le:Try this input with that modification:06234. \$\endgroup\$ – Quixotic Mar 28 '11 at 7:12
4
\$\begingroup\$

Husk, 10 15 bytes

+5 bytes for horrible I/O requirement

m(wΓ·,LU¡oΣdr)¶

Try it online!

Explanation

To support multiple inputs, we need to use m(₁r)¶ (where is the function doing the interesting computation):

m(₁r)¶  -- expects newline-separated inputs: "x₁␤x₂␤…␤xₙ"
     ¶  -- split on newlines: ["x₁","x₂",…,"xₙ"]
m(  )   -- map over each string
 ( r)   -- | read integer: [x₁,x₂,…,xₙ]
 (₁ )   -- | apply the function described below

The function does the following:

wΓ·,LU¡(Σd)  -- input is an integer, eg: 1234
      ¡(  )  -- iterate the following forever and collect results in list:
       ( d)  -- | digits: [1,2,3,4]
       (Σ )  -- | sum: 10
             -- : [1234,10,1,1,1,…
     U       -- keep longest prefix until repetition: [1234,10,1]
 Γ           -- pattern match (x = first element (1234), xs = tail ([10,1])) with:
  · L        -- | length of xs: 2
   ,         -- | construct tuple: (1234,2)
w            -- join with space: "1234 2"
\$\endgroup\$
3
\$\begingroup\$

bash, 105 chars

while read x
do
for((i=0,z=x;x>9;i++))do
for((y=0;x>0;y+=x%10,x/=10))do :
done
x=$y
done
echo $z $i
done

Hardly any golfing actually involved, but I can't see how to improve it.

\$\endgroup\$
3
\$\begingroup\$

Haskell - 114

s t n|n>9=s(t+1)$sum$map(read.(:[]))$show n|1>0=show t
f n=show n++" "++s 0n++"\n"
main=interact$(f.read=<<).lines
\$\endgroup\$
  • \$\begingroup\$ You can save 4 bytes by using pure over (:[]) and defining an operator instead of s, try it online! \$\endgroup\$ – ბიმო Apr 25 '18 at 15:22
3
\$\begingroup\$

Ruby, 85 Chars

puts $<.map{|n|v=n.chop!;c=0;[c+=1,n="#{n.sum-n.size*48}"] while n[1];[v,c]*' '}*"\n"

I had to borrow the "sum-size*48" idea from Alex, because it's just too neat to miss (in Ruby at least).

\$\endgroup\$
3
\$\begingroup\$

Golfscript, 40 chars

n%{.:${;${48-}%{+}*`:$,}%.,1>\1?+' '\n}%
\$\endgroup\$
3
\$\begingroup\$

J - 45 Chars

Reads from stdin

(,' ',[:":@<:@#+/&.:("."0)^:a:)&><;._2(1!:1)3
\$\endgroup\$
  • \$\begingroup\$ I was trying to use ^:a: myself but I couldn't find some proper documentation... any hints? \$\endgroup\$ – Eelvex Mar 26 '11 at 16:12
  • 1
    \$\begingroup\$ The dictionary entry for u^:n has info on its usage but it is a bit dense. ^:a: is like any other call to power but it collects the results and ends when the argument to consecutive calls is the same(converges). \$\endgroup\$ – isawdrones Mar 26 '11 at 17:21
  • 1
    \$\begingroup\$ @Eelvex FWIW I discovered a: through the ^:a: trick in the J Reference Card[PDF] \$\endgroup\$ – J B Mar 27 '11 at 0:55
  • \$\begingroup\$ @JB: That's the only reference on ^:a: that I knew :D \$\endgroup\$ – Eelvex Mar 27 '11 at 0:59
  • \$\begingroup\$ @Eelvex Oh. I had the opposite experience then. I discovered the functionality in the dictionary, and used it as some variant of ^:(<'') at first (probably for Kaprekar), until I spotted it in the card, and learned about a: for the occasion. \$\endgroup\$ – J B Mar 27 '11 at 10:43
3
\$\begingroup\$

c -- 519

(or 137 if you credit me for the framework...)

Rather than solving just this one operation, I decided to produce a framework for solving all persistence problems.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef char*(*O)(char*);
char*b(char*s){long long int v=0,i,l=0;char*t=0;l=strlen(s);t=malloc(l+2);
for(i=0;i<l;i++)v+=s[i]-'0';snprintf(t,l+2,"%lld",v);return t;}
int a(char**s,O o){int r;char*n;n=o(*s);r=!strcmp(*s,n);free(*s);
*s=n;return r;}
int main(int c, char**v){size_t l, m=0;char *d,*n=0;O o=b;FILE*f=stdin;
while(((l=getline(&n,&m,f))>1)&&!feof(f)){int i=0;n=strsep(&n,"\n");
d=strdup(n);while(!a(&n,o))i++;printf("%s %d\n",d,i);free(d);free(n);n=0;m=0;}}

Only the two lines starting from char*b are unique to this problem.

It treats the input as strings, meaning that leading "0"s are not strip before the output stage.

The above has had comments, error checking and reporting, and file reading (input must come from the standard input) striped out of:

/* persistence.c
 *
 * A general framework for finding the "persistence" of input strings
 * on opperations.
 *
 * Persistence is defined as the number of times we must apply
 *
 *    value_n+1 <-- Opperation(value_n)
 *
 * before we first reach a fixed point.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../getline.h"

/* A function pointer type for operations */
typedef char*(op_func)(char*);
typedef op_func* op_ptr;
/* Op functions must
 * + Accept the signature above
 * + return a point to a newly allocated buffer containing the updated str
 */

char* addop(char*s){
  int i,l=0;
  long long int v=0;
  char *t=NULL;
  /* protect against bad input */
  if (NULL==s) return s;
  /* allocate the new buffer */
  l = strlen(s);
  t = malloc(l+2);
  if (NULL==t) return t;
  /* walk the characters of the original adding as we go */
  for (i=0; i<l; i++) v += s[i]-'0';
  //fprintf(stderr,"   '%s' (%d) yields %lld\n",s,l,v);
  snprintf(t,l+2,"%lld",v);
  //fprintf(stderr,"   %lld is converted to '%s'\n",v,t);
  return t;
}

/* Apply op(str), return true if the argument is a fixed point fo
 * falsse otherwise,
 */ 
int apply(char**str, op_ptr op){ 
  int r;
  char*nstr;
  /* protect against bad input */
  if ( NULL==op ) exit(1); 
  if ( NULL==*str ) exit(4); 
  /* apply */
  nstr = op(*str); 
  /* test for bad output */
  if ( NULL==nstr ) exit(2); 
  r = !strcmp(*str,nstr); 
  /* free previous buffer, and reasign the new one */
  free(*str); 
  *str = nstr; 
  return r; 
}

int main(int argc, char**argv){
  size_t len, llen=0;
  char *c,*line=NULL;
  op_ptr op=addop;
  FILE *f=stdin;
  if (argc > 1) f = fopen(argv[1],"r");
  while( ((len=getline(&line,&llen,f))>1) && line!=NULL && !feof(f) ){
    int i=0;
    line=strsep(&line,"\n"); // Strip the ending newline
    /* keep a copy for later */
    c = strdup(line);
    /* count necessary applications */
    while(!apply(&line,op)) i++;
    printf("%s %d\n",c,i);
    /* memory management */
    free(c);
    free(line);
    line=NULL;
    llen=0;
  }
}

A little more could be saved if we were willing to leak memory like a sieve. Likewise by #defineing return and the like, but at this point I don't care to make it any uglier.

\$\endgroup\$
2
\$\begingroup\$

J, 74 chars

i=:<;._2(1!:1)3
i&((],' ',":@(0 i.~9<[:".([:":[:+/"."0)^:(i.9)))@>@{~)i.#i

Edits

  • (86 → 83) Some Caps [: to Ats @
  • (83 → 79) Unneeded parentheses
  • (79 → 75) Changing 0". to ". simplifies things
  • (75 → 74) Better Cutting

E.g

i=:<;._2(1!:1)3
74621
39
2677889
0
i&((],' ',":@(0 i.~9<[:".([:":[:+/"."0)^:(i.9)))@>@{~)i.#i
74621 2  
39 2     
2677889 3
0 0  
\$\endgroup\$
  • \$\begingroup\$ Output is formatted wrong for multiple inputs. See "single space" \$\endgroup\$ – Jesse Millikan Mar 27 '11 at 1:54
  • \$\begingroup\$ @Jesse: I see nothing wrong. Could you write an example please? \$\endgroup\$ – Eelvex Mar 27 '11 at 2:09
  • \$\begingroup\$ I have no idea, I'm seeing things I guess. \$\endgroup\$ – Jesse Millikan Mar 27 '11 at 2:18
1
\$\begingroup\$

I think this is about the best I can come up with.

Ruby 101 Chars

f=->(n){n.sum-n.size*48}
$<.each{|l|i=0;i+=1 while(i+=1;n=f[(n||l.chop!).to_s])>10
puts "#{l} #{i}"}
\$\endgroup\$
  • \$\begingroup\$ Actually, chop! instead of chomp! gives me a one character savings. 97 chars. \$\endgroup\$ – Alex Bartlow Mar 26 '11 at 2:20
  • \$\begingroup\$ Just did some more golfing at it - 91 chars. \$\endgroup\$ – Alex Bartlow Mar 26 '11 at 2:26
1
\$\begingroup\$

PARI/GP 101 Chars

s(n)=r=0;while(n>0,r+=n%10;n\=10);r
f(n)=c=0;while(n>9,c++;n=s(n));c
while(n=input(),print(n," ",f(n)))

Unfortunately, there's no input function for GP, so i guess this lacks the IO part. :( Fixed: Thanks Eelvex! :)

\$\endgroup\$
  • \$\begingroup\$ Sure there is: input() :) \$\endgroup\$ – Eelvex Mar 26 '11 at 5:23
  • \$\begingroup\$ @Eelvex, done. :) \$\endgroup\$ – st0le Mar 26 '11 at 5:53
1
\$\begingroup\$

Javascript - 95

i=prompt();while(i>9){i=''+i;t=0;for(j=0;j<i.length;j++)t+=parseInt(i.charAt(j));i=t;}alert(t);

EDIT: Whoops does'nt do the multi-lines

\$\endgroup\$
  • 1
    \$\begingroup\$ Just noticed this doesn't output it correctly. \$\endgroup\$ – Kevin Brown Mar 30 '11 at 19:04
1
\$\begingroup\$

J, 78

f=:[:+/"."0&":
r=:>:@$:@f`0:@.(=f)
(4(1!:2)~LF,~[:":@([,r)".@,&'x');._2(1!:1)3

Recursive solution. Reads from stdin. Writes to stdout, so cut me some slack - it does take an extra 18-ish characters.

\$\endgroup\$
1
\$\begingroup\$

Perl - 77 characters

sub'_{split//,shift;@_<2?0:1+_(eval join'+',@_)}chop,print$_,$",(_$_),$/for<>
\$\endgroup\$
1
\$\begingroup\$

JavaScript, 57 47 bytes

-10 bytes thanks to @l4m2!

f=(s,c=0)=>s>9?f(eval([...s+""].join`+`),++c):c

Try it online!

\$\endgroup\$
  • \$\begingroup\$ f=(s,c=0)=>s>9?f([...s+""].reduce((x,y)=>x*1+y*1),++c):c \$\endgroup\$ – l4m2 May 5 '18 at 11:10
  • \$\begingroup\$ f=(s,c=0)=>s>9?f([...s+""].reduce((x,y)=>x- -y),++c):c \$\endgroup\$ – l4m2 May 5 '18 at 11:11
  • 1
    \$\begingroup\$ f=(s,c=0)=>s>9?f(eval([...s+""].join`+`)),++c):c \$\endgroup\$ – l4m2 May 5 '18 at 11:11
  • \$\begingroup\$ @l4m2 Thanks! s>9 and eval were great ideas. I think you had an extra paren in there, making it a total of 10 bytes you saved me :-) \$\endgroup\$ – Oliver May 7 '18 at 0:35
  • \$\begingroup\$ Note the strict I/O ;) \$\endgroup\$ – Shaggy May 14 '18 at 14:28
1
\$\begingroup\$

05AB1E, 13 bytes

ε.µΔSO¼}¾}<ø»

Input as a list of integers.

Try it online.

Explanation:

ε     # Map each integer in the (implicit) input to:
 .µ   #  Reset the counter variable to 0
 Δ    #  Loop until the integer no longer changes:
  S   #   Convert it to a list of digits
   O  #   And take the sum of those
  ¼   #   Increase the counter variable by 1
 }¾   #  After the inner loop: Push the counter variable
}<    # After the map: decrease each value by 1
  ø   # Zip/transpose it with the (implicit) input to create a paired list
   »  # Join each pair by a space, and then each string by newlines
      # (after which the result is output implicitly)
\$\endgroup\$
1
\$\begingroup\$

MathGolf, 11 bytes

hÅ_Σ]▀£(k ?

Try it online!

Incredibly inefficient, but we don't care about that. Basically, using the fact that the additive persistence of a number is smaller than or equal to the number itself.

Uses the fact that the additive persistence is less than or equal to the number of digits of the number. Passes all test cases with ease now.

The input format, while suboptimal for some languages, is actually the standard method of taking multiple test cases as input in MathGolf. Each line of the input is processed as its own program execution, and output is separated by a single newline for each execution.

Explanation (using n = 6234)

h             push length of number without popping (6234, 4)
 Å            loop 4 times using next 2 operators
  _           duplicate TOS
   Σ          get the digit sum
    ]         wrap stack in array
              this gives the array [6234, 15, 6, 6, 6]
     ▀        unique elements of string/list ([6234, 15, 6])
      £       length of array/string with pop (3)
       (      decrement (2)
        k ?   push input, space, and rotate top 3 elements to produce output (6234 2)
\$\endgroup\$
1
\$\begingroup\$

K (ngn/k), 16 bytes

Solution:

{x,#1_(+/10\)\x} 

Try it online!

Explanation:

{x,#1_(+/10\)\x} / the solution
{              } / lambda taking implicit x
      (     )\x  / iterate until convergence
         10\     / split into base-10 (123 => 1 2 3)
       +/        / sum
    1_           / drop first result (iterate returns input as first result)
   #             / count length of result
 x,              / prepend x (original input)
\$\endgroup\$
1
\$\begingroup\$

Stax, 8 11 bytes

ªwæMε∞ö?îm⌐

Run and debug it

+3 bytes thanks to @Khuldraeseth (the first answer didn't have compliant output)

\$\endgroup\$
  • 1
    \$\begingroup\$ I reached the same solution, but with i in place of u. Adhering to the draconian IO specifications, this becomes 11 bytes. \$\endgroup\$ – Khuldraeseth na'Barya Aug 6 at 14:58
  • \$\begingroup\$ Oops. I guess I didn't read the IO requirements very well. I'll update my answer. \$\endgroup\$ – recursive Aug 6 at 15:04
0
\$\begingroup\$

scala 173:

def s(n:BigInt):BigInt=if(n<=9)n else n%10+s(n/10)
def d(n:BigInt):Int=if(n<10)0 else 1+d(s(n))
Iterator.continually(readInt).takeWhile(_>0).foreach(i=>println(i+" "+d(i)))
\$\endgroup\$
0
\$\begingroup\$

Perl 5, 65 bytes

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

Try it online!

\$\endgroup\$
0
\$\begingroup\$

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.

\$\endgroup\$
0
\$\begingroup\$

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)))
\$\endgroup\$
0
\$\begingroup\$

Tcl, 95 bytes

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

Try it online!

\$\endgroup\$
  • 3
    \$\begingroup\$ Because the next newest answer is a full 6 years old, which i think is before TIO existed \$\endgroup\$ – fəˈnɛtɪk Apr 15 '18 at 0:35
0
\$\begingroup\$

Japt, 28 bytes

Ë+S+(@D=X©A<D©ì x ªD 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     ªD         // 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!

\$\endgroup\$
0
\$\begingroup\$

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.)
\$\endgroup\$
0
\$\begingroup\$

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.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.