프로그래머스 Python 풀이 노트

```python
def solution(n, left, right):
    answer = []
    for i in range(left, right + 1):
        value = i // n
        remain = i % n
        answer.append(max(value, remain) + 1)
    return answer

answer = solution(4, 7, 14)
len(answer)
print(answer)

def solution(topping):
    answer = 0
    topping_size = len(topping)
    left = []
    right = []
    left_dict = {}
    right_dict = {}
    for i in range(topping_size - 1):
        left_dict[topping[i]] = True
        left.append(len(left_dict))
        right_dict[topping[topping_size - i - 1]] = True
        right.append(len(right_dict))

    for i in range(0, len(left)):
        if left[i] == right[len(right) - i - 1]:
            answer += 1

    return answer

print(solution([1, 2, 1, 3, 1, 4, 1, 2]))

def solution(n, k):
    answer = 0
    k_num = ""
    while n > 0:
        k_num = str(n % k) + k_num
        n = n // k
    k_num_list = k_num.split("0")
    for num in k_num_list:
        if num != "" and is_prime(int(num)):
            answer += 1

    return answer

def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            return False
    return True

print(solution(10, 7))

def solution(order):
    answer = 0
    number_range = len(order) + 1
    stack = []
    pos = 0
    for i in range(1, number_range + 1):
        if pos >= len(order):
            break
        if order[pos] == i:
            answer += 1
            pos += 1
        else :
            while stack and stack[-1] == order[pos] and pos < len(order):
                stack.pop()
                answer += 1
                pos += 1
            if pos >= len(order):
                break
            if order[pos] != i:
                stack.append(i)
            else :
                answer += 1
                pos += 1
    while stack and stack[-1] == order[pos] and pos < len(order):
        stack.pop()
        answer += 1
        pos += 1
    return answer

print(solution([5,4,3,2,1]))

def solution(fees, records):
    fees[0] # 기본 시간
    fees[1] # 기본 요금
    fees[2] # 단위 시간
    fees[3] # 단위 요금

    cars = {}
    for record in records:
        time, car, status = record.split(" ")
        h, m = map(int, time.split(":"))
        total_minute = h * 60 + m
        if car not in cars:
            cars[car] = []
        cars[car].append((total_minute, status))
    
    for car in cars:
        if len(cars[car]) % 2 == 1:
            cars[car].append((23 * 60 + 59, "OUT"))

        total_time = 0
        for i in range(0, len(cars[car]), 2):
            in_time, _ = cars[car][i]
            out_time, _ = cars[car][i + 1]
            total_time += out_time - in_time
        add_fee_time = max(0, total_time - fees[0])
        cars[car] = fees[1] + ((add_fee_time + fees[2] - 1) // fees[2]) * fees[3]

    answer = []
    car_list = sorted(cars.keys())
    for car in car_list:
        answer.append(cars[car])
    return answer

print(solution([180, 5000, 10, 600], ["05:34 5961 IN", "06:00 0000 IN", "06:34 0000 OUT", "07:59 5961 OUT", "07:59 0148 IN", "18:59 0000 IN", "19:09 0148 OUT", "22:59 5961 IN", "23:00 5961 OUT"]))

from collections import deque

def solution(queue1, queue2):
    q1_sum = sum(queue1)
    q2_sum = sum(queue2)
    if q1_sum == q2_sum:
        return 0
    total = q1_sum + q2_sum
    if total % 2 != 0:
        return -1
    
    q1 = deque(queue1)
    q2 = deque(queue2)
    
    answer = 0
    while q1_sum != q2_sum:
        if q1_sum < q2_sum:
            value = q2.popleft()
            q1.append(value)
            q1_sum += value
            q2_sum -= value
            answer += 1
        else :
            value = q1.popleft()
            q2.append(value)
            q1_sum -= value
            q2_sum += value
            answer += 1
        if answer > (len(queue1) + len(queue2)) * 2:
            return -1

    return answer

print(solution([2, 3, 2], [1, 1, 1]))

def dfs(storey, mod=1, max=10**8):
    if storey > max:
        return 0
    if storey < mod:
        return 0
    digit = (storey // mod) % 10

    # up
    storey_up = storey + (10 - digit) * mod
    dfs_up = dfs(storey_up, mod * 10) + (10 - digit)
    # down
    storey_down = storey - digit * mod
    dfs_down = dfs(storey_down, mod * 10) + (digit)

    return min(dfs_up, dfs_down)

def solution(storey):
    answer = dfs(storey)
    return answer

solution(2554)

def solution(players, m, k):
    answer = 0
    auto_increment = [0 for _ in range(24)]
    for i in range(len(players)):
        if players[i] >= (auto_increment[i] + 1) * m:
            increase = (players[i] - ((auto_increment[i] + 1) * m) + m) // m
            answer += increase
            for j in range(k):
                if i + j < len(auto_increment):
                    auto_increment[i + j] += increase
                else :
                    break
    return answer

solution([0, 2, 3, 3, 1, 2, 0, 0, 0, 0, 4, 2, 0, 6, 0, 4, 2, 13, 3, 5, 10, 0, 1, 5], 3, 5)

# 최대 공약수 구하기
def gcd(array):
    from math import gcd
    from functools import reduce
    return reduce(gcd, array)

# 숫자의 약수 구하기
def get_divisors(n):
    divisors = set()
    for i in range(1, int(n**0.5) + 1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n // i)
    return divisors

def check_divisor(div_array, undiv_array):
    ret = 0
    # 배열의 최대공약수의 약수들은 조건을 만족한다.
    gcd_value = gcd(div_array)
    if gcd_value < 2:
        return 0
    divisors = get_divisors(gcd_value)
    
    # 약수들 중에서 undiv_array의 어떤 수로도 나누어 떨어지지 않는 가장 큰 수를 찾는다.
    for num in divisors:
        is_dividable = False
        for undiv in undiv_array:
            if undiv % num == 0:
                is_dividable = True
                break
        if not is_dividable:
            ret = max(ret, num)
    return ret

def solution(arrayA, arrayB):
    answer = max(check_divisor(arrayA, arrayB), check_divisor(arrayB, arrayA))
    return answer

solution([14, 35, 119], [18, 30, 102])

from itertools import combinations

ALPHABET = [chr(i) for i in range(ord('A'), ord('Z') + 1)]

def solution(orders, course):
    answer = []
    course_list = {}
    for course_size in course:
        course_list[course_size] = {}

    for order in orders:
        order = ''.join(sorted(order))
        for course_size in course:
            if len(order) < course_size:
                continue
            comb = combinations(order, course_size)
            for c in comb:
                if c in course_list[course_size]:
                    course_list[course_size][c] += 1
                else :
                    course_list[course_size][c] = 1
    
    for course_size in course:
        max_count = 0
        for c in course_list[course_size]:
            max_count = max(max_count, course_list[course_size][c])
        if max_count < 2:
            continue
        for c in course_list[course_size]:
            if course_list[course_size][c] == max_count:
                answer.append("".join(c))

    answer.sort()

    return answer

print(solution(["ABCFG", "AC", "CDE", "ACDE", "BCFG", "ACDEH"], [2,3,4]))
# ["AC", "ACDE", "BCFG", "CDE"]
print(solution(["ABCDE", "AB", "CD", "ADE", "XYZ", "XYZ", "ACD"], [2,3,5]))
# ["ACD", "AD", "ADE", "CD", "XYZ"]
print(solution(["XYZ", "XWY", "WXA"], [2,3,4]))
# ["WX", "XY"]

    1.1. 입력된 수가 짝수라면 2로 나눕니다.
    1.2. 입력된 수가 홀수라면 3을 곱하고 1을 더합니다.
    2. 결과로 나온 수가 1보다 크다면 1번 작업을 반복합니다.

def solution(k, ranges):
    answer = []

    graph = []
    num = k
    while num > 1:
        graph.append(num)
        if num % 2 == 0:
            num = num // 2
        else :
            num = num * 3 + 1
    graph.append(1)

    n = len(graph) - 1
    for r in ranges:
        start, end = r
        end = n + end
        if start > end:
            answer.append(-1.0)
            continue
        if start == end:
            answer.append(0.0)
            continue
        area = 0.0
        for i in range(start, end):
            rectangle = min(graph[i], graph[i + 1])
            triangle = (max(graph[i], graph[i + 1]) - rectangle) / 2
            area += rectangle + triangle
        answer.append(area)

    return answer

solution(5, [[0,0],[0,-1],[2,-3],[3,-3]])
# [33.0,31.5,0.0,-1.0]

from collections import deque

# bfs 경로 탐색
def go_outside(storage, pos_x, pos_y, n, m):
    queue = deque()
    queue.append((pos_x, pos_y))
    # 반복적으로 초기화되어 경량화 필요
    visited = [[False] * m for _ in range(n)]
    while queue:
        (x, y) = queue.popleft()
        if x == 0 or x == n - 1 or y == 0 or y == m - 1:
            return True
        if storage[x][y] == 'o':
            return True
    
        # up down left right : 방향 튜플 사용
        for dx, dy in ((-1,0),(1,0),(0,-1),(0,1)):
            nx, ny = x + dx, y + dy
            if not visited[nx][ny] and storage[nx][ny] in ('n','o'):
                visited[nx][ny] = True
                queue.append((nx, ny))

    return False

def solution(storage, requests):
    storage = [list(s) for s in storage]
    answer = 0
    # len 호출 간소화
    n, m = len(storage), len(storage[0])
    for request in requests:
        r_stuff = request[0]
        r_type = "one" if len(request) == 1 else "mul"
        remove_pos = []
        for i in range(n):
            for j in range(m):
                if storage[i][j] == r_stuff:
                    if r_type == "mul":
                        storage[i][j] = 'n'
                    elif go_outside(storage, i, j, n, m):
                        remove_pos.append((i, j))
        if len(remove_pos) > 0:
            for pos_x, pos_y in remove_pos:
                storage[pos_x][pos_y] = 'o'
    
    for i in range(n):
        for j in range(m):
            if storage[i][j] not in ('n', 'o'):
                answer += 1
    return answer

print(solution(["AZWQY", "CAABX", "BBDDA", "ACACA"], ["A", "BB", "A"]))
# 11
print(solution(["TTTTT", "TKKKT", "TTKTT", "TTATT"], ["A", "K", "K", "K"]))
# 15
print(solution(["CCCCC", "CABAC", "CABAC", "CCABC"], ["BB", "A"]))
# 15

def get_divisors(n):
    divisors = set()
    for i in range(1, int(n**0.5) + 1):
        if n % i == 0:
            divisors.add(i)
            if i > 1 and n // i > 10000000:
                continue
            divisors.add(n // i)
    return divisors

def solution(begin, end):
    answer = []
    for num in range(begin, end + 1):
        if num == 0: 
            answer.append(0)
            continue
        if num == 1:
            answer.append(0)
            continue
        divisors = get_divisors(num)
        if num in divisors:
            divisors.remove(num)
        answer.append(max(divisors))
    return answer

solution(1, 10)
# [0, 1, 1, 2, 1, 3, 1, 4, 3, 5]

def make_group(cards, is_opened, pos):
    ret = []
    if is_opened[pos - 1]:
        return ret
    
    while not cards[pos - 1] in ret:
        is_opened[pos - 1] = True
        ret.append(cards[pos - 1])
        pos = cards[pos - 1]
    
    return ret

def solution(cards):
    answer = 0
    groups = []
    is_opened = [False] * len(cards)
    for card in cards:
        if is_opened[card - 1]:
            continue
        group = make_group(cards, is_opened, card)
        if len(group) > 0:
            groups.append(len(group))

    if len(groups) < 2:
        return 0
    
    groups.sort(reverse=True)
    answer = groups[0] * groups[1]
        
    return answer

solution([8,6,3,7,2,5,1,4])

from itertools import combinations_with_replacement

def get_score(apeach, ryan):
    ryan_score = 0
    apeach_score = 0
    for i in range(11):
        if apeach[i] < ryan[i]:
            ryan_score += (10 - i)
        elif apeach[i] >= ryan[i] and apeach[i] > 0:
            apeach_score += (10 - i)
    return ryan_score, apeach_score

def solution(n, info):
    answer = []
    answer_list = []
    max_diff = -1
    # 중복 조합 
    comb = combinations_with_replacement(range(11), n)
    for c in comb:
        ryan = [0] * 11
        for num in c:
            ryan[10 - num] += 1
        ryan_score, apeach_score = get_score(info, ryan)
        if ryan_score <= apeach_score:
            continue
        if max_diff == ryan_score - apeach_score:
            answer_list.append(ryan)
        elif max_diff < ryan_score - apeach_score:
            max_diff = ryan_score - apeach_score
            answer_list = [ryan]

    if max_diff == -1:
        return [-1]

    answer_list.sort(key=lambda x: x[::-1], reverse=True)
    answer = answer_list[0]

    return answer

print("res:", solution(5, [2,1,1,1,0,0,0,0,0,0,0]))
print("exp:", [0,2,2,0,1,0,0,0,0,0,0])

def solution(cap, n, deliveries, pickups):
    answer = 0
    truck = 0

    check_deliveries = [0] * n
    check_pickups = [0] * n
    for i in range(n - 1, -1, -1):
        if i == n - 1:
            check_deliveries[i] = deliveries[i]
            check_pickups[i] = pickups[i]
        else :
            check_deliveries[i] = check_deliveries[i + 1] + deliveries[i]
            check_pickups[i] = check_pickups[i + 1] + pickups[i]
    
    # 배송과 수거가 모두 끝났을 때 종료한다.
    delivery_flag = True
    pickup_flag = True
    while delivery_flag or pickup_flag:
        # 트럭에는 남은 배송 물건을 cap 만큼 싣고 센터에서 출발한다.
        truck = check_deliveries[0] % cap if check_deliveries[0] % cap != 0 else cap if check_deliveries[0] > 0 else 0
        # 지역을 탐색하여 배송과 수거를 진행한다.
        d_cycle_flag = True
        p_cycle_flag = True
        d_side_move = 0
        p_side_move = 0
        for i in range(n):
            if not d_cycle_flag and not p_cycle_flag:
                break
            if d_cycle_flag:
                d_side_move += 1
            if p_cycle_flag:
                p_side_move += 1
            # 배송 관련 확인
            if d_cycle_flag:
                if check_deliveries[i] > 0:
                    if truck >= check_deliveries[i]:
                        check_deliveries[i] = 0
                    else :
                        check_deliveries[i] -= truck
                else :
                    d_side_move -= 1
                    d_cycle_flag = False

            # 수거 관련 확인
            if p_cycle_flag:
                if check_pickups[i] > 0:
                    if check_pickups[i] <= cap:
                        check_pickups[i] = 0
                    else :
                        check_pickups[i] -= cap
                else :
                    p_side_move -= 1
                    p_cycle_flag = False
        
        # 결산
        answer += max(d_side_move, p_side_move) * 2
        delivery_flag = True if check_deliveries[0] > 0 else False
        pickup_flag = True if check_pickups[0] > 0 else False

    return answer

solution(2, 7, [1, 0, 2, 0, 1, 0, 2], [0, 3, 0, 1, 0, 2, 0])

def solution(cap, n, deliveries, pickups):
    answer = 0
    deliver_pos = n - 1
    pickup_pos = n - 1
    while deliver_pos >= 0 or pickup_pos >= 0:
        while deliver_pos >= 0 and deliveries[deliver_pos] == 0:
            deliver_pos -= 1
        while pickup_pos >= 0 and pickups[pickup_pos] == 0:
            pickup_pos -= 1
        if deliver_pos < 0 and pickup_pos < 0:
            break
        answer += (max(deliver_pos, pickup_pos) + 1) * 2
        deliver_cap = cap
        pickup_cap = cap
        while deliver_pos >= 0 and deliver_cap > 0:
            if deliveries[deliver_pos] > deliver_cap:
                deliveries[deliver_pos] -= deliver_cap
                deliver_cap = 0
            else :
                deliver_cap -= deliveries[deliver_pos]
                deliveries[deliver_pos] = 0
                deliver_pos -= 1
        while pickup_pos >= 0 and pickup_cap > 0:
            if pickups[pickup_pos] > pickup_cap:
                pickups[pickup_pos] -= pickup_cap
                pickup_cap = 0
            else :
                pickup_cap -= pickups[pickup_pos]
                pickups[pickup_pos] = 0
                pickup_pos -= 1
    return answer

print(solution(4, 5, [1,0,3,1,2], [0,3,0,4,0]))
# 16
print(solution(2, 7, [1, 0, 2, 0, 1, 0, 2], [0, 2, 0, 1, 0, 2, 0]))
# 30

def solution(n, w, num):
    answer = 1

    if num % w == 0: # 위
        move = (1, 2 * w - 1)
    elif (num // w) % 2 == 0: # 오른쪽
        move = ((w - (num % w)) * 2 + 1, (num % w) * 2 - 1)
    elif (num // w) % 2 == 1: # 왼쪽 
        move = ((w - (num % w)) * 2 + 1, (num % w) * 2 - 1)

    clock = 0
    upstair = num + move[clock % 2]
    now = num
    while upstair <= n:
        answer += 1
        now = upstair
        clock += 1
        upstair = now + move[clock % 2]

    return answer

print(solution(22, 6, 8))
# 3

"..........."  
".....*....."  
"..........."  
"..........."  
".*.......*."  
"..........."  
"..........."  
"..........."  
"..........."  
".*.......*."  
"..........."  

"....*...."  
"........."  
"........."  
"*.......*"  
"........."  
"........."  
"........."  
"........."  
"*.......*"  

def find_cross_point(line1, line2):
    A1x, B1y, C1 = line1
    A2x, B2y, C2 = line2
    denominator = A1x * B2y - A2x * B1y
    if denominator == 0:
        return None  # 평행하거나 일치하는 직선

    x_numerator = B1y * C2 - B2y * C1
    y_numerator = C1 * A2x - C2 * A1x

    if x_numerator % denominator != 0 or y_numerator % denominator != 0:
        return None  # 정수 좌표가 아님

    x = x_numerator // denominator
    y = y_numerator // denominator
    return (x, y)

def solution(line):
    answer = []

    """
        모든 직선의 교점 구하기
        교점 중 정수 좌표인 것들만 고르기
        좌표의 x, y 최솟값 최댓값 구하기
        최대 최소와 좌표들을 이용해 맵 만들기
    """

    x = {}
    y = {}
    points = []
    for i in range(len(line)):
        for j in range(i + 1, len(line)):
            point = find_cross_point(line[i], line[j])
            if point is None:
                continue
            points.append(point)
            if "min" not in x or x["min"] > point[0]:
                x["min"] = point[0]
            if "max" not in x or x["max"] < point[0]:
                x["max"] = point[0]
            if "min" not in y or y["min"] > point[1]:
                y["min"] = point[1]
            if "max" not in y or y["max"] < point[1]:
                y["max"] = point[1]

    answer = [["."] * (x["max"] - x["min"] + 1) for _ in range(y["max"] - y["min"] + 1)]
    for point in points:
        answer[y["max"] - point[1]][point[0] - x["min"]] = "*"
    answer = ["".join(row) for row in answer]

    return answer

res = solution([[2, -1, 4], [-2, -1, 4], [0, -1, 1], [5, -8, -12], [5, 8, 12]])
"""[
"....*....", 
".........", 
".........", 
"*.......*", 
".........", 
".........", 
".........", 
".........", 
"*.......*"
]"""
for row in res:
    print(row)

def solution(n):
    dp = [0,3,11]
    # f(n) = f(n-2) x 3 + f(n-4) x 2 + … + f(2) x 2 + 2
    if n % 2 == 1:
        return 0
    divider = 1000000007
    n //= 2
    # f(n) = f(n-1) x 3 + f(n-2) x 2 + … + f(1) x 2 + 2
    for i in range(3, n + 1):
        # 점화식 세우기 (규칙 찾기)
        dp.append((dp[i - 1] * 3 + sum(dp[1:i-1]) * 2 + 2) % divider)

    return dp[n]

print(solution(4))
# 11
print(solution(6))
# 41

def solution(info, n, m):
    INF = float('inf')
    N = len(info)
    # dp[i][a] : 처음 i개 아이템까지 고려했을 때, A의 흔적이 a일 때의 최소 B의 흔적
    dp = [[INF] * n for _ in range(N + 1)]
    dp[0][0] = 0  # 초기 상태

    for i in range(N):
        a_risk, b_risk = info[i]
        for a in range(n):
            if dp[i][a] == INF:
                continue  # 도달할 수 없는 상태는 건너뛰기

            # 1. A 도둑이 아이템 i를 훔치는 경우
            new_a = a + a_risk
            if new_a < n:  # A의 누적 흔적이 n 미만이어야 함
                dp[i + 1][new_a] = min(dp[i + 1][new_a], dp[i][a])
            
            # 2. B 도둑이 아이템 i를 훔치는 경우
            new_b = dp[i][a] + b_risk
            if new_b < m:  # B의 누적 흔적이 m 미만이어야 함
                dp[i + 1][a] = min(dp[i + 1][a], new_b)
    
    # 모든 아이템을 고려한 후, 유효한 상태(두 도둑 모두 안전)에서 A의 흔적의 최솟값을 찾음
    answer = INF
    for a in range(n):
        if dp[N][a] < m:
            answer = min(answer, a)
    
    return answer if answer != INF else -1

print(solution([[1, 2], [2, 3], [2, 1]], 4, 4))

print(solution([[1, 2], [2, 3], [2, 1]], 4, 4))
# 2
print(solution([[1, 2], [2, 3], [2, 1]], 1, 7))
# 0
print(solution([[3, 3], [3, 3]], 7, 1))
# 6
print(solution([[3, 3], [3, 3]], 6, 1))
# -1

#programmers 문자열 내 마음대로 정렬하기
def solution(strings, n):
        # n번째로 인덱스로 정렬하고, 그 인덱스가 같다면 사전순으로 정렬
        strings.sort(key = lambda text : (text[n], text))
        return strings

#programmers 소수 찾기
def solution(n):
        answer = 0
        eratos = []
        for i in range(0, 1000002):
                eratos.append(True)
        
        for i in range(2, n + 1):
                if eratos[i]:
                        answer += 1
                        tmp = i + i
                        while tmp <= 1000000:
                                eratos[tmp] = False
                                tmp += i
        return answer

# programmers 정수 제곱근 판별
def solution(n):
        sqr = int(n ** 0.5)
        tmp = sqr
        if tmp ** 2 == n:
                return (sqr + 1) ** 2
        else:
                return -1

# programmers 예산
def solution(d, budget):
        d.sort()
        answer = 0
        for idx in d:
                if idx <= budget:
                        budget -= idx
                        answer += 1
        return answer

# programmers 탑
def solution(heights):
        answer = []
    
        for i in range(len(heights)):
                answer.append(0)
    
        for i in range(len(heights) - 1, -1, -1):
                for j in range(i, -1, -1):
                        if heights[i] < heights[j]:
                                answer[i] = j + 1
                                break;
        return answer

#programmers 문자열 압축
def solution(s):
	ans = len(s)
    # 압축량에 따라서 확인한다.
	for x in range(1, int(len(s)/2) + 1):
        # 총 문자열의 길이
		d = 0
        # 비교 문자열
		comp = ''
        # same count
		c = 1
        
        # 문자열을 search한다.
		for i in range(0, len(s), x):
            #문자열 복사
			temp = s[i:i + x]
            
            # 비교
            # 같다면 count를 늘려준다.
			if comp == temp:
				c += 1
            # 다르다면
            # 총 문자열 길이를 더해주고
            # 비교 문자열을 갱신한다.
			else:
				d += len(temp)
                
                # 1이면 무시, 1초과라면 int형을 str으로 변환하여 길이를
                # 총 문자열 길이에 더한다.
				if c > 1:
					d += len(str(c))
				c = 1
				comp = temp
		
        # 남은 찌꺼기가 있으면
        if c > 1:
			d += len(str(c))
		
        ans = min(ans, d)
	return ans