---

The Complete Guide to Solving Darts in Clojure

Calculating the score in a game of Darts from a simple set of coordinates is a classic programming challenge that elegantly blends geometry with conditional logic. This task requires translating a point on a 2D plane into a score based on its distance from the center, a perfect problem to showcase the mathematical prowess and expressive syntax of Clojure.

---

The Challenge: From Pixels to Points

Imagine you're building the backend for a new online darts game. The frontend can tell you exactly where the dart landed, providing a simple (x, y) coordinate. Your job is to write the core scoring logic. It sounds simple, but it's the heart of the game. A miss-click, a floating-point error, or an inefficient calculation could ruin the player's experience.

You're faced with a clear set of rules: a bullseye is worth 10 points, the middle ring is 5, the outer ring is 1, and anything beyond that is a miss, worth 0. How do you convert the raw, mathematical precision of Cartesian coordinates into this simple, tiered scoring system? This is where the power of a functional language like Clojure shines, allowing us to build a solution that is not only correct but also concise and deeply readable.

In this guide, we will deconstruct this problem from the ground up. We'll start with the fundamental geometry, translate it into clean Clojure code, and even explore performance optimizations that separate good code from great code. By the end, you'll have mastered a key module from the kodikra Clojure learning path and gained insights applicable to a wide range of computational problems.

---

What is the Darts Scoring Problem?

The Darts problem, as presented in the kodikra.com exclusive curriculum, is a focused computational geometry task. The goal is to write a function that takes two numerical inputs, x and y, representing the coordinates where a dart has landed on a 2D plane. The function must then return an integer score based on the dart's position relative to a target centered at the origin (0, 0).

The target consists of three concentric circles, each defining a scoring zone:

• Inner Circle (Bullseye): Has a radius of 1 unit. Landing within or on this circle awards 10 points.
• Middle Circle: Has a radius of 5 units. Landing outside the bullseye but within or on this circle awards 5 points.
• Outer Circle: Has a radius of 10 units. Landing outside the middle circle but within or on this circle awards 1 point.
• Outside the Target: Any dart landing further than 10 units from the center scores 0 points.

The core of the challenge lies in calculating the straight-line distance from the center of the board (0, 0) to the landing point (x, y) and then using this distance to determine which scoring zone was hit.

---

Why is Clojure a Perfect Fit for This Problem?

Clojure, a modern Lisp dialect that runs on the Java Virtual Machine (JVM), is exceptionally well-suited for problems that are mathematical and logical in nature. Its design philosophy emphasizes simplicity, immutability, and the composition of pure functions, which brings several advantages to the Darts challenge.

Key Clojure Features:

• Mathematical Readability: Clojure's prefix notation (operator operand1 operand2) makes complex mathematical expressions easy to parse and compose. Operations like (+ (* x x) (* y y)) are unambiguous and reflect the structure of the calculation directly.
• Powerful Core Library: The language provides essential functions out of the box. For this problem, we can leverage Java interop to access the Math library for functions like Math/sqrt without any complex imports.
• Expressive Conditionals: Clojure's cond macro is a perfect tool for handling a series of conditions, like our tiered scoring system. It's far cleaner and more scalable than nested if-else statements, leading to more readable and maintainable code.
• Local Bindings with let: The let form allows us to compute a value once (like the distance) and bind it to a local name. This avoids redundant calculations and significantly improves the clarity of the code, as the name can describe the value's purpose.

These features allow us to write a solution that is not just functional but also declarative. We describe what the score is based on the distance, rather than getting bogged down in the imperative steps of how to check each condition. For more on these foundational concepts, explore our complete Clojure guide.

---

How to Calculate the Score: A Step-by-Step Implementation

Let's build the solution from first principles. We'll start with the underlying mathematics, translate it into Clojure, and then refine it into a robust and elegant function.

Step 1: The Geometry — Pythagoras to the Rescue

