Number of Dice Rolls With Target Sum - Practice Coding Problems

Number of Dice Rolls With Target Sum - Problem

Dynamic Programming Medium

Imagine you're at a board game night with n dice, and each die has k faces numbered from 1 to k. Your challenge is to find how many different ways you can roll these dice so that the sum of all face-up numbers equals a specific target.

For example, with 2 dice (each having 6 faces) and a target sum of 7, you could roll (1,6), (2,5), (3,4), (4,3), (5,2), or (6,1) - that's 6 different ways!

The Goal: Count all possible combinations of dice rolls that sum to the target value.

Input: Three integers n (number of dice), k (faces per die), and target (desired sum)

Output: Number of ways to achieve the target sum, modulo 10⁹ + 7 (since the result can be very large)

Note: With n dice having k faces each, there are kⁿ total possible outcomes, but we only want those that sum to our target!

Input & Output

example_1.py — Basic Case

$ Input: n = 1, k = 6, target = 3

› Output: 1

💡 Note: With 1 six-sided die, there's only one way to get sum 3: roll a 3.

example_2.py — Multiple Ways

$ Input: n = 2, k = 6, target = 7

› Output: 6

💡 Note: With 2 six-sided dice, we can get sum 7 in 6 ways: (1,6), (2,5), (3,4), (4,3), (5,2), (6,1).

example_3.py — Impossible Target

$ Input: n = 30, k = 30, target = 500

› Output: 222616187

💡 Note: Large case where the answer needs to be returned modulo 10^9 + 7.

Constraints

1 ≤ n ≤ 30
1 ≤ k ≤ 30
1 ≤ target ≤ 1000
Return result modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Setup the party

We have n children (dice) and need to distribute target cookies total

Give cookies to first child

First child can get 1 to k cookies - try each possibility

Recursive distribution

For each choice, distribute remaining cookies to remaining children

Count valid distributions

Sum up all ways where exactly target cookies are distributed

Key Takeaway

🎯 Key Insight: Break the problem into subproblems - to distribute cookies to n children, try each possible amount for the first child, then recursively solve for the remaining children with updated constraints.

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28

This is a classic dynamic programming problem. The key insight is that to find ways to achieve a target sum with n dice, we can break it down into subproblems: for each possible face value of the first die, find ways to achieve the remaining sum with (n-1) dice. Use memoization to avoid recalculating the same subproblems, achieving O(n × target × k) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Memoization)	O(n * target * k)	O(n * target)	Optimize recursion by caching previously computed results
Recursive Brute Force	O(k^n)	O(n)	Try all possible combinations recursively

Dynamic Programming (Memoization) — Algorithm Steps

Create a memoization cache (dictionary/map)
Before computing, check if result exists in cache
If cached, return the stored result immediately
Otherwise, compute recursively and store in cache
Return the cached result

Visualization

Tap to expand

Step-by-Step Walkthrough

First calculation

Calculate dp(2,5) and store result

Cache hit

When dp(2,5) needed again, return cached value

Build cache

Cache fills with computed subproblem results

Final result

Combine cached results for final answer

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

const int MOD = 1000000007;
long long memo[31][1001]; // n <= 30, target <= 1000
int memo_initialized = 0;

long long dp(int diceLeft, int k, int currentTarget) {
    if (!memo_initialized) {
        memset(memo, -1, sizeof(memo));
        memo_initialized = 1;
    }
    
    if (memo[diceLeft][currentTarget] != -1) {
        return memo[diceLeft][currentTarget];
    }
    
    if (diceLeft == 0) {
        memo[diceLeft][currentTarget] = currentTarget == 0 ? 1 : 0;
        return memo[diceLeft][currentTarget];
    }
    
    if (currentTarget < diceLeft || currentTarget > diceLeft * k) {
        memo[diceLeft][currentTarget] = 0;
        return 0;
    }
    
    long long count = 0;
    for (int face = 1; face <= k; face++) {
        if (face <= currentTarget) {
            count += dp(diceLeft - 1, k, currentTarget - face);
            count %= MOD;
        }
    }
    
    memo[diceLeft][currentTarget] = count;
    return count;
}

int numRollsToTarget(int n, int k, int target) {
    return dp(n, k, target);
}

int main() {
    int n, k, target;
    scanf("%d %d %d", &n, &k, &target);
    printf("%d\n", numRollsToTarget(n, k, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * target * k)

We have at most n * target unique subproblems, each taking O(k) time to compute

✓ Linear Growth

Space Complexity

O(n * target)

Memoization table stores results for n * target subproblems, plus O(n) recursion stack

⚡ Linearithmic Space

89.0K Views

Medium Frequency

~25 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Memoization) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler