highlightmoon 님의 블로그

적당히 하면 변명이 나오고, 어중간 하면 불평이 나오고, 진심을 다하면 지혜가 나온다

highlightmoon — Sat, 11 Apr 2026 18:04:08 +0900

우리가 인생을 대하는 태도는 무엇인가

우리는 살아가면서 그저 주어지는 대로 살아가는 경우가 많습니다.

어떤 시기가 왔을때 무언가를 해내야 하는 것들이 있기 마련이기 때문인데요.

해내야 하는 것들이 있음에도 그것 위한 종합 가이드북이 없다는게 놀라울 따름입니다.

사실 무언가를 해내야 하는 것의 주어와 목적어는 빠져있습니다.

내가 나를 위해 해내야 하는건지,

내가 남을 위해 해내야 하는건지,

우리는 가끔 헷갈립니다.

보통 우리는 내가 나를 위해 해내야 한다고 생각하면서 그걸 향해 달려가지만

곰곰히 생각해보면 오로지 나를 위해 해내야 하는 것들만은 아닙니다.

사랑하는 사람들을 위해, 주변의 기대와 의식을 견뎌내기 위해, 그저 남들이 하니까.

사실 시작하고 나서는 동기는 그렇게 중요해지지 않습니다.

까먹기 때문이지요.

그리고는 그저 목표만 생각해서 나아가다가

문득 내가 무얼 위해 이러고 있는지 생각하며 멈춰설 때가 있습니다.

우리는 왜 이렇게 달리고 있는지

종종 까먹고 멈춰서고 맙니다.

내 꿈이 이뤄지고 있는 방향인가

누구나 각자의 꿈이 있습니다.

현실적인 이유에 의해 다들 마음속에만 품고 지내다가

내 꿈은 뭐였지 하고 까먹을때까지 그저 주어진 목표에 대해서만 생각합니다.

우리 각자 이루고 싶은게 있었을 것입니다.

축구선수, 야구선수 같이 모두의 응원을 받으며 멋진 득점을 하는 운동선수를 꿈 꾼 사람들이 있을 것이고,

과학자, 수학자 같이 모두가 생각지 못한 지혜를 발견하는 걸 꿈 꾼 사람들이 있을 것이고,

음악, 미술 같이 세상에 없단 아름다움을 발견하는 걸 꿈 꾼 사람들이 있을 것입니다.

그 꿈뿐만이 아니라,

우리가 인생 전체를 살아가면서

나중에 후회 없이 눈을 감을 수 있는 방향이라면

그게 한 사람의 멋진 꿈이 될 것입니다.

다만 그 꿈이 중간에 바뀌고 접히는 일 때문에

지금 하는 일에 그렇게 마음이 가지 않을 수 있습니다.

그 마음에 내 자신을 맡기는건

나 자신에게도, 모두에게도 좋지 않은 방향입니다.

우리는 각자 나름의 가치를 만들어 내는 창조주이기 때문에

그 가치가 하락하는 건 곧 개인의 가치가 하락하는 것이기 때문입니다.

뭐가 됐던 진심을 다하자.

우리는 우리가 하는 일에 자부심을 가지고

진심을 다해야 합니다.

우리 각자는 다 멋진 사람이고

이 사회에서 없어서는 안될 중요한 가치입니다.

때문에 뭔가를 하고 이룬다는 것은 아름다운 일이기에

일단 하면 진심을 다하는게 좋다고 생각합니다.

진심을 다하지 않고 그저 대충 때운다고만 생각하면

변명과 불만만 많아질 것입니다.

그러면 자신에게도 좋지 않습니다.

수많은 스트레스에 쌓여 자신을 갉아 먹고 있다고 생각해 보세요.

제목처럼 진심을 다하면 지혜가 나오게 된다는 말은

그래서 저에게 큰 울림이 있습니다.

그 지혜는 앞으로 살아가면서 나 뿐만이 아니라 주변 사람들에게도 중요한 영향을 끼칠 것입니다.

그러니 이왕 할 것 제대로 한번 해봅시다.

멋지게 살아보는것도 참 멋진 일이니까요.

Claude Code와 첫 앱을 만들어 가면서

highlightmoon — Sat, 4 Apr 2026 15:31:44 +0900

1. 들어가며

요즘 Vibe Coding이 대세다.

예전 석기시대시절 개발자들은 모든 코드를 한줄 한줄 정성스레 짰지만

요즘은 AI에게 명령하고 딸각 버튼만 누르면 몇 백줄 몇 천줄 코드가 순식간에 쏟아져 나오는 시대다.

소프트웨어 산업 전선에서 살아남으려 발버둥 치고 있는 나에게

이는 무시할 수 있는 게 아닌 나의 편으로 만들어야 하는 하나의 임무가 되었다.

17세기 산업혁명이 일어났을때 망치로 기계를 다 부셨으면

지금까지의 발전을 막을 수 있었을까?

시대의 흐름을 따라가는 것은 큰 용기가 필요하지만

어쩌면 생존이 달린 문제가 되면 용기고 뭐고 일단 부딪혀 봐야한다.

이전에 Flutter을 공부하면서 습관 앱을 하나 만들어 본 적이 있었다.

꼬박 2-3달을 배우고 앱을 만들며 디자인과 테스트까지 모두 나 혼자 도맡아온 아름답고 우아한 앱이었다.

하지만 이걸 AI와 함께라면 얼마나 빠르게, 어디까지 가능할까?

라는 궁금증과 함께 이걸 다시 한번 AI를 통해 만들어 보고 싶었다.

그래서 떨리는 손으로 Claude Code의 구독 버튼을 누르고야 말았다.(내 피같은 22불..)

이 글에서는

왜 Claude Code를 선택했는지

어떻게 앱을 설계하고 구현했는지

AI 협업하면서 느낀점

을 써보려 한다.

2. 왜 Claude Code를 선택했는가

요즘 AI 코딩 도구는 넘처나고 있다.

ChatGPT, GitHub Copilot, 그리고 Claude Code까지.

그중 Claude Code를 선택한 이유는 단순했다.

긴 컨텍스트 이해 능력

앱 전체 구조를 설명하면,

파일 간 관계까지 이해하고 코드를 생성해준다.

즉, 작은 함수 생성을 여러번 해주는 툴에서 벗어나

프로젝트 단위 사고가 가능한 것이다.

대화 기반 설계 가능

보통은 설계를 먼저 하고 코딩을 하지만,

Claude Code에서는 먼저 이렇게 질문을 한다.

"습관 앱 만들고 싶어. 기능으로는 A, B, C가 가능했으면 해"

이러면 Claude Code가 바로 설계에 들어가고 난 뒤 코드 초안을 생성해준다.

리팩토링 + 개선 제안

코드에 이슈가 있거나 개선 사항을 우리가 제안하면 Claude Code는 단순 수정이 아니라

- 구조 개선

- 성능 개선

- 더 나은 설계 제안

까지 같이 해준다.

3. 내가 개발하는 앱: Habit Tracker

이번 프로젝트의 목표는 단순했다.

나와 내 주변 사람들이 실제로 유용하게 쓸 수 있는 습관 앱을 만들어 보자.

따라서 핵심 기능은 다음과 같았다.

- 습관 생성 (운동, 독서, 물 마시기 등 유저가 직접 커스텀 가능)

- 반복 주기 및 알람 설정 (매일 / 주 n회 / 몇요일마다)

- 체크 및 진행률 추적

- 통계 및 캘린더를 통한 시각화

4. Claude Code와의 개발 과정

Step 1. 아이디어 -> 설계

처음에는 다음 질문과 같이 시작했다.

"습관 앱을 만들어 볼꺼야. 먼저 기본적으로 유저가 습관을 만들어서 추척할 수 있어야 해. 습관을 만들때는 이름과 제목, 아이콘을 설정할 수 있게 해주고 일주일에 어느 요일에 할건지 선택할 수 있어야 해. 또한 알림기능도 있으면 좋겠어. 그리고 메인 페이지에는 캘린더가 있어서 주별로 또는 월별로 한눈에 확인이 가능하게 할거야"

그러면 Claude가 다음과 같이 작업을 진행해준다.

1. 데이터 모델 설계

2. API 구조 제안

3. 상태 관리 방식

4. 디자인

5. 테스트 환경 구성

Step 2. 기능 단위 개발

예를 들어

"오늘 날짜에 해당하는 습관 목록을 보여주고 완료 여부를 체크할 수 있게 해줘"

라고 명령하면, 바로 전체적인 프로젝트 컨텍스트를 기반으로 이를 위한 기능을 가능하게 해주는 코드를 작성해준다.

Step 3. 리팩토링

작업이 진행됨에 따라 코드베이스 크기가 커지는 건 피할 수 없다.

따라서 간간히

" 이 구조 이대로 괜찮아? 더 나은 방식으로 최적화 할 수 없을까?"

라고 물어보면 Claude가 다음과 같이 제안하고 작업을 한다.

- immutable 구조

- state separation

- domain layer 분리

5. Claude Code와 협업하면서 느낀 점

이 프로젝트를 진행하면서 가장 인상 깊었던 것은

코딩하는 방식 자체가 바뀐다는 점이었다.

장점

1. 개발 속도 폭발적으로 증가

- boilerplate 거의 없음

- 반복 작업 제거

2. 설계 피드백을 실시간으로 받음

혼자 개발하면 놓치기 쉬운 부분이 많다.

예를 들면

- 데이터 모델 구조

- edge case

- 확장성

이런 점들에서 놓친 부분들을 Claude Code가 계속 잡아줘서 오류를 줄여준다.

3. 러닝 커브 감소

새로운 기술을 써야할 때가 와도

"이걸로 구현하려면 어떻게 해야 할까?"

물어보면 바로 내 코드베이스에 맞게 적용이 가능하게 만들어준다.

단점

1. 맹신하면 위험

AI는 완벽하지 않다.

가끔씩 Hallucination된 코드를 생성하므로 반드시 검증을 해야 한다.

2. 설계 주도권을 잃을 수 있음

AI가 제안하는 구조만 계속해서 쓰다 보면

내가 왜 이렇게 설계했는지 내가 만들고 내가 이해가 안되는 상황이 펼쳐짐

3. 디자인은 그림판으로 작업한 수준

앱 아이콘이나 전체적인 디자인에 작업을 부탁할때면 한숨만 나온다.

여기에 토큰을 쓰다보니 보이스피싱에 자주 등장하는

미국 여군에게 돈을 갖다 바치는 느낌이 들었다.

6. 앞으로 개선할 부분

현재 앱은 MVP 수준이다. 앞으로 갈 길이 멀다.

앞으로 추가하고 싶은 기능은

- 전체적인 디자인 개선

- 사용자들이 앱을 계속 사용하게 해 줄 동기부여와 같은 기능 제공

- AI기반 추천 습관 제안

- 수익화

앞으로 작업과정에서 개선 할 부분은

- 디자인은 따로 Claude Agent에서 프로젝트 단위로 진행

- 테스트 & 커버리지 관련 코드 같이 개선할 수 있게 명령

- Compact와 같은 기능을 사용해 토큰 사용 최소화

7. 마치며

이번 프로젝트를 진행하면서 느낀 건 크게 다음과 같다.

"AI는 도구가 아니라, 협업 파트너이므로 잘 사용해야 한다"

Claude Code자체의 생산성이 엄청나기 때문에 개발자로써 이를 무시하는것은

엑셀 팡션을 쓰지 않고 직접 계산기로 다 계산을 해보는거와 마찬가지라고 생각한다.

특히 Claude Code는 단순 코드 생성기를 넘어

설계 + 구현 + 리뷰까지 같이 해주는 중니어 개발자 느낌이었다.

혹시 개인적으로 앱을 만들어보고 싶었는데 기본 지식이 부족했거나 시간이 부족해 망설였다면

꼭 Claude Code와 함께 프로젝트를 하나 시작해보길 적극 추천한다.

행동하면 뭐라도 결과가 나오지만 행동하지 않으면 아무것도 일어나지 않지 않은가.

나를 살아남게 만드는 힘, 회복 탄력성

highlightmoon — Mon, 15 Dec 2025 09:18:39 +0900

피할 수 없는 끊임없이 도전하는 삶

