Year 2015 Day 12

Author: maneatingape

README.md

@@ -247,3 +247,4 @@ pie
 | 9 | [All in a Single Night](https://adventofcode.com/2015/day/9) | [Source](src/year2015/day09.rs) | 35 |
 | 10 | [Elves Look, Elves Say](https://adventofcode.com/2015/day/10) | [Source](src/year2015/day10.rs) | 14 |
 | 11 | [Corporate Policy](https://adventofcode.com/2015/day/11) | [Source](src/year2015/day11.rs) | 1 |
+| 12 | [JSAbacusFramework.io](https://adventofcode.com/2015/day/12) | [Source](src/year2015/day12.rs) | 80 |

benches/benchmark.rs

@@ -47,6 +47,7 @@ mod year2015 {
     benchmark!(year2015, day09);
     benchmark!(year2015, day10);
     benchmark!(year2015, day11);
+    benchmark!(year2015, day12);
 }
 
 mod year2019 {

input/year2015/day12.txt

@@ -171,6 +171,7 @@ pub mod year2015 {
     pub mod day09;
     pub mod day10;
     pub mod day11;
+    pub mod day12;
 }
 
 /// # Rescue Santa from deep space with a solar system adventure.

src/lib.rs

@@ -87,6 +87,7 @@ fn all_solutions() -> Vec<Solution> {
         solution!(year2015, day09),
         solution!(year2015, day10),
         solution!(year2015, day11),
+        solution!(year2015, day12),
         // 2019
         solution!(year2019, day01),
         solution!(year2019, day02),

src/main.rs

@@ -0,0 +1,117 @@
+//! # JSAbacusFramework.io
+//!
+//! ## Part One
+//!
+//! The utility [`iter_signed`] method extracts numbers from surrounding text and is used directly.
+//!
+//! ## Part Two
+//!
+//! We build a tiny custom JSON parser using a
+//! [parser combinator](https://en.wikipedia.org/wiki/Parser_combinator) approach,
+//! making some simplifying assumptions:
+//! * The input is always well formed and does not contain any whitespace.
+//! * Arrays and objects contain at least one item.
+//! * We don't care about the content of strings, only if they equal "red" or not.
+//!
+//! Each parsing function returns a [`Result`] struct which has 3 fields:
+//! * `next` The index of the character *after* this object. For example parsing "123," returns
+//!   a value of 3 for next.
+//! * `ignore`: Only true for strings that exactly equals "red", false otherwise and always
+//!   false for numbers, arrays and objects.
+//! * `value`: For numbers the literal value, for string zero, for arrays the sum of child
+//!   items, for objects the sum of child items if no "red" property is present, otherwise zero.
+//!
+//! [`iter_signed`]: crate::util::parse
+use crate::util::parse::*;
+
+const RED: &[u8] = "red".as_bytes();
+
+struct Result {
+    next: usize,
+    ignore: bool,
+    value: i32,
+}
+
+pub fn parse(input: &str) -> &str {
+    input
+}
+
+pub fn part1(input: &str) -> i32 {
+    input.iter_signed::<i32>().sum()
+}
+
+pub fn part2(input: &str) -> i32 {
+    parse_json(input.as_bytes(), 0).value
+}
+
+/// Parse JSON that has no whitespace.
+fn parse_json(input: &[u8], start: usize) -> Result {
+    match input[start] {
+        b'[' => parse_array(input, start),
+        b'{' => parse_object(input, start),
+        b'"' => parse_string(input, start),
+        _ => parse_number(input, start),
+    }
+}
+
+/// Parse array assuming it contains at least one element.
+fn parse_array(input: &[u8], start: usize) -> Result {
+    let mut index = start;
+    let mut total = 0;
+
+    while input[index] != b']' {
+        let Result { next, value, .. } = parse_json(input, index + 1);
+        index = next;
+        total += value;
+    }
+
+    Result { next: index + 1, ignore: false, value: total }
+}
+
+/// Parse object assuming it contains at least one key/value pair.
+fn parse_object(input: &[u8], start: usize) -> Result {
+    let mut index = start;
+    let mut total = 0;
+    let mut ignore = false;
+
+    while input[index] != b'}' {
+        let Result { next: first, .. } = parse_json(input, index + 1);
+        let Result { next: second, ignore: red, value } = parse_json(input, first + 1);
+        index = second;
+        total += value;
+        ignore |= red;
+    }
+
+    Result { next: index + 1, ignore: false, value: if ignore { 0 } else { total } }
+}
+
+/// Parse a string evaluating only if it equals "red".
+fn parse_string(input: &[u8], start: usize) -> Result {
+    let start = start + 1;
+    let mut end = start;
+
+    while input[end] != b'"' {
+        end += 1;
+    }
+
+    Result { next: end + 1, ignore: &input[start..end] == RED, value: 0 }
+}
+
+/// Parse an integer value.
+fn parse_number(input: &[u8], start: usize) -> Result {
+    let mut end = start;
+    let mut neg = false;
+    let mut acc = 0;
+
+    if input[end] == b'-' {
+        neg = true;
+        end += 1;
+    }
+
+    while input[end].is_ascii_digit() {
+        acc = 10 * acc + (input[end] - b'0') as i32;
+        end += 1;
+    }
+
+    Result { next: end, ignore: false, value: if neg { -acc } else { acc } }
+}

src/year2015/day12.rs

@@ -40,6 +40,7 @@ mod year2015 {
     mod day09_test;
     mod day10_test;
     mod day11_test;
+    mod day12_test;
 }
 
 mod year2019 {

tests/test.rs

@@ -0,0 +1,15 @@
+use aoc::year2015::day12::*;
+
+const EXAMPLE: &str = r#"[1,{"c":"red","b":2},3]"#;
+
+#[test]
+fn part1_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part1(input), 6);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part2(input), 4);
+}