# Different ways to sum n using numbers greater than or equal to m

Given two natural number **n** and **m**. The task is to find the number of ways in which the numbers that are greater than or equal to m can be added to get the sum n.**Examples:**

Input : n = 3, m = 1 Output : 3 Following are three different ways to get sum n such that each term is greater than or equal to m 1 + 1 + 1, 1 + 2, 3 Input : n = 2, m = 1 Output : 2 Two ways are 1 + 1 and 2

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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.

The idea is to use Dynamic Programming by define 2D matrix, say dp[][]. **dp[i][j]** define the number of ways to get sum i using the numbers greater than or equal to j. So dp[i][j] can be defined as:

If i < j, dp[i][j] = 0, because we cannot achieve smaller sum of i using numbers greater than or equal to j.If i = j, dp[i][j] = 1, because there is only one way to show sum i using number i which is equal to j.Else dp[i][j] = dp[i][j+1] + dp[i-j][j], because obtaining a sum i using numbers greater than or equal to j is equal to the sum of obtaining a sum of i using numbers greater than or equal to j+1 and obtaining the sum of i-j using numbers greater than or equal to j.

Below is the implementation of this approach:

## C++

`// CPP Program to find number of ways to` `// which numbers that are greater than` `// given number can be added to get sum.` `#include <bits/stdc++.h>` `#define MAX 100` `using` `namespace` `std;` `// Return number of ways to which numbers` `// that are greater than given number can` `// be added to get sum.` `int` `numberofways(` `int` `n, ` `int` `m)` `{` ` ` `int` `dp[n+2][n+2];` ` ` `memset` `(dp, 0, ` `sizeof` `(dp));` ` ` `dp[0][n + 1] = 1;` ` ` `// Filling the table. k is for numbers` ` ` `// greater than or equal that are allowed.` ` ` `for` `(` `int` `k = n; k >= m; k--) {` ` ` `// i is for sum` ` ` `for` `(` `int` `i = 0; i <= n; i++) {` ` ` `// initializing dp[i][k] to number` ` ` `// ways to get sum using numbers` ` ` `// greater than or equal k+1` ` ` `dp[i][k] = dp[i][k + 1];` ` ` `// if i > k` ` ` `if` `(i - k >= 0)` ` ` `dp[i][k] = (dp[i][k] + dp[i - k][k]);` ` ` `}` ` ` `}` ` ` `return` `dp[n][m];` `}` `// Driver Program` `int` `main()` `{` ` ` `int` `n = 3, m = 1;` ` ` `cout << numberofways(n, m) << endl;` ` ` `return` `0;` `}` |

## Java

`// Java Program to find number of ways to` `// which numbers that are greater than` `// given number can be added to get sum.` `import` `java.io.*;` `class` `GFG {` ` ` ` ` `// Return number of ways to which numbers` ` ` `// that are greater than given number can` ` ` `// be added to get sum.` ` ` `static` `int` `numberofways(` `int` `n, ` `int` `m)` ` ` `{` ` ` `int` `dp[][]=` `new` `int` `[n+` `2` `][n+` `2` `];` ` ` ` ` `dp[` `0` `][n + ` `1` `] = ` `1` `;` ` ` ` ` `// Filling the table. k is for numbers` ` ` `// greater than or equal that are allowed.` ` ` `for` `(` `int` `k = n; k >= m; k--) {` ` ` ` ` `// i is for sum` ` ` `for` `(` `int` `i = ` `0` `; i <= n; i++) {` ` ` ` ` `// initializing dp[i][k] to number` ` ` `// ways to get sum using numbers` ` ` `// greater than or equal k+1` ` ` `dp[i][k] = dp[i][k + ` `1` `];` ` ` ` ` `// if i > k` ` ` `if` `(i - k >= ` `0` `)` ` ` `dp[i][k] = (dp[i][k] + dp[i - k][k]);` ` ` `}` ` ` `}` ` ` ` ` `return` `dp[n][m];` ` ` `}` ` ` ` ` `// Driver Program` ` ` `public` `static` `void` `main(String args[])` ` ` `{` ` ` `int` `n = ` `3` `, m = ` `1` `;` ` ` `System.out.println(numberofways(n, m));` ` ` `}` `}` `/*This code is contributed by Nikita tiwari.*/` |

## Python3

`# Python3 Program to find number of ways to` `# which numbers that are greater than` `# given number can be added to get sum.` `MAX` `=` `100` `import` `numpy as np` `# Return number of ways to which numbers` `# that are greater than given number can` `# be added to get sum.` `def` `numberofways(n, m) :` ` ` ` ` `dp ` `=` `np.zeros((n ` `+` `2` `, n ` `+` `2` `))` ` ` ` ` `dp[` `0` `][n ` `+` `1` `] ` `=` `1` ` ` `# Filling the table. k is for numbers` ` ` `# greater than or equal that are allowed.` ` ` `for` `k ` `in` `range` `(n, m ` `-` `1` `, ` `-` `1` `) :` ` ` `# i is for sum` ` ` `for` `i ` `in` `range` `(n ` `+` `1` `) :` ` ` `# initializing dp[i][k] to number` ` ` `# ways to get sum using numbers` ` ` `# greater than or equal k+1` ` ` `dp[i][k] ` `=` `dp[i][k ` `+` `1` `]` ` ` `# if i > k` ` ` `if` `(i ` `-` `k >` `=` `0` `) :` ` ` `dp[i][k] ` `=` `(dp[i][k] ` `+` `dp[i ` `-` `k][k])` ` ` `return` `dp[n][m]` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `n, m ` `=` `3` `, ` `1` ` ` `print` `(numberofways(n, m))` `# This code is contributed by Ryuga` |

