# Solving Leetcode Interviews in Seconds with AI: Shortest Impossible Sequence of Rolls


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2350" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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 ith 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.   Example 1:  Input: rolls = [4,2,1,2,3,3,2,4,1], k = 4 Output: 3 Explanation: Every sequence of rolls of length 1, [1], [2], [3], [4], can be taken from rolls. Every sequence of rolls of length 2, [1, 1], [1, 2], ..., [4, 4], can be taken from rolls. The sequence [1, 4, 2] cannot be taken from rolls, so we return 3. Note that there are other sequences that cannot be taken from rolls. Example 2:  Input: rolls = [1,1,2,2], k = 2 Output: 2 Explanation: Every sequence of rolls of length 1, [1], [2], can be taken from rolls. The sequence [2, 1] cannot be taken from rolls, so we return 2. Note that there are other sequences that cannot be taken from rolls but [2, 1] is the shortest.  Example 3:  Input: rolls = [1,1,3,2,2,2,3,3], k = 4 Output: 1 Explanation: The sequence [4] cannot be taken from rolls, so we return 1. Note that there are other sequences that cannot be taken from rolls but [4] is the shortest.    Constraints:  n == rolls.length 1 <= n <= 105 1 <= rolls[i] <= k <= 105  

	# Explanation
	Here's a breakdown of the solution, followed by the Python code:

*   **High-Level Approach:**
    *   Find the number of distinct subsequences of length 1 present in `rolls`. If this number is less than `k`, return 1.
    *   Iterate through `rolls`, tracking the last seen index of each number from 1 to `k`. Whenever we encounter a number, reset the subsequence length.
    *   Calculate the minimum length of subsequence that can be extracted, by counting continuous subsequences. The desired length is `ceil(n / number of continuous subsequences)`

*   **Complexity:**
    *   Time Complexity: O(n)
    *   Space Complexity: O(k)

	
	# Code
	```python
	import math

def shortest_sequence(rolls, k):
    """
    Finds the length of the shortest sequence of rolls that is not a subsequence of rolls.

    Args:
        rolls: A list of integers representing the results of rolling a k-sided dice n times.
        k: An integer representing the number of sides of the dice.

    Returns:
        An integer representing the length of the shortest sequence of rolls that is not a subsequence of rolls.
    """

    distinct_rolls = set(rolls)
    if len(distinct_rolls) < k:
        return 1

    count = 0
    last_seen = {}
    for roll in rolls:
        last_seen[roll] = 0

    consecutive_subsequences = 0
    last_occurrence = -1
    for i in range(len(rolls)):
        if rolls[i] not in last_seen or last_seen[rolls[i]] <= last_occurrence:
            consecutive_subsequences += 1
            last_occurrence = i
        last_seen[rolls[i]] = i

    return math.ceil(len(rolls) / consecutive_subsequences)
	```