binary-search helper fn

Author: Oddsor

notebooks/y2024/d18.clj

@@ -105,21 +105,12 @@
 ; Dette løser vi ved å snevre inn søkeområdet basert på om vi finner en gyldig path på
 ; starten, midten og slutten av søkeområdet.
 
-; (*TODO: denne algoritmen trenger litt refaktorering*)
-
 (defn part-2 [dimensions input]
-  (let [num-bytes (alength (.split input "\n"))
-        corrupted-locations (corrupted-locations input)]
+  (let [total-number-of-bytes (alength (.split input "\n"))
+        corrupted-locations (corrupted-locations input)
+        has-valid-path? #(find-path dimensions (set (take % corrupted-locations)))]
     (->> (nth corrupted-locations
-              (loop [[start end] [0 num-bytes]]
-                (let [middle (int (+ (/ (- end start) 2) start))
-                      results (->> [start middle end]
-                                   (map #(some? (find-path dimensions (set (take % corrupted-locations))))))
-                      index-result (zipmap [start middle end] results)]
-                  (if (= 2 (count index-result))
-                    (first (keep (fn [[k v]] (when v k)) index-result))
-                    (recur [(last (filter index-result [start middle end]))
-                            (first (remove index-result [start middle end]))])))))
+              (utils/binary-search has-valid-path? (dec total-number-of-bytes)))
          reverse
          (map str)
          (String/join ","))))

src/advent_of_code_clj/utils.clj

@@ -74,3 +74,28 @@
                      (when next-nodes
                        (.addAll visited next-nodes))
                      (seq next-nodes)))))))
+
+(defn binary-search
+  "Find the first or last value where a predicate is true in a range.
+   
+   Tests the start, middle and end of the value range and narrows down
+   the search space until a value is found"
+  ([pred end]
+   (binary-search pred 0 end))
+  ([pred start end]
+   (let [middle (quot (+ start end) 2)
+         p-start (pred start)
+         p-mid (pred middle)
+         p-end (pred end)]
+     (cond
+       (= p-start p-mid p-end) (throw (ex-info "Could not find a solution: start, middle and end had same equality" {}))
+       (= start middle) (if p-start start end)
+       (and p-mid (not p-end)) (binary-search pred middle end)
+       (and p-start (not p-mid)) (binary-search pred start middle)
+       (and (not p-start) p-mid) (binary-search pred start middle)
+       (and (not p-mid) p-end) (binary-search pred middle end)))))
+
+(defn depth-search [graph-fn start-node]
+  (let [visited (doto (HashSet.) (.add start-node))]
+    (loop [node [start-node]]
+      (let [neighbours (graph-fn node)]))))

test/advent_of_code_clj/utils_test.clj

@@ -0,0 +1,33 @@
+(ns advent-of-code-clj.utils-test
+  (:require
+   [advent-of-code-clj.utils :as utils]
+   [clojure.test :refer [deftest is testing]]))
+
+(deftest binary-search-test
+  (testing "Finds last valid value"
+    (let [numbers (vec (range 0 1000000 19))
+          found-index (utils/binary-search #(> 100006 (numbers %)) 0 (dec (count numbers)))]
+      (is (> (numbers (inc found-index)) 100006 (numbers found-index)))))
+  (testing "Finds first valid value"
+    (let [numbers (vec (range 0 1000000 19))
+          found-index (utils/binary-search #(< 100006 (numbers %)) 0 (dec (count numbers)))]
+      (is (< (numbers (dec found-index)) 100006 (numbers found-index)))))
+  (testing "Inverted greater-than/less-than does not find same value"
+    (let [numbers (vec (range 0 1000000 19))
+          found-index (utils/binary-search #(< 100006 (numbers %)) 0 (dec (count numbers)))
+          found-index-2 (utils/binary-search #(> 100006 (numbers %)) 0 (dec (count numbers)))]
+      (is (not= found-index found-index-2)))
+    (let [numbers (vec (range 0 1000000))
+          middle-value (/ 1000000 2)
+          found-index (utils/binary-search #(<= middle-value (numbers %)) 0 (dec (count numbers)))
+          found-index-2 (utils/binary-search #(> middle-value (numbers %)) 0 (dec (count numbers)))]
+      (is (= 500000 found-index))
+      (is (= 499999 found-index-2))
+      (is (not= found-index found-index-2))))
+  (testing "Throws when no value can be found"
+    (let [numbers (vec (range 0 1000000 19))]
+      (is (thrown? Exception (utils/binary-search #(= 199 (numbers %)) 0 (dec (count numbers))))))
+    (let [numbers (vec (repeat 1000 0))]
+      (is (thrown? Exception (utils/binary-search #(= 0 (numbers %)) 0 (dec (count numbers))))))
+    (let [numbers (vec (concat (range 0 400) (range 1000 0) (range 0 400)))]
+      (is (thrown? Exception (utils/binary-search #(> (numbers %) 500) 0 (dec (count numbers))))))))

test/y2024/d18_test.clj

@@ -0,0 +1,13 @@
+(ns y2024.d18-test
+  (:require
+   [advent-of-code-clj.input :as input]
+   [clojure.test :refer [deftest is]]
+   [y2024.d18 :as sut]))
+
+(deftest part-1-test
+  (is (= 22 (sut/part-1 [6 6] 12 sut/test-input)))
+  (is (= 264 (sut/part-1 [70 70] 1024 (input/get-input 2024 18)))))
+
+(deftest part-2-test
+  (is (= "6,1" (sut/part-2 [6 6] sut/test-input)))
+  (is (= "41,26" (sut/part-2 [70 70] (input/get-input 2024 18)))))