Related Articles

# 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)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up