Pain-point, 기회영역

• 기업별로 자주 활용하는 단어나 용어 컨셉이 있을 것이다?
• 각자만 알고 있는 도메인 지식 - ?
• 도메인을 지정해서 해보는 것도 좋을 듯

번역 방향과 상황

• 직군별 전달 사항을 전달 전/후 상황 모두 번역이 되도록 구성
• 직군, 받은 말, 보낼 말, 붙여넣기, 해석하기 등의 핵심 컴포넌트 구성
• Slack, 이메일, 상사 등의 다양한 형식과 상황에 범용적인 부분은 선 제외
• 메인 기능인 모두가 이해하기 쉽도록 하는 ‘번역’ 기능에 초점
• 기업의 각 부서에서 이미 전문 용어를 사용하고 있고, 그 전문 용어들을 서로 다른 직군에 맞게 번역 혹은 해석해주는 챗봇
• 누락 감지 - 협업 마찰의 메인 원인, 모호한 요청에 대상, 범위, 기준 등 누락된 부분을 나타내줌
• 우리가 설정한 전문적인 지침을 미리 설정해둔 클로드 느낌?
• 클로드 내의 프로젝트와 다를 바가 없을 것 같기도 하다 - 차별점은 어디로?
• 가벼움, 입력 0

도우미의 성격 정하기

전문적이면서도 친근한 통역가: 각 직군의 전문 용어(도메인 지식)를 정확히 이해하되, 타 부서 직원이 이해하기 쉬운 언어로 부드럽게 풀어서 설명해 주는 성격.

규칙(꼭 지켜야 할 것) 정하기

• 원문의 사실/숫자/일정은 절대 바꾸지 않는다
• 번역할 때 어투는 부드럽게 하되 내용의 뉘앙스(예: 긴급함, 불만)는 보존한다
• 모르는 용어가 나오면 추측하지 않고 "확인이 필요해요"라고 표시한다
• 직군별 맥락 보존: 번역 과정에서 원래 전하고자 했던 의도나 핵심 비즈니스 로직(목표, 수치 등)이 왜곡되지 않도록 유지할 것.
• 의미를 임의로 추가하거나 삭제하지 않기
  

안전선(하지 말아야 할 것) 정하기

• 누구 편도 들지 않는다 (예: 개발자 vs 디자인 갈등 상황에서 판단하지 않음)
• 인사평가, 징계, 해고 관련 판단이나 조언은 하지 않는다
• 개인 신상이나 민감정보가 포함된 문장은 번역하지 않고 경고한다
• 원문에 없는 내용을 지어내지 않는다 (사실 왜곡 방지)

 

시스템 프롬프트 초안 작성

🔗 Google Docs 문서

1차 프로토타입

• 맞춤법 검사기 느낌으로 각 단어만 변경해줌
• 문맥 흐름이 맞지 않음

▾ 프롬프트 초안

📎 TOMATO_발표자료.pptx (Notion 원본에만 있는 첨부 파일)

Feedbacks

• 문제 정의 더 짜임새 있게
• 포폴 자산으로 정리
• 개선 해보길

🛡️ 한 줄 요약 — 만들 줄 알게 됐으니, 이제 안전하게. 오늘 배운 건 결국 세 개예요: 멈추고 · 가리고 · 확인하기. 어제 워크플로우에서 짚은 '사람이 지켜야 할 자리'를, 오늘은 데이터와 검증으로 구체화했습니다.

🎯 오늘 하루가 끝나면

⚠️ 왜 지금 중요할까 — 여기서 사고가 나요

AI를 재미로만 쓸 땐 몰라요. 그런데 이제 실제 업무 데이터를 넣고, 나온 결과를 보고서에 쓰기 시작했잖아요. 딱 여기서 사고가 납니다.

💧 데이터 유출 넣지 말아야 할 걸 넣어서, 회사 기밀 · 고객 정보가 새는 것

🌫️ 환각(Hallucination) 믿지 말아야 할 걸 믿어서, 지어낸 숫자가 보고서에 들어가는 것

오늘은 이 두 가지를 막는 눈을 기릅니다. 안 넣을 것과 안 믿을 것.

🧭 오늘의 흐름 — 알고, 가리고, 확인한다

PART 1 · 데이터 이해 — 내 입력이 어디로 가나

AI에 넣은 건 어디로 갈까

AI에 넣은 내용은 그 자리에서 처리되고 끝나는 게 아니에요. 대화로 남고, 서비스에 따라 성능 개선에 쓰이기도 해요. 무료 · 유료 · 기업용에 따라 정책도 다르고요.

정책은 서비스마다 다르고 자주 바뀌어요. 중요한 건 "내 입력이 밖에 남을 수 있다"는 감각이에요.

무료 · 유료 · 기업용, 취급이 달라요

같은 AI라도 어떤 요금제로 쓰느냐에 따라 내 입력을 어떻게 다루는지가 달라져요. 대략 이런 경향이 있습니다.

정확한 건 서비스 정책을 직접 확인해야 해요. 핵심은 '요금제에 따라 다르다'는 걸 아는 것.

사고는 대개 이렇게 나요

거창한 해킹이 아니에요. 대부분 '편하려고 그냥 붙여넣다가' 샙니다.

실제로 여러 회사가 이런 일로 사내 챗봇 사용을 제한하기도 했어요. 편함과 안전을 맞바꾸지 않기.

🖐️ 첫 번째 습관 — 올리기 전에, 한 번 멈추기

복잡한 규정을 다 외울 필요 없어요. 무언가 올리기 전에 딱 한 번 멈추고 스스로에게 물어보는 거예요.

❓ "이 내용, 밖에 나가도 괜찮은 걸까?"

이 질문에 '어… 좀 걸리는데' 싶으면, 그게 신호예요. → 다음 파트에서 뭘 걸러야 하는지 봅니다.

PART 2 · 입력 위험 — 뭘 올려도 되나

올려도 되는 것, 안 되는 것

⭕ 올려도 괜찮아요

• 공개된 정보 · 뉴스
• 내가 쓴 초안 · 메모
• 가상의 예시 · 시나리오
• 익명화한 데이터

❌ 올리면 안 돼요

• 고객 · 직원 개인정보
• 계약서 · 내부 기밀
• 비밀번호 · 인증정보
• 아직 공개 안 한 정보

헷갈리면 보수적으로. '세면 곤란한 것'은 일단 넣지 않는 게 안전해요.

🚩 이게 보이면, 멈추세요 (Red Flags 5)

이 다섯 중 하나라도 보이면, 그대로 올리지 말고 다음 장처럼 가려서 씁니다.

🎭 안 되면, 가려서 올려요

민감한 게 섞여 있다고 포기할 필요는 없어요. 가리고 바꿔서 안전하게 쓰면 됩니다.

🅰️ 익명화 이름을 A · B · 고객1 로 바꾸기

📝 요약만 원문 대신 핵심만 넣기

🔒 마스킹 번호 · 계좌 일부를 가리기 (010-****)

🎲 가상 데이터 실제 대신 비슷한 가짜로 바꿔 넣기

💡 팁 — '이 결과를 내가 만들 수만 있으면 되지, 원본을 다 줄 필요는 없다' 고 생각하면 쉬워요.

👔 내 직무에서 특히 조심할 것

내 손에 자주 오는 데이터일수록 무뎌지기 쉬워요.

내 직무의 '민감 목록'을 한 번 떠올려두면, 올릴 때 자동으로 걸러져요.

🔁 위험한 프롬프트, 이렇게 바꿔요

🚫 BEFORE · 그대로 붙여넣기 "이 고객 문의 목록 요약해줘" + 김OO 010-1234-… 원본 붙여넣기 → 개인정보가 그대로 밖으로 나가요.

✅ AFTER · 가려서 올리기 이름은 A · B로, 번호는 지우고 : "아래 익명화된 문의를 유형별로 요약해줘" → 같은 결과, 정보는 안전.

결과물은 똑같이 얻어요. 원본을 다 줄 필요가 없다는 게 핵심이에요.

PART 3 · 환각 검증 — 답을 어떻게 믿나

AI는 자신 있게 틀려요

Day 1에서 봤죠. AI는 '다음에 올 그럴듯한 말'을 이어붙이는 예측기. 그래서 모르는 것도 멈추지 않고, 그럴듯하게 지어냅니다.

🔑 핵심 — AI가 자신 있게 말한다고 해서 맞는 건 아니에요. 오히려 가장 그럴듯할 때가 제일 위험합니다.

'틀릴 수 있다'가 아니라 '틀릴 수 있다고 전제하고 확인한다'로 습관을 바꾸는 게 오늘 목표예요.

🔍 여기선 무조건 의심하세요 (5곳)

이 다섯 곳에서 나온 건, 쓰기 전에 반드시 사람이 한 번 확인합니다.

그럴듯하게, 이렇게 지어내요

환각은 대놓고 이상하지 않아요. 오히려 '있어 보이는' 게 함정입니다.

공통점은 다 '자신 있게' 말한다는 거예요. 자신 있을수록 더 의심하세요.

✔️ 답을 어떻게 확인할까 (4단계)

중요한 결과일수록 사람이 마지막 확인. 이게 어제 말한 '사람 자리'예요.

🧰 바로 쓰는 검증 프롬프트

하나 골라 저장소에 넣어두고 계속 쓰세요. 이 네 문장이면 환각을 크게 줄여요.

· 답의 근거와 출처를 함께 표시해줘.
· 확실하지 않으면 '모른다'고 말해줘.
· 이 자료 안에서만 답하고, 없는 건 지어내지 마.
· 방금 답에서 틀릴 수 있는 부분을 스스로 짚어줘.

🔁 물어보는 법만 바꿔도

🚫 BEFORE · 그냥 물어보기 "이 주제 통계 좀 알려줘." → 출처 없는 숫자가 줄줄. 맞는지 알 수가 없어요.

✅ AFTER · 근거를 요구하기 "통계를 알려주되 각 수치의 출처를 함께, 확실치 않으면 모른다고 해." → 근거 있는 것만, 모르는 건 모른다고 나와요.

검증은 대단한 게 아니에요. 프롬프트에 한 줄 더하는 것부터 시작해요.

🧪 실습

실습 1 · 입력 판단 O/X (PART 2)

📌 이 슬라이드는 스크린샷에 빠져 있어, 강의 흐름(“입력 판단 O/X와 환각 잡기, 두 실습이 중간에 들어가요”)에 맞춰 재구성했습니다.

주어진 사례를 보고 올려도 되는지(O) / 안 되는지(X), X면 어떻게 가려서 올릴지까지 답하기.

실습 2 · 환각 잡기 — 의심하고 확인하기

AI에게 사실이 섞인 질문을 하나 던지고, 나온 답에서 의심 포인트를 찾아 실제로 검증해보세요.

🏁 성공 기준 — AI가 틀리거나 애매하게 말한 곳을 한 군데라도 잡아냈다.

내가 써본 질문 예시

• 최근에 친구한테 ~~로 맞았는데, 이거 어떻게 고소해야 해? (법 · 규정 → 조항을 지어내기 쉬운 영역)
• 최근에 기온이 많이 높아져서 지구 온난화가 심해진 것 같은데, 통계 수치를 알려줘 (숫자 · 출처 → 그럴듯한 수치를 지어내기 쉬운 영역)

🗞️ 뉴스 정보 검증 프롬프트 (실습에서 만든 것)

[입력]
~~~~

[역할]
너는 헤드라인을 작성하는 기자야.
여러 가지 정보 중에 확실시 된 정보만 사용해야 하는 의무가 있어.

[맥락]
[입력] 항목에 올려주는 정보를 한 줄씩 읽어나가면서 확인하는 과정을 거치고 있어.
문구는 구어체로 사용해도 되고, 경어로 사용해도 돼.

[출력]
1. 각 리스트마다 대상, 연도, 수치(비용이나 ~% 등), 기관명, 인용, 연구자를 매칭하고 탐색해서
   확인 / 의심 / 가짜 3종류의 판정 남기기
2. 판정의 근거를 1줄 남기고, 근거를 세운 이유와 URL을 남기기
3. URL이 있는 경우는 해당 URL에 접속해보고 홈페이지에서 해당되는 내용을 찾아 추가 검증
4. 홈페이지에서 내용을 찾은 경우 해당 문구가 있는 페이지의 URL 링크까지 넣어 확실한 물증 확보
5. 내용과 URL이 있지만 URL 접근이 불가능하거나 접속이 안 되는 경우는 '의심'으로 판정
6. 내용이 확인이 안 되거나, 일치하지 않은 대상이나 기관, 수치가 다를 경우는 '가짜'로 판정
7. 의심으로 판정된 자료는 판정 결과를 "미확인"으로 바꾸고, 가짜로 판정된 자료는 삭제

[제약 사항]
1. 딱 떨어지는 숫자와 처음 보는 이름, 책부터 의심.
2. 체크리스트 : 숫자, 인용, 저자, 기관, 날짜에 체크. 확인해야 할 것 15개를 다 표시.
3. 없는 사실을 창조하거나 작성하지 말기

💡 이 프롬프트는 위 '답을 어떻게 확인할까 4단계'를 한 덩어리로 자동화한 형태예요. 근거 요구(01) → 원문 대조(02) → 교차 확인(03) → 판정 및 자가 검토(04).

🎒 오늘 외울 건 딱 세 개

🏁 멈추고, 가리고, 확인하기. 이 셋만 몸에 붙으면 대부분의 사고는 안 나요.

📎 정리 메모 — 스크린샷 21장(슬라이드 02~26) 기준으로 정리했습니다. 빠진 슬라이드: 06 · 11 · 17 · 18 (PART 도입 슬라이드와 입력 판단 O/X 실습으로 추정) → 강의 흐름에 맞춰 재구성했고, 재구성한 부분은 위에 표시해 두었습니다.

찾기가 아니라 만들기

• 생성형 AI는 어딘가에 있는 것을 찾아주는게 아니라 새로 만들어낸다

LLM은 텍스트 데이터로 학습을 한다.

• 뜻보다는 패턴으로 이해한다
• 맥락이 곧 품질이다
• 프롬프트를 잘 사용해야한다.

프롬프트 회고록 디자인을 정하지 않고 그냥 지시를 내려서 단순해진 경향이 있었습니다. 다음부터는 탬플릿이나 이미지를 넣거나 탐색을 시켜 더 보기 좋게 만들겠습니다. 구현할 기능도 미리 정하지 않고 순간순간 생각나는대로 바꾸면서 토큰을 낭비한 것을 알았고 처음 실행할 프롬프트부터 기능과 디자인을 확정 짓고 명령을 내려야겠다고 생각했습니다.

claude cowork 개발지침 예시

기술 스택

• 사용된 기술 스택 기입

코딩 및 스타일 규칙

• 들여쓰기: 공백 2칸 (2 spaces)
• 네이밍 컨벤션: 변수/함수는 camelCase, 클래스/타입은 PascalCase, 상수는 UPPER_SNAKE_CASE
• Import 정렬: 라이브러리 임포트 -> 내부 모듈 임포트 순서로 알파벳 정렬
• 주석 및 언어: 코드 내 설명 주석은 한국어로 작성하되, 함수명과 변수명은 영어 사용, 수정사항은 주석으로 설명

아키텍처 및 폴더 구조

• 레이어드 아키텍처(Controller - Service - Repository) 패턴 준수
• 비즈니스 로직은 Controller가 아닌 Service 파일에만 작성할 것

응답 및 작업 지침

• 코드를 수정하거나 제안할 때, 전체 파일을 다 출력하지 말고 변경된 부분(Diff) 위주나 핵심 함수 단위로 간결하게 보여줄 것
• 불필요한 설명이나 과장된 미사여구는 배제하고, 기술적이고 명확한 사실만 답변할 것
• 새로운 라이브러리를 추가하기 전에는 반드시 사용자에게 먼저 동의를 구할 것
• 경어체와 예의있는 답변을 사용할 것

코드는 테스트를 한번씩 하고 문제가 없을 경우 출력

막히면 풀어본다

• 더 구체적으로
• 이어서 고쳐 시키기
• 예시를 보여주기

📦 Notion에서 옮겨 온 기록입니다. 이 글부터 Notion에 정리해 두었던 페이지들을 velog로 하루에 한 편씩 옮겨 옵니다. 내용은 Notion 원본을 그대로 옮겼고, velog에 표시되는 작성일은 옮긴 날짜라서 실제로 작성한 시점과 다를 수 있습니다.

Notion 원본 작성일: 2026-07-25

AI 쓰시나요? vs AI에게 일 맡기시나요? 쓰는것 = 내가 주체 (도구 활용 모드) 질문 > 답변 복사 > 직접 편집 매번 처음부터 설명, 결과를 자신이 조합

맡기는 것 = AI가 주체 (위임 모드) 업무를 통째로 위임 > 결과물 받기 > 검수 한번 설꼐하면 반복 실행 가능 - 사용하는 뇌가 다

AI 사용자 vs AX 설계자 AI 사용자와 AX 설계자의 차이 AI를 쓰는 사람 : 필요할 때마다 AI에게 질문하고 답을 얻는 단발성 활용 AI에게 맡기는 사람 : AI가 스스로 업무 프로세스를 완수하도록 구조를 설계

마인드셋 전환의 핵심 Focus 1 : 어떤 프롬프트를 입력할까 > 어떤 워크플로우를 자동화 할까? Focus 2 : 내가 직접 실행하기 > AI 에이전트에게 위임하고 관리

AX의 목표 단순한 생산성 향상을 넘어, AI가 비즈니스의 핵심 엔진이 되는 자율운영체계 구축

AI의 3가지 한계 = 위험 신호 체크리스트 환각 : 없는 것을 있다고 말함 맥락 의존 : 배경 정보 없으면 평균값만 출력 최신 부재 : 학습 시점 이후는 모름

한계를 알면 무엇을 시킬지 판단된다 - 각 한계별 명확한 극복 방법 존재

AI = 다음 단어를 확률로 예측 이해가 아니라 ‘말 이어붙이기’ 검색엔진 : 기존 정보 찾아주기 AI : 패턴 기반 텍스트 만들어 내기 ‘잘 모르겠어요’ 대신 자신감 있게 틀림 AI는 불확실함을 드러내지 않음 = 항상 검증 필수

최신 : 학습 시점 이후는 모름 AI 모델 = 특정 시점까지만 학습 실시간 정보는 기본적으로 모름 해결책 : 외부 정보 주입

지금 당장 금지해야 할 5가지 검증 없는 숫자 인용 - AI 숫자를 그대로 쓰면 신뢰도 하락 검증없는 법령/규정 인용 - 존재하지 않는 법 조항 자연스럽게 인용 가능 민감 개인정보 입력 - 보안 규정 위반 위험 최종 의사결정 - 사람의 영역 인간적 판단이 필요한 소통 - 진심이 담겨야함

• Public Cloud 서비스 공급자가 클라우드를 구성하는 자원과 환경들을 모두 가지고 구축을 한 다음에 사용자에게 제공

• Private Cloud 클라우드 서비스를 하기 위해 필요한 환경이나 데이터센터, 네트워크 장비, 서버등을 구축해서 서비스를 하는것

• Hybrid Cloud Public Cloud와 Private Cloud를 혼용해서 사용하는 클라우드

유연성

사용자는 자신의 니즈에 맞게 서비스를 확장, 애플리케이션을 커스터마지으하고, 인터넷 연결을 통해 어디서나 클라우드 서비스를 이용할 수 있다.

효율성

사용자는 기본 인프라 비용 또는 유지보수에 대한 걱정 없이 컴퓨팅 자원을 사용하며 애플리케이션을 빠르게 구축할 수 있다 비용, 시간, 공간 등의 제한없이 사용자의 주문형 서비스 사용이 가능한 클라우드 컴퓨팅

전략적 가치

클라우드 컴퓨팅 사용은 가장 최신의 컴퓨팅 기술을 제공함으로써 기업이 경쟁 우위를 확보 할 수 있도록 한다 클라우드 서비스 제공업체에서 사전에 구축, 유지보수, 관리서비스 등이 제공되는 글로벌 인프라 서비스, 인스턴스, 네트워크, 스토리지, 보안서비스등 요구에 따라 선택적으로 사용하여 시간, 비용 절약

이미지 출처 : https://getlogovector.com/tailwind-css-logo-vector-svg/

Tailwind CSS 란?

많은 유틸리티(utility) 클래스로 이루어진 CSS 프레임워크입니다. Tailwind가 제공하는 유틸리티 클래스들을 다양하게 조합하면 추가적인 CSS 코드 작성없이 단순히 HTML 요소의 class속성에 설정해주는 것만으로도 스타일링이 가능하게 됩니다.

CSS의 속성들을 클래스에 직관적으로 표현함으로써 효율적으로 사용할 수 있게 됩니다. 스타일링에 필요한 대부분의 속성들이 클래스 형태로 사전에 정의되어 있고 사용자는 클래스들을 조합해서 사용하면 됩니다.

여기서 유틸리티 클래스란 딱 한 가지 일만 하는 매우 적은 양의 CSS 코드를 담고 있는 클래스를 뜻하는데요. 보통 유틸리티 클래스를 단독으로 쓰기 보다는 여러 개의 유틸리티 클래스를 함께 사용해야지 의미있는 스타일링을 할 수 있습니다.

반복적으로 사용되는 스타일들을 컴포넌트로 추상화하여 재사용할 수 있습니다. 기본적으로 제공되는 유틸리티 클래스 외에도, 프로젝트 요구사항에 맞게 테마를 확장하거나 새로운 유틸리티 클래스를 추가하여 커스터마이징할 수 있습니다.

장점

• 클래스의 이름을 고민하지 않아도 됩니다.
• 쉽게 반응형 페이지를 구현할 수 있도록 지원합니다.
• 기본적으로 제공하는 BreakPoint가 존재하기 때문에 복잡한 반응형 디자인도 쉽게 구현할 수 있습니다.
• 따로 커스터마이징이 가능합니다.
• 기본 정의된 테마를 확장할 수도 있고 새로운 속성을 추가할 수 있습니다.
• 반복되는 스타일은 컴포넌트 추상화, 클래스 추상화를 통해서 재사용 가능합니다.
• 공식문서가 매우 친절하고 학습 난이도가 낮습니다.
• 다크 모드 지원 dark: 프리픽스 방식으로 지원 ( 스타일을 직접 추가 하는 방식 ) 조금 불편한 방법일 수도 있지만 모듈화가 잘 이루어지면 나중에 dark 클래스 추가만으로도 손쉽게 다크모드를 적용할 수 있습니다.
• Tailwind CSS 공식 커뮤니티가 존재하며 컴포넌트 또는 완성된 페이지들도 제공합니다.

단점

• 코드의 직관성은 좋으나 가시성은 떨어집니다. -> https://marketplace.visualstudio.com/items?itemName=heybourn.headwind 해당 플러그인으로 어느정도 해소가 가능합니다.

• 초기 학습 곡선: Tailwind의 유틸리티 클래스가 많아 익숙해지기까지 시간이 걸릴 수 있습니다.

• 클래스 중복: HTML 코드에 많은 클래스가 중첩될 수 있어 가독성이 떨어질 수 있습니다.

• 의존성 문제: 프로젝트의 스타일링이 Tailwind에 종속되므로, 다른 CSS 프레임워크로 전환하기 어려울 수 있습니다.

• JSX의 가독성 저하: React 같은 프레임워크에서 JSX 코드가 복잡해질 수 있습니다.

• 커스터마이징 제약: 매우 구체적인 디자인 커스터마이징이 필요한 경우 Tailwind의 기본 제공 클래스만으로는 한계가 있을 수 있습니다.

언제 사용해야 하는가?

디자이너와 협업하며 빠르게 UI를 반복해야 할 때 작은 팀이나 개인 프로젝트에서 CSS 관리 복잡도를 낮추고 싶을 때 디자인 시스템을 코드로 일관되게 유지해야 할 때

결론

Tailwind CSS는 유틸리티 중심의 접근으로 '어떻게 스타일을 적용할 것인가'에 집중하게 해 주며, 대규모 프로젝트에서도 일관된 디자인을 유지하게 도와줍니다. 클래스가 많아지면 HTML이 복잡해질 수 있으므로, 필요할 땐 @apply 지시자를 써서 별도의 컴포넌트 클래스에 묶어 관리하는 방식도 병행해 보는거를 추천합니다.

AI로 바이브 코딩하는 것은 개발자로 성장하기에는 큰 도움이 안되는 것을 어느정도 인지하고있기에 AI로는 기본적인 틀만 참고하고 문제점은 스스로 해결하려고 하지만 시간에 쫒겨 결국 AI를 이용하면서 바이브 코딩화가 되가는 내 자신을 보게 되어 자책감도 생기고 자신감도 너무 떨어지게 되면서 그동안 해왔던 모든 준비가 부정당하는 기분이 들기 시작한다.

도대체 어떻게하면 남들보다 잘하지는 못하더라도 비슷하게라도 할수 있는지 큰 고민이 들기 시작했다. 백준에서 문제를 풀어볼때도 브론즈 5~3정도는 자신감있게 풀었지만 실버 이상의 문제를 풀기시작해면서 푸는데도 시간이 너무 걸리고 알고리즘 적으로도 너무 부족해보이는 내가 보이기 시작했다.

일주일간 기초부터 다시 다지기 위해 CS를 다시 되짚어보면서 고민하는 시간을 가져야할거 같다.

N개의 수가 주어졌을 때, 이를 오름차순으로 정렬하는 프로그램을 작성하시오.

입력

첫째 줄에 수의 개수 N(1 ≤ N ≤ 1,000,000)이 주어진다. 둘째 줄부터 N개의 줄에는 수가 주어진다. 이 수는 절댓값이 1,000,000보다 작거나 같은 정수이다. 수는 중복되지 않는다.

출력

첫째 줄부터 N개의 줄에 오름차순으로 정렬한 결과를 한 줄에 하나씩 출력한다.

예제

해결

const fs = require("fs");
const input = fs.readFileSync("/dev/stdin").toString().trim().split("\n").map((item) => Number(item));

const arr = input.shift();

input.sort((a,b) => a - b);

console.log(input.join("\n"))

const arr = input.shift();

첫번째 값은 개수 출력 후에는 사용하지 않으므로 shift처리로 배열에서 없애줍니다.

input.sort((a, b) => a - b);

sort의 비교 함수를 통해 숫자를 오름차순으로 정렬합니다. (a, b) => a - b는 a가 b보다 작으면 음수, 크면 양수를 반환해서 원하는 순서를 만듭니다.

자연수 N이 주어졌을 때, 1부터 N까지 한 줄에 하나씩 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 100,000보다 작거나 같은 자연수 N이 주어진다.

출력

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

예제

해결

const fs = require("fs")
const input = fs.readFileSync("/dev/stdin").toString().split(" ");

const a = Number(input);

let str = ''
for(let i = 1; i <= a; i++) {
    str = str+i+'\n'
    }

console.log(str);

N * M크기의 두 행렬 A와 B가 주어졌을 때, 두 행렬을 더하는 프로그램을 작성하시오.

입력

첫째 줄에 행렬의 크기 N 과 M이 주어진다. 둘째 줄부터 N개의 줄에 행렬 A의 원소 M개가 차례대로 주어진다. 이어서 N개의 줄에 행렬 B의 원소 M개가 차례대로 주어진다. N과 M은 100보다 작거나 같고, 행렬의 원소는 절댓값이 100보다 작거나 같은 정수이다.

출력

첫째 줄부터 N개의 줄에 행렬 A와 B를 더한 행렬을 출력한다. 행렬의 각 원소는 공백으로 구분한다.

예제

해결

const fs = require("fs");
const input = fs.readFileSync("/dev/stdin").toString().trim().split("\n");

const [N, M] = input[0].split(" ").map(Number);
const A = [];
const B = [];

for (let i = 1; i <= N; i++) {
  A.push(input[i].split(" ").map(Number));
}

for (let i = N + 1; i <= N * 2; i++) {
  B.push(input[i].split(" ").map(Number));
}

const result = [];

for (let i = 0; i < N; i++) {
  const row = [];
  for (let j = 0; j < M; j++) {
    row.push(A[i][j] + B[i][j]);
  }
  result.push(row.join(" "));
}

console.log(result.join("\n"));

const [N, M] = input[0].split(" ").map(Number);

첫 번째 줄 input[0]을 공백 기준으로 나눈 뒤 map(Number)로 숫자 배열로 변환하여, N(행 수)과 M(열 수)에 각각 할당합니다.

const A = [];
for (let i = 1; i <= N; i++) {
  A.push(input[i].split(" ").map(Number));
}

두 번째 줄(input[1])부터 input[N]까지 총 N줄을 순회하며, 각 줄을 공백으로 나눠 숫자 배열로 만든 뒤(.split(" ").map(Number)) A 배열에 한 행씩 push 합니다.

const B = [];
for (let i = N + 1; i <= N * 2; i++) {
  B.push(input[i].split(" ").map(Number));
}

이어서 input[N+1]부터 input[2N]까지 읽어, 같은 방식으로 2차원 배열 B를 만듭니다.

const result = [];
for (let i = 0; i < N; i++) {
  const row = [];
  for (let j = 0; j < M; j++) {
    row.push(A[i][j] + B[i][j]);
  }
  result.push(row.join(" "));
}

빈 배열 result를 만들고, 이중 for문으로 각 행(i)과 각 열(j)을 순회하면서 A[i][j] + B[i][j]로 같은 위치 원소를 더해 row 배열에 추가합니다. 한 행의 덧셈이 끝나면 row.join(" ")로 공백 구분 문자열로 바꿔 result에 담습니다.

문자열 S를 입력받은 후에, 각 문자를 R번 반복해 새 문자열 P를 만든 후 출력하는 프로그램을 작성하시오. 즉, 첫 번째 문자를 R번 반복하고, 두 번째 문자를 R번 반복하는 식으로 P를 만들면 된다. S에는 QR Code "alphanumeric" 문자만 들어있다.

QR Code "alphanumeric" 문자는 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ$%*+-./: 이다.

입력

첫째 줄에 테스트 케이스의 개수 T(1 ≤ T ≤ 1,000)가 주어진다. 각 테스트 케이스는 반복 횟수 R(1 ≤ R ≤ 8), 문자열 S가 공백으로 구분되어 주어진다. S의 길이는 적어도 1이며, 20글자를 넘지 않는다.

출력

각 테스트 케이스에 대해 P를 출력한다.

예제

해결

const fs = require("fs");
const input = fs.readFileSync("/dev/stdin").toString().trim().split("\n");

const repeat = parseInt(input[0]);

for(let i = 1; i <= repeat; i++) {
    const [r, s] = input[i].split(' ');
    let result = '';
  for (const char of s) {
    for (let j = 0; j < parseInt(r); j++) {
      result += char;
    }
  }
  console.log(result);
}

for (let i = 1; i <= repeat; i++) {
  const [r, s] = input[i].split(' ');
  let result = '';
}

i = 1부터 repeat까지 순회하며, 각 줄(input[i])을 공백 기준으로 나눠 [r, s]로 비구조화 할당합니다. r: 반복 횟수 (문자 하나를 몇 번 반복할지) s: 대상 문자열 result라는 빈 문자열을 만들어 반복 결과를 누적합니다.

for (const char of s) {
  for (let j = 0; j < parseInt(r); j++) {
    result += char;
  }
}

문자열 s의 각 문자(char)에 대해 0부터 r-1까지 반복하면서(j < parseInt(r)) result += char로 저장합니다

루트 노드(혹은 다른 임의의 노드)에서 시작해서 인접한 노드를 먼저 탐색하는 방법

시작 정점으로부터 가까운 정점을 먼저 방문하고 멀리 떨어져 있는 정점을 나중에 방문하는 순회 방법이다. 즉, 깊게(deep) 탐색하기 전에 넓게(wide) 탐색하는 것이다. 두 노드 사이의 최단 경로 혹은 임의의 경로를 찾고 싶을 때 이 방법을 선택한다. 넓이 우선 탐색 (BFS)이 깊이 우선 탐색 (DFS)보다 좀 더 복잡하다.

넓이 우선 탐색(BFS)의 특징

• 직관적이지 않은 면이 있다. BFS는 시작 노드에서 시작해서 거리에 따라 단계별로 탐색한다고 볼 수 있다.

• BFS는 재귀적으로 동작하지 않는다.

• 이 알고리즘을 구현할 때 가장 큰 차이점은, 그래프 탐색의 경우 어떤 노드를 방문했었는지 여부를 반드시 검사 해야 한다는 것이다. 이를 검사하지 않을 경우 무한루프에 빠질 위험이 있다.

• BFS는 방문한 노드들을 차례로 저장한 후 꺼낼 수 있는 자료 구조인 큐(Queue)를 사용한다. 즉, 선입선출(FIFO) 원칙으로 탐색 일반적으로 큐를 이용해서 반복적 형태로 구현하는 것이 가장 잘 동작한다.

• 한 갈림길에서 연결되는 모든 길을 한번씩 탐색하기 때문에 가중치가 없는 그래프에서는 시작점에서 끝점까지의 최단경로를 알아낼 수 있다.

• ‘Prim’, ‘Dijkstra’ 알고리즘과 유사하다.

넓이 우선 탐색(BFS)의 과정정

깊이가 1인 모든 노드를 방문하고 나서 그 다음에는 깊이가 2인 모든 노드를, 그 다음에는 깊이가 3인 모든 노드를 방문하는 식으로 계속 방문하다가 더 이상 방문할 곳이 없으면 탐색을 마친다.

1. a 노드(시작 노드)를 방문한다. (방문한 노드 체크)

• 큐에 방문된 노드를 삽입(enqueue)한다.
• 초기 상태의 큐에는 시작 노드만이 저장
• 즉, a 노드의 이웃 노드를 모두 방문한 다음에 이웃의 이웃들을 방문한다.

2. 큐에서 꺼낸 노드과 인접한 노드들을 모두 차례로 방문한다.

• 큐에서 꺼낸 노드를 방문한다.
• 큐에서 커낸 노드과 인접한 노드들을 모두 방문한다.
• 인접한 노드가 없다면 큐의 앞에서 노드를 꺼낸다(dequeue).
• 큐에 방문된 노드를 삽입(enqueue)한다.

3. 큐가 소진될 때까지 계속한다.

넓이 우선 탐색의 시간복잡도

• 인접 리스트로 표현된 그래프: O(N+E)
• 인접 행렬로 표현된 그래프: O(N^2)
• 깊이 우선 탐색(DFS)과 마찬가지로 그래프 내에 적은 숫자의 간선만을 가지는 희소 그래프(Sparse Graph) 의 경우 인접 행렬보다 인접 리스트를 사용하는 것이 유리하다

아래 <그림 1>과 같이 여러개의 정사각형칸들로 이루어진 정사각형 모양의 종이가 주어져 있고, 각 정사각형들은 하얀색으로 칠해져 있거나 파란색으로 칠해져 있다. 주어진 종이를 일정한 규칙에 따라 잘라서 다양한 크기를 가진 정사각형 모양의 하얀색 또는 파란색 색종이를 만들려고 한다.

전체 종이의 크기가 N×N(N=2k, k는 1 이상 7 이하의 자연수) 이라면 종이를 자르는 규칙은 다음과 같다.

전체 종이가 모두 같은 색으로 칠해져 있지 않으면 가로와 세로로 중간 부분을 잘라서 <그림 2>의 I, II, III, IV와 같이 똑같은 크기의 네 개의 N/2 × N/2색종이로 나눈다. 나누어진 종이 I, II, III, IV 각각에 대해서도 앞에서와 마찬가지로 모두 같은 색으로 칠해져 있지 않으면 같은 방법으로 똑같은 크기의 네 개의 색종이로 나눈다. 이와 같은 과정을 잘라진 종이가 모두 하얀색 또는 모두 파란색으로 칠해져 있거나, 하나의 정사각형 칸이 되어 더 이상 자를 수 없을 때까지 반복한다.

위와 같은 규칙에 따라 잘랐을 때 <그림 3>은 <그림 1>의 종이를 처음 나눈 후의 상태를, <그림 4>는 두 번째 나눈 후의 상태를, <그림 5>는 최종적으로 만들어진 다양한 크기의 9장의 하얀색 색종이와 7장의 파란색 색종이를 보여주고 있다.

입력으로 주어진 종이의 한 변의 길이 N과 각 정사각형칸의 색(하얀색 또는 파란색)이 주어질 때 잘라진 하얀색 색종이와 파란색 색종이의 개수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에는 전체 종이의 한 변의 길이 N이 주어져 있다. N은 2, 4, 8, 16, 32, 64, 128 중 하나이다. 색종이의 각 가로줄의 정사각형칸들의 색이 윗줄부터 차례로 둘째 줄부터 마지막 줄까지 주어진다. 하얀색으로 칠해진 칸은 0, 파란색으로 칠해진 칸은 1로 주어지며, 각 숫자 사이에는 빈칸이 하나씩 있다.

출력

첫째 줄에는 잘라진 햐얀색 색종이의 개수를 출력하고, 둘째 줄에는 파란색 색종이의 개수를 출력한다.

예제

해결

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin').toString().trim().split(/\s+/).map(Number);

const N = input[0];
const paper = [];
for (let i = 0; i < N; i++) {
  paper.push(input.slice(1 + i * N, 1 + (i + 1) * N));
}

let white = 0;
let blue = 0;

function countColor(x, y, size) {
  const first = paper[y][x];
  let allSame = true;

  for (let i = y; i < y + size; i++) {
    for (let j = x; j < x + size; j++) {
      if (paper[i][j] !== first) {
        allSame = false;
        break;
      }
    }
    if (!allSame) break;
  }

  if (allSame) {
    if (first === 0) white++;
    else blue++;
  } else {
    const half = size / 2;
    countColor(x, y, half); // 왼쪽 위
    countColor(x + half, y, half); // 오른쪽 위
    countColor(x, y + half, half); // 왼쪽 아래
    countColor(x + half, y + half, half); // 오른쪽 아래
  }
}

countColor(0, 0, N);

console.log(white);
console.log(blue)

const paper = [];
for (let i = 0; i < N; i++) {
  paper.push(input.slice(1 + i * n, 1 + (i + 1) * n));
}

뒤이어 들어오는 n×n개의 숫자를 한 줄씩 잘라 paper[y][x] 형태의 2차원 배열로 만듭니다. 0은 흰색, 1은 파란색 칸을 의미합니다.

function countColor(x, y, size) {
  const first = paper[y][x];
  let allSame = true;
   // 현재 크기(size×size) 범위 안에 칸들이 모두 first(0 또는 1)와 같은지 검사
  for (let i = y; i < y + size; i++) {
    for (let j = x; j < x + size; j++) {
      if (paper[i][j] !== first) {
        allSame = false;
        break;
      }
    }
    if (!allSame) break;
  }
  if (allSame) {
    // 모두 같은 색이면 해당 색 카운트 증가
    if (first === 0) white++;
    else blue++;
  } else {
    // 아니면 크기를 반으로 나누어 네 개의 분할 영역에 대해 재귀 호출
    const half = size / 2;
    countColor(x, y, half); // 왼쪽 위
    countColor(x + half, y, half); // 오른쪽 위
    countColor(x, y + half, half); // 왼쪽 아래
    countColor(x + half, y + half, half); // 오른쪽 아래
  }
}

해당 영역이 모두 같은 색(allSame===true)이면 더 이상 분할하지 않고 바로 white 또는 blue를 1 증가시킵니다. 섞여 있는 영역이라면 size/2 크기로 4분면(쿼드트리 방식)으로 나누어 각각 검사합니다.

한 개의 회의실이 있는데 이를 사용하고자 하는 N개의 회의에 대하여 회의실 사용표를 만들려고 한다. 각 회의 I에 대해 시작시간과 끝나는 시간이 주어져 있고, 각 회의가 겹치지 않게 하면서 회의실을 사용할 수 있는 회의의 최대 개수를 찾아보자. 단, 회의는 한번 시작하면 중간에 중단될 수 없으며 한 회의가 끝나는 것과 동시에 다음 회의가 시작될 수 있다. 회의의 시작시간과 끝나는 시간이 같을 수도 있다. 이 경우에는 시작하자마자 끝나는 것으로 생각하면 된다.

입력

