added comments bc i am sure many people want to read this amazing feat of engineering

Signed-off-by: Business Goose <did:plc:hsqwcidfez66lwm3gxhfv5in>

day5/src/main.rs

···
 use std::fmt::Debug;
 use std::{cmp, fs};
 
+#[derive(Debug)]
 struct Ingredient {
     id: u64,
 }
 
+// Describes a range of ingredient ids
 struct IngredientRange {
     start: Ingredient,
     end: Ingredient,
 }
 
+// Used to store and manage IngredientRanges
 struct IngredientDB {
     ranges: Vec<IngredientRange>,
 }
 
-#[derive(Debug, Clone, Copy, Eq)]
+// #[derive(Debug, Clone, Copy, Eq)]
+// don't think i need to do this deriving stuff
+// i find it a bit scary tbh
 enum RangeCap {
     Start(u64),
     End(u64),
 }
 
+// If both elements have the same type and value, they are equal
 impl cmp::PartialEq for RangeCap {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
···
     }
 }
 
+// Implementing an ordering for these Range Caps (better name? terminal?)
 impl cmp::PartialOrd for RangeCap {
     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
         match (self, other) {
+            // if both values are Starts or both are Ends, compare values normally
             (RangeCap::Start(a), RangeCap::Start(b)) => a.partial_cmp(b),
+            (RangeCap::End(a), RangeCap::End(b)) => a.partial_cmp(b),
+            // If they are equal, make sure Starts always go before Ends
             (RangeCap::Start(a), RangeCap::End(b)) => {
                 let result = a.partial_cmp(b);
                 if result == Some(Ordering::Equal) {
···
                     result
                 }
             }
-            (RangeCap::End(a), RangeCap::End(b)) => a.partial_cmp(b),
         }
     }
 }
 
 impl IngredientDB {
+    // Initializing an IngredientDB is basically parsing an input string and initializing the ranges vector.
     fn new(range_list: &str) -> IngredientDB {
         let mut ranges = Vec::new();
         for l in range_list.lines() {
···
         IngredientDB { ranges }
     }
 
+    // We can check if an ingredient is fresh by comparing it to our ranges and seeing if it falls within any of them.
     fn is_fresh(&self, ingredient: Ingredient) -> bool {
         self.ranges
             .iter()
             .any(|range| range.start.id <= ingredient.id && ingredient.id <= range.end.id)
     }
 
+    // This function is called clean_ranges_stack bc i initially tried to do something else and it was a nightmare
+    // Basically we initialize a list of RangeCaps, then sort them by value
+    // Then we go through and push to the stack when we find a Start, pop when we find an End
+    // If the end we find leaves our stack empty, we push a new range to our ranges vector
+    // Finally, we replace the internal ranges of this IngredientDB with our new, optimized ranges.
     fn clean_ranges_stack(&mut self) {
         let mut range_list = Vec::<RangeCap>::new();
         for range in &self.ranges {
             range_list.push(RangeCap::Start(range.start.id));
             range_list.push(RangeCap::End(range.end.id));
         }
-        range_list.sort_by(|a, b| a.partial_cmp(b).unwrap());
+        // Sort range list by Partial Ordering
+        // this shouldn't fail or something's wrong
+        range_list.sort_by(|a, b| {
+            a.partial_cmp(b)
+                .expect("RangeCaps should be able to be compared")
+        });
 
+        // initialize our stack and output range vectors
         let mut range_stack = Vec::<u64>::new();
         let mut new_ranges = Vec::<IngredientRange>::new();
 
         for range in &range_list {
             match *range {
+                // always push Starts to the stack
                 RangeCap::Start(id) => range_stack.push(id),
                 RangeCap::End(id) => {
+                    // if stack has more than 1 element, pop the top and discard
+                    // otherwise construct an IngredientRange with the final element and push it to the new_ranges vector
                     if range_stack.len() > 1 {
                         range_stack.pop();
                     } else {
···
         self.ranges = new_ranges;
     }
 
+    // Simple math function that subtracts ends of all the ranges from the starts and adds 1 to be **inclusive**
     fn count_fresh(&self) -> u64 {
         let mut fresh_count = 0u64;
         for range in &self.ranges {
-            if range.start.id == 0 && range.end.id == 0 {
-                continue;
-            }
             fresh_count += range.end.id.saturating_sub(range.start.id) + 1;
         }
         fresh_count
     }
 }
 
-impl Debug for Ingredient {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Ingredient {{ id: {} }}", self.id)
-    }
-}
-
 impl Debug for IngredientRange {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
···
 
 fn main() {
     let in_file = fs::read_to_string("input.txt").expect("Failed to read file");
-    let file_sections = in_file.split("\n\n").collect::<Vec<&str>>();
 
+    // Split our input file into two parts based on newlines and make sure there are exactly 2 parts
+    let file_sections = in_file.split("\n\n").collect::<Vec<&str>>();
     assert!(file_sections.len() == 2);
 
+    // Parse first part of the file and initialize an IngredientDB
     let mut ingredient_db = IngredientDB::new(file_sections[0]);
-    let mut fresh_count = 0u64;
 
+    // before range cleanup
+    // println!("Ingredient Database: {:?}", ingredient_db);
+    // cleaning our ranges up here gives us better performance for the first part! since there are less ranges to check in.
+    ingredient_db.clean_ranges_stack();
+    // after range cleanup
+    // println!("Ingredient Database: {:?}", ingredient_db);
+
+    // to get our first star, we check each ingredient in the second section against our initialized DB and increment fresh_count
+    let mut fresh_count = 0u64;
     for test_ingredient in file_sections[1].lines() {
         if ingredient_db.is_fresh(Ingredient {
             id: test_ingredient
···
         }
     }
 
-    // before range cleanup
-    // println!("Ingredient Database: {:?}", ingredient_db);
-    ingredient_db.clean_ranges_stack();
-    // after range cleanup
-    // println!("Ingredient Database: {:?}", ingredient_db);
     println!("Fresh Ingredients in Pantry: {}", fresh_count);
     println!(
         "Fresh Ingredients in Database: {}",