Is Longest Semi-Repeating Subarray easy or hard?

The problem is generally categorized as Medium. The main difficulty is recognizing that the constraint can be maintained incrementally with a sliding window instead of recomputing counts for every subarray. Once the pattern is recognized, the implementation is straightforward.

Longest Semi-Repeating Subarray Python/Java solution

Most implementations follow the same sliding window logic regardless of language. Maintain left and right pointers, update a duplicate‑pair counter when adjacent values match, shrink the window when the constraint breaks, and update the maximum length. The FleetCode solution includes implementations in Python, Java, C++, Go, TypeScript, and Rust.

How to solve Longest Semi-Repeating Subarray in O(n)?

Use two pointers representing a dynamic window. Expand the right pointer and increase a counter whenever nums[i] equals nums[i-1]. If the counter becomes greater than one, shift the left pointer forward until the window contains at most one adjacent duplicate pair again. Track the maximum window size during the scan.

What is the best approach for Longest Semi-Repeating Subarray?

The sliding window approach is the most efficient method. Maintain two pointers and track how many adjacent equal pairs exist inside the current window. If the count exceeds one, move the left pointer until the window becomes valid again. This keeps the window valid while scanning the array once in O(n) time and O(1) space.

Is Longest Semi-Repeating Subarray asked at Google/Amazon/Meta?

Sliding window array problems like this frequently appear in interviews at companies such as Amazon, Google, and Meta. Variations often involve limiting duplicates, repeated characters, or frequency constraints within a window. Practicing this pattern helps with many real interview questions.

What data structure is used in Longest Semi-Repeating Subarray?

The optimal approach primarily uses the sliding window two‑pointer technique on an array. Only a small integer counter is required to track adjacent duplicate pairs, so no additional data structures are necessary. Some variants may use a hash table if the constraint involves element frequency instead of adjacency.

What is the time complexity of Longest Semi-Repeating Subarray?

The optimal solution runs in O(n) time using a sliding window. Each element enters the window once and leaves at most once while the two pointers move forward. Space complexity remains O(1) because only a small counter for adjacent duplicate pairs is maintained.

3641. Longest Semi-Repeating Subarray - Practice Online

You are given an integer array nums of length n and an integer k.

A semi‑repeating subarray is a contiguous subarray in which at most k elements repeat (i.e., appear more than once).

Return the length of the longest semi‑repeating subarray in nums.

Example 1:

Input: nums = [1,2,3,1,2,3,4], k = 2

Output: 6

Explanation:

The longest semi-repeating subarray is [2, 3, 1, 2, 3, 4], which has two repeating elements (2 and 3).

Example 2:

Input: nums = [1,1,1,1,1], k = 4

Output: 5

Explanation:

The longest semi-repeating subarray is [1, 1, 1, 1, 1], which has only one repeating element (1).

Example 3:

Input: nums = [1,1,1,1,1], k = 0

Output: 1

Explanation:

The longest semi-repeating subarray is [1], which has no repeating elements.

Constraints:

1 <= nums.length <= 10⁵
1 <= nums[i] <= 10⁵
0 <= k <= nums.length