Day 13-2

src/day_13_2/mod.rs

+mod packet_data;
+
+use std::cmp::Ordering;
+
+use packet_data::PacketData;
+
+pub fn solve_from_str(input: &str) -> usize {
+    let mut packets: Vec<PacketData> = input
+        .replace("\n\n", "\n")
+        .split("\n")
+        .map(|packet| PacketData::from_str(packet))
+        .collect();
+
+    let marker_1 = PacketData::from_str("[[2]]");
+    let marker_2 = PacketData::from_str("[[6]]");
+
+    packets.push(marker_1);
+    packets.push(marker_2);
+
+    solve(packets)
+}
+
+pub fn solve(packets: Vec<PacketData>) -> usize {
+    let mut packets = packets;
+
+    for i in 0..packets.len() {
+        for k in i..packets.len() {
+            if let Ordering::Greater = check_ordering(&packets[i], &packets[k]) {
+                packets.swap(i, k);
+            }
+        }
+    }
+
+    let marker_1 = PacketData::from_str("[[2]]");
+    let marker_2 = PacketData::from_str("[[6]]");
+
+    let index_1 = packets
+        .binary_search_by(|probe| check_ordering(probe, &marker_1))
+        .unwrap();
+    let index_2 = packets
+        .binary_search_by(|probe| check_ordering(probe, &marker_2))
+        .unwrap();
+
+    (index_1 + 1) * (index_2 + 1)
+}
+
+fn check_ordering(first: &PacketData, second: &PacketData) -> Ordering {
+    match (first, second) {
+        (PacketData::Integer(integer_1), PacketData::Integer(integer_2)) => {
+            if integer_1 < integer_2 {
+                Ordering::Less
+            } else if integer_1 > integer_2 {
+                Ordering::Greater
+            } else {
+                Ordering::Equal
+            }
+        }
+        (PacketData::List(list_1), PacketData::List(list_2)) => {
+            for i in 0..list_1.len() {
+                if list_2.len() <= i {
+                    return Ordering::Greater;
+                } else {
+                    let ordering = check_ordering(&list_1[i], &list_2[i]);
+
+                    if let Ordering::Equal = ordering {
+                    } else {
+                        return ordering;
+                    }
+                }
+            }
+
+            if list_1.len() < list_2.len() {
+                return Ordering::Less;
+            } else {
+                return Ordering::Equal;
+            }
+        }
+        (PacketData::Integer(integer), PacketData::List(list)) => {
+            check_ordering(&PacketData::List(vec![first.clone()]), second)
+        }
+        (PacketData::List(list), PacketData::Integer(integer)) => {
+            check_ordering(first, &PacketData::List(vec![second.clone()]))
+        }
+    }
+}

src/day_13_2/packet_data.rs

+#[derive(Debug, Clone)]
+pub enum PacketData {
+    List(Vec<PacketData>),
+    Integer(u32),
+}
+
+impl PacketData {
+    pub fn from_str(input: &str) -> PacketData {
+        if input.starts_with('[') {
+            let mut list = Vec::new();
+
+            let mut element = Vec::new();
+            let mut depth = 0;
+
+            for char in input[1..input.len() - 1].chars() {
+                if char == '[' {
+                    depth += 1;
+                }
+
+                if char == ']' {
+                    depth -= 1;
+                }
+
+                if char == ',' && depth == 0 {
+                    list.push(PacketData::from_str(
+                        element.clone().iter().collect::<String>().as_str(),
+                    ));
+
+                    element.clear();
+                } else {
+                    element.push(char);
+                }
+            }
+
+            if depth == 0 {
+                if element.len() > 0 {
+                    list.push(PacketData::from_str(
+                        element.clone().iter().collect::<String>().as_str(),
+                    ));
+                }
+            } else {
+                panic!("Mismatching brackets!");
+            }
+
+            Self::List(list)
+        } else {
+            Self::Integer(input.parse().expect("Expected integer!"))
+        }
+    }
+}

src/main.rs

@@ -22,13 +22,15 @@ mod day_11_1;
 mod day_11_2;
 mod day_12_1;
 mod day_12_2;
+mod day_13_1;
+mod day_13_2;
 
 use std::fs;
 
 fn main() {
     let input = fs::read_to_string("input").expect("Could not read input!");
 
-    let solution = day_12_2::solve_from_str(input.as_str());
+    let solution = day_13_2::solve_from_str(input.as_str());
 
     println!("Solution: {}", solution);
 }