In 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 ith 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.
 
Example 1:

Input: position = [1,2,3,4,7], m = 3
Output: 3
Explanation: Distributing the 3 balls into baskets 1, 4 and 7 will make the magnetic force between ball pairs [3, 3, 6]. The minimum magnetic force is 3. We cannot achieve a larger minimum magnetic force than 3.

Example 2:
Input: position = [5,4,3,2,1,1000000000], m = 2
Output: 999999999
Explanation: We can use baskets 1 and 1000000000.

 
Constraints:

n == position.length
2 <= n <= 10^5
1 <= position[i] <= 10^9
All integers in position are distinct.
2 <= m <= position.length

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

def _disabled_input(*args, **kwargs):
    raise RuntimeError("input() is disabled in callable mode")
builtins.input = _disabled_input

ns = {"__name__": "__judge__"}  # prevent if __name__ == "__main__" blocks
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = 'class Solution:\n    def maxDistance(self, position: List[int], m: int) -> int:\n        \n        position.sort()\n        L = len(position)\n        \n        left = 1\n        right = position[-1]-position[0]\n        \n        def can_place(f):\n            n_ball = m-1\n            cum_dis = 0\n            p = 1\n            #n_ball -= 1\n            while n_ball >0 and p<L :\n                cum_dis += position[p]-position[p-1]\n                if cum_dis >= f:\n                    n_ball -= 1\n                    cum_dis = 0\n                p += 1\n            \n            if n_ball == 0:\n                return True\n            else:\n                return False\n                    \n                \n        #return can_place(4)\n        # 1, 9, 5 false\n        # 1, 4, 2, true\n        # 2, 4, 3, true\n        # 3, 4, 3,\n        \n        while left < right:\n            mid = right- (-left+right)//2\n            #mid = (left+right)//2\n            if can_place(mid):\n                left = mid\n            else:\n                right = mid-1\n            # if right-left == 1:\n            #     if can_place(right):\n            #         return right\n            #     else:\n            #         return left\n\n        \n        #return can_place(3)\n        return left\n            \n#         if m == 2:\n#             return position[-1] - position[0]\n        \n#         L = len(position)\n        \n#         hp = []\n#         f_set = {}\n#         b_set = {}\n#         for i in range(L-1):\n#             heapq.heappush(hp, (position[i+1]-position[i], position[i], position[i+1]))\n#             f_set[position[i]] = position[i+1]\n#             b_set[position[i+1]] = position[i]\n        \n#         total = L-1\n        \n#         while total > m-1:\n#             l, x, y = heapq.heappop(hp)\n#             if x in f_set and y in b_set and f_set[x] == y and b_set[y] == x:\n#                 left_len = float(inf)\n#                 right_len = float(inf)\n#                 if y in f_set:\n#                     right_len = f_set[y]-y\n#                 if x in b_set:\n#                     left_len = x-b_set[x]\n#                 if left_len < right_len:\n#                     #merge with left\n#                     new_y = y\n#                     new_x = b_set[x]\n#                     del f_set[x]\n#                     del b_set[x]\n#                     f_set[new_x] = new_y\n#                     b_set[new_y] = new_x\n#                     ret = new_y - new_x\n#                 else:\n#                     # merge with right\n#                     new_y = f_set[y]\n#                     new_x = x\n#                     del f_set[y]\n#                     del b_set[y]\n#                     f_set[new_x] = new_y\n#                     b_set[new_y] = new_x\n#                     ret = new_y - new_x\n#                 heapq.heappush(hp, (new_y-new_x, new_x, new_y))\n#                 total -= 1\n        \n#         ret = float(inf)\n#         for k in f_set.keys():\n#             ret = min(ret, f_set[k]-k)\n        \n#         return f_set\n                         \n            \n        \n        \n            \n'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

_target = None
_fn_name = 'maxDistance'
if _fn_name:
    if "Solution" in ns:
        try:
            _obj = ns["Solution"]()
            if hasattr(_obj, _fn_name):
                _target = getattr(_obj, _fn_name)
        except Exception:
            _target = None
    if _target is None and _fn_name in ns and callable(ns[_fn_name]):
        _target = ns[_fn_name]
# Fallback: if there's exactly one user-defined function, use it
if _target is None:
    _cands = [v for k, v in ns.items() if callable(v) and getattr(v, "__module__", "") in ("__judge__", "__main__")]
    _user_funcs = [c for c in _cands if getattr(c, "__name__", "").startswith("_") is False]
    if len(_user_funcs) == 1:
        _target = _user_funcs[0]
if _target is None:
    raise RuntimeError(f"Could not resolve callable '{_fn_name}'")

_raw = sys.stdin.read().strip()
if _raw:
    _parsed = json.loads(_raw)
    if isinstance(_parsed, dict):
        _kwargs = _parsed.get("kwargs", {})
        _args = _parsed.get("args", [])
    else:
        _args, _kwargs = _parsed, {}
else:
    _args, _kwargs = [], {}
if not isinstance(_args, (list, tuple)):
    _args = [_args]
_res = _target(*_args, **_kwargs)
try:
    sys.stdout.write(repr(_res) + "\n")
except Exception:
    pass

```

Measured memory_bytes: 5716