gsinclair · February 9, 2022 11:09
diff --git a/origami.clj b/origami.clj
 ;; Problem 13 from Advent of Code 2021 -- origami

 (defn fold-left [fold-x [x y :as point]]
  (if (< x fold-x)
    point
    [(- (* 2 fold-x) x) y]))

 (defn fold-up [fold-y [x y :as point]]
  (if (< y fold-y)
    point
    [x (- (* 2 fold-y) y)]))

 (defn parse-13 [text]
  (let [[part1 part2] (gs-paragraphs text)
        points (->> (re-seq #"\d+" part1)
                    (map parse-long)
                    (partition 2)
                    (map vec))
        functions (for [match (re-seq #"([xy])=(\d+)" part2)
                        :let [[_ xy n] match
                              n        (parse-long n)]]
                    (case xy
                      "x" (partial fold-left n)
                      "y" (partial fold-up n)))]
    [points functions]))

 (defn p13a
  "How many dots are visible after completing the first fold?"
  [text]
  (let [[points transforms] (parse-13 text)]
    (->> points
         (map (first transforms))
         set
         count)))

 (comment
  (e.g. (p13a input/p13-test) --> 17
        (p13a input/p13-data) --> 17))

 (defn print-points [points]
  ; Need to know the size of the canvas, and make a set of the points so we
  ; can do fast lookups.
  (let [points (set points)
        X (->> points (map first) (apply max))
        Y (->> points (map second) (apply max))]
    (doseq [y (range (inc Y))]
      (doseq [x (range (inc X))]
        (if (contains? points [x y])
          (print "#")
          (print " ")))
      (print "\n"))))


 (defn p13b
  "Apply all transformations and print the resulting dot pattern so
  so that eight capital letters can be discerned."
  [text]
  (let [[points transforms] (parse-13 text)
        transform (apply comp (reverse transforms))
        points' (->> points
                     (map transform)
                     set)]
    (print-points points')))

 (comment
  (p13b input/p13-test)
  (p13b input/p13-data))
	;; Problem 13 from Advent of Code 2021 -- origami

	(defn fold-left [fold-x [x y :as point]]
	(if (< x fold-x)
	point
	[(- (* 2 fold-x) x) y]))

	(defn fold-up [fold-y [x y :as point]]
	(if (< y fold-y)
	point
	[x (- (* 2 fold-y) y)]))

	(defn parse-13 [text]
	(let [[part1 part2] (gs-paragraphs text)
	points (->> (re-seq #"\d+" part1)
	(map parse-long)
	(partition 2)
	(map vec))
	functions (for [match (re-seq #"([xy])=(\d+)" part2)
	:let [[_ xy n] match
	n (parse-long n)]]
	(case xy
	"x" (partial fold-left n)
	"y" (partial fold-up n)))]
	[points functions]))

	(defn p13a
	"How many dots are visible after completing the first fold?"
	[text]
	(let [[points transforms] (parse-13 text)]
	(->> points
	(map (first transforms))
	set
	count)))

	(comment
	(e.g. (p13a input/p13-test) --> 17
	(p13a input/p13-data) --> 17))

	(defn print-points [points]
	; Need to know the size of the canvas, and make a set of the points so we
	; can do fast lookups.
	(let [points (set points)
	X (->> points (map first) (apply max))
	Y (->> points (map second) (apply max))]
	(doseq [y (range (inc Y))]
	(doseq [x (range (inc X))]
	(if (contains? points [x y])
	(print "#")
	(print " ")))
	(print "\n"))))


	(defn p13b
	"Apply all transformations and print the resulting dot pattern so
	so that eight capital letters can be discerned."
	[text]
	(let [[points transforms] (parse-13 text)
	transform (apply comp (reverse transforms))
	points' (->> points
	(map transform)
	set)]
	(print-points points')))

	(comment
	(p13b input/p13-test)
	(p13b input/p13-data))