day7

9 years ago · fdba08b97a
parent 09883ce619
commit fdba08b97a
6 changed files with 522 additions and 3 deletions
--- a/aoc-racket.scrbl
+++ b/aoc-racket.scrbl
@ -15,3 +15,4 @@
@include-section[(submod "day4.scrbl" doc)]
@include-section[(submod "day5.scrbl" doc)]
@include-section[(submod "day6.scrbl" doc)]
@include-section[(submod "day7.scrbl" doc)]
--- a/day6.scrbl
+++ b/day6.scrbl
@ -3,7 +3,7 @@
@aoc-title[6]
-Our @link-rp["day6-input.txt"]{input} is a list instructions for turning on (or off) the bulbs in a @racket[(* 1000 1000)] grid of lights.
+Our @link-rp["day6-input.txt"]{input} is a list of instructions for turning on (or off) the bulbs in a @racket[(* 1000 1000)] grid of lights.
@chunk[<day6>
       <day6-setup>
--- a/day7-input.txt
+++ b/day7-input.txt
@ -0,0 +1,339 @@
 bn RSHIFT 2 -> bo
 lf RSHIFT 1 -> ly
 fo RSHIFT 3 -> fq
 cj OR cp -> cq
 fo OR fz -> ga
 t OR s -> u
 lx -> a
 NOT ax -> ay
 he RSHIFT 2 -> hf
 lf OR lq -> lr
 lr AND lt -> lu
 dy OR ej -> ek
 1 AND cx -> cy
 hb LSHIFT 1 -> hv
 1 AND bh -> bi
 ih AND ij -> ik
 c LSHIFT 1 -> t
 ea AND eb -> ed
 km OR kn -> ko
 NOT bw -> bx
 ci OR ct -> cu
 NOT p -> q
 lw OR lv -> lx
 NOT lo -> lp
 fp OR fv -> fw
 o AND q -> r
 dh AND dj -> dk
 ap LSHIFT 1 -> bj
 bk LSHIFT 1 -> ce
 NOT ii -> ij
 gh OR gi -> gj
 kk RSHIFT 1 -> ld
 lc LSHIFT 1 -> lw
 lb OR la -> lc
 1 AND am -> an
 gn AND gp -> gq
 lf RSHIFT 3 -> lh
 e OR f -> g
 lg AND lm -> lo
 ci RSHIFT 1 -> db
 cf LSHIFT 1 -> cz
 bn RSHIFT 1 -> cg
 et AND fe -> fg
 is OR it -> iu
 kw AND ky -> kz
 ck AND cl -> cn
 bj OR bi -> bk
 gj RSHIFT 1 -> hc
 iu AND jf -> jh
 NOT bs -> bt
 kk OR kv -> kw
 ks AND ku -> kv
 hz OR ik -> il
 b RSHIFT 1 -> v
 iu RSHIFT 1 -> jn
 fo RSHIFT 5 -> fr
 be AND bg -> bh
 ga AND gc -> gd
 hf OR hl -> hm
 ld OR le -> lf
 as RSHIFT 5 -> av
 fm OR fn -> fo
 hm AND ho -> hp
 lg OR lm -> ln
 NOT kx -> ky
 kk RSHIFT 3 -> km
 ek AND em -> en
 NOT ft -> fu
 NOT jh -> ji
 jn OR jo -> jp
 gj AND gu -> gw
 d AND j -> l
 et RSHIFT 1 -> fm
 jq OR jw -> jx
 ep OR eo -> eq
 lv LSHIFT 15 -> lz
 NOT ey -> ez
 jp RSHIFT 2 -> jq
 eg AND ei -> ej
 NOT dm -> dn
 jp AND ka -> kc
 as AND bd -> bf
 fk OR fj -> fl
 dw OR dx -> dy
 lj AND ll -> lm
 ec AND ee -> ef
 fq AND fr -> ft
 NOT kp -> kq
 ki OR kj -> kk
 cz OR cy -> da
 as RSHIFT 3 -> au
 an LSHIFT 15 -> ar
 fj LSHIFT 15 -> fn
 1 AND fi -> fj
 he RSHIFT 1 -> hx
 lf RSHIFT 2 -> lg
 kf LSHIFT 15 -> kj
 dz AND ef -> eh
 ib OR ic -> id
 lf RSHIFT 5 -> li
 bp OR bq -> br
 NOT gs -> gt
 fo RSHIFT 1 -> gh
 bz AND cb -> cc
 ea OR eb -> ec
 lf AND lq -> ls
 NOT l -> m
 hz RSHIFT 3 -> ib
 NOT di -> dj
 NOT lk -> ll
 jp RSHIFT 3 -> jr
 jp RSHIFT 5 -> js
 NOT bf -> bg
 s LSHIFT 15 -> w
 eq LSHIFT 1 -> fk
 jl OR jk -> jm
 hz AND ik -> im
 dz OR ef -> eg
 1 AND gy -> gz
 la LSHIFT 15 -> le
 br AND bt -> bu
 NOT cn -> co
 v OR w -> x
 d OR j -> k
 1 AND gd -> ge
 ia OR ig -> ih
 NOT go -> gp
 NOT ed -> ee
 jq AND jw -> jy
 et OR fe -> ff
 aw AND ay -> az
 ff AND fh -> fi
 ir LSHIFT 1 -> jl
 gg LSHIFT 1 -> ha
 x RSHIFT 2 -> y
 db OR dc -> dd
 bl OR bm -> bn
 ib AND ic -> ie
 x RSHIFT 3 -> z
 lh AND li -> lk
 ce OR cd -> cf
 NOT bb -> bc
 hi AND hk -> hl
 NOT gb -> gc
 1 AND r -> s
 fw AND fy -> fz
 fb AND fd -> fe
 1 AND en -> eo
 z OR aa -> ab
 bi LSHIFT 15 -> bm
 hg OR hh -> hi
 kh LSHIFT 1 -> lb
 cg OR ch -> ci
 1 AND kz -> la
 gf OR ge -> gg
 gj RSHIFT 2 -> gk
 dd RSHIFT 2 -> de
 NOT ls -> lt
 lh OR li -> lj
 jr OR js -> jt
 au AND av -> ax
 0 -> c
 he AND hp -> hr
 id AND if -> ig
 et RSHIFT 5 -> ew
 bp AND bq -> bs
 e AND f -> h
 ly OR lz -> ma
 1 AND lu -> lv
 NOT jd -> je
 ha OR gz -> hb
 dy RSHIFT 1 -> er
 iu RSHIFT 2 -> iv
 NOT hr -> hs
 as RSHIFT 1 -> bl
 kk RSHIFT 2 -> kl
 b AND n -> p
 ln AND lp -> lq
 cj AND cp -> cr
 dl AND dn -> do
 ci RSHIFT 2 -> cj
 as OR bd -> be
 ge LSHIFT 15 -> gi
 hz RSHIFT 5 -> ic
 dv LSHIFT 1 -> ep
 kl OR kr -> ks
 gj OR gu -> gv
 he RSHIFT 5 -> hh
 NOT fg -> fh
 hg AND hh -> hj
 b OR n -> o
 jk LSHIFT 15 -> jo
 gz LSHIFT 15 -> hd
 cy LSHIFT 15 -> dc
 kk RSHIFT 5 -> kn
 ci RSHIFT 3 -> ck
 at OR az -> ba
 iu RSHIFT 3 -> iw
 ko AND kq -> kr
 NOT eh -> ei
 aq OR ar -> as
 iy AND ja -> jb
 dd RSHIFT 3 -> df
 bn RSHIFT 3 -> bp
 1 AND cc -> cd
 at AND az -> bb
 x OR ai -> aj
 kk AND kv -> kx
 ao OR an -> ap
 dy RSHIFT 3 -> ea
 x RSHIFT 1 -> aq
 eu AND fa -> fc
 kl AND kr -> kt
 ia AND ig -> ii
 df AND dg -> di
 NOT fx -> fy
 k AND m -> n
 bn RSHIFT 5 -> bq
 km AND kn -> kp
 dt LSHIFT 15 -> dx
 hz RSHIFT 2 -> ia
 aj AND al -> am
 cd LSHIFT 15 -> ch
 hc OR hd -> he
 he RSHIFT 3 -> hg
 bn OR by -> bz
 NOT kt -> ku
 z AND aa -> ac
 NOT ak -> al
 cu AND cw -> cx
 NOT ie -> if
 dy RSHIFT 2 -> dz
 ip LSHIFT 15 -> it
 de OR dk -> dl
 au OR av -> aw
 jg AND ji -> jj
 ci AND ct -> cv
 dy RSHIFT 5 -> eb
 hx OR hy -> hz
 eu OR fa -> fb
 gj RSHIFT 3 -> gl
 fo AND fz -> gb
 1 AND jj -> jk
 jp OR ka -> kb
 de AND dk -> dm
 ex AND ez -> fa
 df OR dg -> dh
 iv OR jb -> jc
 x RSHIFT 5 -> aa
 NOT hj -> hk
 NOT im -> in
 fl LSHIFT 1 -> gf
 hu LSHIFT 15 -> hy
 iq OR ip -> ir
 iu RSHIFT 5 -> ix
 NOT fc -> fd
 NOT el -> em
 ck OR cl -> cm
 et RSHIFT 3 -> ev
 hw LSHIFT 1 -> iq
 ci RSHIFT 5 -> cl
 iv AND jb -> jd
 dd RSHIFT 5 -> dg
 as RSHIFT 2 -> at
 NOT jy -> jz
 af AND ah -> ai
 1 AND ds -> dt
 jx AND jz -> ka
 da LSHIFT 1 -> du
 fs AND fu -> fv
 jp RSHIFT 1 -> ki
 iw AND ix -> iz
 iw OR ix -> iy
 eo LSHIFT 15 -> es
 ev AND ew -> ey
 ba AND bc -> bd
 fp AND fv -> fx
 jc AND je -> jf
 et RSHIFT 2 -> eu
 kg OR kf -> kh
 iu OR jf -> jg
 er OR es -> et
 fo RSHIFT 2 -> fp
 NOT ca -> cb
 bv AND bx -> by
 u LSHIFT 1 -> ao
 cm AND co -> cp
 y OR ae -> af
 bn AND by -> ca
 1 AND ke -> kf
 jt AND jv -> jw
 fq OR fr -> fs
 dy AND ej -> el
 NOT kc -> kd
 ev OR ew -> ex
 dd OR do -> dp
 NOT cv -> cw
 gr AND gt -> gu
 dd RSHIFT 1 -> dw
 NOT gw -> gx
 NOT iz -> ja
 1 AND io -> ip
 NOT ag -> ah
 b RSHIFT 5 -> f
 NOT cr -> cs
 kb AND kd -> ke
 jr AND js -> ju
 cq AND cs -> ct
 il AND in -> io
 NOT ju -> jv
 du OR dt -> dv
 dd AND do -> dq
 b RSHIFT 2 -> d
 jm LSHIFT 1 -> kg
 NOT dq -> dr
 bo OR bu -> bv
 gk OR gq -> gr
 he OR hp -> hq
 NOT h -> i
 hf AND hl -> hn
 gv AND gx -> gy
 x AND ai -> ak
 bo AND bu -> bw
 hq AND hs -> ht
 hz RSHIFT 1 -> is
 gj RSHIFT 5 -> gm
 g AND i -> j
 gk AND gq -> gs
 dp AND dr -> ds
 b RSHIFT 3 -> e
 gl AND gm -> go
 gl OR gm -> gn
 y AND ae -> ag
 hv OR hu -> hw
 1674 -> b
 ab AND ad -> ae
 NOT ac -> ad
 1 AND ht -> hu
 NOT hn -> ho
--- a/day7.scrbl
+++ b/day7.scrbl
@ -0,0 +1,134 @@
 #lang scribble/lp2
@(require scribble/manual aoc-racket/helper)
@aoc-title[7]
 Our @link-rp["day7-input.txt"]{input} describes an electrical circuit, with each line of the file describing the signal provided to a particular wire.
@chunk[<day7>
       <day7-setup>
       <day7-ops>
       <day7-q1>
       <day7-q2>
       <day7-test>]
@section{What is the signal on wire @tt{a}?}
 The first question we should ask is — how do we model a wire? We're told that it's a thing with inputs that can be evaluated to get a value. So it sounds a lot like a function. Thus, what we'll do is convert our wire descriptions into functions, and then run the function called @racket[a].
 In other languages, creating functions from text strings would be a difficult trick. But this facility is built into Racket with @racket[define-syntax]. Essentially our program will run in two phases: in the syntax-transformation phase, we'll read in the list of wire descriptions and expand them into code that represents functions. In the second phase, the program — including our new functions, created via syntax transformation — will compile & run as usual.
 The @racket[convert-input-to-wire-functions] syntax transformer takes the input strings and converts them into syntax that looks more like Racket code, so that a line like
@tt{bn RSHIFT 2 -> bo}
 becomes
@tt{(wire bn RSHIFT 2 -> bo)}
 Then the @racket[wire] transformer moves the arguments around to define functions, by matching the three definition patterns that appear in the input. Thus, syntax like
@tt{(wire bn RSHIFT 2 -> bo)}
 becomes
@tt{(define (bo) (RSHIFT (evaluate-arg bn) (evaluate-arg 2))}
@racket[evaluate-arg] lets us handle the fact that some of the arguments for our wires are other wires, and some arguments are numbers. Rather than detect these differences in our syntax transformer, we'll just wrap every input argument with @racket[evaluate-arg], which will do the right thing.
 (@racket[wire-value-cache] is just a performance enhancement, so that wire values don't have to be computed multiple times.)
 One gotcha when using syntax transformers is that newly defined identifiers can mask others. For instance, one of the wires in our input is named @tt{if}. When our syntax transformer defines the @tt{if} function, it will override the usual meaning of @racket[if]. There are plenty of elegant ways to handle these kind of namespace collisions. But because this is a puzzle, we'll take the cheap way out: we won't use @racket[if] elsewhere in our code, and instead use @racket[cond].
@chunk[<day7-setup>
       (require racket rackunit
                (for-syntax racket/base racket/file racket/string))
       (define-syntax (convert-input-to-wire-functions stx)
         (syntax-case stx ()
           [(_)
            (let* ([input-strings (file->lines "day7-input.txt")]
                   [wire-strings (map (λ(str) (format "(wire ~a)" str)) input-strings)]
                   [wire-datums (map (compose1 read open-input-string) wire-strings)])
              (datum->syntax stx `(begin ,@wire-datums)))]))
       (define-syntax (wire stx)
         (syntax-case stx (->)
           [(_ arg -> wire-name)
            #'(define (wire-name) (evaluate-arg arg))]
           [(_ 16bit-op arg -> wire-name)
            #'(define (wire-name) (16bit-op (evaluate-arg arg)))]
           [(_ arg1 16bit-op arg2 -> wire-name)
            #'(define (wire-name) (16bit-op (evaluate-arg arg1) (evaluate-arg arg2)))]
           [(_ expr) #'(begin expr)]
           [else #'(void)]))
       (convert-input-to-wire-functions)
       (define wire-value-cache (make-hash))
       (define (evaluate-arg x)
         (cond
           [(procedure? x) (hash-ref! wire-value-cache x (thunk* (x)))]
           [else x]))
       ]
 We also need to implement our 16-bit math operations. As we saw above, our syntax transformers are generating code that looks like, for instance, @tt{(RSHIFT (evaluate-arg bn) (evaluate-arg 2)}. This code won't work unless we've defined an @racket[RSHIFT] function too.
 These next definitions use @racket[define-syntax-rule] as a shortcut, which is another syntax transformer.
@chunk[<day7-ops>
       (define (16bitize x)
         (define 16bit-max (expt 2 16))
         (define r (modulo x 16bit-max))
         (cond
           [(negative? r) (16bitize (+ 16bit-max r))]
           [else r]))
       (define-syntax-rule (define-16bit id proc)
         (define id (compose1 16bitize proc)))
       (define-16bit AND bitwise-and)
       (define-16bit OR bitwise-ior)
       (define-16bit LSHIFT arithmetic-shift)
       (define-16bit RSHIFT (λ(x y) (arithmetic-shift x (- y))))
       (define-16bit NOT bitwise-not)]
 After that, we just evaluate wire function @racket[a] to get our answer.
@chunk[<day7-q1>
       (define (q1) (a))]
@section{What is the signal on wire @tt{a} if wire @tt{b} is overridden with @tt{a}'s original value?}
 Having done the heavy lifting, this is easy. We'll redefine wire function @racket[b] to produce the new value, and then check the value of @racket[a] again.
 Ordinarily, as a safety measure, Racket won't let you redefine functions. But we can circumvent this limitation by setting @racket[compile-enforce-module-constants] to @racket[#f]. We'll also need to reset our cache, since this change will change all the other wire values too.
@chunk[<day7-q2>
       (compile-enforce-module-constants #f)
       (define (q2)
         (define first-a-val (a))
         (set! b (thunk* first-a-val))
         (set! wire-value-cache (make-hash))
         (a))
       ]
@section{Testing our input}
@chunk[<day7-test>
       (module+ test
         (define input-strs (file->lines "day7-input.txt"))
         (check-equal? (q1) 46065)
         (check-equal? (q2) 14134))]
--- a/day7foo.rkt
+++ b/day7foo.rkt
@ -0,0 +1,45 @@
 #lang racket
 (require racket rackunit
                (for-syntax racket/base racket/file racket/string))
 (define-syntax (convert-input-to-wire-functions stx)
         (syntax-case stx ()
           [(_)
            (let* ([input-strings (file->lines "day7-input.txt")]
                   [wire-strings (map (λ(str) (format "(wire ~a)" str)) input-strings)]
                   [wire-datums (map (compose1 read open-input-string) wire-strings)])
              (datum->syntax stx `(begin ,@wire-datums)))]))
       (define-syntax (wire stx)
         (syntax-case stx (->)
           [(_ arg -> id)
            #'(define (id) (get-val arg))]
           [(_ op arg -> id)
            #'(define (id) (op (get-val arg)))]
           [(_ arg1 op arg2 -> id)
            #'(define (id) (op (get-val arg1) (get-val arg2)))]
           [(_ expr) #'(begin expr)]
           [else #'(void)]))
       (convert-input-to-wire-functions)
       (require sugar/debug)
       (define wire-value-cache (make-hash))
       (define (get-val x)
         (report x)
         (if (number? x) #t #f))
       (define (16bitize x)
         (define 16bit-max (expt 2 16))
         (define r (modulo x 16bit-max))
         (if (negative? r)
             (16bitize (+ 16bit-max r))
             r))
       (define-syntax-rule (define-16bit id proc) (define id (compose1 16bitize proc)))
       (define-16bit AND bitwise-and)
       (define-16bit OR bitwise-ior)
       (define-16bit LSHIFT arithmetic-shift)
       (define-16bit RSHIFT (λ(x y) (arithmetic-shift x (- y))))
       (define-16bit NOT bitwise-not)
--- a/info.rkt
+++ b/info.rkt
@ -1,5 +1,5 @@
 #lang info
 (define collection "aoc-racket")
-(define scribblings '(("main.scrbl" (multi-page))))
+(define scribblings '(("aoc-racket.scrbl" (multi-page))))
 (define deps '("base" "scribble-lib"))
 (define build-deps '("rackunit-lib" "racket-doc" "scribble-doc" "rackunit-doc" "at-exp-lib"))