---

Learn Palindrome Products in Crystal from Zero to Hero

Discover how to find the largest and smallest palindrome products within a specific number range using Crystal. This guide covers the algorithm, implementation, and optimization techniques for identifying palindromic numbers and their factors, providing a complete solution from scratch for this classic programming challenge.

Ever stared at a coding problem, the logic swirling in your mind, yet feeling a disconnect when trying to translate it into elegant, efficient code? You're not alone. The challenge of finding palindrome products within a range is a perfect example—a deceptively simple concept that tests your grasp of algorithmic thinking, efficiency, and language-specific features. It's a cornerstone problem featured in many technical interviews and a highlight of the kodikra.com Crystal learning path.

This guide won't just hand you a solution. We will deconstruct the problem from the ground up. You'll learn not just how to write the code in Crystal, but why certain approaches are better than others. We'll explore the brute-force method, uncover its inefficiencies, and then build a more optimized algorithm, all while mastering key Crystal programming concepts.

---

What Exactly Are Palindrome Products?

Before diving into code, let's establish a crystal-clear understanding of the core concepts. The problem breaks down into two simple yet powerful ideas: palindromes and products.

Defining a Palindromic Number

A palindromic number is a number that reads the same forwards and backward. The symmetry is its defining characteristic. Think of words like "racecar" or "level"—a numeric palindrome follows the same principle.

• 121 is a palindrome because reversed, it's still 121.
• 9009 is a palindrome because reversed, it's still 9009.
• 112 is not a palindrome because its reverse is 211.

Single-digit numbers (0, 1, 2, ... 9) are trivially palindromic, but the more interesting cases arise with multiple digits.

Defining a Palindrome Product

A palindrome product is simply a palindromic number that is the result of multiplying two other integers, known as its factors. The challenge usually specifies a range for these factors.

For instance, let's consider the range of factors from 10 to 99. The number 9009 is a famous palindrome product because it's the result of 91 * 99. Both 91 and 99 fall within the specified range [10, 99].

The core task is to search within a given range of factors (e.g., from min_factor to max_factor), find all possible products, identify which of those products are palindromes, and then determine the smallest and largest among them, along with the factor pairs that produced them.

---

Why This Algorithm is a Crucial Skill for Developers

Solving the palindrome products problem is more than just an academic exercise; it's a practical workout for essential software development muscles. It forces you to think critically about performance, data structure design, and algorithmic trade-offs—skills that are paramount in professional software engineering.

• Algorithmic Thinking: It teaches you to break down a complex problem into smaller, manageable steps: generate pairs, calculate products, check for a property (being a palindrome), and store results. This systematic approach is the foundation of all software development.
• Performance Optimization: A naive, brute-force solution works for small ranges but quickly becomes computationally expensive as the range of factors grows. This problem is a perfect introduction to complexity analysis (e.g., O(n²)) and motivates the search for smarter, more efficient algorithms.
• Data Management: The solution isn't just one number; it's a structured result containing the palindrome and its associated factors. This requires you to design appropriate data structures—like a struct or class—to hold the value and a list of factor pairs, a common task in API design and data modeling.
• Edge Case Handling: What happens if no palindrome product exists in the range? What if the minimum factor is greater than the maximum? A robust solution must gracefully handle these scenarios, a critical skill for building reliable software.

Mastering this challenge from the exclusive kodikra.com curriculum demonstrates a solid foundation in computational logic and prepares you for the types of problems encountered in technical interviews at leading tech companies.

---

How to Find Palindrome Products: The Complete Crystal Strategy

We'll now build the solution in Crystal step-by-step. Our strategy will be to start with a clear, straightforward approach and then discuss potential optimizations. The goal is to find both the smallest and largest palindrome products in a single pass.

Step 1: The High-Level Game Plan

Our overall logic follows a clear sequence. We need to systematically check every possible product within the given factor range.

Here is a high-level flowchart of our algorithm:

    ● Start (min_factor, max_factor)
    │
    ▼
  ┌────────────────────────┐
  │ Initialize smallest/largest to nil │
  └────────────┬───────────┘
               │
               ▼
  Loop `i` from min to max
               │
               ├─ Loop `j` from `i` to max  (Optimization: avoids duplicate pairs)
               │  │
               │  ▼
               │ ┌────────────────┐
               │ │ product = i * j│
               │ └────────┬───────┘
               │          │
               │          ▼
               │   ◆ Is product a palindrome?
               │  ╱         ╲
               │ Yes         No
               │  │           │
               │  ▼           └──────────┐
               │ ┌──────────────────────┐ │
               │ │ Update smallest/largest│ │
               │ └──────────────────────┘ │
               │            │             │
               └────────────┼─────────────┘
                            │
  End Loops ────────────────┘
    │
    ▼
  ┌────────────────────────┐
  │ Return smallest/largest results │
  └────────────────────────┘
    │
    ▼
    ● End

