Diamond in Common-lisp: Complete Solution & Deep Dive Guide

a close up of a computer screen with code on it

From 'A' to 'Z': Crafting the Perfect Diamond Pattern in Common Lisp

Learn to solve the Diamond Kata in Common Lisp by generating a symmetrical letter pattern. This guide covers the core logic of calculating spaces, placing characters, and constructing the full diamond shape from 'A' to a specified letter, using powerful and idiomatic functional programming principles.

Algorithmic puzzles often present a deceptive simplicity. You read the problem, visualize the output, and think, "This should be straightforward." Then, you dive into the code and quickly find yourself tangled in a web of off-by-one errors, spacing miscalculations, and frustratingly asymmetric results. The Diamond Kata is a classic example of this, a challenge that tests not just your coding ability but your capacity to think structurally.

Many developers, especially those new to a language like Common Lisp, struggle to translate the geometric pattern into functional code. The pain of managing indices, calculating both inner and outer padding, and ensuring perfect symmetry can feel overwhelming. This guide promises to change that. We will dissect the Diamond problem piece by piece, transforming it from an intimidating puzzle into a series of simple, logical steps, all while showcasing the elegance and power of Common Lisp.

What is the Diamond Kata? A Deep Dive into the Problem

The Diamond Kata, a popular coding challenge found in the exclusive kodikra.com curriculum, asks you to write a program that takes a single uppercase letter as input and generates a diamond shape made of letters. The diamond starts with 'A' at the top and bottom points and expands to its widest point using the input letter.

To truly understand the task, we must break down its explicit requirements:

Starting and Ending Point: The very first and very last rows of the output must contain a single 'A'.
Symmetry is Key: The entire diamond must be both horizontally and vertically symmetrical. The pattern of letters ascending to the input letter is perfectly mirrored in the descending half.
Letter Placement: Every row, with the exception of the 'A' rows at the top and bottom, must contain exactly two identical letters.
Precise Spacing: The diamond is centered within a square grid. This means all rows must have the same total width, achieved by adding leading (and trailing) spaces. The number of leading spaces must equal the number of trailing spaces.
Character Progression: The letters in the diamond follow the alphabet. Starting from 'A', each subsequent row in the top half uses the next letter in the alphabet until the input letter is reached at the widest point.

For example, if the input is the letter 'C', the expected output is a string or a list of strings representing this structure:


  A
 B B
C   C
 B B
  A

This seemingly simple output hides a precise mathematical relationship between the current letter, the outer padding, and the inner spacing between the letters.

Why This Challenge is a Perfect Fit for Common Lisp

While the Diamond Kata can be solved in any language, it serves as a particularly insightful exercise in Common Lisp. The problem's nature plays directly to the strengths of the Lisp family of languages, encouraging a style of problem-solving that is both powerful and elegant.

First, Common Lisp excels at list manipulation. A natural way to represent the diamond is as a list of strings, where each string is a row. Lisp's rich library of functions for building, transforming, and combining lists (like mapcar, cons, append, reverse) makes constructing the final output intuitive.

Second, the problem encourages declarative and functional thinking. Instead of managing complex loops with multiple state variables (e.g., `i`, `j`, `k` counters), you can define functions that describe *what* a row is based on its character. This leads to cleaner, more readable, and less error-prone code. We can define a function `make-row(char)` that handles all the logic for a single line, and then simply apply it to a sequence of characters.

Finally, Common Lisp's powerful LOOP macro and FORMAT function are perfectly suited for this task. The LOOP macro provides a highly readable, English-like syntax for iteration and collection, while the FORMAT function offers sophisticated control over string construction, making the task of adding precise padding and characters remarkably concise.

By tackling this problem, you're not just learning to print a pattern; you're learning to think in Lisp. You can find more challenges like this in our complete Common Lisp guide.

How to Deconstruct the Diamond's Logic: A Step-by-Step Strategy

The key to solving the Diamond Kata is to stop seeing it as a single, complex shape and start seeing it as a collection of simple, predictable rows. We can derive the entire structure from a few core calculations based on the input letter.

Step 1: Understand the Geometry and Dimensions

The diamond fits into a square grid. The width (and height) of this grid is determined by the input letter. Let's assign a numerical index to each letter, starting with A=0, B=1, C=2, and so on. This index is easily calculated: index = character_code(current_letter) - character_code('A').

The widest part of the diamond occurs at the input letter. For an input 'C' (index 2), the structure is:

Row A (index 0): `_ _ A _ _`
Row B (index 1): `_ B _ B _`
Row C (index 2): `C _ _ _ C`

The total width is 5 characters. Notice a pattern? The width is always `2 * index_of_widest_letter + 1`. For 'C' (index 2), the width is `2 * 2 + 1 = 5`. For 'E' (index 4), the width would be `2 * 4 + 1 = 9`.

Step 2: The Power of Symmetry

The diamond is vertically symmetrical. This is a huge advantage. We don't need to write logic for both the top and bottom halves. We can focus entirely on generating the top half, from 'A' to the input letter. Once we have that, the bottom half is simply the reverse of the top half (excluding the middle, widest row, which shouldn't be duplicated).

    ● Input Letter (e.g., 'C')
    │
    ▼
  ┌─────────────────────────┐
  │ Generate Top Half Rows  │
  │ ('A', 'B', 'C')         │
  └───────────┬─────────────┘
              │
              ▼
  ┌─────────────────────────┐
  │ Generate Bottom Half    │
  │ (Reverse of top, no 'C')│
  └───────────┬─────────────┘
              │
              ▼
  ┌─────────────────────────┐
  │    Combine Both Halves  │
  └───────────┬─────────────┘
              │
              ▼
    ● Final Diamond String

Step 3: Calculating Spaces for Any Row

For any given row, we need to calculate two types of spacing:

Outer Spaces: The spaces on the left (and right) that center the letters.
Inner Spaces: The spaces between the two letters in a row (this is zero for the 'A' row).

Let's use `max_index` for the index of the input letter and `current_index` for the index of the letter in the current row.

Outer Spaces: The number of outer spaces on one side is simply `max_index - current_index`.
- For row 'A' (index 0) with input 'C' (max_index 2): `2 - 0 = 2` spaces (` A`).
- For row 'B' (index 1): `2 - 1 = 1` space (` B B`).
- For row 'C' (index 2): `2 - 2 = 0` spaces (`C C`).
Inner Spaces: This also follows a pattern.
- For row 'A' (index 0): 0 inner spaces.
- For row 'B' (index 1): 1 inner space.
- For row 'C' (index 2): 3 inner spaces.
The formula is `2 * current_index - 1` for `current_index > 0`. A simpler way is to calculate it based on the total width. Total Width = `2 * outer_spaces + 2 (for letters) + inner_spaces`. We already know the total width and outer spaces, so the inner space can be derived.

With these formulas, we can now construct any row programmatically.

Where the Code Comes Together: The Common Lisp Implementation

Now, let's translate our strategy into idiomatic Common Lisp code. We'll create a main function, rows, which takes the target character and returns a list of strings representing the diamond.

We will leverage the powerful LOOP macro for its clarity in expressing iteration and collection. This approach is highly efficient and very common in modern Lisp programming.

The Complete Solution


