chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Easy/2025-10-31-3289-The-Two-Sneaky-Numbers-of-Digitville/explanation.md

@@ -0,0 +1,29 @@
+# The Two Sneaky Numbers of Digitville (Easy)
+
+**Problem ID:** 3289  
+**Date:** 2025-10-31  
+**Link:** https://leetcode.com/problems/the-two-sneaky-numbers-of-digitville/
+
+## Approach
+
+To solve the problem of identifying the two sneaky numbers in the list `nums`, we can utilize a straightforward approach based on counting occurrences of each number.
+
+### Approach:
+
+1. **Understanding the Input**: The input list `nums` contains integers from `0` to `n-1`, where each integer is supposed to appear exactly once, except for two integers that appear twice. The length of `nums` is `n + 2`, which indicates that exactly two numbers are duplicated.
+
+2. **Data Structure**: We can use a hash set to track the numbers we encounter as we iterate through the list. This allows us to efficiently check if a number has already been seen.
+
+3. **Iterative Check**: As we traverse the `nums` list:
+   - For each number, check if it is already in the hash set.
+   - If it is, it means this number is one of the sneaky numbers, so we add it to our result list.
+   - If it is not in the set, we add it to the set for future reference.
+
+4. **Stopping Condition**: Since we know there are exactly two duplicates, we can stop once we have found both sneaky numbers.
+
+### Complexity:
+- **Time Complexity**: O(n), where n is the length of the input list `nums`, since we are making a single pass through the list.
+- **Space Complexity**: O(n) in the worst case for the hash set, although in practice, since we only need to store unique numbers, the space will be limited to the number of unique integers (which is `n`).
+
+### Conclusion:
+This approach is efficient and straightforward, leveraging a hash set for quick lookups and insertions to identify the two sneaky numbers in linear time. The algorithm is robust given the constraints and guarantees provided in the problem statement.

Easy/2025-10-31-3289-The-Two-Sneaky-Numbers-of-Digitville/solution.java

@@ -0,0 +1,20 @@
+import java.util.HashMap;
+
+public class Solution {
+    public int[] findSneakyNumbers(int[] nums) {
+        HashMap<Integer, Integer> countMap = new HashMap<>();
+        for (int num : nums) {
+            countMap.put(num, countMap.getOrDefault(num, 0) + 1);
+        }
+        
+        int[] result = new int[2];
+        int index = 0;
+        for (int key : countMap.keySet()) {
+            if (countMap.get(key) == 2) {
+                result[index++] = key;
+            }
+        }
+        
+        return result;
+    }
+}

Easy/2025-10-31-3289-The-Two-Sneaky-Numbers-of-Digitville/solution.js

@@ -0,0 +1,14 @@
+var findDuplicates = function(nums) {
+    const seen = new Set();
+    const duplicates = [];
+    
+    for (const num of nums) {
+        if (seen.has(num)) {
+            duplicates.push(num);
+        } else {
+            seen.add(num);
+        }
+    }
+    
+    return duplicates;
+};

Easy/2025-10-31-3289-The-Two-Sneaky-Numbers-of-Digitville/solution.py

@@ -0,0 +1,12 @@
+class Solution:
+    def findDuplicates(self, nums: List[int]) -> List[int]:
+        seen = set()
+        duplicates = set()
+        
+        for num in nums:
+            if num in seen:
+                duplicates.add(num)
+            else:
+                seen.add(num)
+        
+        return list(duplicates)

README.md

@@ -264,3 +264,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-10-28 — [Make Array Elements Equal to Zero](https://leetcode.com/problems/make-array-elements-equal-to-zero/) (Easy) → `Easy/2025-10-28-3354-Make-Array-Elements-Equal-to-Zero`
 - 2025-10-29 — [Smallest Number With All Set Bits](https://leetcode.com/problems/smallest-number-with-all-set-bits/) (Easy) → `Easy/2025-10-29-3370-Smallest-Number-With-All-Set-Bits`
 - 2025-10-30 — [Minimum Number of Increments on Subarrays to Form a Target Array](https://leetcode.com/problems/minimum-number-of-increments-on-subarrays-to-form-a-target-array/) (Hard) → `Hard/2025-10-30-1526-Minimum-Number-of-Increments-on-Subarrays-to-Form-a-Target-Array`
+- 2025-10-31 — [The Two Sneaky Numbers of Digitville](https://leetcode.com/problems/the-two-sneaky-numbers-of-digitville/) (Easy) → `Easy/2025-10-31-3289-The-Two-Sneaky-Numbers-of-Digitville`