 GFG App
Open App Browser
Continue

# 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  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<

## 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

  $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

 

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.

My Personal Notes arrow_drop_up