This brute-force approach guarantees we will check every combination and find the correct answers. The key optimization shown here is starting the inner loop (`j`) from the current value of the outer loop (`i`). This prevents us from calculating both `10 * 11` and `11 * 10`, as the product is the same.

Step 2: Structuring the Result Data

The problem requires us to return not just the palindrome but also the factors that create it. A single palindrome might even have multiple pairs of factors (e.g., 121 = 11 * 11, and if we were checking a different problem, another number might be 6 * 4 and 8 * 3). A Crystal struct is perfect for this.

# Represents a palindrome product, holding its value and
# all the factor pairs that produce it within the given range.
struct Palindrome
  # The palindromic number itself.
  property value : Int64

  # An array to store one or more factor pairs.
  # A factor pair is represented as a Tuple(Int32, Int32).
  property factors : Array(Tuple(Int32, Int32))

  # Constructor to initialize a new Palindrome with its value.
  # The factors list starts empty.
  def initialize(@value)
    @factors = [] of Tuple(Int32, Int32)
  end
end

Using a struct is efficient here. Since they are value types and allocated on the stack, they are faster for small, immutable-like data containers compared to classes.

Step 3: The Full Crystal Implementation

Now, let's assemble the complete solution into a class. This encapsulates the logic cleanly and allows for easy instantiation with different factor ranges.

# A class to find the smallest and largest palindrome products
# within a given range of factors.
class PalindromeProducts
  # Represents a palindrome product, holding its value and factor pairs.
  struct Palindrome
    property value : Int64
    property factors : Array(Tuple(Int32, Int32))

    def initialize(@value)
      @factors = [] of Tuple(Int32, Int32)
    end
  end

  @min_factor : Int32
  @max_factor : Int32

  # The constructor takes the minimum and maximum factors for the range.
  # It raises an error if the min_factor is greater than the max_factor.
  def initialize(@min_factor, @max_factor)
    if @min_factor > @max_factor
      raise ArgumentError.new("min_factor cannot be greater than max_factor")
    end
  end

  # Generates and returns the smallest and largest palindrome products.
  # The return type is a NamedTuple containing the optional Palindrome structs.
  def generate : {smallest: Palindrome?, largest: Palindrome?}
    smallest = nil
    largest = nil

    # Iterate through all possible pairs of factors in the range.
    # The inner loop starts from 'i' to avoid duplicate pairs (e.g., a*b and b*a).
    (@min_factor..@max_factor).each do |i|
      (i..@max_factor).each do |j|
        # Use Int64 for the product to prevent overflow with large factors.
        product = i.to_i64 * j.to_i64

        if is_palindrome?(product)
          # Logic to update the smallest palindrome found so far.
          if smallest.nil? || product < smallest.not_nil!.value
            smallest = Palindrome.new(product)
            smallest.not_nil!.factors << {i, j}
          elsif product == smallest.not_nil!.value
            smallest.not_nil!.factors << {i, j}
          end

          # Logic to update the largest palindrome found so far.
          if largest.nil? || product > largest.not_nil!.value
            largest = Palindrome.new(product)
            largest.not_nil!.factors << {i, j}
          elsif product == largest.not_nil!.value
            largest.not_nil!.factors << {i, j}
          end
        end
      end
    end

    {smallest: smallest, largest: largest}
  end

  private

  # Helper method to check if a number is a palindrome.
  # It converts the number to a string and compares it with its reverse.
  def is_palindrome?(number : Int64) : Bool
    s = number.to_s
    s == s.reverse
  end
end

Step 4: Detailed Code Walkthrough

Let's dissect the code to understand every component.

1. The Palindrome Struct:
   • property value : Int64: We use Int64 to ensure the product of two Int32 factors doesn't overflow. For example, 9999 * 9999 is nearly 100 million, well within Int32, but for larger potential ranges, Int64 is safer.
   • property factors : Array(Tuple(Int32, Int32)): This holds the pairs of factors. A Tuple is a fixed-size, immutable collection, perfect for representing a pair like {91, 99}.
2. The PalindromeProducts Class:
   • initialize(@min_factor, @max_factor): The constructor sets up the range. It includes a crucial guard clause: if @min_factor > @max_factor, which raises an ArgumentError. This prevents logical errors and makes the class more robust.
   • generate Method: This is the heart of the class. It orchestrates the entire search.
