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
=================================================================