The distance between two points in a Cartesian coordinate system is found using the Pythagorean theorem. For a point (x, y) and the origin (0, 0), the coordinates form a right-angled triangle. The lengths of the sides adjacent to the right angle are x and y, and the hypotenuse is the distance d we want to find.

The theorem states: a² + b² = c².

In our case, this becomes: x² + y² = d².

To find the distance d, we simply take the square root of the sum of the squares:

d = √(x² + y²)

This formula is the mathematical heart of our solution. Once we have d, the rest is just a matter of checking which scoring radius it falls within.

Step 2: Structuring the Clojure Function

We'll define a function called score that accepts two arguments, x and y. This is the public API of our scoring logic.

(ns darts)

(defn score [x y]
  ;; Our logic will go here
)

Step 3: Calculating the Distance with let

Inside our function, the first thing we need is the distance. We can calculate x² + y² and then find its square root. To keep our code clean and avoid recalculating this value, we'll use a let block to compute it once and bind it to a descriptive name, like distance.

(defn score [x y]
  (let [distance (Math/sqrt (+ (* x x) (* y y)))]
    ;; Conditional logic will use 'distance'
  ))

Let's break down this expression:

• (* x x): Calculates x squared.
• (* y y): Calculates y squared.
• (+ ...): Adds the two squared values together.
• (Math/sqrt ...): A Java interop call to get the square root of the sum.
• (let [distance ...]): The result of this entire calculation is bound to the symbol distance, which is only available within the scope of the let block.

Step 4: Mapping Distance to Score with cond

Now that we have the distance, we need to check it against the scoring radii. The cond macro is ideal for this. It takes a series of test-expression/result-expression pairs and evaluates them in order. It returns the result-expression for the first test-expression that evaluates to true.

The logic flows from the smallest radius (highest score) to the largest:

1. Is the distance less than or equal to 1? If yes, the score is 10.
2. If not, is the distance less than or equal to 5? If yes, the score is 5.
3. If not, is the distance less than or equal to 10? If yes, the score is 1.
4. If none of the above are true, the dart missed the board. The score is 0.

This translates directly into a cond block:

(cond
  (<= distance 1) 10
  (<= distance 5) 5
  (<= distance 10) 1
  :else 0)

The :else keyword is a convention for the final test. Since it's a keyword, it always evaluates to a truthy value, acting as a default or catch-all case if all preceding conditions are false.

The Complete Solution

Putting it all together, we arrive at the final, clean, and commented solution for this kodikra module.

(ns darts
  "This namespace provides the logic for scoring a darts game.")

(defn score
  "Calculates the score for a single dart toss given its x and y coordinates.
   The target is centered at (0, 0).

   - Bullseye (radius <= 1): 10 points
   - Middle ring (radius <= 5): 5 points
   - Outer ring (radius <= 10): 1 point
   - Miss (radius > 10): 0 points"
  [x y]
  ;; Use a 'let' block to calculate the distance from the origin (0,0) once.
  ;; This makes the code more readable and efficient by avoiding redundant calculations.
  ;; The distance is calculated using the Pythagorean theorem: d = sqrt(x^2 + y^2).
  (let [distance (Math/sqrt (+ (* x x) (* y y)))]
    ;; 'cond' is used to check the distance against the scoring rings.
    ;; It evaluates conditions sequentially and returns the value associated
    ;; with the first true condition. This is perfect for tiered logic.
    (cond
      ;; Is the dart in the bullseye?
      (<= distance 1) 10

      ;; Is the dart in the middle circle?
      (<= distance 5) 5

      ;; Is the dart in the outer circle?
      (<= distance 10) 1

      ;; If none of the above, it's a miss.
      ;; :else is a convention for the default case.
      :else 0)))

Logic Flow Diagram

