In this solution, we use the concept of bitwise operators and <code>Array.prototype.reduce</code> function to get the only element that is available.
<h3>XOR Bitwise operator in Javascript</h3>
In JavaScript, the bitwise XOR(^) Operator is used to compare two operands and return a new binary number which is 1 if both the bits in operators are different and 0 if both the bits in operads are the same. The operation is represented by the <code>^</code> symbol. This operator can be used to find the missing numbers in an array of natural numbers.
Eg.
<pre><code> 9 (base 10) = 00000000000000000000000000001001 (base 2)
 14 (base 10) = 00000000000000000000000000001110 (base 2)
 --------------------------------
14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
</code></pre>
Read more about bitwise XOR <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_XOR">here</a>
We can use this to determine which of the numbers have a missing counterpart in our array using the following steps.
<ol>
<li>Have a result variable initialized to 0.</li>
<li>Iterate through each element and apply the XOR operation between the result and the element.</li>
<li>Return the result element.</li>
</ol>
Let's take a simple example to better understand these steps.
<code>arr = [2,1,2]</code>
<code>result = 0</code>
Iteration 1: Element: <code>2</code>. Binary representation: <code>10</code>. <code>result = result ^ element =&gt; 00 ^ 10 =&gt; 10 =&gt; 2</code>.
Iteration 2: Element: <code>1</code>. Binary representation: <code>01</code>. <code>result = result ^ element =&gt; 10 ^ 01 =&gt; 11 =&gt; 3</code>. (Please stay with me here, although 3 is not present in the array, we will cancel it out. :))
Iteration 3: Element: <code>2</code>. Binary representation: <code>10</code>. <code>result = result ^ element =&gt; 11 ^ 10 =&gt; 01 =&gt; 1</code>.
Now we return the result of 1.
The javascript implementation of this using <code>Array.prototype.forEach</code> will be as follows:
<pre class="shiki github-dark shaku"><code>/** * @param {number[]} arr * @returns number */function findSingle(arr) { let result = 0; arr.forEach(el =&gt; result = result ^ el) return result;}</code></pre>
This is a very valid simple 3-liner solution to solve this problem. But we can simplify this further.
<h3>Array.prototype.reduce</h3>
The Javascript <code>arr.reduce()</code> method in JavaScript is used to reduce the array to a single value and executes a provided function for each value of the array (from left to right) and the return value of the function is stored in an accumulator.
In our case, the accumulator is the <code>result</code> variable. And we would xor it with itself each iteration.
Read more about <code>Array.prototype.reduce</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce">here</a>
<h3>Final implementation</h3>
<pre class="shiki github-dark shaku"><code>/** * @param {number[]} arr * @returns number */function findSingle(arr) { return arr.reduce((acc, value) =&gt; acc ^= value, 0)}</code></pre>
<h3>Time and space complexity</h3>
The time complexity of this approach is <code>O(n)</code> as we would be iterating through the entire array once.
The space complexity of this approach is <code>O(1)</code> as we don't need any additional space.

Simple O(n) 1 line solution using XOR operator and reduce | With Explanation

Given an array of integers, all integers appear twice except one integer, could you quickly target it ? const arr = [10, 2, 2 , 1, 0, 0, 10]findSingle…