1def solution(topping):
 2    answer = 0
 3    length = len(topping)
 4    toppingA = []
 5    toppingB = []
 6    setA = set()
 7    setB = set()
 8
 9    for i in range(length-1):
10        setA.add(topping[i])
11        setB.add(topping[length-i-1])
12        toppingA.append(len(setA))
13        toppingB.append(len(setB))
14
15    toppingB = toppingB[::-1]
16    for i in range(length-1):
17        if toppingA[i] == toppingB[i]:
18            answer+=1
19    return answer

 1def solution(k, ranges):
 2    answer = []
 3    seq = [k]
 4    section = [0]
 5    while k > 1:
 6        if k%2 == 0:
 7            k = k//2
 8        else:
 9            k = k*3+1
10        seq.append(k)
11    
12    for i in range(0, len(seq)-1):
13        a, b = seq[i], seq[i+1]
14        if a > b:
15            a, b = b, a
16            
17        section.append((b-a)/2+a)
18        if len(section) != 0:
19            section[-1] += section[-2]
20            
21    for i in ranges:
22        a, b = i[0], len(seq)+i[1]-1
23        if a > b:
24            answer.append(-1.0)
25        else:
26            answer.append(section[b]-section[a])
27    return answer

 1def solution(k, tangerine):
 2    D = {}
 3    for i in tangerine:
 4        if i in D:
 5            D[i] += 1
 6        else:
 7            D[i] = 1
 8    D = sorted(D.items(), key=lambda x: -x[1])
 9    answer = 0
10    for _, num in D:
11        k -= num
12        answer += 1
13        if k <= 0:
14            break
15        
16    return answer

 1import math
 2
 3def solution(k, d):
 4    answer = 0
 5    
 6    for x in range(0, d+1, k):
 7        a = math.floor((d**2-x**2)**0.5) // k + 1
 8        answer += a
 9        
10    return answer

 1import heapq
 2
 3def solution(n, k, enemy):
 4    heap = []
 5    cnt = 0 
 6    for i in enemy:
 7        n -= i
 8        heapq.heappush(heap, -i)
 9        while n < 0:
10            k -= 1
11            if not heap or k < 0:
12                return cnt
13            tmp = -heapq.heappop(heap)
14            n += tmp
15        cnt += 1
16    return cnt

 1def solution(data, col, row_begin, row_end):
 2    answer = 0
 3    data.sort(key=lambda x: (x[col-1], -x[0]))
 4    s = []
 5    for i in range(row_begin-1, row_end):
 6        s.append(sum(map(lambda x: x%(i+1), data[i]))) 
 7    
 8    for i in s:
 9        answer ^= i
10    return answer

 1from collections import deque
 2
 3def solution(storey):
 4    answer = 0
 5    q = deque()
 6    q.append((storey, 0))
 7    visited = [False] * (10**8+1)
 8    
 9    while q:
10        cur, cnt = q.popleft()
11        
12        
13        visited[cur] = True
14        while cur != 0 and cur%10 == 0:
15            cur = cur // 10
16        if cur == 0:
17            answer = cnt
18            break
19        for j in [-1, 1]:
20            dest = cur + j
21            if 0 <= dest <= 10**8 and not visited[dest]:
22                q.append((dest, cnt+1))
23    
24    return answer

 1answer = 10**8
 2def dfs(cur, cnt):
 3    global answer
 4    if cur == 0:
 5        answer = min(answer, cnt)
 6        return
 7    while cur % 10 == 0:
 8        cur /= 10
 9
10    if cur%10 < 5:
11        dfs(cur//10, cnt+(cur%10))
12    elif cur%10 > 5:
13        dfs(cur//10+1, cnt+(10-cur%10))
14    else:
15        dfs(cur//10, cnt+(cur%10))
16        dfs(cur//10+1, cnt+(10-cur%10))
17
18def solution(storey):
19    dfs(storey, 0)
20    return answer

 1result = []
 2
 3def dfs(size, percent, users, emoticons):
 4    global result
 5
 6    if len(percent) == size:
 7        temp = [0] * len(users)
 8        for i in range(size):
 9            for j in range(len(users)):
10                if percent[i]*100 >= users[j][0]:
11                    temp[j] += emoticons[i]*(1-percent[i])
12        serviceNum = 0
13        income = 0
14        for i in range(len(users)):
15            if temp[i] >= users[i][1]:
16                serviceNum += 1
17            else:
18                income += temp[i]
19        result.append ((serviceNum, income))
20        return
21
22    for i in [0.1, 0.2, 0.3, 0.4]:
23        dfs(size, percent+[i], users, emoticons)
24
25
26def solution(users, emoticons):
27    dfs(len(emoticons), [], users, emoticons)
28    result.sort(reverse=True)
29    return list(result[0])

 1def solution(cap, n, deliveries, pickups):
 2    answer = 0
 3    tempD = 0
 4    tempP = 0
 5    for i in range(n-1, -1, -1):
 6        tempD += deliveries[i]
 7        tempP += pickups[i]
 8        
 9        while tempD > 0 or tempP > 0:
10            tempD -= cap
11            tempP -= cap
12            answer += (i+1)*2
13    return answer