Here is a visual representation of the logic our function follows:

    ● Start: Input (x, y)
    │
    ▼
  ┌─────────────────────────────┐
  │ Calculate distance          │
  │ d = sqrt(x² + y²)           │
  └───────────┬─────────────────┘
              │
              ▼
    ◆ Is d ≤ 1? ───────── Yes ⟶ [Return 10]
    │
    No
    │
    ▼
    ◆ Is d ≤ 5? ───────── Yes ⟶ [Return 5]
    │
    No
    │
    ▼
    ◆ Is d ≤ 10? ──────── Yes ⟶ [Return 1]
    │
    No
    │
    ▼
  ┌─────────────────────────────┐
  │ Default Case (:else)        │
  └───────────┬─────────────────┘
              │
              ▼
              ⟶ [Return 0]

---

When to Consider Alternative Approaches: The Optimization

Our solution is correct, readable, and idiomatic. For most applications, it's perfect. However, in high-performance scenarios like a real-time physics engine or a game server handling thousands of requests per second, every CPU cycle counts. The call to Math/sqrt involves floating-point arithmetic that can be computationally more expensive than simple multiplication and comparison.

The "Squared Distance" Trick

We can avoid the square root calculation entirely. If d = √(x² + y²), then d² = x² + y².

Instead of comparing the distance d to the radii (1, 5, 10), we can compare the squared distance d² to the squared radii (1², 5², 10²), which are 1, 25, and 100.

The logic remains the same:

• If d² ≤ 1² (i.e., x² + y² ≤ 1), score 10.
• If d² ≤ 5² (i.e., x² + y² ≤ 25), score 5.
• If d² ≤ 10² (i.e., x² + y² ≤ 100), score 1.

Optimized Code Implementation

This small change simplifies the calculation inside our let block, potentially yielding a performance boost.

(ns darts)

(defn score-optimized
  "Calculates the score using squared distances to avoid the costly sqrt operation."
  [x y]
  ;; Calculate the squared distance directly. This is computationally cheaper.
  (let [distance-sq (+ (* x x) (* y y)))]
    ;; Compare the squared distance with the squared radii (1*1=1, 5*5=25, 10*10=100).
    (cond
      (<= distance-sq 1) 10   ;; 1*1
      (<= distance-sq 25) 5  ;; 5*5
      (<= distance-sq 100) 1 ;; 10*10
      :else 0)))

Optimized Logic Flow Diagram

This diagram shows the slightly altered calculation step.

    ● Start: Input (x, y)
    │
    ▼
  ┌─────────────────────────────┐
  │ Calculate SQUARED distance  │
  │ d² = x² + y²                │
  └───────────┬─────────────────┘
              │
              ▼
    ◆ Is d² ≤ 1? ────────── Yes ⟶ [Return 10]
    │
    No
    │
    ▼
    ◆ Is d² ≤ 25? ───────── Yes ⟶ [Return 5]
    │
    No
    │
    ▼
    ◆ Is d² ≤ 100? ──────── Yes ⟶ [Return 1]
    │
    No
    │
    ▼
              ⟶ [Return 0]

Pros & Cons of Each Approach

Choosing between these two versions is a trade-off between readability and performance.

Approach	Pros	Cons
Standard (with Math/sqrt)	Highly readable and intuitive. Directly implements the mathematical distance formula. Easier for other developers to understand at a glance.	Marginally slower due to the floating-point square root calculation.
Optimized (with Squared Distance)	More performant by avoiding Math/sqrt. Uses only integer/floating-point multiplication and addition.	Less intuitive; requires understanding the "squared distance" trick. The "magic numbers" (25, 100) might need comments to explain their origin.

For the vast majority of applications, the standard approach is preferable due to its clarity. The optimized version should be reserved for situations where profiling has identified this specific calculation as a performance bottleneck.

---

Where This Logic Applies in the Real World

While scoring a darts game is a fun example, the core principle—calculating the distance from a central point and acting based on that distance—is a fundamental pattern in computer science and software engineering.

