KBR's Stacked Thoughts

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
def solution(answers):
    # 수포자 패턴
    p1 = [1, 2, 3, 4, 5]
    p2 = [2, 1, 2, 3, 2, 4, 2, 5]
    p3 = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5]
    
    # 각 수포자가 맞힌 개수를 세는 배열 정의
    scores = [0, 0, 0]
    
    for i in range(len(answers)):
        if answers[i] == p1[i % len(p1)]:
            scores[0] += 1
        if answers[i] == p2[i % len(p2)]:
            scores[1] += 1
        if answers[i] == p3[i % len(p3)]:
            scores[2] += 1
    
    # 가장 높은 점수 찾기
    max_score = max(scores)
    
    # 가장 높은 점수를 받은 사람들 반환
    result = []
    for i in range(3):
        if scores[i] == max_score:
            result.append(i + 1)
            
    return result

1
2
3
4
5
6
7
8
9
10
11
12
13
def solution(sizes):
    # 최댓값 변수 선언
    max_w = 0
    max_h = 0
    
    for w, h in sizes:
        long_one = max(w, h)
        short_one = min(w, h)
        # 최댓값 찾기
        max_w = max(max_w, long_one)
        max_h = max(max_h, short_one)
        
    return max_w * max_h

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
from itertools import permutations

# 소수 판별 함수 정의
def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def solution(numbers):
    ### 1. 모든 숫자 조합 만들기
    # 입력 문자를 리스트로 변경하기
    digits = list(numbers)
    
    # 모든 자리수의 순열 만들기
    all_combi = set()
    
    for i in range(1, len(digits) + 1):
        for p in permutations(digits, i):
            num = int(''.join(p))   # 문자열로 붙인 뒤 정수 변환
            all_combi.add(num)
    
    ### 2-3. all_combi에 대해 소수 판별
    prime_set  = {num for num in all_combi if is_prime(num)}
    
    ### 4. 소수인 숫자의 개수 반환
    return len(prime_set)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def solution(brown, yellow):
    answer = []
    ### 1. 전체 격자의 수
    num = brown + yellow
    
    ### 2. 조합 찾기
    # 테두리는 최소 높이 3 이상
    for h in range(3, num + 1):
        # w * h가 되기 위해 나눠 떨어져야 함
        if num % h == 0:
            w = num // h
            # 가로는 세로보다 같거나 길어야 함
            if w >= h:
                if (w - 2) * (h - 2) == yellow:
                    return [w, h]

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
from itertools import permutations

answer = []

def solution(k, dungeons):
    max_count = 0
    
    ### 1. dungeons의 모든 순열 생성
    all_orders = list(permutations(dungeons, len(dungeons)))
    
    ### 2. 각 순서에 대해 k로 던전 시도
    for order in all_orders:
        cur_k = k
        count = 0
        
        for minimum, consume in order:
            # 탐험을 하기 위해서는 최소 필요도보다 커야 함
            if cur_k >= minimum:
                # 현재 k에서 소모 필요도 --
                cur_k -= consume
                count += 1
            # 최소 필요도보다 작은 k가 남았다면 break
            else:
                break
        max_count = max(max_count, count)
            
    return max_count

1
2
3
4
5
6
7
8
9
10
11
def solution(word):
    answer = 0
    # 알파벳
    dict = ['A', 'E', 'I', 'O', 'U']
    # 가중치
    weight = [781, 156, 31, 6, 1]
    
    for i, char in enumerate(word):
        answer += dict.index(char) * weight[i] + 1
        
    return answer

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
def solution(n, wires):
    answer = n
    
    ### 1. 그래프를 인접 리스트 방식으로 표현 (양방향 연결 리스트)
    # 송전탑 번호가 1부터 시작하니까 n + 1 크기로 리스트 생성
    graph = [[] for _ in range(n + 1)]
    
    for v1, v2 in wires:
        graph[v1].append(v2)
        graph[v2].append(v1)
    
    ### 3. BFS로 송전탑 개수 세기
    def bfs(start, removed_v1, removed_v2):
        # 방문 여부 체크 배열 만들기
        visited = [False] * (n + 1)
        # BFS 탐색을 위한 큐
        queue = [start]
        visited[start] = True
        # 시작 노드 포함해서 송전탑 개수 카운트 시작
        count = 1
        
        while queue:
            # 큐에서 노드 꺼내기
            node = queue.pop(0)
            # 현재 노드와 연결된 모든 노드 탐색
            for next_node in graph[node]:
                ### 2. 전선을 하나씩 끊고 끊어진 상태에서 한 쪽 네트워크의 송전탑 개수 구하기
                if (node == removed_v1 and next_node == removed_v2) or (node == removed_v2 and next_node == removed_v1):
                    # 끊어진 전선은 무시하고 넘어감
                    continue
                    
                # 아직 방문하지 않은 송전탑이면
                if not visited[next_node]:
                    visited[next_node] = True
                    queue.append(next_node)
                    # 송전탑 개수 추가
                    count += 1
        # 탐색한 송전탑 개수 반환
        return count
    
    ### 2. 전선을 하나씩 끊는 걸 모든 전선에 대해 반복
    for v1, v2 in wires:
        # 끊어진 상태에서 BFS로 송전탑 개수 세기
        cnt = bfs(1, v1, v2)
        
        ### 4. 두 네트워크의 송전탑 개수 차이 계산
        # 하나의 송전탑 그룹과 나머지 송전탑 그룹의 개수 차이
        diff = abs(cnt - (n - cnt))
        # 최솟값으로 갱신
        answer = min(answer, diff)
        
    return answer