You are given an integer array nums.

Your task is to find the smallest positive integer that satisfies both of the following conditions:

1. It is absent from nums — meaning it does not appear anywhere in the array.
2. It is strictly greater than the average of all elements in nums.

The average of the array is defined as the sum of all its elements divided by the number of elements, i.e., sum(nums) / len(nums). Note that the average can be a fractional value, and it can also be negative or zero if the array contains negative numbers.

Return that smallest absent positive integer.

Example

Suppose nums = [3, 5]:

• The average is (3 + 5) / 2 = 4.
• We need a positive integer strictly greater than 4 that is not in the array.
• 5 is greater than 4, but it appears in nums, so it is skipped.
• 6 is greater than 4 and absent from nums, so the answer is 6.

Suppose nums = [-1, -2, -3]:

• The average is -2.
• Any positive integer is already strictly greater than -2.
• The smallest positive integer is 1, and since 1 does not appear in nums, the answer is 1.

Key Points

• The answer must always be a positive integer (at least 1), even if the average is negative.
• The answer must be strictly greater than the average — being equal to it is not enough.
• The answer must not exist in the array.

The problem gives us two constraints on the answer: it must be strictly greater than the average, and it must be absent from the array. The natural idea is to first figure out the smallest possible candidate, then move upward until we find a valid one.

Let's think about where to start searching:

• The answer must be a positive integer, so it is at least 1.
• The answer must be strictly greater than the average avg. The smallest integer strictly greater than avg is ⌊avg⌋ + 1. This works for both fractional averages (e.g., avg = 3.5 gives 4) and exact integer averages (e.g., avg = 4 gives 5, since equality is not allowed).

Combining both conditions, the smallest candidate worth checking is max(1, ⌊avg⌋ + 1). Anything smaller is guaranteed to violate at least one of the two conditions, so there is no reason to look below this value.

Now we only need to handle the "absent" condition. Starting from this candidate, we check whether it exists in the array. If it does, we try the next integer, and so on. Since checking membership in a list is O(n) per query, we put all elements into a hash set first, which makes each lookup O(1).

One more observation guarantees this loop terminates quickly: the array has only n elements, so at most n consecutive candidates can be blocked. Within at most n + 1 steps starting from max(1, ⌊avg⌋ + 1), we are certain to hit a number that is absent from the array. This bounds the total work at O(n) and confirms that a simple linear scan upward is efficient enough — no sorting or complex search is needed.

We implement the idea in three clear steps, using a hash set as the core data structure.

Step 1: Build a hash set of the elements

s = set(nums)

We store all elements of nums in a set s. This allows us to check whether a candidate number exists in the array in O(1) average time, instead of scanning the whole list for every check.

Step 2: Compute the starting candidate

ans = max(1, sum(nums) // len(nums) + 1)

This single line combines both constraints into the smallest possible starting point:

• sum(nums) // len(nums) is the floor of the average, ⌊avg⌋. In Python, the // operator performs floor division, which rounds toward negative infinity, so this works correctly even when the sum is negative (e.g., -5 // 2 = -3).
• Adding 1 gives ⌊avg⌋ + 1, the smallest integer strictly greater than the average. This holds in both cases:
  • If avg is fractional (say 3.5), then ⌊avg⌋ + 1 = 4 > 3.5. ✓
  • If avg is an exact integer (say 4), then ⌊avg⌋ + 1 = 5 > 4, correctly skipping 4 itself since equality is forbidden. ✓
• Wrapping it in max(1, ...) enforces the positive requirement: if the average is negative or zero, the candidate could drop below 1, so we clamp it up to 1.

Step 3: Scan upward until the candidate is absent

while ans in s:
    ans += 1
return ans

Starting from the candidate, we repeatedly check membership in the set. If the current value exists in nums, we move to the next integer. The loop is guaranteed to stop within at most n + 1 iterations, because the set contains only n elements and cannot block more than n consecutive integers.

Complete Code

class Solution:
    def smallestAbsent(self, nums: List[int]) -> int:
        s = set(nums)
        ans = max(1, sum(nums) // len(nums) + 1)
        while ans in s:
            ans += 1
        return ans

Complexity Analysis

Let n be the length of nums.

• Time complexity: O(n) — building the set takes O(n), computing the sum takes O(n), and the while loop runs at most n + 1 times with O(1) lookups each.
• Space complexity: O(n) — the hash set stores up to n distinct elements.