Matching multiple patterns in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to match the variable against multiple values.

Rust

let x = 3;
match x {
    [1] => println!("Matched 1 or 2"),
    _ => println!("No match"),
}

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

A7 | 8

B1 | 2

C5 | 6

D3 | 4

Attempts:

3 left

💡 Hint

Common Mistakes

Using commas instead of '|' to separate values.

Forgetting to use a pattern and writing a value directly.

The pattern '1 | 2' matches if x is 1 or 2.

2fill in blank

medium

Complete the match arm to handle vowels 'a', 'e', 'i', 'o', or 'u'.

Rust

let letter = 'e';
match letter {
    [1] => println!("It's a vowel"),
    _ => println!("It's a consonant"),
}

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

A'a' | 'e' | 'i' | 'o' | 'u'

B'b' | 'c' | 'd' | 'f' | 'g'

C'm' | 'n' | 'p'

D'x' | 'y' | 'z'

Attempts:

3 left

💡 Hint

Common Mistakes

Using double quotes instead of single quotes for characters.

Missing some vowels in the pattern.

The pattern matches any vowel character.

3fill in blank

hard

Fix the error in the match pattern to correctly match 10 or 20.

Rust

let num = 10;
match num {
    [1] => println!("Matched 10 or 20"),
    _ => println!("No match"),
}

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

A[10, 20]

B10, 20

C10 | 20

D(10, 20)

Attempts:

3 left

💡 Hint

Common Mistakes

Using commas to separate values in a pattern.

Using tuple or array syntax instead of pattern matching.

Use '|' to match multiple values in a pattern, not commas or brackets.

4fill in blank

hard

Fill both blanks to match digits 1-3 and letters 'a' or 'b'.

Rust

let value = 'b';
match value {
    [1] => println!("Digit 1 to 3"),
    [2] => println!("Letter a or b"),
    _ => println!("Other"),
}

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

A'1' | '2' | '3'

B'4' | '5' | '6'

C'a' | 'b'

D'c' | 'd'

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing digits and letters in the same pattern.

Using commas instead of '|'.

The first blank matches digits '1', '2', or '3'. The second blank matches letters 'a' or 'b'.

5fill in blank

hard

Fill all three blanks to match uppercase vowels, lowercase vowels, and digits 0-2.

Rust

let ch = 'A';
match ch {
    [1] => println!("Uppercase vowel"),
    [2] => println!("Lowercase vowel"),
    [3] => println!("Digit 0 to 2"),
    _ => println!("Other"),
}

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

A'A' | 'E' | 'I' | 'O' | 'U'

B'a' | 'e' | 'i' | 'o' | 'u'

C'0' | '1' | '2'

D'3' | '4' | '5'

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing uppercase and lowercase characters.

Using incorrect digits or missing some vowels.

The blanks match uppercase vowels, lowercase vowels, and digits 0 to 2 respectively.

Practice

1. In Rust, which symbol is used to match multiple patterns in a single match arm?

easy

A. |

B. &

C. +

D. &&

Solution

1. Step 1: Recall the syntax for matching multiple patterns

   Rust uses the vertical bar | to separate multiple patterns in one match arm.

2. Step 2: Identify the correct symbol

   The symbol | means "or" in pattern matching, allowing multiple cases to be handled together.

3. Final Answer:

   | -> Option A

4. Quick Check:

   Multiple patterns use | in match arms [OK]

Hint: Use | to combine patterns in one match arm [OK]

Common Mistakes:

• Using & instead of |
• Confusing + with pattern separator
• Using && which is logical AND, not pattern OR

2. Which of the following Rust match arms correctly matches the values 1, 2, or 3 using multiple patterns?

easy

A. 1 & 2 & 3 => println!("Matched 1, 2, or 3"),

B. 1 | 2 | 3 => println!("Matched 1, 2, or 3"),

C. 1 + 2 + 3 => println!("Matched 1, 2, or 3"),

D. 1, 2, 3 => println!("Matched 1, 2, or 3"),

Solution

1. Step 1: Check the syntax for multiple patterns

   Rust uses | to separate multiple patterns in a match arm, so 1 | 2 | 3 is correct.

2. Step 2: Identify incorrect options

   & is not used for matching multiple patterns, + is arithmetic, and commas are invalid here.

3. Final Answer:

   1 | 2 | 3 => println!("Matched 1, 2, or 3"), -> Option B

4. Quick Check:

   Multiple patterns use | separator [OK]

Hint: Separate patterns with | inside match arms [OK]

Common Mistakes:

• Using & instead of | for multiple patterns
• Trying to separate patterns with commas
• Using + which is arithmetic, not pattern matching

3. What will be the output of this Rust code?

let x = 2;
match x {
    1 | 2 | 3 => println!("Small number"),
    4 | 5 | 6 => println!("Medium number"),
    _ => println!("Other number"),
}

medium

A. Compilation error

B. Medium number

C. Small number

D. Other number

Solution

1. Step 1: Identify which pattern matches x=2

   The first arm matches 1, 2, or 3. Since x is 2, it matches this arm.

2. Step 2: Determine the output

   The matched arm prints "Small number" to the console.

3. Final Answer:

   Small number -> Option C

4. Quick Check:

   2 matches 1|2|3 arm [OK]

Hint: Check which pattern includes the value [OK]

Common Mistakes:

• Choosing Medium number for 2
• Thinking _ arm matches first
• Assuming syntax error due to multiple patterns

4. Find the error in this Rust code snippet that tries to match multiple patterns:

let ch = 'a';
match ch {
    'a' | 'e' | 'i' | 'o' | 'u' => println!("Vowel"),
    'a' | 'b' => println!("Letter a or b"),
    _ => println!("Other"),
}

medium

A. Missing semicolon after println! macros

B. Match expression missing a default arm

C. Incorrect use of | operator for multiple patterns

D. Duplicate pattern 'a' in multiple arms causes unreachable code

Solution

1. Step 1: Identify duplicate patterns in match arms

   The character 'a' appears in both the first and second arms, causing the second arm's 'a' pattern to be unreachable.

2. Step 2: Understand Rust's pattern matching rules

   Rust does not allow unreachable patterns; the compiler will warn or error about the duplicate 'a'.

3. Final Answer:

   Duplicate pattern 'a' in multiple arms causes unreachable code -> Option D

4. Quick Check:

   Duplicate patterns cause unreachable code errors [OK]

Hint: Avoid repeating same pattern in multiple match arms [OK]

Common Mistakes:

• Ignoring unreachable pattern warnings
• Thinking | is invalid for multiple patterns
• Missing default arm (actually present here)

5. You want to write a Rust function that returns "Weekend" for Saturday or Sunday, "Weekday" for Monday to Friday, and "Invalid" otherwise. Which match arm correctly uses multiple patterns to do this?

fn day_type(day: &str) -> &str {
    match day {
        ? => "Weekend",
        ? => "Weekday",
        _ => "Invalid",
    }
}

hard

A. "Saturday" | "Sunday",
"Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday"

B. "Saturday", "Sunday",
"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"

C. "Saturday" & "Sunday",
"Monday" & "Tuesday" & "Wednesday" & "Thursday" & "Friday"

D. "Saturday" + "Sunday",
"Monday" + "Tuesday" + "Wednesday" + "Thursday" + "Friday"

Solution

1. Step 1: Use | to match multiple string patterns in one arm

   Rust allows multiple patterns separated by | to group cases like "Saturday" | "Sunday".

2. Step 2: Check other options for invalid syntax

   Commas separate arms, not patterns; & and + are invalid for pattern matching.

3. Final Answer:

   "Saturday" | "Sunday", "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" -> Option A

4. Quick Check:

   Use | to combine multiple string patterns [OK]

Hint: Use | to combine multiple string patterns in match arms [OK]

Common Mistakes:

• Using commas instead of | inside match arms
• Using & or + which are invalid for patterns
• Forgetting to cover all weekdays or weekend days