Scoring
Scoring for Imagine
Cup Algorithm Round 2 is based on the performance of your submitted algorithm.
You will have from
April 5, 2006 to May 9, 2006 to work on your algorithm. During this period you can
test your algorithm as many times as you wish, using either a local test application
or by uploading to the official benchmark server, and using a set of practice boards.
After May 9, we will take the algorithm which you have designated as your best algorithm
and run it against a final series of 32x32 boards. These final boards will be randomly
generated, and their exact configuration will not be known in advance. Your final
score will be determined by your algorithm’s performance against this final series
of boards. The formula used will be
Score = (Moves + (100
x Time)) / NumBoards
where
Moves is the total number of moves required by your algorithm to
solve all boards.
Time
is the running time of your algorithm across all boards, in seconds, as measured on the benchmark server. This counts
all time spent inside your Move method, including any time required by calls you
make to the simulation engine.
NumBoards
is the number of boards that the algorithm was run on. This is 1
when using the Client Runner and 20 when using the benchmark server.
The six contestants
with the lowest (best) scores will advance to the finals.
Competition rules
Contestants must adhere
to the following rules of competition, in addition to the general rules of the Imagine
Cup Competition. We reserve the right to disqualify anyone who, in our opinion,
has violated these rules.
- All work must
be exclusively that of the individual contestant.
- Each contestant
may make work on and submit only one assembly (multiple accounts are not allowed).
- Scores must be achieved only through the use of well-behaved
.NET assemblies which focus exclusively on optimizing the number of moves and running
time to solve the boards. It is prohibited to attempt, by any means, to manipulate
the operation or scoring on the benchmark server other than through such well-behaved
assemblies.
Additionally, submitted assemblies must conform to the following restrictions:
- The assemblies must be .NET 2.0 managed assemblies which expose a Move() method.
- The submitted algorithm must be "clean", defined as follows: They must use only
a single execution thread on the processor and up to 256 MB of memory to determine
the move sequence for a particular board. To the extent a submitted assembly achieves
a higher score than other assemblies, it must do so based strictly on the quality
of its algorithm, and in particular its ability to produce a more optimal move sequence
and/or do it in less time, operating in the same conditions as the other assembly.
In particular, the following techniques are explicitly disallowed:
- Multithreaded solutions.
- Any access to machine resources other than the processor and memory, including files,
registry, or network resources.
- Any technique which effectively calculates moves for a particular board without
being included in the timing results.
- Any saving of state across board runs.
- Any attempt to manipulate the runtime priority of the thread or of other machine
processes.
- Use of .NET reflection, or any attempt to discover or manipulate the
runtime environment of the assembly.
- Any attempt to manipulate assembly results and score other than via a "clean" algorithm,
as defined above.
To help enforce this rule, contestants must supply buildable source for
their assemblies on request.
- Your assembly must conform to the following restrictions, when run on the benchmark
server (for practice runs as well as the final run):
- Total number of moves can not exceed the following limits, by board size:
- 8x8: 150
- 16x16: 600
- 32x32: 2300
- Total "in process" time (time spent within your Move method) must be less than 20
seconds per board.
- Total clock time for running your assembly must be less than 30 seconds per board.
- Total memory used by your assembly must be less than 256 MB.