Advent of Code 2020

import re

blank_regex = re.compile(r'(?:\n){2,}')

passports = re.split(blank_regex, open('input.txt', 'r').read().strip())

valid_passports = 0

def byr_rule(x):
    byr_regex = re.compile(r'^([0-9]{4})$')
    match = re.match(byr_regex, x)
    if match is not None:
        val = int(match.group(1))
        return val >= 1920 and val <= 2002
    return False


def iyr_rule(x):
    iyr_regex = re.compile(r'^([0-9]{4})$')
    match = re.match(iyr_regex, x)
    if match is not None:
        val = int(match.group(1))
        return val >= 2010 and val <= 2020
    return False


def eyr_rule(x):
    eyr_regex = re.compile(r'^([0-9]{4})$')
    match = re.match(eyr_regex, x)
    if match is not None:
        val = int(match.group(1))
        return val >= 2020 and val <= 2030
    return False


def height_rule(x):
    height_regex = re.compile(r'^([0-9]+)(cm|in)$')
    match = re.match(height_regex, x)
    if match is not None and len(match.groups()) == 2:
        height, units = int(match.group(1)), match.group(2)
        if units == 'cm':
            return height >= 150 and height <= 193
        return height >= 59 and height <= 76
    return False


def hcl_rule(x):
    hcl_regex = re.compile(r'^#[0-9a-f]{6}$')
    return re.match(hcl_regex, x) is not None


def pid_rule(x):
    pid_regex = re.compile(r'^[0-9]{9}$')
    return re.match(pid_regex, x) is not None


rules = {
    'byr': byr_rule,
    'iyr': iyr_rule,
    'eyr': eyr_rule,
    'hgt': height_rule,
    'hcl': hcl_rule,
    'ecl': lambda x: x in ['amb', 'blu', 'brn', 'gry', 'grn', 'hzl', 'oth'],
    'pid': pid_rule,
    'cid': lambda x: True
}


for passport in [x.replace('\n', ' ') for x in passports]:
    missing_fields = set(['byr', 'iyr', 'eyr', 'hgt', 'hcl', 'ecl', 'pid', 'cid'])
    is_valid = True
    for field in passport.split(' '):
        name, value = field.split(':')
        is_valid = is_valid and rules[name](value)
        missing_fields.remove(name)
    if is_valid and (not missing_fields or missing_fields == set(['cid'])):
        valid_passports += 1

print(valid_passports)

const hasNDigits = (value, n) => {
  return new RegExp(`^\\d{${n}}$`).test(value);
};

const isNumberInRange = (value, min, max) => {
  const number = parseInt(value);
  return number >= min && number <= max;
};

const requiredFields = [
  {
    key: 'byr',
    validator: value => {
      return hasNDigits(value, 4) && isNumberInRange(value, 1920, 2002);
    }
  },
  {
    key: 'iyr',
    validator: value => {
      return hasNDigits(value, 4) && isNumberInRange(value, 2010, 2020);
    }
  },
  {
    key: 'eyr',
    validator: value => {
      return hasNDigits(value, 4) && isNumberInRange(value, 2020, 2030);
    }
  },
  {
    key: 'hgt',
    validator: value => {
      const match = new RegExp('(^\\d{2,3})(cm|in)$').exec(value);
      if (match) {
        const number = match[1];
        if (match[2] === 'cm') {
          return isNumberInRange(number, 150, 193);
        }
        return isNumberInRange(number, 59, 76);
      }
    }
  },
  {
    key: 'hcl',
    validator: value => {
      return new RegExp('^#[\\d|[a-f]{6}$').exec(value);
    }
  },
  {
    key: 'ecl',
    validator: value => {
      return ['amb', 'blu', 'brn', 'gry', 'grn', 'hzl', 'oth'].includes(value);
    }
  },
  {
    key: 'pid',
    validator: value => {
      return new RegExp('^\\d{9}$').exec(value);
    }
  }
];

function getValidPassoports(passports) {
  return passports.filter(passport =>
    requiredFields.every(({ key, validator }) => validator(passport[key]))
  );
}

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

(def input (str/split-lines (read-file "4.txt")))

(def needed-keys 
    (hash-set 
        "byr" 
        "iyr" 
        "eyr" 
        "hgt" 
        "hcl"
        "ecl"
        "pid"
        "cid"))

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

(defn valid-keys? [keys]
    (or (empty? keys) (= keys (hash-set "cid"))))

; (defn count-valid
;     [{:keys [r keys]} tokens]
;     (if (empty? tokens) 
;         {:r r :keys keys} 
;         (let [
;                 token (get tokens 0)
;                 id (nth (str/split token #":") 0)] 
;             (if (str/blank? token)
;                 {:r r :keys needed-keys}
;                 (if (empty? (disj keys id))
;                     {:r (inc r) :keys needed-keys}
;                     {:r r :keys (disj keys id)})))))

(defn make-groups
    [lines]
    (loop [groups [] group [] i 0]
            (println groups)
           (if (= i (count lines))
            groups
            (let [current-line (nth lines i)]
            (println current-line)
                (if (empty? current-line)
                (recur (conj groups group) [] (inc i))
                (recur groups (conj group current-line) (inc i)))))))

(defn solve1 
    [input] 
    (let [lines (split-by input)
            groups (partition-by #(= [] %) lines)]
        (println groups)))

(defn solve2 
    [input] 
    input)

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

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

leo las lineas.
tengo un pasaporte que es un array []
voy a;adiendo lineas hasta encontrar una linea vacia...
al final tengo todos los pasaportes en arrays
valido/filtro que tengan los ids
devuelvo el count

Si es super facil xd pero tengo problemas con el doble bucle. voy a tomarme un break para empezar a trabajar y luego sigo xd

    fun solveSecondPart(): Int {
        var count = 0
        val chunks = this.input.readText().split("\r\n\r\n")
        chunks.forEach { chunk ->
            if (countValidFields(chunk.replace("\r\n", " ")) > 6) {
                count++
            }
        }

    return count
}

private fun countValidFields(input: String): Int {
    var validFields = 0
    val chunks = input.split(" ")
    val hairColorRegex = "^#([A-Fa-f0-9]{6})$"
    val eyeColorRegex = "amb|blu|brn|gry|grn|hzl|oth"
    val passportIdRegex = "^[0-9]{9}$"

    chunks.forEach { chunk ->
        val fieldType = chunk.split(":")[0]
        val fieldValue = chunk.split(":")[1]

        when (fieldType) {
            "byr" -> if (fieldValue.toInt() in 1920..2020) validFields++
            "iyr" -> if (fieldValue.toInt() in 2010..2020) validFields++
            "eyr" -> if (fieldValue.toInt() in 2020..2030) validFields++
            "hgt" -> {
                val value = fieldValue.filter { it.isDigit() }.toInt()
                if (fieldValue.endsWith("cm", false) && value in 150..193) {
                    validFields++
                } else if (fieldValue.endsWith("in", false) && value in 59..76) {
                    validFields++
                }
            }
            "hcl" -> if (Pattern.compile(hairColorRegex).matcher(fieldValue).matches()) validFields++
            "ecl" -> if (Pattern.compile(eyeColorRegex).matcher(fieldValue).matches()) validFields++
            "pid" -> if (Pattern.compile(passportIdRegex).matcher(fieldValue).matches()) validFields++
        }
    }

    return validFields
}