Move 1988-2004 entries into subdirs
We we move 1988-2004 entries from all of a year's winning entries in a single directory to each winner being in their own sub-directory under the given year directory.
This commit is contained in:
Landon Curt Noll committed
1 parent
1e82e8aa3e
commit
d2a42f42e8
478 files changed
No files matched your search
@@ -0,0 +1,53 @@
|
||||
|
||||
|
||||
static signed char a[] = {0x69,
|
||||
110, 118, 97, 108, 105, 0x64, 1-1,
|
||||
0x6d, 111, 118, 101, 1<<1<<1<<1<<1<<1,
|
||||
114, 105, 0x6e, 103, 32, 'o'/3, 100,
|
||||
32, 102, 114, 111, 0x6d, 32, 115, 116,
|
||||
97, 100-001, 107, 32,37, 2*'2', '@'>>1,
|
||||
116, '%' + '%' + '%','w'-'W',115, 0x74,
|
||||
97, 3*'!', 107, 'q' - 'Q', 37, 10*'\n',
|
||||
10, 0}, * b = a + (1<<1<<1<<1), * w, x,
|
||||
*q, c, r; int main(int d, char *e []) {
|
||||
return q = (signed char *)(e+1+1), (r =
|
||||
e[0] && e[1] ? 0 : 0 * puts (a) + 1) ||
|
||||
(r = e[1<<1] && d != 1 <<1 && 0 * puts(
|
||||
a) + 1) || e[1- -1] || (r = atoi(e[1])
|
||||
< -0200 || atoi (e [1]) > 0x7f || ( x =
|
||||
atoi( e[1] ) ) == 0 ? 0 * puts(a) + 1 :
|
||||
0) || e [1- -1] || (x- -x > 1-1 ? (q[0]
|
||||
= x, q[1] = q[3] = 1, q[2] = 2) : (
|
||||
memset ( w = ( signed char * )
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
malloc(-x), '1', -x), puts (w),
|
||||
q[0] = x, q[1] = '0', q[2] = q[3] =
|
||||
0)), r || (q[3] ? (c = 6 - q[1] - q[2],
|
||||
(q[0] != 1) ? q[0]-- , d = q[2], q[2] =
|
||||
c, main(2, e), c = q[2], q[2] = d, q[0]
|
||||
++ : 0, printf(b, q[0], q[1], q[2]), (q
|
||||
[0] != 1) ? q[0]--, d = q[1],q[1] = c ,
|
||||
main(2, e), c = q[1], q[1] = d, q[0] ++
|
||||
: 0) : - 1 - q[0] - 1 == 0 ? (w[- x - 1
|
||||
- (q[1] & 1 ^ 1)] = q[1], puts (w), w [
|
||||
- x - 1 - (q[1] & 1)] = q[1], puts(w) )
|
||||
: - 1 - q[0] == 0 ? (w[- x - 1] = q[ 1
|
||||
], puts(w)) : (q[0] += 1 + ( q[1] & 1
|
||||
^ 1), main(2, e), q[0] -= 1 + ( q
|
||||
[1] & 1 ^ 1), q[1] & 1 ? (q
|
||||
[0]+=1+1, q[1]^=1, main
|
||||
(2, e), q[1]^=1, q[0]-=1
|
||||
+1) : 0, w[q[0] - x] = q
|
||||
[1], puts(w), q[1] & 1 ?
|
||||
0 : (q[0]+=1+1, q[1]^=1,
|
||||
main (2, e), q[1]^=1, q
|
||||
[0]-=1+1), q[0] += 1 +
|
||||
(q[1] & 1),main(2,e)
|
||||
, q[0] -= 1 + (q[1]
|
||||
& 1) ) ), r; }
|
||||
@@ -0,0 +1,9 @@
|
||||
The Towers of Hanoi is a puzzle consisting of three posts
|
||||
and several rings of various sizes. The initial
|
||||
configuration of the game is that all the rings are stacked
|
||||
in decreasing order of size on one post. The object of the
|
||||
game is to move all the rings from one post to another
|
||||
subject to two rules: only one ring can be moved at a time,
|
||||
and at no time can one ring be placed on top of a smaller
|
||||
ring. The number of steps necessary to solve this puzzle is
|
||||
exponential in the number rings.
|
||||
@@ -0,0 +1,141 @@
|
||||
The Patience puzzle, probably of Chinese origin, consists of
|
||||
an iron U-shaped piece and several rings that link around
|
||||
it. The physical shape of the puzzle is very difficult to
|
||||
describe verbally, but here is an attempt.
|
||||
|
||||
This description of the puzzle is presented as a set of
|
||||
instructions for constructing the puzzle. Start with a flat
|
||||
piece of iron about 15 centimeters long by about two
|
||||
centimeters wide. Drill six holes in the piece of iron.
|
||||
Through each hole, place a rod. The rod should have a
|
||||
diameter slightly less than that of the hole so that it can
|
||||
move freely. One end of the rod is like the head of a nail
|
||||
and is larger than the hole to prevent it from coming free.
|
||||
The other end is looped around a metal ring with a diameter
|
||||
of about five centimeters. This completely prevents the
|
||||
iron rod from separating from the base. Each rod, in
|
||||
addition to going through the iron base, goes through the
|
||||
ring at the end of the rod to its right. The only rod free
|
||||
of this restriction is the rightmost rod. What has been
|
||||
described so far is one of the two components of the puzzle.
|
||||
|
||||
The other component is another iron rod shaped like a U.
|
||||
the U is as long from the tips to the base as the original
|
||||
piece of iron with the holes in it. The ends of the U are
|
||||
looped around another ring of about five centimeters in
|
||||
diameter. In the puzzle's initial configuration, the U is
|
||||
placed through the rings so that it is held in place by the
|
||||
iron rods. Imagine starting with the U piece before the
|
||||
iron loop is placed at the end. Slide the legs of the U
|
||||
through the loops so that the iron rods securing the loops
|
||||
to the metal strip go up the center of the U. Placing the
|
||||
final ring at the ends of the U prevents it from coming out.
|
||||
The object of the puzzle is to free the U-shaped piece from
|
||||
the other piece.
|
||||
|
||||
The following illustration (sideways) shows a three-ring
|
||||
case of this puzzle. If you look carefully, you can see
|
||||
that the first ring could be lifted over the edge of the U
|
||||
and slid down through the center of the U, thereby freeing
|
||||
the U from the first iron rod. The second ring can also be
|
||||
freed in the initial configuration since it is already over
|
||||
the rod for the first ring. The third ring cannot be moved,
|
||||
however, since it is blocked by the iron rod two which the
|
||||
first ring is attached. If the first first is removed, then
|
||||
the third ring is no longer blocked by the first ring's iron
|
||||
rod and can be removed freely. The second ring, however
|
||||
cannot be moved if the first ring is gone because it will
|
||||
then be blocked by the first ring in its new position
|
||||
outside of the U.
|
||||
|
||||
Here is an illustration of the three-ring case. The bottom
|
||||
of the puzzle is on the left-hand side of the page.
|
||||
|
||||
|
||||
|
||||
//==\\
|
||||
|| ||
|
||||
|| ||
|
||||
*****||** ||
|
||||
*** || ***||
|
||||
** || *||
|
||||
|\ ** || ||**
|
||||
| \ *** || || ***
|
||||
| \ *** | || ===
|
||||
| \ *** || // * \\
|
||||
| \ *** || || ** ||
|
||||
| | | ********** ||
|
||||
| | || || || ||
|
||||
| | || || || ||
|
||||
| | *****||** || \\ ||
|
||||
| | |\ | *** || ***|| ||
|
||||
|==| |=========-**-===-||-============//
|
||||
|==| |=========-**-===-||-===========//
|
||||
| | \| | *** || || ***
|
||||
| | *** || || ===
|
||||
| | ***| || // * \\
|
||||
| | *** || || ** ||
|
||||
| | ||********** ||
|
||||
| | || || || ||
|
||||
| | *****||** || \\ ||
|
||||
| | |\ | *** || ***|| ||
|
||||
|==| |=========-**-===-||-============//
|
||||
|==| |=========-**-===-||-===========//
|
||||
| | \| | *** || || ***
|
||||
| | *** || || ===
|
||||
| | ***| || // * \\
|
||||
| | *** || || ** ||
|
||||
| | ||********** ||
|
||||
| | || || || ||
|
||||
| | || || || ||
|
||||
| | | || || \\ ||
|
||||
| | |\ | || || ||
|
||||
|==| |================-||-============//
|
||||
|==| |================-||-===========//
|
||||
| | \| | || ||
|
||||
| | || ||
|
||||
| | || ||
|
||||
| | || ||
|
||||
\ | || ||
|
||||
\ | \\ ||
|
||||
\ | \\ ||
|
||||
\ | \\ ||
|
||||
\ | \\||
|
||||
\| \||
|
||||
|
||||
This puzzle takes other forms as well. One such puzzle is
|
||||
called "Spin-Out". This puzzle consists of one plastic
|
||||
piece that encases another piece that can slide in and out
|
||||
of it. The movement of the smaller piece is restricted by
|
||||
discs that, when turned to one angle, lock the smaller piece
|
||||
inside the larger one and, when turned the other way, allow
|
||||
it to move. This puzzle is as difficult to describe as the
|
||||
first and, since I don't have one in front of me, I will not
|
||||
attempt to describe it. The object of this puzzle is to
|
||||
free the smaller piece from the larger one. The other
|
||||
puzzle that is like this one consists of a cylinder with
|
||||
rods protruding from the top. The rods can be slid from the
|
||||
center to the edge of the cylinder constrained by a series
|
||||
of discs in the center. The discs have cuts in them that
|
||||
allow some rods to move and force others in one place based
|
||||
on the relative rotations of the discs. The object here is
|
||||
to move all the rods from the inside to the outside.
|
||||
|
||||
What makes these puzzles similar is that the physical shapes
|
||||
of the puzzles put the same restrictions on the movement of
|
||||
the pieces. Specifically, there is always one piece that is
|
||||
free to move. The only other piece that is free to move is
|
||||
the second one that is still attached to the base it is
|
||||
trying to be freed from. In the case of the original
|
||||
puzzle, consider the rings numbered from 1 to 6 with ring 1
|
||||
being the one at the closed send of the U. Ring 1 can
|
||||
always be removed from or added to the U. In the initial
|
||||
state, when all rings are around the U, ring 2 is the other
|
||||
one that can be moved because it is second. If ring 1 is
|
||||
removed, then only two operations are possible: the
|
||||
restoration of ring 1 and the removal of ring 3. This is
|
||||
because ring 1 is always movable, and ring 3 is currently
|
||||
the second ring still attached to the U. This constraint
|
||||
leads to a recursive solution to the puzzle. Like the
|
||||
Towers of Hanoi, the number of steps to solve this puzzle is
|
||||
exponential in the number of rings.
|
||||
@@ -0,0 +1,79 @@
|
||||
Best Obfuscated Algorithm:
|
||||
|
||||
E. Jay Berkenbilt
|
||||
Engineering Research Associates
|
||||
1595 Springhill Road
|
||||
Vienna, VA 22182-2235
|
||||
USA
|
||||
|
||||
|
||||
Judges' comments:
|
||||
|
||||
To run:
|
||||
make ejb
|
||||
./ejb level
|
||||
|
||||
where:
|
||||
level a value from -128 to 127
|
||||
|
||||
A negative argument plays the patience puzzle. An argument
|
||||
greater than 0 plays the Tower of Hanoi puzzle. In either case
|
||||
the absolute value of the argument specifies the size of the
|
||||
respective puzzle. Refer to the files ejb.explain1 and
|
||||
ejb.explain2 for more information on these puzzles.
|
||||
|
||||
Of course, you need a different kind of "patience" if you give
|
||||
the argument 127 to this program and want to see it finish!
|
||||
|
||||
|
||||
Selected notes from the author:
|
||||
|
||||
WHAT THIS PROGRAM DOES
|
||||
======================
|
||||
|
||||
./ejb 5 Output: solution to Towers of Hanoi for five rings
|
||||
./ejb -6 Output: solution to the Patience puzzle for six rings
|
||||
|
||||
The format of the output for the Towers of Hanoi case is simply a
|
||||
text description of how to solve the puzzle. For the patience
|
||||
puzzle, the output is a sequence binary codes representing
|
||||
successive states of the puzzle. The rightmost digit represents
|
||||
the first ring. A "1" means the ring is on the U; a "0" means it
|
||||
is off the U. The program prints the word "Invalid" in response to
|
||||
illegal command line parameters.
|
||||
|
||||
MOTIVATION
|
||||
==========
|
||||
Most people who have written software for other people have been
|
||||
asked to count lines of code. Naturally, this brings up the
|
||||
controversial question of exactly what defines a line of code.
|
||||
This program serves to show that counting semicolons will not
|
||||
always provide a meaningful measure of code size. This is
|
||||
especially true in this program where the number of semicolons
|
||||
itself is ambiguous. Does it have two or three? In addition, the
|
||||
only "C" keyword this program uses besides type names and
|
||||
qualifiers is "return", and the only function defined in the code
|
||||
is "main". The level of complexity of the program without multiple
|
||||
semicolons, statements, and functions is achieved by abusing C
|
||||
operators, especially the comma operator. Considerable use of ||,
|
||||
&&, and ? : helps too. In addition, main is called recursively.
|
||||
The null pointer that terminates argv is used to pass additional
|
||||
information into main. Even though the algorithms used by this
|
||||
code are simple, this program is still hard to follow even when
|
||||
indented properly. (It is pretty hard to indent this code
|
||||
reasonably, however.)
|
||||
|
||||
Although this program is has only been tested on UNIX systems but
|
||||
will probably run on just about any machine with an ANSI C
|
||||
compiler. It does not use the C preprocessor at all. The only
|
||||
functions it uses are atoi, malloc, memset, printf, and puts. It
|
||||
does, however, require that the architecture it runs on have bytes
|
||||
that are at least eight bits long and pointers that are at least
|
||||
four bytes long. In addition, it requires an ANSI compiler since
|
||||
it uses "signed char" and ANSI-style function declarations.
|
||||
|
||||
Copyright (c) 1993, Landon Curt Noll & Larry Bassel.
|
||||
All Rights Reserved. Permission for personal, educational or non-profit use is
|
||||
granted provided this this copyright and notice are included in its entirety
|
||||
and remains unaltered. All other uses must receive prior permission in writing
|
||||
from both Landon Curt Noll and Larry Bassel.
|
||||
Reference in new issue
Block a user