완성된 앱은 하단 링크를 통해 다운받을 수 있습니다. https://apps.apple.com/us/app/star-clear/id6757729574

• 노란별 +10점 파란별 -20점 폭탄 목숨-1

새해에 개인 프로젝트로 바이브 코딩에 도전해보았습니다. 바이브 코딩에는 관심이 있었는데 가장 접근하기 쉬운 코파일럿이나 AI 채팅 서비스와 대화를 통해 코드를 수정하는 것을 넘어 전 프로젝트가 바이브 코딩을 주로 했으면 좋겠다는 생각이 들었어요. 그러면서 뭘 만들어볼까 고민하다가 몇 가지 기준이 만들어졌는데요,

1. 평소에 안하던 개발 분야
2. 비개발자가 입문하는 것보다는 난이도가 높길 바람
3. 웹 페이지 제외 (이미 해봄 + 개인 활용도가 낮음.)

3가지 기준을 맞추고 나니 앱을 만들어야겠다는 생각이 들었습니다. 저는 주 언어가 Python으로만 대부분 개발을 해와서 React나 TypeScript, Swift 등에 대해 궁금증이 있었거든요.

자세한 개발 과정은 하단의 블로그에서 확인할 수 있습니다. https://kiteday.tistory.com/87

25년 2월 드디어 대학원을 졸업함으로 나는 완벽한 무소속 상태가 되었다. 더 나은 기회와 호기심으로 대학원에 갔지만 격동의 시대에 AI를 연구한다는 것은 혼란의 연속이었다. 끝도 없이 새로운 것이 나와서 그걸 따라가는 것도 벅찬데 정부의 연구비 삭감으로 연구비가 하루 아침에 0원이 되어 갑자기 생활을 위해 돈을 벌어야 하는 상황에까지 놓였다. 연구에서 느낀 것은 천재는 많고 나는 아무것도 모른다는 것이다. 목표하는 학회에 논문을 내겠다고 죽자고 덤벼들었지만 완벽한 실패를 맛보고서 처음으로 완벽주의를 내려놓고 완료주의를 살아야겠다고 생각했다. 동시에 이제는 달리기를 멈추고 정비할 타이밍이 왔음을 직감했다. 작년은 내가 나에게 주는 갭이어였다. “그냥 조금 쉬고나서 취업 준비하려고요” 라는 말을 많이 했지만 누구에게도 내가 의도적인 갭이어를 가지리라고 말하지 않았기 때문에 여기서부터 시작하려고 한다. 사실 나의 계획은 올해를 통으로 버리는 것이었다. 버린다고 표현하니 비 생산적으로 들리지만, 사실은 내가 가진 유한한 에너지를 연구와 같은 학문이 아닌 다른 여러 갈래로 틀어보고 싶다는 말이었다. 나는 처음에는 식품영양에서 시작해 미대와 인공지능 전공 석사까지 분야는 넘나 들었지만 줄곧 학문에 매몰되어있었고, 그 결정의 큰 원인 중 하나는 불안이었다. 나에게는 무소속 상태에 대한 막역한 불안이 늘 자리매김 했다. 불안은 늘 어떠한 미래 결정에 큰 영향을 미쳤기 때문에 어느 순간부터는 내게 직시하는 눈을 흐리게 하는 기분이었다. 그러나 그걸 계속 지속하기에 증명해내기 위한 싸움에서 너무나 지쳐버렸다. 가장 중요한 것은 이 유한한 자원을 통해 어떤 경험을 만들어서 나의 판단력을 흐려지게 만드는 불안으로부터 더 큰 자유를 얻는 것이었다. 전반부에는 할 일이 많이 있었다. 영상 편집도 하고, 여행도 가고, 친구들도 많이 만나면서 매일 충분한 잠과 압박없는 환경에서 행복감을 느꼈다. 심지어는 서비스직 알바조차 재미있었다. 학생 때 줄곧 사무직 업무만 해봤기 때문에 사람을 상대하는 서비스직이 신선하게 느껴졌다. 하지만 어떤 균열이 생기는 것은 그것들을 거의 다 헤치우고 나서 부터이다. 그 때부턴 내게는 내일에 대한 고민을 다시 시작해야만 했다. 꼭 해야지 하는 것들은 이미 다했고, 딱히 새로이 하고 싶은 공부나 직업은 당장에 없어 결국 취업을 하기로 했다. 한 해를 통으로 보내기엔 나는 너무 유약하고 내 불안은 생각보다 컸기 때문에 갭하프이어에서 만족하기로 했다. 평생 직장도 평생 직업도 없다는 걸 알지만 일단은 전공을 살린 일자리가 필요했다. 취업이 어렵다고 말만 들었지 정말 이 전선에 나와본 건 최초였다. 나는 여러 프로젝트 경험, SCI 해외 논문 및 국내 논문 다수, TA 및 튜터로 강의를 맡아본 경험이 있었지만 서류 통과조차 쉽지 않았다. 일단 내 분야를 원하는 직무 자체를 찾기 어려웠다. 어쩌다가 서류가 통과하더라도 과제 테스트와 코팅 테스트 앞에서 석사 학위는 무용지물이었다. 그렇게 몇 달을 써버리고 나니까 직업을 얻는 것 이외에 쓸일 없는 것들에 시간을 많이 쓰고 있는 자신에게 화가 났다. 왜 나는 직업을 찾을 수 없을까? 그래서 그냥 화를 내기 보다 인과관계를 알고싶어 이에 대한 이유를 찾기로 했다. 크게 두 가지가 문제가 된다. 바로 인플레이션과 AI 때문이다.

...(중략) ...

일을 시작하기에는 외적동기도 당연히 필요하지만 그 일을 지속적으로 하기 위해서는 내적동기가 무엇보다 중요한 사람임을 알게 되었다. 이 사실을 말로 정리한 날 나는 머리를 한대 맞은 듯한 큰 발견을 한 기분이었다. 거의 십년 이상을 고민하던 것에 실마리를 찾은 것 같았다. 이 기준 하나로 그간 타성에 젖은 듯한 문장도 설명되지 않던 나의 중구난방같은 관심들도 모두 내 안에서 정리해 줄 세울 수 있게 되었기 때문이다. 아무튼 본론으로 다시 돌아와 정리해보자. 일에서 얻고 싶은 것이 몰입감이라면 일을 지속할 수 있는 것은 내적동기이고 몰입과 내적동기가 큰 것의 공통점은 단 하나였다. 이 일에게 대체 불가능한 재미(쾌)가 있는가? 어떤 것에 절대적으로 즐겁기만 한 일은 없다. 다만 불쾌를 상쇄할 절대적인 쾌의 권력이 있다면 그게 아무리 고통스럽고 힘이 들어도 나는 멈추지 않는다. 이 기준은 사실 일 뿐만 아니라 나의 모든 기준적 잣대라고 해도 손색이 없는 문장이다. 올해도 책임과 재미 그 어느 경계속에서 살아가보려 한다. 새해 첫 날 이것저것보다 읽은 인상 깊은 문장이 있다. 그 문장으로 이 글을 마무리하고 싶다. 과거도 미래도 다 현재를 위한 것이다.

전문은 kiteday 서브스택(하단 링크)을 통해 확인할 수 있습니다!

https://open.substack.com/pub/kiteday/p/1?utm_campaign=post-expanded-share&utm_medium=web

import sys

nums = int(sys.stdin.readline())
house = [list(map(int, sys.stdin.readline().split())) for _ in range(nums)]
# print(house)
dp = [[False]*3 for _ in range(nums)] # 각각 i에서  RGB를 선택했을 때 가지는 최소 값
dp[0] = house[0]
# print(dp)

for i in range(1, nums):
    for c in range(3): # 0:R, 1:G, 2:B
        color = [0, 1, 2]
        color.remove(c)
        dp[i][c] = min(dp[i-1][color[0]], dp[i-1][color[1]]) + house[i][c]

print(min(dp[-1]))

i번째 위치에 있을 때, 각각 R G B을 선택했을 때의 최소값을 계산하면 모든 경우의 수를 확인할 수 있다. 이후 마지막 row의 최소값이 정답이 된다.

완벽히 다엑스트라 구현 문제이다.

import sys
sys.setrecursionlimit(10**6)

v, e = map(int, sys.stdin.readline().split())
k = int(sys.stdin.readline())
min_path = ['inf']*(v+1)
edge = [[False]*(v+1) for _ in range(v+1)]

for _ in range(e):
    u, ev, w = map(int, sys.stdin.readline().split())
    edge[u][ev] = w

def search(node):
    if min_path[node] == 'inf':
        min_path[node] = 0
    next_node = []

    for n in range(v+1):
        if edge[node][n]:
            if min_path[n] == 'inf':
                min_path[n] = min_path[node] + edge[node][n]
                next_node.append([edge[node][n], n])
            else:
                min_path[n] = min(min_path[n], min_path[node]+edge[node][n])

    if next_node:
        next_node.sort()
        search(next_node[0][1])

min_path[k] = 0
search(k)

for i in range(k, v+1):
    print(min_path[i])

처음에 구현한 코드는 잘 돌아가지만, 인접리스트로 구현했기 때문에 메모리 초과를 피할 수 없었다. 왜냐하면 v가 커질수록 더 많은 메모리가 필요한데 최대 v는 20000이므로 10^8을 수용할 수 있는 메모리가 필요하다. 굉장히 비효율적이다. 결국 우선순위 큐로 다시 코드를 짰다.

import heapq
import sys
sys.setrecursionlimit(10**6)

INF = int(1e9)

V, E = map(int, sys.stdin.readline().split())
K = int(sys.stdin.readline())
min_path = [INF]*(V+1)
edge = [[] for _ in range(V+1)]

for _ in range(E):
    u, v, w = map(int, sys.stdin.readline().split())
    edge[u].append((v, w))

def dijkstra(start):
    q = []
    heapq.heappush(q, (0, start))
    min_path[start] = 0

    while q:
        cur_dis, cur_node = heapq.heappop(q)
        if min_path[cur_node] < cur_dis:
            continue

        for node, dis in edge[cur_node]:
            if cur_dis + dis < min_path[node]:
                min_path[node] = cur_dis + dis
                heapq.heappush(q, (cur_dis + dis, node))

dijkstra(K)
for i in range(1, V+1):
    print(min_path[i] if min_path[i] != INF else "INF")

2178과 2160을 섞은 문제다.

from collections import deque

import sys
sys.setrecursionlimit(10**6)

dx = [1, -1, 0, 0]
dy = [0, 0, 1, -1]

n = int(sys.stdin.readline())
count = 0
blind_count = 0
color = []
for _ in range(n):
    c = list(map(str, sys.stdin.readline()))
    color.append(c[:-1])

blind_color = [[('R' if cell == 'G' else cell) for cell in row] for row in color]

visited = [[False]*(n) for _ in range(n)]

def bfs(r, c, my_color):
    # global last_r, last_c
    q = deque()
    q.append((r, c))

    while q:
        cur_r, cur_c = q.popleft()
        visited[cur_r][cur_c] = True
        for idx in range(4):
            nr = cur_r + dx[idx]
            nc = cur_c + dy[idx]

            if (0<= nr <n) and (0<= nc < n) and my_color[nr][nc] == my_color[cur_r][cur_c] and not visited[nr][nc]:
                visited[nr][nc] = True
                q.append((nr, nc))


for i in range(0, n):
    for j in range(0, n):
        if visited[i][j] == False:
            bfs(i, j, color)
            count += 1

visited = [[False]*(n) for _ in range(n)]
for i in range(0, n):
    for j in range(0, n):
        if visited[i][j] == False:
            bfs(i, j, blind_color)
            blind_count += 1
print(count, blind_count, end=" ")

핵심은 사방의 (좌우상하) 값을 보고 같은 지 비교해야 하는 것이다. 처음에 이중포문 없이 구현하겠다고 last_r, last_c를 선언하여 끝나는 지점의 인덱스를 저장하고 한칸 이동하여 다시 search를 했더니 예제의 GG 같은 부분은 책정되지 않았다. (당연함. R -> B를 하고나면 끝나는 지점의 인덱스가 3, 0이기 때문이다.) 그래서 결국 이중포문으로 풀었다. 나는 BFS로 풀었지만 DFS로도 풀 수 있다.

1번 컴퓨터에 연결된 모든 컴퓨터의 개수를 세는 문제로 bfs나 dfs를 구현하는 문제이다. 나는 평소에 dfs로 문제풀이를 많이 하기 때문에 이번엔 bfs로 코드를 짜보았다.

from collections import deque
import sys

sys.setrecursionlimit(10**6)

computer = int(sys.stdin.readline())
n_pair = int(sys.stdin.readline())

edge = [[False]*(computer+1) for _ in range(computer+1)]
for _ in range(n_pair):
    i, j = map(int, sys.stdin.readline().split())
    edge[i][j] = True
    edge[j][i] = True

visited = [False]*(computer+1)
count = 0
def bfs(n):
    global count
    q = deque([n])
    visited[n] = True

    while q:
        cur = q.popleft()
        # print(cur)
        count += 1
        for num in range(1, computer+1):
            if edge[cur][num] == True and not visited[num]:
                q.append(num)
                visited[num] = True

bfs(1)       
print(count-1)

마지막에 count-1을 해주는 이유는 1번 컴퓨터도 개수 집계가 되기 때문이다. 변수를 헷갈리지 않게 유의하며 풀어주도록 하자.

import sys
sys.setrecursionlimit(10**5)

N, M = map(int, sys.stdin.readline().split())
numbers = sorted(list(map(int, sys.stdin.readline().split())))

nums=[]
def back(start):
    if len(nums) == M:
        print(*nums)

    for i in range(start, N):
        nums.append(numbers[i])
        back(i+1)
        nums.pop()

back(0)

여기서 주의해야할 점은 print(*nums) 부분이었다. 출력양식이 대괄호 [] 없이 숫자만 띄어쓰기로 구분해서 출력해야함! 이 문제도 역시 N과 M 시리즈를 풀었다면 쉽게 금방 풀 수 있다.

import sys
sys.setrecursionlimit(10**6)

N, S = map(int, sys.stdin.readline().split())
numbers = list(map(int, sys.stdin.readline().split()))

count = 0
combi = []

def back(n):
    global count
    if sum(combi) == S and len(combi)>0:
        # print(combi)
        count += 1

    for num in range(n, N):
        combi.append(numbers[num])
        back(num+1)
        # print(combi)
        combi.pop()
back(0)
print(count)

N과 M 문제 시리즈의 변형 같은 문제. 단지 멈추는 조건이 조합의 합이 S가 될 때로 바뀐 것 뿐이다. 한가지 간과한 것은 s가 0일 때 combi가 []인 경우도 포함되어서 count가 올라갔었다. 그래서 추가로 combi에 무조건 값이 있어야 한다는 조항을 추가했다.

n = int(input())
date = []

for _ in range(n):
    f = list(map(int, input().split()))
    date.append(f)
date.sort()
start_date = [3, 1]
end_date = [11, 31]
flowers = 0

while(start_date<end_date):
    candidate = [n for n in date if n[0]<start_date[0] or (n[0]==start_date[0] and n[1]<=start_date[1])]
    # print(candidate)
    if not candidate:
        print(0)
        exit()

    e_day = [3,1]
    day = list()

    for c in candidate:
        if c[2:]>e_day:
            e_day = c[2:]
            day = c
    start_date = e_day
    # print(day)
    date.remove(day)
    flowers += 1

print(flowers)

이 문제의 핵심은 기준 날짜보다(초기값 3월1일) 앞서서 피는 꽃을 찾아야 하고, 그 꽃들 중에서 가장 오래 피어있는 꽃을 선택해야한다. 그리고 선택된 꽃이 지는 날이 다시 기준 날짜가 된다는 것이다. 이 아이디어만 생각하면 구현은 금방한다.
마지막으로 만약 그 어떤 꽃도 선택할 수 없을 땐 0을 출력하고 코드를 끝내면 되는 조건을 추가한다.

리스트로 뭔가를 하는게 익숙해서 무작정 리스트로 풀었는데 우선순위 큐 같은 걸로 풀수도 있을 것 같다.

import heapq

n = int(input())
card = []

for _ in range(n):
    card.append(int(input()))

heapq.heapify(card)
sum_num = 0

while(len(card)>1):
    num = heapq.heappop(card)+heapq.heappop(card)
    sum_num += num
    heapq.heappush(card, num)
print(sum_num)

최종합이 적어지려면 작은수 두개씩을 묶어 더해나가면 된다. 이런 생각으로 처음에는 간단하게 배열을 정렬하고 작은수를 pop하면 두개를 더한 값이 다른 수보다 클테니까 이걸 push해서 반복해나가면 되겠다는 아주 단순한 생각이었는데 항상 두 수를 더한 값이 큰 건 아니란 걸 간과한 것이다. 그래서 결론은 우선순위가 필요하다. 결국 우선순위 큐로 다시 코드를 짰다.

n = int(input())
dis = list(map(int, input().split())) # 사용기름 2 3 5
city = list(map(int, input().split())) # 기름가격 5 4 9 2

prefix = [0]*(n)

if n<=2:
    print(city[0] * dis[0])
else:
    for c in range(1, n):
        prefix[c] = prefix[c-1] + min(city[:c]) * dis[c-1]

print(prefix[-1])

위 코드는 41점짜리다. 서브테스크 문제라서 n의 크기에 제약이 있으면 점수를 절반만 준다. 위 코드가 시간 복잡도가 큰 이유는 min연산이다. min만보더라도 $O(n)$인데 이걸 for문만큼 반복하기 때문에 총 $$O(n^2)$$만큼의 복잡도를 갖게 된다. min을 아주 조금만 바꿔주면 100점짜리로 바꿀 수 있다.

n = int(input())
dis = list(map(int, input().split())) # 사용기름 2 3 5
city = list(map(int, input().split())) # 기름가격 5 4 9 2

prefix = [0]*(n)
min_l = city[0]

if n<=2:
    print(city[0] * dis[0])
else:
    for c in range(1, n):
        min_l = min(min_l, city[c-1])
        prefix[c] = prefix[c-1] + min_l * dis[c-1]

print(prefix[-1])

바로 이렇게 어떤 변수에 이미 최소 기름값을 저장해두고 딱 현재 도시와 비교하면 된다. 두 수를 비교하는 것은 $O(1)$이기 때문에 도시의 크기 n과 연관이 없다.

n = int(input())
p = sorted(list(map(int, input().split())))

time_sum = 0
prefix = 0

for i in p:
    time_sum += i
    prefix += time_sum

print(prefix)

누적합이 적으려면 앞사람의 처리시간이 적어야 한다. (그래야 뒷사람이 오래 안기다리기 때문.) 그래서 작은 순으로 정렬하고 모든 값을 합해주면 끝. 간단하게 완료.