Magnetic Force Between Two Balls - Practice Coding Problems

Magnetic Force Between Two Balls - Problem

The Magnetic Ball Distribution Challenge

In Rick's laboratory, he has discovered a unique property of magnetic force between balls placed in special baskets. Given n baskets positioned at different locations and m magnetic balls, your task is to distribute the balls optimally.

The Goal: Place m balls into m different baskets such that the minimum magnetic force between any two balls is maximized.

Magnetic Force Formula: The magnetic force between two balls at positions x and y is |x - y| (absolute difference).

Input: An integer array position representing basket locations and integer m representing number of balls.

Output: Return the maximum possible minimum magnetic force.

Example: If baskets are at positions [1, 2, 3, 4, 7] and you have 3 balls, placing them at positions [1, 4, 7] gives minimum force of 3 (distances: 3, 3, 6).

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: We can place balls at positions [1,4,7] giving minimum magnetic forces of |4-1|=3 and |7-4|=3. This is the maximum possible minimum force.

example_2.py — Minimum Balls

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

› Output: 999999999

💡 Note: With only 2 balls, we can place them at positions 1 and 1000000000 for maximum magnetic force of 999999999.

example_3.py — All Positions Used

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

› Output: 1

💡 Note: We must use all positions, so the minimum force is limited by the smallest gap, which is 1.

Constraints

2 ≤ n ≤ 10⁵
2 ≤ m ≤ n
1 ≤ position[i] ≤ 10⁹
All positions are distinct
m balls must be placed in m different baskets

Visualization

Tap to expand

Understanding the Visualization

Sort Building Positions

Arrange buildings in order: [1, 2, 3, 4, 7]

Binary Search on Distance

Test if minimum distance of 3 units is achievable

Greedy Placement

Place first guard at position 1, next at position 4 (≥1+3), last at position 7 (≥4+3)

Verify Success

Successfully placed 3 guards with minimum distance 3

Key Takeaway

🎯 Key Insight: Instead of trying all combinations, we binary search on the answer (minimum distance) and use a greedy algorithm to verify if each distance is achievable. This reduces complexity from exponential to O(n log n).

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22 🍎 Apple 18

The optimal solution uses binary search on the answer combined with a greedy verification algorithm. Key insight: if we can achieve minimum distance X, we can achieve any smaller distance. Sort positions, then binary search on possible minimum distances (1 to max_range), using greedy placement to verify feasibility. Time complexity: O(n log n + n log(max_position)).

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer (Optimal)	O(n log n + n log(max_position))	O(1)	Binary search on the minimum distance and use greedy algorithm to check feasibility
Brute Force (Try All Combinations)	O(C(n,m) * m)	O(m)	Generate all possible ways to choose m baskets and find the maximum minimum distance

Binary Search on Answer (Optimal) — Algorithm Steps

Sort the position array to enable greedy placement
Set binary search bounds: left=1, right=max_distance/m
For each mid value, check if it's possible to place m balls with minimum distance mid
Use greedy algorithm: place first ball at position[0], then place next ball at first position >= previous + mid
If possible, try larger minimum distance; otherwise, try smaller
Return the maximum achievable minimum distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort & Initialize

Sort positions and set search bounds

Binary Search

Search for maximum achievable minimum distance

Greedy Check

Verify if distance is achievable greedily

Adjust Bounds

Update search range based on feasibility

Code -

solution.c — C

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

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

bool canPlaceBalls(int* position, int n, int m, int minForce) {
    int count = 1;
    int lastPos = position[0];
    
    for (int i = 1; i < n; i++) {
        if (position[i] - lastPos >= minForce) {
            count++;
            lastPos = position[i];
            if (count == m) return true;
        }
    }
    return false;
}

int maxDistance(int* position, int n, int m) {
    qsort(position, n, sizeof(int), compare);
    
    int left = 1;
    int right = position[n-1] - position[0];
    int result = 0;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canPlaceBalls(position, n, m, mid)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    int position[] = {1, 2, 3, 4, 7};
    int n = 5, m = 3;
    printf("%d\n", maxDistance(position, n, m));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + n log(max_position))

O(n log n) for sorting + O(n log(max_position)) for binary search with O(n) verification

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

67.2K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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 (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler