In the universe Earth C-137, Rick has discovered a unique type of magnetic force between two balls when placed in his newly invented baskets. He has $n$ baskets, each located at specific positions given by the array position[i]. Morty has m balls and needs to distribute these balls across the baskets in such a way that the minimum magnetic force between any two balls is as large as possible.

The magnetic force between two balls placed at positions $x$ and $y$ is calculated as the absolute difference $|x−y|$.

Given an integer array position and the number of balls m, return the maximum possible value of the minimum magnetic force between any two balls after they have been placed in the baskets.

Constraints:

• $2 \leq$ position.length $\leq 10^3$

• $1 \leq$ position[i] $\leq 10^4$

• All integers in position are unique.

• $2 \leq$ m $\leq$ position.length

The magnetic force between two balls is calculated as the absolute difference, $|x−y|$, where $x$ and $y$ are the positions of two balls. The problem requires placing m balls such that the minimum magnetic force (i.e., the smallest gap between any two consecutive balls) is maximized.

Suppose we aim to place the balls with at least a gap of $d$ between them. There are two possible outcomes:

1. If we can place all the balls with at least a gap of $d$ between them, trying smaller gaps is unnecessary, as it will always be possible to place them with a smaller gap.

2. If we can not place all the balls with a gap of $d$, trying larger gaps is useless since placing them with a larger gap will also be impossible.

As the above dichotomy allows us to discard portions of the search space at each step, it makes binary search an efficient approach. The search range for $d$ is between $1$ (smallest possible gap) and $\lceil \frac{max(position)-min(position)}{m-1} \rceil$ (largest possible gap). The expression $max(position)-min(position)$ gives the largest possible gap between any two balls, and $m-1$ is the number of gaps if we place m balls. Therefore, dividing the total range by $m-1$ gives the average gap size when m balls are spaced as far apart as possible.

Using the intuition above, we implement the algorithm as follows:

1. The first step is to sort the array position.

2. Initialize force with 0 to store the maximum possible minimum force between balls.

3. Define the binary search range using the variables low and high:

   1. Initialize low with 1.

   2. Initialize high with (position[position.length - 1] - position[0]) / (m - 1).

4. Use the binary search to find the maximum valid gap. The search continues as long as low is less than or equal to high:

   1. Calculate the midpoint, mid, between low and high.

   2. Call the helper function CanPlaceBalls(mid, position, m) to check if it is possible to place all m balls such that the minimum gap between any two balls is at least mid.

   3. If CanPlaceBalls(mid, position, m) returns true:

      1. Update force = mid because a gap of mid is valid.

      2. Increase low to mid + 1 to try larger gaps.

   4. If CanPlaceBalls(mid, position, m) returns false:

      1. Decrease high to mid - 1 because gaps larger than mid are not feasible.

5. Return force as the largest minimum magnetic force when the binary search terminates.

The helper function, CanPlaceBalls, takes the value mid from the binary search as its parameter (denoted as x) and is implemented as follows:

1. Start by placing the first ball in the first position (position[0]).

2. Initialize a counter, balls, for balls placed.

3. Iterate through the position array and check if the distance from the last placed ball to the current position is greater than or equal to x. If yes:

   1. Increment balls.

   2. Update the last placed ball’s position.

   3. Continue until m balls are placed or all positions are exhausted.

4. Return true if exactly m balls are placed, otherwise false.

Let’s look at the following illustration to get a better understanding of the solution: