Maximize Score of Numbers in Ranges - Problem

You are given an array of integers start and an integer d, representing n intervals [start[i], start[i] + d].

You are asked to choose n integers where the i-th integer must belong to the i-th interval. The score of the chosen integers is defined as the minimum absolute difference between any two integers that have been chosen.

Return the maximum possible score of the chosen integers.

Input & Output

Example 1 — Basic Case

$ Input: start = [4, 6, 8], d = 2

› Output: 2

💡 Note: Intervals are [4,6], [6,8], [8,10]. We can choose integers 4, 6, 8 with minimum difference = min(|6-4|, |8-6|, |8-4|) = min(2, 2, 4) = 2

Example 2 — Same Start Points

$ Input: start = [2, 6, 8], d = 0

› Output: 2

💡 Note: With d=0, each interval contains only one integer: [2,2], [6,6], [8,8]. We must choose 2, 6, 8 with minimum difference = min(|6-2|, |8-6|, |8-2|) = min(4, 2, 6) = 2

Example 3 — Overlapping Intervals

$ Input: start = [6, 13, 18], d = 10

› Output: 3

💡 Note: Intervals are [6,16], [13,23], [18,28]. Optimal selection might be 6, 16, 19 giving minimum difference = min(|16-6|, |19-16|, |19-6|) = min(10, 3, 13) = 3

Constraints

1 ≤ start.length ≤ 10⁴
0 ≤ start[i] ≤ 10⁸
0 ≤ d ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Meta 8

The key insight is to use binary search on the answer space combined with greedy validation. Sort intervals by start position, then binary search on possible score values. For each candidate score, greedily place integers to maintain minimum differences. Best approach is Binary Search on Answer with Time: O(n log n), Space: O(n).

Common Approaches

✓ Binary Search on Answer

⏱️ Time: O(n log n + n log(max_range)) Space: O(n)

Sort intervals by start position, then binary search on possible score values (0 to maximum possible difference). For each candidate score, greedily check if we can select integers with minimum difference ≥ score.

Brute Force

⏱️ Time: O((d+1)ⁿ × n²) Space: O(n)

Generate all possible ways to choose one integer from each interval, then for each combination calculate the minimum absolute difference between any two chosen integers. Keep track of the maximum score found.

Binary Search on Answer — Algorithm Steps

Step 1: Sort intervals by start position to enable greedy selection
Step 2: Binary search on possible score values from 0 to max range
Step 3: For each score, greedily check if it's achievable by placing integers optimally

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Intervals

Sort by start position for greedy placement

Binary Search Score

Search for maximum achievable minimum difference

Greedy Validation

Check if score is achievable with greedy placement

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    int* ia = (int*)a;
    int* ib = (int*)b;
    return ia[0] - ib[0];
}

int canAchieveScore(int intervals[][3], int n, int score) {
    int* chosen = (int*)malloc(n * sizeof(int));
    chosen[intervals[0][2]] = intervals[0][0];
    
    for (int i = 1; i < n; i++) {
        int intervalStart = intervals[i][0];
        int intervalEnd = intervals[i][1];
        int originalIdx = intervals[i][2];
        
        int minAllowed = intervalStart;
        for (int j = 0; j < i; j++) {
            int prevVal = chosen[intervals[j][2]];
            if (prevVal + score > minAllowed) {
                minAllowed = prevVal + score;
            }
        }
        
        chosen[originalIdx] = minAllowed;
        
        if (chosen[originalIdx] > intervalEnd) {
            free(chosen);
            return 0;
        }
    }
    
    free(chosen);
    return 1;
}

int solution(int* start, int n, int d) {
    if (n == 1) return 0;
    
    int intervals[1000][3];
    int maxStart = start[0];
    for (int i = 0; i < n; i++) {
        intervals[i][0] = start[i];
        intervals[i][1] = start[i] + d;
        intervals[i][2] = i;
        if (start[i] > maxStart) maxStart = start[i];
    }
    
    qsort(intervals, n, sizeof(intervals[0]), compare);
    
    int left = 0, right = maxStart + d;
    int result = 0;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canAchieveScore(intervals, n, mid)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int start[1000];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] >= '0' && token[0] <= '9') {
            start[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int d;
    scanf("%d", &d);
    
    printf("%d\n", solution(start, n, d));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + n log(max_range))

Sorting intervals takes O(n log n), binary search runs O(log(max_range)) iterations with O(n) validation each

⚡ Linearithmic

Space Complexity

O(n)

Storage for sorted intervals and temporary arrays

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~35 min Avg. Time

580 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

Maximize Score of Numbers in Ranges - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler