Find the Largest Almost Missing Integer

Find the Largest Almost Missing Integer - Problem

You are given an integer array nums and an integer k. An integer x is almost missing from nums if x appears in exactly one subarray of size k within nums.

Return the largest almost missing integer from nums. If no such integer exists, return -1.

A subarray is a contiguous sequence of elements within an array.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Subarrays: [1,2,3], [2,3,2], [3,2,4]. Number 4 appears in exactly one subarray [3,2,4], and it's the largest such number.

Example 2 — No Almost Missing

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

› Output: -1

💡 Note: All subarrays: [1,2], [2,3], [3,1], [1,2], [2,3]. Every unique number appears in multiple subarrays, so no almost missing integer exists.

Example 3 — Single Element Window

$ Input: nums = [5,3,7,3,5], k = 1

› Output: 7

💡 Note: Each element forms its own subarray. Number 7 appears in exactly one subarray and is the largest among such numbers.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ k ≤ nums.length
-1000 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12

The key insight is to count how many subarrays of size k contain each number, then find the largest number that appears in exactly one subarray. Best approach uses frequency counting with hash map. Time: O(n×k), Space: O(n)

Common Approaches

✓ Brute Force

⏱️ Time: O(n×k) Space: O(n)

For each possible subarray of size k, track which numbers appear and count their occurrences across all subarrays. Then find the largest number that appears exactly once.

Optimized Frequency Tracking

⏱️ Time: O(n×k) Space: O(n)

Use a more streamlined approach where we generate each subarray once and directly update frequency counts, then find the largest number with frequency 1 in a single pass.

Sliding Window Optimization

⏱️ Time: O(n×k) Space: O(n)

Instead of regenerating each subarray from scratch, use a sliding window approach where we add one element and remove one element as we move the window, maintaining frequency counts efficiently.

Brute Force — Algorithm Steps

Generate all subarrays of size k
For each subarray, track which numbers appear
Count total occurrences of each number
Return largest number with count = 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Create all possible subarrays of size k

Count Frequencies

Track how many subarrays contain each number

Find Maximum

Return largest number appearing exactly once

Code -

solution.c — C

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

static int nums[1001];
static int count[10001]; // For values -1000 to 1000, offset by 5000

int solution(int* nums, int n, int k) {
    if (n < k) {
        return -1;
    }
    
    // Clear count array
    for (int i = 0; i < 10001; i++) {
        count[i] = 0;
    }
    
    // Generate all subarrays of size k
    for (int i = 0; i <= n - k; i++) {
        // Count unique numbers in this subarray using a simple check
        int visited[10001] = {0};
        
        for (int j = i; j < i + k; j++) {
            int idx = nums[j] + 5000; // Offset for negative numbers
            if (!visited[idx]) {
                visited[idx] = 1;
                count[idx]++;
            }
        }
    }
    
    // Find numbers that appear in exactly one subarray
    int maxAlmostMissing = INT_MIN;
    int found = 0;
    
    for (int i = 0; i < 10001; i++) {
        if (count[i] == 1) {
            int actualNum = i - 5000;
            if (actualNum > maxAlmostMissing) {
                maxAlmostMissing = actualNum;
            }
            found = 1;
        }
    }
    
    return found ? maxAlmostMissing : -1;
}

int main() {
    char line[10000];
    int k;
    
    fgets(line, sizeof(line), stdin);
    scanf("%d", &k);
    
    // Parse array from string format [1,2,3,2,4]
    int n = 0;
    char* ptr = line;
    
    // Skip the opening bracket
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    // Parse numbers
    while (*ptr && *ptr != ']') {
        while (*ptr == ' ' || *ptr == ',') ptr++;
        if (*ptr == ']' || *ptr == '\0' || *ptr == '\n') break;
        
        nums[n] = (int)strtol(ptr, &ptr, 10);
        n++;
    }
    
    printf("%d\n", solution(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×k)

Generate n-k+1 subarrays, process k elements in each

✓ Linear Growth

Space Complexity

O(n)

Hash map stores frequency count for each unique number

⚡ Linearithmic Space

8.4K Views

Medium Frequency

~15 min Avg. Time

245 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler