Winter is coming! During the contest, your first job is to design a standard heater with a fixed warm radius to warm all the houses.

Every house can be warmed, as long as the house is within the heater's warm radius range.

Given the positions of `houses`

and `heaters`

on a horizontal line, return *the minimum radius standard of heaters so that those heaters could cover all houses.*

**Notice** that all the `heaters`

follow your radius standard, and the warm radius will the same.

**Example 1:**

Input:houses = [1,2,3], heaters = [2]Output:1Explanation:The only heater was placed in the position 2, and if we use the radius 1 standard, then all the houses can be warmed.

**Example 2:**

Input:houses = [1,2,3,4], heaters = [1,4]Output:1Explanation:The two heater was placed in the position 1 and 4. We need to use radius 1 standard, then all the houses can be warmed.

**Example 3:**

Input:houses = [1,5], heaters = [2]Output:3

**Constraints:**

`1 <= houses.length, heaters.length <= 3 * 10`

^{4}`1 <= houses[i], heaters[i] <= 10`

^{9}

```
struct Solution;
impl Solution {
fn distance(a: i32, b: i32) -> i32 {
(a - b).abs()
}
fn find_radius(mut houses: Vec<i32>, mut heaters: Vec<i32>) -> i32 {
houses.sort_unstable();
heaters.sort_unstable();
let mut i = 0;
let mut j = 0;
let n = houses.len();
let m = heaters.len();
let mut max = 0;
while i < n {
while j + 1 < m
&& Self::distance(heaters[j + 1], houses[i])
<= Self::distance(heaters[j], houses[i])
{
j += 1;
}
max = i32::max(Self::distance(houses[i], heaters[j]), max);
i += 1;
}
max
}
}
#[test]
fn test() {
let houses = vec![1, 2, 3];
let heaters = vec![2];
assert_eq!(Solution::find_radius(houses, heaters), 1);
let houses = vec![1, 2, 3, 4];
let heaters = vec![1, 4];
assert_eq!(Solution::find_radius(houses, heaters), 1);
}
```