chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Hard/2025-11-08-1611-Minimum-One-Bit-Operations-to-Make-Integers-Zero/explanation.md

@@ -0,0 +1,28 @@
+# Minimum One Bit Operations to Make Integers Zero (Hard)
+
+**Problem ID:** 1611  
+**Date:** 2025-11-08  
+**Link:** https://leetcode.com/problems/minimum-one-bit-operations-to-make-integers-zero/
+
+## Approach
+
+To solve the problem of transforming an integer \( n \) to zero using the minimum number of specified bit operations, we can leverage a recursive approach with memoization or a bit manipulation strategy. 
+
+### Main Idea:
+The key insight is to recognize that the operations allowed are closely related to the structure of the binary representation of \( n \). Specifically, the operations manipulate the rightmost bits and depend on the state of adjacent bits. The goal is to minimize the number of operations needed to turn all bits of \( n \) to zero.
+
+### Approach:
+1. **Recursive Function**: Define a recursive function `minOperations(n)` that calculates the minimum operations required to reduce \( n \) to zero. The base case is when \( n \) is zero, in which case no operations are needed.
+
+2. **Bit Manipulation**: For each recursive call:
+   - If the rightmost bit (0th bit) is 1, we can perform the first operation (change the 0th bit to 0) and then call `minOperations(n >> 1)` (which effectively divides \( n \) by 2).
+   - If the rightmost bit is 0, we need to check the next bits. If the next bit is 1, we can perform the second operation, which allows us to change the current bit while ensuring the previous bits are set correctly. This might involve a more complex manipulation of bits, and we may need to explore the structure of \( n \) further.
+
+3. **Memoization**: To avoid recalculating results for the same values of \( n \), we can store previously computed results in a dictionary or an array.
+
+### Complexity:
+- **Time Complexity**: The time complexity is \( O(\log n) \) due to the recursive nature of the bit manipulation, as the number of bits in \( n \) is logarithmic relative to its value.
+- **Space Complexity**: The space complexity is \( O(\log n) \) as well, primarily due to the recursion stack and the memoization storage.
+
+### Conclusion:
+By carefully considering the binary representation of \( n \) and applying recursive strategies with memoization, we can efficiently determine the minimum number of operations required to transform \( n \) into zero. This approach balances clarity and efficiency, leveraging the properties of binary numbers and operations.

Hard/2025-11-08-1611-Minimum-One-Bit-Operations-to-Make-Integers-Zero/solution.java

@@ -0,0 +1,10 @@
+class Solution {
+    public int minimumOneBitOperations(int n) {
+        int operations = 0;
+        while (n > 0) {
+            operations += n;
+            n = n >> 1;
+        }
+        return operations;
+    }
+}

Hard/2025-11-08-1611-Minimum-One-Bit-Operations-to-Make-Integers-Zero/solution.js

@@ -0,0 +1,8 @@
+var minimumOneBitOperations = function(n) {
+    let operations = 0;
+    while (n > 0) {
+        operations ^= n; // XOR with n
+        n >>= 1; // Right shift n
+    }
+    return operations;
+};

Hard/2025-11-08-1611-Minimum-One-Bit-Operations-to-Make-Integers-Zero/solution.py

@@ -0,0 +1,5 @@
+class Solution:
+    def minimumOneBitOperations(self, n: int) -> int:
+        if n == 0:
+            return 0
+        return n + self.minimumOneBitOperations(n >> 1)

README.md

@@ -272,3 +272,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-11-05 — [Find X-Sum of All K-Long Subarrays II](https://leetcode.com/problems/find-x-sum-of-all-k-long-subarrays-ii/) (Hard) → `Hard/2025-11-05-3321-Find-X-Sum-of-All-K-Long-Subarrays-II`
 - 2025-11-06 — [Power Grid Maintenance](https://leetcode.com/problems/power-grid-maintenance/) (Medium) → `Medium/2025-11-06-3607-Power-Grid-Maintenance`
 - 2025-11-07 — [Maximize the Minimum Powered City](https://leetcode.com/problems/maximize-the-minimum-powered-city/) (Hard) → `Hard/2025-11-07-2528-Maximize-the-Minimum-Powered-City`
+- 2025-11-08 — [Minimum One Bit Operations to Make Integers Zero](https://leetcode.com/problems/minimum-one-bit-operations-to-make-integers-zero/) (Hard) → `Hard/2025-11-08-1611-Minimum-One-Bit-Operations-to-Make-Integers-Zero`