Tidy 2016

Author: maneatingape

src/year2016/day06.rs

@@ -1,6 +1,6 @@
 //! # Signals and Noise
 //!
-//! The cardinality of uppercase letters is only 26 so we can use a fixed-size array to
+//! The cardinality of lowercase letters is only 26 so we can use a fixed-size array to
 //! count the frequency of each character efficiently.
 type Input = (String, String);
 

src/year2016/day09.rs

@@ -1,8 +1,6 @@
 //! # Explosives in Cyberspace
 //!
 //! The only difference between part one and two is that we recursively decompress inner sequences.
-use crate::util::parse::*;
-
 pub fn parse(input: &str) -> &[u8] {
     input.trim().as_bytes()
 }
@@ -35,15 +33,8 @@ fn decompress(mut slice: &[u8], part_two: bool) -> usize {
 }
 
 fn number(slice: &[u8]) -> (&[u8], usize) {
-    // Parse number digit by digit.
-    let mut index = 0;
-    let mut acc = 0;
-
-    while slice[index].is_ascii_digit() {
-        acc = 10 * acc + slice[index].to_decimal() as usize;
-        index += 1;
-    }
-
+    let end = slice.iter().position(|b| !b.is_ascii_digit()).unwrap();
+    let n = slice[..end].iter().fold(0, |n, &b| 10 * n + (b - b'0') as usize);
     // Skip over trailing delimiter.
-    (&slice[index + 1..], acc)
+    (&slice[end + 1..], n)
 }

src/year2016/day11.rs

@@ -118,9 +118,7 @@ pub fn parse(input: &str) -> u32 {
         if non_empty && pair == PAIR1 {
             steps += 12;
         } else {
-            if (pair & PAIR1) != 0 {
-                non_empty = true;
-            }
+            non_empty |= pair & PAIR1 != 0;
             floors[i] = pair;
             i += 1;
         }
@@ -155,6 +153,16 @@ fn bfs(start: State, steps: u32) -> u32 {
 
         // Iterate over items that can be moved.
         let items = state.pairs & (FLOOR1 << state.elevator);
+        let mut push = |up: bool, mask: u64| -> bool {
+            if let Some(next) = state.move_floor(up, mask)
+                && seen.insert(next)
+            {
+                todo.push_back((next, steps + 1));
+                true
+            } else {
+                false
+            }
+        };
 
         // When moving down, try one item first; try two only if one didn't work.
         // Don't move down from bottom floor, or down into empty region.
@@ -165,22 +173,12 @@ fn bfs(start: State, steps: u32) -> u32 {
             let mut added = false;
 
             for i in items.biterator() {
-                if let Some(next) = state.move_floor(false, 1 << i)
-                    && seen.insert(next)
-                {
-                    added = true;
-                    todo.push_back((next, steps + 1));
-                }
+                added |= push(false, 1 << i);
             }
-
             if !added {
                 for i in items.biterator() {
                     for j in items.biterator().take_while(|&j| j < i) {
-                        if let Some(next) = state.move_floor(false, (1 << i) | (1 << j))
-                            && seen.insert(next)
-                        {
-                            todo.push_back((next, steps + 1));
-                        }
+                        push(false, (1 << i) | (1 << j));
                     }
                 }
             }
@@ -193,22 +191,12 @@ fn bfs(start: State, steps: u32) -> u32 {
 
             for i in items.biterator() {
                 for j in items.biterator().take_while(|&j| j < i) {
-                    if let Some(next) = state.move_floor(true, (1 << i) | (1 << j))
-                        && seen.insert(next)
-                    {
-                        added = true;
-                        todo.push_back((next, steps + 1));
-                    }
+                    added |= push(true, (1 << i) | (1 << j));
                 }
             }
-
             if !added {
                 for i in items.biterator() {
-                    if let Some(next) = state.move_floor(true, 1 << i)
-                        && seen.insert(next)
-                    {
-                        todo.push_back((next, steps + 1));
-                    }
+                    push(true, 1 << i);
                 }
             }
         }

src/year2016/day15.rs

@@ -20,12 +20,12 @@ pub fn parse(input: &str) -> Pair {
     [part1, part2]
 }
 
-pub fn part1(results: &Pair) -> usize {
-    results[0]
+pub fn part1(input: &Pair) -> usize {
+    input[0]
 }
 
-pub fn part2(results: &Pair) -> usize {
-    results[1]
+pub fn part2(input: &Pair) -> usize {
+    input[1]
 }
 
 fn solve(discs: &[Pair], offset: usize, mut time: usize, mut step: usize) -> (usize, usize) {

src/year2016/day16.rs

@@ -41,7 +41,6 @@
 //! showing how to utilize that approach. However, the logarithmic solution shown here is
 //! fast enough to not need to worry about askalski's comment "I have no idea why it works,
 //! only that it does work."
-use crate::util::parse::*;
 
 /// Build a prefix sum of the number of ones at each length in the pattern
 /// including zero at the start.
@@ -50,7 +49,7 @@ pub fn parse(input: &str) -> Vec<usize> {
     let mut ones = vec![0];
 
     for b in input.trim().bytes() {
-        sum += b.to_decimal() as usize;
+        sum += (b & 1) as usize;
         ones.push(sum);
     }
 
@@ -71,7 +70,7 @@ pub fn part2(input: &[usize]) -> String {
 /// ones in each interval to give the checksum.
 pub fn checksum(input: &[usize], disk_size: usize) -> String {
     // Determine how many blocks and how big each one is, by lowest 1-bit in disk_size.
-    let step_size = disk_size & (!disk_size + 1);
+    let step_size = 1 << disk_size.trailing_zeros();
     let blocks = disk_size / step_size;
 
     let counts: Vec<_> = (0..blocks + 1).map(|i| count(input, i * step_size)).collect();