burntsushi / advent-of-code Goto Github PK

fn react (input: &str) -> String {
    let polymer: Vec<char> = input.chars().collect();
    let mut stable: Vec<char> = vec![];

    let mut c = polymer.iter().peekable();
    
    match c.next() {
        Some(first) => {
            match c.peek() {
                Some(second) => {
                    if first.is_uppercase()
                        && second.is_lowercase()
                        && *first != second.to_uppercase() {
                        stable.push(*first);
                        stable.push(**second);
                    }
                },
                None => stable.push(*first),
            }
        },
        None => {},
    }

    stable.into_iter().collect()
}

extern crate chrono;
extern crate regex;

use std::fs;
use regex::Regex;
use std::collections::HashMap;
use chrono::prelude::*;

const FILE_NAME: &str = "./input.txt";

struct Record {
    guard_id: String,
    date_time: DateTime<Utc>,
    fulldate: String,
    // date: String,
    // hour: String,
    minute: String,
    description: String,
}

struct Guard {
    id: String,
    minutes: Vec<(i64, i64)>,
    most_minute_asleep: (i64, i64),
    total_asleep: i64,
}

fn get_guards() {
    let content = fs::read_to_string(FILE_NAME).unwrap();
    let re = Regex::new(r"\[(\d+-\d+-\d+) (\d+):(\d+)\]( Guard #)?(\d+)? (.*)").unwrap();
    let mut records: Vec<Record> = Vec::new();

    for line in content.lines() {
        match re.captures(line) {
            Some(captures) => {
                let date = captures.get(1).unwrap().as_str().to_string();
                let hour = captures.get(2).unwrap().as_str().to_string();
                let minute = captures.get(3).unwrap().as_str().to_string();
                let fulldate = format!("{}T{}:{}:00Z", date, hour, minute);
                let description = captures.get(6).unwrap().as_str().to_string();
                let guard_id = match captures.get(5) {
                    Some(matcher) => matcher.as_str().to_string(),
                    None => String::from("")
                };
                let date_time = fulldate.parse::<DateTime<Utc>>().unwrap();

                records.push(Record {
                    guard_id,
                    date_time,
                    fulldate,
                    // date,
                    // hour,
                    minute,
                    description,
                });
            },
            None => {}
        }
    }

    records.sort_by(|record_a, record_b| record_a.date_time.cmp(&record_b.date_time));
    println!("records size: {}", records.len());

    let mut guards: HashMap<String, Guard> = HashMap::new();
    let mut current_guard: &mut Guard = &mut Guard { id: String::from(""), minutes: Vec::new(), most_minute_asleep: (0, 0), total_asleep: 0 };
    let mut last_date_time = Utc::now();
    let mut last_minute = String::from("");
    let mut minutes: HashMap<i64, i64> = HashMap::new();
    let mut sorted_minutes = Vec::new();

    for record in records {
        let Record { guard_id, date_time, description, minute, .. } = record;

        if !guard_id.is_empty() { // empty guard_id means we are changing guard
            current_guard = guards.entry(guard_id.clone()).or_insert(Guard {
                id: guard_id.clone(),
                minutes: Vec::new(),
                most_minute_asleep: (0, 0),
                total_asleep: 0,
            });

            for (minute, times) in minutes.iter() {
                sorted_minutes.push((minute.clone(), times.clone()));
            }
            sorted_minutes.sort_by(|minute_a, minute_b| minute_b.1.cmp(&minute_a.1));

            current_guard.minutes = sorted_minutes.drain(..).collect();
            current_guard.most_minute_asleep = match current_guard.minutes.get(0) {
                Some(value) => value.clone(),
                None => (0, 0)
            };

            minutes.clear();
            sorted_minutes.clear();
        }

        if description == "falls asleep" {
            last_date_time = date_time.clone();
            last_minute = minute.clone();
        }

        if description == "wakes up" {
            current_guard.total_asleep += (date_time - last_date_time).num_minutes() + 1;

            let num_minutes = (date_time - last_date_time).num_minutes();

            for min in 0..num_minutes {
                *minutes.entry(last_minute.parse::<i64>().unwrap() + min).or_insert(0) += 1;
            }
        }
    }
}

fn main() {
    get_guards();
}

use std::collections::HashSet;

pub fn count_dups (id: &str) -> (u32, u32) {
    let (mut twos, mut threes) = (false, false);
    let mut unique_chars = HashSet::new();

    for c in id.chars() {
        let unique = unique_chars.insert(c);
        if !unique {
            let count = id.matches(c).count();
            if count == 2 {
                twos = true;
            }
            if count == 3 {
                threes = true;
            }
        }
    }
    (twos as u32, threes as u32)
}

#[aoc(day2, part1)]
pub fn find_checksum (ids: &str) -> u32 {
    let (twos, threes) = ids
        .lines()
        .fold((0, 0), |counts, id| {
            let dups = count_dups(id);
            (counts.0 + dups.0, counts.1 + dups.1)
        });
    twos * threes        
}

// ...
    let mut nodes = HashMap::<i32, Node>::new();

// ... loop {
                let ref_nodes = nodes.clone();
                nodes.entry(current_id)
                    .and_modify(|node| node.add_metadata(value, ref_nodes));
// ... }

#[derive(Debug, Clone)]
struct Node {
    id: i32,
    parent: Option<i32>,
    value: i32,
    childs_count: i32,
    childs: Vec<i32>,
    metadatas_count: i32,
    metadatas: Vec<i32>,
}

impl Node {
    fn has_metadatas (&self) -> bool {
        self.metadatas_count == self.metadatas.len() as i32
    }

    fn add_metadata (&mut self, metadata: i32, nodes: HashMap<i32, Node>) {
        self.metadatas.push(metadata);

        if self.has_metadatas() {
            self.value = self.metadatas.iter().fold(
                0,
                |acc, curr| {
                    if self.childs_count == 0 {
                        return acc + curr;
                    }
                    return acc + match self.childs.get(*curr as usize - 1) {
                        None => 0,
                        Some(child_id) => nodes.get(&child_id).unwrap().clone().value,
                    }
                }
            );
        }
    }
}

fn main() {
    let content = fs::read_to_string(FILE_NAME)
        .expect("Error while reading the input file");

    let mut previous = HashSet::new();
    let mut count = 0;

    previous.insert(count);

    for line in content.lines() {
        if !line.is_empty() {
            let current: i32 = line.parse()
                .expect("Error while parsing line");

            count += current;

            if previous.contains(&count) { // I NEVER PASS THIS CONDITION, WHY? :(
                println!("here! {}", count);
                break;
            }

            previous.insert(count);
        }
    }

    println!("{}", count);
}

fn reaction (polymer: &Vec<char>) -> Vec<char> {
    let mut stable: Vec<char> = vec![];

    let mut c = polymer.iter().peekable();
    let mut skip_char = false;

    while let Some(first) = c.next() {
        if skip_char {
            skip_char = false;
            continue;
        }

        match c.peek() {
            Some(second) => {
                if will_react(first, second) {
                    skip_char = true;
                } else {
                    stable.push(*first);
                }
            },
            None => stable.push(*first),
        }
    }

    stable
}