Wait, I here you say “This guy writing there, didn’t he write about not having time and energy for site projects?”:
Well, yes, sadly that’s the case and I did cancel a couple of things for good (BTW, I am looking for someone kind to take over the leadership of Aachens Java User Group EuregJUG, maybe there will be a time again for meetings).
On the other hand, I try not to go completely nuts and the last couple of weeks have not made this easy. It’s grey, cold (which I don’t even mind), but wet, wet, wet, muddy, muddy and then some: Running and especially cycling is a bit hard. Normally that would keep me on the track.
Instead, I started puzzle on Advent of Code again. I have a dedicated repository for my solutions, find it at michael-simons/aoc. Why more coding?
What I really like about the puzzles is the fact that they absolutely have nothing todo with frameworks, annotations, microservices, DDD platforms, build systems or moving JSON between endpoints. Just plain, logical puzzles to tinker with. A bit like doing a crossword thing each day.
In my repository, I tackled every puzzle with what’s available in a language, no libraries. Setup in a way that someone who want’s to run needs only to install one thing, the language. The repository contains Java (of course), Kotlin, Rust, Ruby, Go, SQL, Cypher, PHP, Scala, Typescript and some other things. I guess I managed to be more idiomatic in some languages than others, though. In most of the puzzles you’ll realize that you need various ideas, mathematical concepts, algorithms again and again. It’s helpful to compare how easy or hard is to implement those in various languages.
Up until this week I did run some circles around languages like Clojure or Lisp in general or things like Haskell. I find them intimidating at first sight and I don’t have a university background with knowledge about their theoretical concepts.
I started to read up on Clojure a bit and while I do not yet understand everything, I was able to create the following script
(def input (clojure.string/trim-newline (slurp "input.txt")))
(def freq (frequencies input))
(def starOne
(- (get freq \() (get freq \))))
(println starOne)
(def starTwo
(count
(take-while (fn [p] (not= p -1))
(reductions (fn [sum num] (+ sum num)) 0 (map {\( 1 \) -1} input)))))
(println starTwo) |
(def input (clojure.string/trim-newline (slurp "input.txt")))
(def freq (frequencies input))
(def starOne
(- (get freq \() (get freq \))))
(println starOne)
(def starTwo
(count
(take-while (fn [p] (not= p -1))
(reductions (fn [sum num] (+ sum num)) 0 (map {\( 1 \) -1} input)))))
(println starTwo)
It reads an input file into memory and uses the frequencies function to compute the frequencies of different characters in it. It assigns the difference of occurrences of `(` and `)` to the a variable named starOne and prints it.
The second part counts the number of iterations needed to map all opening brackets to 1 and closing brackets to -1 and summing them up (in several reductions) until one of them hits -1.
Many important things are already in there: Reading files, working with maps and lists, applying functions to every item in a list, calling functions and defining anonymous functions. I can work with that.
Fast forward a couple of days, having a look at I Was Told There Would Be No Math. Well, the math is actual super simple in that. Read a file with lines like 2x3x4. They give you the dimension of a parcel (length, width, height).
Compute according to some rules paper and ribbon needed to wrap those parcels or presents. Paper area is given by “find the surface area of the box, which is 2*l*w + 2*w*h + 2*h*l. The elves also need a little extra paper for each present: the area of the smallest side.”
The good object oriented person and the happy Java 15 user with preview feature I am I started to create a record to model that thing:
record Present(int l, int w, int h) {
int surfaceArea() {
return 2 * (l * w + w * h + h * l);
}
int slack() {
return Math.min(l * w, Math.min(w * h, h * l));
}
int volume() {
return l * w * h;
}
} |
record Present(int l, int w, int h) {
int surfaceArea() {
return 2 * (l * w + w * h + h * l);
}
int slack() {
return Math.min(l * w, Math.min(w * h, h * l));
}
int volume() {
return l * w * h;
}
}
I mean, basic math, right? Solution to the first question is just summing surface area and slack up like var starOne = presents.stream().mapToInt(p -> p.surfaceArea() + p.slack()).sum();. Easy, right?
Always thinking in objects primes you to things. Here to length, width, height. I should have realized what I am doing when I computed the smallest area (computed 3 areas and chose the smallest one): It doesn’t matter which value is assigned to length, width and height: I can just sort them, take the two smallest and multiple them. I realized that when I computed the smallest perimeter of the parcel:
int smallestPerimeter() {
return Stream.of(l, w, h).sorted().limit(2).mapToInt(v -> 2 * v).sum();
} |
int smallestPerimeter() {
return Stream.of(l, w, h).sorted().limit(2).mapToInt(v -> 2 * v).sum();
}
Enter the Clojure solution. It felt very clumsy to define a type just for that.
Here’s what I came up with instead
(use '[clojure.string :only (trim-newline split-lines split)])
(def input
"I use again slurp to read the file and two library functions
to trim the newlines and split the whole thing into a list.
An anonymous function is used on each line to split line by
the letter `x` and map the values to an int. Those ints are than
sorted and the variable `input` will be a lazy list of int arrays."
(map (fn [v] (sort (map bigint (split v #"x"))))
(split-lines (trim-newline (slurp "input.txt")))))
(defn paper
"As I know that the array is sorted, I can deconstruct it into the
3 values contained. The riddle for the paper is that the smallest area
is in there 3 and not 2 times. As the smallest area is defined by the first
two elements, we multiple them 3 instead of 2 times like the rest."
[dimensions]
(let [[l w h] dimensions]
(+ (* 3 l w) (* 2 l h) (* 2 w h))))
(defn ribbon
"Same idea as above: The smallest perimeter is defined by the 2 smallest values.
The volume is of course the product of all 3."
[dimensions]
(let [[l w h] dimensions]
(+ (* 2 l) (* 2 w) (* l w h))))
(println (reduce + (map paper input)))
(println (reduce + (map ribbon input))) |
(use '[clojure.string :only (trim-newline split-lines split)])
(def input
"I use again slurp to read the file and two library functions
to trim the newlines and split the whole thing into a list.
An anonymous function is used on each line to split line by
the letter `x` and map the values to an int. Those ints are than
sorted and the variable `input` will be a lazy list of int arrays."
(map (fn [v] (sort (map bigint (split v #"x"))))
(split-lines (trim-newline (slurp "input.txt")))))
(defn paper
"As I know that the array is sorted, I can deconstruct it into the
3 values contained. The riddle for the paper is that the smallest area
is in there 3 and not 2 times. As the smallest area is defined by the first
two elements, we multiple them 3 instead of 2 times like the rest."
[dimensions]
(let [[l w h] dimensions]
(+ (* 3 l w) (* 2 l h) (* 2 w h))))
(defn ribbon
"Same idea as above: The smallest perimeter is defined by the 2 smallest values.
The volume is of course the product of all 3."
[dimensions]
(let [[l w h] dimensions]
(+ (* 2 l) (* 2 w) (* l w h))))
(println (reduce + (map paper input)))
(println (reduce + (map ribbon input)))
Find my prose inside the program.
I do like the approach not using to many data structures.
In the end: It is good to have a look outside the box sometimes and reset your brain with fresh ideas.
Thanks to Tim, Stefan and Jan for the multiple times in which you brought Clojure into my bubble.
Title picture by Bannon Morrissy on Unsplash
Filed in English posts
|
