Factor out A* implementation

[adventofcode2019.git] / src / adventofcode2019 / lib.clj

(ns adventofcode2019.lib
  [:require [clojure.string :as str]
   [clojure.edn :as edn]
   [clojure.java.io :as io]
   [clojure.java.shell :refer [sh]]
   [clojure.data.priority-map :refer [priority-map-by]]])

(defn get-list-from-file
  ([file-name]
   (str/split-lines (str/trim (slurp file-name))))
  ([file-name split-regex]
   (str/split (str/trim (slurp file-name)) split-regex)))

(defn parse-int [n]
  (let [n-val (edn/read-string n)]
    (if (number? n-val)
      n-val
      (throw (Exception. "Not a number!")))))

(defmacro input-file []
  (let [bottom-ns (last (str/split (str *ns*) #"\."))]
    (str "resources/" bottom-ns)))

(defn manhattan-distance [[ax ay] [bx by]]
  (+ (Math/abs (- ax bx))
     (Math/abs (- ay by))))

(defn a-star
  "succ :: state -> [state]
  cost :: cost -> state -> cost
  heur :: state -> cost
  init :: state
  des? :: state -> bool"
  [succ cost heur init des?]
  (let [update-openl (fn [ol sn pt cs]
                       (reduce (fn [o p]
                                 (assoc o p [(cost cs p) (heur p)]))
                               ol (remove sn (succ pt))))
        openl (priority-map-by (fn [[ag ah] [bg bh]]
                                 (let [cmp (compare (+ ag ah) (+ bg bh))
                                       cmp-g (compare ag bg)
                                       cmp-h (compare ah bh)]
                                   (if-not (zero? cmp)
                                     cmp
                                     (if-not (zero? cmp-g)
                                       cmp-g
                                       cmp-h)))))]
    (loop [openl (assoc openl init [0 (heur init)])
           seen #{init}]
      (let [[point [dist _]] (peek openl)]
        (cond
          (empty? openl) [nil ##Inf]
          (des? point) [point dist]
          :else (let [openl (update-openl (pop openl) seen point dist)
                      seen (apply conj seen (keys openl))]
                  (recur openl seen)))))))

(defn mmap [f m]
  (zipmap (keys m) (map f (vals m))))

(def part1
  #(println (str "Part 1: " %)))
(def part2
  #(println (str "Part 2: " %)))

;; FIXME: this is still broken but i give up for now
; (defn --input-file [for-ns]
;   (let [bottom-ns (last (str/split for-ns #"\."))
;         input-url "https://adventofcode.com/2019/day/%d/input"
;         day-url (->> bottom-ns
;                      (drop 3)
;                      (str/join)
;                      (parse-int)
;                      (format input-url))
;         token (str/trim (slurp (io/resource "token")))
;         res-dir (-> (io/resource "token") 
;                     (.getPath)
;                     (str/replace "token" bottom-ns))
;         cmd ["curl" "-s" "-b" 
;              (format "\"session=%s\"" token) 
;              day-url ">" res-dir]]
;     (if-let [input (io/resource bottom-ns)]
;             input
;             (do (apply sh cmd) nil))))

; (defmacro input-file []
;   (--input-file (str *ns*)))