Third Maximum Number - Practice Coding Problems

Third Maximum Number - Problem

Array Sorting Easy

You're given an integer array nums, and your task is to find the third distinct maximum number in the array. Think of it like finding the bronze medalist in a competition!

Here's the catch: if there aren't three distinct maximum numbers (i.e., the array has fewer than 3 unique values), you should return the maximum number instead.

Key Points:

We need distinct maximums - duplicates don't count as separate maximums
If third maximum exists → return it
If third maximum doesn't exist → return the overall maximum

Example: In array [3, 2, 1], the first max is 3, second max is 2, and third max is 1, so we return 1. But in [1, 2], there's no third distinct maximum, so we return the maximum which is 2.

Input & Output

example_1.py — Standard Case

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

› Output: 1

💡 Note: The first distinct maximum is 3, second is 2, and third is 1. Since we have three distinct maximums, we return the third one which is 1.

example_2.py — Insufficient Distinct Values

$ Input: nums = [1, 2]

› Output: 2

💡 Note: We only have two distinct values (1 and 2), so there's no third distinct maximum. Therefore, we return the maximum value which is 2.

example_3.py — Array with Duplicates

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

› Output: 1

💡 Note: The distinct values are [3, 2, 1]. The third distinct maximum is 1. Note that duplicate 2's are treated as a single distinct value.

Visualization

Tap to expand

Understanding the Visualization

Initialize Podium

Set up three empty podium positions: Gold (1st), Silver (2nd), Bronze (3rd)

Process Each Score

For each athlete's score, check if it deserves a podium position and update accordingly

Handle Ties

Skip duplicate scores as they represent the same performance level

Award Bronze

If we have a bronze medalist, return their score; otherwise, return the gold medalist's score

Key Takeaway

🎯 Key Insight: We only need to track the top 3 distinct values, not sort the entire array. This reduces time complexity from O(n log n) to O(n) while using constant space!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element processed in constant time

✓ Linear Growth

Space Complexity

O(1)

Only using three variables regardless of input size

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁴
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
Follow up: Can you find an O(n) time complexity solution?

Asked in

a Amazon 15 G Google 8 ⊞ Microsoft 6 Apple 4

The optimal solution uses one-pass tracking with three variables to maintain the top 3 distinct maximums in O(n) time and O(1) space. This approach is much more efficient than sorting the entire array, as we only need to track the bronze medalist position!

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Tracking (Optimal)	O(n)	O(1)	Track only the top 3 distinct maximums in a single pass
Brute Force (Find All Distinct Values)	O(n log n)	O(n)	Find all unique values, sort them, then return third largest

One-Pass Tracking (Optimal) — Algorithm Steps

Initialize three variables to track 1st, 2nd, and 3rd maximum
For each number, update the maximums if it's larger and distinct
Shift existing maximums down when a new larger value is found
Return third maximum if it exists, otherwise return first maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Trackers

Set first=-∞, second=-∞, third=-∞

Process Each Element

Update trackers when finding larger distinct values

Return Result

Return third if it exists, otherwise return first

Code -

solution.c — C

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

int thirdMax(int* nums, int numsSize) {
    long first = LONG_MIN, second = LONG_MIN, third = LONG_MIN;
    
    for (int i = 0; i < numsSize; i++) {
        int num = nums[i];
        
        // Skip if we've already seen this number
        if (num == first || num == second || num == third) {
            continue;
        }
        
        if (num > first) {
            third = second;
            second = first;
            first = num;
        } else if (num > second) {
            third = second;
            second = num;
        } else if (num > third) {
            third = num;
        }
    }
    
    return third != LONG_MIN ? (int)third : (int)first;
}

int main() {
    int nums[] = {3, 2, 1};
    int size = 3;
    printf("%d\n", thirdMax(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element processed in constant time

✓ Linear Growth

Space Complexity

O(1)

Only using three variables regardless of input size

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁴
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
Follow up: Can you find an O(n) time complexity solution?

78.5K Views

Medium Frequency

~15 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler