Skip to content

Create DiceThrow.java #2565

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
siriak merged 2 commits into from
Oct 15, 2021
Merged

Create DiceThrow.java #2565

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
c3f003c
Create DiceThrow.java
sahiltagala1 Oct 10, 2021
9b5fcfa
Merge branch 'master' into patch-1
siriak Oct 15, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
66 changes: 66 additions & 0 deletions DynamicProgramming/DiceThrow.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,66 @@
// Given N dice each with M faces, numbered from 1 to M, find the number of ways to get sum X.
// X is the summation of values on each face when all the dice are thrown.

/* The Naive approach is to find all the possible combinations of values from n dice and
keep on counting the results that sum to X. This can be done using recursion. */

// The above recursion solution exhibits overlapping subproblems.

/* Hence, storing the results of the solved sub-problems saves time.
And it can be done using Dynamic Programming(DP).
Following is implementation of Dynamic Programming approach. */


// Code ---->
// Java program to find number of ways to get sum 'x' with 'n'
// dice where every dice has 'm' faces
import java.util.*;
import java.lang.*;
import java.io.*;

class DP {
/* The main function that returns the number of ways to get sum 'x' with 'n' dice and 'm' with m faces. */
public static long findWays(int m, int n, int x){

/* Create a table to store the results of subproblems.
One extra row and column are used for simplicity
(Number of dice is directly used as row index and sum is directly used as column index).
The entries in 0th row and 0th column are never used. */
long[][] table = new long[n+1][x+1];

/* Table entries for only one dice */
for(int j = 1; j <= m && j <= x; j++)
table[1][j] = 1;

/* Fill rest of the entries in table using recursive relation
i: number of dice, j: sum */
for(int i = 2; i <= n;i ++){
for(int j = 1; j <= x; j++){
for(int k = 1; k < j && k <= m; k++)
table[i][j] += table[i-1][j-k];
}
}

return table[n][x];
}

public static void main (String[] args) {
System.out.println(findWays(4, 2, 1));
System.out.println(findWays(2, 2, 3));
System.out.println(findWays(6, 3, 8));
System.out.println(findWays(4, 2, 5));
System.out.println(findWays(4, 3, 5));
}
}

/*
OUTPUT:
0
2
21
4
6
*/

// Time Complexity: O(m * n * x) where m is number of faces, n is number of dice and x is given sum.