A sliding window approach will work. In order to maximise the number of consecutive 1s, it only makes sense to choose adjacent groups of 0s for conversion to 1s (i.e. without any non-chosen 0s between them), otherwise we spend our k on creating disjoint islands of 1s, which is a waste. So you’d first choose the first k groups of 0s, then unselect the first one of these and append the next one, …etc, “sliding” through the input, each time checking which one of these options represents the longest result.

Here is an implementation of the sliding window approach written in JavaScript:

function solve(pattern, k) {
    let start = 0; // start index of the "window"
    let size = 0; // Longest result found so far
    for (let end = 0; end < pattern.length; end++) { // Grow window to the right
        if (pattern[end] == "0" && (end == 0 || pattern[end-1] == "1")) {
            // We encounter a first 0 in a group of 0s
            k--; // Adjust the number of 0-groups we are still allowed to consume
            if (k < 0) { // Must give up a group of 0s
                // Shrink window from the left side, dropping one 0-group
                while (pattern[start] == 1) start++;
                while (pattern[start] == 0) start++;
                k++; // ...and allow for one more 0-group at the right
            }
        }
        if (end - start >= size) size = end + 1 - start; // best so far
    }
    return size;
}

let count = solve("1100101001", 2);
console.log(count);

You’re looking for the longest sequence with the property that it contains at most 2 runs of zeroes. Because that’s the answer: Flip those 2 runs to ones and voila, the longest chain of 1s.

For obvious reasons, the start of this sequence is either the start of the input, or a 1 that is preceded by a 0, and the end is either the end of the input, or a 1 that is followed by a 0.

Rewrite the input to length coding. So, 11000100001 Turns into ‘0,2,3,1,4,1’ (for: 0 zeroes, then 2 ones, then 3 zeroes, 1 one, 4 zeroes, 1 one). For this algorithm we must always start with a count of zeroes, hence, we start with ‘zero zeroes’.

You’re looking for the largest available sum of 4 consecutive numbers if the start is even, and 5 consecutive numbers if the start index is odd.

This can trivially be done with sliding windows: Add up the first 4 numbers and save this value.

Then remove the first number and add the 2 subsequent numbers. If this is larger than what you stored before, save that.

Then remove 2 numbers off the front and add 1 to the back.

Then remove 1 number off the front and add 2 to the back.

Keeping going until you’re at the end. Return the largest ‘stored’ number.