개발 정리함

ios mobile safari 에서 SVG 가 보이지 않는 경우

심정욱 — Thu, 21 Jul 2022 22:50:38 +0900

개발을 하다 겪은 것.

version = 1.1 을 태그에 붙여보라는 말도 있었지만 안 통했다.

해결방법은 SVG 를 div 태그 안에 감싸서 넣었더니 해결했다.

2021 Dev-Matching 웹 프론트엔드 개발자(하반기) : 쇼핑몰 SPA 구현 후기 (pushState, popState)

심정욱 — Thu, 3 Mar 2022 23:39:51 +0900

https://programmers.co.kr/skill_check_assignments/199

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

오랜만에 바닐라 JS 개발을 해보고 싶었는데, 마침 SPA 개발 과제가 있길래 해보았다.

그 과정에서 긴 시간 고전한 주제에 대해 적고자 한다.

결론적으로, 난 완벽한 구현에 성공하지 못했다.

첫 번째로 SPA 라우팅 처리를 vanilla js 로 해본 게 처음이라 고전했고 (쉬운 건데 삽질했다)

두 번째로 js 에서 HTML element 를 만들 때 createElement 를 하나하나 일일히 했다. (미쳤나봄)

해답을 보니 innerHTML = `<div></div>` 식으로 편하게 했더라.

React 를 쓰는 실무에서 워낙 할 일 없던 거라 생각을 못했다.

SPA 라우팅 처리

SPA는 별도의 서버 사이드 렌더링 없이, 경로 별로 innerHTML 을 변경해주면 된다.

즉, 라우팅 처리가 굉장히 중요한 부분이라고 생각했고, history.pushState 와 popState 가 해결책이 되었다.

그 과정에서 한시간 가량 삽질한 부분에 대해 말해보고자 한다.

index.html

<html>
  <head>
    <title>커피캣 스토어</title>
    <link rel="stylesheet" href="styles.css">
  </head>
  <body>
    <main class="App">
    </main>
    <script src="src/index.js" type="module"></script>
  </body>
</html>

src 폴더의 index.js 를 body 태그 밑에 불러온다.

src/index.js

import App from "./App.js"

const start = () => {
    return App();
}

start();

create-react-app 의 구조가 익숙해서 이런 식으로 했는데, 의미가 없었던 거 같다.

src/App.js

import ProductDetail from "./pages/ProductDetail.js";
import ProductList from "./pages/ProductList.js";
import { renderAppContent } from "./utils.js";

const App = async () => {
    const app = document.getElementsByClassName("App")[0];

	// 맨 첫 페이지는 list 이므로, App 에 ProductList를 렌더한다.
	renderAppContent(await ProductList()); // ProductList 함수를 실행시킨 결과값(HTML element)를 app 에 렌더한다
    history.pushState({page : "list"}, '', `.`);  // 렌더하면서, list 로 갔다는 표시로 pushState 를 해준다.

	
    const onPageChange = async () => {
        switch(history.state.page) {
            case "list":
                renderAppContent(await ProductList());
                break;
            case "detail":
                renderAppContent(await ProductDetail({id : history.state.id}));
                break;
            default:
                return;
        }
    }

    window.addEventListener('popstate', onPageChange)
    return app;
}

export default App;

pushState 는

history.pushState( data, title, path ) 의 형태로 이루어진다.

이 때 실제로 앱 전체를 다시 불러오는 형태가 아닌, url 의 path 만 변경시키면서 data 를 history 스택에 push 하는 방식으로 진행된다.

pushState 를 하게 되면 뒤로 가기 버튼이 활성화가 된다. (실제로 하나 이동했다는 말. history.go(1) 과 같은 느낌이다 )

내가 삽질한 부분은, 첫 화면에 들어왔을 때, history.pushState 를 해주지 않고, 리스트의 항목을 클릭했을 때만 pushState 를 해준 것이다.

첫 화면(리스트)이 렌더 됐음에도 pushState 를 해주지 않았기 때문에 null 이 저장됨
리스트의 항목 중 하나를 클릭해서, pushState 를 통해 detail 페이지로 이동함 ( 잘 됐음 )
뒤로 가기 하면 popstate 이벤트가 발생하는데, 이 때 state 가 null 이었음.
근데 앞으로 가기를 다시 누르니까 디테일 페이지로 이동하면서, 디테일 페이지에 전해주려 했던 state 들이 잘 찍혔음 (이것 때문에 헷갈렸음)

나는 바보같이 pushState 를 처음에 해줘야 하는 지 몰랐다. 그래서 계속 null 이 나타나서 한시간 가량 날렸다. ㅋㅋ

저 한줄을 추가하자 거짓말 처럼 잘 됐다.

두 번째 실수 : innerHTML = <div> 를 쓰지 않음

나의 ProductDetail 페이지 코드를 보면 ( 다 안 읽는 걸 추천한다 )

import { makeElement } from "../utils.js"

const ProductDetail = async ({id, name, imageUrl, price}) => {
    const productDetailPage = makeElement("div", "ProductDetailPage");

    const productDetailPageTitle = makeElement("h1");
    productDetailPageTitle.innerText = `${name} 상품 정보`;
    productDetailPage.appendChild(productDetailPageTitle);

    const productDetail = makeElement("div", "ProductDetail");

    const produdctImage = makeElement("img", "", {
        src : imageUrl
    })

    productDetail.appendChild(produdctImage);

    const productDetailInfo = makeElement("div", "ProductDetail__info");

    const productDetailInfoTitle = makeElement("h2");
    productDetailInfoTitle.innerText = `${name}`;
    productDetailInfo.appendChild(productDetailInfoTitle)

    const productDetailPrice = makeElement("div", "ProductDetail__price");
    productDetailPrice.innerText = `${price}원~`;
    productDetailInfo.appendChild(productDetailPrice)

    const productSelectElement = makeElement("select");
    const defaultOption = makeElement("option");
    defaultOption.innerText = `선택하세요.`;
    productSelectElement.appendChild(defaultOption);

    productDetailInfo.appendChild(productSelectElement)
    
    const selectedOptions = makeElement("div", "ProductDetail__selectedOptions");
    const selectedOptionsTitle = makeElement("h3");
    selectedOptionsTitle.innerText = `선택된 상품`;

    const selectedOptionsUl = makeElement("ul");
    selectedOptions.appendChild(selectedOptionsUl);

    productDetailInfo.appendChild(selectedOptions);

    productSelectElement.onchange = () => {
        const selected = productSelectElement.options[productSelectElement.selectedIndex].value
        console.log(selected)
        productSelectElement.value = productSelectElement.options[0].value;

        const selectedOption = makeElement("li");
    }

    try {
        const {productOptions} = await (await fetch(`https://uikt6pohhh.execute-api.ap-northeast-2.amazonaws.com/dev/products/${id}`)).json();
        productOptions.forEach((productOption) => {
            const option = makeElement("option");
            option.innerText = `${name} ${productOption.name}`;
            if(productOption.price >= 0) {
                option.innerText += `(+${productOption.price}원)`;
            }
            if(productOption.stock === 0) {
                option.innerText = `(품절) ${option.innerText}`;
            }
            productSelectElement.appendChild(option);
        })
        
    } catch(e) {

    }
    
    

    productDetail.appendChild(productDetailInfo);
    productDetailPage.appendChild(productDetail)

    return productDetailPage;
}

export default ProductDetail;

너무 힘들었다.

왜 productDetailPage.innerHTML = `blahblah` 를 생각하지 못했을까?

해답을 보고 힘이 다 빠져버렸다..

데브 매칭은 바닐라 JS 로 항상 이루어졌고, 앞으로도 그럴 것 같다. (프레임워크 별로 차이가 있는데, 리액트만 받을 순 없자나.. )

배울 게 아직도 많다는 걸 여실히 깨달은 하루였다.

이 과제에서의 남은 점은, UI 조작의 자잘한 부분 ( 가격에 콤마찍기, 선택 물품 가격 계산하기) 와 주문하기 ( 로컬 스토리지 사용하기 ) 인 것 같은데, 이것들은 쉬우니까 더 안봐도 될 것 같다.

SPA 구현을 해보는 데 굉장히 좋은 기회가 되었다.

고양이 사진첩 만들기 (상반기 문제) 도 풀어 봐야지.

동기, 비동기, 이벤트 루프, 매크로태스크, 마이크로태스크 이해하기 (1) : 동기와 비동기란

심정욱 — Sun, 12 Dec 2021 23:43:36 +0900

오랜만입니다!

정~~~말 오랜만에 글을 쓰네요.

이사도 하고, 일도 바쁘고 하다 보니 이제야 글을 다시 쓰게 되었습니다.

Javascript 개발자의 영원한 친구(이자 숙적), 비동기

Javascript 개발을 할 때마다 느끼는 감정

나는 어느덧 회사에서 react 개발 5개월 차가 되었고, 내가 겪은 대부분의 문제들은 비동기적인 실행으로 인한 이슈들이었다. 그만큼 정말 흔한 이슈이고, 그렇기에 자바스크립트에서 코드가 실행되는 순서를 잘 파악할 수 있는 사람이 실력있는 사람이라고 생각한다. 가보자!

동기 vs 비동기

출처 : https://velog.io/@daybreak/%EB%8F%99%EA%B8%B0-%EB%B9%84%EB%8F%99%EA%B8%B0-%EC%B2%98%EB%A6%AC

동기와 비동기는 딱 한 문장으로 정의할 수 있다.

결과가 나올 때 까지 기다려야 하면 동기, 아니면 비동기

위의 그림을 예로 들면,

기다리는 사람들은 앞 사람이 주문 + 커피 수령하는 시간까지 모두 기다려야 한다 => 동기

기다리는 사람들은 앞 사람이 주문하는 시간만 기다리면 된다.

그리고, 자유롭게 유튜브를 보다가, 진동벨이 울리면 커피를 수령하러 가면 된다. => 비동기

이다. 너무 쉽다!

동기 비동기는 이해했는데요, 자바스크립트는 왜 비동기인가요?

카페와 웹사이트의 공통점은,

1. 사용자가 많다

2. 그 사용자들을 기다리게 하면 모두 떠나갈 것이다.

이다. 웹 사이트는 반드시, 무조건 빨라야한다. 나 같은 90년대 생들은 이해할 것이다. 네이버 블로그에서 동영상 볼 때 버퍼링의 심각함을.. (요새 애들은 버퍼링이 뭔지 알까?)

이렇게 말하면 비동기가 무조건 좋은 거 아닌가? 동기가 왜 필요해 그럼? 이라는 의문이 생길 수 있는데, 다시 카페를 예로 들면

5명의 손님이 왔을 때,

비록 마지막 손님은 많이 기다려야 하겠지만, 적어도 손님들은 온 순서대로 음료를 받을 것이다. => 동기

합리적인 카페 사장은 3번째 손님이 주문한 레인보우샤베트커피토피넛그린라떼보다, 간단한 아메리카노를 시킨 마지막 손님에게 음료를 줄 수 있다. => 비동기

차이를 알겠는가?

동기는, 코드가 작성된 순서대로 반드시 실행된다는 이점이 있다.

100ms 를 들여 받아온 결과값 A를 기반으로 B() 함수를 실행할 때, A가 없을 것이라는 걱정은 안해도 된다는 것이다.

하지만 비동기는 코드가 작성된 순서대로 실행되지 않는다.

A를 B() 함수에서 사용하려고 하는데, A가 받아와지기도 전에 B가 실행되면 오류가 생길 것이다.

이제 비동기와 동기의 장단점을 완벽히 알았을 것이라고 믿는다.

동기는, 코드가 작성된 순서대로 실행되지만, 그렇기에 느리다.

비동기는 코드가 작성된 순서대로 실행되지 않지만, 빠르다.

만약 유튜브 동영상을 로딩하는데 10초가 걸린다고 가정했을 때, 코드가 다음과 같다면,

영상받아오기() // 10s
댓글받아오기() // 10ms
관련동영상받아오기() // 100ms

10초동안, 우리는 댓글도 관련동영상도 받아올 수 없다. 그런 웹사이트는 보지 못했을 것이고, 봤다면 뒤로가기로 뛰쳐 나왔을 것이다.

이벤트 루프?

그럼 이제 카페 주방으로 가보자. 비동기적으로 주문을 받았고, 알바생은 다음의 음료들을 만들어야 한다.

1번 손님의 아메리카노 6잔 -> 3m
2번 손님의 아이스 돌체 라떼 -> 2m
3번 손님의 알바생고생시키는음료 -> 10m

그럼 우리는 카페가 비동기적일 경우,

2분 후에 2번 손님이 아이스 돌체 라떼를 받고
1분 후에 ( 총 3분 후 ) 1번 손님이 아메리카노를 받은 뒤
7분 후( 총 10분 후 ) 3번 손님이 알바생고생시키는음료를 받는다

를 직관적으로 예상할 수 있다.

그럼 Javascript 런타임 엔진이 이런 일을 실제로 한다는 것인데, 그걸 어떻게 하는가?

그것을 다음 글에서 다룰 것이다.

이벤트 루프와, 매크로태스크, 마이크로태스크, async/await, Promise 등.. 할 게 너무 많지만, 차근차근 해보자.

Javascript 변수 선언법 var 에 대하여 : 호이스팅, IIFE

심정욱 — Tue, 7 Sep 2021 18:15:06 +0900

앞서

이 글은 https://ko.javascript.info/var

[

오래된 'var'

ko.javascript.info

](https://ko.javascript.info/var)

이 링크의 글을 기반으로 작성하고 있습니다.

Javascript 의 변수 선언

Javascript 를 처음 시작하는 분들이라면, 사실 굳이 몰라도 되는 개념이 바로 var 이다. 하지만 언젠가는 알아야 한다. 다른 사람의 코드를 봐야 할 일이 분명히 생기고, 레거시 코드를 다루면서 let 이나 const 로 고쳤을 때 예기치 못한 에러가 발생할 수도 있다. 그러므로 이 글에서 Javascript 의 변수 선언식 중 가장 오래 되었고, 가장 관대한 변수 선언식인 var 를 알아보자.

Javascript 에는 세 가지의 변수 선언 방식이 있다.

let
const
var

최신 Javascript 문법으로 배운 사람들은 let 과 const만 사용하라는 말을 많이 봤을 것이다. let 은 일반 변수를 선언할 때, const 는 변하지 않는 값을 나타낼 때 사용한다고 말이다. 하지만 오래된 코드를 보다보면 var 가 많이 쓰이는 데, 통상적으로 var 는 let 으로 바꿔도 크게 문제가 발생하지 않는다.

하지만 var 는 초기 자바스크립트 구현 방식 때문에 let 과 const 로 선언한 변수와는 다른 방식으로 동작한다. 어떻게 다른지 한번 보자.

var 는 블록 스코프가 없다

var 로 선언한 변수의 스코프는 함수 스코프이거나 전역 스코프이다. 블록 기준으로 스코프가 생기지 않기 때문에, 블록 안에서 선언된 변수를 블록 밖에서 접근 가능하다.

if (true) {
  var test = true; // 'let' 대신 'var'를 사용했습니다.
}

alert(test); // true(if 문이 끝났어도 변수에 여전히 접근할 수 있음)

반복문에서도 같은 일이 일어난다.

for (var i = 0; i < 10; i++) {
  // ...
}

alert(i); // 10, 반복문이 종료되었지만 'i'는 전역 변수이므로 여전히 접근 가능합니다.

var 가 함수 안에 있다면, 함수 스코프에 있는 변수가 된다.

function sayHi() {
  if (true) {
    var phrase = "Hello";
  }

  alert(phrase); // 제대로 출력됩니다.
}

sayHi();
alert(phrase); // Error: phrase is not defined

오래 전의 자바스크립트에서는 블록 수준의 렉시컬 환경이 만들어 지지 않았기 때문이라고 한다.

var 와 let 의 차이점 : var 는 재선언이 된다.

만약 let 으로 이미 선언된 변수를 다시 선언하면, 에러가 발생한다.

let user;
let user; // SyntaxError: 'user' has already been declared

반면에 var 로 선언된 변수는 몇 번을 재선언해도 상관없다.

만약에 var 로 선언된 변수를 다시 var 로 재선언하게 되면, var 라는 키워드는 무시당한다.

var user = "Pete";

var user = "John"; // this "var" does nothing (already declared)
// ...it doesn't trigger an error

alert(user); // John

호이스팅

var 선언은 함수가 시작될 때 처리된다. 전역에서 선언한 var 변수라면, 스크립트가 시작될 때 처리된다;.

함수 본문 내에서 var 로 선언한 변수는 선언 위치와 상관없이, 함수 본문이 시작되는 지점에서 정의된다.

function sayHi() {
  phrase = "Hello";

  alert(phrase);

  var phrase;
}
sayHi();

이런 함수가 있다면, 암묵적으로 var phrase 가 함수가 시작될 때 처리된다.

function sayHi() {
  var phrase;

  phrase = "Hello";

  alert(phrase);
}
sayHi();

블록 스코프는 무시되기 때문에, 아래 코드 역시 위처럼 동작한다.

function sayHi() {
  phrase = "Hello"; // (*)

  if (false) {
    var phrase;
  }

  alert(phrase);
}
sayHi();

이렇게 변수가 끌어올려 지는 현상을 호이스팅 이라고 한다.

위 함수에서, if (false) 블록 안의 코드는 절대 실행되지 않지만, 호이스팅에는 전혀 영향을 주지 않는다. if 블록 내부의 var 는 sayHi 함수의 시작 부분에서 처리되기 때문에, 이미 (*) 부분에서 phrase 는 선언이 되어 있는 상태이다.

그리고 주의할 것이 있다.

선언은 호이스팅 되지만, 할당은 호이스팅 되지 않는다.

예시를 살펴보자.

function sayHi() {
  alert(phrase);

  var phrase = "Hello";
}

sayHi();

var phrase = "Hello" 행에선 두 가지 일(변수의 선언과 할당)이 일어난다.

변수 선언은 함수 실행이 시작될 때 처리되지만(호이스팅) 할당은 호이스팅되지 않기 때문에, 위 코드는 아래처럼 동작한다.

function sayHi() {
  var phrase; // 선언은 함수 시작 시 처리됩니다.

  alert(phrase); // undefined

  phrase = "Hello"; // 할당은 실행 흐름이 해당 코드에 도달했을 때 처리됩니다.
}

sayHi();

이처럼 모든 var 선언은 함수 시작 시(전역일 경우 스크립트 시작 시 ) 처리되기 때문에, var 로 선언한 변수는 어디서든 참조할 수 있다. 값을 할당하기 전에는 undefined 가 뜨지만 말이다.(할당은 호이스팅 되지 않기 때문이다)

즉시 실행 함수 표현식 ( IIFE )

지금이야 let 과 const 라는 선택지가 있었지만, 옛날에는 정말 선택지가 var 뿐이었다. 그런데 var 는 블록 스코프를 가질 수가 없다. 개발자들은 var 도 블록 스코프를 가질 수 있게 여러가지 방안을 고려하게 되었고, 이 때 만들어진 것이 즉시 실행 함수 표현식(Immediately-invocked function expressions) 이다. 줄여서 IIFE 라고도 한다. (개인적으로 면접 질문으로 받아봤다)

요즘에는 당연히 쓸 일이 없다. let 과 const 가 대놓고 권장되고 있기 때문에. 하지만 오래된 코드를 보다보면 만날 수 있기 때문에 뭔지 알아 둘 필요가 있다.

IIFE는 다음과 같이 생겼다.

(function() {

  let message = "Hello";

  alert(message); // Hello

})();

함수를 함수 표현식으로 만든 다음에, 바로 호출해버리는 것이다.

즉시 실행 함수를 만들 때는, 함수 표현식을 괄호로 둘러쌓아 ( function() {...} ) 의 형태로 만들어 줘야 한다. (안하면 에러가 난다)

자바스크립트는 function 키워드를 만나는 순간, 함수 선언문이 시작될 것이라 예상한다. 근데 함수 선언문으로 함수를 만들 때는 함수의 이름이 반드시 있어야 한다. 그래서 아래처럼 하면 에러가 난다.

// 함수를 선언과 동시에 실행하려고 함
function() { // <-- Error: Function statements require a function name

  let message = "Hello";

  alert(message); // Hello

}();

"그럼 이름 넣으면 되는 거 아닌가?" 라고 생각해서 넣어봐도 에러가 발생한다. 자바스크립트는 함수 선언문으로 정의한 함수를 정의와 동시에 바로 호출하는 것을 허용하지 않기 때문이다.

// 맨 아래의 괄호 때문에 문법 에러가 발생합니다.
function go() {

}(); // <-- 함수 선언문은 선언 즉시 호출할 수 없습니다.

하지만 함수를 괄호로 감싸면, 자바스크립트가 함수를 함수 선언문이 아닌 표현식으로 인식하도록 속일 수 있다. 함수 표현식은 이름이 없어도 괜찮고, 즉시 호출도 가능하다.

괄호를 사용하는 방법 말고도, 자바스크립트가 함수 표현식이라고 인식하게 해주는 다른 방법들이 있다.

// IIFE를 만드는 방법

(function() {
  alert("함수를 괄호로 둘러싸기");
})();

(function() {
  alert("전체를 괄호로 둘러싸기");
}());

!function() {
  alert("표현식 앞에 비트 NOT 연산자 붙이기");
}();

+function() {
  alert("표현식 앞에 단항 덧셈 연산자 붙이기");
}();

물론 모던 자바스크립트에서는 별 필요 없다. 알아만 두자!

요약

var 로 선언한 변수는 let 과 const 로 선언한 변수와 다른 두 가지 주요한 특성을 보인다.

var 로 선언한 변수는 블록 스코프가 아닌 함수 스코프를 갖는다.
var 선언은 함수가 시작되는 시점(전역에선 스크립트 시작 시점)에서 처리된다. (호이스팅)

이 특성들은 대부분의 상황에서 부작용을 만들어 내고, let 이 표준으로 도입된 이유가 바로 이것이다. 변수는 블록 레벨 스코프를 갖는 게 좋기 때문이다. 이것이 let 과 first 가 대세가 된 이유이다.

Javascript 클로저가 대체 뭘까? - 변수의 유효 범위와 클로저

심정욱 — Tue, 7 Sep 2021 13:56:58 +0900

대체 클로저가 뭐에요

클로저는 Javascript 개발자에게 단골 면접 질문이다.

뭔가 한마디로 정의하기가 어려웠던 개념이다.

https://ko.javascript.info/closure

변수의 유효범위와 클로저

ko.javascript.info

나는 이 글을 읽으면서, 내 나름대로 클로저에 대해 정리해보고자 한다. 면접에서 질문을 받았을 때 완벽히 설명할 수 있을만큼 말이다!

시작한다.

중첩 함수

함수 내부에서 선언한 함수를 중첩 함수( Nested function ) 이라고 한다.

function greet(firstName, lastName) {
  function getFullName() {
    return `${firstName} ${lastName}`;
  }
  
  alert("Hello, " + getFullName());
  alert("Bye, " + getFullName());
}

중복되는 코드를 줄이기에 좋은 방식으로, 자바스크립트에 익숙하다면 자연스럽게 쓰고 있을 것이다.

이제 클로저를 설명할 때, 혹은 질문을 받을 때 가장 단골로 나오는 makeCounter 예제를 보자.

function makeCounter() {
  let count = 0;

  return function() {
    return count++;
  };
}

let counter = makeCounter();

alert( counter() ); // 0
alert( counter() ); // 1
alert( counter() ); // 2

의문이 들 것이다.

대체 왜 0, 1, 2 가 찍히지?

나는 0,0,0 이 찍히는 게 맞지 않나? 생각했다.

함수가 실행될 때 마다 count 가 0이 되고, count++ 이 되지만 리턴 후에 적용되기 때문에 0,0,0 이 찍히는 게 맞지 않나??????

이런 의문을 해결할 수 있게 되면 자바스크립트 숙련도가 올라간다고 한다. 가보자!

렉시컬 환경

자바스크립트에선

1. 실행 중인 함수,

2. 코드 블록( {...} ) ,

3. 스크립트 전체

는 Lexical Environment 라 불리는 내부 숨김 연관 객체(Internal hidden associated object) 를 갖는다.

(일단 넘어가자)

렉시컨 환경 객체는 두 부분으로 구성된다.

1. 환경 레코드(Environment Record)

모든 지역 변수를 프로퍼티로 저장하고 있는 객체. this 값과 같은 정보도 여기에 저장된다.

2. 외부 렉시컬 환경에 대한 참조 - 외부 코드와 연관됨

즉,

변수는 특수 내부 객체인 환경 레코드

의 프로퍼티일 뿐이다.

즉 변수를 가져오거나 변경하는 것은, 환경 레코드의 프로퍼티를 가져오거나 변경함을 의미한다.

let phrase = "Hello";

alert(phrase);

위의 두 줄짜리 코드엔 하나의 렉시컬 환경이 존재한다.

이런 식이 될 것이다.

이렇게 스크립트 전체와 관련된 렉시컬 환경을 전역 렉시컬 환경이라고 한다.

전역 렉시컬 환경은 당연히, 외부 렉시컬이 없으므로 null 을 가리킨다. ( global 보다 더 큰 scope 는 없으니까! )

좀 더 긴 걸 보자.

오른쪽의 네모 상자들은 코드가 한 줄 한 줄 실행될 때마다 전역 렉시컬 환경이 어떻게 변화하는지 보여준다,

스크립트가 시작되면, 스크립트 내에서 선언한 변수 전체가 렉시컬 환경의 프로퍼티로 올라간다.
1. 이 때 변수의 상태는 특수 내부 상태(special internal state) 인 `uninitialized` 가 된다.
2. 자바스크립트 엔진은 uninitialized 상태의 변수를 인지하긴 하지만, let 을 만나기 전까진 이 변수를 참조할 수 없다.
let 이 나타났다! 값을 아직 할당하지 않았기 때문에 phrase 프로퍼티의 값은 undefined 이다. pharse 는 이 시점 이후부터 참조될 수 있다.
phrase 에 "Hello"가 할당되었다.
phrase 에 "Bye"가 할당되었다.

아직까지 어려운 건 없다. 지금까지 배운 것을 요약해보면,

렉시컬 환경에는 환경 레코드와 외부 환경에 대한 참조가 있다.
변수는 환경 레코드의 프로퍼티이다.
환경 레코드는 현재 실행 중인 함수와 코드 블록, 스크립트와 연관되어 있다.
변수를 변경하면 환경 레코드의 프로퍼티가 변경된다.

함수 선언문

함수도 변수와 마찬가지로, 환경 레코드의 값이다. 하지만 변수와의 큰 차이가 있는데,

함수 선언문(function declaration) 으로 선언한 함수는 일반 변수와는 달리 바로 초기화된다.

함수 선언문으로 선언한 함수는 렉시컬 환경이 만들어지는 즉시 사용할 수 있다.

변수는 let을 만나 선언이 될 때까지 사용할 수 없는데 말이다. (unintialized 상태로 가는 데 말이다)

이런 동작 방식은 함수 선언문으로 정의한 함수에만 적용된다.

let say = function (name) {...} 같이 함수를 변수에 할당한 함수 표현식은 해당하지 않는다.

내부와 외부 렉시컬 환경

함수를 호출해 실행하면 새로운 렉시컬 환경이 자동으로 만들어진다.

이 렉시컬 환경엔 함수 호출 시 넘겨받은 매개변수와 함수의 지역 변수가 저장된다.

함수가 호출 중인 동안에,

호출 중인 함수를 위한 내부 렉시컬 환경 (name : "John" 이 매개변수로써 저장된 say 함수 내부 ) 과

내부 렉시컬 환경이 가리키는 외부 렉시컬 환경을 갖게 된다. ( say : function 과 phrase : "Hello" 가 저장된 전역 렉시컬 환경 )

그리고 내부 렉시컬 환경은, 렉시컬 환경의 두 가지 요소 중 두 번째 (첫 번째는 환경 레코드인거 아시죠 ? ) 인 "외부 렉시컬 환경에 대한 참조"를 갖는다. 즉 전역 렉시컬 환경을 가리키는 것이다.

변수의 값을 찾아가는 과정

내부 렉시컬 환경을 먼저 찾는다
내부에 없다면, 내부에서 참조하고 있는 외부 렉시컬 환경에서 찾는다.
전역 렉시컬 환경에 도달할 때 까지, 2번을 반복한다.

즉,

내부 -> 외부 -> 외부의 외부 -> 외부의 외부의 외부 -> 외부의 외부의 .... -> 전역 렉시컬

까지 찾는 것이다. 너무 직관적이고 쉽지 않은가?

전역 렉시컬에서도 못 찾으면??

엄격 모드 : 에러가 발생한다.
비엄격 모드 : 새로운 전역 변수를 만들어낸다.

이 예시를 보면서 변수 검색 과정을 보자.

내부 렉시컬은 name : "John" 이 들어있는, say 의 렉시컬 환경이고, say 가 참조하는 외부 렉시컬(전역 렉시컬) 에는

phrase : "Hello" 와 say : function 이 담겨 있다.

함수 say 내부의 alert 에서, 변수 name 에 접근할 때 먼저 내부 렉시컬 환경을 살펴본다. 내부 렉시컬 환경에서 name 을 찾았다.
phrase 를 찾아야 하는데, 내부 렉시컬 환경에 없다. 외부 렉시컬 환경으로 확장한다. 찾았다!

함수를 반환하는 함수

function makeCounter() {
  let count = 0;

  return function() {
    return count++;
  };
}

let counter = makeCounter();

makeCounter 예시로 돌아오자.

makeCounter() 를 호출할 때마다, 새로운 렉시컬 환경 객체가 만들어지고, 여기에 makeCounter() 를 실행하는데 필요한 변수들이 저장된다.

makeCounter의 내부 렉시컬 환경에는 count : 0이 저장되고, 내부에서 참조하는 외부 렉시컬(전역) 은 makeCounter : function 과 counter : undefined 를 가지고 있다.

근데 위의 say("John") 예제와의 차이가 있는데, 바로 makeCounter() 는 한줄 짜리인 중첩 함수가 만들어진다는 것이다. (return count++) 현재는 중첩 함수가 생기기만 하고 실행은 되지 않은 상태이다.

여기서 클로저에 대해 검색할 때 가장 많이 나오는 말이 나온다.

모든 함수는 함수가 생성된 곳의 렉시컬 환경을 기억한다.

함수는 [[Environment]] 라 불리는 숨김 프로퍼티를 갖는데, 여기에 함수가 만들어진 곳의 렉시컬 환경에 대한 참조가 저장된다.

여기서 counter.[[Environment]] 에는 { count : 0 } 이 있는 렉시컬 환경 ( 즉, makeCounter 함수의 내부 렉시컬) 에 대한 참조가 저장된다. 호출 장소와 상관없이 함수가 자신이 태어난 곳을 기억할 수 있는 건, 이 [[Environment]] 프로퍼티 덕분이다.

[[ Environment ]] 는 함수가 생성될 때 딱 한 번 값이 세팅되고, 영원히 변하지 않는다.

counter() 를 호출하면, 각 호출마다 새로운 렉시컬 환경이 생성된다. 그리고 이 렉시컬 환경은 counter.[[Environment]] 에 저장된 렉시컬 환경을 외부 렉시컬로 참조한다.

function() { return count++; } 의 내부 렉시컬에는 아무 프로퍼티도 없다. ( 당연하다. 매개변수도 지역변수도 없으니 ) 그리고 [[ Environment]] 에는 makeCounter() 의 내부 렉시컬에 대한 참조 값이 저장된다.

맨 마지막 줄의 alert() 으로 넘어오면 count 변수가 필요하다. 내부 렉시컬 환경에서 count 를 찾아서 count++ 을 해주려고 하는데, 없다! 그러면 어떻게 하는지 기억날 것이다. 찾을 때 까지 외부로 가는 것이다. 즉 makeCounter() 의 내부 렉시컬에서 count 를 찾아내는 것이다.

그럼 이제 값이 갱신되어야 한다. 이 때, 변수값 갱신은 변수가 저장된 렉시컬 환경에서 이루어진다. ( 까먹었다면, 맨 위 렉시컬 환경 파트의 네 번째 줄을 보자. )

counter() 를 여러 번 호출하면 count 변수가 2,3 으로 증가하는 이유가 바로 여기에 있다.

클로저

클로저는 외부 변수를 기억하고, 이 외부 변수에 접근할 수 있는 함수를 의미한다. 자바스크립트에서는 모든 함수가 자연스럽게 클로저가 된다! 예외가 하나 있긴 하다고 하는데, 자세한 건 new Function 문법 에서 찾아보자. (나중에 정리하긴 할 것이다!)

요점을 정리하면, 함수는 숨김 프로퍼티인 [[ Environment ]] 를 이용해 자신이 어디서 만들어졌는지를 기억한다.

함수 본문에서는 [[ Environment ]] 를 사용해 외부 변수에 접근한다.

가비지 컬렉션

함수 호출이 끝나면 함수에 댁응하는 렉시컬 환경이 메모리에서 제거된다. 함수와 관련된 변수들은 이때 모두 사라져버린다. 함수 호출이 끝나면 관련 변수를 참조할 수 없는 것이 바로 이거 때문이다.모든 객체는 도달 가능한 상태일 때만 메모리에서 유지되기 때문이다.

그런데 호출이 끝난 후에도, 여전히 도달 가능한 중첩 함수가 있을 수 있다. 이 때는 이 중첩 함수의 [[ Environment ]] 프로퍼티에 외부 함수 렉시컬 환경에 대한 정보가 저장된다. 도달 가능한 상태가 되는 것이다.

function f() {
  let value = 123;

  return function() {
    alert(value);
  }
}

let g = f(); // g.[[Environment]]에 f() 호출 시 만들어지는
// 렉시컬 환경 정보가 저장됩니다.

그래서 중첩함수를 사용할 때는 주의점이 있다. f() 를 호출 하고 그 결과를 어딘가에 저장하는 경우, 호출 시 만들어지는 각 렉시컬 환경 모두가 메모리에 유지된다는 점이다.

function f() {
  let value = Math.random();

  return function() { alert(value); };
}

// 배열 안의 세 함수는 각각 f()를 호출할 때 생성된
// 렉시컬 환경과 연관 관계를 맺습니다.
let arr = [f(), f(), f()];

렉시컬 환경 객체는 다른 객체와 마찬가지로 도달할 수 없을 때 메모리에서 삭제된다. 해당 렉시컬 환경 객체를 참조하는 중첩 함수( 여기에서는 alert(value) 가 있는 function 함수 ) 가 하나라도 있다면, 영원히 사라지지 않는다. ( 여기서는 value )

아래처럼 중첩 함수가 메모리에서 삭제되고 난 후에야 그 중첩 함수를 감싸는 렉시컬 환경 ( value ) 도 메모리에서 제거된다.

function f() {
  let value = 123;

  return function() {
    alert(value);
  }
}

let g = f(); // g가 살아있는 동안엔 연관 렉시컬 환경도 메모리에 살아있습니다.

g = null; // 도달할 수 없는 상태가 되었으므로 메모리에서 삭제됩니다.

최적화

앞에서 본 것 처럼, 이론상으론 함수가 살아있다면 모든 외부 변수가 메모리에 유지된다.

하지만 실제로는 자바스크립트 엔진이 이를 지속해서 최적화한다. 변수 사용을 분석하고 외부 변수가 사용되지 않는다고 판단되면 메모리에서 제거한다. 이것이 부작용을 일으킬 수도 있는데,

function f() {
  let value = Math.random();

  function g() {
    debugger; // Uncaught ReferenceError: value is not defined가 출력됩니다.
  }

  return g;
}

let g = f();
g();

value 가 정의되지 않았다고 한다. 이론상으로는 value 에 접근할 수 있어야 하는데, 최적화의 대상이 되어서 이런 에러가 발생한 것이다. 그래서 이런 최적화 때문에 때로는 이상한 문제가 발생하기도 한다.

let value = "이름이 같은 다른 변수";

function f() {
  let value = "가장 가까운 변수";

  function g() {
    debugger; // 콘솔에 alert(value);를 입력하면 '이름이 같은 다른 변수'가 출력됩니다.
  }

  return g;
}

let g = f();
g();

g() 가 생성된 환경 ( f() 의 내부 렉시컬 ) 의 value 인 "가장 가까운 변수" 를 출력해야 한다고 생각하지만, 가비지 컬렉션에 의해 "이름이 같은 다른 변수" 를 출력하는 것이다. 알아두면 좋을 것 같다. 알고 이 문제를 직면하는 것과 모르는 것은 천지차이니까 말이다.

문제를 풀어봅시다!

1. 함수는 가장 최근의 변화를 감지할까요?

let name = "John";

function sayHi() {
  alert("Hi, " + name);
}

name = "Pete";

sayHi(); // what will it show: "John" or "Pete"?

답은 Pete 입니다. 가장 최근의 값을 사용하기 때문입니다.

2. 어떤 변수가 사용 가능할까요?

function makeWorker() {
  let name = "Pete";

  return function() {
    alert(name);
  };
}

let name = "John";

// create a function
let work = makeWorker();

// call it
work(); // what will it show?

makeWorker 는 내부 함수를 만들고 리턴하고 있습니다. 내부 함수의 alert에서 사용하는 name 은 어떤 것일까요?

당연히 "Pete" 입니다.

가장 가까운 외부 렉시컬 환경에서의 변수 값을 가져오기 때문입니다.

3. counter 는 독립적일까요?

function makeCounter() {
  let count = 0;

  return function() {
    return count++;
  };
}

let counter = makeCounter();
let counter2 = makeCounter();

alert( counter() ); // 0
alert( counter() ); // 1

alert( counter2() ); // ?
alert( counter2() ); // ?

makeCounter를 사용해 두 개의 카운터를 만들었습니다.

출력 값은 0,1,2,3 일까요?

답은 0,1,0,1 입니다.

각각 다른 makeCounter 호출에 의해 만들어졌기 때문입니다.

makeCounter one 과 two 가 생성된 환경은 각각 다르니까요!

4. 생성자 함수를 이용해 counter 객체를 만들었다.

function Counter() {
  let count = 0;

  this.up = function() {
    return ++count;
  };
  this.down = function() {
    return --count;
  };
}

let counter = new Counter();

alert( counter.up() ); // ?
alert( counter.up() ); // ?
alert( counter.down() ); // ?

이 코드의 실행 결과는 어떨까요?

의도한 대로 잘 동작합니다. 1,2,1 이 될 겁니다.

this.up 에 저장된 중첩 함수와 this.down 에 저장된 중첩 함수 모두 동일한 외부 렉시컬 환경에서 만들어졌기 때문에, 같은 count 변수를 공유합니다. ( 헷갈리지 마세요. 앞서 언급한 클로저가 되지 않는 함수 선언 방식인 new Function 과는 다른, 생성자 함수입니다!! )

5. if 문 안의 함수

let phrase = "Hello";

if (true) {
  let user = "John";

  function sayHi() {
    alert(`${phrase}, ${user}`);
  }
}

sayHi();

에러가 발생합니다.

if 문 안에서 정의되었기 때문에 sayHi 는 if 블록의 렉시컬 환경에 있습니다. ( 실행 중인 함수, 코드 블럭, 스크립트 전체는 렉시컬 환경을 갖는 거 기억하시죠? )

즉 sayHi 를 전역 렉시컬 환경에서 호출하면, 내부까지 들어가는 것이 아니므로 에러가 발생합니다.

6. 클로저의 활용

sum(1)(2) = 3
sum(5)(-1) = 4

이런 연산을 해주는 함수 sum 을 만들어보세요.

function sum(a) {
	return function (b) {
      return a + b;
    }
}

alert(sum(1)(2))

난 이렇게 짰다!

7. 함수를 이용해 원하는 값만 걸러내기

배열에 사용할 수 있는 내장 메서드 arr.filter(func) 는 함수 func 의 반환 값을 true 로 만드는 모든 요소를 배열로 반환해줍니다.

filter 에 넘겨서 사용할 수 있는 함수 두 가지를 만들어봅시다.

inBetween(a, b) - a 이상 b 이하
inArray([...]) - 배열 안에 있는 값인가

위 함수를 활용하면 다음과 같은 결과가 나와야 합니다.

arr.filter(inBetween(3,6)) – 3과 6 사이에 있는 값만 반환함

arr.filter(inArray([1,2,3])) – [1,2,3] 안에 있는 값과 일치하는 값만 반환함

/* ... 여기에 두 함수 inBetween과 inArray을 만들어주세요 ...*/
let arr = [1, 2, 3, 4, 5, 6, 7];

alert( arr.filter(inBetween(3, 6)) ); // 3,4,5,6

alert( arr.filter(inArray([1, 2, 10])) ); // 1,2

function inBetween(a, b) {
  return function(x) {
    return x >= a && x <= b;
  }
}

function inArray(arr) {
  return function(x) {
    return arr.includes(x);
  }
}

8. 필드를 기준으로 정렬하기

객체가 담긴 배열을 정렬해야 합니다.

let users = [
  { name: "John", age: 20, surname: "Johnson" },
  { name: "Pete", age: 18, surname: "Peterson" },
  { name: "Ann", age: 19, surname: "Hathaway" }
];

아래와 같은 방법을 사용해 정렬할 수 있습니다.

// 이름을 기준으로 정렬(Ann, John, Pete)
users.sort((a, b) => a.name > b.name ? 1 : -1);

// 나이를 기준으로 정렬(Pete, Ann, John)
users.sort((a, b) => a.age > b.age ? 1 : -1);

그런데, 아래와 같이 함수를 하나 만들어서 정렬하면 깔끔할 것 같습니다.

users.sort(byField('name'));
users.sort(byField('age'));

byField 함수를 구현해봅시다.

해답

let users = [
  { name: "John", age: 20, surname: "Johnson" },
  { name: "Pete", age: 18, surname: "Peterson" },
  { name: "Ann", age: 19, surname: "Hathaway" }
];

function byField(key) {
  return (a,b) => a[key] > b[key] ? 1 : -1
}

console.log(users.sort(byField("name")))

9. 함수를 사용해 군대 만들기

function makeArmy() {
  let shooters = [];

  let i = 0;
  while (i < 10) {
    let shooter = function() { // shooter 함수
      alert( i ); // 몇 번째 shooter인지 출력해줘야 함
    };
    shooters.push(shooter);
    i++;
  }

  return shooters;
}

let army = makeArmy();

army[0](); // 0번째 shooter가 10을 출력함
army[5](); // 5번째 shooter 역시 10을 출력함
// 모든 shooter가 자신의 번호 대신 10을 출력하고 있음

왜 둘 다 10이 뜰까?

코드를 분석해보면, 반복문에서 사용되는 i 가 while 반복문의 스코프의 외부 렉시컬 환경에 있다.

즉, shooters 라는 빈 배열에는 function() {alert(i)} 가 10개 들어가게 될 텐데, 여기서 i 는 외부 렉시컬에서 선언된 i에 의존한다는 것이다.

i 가 0일 때는

shooters = [ function () { alert(0) } ] 이 될 것이고, i 가 1일 때는 shooters = [ function () { alert(1) }, function () { alert(1) } ]

이렇게 같은 값을 alert 하는 함수들이 그 개수에 맞춰 증가한다.

그럼 해결 방법은? 당연히 i 의 값을 반복문의 내부 렉시컬에 있는 값으로 대체해주는 것이다.

for문으로 바꾸거나, let j = i; 같이 선언한 후 i 대신 j 로 바꿔주자.

function makeArmy() {

  let shooters = [];

  for(let i = 0; i < 10; i++) {
    let shooter = function() { // shooter function
      alert( i ); // should show its number
    };
    shooters.push(shooter);
  }

  return shooters;
}

let army = makeArmy();

army[0](); // 0
army[5](); // 5

function makeArmy() {
  let shooters = [];

  let i = 0;
  while (i < 10) {
    let j = i;
    let shooter = function() { // shooter function
      alert( j ); // should show its number
    };
    shooters.push(shooter);
    i++;
  }

  return shooters;
}

let army = makeArmy();

army[0](); // 0
army[5](); // 5

마치며

자바스크립트 초심자에게는 상당히 어려운 개념일 것 같지만, 다 용어가 어려워서 그런게 아닐까 생각한다. 나도 이해하는데 좀 힘들었다.. 화이팅!

NestJS : @nestjs/mongoose MongooseModule 세팅 시 Authentication failed Error 해결 방법

심정욱 — Sun, 15 Aug 2021 02:24:16 +0900

하루 종일 개삽질하다가 공유합니다.

거두절미하고,

MongooseModule.forRootAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService) => ({
        uri: configService.get("DB_URL"),
        auth: {
          user: configService.get("DB_USERNAME"),
          password: configService.get("DB_PASSWORD"),
        },
        authSource : "admin"
      }),
      inject: [ConfigService],
    }),

보통 이런식으로 많이들 하실텐데요,

authSource : "admin"

이걸 집어넣자마자 바로 해결됐습니다.

이거 때문에 하루종일 몽고 재설치하고, 권한부여하고 난리를 쳤는데 허허,,

ps) authSource 가 뭐길래?

=> 몽고DB의 사용자 정보를 담아놓는 데이터베이스라고 합니다. 평소에 mongodb 를 안쓰다가 썼더니 이런 간단한걸 너무 돌아간 거 같네요.

[Typescript] typescript 입문자를 위한 지침서 - ( 1 ) 타입스크립트, 왜 필요한데요?

심정욱 — Sun, 8 Aug 2021 00:03:39 +0900

Typescript 왜 인기에요?

수요가 많은 프로그래밍 언어 순위

한국과는 상황이 많이 다른 것 같지만, 세계적으로 이렇다고 합니다. Python이 1위인 것도 그렇다치고, Javascript 도 2위인 거 알겠는데, typescript 는 뭐가 어떻길래 Java, Kotlin, C++, SQL 마저 이겨버리는 걸까요?

타입스크립트의 공식 홈페이지의 첫 배너를 보면, 한 줄 설명이 나옵니다.

타입스크립트는 에러를 잡아내주고, 실행 전에 이를 고칠 수 있게 해줍니다!

이게 별 거 아닌 것처럼 보일 수 있습니다. 아주아주 잘 짜여진 자바스크립트 코드 베이스에서 일해보신 분이거나, 큰 규모의 자바스크립트 프로젝트를 해보지 않은 분들은 특히 그렇습니다.

자바스크립트가 싫어질 때

자바스크립트나 파이썬이 특히 초심자에게 인기가 많은 이유가 뭘까요? 당연히 배우기 쉬우니까 입니다.

저는 두 언어가 입문하기 가장 좋은 이유가 바로 type 을 지정해줄 필요가 없는 것이라고 생각합니다. 초심자에게는 for 문도 힘든 역경인데, string 과 char 의 차이까지 알고 가는 것은 힘들잖아요! 포인터는 또 어떻구요.

이런 짤도 있잖아요!

그렇게 우리는 자바스크립트를 쭉 써왔습니다. var 로 변수 선언을 하면서, let 과 const 를 배운 뒤 var 을 멀리하기 시작하며 화살표 함수를 멋지게 쓰고 있었어요. 아무런 문제없이 코드는 잘 굴러갔는데, 코드가 커질 수록 몇 가지 문제가 생깁니다.

function hello(name) {
	console.log(`안녕! ${name}!`);
}

이 정도 코드는 괜찮죠! 그런데, 페이팔 등을 통해 결제 모듈을 도입해야 하는 일이 생겼다고 해봅시다.

function newPayment({ username, paymentLength, payAmount, isYearly, whereToPay, paymentType }) {
  paymentLength.toString();
}

저 정도의 인자들이 필요하다고 합니다. 그럼 저 값들은 어디서 올까요? 당연히 유저가 결제를 원하는 페이지에서 설정한 값들로부터 나올 것입니다. 근데 정말 확신할 수 있나요? 유저가 원하는 페이지에서, select option 의 value 를 가져와서, 나름대로의 가공을 거친 뒤 newPayment() 함수를 실행할 때까지, 모든 값들이 원하는 대로 온다는 확신이 있을까요?

불행하게도 부분은 그렇지 않습니다. 어딘가 하나는 undefined 가 올 수도 있고, 값이 꼬여버려서 isYearly 처럼 boolean 형이 들어가야 하는 자리에 string 이 들어가버릴 수도 있습니다. 이런 문제가 생기는 이유는 자바스크립트가 동적 타입 언어 이기 때문입니다.

문제는 또 있습니다. paymentLength 가 number 형으로 올 것으로 짐작하고 toString() 을 써보려고 합니다.하지만 위에서 말한 것 처럼 동적 타입 언어이기 때문에, 누구도 paymentLength 가 number 형이라고 확신해주지 않습니다. 자동완성도 되지 않죠.

하지만 뭐, number 형으로 들어오기만 하면 잘 작동할테니 별 문제 없잖아요? 일단 돌려봅니다. 하지만 불행하게도, undefined.toString() 은 불가능하다는 답변이 돌아오네요. 작동 중에 말이에요.

이런 불편함들에서 typescript 가 등장합니다.

Typescript 의 핵심 가치는

정적인 타입 부여
(를 통한) 자동 완성 및 컴파일 에러
결과적으로 생산성 향상

에 있습니다.

타입스크립트는 동적 타입 언어에서 정적 타입 언어로 바꿔 줍니다. 그렇기 때문에, 어느 변수에 있는 값에 대한 불확실성을 해소해줄 수 있습니다.

또한 타입이 이미 지정되어 있기 때문에 자동 완성 또한 지원 되며, boolean 값이 string 형 변수에 들어올 수 있는 상황이라면 컴파일 에러를 내뱉어 줍니다. 컴파일 에러!! 즉, 런타임 에러 전에 잡아낼 수 있다는 말입니다.

그렇기 때문에, 타입스크립트를 도입하게 되면, 실행하기도 전에 어마어마한 에러를 뿜어냅니다. 이것 자체가 굉장히 지칠 수도 있습니다. 하지만 실무 개발을 해보신 분이라면, 새로운 코드를 짜는 것보다 기존의 코드를 보는 게 훨씬 힘들다는 것을 아실 겁니다.

타입스크립트를 적용하면 코드는 길어지지만, 버그를 찾는 데 힘을 덜 들일 수 있게 됩니다.

위의 코드를 타입스크립트로 바꿔본다면 어떻게 될까요?

interface PaymentInfo {
  username: string;
  paymentLength: number;
  payAmount: number;
  isYearly: boolean;
  whereToPay: string;
  paymentType: string;
}

function newPayment({ username, paymentLength, payAmount, isYearly, whereToPay, paymentType } : PaymentInfo) {
  paymentLength.toString();
}

이렇게 됩니다.

여기서 얻는 이점들이 있죠.

1. 이제 우리는 newPayment 의 인자로 들어오는 object 의 타입을, PaymentInfo 로만 받을 것으로 규정했습니다. 따라서 username 부터 paymentType 까지의 6개의 key 값을 제외한 어떤 것도 들어오지 않을 것을 확신합니다.

2. 또한 우리는 payment 에는 오로지 number 타입만 들어올 것을 확신할 수 있고, number 형에서 쓸 수 있는 메소드들의 자동 완성 기능 또한 사용할 수 있습니다.

3. payment 가 오로지 number 형만 들어온다는 것이 확실하기 때문에, undefined 가 들어올 가능성이 있다면, 컴파일 단계에서 잡아줌으로써 런타임 에러를 방지할 수 있습니다.

재밌게 해봅시다!

기존의 자바스크립트 코드를 타입스크립트로 꼭 바꿀 필요는 없습니다. 하지만 리팩토링의 기회가 생긴다면 하는 것이 좋다고 생각합니다. 레거시 코드의 복잡성은 집값과 같아서, 시간이 지날수록 끝없이 올라가기 때문입니다. 지금이 가장 빠를 때라는 이야기죠!

저는 공부할 때 이게 정말 필요한 지를 항상 되뇌어야 한다고 생각합니다. 타입스크립트가 필요한 것이라고 느꼈기 때문에 공부하고, 이 글을 쓰고 있습니다. 여러분도 함께 배워가면 좋겠습니다.

Mac zsh permission denied : code 해결법

심정욱 — Fri, 30 Jul 2021 12:28:04 +0900

zsh 에서 code . 을 입력하니 저 에러가 떴었다. 거의 6시간 날렸다..

sudo code . 을 입력하니 code commant not found 가 떴다.

vscode 에서 shell command : install code 를 쓰니까 EACCESS 어쩌고가 떴다.

sudo chown , chmod 등 별 짓거리 다해봤는데, 바로 해결된 것은

sudo rm -rf /usr/local/bin/code 로 vscode 를 삭제? 한뒤

applications 폴더에 있는 vsc 를 실행한 뒤,

shell command install code 를 다시 해보니까 놀랍게도 됐다. 어이가없네 진짜,,

--- 2021.12.1 ---

만약에 vscode 가 applications 폴더에 없다면 넣어주세요.

2021년, 주니어 개발자 상반기 회고 : 취직하다

심정욱 — Sun, 18 Jul 2021 09:23:30 +0900

거의 처음으로, 개발에 관한 글이 아닌 회고를 써보는 것 같네요.

2021년은 제게 어느정도 본격적인 취준의 해였습니다.

SSAFY 5기

1월에는 삼성청년SW아카데미 5기 활동을 시작했습니다.

정말 재미있기도 하고, 힘들기도 하고, 배운 것도 많았습니다.

사진이 어디갔는지 없어서 https://won-percent.tistory.com/69 에 있는 동기님의 글에서 가져왔습니다.

저는 저 후드에 김치국물 튈 때까지 열심히 입었습니다. 지금도 좀 꼬질하지만 편의점 갈 때는 좋습니다. ㅋㅋㅋ

그 전까지 Node.js 기반 백엔드 개발만 해왔던 제게, Java Spring , Vuejs 등 풀스택 겉핥기를 배울 수 있었죠.

물론 이 경험들도 제겐 굉장히 귀중했지만, 가장 도움이 많이 된 것은

"알고리즘 문제 해결 능력" 향상이었습니다.

SSAFY 에서는 알고리즘을 1학기에 굉장히 많이 합니다. 많이 하고, 또 심층적으로 가르쳐 주십니다. 어디 가서 돈주고 들으려면 최소 몇백만원 정도의 커리큘럼이라고 생각하는데, 한 달에 100만원씩 오히려 받으면서 배웁니다. 최고죠?

알고리즘 문제 해결 능력이 좀 늘어나고, solved.ac 기준 골드 1 까지 찍으니까 코딩테스트에 조금씩 붙기 시작했어요. SSAFY 입과 전에는 과장 좀 보태서 서류 합격률 100%, 코딩테스트 합격률 0% 였습니다. 많이 절망했었어요. ㅠㅠ

SSAFY 경쟁률이 점점 늘어나는 것 같더라구요. 제가 합격할 때도 많이 높았던 걸로 기억합니다. (여러분이 생각하는 그 이상) 이제 6기 활동이 시작했습니다. 만약 6기 분들이 이 글을 보신다면, 본인 의지 여부에 따라 저보다 훨씬 더 많이 배워갈 수 있다는 말 드리고 싶습니다. 화이팅입니다!

6월. SSAFY 취업박람회

갑자기 1월부터 6월까지 뛰는 게 말이 되냐고 하시겠지만, 정말 시공간을 넘었다고 할 만큼 시간이 빨리 갔습니다. SSAFY 는 정말 바쁘게 굴러가거든요. 그동안 저는 중점적으로 알고리즘을 풀었던 거 같습니다. 기존에 하던 프로젝트도 조금씩 하면서 취업을 준비하고 있었죠.

SSAFY 1학기가 끝나고, 약 한달 간의 취업박람회가 있었습니다.

저는 2학기를 하는 데 고민이 많았어요. 2학기는 3가지의 프로젝트를 완성하는 것을 목표로 하는데, 이미 하던 프로젝트의 완성을 위해 달리고 있었고, 짧은 프로젝트를 여러 개 하는 것 보다 하나의 프로젝트를 출시 및 운영까지 해보는 것이 더 좋다고 판단했습니다. 그래서 2학기 전에 취직을 하고 싶었어요!

취업 박람회 때, SSAFY와 연결되어 있는 수많은 기업들 중에서, 여러 곳을 지원했습니다. 저는 스타트업 문화를 좋아하고 친숙한 사람이라, 전부 스타트업만 넣었어요. (사실 대기업보다 스타트업부터 면접 경험 해보는 게 더 낫겠다라는 생각도 없지 않았죠.ㅎㅎ)

하지만 자기소개서를 너무 날려쓴 걸까요? 딱 한 곳만 면접이 잡혔습니다. 심지어, 제가 준비해온 백엔드 개발 직군이 아닌 프론트엔드 개발 직군이었어요. 왜 프론트를 썼냐면, 백엔드 공고에 Python, Django 가 적혀 있었기 때문입니다. 프론트는 제가 가장 잘하는 Javascript + React 였기도 하고, SSAFY 1학기 최종 프로젝트를 VueJS 프론트엔드 개발자로 참여하면서, 프론트에 관심이 조금 생기기도 했었습니다.

1차 면접

사실 제가 그 당시에 팀 소개 페이지를 제대로 안 봐서, 첫 면접이 컬쳐 핏 면접인 지도 몰라 기술 면접 준비를 해갔었습니다. ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ (미쳤나봄)

나중에 찾아보니 팀 소개 페이지에 채용 절차가 적혀있더라구요..ㅎㅎ

하지만 면접 때 긴장하는 스타일은 아니라서, 즐겁게 대화하다가 끝난 것 같습니다.

아무래도 프론트엔드 개발 경험이 별로 없는데 프론트엔드로 지원하게 된 계기를 물어보셨는데, 위의 이유들을 바탕으로 잘 이야기 했더니 합격했습니다. ㅎㅎ

2차 면접

2차 면접은 대면 + 기술 면접이었습니다.

저희 회사는 외국인 개발자가 있기도 하고, 글로벌 서비스를 준비하는 스타트업이라 사내 소통을 전부 영어로 합니다. 그래서 설마하고 면접을 갔는데 전부 영어로 면접을 봤습니다. ㅎㅎ

다행히 영어를 아주 못하는 편은 아니라서, 그리고 준비해간 면접 질문에서 많이 나와서 다행히 잘 볼 수 있었습니다.

가장 인상 깊었던 건, 디버그 문제를 풀면서 제가 헤매니까 3명의 면접관(이젠 팀원이죠) 분들과 함께 토론하며 풀어낼 수 있었던 경험입니다.

그렇게 최종 합격을 했고, 출근 D-1이 어느덧 다가왔네요!

아니 왜 스타트업 갔어요? 신입이면 대기업 가는 게 나을 거 같은데??

이런 질문이 많을 것 같고, 저도 이 생각 했습니다. ㅎㅎ

첫 직장이 가장 중요하다는 말을 많이 들었어요. 이직할 때 전 직장 연봉 기준으로 한다느니 뭐니 하는 말이 많죠. 대기업의 복지도 그렇고..

첫 번째 이유는, 한 살이라도 어릴 때 내가 경험해보고 싶었던 스타트업에서 뭔가 해보자라는 의지가 있었습니다. 제가 올해 20대 후반이거나, 30대 초반이었다면 사실 안 갔을 것 같아요. 그 때는 정말 "직장"의 개념으로 첫 직장을 잡아야하는 때일 것 같거든요. ( 사실 아직 그 나이가 아니라서 잘 모르겠습니다. ㅎㅎ )

두 번째는 팀원입니다. 제가 면접 볼 당시 3분의 면접관이 팀 전체였어요. 팀 구성원이 3명이었다는 소리죠. ㅋㅋㅋㅋ

그 3분이 모두 함께하고 싶은 성격이었고, 면접 자체도 재미있게 했었어요. 이 사람들과 함께 뭔가 큰 변화를 일으켜 보고 싶다라는 생각이 들었습니다.

세 번째는 믿고 배울 수 있는 시니어 였습니다. 저는 이걸 제일 중요하게 봤어요. 스타트업 아무 데나 갔다가 시니어가 없어서 혼자 다 하고 그랬다는 경험을 많이 봤거든요. 주니어 개발자로써, 믿을 수 있는 시니어의 유무는 정말정말 중요하다는 말을 많이 들었어요. 저는 회사의 대표님이자 실리콘밸리 출신 개발자인 분에게 많이 배울 거라고 들었고, 입사를 결정하게 되었네요.

한 번 취직했다고 끝나지 않습니다!

이제 첫 단추를 꿰었을 뿐이라고 생각해요. 입사 해보니 마음에 안들어서 때려칠 수도 있다고 생각하고, 서비스가 급성장해서 스톡옵션으로 몇 억을 받을 수도 있다고 생각합니다. 결국 다 제가 하기 나름이 아닐까요?

취준 단계에는 사실 좀 우울한 적이 많았어요. 대표적인 게 서류 탈락할 때랑 코딩테스트 탈락할 때... 하지만 취업은 결국 n번의 try 가운데 단 한 번만 성공하면 되는 거 아니겠어요.

try {
	tryToGetJob();
} catch(fail) {
	levelUp();
} finally {
	success();
}

너무 슬퍼하기 보다는 다음을 위한 발판으로 생각하시면 좋은 결과 있을 겁니다.

코로나 때문에 다들 너무 힘드실텐데, 화이팅 하시길 바라며 포스팅 마칩니다.

초보를 위한 쿠버네티스 안내서 (2) : 쿠버네티스 아키텍처

심정욱 — Thu, 24 Jun 2021 21:53:51 +0900

앞서

이 게시글은 subicura 님의 인프런 유료 강의, "초보를 위한 쿠버네티스 안내서"를 듣고 정리하기 위해 작성했습니다.

https://www.inflearn.com/course/%EC%BF%A0%EB%B2%84%EB%84%A4%ED%8B%B0%EC%8A%A4-%EC%9E%85%EB%AC%B8/dashboard

초보를 위한 쿠버네티스 안내서 - 인프런 | 강의

쿠버네티스를 1도 모르는 입문자, 초보자를 위한 쿠버네티스 안내서 입니다. 초보자도 이해하기 쉬운 내용과 흐름으로 구성했어요., 데브옵스 입문자라면 주목! 지금, 초보자를 위한 쿠버네티스

www.inflearn.com

아키텍처

사람을 시켜 컨테이너를 하나를 띄우려면?

1. 컨테이너 한개 생성 해달라는 요청을 받음

2. 그 요청을 어딘가에 적어둠

3. 서버의 현재 상태가 방금 적어둔 ( 컨테이너 1개 생성 ) 상태와 같은지 체크

4. 컨테이너 하나 있어야 하는데 없네? 만들기

이 개념이 굉장히 중요하다.

Desired State

1. Observe (상태 체크) : 현재 상태 == 원하는 상태 인지 체크

2. Diff ( 차이점 발견 ) : 현재 상태 != 원하는 상태 이므로

3. Act ( 조치 ) : 현재 상태 -> 원하는 상태

쿠버네티스는 이 3가지를 반복함.

다시 위의 예시로 돌아가서, 이번에는 서버를 2대로 증설하라는 요청을 받았다!

그렇게 서버를 새로 하나 띄웠다. 이 때 새로운 컨테이너는 어디에 띄워야 할까?

당연히 아무 것도 띄워져 있지 않은 2번 서버에 띄워야 할 것이다.

이 때, 어느 서버에 띄워줄 지 결정하는 사람을 Scheduler 라 하자.

컨테이너나 네트워크, 노드 등을 체크해주는 사람을 Controller 라 하자.

즉, 컨트롤러의 갯수에 따라 Desired State 가 굉장히 많아질 수 있다.

다시 나눠보면, 쿠버네티스의 영역은 두 가지가 생긴다.

실제로 컨테이너들이 띄워져있는 Node 부분과, Node 를 관리하기 위해 움직이는 Master 영역으로 나뉜다.

중간에서 Scheduler, Controller 들에게 명령을 해줬던 사람은 API Server 라는 용어로 부르고, API Server 가 명령을 기억해해두기 위해 적어두던 데이터베이스를 etcd 라고 한다.

etcd

모든 상태와 데이터를 저장
분산 시스템으로 구성하여 안전성을 높임 (고가용성, 보통 3대 정도 띄움 )
가볍고 빠르면서 정확하게 설계
Key(directory) - Value 형태로 데이터 저장
TTL, watch 같은 부가 기능 제공.
백업은 필수!

API Server

상태를 바꾸거나 조회
etcd 와 유일하게 통신하는 모듈
REST API 형태로 제공
권한을 체크하여 적절한 권한이 없을 경우 요청을 차단
관리자 요청 뿐만 아니라 다양한 내부 모듈과 통신
요청이 굉장히 많음. 수평으로 확장되도록 디자인

Scheduler

새로 생성된 Pod ( 지금은 컨테이너라고 생각하세요) 를 감지하고 실행할 노드를 선택 ( 어떤 노드에 어떤 컨테이너를? )
노드의 현재 상태와 Pod의 요구사항을 체크
노드에 라벨을 부여 ( 그래픽이 필요한 경우, gpu-enabled 라벨이 되어있는 노드에 배포한다던가..)

Controller

논리적으로 다양한 컨트롤러가 존재 (복제 컨트롤러, 노드 컨트롤러, 엔드포인트 컨트롤러...)
끊임 없이 상태를 체크하고 Desired State를 유지
복잡성을 낮추기 위해 하나의 프로세스로 실행

조회 흐름

Controller 는 etcd 와 직접 통신하지 않고 API Server 에게 요청한다.
API Server는 해당 Controller 가 조회 권한이 있는지 체크
권한이 있다면 etcd 에 정보 조회함.
etcd 가 Desired State가 변경되었다고 API Server에 알려줌
API Server는 Controller 에게 변경되었다고 알려줌
Controller 는 Desired State 로 리소스 변경
Contoller 는 변경 후에 API Server 에 변경 사항 전달
API Server 는 얘가 정보를 변경할 권한이 있는지 체크하고,
권한이 있다면 etcd 에 정보 갱신을 기록함.

즉, Scheduler, Controller 들 모두가 API Server 와의 통신을 하고 있다.

이제 Node 부분을 살펴보자

크게 Proxy 와 Kubelet 이라는 컴포넌트가 있다. 마찬가지로 API Server 와 통신함.

Proxy 는 iptables, ipvs 방식을 사용하고, Kubelet 이 Pod 와 직접 통신한다.

Kubelet

각 노드에서 실행
Pod을 실행/중지하고 상태를 체크
CRI (Container Runtime Interface)
컨테이너를 직접 쓰는게 아니라 Pod 이라는 것으로 감싸서 사용함.

Proxy

네트워크 프록시 같이 부하 분산 역할
성능상의 이유로 별도의 프록시 프로그램 대신 iptables 또는 IPVS를 사용 ( 설정 파일만 관리 )

그럼 용어를 토대로 다시 예제로 돌아가볼까요?

관리자가 API Server 에게 Pod 를 띄워달라고 요청함
API Server 는 etcd 에게 "Pod 을 생성하라는 요청이 들어왔다!" 라고 적어둔다.
Controller 는 "새 Pod 가 확인 되어야 하나??" 를 계속 API Server 에게 체크 중이다.
헐, 요청이 들어왔네! Pod 할당 요청을 API Server에게 한다.
API Server 는 다시 받아서 etcd 의 상태를 "Pod 할당 요청" 으로 바꾼다.
Scheduler 또한 계속 API Server 에게 할당할 Pod 가 있는지 체크 중이다.
헐 있네! 새 노드에 할당하겠다고 API Server 에 요청함.
API Server 는 etcd 에 "새로운 Pod 를 특정 노드에 할당하는데, 아직 미실행 상태다!" 를 기록함.
Node 단의 Kubelet 은 "어, 내 담당 노드에 할당된 Pod 중에서 아직 미실행 된 게 있네?"를 체크함.
정보를 가져와서 Pod 생성하고, API Server 에 Pod 생성했다고 알려줌
API Server 는 etcd 에 "새 Pod를 특정 노드에 할당해서 실행중이다" 를 기록함.

Addons

CNI (네트워크), DNS(도메인, 서비스 디스커버리), 대시보드(시각화) 등의 컴포넌트가 있다.

오브젝트

지금까지 쿠버네티스가 어떻게 내부적으로 동작하는 지 알아봤다. 이제 각 오브젝트를 알아보자.

Pod

가장 작은 배포 단위 ( 컨테이너를 감싼다 )
각 Pod 마다 고유 IP 를 받는다.
하나의 Pod 에 여러 개의 컨테이너가 들어갈 수 있다. 각 컨테이너가 localhost 의 폴더를 공유할 수도 있고 포트로 네트워크를 공유할 수도 있다.

ReplicaSet

여러 개의 Pod 를 관리
새로운 Pod 는 Pod Template 을 보고 하나 더 띄워줌.
원하는 Pod의 수(Replicas) 에 맞춰 Pod 를 관리

Delpoyment

배포 버전을 관리
무중단으로 배포하기 위해서, 순간적으로 ReplicaSet 을 2개로 만들고, 각 replicas 를 한 쪽 컨테이너는 줄이고, 한 쪽 컨테이너는 늘이면서 자연스럽게 update 시킴.

이 외에도 다양한 Workload 가 있다.

Daemon Set : 모든 Node 에 꼭 하나씩만 떠있길 원하는 Pod 을 만들고 싶을 때(모니터링, 로그)
Staeful Sets : 순서대로 Pod을 실행하고 싶거나, 같은 볼륨을 재활용하고 싶을 때
Job : 한 번 실행하고 죽는 Pod

Service - Cluster IP

3개의 Pod 이 있을 때, ClusterIP 로 묶여 있으면 ClusterIP 로 요청을 보내면 3개 중에 하나로 보내서 수행함.
이렇게 하는 이유는, Pod 가 업데이트될 때 기존 Pod 이 유지되지 않고 죽었다가 새로 만들어진다.
즉 IP 가 유동적이기 때문에, 고유 IP 를 갖는 Service 의 ClusterIP 로 요청을 보내는 것.
web 에서 redis 가 있는 Pod 로 요청을 보낸다면, redis 가 속해있는 ClusterIP 로 요청을 보냄.

Service - NodePort

Cluster IP 는 내부 통신만 가능하다. 외부 브라우저에서는 접근이 안 된다.
외부에서 접근하기 위해서, Cluster IP 를 NodePort 로 감싸준다. (30000-32767 포트)
노드01 과 노드02 가 있다면, 노드01 로 직접 요청해서 Pod 에 접근할 수도 있고, 노드02에서 노드01 내부의 ClusterIP 에 요청해서 접근할 수도 있다. 즉 둘 중 어느 노드에 접근해도 같은 Pod 에 접근할 수 있게 되는 것

Service - LoadBalancer

노드01 로 도메인을 연결해놨는데 노드01이 갑자기 죽어버린다면? 노드02로 붙어야 하는데,,
직접 연결해뒀다면 접속이 안될 것이다.
이 때 사용자는 LoadBalancer 에게 요청을 한다. 그 요청이 NodePort 로 가고, ClusterIp 로 가고, Pod 로 가는 방식

Ingress

도메인 또는 경로 별 라우팅
Nginx, HAProxy, ALB ...

일반적인 구성

Pod 를 직접 띄우는 일은 잘 없다. Deployment 를 띄우면 자동으로 ReplicaSet 을 생성하고, 얘는 Pod 를 생성하고..
외부 노출을 위해 Service (ClusterIp) 를 붙이고, 얘는 NodePort 에 붙이고, LoadBalancer 에 붙이고..
Ingress 에 연결해 도메인을 연결하면, 사용자가 www.어디어디 로 들어왔을 때 요청이 간다.

그 외 기본 오브젝트

Volume ( Storage )
Namespace - 논리적인 리소스 구분
ConfigMap/Secret - 설정
ServiceAccount - 권한 계정
Role/ClusterRole - 권한 설정

API 호출

원하는 상태(Desired State) 를 다양한 오브젝트(Object) 로 정의(Spec) 하고 API 서버에 yaml 형식으로 전달

초보를 위한 Kubernetes 안내서 (1) : 소개

심정욱 — Tue, 22 Jun 2021 23:13:33 +0900

앞서

이 게시글은 subicura 님의 인프런 유료 강의, "초보를 위한 쿠버네티스 안내서"를 듣고 정리하기 위해 작성했습니다.

https://www.inflearn.com/course/%EC%BF%A0%EB%B2%84%EB%84%A4%ED%8B%B0%EC%8A%A4-%EC%9E%85%EB%AC%B8/dashboard

초보를 위한 쿠버네티스 안내서 - 인프런 | 강의

www.inflearn.com

서버 관리?

- 서버의 상태를 관리하기 위한 노력 ( 밤에 출근하기 싫다. 갑자기 죽는 서버가 밉다... )

- 첫 번째 노력 : 문서화

환경이 조금 바뀌면 다 바뀌어야 한다.

- 두 번째 노력 : 서버 관리 도구 (CHEF, puppet, ansible ... )

좋기는 한데,,, 서버 관리 도구를 또 배워야 하네.
서버가 복잡해지면 ? 관리도 너무너무너무 복잡해짐.
Java 도 써야 하고, Node.js 도 써야 하는데.. 한 서버에서 어떻게 하지?

- 세 번째 노력 : 가상 머신

서버 하나에 가상 머신 여러 개를 띄워서 쓰기 -> 안정적이고 관리도 잘 됨(느리지만..)
특정 vendor 에 의존하게 됨. 그리고 느림..

그리고 이 때, docker 가 등장하게 되는데..

모든 실행 환경을 container 로 바꾸게 됨.
도커만 설치 되어 있으면 어디서든 동작하고, 쉽고, 느리지도 않다. (최고!)

컨테이너의 특징

가상머신에 비해 생성이 쉽고 효율적
컨테이너 이미지를 이용한 배포와 롤백이 간단
언어나 프레임워크 상관 없이, 동일한 방식으로 애플리케이션 관리
개발, 테스팅, 운영 환경은 물론 로컬 PC와 클라우드까지 동일한 환경을 구축
오픈 소스이고, 특정 클라우드 vendor 에 종속적이지 않음.

MySQL, redis, Jenkins, ... 모든 것을 컨테이너로 관리하고 싶은 욕구가 생긴다. => Containerization

도커의 등장 이후,

개발자가 코드 작성
빌드
컨테이너화
실행!

의 과정으로 개발이 이뤄지게 되었다. 드디어 편해졌나?

모든 걸 컨테이너화 하긴 했는데...

컨테이너가 점점 많아지면..?
4개일 때는 괜찮았는데, 100개, 1000개, Integer.MAX_VALUE 개가 된다면..? 어떻게 관리함???

도커 그 이후

배포는 어떻게?

도커 서버가 많아지면 ? 하나하나 실행하기가...
컨테이너가 실행되지 않는 서버도 생긴다.
- 그럼 당연히 비어있는 서버에 실행하는 게 좋은데,
- 어떤 게 비어있지??
v1 -> v2 로 업데이트를 힘들게 서버 하나하나 접속해가며 했는데, 오류가 나서 롤백을 해야 한다

서비스 검색은 어떻게?

프록시가 있고, 컨테이너를 연결해줄 때, 컨테이너가 늘어나면 ?

생각할 수 있는 것 : 로드밸런서 붙이기
마이크로서비스가 유행하면서, 점점 컨테이너가 많아지는 데, 이럴 때 마다 도커 서버 주소를 추가해주고, 어떤 건 삭제하고... 일련의 과정이 너무 힘들다.

서비스 노출은?

기존의 방식

public 영역에 nginx 같은 프록시 서버를 두고, 들어오는 host 에 따라서 private 영역의 내부 서버에 연결하는 방식
마찬가지로, 서버 하나 추가되면 nginx conf 파일 들어가서 추가해주고.. 귀찮다

모니터링은??

어떤 서버가 죽어버리거나, 느려져버리면.. 그게 하필 새벽이라면..

명절을 앞둔 서버 개발자의 모습

복잡한 컨테이너 환경을 효과적으로 관리하기 위한 도구가 필요해!

Container Orchestration 의 등장

서버 관리자의 일을 대신 해주는 도구
특징

Cluster
1. 중앙제어(Cluster)
  1. node 1번에는 뭐가 있고, 얼마의 리소스가 있고, 2번에는...
  2. 이게 많아지면 ? 사람이 알고 있기에는 한계가 있다.
  3. 이 많은 node 들을 cluster 라는 단위로 묶어서 관리한다.
2. 상태관리(State)
  1. app1 이라는 이미지를 replicas 2로 설정하면 2개 뜨게, 3으로 설정하면 3개 뜨게 함.
  2. 3개인 상황에서 하나가 문제가 생기면, 죽이고 하나를 새로 띄워주는 것
3. 배포관리(Scheduling)
  1. 어느 서버가 여유있는 지 찾아서, 새로운 앱을 띄울 때 그 서버에 띄워주거나, 혹은 여유 있는 서버가 없으면 서버 하나 새로 띄워주는 것
4. 배포 버전관리(Rollout-Rollback)
  1. { version : "v2" } 로 하면 v2 로 모두 바뀌고, v1 으로 하면 모두 바뀌게 중앙에서 처리해주는 것
5. 서비스 등록 및 조회(Service Discovery)
  1. 서버가 x.x.x.100 에 뜨면 master node 에 등록되고, 101에 하나 더 뜨면 또 등록됨.
  2. 설정 변경 시 프로세스 재시작을 자동으로 해줌.
6. 볼륨 스토리지(Volume)
  1. 1번 노드는 NFS 에 연결, 2번 노드는 AWS EBS 에 연결, 3번 노드는 ...
  2. 손으로 일일히 할 수 있지만, 설정으로 관리해줄 수 있음.

Container Orchestration 은 하나의 개념이다.

다양한 게 생겼고, docker 에서 만든 docker swarm 이란 것도 있다. 하지만 kubernetes 가 암묵적인 표준이 되어버렸다

왜 kubernetes 가??

- 1주일에 20억개의 컨테이너를 생성하는 google

- 컨테이너 배포 시스템으로 사용하던 borg 를 기반으로 만듦.

- 유연하고, 어디서든 동작하며, 오픈소스이다.

- 무한한 확장성 : 머신러닝, CI/CD, 서비스메시, 서버리스 등... k8s 가 하나의 플랫폼이 되어버렸다.

- 도커도 쿠버네티스 지원하고, 아마존, azure, google 도 다 지원하게 되었다.

사실상의 표준(de facto) 이다.

마치며

- subicura 님의 강의력이 너무 좋더라구요. 그래도 제 머리가 미천하여 한 번 듣고는 기억을 못할 것 같아서 작성하게 되었습니다. 혹시 문제가 된다면 삭제하겠습니다.

백준 1504 번 : 특정한 최단 경로 풀이(Java)

심정욱 — Tue, 8 Jun 2021 21:05:03 +0900

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

1504번: 특정한 최단 경로

첫째 줄에 정점의 개수 N과 간선의 개수 E가 주어진다. (2 ≤ N ≤ 800, 0 ≤ E ≤ 200,000) 둘째 줄부터 E개의 줄에 걸쳐서 세 개의 정수 a, b, c가 주어지는데, a번 정점에서 b번 정점까지 양방향 길이 존

www.acmicpc.net

Solution

- 다익스트라 알고리즘의 응용 문제이다. 이 문제에서 주의할 점은, 다익스트라가 다 그렇겠지만 MAX 값 끼리의 더함, 즉 연결되지 않는 경로의 합 등에 의해 발생하는 오버플로우가 있고, 방향성이 없는 그래프 라는 점 또한 주의해야 한다.

- 오버플로우의 경우, 다음 TC를 시도해보자.

3 0

2 3

간선이 없을 수 있는데, 2번 3번을 지나야 한다고 하면 오버플로우에 의해 음수가 나올 수 있다.

- 방향성이 없는 그래프이다. 즉 양방향 그래프라는 말이고, graph 를 만들 때 from 에도 to 에도 추가를 해줘서 양방향으로 만든다.

import java.io.*;
import java.util.*;

public class Main {
    private static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    private static int N,E;
    private static List<List<Node>> graph;
    private static final int MAX = 987654321;
    private static int[] mustGo;

    private static class Node implements Comparable<Node> {
        int idx;
        int distance;

        public Node(int idx, int distance) {
            this.idx = idx;
            this.distance = distance;
        }

        @Override
        public int compareTo(Node o) {
            return this.distance - o.distance;
        }
    }
    public static void main(String[] args) throws IOException {
        input();
        solve();
        bufferedReader.close();
        bufferedWriter.flush();
        bufferedWriter.close();
    }

    private static void input() throws IOException {
        StringTokenizer ne = new StringTokenizer(bufferedReader.readLine());
        N = Integer.parseInt(ne.nextToken());
        E = Integer.parseInt(ne.nextToken());
        graph = new ArrayList<>();
        for(int i = 0 ; i <= N; i++) {
            graph.add(new ArrayList<>());
        }
        for(int i = 0 ; i < E; i++) {
            StringTokenizer edge = new StringTokenizer(bufferedReader.readLine());
            int from = Integer.parseInt(edge.nextToken());
            int to = Integer.parseInt(edge.nextToken());
            int cost = Integer.parseInt(edge.nextToken());
            graph.get(from).add(new Node(to, cost));
            graph.get(to).add(new Node(from, cost));
        }
        StringTokenizer mg = new StringTokenizer(bufferedReader.readLine());
        mustGo = new int[2];
        mustGo[0] = Integer.parseInt(mg.nextToken());
        mustGo[1] = Integer.parseInt(mg.nextToken());
    }

    private static int dijkstra(int start, int end) {
        int[] distance = new int[N+1];
        Arrays.fill(distance, MAX);
        boolean[] visited = new boolean[N+1];
        PriorityQueue<Node> pq = new PriorityQueue<>();
        pq.offer(new Node(start, 0));
        distance[start] = 0;

        while (!pq.isEmpty()) {
            int idx = pq.poll().idx;
            if(visited[idx]) continue;
            visited[idx] = true;

            for(Node node : graph.get(idx)) {
                if(distance[node.idx] > distance[idx] + node.distance) {
                    distance[node.idx] = distance[idx] + node.distance;
                    pq.add(new Node(node.idx, distance[node.idx]));
                }
            }
        }
        return distance[end];
    }

    private static void solve() throws IOException {
        int d1 = dijkstra(1, mustGo[0]) + dijkstra(mustGo[0], mustGo[1]) + dijkstra(mustGo[1], N);
        int d2 = dijkstra(1, mustGo[1]) + dijkstra(mustGo[1], mustGo[0]) + dijkstra(mustGo[0], N);
        //System.out.println(d1 + " " + d2);
        int result = Math.min(d1, d2);
        result = result >= MAX || result < 0 ? -1 : result;
        bufferedWriter.write(result + "\n");
    }
}

백준 16234번 : 인구 이동 풀이(Java)

심정욱 — Mon, 17 May 2021 23:49:36 +0900

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

16234번: 인구 이동

N×N크기의 땅이 있고, 땅은 1×1개의 칸으로 나누어져 있다. 각각의 땅에는 나라가 하나씩 존재하며, r행 c열에 있는 나라에는 A[r][c]명이 살고 있다. 인접한 나라 사이에는 국경선이 존재한다. 모

www.acmicpc.net

Solution

1. 이 문제는 BFS + 시뮬레이션 문제이다. 국경선을 여는 것도, 인구를 이동시키는 것도 모두 BFS로 풀었다.

2. 먼저, main 역할을 하는 메서드에서는, 더 이상 열리는 국경선이 없을 때 까지 국경선 열기 -> 인구 이동하기 -> 국경선 열기 -> ... 를 반복해야 한다.

3. 그럼 결국 구현해야 할 것은

국경선을 열기(즉, 가능한 국가들 끼리 서로 연결하는 것)
인구 이동하기(연결된 국가들의 인구수를 합치고, 총 인구 수 / 국가 수 로 업데이트 해주기

이다.

4. 국경선을 여는 기능(그룹 기능)

먼저, 그룹을 나타내는 int[N][N] 배열을 만들어준다. 이름은 connected 로 했다. 또한 연합이 되는 국가가 하나도 없다면 main 메서드에서 반복문을 끝내기 위해서, atLeastOneOpened 라는 boolean 변수를 만들었다.

N*N 의 map을 돌면서, 아직 그룹에 포함되지 않은 나라라면, 그 나라부터 BFS 를 돌면서 "연합"을 만든다. 1번 연합, 2번 연합... 으로 이어질 것이다.
그럼 connected[r][c] 의 값이 0인 곳이, 연합에 포함되지 않은 나라이다. 그 곳부터 BFS 를 돌면 된다!
BFS 를 돌면서 연합에 넣기 전에, 둘의 인구 수 차이가 L이상 R이하라면 연합에 넣어준다. 연합에 넣는다는 의미는, connected[nextR][nextC] 의 값을 connected[r][c] 의 값으로 바꿔주면 된다는 것이다. 이 때, atLeastOneOpened 를 true 로 만들어 줘서 반복문이 종료되지 않고 인구 이동이 일어나게 해준다.

5. 인구 이동 기능

connected 배열을 참고해서, 마찬가지로 N*N 배열을 돌며 연합인 국가들의 인구 수를 모두 합해준다. BFS가 끝난다면 해당 그룹의 모든 국가들의 인구수를 다 더해줬다는 의미이므로, 이제 map 의 인구 수를 갱신해줘야 한다.

이 때 주의할 점이 있다(시간 초과)

나는 값이 작길래 별 생각 없이, 각 나라가 해당 연합의 나라인지 나타내는 boolean 2차원 배열을 만들고 N*N 돌면서 연합일 경우 총 인구 수 / 국가 수 로 갱신해줬는데, 이렇게 하면 O(N^4) 의 시간 복잡도가 나오므로 80% 쯤에서 터졌었다. 그래서 생각한 방법은, BFS 를 돌면서 해당 연합인 경우 ArrayList 에 넣어서 기록을 해주고, BFS 가 끝날 때 ArrayList 를 돌면서 갱신해줬고 통과했다.

Source Code

import java.io.*;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {
    private static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    private static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    private static int N,L,R,RL;
    private static final int UP=0,RIGHT=2,DOWN=1,LEFT=3;
    private static int[][] map;
    private static int[][] connected;
    private static int[] dx = {-1,1,0,0};
    private static int[] dy = {0,0,1,-1};

    private static class Node {
        int r;
        int c;
        int group;

        public Node(int r, int c, int group) {
            this.r = r;
            this.c = c;
            this.group = group;
        }
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
        bufferedReader.close();
        bufferedWriter.close();
    }
    
    private static void input() throws IOException {
        StringTokenizer nlr = new StringTokenizer(bufferedReader.readLine());
        N = Integer.parseInt(nlr.nextToken());
        L = Integer.parseInt(nlr.nextToken());
        R = Integer.parseInt(nlr.nextToken());
        RL = R-L;
        map = new int[N][N];
        for(int i = 0 ; i < N; i++) {
            StringTokenizer line = new StringTokenizer(bufferedReader.readLine());
            for(int j = 0 ; j < N; j++) {
                map[i][j] = Integer.parseInt(line.nextToken());
            }
        }
    }

    private static boolean openLine() {
        connected = new int[N][N];
        int group = 1;
        boolean atLeastOneOpened = false;
        for(int r = 0; r < N; r++) {
            for(int c = 0; c < N; c++) {
                if(connected[r][c] != 0) continue; // 이미 연결된 애들은 넘어간다.
                Queue<Node> queue = new LinkedList<>();
                queue.add(new Node(r, c, group));
                connected[r][c] = group++;
                while (!queue.isEmpty()) {
                    Node before = queue.poll();
                    int sr = before.r;
                    int sc = before.c;
                    int sg = before.group;
                    for(int d = 0; d < 4; d++) {
                        int nr = sr + dx[d];
                        int nc = sc + dy[d];
                        if(nr < 0 || nc < 0 || nr >= N || nc >= N) continue;
                        if(connected[nr][nc] != 0) continue;
                        int next = map[nr][nc];
                        int howManyDiff = Math.abs(map[sr][sc] - next);
                        if(howManyDiff >= L && howManyDiff <= R) {
                            connected[nr][nc] = connected[sr][sc];
                            atLeastOneOpened = true;
                            queue.add(new Node(nr, nc, sg));
                        }
                    }
                }
            }
        }
        return atLeastOneOpened;
    }
    private static void checkLine() {
        for(int r = 0 ; r < N; r++) {
            for(int c = 0 ; c < N; c++) {
                System.out.print(connected[r][c] + " ");
            }
            System.out.println();
        }
        System.out.println("===========");
    }

    private static void printMap() {
        for(int r = 0 ; r < N; r++) {
            for(int c = 0 ; c < N; c++) {
                System.out.print(map[r][c] + " ");
            }
            System.out.println();
        }
        System.out.println("===========");
    }

    private static void move() {
        boolean[][] visited = new boolean[N][N];
        for(int r = 0 ; r < N; r++) {
            for(int c = 0 ; c < N; c++) {
                if(visited[r][c]) continue; // 이미 처리한 곳이라면 넘어가기
                ArrayList<Node> inGroup = new ArrayList<>(); // 해당 그룹에 있는 노드들을 담아두기
                int populationSum = map[r][c]; // 해당 그룹의 총 인구 수
                Queue<Node> queue = new LinkedList<>();
                queue.add(new Node(r, c, connected[r][c]));
                inGroup.add(new Node(r, c, connected[r][c]));
                while (!queue.isEmpty()) {
                    Node before = queue.poll();
                    int sr = before.r;
                    int sc = before.c;
                    visited[sr][sc] = true;
                    int sg = before.group;
                    for(int d = 0; d < 4; d++) {
                        int nr = sr + dx[d];
                        int nc = sc + dy[d];
                        if(nr < 0 || nc < 0 || nr >= N || nc >= N) continue;
                        if(visited[nr][nc]) continue;
                        if(connected[nr][nc] == sg) {
                            visited[nr][nc] = true;
                            populationSum += map[nr][nc];
                            queue.add(new Node(nr,nc,sg));
                            inGroup.add(new Node(nr, nc, sg));
                        }
                    }
                }
                for(Node x : inGroup) {
                    map[x.r][x.c] = populationSum / inGroup.size();
                }
            }
        }
    }

    private static void solve() {
        int count = 0;
        while (true) {
            if(!openLine()) {
                break;
            }
            //printMap();
            //checkLine();
            move();
            //printMap();
            count++;
        }
        System.out.println(count);
    }
}

Spring : @Autowired 했는데 null 이 나와서 NullPointerException 이 뜨는 경우

심정욱 — Thu, 29 Apr 2021 23:54:05 +0900

@Autowired 는 Spring Container 에서 관리 중인 Bean 을, 자료형이 같을 경우 자동 매핑해주는 어노테이션이다. 예제를 통해 알아보자.

예제는 ProductController 와 ProductService 로 구성되며,

ProductService 는 Interface 이고, ProductServiceImpl 내에 구현해놓았다.

ProductServiceImpl.java

@Service
public class ProductServiceImpl implements ProductService{
	@Autowired
	private SqlSession sqlSession;
    
    ...
 }

주의해야 할 점은,

1. 생성자를 사용하면 안 된다.

@Controller
public class ProductController {
	@Autowired
	private ProductService productService = new ProductServiceImpl();
    
    ...
}

Controller 에서 생성자로 초기화해주면, 이는 Spring Container 에서 Singleton 으로 생성된 인스턴스를 참조하지 않고, 말 그대로 생성자로 인해 생성된 새로운 ProductServiceImpl 객체의 인스턴스를 참조한다.

이 경우 당연히 Null 은 뜨지 않겠지만, Spring Container 의 Bean 관리를 받는 것이 아니므로 DI 에 실패한 코드이다.

2. (내가 해결한 것) static 키워드를 사용하면 안 된다.

@Controller
public class ProductController {
	@Autowired
	private static ProductService productService; // 이 경우, 자동으로 생성자가 실행되지 않기 때문에 null 이다.
    
    ...
 }

정적 멤버로 선언될 경우, ProductController 가 먼저 로드되고, ProductService 는 그 시점에서 생성되지 않기 때문이다.

잘 모르겠다면 static autowired 로 검색해보자.

티스토리 사진이 아예 안뜨거나 관리자 페이지 그래프 안보이거나 하는 경우 해결법

심정욱 — Mon, 26 Apr 2021 20:12:20 +0900

길호넷의 시크릿DNS가 깔려있다면 실행을 중지하거나 삭제해보세요. 아예 못들어오는 분 있을까봐 짧게씁니다

백준 15683번 : 감시 풀이(Java) - DFS

심정욱 — Wed, 21 Apr 2021 22:42:49 +0900

www.acmicpc.net/problem/15683

15683번: 감시

스타트링크의 사무실은 1×1크기의 정사각형으로 나누어져 있는 N×M 크기의 직사각형으로 나타낼 수 있다. 사무실에는 총 K개의 CCTV가 설치되어져 있는데, CCTV는 5가지 종류가 있다. 각 CCTV가 감

www.acmicpc.net

Solution

잘 안풀어본 유형이라 어려웠다. 아직 DFS 가 BFS에 비해 익숙하지 않은 것 같다. 교수님의 풀이 코드를 보고 실행 부분을 고쳤더니 해결이 되었다!

이 문제는 데이터의 범위가 굉장히 작기 때문에, 모든 cctv의 회전을 고려해도 된다. (브루트포스)

하지만 모든 cctv의 회전을 고려하는 상황을 만들기에 적합한 알고리즘이 DFS 였다.

사각지대에서 벗어난 빈 지역, 즉 CCTV로 관찰 가능한 0번의 경우를 9번으로 만들어주고, 모든 CCTV 의 경우를 다 보고난 뒤 남은 0의 갯수가 사각지대의 갯수이다.

나의 경우, 타입 5번, 상하좌우를 모두 보는 CCTV는 회전을 해봐야 결과가 같으므로, 입력을 받을 때 5번의 상하좌우를 9로 만들고 시작했다. 이제 카메라의 움직임을 주시해야 한다. 나는 switch 문을 쓰기 보다 3차원 배열로 한 방에 했다.

각 차원을 자세히 보면

타입의 갯수가 4가지( 5번 제외, 1~4 이므로 4 + 1 크기의 1차원)
각 타입별로, 회전하지 않았을 때, 회전 1번, 2번, 3번 즉 볼 수 있는 방향의 경우의 수가 4가지(4 크기의 2차원)
1번 타입의 경우는 한 번에 한 방향, 2번 3번의 경우는 두 방향, 4번의 경우는 3방향 (각각 1, 2, 3 크기의 3차원)

이다.

상하좌우를 0,1,2,3 등으로 표현하면 반드시 헷갈릴 것 같아서 상수로 보기 좋게 표현해줬다. 사실 숫자에 크게 의미는 없다. 비교를 위한 것.

private static final int UP = 0, DOWN = 1, LEFT = 2, RIGHT = 3, WALL = 6, CAN_SEE = 9;
private static int[][][] d = {{}, // 타입 0번은 없다
{{RIGHT},{DOWN},{LEFT},{UP}},  // 타입 1번
{{LEFT, RIGHT}, {UP, DOWN}, {LEFT, RIGHT}, {UP,DOWN}}, //2번
{{UP,RIGHT}, {RIGHT, DOWN}, {DOWN, LEFT}, {LEFT, UP}}, //3번 
{{UP,LEFT,RIGHT},{ UP,RIGHT,DOWN},{RIGHT,DOWN,LEFT},{DOWN,LEFT,UP}}}; // 4번

다음은 이렇게 만든 d를 기반으로, cctv의 위치를 기반으로 UP,DOWN,LEFT, RIGHT 각각에 따라 지역을 감시하는 메서드를 만들어준다.

private static void show(int[][] map, int cameraX, int cameraY, int showDir) {
        if(showDir == UP) {
            for(int x = cameraX; x >= 0; x--) {
                if(map[x][cameraY] == WALL) break; // 벽을 마주치면 더 볼 수 없다.
                if(map[x][cameraY] == 0 || map[x][cameraY] == CAN_SEE) {
                    // 관찰 가능한 0번이거나, 이미 관찰한 9번이라면
                    map[x][cameraY] = CAN_SEE;
                }
            }
        } else if(showDir == DOWN) {
            for(int x = cameraX; x < N; x++) {
                if(map[x][cameraY] == WALL) break;
                if(map[x][cameraY] == 0 || map[x][cameraY] == CAN_SEE) {
                    map[x][cameraY] = CAN_SEE;
                }
            }
        }else if(showDir == LEFT) {
            for(int y = cameraY; y >= 0; y--) {
                if(map[cameraX][y] == WALL) break;
                if(map[cameraX][y] == 0 ||map[cameraX][y] == CAN_SEE) {
                    map[cameraX][y] = CAN_SEE;
                }
            }
        }else if(showDir == RIGHT) {
            for(int y = cameraY; y < M; y++) {
                if(map[cameraX][y] == WALL) break;
                if(map[cameraX][y] == 0 ||map[cameraX][y] == CAN_SEE) {
                    map[cameraX][y] = CAN_SEE;
                }
            }
        }
 }

마지막으로, 전체 경우의 수를 돌아줄 DFS 메서드를 만들어준다.

private static void dfs(int idx, int[][] map) {
        if(idx == cameras.size()) { // 기저조건 : 모든 카메라를 다 돌았다면 종료
            answer = Math.min(answer, getEdgeCount(map));
            // map 에서 0의 갯수를 센 것과, answer 중 작은 것을 저장한다.
            return;
        }
        Camera camera = cameras.get(idx); // 해당 인덱스의 카메라를 가져오고
        int x = camera.x;
        int y = camera.y;
        int[][] newMap = new int[N][M];
        for(int i = 0 ; i < 4 ; i++) { // 회전횟수 4회를 돌면서
            int[] next = d[camera.type][i]; // 카메라의 타입(1차원) -> 회전 횟수에 따른 움직임들(2차원)
            newMap = copyMap(map); // 이전의 map 을 복사해준다. (서로에게 영향을 끼치지 않기 위해)
            for(int j = 0; j < next.length; j++) {
            	// {LEFT, RIGHT, DOWN}  일 경우, LEFT->RIGHT->DOWN 을 감시해준다.
                show(newMap, x, y, next[j]);
            }
            // 이러면, i번 회전한 카메라로 여러 방향을 감시한 결과가 newMap 에 저장되고
            dfs(idx + 1, newMap);
           	// 재귀로 넘겨준다.
        }
    }

이제 합치면 끝이다.

Source Code

import java.io.*;
import java.util.*;

public class Main {
    private static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    private static int N,M,answer;
    private static int[][] map;
    private static ArrayList<Camera> cameras;
    // 1번 : RIGHT -> DOWN -> LEFT -> UP
    // 2번 : LEFT, RIGHT -> UP, DOWN -> LEFT, RIGHT -> UP, DOWN
    // 3번 : UP, RIGHT -> RIGHT, DOWN -> DOWN, LEFT -> LEFT, UP
    // 4번 : UP, LEFT, RIGHT -> UP, RIGHT, DOWN -> RIGHT, DOWN, LEFT -> DOWN, LEFT, UP
    private static final int UP = 0, DOWN = 1, LEFT = 2, RIGHT = 3, WALL = 6, CAN_SEE = 9;
    private static int[][][] d = {{}, {{RIGHT},{DOWN},{LEFT},{UP}}, {{LEFT, RIGHT}, {UP, DOWN}, {LEFT, RIGHT}, {UP,DOWN}}, {{UP,RIGHT}, {RIGHT, DOWN}, {DOWN, LEFT}, {LEFT, UP}}, {{UP,LEFT,RIGHT},{ UP,RIGHT,DOWN},{RIGHT,DOWN,LEFT},{DOWN,LEFT,UP}}};

    private static class Camera {
        int x;
        int y;
        int type;

        public Camera(int x, int y, int type) {
            this.x = x;
            this.y = y;
            this.type = type;
        }

        @Override
        public String toString() {
            return "Camera{" +
                    "x=" + x +
                    ", y=" + y +
                    ", type=" + type +
                    '}';
        }
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
    }

    private static void input() throws IOException {
        StringTokenizer nm = new StringTokenizer(bufferedReader.readLine());
        N = Integer.parseInt(nm.nextToken());
        M = Integer.parseInt(nm.nextToken());
        map = new int[N][M];
        answer = Integer.MAX_VALUE;
        cameras = new ArrayList<>();
        for(int i = 0 ; i < N; i++) {
            StringTokenizer line = new StringTokenizer(bufferedReader.readLine());
            for(int j = 0 ; j < M; j++) {
                map[i][j] = Integer.parseInt(line.nextToken());
                if(map[i][j] > 0 && map[i][j] < 6) {
                    cameras.add(new Camera(i,j, map[i][j]));
                }
            }
        }
        ArrayList<Camera> newCameras = new ArrayList<>();
        for(Camera c : cameras) {
            if(c.type == 5) {
                show(map, c.x, c.y, UP);
                show(map, c.x, c.y, DOWN);
                show(map, c.x, c.y, RIGHT);
                show(map, c.x, c.y, LEFT);
            } else {
                newCameras.add(c);
            }
        }
        cameras = newCameras;
    }

    private static int getEdgeCount(int[][] map) {
        int sum = 0;
        for(int i = 0 ; i < N; i++) {
            for(int j = 0 ; j < M; j++) {
                if(map[i][j] == 0) sum++;
            }
        }
        return sum;
    }

    private static void printMap(int[][] map) {
        for(int i = 0 ; i < N; i++) {
            for(int j = 0 ; j < M; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println("====================");
    }

    private static int[][] copyMap(int[][] map) {
        int[][] result = new int[N][M];
        for(int i = 0 ; i < N; i++) {
            result[i] = map[i].clone();
        }
        return result;
    }


    private static void show(int[][] map, int cameraX, int cameraY, int showDir) {
        if(showDir == UP) {
            for(int x = cameraX; x >= 0; x--) {
                if(map[x][cameraY] == WALL) break;
                if(map[x][cameraY] == 0 || map[x][cameraY] == CAN_SEE) {
                    map[x][cameraY] = CAN_SEE;
                }
            }
        } else if(showDir == DOWN) {
            for(int x = cameraX; x < N; x++) {
                if(map[x][cameraY] == WALL) break;
                if(map[x][cameraY] == 0 || map[x][cameraY] == CAN_SEE) {
                    map[x][cameraY] = CAN_SEE;
                }
            }
        }else if(showDir == LEFT) {
            for(int y = cameraY; y >= 0; y--) {
                if(map[cameraX][y] == WALL) break;
                if(map[cameraX][y] == 0 ||map[cameraX][y] == CAN_SEE) {
                    map[cameraX][y] = CAN_SEE;
                }
            }
        }else if(showDir == RIGHT) {
            for(int y = cameraY; y < M; y++) {
                if(map[cameraX][y] == WALL) break;
                if(map[cameraX][y] == 0 ||map[cameraX][y] == CAN_SEE) {
                    map[cameraX][y] = CAN_SEE;
                }
            }
        }
    }

    private static void dfs(int idx, int[][] map) {
        if(idx == cameras.size()) {
            answer = Math.min(answer, getEdgeCount(map));
            return;
        }
        Camera camera = cameras.get(idx);
        int x = camera.x;
        int y = camera.y;
        int[][] newMap = new int[N][M];
        for(int i = 0 ; i < 4 ; i++) {
            int[] next = d[camera.type][i];
            newMap = copyMap(map);
            for(int j = 0; j < next.length; j++) {
                show(newMap, x, y, next[j]);
            }
            dfs(idx + 1, newMap);
        }
    }

    private static void solve() throws IOException {
        dfs(0, map);
        System.out.println(answer);
    }
}

백준 1062번 : 가르침 풀이(Java) - 브루트포스

심정욱 — Sun, 18 Apr 2021 17:06:32 +0900

www.acmicpc.net/problem/1062

1062번: 가르침

첫째 줄에 단어의 개수 N과 K가 주어진다. N은 50보다 작거나 같은 자연수이고, K는 26보다 작거나 같은 자연수 또는 0이다. 둘째 줄부터 N개의 줄에 남극 언어의 단어가 주어진다. 단어는 영어 소문

www.acmicpc.net

Solution

이 문제는 조합 + 브루트포스로 풀 수 있다. 해법은 다음과 같다.

가르칠 수 있는 문자가 K개로 한정되어 있으므로, a~z 중에 어떤 문자를 가르칠 지 정해야 한다. -> 바로 조합임을 알 수 있다.
그럼 주어진 단어들을 읽을 수 있냐는 간단하다. 단어의 0번 알파벳부터 끝 알파벳까지, 가르친 적 없는 문자가 하나라도 있다면 읽을 수 없으므로 갯수에 포함하지 않고, 다 읽을 수 있다면 답을 더해준다.
모든 조합의 경우의 수에서, 읽을 수 있는 최대값을 구한다.

이다.

알파벳은 a부터 z까지 26개 이므로, 26개 중에 K개를 뽑으면 되겠다. 그렇게 푼게 맨 밑의 풀이, 2616ms 가 나왔다.

사실 첫 풀이를 제출할 때 시간초과가 날 줄 알았는데, 엄청나게 긴 시간이 나왔으므로 바로 떠오른 시간 줄이기 방법을 적용했다.

문제의 조건 중에,

남극언어의 모든 단어는 "anta"로 시작되고, "tica"로 끝난다. 남극언어에 단어는 N개 밖에 없다고 가정한다.

라는 게 있다. 즉, anta 와 tica 를 "반드시" 읽을 수 있어야 단어 전체를 읽어볼 수 있을까 말까한다는 뜻이다.

anta 와 tica 를 읽으려면 기본적으로 a, n, t, i, c 의 알파벳을 알아야 하므로, 이 5개는 기본으로 깔고 가자는 거다.

이는 곧, K 가 5 미만이라면(가르칠 수 있는 문자 갯수가 5 이하라면) 어떤 단어가 오든 아예 못 읽는다는 말이므로 조기 종료해주면 된다.

코드를 보면 금방 이해 될 것이다.

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    private static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    private static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    private static int N,K, answer;
    private static String[] words;
    private static boolean[] pickedChars;
    private static char[] defaults = new char[]{'a','c','n','t','i'};
    
    public static void main(String[] args) throws IOException {
        input();
        solve();
        bufferedReader.close();
        bufferedWriter.close();
    }

    private static void input() throws IOException {
        StringTokenizer nk = new StringTokenizer(bufferedReader.readLine());
        N = Integer.parseInt(nk.nextToken());
        K = Integer.parseInt(nk.nextToken());
        if(K < 5) { // 가르칠 수 있는 게 5개 미만이면 어차피 아무것도 못읽는다.
            System.out.println(0);
            System.exit(0);
        }
        K -= 5; // 디폴트로 뽑을 것이므로
        words = new String[N];
        for(int i = 0 ; i < N; i++) {
            String word = bufferedReader.readLine();
            words[i] = word;
        }
    }
    
    private static void solve() {
        makeCombination(0,0,new int[K]);
        System.out.println(answer);
    }
    
    private static void makeCombination(int start, int cnt, int[] picked) {
        if(cnt == K) {
            pickedChars = new boolean[26];
            setDefault();
            for(int i = 0 ; i < K; i++) {
                char c = (char)(picked[i] + 97);
                pickedChars[picked[i]] = true;
            }
            checkReadable();
            return;
        }
        for(int i = start; i < 26; i++) { // 0번부터 25번 까지(a부터 z까지)
            boolean alreadyPicked = false; // 미리 가르친 a,c,n,t,i 중에서 또 가르치면 낭비이므로,
            for(char aDefault : defaults) {
                if(aDefault-'a' == i) { // 만약 i 번이 이미 가르친 a,c,n,t,i 의 code값과 같다면
                    alreadyPicked = true; // 낭비임을 체크해준다.
                    break;
                }
            }
            if(alreadyPicked) { // 만약 낭비라면, 조합을 만들어줄 필요가 없다.
                continue;
            }
            picked[cnt] = i;
            makeCombination(i+1, cnt+1, picked);
        }
    }

    private static void setDefault() {
        for (char aDefault : defaults) {
            pickedChars[aDefault - 'a'] = true;
        }
        // a,c,n,t,i 를 미리 가르친다.
    }

    private static void checkReadable() {
        int sum = 0;
        for(int i = 0 ; i < N; i++) {
            boolean readable = true; // 해당 단어를 읽을 수 있는지
            for(int j = 0 ; j < words[i].length(); j++) {
                char c  = words[i].charAt(j); // 단어의 알파벳 하나하나 중에
                if(!pickedChars[(int)c - 97]) { // 안가르친게 있다면 
                    readable = false; // 읽을 수 없음을 체크해준다.
                    break;
                }
            }
            if(readable) { // 읽을 수 있다면 
                sum++; // 갯수를 더해주고
            }
        }
        answer = Math.max(answer, sum); // 최대값을 저장해준다.
    }
}

백준 7576번 : 토마토 풀이(Java) - BFS

심정욱 — Wed, 14 Apr 2021 10:32:36 +0900

www.acmicpc.net/problem/7576

7576번: 토마토

첫 줄에는 상자의 크기를 나타내는 두 정수 M,N이 주어진다. M은 상자의 가로 칸의 수, N은 상자의 세로 칸의 수를 나타낸다. 단, 2 ≤ M,N ≤ 1,000 이다. 둘째 줄부터는 하나의 상자에 저장된 토마토

www.acmicpc.net

얼마 전에 풀었던 문제인데 다시 풀게 되었다.

Solution

이 문제는 BFS를 구현할 줄 안다면 크게 어렵지 않은데, 주의할 점은,

이미 익어있는 토마토(즉, 시작점) 가 처음에 여러 개 있을 수 있다.
토마토가 몇 초 대에 익는지 기록한다.

이다. 즉, 1번의 경우 여러 토마토가 한 번에 큐에 담겨서 같이 순차적으로 진행될 수 있도록 해야한다는 의미이다.

2번의 경우는, 큐에 담을 때 토마토가 몇 초 대에 익는지 기록하고 나면, 그 토마토에 의해서 익을 다음 토마토들은 이전 토마토가 익은 시간 + 1 이 담기면 된다는 것이다. ( 2초 대에 익은 토마토가 3초 대에 상,하의 토마토를 익힘 )

한 번 풀어봤던 문제라 빠르게 풀었다.

실행 시간을 줄인 것은, 입력 받을 때 익혀야 되는 토마토의 수, 즉 0인 것들의 갯수를 세어서 bfs를 돌고 난 이후에 체크해줘서 2차원 반복을 피할 수 있었다. 입력이 작아서 크게 소용있진 않았지만,,

Source Code

import java.io.*;
import java.util.*;

public class Main {
    private static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    private static int width, height, result, shouldRipeCount;
    private static int[][] map;
    private static ArrayList<Node> tomatoes;
    private static boolean[][] visited;
    private static int[] dx = {-1,1,0,0};
    private static int[] dy = {0,0,-1,1};


    private static class Node {
        int x;
        int y;
        int depth;

        public Node(int x, int y, int depth) {
            this.x = x;
            this.y = y;
            this.depth = depth;
        }
    }

    private static void input() throws IOException {
        StringTokenizer wh = new StringTokenizer(bufferedReader.readLine());
        width = Integer.parseInt(wh.nextToken());
        height = Integer.parseInt(wh.nextToken());
        map = new int[height][width];
        visited = new boolean[height][width];
        tomatoes = new ArrayList<>();
        for(int i = 0 ; i < height; i++) {
            StringTokenizer st = new StringTokenizer(bufferedReader.readLine());
            for(int j = 0 ; j < width; j++) {
                map[i][j] = Integer.parseInt(st.nextToken());
                if(map[i][j] == 1) {
                    tomatoes.add(new Node(i,j, 0)); // 이미 익은 토마토들을 담아주고,
                    visited[i][j] = true; // 방문 처리도 해준다.
                } else if(map[i][j] == 0) {
                    shouldRipeCount++; // 익혀야 하는 토마토 갯수
                }
            }
        }
    }

    private static boolean bfs() {
        ArrayDeque<Node> queue = new ArrayDeque<>();
        queue.addAll(tomatoes); // 초기에 익은 토마토들을 먼저 담는다.
        int ripeCount = 0; // BFS로 인해 익을 토마토의 갯수를 담는다.
        while (!queue.isEmpty()) {
            Node s = queue.poll();
            int sx = s.x;
            int sy = s.y;
            int sd = s.depth; // 토마토가 sd 초에 익었다는 것을 나타낸다.
            result = sd; // BFS 가 끝날 때,마지막에 익은 토마토는 sd초에 익을 것이므로 계속 대입해준다.
            for(int i = 0 ; i < 4; i++) {
                int nx = sx + dx[i];
                int ny = sy + dy[i];
                if(nx < 0 || ny < 0 || nx >= height || ny >= width) continue;
                if(visited[nx][ny]) continue;
                if(map[nx][ny] == 0) {
                    map[nx][ny] = 1;
                    ripeCount++;
                    visited[nx][ny] = true;
                    queue.add(new Node(nx, ny, sd + 1));
                }
            }
        }
        if(ripeCount == shouldRipeCount) { // 익힌 갯수 = 익혀야 할 갯수라면 true
            return true;
        } else return false;
    }

    private static void solve() throws IOException {
        if(bfs()) {
            System.out.println(result);
        } else {
            System.out.println(-1);
        }

    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
    }
}

백준 12026 번 : BOJ 거리 풀이(Java) - DP

심정욱 — Wed, 31 Mar 2021 22:24:25 +0900

www.acmicpc.net/problem/12026

12026번: BOJ 거리

스타트가 링크를 만나는데 필요한 에너지 양의 최솟값을 출력한다. 만약, 스타트가 링크를 만날 수 없는 경우에는 -1을 출력한다.

www.acmicpc.net

Solution

1. 이 문제는 N 이 최대 1000 밖에 안된다. 별로 크지 않다는 의미이고, 시간 제한도 2초로 굉장히 널널하다. 그래서 2중 for문을 돌아도 되겠다는 생각이 들었다. 처음에는 DP에 2중 for 문을 쓰면 터지지 않을까.. 걱정했지만 104ms 라는 만족스러운 시간으로 통과했다. 역시 먼저 드는 생각으로 풀어보는 게 최고인 것 같다.

2. 이 문제에는 규칙이 있다.

B 를 밟았다면, 다음은 무조건 O를, 마찬가지로

O -> J

J -> B

를 밟아야 한다.

BOJBOJBOJ

가 입력이라 가정해보자.

맨 처음(0번)은 무조건 B 이므로, 다음 순번인 1번부터 끝까지 살피면서 O인 곳을 체크한다. 갈 수 있는 모든 곳을 체크하면서, 인덱스 0번 -> 인덱스 i 번으로 가는 데 드는 비용은 i*i 가 될 것이다.

그 다음인 1번은 O 이므로, 다음 순번인 2번부터 끝까지 살피면서 J인 곳을 체크한다. ( B -> O -> J -> B -> ... )

마찬가지로 (i - 1) * (i - 1) 을 비용으로 정해준다.

2번인 J 도 똑같은 과정을 했다고 생각하면,

0번의 B에 의해서, 1번의 O, 4번의 O, 7번의 O 가 값이 정해졌고,

1번의 O에 의해서, 2번의 J, 5번의 J, 8번의 J 의 값이 정해졌고,

2번의 J 에 의해서, 3번의 B, 6번의 B 의 값이 정해졌다.

도착하는 기준은, dp[N-1] 의 값(0 번부터 N번 까지 가는 데 드는 최소 비용) 이 초기화된 값( 최소 값을 구하는 것이므로, 아주 큰 값(Integer.MAX_VALUE 라던가) ) 이 아니라면 N번에 갈 수 있다는 것이 된다.

그러므로 출력 형식은, dp[N-1] 이 MAX 라면 -1 을 출력, 아니라면 dp[N-1] 을 출력하면 된다.

3. 하지만 2번처럼 그 때마다 값을 그냥 바꿔주면 최소가 보장되지 않는다.

0번 k번 i번 N-1번

B O O J

라면, k번과 i 번 중 어느 O를 밟고 가야 최선일까?

0~k-1, k+1 ~ i - 1 번에 있는 것들이 어떻게 될 지 모르니까,

만약 a -> b 로 간다면,

dp[b] 배열에 담겨있는 값과, ( 0번부터 b 번까지 가는 값들 중 현재까지 발견된 최소 값)
dp[a] + (b-a)^2 의 값 (0번부터 a 번까지 가는 최소값 + a 번에서 b 번까지 점프하는데 드는 비용 )

을 비교해서, 작은 값으로 담아줘야 한다.

이 점만 알면 구현은 쉽다.

Source Code

import java.io.*;
import java.util.Arrays;

public class Main {
    private static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    private static final int MAX = 987654321;
    private static int N;
    private static char[] street;
    private static int[] dp;
    private static void input() throws IOException {
        N = Integer.parseInt(bufferedReader.readLine());
        street = new char[N];
        street = bufferedReader.readLine().toCharArray();
        dp = new int[N];
        Arrays.fill(dp, MAX);
    }

    private static void solve() throws IOException {
        dp[0] = 0;
        for(int i = 0; i < N-1; i++) {
            int now = i;
            char nowBlock = street[now];
            if(nowBlock == 'B') {
                for(int j = i +1; j < N; j++) {
                    int next = j;
                    char nextBlock = street[next];
                    if(nextBlock == 'O') {
                        dp[next] = Math.min(dp[next], dp[now] + (next-now) * (next-now));
                    }
                }
            } else if(nowBlock == 'O') {
                for(int j = i +1; j < N; j++) {
                    int next = j;
                    char nextBlock = street[next];
                    if(nextBlock == 'J') {
                        dp[next] = Math.min(dp[next], dp[now] + (next-now) * (next-now));
                    }
                }
            } else {
                for(int j = i +1; j < N; j++) {
                    int next = j;
                    char nextBlock = street[next];
                    if(nextBlock == 'B') {
                        dp[next] = Math.min(dp[next], dp[now] + (next-now) * (next-now));
                    }
                }
            }
        }
        if(dp[N-1] == MAX) {
            System.out.println("-1\n");
        } else {
            System.out.println(dp[N-1]);
        }
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
    }
}

백준 1915번 : 가장 큰 정사각형 풀이 (Java) - DP

심정욱 — Sat, 27 Mar 2021 19:41:32 +0900

www.acmicpc.net/problem/1915

1915번: 가장 큰 정사각형

첫째 줄에 n, m(1 ≤ n, m ≤ 1,000)이 주어진다. 다음 n개의 줄에는 m개의 숫자로 배열이 주어진다.

www.acmicpc.net

Solution

1. N*M 2차원 배열 dp 를 만들고, 안에 들어가는 값은

dp[a][b] = (a,b) 를 오른쪽 아래로 하는 정사각형 중, 최대 정사각형의 변의 길이 이다.

2. 오른쪽 아래를 기점으로 삼는다는 말은,

dp[a-1][b] ( 오른쪽 위 )

dp[a-1][b-1] ( 왼쪽 위 )

dp[a][b-1] (왼쪽 아래)

가 모두 1보다 커야 한다. 예제로 한번 보자. 만약에 입력이

4 4

0111

이라면, dp 배열은

0 1 1 1
0 1 2 2
0 1 2 3
0 1 2 3

가 된다.

천천히 보자. 우선 당연히 (1,1)부터 봐야한다. ( 왼쪽 위까지 봐야 하니까 )

(1,1) 에서는 (0,0), (0,1), (1,0) 을 볼텐데, (0,0) 과 (1,0) 이 0, 즉 정사각형의 선분이 될 수 없으므로 그냥 자신의 값인 1만 유지한다.
(1,2) 에서라면 ? (0,1), (0,2), (1,1) 을 보는데, 이 3개의 값이 전부 0보다 크다. 즉, 최소 한개의 선분은 가지고 있다는 뜻이 될 것이다. 그럼 일단 직관적으로 봤을 때 선분의 길이가 2인 정사각형을 만들 수 있으므로 넘어가자.

위 예제에서, 우리는 당연히 길이가 3인 정사각형이 최대인 걸 한 눈에 알 수 있다. 근데 문제는, 오른쪽에 세로 길이가 4인 직사각형 형태가 있다는 것인데, 어떻게 3과 4 중에 올바른 값을 골라낼 수 있을까?

이 문제가 생길 수 있는, 맨 오른쪽 아래의 (3,3)을 보자.

(2,2) 는 2, (2,3) 은 3, (3,2) 는 2 이다. 즉, (2,2) 까지는 길이가 2인 정사각형을 무조건 만들 수 있다는 것이 보장되고, (2,3)까지는 길이가 3인 정사각형을 무조건 만들 수 있다. (3,2)도 마찬가지로 2인 정사각형을 만들 수 있다.

여기서 우리가 알 수 있는 것은,

arr[i][j] 가 1 이고, (정사각형의 한 꼭지점이 될 수 있고 )
dp[i-1][j-1], dp[i-1][j], dp[i][j-1] 이 세 곳의 값 중에 최소값+1 의 선분의 길이가 최대 정사각형이라는 것이다.

이 예시에서, (2,2), (2,3), (3,2) 가 모두 3이면, (3,3) 이 1일 때, 길이가 4인 정사각형이 보장된다. 이것만 이해하면 금방 풀 수 있다.

Source Code

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    private static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    private static int N,M, max;
    private static int[][] arr, dp;
    private static void input() throws IOException {
        StringTokenizer nm = new StringTokenizer(bufferedReader.readLine());
        N = Integer.parseInt(nm.nextToken());
        M = Integer.parseInt(nm.nextToken());
        arr = new int[N][M];
        dp = new int[N][M];
        for(int i = 0 ; i < N; i++) {
            char[] line = bufferedReader.readLine().toCharArray();
            for(int j = 0 ; j < M; j++) {
                arr[i][j] = Character.getNumericValue(line[j]);
                dp[i][j] = arr[i][j];
                if(i >= 1 && j >= 1) {
                    if(dp[i-1][j] > 0 && dp[i-1][j-1] > 0 && dp[i][j-1] > 0 && dp[i][j] > 0) {
                        int min = Math.min(dp[i-1][j], Math.min(dp[i-1][j-1], dp[i][j-1]));
                        dp[i][j] = min + 1;
                    }
                }
                max = Math.max(max, dp[i][j]);
            }
        }
        for(int i = 0 ; i < N; i++) {
            for(int j = 0 ; j < M; j++) {
                System.out.print(dp[i][j] + " ");
            }
            System.out.println();
        }
    }

    private static void solve() throws IOException {
        System.out.println(max * max);
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
    }
}

백준 11659번 : 구간 합 구하기 4 풀이 (Java) - DP

심정욱 — Sat, 27 Mar 2021 18:46:23 +0900

www.acmicpc.net/problem/11659

11659번: 구간 합 구하기 4

첫째 줄에 수의 개수 N과 합을 구해야 하는 횟수 M이 주어진다. 둘째 줄에는 N개의 수가 주어진다. 수는 1,000보다 작거나 같은 자연수이다. 셋째 줄부터 M개의 줄에는 합을 구해야 하는 구간 i와 j

www.acmicpc.net

dp 에 익숙하다면 금방 풀 것이다. 10분도 안 걸린듯하다.

Solution

1. N, M 이 모두 최대가 100,000 이다. 만약 합을 구할 구간을 입력받을 때 마다 반복문으로 돌린다고 해도,1~100000 이 100000번 나온다면 100억 회를 해야 한다. 당연히 시간 초과가 뜰 것이다.

2. 즉 이 문제는, N 만큼의 배열의 숫자들을 입력 받을 때, dp 배열에다가 합을 미리 구해놓는 것이다.

dp[N] = 1번부터 N번 까지의 구간 합을 나타내는 것이다.

3. 그럼 A번 부터 B번 까지 (A <= B) 의 구간 합은,

dp[A] = 1번부터 A번 까지의 구간 합

dp[B] = 1번부터 B번 까지의 구간 합 이므로, dp[B] - dp[A] 이다.

Source Code

import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    private static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    private static int N,M;
    private static int[] arr, dp;

    private static void input() throws IOException {
        StringTokenizer nm = new StringTokenizer(bufferedReader.readLine());
        N = Integer.parseInt(nm.nextToken());
        M = Integer.parseInt(nm.nextToken());
        arr = new int[N+1];
        dp = new int[N+1];
        StringTokenizer line = new StringTokenizer(bufferedReader.readLine());
        for (int i = 1; i <= N; i++) {
            arr[i] = Integer.parseInt(line.nextToken());
            dp[i] = dp[i-1] + arr[i];
            // 구간합을 구할 때도 매번 i-1 번까지 for문으로 돌릴 필요가 없다.
        }
    }

    private static void solve() throws IOException {
        for(int i = 0; i < M; i++) {
            StringTokenizer section = new StringTokenizer(bufferedReader.readLine());
            int from = Integer.parseInt(section.nextToken()) - 1;
            int to = Integer.parseInt(section.nextToken());
            bufferedWriter.write((dp[to] - dp[from]) + "\n");
        }
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
        bufferedWriter.close();
        bufferedReader.close();
    }
}

백준 1600번 : 말이 되고픈 원숭이 풀이 ( Java ) - BFS

심정욱 — Wed, 24 Mar 2021 15:36:11 +0900

www.acmicpc.net/problem/1600

1600번: 말이 되고픈 원숭이

첫째 줄에 정수 K가 주어진다. 둘째 줄에 격자판의 가로길이 W, 세로길이 H가 주어진다. 그 다음 H줄에 걸쳐 W개의 숫자가 주어지는데, 0은 아무것도 없는 평지, 1은 장애물을 뜻한다. 장애물이 있

www.acmicpc.net

Solution

1. 이 문제는 백준 2206 번 : 벽 부수고 이동하기와 굉장히 유사한 문제이다. simju9397.tistory.com/11

백준 2206번 : 벽 부수고 이동하기 풀이(Java)

www.acmicpc.net/problem/2206 2206번: 벽 부수고 이동하기 N×M의 행렬로 표현되는 맵이 있다. 맵에서 0은 이동할 수 있는 곳을 나타내고, 1은 이동할 수 없는 벽이 있는 곳을 나타낸다. 당신은 (1, 1)에서 (N,

simju9397.tistory.com

2. 아직 저 문제를 풀어보지 않았다면 먼저 풀어보시길 바란다.

3. 메모리 초과의 이유

처음에 나는, 200*200*30 정도이므로 괜찮지 않을까? 하는 생각에 이 문제를 3차원 배열로 풀지 않고 2차원 배열을 복사해서 풀어봤다.

private static void bfs(int sx, int sy, int sd, boolean[][] visited, int k) {
        if(sx == W-1 && sy == H-1) {
            ans = Math.min(ans, sd);
            return;
        }
        visited[sx][sy] = true;
        boolean[][] visited1 = clone(visited);
        boolean[][] visited2 = clone(visited);
        for(int i = 0 ; i < 4; i++) {
            int nx = sx + dx[i];
            int ny = sy + dy[i];
            if(nx < 0 || ny < 0 || nx >= W || ny >= H) continue;
            if(visited1[nx][ny]) continue;
            visited1[nx][ny] = true;
            bfs(nx, ny, sd + 1, visited1, k);
        }
        if(k > 0 ) {
            for(int i = 0 ; i < 8; i++) {
                int mx = sx + kx[i];
                int my = sy + ky[i];
                if(mx < 0 || my < 0 || mx >= W || my >= H) continue;
                if(visited2[mx][my]) continue;
                visited2[mx][my] = true;
                bfs(mx, my, sd + 1, visited2, k-1);
            }
        }
    }

일반 상하좌우 이동을 하는 visited1 배열, 말처럼 이동하는 visited2 배열을 각각 visited 에서 복사해주고, 각각을 재귀로 넘겨주는 식으로 했다. 하지만 당연히 터졌다.

4. 이 문제의 핵심은, 방문처리를 하는 visited 배열을

H * W 크기의 boolean 배열이
K+1 개 만큼 있도록

3차원으로 만들어주는 것이다. 그럼 visited[x][y][k] 의 의미는, 말처럼 이동한 횟수가 k번일 때, (x,y)가 방문한 지점인지 로 생각하는 것이다.

평범하게 이동할 때는 visited[nx][ny][현재 k] 를 true 로 해주고,

말처럼 이동할 때는 visited[nx][ny][현재 k + 1] 을 true 로 해주면 될 것이다.

그럼 왜 K+1 개 만큼 만들어야 할까?

바로 K = 0 인 경우를 포함해야 하기 때문이다. 원숭이는 K회 만큼 말처럼 이동 가능하므로, 말처럼 움직이는 행위 없이(K = 0) 도착지에 도착할 수도 있을 것이고, 한 번이든 두 번이든 K회 이하로만 움직이면 된다는 것이다.

그럼 큐에 저장하기 위한 Node 의 필드 변수는 좌표 x,y 와 더불어, 얼마나 움직였는지를 나타내주는 depth, 그리고 지금까지 몇 번 만큼 말처럼 이동했는지를 나타내주는 k로 지정해주면 된다.

private static class Node {
        int x;
        int y;
        int depth;
        int k;

        public Node(int x, int y, int depth, int k) {
            this.x = x;
            this.y = y;
            this.depth = depth;
            this.k = k;
        }
    }

Source Code

import java.io.*;
import java.util.*;

public class Main {
    private static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    private static int K, W, H, ans;
    private static int[][] map;
    private static int[] dx = {-1,1,0,0};
    private static int[] dy = {0,0,-1,1};
    private static int[] kx = {-2,-1,1,2,2,1,-1,-2};
    private static int[] ky = {1,2,2,1,-1,-2,-2,-1};

    private static class Node {
        int x;
        int y;
        int depth;
        int k;

        public Node(int x, int y, int depth, int k) {
            this.x = x;
            this.y = y;
            this.depth = depth;
            this.k = k;
        }
    }

    private static void input() throws IOException {
        K = Integer.parseInt(bufferedReader.readLine());
        StringTokenizer wh = new StringTokenizer(bufferedReader.readLine());
        W = Integer.parseInt(wh.nextToken()); // 가로 길이
        H = Integer.parseInt(wh.nextToken()); // 세로 길이
        map = new int[H][W];
        for(int i = 0; i < H; i++) {
            StringTokenizer st = new StringTokenizer(bufferedReader.readLine());
            for(int j = 0;j < W; j++) {
                map[i][j] = Integer.parseInt(st.nextToken());
            }
        }
        ans = Integer.MAX_VALUE;
    }

    private static void bfs(Node start, boolean[][][] visited) {
        Deque<Node> deque = new ArrayDeque<>();
        deque.offer(start);
        visited[start.x][start.y][0] = true;
        while (!deque.isEmpty()) {
            Node node = deque.poll();
            int sx = node.x;
            int sy = node.y;
            int sd = node.depth;
            int sk = node.k; // 지금까지 말처럼 움직인 횟수
            if(sx == H-1 && sy == W-1) {
                ans = Math.min(ans, sd);
            }
            for(int i = 0 ; i < 4; i++) { // 평소처럼 이동하는 경우
                int nx = sx + dx[i];
                int ny = sy + dy[i];
                if(nx < 0 || ny < 0 || nx >= H || ny >= W) continue;
                if(sk > K || visited[nx][ny][sk] || map[nx][ny] == 1) continue;
                deque.offer(new Node(nx, ny, sd+1, sk));
                visited[nx][ny][sk] = true; // 평소대로 움직이므로 sk를 그대로
            }
            if(sk <= K-1) { // 말처럼 이동할 수 있는 경우
                for(int i = 0 ; i < 8; i++) { 
                    int nx = sx + kx[i];
                    int ny = sy + ky[i];
                    if(nx < 0 || ny < 0 || nx >= H || ny >= W) continue;
                    if(visited[nx][ny][sk+1] || map[nx][ny] == 1) continue;
                    deque.offer(new Node(nx, ny, sd+1, sk + 1));
                    visited[nx][ny][sk+1] = true; // 한 번 말처럼 이동하므로 sk+1 번째를 바꾼다.
                }
            }

        }
    }

    private static void solve() throws IOException {
        bfs(new Node(0,0,0, 0), new boolean[H][W][K+1]);
        if(ans==Integer.MAX_VALUE) {
            bufferedWriter.write(-1 + "\n");
        } else {
            bufferedWriter.write(ans + "\n");
        }
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
        bufferedWriter.close();
        bufferedReader.close();
    }
}

프로그래머스 코딩테스트 연습 : N으로 표현 Java 풀이 (DP 방식)

심정욱 — Tue, 23 Mar 2021 20:43:20 +0900

programmers.co.kr/learn/courses/30/lessons/42895

코딩테스트 연습 - N으로 표현

programmers.co.kr

오랜만에 프로그래머스 문제를 풀었다.

약 1년 전에 풀다가 못 풀겠어서 포기했던 문제인데, 오늘 드디어 풀었다!

Solution

1. N과 number 가 같은 경우, 1을 리턴해야 한다. (TC 9번)

2. 최대로 쓸 수 있는 N의 갯수가 8이므로, 1번부터 8번까지 표현할 수 있도록 Integer 를 담는 Set 배열을 9 크기로 만들어준다. 무슨 말이냐면,

set[1] => N을 1개 썼을 때 나올 수 있는 숫자들

set[2] => N을 2개 썼을 때 나올 수 있는 숫자들

이라는 말이다.

3. N을 여러개 이어서 붙이는 것, 즉 예시에서는 5를 2개 붙인 숫자인 55 가 있었다. 이미 계산된 결과의 앞, 뒤에 N을 붙이는 경우는 고려하지 않는다.

예를 들어, set[2] 에 5*5 해서 25 가 있을 텐데, 255 나 525 같은 방식은 고려하지 않는다는 것이다. 그러므로, set[8] 까지 5, 55, 555, 5555.... 만 생각하면 된다.

4. 마지막으로, set[i-1] 번째의 숫자들에 N을 사칙연산으로 붙여주면 TC 5번부터 8번까지 해결할 수 없다. 왜냐면, 이는 결국

set[i] = N을 i-1번 써서 만들 수 있는 숫자들 ( 사칙연산자 ) N

이라는 것인데, 괄호를 고려해야 한다.

만약, i가 4이라면 위의 경우에서는

(5+5+5)+5

의 경우만 고려한다는 것이다.

우리가 고려해야 할 경우는

(5+5+5)+5

5 + (5+5+5)

(5+5) + 5 + 5

5 + (5+5) + 5

5 + 5 + (5 + 5)

즉, set[i] = set[i-1] (사칙연산) set[1] + set[i-2] (사칙연산) set[2] + ... + set[2] (사칙연산) set[i-2]+ set[1] (사칙연산) set[i-1]

이다.

5. 주의해야 할점은, 같은 숫자들이 엄청나게 많아질 수 있다는 것이다. 메모리 초과가 날 수도 있다. set[2] 에 11 이 여러 개 있다면, 그 수에 대한 사칙연산 결과는 모두 똑같으므로 비효율적이다. 즉 중복 제거가 필요하므로, set 을 이용하는 것이다.

Source Code

import java.util.*;

public class Solution {
    public int solution(int N, int number) {
        if(N == number) {
            return 1;
        }
        TreeSet<Integer>[] possibleNumbers = new TreeSet[9];
        for(int i = 1; i <= 8; i++) {
            possibleNumbers[i] = new TreeSet<>();
        }
        possibleNumbers[1].add(N);
        for(int i = 2; i <= 8; i++) {
            String nn = "";
            for(int o = 0; o < i; o++) {
                nn += N;
            }
            possibleNumbers[i].add(Integer.parseInt(nn));
            if(Integer.parseInt(nn) == number) {
                return i;
            }
            for(int k = 1; k < i; k++) {
                Iterator<Integer> kIter = possibleNumbers[k].iterator();
                Iterator<Integer> pIter = possibleNumbers[i-k].iterator();
                while (kIter.hasNext()) {
                    Integer n1 = kIter.next();
                    HashSet<Integer> possibles = new HashSet<>();
                    while (pIter.hasNext()) {
                        Integer n2 = pIter.next();
                        possibles.add(n1 + n2);
                        possibles.add(n1 - n2);
                        possibles.add(n1 * n2);
                        if(n2 != 0) {
                            possibles.add(n1 / n2);
                        }
                    }
                    if(possibles.contains(number)) {
                        return i;
                    }
                    possibleNumbers[i].addAll(possibles);
                    pIter = possibleNumbers[i-k].iterator();
                    //이거 중요한데,kIter 를 돌면서 pIter를 한번 다 썼으므로 다시 초기화해야한다.
                }
            }
        }
        System.out.println(Arrays.toString(possibleNumbers));
        return -1;
    }

    public static void main(String[] args) {
        System.out.println(new Solution_N으로표현().solution(4, 17));
        //System.out.println(new Solution_N으로표현().solution(2, 11));
    }
}

백준 1149번 : RGB 거리 풀이 (Java) - DP

심정욱 — Tue, 23 Mar 2021 20:26:53 +0900

www.acmicpc.net/problem/1149

1149번: RGB거리

첫째 줄에 집의 수 N(2 ≤ N ≤ 1,000)이 주어진다. 둘째 줄부터 N개의 줄에는 각 집을 빨강, 초록, 파랑으로 칠하는 비용이 1번 집부터 한 줄에 하나씩 주어진다. 집을 칠하는 비용은 1,000보다 작거나

www.acmicpc.net

한 번 풀어본 문제라서 쉽게 풀었다.

Solution

1. 이 문제는 DP 문제이다. N번 집은 N-1 번 집의 색과 같으면 안된다. 세 번째 조건인

i(2 ≤ i ≤ N-1)번 집의 색은 i-1번, i+1번 집의 색과 같지 않아야 한다.

에서 좀 헷갈릴 수 있는데, 어차피 N-1 번의 집과 N번의 집을 다르게 칠한다면, N+1번도 N번과 다르게 칠하므로 상관없다.

2. 그러므로, 집의 개수 N * 칠할 수 있는 색의 종류 수 3 의 크기의 2차원 배열 dp 를 만든다.

3. dp[i][0] 번은 i번째의 집에 0번 색을 칠한다는 의미이고, 0번 색을 칠하는 데 드는 비용은

i 번째 집에 0번을 칠하는 비용 + i-1번째 집에 1번을 칠하는 비용과 2번을 칠하는 비용중에 작은 비용

이다.

DP에서는 쉬운 문제이다.

Source Code

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    private static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    private static int N, min;
    private static int[][] costs;
    private static int[][] dp;

    private static void input() throws IOException {
        N = Integer.parseInt(bufferedReader.readLine());
        costs = new int[N][3];
        dp = new int[N][3];
        min = Integer.MAX_VALUE;
        for(int i = 0 ; i < N; i++) {
            StringTokenizer st = new StringTokenizer(bufferedReader.readLine());
            for(int j = 0 ; j < 3; j++) {
                costs[i][j] = Integer.parseInt(st.nextToken());
                if(i == 0) {
                    dp[0][j] = costs[0][j];
                }
            }
        }
    }

    private static void solve() throws IOException {
        for(int i = 1; i < N; i++) {
            dp[i][0] = costs[i][0] + Math.min(dp[i-1][1], dp[i-1][2]);
            dp[i][1] = costs[i][1] + Math.min(dp[i-1][0], dp[i-1][2]);
            dp[i][2] = costs[i][2] + Math.min(dp[i-1][0], dp[i-1][1]);
        }
        min = Math.min(Math.min(dp[N-1][0], dp[N-1][1]), dp[N-1][2]);
        System.out.println(min);
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
    }
}

백준 1302번 : 베스트셀러 풀이 (Java)

심정욱 — Sun, 21 Mar 2021 15:14:20 +0900

www.acmicpc.net/problem/1302

1302번: 베스트셀러

첫째 줄에 오늘 하루 동안 팔린 책의 개수 N이 주어진다. 이 값은 1,000보다 작거나 같은 자연수이다. 둘째부터 N개의 줄에 책의 제목이 입력으로 들어온다. 책의 제목의 길이는 50보다 작거나 같고

www.acmicpc.net

이 문제를 풀고 나서 깨달았다.

어제 라인 코딩테스트의 반례가 여기 있었다는 걸 말이다. ㅠㅠ

이 문제는 로직 자체는 쉽지만, "사전순 정렬"을 해본 적이 없다면 주의해야 한다.

나는 java로 string 을 사전 순으로 정렬하는 것을 처음 해봤는데, 어제 LINE 코딩 테스트에 나왔었다.

사전 순이면,

ab, a 일 경우에

a 가 먼저 나오고 ab 가 다음에 나온다.

나는 단순하게 0번째 문자로만 비교를 했었다. 그렇기 때문에 위의 경우에서 ab, a 가 되어버렸다.

하지만 java의 string 에 훌륭한 메소드가 있었는데, 바로 compareTo 메소드이다.

string1.compareTo(string2) 의 리턴 형태는 int 이다.

0일 경우 같은 문자열이고,

음수일 경우 string1 이 사전 순으로 앞이고, 양수일 경우 string2 가 앞이다.

이것만 알면 틀릴 리가 없는 문제이다.

Source Code

import java.io.*;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Main {
    private static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    private static int N;
    private static HashMap<String, Integer> map;
    private static void input() throws IOException {
        N = Integer.parseInt(bufferedReader.readLine());
        map = new HashMap<>();
        for(int i = 0 ; i < N; i++) {
            String bookName = bufferedReader.readLine();
            Integer bookSoldCount = map.get(bookName);
            if(bookSoldCount == null) {
                map.put(bookName, 1);
            } else {
                map.put(bookName, bookSoldCount + 1);
            }
        }
    }

    private static void solve() throws IOException {
        Iterator<String> bookNames = map.keySet().iterator();
        int count = 0;
        String answer = "";
        while(bookNames.hasNext()) {
            String bookName = bookNames.next();
            Integer bookSoldCnt = map.get(bookName);
            if(count < bookSoldCnt) {
                answer = bookName;
                count = bookSoldCnt;
            } else if(count == bookSoldCnt) {
                answer = answer.compareTo(bookName) < 0 ? answer : bookName;
            }
        }
        System.out.println(answer);
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
    }
}

백준 14889번 : 스타트와 링크 풀이 (Java)

심정욱 — Wed, 17 Mar 2021 19:30:52 +0900

www.acmicpc.net/problem/14889

14889번: 스타트와 링크

예제 2의 경우에 (1, 3, 6), (2, 4, 5)로 팀을 나누면 되고, 예제 3의 경우에는 (1, 2, 4, 5), (3, 6, 7, 8)로 팀을 나누면 된다.

www.acmicpc.net

Solution

조합 + 브루트포스 문제이다.

1번부터 N번까지 중에, start 팀에 들어갈 N / 2 명을 뽑으면 나머지는 자연스레 link 팀이 된다.

나는 isStart 라는 boolean 배열에 뽑은 결과를 기반으로 true 면 start 팀, false 면 link 팀으로 생각하고,

이중 for문을 돌면서 값을 각각 더해줬다. 별로 어렵지 않으니 코드를 보자.

Source Code

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    private static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    private static int N, startSum, linkSum, answer;
    private static int[] people;
    private static boolean[] isStart;
    private static int[][] S;
    private static void input() throws IOException {
        N = Integer.parseInt(bufferedReader.readLine());
        people = new int[N];
        S = new int[N][N];
        startSum = 0;
        linkSum = 0;
        answer = Integer.MAX_VALUE;
        isStart = new boolean[N];
        for(int i = 0 ; i < N; i++) {
            StringTokenizer st = new StringTokenizer(bufferedReader.readLine());
            people[i] = i+1;
            for(int j = 0; j < N; j++) {
                S[i][j] = Integer.parseInt(st.nextToken());
            }
        }
    }

    private static void startCombi(int cnt, int start, int[] arr) {
        if(cnt == N / 2) {
            for(int i = 0 ; i < N/2; i++) {
                isStart[arr[i] - 1] = true;
            }
            for(int i = 0; i < N-1; i++) {
                for(int j = i+1; j < N; j++) {
                    if(isStart[i] && isStart[j]) {
                        startSum += S[i][j] + S[j][i];
                    } else if(!isStart[i] && !isStart[j]) {
                        linkSum += S[i][j] + S[j][i];
                    }
                }
            }
            answer = Math.min(answer, Math.abs(linkSum - startSum));
            startSum = 0;
            linkSum = 0;
            isStart = new boolean[N];
            // 초기화 해주는 것 잊지말자. 전역변수이기 때문이다.
            return;
        }
        for(int i = start; i < N; i++) {
            arr[cnt] = people[i];
            startCombi(cnt+1, i + 1, arr);
        }
    }

    private static void solve() throws IOException {
        startCombi(0, 0, new int[N/2]);
        System.out.println(answer);
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
        bufferedReader.close();
        bufferedWriter.close();
    }
}

백준 16236번 : 아기 상어 풀이(Java)

심정욱 — Wed, 17 Mar 2021 10:31:01 +0900

www.acmicpc.net/problem/16236

16236번: 아기 상어

N×N 크기의 공간에 물고기 M마리와 아기 상어 1마리가 있다. 공간은 1×1 크기의 정사각형 칸으로 나누어져 있다. 한 칸에는 물고기가 최대 1마리 존재한다. 아기 상어와 물고기는 모두 크기를 가

www.acmicpc.net

최근에 한 번 풀었던 문제를 사정이 있어 다시 풀게 되었는데, 빠르게 풀어서 기분이 좋다. 이런 구현 문제는 정말 조건을 잘 생각하고 그에 맞춰 구현 가능하면 금방 풀리는 데, 아니면 엄청 오래 걸리는 것 같다.

Solution

1. 먼저, 아기 상어의 이동의 종료 조건은 다음과 같다.

- 더 이상 먹을 수 있는 물고기가 없을 때(물고기가 아예 없거나, 남은 물고기가 전부 자신보다 크기가 크거나 같을 때)

2. 먹을 수 있는 물고기가 한 마리 남았으면 걔를 먹으면 된다.

3. 한 마리 이상이라면,

- 1순위 : 가장 가까운 물고기

- 2순위 : 가장 가까운 물고기가 여러 마리면, 가장 위에 있는 물고기

- 3순위 : 가장 가깝고 x 축의 값마저 같은 물고기가 여러 마리면, y 값이 가장 작은 물고기

이를 축약하면 결국, 젤 가깝고 젤 위에 있고 젤 왼쪽에 있는 물고기 를 먹는다고 생각하면 된다.

3. 가장 가까운 물고기, 즉 최단거리를 구해야 한다. 최단거리를 구하는 문제는 대부분이 BFS 로 풀 수 있다.

4. 주의할 점

- 첫 번째 : 가장 가까운 물고기는 여러 마리 일 수 있다. 위에서도 말한 건데, 즉 처음으로 먹을 수 있는(상어보다 크기가 작은) 물고기를 만났다고 해서, 바로 while 문을 끝내버리면 안된다는 것이다. 물고기를 처음 만났을 때의 거리를 최소 거리로 저장해두고 depth 가 그 최소 거리 이상이 되는 시점에서 끝내버리는 것도 가능하지만, 이 문제의 N은 최대가 20밖에 안되기 때문에 안 그래도 충분히 통과가 된다.

- 두 번째 : 여러 마리를 담았다면, 가장 가까운 물고기가 2마리 이상이라는 뜻이고, 1순위 x, 2순위 y 에 따라 정렬 해야 한다. Java 의 Comparable 인터페이스를 구현하는 방법과 Collections.sort 를 안다면 이는 어렵지 않다.

- 세 번째 : 그렇게 정렬까지 마쳤다면, 한 턴에 먹을 수 있는 물고기는 "한 마리" 임을 꼭 생각해야 한다. 정렬을 했으므로, 먹을 수 있는 물고기들 중에 0번째만 먹어야 한다는 것이다.

- 네 번째 : 물고기를 먹었다면, 해당 물고기가 있던 위치는 더 이상 아무것도 없게 되므로 0 으로 만들어 준다. 또한, 상어가 그 물고기를 먹으러 이동했으므로, 상어를 해당 물고기가 있던 위치 로 이동시켜줘야 한다.

이를 모두 숙지했다면 구현이 어렵지 않다.

Source Code

import java.io.*;
import java.util.*;

public class Main {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    static int N, time;
    static int[][] map;
    static Shark shark; // 상어의 정보
    static ArrayList<Fish> fishes; // 현재 남아있는 물고기들
    static int[] dx = {-1,1,0,0};
    static int[] dy = {0,0,-1,1};

    static class Node {
        int x;
        int y;
        int depth; // 상어로부터의 거리

        public Node(int x, int y, int depth) {
            this.x = x;
            this.y = y;
            this.depth = depth;
        }
    }
    static class Fish extends Node implements Comparable<Fish>{
    	// Fish 가 Node 를 상속받게 함으로써, 상어로부터의 거리 또한 가지게 한다.
        int size;

        public Fish(int x, int y, int depth, int size) {
            super(x, y, depth);
            this.size = size;
        }

        @Override
        public int compareTo(Fish o) {
            return this.x==o.x?this.y-o.y : this.x-o.x;
        }
    }

    static class Shark {
        int x;
        int y;
        int size;
        int eatFishCount; // 먹은 물고기 수가 size 가 된 순간, size++ 한 뒤 0으로 만들어줘야 한다.

        public Shark(int x, int y, int size, int eatFishCount) {
            this.x = x;
            this.y = y;
            this.size = size;
            this.eatFishCount = eatFishCount;
        }
    }

    static void input() throws IOException {
        N = Integer.parseInt(bufferedReader.readLine());
        map = new int[N][N];
        fishes = new ArrayList<>();
        for(int i = 0 ; i < N; i++) {
            StringTokenizer st = new StringTokenizer(bufferedReader.readLine());
            for(int j = 0 ; j < N; j++) {
                map[i][j] = Integer.parseInt(st.nextToken());
                if(map[i][j] == 9) {
                    shark = new Shark(i,j,2,0); // 초기 사이즈가 2인 아기 상어의 위치를 저장해준다.
                } else if(map[i][j] >= 1 && map[i][j] <= 6) {
                    fishes.add(new Fish(i,j, map[i][j], 0));
                    // 초기 물고기들의 위치와 크기를 저장해준다.
                }
            }
        }
    }

    static boolean bfs(boolean[][] visited) {
        Queue<Node> queue = new LinkedList<>();
        queue.add(new Node(shark.x, shark.y, 0)); 
        // 상어의 위치부터 시작하고, 상어부터 시작하므로 depth 는 0으로 시작한다.
        visited[shark.x][shark.y] = true;
        ArrayList<Fish> canEatFishes = new ArrayList<>();
        while (!queue.isEmpty()) {
            Node node = queue.poll();
            int sx = node.x;
            int sy = node.y;
            int sDepth = node.depth;
            for(int i = 0 ; i < 4; i++) {
                int nx = sx + dx[i];
                int ny = sy + dy[i];
                if(nx < 0 || ny < 0 || nx >= N || ny >= N) continue;
                if(visited[nx][ny]) continue;
                if(map[nx][ny] > 0 && map[nx][ny] != 9) {
                //해당 위치에 물고기가 있다면
                    if(shark.size > map[nx][ny]) { // 상어보다 작은 물고기만 먹을 수 있다.
                        if(canEatFishes.size() == 0) { // 아직 먹을 수 있는 물고기가 하나도 없다면 추가
                            canEatFishes.add(new Fish(nx,ny,sDepth+1, map[nx][ny]));
                        } else if(canEatFishes.get(canEatFishes.size() - 1).depth == sDepth + 1) {
                        	//먹을 수 있는 물고기가 하나 이상일 때, 먹을 수 있는 물고기보다
                            //거리가 먼 물고기는 담지 않게 한다.
                            canEatFishes.add(new Fish(nx,ny,sDepth+1, map[nx][ny]));
                        }

                    } else if(shark.size < map[nx][ny]) { // 상어보다 큰 물고기는 지나갈 수도 없다.
                        continue;
                    }
                    // 여기의 else 에는 자연스레, 상어랑 크기가 같은 물고기는 지나갈 수만 있다는 걸 암시한다.
                }
                visited[nx][ny] = true;
                queue.add(new Node(nx, ny, sDepth+1));
            }
        }
        Collections.sort(canEatFishes);
        // compareTo 메서드에 따라 정렬해준다. 같은 물고기가 여럿일 경우
        // x가 작은 물고기, y가 작은 물고기 순서대로 정렬된다.
        if(canEatFishes.size() == 0) {
            return false;
            // 먹을 수 있는 물고기가 아예 없다면, 반복문을 종료하기 위해 false 를 리턴한다.
        }
        Fish eatFish = canEatFishes.get(0);
        // 이미 정렬됐으므로, 먹을 물고기는 0번째에 있다.
        int idx = 0;
        for(int i = 0 ; i < fishes.size(); i++) {
            Fish fish = fishes.get(i);
            if(fish.x == eatFish.x && fish.y == eatFish.y) {
            	// 물고기들 중에, 먹을 물고기는 제거해줘야 한다.
                idx = i; // 제거될 물고기의 인덱스를 저장해주고
                shark.eatFishCount++; // 상어의 포식 횟수를 늘려준 뒤,
                time += eatFish.depth; // 먹을 물고기까지의 거리만큼의 시간이 흐르고,
                shark.x = eatFish.x;
                shark.y = eatFish.y;
                // 먹을 물고기의 위치로 상어를 이동시킨다
                map[eatFish.x][eatFish.y] = 0;
                // 먹힌 물고기는 사라졌으므로 map 에 0으로 표시해준다.
                break;
            }
        }
        if(shark.eatFishCount == shark.size) {
        	// 포식 횟수가 상어의 크기와 같아진다면
            shark.size++; // 상어의 크기를 늘려주고
            shark.eatFishCount = 0; // 포식 횟수를 초기화 한다.
        }
        fishes.remove(idx);
        // 물고기를 제거한다.
        //System.out.println(eatFish.x + " " + eatFish.y + " 먹음, time : " + time);
        return true;
    }

    static void solve() {
        while (!fishes.isEmpty()) { // 물고기가 아예 없거나
            if(!bfs(new boolean[N][N])) { // 먹을 수 있는 물고기가 없을 때 까지 돌린다.
                break;
            }
        }
        System.out.println(time);
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
        bufferedReader.close();
        bufferedWriter.close();
    }
}

백준 1759번 : 암호 만들기 풀이 및 Java 로 순열, 조합, 부분집합 만들기

심정욱 — Tue, 16 Mar 2021 21:07:27 +0900

www.acmicpc.net/problem/1759

1759번: 암호 만들기

첫째 줄에 두 정수 L, C가 주어진다. (3 ≤ L ≤ C ≤ 15) 다음 줄에는 C개의 문자들이 공백으로 구분되어 주어진다. 주어지는 문자들은 알파벳 소문자이며, 중복되는 것은 없다.

www.acmicpc.net

Solution

골드라고 하기엔 많이 쉬운 문제같다. 평소에 조합 짜는 코드를 잘 알고 있다는 가정 하에..

해법은 아주 간단하다. 우선

3 <= L, C <= 15 로 범위가 굉장히 작고, 중복되는 알파벳 소문자도 없으므로 그냥 별 생각없이 조합 + 완전탐색을 생각했다.

1. C개의 chars 중에서 L개의 char 배열인 arr 을 뽑아내야 한다. 조합을 사용하자.

2. 뽑아낸 L개의 배열 중에서 모음의 개수와 자음의 개수를 세어준다. 모음의 종류들을 미리 List 에 저장해두고, 거기 있으면 모음 아니면 자음으로 세면 된다. 모음 최소 1개, 자음 최소 2개 이상이므로 해당 조건을 만족하지 못하면 결과에 출력하지 않는다.

3. 해당 조건 말고는 없으므로, 정렬해서 알파벳 순서로 만들어준 뒤 String 으로 합쳐주면 끝이다.

워낙 별 게 없지만, 검색이 제한되는 환경이었다면 조금 고생했을 것 같다.

1. 모음 종류를 List 로 만들기

static List<Character> vowelTypes = Arrays.asList('a','e','i','o','u');

List.contains 메서드를 사용하기 위해서 만드려고 했는데, Arrays.asList 는 기억이 났는데 안에 들어가는 매개변수를 { } 로 감싸야하는지, [ ] 로 감싸야하는지 몰라서 둘 다 해봤는데 컴파일 에러가 났었다. 결론은 저렇게 그냥 콤마로 구분해서 넣으면 되더라.

2. 조합 코드

꽤 많이 짜왔다고 생각하는데 아직도 한 번씩 헷갈린다. 순열, 조합, 부분집합 코드는 암기를 해서 사용하면 편하다. 시험 환경에서 snippet 으로 저장해둬도 되지만 IDE 가 허용되지 않는 시험에서는 그럼 어떡할 것인가. 외우는게 낫다. 순열, 조합, 부분집합 코드를 저장해둔 것을 공유한다. 필요없다면 넘기자.

import java.util.Scanner;

public class Main {
    static int N, R = 2;
    static int[] nums;
    public static void main(String[] args) {
        System.out.print("입력할 갯수 : ");
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        nums = new int[N];
        for(int i = 0 ; i < N; i++) {
            nums[i] = sc.nextInt();
        }
        System.out.println("1. 조합의 결과");
        makeCombination(0,0,new int[R]);
        System.out.println("2. 순열의 결과");
        makePermutation(0, new int[N], new boolean[N]);
        System.out.println("3. 부분집합의 결과");
        makeSubset(0, new boolean[N]);
    }

    private static void makeCombination(int cnt, int start, int[] arr) {
        if(cnt == R) {
            for(int i = 0 ; i < R; i++) {
                System.out.print(arr[i] + " ");
            }
            System.out.println();
            return;
        }
        for(int i = start; i < N; i++) {
            arr[cnt] = nums[i];
            makeCombination(cnt+1, i+1, arr);
        }
    }

    private static void makePermutation(int cnt, int[] arr, boolean[] visited) {
        if(cnt == N) {
            for(int i = 0 ; i < N; i++) {
                if(visited[i]) System.out.print(arr[i] + " ");
            }
            System.out.println();
            return;
        }
        for(int i = 0 ; i < N; i++) {
            if(visited[i]) continue;
            visited[i] = true;
            arr[cnt] = nums[i];
            makePermutation(cnt + 1, arr, visited);
            visited[i] = false;
        }
    }

    private static void makeSubset(int cnt, boolean[] isSelected) {
        if(cnt == N) {
            for(int i = 0 ; i < N; i++) {
                if(isSelected[i]) System.out.print(nums[i] + " ");
            }
            System.out.println();
            return;
        }
        isSelected[cnt] = true;
        makeSubset(cnt+1, isSelected);
        isSelected[cnt] = false;
        makeSubset(cnt + 1, isSelected);
    }
}

Source Code

import java.io.*;
import java.util.*;

public class Main {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    static int L,C;
    static char[] chars;
    static List<Character> vowelTypes = Arrays.asList('a','e','i','o','u');

    static void input() throws IOException {
        StringTokenizer lc = new StringTokenizer(bufferedReader.readLine());
        L = Integer.parseInt(lc.nextToken());
        C = Integer.parseInt(lc.nextToken());
        chars = new char[C];
        StringTokenizer line = new StringTokenizer(bufferedReader.readLine());
        for(int i = 0 ; i < C; i++) {
            chars[i] = line.nextToken().charAt(0);
        }
        Arrays.sort(chars);
    }

    static void checkString(char[] arr) throws IOException {
        int vowels = 0;
        int cons = 0;
        for(int i = 0 ; i < L; i++) {
            if(vowelTypes.contains(arr[i])) {
                vowels++; // 모음 갯수
            } else {
                cons++; // 자음 갯수
            }
        }
        if(vowels < 1 || cons < 2) {
            return;
        }
        Arrays.sort(arr);
        bufferedWriter.write(new String(arr) + " \n");
    }

    static void makeCombination(int cnt, int start, char[] arr) throws IOException {
        if(cnt == L) {
            checkString(arr); // L개의 문자 배열이 완성되면 보낸다.
            return;
        }
        for(int i = start; i < C; i++) {
            arr[cnt] = chars[i];
            makeCombination(cnt+1, i+1, arr);
        }
    }

    static void solve() throws IOException {
        makeCombination(0,0,new char[L]);
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
        bufferedWriter.close();
        bufferedReader.close();
    }
}

Express 로 만든 내 서버, AWS lambda 에다가 올리기

심정욱 — Sun, 14 Mar 2021 21:40:57 +0900

개요

슬슬 공채 시즌 + SSAFY 5기의 삼성 SW역량테스트 A형 이 곧 다가와서 백준만 풀다가.. 정신이 나갈 것 같더라구요. 그런데 포폴을 쓰다가, AWS EC2 의 비용 문제로 스토어에서 내려버렸던( 지금 보니 바보짓이었어요 ) 저의 팀프로젝트 결과물을 다시 살려야 겠다는 생각을 했습니다.

비용은 한 달에 약 3만원 후반 대 정도였는데, 마케팅을 따로 하지 않았다 보니 사용자의 수에 비해 너무 과한 비용처럼 느껴졌습니다. 프리티어 쓰면 되지 않냐! 하실 수 있는데, 어떤 날은 10명 들어와서 그냥 서버가 터져버렸습니다. 그런 걸 방지하기 위해 ec2 티어를 올렸더니 또 유저가 안들어온 날이면 아.. 1300원 정도가 허공에 날아갔네 싶었습니다.

그러던 중 Severless 와 AWS Lambda 의 존재를 알게 되었고, 쓴 만큼 비용을 낸다! 는 것을 보고 적용해야겠다는 생각을 했습니다. 서비스는 production 환경은 lambda에서, dev 환경은 ec2 인스턴스에서 굴릴 예정입니다.

잡설이 길었는데, 얼른 시작해보겠습니다. 이번 글은, 별 설명없이 lambda 를 빠르게 적용해야 하는 분들에게 좋을 것 같습니다. 제 프로젝트의 환경은

- nodejs 14.x

- express

- http server

입니다.

1 단계 : express server를 lambda 에 deploy 하기

먼저, serverless 라는 패키지를 global 로 설치해줍니다.

$ npm install serverless -g

설치 되었는지 확인해줍니다.

$ serverless --version
Framework Core: 2.29.0
Plugin: 4.5.0
SDK: 4.2.0
Components: 3.7.3

이제 자신의 AWS 계정 정보를 입력해줘야 합니다. AWS 계정은 당연히 다 있다고 생각하고 진행합니다.

콘솔의 우상단에 있습니다.

[내 보안 자격 증명] 을 클릭해서 들어가줍니다.

저는 이미 있는데, 새 엑세스 키 만들기를 해줍니다.

이렇게 뜹니다. 보안 액세스 키는 이 창 이후로 다시 볼 수 없습니다. 다운로드 해두시길 바랍니다.

이제 콘솔창으로 돌아와서,

export AWS_ACCESS_KEY_ID=<your-key-here>
export AWS_SECRET_ACCESS_KEY=<your-secret-key-here>

[액세스 키 ID] 가 위, [보안 액세스 키] 가 아래입니다.

이제, serverless.yml 을 루트 디렉토리에 하나 만들어주고, 다음을 입력합니다.

service: {올릴 이름}
provider:
  name: aws
  runtime: nodejs14.x
  stage: production
  region: ap-northeast-2
  memorySize: 128
functions:
  app:
    handler: app/app.handler
    events: 
      - http: 
          path: /
          method: ANY
          cors: true
      - http: 
          path: /{proxy+}
          method: ANY
          cors: true

이제 app.js 내에 약간의 수정이 필요합니다. 먼저 serverless-http 패키지를 설치해줍니다.

$ npm install serverless-http

이후, app.js 를 다음과 같이 수정합니다.

var express = require('express');
const serverless = require('serverless-http');
var app = express();

/** 나머지 코드들 **/

module.exports.handler = serverless(app);

아마 많은 분들이 module.exports = app 을 설정해놨을 텐데, 사용해도 상관없는 것 같습니다.

이제 다 끝났습니다! 다음 명령어를 입력해줍시다.

serverless deploy

기다리다 보면 콘솔창에 좌라락 뜨는데, endpoints 부분이 우리가 접근할 수 있는 uri 입니다.

이제 기존의 localhost:포트번호 대신, https:// 다음 부분부터 끝까지 입력해주시면 됩니다. 기존의 서버가 http 서버였다면 이렇게 해야하고, https 서버면 전체를 입력하면 될 것입니다.

이제 aws 콘솔에서 lambda 로 들어가서 보시면 올려놓은 서버가 있을 겁니다. 그럼 끝입니다!

하지만?

저는 또 다른 문제점이 있었습니다. 외부 API 와 통신하는 기능이 있었는데, 해당 API 는 고정 IP 를 등록해두고 사용하는 방식이었습니다. 하지만 Lambda 는 고정 ip 가 아니라, 계속해서 ip 가 바뀐다고 하더라구요. 저는 구글링 끝에 이 문제를 어찌저찌 해결했습니다. 다음 포스팅에는 VPC 만들기, 탄력적 ip 할당, Lambda 에 권한 추가 등 제가 했던 일들을 정리해서 올려보겠습니다. 감사합니다!

백준 20055 번 : 컨베이어 벨트 위의 로봇 풀이(Java) - 삼성 역량 테스트 A형 기출문제

심정욱 — Sun, 14 Mar 2021 17:24:07 +0900

www.acmicpc.net/problem/20055

20055번: 컨베이어 벨트 위의 로봇

길이가 N인 컨베이어 벨트가 있고, 길이가 2N인 벨트가 이 컨베이어 벨트를 위아래로 감싸며 돌고 있다. 벨트는 길이 1 간격으로 2N개의 칸으로 나뉘어져 있으며, 각 칸에는 아래 그림과 같이 1부

www.acmicpc.net

문제 설명이 모호한 점이 많아서 삽질을 좀 했다. 먼저,

1. 회전할 때는 내구도가 소모되지 않는다. (오로지 이동할 때, 첫 칸에 로봇을 둘 때만 내구도가 감소한다.)

2. 그림이 2줄의 배열이 돌아가는 형태로 그려져서 오해하기 쉬운데, 로봇은 "내려가는 위치" 즉, [0][N-1] 에 도착하자마자 무조건 바로 떨어져서 사라진다. 즉, 이동에 의한 이동이든, 회전에 의한 이동이든 무조건 내려가는 위치에 도착하면 사라져야 한다.

3. 벨트는 회전한다. 이게 무슨 의미냐면, 벨트 한 칸마다 고유한 내구도가 있는데, 이것들이 회전을 해야한다는 말이다.

내구도가

10 10 10

9 9 9

로 되어있을 경우, 회전하면

9 10 10

9 9 10

으로 되어야 한다는 의미이다.

로봇의 이동이나 로봇을 새로 놓는 행위에 대해서, 고정적인 위치가 아니라는 의미이다.

나는 위의 세 가지를 제대로 파악 못해서 푸는 데 좀 걸렸다. 이런 구현 문제가 정말 어렵게 나오면 어려운 것 같다.

Solution

0. input 받기

- 내구도를 나타내는 A를 윗 줄인 topA와 bottomA 로 나눴고, 이들을 ArrayList<Integer> 로 설정했다.

- 로봇은 위의 한 줄에만 있으므로, topRobot 이라는 객체를 ArrayList<boolean> 으로 만들어줬다. true이면 로봇이 해당 위치에 있는 것, false 이면 없다는 것이다.

이 때 bottomA에서 중요한 것이 있는데, input으로 들어오는 순서가 bottomA에서는 역순이 되어야 한다는 것이다. 내구도가 만약

1 2 3 4 5 6 7 8

로 들어오면, topA와 bottomA로 나눠보면

1 2 3 4

8 7 6 5

가 되어야 한다.

만약 topA를 받는 순서가 정순이라고 그대로 받으면,

1 2 3 4

5 6 7 8

이 되어버리므로, 주의하자. 나는 받고 난 후에 Collections.reverse(bottomA) 로 뒤집어줬다.

1. 회전

회전할 때는 "내려가는 위치"에 있는, 즉 topA의 마지막 요소 를 bottomA 의 마지막 요소로 넣어주고, "올라가는 위치" 에 "올라 가야할 요소" 즉, bottomA의 첫 번째 요소 를 topA의 첫 번째 요소로 넣어준다. 이후, topA의 마지막 요소, bottomA의 첫 번째 요소들은 이미 이동했으므로 삭제해주면, 자연스레 회전이 완성된다.

2. 이동

로봇은 왼쪽에서 오른쪽으로 이동하므로, (윗 벨트의 이동방향이 왼쪽->오른쪽이므로) 이동할 수 있는 조건은,

1. 다음 위치의 내구도가 0보다 큰지(초과)

2. 다음 위치에 로봇이 이미 있는지

3. 현재 위치에 로봇이 있어서 이동 가능 한지

이다. 이 때,

topRobot을 오른쪽에서 왼쪽으로 순회하면서 확인한다. 그렇지 않으면,

T F F F F

일 때, 왼쪽에서 오른쪽으로 순회하면

F F F F T

가 될 것이다. 로봇은 한 번의 이동에서 한 칸 만 이동하므로 이는 일어나서는 안 된다.

3. 로봇 올리기

제일 간단한 메서드이다.

1. topA의 첫 번째 요소, 즉 "올라가는 위치"의 내구도가 0 보다 크고,

2. topRobot의 첫 번째 요소, 즉 "올라가는 위치"에 로봇이 없어야 한다.

그럴 경우, "올라가는 위치"에 topRobot 을 true 로 해서 로봇을 올려주고, topA는 1 감소 시켜주면 된다.

4. 내구도가 0인 칸이 K를 넘어가는지 체크하기

단순하게 topA와 bottomA를 모두 돌면서 내구도가 0 이하인 칸을 세어주고, K보다 큰지 작은지 boolean 을 리턴해준다.

이렇게 4가지의 메서드를 만들고, main 에서,

while(!4()) {
	1();
    2();
    3();
    cnt++;
}

이런 식으로 구현해줬다.

Source Code

import java.io.*;
import java.util.*;

public class Main {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    static int N,K,cnt;
    static ArrayList<Integer> topA;
    static ArrayList<Integer> bottomA;
    static ArrayList<Boolean> topRobot;
    static void input() throws IOException {
        StringTokenizer nk = new StringTokenizer(bufferedReader.readLine());
        N = Integer.parseInt(nk.nextToken());
        K = Integer.parseInt(nk.nextToken());
        topA = new ArrayList<>();
        bottomA = new ArrayList<>();
        topRobot = new ArrayList<>();
        StringTokenizer a = new StringTokenizer(bufferedReader.readLine());
        for(int i = 0; i < 2; i++) {
            for(int j = 0 ; j < N;j++) {
                if(i == 0) {
                    topA.add(Integer.parseInt(a.nextToken()));
                    topRobot.add(false);
                } else {
                    bottomA.add(Integer.parseInt(a.nextToken()));
                }
            }
        }
        Collections.reverse(bottomA);
    }
    
    static void addRobot() {
        //System.out.println("3. 로봇 놓기 단계");
        if(topA.get(0) > 0 && !topRobot.get(0)) {
            topRobot.set(0, true);
            topA.set(0, topA.get(0) - 1);
        }
    }

    static void printRobots() { // 디버그용 메서드.
        System.out.println("==========로봇 상태==========");
        for(int j = 0 ; j < N;j++) {
            if(topRobot.get(j)) System.out.print("R ");
            else System.out.print("X ");
        }
        System.out.println("\n=========내구도 상태============");
        for(int i = 0; i < 2; i++) {
            for(int j = 0 ; j < N;j++) {
                if(i == 0) System.out.print(topA.get(j) + " ");
                else System.out.print(bottomA.get(j) + " ");
            }
            System.out.println();
        }
        System.out.println("=================");
    }

    static void rotate() {
        //System.out.println("1. 회전 단계");
        topRobot.add(0, false); // 처음에 robot을 없애주고
        topRobot.remove(topRobot.size() - 1); // 마지막에 robot은 땅으로
        topA.add(0, bottomA.get(0));
        bottomA.add(bottomA.size() , topA.get(topA.size() - 1));
        topA.remove(topA.size()-1);
        bottomA.remove(0);
        if(topRobot.get(topRobot.size() - 1)) {
            topRobot.set(topRobot.size() - 1, false);
        }
    }

    static void move() {
        //System.out.println("2. 움직임 단계");

        for(int i = N-1; i > 0; i--) {
            int now = topA.get(i);
            boolean isNowRobot = topRobot.get(i);
            boolean isBeforeRobot = topRobot.get(i-1);
            if(now > 0 && !isNowRobot && isBeforeRobot) {
                topA.set(i, topA.get(i) - 1);
                topRobot.set(i, true);
                topRobot.set(i-1, false);
            }
            if(topRobot.get(topRobot.size() - 1)) {
                topRobot.set(topRobot.size() - 1, false);
            }
        }
    }

    static boolean isZeroMoreThanK() {
        int zeroCnt = 0;
        for(int j = 0 ; j < N; j++) {
            if(topA.get(j) <= 0) {
                zeroCnt++;
            }
        }
        for(int j = 0 ; j < N; j++) {
            if(bottomA.get(j) <= 0) {
                zeroCnt++;
            }
        }
//        System.out.println("4. 체크 단계 : 현재 0인 칸의 갯수 : " + zeroCnt);
//        printRobots();
        if(zeroCnt >= K) {
            return true;
        }
        else {
            return false;
        }
    }

    static void solve() {
        while (!isZeroMoreThanK()) {
            rotate();
            move();
            addRobot();
            cnt++;
        }
        System.out.println(cnt);
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
    }
}

백준 12100 번 : 2048 (Easy) 풀이 ( 삼성 SW 역량 테스트 기출 문제 )

심정욱 — Sat, 13 Mar 2021 16:33:28 +0900

www.acmicpc.net/problem/12100

12100번: 2048 (Easy)

첫째 줄에 보드의 크기 N (1 ≤ N ≤ 20)이 주어진다. 둘째 줄부터 N개의 줄에는 게임판의 초기 상태가 주어진다. 0은 빈 칸을 나타내며, 이외의 값은 모두 블록을 나타낸다. 블록에 쓰여 있는 수는 2

www.acmicpc.net

곧 SSAFY 에서 있을 삼성 SW 역량 테스트 A형 모의고사를 대비해 기출문제를 풀어보았다.

A형 취득할 수 있을지 걱정된다...

Solution

1. A형 문제는 대체로 완전탐색을 돌려도 문제가 없다고 하길래, 내 수준을 감안해서 완전탐색 말고는 생각을 하지 않기로 했다.

2. 먼저 방향에 따라서 배열을 움직이는 shift() 메서드를 만들었다. 방향이 상하좌우로 4가지, 최대 5번을 돌리므로, 4^5 만큼의 shift() 가 수행되어야 한다.

3. shift 의 파라미터에 depth 를 넣어서, 5번이 될 경우 return 시켜서 끝내버린다. 이후 map 을 이동시키고 나서, 상하좌우 4방향으로 shift 재귀를 돌려준다. 이 때, 상하좌우 shift의 파라미터로 들어가는 map의 메모리 주소가 같으면 안되므로 deepcopy 를 수행해야 한다.

4. 이게 무슨 말이냐면, 만약 0번째 수행에서 1번째 수행으로 가기 위해 반복문을 돌리면

shift(map, dir, depth+1);
shift(map, dir, depth+1);
shift(map, dir, depth+1);
shift(map, dir, depth+1);

이렇게 풀어질텐데, 이는 map이 같은 주소를 가진 채로 재귀가 수행되므로 상->하->좌->우 가 이전의 결과값을 바탕으로 실행이 된다. 그렇기에, 각 함수마다

shift(cloneMap(map), dir, depth+1);
shift(cloneMap(map), dir, depth+1);
shift(cloneMap(map), dir, depth+1);
shift(cloneMap(map), dir, depth+1);

이런 식으로 deepcopy 를 해주는 cloneMap 함수를 이용해서 각각의 결과가 독립적이도록 했다.

5. 이제 shift 함수를 구현해보면,

- 0번 : 위로 이동

맨 위에서 바로 아래부터(1번 열부터), (map[x][y])

바로 위의 열을 봤을 때, (map[x-1][y])

0이라면 -> 0이 아닐 때 까지 swap 을 해주면서 이동한다.

0이 아니라면?

-> 만약 같은 값이라면, map[x-1][y] 에 곱하기 2를 해주고, map[x][y] = 0 으로 만들어준다.

- !중요! 연쇄 반응이 없다고 문제에 나와 있으므로, 한 번 이렇게 합쳐진 곳은 다시 합쳐지지 않도록, summed 라는 boolean 2차원 배열에 기록해둔다.

-> 다른 값이라면 그냥 break

6. 한 번 이동해주고, 2차원 배열을 돌면서 max 값을 저장한다.

7. 이후 위에서 말한 것 처럼 4방향으로 shift 를 돌려주면 된다.

Source Code

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    static int N, max;
    static int[][] map;

    static void input() throws IOException {
        N = Integer.parseInt(bufferedReader.readLine());
        map = new int[N][N];
        for(int i = 0 ; i < N; i++) {
            StringTokenizer st = new StringTokenizer(bufferedReader.readLine());
            for(int j = 0; j < N; j++) {
                map[i][j] = Integer.parseInt(st.nextToken());
            }
        }
    }

    static boolean isOut(int nx, int ny) {
        return nx < 0 || ny < 0 || nx >= N || ny >= N;
    }

    static int[][] swap(int[][] map, int x, int y, int nx, int ny) {
        int temp = map[x][y];
        map[x][y] = map[nx][ny];
        map[nx][ny] = temp;
        return map;
    }

    static void findMax(int[][] map) {
        for(int i = 0 ; i < N; i++) {
            for(int j = 0; j < N; j++) {
                max = Math.max(max, map[i][j]);
            }
        }
    }

    static int[][] shift(int[][] map, int dir, boolean[][] summed, int depth) {
        if(depth == 5) {
            return null;
        }
        //System.out.println(depth + "회차 : " + "방향 : " + dir);
        switch (dir) {
            case 0:
                for(int x = 1; x < N; x++) {
                    for(int y = 0; y < N; y++) {
                        int nx = x;
                        while (!isOut(nx-1, y) && map[nx-1][y] == 0) {
                            map = swap(map, nx, y, nx-1, y);
                            nx--;
                        }
                        int nnx = nx;
                        while (!isOut(nnx-1, y)) {
                            if(map[nnx][y] == map[nnx-1][y] && !summed[nnx-1][y] && !summed[nnx][y]) {
                                map[nnx-1][y] *= 2;
                                map[nnx][y] = 0;
                                summed[nnx-1][y] = true;
                            } else {
                                break;
                            }
                            nnx--;
                        }
                    }
                }
                break;
            case 1:
                for(int x = 0; x < N; x++) {
                    for(int y = N-2; y >= 0; y--) {
                        int ny = y;
                        while (!isOut(x, ny+1) && map[x][ny+1] == 0) {
                            map = swap(map, x, ny, x, ny+1);
                            ny++;
                        }
                        int nny = ny;
                        while (!isOut(x, nny+1)) {
                            if(map[x][nny] == map[x][nny+1] && !summed[x][nny+1] && !summed[x][nny]) {
                                map[x][nny+1] *= 2;
                                map[x][nny] = 0;
                                summed[x][nny+1] = true;
                            } else {
                                break;
                            }
                            nny++;
                        }
                    }
                }
                break;
            case 2:
                for(int x = N-2; x >= 0; x--) {
                    for(int y = 0; y < N; y++) {
                        int nx = x;
                        while (!isOut(nx+1, y) && map[nx+1][y] == 0) {
                            map = swap(map, nx, y, nx+1, y);
                            nx++;
                        }
                        int nnx = nx;
                        while (!isOut(nnx+1, y)) {
                            if(map[nnx][y] == map[nnx+1][y] && !summed[nnx+1][y] && !summed[nnx][y]) {
                                map[nnx+1][y] *= 2;
                                map[nnx][y] = 0;
                                summed[nnx+1][y] = true;
                            } else {
                                break;
                            }
                            nnx++;
                        }
                    }
                }
                break;
            case 3:
                for(int x = 0; x < N; x++) {
                    for(int y = 1; y < N; y++) {
                        int ny = y;
                        while (!isOut(x, ny-1) && map[x][ny-1] == 0) {
                            map = swap(map, x, ny, x, ny-1);
                            ny--;
                        }
                        int nny = ny;
                        while (!isOut(x, nny-1)) {
                            if(map[x][nny] == map[x][nny-1] && !summed[x][nny-1] && !summed[x][nny]) {
                                map[x][nny-1] *= 2;
                                map[x][nny] = 0;
                                summed[x][nny-1] = true;
                            } else {
                                break;
                            }
                            nny--;
                        }
                    }
                }
                break;
        }
        findMax(map);
        for(int i = 0 ; i < 4; i++) {
            shift(cloneMap(map), i, new boolean[N][N], depth+1);
        }
        return map;
    }

    static int[][] cloneMap(int[][] map) {
        int[][] clone = new int[N][N];
        for(int i = 0; i < N; i++) {
            clone[i] = map[i].clone();
        }
        return clone;
    }

    static void solve() {
        for(int j = 0; j < 4; j++) {
            shift(cloneMap(map), j, new boolean[N][N], 0);
        }
        System.out.println(max);
    }


    public static void main(String[] args) throws IOException {
        input();
        solve();
    }
}

백준 2096 번 : 내려가기 풀이 (Java)

심정욱 — Thu, 11 Mar 2021 19:04:03 +0900

www.acmicpc.net/problem/2096

2096번: 내려가기

첫째 줄에 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 N개의 줄에는 숫자가 세 개씩 주어진다. 숫자는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 중의 하나가 된다.

www.acmicpc.net

문제를 잘 읽자.

Solution

1. 이 문제의 해법 자체는 dp 문제를 조금이라도 풀어봤다면 어렵지 않을 것이다. dp[i][j] 는, dp[i-1][j-1], dp[i-1][j], dp[i-1][j+1] 중에 최대값, 최소값을 가져와서 입력받았던 input[i][j] 를 더해주면 될 것이다.

2. 하지만 이 문제는 메모리 제한이 있다. 나는 얼마나 줄여야 메모리 초과가 안날지 궁금해서 가장 처음 떠오르는 방법부터 차근차근 해봤었다. 그리고 나는 이 문제의 행이 3개로 고정 되어있다는 걸 나중에 알았다.(문제 잘읽자 제발!!!) 아래에 적는 것 중에 열 부분의 N을 3이라 생각하고 봐주시길 바란다. (런타임 에러 이유 표시가 안됐다면 지옥이지 않았을까)

- N*N*2 (2는 최대, 최소를 한 배열에서 해결하기 위해) 의 dp 배열 + N*N의 map 배열 -> 바로 초과

- N*N 의 dp배열 2개 + N*N의 map 배열 -> 초과

- N*N의 dp 배열 2개 -> 초과

- 2*N의 dp 배열 2개 -> 초과안남

즉, 우리가 선택할 것은 2*3 의 dp 배열 2개이다. 왜 2*3 만으로 되는 걸까? 그 이유는,

지금 행과 이전 행 만 비교하면 되기 때문이다.

굳이 필요없는 행들 까지 다 저장할 필요가 아예 없다는 것이다.

그러므로 해법은 이렇게 될 것이다.

1. 입력을 받으면서 dp[0][j-1], dp[0][j], dp[0][j+1] 중에 최대값, 최소값 + 입력값 을 dp[1][j] 에 저장해준다. 입력을 받으면서 해야 N*3의 배열을 쓸 필요가 없어진다.

2. 모든 열의 값이 계산됐다면, dp[1] 배열을 dp[0] 에 deepcopy 해주고, dp[1] 배열은 0으로 모두 초기화해준다. 행을 올려주는 것이다.

3. 1, 2 를 반복한다.

Source Code

import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
    static int N, max = Integer.MIN_VALUE, min = Integer.MAX_VALUE;
    static int[][] dp1, dp2;
    static void input() throws IOException {
        N = Integer.parseInt(bufferedReader.readLine());
        dp1 = new int[2][3];
        dp2 = new int[2][3];
        for(int i = 0 ; i < N; i++) {
            StringTokenizer st = new StringTokenizer(bufferedReader.readLine());
            for(int j = 0; j < 3; j++) {
                dp1[1][j] = Integer.parseInt(st.nextToken());
                dp2[1][j] = dp1[1][j];
                if(j == 0) {
                    dp1[1][j] = Math.max(dp1[0][0], dp1[0][1]) + dp1[1][0];
                    dp2[1][j] = Math.min(dp2[0][0], dp2[0][1]) + dp2[1][0];
                } else if(j == 2) {
                    dp1[1][j] = Math.max(dp1[0][2], dp1[0][1]) + dp1[1][2];
                    dp2[1][j] = Math.min(dp2[0][2], dp2[0][1]) + dp2[1][2];
                } else {
                    dp1[1][1] = Math.max(Math.max(dp1[0][0], dp1[0][1]), dp1[0][2]) + dp1[1][1];
                    dp2[1][1] = Math.min(Math.min(dp2[0][0], dp2[0][1]), dp2[0][2]) + dp2[1][1];
                }
            }
            dp1[0] = dp1[1].clone();
            dp2[0] = dp2[1].clone();
            Arrays.fill(dp1[1], 0);
            Arrays.fill(dp2[1], 0);
        }
        for(int j = 0 ; j < 3; j++) {
            max = Math.max(max, dp1[0][j]);
            min = Math.min(min, dp2[0][j]);
        }
        bufferedWriter.write(max + " " + min);
    }


    public static void main(String[] args) throws IOException {
        input();
        bufferedReader.close();
        bufferedWriter.close();
    }
}

백준 12852번 : 1로 만들기 2 풀이 (Java)

심정욱 — Thu, 11 Mar 2021 18:48:08 +0900

www.acmicpc.net/problem/12852

12852번: 1로 만들기 2

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

www.acmicpc.net

6의 배수를 조심하자

Solution

1. 이 문제는 다이나믹 프로그래밍, DP 로 풀어야 하는 문제이다. 최대 인풋이 10의 6승이고, 그렇기에 최대 O(n) 으로 풀어야 할 것이다.

2. N 을 1로 만드는 것이라서 top-down 방식으로 풀까 하다가 웬지 어려울 것 같아서 bottom-up 으로 풀었는데, 출력을 위해서 반복문을 한번 더 돌려야했다. 푼 뒤에 top-down 을 시도해봤는데 이 편이 더 어려운 것 같다..

3. N+1 크기의 dp 배열을 만들고, dp[i] 에는 i 를 1로 만드는 데 필요한 연산 횟수를 담는다. dp[1] = 0, dp[2] = 1 일 것이다.

4. 이제, 우리가 할 수 있는 세 가지 연산을 했을 때의 횟수 를 구해줘야 하는데, 이는

1을 빼주는 경우 : 1을 빼주는 연산 횟수 ( 1 ) + (i - 1) 을 1로 만드는 데 필요한 연산 횟수( dp[i-1] )

2로 나눠주는 경우 : 2로 나눠주는 연산 횟수 ( 1 ) + (i / 2) 를 1로 만드는 데 필요한 연산 횟수 (dp[i / 2])

3으로 나눠주는 경우 : 3으로 나눠주는 연산 횟수 ( 1 ) + (i / 3) 를 1로 만드는 데 필요한 연산 횟수 (dp[i / 3])

이다. 이 셋을 비교해주면서 최소인 것들을 담아주면서 dp 배열을 완성시켜준다. 이후, N 이 1이 될 때까지 다시 같은 연산을 해주면서 최소의 경우들을 찾고, 해당하는 수들을 bufferedWriter 에 써주면 그 동안의 기록들이 완성된다.

Source Code

import java.io.*;
import java.util.Arrays;

public class Main {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));

    static void solve() throws IOException{
        int N = Integer.parseInt(bufferedReader.readLine());
        if(N == 1) {
            System.out.println(0);
            System.out.println(1);
            return;
        }
        int[] dp = new int[N+1];
        dp[N] = 0;
        dp[1] = 0;
        dp[2] = 1;
        int i = 3;
        while(i <= N) {
            int minusOneResult = dp[i-1] + 1;
            int divByThreeResult = Math.min(minusOneResult, dp[i/3] + 1);
            int divByTwoResult = Math.min(minusOneResult, dp[i/2] + 1);
            if(i % 3 == 0) {
                if(i % 2 == 0) {
                    dp[i] = Math.min(divByThreeResult,divByTwoResult );
                }
                else {
                    dp[i] = divByThreeResult;
                }
            }
            else if(i % 2 == 0) {
                dp[i] = divByTwoResult;
            } else {
                dp[i] = minusOneResult;
            }
            i++;
        }
        int n = N;
        bufferedWriter.write(dp[N] + "\n");
        bufferedWriter.write(N + " ");
        while(n > 1) {
            if(n % 3 == 0 && dp[n / 3] + 1 < dp[n-1] + 1) {
                n /= 3;
                bufferedWriter.write(n + " ");
            } else if(n % 2 == 0 && dp[n / 2] + 1 < dp[n-1] + 1) {
                n /= 2;
                bufferedWriter.write(n + " ");
            } else {
               n -= 1;
               bufferedWriter.write(n + " ");
            }
        }


    }

    public static void main(String[] args) throws IOException {
        solve();
        bufferedWriter.close();
        bufferedReader.close();
    }
}

백준 2003 번 : 수들의 합 2 풀이 (Java)

심정욱 — Wed, 10 Mar 2021 13:03:54 +0900

www.acmicpc.net/problem/2003

2003번: 수들의 합 2

첫째 줄에 N(1 ≤ N ≤ 10,000), M(1 ≤ M ≤ 300,000,000)이 주어진다. 다음 줄에는 A[1], A[2], …, A[N]이 공백으로 분리되어 주어진다. 각각의 A[x]는 30,000을 넘지 않는 자연수이다.

www.acmicpc.net

Key Point

이 문제를 2중 for문을 이용해 완전 탐색으로 돌리면 시간 초과가 날 것이라 짐작했다. N의 범위가 1에서 10000까지인데, 10000 * 10000 의 연산을 0.5초의 시간 제한에서 할 수 있을리가.

이 문제는 투 포인터 알고리즘 문제이다. 투포인터 알고리즘이란,

1차원 배열에서 두 개의 포인터를 조작하여 원하는 결과를 얻는 알고리즘 이다.

구간의 합을 구하는 시작점을 start 로, 끝 점을 end 로 둔다. (start <= end)

그 뒤, 목표하는 값보다 구간합이 작으면 end 위치의 값을 더해주고, end 를 증가시켜주면서 값을 키워간다.

그러다가 구간합이 목표값보다 커지면, 이번에는 기존 start 위치의 값을 빼주고, start 를 증가시켜주며, 범위와 값을 같이 줄여나간다.

그 점만 잘 알고나서 보면 쉬운 문제인데, 구현을 좀 잘못하면 저렇게 틀릴 수 있다. 나의 경우는 인덱스 문제였다.

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static int N,M;
    static int[] arr;

    static void input() throws IOException {
        StringTokenizer nm = new StringTokenizer(bufferedReader.readLine());
        N = Integer.parseInt(nm.nextToken());
        M = Integer.parseInt(nm.nextToken());
        arr = new int[N+1];
        StringTokenizer line = new StringTokenizer(bufferedReader.readLine());
        for(int i = 0; i < N; i++) {
            arr[i] = Integer.parseInt(line.nextToken());
        }
    }

    static void solve() {
        if(N == 1 && arr[0] == M) {
            System.out.println(1);
            return;
        }
        // 1 1
        // 1
        // 의 반례를 잡기 위해서 넣었다.
        int ans = 0, start = 0, end = 0, sum = 0;
        while(end <= N) { // end 가 배열 범위를 초과하면 break해준다.
            if(sum >= M) {
                sum -= arr[start++];
                // 2. 구간합이 목표값 보다 크거나 같으면, sum -= arr[start];
                // start += 1;
            } else if(sum < M) {
                sum += arr[end++]; 
                // 1. 구간합이 목표값 보다 작으면, sum += arr[end];
                // end += 1;
            }
            if(sum == M){
                ans++;
            }
        }
        System.out.println(ans);
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
        bufferedReader.close();
    }
}

백준 14502번 : 연구소 풀이 (Java)

심정욱 — Tue, 9 Mar 2021 23:13:12 +0900

www.acmicpc.net/problem/14502

14502번: 연구소

인체에 치명적인 바이러스를 연구하던 연구소에서 바이러스가 유출되었다. 다행히 바이러스는 아직 퍼지지 않았고, 바이러스의 확산을 막기 위해서 연구소에 벽을 세우려고 한다. 연구소는 크

www.acmicpc.net

생각을 너무 오래했다.

Key Point

벽 부수고 이동하기(simju9397.tistory.com/11) 문제를 풀고 나서 보고 나니 오히려 혼동이 생겨 고민을 굉장히 오래 했다. 이 문제의 핵심은 그냥..

1. 빈 공간들과 바이러스들을 각각의 ArrayList에 담는다.

2. 빈 공간들 중에서 벽으로 만들 3개의 공간을 선택한다. 그렇다. 조합과 완전탐색 문제이다.

3. 조합을 만들었다면, 첫 바이러스들의 위치를 담은 ArrayList를 기반으로 Queue 를 만든 뒤에, BFS를 돌려준다.

4. 탐색 하면서 감염되는 공간들은 0에서 2로 바꿔준다.

5. 탐색이 끝난 후, 여전히 0인 '안전 공간'들의 갯수를 세어 정답에 담아 놓은 값과 비교해 큰 값을 정답으로 담는다.

3 <= N,M <= 8 이라는, 굉장히 작은 범위이기 때문에 이렇게 풀어도 풀린다. 나는 이전 문제와 비교해 겁을 먹고, 3개니까 3차원 배열을 visited[N][M][4]; 이런 식으로 만들어줘야 하나 싶어서 한시간 넘게 날렸다.

앞으로는 input의 범위를 보고, 작은 것은 무조건 완전 탐색부터 생각하는 습관을 들여야겠다. 완전 탐색은 모든 알고리즘의 기본이고 제일 쉬우니까 말이다.

Source Code

import java.io.*;
import java.util.*;

public class Main {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static int N,M, ans = Integer.MIN_VALUE;
    static int[][] map;
    static ArrayList<Node> viruses; // 초기 바이러스의 위치
    static ArrayList<Node> safes; // 안전 장소들의 위치
    static int[] dx = {-1,1,0,0};
    static int[] dy = {0,0,-1,1};

    static class Node {
        int x;
        int y;

        public Node(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    static void input() throws IOException {
        StringTokenizer nm = new StringTokenizer(bufferedReader.readLine());
        N = Integer.parseInt(nm.nextToken());
        M = Integer.parseInt(nm.nextToken());
        map = new int[N][M];
        viruses = new ArrayList<>();
        safes = new ArrayList<>();
        for(int i = 0 ; i < N; i++) {
            StringTokenizer st = new StringTokenizer(bufferedReader.readLine());
            for(int j = 0;j < M; j++) {
                map[i][j] = Integer.parseInt(st.nextToken());
                if(map[i][j] == 2) {
                    viruses.add(new Node(i, j)); // 각각
                } else if(map[i][j] == 0) {
                    safes.add(new Node(i, j)); // 담아준다
                }
            }
        }
    }

    private static void makeCombination(int cnt, int start ,int[] arr) {
        if(cnt == 3) {
            int[][] newMap = new int[N][M];
            for(int i = 0 ; i < N; i++) {
                newMap[i] = map[i].clone(); 
                // 이거 중요한 부분인데, 2차원 배열을 복사하는 것이기 때문에
                // 반복문을 돌면서 한 열씩 복사해줘야 한다!!!
            }
            for(int i = 0; i < 3; i++) {
                Node n = safes.get(arr[i]); // 뽑은 인덱스들을 반복문을 돌면서 Node 를 가져온 뒤
                newMap[n.x][n.y] = 1; // 뽑힌 노드들을 벽으로 만들어서
            }
            bfs(new boolean[N][M], newMap); // bfs 에 던져준다.
            return;
        }
        for(int i = start; i < safes.size() ; i++) {
            arr[cnt] = i; // 0~safes.size()-1 의 범위에서 인덱스 3개를 조합으로 뽑는다.
            makeCombination(cnt+1, i+1, arr);
        }
    }


    static void bfs(boolean[][] visited, int[][] map) {
        Queue<Node> queue = new LinkedList<>(viruses); // 초기 바이러스의 위치들을 담아준다.
        // 한 번에 담아야 여러 바이러스 들이 같이 확산을 시작할 것이다.
        while (!queue.isEmpty()) {
            Node start = queue.poll();
            int sx = start.x;
            int sy = start.y;
            visited[sx][sy] = true;
            for(int i = 0 ; i < 4; i++) {
                int nx = sx + dx[i];
                int ny = sy + dy[i];
                if(nx < 0 || ny < 0 || nx >= N || ny >= M) continue;
                if(visited[nx][ny] || map[nx][ny] != 0) continue;
                // 방문했거나, 0이 아닌 경우는 넘겨준다(이미 확산됐거나(2), 벽이거나(1) )
                visited[nx][ny] =true;
                queue.add(new Node(nx, ny));
                map[nx][ny] = 2; // 방문한 지점은 확산된 것이므로 2로 바꿔준다.
            }
        }
        int count = 0;
        for(int i = 0 ; i < N; i++) {
            for(int j = 0 ; j < M; j++) {
                if(map[i][j] == 0) { // 이후 2차원 배열을 돌면서 안전 지점의 갯수를 세준다.
                    count++;
                }
            }
        }
        ans = Math.max(ans, count);
    }

    static void solve() {
        makeCombination(0,0,new int[3]);
        System.out.println(ans);
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
        bufferedReader.close();
    }
}

백준 2206번 : 벽 부수고 이동하기 풀이(Java)

심정욱 — Tue, 9 Mar 2021 08:53:38 +0900

www.acmicpc.net/problem/2206

2206번: 벽 부수고 이동하기

N×M의 행렬로 표현되는 맵이 있다. 맵에서 0은 이동할 수 있는 곳을 나타내고, 1은 이동할 수 없는 벽이 있는 곳을 나타낸다. 당신은 (1, 1)에서 (N, M)의 위치까지 이동하려 하는데, 이때 최단 경로

www.acmicpc.net

모든 틀림을 다 겪었다

Key Point

1. 나는 처음 접근할 때 1000*1000 인줄 모르고 벽을 부술 때 마다 BFS를 다시 돌리는 것으로 생각했다. 당연히 시간초과로 털렸다.

2. 이 문제에서 가장 중요한 것은 무조건 한번의 BFS 내에서 해결해야 한다는 것이다. 위와 동일한 얘기지만, 이 점이 굉장히 어려웠다.

3. 질문 검색을 조금 보고나서 기존의 visited 배열을 2차원에서 3차원으로 확장해야 한다는 것을 알았다.

이 문제는 벽을 단 한번 부술 수 있으므로,

visited[x][y][0](벽을 아직 안 부순 경우) 과 visited[x][y][1] ( 벽을 부수고 온 경우 ) 로 나뉘어 생각해야 한다.

벽을 여러 번 부술 수 있다면 3차원 을 그 횟수에 맞춰 확장해야 하지 않을까 싶은데, 나중에 풀어봐야 겠다.

4. 또한, 큐를 돌면서 도착 지점에 도착했다고 바로 리턴해서 끝내 버리면 안 된다. 반드시 큐가 완전히 빌 때까지 다 돌면서 "최단" 거리를 찾아야 한다.

Solution

1. (0,0) 에서 시작하고, (0,0) 은 무조건 벽이 없으므로 visitied[0][0][0] = true; 로 방문 체크를 해준다.

2. 큐에 (0,0) 노드를 담아준다. 이 때 거리를 나타내는 depth 는 1부터 시작임을 잊지 말자.

3. 이 후 늘 하던 BFS 처럼 상하좌우를 순회한다.

if(sx == N-1 && sy == M-1) {
  ans = Math.min(ans, sd);
  continue;
}

Key Point 에서 언급한 4번을 담당하는 코드이다. 도착 했다고 바로 끝내면 안 된다!!

5. 배열의 범위를 벗어나는 다음 지점들은 continue로 넘겨준다.

if(visited[sx][sy][0]) {
    if(visited[nx][ny][0]) continue;
    if(map[nx][ny] == 1) {
      visited[nx][ny][1] = true;
    } else {
      visited[nx][ny][0] = true;
  }
} else if(visited[sx][sy][1]) {
    if(visited[nx][ny][1]) continue;
    if(map[nx][ny] == 1) {
      continue;
    } else {
      visited[nx][ny][1] = true;
    }
}

여기서 분기가 갈린다. 시작 지점인 sx, sy 에서 만약에 0번, 즉 벽을 안 부수고 지나온 경우가 true 일 경우에,

벽을 부수지 않은 채로 다음 지점에 가는 경우가 이미 방문한 경우라면 넘겨준다. 안 해주면 당연히 무한 루프가 돌 것이다.

만약 다음 지점에 벽이 있다면,

다음 지점의 1번을 true로 , 즉 다음 지점 부터는 벽을 부순 경우로 생각하라고 남겨주는 것이다.

벽이 없다면, 다음 지점의 0번을 true로 해서 다음 지점에서도 벽을 부수지 않은 경우로 생각하라고 남겨준다.

반대로, 시작 지점에서 벽을 부수고 지나온 경우가 true일 경우,

벽을 부순 채로 다음 지점에 가는 경우가 이미 방문한 경우라면 넘겨준다. 마찬가지로 무한 루프 방지.

만약 다음 지점에 벽이 있다면, 이미 한 번 부쉈으므로 그 지점에 갈 수 없다. 넘겨준다.

벽이 없다면, 벽을 부쉈다는 것을 기록하기 위해 visited[nx][ny][1] = true 로 기록을 남겨준다.

이후 하던 것 처럼 기존 거리 + 1 을 큐에 기록해준다.

전체 코드

package boj.BFS_DFS;
import java.io.*;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main_벽부수고이동하기_2206 {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static int N,M, ans = Integer.MAX_VALUE;
    static int[][] map;
    static int[] dx = {-1,1,0,0};
    static int[] dy = {0,0,-1,1};

    static class Node {
        int x;
        int y;
        int depth;

        public Node(int x, int y, int depth) {
            this.x = x;
            this.y = y;
            this.depth = depth;
        }
    }

    static void input() throws IOException {
        StringTokenizer nm = new StringTokenizer(bufferedReader.readLine());
        N = Integer.parseInt(nm.nextToken());
        M = Integer.parseInt(nm.nextToken());
        map = new int[N][M];
        for(int i = 0 ; i < N; i++) {
            char[] line = bufferedReader.readLine().toCharArray();
            for(int j = 0; j < M; j++) {
                map[i][j] = Integer.parseInt(Character.toString(line[j]));
            }
        }
    }

    static void bfs(boolean[][][] visited) {
        Queue<Node> queue = new LinkedList<>();
        visited[0][0][0] = true; 
        queue.add(new Node(0,0,1));
        while (!queue.isEmpty()) {
            Node start = queue.poll();
            int sx = start.x;
            int sy = start.y;
            int sd = start.depth;
            if(sx == N-1 && sy == M-1) {
                ans = Math.min(ans, sd);
                continue;
            }
            for(int i = 0 ; i < 4; i++) {
                int nx = sx + dx[i];
                int ny = sy + dy[i];
                if(nx < 0 || ny < 0 || nx >= N || ny >= M) continue;
                if(visited[sx][sy][0]) {
                    if(visited[nx][ny][0]) continue;
                    if(map[nx][ny] == 1) {
                        visited[nx][ny][1] = true;
                    } else {
                        visited[nx][ny][0] = true;
                    }
                } else if(visited[sx][sy][1]) {
                    if(visited[nx][ny][1]) continue;
                    if(map[nx][ny] == 1) {
                        continue;
                    } else {
                        visited[nx][ny][1] = true;
                    }
                }
                queue.add(new Node(nx, ny, sd+1));
            }
        }
    }

    static void solve() {
        bfs(new boolean[N][M][2]);
        if(ans == Integer.MAX_VALUE) {
            System.out.println(-1);
        } else {
            System.out.println(ans);
        }
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
        bufferedReader.close();
    }
}

백준 6416 : 트리인가 풀이 (Java)

심정욱 — Tue, 9 Mar 2021 00:02:38 +0900

www.acmicpc.net/problem/6416

6416번: 트리인가?

트리는 굉장히 잘 알려진 자료 구조이다. 트리를 만족하는 자료 구조는 비어 있거나(노드의 개수가 0개), 노드의 개수가 1개 이상이고 방향 간선이 존재하며 다음과 같은 조건을 만족해야 한다.

www.acmicpc.net

울화통의 흔적

참고한 코드

velog.io/@pss407/%EB%B0%B1%EC%A4%806416-%ED%8A%B8%EB%A6%AC%EC%9D%B8%EA%B0%80

[백준]#6416 트리인가?

문제트리는 굉장히 잘 알려진 자료 구조이다. 트리를 만족하는 자료 구조는 비어 있거나(노드의 개수가 0개), 노드의 개수가 1개 이상이고 방향 간선이 존재하며 다음과 같은 조건을 만족해야 한

velog.io

Key Point

0. 먼저, 이 문제는 결국 내 힘으로 풀지 못했다. 풀이법에서는 틀린 게 없는 것 같은데, 아직 Java 가 익숙하지 않아서 코드를 잘못 짠 것인지 모르겠는데 질문 검색 에서의 케이스들도 다 맞아서 반례를 못 찾았다 결국...

1. 이 문제의 핵심은,

"루트가 하나인지", "정점 갯수 - 간선 갯수 == 1인지", "들어오는 간선의 갯수가 2개 이상인 노드가 있는지"

이다.

2. 정점이 순서대로 들어오지 않으므로, HashSet 을 이용해서 중복을 제거하면서 넣으면 그것이 정점이 된다.

3. 이건 세세한 건데, 문장의 마지막에 점 찍는 거 잊지 말자.

소스코드

import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        HashSet<Integer> set;
        int[] cnt; // idx : 노드 번호 value : 들어오는 간선 의 갯수
        int tc = 0;
        int root;
        boolean hasTwoMoreIncomeVector;
        int v; // 간선의 갯수

        while(true) {
            set = new HashSet<>();
            cnt = new int[1001];
            root = 0;
            tc++;
            hasTwoMoreIncomeVector = false;
            v = 0;

            while(true) {
                int a = sc.nextInt();
                int b = sc.nextInt();

                if (a == 0 && b == 0) break;
                if (a == -1 && b == -1) return;

                set.add(a);
                set.add(b);
                cnt[b]++;
                v++;
            }
            if(set.size()==0) {
                System.out.println("Case "+ tc +" is a tree."); // 아무 것도 없는 트리도 트리임.
                continue;
            }

            Iterator iter = set.iterator();
            while(iter.hasNext()) {
                int num = (int)iter.next();
                if(cnt[num]==0) root++; // 들어오는 간선의 갯수가 0인 경우 root
                if(cnt[num]>1) {
                    hasTwoMoreIncomeVector = true; // 들어오는 간선의 갯수가 2개 이상인 노드가 있는 경우
                    break;
                }
            }

            if(hasTwoMoreIncomeVector || root!=1 || set.size()-v!=1) // 들어오는 간선의 갯수가 2개 이상 or 루트 노드가 유일하지 않음 or 노드의 개수 - 간선의 개수 가 1이 아님
                System.out.println("Case "+ tc +" is not a tree.");

            else
                System.out.println("Case "+ tc +" is a tree.");
        }
    }
}

백준 11660 번 : 구간 합 구하기 5 (Java)

심정욱 — Sat, 6 Mar 2021 12:55:08 +0900

www.acmicpc.net/problem/11660

11660번: 구간 합 구하기 5

첫째 줄에 표의 크기 N과 합을 구해야 하는 횟수 M이 주어진다. (1 ≤ N ≤ 1024, 1 ≤ M ≤ 100,000) 둘째 줄부터 N개의 줄에는 표에 채워져 있는 수가 1행부터 차례대로 주어진다. 다음 M개의 줄에는 네

www.acmicpc.net

Key Point

1. (x1,y1) 부터 (x2, y2) 까지의 구역의 합을 구하는 문제이다.

2. 2차원 배열 dp에 1,1 부터 (x,y) 까지의 합을 기억해놓는다.

1 2 3 4

2 3 4 5

인 경우, dp 는

1 3 6 10

3 7 14 24

이다.

3. x1 <= x2이고 y1 <= y2 이므로, (x1,y1) 부터 (x2,y2) 까지의 합은,

1,1에서 x2,y2 까지의 합(큰 사각형) 빼기

1,1에서 x1,y2 까지의 합 빼기

1,1에서 x2,y1 까지의 합 더하기

1,1에서 x1,y1 까지의 합이다. (이 부분은 두번 마이너스 됐기 때문이다.)

이것만 알면 구현은 쉽다.

소스코드

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static int N, M;
    static int[][] map, dp;
    static Op[] ops;

    static class Op {
        int x1;
        int y1;
        int x2;
        int y2;

        public Op(int x1, int y1, int x2, int y2) {
            this.x1 = x1;
            this.y1 = y1;
            this.x2 = x2;
            this.y2 = y2;
        }
    }

    static void input() throws IOException {
        StringTokenizer nm = new StringTokenizer(bufferedReader.readLine());
        N = Integer.parseInt(nm.nextToken());
        M = Integer.parseInt(nm.nextToken());
        map = new int[N+1][N+1];
        dp = new int[N+1][N+1];
        ops = new Op[M];
        for(int i = 1 ; i <= N; i++) {
            StringTokenizer st = new StringTokenizer(bufferedReader.readLine());
            for(int j = 1 ; j <= N; j++) {
                map[i][j] = Integer.parseInt(st.nextToken());
            }
        }
        for(int i = 1; i <= N; i++) {
            for(int j = 1; j <= N; j++) {
                dp[i][j] = dp[i-1][j] + dp[i][j-1] - dp[i-1][j-1] + map[i][j];
                //x1,y1 부터 x2,y2 까지의 합을 구하는 로직과 동일하게 dp를 구한다.
            }
        }
        for (int i = 0; i < M; i++) {
            StringTokenizer st = new StringTokenizer(bufferedReader.readLine());
            ops[i] = new Op(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
        }
    }

    static void solve() {
        for(int i = 0 ; i < M; i++) {
            Op op = ops[i];
            System.out.println(dp[op.x2][op.y2] - dp[op.x2][op.y1-1] - dp[op.x1-1][op.y2] + dp[op.x1-1][op.y1-1]);
        }
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
        bufferedReader.close();
    }
}

백준 2636번 : 치즈 풀이(Java)

심정욱 — Thu, 4 Mar 2021 22:51:25 +0900

www.acmicpc.net/problem/2636

2636번: 치즈

아래 <그림 1>과 같이 정사각형 칸들로 이루어진 사각형 모양의 판이 있고, 그 위에 얇은 치즈(회색으로 표시된 부분)가 놓여 있다. 판의 가장자리(<그림 1>에서 네모 칸에 X친 부분)에는 치즈가 놓

www.acmicpc.net

바로 AC가 나와서 기분이 좋았다 ㅎ

BFS 로 풀 수 있는 문제이다.

Key Point

1. 현재 치즈들의 위치를 arraylist에 담아주고, 모든 치즈들에 대해 영역 바깥으로 갈 수 있는지를 체크해준다. 만약 bfs 로 탐색하면서, 이미 방문한 곳이거나, 그 위치에 치즈가 있다면 그 지점은 바깥에 닿지 않는, 즉 그 시간 대에서는 공기 중으로 사라지지 않는 안전한 치즈이다.

2. 중요 : 치즈들을 돌면서 map의 바깥에 갈 수 있다면, 즉 사라져야 하는 치즈라고 바로 삭제시켜서는 안된다. 바로 삭제시켜버리면 그 치즈에 의해 보호받던 안쪽의 치즈들까지 원치 않게 사라져버릴 것이기 때문이다. 나의 경우는 삭제시켜야 하는 치즈들과 그렇지 않은 치즈들의 ArrayList를 만들어서, 그렇지 않은 치즈들, 즉 생존한 치즈들이 남지 않을 때 까지 while 문으로 돌려주었다.

3. 내가 실수했던 부분인데,

11111

11011

11111

이 있다면, 중간의 0과 맞닿는 부분들이 삭제 되어서는 안된다. 1번과 같은 맥락이다. 내부의 공기는 아무 상관 없으므로, 반드시 bfs 를 돌면서 map 의 바깥으로 갈 수 있는 것들이 삭제되어야 한다.

위의 두 가지를 감안하면 쉬운 문제이다. 골드 치고 굉장히 빨리 푼 것 같다.

import java.io.*;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static int R,C;
    static int[][] map;
    static int[] dx = {-1,1,0,0};
    static int[] dy = {0,0,-1,1};
    static ArrayList<Node> cheeses;

    static class Node {
        int x;
        int y;

        public Node(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }


    static void input() throws IOException {
        StringTokenizer rc = new StringTokenizer(bufferedReader.readLine());
        R = Integer.parseInt(rc.nextToken());
        C = Integer.parseInt(rc.nextToken());
        map = new int[R][C];
        cheeses = new ArrayList<>();
        for(int i = 0; i < R; i++) {
            StringTokenizer st = new StringTokenizer(bufferedReader.readLine());
            for(int j = 0; j < C; j++) {
                map[i][j] = Integer.parseInt(st.nextToken());
                if(map[i][j] == 1) {
                    cheeses.add(new Node(i, j));
                }
            }
        }
    }

    static boolean bfs(Node start, boolean[][] visited) {
        Queue<Node> queue = new LinkedList<>();
        queue.add(start);
        while(!queue.isEmpty()) {
            Node s = queue.poll();
            int x = s.x;
            int y = s.y;
            visited[x][y] = true;
            for(int i = 0 ; i < 4; i++) {
                int nx = x + dx[i];
                int ny = y + dy[i];
                if(nx < 0 || ny < 0 || nx >= R || ny >= C) {
                    return true;
                }
                if(visited[nx][ny] || map[nx][ny] >= 1) continue;
                queue.add(new Node(nx, ny));
                visited[nx][ny] = true;
            }
        }
        return false;
    }

    static void printMap() {
        for(int i = 0; i < R; i++) {
            for(int j = 0; j < C; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }

    static void solve() {
        int count = 0;
        int time = 0;
        while (!cheeses.isEmpty()) {
            ArrayList<Node> newCheeses = new ArrayList<>();
            ArrayList<Node> deleteCheeses = new ArrayList<>();
            for(Node cheese : cheeses) {
                if(!bfs(cheese, new boolean[R][C])) {
                    newCheeses.add(cheese);
                } else {
                    deleteCheeses.add(cheese);
                }
            }
            for(Node cheese : deleteCheeses) {
                map[cheese.x][cheese.y] = 0;
            }
            count = cheeses.size();
            cheeses = newCheeses;
            time++;
//            printMap();
//            System.out.println("=================");
        }
        System.out.println(time);
        System.out.println(count);
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
        bufferedReader.close();
    }
}

백준 3190 번 : 뱀 풀이(Java)

심정욱 — Wed, 3 Mar 2021 23:10:21 +0900

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

3190번: 뱀

'Dummy' 라는 도스게임이 있다. 이 게임에는 뱀이 나와서 기어다니는데, 사과를 먹으면 뱀 길이가 늘어난다. 뱀이 이리저리 기어다니다가 벽 또는 자기자신의 몸과 부딪히면 게임이 끝난다. 게임

www.acmicpc.net

시간이 이것보단 길게 나올 줄 알았는데 의외였다.

Key Point

1. 뱀의 머리는 기본적으로 정해진 방향대로 이동한다.

2. 사과를 먹었을 때는 꼬리를 고정해두고, 먹지 못했다면 꼬리를 머리 쪽으로 당겨야 한다.

3. 이게 중요한데, 사과를 먹었다면 먹은 걸로 처리를 해줘야한다. (안 해주면 23% 에서 틀리는 것 같다.)

해법

뱀의 상태, 즉 뱀이 차지하고 있는 칸들을 Deque 에 담아 준다. front 와 rear 모두 삽입과 삭제가 가능한 만큼 최적의 자료구조일 것이다. 뱀의 상태를 나타낼 생각을 안하고, 뱀이 방향을 꺾을 때 마다 관절 부분들을 덱에 넣는 방식을 채택했다가 시간을 많이 잡아먹었다. 역시 아직도 많이 부족함을 느낀다.

1. 입력을 받는다. (받으면서 사과는 map에 다르게 표시를 해준다)

1-1. 뱀의 상태를 나타내는 snake 덱에 시작 위치인 (0,0) 의 Node 를 담는다.

2. 무한 루프를 돌면서

2-1. 뱀의 머리의 다음 위치는 현재 뱀 머리의 위치에, 뱀이 바라보고 있는 방향이다.

int hx = head.x;
int hy = head.y;
checkChangeDir();
int nx = hx + dx[snakeDir];
int ny = hy + dy[snakeDir];

다음 위치를 바라보기 전에, 방향을 바꿔야 하는지 체크하고 필요하다면 바꿔준 뒤에 이동한다.

2-2. 만약에 다음 위치가 map 을 벗어나거나, 자신의 몸 부분이라면 break 해준다.

2-2-1. 만약 둘 다 아니라서 이동이 가능한 경우, 머리는 어차피 이동 하므로 다음 위치를 snake 의 rear 에 추가해준다.

2-2-1-1 . 다음 위치가 사과일 경우, 다음 위치는 사과를 먹은 후의 상태로 초기화를 해준다.

2-2-1.2 . 다음 위치가 사과가 아닐 경우, 기존의 꼬리를 떼준다.

전체 코드

import java.io.*;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.StringTokenizer;

public class Main {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static int N,K,L, snakeDir, count;
    static short[][] map;
    static Deque<Node> snake;
    static Deque<Movement> movements;
    static int[] dx = {-1,0,1,0};
    static int[] dy = {0,1,0,-1}; // 상, 우, 하, 좌

    static class Node {
        int x;
        int y;

        public Node(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    static class Movement {
        int time;
        char dir;

        public Movement(int time, char dir) {
            this.time = time;
            this.dir = dir;
        }
    }

    static void input() throws IOException {
        N = Integer.parseInt(bufferedReader.readLine());
        K = Integer.parseInt(bufferedReader.readLine());
        map = new short[N][N];
        movements = new ArrayDeque<>();
        snake = new ArrayDeque<>();
        snake.addLast(new Node(0,0));
        count = 0;
        snakeDir = 1; // 오른쪽 방향을 보고 시작
        for(int i = 0; i < K; i++) {
            StringTokenizer xy = new StringTokenizer(bufferedReader.readLine());
            int x = Integer.parseInt(xy.nextToken()) - 1;
            int y = Integer.parseInt(xy.nextToken()) - 1; // input 이 1,1 부터 시작하는 기준이라서 1씩 빼준다.
            map[x][y] = 1;
        }
        L = Integer.parseInt(bufferedReader.readLine());
        for (int i = 0; i < L; i++) {
            StringTokenizer st = new StringTokenizer(bufferedReader.readLine());
            movements.offer(new Movement(Integer.parseInt(st.nextToken()),  st.nextToken().charAt(0)));
        }
    }

    static boolean isOut(int nx, int ny) {
        if(nx < 0 || ny < 0 || nx >= N || ny >= N) {
            return true;
        }
        return false;
    }

    static boolean isSelfBody(int nx, int ny) {
        for(Node n : snake) {
            if(n.x == nx && n.y == ny) {
                return true;
            }
        }
        return false;
    }

    static void checkChangeDir() {
        if(!movements.isEmpty() && movements.peekFirst().time + 1 == count) {
            Movement m = movements.pollFirst();
            if(m.dir == 'D') {
                snakeDir = (snakeDir + 1) % 4;
            } else {
                if(snakeDir == 0) {
                    snakeDir = 3;
                } else {
                    snakeDir -= 1;
                }
            }
        }
    }

    static boolean isApple(int nx, int ny) {
        return map[nx][ny] == 1;
    }

    static void solve() {
        while (true) {
            ++count;
            Node head = snake.peekLast();
            Node tail = snake.peekFirst();
            int hx = head.x;
            int hy = head.y;
            checkChangeDir();
            int nx = hx + dx[snakeDir];
            int ny = hy + dy[snakeDir];
            if(isOut(nx, ny) || isSelfBody(nx, ny)) {
                break;
            }
            snake.addLast(new Node(nx, ny));
            if(!isApple(nx, ny)) {
                snake.pollFirst();
            } else {
                map[nx][ny] = 0;
            }
        }
        System.out.println(count);
    }

    public static void main(String[] args) throws IOException {
        input();
        solve();
        bufferedReader.close();
    }
}

이건 보고 HTML 짜자! 깔끔한 HTML을 만들기 위한 HTML 코드 컨벤션

심정욱 — Wed, 3 Mar 2021 09:52:36 +0900

HTML 코드 작성 규칙

대전제

DTD를 제외한 모든 요소와 애트리뷰트는 소문자로 작성합니다.

<pre>Good!</pre>
<PRE>Bad..</PRE>

애트리뷰트 값은 큰 따옴표로 묶습니다.

<div id="good"></div>
<div id='BAD'></div>

아이디와 클래스의 속성 값은 숫자, 대문자, 특수문자로 시작할 수 없습니다.
애트리뷰트의 속성의 값은 숫자, 특수문자로 시작할 수 없으며, 대문자로는 시작할 수 있습니다.

아이디, 클래스

아이디는 소문자 카멜 표기법 을 사용합니다. 스타일 지정을 위해 사용하지 않으며, DOM 조작을 위해 사용해야 합니다.

주의 : 숫자, 대문자, 특수문자로 시작할 수 없습니다.

<div id="headerMenu">
  ...
</div>

<div id="layerPop-1">
 ...
</div>

클래스는 아이디와 시각적 구분을 위해 하이픈 표기법 을 사용합니다.

<div class="slide-label n-3 back-swiper">
  <div class="swiper-wrapper">
    ...
  </div>
</div>

들여쓰기(indent)

body 태그 안의 모든 요소는 중첩의 깊이에 따라 1탭 들여 씁니다. 1탭의 크기는 공백 2칸입니다.(vscode 내에서 설정할 수도 있습니다.)

<body class="">
  <div class="ly-wrapper">
    <div class="ly-total-menu">
    ...
</div>

빈 줄

그룹 되어있는 태그들을 구분하기 위하여 코드 간 1 줄의 빈 줄을 사용하는 경우가 있지만, 이 경우 주석 사용을 권장하며 빈 줄을 사용하지 않습니다.

<!-- bad -->
<div class="section-login">

  <div class="login-before">
  ...
</div>

주석

주석 기호와 내용 사이에는 반드시 공백이 한 칸 있어야 합니다. 시작 주석과 끝 주석 모두 작성하는 것을 권장합니다.

<!-- 2016.07.20 고객권리안내문 추가 -->
<ul class="policy">
  <li><a href="#none">이용약관</a></li>
  <li><a href="#none">개인정보처리방침</a></li>
  <li><a href="#none">고객권리안내문</a></li>
  <li><a href="#none">전자금융거래표준약관</a></li>
</ul>
<!--// 2016.07.20 객권리안내문 추가 -->

공백 및 종료태그

태그 명과 애트리뷰트, 애트리뷰트와 애트리뷰트 사이에 한 개의 공백이 필요하며 한 개 이상의 공백은 사용하지 않습니다.
HTML5를 사용한다면 닫는 기호를 생략해서 문서를 작성하고 XHTML을 사용한 경우는 닫는 기호를 반드시 사용합니다.

HTML5 가 아닌 경우, 종료 태그가 없는 태그의 닫는 규칙 앞에도 한 개의 공백이 필요합니다.

<label for="checkboxA-1" class="label">체크 레이블</label>
<input type="checkbox" name="CA-1" id="checkboxA-1" class="checkbox">

// Doctypes XHTML일 경우 종료 태그 앞에도 한 개의 공백이 들어갑니다.
<img src="/img/logo.png" alt="logo" />

// HTML
<input type="text">

// XHTML
<input type="text" />

종료 태그가 없는 요소들

area,base, br, col, commend, embed, hr, img, input, keygen, link, meta, param, source

DOCTYPE

보통 DTD라고 표현을 하며, HTML 문서를 작성할 때 가장 먼저 선언하게 됩니다. HTML5를 기본적으로 사용합니다.

스타일 선언

CSS는 외부 파일에 작성해 사용합니다. 이러한 작업 방식을 External Type 방식이라 명칭합니다.

/*  External Type  */
<link rel="stylesheet" href="css/normalize.css">
<link rel="stylesheet" href="css/main.css">

자바스크립트 선언

웹 브라우저가 렌더링을 마치기 전에 자바스크립트로 어떠한 동작을 실행해야 한다면 요소 안에 스크립트를 선언합니다.
이런 상황이 아니라면 태그 앞에 자바스크립트를 작성하는 것이 성능적인 측면에서 좋습니다.

// 브라우저가 랜더링을 마치기 전에 실행할 파일을 선언한다.
<head>
  ...  
  <script src="js/vendor/modernizr-2.8.3.min.js"></script>
</head>
<body>
  ..
  // 모든 콘텐츠가 로드되고 실행될 스크립트 파일을 선언한다.
  <script src="js/main.js"></script>
</body>

Jenkins를 활용한 CI/CD 강의 노트 (2) : 젠킨스 개발환경 및 CI/CD 기본 동작 이해

심정욱 — Mon, 1 Mar 2021 23:55:23 +0900

앞서

이전 글(simju9397.tistory.com/4) 과 이어지는 내용입니다.

개발 환경의 종류

개발자가 개발을 하는 Local
개발자들끼리 개발 내용에 대한 통합 테스트를 하는 Development 환경
개발이 끝나고 QA 엔지니어 및 내부 사용자들이 사용해보기 위한 QA 환경
실제 유저가 사용하는 Production 환경
앞으로는 DEV, QA, PROD 환경으로 부른다.

개발 프로세스

개발자가 Local에서 개발을 진행한다.
다른 개발자가 작성한 코드와 차이가 발생하지 않는지 내부 테스트를 진행한다.
진행한 내용을 다른 개발자들과 공유하기 위해 git 에 올린다. -> 흔히 dev 브랜치
Dev 브랜치의 내용을 개발 환경에 배포하기 전에 테스트와 lint 등 코드 포맷팅을 한다.
빌드 -> 배포 -> 테스트 ->각각의 환경에 위 과정을 다하고 환경에 배포

여러 배포 환경의 관리

인프라를 모듈화 하여 어떤 것이 변수인지 잘 설정하고 이를 잘 설계하는 것!!
가령 APP_ENV 처럼 현재 배포하고자 하는 것이 무슨 환경인지 설정하고, 앱 내에서 사용하는 다양한 변수들을 APP_ENV 에 맞게 잘 가져다 쓰는 것
AWS System Manager 의 parameter store 와 같은 키 관리 서비스를 쓰자.

예시 배포 환경

웹사이트 코드 작성
웹사이트 코드를 린트, 웹팩 빌드해서 AWS S3 bucket 에 html 파일 업로드
Node.js 백엔드 코드를 typescript 로 작성
위 코드를 javascript compile 하고, 테스트 코드를 돌려서 도커 이미지를 만들어 ECR 에 올린다.
업로드한 ECR 이미지로 ECS 서비스를 재시작한다.(rolling deploy => continuous deploy)

개발에 필요한 리소스 리뷰

ECR : 도커 이미지를 저장하는 private repository
ECS : 도커 컨테이너 기반으로 서비스 운용을 가능하게 해주는 간단한 서비스
1. 무중단 배포를 제공. scale up 가능
2. 수많은 도커 컨테이너 서버를 띄우고 LB가 이들 사이에 밸런싱을 해줌
3. fargate(ec2 안띄우고 전적으로 맡겨놓는 것), ec2 모드가 있어서 docker container 리소스만 띄우거나 물리적인 ec2 클러스터로 구성 가능.
ECS 혹은 k8s 등을 통해 rolling deploy 가 처리 되기 때문에, jenkins 의 역할은 배포 명령만 내려주면 된다! (aws ecs update-service {serviceName} )

동작 방식 다이어그램

위의 예는 작은 규모의 서비스이며, 현업에서는 dev 와 prod 를 git 부터 aws 계정까지 물리적으로 분리해놓는다고 한다.

마치며

다음 수업에서 드디어 시작을 할텐데, 잘 배울 수 있을지 조금 걱정되지만 재밌을 것 같다.

Jenkins를 활용한 CI/CD 강의 노트 (1) : 젠킨스(Jenkins) 이해하기

심정욱 — Mon, 1 Mar 2021 21:09:59 +0900

개요

이 글은 T아카데미의 세미나 영상 을 보고 제가 다시 보기 위해 정리하는 글입니다.

CI/CD?

CI

Continuous Integration : 지속적인 통합
뭘 통합하나 ?
- 여러 개발자의 코드베이스를 계속해서 통합
없다면?

10명의 개발자가 열심히 개발을 한다.
Merge 어케하지..?

있다면?

10명의 개발자가 열심히 개발을 한다.
커밋!
로컬 테스트 통과 실패 ㅠ
다시 커밋!
코드 베이스 Merge
만족!

테스트가 되어 있지 않은 무서운 코드를 애초에 없앤다!

CD

Continuous Delivery : 지속적인 배달
뭘 배달해??
- 사용자에게 제품(서비스)을 지속적으로 배달
- 코드베이스가 항상 배포가능한 상태를 유지하는 것.
즉, CI/CD란, 개발 환경을 사용자가 사용 가능한 서비스로 전달하는 모든 과정을
지속 가능한 형태로, 가능하다면 자동으로 해서
개발자와 사용자 사이의 격차를 없애는 것!
코드 작성 -> 빌드 -> 테스트 -> 배포
없다면?

백엔드 코드 개발
프론트와 통신 해야하니 배포를 해볼까?
저기 배포좀 해주세요..
앗 버그났는데 다시 배포좀..
데브 서버에 누가 배포했나요? 제꺼 안되는데;;
앗 죄송..
QA 배포..
프로덕션 배포시 초긴장 유지..
개발자가 코드만 짜면 되지 뭐이리 할게 많아 ㅜ

있다면?

개발
끝!

What is Jenkins?

JRE 위에서 동작하는 자동화 서버.
빌드, 테스트, 배포 등 모든 것을 자동화 해줌.
난 개발만 할거니 니가 다해라!
다양한 플러그인들을 활용해서 각종 자동화 작업을 처리할 수 있음.
플러그인들을 잘 조립해서 , 일련의 자동화 작업의 순서들의 집한인 Pipeline 을 통해 CI/CD 파이프라인 구축.

Plugin

대표적인 플러그인들

Credential Plugin

배포에 필요한 각종 리소스에 접근하기 위해서는 여러가지 중요 정보들을 저장하고 있어야 함.
그런 중요한 정보들(AWS token, Git access token, ...)들을 저장해주는 플러그인.

Pipeline

플러그인들의 집합이자 구성
여러 플러그인들을 파이프라인에서 용도에 맞게 사용하고 정의함으로써, 파이프라인을 통해 서비스가 배포됨.
두 가지 형태의 Syntax 가 존재(Declarative, Scripted Pipeline)
Declarative Pipeline Syntax 배울 예정.

Pipeline Syntax

Sections

Agent Section

젠킨스는 많은 일들을 해야 하기 때문에 혼자 하기 버겁다.
여러 slave node 를 두고 일을 시킬 수 있는데, 어떤 젠킨스가 일을 하게 할 것인지 지정함.

Post Section

스테이지가 끝난 이후의 결과에 따라서 후속 조치를 취할 수 있다.
if success -> slack 에 배포됐습니다 띄워준다던지

Stages Section

어떤 일들을 처리할 건지 일련의 stage를 정의함.

Steps Section

한 스테이지 안에서의 단계로 일련의 스텝을 보여줌.

Declaratives

Environment : 어떤 pipeline 이나 stage scope 의 환경 변수 설정
Parameter : 파이프라인 실행 시 파라미터 받음.
Trigger : 파이프라인이 무슨 주기로 실행되는지 설정
When : 언제 실행되는가

Steps

Steps 내부는 여러가지 스텝들로 구성
여러 작업들을 실행 가능
플러그인을 깔면 사용할 수 있는 스텝들이 생겨남.

pipeline 예시 코드

pipeline {
    agent any

    stages {
        stage('Prepare') { 
            steps {git pull}
            post { success { echo 'success' }
        }

        stage('Build') { steps { echo 'building...'}}
    }
}

NestJS(Node.js) 프레임워크로 SMS 문자 인증 서버 구현하기 (Naver Cloud Platform SENS API )

심정욱 — Mon, 1 Mar 2021 21:04:11 +0900

개요

현재 진행하는 프로젝트에서 SMS 인증 기능이 추가될 것이라는 말을 듣고, 아직 한 번도 안해본 기능이라 해보고 싶었다. 꽤나 애를 먹었고, 기능 구현에 이 글이 도움이 되기를 바란다. 글의 이해를 위해 다음과 같은 기술들의 개념이 필요하다.

Node.js
NestJS Framework
Typescript
async/await

API Docs

공식 API 문서 바로가기
API 문서에도 나와있지만, NCP 의 API 인증 방식은 꽤 특이하다.

Content-Type 은 그냥 해도 되는데, timestamp를 찍어줘야 한다.
node.js 기준으로는 Date.now().toString() 으로 보내주면 된다.
access key 는 계정 관리 - 인증키 관리에서 Access Key ID를 쓰면 된다.

마지막으로 signature 가 가장 어려웠는데, 생성 가이드대로 했는데도 계속 인증키 오류가 나서 1시간 정도 썼었다. 우리가 해싱해줘야하는 string은 다음 형식이다.

{METHOD} {uri}
{timestamp}
{accesskey}

SMS API를 예제로 하면 다음과 같다.

POST /sms/v2/services/{serviceId}/messages
Date.now().toString()
{accessKey}

이후, 이렇게 만들어진 string을 crypto.createHmac() 함수를 통해, 계정 관리-인증키 관리에 있는 secret key로 해싱해주면 된다.

전체 코드는 다음과 같다.

import {
  InternalServerErrorException,
} from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import axios from 'axios';
import * as crypto from 'crypto';

@Injectable()
export class AppService {
  constructor(
    private readonly config: ConfigService, // .env
  ) {}

  private makeSignature(): string {
    const message = [];
    const hmac = crypto.createHmac('sha256', this.config.get('NCP_secretKey'));
    const space = ' ';
    const newLine = '\n';
    const method = 'POST';
    const timestamp = Date.now().toString();
    message.push(method);
    message.push(space);
    message.push(this.config.get('uri'));
    message.push(newLine);
    message.push(timestamp);
    message.push(newLine);
    message.push(this.config.get('NCP_accessKey'));
    //message 배열에 위의 내용들을 담아준 후에
    const signature = hmac.update(message.join('')).digest('base64');
    //message.join('') 으로 만들어진 string 을 hmac 에 담고, base64로 인코딩한다
    return signature.toString(); // toString()이 없었어서 에러가 자꾸 났었는데, 반드시 고쳐야함.
  } 

  async sendSMS(phoneNumber: string): Promise<string> {
    const body = {
      type: 'SMS',
      contentType: 'COMM',
      countryCode: '82',
      from: this.config.get('hostPhoneNumber'), // 발신자 번호
      content: `문자 내용 부분 입니다.`,
      messages: [
        {
          to: phoneNumber, // 수신자 번호
        },
      ],
    };
    const options = {
      headers: {
        'Content-Type': 'application/json; charset=utf-8',
        'x-ncp-iam-access-key': this.config.get('NCP_accessKey'),
        'x-ncp-apigw-timestamp': Date.now().toString(),
        'x-ncp-apigw-signature-v2': this.makeSignature(),
      },
    };
    axios
      .post(this.config.get('url'), body, options)
      .then(async (res) => {
        // 성공 이벤트
      })
      .catch((err) => {
        console.error(err.response.data);
        throw new InternalServerErrorException();
      });

    return authNumber;
  }
}

마치며

처음 써본 api였는데, 사용법이 꽤 어려웠지만 네이버에서 제공하는 기능이니만큼 안정적일 것이고, 무엇보다 secret key로만 그치지 않고 암호화까지 하는 걸 보니 보안적인 측면에서도 괜찮을 것 같다. 성공적으로 문자 인증 서버를 NestJS를 통해 구축할 수 있었다.