Find the Only Non Repeating Element Using XOR in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the result variable to zero.

DSA Rust

fn find_unique(nums: &[i32]) -> i32 {
    let mut result = [1];
    for &num in nums {
        result ^= num;
    }
    result
}

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

A-1

B1

C0

Dnums[0]

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing result with nums[0] causes skipping the first element in loop.

Using 1 or -1 changes the XOR result incorrectly.

We start with zero because XOR with zero leaves the number unchanged, allowing us to accumulate XOR of all elements.

2fill in blank

medium

Complete the code to XOR each number with the result.

DSA Rust

fn find_unique(nums: &[i32]) -> i32 {
    let mut result = 0;
    for &num in nums {
        result [1] num;
    }
    result
}

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

A+=

B^=

C-=

D*=

Attempts:

3 left

💡 Hint

Common Mistakes

Using += or other arithmetic operators instead of XOR.

Forgetting to use the assignment operator.

XOR assignment (^=) updates result by XORing it with num, which helps find the unique element.

3fill in blank

hard

Fix the error in the function signature to accept a slice of integers.

DSA Rust

fn find_unique([1]) -> i32 {
    let mut result = 0;
    for &num in nums {
        result ^= num;
    }
    result
}

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

Anums: &[i32]

Bnums: Vec<i32>

Cnums: &Vec<i32>

Dnums: i32

Attempts:

3 left

💡 Hint

Common Mistakes

Using Vec requires ownership and may cause unnecessary copying.

Using i32 is incorrect because we need a collection.

Using a slice &[i32] allows the function to accept any slice of integers without ownership issues.

4fill in blank

hard

Fill both blanks to create a function that returns the unique element using XOR.

DSA Rust

fn find_unique(nums: [1]) -> [2] {
    let mut result = 0;
    for &num in nums {
        result ^= num;
    }
    result
}

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

A&[i32]

Bi32

CVec<i32>

Dusize

Attempts:

3 left

💡 Hint

Common Mistakes

Returning Vec instead of i32.

Using usize as return type which is incorrect here.

The function takes a slice of i32 (&[i32]) and returns a single i32 value representing the unique element.

5fill in blank

hard

Fill all three blanks to complete the main function that tests find_unique.

DSA Rust

fn main() {
    let nums = [1];
    let unique = find_unique([2]);
    println!("Unique element is: {}", [3]);
}

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

Avec![2, 3, 2, 4, 3]

B&nums

Cunique

D[1, 1, 5, 7, 5, 7, 9]

Attempts:

3 left

💡 Hint

Common Mistakes

Passing nums without reference causes type mismatch.

Printing nums instead of unique.

We create a vector nums, pass a reference &nums to find_unique, and print the unique variable.

Practice

1. What does the XOR operation do when applied between two identical numbers?

easy

A. It returns 0

B. It returns the number itself

C. It returns 1

D. It returns the sum of the numbers

Solution

1. Step 1: Understand XOR property for identical numbers

   XOR of a number with itself is always 0 because bits cancel out.

2. Step 2: Apply this property to the question

   Since the two numbers are identical, XOR returns 0.

3. Final Answer:

   It returns 0 -> Option A

4. Quick Check:

   X XOR X = 0 [OK]

Hint: XOR of same numbers always zero [OK]

Common Mistakes:

• Thinking XOR returns the number itself
• Confusing XOR with addition
• Assuming XOR returns 1 for identical numbers

2. Which Rust syntax correctly initializes a variable to zero for XOR operation?

easy

A. let mut result = 0;

B. let result = 0;

C. let mut result = 1;

D. let mut result = None;

Solution

1. Step 1: Identify mutable variable declaration

   We need a mutable variable to update XOR results, so use 'mut'.

2. Step 2: Initialize variable to zero

   Zero is the identity for XOR, so initialize with 0.

3. Final Answer:

   let mut result = 0; -> Option A

4. Quick Check:

   Mutable zero initialization for XOR [OK]

Hint: Use 'let mut var = 0;' for XOR accumulator [OK]

Common Mistakes:

• Not using 'mut' for variable to update
• Initializing with 1 instead of 0
• Using Option type instead of integer

3. What is the output of this Rust code?

fn main() {
    let arr = [2, 3, 5, 4, 5, 3, 4];
    let mut result = 0;
    for &num in &arr {
        result ^= num;
    }
    println!("{}", result);
}

medium

A. 4

B. 5

C. 0

D. 2

Solution

1. Step 1: XOR all elements in the array

   Calculate XOR stepwise: 0^2=2, 2^3=1, 1^5=4, 4^4=0, 0^5=5, 5^3=6, 6^4=2.

2. Step 2: Identify the non-repeating element

   The final XOR result is 2, which is the only number not repeated.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Final XOR = 2 [OK]

Hint: XOR all numbers; result is unique element [OK]

Common Mistakes:

• Miscomputing XOR steps
• Assuming repeated numbers affect result
• Confusing output with repeated elements

4. Identify the error in this Rust code that tries to find the non-repeating element using XOR:

fn main() {
    let arr = [1, 2, 1, 3, 2];
    let mut result = 0;
    for num in arr {
        result = result ^ num;
    }
    println!("{}", result);
}

medium

A. Missing '&' in for loop to borrow elements

B. No error, code works correctly

C. Incorrect initialization of result variable

D. Using '=' instead of '^=' operator

Solution

1. Step 1: Check for borrowing in for loop

   Iterating over array by value is allowed; no '&' needed.

2. Step 2: Verify XOR operation and initialization

   Result initialized to 0 and XOR applied correctly with '=' operator.

3. Final Answer:

   No error, code works correctly -> Option B

4. Quick Check:

   Code runs and finds unique element [OK]

Hint: XOR with '=' works; no borrow needed for array iteration [OK]

Common Mistakes:

• Thinking '&' is mandatory in for loop
• Confusing '=' with '^=' operator
• Assuming initialization must be different

5. Given an array where every element repeats twice except one element which repeats thrice, can XOR find the unique element? Why or why not?

hard

A. Yes, XOR works for any number of duplicates

B. No, XOR works only if unique element appears once

C. No, XOR only works if all duplicates appear exactly twice

D. Yes, but only if array length is odd

Solution

1. Step 1: Understand XOR behavior with duplicates

   XOR cancels pairs of identical numbers (duplicates appearing twice).

2. Step 2: Analyze effect of triplicate duplicates

   Triplicates do not cancel out with XOR, so result is incorrect.

3. Final Answer:

   No, XOR only works if all duplicates appear exactly twice -> Option C

4. Quick Check:

   XOR cancels pairs, not triplets [OK]

Hint: XOR cancels pairs only, not triplets [OK]

Common Mistakes:

• Assuming XOR works for any duplicate count
• Confusing unique element count with duplicates
• Ignoring XOR cancellation properties