1from itertools import combinations
 2from collections import defaultdict
 3from bisect import bisect_left
 4
 5def solution(infos, queries):
 6    answer = []
 7    dataset = defaultdict(list)
 8
 9    for info in infos:
10        token = info.split(' ')
11
12        for j in range(5):
13            for case in list(combinations([0,1,2,3], j)):
14                temp = token[:-1]
15                for c in case:
16                    temp[c] = '-'
17                dataset[''.join(temp)].append(int(token[-1]))
18    for value in dataset.values():
19        value.sort()
20
21    for query in queries:
22        query = query.replace(" and", "").split()
23        target_key = ''.join(query[:-1])
24        target_value = int(query[-1])
25        count = 0
26
27        if target_key in dataset:
28            target_list = dataset[target_key]
29            idx = bisect_left(target_list, target_value)
30            count = len(target_list)-idx
31
32        answer.append(count)
33    return answer

 1def check(string):
 2    stack = []
 3    for i in string:
 4        if i == '(' or i == '{' or i == '[':
 5            stack.append(i)
 6        else:
 7            if len(stack) == 0:
 8                return False
 9            if i == ')':
10                if stack[-1] != '(': return False
11            if i == '}':
12                if stack[-1] != '{': return False
13            if i == ']':
14                if stack[-1] != '[': return False
15            stack.pop()
16    if len(stack) != 0: return False
17    return True
18
19def solution(s):
20    s = list(s)
21    result = 0
22    for i in range(len(s)):
23        if check(s):
24            result += 1
25        s.append(s.pop(0))
26    return result

 1dx = [1, 0, -1, 0]
 2dy = [0, 1, 0, -1]
 3
 4def solution(rows, columns, queries):
 5    table = [[(j*columns)+i+1 for i in range(columns)] for j in range(rows)]
 6    answer = []
 7
 8    for y1, x1, y2, x2 in queries:
 9        min_num = 10000
10        x1 -= 1
11        y1 -= 1
12        x2 -= 1
13        y2 -= 1
14        direction = 0
15        curX, curY = x1, y1
16        postNum = table[y1][x1]
17        while True:
18            curX = curX+dx[direction]
19            curY = curY+dy[direction]
20
21            temp = table[curY][curX]
22            table[curY][curX] = postNum
23            postNum = temp
24
25            min_num = min(min_num ,postNum)
26
27            if ((curX == x2 and curY == y1) or
28                (curX == x2 and curY == y2) or
29                (curX == x1 and curY == y2)):
30                direction += 1
31            
32            if curX == x1 and curY == y1:
33                break
34
35        answer.append(min_num)
36
37    return answer

 1def solution(numbers):
 2    answer = []
 3    for number in numbers:
 4        num = list(str(bin(number)).split('b')[1])
 5
 6        # 첫번째 자릿수가 0인 경우
 7        if num[-1] == '0':
 8            num[-1] = '1'
 9            answer.append(int('0b'+''.join(num), 2))
10            continue
11        
12        # 첫번째 자릿수가 1인 경우
13        num = ['0']+num
14        # 두번째 자리부터 순회
15        for i in range(len(num)-2, -1, -1):
16            # 가장 오른쪽의 0을 찾았을 때
17            if num[i] == '0':
18                # 0을 오른쪽으로, 1을 왼쪽으로 옮긴다
19                num[i], num[i+1] = num[i+1], num[i]
20                answer.append(int('0b'+''.join(num), 2))
21                break
22
23    return answer

 1dx = [-1, 1, 0, 0]
 2dy = [0, 0, -1, 1]
 3def quest(table):
 4    table = [list(line) for line in table]
 5    for j in range(5):
 6        for i in range(5):
 7            if table[i][j] == 'P':
 8                flag = [False]*4
 9                target = []
10                for k in range(4):
11                    nx = i+dx[k]
12                    ny = j+dy[k]
13                    if 0 <= nx < 5 and 0 <= ny < 5:
14                        target.append((nx, ny))
15                        flag[k] = True
16
17                for x, y in target:
18                    if table[x][y] == 'C' or table[x][y] == 'P':
19                        return 0
20                    if table[x][y] == 'O':
21                        table[x][y] = 'C'
22
23                target = []
24                if flag[0] and flag[2] and table[i-1][j] == 'O' and table[i][j-1] == 'O':
25                    target.append((i-1, j-1))
26                if flag[0] and flag[3] and table[i-1][j] == 'O' and table[i][j+1] == 'O':
27                    target.append((i-1, j+1))
28                if flag[1] and flag[2] and table[i+1][j] == 'O' and table[i][j-1] == 'O':
29                    target.append((i+1, j-1))
30                if flag[1] and flag[3] and table[i+1][j] == 'O' and table[i][j+1] == 'O':
31                    target.append((i+1, j+1))
32
33                for x, y in target:
34                    if table[x][y] == 'P':
35                        return 0
36    return 1
37
38def solution(places):
39    answer = []
40    for table in places:
41        answer.append(quest(table))
42    return answer

 1def solution(word):
 2    answer = 0
 3    char = ['A', 'E', 'I', 'O', 'U']
 4    cnt = 0
 5
 6    def traverse(cur):
 7        nonlocal char, cnt, word
 8        if cur == word:
 9            return cnt
10
11        if len(cur) < 5:
12            for ch in char:
13                cnt += 1
14                if traverse(cur+ch) != None:
15                    return cnt
16    return traverse('')

 1dx = [1, 0, -1, 0]
 2dy = [0, 1, 0, -1]
 3def solution(grid):
 4    N = len(grid)
 5    M = len(grid[0])
 6    grid = [list(line) for line in grid]
 7    route = [[[False]*4 for _ in range(M)] for _ in range(N)]
 8    answer = []
 9    
10    for i in range(M):
11        for j in range(N):
12            for k in range(4):
13                cur = [i, j]
14                dir = k
15                cnt = 0
16                while not route[cur[1]][cur[0]][dir]:
17                    cnt += 1
18                    route[cur[1]][cur[0]][dir] = True
19                    cur[0] = (cur[0]+dx[dir]) % M
20                    cur[1] = (cur[1]+dy[dir]) % N
21
22                    if grid[cur[1]][cur[0]] == 'L':
23                        dir = (dir-1) % 4
24                    elif grid[cur[1]][cur[0]] == 'R':
25                        dir = (dir+1) % 4
26                if cnt != 0:
27                    answer.append(cnt)
28
29    return sorted(answer)

 1def solution(n, wires):
 2    tower = [[] for _ in range(n)]
 3    answer = 100
 4    for wire in wires:
 5        wire[0] -= 1
 6        wire[1] -= 1
 7        tower[wire[0]].append(wire[1])
 8        tower[wire[1]].append(wire[0])
 9    
10    def traverse(visited, start):
11        visited[start] = True
12        for i in tower[start]:
13            if not visited[i]:
14                traverse(visited, i)
15    for wire in wires:
16        tower[wire[0]].remove(wire[1])
17        tower[wire[1]].remove(wire[0])
18
19        visited = [False]*n
20        a = 0
21        traverse(visited, wire[0])
22        for i in range(n):
23            if visited[i]:
24                a += 1
25
26        visited = [False]*n
27        b = 0
28        traverse(visited, wire[1])
29        for i in range(n):
30            if visited[i]:
31                b += 1
32        answer = min(answer, abs(a-b))
33        tower[wire[0]].append(wire[1])
34        tower[wire[1]].append(wire[0])
35    return answer

 1def calc(a1, b1, c1, a2, b2, c2):
 2    if a1*b2-a2*b1 == 0:
 3        return (0.1, 0.1)
 4    return ((b1*c2-b2*c1)/(a1*b2-a2*b1), (c1*a2-a1*c2)/(a1*b2-a2*b1))
 5
 6def solution(line):
 7    answer = []
 8    length = len(line)
 9    points = []
10    size = [1e15, -1e15, 1e15,- 1e15]
11
12    for i in range(length):
13        for j in range(i):
14            point = calc(line[i][0],line[i][1], line[i][2], line[j][0], line[j][1], line[j][2])
15            if point[0]%1 != 0 or point[1]%1 != 0:
16                continue
17            x = int(point[0])
18            y = int(point[1])
19            points.append((x, y))
20            size[0] = min(size[0], x)
21            size[1] = max(size[1], x)
22            size[2] = min(size[2], y)
23            size[3] = max(size[3], y)                
24
25    answer = [['.'] * (size[1]-size[0]+1) for _ in range(size[3]-size[2]+1)]
26    for x, y in points:
27        answer[size[3]-y][x-size[0]] = '*'
28
29    return [''.join(i) for i in answer]

 1def solution(n, left, right):
 2    answer = []
 3    start = (left//n, left%n)
 4    end = (right//n, right%n)
 5
 6    for i in range(start[0], end[0]+1):
 7        line = [i+1]*(i+1) + [i for i in range(i+2, n+1)]
 8        answer += line
 9        
10    return answer[start[1]:right-(start[0]*n)+1]