adventofcode2018/04-2.py at master · karoberts/adventofcode2018 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
import json
import re
import operator
from collections import Counter

pat = re.compile(r'^\[\d{4}-(\d{2}-\d{2}) (\d{2}):(\d{2})\] (wakes up|falls asleep|Guard #\d+ begins shift)$')
pat2 = re.compile(r'^Guard #(\d+) begins shift$')
def parse(l):
    m = pat.match(l)
    m2 = pat2.match(m.group(4))

    return {'sk': m.group(1) + m.group(2) + m.group(3), 'day': m.group(1), 'h': int(m.group(2)), 'm': int(m.group(3)), 'g': int(m2.group(1)) if m2 is not None else None, 'ev':m.group(4) if m2 is None else 'shift'}

def get_times(e1, e2):
    return [m for m in range(e1['m'], e2['m'])]

entries = None
with open('04.txt') as f:
    entries = sorted([parse(line.strip()) for line in f], key=lambda x:x['sk'])

curday = None
curguard = -1
sleeping = None
sleeps = {}
totsleeps = {}
for e in entries:
    #print(e['day'], e['h'], e['m'], e['g'], e['ev'])

    if e['day'] != curday:
        curday = e['day']
        #print('starting day', curday)

    if e['ev'] == 'shift' and e['g'] != curguard:
        curguard = e['g']
        if curguard not in sleeps:
            sleeps[curguard] = []
            totsleeps[curguard] = 0
        #print('guard start', curguard)
        continue

    if e['ev'] == 'falls asleep':
        #print(curguard, 'sleep', e['h'], e['m'])
        sleeping = e
        pass

    if e['ev'] == 'wakes up':
        #print(curguard, 'wake', e['h'], e['m'])
        minutes = get_times(sleeping, e)
        #print(json.dumps(minutes))
        totsleeps[curguard] = totsleeps[curguard] + len(minutes)
        sleeps[curguard].extend(minutes)
        sleeping = None
        pass

max_g = 0
max_m = 0
max_c = 0
for g in sleeps:
    if len(sleeps[g]) == 0:
        continue
    c = Counter(sleeps[g])
    #print(c)
    maxmin = max(c, key=lambda x:c[x])
    print(g, maxmin, c[maxmin])
    if c[maxmin] > max_c:
        max_c = c[maxmin]
        max_g = g
        max_m = maxmin

print(max_g, max_m, max_c)
print(max_g * max_m)

#maxsleeper = max(totsleeps, key=lambda k: totsleeps[k])
#print (maxsleeper)
#print(sleeps[maxsleeper])
#minutes = Counter(sleeps[maxsleeper])
#maxmin = max(minutes, key=lambda x:minutes[x])
#print (maxmin * maxsleeper)