Find Occurrences of an Element in an Array

Find Occurrences of an Element in an Array - Problem

Imagine you're a data analyst working with search logs, and you need to quickly find the nth occurrence of specific search terms across your database. This problem captures that exact scenario!

You are given an integer array nums, an integer array queries, and a target integer x. For each query queries[i], you need to find the index where the queries[i]-th occurrence of x appears in the nums array.

Key Rules:

If there are fewer than queries[i] occurrences of x, return -1 for that query
Occurrences are counted from left to right (1st, 2nd, 3rd, etc.)
Return an integer array containing answers to all queries

Example: If nums = [1, 3, 1, 7, 1], x = 1, and queries = [1, 3, 2], then the 1st occurrence of 1 is at index 0, the 3rd occurrence is at index 4, and the 2nd occurrence is at index 2. Answer: [0, 4, 2]

Input & Output

example_1.py — Basic Case

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

› Output: [0,4,2]

💡 Note: The 1st occurrence of x = 1 is at index 0. The 3rd occurrence of x = 1 is at index 4. The 2nd occurrence of x = 1 is at index 2.

example_2.py — Query Exceeds Occurrences

$ Input: nums = [1,2,3], queries = [10], x = 5

› Output: [-1]

💡 Note: x = 5 doesn't appear in nums, so the 10th occurrence doesn't exist. Return -1.

example_3.py — Mixed Valid and Invalid Queries

$ Input: nums = [5,2,5,4], queries = [2,4], x = 5

› Output: [2,-1]

💡 Note: The 2nd occurrence of x = 5 is at index 2. The 4th occurrence doesn't exist since x only appears twice.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
1 ≤ queries[i] ≤ 10⁵
1 ≤ nums[i], x ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Create Index

Walk through the library once and note all positions where 'Harry Potter' appears

Answer Queries

When someone asks for the 2nd copy, instantly look up position from our index

Handle Missing

If someone asks for the 5th copy but we only have 3, return 'Not Found'

Key Takeaway

🎯 Key Insight: Preprocessing data once allows us to answer multiple queries efficiently, transforming O(n×m) brute force into O(n+m) optimal solution!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses preprocessing to solve this problem efficiently. First, we scan the array once to collect all indices where the target element x appears. Then, for each query asking for the nth occurrence, we can answer in O(1) time by looking up positions[n-1]. This gives us O(n + m) total time complexity compared to the brute force O(n × m) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Search for Each Query)	O(n × m)	O(1)	For each query, scan the entire array to find the nth occurrence
Precompute Positions (Optimal)	O(n + m)	O(k)	First pass: collect all positions of x, Second pass: answer queries using the positions list

Brute Force (Search for Each Query) — Algorithm Steps

For each query q in queries array
Initialize counter = 0 and scan nums from index 0
When we find x, increment counter
When counter equals q, return current index
If we finish scanning without finding q occurrences, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Query 1: Find 1st occurrence

Scan array counting occurrences of target until we find the 1st one

Query 2: Find 3rd occurrence

Start over, scan array again counting until we find the 3rd occurrence

Query 3: Find 2nd occurrence

Start over again, scan until we find the 2nd occurrence

Code -

solution.c — C

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

int* occurrencesOfElement(int* nums, int numsSize, int* queries, int queriesSize, int x, int* returnSize) {
    *returnSize = queriesSize;
    int* result = (int*)malloc(queriesSize * sizeof(int));
    
    for (int q = 0; q < queriesSize; q++) {
        int count = 0;
        int foundIndex = -1;
        
        for (int i = 0; i < numsSize; i++) {
            if (nums[i] == x) {
                count++;
                if (count == queries[q]) {
                    foundIndex = i;
                    break;
                }
            }
        }
        
        result[q] = foundIndex;
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of the m queries, we potentially scan the entire array of size n

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting and indexing

✓ Linear Space

42.5K Views

Medium Frequency

~15 min Avg. Time

1.3K 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 (Search for Each Query) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler