Maximize Score of Numbers in Ranges - Practice Coding Problems

Maximize Score of Numbers in Ranges - Problem

You are an optimization strategist tasked with making the smartest choices from constrained ranges. Given an array of starting positions start and a range distance d, you have n intervals where the i-th interval is [start[i], start[i] + d].

Your mission: Choose exactly one integer from each interval such that the minimum absolute difference between any two chosen numbers is as large as possible. This minimum difference is your "score" - and you want to maximize it!

Think of it as: You're placing guards at strategic positions within their assigned zones, and you want to ensure the closest two guards are as far apart as possible for maximum coverage.

Example: If start = [1, 0, 9] and d = 2, your intervals are [1,3], [0,2], [9,11]. You might choose 2, 0, 10 giving you differences of |2-0|=2, |10-2|=8, |10-0|=10. The minimum is 2, which becomes your score.

Input & Output

example_1.py — Basic case

$ Input: start = [1, 0, 9], d = 2

› Output: 2

💡 Note: Intervals are [1,3], [0,2], [9,11]. We can choose 2 from [1,3], 0 from [0,2], and 10 from [9,11]. The differences are |2-0|=2, |10-2|=8, |10-0|=10. The minimum is 2, which is the maximum possible.

example_2.py — Close intervals

$ Input: start = [2, 6, 13, 13], d = 5

› Output: 5

💡 Note: Intervals are [2,7], [6,11], [13,18], [13,18]. We can choose 2, 7, 13, 18 giving minimum difference of 5 (between 2 and 7).

example_3.py — Single interval

$ Input: start = [5], d = 3

› Output: 0

💡 Note: With only one interval [5,8], we choose one number. Since there are no pairs, the minimum difference is undefined, but conventionally we return 0 for single element cases.

Constraints

1 ≤ start.length ≤ 10⁴
0 ≤ start[i] ≤ 10⁸
0 ≤ d ≤ 10⁴
All intervals have the same length d

Visualization

Tap to expand

Understanding the Visualization

Zone Assignment

Each guard gets a patrol zone [start[i], start[i] + d] where they must be positioned

Distance Optimization

We want to position guards so the closest two are as far apart as possible

Greedy Placement

Sort zones and greedily place guards as far left as possible while maintaining minimum distance

Key Takeaway

🎯 Key Insight: The problem has a monotonic property - if we can achieve distance X, we can achieve any smaller distance. This makes binary search on the answer optimal, combined with greedy validation.

Asked in

G Google 28 a Amazon 22 f Meta 15 ⊞ Microsoft 12

The optimal approach uses binary search on the answer combined with greedy validation. We binary search on possible minimum distances and use a greedy strategy to check if each distance is achievable. The key insight is the monotonic property: if distance X is achievable, then any smaller distance is also achievable. Time complexity: O(n log n + n log(max_range)).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O((d+1)^n * n^2)	O((d+1)^n)	Generate all possible combinations of numbers from intervals and find maximum minimum difference
Binary Search + Greedy (Optimal)	O(n log n + n log(max_range))	O(n)	Binary search on answer combined with greedy validation

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible integers for each interval [start[i], start[i] + d]
Create all possible combinations by picking one number from each interval
For each combination, calculate all pairwise differences
Find the minimum difference in each combination
Return the maximum of all minimum differences found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate intervals

Create all possible ranges from start positions

Try combinations

Generate all possible ways to pick one number from each interval

Calculate scores

For each combination, find the minimum pairwise difference

Code -

solution.c — C

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

int maxScore = 0;

void backtrack(int index, int* start, int n, int d, int* chosen, int chosenSize) {
    if (index == n) {
        if (chosenSize < 2) {
            if (INT_MAX > maxScore) {
                maxScore = INT_MAX;
            }
            return;
        }
        int minDiff = INT_MAX;
        for (int i = 0; i < chosenSize; i++) {
            for (int j = i + 1; j < chosenSize; j++) {
                int diff = abs(chosen[i] - chosen[j]);
                if (diff < minDiff) {
                    minDiff = diff;
                }
            }
        }
        if (minDiff > maxScore) {
            maxScore = minDiff;
        }
        return;
    }
    
    for (int num = start[index]; num <= start[index] + d; num++) {
        chosen[chosenSize] = num;
        backtrack(index + 1, start, n, d, chosen, chosenSize + 1);
    }
}

int maximizeTheScore(int* start, int n, int d) {
    maxScore = 0;
    int* chosen = (int*)malloc(n * sizeof(int));
    backtrack(0, start, n, d, chosen, 0);
    free(chosen);
    return maxScore;
}

int main() {
    int start[] = {1, 0, 9};
    int d = 2;
    int n = 3;
    printf("%d\n", maximizeTheScore(start, n, d));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((d+1)^n * n^2)

(d+1)^n combinations times n^2 to find minimum difference for each

⚠ Quadratic Growth

Space Complexity

O((d+1)^n)

Store all combinations in worst case

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

874 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler