Dice Roll Simulation - Practice Coding Problems

Dice Roll Simulation - Problem

Dice Roll Simulation with Consecutive Limits

Imagine you're building a dice game simulator, but there's a twist! Your dice can't show the same number too many times in a row - just like how real dice games often have streak limits to keep things fair and exciting.

🎲 You have a standard 6-sided die (numbers 1-6) and need to simulate n rolls. However, each number i can appear at most rollMax[i-1] consecutive times. For example, if rollMax[0] = 3, then the number 1 can appear at most 3 times in a row.

Goal: Count how many distinct valid sequences of exactly n dice rolls are possible.

Input: An array rollMax of 6 integers (limits for numbers 1-6) and integer n (number of rolls)
Output: Number of valid sequences modulo 10⁹ + 7

Example: With rollMax = [1,1,2,2,2,3] and n = 2, sequences like [1,1] are invalid (1 appears twice but limit is 1), while [1,2] is valid.

Input & Output

example_1.py — Basic Case

$ Input: rollMax = [1,1,2,2,2,3], n = 2

› Output: 34

💡 Note: With 2 rolls and given limits: number 1 can appear max 1 consecutive time, number 2 can appear max 1 consecutive time, numbers 3,4,5 can appear max 2 consecutive times, and number 6 can appear max 3 consecutive times. Valid sequences include [1,2], [1,3], [1,4], [1,5], [1,6], [2,1], [2,3], etc. Total count is 34.

example_2.py — Longer Sequence

$ Input: rollMax = [1,1,1,1,1,1], n = 3

› Output: 0

💡 Note: Each number can appear at most 1 consecutive time, but we need 3 rolls. Since no number can repeat consecutively and we only have 6 different numbers, it's impossible to create a valid sequence of length 3. Hence the answer is 0.

example_3.py — All Same Limit

$ Input: rollMax = [2,2,2,2,2,2], n = 2

› Output: 36

💡 Note: Every number can appear up to 2 consecutive times. With 2 rolls, all possible combinations are valid: 6 choices for first roll × 6 choices for second roll = 36 total valid sequences.

Constraints

1 ≤ n ≤ 5000
rollMax.length == 6
1 ≤ rollMax[i] ≤ 15
Return answer modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

State Tracking

Track current position, last rolled number, and how many times it appeared consecutively

Smart Transitions

For each state, calculate valid next moves by trying all 6 dice values

Constraint Checking

Only allow transitions that don't exceed consecutive roll limits

Memoization Magic

Cache results for each state to avoid recalculating the same subproblems

Key Takeaway

🎯 Key Insight: Transform exponential enumeration into polynomial counting by tracking (position, last_number, consecutive_count) states with memoization. This reduces O(6ⁿ) to O(n×6×max(rollMax))!

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses dynamic programming with memoization to count valid dice sequences efficiently. Instead of generating all 6ⁿ possible sequences, we track states as (position, last_number, consecutive_count) and use memoization to avoid redundant calculations. This reduces complexity from exponential O(6ⁿ) to polynomial O(n × 6 × max(rollMax)), making it feasible for large inputs up to n=5000.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with State Memoization (Optimal)	O(n × 6 × max(rollMax))	O(n × 6 × max(rollMax))	Use DP to count sequences by tracking position, last number, and consecutive count
Recursive Enumeration (Brute Force)	O(6^n)	O(n)	Generate all possible sequences recursively and count valid ones

Dynamic Programming with State Memoization (Optimal) — Algorithm Steps

Define DP state: dp[pos][last_num][consecutive_count] = number of valid sequences
Base case: if pos == n, return 1 (found valid sequence)
For each state, try all 6 dice values as next number
If next number equals last number, increment consecutive count
If next number differs from last number, reset consecutive count to 1
Only proceed if consecutive count doesn't exceed rollMax limit
Use memoization to store and reuse computed results

Visualization

Tap to expand

Step-by-Step Walkthrough

State Definition

Define state as (position, last_number, consecutive_count)

Transition

For each state, try all 6 dice values with constraint checking

Memoization

Store computed results to avoid recalculation

Optimal Path

Build solution bottom-up using memoized subproblems

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_STATES 100000

typedef struct {
    int pos, lastNum, consecutiveCount;
    int result;
} MemoEntry;

MemoEntry memo[MAX_STATES];
int memoSize = 0;

int findMemo(int pos, int lastNum, int consecutiveCount) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].pos == pos && memo[i].lastNum == lastNum && memo[i].consecutiveCount == consecutiveCount) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int pos, int lastNum, int consecutiveCount, int result) {
    memo[memoSize].pos = pos;
    memo[memoSize].lastNum = lastNum;
    memo[memoSize].consecutiveCount = consecutiveCount;
    memo[memoSize].result = result;
    memoSize++;
}

int dp(int pos, int lastNum, int consecutiveCount, int n, int* rollMax) {
    if (pos == n) return 1;
    
    int cached = findMemo(pos, lastNum, consecutiveCount);
    if (cached != -1) return cached;
    
    long long result = 0;
    for (int num = 1; num <= 6; num++) {
        if (num == lastNum) {
            if (consecutiveCount < rollMax[num - 1]) {
                result = (result + dp(pos + 1, num, consecutiveCount + 1, n, rollMax)) % MOD;
            }
        } else {
            result = (result + dp(pos + 1, num, 1, n, rollMax)) % MOD;
        }
    }
    
    addMemo(pos, lastNum, consecutiveCount, (int)result);
    return (int)result;
}

int numRollsToTarget(int n, int* rollMax) {
    memoSize = 0;
    return dp(0, -1, 0, n, rollMax);
}

int main() {
    int rollMax[] = {1, 1, 2, 2, 2, 3};
    int n = 2;
    printf("%d\n", numRollsToTarget(n, rollMax));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 6 × max(rollMax))

For each position (n), we have 6 possible last numbers, each with up to max(rollMax) consecutive counts

✓ Linear Growth

Space Complexity

O(n × 6 × max(rollMax))

Memoization table stores results for all possible states

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~25 min Avg. Time

892 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 with State Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler