Merge pull request #84 from SenthilkumarKailash/feature/137-Single-Number-II

Solution #137 - Kailash Senthilkumar - 09/08/2025

Author: JRS296

Arrays & Strings/#137 - Single Number II - Medium/Explanation.md

@@ -0,0 +1,129 @@
+# Single Number II
+
+**Difficulty:** Medium  
+**Category:** Arrays, Bit Manipulation  
+**Leetcode Link:** [Problem Link](https://leetcode.com/problems/single-number-ii/)  
+
+---
+
+## 📝 Introduction
+
+We are given an integer array `nums` where every element appears exactly **three times**, except for one element which appears exactly **once**. The task is to find and return this unique element.  
+The solution must have:
+- **Linear runtime complexity** O(n)
+- **Constant extra space** O(1)
+
+---
+
+## 💡 Approach & Key Insights
+
+The naive approach would involve counting the occurrences of each number (using a hash map), but that would require **O(n)** extra space, violating the space constraint.
+
+Instead, we can use **bitwise manipulation** to track the count of each bit across all numbers:
+- Maintain two bitmasks:
+  - **`ones`** → bits that have appeared exactly once so far.
+  - **`twos`** → bits that have appeared exactly twice so far.
+- When a bit appears a **third time**, it is removed from both `ones` and `twos`.
+
+The key insight:
+- `ones = (ones ^ num) & ~twos`
+- `twos = (twos ^ num) & ~ones`
+- XOR toggles the bit, AND with `~` masks out unwanted bits.
+
+---
+
+## 🛠️ Breakdown of Approaches
+
+### 1️⃣ Brute Force / Naive Approach
+
+- **Explanation:**  
+  Use a hash map to count each number’s frequency, then return the number with count = 1.
+- **Time Complexity:** O(n)  
+- **Space Complexity:** O(n)
+
+Example:  
+`nums = [2, 2, 3, 2]` → Frequency: `{2: 3, 3: 1}` → Output: `3`
+
+---
+
+### 2️⃣ Bitwise Counting Approach
+
+- **Explanation:**  
+  For each bit position (0–31), count how many numbers have that bit set.  
+  Take `count % 3` to determine if that bit belongs to the unique number.
+- **Time Complexity:** O(32n) ≈ O(n)  
+- **Space Complexity:** O(1)
+
+Example:  
+Count bits column-wise → reconstruct the number.
+
+---
+
+### 3️⃣ Best / Final Optimized Approach (Bitmask Method)
+
+- **Explanation:**  
+  Use `ones` and `twos` to track the counts of bits modulo 3.
+- **Time Complexity:** O(n) — single pass  
+- **Space Complexity:** O(1) — only two variables used
+
+Example/Dry Run for `nums = [2, 2, 3, 2]`:  
+Binary:  
+- 2 → `10`  
+- 3 → `11`
+
+Step-by-step:
+```
+Initial: ones=00, twos=00
+
+num=2: ones=(00^10)&~00=10, twos=(00^10)&~10=00
+num=2: ones=(10^10)&~00=00, twos=(00^10)&~00=10
+num=3: ones=(00^11)&~10=01, twos=(10^11)&~01=00
+num=2: ones=(01^10)&~00=11, twos=(00^10)&~11=00
+Final: ones=11 (decimal 3)
+```
+Output: `3`
+
+---
+
+## 📊 Complexity Analysis
+
+| Approach      | Time Complexity | Space Complexity |
+| ------------- | --------------- | ---------------- |
+| Brute Force   | O(n)            | O(n)             |
+| Bit Count     | O(n)            | O(1)             |
+| Bitmask Method| O(n)            | O(1)             |
+
+---
+
+## 📉 Optimization Ideas
+
+The **bitmask method** is already optimal for both runtime and space. Any further improvements would be micro-optimizations or hardware-specific.
+
+---
+
+## 📌 Example Walkthroughs & Dry Runs
+
+Example:  
+```
+Input: nums = [0, 1, 0, 1, 0, 1, 99]
+Output: 99
+
+Step-by-step bitmask evolution:
+ones=0, twos=0
+Process each number using:
+ones = (ones ^ num) & ~twos
+twos = (twos ^ num) & ~ones
+Final ones=99 → Output
+```
+
+---
+
+## 🔗 Additional Resources
+
+- [LeetCode Bit Manipulation Patterns](https://leetcode.com/tag/bit-manipulation/)
+- [GeeksforGeeks - Bitwise Operators](https://www.geeksforgeeks.org/bitwise-operators-in-c-cpp/)
+
+---
+
+Author: Kailash Senthilkumar  
+Date: 09/08/2025  

Arrays & Strings/#137 - Single Number II - Medium/Solution.cpp.txt

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int singleNumber(vector<int>& nums) {
+        int ones = 0, twos = 0;
+        for (int num : nums) {
+            // Update 'ones' with bits appearing first time or third time
+            ones = (ones ^ num) & ~twos;
+            // Update 'twos' with bits appearing second time
+            twos = (twos ^ num) & ~ones;
+        }
+        // 'ones' will contain the number that appears only once
+        return ones;
+    }
+};

Arrays & Strings/#137 - Single Number II - Medium/Solution.java.txt

@@ -0,0 +1,17 @@
+class Solution {
+    public int singleNumber(int[] nums) {
+        int ones = 0;
+        int twos = 0;
+        for(int num:nums){
+             // This updates 'ones' with bits appearing first time or third time
+            ones = (ones^num) & ~twos;
+            // This updates 'twos' with bits appearing second time
+            twos =(twos^num) & ~ones;
+
+
+
+        }
+        // The 'ones' variable will contain the number that has appeared only once.
+        return ones;
+    }
+}

Arrays & Strings/#137 - Single Number II - Medium/Solution.py.txt

@@ -0,0 +1,10 @@
+class Solution:
+    def singleNumber(self, nums):
+        ones, twos = 0, 0
+        for num in nums:
+            # Update 'ones' with bits appearing first time or third time
+            ones = (ones ^ num) & ~twos
+            # Update 'twos' with bits appearing second time
+            twos = (twos ^ num) & ~ones
+        # 'ones' will contain the number that appears only once
+        return ones

Arrays & Strings/#268 - Missing Number - Easy/Missing Number - Explanation.md.md

@@ -0,0 +1,124 @@
+# Missing Number
+
+**Difficulty:** Easy  
+**Category:** Arrays, Bit Manipulation  
+**Leetcode Link:** [Problem Link](https://leetcode.com/problems/missing-number/)  
+
+---
+
+## 📝 Introduction
+
+Given an array `nums` containing `n` distinct numbers in the range `[0, n]`, the task is to find the single number missing from this range. The input guarantees exactly one missing number.
+
+**Constraints:**
+- `n` numbers, each unique, ranging from 0 to n.
+- Exactly one number in this range is missing.
+- Expected output: the missing number.
+
+---
+
+## 💡 Approach & Key Insights
+
+The main idea is to leverage the **XOR property**:
+- XOR of a number with itself is 0 (`x ^ x = 0`).
+- XOR of a number with 0 is the number itself (`x ^ 0 = x`).
+- XOR is commutative and associative.
+
+If we XOR all indices (0 to n) with all numbers in the array, the duplicates cancel out, leaving only the missing number.
+
+---
+
+## 🛠️ Breakdown of Approaches
+
+### 1️⃣ Brute Force / Naive Approach
+
+- **Explanation:**  
+  Loop through numbers from `0` to `n` and check if each is present in the array. Return the number that is not found.
+- **Time Complexity:** O(n²) — because for each number we scan the array.
+- **Space Complexity:** O(1) — no extra space needed apart from variables.
+
+Example:  
+Input: `[3, 0, 1]`  
+Step 1: Check `0` → Found  
+Step 2: Check `1` → Found  
+Step 3: Check `2` → Missing → Output: `2`
+
+---
+
+### 2️⃣ Optimized Approach (Sum Formula)
+
+- **Explanation:**  
+  Use the sum formula for the first `n` integers:  
+  `expectedSum = n * (n + 1) / 2`  
+  Subtract the actual sum of the array from `expectedSum` to get the missing number.
+- **Time Complexity:** O(n) — single pass to get the sum.
+- **Space Complexity:** O(1) — only variables for sums.
+
+Example:  
+Input: `[3, 0, 1]`  
+n = 3 → Expected Sum = `6`  
+Actual Sum = `4`  
+Missing = `6 - 4 = 2`
+
+---
+
+### 3️⃣ Best / Final Optimized Approach (XOR Method)
+
+- **Explanation:**  
+  XOR all numbers from `0` to `n` with all elements of the array. All pairs cancel out except the missing number.  
+  This avoids integer overflow (unlike sum approach for very large n) and still runs in O(n).
+- **Time Complexity:** O(n) — single pass.
+- **Space Complexity:** O(1) — no extra space.
+
+Example:  
+Input: `[3, 0, 1]`  
+```
+xor = 0
+xor ^ 0 ^ 3 = 3  
+xor ^ 1 ^ 0 = 4 (in binary cancels out)  
+xor ^ 2 = 2 (final answer)
+```
+
+---
+
+## 📊 Complexity Analysis
+
+| Approach      | Time Complexity | Space Complexity |
+| ------------- | --------------- | ---------------- |
+| Brute Force   | O(n²)           | O(1)             |
+| Optimized     | O(n)            | O(1)             |
+| Best Approach | O(n)            | O(1)             |
+
+---
+
+## 📉 Optimization Ideas
+
+The XOR method is already optimal for both time and space. Any further optimization would focus on language-specific performance tricks, but asymptotic complexity cannot be improved.
+
+---
+
+## 📌 Example Walkthroughs & Dry Runs
+
+Example:  
+Input: `nums = [3, 0, 1]`  
+n = 3  
+```
+xor = 0
+i = 0 → xor = 0 ^ 0 ^ 3 = 3
+i = 1 → xor = 3 ^ 1 ^ 0 = 2
+i = 2 → xor = 2 ^ 2 ^ 1 = 1
+Final: xor = 1 ^ 3 = 2
+Output: 2
+```
+
+---
+
+## 🔗 Additional Resources
+
+- [LeetCode Discussion on XOR Trick](https://leetcode.com/problems/missing-number/discuss)
+- [Bit Manipulation Basics](https://www.geeksforgeeks.org/bitwise-operators-in-c-cpp/)
+
+---
+
+Author: Kailash Senthilkumar  
+Date: 09/08/2025  

Arrays & Strings/#268 - Missing Number - Easy/Missing Number - Solution.cpp.txt

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int missingNumber(vector<int>& nums) {
+        int n = nums.size();
+
+        // Initialize xor to 0. This will hold the result of XOR operations.
+        int xorResult = 0;
+
+        // Iterate through the array
+        for (int i = 0; i < n; i++) {
+            // XOR current index and the current number
+            xorResult = xorResult ^ i ^ nums[i];
+        }
+
+        // XOR with the last number n (because indices go from 0 to n-1, but range is 0 to n)
+        xorResult = xorResult ^ n;
+
+        // The result is the missing number
+        return xorResult;
+    }
+};

Arrays & Strings/#268 - Missing Number - Easy/Missing Number - Solution.java.txt

@@ -0,0 +1,20 @@
+class Solution {
+    public int missingNumber(int[] nums) {
+        int n = nums.length;
+        
+        // Initialize xor to 0. This will hold the result of XOR operations.
+        int xor = 0;
+
+        // Iterate through the array
+        for (int i = 0; i < n; i++) {
+            // XOR current index and the current number
+            xor = xor ^ i ^ nums[i];
+        }
+
+        // XOR with the last number n (because indices go from 0 to n-1, but range is 0 to n)
+        xor = xor ^ n;
+
+        // The result is the missing number
+        return xor;
+    }
+}

Arrays & Strings/#268 - Missing Number - Easy/Missing Number - Solution.py.txt

@@ -0,0 +1,17 @@
+class Solution:
+    def missingNumber(self, nums):
+        n = len(nums)
+
+        # Initialize xor to 0. This will hold the result of XOR operations.
+        xor = 0
+
+        # Iterate through the array
+        for i in range(n):
+            # XOR current index and the current number
+            xor = xor ^ i ^ nums[i]
+
+        # XOR with the last number n (because indices go from 0 to n-1, but range is 0 to n)
+        xor = xor ^ n
+
+        # The result is the missing number
+        return xor