## C#

`// C# program to find number of ways to` `// which numbers that are greater than` `// given number can be added to get sum.` `using` `System;` `class` `GFG {` ` ` `// Return number of ways to which numbers` ` ` `// that are greater than given number can` ` ` `// be added to get sum.` ` ` `static` `int` `numberofways(` `int` `n, ` `int` `m)` ` ` `{` ` ` `int` `[, ] dp = ` `new` `int` `[n + 2, n + 2];` ` ` `dp[0, n + 1] = 1;` ` ` `// Filling the table. k is for numbers` ` ` `// greater than or equal that are allowed.` ` ` `for` `(` `int` `k = n; k >= m; k--) {` ` ` `// i is for sum` ` ` `for` `(` `int` `i = 0; i <= n; i++) {` ` ` `// initializing dp[i][k] to number` ` ` `// ways to get sum using numbers` ` ` `// greater than or equal k+1` ` ` `dp[i, k] = dp[i, k + 1];` ` ` `// if i > k` ` ` `if` `(i - k >= 0)` ` ` `dp[i, k] = (dp[i, k] + dp[i - k, k]);` ` ` `}` ` ` `}` ` ` `return` `dp[n, m];` ` ` `}` ` ` `// Driver Program` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `int` `n = 3, m = 1;` ` ` `Console.WriteLine(numberofways(n, m));` ` ` `}` `}` `/*This code is contributed by vt_m.*/` |

## PHP

`<?php` `// PHP Program to find number of ways to` `// which numbers that are greater than` `// given number can be added to get sum.` `$MAX` `= 100;` `// Return number of ways to which numbers` `// that are greater than given number can` `// be added to get sum.` `function` `numberofways(` `$n` `, ` `$m` `)` `{` ` ` `global` `$MAX` `;` ` ` `$dp` `= ` `array_fill` `(0, ` `$n` `+ 2, ` `array_fill` `(0, ` `$n` `+2, NULL));` ` ` `$dp` `[0][` `$n` `+ 1] = 1;` ` ` `// Filling the table. k is for numbers` ` ` `// greater than or equal that are allowed.` ` ` `for` `(` `$k` `= ` `$n` `; ` `$k` `>= ` `$m` `; ` `$k` `--)` ` ` `{` ` ` `// i is for sum` ` ` `for` `(` `$i` `= 0; ` `$i` `<= ` `$n` `; ` `$i` `++)` ` ` `{` ` ` `// initializing dp[i][k] to number` ` ` `// ways to get sum using numbers` ` ` `// greater than or equal k+1` ` ` `$dp` `[` `$i` `][` `$k` `] = ` `$dp` `[` `$i` `][` `$k` `+ 1];` ` ` `// if i > k` ` ` `if` `(` `$i` `- ` `$k` `>= 0)` ` ` `$dp` `[` `$i` `][` `$k` `] = (` `$dp` `[` `$i` `][` `$k` `] + ` `$dp` `[` `$i` `- ` `$k` `][` `$k` `]);` ` ` `}` ` ` `}` ` ` `return` `$dp` `[` `$n` `][` `$m` `];` `}` ` ` `// Driver Program` ` ` `$n` `= 3;` ` ` `$m` `= 1;` ` ` `echo` `numberofways(` `$n` `, ` `$m` `) ;` ` ` `return` `0;` ` ` ` ` `// This code is contributed by ChitraNayal` `?>` |

## Javascript

`<script>` `// Javascript Program to find number of ways to` `// which numbers that are greater than` `// given number can be added to get sum.` ` ` ` ` `// Return number of ways to which numbers` ` ` `// that are greater than given number can` ` ` `// be added to get sum.` ` ` `function` `numberofways(n,m)` ` ` `{` ` ` `let dp=` `new` `Array(n+2);` ` ` `for` `(let i=0;i<dp.length;i++)` ` ` `{` ` ` `dp[i]=` `new` `Array(n+2);` ` ` `for` `(let j=0;j<dp[i].length;j++)` ` ` `{` ` ` `dp[i][j]=0;` ` ` `}` ` ` `}` ` ` ` ` `dp[0][n + 1] = 1;` ` ` ` ` `// Filling the table. k is for numbers` ` ` `// greater than or equal that are allowed.` ` ` `for` `(let k = n; k >= m; k--) {` ` ` ` ` `// i is for sum` ` ` `for` `(let i = 0; i <= n; i++) {` ` ` ` ` `// initializing dp[i][k] to number` ` ` `// ways to get sum using numbers` ` ` `// greater than or equal k+1` ` ` `dp[i][k] = dp[i][k + 1];` ` ` ` ` `// if i > k` ` ` `if` `(i - k >= 0)` ` ` `dp[i][k] = (dp[i][k] + dp[i - k][k]);` ` ` `}` ` ` `}` ` ` ` ` `return` `dp[n][m];` ` ` `}` ` ` ` ` `// Driver Program` ` ` `let n = 3, m = 1;` ` ` `document.write(numberofways(n, m));` ` ` ` ` `// This code is contributed by avanitrachhadiya2155` `</script>` |

**Output:**

3