# 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 = 2Output:5Explanation: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}, the sum is 8.
- {2, 1, 1, 1, 1, 1, 1}, the sum is 8.
- {2, 2, 1, 1, 1, 1}, the sum is 8.
- 2, 2, 2, 1, 1}, the sum is 8.
- {2, 2, 2, 2}}, the sum is 8.
Therefore, the total number of ways is 5.

Input:N = 2, K = 2Output: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**.

**Time Complexity:** O(K^{N})**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**.

- For

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**.

- Iterate over the range
- 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 <bits/stdc++.h>` `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))` |

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

## Javascript

`<script>` `// Javascript implementation 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]` `function` `NumberOfways(N, K)` `{` ` ` ` ` `// Initialize a list` ` ` `let dp = Array.from({length: N +1}, (_, i) => 0);` ` ` ` ` `// Update dp[0] to 1` ` ` `dp[0] = 1;` ` ` `// Iterate over the range [1, K + 1]` ` ` `for` `(let row = 1; row < K + 1; row++)` ` ` `{` ` ` `// Iterate over the range [1, N + 1]` ` ` `for` `(let 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` ` ` ` ` `// Given inputs` ` ` `let N = 8;` ` ` `let K = 2;` ` ` ` ` `document.write(NumberOfways(N, K));` `</script>` |

**Output:**

5

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