ajet/advent-of-code
1
0
Fork 0
mirror of https://github.com/Ajetski/advent-of-code.git synced 2025-09-30 13:03:19 -09:00
Code Issues Packages Projects Releases Wiki Activity

fix memoiation

Browse Source
This commit is contained in:
Adam Jeniski 2023-12-15 15:29:56 -05:00
parent adfc073ed1
commit a87daecd7d
1 changed files with 52 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
2023/src/day13.clj
View File

@ -34,45 +34,38 @@
(filter (fn [[[row]]] (= r row))) (filter (fn [[[row]]] (= r row)))
(map second))) (map second)))
(defn get-refl-value [m num-rows num-cols & [discriminator]] (defn get-refl-value [m num-rows num-cols]
(let [rows (range 0 num-rows) (let [rows (range 0 num-rows)
cols (range 0 num-cols)] cols (range 0 num-cols)]
(when discriminator (apply
(println discriminator)) concat
(or (->> cols (filter
(map #(for [c (range (min (inc %) (- (dec num-cols) %)))] not-empty
[(- % c) (inc (+ % c))])) (list (->>
(filter not-empty) rows
(filter #(or (not= (second discriminator) :row)
(not= (first discriminator) %)))
(map (partial map (fn [[a b]]
; (println a b :col discriminator)
(= (get-col m a)
(get-col m b)))))
(map-indexed vector)
(filter (comp (partial every? identity)
second))
(filter second)
first
(#(when %
[(inc (first %)) :col])))
(->> rows
(map #(for [r (range (min (inc %) (- (dec num-rows) %)))] (map #(for [r (range (min (inc %) (- (dec num-rows) %)))]
[(- % r) (inc (+ % r))])) [(- % r) (inc (+ % r))]))
(filter not-empty) (filter not-empty)
(filter #(or (not= (second discriminator) :row)
(not= (first discriminator) %)))
(map (partial map (fn [[a b]] (map (partial map (fn [[a b]]
; (println a b :row discriminator)
(= (get-row m a) (= (get-row m a)
(get-row m b))))) (get-row m b)))))
(map-indexed vector) (map-indexed vector)
(filter (comp (partial every? identity) (filter (comp (partial every? identity)
second)) second))
(filter second) (filter second)
first (map #(vector (inc (first %)) :row)))
(#(when % (->> cols
[(inc (first %)) :row])))))) (map #(for [c (range (min (inc %) (- (dec num-cols) %)))]
[(- % c) (inc (+ % c))]))
(filter not-empty)
(map (partial map (fn [[a b]]
(= (get-col m a)
(get-col m b)))))
(map-indexed vector)
(filter (comp (partial every? identity)
second))
(filter second)
(map #(vector (inc (first %)) :col))))))))
(defn gen-map [input] (defn gen-map [input]
(->> input (->> input
@ -87,31 +80,41 @@
(map #(get-refl-value (gen-map %) (map #(get-refl-value (gen-map %)
(count %) (count %)
(count (first %)))) (count (first %))))
(map first)
(map #(update % 1 (fn [x] (condp = x
:col 1
:row 100))))
(map (partial apply *))
(reduce +)
)
(defn print-board [m num-rows num-cols]
(println)
(doseq [row (range num-rows)]
(doseq [col (range num-cols)]
(print (m [row col])))
(println)))
;; part 2
(->> input
(mapv
#(let [num-rows (count %)
num-cols (count (first %))
m (gen-map %)
smudge (first (get-refl-value m num-rows num-cols))]
(->> (for [r (range num-rows)
c (range num-cols)]
(->> (get-refl-value
(update m [r c] (fn [c] (if (= c \#) \. \#)))
num-rows
num-cols)
(filter (partial not= smudge))))
(filter not-empty)
(apply concat))))
(map first)
(map #(update % 1 (fn [x] (condp = x (map #(update % 1 (fn [x] (condp = x
:col 1 :col 1
:row 100)))) :row 100))))
(map (partial apply *)) (map (partial apply *))
(reduce +)) (reduce +))
;; part 2
(->> sample-input
(mapv #(let [num-rows (count %)
num-cols (count (first %))
m (gen-map %)
smudge (get-refl-value m num-rows num-cols)]
(->>
(for [r (range num-rows)
c (range num-cols)]
(let [m-prime (update m [r c] (fn [c] (if (= c \#) \. \#)))
res (get-refl-value m-prime num-rows num-cols smudge)]
res))
(filter identity)
first)))
; (map get-refl-value)
; (map #(update % 1 (fn [x] (condp = x
; :col 1
; :row 100))))
; (map (partial apply *))
; (reduce +)
)