Formatting output in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What macro is commonly used in Rust to print formatted output to the console?

The println! macro is used to print formatted output to the console in Rust.

beginner

How do you insert a variable's value inside a string using Rust's formatting syntax?

Use curly braces {} as placeholders inside the string, and pass the variable after the comma. For example: println!("Value: {}", x);

intermediate

What does the format specifier {:.2} do in Rust's formatting?

It formats a floating-point number to show exactly 2 digits after the decimal point.

intermediate

How can you align text to the right with a width of 10 characters in Rust formatting?

Use {:>10} inside the format string. This pads the text on the left to make the total width 10 characters.

beginner

What is the difference between print! and println! macros in Rust?

print! outputs text without adding a new line at the end, while println! adds a new line after printing.

Which macro in Rust adds a newline after printing?

A eprintln!

B print!

C format!

D println!

println! prints text and adds a newline. print! does not add a newline.

How do you format a floating-point number to 3 decimal places in Rust?

A {:.3}

B {:3}

C {.3}

D {3}

The syntax {:.3} formats a float to 3 decimal places.

What does {:>8} do in a format string?

A Left-align text with width 8

B Right-align text with width 8

C Center-align text with width 8

D Truncate text to 8 characters

{:>8} right-aligns the text and pads with spaces to width 8.

Which macro returns a formatted string without printing it?

A format!

B print!

C eprint!

D println!

format! creates a formatted string but does not print it.

How do you include a literal curly brace character in a Rust format string?

A Use single braces {}

B Escape with backslash \{

C Use double braces {{ or }}

D Use parentheses ()

Double braces {{ or }} print a literal curly brace.

Explain how to format a floating-point number to 2 decimal places and align it right with width 10 in Rust.

Think about combining precision and alignment inside the curly braces.

Describe the difference between print!, println!, and format! macros in Rust.

Consider what each macro does with the output.

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