Minimum Operations to Make Binary Array Elements Equal to One II
Source: leetcode
Difficulty: Medium
Tags: array, dynamic-programming, greedy

You are given a binary array `nums`.


You can do the following operation on the array **any** number of times (possibly zero):


- Choose **any** index `i` from the array and **flip** **all** the elements from index `i` to the end of the array.


**Flipping** an element means changing its value from 0 to 1, and from 1 to 0\.


Return the **minimum** number of operations required to make all elements in `nums` equal to 1\.


 


**Example 1:**



**Input:** nums \= \[0,1,1,0,1]


**Output:** 4


**Explanation:**\

We can do the following operations:


- Choose the index `i = 1`. The resulting array will be `nums = [0,0,0,1,0]`.
- Choose the index `i = 0`. The resulting array will be `nums = [1,1,1,0,1]`.
- Choose the index `i = 4`. The resulting array will be `nums = [1,1,1,0,0]`.
- Choose the index `i = 3`. The resulting array will be `nums = [1,1,1,1,1]`.



**Example 2:**



**Input:** nums \= \[1,0,0,0]


**Output:** 1


**Explanation:**\

We can do the following operation:


- Choose the index `i = 1`. The resulting array will be `nums = [1,1,1,1]`.



 


**Constraints:**


- `1 <= nums.length <= 105`
- `0 <= nums[i] <= 1`




C++ solution:
class Solution {
public:
    int minOperations(vector<int>& nums) {
        ios::sync_with_stdio(false);
        cin.tie(0);
        int flips = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] == 0 && flips % 2 == 1) {
                nums[i] = 1;
            } else if (nums[i] == 0 && flips % 2 == 0) {
                flips++;
                nums[i] = 1;
            } else if (nums[i] == 1 && flips % 2 == 1) {
                flips++;
            } else {
                continue;
            }
        }
        return flips;
    }
};

Go solution:
func minOperations(nums []int) int {
    operations := 0
    flipped := 0

    for i := 0; i < len(nums); i++ {
        // Determine the current state considering the number of flips so far
        currentState := nums[i]
        if flipped%2 != 0 {
            currentState = 1 - nums[i]
        }
        if currentState == 0 {
            // Perform a flip operation
            operations++
            flipped++
        }
    }

    return operations
}

Java solution:
class Solution {
    public int minOperations(int[] nums) {
        int n = nums.length;
        int i = 0, flips = 0;
        
        while (i < n) {
            nums[i] = (flips % 2 == 1) ? (nums[i] == 0 ? 1 : 0) : nums[i];
            
            if (nums[i] == 0) {
                flips++;
            }
            
            i++;
        }
        
        return flips;
    }
}

JavaScript solution:
var minOperations = function(nums) {
    let operations = 0;
    let flipped = 0;

    for (let i = 0; i < nums.length; i++) {
        // Determine the current state considering the number of flips so far
        let current_state = (flipped % 2 === 0) ? nums[i] : 1 - nums[i];
        if (current_state === 0) {
            // Perform a flip operation
            operations++;
            flipped++;
        }
    }

    return operations;
};

Python solution:
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        flips = current = 0
        for num in nums:
            if num == current:
                flips += 1
                current = not current
        return flips

Ruby solution:
# @param {Integer[]} nums
# @return {Integer}

def min_operations(nums)
    nums.each_with_object([]){|i,obj| obj << 1 if (obj.length + i).even?}.length
end