Add pathalogical parser benchmark

Author: nrc

inflate-0.1.0/Cargo.lock

@@ -0,0 +1,6 @@
+[package]
+name = "day15"
+version = "0.1.0"
+authors = ["Jed Davis <[email protected]>"]
+[dependencies]
+combine = "1.2.0"

jld-day15-parser/Cargo.toml

@@ -0,0 +1,7 @@
+all:
+	$(CARGO_BUILD)
+touch:
+	rm target/debug/*
+clean:
+	rm target -rf
+	rm Cargo.lock

jld-day15-parser/makefile

@@ -0,0 +1,22 @@
+extern crate combine;
+
+mod parser;
+
+pub type Num = i64;
+
+pub struct Stats {
+    pub capacity: Num,
+    pub durability: Num,
+    pub flavor: Num,
+    pub texture: Num,
+    pub calories: Num,
+}
+impl Stats {
+    fn zero() -> Stats {
+        Stats { capacity: 0, durability: 0, flavor: 0, texture: 0, calories: 0 }
+    }
+}
+
+fn main() {
+    println!("Hello, world!");
+}

jld-day15-parser/src/main.rs

@@ -0,0 +1,50 @@
+use std::collections::HashMap;
+use std::iter::FromIterator;
+use std::str::FromStr;
+
+use combine::{digit,letter,sep_by,many1,char,string,not_followed_by,any,
+              Parser,ParserExt,ParseError};
+
+use ::{Num,Stats};
+
+pub enum SemanticError {
+    DupStat(String, Num, Num),
+    MissingStat(&'static str),
+}
+pub type SyntaxError<'a> = ParseError<&'a str>;
+
+struct MaybeStats(Result<Stats, SemanticError>);
+impl FromIterator<(String,Num)> for MaybeStats {
+    fn from_iter<T>(ii: T) -> Self where T: IntoIterator<Item=(String,Num)> {
+        let squash_plist = move || {
+            let mut tab: HashMap<String,Num> = HashMap::new();
+            for (key, val) in ii {
+                if let Some(oldval) = tab.insert(key.clone(), val) {
+                    return Err(SemanticError::DupStat(key, oldval, val));
+                }
+            }
+            let get = |key| {
+                tab.get(key).ok_or(SemanticError::MissingStat(key))
+            };
+            Ok(Stats {
+                capacity: *try!(get("capacity")),
+                durability: *try!(get("durability")),
+                flavor: *try!(get("flavor")),
+                texture: *try!(get("texture")),
+                calories: *try!(get("calories")),
+            })
+        };
+        MaybeStats(squash_plist())
+    }
+}
+
+pub fn parse(s: &str) -> Result<(String, Result<Stats, SemanticError>), SyntaxError> {
+    let num = many1(digit().or(char('-'))).and_then(|s: String| Num::from_str(&s));
+    let prop = (many1(letter())).skip(char(' ')).and(num);
+    let plist = sep_by::<MaybeStats, _, _>(prop, string(", "));
+    let mut ingred = many1(letter()).skip(string(": ")).and(plist).skip(not_followed_by(any()));
+
+    let ((name, MaybeStats(ms)), rest) =  try!(ingred.parse(s));
+    assert!(rest == "");
+    Ok((name, ms))
+}

jld-day15-parser/src/parser.rs

@@ -0,0 +1,109 @@
+use std::cmp::{min,max};
+
+use util::best;
+use ::{Stats,Num,Qty};
+
+type Best = best::Best<Num, Vec<Qty>, best::Largest>;
+
+trait CookieMonitor {
+    fn judge(&self, after: usize, left: Qty, acc: &Stats) -> bool;
+}
+
+struct Whatever;
+impl CookieMonitor for Whatever {
+    fn judge(&self, _after: usize, _left: Qty, _acc: &Stats) -> bool {
+        true
+    }
+}
+
+struct CalorieCounter {
+    mincals: Vec<Num>,
+    maxcals: Vec<Num>,
+    target: Num,
+}
+impl CalorieCounter {
+    fn new(stats: &[Stats], target: Num) -> CalorieCounter {
+        let c0 = stats[0].calories;
+        let (imin, imax) = stats.iter().scan((c0, c0), |state, stat| {
+            let (lmin, lmax) = *state;
+            *state = (min(lmin, stat.calories), max(lmax, stat.calories));
+            Some(*state)
+        }).unzip();
+        CalorieCounter {
+            mincals: imin,
+            maxcals: imax,
+            target: target
+        }
+    }
+}
+impl CookieMonitor for CalorieCounter {
+    fn judge(&self, after: usize, left: Qty, acc: &Stats) -> bool {
+        let left = Num::from(left);
+        let rest = self.target - acc.calories;
+        rest >= self.mincals[after] * left && rest <= self.maxcals[after] * left
+    }
+}
+
+struct ExhCtx<'s> {
+    stats: &'s [Stats],
+    qtys: Vec<Qty>,
+    best: Best,
+}
+
+fn exh_recur<M: CookieMonitor>(ctx: &mut ExhCtx, mon: &M, i: usize, left: Qty, acc: Stats) {
+    if !mon.judge(i, left, &acc) {
+        return;
+    }
+    if i == 0 {
+        ctx.qtys[i] = left;
+        ctx.best.add((acc + ctx.stats[i].clone() * left).eval(), &ctx.qtys);
+    } else {
+        for this in 0..(left+1) {
+            ctx.qtys[i] = this;
+            exh_recur(ctx, mon, i - 1, left - this, acc.clone() + ctx.stats[i].clone() * this);
+        }
+    }
+}
+
+pub fn exhaustive(stats: &[Stats], total: Qty, opt_cals: Option<Num>) -> (Num, Vec<Qty>) {
+    assert!(stats.len() >= 1);
+    let mut ctx = ExhCtx {
+        stats: stats,
+        qtys: vec![!0; stats.len()],
+        best: Best::new(best::Largest),
+    };
+    let n1 = stats.len() - 1;
+    match opt_cals {
+        None => exh_recur(&mut ctx, &Whatever, n1, total, Stats::zero()),
+        Some(cals) => {
+            let mon = CalorieCounter::new(stats, cals);
+            exh_recur(&mut ctx, &mon, n1, total, Stats::zero())
+        },
+    };
+    ctx.best.unwrap()
+}
+
+// Conjecture: this problem is amenable to hill-climbing.  ...without
+// the part 2 addendum, at least.  Probably still is even with it,
+// with a little more subtlety, since everything except the final
+// metric is linear.
+
+#[cfg(test)]
+mod tests {
+    use super::exhaustive;
+    use ::{Stats};
+
+    #[test]
+    fn example1() {
+        let bt = Stats { capacity: -1, durability: -2, flavor: 6, texture: 3, calories: 8 };
+        let cn = Stats { capacity: 2, durability: 3, flavor: -2, texture: -1, calories: 3 };
+        assert_eq!(exhaustive(&[bt, cn], 100, None), (62842880, vec![44, 56]));
+    }
+
+    #[test]
+    fn example2() {
+        let bt = Stats { capacity: -1, durability: -2, flavor: 6, texture: 3, calories: 8 };
+        let cn = Stats { capacity: 2, durability: 3, flavor: -2, texture: -1, calories: 3 };
+        assert_eq!(exhaustive(&[bt, cn], 100, Some(500)), (57600000, vec![40, 60]));
+    }
+}

jld-day15-parser/src/search.rs

@@ -0,0 +1,91 @@
+use std::ops::Deref;
+
+#[derive(Debug, Clone)]
+pub struct AutoVec<T: Default>(Vec<T>);
+
+impl<T: Default> AutoVec<T> {
+    pub fn new() -> Self { AutoVec(Vec::new()) }
+    fn ensure_len(&mut self, len: usize) {
+        while len > self.0.len() {
+            self.0.push(T::default());
+        }
+    }
+    pub fn into_boxed_slice(mut self, len: usize) -> Box<[T]> {
+        self.ensure_len(len);
+        self.0.into_boxed_slice()
+    }
+    pub fn at(&mut self, i: usize) -> &mut T {
+        self.ensure_len(i + 1);
+        &mut self.0[i]
+    }
+}
+
+impl<T: Default> Default for AutoVec<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl <T: Default> Deref for AutoVec<T> {
+    type Target = Vec<T>;
+    fn deref(&self) -> &Vec<T> {
+        &self.0
+    }
+}
+
+impl <T: Default> IntoIterator for AutoVec<T> {
+    type Item = T;
+    type IntoIter = <Vec<T> as IntoIterator>::IntoIter;
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::AutoVec;
+
+    #[test]
+    fn empty() {
+        let v: AutoVec<i32> = AutoVec::new();
+        assert_eq!(v.0, vec![]);
+    }
+
+    #[test]
+    fn one() {
+        let mut v = AutoVec::new();
+        *v.at(0) = 17;
+        assert_eq!(v.0, vec![17]);
+    }
+
+    #[test]
+    fn two() {
+        let mut v = AutoVec::new();
+        *v.at(1) = 17;
+        assert_eq!(*v, vec![0, 17]);
+        *v.at(0) = 23;
+        assert_eq!(v.0, vec![23, 17]);
+    }
+
+    #[test]
+    fn sadness() {
+        let mut v = AutoVec::new();
+        let _: &mut i32 = v.at(5);
+        assert_eq!(v.0, vec![0,0,0,0,0,0]);
+    }
+
+    #[test]
+    fn autoderef() {
+        let mut v = AutoVec::new();
+        assert_eq!(v.len(), 0);
+        *v.at(3) = 1000;
+        assert_eq!(v.iter().collect::<Vec<_>>(), vec![&0, &0, &0, &1000]);
+    }
+
+    #[test]
+    fn move_iter() {
+        let mut v = AutoVec::new();
+        *v.at(3) = 1000;
+        assert_eq!(v.into_iter().collect::<Vec<_>>(), vec![0, 0, 0, 1000]);
+    }
+}