String to Integer atoi in DSA Go - Execution Trace

Concept Flow - String to Integer atoi

Start

↓

Skip leading spaces

↓

Check sign '+' or '-'

↓

Read digits one by one

↓

Convert digit char to int

↓

Check overflow

↓

Add digit to result

↓

Next char is digit?

No→Return result with sign

Yes↓

Repeat reading digits

The process reads the string from left to right, skipping spaces, detecting sign, converting digits to number, checking overflow, and stopping at first non-digit.

Execution Sample

DSA Go

import "math"

func myAtoi(s string) int {
  i, sign, result := 0, 1, 0
  // skip spaces
  for i < len(s) && s[i] == ' ' { i++ }
  // check sign
  if i < len(s) && (s[i] == '+' || s[i] == '-') {
    if s[i] == '-' { sign = -1 }
    i++
  }
  // convert digits
  for i < len(s) && s[i] >= '0' && s[i] <= '9' {
    digit := int(s[i] - '0')
    // check overflow
    if result > (math.MaxInt32-digit)/10 { break }
    result = result*10 + digit
    i++
  }
  return sign * result
}

This code converts a string to an integer by skipping spaces, detecting sign, reading digits, checking overflow, and returning the signed integer.

Execution Table

Step	Operation	Index i	Current Char	Sign	Result	Overflow Check	Action	Visual State
1	Start	0	' '	1	0	N/A	Skip space	Result=0, i=1
2	Skip space	1	' '	1	0	N/A	Skip space	Result=0, i=2
3	Skip space	2	'4'	1	0	N/A	Stop skipping	Result=0, i=2
4	Check sign	2	'4'	1	0	N/A	No sign change	Sign=1, i=2
5	Read digit	2	'4'	1	0	0 <= (2147483647-4)/10	Add digit 4	Result=4, i=3
6	Read digit	3	'2'	1	4	4 <= (2147483647-2)/10	Add digit 2	Result=42, i=4
7	Read digit	4	'7'	1	42	42 <= (2147483647-7)/10	Add digit 7	Result=427, i=5
8	Read digit	5	' '	1	427	N/A	Stop reading digits	Final Result=427
9	Return	5	N/A	1	427	N/A	Return 427	Output=427

💡 Stopped reading digits at index 5 because current char is not a digit

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 5	After Step 6	After Step 7	Final
i	0	1	2	2	3	4	5	5
sign	1	1	1	1	1	1	1	1
result	0	0	0	0	4	42	427	427

Key Moments - 3 Insights

Why do we skip spaces before processing digits?

Because the function ignores leading spaces to find the actual number start, as shown in execution_table steps 1-3 where i moves past spaces before reading digits.

How does the function handle the sign '+' or '-'?

At step 4, the code checks if the current character is '+' or '-'. If '-', sign becomes -1; otherwise, it stays 1. This affects the final returned result.

Why do we check for overflow before adding a digit?

To avoid exceeding the 32-bit integer limit, the code checks if result > (MaxInt32 - digit)/10 before multiplying and adding. This prevents incorrect results or crashes, as seen in steps 5-7.

Visual Quiz - 3 Questions

Look at the execution_table at step 6, what is the value of 'result' after adding the digit?

A 427

B 42

C 4

D 0

💡 Hint

Check the 'Result' column at step 6 in the execution_table.

At which step does the function stop reading digits because the current character is not a digit?

A Step 5

B Step 7

C Step 8

D Step 4

💡 Hint

Look for the step where 'Current Char' is not a digit and action is 'Stop reading digits' in the execution_table.

If the input string started with '-', what would be the value of 'sign' after step 4?

A -1

B 1

C 0

D Undefined

💡 Hint

Refer to the 'Check sign' operation in execution_table step 4 and variable_tracker for 'sign'.

Concept Snapshot

String to Integer (atoi) conversion:
- Skip leading spaces
- Detect optional '+' or '-' sign
- Convert digits to integer one by one
- Check for 32-bit integer overflow before adding digit
- Stop at first non-digit character
- Return signed integer result

Full Transcript

This visual trace shows how the string to integer conversion works step-by-step. First, it skips spaces until it finds a non-space character. Then it checks if the next character is a sign '+' or '-'. After that, it reads digits one by one, converting each character to its integer value. Before adding a digit, it checks if adding it would cause overflow beyond 32-bit integer limits. If so, it stops reading further digits. Finally, it returns the integer with the correct sign. The execution table tracks the index, current character, sign, result, and actions at each step. The variable tracker shows how 'i', 'sign', and 'result' change over time. Key moments clarify why spaces are skipped, how sign is handled, and why overflow checks are important. The quiz tests understanding of these steps.

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