Positions 81-131

Note - program listings may not print correctly due to HTML conflicts.
RESET Program entry descriptions (continued)  positions 81-131

---()--()--()--()--()--()--()--()--()--()--()--()--()--()--()--()--()--()---
-()--()--()--()--()--()--()--()--()--()--()--()--()--()--()--()--()--()--()-
---()--()--()--()--()--()--()--()--()--()--()--()--()--()--()--()--()--()---

=================================================================

============== 81 ====================== heres_a_shot =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
      heres_a_shot      1879997   2303   1860    443 5  Raymond Cook
=================
heres_a_shot was submitted by Raymond Cook at cookre@dur.mindspring.com
=================
++ Please summarize the algorithm used by heres_a_shot

Lazy me, just an extract of comments from the plain text code:

Regardless of what the odometer starts out at, the final reading will,
perforce, have no duplicate digits in the odometer.  So, starting with
the beginning odometer reading Z, we look at future odometer readings
whose digits are unique until we find some reading F for which the
four missing digits can be re-arranged to form an integer that is
less than or equal to the total miles traveled between Z and F.

Rollover of the odometer doesn't matter, since we're only concerned with
total miles traveled against which digits don't appear.  Does trip meter
rollover matter?  It would only if one would have to travel more than 9999
miles after reset to achieve unique digits.  This, however, can't happen
since the missing four digits will appear somewhere between 0123 and 9876.


++ What kind of tricks did heres_a_shot use to minimize code length?

Just the basic single character variables, a few DEFINEs, and squished up lines.

++ Here's what I hated (and loved) about this POTM's scoring:

Hated: Not having a box & compiler similar to the target to see how
       various approaches performed

       Not having the time to spend on the problem

Loved: Anticipation of future problems

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?

Company:  BDM, Inc.
Location: US Postal Service, Raleigh, NC
Job:      Software hat: C/Netware API coding
                        Hardware identification software
                        Solve the problems everybody else gve up on

          Hardware hat: Evaluate new PCs for use within the USPS
                        Solve the problems everybody else gve up on
               
Do for fun: (See Job:)

Innermost Secret: I actually enjoy mowing 3 acres without a riding mower.

=================================================================

============== 82 ====================== HAMI =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
              HAMI      1879997   2393   1819    574 3  M.Migdol S.Haller

	Sorry ... no description available for HAMI

=================================================================

============== 83 ====================== Miles_Ahead =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
       Miles_Ahead      1879997   2523   1328   1195 55  Mark Dettinger
==============================================
Miles_Ahead was submitted by Mark Dettinger at 
mdetting@hydra.informatik.uni-ulm.de
==============================================

++ Please summarize the algorithm used by Miles_Ahead

1. By backtracking generate all (151200) 6-digit-numbers A with all digits 
   distinct. For each number A compute the smallest 4-digit number B that 
   uses the 4 remaining digits and the number C=A-B which is the latest 
   time to press the button if you want 10 distinct digits when the 
   6-digit-odometer reads A.

2. Sort the generated triples (A,B,C) by C.

3. A triple (A,B,C) now is ruled out if there is another triple
  (A',B',C') with C'>C and A' 560000

Size trick:  
Nothing really tricky; just the obvious stuff.  No local identifiers
greater than 1 character.  #define's for char, int, return, for, 1000000.

++ Here's what I hated (and loved) about this POTM's scoring:

I really didn't like not knowing the actual scores for all the entrants. 
I'd like to have known how much I had to improve my solution to bump up my
standing!  8) 

On the other hand, I really like the fact that a correct solution was not
too difficult to code up.  There was an immediate feeling of success,
even if the entry wasn't very optimized.

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?

I'm a graduate student at the University of Washington in Seattle, WA,
USA.  I have also been known to work for Cirrus Logic in my off-student
hours, working on XFree86 driver code for their Laguna graphics chips. 

=================================================================

============== 86 ====================== DrivingMissPerl =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
   DrivingMissPerl      1879997   3077    306   2771 74  Andrew Robinson
=================
DrivingMissPerl was submitted by Andrew Robinson at arobinso@zenith.att.com
=================
++ Please summarize the algorithm used by DrivingMissPerl

The idea was to try to get the smallest digits as far to the left on
the odometer, while still being able to produce a valid value on the
trip odometer.  For each position on the odometer, it would pull the
smallest digit still available, and then use the next four smallest
for the trip odometer.  If the trip odometer was now a valid value,
the digit would be used for the odometer; otherwise, the next digit
available would be tried.

The PERL script used a hash table to keep track of what digits were
still available to be placed.  The digits were used as the keys in the
table.

++ What kind of tricks did DrivingMissPerl use to minimize code length?

I really didn't use any tricks...just things like single character
variable names, removal of unnecessary spaces, ranges (0..9 instead of
0,1,2,etc).

++ Here's what I hated (and loved) about this POTM's scoring:

Did a PERL script really have a chance of winning?  I don't think so.
It's just too slow as compared to compiled C code.  Of course, I
realized this before entering, but I decided to use PERL anyway just
to be different :-) Also, I had just learned PERL about one or two
weeks before entering, so I wanted to try out my skills.
 
++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?
 
I work as a software developer (C++) for AT&T in Piscataway, NJ.  My
leisure-time activities include riding my motorcycle, playing
paintball, and inline skating.  As for my innermost secret, I could
tell you, but then I'd have to kill you [now THAT's original, isn't it?]
=================================================================

============== 87 ====================== Telecommuter =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
      Telecommuter      1879997   3326   1205   2121 126  Emerald Chung

	Sorry ... no description available for Telecommuter

=================================================================

============== 88 ====================== The_Wheel =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
         The_Wheel      1879997   3590   2912    678 11  Brian Schleaden

	Sorry ... no description available for The_Wheel

=================================================================

============== 89 ====================== freerun =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
           freerun      1879997   3658   2140   1518 26  Matthew Haley
freerun was submitted by Matthew Haley at mhaley@ids2.idsonline.com
=================
++ Please summarize the algorithm used by freerun

Basically, freerun read in a number and put it in an array of integers and
used this just like the cars odometer.  I would then increase the odometer
and total distance by one then check the odometer to see if all the digits
were different.  if they weren't I'd continue increasing, but if they were
different I would find the four unused digits and place them in an array
from least to greatest and use this as the trip odometer.  If this number
was  more than total distance, I would start increasing the mile odometer
again, but if it was less than total distance, i knew I had found the right
mileage.  I would then subtract the trip odometer from the mileage odometer
to know when to push the reset button.  Then just print the required
numbers.  continue this process until you reach end of file.

++ What kind of tricks did freerun use to minimize code length?

All optional syntax was not used.
keeping in mind the 80 character per line limit, I put as many commands on
one line as c++ would allow, splitting commands that ran over the limit into
two line.

Also put all functions in front of any function that call them, so I
wouldn't waste space prototyping.

++ Here's what I hated (and loved) about this POTM's scoring:

ambivalent(sp?)  towards the scoring. (Unless I didn't win)

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?
Ensign Matthew Haley
Chief Computer Scientist
USS Matrix -2296
mhaley@ids2.idsonline.com


=================================================================

============== 90 ====================== Rallye =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
            Rallye      1879997   4038   3159    879 88  Kroum Savadjiev

	Sorry ... no description available for Rallye

=================================================================

============== 91 ====================== herfstversie =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
      herfstversie      1879997   4704   3694   1010 44  Carl in_'t_Veld
herfstversie was submitted by Carl in_'t_Veld at cveld@digitaal.nl
=================
++ Please summarize the algorithm used by herfstversie
Okey, a very easy one. I read out the starting value and began checking the
decimals if they were all different from left to right. As soon as there is
encountered a double, this one will be increased. This process goes on till
there are 6 different decimals. Now I check if it is a valid solution:
checking if the 4-number-display can reach the other 4 decimals in time. If
it is not, I'll search further for another 6 different decimals. 

++ What kind of tricks did herfstversie use to minimize code length?
None actually, I gave up many compact routines to increase overall speed...

++ Here's what I hated (and loved) about this POTM's scoring:
The performance of the code was relatively not important: it was better to
minimize code length instead of beaming up speed!

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?
I am student, sixth degree at a grammar school. Hobbies are playing the
piano, filosophizing about life etc. Don't have any jobs... My secret is I
rationalize all my feelings: I think about them if they were just things
that can be ordered. 
Carl in 't Veld   cveld@digitaal.nl   http://www.digitaal.nl/~cveld

=================================================================

============== 92 ====================== rsrini =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
            rsrini      1879997   6052    562   5490 99  Ramkumar Srinivasan
=================
rsrini was submitted by Ramkumar Srinivasan at rsrini@iiap.ernet.in
=================
++ Please summarize the algorithm used by rsrini

   1: Open the file passed as a parameter.
   2: Read a number from the file and store it in A.
   3: Copy the value of A to B (ie) B=A.
   4: Repeat step 5 till all digits in B are different.
   5: increament B by 1.
   6: Find the other four digits which does not exist in B.
   7: Form the smallest number possible using the combination of the 
       four digits and store it in C.
   8: if B-C >= A then print the value of B-C and B
       else increment B by 1 and goto step 4.
   9: if EOF of opened file is not reached goto step 2.
   10: Stop

++ What kind of tricks did rsrini use to minimize code length?

1. Never do unwanted things like checking to see if a file is opened properly. 
   For example :

   f=fopen("1.dat","rt");
   if(f==NULL)                     ----------------+
        {                                          |
        puts("File I/O error");                    |--- Unwanted 
        exit(1);                                   | (will cost you 50 bytes)
        }                          ----------------+
   ....
   ...
   ..

2. Never use sensible variable names .
   For example in the current POTM instead of using variables names like :
   
        main_odometer_value, sub_odometer_value, temporary_odometer_value

   use :

        m, s, t

3. Try squeezing as many charecters in a line as permitted (80 charecters in 
   the current POTM). For example change :

   printf("Hello");    
   i++;                   
   printf("\nI=%d",i);    
   k--;                   
   printf("\nK=%d",k);

   to :

   printf("Hello");i++;printf("\nI=%d",i);k--;printf("\nK=%d",k);

++ Here's what I hated (and loved) about this POTM's scoring:

   I was happy to know that my program worked pretty fast in your computer
    it took 3 times longer in mine. 
   I hated seeing nearly 85 people score better than me. (Just joking)

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?
      |        |         |        |                |              |
         |      Student     |                |          I shall mail U   
               |                  |                |             one soon.
            Bangalore,            |       I cant tell U that!
              India               |
                                1.System programming                 
                                2.Graze the Internet                   
                                3.Watch cricket
                                4.Solve POTM problems


=================================================================

============== 93 ====================== push_the_button =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
   push_the_button      1879997   6080   3490   2590 6  Jerry Ryan
=================
push_the_button was submitted by Jerry Ryan at gwryan@bell-labs.com
=================
++ Please summarize the algorithm used by push_the_button
a very simple algorithm that took a setting on the odometer and found the
'next' setting where all digits were different. as soon as the trip counter
miles were less than the difference between start and end, I was done. I
hacked this simple program together pretty quickly and then never had the
time to go back and make it any more elegant...


++ What kind of tricks did push_the_button use to minimize code length?
I never got to the "optimize the program length" stage, more's the pity


++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?
Lucent Technologies in Murray Hill.
Distributed Software Research Department.
For fun I hold elected office in my town. (that's fun?)
My innermost secrets are too innermost for email...

=================================================================

============== 94 ====================== kyeoto_im_tr =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
      kyeoto_im_tr      1879997   6261   1695   4566 30  Salman Nawaz

	Sorry ... no description available for kyeoto_im_tr

=================================================================

============== 95 ====================== miano =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
             miano      1879997   7828   2384   5444 77  John Miano
=================
miano was submitted by John Miano at miano@worldnet.att.net
=================
++ Please summarize the algorithm used by miano

1. From the starting point find the next number where all the odometer 
	digits are unique.
2. From the remaining digits create the smallest number.
3. If the different between 1 and 2 is greater than zero then this is 
	the solution.  Otherwise continue searching.

++ What kind of tricks did miano use to minimize code length?

I made no effort to minimize code length.  After writing the the thing 
I created a much smaller version by using macros, 1 letter variable 
names and the like. As I was doing this I said to myself "What's the point?".  

++ Here's what I hated (and loved) about this POTM's scoring:

Code size is a silly measurement.  .EXE size maybe but source that is stuped.

=================================================================

============== 96 ====================== Reload! =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
           Reload!      1879997   8966    925   8041 8  Phil Darnowsky
On Fri, 29 Nov 1996, Fred Hicinbothem - POTM Master wrote:

=================
Reload! was submitted by Phil Darnowsky at pdarnows@goucher.edu
=================
++ Please summarize the algorithm used by Reload!

It was built around a highly inefficient linear search algorithm.

++ What kind of tricks did Reload! use to minimize code length?

I slash-'n'-burned all of the whitespace out.

++ Here's what I hated (and loved) about this POTM's scoring:

I thought it was reasonable.

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?

I'm a student at Goucher College in Baltimore.  If I had time for 
anything fun, I would spend more time working on my POTM entries.

=================================================================

============== 97 ====================== roadrunner =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
        roadrunner      1879997  10238    436   9802 63  Ramon Clout

	Sorry ... no description available for roadrunner

=================================================================

============== 98 ====================== singularity =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
       singularity      1879997  11766   2982   8784 100  Dave Krofssik
==============================================
singularity was submitted by Dave Krofssik at davek@soft-tek.com
==============================================
++ Please summarize the algorithm used by singularity

My C++ program used a Number class that maintained its data as a
character string and length.  Addition, subtraction, shift operators that
do decimal shifting, and comparison were implemented in this class.  It
also implemented the next_unique(digit_count) method which finds the next
number with all unique digits (of the given digit count), and a
bottom_digits(digit_count) operator which gets a number with only the
low order digits (of the given digit count).

The basic algorithm was as follows:

Starting with new_total = input number + 123 (the minimum distance with
different digits:

1.  Find the next (smallest) number with 6 unique digits from new_total
    ( new_total = new_total.next_unique(6) ).
2.  Compute the trip total from the original
    ( trip_total = new_total-original ).
3.  Compute the smallest low order 4 digits that do not conflict with
    the new total
    ( display_trip = (new_total<<4).next_unique(10).bottom_digits(4)
      [ note that this is a decimal shifting operator ] ).
4.  We are successful if display_trip is less than or equal to
    trip_total (the last place we can press the reset button is after
    the starting point); otherwise, incerment new_total and start over.


The next_unique(digit_count) algorithm was as follows:

Starting with the previous value in old_digits and zero in new_value:

1.  Get the next digit from the old_digits.

2.  If the digit is not already in new_value, add it.  Otherwise, put
    it back in old_digits and increment it.

3.  If there are still digits left in old_digits, then return to the
    first step.

 
++ What kind of tricks did singularity use to minimize code length?

It ran through a shell script and program that did the following:

1.  Ran the C++ preprocessor to eliminate comments and debug code.

2.  Eliminated all unnecessary whitespace (the only necessary
    whitespace is between character tokens and within strings).

3.  Replaced all character tokens (i.e. function and variable names)
    with one or two characters.

4.  Removed all unnecessary semicolons (usually caused by macro
    expansion).


++ Here's what I hated (and loved) about this POTM's scoring:

I don't have any feelings about the scoring, other than I wish I did
better.


COMPANY?

Soft-tek International
Makes charting and graphing products for UNIX and Windows.

LOCATION? Work is in Wichita, Kansas; live in nearby Derby.
JOB? Lead Engineer.  Some management responsibility; mostly development in C++.
DO FOR FUN? Private Pilot.  I rent a Cessna 140 when I can.
=================================================================

============== 99 ====================== frsrst =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
            frsrst      1879997  13709    673  13036 1  Fred Stearns

	Sorry ... no description available for frsrst

=================================================================

============== 100 ====================== ko =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
                ko      1879997  14160   1062  13098 16  Karen Karp
================= 
ko was submitted by Karen Karp at kkarp@cammail2.attmail.com 
================= 
++ Please summarize the algorithm used by ko 
	It's been awhile since I wrote ko, and the code is on a machine that 
is currently off, so I can't look at it.  But, here it is, best I remember.  
It went something like this: 
1)  seperate the numbers out of the current mileage into 
	a1,a2,a3,a4,a5,a6 
2)  start at a1 and check a2-a6 for a repeat of the digit in a1 
3)  if there is a repeat, add 1 to the repeated digit, write 
	1,2,3.. into the remaining digits and start the check again 
