chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Easy/2026-02-22-868-Binary-Gap/explanation.md

@@ -0,0 +1,28 @@
+# Binary Gap (Easy)
+
+**Problem ID:** 868  
+**Date:** 2026-02-22  
+**Link:** https://leetcode.com/problems/binary-gap/
+
+## Approach
+
+To solve the "Binary Gap" problem, we need to find the longest distance between any two adjacent '1's in the binary representation of a given positive integer \( n \).
+
+### Approach:
+
+1. **Binary Representation**: First, we convert the integer \( n \) into its binary form. This can be done using built-in functions or bit manipulation.
+
+2. **Track Positions of '1's**: As we traverse the binary string, we will keep track of the positions (indices) of each '1' encountered. This can be done using a simple list or array to store the indices.
+
+3. **Calculate Distances**: Once we have the positions of all '1's, we can calculate the distances between each pair of adjacent '1's. The distance between two '1's at positions \( i \) and \( j \) is given by \( j - i \).
+
+4. **Find Maximum Distance**: As we compute the distances, we maintain a variable to track the maximum distance found. If there are no adjacent '1's (i.e., less than two '1's in the binary representation), we return 0.
+
+### Data Structures:
+- A list (or array) to store the indices of '1's in the binary representation.
+
+### Complexity:
+- **Time Complexity**: The time complexity is \( O(\log n) \) because the number of bits in the binary representation of \( n \) is \( \log_2(n) \).
+- **Space Complexity**: The space complexity is also \( O(\log n) \) due to storing the indices of '1's.
+
+This approach efficiently calculates the desired distance by leveraging the properties of binary numbers and simple list operations, ensuring that we meet the problem's constraints.

Easy/2026-02-22-868-Binary-Gap/solution.java

@@ -0,0 +1,17 @@
+class Solution {
+    public int binaryGap(int n) {
+        int lastPosition = -1;
+        int maxGap = 0;
+        
+        for (int i = 0; i < 32; i++) {
+            if ((n & (1 << i)) != 0) {
+                if (lastPosition != -1) {
+                    maxGap = Math.max(maxGap, i - lastPosition);
+                }
+                lastPosition = i;
+            }
+        }
+        
+        return maxGap;
+    }
+}

Easy/2026-02-22-868-Binary-Gap/solution.js

@@ -0,0 +1,16 @@
+var binaryGap = function(n) {
+    let lastIndex = -1;
+    let maxDistance = 0;
+    
+    for (let i = 0; n > 0; i++) {
+        if (n & 1) {
+            if (lastIndex !== -1) {
+                maxDistance = Math.max(maxDistance, i - lastIndex);
+            }
+            lastIndex = i;
+        }
+        n >>= 1;
+    }
+    
+    return maxDistance;
+};

Easy/2026-02-22-868-Binary-Gap/solution.py

@@ -0,0 +1,12 @@
+class Solution:
+    def binaryGap(self, n: int) -> int:
+        last_position = -1
+        max_gap = 0
+        
+        for i in range(32):
+            if n & (1 << i):
+                if last_position != -1:
+                    max_gap = max(max_gap, i - last_position)
+                last_position = i
+        
+        return max_gap

README.md

@@ -372,3 +372,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-02-19 — [Count Binary Substrings](https://leetcode.com/problems/count-binary-substrings/) (Easy) → `Easy/2026-02-19-696-Count-Binary-Substrings`
 - 2026-02-20 — [Special Binary String](https://leetcode.com/problems/special-binary-string/) (Hard) → `Hard/2026-02-20-761-Special-Binary-String`
 - 2026-02-21 — [Prime Number of Set Bits in Binary Representation](https://leetcode.com/problems/prime-number-of-set-bits-in-binary-representation/) (Easy) → `Easy/2026-02-21-762-Prime-Number-of-Set-Bits-in-Binary-Representation`
+- 2026-02-22 — [Binary Gap](https://leetcode.com/problems/binary-gap/) (Easy) → `Easy/2026-02-22-868-Binary-Gap`