Make cannot deal with spaces in filenames.
Is make wrong, or is it your filename?
This commit is contained in:
Simon Forman
@@ -0,0 +1,324 @@
|
||||
|
||||
Advent of Code 2017
|
||||
===================
|
||||
|
||||
December 5th
|
||||
------------
|
||||
|
||||
...a list of the offsets for each jump. Jumps are relative: -1 moves to
|
||||
the previous instruction, and 2 skips the next one. Start at the first
|
||||
instruction in the list. The goal is to follow the jumps until one leads
|
||||
outside the list.
|
||||
|
||||
In addition, these instructions are a little strange; after each jump,
|
||||
the offset of that instruction increases by 1. So, if you come across an
|
||||
offset of 3, you would move three instructions forward, but change it to
|
||||
a 4 for the next time it is encountered.
|
||||
|
||||
For example, consider the following list of jump offsets:
|
||||
|
||||
::
|
||||
|
||||
0
|
||||
3
|
||||
0
|
||||
1
|
||||
-3
|
||||
|
||||
Positive jumps ("forward") move downward; negative jumps move upward.
|
||||
For legibility in this example, these offset values will be written all
|
||||
on one line, with the current instruction marked in parentheses. The
|
||||
following steps would be taken before an exit is found:
|
||||
|
||||
-
|
||||
|
||||
(0) 3 0 1 -3 - before we have taken any steps.
|
||||
|
||||
-
|
||||
|
||||
(1) 3 0 1 -3 - jump with offset 0 (that is, don't jump at all).
|
||||
Fortunately, the instruction is then incremented to 1.
|
||||
|
||||
- 2 (3) 0 1 -3 - step forward because of the instruction we just
|
||||
modified. The first instruction is incremented again, now to 2.
|
||||
- 2 4 0 1 (-3) - jump all the way to the end; leave a 4 behind.
|
||||
- 2 (4) 0 1 -2 - go back to where we just were; increment -3 to -2.
|
||||
- 2 5 0 1 -2 - jump 4 steps forward, escaping the maze.
|
||||
|
||||
In this example, the exit is reached in 5 steps.
|
||||
|
||||
How many steps does it take to reach the exit?
|
||||
|
||||
Breakdown
|
||||
---------
|
||||
|
||||
For now, I'm going to assume a starting state with the size of the
|
||||
sequence pre-computed. We need it to define the exit condition and it is
|
||||
a trivial preamble to generate it. We then need and ``index`` and a
|
||||
``step-count``, which are both initially zero. Then we have the sequence
|
||||
itself, and some recursive function ``F`` that does the work.
|
||||
|
||||
::
|
||||
|
||||
size index step-count [...] F
|
||||
-----------------------------------
|
||||
step-count
|
||||
|
||||
F == [P] [T] [R1] [R2] genrec
|
||||
|
||||
Later on I was thinking about it and the Forth heuristic came to mind,
|
||||
to wit: four things on the stack are kind of much. Immediately I
|
||||
realized that the size properly belongs in the predicate of ``F``! D'oh!
|
||||
|
||||
::
|
||||
|
||||
index step-count [...] F
|
||||
------------------------------
|
||||
step-count
|
||||
|
||||
So, let's start by nailing down the predicate:
|
||||
|
||||
::
|
||||
|
||||
F == [P] [T] [R1] [R2] genrec
|
||||
== [P] [T] [R1 [F] R2] ifte
|
||||
|
||||
0 0 [0 3 0 1 -3] popop 5 >=
|
||||
|
||||
P == popop 5 >=
|
||||
|
||||
Now we need the else-part:
|
||||
|
||||
::
|
||||
|
||||
index step-count [0 3 0 1 -3] roll< popop
|
||||
|
||||
E == roll< popop
|
||||
|
||||
Last but not least, the recursive branch
|
||||
|
||||
::
|
||||
|
||||
0 0 [0 3 0 1 -3] R1 [F] R2
|
||||
|
||||
The ``R1`` function has a big job:
|
||||
|
||||
::
|
||||
|
||||
R1 == get the value at index
|
||||
increment the value at the index
|
||||
add the value gotten to the index
|
||||
increment the step count
|
||||
|
||||
The only tricky thing there is incrementing an integer in the sequence.
|
||||
Joy sequences are not particularly good for random access. We could
|
||||
encode the list of jump offsets in a big integer and use math to do the
|
||||
processing for a good speed-up, but it still wouldn't beat the
|
||||
performance of e.g. a mutable array. This is just one of those places
|
||||
where "plain vanilla" Joypy doesn't shine (in default performance. The
|
||||
legendary *Sufficiently-Smart Compiler* would of course rewrite this
|
||||
function to use an array "under the hood".)
|
||||
|
||||
In the meantime, I'm going to write a primitive function that just does
|
||||
what we need.
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
from notebook_preamble import D, J, V, define
|
||||
from joy.library import SimpleFunctionWrapper
|
||||
from joy.utils.stack import list_to_stack
|
||||
|
||||
|
||||
@SimpleFunctionWrapper
|
||||
def incr_at(stack):
|
||||
'''Given a index and a sequence of integers, increment the integer at the index.
|
||||
|
||||
E.g.:
|
||||
|
||||
3 [0 1 2 3 4 5] incr_at
|
||||
-----------------------------
|
||||
[0 1 2 4 4 5]
|
||||
|
||||
'''
|
||||
sequence, (i, stack) = stack
|
||||
mem = []
|
||||
while i >= 0:
|
||||
term, sequence = sequence
|
||||
mem.append(term)
|
||||
i -= 1
|
||||
mem[-1] += 1
|
||||
return list_to_stack(mem, sequence), stack
|
||||
|
||||
|
||||
D['incr_at'] = incr_at
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
J('3 [0 1 2 3 4 5] incr_at')
|
||||
|
||||
|
||||
.. parsed-literal::
|
||||
|
||||
[0 1 2 4 4 5]
|
||||
|
||||
|
||||
get the value at index
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
::
|
||||
|
||||
3 0 [0 1 2 3 4] [roll< at] nullary
|
||||
3 0 [0 1 2 n 4] n
|
||||
|
||||
increment the value at the index
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
::
|
||||
|
||||
3 0 [0 1 2 n 4] n [Q] dip
|
||||
3 0 [0 1 2 n 4] Q n
|
||||
3 0 [0 1 2 n 4] [popd incr_at] unary n
|
||||
3 0 [0 1 2 n+1 4] n
|
||||
|
||||
add the value gotten to the index
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
::
|
||||
|
||||
3 0 [0 1 2 n+1 4] n [+] cons dipd
|
||||
3 0 [0 1 2 n+1 4] [n +] dipd
|
||||
3 n + 0 [0 1 2 n+1 4]
|
||||
3+n 0 [0 1 2 n+1 4]
|
||||
|
||||
increment the step count
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
::
|
||||
|
||||
3+n 0 [0 1 2 n+1 4] [++] dip
|
||||
3+n 1 [0 1 2 n+1 4]
|
||||
|
||||
All together now...
|
||||
~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
::
|
||||
|
||||
get_value == [roll< at] nullary
|
||||
incr_value == [[popd incr_at] unary] dip
|
||||
add_value == [+] cons dipd
|
||||
incr_step_count == [++] dip
|
||||
|
||||
R1 == get_value incr_value add_value incr_step_count
|
||||
|
||||
F == [P] [T] [R1] primrec
|
||||
|
||||
F == [popop !size! >=] [roll< pop] [get_value incr_value add_value incr_step_count] primrec
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
from joy.library import DefinitionWrapper
|
||||
|
||||
|
||||
DefinitionWrapper.add_definitions('''
|
||||
|
||||
get_value == [roll< at] nullary
|
||||
incr_value == [[popd incr_at] unary] dip
|
||||
add_value == [+] cons dipd
|
||||
incr_step_count == [++] dip
|
||||
|
||||
AoC2017.5.0 == get_value incr_value add_value incr_step_count
|
||||
|
||||
''', D)
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
define('F == [popop 5 >=] [roll< popop] [AoC2017.5.0] primrec')
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
J('0 0 [0 3 0 1 -3] F')
|
||||
|
||||
|
||||
.. parsed-literal::
|
||||
|
||||
5
|
||||
|
||||
|
||||
Preamble for setting up predicate, ``index``, and ``step-count``
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
We want to go from this to this:
|
||||
|
||||
::
|
||||
|
||||
[...] AoC2017.5.preamble
|
||||
------------------------------
|
||||
0 0 [...] [popop n >=]
|
||||
|
||||
Where ``n`` is the size of the sequence.
|
||||
|
||||
The first part is obviously ``0 0 roll<``, then ``dup size``:
|
||||
|
||||
::
|
||||
|
||||
[...] 0 0 roll< dup size
|
||||
0 0 [...] n
|
||||
|
||||
Then:
|
||||
|
||||
::
|
||||
|
||||
0 0 [...] n [>=] cons [popop] swoncat
|
||||
|
||||
So:
|
||||
|
||||
::
|
||||
|
||||
init-index-and-step-count == 0 0 roll<
|
||||
prepare-predicate == dup size [>=] cons [popop] swoncat
|
||||
|
||||
AoC2017.5.preamble == init-index-and-step-count prepare-predicate
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
DefinitionWrapper.add_definitions('''
|
||||
|
||||
init-index-and-step-count == 0 0 roll<
|
||||
prepare-predicate == dup size [>=] cons [popop] swoncat
|
||||
|
||||
AoC2017.5.preamble == init-index-and-step-count prepare-predicate
|
||||
|
||||
AoC2017.5 == AoC2017.5.preamble [roll< popop] [AoC2017.5.0] primrec
|
||||
|
||||
''', D)
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
J('[0 3 0 1 -3] AoC2017.5')
|
||||
|
||||
|
||||
.. parsed-literal::
|
||||
|
||||
5
|
||||
|
||||
|
||||
::
|
||||
|
||||
AoC2017.5 == AoC2017.5.preamble [roll< popop] [AoC2017.5.0] primrec
|
||||
|
||||
AoC2017.5.0 == get_value incr_value add_value incr_step_count
|
||||
AoC2017.5.preamble == init-index-and-step-count prepare-predicate
|
||||
|
||||
get_value == [roll< at] nullary
|
||||
incr_value == [[popd incr_at] unary] dip
|
||||
add_value == [+] cons dipd
|
||||
incr_step_count == [++] dip
|
||||
|
||||
init-index-and-step-count == 0 0 roll<
|
||||
prepare-predicate == dup size [>=] cons [popop] swoncat
|
||||
|
||||
This is by far the largest program I have yet written in Joy. Even with
|
||||
the ``incr_at`` function it is still a bear. There may be an arrangement
|
||||
of the parameters that would permit more elegant definitions, but it
|
||||
still wouldn't be as efficient as something written in assembly, C, or
|
||||
even Python.
|
||||
Reference in New Issue
Block a user