뽕뽑기

[내일배움캠프 사전캠프] - Spring 숙련

단축 — Fri, 2 Oct 2026 21:44:46 +0900

오늘 학습 키워드

동기 & 비동기

동기

호출 후 결과를 기다리고 이후 일을 진행

비동기

호출 후 결과를 기다리지 않고 다음 일을 진행. 결과는 향후 처리

DB 격리 수준

Read Committed

다른 트랜잭션이 커밋한 행의 데이터만 읽을 수 있도록 함

Read UnCommitted

다른 트랜잭션이 아직 커밋하지 않은 행의 데이터도 읽을 수 있도록 함

Repeatable Read

같은 트랜잭션에서 같은 행을 다시 읽을 때 다른 트랜잭션의 변경 때문에 값이 달라지지 않도록 함

Serializable

여러 트랜잭션이 동시에 실행돼도, 그 트랜잭션들을 하나씩 순서대로 실행한 것과 같은 결과를 보장

Spring

낙관적 락 & 비관적 락

낙관적 락: 수정 내용을 DB에 반영할 때 읽어둔 @Version 값과 DB의 현재 버전이 같으면 반영하고, 다르면 충돌로 실패시킴. 성공하면 Hibernate가 버전을 올려 저장함
비관적 락: 데이터를 먼저 잠가 다른 트랜잭션의 충돌하는 작업을 기다리게 하거나 실패시킴

즉시 로딩 & 지연 로딩

즉시 로딩(EAGER): 엔티티를 조회할 때 연결된 연관 데이터도 바로 가져옴
지연 로딩(LAZY): 연관 데이터를 처음 사용할 때 가져옴. 사용하지 않으면 해당 조회를 생략할 수 있음

IoC

객체의 생성과 생명주기 관리를 프레임워크에 맡기는 것

DI

객체가 필요로 하는 다른 객체를 외부에서 전달받는 것. 생성자, 메서드 주입 등이 가능함

Spring Data JPA

JPA 기반 Repository의 반복 코드(보일러플레이트)를 줄여 구현을 간단하게 해줌

인증

사용자가 누구인지 확인

인가

그 사용자가 특정 기능을 사용해도 되는지 확인

Session

사용자별 로그인 상태 등을 서버의 세션 저장소에 보관함. 새로고침만으로 사라지지 않음

Cookie

브라우저에 저장하고, 조건에 맞는 HTTP 요청에 함께 보내는 작은 데이터
보안은 저장하는 내용과 쿠키 속성 및 사용 방식에 따라 달라짐

Filtering

요청이 서블릿에 도달하기 전과 응답이 클라이언트로 돌아가기 전에 공통 작업을 처리함. 로깅과 보안 처리를 비즈니스 로직과 분리할 수 있음

오늘 학습한 내용

무엇을 배웠는지

@Transactional

메서드가 트랜잭션 안에서 실행되도록 설정하는 어노테이션. 메서드나 클래스에 선언할 수 있음

영속성 컨텍스트

엔티티를 관리하고, 변경 내용을 DB에 반영할 수 있도록 추적하는 공간

@Primary, @Qualifier

같은 타입의 Bean 후보 중 어떤 Bean을 주입할지 선택함
@Primary: 같은 타입의 Bean 중 기본으로 선택할 Bean을 지정함
@Qualifier: 주입받는 곳에서 원하는 Bean을 구체적으로 지정함

@Order

여러 Bean을 처리할 때 적용할 순서를 지정함

직접 해본 것

간단 회원가입, 로그인

사용자 비밀번호를 BCrypt로 단방향 해싱하여 저장
사용자 정보로 회원가입, ID 중복 방지
로그인 에러 처리
인증
- 세션 방식: 로그인 성공 시 서버가 세션을 만들고 세션 ID를 쿠키로 전달함. 이후 쿠키의 세션 ID로 로그인 상태를 확인함. 쿠키의 Max-Age와 서버 세션 만료시간은 별개임
- JWT 방식: 로그인 성공 시 사용자 정보와 만료시간을 포함하고 Secret Key로 서명한 Access Token을 발급함. 이후 요청에서 토큰의 서명과 만료시간을 검증해 사용자를 확인함
인가
- 관리자인 경우와 아닌 경우를 나눠 처리하도록 단순 구현

학습하며 겪었던 문제점 & 에러

문제 또는 헷갈렸던 점

JPA와 영속성 컨텍스트

EntityManagerFactory가 EntityManager를 생성하고, EntityManager가 영속성 컨텍스트를 관리하는 관계
비영속: 객체는 생성됐지만 영속성 컨텍스트가 관리하지 않는 상태
영속: 영속성 컨텍스트가 관리하는 상태
준영속: 관리되던 엔티티가 분리되어 더 이상 관리되지 않는 상태
삭제: DB에서 삭제하도록 요청된 상태
엔티티 상태와 메서드는 구분해야 함. find는 조회, persist는 새 엔티티 등록, merge는 상태 병합, remove는 삭제 요청

같은 인터페이스를 구현한 Bean이 여러 개일 때

Food 인터페이스를 구현한 Pizza, Chicken이 모두 Bean으로 등록된 경우
Food 타입만으로 주입할 때 후보가 여러 개이면 주입 대상이 모호해지는 오류가 발생할 수 있음
주입받는 파라미터나 필드 이름이 Bean 이름과 일치하면 이름으로 후보를 구분할 수 있음. @Primary 또는 @Qualifier로 선택을 명시할 수도 있음

내일 학습할 내용

다음 학습

Spring 심화, N+1, 연관관계, 트랜잭션 전파

더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

[내일배움캠프 사전캠프] Spring Boot, Docker, AI literacy

단축 — Thu, 1 Oct 2026 20:59:24 +0900

오늘 학습 키워드

HTTP와 멱등성

GET

조회 URL을 통해 요청

POST

보낸 데이터를 본문에 담아 서버가 처리하도록 요청

PUT

덮어쓰도록 서버에 요청

DELETE

URL로 지정한 자원을 서버가 삭제하도록 요청

HEAD

응답 본문 없이 상태와 헤더정보를 받는 요청

멱등성

같은 요청을 반복했을 때 서버에서 처리 후 의도한 결과가 같은지. POST를 제외하고 모두 반복 요청시 서버가 의도한 동작은 유지된다. DELETE나 PUT은 첫 번째 요청과 두 번째 요청간 결과 상태가 달라질 수 있지만 의도한 삭제와, 덮어쓰기 동작은 변함이 없기 때문에 멱등하다

Spring

라이브러리

기능을 직접 구현하지 않고 불러 쓸 수 있게 정의된 모듈

프레임워크

애플리케이션을 만들 수 있도록 여러 지원을 해주는 공장같은 개념의 도구

ORM

java의 상태에는 한 변수에 객체나 리스트가 담길 수 있다. 그러나 db의 경우 한 칸에 하나의 String이나 Integer값이 들어갈 수 있다. 이 성질 차이를 편하게 메꿔줄 수 있는 중간단계 모델이다

JPA

객체과 RDBMS를 매필하고 관리하는 표준.

영속성 컨텍스트

save함수 수행 시점에 새엔티티시 persist 컨테이너 관리 시작 시점의 엔티티는 영속성이 있다. 그렇지 않으면 merge가 호출됨 이 시점에 반환한 엔티티도 영속성이 있음

Docker

Image

여러 다른 머신에서도 균일하게 동작할 수 있도록 layer형태로 저장해놓은 실행파일

AI

프롬프팅

COT: 문제를 푸는 중간 추론 단계를 나누어 설명하도록 요청하기

structured prompting: 구조화된 형식의 요청. system, name, 요구사항 이런식으로

명령하기: 제안하는 것보다 명령어가 ai가 더 잘 알아들음

윤리

저작권이 있는 저작물에 대한 2차 창작은 저작재산권자의 이용허락 없이 상업적 이용할 경우 법적 침해 가능성이 있다.

오늘 학습 한 내용

무엇을 배웠는지

까먹었던 객체 개념 Spring CRUD에서 3 layer architecture 개념다시 잡음

직접 해본 것

repository, dto, service, controller로 User 엔티티 생성. audit entity를 user가 상속해 생성시점과 변경시점을 자동으로 응답에 포함되도록 진행

학습하며 겪었던 문제점 & 에러

문제 또는 헷갈렸던 점

Controller -> service -> repository 흐름에서 entity를 이용해 DB값 변경하는 과정을 다시 잡음.

상기 배운 내용은 직접 말로 설명할 수 없었던 키워드들을 정리한 내용이고 입에 붙을 때까지 복습할 예정

내일 학습할 내용

강의 수강

Docker CI/CD, Spring 입문주차(70%), 심화주차, 숙련주차

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Python3) - LeetCode (Medium) : 3524. Find X Value of Array I

단축 — Mon, 21 Sep 2026 20:32:38 +0900

https://leetcode.com/problems/find-x-value-of-array-i

Find X Value of Array I - LeetCode

Can you solve this real interview question? Find X Value of Array I - You are given an array of positive integers nums, and a positive integer k. You are allowed to perform an operation once on nums, where in each operation you can remove any non-overlappi

leetcode.com

다소 adhoc 스러운 dp 였습니다.

풀이방법

입력 및 초기화

정답 배열 ans, dict자료구조 cur을 선언 후 적절히 초기화해줍니다.

풀이과정

문제 요구사항을 분해해 재조립하면 답이 보이는 문제입니다. 문제의 연산은 prefix와 suffix를 각각 제거하고, 배열을 비어 있지 않게 남기는 것입니다.

예를 들어

nums = [1, 2, 3, 4]

에서 prefix [1], suffix [4]를 제거하면 [2, 3]이 남습니다.

이를 일반화한다면 어떤 방식으로 prefix와 suffix를 제거하더라도 최종적으로 남는 배열은 항상

nums[left ... right]

형태의 연속된 부분 배열입니다.

즉 문제를 다시 표현하면,

nums의 모든 비어 있지 않은 연속 부분 배열에 대해
부분 배열 원소의 곱 % k를 구하고, 각 나머지가 몇 번 나오는지 세는 문제입니다.

가 됩니다.

가장 단순하게는 모든 (left, right)를 탐색할 수 있습니다. 하지만 가능한 (left, right)의 수 자체가 O(N²)개이므로, memoization을 사용하더라도 각 구간을 상태로 저장한다면 O(N²)개의 상태를 줄일 수 없습니다.

따라서 (left, right) 자체를 저장하지 않고 더 작은 상태로 줄일 방법을 생각해야 합니다.

이때 모든 연속 부분 배열을 오른쪽 끝점 right가 같은 것끼리 묶어서 생각할 수 있습니다. right를 하나 고정하면 가능한 구간은 left만 다른 형태가 되고, right를 한 칸 증가시킬 때는 기존 구간의 오른쪽에 새 원소 하나를 붙이는 형태가 됩니다.

따라서 right를 왼쪽에서 오른쪽으로 하나씩 이동시키면서, 이전 right에서 계산한 정보를 재사용할 수 있는지 살펴봅니다.

왜 right를 하나씩 이동시키는가
모든 부분 배열에는 정확히 하나의 오른쪽 끝점이 있습니다.

예를 들어

nums = [1, 2, 3, 4]

라면 오른쪽 끝점별로 가능한 배열은 다음과 같습니다.

right = 0
[1]

right = 1
[1, 2]
[2]

right = 2
[1, 2, 3]
[2, 3]
[3]

right = 3
[1, 2, 3, 4]
[2, 3, 4]
[3, 4]
[4]

이렇게 보면 모든 연속 부분 배열이 정확히 한 번씩 등장합니다.

원래 문제의 prefix/suffix 관점으로 보면,

right = 2

에서 세는 배열들은 모두 [4]를 suffix로 제거한 경우이고,

[1,2,3]   → prefix 제거 없음
[2,3]     → prefix [1] 제거
[3]       → prefix [1,2] 제거

에 해당합니다.

따라서 right를 0부터 nums길이-1까지 이동하면 suffix를 어디까지 제거할지가 자연스럽게 모두 처리되고, 각 right에서 여러 prefix제거 경우를 처리하면 됩니다.

left를 모두 순회하지 않는 법

여기까지 그대로 구현하면 각 right마다 모든 left를 다시 확인해야 하므로 여전히 O(N²)입니다.

하지만 우리는 각 부분 배열의 실제 곱 전체가 필요한 것이 아니라 곱 % k만 필요합니다.

현재 위치에서 끝나는 두 부분 배열의 곱을 각각 A,B라고 할때

A % k == B % k

라면 다음 숫자 num을 두 배열에 추가했을 때도

(A * num) % k == (B * num) % k

입니다.

따라서 곱의 나머지가 같은 부분 배열들은 앞으로도 똑같이 변화하므로 서로 구분할 필요가 없습니다.

그래서 다음과 같이 줄일 수 있습니다.

cur[remainder] =
    현재 right에서 끝나는 부분 배열 중
    product % k == remainder 인 배열의 개수

예를 들어

cur = {2: 5}

라면 실제로 어떤 left에서 시작했는지는 저장하지 않고,

현재 위치에서 끝나며 곱의 나머지가 2인 부분 배열이 5개 있다.

는 정보만 저장합니다.

다음 숫자가 num이라면 이 5개는 각각 계산할 필요 없이 한꺼번에

new_remainder = (2*num)%k

의 위치에 해당하는 곳으로 이동시킬 수 있고, 이 위치에 5를 더하면 됩니다.

단, 기존 부분 배열을 연장하는 경우 외에도 현재 num하나만 남기는 경우가 새로 하나 생깁니다. 이는 현재 위치 이전의 모든 원소를 prefix로 제거한 경우이므로 num % k 위치에도 하나 추가합니다.

new_cur[num % k] += 1

이렇게 만들어진 next_cur은 현재 right에서 끝나는 모든 부분 배열을 나타냅니다. 따라서 각 (remainder, count)에 대해

ans[remainder] += count

를 수행합니다.

이후

cur = next_cur

로 갱신해 다음 right를 처리합니다.

시간 복잡도

O(N * K): 각 nums에 대해 현재 존재하는 나머지 상태를 순회하며, 가능한 나머지는 0 ~ k-1이므로 최대 k개의 상태만 존재합니다. 문제에서 k <= 5이므로 k를 상수로 보면 최종적으로 O(N)입니다.

공간 복잡도

O(k): cur, next_cur, ans가 각각 최대 k개의 상태만 저장합니다. 문제에서 k <= 5이므로 O(1)로 볼 수 있습니다.

정답 출력 | 반환

ans를 반환합니다.

Code

Python3

class Solution:
    def resultArray(self, nums: List[int], k: int) -> List[int]:
        ans = [0] * k
        cur = {}
        for num in nums:
            next_cur = {}
            
            for item, count in cur.items():
                next_rem = item*num % k
                next_cur[next_rem] = next_cur.get(next_rem,0) + count
            
            next_rem = num % k
            next_cur[next_rem] = next_cur.get(next_rem,0) + 1

            for rem, cnt in next_cur.items():
                ans[rem] += cnt
            cur = next_cur
        return ans

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Python3) - LeetCode (Medium) : 1477. Find Two Non-overlapping Sub-arrays Each With Target Sum

단축 — Thu, 17 Sep 2026 15:24:41 +0900

https://leetcode.com/problems/find-two-non-overlapping-sub-arrays-each-with-target-sum

Find Two Non-overlapping Sub-arrays Each With Target Sum - LeetCode

Can you solve this real interview question? Find Two Non-overlapping Sub-arrays Each With Target Sum - You are given an array of integers arr and an integer target. You have to find two non-overlapping sub-arrays of arr each with a sum equal target. There

leetcode.com

two pointer로 해결한 문제였습니다. arr[i] >= 1이므로 오른쪽을 늘리면 합이 증가하고 왼쪽을 줄이면 합이 감소합니다. 따라서 합이 target을 초과했을 때 left를 이동시키는 sliding window를 사용할 수 있습니다.

풀이방법

입력 및 초기화

현재 구간의 누적합 total과 left 각각 0,0으로 선언합니다.

ans, best(arr[0:i] 범위에서 합이 target인 부분 배열의 최소 길이)를 적절히 큰 값으로 저장합니다.

풀이과정

arr의 원소를 순회하며 다음을 구합니다.
1. total에 현재 원소를 누적해 더해줍니다.

2. total이 target초과한 동안 left의 원소를 total에 제하며 증가시켜줍니다.

3. 현재 위치에서 새로운 target 구간을 찾지 못하더라도 이전까지의 최소 길이를 그대로 이어받습니다.

4. total == target인 경우

4-1. 현 구간 길이 length를 선언해 값을 저장합니다.

4-2. best[left] + length 값과 ans의 최솟값을 저장합니다. best[left]는 arr[0:left] 즉 index left-1까지만 포함하므로 현재 [left,right]과 겹치지 않습니다.

4-3. best[right+1] 은 length의 최솟값과 비교해 저장합니다.

시간 복잡도

O(n): right가 배열을 한 번 순회하고 left 역시 전체 실행에 대해 최대 n번만 이동하기 때문입니다.

공간 복잡도

O(n): best 배열을 n+1크기로 사용하기 때문입니다.

정답 출력 | 반환

ans가 INF라면 -1을 아니라면 ans를 반환합니다.

Code

Python3

class Solution:
    def minSumOfLengths(self, arr: List[int], target: int) -> int:
        total,left = 0,0
        n = len(arr)
        INF = n + 1
        ans = INF
        best = [INF] * (n+1)
        for right,x in enumerate(arr):
            total += x
            while total > target:
                total -= arr[left]
                left+=1
            best[right+1] = best[right]
            if total == target:
                length = right - left + 1
                ans = min(ans, best[left] + length)
                best[right+1] = min(best[right+1], length)
        return -1 if ans == INF else ans

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

2026.08.14

단축 — Fri, 14 Aug 2026 21:25:36 +0900

11:55

기상 늦었다

12:05

대충 앉아있다가 청소할 준비를 한다

13:53

2,6번 항목에 대해 빨리 수정해서 배포하려고 출근했다. 바로 단톡방에 대표님이 연락왔다. 뭐 여러가지 안된다고 하셨다. 안드로이드 결제는 오늘부터 안되다고 원인을 물어보셨다. 상황파악을 했었다. 내가 봤을 때는 2주전에 없던 빨간 네모 표시가 생겼다. 이에 대해 언제부터 되었었고 언제부터 안되었냐고 여쭤봤다. 3달전부터 문제였는데 코드 문제가 아니라 google store의 인 앱 결제 프로필 문제를 해결안해서 정지된 듯 하다. 답변해줬다. 결제부터 해결하라고. 한편 배팀장님이 tag를 2.4.0..2.4.2까지 안따서 따달라고 부탁드렸다. 내 2,6번 항목은 각각 그룹미팅 채팅방 알람끄기 기능 추가랑 cms에서 그룹미팅 쪽 '일시'에 대한 정렬 기능을 추가하는 일이었다. 딸깍 했고 후자는 그 컬럼만 붙이기 짜쳐서 다 고민해서 필요한 컬럼들에 대해 api를 수정해서 다 붙였다. 0.1.32 계약 배포하고 소비자에 물렸다.

개발계에 배포했다고 말씀드렸더니 또 빌드가 안된다고 나보고 apk를 달라고 했다. 드렸더니 확인 후 채팅 아이콘이랑 toast 붙여달라고 하셨다. figma에 있더라 이젠 뭐 빨간네모 어쩌고 되어있어서 모르겠다. 프론트 쪽만 고치면 될 것 같다고 운영에 바로 배포해달라고 하셨다. api,admin,db 컬럼 추가해서 2.5.0배포하고 2.4.2모바일에 next push 해놓았다.

15:30

밥 먹었다. 황태해장국에 라면 넣어서 질펀하게 먹었다. 부추김치 엄마가 해준거 냠냠 흑흑 너무 슬프고 외롭다. 일은 해도 끝도 없고 돈은 푼돈이고 빚은 지고있다. 2번의 임금체불..퇴사..진정서 조사하고..실업급여관련 서류 다 준비하고 수급자격 얻고 교육 오프라인으로 듣고 취업준비하며 계속 서탈 과제탈..일도 하면서 이제 ai 시대에 비즈니스 적 임팩트를 내기 위해 고군분투하고 있다. 회사가 원하는 인재상이 그런 것이라고 생각이 든다. 0-1까지 개발하고 배포한 사람, 비즈니스 적으로 몇명의 사용자를 모았는지, 트래픽은 얼마까지 내봤는지 등을 말이다.

17:53

퇴근하면서 docs깎았다. 릴리즈 랑 뭐 이것저것 볼트쪽 중앙화도 했다. 중복된 부분도 정리하고. 끝이 없다. ai의 장황함을 또 다른 기술부채로 떠안아서 정리하고 있다. 언젠간 해결되겠지 .. 자연어로

18:06

이대로면 썩을 것 같아서 나왔다. 나가자마자 담배 두 갑을 사서 두개를 피며 헬스장으로 향하는 길. 버거킹가서 치즈와퍼를 6,500주고 사먹었다.

18:20 ~ 18:35

헬장가서 스트레칭했다. 흉추 피는게 낙이다

20:05

유일한 행복이다. 매일 밥을 1끼 이상 먹고 운동을 하루 할 수 있는 시간. 내 유일한 자유시간

21:00

리트코드 한 문제 풀고 블로그에 알고리즘 글을 썼다. 무슨 의미가 있나 싶다. 더 큰걸 해야할 것 같다.

21:24

확실히 하루하루 하는 것은 늘었지만 의미있는 작업은 모르겠다.

괴롭다. 언제까지 이러고 살아야하지? 안정감은 언제 들 수 있는거지? 쉬고싶다 매일매일 게으르게 살아도 월 600씩 꼬박 들어왔으면 좋겠다. 맛있는 것. 보고 싶은 것 자유롭게 보고 매일 운동하면서 살고 싶다. 엄청난 욕심인가 싶다.

(Python3) - LeetCode (Easy) : 3090. Maximum Length Substring With Two Occurrences

단축 — Fri, 14 Aug 2026 21:08:41 +0900

https://leetcode.com/problems/maximum-length-substring-with-two-occurrences

Maximum Length Substring With Two Occurrences - LeetCode

Can you solve this real interview question? Maximum Length Substring With Two Occurrences - Given a string s, return the maximum length of a substring such that it contains at most two occurrences of each character. Example 1: Input: s = "bcbbbcba" Out

leetcode.com

two pointer sweeping으로 푼 문제였습니다.

풀이방법

입력 및 초기화

왼쪽 포인터 l, 오른쪽 포인터 r, 정답 ans, 알파뱃을 key로 빈도수를 value 저장할 dict freq를 선언 후 적절히 초기화합니다.

풀이과정

s의 부분문자열이란 s문자열 전체 혹은 일부로 이루어진 연속적인 문자열 이므로 부분문자열을 구성하는 각 알파벳의 빈도수가 최대 2 이하여야 합니다. 이를 검사하기 위해서는 다음을 진행합니다.

s의 각 원소를 순서대로 순회하며 다음을 검사합니다
1. freq[s[r]]은 새로 확인할 알파뱃의 빈도수이므로 이 값 + 1로 갱신합니다

2. freq[s[r]]이 2를 초과하는 동안 freq[s[l]] -= 1 후 l+=1해줍니다

3. r을 1 증가시킨 뒤 현재 유효한 부분문자열의 길이는 r-l이 되며, 이를 ans와 비교해 최댓값을 갱신합니다.

s[r]을 빈도계산하기 전 이미 [l,r-1] 구간은 각 문자의 빈도수가 2이하인 유효한 부분문자열입니다. s[r]을 빈도계산해 갱신 후 2를 초과했을 때 2이하가 될때까지 s[l]을 이동하며 버린다면 갱신된 l1에 대해 다시 연속된 [l1,r] 구간의 유효한 부분문자열이 됩니다. 이때 갱신된 freq의 구성또한 이 부분문자열의 각 빈도수를 정확히 가지게 됩니다.

시간 복잡도

O(N): s배열 길이 N에 대해 r은 최대 N번 증가하고 l역시 최대 N번 증가하기 때문입니다.

공간 복잡도

O(1): 소문자 알파뱃 만큼의 빈도수를 key로 가지기 때문입니다.

정답 출력 | 반환

ans를 반환합니다.

Code

Python3

class Solution:
    def maximumLengthSubstring(self, s: str) -> int:
        l,r,ans = 0,0,0
        freq = {}
        while r < len(s):
            freq[s[r]] = freq.get(s[r],0) + 1
            while freq[s[r]] > 2:
                freq[s[l]] -= 1
                l += 1
            r += 1
            ans = max(ans, r-l)
        return ans

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Python3) - LeetCode (Easy) : 2996. Smallest Missing Integer Greater Than Sequential Prefix Sum

단축 — Tue, 11 Aug 2026 14:42:17 +0900

https://leetcode.com/problems/smallest-missing-integer-greater-than-sequential-prefix-sum

Smallest Missing Integer Greater Than Sequential Prefix Sum - LeetCode

Can you solve this real interview question? Smallest Missing Integer Greater Than Sequential Prefix Sum - You are given a 0-indexed array of integers nums. A prefix nums[0..i] is sequential if, for all 1 <= j <= i, nums[j] = nums[j - 1] + 1. In particular,

leetcode.com

간단 구현문제였습니다.

풀이방법

입력 및 초기화

가장 긴 1씩 증가하는 순열의 누적합을 저장할 prefix_sum을 선언해 nums[0]에 저장합니다.

풀이과정

nums를 순회하며 가장 긴 1씩 증가하는 순열을 계산해 prefix_sum에 누적해 더해줍니다.

조회를 위해 nums를 set로 바꿔 num_set에 저장합니다.
num_set에서 prefix_sum이 없을때까지 1씩 증가시킵니다.

시간 복잡도

O(N): nums에 대해 순회하기 때문입니다.

공간 복잡도

O(N): nums 배열, nums 만큼의 set을 선언합니다.

정답 출력 | 반환

최종 계산된 prefix_sum을 반환합니다.

Code

Python3

class Solution:
    def missingInteger(self, nums: List[int]) -> int:
        prefix_sum = nums[0]
        for i in range(1, len(nums)):
            if nums[i] != nums[i-1] + 1:
                break
            else:
                prefix_sum += nums[i]
        num_set = set(nums)
        while prefix_sum in num_set:
            prefix_sum += 1
        return prefix_sum

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Python3) - LeetCode (Medium) : 1140. Stone Game II

단축 — Sun, 9 Aug 2026 14:00:32 +0900

https://leetcode.com/problems/stone-game-ii

Stone Game II - LeetCode

Can you solve this real interview question? Stone Game II - Alice and Bob continue their games with piles of stones. There are a number of piles arranged in a row, and each pile has a positive integer number of stones piles[i]. The objective of the game is

leetcode.com

memoization dp로 해결한 문제였습니다

풀이방법

입력 및 초기화

memoization을 위한 dict mem, 현 index까지 누적합 sum, 더미의 길이 pile_len을 선언 후 적절히 초기화합니다

풀이과정

alice가 x개를 가져간다면 bob은 다음에 1 <= x <= 2 * max(이전 x, 이전 M)만큼 가져갈 수 있습니다. 즉, 많이 가져갈 수록 상대방이 가져갈 수 있는 더미 길이가 늘어나게 됩니다. alice는 최적의 플레이를 위해 앞으로 x개를 가져갔을 때 bob은 최적의 플레이를 한다면 몇개를 가져갈 수 있을지 계산을 해야합니다. 이는 dp를 이용해 모든 경우의 수를 분석할 수 있도록 점화식을 세우는 것이 가장 간단해 보입니다.

점화식 설정
dp(piv, M): piv위치부터 현 플레이어가 1~2M개의 pile을 선택할 때 최종적으로 얻게되는 최대 돌 수

dp함수 구현
1. 이미 계산된 mem이라면 이후 재귀함수는 호출할 필요가 없으므로 바로 반환합니다.

2. 현 플레이어가 최적 플레이시 piv 위치에서 얻을 수 있는 최댓값 best를 선언 후 0으로 초기화합니다.

3. 현 플레이어 차례에서 piv위치로부터 앞으로 남은 돌의 총합 remaining_candidate를 구해줍니다. piv가 0일때는 sum[-1]을 저장하도록 해주며 나머지의 경우는 sum[-1] - sum[piv-1] 입니다.

4. 현 플레이어가 가져갈 수 있는 x의 범위만큼 순회합니다. 순회하며 각자 최선의 플레이를 했을 때 현 플레이어가 가져갈 수 있는 돌의 최댓값을 best에 저장합니다. piv위치에서 가져갈 수 있는 x의 범위는 1 <= x <= min(2*m, pile_len - piv) 입니다. 이 때 상대 플레이어의 최적 플레이시 가지게 될 돌 수이므로 dp(piv + x, max(m,x))가 됩니다. 현 플레이어는 remaining_candidate - 상대 플레이어의 최적 플레이시 가지게 될 돌 만큼을 가져가게 되며 이때의 최댓값은 best에 저장합니다

5. mem[(piv,m)]을 best값으로 갱신합니다

시간 복잡도

O(N^3): x만큼 dp를 재귀적으로 호출하기 때문입니다

공간 복잡도

O(N^2): memoization key가 piv, m 2차원이기 때문입니다.

정답 출력 | 반환

dp(0,1)을 반환합니다.

Code

Python3

class Solution:
    def stoneGameII(self, piles: List[int]) -> int:
        mem = {}
        sum = [piles[0]]
        pile_len = len(piles)
        for i in range(1, pile_len):
            sum.append(sum[i-1] + piles[i])
        # dp(piv, M): piv위치부터 현 플레이어가 1~2M 개의 pile을 선택할 수 있을 때 최종적으로 얻는 최대 돌 개수 
        def dp(piv: int, m: int):
            if (piv,m) in mem:
                return mem[(piv,m)]
            best = 0
            remaining_candidate = 0
            if piv == 0:
                remaining_candidate = sum[-1]
            else:
                remaining_candidate = sum[-1] - sum[piv-1]
            for x in range(1, min(2*m, pile_len - piv)+1):
                current = dp(piv + x, max(m,x))
                opposite = remaining_candidate - current
                best = max(best, opposite)
            mem[(piv,m)] = best
            return mem[(piv,m)]

        return dp(0,1)

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Python3) - LeetCode (Medium) : 3310. Remove Methods From Project

단축 — Wed, 5 Aug 2026 15:31:26 +0900

https://leetcode.com/problems/remove-methods-from-project

Remove Methods From Project - LeetCode

Can you solve this real interview question? Remove Methods From Project - You are maintaining a project that has n methods numbered from 0 to n - 1. You are given two integers n and k, and a 2D integer array invocations, where invocations[i] = [ai, bi] ind

leetcode.com

stack dfs로 해결한 문제였습니다.

풀이방법

입력 및 초기화

인접그래프를 저장할 2차원 배열 graph를 선언합니다. n행은 method n이 호출하는 caller이고 저장될 원소는 callee가 되므로 invocations의 원소를 순회하며 graph를 갱신합니다.

의심되는 노드를 저장할 suspicious를 선언합니다.

그래프를 순회할 노드를 저장할 stack을 선언합니다. 순회할 첫 노드인 k를 stack에 저장합니다.

풀이과정

k가 직접 또는 간접적으로 호출하는 모든 메서드를 탐색하여 suspicious에 저장합니다.

stack에서 탐색할 노드 node를 꺼냅니다.
0 → 1 → 0과 같은 순환 호출에서 무한 탐색하는 것을 막기 위해, 이미 suspicious에 포함된 노드라면 건너뜁니다.
현재 node는 k에서 도달 가능한 메서드이므로 suspicious에 추가합니다.
node가 호출하는 모든 인접 메서드를 다음 탐색 대상으로 stack에 추가합니다.

이 과정을 통해 k가 직접 또는 간접적으로 호출하는 모든 메서드를 찾습니다.

이후 invocations를 다시 순회하며 의심스러운 메서드들을 제거할 수 있는지 검사합니다.

caller not in suspicious and callee in suspicious

위 조건은 정상 메서드가 의심스러운 메서드를 호출하는 경우를 의미합니다.

문제에서는 의심스러운 메서드를 모두 제거할 수 없는 경우 아무것도 제거하지 않아야 하므로, 이 조건을 하나라도 발견하면 모든 메서드를 반환합니다.

return list(range(n))

외부에서 의심스러운 메서드를 호출하는 경우가 없다면 suspicious에 포함되지 않은 메서드만 반환합니다.

시간 복잡도

메서드의 개수를 n, 호출 관계의 개수를 m이라고 하겠습니다.

인접 리스트 생성: O(m)
DFS 탐색: O(n + m)
외부에서 의심스러운 메서드를 호출하는지 검사: O(m)
남은 메서드 생성: O(n)

따라서 전체 시간 복잡도는:

O(n + m)

공간 복잡도

인접 리스트 graph: O(n + m)
의심스러운 메서드 집합 suspicious: O(n)
DFS 탐색용 stack: O(n)

따라서 전체 공간 복잡도는:

O(n + m)

정답 출력 | 반환

정상 메서드가 의심스러운 메서드를 호출한다면 모든 메서드를 반환합니다.

그렇지 않다면 의심스러운 메서드를 제외한 나머지 메서드 목록을 반환합니다.

Code

Python3

class Solution:
    def remainingMethods(self, n: int, k: int, invocations: List[List[int]]) -> List[int]:
        graph = [[] for _ in range(n)]
        for caller, callee in invocations:
            graph[caller].append(callee)
        suspicious = set()
        stack = [k]
        while stack:
            node = stack.pop()
            if node in suspicious:
                continue
            
            suspicious.add(node)
            for next_node in graph[node]:
                stack.append(next_node)

        for caller, callee in invocations:
            if caller not in suspicious and callee in suspicious:
                return list(range(n))

        return [method for method in range(n) if method not in suspicious]

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Python3) - LeetCode (Easy) : 3731. Find Missing Elements

단축 — Tue, 4 Aug 2026 20:55:00 +0900

https://leetcode.com/problems/find-missing-elements

Find Missing Elements - LeetCode

Can you solve this real interview question? Find Missing Elements - You are given an integer array nums consisting of unique integers. Originally, nums contained every integer within a certain range. However, some integers might have gone missing from the

leetcode.com

