old problem

Author: jitwit

README

@@ -6,11 +6,15 @@
   ~haskell~.
 
 ** Scheme
-
+   
 *** 2019
 
    - [[./scheme/19/Day5][Day 5: Sunny with a Chance of Asteroids]]
 
+*** 2017
+
+   - [[./scheme/17/Day24][Day 24: Electromagnetic Moat]]
+
 *** 2015
 
    - [[./scheme/15/Day7][Day 7: Some Assembly Required]]

code/biblio.ss

@@ -43,7 +43,7 @@
   (lambda ()
     (let ((cleaner (input-chars-with transform)))
       (with-input-from-string (list->string (cleaner))
-			      parser))))
+                              parser))))
 
 (define comma-separated
   (input-chars-transform-parse

input/17/24.in

@@ -0,0 +1,57 @@
+25/13
+4/43
+42/42
+39/40
+17/18
+30/7
+12/12
+32/28
+9/28
+1/1
+16/7
+47/43
+34/16
+39/36
+6/4
+3/2
+10/49
+46/50
+18/25
+2/23
+3/21
+5/24
+46/26
+50/19
+26/41
+1/50
+47/41
+39/50
+12/14
+11/19
+28/2
+38/47
+5/5
+38/34
+39/39
+17/34
+42/16
+32/23
+13/21
+28/6
+6/20
+1/30
+44/21
+11/28
+14/17
+33/33
+17/43
+31/13
+11/21
+31/39
+0/9
+13/50
+10/14
+16/10
+3/24
+7/0
+50/50

j/19/Day3

@@ -21,29 +21,18 @@ trip =: [: <"0 [: +/\ 0&, @: >
 step =: (%|)@:-~
 
 fill =: 4 : 0
-dz =. (0{y)-(_1{x)
+dz =. y - x
 step =. dz % | dz
-(_1{x)+(step * >:i.|dz)
+x+(step * >:i.|dz)
 )
-wires
+NB. wires
 
-10 fill 10j3
-10 step 10j4
 NB. fill/ 0 10 10j3
 NB. 0 ;"1 (A ,: B)
 NB. (trip A);  (zip_trip (trip A))
 #+end_src
 
 #+RESULTS:
-: ┌───┬───┬────┬────┐
-: │8  │0j5│_5  │0j_3│
-: ├───┼───┼────┼────┤
-: │0j7│6  │0j_4│_4  │
-: └───┴───┴────┴────┘
-: 
-: 10j1 10j2 10j3
-: 
-: 0j1
 
 #+begin_src j :session :exports code
 #+end_src

j/19/Day4

@@ -5,16 +5,57 @@
   enough time for this solution to run. It does still work from a
   ~jconsole~ repl.
 
-#+begin_src j :session :exports both :tangle 4.ijs
+#+begin_src j :session :exports code
 eg =: 228888,111111,123346,123350,123789,123345,123999
-input =: 134792 }. i.675810
+input =: 134792+i.(675810-134792)
 
+#+end_src
+
+#+RESULTS:
+  
+  I am sure there's either a built in way to do this, or a better
+  way. ~digits~ is the slowest part of the solution. Recursively
+  div/mods by 10 and appends to a list.
+  
+#+BEGIN_SRC j :session :exports code
 digits =: 1&$`($:@:(<.@:%&10),10&|)@.(9&<)
-goodA =: 0&e.@~:*.]-:/:~
-goodB =: (_4&e.+.2&e.)@(-_1&|.)@I.@~:*.]-:/:~
+#+END_SRC
+
+#+RESULTS:
+
+  Check that the digit list is sorted and check that some index is a
+  repeat (~0&e.~). Since the list is sorted, any repeat must be a
+  consecutive one.
+
+#+BEGIN_SRC j :session :exports code
+goodA =: 0&e.@~: *. (-: /:~)
+#+END_SRC
+
+#+RESULTS:
+  
+  Check for sorted digit list again, but here the requirements are a
+  more complicated. There must be a repeat of length exactly 2. We
+  diverge slightly from the idea above, by looking at the differences
+  between consecutive digits.
+
+  Verb uses ~I.~ to get values at classified indices, rotates by ~_1~
+  and takes the difference. The last trick is that this solution will
+  miss numbers like ~111122~ which has the repeat of 2 at the end of
+  the string -- to fix this, look for negative ~_4~ which is in the
+  list of differences precisely in this situation.
+
+#+BEGIN_SRC j :session :exports code
+goodB =: (_4&e.+.2&e.) @ (-_1&|.) @ I. @ ~: *. (-:/:~)
+#+END_SRC
+
+#+RESULTS:
+
+  print!
+
+#+BEGIN_SRC j :session :exports both
 <"0 (] ,. (goodA ,. goodB) @: digits"0) eg
 ([: +/ (goodA , goodB) @: digits"0) input
-#+end_src
+#+END_SRC
 
 #+RESULTS:
 #+begin_example
@@ -34,4 +75,3 @@ goodB =: (_4&e.+.2&e.)@(-_1&|.)@I.@~:*.]-:/:~
 │123999│1│0│
 └──────┴─┴─┘
 #+end_example
-

scheme/17/Day24

@@ -0,0 +1,111 @@
+# -*- mode: org -*-
+#+title: [[https://adventofcode.com/2017/day/24][Day 24: Electromagnetic Moat]]
+
+ Clearing of the throat
+
+#+BEGIN_SRC scheme :session :exports code
+(load "~/code/advent/load.ss")
+
+(advent-year 17)
+(advent-day 24)
+
+(import (prefix (patricia) t:)
+	(prefix (patricia-set) s:))
+#+END_SRC
+
+#+RESULTS:
+: #<void>
+
+  Rather ugly parsing of the bridges. The pool of available pieces
+  shall be stored in a map of sets. 
+
+#+BEGIN_SRC scheme :session :exports code
+(define bridges
+  (fold-right (lambda (bridge T)
+                (let-values (((x y) (apply values bridge)))
+                  (t:insert-with s:union y (s:singleton x)
+                                 (t:insert-with s:union x (s:singleton y) T))))
+              t:empty-tree
+              (n-tuples 2
+                        (parse-advent
+                         (input-chars-transform-parse
+                          (lambda (x)
+                            (if (char=? x #\/)
+                                #\space
+                                x))
+                          input)))))
+#+END_SRC
+
+#+RESULTS:
+: #<void>
+
+  As we select a bridge to connect, we delete it from the pool. All
+  paths are expanded from a node, which have an endpoint that agrees.
+
+#+begin_src scheme :session :exports code
+
+(define (connections pin bridges)
+  (s:set->list
+   (t:lookup-with-default pin s:empty-set bridges)))
+
+(define (connect in out bridges)
+  (t:modify (lambda (S)
+              (s:delete in S))
+	    out
+	    (t:modify (lambda (S) (s:delete out S))
+		      in
+		      bridges)))
+
+(define (expand pin network)
+  `(,pin ,@(map (lambda (out)
+		  (expand out (connect pin out network)))
+		(connections pin network))))
+#+end_src
+
+#+RESULTS:
+: #<void>
+
+  To find the strongest and deepest paths, we expore them all
+  recursively. Two variables are visible for ~set!~ ing as we find
+  better paths.
+
+#+begin_src scheme :session :exports code
+(define (explore root network)
+  (let ((deepest 0)
+        (strongest 0)
+        (global 0))
+    (let walk ((level 0) (signal root) (pin root) (network network))
+      (let ((outs (connections pin network)))
+        (cond ((null? outs)
+               (when (or (> level deepest)
+                         (and (= level deepest)
+                              (> signal strongest)))
+                 (set! deepest level)
+                 (set! strongest signal))
+               (when (> signal global)
+                 (set! global signal)))
+              (else
+               (for-all (lambda (out)
+                          (walk (1+ level)
+                                (+ signal pin out)
+                                out
+                                (connect pin out network)))
+                        outs)))))
+    (values global strongest)))
+#+end_src
+
+#+RESULTS:
+: #<void>
+
+
+  And printing
+
+#+BEGIN_SRC scheme :session :results output
+(let-values (((part-a part-b) (explore 0 bridges)))
+  (format #t "part-a: ~a~%part-b: ~a~%" part-a part-b))
+#+END_SRC
+
+#+RESULTS:
+: part-a: 1868
+: part-b: 1841
+

scheme/19/1.ss

@@ -10,8 +10,8 @@
 (define (fuel+ mass)
   (if (< 0 mass) (+ mass (fuel+ (fuel mass))) 0))
 
-(define (part-a)
+(define (part-a masses)
   (apply + (map fuel masses)))
 
-(define (part-b)
+(define (part-b masses)
   (apply + (map (compose fuel+ fuel) masses)))

scheme/19/Day5

@@ -1,11 +1,7 @@
 # -*- mode: org -*-
 #+title: [[https://adventofcode.com/2019/day/5][Day 5: Sunny with a Chance of Asteroids]]
 
-  I would have like to solve this in ~J~ like day 2, but the amount of
-  conditional referencing feels a bit intimidating at my current skill
-  level.
-
-** Parsing
+** Reading
 
   Intcode programs are given as a comma separated list of ints. The
   some code in [[./../../code/][code/]] that makes getting a hold of this more
@@ -63,6 +59,7 @@
 #+end_src
 
 #+RESULTS:
+: #<void>
 
 ** Executing
 
@@ -119,7 +116,7 @@
 #+end_src
 
 #+RESULTS:
-: #<void>
+>
 
   To run a program to completion, we wait until the ~ip~ does not
   advance (opcode 99).
@@ -136,22 +133,19 @@
 #+RESULTS:
 : #<void>
 
-** Solving
 
   Finally, we ~run~ and read ~out~.
 
-#+begin_src scheme :session :exports both :results output
-(display-ln
+#+begin_src scheme :session :exports both :results value
+(cons
  (parameterize ((in 1))
    (run)
-   (out)))
-
-(display-ln
+   (out))
  (parameterize ((in 5))
    (run)
    (out)))
 #+end_src
 
 #+RESULTS:
-: (7265618 7731427)
+: (7265618 . 7731427)