Smallest Missing Non-negative Integer After Operations

Smallest Missing Non-negative Integer After Operations - Problem

You're given an integer array nums and a special value. Your mission is to maximize the MEX (minimum excluded value) of the array by strategically adding or subtracting the given value from any elements.

What is MEX? The MEX of an array is the smallest non-negative integer that doesn't appear in the array. For example:

MEX of [-1, 2, 3] is 0 (since 0 is missing)
MEX of [1, 0, 3] is 2 (since 2 is missing)

Operations allowed: You can perform unlimited operations where each operation adds or subtracts value from any array element.

Example: If nums = [1, 2, 3] and value = 2, you could subtract 2 from the first element to get [-1, 2, 3], making the MEX = 0.

🎯 Goal: Return the maximum possible MEX after performing any number of operations.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, -10, 7, 13, 6, 8], value = 5

› Output: 4

💡 Note: We can transform: 1→1, -10→0 (add 10=2×5), 7→2 (subtract 5), 13→3 (subtract 10=2×5), giving us [1, 0, 2, 3, 6, 8]. The MEX is 4 since we have {0, 1, 2, 3} but missing 4.

example_2.py — All Same Remainder

$ Input: nums = [1, 4, 7, 10], value = 3

› Output: 1

💡 Note: All numbers have remainder 1 when divided by 3. We can only create one number with remainder 0 by transforming one element. Best we can do is [0, 4, 7, 10] → MEX = 1.

example_3.py — Edge Case Small Array

$ Input: nums = [3], value = 1

› Output: 1

💡 Note: We can transform 3 to 0 (subtract 3×1), giving us [0]. The MEX is 1 since we have 0 but missing 1.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
1 ≤ value ≤ 10⁵
The answer is guaranteed to be in the range [0, nums.length]

Visualization

Tap to expand

Understanding the Visualization

Group Your Tokens

Sort tokens into buckets based on their remainder when divided by the increment value

Fill Slots Greedily

Starting from slot 0, use tokens from the appropriate bucket to fill each consecutive slot

Find First Empty

The first slot you can't fill gives you the maximum MEX

Key Takeaway

🎯 Key Insight: Elements with the same remainder modulo `value` can be transformed into each other. Group by remainder, then greedily assign to consecutive positions for optimal MEX.

Asked in

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

The optimal solution uses modular arithmetic and greedy assignment. Key insight: elements can be converted to each other if they have the same remainder when divided by value. We group elements by remainder, then greedily fill consecutive positions starting from 0. Time: O(n), Space: O(min(n, value)).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(k^n * n)	O(k^n)	Try all possible operations and find maximum MEX
One-Pass Hash Table (Optimal)	O(n)	O(min(n, value))	Group elements by remainder modulo value, then greedily assign to consecutive slots

Brute Force (Try All Combinations) — Algorithm Steps

For each array element, generate all possible values by adding/subtracting 'value' multiple times
Try all combinations of these generated values
For each combination, calculate the MEX
Return the maximum MEX found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Options

For each element, generate multiple values by adding/subtracting 'value'

Try Combinations

Recursively try all combinations of generated values

Calculate MEX

For each complete combination, find the MEX

Track Maximum

Keep track of the highest MEX found

Code -

solution.c — C

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

int calculateMEX(int* arr, int size) {
    bool seen[10000] = {false};  // Limited range
    for (int i = 0; i < size; i++) {
        if (arr[i] >= 0 && arr[i] < 10000) {
            seen[arr[i]] = true;
        }
    }
    
    int mex = 0;
    while (mex < 10000 && seen[mex]) {
        mex++;
    }
    return mex;
}

int backtrack(int* nums, int numsSize, int value, int index, int* current, int currentSize) {
    if (index == numsSize) {
        return calculateMEX(current, currentSize);
    }
    
    int maxMex = 0;
    int original = nums[index];
    for (int operations = -10; operations <= 10; operations++) {
        int newVal = original + operations * value;
        current[currentSize] = newVal;
        int mex = backtrack(nums, numsSize, value, index + 1, current, currentSize + 1);
        if (mex > maxMex) {
            maxMex = mex;
        }
    }
    
    return maxMex;
}

int findSmallestInteger(int* nums, int numsSize, int value) {
    int* current = (int*)malloc(numsSize * sizeof(int));
    int result = backtrack(nums, numsSize, value, 0, current, 0);
    free(current);
    return result;
}

int main() {
    // Input parsing implementation
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n * n)

k possible values per element, n elements, O(n) to calculate MEX for each combination

✓ Linear Growth

Space Complexity

O(k^n)

Need to store all possible combinations

⚡ Linearithmic Space

78.4K Views

High Frequency

~25 min Avg. Time

1.8K 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler