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 <iostream> 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# 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

<script> // Javascript Algorithm for the above approach  // Function which returns // minimum number of operations // required to convert array // into target array function minOperations(nums, N) {        // ans variable contains number of     // operations processed after traversing     // ith element     let ans = 0;     let 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     let N = 5;     let nums = [ 0, 2, 0, 2, 0 ];        // Function Call     let ans = minOperations(nums, N);     document.write(ans);          // This code is contributed by satwik4409.     </script>

Output

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

Minimize operations to make Array a permutation

kdheeraj

Improve

Article Tags :

Practice Tags :

Minimize operations to convert Array elements to 0s

Similar Reads