287. Find the Duplicate Number

Author: shivang21007

287. Find the Duplicate Number.cpp

@@ -0,0 +1,134 @@
+/* 1)
+- Brute Force Solution
+time Complexity = O(nlogn) ->> Sort function take O(nlogn) and for loop take between O(1 to n)
+Space Complexity - O(1) -> Constant Space
+*/
+
+class Solution
+{
+public:
+    int findDuplicate(vector<int> &nums)
+    {
+        sort(nums.begin(), nums.end());
+        int i = 0;
+        for (i = 0; i < nums.size() - 1; i++)
+        {
+            if (nums[i] == nums[i + 1]) // -> if(nums[i]^nums[i+1] == 0)
+            {
+                break;
+            }
+        }
+        return nums[i];
+    }
+};
+
+/* 2)
+- Bool Method
+time Complexity = O(n)
+Space Complexity - O(n) -> Because it is creating an extra arr.
+*/
+// choose Between 2.1 / 2.2
+
+// 2.1 ->
+class Solution
+{
+public:
+    int findDuplicate(vector<int> &nums)
+    {
+        vector<bool> hash(nums.size(), false);
+
+        for (int i = 0; i < nums.size(); i++)
+        {
+            if (hash[nums[i]])
+            {
+                return nums[i];
+            }
+            else
+            {
+                hash[nums[i]] = true;
+            }
+        }
+        return -1;
+    }
+};
+
+// 2.2 ->
+class Solution
+{
+public:
+    int findDuplicate(vector<int> &nums)
+    {
+        vector<int> arr(nums.size(), 0);
+        int i = 0;
+
+        // storing 0->1 at position accoring to nums, if any no. came twice then there stores 1->2.
+        for (i = 0; i < nums.size(); i++)
+        {
+            arr[nums[i]]++;
+        }
+
+        for (i = 0; i < arr.size(); i++)
+        {
+            if (arr[i] > 1) //  element occur more than once in nums
+            {
+                break;
+            }
+        }
+
+        return i;
+    }
+};
+
+/* 3)
+- Binary Search Method
+time Complexity = O(n^2)
+Space Complexity - O(1) -> Constant Space
+*/
+
+class Solution
+{
+public:
+    int findDuplicate(vector<int> &nums)
+    {
+        int low = 1, high = nums.size() - 1, cnt;
+
+        while (low <= high)
+        {
+            int mid = low + (high - low) / 2;
+            cnt = 0;
+            // cnt number less than equal to mid
+            for (int n : nums)
+            {
+                if (n <= mid)
+                    ++cnt;
+            }
+            // binary search on left
+            if (cnt <= mid)
+                low = mid + 1;
+            else
+                // binary search on right
+                high = mid - 1;
+        }
+        return low;
+    }
+};
+
+
+/* 4)
+- Hash Map
+time Complexity = O(n)
+Space Complexity - O(n) 
+*/
+class Solution{
+    public:  int findDuplicate_set(int[] nums) {
+        Set<int> set = new HashSet<>();
+        int len = nums.size();
+        for (int i = 0; i < len; i++) {
+            if (!set.add(nums[i])) {
+                return nums[i];
+            }
+        }
+
+        return len;
+    }
+};

287.txt

@@ -0,0 +1,81 @@
+Remember these two properties of XOR operator :
+
+(1) If you take xor of a number with 0 ( zero ) , it would return the same number again.
+
+Means , n ^ 0 = n
+
+(2) If you take xor of a number with itself , it would return 0 ( zero ).
+
+Means , n ^ n = 0
+
+Now , Coming to the problem :
+
+   Let    Input_arr = { 23 , 21 , 24 , 27 , 22 , 27 , 26 , 25 }    
+
+   Output should be 27 ( because 27 is the duplicate element in the Input_arr ).
+Solution :
+
+Step 1 : Find “min” and “max” value in the given array. It will take O(n).
+
+Step 2 : Find XOR of all integers from range “min” to “max” ( inclusive ).
+
+Step 3 : Find XOR of all elements of the given array.
+
+Step 4 : XOR of Step 2 and Step 3 will give the required duplicate number.
+
+Description :
+
+Step1 : min = 21 , max = 27
+
+Step 2 : Step2_result = 21 ^ 22 ^ 23 ^ 24 ^ 25 ^ 26 ^ 27 = 20
+
+Step 3 : Step3_result = 23 ^ 21 ^ 24 ^ 27 ^ 22 ^ 27 ^ 26 ^ 25 = 15
+
+Step 4 : Final_Result = Step2_result ^ Step3_result = 20 ^ 15 = 27
+
+But , How Final_Result calculated the duplicate number ?
+
+Final_Result = ( 21 ^ 22 ^ 23 ^ 24 ^ 25 ^ 26 ^ 27 ) ^ ( 23 ^ 21 ^ 24 ^ 27 ^ 22 ^ 27 ^ 26 ^ 25 )
+
+Now , Remember above two properties : n ^ n = 0 AND n ^ 0 = n
+
+So , here ,
+
+Final_Result = ( 21 ^ 21 ) ^ ( 22 ^ 22 ) ^ ( 23 ^ 23 ) ^ ( 24 ^ 24 ) ^ ( 25 ^ 25 ) ^ ( 26 ^ 26 ) ^ ( 27 ^ 27 ^ 27 )
+
+             = 0 ^ 0 ^ 0 ^ 0 ^ 0 ^ 0 ^ ( 27 ^ 0 ) ( property applied )
+
+             = 0 ^ 27 ( because we know 0 ^ 0 = 0 )
+
+             = 27 ( Required Result )
+
+
+
+Q - if the input is [2,2,2,2,2] then this solution is giving the wrong answer.
+ans - Duplicate here means an element that occurs exactly twice, while all other elements occur exactly once. Though this will also work if you define duplicate as meaning an element that occurs an even number of times, while all other elements occur an odd number of times.
+
+
+
+class Solution {
+public:
+    int findDuplicate(vector<int>& nums){
+        int check_1=0;
+        int check_2=0;
+        int ans;
+        
+        int min = *min_element(nums.begin(), nums.end());
+        int max = *max_element(nums.begin(), nums.end());
+
+        for(int i=min;i<=max;i++){
+            check_1 = check_1 ^ i;
+        }
+
+        for(int i=0;i<nums.size();i++){
+            check_2 = check_2 ^ nums[i];
+        }
+
+        ans = check_1 ^ check_2;
+
+        return ans;
+    }
+};