ACM Regionals Results!

Congratulations to Waterloo's two teams, who placed second and first!
Due to a rule to the contrary, both of Waterloo's teams will not advance
to the Finals. Instead, Waterloo B and Case Western A will advance to
the Finals, to be held in Nashville, Tennessee, on 1 March.

There is a possibility that a third team will be selected from this region
to advance to the finals. In that event, Michigan State will go as well.

Much information about the contest is available at the URL
http://maveric0.uwaterloo.ca/ECR94/

- "Tech Guy" Ian Goldberg

Hmm... just curious: the numbers in the far column seem to suggest that CWRU
placed first. How is the ranking tallied?

Thanks,

Tim

--
_ _ __ ___________ ____ ___ __ |"For false Christs and false prophets will
_ ___ \__ _\ \ \/ \ \/ \ \/_/ | appear and perform signs and miracles to
_ __ `--\_\-\_\_\_\_\_\_\_\\_\ | deceive The Elect - if that were possible.
- - `-' `-"-"-"-'-"-"-'`-' | So be on your guard;" - Mark 13:22-23[NIV]

The numbers in the lettered columns are number of minutes until a correct
submission was submitted plus twenty times the number of incorrect
solutions submitted by that team before a correct solution was submitted.
The total column gives the number of correctly answered questions and the
sum of the penalty points. Team B won because they spent less time/made
fewer erroneous submissions on the questions that they solved. The most
important number is the total number of questions correctly answered.

Since I have only properly congratulated Zygo Blaxell (Waterloo team B,
CSC sysadmin, victim of my teasing his girlfriend) and Notre Dame team
B (solved question A before any other team -- without making an error),
I would like to congratulate all of the people that participated.

--
"You're obviously on drugs, Michael Van Biesbrouck
but not the right ones." Oook! UW CSC Librarian
-- bwross about mlvanbie http://csclub.uwaterloo.ca/u/mlvanbie/

From my recollection of competing for Cal Poly Pomona and USC, the
winning team is decided by:

1) The team that completes the most programs in the alloted time
(that's the number on the left)

2) If there's a tie in the number of programs completed, then the
team that used the least amount of time to complete the programs
is used (the number on the right).

When I was competing there was you could submit a program as either
a "test run" (compile and execute against your own data) or a
"judged run" (compile and execute against the judges data. There
was a time penalty for both types of submissions (larger penalty
for "judged runs"). These penalties were important because if
you completed say "n" programs but then submitted some test or
"judged runs" on another program, you would increase your team's
total time.

My Cal Poly Team won a regional contest once because we finished
one program and another team finished the same program before we
did but they attempted to get another program running and incurred
the time penalities which put us in first place. (Note: Back then
1980, our regional contest was done on PUNCH CARDS so the turnaround
time was very long!)

Mike
------------------------------------------------------------------------------
Michael Kimura -- m...@mass.rsg.hac.com -- (310) 607-1570
Hughes Aerospace & Electronics Company (HAEC) -- Radar Systems, El Segundo, CA
P.O. Box 92426, MS: R8/N505, Los Angeles, CA 90009
------------------------------------------------------------------------------

Teams could compile and test against their own data as many times as
they wanted without incurring any penalties. The second difference
in this case was that teams are only given penalties on questions
that they complete. A program submission that is judged incorrect adds
20 minutes to the penalty time for the question.

At the University of Waterloo we were able to devote 8 Suns (with 17
processors between them, I believe) to the contest , so we did not
really need to have time penalties for all compiles. All of the
contests that I have seen administered locally have followed the same
judging scheme. Are other current regionals run in the same manner?

At the last contest you would have lost. I guess that this encourages
somewhat different programming attitudes, and both have merit. I
wouldn't want to penalize teams for typing mistakes that result in
syntactically incorrect programs, however.

Fortunately the UW Computer Science Club was able to provide a
friendlier environment, although there were some complaints on turn
around times for typed characters :)

The rules were different back in 1979/80. A team was charged for every run,
(10 minutes for "test", 20 minutes for "judged"), regardless of whether or not
the problem was ultimately solved. Of course, number of solutions was still the
primary factor in ranking teams. There were four person teams, six hours, and
only four problems; the average difficulty level of each problem was therefore
higher. The charges for test runs went away in around 1981/82 or so, as
computers became less expensive; judged run penalties only applying to solved
problems has only been the rule universally for the last four or five years.
(You were allowed to get a listing of your card deck in 1980 using off-line
equipment without "charge".)

An argument can still be made that a team should be charged for every judged
run, regardless of whether or not they eventually solve the problem they were
attempting. When you submit a program for judging, you are asserting that your
code is "ready for release"; and if it turns out to have errors your team
should be penalized. This would have the side effect of reducing the load on
the judges somewhat, and add a different type of "gamesmanship" to the contest:
"If our program works, we move up in the standings by virtue of having solved
another problem; if not, we might drop when our 20 minute penalty is added." A
team might consider how big their lead is over the next team below them, and
their confidence level in their code before deciding to submit a judged run.

Marc K. Furon
Director, Southern California Region
ACM International Collegiate Programming Contest

(the scorekeeper in the 1979/80 contest referred to above)

...no comment.

Amy

If that were the case, there would be an incentive to stop trying at
some point. I believe the current scoring is better: if penalties are
only assessed against solved problems, you can only advance, never
reduce, your standing by attempting further problems. The penalties
discourage over-use of the judging system for cheap debugging.

Peter F. Klammer, Racom Systems Inc. PKla...@ACM.Org
6080 Greenwood Plaza Boulevard (303)773-7411
Englewood, CO 80111 FAX:(303)771-4708

That was the case when I was competing at both the regional and
national contests. I remember at one regional contest after completing
our last program we looked at the time remaining and decided that we
decided that there was probably not enough time to complete another
program and if we tried to work on one, the time penalty might drop
our team's standing. We decided to sit and do nothing and by doing
so we moved up ahead of another team that submitted one or more judged
runs.

This same thing happened at the 1980 National Finals. We were all in
this LARGE hall, each team given a table and terminal. Our team didn't
do so well; but I distinctly remember that one team got ahead and decided
it wasn't worth trying to submit another program and began playing cards!
Too bad for them that another team actually did submit a correct solution
and the card playing team ended up in second place.

P.S. The *ONLY* language used back then was FORTRAN IV.