Program to find sum of the given sequence

Given two numbers and . The task is to find the sum of the sequence given below.

(1*2*3*…*k) + (2*3*…*k*(k+1)) + (3*4*..*(k+1)*(k+2)) +…..+((n-k+1)*(n-k+2)*…*(n-k+k)).

Since the output can be large, print the answer under modulo 10^9+7.
Examples: 

Input : N = 3, K = 2
Output : 8

Input : N = 4, K = 2
Output : 20

Let us take the given example and try to reduce it to a general formula.
In the given example for n = 3 and k=2, 

Sum = 1*2 + 2*3 

We know that: 

So each term is of the form: 

If we multiply and divide by , it becomes 

Which is nothing but, 

Therefore, 

But since n is so large we can not calculate it directly, we have to simplify the above expression.
On Simplifying we get, 

Algorithm:

• Create a static long variable named MOD and initialize it to 1000000007.
• Create a static function modInv of long return type which takes a long value as input and returns modulo inverse of x under MOD
  •  Create a new long variable n and set it to MOD -2
  • Initialize another long variable result to 1
  •  start a while loop with condition n is greater than 0.
    • If the least significant bit of n is 1, then multiply the result with x modulo MOD and store it in the result.
    • Modulus x is squared and stored in x.
    •  Now shift n right by 1.
  •  return the final value.
• create a static function getSum with a long return type which takes two long values as input n and k
  • create a long variable ans and initialize it to 1
  • start a for loop from i = n + 1 to i greater than n-k and decrement i after every iteration and for each iteration Add(n + 1 – i) modulo MOD to ans and store the result.
  •  Modulo MOD, multiply ans by modInv(k + 1), and store the result in and.
  •  return ans
    

Below is the implementation of the above idea: 

C++

// CPP program to find the sum of the
// given sequence

#include <bits/stdc++.h>
using namespace std;

const long long MOD = 1000000007;

// function to find modulo inverse
// under 10^9+7
long long modInv(long long x)
{
    long long n = MOD - 2;
    long long result = 1;
    while (n) {
        if (n & 1)
            result = result * x % MOD;
        x = x * x % MOD;
        n = n / 2;
    }

    return result;
}

// Function to find the sum of the
// given sequence
long long getSum(long long n, long long k)
{
    long long ans = 1;

    for (long long i = n + 1; i > n - k; i--)
        ans = ans * i % MOD;
    ans = ans * modInv(k + 1) % MOD;

    return ans;
}

// Driver code
int main()
{
    long long n = 3, k = 2;

    cout<<getSum(n,k);

    return 0;
}

Java

// Java program to find the sum of the
// given sequence

class GFG {

    static long MOD = 1000000007;

// function to find modulo inverse
// under 10^9+7
    static long modInv(long x) {
        long n = MOD - 2;
        long result = 1;
        while (n > 0) {
            if ((n & 1) > 0) {
                result = result * x % MOD;
            }
            x = x * x % MOD;
            n = n / 2;
        }

        return result;
    }

// Function to find the sum of the
// given sequence
    static long getSum(long n, long k) {
        long ans = 1;

        for (long i = n + 1; i > n - k; i--) {
            ans = ans * i % MOD;
        }
        ans = ans * modInv(k + 1) % MOD;

        return ans;
    }

// Driver code
    public static void main(String[] args) {
        long n = 3, k = 2;
        System.out.println(getSum(n, k));
    }
}

Python3

# Python3 program to find the sum
# of the given sequence

MOD = 1000000007;

# function to find modulo inverse
# under 10^9+7
def modInv(x):

    n = MOD - 2;
    result = 1;
    while (n):
        if (n&1):
            result = result * x % MOD;
        x = x * x % MOD;
        n = int(n / 2);

    return result;

# Function to find the sum of
# the given sequence
def getSum(n, k):

    ans = 1;

    for i in range(n + 1, n - k, -1):
        ans = ans * i % MOD;
    ans = ans * modInv(k + 1) % MOD;

    return ans;

# Driver code
n = 3;
k = 2;

print(getSum(n,k));

# This code is contributed by mits

C#

// C# program to find the sum of the
// given sequence
using System;



// function to find modulo inverse
// under 10^9+7
class gfg
{
    public long MOD = 1000000007;
 public long modInv(long x)
 {
    long n = MOD - 2;
    long result = 1;
    while (n >0) {
        if ((n & 1) > 0)
            result = result * x % MOD;
        x = x * x % MOD;
        n = n / 2;
    }

    return result;
}

// Function to find the sum of the
// given sequence
  public long getSum(long n, long k)
  {
    long ans = 1;

    for (long i = n + 1; i > n - k; i--)
        ans = ans * i % MOD;
    ans = ans * modInv(k + 1) % MOD;

    return ans;
 }
}

// Driver code
class geek
{
  public static int Main()
 {
     gfg g = new gfg();
    long n = 3, k = 2;

    Console.WriteLine(g.getSum(n,k));

    return 0;
 }
}
//This code is contributed by SoumikMondal

PHP

<?php
// PHP program to find the sum of
// the given sequence

// function to find modulo inverse
// under 10^9+7
function modInv($x)
{
    $MOD = 1000000007;
    $n = $MOD - 2;
    $result = 1;
    while ($n)
    {
        if ($n & 1)
            $result = $result * $x % $MOD;
        $x = $x * $x % $MOD;
        $n = $n / 2;
    }

    return $result;
}

// Function to find the sum of the
// given sequence
function getSum($n, $k)
{
    $MOD = 1000000007;
    $ans = 1;

    for ($i = $n + 1; $i > $n - $k; $i--)
        $ans = $ans * $i % $MOD;
    $ans = $ans * modInv($k + 1) % $MOD;

    return $ans;
}

// Driver code
$n = 3; $k = 2;

echo getSum($n, $k);

// This code is contributed
// by Akanksha Rai
?>

Javascript

<script>

// Javascript program to find the sum of the
// given sequence

var MOD = 100000007;

// function to find modulo inverse
// under 10^9+7
function modInv(x)
{
    var n = MOD - 2;
    var result = 1;
    while (n) {
        if (n & 1)
            result = result * x % MOD;
        x = x * x % MOD;
        n = n / 2;
    }

    return result;
}

// Function to find the sum of the
// given sequence
function getSum(n, k)
{
    var ans = 1;

    for (var i = n + 1; i > n - k; i--)
        ans = ans * i % MOD;
    ans = ans * modInv(k + 1) % MOD;

    return ans;
}

// Driver code
var n = 3, k = 2;

document.write( getSum(n,k));

// This code is contributed by noob2000.
</script>

Output

8

Time Complexity: O(k+log(m)) where k is the given number and m is the value of the modulo.
Auxiliary Space: O(1), since no extra space has been taken.