4)  Repeat the check for a2 (checking a3-a6) through a5. 
5)  When that is found, build the tripometer by inserting the remaining 
	numbers (lowest first) into b1,b2,b3,b4 to get a 4-digit #. 
6)  Subtract the new tripometer setting from the new odometer setting. 
	If the result is greater then the current setting, you are done. 
	If not,  add one to the new setting and start at step 1 again 
	with the new setting. 

++ What kind of tricks did ko use to minimize code length? 
	I just made all the variables and functions 1 letter and took 
out all the extra spaces. 

++ Here's what I hated (and loved) about this POTM's scoring: 
	I was very neutral about the scoring. 

++ COMPANY?  LOCATION?  JOB? DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS? 
	I work for AT&T in Somerset, NJ.  Mostly, I program in PowerBuilder.  
This is my first POTM, I figured I needed some C practice and this one 
didn't look that hard.  I write code for fun. Why else would I do this POTM
stuff?  I also play inline hockey, snowboard, ski, mountain bike and watch
TV.  I have no secrets. I have no ideas.  I know nothing.	
=================================================================

============== 101 ====================== potm =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
              potm      1879997  21822    974  20848 121  Vishal Awasthi
=================
potm was submitted by Vishal Awasthi at vishala@hotmail.com
=================
++ Please summarize the algorithm used by potm:
MY ALGORITHM:

