Two Non Repeating Elements in Array Using XOR in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to XOR all elements in the array.

DSA Rust

let mut xor_all = 0;
for &num in &arr {
    xor_all [1]= num;
}

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

A^

B|

C&

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition (+) instead of XOR (^).

Using bitwise AND (&) or OR (|) which do not help find unique elements.

XOR operator (^) is used to find the XOR of all elements.

2fill in blank

medium

Complete the code to find the rightmost set bit in xor_all.

DSA Rust

let set_bit = xor_all & [1];

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

Axor_all

B-xor_all

C!xor_all

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using xor_all & xor_all which returns xor_all itself.

Using xor_all & !xor_all which results in 0.

Rightmost set bit can be found by xor_all & (-xor_all).

3fill in blank

hard

Fix the error in the loop that separates elements into two groups based on set_bit.

DSA Rust

for &num in &arr {
    if num & [1] != 0 {
        x [2]= num;
    } else {
        y ^= num;
    }
}

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

A&

B|

C^

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using | instead of & in the if condition.

Using + instead of ^= to accumulate XOR.

Use bitwise AND (&) to check set bit and XOR (^=) to accumulate unique elements.

4fill in blank

hard

Fill both blanks to initialize variables and print the two unique numbers.

DSA Rust

let (mut x, mut y) = ([1], [2]);
// After processing
println!("Two non-repeating elements are: {} and {}", x, y);

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

A0

B1

Cxor_all

Darr[0]

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing with xor_all which is incorrect.

Initializing with array elements which may cause wrong results.

Initialize x and y to 0 before XOR accumulation.

5fill in blank

hard

Fill all three blanks to complete the function that returns the two unique numbers as a tuple.

DSA Rust

fn find_two_unique(arr: &[i32]) -> (i32, i32) {
    let mut xor_all = 0;
    for &num in arr {
        xor_all [1]= num;
    }
    let set_bit = xor_all & [2];
    let (mut x, mut y) = ([3], 0);
    for &num in arr {
        if num & set_bit != 0 {
            x ^= num;
        } else {
            y ^= num;
        }
    }
    (x, y)
}

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

A^

B-xor_all

C0

Dxor_all

Attempts:

3 left

💡 Hint

Common Mistakes

Using + instead of ^= for XOR.

Incorrect set_bit calculation.

Initializing x with xor_all instead of 0.

Use ^= to XOR all elements, find set_bit with xor_all & (-xor_all), initialize x with 0.

Practice

1. What is the main idea behind using XOR to find two non-repeating elements in an array where every other element repeats?

easy

A. XOR removes duplicates by summing elements

B. XOR of all elements gives XOR of the two unique elements

C. XOR sorts the array to find unique elements

D. XOR counts the frequency of elements

Solution

1. Step 1: Understand XOR operation on array elements

   XORing all elements cancels out pairs of repeating elements because x ^ x = 0.

2. Step 2: Result after XORing all elements

   The result is XOR of the two unique elements since all duplicates cancel out.

3. Final Answer:

   XOR of all elements gives XOR of the two unique elements -> Option B

4. Quick Check:

   XOR cancels duplicates = XOR of unique elements [OK]

Hint: XOR all elements to isolate unique pair XOR [OK]

Common Mistakes:

• Thinking XOR counts frequency
• Assuming XOR sorts elements
• Using XOR as sum instead of bitwise operation

2. Which Rust syntax correctly initializes a variable to store XOR of all elements in a vector named arr?

easy

A. let mut xor = 0; for &num in &arr { xor ^= num; }

B. let xor = arr.reduce(|a, b| a + b);

C. let xor = arr.iter().sum();

D. let mut xor = 1; for num in arr { xor *= num; }

Solution

1. Step 1: Initialize mutable variable for XOR

   Use let mut xor = 0; to start XOR from zero.

2. Step 2: Iterate over references to elements and XOR

   Use for &num in &arr { xor ^= num; } to XOR each element.

3. Final Answer:

   let mut xor = 0; for &num in &arr { xor ^= num; } -> Option A

