Largest Unique Number - Practice Coding Problems

Largest Unique Number - Problem

Given an integer array nums, return the largest integer that only occurs once. If no integer occurs exactly once, return -1.

An integer occurs once if it appears exactly one time in the array, meaning it has no duplicates.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Numbers 2 and 1 each appear twice, but 3 appears only once. Since 3 is the largest unique number, return 3.

Example 2 — No Unique Numbers

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

› Output: -1

💡 Note: Every number appears exactly twice, so there are no unique numbers. Return -1.

Example 3 — Single Element

$ Input: nums = [5]

› Output: 5

💡 Note: The array has only one element, which appears exactly once, so return 5.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input Array

Array with some duplicate numbers

Count Frequencies

Identify which numbers appear exactly once

Find Maximum

Return the largest unique number

Key Takeaway

🎯 Key Insight: Use frequency counting to identify unique elements, then find the maximum among them

Asked in

a Amazon 25 G Google 18 f Facebook 12

The key insight is to count the frequency of each number and find the largest one that appears exactly once. The best approach uses a hash map to count frequencies in O(n) time, then scans for the maximum unique element. Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Sort First	O(n log n)	O(1)	Sort the array, then scan from right to left to find the largest unique element
Frequency Count (Hash Map)	O(n)	O(n)	Count frequencies with a hash map, then find the largest unique element
Brute Force	O(n²)	O(1)	For each number, count its occurrences and track the largest unique one

Sort First — Algorithm Steps

Sort the array in ascending order
Iterate from right to left (largest to smallest)
For each element, check if it's unique (different from neighbors)
Return the first unique element found, or -1 if none exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort elements in ascending order

Check from Right

Start from largest element

Find Unique

Return first unique element found

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int solution(int* nums, int numsSize) {
    if (numsSize == 0) return -1;
    
    qsort(nums, numsSize, sizeof(int), compare);
    
    // Check from right to left to find largest unique
    for (int i = numsSize - 1; i >= 0; i--) {
        int isUnique = 1;
        
        // Check left neighbor
        if (i > 0 && nums[i] == nums[i - 1]) {
            isUnique = 0;
        }
        
        // Check right neighbor
        if (i < numsSize - 1 && nums[i] == nums[i + 1]) {
            isUnique = 0;
        }
        
        if (isUnique) {
            return nums[i];
        }
    }
    
    return -1;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[1000];
    int numsSize = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), then single pass through array takes O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables, sorting is done in-place

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Sort First — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler