Largest Number At Least Twice of Others - Practice Coding Problems

Largest Number At Least Twice of Others - Problem

Array Sorting Easy

You are given an integer array nums where the largest integer is unique. Your task is to determine whether the largest element in the array is at least twice as much as every other number in the array.

Goal: If the largest element is at least twice as large as every other element, return the index of the largest element. Otherwise, return -1.

Example: In array [3, 6, 1, 0], the largest element is 6 at index 1. Since 6 >= 2×3, 6 >= 2×1, and 6 >= 2×0, we return 1.

Important: The problem guarantees that the largest element appears exactly once in the array.

Input & Output

example_1.py — Basic Dominant Case

$ Input: [3, 6, 1, 0]

› Output: 1

💡 Note: The largest element is 6 at index 1. Since 6 ≥ 2×3, 6 ≥ 2×1, and 6 ≥ 2×0, the largest element is at least twice as large as every other element.

example_2.py — Non-Dominant Case

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

› Output: -1

💡 Note: The largest element is 4 at index 3. However, 4 < 2×3, so the largest element is not at least twice as large as every other element.

example_3.py — Single Element Edge Case

$ Input: [1]

› Output: 0

💡 Note: With only one element, it is automatically the largest and dominant since there are no other elements to compare against.

Constraints

1 ≤ nums.length ≤ 50
0 ≤ nums[i] ≤ 100
The largest element in nums is unique

Visualization

Tap to expand

Understanding the Visualization

Identify Champion

Find the strongest player (largest element) in the competition

Find Runner-up

Identify the second strongest player (second largest element)

Verify Dominance

Check if champion is at least twice as strong as the runner-up

Conclusion

If yes, return champion's position; if no, return -1 (no dominant champion)

Key Takeaway

🎯 Key Insight: We only need to compare the largest element with the second-largest. If the champion beats the runner-up by 2x, they automatically beat everyone else by 2x!

Asked in

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

The optimal solution uses a single-pass approach to track the largest and second-largest elements simultaneously. The key insight is that if the largest element is at least twice the second-largest, it automatically satisfies the condition for all smaller elements. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Find Max, Check All)	O(n)	O(1)	Find the maximum element, then verify it's at least twice every other element
One-Pass Optimal Solution	O(n)	O(1)	Track largest and second-largest elements in a single pass through the array
Two-Pass Optimization (Track Top Two)	O(n)	O(1)	Find the largest and second-largest elements, then check if largest ≥ 2×second-largest

Brute Force (Find Max, Check All) — Algorithm Steps

Iterate through array to find maximum value and its index
Iterate through array again to check if max >= 2 * each other element
Return index if condition holds for all elements, otherwise return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Maximum

Scan array to find largest element and its index

Verify Dominance

Check if maximum is at least twice every other element

Code -

solution.c — C

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

int dominantIndex(int* nums, int numsSize) {
    if (numsSize <= 1) {
        return numsSize == 1 ? 0 : -1;
    }
    
    // First pass: find maximum and its index
    int maxVal = nums[0];
    int maxIdx = 0;
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] > maxVal) {
            maxVal = nums[i];
            maxIdx = i;
        }
    }
    
    // Second pass: check if max is at least twice every other element
    for (int i = 0; i < numsSize; i++) {
        if (i != maxIdx && maxVal < 2 * nums[i]) {
            return -1;
        }
    }
    
    return maxIdx;
}

int main() {
    int nums[] = {3, 6, 1, 0}; // Example input
    int size = sizeof(nums) / sizeof(nums[0]);
    printf("%d\n", dominantIndex(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array of length n

✓ Linear Growth

Space Complexity

O(1)

Only storing maximum value, index, and loop variables

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

980 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 (Find Max, Check All) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler