int atoi( char* pStr )

**problem**: write the definition for this
function without using any built-in functions. if pStr is null, return
0. if pStr contains non-numeric characters, either return 0 (ok) or
return the number derived so far (better) (e.g. if its "123A", then
return 123). assume all numbers are positive. plus or minus signs can
be considered non-numeric characters. in order to solve this program,
the programmer must understand the difference between the integer 0 and
the character '0', and how converting '0' to an int, will not result in
0. in other words, they have to understand what ascii is all about.**solution**: atoi

string
manipulation functions are great programming questions. they test
whether the user can understand and translate into code simple
algorithms. string functions test pointer arithmetic which usually
shows a knowledgeable programmer. also there are usually multiple
solutions, some more efficient than others. plus people use them all
the time so they should understand how they work. my favorite is atoi
and i start the problem like this:

int atoi( char* pStr )

write
the definition for this function without using any built-in functions.
if pStr is null, return 0. if pStr contains non-numeric characters,
either return 0 (ok) or return the number derived so far (better) (e.g.
if its "123A", then return 123). assume all numbers are positive. plus
or minus signs can be considered non-numeric characters. in order to
solve this program, the programmer must understand the difference
between the integer 0 and the character '0', and how converting '0' to
an int, will not result in 0. in other words, they have to understand
what ascii is all about. if they are stuck solving this problem, just
ask them first to write:

charToInt(char c)

if they can't do that
then they basically missed half the problem. any moderately talented
programmer who has a CS degree knows how to convert a char to an int.
(note i said convert, not cast. charToInt('9') should return 9.)

when
they start to solve the problem you will notice that they must make a
choice in how they will process the string - from left to right or
right to left. i will discuss both methods and the difficulties
encountered in each.

"right to left" - this method starts at the
right hand letter of the string and converts that character to an int.
it then stores this value after promoting it to its correct "tens"
place.

int atoi( char* pStr )

{

int iRetVal = 0;

int iTens = 1;

if ( pStr )

{

char* pCur = pStr;

while (*pCur)

pCur++;

pCur--;

while ( pCur >= pStr && *pCur <= '9' && *pCur >= '0' )

{

iRetVal += ((*pCur - '0') * iTens);

pCur--;

iTens *= 10;

}

}

return iRetVal;

}

"left
to right" - this method keeps adding the number and multiplying the
result by ten before continuing to the next number. e.g. if you had
"6234" and you processed from left to right you'd have 6, then if you
kept reading you'd multiply your result by 10 (6*10) to add a zero for
where the next number would go. 60, and then you'd slide the 2 into the
zero place you just made. 62. do it again, 620, slide the next number
in, 623.

int atoi( char* pStr )

{

int iRetVal = 0;

if ( pStr )

{

while ( *pStr && *pStr <= '9' && *pStr >= '0' )

{

iRetVal = (iRetVal * 10) + (*pStr - '0');

pStr++;

}

}

return iRetVal;

}

i think the "left to right" method is a little bit cleaner, or maybe its just cooler. but both are "correct".

remember
that debugging code on paper is somewhat hard. most programmers aren't
used to studying code that much when you can just hit F-7, compile and
see if the compiler barfs or not. if you notice an error, just ask them
to step through a sample string drawing out what is happening with all
the variables and the pointers in every step. they should find their
mistake then and fix it (no points deducted).