# Minimum number of changes such that elements are first Negative and then Positive

• Difficulty Level : Medium
• Last Updated : 09 Jun, 2022

Given an array arr[] of size N. The task is to find the minimum number of changes required to convert the array such that for any index 0 ≤ k < N, the elements in the array upto k-th index will be less than zero and after k-th index will be greater than zero.
That is:

arr < 0, arr < 0, …, arr[k] < 0 and arr[k + 1] > 0, arr[k + 2] > 0, …, arr[N – 1] > 0

Examples:

Input: arr[] = { -1, 1, 2, -1}
Output:
Replace last -1 with any positive integer.
Input: arr[] = { -1, 0, 1, 2 }
Output:
Replace 0 with any negative integer.

Approach: First, find for each valid k, the number of non-negative integers to the left of it and the number of non-positive integers to the right. Now, run a loop for each valid k (0 ≤ k <n) and find the sum of the number of non-negative integers left to it and number of non-positive integers right to it, and the minimum of these values for every k is our required answer.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return the count``// of minimum operations required``int` `Minimum_Operations(``int` `a[], ``int` `n)``{` `    ``// To store the count of negative integers``    ``// on the right of the current index (inclusive)``    ``int` `np[n + 1];``    ``np[n] = 0;` `    ``// Find the count of negative integers``    ``// on the right``    ``for` `(``int` `i = n - 1; i >= 0; i--) {``        ``np[i] = np[i + 1];` `        ``// If current element is negative``        ``if` `(a[i] <= 0)``            ``np[i]++;``    ``}` `    ``// To store the count of positive elements``    ``int` `pos = 0;``    ``int` `ans = n;` `    ``// Find the positive integers``    ``// on the left``    ``for` `(``int` `i = 0; i < n - 1; i++) {` `        ``// If current element is positive``        ``if` `(a[i] >= 0)``            ``pos++;` `        ``// Update the answer``        ``ans = min(ans, pos + np[i + 1]);``    ``}` `    ``// Return the required answer``    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``int` `a[] = { -1, 0, 1, 2 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a);``    ``cout << Minimum_Operations(a, n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{``    ` `// Function to return the count``// of minimum operations required``static` `int` `Minimum_Operations(``int` `[]a, ``int` `n)``{` `    ``// To store the count of negative integers``    ``// on the right of the current index (inclusive)``    ``int``[] np = ``new` `int``[n + ``1``];``    ``np[n] = ``0``;` `    ``// Find the count of negative integers``    ``// on the right``    ``for` `(``int` `i = n - ``1``; i >= ``0``; i--)``    ``{``        ``np[i] = np[i + ``1``];` `        ``// If current element is negative``        ``if` `(a[i] <= ``0``)``            ``np[i]++;``    ``}` `    ``// To store the count of positive elements``    ``int` `pos = ``0``;``    ``int` `ans = n;` `    ``// Find the positive integers``    ``// on the left``    ``for` `(``int` `i = ``0``; i < n - ``1``; i++)``    ``{` `        ``// If current element is positive``        ``if` `(a[i] >= ``0``)``            ``pos++;` `        ``// Update the answer``        ``ans = Math.min(ans, pos + np[i + ``1``]);``    ``}` `    ``// Return the required answer``    ``return` `ans;``}` `// Driver code``public` `static` `void` `main(String args[])``{``    ``int` `[]a = { -``1``, ``0``, ``1``, ``2` `};``    ``int` `n = a.length;``    ``System.out.print(Minimum_Operations(a, n));``}``}` `// This code is contributed by Akanksha Rai`

## Python3

 `# Python3 implementation of the approach` `# Function to return the count``# of minimum operations required``def` `Minimum_Operations(a, n):` `    ``# To store the count of negative integers``    ``# on the right of the current index (inclusive)``    ``np ``=` `[``0` `for` `i ``in` `range``(n ``+` `1``)]` `    ``# Find the count of negative integers``    ``# on the right``    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``):``        ``np[i] ``=` `np[i ``+` `1``]` `        ``# If current element is negative``        ``if` `(a[i] <``=` `0``):``            ``np[i] ``+``=` `1` `    ``# To store the count of positive elements``    ``pos ``=` `0``    ``ans ``=` `n` `    ``# Find the positive integers``    ``# on the left``    ``for` `i ``in` `range``(n ``-` `1``):` `        ``# If current element is positive``        ``if` `(a[i] >``=` `0``):``            ``pos ``+``=` `1` `        ``# Update the answer``        ``ans ``=` `min``(ans, pos ``+` `np[i ``+` `1``])` `    ``# Return the required answer``    ``return` `ans` `# Driver code``a ``=` `[``-``1``, ``0``, ``1``, ``2``]``n ``=` `len``(a)``print``(Minimum_Operations(a, n))` `# This code is contributed by mohit kumar`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{``    ` `// Function to return the count``// of minimum operations required``static` `int` `Minimum_Operations(``int` `[]a, ``int` `n)``{` `    ``// To store the count of negative integers``    ``// on the right of the current index (inclusive)``    ``int``[] np = ``new` `int``[n + 1];``    ``np[n] = 0;` `    ``// Find the count of negative integers``    ``// on the right``    ``for` `(``int` `i = n - 1; i >= 0; i--)``    ``{``        ``np[i] = np[i + 1];` `        ``// If current element is negative``        ``if` `(a[i] <= 0)``            ``np[i]++;``    ``}` `    ``// To store the count of positive elements``    ``int` `pos = 0;``    ``int` `ans = n;` `    ``// Find the positive integers``    ``// on the left``    ``for` `(``int` `i = 0; i < n - 1; i++)``    ``{` `        ``// If current element is positive``        ``if` `(a[i] >= 0)``            ``pos++;` `        ``// Update the answer``        ``ans = Math.Min(ans, pos + np[i + 1]);``    ``}` `    ``// Return the required answer``    ``return` `ans;``}` `// Driver code``static` `void` `Main()``{``    ``int` `[]a = { -1, 0, 1, 2 };``    ``int` `n = a.Length;``    ``Console.WriteLine(Minimum_Operations(a, n));``}``}` `// This code is contributed by mits`

## PHP

 `= 0; ``\$i``--)``    ``{``        ``\$np``[``\$i``] = ``\$np``[``\$i` `+ 1];` `        ``// If current element is negative``        ``if` `(``\$a``[``\$i``] <= 0)``            ``\$np``[``\$i``]++;``    ``}` `    ``// To store the count of positive elements``    ``\$pos` `= 0;``    ``\$ans` `= ``\$n``;` `    ``// Find the positive integers``    ``// on the left``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n` `- 1; ``\$i``++)``    ``{` `        ``// If current element is positive``        ``if` `(``\$a``[``\$i``] >= 0)``            ``\$pos``++;` `        ``// Update the answer``        ``\$ans` `= min(``\$ans``, ``\$pos` `+ ``\$np``[``\$i` `+ 1]);``    ``}` `    ``// Return the required answer``    ``return` `\$ans``;``}` `// Driver code``\$a` `= ``array``( -1, 0, 1, 2 );``\$n` `= ``count``(``\$a``) ;` `echo` `Minimum_Operations(``\$a``, ``\$n``);` `// This code is contributed by Ryuga``?>`

## Javascript

 ``

Output:

`1`

Time Complexity: O(n)
Auxiliary Space: O(n)

My Personal Notes arrow_drop_up