CareerCup

here it is in C. it handles leading whitespaces & trailing whitespaces. if characters are found in between numbers, it ignores them. it allows negative numbers, and it detects buffer overflows.

#include <stdio.h>

int my_atoi(char *string) {
  
  int negative = 0;
  int value = 0;
  char *start;

  if (string == NULL) /* if data passed in is null */
    return 0;

  start = string;

  while(*start == ' ') /* ignore pre-whitespaces */
    start++;

  if (*start == '-') { 
    negative = 1;
    start++;
  }

  while (*start != '\0') {
    if (*start >= '0' && *start <= '9') { /* numeric characters */
      if (negative == 0 && value * 10 + ((int)*start - '0') < value) { /* check for + buffer overflow */
        printf("buffer overflow \n");
        return 0;
      }
      if (negative == 1 && (((-value) * 10) - ((int)*start - '0') > -value)) { /* check for - buffer overflow */
        printf("buffer overflow \n");
        return 0;
      }
      value = value * 10 + ((int)*start - '0');
    }

    start++;
  }

  if (negative)
    value = -value;

  return value;
}

Should be something like this:

public class ATOI
{
        public static void main(String[] args){
                String s = "ABCD";
                char[] chars = s.toCharArray();
                for(int i=0; i<s.length();i++){
                        int j = (int)chars[i];
                        System.out.print(" " + j);
                        System.out.println();
                }
        }
}

atoi is simple to implement. I was asked itoa by Amazon.. :(

atoi is simple to implement. I was asked itoa by Amazon.. :(

int atoi(char* str){
assert(str!=NULL);//check for null string
bool negFlag=false;
int i=0;
if(str[0]=='-')//check for negative numbers
{negFlag=true;
i++;
}
int num=0;
while(str[i]!='\0'){
num*=10;
num+=(str[i]-'0');//extract value of number at position i
i++;
}
if(negFlag){
num*=-1;
}
return num;
}

In C#

private static string MyItoA(int input)
{
string result = string.Empty;

var quotient = input;

while (quotient > 0)
{
var remainder = quotient % 10;
quotient = quotient / 10;
char addedNumberString = (char)(remainder + (int)'0'); ;
result = string.Concat(addedNumberString , result);
}
return result;
}

And here is my itoa function. it issues malloc a single time at the expense of looping an extra log10(n) times to get the number of digits. if anyone has a more elegant solution please share.

#include <stdio.h>
#include <stdlib.h>
char *itoa(int input) {
  int digits = 0;
  int value = input;
  char *str_val = NULL;
  char *end;
  if (value == 0) { /* special case */
    str_val = malloc(2*sizeof(char));
    *str_val = '0';
    *(++str_val) = '\0';
    return --str_val;
  }
    if (value < 0) { /* negative value requires an extra digit */
    digits++; 
  }
  while (value != 0) {
    value /= 10;
    digits++;
  }
  value = input; /* reset value */
  str_val = malloc((digits+1)*sizeof(char));
  end = str_val + digits;
  if (value < 0) { /* allocate negative character */
    *str_val = '-';
    value = value * -1;
  }
  *end = '\0';
  end--;
  while (value != 0) {
    *end = '0'+(value % 10);
    value /= 10;    
    end--;
  }
  return str_val;

}

would not it be better to get the malloc of word length first and then doing the needful conversion and then realloc to squeeze in case extra memory has been allocated. This will avoid the loop to count the digits before actually doing the conversion.