---

The Complete Guide to Solving Darts in Common Lisp: From Geometry to Code

To calculate the score in a Darts game using Common Lisp, you must first determine the dart's distance from the center (0,0) via the Pythagorean theorem. For efficiency, compare the squared distance (x² + y²) against the squared radii (1, 25, 100) using a cond expression to map the distance to the correct score.

You've seen it in movies, pubs, or maybe even your own garage: the focused stance, the steady arm, the satisfying *thwack* as a dart hits the board. The game of Darts is a classic test of skill. But behind its simple rules lies a perfect problem for a programmer—a challenge that blends geometry, logic, and computational efficiency. You might look at the board and intuitively know the score, but how do you teach a computer to do the same?

Translating this visual, spatial problem into clean, effective code can be surprisingly tricky. You're not just writing a program; you're modeling a piece of the physical world. This guide will walk you through every step, transforming the geometric rules of Darts into an elegant and idiomatic Common Lisp solution. We'll explore not just *how* to solve it, but *why* the solution is structured the way it is, revealing powerful concepts you can apply to countless other programming challenges.

---

What is the Darts Problem in the Kodikra Learning Path?

The Darts problem, a core challenge in the kodikra.com Common Lisp learning path, asks us to write a function that calculates the score of a single dart toss. The function receives the Cartesian coordinates (x, y) of where the dart landed on a 2D plane. The center of the dartboard is located at the origin (0, 0).

The scoring is based on concentric circles, each defined by a radius from the center:

• Bullseye: If the dart lands within the inner circle (radius of 1 unit), the player scores 10 points.
• Middle Ring: If the dart lands outside the bullseye but within the middle circle (radius of 5 units), the player scores 5 points.
• Outer Ring: If the dart lands outside the middle ring but within the outer circle (radius of 10 units), the player scores 1 point.
• A Miss: If the dart lands outside the outer circle (a radius greater than 10 units), the player scores 0 points.

The challenge lies in taking the x and y inputs and correctly applying these geometric rules to return a single integer representing the score.

---

Why This Problem is a Gateway to Mastering Core Concepts

At first glance, this seems like a simple geometry puzzle. However, solving it effectively teaches fundamental principles that are critical for any aspiring software engineer. It’s more than just a coding exercise; it’s a practical lesson in algorithmic thinking and language mastery.

Mathematical Modeling in Code

The most crucial skill this problem hones is mathematical modeling. You are tasked with translating a physical object (a dartboard) and its rules into a purely logical and mathematical construct. The core of this is the Pythagorean theorem, which allows us to calculate the distance from the center to any point (x, y) on a plane. The distance d is given by the formula d = sqrt(x² + y²). This is also known as the Euclidean distance.

Algorithmic Efficiency

A naive solution might calculate the exact distance using the sqrt function. However, square root operations are computationally more expensive than basic arithmetic like multiplication and addition. A key insight for an optimized solution is that if d1 > d2, then it is also true that d1² > d2². This means we can avoid the costly sqrt operation entirely by comparing the *squared distance* (x² + y²) with the *squared radii* of the scoring circles (1², 5², 10²). This concept of avoiding unnecessary computation is a cornerstone of writing efficient, high-performance code.

Learning Idiomatic Common Lisp

Every programming language has its own "style" or idiomatic way of solving problems. For Common Lisp, this problem is a perfect introduction to the cond macro. While you could solve it with a series of nested if statements, cond provides a much cleaner, more readable, and more extensible way to handle multi-branch conditional logic. Learning to "think in `cond`" is a significant step towards writing code like a seasoned Lisp developer.

---

How to Solve the Darts Problem: The Logic and Implementation

Let's break down the solution into a clear, step-by-step process. Our goal is to create a function, let's call it score, that takes x and y as arguments and returns the correct point value.

Step 1: The Core Logic — From Coordinates to Squared Distance

The entire scoring system depends on the dart's distance from the origin (0,0). As we established, we don't need the exact distance, just its relationship to the scoring radii. Therefore, our first and most important calculation is the squared distance.

Given coordinates (x, y):

distance_squared = x² + y²

We will calculate this value once and then use it for all our comparisons. This is more efficient than recalculating it for every check.

Step 2: The Conditional Checks — Mapping Distance to Score

Now, we compare our calculated distance_squared with the squares of the scoring radii. The order of these checks is critical. We must check from the smallest radius (the bullseye) outwards. If we checked for the outer ring first, a bullseye hit would incorrectly be scored as 1 point, because a distance of 0.5 is indeed less than 10.

The logic flows as follows:

1. Is distance_squared <= 1² (which is 1)? If yes, the score is 10. Stop.
2. If not, is distance_squared <= 5² (which is 25)? If yes, the score is 5. Stop.
3. If not, is distance_squared <= 10² (which is 100)? If yes, the score is 1. Stop.
4. If none of the above are true, the dart missed the board. The score is 0.

This sequential, ordered logic is perfectly suited for Common Lisp's cond structure.

ASCII Diagram: Logical Flow

Here is a visual representation of our algorithm's decision-making process.

    ● Start (Input: x, y)
    │
    ▼
  ┌───────────────────────────┐
  │ Calculate squared_distance │
  │   d² = x² + y²            │
  └────────────┬──────────────┘
               │
               ▼
         ◆ d² <= 1 ?
        ╱         ╲
      Yes          No
      │            │
      ▼            ▼
 [Score = 10]    ◆ d² <= 25 ?
                   ╱         ╲
                 Yes          No
                 │            │
                 ▼            ▼
              [Score = 5]    ◆ d² <= 100 ?
                              ╱         ╲
                            Yes          No
                            │            │
                            ▼            ▼
                         [Score = 1]   [Score = 0]
                            │            │
                            └──────┬─────┘
                                   │
                                   ▼
                                ● End (Return Score)

The Common Lisp Implementation

Now, let's translate this logic into clean, idiomatic Common Lisp code. We will define a package and a single function, score, within it.

;;; This code is part of the exclusive kodikra.com curriculum.

(defpackage #:darts
  (:use #:cl)
  (:export #:score))

(in-package #:darts)

(defun score (x y)
  "Calculates the score for a dart toss given the cartesian coordinates (x, y).
   It uses the squared Euclidean distance for efficient comparison."

  ;; Bind the result of the calculation to a local variable 'dist-squared'.
  ;; This avoids re-calculating the value for each condition.
  (let ((dist-squared (+ (* x x) (* y y))))

    ;; Use 'cond' for clear, multi-branch conditional logic.
    ;; The checks are ordered from the smallest radius to the largest.
    (cond
      ((<= dist-squared 1) 10)   ; Bullseye (radius 1, squared radius 1)
      ((<= dist-squared 25) 5)  ; Middle ring (radius 5, squared radius 25)
      ((<= dist-squared 100) 1) ; Outer ring (radius 10, squared radius 100)
      (t 0))))                   ; 't' acts as the default "else" case for a miss.

Detailed Code Walkthrough

Let's dissect this solution piece by piece to understand exactly what's happening.

1. (defpackage #:darts ...): This defines a new package named darts. In Common Lisp, packages are used to manage namespaces, preventing name collisions between different parts of a large program. We specify that it should use the standard Common Lisp package (#:cl) and that it should export the symbol score, making it accessible to other packages.
2. (in-package #:darts): This command switches the current namespace to our newly created darts package. All subsequent definitions will belong to this package.
3. (defun score (x y) ...): This is the standard way to define a function in Common Lisp. Our function is named score and it accepts two arguments, x and y.
4. (let ((dist-squared (+ (* x x) (* y y)))) ...): Here, we use the let special form. let creates local variable bindings. We define a variable named dist-squared and assign it the value of x*x + y*y. The rest of the code inside the let block can now access this variable. This is crucial for both readability and performance.
5. (cond ...): This is the heart of our logic. cond evaluates a series of clauses. Each clause has the form (test-expression result-expression).
   • cond evaluates the test-expression of the first clause.
   • If it's true, it evaluates the corresponding result-expression and returns its value. The entire cond form stops executing.
   • If it's false, it moves to the next clause and repeats the process.
6. ((<= dist-squared 1) 10): This is the first clause. The test is (<= dist-squared 1). If the squared distance is less than or equal to 1, this clause returns 10.
7. ((<= dist-squared 25) 5): If the first test failed, this one is checked. If the squared distance is less than or equal to 25, it returns 5.
8. ((<= dist-squared 100) 1): The third check, for the outer ring.
9. (t 0): This is the final, default clause. The symbol t in Common Lisp represents the canonical true value. A clause of the form (t result) will always have its test succeed, making it the equivalent of an else statement in other languages. If all previous checks have failed, we know the dart missed the board, and this clause ensures we return 0.

How to Run and Test the Code

You can test this function in any Common Lisp environment, such as SBCL (Steel Bank Common Lisp).

1. Save the code above into a file named darts.lisp.

2. Start your Lisp REPL (Read-Eval-Print Loop).

3. Load the file:

* (load "darts.lisp")
T

4. To use the function, you can either refer to it with its full package name or import the package symbols.

* (darts:score 0 0)   ; Bullseye
10

* (darts:score 3 4)   ; x²+y² = 9+16 = 25. On the edge of the middle ring.
5

* (darts:score -7 8)  ; x²+y² = 49+64 = 113. Outside the board.
0

* (darts:score 0.5 -0.5) ; x²+y² = 0.25+0.25 = 0.5. Bullseye.
10

---

Alternative Approaches and Performance Considerations

While our chosen solution is efficient and idiomatic, it's valuable to explore other ways to solve the problem to understand the trade-offs involved.

Approach 1: Using the Actual Distance with `sqrt`

A more direct translation of the geometric formula would involve calculating the actual distance using sqrt. Common Lisp doesn't have a built-in hypot function like some other languages, but we can easily use sqrt.

(defun score-with-sqrt (x y)
  "Calculates the score using the actual Euclidean distance."
  (let ((distance (sqrt (+ (* x x) (* y y)))))
    (cond
      ((<= distance 1) 10)
      ((<= distance 5) 5)
      ((<= distance 10) 1)
      (t 0))))

This code is arguably more readable to someone unfamiliar with the squared-distance optimization, as the numbers 1, 5, and 10 directly match the problem description. However, it introduces a floating-point calculation (sqrt) which is generally slower than integer arithmetic.

Approach 2: Using Nested `if` Statements

You can also solve the problem without cond, using only if. This often leads to less elegant, nested code.

(defun score-with-if (x y)
  "Calculates the score using nested IF statements."
  (let ((dist-squared (+ (* x x) (* y y))))
    (if (<= dist-squared 1)
        10
        (if (<= dist-squared 25)
            5
            (if (<= dist-squared 100)
                1
                0)))))

While this works perfectly, it's harder to read and maintain. Each new condition adds another level of indentation, creating what is sometimes called an "arrow shape" of code. The flat structure of cond is far superior for this kind of linear, multi-branch logic.

Pros and Cons: Squared Distance vs. `sqrt`

Let's formalize the comparison in a table.

Approach	Pros	Cons	Best For
Squared Distance Comparison	- Highly performant; avoids floating-point math and expensive sqrt calls. - Uses integer arithmetic which is faster.	- Less immediately obvious; requires the developer to know the optimization trick. - Compares against "magic numbers" (25, 100) instead of the radii (5, 10).	Performance-critical applications like game engines, physics simulations, or high-frequency calculations.
Using `sqrt` (Actual Distance)	- Very readable and a direct implementation of the distance formula. - The code's numbers (1, 5, 10) match the problem statement exactly.	- Less performant due to the sqrt function call. - Introduces potential floating-point inaccuracies in more complex scenarios.	Situations where code clarity is the absolute highest priority and performance is not a bottleneck.

ASCII Diagram: Scoring Zones by Squared Distance

This diagram helps visualize the logic used in our primary, optimized solution.

    Target Zones by Squared Distance (d²)
    
    (0,0) Center
      │
      ├─> Range: d² ∈ [0, 1]
      │   └── ● Bullseye: 10 Points
      │
      ├─> Range: d² ∈ (1, 25]
      │   └── ● Middle Ring: 5 Points
      │
      ├─> Range: d² ∈ (25, 100]
      │   └── ● Outer Ring: 1 Point
      │
      └─> Range: d² ∈ (100, ∞)
          └── ● Miss: 0 Points

---

Frequently Asked Questions (FAQ)

1. Why is comparing squared distances better than using sqrt?

The primary reason is performance. The sqrt function is a complex operation for a CPU to perform compared to simple multiplication. By squaring the radii and comparing against the squared distance (x² + y²), we completely eliminate the need for this expensive function call. In a single call it makes no difference, but in an application that performs this check thousands of times per second (like a game engine), this optimization is significant.

2. What exactly is cond in Common Lisp?

cond is Common Lisp's primary conditional macro for handling multiple cases. It takes a series of clauses, each containing a test and a result. It evaluates the tests one by one until it finds one that is true, then it executes the corresponding result and stops. It's a more powerful and flexible version of the switch or case statements found in other languages and is generally preferred over deeply nested if statements.

3. Why is the order of the checks in cond so important?

The order is crucial because cond stops at the *first* true condition. A dart that lands in the bullseye (e.g., at a squared distance of 0.5) also satisfies the conditions for the middle ring (0.5 <= 25) and the outer ring (0.5 <= 100). If we checked for the outer ring first, the function would incorrectly return 1 point. By checking from the most specific, smallest area (bullseye) to the most general, largest area (outer ring), we ensure the correct score is always awarded.

4. What does the let block do?

The let special form establishes a new lexical scope and binds variables to values within that scope. In our code, (let ((dist-squared ...))) calculates the squared distance once and stores it in the local variable dist-squared. This variable is only accessible inside the let block. This is good practice because it makes the code more readable (giving a name to the value) and more efficient (preventing the same calculation from being repeated in every clause of the cond).

5. How does this Darts problem relate to real-world game development?

This problem is a simplified version of a very common task in game development: hit detection or collision detection. Games constantly need to check if a point (like a mouse click or a bullet) is inside a certain area (like a button or an enemy). The logic of calculating distance to a center point and checking it against a radius is fundamental for circular or spherical hitboxes.

6. What does t mean in the last clause of cond?

In Common Lisp, the symbol t is the canonical representation of "true". Any non-nil value is considered true in a boolean context, but t is the standard one. When used as the test in a cond clause, (t ...), it serves as a catch-all "else" or "default" case because the test t will always evaluate to true, guaranteeing that this clause will be executed if no preceding clause was.

7. Can I use other Lisp functions like expt for squaring?

Yes, you could write (+ (expt x 2) (expt y 2)). The expt function raises a number to a power. However, for squaring a number, simply multiplying it by itself, (* x x), is generally considered more idiomatic and can be slightly more performant in some Lisp implementations as it avoids the overhead of a more general-purpose power function.

---

Conclusion: From a Simple Game to Powerful Principles

We began with the simple, familiar image of a dartboard and have now journeyed through Cartesian geometry, algorithmic optimization, and idiomatic Common Lisp programming. The Darts problem, while straightforward, serves as a powerful lesson. It teaches us to look beyond the surface and find more efficient ways to model the world in code, such as choosing squared distance comparisons over costly sqrt operations.

You have learned how to structure multi-branch logic cleanly using cond and how to manage local state effectively with let. These are not just tricks for one specific problem; they are fundamental patterns that will make your code more readable, maintainable, and performant. By mastering this challenge, you've added essential tools to your programming arsenal.

For more challenges that build on these concepts, explore the full Common Lisp Learning Path on kodikra.com. To dive deeper into the language's features and philosophy, be sure to visit our comprehensive guide to Common Lisp.

Disclaimer: The code in this article is written against the Common Lisp standard. Behavior is consistent across modern implementations like SBCL 2.4+, CLISP, and CCL.

---

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