---

Common Lisp Resistor Color Duo: The Complete Guide from Zero to Hero

Learn to solve the Resistor Color Duo challenge in Common Lisp by mapping color names to their numeric values. This guide explains how to process a list of colors, extract the first two, and concatenate their corresponding digits to form a two-digit resistance value efficiently.

You’re staring at a breadboard, a tiny Raspberry Pi humming beside you, ready to bring your next brilliant electronics project to life. But then you hit a snag—a pile of minuscule resistors, their resistance values hidden behind a cryptic code of colored bands. It’s a classic pain point for makers and engineers alike, where the physical world’s constraints demand an elegant, abstract solution.

This scenario is more than just an electronics puzzle; it's a perfect analogy for many programming challenges. We're often given data in one form (colors) and need to translate it into another (a numeric value). This guide promises to turn that frustration into mastery. We will dissect this problem and build a robust solution in Common Lisp, transforming you from a novice to a confident Lisp programmer capable of tackling real-world data manipulation tasks. You won't just learn the answer; you'll understand the Lisp philosophy behind it.

---

What is the Resistor Color Duo Problem?

At its core, the Resistor Color Duo problem is a translation task rooted in electronics. It simplifies the real-world resistor color code system to focus on a fundamental programming concept: mapping and data extraction. For this challenge, derived from the exclusive kodikra.com curriculum, we only care about the first two color bands on a resistor.

Each color corresponds to a specific digit from 0 to 9. The goal is to take a list of color names (representing the bands on a resistor) and calculate a two-digit number formed by the values of the first two colors. For example, if the first band is "brown" and the second is "black", their corresponding values are 1 and 0. Combining these gives us the number 10.

The Standard Color-to-Value Mapping

To solve the problem, you must first know the universal mapping. This is the dictionary or key-value store that will be the foundation of our program's logic.

• Black: 0
• Brown: 1
• Red: 2
• Orange: 3
• Yellow: 4
• Green: 5
• Blue: 6
• Violet: 7
• Grey: 8
• White: 9

So, given an input list like ("green" "blue" "yellow"), our program should:

1. Identify the first color: "green" (value 5).
2. Identify the second color: "blue" (value 6).
3. Combine these two values to form the number 56.

The remaining colors in the list are ignored for this specific problem, simplifying the scope and allowing us to focus on core Lisp features.

---

Why is This an Ideal Challenge for Common Lisp?

Common Lisp, with its roots in symbolic computation and data manipulation, is exceptionally well-suited for this kind of problem. While you could solve this in any language, Lisp's features make the solution particularly elegant and instructive.

Firstly, Lisp treats code as data (a principle called homoiconicity), and its foundational data structure is the list. The problem's input is naturally a list of colors, which maps directly to Lisp's native strengths. Functions like car (first element), cadr (second element), and nth are designed precisely for this type of data access, making list processing feel intuitive and direct.

Secondly, the task requires a mapping structure to associate color strings with numeric values. Common Lisp offers several powerful ways to handle this, primarily through Association Lists (alists) and Hash Tables. This challenge provides a perfect opportunity to compare these two fundamental data structures, understanding their trade-offs in performance, readability, and use cases.

Finally, Lisp's functional programming paradigm encourages building solutions by composing small, pure functions. We can create a function to look up a color's value and another to combine the results. This modular approach leads to code that is easy to test, debug, and understand—a cornerstone of good software engineering.

---

How to Solve It: The Core Logic and Implementation

Let's break down the solution into logical steps. We need to define our data mapping, access the required elements from the input list, look up their values, and combine them to produce the final integer.

Step 1: The Logical Flow

Before writing any code, it's crucial to visualize the process. Our program will follow a clear, linear path from input to output.

    ● Start with a list of color strings
    │
    ▼
  ┌───────────────────────────┐
  │ Extract the first color   │
  │ e.g., (first colors)      │
  └────────────┬──────────────┘
               │
               ▼
  ┌───────────────────────────┐
  │ Extract the second color  │
  │ e.g., (second colors)     │
  └────────────┬──────────────┘
               │
               ▼
  ┌───────────────────────────┐
  │ Look up numeric value for │
  │ the first color           │
  └────────────┬──────────────┘
               │
               ▼
  ┌───────────────────────────┐
  │ Look up numeric value for │
  │ the second color          │
  └────────────┬──────────────┘
               │
               ▼
    ◆ Combine the two digits
   ╱   (e.g., "5" + "6" -> "56")
  ╱
  ▼
  ┌───────────────────────────┐
  │ Convert combined string   │
  │ to an integer (56)        │
  └────────────┬──────────────┘
               │
               ▼
    ● Return the final integer

Step 2: Choosing the Right Data Structure

Our primary task is mapping strings like "brown" to integers like 1. In Common Lisp, the two most common choices are Association Lists and Hash Tables.

• Association List (Alist): An alist is a list of pairs (specifically, cons cells). For our case, it would look like '(("black" . 0) ("brown" . 1) ...). Lookups are done with functions like assoc, which performs a linear scan. It's simple and great for small, static datasets.
• Hash Table: A hash table is a more complex structure that provides fast, near-constant time lookups (amortized O(1)). It's ideal for larger datasets or when performance is a critical concern.

For this problem, the dataset is tiny (only 10 colors), so an alist would be perfectly acceptable. However, using a hash table is often considered better practice for scalability and demonstrates a more modern approach. We'll build our primary solution using a hash table.

Step 3: The Complete Common Lisp Solution

Here is a complete, well-commented solution. We'll define a package, create a hash table for our color mappings, and then write the function to calculate the value.

;;; Defines a package for our solution to avoid symbol clashes.
(defpackage #:resistor-color-duo
  (:use #:cl)
  (:export #:value))

(in-package #:resistor-color-duo)

;;; We define a global parameter to hold our color-to-value mapping.
;;; Using a hash table is efficient for lookups.
(defparameter *color-map*
  (let ((table (make-hash-table :test 'equal)))
    (setf (gethash "black"  table) 0)
    (setf (gethash "brown"  table) 1)
    (setf (gethash "red"    table) 2)
    (setf (gethash "orange" table) 3)
    (setf (gethash "yellow" table) 4)
    (setf (gethash "green"  table) 5)
    (setf (gethash "blue"   table) 6)
    (setf (gethash "violet" table) 7)
    (setf (gethash "grey"   table) 8)
    (setf (gethash "white"  table) 9)
    table)
  "A hash table mapping resistor color strings to their integer values.")

(defun value (colors)
  "Calculates the two-digit value from the first two colors in a list."
  (unless (>= (length colors) 2)
    (error "Input list must contain at least two colors."))

  ;; Extract the first two colors from the input list.
  ;; `first` is an alias for `car`, and `second` is an alias for `cadr`.
  (let ((color1 (first colors))
        (color2 (second colors)))

    ;; Look up the numeric value for each color in our hash table.
    (let ((val1 (gethash color1 *color-map*))
          (val2 (gethash color2 *color-map*)))
      
      ;; Ensure both colors were found in the map.
      (unless (and val1 val2)
        (error "Invalid color found in input list."))

      ;; Combine the two digits into a single integer.
      ;; We use `format` to create a string like "10" from digits 1 and 0.
      ;; Then, `parse-integer` converts this string back into a number.
      (parse-integer (format nil "~d~d" val1 val2)))))

Step 4: Detailed Code Walkthrough

Let's dissect the code to understand every piece.

1. (defpackage #:resistor-color-duo ...)

   This creates a namespace for our code. It prevents our function named value from conflicting with any other function named value in another library. The :export #:value part makes our function accessible to other packages.

2. (defparameter *color-map* ...)

   We define a global variable, or "special variable" in Lisp terminology, to store our mappings. The asterisks (*) around the name are a convention for naming global parameters. Inside the let block, we initialize a new hash table with (make-hash-table :test 'equal). The :test 'equal is crucial because we are using strings as keys, and equal correctly compares string content.

3. (setf (gethash "black" table) 0)

   This is how we populate the hash table. gethash is used to access values, and when combined with setf, it allows us to insert or update key-value pairs.

4. (defun value (colors) ...)

   This defines our main function, which takes one argument: a list named colors.

5. (unless (>= (length colors) 2) ...)

   This is a simple error check. If the input list doesn't have at least two colors, it's impossible to proceed, so we signal an error. This makes our function more robust.

6. (let ((color1 (first colors)) (color2 (second colors))) ...)

   Here, we use let to create local bindings. (first colors) retrieves the first element, and (second colors) retrieves the second. These are more readable aliases for the traditional Lisp functions car and cadr.

7. (let ((val1 (gethash color1 *color-map*)) ...)

   We perform the lookup. (gethash color1 *color-map*) searches for the string key color1 in our hash table and returns the corresponding integer value. If the key is not found, it returns nil.

8. (parse-integer (format nil "~d~d" val1 val2))

   This is the magic of combining the digits. The format function is incredibly powerful in Lisp. Here, format nil "..." means "format a string but return it instead of printing it." The control sequence ~d is a placeholder for a decimal number. So, "~d~d" with inputs 1 and 0 creates the string "10". Finally, parse-integer converts that string into the actual integer 10, which is our final result.

Step 5: Running the Code

You can test this code in any Common Lisp REPL (Read-Eval-Print Loop), such as SBCL (Steel Bank Common Lisp).

First, save the code as resistor-color-duo.lisp. Then start your REPL:

$ sbcl
* (load "resistor-color-duo.lisp")
; Loading file ...
T
* (resistor-color-duo:value '("brown" "black" "red"))
; Evaluation continues.
10
* (resistor-color-duo:value '("green" "violet"))
; Evaluation continues.
57
* (resistor-color-duo:value '("blue" "grey" "orange"))
; Evaluation continues.
68

Notice we have to prefix the function call with the package name, resistor-color-duo:, because we are calling it from the default CL-USER package.

---

When to Choose Different Data Structures: Alist vs. Hash Table

Our primary solution used a hash table for its efficiency. But what if we had used an association list? Let's explore that alternative to understand the trade-offs involved.

Alternative Solution: Using an Association List (Alist)

Here's how the solution would look using an alist. The core logic remains the same, but the data structure and lookup method change.

(defpackage #:resistor-color-duo-alist
  (:use #:cl)
  (:export #:value))

(in-package #:resistor-color-duo-alist)

;;; Using an alist (list of pairs) for the mapping.
;;; The `cons` cells are represented by a dot. ("black" . 0)
(defparameter *color-alist*
  '(("black"  . 0)
    ("brown"  . 1)
    ("red"    . 2)
    ("orange" . 3)
    ("yellow" . 4)
    ("green"  . 5)
    ("blue"   . 6)
    ("violet" . 7)
    ("grey"   . 8)
    ("white"  . 9))
  "An association list mapping color strings to their integer values.")

(defun value (colors)
  "Calculates the two-digit value using an alist for lookups."
  (unless (>= (length colors) 2)
    (error "Input list must contain at least two colors."))

  (let* ((color1-pair (assoc (first colors) *color-alist* :test #'string=))
         (color2-pair (assoc (second colors) *color-alist* :test #'string=))
         (val1 (cdr color1-pair))
         (val2 (cdr color2-pair)))
    
    (unless (and val1 val2)
      (error "Invalid color found in input list."))

    (parse-integer (format nil "~d~d" val1 val2))))

In this version, we use assoc to find the pair corresponding to a color string. assoc returns the entire pair (e.g., ("brown" . 1)), so we then use cdr to extract the value part (the number 1).

Performance and Readability Comparison

Let's compare the two approaches with a clear diagram and table.

    ● Lookup Request: "green"
    │
    ├─────────────────────────────┬───────────────────────────┐
    │      Association List       │        Hash Table         │
    │      (Sequential Scan)      │      (Direct Access)      │
    └──────────────┬──────────────┴──────────────┬────────────┘
                   │                              │
                   ▼                              ▼
          "black"? No. ───┐               Hash("green") ───► Index 5
                   │      │                       │
                   ▼      │                       ▼
          "brown"? No. ───┤               ┌───────────────┐
                   │      │               │ Bucket/Entry  │
                   ▼      │               │ at Index 5    │
          "red"? No. ─────┤               └───────┬───────┘
                   │      │                       │
                   ▼      │                       ▼
          ... (continue scan) ...                 ● Return Value: 5
                   │
                   ▼
          "green"? Yes! ───► ● Return Value: 5

This diagram illustrates the fundamental difference: an alist must check each element one by one until it finds a match, while a hash table uses a hash function to jump directly to the correct location.

Pros & Cons Table

Feature	Association List (Alist)	Hash Table
Lookup Speed	Slow (O(n)). Performance degrades as the list grows.	Fast (Amortized O(1)). Performance is consistent regardless of size.
Syntax	Very simple and literal. Easy to read and write by hand.	Slightly more verbose to initialize programmatically.
Memory Usage	Minimal overhead. It's just a list of cons cells.	Higher overhead due to its internal array structure and hash calculations.
Best Use Case	Small, static datasets where readability is key and performance is not critical (e.g., configuration constants).	Medium to large datasets, or any situation where lookup performance matters (e.g., caches, symbol tables).
Mutability	Can be modified with list operations, but this is often inefficient.	Designed for efficient additions, deletions, and updates.

Verdict: For the Resistor Color Duo problem, both are perfectly fine. However, getting into the habit of using hash tables for key-value mappings is a valuable skill that scales to more complex problems. It's the professionally preferred choice in most scenarios.

---

Where Can This Logic Be Applied? Beyond Resistors

The "lookup and combine" pattern we've implemented is incredibly common in software development. By abstracting the problem, we can see its application in many other domains:

• Configuration Parsers: Reading a config file where keys like "database_host" or "port" map to specific values. The logic is the same: read a key, look up its value.
• Protocol Decoders: In networking, you might receive a byte stream where certain values represent specific commands (e.g., 0x01 = "Login", 0x02 = "Logout"). A program would use a map to translate these byte codes into actions.
• API Response Handling: When you receive JSON from an API, you are essentially working with a hash table. You look up keys like "userName" or "userId" to extract the data you need.
• Game Development: Mapping item IDs to item properties (name, damage, cost) or tile types ('W' for wall, 'G' for grass) to their corresponding graphics and behaviors.
• URL Routing: A web framework maps URL patterns like "/users/:id" to the specific controller function that should handle the request. This is a more advanced form of key-value lookup.

Mastering this simple kodikra module gives you a foundational tool for a vast range of programming tasks. It teaches you to think about data transformation, which is at the heart of most software.

---

Frequently Asked Questions (FAQ)

Why use defpackage? Is it really necessary?

For a small script, it's not strictly necessary. However, it's a critical best practice in Common Lisp. Packages prevent "symbol collision"—imagine if you defined a function called list and it overwrote the built-in list function! Packages create isolated namespaces, making your code modular, reusable, and safe to combine with other libraries.

What is the difference between a string like "black" and a keyword like :black?

A string is an array of characters used for general text data. A keyword is a special type of symbol that is automatically "interned" in the KEYWORD package. This means that no matter how many times you write :black in your code, it refers to the exact same object in memory. They are often used as keys in hash tables or as symbolic names for options because they are efficient to compare. For this problem, strings are used as per the problem specification.

Could I solve this with case or cond instead of a hash table?

Absolutely. You could write a helper function like (defun color-value (color) (case (intern (string-upcase color)) ...)). This would work perfectly for 10 colors. However, this approach is less scalable. If you needed to add 50 more colors, you would have to add 50 more clauses to your case statement. A hash table or alist separates the data (the mappings) from the logic (the lookup), which is generally better design.

How would I handle invalid color inputs more gracefully?

Our solution uses error to stop execution, which is good for debugging. In a real application, you might want to return nil or a specific error condition. You could change the lookup logic to: (let ((val1 (gethash color1 *color-map*))) (unless val1 (return-from value nil)) ...). This would cause the function to exit early and return nil if any color is not found, which the calling code could then handle.

Is format the only way to combine the numbers?

No, you could also use arithmetic. For example: (+ (* val1 10) val2). If val1 is 5 and val2 is 7, this calculates (5 * 10) + 7 = 57. This is often more performant as it avoids the overhead of creating strings. However, the format approach is arguably more readable and directly expresses the idea of "concatenating digits." Both are valid solutions.

What does :test 'equal do in make-hash-table?

The :test argument specifies the function used to compare keys. The default is eql, which checks if two objects are the same object in memory. This works for numbers and symbols but not for strings. Two strings with the same content (e.g., "hello" and "hello") can be different objects. 'equal compares the contents of strings, making it the correct choice when using strings as keys.

---

Conclusion and Next Steps

We have journeyed from a simple electronics puzzle to a deep exploration of fundamental Common Lisp concepts. By solving the Resistor Color Duo problem, you've not only written a functional piece of code but also learned to make critical design decisions, such as choosing between an association list and a hash table. You've seen the power of Lisp's list processing functions and its expressive format facility for string manipulation.

More importantly, you've mastered a pattern—mapping, extraction, and transformation—that forms the backbone of countless applications. This small exercise, part of the kodikra Common Lisp learning path, is a building block that prepares you for more complex challenges in data processing, application development, and beyond.

The Lisp world is vast and rewarding. Continue to practice these concepts, and you'll find its unique approach to problem-solving becoming an invaluable part of your programming toolkit.

Disclaimer: All code in this article is written against modern Common Lisp implementations like SBCL 2.4+ and should be compatible with the ANSI Common Lisp standard. Future language changes may require minor adjustments.

Ready to continue your Lisp adventure? Explore the next module in our Common Lisp roadmap or dive into our complete guide to Common Lisp programming for more in-depth tutorials.

---

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