(defun make-row (current-char max-char)
  "Generates a single string row for the diamond.
   Calculates outer and inner spacing based on the current and max characters."
  (let* ((max-index (- (char-code max-char) (char-code #\A)))
         (current-index (- (char-code current-char) (char-code #\A)))
         (outer-spaces (- max-index current-index)))
    (cond
      ;; Handle the 'A' case specifically (top and bottom)
      ((char= current-char #\A)
       (format nil "~v@{~A~:*~}A" outer-spaces " "))
      ;; Handle all other letters
      (t
       (let ((inner-spaces (1- (* 2 current-index))))
         (format nil "~v@{~A~:*~}~c~v@{~A~:*~}~c"
                 outer-spaces " "
                 current-char
                 inner-spaces " "
                 current-char))))))

(defun rows (limit-char)
  "Generates the full diamond pattern up to the given limit-char.
   Returns a list of strings, with each string representing a row."
  (let* ((start-char #\A)
         (start-code (char-code start-char))
         (limit-code (char-code limit-char)))
    ;; Generate the top half of the diamond, including the middle row
    (let ((top-half
            (loop for code from start-code to limit-code
                  collect (make-row (code-char code) limit-char))))
      ;; Combine the top half with its reverse (excluding the duplicated middle row)
      (append top-half (rest (reverse top-half))))))

Detailed Code Walkthrough

Let's break down how this solution works, function by function.

The `make-row` Helper Function

This function is the heart of our logic. Its sole responsibility is to create one correct row of the diamond.

    ● Input: current-char, max-char
    │
    ▼
  ┌─────────────────────────┐
  │ Calculate Indices       │
  │ (from char codes)       │
  └───────────┬─────────────┘
              │
              ▼
  ┌─────────────────────────┐
  │ Calculate Outer Spaces  │
  │ (max_idx - current_idx) │
  └───────────┬─────────────┘
              │
              ▼
    ◆ Is current-char 'A'?
   ╱                       ╲
  Yes (Top/Bottom)          No (Middle Rows)
  │                         │
  ▼                         ▼
┌──────────────────┐      ┌─────────────────────────┐
│ Format with only │      │ Calculate Inner Spaces  │
│ outer spaces     │      │ (2 * current_idx - 1)   │
└──────────────────┘      └───────────┬─────────────┘
  │                                   │
  │                                   ▼
  │                                 ┌────────────────────────┐
  │                                 │ Format with outer,     │
  │                                 │ inner, and two chars   │
  │                                 └────────────────────────┘
  └─────────────────┬─────────────────┘
                    │
                    ▼
      ● Return Formatted String Row

`let*` Binding: We use let* to define our local variables. max-index and current-index are calculated by subtracting the character code of 'A' from the respective input character codes. This converts 'A' -> 0, 'B' -> 1, etc. outer-spaces is then calculated using the formula we derived earlier.
`cond` for Logic Branching: We use a cond statement to handle the two distinct cases for a row.
- The 'A' Case: If (char= current-char #\A) is true, we are at the tip of the diamond. This row has no inner spaces. We use format to create the string. The format directive ~v@{~A~:*~} is a powerful Lisp feature. v takes an argument (outer-spaces) for the repetition count, and @{~A~:*} tells it to print the next argument (" ") that many times. Finally, we print the 'A'.
- The General Case: For any other character, we calculate inner-spaces. The format string is more complex here: it first prints the outer spaces, then the current-char, then the inner spaces, and finally the current-char again.

The Main `rows` Function

This function orchestrates the process, calling `make-row` to build the complete diamond.

Character Codes: We get the integer character codes for 'A' and the input limit-char. This is more efficient for iteration than working with characters directly.
The `LOOP` Macro: This is where the magic happens.
- loop for code from start-code to limit-code: This sets up a loop that iterates through the character codes from 'A' up to our limit character.
- collect (make-row (code-char code) limit-char): In each iteration, we convert the numeric code back to a character using code-char. We then call our make-row helper with this character and the limit character. The collect keyword gathers the result of each call into a list.
The result, stored in top-half, is a list of strings for the top part of the diamond, e.g., `(" A " " B B " "C C")` for an input of 'C'.
Constructing the Full Diamond: We use append to join two lists. The first is our top-half. The second is (rest (reverse top-half)).
- (reverse top-half) would give `("C C" " B B " " A ")`.
- We don't want to duplicate the middle row ("C C"), so we take the rest of this reversed list, which gives `(" B B " " A ")`.
- Appending them gives us the final, perfectly symmetrical diamond.

When to Consider Alternative Approaches

The LOOP-based solution is highly idiomatic and efficient for Common Lisp. However, exploring other paradigms can deepen your understanding of the language.

A Purely Functional/Recursive Approach

One could implement this without any explicit looping, using recursion. You could define a recursive function that builds the diamond from the inside out (from the widest row) or from the outside in (from 'A').

A recursive helper function might look like `(build-half current-char limit-char)`. If `current-char` is greater than `limit-char`, it returns an empty list. Otherwise, it constructs the current row and prepends it to the result of calling itself with the next character, `(cons (make-row ...) (build-half (next-char) ...))`. While elegant, this can be less performant and risks stack overflow for very large inputs (e.g., 'Z'), although tail-call optimization can mitigate this in some Lisp implementations.

Pros and Cons of Different Methods

Approach	Pros	Cons
Iterative (`LOOP` Macro)	- Highly readable and idiomatic in Common Lisp. - Very performant and memory-efficient. - No risk of stack overflow.	- Can feel less "purely functional" to purists. - The `LOOP` macro syntax can be complex for beginners.
Recursive	- Elegant and mathematically pure representation of the logic. - Excellent for demonstrating functional programming principles.	- Can be slower due to function call overhead. - Risk of stack overflow on large inputs without tail-call optimization. - Can be harder to debug for some developers.
Mathematical (Direct Generation)	- Potentially the fastest method if implemented well. - Directly calculates each row without relying on previous rows.	- The logic can be more obscure and harder to read. - Prone to off-by-one errors in calculations.

For this particular problem from the kodikra learning path, the LOOP macro approach strikes the best balance of readability, performance, and idiomatic style.

Frequently Asked Questions (FAQ)

Why is the diamond width calculated as `2 * index + 1`?

This formula ensures the diamond has a center column. For index 0 ('A'), width is 1. For index 1 ('B'), the structure is `B_B`, which is 3 characters wide (`2*1+1`). For index 2 ('C'), it's `C___C`, which is 5 characters wide (`2*2+1`). The `+1` accounts for the single center character or the center space in rows with an even index.

How do `char-code` and `code-char` work in Common Lisp?

They are inverse functions for converting between characters and their underlying integer representations (like ASCII or Unicode). (char-code #\A) returns an integer (e.g., 65). (code-char 65) returns the character #\A. This is extremely useful for performing arithmetic on characters, like iterating through the alphabet.

Can this be solved without the `LOOP` macro?

Absolutely. You could use other iteration constructs like dotimes or dolist, or functional mapping with mapcar over a list of characters. A recursive solution, as discussed in the alternatives section, is also a very valid, albeit different, approach.

What's the best way to handle invalid input, like a lowercase letter?

Our current solution assumes valid uppercase input. For a production-ready function, you should add error handling. You could use (char-upcase input-char) to automatically handle lowercase letters. For non-alphabetic input, you could use a type check like (alpha-char-p input-char) and signal an error or return an empty list if the input is invalid.

How can I modify this code to print a hollow diamond with asterisks?

The logic remains almost identical. You would simply replace the character arguments in the format calls. Instead of passing current-char, you would pass #\*. The core calculations for outer and inner spaces do not change, making the code highly adaptable.

Is this type of problem common in technical interviews?

Yes, pattern-printing problems like the Diamond Kata are very common, especially in initial screening rounds. They test a candidate's ability to break down a problem, think algorithmically, handle edge cases (like the 'A' row), and write clean, structured code. Demonstrating a solution like this shows strong foundational skills.

Conclusion: From Pattern to Principle

Mastering the Diamond Kata in Common Lisp is more than just a graphical exercise; it's a lesson in structured thinking and leveraging the unique strengths of a language. We've seen how a seemingly complex visual pattern can be broken down into simple, repeatable mathematical rules for calculating spacing and placing characters. By separating the logic for a single row into a helper function, we created clean, modular, and reusable code.

The final solution, using the idiomatic LOOP macro and the powerful FORMAT function, demonstrates how Common Lisp can solve such problems with remarkable conciseness and clarity. You've not only solved a classic puzzle but also gained deeper insight into list manipulation, character encoding, and declarative iteration in Lisp.

Ready for your next challenge? Continue your journey by exploring the full Common Lisp Module 5 on kodikra.com, or deepen your overall language proficiency with our comprehensive Common Lisp guide.

Disclaimer: All code examples are written for a modern Common Lisp environment (e.g., SBCL 2.4+). Syntax and function availability may vary in older implementations.

Published by Kodikra — Your trusted Common-lisp learning resource.

kodikra

Search this blog