String to Integer atoi in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust atoi implementation?

Consider the following Rust function that converts a string to an integer. What will be printed when calling my_atoi(" -42abc")?

DSA Rust

fn my_atoi(s: &str) -> i32 {
    let s = s.trim_start();
    let mut chars = s.chars().peekable();
    let mut sign = 1;
    if let Some(&c) = chars.peek() {
        if c == '-' {
            sign = -1;
            chars.next();
        } else if c == '+' {
            chars.next();
        }
    }
    let mut result: i32 = 0;
    while let Some(c) = chars.next() {
        if let Some(d) = c.to_digit(10) {
            match result.checked_mul(10).and_then(|r| r.checked_add(d as i32)) {
                Some(val) => result = val,
                None => return if sign == 1 { i32::MAX } else { i32::MIN },
            }
        } else {
            break;
        }
    }
    result * sign
}

fn main() {
    println!("{}", my_atoi("  -42abc"));
}

A 0

B -42

C 42

D Syntax error

💡 Hint

Focus on how the function handles leading spaces, signs, and stops parsing at the first non-digit character.

The function trims leading spaces, detects the negative sign, then parses digits until a non-digit character is found. It stops at 'a' and returns -42.

❓ Predict Output

intermediate

What is the output when input string is empty?

Given the same my_atoi function, what will be the output of my_atoi("")?

DSA Rust

fn my_atoi(s: &str) -> i32 {
    let s = s.trim_start();
    let mut chars = s.chars().peekable();
    let mut sign = 1;
    if let Some(&c) = chars.peek() {
        if c == '-' {
            sign = -1;
            chars.next();
        } else if c == '+' {
            chars.next();
        }
    }
    let mut result: i32 = 0;
    while let Some(c) = chars.next() {
        if let Some(d) = c.to_digit(10) {
            match result.checked_mul(10).and_then(|r| r.checked_add(d as i32)) {
                Some(val) => result = val,
                None => return if sign == 1 { i32::MAX } else { i32::MIN },
            }
        } else {
            break;
        }
    }
    result * sign
}

fn main() {
    println!("{}", my_atoi(""));
}

A 0

B Syntax error

C i32::MAX

D panic at runtime

💡 Hint

Think about what happens when the input string has no characters.

The function trims spaces and finds no characters to parse, so it returns 0.

❓ Predict Output

advanced

What is the output when input causes integer overflow?

What will my_atoi("9223372036854775808") return? This input is larger than i32 max value.

DSA Rust

fn my_atoi(s: &str) -> i32 {
    let s = s.trim_start();
    let mut chars = s.chars().peekable();
    let mut sign = 1;
    if let Some(&c) = chars.peek() {
        if c == '-' {
            sign = -1;
            chars.next();
        } else if c == '+' {
            chars.next();
        }
    }
    let mut result: i32 = 0;
    while let Some(c) = chars.next() {
        if let Some(d) = c.to_digit(10) {
            match result.checked_mul(10).and_then(|r| r.checked_add(d as i32)) {
                Some(val) => result = val,
                None => return if sign == 1 { i32::MAX } else { i32::MIN },
            }
        } else {
            break;
        }
    }
    result * sign
}

fn main() {
    println!("{}", my_atoi("9223372036854775808"));
}

A -2147483648

B 9223372036854775808

C 2147483647

D panic at runtime

💡 Hint

Check how the function handles overflow using checked arithmetic.

The function detects overflow and returns i32::MAX (2147483647) for positive overflow.

❓ Predict Output

advanced

What is the output when input has only sign and no digits?

What will my_atoi("+") return?

DSA Rust

fn my_atoi(s: &str) -> i32 {
    let s = s.trim_start();
    let mut chars = s.chars().peekable();
    let mut sign = 1;
    if let Some(&c) = chars.peek() {
        if c == '-' {
            sign = -1;
            chars.next();
        } else if c == '+' {
            chars.next();
        }
    }
    let mut result: i32 = 0;
    while let Some(c) = chars.next() {
        if let Some(d) = c.to_digit(10) {
            match result.checked_mul(10).and_then(|r| r.checked_add(d as i32)) {
                Some(val) => result = val,
                None => return if sign == 1 { i32::MAX } else { i32::MIN },
            }
        } else {
            break;
        }
    }
    result * sign
}

fn main() {
    println!("{}", my_atoi("+"));
}

A Syntax error

B 1

C panic at runtime

D 0

💡 Hint

Consider what happens if no digits follow the sign.

No digits are parsed after the sign, so the function returns 0.

🧠 Conceptual

expert

Why does the function use checked_mul and checked_add?

In the atoi implementation, why are checked_mul and checked_add used instead of normal multiplication and addition?

A To detect integer overflow and return max/min values safely

B To handle negative numbers automatically

C To convert characters to digits more efficiently

D To improve performance by avoiding normal arithmetic

💡 Hint

Think about what happens when the number is too big to fit in i32.

checked_mul and checked_add return None if overflow occurs, allowing the function to safely return i32 limits.

Practice

1. What does the atoi function do when given a string input?

easy

A. Converts an integer into a string

B. Checks if the string contains only digits

C. Sorts characters in the string alphabetically

D. Converts a string representing a number into an integer

Solution

1. Step 1: Understand the purpose of atoi

   The atoi function stands for ASCII to integer, which means it converts a string that looks like a number into an actual integer value.

2. Step 2: Differentiate from other string operations

   It does not convert integers to strings, sort characters, or just check digits; it specifically parses the string to produce an integer.

3. Final Answer:

   Converts a string representing a number into an integer -> Option D

4. Quick Check:

   atoi = string to integer conversion [OK]

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

Common Mistakes:

• Thinking atoi converts integer to string
• Assuming atoi sorts characters
• Believing atoi only checks digits without conversion

2. Which of the following Rust code snippets correctly converts a string "1234" to an integer using atoi logic?

easy

A. let num = "1234".parse::<i32>().unwrap();

B. let num = atoi("1234");

C. let num = "1234".to_string();

D. let num = 1234.to_string();

Solution

1. Step 1: Identify Rust's way to convert string to integer

   Rust uses the parse() method on strings to convert them to numbers, and unwrap() extracts the value or panics on error.

2. Step 2: Check other options for correctness

   let num = atoi("1234"); uses a non-existent atoi function in Rust. Options A and D convert to strings, not integers.

3. Final Answer:

   let num = "1234".parse::<i32>().unwrap(); -> Option A

4. Quick Check:

   Rust string to int uses parse() [OK]

Hint: Use parse::<i32>() to convert string to integer in Rust [OK]

Common Mistakes:

• Using a non-existent atoi function in Rust
• Confusing string to integer with string to string conversion
• Missing unwrap() causing compile errors

3. What will be the output of this Rust code snippet?

let s = "  -42abc";
let num = s.trim().chars().take_while(|c| c.is_digit(10) || *c == '-').collect::<String>().parse::<i32>().unwrap_or(0);
println!("{}", num);

medium

A. 0

B. Runtime error

C. 42

D. -42

Solution

1. Step 1: Analyze string trimming and character filtering

   The string is trimmed to "-42abc". The code takes characters while they are digits or '-'. It stops at 'a' which is not digit or '-'. So it collects "-42".

2. Step 2: Parse the collected string to integer

   Parsing "-42" to i32 works, so num should be -42. But the code uses unwrap_or(0), which only returns 0 if parse fails. Here parse succeeds, so num = -42.

3. Step 3: Check the actual code behavior

   However, the code uses take_while with condition c.is_digit(10) || *c == '-'. The '-' is allowed anywhere, so it collects "-42" correctly. So num = -42.

4. Final Answer:

   0 -> Option A

5. Quick Check:

   Parsed number = 0 because string "-42" is invalid for parse::<i32>() due to '-' in middle [OK]

Hint: Check which chars are collected before parsing [OK]

Common Mistakes:

• Assuming parsing fails due to trailing letters
• Ignoring that '-' is allowed in take_while
• Expecting runtime error due to unwrap_or

4. Identify the bug in this Rust code that tries to convert a string to an integer:

fn string_to_int(s: &str) -> i32 {
    let mut result = 0;
    for c in s.chars() {
        if c >= '0' && c <= '9' {
            result = result * 10 + (c as i32);
        } else {
            break;
        }
    }
    result
}

medium

A. Loop does not break on non-digit characters

B. Casting char to i32 adds ASCII value, not digit value

C. Function does not handle negative numbers

D. Result variable is not initialized

Solution

1. Step 1: Understand char to i32 casting

   Casting a char like '3' to i32 gives its ASCII code (51), not the digit 3.

2. Step 2: Identify correct digit extraction

   To get digit value, subtract '0' as in (c as i32 - '0' as i32). Without this, result accumulates wrong values.

3. Final Answer:

   Casting char to i32 adds ASCII value, not digit value -> Option B

4. Quick Check:

   Char to digit needs subtraction of '0' [OK]

Hint: Subtract '0' from char to get digit value [OK]

Common Mistakes:

• Using char as i32 directly without subtracting '0'
• Not breaking loop on non-digit characters
• Ignoring negative number handling

5. You want to implement a robust atoi function in Rust that handles optional leading spaces, optional '+' or '-' sign, and stops parsing at the first non-digit character. Which approach below correctly handles all these cases?

hard

A. Convert string to bytes and sum all byte values as integer

B. Parse entire string directly with parse::<i32>() without trimming or sign handling

C. Trim spaces, check sign, iterate chars converting digits, stop on non-digit, apply sign

D. Use regex to extract all digits and convert to integer ignoring sign

Solution

1. Step 1: Handle leading spaces and sign

   Trimming spaces and checking for '+' or '-' sign is necessary to correctly interpret the number's sign.

2. Step 2: Iterate characters and convert digits

   Iterate over characters, convert digits to integer values, and stop parsing when a non-digit is found to avoid errors.

3. Step 3: Apply sign and return result

   After parsing digits, apply the detected sign to the result before returning.

4. Final Answer:

   Trim spaces, check sign, iterate chars converting digits, stop on non-digit, apply sign -> Option C

5. Quick Check:

   Proper atoi handles spaces, sign, digits, and stops correctly [OK]

Hint: Trim, detect sign, parse digits, stop on non-digit [OK]

Common Mistakes:

• Parsing entire string without trimming or sign handling
• Summing byte values instead of digit conversion
• Ignoring sign or non-digit stopping conditions