1def solution(plans):
 2    q = []
 3    answer = []
 4    for plan in plans:
 5        h, m = map(int, plan[1].split(':'))
 6        plan[1] = h*60 + m
 7        plan[2] = int(plan[2])
 8    plans.sort(key = lambda x: x[1])
 9
10    for plan in plans:
11        if q:
12            free_time = plan[1] - q[-1][1]
13        while q:
14            q[-1][2] -= free_time
15            free_time = -1 * q[-1][2]
16
17            print (free_time, q[-1][2])
18            if free_time < 0:
19                break
20
21            if q[-1][2] <= 0:
22                answer.append(q.pop()[0])
23
24        q.append(plan)
25    while q:
26        answer.append(q.pop()[0])
27
28    return answer

 1def solution(plans):
 2    plans = sorted(map(lambda x: [x[0], int(x[1][:2]) * 60 + int(x[1][3:]), int(x[2])], plans), key=lambda x: -x[1])
 3    q = []
 4
 5    while plans:
 6        cur = plans.pop()
 7
 8        for idx, item in enumerate(q):
 9            if item[0] > cur[1]:
10                q[idx][0] += cur[2]
11
12        q.append([cur[1]+cur[2], cur[0]])
13
14    q.sort()
15    return list(map(lambda x: x[1], q))

 1def solution(sequence, k):
 2    answer = []
 3    e = len(sequence)-1
 4    s = len(sequence)
 5    cur = 0
 6
 7    while s >= 0:
 8        if cur < k:
 9            s -= 1
10            cur += sequence[s]
11        elif cur > k:
12            cur -= sequence[e]
13            e -= 1
14        else:
15            answer.append((s, e))
16            s -= 1
17            cur += sequence[s]
18    answer.sort(key=lambda x: (x[1]-x[0], x[0]))
19    return answer[0]

 1import math
 2
 3def calc1(r):
 4    result = 0
 5    for i in range(1, r):
 6        result += math.floor(math.sqrt(r**2 - i**2))
 7    return result*4 + r*4 + 1
 8
 9def calc2(r):
10    result = 0
11    for i in range(1, r):
12        a = math.sqrt(r**2 - i**2)
13        result += math.floor(a)
14        if a % 1 == 0:
15            result -= 1
16    return result*4 + r*4 + 1
17
18def solution(r1, r2):
19    return calc1(r2)-calc2(r1)+4

 1def solution(targets):
 2    answer = 0
 3    targets.sort(key=lambda x:x[1])
 4    cur = 0
 5
 6    for i in targets:
 7        if i[0] >= cur:
 8            answer += 1
 9            cur = i[1]
10
11    return answer