[p9] Study and various failed attempts

p9/p9.org

@@ -2,7 +2,7 @@
 
 #+begin_src emacs-lisp :results none
   (with-temp-buffer
-    (insert-file-contents "input-test")
+    (insert-file-contents "input")
     (advent/replace-multiple-regex-buffer
      '(("," . " ")
        ("^" . "(")
@@ -31,13 +31,14 @@ Find max area
 #+end_src
 
 #+RESULTS:
-: 50
+: 4737096935
 
 For part 2, we begin by removing the vertices that are not corners.
 (there may be some, or none, but I don't know for sure)
 #+begin_src emacs-lisp :results none
   (setq data-prev (-rotate 1 data)
         data-next (-rotate -1 data)
+        edges (-zip-lists data data-next)
         data-pv (-zip-lists data data-prev data-next))
 
   (defun normalize (x)
@@ -57,13 +58,10 @@ For part 2, we begin by removing the vertices that are not corners.
                      (cons (cornerize (cadr it) (car it))
                            (cornerize (car it) (caddr it))))
                data-pv))
-
-  (setq data-corners
-        (--remove (equal (cadr it) (cddr it)) data-corners))
 #+end_src
 
 OK, the datapoints are all corners. Now I know. Find which way is inside
-#+begin_src emacs-lisp
+#+begin_src emacs-lisp :results none
     ;; find the leftmost and topmost coordinate
     (setq leftmost (-min (-map #'car data))
           topmost (-min (-map #'cadr data)))
@@ -71,24 +69,43 @@ OK, the datapoints are all corners. Now I know. Find which way is inside
   ;; find corners that lie on the leftmost coordinate; the domain must
   ;; be to their right it appears that there are only two such corners;
   ;; take the first one, and the outgoing direction; it is going down
-    ;; and it must come from the right, so it should be (-1 0) . (0 -1)
+  ;; and it must come from the right, so it should be (-1 0) . (0 1)
 
-      (car (--filter (= (caar it) leftmost) data-corners))
+  (setq orientation (-last-item (car (--filter (= (caar it) leftmost) data-corners))))
 
   ;; We therefore know what corners are convex and what corners are concave
-    (setq quadrant-map
+
-          '( (((-1 0) . (0 -1)) . (4))
+  (defun corner-normal (corner)
-             (((0 -1) . (1  0)) . (1))
+    (let* ((cor (cdr corner))
-             (((1 0)  .  (0 1)) . (2))
+           (a (caar cor))
-             (((0 1)  . (-1 0)) . (3))
+           (d (caddr cor))
-             (((-1 0) . (0 1)) . (2 3 4))
+           (b (cadar cor))
-             (((0 1) . (1  0)) . (1 3 4))
+           (c (cadr cor))
-             (((1 0)  .  (0 -1)) . (4 1 2))
+           (det (* orientation (- (* b c) (* a d)))))
-             (((0 -1)  . (-1 0)) . ( 1 2 3))))
+      (list det (- c a) (- d b))))
+
+  (setq data-normals (--map (cons (car it) (corner-normal it)) data-corners))
 
   (setq rects (symmetric-pairs data))
 
-    ;; first filter away those that strictly contain a vertex
+  ;; first filter those rectangles that are defined by vertices that
+  ;; have the wrong orientation
+
+  (defun compatible-or (u v)
+    (if (or (= (car u) 0) (= (cadr u) 0)) t
+      (if (> (car v) 0) (equal u (cdr v)) ;convex corner
+        (not (equal u (cdr v))) ;concave corner
+        )))
+
+  (defun good-orientation-p (rect)
+    (let ((a (assoc (car rect) data-normals))
+          (b (assoc (cdr rect) data-normals)))
+      (and (compatible-or (cornerize (car b) (car a))  (cdr b))
+           (compatible-or (cornerize (car a) (car b))  (cdr a)))))
+
+  (setq good-rects (-filter #'good-orientation-p rects))
+
+  ;; then filter away those that strictly contain a vertex
   (defun strictly-contains-p (rect p)
     (let ((minx (min (caar rect) (cadr rect)))
           (maxx (max (caar rect) (cadr rect)))
@@ -99,10 +116,13 @@ OK, the datapoints are all corners. Now I know. Find which way is inside
       (and (< minx px) (< px maxx)
            (< miny py) (< py maxy))))
 
-    (setq rects-sifted (-remove (lambda (rect) (--any (strictly-contains-p rect it) data)) rects))
+  (setq rects-sifted (-remove (lambda (rect) (--any (strictly-contains-p rect it) data)) good-rects))
+
+  (length rects-sifted)
 #+end_src
 
-#+begin_src emacs-lisp
+
+#+begin_src emacs-lisp :results none
    (defun incompatible-p (rect corner)
      (let ((minx (min (caar rect) (cadr rect)))
            (maxx (max (caar rect) (cadr rect)))
@@ -110,107 +130,57 @@ OK, the datapoints are all corners. Now I know. Find which way is inside
            (maxy (max (cadar rect) (caddr rect)))
            (px (caar corner))
            (py (cadar corner))
-          (quadrant-list (cdr (assoc (cdr corner) quadrant-map))))
+           (convexity (cadr corner))
-      (or (and (= px minx) (< miny py) (< py maxy) (< 2 (length (-intersection '(1 4) quadrant-list))))   ; on left edge
+           (normal (cddr corner)))
-          (and (= px maxx) (< miny py) (< py maxy) (< 2 (length (-intersection '(2 3) quadrant-list))))
+
-          (and (= py miny) (< minx px) (< px maxx) (< 2 (length (-intersection '(1 2) quadrant-list))))
+       (or (and (= px minx) (< miny py) (< py maxy) (< (advent/dot normal (list convexity 0)) 0))   ; on left edge
-          (and (= py maxy) (< minx px) (< px maxx) (< 2 (length (-intersection '(3 4) quadrant-list)))))))
+           (and (= px maxx) (< miny py) (< py maxy) (> (advent/dot normal (list convexity 0)) 0))
-
+           (and (= py miny) (< minx px) (< px maxx) (< (advent/dot normal (list 0 convexity)) 0))
-  (setq final-rects (-remove (lambda (rect) (--any (incompatible-p rect it) data-corners)) rects-sifted))
+           (and (= py maxy) (< minx px) (< px maxx) (> (advent/dot normal (list 0 convexity)) 0)))))
-  (-max (-map #'area final-rects))
+
+  (setq rects-refined (-remove (lambda (rect) (--any (incompatible-p rect it) data-normals)) rects-sifted))
 #+end_src
 
-#+RESULTS:
+Now we should have eliminated all corner cases; we just need to remove
-: 40
+those that are cut by an edge
 
 #+begin_src emacs-lisp
-  (car rects)
+  (length rects)
-  (--filter (incompatible-p (cadr rects-sifted) it) data-corners)
+  (length good-rects)
+  (length rects-sifted)
+  (length rects-refined)
 
-  (cadr rects-sifted)
+  (defun cuts-p (rect edge)
+    (let* ((minx (min (caar rect) (cadr rect)))
+          (maxx (max (caar rect) (cadr rect)))
+          (miny (min (cadar rect) (caddr rect)))
+          (maxy (max (cadar rect) (caddr rect)))
+          (eminx (min (caar edge) (caadr edge)))
+          (emaxx (max (caar edge) (caadr edge)))
+          (eminy (min (cadar edge) (cadadr edge)))
+          (emaxy (max (cadar edge) (cadadr edge)))
+          (ver (= eminx emaxx)))
+      (if ver (and (< minx eminx) (< eminx maxx) (< eminy miny) (< maxy emaxy))
+        (and (< miny eminy) (< eminy maxy) (< eminx minx) (< maxx emaxx))))
+    )
 
-#+end_src
+  (setq rects-uncut (-remove (lambda (rect) (--any (cuts-p rect it) edges)) rects-refined))
+  (length rects-uncut)
 
-#+RESULTS:
-| (7 1)  | 11 | 1 |
-| (7 1)  | 11 | 7 |
-| (7 1)  |  9 | 7 |
-| (7 1)  |  9 | 5 |
-| (7 1)  |  2 | 5 |
-| (7 1)  |  2 | 3 |
-| (7 1)  |  7 | 3 |
-| (11 1) | 11 | 7 |
-| (11 1) |  9 | 7 |
-| (11 1) |  9 | 5 |
-| (11 1) |  2 | 5 |
-| (11 1) |  2 | 3 |
 
-| (11 1) |  7 | 3 |
+  (-max (-map #'area rects-uncut))
-| (11 7) |  9 | 7 |
-| (11 7) |  9 | 5 |
-| (11 7) |  2 | 5 |
-| (11 7) |  2 | 3 |
-| (11 7) |  7 | 3 |
-| (9 7)  |  9 | 5 |
-| (9 7)  |  2 | 5 |
-| (9 7)  |  2 | 3 |
-| (9 7)  |  7 | 3 |
-| (9 5)  |  2 | 5 |
-| (9 5)  |  2 | 3 |
-| (9 5)  |  7 | 3 |
-| (2 5)  |  2 | 3 |
-| (2 5)  |  7 | 3 |
-| (2 3)  |  7 | 3 |
 
-#+begin_src emacs-lisp
-  rects-sifted
 #+end_src
 
 #+RESULTS:
-| (7 1)  | 11 | 1 |
+: 1644057540
-| (7 1)  |  9 | 7 |
-| (7 1)  |  9 | 5 |
-| (7 1)  |  2 | 5 |
-| (7 1)  |  2 | 3 |
-| (7 1)  |  7 | 3 |
-| (11 1) | 11 | 7 |
-| (11 1) |  9 | 7 |
-| (11 1) |  9 | 5 |
-| (11 1) |  2 | 3 |
-| (11 1) |  7 | 3 |
-| (11 7) |  9 | 7 |
-| (11 7) |  9 | 5 |
-| (11 7) |  2 | 5 |
-| (9 7)  |  9 | 5 |
-| (9 7)  |  2 | 5 |
-| (9 7)  |  2 | 3 |
-| (9 7)  |  7 | 3 |
-| (9 5)  |  2 | 5 |
-| (9 5)  |  2 | 3 |
-| (9 5)  |  7 | 3 |
-| (2 5)  |  2 | 3 |
-| (2 5)  |  7 | 3 |
-| (2 3)  |  7 | 3 |
-
-#+begin_src emacs-lisp
-  final-rects
-#+end_src
 
-#+RESULTS:
-| (7 1)  | 11 | 1 |
-| (7 1)  |  9 | 7 |
-| (7 1)  |  9 | 5 |
-| (7 1)  |  2 | 5 |
-| (7 1)  |  2 | 3 |
-| (7 1)  |  7 | 3 |
-| (11 1) | 11 | 7 |
-| (11 1) |  9 | 7 |
-| (11 1) |  9 | 5 |
-| (11 1) |  2 | 3 |
 | (11 1) |  7 | 3 |
 | (11 7) |  9 | 7 |
 | (11 7) |  9 | 5 |
 | (11 7) |  2 | 5 |
+| (11 7) |  2 | 3 |
+| (11 7) |  7 | 3 |
 | (9 7)  |  9 | 5 |
 | (9 7)  |  2 | 5 |
 | (9 7)  |  2 | 3 |