Coding Problem Interview Series: How to Convert a String to Integer (atoi())?

const atoi = parseInt

function atoi(str) {
    // match 0-1 signs (+ or -), followed by 1 or more ASCII digits
    // formats like "1", "01", "+1", "-1" are allowed
    // formats like "0xff", "1e6", "1.1", " 1 " are rejected
    const matched = str.match(/^([+\-]?)(\d+)$/)

    // `matched` will be `null` if the format requirement wasn't met,
    // so we return Not a Number
    if (!matched) return NaN

    // destructure the capture groups: 0 is discarded (full match)
    const [, sign, digits] = matched

    let total = 0
    // go through the decimal places in reverse:
    // units, tens, hundreds, etc.
    for (const [i, digit] of [...digits].reverse().entries()) {
        // subtract 0x30 from the codepoint, as ASCII digits are
        // located at codepoints 0x30..0x39
        // (i.e. "0" is codepoint 0x30, "1" is 0x31, etc.)
        // multiply by 10 raised to the power of the appropriate
        // decimal place
        total += (digit.codePointAt(0) - 0x30) * 10 ** i
    }

    // multiply by -1 if the sign was negative
    return total * (sign === '-' ? -1 : 1)
}

atoi('42') // 42
atoi('-99') // -99
atoi('+500') // 500
atoi('0001230') // 1230
atoi('1.5') // NaN

int atoi_func(const char* str, size_t len) {
  int aggregator = 0;
  char *ptr = str;

  while (*ptr != '\0' && (ptr - str) < len) {
    int digit = *ptr - '0';
    if (digit > 9 || digit < 0) {
      fprintf(stderr, "«%c» is not a digit.\n", *ptr);
      return -1;
    }

    aggregator += digit * (ptr - str);
  }

  if (*ptr != '\0') {
    fprintf(stderr, "potential overflow detected; no null terminator.\n");
    return -1;
  }

  return aggregator;
}

use std::error::Error;
use std::fmt;

#[derive(Debug)]
pub enum AtoiError {
    IntegerOverflow,
    ZeroLengthInput,
    InvalidChar(char),
}

impl fmt::Display for AtoiError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

impl Error for AtoiError {}

pub fn atoi(input: &str) -> Result<i64, AtoiError> {
    use crate::AtoiError::*;

    let mut chars = input.chars();

    // `sign` can be either `Some('+')`, `Some('-')`, or `None`
    let sign = match chars.next() {
        x @ Some('-' | '+') => x,
        Some(_) => None,
        None => return Err(ZeroLengthInput),
    };

    // `chars` iterator is currently at index 1 due to calling `next`
    // in previous expression.
    // If the sign wasn't explicitly specified, then re-start chars
    // iterator from index 0
    if sign.is_none() {
        chars = input.chars();
    }

    let mut total: i64 = 0;

    // Go through the decimal places in reverse:
    // units, tens, hundreds, etc.
    for (i, c) in chars.rev().enumerate() {
        match c {
            // Check if char is a digit
            c if c >= '0' && c <= '9' => {
                // Subtract codepoint of '0' from the char.
                // Multiply by 10 raised to the power of the appropriate
                // decimal place

                total = total
                    .checked_add(
                        (c as i64 - '0' as i64)
                            .checked_mul(10i64.checked_pow(i as u32).ok_or(IntegerOverflow)?)
                            .ok_or(IntegerOverflow)?,
                    )
                    .ok_or(IntegerOverflow)?;
            }
            // Return error result if char is not a digit
            c => return Err(InvalidChar(c)),
        };
    }

    // Multiply by -1 if the sign was negative
    Ok(match sign {
        Some('-') => total * -1,
        _ => total,
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::AtoiError::*;

    #[test]
    fn valid() {
        assert!(matches!(atoi("0"), Ok(0)));
        assert!(matches!(atoi("42"), Ok(42)));
        assert!(matches!(atoi("-99"), Ok(-99)));
        assert!(matches!(atoi("+500"), Ok(500)));
        assert!(matches!(atoi("0001230"), Ok(1230)));
    }

    #[test]
    fn invalid() {
        assert!(matches!(atoi(""), Err(ZeroLengthInput)));
        assert!(matches!(atoi("1.5"), Err(InvalidChar('.'))));
        assert!(matches!(atoi("1-2"), Err(InvalidChar('-'))));
        assert!(matches!(atoi("1+3"), Err(InvalidChar('+'))));
        assert!(matches!(atoi("999999999999999999999"), Err(IntegerOverflow)));
    }
}

import Parser as P exposing ((|.), (|=), Parser)


type Sign
    = Positive
    | Negative


type Integer
    = Integer Sign String


applySign : Integer -> Maybe Int
applySign (Integer sign digits) =
    case ( sign, String.toInt digits ) of
        ( Positive, Just n ) ->
            Just n

        ( Negative, Just n ) ->
            Just (-1 * n)

        _ ->
            Nothing


intP : Parser Int
intP =
    P.succeed Integer
        |= P.oneOf
            [ P.symbol "+" |> P.map (always Positive)
            , P.symbol "-" |> P.map (always Negative)
            , P.succeed Positive
            ]
        |= (P.chompWhile Char.isDigit |> P.getChompedString)
        |. P.end
        |> P.andThen
            (\integer ->
                case applySign integer of
                    Just n ->
                        P.succeed n

                    Nothing ->
                        P.problem "applySign failed"
            )


atoi : String -> Maybe Int
atoi input =
    P.run intP input |> Result.toMaybe

atoi "1" -- Just 1
atoi "45" -- Just 45
atoi "-45" -- Just -45
atoi "" -- Nothing
atoi "--335" -- Nothing
atoi "-3-42" -- Nothing

class Solution {
    public int myAtoi(String s) {
        double num = 0;
        boolean neg=false,numFound=false,space=false;
        int charCount=0;
        for (char ch : s.toCharArray()) {
            if(charCount>=2){
                break;
            }
            if(charCount>0 && space){
                break;
            }
            if (ch >= '0' && ch <= '9') {
                numFound=true;
                num = ((int) ch - 48) + num * 10;
            }
            else if(!numFound&&ch=='-'){
                space=false;
                neg=true;
                charCount++;
            }
            else if(!numFound&&ch=='+'){
                space=false;
                charCount++;
            }
            else if(!numFound&&ch==' '){
                space=true;
                continue;
            }
            else if(!numFound&&ch=='.'){
                break;
            }
            else{
                break;
            }
        }
        if(neg)
            return (int)(0-num);
        return (int)num;
    }
}

const stringNum = "12345"
const intNum = +stringNum

npm i atoi-js