Retaining your names, I'd rewrite the functions as follows:

(defn sum-once [x]  (reduce +          (map            #(- (int %) (int \0))            (str x))))(defn sum-digits [x]  (let [y (sum-once x)]    (if (< y 10)       y      (recur y))))

The only substantive change toCasey's answer is to replace the recursive call ofsum-digits withrecur. This recognises tail recursion and implements it by agoto: faster and not subject to stack overflow.

Edit

We can probably (untested) make things faster by calculating the digit sum inline:

(defn sum-digits [x]  (let [y (loop [x (long x), ans 0]            (if (zero? x)              ans              (recur (quot x 10) (+ ans (mod x 10)))))]    (if (< y 10)       y      (recur y))))

This avoids layers of sequence functions and the boxing and unboxing that goes with calling global functions.

• There is no conversion to and from characters.
• We get the digits right to left.
• The(long x) conversion is a hint enabling the compiler to inferthat everything is along.

By the way, you can get the same result from the remainder of dividing the original number by 9, except that 0 translates to 9, unless the original number was zero:

(defn sum-digits [n]  (if (zero? n)    0    (let [r (mod n 9)]      (if (zero? r) 9 r))))

• \$\begingroup\$boxing and unboxing that goes with calling global. Could you elaborate that a bit?\$\endgroup\$

  Aseem Bansal

  – Aseem Bansal

  2015-11-14 14:22:54 +00:00

  CommentedNov 14, 2015 at 14:22
• \$\begingroup\$@AseemBansal Arguments are passed to and the result returned from Clojure functions as JavaObjects. This is evident in theinvoke methods ofclojure.core.IFn. So numbers such aslongs have to be passed asObjects such asLongs.\$\endgroup\$

  Thumbnail

  – Thumbnail

  2015-11-14 16:10:37 +00:00

  CommentedNov 14, 2015 at 16:10

I was confused by your code until reading the comments. You want to change the name ofsum-once tosum-digits ordigit-sum (pick this one!) or anything like it, since that's what it really does.

Your currentsum-digits should becomedigital-root (that'sthe term for what you're trying to achieve).

The digital root (also repeated digital sum) of a non-negative integer is the (single digit) value obtained by an iterative process of summing digits, on each iteration using the result from the previous iteration to compute a digit sum. The process continues until a single-digit number is reached.

Stylistically this is pretty good. I have two stylistic suggestions, plus a bit of code-golf:

1. Stylistically, I would prefer forsum-once to take a number and callstr there. Also, there are a few standards around "subsidiary" functions - I prefer a "-" prefix. So it would besum-digits and-sum-digits.

2. You don't need to convert a string to achar-array - it is already a sequence.

   user=> (seq "4312")(\4 \3 \1 \2)

3. This is total code-golf, but you can just subtract individual characters from the ASCII value of 0, which happens to be 48:

   (defn -sum-digits  [val]  (reduce +           (map #(- (int %) 48)                (str val))))

• \$\begingroup\$In (3), replace magic number48 with self-explanatory(int \0)?\$\endgroup\$

  Thumbnail

  – Thumbnail

  2015-11-13 14:55:49 +00:00

  CommentedNov 13, 2015 at 14:55

• beginner
• clojure