Verify Armstrong Number in Clojure

I think converting the number into string to parse it's digits and to find the number of digits helps a lot. Then you should be careful to use biginteger (that converts is to java.math.BigInteger) instead of bigint (what is clojure.lang.BigInt) as bigint does not give you enough precision with pow function with big exponents. Also, use +' instead of + to support big integers addition.

(ns armstrong-numbers)

(defn armstrong? [num]
  (let [digits (map #(Integer/parseInt (str %)) (str num))
        len (count digits)]
    (= (biginteger num)
       (apply +' (map #(.pow (biginteger %) len) digits)))))

Here is how I would code it. It takes a lot of care to properly account for BigInteger values. We will use the Google Guava BigInteger lib to augment what we get from Java:

(ns tst.demo.core
  (:use tupelo.core tupelo.test)
  (:import
    [java.math RoundingMode]
    [com.google.common.math BigIntegerMath]
    ))

(defn num-digits
  [n]
  (let [n (biginteger n)]
    (inc (BigIntegerMath/log10 n RoundingMode/DOWN))))

(dotest
  (is= 1 (num-digits 1))
  (is= 1 (num-digits 9))
  (is= 2 (num-digits 10))
  (is= 2 (num-digits 99))
  (is= 3 (num-digits 100))
  (is= 3 (num-digits 999))
  (is= 4 (num-digits 1000))
  (is= 4 (num-digits 5555)))

I like to write the tests inline at first. We need a custom remainder function since Guava doesn't have one

(defn bigint-quot-rem
  [n d]
  (let [n    (biginteger n)
        d    (biginteger d)
        quot (BigIntegerMath/divide n d RoundingMode/DOWN)
        rem  (- n (* quot d))]
    [quot rem]))

(dotest
  (is= [1 2] (bigint-quot-rem 5 3))
  (is= [2 0] (bigint-quot-rem 6 3)))

Then a function to extract the digits of the number

(defn digits
  [n]
  (assert (pos? n))
  (loop
    [accum []
     value (biginteger n)]
    (if (zero? value)
      (mapv biginteger (reverse accum))
      (let [[value-next last-digit] (bigint-quot-rem value 10)
            accum-next (append accum last-digit)]
        (recur accum-next value-next)))))

(dotest
  (is= [3 1 4] (digits 314))
  (is= [1] (digits 1))
  (is= [1 3] (digits 13)))

and finally we can test for the armstrong property

(defn armstrong?
  [n]
  (let [n          (bigint n)
        ndigits    (num-digits n)
        digits     (digits n)
        digits-exp (mapv #(.pow % ndigits)
                     digits)
        powsum     (apply + digits-exp)
        result     (= n powsum)]
    result))

(dotest

  (is= 3 (num-digits 151))
  (isnt (armstrong? 151))
  (is (armstrong? 153))
  (isnt (armstrong? 154))

  (is (armstrong? 9926315))
  (isnt (armstrong? 9926314))

  (is (armstrong? 4679307774N))
  (is (armstrong? 28116440335967N))
  (is (armstrong? 63105425988599693916N))
  (is (armstrong? 188451485447897896036875N))
  (is (armstrong? 115132219018763992565095597973971522401N))

  (is (armstrong? 21897142587612075N))
  )

with result

-----------------------------------
   Clojure 1.10.3    Java 15.0.2
-----------------------------------

Testing tst.demo.core

Ran 5 tests containing 25 assertions.
0 failures, 0 errors.

The above is using my favorite template project. Extra test values are from

https://codegolf.stackexchange.com/questions/83272/all-armstrong-numbers

Note also that, in Clojure, bigint is different than biginteger.