# Count of distinct sums formed by N numbers taken form range [L, R]

Given three integers **N**, **L**, and **R**. The task is to count distinct sums formed by using **N** numbers from the range **[L, R]**, where any number can be taken infinite times.

**Examples:**

Input:N = 2, L = 1, R = 3Output:5Explanation:Generating all distinct combinations of 2 numbers taken from the range [1, 3]

{1, 1} => sum = 2

{1, 2} => sum = 3

{1, 3} => sum = 4

{2, 2} => sum = 4

{2, 3} => sum = 5

{3, 3} => sum = 6

Therefore, there are 5 (2, 3, 4, 5, 6) different sums possible with 2 numbers taken from range [1, 3].

Input:N = 3, L = 1, R = 9Output:10

**NaÃ¯ve Approach:** The simplest approach to solve the given problem is to generate all possible combinations of **N** numbers from the range **[L, R]** and** **then count the total distinct sums formed by those combinations.

**Time Complexity:** O((R – L)^{N})**Auxiliary Space:** O(1)

**Efficient Approach:** The** **given problem can be solved by some observation and by the use of some math. Here minimum and maximum numbers that can be used are **L** and **R** respectively. So, the minimum and maximum possible sum that can be formed are **L*N** (all N numbers are L) and **R*N** (all N numbers are R) respectively, Similarly, all other sums in between this range can also be formed. Follow the steps below to solve the given problem.

- Initialize a variable say,
**minSum = L*N**, to store the minimum possible sum. - Initialize a variable say,
**maxSum = R*N**, to store the maximum possible sum. - The final answer is the total numbers in the range
**[minSum, maxSum]**i.e.,**(maxSum – minSum + 1)**.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find total number of` `// different sums of N numbers in` `// the range [L, R]` `int` `countDistinctSums(` `int` `N, ` `int` `L, ` `int` `R)` `{` ` ` `// To store minimum possible sum with` ` ` `// N numbers with all as L` ` ` `int` `minSum = L * N;` ` ` `// To store maximum possible sum with` ` ` `// N numbers with all as R` ` ` `int` `maxSum = R * N;` ` ` `// All other numbers in between maxSum` ` ` `// and minSum can also be formed so numbers` ` ` `// in this range is the final answer` ` ` `return` `maxSum - minSum + 1;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `N = 2, L = 1, R = 3;` ` ` `cout << countDistinctSums(N, L, R);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.util.*;` `class` `GFG{` `// Function to find total number of` `// different sums of N numbers in` `// the range [L, R]` `static` `int` `countDistinctSums(` `int` `N, ` `int` `L, ` `int` `R)` `{` ` ` `// To store minimum possible sum with` ` ` `// N numbers with all as L` ` ` `int` `minSum = L * N;` ` ` `// To store maximum possible sum with` ` ` `// N numbers with all as R` ` ` `int` `maxSum = R * N;` ` ` `// All other numbers in between maxSum` ` ` `// and minSum can also be formed so numbers` ` ` `// in this range is the final answer` ` ` `return` `maxSum - minSum + ` `1` `;` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `N = ` `2` `, L = ` `1` `, R = ` `3` `;` ` ` `System.out.print(countDistinctSums(N, L, R));` `}` `}` `// This code is contributed by 29AjayKumar` |

## Python3

`# Python program for the above approach` `# Function to find total number of` `# different sums of N numbers in` `# the range [L, R]` `def` `countDistinctSums(N, L, R):` ` ` `# To store minimum possible sum with` ` ` `# N numbers with all as L` ` ` `minSum ` `=` `L ` `*` `N` ` ` `# To store maximum possible sum with` ` ` `# N numbers with all as R` ` ` `maxSum ` `=` `R ` `*` `N` ` ` `# All other numbers in between maxSum` ` ` `# and minSum can also be formed so numbers` ` ` `# in this range is the final answer` ` ` `return` `maxSum ` `-` `minSum ` `+` `1` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `N ` `=` `2` ` ` `L ` `=` `1` ` ` `R ` `=` `3` ` ` `print` `(countDistinctSums(N, L, R))` ` ` `# This code is contributed by rakeshsahni` |

## C#

`// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{` `// Function to find total number of` `// different sums of N numbers in` `// the range [L, R]` `static` `int` `countDistinctSums(` `int` `N, ` `int` `L, ` `int` `R)` `{` ` ` `// To store minimum possible sum with` ` ` `// N numbers with all as L` ` ` `int` `minSum = L * N;` ` ` `// To store maximum possible sum with` ` ` `// N numbers with all as R` ` ` `int` `maxSum = R * N;` ` ` `// All other numbers in between maxSum` ` ` `// and minSum can also be formed so numbers` ` ` `// in this range is the final answer` ` ` `return` `maxSum - minSum + 1;` `}` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` `int` `N = 2, L = 1, R = 3;` ` ` `Console.Write(countDistinctSums(N, L, R));` `}` `}` `// This code is contributed by SURENDRA_GANGWAR.` |

## Javascript

`<script>` ` ` `// JavaScript Program to implement` ` ` `// the above approach` ` ` `// Function to find total number of` ` ` `// different sums of N numbers in` ` ` `// the range [L, R]` ` ` `function` `countDistinctSums(N, L, R) {` ` ` `// To store minimum possible sum with` ` ` `// N numbers with all as L` ` ` `let minSum = L * N;` ` ` `// To store maximum possible sum with` ` ` `// N numbers with all as R` ` ` `let maxSum = R * N;` ` ` `// All other numbers in between maxSum` ` ` `// and minSum can also be formed so numbers` ` ` `// in this range is the final answer` ` ` `return` `maxSum - minSum + 1;` ` ` `}` ` ` `// Driver Code` ` ` `let N = 2, L = 1, R = 3;` ` ` `document.write(countDistinctSums(N, L, R));` `// This code is contributed by Potta Lokesh` ` ` `</script>` |

**Output:**

5

**Time Complexity:** O(1)**Auxiliary Space:** O(1)