Largest Positive Integer That Exists With Its Negative

Largest Positive Integer That Exists With Its Negative - Problem

Given an integer array nums that does not contain any zeros, find the largest positive integer k such that -k also exists in the array.

Return the positive integer k. If there is no such integer, return -1.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: 3 is the largest positive integer that has its negative -3 in the array. Both 2 and 3 have their negatives, but 3 is larger.

Example 2 — No Valid Pairs

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

› Output: 7

💡 Note: Only 7 has its negative -7 in the array. Numbers like 10, 6 don't have their negatives present.

Example 3 — No Pairs Exist

$ Input: nums = [-10,8,6,7,4,2,3]

› Output: -1

💡 Note: None of the positive integers have their negative counterparts in the array.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to find positive-negative pairs efficiently. The hash set approach is optimal with O(n) time and O(n) space - store all numbers for O(1) lookup, then check each positive for its negative counterpart. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Check Every Pair

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

Iterate through the array to find positive numbers, then for each positive number, search the entire array to see if its negative exists. Keep track of the largest such positive number.

Hash Set - Single Pass

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

First pass stores all numbers in a hash set for O(1) lookup. Second pass checks each positive number to see if its negative exists in the set, tracking the maximum.

Two Pointers - Sort First

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

Sort the array first, then use two pointers from both ends. When we find a pair that sums to zero, we found a positive-negative pair. Move pointers based on the sum to efficiently find all such pairs.

Brute Force - Check Every Pair — Algorithm Steps

Step 1: Find all positive numbers in the array
Step 2: For each positive number, search entire array for its negative
Step 3: Track the maximum positive number that has its negative pair

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Positive

Iterate to find positive numbers

Search Array

For each positive, scan entire array for its negative

Track Maximum

Keep the largest positive that has its negative pair

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    int maxK = -1;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > 0) {  // Only consider positive numbers
            // Search for the negative counterpart
            for (int j = 0; j < numsSize; j++) {
                if (nums[j] == -nums[i]) {
                    if (nums[i] > maxK) {
                        maxK = nums[i];
                    }
                    break;
                }
            }
        }
    }
    return maxK;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we potentially scan all n elements to find its negative

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Brute Force - Check Every Pair — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler