These rules are as paraphrased by me,
Gordon Cormack in the fall
of 1998, and revised January 2001. I believe the paraphrasal is accurate, but I'm providing no
warranty. Here's an
official ACM page that contains similar information.
This year, the Association for Computing
Machinery (ACM) holds its 23rd annual
Programming Contest, open to teams of three students from
postsecondary institutions throughout the world.
Structure of the Contest
Regional contests are conducted throughout the fall. Colleges and
universities are invited to send a team or teams to the regional contests.
These contests are held at various institutions in the individual regions
and are conducted autonomously, with separate problem sets and judging.
One or more teams from each region (depending on the number of participants)
qualifies to compete in the World Finals, held the following spring.
Details on venues for the regional and final competitions can be found
at the contest web site.
Team Composition and Eligibility
A team consists of three full-time students from the same institution.
Students on normal work or vacation terms are eligible provided they were
registered in a full-time program prior to the work or vacation term and
are continuing their program.
At least two of the students must be undergraduates; that is, they must
not hold a post-secondary degree in any subject. One student may be
a graduate student provided he or she does not hold a graduate degree and
has not completed 2 years of graduate study.
Students who compete in the World Final (but not those who compete in the
Regionals) are required to become
student members of the ACM.
Students who have participated in two World Final competitions are
ineligible to participate in further Regional or World Final competitions.
Each team has access to one computer work station, and is given (on paper) a set of
independent problems which may be solved in any order. Each solution is
a program, composed by the team at the work station, in
one of a set of available languages. Regional contests provide C, C++,
and Java compilers, and may provide compilers for other languages.
Teams may bring books, notes, or papers for reference, but may not use
any electronic or programmable device other than the single
computer work station supplied by the contest. Team members may communicate
with each other and with contest officials but not with anyone else.
Contest officials will assist teams with system problems but all
questions relating to the contest problem set must be submitted and
answered in writing.
When the team feels that it has solved a problem, the solution (a program
in C, C++, Java, or other available language) is submitted for judging.
It is judged by compiling it and running it against blind test data. If
it produces correct output for all test data, it is judged correct. If
it produces incorrect output it is judged incorrect. If it fails, either
to compile, or to run without error, it is judged incorrect. The judgement
is communicated to the team in as timely a manner as possible, and the
team may re-submit solutions judged incorrect. Re-submissions
for problems already judged correct are ignored.
The contest runs for five hours (or as varied by the region) and consists
of six or more problems. Scores are available on-line to contestants
and to spectators, except that they are not updated during the last hour
of the contest (so as to ensure suspense about the final rankings).
The score is based on three components: the number of problems correctly
solved; the time from the beginning of the contest to the submission of
a correct solution for each problem; the number of incorrect submissions
to a problem for which a correct solution is eventually submitted. First,
teams are ranked in order of the number of correct solutions. When two
or more teams have the same number of correct solutions, they are further
ranked by penalty minutes computed as the sum of:
for each solved problem, the number of minutes from the beginning of the
contest until the correct solution was submitted
for each solved problem, 20 minutes for each incorrect solution submitted
before the correct solution
Consider three teams, Red, Green, and Blue. The contest
starts at 1:00 and the submissions are as follows:
The scores are as follows:
- Red submits a correct solution to Problem A at 2:15.
- Green submits a correct solution to Problem B at 3:00.
- Red submits an incorrect solution to Problem H at 3:01.
- Green submits a correct solution to Problem A at 3:50.
- Red submits a correct solution to Problem H at 4:00.
- Green submits an incorrect colution to Problem A at 4:00.
- Red submits an incorrect solution to Problem G at 4:15.
- Blue submits a correct solution to Problem C at 5:00.
- 1st place: Red with 2 correct, 275 penalty minutes
- 2nd place: Green with 2 correct, 290 penalty minutes
- 3rd place: Blue with 1 correct, 240 penalty minutes
The problems draw from high school and college mathematics and
computing, as well as everyday knowledge and problem solving.
500 sample questions (and an on-line judge) are available at
An article on team strategy is available at