Relational operators in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if a is less than b.

Rust

let a = 5;
let b = 10;
let result = a [1] b;
println!("{}", result);

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

A>=

B<

C==

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using > instead of < will check the opposite condition.

The operator < checks if the left value is less than the right value.

2fill in blank

medium

Complete the code to check if x is equal to y.

Rust

let x = 7;
let y = 7;
let is_equal = x [1] y;
println!("{}", is_equal);

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

A==

B!=

C>

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using = instead of == assigns a value instead of comparing.

The operator == checks if two values are equal.

3fill in blank

hard

Fix the error in the code to check if num is not equal to 0.

Rust

let num = 3;
let check = num [1] 0;
println!("{}", check);

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

A==

B<=

C!=

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using == will check for equality, not inequality.

The operator != checks if two values are not equal.

4fill in blank

hard

Fill the blank to create a dictionary with words as keys and their lengths as values, only for words longer than 3 letters.

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 < will select shorter words instead.

The operator > filters words with length greater than 3.

5fill in blank

hard

Fill the blanks to create a HashMap with uppercase keys and values greater than 2.

Rust

let data = vec![("one", 1), ("two", 2), ("three", 3)];
let filtered: std::collections::HashMap<_, _> = data.into_iter()
    .filter(|&(_, v)| v [1] 2)
    .map(|(k, v)| (k.[2](), v))
    .collect();

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

A<

B>

Cto_uppercase

Dto_lowercase

Attempts:

3 left

💡 Hint

Common Mistakes

Using < will filter wrong values.

Using to_lowercase will not convert keys to uppercase.

The operator > filters values greater than 2, and to_uppercase converts keys to uppercase.

Practice

1. Which of the following relational operators in Rust checks if two values are not equal?

easy

A. !=

B. ==

C. <=

D. >=

Solution

1. Step 1: Understand the meaning of relational operators

   Relational operators compare two values and return true or false based on the comparison.

2. Step 2: Identify the operator for 'not equal'

   The operator '!=' means 'not equal to' in Rust.

3. Final Answer:

   != -> Option A

4. Quick Check:

   Not equal operator = != [OK]

Hint: Remember '!=' means not equal in most languages [OK]

Common Mistakes:

• Confusing '!=' with '=='
• Using '<>' which is not valid in Rust
• Mixing up '<=' and '>='

2. Which of the following is the correct syntax to check if variable a is greater than or equal to variable b in Rust?

easy

A. a =>= b

B. a => b

C. a =< b

D. a >= b

Solution

1. Step 1: Recall Rust relational operator syntax

   Rust uses '>=' to check if left value is greater than or equal to right value.

2. Step 2: Identify correct syntax among options

   Only 'a >= b' matches the correct Rust syntax.

3. Final Answer:

   a >= b -> Option D

4. Quick Check:

   Greater or equal operator = >= [OK]

Hint: Greater or equal is '>=' not '=>' [OK]

Common Mistakes:

• Using '=>' instead of '>='
• Swapping '=' and '<' in operators
• Confusing assignment '=' with comparison

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

let x = 10;
let y = 20;
println!("{}", x < y);

medium

A. true

B. 20

C. 10

D. false

Solution

1. Step 1: Understand the comparison operation

   The code compares if x (10) is less than y (20), which is true.

2. Step 2: Determine the printed output

   Since the condition is true, the printed output will be 'true'.

3. Final Answer:

   true -> Option A

4. Quick Check:

   10 < 20 = true [OK]

Hint: Compare values carefully; 10 is less than 20 [OK]

Common Mistakes:

• Confusing output with variable values
• Thinking it prints the smaller number
• Mixing up < and > operators

4. Identify the error in the following Rust code snippet:

let a = 5;
let b = 10;
if a <> b {
    println!("Not equal");
}

medium

A. Variables a and b must be mutable

B. The operator '<>' is invalid in Rust

C. Missing semicolon after println!

D. The if statement needs parentheses

Solution

1. Step 1: Check the relational operator used

   The operator '<>' is not a valid relational operator in Rust.

2. Step 2: Confirm correct operator for not equal

   Rust uses '!=' to check if two values are not equal.

3. Final Answer:

   The operator '<>' is invalid in Rust -> Option B

4. Quick Check:

   Not equal operator = !=, not <> [OK]

Hint: Use '!=' for not equal, not '<>' [OK]

Common Mistakes:

• Using '<>' from other languages
• Forgetting Rust requires '!='
• Assuming parentheses needed in if condition

5. Given a list of integers, which Rust expression correctly checks if all elements are greater than 0 using relational operators?

hard

A. numbers.iter().filter(|&x| x > 0)

B. numbers.iter().any(|&x| x > 0)

C. numbers.iter().all(|&x| x > 0)

D. numbers.iter().map(|&x| x > 0)

Solution

1. Step 1: Understand the requirement

   We want to check if all elements in the list are greater than 0.

2. Step 2: Identify the correct iterator method

   'all' returns true only if every element satisfies the condition x > 0.

3. Step 3: Confirm the closure syntax

   The closure '|&x| x > 0' correctly compares each element to 0.

4. Final Answer:

   numbers.iter().all(|&x| x > 0) -> Option C

5. Quick Check:

   Check all elements > 0 with 'all' method [OK]

Hint: Use 'all' to check every element meets condition [OK]

Common Mistakes:

• Using 'any' which checks only one element
• Using 'filter' which returns iterator, not bool
• Using 'map' which transforms elements, not checks