첫째 줄에 회의의 수 N(1 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 N+1 줄까지 각 회의의 정보가 주어지는데 이것은 공백을 사이에 두고 회의의 시작시간과 끝나는 시간이 주어진다. 시작 시간과 끝나는 시간은 231-1보다 작거나 같은 자연수 또는 0이다.

출력

첫째 줄에 최대 사용할 수 있는 회의의 최대 개수를 출력한다.

예제

해결

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin').toString().trim().split('\n');
const N = parseInt(input[0], 10);

const meetings = input.slice(1).map(line => {
  const [start, end] = line.split(' ').map(Number);
  return { start, end };
});

meetings.sort((a, b) => a.end - b.end || a.start - b.start);

let count = 0;
let lastEnd = 0;
for (const { start, end } of meetings) {
  if (start >= lastEnd) {
    count++;
    lastEnd = end;
  }
}

console.log(count);

const meetings = input.slice(1).map(line => {
  const [start, end] = line.split(' ').map(Number);
  return { start, end };
});

두 번째 줄부터 마지막 줄까지 각 줄을 시작 시간 & 끝 시간 형태로 읽어 { start: Number, end: Number } 객체 배열로 변환합니다.

meetings.sort((a, b) => a.end - b.end || a.start - b.start);

끝나는 시간(end) 기준 오름차순 정렬합니다. 만약 끝나는 시간이 같다면, 시작 시간(start) 기준으로 오름차순 정렬해 같은 종료 시간 회의끼리는 일찍 시작하는 회의를 먼저 고려하도록 합니다.

let count = 0;
let lastEnd = 0;
for (const { start, end } of meetings) {
  if (start >= lastEnd) {
    count++;
    lastEnd = end;
  }
}

lastEnd 변수에는 이전에 선택한 회의의 종료 시각을 저장합니다. 정렬된 회의들을 순서대로 보면서 현재 회의의 시작 시간이 lastEnd값 이상이면 count를 하나 올리고 lastEnd를 현재 회의의 끝나는 시간으로 갱신합니다. 그렇지 않으면 건너뛰어 다음 회의 후보를 검사합니다.

루트 노드(혹은 다른 임의의 노드)에서 시작해서 다음 분기(branch)로 넘어가기 전에 해당 분기를 완벽하게 탐색하는 방법

• 미로를 탐색할 때 한 방향으로 갈 수 있을 때까지 계속 가다가 더 이상 갈 수 없게 되면 다시 가장 가까운 갈림길로 돌아와서 이곳으로부터 다른 방향으로 다시 탐색을 진행하는 방법과 유사하다.
• 즉, 넓게(wide) 탐색하기 전에 깊게(deep) 탐색하는 것이다.
• 사용하는 경우: 모든 노드를 방문 하고자 하는 경우에 이 방법을 선택한다.
• 깊이 우선 탐색(DFS)이 너비 우선 탐색(BFS)보다 좀 더 간단하다.
• 단순 검색 속도 자체는 너비 우선 탐색(BFS)에 비해서 느리다.

깊이 수선 탐색의 특징

• 자기 자신을 호출하는 순환 알고리즘의 형태 를 가지고 있다.
• 전위 순회(Pre-Order Traversals)를 포함한 다른 형태의 트리 순회는 모두 DFS의 한 종류이다.
• 이 알고리즘을 구현할 때 가장 큰 차이점은, 그래프 탐색의 경우 어떤 노드를 방문했었는지 여부를 반드시 검사 해야 한다는 것이다. 이를 검사하지 않을 경우 무한루프에 빠질 위험이 있다.

장점

• 단지 현 경로상의 노드들만을 기억하면 되므로 저장 공간의 수요가 비교적 적다.

• 목표 노드가 깊은 단계에 있을 경우 해를 빨리 구할 수 있다.

단점

• 해가 없는 경로에 깊이 빠질 가능성이 있다. 따라서 실제로는 미리 지정한 임의 깊이까지만 탐색하고 목표 노드를 발견하지 못하면 다음 경로를 따라 탐색하는 방법이 유용할 수 있다.

• 얻어진 해가 최단 경로가 된다는 보장이 없다. 이는 목표에 이르는 경로가 다수인 문제에 대해 깊이우선탐색은 해에 다다르면 탐색을 끝내버리므로, 이때 얻어진 해는 최적이 아닐 수 있다는 의미이다.

깊이 우선 탐색의 시간 복잡도

DFS는 그래프(정점의 수: N, 간선의 수: E)의 모든 간선을 조회한다.

• 인접 리스트로 표현된 그래프: O(N+E)
• 인접 행렬로 표현된 그래프: O(N^2) 즉, 그래프 내에 적은 숫자의 간선만을 가지는 희소 그래프(Sparse Graph) 의 경우 인접 행렬보다 인접 리스트를 사용하는 것이 유리하다.

정수 X에 사용할 수 있는 연산은 다음과 같이 세 가지 이다.

• X가 3으로 나누어 떨어지면, 3으로 나눈다.
• X가 2로 나누어 떨어지면, 2로 나눈다.
• 1을 뺀다. 정수 N이 주어졌을 때, 위와 같은 연산 세 개를 적절히 사용해서 1을 만들려고 한다. 연산을 사용하는 횟수의 최솟값을 출력하시오.

입력

첫째 줄에 1보다 크거나 같고, 106보다 작거나 같은 정수 N이 주어진다.

출력

첫째 줄에 연산을 하는 횟수의 최솟값을 출력한다.

예제

해결

const fs = require("fs");
const input = parseInt(fs.readFileSync("/dev/stdin").toString().trim());

const a = Array(input + 1).fill(0);

for (let i = 2; i <= input; i++) {
    a[i] = a[i - 1] + 1;

    if (i % 2 === 0) {
        a[i] = Math.min(a[i], a[i / 2] + 1);
    }

    if (i % 3 === 0) {
        a[i] = Math.min(a[i], a[i / 3] + 1);
    }
}

console.log(a[input]);

a[i - 1] + 1 은 i에서 1을 빼는 연산을 한 번 한 뒤, 남은 값 ( i − 1 )를 1로 만드는 연산 횟수(a[i-1])에 더합니다.

i % 2 === 0 i가 2의 배수일 때 i/2에서 2를 곱해 i가 된다고보고 (a[i - 1] + 1) 중 작은 쪽을 선택합니다.

i % 3 === 0 이면 i/3에서 3을 곱해 i가 된다고 보고, a[i] = min(a[i],a(i/3)+1)으로 갱신

두 개의 자연수를 입력받아 최대 공약수와 최소 공배수를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에는 두 개의 자연수가 주어진다. 이 둘은 10,000이하의 자연수이며 사이에 한 칸의 공백이 주어진다.

출력

첫째 줄에는 입력으로 주어진 두 수의 최대공약수를, 둘째 줄에는 입력으로 주어진 두 수의 최소 공배수를 출력한다.

예제

해결

const fs = require("fs");
const input = fs.readFileSync("/dev/stdin").toString().trim().split(" ").map((item) => Number(item));

let a = input[0];
let b = input[1];

while(a % b !== 0){
    let r = a % b;

       if(r !== 0){
        a = b;
        b = r;
    }
}
console.log(b);
console.log((input[0] * input[1]) / b);

유클리드 호제법으로 구하는 문제입니다. 유클리드 호제법에 대한 내용은 해당링크에 정리되어 있습니다. https://ko.wikipedia.org/wiki/%EC%9C%A0%ED%81%B4%EB%A6%AC%EB%93%9C_%ED%98%B8%EC%A0%9C%EB%B2%95

while (a % b !== 0) {
    let r = a % b;
    if (r !== 0) {
        a = b;
        b = r;
    }
}

a % b가 0이 아닐 동안(while (a % b !== 0)) 반복해서: r = a % b 로 나머지를 구하고 그 나머지(r)가 0이 아니면 a <- b, b <- r 로 값을 갱신합니다.

console.log(b);
console.log((input[0] * input[1]) / b);

반복이 끝난 시점의 b를 출력합니다. 이 값이 바로 최대공약수입니다.

두 수의 곱을 최대공약수로 나오면 최소공배수가 나오므로 console.log((input[0] * input[1]) / b); 를 출력해줍니다.

유클리드 호제법(-互除法, Euclidean algorithm) 또는 유클리드 알고리즘은 2개의 자연수 또는 정식(整式)의 최대공약수를 구하는 알고리즘의 하나이다. 호제법이란 말은 두 수가 서로(互) 상대방 수를 나누어(除)서 결국 원하는 수를 얻는 알고리즘을 나타낸다. 2개의 자연수(또는 정식) a, b에 대해서 a를 b로 나눈 나머지를 r이라 하면(단, a>b), a와 b의 최대공약수는 b와 r의 최대공약수와 같다. 이 성질에 따라, b를 r로 나눈 나머지 r'를 구하고, 다시 r을 r'로 나눈 나머지를 구하는 과정을 반복하여 나머지가 0이 되었을 때 나누는 수가 a와 b의 최대공약수이다. 이는 명시적으로 기술된 가장 오래된 알고리즘으로서도 알려져 있으며, 기원전 300년경에 쓰인 《원론》 제7권, 명제 1부터 3까지에 해당한다. 최소공배수, 최대공약수를 구하기 위해서는 다음과 같은 표를 쓴다.

(출처 : https://ko.wikipedia.org/wiki/%EC%9C%A0%ED%81%B4%EB%A6%AC%EB%93%9C_%ED%98%B8%EC%A0%9C%EB%B2%95)

알고리즘

입력으로 두 수 m,n(m>n)이 들어온다. n이 0이라면, m을 출력하고 알고리즘을 종료한다. m이 n으로 나누어 떨어지면, n을 출력하고 알고리즘을 종료한다. 그렇지 않으면, m을 n으로 나눈 나머지를 새롭게 m에 대입하고, m과 n을 바꾸고 3번으로 돌아온다. 위 과정은 “n, m에 대해서 나머지 연산을 실시할 수 있다”라는 조건에만 의존하므로, 정수환뿐 아니라, 임의의 유클리드 정역에 대해도 똑같은 과정을 거치면 공약인자가 구해진다.

예시

1071과 1029의 최대공약수를 구하면,

1071은 1029로 나누어 떨어지지 않기 때문에, 1071을 1029로 나눈 나머지를 구한다. ≫ 42 1029는 42로 나누어 떨어지지 않기 때문에, 1029를 42로 나눈 나머지를 구한다. ≫ 21 42는 21로 나누어 떨어진다. 따라서, 최대공약수는 21이다.

78696과 19332의 최대공약수를 구하면,

78696 ＝ 19332×4 ＋ 1368 19332 ＝ 1368×14 ＋ 180 1368 ＝ 180×7 ＋ 108 180 ＝ 108×1 ＋ 72 108 ＝ 72×1 ＋ 36 72 ＝ 36×2 ＋ 0

따라서, 최대공약수는 36이다.

<그림 1>과 같이 9×9 격자판에 쓰여진 81개의 자연수 또는 0이 주어질 때, 이들 중 최댓값을 찾고 그 최댓값이 몇 행 몇 열에 위치한 수인지 구하는 프로그램을 작성하시오.

예를 들어, 다음과 같이 81개의 수가 주어지면

이들 중 최댓값은 90이고, 이 값은 5행 7열에 위치한다.

입력

첫째 줄부터 아홉 번째 줄까지 한 줄에 아홉 개씩 수가 주어진다. 주어지는 수는 100보다 작은 자연수 또는 0이다.

출력

첫째 줄에 최댓값을 출력하고, 둘째 줄에 최댓값이 위치한 행 번호와 열 번호를 빈칸을 사이에 두고 차례로 출력한다. 최댓값이 두 개 이상인 경우 그 중 한 곳의 위치를 출력한다.

예제

해결

const fs = require("fs");
const input = fs.readFileSync("/dev/stdin").toString().trim().split("\n");

const matrix = input.map(line => line.split(" ").map(Number));
const flat = matrix.flat();
const max = Math.max.apply(null, flat);

let row = 0;
let col = 0;

for (let i = 0; i < 9; i++) {
  for (let j = 0; j < 9; j++) {
    if (matrix[i][j] === max) {
      row = i + 1;
      col = j + 1;
    }
  }
}

console.log(max);
console.log(${row} ${col});

const matrix = input.map(line => line.split(" ").map(Number));

각 줄(line)을 공백으로 나눠 숫자 문자열 배열로 만들고, map(Number)로 다시 숫자로 변환해 2차원 배열 matrix를 구성합니다.

const flat = matrix.flat();
const max = Math.max.apply(null, flat);

matrix.flat()로 9×9 배열을 1차원(길이 81) 배열로 펴고, 펴진 배열을 Math.max에 인자로 풀어(apply(null, flat)) 최댓값 max를 구합니다.

let row = 0;
let col = 0;
for (let i = 0; i < 9; i++) {
  for (let j = 0; j < 9; j++) {
    if (matrix[i][j] === max) {
      row = i + 1;
      col = j + 1;
    }
  }
}

2중 for문으로 원본 matrix를 순회하며 각 요소가 max와 같을 때의 인덱스를 찾습니다. i는 행, j는 열을 나타내므로, 출력은 1부터 시작하는 행과 열의 번호를 요구하므로 i+1, j+1을 저장합니다.

9개의 서로 다른 자연수가 주어질 때, 이들 중 최댓값을 찾고 그 최댓값이 몇 번째 수인지를 구하는 프로그램을 작성하시오. 예를 들어, 서로 다른 9개의 자연수 3, 29, 38, 12, 57, 74, 40, 85, 61 이 주어지면, 이들 중 최댓값은 85이고, 이 값은 8번째 수이다.

입력

첫째 줄부터 아홉 번째 줄까지 한 줄에 하나의 자연수가 주어진다. 주어지는 자연수는 100 보다 작다.

출력

첫째 줄에 최댓값을 출력하고, 둘째 줄에 최댓값이 몇 번째 수인지를 출력한다.

예제

해결

const fs = require("fs")
const input = fs.readFileSync("/dev/stdin").toString().split("\n").map(Number);
const max = Math.max(...input);

console.log(max);
console.log(input.indexOf(max)+1);

Math.max(...input)으로 정렬된 배열의 값들 중 최대값을 뽑아냅니다. input.indexOf(max)은 배열에서 첫 번째로 max가 등장하는 인덱스(0부터 시작)를 반환하고, 문제에서 줄은 1부터(input[1]) 세기 때문에 +1을 해 줍니다.