3. Inside the generate Method:
   • smallest = nil and largest = nil: We initialize our result variables as nil. They will hold Palindrome structs once we find our first match. Their type is inferred by Crystal as Palindrome?, meaning "either a Palindrome or nil".
   • (@min_factor..@max_factor).each do |i|: The outer loop iterates through the first factor.
   • (i..@max_factor).each do |j|: The inner loop iterates through the second factor, starting from i. This is a key optimization.
   • if is_palindrome?(product): We call our private helper method to check the property.
4. The Update Logic: This is the most complex part of the loop. Let's visualize the decision-making process for updating the `smallest` and `largest` values.

    ● New Palindrome Found (`product`)
    │
    ├─ Check against `smallest` ────────────────
    │  │
    │  ▼
    │ ◆ Is `smallest` nil OR `product` < `smallest.value`?
    │ ╱                       ╲
    │Yes (New smallest)         No
    │ │                         │
    │ ▼                         ▼
    │┌───────────────────┐     ◆ Is `product` == `smallest.value`?
    ││ smallest = new Palindrome │╱               ╲
    ││ Add factors {i,j}         │Yes (Another factor pair) No (Ignore)
    │└───────────────────┘     │                 │
    │                           ▼                 │
    │                         ┌─────────────────┐ │
    │                         │ Add factors {i,j} │ │
    │                         └─────────────────┘ │
    │                           └─────────────────┴─
    │
    ├─ Check against `largest` ─────────────────
    │  │
    │  ▼
    │ ◆ Is `largest` nil OR `product` > `largest.value`?
    │ ╱                      ╲
    │Yes (New largest)         No
    │ │                        │
    │ ▼                        ▼
    │┌──────────────────┐     ◆ Is `product` == `largest.value`?
    ││ largest = new Palindrome │╱              ╲
    ││ Add factors {i,j}        │Yes (Another factor pair) No (Ignore)
    │└──────────────────┘      │                │
    │                          ▼                │
    │                        ┌────────────────┐ │
    │                        │ Add factors {i,j}│ │
    │                        └────────────────┘ │
    │                          └────────────────┴─
    │
    ▼
    ● Continue to next product

The use of .not_nil! is a way to tell the Crystal compiler, "I am certain that this variable is not nil at this point." We can use it safely here because the checks `smallest.nil?` and `largest.nil?` happen right before, guaranteeing the variable is populated if that branch is skipped.

Step 5: How to Run the Code

To use this class, you would create a file, for example main.cr, and instantiate it.

# main.cr

# Require the file containing the PalindromeProducts class
require "./palindrome_products.cr"

# --- Example 1: Range 1 to 9 ---
puts "Checking range 1 to 9..."
calculator1 = PalindromeProducts.new(min_factor: 1, max_factor: 9)
results1 = calculator1.generate

smallest1 = results1[:smallest]
if smallest1
  puts "Smallest: #{smallest1.value} (Factors: #{smallest1.factors})"
else
  puts "No smallest palindrome found."
end

largest1 = results1[:largest]
if largest1
  puts "Largest:  #{largest1.value} (Factors: #{largest1.factors})"
else
  puts "No largest palindrome found."
end

puts "\n" + "-"*20 + "\n"

# --- Example 2: Range 10 to 99 ---
puts "Checking range 10 to 99..."
calculator2 = PalindromeProducts.new(min_factor: 10, max_factor: 99)
results2 = calculator2.generate

smallest2 = results2[:smallest]
if smallest2
  puts "Smallest: #{smallest2.value} (Factors: #{smallest2.factors})"
else
  puts "No smallest palindrome found."
end

largest2 = results2[:largest]
if largest2
  puts "Largest:  #{largest2.value} (Factors: #{largest2.factors})"
else
  puts "No largest palindrome found."
end

Assuming you have your class in palindrome_products.cr and the runner script in main.cr, you would execute it from your terminal like this:

# Compile and run the Crystal program
crystal run main.cr

The expected output would be:

Checking range 1 to 9...
Smallest: 1 (Factors: [{1, 1}])
Largest:  9 (Factors: [{1, 9}, {3, 3}])
--------------------

Checking range 10 to 99...
Smallest: 121 (Factors: [{11, 11}])
Largest:  9009 (Factors: [{91, 99}])

---

Alternative Approaches and Performance Considerations

The brute-force solution is correct and easy to understand, but it's not the most performant, especially for very large ranges. Its time complexity is roughly O(N²), where N is the size of the factor range (max_factor - min_factor).

Optimized Search: Searching from the Edges

A more clever approach is to change the direction of your search.

