 GeeksforGeeks App
Open App Browser
Continue

# Ways to sum to N using Natural Numbers up to K with repetitions allowed

Given two integers N and K, the task is to find the total number of ways of representing N as the sum of positive integers in the range [1, K], where each integer can be chosen multiple times.

Examples:

Input: N = 8, K = 2
Output: 5
Explanation: All possible ways of representing N as sum of positive integers less than or equal to K are:

1. {1, 1, 1, 1, 1, 1, 1, 1}, the sum is 8.
2. {2, 1, 1, 1, 1, 1, 1}, the sum is 8.
3. {2, 2, 1, 1, 1, 1}, the sum is 8.
4. 2, 2, 2, 1, 1}, the sum is 8.
5. {2, 2, 2, 2}}, the sum is 8.

Therefore, the total number of ways is 5.

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

Naive Approach: The simplest approach to solve the given problem is to generate all possible combinations of choosing integers over the range [1, K] and count those combinations whose sum is N

Implementaion :

## C++

 `//C++ program for above approach` `#include ``using` `namespace` `std;`  `// Function that return Ways to sum to N using``// Natural Numbers up to K with repetitions allowed``int` `NumberOfways(``int` `N, ``int` `K) {``    ` `    ``// Base case``    ``if` `(N == 0) ``return` `1;``    ``if` `(N < 0 || K <= 0) ``return` `0;``    ` `    ``// including and not including K in sum``    ``return` `NumberOfways(N - K, K) + NumberOfways(N, K - 1);``}`  `// Driver code``int` `main() {``    ``int` `N = 8;``    ``int` `K = 2;``    ` `    ``// function call``    ``cout << NumberOfways(N, K) << endl;``    ``return` `0;``}` `// this code is contributed by bhardwajji`

## Java

 `import` `java.util.*;` `class` `Main {``    ``// Function that return Ways to sum to N using``    ``// Natural Numbers up to K with repetitions allowed``    ``public` `static` `int` `NumberOfways(``int` `N, ``int` `K)``    ``{``        ``// Base case``        ``if` `(N == ``0``)``            ``return` `1``;``        ``if` `(N < ``0` `|| K <= ``0``)``            ``return` `0``;` `        ``// including and not including K in sum``        ``return` `NumberOfways(N - K, K)``            ``+ NumberOfways(N, K - ``1``);``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``8``;``        ``int` `K = ``2``;` `        ``// function call``        ``System.out.println(NumberOfways(N, K));``    ``}``}`

## Python3

 `# Function that returns the number of ways to sum``# to N using natural numbers up to K with repetitions allowed`  `def` `number_of_ways(N, K):` `    ``# Base case``    ``if` `N ``=``=` `0``:``        ``return` `1``    ``if` `N < ``0` `or` `K <``=` `0``:``        ``return` `0` `    ``# Including and not including K in sum``    ``return` `number_of_ways(N ``-` `K, K) ``+` `number_of_ways(N, K ``-` `1``)`  `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``N ``=` `8``    ``K ``=` `2` `    ``# Function call``    ``print``(number_of_ways(N, K))`

## Javascript

 `// Function that return Ways to sum to N using``// Natural Numbers up to K with repetitions allowed``function` `numberOfWays(N, K) {``    ` `    ``// Base case``    ``if` `(N == 0) ``return` `1;``    ``if` `(N < 0 || K <= 0) ``return` `0;``    ` `    ``// including and not including K in sum``    ``return` `numberOfWays(N - K, K) + numberOfWays(N, K - 1);``}`  `// Driver code``let N = 8;``let K = 2;``    ` `// function call``console.log(numberOfWays(N, K));`

## C#

 `using` `System;` `class` `MainClass {``    ``// Function that return Ways to sum to N using``    ``// Natural Numbers up to K with repetitions allowed``    ``static` `int` `NumberOfWays(``int` `N, ``int` `K)``    ``{``        ``// Base case``        ``if` `(N == 0)``            ``return` `1;``        ``if` `(N < 0 || K <= 0)``            ``return` `0;` `        ``// including and not including K in sum``        ``return` `NumberOfWays(N - K, K)``            ``+ NumberOfWays(N, K - 1);``    ``}` `    ``// Driver code``    ``static` `void` `Main()``    ``{``        ``int` `N = 8;``        ``int` `K = 2;` `        ``// function call``        ``Console.WriteLine(NumberOfWays(N, K));``    ``}``}``// This code is contributed by user_dtewbxkn77n`

Output

`5`

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

Efficient Approach: The above approach has Overlapping Subproblems and an Optimal Substructure. Hence, in order to optimize, Dynamic Programming is needed to be performed based on the following observations:

• Considering dp[i] stores the total number of ways for representing i as the sum of integers lying in the range [1, K], then the transition of states can be defined as:
• For i in the range [1, K] and for every j in the range [1, N]
• The value of dp[j] is equal to (dp[j]+ dp[j – i]), for all j ≥ i.

