Skip to content
Related Articles

Related Articles

Improve Article

Longest subsegment of ‘1’s formed by changing at most k ‘0’s

  • Difficulty Level : Medium
  • Last Updated : 25 May, 2021

Given a binary array a[] and a number k, we need to find length of the longest subsegment of ‘1’s possible by changing at most k ‘0’s. 
Examples: 
 

Input : a[] = {1, 0, 0, 1, 1, 0, 1}, 
          k = 1.
Output : 4
Explanation : Here, we should only change 1
zero(0). Maximum possible length we can get
is by changing the 3rd zero in the array, 
we get a[] = {1, 0, 0, 1, 1, 1, 1}

Input : a[] = {1, 0, 0, 1, 0, 1, 0, 1, 0, 1}, 
         k = 2.
Output : 5
Output: Here, we can change only 2 zeros. 
Maximum possible length we can get is by 
changing the 3rd and 4th (or) 4th and 5th 
zeros.

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

We can solve this problem using two pointers technique. Let us take a subarray [l, r] which contains at most k zeroes. Let our left pointer be l and right pointer be r. We always maintain our subsegment [l, r] to contain no more than k zeroes by moving the left pointer l. Check at every step for maximum size (i.e, r-l+1). 
 

C++




// CPP program to find length of longest
// subsegment of all 1's by changing at
// most k 0's
#include <iostream>
using namespace std;
 
int longestSubSeg(int a[], int n, int k)
{
    int cnt0 = 0;
    int l = 0;
    int max_len = 0;
 
    // i decides current ending point
    for (int i = 0; i < n; i++) {
        if (a[i] == 0)
            cnt0++;
 
        // If there are more 0's move
        // left point for current ending
        // point.
        while (cnt0 > k) {
            if (a[l] == 0)
                cnt0--;
            l++;
        }
 
        max_len = max(max_len, i - l + 1);
    }
 
    return max_len;
}
 
// Driver code
int main()
{
    int a[] = { 1, 0, 0, 1, 0, 1, 0, 1 };
    int k = 2;
    int n = sizeof(a) / sizeof(a[0]);
    cout << longestSubSeg(a, n, k);
    return 0;
}

Java




// Java program to find length of
// longest subsegment of all 1's
// by changing at most k 0's
import java.io.*;
 
class GFG {
 
static int longestSubSeg(int a[], int n,
                                  int k)
{
    int cnt0 = 0;
    int l = 0;
    int max_len = 0;
 
    // i decides current ending point
    for (int i = 0; i < n; i++) {
        if (a[i] == 0)
            cnt0++;
 
        // If there are more 0's move
        // left point for current ending
        // point.
        while (cnt0 > k) {
            if (a[l] == 0)
                cnt0--;
            l++;
        }
 
        max_len = Math.max(max_len, i - l + 1);
    }
 
    return max_len;
}
 
// Driver code
public static void main (String[] args)
{
    int a[] = { 1, 0, 0, 1, 0, 1, 0, 1 };
    int k = 2;
    int n = a.length;
    System.out.println( longestSubSeg(a, n, k));
         
}
}
 
// This code is contributed by vt_m

Python3




# Python3 program to find length
# of longest subsegment of all 1's 
# by changing at most k 0's
 
def longestSubSeg(a, n, k):
 
    cnt0 = 0
    l = 0
    max_len = 0;
 
    # i decides current ending point
    for i in range(0, n):
        if a[i] == 0:
            cnt0 += 1
 
        # If there are more 0's move
        # left point for current
        # ending point.
        while (cnt0 > k):
            if a[l] == 0:
                cnt0 -= 1
            l += 1
         
 
        max_len = max(max_len, i - l + 1);
     
 
    return max_len
 
# Driver code
a = [1, 0, 0, 1, 0, 1, 0, 1 ]
k = 2
n = len(a)
print(longestSubSeg(a, n, k))
 
# This code is contributed by Smitha Dinesh Semwal

C#




// C# program to find length of
// longest subsegment of all 1's
// by changing at most k 0's
using System;
 
class GFG {
 
    static int longestSubSeg(int[] a, int n,
                                      int k)
    {
        int cnt0 = 0;
        int l = 0;
        int max_len = 0;
 
        // i decides current ending point
        for (int i = 0; i < n; i++)
        {
            if (a[i] == 0)
                cnt0++;
 
            // If there are more 0's move
            // left point for current ending
            // point.
            while (cnt0 > k) {
                if (a[l] == 0)
                    cnt0--;
                l++;
            }
 
            max_len = Math.Max(max_len, i - l + 1);
        }
 
        return max_len;
    }
 
    // Driver code
    public static void Main()
    {
        int[] a = { 1, 0, 0, 1, 0, 1, 0, 1 };
        int k = 2;
        int n = a.Length;
        Console.WriteLine(longestSubSeg(a, n, k));
    }
}
 
// This code is contributed by vt_m

PHP




<?php
// PHP program to find length of longest
// subsegment of all 1's by changing at
// most k 0's
 
function longestSubSeg( $a, $n, $k)
{
    $cnt0 = 0;
    $l = 0;
    $max_len = 0;
 
    // i decides current ending point
    for($i = 0; $i < $n; $i++)
    {
        if ($a[$i] == 0)
            $cnt0++;
 
        // If there are more 0's move
        // left point for current ending
        // point.
        while ($cnt0 > $k)
        {
            if ($a[$l] == 0)
                $cnt0--;
            $l++;
        }
 
        $max_len = max($max_len, $i - $l + 1);
    }
 
    return $max_len;
}
 
    // Driver code
    $a = array(1, 0, 0, 1, 0, 1, 0, 1);
    $k = 2;
    $n = count($a);
    echo longestSubSeg($a, $n, $k);
 
// This code is contributed by anuj_67.
?>

Javascript




<script>
 
    // JavaScript program to find length of
    // longest subsegment of all 1's
    // by changing at most k 0's
     
    function longestSubSeg(a, n, k)
    {
        let cnt0 = 0;
        let l = 0;
        let max_len = 0;
   
        // i decides current ending point
        for (let i = 0; i < n; i++)
        {
            if (a[i] == 0)
                cnt0++;
   
            // If there are more 0's move
            // left point for current ending
            // point.
            while (cnt0 > k) {
                if (a[l] == 0)
                    cnt0--;
                l++;
            }
   
            max_len = Math.max(max_len, i - l + 1);
        }
   
        return max_len;
    }
     
    let a = [ 1, 0, 0, 1, 0, 1, 0, 1 ];
    let k = 2;
    let n = a.length;
    document.write(longestSubSeg(a, n, k));
     
</script>

Output:  

5

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :