 Open in App
Not now

# Count ways to obtain given sum by repeated throws of a dice

• Difficulty Level : Medium
• Last Updated : 23 Jun, 2021

Given an integer N, the task is to find the number of ways to get the sum N by repeatedly throwing a dice.

Examples:

Input: N = 3
Output: 4
Explanation:
The four possible ways to obtain N are:

• 1 + 1 + 1
• 1 + 2
• 2 + 1
• 3

Input: N = 2
Output: 2
Explanation:
The two possible ways to obtain N are:

• 1 + 1
• 2

Recursive Approach: The idea is to iterate for every possible value of dice to get the required sum N. Below are the steps:

1. Let findWays() be the required answer for sum N.
2. The only numbers obtained from the throw of dice are [1, 6], each having equal probability in a single throw of dice.
3. Therefore, for every state, recur for the previous (N – i) states (where 1 ≤ i ≤ 6). Therefore, the recursive relation is as follows:

findWays(N) = findWays(N – 1) + findWays(N – 2) + findWays(N – 3) + findWays(N – 4) + findWays(N – 5) + findWays(N – 6)

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find the number of ways` `// to get the sum N with throw of dice` `int` `findWays(``int` `N)` `{` `    ``// Base Case` `    ``if` `(N == 0) {` `        ``return` `1;` `    ``}`   `    ``// Stores the count of total` `    ``// number of ways to get sum N` `    ``int` `cnt = 0;`   `    ``// Recur for all 6 states` `    ``for` `(``int` `i = 1; i <= 6; i++) {`   `        ``if` `(N - i >= 0) {`   `            ``cnt = cnt` `                  ``+ findWays(N - i);` `        ``}` `    ``}`   `    ``// Return answer` `    ``return` `cnt;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 4;`   `    ``// Function call` `    ``cout << findWays(N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG{`   `// Function to find the number of ways` `// to get the sum N with throw of dice` `static` `int` `findWays(``int` `N)` `{` `    `  `    ``// Base Case` `    ``if` `(N == ``0``)` `    ``{` `        ``return` `1``;` `    ``}`   `    ``// Stores the count of total` `    ``// number of ways to get sum N` `    ``int` `cnt = ``0``;`   `    ``// Recur for all 6 states` `    ``for``(``int` `i = ``1``; i <= ``6``; i++)` `    ``{` `        ``if` `(N - i >= ``0``) ` `        ``{` `            ``cnt = cnt + ` `                  ``findWays(N - i);` `        ``}` `    ``}`   `    ``// Return answer` `    ``return` `cnt;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `N = ``4``;`   `    ``// Function call` `    ``System.out.print(findWays(N));` `}` `}`   `// This code is contributed by 29AjayKumar `

## Python3

 `# Python3 program for the above approach`   `# Function to find the number of ways` `# to get the sum N with throw of dice` `def` `findWays(N):` `    `  `    ``# Base case` `    ``if` `(N ``=``=` `0``):` `        ``return` `1`   `    ``# Stores the count of total` `    ``# number of ways to get sum N` `    ``cnt ``=` `0`   `    ``# Recur for all 6 states` `    ``for` `i ``in` `range``(``1``, ``7``):` `        ``if` `(N ``-` `i >``=` `0``):` `            ``cnt ``=` `cnt ``+` `findWays(N ``-` `i)`   `    ``# Return answer` `    ``return` `cnt` `    `  `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``N ``=` `4`   `    ``# Function call` `    ``print``(findWays(N))`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for ` `// the above approach ` `using` `System;` `class` `GFG{`   `// Function to find the number of ways` `// to get the sum N with throw of dice` `static` `int` `findWays(``int` `N)` `{` `  ``// Base Case` `  ``if` `(N == 0)` `  ``{` `    ``return` `1;` `  ``}`   `  ``// Stores the count of total` `  ``// number of ways to get sum N` `  ``int` `cnt = 0;`   `  ``// Recur for all 6 states` `  ``for``(``int` `i = 1; i <= 6; i++)` `  ``{` `    ``if` `(N - i >= 0) ` `    ``{` `      ``cnt = cnt + findWays(N - i);` `    ``}` `  ``}`   `  ``// Return answer` `  ``return` `cnt;` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `  ``int` `N = 4;`   `  ``// Function call` `  ``Console.Write(findWays(N));` `}` `}`   `// This code is contributed by sanjoy_62`

## Javascript

 ``

Output:

`8`

Time Complexity: O(6N)
Auxiliary Space: O(1)

Dynamic Programming Approach: The above recursive approach needs to be optimized by dealing with the following overlapping subproblems:

Overlapping Subproblems:
Partial recursion tree for N = 8: Optimal Substructure: As for every state, recurrence occurs for 6 states, so the recursive definition of dp(N) is the following:

dp[N] = dp[N-1] + dp[N-2] + dp[N-3] + dp[N-4] + dp[N-5] + dp[N-6]

Follow the steps below to solve the problem:

• Initialize an auxiliary array dp[] of size N + 1 with initial value -1, where dp[i] stores the count of ways of having sum i.
• The base case while solving this problem is if N is equal to 0 in any state, the result to such a state is 1.
• If for any state dp[i] is not equal to -1, then this value as this substructure is already beed calculated.

Top-Down Approach: Below is the implementation of the Top-Down approach:

## C++

 `// C++ Program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to calculate the total` `// number of ways to have sum N` `int` `findWays(``int` `N, ``int` `dp[])` `{` `    ``// Base Case` `    ``if` `(N == 0) {` `        ``return` `1;` `    ``}`   `    ``// Return already stored result` `    ``if` `(dp[N] != -1) {`   `        ``return` `dp[N];` `    ``}`   `    ``int` `cnt = 0;`   `    ``// Recur for all 6 states` `    ``for` `(``int` `i = 1; i <= 6; i++) {`   `        ``if` `(N - i >= 0) {` `            ``cnt = cnt` `                  ``+ findWays(N - i, dp);` `        ``}` `    ``}`   `    ``// Return the result` `    ``return` `dp[N] = cnt;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given sum N` `    ``int` `N = 4;`   `    ``// Initialize the dp array` `    ``int` `dp[N + 1];`   `    ``memset``(dp, -1, ``sizeof``(dp));`   `    ``// Function Call` `    ``cout << findWays(N, dp);`   `    ``return` `0;` `}`

## Java

 `// Java Program for ` `// the above approach` `import` `java.util.*;` `class` `GFG{`   `// Function to calculate the total` `// number of ways to have sum N` `static` `int` `findWays(``int` `N, ``int` `dp[])` `{` `    ``// Base Case` `    ``if` `(N == ``0``) ` `    ``{` `        ``return` `1``;` `    ``}`   `    ``// Return already ` `    ``// stored result` `    ``if` `(dp[N] != -``1``) ` `    ``{` `        ``return` `dp[N];` `    ``}`   `    ``int` `cnt = ``0``;`   `    ``// Recur for all 6 states` `    ``for` `(``int` `i = ``1``; i <= ``6``; i++) ` `    ``{` `        ``if` `(N - i >= ``0``) ` `        ``{` `            ``cnt = cnt + ` `                  ``findWays(N - i, dp);` `        ``}` `    ``}`   `    ``// Return the result` `    ``return` `dp[N] = cnt;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``// Given sum N` `    ``int` `N = ``4``;`   `    ``// Initialize the dp array` `    ``int` `[]dp = ``new` `int``[N + ``1``];`   `    ``for` `(``int` `i = ``0``; i < dp.length; i++)` `        ``dp[i] = -``1``;`   `    ``// Function Call` `    ``System.out.print(findWays(N, dp));` `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 Program for the ` `# above approach`   `# Function to calculate ` `# the total number of ways ` `# to have sum N` `def` `findWays(N, dp):`   `    ``# Base Case` `    ``if` `(N ``=``=` `0``):` `        ``return` `1` `   `  `    ``# Return already ` `    ``# stored result` `    ``if` `(dp[N] !``=` `-``1``):` `        ``return` `dp[N]`   `    ``cnt ``=` `0`   `    ``# Recur for all 6 states` `    ``for` `i ``in` `range` `(``1``, ``7``):` `        ``if` `(N ``-` `i >``=` `0``):` `            ``cnt ``=` `(cnt ``+` `                   ``findWays(N ``-` `i, dp))`   `    ``# Return the result` `    ``dp[N] ``=` `cnt` `    ``return` `dp[N]`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``# Given sum N` `    ``N ``=` `4`   `    ``# Initialize the dp array` `    ``dp ``=` `[``-``1``] ``*` `(N ``+` `1``)`   `    ``# Function Call` `    ``print``(findWays(N, dp))`   `# This code is contributed by Chitranayal`

