« return to puzzle


Erik Brisson

Step 1: The data file "this" is a valid C program. Compile this using your favorite C compiler, e.g.,

	% cp this this-program.c
	% gcc -o this-program this-program.c

Step 2: Run the executable generated in Step 1, giving the "this" file as input (on stdin) and saving the output (from stdout), e.g.,

        % this-program < this > this-program.out

Step 3: Look at the output file generated in step 2. Realize that each 3x3 binary array in that output could be taken as a rule in a cellular automata simulation along the lines of Conway's Game of Life. Notice that all of these 3x3 arrays have a 1 in the center. Guess that the printed arrays specify the neighborhood configurations which force a 1 in the center space. For example, if the output file contained:

then this rule would say that if a cell is surrounded by
	0 1
then at the next time step, the center cell would be set to a 1. Otherwise that center cell will become a 0. The state of a cell at time t+1 depends only on the state of its 8 neighbors at time t.

Step 4: Notice that there are occasionally sets of 3 dashes in the output. Conclude that these are separators between sets of rules.

Step 5: Write a program to perform a simulation game similar to Conway's Game of Life, using the sets of rules as described above. The flavor text, and the starting image you make as in step 6 below, hint that you should use periodic boundary conditions, i.e., take the game board as a torus.

Step 6: Compute the initial starting array for the game, using the original file "this" as a binary 2-dimensional array. The size of the file is 157009 bytes, which factors into a product of the primes 197 and 797, giving the width and height of the grid. There is a newline character at the end of each 197 character line, which hints at the way to take the dimensions. (The newlines are not discarded when using the data as a grid.) To make the byte data into a binary array, take the lowest order bit of each character, the result of which looks like this: (image1). If one looks at the full 8-bit character array as a grayscale image, image8, one will see a hint which should help one narrow it down, so to speak.

Step 7: For each of the 11 rule sets in the output file, run the life program written in step 5. Notice that they all end up with the whole grid dying, i.e., every cell has the value 0, and after that there is no change. Notice that in each of the 11 cases, just before the board enters the state of "all dead", there is one cell left alive. Note where that cell is. Example, rule set 7 gives the following sequence of boards (shown as images):

Step 8: For each of the 11 cells identified in step 7, look at the character in that position in the original "this" array. Taken in the order of the rule sets in step 4, these characters will spell out the puzzle answer.

Rule set Number of steps
to termination
Last live cell
Letter in this
1 3 (152, 613) A
2 51 (108, 413) F
3 96 (71, 238) T
4 8 (98, 515) E
5 106 (73, 412) R
6 34 (96, 22) E
7 6 (2, 588) F
8 3 (167, 736) F
9 315 (85, 430) E
10 332 (51, 399) C
11 8 (32, 12) T

Final answer: AFTEREFFECT.