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] < 0, arr[1] < 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.
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 <bits/stdc++.h> 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[0]); cout << Minimum_Operations(a, n); return 0; } |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
PHP
<?php // PHP implementation of the approach // Function to return the count // of minimum operations required function Minimum_Operations($a, $n) { // To store the count of negative // integers on the right of the // current index (inclusive) $np = array(); $np[$n] = 0; // Find the count of negative // integers on the right for ($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 $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 ?> |
chevron_right
filter_none
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.
