Handling input values 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 standard input 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!\nEnter your name:

C Enter your name: Hello, Alex\n!

D Hello, Alex!

💡 Hint

Remember that print! does not add a newline, so flushing is needed to show the prompt before input.

The program prints the prompt without a newline, flushes output to show it immediately, then reads input. After trimming the newline from input, it prints the greeting on the next line.

❓ Predict Output

intermediate

What error does this Rust code produce when reading input?

Look at this Rust code snippet:

use std::io;

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

What error will this code cause when compiled?

Rust

use std::io;

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

A error[E0599]: no method named `read_line` found for struct `String`

B error[E0308]: mismatched types: expected &mut String, found struct String

C No error, runs correctly

D error[E0425]: cannot find value `input` in this scope

💡 Hint

Check the argument type expected by read_line.

The method read_line expects a mutable reference &mut String, but the code passes input by value. This causes a type mismatch error.

🔧 Debug

advanced

Why does this Rust program panic when parsing input?

Examine 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 plus 10 is {}", num + 10);
}

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 plus 10 is {}", num + 10);
}

A Program panics with a parse error at unwrap()

B Program prints: Number plus 10 is 10

C Program prints: Number plus 10 is abc10

D Program waits for more input indefinitely

💡 Hint

What happens if parse() fails and you call unwrap()?

Parsing "abc" as an integer fails, so parse() returns an error. Calling unwrap() on an error causes the program to panic and crash.

📝 Syntax

advanced

Which Rust code correctly reads and parses an integer input?

Choose the Rust code snippet that correctly reads a line from input and parses it as an i32 without panicking.

A

let mut input = String::new();
io::stdin().read_line(&mut input).unwrap();
let num: i32 = input.parse().unwrap();

B

let mut input = String::new();
io::stdin().read_line(&mut input).unwrap();
let num: i32 = input.trim().parse().unwrap();

C

let mut input = String::new();
io::stdin().read_line(input).unwrap();
let num: i32 = input.trim().parse().unwrap();

D

let mut input = String::new();
io::stdin().read_line(&mut input).unwrap();
let num: i32 = match input.trim().parse() {
    Ok(n) => n,
    Err(_) => 0,
};

💡 Hint

Look for safe parsing that handles errors.

Option D uses match to handle parse errors safely, returning 0 if parsing fails. Others either panic or have syntax errors.

🚀 Application

expert

How many items are in the vector after this input processing?

This Rust program reads a line of space-separated numbers and collects them into a vector:

use std::io;

fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    let numbers: Vec = input
        .trim()
        .split(' ')
        .filter_map(|s| s.parse().ok())
        .collect();
    println!("Count: {}", numbers.len());
}

If the user inputs: 10 20 abc 30 40x 50 and presses Enter, what will be printed?

Rust

use std::io;

fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    let numbers: Vec<i32> = input
        .trim()
        .split(' ')
        .filter_map(|s| s.parse().ok())
        .collect();
    println!("Count: {}", numbers.len());
}

A Count: 5

B Count: 3

C Count: 4

D Count: 6

💡 Hint

Only valid integers are collected. Non-integers are skipped.

The input splits into: "10", "20", "abc", "30", "40x", "50". Only "10", "20", "30", and "50" parse as integers. So the vector length is 4.