CodeChronicle

About

CodeChronicle — Mon, 28 Sep 2026 17:48:04 +0900

백엔드 개발자 정석환입니다.

Java와 Spring Boot로 서비스를 만듭니다. 기획 단계부터 함께 고민하고, 직접 배포하고 모니터링하는 데까지 책임지는 개발을 지향합니다. 이 블로그에는 그 과정의 설계 판단과 시행착오를 기록합니다.

GitHub jsh36580@gmail.com solved.ac

Tech Stack

Backend

JavaSpring BootSpring SecurityJPAPython

Database

MySQLPostgreSQLRedisFlyway

Infra

AWS EC2S3DockerCaddyGitHub Actions

Monitoring

PrometheusGrafanaActuatorMicrometer

OpenAI APIRAGClaude Code

Projects

2025.06 – 2026.05
팀 Refresh
기획 · Server · AI

Acci

인천대학교 2026 컴퓨터공학부 졸업작품회 대상

교통사고 영상을 AI가 분석해 과실비율, 분석 근거, 관련 판례를 제공하는 분쟁 심의 지원 플랫폼

RAG 기반 판례 검색과 OpenAI Vision API 기반 수리비 견적 기능 구현
EC2 · Docker · Caddy · GitHub Actions 배포, Prometheus · Grafana 모니터링

Spring Boot · MySQL · VectorDB · AWS S3

GitHub 수리비 견적 서비스 구현기

2026.06 –
Server

Gravit!

개념 노트로 익히고, 문제로 확인하고, 면접 시뮬레이션으로 체화하는 하루 10분 CS 학습 플랫폼

Spring Security · OAuth2.0 · JWT 인증, FCM · Spring Mail 알림
Actuator · Micrometer · Prometheus 모니터링
Claude Code 기반 Harness Engineering 개발 워크플로우 적용

Spring Boot · PostgreSQL · Flyway · Redis

GitHub Harness Engineering

2025.06 – 2026.08
INU AppCenter
PM · Server

UniClub

동아리를 찾고, 소통하고, 참여할 수 있는 인천대학교 공식 중앙동아리 통합 플랫폼

Oracle 연동 교내 로그인 인증, FCM 푸시 알림
GitHub Actions · Docker · Caddy 배포

Spring Boot · MySQL · AWS S3

GitHub

Activities & Education

2024.06 –

INU AppCenter Server 파트

스터디

Effective Java 스터디

2021.03 – 2027.02

인천대학교 컴퓨터공학부 (졸업 예정)

자격

SQLD, 정보처리기사 필기 합격

Harness Engineering: 모델이 아니라 '환경'을 설계한다는 것

CodeChronicle — Thu, 30 Jul 2026 17:59:58 +0900

Harness Engineering: 모델이 아니라 '환경'을 설계한다는 것

AI 에이전트에게 "이걸 만들어줘"라고 던져놓고 기다려본 적이 있다면, 아마 비슷한 경험이 있을 것이다.

처음 20분은 그럴듯하다. 그런데 시간이 지날수록 어긋나는 부분들이 눈에 보이기 시작한다.

부족한 부분들이 눈에 보이는 상황에서 "완료됐습니다"라며 대충 넘어간다.

많은 개발자들은 모델을 탓한다. "프롬프트를 더 자세하게 작성해야 해", "컨텍스트 윈도우가 너무 작아".

물론 틀린 말은 아니다. 명확하고 자세한 프롬프트와 큰 컨텍스트 윈도우는 사용자가 원하는 결과를 도출하는데 도움이 된다.

다만 현시점 업계가 도달한 결론은 "모델 그 자체가 아닌, 모델을 둘러싼 환경 설계"에 문제가 있다는 것이다.

이 환경 설계를 가리키는 이름이 "Harness Engineering"이다.

What is Harness?

하네스는 "등산이나 패러글라이딩에서 몸을 고정하는 안전벨트" 따위를 의미한다.

AI Agent 맥락에서 모델이 "등반자"라면, Harness는 해당 등반자가 어떤 도구를 쓸 수 있는지, 어디서 정보를 얻는지, 자신의 판단을 어떻게 검증하는지, 언제 멈춰야 하는지를 정의하는 "장비" 전체이다.

모델 자체를 더 똑똑하게 만드는 것이 아니라, 모델이 안전하고 일관되게 오래 작업할 수 있도록 환경을 구축하는 일이다.

이걸 이해하기 위해 AI 활용의 3단계를 늘어놓아 보자.

Prompt Engineering: 한 번의 대화, 한 번의 출력을 최적화한다. 문구를 다듬고, 예시를 넣고, 구조를 잡는다.
Context Engineering: 모델이 한 번에 보는 정보의 양과 구성을 관리한다. 어떤 문서를 검색해서 넣을지, 히스토리를 어떻게 압축할지, 컨텍스트 윈도우 안에 무엇을 남기고 무엇을 버릴지 선택한다.
Harness Engineering: Agent가 감독 없이 몇 시간 동안 자율적으로 수백 번의 판단을 내리며 동작하는 전체 실행 환경을 설계한다. 도구, 지식, 검증 로직, 아키텍처 제약까지 에이전트가 안정적으로 돌아가는지 여부를 결정하는 모든 것을 포함한다.

프롬프트 엔지니어링과 컨텍스트 엔지니어링은 "한 번에 어떤 결과물을 보여주는가"에 관한 것이다.

하네스 엔지니어링은 이와 달리 "이 시스템이 장기간 자율적으로 돌아가도 문제가 생기지 않으려면 무엇이 필요한가"에 관한 것이다.

용어의 유래

2026년 2월, HashiCorp를 설립하고 Terraform을 공동 개발한 Mitchell Hashimoto가 자신의 AI 활용 습관을 블로그에 공유했다. 에이전트가 실수를 할 때마다, 그 실수를 다시 반복하지 않도록 에이전트의 환경에 영구적인 수정을 심어 넣는다는 습관이었다. 그는 이를 "하네스를 엔지니어링 한다"라고 표현했다.

며칠 지나지 않아 OpenAI가 비슷한 개념을 공식 엔지니어링 블로그에서 정리했고, Anthropic 역시 자체 사례를 담은 글을 냈다. 흥미로운 사실로, 프로덕션 환경에서 AI 에이전트를 실제로 운영해 본 개발자들은 이름이 붙기도 전에 이미 비슷한 해법에 각자 도달해 있었다. 신뢰할 수 없는 모델 출력, 실서비스의 리스크, 휘발되는 컨텍스트에 부딪히며 같은 형태의 구조로 수렴한 것이다.

https://mitchellh.com/writing/my-ai-adoption-journey

My AI Adoption Journey

Table of Contents My experience adopting any meaningful tool is that I've necessarily gone through three phases: (1) a period of inefficiency (2) a period of adequacy, then finally (3) a period of workflow and life-altering discovery. In most cases, I have

mitchellh.com

Anthropic의 실제 구축 사례

이 개념을 가장 구체적으로 보여주는 자료는 Anthropic Labs의 Prithvi Rajasekaran이 2026년 3월에 공개한 엔지니어링 글이다.

프론트엔드 디자인 품질 개선과 장시간 자율 코딩이라는 두 문제를 동시에 다룬다.

해당 사례를 통해 하네스가 왜 필요하고, 어떻게 설계되는지를 간접적으로 바라볼 수 있다.

https://www.anthropic.com/engineering/harness-design-long-running-apps

Harness design for long-running application development

Anthropic is an AI safety and research company that's working to build reliable, interpretable, and steerable AI systems.

www.anthropic.com

단순한 방식이 무너지는 두 가지 이유

에이전트 하나에게 스펙을 주고 끝까지 밀어붙이는 방식은 두 가지 지점에서 반복적으로 무너진다.

첫째, 컨텍스트 불안(context anxiety)이다.

작업이 길어질수록 컨텍스트 윈도우가 채워지고, 한계에 가까워지고 있다고 느끼면 작업을 서둘러 마무리하려는 경향을 보인다.

대화 히스토리를 요약해서 압축하는 방식만으로는 이 불안감이 완전히 사라지지 않았다.

해법은 압축이 아닌, 컨텍스트 리셋이었다.

컨텍스트를 완전히 비우고 새 에이전트를 시작하되, 이전 상태와 다음에 할 일을 구조화된 형태로 정리한 인계 자료를 함께 넘기는 방식이다.

물론, 이 방식은 토큰 비용과 지연 시간을 야기한다.

둘째, 자기평가 편향이다.

에이전트에게 자신이 만든 결과물을 평가하라고 시키면, 사람이 보기에 볼품없더라도 자신 있게 좋은 작업물이라고 평가하는 경향이 있다.

이 문제는 디자인처럼 정답이 없는 주관적인 작업에서 특히 두드러지만, 검증 가능한 결과물이 있는 작업에서도 판단력이 흐려지는 현상은 마찬가지로 나타났다.

그래서 찾아낸 방법은 작업하는 에이전트와 평가하는 에이전트를 분리하는 것이었다.

이것만으로 관대함이 완전히 사라지지 않지만 별도의 평가자를 회의적으로 조율하는 것이, 생성자 스스로를 자기비판적으로 만드는 것보다 쉬웠다.

이와 더불어, 외부 피드백이 존재하는 순간, 생성자는 구체적으로 개선할 대상을 갖게 된다.

3개의 에이전트로 이루어진 구조: Planner -> Generator -> Evaluator

이 두 문제를 풀기 위해 도달한 구조는 GAN(생성적 적대 신경망)에서 영감을 받은 생성자-평가자 구도를 SW개발 생명주기 전체로 확장한 형태이다.

Planner(기획자): 한두 문장의 요청을 받아 완전한 제품 스펙으로 확장한다. 세부 기술 구현보다는 상위 수준의 기술 설계에 집중하도록 제한한다. 이는 기획 단계에서 세밀한 기술 결정을 잘못 내리면 그 오류가 이후 구현 전체로 퍼지기 때문이다.
Generator(생성자): 스펙을 스프린트 단위로 쪼개 한 번에 기능 하나씩 구현한다. 각 스프린트가 끝나면 스스로 점검한 뒤 QA로 넘긴다.
Evaluator(평가자): 실행 중인 애플리케이션을 MCP로 직접 조작하며 검증한다. 실제 사용자처럼 클릭, 입력하고 API와 DB 상태를 점검한다. 제품 완성도, 기능성, 디자인, 코드 품질에 대해 각각 기준선을 두고, 하나라도 미달하면 해당 스프린트는 실패 처리되어 생성자에게 구체적인 피드백이 돌아간다.

여기에 더해진 장치가 스프린트 계약(sprint contract)이다.

각 스프린트가 시작되기 전, 생성자와 평가자가 "이번 작업에서의 완료"에 대해 합의한다.

스펙이 의도적으로 상위 수준으로만 작성되기 때문에, 간극을 좁히는 절차가 필요하다.

생성자가 무엇을, 어떻게 검증지 제안하면 평가자가 검토하고, 두 에이전트가 합의에 이를 때까지 조율한다.

이 모든 소통은 파일을 통해 이루어진다.

하네스는 고정된 답이 아니다

해당 구조에서 가장 중요한 것은 완성된 아키텍처 자체가 아니다.

만약 더 강력한 상위 모델이 나온다면, 스프린트 구조를 완전히 제거해도 모델 스스로 일관되게 작업을 이어나갈 수 있다.

평가자의 역할도 상황에 따라 달라진다.

모델의 한계에 걸쳐 있는 작업에서는 평가자가 여전히 실질적인 도움을 줄 수 있다.

하지만 모델이 혼자서도 잘 처리하는 범위의 작업에서 평가자가 개입한다면, 불필요한 오버헤드가 된다.

하네스의 모든 구성 요소는 "모델이 이걸 혼자 못한다"는 가정을 내포하고 있으며, 그 가정은 틀렸을 수도 있고 모델이 발전하면서 낡은 구성이 되었을 수도 있다.

결과적으로 새 모델이 나올 때마다 하네스를 점검하고, 더 이상 필요 없는 구성을 걷어내는 과정이 필요하다.

이는 Anthropic이 이전에 낸 "Building Effective Agents"글에서 이미 강조했던 원칙, "가능한 가장 단순한 해법을 찾고, 필요할 때만 복잡성을 더하라"와 같은 맥락이다.

실제로 하네스를 구축하는 과정

어떤 게 "정답"이라고 할 수는 없지만, 하네스를 구축해 본 여러 사람들의 의견을 종합하면 다음과 같은 구축과정을 거친다.

1단계 - 실패의 과정을 관찰한다

바로 구조를 설계하지 말고, 가장 단순한 형태(에이전트 하나, 최소한의 프롬프트)로 먼저 돌려본다.

그리고 그 결과물이 정확히 어디서, 어떻게 무너지는지 로그와 결과물을 살펴본다.

"컨텍스트가 길어지면 서두른다", "자기 결과물을 과대평가한다", "특정 종류의 버그를 놓친다"처럼 구체적인 패턴을 찾는 것이 다음 설계의 근거가 된다.

2단계 - 작업을 다룰 수 있는 단위로 쪼갠다.

전체 작업을 통째로 맡기지 말고 기능 단위, 스프린트 단위로 분리한다.

이때 상위 수준의 스펙과 하위 수준의 구현 디테일을 분리해서, 기획 단계의 실수가 구현 전체로 전파되지 않도록 한다.

3단계 - 생성과 검증을 분리한다.

같은 에이전트에게 생성과 평가까지 맡기지 않는다.

별도의 평가 에이전트를 두고, "이게 좋은가?"처럼 막연한 질문 대신 "이 원칙을 지켰는가?"처럼 구체적이고 채점 가능한 기준을 준다.

가능하다면 평가자에게는 실제로 결과물을 조작해 볼 수 있는 도구(브라우저 자동화 등)를 주고 정적으로 보기만 하는 것이 아니라, 실제로 사용해 보며 검증할 수 있도록 한다.

4단계 - 상태를 대화가 아닌 외부 아티팩트에 남긴다.

컨텍스트 윈도우 안의 대화 기록에만 의존하면 세션이 바뀌거나 리셋될 때 상태가 사라진다.

작업 목록, 진행 상황, 합의된 완료 기준 같은 것들을 파일이나 DB처럼 영속적인 형태로 남기고, 다음 세션의 에이전트가 이를 읽고 이어받을 수 있게 한다.

5단계 - 완료의 기준을 미리 합의한다.

코드를 쓰기 전에 "무엇이 완료인가"를 구체적인 테스트 가능한 형태로 먼저 정의한다.

이렇게 하면 상위 수준 스펙과 실제 구현 사이의 간극에서 발생하는 임의성을 줄일 수 있다.

6단계 - 컨텍스트 관리 전략을 정한다.

컨텍스트가 길어질 때 압축으로 충분한지, 아니면 완전한 리셋이 필요한지는 사용하는 모델에 따라 다르다.

모델이 컨텍스트 불안을 강하게 보인다면 리셋이 필요하고, 그렇지 않다면 압축만으로 충분하다.

7단계 - 도구와 권한 범위를 최소한으로 설계한다.

에이전트가 접근할 수 있는 도구, 파일 시스템, 실행 권한을 필요한 범위로 제한한다.

이는 안전성뿐만 아니라 에이전트가 불필요한 선택지 사이에서 헤매지 않도록 하는 효과도 있다.

8단계 - 모델이 바뀔 때마다 하네스를 재검토한다.

새 모델이 나오면 구성 요소를 하나씩 제거해 가며 무엇이 여전히 필요하고 무엇이 불필요한 오버헤드인지 확인한다.

실전 메커니즘: CLAUDE.md, Hook, Skill, Sub-agent

앞서 정리한 8단계가 설계 원칙이라면, 이제부터는 그 원칙을 실제 코드로 어떻게 구현하는지를 알아볼 차례이다.

Claude Code를 기준으로 보면, 하네스는 추상적인 개념이 아니라 .claude/ 디렉터리 아래에 실제로 존재하는 파일들의 집합이다.

Anthropic이 공개한 예제 저장소 anthropics/cwc-long-running-agents 는 이 primitive들을 짧고 읽기 쉬운 형태로 보여준다.

CLAUDE.md

CLAUDE.md는 에이전트가 세션을 시작할 때마다 읽는 프로젝트 규칙 파일이다.

cwc-long-running-agents의 CLAUDE.md는 다음과 같은 규칙을 담고 있다.

# Long-running conventions for this project

## Always start here
다른 무엇보다 먼저 PROGRESS.md를 읽는다. 이전 세션이 남긴 인계 노트다.
없으면 Done / In progress / Next / Notes 네 섹션으로 새로 만든다.
그다음 git log --oneline -10으로 방금 커밋된 내용을 확인하고,
빌드/테스트를 한 번 돌려 "정상 작동하는 상태"에서 시작하는지 확인한다.

## One feature at a time
세션당 PROGRESS.md의 항목 하나만 작업한다.
테스트 통과 + 스크린샷 검증까지 끝내고서야 다음 항목으로 넘어간다.

## Proof before passing
"통과"로 인정되려면: 1) 실제 앱에 대해 테스트를 실행하고
2) 그 결과(스크린샷/콘솔 로그)를 Read 도구로 직접 열어보고
3) 기대한 내용이 맞는지 확인해야 한다.
verify-gate 훅이 이 증거 없이는 test-results.json 수정을 막는다.

## Keep PROGRESS.md current
항목을 끝낼 때마다 완료 표시, 배운 점, 다음 할 일을 갱신한다.

## If you're told to stop
"OPERATOR STEERING:" 메시지는 사람이 직접 개입한 것이므로
현재 계획보다 우선순위가 높다.

여기서 중요한 건, CLAUDE.md가 단순히 안내문이 아니라 뒤에 나올 훅(hook)과 짝을 이루는 절반짜리 규칙이라는 점이다.

"명확한 증거 없이는 통과시키지 마라"는 규칙은 말로만 존재하지 않는다.

실제로 그 규칙을 어기면 훅이 물리적으로 쓰기 작업을 막는다.

Hook - 말로 하는 부탁이 아닌 구조적으로 막는 장치

이 저장소에서 가장 실무적인 통찰은 이 한 줄에 담겨 있다.

에이전트는 UI가 명백히 깨져있어도 단위 테스트나 curl 명령 하나만 통과하면 통과라고 표시해 버리는 경향이 있고, 프롬프트에 "제발 정직하게 확인해 줘"라고 아무리 부탁해도 이 문제는 잘 해결되지 않는다.

그래서 하네스는 "완료"라는 개념 자체를 구조적으로 만든다.

실제 구현은 test-results.json이라는 파일에 모든 기능을 기본값 false로 두는 것에서 시작한다.

{ "feature-1": { "passes": false }, "feature-2": { "passes": false } }

그리고 PreToolUse 훅이 이 파일에 대한 쓰기 요청을 가로챈다.

Claude Code 훅은 표준입출력으로 JSON을 주고받는 단순한 Shell 스크립트인데, 실제 코드는 이렇게 생겼다.

( Anthropic, Apache-2.0)

#!/usr/bin/env bash
# Denies any Write/Edit to the results file unless the agent has opened at least
# one evidence file (screenshot/console log) since the gate last fired.

log="${VERIFY_READ_LOG:-./.claude/.evidence-reads}"
results="${RESULTS_FILE:-test-results.json}"
input=$(cat)
target=$(printf '%s' "$input" | python3 -c 'import json,sys; print(json.load(sys.stdin).get("tool_input",{}).get("file_path",""))' 2>/dev/null)

case "$target" in "$results"|*/"$results") ;; *) exit 0 ;; esac

if [ ! -s "$log" ]; then
  cat <<'JSON'
{"decision":"block","reason":"Cannot modify the results file: no screenshot or console-log evidence has been Read this session. Open the evidence file with the Read tool first, then retry."}
JSON
  exit 0
fi

# consume the evidence so the next change needs fresh proof
: > "$log"

동작 원리는 단순하다.

에이전트가 test-results.json을 수정하려고 하면 훅이 가로채서, 이번 세션에서 스크린샷이나 콘솔 로그 같은 증거 파일을 Read 도구로 연 적이 있는지 확인한다.

없다면 {"decision":"block", ...}를 반환해 쓰기 자체를 거부한다.

있다면 그 증거 기록을 초기화해서, 다음 변경에는 또다시 새로운 증거가 필요하도록 만든다.

저장소 README도 이 훅이 "가르치기용 예제이지 보안 경계는 아니다"라고 명시하는데, sed나 jq로 파일을 직접 조작하면 우회 가능하고, 경로 매칭이 느슨하다는 한계를 스스로 밝히고 있다.

실무에 쓸 때는 이런 지점을 더 촘촘하게 막아야 한다는 뜻이다.

Sub-agent

3단계 아키텍처에서 다룬 Evaluator가 실제로는 별도의 컨텍스트 윈도우, 별도의 도구 권한을 가진 서브에이전트로 구현된다.

agents/evaluator.md 파일이 이를 정의한다

---
name: evaluator
description: 회의적인 2차 검토자. diff와 빌더가 남긴 증거를 읽고
  PASS 또는 NEEDS_WORK를 구체적인 근거와 함께 반환한다.
  Write/Edit 도구는 주지 않는다.
tools: Read, Glob, Grep, Bash
---

당신은 별도의 빌더 에이전트가 "완료했다"고 주장한 작업을 검토하는 중이다.
그 작업이 어떻게 만들어졌는지 보지 못했고, 빌더 스스로의 평가도 신뢰하지 않는다.

매번 다음을 수행한다:
1. 이 기능에 대한 스펙/인수 기준을 읽는다.
2. git diff로 실제로 무엇이 바뀌었는지 확인한다.
3. screenshots/ 아래의 스크린샷·콘솔 로그를 실제로 열어서
   "파일명이 암시하는 내용"이 아니라 "실제로 보여주는 내용"을 확인한다.
   파일이 열리지 않으면 증거 없음으로 간주한다.
4. 판단한다.

그럴듯해 보이는 것과 실제로 맞는 것은 다르다. diff는 합리적으로 보이는데
스크린샷은 레이아웃이 깨져 있다면 NEEDS_WORK다. 어떤 인수 기준이든
증거가 없다면 NEEDS_WORK다. "아마 작동할 것"이라고 가정하고 있다면,
멈추고 증거를 찾아라.

답변 첫 줄은 반드시 PASS 또는 NEEDS_WORK 단독으로 시작한다(래퍼 스크립트가
이 줄만 읽고 판단하기 때문). Bash는 git diff/log, ls, cat 용도로만 쓰고,
직접 고치거나 실행해보겠다고 제안하지 않는다.

여기서 핵심 설계 포인트 세 가지를 알 수 있다.

Write/Edit 도구를 아예 주지 않는다. 검사관이 직접 고칠 수 있으면, "고치면서 대충 넘어가는" 유혹이 생긴다.
도구 권한 자체를 좁혀서 역할을 강제한다.
그럴듯함(plausibility)과 정확함(correctness)을 명시적으로 구분하도록 프롬프트에 못 박는다.
이건 앞서 다룬 자기 평가 편향을 다른 각도에서 막는 장치다.
응답 형식을 기계가 파싱하기 쉽게 강제한다(PASS/NEEDS_WORK를 첫 줄에).
사람이 읽기 좋은 문장이 아니라, 래퍼 스크립트가 자동으로 다음 행동을 결정할 수 있는 형태로 설계되어 있다.

Skill

CLAUDE.md와 Skill을 헷갈릴 수 있는데, 역할이 다르다.

CLAUDE.md는 세션 시작 시 항상 읽히는 상시 규칙이고, Skill은 관련성이 있을 때만 로드되는 지식 패키지이다.

매 턴 컨텍스트를 차지하는 CLAUDE.md와 달리, Skill은 이름과 설명만 시스템 프롬프트에 미리 올라가 있다가, Claude가 관련이 있다고 판단할 때만 Skill을 읽는다.

구조는 폴더 하나 + SKILL.md(필수) + 선택적으로 scripts/, references/, assets/로 이뤄진다.

my-skill/
├── SKILL.md        # YAML 프런트매터 + 지침 본문
├── scripts/         # 실행 가능한 Python/Bash 스크립트
├── references/      # 필요할 때만 읽히는 문서
└── assets/          # 템플릿, 바이너리 리소스

SKILL.md는 다음과 같은 최소 형태를 갖는다.

---
name: api-conventions
description: 이 코드베이스의 API 설계 패턴. REST 엔드포인트를
  작성하거나 리뷰할 때 사용한다.
---

API 엔드포인트를 작성할 때:
- RESTful 네이밍 컨벤션을 따른다
- 성공 응답은 { data, meta } 형태로 감싼다
- 에러는 표준 에러 코드 테이블(references/error-codes.md)을 따른다

하네스 관점에서 Skill이 갖는 의미는 명확하다.

매번 필요하지 않은 절차적 지식(특정 프레임워크 관례, 사내 API 스펙, 디자인 원칙 같은 것)을 CLAUDE.md에 욱여넣어 매 턴 토큰을 태우는 대신, 필요한 순간에만 불러와 쓰는 구조로 분리하는 것이다.

총정리

모델은 상품이 아니라 엔진이다.

하네스 엔지니어링에 대한 비유가 하나 있다.

우리는 아무도 Postgres를 쓴다는 사실 자체를 자랑하지 않는다.

자랑하는 건 그 위에 짠 쿼리 최적화, 스키마 설계, 인덱스 전략이다.

데이터베이스 엔진 자체는 상품화된 재화에 가깝고, 실제 프로덕션 시스템을 가르는 건 그 위에 무엇을 설계했는가이다.

AI 에이전트도 마찬가지이다.

OpenAI Vision API를 활용한 수리비 견적 서비스 구현

CodeChronicle — Wed, 1 Jul 2026 01:40:11 +0900

OpenAI Vision API를 활용한 수리비 견적 서비스 구현

Acci 서비스를 개발하며, 사용자가 사고 이미지를 업로드하면 AI가 자동으로 수리비 견적을 산출해 주는 기능을 구현했다.

해당 서비스는 수리비 산정에 어려움을 겪는 초보 운전자를 타겟으로 구현되었다.

이 글에서는 OpenAI Vision API를 Spring Boot 서버에 연동하는 과정을 다룬다.

단순한 API호출 방법보다는, 실제 서비스에서 마주했던 설계과정과 프롬프트 엔지니어링 시행착오에 초점을 맞췄다.

Acci 수리비 견적 서비스 Flow
사용자가 차량 정보 + 손상 내역 + 사고 이미지를 입력하면, LLM이 각 부위별 수리 방법과 비용을 분석해 견적을 반환한다.

수리비 견적 서비스 코드 구조

코드를 보기 전에 전체 흐름을 먼저 파악해보자.

[클라이언트]
    │  차량 정보 + 손상 내역 + 이미지 파일
    ▼
[Spring 서버]
    │  1. 이미지 → S3 업로드 후 S3 Key 저장
    │  2. RepairEstimate 엔티티 생성 (PENDING 상태)
    │  3. 이벤트 발행 → 비동기 워커 실행
    ▼
[RepairEstimateWorkerService]
    │  4. S3 Key → 이미지 다운로드 → Base64 변환
    │  5. 프롬프트 생성 (RepairPromptBuilder)
    │  6. OpenAI Vision API 호출
    │  7. 응답 파싱 → RepairItem 저장
    │  8. COMPLETED 상태로 전환 + SSE로 클라이언트에 알림
    ▼
[클라이언트]
    SSE로 실시간 완료 수신

알아두어야 할 두 가지 포인트가 있다.

비동기 처리

LLM 호출에 수 초가 소요되기 때문에 요청 스레드에서 직접 처리하지 않는다.

@TransactionalEventListener(phase = AFTER_COMMIT)로 트랜잭션 커밋 이후 별도 스레드풀에서 실행한다.

SSE(Server-Sent Events)

클라이언트가 완료를 폴링 하는 구조가 아닌, 서버가 상태 변경을 실시간으로 푸시한다.

비동기/SSE 구현은 글의 후반부에서 다루고, 먼저 핵심인 API 연동과 프롬프트 설계부터 살펴보자.

OpenAI API 연동

초기 설정

WebClient webClient = WebClient.builder()
    .baseUrl("https://api.openai.com/v1")
    .defaultHeader("Authorization", "Bearer " + apiKey)
    .build();

API키는 환경변수로 주입받아 코드에 노출되지 않도록 하였다.

이미지 유무에 따른 메시지 분기

OpenAI Chat Completions API는 텍스트만 보낼 때와 이미지를 함께 보낼 때 메시지의 content 구조가 다르다.

텍스트만 있는 경우 단순 문자열이지만, 이미지가 포함되면 content가 배열 형태로 변경되어 텍스트와 이미지가 함께 들어간다.

Acci에서는 이미지가 선택 사항(최대 5장)이므로, 이미지 유무에 따라 메시지를 다르게 구성하는 분기 로직이 필요했다.

private OpenAiRequest.Message buildUserMessage(String userPrompt, List<ImageData> imagesData) {
    // 이미지 없으면 텍스트만
    if (imagesData == null || imagesData.isEmpty()) {
        return new OpenAiRequest.Message(USER_ROLE, userPrompt);
    }

    // 텍스트 + 이미지 배열
    List<OpenAiRequest.ContentPart> contentParts = new ArrayList<>();
    contentParts.add(OpenAiRequest.ContentPart.ofText(userPrompt));
    imagesData.forEach(imageData ->
        contentParts.add(OpenAiRequest.ContentPart.ofImage(imageData.base64(), imageData.mediaType())));

    return new OpenAiRequest.Message(USER_ROLE, contentParts);
}

이미지는 Base64로 인코딩해서 전달하는데, 이때 MIME 타입(image/jpeg, image/png 등)을 파일 확장자가 아니라 실제 시그니처로 동적 판별하도록 했다.

사용자가 확장자를 임의로 바꿔 업로드하는 케이스를 대비하기 위함이다.

에러 처리와 타임아웃

외부 API호출이기 때문에 실패 가능성을 항상 염두해야 한다.

webClient.post()
    .uri(CHAT_COMPLETIONS_URI)
    .contentType(MediaType.APPLICATION_JSON)
    .bodyValue(requestBody)
    .retrieve()
    .onStatus(
        status -> status.is4xxClientError() || status.is5xxServerError(),
        response -> response.bodyToMono(String.class)
            .flatMap(body -> {
                log.error("OpenAI API 호출 실패 - Status: {}, Body: {}", response.statusCode(), body);
                return Mono.error(new CustomException(ErrorCode.LLM_API_CALL_FAILED));
            })
    )
    .bodyToMono(String.class)
    .timeout(API_TIMEOUT)
    .block();

WebClient는 원래 Non-Blocking 방식이지만, 해당 호출은 이미 별도의 스레드풀에서 비동기로 실행되는 워커 내부에 있다.

즉, 메인 요청 스레드를 막는 게 아니라, 이미 격리된 워커 스레드 안에서 동기적으로 결과를 기다리는 구조라 block()를 사용했다.

프롬프트 설계

LLM이 매번 일관된 형식과 합리적인 가격으로 응답하게 만들기 위한 과정이다.

일관성 부재

초기 버전에서는 시스템 프롬프트에 "한국 시장 기준으로 적절한 수리비를 산출하라"는 방향의 자연어 지시만 줬다.

결과는 좋지 않았다.

같은 손상 내역임에도 호출할 때마다 견적이 크게 들쭉날쭉
가끔 비현실적인 금액(너무 낮거나 높음)
수리 방법 판단 기준이 매번 달라짐

구조화된 가이드라인

LLM에게 모든 판단을 맡기지 않고, 서버에서 정한 규칙과 가격 가이드라인을 시스템 프롬프트에 명시적으로 넣었다.

가이드라인은 현대자동차 공식 서비스 협력사 블루핸즈 공임과 부가정보를 참고했다.

시스템 프롬프트는 네 부분으로 구성된다.

1. 역할 정의      : "당신은 OO 차량 전문 수리비 견적 전문가입니다"
2. 강제 규칙      : 손상 심각도(severity) → 수리 방법(repair_method) 매핑 규칙
3. 가격 가이드라인 : 부위별/심각도별 가격 범위 참고표
4. 응답 포맷      : 반드시 따라야 할 JSON 스키마

이렇게 역할을 나눈 이유는, LLM이 완전히 자유롭게 추론하는 것도 아니고, 서버에서 결정론적으로 계산하는 것도 아닌 중간 지점을 추구했기 때문이다.

손상 부위가 다양하고 사용자 설명이 자연어로 들어오기 때문에 완전 서버 계산은 비현실적이지만, 가이드라인 없는 완전 자유 추론은 일관성이 없다.

때문에 정해진 가이드라인 안에서 LLM이 도메인 지식을 발휘하도록 절충했다.

+ 사소한 포인트

프롬프트 작성 시 유니코드 박스문자로 표를 그렸는데, 사람이 읽기에는 깔끔하지만 두 가지 문제가 있다.

1. 토큰 소모가 불필요하게 많다.

2. LLM이 표 구조를 정확히 파싱 하지 못하고 행이 밀리는 경우 발생

LLM 학습 데이터에 마크다운 표 형식이 압도적으로 많이 등장하기 때문에, 모델이 더 안정적으로 구조를 인식하는 것 같다.

결론: 마크다운 테이블을 쓰자.

응답파싱

LLM에 아무리 "JSON으로만 응답하라"라고 명시해도 응답 앞뒤에 ```같은 코드블록 마커나 불필요한 문장이 섞여 나오는 경우가 있다.

이걸 매번 정규식으로 걷어내는 건 불안정하다.

response_format으로 출력 강제하기

OpenAI API는 response_format을 json_object로 지정하면, 모델이 순수 JSON만 반환하도록 강제하는 옵션을 제공한다.

return OpenAiRequest.builder()
    .model(model)
    .messages(List.of(
        new OpenAiRequest.Message(SYSTEM_ROLE, systemMessage),
        userMessage
    ))
    .responseFormat(new OpenAiRequest.ResponseFormat(JSON_RESPONSE_TYPE)) // "json_object"
    .maxCompletionTokens(maxTokens)
    .build();

다음과 같이 형식을 강제하면 안정적으로 구동할 수 있다.

2단계 파싱구조

OpenAI 응답은 한 번에 원하는 데이터로 바로 주어지지 않는다.

응답 자체가 메타데이터를 감싸고 있고, 우리가 원하는 실제 콘텐츠는 그 안의 choices[0].message.content에 문자열 형태의 JSON으로 들어있다.

때문에 파싱은 두 단계를 거친다.

private RepairEstimateLlmResponse parseResponse(String responseString) {
    try {
        // 1단계: OpenAI 응답 전체 구조 파싱
        OpenAiResponse openAiResponse = objectMapper.readValue(responseString, OpenAiResponse.class);

        // choices[0].message.content 추출
        String content = openAiResponse.getChoices().stream()
            .findFirst()
            .map(OpenAiResponse.Choice::getMessage)
            .map(OpenAiResponse.Message::getContent)
            .filter(text -> !text.isBlank())
            .orElseThrow(() -> {
                log.error("OpenAI 응답에 content가 없습니다. Raw Response: {}", responseString);
                return new CustomException(ErrorCode.LLM_RESPONSE_PARSE_FAILED);
            });

        // 2단계: content(JSON 문자열)를 우리 도메인 DTO로 파싱
        return objectMapper.readValue(content, RepairEstimateLlmResponse.class);

    } catch (CustomException e) {
        throw e;
    } catch (Exception e) {
        log.error("LLM 응답 파싱 실패: {}", responseString, e);
        throw new CustomException(ErrorCode.LLM_RESPONSE_PARSE_FAILED);
    }
}

LLM응답은 정확하지 않을 수 있다.

즉, 드물게 content가 비어있거나 정의한 스키마와 다른 형태로 올 수 있다.

이런 경우 원본 응답을 그대로 로그에 남겨야 나중에 "왜 실패했는지"를 재현하고 디버깅할 수 있다.

이를 고려하여 실패를 가정하고 로깅을 하였다.

비동기 처리와 SSE를 통한 UX 개선

LLM 호출은 이미지가 여러 장 포함되면 수 초 이상 소요된다.

이걸 사용자 요청을 받는 스레드에서 동기로 처리하면, 클라이언트는 응답이 올 때까지 기다려야 한다.

UX도 나쁘고, 서버의 요청 처리 스레드도 오래 점유된다.

견적 생성과 LLM 호출을 분리

1. 요청 수신 시점: RepairEstimate를 PENDING 상태로 DB에 저장하고, 클라이언트에는 즉시 estimateId를 반환한다.

2. 별도 워커: 트랜잭션이 커밋된 이후, 백그라운드에서 LLM호출과 결과 저장을 처리한다.

여기서 한 가지 주의점이 있다.

단순히 @Async로 비동기 메서드를 만들어 호출하면, 트랜잭션이 아직 커밋되지 전에 워커가 먼저 실행될 수 있다.

워커가 DB에서 방금 생성한 RepairEstimate를 조회하려는데, 아직 커밋되지 않아 엔티티가 존재하지 않는 레이스 컨디션이 발생하는 것이다.

이를 막기 위해 @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)를 사용했다.

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void handleEstimateCreated(RepairEstimateCreatedEvent event) {
    repairEstimateExecutor.execute(() -> workerService.processEstimate(event.estimateId()));
}

다음과 같이 작성하면 이벤트 리스너는 트랜잭션이 정상적으로 커밋된 이후에만 실행되기 때문에, 워커가 DB를 조회하는 시점엔 데이터가 확실히 존재한다.

이 리스너 안에서 별도 전용 스레드풀에 작업을 위임해서, 무거운 LLM호출이 다른 요청 처리에 영향을 주지 않도록 격리했다.

SSE로 클라이언트에 결과 전달

워커가 백그라운드에서 처리되는 동안, 클라이언트는 진행 상태를 알아야 한다.

처음 구현시에는 기능구현을 위해 타협하고 일정주기로 polling 하는 방식으로 임시 구현했다.

이후 Server-Sent Events 즉, SSE를 통해 불필요한 요청을 막고 실시간성을 확보했다.

@Transactional
public void processEstimate(UUID estimateId) {
    RepairEstimate estimate = getEstimateById(estimateId);

    estimate.startProcessing();
    estimateRepository.flush();
    sseService.sendStatus(estimate);  // PROCESSING 상태 전송

    // ... LLM 호출, 결과 저장 ...

    estimate.completeEstimate(totalCost);  // COMPLETED 상태로 전환
}

SSE로는 상태(PENDING / PROCESSING / COMPLETED / FAILED)만 전송하고, 실제 견적 데이터는 보내지 않는다.

클라이언트는 COMPLETE 상태를 받으면 그때 기존에 있던 GET 엔드포인트를 호출해서 전체 결과를 가져온다.

SSE 채널 하나에 모든 데이터를 보내는 대신 "상태 알림"과 "데이터 조회"의 책임을 분리한 것이다.

실제 시연

https://www.youtube.com/watch?v=2NB8CYw9FB0

Strategy Pattern을 통한 OAuth2.0 다중 제공자 구조 설계

CodeChronicle — Mon, 22 Jun 2026 18:40:14 +0900

Strategy Pattern을 통한 OAuth2.0 다중 제공자 구조 설계

Strategy Pattern은 동일한 목적을 가진 알고리즘들을 각각의 독립된 클래스로 캡슐화하고, 런타임에 교체할 수 있도록 하는 설계 패턴이다.

같은 인터페이스를 구현하지만 내부 동작이 다른 경우, 그 종류가 확장될 가능성이 있는 경우 적합하다.

OAuth 다중 제공자 구조 설계에 적절한 디자인 패턴임을 알 수 있다.

문제 상황

각 OAuth 제공자마다 반환하는 사용자 정보의 JSON 구조는 전부 다르다.

// 제공자별 응답 구조가 전부 다르다
// Google: attributes.get("sub"), attributes.get("name")
// Kakao:  attributes.get("kakao_account") → profile → nickname
// Naver:  attributes.get("response") → name

Strategy Pattern을 사용하지 않고 분기 처리하는 경우의 코드는 다음과 같이 가정할 수 있다.

public OAuthAttributes createOAuthAttributes(String provider, Map<String, Object> attributes) {
    if (provider.equals("google")) {
        // Google 파싱 로직
    } else if (provider.equals("kakao")) {
        // Kakao 파싱 로직
    } else if (provider.equals("naver")) {
        // Naver 파싱 로직
    }
}

해당 코드는 새로운 제공자가 추가될 때마다 메서드를 직접 수정해야 한다.

또한 기존 코드를 건드릴수록 사이드 이펙트를 고려해야 하는 불편함이 발생한다.

Strategy Pattern 적용

Strategy 패턴의 구성요소는 세 가지로 나눌 수 있다.

공통 인터페이스를 정의하는 Strategy

인터페이스의 실제 구현체 ConcreteStrategy

전략을 주입받아 실행하는 객체 Context

호출부(Context)는 구체적인 구현을 몰라도 된다.

인터페이스에만 의존하기 때문에, 구현체가 변경돼도 호출부의 코드는 변하지 않는다.

OAuthResponseStrategy (interface)
├── GoogleOAuthResponseStrategy
├── KakaoOAuthResponseStrategy
└── NaverOAuthResponseStrategy

OAuthResponseFactory        → Context 역할

OAuthAttributes (interface)
├── GoogleOAuthAttributes
├── KakaoOAuthAttributes
└── NaverOAuthAttributes

Strategy 인터페이스

public interface OAuthResponseStrategy {
    String getProviderName();
    OAuthAttributes createOAuthAttributes(Map<String, Object> attributes);
}

getProviderName() 은 제공자 식별 키를 반환하고, createOAuthAttributes()는 제공자 응답을 파싱하여 공통 객체로 변환한다.

ConcreteStrategy 구현체

@Component
public class KakaoOAuthResponseStrategy implements OAuthResponseStrategy {

    @Override
    public String getProviderName() {
        return "kakao";
    }

    @Override
    public OAuthAttributes createOAuthAttributes(Map<String, Object> attributes) {
        return KakaoOAuthAttributes.of(attributes);
    }
}

각 제공자별로 응답 파싱 로직을 독립적으로 구현한다.

Google, Naver 등등 다른 제공자도 동일한 구조로 각자 파싱 로직만 다르게 구현한다.

+ OAuthAtrributes

public interface OAuthAttributes {
    String getProvider();
    String getProviderId();
    String getName();
    String getEmail();
    String getProfileImage();
    User toEntity();
}

파싱 결과를 담는 객체도 인터페이스로 추상화했다. toEntity()를 통해 도메인 객체인 User로 변환한다.

Spring DI와의 조합

Strategy Pattern으로 설계했을 때의 진가는 Spring DI와 결합할 때 극대화된다.

@Component
public class OAuthResponseFactory {

    private final Map<String, OAuthResponseStrategy> strategies;
    
    // Spring이 OAuthResponseStrategy 구현체들을 자동으로 주입
    public OAuthResponseFactory(List<OAuthResponseStrategy> strategyList) {
        this.strategies = strategyList.stream()
                .collect(Collectors.toMap(
                        OAuthResponseStrategy::getProviderName,
                        Function.identity(),
                        (existing, replacement) -> {
                            throw new CustomException(ErrorCode.DUPLICATE_OAUTH_PROVIDER);
                        }
                ));
    }
    
    // 제공자에 맞는 OAuthAttributes 생성
    public OAuthAttributes createOAuthAttributes(String provider, Map<String, Object> attributes) {
        OAuthResponseStrategy strategy = strategies.get(provider.toLowerCase());
        if (strategy == null) {
            throw new CustomException(ErrorCode.UNSUPPORTED_OAUTH_PROVIDER);
        }
        return strategy.createOAuthAttributes(attributes);
    }
}

핵심은 생성자 파라미터 List<OAuthResponseStrategy>이다.

Spring은 OAuthResponseStrategy를 구현한 모든 @Component 빈을 자동으로 수집해 리스트로 주입한다.

이를 getProviderName()을 키로 Map으로 변환하면, 제공자 이름으로 조회(O(1))가 가능해진다.

새로운 OAuth 제공자를 추가하고 싶다면, Strategy 구현체 클래스를 하나 만들고 @Component만 붙이면 된다.

즉, 기존 코드는 전혀 수정할 필요가 없다.

정리

Strategy Pattern을 통한 OAuth2.0 다중 제공자 구조 설계를 통해 OCP를 실현할 수 있다.

전형적으로 확장에는 열려 있고, 기존 코드 수정에는 닫혀있는 구조다.

제공자 추가 시 기존 코드 수정 없이 클래스 하나만 추가하면 된다.

DDD(Domain-Driven Design) 구조

CodeChronicle — Tue, 14 Apr 2026 01:17:45 +0900

DDD(Domain-Driven Design) 구조

DDD는 Domain Driven Design으로 비즈니스 도메인을 중심으로 소프트웨어를 설계하는 방법론이다.

패키지 구조도 그 철학을 반영한다.

DDD를 사용하는 이유

만약 1인 개발을 하거나, 소규모 프로젝트에서는 DDD 패키지 구조의 필요성을 느끼지 못할 수 있다.

하지만 여러명이 작업하거나 프로젝트의 규모가 커졌을 때 생기는 다양한 문제를 해결하기 위해 DDD 패키지 구조를 채택한다.

복잡한 비즈니스 로직의 응집도를 높여 각 도메인별로 병렬 개발을 원활하게 진행할 수 있다.

Layered architecture

DDD는 보통 4개의 Layer로 구성된다.

Presentation (Interface) Layer
|
Application Layer
|
Domain Layer
|
Infrastructure Layer

Presentation Layer

해당 Layer의 역할은 명확하다.

외부에서 들어오는 요청을 받아 Application Layer에 넘기고, 결과를 다시 외부에 돌려주는 것.

이때 중요한 것은 Presentation Layer에 비즈니스 로직이 존재하면 안 된다.

@RestController가 여기에 위치하고, 클라이언트가 보낸 요청을 DTO로 받아 유효성 검사를 마친 뒤 Application을 호출한다.

통신 프로토콜에 관한 내용은 해당 Layer에 있어야 한다.

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/orders")
public class OrderController {

    private final OrderService orderService
    
    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(@RequestBody @Valid CreateOrderRequest request) {
    	OrderResult result = orderService.createOrder(request.toCommand());
        return ResponseEntity.ok(OrderResponse.from(result));
    }
}

Application Layer

UseCase를 조율하는 Layer이다.

"주문을 생성한다.", "주문을 취소한다." 와 같이 하나의 UseCase를 완성하기 위해 필요한 도메인 객체들을 조율한다.

중요한 특징은 비즈니스 규칙을 직접 구현하지 않는다.

Application Layer는 도메인 객체에게 일을 시키는 지휘자 같은 역할이다.

(Facade 패턴과 구조적으로 거의 동일하다.)

@Transaction이 해당 Layer에 붙고, 트렌젝션의 경계는 하나의 UseCase 단위와 일치해야 한다.

@Service
@Transactional
@RequiredArgsConstructor
public class OrderService {
    
    private final OrderRepository orderRepository
    private final ProductRepository productRepository
    private final PaymentService patmentService
    
    public OrderResponse createOrder(CreateOrderCommand command) {
    	// 도메인 객체 조회
        Product product = productRepository.findById(command.getProductId());
        
        // 도메인 로직 위임
        Order order = Order.craete(product, command.getQuantity(), command.getUserId());
        
        // 저장
        orderRepository.save(order);
        
        // 결과 반환
        return OrderResult.from(order);
    }
}

Domain Layer

DDD의 핵심으로 해당 Layer는 크게 네 가지 구성요소로 이루어져있다.

Aggregate Root(Entity)는 비즈니스 규칙을 메서드로 표현한다.

setter를 열어두지 않고, 상태 변경은 반드시 의미 있는 메서드를 통해서만 이루어진다.

public class Order {

    private Long id;
    private List<OrderItem> items;
    private OrderStatus status;
    
    // 정적 팩토리 메서드로 생성 규칙 표현
    public static Order create(...) {
    	// 생성규칙 작성...
    }
    
    // 비즈니스 규칙이 메서드 안에 담김
    public void cancel() {
    	if (...) {
        	// 비즈니스 코드
        }
    }
    
    ...
}

Value Object는 식별자 없이 값 자체로 동일성을 판단하는 개념이다.

Repository 인터페이스는 Domain Layer에 선언만 하고 구현은 Infrastructure가 한다.

Domain은 저장소가 어떻게 동작하는지 모르고, 테스트 시 Mock으로 교체할 수 있다.

public interface OrderRepository {
    Order findById(Long id);
    void save(Order order);
    List<Order> findByUserId(UserId userId);
}

Domain Service는 하나의 Aggregate로 표현하기 어려운 비즈니스 규칙을 처리한다.

Infrastructure Layer

Domain이 선언한 Repository 인터페이스를 실제로 구현하고 DB연결, 외부 API호출, 메시지 큐 등 모든 기술적 구현을 담당한다.

핵심 패턴은 Domain 모델과 DB 모델을 분리하는 것이다.

JPA Entity는 DB 테이블 구조에 맞게 설계되고, Domain 객체는 비즈니스에 맞게 설계된다.

@Repository
@RequiredArgsConstructor
public class OrderRepositoryImpl implements OrderRepository {

    private final OrderJpaRepository jpaRepository;

    @Override
    public Order findById(OrderId id) {
        OrderEntity entity = jpaRepository.findById(id.getValue())
            .orElseThrow(() -> new OrderNotFoundException(id));

        return entity.toDomain();
    }

    @Override
    public void save(Order order) {
        OrderEntity entity = OrderEntity.from(order);
        jpaRepository.save(entity);
    }
}

정리

4개의 Layer의 핵심 규칙은 의존성이 항상 Domain방향이라는 것이다.

Presentation => Application => Domain <= Infrastructure

Infrastructure가 Domain을 향해 의존하는 구조이기 때문에, Domain은 아무것도 의존하지 않는 순수한 상태를 유지할 수 있다.

마무리하며

해당 포스트를 작성하며 "난 항상 DDD 구조에 맞게 설계하고 코드를 작성하고 있어."라고 생각했던 코드들이 스쳐 지나갔다.

프로젝트를 시작하면 이번에는 "DDD를 엄격하게 준수해서 코드를 작성해야지"라고 생각하지만, 코드가 늘어날수록 지켜지지 않는 부분들이 많아진다. (결국 타협하고 코드를 작성해야 하는 순간이 온다.)

물론 DDD를 단순 CRUD 수준의 서비스에 적용하는 건 오버엔지니어링이라고 생각한다.

다만, 이 정도는 괜찮겠지라고 생각하며 코드를 작성하면 레이어 간의 의존성 문제가 생기고 레거시 코드가 된다는 걸 유념해야 한다.

백준 10610번 Python

CodeChronicle — Wed, 5 Feb 2025 21:09:44 +0900

백준 10610번 Python

https://www.acmicpc.net/problem/10610

문제

어느 날, 미르코는 우연히 길거리에서 양수 N을 보았다.

미르코는 30이란 수를 존경하기 때문에,

그는 길거리에서 찾은 수에 포함된 숫자들을 섞어 30의 배수가 되는 가장 큰 수를 만들고 싶어 한다.

미르코를 도와 그가 만들고 싶어 하는 수를 계산하는 프로그램을 작성하라.

입력

N을 입력받는다. N는 최대 10⁵개의 숫자로 구성되어 있으며, 0으로 시작하지 않는다.

출력

미르코가 만들고 싶어 하는 수가 존재한다면 그 수를 출력하라. 그 수가 존재하지 않는다면, -1을 출력하라.

풀이

import sys
input = sys.stdin.readline


def check(num):
    if sum(map(int, num)) % 3 != 0:
        return False
    if num[-1] != '0':
        return False
    return True

N = list(input().rstrip())
N.sort(reverse=True)

if not check(N):
    print(-1)
else:
    print(*N, sep='')

30의 배수가 되는 조건을 이해하면 쉽게 풀 수 있다.

일단 30의 배수가 되려면 1의 자릿수가 0이 되어야 한다는 것이 첫 번째 조건이다.

두 번째 조건으로는 3의 배수의 특성을 이용할 것이다.

30의 배수는 곧 3의 배수임을 알 수 있다.

이 두 가지 조건을 만족하는 모든 수는 30의 배수이다.

마지막으로 정렬을 통해 가장 큰 수를 구하면 문제를 해결할 수 있다.

Python - dictionary 활용과 시간 복잡도 (Big-O)

CodeChronicle — Sat, 18 Jan 2025 20:52:06 +0900

Python - dictionary 활용과 시간 복잡도 (Big-O)

알고리즘 문제를 풀다 보면 딕셔너리를 사용하는 경우가 있다.

딕셔너리는 다른 다른 자료형에 비해 동작시간에서 유리한 측면이 있다.

Dictionary 자료형

딕셔너리는 사전이라는 의미로 key-value 쌍을 가지는 자료형이다.

1) 딕셔너리 생성

dictionary0 = dict()
dictionary1 = {}

2) 딕셔너리 값 추가 및 삭제

dictionary["과일"] = "apple"

del dictionary["과일"]

3) 딕셔너리 내장함수

dictionary.keys()    # 딕셔너리의 key를 가져온다. 
dictionary.values()  # 딕셔너리의 value를 가져온다.
dictionary.get()     # 해당 딕셔너리 key의 value값을 가져온다. 값이 없으면 none 반환
dictionary.items()   # 딕셔너리의 key와 value을 가져온다.

Dictionary 활용

값을 입력받는 로직이다.

value값을 list형으로 입력받고 싶을 때 사용하는 로직이다.

graph = dict()
for _ in range(N):
    key, value = map(int, input().rstrip().split())
    if value not in graph:
        graph[key] = list()
    graph[key].append(value)

모듈을 사용하여 해당 키가 존재하는지 확인하는 과정을 생략할 수 있다.

from collections import defaultdict

dic = defaultdict(list)
dic["과일"].append("apple")
dic["과일"].append("orange")
dic["숫자"].append(0)
dic["숫자"].append(1)

시간 복잡도 (Big-O)

Operation	Example	Class
Store	d[k] = v	O(1)
Length	len(d)	O(1)
Delete	del d[k]	O(1)
Get	d.get(k)	O(1)
Pop	d.pop(k)	O(1)
Clear	d.clear()	O(1)
View	d.keys()	O(1)
Iteration	for k in d	O(N)

List 자료형에 비해 빠른 동작 속도를 가지고 있는 것을 알 수 있다.

Dictionary는 Hash Table을 사용한다.

key 값을 알고 있으면 바로 접근할 수 있다.

때문에 순차적으로 값을 탐색하는 List 보다 시간복잡도면에서 유리하다.

백준 15975번 Python

CodeChronicle — Sat, 18 Jan 2025 19:44:27 +0900

백준 15975번 Python

https://www.acmicpc.net/problem/15975

문제

직선 위에 직선 위에 N개의 점들이 주어지고 각 점은 N개의 색깔 중 하나를 가진다.

편의상, 색깔은 1부터 N까지의 수로 표시하고, 점들의 좌표는 모두 다르다.

각 점 p에 대해서, p에서 시작하는 직선 화살표를 이용해서 다른 점 q에 연결하려고 한다.

여기서, 점 q는 p와 같은 색깔의 점들 중 p와 거리가 가장 가까운 점이어야 한다.

만약 가장 가까운 점이 두 개 이상이면 아무거나 하나를 선택한다.

각 점 p에서 시작하여 위 조건을 만족하는 q로 가는 하나의 화살표 ℓ_p를 그린다.

특별히 점 p에 대해서 수평선 상에 같은 색깔의 다른 점이 없다면 |ℓ_p| = 0이다.

여기서 |ℓ_p|는 화살표 ℓ_p의 길이를 나타낸다.

예를 들어, 점들을 순서쌍 (좌표, 색깔)로 표시할 때, p₁ = (0, 1), p₂ = (1, 2), p₃ = (3, 1), p₄ = (4, 1)라고 하자.

점 p₁의 화살표 |ℓ_p₁|는 p₁ → p₃로 연결된다.

점 p₃와 p₄의 화살표 |ℓ_p₃|, |ℓ_p₄|는 각각 p₃ → p₄와 p₄ → p₃로 연결된다.

점 p₂의 경우는 같은 색깔의 다른 점이 존재하지 않는다.

따라서 모든 화살표들의 길이의 합은 |ℓ_p₁| + |ℓ_p₂| + |ℓ_p₃| + |ℓ_p₄| = 3 + 0 + 1 + 1 = 5이다.

점들의 좌표와 색깔이 주어질 때, 모든 점에서 시작하는 화살표들의 길이의 합, 다시 말해서, Σ_p |ℓ_p| 을 출력하는 프로그램을 작성하시오.

입력

표준 입력으로 다음 정보가 주어진다.

첫 번째 줄에는 점들의 개수를 나타내는 정수 N이 주어진다.

다음 N개의 줄 각각에는 점의 좌표와 색깔을 나타내는 두 정수 x와 y가 주어진다.

출력

표준 출력으로 모든 점에서 시작하는 화살표들의 길이 합을 출력한다.

제한 및 서브태스크

제한
모든 서브태스크에서 점들의 좌표 x와 색깔 y는 각각 0 ≤ x ≤ 10⁹, 1 ≤ y ≤ N을 만족한다.

서브태스크 1

점들의 색깔은 모두 동일하고 점들의 개수는 1 < N ≤ 10을 만족한다.

서브태스크 2
점들의 색깔은 정확히 두 가지이고 점들의 개수는 1 ≤ N ≤ 2,000를 만족한다.

서브태스크 3
점들의 개수는 1 ≤ N ≤ 10,000를 만족한다.

서브태스크 4
점들의 개수는 1 ≤ N ≤ 100,000를 만족한다.

풀이

import sys
input = sys.stdin.readline


N = int(input().rstrip())

graph = dict()
for _ in range(N):
    pos, clr = map(int, input().rstrip().split())
    if clr not in graph:
        graph[clr] = list()
    graph[clr].append(pos)


ans = 0
for cur in graph:
    li = sorted(graph[cur])

    if len(li) == 1:
        continue

    tmp_list = list()
    for i in range(len(li)-1):
        tmp_list.append(li[i+1]-li[i])

    ans += tmp_list[0]
    ans += tmp_list[-1]

    for j in range(len(tmp_list)-1):
        if tmp_list[j] < tmp_list[j+1]:
            ans += tmp_list[j]
        else:
            ans += tmp_list[j+1]

print(ans)

다소 난해해 보이는 문제이다.

일단 문제를 간단하게 정리하여 보자.

다수의 색깔이 있고, 색깔별로 점들이 찍혀있다.

특정 색깔에 점의 개수가 하나 이하라면 점 사이의 거리를 측정할 수 없기 때문에 무시하여도 된다.

임의의 색깔에 한 개 이상의 점이 존재할 때 각 점에서 가장 가까운 점과의 거리를 구한다.

이를 총합하여 출력하면 된다.

문제를 풀기 앞서 문제 풀이 아이디어를 공유해 보겠다.

일단 딕셔너리의 key값을 색깔로 value 값을 점들의 좌표로 받아 저장해 준다.

이후 각 색깔별로 점들 사이의 거리를 측정하여 이를 임의의 리스트에 저장한다.

임의의 리스트에는 각 점들 사이의 거리가 담기게 되는데 이때 더 가까운 거리

즉, 더 작은 값을 채택하여 ans 변수에 담는다.

graph = dict()
for _ in range(N):
    pos, clr = map(int, input().rstrip().split())
    if clr not in graph:
        graph[clr] = list()
    graph[clr].append(pos)

입력값을 풀이에 맞게 재단하는 과정이다.

from collections import defaultdict

조금 더 편하게 풀고 싶다면 defaultdict 모듈을 사용해도 된다.

~~(필자는 사용하지 않았다.)~~

for cur in graph:
    li = sorted(graph[cur])

    if len(li) == 1:
        continue

각 색깔별로 풀이를 반복한다.

이후 가장 가까운 점 사이의 거리를 구하기 위해 sort 해주었다.

길이가 1인 key값의 value는 점사이의 거리를 측정할 수 없기 때문에 continue 한다.

tmp_list = list()
for i in range(len(li)-1):
	tmp_list.append(li[i+1]-li[i])

점 사이의 거리를 임의의 리스트에 저장한다.

ans += tmp_list[0]
ans += tmp_list[-1]

for j in range(len(tmp_list)-1):
    if tmp_list[j] < tmp_list[j+1]:
        ans += tmp_list[j]
    else:
        ans += tmp_list[j+1]

처음의 점과 마지막 점에서 가장 가까운 점은 항상 하나이기 때문에 미리 ans 변수에 더한다.

이후 수직선을 기준으로 좌우 점 중 거리가 더 가까운 점과의 거리를 ans 변수에 더한다.

다소 난해한 풀이라고 느껴질 수 있다.

하지만 각 점 사이의 거리를 저장해 두고 더 짧은 거리를 채택하여 ans변수에 더한다 라는 대전제를 이해하고 풀이를 보면 이해하기 쉬울 것 같다.

백준 23802번 Python

CodeChronicle — Fri, 17 Jan 2025 20:57:03 +0900

백준 23802번 Python

https://www.acmicpc.net/problem/23802

문제

서준이는 아빠로부터 골뱅이가 들어 있는 상자를 생일 선물로 받았다.

상자 안에는 뒤집힌 ㄱ자 모양의 골뱅이가 들어있다.

뒤집힌 ㄱ자 모양은 가로 및 세로로 각각 5개의 셀로 구성되어 있다.

상자에는 정사각형 모양의 셀의 크기를 나타내는 숫자 하나가 적혀있다.

셀의 크기 N이 주어지면 예제 출력과 같은 방식으로 골뱅이 모양을 출력하시오.

입력

첫째 줄에 정수 N(1 ≤ N ≤ 100)이 주어진다.

출력

셀의 크기가 N인 골뱅이를 출력한다.

풀이

import sys
input = sys.stdin.readline


N = int(input().rstrip())

for _ in range(N):
    print('@@@@@'*N)

for _ in range(N*4):
    print('@'*N)

문제의 예제 출력을 보면 기본적으로 셀의 크기가 1일 때 5개의 '@'를 출력하는 것을 알 수 있다.

가로 세로의 두께가 N인 뒤집힌 ㄱ자 모양을 출력한다라고 이해할 수 있다.

때문에 가로는 '@@@@@'를 한 묶음으로 N번 출력하고,

세로는 '@'를 N개씩 N*4번 출력하면 된다.

이때 N*4번 출력하는 이유는 가로를 출력하는 과정에서 N번의 @가 출력되었기 때문이다.

백준 12971번 Python

CodeChronicle — Tue, 14 Jan 2025 01:00:35 +0900

백준 12971번 Python

https://www.acmicpc.net/problem/12971

문제

준서는 얼마 전 나머지연산에 대해 배웠다.

양의 정수 N을 다른 양의 정수 M으로 나눈 나머지는 항상 0이상 M-1이하의 정수가 된다는 사실이 신기한 준서는 혼자만의 숫자놀이를 고안했다.

먼저 준서는 양의 정수 X1, X2, X3 3개를 임의로 고른다.

그 후 3개의 양의 정수 P1, P2, P3을 고르는데, P1 > X1, P2 > X2, P3 > X3을 만족하도록 고른다.

준서가 알고 싶은 것은 아래의 조건을 만족하는 가장 작은 양의 정수 N이다.

N을 P1로 나눈 나머지가 X1, P2로 나눈 나머지가 X2, P3로 나눈 나머지가 X3

준서가 선택한 P1, P2, P3, X1, X2, X3가 주어졌을 때, 가장 작은 정수 N을 찾는 프로그램을 작성하시오.

입력

공백으로 구분된 6개의 정수 P1, P2, P3, X1, X2, X3가 순서대로 주어진다. 모든 숫자는 1과 300사이의 정수다.

출력

한 줄에 가장 작은 양의 정수 N을 출력한다.

단, 조건을 만족하는 1,000,000,000미만의 양의 정수가 없을 경우 -1을 출력한다.

풀이

import sys
input = sys.stdin.readline


def solved():
    P1, P2, P3, X1, X2, X3 = map(int, input().rstrip().split())
    for N in range(X1, P1*P2*P3+1, P1):
        if (N%P2 == X2 and N%P3 == X3):
            return N
    return -1

print(solved())

브루트 포스로 문제를 풀엇다.

최소공배수로 풀어야 할 것 같은 마음에 유클리드 호제법을 이리저리 써봤다.

하지만 전탐색으로 문제를 푸니 바로 풀렸다.

조금이라도 효율적으로 문제를 풀기 위해 반복문에서 변수가 P1식 증가하도록 했다.

P1의 숫자가 클수록 1씩 증가하며 풀이하는 것보다 보다 빠른 수행속도를 보여준다.

P1, P2, P3를 비교하여 가장 큰 숫자를 증가량으로 설정하는 것도 방법이다.

다만 정수론, 중국인의 나머지 정리를 이용하여 푸는 방법도 추후에 풀어보면 좋을 것 같다.

백준 1912번 Python

CodeChronicle — Fri, 10 Jan 2025 16:50:12 +0900

백준 1912번 Python

https://www.acmicpc.net/problem/1912

문제

n개의 정수로 이루어진 임의의 수열이 주어진다.

우리는 이 중 연속된 몇 개의 수를 선택해서 구할 수 있는 합 중 가장 큰 합을 구하려고 한다.

단, 수는 한 개 이상 선택해야 한다.

예를 들어서 10, -4, 3, 1, 5, 6, -35, 12, 21, -1 이라는 수열이 주어졌다고 하자.

여기서 정답은 12+21인 33이 정답이 된다.

입력

첫째 줄에 정수 n(1 ≤ n ≤ 100,000)이 주어지고 둘째 줄에는 n개의 정수로 이루어진 수열이 주어진다.

수는 -1,000보다 크거나 같고, 1,000보다 작거나 같은 정수이다.

출력

첫째 줄에 답을 출력한다.

풀이

import sys
input = sys.stdin.readline


n = int(input().rstrip())
nums = list(map(int, input().rstrip().split()))

dp = [0] * n
dp[0] = nums[0]
ans = nums[0]

for i in range(1, n):
    dp[i] = max(nums[i], dp[i-1] + nums[i])
    if dp[i] > ans:
        ans = dp[i]

print(ans)

조건과 관계없이 해당 문제를 푸는 것은 그리 어렵지 않다.

브루트포스 기법으로 모든 임의의 수열에 대해 값을 비교해도 된다.

다만, 해당 방법으로 문제를 풀면 문제의 조건에 만족하지 못한다.

처음 문제를 접했을 때 여러 방법을 떠올렸다.

연속합이라는 제목을 보고 누적합을 고민했다.

하지만 일반적인 누적합은 문제에 적용하기 어려움이 있었고, 조건을 추가하여 문제를 풀었다.

결국 DP를 이용하여 문제를 풀었다.

입력받은 배열과 같은 크기의 DP배열을 새로 만들고

dp[i] = max(nums[i], dp[i-1] + nums[i])

해당 점화식을 사용하였다.

자, DP에서 점화식을 구하면 나머지는 구현의 영역이다.

초기값 세팅과 나머지 과정을 구현하여 문제를 해결했다.

백준 2577번 Python

CodeChronicle — Thu, 9 Jan 2025 17:37:24 +0900

백준 2577번 Python

https://www.acmicpc.net/problem/2577

문제

세 개의 자연수 A, B, C가 주어질 때

A × B × C를 계산한 결과에 0부터 9까지 각각의 숫자가 몇 번씩 쓰였는지를 구하는 프로그램을 작성하시오.

예를 들어 A = 150, B = 266, C = 427 이라면 A × B × C = 150 × 266 × 427 = 17037300 이 되고,

계산한 결과 17037300 에는 0이 3번, 1이 1번, 3이 2번, 7이 2번 쓰였다.

입력

첫째 줄에 A, 둘째 줄에 B, 셋째 줄에 C가 주어진다.

A, B, C는 모두 100보다 크거나 같고, 1,000보다 작은 자연수이다.

출력

첫째 줄에는 A × B × C의 결과에 0 이 몇 번 쓰였는지 출력한다.

마찬가지로 둘째 줄부터 열 번째 줄까지 A × B × C의 결과에 1부터 9까지의 숫자가 각각 몇 번 쓰였는지 차례로 한 줄에 하나씩 출력한다.

풀이

import sys
input = sys.stdin.readline


num = 1
for _ in range(3):
    num *= int(input().rstrip())

for i in range(10):
    print(str(num).count(str(i)))

문제에서 ABC의 숫자는 중요하지 않다.

ABC를 곱한 값만 알면 되기 때문에 num에 곱한값을 입력하였다.

이후 0부터 9까지 각 숫자가 몇 번 포함되는지 알기 위해 count() 함수를 사용하였다.

다만 int형으로 이루어져있는 num과 i를 문자로 타입을 변환하여 코드를 진행하였다.

백준 6550번 Python

CodeChronicle — Wed, 8 Jan 2025 18:40:58 +0900

백준 6550번 Python

https://www.acmicpc.net/problem/6550

문제

2개의 문자열 s와 t가 주어졌을 때 s가 t의 부분 문자열인지 판단하는 프로그램을 작성하라.

부분 문자열을 가지고 있는지 판단하는 방법은 t에서 몇 개의 문자를 제거하고 이를 순서를 바꾸지 않고 합쳤을 경우 s가 되는 경우를 이야기한다.

입력

입력은 여러 개의 테스트 케이스로 이루어져 있다.

각 테스트 케이스는 한 줄로 이루어져 있으며, 문자열 s와 t가 빈칸을 사이에 두고 들어온다.

s와 t의 길이는 10만을 넘지 않는다.

출력

입력된 s와 t의 순서대로 s가 t의 부분 문자열인 경우 Yes라 출력하고 아닐 경우 No라고 출력한다.

풀이

""" 첫 번째 풀이 """
import sys
input = sys.stdin.readline


def is_in_string(s, t):
    i, j = 0, 0
    
    while i < len(s) and j < len(t):
        if s[i] == t[j]:
            i += 1
        j += 1

    if i == len(s):
        print("Yes")
    else:
        print("No")


while True:
    try:
        s, t = map(str, input().rstrip().split())
        is_in_string(s, t)
    except:
        break

문자열의 문자를 하나씩 비교하는 방법을 채택한 풀이이다.

is_in_string() 함수를 만들어 사용했다.

일단 제출해서 '통과!'는 받았지만 마음에 드는 코드는 아니다.

추후 코드를 다시 볼 때 좋지 않은 코드이다.

""" 두 번째 코드 """
import sys
input = sys.stdin.readline


def is_in_string(s, t):
    idx = -1
    for c in s:
        idx = t.find(c,idx+1)
        if idx == -1:
            print("No")
            return
    print("Yes")
    return


while True:
    try:
        s, t = map(str, input().rstrip().split())
        is_in_string(s, t)
    except:
        break

해당 코드는 find 함수를 이용하여 문자를 찾는 지점을 설정해 주었다.

find 함수는 해당 문자를 문자열에서 찾지 못했을 때 -1을 반환하기 때문에 idx 변수가 -1이라면 No를 출력하도록 했다.

첫 번째 코드보다 의도한 바를 잘 전달할 수 있는 코드라고 생각하는 풀이이다.

백준 16916번 Python

CodeChronicle — Wed, 8 Jan 2025 17:07:23 +0900

백준 16916번 Python

https://www.acmicpc.net/problem/16916

문제

문자열 S의 부분 문자열이란, 문자열의 연속된 일부를 의미한다.

예를 들어, "aek", "joo", "ekj"는 "baekjoon"의 부분 문자열이고, "bak", "p", "oone"는 부분 문자열이 아니다.

문자열 S와 P가 주어졌을 때, P가 S의 부분 문자열인지 아닌지 알아보자.

입력

첫째 줄에 문자열 S, 둘째 줄에 문자열 P가 주어진다.

두 문자열은 빈 문자열이 아니며, 길이는 100만을 넘지 않는다.

또, 알파벳 소문자로만 이루어져 있다.

출력

P가 S의 부분 문자열이면 1, 아니면 0을 출력한다.

풀이

import sys
input = sys.stdin.readline

S = input().rstrip()
P = input().rstrip()
print(1 if P in S else 0)

두 문자열을 받아 기준이 되는 문자열 S에 부분 문자열 P를 비교하면 된다.

만약 문자열 P가 문자열 S에 포함된다면 1 아니라면 0을 출력한다.

간단한 문자열 문제이다.

Python으로 백준 풀기 - 자주 사용하는 라이브러리와 구문

CodeChronicle — Tue, 7 Jan 2025 22:50:31 +0900

Python으로 백준 풀기 - 자주 사용하는 라이브러리와 구문

https://solved.ac/problems/sprout

solved.ac

알고리즘 문제해결 학습의 이정표 Baekjoon Online Judge 문제들의 난이도 및 티어 정보를 제공하는 사이트입니다.

solved.ac

처음 알고리즘 문제풀이를 접한다면 solved.ac에서 제공하는 연습문제를 풀어보는 것을 추천한다.

'새싹' 이라는 키워드로 기본적으로 알아야 할 것들을 정리해 두었다.

여기까지는 '문제는 푼다'기 보다는 '프로그래밍 문제풀이를 어떻게 시작해야 하는가'에 대한 내용이다.

자주 사용하는 라이브러리

import sys
import math
import heapq
from itertools import combinations, permutations
from collections import deque
input = sys.stdin.readline
INF = int(1e9)

필자는 자주 사용하는 라이브러리를 지우지 않고 그대로 둔다.

새로운 문제를 풀 때마다 입력하는 것보다 해당 코드 아래에 문제 풀이를 하고 풀이만 지웠다 썼다 하는 것이 편하다.

몇 가지 설명해 보겠다.

import sys
input = sys.stdin.readline

거의 모든 풀이에 포함하는 구문이다.

빠른 입출력을 위해 사용하는 라이브러리이다.

다만 문제 풀이를 하다 보면 입력을 받을 때마다 sys.stdin.readline() 처럼 입력받는 것이 번거롭게 느껴진다.

때문에 input = sys.stdin.readline 한 줄을 추가하여 input() 함수를 호출하면 바로 sys 입력으로 변환되도록 한다.

from collections import deque

문제 풀이 시 상당히 많이 사용하는 자료구조 deque이다.

양방향으로 데이터에 접근할 수 있는 것이 장점이다.

보통 popleft() 함수를 쓰기 위해 사용하는 것 같다.

(맨 앞의 인덱스에 접근하기 위해서)

from itertools import combinations, permutations

순열 조합 관련 문제가 나오면 자주 사용하는 라이브러리 itertools이다.

문제를 풀다 보면 '~의 조건을 만족하는 수열을 구하시오.' 와 같은 구문이 나오는 경우가 있다.

이때 해당 라이브러리를 활용하면 코드를 조금 더 간결하고 직관적으로 풀 수 있다.

[BOJ] 백준 15649번 Python

백준 15649번 Pythonhttps://www.acmicpc.net/problem/15649 문제자연수 N과 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오.1부터 N까지 자연수 중에서 중복 없

codechronicle.tistory.com

import math

sqrt() 함수 활용 때문에 자주 사용한다.

소수판정 문제 등에서 에라토스테네스의 체 같은 알고리즘을 사용하면 루트(root)와 같은 수학 기호가 필요할 때가 있다.

import heapq

난이도가 올라가면 사용할 일이 많아지는 라이브러리이다.

힙은 최댓값과 최솟값을 빠르게 찾기 위해 특정한 규칙을 사용하는 자료구조이다.

난이도가 올라갈수록 시간제한이 타이트하게 설정되어 있는 경우가 많은데, 동작속도가 느린 python으로 이런 문제들을 해결하기 위해서는 필히 사용해야 하는 경우가 있다.

INF = int(1e9)

int 범위 내에서 무한대 값을 나타내기 위해 사용한다.

(1e9는 10의 9 제곱이라는 의미)

관례적인 값이다.

자주 사용하는 구문

변수1, 변수2 = map(자료형, input().rstrip().split())

여러 입력값을 한 번에 받을 때 자주 사용한다.

하나하나 의미를 뜯어보자.

map은 여러 개의 데이터를 입력받아 각각의 변수에 함수를 적용한 결과를 반환하는 내장함수이다.

rstrip()는 입력데이터의 오른쪽에 공백을 제거해 주기 위해 사용했다.

split() 말 그대로 입력 데이터를 나눠주는 함수이다.

array = list(map(int, input().rstrip().split()))

2DArray = [list(map(int, input().rstrip().split())) for _ in range(반복횟수)]

다음과 같이 데이터를 입력받는 경우도 많다.

for _ in range(반복횟수):

보편적으로 for i in range(n): 처럼 많이 사용한다.

하지만 i 값을 굳이 사용하지 않는다면 언더바를 사용해도 좋다.

print(*arr)

unpacking을 쉽게 하는 방법이다.

배열을 출력하고 싶은데 매번

for i in range(len(arr)):
	print(arr[i], end = " ")

이렇게 쓰는 게 귀찮다면 위에서 사용한 방법대로 사용하는 것도 좋다.

번외

풀이 제출시에 python3에서 통과되지 않는 문제가 pypy3로 제출하면 통과되는 경우도 있습니다. 꿀팁(?)

다만, 출력은 맞아야함. (경험상 재귀를 사용했을 때는 더 느린경우도 많았다.)

정리

개인적으로 자주 사용한 라이브러리와 구문들을 공유해 보았습니다.

본 글에서 공유한 정보들이 알고리즘 풀이 실력을 늘려주지는 않겠지만, 문제 푸는 속도나 편의성 측면에서 도움이 될 것 같아 작성했습니다.

이후 추가적으로 공유하고 싶은 내용이 있다면 계속해서 업데이트하겠습니다!

백준 15649번 Python

CodeChronicle — Tue, 7 Jan 2025 18:32:44 +0900

백준 15649번 Python

https://www.acmicpc.net/problem/15649

문제

자연수 N과 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오.

1부터 N까지 자연수 중에서 중복 없이 M개를 고른 수열

입력

첫째 줄에 자연수 N과 M이 주어진다. (1 ≤ M ≤ N ≤ 8)

출력

한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다.

중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다.

수열은 사전 순으로 증가하는 순서로 출력해야 한다.

풀이

import sys
from itertools import permutations
input = sys.stdin.readline


N, M = map(int, input().rstrip().split())

nums = [n for n in range(1,N+1)]
nPm = permutations(nums,M)
for ans in nPm:
    print(*ans)

모듈을 이용하면 간단하게 풀 수 있다.

1 ~ N 까지 숫자를 사전순으로 M개 선택하면 된다.

itertools 에서 permutations를 import하면 permutations(), 순열 함수를 사용할 수 있다.

[(1, 2), (1,3), ... ] 와 같은 구조로 l-value에 입력된다.

이 때 출력 형식을 맞추기 위해서 *을 이용해서 unpacking 해주었다.

백준 2441번 Python

CodeChronicle — Sun, 5 Jan 2025 16:10:41 +0900

백준 2441번 Python

https://www.acmicpc.net/problem/2441

문제

첫째 줄에는 별 N개, 둘째 줄에는 별 N-1개, ..., N번째 줄에는 별 1개를 찍는 문제

하지만, 오른쪽을 기준으로 정렬한 별(예제 참고)을 출력하시오.

입력

첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다.

출력

첫째 줄부터 N번째 줄까지 차례대로 별을 출력한다.

풀이

N = int(input().rstrip())
for i in range(N):
    print(" "*i+"*"*(N-i))

N = int(input().rstrip())
for i in range(N):
    for j in range(i):
        print(" ", end="")
    for k in range(N-i):
        print("*", end="")
    print()

이정도 난이도의 별 찍기는 뭐 숏코딩의 영역이라 봐도 되는 것 같다.

~~(난이도 올라갈수록 보기엔 쉬워도 생각보다 어려움)~~

백준 1316번 Python

CodeChronicle — Sun, 5 Jan 2025 15:09:49 +0900

백준 1316번 Python

https://www.acmicpc.net/problem/1316

문제

그룹 단어란 단어에 존재하는 모든 문자에 대해서, 각 문자가 연속해서 나타나는 경우만을 말한다.

예를 들면, ccazzzzbb는 c, a, z, b가 모두 연속해서 나타나고, kin도 k, i, n이 연속해서 나타나기 때문에 그룹 단어이지만, aabbbccb는 b가 떨어져서 나타나기 때문에 그룹 단어가 아니다.

단어 N개를 입력으로 받아 그룹 단어의 개수를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 단어의 개수 N이 들어온다. N은 100보다 작거나 같은 자연수이다.

둘째 줄부터 N개의 줄에 단어가 들어온다.

단어는 알파벳 소문자로만 되어있고 중복되지 않으며, 길이는 최대 100이다.

출력

첫째 줄에 그룹 단어의 개수를 출력한다.

풀이

import sys
input = sys.stdin.readline


N = int(input().rstrip())
ans = N

for _ in range(N):
    word = input().rstrip()
    pre = [word[0]]
    tmp = word[0]
    for c in word[1:]:
        if c == tmp:
            continue
        if c not in pre:
            pre.append(c)
            tmp = c
        else:
            ans -= 1
            break

print(ans)

이전의 문자를 tmp변수에 담아둠과 동시에 이전에 나온 기록을 pre 배열에 담아두었다.

단어의 알파벳을 하나씩 비교하며 답을 찾아내는 방식으로 문제를 해결했다.

~~(진하게 느껴지는 하드코딩의 냄새...)~~

for문을 돌려 문제가 없다면 ans 가 1씩 늘어나는 방향으로 코드를 작성하려는 생각었다.

하지만 해당 방법을 사용하려면 for 문에 flag와 같은 추가적인 boolean 타입 변수 등을 포함시켜야 했다.

코드가 지저분해지는 것이 싫다면 for else 와 같은 조금 구닥다리(?) 같은 문법을 사용해야하는데...

공식문서에서도 for else는 가독성을 위해 비추천하는 아주 안 좋은 방식이다.

그래서 ans 값을 N으로 초기화하고 역으로 빼는 방법으로 문제를 해결했다.

코드를 완성하고 통과는 했는데... 맘에 안 든다.

다른 사람 풀이가 궁금해서 찾아보았다.

if list(word) == sorted(word, key=word.find):

이런 식으로 비교하면 코드가 굉장히 간단하고 직관적이게 된다.

좋은 풀이이다.

역시 문제를 풀고 다른 분들이 어떻게 풀었는지 확인해보고 내 코드와 비교하는게 실력 향상에 좋다.

백준 2525번 Python

CodeChronicle — Sun, 5 Jan 2025 13:54:01 +0900

백준 2525번 Python

https://www.acmicpc.net/problem/2525

문제

KOI 전자에서는 건강에 좋고 맛있는 훈제오리구이 요리를 간편하게 만드는 인공지능 오븐을 개발하려고 한다.

인공지능 오븐을 사용하는 방법은 적당한 양의 오리 훈제 재료를 인공지능 오븐에 넣으면 된다.

그러면 인공지능 오븐은 오븐구이가 끝나는 시간을 분 단위로 자동적으로 계산한다.

또한, KOI 전자의 인공지능 오븐 앞면에는 사용자에게 훈제오리구이 요리가 끝나는 시각을 알려 주는 디지털 시계가 있다.

훈제오리구이를 시작하는 시각과 오븐구이를 하는 데 필요한 시간이 분단위로 주어졌을 때, 오븐구이가 끝나는 시각을 계산하는 프로그램을 작성하시오.

입력

첫째 줄에는 현재 시각이 나온다.

현재 시각은 시 A (0 ≤ A ≤ 23) 와 분 B (0 ≤ B ≤ 59)가 정수로 빈칸을 사이에 두고 순서대로 주어진다.

두 번째 줄에는 요리하는 데 필요한 시간 C (0 ≤ C ≤ 1,000)가 분 단위로 주어진다.

출력

첫째 줄에 종료되는 시각의 시와 분을 공백을 사이에 두고 출력한다.

(단, 시는 0부터 23까지의 정수, 분은 0부터 59까지의 정수이다. 디지털 시계는 23시 59분에서 1분이 지나면 0시 0분이 된다.)

풀이

import sys
input = sys.stdin.readline

H, M = map(int, input().rstrip().split())
C = int(input().rstrip())

M += C
H += M // 60
M = M % 60
H = H % 24
print(H, M)

간단한 진법변환 문제였다.

60분 이상이면 시간으로 24시간 이상이면 0으로 초기화하는 과정을 쭉 코드로 작성하면 된다.

/ 대신 //써주는 것만 유의하면 문제될 것이 없다.

백준 1793번 Python

CodeChronicle — Fri, 3 Jan 2025 19:19:58 +0900

백준 1793번 Python

https://www.acmicpc.net/problem/1793

문제

2×n 직사각형을 2×1과 2×2 타일로 채우는 방법의 수를 구하는 프로그램을 작성하시오.

아래 그림은 2×17 직사각형을 채운 한 가지 예이다.

입력

입력은 여러 개의 테스트 케이스로 이루어져 있다.

각 테스트 케이스는 한 줄로 이루어져 있으며, 정수 n이 주어진다.

출력

입력으로 주어지는 각각의 n마다, 2×n 직사각형을 채우는 방법의 수를 출력한다. (0 ≤ n ≤ 250)

풀이

"""백준에서 정답으로 인정하는 코드"""
import sys
input = sys.stdin.readline


DP = [0 for _ in range(251)]
DP[0] = 1
DP[1] = 1

for i in range(2,251):
    DP[i] = DP[i-1] + 2*DP[i-2]

while (True):
    try:
        n = int(input().rstrip())
        print(DP[n])
    except:
        break

문제를 보자마자 생각나는 DP풀이법이다.

~~노트에 하나하나 그려서 세어본건 안 비밀~~

숫자에서 규칙을 찾아 DP풀이법으로 문제를 해결했다.

DP는 수학에서 점화식 풀이를 알고리즘 문제 풀이에 적용한 것이라고 생각하면 편하다.

이 문제에서 어렵게 느껴질 수 있는 부분이 2가지가 있다.

첫 번째로는 DP풀이를 생각해내는 것이다.

알고리즘 문제를 좀 풀어봤다 하는 사람들이라면 문제를 보자마자 DP가 생각나는 문제이다.

그에 반해 DP문제를 처음 접한 사람이라면 감도 안 잡힐 수 있다고 생각한다.

많이 풀어보는 방법밖에 없는 것 같다.

두 번째로는 대부분의 백준 문제와 다르게 입력값의 제한이 없다는 것이다.

대부분 백준 문제들은 N과 같은 반복실행 횟수를 입력값으로 제공한다.

다만, 해당 문제에서는 반복실행 횟수가 정해져 있지 않고 while과 try except 구문으로 입력값이 없을 때를 구분하여 프로그램을 종료하여야 한다.

이 문제에는 그보다 더 큰 문제가 있다.

2*n 범위에서 n이 0일 때 답이 무엇이라고 생각하는가?

타일이 들어갈 공간이 존재하지 않으므로 0이 맞는 풀이라고 생각한다.

필자도 그렇게 생각하고 다음과 같은 코드를 제출했다.

"""내가 생각하는 옳은 풀이 (백준에서 통과 안 됨)"""
import sys
input = sys.stdin.readline


DP = [0 for _ in range(251)]
DP[0] = 1
DP[1] = 1

for i in range(2,251):
    DP[i] = DP[i-1] + 2*DP[i-2]

while (True):
    try:
        n = int(input().rstrip())
        if n == 0:
            print(0)
        else:
            print(DP[n])
    except:
        break

결과를 확인해보자

???

숨쉴틈도 없이 '틀렸습니다'를 출력한다.

처음에는 어디에 문제가 있나 코드를 다시 봤다.

~~분명 맞는 것 같은데...~~

질문게시판에서 찾은 답변이다.

바로 예외처리 부분을 삭제하고 제출해 봤다.

이게 왜 맞지?

컴퓨터구조 - 디지털 논리회로

CodeChronicle — Fri, 3 Jan 2025 18:08:59 +0900

디지털 컴퓨터

디지털 컴퓨터는 0과 1의 두 개로 숫자만을 사용하는 이진수 시스템이다.

하나의 이진숫자를 bit라고 부르며, 디지털 컴퓨터에서 정보는 비트들의 그룹으로 표현한다.

비트 그룹을 통해 숫자와 문자등을 표현한다.

컴퓨터는 주로 하드웨어와 소프트웨어의 두 부분으로 나뉜다.

하드웨어는 전자부품과 주변 장치를 구성하는 전자기적 부품이다.
소프트웨어는 컴퓨터의 다양한 정보처리 작업을 수행하는 명령어와 데이터들로 구성된다.

논리 게이트

디지털 컴퓨터에서 이진 정보는 물리량인 전압 신호를 이용하여 0과 1로 표현된다.

이진 정보의 처리는 게이트(gate)라 불리는 논리 회로에서 행해진다.

게이트는 입력 논리의 필요조건을 만족할 때 1 또는 0의 신호를 만드는 하드웨어의 블럭이다.

각 게이트는 기호가 다르고 그것의 동작은 대수 함수의 방법으로 표시된다.

Name	Graphic symbol	Algebraic function	Truth table
AND		x = A * B or x = AB
OR		x = A + B
Inverter		x = A'
Buffer		x = A
NAND		x = (AB)'
NOR		x = (A + B)'
Exclusive-OR (XOR)		x = A ⊕ B or x = A'B + AB'
Exclusive-NOR or equivalence		x = (A ⊕ B)' or x = A'B' + AB

[이미지 출처] https://en.wikipedia.org/wiki/Logic_gate

Logic gate - Wikipedia

From Wikipedia, the free encyclopedia Device performing a Boolean function A logic circuit diagram for a 4-bit carry lookahead binary adder design using only the AND, OR, and XOR logic gates. A logic gate is a device that performs a Boolean function, a log

en.wikipedia.org

부울 대수

부울 대수는 이진 변수와 논리 동작을 취급하는 대수이다.

EX) F = x + y'z

부울 대수의 목적은 디지털 회로의 해석과 설계를 쉽게 하는 데 있다.

(1) x + 0 = x

(3) x + 1 = 1

(5) x + x = x

(7) x + x' = 1

(9) x + y = y + x

(11) x + (y + z) = (x + y) + z

(13) x(y + z) = xy + xz

(15) (x + y)' = x'y'

(17) (x')' = x

(2) x * 0 = 0

(4) x * 1 = x

(6) x * x = x

(8) x * x' = 0

(10) xy = yx

(12) x(yz) = (xy)z

(14) x + yz = (x + y)(x + z)

(16) (xy)' = x' + y'

De Morgan 정리

논리 연산에서 논리합은 논리곱과 부정기호로, 논리곱은 논리합과 부정기호로 표현할 수 있음을 가리키는 법칙이다.

not (A or B) = (not A) and (not B)
not (A and B) = (not A) or (not B)

맵의 간소화

진리표로부터 논리 표현식을 얻게 된다.

논리표현식은 부울 대수를 사용해서 간단히 만들 수 있으나 여러 가지 규칙이 있다.

맵(Map) 방법은 부울 함수를 곧바로 간소화할 수 있다.

진리표에서 변수의 각 조합을 minterm이라 한다.

[K-map(카르노 맵)에 대한 사이트] https://en.wikipedia.org/wiki/Karnaugh_map

Karnaugh map - Wikipedia

From Wikipedia, the free encyclopedia Graphical method to simplify Boolean expressions An example Karnaugh map. This image actually shows two Karnaugh maps: for the function ƒ, using minterms (colored rectangles) and for its complement, using maxterms (gr

en.wikipedia.org

진리표에서 출력 F가 1이 되는 minterm만을 뽑으면 SOP(sum of products)을 유도할 수 있다.

논리합의 논리곱 (POS)

이전에 유도한 부울 함수는 SOP(sum of products) 즉, 논리곱의 논리합이다.

다만 경우에 따라 POS(product of sums) 논리합의 논리곱을 사용하는 것이 유리할 때가 있다.

이러한 경우 함수가 0이 되는 minterm에 0을 넣고 인접한 0을 크게 묶는다.

F'를 구할 수 있는데 이때 De Morgan 정리에 의하여 F = (F')'을 얻는다.

Don't care 조건

map에 minterm 구역에는 0 또는 1이 들어가는데, minterm 이 0 또는 1이 되는 것과 관계없이 같은 함숫값을 가지는 경우가 있다.

이런 don't care를 맵에서는 X로 집어넣고 간소화시키기 위하여 묶는데 편히라도록 이를 편의에 따라 1 또는 0으로 본다.

묶는데 유리한 방향으로 생각하면 된다.

조합 회로

조합 회로는 입력과 출력을 가진 논리 게이트의 집합이다.

반가산기

반가산기(half-adder)는 비트 두 개를 가산하는 조합회로이다.

두 개의 비트를 x, y라 할 때 가산을 위한 논리 표현식은 다음과 같다.

S : Sum
C : Carry

S = x'y + xy' = x ⊕ y
C = xy

전가산기

전가산기(full-adder)는 비트 두 개와 밑에서 올라오는 Carry까지 고려한 비트 세 개의 가산 조합회로이다.

두 개의 반가산기로 구성된다.

S = x ⊕ y ⊕ z
C = xy + (x ⊕ y)z

[가산기에 대한 사이트] https://en.wikipedia.org/wiki/Adder_(electronics)

Adder (electronics) - Wikipedia

From Wikipedia, the free encyclopedia Digital circuit that produces sums from inputs An adder, or summer,[1] is a digital circuit that performs addition of numbers. In many computers and other kinds of processors, adders are used in the arithmetic logic un

en.wikipedia.org

플립플롭

플립플롭은 한 비트의 정보를 저장하는 이진 셀이다.

플립플롭은 입력 펄스가 상태 변환을 일으키기 전까지 이진 상태를 그대로 유지한다.

입력이 이진 상태에 영향을 미치는 방식에 따라 여러 종류로 분류할 수 있다.

SR flip-flop

Characteristic table

S R Q(t + 1)

0 0 Q(t) No change

0 1 0 Clear 0

1 0 1 Set to 1

1 1 ? Indeterminate

Excitation table

Q(t) Q(t + 1) S R

0 0 0 x

0 1 1 0

1 0 0 1

1 1 x 0

JK flip-flop

Characteristic table

J K Q(t + 1)

0 0 Q(t) No change

0 1 0 Clear 0

1 0 1 Set to 1

1 1 Q'(t) Complement

Excitation table

Q(t) Q(t + 1) J K

0 0 0 x

0 1 1 x

1 0 x 1

1 1 x 0

D flip-flop

Characteristic table

D Q(t + 1)

0 0 Clear 0

1 1 Set to 1

Excitation table

Q(t) Q(t + 1) D

0 0 0

0 1 1

1 0 0

1 1 1

T flip-flop

Characteristic table

D Q(t + 1)

0 Q(t) No change

1 Q'(t) Complement

Excitation table

Q(t) Q(t + 1) T

0 0 0

0 1 1

1 0 1

1 1 0

['Mano의 컴퓨터시스템구조 제 3판' 을 공부하며 작성한 내용입니다.]

백준 22252번 Python

CodeChronicle — Thu, 2 Jan 2025 18:56:09 +0900

백준 22252번 Python

https://www.acmicpc.net/problem/22252

문제

암흑가의 권력은 주먹과 정보에서 나온다.

주먹은 한 명에게 강하고, 정보는 세계를 가지고 놀 수 있기 때문에 호석이는 세상 모든 정보를 모으는 "정보 상인"이 되고 싶다.

정보 상인은 정보를 사고파는 사람을 의미한다.

호석이는 아직 상인계의 새싹이기 때문에, 초기 투자를 통해서 여러 명의 "정보 고릴라"들로부터 정보를 모으려고 한다.

정보 고릴라란 여기저기서 정보를 수집하는 사람들을 의미한다.

일단 정보를 긁어모으기 위해서 호석이는 여러 정보 고릴라들에게 정보를 구매하려고 한다.

암흑가의 연락망은 뻗어 있기 때문에 누가 어떤 정보를 얻었는지에 대한 찌라시들이 수시로 퍼진다.

찌라시로 알 수 있는 것은, 어떤 이름을 가진 고릴라가 C₁, C₂, …, C_k 만큼의 가치가 있는 정보 k개를 얻었다는 점이다.

호석이는 이를 바탕으로 임의의 시점에 특정 고릴라에게 정보를 몇 개 살 것인지를 정할 수 있다.

이때 가치 순으로 가장 비싼 정보를 구매한다.

예를 들어 고릴라가 가진 정보가 10개이고, 호석이가 사고 싶은 정보 개수가 4개라면, 고릴라는 10개 중에서 가치 순으로 가장 비싼 4개를 팔 것이다.

한 번 거래한 정보는 호석이에게 더 이상 가치가 없기 때문에 고릴라로 그 정보를 파기한다.

당신은 암흑가의 주역이며 양대 산맥이 될 가능성이 있는 호석이를 주시하고 있다.

관찰하면서 얻은 정보는 총 Q개이다. 각 정보는 다음의 2가지 중 하나이다.

1 Name k C₁, C₂, …, C_k : 이름이 [Name]인 고릴라가 k개의 정보를 얻었으며, 각 가치는 C₁부터 C_k이다.

2 Name b : 호석이가 이름이 [Name]인 고릴라에게 b개의 정보를 구매한다.
이때 고릴라가 가진 정보들 중 가장 비싼 b개를 구매하며, 고릴라가 가진 정보가 b개 이하이면 가진 모든 정보를 구매한다.

결과를 위해서 호석이가 가진 정보들의 가치 총합, 즉 호석이가 정보들을 구매하는 데에 쓴 돈의 총합을 구하자.

입력

고릴라들이 정보를 얻는 사건과 호석이가 거래하는 정보가 시간순으로 주어진다.

첫 번째 줄에는 쿼리의 개수 Q가 주어진다.

이어서 Q개의 줄에 걸쳐서 각 줄에 쿼리가 주어진다. 쿼리는 1이나 2로 시작한다.

1로 시작하는 경우에는 정보를 얻은 정보 고릴라의 이름과 k가 주어지며, 이어서 k개의 정보 가치 C₁, …, C_k가 자연수로 주어진다.

모든 C_i는 1 이상 100,000 이하이다.

2로 시작하는 경우에는 호석이가 거래하려는 정보 고릴라의 이름과 구매하려는 정보의 개수 b가 주어진다.

출력

모든 쿼리가 종료되었을 때에 호석이가 얻게 되는 정보 가치의 총합을 출력하라.

풀이

import sys
import heapq
from collections import deque
input = sys.stdin.readline


Q = int(input().rstrip())
Gorilla = dict()
ans = 0

for _ in range(Q):
    tmp = deque(input().rstrip().split())
    cur_Q = int(tmp.popleft())
    name = tmp.popleft()
    if cur_Q == 1:
        if name not in Gorilla.keys():
            Gorilla[name] = list()
        n = int(tmp.popleft())
        for value in tmp:
            heapq.heappush(Gorilla[name], -int(value))
    else:
        if name not in Gorilla.keys():
            continue
        n = int(tmp.popleft())
        for _ in range(n):
            if len(Gorilla[name]) == 0:
                break
            ans += -heapq.heappop(Gorilla[name])

print(ans)

문제가 긴 편인데 요약하자면 1의 경우에는 저장, 2는 출력하라는 말을 길게 써놓은 것이다.

출력 할 때는 가치(숫자)가 높은 순서대로 pop하여 출력하면 된다.

입력값을 원하는대로 재단하기 편하도록 deque자료형을 사용했다.

deque 자료형은 Double-ended queue 로 양쪽 끝에서 자료의 삽입과 삭제가 가능하다.

해당 문제에서는 앞에 나오는 데이터에 따라 name 뒤에 나오는 숫자의 활용이 달라진다.

때문에 앞에 나오는 데이터를 먼저 처리해주었다.

{key1 : list(), key2 : list()} 의 형태로 데이터를 보관하기 위해 이름을 확인하고 해당 key(name)값이 존재하는지 검증하는 과정을 삽입하였다.

1의 경우 즉, 데이터를 추가하는 경우 name에 해당하는 key값이 존재하지 않다면 dictionary에 새로운 key에 대한 공간을 할당했다.

2의 경우 데이터를 추출하는 과정이므로 name에 해당하는 key값이 존재하지 않다면 데이터 또한 존재하지 않기 때문에 해당 루프를 넘기도록 continue 하였다.

데이터를 입출력하는 과정에서는 heapq 라이브러리를 활용하여 최대 힙을 구현하였다.

heapq 라이브러리에서 최대 힙을 따로 제공하지는 않기 때문에 값을 음수로 변환하여 입출력하는 방식으로 최대힙을 구현하였다.

숫자 그대로 입력한다면 숫자가 작은 값이 우선순위이기 때문에 마이너스를 붙혀 추가하면 우선순위를 뒤집을 수 있다.

ex) 3과 7 이 있을 때 3이 우선순위가 높지만 -3과 -7로 변환하면 -7이 우선순위가 높다.

마지막으로 2 (데이터를 추출하는) 과정에서 해당 key에 해당하는 value가 더이상 존재하지 않다면 루프를 중단했다.

코드가 다소 복잡해보일 수 있지만 여러 자료형을 활용했을 뿐 난해한 풀이과정을 아니라고 생각한다.

다른 풀이도 확인해보았는데, 굳이 heapq를 활용하지 않고 리스트 정렬을 통해서 문제를 풀어도 충분히 통과할 수 있는 문제이기는 했다.

백준 32867번 Python

CodeChronicle — Thu, 2 Jan 2025 17:15:00 +0900

백준 32867번 Python

https://www.acmicpc.net/problem/32867

문제

컴스 최고의 피아니스트 예원이는 오른손만으로도 모든 곡을 연주할 수 있다.

비결은 손을 최대한 조금 움직이는 것이다.

예원이가 연주하는 피아노에는 200000개의 흰건반만 있으며,

가장 왼쪽 건반부터 순서대로 1, 2, …, 200000까지의 번호가 차례대로 매겨져 있다.

예원이의 손 길이는 한 건반 K개만큼이며,

다음에 치려는 건반이 손 안에 있다면 손을 움직이지 않고 다음 음을 낼 수 있다.

예를 들어, 손 길이가 건반 5개만큼이고 오른손 엄지를 1번 건반에 두었다면 1번 건반부터 5번 건반까지는 손을 움직이지 않고 칠 수 있지만, 이 범위를 벗어나는 건반을 누르려면 손을 다른 위치로 움직여야 한다.

다음 곡을 연주하려면 N개의 흰건반을 순서대로 눌러야 한다.

예원이는 원하는 위치에 손을 두고 연주를 시작하며, 연주 중 필요할 때만 손을 움직일 것이다.

하지만 예원이는 수많은 과제에 시달리느라 악보를 분석할 시간이 없다.

바쁜 예원이를 대신 곡을 연주하기 위해 손을 옮겨야 하는 최소 횟수를 구하는 프로그램을 작성해 주자!

입력

첫째 줄에 두 정수 N, K가 공백으로 구분되어 주어진다. (1 ≤ N ≤ 200000; 1 ≤ K ≤ 1000)

둘째 줄에는 눌러야 하는 건반의 번호 a1, a2, …, aN이 공백으로 구분되어 주어진다.

이는 i번째로 누르는 건반이 a_i번 건반이라는 의미이다. (1 ≤ a_i ≤ 200000)

출력

첫째 줄에 손을 옮겨야 하는 최소 횟수를 출력한다.

풀이

import sys
input = sys.stdin.readline


N, K = map(int, input().rstrip().split())
A = list(map(int, input().rstrip().split()))

left_p = A[0]
right_p = A[0]
ans = 0

for i in A:
    if left_p <= i <= right_p:
        continue

    if i > right_p:
        right_p = i
    else:
        left_p = i

    if right_p - left_p >= K:
        ans += 1
        left_p = i
        right_p = i

print(ans)

손을 움직여야 하는 횟수를 최소로 하는 문제이다.

문제에서 손의 크기는 K로 주어졌고 left_p, right_p 라는 두 가지 변수의 차가 K를 넘지 않도록 최적의 손 위치를 찾으면 된다.

list A에서 값을 하나씩 불러와 left_p 와 right_p 범위 안에 있다면 손을 움직일 필요가 없으므로 continue로 빠르게 다음 값을 불러오도록 한다.

(불필요한 코드진행을 줄여 실행시간을 단축)

이 외의 경우 right_p값 또는 left_p값을 i로 설정하여 손이 움직여야 하는 일정범위를 고정해준다.

이때 left_p 와 right_p 범위가 K를 넘어간다면 다음 건반진행을 위해 반드시 손을 움직여야하므로 ans값을 증가시키고, left_p 와 right_p 값을 i로 초기화한다.

다음 과정을 반복하면 ans 변수에 손을 옮겨야 하는 최소 횟수를 담을 수 있다.

백준 15740번 Python

CodeChronicle — Thu, 2 Jan 2025 16:09:12 +0900

백준 15740번 Python

https://www.acmicpc.net/problem/15740

문제

두 정수 A와 B를 입력받은 다음, A+B를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 A와 B (-10¹⁰⁰⁰⁰ ≤ A, B ≤ 10¹⁰⁰⁰⁰) 가 주어진다.

출력

첫째 줄에 A+B 를 출력한다.

풀이

import sys
input = sys.stdin.readline


print(sum(map(int, input().split())))

입력과 동시에 출력을 해보았다.

파이썬은 큰 수 연산을 지원하기 때문에 어렵지 않게 풀이할 수 있다.

백준 11811번 Python

CodeChronicle — Mon, 30 Dec 2024 18:11:21 +0900

백준 11811번 Python

https://www.acmicpc.net/problem/11811

문제

젊은 제다이 이번의 임무는 데스타에 침투하여 파괴하는 일이다.

데스타를 파괴하기 위해서는 길이 N의 음이 아닌 정수 수열 a_i가 필요하다.

그러나 이번은 이 수열을 가지고 있지 않다.

대신 그에게는 오랜 친구 다스 베이더에게 받은 쪽지가 하나 있다.

이 쪽지에는 그 수열이 만족해야 하는 조건이 적혀 있다.

이 쪽지에는 크기 N의 정사각 행렬이 있는데, i번째 행 j번째 열에 적힌 숫자는 a_i와 a_j에 비트연산 and를 수행한 결과값이다.

하지만 안타깝게도 광선검에 의해 쪽지가 손상되었고 이번은 행렬의 주 대각선에 있는 숫자를 읽을 수 없게 되었다.

원래 배열을 재구성하여 임무를 수행해야 하는 이번을 도와주자.

답은 유일하지 않을 수 있지만, 항상 존재하도록 주어진다.

입력

입력의 첫 번째 줄에는 행렬의 크기 N (1 ≤ N ≤ 1 000)이 주어진다.

다음 N개의 줄에는 행렬의 각 원소인 N개의 숫자 m_ij (1 ≤ m_ij ≤ 10⁹)가 주어진다.

출력

정확히 한 줄에 문제의 조건을 만족하는 N개의 음이 아닌 정수를 출력한다.

각 정수는 10⁹보다 같거나 작아야 한다. 답이 여러 개인 경우 아무거나 출력한다.

풀이

import sys
input = sys.stdin.readline


N = int(input().rstrip())
array = [list(map(int, input().rstrip().split())) for _ in range(N)]
nums = [0 for _ in range(N)]

for i in range(N):
    for j in range(i,N):
        if array[i][j] == 0:
            continue
        nums[i] |= array[i][j]
        nums[j] |= array[i][j]

print(*nums)

입력에서 주어진 행렬은 수열 A를 기반으로 생성된 정사각행렬이다.

문제의 목표인 수열 A를 구하기 위해 주어진 정사각행렬을 통해 역추론 해보자.

정사각행렬에서 주 대각선에 해당하는 값은 읽을 수 없고 m_ij와 m_ji는 동일한 값을 가진다.

때문에 다음과 같이 반복문을 돌려준다.

for i in range(N):
for j in range(i,N):

array[i][j] == A_i & A_j 이므로 A_i와 A_j는 nums[i] |= array[i][j], nums[j] |= array[i][j] 다음과 같이 구해 줄 수 있다.

(array는 행렬을 nums는 수열 A를 나타낸다.)

조금 풀어서 쉽게 설명해보자.

A_i 와 A_j 의 각 비트에서 공통으로 1의 값을 가지는 비트만 1의 값을 값을 가진다.

이는 array[i][j] 에서 1로 표현된 비트는 해당하는 수열값에서 항상 1을 가진다는 것으로 해석 할 수 있다.

(이해가 안 된다면 비트연산에 대한 개념을 찾아보는 것을 추천한다.)

이 과정을 반복하면 수열 A를 유추할 수 있다.

다만, 답은 여러가지가 있을 수 있다.

~~(함수를 미분하고 다시 적분했을 때 적분상수의 정확한 값을 알 수 없는 것과 같은 느낌이다.)~~

마지막으로 무의미한 연산과정을 줄이기 위해 행렬의 값이 0인 경우에는 과정을 생략하도록 한다.

(행렬의 값이 0 이라면 or 연산을 해도 같은 값이 나온다.)

import sys
input = sys.stdin.readline

N = int(input().rstrip())
for _ in range(N):
    print(max(list(map(int, input().rstrip().split()))), end=' ')

문제를 풀다 생각난 또 다른 풀이이다.

문제에서 요구하는 방식은 아니지만 해당 문제를 해결하는데 문제가 없다.

이렇게 쉽게 풀 수 있는 문제였다니...

기존 코드

또 다른 풀이

심지어 실행시간도 짧고 메모리도 적게 차지한다.

백준 25550번 Python

CodeChronicle — Wed, 25 Dec 2024 17:00:57 +0900

백준 25550번 Python

https://www.acmicpc.net/problem/25550

문제

포스텍에서는 기숙사 퇴사날이면 학생들이 집으로 보내는 택배 상자가 가득 쌓인다.

택배를 놓는 곳은 N행 M열로 이루어진 격자로 표현된다.

격자의 각 칸은 크기 1의 정사각형 모양이며, 모든 택배 상자는 부피 1의 직육면체 형태이다.

온통 칙칙한 색의 택배 상자들을 보고 따분함을 느낀 포닉스는 택배 상자들을 옮기지 않고

보이는 모든 면에 붉은색 페인트를 칠하려 한다.

이 때, 보이는 면이란 다른 상자 또는 바닥과 닿아있지 않은 면을 말한다.

포닉스가 페인트칠을 마친 후, 어떤 면에도 페인트가 칠해져 있지 않은 택배 상자의 수를 구해 보자.

입력

첫째 줄에 격자의 행의 수 N, 열의 수 M이 주어진다. (1 ≤ N, M ≤ 1000)

이후 둘째 줄부터 N줄에 걸쳐 각 줄에 M개의 수가 주어진다.

i번째 줄의 j번째 수는 i번째 행 j번째 열에 해당하는 칸에 쌓인 택배 상자의 수 A_ij이다. (0 ≤ A_ij ≤ 10⁹)

출력

페인트칠을 마친 후, 어떤 면에도 페인트가 칠해져 있지 않은 택배 상자의 수를 출력한다.

풀이

import sys
input = sys.stdin.readline


N, M = map(int, input().rstrip().split())
array = [list(map(int, input().rstrip().split())) for _ in range(N)]

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

answer = 0

for y in range(1, N-1):
    for x in range(1, M-1):
        if array[y][x] == 0:
            continue
        cur = array[y][x] - 1
        for i in range(4):
            ny = y + dy[i]
            nx = x + dx[i]
            if array[ny][nx] < cur:
                cur = array[ny][nx]
        answer += cur

print(answer)

일단 문제의 입력값을 받아 각 변수와 배열에 넣어주었다.

문제를 해결하기 위해 조건을 다시 살펴보자.

보이는 모든면에 페인트를 칠한다.
어떤 면에도 페이트가 칠해지지 않은 상자의 수를 구하라.

어떤 면에도 페인트가 칠해지지 않았다는 것은 정육면체의 6면 모두 겉에서 보이지 않는다는 것이다.

그러므로 첫번째 행과 열 마지막 행과 열은 확인 할 필요가 없다.

(가장 바깥쪽 박스이기 때문이다.)

이 조건을 다음과 같이 표현되었다.

for y in range(1, N-1):
for x in range(1, M-1):

나머지 배열에 대하여 해당 지점의 동서남북 그리고 자신 - 1 (맨 위의 박스 제외) 중

가장 작은 값을 채택하는 과정을 반복하면 올바른 출력을 도출할 수 있다.

여기까지가 문제 풀이에 대한 아이디어이다.

다음으로 해당 아이디어를 코드로 구현해보자.

가장 중요한 파트인 상하좌우를 확인하는 부분은 해당 코드를 사용하였다.

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

for i in range(4):
    ny = y + dy[i]
    nx = x + dx[i]

배열에서 주변의 박스 개수를 확인하며 최소인 값을 확인하는 과정을 거쳤다.

이를 종합하면 다음과 같은 코드가 완성된다.

""" 미완성 코드 """
N, M = map(int, input().rstrip().split())
array = [list(map(int, input().rstrip().split())) for _ in range(N)]

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

answer = 0

for y in range(1, N-1):
    for x in range(1, M-1):
        cur = array[y][x] - 1
        for i in range(4):
            ny = y + dy[i]
            nx = x + dx[i]
            if array[ny][nx] < cur:
                cur = array[ny][nx]
        answer += cur

print(answer)

하지만 코드를 제출해도 통과되지 않는다.

예외처리를 해주지 않았기 때문이다.

현재 지점의 박스 개수에서 -1 한 값을 채택하는 부분이 있는데,

만약 해당 지점의 박스 개수의 초기값이 0이라면 -1로 초기화되는 예외가 발생한다.

예외처리까지 해주면 다음과 같은 코드가 완성된다.

import sys
input = sys.stdin.readline


N, M = map(int, input().rstrip().split())
array = [list(map(int, input().rstrip().split())) for _ in range(N)]

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

answer = 0

for y in range(1, N-1):
    for x in range(1, M-1):
        if array[y][x] == 0:
            continue
        cur = array[y][x] - 1
        for i in range(4):
            ny = y + dy[i]
            nx = x + dx[i]
            if array[ny][nx] < cur:
                cur = array[ny][nx]
        answer += cur

print(answer)

앞으로도 dfs,bfs 등등 다양한 알고리즘 문제에서 활용될 코드 구조이다.

백준 14581번 Python

CodeChronicle — Wed, 25 Dec 2024 15:28:41 +0900

백준 14581번 Python

https://www.acmicpc.net/problem/14581

문제

홍준은 참 팬이 많다. 이를 본 구사과는 BOJ 슬랙에서 이모티콘을 만들었다.

선풍기 모양의 이모티콘은 :fan: 이고, 홍준의 이모티콘은 :(홍준의 아이디): 이다.

홍준의 아이디가 주어지면 구사과가 만든 이모티콘을 출력하는 프로그램을 작성하여라.

자세한 출력 방식은 입출력 형식을 참고하면 된다.

입력

첫 번째 줄에 홍준의 아이디를 입력받는다.

홍준의 아이디는 길이가 20 이하인 문자열이며, 알파벳 소문자, 알파벳 대문자, 숫자로만 이루어졌다.

출력

3개의 줄에 걸쳐, 팬들에게 둘러싸인 홍준의 모습을 출력한다.

풀이

import sys
input = sys.stdin.readline

id = input().rstrip()
print(""":fan::fan::fan:
:fan::%s::fan:
:fan::fan::fan:
"""%id)

따옴표 3개를 이용해서 여러 줄을 한 번에 출력했다.

print(":fan::fan::fan:")

print(":fan::%s::fan:"%id)

print(":fan::fan::fan:")

다음과 같이 출력해도 문제는 없지만 따옴표 3개를 활용하면 조금 더 직관적으로 볼 수 있다.

물론 처음에는 출력형식을 지키지 않고 다음과 같이 코드를 작성했다.

import sys
input = sys.stdin.readline

id = input().rstrip()
print(
"""
:fan::fan::fan:
:fan::%s::fan:
:fan::fan::fan:
"""
%id
)

'출력 형식이 잘못되었습니다' 문구와 함께 오답처리되었다...

브론즈 5 문제라면 문자열 format도 설명하고 넘어가야 할 것 같다.

%s : 문자열
%d : 정수
%c : 문자 1개
%f : 부동 소수
%o : 8 진수
%x : 16 진수
%% : '%' 자체를 출력

str = "출력"
print("문자열 %s은 이렇게 하는겁니다." %str)

"""
----------Output------------
문자열 출력은 이렇게 하는겁니다.
----------------------------
"""

한 번 알아두면 출력형식 맞출 때 편하다.

백준 20115번 Python

CodeChronicle — Tue, 24 Dec 2024 17:20:47 +0900

백준 20115번 Python

https://www.acmicpc.net/problem/20115

문제

페인은 에너지 드링크를 좋아하는 회사원이다.

에너지 드링크는 카페인, 아르기닌, 타우린, 나이아신 등의 성분이 들어있어

피로 회복에 도움을 주는 에너지 보충 음료수이다.

야근을 마치고 한밤중에 퇴근하니 벌써 새벽 1시.

하지만 주말은 아직 멀었고, 다음 날에도 정시에 출근해야 하는 페인은 오늘도 에너지 드링크를 찾는다.

반복되는 야근에 지친 나머지, 평소보다 더 많은 에너지와 피로 회복이 필요했던 페인은

집에 있던 에너지 드링크들을 한 데 합쳐서, 하나의 에너지 드링크로 만들어 한 번에 마시려 한다.

페인이 에너지 드링크들을 합치는 과정은 다음과 같다.

임의의 서로 다른 두 에너지 드링크를 고른다.

한쪽 에너지 드링크를 다른 쪽 에너지 드링크에 모두 붓는다.
단, 페인은 야근 후유증으로 인해 손이 떨려, 붓는 과정에서 원래 양의 절반을 바닥에 흘리게 된다.

다 붓고 남은 빈 에너지 드링크는 버린다.

1~3 과정을 에너지 드링크가 하나만 남을 때까지 반복한다.

예를 들어, 두 에너지 드링크 a, b가 있고, 양이 각각 x_a, x_b라 할 때, 다음 둘 중 하나의 선택을 할 수 있다.

a의 양을 x_a + (x_b/2)로 만들고, b를 버리기

b의 양을 x_b + (x_a/2)로 만들고, a를 버리기

페인은 합쳐진 에너지 드링크의 양을 최대로 하려 한다. 불쌍한 페인을 도와주자!

입력

첫째 줄에 페인이 가지고 있는 에너지 드링크의 수 N이 주어진다. (2 ≤ N ≤ 10⁵)

둘째 줄에 각 에너지 드링크의 양이 공백으로 구분되어 주어진다.

i번째 정수 x_i (1 ≤ x_i ≤ 10⁹)는 에너지 드링크 i의 양이 x_i임을 의미한다.

출력

첫째 줄에 페인이 최대로 만들 수 있는 에너지 드링크의 양을 출력한다.

절대/상대 오차는 10^-5까지 허용한다.

풀이

import sys
input = sys.stdin.readline

N = int(input().rstrip())
drink = list(map(int, input().rstrip().split()))
M = max(drink)
print(M + (sum(drink)-M)/2)

정말 간단한 풀이이다.

~~(이게 실버3 문제가 맞나?)~~

문제를 보면 '에너지 드링크를 합칠 때 붓는 과정에서 원래 양의 절반을 바닥에 흘리게 된다' 라는 조건이 있다.

이 말은 '에너지드링크를 옮길때마다 양이 1/2배가 된다'라고 해석할 수 있다.

에너지 드링크의 양을 최대로하기 위해서 옮기는 과정에서의 손실을 줄여야한다.

가장 양이 많은 에너지드링크에 나머지를 하나씩 붓는 방식을 생각할 수 있었다.

결과적으로 <가장 양이 많은 에너지 드링크> + <나머지의 절반> 이 문제에서 요구하는 출력임을 알 수 있다.

이 문제에서 유일하게 유의해야할 점이 하나 있다.

코드를 작성할 때 관성적으로 나누기 표현을 //로 하면 소수점 표기가 안 된다.

(//는 정수인 몫을 반환하기 때문에 소수점이 표현이 안 된다.)

백준 24314번 Python

CodeChronicle — Tue, 24 Dec 2024 15:57:16 +0900

백준 24314번 Python

https://www.acmicpc.net/problem/24314

문제

오늘도 서준이는 점근적 표기 수업 조교를 하고 있다.

아빠가 수업한 내용을 학생들이 잘 이해했는지 문제를 통해서 확인해 보자.

알고리즘의 소요 시간을 나타내는 Ω-표기법(빅-오메가)을 다음과 같이 정의한다.

Ω(g(n)) = {f(n) | 모든 n ≥ n0에 대하여 c × g(n) ≤ f(n)인 양의 상수 c와 n0가 존재한다}

이 정의는 실제 Ω-표기법(https://en.wikipedia.org/wiki/Big_O_notation)과 다를 수 있다.

함수 f(n) = a1n + a0, 양의 정수 c, n0가 주어질 경우 Ω(n) 정의를 만족하는지 알아보자.

입력

첫째 줄에 함수 f(n)을 나타내는 정수 a1, a0가 주어진다. (0 ≤ |ai| ≤ 100)

다음 줄에 양의 정수 c가 주어진다. (1 ≤ c ≤ 100)

다음 줄에 양의 정수 n0가 주어진다. (1 ≤ n0 ≤ 100)

출력

f(n), c, n0가 Ω(n) 정의를 만족하면 1, 아니면 0을 출력한다.

풀이

""" 첫 번째 정답 코드 """
import sys
input = sys.stdin.readline

a1, a0 = map(int, input().rstrip().split())
c = int(input().rstrip())
n0 = int(input().rstrip())

ans = 1
for i in range(n0, 101):
    if (c*i)>(a1*i+a0) :
        ans = 0
        break

print(ans)

문제를 그대로 따라 코드로 작성하면 다음과 같은 코드가 나온다.

n0를 주어진 조건에 따라 하나하나 대입하며 식이 성립하는지 확인하는 방식이다.

해당 문제에서는 주어진 숫자가 작아 문제를 직관적으로 풀어도 문제가 없지만 입력값이 많아진다면 연산에 부담이 간다.

조금 더 나은(?) 코드를 작성하기 위해 수학적 접근을 해보자.

입력 조건을 다시 한번 살펴보자.

첫째 줄에 함수 f(n)을 나타내는 정수 a1, a0가 주어진다. (0 ≤ |ai| ≤ 100)

다음 줄에 양의 정수 c가 주어진다. (1 ≤ c ≤ 100)

다음 줄에 양의 정수 n0가 주어진다. (1 ≤ n0 ≤ 100)

해당 조건을 보고 조금만 생각을 한다면 다음과 같은 코드를 작성할 수 있다.

""" 두 번째 정답 코드 """
import sys
input = sys.stdin.readline

a1, a0 = map(int, input().rstrip().split())
c = int(input().rstrip())
n0 = int(input().rstrip())

print(1 if (c*n0) <= (a1*n0+a0) and (c <= a1) else 0)

모든 값을 확인하지 않고 경곗값 그리고 c와 a1의 관계만 확인해도 Ω(n) 정의를 만족하는지 확인할 수 있다.

3항 연산자 표현이 조금 낯설게 느껴질 수 있다.

잠깐 3항 연산자에 대해 짚어보고 가자.

[condition] ? [true_value] : [flase_vlaue]

많은 언어들은 다음과 같은 삼항 연산자를 지원한다.

다만, 파이썬의 표현방식은 다음과 같다.

[true_value] if [condition] else [false_value]

조건문이 참일 때 true_value를 거짓일 때 false_value를 반환한다.

처음에는 어색할 수 있지만 사용하다 보면 익숙해진다.

코드도 간결해진다.

(~~조금 멋있어 보인다.)~~

각설하고 문제풀이로 돌아가자.

해당문제에서 배운 Big-Omega 표기법(점근적 하한 표기)에 관한 문제였다.

Big-O 표기법(점근적 상한 표기)을 활용해 문제를 바라보자.

첫 번째 코드는 O(n)의 시간복잡도를 가지는 코드이다.

두 번째 코드는 n의 범위가 넓어져도 실행시간이 일정한 O(1)의 시간복잡도를 가지는 코드이다.

해당문제는 n의 범위가 작았기 때문에 실행시간에는 큰 차이가 없지만,

지금부터 효율적인 코드를 작성하는 연습을 해야 이후에 시간제한 조건이 까다로운 문제를 해결할 수 있을 것이다.

Big-O 표기법은 알고리즘 문제를 풀 때 중요한 개념이므로 알아두면 좋을 것 같다.

참고 : https://en.wikipedia.org/wiki/Big_O_notation

Big O notation - Wikipedia

From Wikipedia, the free encyclopedia Describes limiting behavior of a function Example of Big O notation: f ( x ) = O ( g ( x ) ) {\displaystyle {\color {red}f(x)}=O{\color {blue}(g(x))}} as x → ∞ {\displaystyle x\to \infty } since there exists M > 0

en.wikipedia.org

백준 15719번 Python

CodeChronicle — Mon, 23 Dec 2024 18:22:38 +0900

백준 15719번 Python

https://www.acmicpc.net/problem/15719

문제

1부터 N - 1까지의 정수가 하나씩 정렬되지 않은 채로 저장되어 있는 어떤 수열 A가 있다.

수열 A에 임의의 정수 M(1 ≤ M ≤ N – 1)을 넣어 크기가 N인 수열로 만들었을 때,

임의의 정수 M을 찾는 프로그램을 작성하라.

입력

첫째 줄에 수열의 크기 N(2 ≤ N ≤ 10,000,000)이 주어진다.

둘째 줄에 수열 A의 원소인 N개의 정수가 주어진다. 입력으로 주어지는 정수는 모두 1보다 크거나 같고,

N-1보다 작거나 같은 정수이며 문제의 답인 M을 제외하고는 모두 서로 다른 정수이다.

출력

M을 출력하라.

풀이

""" 정답 """

import sys
input = sys.stdin.readline

N = int(input().rstrip())
N_sum = N * (N-1) // 2

nums = input().rstrip()
nums_sum = 0
tmp = ""
for n in nums:
    if n == " ":
        nums_sum += int(tmp)
        tmp = ""
    else:
        tmp += n

nums_sum += int(tmp)

print(nums_sum - N_sum)

해당문제의 메모리제한과 시간제한이 Python은로 풀기에는 적합하지 않은 것 같다.

""" 시간 초과 """

import sys
input = sys.stdin.readline

N = int(input().rstrip())
nums = list(map(int, input().rstrip().split()))
ans = set()

for n in nums:
    if n in ans:
        print(n)
        break
    ans.add(n)

처음에는 다음과 같이 집합을 이용한 방식으로 접근했지만 메모리초과에 걸렸다.

~~메모리와 시간 조건을 만족하기 위해 점점 코드가 지저분해지는데...~~

""" 틀린 풀이 """

import sys
input = sys.stdin.readline

N = int(input().rstrip())
N_sum = N * (N-1) // 2

nums = input().rstrip()
nums_sum = 0
for n in nums:
    if n == " ": continue
    nums_sum += int(n)

print(nums_sum - N_sum)

python에서 int형은 28 bytes으로 메모리를 상당히 많이 잡아먹는다.

N(2 ≤ N ≤ 10,000,000) 최대 1억개의 int형을 리스트에 넣어버리면, 대략 2800MB를 사용해 버린다.

(문제의 메모리 제한은 256MB)

그래서 생각해 낸 방법이 list(map(int, input().split())) 으로 배열에 int형으로 다 넣어버리는 대신 하나씩 int형으로 변환해서 계산하는 방법이다.

다만, 위의 코드대로라면 두 자릿수 숫자를 계산하는 과정에서 문제가 발생한다.

예를 들어 12를 1과 2로 계산해 버린다.

이걸 해결하기 위해 tmp변수를 사용해서 " "

즉, 공백이 나올 때까지 문자열을 더해 공백을 만났을 때 자료형을 변환하여 nums_num에 넘기는 방식을 선택했다.

~~코드가 지저분해져서 정말 하기 싫은 방식이었지만 도저히 다른 방법이 생각이 안 난다.~~

""" 정답 """

import sys
input = sys.stdin.readline

N = int(input().rstrip())
N_sum = N * (N-1) // 2

nums = input().rstrip()
nums_sum = 0
tmp = ""
for n in nums:
    if n == " ":
        nums_sum += int(tmp)
        tmp = ""
    else:
        tmp += n

nums_sum += int(tmp)

print(nums_sum - N_sum)

그렇게 해서 나온 코드

이렇게 해도 python으로 돌리면 시간초과가 뜬다 ㅠㅠ

뭐 어쩔 수 없지 마지막 방법

PyPy3로 돌려서 solved 받아내고 덮어버렸다.

이후에 다른 분들 풀이 살펴보면 sys.stdin.readline 대신 sys.stdin.read 활용해서 푸는 방법도 있었다.

백준 1076번 Python

CodeChronicle — Mon, 23 Dec 2024 16:09:55 +0900

백준 1076번 Python

https://www.acmicpc.net/problem/1076

문제

전자 제품에는 저항이 들어간다.

저항은 색 3개를 이용해서 그 저항이 몇 옴인지 나타낸다.

처음 색 2개는 저항의 값이고, 마지막 색은 곱해야 하는 값이다.

저항의 값은 다음 표를 이용해서 구한다.

예를 들어, 저항의 색이 yellow, violet, red였다면 저항의 값은 4,700이 된다.

입력

첫째 줄에 첫 번째 색, 둘째 줄에 두 번째 색, 셋째 줄에 세 번째 색이 주어진다.

위의 표에 있는 색만 입력으로 주어진다.

출력

입력으로 주어진 저항의 저항값을 계산하여 첫째 줄에 출력한다.

풀이

Resis = ["black", "brown", "red", "orange", "yellow",
         "green", "blue", "violet", "grey", "white"]

ohm = 0
ohm += 10*Resis.index(input().rstrip())
ohm += Resis.index(input().rstrip())
ohm *= 10**Resis.index(input().rstrip())
print(ohm)

index 함수를 활용하였다.

해당 표를 보면 리스트에 색을 나열하였을 때, 색과 값의 관계가 인덱스 값으로 나온다는 것을 알 수 있다.

첫번째와 두번째 입력데이터를 처리하고 세번째 데이터는 10의 제곱이라는 규칙을 이용하여 문제를 해결했다.

Git 명령어

CodeChronicle — Fri, 20 Dec 2024 18:50:26 +0900

Git 주요 명령어

$git init

새로운 Git 저장소를 초기화합니다.
현재 작업 디렉토리를 Git 저장소로 설정하고, 숨김 폴더 .git을 생성합니다.

$git config

Git의 설정을 관리합니다.
사용자 정보 또는 저장소별 설정을 구성합니다.

$git add <file>
$git add .

변경된 파일을 staging 영역에 추가합니다.
현재 디렉토리의 모든 파일을 추가합니다.

$git status

작업 디렉토리와 staging 영역의 현재 상태를 확인합니다.

$git commit
$git commit -m "commit messege"

staging 영역 파일의 상태를 repository에 기록합니다.

$git branch
$git branch <branch_name>

branch를 관리할 때 사용합니다.
기존의 브랜치를 관리하거나 새로운 branch를 생성합니다.

$git checkout <branch>
$git checkout -b new_branch

특정 commit, branch 또는 파일로 작업 디렉토리를 되돌립니다.
-b 새로운_브랜치명 으로 branch를 생성과 동시에 전환할 수 있습니다.

[Git] GUI를 통해 더 쉽게 관리하기

Git & Github

CodeChronicle — Fri, 20 Dec 2024 18:48:38 +0900

Git & Github

Git은 소프트웨어 버전관리 시스템입니다.

소프트웨어 개발 과정에서 코드의 변경 내역을 추적하고,

여러 개발자들이 동시에 협업할 수 있도록 돕는 버전관리 시스템입니다.

코드나 문서 등의 프로젝트 관리 시, 특정 지점으로 롤백하거나 변경사항을 한눈에 파악할 수 있습니다.

오픈소스 프로젝트나 대규모 프로젝트에서 효율적인 협업 툴로 활용되고 있습니다.

Repository (저장소)

Git에서 프로젝트를 저장하는 곳을 의미합니다.

로컬 저장소와 원격 저장소로 나뉩니다.

Commit (커밋)

변경사항을 저장소에 기록하는 단위입니다.

각 커밋은 고유한 해시값을 가지며, 변경상항의 설명을 포함합니다.

Branch (브랜치)

코드를 나누어 개발할 때 사용하는 가지(branch)입니다.

각 브랜치는 독립적으로 관리되며, 변경사항이 다른 브랜치에 영향을 주지 않습니다

Github는 Git 기반의 버전 관리와 협업 환경을 웹 상에서 구축할 수 있도록 하는 호스팅 서비스입니다.

Repository를 web 인터페이스로 관리 할 수 있도록 하여 코드의 변경사항, Branch 변화, Commit 이력 추적을 쉽게 할 수 있습니다.

GitHub는 세계 최대 규모의 개발자 커뮤니티로 수많은 오픈소스 프로젝트가 공유되고 있습니다.

[Git] Git 명령어 알아보기

S	R	Q(t + 1)
0	0	Q(t)	No change
0	1	0	Clear 0
1	0	1	Set to 1
1	1	?	Indeterminate