Clojure solutions for Advent of Code 2015 puzzles 3-8

After months of intermittent coding sessions between work and life’s distractions, I’ve finally reached puzzle eight in Advent of Code 2015. While progress has been slow—blame undiagnosed ADHD and the endless cycle of responsibilities—each solution has taught me something new about functional programming in Clojure.

Solving Puzzle 3: Tracking Santa’s Delivery Route

The challenge involved calculating unique coordinates Santa visits based on directional commands. My approach used a direction-to-vector mapping to simplify coordinate updates:

(def moves {\^ [0 1]  ; North
           \v [0 -1] ; South
           \> [1 0]  ; East
           \< [-1 0]}) ; West

The rest was straightforward iteration, incrementing the x and y coordinates based on each move. This pattern—storing transformations as data—made the logic clean and reusable.

Mining Crypto with Puzzle 4: A Brute-Force Approach

The task required finding the smallest positive integer that produces an MD5 hash with a specific number of leading zeros. I leveraged Java interop for hashing:

(java.security.MessageDigest/getInstance "MD5")

The solution looped through integers, checking each hash’s hexadecimal representation. While effective, it was computationally intensive. Parallel processing or byte-array optimizations could improve performance, but for now, patience was key.

String Parsing in Puzzle 5: Identifying "Nice" Words

This puzzle demanded string analysis to classify words as "nice" based on vowel counts, repeated letters, and forbidden substrings. My solution used a straightforward helper function:

defn nice? "Is a word nice?" [word]
  (and (has-three-vowels? word)
       (has-repeated-letter? word)
       (no-forbidden-strings? word)))

The question-mark naming convention in Clojure clearly signals a predicate function, a convention worth adopting in other languages.

Puzzle 6: Controlling a Light Grid

The task involved parsing instructions to toggle lights in rectangular regions of a grid. While the solution was functional, I wondered if anyone had visualized the final pattern—turns out, no such image exists.

Simulating Logic Circuits in Puzzle 7

This puzzle introduced a circuit simulation challenge with inputs like:

123 -> x
456 -> y
x AND y -> d
x OR y -> e

My brute-force method iterated through instructions until all values resolved. A graph-based approach could optimize execution order, but the simplicity of brute force worked for this scale.

String Representation Challenges in Puzzle 8

The final puzzle revisited string parsing, comparing raw and escaped character counts. While tedious, it reinforced the importance of careful string manipulation in functional programming.

Streamlining Input Parsing

Most puzzles relied on text-based inputs, but structured parsing would improve efficiency. For example, Day 2’s cube dimensions could be parsed with:

(parse-input "day02.input" "<int>x<int>x<int>")

This would return ((1 2 3) (1 3 6) ...). A more advanced format could even map keys:

(parse-input "day08.input" "<string:from> to <string:to> = <int:distance>")

This would yield structured data like {:from "London" :to "Dublin" :distance 464}. While custom solutions exist, a standardized library for input parsing in Clojure would be a game-changer.

As I continue, I’ll focus on refining my approach rather than speed. After all, the leaderboard rewards the fastest, not the most persistent.