adventofcode/2018/internal/day04/guards.go

101 lines
2.2 KiB
Go
Raw Normal View History

package day04
import (
"sort"
"strconv"
"strings"
"time"
)
type Guard struct {
ID int
Sleep [60]int
SleepTotal int
}
type SleepEvent struct {
start, end int
}
type Shift struct {
start time.Time
guard int
sleepEvents []*SleepEvent
}
// ParseInput takes the input data and creates a series of "Shift" objects,
// which are just a structured form of the data.
func ParseInput(rawData []string) []*Shift {
sort.Strings(rawData)
shifts := []*Shift{}
var currentShift *Shift
var currentSleepEvent *SleepEvent
for _, line := range rawData {
data := strings.Split(line, "]")
timestamp, _ := time.Parse("2006-01-02 15:04", data[0][1:])
event := data[1][1:]
// handle beginning of shift
if strings.HasPrefix(event, "Guard #") {
// save old shift first
if currentShift != nil {
shifts = append(shifts, currentShift)
}
// now extract the guard ID and create a new Shift object
guardID, _ := strconv.Atoi(strings.Split(event, " ")[1][1:])
currentShift = &Shift{
guard: guardID,
start: timestamp,
}
}
if strings.HasPrefix(event, "falls") {
currentSleepEvent = &SleepEvent{
start: timestamp.Minute(),
}
}
if strings.HasPrefix(event, "wakes") {
currentSleepEvent.end = timestamp.Minute()
currentShift.sleepEvents = append(currentShift.sleepEvents, currentSleepEvent)
}
}
// save last shift
shifts = append(shifts, currentShift)
return shifts
}
// BuildGuards takes the shift data created by ParseInput and builds a map of
// 'guards', with a per-minute counter (and handy sum) of their sleep habits.
func BuildGuards(data []*Shift) map[int]*Guard {
guards := make(map[int]*Guard)
for _, shift := range data {
// fetch the guard for this shift, initialize if necessary
var guard *Guard
// declaring 'ok' here seems to be the only way to keep 'guard' from becoming
// a local variable inside the conditional. This seems like a flaw.
var ok bool
if guard, ok = guards[shift.guard]; !ok {
guard = &Guard{
ID: shift.guard,
}
guards[guard.ID] = guard
}
for _, event := range shift.sleepEvents {
guard.SleepTotal += event.end - event.start
for i := event.start; i < event.end; i++ {
guard.Sleep[i]++
}
}
}
return guards
}