Suma de elementos de array que primero aumenta continuamente y luego disminuye

Dada una array donde los elementos primero aumentan continuamente y luego se alcanza nuevamente su primer número de unidad que disminuye continuamente. Queremos agregar los elementos de array. Podemos suponer que no hay desbordamiento en suma.

Ejemplos: 

Input  : arr[] = {5, 6, 7, 6, 5}.
Output : 29 

Input  : arr[] = {10, 11, 12, 13, 12, 11, 10}
Output : 79

Una solución simple es atravesar n y agregar los elementos de la array. 

Implementación:

// Simple C++ method to find sum of the
// elements of array.
#include <iostream>
using namespace std;
int arraySum(int arr[], int n)
{
    int sum = 0;
    for (int i = 0; i < n; i++)
        sum = sum + arr[i];
    return sum;
}
 
// Driver code
int main()
{
    int arr[] = {10, 11, 12, 13, 12, 11, 10};
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << arraySum(arr, n);
    return 0;
}

// JAVA Code for Sum of array elements
// that is first continuously increasing
// then decreasing
class GFG {
     
    public static int arraySum(int arr[], int n)
    {
        int sum = 0;
        for (int i = 0; i < n; i++)
            sum = sum + arr[i];
        return sum;
    }
     
    /* Driver program to test above function */
    public static void main(String[] args)
    {
        int arr[] = {10, 11, 12, 13, 12, 11, 10};
        int n = arr.length;
        System.out.print(arraySum(arr, n));
             
    }
}
// This code is contributed by Arnav Kr. Mandal.

# Simple python method to find sum of the
# elements of array.
def arraySum( arr, n):
    _sum = 0
    for i in range(n):
        _sum = _sum + arr[i]
    return _sum
 
# Driver code
arr = [10, 11, 12, 13, 12, 11, 10]
n = len(arr)
print(arraySum(arr, n))
 
# This code is contributed by "Abhishek Sharma 44"

// C# Code for Sum of array elements
// that is first continuously increasing
// then decreasing
using System;
 
class GFG {
     
    public static int arraySum(int []arr, int n)
    {
        int sum = 0;
        for (int i = 0; i < n; i++)
            sum = sum + arr[i];
        return sum;
    }
     
    // Driver program
    public static void Main()
    {
        int []arr = {10, 11, 12, 13, 12, 11, 10};
        int n = arr.Length;
        Console.WriteLine(arraySum(arr, n));
             
    }
}
// This code is contributed by vt_m.

<?php
// Simple PHP method
// to find sum of the
// elements of array.
function arraySum($arr, $n)
{
    $sum = 0;
    for ($i = 0; $i < $n; $i++)
        $sum = $sum + $arr[$i];
    return $sum;
}
 
// Driver code
$arr = array(10, 11, 12, 13,
             12, 11, 10);
$n = sizeof($arr);
echo(arraySum($arr, $n));
 
// This code is contributed by Ajit.
?>

<script>
    // Simple Javascript method
// to find sum of the
// elements of array.
function arraySum(arr, n)
{
    let sum = 0;
    for (let i = 0; i < n; i++)
        sum = sum + arr[i];
    return sum;
}
   
// Driver code
let arr = [10, 11, 12, 13,
             12, 11, 10];
let n = arr.length;
document.write(arraySum(arr, n));
   
// This code is contributed by _saurabh_jaiswal.
</script>

79

Una solución eficiente es aplicar la siguiente fórmula. 

sum = (arr[0] - 1)*n + ⌈n/2⌉2

How does it work? 
If we take a closer look, we can notice that the
sum can be written as.

(arr[0] - 1)*n + (1 + 2 + .. x + (x -1) + (x-2) + ..1)
Let us understand above result with example {10, 11,
12, 13, 12, 11, 10}.  If we subtract 9 (arr[0]-1) from
this array, we get {1, 2, 3, 2, 1}.

Where x = ceil(n/2)  [Half of array size]

As we know that 1 + 2 + 3 + . . . + x = x * (x + 1)/2.
And we have given
    = 1 + 2 + 3 + . . . + x + (x - 1) + . . . + 3 + 2 + 1
    = (1 + 2 + 3 + . . . + x) + ((x - 1) + . . . + 3 + 2 + 1)
    = (x * (x + 1))/2 + ((x - 1) * x)/2
    = (x2 + x)/2 + (n2 - x)/2
    = (2 * x2)/2
    = x2

Implementación:

// Efficient C++ method to find sum of the
// elements of array that is halfway increasing
// and then halfway decreasing
#include <iostream>
using namespace std;
 
int arraySum(int arr[], int n)
{
    int x = (n+1)/2;
    return (arr[0] - 1)*n + x*x;
}
 
// Driver code
int main()
{
    int arr[] = {10, 11, 12, 13, 12, 11, 10};
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << arraySum(arr, n);
    return 0;
}

// JAVA Code for Sum of array elements
// that is first continuously increasing
// then decreasing
class GFG {
     
    public static int arraySum(int arr[], int n)
    {
        int x = (n + 1) / 2;
        return (arr[0] - 1) * n + x * x;
    }
     
    /* Driver program to test above function */
    public static void main(String[] args)
    {
        int arr[] = {10, 11, 12, 13, 12, 11, 10};
        int n = arr.length;
        System.out.print(arraySum(arr, n));  
    }
}
// This code is contributed by Arnav Kr. Mandal.

# Efficient python method to find sum of the
# elements of array that is halfway increasing
# and then halfway decreasing
def arraySum( arr, n):
    x = (n + 1)/2
    return (arr[0] - 1)*n + x * x
     
# Driver code
arr = [10, 11, 12, 13, 12, 11, 10]
n = len(arr)
print(arraySum(arr, n))
 
# This code is contributed by "Abhishek Sharma 44"

// C# Code for Sum of array elements
// that is first continuously increasing
// then decreasing
using System;
 
class GFG {
     
    public static int arraySum(int []arr, int n)
    {
        int x = (n + 1) / 2;
        return (arr[0] - 1) * n + x * x;
    }
     
    /* Driver program to test above function */
    public static void Main()
    {
        int []arr = {10, 11, 12, 13, 12, 11, 10};
        int n = arr.Length;
        Console.WriteLine(arraySum(arr, n));
    }
}
 
// This code is contributed by vt_m.

<?php
// Efficient PHP method to
// find sum of the elements
// of array that is halfway
// increasing and then halfway
// decreasing
 
function arraySum($arr, $n)
{
    $x = ($n + 1) / 2;
    return ($arr[0] - 1) *
            $n + $x * $x;
}
 
// Driver code
$arr = array(10, 11, 12, 13,
                12, 11, 10);
$n = sizeof($arr);
echo(arraySum($arr, $n));
 
// This code is contributed by Ajit.
?>

// Efficient Javascript method to
// find sum of the elements
// of array that is halfway
// increasing and then halfway
// decreasing
   
function arraySum(arr, n)
{
    let x = (n + 1) / 2;
    return (arr[0] - 1) *
            n + x * x;
}
   
// Driver code
let arr = [10, 11, 12, 13,
                12, 11, 10];
let n = arr.length;
document.write(arraySum(arr, n));
   
// This code is contributed by _saurabh_jaiswal.

79

Tiempo Complejidad: O(1)
Espacio Auxiliar: O(1)

Este artículo es una contribución de Dharmendra kumar . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.