You are given a binary array nums and an integer k.

A k-bit flip is choosing a subarray of length k from nums and simultaneously changing every 0 in the subarray to 1, and every 1 in the subarray to 0.

Return the minimum number of k-bit flips required so that there is no 0 in the array. If it is not possible, return -1.

A subarray is a contiguous part of an array.

&nbsp;
Example 1:

Input: nums = [0,1,0], k = 1
Output: 2
Explanation: Flip nums[0], then flip nums[2].


Example 2:

Input: nums = [1,1,0], k = 2
Output: -1
Explanation: No matter how we flip subarrays of size 2, we cannot make the array become [1,1,1].


Example 3:

Input: nums = [0,0,0,1,0,1,1,0], k = 3
Output: 3
Explanation: 
Flip nums[0],nums[1],nums[2]: nums becomes [1,1,1,1,0,1,1,0]
Flip nums[4],nums[5],nums[6]: nums becomes [1,1,1,1,1,0,0,0]
Flip nums[5],nums[6],nums[7]: nums becomes [1,1,1,1,1,1,1,1]


&nbsp;
Constraints:


	1 &lt;= nums.length &lt;= 105
	1 &lt;= k &lt;= nums.length


class Solution:
    def minKBitFlips(self, nums: List[int], k: int) -> int:
        flips = [0]*len(nums)
        csum = 0

        for left in range(0, len(nums)-k+1):
            if (nums[left] + csum) % 2 == 0:
                flips[left] += 1
                csum += 1
            if left >= k-1:
                csum -= flips[left-k+1]

        for check in range(len(nums)-k+1, len(nums)):
            if (nums[check] + csum) % 2 == 0:
                return -1
            if check >= k-1:
                csum -= flips[check-k+1]

        return sum(flips)
class Solution {
    public int minKBitFlips(int[] nums, int k) {
        int target = 0, ans = 0;;
        boolean[] flip = new boolean[nums.length+1];
        for (int i = 0; i < nums.length; i++){
            if (flip[i]){
                target^=1;
            }
            if (i<nums.length-k+1&&nums[i]==target){
                target^=1;
                flip[i+k]^=true;
                ans++;
            }
            if (i>nums.length-k&&nums[i]==target){
                return -1;
            }
        }
        return ans;
    }
}
class Solution {
public:
    int minKBitFlips(vector<int>& nums, int k) {
        
        int n = nums.size();
        
        int flips = 0;                  // flips on current positions
        vector<int> flip(n+1,0);        // to set end pointer for a flip i.e i+k ->-1
        int ops = 0;                    // answer
        
        for(int i=0;i<n;i++){
            
            flips +=flip[i];            // update flips for current position
                                       
            // even flips on 1 okay
            if(nums[i]==1 && (flips)%2==0){
                continue;
            }
            
            // odd flips on 0 okay
            
            if(nums[i]==0 && (flips)%2!=0){
                continue;
            }
            
            // margin error as k bits flips is must
            
            if(i+k > n){
                return -1;
            }
            
            ops++;           //increment ans
            flips++;         // do flip at this position
            flip[i+k] = -1;  // set poiter where current flip ends
            
        }
        
        return ops;
        
    }
};
var minKBitFlips = function(nums, k) {
    let count = 0
    
    for(let i=0; i<nums.length; i++){
        if (nums[i] == 0){
            for(let j=0; j<k && i+k <= nums.length; j++){
                nums[i+j] = 1 - nums[i+j]
            }
            count++
        }
    }
        
    return nums.every(n => n ==1) ? count : -1
};
Minimum Number of K Consecutive Bit Flips