AoC Day 3

(ns manhattan.core
  (:require [clojure.set :refer [intersection]]
            [clojure.string :refer [lower-case split split-lines]]))

(def pos
  {:u inc :d dec
   :r inc :l dec})

(defn path-inc [cord [k v]]
  (let [dir (if (contains? #{:u :d} k) 1 0)
        choose #(update % dir (pos k))]
    (take v (rest (iterate choose cord)))))

(defn trace-line [start dirs]
  (let [llast #(last (last %))
        reducer (fn [acc dir]
                  (conj acc (path-inc (llast acc) dir)))]
    (->> dirs
         (reduce reducer [[start]])
         flatten
         (partition 2)
         rest)))

(defn mh-dist [[ax ay] [bx by]]
  (+ (Math/abs (- ax bx))
     (Math/abs (- ay by))))

(defn min-dist [start dists]
  (->> dists
       (map (partial mh-dist start))
       (apply min)))

(defn least-cost [intersections [a-trace b-trace]]
  (->> intersections
       (map (fn [pos]
              (let [cost #(count (take-while (partial not= pos) %))]
                (+ (cost a-trace) (cost b-trace) 2))))
       (apply min)))

(def parse-list
  (partial
   map
   (fn [[d & num]]
     [(keyword (lower-case d))
      (Integer/parseInt (apply str num))])))

(defn parse-input [string]
  (let [[a b] (->> string
                   split-lines
                   (map #(split % #",")))]
    [(parse-list a) (parse-list b)]))

(defn -main []
  (let [data (parse-input
              (slurp "input.txt"))
        [a b] (map (partial trace-line [0 0]) data)
        intsec-points (intersection (set a) (set b))
        dist (min-dist [0 0] intsec-points)]
    (println dist)
    (println (least-cost intsec-points [a b]))))