add question no 260

Author: agarwalhimanshugaya

dsa-solutions/lc-solutions/0200-0299/0260-Single-Number-III.md

@@ -0,0 +1,136 @@
+---
+id: single-number-III
+title: Single Number III
+sidebar_label: 0260-Single-Number-III
+tags:
+ - Array
+ - Bit Manipulation
+ - C++
+ - Java
+ - Python
+description: "Given an integer array `nums`, in which exactly two elements appear only once and all the other elements appear exactly twice. Find the two elements that appear only once. You can return the answer in any order."
+---
+
+## Problem
+
+Given an integer array `nums`, in which exactly two elements appear only once and all the other elements appear exactly twice. Find the two elements that appear only once. You can return the answer in any order.
+
+You must write an algorithm that runs in linear runtime complexity and uses only constant extra space.
+
+### Examples
+
+**Example 1:**
+```
+Input: nums = [1,2,1,3,2,5]
+Output: [3,5]
+Explanation:  [5, 3] is also a valid answer.
+```
+**Example 2:**
+
+Input: nums = [-1,0]
+Output: [-1,0]
+
+**Example 3:**
+
+Input: nums = [0,1]
+Output: [1,0]
+
+
+### Constraints
+
+- `2 <= nums.length <= 3 * 10^4`
+- `-2^31 <= nums[i] <= 2^31 - 1`
+- Each integer in `nums` will appear twice, only two integers will appear once.
+
+### Approach
+
+Once again, we need to use XOR to solve this problem. But this time, we need to do it in two passes:
+
+- In the first pass, we XOR all elements in the array, and get the XOR of the two numbers we need to find. Note that since the two numbers are distinct, so there must be a set bit (that is, `the bit with value '1'`) in the XOR result. Find
+out an arbitrary set bit (for example, the rightmost set bit).
+
+- In the second pass, we divide all numbers into two groups, one with the aforementioned bit set, another with the aforementinoed bit unset. Two different numbers we need to find must fall into thte two distrinct groups. XOR numbers in each group, we can find a number in either group.
+
+### Solution
+
+#### Code in Different Languages
+
+### C++ Solution
+```cpp
+class Solution
+{
+public:
+    vector<int> singleNumber(vector<int>& nums) 
+    {
+        // Pass 1 : 
+        // Get the XOR of the two numbers we need to find
+        int diff = accumulate(nums.begin(), nums.end(), 0, bit_xor<int>());
+        // Get its last set bit
+        diff &= -diff;
+
+        // Pass 2 :
+        vector<int> rets = {0, 0}; // this vector stores the two numbers we will return
+        for (int num : nums)
+        {
+            if ((num & diff) == 0) // the bit is not set
+            {
+                rets[0] ^= num;
+            }
+            else // the bit is set
+            {
+                rets[1] ^= num;
+            }
+        }
+        return rets;
+    }
+};
+```
+### Java Solution
+
+```java
+public class Solution {
+    public int[] singleNumber(int[] nums) {
+        // Pass 1 : 
+        // Get the XOR of the two numbers we need to find
+        int diff = 0;
+        for (int num : nums) {
+            diff ^= num;
+        }
+        // Get its last set bit
+        diff &= -diff;
+        
+        // Pass 2 :
+        int[] rets = {0, 0}; // this array stores the two numbers we will return
+        for (int num : nums)
+        {
+            if ((num & diff) == 0) // the bit is not set
+            {
+                rets[0] ^= num;
+            }
+            else // the bit is set
+            {
+                rets[1] ^= num;
+            }
+        }
+        return rets;
+    }
+}
+```
+### Python Solution
+
+```python
+class Solution:
+    def singleNumber(self, nums):
+        s = reduce(xor, nums)
+        nz = s & (s-1) ^ s
+        num1 = reduce(xor, filter(lambda n: n & nz, nums))
+        return(num1, s ^ num1)
+
+```
+### Complexity Analysis
+**Time Complexity:** O(N)
+
+**Space Complexity:** O(1)
+
+### References
+**LeetCode Problem:** Single Number III