편안한 마음으로 꽃 구경하기

프로그래머스 - 다단계 칫솔 판매 [2021-Dev-Matching: 웹 백엔드 개발자(상반기)

junsky00 — Wed, 4 Mar 2026 09:37:19 +0900

문제 설명:

민호는 다단계 조직을 이용하여 칫솔을 판매하고 있습니다. 판매원이 칫솔을 판매하면 그 이익이 피라미드 조직을 타고 조금씩 분배되는 형태의 판매망입니다. 어느정도 판매가 이루어진 후, 조직을 운영하던 민호는 조직 내 누가 얼마만큼의 이득을 가져갔는지가 궁금해졌습니다. 예를 들어, 민호가 운영하고 있는 다단계 칫솔 판매 조직이 아래 그림과 같다고 합시다.

민호는 center이며, 파란색 네모는 여덟 명의 판매원을 표시한 것입니다. 각각은 자신을 조직에 참여시킨 추천인에 연결되어 피라미드 식의 구조를 이루고 있습니다. 조직의 이익 분배 규칙은 간단합니다. 모든 판매원은 칫솔의 판매에 의하여 발생하는 이익에서 10% 를 계산하여 자신을 조직에 참여시킨 추천인에게 배분하고 나머지는 자신이 가집니다. 모든 판매원은 자신이 칫솔 판매에서 발생한 이익 뿐만 아니라, 자신이 조직에 추천하여 가입시킨 판매원에게서 발생하는 이익의 10% 까지 자신에 이익이 됩니다. 자신에게 발생하는 이익 또한 마찬가지의 규칙으로 자신의 추천인에게 분배됩니다. 단, 10% 를 계산할 때에는 원 단위에서 절사하며, 10%를 계산한 금액이 1 원 미만인 경우에는 이득을 분배하지 않고 자신이 모두 가집니다.

예를 들어, 아래와 같은 판매 기록이 있다고 가정하겠습니다. 칫솔의 판매에서 발생하는 이익은 개당 100 원으로 정해져 있습니다.

판매원	판매 수량	이익금
young	12	1,200원
ohn	4	400원
tod	2	200원
emily	5	500원
mary	10	1,000원

판매원 young 에 의하여 1,200 원의 이익이 발생했습니다. young 은 이 중 10% 에 해당하는 120 원을, 자신을 조직에 참여시킨 추천인인 edward 에게 배분하고 자신은 나머지인 1,080 원을 가집니다. edward 는 young 에게서 받은 120 원 중 10% 인 12 원을 mary 에게 배분하고 자신은 나머지인 108 원을 가집니다. 12 원을 edward 로부터 받은 mary 는 10% 인 1 원을 센터에 (즉, 민호에게) 배분하고 자신은 나머지인 11 원을 가집니다. 이 상태를 그림으로 나타내면 아래와 같습니다.

그 후, 판매원 john 에 의하여 400 원의 이익이 발생합니다. john 은 10% 인 40 원을 센터에 배분하고 자신이 나머지인 360 원을 가집니다. 이 상태를 그림으로 나타내면 아래와 같습니다.

또 그 후에는 판매원 tod 에 의하여 200 원 이익이 발생하는데, tod 자신이 180 원을, 추천인인 jaimie 가 그 중 10% 인 20 원을 받아서 18 원을 가지고, jaimie 의 추천인인 mary 는 2 원을 받지만 이것의 10% 는 원 단위에서 절사하면 배분할 금액이 없기 때문에 mary 는 2 원을 모두 가집니다. 이 상태를 그림으로 나타내면 아래와 같습니다.

그 다음으로 emily 가 칫솔 판매를 통하여 얻은 이익 500 원은 마찬가지의 규칙에 따라 emily 에게 450 원, mary 에게 45 원, 그리고 센터에 5 원으로 분배됩니다. 이 상태를 그림으로 나타내면 아래와 같습니다.

마지막으로, 판매원 mary 는 1,000 원의 이익을 달성하고, 이 중 10% 인 100 원을 센터에 배분한 후 그 나머지인 900 원을 자신이 가집니다. 이 상태를 그림으로 나타내면 아래와 같습니다. 위와 같이 하여 모든 조직 구성원들의 이익 달성 현황 집계가 끝났습니다. 지금까지 얻은 이익을 모두 합한 결과를 그림으로 나타내면 아래와 같습니다.

이 결과가 민호가 파악하고자 하는 이익 배분 현황입니다.

각 판매원의 이름을 담은 배열 enroll, 각 판매원을 다단계 조직에 참여시킨 다른 판매원의 이름을 담은 배열 referral, 판매량 집계 데이터의 판매원 이름을 나열한 배열 seller, 판매량 집계 데이터의 판매 수량을 나열한 배열 amount가 매개변수로 주어질 때, 각 판매원이 득한 이익금을 나열한 배열을 return 하도록 solution 함수를 완성해주세요. 판매원에게 배분된 이익금의 총합을 계산하여(정수형으로), 입력으로 주어진 enroll에 이름이 포함된 순서에 따라 나열하면 됩니다.

문제 해결:

def solution(enroll, referral, seller, amount):
    answer = []
    net = {}
    
    for p, r in zip(enroll, referral):
        net[p] = [r, 0]
        
    for s, a in zip(seller, amount):
        price = a*100
        curr = s
        
        while curr != "-" and price > 0:
            comm = price // 10
            net[curr][1] += (price-comm)
            
            curr = net[curr][0]
            price = comm
            
    for name in enroll:
        answer.append(net[name][1])
    
    return answer

해당 문제는 간단한 구현 문제이다.

신경써야 할 점은 10 절삭을 신경 써야 한다.

10%와 90%에 매몰되어 저 조건을 넘어가게 된다면 고전하게 된다.

"절삭"이므로 몫만 구한 뒤 price에서 빼는 형태로 사용하게 해야한다.

그 외에는 간단하다.

이전 코드:

import math

def solution(enroll, referral, seller, amount):
    answer = []
    net = {}
    
    for p, r in zip(enroll, referral):
        if r == '-':
            net[p] = [[], 0]
        else:
            net[p] = [[r], 0]
            net[p][0].extend(net[r][0])
    
    for s, a in zip(seller, amount):
        price = a*100
        net[s][1] += 0.9*price
        price -= 0.9*price
        
        for c in net[s][0]:
            if price < 10:
                net[c][1] += round(price)
                price -= round(price)
                break
            
            net[c][1] += round(0.9*price)
            price -= round(0.9*price)
    
    [answer.append(v[1]) for k, v in net.items()]
    return answer

이 코드가 절삭을 고려하지 않아 고전했던 코드인데 round로 해결하고자 하였지만 뜻대로되지 않았다.

그 외에 로직은 간단하게 dict 형태에 다른 초대인들을 모두 넣는다거나 다른 초대인들의 초대인들을 넣는 등

상당히 간단한 로직이다.

프로그래머스 - 사라지는 발판 [2022 KAKAO BLIND RECRUITMENT]

junsky00 — Wed, 25 Feb 2026 09:11:44 +0900

문제 설명:

플레이어 A와 플레이어 B가 서로 게임을 합니다. 당신은 이 게임이 끝날 때까지 양 플레이어가 캐릭터를 몇 번 움직이게 될지 예측하려고 합니다.

각 플레이어는 자신의 캐릭터 하나를 보드 위에 올려놓고 게임을 시작합니다. 게임 보드는 1x1 크기 정사각 격자로 이루어져 있으며, 보드 안에는 발판이 있는 부분과 없는 부분이 있습니다. 발판이 있는 곳에만 캐릭터가 서있을 수 있으며, 처음 캐릭터를 올려놓는 곳은 항상 발판이 있는 곳입니다. 캐릭터는 발판이 있는 곳으로만 이동할 수 있으며, 보드 밖으로 이동할 수 없습니다. 밟고 있던 발판은 그 위에 있던 캐릭터가 다른 곳으로 이동하여 다른 발판을 밞음과 동시에 사라집니다. 양 플레이어는 번갈아가며 자기 차례에 자신의 캐릭터를 상하좌우로 인접한 4개의 칸 중에서 발판이 있는 칸으로 옮겨야 합니다.

다음과 같은 2가지 상황에서 패자와 승자가 정해지며, 게임이 종료됩니다.

움직일 차례인데 캐릭터의 상하좌우 주변 4칸이 모두 발판이 없거나 보드 밖이라서 이동할 수 없는 경우, 해당 차례 플레이어는 패배합니다.
두 캐릭터가 같은 발판 위에 있을 때, 상대 플레이어의 캐릭터가 다른 발판으로 이동하여 자신의 캐릭터가 서있던 발판이 사라지게 되면 패배합니다.
게임은 항상 플레이어 A가 먼저 시작합니다. 양 플레이어는 최적의 플레이를 합니다. 즉, 이길 수 있는 플레이어는 최대한 빨리 승리하도록 플레이하고, 질 수밖에 없는 플레이어는 최대한 오래 버티도록 플레이합니다. '이길 수 있는 플레이어'는 실수만 하지 않는다면 항상 이기는 플레이어를 의미하며, '질 수밖에 없는 플레이어'는 최선을 다해도 상대가 실수하지 않으면 항상 질 수밖에 없는 플레이어를 의미합니다. 최대한 오래 버틴다는 것은 양 플레이어가 캐릭터를 움직이는 횟수를 최대화한다는 것을 의미합니다.

아래 그림은 초기 보드의 상태와 각 플레이어의 위치를 나타내는 예시입니다.

위와 같은 경우, 플레이어 A는 실수만 하지 않는다면 항상 이길 수 있습니다. 따라서 플레이어 A는 이길 수 있는 플레이어이며, B는 질 수밖에 없는 플레이어입니다. 다음은 A와 B가 최적의 플레이를 하는 과정을 나타냅니다.

플레이어 A가 초기 위치 (1, 0)에서 (1, 1)로 이동합니다. 플레이어 A가 (0, 0)이나 (2, 0)으로 이동할 경우 승리를 보장할 수 없습니다. 따라서 무조건 이길 방법이 있는 (1, 1)로 이동합니다.
플레이어 B는 (1, 1)로 이동할 경우, 바로 다음 차례에 A가 위 또는 아래 방향으로 이동하면 발판이 없어져 패배하게 됩니다. 질 수밖에 없는 플레이어는 최대한 오래 버티도록 플레이하기 때문에 (1, 1)로 이동하지 않습니다. (1, 2)에서 위쪽 칸인 (0, 2)로 이동합니다.
A가 (1, 1)에서 (0, 1)로 이동합니다.
B에게는 남은 선택지가 (0, 1)밖에 없습니다. 따라서 (0, 2)에서 (0, 1)로 이동합니다.
A가 (0, 1)에서 (0, 0)으로 이동합니다. 이동을 완료함과 동시에 B가 서있던 (0, 1)의 발판이 사라집니다. B가 패배합니다.
만약 과정 2에서 B가 아래쪽 칸인 (2, 2)로 이동하더라도 A는 (2, 1)로 이동하면 됩니다. 이후 B가 (2, 1)로 이동, 다음 차례에 A가 (2, 0)으로 이동하면 B가 패배합니다.
위 예시에서 양 플레이어가 최적의 플레이를 했을 경우, 캐릭터의 이동 횟수 합은 5입니다. 최적의 플레이를 하는 방법은 여러 가지일 수 있으나, 이동한 횟수는 모두 5로 같습니다.

게임 보드의 초기 상태를 나타내는 2차원 정수 배열 board와 플레이어 A의 캐릭터 초기 위치를 나타내는 정수 배열 aloc, 플레이어 B의 캐릭터 초기 위치를 나타내는 정수 배열 bloc이 매개변수로 주어집니다. 양 플레이어가 최적의 플레이를 했을 때, 두 캐릭터가 움직인 횟수의 합을 return 하도록 solution 함수를 완성해주세요.

문제 해결:

def solution(board, aloc, bloc):
    R, C = len(board), len(board[0])
    
    def back(curr_loc, opp_loc):
        r, c = curr_loc
        
        if board[r][c] == 0:
            return False, 0
        
        can_move = False
        min_steps = float('inf')
        max_steps = 0
        
        for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
            nr, nc = r + dr, c + dc
            
            if 0 <= nr < R and 0 <= nc < C and board[nr][nc] == 1:
                can_move = True
                
                board[r][c] = 0
                win, steps = back(opp_loc, [nr, nc])
                board[r][c] = 1
                
                if not win:
                    min_steps = min(min_steps, steps + 1)
                else:
                    max_steps = max(max_steps, steps + 1)
        
        if not can_move:
            return False, 0
        
        if min_steps != float('inf'):
            return True, min_steps
        
        return False, max_steps

    _, answer = back(aloc, bloc)
    return answer

해결 방법은 백트래킹을 사용하였다.

백트래킹을 사용한 이유는 다음과 같다.

1. 10초 정도의 시간이 제한 조건이고

2. board의 전체 조건은 1부터 5 사이이다

따라서 전체를 다 돌아도 시간 내에서 끝낼 수 있을 것으로 생각했다.

우선 고려 사항은 다음과 같다.

1. board의 0이 다음 이동 방향일 때는 움직일 수 없다.

2. win이라면 min_step의 비교가 필요하다 이때 min(min_steps, steps+1)로 현재 값과 이전 값의 비교를 한다

3. win이 아니라면 max_step으로 비교를 해야한다. 져야한다면 가장 늦게 져야하기 때문이다. max(max_steps, steps+1)로 비교

4. dx, dy 는 1, -1 이므로 [(0,1), (0,-1), (1,0), (-1,0)]으로 설정하여 for 문을 돌며 dx, dy를 구한다

5. 이때, board 안의 index에서만 돌 수 있도록 간단한 체크문이 필요하다

5-1. 백트래킹의 기본 원칙을 이용하여 넣을 때는 board의 cur location을 0으로 만들고 넘겨준다

5-2. 이후 다시 cur location을 1로 만든다

6. 마지막으로 inf와 비교하여 min_steps가 존재할 때는 minstep을 return하고 그렇지 않으면 max step을 return 한다

프롬프트를 반복하면 정확도가 올라간다

junsky00 — Tue, 24 Feb 2026 20:11:52 +0900

본문:

https://arxiv.org/pdf/2512.14982

2025년 12월에 올라온 논문의 내용인데 최근데 GeekNews에 떠서 읽게 되었다.

내용은 한 줄로 요약이 가능하고 다음과 같다

"Prompt를 reasoning 없이 반복하여 사용하면 높은 퍼포먼스를 보여준다."

도표를 보면 다음과 같이 나와있다. 모든 벤치마크에 따라서 높은 퍼포먼스를 보여주는 것은 아니다.

하지만, 보면 prompt repetition을 하면 할수록 높아지고 있다.

상당히 간단한 논문이고 총 장수는 12장이지만 그 중에서 3장만 읽으면 끝이다.

이 Google 연구진들이 생각하는 다음 방향은 다음과 같다.

1. repeated prompts로 fine-tune하기

2. efficiency를 높이기 위해 reasoning model을 prompt repetition을 사용하기

3. KV-cache에 두번 repeat한 것만 넣기

4. Reorder prompt

5. Repeat only parts of prompt

6. 해당 내용을 non-text modalities에 적용하기

7. Analyze the attention patterns due to repetition

8. Selective attention을 사용하여 use repetitions in tandem

등 여러가지 연구 방향성을 제시하기도 했다.

(대학원생 챙기는 건 역시 갓구글...)

구글이 이젠 scholar까지 먹여살리는 것으로 보인다.

한 10분 정도의 시간만 투자해서 확인해보시길 바란다.

프로그래머스 - [3차] 자동완성 [2018 KAKAO BLIND RECRUITMENT]

junsky00 — Tue, 24 Feb 2026 12:50:10 +0900

문제 설명:

자동완성
포털 다음에서 검색어 자동완성 기능을 넣고 싶은 라이언은 한 번 입력된 문자열을 학습해서 다음 입력 때 활용하고 싶어 졌다. 예를 들어, go 가 한 번 입력되었다면, 다음 사용자는 g 만 입력해도 go를 추천해주므로 o를 입력할 필요가 없어진다! 단, 학습에 사용된 단어들 중 앞부분이 같은 경우에는 어쩔 수 없이 다른 문자가 나올 때까지 입력을 해야 한다.
효과가 얼마나 좋을지 알고 싶은 라이언은 학습된 단어들을 찾을 때 몇 글자를 입력해야 하는지 궁금해졌다.

예를 들어, 학습된 단어들이 아래와 같을 때

go
gone
guild
go를 찾을 때 go를 모두 입력해야 한다.
gone을 찾을 때 gon 까지 입력해야 한다. (gon이 입력되기 전까지는 go 인지 gone인지 확신할 수 없다.)
guild를 찾을 때는 gu 까지만 입력하면 guild가 완성된다.
이 경우 총 입력해야 할 문자의 수는 7이다.

라이언을 도와 위와 같이 문자열이 입력으로 주어지면 학습을 시킨 후, 학습된 단어들을 순서대로 찾을 때 몇 개의 문자를 입력하면 되는지 계산하는 프로그램을 만들어보자.

문제 예시:

words	result
["go","gone","guild"]	7
["abc","def","ghi","jklm"]	4
["word","war","warrior","world"]	15

문제 해결:

def solution(words):
    answer = 0
    N = len(words)
    MAXLEN = len(max(words, key=lambda x: len(x)))
    
    # 반드시 시작점부터 idx까지
    # key값으로 넣고 count 값 넣어서 1인 애들만 더하기
    idx = 1
    count = 0
    
    for idx in range(1, MAXLEN+1):
        lst = []
        dictWords = {}
        
        for idxw in range(len(words)):
            target = words[idxw][:idx]
            if target not in dictWords.keys():
                dictWords[target] = [idxw]
            else:
                dictWords[target].append(idxw)
                
            if len(words[idxw]) == idx:
                count += 1
                answer += len(words[idxw])
                
                if words[idxw] not in lst:
                    lst.append(words[idxw])
        
        for k, v in dictWords.items():
            if len(v) == 1:
                if words[v[0]] not in lst:
                    lst.append(words[v[0]])
                    count += 1
                    answer += len(k)
        
        for i in lst:
            words.remove(i)
        
        if count == N:
            break
    
    return answer

제일 처음으로 아무 생각없이 구현만 해보았다.

시간 초과로 인해 코드를 다시 작성해야 했다.

문제점은 이미 answer에 확정된 단어를 다시 보고 있는 것이 문제였고 끝났음에도 for문을 계속 도는 것이 문제였다.

def solution(words):
    # 트라이(Trie) 구조 생성
    # 구조: {문자: [해당 문자를 거쳐가는 단어 수, 하위 노드 딕셔너리]}
    trie = {}
    
    # 1. 모든 단어를 트라이에 삽입
    for word in words:
        current_node = trie
        for char in word:
            if char not in current_node:
                current_node[char] = [0, {}]
            current_node[char][0] += 1 # 이 노드를 거쳐가는 단어 수 증가
            current_node = current_node[char][1]
            
    answer = 0
    
    # 2. 각 단어별 최소 입력 횟수 계산
    for word in words:
        current_node = trie
        count = 0
        for char in word:
            count += 1
            # 만약 이 접두사를 공유하는 단어가 1개뿐이라면 중단
            if current_node[char][0] == 1:
                break
            current_node = current_node[char][1]
        answer += count
        
    return answer

다음에서 사용한 로직은 트라이(trie)이다.

이 로직은 처음에 {} 으로 비어있는 dict를 주면서 그 이전에 거쳐간 알파벳이 없다는 것을 인지 시키는 것이 제일 중요하다

따라서, gone이라면 {g}, [1, {go}], ... [1, {gone}] 이 된다.

이렇게 모든 단어에 대해서 모든 char를 돌고 결과값을 낸다

#2 에서는 만들어진 trie를 통해 1만 나오는 값을 찾고 해당 값을 answer에 더하고 return한다

프로그래머스 - 숫자 게임 [Summer/Winter Coding (~2018)]

junsky00 — Sun, 22 Feb 2026 14:36:28 +0900

문제 설명:

xx 회사의 2xN명의 사원들은 N명씩 두 팀으로 나눠 숫자 게임을 하려고 합니다. 두 개의 팀을 각각 A팀과 B팀이라고 하겠습니다. 숫자 게임의 규칙은 다음과 같습니다.

먼저 모든 사원이 무작위로 자연수를 하나씩 부여받습니다.
각 사원은 딱 한 번씩 경기를 합니다.
각 경기당 A팀에서 한 사원이, B팀에서 한 사원이 나와 서로의 수를 공개합니다. 그때 숫자가 큰 쪽이 승리하게 되고, 승리한 사원이 속한 팀은 승점을 1점 얻게 됩니다.
만약 숫자가 같다면 누구도 승점을 얻지 않습니다.
전체 사원들은 우선 무작위로 자연수를 하나씩 부여받았습니다. 그다음 A팀은 빠르게 출전순서를 정했고 자신들의 출전 순서를 B팀에게 공개해버렸습니다. B팀은 그것을 보고 자신들의 최종 승점을 가장 높이는 방법으로 팀원들의 출전 순서를 정했습니다. 이때의 B팀이 얻는 승점을 구해주세요.
A 팀원들이 부여받은 수가 출전 순서대로 나열되어있는 배열 A와 i번째 원소가 B팀의 i번 팀원이 부여받은 수를 의미하는 배열 B가 주어질 때, B 팀원들이 얻을 수 있는 최대 승점을 return 하도록 solution 함수를 완성해주세요.

문제 예시:

A	B	result
[5,1,3,7]	[2,2,6,8]	3
[2,2,2,2]	[1,1,1,1]	0

입출력 예 #1

A 팀은 숫자 5를 부여받은 팀원이 첫번째로 출전하고, 이어서 1,3,7을 부여받은 팀원들이 차례대로 출전합니다.
B 팀원들을 4번, 2번, 3번, 1번의 순서대로 출전시킬 경우 팀원들이 부여받은 숫자들은 차례대로 8,2,6,2가 됩니다. 그러면, 첫 번째, 두 번째, 세 번째 경기에서 승리하여 3점을 얻게 되고, 이때가 최대의 승점입니다.

입출력 예 #2
B 팀원들을 어떤 순서로 출전시켜도 B팀의 승점은 0점입니다.

문제 해결:

def solution(A, B):
    answer = 0
    
    B.sort()
    
    for a in A:
        for b in B:
            if b > a:
                answer += 1
                B.remove(b)
                break
    
    return answer

문제 해결은 했지만 효율성 테스트에서 탈락했다.

이는 이중 for문을 돌며 O(n^2)이 되기 때문이다.

따라서, 하나의 for문을 돌며 O(n)이 되게 만드려면 idx를 직접 만들어서 돌아야 한다.

이를 위해서는 A와 B 둘 다 sort를 해야한다.

sort 시에는 가장 큰 값부터 봐야 하므로 reverse=True를 준다.

이후 idx를 a와 b 둘 다에게 주면서 값을 비교해야 한다.

여기서 True로 준 이유가 나온다.

내림차순으로 정렬하면 서로 가장 큰 값들끼리 비교를 하므로 확정적으로 승점을 얻을 수 있는 최적을 구할 수 있다.

만약 크지 않다면 가장 작은 값을 없앰으로써 가장 큰 값에 가장 작은 값을 매칭시키는 방안으로 수행할 수 있다.

def solution(A, B):
    answer = 0
    
    B.sort(reverse=True)
    A.sort(reverse=True)
    
    idxa = 0
    idxb = 0
    
    for i in range(len(A)):
        if B[idxb] > A[idxa]:
            idxa += 1
            idxb += 1
            answer += 1
        else:
            B.pop()
            idxa += 1
    
    return answer

프로그래머스 - 섬 연결하기 [탐욕법(Greedy)]

junsky00 — Thu, 19 Feb 2026 20:07:50 +0900

문제 설명:

n개의 섬 사이에 다리를 건설하는 비용(costs)이 주어질 때, 최소의 비용으로 모든 섬이 서로 통행 가능하도록 만들 때 필요한 최소 비용을 return 하도록 solution을 완성하세요.

다리를 여러 번 건너더라도, 도달할 수만 있으면 통행 가능하다고 봅니다. 예를 들어 A 섬과 B 섬 사이에 다리가 있고, B 섬과 C 섬 사이에 다리가 있으면 A 섬과 C 섬은 서로 통행 가능합니다.

문제 예시:

n	costs	result
4	[[0,1,1],[0,2,2],[1,2,5],[1,3,1],[2,3,8]]	4

문제 해결:

def solution(n, costs):
    costs.sort(key=lambda x: x[2])
    main_group = {costs[0][0]}
    answer = 0
    
    while len(main_group) < n:
        for i in range(len(costs)):
            s, e, w = costs[i]
            
            if s in main_group and e in main_group:
                continue
            
            if s in main_group or e in main_group:
                main_group.add(s)
                main_group.add(e)
                answer += w
                costs.remove(costs[i])
                break
    return answer

모든 값을 비교하면서 최적 값을 넣고 찾았다면 break 하고 다시 while문을 돌려서 최적의 값을 비교하고 찾아낸다.

이때, main_group에 값이 없어야 하며 만약 있더라도 모두가 있으면 안된다.

맨 처음에는 weight가 존재하므로 kruskal 방식으로 풀려고 하였지만 weight 비교를 하기가 너무 까다로웠다.

또한, kruskal의 미숙함도 한 몫한 것으로 보인다.

따라서, kruskal을 쓸 때의 예시를 보여주겠다.

def ancestor(node, parents):
    if parents[node] == node:
        return node
    else:
        return ancestor(parents[node], parents)

def solution(n, costs):
    answer = 0
    edges = sorted([(x[2], x[0], x[1]) for x in costs])
    parents = [i for i in range(n)]
    bridges = 0
    for w, f, t in edges:
        if ancestor(f, parents) != ancestor(t, parents):
            answer += w
            parents[ancestor(f, parents)] = t
            bridges += 1
        if bridges == n - 1:
            break
    return answer

여기서는 ancestor로 linked list가 자기 자신으로 향하는 방식으로 initialize를 한 후에 값을 비교합니다.

만약 둘이 서로 같다면 (이미 연결된 상태) 이때는 건너뜁니다.

그 후 bridges 개수로 완료되었는지 아닌지 확인한 후에 n-1이면 (다 연결된 상태) 그만 둡니다.

프로그래머스 - 야근 지수 [연습문제]

junsky00 — Wed, 18 Feb 2026 16:05:50 +0900

문제 설명:

회사원 Demi는 가끔은 야근을 하는데요, 야근을 하면 야근 피로도가 쌓입니다. 야근 피로도는 야근을 시작한 시점에서 남은 일의 작업량을 제곱하여 더한 값입니다. Demi는 N시간 동안 야근 피로도를 최소화하도록 일할 겁니다.Demi가 1시간 동안 작업량 1만큼을 처리할 수 있다고 할 때, 퇴근까지 남은 N 시간과 각 일에 대한 작업량 works에 대해 야근 피로도를 최소화한 값을 리턴하는 함수 solution을 완성해주세요.

문제 예시:

works	n	result
[4, 3, 3]	4	12
[2, 1, 2]	1	6
[1, 1]	3	0

문제 해결:

import heapq

def solution(n, works):
    if sum(works) <= n:
        return 0
    
    max_heap = []
    for work in works:
        heapq.heappush(max_heap, -work)
    
    for _ in range(n):
        max_val = heapq.heappop(max_heap)
        
        if max_val < 0:
            heapq.heappush(max_heap, max_val+1)
        else:
            heapq.heappush(max_heap, 0)
        
    return sum(w**2 for w in max_heap)

heapq는 heappop 시에 최소값을 뱉어내는 라이브러리이다.

이를 최대값에 적용 시키려면 heappush 시에 -값으로 변환시켜 적용하면 최대값이 나오게 된다.

ex)

4, 3, 3

-4, -3, -3

heappop() 시에 -4가 튀어나온다.

따라서, heappop으로 매 순간 가장 작은 값을 가져와서 n range 내에서 +1 씩 한 후에 마지막에 제곱하여 더하면 결과값이 나온다.

Agent AI Mini Project - 회의 인사이트 제공 AI

junsky00 — Thu, 12 Feb 2026 15:31:49 +0900

개요:

근래에 한국의 근간 사업이 되는 반도체 사업의 붐이 일어나며 해당 산업의 Pain Point가 드러나기 시작했다.

1. 새로운 반도체의 개발을 위해서 논문을 읽으며 회의를 하여 새로운 아이디어를 내는데 오랜 시간이 걸린다.

2. 반도체의 미래 방향성은 당사의 미래를 결정짓는 중요한 결정이다.

3. 끊임없이 나오는 논문과 기사들을 모두 읽을 수 없지만 읽으려면 많은 시간이 걸린다

4. 내부 R&D 자료를 활용하기 어렵다. 왜냐하면 수많은 데이터가 존재하고 이를 외부와 소통하는 LLM에 넣지 못한다

해당 포인트들은 다음과 같은 Solution으로 해결한다.

1. On-Premise Open Source LLM으로 사내 민감 자료를 사용할 수 있게 합니다

2. 반도체와 관련된 기사를 수집 및 Qdrant Vector DB에 저장합니다 - 스케쥴링으로 매일 오후 3시에 수집

3. 반도체와 관련된 논문을 수집 및 Qdrant Vector DB에 저장합니다 - 스케쥴링으로 매일 오후 3시에 수집

4. 보고서 작성 및 인사이트 제공을 위해 LLM이 정보를 취합하여 보고서 형태로 작성합니다

아키텍쳐:

프로젝트의 아키텍쳐 도식화

문제점:

1. 마지막 보고서 작성 단계에서 퀄리티 좋은 보고서를 주지 못한다

2. 기존의 사내 R&D 리포트는 외부와 연결을 닫힌 상태로 정보를 누구에게도 주지 않고 안에서만 돌아야 한다

이러한 과정 중 현재는 1번 문제만 해결을 부분적으로 하였다.

2번의 경우 맞는 LLM을 선택하고 사내 서버에 설치하여야 하는데 적은 이틀동안 하기에 제약이 많아서 수행하진 못했다.

해결점:

1. LLM의 분리화

LLM의 Orchestration을 부분적으로 구현하여 해결하였다.

현재는 Agent 모델이 총 4개로 각각 R&D 자료, 논문, 기사 자료를 검색 및 정보를 추출하는 Agent가 존재하고 보고서 작성 Agent가 또 존재한다.

이를 보고서 작성 단계에서 논문 Agent와 기사 Agent 둘이 회의 혹은 결과물을 만들고 중재자 Agent가 결과물을 통합 및 보고서로 작성한다.

이 방향을 두 가지로 나눠서 구현해 보고 현재 비교 중이다.

1. 논문 Agent와 기사 Agent 둘이 서로 토의 및 질문을 하며 질문을 고도화 - 이후 중재자 Agent가 답변들을 취합 및 보고서로 저장합니다.

2. 중재자 Agent에게 Persona를 입힌 후 기준을 세웁니다. 이후, 논문 Agent와 기사 Agent가 주는 답변을 받습니다. 이후, 수정이 필요하면 instruction과 함께 다시 명령을 내립니다. 최종 통과된 답변들을 취합하여 보고서를 만드는 역할을 합니다.

예시:

사용 예시 이미지

질문: 모 기업의 미래 성장 방향성을 제시해 주고 HBM 수율 문제를 어떻게 해결할 수 있을지 알려주세요

결과:

결과 예시 이미지

(뒷 내용은 잘랐습니다)

현재는 사내 내부 R&D 자료를 사용하지 못하였으며 넣지 않습니다.

추후 계획:

On-Premise로 만들기에는 Mini-Project를 수행하며 수업을 병행하기 어려우니 최종 프로젝트에서 동일한 주제를 사용하게 된다면 그때 바꿀 계획입니다.

또한, 모기업의 뉴스룸 혹은 특허청과 같은 자료들을 수집 및 저장하여 보고서 만들 때 참조하여 사용할 수 있음을 시사하고자 합니다.

느낀 점:

이틀이라는 짧은 시간에도 불구하고 코딩하는 시간은 많이 걸리지 않았습니다.

오히려 아이디어를 만들고 구체화하는데 시간이 많이 걸렸으며 아키텍처를 생성하고 방법을 고안하는데 시간을 많이 할애했습니다.

최근에 본 Geek News의 "우리의 장인정신을 애도합니다"를 보며 많은 생각이 들었습니다.

https://nolanlawson.com/2026/02/07/we-mourn-our-craft/

We mourn our craft

I didn’t ask for this and neither did you. I didn’t ask for a robot to consume every blog post and piece of code I ever wrote and parrot it back so that some hack could make money off o…

nolanlawson.com

이러한 시대의 흐름 속에서 우리는 생각하는 방법을 끊임없이 길러야 하며 error 및 trouble shooting에서의 이해 능력을 길러야 살아남을 수 있을 것으로 보입니다.

비록 Vibe Coding의 생산력과 시간의 효율성은 압도적입니다. 하지만, 코드 리팩토링, 최적화, 창의적인 생각, 등의 능력들은 아직은 힘들다고 생각합니다. 물론 몇 년 사이에 정복될 것이라고 생각합니다. 하지만, 코드를 이해할 수 있는 개발자와 그렇지 못한 개발자는 AI를 쓰더라도 결과물의 퀄리티가 다를 것이라고 생각합니다.

