Advent of Code 2020

(ns aocl.2
  (:gen-class)
  (:require [aocl.core :refer [read-file-into-lines]])
  (:require [clojure.string :as str]))

; Example of a Record, if we wanted ploymorphism and/or dynamic dispatching 
; always use plain hash maps until you really need polymorphism and then decide whether you want
; multi-methods (dispatch on one or more arguments/attributes) 
; or protocols (dispatch on just the type).
(defrecord Password [char min max seq])
; default constructor is
; (->Password char min max seq)

(def input (list (read-file-into-lines "2.txt")))

(defn make-password 
  [char min max seq]
  (hash-map :char (nth char 0) :min min :max max :seq seq))

(defn split-by 
  [input]
  (map #(str/split % #" ") input))

(defn to-flatten-list 
  [tokens]
 (apply list (flatten tokens)))

(defn to-range 
  [raw-range]
  (map #(Integer/parseInt %) ( str/split raw-range #"-")))

(defn token-to-password 
  [token]
  (let [[raw-range char seq] (to-flatten-list token)
       [min max] (to-range raw-range)]
       (make-password char min max seq)))

(defn count-char [char string]
  (loop [i 0 r 0]
    (if (>= i (count string)) r
      (recur 
        (inc i) 
        (if (= (nth string i) char) (inc r) r)))))

(defn is-valid [{:keys [char min max seq]}]
  (let [count (count-char char seq)
        geq-than-min? (>= count min)
        leq-than-max? (<= count max)]
    (and geq-than-min? leq-than-max?)))

(defn count-valid-password [input] 
  (let [tokens (split-by input)
        passwords (map token-to-password tokens)
        valid-passwords (filter is-valid passwords)]
        (count valid-passwords)))

(defn is-valid2 [{:keys [char min max seq]}]
    (let [
          imin (dec min)
          imax (dec max)
          valmin (nth seq imin)
          valmax (nth seq imax)
          both? (and (= valmin char) (= valmax char))
          neither? (and (not= valmin char) (not= valmax char))
          both-or-neither? (or both? neither?)
          any? (or (= valmin char) (= valmax char))
        ]
    (if both-or-neither? false any?)))

(defn count-valid-password2 [input] 
  (let [tokens (split-by input)
        passwords (map token-to-password tokens)
        valid-passwords (filter is-valid2 passwords)]
        (count valid-passwords)))

(def solve1 (list(map count-valid-password input)))
(def solve2 (list(map count-valid-password2 input)))

(def part1 (str "part1: " solve1))
(def part2 (str "part2: " solve2))

(defn -main [& args] (run! println [part1, part2]))

import re


def parse_line(line, parser):
    match = parser.search(line)
    return int(match.group(1)), int(match.group(2)), match.group(3), match.group(4)


def check_range_rule(password, letter, lowerlimit, upperlimit):
    return lowerlimit <= password.count(letter) <= upperlimit


if __name__ == '__main__':

parser = re.compile('([0-9]+)-([0-9]+) ([a-z]): ([a-z]+)')
valid_passwords = 0
with open('input', 'r') as f:
    for line in f.readlines():
        lowerlimit, upperlimit, letter, password = parse_line(line, parser)
        if check_range_rule(password, letter, lowerlimit, upperlimit):
            valid_passwords += 1
print(valid_passwords)

import re


def parse_line(line, parser):
    match = parser.search(line)
    return int(match.group(1)), int(match.group(2)), match.group(3), match.group(4)


def check_positions_rule(password, letter, pos1, pos2):
    return (password[pos1-1] == letter) ^ (password[pos2-1] == letter)


if __name__ == '__main__':

parser = re.compile('([0-9]+)-([0-9]+) ([a-z]): ([a-z]+)')
valid_passwords = 0
with open('input', 'r') as f:
    for line in f.readlines():
        pos1, pos2, letter, password = parse_line(line, parser)
        if check_positions_rule(password, letter, pos1, pos2):
            valid_passwords += 1
print(valid_passwords)

use std::path::Path;
use std::io::BufReader;
use std::io::prelude::*;
use std::fs::File;

fn main() {
    solve_day_2_phase_1();
    solve_day_2_phase_2();
}

struct PasswordPolicy {
    min: usize,
    max: usize,
    char: char,
}

impl PasswordPolicy {
    fn parse(policy_def: &str) -> PasswordPolicy {
        let range: Vec<&str> = policy_def[..policy_def.chars().count() - 2].split('-').collect();
        PasswordPolicy {
            min: range[0].trim().parse::<usize>().unwrap(),
            max: range[1].trim().parse::<usize>().unwrap(),
            char: policy_def.chars().last().unwrap()
        }
    }

fn validate_phase_1(self, password: &str) -> bool {
    return within_range(password.chars().map(|char| {
        return if char == self.char {
            1
        } else {
            0
        }
    }).sum(), self.min, self.max);
}

fn validate_phase_2(self, password: &str) -> bool {
    let expected = Some(self.char);
    return xor(
        password.chars().nth(self.min - 1) == expected,
        password.chars().nth(self.max - 1) == expected);
}
}

fn within_range(val: usize, min: usize, max: usize) -> bool {
    return val >= min && val <= max;
}

fn xor(a: bool, b: bool) -> bool {
    return (a || b) && !(a && b);
}

fn solve_day_2_phase_2() -> usize {
    solve_day_2(2)
}

fn solve_day_2_phase_1() -> usize {
    solve_day_2(1)
}

fn solve_day_2(phase: i32) -> usize {
    let path = Path::new("day_2/src/day_2_input.txt");
    let file = BufReader::new(File::open(&path).unwrap());

let valid_passwords = file.lines()
    .map(|line_result| {
        let line = line_result.unwrap();
        let parsed_line: Vec<&str> = line.split(':').collect::<Vec<&str>>();
        let policy_def = parsed_line[0].trim();
        let password = parsed_line[1].trim();

        let policy = PasswordPolicy::parse(policy_def);
        let valid =
            if phase == 1 { policy.validate_phase_1(password) }
            else { policy.validate_phase_2(password) };

        return if valid { 1 } else { 0 }
    }).sum();

println!("Day 2 Phase {} => Valid passwords {}", phase, valid_passwords);
return valid_passwords;
}