Number of Distinct Roll Sequences - Practice Coding Problems

Number of Distinct Roll Sequences - Problem

Imagine you're a game designer creating a special dice game with magical rules! You have a fair 6-sided die and need to roll it n times to create a sequence. However, this isn't just any ordinary sequence - it must follow two mystical constraints:

🎯 Rule 1: Adjacent Harmony
Any two consecutive rolls must be coprime (their greatest common divisor equals 1). For example, rolling a 2 followed by a 3 is valid, but rolling a 2 followed by a 4 is not (since gcd(2,4) = 2).

🎯 Rule 2: Separation Distance
If you roll the same number twice, there must be at least 2 other rolls between them. So if you roll a 3 at position i, you cannot roll another 3 at positions i+1, i+2, or i+3.

Your task is to determine how many distinct valid sequences are possible. Since this number can be astronomically large, return the result modulo 10⁹ + 7.

Two sequences are considered distinct if they differ in at least one position.

Input & Output

example_1.py — Basic Case

$ Input: n = 4

› Output: 184

💡 Note: For n=4, we need sequences of 4 dice rolls. Example valid sequence: [1,3,2,5]. This satisfies both constraints: adjacent elements are coprime (gcd(1,3)=1, gcd(3,2)=1, gcd(2,5)=1) and no repeated values appear within 2 positions of each other.

example_2.py — Edge Case Small

$ Input: n = 2

› Output: 22

💡 Note: For n=2, we need pairs of dice rolls that are coprime. Valid pairs: (1,2), (1,3), (1,4), (1,5), (1,6), (2,1), (2,3), (2,5), (3,1), (3,2), (3,4), (3,5), (4,1), (4,3), (4,5), (5,1), (5,2), (5,3), (5,4), (5,6), (6,1), (6,5). Total: 22 pairs.

example_3.py — Single Roll

$ Input: n = 1

› Output: 6

💡 Note: For n=1, any single dice roll is valid since there are no adjacent elements to check and no repetition constraints. We can roll any of the 6 values: 1, 2, 3, 4, 5, or 6.

Constraints

1 ≤ n ≤ 10⁴
Dice values are always between 1 and 6 inclusive
Result must be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Start with First Roll

Any of the 6 dice values (1-6) can be the first roll

Check Adjacent Harmony

Next roll must be coprime with the previous roll (gcd = 1)

Enforce Separation Rule

Cannot repeat the same value within 2 positions

Use DP to Build Efficiently

Memoize (position, prev1, prev2) states to avoid recalculation

Key Takeaway

🎯 Key Insight: By tracking only the last two dice values, we can efficiently determine all valid next moves while satisfying both the coprime and separation constraints, transforming an exponential brute force solution into an elegant polynomial-time dynamic programming approach.

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

This problem is optimally solved using dynamic programming with memoization. The key insight is that we only need to track the last two dice values to make decisions about the next roll. We define our state as (position, prev1, prev2) and use precomputed coprime relationships to efficiently validate constraints. This reduces the time complexity from exponential O(6^n) to polynomial O(n × 6²), making it practical for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Recursion	O(6^n)	O(n)	Generate all possible sequences and validate constraints
Dynamic Programming (Optimal)	O(n * 6 * 6 * 6)	O(n * 6 * 6)	Use memoized DP to track states with last two dice values

Brute Force Recursion — Algorithm Steps

Generate all possible sequences of length n using recursive backtracking
For each complete sequence, check if adjacent elements are coprime
Verify that identical elements have at least 2 positions between them
Count valid sequences and return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Paths

Create a tree where each level represents a dice roll position

Validate Each Path

Check each complete sequence against both constraints

Count Valid Sequences

Sum up all sequences that pass both validation rules

Code -

solution.c — C

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

const int MOD = 1000000007;

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

bool isValidSequence(int* seq, int len) {
    // Check adjacent coprime constraint
    for (int i = 0; i < len - 1; i++) {
        if (gcd(seq[i], seq[i + 1]) != 1) {
            return false;
        }
    }
    
    // Check separation constraint
    for (int i = 0; i < len; i++) {
        int end = (i + 4 < len) ? i + 4 : len;
        for (int j = i + 1; j < end; j++) {
            if (seq[i] == seq[j]) {
                return false;
            }
        }
    }
    return true;
}

long long generateSequences(int* currentSeq, int currentLen, int remaining, int maxLen) {
    if (remaining == 0) {
        return isValidSequence(currentSeq, currentLen) ? 1 : 0;
    }
    
    long long count = 0;
    for (int diceVal = 1; diceVal <= 6; diceVal++) {
        currentSeq[currentLen] = diceVal;
        count = (count + generateSequences(currentSeq, currentLen + 1, remaining - 1, maxLen)) % MOD;
    }
    
    return count;
}

int distinctSequences(int n) {
    if (n == 1) return 6;
    int* seq = (int*)malloc(n * sizeof(int));
    long long result = generateSequences(seq, 0, n, n);
    free(seq);
    return (int)result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(6^n)

We generate 6^n possible sequences, and for each sequence we perform O(n) validation checks

✓ Linear Growth

Space Complexity

O(n)

Recursive call stack depth is n, plus space to store current sequence

⚡ Linearithmic Space

25.4K 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

Brute Force Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler