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

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: 1
Replace last -1 with any positive integer.

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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++ 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 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 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# 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 `

 `= 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 ` `?> `

Output:
```1
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

pawanasipugmailcom

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :