The k Strongest Values in an Array - Practice Coding Problems

The k Strongest Values in an Array - Problem

You're given an array of integers arr and an integer k. Your task is to find the k strongest values in the array based on a unique strength metric.

What makes a value "stronger"?

A value arr[i] is considered stronger than arr[j] if:

|arr[i] - m| > |arr[j] - m| where m is the median of the array
If the distances are equal (|arr[i] - m| == |arr[j] - m|), then the larger value wins (arr[i] > arr[j])

Finding the median: Sort the array and take the element at position ((n - 1) / 2) using 0-based indexing.

Example: For [6, -3, 7, 2, 11], sorted becomes [-3, 2, 6, 7, 11]. The median is at index (5-1)/2 = 2, which is 6.

Return the k strongest values in any order.

Input & Output

example_1.py — Basic Case

$ Input: arr = [1, 2, 3, 4, 5], k = 2

› Output: [5, 1]

💡 Note: Median is 3 (middle of sorted array). Strengths: |1-3|=2, |2-3|=1, |3-3|=0, |4-3|=1, |5-3|=2. Both 1 and 5 have strength 2, but we can return in any order.

example_2.py — Original Example

$ Input: arr = [6, -3, 7, 2, 11], k = 3

› Output: [11, 7, 6]

💡 Note: Sorted: [-3, 2, 6, 7, 11], median = 6. Strengths: |-3-6|=9, |2-6|=4, |6-6|=0, |7-6|=1, |11-6|=5. Top 3 strongest: -3(9), 11(5), 2(4). But since 11 > -3 in tie-breaking, result includes [11, 7, 6] or similar.

example_3.py — Single Element

$ Input: arr = [1], k = 1

› Output: [1]

💡 Note: Only one element, so it's automatically the strongest (and weakest). Median is 1, strength is |1-1|=0.

Constraints

1 ≤ arr.length ≤ 10⁵
-10⁵ ≤ arr[i] ≤ 10⁵
1 ≤ k ≤ arr.length
The answer can be returned in any order

Visualization

Tap to expand

Understanding the Visualization

Find the Median

Sort all athletes by performance and find the middle performer (median)

Calculate Deviations

Measure how far each athlete's performance is from the median

Rank by Extremeness

The athletes with the largest deviations (positive or negative) are 'strongest'

Break Ties by Performance

If two athletes have the same deviation, the higher performer wins

Key Takeaway

🎯 Key Insight: After sorting, the strongest values will always be at the extremes (left and right ends) since they have the maximum distance from the median. Two pointers efficiently capture this without needing to calculate all strengths explicitly!

Asked in

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

The optimal solution uses the two pointers technique after sorting. Since the strongest values are furthest from the median, they will be at the extremes of the sorted array. We compare elements from both ends and greedily pick the stronger one, achieving O(n log n) time complexity with O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n log n)	O(1)	Sort array and use two pointers from both ends to find strongest values
Brute Force (Custom Sorting)	O(n log n)	O(n)	Calculate median, then sort all elements by strength criteria

Two Pointers (Optimal) — Algorithm Steps

Find median by sorting array and taking middle element
Sort the original array
Initialize left pointer at start, right pointer at end
Compare strength of arr[left] and arr[right] against median
Pick the stronger value, move corresponding pointer, repeat k times

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort array and find median

Initialize Pointers

Place left at start, right at end

Compare Strengths

Compare distances from median at both ends

Pick Stronger

Choose stronger value and move pointer inward

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int* getStrongest(int* arr, int arrSize, int k, int* returnSize) {
    qsort(arr, arrSize, sizeof(int), compare);
    int median = arr[(arrSize - 1) / 2];
    
    int* result = (int*)malloc(k * sizeof(int));
    int left = 0, right = arrSize - 1;
    
    for (int i = 0; i < k; i++) {
        int leftStrength = abs(arr[left] - median);
        int rightStrength = abs(arr[right] - median);
        
        if (leftStrength > rightStrength) {
            result[i] = arr[left];
            left++;
        } else {
            result[i] = arr[right];
            right--;
        }
    }
    
    *returnSize = k;
    return result;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int k = 2;
    int returnSize;
    int* result = getStrongest(arr, 5, k, &returnSize);
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting, O(k) for two-pointer traversal

⚡ Linearithmic

Space Complexity

O(1)

Only constant extra space after sorting (excluding result array)

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

847 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

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler