diff --git a/2005/anon/README.md b/2005/anon/README.md index 185057e91..23e0f8be2 100644 --- a/2005/anon/README.md +++ b/2005/anon/README.md @@ -4,8 +4,8 @@ make ``` -NOTE: there is an alternate version for vi(m) like movements. See [alternate -version](#alternate-code) below. If your terminal has problems with the +**NOTE**: there is an alternate version for vi(m) like movements. See [Alternate +code](#alternate-code) below. If your terminal has problems with the `stty(1)` commands try: ``` @@ -62,7 +62,7 @@ something strange. This might also happen if you specify excessively large board dimensions. Try `100 100 100` for instance and see what happens! -## Alternate version: +## Alternate code: The alternate version uses `vi(m)` like movement keys. @@ -84,14 +84,19 @@ To compile the version without `stty(1)`: Use `anon.alt` as you would `anon` with the change in movements: -``` - k | Move empty spot up - h | Move empty spot left - j | Move empty spot down - l | Move empty spot right - J | Move empty spot forwards - K | Move empty spot backwards -``` + +* `k` + - Move empty spot up +* `h` + - Move empty spot left +* `j` + - Move empty spot down +* `l` + - Move empty spot right +* `J` + - Move empty spot forwards +* `K` + - Move empty spot backwards ## Judges' remarks: @@ -130,9 +135,9 @@ To play with a 3D board, do something like this: ./anon 3 3 3 ``` -**WARNING: do NOT run the program with more than 3 command-line arguments. +**WARNING**: do NOT run the program with more than 3 command-line arguments. This will trigger a bug that will cause it to crash or do something strange. -:-)** +:-) Also, resist the temptation to create very large puzzles. The program does not attempt to resize your terminal for you, and will produce confusing output. It @@ -143,34 +148,38 @@ The empty space on the board is represented by a space filled with `#` characters instead of digits. To slide the tiles around, use the following keys: -``` - i | Slide the tile above the current empty space downwards. - j | Slide the tile to the left of the current empty space to the right. - k | Slide the tile below the current empty space upwards. - l | Slide the tile to the right of the current empty space to the left. - o | Slide the tile behind the current empty space forwards. - n | Slide the tile in front of the current empty space backwards. -``` +* `i` + - Slide the tile above the current empty space downwards. +* `j` + - Slide the tile to the left of the current empty space to the right. +* `k` + - Slide the tile below the current empty space upwards. +* `l` + - Slide the tile to the right of the current empty space to the left. +* `o` + - Slide the tile behind the current empty space forwards. +* `n` + - Slide the tile in front of the current empty space backwards. -To quit the game: - -``` - q | Quit the game. -``` +To quit the game, hit `q`. Note that, for example, sliding the tile above the current empty spot downwards will fill up the empty spot, and create a new empty spot above where the current empty spot was. Hence, you could think of the movement keys in terms of how they effectively "move" the empty spot: -``` - i | Move empty spot up - j | Move empty spot left - k | Move empty spot down - l | Move empty spot right - n | Move empty spot forwards - o | Move empty spot backwards -``` +* `i` + - Move empty spot up +* `j` + - Move empty spot left +* `k` + - Move empty spot down +* `l` + - Move empty spot right +* `n` + - Move empty spot forwards +* `o` + - Move empty spot backwards **NOTE:** as a measure of alleviating counter-productivity due to addiction to this game, particularly for those hardcore gamers who insist on solving a @@ -315,13 +324,13 @@ To avoid having to handle issues of `int` sizes, memory alignment, what exactly is on the stack between successive locations of `argc`, etc., the program (ab)uses the fact that `argc` must necessarily be allocated on an aligned address, and therefore, the range of memory between two `argc`s is aligned, and -therefore safe to use as an array of `long`s.[\*] The program also compares the +therefore safe to use as an array of `long`s.[^1] The program also compares the pointers as `long*` pointers, so that it will not have to deal with mapping bytes to larger types. The initial memory allocation is done by recursively calling `main()` until there is enough space on the stack (the exact number of recursive calls is, of course, architecture-dependent). -[\*] `long` was chosen instead of `int`, in order to skirt around pointer-size +[^1]: `long` was chosen instead of `int`, in order to skirt around pointer-size issues on architectures like ia64. It really can be made anything large enough to hold both `int`s and pointers. `:-)` @@ -330,10 +339,10 @@ array (pun intended), the program begins its real code. It uses `argc` to keep track of what it's supposed to be doing (since `main()` is the only function), and `argv` to point to the base of this array (which is computed differently based on how the architecture allocates the stack). Since this fills up the -only two variables in the program, everything else is stored in the `MASS` [\*\*] +only two variables in the program, everything else is stored in the `MASS` [^2] array. -[\*\*] for "Memory Allocated by Stack Smashing" :-) +[^2]: for "Memory Allocated by Stack Smashing" :-) Note that from this point on, all bets are off as to what the contents of the runtime stack are below the current recursive call to `main()`. We are @@ -450,29 +459,46 @@ program, and what the various state numbers are meant to do: #### MASS usage map -``` - 0 | Function return value - 1 | Function argument 1 - 2 | Function argument 2 - 3 | Function argument 3 - 4 | Scratch register 1 - 5 | Scratch register 2 - 6 | Scratch register 3 - 7 | Scratch register 4 - 8 | Value of original argv :-) - 9 | Value of original argc :-) - 11 | Zero register (always set to 0) - 12 | Width of board - 13 | Length of board - 14 | Height of board - 15 | Current position of hole - 16 | Random seed for rand_r(3) - 18 | Scratch register used by state 18 :-) - 31 | field width for printing tiles - 32 | Start of board data -``` +* `0` + - Function return value +* `1` + - Function argument 1 +* `2` + - Function argument 2 +* `3` + - Function argument 3 +* `4` + - Scratch register 1 +* `5` + - Scratch register 2 +* `6` + - Scratch register 3 +* `7` + - Scratch register 4 +* `8` + - Value of original argv :-) +* `9` + - Value of original argc :-) +* `11` + * Zero register (always set to 0) +* `12` + - Width of board +* `13` + - Length of board +* `14` + - Height of board +* `15` + - Current position of hole +* `16` + - Random seed for rand_r(3) +* `18` + - Scratch register used by state 18 :-) +* `31` + - Field width for printing tiles +* `32` + - Start of board data -(**CAVEAT:** not all of these mappings ended up in the final version of the +(**CAVEAT**: not all of these mappings ended up in the final version of the program, mainly due to size limitations which entailed the trimming off of a lot of neat features in the game. It is left as an exercise for the reader to figure out which of these are actually used.) @@ -484,24 +510,38 @@ to be on all tested architectures.) #### State number assignments -``` - 1 | showhelp - 2 | showhelp - 3 | is 2D: start init - 4 | is 3D: start init - 5 | find allocation type - 6 | MASS init, bottom-up - 7 | MASS init, top-down - 8 | main program - 9 | generate() outer loop - 13 | render() - 14 | render() loop - 15 | exit(0) - 16 | pick a tile that hasn't occurred yet - 17 | inner loop of 16. - 18 | main loop - 19 | checkwin() loop -``` +* `1` + - `showhelp` +* `2` + - `showhelp` +* `3` + - is 2D: start init +* `4` + - is 3D: start init +* `5` + - find allocation type +* `6` + - MASS init, bottom-up +* `7` + - MASS init, top-down +* `8` + - main program +* `9` + - `generate()` outer loop +* `13` + - `render()` +* `14` + - `render()` loop +* `15` + - `exit(0)` +* `16` + - pick a tile that hasn't occurred yet +* `17` + - inner loop of `16`. +* `18` + - main loop +* `19` + - `checkwin()` loop Note that some of the manually-implemented states (those not implemented by `do()`) respond to multiple state numbers. Also note that states 1-4 diff --git a/2005/anon/index.html b/2005/anon/index.html index 6def24221..b69b26d6b 100644 --- a/2005/anon/index.html +++ b/2005/anon/index.html @@ -409,8 +409,8 @@ Location: ZZ - Unknown location

To build:

    make
-

NOTE: there is an alternate version for vi(m) like movements. See alternate -version below. If your terminal has problems with the +

NOTE: there is an alternate version for vi(m) like movements. See Alternate +code below. If your terminal has problems with the stty(1) commands try:

    make anon-no_stty

This will compile anon.c as anon to not use @@ -438,7 +438,7 @@ hook you) and spending too much time playing. :-)

If you specify more than three args the program might also crash or do something strange. This might also happen if you specify excessively large board dimensions. Try 100 100 100 for instance and see what happens!

-

Alternate version:

+

Alternate code:

The alternate version uses vi(m) like movement keys.

Alternate build:

    make alt
@@ -446,12 +446,32 @@ dimensions. Try 100 100 100 for instance and see what happens!

    make alt-no_stty

Alternate use:

Use anon.alt as you would anon with the change in movements:

-
    k | Move empty spot up
-    h | Move empty spot left
-    j | Move empty spot down
-    l | Move empty spot right
-    J | Move empty spot forwards
-    K | Move empty spot backwards
+

Judges’ remarks:

Taking the 4x4 board with 15 tiles to a whole new level, this entry takes this puzzle to a whole new dimension! While you puzzle out this puzzle, we invite @@ -473,9 +493,9 @@ For example, to play the original version of the Fifteen Puzzle:

    ./anon 4 4

To play with a 3D board, do something like this:

    ./anon 3 3 3
-

WARNING: do NOT run the program with more than 3 command-line arguments. +

WARNING: do NOT run the program with more than 3 command-line arguments. This will trigger a bug that will cause it to crash or do something strange. -:-)

+:-)

Also, resist the temptation to create very large puzzles. The program does not attempt to resize your terminal for you, and will produce confusing output. It may also crash on you if you insist on running it with excessively large board @@ -483,24 +503,63 @@ dimensions. :-) (10x10x10 is considered a safe upper limit.)

The empty space on the board is represented by a space filled with # characters instead of digits. To slide the tiles around, use the following keys:

-
    i | Slide the tile above the current empty space downwards.
-    j | Slide the tile to the left of the current empty space to the right.
-    k | Slide the tile below the current empty space upwards.
-    l | Slide the tile to the right of the current empty space to the left.
-    o | Slide the tile behind the current empty space forwards.
-    n | Slide the tile in front of the current empty space backwards.
-

To quit the game:

-
    q | Quit the game.
+ +

To quit the game, hit q.

Note that, for example, sliding the tile above the current empty spot downwards will fill up the empty spot, and create a new empty spot above where the current empty spot was. Hence, you could think of the movement keys in terms of how they effectively “move” the empty spot:

-
    i | Move empty spot up
-    j | Move empty spot left
-    k | Move empty spot down
-    l | Move empty spot right
-    n | Move empty spot forwards
-    o | Move empty spot backwards
+

NOTE: as a measure of alleviating counter-productivity due to addiction to this game, particularly for those hardcore gamers who insist on solving a 10x10x10 puzzle during work hours, and also to give an upper bound to user @@ -612,22 +671,18 @@ call is greater or less than in the parent call.)

is on the stack between successive locations of argc, etc., the program (ab)uses the fact that argc must necessarily be allocated on an aligned address, and therefore, the range of memory between two argcs is aligned, and -therefore safe to use as an array of longs.[*] The program also compares the +therefore safe to use as an array of longs.1 The program also compares the pointers as long* pointers, so that it will not have to deal with mapping bytes to larger types. The initial memory allocation is done by recursively calling main() until there is enough space on the stack (the exact number of recursive calls is, of course, architecture-dependent).

-

[*] long was chosen instead of int, in order to skirt around pointer-size -issues on architectures like ia64. It really can be made anything large enough -to hold both ints and pointers. :-)

After the stack is deemed to have grown deep enough to be a sufficiently long array (pun intended), the program begins its real code. It uses argc to keep track of what it’s supposed to be doing (since main() is the only function), and argv to point to the base of this array (which is computed differently based on how the architecture allocates the stack). Since this fills up the -only two variables in the program, everything else is stored in the MASS [**] +only two variables in the program, everything else is stored in the MASS 2 array.

-

[**] for “Memory Allocated by Stack Smashing” :-)

Note that from this point on, all bets are off as to what the contents of the runtime stack are below the current recursive call to main(). We are overwriting frame pointers, return addresses, etc., with data. Hence, the @@ -717,26 +772,85 @@ key press. What could be more fun than to define such a case in terms of a are the mappings of various locations of the MASS to their usage in the program, and what the various state numbers are meant to do:

MASS usage map

-
    0  | Function return value
-    1  | Function argument 1
-    2  | Function argument 2
-    3  | Function argument 3
-    4  | Scratch register 1
-    5  | Scratch register 2
-    6  | Scratch register 3
-    7  | Scratch register 4
-    8  | Value of original argv :-)
-    9  | Value of original argc :-)
-    11 | Zero register (always set to 0)
-    12 | Width of board
-    13 | Length of board
-    14 | Height of board
-    15 | Current position of hole
-    16 | Random seed for rand_r(3)
-    18 | Scratch register used by state 18 :-)
-    31 | field width for printing tiles
-    32 | Start of board data
-

(CAVEAT: not all of these mappings ended up in the final version of the +

+

(CAVEAT: not all of these mappings ended up in the final version of the program, mainly due to size limitations which entailed the trimming off of a lot of neat features in the game. It is left as an exercise for the reader to figure out which of these are actually used.)

@@ -745,22 +859,72 @@ the MASS, because otherwise they may overwrite their original value memory allocation code saves them. Index 8 is deemed “safe enough”. (It seems to be on all tested architectures.)

State number assignments

-
    1  | showhelp
-    2  | showhelp
-    3  | is 2D: start init
-    4  | is 3D: start init
-    5  | find allocation type
-    6  | MASS init, bottom-up
-    7  | MASS init, top-down
-    8  | main program
-    9  | generate() outer loop
-    13 | render()
-    14 | render() loop
-    15 | exit(0)
-    16 | pick a tile that hasn't occurred yet
-    17 | inner loop of 16.
-    18 | main loop
-    19 | checkwin() loop
+

Note that some of the manually-implemented states (those not implemented by do()) respond to multiple state numbers. Also note that states 1-4 conveniently correspond to what the program should do when 1-4 arguments are @@ -784,6 +948,16 @@ smiley. :-)

--> +
+
+
Footnotes
+
    +

  1. long was chosen instead of int, in order to skirt around pointer-size +issues on architectures like ia64. It really can be made anything large enough +to hold both ints and pointers. :-)↩︎

    2. +

  2. for “Memory Allocated by Stack Smashing” :-)↩︎

    3. +
+