---

The Ultimate Guide to the Beer Song in Common Lisp: From Loops to Recursion

Solving the "99 Bottles of Beer" song in Common Lisp is the perfect challenge to master core language features. It goes beyond a simple loop, forcing you to handle string formatting, pluralization, and specific edge cases for 2, 1, and 0 bottles. This guide provides a complete solution, breaking down the logic from an iterative approach to an elegant recursive one, straight from the kodikra.com curriculum.

---

You’ve just started learning a new programming language. You understand variables, you’ve written a few functions, and now you encounter a seemingly trivial problem: print the lyrics to a children's song. It sounds easy, right? But as you start coding, the complexity reveals itself. You hit an off-by-one error. The grammar for "1 bottle" is different from "2 bottles". The final verse is completely unique. This small, deceptive challenge is where true learning begins.

This isn't just a random exercise; it's a rite of passage. The Beer Song problem, a staple in the kodikra.com learning path, is a masterclass in handling control flow and edge cases. In this comprehensive guide, we'll dissect this problem and craft a robust, idiomatic Common Lisp solution. You won't just get the code; you'll understand the Lisp philosophy behind it, exploring powerful tools like the loop macro, the versatile format function, and the elegance of recursion.

---

What is the Beer Song Problem?

The Beer Song problem is a classic programming exercise that requires you to generate the lyrics for the song "99 Bottles of Beer on the Wall." The song counts down from a starting number of bottles (typically 99) to 0.

While most verses follow a standard pattern, the challenge lies in correctly handling the special cases, which break the mold. Understanding these exceptions is the key to solving the problem correctly.

The Core Rules and Edge Cases

• The General Verse (99 down to 3 bottles): The pattern is straightforward. For n bottles, the verse is:
  "n bottles of beer on the wall, n bottles of beer."
  "Take one down and pass it around, n-1 bottles of beer on the wall."
• The "2 Bottles" Verse: When you have 2 bottles, the next line must be grammatically correct, referring to "1 bottle" (singular).
  "2 bottles of beer on the wall, 2 bottles of beer."
  "Take one down and pass it around, 1 bottle of beer on the wall."
• The "1 Bottle" Verse: This is another unique case. The pluralization changes, and the result is "no more bottles."
  "1 bottle of beer on the wall, 1 bottle of beer."
  "Take one down and pass it around, no more bottles of beer on the wall."
• The Final Verse (0 bottles): The song concludes with a completely different verse, resetting the count.
  "No more bottles of beer on the wall, no more bottles of beer."
  "Go to the store and buy some more, 99 bottles of beer on the wall."

This exercise beautifully tests a developer's ability to manage state, handle conditional logic, and perform precise string manipulation—skills fundamental to any programming task.

---

Why Use Common Lisp for This Challenge?

Common Lisp, with its rich history and powerful features, offers a uniquely expressive way to solve problems like the Beer Song. It's not just about getting the right output; it's about how you get there. Lisp encourages you to think about problems in a structured, often functional, way.

Key Language Features

• Expressive Syntax (S-expressions): Lisp's parenthesized prefix notation, or S-expressions, makes the code structure explicit. A function call is always (function-name argument1 argument2), which creates a consistent and predictable syntax tree.
• Powerful Control Flow: Beyond simple if statements, Common Lisp provides constructs like cond, which is perfect for handling a series of mutually exclusive conditions—exactly what we need for the 0, 1, and 2-bottle cases.
• The Almighty LOOP Macro: The loop macro is one of the most versatile iteration tools in any language. It allows for complex loops with multiple clauses (for, downto, collect, finally) in a highly readable format.
• Advanced String Formatting: The format function is a mini-language in itself. It can handle variable interpolation, conditional pluralization, and output to different streams (like a string or the console) with incredible flexibility.
• Functional Programming Paradigm: Lisp is a multi-paradigm language, but its functional roots are deep. We can solve this problem using recursion, which often leads to more declarative and elegant code.

By leveraging these features, we can write a solution that is not only correct but also clean, readable, and idiomatic to the Lisp style of programming. For a deeper exploration of these concepts, check out our complete Common Lisp guide.

---

How to Structure the Solution: A Step-by-Step Logic Flow

Before writing a single line of code, it's crucial to break the problem down into manageable pieces. A good structure will make the code easier to write, debug, and understand. We'll separate the logic for a single verse from the logic for singing the entire song.

Our Functional Decomposition

1. A verse Function: This will be our core workhorse. It will take a single integer n (the number of bottles) and return the complete, formatted string for that specific verse. All the conditional logic for handling 0, 1, 2, and the general case will live here.
2. A verses Function: This function will take a starting number and an ending number. It will call the verse function repeatedly for each number in that range and concatenate the results, separated by newlines.
3. A sing Function: This is the main entry point. It will simply call the verses function with the full range of the song (e.g., from 99 down to 0).

This separation of concerns is a fundamental principle of good software design. The verse function does one thing well, and the verses function uses it as a building block.

Visualizing the Verse Logic

The logic inside the verse function is the most complex part. We can visualize its decision-making process with a flow diagram.

    ● Start (Input: n bottles)
    │
    ▼
  ┌───────────────────┐
  │ Check bottle count `n` │
  └─────────┬─────────┘
            │
            ▼
      ◆ Is n == 0?
     ╱          ╲
   Yes           No
    │             │
    ▼             ▼
 [Generate      ◆ Is n == 1?
 "Go to store"  ╱          ╲
  verse]      Yes           No
                │             │
                ▼             ▼
             [Generate      ◆ Is n == 2?
             "1 bottle"    ╱          ╲
              verse]     Yes           No
                           │             │
                           ▼             ▼
                        [Generate    [Generate
                        "2 bottles"  "n bottles"
                         verse]       verse]
                           │             │
                           └──────┬──────┘
                                  │
    ┌─────────────────────────────┴─────────────────────────────┐
    │                                                           │
    ▼                                                           ▼
  ┌────────────────────────┐                             ┌────────────────────────┐
  │ Format and return string │                             │ Format and return string │
  └────────────────────────┘                             └────────────────────────┘
            │                                                    │
            └──────────────────────┬─────────────────────────────┘
                                   │
                                   ▼
                                ● End

This diagram clearly shows the cascading checks required. We handle the most specific cases first (0, 1, 2) and leave the general case for last. This is a perfect use case for the cond special form in Common Lisp.

---

The Complete Common Lisp Solution

Now, let's translate our logic into idiomatic Common Lisp code. We'll define our functions within a package and use comments to explain each part. The primary tool here will be the format function for its powerful string construction capabilities.

The Code Implementation

We'll create a package named beer-song to encapsulate our functions, which is good practice in Common Lisp development.

