[MUSINSA ROOKIE AI NATIVE ENGINEER] 1차 알고리즘 테스트 회고

Career_커리어

[MUSINSA ROOKIE AI NATIVE ENGINEER] 1차 알고리즘 테스트 회고 - 합격

the.Dev.Cat 2026. 2. 28. 14:49

들어가며

무신사에서 MUSINSA ROOKIE AI NATIVE ENGINEER (6개월 전환형) 포지션 공고를 봤다.

솔직히 말하면, 지원 동기가 거창하지 않았다. "어...? 이 정도면 나도 지원해볼 수 있겠는데?" 싶었다.

큰 기대 없이 Notion으로 하루 만에 뚝딱 서류를 넣었고, 그냥 잊고 있었다.

그런데 서류 합격 메일이 왔다.

메일에서 눈에 들어온 문장이 있었다.

우리는 AI Native 엔지니어를 찾고 있지만,
AI를 잘 활용하기 위해서는 탄탄한 기초 코딩 실력이 필수라고 믿습니다.

이번 테스트를 통해 여러분의 기본기를 마음껏 보여주시기 바랍니다.

전형 구조도 명확했다.
1차는 기본적인 개발 역량 확인, 2차는 GitHub + AI Agent 활용이라는 두 단계로 나뉜다.

AI 도구 없이 코딩 기초를 먼저 검증하고, 그다음에 AI와 협업하는 능력을 보겠다는 설계다.

시험 환경

언어는 Python으로 결정했다. 평소 주력은 JS/TS지만, 코딩테스트만큼은 Python을 선택하는 편이다.
강의와 레퍼런스가 풍부하고, 다른 언어 대비 문법이 훨씬 간결하다.
코테 풀이 방법을 찾을 때 Python 예시가 압도적으로 많다는 것도 무시할 수 없는 이점이다.

이번 문제의 특징

제약 조건이 매우 작다.

브랜드 수 B ≤ 10, 고객 수 Q ≤ 100 수준이라 실행 속도는 무의미하다.

Python의 속도 약점이 전혀 영향을 미치지 않는 문제다.

구현 속도가 승부를 가른다.

60분에 2문제를 정확히 짜야 한다. Python은 같은 로직을 Java 대비 약 1/3의 코드량으로 작성할 수 있다.

비정형 CSV 파싱에 최적이다.

두 문제 모두 쉼표 구분, 콜론 구분(A001:10), 하이픈 예외(-) 등 파싱이 까다롭다.

split(), strip(), f-string이 이런 작업에 가장 간결하다.

1번 문제: 브랜드별 사이즈 추천 (풀이시간 : 50분)

배경

무신사에서는 브랜드마다 사이즈 체계가 다릅니다. 구체적으로, B개의 브랜드가 있으며, 각 브랜드에는 여러 사이즈가 있습니다. 각 사이즈는 키, 가슴, 허리로 총 세 부위의 추천 치수의 최솟값, 최댓값으로 이루어져 있습니다.

아래 규칙에 따라 Q명의 고객의 원하는 브랜드와 신체 치수를 기반으로 브랜드별 추천 사이즈를 안내하세요.

규칙

고객이 원하는 브랜드가 존재하지 않는 브랜드이면 UNKNOWN을 안내해야 합니다.
고객이 원하는 브랜드에 대해, 고객의 키, 가슴, 허리 치수 모두 다음과 같은 조건을 만족하는 사이즈를 안내해야 합니다.
- 해당 부위의 추천 치수의 최솟값 이상 최댓값 이하여야 합니다.
추천 가능한 사이즈가 여럿이면, 가장 작은 사이즈를 안내해야 합니다.
- 사이즈 순서는 입력 순서입니다.
  - 첫 번째로 주어지는 사이즈가 가장 작습니다.
만족하는 사이즈가 없는 경우 다음과 같이 처리해야 합니다.
- 고객의 키, 가슴, 허리 치수 모두, 가장 큰 사이즈의 부위별 추천 치수의 최댓값보다 크다면 UP을 안내해야 합니다.
- 고객의 키, 가슴, 허리 치수 모두, 가장 작은 사이즈의 부위별 추천 치수의 최솟값보다 작다면 DOWN을 안내해야 합니다.
- 위 두 경우에 해당하지 않으면 MISMATCH를 안내해야 합니다.

입력 형식

첫째 줄에 브랜드의 개수 B, 고객의 수 Q가 쉼표를 두고 주어집니다.

다음 줄부터 B개의 브랜드의 정보가 다음과 같이 주어집니다.

각 브랜드의 정보의 첫째 줄에는 브랜드명 S, 사이즈 개수 N이 쉼표를 두고 주어집니다.
각 브랜드의 정보의 둘째 줄부터 N개의 줄에 걸쳐 사이즈명 T, 최소 키 H_min, 최대 키 H_max, 최소 가슴 C_min, 최대 가슴 C_max, 최소 허리 W_min, 최대 허리 W_max가 쉼표를 두고 주어집니다.

다음 줄부터 Q개의 줄에 걸쳐 고객이 원하는 브랜드명 S_want, 고객의 키, 가슴, 허리 치수 H, C, W가 쉼표를 두고 주어집니다.

제약 조건

1 <= B <= 10
1 <= Q <= 100
S는 알파벳 대소문자로 이루어진 길이 1 이상 10 이하의 문자열입니다.
B개의 브랜드명은 서로 다릅니다.
1 <= N <= 5
T는 알파벳 대소문자로 이루어진 길이 1 이상 10 이하의 문자열입니다.
브랜드별 N개의 사이즈명은 서로 다릅니다.
100 <= H_min < H_max <= 200
50 <= C_min < C_max <= 150
50 <= W_min < W_max <= 150
브랜드별 N개의 사이즈의 각 치수는 주어지는 순서대로 반드시 증가함이 보장됩니다.
- 각 브랜드에서 첫 번째로 주어지는 사이즈가 해당 브랜드에서 가장 작은 사이즈입니다.
S_want는 알파벳 대소문자로 이루어진 길이 1 이상 10 이하의 문자열입니다.
100 <= H <= 200
50 <= C <= 150
50 <= W <= 150
입력으로 주어지는 모든 수는 정수입니다.

출력 형식

Q개의 줄에 걸쳐 i번째 줄에 i번째 고객이 원하는 브랜드명과 해당 고객한테 안내해야 하는 결과를 쉼표를 두고 출력합니다.

입/출력 예시

예시 1

입력

1,6
Musinsa,3
S,160,170,85,95,70,80
M,165,175,90,100,75,85
L,170,180,95,105,80,90
Musinsa,160,94,80
Musinsa,175,95,85
Nike,170,96,80
Musinsa,182,106,91
Musinsa,155,80,61
Musinsa,180,95,70

출력

Musinsa,S
Musinsa,M
Nike,UNKNOWN
Musinsa,UP
Musinsa,DOWN
Musinsa,MISMATCH

예시 2

입력

2,5
Nike,2
M,170,180,95,105,80,90
L,180,190,105,115,90,100
Adidas,2
S,160,170,85,95,70,80
M,170,180,95,105,80,90
Nike,175,100,85
Adidas,165,90,75
Puma,170,95,80
Reebok,175,100,85
Asics,180,105,90

출력

Nike,M
Adidas,S
Puma,UNKNOWN
Reebok,UNKNOWN
Asics,UNKNOWN

예시 3

입력

1,1
A,1
A,100,200,50,150,50,150
A,100,50,50

출력

A,A

문제 요약

B개 브랜드, 각 브랜드에 N개 사이즈가 있다. 각 사이즈는 키/가슴/허리 세 부위의 추천 치수 범위(min~max)를 가진다. Q명의 고객에 대해 원하는 브랜드와 신체 치수를 받아 사이즈를 안내한다.

판정 흐름은 이렇다.

고객 입력 (브랜드명, 키, 가슴, 허리)
    │
    ├─ 브랜드가 없다 ──────────────────→ UNKNOWN
    │
    ├─ 작은 사이즈부터 순회
    │   └─ 3부위 모두 범위 안 ─────────→ 해당 사이즈명 (첫 매칭 = 가장 작은 것)
    │
    ├─ 3부위 모두 최대 사이즈 초과 ────→ UP
    ├─ 3부위 모두 최소 사이즈 미만 ────→ DOWN
    └─ 그 외 ──────────────────────────→ MISMATCH

핵심 설계 판단 3가지

1. 딕셔너리 O(1) 조회

브랜드명을 키로 사용해 사이즈 리스트에 바로 접근한다.

존재 여부 체크와 데이터 접근을 한 번에 처리할 수 있다.

brands = {}
# key: 브랜드명 (str)
# value: [(사이즈명, hmin, hmax, cmin, cmax, wmin, wmax), ...]

2. 순차 순회 + break

문제에서 "입력 순서대로 크기가 증가함이 보장"된다고 명시했다.

따라서 앞에서부터 순회하다 첫 매칭에서 break하면 자동으로 "가장 작은 사이즈"가 된다.

for t, hmin, hmax, cmin, cmax, wmin, wmax in sizes:
    if hmin <= h <= hmax and cmin <= c <= cmax and wmin <= w <= wmax:
        matched = t
        break

break를 빼면 마지막 매칭이 결과가 된다. 즉, "가장 큰 사이즈"를 안내하는 오답이 나온다.

3. and 조건

UP/DOWN 판정에서 and와 or의 차이가 합격과 오답을 가른다.

키	가슴	허리	and	or
> max	> max	> max	UP	UP
> max	> max	범위 내	MISMATCH	UP
> max	< min	범위 내	MISMATCH	UP

or를 쓰면 "키만 초과해도 UP"이 된다. 문제의 "모두"라는 단어가 and 조건임을 나타내는 핵심 키워드였다. 코드를 짜기 전에 이 경우의 수를 직접 따져본 것이 핵심이었다.

전체 코드

import sys


def main():
    input = sys.stdin.readline

    B, Q = map(int, input().strip().split(","))

    brands = {}

    for _ in range(B):
        parts = input().strip().split(",")
        brand_name = parts[0]
        n = int(parts[1])

        sizes = []
        for _ in range(n):
            p = input().strip().split(",")
            sizes.append((p[0], int(p[1]), int(p[2]), int(p[3]), int(p[4]), int(p[5]), int(p[6])))

        brands[brand_name] = sizes

    results = []

    for _ in range(Q):
        parts = input().strip().split(",")
        swant = parts[0]
        h = int(parts[1])
        c = int(parts[2])
        w = int(parts[3])

        if swant not in brands:
            results.append(f"{swant},UNKNOWN")
            continue

        sizes = brands[swant]
        matched = None

        for t, hmin, hmax, cmin, cmax, wmin, wmax in sizes:
            if hmin <= h <= hmax and cmin <= c <= cmax and wmin <= w <= wmax:
                matched = t
                break

        if matched is not None:
            results.append(f"{swant},{matched}")
            continue

        smallest = sizes[0]
        largest = sizes[-1]

        if h > largest[2] and c > largest[4] and w > largest[6]:
            results.append(f"{swant},UP")
        elif h < smallest[1] and c < smallest[3] and w < smallest[5]:
            results.append(f"{swant},DOWN")
        else:
            results.append(f"{swant},MISMATCH")

    print("\n".join(results))


if __name__ == "__main__":
    main()

이것이 시험 후 수정한 정답 버전이다. 실제 제출 코드에는 버그가 있었다.

버그	실제 제출	수정 후
출력 구분자	`f"{swant} UNKNOWN"` (공백)	`f"{swant},UNKNOWN"` (쉼표)
`__name__` 표기	`name` (구름 IDE 변환)	`__name__`

로직 자체는 맞았다. 출력 형식 하나를 놓쳤다.

시험장에서 예제를 다시 확인했어야 했는데, 테스트 통과에 안심하고 넘어간 것이 실수였다.

2번 문제 : 스토어 픽업 예약 (풀이시간 : 10분, 미완성 제출)

배경

무신사 오프라인 스토어에서 온라인 주문 픽업 서비스를 운영합니다. 구체적으로, S개의 스토어가 있으며, 각 스토어는 스토어 ID, 오픈 시간, 마감 시간, 시간당 픽업 한도, 상품별 재고 정보가 있습니다.

아래 규칙에 따라 Q개의 픽업 예약 요청을 순서대로 처리하세요.

규칙

픽업 예약의 스토어 ID가 존재하는 스토어여야 합니다.
픽업 예약의 희망 시간은 스토어의 오픈 시간 이상 마감 시간 미만이어야 합니다.
- 예를 들어, 오픈 시간이 10시이고, 마감 시간이 20시라면, 희망 시간은 10:00 이상 20:00 미만이어야 합니다.
픽업 예약의 희망 시간이 속한 시간대의 픽업 예약 수가 스토어의 시간당 픽업 한도 미만이어야 합니다.
- 여기서 희망 시간이 속한 시간대란, 희망 시간의 분을 제외한 시간만 의미합니다.
  - 예를 들어, 희망 시간이 14:30이라면, 이는 14시대의 예약입니다.
픽업 예약의 요청 수량은 스토어의 재고 이하여야 합니다.
픽업 예약에 성공하면, 해당 스토어의 재고가 요청 수량만큼 차감되며, 해당 시간대의 픽업 예약 수가 1만큼 증가합니다.
요청은 입력 순서대로 처리해야 합니다.

입력 형식

첫째 줄에 스토어의 수 S와 픽업 예약 요청 수 R이 쉼표를 두고 주어집니다.

다음 S개의 줄에 걸쳐, i번째 줄에 스토어 ID N_i, 오픈 시간 L_i, 마감 시간 R_i, 시간당 픽업 한도 M_i가 쉼표를 두고 주어집니다. 이는 N_i번 스토어에 대한 정보들을 나타냅니다.

다음 S개의 줄에 걸쳐, j번째 줄에 스토어 ID N_j와 상품별 재고 정보가 쉼표를 두고 주어집니다. 상품별 재고 정보의 경우, 상품 ID와 수량이 콜론(:)을 두고 주어집니다. 이때, N_j번 스토어에 재고가 존재하지 않으면, 상품 ID와 콜론, 수량 대신 하이픈(-)기호 하나만 주어집니다.

다음 R개의 줄에 걸쳐, k번째 줄에 요청 ID P_k, 스토어 ID N_k, 상품 ID X_k, 수량 A_k, 희망 시간 T_k가 쉼표를 두고 주어집니다.

제약 조건

1 <= S <= 5
1 <= R <= 200
1 <= N_i <= S
주어지는 N_i의 값은 모두 다릅니다.
0 <= L_i < R_i <= 24
1 <= M_i <= 10
1 <= N_j <= S
주어지는 N_j의 값은 모두 다릅니다.
하나의 스토어에 존재하는 재고 정보는 5개 이하입니다.
상품별 재고 정보가 주어질 때, 상품 ID는 A001, A002, A003, A004, A005 중 하나이며, 수량은 1 이상 100 이하의 정수입니다.
1 <= P_k <= R
1 <= N_k <= 100
X_k는 A001, A002, A003, A004, A005 중 하나입니다.
1 <= A_k <= 10
T_k는 HH:MM의 형식이며, 00:00부터 23:59 사이의 올바른 시간 형식으로 주어집니다.
입력으로 주어지는 모든 수는 정수입니다.

출력 형식

주어진 Q개의 픽업 예약 요청에 대한 결과를 한 줄에 하나씩 입력 순서대로 출력해야 합니다. 만약 픽업 예약 요청이 성공한 경우, 요청 ID와 OK를 쉼표를 두고 출력하며, 실패한 경우 요청 ID와 FAIL, 실패 사유를 쉼표를 두고 출력합니다.

이때 각각의 실패 사유에 따라 출력해야 하는 문자열은 다음과 같으며, 실패 사유가 여러가지인 경우 우선순위가 가장 높은 실패 사유만 출력합니다.

우선순위	사유	설명
1	STORE	존재하지 않는 스토어
2	TIME	운영 시간 외
3	FULL	해당 시간대 픽업 한도 초과
4	STOCK	재고 부족

이후, Q+1번째 줄에 총 예약 성공 건수를 출력합니다.

예제 설명

첫 번째 예제에서, 입력으로 주어진 스토어들의 정보는 다음과 같습니다.

스토어 1) 오픈 시간: 10시, 마감 시간: 20시, 시간당 픽업 한도: 3건, 재고 A001: 10개, A002: 5개
스토어 2) 오픈 시간: 11시, 마감 시간: 21시, 시간당 픽업 한도: 2건, 재고 A001: 8개, A003: 3개

이후 픽업 요청 처리 과정은 다음과 같습니다.

요청 ID	스토어 ID	상품 ID	수량	희망 시간	성공 여부	사유
1	1	A001	2	10:30	OK	10시대 픽업 한도 0/3 → 1/3, 재고 10 → 8
2	1	A001	3	10:00	OK	10시대 픽업 한도 1/3 → 2/3, 재고 8 → 5
3	1	A001	6	10:45	FAIL	STOCK (재고 5 < 요청 6)
4	1	A002	2	09:30	FAIL	TIME (09:30 < 10:00)
5	2	A001	5	15:00	OK	15시대 픽업 한도 0/2 → 1/2, 재고 8 → 3
6	2	A003	5	20:30	FAIL	STOCK (재고 3 < 요청 5)
7	3	A001	1	12:00	FAIL	STORE (스토어 3 없음)

