Compruebe si la suma de la array se puede reducir a cero reduciendo repetidamente el elemento de la array por su valor de índice

Dada una array arr[] que consta de N enteros, la tarea es determinar si la suma de los elementos de la array se puede reducir a 0 realizando las siguientes operaciones cualquier número de veces:

• Elija un elemento A[i] y reduzca A[i] por i ( indexación basada en 1 ), cualquier número de veces, posiblemente 0 .
• Si la suma se puede reducir a 0 , imprima » Sí «. De lo contrario, escriba “ No ”.

Ejemplos:

Entrada: arr[] = {2, 3, 1}
Salida: Sí
Explicación:
Seleccione A[2] = 3
Realice la operación dada 3 veces para obtener el siguiente resultado: 
3 -> (3 -2) -> (3 – 2 – 2) -> (3 – 2 – 2 – 2) 
Suma del arreglo modificado = 2 + (-3) + 1 = 0. 
Por lo tanto, la respuesta requerida es 0.

Entrada: arr[] = {-5, 3}
Salida: No

Enfoque: Este problema se puede resolver en base a las siguientes observaciones:

• Si un número positivo se resta repetidamente de otro número positivo , eventualmente se puede obtener 0 . Pero, restando repetidamente un número positivo de un número negativo , nunca se puede obtener 0 ya que sigue disminuyendo negativamente.
• La tarea de reducir la suma a 0 restando i de A[i] .
• Por lo tanto, al elegir un elemento y reducir el valor del elemento en i , la suma se reduce en i . 
   

Deje que la suma de la array sea S .
S = A[1] + A[2] + …. + A[N]
Después de realizar las operaciones dadas, la suma de la array se modifica a 
S2 = (A[i] – (i)) + (A[i+1] – (i+1)) …. 
S2 = A[i] + A[i+1]…. – (i + i+1….) 
S2 = S – (i + i + 1…..) 
Por lo tanto, después de cada operación, la suma original se reduce. 

• Por lo tanto, la tarea se reduce a verificar si la suma inicial de la array es positiva o 0 . Si es cierto, escriba “ Sí ”. De lo contrario, escriba “ No ”.

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

// C++ Program for the above approach
#include <iostream>
using namespace std;
 
// Function to check if an array
// sum can be reduced to zero or not
bool isPossible(int arr[], int n)
{
    // Stores the sum of the array
    int S = 0;
 
    for (int i = 0; i < n; i++) {
 
        // Update sum of the array
        S = S + arr[i];
    }
 
    // If the sum is positive
    if (S >= 0) {
 
        // Array sum can be
        // reduced to 0
        return true;
    }
 
    // Otherwise
    else {
 
        // Array sum cannot
        // be reduced to 0
        return false;
    }
}
 
// Driver Code
int main()
{
    int arr[] = { -5, 3 };
 
    int n = sizeof(arr) / sizeof(int);
 
    // Print the answer
    if (isPossible(arr, n)) {
        cout << "Yes";
    }
    else {
        cout << "No";
    }
}

// Java program for the above approach
 
import java.io.*;
 
class GFG {
 
    // Function to check if array sum
    // can be reduced to zero or not
    static boolean isPossible(int[] arr, int n)
    {
        // Stores the sum of the array
        int S = 0;
 
        for (int i = 0; i < n; i++) {
            S = S + arr[i];
        }
 
        // If array sum is positive
        if (S >= 0)
 
            // Array sum can be
            // reduced to 0
            return true;
 
        // Otherwise
        else
 
            // Array sum cannot
            // be reduced to 0
            return false;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = { -5, 3 };
        int n = arr.length;
 
        // Function call
        if (isPossible(arr, n))
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}

# Python program for the above approach
 
# Function to check if an array
# sum can be reduced to zero or not
def isPossible(arr, n):
 
    # Stores sum of the array
    S = sum(arr)
 
    # If sum is positive
    if(S >= 0):
        return true
 
    # If sum is negative
    else:
        return false
 
 
# Driver Code
if __name__ == '__main__':
 
    arr = [-5, 3]
    n = len(arr)
 
    # Function call
    if (isPossible(arr, n)):
        print("Yes")
    else:
        print("No")

// C# program for
// the above approach
using System;
class GFG{
   
// Function to check if array sum
// can be reduced to zero or not
static bool isPossible(int[] arr,
                       int n)
{
  // Stores the sum
  // of the array
  int S = 0;
 
  for (int i = 0; i < n; i++)
  {
    S = S + arr[i];
  }
 
  // If array sum is positive
  if (S >= 0)
 
    // Array sum can be
    // reduced to 0
    return true;
 
  // Otherwise
  else
 
    // Array sum cannot
    // be reduced to 0
    return false;
}
 
// Driver Code
public static void Main()
{
  int[] arr = {-5, 3};
  int n = arr.Length;
 
  // Function call
  if (isPossible(arr, n))
    Console.Write("Yes");
  else
    Console.Write("No");
}
}
 
// This code is contributed by Chitranayal

<script>
// javascript program for the above approach   
// Function to check if array sum
    // can be reduced to zero or not
    function isPossible(arr , n)
    {
     
        // Stores the sum of the array
        var S = 0;
 
        for (i = 0; i < n; i++) {
            S = S + arr[i];
        }
 
        // If array sum is positive
        if (S >= 0)
 
            // Array sum can be
            // reduced to 0
            return true;
 
        // Otherwise
        else
 
            // Array sum cannot
            // be reduced to 0
            return false;
    }
 
    // Driver Code
     
        var arr = [ -5, 3 ];
        var n = arr.length;
 
        // Function call
        if (isPossible(arr, n))
            document.write("Yes");
        else
            document.write("No");
 
// This code is contributed by todaysgaurav
</script>

No

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