645-set-mismatch complete

Author: Abhay Bhat

0-template/Solution.java

@@ -0,0 +1,3 @@
+public class Solution {
+    
+}

0-template/readme.md

@@ -0,0 +1,15 @@
+## 0. Problem Name
+### Brief Description
+
+**Example:**
+
+[<problem-name> on leetcode](https://leetcode.com/problems/<problem-name>/description/)
+
+## Solution
+### Intuition
+
+### Approach
+
+### Time Complexity
+
+### Space Complexity

645-set-mismatch/Solution.java

@@ -0,0 +1,65 @@
+/**
+ * This class provides a solution for finding the error numbers in an array. Error numbers are numbers that are missing and numbers that are repeated.
+ * Provided only one is missing and one is repeated and the array contains only positive numbers from 1 to n, where n is the length of the array.
+ */
+public class Solution {
+    /**
+     * Finds the error numbers in the given array.
+     * 
+     * @param nums The array of integers.
+     * @return An array containing the error numbers, where the first element is the missing number and the second element is the repeating number.
+     */
+    public int[] findErrorNums(int[] nums) {
+        int xor = 0;
+
+        // XOR all the numbers from 1 to nums.length and all the numbers in the nums array.
+        // The result is the XOR of the missing and repeating numbers.
+        for(int i = 1; i <= nums.length; i++) {
+            xor ^= i;
+            xor ^= nums[i-1];
+        }
+
+        // Initialize a counter i and a variable xor1 with the value of xor.
+        // Start a loop that will run up to 31 times. This is because the maximum value of n is 2^31 - 1(integer limit).
+        // In each iteration, check if the least significant bit of xor1 is 1.
+        // If it is, break the loop as we've found the first set bit.
+        // If it's not, shift the bits of xor1 one place to the right, effectively dividing it by 2.
+        int i = 0;
+        int xor1 = xor;
+        for(i = 0; i < 30; i++) {
+            if((xor1 & 1) == 1)
+                break;
+            xor1 >>= 1;
+        }
+        
+        // This code separates the numbers into two groups based on the checker bit.
+        // If the checker bit in a number is 1, it is XORed with xor1.
+        // If the checker bit in a number is 0, it is XORed with xor2.
+        // This is done for both the numbers from 1 to nums.length and the numbers in the nums array.
+        // The result is that xor1 and xor2 hold the missing and repeating numbers, but it's not known which is which.
+        int checker = i;
+        int xor2 = 0;
+        xor1 = 0;
+        for(i = 1; i <= nums.length; i++) {
+            if(((i >> checker) & 1) == 1)
+                xor1 ^= i;
+            else
+                xor2 ^= i;
+            
+            if(((nums[i-1] >> checker) & 1) == 1)
+                xor1 ^= nums[i-1];
+            else
+                xor2 ^= nums[i-1];
+        }
+
+        // This code finds the missing and repeating numbers.
+        // It does so by checking if the missing number is in the nums array.
+        // If it is, then the missing number is xor1 and the repeating number is xor2.
+        // If it's not, then the missing number is xor2 and the repeating number is xor1.
+        for(i = 0; i < nums.length; i++) {
+            if(xor1 == nums[i])
+                return new int[] {xor1, xor2};
+        }
+        return new int[] {xor2, xor1};
+    }
+}

645-set-mismatch/readme.md

@@ -0,0 +1,68 @@
+## 645. Set Mismatch
+### Brief Description
+
+- Given a set of integers `nums`, which originally contains all the numbers from 1 to n. 
+- Due to some error, one of the numbers in `nums` got duplicated to another number in the set
+- This results in repetition of one number and loss of another number.
+
+Find the number that occurs twice and the number that is missing and return them in the form of an array.
+
+**Example:**
+>**Input:** nums = [1,2,2,4] \
+**Output:** [2,3]
+
+[set-mismatch on leetcode](https://leetcode.com/problems/set-mismatch/description/)
+
+## Solution
+### Intuition
+Use xor to find the repeated and missing values.
+
+### Approach
+since all the number are from 1 - n we traverse from 1 - n and xor all the values and xor them with the array elements, we will end up with the xor of the missing element and repeated element
+
+```x
+example:
+arr = [6,4,5,2,1,7,4]
+
+result_xor = 
+    (1 ^ 2 ^ 3 ^ 4 ^ 5 ^ 6 ^ 7) ^ 
+        (6 ^ 4 ^ 5 ^ 2 ^ 1 ^ 7 ^ 4) 
+    = 3 ^ 4
+```
+
+now based on the least significant set bit ($i^{th}$ bit) in the resulting XOR we can divide the number array into 2 parts one part with the $i^{th}$ bit set and the other set with $i^{th}$ bit is not set.
+
+```x 
+Why does this work?
+```
+Well since if the ith bit is set in the result_xor it means that $i^{th}$ bit is set in only one of the 2 numbers forming the xor hence when we partition the array into 2 parts we will end up with 2 xors one having the missing number and one having the repeated number.
+
+```x
+from the above example we have 
+result_xor = 3 ^ 4 = 7
+in 7 0th bit is set hence i = 0
+
+so we divide the array and index into 2 parts based 
+on the rightmost bit (p1 is part1(right bit 0) and 
+p2 is part2(right bit 1))
+
+the array         ---  the indices(1-indexed)
+6  - 110  - p1               1  - 001 - p2
+4  - 100  - p1               2  - 010 - p1
+5  - 101  - p2               3  - 011 - p2
+2  - 010  - p1               4  - 100 - p1
+1  - 001  - p2               5  - 101 - p2
+7  - 111  - p2               6  - 110 - p1
+4  - 100  - p1               7  - 111 - p2
+
+xor_p1 = (6 ^ 4 ^ 2 ^ 4) ^ (2 ^ 4 ^ 6) = 4
+xor_p2 = (5 ^ 1 ^ 7) ^ (1 ^ 3 ^ 5 ^ 7) = 3
+```
+
+Iterate over the array again to check which one of xor_p1 and xor_p2 is present in the array and return answer appropriately.
+
+### Time Complexity
+$O(n)$ -> since the array is being traversed in one direction
+
+### Space Complexity
+$O(1)$ -> no extra space used only integers to store XOR values

818-race-car/readme.md

@@ -14,9 +14,9 @@ When you get an instruction `'R'`, your car does the following:
 - Your position stays the same.
 
 **Example:**
-- sequence: `AAR`
-- your car goes to positions `0 --> 1 --> 3 --> 3`
-- your speed goes to `1 --> 2 --> 4 --> -1`
+> sequence: `AAR` \
+your car goes to positions `0 --> 1 --> 3 --> 3` \
+your speed goes to `1 --> 2 --> 4 --> -1`
 
 Given a target position target, return the length of the shortest sequence of instructions to get there.