chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-03-07-1888-Minimum-Number-of-Flips-to-Make-the-Binary-String-Alternating/explanation.md

@@ -0,0 +1,44 @@
+# Minimum Number of Flips to Make the Binary String Alternating (Medium)
+
+**Problem ID:** 1888  
+**Date:** 2026-03-07  
+**Link:** https://leetcode.com/problems/minimum-number-of-flips-to-make-the-binary-string-alternating/
+
+## Approach
+
+To solve the problem of finding the minimum number of flips required to make a binary string alternating, we can utilize a systematic approach that involves analyzing the string's structure and potential transformations.
+
+### Approach:
+
+1. **Understanding Alternating Patterns**:
+   An alternating binary string can either start with '0' or '1', leading to two possible valid patterns:
+   - Pattern A: "010101..."
+   - Pattern B: "101010..."
+
+2. **Counting Flips**:
+   For each character in the string, we will compare it against the expected character in both patterns:
+   - For Pattern A, the expected character at index `i` is `i % 2 == 0 ? '0' : '1'`.
+   - For Pattern B, the expected character at index `i` is `i % 2 == 0 ? '1' : '0'`.
+   
+   As we traverse the string, we will maintain two counters:
+   - `flipsA`: Counts the number of flips needed to convert the string to Pattern A.
+   - `flipsB`: Counts the number of flips needed to convert the string to Pattern B.
+
+3. **Handling Rotations**:
+   Since we can perform Type-1 operations (rotating the string), we need to consider all possible rotations of the string. However, instead of generating each rotation, we can simulate this by considering the string as circular. This can be efficiently done by concatenating the string to itself (i.e., `s + s`), allowing us to check for alternating patterns starting from any index in the original string.
+
+4. **Sliding Window Technique**:
+   We can use a sliding window of size equal to the original string length to evaluate the number of flips required for each segment of length `n` in the concatenated string. For each window position, we compute the flips required for both patterns and update the minimum flips accordingly.
+
+5. **Final Calculation**:
+   The result will be the minimum value between `flipsA` and `flipsB` across all evaluated windows.
+
+### Data Structures:
+- We primarily use integer counters for `flipsA` and `flipsB`.
+- A single string variable for the binary string and its concatenated version.
+
+### Complexity:
+- **Time Complexity**: O(n), where n is the length of the string. We perform a single pass over the string and a sliding window check, both of which operate in linear time.
+- **Space Complexity**: O(1) for the counters, as we do not use any additional data structures that scale with input size.
+
+This approach ensures that we efficiently compute the minimum flips required to make the binary string alternating while considering all possible rotations without explicitly generating them.

Medium/2026-03-07-1888-Minimum-Number-of-Flips-to-Make-the-Binary-String-Alternating/solution.java

@@ -0,0 +1,25 @@
+class Solution {
+    public int minFlips(String s) {
+        int n = s.length();
+        s += s; // Concatenate the string to handle rotations
+        int count1 = 0, count2 = 0;
+
+        // Count flips for both patterns: "010101..." and "101010..."
+        for (int i = 0; i < n; i++) {
+            if (s.charAt(i) != '0' + (i % 2)) count1++;
+            if (s.charAt(i) != '1' - (i % 2)) count2++;
+        }
+
+        int minFlips = Math.min(count1, count2);
+        for (int i = n; i < s.length(); i++) {
+            // Slide the window
+            if (s.charAt(i) != '0' + (i % 2)) count1++;
+            if (s.charAt(i) != '1' - (i % 2)) count2++;
+            if (s.charAt(i - n) != '0' + ((i - n) % 2)) count1--;
+            if (s.charAt(i - n) != '1' - ((i - n) % 2)) count2--;
+            minFlips = Math.min(minFlips, Math.min(count1, count2));
+        }
+
+        return minFlips;
+    }
+}

Medium/2026-03-07-1888-Minimum-Number-of-Flips-to-Make-the-Binary-String-Alternating/solution.js

@@ -0,0 +1,26 @@
+var minFlips = function(s) {
+    const n = s.length;
+    s += s; // Concatenate the string to handle rotations
+    let count1 = 0, count2 = 0;
+
+    for (let i = 0; i < n; i++) {
+        // Expected characters for alternating patterns
+        if (s[i] !== (i % 2 === 0 ? '0' : '1')) count1++;
+        if (s[i] !== (i % 2 === 0 ? '1' : '0')) count2++;
+    }
+
+    let minFlips = Math.min(count1, count2);
+    
+    for (let i = n; i < s.length; i++) {
+        // Slide the window
+        if (s[i - n] !== (i - n % 2 === 0 ? '0' : '1')) count1--;
+        if (s[i - n] !== (i - n % 2 === 0 ? '1' : '0')) count2--;
+        
+        if (s[i] !== (i % 2 === 0 ? '0' : '1')) count1++;
+        if (s[i] !== (i % 2 === 0 ? '1' : '0')) count2++;
+        
+        minFlips = Math.min(minFlips, count1, count2);
+    }
+
+    return minFlips;
+};

Medium/2026-03-07-1888-Minimum-Number-of-Flips-to-Make-the-Binary-String-Alternating/solution.py

@@ -0,0 +1,30 @@
+class Solution:
+    def minFlips(self, s: str) -> int:
+        n = len(s)
+        s = s + s  # Concatenate the string to handle rotations
+        count1 = count2 = 0
+        
+        # Count flips for the two possible alternating patterns
+        for i in range(n):
+            if s[i] != '0' if i % 2 == 0 else '1':
+                count1 += 1
+            if s[i] != '1' if i % 2 == 0 else '0':
+                count2 += 1
+        
+        # Minimum flips needed for any rotation
+        min_flips = min(count1, count2)
+        
+        for i in range(n, len(s)):
+            if s[i] != '0' if i % 2 == 0 else '1':
+                count1 += 1
+            if s[i] != '1' if i % 2 == 0 else '0':
+                count2 += 1
+            
+            if s[i - n] != '0' if (i - n) % 2 == 0 else '1':
+                count1 -= 1
+            if s[i - n] != '1' if (i - n) % 2 == 0 else '0':
+                count2 -= 1
+            
+            min_flips = min(min_flips, count1, count2)
+        
+        return min_flips

README.md

@@ -385,3 +385,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-03-04 — [Special Positions in a Binary Matrix](https://leetcode.com/problems/special-positions-in-a-binary-matrix/) (Easy) → `Easy/2026-03-04-1582-Special-Positions-in-a-Binary-Matrix`
 - 2026-03-05 — [Minimum Changes To Make Alternating Binary String](https://leetcode.com/problems/minimum-changes-to-make-alternating-binary-string/) (Easy) → `Easy/2026-03-05-1758-Minimum-Changes-To-Make-Alternating-Binary-String`
 - 2026-03-06 — [Check if Binary String Has at Most One Segment of Ones](https://leetcode.com/problems/check-if-binary-string-has-at-most-one-segment-of-ones/) (Easy) → `Easy/2026-03-06-1784-Check-if-Binary-String-Has-at-Most-One-Segment-of-Ones`
+- 2026-03-07 — [Minimum Number of Flips to Make the Binary String Alternating](https://leetcode.com/problems/minimum-number-of-flips-to-make-the-binary-string-alternating/) (Medium) → `Medium/2026-03-07-1888-Minimum-Number-of-Flips-to-Make-the-Binary-String-Alternating`