Find the Only Non Repeating Element Using XOR in DSA Rust - Time & Space Complexity

Time Complexity: Find the Only Non Repeating Element Using XOR

O(n)

Understanding Time Complexity

We want to know how fast we can find the single element that does not repeat in a list.

How does the time needed grow as the list gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fn find_non_repeating(arr: &[i32]) -> i32 {
    let mut result = 0;
    for &num in arr {
        result ^= num;
    }
    result
}
    

This code finds the only number that appears once by using XOR on all elements.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: One loop that goes through each element once.
• How many times: Exactly once per element in the list.

How Execution Grows With Input

As the list grows, the number of XOR operations grows directly with the number of elements.

Input Size (n)	Approx. Operations
10	10 XOR operations
100	100 XOR operations
1000	1000 XOR operations

Pattern observation: The operations increase in a straight line as input size increases.

Final Time Complexity

Time Complexity: O(n)

This means the time to find the unique element grows directly with the number of elements.

Common Mistake

[X] Wrong: "Using XOR means the time is constant no matter the list size."

[OK] Correct: Even though XOR is fast, we must do it for every element, so time grows with list size.

Interview Connect

Understanding this method shows you can use clever tricks to solve problems efficiently, a skill valued in real coding tasks.

Self-Check

"What if the list was sorted? Would that change the time complexity of finding the non-repeating element?"

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