Largest Unique Number

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

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

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force

⏱️ Time: O(n²) Space: O(1)

For every number in the array, scan the entire array to count how many times it appears. If it appears exactly once and is larger than our current answer, update the result.

Frequency Count (Hash Map)

⏱️ Time: O(n) Space: O(n)

Use a hash map to count the frequency of each number in a single pass. Then iterate through the frequency map to find the largest number that appears exactly once.

Sort First

⏱️ Time: O(n log n) Space: O(1)

Sort the array in ascending order, then iterate from the largest element to the smallest. For each element, check if it's different from its neighbors to determine uniqueness.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int commonSuffixLength(const char* s1, const char* s2) {
    int len1 = strlen(s1), len2 = strlen(s2);
    int i = len1 - 1, j = len2 - 1;
    int length = 0;
    while (i >= 0 && j >= 0 && s1[i] == s2[j]) {
        length++;
        i--;
        j--;
    }
    return length;
}

int* solution(char wordsContainer[][5001], int containerSize, char wordsQuery[][5001], int querySize, int* returnSize) {
    *returnSize = querySize;
    int* result = (int*)malloc(querySize * sizeof(int));
    
    for (int q = 0; q < querySize; q++) {
        int bestIdx = 0;
        int bestSuffixLen = commonSuffixLength(wordsContainer[0], wordsQuery[q]);
        int bestWordLen = strlen(wordsContainer[0]);
        
        for (int i = 1; i < containerSize; i++) {
            int suffixLen = commonSuffixLength(wordsContainer[i], wordsQuery[q]);
            int wordLen = strlen(wordsContainer[i]);
            
            if (suffixLen > bestSuffixLen || 
                (suffixLen == bestSuffixLen && wordLen < bestWordLen) ||
                (suffixLen == bestSuffixLen && wordLen == bestWordLen && i < bestIdx)) {
                bestIdx = i;
                bestSuffixLen = suffixLen;
                bestWordLen = wordLen;
            }
        }
        
        result[q] = bestIdx;
    }
    return result;
}

char* parseString(char* input, int* pos) {
    while (input[*pos] && (input[*pos] == ' ' || input[*pos] == '[' || input[*pos] == ',' || input[*pos] == '"')) (*pos)++;
    if (!input[*pos] || input[*pos] == ']') return NULL;
    
    int start = *pos;
    while (input[*pos] && input[*pos] != '"' && input[*pos] != ',' && input[*pos] != ']') (*pos)++;
    
    char* result = (char*)malloc((*pos - start + 1) * sizeof(char));
    strncpy(result, input + start, *pos - start);
    result[*pos - start] = '\0';
    
    if (input[*pos] == '"') (*pos)++;
    return result;
}

int main() {
    char line[100000];
    char wordsContainer[10000][5001], wordsQuery[10000][5001];
    int containerSize = 0, querySize = 0;
    
    // Read first line
    fgets(line, sizeof(line), stdin);
    int pos = 0;
    char* word;
    while ((word = parseString(line, &pos)) != NULL) {
        strcpy(wordsContainer[containerSize++], word);
        free(word);
    }
    
    // Read second line  
    fgets(line, sizeof(line), stdin);
    pos = 0;
    while ((word = parseString(line, &pos)) != NULL) {
        strcpy(wordsQuery[querySize++], word);
        free(word);
    }
    
    int returnSize;
    int* result = solution(wordsContainer, containerSize, wordsQuery, querySize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ 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