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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the XOR of all elements.

DSA Typescript

let xor = 0;
for (const num of arr) {
  xor = xor [1] num;
}

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

A^

B+

C&

D|

Attempts:

3 left

💡 Hint

Common Mistakes

Using + instead of ^ causes incorrect results.

Using & or | operators does not find unique elements.

We use the XOR operator (^) to combine all elements because XOR of two identical numbers is 0 and XOR with 0 is the number itself.

2fill in blank

medium

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

DSA Typescript

let setBit = xor & -[1];

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

A1

Bxor

C0

Darr.length

Attempts:

3 left

💡 Hint

Common Mistakes

Using 1 or 0 instead of xor causes wrong bit isolation.

The expression xor & -xor isolates the rightmost set bit of xor.

3fill in blank

hard

Fix the error in the loop that separates elements based on setBit.

DSA Typescript

for (const num of arr) {
  if ((num & [1]) !== 0) {
    res1 = res1 [2] num;
  } else {
    res2 = res2 ^ num;
  }
}

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

AsetBit

Bxor

C+

D^

Attempts:

3 left

💡 Hint

Common Mistakes

Using + instead of ^ causes wrong results.

Using xor instead of setBit in condition causes logic error.

We check if the bit is set using setBit and XOR accumulate the numbers in res1 and res2.

4fill in blank

hard

Fill both blanks to initialize result variables and return the final unique elements.

DSA Typescript

let res1 = [1], res2 = [2];
return [res1, res2];

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

A0

B1

Cxor

Darr[0]

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing with xor or array element causes wrong output.

Initialize res1 and res2 to 0 before XOR accumulation to correctly find unique elements.

5fill in blank

hard

Fill all three blanks to complete the function that finds two non-repeating elements.

DSA Typescript

function findTwoUnique(arr: number[]): number[] {
  let xor = 0;
  for (const num of arr) {
    xor = xor [1] num;
  }
  let setBit = xor & -[2];
  let res1 = [3], res2 = 0;
  for (const num of arr) {
    if ((num & setBit) !== 0) {
      res1 = res1 ^ num;
    } else {
      res2 = res2 ^ num;
    }
  }
  return [res1, res2];
}

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

A^

Bxor

C0

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using + instead of ^ causes wrong results.

Initializing res1 with xor causes incorrect output.

Use XOR (^) to combine elements, xor variable to find setBit, and initialize res1 with 0 for accumulation.

Practice

1. What is the main purpose of using XOR operation to find two non-repeating elements in an array?

easy

A. To sort the array in ascending order

B. To count the frequency of each element

C. To cancel out all repeating elements and isolate the unique ones

D. To reverse the array elements

Solution

1. Step 1: Understand XOR properties

   XOR of two same numbers is 0, and XOR with 0 is the number itself.

2. Step 2: Apply XOR on array elements

   XORing all elements cancels out repeating ones, leaving XOR of two unique elements.

3. Final Answer:

   To cancel out all repeating elements and isolate the unique ones -> Option C

4. Quick Check:

   XOR cancels duplicates = isolate unique elements [OK]

Hint: XOR cancels pairs, leaving unique elements [OK]

Common Mistakes:

• Thinking XOR sorts the array
• Using XOR to count frequencies
• Assuming XOR reverses elements

2. Which of the following TypeScript code snippets correctly initializes the XOR variable to start finding two unique elements?

easy

A. let xor = 1;

B. let xor = 0;

C. let xor = -1;

D. let xor = null;

Solution

1. Step 1: Identify initial XOR value

   XOR with 0 returns the number itself, so start with 0.

2. Step 2: Confirm initialization

   Initializing xor as 0 allows proper XOR accumulation over array elements.

3. Final Answer:

   let xor = 0; -> Option B

4. Quick Check:

   Start XOR with 0 for correct accumulation [OK]

Hint: Initialize XOR with 0 to accumulate correctly [OK]

Common Mistakes:

• Starting XOR with 1 changes results
• Using null or undefined causes errors
• Starting XOR with -1 gives wrong output

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

const arr = [2, 3, 7, 9, 2, 3];
let xor = 0;
for (const num of arr) {
  xor ^= num;
}
console.log(xor);

medium

A. 0

B. 9

C. 7

D. 14

Solution

1. Step 1: XOR all elements in array

   Calculate XOR stepwise: 0^2=2, 2^3=1, 1^7=6, 6^9=15, 15^2=13, 13^3=14.

2. Step 2: Final XOR value

   The final XOR after all elements is 14.

3. Final Answer:

   14 -> Option D

4. Quick Check:

   XOR all elements = 14 [OK]

Hint: XOR all elements stepwise to find final value [OK]

Common Mistakes:

• Stopping XOR early
• Incorrect XOR calculation order
• Confusing XOR with addition

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

const arr = [4, 1, 2, 1, 2, 5];
let xor = 0;
for (let i = 0; i <= arr.length; i++) {
  xor ^= arr[i];
}
console.log(xor);

medium

A. Loop condition should be i < arr.length, not i <= arr.length

B. XOR operator should be & instead of ^

C. Variable xor should be initialized to 1

D. Array elements should be converted to strings before XOR

Solution

1. Step 1: Check loop boundary

   Loop uses i <= arr.length which causes out-of-bounds access at last iteration.

2. Step 2: Correct loop condition

   Change to i < arr.length to avoid accessing undefined element.

3. Final Answer:

   Loop condition should be i < arr.length, not i <= arr.length -> Option A

4. Quick Check:

   Loop index must be less than array length [OK]

Hint: Use i < length to avoid out-of-bounds errors [OK]

Common Mistakes:

• Using wrong loop boundary causing runtime error
• Confusing XOR with AND operator
• Initializing xor incorrectly

5. Given the array [6, 1, 3, 6, 1, 5], which two numbers are the non-repeating elements found using XOR method?

hard

A. [3, 5]

B. [6, 1]

C. [1, 3]

D. [5, 6]

Solution

1. Step 1: XOR all elements

   6^1=7, 7^3=4, 4^6=2, 2^1=3, 3^5=6 (final XOR = 6).

2. Step 2: Find rightmost set bit of XOR

   Rightmost set bit of 6 (binary 110) is 2 (binary 010).

3. Step 3: Divide elements into two groups and XOR separately

   Group 1 (bit set): 6, 3, 6 -> XOR = 3; Group 2 (bit not set): 1, 1, 5 -> XOR = 5.

4. Final Answer:

   [3, 5] -> Option A

5. Quick Check:

   Two unique elements = [3, 5] [OK]

Hint: Use rightmost set bit to separate and XOR groups [OK]

Common Mistakes:

• Not separating elements by set bit
• Mixing order of unique elements
• Incorrect XOR calculations