binary-search -> bisect

Author: Oddsor

deps.edn

@@ -29,7 +29,8 @@
         net.mikera/vectorz-clj {:mvn/version "0.48.0"}
         org.scicloj/clay {:mvn/version "2-beta25"}
         org.scicloj/kindly {:mvn/version "4-beta14"}
-        uncomplicate/fluokitten {:mvn/version "0.10.0"}}
+        uncomplicate/fluokitten {:mvn/version "0.10.0"}
+        metosin/malli {:mvn/version "0.17.0"}}
  :aliases
  {:profiler {:extra-deps {com.clojure-goes-fast/clj-async-profiler {:mvn/version "1.5.1"}}
              :jvm-opts ["-Djdk.attach.allowAttachSelf"]}

input/2022/input1.nippy

@@ -5,7 +5,8 @@
    {:title "Y2022 - Day 1"}}
   (:require [advent-of-code-clj.utils :refer [emap sort- split-newline sum]]
             [clojure.string :as str]
-            [nextjournal.clerk :as clerk]))
+            [nextjournal.clerk :as clerk]
+            [advent-of-code-clj.input :as input]))
 
 ^{::clerk/visibility {:code :hide}}
 (clerk/md "# Advent of code 2022, part 01")
@@ -54,20 +55,18 @@
 (part-1 test-data)
 
 ;; This yields the expected result, so we apply it to our input:
-^{::clerk/visibility {:code :hide}}
-(clerk/code
- '(= 66186 (part-1 (slurp "input/2022/01.txt"))))
+
+(= 66186 (part-1 (input/get-input 2022 1)))
 
 ;; ## Part 2
 ;; > find the amount of calories carried by the "top 3" elves
 
 ^{::clerk/visibility {:result :hide}}
 (defn part-2 [data]
   (->> data parse sorted-calories (take 3) sum))
+
 (part-2 test-data)
 
 ;; Test output looks ok, so let's apply it to the read input
 
-^{::clerk/visibility {:code :hide}}
-(clerk/code
- '(= 196804 (part-2 (slurp "input/2022/01.txt"))))
+(= 196804 (part-2 (input/get-input 2022 1)))

notebooks/y2022/d01.clj

@@ -110,7 +110,7 @@
         corrupted-locations (corrupted-locations input)
         has-valid-path? #(find-path dimensions (set (take % corrupted-locations)))]
     (->> (nth corrupted-locations
-              (utils/binary-search has-valid-path? (dec total-number-of-bytes)))
+              (utils/bisect has-valid-path? (dec total-number-of-bytes)))
          reverse
          (map str)
          (String/join ","))))

notebooks/y2024/d18.clj

@@ -1,25 +1,30 @@
 (ns advent-of-code-clj.utils
-  (:require [clojure.string :as str])
   (:import [java.util HashSet]))
 
-(defn coord-map [xs-of-xses]
+(defn coord-map
+  {:malli/schema [:-> [:sequential [:sequential :any]] [:map-of [:tuple :int :int] :any]]}
+  [xs-of-xses]
   (->> xs-of-xses
        (map-indexed (fn [idy xs]
                       (map-indexed (fn [idx v]
                                      [[idx idy] v])
                                    xs)))
        (transduce cat merge)))
 
-(defn coord-map-fixed [xs-of-xses]
+(defn coord-map-fixed
+  {:malli/schema [:-> [:sequential [:sequential :any]] [:map-of [:tuple :int :int] :any]]}
+  [xs-of-xses]
   (->> xs-of-xses
        (map-indexed (fn [idy xs]
                       (map-indexed (fn [idx v]
                                      [[idy idx] v])
                                    xs)))
        (transduce cat merge)))
 
-(defn text->matrix [text]
-  (mapv vec (str/split-lines text)))
+(defn text->matrix
+  {:malli/schema [:-> :string [:vector [:vector char?]]]}
+  [text]
+  (mapv vec (.split text "\n")))
 
 (defn adjacent-hv
   "Find adjacent coordinates, without diagonals"
@@ -40,7 +45,7 @@
    [(dec x) (inc y)] [x (inc y)] [(inc x) (inc y)]])
 
 (defn split-newline [text]
-  (str/split text #"\n\n"))
+  (.split text "\n\n"))
 
 (defn emap [fun xs]
   (if (coll? xs)
@@ -75,13 +80,14 @@
                        (.addAll visited next-nodes))
                      (seq next-nodes)))))))
 
-(defn binary-search
+(defn bisect
   "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"
+  {:malli/schema [:-> ifn? :int [:* :int] :int]}
   ([pred end]
-   (binary-search pred 0 end))
+   (bisect pred 0 end))
   ([pred start end]
    (let [middle (quot (+ start end) 2)
          p-start (pred start)
@@ -90,10 +96,10 @@
      (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)))))
+       (and p-mid (not p-end)) (bisect pred middle end)
+       (and p-start (not p-mid)) (bisect pred start middle)
+       (and (not p-start) p-mid) (bisect pred start middle)
+       (and (not p-mid) p-end) (bisect pred middle end)))))
 
 (defn depth-search [graph-fn start-node]
   (let [visited (doto (HashSet.) (.add start-node))]

src/advent_of_code_clj/utils.clj

@@ -1,33 +1,36 @@
 (ns advent-of-code-clj.utils-test
   (:require
+   [aoc.test-utils :as tu]
    [advent-of-code-clj.utils :as utils]
-   [clojure.test :refer [deftest is testing]]))
+   [clojure.test :refer [deftest is testing use-fixtures]]))
 
-(deftest binary-search-test
+(use-fixtures :once tu/with-instrumentation)
+
+(deftest bisect-test
   (testing "Finds last valid value"
     (let [numbers (vec (range 0 1000000 19))
-          found-index (utils/binary-search #(> 100006 (numbers %)) 0 (dec (count numbers)))]
+          found-index (utils/bisect #(> 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)))]
+          found-index (utils/bisect #(< 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)))]
+          found-index (utils/bisect #(< 100006 (numbers %)) 0 (dec (count numbers)))
+          found-index-2 (utils/bisect #(> 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)))]
+          found-index (utils/bisect #(<= middle-value (numbers %)) 0 (dec (count numbers)))
+          found-index-2 (utils/bisect #(> 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))))))
+      (is (thrown? Exception (utils/bisect #(= 199 (numbers %)) 0 (dec (count numbers))))))
     (let [numbers (vec (repeat 1000 0))]
-      (is (thrown? Exception (utils/binary-search #(= 0 (numbers %)) 0 (dec (count numbers))))))
+      (is (thrown? Exception (utils/bisect #(= 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))))))))
+      (is (thrown? Exception (utils/bisect #(> (numbers %) 500) 0 (dec (count numbers))))))))

test/advent_of_code_clj/utils_test.clj

@@ -0,0 +1,7 @@
+(ns aoc.test-utils
+  (:require [malli.dev :as md]))
+
+(defn with-instrumentation [f]
+  (md/start!)
+  (f)
+  (md/stop!))

test/aoc/test_utils.clj

@@ -11,8 +11,9 @@
  :kaocha.plugin.randomize/seed 156086537,
  :kaocha.plugin.randomize/randomize? true,
  :kaocha/plugins
- [:kaocha.plugin/randomize
-  :kaocha.plugin/filter
-  :kaocha.plugin/capture-output],
- :kaocha.plugin.capture-output/capture-output? true,
+ [:randomize
+  :filter
+  :capture-output
+  :profiling],
+ :kaocha.plugin.capture-output/capture-output? true
  :kaocha/reporter [kaocha.report/dots]}