본인의 강점을 끊임없이 생성하고 AI가 하지 못하는 영역을 고민하며 성장해 나가야 한다고 느끼는 좋은 시간이었습니다.

Compound Engineering - 개발자들의 AI의 활용의 극대화

junsky00 — Wed, 11 Feb 2026 10:26:11 +0900

Github:

https://github.com/EveryInc/compound-engineering-plugin

GitHub - EveryInc/compound-engineering-plugin: Official Claude Code compound engineering plugin

Official Claude Code compound engineering plugin. Contribute to EveryInc/compound-engineering-plugin development by creating an account on GitHub.

github.com

개요:

AI를 사용하는데 아직도 채팅 서버 혹은 CLI와 같은 Extension으로만 사용하시나요?

Claw 혹은 Claude에서 발표한 Agent들과 비교하면 현재 AI 사용 방법 또한 발전해야 합니다.

바로, 독립적은 AI Agent들이 일을 할 수 있게 Instruction을 해야 하는 것입니다.

이 Compound Engineering은 Readme.md 와 같은 본인의 취향과 정보를 넣고 plan을 넣으면 AI Agent가 자동으로 작업을 수행 및 완료합니다.

최근에 개발자들을 위한 Prompt 레시피가 많이 존재합니다.

해당 레시피와 유사하다고 보면 됩니다. 하지만, 이 뉴스에서는 AI 활용 단계의 고도화 스텝들을 명시합니다.

Geek News에서 발췌:

개발자 성장 단계 (5단계 래더)

Stage 0: 수동 개발
AI 없이 코드를 한 줄씩 작성, 문서와 Stack Overflow로 조사, print 문으로 디버깅
수십 년간 좋은 소프트웨어를 만들어왔지만 2025년에는 충분히 빠르지 않음

Stage 1: 채팅 기반 어시스턴스
ChatGPT, Claude, Cursor 등에 질문하여 코드 스니펫을 받고 유용한 것을 복사·붙여 넣기
AI가 리서치와 보일러플레이트 생성을 가속하지만 모든 라인을 직접 리뷰하며 완전한 통제 유지

Stage 2: 에이전틱 도구 + 라인별 리뷰
Claude Code, Cursor Composer, Copilot Chat 등 에이전틱 도구가 파일을 읽고 코드베이스에 직접 변경
에이전트가 제안하는 모든 것을 승인/거절하는 게이트키퍼 역할
대부분의 개발자가 이 단계에서 정체하여 AI 위임의 이점을 누리지 못함

Stage 3: 계획 우선, PR 수준 리뷰
모든 것이 변하는 단계: 요구사항·접근 방식·에지 케이스를 포함한 상세 계획을 AI와 공동 작성
계획 수립 후 AI가 감독 없이 구현, 출력물은 PR로 리뷰
Compound Engineering이 여기서 시작 — 매 사이클의 계획·구현·리뷰가 시스템을 학습시켜 다음 사이클을 더 빠르고 쉽게 만듦

Stage 4: 아이디어 → PR (단일 머신)
아이디어를 제공하면 에이전트가 코드베이스 리서치, 계획, 구현, 테스트, 자체 리뷰, 이슈 해결, PR 생성까지 모두 처리
참여가 아이디어 제시, PR 리뷰, 머지 3단계로 축소
아직 한 컴퓨터에서 한 번에 하나만 실행

Stage 5: 병렬 클라우드 실행 (다중 디바이스)
실행을 클라우드로 이전하여 병렬 실행
3개 기능에 3개 에이전트를 동시 투입, PR이 완료되면 리뷰
에이전트가 피드백을 모니터링하고 자발적으로 수정 제안까지 가능
개별 기여자가 아닌 에이전트 함대를 지휘하는 역할

개념:

AI를 사용하려면 다음과 같은 단계가 필요하다.

메인 단계는 다음과 같습니다.

Plan → Work → Review → Compound

1. Plan

요구사항 이해
기존 코드 베이스 조사
사용할 프레임워크, 기술
접근 방식과 변경 대상 파일을 결정
전체 계획의 완결성과 정합성을 확인

2. Work

Git Repository 또는 브랜치로 작업 분리
에이전트가 단계별로 구현
변경 후마다 테스트, 코드 검사, 타입 체크 수행
진행 상황 추적 및 이슈 발생 시 계획 수정
주의: 계획이 완벽하다면 모든 코드 라인들을 감시할 필요 없음

3. Review

여러 에이전트 병렬로 코드 검토
발견 사항을 우선순위로 분류
- P1 (필수 수정)
- P2 (권장 수정)
- P3 (개선 사항)
리뷰 피드백 기반으로 이슈 수정, 수정 결과 검증
특이 사항: 패턴을 기록합니다 (무엇이 잘못되었는지 재발 방지를 위해 문서화)

4. Compound

개발은 위의 단계에서 종료하지만 Compound 단계에서는 시스템 개선이 축적
이 단계에서는 기능을 더 잘 만드는 시스템을 생산 및 개선하는 단계
수행 작업:
- 무엇이 효과적이고 아니었는지 재사용 가능한 통찰은 무엇인지 포착
- YAML로 메타이데이 터, 태그, 카테고리를 추가하여 검색 가능하게 설정
- 새로운 패턴을 CLAUDE.md에 추가하고 필요시 새 에이전트 생성
- 다음에 시스템이 이 문제를 자동으로 잡을 수 있는가? 검증

해당 플로우를 기반으로 Github은 구조화되어있습니다.

26개의 전문 에이전트, 23개 워크플로우 커맨드, 13개 스킬로 구성되어 있습니다.

자세한 구동 방식이나 구성은 Github을 확인해 주세요.

새로운 이념:

버려야 할 8가지 이념

1. 코드는 손으로 작성해야 한다

2. 모든 라인을 수동 리뷰해야 한다

3. 설루션은 엔지니어에게서 나와야 한다 - 필자는 반대하는 입장이다.

4. 코드가 주요 산출물이다

5. 코드 작성이 핵심 업무다

6. 첫 시도가 좋아야 한다

7. 코드는 자기표현이다 - 필자는 반대하는 입장이다.

8. 더 많이 타이핑해야 더 많이 배운다

새로운 이념

1. 시스템에 취향을 추출할 것

네이밍 규칙, 에러 처리 패턴 등 개발자의 취향을 기록하여 AI가 승인할 만한 코드를 직접 생산하도록 해야 함

2. 50/50 규칙 - 50%는 기능 개발, 50%는 시스템 개선에 배분

3. 프로세스를 신뢰하고 안정망을 구축할 것

AI가 테스트, 자동 리뷰, 모니터링 같은 가드레일 구축이 핵심 따라서 수동 리뷰가 아닌 해당 단계를 신뢰할 수 있게 만드는 시스템을 추가해야 합니다

"여기서 가장 어려운 결정은 무엇이었나?" - AI가 까다로운 부분과 판단 지점을 드러내도록 유도
"어떤 대안을 거부했고, 왜 그랬나?" - 고려한 옵션을 확인하여 잘못된 선택 포착
"가장 확신이 없는 부분은?" - LLM이 자신의 약점을 인정하게 하되, 직접 물어야만 답변

4. 환경을 에이전트 네이티브로 구성할 것

개발자가 볼 수 있거나 할 수 있는 것을 에이전트도 할 수 있어야 한다

에이전트에게 허용하지 않는 모든 작업은 직접 수동으로 수행해야 한다

5. 병렬화 활용

에이전트를 클라우드에 여러 개 띄워서 동시에 활용하면 좋다

6. 계획이 새로운 코드

계획 문서가 이제 가장 중요한 산출물

아이디어를 종이 위에서 수정하는 것이 코드에서 수정하는 것보다 저렴

7. 핵심 원칙 요약

모든 작업 단위가 후속 작업을 쉽게 만들 것
취향은 리뷰가 아닌 시스템에 내장할 것
직접 작업하지 말고 시스템을 가르칠 것
리뷰 프로세스가 아닌 안전망을 구축할 것
환경을 에이전트 네이티브로 구조화할 것
복리적 사고를 모든 곳에 적용할 것
위임의 불편함을 수용하고, 완벽하지만 확장 불가한 결과보다 불완전하지만 확장 가능한 결과 선택
더 적은 코드를 작성하고 더 많은 가치를 전달할 것
이 원칙들은 엔지니어링을 넘어 디자인, 리서치, 글쓰기 등 취향과 맥락의 코드화가 도움 되는 모든 분야에 확장 가능

결론:

시대가 빠르게 바뀌고 있고 이에 맞게 현명하게 AI를 쓰는 방법이 화두가 되는 중이다.

이전의 Prompt Engineer라고 불리었던 직무는 이제는 기본 소양으로 전락해 버렸고 이에 맞게 글을 잘 쓰는 방법과 내 생각을 잘 전달하는 과정이 핵심이라고 생각한다.

지금만큼 비전공자가 코딩을 하는데 쉬운 환경은 없을 것이다.

더 이상 코딩은 전공자들만의 전유물이 아니다.

이제는 코딩은 기본이 되었으며 차이를 가르는 것은 창의력과 해결 방법일 것이다.

해당 과정을 사용하게 된다면 해결 방법 또한 AI가 만들어주니 창의력에서 갈라지게 될 것이며 Plan을 짜는 단계가 모든 결과물의 분기점이 될 것이다.

즉, 더 이상 일반 개발자들은 깊이 있는 기술 공부를 하지 않아도 괜찮으며 모르는 분야의 접근성이 뛰어난 시대에서 창의력, 문해력, 독해력, 필력을 갖춰야 한다.

"개발자는 이제 문과"라는 위험한 발언을 조심스레 해본다.

Reference:

https://news.hada.io/topic? id=26560

Compound Engineering : AI 네이티브 엔지니어링 철학 | GeekNews

모든 엔지니어링 작업 단위가 이후 작업을 더 쉽게 만드는 복리형 소프트웨어 개발 방법론으로, AI 에이전트와의 협업을 체계화한 4단계 루프(계획→실행→리뷰→복리화) 를 핵심으로 구성반복

news.hada.io

PostgreSQL Is All You Need (?)

junsky00 — Thu, 5 Feb 2026 09:38:05 +0900

Postgre 진짜 하나로 끝?

PostgreSQL

최근에 AI 화두와 비롯해 메모리 DB 사용 등 여러 기능들을 추가하고 사용하며 여러 기능들을 많이 사용하는 경우가 있다.

하지만, 이번에 들고 온 뉴스의 주장은 Postgres 하나로 모든 것을 해결할 수 있다는 주장이다.

대부분의 회사는 Postgres 하나로 충분해 보인다.

라는 뜻이다. 그렇다면 왜 그럴까? 하나씩 찾아보자

사용하는 Tool들

도구	목적
Elasticsearch	검색
Pinecone	벡터
Redis	캐시
Mongo DB	JSON, 비정형 데이터
Kafka	메세지 큐
InfluxDB	시계열 데이터
PostgreSQL	그 외

이런 애들을 모두 연결하여 혹은 일부만 사용하여 연결하여 사용하는데 문제가 있다.

AI 에이전트는 테스트 DB를 빠르게 띄우고, 포크 하고, 디버깅해야 하는데 여러 DB를 쓰면 힘들다.

Ex) DB(Pinecone + Elasticsearch + Redis + MongoDB)로 사용하면 하나가 무너지거나 실패하면 해당 DB들의 모든 것들을 점검하고 모니터링하며 여러 노력들을 부어야 한다.

하지만 PostgreSQL은 위의 6개의 다른 tool들을 내부적으로 지원해 준다.

Elasticsearch - pg_textsearch - 둘 다 BM25 사용

Pinecone - pgvector + pgvectorscale - 둘 다 DiskANN/HNSW 사용 - Pinecone보다 75% 낮은 cost와 28배 낮은 latency

InfluxDB - TimescaleDB - 둘 다 time partition 사용

MongoDB - JSONB - 둘 다 document index 가능

지리정보 - PostGIS - GIS 포맷 지원

Kafka - pgmq - 로그 생성

Redis - UNLOGGED tables - 둘 다 in-memory 사용

같은 방식으로 작동하는가? Y

같은 목적인가? Y

같은 DB에서 사용하는가? N

Postgres를 쓰면 하나의 DB에서 작동 가능한가? Y

예시

목적	Postgre	다른 tool +
백업 저장소	1	7
모니터링 대시보드	1	7
시큐리티 패치	1	7
온콜 런북	1	7

결론

미래 시대에는 AI Agent와 AI 시대에는 여러 DB들을 사용해야 하는 경우가 많다.

이에 Postgres를 사용하면 필요한 기능들은 외부 extension으로 불러서 사용 가능하다.

이를 통해 복잡한 파이프라인을 구축할 필요 없이 하나의 DB에서 관리하여

1. 모니터링

2. 디버깅

3. 관리

4. 동기화

5. 복구

가 펴하게 할 수 있도록 한다.

물론 Postgre로 모든 게 가능한 것은 아니다.

특정 작업은 전문 DB가 낫기도 하고 right tool이라는 신화에 대해서 비판하고자 하기 위함이다.

따라서, Postgres부터 시작하고 필요 증명 (PoC) 단계에서 사용하고 이후에 Needs가 필요하다면 추가적으로 복잡하게 다르 DB를 사용하자.

하지만 대부분의 경우 Postgres 하나로 충분해 보이니 동기화 실패, 복구 난이도 폭증, 운영 복잡성의 측면에서 비교를 하고 사용하자.

예시 사용 코드는 아래의 reference 및 source url에서 확인하면 좋다.

References:

https://www.tigerdata.com/blog/its-2026-just-use-postgres

It’s 2026, Just Use Postgres | Tiger Data

Stop managing multiple databases. Postgres extensions replace Elasticsearch, Pinecone, Redis, MongoDB, and InfluxDB with BM25, vectors, JSONB, and time-series in one database.