AoC Day 4: Repose Record

import re
from collections import Counter

with open('input.txt', 'r') as f:
    data = []
    for line in f:
       date = line[line.find("[")+1:line.find("]")]
       action = line.split("] ")[1].strip()
       data.append((date, action,))
    data = sorted(data, key=lambda i: i[0])

guards = {}
for time, action in data:
    time = int(time[-2:])
    if "Guard" in action:
        _id = re.findall(r'\d+', action)[0]
        if not _id in guards:
            guards[_id] = {'length': 0, 'minutes': []}
    elif action == "falls asleep":
        start = time
    else:
        guards[_id]['length'] += time - start
        guards[_id]['minutes'] += list(range(start, time))

sleep_longest = max(guards.items(),key=lambda guard: guard[1]['length'])
minutes = sleep_longest[1]['minutes']
print(Counter(minutes).most_common(1)[0][0] * int(sleep_longest[0]))

import re
from collections import Counter

with open('input.txt', 'r') as f:
    data = []
    for line in f:
       date = line[line.find("[")+1:line.find("]")]
       action = line.split("] ")[1].strip()
       data.append((date, action,))
    data = sorted(data, key=lambda i: i[0])

guards = {}
for time, action in data:
    time = int(time[-2:])
    if "Guard" in action:
        _id = re.findall(r'\d+', action)[0]
        if not _id in guards:
            guards[_id] = []
    elif action == "falls asleep":
        start = time
    else:
        guards[_id] += list(range(start, time))

max_count = 0
solution = 0
for guard, minutes in guards.items():
    if minutes:
        most_frequent = Counter(minutes).most_common(1)[0]
        if most_frequent[1] > max_count:
            max_count = most_frequent[1]
            solution = int(guard) * most_frequent[0]
print(solution)

namespace Day4
open System.Text.RegularExpressions

module util =
  let getContents fileName =
    System.IO.File.ReadLines(fileName) |> Seq.toList

  type LogEntry =
    | NewGuard of System.DateTime * int
    | Asleep of System.DateTime
    | Awake of System.DateTime
    | Nonsense

  let recordRegex = @"^\[([0-9]{4})-([0-9]{2})-([0-9]{2}) ([0-3]{2}):([0-9]{2})] (.*)$"

  let (|FirstRegexGroup|_|) pattern input =
   let m = Regex.Match(input,pattern) 
   if (m.Success) then Some m.Groups.[1].Value else None  

  let sortLog log = List.sortBy (fun el -> 
    match el with
    | LogEntry.Asleep dt -> dt
    | LogEntry.Awake dt -> dt
    | LogEntry.NewGuard (dt, _) -> dt
    | LogEntry.Nonsense -> new System.DateTime()) log

  let scrapeLog inputs =
     List.map (fun logEntry ->
      let m = Regex.Match(logEntry, recordRegex)
      if m.Success then
        let dt =
          new System.DateTime(
            (m.Groups.[1].Value |> System.Convert.ToInt32),
            (m.Groups.[2].Value |> System.Convert.ToInt32),
            (m.Groups.[3].Value |> System.Convert.ToInt32),
            (m.Groups.[4].Value |> System.Convert.ToInt32),
            (m.Groups.[5].Value |> System.Convert.ToInt32),
            0)

        match m.Groups.[6].Value with
        | "falls asleep" -> LogEntry.Asleep (dt)
        | "wakes up" -> LogEntry.Awake (dt)
        | FirstRegexGroup "Guard #([0-9]+) begins shift" badge -> LogEntry.NewGuard (dt, System.Convert.ToInt32 badge)
        | _ -> LogEntry.Nonsense
      else LogEntry.Nonsense) inputs
      |> sortLog


  let first (a, _, _) = a
  let second (_, b, _) = b
  let third (_, _, c) = c

  type MinuteCounts = Map<int, int>

  let getHighest minuteCounts =
    Map.fold (fun s k v -> if v > snd s then (k, v) else s) (0, 0) minuteCounts

  type SingleEntry =
    { TotalAsleep : int
      MinuteCounts : MinuteCounts }
  type SleepLog = Map<int, SingleEntry>

  let tickMinute (mcs: MinuteCounts) m =
    match (mcs.TryFind m) with
    | Some x -> Map.add m (x + 1) mcs
    | None -> Map.add m 1 mcs

  let addRangeToLog sleep wake sleepLogEntry =
    let timeAsleep = wake - sleep
    let eachMinute = [ for i in sleep..wake - 1 do yield i ]
    { TotalAsleep = sleepLogEntry.TotalAsleep + timeAsleep;
      MinuteCounts = List.fold tickMinute sleepLogEntry.MinuteCounts eachMinute }

  let processLog log =
    List.fold
      (fun s el ->
        match el with
        | LogEntry.NewGuard (_, badge) -> (Some badge, second s, third s)
        | LogEntry.Awake dt ->
          match (first s) with
          | Some badge ->
            match (second s) with
            | Some sleepTime ->
              let map: SleepLog = third s 
              let newMap =
                match map.TryFind badge with
                | Some x -> Map.add badge (addRangeToLog sleepTime dt.Minute x) map
                | None -> Map.add badge (addRangeToLog sleepTime dt.Minute {TotalAsleep = 0; MinuteCounts = (new Map<int, int> (Seq.empty))}) map
              (first s, None, newMap)
            | None -> s // This branch indicates an error in the input - there was no "time asleep" stored for a "wakes up" entry
          | None -> s // This branch indicates an error in the input - there was no active badge for a "wakes up" entry
        | LogEntry.Asleep dt -> (first s, Some dt.Minute, third s)
        | LogEntry.Nonsense -> s)
      (None, None, new Map<int, SingleEntry> (Seq.empty)) // Active Badge, Minute Fell Asleep, SleepLog
      log

  let getSleepLog fileName =
    getContents fileName |> scrapeLog |> processLog |> third

module part1 =
  open util

  let getLongestAsleep sleepLog =
    sleepLog |> Map.fold (fun s k v -> if v.TotalAsleep > first s then (v.TotalAsleep, k, getHighest v.MinuteCounts) else s) (0, 0, (0, 0))

  let execute fileName =
    let res = getSleepLog fileName |> getLongestAsleep
    (second res) * (fst (third res))

module part2 =
  open util
  let getMostFrequentAsleep sleepLog =
    sleepLog |> Map.fold (fun s k (v: SingleEntry) ->
      let h = getHighest v.MinuteCounts
      if snd h >= snd (snd s) then
        (k, h)
      else s
      ) (0, (0, 0))

  let execute fileName =
    let res = getSleepLog fileName |> getMostFrequentAsleep
    (fst res) * (fst (snd res))

<?php
$list = file_get_contents($argv[1]);
$records = explode("\n", trim($list));
$currentguard = null;
$lastminute = 0;
$awake = true;
$guardtotals = array();

usort($records, function($a, $b) {
  preg_match('/\[([0-9]{4})\-([0-9]{2})\-([0-9]{2}) ([0-9]{2}):([0-9]{2})\]/', $a, $atimes);
  preg_match('/\[([0-9]{4})\-([0-9]{2})\-([0-9]{2}) ([0-9]{2}):([0-9]{2})\]/', $b, $btimes);
  if (intval($atimes[1].$atimes[2].$atimes[3].$atimes[4].$atimes[5]) == intval($btimes[1].$btimes[2].$btimes[3].$btimes[4].$btimes[5])) {
    return 0;
  }
  return (intval($atimes[1].$atimes[2].$atimes[3].$atimes[4].$atimes[5]) < intval($btimes[1].$btimes[2].$btimes[3].$btimes[4].$btimes[5])) ? -1 : 1;
});

foreach ($records as $record) {
  preg_match('/\[[0-9]{4}\-([0-9]{2})\-([0-9]{2}) ([0-9]{2}):([0-9]{2})\]/', $record, $timestamps);
  preg_match('/Guard #([0-9]+)/', $record, $guard);
  if (count($guard) > 0) {
    if (!$awake && $currentguard) {
      $timeasleep = 60 - $lastminute;
      $guardtotals[$currentguard]['asleep'] += $timeasleep;
      $sleep = array_slice($guardtotals[$currentguard]['minutes'], $lastminute, $timeasleep);
      $sleep = array_map(function($x) {
        return $x+1;
      }, $sleep);
      array_splice($guardtotals[$currentguard]['minutes'], $lastminute, $timeasleep, $sleep);
      $lastminute = 0;
    }
    $currentguard = intval($guard[1]);
    $awake = true;
    if (!array_key_exists($currentguard, $guardtotals)) {
      $guardtotals[$currentguard] = array(
        'asleep' => 0,
        'minutes' => array_fill(0, 60, 0)
      );
    }
  } elseif (strpos($record, 'falls asleep')) {
    $awake = false;
    $lastminute = intval($timestamps[4]);
  } elseif (strpos($record, 'wakes up')) {
    if ($currentguard) {
      $timeasleep = intval($timestamps[4]) - $lastminute;
      $guardtotals[$currentguard]['asleep'] += $timeasleep;
      $sleep = array_slice($guardtotals[$currentguard]['minutes'], $lastminute, $timeasleep);
      $sleep = array_map(function($x) {
        return $x+1;
      }, $sleep);
      array_splice($guardtotals[$currentguard]['minutes'], $lastminute, $timeasleep, $sleep);
      $lastminute = intval($timestamps[4]);
      $awake = true;
    }
  }
}
uasort($guardtotals, function($a, $b) {
  if ($a['asleep'] == $b['asleep']) {
    return 0;
  }
  return ($a['asleep'] < $b['asleep']) ? 1 : -1;
});
$chosenguard = array_keys($guardtotals)[0];
$chosenminute = array_search(max($guardtotals[$chosenguard]['minutes']), $guardtotals[$chosenguard]['minutes']);
echo $chosenguard*$chosenminute;
die(1);

<?php
$list = file_get_contents($argv[1]);
$records = explode("\n", trim($list));
$currentguard = null;
$lastminute = 0;
$awake = true;
$guardtotals = array();

usort($records, function($a, $b) {
  preg_match('/\[([0-9]{4})\-([0-9]{2})\-([0-9]{2}) ([0-9]{2}):([0-9]{2})\]/', $a, $atimes);
  preg_match('/\[([0-9]{4})\-([0-9]{2})\-([0-9]{2}) ([0-9]{2}):([0-9]{2})\]/', $b, $btimes);
  if (intval($atimes[1].$atimes[2].$atimes[3].$atimes[4].$atimes[5]) == intval($btimes[1].$btimes[2].$btimes[3].$btimes[4].$btimes[5])) {
    return 0;
  }
  return (intval($atimes[1].$atimes[2].$atimes[3].$atimes[4].$atimes[5]) < intval($btimes[1].$btimes[2].$btimes[3].$btimes[4].$btimes[5])) ? -1 : 1;
});

foreach ($records as $record) {
  preg_match('/\[[0-9]{4}\-([0-9]{2})\-([0-9]{2}) ([0-9]{2}):([0-9]{2})\]/', $record, $timestamps);
  preg_match('/Guard #([0-9]+)/', $record, $guard);
  if (count($guard) > 0) {
    if (!$awake && $currentguard) {
      $timeasleep = 60 - $lastminute;
      $guardtotals[$currentguard]['asleep'] += $timeasleep;
      $sleep = array_slice($guardtotals[$currentguard]['minutes'], $lastminute, $timeasleep);
      $sleep = array_map(function($x) {
        return $x+1;
      }, $sleep);
      array_splice($guardtotals[$currentguard]['minutes'], $lastminute, $timeasleep, $sleep);
      $lastminute = 0;
    }
    $currentguard = intval($guard[1]);
    $awake = true;
    if (!array_key_exists($currentguard, $guardtotals)) {
      $guardtotals[$currentguard] = array(
        'asleep' => 0,
        'minutes' => array_fill(0, 60, 0)
      );
    }
  } elseif (strpos($record, 'falls asleep')) {
    $awake = false;
    $lastminute = intval($timestamps[4]);
  } elseif (strpos($record, 'wakes up')) {
    if ($currentguard) {
      $timeasleep = intval($timestamps[4]) - $lastminute;
      $guardtotals[$currentguard]['asleep'] += $timeasleep;
      $sleep = array_slice($guardtotals[$currentguard]['minutes'], $lastminute, $timeasleep);
      $sleep = array_map(function($x) {
        return $x+1;
      }, $sleep);
      array_splice($guardtotals[$currentguard]['minutes'], $lastminute, $timeasleep, $sleep);
      $lastminute = intval($timestamps[4]);
      $awake = true;
    }
  }
}
$maximums = array_map(function($z) {
  return max($z['minutes']);
}, $guardtotals);
uasort($maximums, function($a, $b) {
  if ($a == $b) {
    return 0;
  }
  return ($a < $b) ? 1 : -1;
});
$chosenguard = array_keys($maximums)[0];
$chosenminute = array_search($maximums[$chosenguard], $guardtotals[$chosenguard]['minutes']);
echo $chosenguard*$chosenminute;
die(1);

from collections import defaultdict


def main():
    guard_sleep_dict = calculate_guard_sleep_dict()
    part_one(guard_sleep_dict)
    part_two(guard_sleep_dict)


def calculate_guard_sleep_dict():
    with open('input.txt', 'r') as data:

        sorted_data = sorted(data)  # This will work too... No extra key required

        guard_sleep_dict = defaultdict(lambda: [0 for x in range(60)])
        current_guard = -1
        start_sleeping = -1
        for line in sorted_data:
            if line[25] == "#":
                current_guard = line.split()[3]
            elif line[25] == "a":
                start_sleeping = int(line[15:17])
            else:  # "wakes up"
                end_sleeping = int(line[15:17])
                for x in range(start_sleeping, end_sleeping):
                    guard_sleep_dict[current_guard][x] += 1

    return guard_sleep_dict


def part_one(guard_sleep_dict):
    guard = sorted(guard_sleep_dict.keys(), key=lambda g: -sum(guard_sleep_dict[g]))[0]

    gh = guard_sleep_dict[guard]
    minute = gh.index(max(gh))
    print int(guard[1:]) * minute


def part_two(guard_sleep_dict):
    guard = sorted(guard_sleep_dict.keys(), key=lambda g: -max(guard_sleep_dict[g]))[0]
    gh = guard_sleep_dict[guard]
    minute = gh.index(max(gh))
    print int(guard[1:]) * minute


if __name__ == '__main__':
    main()

const fs = require('fs');
const readline = require('readline');

const readLines = (file, onLine) => {
    const reader = readline.createInterface({
        input: fs.createReadStream(file),
        crlfDelay: Infinity
    });

    reader.on('line', onLine);

    return new Promise(resolve => reader.on('close', resolve));
};

const readFile = async file => {
    const lines = [];
    await readLines(file, line => lines.push(line));  
    return lines;
}

module.exports = {
    readLines,
    readFile
};

class SleepingSchedule {
    constructor(guard) {
        this.guard = guard;
        this.guard.schedules.push(this);

        this.minutesSlept = [];
    }

    setDate(year, month, day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    addNap(start, end) {
        const length = end - start;
        this.minutesSlept.push(...Array.from({ length }, (e, i) => start + i));
        this.guard.maxMinutesSlept += length;
    }
}

class Guard {
    constructor(id) {
        this.id = id;
        this.maxMinutesSlept = 0;
        this.schedules = [];
    }
}

const buildGuards = lines => {
    const beginsShiftRegex = /^\[(?<year>\d+)-(?<month>\d+)-(?<day>\d+)\s(?<hour>\d+):(?<minute>\d+)\]\sGuard\s#(?<id>\d+) begins shift$/;
    const fallsAsleepRegex = /^\[(?<year>\d+)-(?<month>\d+)-(?<day>\d+)\s(?<hour>\d+):(?<minute>\d+)\]\sfalls\sasleep$/;
    const wakesUpRegex = /^\[(?<year>\d+)-(?<month>\d+)-(?<day>\d+)\s(?<hour>\d+):(?<minute>\d+)\]\swakes\sup$/;

    const sleepingSchedules = new Map();
    const guards = new Map();

    let currentSchedule;
    let hasNapped;
    let napStartMinute;
    let currentGuard;
    for (let line of lines) {
        let match = line.match(beginsShiftRegex);
        if (match) {
            if (napStartMinute) {
                currentSchedule.addNap(napStartMinute, 60);
            }

            const { id } = match.groups;

            if (guards.has(id)) {
                currentGuard = guards.get(id);
            }
            else {
                currentGuard = new Guard(id);
                guards.set(id, currentGuard);
            }
            currentSchedule = new SleepingSchedule(currentGuard);

            hasNapped = false;
            napStartMinute = undefined;
        }
        else {
            match = line.match(fallsAsleepRegex);
            if (match) {
                if (!hasNapped) {
                    const { year, month, day } = match.groups;
                    currentSchedule.setDate(year, month, day);
                    hasNapped = true;
                }
                const { minute } = match.groups;
                napStartMinute = +minute;
            }
            else {
                match = line.match(wakesUpRegex);
                if (match) {
                    const { minute } = match.groups;
                    currentSchedule.addNap(napStartMinute, +minute);
                    napStartMinute = undefined;
                }
            }
        }
    }
    return guards;
};

module.exports = { 
    SleepingSchedule,
    Guard,
    buildGuards
};

const { readFile } = require('./reader');
const {
    SleepingSchedule,
    Guard,
    buildGuards
} = require('./04-common');

const findZonkedGuard = guards => {
    return [...guards.values()].reduce((zonkedGuard, guard) => {
        if (guard.maxMinutesSlept > zonkedGuard.maxMinutesSlept) {
            zonkedGuard = guard;
        }
        return zonkedGuard;
    });
};

const findMostAsleepMinute = guard => {
    const minutesCount = Array.from({ length: 60 }, m => 0);
    for (let i = 0; i < 60; i++) {
        for (let schedule of guard.schedules) {
            minutesCount[i] += +(schedule.minutesSlept.indexOf(i) > -1);
        }
    }

    const mostAsleepMinuteCount = Math.max(...minutesCount);
    return minutesCount.indexOf(mostAsleepMinuteCount);
};

(async () => {
    const lines = await readFile('04-input.txt');
    lines.sort();

    const guards = buildGuards(lines);
    const zonkedGuard = findZonkedGuard(guards);
    const mostAsleepMinute = findMostAsleepMinute(zonkedGuard);

    const solution = +zonkedGuard.id * mostAsleepMinute;
    console.log(`The ID of the guard multiplied by the minute is ${solution}`);
})();

const { readFile } = require('./reader');
const {
    SleepingSchedule,
    Guard,
    buildGuards
} = require('./04-common');


const findMostAsleepMinute = guard => {
    const minutesCount = Array.from({ length: 60 }, m => 0);
    for (let i = 0; i < 60; i++) {
        for (let schedule of guard.schedules) {
            minutesCount[i] += +(schedule.minutesSlept.indexOf(i) > -1);
        }
    }

    const mostAsleepMinuteCount = Math.max(...minutesCount);
    return minutesCount.indexOf(mostAsleepMinuteCount);
};

const findMostFrequentlySleptMinute = guards => {
    const minutesMostSlept = [];

    // Finding the guard which slept the most minutes for every minute
    for (let i = 0; i < 60; i++) {
        const guardsWhichSleptThisMinute = new Map();
        for (let guard of guards.values()) {
            let minutesThisGuardSlept = 0;
            for (let schedule of guard.schedules) {
                minutesThisGuardSlept += +(schedule.minutesSlept.indexOf(i) > -1);
            }
            guardsWhichSleptThisMinute.set(guard.id, minutesThisGuardSlept);
        }

        let zonkedGuardId;
        let maxMinutesSlept = 0;
        for (let [guardId, minutes] of guardsWhichSleptThisMinute.entries()) {
            if (minutes > maxMinutesSlept) {
                maxMinutesSlept = minutes;
                zonkedGuardId = guardId;
            }
        }

        minutesMostSlept[i] = { zonkedGuardId, maxMinutesSlept };
    }

    // Finding the guard which slept the most minutes total
    let zonkedGuardIdTotal;
    let maxMinutesSleptTotal = 0;
    let minuteMostSleptTotal = -1;
    for (let i = 0; i < 60; i++) {
        const { zonkedGuardId, maxMinutesSlept } = minutesMostSlept[i];
        if (maxMinutesSlept > maxMinutesSleptTotal) {
            maxMinutesSleptTotal = maxMinutesSlept;
            zonkedGuardIdTotal = zonkedGuardId;
            minuteMostSleptTotal = i;
        }
    }

    return { zonkedGuardIdTotal, minuteMostSleptTotal }
}

(async () => {
    const lines = await readFile('04-input.txt');
    lines.sort();

    const guards = buildGuards(lines);
    const { zonkedGuardIdTotal, minuteMostSleptTotal } = findMostFrequentlySleptMinute(guards);

    const solution = +zonkedGuardIdTotal * minuteMostSleptTotal;
    console.log(`The ID of the guard multiplied by the minute is ${solution}`);
})();

typealias Duration = Pair<LocalDateTime, LocalDateTime>

private val dateFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")

fun String.parseEntry() =
    Regex("""\[(.*)] (.*)""").matchEntire(this)!!.groupValues.let {
        LocalDateTime.parse(it[1], dateFormat) to it[2]
    }

fun String.parseGuardId() =
    Regex("""Guard #(\d+) begins shift""")
        .matchEntire(this)!!
        .groupValues[1]
        .toInt()


fun Duration.minutes() = let { (start, end) ->
    ((end.toEpochSecond(UTC) - start.toEpochSecond(UTC)) / 60).toInt()
}

fun Duration.minuteRange() = let { (start, end) ->
    start.minute until end.minute
}

private fun computeGuardSchedules(initial: List<Pair<LocalDateTime, String>>): List<Guard> {
    val guards = mutableMapOf<Int, Guard>()
    initial.sortedBy { it.first }.fold(-1) { onDuty, (ts, type) ->
        val guard = when (type) {
            "wakes up" -> guards[onDuty]?.awaken(ts)
            "falls asleep" -> guards[onDuty]?.asleepen(ts)
            else -> type.parseGuardId().let { gid ->
                if (gid !in guards) {
                    guards[gid] = Guard(gid)
                }
                guards[gid]!!.ondutyen(ts)
            }
        }!!
        guard.id
    }
    return guards.values.toList()
}


class Guard(val id: Int) {
    private var lastStatusChange: LocalDateTime? = null
    val sleepLog = mutableListOf<Duration>()

    fun awaken(ts: LocalDateTime): Guard {
        sleepLog.add(lastStatusChange!! to ts)
        lastStatusChange = ts
        return this
    }


    fun asleepen(ts: LocalDateTime): Guard {
        lastStatusChange = ts
        return this
    }

    fun ondutyen(ts: LocalDateTime): Guard {
        lastStatusChange = ts
        return this
    }
}



fun answer1(input: List<Guard>): Int {
    val sleepiest = input.maxBy {
        it.sleepLog.sumBy(Duration::minutes)
    }!!

    val minuteMostOftenAsleep = sleepiest.sleepLog
        .flatMap(Duration::minuteRange)
        .frequencies()
        .maxBy { (_, v) -> v }!!.key

    return sleepiest.id * minuteMostOftenAsleep
}

    fun answer2(input: List<Guard>) =
        input.map {
            it.id to (
                    it.sleepLog
                        .flatMap(Duration::minuteRange)
                        .frequencies()
                        .toList()
                        .sortedBy { (k, v) -> -v }
                        .firstOrNull()
                    )
        }.sortedBy { (k, v) ->
            -(v?.second ?: -10000)
        }.first().let {
            it.first * it.second!!.first
        }

def sort_log(log):
    log = [line.split("]") for line in log]
    log = sorted(log, key=lambda x: datetime.datetime.strptime(x[0], "[%Y-%m-%d %H:%M"))
    return [line[0] + "]" + line[1] for line in log]

def tally_shift(current_guard, guards):
    try:
        previous_shift = current_guard.pop(0)
        if previous_shift not in guards.keys():
            guards[previous_shift] = dict((k, 0) for k in range(60))
    except IndexError:
        pass
    while len(current_guard) > 0:
        guard = guards[previous_shift]
        range_start = int(current_guard.pop(0))
        range_end = int(current_guard.pop(0))
        for m in range(range_start, range_end):
            guard[m] += 1
    return guards

def process_shifts(entries):
    guard_pattern = re.compile(r'^.*#(?P<guard_id>\d*)')
    minute_pattern = re.compile(r'^.*:(?P<minute>\d{2})\]')
    guards = {}
    current_guard = []
    entries = sort_log(entries)
    for entry in entries:
        if "begins shift" in entry:
            guards = tally_shift(current_guard, guards)
            current_guard = []
            current_guard.append(guard_pattern.search(entry).group('guard_id'))
        elif "falls asleep" in entry:
            current_guard.append(minute_pattern.search(entry).group('minute'))
        else:
            current_guard.append(minute_pattern.search(entry).group('minute'))
    return tally_shift(current_guard, guards)

def part_one(schedule):
    current_leader = None
    most_minutes_slept = 0
    minute_most_likely_asleep = 0
    for k, v in process_shifts(schedule).items():
        total_mins_asleep = sum(v.values())
        minute_most_slept_through = max(v.values())
        if total_mins_asleep >= most_minutes_slept:
            current_leader = k
            most_minutes_slept = total_mins_asleep
            minute_most_likely_asleep = [min for min, freq in v.items() if freq == minute_most_slept_through]

    return int(current_leader) * minute_most_likely_asleep.pop()

def part_two(schedule):
    current_leader = None
    max_global_frequency = 0
    for k, v in process_shifts(schedule).items():
        max_freq = max(v.values())
        if max_freq >= max_global_frequency:
            max_global_frequency = max_freq
            current_leader = k
            most_freq = [min for min, freq in v.items() if freq == max_freq][0]

    return int(current_leader) * most_freq

(def build-table
  [input-file]
  (loop [[line & xlines] (sort (lines input-file)) guard 0 table {}]
    (if-not line
      table
      (if (= "Guard" (subs line 19 24))
        (recur xlines (-> (subs line 26) (split #" ") first as-long) table)
        (let [sleep (as-long (subs line 15 17))
              wake (as-long (subs (first xlines) 15 17))
              table' (reduce (fn [t minute]
                               (update-in t [guard minute] #(if % (inc %) 1)))
                             table (range sleep wake))]
          (recur (rest xlines) guard table'))))))

(defn max-finder
  [vfn]
  (fn [[_ mv :as mkv] [_ v :as kv]] (if (> (vfn v) (vfn mv)) kv mkv)))

(defn star
  [input-file]
  (let [table (build-table input-file)
        [guard times] (reduce (max-finder count) [0 []] table)
        [max-time _] (reduce (max-finder identity) [0 0] times)]
    (* guard max-time)))

(defn star2
  [input-file]
  (let [table (build-table input-file)
        ident-finder (max-finder identity)
        guards-maxes (map (fn [[g tm]] [g (reduce ident-finder [0 0] tm)]) table)
        [guard [minute _]] (reduce (max-finder second) [0 [0 0]] guards-maxes)]
    (* guard minute)))

defmodule AoC.DayFour.Common do
  @line_regex ~r/\[(.*)\] (.*)/
  @date_format "{YYYY}-{M}-{D} {h24}:{m}"

  def read_input(path) do
    path
    |> File.stream!()
    |> Stream.map(&String.trim_trailing/1)
    |> Enum.to_list()
    |> Enum.sort()
    |> Enum.map(fn x ->
      [datetime, log] = Regex.run(@line_regex, x, capture: :all_but_first)
      {:ok, datetime} = Timex.parse(datetime, @date_format)
      %{datetime: datetime, log: log}
    end)
  end

  def calculate_guard_minutes(input, map \\ %{}, current_guard \\ "", last_minute \\ 0)

  def calculate_guard_minutes([line | rest], map, current_guard, last_minute) do
    case line.log do
      "falls asleep" ->
        calculate_guard_minutes(rest, map, current_guard, line.datetime.minute)

      "wakes up" ->
        map = Map.put_new(map, current_guard, %{})
        guard = Map.get(map, current_guard)

        guard =
          Enum.reduce(last_minute..(line.datetime.minute - 1), guard, fn x, acc ->
            Map.update(acc, x, 1, &(&1 + 1))
          end)

        map = Map.put(map, current_guard, guard)
        calculate_guard_minutes(rest, map, current_guard, line.datetime.minute)

      _ ->
        [new_guard] =
          Regex.run(~r/^Guard #(\d+) begins shift$/, line.log, capture: :all_but_first)

        calculate_guard_minutes(rest, map, new_guard, 0)
    end
  end

  def calculate_guard_minutes([], map, _current_guard, _last_minute) do
    map
  end
end

defmodule AoC.DayFour.PartOne do
  alias AoC.DayFour.Common

  def main() do
    "lib/day4/input.txt"
    |> Common.read_input()
    |> Common.calculate_guard_minutes()
    |> get_sleepiest_guard()
    |> get_sleepiest_minute()
    |> calculate_result()
  end

  defp calculate_result({guard, minute}) do
    guard * minute
  end

  defp get_sleepiest_minute(map) do
    {_, {guard, minutes}} = map

    {sleepiest_minute, _} =
      # Format: {guard, minutes_slept}
      Enum.reduce(minutes, {0, 0}, fn {current_minute, count}, {highest_minute, highest_count} ->
        if count > highest_count,
          do: {current_minute, count},
          else: {highest_minute, highest_count}
      end)

    {String.to_integer(guard), sleepiest_minute}
  end

  defp get_sleepiest_guard(map) do
    # Format: {minutes_slept, {guard, minutes}}
    Enum.reduce(map, {0, {0, %{}}}, fn {guard, minutes}, sleepiest_guard ->
      minutes_slept = Enum.reduce(minutes, 0, fn {_, count}, acc -> acc + count end)
      {current_sleep_minutes, _} = sleepiest_guard

      if minutes_slept > current_sleep_minutes,
        do: {minutes_slept, {guard, minutes}},
        else: sleepiest_guard
    end)
  end
end

defmodule AoC.DayFour.PartTwo do
  alias AoC.DayFour.Common

  def main() do
    "lib/day4/input.txt"
    |> Common.read_input()
    |> Common.calculate_guard_minutes()
    |> get_sleepiest_guard()
    |> calculate_result()
  end

  defp calculate_result({guard, minute}) do
    guard * minute
  end

  defp get_sleepiest_guard(map) do
    # Format: {guard, minute, count}
    {guard, minute, _} =
      Enum.reduce(map, {0, 0, 0}, fn {guard, minutes}, sleepiest_guard ->
        # Format: {minute, count}
        {minute, count} =
          Enum.reduce(minutes, {0, 0}, fn {minute, count}, {current_minute, highest_count} ->
            if count > highest_count, do: {minute, count}, else: {current_minute, highest_count}
          end)

        {_, _, current_count} = sleepiest_guard

        if count > current_count,
          do: {String.to_integer(guard), minute, count},
          else: sleepiest_guard
      end)

    {guard, minute}
  end
end