Identify the Largest Outlier in an Array - Practice Coding Problems

Identify the Largest Outlier in an Array - Problem

You are given an integer array nums containing n elements with a special structure:

n - 2 elements are special numbers
1 element is the sum of all special numbers
1 element is an outlier (neither special nor the sum)

Your task is to identify and return the largest potential outlier in the array.

Key Rules:

All elements must have distinct indices (but can share the same value)
The outlier is any number that isn't a special number or the sum element
You need to find the maximum possible outlier value

Example: In array [2, 1, 3, 4], if special numbers are [2, 1], then sum = 3, making 4 the outlier.

Input & Output

example_1.py — Basic Case

$ Input: [2, 1, 3, 4]

› Output: 4

💡 Note: Special numbers: [2, 1], Sum: 3, Outlier: 4. Since 4 is the largest (and only) outlier, return 4.

example_2.py — Multiple Candidates

$ Input: [-2, -1, -3, -6, 4]

› Output: 4

💡 Note: Special numbers: [-2, -1], Sum: -3, Outlier: 4. Alternative: [-2, -1, -6], Sum: -9 (not in array). So 4 is the largest outlier.

example_3.py — Same Values

$ Input: [1, 1, 1, 1, 1, 5]

› Output: 5

💡 Note: Special numbers: [1, 1, 1, 1] (sum=4), but 4 is not in array. Try [1] as special (sum=1), then 1 exists as sum, making 5 the outlier.

Visualization

Tap to expand

Understanding the Visualization

Catalog Evidence

Count all items and calculate total value in the evidence box

Test Suspicions

For each item, assume it's suspicious and check if remaining items form valid receipt-total pair

Verify Mathematics

Use the constraint that total bill equals sum of individual receipts

Find Largest Culprit

Among all valid suspicious items, identify the one with maximum value

Key Takeaway

🎯 Key Insight: Use the mathematical relationship between total sum, outlier, and sum element to instantly verify each candidate without checking all combinations.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array: build frequency map and check each outlier candidate in the same iteration

✓ Linear Growth

Space Complexity

O(n)

Hash map to store frequency of unique elements, worst case all elements are unique

⚡ Linearithmic Space

Constraints

3 ≤ nums.length ≤ 10⁵
-1000 ≤ nums[i] ≤ 1000
The input guarantees at least one valid outlier exists
All elements may have the same value
Exactly one valid configuration exists for the array structure

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22 Apple 18

The optimal solution uses a hash table to solve this in O(n) time. Key insight: if we know the outlier, we can calculate the required sum element using the formula sum_element = (total_sum - outlier) / 2. We build a frequency map and for each potential outlier, verify if the required sum element exists with proper frequency.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Build frequency map and find outliers simultaneously in a single pass
Two-Pass Hash Table	O(n)	O(n)	Build frequency map first, then efficiently check each outlier candidate
Brute Force (Triple Nested Approach)	O(n³)	O(1)	Try every possible combination of outlier, sum, and special numbers

One-Pass Hash Table (Optimal) — Algorithm Steps

Calculate total sum while building frequency map
For each element, temporarily remove it as potential outlier
Calculate required sum element using mathematical relationship
Check if required sum element exists in remaining elements
Track maximum valid outlier found

Visualization

Tap to expand

Step-by-Step Walkthrough

Single Pass Setup

Build frequency map while calculating total sum

Mathematical Check

For each unique element, calculate required sum using formula

Frequency Validation

Verify sum element exists with proper count after removing outlier

Track Maximum

Update maximum outlier found across all valid configurations

Code -

solution.c — C

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

#define HASH_SIZE 10007

typedef struct HashNode {
    int key;
    int count;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];
int uniqueKeys[1000];
int uniqueCount = 0;

int hashFunc(int key) {
    return abs(key) % HASH_SIZE;
}

void insertHash(int key) {
    int index = hashFunc(key);
    HashNode* node = hashTable[index];
    
    while (node) {
        if (node->key == key) {
            node->count++;
            return;
        }
        node = node->next;
    }
    
    HashNode* newNode = (HashNode*)malloc(sizeof(HashNode));
    newNode->key = key;
    newNode->count = 1;
    newNode->next = hashTable[index];
    hashTable[index] = newNode;
    uniqueKeys[uniqueCount++] = key;
}

int getCount(int key) {
    int index = hashFunc(key);
    HashNode* node = hashTable[index];
    
    while (node) {
        if (node->key == key) {
            return node->count;
        }
        node = node->next;
    }
    return 0;
}

void setCount(int key, int count) {
    int index = hashFunc(key);
    HashNode* node = hashTable[index];
    
    while (node) {
        if (node->key == key) {
            node->count = count;
            return;
        }
        node = node->next;
    }
}

int getLargestOutlier(int* nums, int n) {
    // Initialize
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    uniqueCount = 0;
    
    int totalSum = 0;
    for (int i = 0; i < n; i++) {
        insertHash(nums[i]);
        totalSum += nums[i];
    }
    
    int maxOutlier = INT_MIN;
    
    // Check each unique element as potential outlier
    for (int i = 0; i < uniqueCount; i++) {
        int outlier = uniqueKeys[i];
        int remainingSum = totalSum - outlier;
        
        if (remainingSum % 2 != 0) continue;
        
        int sumElement = remainingSum / 2;
        int originalCount = getCount(outlier);
        
        setCount(outlier, originalCount - 1);
        
        if (getCount(sumElement) > 0) {
            if (outlier > maxOutlier) {
                maxOutlier = outlier;
            }
        }
        
        setCount(outlier, originalCount);
    }
    
    return maxOutlier;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[1000];
    int n = 0;
    
    char* token = strtok(input, "[,]\n ");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[,]\n ");
    }
    
    printf("%d\n", getLargestOutlier(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array: build frequency map and check each outlier candidate in the same iteration

✓ Linear Growth

Space Complexity

O(n)

Hash map to store frequency of unique elements, worst case all elements are unique

⚡ Linearithmic Space

Constraints

3 ≤ nums.length ≤ 10⁵
-1000 ≤ nums[i] ≤ 1000
The input guarantees at least one valid outlier exists
All elements may have the same value
Exactly one valid configuration exists for the array structure

38.2K Views

Medium-High Frequency

~18 min Avg. Time

1.5K 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 Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler