String to Integer (atoi) - Practice Coding Problems

String to Integer (atoi) - Problem

String Medium

Ever wondered how programming languages convert strings to integers? Welcome to the world of atoi (ASCII to Integer)! Your mission is to implement a string-to-integer conversion function that mimics the behavior of C's atoi function.

Given a string s, your function myAtoi(s) should convert it to a 32-bit signed integer following these rules:

Skip Whitespace: Ignore any leading whitespace characters (' ')
Handle Sign: Check if the next character is '-' or '+'. If neither is present, assume positive.
Convert Digits: Read digits until you encounter a non-digit character or reach the end. Skip leading zeros.
Handle Empty: If no digits were read, return 0.
Clamp Range: If the result exceeds the 32-bit signed integer range [-2³¹, 2³¹ - 1], clamp it to the boundary values.

Challenge: Handle edge cases like overflow, underflow, and invalid characters gracefully!

Input & Output

example_1.py — Basic Conversion

$ Input: s = "42"

› Output: 42

💡 Note: Simple numeric string converts directly to integer 42

example_2.py — Whitespace and Sign

$ Input: s = " -42"

› Output: -42

💡 Note: Leading whitespace is ignored, negative sign is processed, resulting in -42

example_3.py — Mixed Characters

$ Input: s = "4193 with words"

› Output: 4193

💡 Note: Digits are read until the first non-digit character (space), so only '4193' is converted

example_4.py — Overflow Case

$ Input: s = "91283472332"

› Output: 2147483647

💡 Note: Number exceeds 32-bit integer maximum, so it's clamped to 2³¹-1 = 2147483647

Visualization

Tap to expand

Understanding the Visualization

Initialize State

Start with result = 0, sign = 1, and begin scanning

Skip Whitespace

Ignore leading spaces until we find a non-space character

Process Sign

If we see '+' or '-', record the sign and move to next character

Build Number

For each digit, multiply current result by 10 and add the digit

Check Overflow

Before each multiplication, verify we won't exceed 32-bit limits

Return Result

Apply sign and return the final clamped result

Key Takeaway

🎯 Key Insight: The optimal solution is essentially a finite state machine that processes each character exactly once, making decisions based on the current state and input character. This eliminates the need for multiple passes or string manipulation.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Although we make multiple passes, each is O(n), so overall still O(n)

✓ Linear Growth

Space Complexity

O(n)

Creates intermediate strings for processing

⚡ Linearithmic Space

Constraints

0 ≤ s.length ≤ 200
s consists of English letters (lower-case and upper-case), digits (0-9), ' ', '+', '-', and '.'
Follow-up: Can you solve it without using any built-in library functions for string-to-integer conversion?

Asked in

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

The optimal approach uses a single-pass state machine that processes each character exactly once. We track our current state (whitespace, sign, digits) and build the result incrementally while checking for overflow before it occurs. This gives us O(n) time and O(1) space complexity - the most efficient solution possible for this problem.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Character-by-Character with String Manipulation)	O(n)	O(n)	Process string multiple times, rebuilding number from scratch for each validation

Brute Force (Character-by-Character with String Manipulation) — Algorithm Steps

Trim all leading and trailing whitespace
Extract sign character if present
Extract all consecutive digits into a separate string
Convert digit string to integer using built-in functions
Apply sign and check bounds
Clamp to 32-bit integer range if needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Whitespace Removal

First pass: identify and remove leading whitespace

Sign Detection

Second pass: check for '+' or '-' sign

Digit Extraction

Third pass: collect all consecutive digits

Conversion

Convert digit string to integer

Range Clamping

Apply bounds checking and clamping

Code -

solution.c — C

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

int myAtoi(char* s) {
    int len = strlen(s);
    if (len == 0) return 0;
    
    // Phase 1: Skip leading whitespace
    int start = 0;
    while (start < len && s[start] == ' ') start++;
    if (start == len) return 0;
    
    // Phase 2: Handle sign
    int sign = 1;
    if (s[start] == '+' || s[start] == '-') {
        sign = (s[start] == '-') ? -1 : 1;
        start++;
    }
    
    // Phase 3: Extract digits and convert
    long long result = 0;
    for (int i = start; i < len; i++) {
        if (s[i] >= '0' && s[i] <= '9') {
            result = result * 10 + (s[i] - '0');
            // Check for overflow during calculation
            if (result > INT_MAX) break;
        } else {
            break;
        }
    }
    
    result *= sign;
    
    // Phase 4: Clamp to 32-bit range
    if (result > INT_MAX) return INT_MAX;
    if (result < INT_MIN) return INT_MIN;
    
    return (int) result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Although we make multiple passes, each is O(n), so overall still O(n)

✓ Linear Growth

Space Complexity

O(n)

Creates intermediate strings for processing

⚡ Linearithmic Space

Constraints

0 ≤ s.length ≤ 200
s consists of English letters (lower-case and upper-case), digits (0-9), ' ', '+', '-', and '.'
Follow-up: Can you solve it without using any built-in library functions for string-to-integer conversion?

67.8K Views

Very High Frequency

~25 min Avg. Time

3.2K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Character-by-Character with String Manipulation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler