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

Last Updated : 13 Apr, 2023

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[0] 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[0] 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` `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[0] 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[0] 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[0] 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()` `    ``{` `        ``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)