Related Articles
Sum of all natural numbers from L to R ( for large values of L and R )
• Last Updated : 19 Sep, 2019

Given two very large numbers L and R where L ≤ R, the task is to compute the sum of all the natural numbers from L to R. The sum could be large so print the sum % 1000000007.

Examples:

Input: L = “8894” R = “98592”
Output: 820693329

Input: L = “88949273204” R = “98429729474298592”
Output: 252666158

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

• Let sum(N) is a function that returns the sum of first N natural numbers.
• The sum of the first N natural numbers is sum(N) = (N * (N + 1)) / 2.
• The sum of the numbers in the range between L to R will be RangeSum = sum(R) – sum(L – 1)
• The answer is calculated with the modulo 109 + 7, So,

mod = 109 + 7

RangeSum = (sum(R) – sum(L-1) + mod)%mod;

This can be also written as RangeSum = (sum(R)%mod – sum(L-1)%mod + mod)%mod;

Now, sum(R) % mod can be written as ((R * (R + 1)) / 2) % mod

Or ((R % mod) * ((R + 1) % mod) * invmod(2)) % mod

Since R is large, the modulo of R can be calculated as described here.

The value of inversemod(2) = 500000004 which can be calculated using Fermat’s little theorem.

Similarly, sum(L – 1) % mod can also be calculated.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;`` ` `#define mod 1000000007`` ` `// Value of inverse modulo``// 2 with 10^9 + 7``const` `long` `long` `inv2 = 500000004;`` ` `// Function to return num % 1000000007``// where num is a large number``long` `long` `int` `modulo(string num)``{``    ``// Initialize result``    ``long` `long` `int` `res = 0;`` ` `    ``// One by one process all the``    ``// digits of string 'num'``    ``for` `(``long` `long` `int` `i = 0;``         ``i < num.length();``         ``i++)``        ``res = (res * 10``               ``+ (``long` `long` `int``)num[i]``               ``- ``'0'``)``              ``% mod;``    ``return` `res;``}`` ` `// Function to return the sum of the``// integers from the given range``// modulo 1000000007``long` `long` `int` `findSum(string L,``                      ``string R)``{``    ``long` `long` `int` `a, b, l, r, ret;`` ` `    ``// a stores the value of``    ``// L modulo 10^9 + 7``    ``a = modulo(L);`` ` `    ``// b stores the value of``    ``// R modulo 10^9 + 7``    ``b = modulo(R);`` ` `    ``// l stores the sum of natural``    ``// numbers from 1 to (a - 1)``    ``l = ((a * (a - 1))``         ``% mod * inv2)``        ``% mod;`` ` `    ``// r stores the sum of natural``    ``// numbers from 1 to b``    ``r = ((b * (b + 1))``         ``% mod * inv2)``        ``% mod;`` ` `    ``ret = (r % mod - l % mod);`` ` `    ``// If the result is negative``    ``if` `(ret < 0)``        ``ret = ret + mod;``    ``else``        ``ret = ret % mod;``    ``return` `ret;``}`` ` `// Driver code``int` `main()``{``    ``string L = ``"88949273204"``;``    ``string R = ``"98429729474298592"``;`` ` `    ``cout << findSum(L, R) << endl;`` ` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;`` ` `class` `GFG``{``static` `long` `mod = ``1000000007``;`` ` `// Value of inverse modulo``// 2 with 10^9 + 7``static` `long` `inv2 = ``500000004``;`` ` `// Function to return num % 1000000007``// where num is a large number``static` `long` `modulo(String num)``{``    ``// Initialize result``    ``long` `res = ``0``;`` ` `    ``// One by one process all the``    ``// digits of string 'num'``    ``for` `(``int` `i = ``0``;``             ``i < num.length(); i++)``        ``res = (res * ``10` `+ ``              ``(``long``)num.charAt(i) - ``'0'``) % mod;``    ``return` `res;``}`` ` `// Function to return the sum of the``// longegers from the given range``// modulo 1000000007``static` `long` `findSum(String L, String R)``{``    ``long` `a, b, l, r, ret;`` ` `    ``// a stores the value of``    ``// L modulo 10^9 + 7``    ``a = modulo(L);`` ` `    ``// b stores the value of``    ``// R modulo 10^9 + 7``    ``b = modulo(R);`` ` `    ``// l stores the sum of natural``    ``// numbers from 1 to (a - 1)``    ``l = ((a * (a - ``1``)) % mod * inv2) % mod;`` ` `    ``// r stores the sum of natural``    ``// numbers from 1 to b``    ``r = ((b * (b + ``1``)) % mod * inv2) % mod;`` ` `    ``ret = (r % mod - l % mod);`` ` `    ``// If the result is negative``    ``if` `(ret < ``0``)``        ``ret = ret + mod;``    ``else``        ``ret = ret % mod;``    ``return` `ret;``}`` ` `// Driver code``public` `static` `void` `main(String[] args) ``{``    ``String L = ``"88949273204"``;``    ``String R = ``"98429729474298592"``;`` ` `    ``System.out.println(findSum(L, R));``}``} `` ` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 implementation of the approach ``mod ``=` `1000000007`` ` `# Value of inverse modulo ``# 2 with 10^9 + 7 ``inv2 ``=` `500000004``; `` ` `# Function to return num % 1000000007 ``# where num is a large number ``def` `modulo(num) : `` ` `    ``# Initialize result ``    ``res ``=` `0``; `` ` `    ``# One by one process all the ``    ``# digits of string 'num' ``    ``for` `i ``in` `range``(``len``(num)) :``        ``res ``=` `(res ``*` `10` `+` `int``(num[i]) ``-` `0``) ``%` `mod; ``         ` `    ``return` `res; `` ` `# Function to return the sum of the ``# integers from the given range ``# modulo 1000000007 ``def` `findSum(L, R) : ``     ` `    ``# a stores the value of ``    ``# L modulo 10^9 + 7 ``    ``a ``=` `modulo(L); `` ` `    ``# b stores the value of ``    ``# R modulo 10^9 + 7 ``    ``b ``=` `modulo(R); `` ` `    ``# l stores the sum of natural ``    ``# numbers from 1 to (a - 1) ``    ``l ``=` `((a ``*` `(a ``-` `1``)) ``%` `mod ``*` `inv2) ``%` `mod; `` ` `    ``# r stores the sum of natural ``    ``# numbers from 1 to b ``    ``r ``=` `((b ``*` `(b ``+` `1``)) ``%` `mod ``*` `inv2) ``%` `mod; `` ` `    ``ret ``=` `(r ``%` `mod ``-` `l ``%` `mod); `` ` `    ``# If the result is negative ``    ``if` `(ret < ``0``) :``        ``ret ``=` `ret ``+` `mod; ``    ``else` `:``        ``ret ``=` `ret ``%` `mod; ``         ` `    ``return` `ret; `` ` `# Driver code ``if` `__name__ ``=``=` `"__main__"` `: `` ` `    ``L ``=` `"88949273204"``; ``    ``R ``=` `"98429729474298592"``; `` ` `    ``print``(findSum(L, R)) ; ``     ` `# This code is contributed by AnkitRai01`

## C#

 `// C# implementation of the approach``using` `System;``     ` `class` `GFG``{``static` `long` `mod = 1000000007;`` ` `// Value of inverse modulo``// 2 with 10^9 + 7``static` `long` `inv2 = 500000004;`` ` `// Function to return num % 1000000007``// where num is a large number``static` `long` `modulo(String num)``{``    ``// Initialize result``    ``long` `res = 0;`` ` `    ``// One by one process all the``    ``// digits of string 'num'``    ``for` `(``int` `i = 0;``             ``i < num.Length; i++)``        ``res = (res * 10 + ``              ``(``long``)num[i] - ``'0'``) % mod;``    ``return` `res;``}`` ` `// Function to return the sum of the``// longegers from the given range``// modulo 1000000007``static` `long` `findSum(String L, String R)``{``    ``long` `a, b, l, r, ret;`` ` `    ``// a stores the value of``    ``// L modulo 10^9 + 7``    ``a = modulo(L);`` ` `    ``// b stores the value of``    ``// R modulo 10^9 + 7``    ``b = modulo(R);`` ` `    ``// l stores the sum of natural``    ``// numbers from 1 to (a - 1)``    ``l = ((a * (a - 1)) % mod * inv2) % mod;`` ` `    ``// r stores the sum of natural``    ``// numbers from 1 to b``    ``r = ((b * (b + 1)) % mod * inv2) % mod;`` ` `    ``ret = (r % mod - l % mod);`` ` `    ``// If the result is negative``    ``if` `(ret < 0)``        ``ret = ret + mod;``    ``else``        ``ret = ret % mod;``    ``return` `ret;``}`` ` `// Driver code``public` `static` `void` `Main(String[] args) ``{``    ``String L = ``"88949273204"``;``    ``String R = ``"98429729474298592"``;`` ` `    ``Console.WriteLine(findSum(L, R));``}``}`` ` `// This code is contributed by PrinciRaj1992`
Output:
```252666158
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up