Two Non Repeating Elements in Array Using XOR in DSA Rust - Build from Scratch

Two Non Repeating Elements in Array Using XOR

📖 Scenario: Imagine you have a list of numbers where every number appears twice except for two unique numbers that appear only once. You want to find those two unique numbers quickly without using extra space.

🎯 Goal: Build a Rust program that finds the two numbers in an array that do not repeat, using the XOR operation.

📋 What You'll Learn

Create a vector called nums with the exact values: [2, 3, 7, 9, 2, 3]

Create a variable called xor_all to store the XOR of all elements in nums

Use a variable called set_bit to find the rightmost set bit in xor_all

Create two variables num1 and num2 initialized to 0 to hold the two unique numbers

Use a for loop with variable num to iterate over nums and separate numbers based on set_bit

Print the two unique numbers num1 and num2 separated by a space

💡 Why This Matters

🌍 Real World

Finding unique elements quickly in large datasets is useful in error detection, network packet analysis, and data cleaning.

💼 Career

Bitwise operations and efficient algorithms are important skills for software engineers working on performance-critical systems.

1

Create the input vector

Create a vector called nums with the exact values [2, 3, 7, 9, 2, 3].

DSA Rust

# Create the vector nums with values [2, 3, 7, 9, 2, 3]
# Your code here

Hint

Use let nums = vec![2, 3, 7, 9, 2, 3]; to create the vector.

2

Calculate XOR of all elements and find rightmost set bit

Create a variable called xor_all and set it to 0. Then use a for loop with variable num to XOR all elements in nums into xor_all. Next, create a variable called set_bit to find the rightmost set bit in xor_all using xor_all & (-xor_all).

DSA Rust

fn main() {
    let nums = vec![2, 3, 7, 9, 2, 3];
    let mut xor_all = 0;
    // Use a for loop to XOR all elements in nums into xor_all
    // Your code here
    // Find the rightmost set bit in xor_all and store in set_bit
    // Your code here
}

Hint

Use for num in &nums { xor_all ^= num; } to XOR all elements. Then find the rightmost set bit with xor_all & (-xor_all).

3

Separate numbers into two groups and find unique elements

Create two variables num1 and num2 initialized to 0. Use a for loop with variable num to iterate over nums. Inside the loop, use an if statement to check if num & set_bit != 0. If true, XOR num with num1, else XOR num with num2.

DSA Rust

fn main() {
    let nums = vec![2, 3, 7, 9, 2, 3];
    let mut xor_all = 0;
    for num in &nums {
        xor_all ^= *num;
    }
    let set_bit = xor_all & (-xor_all);
    let mut num1 = 0;
    let mut num2 = 0;
    // Use a for loop to separate nums into two groups using set_bit
    // Your code here
}

Hint

Use if num & set_bit != 0 { num1 ^= num; } else { num2 ^= num; } inside the loop.

4

Print the two unique numbers

Use println!("{} {}", num1, num2); to print the two unique numbers separated by a space.

DSA Rust

fn main() {
    let nums = vec![2, 3, 7, 9, 2, 3];
    let mut xor_all = 0;
    for num in &nums {
        xor_all ^= *num;
    }
    let set_bit = xor_all & (-xor_all);
    let mut num1 = 0;
    let mut num2 = 0;
    for num in &nums {
        if num & set_bit != 0 {
            num1 ^= *num;
        } else {
            num2 ^= *num;
        }
    }
    // Print num1 and num2 separated by a space
    // Your code here
}

Hint

Use println!("{} {}", num1, num2); to print the two unique numbers.

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