4. Quick Check:

   Mutable xor with ^= in loop = correct syntax [OK]

Hint: Use 'let mut xor = 0;' and XOR in loop [OK]

Common Mistakes:

• Using sum() instead of XOR
• Trying to multiply elements
• Not using mutable variable for XOR

3. What is the output of the following Rust code snippet?

let arr = vec![2, 3, 7, 9, 2, 3];
let mut xor = 0;
for &num in &arr {
    xor ^= num;
}
println!("{}", xor);

medium

A. 16

B. 0

C. 14

D. 9

Solution

1. Step 1: XOR all elements in the array

   Calculate 2 ^ 3 ^ 7 ^ 9 ^ 2 ^ 3 step-by-step: 2 ^ 3 = 1, 1 ^ 7 = 6, 6 ^ 9 = 15, 15 ^ 2 = 13, 13 ^ 3 = 14.

2. Step 2: Final XOR value

   The final XOR value is 14 after processing all elements.

3. Final Answer:

   14 -> Option C

4. Quick Check:

   XOR all elements = 14 [OK]

Hint: XOR duplicates cancel, result is XOR of unique elements [OK]

Common Mistakes:

• Incorrect XOR calculation order
• Assuming sum instead of XOR
• Forgetting XOR cancels duplicates

4. Identify the error in this Rust code snippet that tries to find two unique elements using XOR:

let arr = vec![4, 1, 2, 1, 2, 5];
let mut xor = 0;
for num in arr {
    xor ^= num;
}
let set_bit = xor & (-xor);
println!("{}", set_bit);

medium

A. Incorrect loop syntax for vector iteration

B. Missing mutable keyword for xor variable

C. Cannot use negative sign on unsigned integer

D. No error, code runs fine

Solution

1. Step 1: Understand variable types and operations

   In Rust, integer literals default to i32 (signed), so xor & (-xor) is valid.

2. Step 2: Verify code execution

   Loop correctly computes XOR (1), set_bit calculates correctly (1). No syntax or runtime errors.

3. Final Answer:

   No error, code runs fine -> Option D

4. Quick Check:

   i32 supports unary minus operator [OK]

Hint: Rust ints default to signed i32, -xor valid [OK]

Common Mistakes:

• Misassuming unsigned integers by default
• Thinking 'for num in arr' syntax is wrong
• Expecting mutable keyword issues

5. Given an array arr = [6, 1, 3, 6, 1, 5], which Rust code snippet correctly finds the two non-repeating elements using XOR?

hard

A. let mut xor = 0;
for &num in &arr { xor ^= num; }
let set_bit = xor & xor.wrapping_neg();
let (mut x, mut y) = (0, 0);
for &num in &arr {
if num & set_bit != 0 { x ^= num; } else { y ^= num; }
}
println!("{} {}", x, y);

B. let mut xor = 0;
for num in arr {
xor += num;
}
println!("{}", xor);

C. let mut xor = 0;
for &num in &arr {
xor ^= num;
}
println!("{}", xor);

D. let mut xor = 0;
for &num in &arr {
xor *= num;
}
println!("{}", xor);

Solution

1. Step 1: XOR all elements to get xor of two unique numbers

   Loop over array and XOR all elements to get xor = 6 ^ 1 ^ 3 ^ 6 ^ 1 ^ 5 = 3 ^ 5 = 6.

2. Step 2: Find rightmost set bit and separate elements

   Calculate set_bit = xor & xor.wrapping_neg() to isolate differing bit. Then separate elements into two groups based on this bit and XOR each group to find unique elements.

3. Step 3: Print the two unique elements

   After separation and XOR, x and y hold the two unique numbers 3 and 5.

4. Final Answer:

   Code snippet in Option A correctly finds two unique elements -> Option A

5. Quick Check:

   Use XOR, set bit, separate groups = correct approach [OK]

Hint: Use XOR, find set bit, separate and XOR groups [OK]

Common Mistakes:

• Using sum or multiplication instead of XOR
• Not isolating rightmost set bit correctly
• Not separating elements into two groups