우리는 태어나는 순간부터 수치에 길들여집니다. 태어나자마자 몸무게를 재고, 성별을 확인하며, 키와 혈액형을 기록함으로써 이 세상에 발자취를 남기기 시작합니다. 우리 자체를 나타내는 그 수치들은 점차 나이가 들어감에 따라 서로의 값들을 비교하면서 경쟁하는 것들이 추가가 되기 시작합니다. 친구의 키가 더 큼에 부러움을 느끼고, 시험 성적이 내가 더 높다는 사실에 뿌듯함을 느끼고, 직장동료보다 인사고과를 더 잘 받기 위해 라인을 타기도 합니다. 그렇게 나를 나타내는 수치들을 기록하게 되면서 우리는 피할 수 없는 경쟁에 뛰어들게 됩니다.

물론 경쟁에 뛰어들지 않아도 됩니다. 전 세계에 의무교육이 있어 어느정도의 교육을 받아야 하고 그 과정에서 순위가 기록되기는 하지만, 우리는 그것을 거부할 수 있습니다. 경쟁하지 않고 나 혼자만의 만족과 자부심을 느끼며 살아간다는 것은 그 사람에게 주어진 자유입니다.

그러나 그 삶이 언제나 행복으로 이어진다고 확신있게 말할 수 있는 사람이 얼마나 될까요? 이 세상은 혼자만이 살 수 있는 곳이 아닌, 모두가 서로의 역할을 다하며 서로 도우며 살아가는 공간입니다. 한 사회인으로서의 역할을 한다는 것은 누군가보다 자신이 그 역할에 더 낫다는 것을 보여줌으로써 얻을 수 있습니다. 법에 대해 잘 모르는 제가 재판장이 된다면 이 사회는 얼마나 혼란스러워 질지 생각해보세요.

도전하는 삶은 실패를 항상 품고 있다

우리는 다른 누군가 경쟁을 하면서 도전을 하게 됩니다. 따라서 도전과 경쟁은 다른 의미이지만 꼭 같이 붙어다니는 친구와 같습니다. 그렇다면 이 도전, 경쟁은 항상 내 편일까요? 당연히 아닙니다. 시험에 떨어질 수도 있고, 승진에 실패해 퇴사를 하는 경우도 있습니다. 사업을 일으켰다가 망하는 경우도 정말 많고요. 누군가 도전하지 않는 영역을 도전하면 처음에 경쟁이 없을 수도 있겠지만 당신이 성공을 하게 된다면 당신을 따라하려는 후발 주자들이 우후죽순 생겨날 것이기 때문에 경쟁은 성공 뒤에도 피할 수 없습니다.

따라서 우리의 삶은 언젠간 피할 수 없는 실패를 항상 짊어지고 살아가는것이라 말할 수 있겠습니다. 당연히 많은 사람들은 그 실패를 두려워 하고 피하기 위해 온갖 노력을 다 할 것입니다. 저도 마찬가지로, 실패를 즐기는 사람은 극히 드물 것이기 때문이죠.

저주받은 재능은 애매한 재능이다.

우리는 예술쪽에서 "저주받은 재능은 아예 소질이 없는 재능이 아니라 천재도 아니고 그렇다고 못하는것도 아닌 애매한 재능이다"라는 말을 들어보셨을겁니다. 놀랍게도 그 애매한 재능을 가진 많은 분들이 자신의 능력을 증명할 수 있는 기회를 가짐에도 그것을 피하려고 하는것을 아시나요? 자신의 능력을 증명한다고 생각하는게 아닌, 만천하에 드러난다고 생각하여 그 기회를 잡지 않으려고 한다고 하네요. 마치 어린아이가 숨바꼭질을 할 때 자신의 눈을 가리면 아무도 자신을 보지 못한다고 생각하는 것처럼요.

우리도 도전을 하게 될 때 위와 같은 생각이 많이 들 것입니다. 도전을 해서 실패를 하게 되면 내 실력이 만천하에 드러나게 될테니 그저 현재 상황에 안주하면서 나중에 도전하기 위해 준비중이라는 말만 반복하면서요. 우리는 실패를 두려워해 노력을 한다고 하지만 그건 사실 회피하는게 아닌지 생각해 본 적이 있으신가요?

실패에 무너지는 사람 vs 실패에 배우는 사람

우리는 실패를 한 사람이 한순간 무너지는 경우를 많이 봤습니다. 대부분의 경우 개인적으로 그런 사람들은 과거에 실패를 해본적이 없는 사람들입니다. 항상 성공하고 뜻대로 일이 풀리며 탄탄대로를 걸었던 것이지요. 그러다가 단 하나의 실패로 자신이 부정당하는 기분이 들며 자신이 무너지는 경험을 합니다.

하지만 반대로 실패에 배우는 사람도 있습니다. 이분들의 공통점은 실패에 의연하다는 것입니다. 실패가 자신을 부정당하는 것이 아닌, 어떤 상황과 선택이 여러가지 경우의 수가 패착인 경우도 있고 단지 운이 좋지 못했을 경우도 있습니다. 거기에서 자신이 무엇을 더 잘했으면 이런 결과가 나오지 않았을지 다시 한번 복기하며 다음 도전을 위해 준비를 하지요. 우리가 따라야 하는 실패에 준비를 해야 한다는 것은 이런 방향이 되어야 한다고 생각합니다.

회복 탄력성, 실패에서 성장하는 힘

실패에 의연해지며 실패에서 배우려는 의지와 다음 도전을 향해 나아갈 수 있는 힘, 저는 그것을 회복 탄력성이라 부릅니다. 이는 다시 말해 실패를 해본 사람이 더욱 성장할 수 있는 기회가 있다는 것입니다. 실패를 회피하려는 것이 아닌, 정.면.돌.파 - 이 접근 방법이 우리가 이 삶을 살아가는데 정말 중요한 힘이 아닐까요?

도전하고 싶은 일이 있는데 실패할까봐 두려워 아직도 미루고 계신가요? 그 실패에서 헤어나오지 못할까봐 두려우신가요? 우리는 각자 자신만의 회복 탄력성을 키워야 합니다. 그 실패에도 의연할 수 있고 다음 도전을 할 수 있게 해주는 힘, 그 힘은 성공이 아닌 실패에서 나온다고 생각합니다. 무모한 도전이 아니라면 여러분은 도전하여야 합니다. 성공하면 더할 나위없이 좋고, 실패하면 회복 탄력성이 길러지니까요.

116. Populating Next Right Pointers in Each Node (Linked List, Tree, Depth-First Search, Breadth-First Search, Binary Tree)

highlightmoon — Wed, 29 Oct 2025 08:52:29 +0900

링크 - https://leetcode.com/problems/populating-next-right-pointers-in-each-node/description/?envType=company&envId=facebook&favoriteSlug=facebook-three-months

난이도 - Medium

Intuition

1) BFS

이 문제는 BFS를 통해 풀 수 있다. 우리는 이 Tree가 Perfect binary Tree임을 알고 있으므로, 매번 1, 2, 4, 8,..개의 노드들을 처리해야한다는 것을 알 고 있다. 따라서 이 값을 추적하면서 BFS를 하면 쉽게 문제를 풀 수 있다.

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""

class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        if not root:
            return root

        queue = deque()
        queue.append(root)

        num_nodes_to_count = 1
        cur_count = 0
        prev = None
        while queue:
            node = queue.popleft()
            cur_count += 1

            if prev is not None:
                prev.next = node
            prev = node

            if cur_count == num_nodes_to_count:
                cur_count = 0
                num_nodes_to_count *= 2
                prev = None

            if node.left and node.right:
                queue.append(node.left)
                queue.append(node.right)

        return root

Time Complexity: O(N) 우리는 한번에 하나의 노드씩 모든 노드를 탐색하므로 O(N)이다.

Space Complexity: O(N) BFS를 통해 문제를 푸므로, 마지막 level에서의 노드의 개수는 N/2개이다. 따라서 최대 N/2개의 노드들이 deque에 담길 것이므로, O(N)이다.

2) Using previously established next pointers (O(1) space complexity)

우리는 각 level에서 아래 level에 대해 작업을 수행할 수 있다. 우리가 살펴야 할 것은 두가지 케이스이다.

위의 이미지는 자식 노드들을 어떻게 이어주는지를 보여준다. 예를 들어, 1의 자식노드 2와3을 연결하기 위해서는,

node.left.next = node.right을 해줘야 한다.

하지만 자식노드들의 자식노드들을 이어주다보면 문제가 생긴다. 5와6같이 같은 부모가 아닌 노드들도 연결해줘야 하기 때문이다. 이같은 경우에는 다음 코드로 이어준다.

node.right.next = node.next.left

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""

class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        if not root:
            return root

        # Start with the root node. There are no next pointers
        # that need to be set up on the first level
        leftmost = root

        # Once we reach the final level, we are done
        while leftmost.left:

            # Iterate the "linked list" starting from the head
            # node and using the next pointers, establish the
            # corresponding links for the next level
            head = leftmost
            while head:
                # CONNECTION 1
                head.left.next = head.right
                # CONNECTION 2
                if head.next:
                    head.right.next = head.next.left
                
                # Progress along the list (nodes on the current level)
                head = head.next

            # Move onto the next level
            leftmost = leftmost.left

        return root

Time Complexity: O(N) 모든 노드들(N)을 방문하기 때문이다.

Space Complexity: O(1)

498. Diagonal Traverse (Array, Matrix, Simulation)

highlightmoon — Tue, 28 Oct 2025 16:08:08 +0900

링크 - https://leetcode.com/problems/diagonal-traverse/description/?envType=company&envId=facebook&favoriteSlug=facebook-three-months

난이도 - Medium

Intuition

이 문제는 동작 방식을 이해하면 쉽게 풀 수 있다. 먼저 direction을 1 또는 0으로 설정하게 한다(초기값은 1). 그리고 row와 col이 edge를 만날 경우에는 우리는 그것에 대한 경우의 수를 적어 놓아야 한다.

Code

class Solution:
    def findDiagonalOrder(self, mat: List[List[int]]) -> List[int]:
        ans = []
        rows = len(mat)
        cols = len(mat[0])

        row = col = 0
        direction = 1
        while row < rows and col < cols:
            ans.append(mat[row][col])
            new_row = row + (-1 if direction == 1 else 1)
            new_col = col + (1 if direction == 1 else -1)

            if new_row < 0 or new_col < 0 or new_row >= rows or new_col >= cols:
                if direction == 1:
                    row += (col == cols-1)
                    col += (col < cols-1)
                else:
                    col += (row == rows-1)
                    row += (row < rows-1)
                direction = 1 - direction
            else:
                row = new_row
                col = new_col

        return ans

Complexity

Time Complexity: O(N*M)

Space Complexity: O(1)

1216. Valid Palindrome III (String, Dynamic Programming)

highlightmoon — Tue, 28 Oct 2025 15:10:48 +0900

링크 - https://leetcode.com/problems/valid-palindrome-iii/description/?envType=company&envId=facebook&favoriteSlug=facebook-three-months

난이도 - Hard

Intuition

1) Bottom-Up DP (2D)

우리는 2D list DP를 사용해 이 문제를 풀 수 있다. 알고리즘은 다음과 같다.

1. 먼저 DP를 nxn 리스트로 만든 뒤, 0으로 초기화 한다.

2. i는 n-2부터 0까지, j는 i+1부터 n-1까지 돌린다.

3. s[i] == s[j]이면, 우리는 그 사이의 dp값을 그대로 쓰면 되므로 dp[i][j] = dp[i+1][j-1]이 된다.

4. s[i] != s[j]이면, 우리는 그 사이의 dp값에서 하나를 제거해야 한다. 따라서 dp[i][j] = 1 + min(dp[i+1][j], dp[i][j-1])이 된다. min을 써야 최소값을 계속 추적할 수 있다.

5. 마지막까지 오면 우리가 최종적으로 바꿔야 할 최소값은 dp[0][n-1]이다. 따라서 이 값이 k보다 작거나 같은지 확인한다.

class Solution:
    def isValidPalindrome(self, s: str, k: int) -> bool:
        n = len(s)
        dp = [[0] * n for _ in range(n)]
        for i in range(n-2, -1, -1):
            for j in range(i+1, n):
                if s[i] == s[j]:
                    dp[i][j] = dp[i+1][j-1]
                else:
                    dp[i][j] = 1 + min(dp[i+1][j], dp[i][j-1])

        return dp[0][n-1] <= k