• To find the largest palindrome: Start your loops from the outside in. That is, iterate from max_factor down to min_factor. The very first palindrome you find is guaranteed to be the largest (or at least a candidate for the largest, as smaller factors could produce a larger product, but it's a much better starting point). This dramatically reduces the search space for the largest value.
• To find the smallest palindrome: The current approach of iterating from min_factor upwards is already optimal.

This suggests that two separate, targeted searches could be faster than one combined search, though it might make the code slightly more complex.

Pros and Cons of Different Approaches

Let's compare the simple brute-force method with a more optimized, edge-searching approach.

Attribute	Simple Brute-Force (Our Solution)	Optimized Edge-Search
Implementation Complexity	Low. A single, unified search loop.	Medium. Requires separate logic or two passes to find min and max efficiently.
Readability	High. The logic is straightforward and follows a simple path.	Moderate. The intent might be less obvious without comments explaining the optimization.
Performance (Small Range)	Excellent. The overhead of a more complex algorithm is not worth it.	Good. Slightly more complex setup might be marginally slower.
Performance (Large Range)	Poor. Must iterate through the entire search space.	Excellent. Can find the largest palindrome much faster by starting from the top.

For most learning purposes and typical interview scenarios, the simple, well-explained brute-force solution is perfectly acceptable and often preferred for its clarity.

---

Frequently Asked Questions (FAQ)

1. What is the time complexity of the provided solution?

The time complexity is approximately O(N²), where N is the number of elements in the range (max_factor - min_factor + 1). This is because of the nested loops, each iterating through the range of factors. While we optimize by starting the inner loop at i, which halves the number of product calculations, in Big O notation, this constant factor is dropped, and it remains a quadratic time complexity.

2. Why convert the number to a string to check for a palindrome?

Converting the number to a string is the most idiomatic and readable way to check for a palindrome in many high-level languages, including Crystal. The language provides built-in, highly optimized methods for string reversal. The alternative is a mathematical approach, which involves repeatedly using the modulo (%) and division (/) operators to reverse the number arithmetically. While possible, this is often more complex to implement and more prone to errors (like integer overflow) without offering a significant performance benefit for typical number sizes.

3. How would this algorithm handle very large number ranges?

For extremely large ranges, the O(N²) complexity would make this solution too slow. The memory usage is low, but the CPU time would be prohibitive. In such cases, you would need to move beyond brute-force and explore advanced mathematical properties of palindromes or use parallel processing to divide the search space across multiple CPU cores.

4. How does Crystal's static typing help in this problem?

Crystal's static type system with type inference provides safety and clarity. By defining product as Int64, we prevent potential integer overflows at compile time. The return type annotation {smallest: Palindrome?, largest: Palindrome?} clearly documents the method's contract, ensuring that anyone using the generate method knows to handle `nil` cases. This eliminates a whole class of runtime errors common in dynamically typed languages.

5. What happens if no palindrome product exists in the given range?

Our solution handles this gracefully. The smallest and largest variables are initialized to nil. If the loops complete without finding any palindromic products, these variables remain nil. The method then returns {smallest: nil, largest: nil}, correctly indicating that no palindromes were found. The calling code can then check for `nil` to handle this outcome.

6. Is there a way to generate palindromes directly instead of searching for them?

Yes, this is an advanced optimization strategy. You could write a function that generates palindromes (e.g., take a number `123`, create the palindrome `123321` or `12321`). Then, for each generated palindrome, you would need to check if it has two factors that fall within your required range. This can be more efficient as it avoids calculating millions of non-palindromic products, but the logic for factoring numbers and checking against the range is significantly more complex.

---

Conclusion: From Theory to Mastery

You have successfully journeyed from the basic definition of a palindrome product to implementing a complete, robust, and well-structured solution in Crystal. We've not only built the code but also analyzed its performance, explored optimizations, and understood the design choices behind its structure. This problem is a testament to the idea that even simple concepts can lead to deep insights into software engineering principles.

The skills you've honed here—algorithmic decomposition, data structuring with `structs`, handling `nil` values, and writing clean, maintainable code—are universally applicable. They are the building blocks you will use to tackle far more complex challenges in your career.

To continue building your expertise, we encourage you to explore the complete kodikra guide to the Crystal language and tackle more problems in our exclusive learning curriculum. Each challenge is an opportunity to refine your problem-solving abilities and deepen your understanding of modern programming.

Disclaimer: All code in this article is written for Crystal 1.12+ and is designed to be compatible with future stable releases. Syntax and standard library features may evolve in subsequent versions.

---

Published by Kodikra — Your trusted Crystal learning resource.