Earthnuker
/
AoC_2020
0
2
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

cargo fmt

This commit is contained in:
Daniel S. 2020-12-03 15:10:04 +01:00
parent 0bb5d960e5
commit 336a03055d
5 changed files with 187 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
src/day1.rs
View File

@ -1,37 +1,46 @@
use aoc_runner_derive::{aoc,aoc_generator}; use aoc_runner_derive::{aoc, aoc_generator};
#[aoc_generator(day1)] #[aoc_generator(day1)]
pub fn input_generator(input: &str) -> Vec<usize> { pub fn input_generator(input: &str) -> Vec<usize> {
input.lines().map(|l| l.trim().parse()).collect::<Result<Vec<usize>,_>>().unwrap() input
.lines()
.map(|l| l.trim().parse())
.collect::<Result<Vec<usize>, _>>()
.unwrap()
} }
#[aoc(day1, part1)] #[aoc(day1, part1)]
pub fn solve_part1(input: &Vec<usize>) -> usize { pub fn solve_part1(input: &Vec<usize>) -> usize {
let mut input=input.clone(); let mut input = input.clone();
input.sort(); input.sort();
for (i1,v1) in input.iter().enumerate() { for (i1, v1) in input.iter().enumerate() {
if v1>&2020 {break;} if v1 > &2020 {
for v2 in input.iter().skip(i1+1) { break;
if (v1+v2)==2020 { }
return v1*v2; for v2 in input.iter().skip(i1 + 1) {
if (v1 + v2) == 2020 {
return v1 * v2;
} }
} }
} }
panic!("No pair summed to 20202!"); panic!("No pair summed to 20202!");
} }
#[aoc(day1, part2)] #[aoc(day1, part2)]
pub fn solve_part2(input: &Vec<usize>) -> usize { pub fn solve_part2(input: &Vec<usize>) -> usize {
let mut input=input.clone(); let mut input = input.clone();
input.sort(); input.sort();
for (i1,v1) in input.iter().enumerate() { for (i1, v1) in input.iter().enumerate() {
if v1>&2020 {break;} if v1 > &2020 {
for (i2,v2) in input.iter().enumerate().skip(i1+1) { break;
if (v1+v2)>2020 {break;} }
for v3 in input.iter().skip(i2+1) { for (i2, v2) in input.iter().enumerate().skip(i1 + 1) {
if (v1+v2+v3)==2020 { if (v1 + v2) > 2020 {
return v1*v2*v3; break;
}
for v3 in input.iter().skip(i2 + 1) {
if (v1 + v2 + v3) == 2020 {
return v1 * v2 * v3;
} }
} }
} }

59
src/day2.rs
View File

@ -1,68 +1,75 @@
use aoc_runner_derive::{aoc,aoc_generator}; use aoc_runner_derive::{aoc, aoc_generator};
#[derive(Debug,PartialEq,Eq,Ord,PartialOrd)] #[derive(Debug, PartialEq, Eq, Ord, PartialOrd)]
pub struct Rule { pub struct Rule {
min: usize, min: usize,
max: usize, max: usize,
ch: char, ch: char,
pw: String pw: String,
} }
impl Rule { impl Rule {
fn is_valid_part1(&self) -> bool { fn is_valid_part1(&self) -> bool {
let n=self.pw.chars().filter(|c| *c==self.ch).count(); let n = self.pw.chars().filter(|c| *c == self.ch).count();
return n>=self.min && n<=self.max; return n >= self.min && n <= self.max;
} }
fn is_valid_part2(&self) -> bool { fn is_valid_part2(&self) -> bool {
let idx_1=self.min-1; let idx_1 = self.min - 1;
let idx_2=self.max-1; let idx_2 = self.max - 1;
let chars: Vec<char> = self.pw.chars().collect(); let chars: Vec<char> = self.pw.chars().collect();
return (chars.get(idx_1)==Some(&self.ch))^(chars.get(idx_2)==Some(&self.ch)) return (chars.get(idx_1) == Some(&self.ch)) ^ (chars.get(idx_2) == Some(&self.ch));
} }
} }
#[aoc_generator(day2)] #[aoc_generator(day2)]
pub fn input_generator(input: &str) -> Vec<Rule> { pub fn input_generator(input: &str) -> Vec<Rule> {
input.lines().map(|l| { input
.lines()
.map(|l| {
let mut ws = l.trim().split_whitespace(); let mut ws = l.trim().split_whitespace();
let range= ws.next().unwrap(); let range = ws.next().unwrap();
let ch= ws.next().unwrap().trim_end_matches(|c| c==':').chars().next().unwrap(); let ch = ws
let pw= ws.next().unwrap().to_owned(); .next()
.unwrap()
.trim_end_matches(|c| c == ':')
.chars()
.next()
.unwrap();
let pw = ws.next().unwrap().to_owned();
let (r_min, r_max) = { let (r_min, r_max) = {
let mut r=range.split('-'); let mut r = range.split('-');
let r_min=r.next().unwrap().parse().unwrap(); let r_min = r.next().unwrap().parse().unwrap();
let r_max=r.next().unwrap().parse().unwrap(); let r_max = r.next().unwrap().parse().unwrap();
(r_min,r_max) (r_min, r_max)
}; };
Rule { Rule {
min:r_min, min: r_min,
max:r_max, max: r_max,
ch, ch,
pw pw,
} }
}).collect::<Vec<Rule>>() })
.collect::<Vec<Rule>>()
} }
#[aoc(day2, part1)] #[aoc(day2, part1)]
pub fn solve_part1(input: &Vec<Rule>) -> usize { pub fn solve_part1(input: &Vec<Rule>) -> usize {
let mut total=0; let mut total = 0;
for rule in input { for rule in input {
if rule.is_valid_part1() { if rule.is_valid_part1() {
total+=1; total += 1;
} }
} }
total total
} }
#[aoc(day2, part2)] #[aoc(day2, part2)]
pub fn solve_part2(input: &Vec<Rule>) -> usize { pub fn solve_part2(input: &Vec<Rule>) -> usize {
let mut total=0; let mut total = 0;
for rule in input { for rule in input {
if rule.is_valid_part2() { if rule.is_valid_part2() {
total+=1; total += 1;
} }
} }
total total
} }

61
src/day3.rs
View File

@ -1,54 +1,57 @@
use aoc_runner_derive::{aoc,aoc_generator}; use aoc_runner_derive::{aoc, aoc_generator};
pub struct Forest { pub struct Forest {
slice: Vec<Vec<bool>>, slice: Vec<Vec<bool>>,
} }
impl Forest { impl Forest {
fn get(&self, x: usize,y: usize) -> Option<bool> { fn get(&self, x: usize, y: usize) -> Option<bool> {
self.slice.get(y).map(|line| line.get(x%line.len())).flatten().cloned() self.slice
.get(y)
.map(|line| line.get(x % line.len()))
.flatten()
.cloned()
} }
} }
#[aoc_generator(day3)] #[aoc_generator(day3)]
pub fn input_generator(input: &str) -> Forest { pub fn input_generator(input: &str) -> Forest {
let slice=input.lines().map(|l| l.chars().map(|c| c=='#').collect()).collect(); let slice = input
Forest{ .lines()
slice .map(|l| l.chars().map(|c| c == '#').collect())
} .collect();
Forest { slice }
} }
#[aoc(day3,part1)] #[aoc(day3, part1)]
pub fn solve_part1(input: &Forest) -> usize { pub fn solve_part1(input: &Forest) -> usize {
let mut sum: usize=0; let mut sum: usize = 0;
let dx=3; let dx = 3;
let dy=1; let dy = 1;
let mut pos=(0,0); let mut pos = (0, 0);
while let Some(tree) = input.get(pos.0,pos.1) { while let Some(tree) = input.get(pos.0, pos.1) {
if tree { if tree {
sum+=1; sum += 1;
}
pos.0 += dx;
pos.1 += dy;
} }
pos.0+=dx;
pos.1+=dy;
};
sum sum
} }
#[aoc(day3, part2)]
#[aoc(day3,part2)]
pub fn solve_part2(input: &Forest) -> usize { pub fn solve_part2(input: &Forest) -> usize {
let mut prod: usize = 1; let mut prod: usize = 1;
for (dx,dy) in &[(1,1),(3,1),(5,1),(7,1),(1,2)] { for (dx, dy) in &[(1, 1), (3, 1), (5, 1), (7, 1), (1, 2)] {
let mut sum: usize=0; let mut sum: usize = 0;
let mut pos=(0,0); let mut pos = (0, 0);
while let Some(tree) = input.get(pos.0,pos.1) { while let Some(tree) = input.get(pos.0, pos.1) {
if tree { if tree {
sum+=1; sum += 1;
} }
pos.0+=dx; pos.0 += dx;
pos.1+=dy; pos.1 += dy;
}; }
prod*=sum; prod *= sum;
} }
prod prod
} }