## C#

 `// C# Program for ` `// the above approach` `using` `System;` `class` `GFG{`   `// Function to calculate the total` `// number of ways to have sum N` `static` `int` `findWays(``int` `N, ``int` `[]dp)` `{` `  ``// Base Case` `  ``if` `(N == 0) ` `  ``{` `    ``return` `1;` `  ``}`   `  ``// Return already stored result` `  ``if` `(dp[N] != -1) ` `  ``{` `    ``return` `dp[N];` `  ``}`   `  ``int` `cnt = 0;`   `  ``// Recur for all 6 states` `  ``for` `(``int` `i = 1; i <= 6; i++) ` `  ``{` `    ``if` `(N - i >= 0) ` `    ``{` `      ``cnt = cnt + findWays(N - i, dp);` `    ``}` `  ``}`   `  ``// Return the result` `  ``return` `dp[N] = cnt;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  ``// Given sum N` `  ``int` `N = 4;`   `  ``// Initialize the dp array` `  ``int` `[]dp = ``new` `int``[N + 1];`   `  ``for` `(``int` `i = 0; i < dp.Length; i++)` `    ``dp[i] = -1;`   `  ``// Function Call` `  ``Console.Write(findWays(N, dp));` `}` `}` ` `  `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output:

`8`

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

Bottom-Up Approach: Below is the implementation of the Bottom-up Dynamic Programming approach:

## C++

 `// C++ Program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to calculate the total` `// number of ways to have sum N` `void` `findWays(``int` `N)` `{` `    ``// Initialize dp array` `    ``int` `dp[N + 1];`   `    ``dp = 1;`   `    ``// Iterate over all the possible` `    ``// intermediate values to reach N` `    ``for` `(``int` `i = 1; i <= N; i++) {`   `        ``dp[i] = 0;`   `        ``// Calculate the sum for` `        ``// all 6 faces` `        ``for` `(``int` `j = 1; j <= 6; j++) {`   `            ``if` `(i - j >= 0) {` `                ``dp[i] = dp[i] + dp[i - j];` `            ``}` `        ``}` `    ``}`   `    ``// Print the total number of ways` `    ``cout << dp[N];` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given sum N` `    ``int` `N = 4;`   `    ``// Function call` `    ``findWays(N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;` ` `  `class` `GFG{` ` `  `// Function to calculate the total` `// number of ways to have sum N` `static` `void` `findWays(``int` `N)` `{` `    `  `    ``// Initialize dp array` `    ``int` `[]dp = ``new` `int``[N + ``1``];` ` `  `    ``dp[``0``] = ``1``;` ` `  `    ``// Iterate over all the possible` `    ``// intermediate values to reach N` `    ``for``(``int` `i = ``1``; i <= N; i++)` `    ``{` `        ``dp[i] = ``0``;` ` `  `        ``// Calculate the sum for` `        ``// all 6 faces` `        ``for``(``int` `j = ``1``; j <= ``6``; j++) ` `        ``{` `            ``if` `(i - j >= ``0``)` `            ``{` `                ``dp[i] = dp[i] + dp[i - j];` `            ``}` `        ``}` `    ``}` ` `  `    ``// Print the total number of ways` `    ``System.out.print(dp[N]);` `}` ` `  `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``// Given sum N` `    ``int` `N = ``4``;` ` `  `    ``// Function call` `    ``findWays(N);` `}` `}` ` `  `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program for ` `# the above approach`   `# Function to calculate the total` `# number of ways to have sum N` `def` `findWays(N):` `  `  `    ``# Initialize dp array` `    ``dp ``=` `[``0``] ``*` `(N ``+` `1``);` `    ``dp[``0``] ``=` `1``;`   `    ``# Iterate over all the ` `    ``# possible intermediate ` `    ``# values to reach N` `    ``for` `i ``in` `range``(``1``, N ``+` `1``):` `        ``dp[i] ``=` `0``;`   `        ``# Calculate the sum for` `        ``# all 6 faces` `        ``for` `j ``in` `range``(``1``, ``7``):` `            ``if` `(i ``-` `j >``=` `0``):` `                ``dp[i] ``=` `dp[i] ``+` `dp[i ``-` `j];`   `    ``# Print total number of ways` `    ``print``(dp[N]);`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `  `  `    ``# Given sum N` `    ``N ``=` `4``;`   `    ``# Function call` `    ``findWays(N);`   `# This code is contributed by 29AjayKumar`

## C#

 `// C# program for ` `// the above approach` `using` `System;` `class` `GFG{` ` `  `// Function to calculate the total` `// number of ways to have sum N` `static` `void` `findWays(``int` `N)` `{` `  ``// Initialize dp array` `  ``int` `[]dp = ``new` `int``[N + 1];`   `  ``dp = 1;`   `  ``// Iterate over all the possible` `  ``// intermediate values to reach N` `  ``for``(``int` `i = 1; i <= N; i++)` `  ``{` `    ``dp[i] = 0;`   `    ``// Calculate the sum for` `    ``// all 6 faces` `    ``for``(``int` `j = 1; j <= 6; j++) ` `    ``{` `      ``if` `(i - j >= 0)` `      ``{` `        ``dp[i] = dp[i] + dp[i - j];` `      ``}` `    ``}` `  ``}`   `  ``// Print the total number of ways` `  ``Console.Write(dp[N]);` `}` ` `  `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  ``// Given sum N` `  ``int` `N = 4;`   `  ``// Function call` `  ``findWays(N);` `}` `} `   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`8`

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

My Personal Notes arrow_drop_up
Related Articles