set 을 사용해본 문제였습니다. 값만 저장하는 자료구조로 저장 삽입 삭제가 O(1)입니다

풀이방법

입력 및 초기화

nums_set을 선언해 list인 nums를 set으로 변환 후 저장합니다.

정답변수 list ans를 선언합니다.

풀이과정

nums의 최솟값 ~ 최댓값 - 1 만큼 순회하며 다음 조건을 검사합니다
nums_set에 현재 확인하는 정수값 num이 없다면 비어있는 상황이므로 ans에 num을 append해줍니다

시간 복잡도

O(n): 배열의 원소들을 한 번씩 순회하기 때문입니다.

공간 복잡도

O(n): 배열의 원소만큼 set이 가지기 때문입니다.

정답 출력 | 반환

ans를 반환합니다.

Code

Python3

class Solution:
    def findMissingElements(self, nums: List[int]) -> List[int]:
        nums_set = set(nums)
        ans = []
        for num in range(min(nums), max(nums)):
            if num not in nums_set:
                ans.append(num)
        return ans

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Python3) - LeetCode (Easy) : 3014. Minimum Number of Pushes to Type Word I

단축 — Thu, 30 Jul 2026 15:02:23 +0900

https://leetcode.com/problems/minimum-number-of-pushes-to-type-word-i

Minimum Number of Pushes to Type Word I - LeetCode

Can you solve this real interview question? Minimum Number of Pushes to Type Word I - You are given a string word containing distinct lowercase English letters. Telephone keypads have keys mapped with distinct collections of lowercase English letters, whic

leetcode.com

비둘기집 원리를 생각해 풀 수 있었던 문제였습니다.

풀이방법

입력 및 초기화

key 배정하는 것을 word의 한 문자를 누르는 비용이라고 생각하고 assign과 배정을 위해 남은 word의 길이 remaining, 정답 ans를 선언해주고 각각 최소 1번 눌러야하므로 1을, word의 현재 길이를, 0을 배정합니다

풀이과정

비둘기집의 원리
2 ~ 9까지의 패드에만 key 배정이 가능하므로 8자가 넘는 word는 골고루 배치한다고 쳤을때 첫 8자는 1번씩만 누를 수 있게 배치하게 되면 그 다음 문자부터는 2번씩 누르도록 배치할 수 밖에 없습니다. 순차적으로 8자씩 배치할 때 눌러야할 패드의 수 또한 1개씩 사용자가 눌러야 합니다.

루프 제한
remaining // 8 만큼 loop를 돌아 8자씩 배정하며 매 루프마다 ans는 8*assign만큼 누적해 더해주며 assign을 1씩 증가시킵니다.

시간 복잡도

O(1): 26자가 최대이기 때문입니다

공간 복잡도

O(1): 변수 4개만 선언하기 때문입니다

정답 출력 | 반환

ans를 반환합니다.

Code

Python3

class Solution:
    def minimumPushes(self, word: str) -> int:
        assign = 1
        remaining = len(word)
        ans = 0
        loop = remaining // 8
        for _ in range(loop):
            remaining -= 8
            ans += 8 * assign
            assign += 1
        ans += remaining * assign
        return ans

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Python3) - LeetCode (Medium) : 3517. Smallest Palindromic Rearrangement I

단축 — Tue, 28 Jul 2026 23:13:14 +0900

https://leetcode.com/problems/smallest-palindromic-rearrangement-i

Smallest Palindromic Rearrangement I - LeetCode

Can you solve this real interview question? Smallest Palindromic Rearrangement I - You are given a palindromic string s. Return the lexicographically smallest palindromic permutation of s. Example 1: Input: s = "z" Output: "z" Explanation: A string of o

leetcode.com

정렬을 통해 해결한 문제였습니다.

풀이방법

입력 및 초기화

dict d, 팰린드롬의 왼편 문자열 left, 가운데 문자열 middle을 선언해준뒤 s의 문자를 순회하며 문자를 key로, 빈도 수를 value로 누적해 세줍니다.

풀이과정

팰린드롬의 특성상 홀수개수인 알파뱃은 가운데에 위치해야합니다. 홀수개수인 알파뱃을 제외하고 짝수빈도를 가진 알파뱃을 양옆에 데칼코마니 형식으로 배치해주면 가장 빠른 사전순의 팰린드롬이 완성됩니다.

key로 정렬된 dict를 순회하며 팰린드롬을 만들어줍니다.

1. left에 특정 알파뱃 ch를 count // 2 만큼 붙여줍니다.

2. 홀수인 알파뱃이 있다면 가운데에 붙일 middle은 ch가 됩니다.

시간 복잡도

O(N): n의 길이의 s에 대해 한번 순회하며 dict에 저장하기 때문입니다.

공간 복잡도

O(k): 26개의 알파뱃에 대한 순회만 진행하기 때문입니다.

정답 출력 | 반환

left + middle + 뒤집은 left를 반환합니다.

Code

Python3

class Solution:
    def smallestPalindrome(self, s: str) -> str:
        d = {}

        for ch in s:
            d[ch] = d.get(ch, 0) + 1

        left = ""
        middle = ""

        for ch in sorted(d):
            count = d[ch]

            left += ch * (count // 2)

            if count % 2 == 1:
                middle = ch

        return left + middle + left[::-1]

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Python3) - LeetCode (Easy) : 3536. Maximum Product of Two Digits

단축 — Sat, 25 Jul 2026 20:04:39 +0900

https://leetcode.com/problems/maximum-product-of-two-digits

Maximum Product of Two Digits - LeetCode

Can you solve this real interview question? Maximum Product of Two Digits - You are given a positive integer n. Return the maximum product of any two digits in n. Note: You may use the same digit twice if it appears more than once in n. Example 1: Input

leetcode.com

구현 문제였습니다

풀이방법

입력 및 초기화

입력받은 n을 한자리 별 원소로 저장할 배열 digits를 선언합니다

풀이과정

같은 자리가 아닌 두 정수의 최댓값은 가장 큰 두 원소의 곱입니다
따라서 n의 각 자릿수를 배열로 만든 뒤 내림차순으로 정렬했을 때 0,1 원소가 최댓값입니다.

시간 복잡도

O(NlogN): 정렬을 내림차순으로 하기 때문

공간 복잡도

O(N): n의 자릿수만큼의 배열을 선언하기 때문

정답 출력 | 반환

첫 번째와 두 번째의 곱을 반환합니다

Code

Python3

class Solution:
    def maxProduct(self, n: int) -> int:
        digits = sorted(map(int, str(n)), reverse=True)
        return digits[0] * digits[1]

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Python3) - LeetCode (Medium) : 3867. Sum of GCD of Formed Pairs

단축 — Fri, 17 Jul 2026 16:35:41 +0900

https://leetcode.com/problems/sum-of-gcd-of-formed-pairs

Sum of GCD of Formed Pairs - LeetCode

Can you solve this real interview question? Sum of GCD of Formed Pairs - You are given an integer array nums of length n. Construct an array prefixGcd where for each index i: * Let mxi = max(nums[0], nums[1], ..., nums[i]). * prefixGcd[i] = gcd(nums[i], mx

leetcode.com

유클리드 gcd 구현해보고 자료구조와 정렬해보는 문제였습니다.

풀이방법

입력 및 초기화

현재까지의 최댓값을 저장할 current_max_num, 정답 누적값을 저장할 sum, prefixGcd를 선언 후 적절히 초기화해줍ㅂ니다.

풀이과정

prefixGcd 구하기
1. nums의 원소를 순회하며 현 원소 num과 current_max_num과 비교해 더 큰 값이 있다면 갱신해줍니다.

2. num과 current_max_num의 gcd값을 구합니다. gcd를 구할 때는 시간 초과가 되지 않기 위해 O(logN)으로 구현되어야 합니다.

prefixGcd 오름차순으로 정렬하기

누적합 구하기
prefixGcd의 양옆에서 가운데로 순회하며 양끝마다 구한 gcd값을 sum에 누적해 더해줍니다.

시간 복잡도

O(NlogN): pregixGcd길이의 절반만큼 순회하며 gcd를 O(logN)만에 구하기 때문입니다.

공간 복잡도

O(N): n만큼의 길이 배열을 생성하기 때문입니다.

정답 출력 | 반환

sum을 반환합니다.

Code

Python3

class Solution:
    def gcd(a:int, b:int) -> int:
        if b == 0:
            return a
        return gcd(b, a%b)

    def gcdSum(self, nums: list[int]) -> int:
        prefixGcd = []

        sum = 0

        current_max_num = nums[0]

        for num in nums:
            current_max_num = max(current_max_num, num)
            prefixGcd.append(gcd(num,current_max_num))
        prefixGcd.sort()

        prefix_gcd_len = len(prefixGcd)
        for i in range(prefix_gcd_len//2):
            sum += gcd(prefixGcd[i], prefixGcd[prefix_gcd_len-i-1])
        return sum

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Rust) - LeetCode (Easy) : 3120. Count the Number of Special Characters I

단축 — Tue, 26 May 2026 16:21:46 +0900

https://leetcode.com/problems/count-the-number-of-special-characters-i

Count the Number of Special Characters I - LeetCode

Can you solve this real interview question? Count the Number of Special Characters I - You are given a string word. A letter is called special if it appears both in lowercase and uppercase in word. Return the number of special letters in word. Example 1

leetcode.com

vector 자료구조를 사용해본 문제였습니다.

풀이방법

입력 및 초기화

word가 가지고 있는 소문자, 대문자에 대한 vector lower, upper를 각각 선언해 false로 초기화합니다

정답 변수 ans를 선언 후 0으로 초기화합니다.

풀이과정

word의 문자 순회
bytes()로 순회하면 - 연산으로 usize의 index 접근이 가능합니다. 이를 순회하며 소문자라면 lower에 대문자라면 upper를 true로 저장합니다.

알파뱃 순회 lower와 upper가 둘다 있다면 ans값을 1씩 추가합니다.

시간 복잡도

O(n): word의 크기만큼 배열 순회하는 것이 최대 복잡도이기 때문입니다.

공간 복잡도

O(1): 알파뱃 개수*2 만큼의 배열 공간만 선언하면 되기 때문입니다

정답 출력 | 반환

ans를 반환합니다.

Code

Rust

impl Solution {
    pub fn number_of_special_chars(word: String) -> i32 {
        let mut lower = vec![false; 26];
        let mut upper = vec![false; 26];
        let mut ans = 0;
        for word_byte in word.bytes() {
            if word_byte.is_ascii_lowercase() {
                lower[(word_byte - b'a') as usize] = true;
            } else if word_byte.is_ascii_uppercase() {
                upper[(word_byte - b'A') as usize] = true;
            }
        }
        for i in 0..26 {
            if lower[i] && upper[i] {
                ans += 1;
            }
        }
        ans
    }
}

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Rust) - LeetCode (Medium) : 1391. Check if There is a Valid Path in a Grid

단축 — Mon, 27 Apr 2026 15:45:17 +0900

https://leetcode.com/problems/check-if-there-is-a-valid-path-in-a-grid

Check if There is a Valid Path in a Grid - LeetCode

Can you solve this real interview question? Check if There is a Valid Path in a Grid - You are given an m x n grid. Each cell of grid represents a street. The street of grid[i][j] can be: * 1 which means a street connecting the left cell and the right cell

leetcode.com

기존의 단순 bfs가 아닌 한 그리드 칸에 두 상태가 섞인 것을 어떻게 표현하는지의 구현도 포함된 문제였습니다.

풀이방법

입력 및 초기화

mask 함수 구현

각 그리드는 숫자 하나로 구성되어 있으므로 6가지 유형에 대해 서로 연결되었는지 판단하기 위해서는 bit masking이 제일 간단해 보입니다. 왜냐하면 여러 상태를 or 연산으로 집합형태의 masking으로 표현 가능하기 때문입니다. match 패턴으로 유형별 or연산을 해서 상태를 나타낼 mask함수를 선언 및 구현해줍니다.

순회할 방향 정의

길이 뚫려있는지 확인하기 위한 dirs 배열을 정의해줍니다. 예를 들어 행,열 좌표가 -1, 0 방향이면 위로 향하는 것이므로 현재 방향은 위, 그 반대 방향은 아래가 됩니다. -1, 0으로 가기 위해서는 masking된 그리드 값과 & 연산을 했을 때 0이아니라면 그 길이 뚫려있다고 볼 수 있으므로 확인을 위해 현재 방향과 반대방향을 dir의 원소로 추가해줍니다. 즉, dir의 하나의 좌표를 (행, 열, 현재 방향, 반대 방향) 의 tuple로 정의할 수 있습니다.

행, 열, VecDeque, visited 배열 선언

순회를 위한 자료구조들을 선언해줍니다.

풀이과정

사전 작업
1. 첫 순회를 위해 visited[0][0]는 true로, VecDeque인 q의 첫 원소로 0usize, 0usize를 push_back해줍니다.

2. q.pop_front()했을 때 Some인 동안 while loop를 수행하며 bfs를 수행합니다.

2-1. 뽑았을 때 도착 지점이라면 true를 바로 반환합니다.

2-3. 다음 방향으로 갈 수 있는지 dirs의 원소를 순회하며 조건을 검사하며 맞다면 q에 다음 좌표를 push_back합니다. 이미 방문했거나 그리드를 벗어났으면 continue해줍니다. 그 외 다음 좌표가 길이 뚫려있다면 push_back합니다.

시간 복잡도

O(행 수 * 열 수): 각 칸별 4방향 순회

공간 복잡도

O(행 수 * 열 수): 각 칸 방문

정답 출력 | 반환

우측 아래의 좌표로 도달했다면 true, bfs완료 후에도 도달 못했다면 false를 반환합니다.

Code

Rust

use std::collections::VecDeque;

impl Solution {
    const U: i32 = 1;
    const R: i32 = 2;
    const D: i32 = 4;
    const L: i32 = 8;

