Minimum Subarray with K Distinct Integers

The closest widely available problem matching your description is “Smallest subarray with k distinct numbers,” which is a sliding-window, array, hash-table problem and appears in interview-prep lists for major companies, but the specific Adobe-labeled problem “Minimum Subarray with K Distinct Integers” on HackTheRounds is paywalled and does not expose its full statement, examples, or constraints publicly. Because of that, we cannot retrieve or reconstruct its exact official wording or test set; we can only use open versions of the same underlying problem.[1]

Publicly available version of the problem

A fully visible version of this problem is given as:

You are given an array of $$n$$ integers and an integer $$k$$. Find the smallest subarray $$[l, r]$$ (both $$l$$ and $$r$$ inclusive) such that there are exactly $$k$$ different numbers in this subarray. If no such subarray exists, print $$-1$$. If multiple subarrays meet the criteria, return the one with the smallest starting index.

This matches your tags: Array (array of integers), Hash Table (map/set to count distinct), Sliding Window (two-pointer window maintained over the array).

Input / output format and examples

The GeeksforGeeks statement provides the task in narrative form; its examples make the expected I/O behavior clear.

Examples:

• Input: arr[] = {1, 1, 2, 2, 3, 3, 4, 5}, k = 3
• Output: 5 7
• Explanation: The subarray from index 5 to 7 (0-based) has exactly 3 distinct numbers with minimal length among all such subarrays.

• Input: arr[] = {1, 2, 2, 3}, k = 2
• Output: 0 1
• Explanation: A subarray with exactly 2 distinct numbers and minimal length starts at index 0; among subarrays with minimal length, the one with smallest starting index is chosen.

• Input: arr[] = {1, 1, 2, 1, 2}, k = 3
• Output: Invalid k or -1
• Explanation: The array never contains a subarray with exactly 3 distinct numbers, so we report that no valid subarray exists.

In the same article, the implementations print -1 when no such subarray exists (rather than the text “Invalid k”), so you should expect the canonical behavior to be to output -1 in that case.

Typical competitive-programming style formats this as:

• Input:
  • First line: integer $$n$$ and integer $$k$$.
  • Second line: $$n$$ integers $$a_1, a_2, \dots, a_n$$.
• Output:
  • Either two integers $$l$$ and $$r$$ (0-based or 1-based indices, depending on platform) denoting the minimal subarray with exactly $$k$$ distinct integers, or -1 if no such subarray exists.

Because the Adobe/HackTheRounds problem is not publicly visible, its exact input format (0-based vs 1-based indices, error string vs -1) may differ, but the underlying behavior (minimum-length subarray with exactly $$k$$ distinct values, tie-breaking by smallest start) aligns with the version above.[1]

Constraints (from open version)

The article provides two approaches (naive $$O(n^2)$$ and expected sliding-window $$O(n)$$), and describes time and space expectations rather than explicit numeric bounds. From the use of a linear-time sliding window with hash map and from typical GeeksforGeeks constraint patterns, reasonable implied constraints are:

• $$1 \le n$$ (array length).
• $$1 \le k \le n$$.
• Elements of arr are integers (examples use small positive integers, but the algorithm handles arbitrary integer values).
• Expected time complexity: $$O(n)$$ using sliding window and a hash map to count frequencies.
• Expected extra space: $$O(k)$$ for the hash map/set of distinct elements in the window.

No stricter numeric ranges (like $$n \le 2 \cdot 10^5$$) are explicitly stated in the open statement.

Why the exact Adobe version cannot be reproduced

The HackTheRounds Adobe question list only shows the title “Minimum Subarray with K Distinct Integers” with meta-info (difficulty and round), and the actual statement and examples are behind a logged-in/paywalled “PRO” section. That means:[1]

• The full official wording, I/O format, exact constraints, and all platform-provided examples for that Adobe-branded instance are not accessible from the open internet.
• Any attempt to give “the” Adobe statement, with all its examples and constraints, would be a guess based on similar public problems, not a faithful reproduction of that private content.[1]

If you need to prepare for this interview question, you can confidently study and implement the “Smallest subarray with k distinct numbers” problem as described above, using an array + hash map + sliding window solution; this matches the same core problem and expected approach.