Nested conditions in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of nested if-else blocks

What is the output of this Rust code snippet?

Rust

fn main() {
    let x = 7;
    if x > 5 {
        if x < 10 {
            println!("A");
        } else {
            println!("B");
        }
    } else {
        println!("C");
    }
}

A B

B A

C C

D No output

💡 Hint

Check the conditions step by step: is x greater than 5? Is it less than 10?

The variable x is 7, which is greater than 5 and less than 10, so the inner if prints "A".

❓ Predict Output

intermediate

Nested match with conditions output

What will this Rust program print?

Rust

fn main() {
    let num = 3;
    match num {
        1..=5 => {
            if num % 2 == 0 {
                println!("Even");
            } else {
                println!("Odd");
            }
        }
        _ => println!("Out of range"),
    }
}

A Odd

B No output

C Out of range

D Even

💡 Hint

Check if 3 is between 1 and 5, then check if it is even or odd.

3 is between 1 and 5, and 3 % 2 is 1 (odd), so it prints "Odd".

🔧 Debug

advanced

Identify the error in nested if conditions

This Rust code does not compile. What is the error?

Rust

fn main() {
    let x = 10;
    if x > 5 {
        if x < 15 {
            println!("Inside");
        }
    } else {
        println!("Outside");
    }
}

A Variable x is not mutable

B Missing braces for the outer if block

C println! macro syntax error

D The else is not matched with any if

💡 Hint

Look at how Rust matches else with the nearest if.

The else is matched with the inner if, but the outer if lacks braces, causing a syntax error.

❓ Predict Output

advanced

Output of nested if with else if

What does this Rust program print?

Rust

fn main() {
    let score = 85;
    if score >= 90 {
        println!("A");
    } else if score >= 80 {
        if score >= 85 {
            println!("B+");
        } else {
            println!("B");
        }
    } else {
        println!("C");
    }
}

A B

B C

C B+

D A

💡 Hint

Check the score against each condition carefully.

Score 85 is not >= 90, but >= 80 and also >= 85, so it prints "B+".

🧠 Conceptual

expert

How many times is the inner block executed?

Consider this Rust code snippet. How many times will the inner println! be executed?

Rust

fn main() {
    for i in 1..=5 {
        if i % 2 == 0 {
            if i > 2 {
                println!("{}", i);
            }
        }
    }
}

A 1

B 2

C 3

D 4

💡 Hint

Check which numbers from 1 to 5 are even and greater than 2.

Only 4 and 2 are even, but 2 is not greater than 2, so only 4 is printed. Also 4 is the only number printed, so 1 time.

Practice

1.

What does nested conditions mean in Rust?

Choose the best description.

easy

A. Writing conditions without any if statements.

B. Using only one condition without any others.

C. Checking one condition inside another condition.

D. Ignoring conditions and running all code blocks.

Solution

1. Step 1: Understand the meaning of nested conditions

   Nested conditions mean putting one if or else if inside another to check multiple steps.

2. Step 2: Compare options with definition

   Only Checking one condition inside another condition. correctly describes checking one condition inside another.

3. Final Answer:

   Checking one condition inside another condition. -> Option C

4. Quick Check:

   Nested conditions = one condition inside another [OK]

Hint: Nested means inside another condition [OK]

Common Mistakes:

• Thinking nested means only one condition
• Confusing nested with multiple separate conditions
• Ignoring the use of if inside another if

2.

Which of the following is the correct syntax for nested if conditions in Rust?

fn main() {
    let x = 10;
    if x > 5 {
        if x < 15 {
            println!("x is between 6 and 14");
        }
    }
}

easy

A. The code shown above is correct.

B. You must use else if instead of nested if.

C. Rust does not allow nested if statements.

D. You need to add semicolons after if conditions.

Solution

1. Step 1: Check Rust syntax rules for nested if

   Rust allows if inside another if block without semicolons after conditions.

2. Step 2: Verify the given code

   The code uses nested if correctly and prints the message if both conditions are true.

3. Final Answer:

   The code shown above is correct. -> Option A

4. Quick Check:

   Nested if syntax correct = true [OK]

Hint: Nested if blocks need braces, no semicolon after conditions [OK]

Common Mistakes:

• Adding semicolons after if conditions
• Thinking else if must replace nested if
• Believing Rust disallows nested if

3.

What will be the output of this Rust code?

fn main() {
    let num = 8;
    if num > 5 {
        if num < 10 {
            println!("A");
        } else {
            println!("B");
        }
    } else {
        println!("C");
    }
}

medium

A. B

B. A

C. C

D. No output

Solution

1. Step 1: Check outer if condition

   Variable num is 8, which is greater than 5, so enter the first if block.

2. Step 2: Check inner if condition

   Inside, check if 8 is less than 10, which is true, so print "A".

3. Final Answer:

   A -> Option B

4. Quick Check:

   8 > 5 and 8 < 10 = "A" [OK]

Hint: Follow conditions step-by-step inside nested blocks [OK]

Common Mistakes:

• Ignoring inner if and printing wrong output
• Confusing else placement
• Assuming no output if conditions are true

4.

Find the error in this nested condition Rust code:

fn main() {
    let x = 3;
    if x > 0
        if x < 5 {
            println!("x is between 1 and 4");
        }
}

medium

A. The println! macro is used wrongly.

B. Incorrect comparison operators used.

C. Variable x is not declared.

D. Missing braces for the outer if block.

Solution

1. Step 1: Check syntax of outer if

   The outer if lacks braces, so the inner if is not properly nested.

2. Step 2: Understand Rust's block requirements

   Rust requires braces to group nested blocks clearly; missing braces cause syntax errors.

3. Final Answer:

   Missing braces for the outer if block. -> Option D

4. Quick Check:

   Braces needed for nested if blocks [OK]

Hint: Always use braces {} for nested if blocks [OK]

Common Mistakes:

• Skipping braces for nested if
• Misreading comparison operators
• Assuming println! usage is wrong

5.

Write a nested condition in Rust that prints:

• "Small and even" if a number is less than 10 and even,
• "Small and odd" if less than 10 and odd,
• "Large number" if 10 or more.

Which code snippet correctly implements this?

fn main() {
    let n = 8;
    // Choose the correct nested condition
}

hard

A. if n < 10 {
if n % 2 == 0 {
println!("Small and even");
} else {
println!("Small and odd");
}
} else {
println!("Large number");
}

B. if n % 2 == 0 {
if n < 10 {
println!("Small and even");
} else {
println!("Large number");
}
} else {
println!("Small and odd");
}

C. if n < 10 && n % 2 == 0 {
println!("Small and even");
} else if n < 10 {
println!("Small and odd");
} else {
println!("Large number");
}

D. if n < 10 {
println!("Small and even");
} else if n % 2 == 0 {
println!("Large number");
} else {
println!("Small and odd");
}

Solution

1. Step 1: Check outer condition for number size

   if n < 10 { if n % 2 == 0 { println!("Small and even"); } else { println!("Small and odd"); } } else { println!("Large number"); } first checks if n < 10, then inside checks even or odd.

2. Step 2: Verify inner conditions and outputs

   If even, prints "Small and even"; else prints "Small and odd". If not less than 10, prints "Large number".

3. Final Answer:

   Option A correctly implements the nested conditions as described. -> Option A

4. Quick Check:

   Outer size check, inner even/odd check = if n < 10 { if n % 2 == 0 { println!("Small and even"); } else { println!("Small and odd"); } } else { println!("Large number"); } [OK]

Hint: Check outer condition first, then inner even/odd [OK]

Common Mistakes:

• Checking even before size
• Mixing up print messages
• Using flat conditions instead of nested