advent of code 2022 day 13 part 1

aoc.rs

// Determine which pairs of packets are already in the right order. What is the sum of the indices of those pairs?

use core::fmt;
use serde::Deserialize;
use std::fs;

static FILENAME: &str = "inputs/13";

#[derive(Deserialize, PartialEq, Clone)]
#[serde(untagged)]
enum Term {
    Integer(u32),
    List(Vec<Term>),
}

impl Term {
    fn to_vec(&self) -> Vec<Term> {
        match self {
            Term::Integer(n) => vec![Term::Integer(*n)],
            Term::List(l) => l.clone(),
        }
    }
}

fn main() {
    let s = fs::read_to_string(FILENAME).unwrap();
    println!("part 1: {}", get_sum(&s));
}

fn get_sum(file: &str) -> usize {
    let mut sum = 0;
    let file = file.replace('\r', "");
    let pairs: Vec<&str> = file.split("\n\n").collect();

    for (i, pair) in pairs.iter().enumerate() {
        let pair_index = i + 1;
        let mut parsed_pair = pair
            .lines()
            .map(|line| serde_json::from_str::<Term>(line).unwrap());

        let left = parsed_pair.next().unwrap();
        let right = parsed_pair.next().unwrap();

        let is_in_order = compare_terms(&left, &right).unwrap();

        if is_in_order {
            sum += pair_index;
        }
    }
    sum
}

fn compare_terms(left: &Term, right: &Term) -> Option<bool> {
    match (left, right) {
        (Term::Integer(l), Term::Integer(r)) => {
            if l == r {
                return None;
            }
            return Some(l < r);
        }
        (l, r) => {
            let list_l = l.to_vec();
            let list_r = r.to_vec();

            return list_l
                .iter()
                .zip(list_r.iter())
                .map(|(l_item, r_item)| {
                    compare_terms(&l_item, &r_item)
                })
                .find(|&b| b.is_some())
                .unwrap_or_else(|| {
                    if list_l.len() == list_r.len() {
                        return None;
                    }
                    Some(list_l.len() < list_r.len())
                });
        }
    }
}

impl fmt::Debug for Term {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Integer(n) => write!(f, "{n}"),
            Self::List(n) => f.debug_list().entries(n).finish(),
        }
    }
}