1class Solution {
2    private char[] chars; // Array to hold character data
3    private int maxOperations; // Maximum allowable operations
4
5    public int minLength(String s, int numOps) {
6        this.maxOperations = numOps;
7        this.chars = s.toCharArray();
8        int left = 1, right = s.length(); // Initialize binary search boundaries
9        while (left < right) {
10            int mid = (left + right) >> 1; // Calculate the mid-point for binary search
11            if (check(mid)) {
12                right = mid; // Narrow down the search to the left half
13            } else {
14                left = mid + 1; // Narrow down the search to the right half
15            }
16        }
17        return left; // Return the minimum valid length
18    }
19
20    private boolean check(int m) {
21        int operationsCount = 0; // Count of required operations
22
23        if (m == 1) {
24            // Handle the special case when m = 1
25            char[] pattern = {'0', '1'};
26            for (int i = 0; i < chars.length; ++i) {
27                if (chars[i] == pattern[i & 1]) { // Check for alternating pattern
28                    ++operationsCount;
29                }
30            }
31            operationsCount = Math.min(operationsCount, chars.length - operationsCount);
32        } else {
33            int segmentLength = 0;
34            for (int i = 0; i < chars.length; ++i) {
35                ++segmentLength;
36                // Check for the end of the segment or a change in character
37                if (i == chars.length - 1 || chars[i] != chars[i + 1]) {
38                    operationsCount += segmentLength / (m + 1); // Calculate operations needed for the segment
39                    segmentLength = 0; // Reset segment length
40                }
41            }
42        }
43
44        return operationsCount <= maxOperations; // Evaluate if current m is feasible
45    }
46}
47

1#include <string>
2#include <algorithm>
3using namespace std;
4
5class Solution {
6public:
7    int minLength(string s, int numOps) {
8        int n = s.size(); // Get the size of the string
9        auto canAchieve = [&](int m) {
10            int cnt = 0; // Initialize a counter for operations needed
11
12            // Case when m equals 1
13            if (m == 1) {
14                string expectedPattern = "01"; // Alternating pattern
15                for (int i = 0; i < n; ++i) {
16                    // Check if current character matches the alternating pattern
17                    if (s[i] == expectedPattern[i % 2]) {
18                        ++cnt; // Increment count if matches
19                    }
20                }
21                cnt = min(cnt, n - cnt); // Get minimum number of operations required
22            } else {
23                int groupSize = 0; // Variable to track group size
24                for (int i = 0; i < n; ++i) {
25                    ++groupSize; // Increment group size
26                    // Check if it's the end of a group
27                    if (i == n - 1 || s[i] != s[i + 1]) {
28                        // Calculate the number of operations needed for this group
29                        cnt += groupSize / (m + 1);
30                        groupSize = 0; // Reset the group size for the next group
31                    }
32                }
33            }
34            return cnt <= numOps; // Check if we can achieve this with the given number of operations
35        };
36
37        int left = 1, right = n;
38        while (left < right) {
39            int mid = (left + right) >> 1; // Find the midpoint
40            // If the current mid can be achieved, search in the left half
41            if (canAchieve(mid)) {
42                right = mid;
43            } else {
44                left = mid + 1; // Else search in the right half
45            }
46        }
47        return left; // Return the minimum length found
48    }
49};
50

1// Function to determine the minimum possible length of string after performing operations
2function minLength(s: string, numOps: number): number {
3    const n = s.length;
4
5    // Inner function to check if a given length `m` is achievable with the allowed number of operations
6    const check = (m: number): boolean => {
7        let cnt = 0; // Initialize count of operations performed
8
9        if (m === 1) {
10            const alterPattern = '01'; // Alternating pattern for comparison
11            for (let i = 0; i < n; ++i) {
12                if (s[i] === alterPattern[i % 2]) {
13                    // Count the mismatches with alternating pattern
14                    ++cnt;
15                }
16            }
17            // Take the minimum of mismatches or matches to calculate operation count
18            cnt = Math.min(cnt, n - cnt);
19        } else {
20            let seqLength = 0; // Length of the current sequence of identical characters
21            for (let i = 0; i < n; ++i) {
22                ++seqLength;
23                if (i === n - 1 || s[i] !== s[i + 1]) {
24                    // Calculate the number of operations needed for this sequence
25                    cnt += Math.floor(seqLength / (m + 1));
26                    seqLength = 0; // Reset the sequence length for the next group
27                }
28            }
29        }
30        // Returns true if the required number of operations is less than or equal to allowed operations
31        return cnt <= numOps;
32    };
33
34    let [left, right] = [1, n]; // Initialize binary search boundaries
35
36    // Binary search to find the minimum length `m`
37    while (left < right) {
38        const mid = (left + right) >> 1; // Middle point
39
40        if (check(mid)) {
41            right = mid; // Try for a smaller length
42        } else {
43            left = mid + 1; // Increase the minimum possible length
44        }
45    }
46    return left; // Return the minimal length found
47}
48