Number of ways to get a given sum with n number of m-faced dices

Given n dices each with m faces, numbered from 1 to m, find the number of ways to get a given sum X. X is the summation of values on each face when all the dice are thrown.

Examples:

Input : faces = 4 throws = 2 sum =4
Output : 3
Ways to reach sum equal to 4 in 2 throws can be { (1, 3), (2, 2), (3, 1) }

Input : faces = 6 throws = 3 sum = 12
Output : 25

Approach:
Basically, it is asked to achieve sum in n number of operations using the values in the range [1…m].
Use dynamic programming top down methodology for this problem. The steps are:

  • Base Cases:
    1. If (sum == 0 and noofthrowsleft ==0) return 1 . It means that sum x has
      been achieved.
    2. If (sum < 0 and noofthrowsleft ==0) return 0.It means that sum x has not
      been achieved in all throws.
  • If present sum with present noofthrowsleft is already achieved then return it from table instead of re computation.
  • Then we will loop through all the values of faces from i=[1..m] and recursively moving to achieve sum-i and also decrease the noofthrowsleft by 1.
  • Finally we will store current values in the dp array

Below is the implementation of the above method:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ function to calculate the number of
// ways to achieve sum x in n no of throws
#include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
int dp[55][55];
  
// Function to calculate recursively the
// number of ways to get sum in given
// throws and [1..m] values
int NoofWays(int face, int throws, int sum)
{
    // Base condition 1
    if (sum == 0 && throws == 0)
        return 1;
  
    // Base condition 2
    if (sum < 0 || throws == 0)
        return 0;
  
    // If value already calculated dont
    // move into re-computation
    if (dp[throws][sum] != -1)
        return dp[throws][sum];
  
    int ans = 0;
    for (int i = 1; i <= face; i++) {
  
        // Recusively moving for sum-i in
        // throws-1 no of throws left
        ans += NoofWays(face, throws - 1, sum - i);
    }
  
    // Inserting present values in dp
    return dp[throws][sum] = ans;
}
  
// Driver function
int main()
{
    int faces = 6, throws = 3, sum = 12;
  
    memset(dp, -1, sizeof dp);
  
    cout << NoofWays(faces, throws, sum) << endl;
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java function to calculate the number of 
// ways to achieve sum x in n no of throwsVal 
class GFG 
{
  
    static int mod = 1000000007;
    static int[][] dp = new int[55][55];
  
    // Function to calculate recursively the 
    // number of ways to get sum in given 
    // throwsVal and [1..m] values 
    static int NoofWays(int face, int throwsVal, int sum)
    {
        // Base condition 1 
        if (sum == 0 && throwsVal == 0)
        {
            return 1;
        }
  
        // Base condition 2 
        if (sum < 0 || throwsVal == 0
        {
            return 0;
        }
  
        // If value already calculated dont 
        // move into re-computation 
        if (dp[throwsVal][sum] != -1
        {
            return dp[throwsVal][sum];
        }
  
        int ans = 0;
        for (int i = 1; i <= face; i++)
        {
  
            // Recusively moving for sum-i in 
            // throwsVal-1 no of throwsVal left 
            ans += NoofWays(face, throwsVal - 1, sum - i);
        }
  
        // Inserting present values in dp 
        return dp[throwsVal][sum] = ans;
    }
  
    // Driver code 
    public static void main(String[] args)
    {
        int faces = 6, throwsVal = 3, sum = 12;
        for (int i = 0; i < 55; i++) 
        {
            for (int j = 0; j < 55; j++) 
            {
                dp[i][j] = -1;
            }
        }
  
        System.out.println(NoofWays(faces, throwsVal, sum));
    }
}
  
// This code is contributed by 29AjayKumar

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 function to calculate the number of 
# ways to achieve sum x in n no of throws 
import numpy as np
  
mod = 1000000007;
  
dp = np.zeros((55,55)); 
  
# Function to calculate recursively the 
# number of ways to get sum in given 
# throws and [1..m] values 
def NoofWays(face, throws, sum) : 
  
    # Base condition 1 
    if (sum == 0 and throws == 0) :
        return 1
  
    # Base condition 2 
    if (sum < 0 or throws == 0) :
        return 0
  
    # If value already calculated dont 
    # move into re-computation 
    if (dp[throws][sum] != -1) :
        return dp[throws][sum]; 
  
    ans = 0
    for i in range(1, face + 1) : 
  
        # Recusively moving for sum-i in 
        # throws-1 no of throws left 
        ans += NoofWays(face, throws - 1, sum - i); 
  
    # Inserting present values in dp 
    dp[throws][sum] = ans;
      
    return ans;
  
  
# Driver function 
if __name__ == "__main__"
  
    faces = 6; throws = 3; sum = 12
  
    for i in range(55) :
        for j in range(55) :
            dp[i][j] = -1
  
    print(NoofWays(faces, throws, sum)) ; 
      
# This code is contributed by AnkitRai01

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# function to calculate the number of 
// ways to achieve sum x in n no of throwsVal 
using System;
  
class GFG
{
      
    static int[,]dp = new int[55,55];
  
    // Function to calculate recursively the 
    // number of ways to get sum in given 
    // throwsVal and [1..m] values 
    static int NoofWays(int face, int throwsVal, int sum)
    {
        // Base condition 1 
        if (sum == 0 && throwsVal == 0)
        {
            return 1;
        }
  
        // Base condition 2 
        if (sum < 0 || throwsVal == 0) 
        {
            return 0;
        }
  
        // If value already calculated dont 
        // move into re-computation 
        if (dp[throwsVal,sum] != -1) 
        {
            return dp[throwsVal,sum];
        }
  
        int ans = 0;
        for (int i = 1; i <= face; i++)
        {
  
            // Recusively moving for sum-i in 
            // throwsVal-1 no of throwsVal left 
            ans += NoofWays(face, throwsVal - 1, sum - i);
        }
  
        // Inserting present values in dp 
        return dp[throwsVal,sum] = ans;
    }
  
    // Driver code 
    static public void Main ()
    {
        int faces = 6, throwsVal = 3, sum = 12;
        for (int i = 0; i < 55; i++) 
        {
            for (int j = 0; j < 55; j++) 
            {
                dp[i,j] = -1;
            }
        }
  
    Console.WriteLine(NoofWays(faces, throwsVal, sum));
    }
}
  
// This code is contributed by ajit.

chevron_right


Output:

25

Time complexity : O(throws*faces)
Space complexity : O(faces*sum)



My Personal Notes arrow_drop_up

Competitive Programmer, Full Stack Developer

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : AnkitRai01, 29AjayKumar, jit_t