Time Complexity: O(N^2)

Space Complexity: O(N^2)

2) Bottom-Up DP (1D)

위의 알고리즘에서 보면 우리는 항상 dp에서 i+1과 j-1를 참고하는 것을 알 수 있다. 따라서 우리는 space complexity를 O(n)으로 바꿀 수 있다.

우리는 각 i마다 prev를 통해 이전 결과값을 저장할 수 있다. 그리고 각 j마다 현재 dp[j]를 저장하고, dp[j]를 업데이트 한 다음, prev를 이전 dp[j]값으로 가져가는 식이다.

예를 들어보자. 우리가 abceca라는 글자의 최소 제거 값을 알고 싶다고 하자. 알고리즘은 다음과 같을 것이다.

(a - 0, b - 1, c - 2, e - 3, c - 4, a - 5)

1. 먼저 ca이다. (i=4, j=5) 우리는 dp[j=5]값을 구해야 하는데 c와 a가 같지 않으므로 min(dp[5], dp[4])값에 1를 더해야 한다. 따라서 dp[5] = 1이 된다.

2. 그 다음으로 eca이다. 우리는 dp[j=4]와 dp[j=5]값을 구해야 하는데 ec와 eca둘다 양쪽 끝 글자가 같지 않다. 먼저 ec는 당연히 dp[4] = 1이 될것이다. 또한 다음으로 dp[5] = 1 + min(dp[5], dp[4]) = 1 + min(1, 1) = 2가 된다.

3. 그 다음으로 ceca이다. 우리는 dp[j=3],dp[j=4],dp[j=5]를 구해야 하는데 먼저 dp[3] 은 위와 같은 방법으로 1이 된다. 그 전에 원래 값이었던 dp[3] = 0을 이전값으로 가지고 있는다. 그 다음 dp[4]는 양쪽 글자가 같으므로 이전에 가지고 있었던 0을 가져온다. 따라서 dp[4] = 0이 된다. 그러므로 dp[5] = 1 + min(dp[4], dp[5]) = 1 + min(0, 2) = 1이 된다.

class Solution:
    def isValidPalindrome(self, s: str, k: int) -> bool:
        dp = [0] * len(s)

        for i in range(len(s)-2, -1, -1):
            prev = 0
            for j in range(i+1, len(s)):
                temp = dp[j]

                if s[i] == s[j]:
                    dp[j] = prev
                else:
                    dp[j] = 1 + min(dp[j], dp[j-1])
                prev = temp
            print(dp)

        return dp[len(s) - 1] <= k

Time Complexity: O(N^2)

Space Complexity: O(N)

609. Find Duplicate File in System (Array, Hash Table, String)

highlightmoon — Tue, 28 Oct 2025 13:09:08 +0900

링크 - https://leetcode.com/problems/find-duplicate-file-in-system/description/

난이도 - Medium

Intuition

Hash table로 쉽게 풀 수 있는 문제이다. 문제를 잘 이해했다면 어렵지 않을 것이다.

1. 먼저 각 path를 " "로 split한다. 첫번째 원소를 directory로 놓고 다음 원소들부터 file_path와 content로 나눠 content를 key, directory + "/" + file_path를 value로 append한다.

2. 각 hash table 아이템들을 돌면서 value의 크기가 1 이상인 것들만 ans에 append한다.

Code

class Solution:
    def findDuplicate(self, paths: List[str]) -> List[List[str]]:
        hash_table = defaultdict(list)

        for path in paths:
            p = path.split(" ")
            directory = p[0]
            for f in p[1:]:
                file_path, content = f.split("(")
                content = content[:-1]
                hash_table[content].append(directory + "/" + file_path)

        ans = []
        for k, v in hash_table.items():
            if len(v) > 1:
                ans.append(v)
        return ans

Complexity

Time Complexity: O(N*X) N은 paths의 원소의 개수이고 X는 각 string의 평균 길이이다.

Space Complexity: O(N*X) 해시 테이블의 크기는 N * X만큼 늘어나게 된다.

468. Validate IP Address (String)

highlightmoon — Tue, 28 Oct 2025 11:14:42 +0900

링크 - https://leetcode.com/problems/validate-ip-address/description/

난이도 - Medium

Intuition

우리는 각 ip를 그에 맞는 함수에 적용시켜 문제를 풀 수 있다.

Code

class Solution:
    def validIPAddress(self, queryIP: str) -> str:
        counter = Counter(queryIP)
        if counter.get(".", 0) == 3:
            return self.validateIPv4(queryIP)
        elif counter.get(":", 0) == 7:
            return self.validateIPv6(queryIP)
        else:
            return "Neither"

    def validateIPv4(self, ip):
        nums = ip.split(".")
        for num in nums:
            if len(num) == 0 or len(num) > 3:
                return "Neither"
            if len(num) > 1 and num[0] == "0":
                return "Neither"
            if not num.isdigit():
                return "Neither"
            if int(num) > 255:
                return "Neither"
        return "IPv4"

    def validateIPv6(self, ip):
        nums = ip.split(":")
        hexdigits = "0123456789abcdefABCDEF"
        for num in nums:
            if len(num) == 0 or len(num) > 4:
                return "Neither"
            for c in num:
                if c not in hexdigits:
                    return "Neither"
        return "IPv6"

Complexity

Time Complexity: O(N)

Space Complexity: O(1)

905. Sort Array By Parity (Array, Two Pointers, Sorting)

highlightmoon — Tue, 28 Oct 2025 08:26:03 +0900

링크 - https://leetcode.com/problems/sort-array-by-parity/description/

난이도 - Easy

Intuition

이 문제는 쉬우므로 in-place변경을 통해 Space complexity가 O(1)로 할 수 있는 방법으로 문제를 풀어보겠다.

1. 먼저 left, right를 0, len(nums) - 1로 초기화한다.

2. left<right일때 while문을 돌린다.

3. 먼저 nums[left]가 홀수이고 nums[right]가 짝수이면, 둘을 swap한다.

4. 아니면 둘 다 홀수이거나 둘 다 짝수, 혹은 nums[left]가 짝수이고 nums[right]가 홀수이다. 이때 nums[left]가 짝수이면 left += 1하고, nums[right]가 홀수이면 right -= 1한다.

Code

class Solution:
    def sortArrayByParity(self, nums: List[int]) -> List[int]:
        left, right = 0, len(nums) - 1
        while left < right:
            if nums[left] % 2 > nums[right] % 2:
                nums[left], nums[right] = nums[right], nums[left]
            if nums[left] % 2 == 0:
                left += 1
            if nums[right] % 2 == 1:
                right -= 1
        return nums

Complexity

Time Complexity: O(N) one pass from both end

Space Complexity: O(1) in-place operation

15. 3Sum (Array, Two Pointers, Sorting)

highlightmoon — Mon, 27 Oct 2025 16:02:12 +0900

링크 - https://leetcode.com/problems/3sum/description/?envType=company&envId=tiktok&favoriteSlug=tiktok-three-months

난이도 - Medium

Intuition

우리는 TwoSum문제를 푼 방식과 같은 방법으로 문제를 풀 수 있다.

1. nums를 sort한다. 그다음 nums를 for문으로 돌리면서 num이 0보다 크면 앞의 수들은 다 더해도 0보다 크게 되므로 break를 건다.

2. 만약 i == 0 이거나 nums[i-1] != nums[i]이면 TwoSum을 한다.

3. j = i+1부터 시작하여 하나씩 올려간다. 만약 -nums[i] - nums[j]가 target에 있다면 ans에 답으로 집어넣는다. 그리고 nums[j]가 다른 값이 나올때까지 계속 올린다.

Code

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        ans = []

        for i in range(len(nums)):
            if nums[i] > 0:
                break
            if i == 0 or nums[i-1] != nums[i]:
                self.twoSum(nums, i, ans)

        return ans

    def twoSum(self, nums, i, ans):
        visited = set()
        j = i + 1
        while j < len(nums):
            target = -nums[i] - nums[j]
            if target in visited:
                ans.append([nums[i], nums[j], target])
                while j + 1 < len(nums) and nums[j] == nums[j+1]:
                    j += 1
            visited.add(nums[j])
            j += 1

Complexity

Time Complexity: O(N^2)

Space Complexity: O(N)