i got this to work. i do not know how.

day22/src/main.rs

@@ -1,9 +1,8 @@
 use std::{env, fs};
-use std::cmp::{max, min, Ordering};
 use std::collections::{HashMap, HashSet};
 use std::str::FromStr;
 
-#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
 struct Brick {
     start: (i32, i32, i32),
     end: (i32, i32, i32),
@@ -31,24 +30,8 @@ impl Brick {
             .collect();
         if xes.len() != 1 { return xes; }
         if yes.len() != 1 { return yes; }
-        if zes.len() != 1 { return zes; }
+        return zes;
-        return Vec::new();
     }
-    fn shadow(&self) -> Vec<(i32, i32)> {
-        let mut squares = self.squares();
-        squares.dedup_by(|a, b| a.2 == b.2);
-        return squares.iter().map(|(x,y,_z)| (*x,*y)).collect();
-    }
-    fn top (&self) -> i32 {
-        return max(self.start.2, self.end.2);
-    }
-    fn bottom (&self) -> i32 {
-        return min(self.start.2, self.end.2);
-    }
-}
-
-fn compare_z(a: &Brick, b: &Brick) -> Ordering {
-    return a.start.2.cmp(&b.start.2);
 }
 
 fn main() {
@@ -63,138 +46,121 @@ fn main() {
     let file_path = &args[1];
     let contents = fs::read_to_string(file_path).expect("Should have been able to read the file");
 
-    println!("soorting the bricks by z for some reason");
     let mut bricks: Vec<Brick> = contents.lines().map(|x| x.parse().unwrap()).collect();
-    let mut bbs = bricks_by_shadow(&bricks);
+    let mut grid: HashMap<(i32, i32, i32), Brick> = HashMap::new();
-    bricks.sort_unstable_by(compare_z);
-    println!("{:?}", bricks);
-
-    println!("dropping bricks now");
-    let mut made_changes = true;
-    while made_changes {
-        let mut new_bricks: Vec<Brick> = Vec::new();
-        made_changes = false;
     for brick in &bricks {
-            if made_changes {
+        for coordinate in brick.squares() {
-                new_bricks.push(brick.clone());
+            grid.insert(coordinate, brick.clone());
-            } else {
-                let tops = under(&brick, &bbs);
-                if let Some(highest) = tops.iter().max_by_key(|a| a.top()) {
-                    let new_brick = lower(brick,highest);
-                    if new_brick != brick.clone() {
-                        new_bricks.push(new_brick);
-                        made_changes = true;
-                    } else {
-                        new_bricks.push(brick.clone());
         }
-                } else {
-                    new_bricks.push(brick.clone());
     }
+
+    //println!("Bricks: {bricks:?}");
+
+    let mut changed_things = true;
+    while changed_things {
+        changed_things = false;
+        for brick in &mut bricks {
+            let mut able_to_drop_1 = true;
+            for (x, y, z) in brick.squares() {
+                if z <= 0 { able_to_drop_1 = false; }
+                let runs_into_something =
+                    grid.contains_key(&(x,y,z-1)) && !brick.squares().contains(&(x,y,z-1));
+                able_to_drop_1 = able_to_drop_1 && !runs_into_something;
             }
+
+            if able_to_drop_1 {
+                for (x, y, z) in brick.squares() {
+                    grid.remove(&(x,y,z));
                 }
-        bricks = new_bricks;
+                brick.start.2 -= 1;
-        bbs = bricks_by_shadow(&new_bricks);
+                brick.end.2 -= 1;
+
+                for (x, y, z) in brick.squares() {
+                    grid.insert((x, y, z), brick.clone());
                 }
+                //println!("dropping brick {brick:?}");
+                changed_things = true;
 
-    println!("bricks have been dropped: {bricks:?}");
+            }
+        }
+    }
 
-    println!("calculating brick shadows");
+    println!("bricks have been dropped:");// {bricks:?}");
-    let brick_shadows = bricks_by_shadow(&bricks);
-    println!("there are {} brick shadows", brick_shadows.len());
 
-    println!("looking for disintegratbale bricks");
+    let mut grid: HashMap<(i32, i32, i32), Brick> = HashMap::new();
-    let mut disintegratable_bricks: HashSet<Brick> = HashSet::new();
     for brick in &bricks {
-        let mut removable = true;
+        for coordinate in brick.squares() {
-        for other_brick in supported_by(brick, &brick_shadows) {
+            grid.insert(coordinate, brick.clone());
-            if supporting(other_brick, &brick_shadows).len() == 1 {
-                removable = false;
         }
     }
-        if removable {
+    println!("looking for disintegratbale bricks");
+
+    let mut disintegratable_bricks: HashSet<Brick> = HashSet::new();
+    for brick in &bricks {
+        if dependent_bricks(&HashSet::from([*brick]), &grid).len() == 0 {
             disintegratable_bricks.insert(brick.clone());
         }
     }
     println!("The total number of disintegratable bricks is {}", disintegratable_bricks.len());
-}
 
-fn bricks_by_shadow(bricks: &Vec<Brick>) -> HashMap<(i32, i32), Vec<&Brick>> {
+    println!("now we're looking for chain reactions.");
-    let mut bricks_by_shadow: HashMap<(i32, i32), Vec<&Brick>> = HashMap::new();
+    let mut sum = 0;
-    for brick in bricks {
+    for brick in &bricks {
-        for coordinate in brick.shadow() {
+        let mut start = HashSet::from([*brick]);
-            if let Some(vector) = bricks_by_shadow.get_mut(&coordinate) {
+        let mut keep_going = true;
-                vector.push(&brick)
+        while keep_going {
-            } else {
+            keep_going = false;
-                bricks_by_shadow.insert(coordinate, Vec::new());
+            let chain = dependent_bricks(&start, &grid);
-                bricks_by_shadow.get_mut(&coordinate).unwrap().push(brick);
+            if chain.len() != 0 { keep_going = true;}
-            }
+            start.extend(chain.iter());
         }
+        start.remove(&brick);
+        //println!("found a brick we could remove to immediately chain {} bricks", start.len());
+        sum += start.len();
     }
-    return bricks_by_shadow;
+    println!("sum is {sum}");
 }
 
-// returns a set of bricks under the specified brick
+fn bricks_relying_on(brick: &Brick, grid: &HashMap<(i32, i32, i32), Brick>) -> HashSet<Brick> {
-fn under<'a>(brick: &Brick,
+    let mut output = HashSet::new();
-             shadow_bricks: &'a HashMap<(i32, i32), Vec<&Brick>>) -> HashSet<&'a Brick>
+
-{
+    for (x, y, z) in brick.squares() {
-    let mut unders: HashSet<&Brick> = HashSet::new();
+        if let Some(other_brick) = grid.get(&(x,y,z+1)) {
-    for c in brick.shadow() {
+            if other_brick != brick {
-        let mut top_brick: Option<&Brick> = None;
+                output.insert(other_brick.clone());
-        for other_brick in shadow_bricks.get(&c).unwrap() {
-            if other_brick.top() < brick.bottom() {
-                if top_brick.is_none() {
-                    top_brick = Some(other_brick);
-                } else if other_brick.top() > top_brick.unwrap().top() {
-                    top_brick = Some(other_brick);
             }
         }
     }
 
-        if top_brick.is_some() {
+    return output;
-            unders.insert(top_brick.unwrap());
-        }
 }
 
-    return unders;
+fn bricks_relied_on_by(brick: &Brick, grid: &HashMap<(i32, i32, i32), Brick>) -> HashSet<Brick> {
-}
+    let mut output: HashSet<Brick> = HashSet::new();
 
-fn supporting<'a>(brick: &Brick, shadow_bricks: &'a HashMap<(i32, i32), Vec<&Brick>>) -> HashSet<&'a Brick> {
+    for (x, y, z) in brick.squares() {
-    let mut candidates: Vec<&Brick> = Vec::new();
+        if let Some(other_brick) = grid.get(&(x,y,z-1)) {
-    for coordinate in brick.shadow() {
+            if other_brick != brick {
-        candidates.extend(shadow_bricks.get(&coordinate).unwrap());
+                output.insert(other_brick.clone());
             }
-
-    let mut output = HashSet::new();
-    for other_brick in candidates {
-        if other_brick.top() == brick.bottom() - 1 {
-            output.insert(other_brick);
         }
     }
 
     return output;
 }
-fn supported_by<'a>(brick: &Brick, shadow_bricks: &'a HashMap<(i32, i32), Vec<&Brick>>) -> HashSet<&'a Brick> {
-    let mut candidates: Vec<&Brick> = Vec::new();
-    for coordinate in brick.shadow() {
-        candidates.extend(shadow_bricks.get(&coordinate).unwrap());
-    }
 
+fn dependent_bricks(missing_bricks: &HashSet<Brick>, grid: &HashMap<(i32, i32, i32), Brick>) -> HashSet<Brick> {
     let mut output = HashSet::new();
-    for other_brick in candidates {
+
-        if other_brick.bottom() == brick.top() + 1 {
+    for brick in missing_bricks {
+        let above = bricks_relying_on(brick, grid);
+        for other_brick in above {
+            let below = bricks_relied_on_by(&other_brick, grid);
+            if below.is_subset(missing_bricks) && !missing_bricks.contains(&other_brick) {
                 output.insert(other_brick);
             }
         }
-
-    return output;
     }
 
-fn lower(brick: &Brick, below: &Brick) -> Brick {
-    let mut output = brick.clone();
-    let distance = brick.bottom() - below.top() - 1;
-    if distance > 0 {
-        output = Brick{start: (brick.start.0, brick.start.1, brick.start.2 - distance),
-                       end: (brick.end.0, brick.end.1, brick.end.2 - 1)};
-    }
     return output;
 }