Open the file;
While (True)
  {
  Read one line;
 
 If EOF then 
    Break
  else  
    store read bytes as Integer in Var :Read1.
 
 While (true)
   {
   If (Read1<5556 OR Read1 >987654) then
    {
    m1=12345;
    m2=6789;  
    break;
    }
 
   If the Read1 is passing the loop for first time Then
     {
     Read1 += Least four digit no.formed by digits 
              exclusive first two digits of read1 (0 inclusive); 
     }  
   {Above increment boost up the performance}
   
   OriginalRead1 = Read1;
   
   Take out the 1st element of Read1, from left.
   For i = 2 to 6
     {
     Take out the i th element of Read1, from left.
     For j = 1 to i-1
       {
       if digit[i] = digit[j] Then
        {
        Read1 += 10**(6-i);        {To boost up performance}
        Break from both for loops;
        Unique = False;
        }
      }
    }
  
    If Unique = True Then
      {
      Read2 = Least four digit no.formed by digits 
              exclusive of 6 digits of Read1.
      If (Read1 - Read2)>=OriginalRead1 then
        {
        m1 = Read1-Read2;
        m2 = Read1;
        Break;
        }
      else 
        Read1 ++;
      }
  }  {Inner while-true loop ends}
  
  Print m1 and m2.

} {Outer while-true loop ends}
Close file;

      
      

++ What kind of tricks did potm use to minimize code length?

In JAVA, there is no no way (as for as in my knowledge) to read a line directly
as Integer. Therefore just to do this I have to write lot of code at byte
level. Also, big class names, such as "FileInputStream", really added up to the
code size like anything.
Anyway, I have tried to keep the code size as low as possible by removing
unnecessary spaces and keeping variable names short. Also I have tried to do
more and more operations in single loop.

++ Here's what I hated (and loved) about this POTM's scoring:

I won't comment on the scoring part, as whatever it is,  is same for all.
However, I am badly purturbed due to one and only one reason:

THE SAME CODE, WHEN I RUN AT MY LOCAL 486DX2 MACHINE/ WINDOWS NT FOR 100
STANDARD ENTRIES, COMPLETES IN JUST 1.85 SECONDS (EVERYTHING INCLUSIVE, ie
SYS+USER TIME)WHEREAS IT TAKES AROUND 12 SECONDS AT YOUR MACHINE, WHICH IS
OBVIOUSLY SUPPOSED TO BE BETTER THAN MINE.
THE JAVA COMPILER, I AM USING IS FOR DOS.
CAN YOU PLEASE HIGHLIGHT THE REASON OF SUCH A DRASTICE DIFFERENCE IN
PERFORMENCE ????????

IF THE PERFORMANCE OF PROGRAM AT YOUR MACHINE WOULD HAVE REMAINED SAME, IF NOT
IMPROVED, I WOULD HAVE BEEN FIRST AT LEAST IN JAVA ENTRIES.

ANYWAY I EXPECT SOMETHING FROM YOU AS POSSIBLE REASON FOR ABOVE.

>>> POTM-MASTER note (in lower case of course!):  The reason for such a
>>> drastic difference in performance is that we are running on different
>>> machines and using different compilers.  I'm sorry I received this
>>> note AFTER I sent out the consolation awards - you most definitely
>>> would have won an award for something!  Seriously - sorry you are
>>> perturbed - this thing is purely for fun.

++ COMPANY?         TATA UNISYS LTD.
++LOCATION?         BOMBAY, INDIA.
++JOB?              SYSTEMS ANALYST.
++DO FOR FUN?       JUST AS ANOTHER HOBBY.
++INNERMOST SECRET? DIDN'T GET THE Q.
++POTM IDEAS?       WOULD LIKE TO CONTRIBUTE IN FUTURE.
=================================================================

============== 102 ====================== guess =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
             guess      1879997  83271    549  82722 32  Matt Nelson
==============================================
guess	floodland.mv.com!ach@caig2.att.att.com	Matt Nelson	
==============================================
++ Please summarize the algorithm used by guess
guess takes the starting milage and makes a "guess" at the answer by adding
to the start then constructing the next greater (or equal) unique odometer
reading. It repeats the process until an answer is reached.

++ What kind of tricks did guess use to minimize code length?
I eliminated whitespace, used short variable names, and removed punctuation
that is optional in Perl ( For example { print $foo; } became {print $f} ).

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?
I work at Cabletron Systems in Rochester, new Hampshire as a Programmer /
Analyst. In my free time I like to program in Perl, read about Math and
Physics, and play Magic the Gathering.

=================================================================

============== 103 ====================== AWKward =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
           AWKward      1879997 136791    729 136062 28  Ken Kopecky
=================
AWKward was submitted by Ken Kopecky at kennk@ihgp.ih.lucent.com
=================
++ Please summarize the algorithm used by AWKward

 + Initialized odometer and used while[all 10 digits not displayed]
   loop.
 + Jump increment miles traveled if any of 4 leftmost digits are
   the same.
 + Detect which digits are seen on the odometer [and which are 
   needed by the trip-odometer]
 + If odometer has 6 unique digits and miles traveled equals or 
   exceeds the smallest 4 digit trip-odometer reading - then 
   break out of the while loop.... else continue the while loop.

++ What kind of tricks did AWKward use to minimize code length?

 + Used single character variables.
 + Added 1,000,000 miles to the odometer so that I could use
   strings/sub-strings of digits and maintain leading zeroes.
 + Added 0122 miles to input since no trip could be complete
   until trip-odometer read at least 0123 miles.
 + Used nested if/then/elses to check for cases where any of the
   leftmost 4 odometer digits were the same...added 10,123 or
   1,012 or 101 or 10 miles accordingly to save useless trips
   through the primary mileage loop.
 + Used an array for the digits, 0-9 to determine which digits
   were displayed on the odometer and which were needed for the
   trip-odometer.
 + Took advantage of AWK's ability to change integers to strings
   and strings to integers

++ Here's what I hated (and loved) about this POTM's scoring:

   Could not expect AWK to be faster than C. Hoped to just show
   that AWK could do the job.

COMPANY?  Lucent Technologies
LOCATION?  Indian Hill South Naperville IL
JOB?  5ESS software regression tester
DO FOR FUN?  Work with PC/Win95
INNERMOST SECRET?  none
POTM IDEAS? none at this time. will keep watching for POTM's that
            might give AWK an advantage over C.


=================================================================

============== 104 ====================== roadtrip =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
          roadtrip      1880006    580    400    180 91  Dave Spears

	Sorry ... no description available for roadtrip

=================================================================

============== 105 ====================== odometer =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
          odometer      1904885    651    513    138 43  David Korn

	Sorry ... no description available for odometer

=================================================================

============== 106 ====================== vvidya =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
            vvidya      1904885    937    829    108 83  Vidya Velgapudi

	Sorry ... no description available for vvidya

=================================================================

============== 107 ====================== mooshikan =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
         mooshikan      1904885   2587    963   1624 81  Padma Vellanki
===============
mooshikan submitted by Padma Vellanki at padmav@lucent.com
===============
++ Please summarize the algorithm used by mooshikan
The algorithm:
Find the closest number to the a-reading which has unique numbers.
(To obtain the next a-reading with unique numbers, start from the 
leftmost digit and if the digit is already encountered once, increment
it...)
Then see if a b-reading can be obtained with the given initial
a-reading and the new a-reading, if so, output the answer, else
try the next unique a-reading.


++ What kind of tricks did mooshikan use to minimize code length?
Eliminate function calls, minimize variable name lengths etc.

++ Here's what I hated (and loved) about this POTM's scoring:
I hated this: The code size restriction  on the .c file rather than 
	the  executable size.

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?
Lucent, Red Bank.

=================================================================

============== 108 ====================== NotSoHot =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
          NotSoHot      1904885   3088   1303   1785 21  David Rysdam
=================
NotSoHot was submitted by David Rysdam at drysdam@az.com
=================
++ Please summarize the algorithm used by NotSoHot

Figure out when the main odometer will next have a "fully unique" reading.
Get the unused digits from the reading and order them smallest to largest.
If the ordered, unused digits form a number SMALLER than the distance to the 
  unique reading, subtract the two and output the difference; else repeat

++ What kind of tricks did NotSoHot use to minimize code length?

To minimize code length, I shortened var names to 1 or 2 characters and killed
all unnecessary CRLFs (just enough to slip under 80 char limit).  After that
point I realized that I should have done my code speed optimization first.
Then I became unmotivated.

++ Here's what I hated (and loved) about this POTM's scoring:

It seems fair enough.

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?

Bank
Bellingham, WA
Read, internet, program
it wouldn't be a secret then
That wouldn't be fair.

=================================================================

============== 109 ====================== CheeseHead =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
        CheeseHead      1904885   4317   1511   2806 64  Mike Buchmann

	Sorry ... no description available for CheeseHead

=================================================================

============== 110 ====================== yogi =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
              yogi      1904885 148073   8961 139112 29  Yogesh Randad
=================
yogi was submitted by Yogesh Randad at yogi@idc.tandem.com
=================
         ++ Please summarize the algorithm used by yogi
      1. read input number.
      2. increment number by 1
      3. does the new number have six diff digits?
         if yes, store the counter. go to step 4
         if no, go to step 2.
      4. decrement counter by 1.
         if zero is reached, go to step 2.
       /* the counter here is the sum of the two trip meter readings -
            i) when reset is to be pressed.
            ii) the miles on it when all ten digits are diff. */
      5. does the new number have diff digits?
         if yes, go to step six.
         if no, go to step 4.
     6. do the 4 digit number and the six digit number reached have 10
	diff digits?
         if yes, go to step 7.
         if no, go to step 2.
      7. calculate required numbers using simple algebra. write answers.
 
      ** the logic of the program took care of special cases.
         e.g. increment from 999999 by 1 is 000000.
 
         ++ What kind of tricks did yogi use to minimize code length?
      unfortunately, i was not too careful about this.
         ++ Here's what I hated (and loved) about this POTM's scoring:
      everything seemed fair.
         ++ COMPANY?           Wipro Ltd.
         ++ LOCATION? Bangalore, India.
	 ++ JOB? S/W engineer.
  	 ++ DO FOR FUN? Hang around.
	 ++ INNERMOST SECRET? I won't tell.
	 POTM IDEAS? Let me recover from the loss, yet.

=================================================================

============== 111 ====================== my.program =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
        my.program      1907706   1038    776    262 107  Fan Xiaobo
=================
my.program was submitted by Fan Xiaobo at fxb@csnet1.dcs.tsinghua.edu.cn
=================
++ Please summarize the algorithm used by my.program

  The first is to acquire the nearest base mileage consisting of six 
different numbers greater than the start as a candidate. To test its 
validity, the sole necessity is to see whether this mileage minus the 
second one, which is the smallest composed of the four left numbers, is 
no less than the starting point. If so, it is the correct answer. Or, 
find the next candidate according to the dictionary sequence, and test it.

++ What kind of tricks did my.program use to minimize code length?

  Besides the usual finesse at the expense of poor readability such as 
reducing length of variables, seperating characters, and so on, I defined 
the frequently-used reserved-word as a single letter (i.e. #define U 
continue, I should have defined "for" as "F" to save 8 characters).

++ Here's what I hated (and loved) about this POTM's scoring:

  It is challenging to all the participants. But the portion of the 
source length in the scoring is too large. The better, I think, is to 
divide the length by a constant in order to reduce its weight and ignore 
the minor variation.

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?

  Tsinghua University.
  Beijing, China. 
  The first-year graduate.
  Yes.
  "lprof" and "prof" can be used to optimize the execution time, but it 
is not so effective due to the source length (at least in my program).
  No. Maybe in the future.
=================================================================

============== 112 ====================== CCC =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
               CCC      1931841   2546   1417   1129 20  Claudio Cabaleiro

	Sorry ... no description available for CCC

=================================================================

============== 113 ====================== Skys.the.limit =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
    Skys.the.limit      1933065  50243   1760  48483 35  Linda Licari

	Sorry ... no description available for Skys.the.limit

=================================================================

============== 114 ====================== waldacj =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
           waldacj      1947116  74506   3658  70848 110  Jesse Waldack
=================
waldacj was submitted by Jesse Waldack at waldacj@abu.spanlink.com
=================
++ Please summarize the algorithm used by waldacj

I started the program out by starting a loop until the solution was   
found, incrementing both odometers, and sending it into a check function   
that looked at the 10 digits, checked for dupes, and if one was found,   
would decrement the trip and loop until trip was 0.  I got the right   
answer, but it would take about a minute to get the answer on a fast UNIX   
box. (On the box I developed the program on, I always got times about   
half of the POTM judge got.)

I reduced the time it took by first looking at the 6 digit odometer.  If   
there were duplicate digits in this number, I would not put it in the   
loop to check the trip.  This reduced it to about 5 seconds per number.

All of my changes from here on was in the function that tested the first   
6 digits.  My next change was to modify the odometer so no digits are   
duped if there currently is a dupe.
(That is,  If odom=1; trip=1, the test would fail, and the next time the   
test is made odom=12345; trip=12345.  Sense the trip has now looped to   
past 0000 again; the solution is 12345. All that is needed now is to find   
the trip needed by using the function to test the trip.)  This reduced   
most cases to less than a second.  Only one case out of the 10 test   
numbers (12345) took several seconds to find the right solution.

To help this case, I found out what the lowest number the trip needed to   
be a possible solution (in odom=12345, the lowest digit in trip must be   
6.  So I check the first digit in the trip (if trip = 12345, the first   
"digit" is 12) and make sure that it is larger than the smallest digit   
found.  If the first digit is smaller, even though the first 6 digits are   
unique, the trip test is not run.

I would have found more ways to optimize speed, but time ran out.  :)

++ What kind of tricks did waldacj use to minimize code length?

I did not worry about code length that much.  My code was about 3500   
bytes.  I worked most on speed reduction sense if I saved 1 second for   
each odometer in the file, I saved 1000 seconds (16 min 20 seconds)   
overall.

++ Here's what I hated (and loved) about this POTM's scoring:

It would have been nice if your computer you tested from was as fast as   
the computer I tested from.  I clocked my program (with the 100 test   
numbers) at under a minute.  You had about 1:40.

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?

I work at Spanlink Communications in Minneapolis, Minnesota.  I am   
currently an intern, but plan to get a full time job when my internship   
is completed.  I am 22, married, and BBS for fun (That is how I met my wife).

Feel free to check out my home page at http://www.winternet.com/~llaffer   
(it is not much, but all I have had time to work on)

=================================================================

============== 115 ====================== NumberAngel =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
       NumberAngel      1987198    570    453    117 89  Robert Ang

	Sorry ... no description available for NumberAngel

=================================================================

============== 116 ====================== OnTheRoadAgain =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
    OnTheRoadAgain      2461911   1078    432    646 10  Joe Eccles
=================
OnTheRoadAgain was submitted by Joe Eccles at joe@mink.mt.att.com
=================
++ Please summarize the algorithm used by OnTheRoadAgain
	Keep a map of digits used. Starting mileage is set to the input
	mileage. Starting with the most significant digit,
	replace it with the smallest yet unused digit that results in a
	number greater than or equal to the input number. When all six digits
	are determined (A), construct the smallest possible number from the
	four remaining digits (B), and determine the reset mileage (A-B). If the
	reset milage is between the input mileage and A, output A-B and A.
	Otherwise, incement the starting mileage and try again.

++ What kind of tricks did OnTheRoadAgain use to minimize code length?
	Just simple stuff - one character variables, one macro, and squeezing
	out spaces and new-lines.

++ Here's what I hated (and loved) about this POTM's scoring:
	Just like working on a real project - the requirements are untestable!!

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?
	Company: AT&T, Middletown, NJ.
	Job: Systems architecture.
=================================================================

============== 117 ====================== balaji =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
            balaji      2554495   2241   1136   1105 111  Balaji Polimera
=================
balaji was submitted by Balaji Polimera at balajip@mink.mt.att.com
=================

++ Please summarize the algorithm used by balaji
   
main()
{
  For each Odometer A reading (aRead),
  {
		j = -1; 
		tmpA = aRead - 1.
		while ( j < 0)
		{
			increment tmpA by 1.

		/*
		 * Function checkA takes an integer tmpA as input
		 * parameter and returns the smallest integer greater 
             * than tmpA, which has the 6 least significant digits
             * all different. 
             */ 

			tmpA = checkA(tmpA)

			/*
		 * Function checkB takes two input parameters.
             * First parameter is tmpA which is the return value
		 * of function checkA, and 2nd parameter  aRead is
		 * the Odometer reading worked on. This function
		 * then forms the smallest number, num with the 4 digits
		 * which are not present in the 6 least significant
		 * digits of tmpA. It then returns the value 
		 * (tmpA - aRead - num). If the return value is greater than
		 * zero, num will be Odometer B reading when all 10 digits
		 * are different, tmpA's 6 least significant digits will be 
		 * Odometer A reading when all 10 digits are different, And j
		 * will be the number of miles to travel before resetting
		 * the Odometer B reading. Otherwise, we need to go thru
		 * this while loop till checkB returns a value > 0.
			 */

		j = checkB(tmpA, aRead)

		if (j is greater than 0) 
		{ 
		(aRead + j) gives the Odometer A reading at which 
		Odometer B was reset, and the 6 least significant 
		digits of tmpA give the Odometer A reading when all
		10 digits are different.
		}

		} /* End of while */

	} /* End of for */
} /* End of main */



	/*
	 * Function checkA takes an integer as input argument,tmpA and 
	 * returns the smallest number greater than tmpA such that 6 
	 * least significant digits of the number are all different.
	 * The positions of the digits are counted with the least 
	 * significant digit's position as 0. The function works as
	 * follows: For each digit in positions 5 thru 1 of tmpA, if 
	 * there is a matching digit in tmpA in a position less than 
	 * this digit's position, change the digit such that the increase 
	 * in tmpA will be minimum. Repeat this till 6 least significant 
	 * digits of tmpA are all different.
	 */

checkA(tmpA)
{

	/* 
	 * Below, positions of the digits are counted assuming
	 * that the least significant digit's position is zero.
	 */

	while(NOT(6 least significant digits of tmpA are all different))
	{
		For i in 5 to 1 do
		{
			For j in (i-1) to 0 do
			{
				if the digit in i'th position equals the digit
				in j'th position, add power(10, (j-1)) to the
				number.
			}
		}
	}

	return(tmpA)
}


	/*
	 * Function checkB takes two input arguments tmpA and aRead.
	 * tmpA is a number returned by checkA and has the 6 least
	 * significant digits all different. aRead is the Odomer
	 * reading (read from input file) working on right now.
	 * This function forms the smallest number, num with the four
	 * digits which are not there in the 6 least significant digits
	 * of tmpA. num is a possible value for the Odometer reading.
	 * checkB then returns (tmpA - aRead - num).
	 */

checkB(tmpA, aRead)
{
	pick up the 4 digits not found in the 6 least significant
	digits of tmpA in to i1, i2, i3, i4 such that

        i1 < i2 < i3 < i4.

	num = 1000*i1 + 100*i2 + 10*i3 + i4.

	return(tmpA - aRead - num).
}

	/* 
	 * A very simple example to illustrate how the above algorithm
	 * works. Suppose the input odometer reading is 663489.
	 *
	 * So aRead = 663489.
	 *
	 * main calls checkA(663489)
	 *
	 * Function checkA will add power(10, 4) = 10000 to 663489
	 * so that the number will be 673489 and returns 673489.
	 *
	 * Now checkB forms the number 0125 using the 4 digits missing
	 * from 673489. checkB returns (673489 - 663489 - 0125) = 9875.
	 * 
	 * The return value of checkB is > 0.
	 * So, Odometer B was reset when A read 663489 + 9875 = 673364.
	 * Odometer A reads 673489 when all 10 digits are different.
	 */


++ What kind of tricks did balaji use to minimize code length?

	Nothing much except keeping names of functions and variables short.

++ Here's what I hated (and loved) about this POTM's scoring:

	I feel the score being used is a good one to resolve the ties.

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?

    COMPANY : Regal Data systems, NJ (Contactor at AT&T Middletown, NJ).
	JOB     : Software Development.
	DO FOR FUN : Listen to Music, Watch movies.
=================================================================

============== 118 ====================== Frodo =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
             Frodo      6274359    751    471    280 52  Austin Green

	Sorry ... no description available for Frodo

=================================================================

============== 119 ====================== ODOSNAIL =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
          ODOSNAIL      6927761  35454   1226  34228 19  Markus Sabadello

	Sorry ... no description available for ODOSNAIL

=================================================================

============== 120 ====================== odo =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
               odo    999999999    897    655    242 57  Matthew Cross
=================
odo was submitted by Michael Cross at mcross@sw.stratus.com
=================
++ Please summarize the algorithm used by odo

The main utility function was able to, given a ten-digit string
representing the two odometers, find the next smallest 10-digit number
in which all digits are unique and the upper six digits are different.
It would also handle starting from a point where only some of the
high-order digits were filled in; this was used after reading in the
initial number.

The main loop would read in the number, fill in a ten-digit string
with as many unique digits it could from the read in mileage, then
call the utility function to get the next unique mileage.  It then
calculated if the distance to that mileage was greater than or equal
to the mileage in the lower four digits; if so, that was the answer -
print out the upper six digits minus the lower four digits, then the
upper size digits.  If not, then loop around to call the utility
function again and check the answer.

++ What kind of tricks did odo use to minimize code length?

I started writing the code out full length as I normally would and
debugging that.  Then I would progressively make it smaller testing
after each set of changes.

I started with the easy changes - eliminate white space and comments,
don't include files, make all identifiers only one character.

Then I would combine code as much as possible, use for loops rather
than while loops, make judicious use of the comma operator and the ?:
operator, etc.

++ Here's what I hated (and loved) about this POTM's scoring:

I enjoy the challenge of misusing C to make the source code as small
as possible.  I also enjoyed that getting the problem right was mostly
straightforward (even though mine didn't work in the end), forcing the
emphasis to be on code size and speed.  I would rather see the
emphasis on speed than on source code size, but it is interesting
trying to balance the two.

At the same time I find it annoying that being able to make compact
code is necessary and I find it difficult to work that way.  I would
rather see something like a token counter or a whitespace eliminator
to count the size, rather than using the raw byte size of the source.

It was frustrating not knowing other people's raw scores, only a
relative ranking.

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?

I work for Stratus Computer, as a software engineer on our proprietary
operating system, VOS.  For fun, I build small robots (ok, I've only
built one so far, and it didn't really work), and other mundane
things.

I would like to see a competitive POTM, where programs compete against
one another directly.  Something simple, like checkers,
dots-and-lines, or 3D tic-tac-toe.


-- 
Matthew E. Cross                              E-Mail: mcross@sw.stratus.com
Software Engineer                              Phone: 508-460-2926
Stratus Computer, Inc.                           Fax: 508-460-0397

=================================================================

============== 121 ====================== AreWeThereYet =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
     AreWeThereYet    999999999    924    395    529 96  Steven Burnap
=================
AreWeThereYet was submitted by Steven Burnap at sburnap@wsgc.com
=================
++ Please summarize the algorithm used by AreWeThereYet

1) Start with the current odometer reading.
2) Find the next odometer reading that is "legal" (i.e. has unique digits).
3) Using the remaining digits, find the lowest combination for the tripmeter.
4) Repeat steps 2 and 3 until the tripmeter is less than the difference 
between the current odometer reading and the written one.
5) Output.

Details:

1) Add '123' to the odometer reading (as this is the minimum tripmeter) 
or '1234' if the first digit of the odometer is '0'.
2) Start with the second digit.  For each digit, if there is a prior 
digit that is the same, increment it and clear the rest of the odometer 
to all zeros.  If this is greater than '9', set to zero, back up one digit
and increment that one.  Repeat until the last digit is reached.
3) Start at zero.  Set each digit in the tripmeter sequentially when an 
unused digit is found.

++ What kind of tricks did AreWeThereYet use to minimize code length?

Reusing variables extensively (including reusing that arguments to 'main' 
for other purposes.  Declaring most things 'int' regardless of wether 
they were 'char', 'FILE *' or 'int'.  Not including 'stdio.h' and fudging 
on parameters.  On long macro for a twice repeated block of code.

There are also a lot of syntax tricks:

When defining a macro with an argument, you don't need a space between 
the macro name and definition.
The only part of the syntax that requires whitespace is the middle of the 
declaration.  I tried to arrange declarations so that I could use a 
carriage return (which I was required to use anyway) instead of a space.
I used array math when possible (i.e. I used *O and O+1 instead of O[0] 
and &O[1])
I used ?-: blocks instead of if-thens when possible.
If two mathematical expressions (including '?-:' blocks) appeared one 
after another, I used a ',' instead of a ';' to separate them.  This made 
the two lines one statement so that I could often remove the surrounding 
curly-braces.

++ Here's what I hated (and loved) about this POTM's 
scoring: 

Since the test file was significantly different in length from the final 
final it was really difficult to determine how well I was doing.  The 
scoring for the test favored code size vs. speed more than the final file 
will (if it is indeed 10 times as large).
The constraints seemed a little artificial.  It might have been more 
interesting if it had been object code size and not source code size that 
had been used for scoring.
Knowing my rank, but not the scores that caused it, made it interesting.

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?

I work for Williams-Sonoma as a contract Point of Sale programmer in San 
Francisco.  I read and wonder around the Bay Area with my wife for fun, 
as well as hacking at the computer (and my innermost secret is that this 
hacking too often involves nonconstructive (i.e. computer game) activities.

Steven Burnap
Williams-Sonoma
sburnap@wsgc.com
(415) 616-8405
(510) 942-0376


=================================================================

============== 122 ====================== Crazy_Odos =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
        Crazy_Odos    999999999   1769   1385    384 123  Wim Decroix

	Sorry ... no description available for Crazy_Odos

=================================================================

============== 123 ====================== bcrosby =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
           bcrosby    999999999   1880   1880      0 79  Brandon Crosby

	Sorry ... no description available for bcrosby

=================================================================

============== 124 ====================== POSSIBLE =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
          POSSIBLE    999999999   2257    395   1862 72  Gerry Scheetz
=================
POSSIBLE was submitted by Gerry Scheetz at prof@mt.net
=================
++ Please summarize the algorithm used by POSSIBLE
I had a linked list (used an array) that contained the number 0 through 9. 
From this I calculated out all the possible variations for the odometers. 
Then for each odometer reading I figured where the reset value was and if
it was after the last odometer reading I stored it in an array.  I then
read through the file and did a search on my array looking for the
appropriate answer.

++ What kind of tricks did POSSIBLE use to minimize code length?
My original linked list way dynamic, I used an array.
In many places where I would normally use a while loop I used a for loop.
Used C++ streams for I/0 instead of C standard I/O routines.

++ Here's what I hated (and loved) about this POTM's scoring:
Love/hate relationship with the scoring system.  I code on a Pentium 90
running Win95.  So it was tough to figure out what my score might be if
when ran on the test system.

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?
BDM Technologies in Helena, MT.  Systems Programmer working on a contract
for the State of Montana's Department of Public Health and Human services. 
Play basketball for fun.
=================================================================

============== 125 ====================== tclau =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
             tclau    999999999   2396   2385     11 69  Claudiu Tatar

	Sorry ... no description available for tclau

=================================================================

============== 126 ====================== indy499 =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
           indy499    999999999   7737   7322    415 115  Ram Ramachandran

	Sorry ... no description available for indy499

=================================================================

============== 127 ====================== SimplyMinded =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
      SimplyMinded    999999999 181146   1001 180145 36  Jason Grosland
=================
SimplyMinded was submitted by Jason Grosland at jcg3@acpub.duke.edu
=================
++ Please summarize the algorithm used by SimplyMinded

My program first found a 6 digit unique number (no digits alike) that was 
greater than the starting number.  It then found the first 10 digit 
unique number by counting up on a 4 digit number, then checked to see if 
this new number was withing program specifications.

++ What kind of tricks did SimplyMinded use to minimize code length?

I tired to use a nested for loop and divisors to make finding a unique 
number easier, but apparently this confused things as I didn't come up 
with a correct total.

++ Here's what I hated (and loved) about this POTM's scoring:

Scoring was fine, it would've been nice to get running times for the 
programs, but there is only so mucha POTM master can do, eh?

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?

Currently a second year undergraduate majoring in Computer Science at Duke, 
and hope to one day change the world...
Jason Grosland jcg3@acpub.duke.edu	www.duke.edu/~jcg3/resume.html

=================================================================

============== 128 ====================== steer =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
             steer    999999999 181714   1585 180129 76  Mark Studebaker
=================
steer was submitted by Mark Studebaker at mds@pdn.paradyne.com
=================
++ Please summarize the algorithm used by steer
	Brute force search; store solutions in table so that
	duplicates are solved really fast.

++ What kind of tricks did steer use to minimize code length?
	Just squish all variable names to one character.
	
++ Here's what I hated (and loved) about this POTM's scoring:
	Hate the code length restriction and scoring.

++ COMPANY?  LOCATION?  JOB?  DO FOR FUN?  INNERMOST SECRET?  POTM IDEAS?
	Paradyne (ex-AT&T!) Largo, FL - MTS Hardware Engineer

=================================================================

============== 129 ====================== FastCounter =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
       FastCounter    999999999 182342   2004 180338 60  Jonathan Nicolas

	Sorry ... no description available for FastCounter

=================================================================

============== 130 ====================== ResetEntry1 =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
       ResetEntry1    999999999 183579   2390 181189 68  Guy Oliver

	Sorry ... no description available for ResetEntry1

=================================================================

============== 131 ====================== Giraffe96 =============

=================================================================
            ENTRY       SCORE1   SCORE2 = CHARS+HSEC AGE  PROGRAMMERS
         Giraffe96    999999999 184323   3141 181182 17  Gopalan Balaji

	Sorry ... no description available for Giraffe96

=================================================================












Make your own free website on Tripod.com