最少数量的变化，使得元素首先是负的，然后是正的

给定一个大小为N的数组arr[] 。任务是找到转换数组所需的最小更改次数，使得对于任何索引0 ≤ k < N ，数组中直到第 k 个索引的元素将小于零，并且在第 k 个索引之后将更大比零。
那是：

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

例子：

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. 
 

方法：首先，对于每个有效的k ，找到它左边的非负整数的数量和右边的非正整数的数量。现在，为每个有效的k (0 ≤ k k是我们需要的答案。
下面是上述方法的实现：

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[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

= 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

 
// 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));
           

输出：

1

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。