Suma de series si se da T(n) y n es muy grande

Dada una sucesión cuyo n ^-ésimo término es 
 

T(n) = norte ² – (n – 1) ²

 
La tarea es evaluar la suma de los primeros n términos, es decir 
 

S(n) = T(1) + T(2) + T(3) + … + T(n)

 
Imprimir S(n) mod (10 ⁹ + 7) .
Ejemplos: 
 

Entrada: n = 3 
Salida: 9 
S(3) = T(1) + T(2) + T(3) = (1 ² – 0 ² ) + (2 ² – 1 ² ) + (3 ² – 2 ² ) = 1 + 3 + 5 = 9
Entrada: n = 10 
Salida: 100 
 

Enfoque: Si tratamos de encontrar algunos términos iniciales de la sucesión poniendo n = 1, 2, 3, … en T(n) = n ² – (n – 1) ² , encontramos la sucesión 1, 3, 5 , … 
Por lo tanto, encontramos un PA donde el primer término es 1 y d (diferencia común entre términos consecutivos 
) es 2 . 
La fórmula para la suma de n términos de AP es 
 

S(n) = n / 2 [ 2 * a + (n – 1) * d ]

 
donde a es el primer término. 
Entonces, poniendo a = 1 y d = 2 , obtenemos 
 

S(n) = norte ²

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

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define MOD 1000000007
 
// Function to return the sum
// of the given series
int sumOfSeries(int n)
{
    ll ans = (ll)pow(n % MOD, 2);
 
    return (ans % MOD);
}
 
// Driver code
int main()
{
    int n = 10;
    cout << sumOfSeries(n);
 
    return 0;
}

// Java implementation of the approach
class GFG
{
     
public static final int MOD = 1000000007;
 
// Function to return the sum
// of the given series
static int sumOfSeries(int n)
{
    int ans = (int)Math.pow(n % MOD, 2);
 
    return (ans % MOD);
}
 
// Driver code
public static void main(String[] args)
{
    int n = 10;
    System.out.println(sumOfSeries(n));
}
}
 
// This code is contributed by Code_Mech.

# Python 3 implementation of the approach
from math import pow
 
MOD = 1000000007
 
# Function to return the sum
# of the given series
def sumOfSeries(n):
    ans = pow(n % MOD, 2)
 
    return (ans % MOD)
 
# Driver code
if __name__ == '__main__':
    n = 10
    print(int(sumOfSeries(n)))
 
# This code is contributed by
# Surendra_Gangwar

// C# implementation of the approach
using System;
 
class GFG
{
     
const int MOD = 1000000007;
 
// Function to return the sum
// of the given series
static int sumOfSeries(int n)
{
    int ans = (int)Math.Pow(n % MOD, 2);
 
    return (ans % MOD);
}
 
// Driver code
public static void Main()
{
    int n = 10;
    Console.Write(sumOfSeries(n));
}
}
 
// This code is contributed
// by Akanksha Rai

<?php
// PHP implementation of the approach
$GLOBALS['MOD'] = 1000000007;
 
// Function to return the sum
// of the given series
function sumOfSeries($n)
{
    $ans = pow($n % $GLOBALS['MOD'], 2);
 
    return ($ans % $GLOBALS['MOD']);
}
 
// Driver code
$n = 10;
echo sumOfSeries($n);
 
// This code is contributed by Ryuga
?>

<script>
 
// javascript program for the above approach
 
let MOD = 1000000007;
 
// Function to return the sum
// of the given series
function sumOfSeries(n)
{
    let ans = Math.pow(n % MOD, 2);
 
    return (ans % MOD);
}
 
// Driver Code
     
        let n = 10;
    document.write(sumOfSeries(n));
 
</script>

100

Complejidad de Tiempo: O(logn)
Espacio Auxiliar: O(1), ya que no se ha tomado espacio extra.