• Game Development: Beyond scoring, this is used for collision detection (is an object within the blast radius of an explosion?), AI behavior (is the enemy within aggro range?), and click detection (did the user click inside a circular button?).
• Geospatial Services: Applications like Uber or Google Maps use this logic constantly. "Find all restaurants within a 5-mile radius" is the same problem, just on a global scale with latitude and longitude.
• Computer Graphics: Used in shaders and rendering engines to create effects like vignettes (darkening the corners of an image), radial gradients, or simulating light sources.
• Network Analysis: In graph theory, it can be adapted to find all nodes within a certain number of "hops" from a central node, crucial for routing algorithms and social network analysis.

---

Frequently Asked Questions (FAQ)

What is the Pythagorean theorem and why is it essential here?

The Pythagorean theorem, a² + b² = c², is a fundamental principle of Euclidean geometry that relates the sides of a right-angled triangle. It's essential here because the x and y coordinates of a point form the two shorter sides of a right triangle, with the origin as one vertex. The hypotenuse (c) of that triangle is the direct distance from the origin to the point, which is exactly what we need to determine the score.

Why use cond instead of nested if statements in Clojure?

While you could use nested (if ... (if ...)) forms, cond is specifically designed for a sequence of mutually exclusive conditions. It produces code that is "flatter," more readable, and easier to modify. Adding a new scoring ring would just be one new line in the cond block, whereas it would require restructuring nested if statements, making cond the idiomatic and more maintainable choice in Clojure.

Can I really solve this without using Math/sqrt?

Yes. As shown in the "Alternative Approaches" section, you can perform the entire comparison using squared distances. By comparing the sum of the squares of the coordinates (x² + y²) with the squares of the radii (1, 25, 100), you avoid the computationally more expensive square root operation, which can be a valuable optimization in performance-critical code.

What does the let form do in the Clojure solution?

let is a special form in Clojure that establishes local bindings. It allows you to compute a value, assign it to a temporary, named symbol (like distance), and then use that symbol within the body of the let block. This is useful for two main reasons: 1) It improves readability by giving a descriptive name to a complex calculation. 2) It improves efficiency by ensuring the calculation is performed only once, even if the named symbol is used multiple times.

How would this logic change if the dartboard center wasn't at (0, 0)?

If the center of the dartboard was at a different coordinate, say (cx, cy), the logic would only require a small adjustment to the distance formula. You would calculate the difference in the x and y coordinates before squaring them: distance = √((x - cx)² + (y - cy)²). The rest of the `cond` logic for checking the distance against the radii would remain exactly the same.

Is Clojure a good language for game development?

Clojure can be an excellent choice for certain aspects of game development, particularly for the game logic, server-side code, and AI. Its functional nature and immutable data structures can help manage complex game states more predictably. While not as common for high-performance graphics rendering as C++, it pairs well with game engines and libraries (like libGDX via interop) and is a strong contender for building the "brain" of a game.

---

Conclusion: From Theory to Mastery

We've successfully journeyed from a simple geometric theorem to a complete, optimized, and idiomatic Clojure solution for the Darts scoring problem. This exercise from the kodikra.com curriculum is more than just a game; it's a practical lesson in applying mathematical concepts, structuring logical flows with cond, and managing intermediate values cleanly with let.

You've also seen a crucial aspect of software engineering: the trade-off between readability and performance. The "squared distance" optimization is a powerful technique, but understanding when and why to use it is what separates a novice from an expert developer. The principles learned here—calculating distance, handling tiered conditions, and optimizing calculations—will serve you well in countless other programming challenges.

Ready to tackle the next challenge? Explore our full Clojure Learning Roadmap to continue building your skills and mastering this powerful functional language.

Disclaimer: All code in this article is written and tested against Clojure 1.11+ and standard Java Development Kit (JDK) versions. The core functions used (+, *, let, cond) and Java interop (Math/sqrt) are fundamental and stable across versions.

---

Published by Kodikra — Your trusted Clojure learning resource.