DEV Community: Andy N

Advent of Code 2015 days 3-8 in Clojure

Andy N — Wed, 27 May 2026 15:42:57 +0000

Yeah, I'm starting to think my initial comment about taking until the heat death of the universe to complete this wasn't far off the mark. I'm not really slow at finishing the tasks, it's just between working , the drudgery of everything else in life and possible undiagnosed ADHD, progress becomes a sporadic thing. Gone forever I think are the late-nighters of chugging caffeinated drinks...

But with that said, I have been slowly chugging away and gotten myself up to the heady heights of puzzle number 8.

I don't think I shall labour over each and every puzzle, instead I'll just gloss over the interesting parts.

Day 03

You're trying to determine how many points are visited if you're given a list of directions (N/S/E/W effectively). One pattern with this sort of thing I like to do is to store the position transformation as a map with the keys being the direction and the values being values to add to x and y coordinates.

(def moves {\^ [0  1]
            \v [0 -1]
            \> [1  0]
            \< [-1 0]})

The rest is just bookkeeping ;D

Day 04

Trying to mine a proprietary cryptocoin. I just used Java interop here - (java.security.MessageDigest/getInstance "MD5"). It is then a matter of looping through numbers to get the required number of leading zeros in the hexadecimal representation of the digest.

This was pretty brute-force and I don't expect to retire from crypto riches any time soon. It's quite slow too - clearly the hashing is going to be but I suspect we could possibly run multiple threads in parallel and/or optimise the way we're creating the byte-array to feed into Java each loop.

As it is, I was content just to wait for it to finish...

Day 05

String parsing really. I'm not a massive fan!

Was nice going back to see part of my original solution looks like this;

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

Pretty legible. I guess you'd write something similar in most languages, but the convention of adding a question mark to tests is a nice touch.

Day 06

Mapping text instructions into turning a series of lights on/off/toggling in a given rectangle. Nothing to write about but I was interested to see if anyone had plotted the result in case there was a picture.

There isn't.

Day 07

Ah, we're getting interesting now, we had to simulate a basic logic circuit. We're given a input like;

123 -> x
456 -> y
x AND y -> d
x OR y -> e
x LSHIFT 2 -> f
y RSHIFT 2 -> g
NOT x -> h
NOT y -> i

I suspect there's a proper way of doing this in which we create a graph of connections and evaluate everything in the proper order. But what I did was just to brute force the whole thing; just keep running through the instructions until every instruction could be executed e.g. if you imagine in the example above that the numbers aren't applied to x and y until the last line, then we couldn't perform most of it until the second loop round the instructions.

Yes, as I edit this, I'm seeing a theme forming here where my solutions are just brute forced.

Day 08

String parsing again :D Trying to count the number of characters in a string and in the final representation. Not much to say again. Slogged through it.

Parser?

So far each problem's input is basic text, but I'd be interested to see if there's a tidy way of specifying the puzzle input. For example Day 2's input looks like;

1x2x3
1x3x6
...
...

So I'm thinking we almost want a function like;


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

;; -> ((1 2 3) (1 3 6) ... ...)

Usually I'd either split or use regex for input, but it seems like what I'd like is to also be able to specify the basic type. Puzzle 8's example;

London to Dublin = 464
London to Belfast = 518
Dublin to Belfast = 141

Would be;

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

;; -> (("London" "Dublin" 464) ...)

Or even better!

(parse-input "day08.input" "<string:from> to <string:to> = <int:distance>")
;; -->
({:from "London" :to "Dublin" :distance 464} ...)

I'd be interested if you know of anything like this feature.

End

I'll carry on with some more problems. I don't think I'll be entering any leaderboards soon ... unless there are some for slowest?

Advent of Code 2015 (day 2)

Andy N — Mon, 26 Feb 2024 16:31:17 +0000

I expect the heat death of the universe before this series is completed :|

Previously

Day 1

Day 2

Part 1

There are no tricks here - we just have to take a list of package dimensions and determine how much wrapping paper we need to wrap each of them according to a formula we're given.

; We're using a regex to get the digits out of our
; dimension property e.g. "1x2x3" -> ["1x2x3" "1" "2" "3"]
(def re #"(\d+)x(\d+)x(\d+)")

(defn dimensions [str]
  (let [match (re-find re str)]
    (if (nil? match) nil
        (->> (rest match)
             (map #(Integer/parseInt %1))
             (sort)))))

(def input (->> (slurp "input")
                (str/split-lines)
                (map dimensions)
                (filter (complement nil?))))

We're defining a variable "input" which is taken from slurping a file with the puzzle input. We then use our dimensions function to turn each text row into a list of 3 numbers: our dimensions.

Half the effort on these early puzzles is just transforming the input into something usable :)

Note the sort in our dimensions function. This means that our resulting dimensions are in the order from smallest to largest. Our puzzle requires us knowing the shortest sides so we know the first two entries in each list are those.

Finally we just filter to remove any items which didn't match.

(defn area [[w h l]]
  (+ (* 2 l w)
     (* 2 w h)
     (* 2 h l)
     (* w h)))

(def part-1-answer (apply + (map area input)))

The answer is just a sum of the areas of each parcel size we're given.

Part 2

The second part required working out how much ribbon was required for each parcel and figuring out the total length of ribbon required.

The solution is pretty much a repeat of the last answer. I defined a new function ribbon-length which took parcel dimensions as an argument. Then it's just mapping it to each input and returning the sum.

Closing Thoughts

This was a straightforward puzzle.
Hooray for destructuring arguments.
I used Babashka for this day. It's definitely faster to startup and the integration with Calva was great.

Advent of Code 2015 in Clojure

Andy N — Fri, 02 Dec 2022 18:20:53 +0000

Yes, you read that right; 2015.

I envy people who have the time to do these things as they happen but life seems to have a habit of getting in the way. I would describe my progress as "glacial".

But anyhoo, I thought I'd try completing each of the 2015 puzzles in Clojure as I'm learning it at present. I won't be marking spoilers as these puzzles are ~7 years old already and I'll likely just talk about solving them at a higher level than a blow by blow...

The Setup

I'm just running VSCode and using the calva plugin so I can just directly run Clojure code within my IDE. There is a deps.edn file which just has a {} in it. Nothing special.

Day One

Part One

Essentially we're given a string of open and close bracket characters as "elevator instructions" where ( means "go up a floor" and ) means "go down". Our first task is simply to take a sequence of these chars and determine which floor our elevator ends up on.

So this is my solution for that first part:


(defn eval-instr [floor instr]
  (+ floor ({\( 1 \) -1} instr)))

(defn eval-elevator [instructions]
  (reduce eval-instr 0 instructions))

(def puzzle-input (slurp "1.input"))

(comment
  (eval-elevator "(()))")
  (eval-elevator puzzle-input)
  )

A few notes:

eval-instr takes a floor and an instruction, returning a new floor. Originally it was part of eval-elevator, but it's a little tidier this way.
I liked doing the floor command mapping using a map. I like often defining these transformations as data.
eval-elevator takes the instruction list and reduces it with the eval-instr to get the final floor number. I always have to look up the order of arguments for reduce :(
puzzle-input is initialised with the contents of the file "1.input", which is our puzzle input. Every language I think should have a slurp command, did you know it can take a URL also?
Finally, I put the tests into a comment tag so they're not evaluated unless I put my cursor over them in calva and press ALT+ENTER. A nice touch.
It occurs to me that we could simply count the number of each bracket chars in our puzzle input to get an answer quicker! However as we see in part 2, it's actually useful to not do that yet. But I would have counted if I'd thought about it at the time!

Part 2

The second part of this puzzle requires us to find the index of the first command to take the elevator below the zeroth floor. So we just want to step through our floors until we get to -1:


(defn find-basement [instr]
  (loop [floor 0
         instr instr
         count 1]
    (let [next-floor (eval-instr floor (first instr))]
      (if (== next-floor -1)
        count
        (recur next-floor (rest instr) (inc count))))))

loop ... recur feels close to writing a loop in another language.

See you in a month when I get round to typing up the second day :|

Edit: Part 2!