입/출력 예시

예시 1

입력

2,7
1,10,20,3
2,11,21,2
1,A001:10,A002:5
2,A001:8,A003:3
1,1,A001,2,10:30
2,1,A001,3,10:00
3,1,A001,6,10:45
4,1,A002,2,09:30
5,2,A001,5,15:00
6,2,A003,5,20:30
7,3,A001,1,12:00

출력

1,OK
2,OK
3,FAIL,STOCK
4,FAIL,TIME
5,OK
6,FAIL,STOCK
7,FAIL,STORE
3

예시 2

입력

1,1
1,10,20,5
1,A001:10
1,1,A001,2,14:30

출력

1,OK
1

예시 3

입력

3,8
1,10,20,3
2,11,21,2
3,09,18,5
1,A001:10,A002:5
2,A001:8
3,-
1,1,A001,2,14:00
2,2,A001,3,15:00
3,3,A001,1,12:00
4,1,A002,2,14:30
5,2,A001,6,16:00
6,1,A001,5,14:45
7,3,A002,1,10:00
8,2,A002,1,20:00

출력

1,OK
2,OK
3,FAIL,STOCK
4,OK
5,FAIL,STOCK
6,OK
7,FAIL,STOCK
8,FAIL,STOCK
4

문제 요약

S개 스토어의 운영시간/시간당 픽업 한도/상품별 재고를 관리하며, R개의 예약 요청을 순서대로 처리한다.

예약 성공 시 재고가 차감되고 해당 시간대 예약 수가 증가해서, 이후 요청의 결과에 영향을 준다.

1번과의 핵심 차이는 상태의 유무다.

1번 (Stateless)                       2번 (Stateful)
─────────────────────────             ─────────────────────────
고객 A 판정 → 결과                     요청 1 처리 → 재고 차감, 예약 수 증가
고객 B 판정 → 결과  (A와 무관)          요청 2 처리 → 변경된 재고로 판정
고객 C 판정 → 결과  (A,B와 무관)        요청 3 처리 → 또 변경된 재고로 판정

검증 우선순위

실패 사유가 여러 개일 때 우선순위가 가장 높은 것만 출력한다.

우선순위	사유	설명
1	STORE	존재하지 않는 스토어
2	TIME	운영 시간 외
3	FULL	해당 시간대 픽업 한도 초과
4	STOCK	재고 부족

이 순서가 중요한 이유가 있다. 스토어 존재 여부를 먼저 체크하지 않으면, 없는 스토어의 운영시간을 조회하다 KeyError가 발생한다. 우선순위 순서는 정확성과 안전성을 동시에 보장하는 설계다.

전체 코드 (문제 공개 후 다시 푼 버전)

시험 당시에는 10분 만에 미완성으로 제출했지만,

이후 문제가 공식 공개된 뒤 3차 최종 면접을 대비하면서 처음부터 다시 풀었다.

import sys


def main():
    input = sys.stdin.readline

    S, R = map(int, input().strip().split(","))

    stores = {}

    for _ in range(S):
        parts = input().strip().split(",")
        sid = parts[0]
        stores[sid] = {
            "open": int(parts[1]),
            "close": int(parts[2]),
            "limit": int(parts[3]),
            "stock": {},
            "reserved": {},
        }

    for _ in range(S):
        parts = input().strip().split(",")
        sid = parts[0]
        for item in parts[1:]:
            if item == "-":
                continue
            pid, qty = item.split(":")
            stores[sid]["stock"][pid] = int(qty)

    success = 0
    results = []

    for _ in range(R):
        parts = input().strip().split(",")
        rid = parts[0]
        sid = parts[1]
        pid = parts[2]
        qty = int(parts[3])
        time_str = parts[4]
        hour, minute = map(int, time_str.split(":"))
        total_minutes = hour * 60 + minute

        if sid not in stores:
            results.append(f"{rid},FAIL,STORE")
            continue

        store = stores[sid]

        if not (store["open"] * 60 <= total_minutes < store["close"] * 60):
            results.append(f"{rid},FAIL,TIME")
            continue

        cnt = store["reserved"].get(hour, 0)
        if cnt >= store["limit"]:
            results.append(f"{rid},FAIL,FULL")
            continue

        if pid not in store["stock"] or store["stock"][pid] < qty:
            results.append(f"{rid},FAIL,STOCK")
            continue

        store["stock"][pid] -= qty
        store["reserved"][hour] = cnt + 1
        success += 1
        results.append(f"{rid},OK")

    results.append(str(success))
    print("\n".join(results))


if __name__ == "__main__":
    main()

실제 제출 코드의 버그 3가지

시험장에서 제출한 코드는 세 가지 버그가 있었다.

버그 1: 하이픈(-) 미처리

for item in parts[1:]:
    pid, qty = item.split(":")  # "-".split(":") → ["-"] → 언패킹 실패

문제에서 "재고가 없으면 하이픈(-) 하나만 주어진다"고 명시했는데, 이 예외를 처리하지 못했다.

if item == "-": continue 한 줄이면 해결되는 문제였다.

입력 파싱 단계에서 예외 케이스를 먼저 체크하지 않은 결과다.

버그 2: FULL을 TIME으로 출력

if cnt >= store["limit"]:
    print(f"{rid},FAIL,TIME")  # TIME이 아니라 FULL이어야 함

"시간당 한도 초과"를 직관적으로 "시간 관련 실패"로 분류했다.

하지만 문제 출력 명세에는 FULL이라는 별도 사유가 정의되어 있었다.

구현에 들어가기 전에 출력 형식 표를 끝까지 읽지 않은 것이 원인이었다.

버그 3: 운영시간 비교 정밀도

if not (store["open"] <= hour < store["close"]):  # hour 단위만 비교

문제에서 "오픈 시간 10:00 이상, 마감 시간 20:00 미만"이라고 정확히 명시했다.

분 단위를 포함한 비교가 필요하다. hour * 60 + minute으로 변환해 open * 60 <= total_minutes < close * 60으로 비교해야 경계값을 정확히 처리할 수 있다.

되짚어보기

시간 배분

문제	실제 배분	내용
1번	50분	문제 분석 20분 + 구현 10분 + 컴파일 오류/오타 수정 20분
2번	10분	문제를 제대로 읽지도 못하고 미완성 제출

1번에서 50분을 다 써버렸다. 구현 자체는 10분이면 됐는데, 컴파일 오류를 잡고 오타를 수정하는 데 20분이 날아갔다. 그 결과 2번은 문제를 제대로 읽지도 못한 채로 시간이 끝났고, 완성하지 못한 코드를 그냥 제출했다.

냉정하게 보면, 1번의 디버깅 시간을 절반만 줄였어도 2번에서 최소한 하이픈 처리와 FULL/TIME 구분 정도는 잡아낼 수 있었다. 예제가 통과하면 더 이상 들여다보지 말고 넘어가는 결단이 필요한 순간이었다.

핵심 교훈 3가지

1. 문제를 끝까지 읽고, 출력 형식부터 정리한 뒤 구현에 들어갈 것.

출력 명세에 있는 실패 사유 표(STORE/TIME/FULL/STOCK)를 먼저 읽었다면 FULL과 TIME을 혼동하지 않았을 것이다. 구현에 급하게 달려드는 습관이 이런 실수를 만든다.

2. 입력 파싱 단계에서 예외 케이스를 먼저 식별할 것.

"하이픈이 올 수 있다"는 문장을 읽었지만, 파싱 코드를 짤 때 이미 머릿속에서 날아간 상태였다.

입력 형식을 읽을 때 예외 케이스(하이픈, 빈 값, 특수 구분자)를 체크리스트로 따로 적어두는 습관이 필요하다.

3. 예제가 모두 통과하면 과도한 디버깅 대신 다음 문제로 넘어갈 것.

예제 통과 = 기본 로직 검증 완료다. 더 이상 코드를 들여다보는 것은 시간 낭비다. 결단이 필요한 순간이다.

그래서 결과는

2문제 중 1솔. 2번은 거의 손도 못 댄 채로 제출했으니 크게 기대하지 않았다.

사실 기대라기보다는 그냥 접었다.

그런데... 합격 메일이 왔다.

MUSINSA ROOKIE AI NATIVE ENGINEER (6개월 전환형) 포지션의 1차 코딩 테스트 전형을 통과하신 것을 진심으로 축하드립니다!

2차 코딩 테스트는 GitHub와 AI Agent를 활용하여 진행됩니다.

AI 도구 없이 기초를 검증하는 1차, AI와 협업 능력을 보는 2차.

무신사가 AI Native 엔지니어에게 원하는 것이 무엇인지 전형 구조 자체에서 읽힌다.

2차 코딩테스트 회고는 다음 글에서 이어진다.