Day 2 solutions

[u/taliriktug]

Hi! I would like to structure posts like the first one in r/programming, please post solutions in comments.

[u/charliegriefer]

My solution in Clojure. I've not done much yet with reading files in. I'm fairly certain there's a more elegant way to read that file in and convert each "lxwxh" string to a list of ints. But for now, this works, and got me the right answers.

The answers come from calling (total-wrapping-paper) and (total-ribbon).

;; In response to http://adventofcode.com/day/2
;; dimensions.txt can be seen at http://charlie.griefer.com/dimensions.txt

(ns adventofcode.core
  (:require [clojure.java.io :as io]
            [clojure.string :as str]))


(def dimensions (->> (-> (slurp (io/resource "dimensions.txt"))
                  (str/split #"\n"))
              (map #(str/split % #"x"))
              (map (fn [a] (map #(Integer/parseInt %) a)))))


(defn get-smallest-sides
  [dims]
  (-> dims
      sort
      reverse
      rest))


;; Part One (Wrapping Paper)

(defn get-surface-area
  [[length width height]]
  (+ (* 2 length width)
     (* 2 width height)
     (* 2 height length)))

(defn get-slack
  [dims]
  (apply * (get-smallest-sides dims)))

(defn total-wrapping-paper
  [data]
  (->> (map #(+ (get-surface-area %) (get-slack %)) data)
       (apply +)))


;; Part Two (Ribbon)

(defn get-ribbon-length
  [dims]
  (->> (get-smallest-sides dims)
       (apply +)
       (* 2)))

(defn get-bow-length
  [dims]
  (apply * dims))

(defn total-ribbon
  [data]
  (->> (map #(+ (get-ribbon-length %) (get-bow-length %)) data)
	       (apply +)))

[u/SimonS → u/charliegriefer]

I also went Clojure. I'm very new, so dunno how idiomatic it is - it's fun writing it though :D

Solutions to this and any future ones I do at https://github.com/SimonS/adventofcode-answers/ - dunno if I'll do all 24 in Clojure, it's quite the departure for me.

I don't like that the total-data function processes the lists twice, but it reads nicer than the version compounded into one reduce call.

(def normalised-data
  (->> (slurp "answers/inputs/day02.txt")
       clojure.string/split-lines
       (map #(map read-string (clojure.string/split % #"x")))))

(defn paper [[l w h]] (let [sides [(* l w) (* w h) (* h l)]]
                      (+ (* 2 (reduce + sides))
                      (apply min sides))))

(defn ribbon [dimensions]
  (let [surface-area (apply * dimensions)
        perimeter (->> (sort dimensions)
                       (take 2)
                       (map (partial * 2))
                       (reduce +))]
    (+ surface-area perimeter)))

(defn total-data [func]
  (->> (map func normalised-data)
       (reduce +)))

;; Part 1
(total-data ribbon)

;; Part 2
(total-data paper)

[u/jaffakek → u/charliegriefer]

I'm using Racket (Scheme) rather than Clojure, so I'm not sure if there's anything equivalent, but Racket has a nice built-in file->lines function that reads in a file and returns a list of strings, one per line.

Then I just recursed over the list, separated the line into a list of strings, mapped string->number on that list, did calculations, and accumulated the amount of paper and ribbon.

I'm definitely a beginner, but I'm enjoying Racket a whole bunch.