Shortest Impossible Sequence of Rolls

Shortest Impossible Sequence of Rolls - Problem

You are given an integer array rolls of length n and an integer k. You roll a k-sided dice numbered from 1 to k, n times, where the result of the i-th roll is rolls[i].

Return the length of the shortest sequence of rolls so that there's no such subsequence in rolls.

A sequence of rolls of length len is the result of rolling a k-sided dice len times.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: We can form any sequence of length 1: [1], [2], [3], [4] all appear in rolls. For length 2, we need all possible pairs, but [1,1] never appears as a subsequence, so answer is 2.

Example 2 — Immediate Missing

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

› Output: 1

💡 Note: Values 3 and 4 never appear in rolls, so sequences [3] and [4] are impossible. The shortest impossible sequence has length 1.

Example 3 — Longer Sequence

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

› Output: 2

💡 Note: All length 1 sequences appear: [1], [2], [3]. But some length 2 sequences like [1,2] don't appear as subsequences, so answer is 2.

Constraints

1 ≤ rolls.length ≤ 10⁵
1 ≤ rolls[i], k ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use a greedy approach to track when we've seen all possible dice values. The optimal solution uses a set to track unseen values, incrementing the sequence length whenever all values have been seen. Time: O(n), Space: O(k).

Common Approaches

✓ Brute Force - Check All Sequences

⏱️ Time: O(k^L × n × L) Space: O(L)

For each possible length starting from 1, generate all possible sequences of that length and check if any of them doesn't exist as a subsequence in the rolls array.

Greedy - Build Missing Sequence

⏱️ Time: O(n) Space: O(k)

Use a greedy approach to build the shortest missing sequence. At each step, find values that haven't appeared yet. When all values have been seen, we need to extend the sequence length.

Brute Force - Check All Sequences — Algorithm Steps

Start with length 1, generate all sequences of length 1
Check if each sequence exists as subsequence in rolls
If found missing sequence, return its length
Otherwise increment length and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Length 1

Generate all sequences: [1], [2], [3], [4]

Check Each

Check if each exists as subsequence in rolls

Found Missing

Return length when first missing sequence found

Code -

solution.c — C

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

bool isSubsequence(int* seq, int seqLen, int* rolls, int rollsLen) {
    int i = 0;
    for (int j = 0; j < rollsLen; j++) {
        if (i < seqLen && rolls[j] == seq[i]) {
            i++;
        }
    }
    return i == seqLen;
}

int solution(int* rolls, int rollsLen, int k) {
    int length = 1;
    while (true) {
        int totalSeqs = 1;
        for (int i = 0; i < length; i++) {
            totalSeqs *= k;
        }
        
        for (int seqNum = 0; seqNum < totalSeqs; seqNum++) {
            int* seq = (int*)malloc(length * sizeof(int));
            int temp = seqNum;
            for (int i = length - 1; i >= 0; i--) {
                seq[i] = (temp % k) + 1;
                temp /= k;
            }
            
            if (!isSubsequence(seq, length, rolls, rollsLen)) {
                free(seq);
                return length;
            }
            free(seq);
        }
        length++;
    }
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int rolls[1000];
    int rollsLen = 0;
    char* ptr = strchr(line, '[') + 1;
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        rolls[rollsLen++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(rolls, rollsLen, k);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^L × n × L)

For each length L, generate k^L sequences, each taking O(n×L) to check

✓ Linear Growth

Space Complexity

O(L)

Space for current sequence being checked

✓ Linear Space

12.0K Views

Medium Frequency

~25 min Avg. Time

450 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 - Check All Sequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler