String to Integer atoi in DSA Go

Mental Model

Convert a string of characters into a number by reading each digit and building the number step by step.

Analogy: Like reading a number from a sign one digit at a time and writing it down as a real number in your notebook.

"string: '1234'\nnumber: 0\nreading each char -> convert -> add to number"

Dry Run Walkthrough

Input: string: "42"

Goal: Convert the string "42" into the integer 42

Step 1: Read first character '4', convert to digit 4

number = 0 * 10 + 4 = 4

Why: Start building the number from left to right

Step 2: Read second character '2', convert to digit 2

number = 4 * 10 + 2 = 42

Why: Add next digit to the right by multiplying previous number by 10

Result:

number = 42

Annotated Code

DSA Go

package main

import (
	"fmt"
)

func myAtoi(s string) int {
	const INT_MAX = 2147483647
	const INT_MIN = -2147483648
	n := len(s)
	index := 0
	// skip leading spaces
	for index < n && s[index] == ' ' {
		index++
	}
	// check sign
	sign := 1
	if index < n && (s[index] == '+' || s[index] == '-') {
		if s[index] == '-' {
			sign = -1
		}
		index++
	}
	result := 0
	// convert digits
	for index < n {
		ch := s[index]
		if ch < '0' || ch > '9' {
			break
		}
		digit := int(ch - '0')
		// check overflow
		if result > (INT_MAX-digit)/10 {
			if sign == 1 {
				return INT_MAX
			} else {
				return INT_MIN
			}
		}
		result = result*10 + digit
		index++
	}
	return sign * result
}

func main() {
	fmt.Println(myAtoi("42"))
}

for index < n && s[index] == ' ' { index++ }

skip leading spaces to find start of number

if index < n && (s[index] == '+' || s[index] == '-') { if s[index] == '-' { sign = -1 } index++ }

detect and record sign of number

for index < n { ch := s[index]; if ch < '0' || ch > '9' { break }

stop conversion when non-digit found

digit := int(ch - '0')

convert character digit to integer

if result > (INT_MAX-digit)/10 { return INT_MAX or INT_MIN }

check for integer overflow before adding digit

result = result*10 + digit; index++

build number by shifting digits left and adding new digit

return sign * result

apply sign and return final integer

Output

42

Complexity Analysis

Time: O(n) because we scan the string once from left to right

Space: O(1) because we use only fixed extra space for variables

vs Alternative: This is more efficient than parsing with built-in functions that may do extra checks or allocations

Edge Cases

empty string

returns 0 because no digits to convert

DSA Go

for index < n && s[index] == ' ' { index++ }

string with only spaces

returns 0 after skipping all spaces

DSA Go

for index < n && s[index] == ' ' { index++ }

string with sign but no digits

returns 0 because no digits found after sign

DSA Go

for index < n { ch := s[index]; if ch < '0' || ch > '9' { break }

number exceeding 32-bit int max

returns INT_MAX or INT_MIN to avoid overflow

DSA Go

if result > (INT_MAX-digit)/10 { return INT_MAX or INT_MIN }

When to Use This Pattern

When you need to convert a string to a number manually, especially handling spaces, signs, and overflow, use the atoi pattern to parse character by character.

Common Mistakes

Mistake: Not handling leading spaces before the number
Fix: Add a loop to skip all spaces before processing digits

Mistake: Ignoring sign character '+' or '-'
Fix: Check for sign character and record sign before digit conversion

Mistake: Not checking for integer overflow before adding new digit
Fix: Add overflow check before multiplying and adding digit

Mistake: Stopping conversion too late or too early
Fix: Stop conversion exactly when a non-digit character is found

Summary

Converts a string into an integer by reading digits and handling sign and overflow.

Use when you need to parse numbers from strings without built-in parsing functions.

The key insight is to process characters one by one, build the number, and carefully handle edge cases like spaces, signs, and overflow.

Practice

1. What does the atoi function do in the context of strings and integers?

easy

A. Converts an integer into a string representation

B. Converts a string representing a number into an integer value

C. Checks if a string contains only digits

D. Splits a string into individual characters

Solution

1. Step 1: Understand the purpose of atoi

   The function atoi stands for ASCII to integer, meaning it converts a string of digits into an integer number.

2. Step 2: Compare options with definition

   Only Converts a string representing a number into an integer value correctly describes converting a numeric string to an integer value.

3. Final Answer:

   Converts a string representing a number into an integer value -> Option B

4. Quick Check:

   atoi converts string to int [OK]

Hint: Remember atoi means ASCII to integer conversion [OK]

Common Mistakes:

• Confusing atoi with integer to string conversion
• Thinking atoi splits strings
• Assuming atoi validates string digits only

2. Which of the following Go code snippets correctly converts the string "1234" to an integer using strconv.Atoi?

easy

A. num, err := strconv.Atoi("1234")

B. num := strconv.Atoi("1234")

C. num := strconv.Atoi(1234)

D. num, err := strconv.Atoi(1234)

Solution

1. Step 1: Check function signature of strconv.Atoi

   It returns two values: an integer and an error, so both must be captured.

2. Step 2: Verify argument type

   The argument must be a string, so "1234" is correct, not 1234 (int).

3. Final Answer:

   num, err := strconv.Atoi("1234") -> Option A

4. Quick Check:

   Correct syntax captures int and error [OK]

Hint: Always capture both int and error from strconv.Atoi [OK]

Common Mistakes:

• Not capturing the error return value
• Passing an integer instead of a string
• Using single return variable for two returns

3. What will be the output of the following Go code?

package main
import (
  "fmt"
  "strconv"
)
func main() {
  s := "-42"
  num, err := strconv.Atoi(s)
  if err != nil {
    fmt.Println("Error")
  } else {
    fmt.Println(num)
  }
}

medium

A. -42

B. 42

C. Error

D. 0

Solution

1. Step 1: Understand input string and conversion

   The string "-42" is a valid integer representation including a negative sign.

2. Step 2: Check error handling and output

   Since "-42" is valid, err will be nil and num will be -42, so it prints -42.

3. Final Answer:

   -42 -> Option A

4. Quick Check:

   Valid negative string converts to negative int [OK]

Hint: Negative strings convert correctly with atoi [OK]

Common Mistakes:

• Assuming negative sign causes error
• Expecting absolute value output
• Ignoring error check

4. Identify the error in the following Go code snippet that uses strconv.Atoi:

package main
import (
  "fmt"
  "strconv"
)
func main() {
  s := "12a4"
  num, _ := strconv.Atoi(s)
  fmt.Println(num)
}

medium

A. Missing import of strconv package

B. Using fmt.Println instead of fmt.Print

C. Passing a string with letters to strconv.Atoi is allowed

D. Ignoring the error returned by strconv.Atoi

Solution

1. Step 1: Analyze input string validity

   The string "12a4" contains a letter 'a', so it is not a valid integer string.

2. Step 2: Check error handling in code

   The code ignores the error by using underscore _, so it prints zero value 0 without warning.

3. Final Answer:

   Ignoring the error returned by strconv.Atoi -> Option D

4. Quick Check:

   Always check error when converting strings [OK]

Hint: Never ignore error from atoi, always check it [OK]

Common Mistakes:

• Assuming invalid strings convert to partial numbers
• Ignoring error causes silent wrong output
• Thinking fmt.Println usage is wrong

5. You want to convert a list of strings ["10", "-5", "abc", "20"] to integers using strconv.Atoi. Which approach correctly handles invalid strings and collects only valid integers?

hard

A. Use strconv.Atoi only on first string, ignore rest

B. Convert all strings without error check and append results directly

C. Loop over strings, convert each with strconv.Atoi, append to result only if error is nil

D. Convert strings to integers using strconv.Itoa

Solution

1. Step 1: Understand the problem requirements

   We must convert multiple strings to integers and skip invalid ones safely.

2. Step 2: Evaluate each option's correctness

   Loop over strings, convert each with strconv.Atoi, append to result only if error is nil correctly loops, converts, checks error, and appends valid integers only.

3. Final Answer:

   Loop over strings, convert each with strconv.Atoi, append to result only if error is nil -> Option C

4. Quick Check:

   Check error for each conversion before appending [OK]

Hint: Check error for each string before adding integer [OK]

Common Mistakes:

• Appending invalid conversions without error check
• Using strconv.Itoa which converts int to string
• Ignoring invalid strings completely