Most Frequent Number Following Key In an Array

Most Frequent Number Following Key In an Array - Problem

Imagine you're analyzing a sequence of events where you want to find patterns of what happens immediately after a specific trigger event occurs.

You are given a 0-indexed integer array nums and an integer key that is guaranteed to be present in the array. Your task is to find which number appears most frequently immediately after the key.

Specifically:

For every occurrence of key at index i (where i < nums.length - 1)
Look at the next element nums[i + 1]
Count how many times each unique number appears in these "next" positions
Return the number with the highest count

Example: If nums = [1, 100, 200, 1, 100] and key = 1, then after the first occurrence of 1, we see 100, and after the second occurrence of 1, we also see 100. So 100 appears 2 times after key, making it our answer.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,100,200,1,100], key = 1

› Output: 100

💡 Note: The key 1 appears at indices 0 and 3. After index 0, the next number is 100. After index 3, the next number is also 100. So 100 appears 2 times after key, making it the most frequent.

example_2.py — Multiple Targets

$ Input: nums = [2,2,2,2,3], key = 2

› Output: 2

💡 Note: The key 2 appears at indices 0, 1, 2, and 3. The next numbers are 2, 2, 2, and 3 respectively. Number 2 appears 3 times after key, while 3 appears only once. So 2 is the most frequent.

example_3.py — Single Occurrence

$ Input: nums = [1,1000,2], key = 1

› Output: 1000

💡 Note: The key 1 appears only at index 0, and the next number is 1000. Since 1000 is the only number following key, it's the most frequent (and only) target.

Constraints

2 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
key is guaranteed to be present in nums
The test cases guarantee that the target with maximum count is unique

Visualization

Tap to expand

Understanding the Visualization

Scan Purchase History

Go through all purchases in chronological order

Identify Key Purchases

When you see the key product being bought, look at the very next purchase

Count Next Purchases

Keep a tally of what products are bought immediately after the key product

Find Most Popular

The product with the highest count is the most frequent 'next purchase'

Key Takeaway

🎯 Key Insight: Pattern detection in sequential data can be solved efficiently by tracking frequencies during a single scan, making it perfect for real-time analysis of customer behavior, user interactions, or any sequential event data.

Asked in

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

The optimal solution uses a hash table in a single pass to count frequencies of targets that follow the key. As we iterate through the array, whenever we find the key, we increment the count for the next element and track the maximum frequency simultaneously, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Approach)	O(n²)	O(k)	Find all targets following key, then count each target's frequency separately
One-Pass Hash Table (Optimal)	O(n)	O(k)	Count frequencies of targets following key in a single pass through the array

Brute Force (Nested Approach) — Algorithm Steps

Scan array to find all unique numbers that appear immediately after key
For each unique target number, scan the array again
Count how many times this target appears right after key
Keep track of the target with maximum count
Return the most frequent target

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Unique Targets

First scan to collect all unique numbers that appear after key

Count Each Target

For each unique target, scan array again to count occurrences

Track Maximum

Keep track of the target with highest count

Code -

solution.c — C

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

int mostFrequent(int* nums, int numsSize, int key) {
    if (numsSize < 2) return -1;
    
    // Simple approach: try each possible target
    int maxCount = 0;
    int result = -1;
    
    // Check each position that could be a target
    for (int j = 0; j < numsSize - 1; j++) {
        if (nums[j] == key) {
            int target = nums[j + 1];
            int count = 0;
            
            // Count this target
            for (int i = 0; i < numsSize - 1; i++) {
                if (nums[i] == key && nums[i + 1] == target) {
                    count++;
                }
            }
            
            if (count > maxCount) {
                maxCount = count;
                result = target;
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might have O(n) unique targets, and for each we scan the entire array O(n), giving us O(n²)

⚠ Quadratic Growth

Space Complexity

O(k)

Only need to store unique targets that follow key, where k is the number of unique followers (at most n-1)

✓ Linear Space

38.2K Views

Medium Frequency

~12 min Avg. Time

890 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 (Nested Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler