Skip to content
Related Articles

Related Articles

Improve Article

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

  • Difficulty Level : Medium
  • Last Updated : 19 May, 2021

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;
}
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



<?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
?>
Javascript



<script>
 
// JavaScript implementation of the approach
 
// Function to return the count
// of minimum operations required
function Minimum_Operations(a, n)
{
   
    // To store the count of negative letegers
    // on the right of the current index (inclusive)
    let np = Array(n+1).fill(0);
    np[n] = 0;
   
    // Find the count of negative letegers
    // on the right
    for (let 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
    let pos = 0;
    let ans = n;
   
    // Find the positive letegers
    // on the left
    for (let 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
 
    let a = [ -1, 0, 1, 2 ];
    let n = a.length;
    document.write(Minimum_Operations(a, n));
           
</script>
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.



My Personal Notes
arrow_drop_up
Previous
Find number of unique triangles among given N triangles
Next

Length of the longest substring with no consecutive same letters
Recommended Articles
Page :
Only integer with positive value in positive negative value in array
08, Nov 17
Find Kth element in an array containing odd elements first and then even elements
03, Sep 19
Maximum sum subset having equal number of positive and negative elements
07, May 20
Check if array elements are consecutive in O(n) time and O(1) space (Handles Both Positive and negative numbers)
15, Jul 17
Generate an array with K positive numbers such that arr[i] is either -1 or 1 and sum of the array is positive
16, May 21
Minimum toggles to partition a binary array so that it has first 0s then 1s
20, Apr 17
Positive elements at even and negative at odd positions (Relative order not maintained)
12, Sep 17
Replace all elements by difference of sums of positive and negative numbers after that element
19, Mar 19
Maximum sum possible by assigning alternate positive and negative sign to elements in a subsequence
20, Oct 20
Sum of array elements that is first continuously increasing then decreasing
04, Sep 17
Print all subsequences in first decreasing then increasing by selecting N/2 elements from [1, N]
05, Jul 21
Largest number having both positive and negative values present in the array
17, Jun 21
Rearrange positive and negative numbers in O(n) time and O(1) extra space
13, Apr 13
Segregating negative and positive maintaining order and O(1) space
19, Aug 18
Find the maximum element in an array which is first increasing and then decreasing
14, Jan 12
Flip minimum signs of array elements to get minimum sum of positive elements possible
27, Jun 19
Move all negative numbers to beginning and positive to end with constant extra space
06, Sep 17
Rearrange positive and negative numbers using inbuilt sort function
25, Oct 17
Lambda expression in Python to rearrange positive and negative numbers
27, Oct 17
Longest alternating (positive and negative) subarray starting at every index
09, Dec 17
Make three non-empty sets with negative, positive and 0 products
14, Nov 17
Partition negative and positive without comparison with 0
05, Jun 18
Longest alternating subsequence in terms of positive and negative integers
18, Mar 20
Find ratio of zeroes, positive numbers and negative numbers in the Array
19, Apr 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
pawan_asipu
@pawan_asipu
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox