Minimice los incrementos o decrementos necesarios para que la suma y el producto de los elementos de la array no sean cero

Dada una array arr[] de N enteros, la tarea es contar el número mínimo de operaciones de incremento o decremento requeridas en la array de modo que la suma y el producto de todos los elementos de la array arr[] no sean cero.

Ejemplos:

Entrada: arr[] = {-1, -1, 0, 0}
Salida: 2
Explicación: Realice las siguientes operaciones para actualizar la array como:
Operación 1: Incrementar arr[2] modifica la array a {-1, -1, 1, 0}.
Operación 2: Decrementar arr[3] modifica la array a {-1, -1, 1, -1}.
Por lo tanto, la suma y el producto de la array anterior es -2 y -1, que no es cero.

Entrada: arr[] = {-2, 1, 0}
Salida: 1

Enfoque: El problema dado se puede resolver con base en las siguientes observaciones:

• Pasos mínimos necesarios para que el producto de la array sea distinto de cero y para que el producto sea distinto de cero, todos los elementos deben ser distintos de cero.
• Pasos mínimos requeridos para hacer que la suma de la array no sea cero si la suma es negativa, luego disminuya todos los elementos 0 en 1 y si la suma es positiva, incremente todos los elementos cero en 1 y si la suma no es cero, entonces, simplemente incremente o disminuya cualquier elemento de la array.

Siga los pasos a continuación para resolver este problema:

1. Recorre la array dada y cuenta el número de ceros en la array.
2. Encuentre la suma de la array dada .
3. Si el recuento de ceros es mayor que 0 , el resultado es ese recuento.
4. De lo contrario, si la suma es igual a 0, entonces el resultado es 1 .
5. De lo contrario, el resultado será 0 .

A continuación se muestra la implementación del enfoque anterior:

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the sum of array
int array_sum(int arr[], int n)
{
    int sum = 0;
    for (int i = 0; i < n; i++)
        sum += arr[i];
 
    // Return the sum
    return sum;
}
 
// Function that counts the minimum
// operations required to make the
// sum and product of array non-zero
int countOperations(int arr[], int N)
{
    // Stores count of zero elements
    int count_zeros = 0;
 
    // Iterate over the array to
    // count zero elements
    for (int i = 0; i < N; i++) {
        if (arr[i] == 0)
            count_zeros++;
    }
 
    // Sum of elements of the array
    int sum = array_sum(arr, N);
 
    // Print the result
    if (count_zeros)
        return count_zeros;
 
    if (sum == 0)
        return 1;
 
    return 0;
}
 
// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { -1, -1, 0, 0 };
 
    // Size of array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    cout << countOperations(arr, N);
 
    return 0;
}

// Java program for the above approach
import java.util.*;
class GFG{
   
// Function to find the
// sum of array
static int array_sum(int arr[],
                     int n)
{
  int sum = 0;
   
  for (int i = 0; i < n; i++)
    sum += arr[i];
 
  // Return the sum
  return sum;
}
 
// Function that counts the minimum
// operations required to make the
// sum and product of array non-zero
static int countOperations(int arr[],
                           int N)
{
  // Stores count of zero
  // elements
  int count_zeros = 0;
 
  // Iterate over the array to
  // count zero elements
  for (int i = 0; i < N; i++)
  {
    if (arr[i] == 0)
      count_zeros++;
  }
 
  // Sum of elements of the
  // array
  int sum = array_sum(arr, N);
 
  // Print the result
  if (count_zeros != 0)
    return count_zeros;
 
  if (sum == 0)
    return 1;
 
  return 0;
}
 
// Driver Code
public static void main(String[] args)
{
  // Given array arr[]
  int arr[] = {-1, -1, 0, 0};
 
  // Size of array
  int N = arr.length;
 
  // Function Call
  System.out.print(countOperations(arr, N));
}
}
 
// This code is contributed by sanjoy_62

# Python3 program for the
# above approach
 
# Function to find the
# sum of array
def array_sum(arr, n):
   
    sum = 0
     
    for i in range(n):
        sum += arr[i]
         
    # Return the sum
    return sum
 
# Function that counts the minimum
# operations required to make the
# sum and product of array non-zero
def countOperations(arr, N):
   
    # Stores count of zero
    # elements
    count_zeros = 0
 
    # Iterate over the array to
    # count zero elements
    for i in range(N):
        if (arr[i] == 0):
            count_zeros+=1
 
    # Sum of elements of the
    # array
    sum = array_sum(arr, N)
 
    # Print result
    if (count_zeros):
        return count_zeros
 
    if (sum == 0):
        return 1
 
    return 0
 
# Driver Code
if __name__ == '__main__':
   
    # Given array arr[]
    arr = [-1, -1, 0, 0]
 
    # Size of array
    N = len(arr)
 
    # Function Call
    print(countOperations(arr, N))
 
# This code is contributed by Mohit Kumar 29

// C# program for the above approach
using System;
 
class GFG{
 
// Function to find the
// sum of array
static int array_sum(int[] arr,
                     int n)
{
  int sum = 0;
   
  for(int i = 0; i < n; i++)
    sum += arr[i];
 
  // Return the sum
  return sum;
}
 
// Function that counts the minimum
// operations required to make the
// sum and product of array non-zero
static int countOperations(int[] arr,
                           int N)
{
   
  // Stores count of zero
  // elements
  int count_zeros = 0;
 
  // Iterate over the array to
  // count zero elements
  for(int i = 0; i < N; i++)
  {
    if (arr[i] == 0)
      count_zeros++;
  }
 
  // Sum of elements of the
  // array
  int sum = array_sum(arr, N);
 
  // Print the result
  if (count_zeros != 0)
    return count_zeros;
 
  if (sum == 0)
    return 1;
 
  return 0;
}
 
// Driver Code
public static void Main()
{
   
  // Given array arr[]
  int[] arr = { -1, -1, 0, 0 };
 
  // Size of array
  int N = arr.Length;
 
  // Function call
  Console.Write(countOperations(arr, N));
}
}
 
// This code is contributed by code_hunt

<script>
 
// Javascript program for the above approach
 
    // Function to find the
    // sum of array
    function array_sum(arr , n) {
        var sum = 0;
 
        for (i = 0; i < n; i++)
            sum += arr[i];
 
        // Return the sum
        return sum;
    }
 
    // Function that counts the minimum
    // operations required to make the
    // sum and product of array non-zero
    function countOperations(arr , N) {
        // Stores count of zero
        // elements
        var count_zeros = 0;
 
        // Iterate over the array to
        // count zero elements
        for (i = 0; i < N; i++) {
            if (arr[i] == 0)
                count_zeros++;
        }
 
        // Sum of elements of the
        // array
        var sum = array_sum(arr, N);
 
        // Print the result
        if (count_zeros != 0)
            return count_zeros;
 
        if (sum == 0)
            return 1;
 
        return 0;
    }
 
    // Driver Code
     
        // Given array arr
        var arr = [ -1, -1, 0, 0 ];
 
        // Size of array
        var N = arr.length;
 
        // Function Call
        document.write(countOperations(arr, N));
 
// This code contributed by umadevi9616
 
</script>

2

Complejidad temporal: O(N)
Espacio auxiliar: O(1)