Reading input basics in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code reading input?

Consider this Rust program that reads a line from the user and prints it back:

use std::io::{self, Write};

fn main() {
    let mut input = String::new();
    print!("Enter your name: ");
    io::stdout().flush().unwrap();
    io::stdin().read_line(&mut input).unwrap();
    println!("Hello, {}!", input.trim());
}

If the user types Alex and presses Enter, what will be printed?

Rust

use std::io::{self, Write};

fn main() {
    let mut input = String::new();
    print!("Enter your name: ");
    io::stdout().flush().unwrap();
    io::stdin().read_line(&mut input).unwrap();
    println!("Hello, {}!", input.trim());
}

A Enter your name: Hello, Alex!

B Hello, Alex!\n

C Hello, Alex!\nEnter your name:

D Enter your name: Hello, Alex!\n

💡 Hint

Remember that print! does not add a newline, so the prompt stays on the same line.

The print! macro prints the prompt without a newline, so the cursor stays on the same line. The user types Alex and presses Enter. The program then prints Hello, Alex! with a newline. So the full output is the prompt and the greeting on the same line, followed by a newline.

❓ Predict Output

intermediate

What error occurs when reading input without mutable String?

Look at this Rust code snippet:

use std::io;

fn main() {
    let input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    println!("You typed: {}", input);
}

What error will the compiler produce?

Rust

use std::io;

fn main() {
    let input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    println!("You typed: {}", input);
}

A error: missing semicolon after `String::new()`

B error: cannot borrow immutable local variable `input` as mutable

C error: expected `&mut String` but found `&String`

D error: cannot move out of borrowed content

💡 Hint

Think about whether the variable can be changed when passed as mutable reference.

The variable input is declared as immutable by default. The read_line function requires a mutable reference to modify the string. So the compiler complains that you cannot borrow an immutable variable as mutable.

❓ Predict Output

advanced

What is the output of this Rust code reading multiple inputs?

Consider this Rust program:

use std::io;

fn main() {
    let mut buffer = String::new();
    io::stdin().read_line(&mut buffer).unwrap();
    let numbers: Vec = buffer
        .trim()
        .split_whitespace()
        .map(|x| x.parse().unwrap())
        .collect();
    println!("Sum: {}", numbers.iter().sum::());
}

If the user inputs 10 20 30 and presses Enter, what will be printed?

Rust

use std::io;

fn main() {
    let mut buffer = String::new();
    io::stdin().read_line(&mut buffer).unwrap();
    let numbers: Vec<i32> = buffer
        .trim()
        .split_whitespace()
        .map(|x| x.parse().unwrap())
        .collect();
    println!("Sum: {}", numbers.iter().sum::<i32>());
}

A Sum: 60

B Sum: 10 20 30

C Sum: 0

D Sum: 102030

💡 Hint

Think about how the input string is split and parsed into numbers before summing.

The input string is split by whitespace into three strings: "10", "20", "30". Each is parsed into an integer and collected into a vector. The sum of these integers is 10 + 20 + 30 = 60.

❓ Predict Output

advanced

What error occurs when parsing invalid input to integer?

Look at this Rust code:

use std::io;

fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    let num: i32 = input.trim().parse().unwrap();
    println!("Number is {}", num);
}

If the user types abc and presses Enter, what happens?

Rust

use std::io;

fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    let num: i32 = input.trim().parse().unwrap();
    println!("Number is {}", num);
}

A Program panics with a parse error

B Program prints: Number is 0

C Program waits for more input

D Program prints: Number is abc

💡 Hint

What happens if you try to convert a non-number string to an integer?

The parse() method tries to convert the trimmed input to an integer. Since "abc" is not a valid number, unwrap() causes the program to panic with a parse error.

🧠 Conceptual

expert

How to correctly read multiple lines of input until EOF in Rust?

You want to read multiple lines from standard input until there is no more input (EOF). Which Rust code snippet correctly does this?

A

use std::io;

fn main() {
    let mut input = String::new();
    while io::stdin().read_line(&mut input).unwrap() != 0 {
        println!("Read: {}", input);
        input.clear();
    }
}

B

use std::io;

fn main() {
    let mut input = String::new();
    while io::stdin().read_line(&mut input).unwrap() > 0 {
        println!("Read: {}", input.trim());
        input.clear();
    }
}

C

use std::io::{self, BufRead};

fn main() {
    for line in io::stdin().lock().lines() {
        let line = line.unwrap();
        println!("Read: {}", line);
    }
}

D

use std::io;

fn main() {
    loop {
        let mut input = String::new();
        io::stdin().read_line(&mut input).unwrap();
        if input.is_empty() { break; }
        println!("Read: {}", input.trim());
    }
}

💡 Hint

Think about how to handle input lines safely and efficiently until EOF.

Option C uses io::stdin().lock().lines() which returns an iterator over lines until EOF. It unwraps each line safely and prints it. This is the idiomatic and correct way to read multiple lines until EOF in Rust.

Option C is close but reuses the same string without clearing it properly before reading, which can cause concatenation issues.

Option C checks if the input string is empty, but read_line returns 0 on EOF, not an empty string, so it may loop infinitely.

Option C does not clear the input string, so it will print accumulated input repeatedly.

Practice

1. What is the main purpose of using io::stdin().read_line(&mut input) in Rust?

easy

A. To read a line of text input from the user

B. To print text to the console

C. To declare a new variable

D. To create a new thread

Solution

1. Step 1: Understand the function of read_line

   This function reads a line of input from the user and stores it in a mutable string.

2. Step 2: Identify the purpose of io::stdin()

   io::stdin() accesses the standard input stream, allowing the program to receive user input.

3. Final Answer:

   To read a line of text input from the user -> Option A

4. Quick Check:

   Reading input = B [OK]

Hint: Remember: read_line reads user input into a string [OK]

Common Mistakes:

• Confusing input reading with printing output
• Forgetting to make the string mutable
• Using read_line without a mutable reference

2. Which of the following is the correct way to declare a mutable string variable to store user input in Rust?

easy

A. let input: &str = String::new();

B. let input = String::new();

C. let mut input = String::new();

D. let mut input: &str = String::new();

Solution

1. Step 1: Identify the need for mutability

   To store user input, the string must be mutable because read_line modifies it.

2. Step 2: Check the correct syntax for mutable String

   let mut input = String::new(); correctly declares a mutable String variable.

3. Final Answer:

   let mut input = String::new(); -> Option C

4. Quick Check:

   Mutable String declaration = A [OK]

Hint: Use 'mut' to allow input string to change [OK]

Common Mistakes:

• Omitting 'mut' keyword for the input string
• Using &str instead of String for input storage
• Declaring input as immutable

3. What will be the output of this Rust code if the user types "hello" and presses Enter?

use std::io;

fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    println!("You typed: {}", input.trim());
}

medium

A. Compilation error

B. You typed: hello

C. You typed:

D. You typed: hello\n

Solution

1. Step 1: Understand input reading and trimming

   The program reads the input including the newline, but trim() removes whitespace like newlines.

2. Step 2: Analyze the output statement

   The trimmed input "hello" is printed after "You typed: ".

3. Final Answer:

   You typed: hello -> Option B

4. Quick Check:

   Trim removes newline, output = D [OK]

Hint: Remember to trim input to remove newline before printing [OK]

Common Mistakes:

• Not trimming input, so newline appears in output
• Expecting raw input without newline removal
• Confusing compile errors with runtime behavior

4. Identify the error in this Rust code snippet that tries to read user input:

use std::io;

fn main() {
    let input = String::new();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    println!("Input: {}", input);
}

medium

A. The variable 'input' should be mutable

B. Missing 'use std::io::Write;' import

C. read_line should not use '&mut' reference

D. println! macro syntax is incorrect

Solution

1. Step 1: Check variable mutability

   read_line requires a mutable reference to modify the string, but input is not mutable.

2. Step 2: Confirm other parts are correct

   Imports and println! syntax are correct; only mutability is missing.

3. Final Answer:

   The variable 'input' should be mutable -> Option A

4. Quick Check:

   Mutable variable needed for read_line = C [OK]

Hint: Make input mutable to allow read_line to change it [OK]

Common Mistakes:

• Forgetting 'mut' keyword for input variable
• Thinking &mut is not needed for read_line
• Assuming println! syntax is wrong

5. You want to read a user's age as an integer from input. Which code snippet correctly reads the input, trims it, and converts it to an i32 in Rust?

hard

A. let age = String::new(); io::stdin().read_line(&age).expect("Failed"); let age: i32 = age.trim().parse().unwrap();

B. let age: i32 = io::stdin().read_line().trim().parse().expect("Invalid number");

C. let mut age = String::new(); io::stdin().read_line(age).expect("Failed"); let age: i32 = age.parse().unwrap();

D. let mut age = String::new(); io::stdin().read_line(&mut age).expect("Failed"); let age: i32 = age.trim().parse().expect("Invalid number");

Solution

1. Step 1: Read input into a mutable String

   Input must be stored in a mutable String variable passed as a mutable reference to read_line.

2. Step 2: Trim and parse input to i32

   Use trim() to remove whitespace, then parse() to convert to integer, handling errors with expect().

3. Final Answer:

   let mut age = String::new(); io::stdin().read_line(&mut age).expect("Failed"); let age: i32 = age.trim().parse().expect("Invalid number"); -> Option D

4. Quick Check:

   Mutable input + trim + parse = A [OK]

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

Common Mistakes:

• Not making input string mutable
• Forgetting to trim before parsing
• Passing input without &mut to read_line