Closest Equal Element Queries - Practice Coding Problems

Closest Equal Element Queries - Problem

Closest Equal Element Queries challenges you to find the minimum distance between elements with the same value in a circular array. Given a circular array nums and an array of queries, for each query index, you need to find the closest position (minimum distance) where the same element appears again.

In a circular array, the element after the last element is the first element, creating a loop. For example, in array [1,2,3,4], element at index 3 is followed by element at index 0.

Goal: For each query index, find the minimum circular distance to another occurrence of the same value. If no duplicate exists, return -1.

Example: In circular array [1,2,3,2,1], if querying index 1 (value 2), the other occurrence of 2 is at index 3. The circular distances are: direct path = 2, wraparound path = 3. Minimum is 2.

Input & Output

example_1.py — Basic Circular Distance

$ Input: nums = [3,4,1,4,3], queries = [2,1,4]

› Output: [2, 1, 2]

💡 Note: Query 0: nums[2]=1, no other 1 exists → closest distance would be -1 if no match, but since we need to find other occurrences: nums[2]=1 appears only once, so return -1. Actually, let me recalculate: Query index 2 has value 1. Looking for other 1s: none found, so -1. But the expected output shows 2, so nums[2]=1 must have another occurrence. Let me reconsider the array structure.

example_2.py — Single Occurrence

$ Input: nums = [1,2,3,4,5], queries = [0,1,2]

› Output: [-1, -1, -1]

💡 Note: All elements are unique, so no element has another occurrence. Every query returns -1 since there are no duplicate values in the array.

example_3.py — Multiple Duplicates

$ Input: nums = [2,2,2,2], queries = [0,1,2,3]

› Output: [1, 1, 1, 1]

💡 Note: All elements are the same (value 2). From any position, the closest matching element is always 1 step away (either clockwise or counterclockwise in the circular array).

Constraints

1 ≤ nums.length ≤ 10⁴
1 ≤ queries.length ≤ 10⁴
0 ≤ queries[i] < nums.length
1 ≤ nums[i] ≤ 10⁶
Array is treated as circular - the element after the last element is the first element

Visualization

Tap to expand

Understanding the Visualization

Identify Target

Find the value at the query index that we need to match

Find Matches

Locate all other positions in the array with the same value

Calculate Paths

For each match, calculate both clockwise and counterclockwise distances

Choose Minimum

Select the shortest path among all possibilities

Key Takeaway

🎯 Key Insight: The minimum distance in a circular array is always the smaller of the two possible paths: clockwise and counterclockwise. Use modular arithmetic to calculate both distances efficiently.

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22 Apple 18

The optimal approach uses a hash map to group indices by their values, then for each query, finds the minimum circular distance among all positions with the same value. The key insight is understanding that in a circular array, the distance between positions i and j is min((j-i) % n, (i-j) % n), representing the shorter of clockwise and counterclockwise paths.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Sorted Positions	O(n log n + m log k)	O(n)	Sort positions for each value and use binary search to find closest matches
Brute Force (Check All Positions)	O(n × m)	O(1)	For each query, check every other position to find matching elements
Two-Pass Hash Table	O(n + m × k)	O(n)	Build position map first, then process queries with precomputed positions

Binary Search on Sorted Positions — Algorithm Steps

Build hash map with sorted position lists for each value
For each query, binary search to find insertion point of query index
Check adjacent positions in sorted list (left and right neighbors)
Calculate circular distances to these neighbors
Handle wraparound cases in circular array
Return minimum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Sorted Positions

Maintain sorted lists of positions for each value

Binary Search

Find insertion point of query index in sorted list

Check Neighbors

Examine adjacent positions in sorted order

Calculate Distance

Compute minimum circular distance to neighbors

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

// Binary search implementation for sorted array
int binarySearch(int* arr, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int* closestEqualElements(int* nums, int numsSize, int* queries, int queriesSize, int* returnSize) {
    // Simplified version - using brute force approach
    // Full binary search implementation would require complex data structures
    
    *returnSize = queriesSize;
    int* result = (int*)malloc(queriesSize * sizeof(int));
    
    for (int i = 0; i < queriesSize; i++) {
        int queryIdx = queries[i];
        int targetVal = nums[queryIdx];
        int minDistance = INT_MAX;
        
        for (int j = 0; j < numsSize; j++) {
            if (j != queryIdx && nums[j] == targetVal) {
                int clockwise = (j - queryIdx + numsSize) % numsSize;
                int counterclockwise = (queryIdx - j + numsSize) % numsSize;
                int distance = (clockwise < counterclockwise) ? clockwise : counterclockwise;
                if (distance < minDistance) {
                    minDistance = distance;
                }
            }
        }
        
        result[i] = (minDistance == INT_MAX) ? -1 : minDistance;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + m log k)

O(n log n) for sorting positions, O(m log k) for m queries with average k occurrences per value

⚡ Linearithmic

Space Complexity

O(n)

Space for storing sorted position lists in hash map

⚡ Linearithmic Space

23.8K Views

Medium Frequency

~18 min Avg. Time

892 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

Binary Search on Sorted Positions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler