вещи. Написал код ниже, это кусочек решения для задачи с литкода, сначала я написал fn overflow через анвреп с дефолтом, но из-за того что я пока не до конца понимаю владение, влепил клон (т.к. это бокс то по идее клониться будет весь хвост линкед листа что не круто), плюс нужна имплементация дефолт, потом я подумал как бы избавиться от него, и придумал влепить вместо этой конструкции еще один матч. Я хочу понять какое решение более "идеоматическое" и в целом более грамотное, почему, можно ли сделать лучше (в конструкции с матч меня как то коробит что два разных вызова конструктора ноды хотя код выглядит чисто). Может быть как-то можно переписать вариант типа анврепа только без клонирования и покрасивее?
                  
                  
                  
                  
                  
                  * для контекста, функция приводит лист типа [1, 10, 9, 1] к [1, 9, 0, 2]
                  
                  
                  
                  
                  
                  rust
                  
                  
                  
                  
                  
                  #[derive(PartialEq, Eq, Clone, Debug)]
                  
                  
                  pub struct ListNode {
                  
                  
                      pub val: i32,
                  
                  
                      pub next: Option<Box<ListNode>>,
                  
                  
                  }
                  
                  
                  
                  
                  
                  type Node = Option<Box<ListNode>>;
                  
                  
                  
                  
                  
                  impl Default for Box<ListNode> {
                  
                  
                      fn default() -> Self {
                  
                  
                          Box::new(ListNode::new(0))
                  
                  
                      }
                  
                  
                  }
                  
                  
                  
                  
                  
                  fn node(val: i32, next: Node) -> Node {
                  
                  
                      Some(Box::new(ListNode { val, next }))
                  
                  
                  }
                  
                  
                  
                  
                  
                  /// using unwrap and clone
                  
                  
                  fn overflow(l: Node) -> Node {
                  
                  
                      match l {
                  
                  
                          None => None,
                  
                  
                          Some(b) if b.val < 10 => Some(b),
                  
                  
                          Some(b) => node(
                  
                  
                              b.val - 10,
                  
                  
                              overflow(node(
                  
                  
                                  b.next.clone().unwrap_or_default().val + 1,
                  
                  
                                  b.next.unwrap_or_default().next)),
                  
                  
                          ),
                  
                  
                      }
                  
                  
                  }
                  
                  
                  
                  
                  
                  /// using match
                  
                  
                  fn overflow(l: Node) -> Node {
                  
                  
                      match l {
                  
                  
                          None => None,
                  
                  
                          Some(b) if b.val < 10 => Some(b),
                  
                  
                          Some(b) => node(
                  
                  
                              b.val - 10,
                  
                  
                              overflow(match b.next {
                  
                  
                                  None => node(1, None),
                  
                  
                                  Some(next) => node(next.val + 1, next.next),
                  
                  
                              }),
                  
                  
                          ),
                  
                  
                      }
                  
                  
                  }
                  
                  
                
а оно вообще работает? Или ты написал просто как хочешь чтобы было
работает корректно, разница в производительности в пределах погрешности (ну на литкоде...)
https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=42171403097f777a3e9355856b4d2e34 ну вот я посмотрел - как было 1 10 9 1 так и осталось
я немного не так описал функцию, т.к. это часть решения, но вопрос у меня все же больше про то как работать с опциями
у тебя получается ерунда потому что линкед листы так никто не описывает. А так второй способ с матчем достаточно идеоматичный
ну листы такие автор задачи дает т.ч. не поспоришь )
в принципе ответ получил, спасибо
Обсуждают сегодня