Handling input values in Rust - Time & Space Complexity

Time Complexity: Handling input values

O(n)

Understanding Time Complexity

When handling input values in Rust, it's important to know how the program's work grows as the input size changes.

We want to see how the time to process inputs changes when we get more or fewer values.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

use std::io;

fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    let numbers: Vec = input
        .trim()
        .split_whitespace()
        .map(|x| x.parse().unwrap())
        .collect();
}
    

This code reads a line of input, splits it into parts, converts each part to a number, and stores them in a list.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Splitting the input string and parsing each piece into a number.
• How many times: Once for each value entered in the input line.

How Execution Grows With Input

As the number of input values grows, the program does more work to split and convert each one.

Input Size (n)	Approx. Operations
10	About 10 splits and parses
100	About 100 splits and parses
1000	About 1000 splits and parses

Pattern observation: The work grows directly with the number of input values.

Final Time Complexity

Time Complexity: O(n)

This means the time to handle input grows in a straight line with the number of values entered.

Common Mistake

[X] Wrong: "Reading input is always constant time no matter how many values."

[OK] Correct: The program must look at each input value to split and convert it, so more values mean more work.

Interview Connect

Understanding how input size affects processing time helps you write efficient programs and explain your code clearly in interviews.

Self-Check

"What if we read multiple lines of input instead of one? How would the time complexity change?"

Practice

1. What does the Rust function io::stdin().read_line(&mut input) do in a program?

easy

A. It clears the input buffer.

B. It writes a line of text to the screen.

C. It reads a line of text from the user and stores it in the variable input.

D. It converts a string to a number.

Solution

1. Step 1: Understand the function purpose

   io::stdin().read_line(&mut input) reads user input from the keyboard as a string.

2. Step 2: Recognize the role of input

   The input is stored in the mutable variable input passed by reference.

3. Final Answer:

   It reads a line of text from the user and stores it in the variable input. -> Option C

4. Quick Check:

   read_line reads user input [OK]

Hint: read_line reads user input into a variable [OK]

Common Mistakes:

• Thinking read_line writes output
• Confusing input reading with clearing buffer
• Assuming it converts types automatically

2. Which of the following Rust code snippets correctly reads a line of input and trims whitespace?

easy

A. let input = io::stdin().read_line().trim();

B. let mut input = String::new(); io::stdin().read_line(&mut input).expect("Failed"); let input = input.trim();

C. io::stdin().read_line(input); let input = input.trim();

D. let mut input = String::new(); io::stdin().read_line(input); input.trim();

Solution

1. Step 1: Check correct usage of read_line

   It requires a mutable String reference: read_line(&mut input).

2. Step 2: Confirm trimming is done on the input string

   Calling input.trim() removes whitespace correctly.

3. Final Answer:

   let mut input = String::new(); io::stdin().read_line(&mut input).expect("Failed"); let input = input.trim(); -> Option B

4. Quick Check:

   read_line needs &mut String and trim() cleans input [OK]

Hint: Use &mut String and call trim() after read_line [OK]

Common Mistakes:

• Forgetting &mut before input
• Calling trim() on read_line() result
• Not creating a mutable String first

3. What will be the output of this Rust code if the user inputs 42?

use std::io;
fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Failed");
    let num: i32 = input.trim().parse().expect("Not a number");
    println!("Number plus 10 is {}", num + 10);
}

medium

A. Number plus 10 is 52

B. Number plus 10 is 42

C. Not a number

D. Failed

Solution

1. Step 1: Read and parse input

   The input string "42" is trimmed and parsed to integer 42 successfully.

2. Step 2: Add 10 and print

   42 + 10 equals 52, so the output prints "Number plus 10 is 52".

3. Final Answer:

   Number plus 10 is 52 -> Option A

4. Quick Check:

   42 + 10 = 52 [OK]

Hint: Trim and parse input before math operations [OK]

Common Mistakes:

• Not trimming input before parse
• Parsing input as wrong type
• Ignoring parse errors

4. Identify the error in this Rust code snippet that reads an integer from input:

let mut input = String::new();
io::stdin().read_line(&mut input).expect("Failed");
let num: i32 = input.parse().expect("Not a number");
println!("Number: {}", num);

medium

A. parse() called without trimming input

B. Missing &mut before input in read_line

C. input is not mutable

D. println! macro syntax error

Solution

1. Step 1: Check read_line usage

   read_line correctly uses &mut input and input is mutable.

2. Step 2: Identify parse error cause

   parse() is called on input without trimming, so newline remains causing parse failure.

3. Final Answer:

   parse() called without trimming input -> Option A

4. Quick Check:

   Always trim input before parse() [OK]

Hint: Always trim input string before parsing to number [OK]

Common Mistakes:

• Forgetting to trim input before parse
• Assuming read_line returns trimmed string
• Misusing &mut in read_line

5. You want to read multiple numbers from user input separated by spaces and store them in a vector of integers. Which Rust code correctly does this?

use std::io;
fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Failed");
    let numbers: Vec<i32> = input.trim().split_whitespace()
        .map(|x| x.parse().expect("Not a number"))
        .collect();
    println!("Numbers: {:?}", numbers);
}

hard

A. read_line() cannot read multiple numbers at once.

B. Fails because split_whitespace() does not split strings.

C. parse() should be called before split_whitespace().

D. Correctly reads and parses space-separated numbers into a vector.

Solution

1. Step 1: Read input line and trim

   Input is read as a string and trimmed to remove trailing whitespace.

2. Step 2: Split and parse each number

   split_whitespace() splits input by spaces, map parses each piece to i32, collect gathers into vector.

3. Final Answer:

   Correctly reads and parses space-separated numbers into a vector. -> Option D

4. Quick Check:

   split_whitespace + map(parse) + collect = vector [OK]

Hint: Use split_whitespace, map parse, then collect to vector [OK]

Common Mistakes:

• Parsing before splitting input
• Using wrong iterator methods
• Assuming read_line reads multiple inputs separately