Magnetic Force Between Two Balls

Magnetic Force Between Two Balls - Problem

In the universe Earth C-137, Rick discovered a special form of magnetic force between two balls if they are put in his new invented basket. Rick has n empty baskets, the i-th basket is at position[i]. Morty has m balls and needs to distribute the balls into the baskets such that the minimum magnetic force between any two balls is maximum.

Rick stated that magnetic force between two different balls at positions x and y is |x - y|.

Given the integer array position and the integer m. Return the required force.

Input & Output

Example 1 — Basic Case

$ Input: position = [1,2,3,4,7], m = 3

› Output: 3

💡 Note: Place balls at positions 1, 4, and 7. The minimum distance between any two balls is min(|4-1|, |7-4|, |7-1|) = min(3, 3, 6) = 3.

Example 2 — Closer Positions

$ Input: position = [5,4,3,2,1,1000000000], m = 2

› Output: 999999999

💡 Note: Place balls at positions 1 and 1000000000. The distance between them is |1000000000 - 1| = 999999999, which is the maximum possible minimum distance.

Example 3 — All Balls Must Fit

$ Input: position = [1,2,8,4,9], m = 4

› Output: 1

💡 Note: After sorting positions = [1,2,4,8,9]. To place 4 balls, we can place them at positions 1, 2, 4, 8 with minimum distance = 1.

Constraints

2 ≤ n ≤ 10⁵
1 ≤ m ≤ n
1 ≤ position[i] ≤ 10⁹
All position[i] are distinct

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use binary search on the answer space. We can sort positions and use greedy placement to check if a given minimum distance is achievable. Best approach is Binary Search on Answer with Time: O(n log n + n log(max_pos)), Space: O(1).

Common Approaches

✓ Binary Search on Answer Space

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

Sort positions first, then binary search on the answer. For each candidate minimum distance, use greedy placement to check if we can place m balls with at least that distance between them.

Brute Force - Try All Combinations

⏱️ Time: O(C(n,m) × m²) Space: O(m)

Try every possible combination of m positions from n available positions. For each combination, calculate the minimum distance between any two balls and keep track of the maximum such minimum distance.

Binary Search on Answer Space — Algorithm Steps

Step 1: Sort the positions array to enable greedy placement
Step 2: Binary search on possible minimum distances (1 to max_position - min_position)
Step 3: For each candidate distance, greedily place balls and check if m balls fit
Step 4: If achievable, try larger distance; otherwise try smaller distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Positions

Sort array to enable greedy placement

Binary Search Range

Search between 1 and (max_pos - min_pos)

Greedy Validation

For each candidate distance, check if m balls can be placed

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 canPlace(int* position, int n, int m, int minDist) {
    int count = 1; // Place first ball at position[0]
    int lastPos = position[0];
    
    for (int i = 1; i < n; i++) {
        if (position[i] - lastPos >= minDist) {
            count++;
            lastPos = position[i];
            if (count == m) {
                return 1;
            }
        }
    }
    return 0;
}

int solution(int* position, int n, int m) {
    qsort(position, n, sizeof(int), compare);
    
    int left = 1;
    int right = position[n - 1] - position[0];
    int result = 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canPlace(position, n, m, mid)) {
            result = mid;
            left = mid + 1; // Try for larger distance
        } else {
            right = mid - 1; // Try smaller distance
        }
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n log n + n log(max_pos))

O(n log n) for sorting, O(n log(max_pos)) for binary search with O(n) validation each time

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.0K Views

Medium Frequency

~25 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

Binary Search on Answer Space — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler