2023 Advent of Code Day 1

main.rs

const INPUT: &str = "...snip...";

fn main() {
    // part1
    let sum: u32 = INPUT.lines()
        .map(extract_digit)
        .sum();
    println!("part1 sum: {}", sum);

    // part2
    let sum: u32 = INPUT.lines()
        .map(|s| {
            print!("{}: ", s);
            s
        })
        .map(extract_digit2)
        .map(|n| {
            println!("{}", n);
            n
        })
        .sum();
    println!("part2 sum: {}", sum);
}

fn extract_digit(s: &str) -> u32 {
    let mut chars: Vec<char> = s.chars().collect();
    let mut d: (char, char) = ('0', '0');

    for c in chars.iter() {
        if c.is_numeric() {
            d.0 = *c;
            break;
        }
    }
    chars.reverse();
    for c in chars.iter() {
        if c.is_numeric() {
            d.1 = *c;
            break;
        }
    }

    let mut r = String::new();
    r.push(d.0);
    r.push(d.1);

    r.parse::<u32>().expect("invalid number")
}

fn extract_digit2(s: &str) -> u32 {
    let digits = extract_all_digits(s);
    let r = digits[0].to_string() + digits[ digits.len() - 1 ].to_string().as_str();
    r.parse().unwrap()
}

fn extract_all_digits(s: &str) -> Vec<u32> {
    let mut r: Vec<u32> = vec![];

    for n in 0..s.len() {
        let s = &s[n..];
        let c = s.chars().next().unwrap();
        if c.is_numeric() {
            r.push(c.to_digit(10).unwrap())
        } else if s.starts_with("one") {
            r.push(1);
        } else if s.starts_with("two") {
            r.push(2);
        } else if s.starts_with("three") {
            r.push(3);
        } else if s.starts_with("four") {
            r.push(4);
        } else if s.starts_with("five") {
            r.push(5);
        } else if s.starts_with("six") {
            r.push(6);
        } else if s.starts_with("seven") {
            r.push(7);
        } else if s.starts_with("eight") {
            r.push(8);
        } else if s.starts_with("nine") {
            r.push(9);
        }
    }

    r
//
//    lazy_static! {
//        static ref RE: Regex = Regex::new(r"([1-9]|one|two|three|four|five|six|seven|eight|nine)").expect("invalid regexp");
//    }
//
//    RE.captures_iter(s)
//        .map(|c| {
//            let s = c[0].to_string();
//            match s.as_str() {
//                "one" => 1,
//                "two" => 2,
//                "three" => 3,
//                "four" => 4,
//                "five" => 5,
//                "six" => 6,
//                "seven" => 7,
//                "eight" => 8,
//                "nine" => 9,
//                _ => s.parse::<u32>().expect("unexpected input"),
//            }
//        }).collect()
}

#[cfg(test)]
mod tests {
    use crate::{extract_digit, extract_all_digits, extract_digit2};

    #[test]
    fn test_extract_digit() {
        assert_eq!(extract_digit("1abc2"), 12);
        assert_eq!(extract_digit("pqr3stu8vwx"), 38);
        assert_eq!(extract_digit("1abc2a1b2c3d4e5f"), 15);
        assert_eq!(extract_digit("treb7uchet"), 77);
    }

    #[test]
    fn test_extract_digit2() {
        assert_eq!(extract_digit2("two1nine"), 29);
        assert_eq!(extract_digit2("eightwothree"), 83);
        assert_eq!(extract_digit2("abcone2threexyz"), 13);
        assert_eq!(extract_digit2("xtwone3four"), 24);
        assert_eq!(extract_digit2("4nineeightseven2"), 42);
        assert_eq!(extract_digit2("zoneight234"), 14);
        assert_eq!(extract_digit2("7pqrstsixteen"), 76);
    }

    #[test]
    fn test_extract_all_digits() {
        assert_eq!(extract_all_digits("two1nine"), vec![2, 1, 9]);
    }
}