Split linked list in parts

/*
 * Given the head of a singly linked list and an integer k, split the linked list into k consecutive linked list parts.
 * The length of each part should be as equal as possible: no two parts should have a size differing by more than one. This may lead to some parts being null.
 * The parts should be in the order of occurrence in the input list, and parts occurring earlier should always have a size greater than or equal to parts occurring later.
 * Return an array of the k parts.
 * Example 1:
 * Input: head = [1,2,3], k = 5
 * Output: [[1],[2],[3],[],[]]
 * Explanation:
 * The first element output[0] has output[0].val = 1, output[0].next = null.
 * The last element output[4] is null, but its string representation as a ListNode is [].
 * Example 2:
 * Input: head = [1,2,3,4,5,6,7,8,9,10], k = 3
 * Output: [[1,2,3,4],[5,6,7],[8,9,10]]
 * Explanation:
 * The input has been split into consecutive parts with size difference at most 1, and earlier parts are a larger size than the later parts.
 * Constraints:
 * The number of nodes in the list is in the range [0, 1000].
 * 0 <= Node.val <= 1000
 * 1 <= k <= 50
 */
impl Solution {
  pub fn split_list_to_parts(head: Option<Box<ListNode>>, k: i32) -> Vec<Option<Box<ListNode>>> {
    let k = k as usize;
    let mut len = 0;
    let mut cur = head.as_ref();
    while let Some(node) = cur { len += 1; cur = node.next.as_ref(); }
    let base = len / k;
    let extra = len % k;
    let mut result: Vec<Option<Box<ListNode>>> = Vec::with_capacity(k);
    let mut current = head;
    for i in 0..k {
      result.push(current);
      current = None;
      let size = base + if i < extra { 1 } else { 0 };
      let mut tail = &mut result[i];
      for _ in 0..size.saturating_sub(1) {
        tail = match tail {
          Some(node) => &mut node.next,
          None => break,
        };
      }
      if let Some(node) = tail.as_mut() {
        current = node.next.take();
      }
    }
    result
  }
}