9/src/main.rs

@@ -1,3 +1,4 @@
+use std::collections::LinkedList;
 use std::fmt::{Display, Write};
 use std::fs::File;
 use std::io::{BufRead, BufReader, Lines};
@@ -52,7 +53,6 @@ struct Inode {
 struct DiskMap {
     map: Vec<Unit>,
     files: Vec<Inode>,
-    frees: Vec<Inode>,
 }
 
 impl<T: BufRead> From<Lines<T>> for DiskMap {
@@ -62,9 +62,8 @@ impl<T: BufRead> From<Lines<T>> for DiskMap {
         let mut file_id = 0;
         let mut map = Vec::new();
         let mut files = Vec::new();
-        let mut frees = Vec::new();
-        for (i, c) in line.iter().enumerate() {
-            let len = c - b'0';
+        for i in 0..line.len() {
+            let len = line[i] - b'0';
             if i % 2 == 0 {
                 // file
                 files.push(Inode {
@@ -78,17 +77,12 @@ impl<T: BufRead> From<Lines<T>> for DiskMap {
                 file_id += 1;
             } else {
                 // free
-                frees.push(Inode {
-                    id: 0,
-                    pos: map.len(),
-                    len,
-                });
                 for _ in 0..len {
                     map.push(Unit::Free)
                 }
             }
         }
-        Self { map, files, frees }
+        Self { map, files }
     }
 }
 
@@ -121,28 +115,43 @@ impl DiskMap {
 
 fn problem1<T: BufRead>(input: Lines<T>) -> u64 {
     let mut map = DiskMap::from(input);
-    let mut last_free = 0;
-    for file in map.files.iter().rev() {
+    let mut i = map.map.len() - 1;
+    while i != 0 {
+        // find start index of 'file'
+        if map.map[i] == Unit::Free {
+            i -= 1;
+            continue;
+        };
+        let mut len = 1;
+        while i >= 1 && map.map[i] == map.map[i - 1] {
+            i -= 1;
+            len += 1;
+        }
+        let file_id = match map.map[i] {
+            Unit::File(id) => id,
+            _ => panic!(),
+        };
         let frees = map
             .map
             .iter()
             .enumerate()
-            .skip(last_free) // we greedy fill, so no need to check for free space before the last one we used
-            .take(file.pos + file.len as usize) // and we only need to search until the end of the current file
-            .filter(|(_i, u)| **u == Unit::Free || **u == Unit::File(file.id)) // look for free space or our existing space
+            .take(i + len + 1)
+            .filter(|(_i, u)| **u == Unit::Free || **u == Unit::File(file_id))
             .map(|(i, _u)| i)
-            .take(file.len as usize) // get the first file.len free blocks
+            .take(len)
             .collect_vec();
-        // Note: no need to test for too small frees list here, since we are guaranteed at worst to find our current position
-        if frees[0] >= file.pos {
-            // if the first available free is > file.pos, it's fully packed, job done
-            break;
+        if frees[0] >= i {
+            if i > 0 {
+                i -= 1;
+            }
+            continue;
         }
-        #[allow(clippy::needless_range_loop)]
-        for j in 0..file.len as usize {
-            map.map.swap(frees[j], file.pos + j);
+        for j in 0..len {
+            map.map.swap(frees[j], i + j);
+        }
+        if i > 0 {
+            i -= 1;
         }
-        last_free = frees[file.len as usize - 1]
     }
     map.checksum()
 }
@@ -150,27 +159,30 @@ fn problem1<T: BufRead>(input: Lines<T>) -> u64 {
 // PROBLEM 2 solution
 fn problem2<T: BufRead>(input: Lines<T>) -> u64 {
     let mut map = DiskMap::from(input);
+    // println!("before: {}", map);
     for file in map.files.iter().rev() {
-        let free = map.frees.iter_mut().find(|inode| inode.len >= file.len); // find the first entry in the free space map large enough
-        if let Some(free) = free {
-            if free.pos >= file.pos {
-                // if it's past our position, continue, but can't break since there might be free space for future files
-                continue;
-            }
+        let free_pos = map
+            .map
+            .windows(file.len as usize)
+            .take(file.pos)
+            .enumerate()
+            .find(|(_i, u)| {
+                u.iter().all(|u| match u {
+                    Unit::Free => true,
+                    _ => false,
+                })
+            })
+            .map(|(i, _)| i);
+        if let Some(free_pos) = free_pos {
+            // println!("moving {}@{:?} to {}", file.id, file.pos, free_pos);
             for j in 0..file.len {
-                map.map.swap(free.pos + j as usize, file.pos + j as usize);
+                map.map[free_pos + j as usize] = map.map[file.pos + j as usize];
+                map.map[file.pos + j as usize] = Unit::Free;
             }
-            // Note: It is slightly faster to keep these hanging around in the free map with size = 0 then to remove them from the vec
-            free.len -= file.len;
-            free.pos += file.len as usize;
-
-            map.frees.push(Inode {
-                id: 0,
-                pos: file.pos,
-                len: file.len,
-            });
+            // println!("after:  {}", map);
         }
     }
+    // println!("after:  {}", map);
     map.checksum()
 }