Largest Multiple of Three LeetCode solution in Rust

1
pub fn normalize(mut vec: [Vec<u8>; 3], diff: u8) -> Option<[Vec<u8>; 3]> {
2
  if diff < 1 {
3
    return Some(vec);
4
  }
5

6
  if vec[1].is_empty() && vec[2].is_empty() {
7
    return None;
8
  }
9

10
  if vec[1].is_empty() {
11
    vec[2].pop();
12
    return normalize(vec, (diff + 1) % 3);
13
  }
14

15
  if vec[2].is_empty() {
16
    vec[1].pop();
17
    return normalize(vec, (diff + 2) % 3);
18
  }
19

20
  // both non-empty
21
  vec[diff as usize].pop();
22
  Some(vec)
23
}
24

25
impl Solution {
26
  fn preproc(mut vec: Vec<i32>) -> ([Vec<u8>; 3], u8) {
27
    vec.sort_unstable();
28
    vec.reverse();
29
    let diff = vec.iter().sum::<i32>() as u32;
30
    let diff = (diff % 3) as u8;
31

32
    let mut ret = [vec![], vec![], vec![]];
33

34
    for e in vec {
35
      ret[e as usize % 3].push(e as u8);
36
    }
37

38
    (ret, diff)
39
  }
40

41
  fn _impl(vec: Vec<i32>) -> Option<Vec<u8>> {
42
    let (vec, diff) = Self::preproc(vec);
43
    let [mut vec_0, mut vec_1, mut vec_2] = normalize(vec, diff)?;
44

45
    vec_0.append(&mut vec_1);
46
    vec_0.append(&mut vec_2);
47
    vec_0.sort_unstable();
48
    vec_0.reverse();
49

50
    if vec_0.is_empty() {
51
      return None;
52
    }
53
    if vec_0[0] < 1 {
54
      return Some(vec![0]);
55
    }
56

57
    Some(vec_0)
58
  }
59

60
  pub fn largest_multiple_of_three(vec: Vec<i32>) -> String {
61
    let ret = if let Some(inner) = Self::_impl(vec) {
62
      inner
63
    } else {
64
      return String::new();
65
    };
66

67
    ret.into_iter().map(|e| (e + '0' as u8) as char).collect()
68
  }
69
}