Reading input basics in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to read a line of input from the user.

Rust

use std::io;

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

Drag options to blanks, or click blank then click option'

Aread_exact

Bread_to_string

Cread_line

Dread

Attempts:

3 left

💡 Hint

Common Mistakes

Using read_to_string which reads until EOF, not just one line.

Using read_exact which requires a fixed number of bytes.

The read_line method reads a line from standard input into the given string buffer.

2fill in blank

medium

Complete the code to trim whitespace from the input string.

Rust

use std::io;

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

Drag options to blanks, or click blank then click option'

Atrim

Btrim_start

Ctrim_end

Dstrip

Attempts:

3 left

💡 Hint

Common Mistakes

Using trim_start or trim_end which only remove whitespace from one side.

Using strip which does not exist in Rust String.

The trim method removes whitespace from both ends of a string.

3fill in blank

hard

Fix the error in the code to parse the input string into an integer.

Rust

use std::io;

fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let num: i32 = input.[1]().parse().expect("Not a number");
    println!("Number is: {}", num);
}

Drag options to blanks, or click blank then click option'

Aclone

Bto_string

Cparse

Dtrim

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to parse the raw input string with newline, causing parse error.

Using to_string or clone which do not remove whitespace.

We use trim to remove newline and spaces before parsing the string to an integer.

4fill in blank

hard

Fill both blanks to create a dictionary (HashMap) from words to their lengths, filtering words longer than 3 characters.

Rust

use std::collections::HashMap;

fn main() {
    let words = vec!["apple", "cat", "banana", "dog"];
    let lengths: HashMap<_, _> = words.iter().map(|word| (word, word.len())).filter(|(_, &len)| len [1] 3).collect();
    println!("{:?}", lengths);
}

Drag options to blanks, or click blank then click option'

A<

B>

C>=

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' or '<=' which filters shorter words.

Using '>=' which includes words of length 3.

The filter keeps words whose length is greater than 3.

5fill in blank

hard

Fill all three blanks to read input, trim it, parse to i32, and print the number.

Rust

use std::io;

fn main() {
    let mut input = String::new();
    io::stdin().[1](&mut input).expect("Failed to read line");
    let num: i32 = input.[2]().parse().expect("Not a number");
    println!("You entered: {}", [3]);
}

Drag options to blanks, or click blank then click option'

Aread_line

Btrim

Cnum

Dparse

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to trim before parsing causing errors.

Printing the input string instead of the parsed number.

First, read a line with read_line. Then trim whitespace with trim. Finally, print the parsed number variable num.

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