Find the Largest Almost Missing Integer - Practice Coding Problems

Find the Largest Almost Missing Integer - Problem

Find the Largest Almost Missing Integer

You are given an integer array nums and an integer k. Your task is to find the largest almost missing integer from the array.

An integer x is considered almost missing if it appears in exactly one subarray of size k within nums. In other words, when you slide a window of size k across the array, the integer x should appear in only one of these windows.

Goal: Return the largest such integer. If no almost missing integer exists, return -1.

Example: For nums = [1, 2, 3, 2, 4] and k = 3, the subarrays are [1,2,3], [2,3,2], and [3,2,4]. The number 4 appears in exactly one subarray, making it almost missing.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: Subarrays of size 3 are: [1,2,3], [2,3,2], [3,2,4]. Number 1 appears in 1 subarray, number 4 appears in 1 subarray. The largest almost missing integer is 4.

example_2.py — No Almost Missing

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

› Output: -1

💡 Note: Subarrays of size 2 are: [1,1], [1,1], [1,1]. Number 1 appears in all 3 subarrays, so there are no almost missing integers.

example_3.py — Multiple Almost Missing

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

› Output: 5

💡 Note: Subarrays of size 2 are: [5,1], [1,2], [2,3], [3,4]. Numbers 5 and 4 each appear in exactly one subarray. The largest is 5.

Constraints

1 ≤ nums.length ≤ 10⁴
1 ≤ k ≤ nums.length
-10⁴ ≤ nums[i] ≤ 10⁴
Numbers can be negative

Visualization

Tap to expand

Understanding the Visualization

Position Window

Place a window of size k at the beginning of the array

Count Unique Numbers

For current window, add each unique number to frequency map

Slide Window

Move window one position right and repeat counting

Find Maximum

Among numbers with frequency = 1, return the largest

Key Takeaway

🎯 Key Insight: By using a sliding window and frequency counting, we can efficiently identify numbers that appear in exactly one subarray, then simply return the maximum among them.

Asked in

G Google 23 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal approach uses a two-pass hash table to efficiently count occurrences of each number across all subarrays of size k. The key insight is that we only need to track unique numbers within each subarray, not their individual positions. This reduces time complexity to O(n × k) while maintaining clear, readable code.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n² × k)	O(n × k)	Generate all subarrays and count occurrences for each number
Two-Pass Hash Table	O(n × k)	O(n × k)	First pass counts frequencies, second pass finds the maximum almost missing

Brute Force (Nested Loops) — Algorithm Steps

Generate all subarrays of size k
Collect all unique numbers from these subarrays
For each unique number, count in how many subarrays it appears
Find the maximum number that appears in exactly one subarray

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Create all possible subarrays of size k

Collect Numbers

Gather all unique numbers from subarrays

Count Occurrences

For each number, count how many subarrays contain it

Find Maximum

Return the largest number with count = 1

Code -

solution.c — C

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

int findLargestAlmostMissing(int* nums, int numsSize, int k) {
    if (numsSize < k) return -1;
    
    int maxVal = INT_MIN;
    
    // Find range of values
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    // Count frequency for each number
    int* freq = (int*)calloc(maxVal + 1001, sizeof(int)); // Handle negative numbers
    int offset = 1000;
    
    // Generate all subarrays and count frequencies
    for (int i = 0; i <= numsSize - k; i++) {
        int* seen = (int*)calloc(maxVal + 1001, sizeof(int));
        for (int j = i; j < i + k; j++) {
            if (!seen[nums[j] + offset]) {
                seen[nums[j] + offset] = 1;
                freq[nums[j] + offset]++;
            }
        }
        free(seen);
    }
    
    int result = -1;
    for (int i = 0; i < maxVal + 1001; i++) {
        if (freq[i] == 1) {
            int actualVal = i - offset;
            if (actualVal > result) {
                result = actualVal;
            }
        }
    }
    
    free(freq);
    return result;
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    
    printf("%d\n", findLargestAlmostMissing(nums, n, k));
    
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × k)

O(n-k+1) subarrays, for each number we check all O(n-k+1) subarrays, each check takes O(k) time

⚠ Quadratic Growth

Space Complexity

O(n × k)

Storage for all unique numbers found in subarrays

⚡ Linearithmic Space

28.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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler