Cleanup gamle notebooks

Author: Oddsor

notebooks/y2022/d01.clj

@@ -8,12 +8,12 @@
             [nextjournal.clerk :as clerk]
             [advent-of-code-clj.input :as input]))
 
-^{::clerk/visibility {:code :hide}}
-(clerk/md "# Advent of code 2022, part 01")
+
+; # Advent of code 2022, part 01
 
 ; Create a parser to convert the following test-data into lists:
 
-^{::clerk/visibility {:code :hide}} (def test-data "1000
+^{:nextjournal.clerk/visibility {:code :hide}} (def test-data "1000
 2000
 3000
 
@@ -28,28 +28,28 @@
 
 10000")
 
-{::clerk/visibility {:code :show :result :hide}}
+{:nextjournal.clerk/visibility {:code :show :result :hide}}
 
 (defn- parse [text]
   (->> text split-newline (map str/split-lines) (emap parse-long)))
 
-^{::clerk/visibility {:code :hide :result :show}}
+^{:nextjournal.clerk/visibility {:code :hide :result :show}}
 (clerk/example
  (parse test-data))
 
-{::clerk/visibility {:code :show :result :show}}
+{:nextjournal.clerk/visibility {:code :show :result :show}}
 
 ;; ## Part 1
 ;; > find the maximum calories carried by one elf
 
 ;; Could use "(apply max ...)" instead of sorting, but part 2
 ;; needs the maximum 3 calorie counts, so a sorted list is more useful
 
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (defn sorted-calories [data]
   (->> data (map sum) sort-))
 
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (defn part-1 [data]
   (->> data parse sorted-calories first))
 (part-1 test-data)
@@ -61,7 +61,7 @@
 ;; ## Part 2
 ;; > find the amount of calories carried by the "top 3" elves
 
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (defn part-2 [data]
   (->> data parse sorted-calories (take 3) sum))
 

notebooks/y2022/d02.clj

@@ -21,19 +21,19 @@
                :rock :scissors})
 (def wins-to (set/map-invert loses-to))
 
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (defn decide-outcome [{:keys [player opponent]}]
   (cond
     (= player opponent) :draw
     (= opponent (wins-to player)) :opponent-wins
     (= opponent (loses-to player)) :player-wins))
 
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (defn calculate-score [{:keys [player] :as game}]
   (+ (outcome-points (decide-outcome game))
      (hand-points player)))
 
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (defn part-1 [data]
   (letfn [(calculate [line]
             (calculate-score
@@ -45,14 +45,14 @@
 (def desired-outcome {\X :lose
                       \Y :draw
                       \Z :win})
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (defn decide-hand [opponent desired-outcome]
   (case desired-outcome
     :draw opponent
     :win (wins-to opponent)
     :lose (loses-to opponent)))
 
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (defn part-2 [data]
   (letfn [(calculate [line]
             (let [opponent-hand (opponent-strategy (first line))]
@@ -62,7 +62,7 @@
     (transduce (map (comp calculate)) +
                (str/split-lines data))))
 
-^{::clerk/visibility {:code :hide}}
+^{:nextjournal.clerk/visibility {:code :hide}}
 (clerk/code '(= 11767 (part-1 (slurp "input/2022/02.txt"))))
-^{::clerk/visibility {:code :hide}}
-(clerk/code '(= 13886 (part-2 (slurp "input/2022/02.txt"))))
+^{:nextjournal.clerk/visibility {:code :hide}}
+(clerk/code '(= 13886 (part-2 (slurp "input/2022/02.txt"))))

notebooks/y2022/d16.clj

@@ -16,7 +16,7 @@
 
 ;; > For example, suppose you had the following scan output:
 
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (def test-data "Valve AA has flow rate=0; tunnels lead to valves DD, II, BB
 Valve BB has flow rate=13; tunnels lead to valves CC, AA
 Valve CC has flow rate=2; tunnels lead to valves DD, BB
@@ -36,10 +36,10 @@ Valve JJ has flow rate=21; tunnel leads to valve II")
 
 ;; Start by parsing the test-data into a map where each valve is a key, and the value is a map listing the pressure and neighbouring nodes:
 
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (require '[clojure.string :as str])
 
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (defn parse [data]
   (->> data
        str/split-lines
@@ -55,15 +55,15 @@ Valve JJ has flow rate=21; tunnel leads to valve II")
                         :pressure pressure}])))
        (into {})))
 
-^{::clerk/visibility {:code :hide}}
+^{:nextjournal.clerk/visibility {:code :hide}}
 (clerk/example
  (parse test-data))
 
 ;; To find the shortest path we'll use the excellent Ubergraph library:
 
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (require '[ubergraph.alg :as ua])
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (defn shortest-path [start-pos end-pos data]
   (ua/shortest-path (fn [coord]
                       (map (fn [neighbour] {:dest neighbour}) (-> data coord :next)))
@@ -73,7 +73,7 @@ Valve JJ has flow rate=21; tunnel leads to valve II")
 ;; Once refactored and shrunk down, this function ended up being almost
 ;; a copy-paste of [@volesen's solution](https://github.com/volesen/aoc2022/blob/main/day16/day16.clj#L48C10-L48C10)
 
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (defn max-pressure [time-remaining start non-zero-valves elephant? data]
   (let [next-nodes* (keep (fn [node]
                             (let [time-to-open (inc (:cost (shortest-path start node data)))]
@@ -89,31 +89,31 @@ Valve JJ has flow rate=21; tunnel leads to valve II")
                      elephant? (conj (max-pressure 26 :AA non-zero-valves false data)))]
     (+ (* time-remaining (-> data start :pressure)) (apply max 0 next-nodes))))
 
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (defn part-1 [data]
   (with-redefs [shortest-path (memoize shortest-path)]
     (let [data (parse data)
           non-zero-valves (set (remove (fn [valve] (zero? (:pressure (valve data)))) (keys data)))]
       (max-pressure 30 :AA non-zero-valves false data))))
 
-^{::clerk/visibility {:code :hide}}
+^{:nextjournal.clerk/visibility {:code :hide}}
 (clerk/example (= 1651 (part-1 test-data)))
 
 ;; Applying it to our input we get:
-^{::clerk/visibility {:code :hide}}
+^{:nextjournal.clerk/visibility {:code :hide}}
 (clerk/code
  '(= 1896 (part-1 (slurp "input/2022/16.txt"))))
 
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (defn part-2 [data-string]
   (with-redefs [shortest-path (memoize shortest-path)]
     (let [data (parse data-string)
           non-zero-valves (set (remove (fn [valve] (zero? (:pressure (valve data)))) (keys data)))]
       (max-pressure 26 :AA non-zero-valves true data))))
-^{::clerk/visibility {:code :hide}}
+^{:nextjournal.clerk/visibility {:code :hide}}
 (clerk/example (= 1707 (part-2 test-data)))
 
 ;; Applying it to our input we get:
-^{::clerk/visibility {:code :hide}}
+^{:nextjournal.clerk/visibility {:code :hide}}
 (clerk/code
  '(= 2576 (part-2 (slurp "input/2022/16.txt"))))

notebooks/y2022/d18.clj

@@ -4,7 +4,7 @@
 
 ;; # Year 2022 - Day 18
 
-^{::clerk/visibility {:result :hide}}
+^{:nextjournal.clerk/visibility {:result :hide}}
 (def test-data "2,2,2
 1,2,2
 3,2,2
@@ -19,7 +19,7 @@
 2,1,5
 2,3,5")
 
-{::clerk/visibility {:result :hide}}
+{:nextjournal.clerk/visibility {:result :hide}}
 
 (require '[advent-of-code-clj.utils :as u]
          '[clojure.core.matrix :as mx]
@@ -43,9 +43,9 @@
        ;; For every immediate neighbour we lose two sides
        (* (count (neighbours points)) 2))))
 
-{::clerk/visibility {:result :show}}
+{:nextjournal.clerk/visibility {:result :show}}
 
-^{::clerk/visibility {:code :hide}}
+^{:nextjournal.clerk/visibility {:code :hide}}
 (clerk/example
  (= 64 (part-1 test-data)))
 
@@ -54,7 +54,7 @@
 (clerk/code
  '(= 4302 (part-1 (slurp "input/2022/18.txt"))))
 
-{::clerk/visibility {:result :hide}}
+{:nextjournal.clerk/visibility {:result :hide}}
 
 (defn adjacents [[x y z]]
   (set (u/adjacent-hv x y z)))
@@ -106,9 +106,9 @@
            ;; For every immediate neighbour we lose two sides
        (* (count (neighbours diff)) 2))))
 
-{::clerk/visibility {:result :show}}
+{:nextjournal.clerk/visibility {:result :show}}
 
-{::clerk/visibility {:code :hide}}
+{:nextjournal.clerk/visibility {:code :hide}}
 (clerk/example
  (= 58 (part-2 test-data)))
 

notebooks/y2022/d22.clj

@@ -75,7 +75,7 @@
 ;; We use the parsed map to find the starting position:
 
 ^{:nextjournal.clerk/visibility {:result :hide}}
-(defn find-starting-position [{:keys [open-spaces] :as map-coords}]
+(defn find-starting-position [{:keys [open-spaces] :as _map-coords}]
   {:coord (->> open-spaces
                (filter (fn [[x y]] (zero? y)))
                (sort-by first)
@@ -347,4 +347,4 @@
         starting-position (find-starting-position map-coords)]
     (->> (reduce (partial make-move (partial update-position-cube manual-quadrant-mapping-input) map-coords) starting-position movements)
          calculate
-         (= 195032))))
+         (= 195032))))