Formatting output in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to print the value of x using Rust's formatting macro.

Rust

let x = 10;
println!("[1]", x);

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

A"{}"

B"{:?}"

C"{x}"

D"%d"

Attempts:

3 left

💡 Hint

Common Mistakes

Using %d like in C language.

Using {x} which is not valid in Rust formatting.

Using debug format {:?} when simple display is enough.

Rust uses {} inside println! to format and print values.

2fill in blank

medium

Complete the code to print the variable name with a greeting using Rust formatting.

Rust

let name = "Alice";
println!("Hello, [1]!", name);

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

A"name"

B"{:?}"

C"{}"

D"{name}"

Attempts:

3 left

💡 Hint

Common Mistakes

Putting the variable name inside quotes, which prints the literal text.

Using debug format {:?} unnecessarily.

Trying to use {name} without the new Rust feature for named arguments.

Use {} as a placeholder to insert the value of name in the string.

3fill in blank

hard

Fix the error in the code to correctly print the floating-point number with 2 decimal places.

Rust

let pi = 3.14159;
println!("Pi is approximately [1]", pi);

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

A"{:.2f}"

B"{:.2}"

C"{:2}"

D"{:.2p}"

Attempts:

3 left

💡 Hint

Common Mistakes

Using {:.2f} which is invalid in Rust.

Using {:2} which sets width, not decimal places.

Using {:.2p} which is not a valid format specifier.

Rust uses {:.2} to format a float with 2 decimal places. The f is not used.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps words to their lengths only if length is greater than 3.

Rust

let words = ["apple", "cat", "banana", "dog"];
let lengths = words.iter().filter(|&&word| word.len() [1] 3).map(|&word| (word, word.len())).collect::<std::collections::HashMap<_, _>>();

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

A!=

B<

C==

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using < which keeps shorter words.

Using == which keeps only words of length exactly 3.

Using != which keeps all words except length 3.

The filter should keep words with length greater than 3, so use >.

5fill in blank

hard

Fill all three blanks to create a formatted string that shows the name in uppercase, age, and a check if age is over 18.

Rust

let name = "bob";
let age = 20;
let info = format!("Name: [1], Age: [2], Adult: [3]", name.[1](), age, age [3] 18);

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

Ato_uppercase

Bage

C>

Dto_lowercase

Attempts:

3 left

💡 Hint

Common Mistakes

Using to_lowercase() instead of uppercase.

Using < instead of > for age comparison.

Not calling the method with parentheses.

Use to_uppercase() to capitalize the name, print age, and check if age > 18 for adult status.

Practice

1. What does the placeholder {} do in Rust's println! macro?

easy

A. It comments out the line in the code.

B. It inserts the value of a variable or expression into the string.

C. It creates a new variable inside the string.

D. It repeats the string multiple times.

Solution

1. Step 1: Understand the role of {} in formatting

   The {} acts as a placeholder where Rust inserts the value of a variable or expression inside a string.

2. Step 2: Recognize its use in println!

   When using println!("Hello, {}", name);, Rust replaces {} with the value of name.

3. Final Answer:

   It inserts the value of a variable or expression into the string. -> Option B

4. Quick Check:

   Placeholder {} = Insert value [OK]

Hint: Remember: {} means insert value here [OK]

Common Mistakes:

• Thinking {} creates variables
• Assuming {} repeats strings
• Confusing {} with comments

2. Which of the following is the correct syntax to format a floating-point number with 2 decimal places in Rust?

easy

A. println!("{:.2}", 3.14159);

B. println!("{2f}", 3.14159);

C. println!("{.2f}", 3.14159);

D. println!("{2}", 3.14159);

Solution

1. Step 1: Identify correct decimal formatting syntax

   Rust uses {:.2} inside println! to format a float with 2 decimal places.

2. Step 2: Check each option

   println!("{:.2}", 3.14159); uses {:.2}, which is correct. Others use invalid or incorrect syntax.

3. Final Answer:

   println!("{:.2}", 3.14159); -> Option A

4. Quick Check:

   Decimal places = {:.2} [OK]

Hint: Use {:.N} to set N decimal places [OK]

Common Mistakes:

• Using {2f} or {.2f} which is invalid in Rust
• Omitting the colon before precision
• Confusing with other language formats

3. What is the output of this Rust code?

let x = 255;
println!("Decimal: {}, Hex: {:x}, Binary: {:b}", x, x, x);

medium

A. Decimal: 255, Hex: FF, Binary: 11111111

B. Decimal: 255, Hex: ff, Binary: 1111111

C. Decimal: 255, Hex: 0xff, Binary: 11111111

D. Decimal: 255, Hex: ff, Binary: 11111111

Solution

1. Step 1: Understand formatting specifiers

   {} prints decimal, {:x} prints lowercase hex, {:b} prints binary.

2. Step 2: Convert 255 to hex and binary

   255 decimal is ff in hex (lowercase) and 11111111 in binary.

3. Final Answer:

   Decimal: 255, Hex: ff, Binary: 11111111 -> Option D

4. Quick Check:

   Hex lowercase = {:x}, Binary = {:b} [OK]

Hint: Use {:x} for hex lowercase, {:b} for binary [OK]

Common Mistakes:

• Expecting uppercase hex without :X
• Adding 0x prefix automatically
• Miscounting binary digits

4. Identify the error in this Rust code snippet:

let num = 42;
println!("Number: {2}", num);

medium

A. The println! macro requires a semicolon inside the string.

B. The variable num is not declared correctly.

C. The placeholder {2} refers to an argument index that does not exist.

D. Rust does not support numbered placeholders.

Solution

1. Step 1: Check placeholder indexing

   The placeholder {2} means use the third argument (index 2), but only one argument num is provided.

2. Step 2: Understand argument count mismatch

   Since only one argument exists, index 2 is out of range, causing a runtime error.

3. Final Answer:

   The placeholder {2} refers to an argument index that does not exist. -> Option C

4. Quick Check:

   Placeholder index must match argument count [OK]

Hint: Count arguments before using numbered placeholders [OK]

Common Mistakes:

• Using wrong index in placeholders
• Assuming Rust auto-corrects missing arguments
• Thinking semicolon needed inside string

5. You want to print a table of names and scores aligned in columns using Rust's formatting. Which code correctly aligns the names left in 10 spaces and scores right in 5 spaces?

let name = "Alice";
let score = 93;
// Which println! line is correct?

hard

A. println!("{:<10} | {:>5}", name, score);

B. println!("{:>10} | {:<5}", name, score);

C. println!("{:10} | {:5}", name, score);

D. println!("{:^10} | {:^5}", name, score);

Solution

1. Step 1: Understand alignment specifiers

   {:<10} aligns left in 10 spaces, {:>5} aligns right in 5 spaces.

2. Step 2: Match alignment to requirements

   Names should be left aligned, scores right aligned, so println!("{:<10} | {:>5}", name, score); matches perfectly.

3. Final Answer:

   println!("{:<10} | {:>5}", name, score); -> Option A

4. Quick Check:

   Left align = <, Right align = > [OK]

Hint: Use <: for left, >: for right alignment [OK]

Common Mistakes:

• Swapping alignment symbols
• Omitting width numbers
• Using center alignment when not needed