Números mínimos que se agregarán de modo que la media de Array sea igual a 1

Dada una array arr[ ] de tamaño N , la tarea es encontrar el número mínimo de operaciones requeridas para que la media de Array arr[ ] sea igual a 1. En una operación, se puede agregar un número no negativo al final de la array.

Ejemplos:

Entrada: N = 3, arr = {1, 1, 1}
Salida: 0
Explicación:
Como puede verse, la media de arr[ ], (1+1+1)/3 = 1, 
por lo tanto, se requieren 0 operaciones para realizar buena array.

Entrada: N = 4, arr = {8, 4, 6, 2}
Salida: 16
Explicación:
Como la suma de la array dada es 20 y el número de elementos es 4. 
Por lo tanto, necesitamos agregar 16 cero en el último de la array , para que su media sea igual a 1.

Enfoque: el problema anterior se puede resolver con la ayuda de la suma de la array y el recuento de elementos en la array, es decir, N, según los casos a continuación: 
 

• Si la suma de la array es menor que N, la diferencia entre ellos se puede agregar en la array y, por lo tanto, se requiere 1 operación.
• Si la suma de la array es igual a N, entonces la media será igual a 1 y, por lo tanto, se requieren 0 operaciones.
• Si la suma de la array es mayor que N, entonces se puede agregar 0 en la array (arraySum – N) veces. Por lo tanto, se requieren operaciones (arraySum – N).

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

• Encuentre la suma de la array arr[ ], digamos sum_arr.
• Si sum_arr >= N , imprime sum_arr – N .
• De lo contrario imprima 1 .

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

// C++ program for above approach
#include<bits/stdc++.h>
using namespace std;
 
// Function to calculate minimum
// Number of operations
void minumumOperation(int N, int arr[]){
 
// Storing sum of array arr[]
    int sum_arr =  0;
    sum_arr = accumulate(arr, arr+N, sum_arr);
 
    if(sum_arr >= N)
      cout<<sum_arr-N<<endl;
 
    else
        cout<<1<<endl;
}
 
// Driver Code
int main(){
   int N = 4;
   int arr[] = {8, 4, 6, 2};
 
// Function Call
   minumumOperation(N, arr);
}
 
// This code is contributed by ipg2016107.

// Java program for the above approach
import java.io.*;
class GFG
{
 
// Function to calculate minimum
// Number of operations
static void minumumOperation(int N, int arr[])
{
  
// Storing sum of array arr[]
    int sum_arr =  0;
    for(int i = 0; i < N; i++)
    {
        sum_arr += arr[i];
    }
  
    if(sum_arr >= N)
      System.out.println(sum_arr - N);
  
    else
        System.out.println("1");
}
// Driver Code
public static void main(String[] args)
{
     int N = 4;
   int arr[] = {8, 4, 6, 2};
  
// Function Call
   minumumOperation(N, arr);
}
}
 
// This code is contributed by dwivediyash

# Python program for above approach
 
# Function to calculate minimum
# Number of operations
def minumumOperation(N, arr):
 
    # Storing sum of array arr[]
    sum_arr = sum(arr)
 
    if sum_arr >= N:
        print(sum_arr-N)
 
    else:
        print(1)
 
 
# Driver Code
N = 4
arr = [8, 4, 6, 2]
 
# Function Call
minumumOperation(N, arr)

// C# program for above approach
using System;
class GFG
{
 
  // Function to calculate minimum
  // Number of operations
  static void minumumOperation(int N, int []arr){
 
    // Storing sum of array arr[]
    int sum_arr =  0;
    for (int i = 0; i < N; i++) {
      sum_arr = sum_arr + arr[i];
    }
 
    if(sum_arr >= N)
      Console.Write(sum_arr-N);
 
    else
      Console.Write(1);
  }
 
  // Driver Code
  static public void Main (){
    int N = 4;
    int []arr = {8, 4, 6, 2};
 
    // Function Call
    minumumOperation(N, arr);
  }
}
 
// This code is contributed by shivanisinghss2110

<script>
        // JavaScript Program to implement
        // the above approach
 
        // Function to calculate minimum
        // Number of operations
        function minumumOperation(N, arr) {
 
            // Storing sum of array arr[]
            let sum_arr = 0;
            for (let i = 0; i < N; i++) {
                sum_arr = sum_arr + arr[i];
            }
 
            if (sum_arr >= N)
                document.write(sum_arr - N + "<br>");
 
            else
                document.write(1 + "<br>");
        }
 
        // Driver Code
 
        let N = 4;
        let arr = [8, 4, 6, 2];
 
        // Function Call
        minumumOperation(N, arr);
 
// This code is contributed by Potta Lokesh
    </script>

16

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