String to Integer (atoi)

String to Integer (atoi) - Problem

String Medium

Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer following these rules:

Whitespace: Ignore any leading whitespace characters
Signedness: Determine the sign by checking if the next character is '-' or '+', assuming positivity if neither present
Conversion: Read the integer by skipping leading zeros until a non-digit character is encountered or the end of the string is reached. If no digits were read, then the result is 0
Rounding: If the integer is out of the 32-bit signed integer range [-2³¹, 2³¹ - 1], then clamp the integer to remain in the range

Return the integer as the final result.

Input & Output

Example 1 — Basic Negative Number

$ Input: s = "42"

› Output: 42

💡 Note: Simple case: skip no whitespace, no sign, convert digits "42" to integer 42

Example 2 — Whitespace and Sign

$ Input: s = " -42"

› Output: -42

💡 Note: Skip leading spaces, parse negative sign, convert "42" and apply sign to get -42

Example 3 — Mixed Characters

$ Input: s = "4193 with words"

› Output: 4193

💡 Note: Convert "4193" until space character encountered, ignore remaining characters

Constraints

0 ≤ s.length ≤ 200
s consists of English letters (lower-case and upper-case), digits (0-9), ' ', '+', '-', and '.'

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 38 f Facebook 32 M Microsoft 28

The key insight is to handle edge cases systematically: whitespace, sign, digits, and overflow. The optimal approach uses single-pass parsing with mathematical overflow detection. Time: O(n), Space: O(1)

Common Approaches

✓ Character-by-Character Parsing

⏱️ Time: O(n) Space: O(1)

Iterate through the string character by character, first skipping whitespace, then checking for sign, then converting digits to integer while checking for overflow at each step.

Optimized Single Pass with Early Termination

⏱️ Time: O(n) Space: O(1)

Parse the string in one pass with optimized overflow checking using mathematical bounds. Exit early when encountering non-digit characters or when overflow is detected.

Character-by-Character Parsing — Algorithm Steps

Skip leading whitespace characters
Check for optional sign (+ or -)
Convert consecutive digits to integer
Handle 32-bit integer overflow by clamping

Visualization

Tap to expand

Step-by-Step Walkthrough

Skip Whitespace

Move pointer past leading spaces

Parse Sign

Detect negative sign and set multiplier

Convert Digits

Build integer from consecutive digits

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>

int solution(char* s) {
    if (!s || strlen(s) == 0) return 0;
    
    int i = 0;
    int n = strlen(s);
    
    // Skip leading whitespace
    while (i < n && s[i] == ' ') {
        i++;
    }
    
    if (i >= n) return 0;
    
    // Check sign
    int sign = 1;
    if (s[i] == '-') {
        sign = -1;
        i++;
    } else if (s[i] == '+') {
        i++;
    }
    
    // Convert digits
    long long result = 0;
    
    while (i < n && isdigit(s[i])) {
        int digit = s[i] - '0';
        
        // Check overflow
        if (result > (INT_MAX - digit) / 10) {
            return sign == 1 ? INT_MAX : INT_MIN;
        }
        
        result = result * 10 + digit;
        i++;
    }
    
    result *= sign;
    
    // Clamp to 32-bit range
    if (result > INT_MAX) return INT_MAX;
    if (result < INT_MIN) return INT_MIN;
    
    return (int) result;
}

int main() {
    char s[10000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string, examining each character once

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track state and result

✓ Linear Space

89.3K Views

High Frequency

~25 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Character-by-Character Parsing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler