String to Integer (atoi) - Practice Coding Problems

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

Understanding the Visualization

Input

String with potential whitespace, sign, digits, and other chars

Process

Parse systematically: skip whitespace → check sign → convert digits

Output

32-bit signed integer with overflow clamping

Key Takeaway

🎯 Key Insight: Handle parsing systematically with proper overflow detection using mathematical bounds

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

Approach	Time	Space	Notes
✓ Character-by-Character Parsing	O(n)	O(1)	Parse each character sequentially, handling all edge cases manually
Optimized Single Pass with Early Termination	O(n)	O(1)	Single pass with optimized overflow detection and early exit

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.2K 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