]> code.bitgloo.com Git - clyne/advent-of-code.git/commitdiff
day18: simplify part 2 'for'
authorClyne Sullivan <clyne@bitgloo.com>
Sat, 18 Dec 2021 23:07:21 +0000 (18:07 -0500)
committerClyne Sullivan <clyne@bitgloo.com>
Sat, 18 Dec 2021 23:07:21 +0000 (18:07 -0500)
day17/partboth.clj
day18/partboth.clj

index 91b005c01c0aaf188b9fb5c74fab8e214c4ccc17..c585bf95c64ec0895b4757c30d4326df5679fbb5 100644 (file)
@@ -1,5 +1,8 @@
-(def target-area [[169 -68] [206 -108]])
-;(def target-area [[20 -5] [30 -10]])
+(require '[clojure.core.reducers :as r])
+
+;(def target-area [[169 -68] [206 -108]])
+(def target-area [[20000 -5000] [30000 -10000]])
+;(def target-area [[2000 -500] [3000 -1000]])
 (def initial-pos [0 0])
 
 (defn beyond-target? [[[tbx tby] [tex tey]] [x y]]
 (defn apply-velocity [[[px py] [vx vy]]]
   [[(+ px vx) (+ py vy)] [(cond-> vx (pos? vx) dec) (dec vy)]])
 
+(defn take-last-while [pred coll]
+  (loop [v (first coll) r (rest coll)]
+    (if (not (pred (first r)))
+      v
+      (recur (first r) (rest r)))))
+
 (defn build-path [target vel]
   (->> (iterate apply-velocity [initial-pos vel])
-       (take-while (comp not (partial beyond-target? target) first))
-       (mapv first)))
-
-(defn path-height [target vel]
-  (let [path (build-path target vel)]
-    (when (within-target? target (last path))
-      (apply max (map second path)))))
+       (take-last-while (comp not (partial beyond-target? target) first))
+       (first)))
 
 ; Used to determine best x velocity for highest path
 (def tnum-seq (iterate #(do [(apply + %) (inc (second %))]) [0 1]))
 (let [[tb te]      target-area
       lowest-x     (second (last (take-while #(< (first %) (first tb)) tnum-seq)))
       highest-y    (dec (Math/abs (second te)))]
-  (println
-    (path-height target-area [lowest-x highest-y])
-    (count
-      (filter (partial within-target? target-area)
-        (for [x (range lowest-x (inc (first te)))
-              y (range (second te) (inc highest-y))]
-          (last (build-path target-area [x y])))))))
+  (->> (for [y (range (second te) (inc highest-y))
+             x (range lowest-x (inc (first te)))] [x y])
+       (#(do (println "Generated xy pairs...") %))
+       (#(do (println "Total: " (* (- highest-y (second te)) (- (inc highest-y) lowest-x))) %))
+       (partition 50000)
+       (#(do (println "Prepared partitions...") %))
+       (reduce
+          (fn [sum nlst]
+            (println sum)
+            (+ sum
+              (r/fold +
+                (r/monoid
+                  (fn [tot xy]
+                    (cond-> tot
+                      (within-target? target-area (build-path target-area xy))
+                      inc))
+                  (constantly 0))
+                (into [] nlst))))
+           0)
+       (println)))
 
index b3b97caa1c7cfd70b8e672267b7c86a9ab48d2cb..83fc42c0f60b6411c33a1af2990ce01f39dd0770 100644 (file)
 (println (snailfish-solve input))
 
 ; Part 2
-(->> (let [input-set (set input)]
-       (for [in input in2 (set/difference input-set (set [in]))]
-         [in in2]))
-     (into [])
+(->> (for [in input in2 input :when (not= in in2)] [in in2])
+     (vec)
      (r/map snailfish-solve)
      (r/fold (r/monoid max (constantly 0)))
      (println))