Largest Positive Integer That Exists With Its Negative

Largest Positive Integer That Exists With Its Negative - Problem

Imagine you're organizing a list of numbers, and you notice that some positive numbers have their negative counterparts hiding in the same list. Your task is to find the largest positive integer k such that its negative twin -k also exists in the array.

Given an integer array nums that contains no zeros, return the largest positive integer k where both k and -k are present in the array. If no such pair exists, return -1.

Example: In array [3, 2, -2, 5, -3], both 2 and -2 exist, and both 3 and -3 exist. The largest positive integer with its negative counterpart is 3.

Input & Output

example_1.py — Python

$ Input: [3, 2, -2, 5, -3]

› Output: 3

💡 Note: We have pairs (2, -2) and (3, -3). The largest positive integer with its negative counterpart is 3.

example_2.py — Python

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

› Output: 3

💡 Note: We have the pair (3, -3). The number 2 doesn't have its negative counterpart -2, so we return 3.

example_3.py — Python

$ Input: [-1, 10, 6, 7, -7, 1]

› Output: 7

💡 Note: We have pairs (1, -1) and (7, -7). The largest positive integer is 7.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Meet Someone

You encounter person wearing jersey #3

Check Your Notes

Look in your notebook - have you seen someone with #-3?

Record the Pair

If you find both #3 and #-3, record 3 as a valid pair

Update Maximum

Keep track of the highest number that has both versions

Add to Notes

Write down #3 in your notebook for future reference

Key Takeaway

🎯 Key Insight: Instead of searching for each number's opposite repeatedly, we use a hash set to store seen numbers and check opposites in O(1) time, making the entire solution O(n).

Asked in

G Google 34 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses a hash set to track numbers as we process them. For each number, we check if its opposite exists in our set - if so, we update our maximum positive value. This achieves O(n) time complexity with a single pass through the array, making it more efficient than sorting-based approaches.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Set (Optimal)	O(n)	O(n)	Use a hash set to track seen numbers and check for complements in one pass
Brute Force (Nested Loops)	O(n²)	O(1)	For each positive number, search the entire array for its negative counterpart
Two Pointers (Sorted Array)	O(n log n)	O(n)	Sort array and use two pointers from both ends to find complementary pairs

One-Pass Hash Set (Optimal) — Algorithm Steps

Initialize an empty hash set and max_k = -1
For each number in the array, check if its opposite exists in the set
If the opposite exists and current number is positive, update max_k
Add the current number to the hash set
Return max_k

Visualization

Tap to expand

Step-by-Step Walkthrough

Process number

Take next number from array

Check opposite

Look for opposite in hash set

Update result

If found, update maximum positive value

Store number

Add current number to hash set

Code -

solution.c — C

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

#define HASH_SIZE 20001
#define OFFSET 10000

bool hash_table[HASH_SIZE];

int findMaxK(int* nums, int numsSize) {
    // Initialize hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hash_table[i] = false;
    }
    
    int maxK = -1;
    
    for (int i = 0; i < numsSize; i++) {
        int num = nums[i];
        int opposite = -num;
        
        // Check if opposite exists (with bounds checking)
        if (opposite >= -10000 && opposite <= 10000 && hash_table[opposite + OFFSET]) {
            int positiveVal = (num > 0) ? num : -num;
            if (positiveVal > maxK) {
                maxK = positiveVal;
            }
        }
        
        // Add current number to hash table
        if (num >= -10000 && num <= 10000) {
            hash_table[num + OFFSET] = true;
        }
    }
    
    return maxK;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    int sign = 1;
    int reading = 0;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            reading = 1;
        } else if (c == '-') {
            sign = -1;
            reading = 1;
        } else if (c == ',' || c == ']') {
            if (reading) {
                nums[size++] = sign * num;
                num = 0;
                sign = 1;
                reading = 0;
            }
        }
    }
    
    printf("%d\n", findMaxK(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each element exactly once, and hash set operations are O(1) average case

✓ Linear Growth

Space Complexity

O(n)

Hash set can store up to n elements in worst case

⚡ Linearithmic Space

23.4K 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

One-Pass Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler