chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-01-21-3315-Construct-the-Minimum-Bitwise-Array-II/explanation.md

@@ -0,0 +1,32 @@
+# Construct the Minimum Bitwise Array II (Medium)
+
+**Problem ID:** 3315  
+**Date:** 2026-01-21  
+**Link:** https://leetcode.com/problems/construct-the-minimum-bitwise-array-ii/
+
+## Approach
+
+To solve the problem of constructing the minimum bitwise array `ans` such that for each index `i`, the condition `ans[i] OR (ans[i] + 1) == nums[i]` holds, we can follow a systematic approach:
+
+### Main Idea:
+The key observation is to understand the properties of the bitwise OR operation. For two consecutive integers `x` and `x + 1`, the result of `x OR (x + 1)` will have all bits set to 1 up to the highest set bit in `x`. Therefore, the goal is to find the smallest integer `ans[i]` such that this condition is satisfied for each prime number `nums[i]`.
+
+### Steps to Approach:
+1. **Identify the Highest Set Bit**: For each prime number `nums[i]`, determine the highest bit position that is set to 1. This can be done using bit manipulation techniques, such as repeatedly shifting right until the number becomes zero.
+
+2. **Construct `ans[i]`**: Once the highest set bit position is identified, the smallest `ans[i]` can be constructed. The value of `ans[i]` should be:
+   - `2^k - 1` where `k` is the position of the highest set bit in `nums[i]`. This ensures that `ans[i] OR (ans[i] + 1)` will yield the desired `nums[i]`.
+
+3. **Check Validity**: If the calculated `ans[i]` does not satisfy the condition `ans[i] OR (ans[i] + 1) == nums[i]`, then set `ans[i]` to `-1`.
+
+4. **Iterate for All Elements**: Repeat the above steps for all elements in the `nums` array to construct the final `ans` array.
+
+### Data Structures:
+- An array `ans` of the same length as `nums` to store the results.
+- Basic integer variables to hold intermediate results (e.g., for bit manipulation).
+
+### Complexity:
+- **Time Complexity**: O(n * log(max(nums))) where `n` is the length of the `nums` array and `log(max(nums))` is due to the bit manipulation needed to find the highest set bit.
+- **Space Complexity**: O(n) for the output array `ans`.
+
+This approach efficiently constructs the required array while ensuring that the values are minimized, adhering to the constraints of the problem.

Medium/2026-01-21-3315-Construct-the-Minimum-Bitwise-Array-II/solution.java

@@ -0,0 +1,21 @@
+class Solution {
+    public int[] constructArray(int[] nums) {
+        int n = nums.length;
+        int[] ans = new int[n];
+        
+        for (int i = 0; i < n; i++) {
+            int num = nums[i];
+            ans[i] = -1; // Default value
+            
+            // Check if we can find a valid ans[i]
+            for (int j = 0; j <= num; j++) {
+                if ((j | (j + 1)) == num) {
+                    ans[i] = j;
+                    break;
+                }
+            }
+        }
+        
+        return ans;
+    }
+}

Medium/2026-01-21-3315-Construct-the-Minimum-Bitwise-Array-II/solution.js

@@ -0,0 +1,19 @@
+function constructArray(nums) {
+    const ans = [];
+    
+    for (const num of nums) {
+        let found = false;
+        for (let i = 0; i <= num; i++) {
+            if ((i | (i + 1)) === num) {
+                ans.push(i);
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            ans.push(-1);
+        }
+    }
+    
+    return ans;
+}

Medium/2026-01-21-3315-Construct-the-Minimum-Bitwise-Array-II/solution.py

@@ -0,0 +1,13 @@
+class Solution:
+    def minimumBitwiseArray(self, nums: List[int]) -> List[int]:
+        ans = []
+        for num in nums:
+            found = False
+            for x in range(num):
+                if x | (x + 1) == num:
+                    ans.append(x)
+                    found = True
+                    break
+            if not found:
+                ans.append(-1)
+        return ans

README.md

@@ -340,3 +340,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-01-18 — [Largest Magic Square](https://leetcode.com/problems/largest-magic-square/) (Medium) → `Medium/2026-01-18-1895-Largest-Magic-Square`
 - 2026-01-19 — [Maximum Side Length of a Square with Sum Less than or Equal to Threshold](https://leetcode.com/problems/maximum-side-length-of-a-square-with-sum-less-than-or-equal-to-threshold/) (Medium) → `Medium/2026-01-19-1292-Maximum-Side-Length-of-a-Square-with-Sum-Less-than-or-Equal-to-Threshold`
 - 2026-01-20 — [Construct the Minimum Bitwise Array I](https://leetcode.com/problems/construct-the-minimum-bitwise-array-i/) (Easy) → `Easy/2026-01-20-3314-Construct-the-Minimum-Bitwise-Array-I`
+- 2026-01-21 — [Construct the Minimum Bitwise Array II](https://leetcode.com/problems/construct-the-minimum-bitwise-array-ii/) (Medium) → `Medium/2026-01-21-3315-Construct-the-Minimum-Bitwise-Array-II`