# Minimize operations to convert Array elements to 0s

• Last Updated : 12 Aug, 2022

Given an array nums[] of length N containing non-negative integers, the task is to convert all elements from index 0 to N-2 to zero, after doing the below operations minimum number of times.

• In one operation select two indices i and j such that i < j  and all the elements between i and j has to be non-zero, then set nums[i] = nums[i] – 1 and nums[j] = nums[j] + 1.

Examples:

Input: N = 5, nums[] = [0, 2, 0, 2, 0]
Output: 5
Explanation: We need to do 5 above given operation
to complete the task, and the operations are:

• Select j = 3, k = 4 nums[] becomes: [0, 2, 0, 1, 1]
• Select j = 1, k = 2 nums[] becomes: [0, 1, 1, 1, 1]
• Select j = 1, k = 4 nums[] becomes: [0, 0, 1, 1, 2]
• Select j = 2, k = 4 nums[] becomes: [0, 0, 0, 1, 3]
• Select j = 3, k = 4 nums[] becomes: [0, 0, 0, 0, 4]

Input: N = 3, nums[] = [2, 0, 0]
Output: 3
Explanation: We need to do 3 above given operation
to complete the task, and the operations are:

• Select j = 0, k = 1 nums[] becomes: [1, 1, 0]
• Select j = 0, k = 2 nums[] becomes: [0, 1, 1]
• Select j = 1, k = 2 nums[] becomes: [0, 0, 2]

Approach: The problem can be solved based on the following idea:

• The possible way to convert all elements from 0 to N-2 to 0 is by reducing each element from the left by 1 and adding 1 each time to the last element, until leftmost element become zero and then moving to the next index. So the number of operations will be the sum of elements from 0 to N-2.
• But if there is a 0 present in between then first we have to convert that 0 into a positive number, so that we can perform the operation for the elements present in the left of that 0.
• To convert a 0 to a positive element, 1 operation will take place, so our final answer will be the sum of elements from 0 to N-2 and the number of zeros present after the first positive element.

Follow the steps given below to implement the approach:

• First traverse the array till you get the first non-zero element.
• After that if element is non-zero then update ans += nums[i]
• Else if the element is zero then update ans += 1.
• Traverse the given array till N-2 and calculate the required answer as mentioned above.
• Return the calculated answer.

Below is the implementation of the above approach.

## C++

 `// C++ Algorithm for the above approach``#include ``using` `namespace` `std;` `// Function which returns``// minimum number of operations``// required to convert array``// into target array``int` `minOperations(``int` `nums[], ``int` `N)``{``  ` `    ``// ans variable contains number of``    ``// operations processed after traversing``    ``// ith element``    ``int` `ans = 0;``    ``int` `i = 0;` `    ``// Traversing to get first non-zero element``    ``while` `(i < N && nums[i] == 0)``        ``i++;``  ` `    ``// After getting first non-zero element we will``    ``// apply the given operation``    ``while` `(i < N - 1) {``        ``if` `(nums[i] == 0)``            ``ans++;``        ``else``            ``ans += nums[i];``        ``i++;``    ``}` `    ``// Returning the ans variable``    ``return` `ans;``}` `// Driver Code``int` `main()``{` `    ``int` `N = 5;``    ``int` `nums[] = { 0, 2, 0, 2, 0 };``  ` `    ``// Function Call``    ``int` `ans = minOperations(nums, N);``    ``cout << ans;``    ``return` `0;``}` `// This code is contributed by Kdheeraj.`

## Java

 `// Java algorithm of the above approach` `import` `java.util.*;` `class` `GFG {` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``5``;``        ``int``[] nums = { ``0``, ``2``, ``0``, ``2``, ``0` `};``        ``// Function Call``        ``int` `ans = minOperations(nums, N);``        ``System.out.println(ans);``    ``}` `    ``// Function which returns``    ``// minimum number of operations``    ``// required to convert array``    ``// into target array``    ``public` `static` `int` `minOperations(``int``[] nums, ``int` `N)``    ``{``        ``// ans variable contains number of``        ``// operations processed after traversing``        ``// ith element``        ``int` `ans = ``0``;``        ``int` `i = ``0``;` `        ``// Traversing to get first non-zero element``        ``while` `(i < N && nums[i] == ``0``)``            ``i++;``        ``// After getting first non-zero element we will``        ``// apply the given operation``        ``while` `(i < N - ``1``) {``            ``if` `(nums[i] == ``0``)``                ``ans++;``            ``else``                ``ans += nums[i];``            ``i++;``        ``}` `        ``// Returning the ans variable``        ``return` `ans;``    ``}``}`

## Python3

 `# Python code to implement the above approach` `# Function which returns``# minimum number of operations``# required to convert array``# into target array``def` `minOperations(nums, N) :``  ` `    ``# ans variable contains number of``    ``# operations processed after traversing``    ``# ith element``    ``ans ``=` `0``    ``i ``=` `0` `    ``# Traversing to get first non-zero element``    ``while` `(i < N ``and` `nums[i] ``=``=` `0``) :``        ``i ``+``=` `1``  ` `    ``# After getting first non-zero element we will``    ``# apply the given operation``    ``while` `(i < N ``-` `1``) :``        ``if` `(nums[i] ``=``=` `0``) :``            ``ans ``+``=` `1``        ``else` `:``            ``ans ``+``=` `nums[i]``        ``i ``+``=` `1``    `  `    ``# Returning the ans variable``    ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `5``    ``nums ``=` `[ ``0``, ``2``, ``0``, ``2``, ``0` `]``  ` `    ``# Function Call``    ``ans ``=` `minOperations(nums, N)``    ``print``(ans)``    ` `    ``# This code is contributed by sanjoy_62.`

## C#

 `// C# program for above approach:``using` `System;``class` `GFG {` `  ``// Function which returns``  ``// minimum number of operations``  ``// required to convert array``  ``// into target array``  ``public` `static` `int` `minOperations(``int``[] nums, ``int` `N)``  ``{``    ` `    ``// ans variable contains number of``    ``// operations processed after traversing``    ``// ith element``    ``int` `ans = 0;``    ``int` `i = 0;` `    ``// Traversing to get first non-zero element``    ``while` `(i < N && nums[i] == 0)``      ``i++;``    ``// After getting first non-zero element we will``    ``// apply the given operation``    ``while` `(i < N - 1) {``      ``if` `(nums[i] == 0)``        ``ans++;``      ``else``        ``ans += nums[i];``      ``i++;``    ``}` `    ``// Returning the ans variable``    ``return` `ans;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main()``  ``{``    ``int` `N = 5;``    ``int``[] nums = { 0, 2, 0, 2, 0 };``    ` `    ``// Function Call``    ``int` `ans = minOperations(nums, N);``    ``Console.Write(ans);` `  ``}``}` `// This code is contributed by code_hunt.`

## Javascript

 ``

Output

`5`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up