Follow the steps below to solve the problem:

• Initialize an array, say dp[], with all elements as 0, to store all the recursive states.
• Initialize dp as 1.
• Now, iterate over the range [1, K] using a variable i and perform the following steps:
• Iterate over the range [1, N], using a variable j, and update the value of dp[j] as dp[j]+ dp[j – i], if j ≥ i.
• After completing the above steps, print the value of dp[N] as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the total number of``// ways to represent N as the sum of``// integers over the range [1, K]``int` `NumberOfways(``int` `N, ``int` `K)``{` `    ``// Initialize a list``    ``vector<``int``> dp(N + 1, 0);``  ` `    ``// Update dp to 1``    ``dp = 1;` `    ``// Iterate over the range [1, K + 1]``    ``for` `(``int` `row = 1; row < K + 1; row++)``    ``{` `        ``// Iterate over the range [1, N + 1]``        ``for` `(``int` `col = 1; col < N + 1; col++)``        ``{` `            ``// If col is greater``            ``// than or equal to row``            ``if` `(col >= row)``              ` `                ``// Update current``                ``// dp[col] state``                ``dp[col] = dp[col] + dp[col - row];``          ``}``    ``}` `    ``// Return the total number of ways``    ``return``(dp[N]);``}` `// Driver Code``int` `main()``{``  ``int` `N = 8;``  ``int` `K = 2;` `  ``cout << (NumberOfways(N, K));``}` `// This code is contributed by mohit kumar 29.`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{``    ` `// Function to find the total number of``// ways to represent N as the sum of``// integers over the range [1, K]``static` `int` `NumberOfways(``int` `N, ``int` `K)``{``    ` `    ``// Initialize a list``    ``int``[] dp = ``new` `int``[N + ``1``];``  ` `    ``// Update dp to 1``    ``dp[``0``] = ``1``;` `    ``// Iterate over the range [1, K + 1]``    ``for``(``int` `row = ``1``; row < K + ``1``; row++)``    ``{` `        ``// Iterate over the range [1, N + 1]``        ``for``(``int` `col = ``1``; col < N + ``1``; col++)``        ``{``            ` `            ``// If col is greater``            ``// than or equal to row``            ``if` `(col >= row)``              ` `                ``// Update current``                ``// dp[col] state``                ``dp[col] = dp[col] + dp[col - row];``          ``}``    ``}` `    ``// Return the total number of ways``    ``return``(dp[N]);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given inputs``    ``int` `N = ``8``;``    ``int` `K = ``2``;``    ` `    ``System.out.println(NumberOfways(N, K));``}``}` `// This code is contributed by offbeat`

## Python

 `# Python program for the above approach` `# Function to find the total number of``# ways to represent N as the sum of``# integers over the range [1, K]``def` `NumberOfways(N, K):``  ` `    ``# Initialize a list``    ``dp ``=` `[``0``] ``*` `(N ``+` `1``)``    ` `    ``# Update dp to 1``    ``dp[``0``] ``=` `1``    ` `    ``# Iterate over the range [1, K + 1]``    ``for` `row ``in` `range``(``1``, K ``+` `1``):``      ` `        ``# Iterate over the range [1, N + 1]``        ``for` `col ``in` `range``(``1``, N ``+` `1``):``          ` `            ``# If col is greater``            ``# than or equal to row``            ``if` `(col >``=` `row):``              ` `                ``# Update current``                ``# dp[col] state``                ``dp[col] ``=` `dp[col] ``+` `dp[col ``-` `row]``                ` `                ` `    ``# Return the total number of ways``    ``return``(dp[N])` `# Driver Code` `N ``=` `8``K ``=` `2` `print``(NumberOfways(N, K))`

## Javascript

 ``

## C#

 `// C# program for the above approach``using` `System;``class` `GFG``{``  ` `    ``// Function to find the total number of``    ``// ways to represent N as the sum of``    ``// integers over the range [1, K]``    ``static` `int` `NumberOfways(``int` `N, ``int` `K)``    ``{` `        ``// Initialize a list``        ``int``[] dp = ``new` `int``[(N + 1)];` `        ``// Update dp to 1``        ``dp = 1;` `        ``// Iterate over the range [1, K + 1]``        ``for` `(``int` `row = 1; row < K + 1; row++) {` `            ``// Iterate over the range [1, N + 1]``            ``for` `(``int` `col = 1; col < N + 1; col++) {` `                ``// If col is greater``                ``// than or equal to row``                ``if` `(col >= row)` `                    ``// Update current``                    ``// dp[col] state``                    ``dp[col] = dp[col] + dp[col - row];``            ``}``        ``}` `        ``// Return the total number of ways``        ``return` `(dp[N]);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int` `N = 8;``        ``int` `K = 2;` `        ``Console.WriteLine(NumberOfways(N, K));``    ``}``}` `// This code is contributed by ukasp.`

Output:

`5`

Time Complexity: O(N * K)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up