    fn mask(x: i32) -> i32 {
        match x {
            1 => Self::L | Self::R,
            2 => Self::U | Self::D,
            3 => Self::L | Self::D,
            4 => Self::R | Self::D,
            5 => Self::L | Self::U,
            6 => Self::R | Self::U,
            _ => 0,
        }
    }

    pub fn has_valid_path(grid: Vec<Vec<i32>>) -> bool {
        let r_len = grid.len();
        let c_len = grid[0].len();

        // (행, 열, 현재 방향, 반대 방향)
        let dirs = [
            (-1, 0, Self::U, Self::D),
            (0, 1, Self::R, Self::L),
            (1, 0, Self::D, Self::U),
            (0, -1, Self::L, Self::R),
        ];

        let mut visited = vec![vec![false; c_len]; r_len];
        visited[0][0] = true;

        let mut q = VecDeque::new();
        q.push_back((0usize, 0usize));

        while let Some((r, c)) = q.pop_front() {
            if r == r_len - 1 && c == c_len - 1 {
                return true;
            }

            for &(dr, dc, cur_dir, opp_dir) in &dirs {
                let nr = r as i32 + dr;
                let nc = c as i32 + dc;

                if nr < 0 || nr >= r_len as i32 || nc < 0 || nc >= c_len as i32 {
                    continue;
                }
                let nr = nr as usize;
                let nc = nc as usize;

                if visited[nr][nc] {
                    continue;
                };

                if Self::mask(grid[r][c]) & cur_dir != 0 && Self::mask(grid[nr][nc]) & opp_dir != 0
                {
                    visited[nr][nc] = true;
                    q.push_back((nr, nc));
                }
            }
        }

        false
    }
}

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Rust) - LeetCode (Easy) : 342. Power of Four

단축 — Fri, 15 Aug 2025 22:46:20 +0900

https://leetcode.com/problems/power-of-four

pow함수를 써보는 문제였습니다.

풀이방법

풀이과정

시간 복잡도

16번만 수행하면 되므로 O(1) 입니다

공간 복잡도

상수 공간을 사용하므로 O(1) 입니다.

정답 출력 | 반환

n의 범위가 2^32이므로 4^16까지 for loop를 수행하며 n이랑 같다면 true를 반환하면됩니다.

Code

Rust

impl Solution {
    pub fn is_power_of_four(n: i32) -> bool {
        if n == 0 {
            return false;
        }
        for i in 0..=16 {
            if 4_i32.pow(i) == n {
                return true;
            }
        }
        return false;
    }
}

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Rust) - LeetCode (Easy) : 3477. Fruits Into Baskets II

단축 — Tue, 5 Aug 2025 15:39:52 +0900

https://leetcode.com/problems/fruits-into-baskets-ii/description

전수조사로 해결한 문제였습니다.

풀이방법

입력 및 초기화

i번째 바구니를 사용했는지 여부를 확인하기 위해 vector checked 변수를 mut으로 선언해줍니다.

풀이과정

i번째 fruit를 담을 j번째 basket 크기를 비교
fruits에 대해 iter수행하며 for_each마다 basket에 enumerate 했을 때 j번째가 현재 fruit 이상이라면 담을 수 있으므로 j번째 checked 를 true로 바꿔줍니다.

checked배열에서 false인 값을 변수 unplaced

시간 복잡도

O(n^2)

공간 복잡도

O(n)

정답 출력 | 반환

unplaced를 반환합니다.

Code

Rust

impl Solution {
    pub fn num_of_unplaced_fruits(fruits: Vec<i32>, baskets: Vec<i32>) -> i32 {
        let mut checked = vec![false; baskets.len()];

        fruits.iter().for_each(|fruit| {
            if let Some((j, _)) = baskets
                .iter()
                .enumerate()
                .find(|(j, basket)| fruit <= basket && !checked[*j])
            {
                checked[j] = true;
            }
        });
        let unplaced = checked.iter().filter(|&&x| !x).count() as i32;
        unplaced
    }
}

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Rust) - LeetCode (Easy) : 1979. Find Greatest Common Divisor of Array

단축 — Mon, 4 Aug 2025 13:00:12 +0900

https://leetcode.com/problems/find-greatest-common-divisor-of-array/description/

gcd를 사용해본 문제였습니다.

풀이방법

입력 및 초기화

유클리드 호제법으로 gcd를 반환할 함수를 구현합니다. 시간복잡도는 O(logN)을 가집니다.

풀이과정

nums의 최댓값, 최솟값을 뽑아 값이 있는 경우 max_num, min_num변수에 저장합니다.

시간 복잡도

O(logN)

공간 복잡도

O(N)

정답 출력 | 반환

값이 있는 경우 두 변수의 gcd값을 반환하며 아닌 경우 아무의미 없는 값 0을 반환합니다. if let문은 해당 분기 외의 조건에도 반환값을 강제하기 때문입니다.

Code

Rust

use std::cmp::max;

impl Solution {
    pub fn gcd(a: i32, b: i32) -> i32 {
        if (b == 0) {
            return a;
        }
        return Self::gcd(b, a % b);
    }

    pub fn find_gcd(nums: Vec<i32>) -> i32 {
        if let (Some(&max_num), Some(&min_num)) = (nums.iter().max(), nums.iter().min()) {
            return Self::gcd(max_num, min_num);
        } else {
            return 0;
        }
    }
}

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.

(Python3) - LeetCode (Medium) : 802. Find Eventual Safe States

단축 — Fri, 24 Jan 2025 18:32:52 +0900

https://leetcode.com/problems/find-eventual-safe-states

dfs 문제였습니다.

풀이방법

입력 및 초기화

다음 변수를 선언합니다.

node별로 state를 저장할 배열을 선언합니다.

풀이과정

terminal node인지 검사하는 dfs를 구현합니다.

기저 반환값을 지정합니다: cycle이 발생한다면 말단이 아니므로 False를 아니라면 말단이므로 True를 반환합니다.
중간 계산값을 반환합니다: 현재 node의 state를 1로 만들어주고 이웃이 말단인지 검사해 그 중 하나라도 말단이 아니라면 False를 반환합니다.
이웃들이 모두 말단이므로 현 node도 말단이기 때문에 True를 반환합니다.

시간 복잡도

각 node별로 한 번 씩 검사하므로 O(N) 입니다.

공간 복잡도

각 node 별로 state를 관리하므로 O(N)입니다.

정답 출력 | 반환

각 노드별 dfs 수행결과 말단인 node번호를 배열에 담아 반환합니다.

Code

Python3

class Solution:
    def eventualSafeNodes(self, graph: List[List[int]]) -> List[int]:
        state = [0 for _ in range(len(graph))]
        def dfs(node: int) -> bool:
            if state[node] > 0:
                return state[node] == 2
            state[node] = 1
            for neighbor in graph[node]:
                if not dfs(neighbor):
                    return False
            state[node] = 2
            return True

        return [i for i in range(len(graph)) if dfs(i)]

*더 나은 내용을 위한 지적, 조언은 언제나 환영합니다.