Shortest Impossible Sequence of Rolls - Practice Coding Problems

Shortest Impossible Sequence of Rolls - Problem

Imagine you're analyzing dice roll patterns to find the shortest sequence that's guaranteed to never appear in your data!

You have an array rolls of length n representing the results of rolling a k-sided dice (numbered 1 to k) exactly n times. Your task is to find the length of the shortest sequence of consecutive rolls that cannot be found as a subsequence in the given rolls array.

Key insight: A sequence of length len represents the result of rolling the dice len times consecutively. We need to find the minimum len such that there exists at least one sequence of length len that doesn't appear as a subsequence in our rolls.

Example: If rolls = [4,2,1,2,3] and k = 4, we need to find the shortest length where at least one possible sequence of that length is missing from the subsequences of our rolls.

Input & Output

example_1.py — Basic Case

$ Input: rolls = [4,2,1,2,3], k = 4

› Output: 2

💡 Note: For length 1: All values 1,2,3,4 appear as subsequences. For length 2: We can form sequences like [4,2], [2,1], [1,2], [2,3], but we cannot form [1,1] or several others. So the answer is 2.

example_2.py — Longer Sequence

$ Input: rolls = [1,1,2,2], k = 2

› Output: 2

💡 Note: For length 1: Both [1] and [2] exist. For length 2: We have [1,1], [1,2], [2,2] but missing [2,1]. So answer is 2.

example_3.py — Edge Case

$ Input: rolls = [1,1,1,1], k = 4

› Output: 1

💡 Note: Only value 1 appears in rolls, so sequences [2], [3], [4] are all missing. The shortest impossible sequence has length 1.

Visualization

Tap to expand

Understanding the Visualization

Start Collecting

Begin with an empty ingredient basket and target recipe length 1

Add Ingredients

As you see each dice roll (ingredient), add it to your basket

Complete Recipe

When you have all k ingredients, you've completed one recipe

Level Up

Clear basket, increase recipe length, continue collecting

Find Answer

When rolls end, current length is the shortest impossible sequence

Key Takeaway

🎯 Key Insight: The moment you can't collect all k ingredients to complete a recipe, you've found the shortest impossible sequence length!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the rolls array, with O(1) set operations

✓ Linear Growth

Space Complexity

O(k)

Only need to store at most k different values in the set

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
1 ≤ rolls[i] ≤ k ≤ 10⁵
rolls[i] represents the result of rolling a k-sided dice

Asked in

G Google 42 f Meta 28 a Amazon 35 B ByteDance 15

The optimal solution uses a greedy counting approach in O(n) time. Key insight: if we can form fewer than k^L complete sequences of length L, then some sequence of length L must be missing. We scan through rolls, greedily collecting values in a set until we have all k values (completing one sequence), then increment length and reset.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Counting (Optimal)	O(n)	O(k)	Greedily count how many complete sequences we can form at each length
Brute Force (Generate All Sequences)	O(k^L × L × n)	O(k^L × L)	Generate all possible sequences and check if each exists as subsequence

Greedy Counting (Optimal) — Algorithm Steps

Start with length = 1 and a set to track what values we've seen
Scan through rolls, adding each roll to our current set
When set becomes full (size k), we've completed one sequence, increment count and reset set
If we can't complete enough sequences (count < k^(length-1)), return current length
Otherwise, increment length and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Values

Add each roll to our set until we have all k values

Complete Sequence

When set is full, we've completed one sequence of current length

Reset and Continue

Clear set and continue for next sequence

Code -

solution.c — C

#include <stdbool.h>

int shortestSequence(int* rolls, int rollsSize, int k) {
    int length = 1;
    bool* seen = (bool*)calloc(k + 1, sizeof(bool));
    int seenCount = 0;
    
    for (int i = 0; i < rollsSize; i++) {
        if (!seen[rolls[i]]) {
            seen[rolls[i]] = true;
            seenCount++;
        }
        
        if (seenCount == k) {
            // We've completed a sequence of current length
            length++;
            for (int j = 1; j <= k; j++) {
                seen[j] = false;
            }
            seenCount = 0;
        }
    }
    
    free(seen);
    return length;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the rolls array, with O(1) set operations

✓ Linear Growth

Space Complexity

O(k)

Only need to store at most k different values in the set

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
1 ≤ rolls[i] ≤ k ≤ 10⁵
rolls[i] represents the result of rolling a k-sided dice

41.3K Views

Medium Frequency

~25 min Avg. Time

1.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Greedy Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler