Home
4
Clojure

Perfect Numbers in Clojure: Complete Solution & Deep Dive Guide

shape, arrow

The Complete Guide to Perfect Numbers in Clojure: From Ancient Math to Functional Code

Discover how to classify numbers as perfect, abundant, or deficient using the elegant, functional power of Clojure. This guide breaks down the ancient mathematical theory of aliquot sums and translates it into clean, idiomatic Clojure code, moving from core concepts to a complete, runnable solution.

Have you ever looked at the number 6 and noticed something special? Its divisors (excluding itself) are 1, 2, and 3. And if you add them up, 1 + 2 + 3, you get 6. This perfect balance has fascinated mathematicians for over two millennia, since the time of Greek scholars like Nicomachus. This property isn't just a mathematical curiosity; it's a perfect problem to explore the elegance and power of functional programming in Clojure.

You might be wrestling with how to translate mathematical rules into effective code, especially in a functional paradigm that avoids traditional loops and mutable state. This article is your solution. We will bridge the gap between ancient number theory and modern software development, guiding you step-by-step to build a robust Clojure program that can classify any positive integer, all while mastering key functional concepts.

What Are Perfect, Abundant, and Deficient Numbers?

Before we can write a single line of Clojure, we must first understand the foundational mathematics laid out by Nicomachus around 100 CE. The entire classification system hinges on a concept called the Aliquot Sum.

The Aliquot Sum: A Number's True Essence

The Aliquot Sum of a positive integer n is the sum of all its positive divisors, excluding n itself. These divisors are also known as its "proper divisors".

Let's take the number 12 as an example:

  • The divisors of 12 are: 1, 2, 3, 4, 6, and 12.
  • The proper divisors of 12 (excluding 12) are: 1, 2, 3, 4, and 6.
  • The Aliquot Sum of 12 is: 1 + 2 + 3 + 4 + 6 = 16.

This sum is the key. By comparing the Aliquot Sum to the original number, we can place it into one of three distinct categories.

The Three Classifications

Based on the relationship between a number (n) and its Aliquot Sum (sum), we have the following classifications:

Classification Rule Example
Perfect sum == n For n = 6, the divisors are 1, 2, 3. The sum is 1 + 2 + 3 = 6. It's a perfect match.
Abundant sum > n For n = 12, the divisors are 1, 2, 3, 4, 6. The sum is 1 + 2 + 3 + 4 + 6 = 16. The sum is greater than the number.
Deficient sum < n For n = 8, the divisors are 1, 2, 4. The sum is 1 + 2 + 4 = 7. The sum is less than the number.

Every positive integer falls into exactly one of these categories. This clear, rule-based system is an ideal candidate for implementation in a logical and expressive language like Clojure.

Why Use Clojure for This Mathematical Problem?

We could solve this problem in any language, but Clojure offers a particularly elegant and insightful path. Its functional nature encourages us to think about the problem as a series of data transformations rather than a sequence of steps to be executed. This aligns perfectly with the mathematical logic.

Here's why Clojure shines:

  • Immutability by Default: Numbers, collections, and all data structures in Clojure are immutable. This eliminates a whole class of bugs related to state mutation. We don't need to worry about accidentally changing a variable's value; instead, we create new values through transformation.
  • Functional Composition: The problem can be broken down into small, pure functions: one to find divisors, one to sum them, and one to classify. Clojure makes it trivial to chain these functions together, creating a clear and readable pipeline of operations.
  • Expressive Core Library: Clojure provides powerful functions like filter, map, reduce, and range that are perfectly suited for this task. We can express complex logic concisely without resorting to manual loops.
  • The REPL (Read-Eval-Print Loop): Clojure's interactive development environment allows us to build and test each function piece by piece. We can instantly verify that our `factors-of` function works before moving on to the `aliquot-sum`, making for a rapid and confident development cycle.

In an imperative language, you might write a `for` loop, initialize a `sum` variable to 0, and then add to it inside the loop. In Clojure, we think differently: "Give me the range of potential divisors, filter them to get the actual divisors, and then reduce that collection to a single sum." This declarative style is often closer to the mathematical definition itself.

How to Implement the Solution in Clojure

Let's build our solution from the ground up, following a logical progression from finding divisors to the final classification. We will break the problem down into small, manageable, and testable functions.

Step 1: Finding All Divisors of a Number

The first and most crucial step is to write a function that takes a number n and returns a sequence of all its positive divisors. A common and efficient algorithm is to check for divisibility only up to the square root of n.

If a number i divides n, then n / i is also a divisor. By iterating up to sqrt(n), we can find pairs of divisors at once. For example, when finding divisors of 36, when we find that 3 is a divisor, we automatically know that 36 / 3 = 12 is also a divisor.

Here is the logic flow for finding factors:

    ● Start with number `n`
    │
    ▼
  ┌────────────────────────┐
  │ Generate numbers from 1│
  │ to sqrt(n)             │
  └──────────┬─────────────┘
             │
             ▼
  ┌────────────────────────┐
  │ Filter for numbers `i` │
  │ where `(mod n i)` is 0 │
  └──────────┬─────────────┘
             │
             ▼
  ┌────────────────────────┐
  │ For each `i`, create a │
  │ pair: `[i, n/i]`       │
  └──────────┬─────────────┘
             │
             ▼
  ┌────────────────────────┐
  │ Flatten pairs into a   │
  │ single list of factors │
  └──────────┬─────────────┘
             │
             ▼
    ● End with unique factors

Now, let's translate this logic into idiomatic Clojure code.


(ns perfect-numbers)

(defn- factors-of
  "Calculates all unique positive factors of a given number n.
  It efficiently finds factor pairs by iterating up to the square root of n."
  [n]
  ;; Ensure we handle non-positive numbers gracefully by returning an empty set.
  (if (pos? n)
    ;; `->>` is the thread-last macro. It passes the result of each form
    ;; as the last argument to the next form.
    (->> (range 1 (inc (Math/sqrt n))) ; 1. Generate numbers from 1 to sqrt(n)
         (filter #(zero? (mod n %)))   ; 2. Keep only the numbers that divide n
         (mapcat #(vector % (/ n %)))  ; 3. For each factor i, create a pair [i, n/i]
         (into #{}))                   ; 4. Collect into a set to get unique factors
    #{}))

Code Breakdown:

  • (if (pos? n) ... #{}): We first check if the number is positive. Our classification only applies to positive integers. If not, we return an empty set.
  • (range 1 (inc (Math/sqrt n))): This generates a lazy sequence of integers starting from 1 up to (and including) the integer part of the square root of n. For n=36, this would be `(1 2 3 4 5 6)`.
  • (filter #(zero? (mod n %))): We filter this sequence, keeping only the numbers that are actual divisors. The #(...) is a shorthand for an anonymous function. (mod n %) calculates the remainder, and zero? checks if it's 0. For n=36, this results in `(1 2 3 4 6)`.
  • (mapcat #(vector % (/ n %))): This is the clever part. mapcat is a combination of `map` and `concat`. For each divisor i we found, we create a vector containing the pair `[i, n/i]`. For n=36 and input `(1 2 3 4 6)`, this produces `([1 36] [2 18] [3 12] [4 9] [6 6])`. `mapcat` then flattens this into a single sequence: `(1 36 2 18 3 12 4 9 6 6)`.
  • (into #{}): Finally, we pour the elements of the sequence into a set (#{}). A set automatically handles duplicates, so the repeated `6` is stored only once. This gives us the final collection of unique factors.

Step 2: Calculating the Aliquot Sum

With a reliable way to get all factors, calculating the Aliquot Sum is straightforward. We need to sum all the factors and then subtract the number itself.


(defn- aliquot-sum
  "Calculates the aliquot sum of n, which is the sum of its proper divisors."
  [n]
  ;; Proper divisors are all divisors except the number itself.
  ;; We can calculate this by summing all factors and subtracting n.
  (- (reduce + (factors-of n)) n))

Code Breakdown:

  • (factors-of n): We call our previously defined function to get a set of all divisors, e.g., for n=12, this returns #{1 2 3 4 6 12}.
  • (reduce + ...): reduce is a powerful function that "reduces" a collection to a single value. Here, it applies the addition function + across all elements. (reduce + #{1 2 3 4 6 12}) results in 28.
  • (- ... n): We then subtract the original number n from the total sum of factors to get the Aliquot Sum. For n=12, this is 28 - 12 = 16.

Step 3: Classifying the Number

Now we have all the components. The final step is to compare the Aliquot Sum with the original number and return the correct classification as a Clojure keyword (e.g., :perfect). The cond macro is the perfect tool for this series of comparisons.

Here is the classification logic flow:

    ● Start with number `n`
    │
    ▼
  ┌──────────────────┐
  │ Calculate        │
  │ aliquot-sum(n)   │
  └────────┬─────────┘
           │
           ▼
    ◆ aliquot-sum > n?
   ╱         ╲
  Yes         No
  │           │
  ▼           ▼
:abundant   ◆ aliquot-sum < n?
           ╱         ╲
          Yes         No
          │           │
          ▼           ▼
      :deficient    :perfect
          │           │
          └─────┬─────┘
                ▼
           ● End with classification

And here is the final function in Clojure:


(defn classify
  "Classifies a positive integer as :perfect, :abundant, or :deficient."
  [n]
  ;; Pre-condition check: The classification is only defined for positive integers.
  (if (not (pos? n))
    (throw (IllegalArgumentException. "Classification is only possible for positive integers."))
    ;; `cond` evaluates test-expression pairs. It executes the expression
    ;; corresponding to the first true test.
    (let [s (aliquot-sum n)]
      (cond
        (> s n) :abundant
        (< s n) :deficient
        :else   :perfect))))

Code Breakdown:

  • (if (not (pos? n)) ...): This is a pre-condition check, also known as a guard clause. According to the mathematical definition, this classification scheme is for positive integers. We throw an IllegalArgumentException for invalid input, which is good practice for robust functions.
  • (let [s (aliquot-sum n)] ...): We use a let binding to calculate the aliquot sum just once and assign it to the local symbol s. This is efficient and makes the following code cleaner.
  • (cond ...): The cond macro checks each condition in order.
    • (> s n) :abundant: If the sum s is greater than n, the expression evaluates to the keyword :abundant and cond stops.
    • (< s n) :deficient: If the first test was false, it checks if s is less than n, returning :deficient if true.
    • :else :perfect: The :else keyword acts as a catch-all that is always true. If neither of the previous conditions was met, the only possibility left is that s equals n, so we return :perfect.

The Complete Code File

Here is the complete code, assembled in a single file named perfect_numbers.clj within the src/ directory of a standard Clojure project.


(ns perfect-numbers
  "This module, part of the kodikra.com exclusive curriculum, provides functions
  to classify positive integers based on Nicomachus' number theory."
  (:gen-class))

(defn- factors-of
  "Calculates all unique positive factors of a given number n.
  It efficiently finds factor pairs by iterating up to the square root of n."
  [n]
  (if (pos? n)
    (->> (range 1 (inc (Math/sqrt n)))
         (filter #(zero? (mod n %)))
         (mapcat #(vector % (/ n %)))
         (into #{}))
    #{}))

(defn- aliquot-sum
  "Calculates the aliquot sum of n, which is the sum of its proper divisors."
  [n]
  (- (reduce + (factors-of n)) n))

(defn classify
  "Classifies a positive integer as :perfect, :abundant, or :deficient.
  Throws an IllegalArgumentException if the input is not a positive integer."
  [n]
  (if (not (pos? n))
    (throw (IllegalArgumentException. "Classification is only possible for positive integers."))
    (let [s (aliquot-sum n)]
      (cond
        (> s n) :abundant
        (< s n) :deficient
        :else   :perfect))))

;; Example usage function to run from the command line
(defn -main
  [& args]
  (println "Demonstrating number classification from the kodikra learning path:")
  (println "Classification for 6:" (classify 6))
  (println "Classification for 28:" (classify 28))
  (println "Classification for 12:" (classify 12))
  (println "Classification for 8:" (classify 8))
  (try
    (println "Classification for 0:" (classify 0))
    (catch IllegalArgumentException e
      (println "Caught expected error for 0:" (.getMessage e)))))

Where to Run and Test the Code?

The best way to interact with Clojure code is through its REPL. We'll use Leiningen, a popular Clojure project automation tool, to set up a project and run our code.

Project Setup with Leiningen

If you don't have Leiningen installed, follow the instructions on its official website. Once installed, create a new project:


# Create a new Clojure application project
lein new app clojure-perfect-numbers

# Navigate into the project directory
cd clojure-perfect-numbers

Now, replace the contents of src/clojure_perfect_numbers/core.clj with the complete code we wrote above. Make sure to adjust the namespace at the top to match the file structure, e.g., (ns clojure-perfect-numbers.core ...).

Running from the REPL

Start the REPL from your terminal within the project directory:


lein repl

You'll be greeted with a prompt like clojure-perfect-numbers.core=>. Now you can interact with your classify function directly:


;; Test a perfect number
clojure-perfect-numbers.core=> (classify 6)
:perfect

;; Test another perfect number
clojure-perfect-numbers.core=> (classify 28)
:perfect

;; Test an abundant number
clojure-perfect-numbers.core=> (classify 12)
:abundant

;; Test a deficient number
clojure-perfect-numbers.core=> (classify 7)
:deficient

;; Test the error handling for a non-positive number
clojure-perfect-numbers.core=> (classify -1)
;; => java.lang.IllegalArgumentException: Classification is only possible for positive integers.

This interactive testing loop is a cornerstone of Clojure development and allows for rapid validation of your logic.

When to Consider Alternative Approaches?

The solution we built is clear, idiomatic, and efficient enough for a wide range of inputs. However, for extremely large numbers (think numbers with dozens of digits), the performance of our factors-of function could become a bottleneck. It's always valuable to consider the trade-offs of different approaches.

Potential Optimizations

  1. Prime Factorization: The most computationally efficient way to find the sum of divisors involves first finding the prime factorization of a number. If a number n = p₁^a₁ * p₂^a₂ * ..., the sum of its divisors can be calculated with a specific formula. This approach is much faster for huge numbers but also significantly more complex to implement.
  2. Laziness and Transducers: For very large collections of factors, using transducers could offer better performance by avoiding the creation of intermediate collections between the filter and mapcat steps. This is a more advanced Clojure topic but powerful for high-performance data processing pipelines.

Pros and Cons of Our Current Approach

Pros Cons
Readability & Simplicity: The code directly mirrors the mathematical definition and is easy for other developers to understand. Performance on Huge Numbers: The square root iteration can be slow for numbers in the trillions or larger.
Idiomatic Clojure: It effectively uses the core library functions (->>, filter, mapcat, reduce), making it a great learning example. Memory Usage: It materializes the entire set of factors in memory, which could be an issue for numbers with an exceptionally high number of divisors.
Robustness: The use of a guard clause for invalid input makes the public API safe to use. Not Lazy: The `factors-of` function calculates all factors upfront. A lazy version could be more memory-efficient if the consumer only needed to inspect the first few factors.

For the scope of the problem as defined in the kodikra learning path, our implementation strikes the perfect balance between clarity, correctness, and reasonable performance.

Frequently Asked Questions (FAQ)

What exactly is an Aliquot Sum again?

The Aliquot Sum is the sum of the "proper divisors" of a number. Proper divisors include all positive numbers that divide a number evenly, except for the number itself. For example, for the number 10, the divisors are 1, 2, 5, and 10. The proper divisors are 1, 2, and 5. The Aliquot Sum is 1 + 2 + 5 = 8.

Why is 1 considered a deficient number?

The only positive divisor of 1 is 1 itself. To find the Aliquot Sum, we sum the proper divisors (excluding the number itself). Since there are no other divisors, the sum is 0. Because 0 is less than 1, the number 1 is classified as deficient.

Can this code handle negative numbers or zero?

No, and this is by design. The mathematical classification of perfect, abundant, and deficient is only defined for positive integers. Our classify function enforces this by throwing an IllegalArgumentException if the input is 0 or negative, preventing incorrect usage.

How does Clojure's use of a Set in `factors-of` help?

Our algorithm for finding factors generates pairs like [i, n/i]. For a perfect square like 36, the square root is 6. Our algorithm will generate the pair [6, 36/6] which is [6, 6]. When we flatten this into a sequence, we get two 6s. By collecting the results into a set ((into #{})), we leverage the set's property of only storing unique values, automatically and efficiently de-duplicating our list of factors.

Are there any odd perfect numbers?

This is one of the oldest unsolved problems in number theory! To date, no odd perfect numbers have ever been found. However, mathematicians have not yet been able to prove that one cannot exist. All known perfect numbers are even.

What's the next perfect number after 6 and 28?

The next perfect number is 496. After that, they become much rarer. The next one is 8,128, followed by 33,550,336. They are related to a special type of prime number called Mersenne primes.

Is there a way to make the `factors-of` function lazy?

Yes, but it would require a different structure. Instead of using mapcat and into, which create concrete collections, one could build a more complex function that returns a lazy sequence. This would involve manually managing the sequence generation. For this problem, where we immediately need to sum all the factors, the eager calculation is simpler and often just as fast.

Conclusion: The Elegance of Functional Mathematics

We began with a mathematical concept from ancient Greece and successfully translated it into a clean, robust, and idiomatic Clojure program. In doing so, we've seen how the principles of functional programming—immutability, function composition, and data transformation—provide a powerful and expressive toolkit for solving logic-based problems.

You have learned how to break down a problem into small, pure functions (factors-of, aliquot-sum, classify), how to use Clojure's rich core library to manipulate data sequences, and how to structure code with guards and conditional logic like cond. This approach not only yields a correct solution but also one that is a pleasure to read and maintain.

Disclaimer: The code in this article is written based on Clojure 1.11.x. While the core functions are highly stable, always consult the official documentation for the version you are using.

Ready to continue your journey? Explore our complete Clojure Learning Path to master more advanced concepts, or continue to the next module in the roadmap to tackle your next challenge.

Published by Kodikra — Your trusted Clojure learning resource.

Post a Comment