(defpackage #:beer-song
  (:use #:cl)
  (:export #:verse #:verses #:sing))

(in-package #:beer-song)

(defun bottles-text (n)
  "Returns the correct string for 'n bottles'."
  (format nil "~[no more bottles~;1 bottle~:;~a bottles~]" n n))

(defun verse (n)
  "Generates the verse for a given number of bottles 'n'."
  (cond
    ((= n 0)
     (format nil "No more bottles of beer on the wall, no more bottles of beer.~%Go to the store and buy some more, 99 bottles of beer on the wall.~%"))
    ((= n 1)
     (format nil "1 bottle of beer on the wall, 1 bottle of beer.~%Take it down and pass it around, no more bottles of beer on the wall.~%"))
    (t
     (format nil "~a of beer on the wall, ~a of beer.~%Take one down and pass it around, ~a of beer on the wall.~%"
             (bottles-text n)
             (bottles-text n)
             (bottles-text (1- n))))))

(defun verses (start end)
  "Generates a string of verses from 'start' down to 'end'."
  (loop for i from start downto end
        collect (verse i) into result
        finally (return (format nil "~{~a~^~%~}" result))))

(defun sing (start end)
  "Alias for the verses function to match the problem's naming convention."
  (verses start end))

;; Example of how to use it from the REPL:
;; (beer-song:sing 99 0)

Detailed Code Walkthrough

1. The bottles-text Helper Function

(defun bottles-text (n)
  "Returns the correct string for 'n bottles'."
  (format nil "~[no more bottles~;1 bottle~:;~a bottles~]" n n))

• This small but powerful helper function handles all the pluralization logic in one place.
• It uses a feature of format called conditional formatting (~[...]).
• ~[...~;...~;...~] acts like a case statement. If the argument n is 0, it uses the first clause ("no more bottles"). If n is 1, it uses the second clause ("1 bottle").
• The ~:; directive says that for any other value (n > 1), use the third clause ("~a bottles"), which then uses the second n argument to fill in the number.
• This centralization prevents us from repeating pluralization logic in every verse.

2. The verse Function

(defun verse (n)
  "Generates the verse for a given number of bottles 'n'."
  (cond
    ((= n 0)
     (format nil "No more bottles of beer on the wall, no more bottles of beer.~%Go to the store and buy some more, 99 bottles of beer on the wall.~%"))
    ((= n 1)
     (format nil "1 bottle of beer on the wall, 1 bottle of beer.~%Take it down and pass it around, no more bottles of beer on the wall.~%"))
    (t
     (format nil "~a of beer on the wall, ~a of beer.~%Take one down and pass it around, ~a of beer on the wall.~%"
             (bottles-text n)
             (bottles-text n)
             (bottles-text (1- n))))))

• We use cond, which evaluates each condition sequentially and executes the code for the first one that returns true.
• The first clause checks (= n 0) and returns the special final verse. The hardcoded "99" is a specific requirement of the problem.
• The second clause handles (= n 1), which has unique wording ("Take it down") and results in "no more bottles".
• The t clause is the default case, catching all other numbers. It uses our bottles-text helper for both the current number n and the next number (1- n), ensuring correct grammar for cases like "2 bottles" -> "1 bottle".
• ~% is the format directive for a newline character.

3. The verses Function

(defun verses (start end)
  "Generates a string of verses from 'start' down to 'end'."
  (loop for i from start downto end
        collect (verse i) into result
        finally (return (format nil "~{~a~^~%~}" result))))

• This function showcases the power of the loop macro.
• for i from start downto end sets up the iteration, counting down from the start number to the end number.
• collect (verse i) into result calls our verse function for each number i and gathers the resulting strings into a list called result.
• The finally clause executes once the loop is finished. (return ...) exits the loop and returns the value.
• "~{~a~^~%~}" is another advanced format directive. It iterates through the list `result`. ~a prints each element, and ~^~% inserts a newline between elements but not after the last one. This is the perfect way to join a list of strings with a separator.

---

When to Consider Alternative Approaches

The iterative solution using the loop macro is highly efficient and readable for many Lispers. However, exploring other paradigms like recursion can provide deeper insight into the language's functional capabilities. It's a different way of thinking about the problem.

A Recursive Solution

In a recursive approach, a function calls itself with a modified argument until it reaches a "base case." For the Beer Song, the base case is when we reach the final verse to be printed.

(defun verses-recursive (start end)
  "Generates verses recursively from start down to end."
  (if (< start end)
      "" ; Base case: if we've gone past the end, return an empty string.
      (let ((current-verse (verse start)))
        (if (= start end)
            current-verse ; Base case: if this is the last verse, just return it.
            (format nil "~a~%~a"
                    current-verse
                    (verses-recursive (1- start) end)))))) ; Recursive step

;; You would call this like (verses-recursive 99 0)

How the Recursion Works

1. Base Case: The function first checks if start is less than end. If so, the recursion stops. It also checks if start equals end; if so, it just returns the final verse without making another recursive call.
2. Recursive Step: If it's not the base case, the function generates the verse for the start number. Then, it concatenates this verse with the result of calling itself with a decremented start number (1- start).
3. Unwinding: This process continues until start equals end. At that point, the calls start returning up the chain, building the final string from the end to the beginning.

Comparing Iteration and Recursion

Let's visualize the high-level flow of both approaches.

    Iterative Approach (LOOP)           Recursive Approach (verses-recursive)
    ─────────────────────────           ───────────────────────────────────
    ● Start(99, 0)                      ● Start(99, 0)
    │                                   │
    ▼                                   ▼
  ┌─────────────┐                       ┌──────────────────┐
  │ Loop i = 99 │                       │ Generate verse(99) │
  └──────┬──────┘                       └─────────┬────────┘
         │                                        │
         ▼                                        ▼
    [Collect verse(99)]                Call verses-recursive(98, 0)
         │                                        │
         ▼                                        ▼
  ┌─────────────┐                       ┌──────────────────┐
  │ Loop i = 98 │                       │ Generate verse(98) │
  └──────┬──────┘                       └─────────┬────────┘
         │                                        │
         ▼                                        ▼
    [Collect verse(98)]                Call verses-recursive(97, 0)
         │                                        │
         ...                                      ... (down to 0)
         │                                        │
         ▼                                        ▼
  ┌─────────────┐                       ┌──────────────────┐
  │ Loop i = 0  │                       │ Generate verse(0)  │
  └──────┬──────┘                       └─────────┬────────┘
         │                                        │ (Base Case Hit)
         ▼                                        ▼
  ┌─────────────┐                       [Return verse(0)]
  │ Join all    │                                 │
  │ collected   │                                 ▼
  │ verses      │                     [Return verse(1) + result from below]
  └─────────────┘                                 │
         │                                        ▼
         ▼                                      ... (unwinding)
    ● End                                         │
                                                  ▼
                                        [Return verse(99) + result from below]
                                                  │
                                                  ▼
                                               ● End

Pros and Cons Table

Aspect	Iterative (loop)	Recursive
Readability	Very high for developers familiar with imperative loops. The intent is explicit and linear.	Can be more elegant and declarative for those with a functional programming background. May be less intuitive for beginners.
Performance	Generally more performant in Common Lisp for simple linear tasks. Avoids function call overhead.	Can lead to stack overflow errors for very large inputs if not implemented with tail-call optimization (which is not guaranteed by the standard). For 100 verses, this is not an issue.
Memory Usage	The collect clause builds a list in memory, so memory usage is proportional to the number of verses.	Each recursive call adds a frame to the call stack. String concatenation can also create many intermediate strings, potentially using more memory.
Idiomatic Style	The loop macro is highly idiomatic and a celebrated feature of Common Lisp.	Recursion is a cornerstone of the Lisp heritage and is very idiomatic for problems that are naturally recursive (like traversing trees).

For this specific problem, the iterative solution is arguably more practical and straightforward. However, understanding the recursive alternative is crucial for mastering the functional side of Lisp, a skill you'll need as you progress through the kodikra learning path.

---

FAQ: Common Lisp Beer Song

Why is the format function so powerful in Common Lisp?

The format function is much more than a simple string interpolator. It's a domain-specific language for text formatting. It can handle different number bases, justification, padding, conditional logic (like our pluralization example), and iteration over lists, all within the format control string. This power allows developers to create complex text output with concise and expressive code.

What's the difference between cond and if in this context?

if is for a simple binary choice: (if condition then-form else-form). For the Beer Song, we have multiple conditions (n=0, n=1, n=2, etc.). Chaining multiple if statements (nesting them) would be clumsy and hard to read. cond is designed for exactly this scenario, providing a clean, flat list of condition/action pairs: (cond (test1 action1) (test2 action2) ...). It's the right tool for handling multiple, mutually exclusive cases.

Is recursion or iteration better for the Beer Song problem in Lisp?

For this problem, iteration using the loop macro is generally considered more pragmatic. It's efficient, highly readable, and avoids any potential for stack depth issues (though not a real concern here). The recursive solution is an excellent academic exercise to understand a core functional concept but offers no practical advantage over the iterative one in this specific case.

How did you handle pluralization ("bottle" vs. "bottles") so elegantly?

The elegance comes from centralizing the logic in a helper function (bottles-text) and leveraging a specific feature of the format function. The ~[...~;...~:;...~] directive allows conditional selection of a format string based on a numeric argument. This avoids messy if statements scattered throughout the code and makes the main verse logic cleaner.

What is t in Common Lisp?

t is the canonical symbol for "true" in Common Lisp. In a cond form, a final clause of (t ...) acts as a default or "else" case, because t is always true. Its condition will always be met if none of the preceding conditions were, making it perfect for handling the general case in our verse logic.

Could I solve this without helper functions?

Yes, you could put all the logic inside one giant function. However, this is poor software design. Using helper functions like bottles-text follows the Don't Repeat Yourself (DRY) principle. It isolates a specific piece of logic (pluralization), making the code easier to read, test, and maintain. If the pluralization rule ever changed, you'd only have to update it in one place.

Where can I learn more about Common Lisp control structures?

The best way to learn is by doing. The kodikra.com curriculum is filled with challenges that test your understanding of control flow. For more in-depth documentation and examples, our comprehensive Common Lisp language guide is an excellent resource covering everything from basic loops to advanced macros.

---

Conclusion: More Than Just a Song

We've successfully navigated the Beer Song challenge, transforming a simple set of rules into a robust and idiomatic Common Lisp program. Along the way, we've done far more than just print lyrics. We've explored fundamental concepts: the power of functional decomposition, the clarity of the cond macro for handling edge cases, the unparalleled flexibility of format for string manipulation, and the expressive nature of the loop macro.

We also contrasted this iterative approach with a classic recursive solution, highlighting the different ways to think about a problem in a multi-paradigm language like Lisp. This exercise, found in the Module 3 roadmap on kodikra.com, serves as a perfect stepping stone, solidifying your understanding of core principles before you move on to more complex topics.

The true lesson of the Beer Song is that even the simplest problems can teach profound lessons about software craftsmanship. Attention to detail, clean structure, and choosing the right tool for the job are the hallmarks of an expert developer.

Disclaimer: The code in this article is based on standard Common Lisp as of its latest specification (ANSI Common Lisp). It is expected to be compatible with all major implementations like SBCL, CCL, and ECL.

---

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