Algorithm: Find smallest contiguous array containing K 0's in array of 1's and 0's - arrays

Question

I have array of 1's and 0's only. Now I want to find smallest contiguous subset/subarray which contains at least K 0's.
Example
Array is 1 1 0 1 1 0 1 1 0 0 0 0 1 0 1 1 0 0 0 1 1 0 0 1 0 0 0
and K(6) should be 0 0 1 0 1 1 0 0 0 or 0 0 0 0 1 0 1 1 0....
My Solution
Array: 1 1 0 1 1 0 1 1 0 0 0 0 1 0 1 1 0 0 0 1 1 0 0
Index: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
Sum: 1 2 2 3 4 4 5 6 6 6 6 6 7 7 8 9 9 9 9 10 11 11 11
Diff(I-S): 0 0 1 1 1 2 2 2 3 4 5 6 6 7 7 7 8 9 10 10 10 11 12
For K(6)
Start with 9-15 = Store difference in diff.
Next increase difference
8-15(Difference in index)
8-14(Compare Difference in index)
So on keep moving to find element with least elements...
I am looking for better algorithm for this solution.

Answer 1

I believe you could do it with a rolling window like:
In the given array, find the first occurance of 0 (say at index i).
Keep on scanning until you've k 0's included in your window (say, the window ends at index j) Record the window Length(say j-i+1=L).
Now, discard the left-most 0 at index i, and keep scanning till you get next 0 (say at index i'
Extend the right-end of the window situated at j to j' to make the count of 0's = k again.
If the new window-length L'=j'-i'+1 is smaller update it.
Keep on repeating the above procedure till j hits the end of array.
No extra space needed and It's O(N) time-complexity, as an element would be scanned at max twice.

Answer 2

With extra O(k) memory , you can do it in O(n) time.Here is the java code.What you are doing is , if a[i]==0 then you check where the queue's first element points to.and if the differnce in positions is less than minimum, then you update the answer.
Queue<Integer> queue =new LinkedList<Integer>();
int i=0;
while(queue.size()<k&&i<n)
{
if(a[i]==0)
{
queue.add(i);
}
i++;
}
if(i==n&&queue.size()<k)
System.out.println("Insufficient 0''s");
int ans=i-1-queue.peek();
for(int j=i;j<n;j++)
{
if(a[i]==0)
{
queue.poll();
queue.add(i);
ans=Math.min(ans,i-queue.peek());
}
}
System.out.println(ans);
EDIT :Explanation
We maintain a queue which consist of all the positions which have a 0 and we limit the queue size to be k. So initially in the while loop we fill the queue with the first k indexes. If ofcourse the queue size is less than k after seeing all elements , then it's impossible. After that , we keep going to all the left over elements .Each time we see a 0 , we calcualte the length of the subsequence ,(i-queue.peek()) and find the minimum .Also we remove the first element , and add the latest index again maintaining the queue size

Answer 3

fully working python code:
>>> A = "1 1 0 1 1 0 1 1 0 0 0 0 1 0 1 1 0 0 0 1 1 0 0".split()
>>> A = map(int, A)
>>> zero_positions = [i for i, x in enumerate(A) if x == 0]
>>> k = 3
>>> containing_k_zeros_intervals = zip(zero_positions, zero_positions[k:])
>>> min(b - a for a, b in containing_k_zeros_intervals)
3

Answer 4

Scan the array from the starting to find the index till which we get k zeros.
Have two pointers.
Now ptr1 is at the index where first zero is seen.
start = ptr1
ptr2 is at the index where we have found k 0's.
end = ptr2;
a)increment ptr1.
b ) find the index from ptr2+1 until we find k 0's.
c) Say at ptr3 we find K 0's. If ptr3-ptr1 < (end-start) update indexes start and end.
Repeat steps a -c until the end of the list.
At the end, start and end will have indexes where there are k 0's.