From 8c455609328667c6edca55938f717b628fc55ebd Mon Sep 17 00:00:00 2001
From: Jan Tuomi <jan.tuomi@eficode.com>
Date: Sat, 15 Dec 2018 15:09:20 +0200
Subject: Solve day12.1 with naive vectors

---
 day12/src/main.rs | 111 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 111 insertions(+)
 create mode 100644 day12/src/main.rs

(limited to 'day12/src')

diff --git a/day12/src/main.rs b/day12/src/main.rs
new file mode 100644
index 0000000..6b421e4
--- /dev/null
+++ b/day12/src/main.rs
@@ -0,0 +1,111 @@
+use std::env;
+use std::io::BufReader;
+use std::io::BufRead;
+use std::fs::File;
+use std::process;
+use std::collections::HashMap;
+
+type State = Vec<(i64, char)>;
+type RuleKey = (char, char, char, char, char);
+type Rules = HashMap<RuleKey, char>;
+
+static ITERATIONS: usize = 20;
+
+fn parse_initial_state(line: &String) -> State {
+  let initial: Vec<char> = line[15..].chars().collect();
+  let mut slice: State = Vec::new();
+  for i in -(ITERATIONS as i64) - 2..0 {
+    slice.push((i, '.'));
+  }
+  for (i, ch) in initial.iter().enumerate() {
+    slice.push((i as i64, *ch));
+  }
+  for i in initial.len()..initial.len() + ITERATIONS + 2 {
+    slice.push((i as i64, '.'));
+  }
+  for (i, _) in &slice {
+    print!("{} ", i);
+  }
+  print!("\n");
+  slice
+}
+
+fn parse_rule(rules: &mut Rules, line: &String) {
+  let chs: Vec<char> = line.chars().collect();
+  let res: char = chs[chs.len() - 1];
+  let p = chs[0..6].to_vec();
+  let rule_key = (p[0], p[1], p[2], p[3], p[4]);
+  rules.insert(rule_key, res);
+}
+
+fn main() {
+  let args: Vec<String> = env::args().collect();
+  if args.len() != 2 {
+    println!("Wrong number of arguments. Provide a file name and worker count.");
+    process::exit(1);
+  }
+  let filename = &args[1];
+
+  println!("Using file {} as input.", filename);
+  let f = match File::open(filename) {
+    Ok(file) => file,
+    Err(e) => {
+      println!("Failed to open file {}. {:?}", filename, e);
+      process::exit(1);
+    }
+  };
+  let file = BufReader::new(&f);
+  let lines: Vec<String> = file.lines()
+    .map(|line| line.expect("Could not parse line."))
+    .collect();
+
+  let mut initial_state: State = Vec::new();
+  let mut rules: Rules = HashMap::new();
+  for (i, line) in lines.iter().enumerate() {
+    match i {
+      0 => { initial_state = parse_initial_state(&line); }
+      1 => { }
+      _ => { parse_rule(&mut rules, &line); }
+    }
+  }
+  assert_ne!(initial_state.len(), 0);
+
+  let state_len = initial_state.len();
+  let mut states: Vec<State> = vec![initial_state];
+  for iteration in 0..ITERATIONS {
+    let mut new_state: State = vec![(-999, '.'); state_len];
+    {
+      let prev_state = &states[states.len() - 1];
+      for (i, _) in prev_state.iter().enumerate() {
+        if i < 2 || i >= state_len - 2 { continue; }
+        let rule_key = (prev_state[i-2].1, prev_state[i-1].1, prev_state[i].1, prev_state[i+1].1, prev_state[i+2].1);
+        let value = rules[&rule_key];
+        new_state[i] = (prev_state[i].0, value);
+      }
+    }
+    if iteration % 1000 == 0 {
+      println!("Iteration: {}", iteration);
+    }
+    states.push(new_state);
+  }
+
+  for (i, state) in states.iter().enumerate() {
+    print!("{}: ", i);
+    for tupl in state {
+      let ch = tupl.1;
+      print!("{}", ch);
+    }
+    print!("\n");
+  }
+
+  let mut total = 0;
+  let last_i = states.len() - 1;
+  let last_state = &states[last_i];
+  for (_, &tupl) in last_state.iter().enumerate() {
+    let (i, ch) = tupl;
+    if ch == '#' {
+      total += i;
+    }
+  }
+  println!("Result: {}", total);
+}
-- 
cgit v1.3