Sorry, we've misplaced that URL or it's pointing to something that doesn't exist.
Head back Home to try finding it again, or search for it on the Archives page.
Sorry, we've misplaced that URL or it's pointing to something that doesn't exist.
Head back Home to try finding it again, or search for it on the Archives page.
프론트엔드 관련 아티클을 읽다보면 다양한 bundler, package manger, compiler 도구에 대한 얘기가 나온다. 그때마다 익숙지않은 도구의 이름(pnpm, swc, vite 등)이 나오는데 뭐가 뭔지 잘 이해가 안간다. 따라서 각각의 역할이 무엇인지, 어떤 종류가 있고 어떤 장단이 있는지 간단히 정리해보려고 한다. Bundler ...
원본 작성자가 언제 어떻게 LLM 을 활용하는지 공유하는 포스트 애플리케이션을 만드는 초기 단계에서 전체적인 베이스를 만드는데 도움을 받았음 새로운 기술의 튜터로써 코드 단순화를 위해 단조로운 작업을 빠르게 처리하기 위해 불규칙적인 작업이더라도 LLM이 패턴을 파악하여 결과물을 내게할 수 있음 ...
원본 기존에 빌드가 오래 걸렸던 원인들 웹팩, 롤업 작업 시간이 대부분이었음 작은 의존성들이 하나씩 빌드됨. 이것들은 동시에 진행될 여지가 있음 몇몇 의존성은 필요한 것보다 오래 빌드됨. 변경되지 않은 파일에 대해서 typeshare 를 재실행하지 않기위해 find를 실행했으나, 그냥 typeshare를 실행하는 것보다 find 실행...
이 책은 프로젝트 과정 전반에 거쳐 소프트웨어 전문가답게 진행하는 방법에 대해 서술되어있다. 전반적으로 이해가 잘되도록 쓰여져 있고, 현인의 어록과도 같은 책이라 참고할만한 부분도 많이 있다. 하지만 조직문화나 권한의 한계, 물리적인 시간의 한계로 모든 팁을 다 따르기는 어렵다. 또한 이러한 내용은 완전히 습관이 되어야하는데, 긴 책 내용을 전부 기...
Topic 49 : 프로젝트 참여인원이 복수가 되었을때 실용적으로 각 부분을 위임하는 법 Topic 50 : 팀에게 잘 맞는 방법론을 사용하고 있는가 Topic 51 : 안정적인 소프트웨어를 지속적으로 생산해내는 방법 Topic 52 : 사용자를 기쁘게하는 방법 Topic 53 : 자신의 작업에 자부심을 가져라 Topic 49 ...
Topic 45 : 요구사항의 구렁텅이 자신이 뭘 원하는지 정확히 아는 사람은 아무도 없다. 요구사항 미신 무엇을 다루든 정확한 명세란 것은 거의 불가능하다. 이때 프로그래머는 사람들이 자신이 무엇을 원하는지 깨닫도록 도와줄수 있다. 프로그래머는 사람들이 자신이 원하는 바를 꺠닫도록 돕는다. 상담 치료로서의 프로그래밍 신입 개...
https://velog.io/@eunbinn/dry-the-common-source-of-bad-abstractions DRY 원칙을 너무 지키다보니 잘못된 추상화를 하는 경우가 있다 바로 서로 성격이 다른 코드이지만, 비슷한 패턴을 가진다는 이유로 같은 코드로 묶는 경우이다. ex) 네비게이션에 Article, Menu, Buy 버튼...
코딩은 설계내용을 단순히 코드로 바꾸는 과정이 아니다. 이번 장에서는 프로그램을 정확하게 동작하게 하려면 어떻게 해야하는지 다룬다. 운전할 때와 마찬가지로 코딩도 반복적인 일이지만 정신을 늘 기민하게 유지하여야한다. topic 37 : 본능과 무의식적인 생각을 더 잘 활용할 수 있다 topic 38 : 우연에 맡기는 프로그래밍을 피하는 방법...
동시성 : 둘 이상의 코드 조작이 실행될 때 동시에 실행 중인 것처럼 행동하는 것. 소프트웨어 동작 코드의 다른 부분으로 실행을 전환할 수 있는 환경에서 코드를 구동해야함. ex) 스레드, 프로세스 병렬성 : 실제로 동시에 실행되는 것. 하드웨어 동작 두가지 일을 동시에 할 수 있는 하드...
이번 장에서는 되돌릴 수 있는 의사결정을 내리는 구체적인 방법을 설명한다. topic 28 : 결합도 줄이기 topic 29 : 실세계를 갖고 저글링하기. 이벤트에 반응하는 네 가지 서로 다른 전략 topic 30 : 변환 프로그래밍. 함수 파이프라인 topic 31 : 상속세. 유연하고 바꾸기 쉬운 코드를 만들 수 있는 대안 t...
클래스 초기화 블록 어떤 클래스에 static 변수를 추가했더니 github copilot이 다음과 같은 문장을 추천해주었다. public class Crypto { private static CryptoProperties cryptoProperties; // github copilot suggestion static { crypto...
Pinpoint Pinpoint는 대규모 분산 시스템의 성능을 분석하고 문제를 진단, 처리하는 플랫폼입니다. 2012년 7월에 개발을 시작해 2015년 1월 9일에 오픈소스로 공개했습니다 Pinpoint 개발 동기와 Pinpoint의 특징 인터넷 서비스의 시스템 복잡도가 증가함에 따라 장애나 성능 문제가 발생했을 때 해결이 어려워졌다....
Istio istio는 service mesh를 위한 tool입니다. istio를 사용하면 MSA(Micro Service Architecture)를 적용할 때 반복적으로 설정해야하는 L7/모니터링을 쉽고 간편하게 설정할 수 있습니다. Service mesh Service mesh는 API 등을 사용하여 마이크로 서비스 간 통신을 안전하고...
사이드카 패턴 쿠버네티스의 패턴 중 하나로, 어플리케이션 컨테이너와 독립적으로 동작하는 별도의 컨테이너를 붙이는 패턴이다. 어플리케이션 컨테이너의 변경이나 수정 없이 독립적으로 동작하는 컨테이너를 붙였다 뗐다 할 수 있다. 파드에서의 사이드카 파드는 쿠버네티스에서 가장 기본적인 배포 단위로서 자신에게 속한 컨테이너들에게 런타임제약을 걸 수 있...
예외 발생 시에도 JSON 응답 보내기 ResponseEntity를 사용해서 응답을 보내면 된다. public ResponseEntity<String> errorPage500Api() { String result = "error"; return new ResponseEntity(result, HttpStatus.BAD_REQUEST....
AOP = Aspect Oriented Programming = 관점 지향 프로그래밍 관점 지향이란 어떤 로직을 기준으로 핵심적인 관점, 부가적인 관점으로 나누어서 보고 그 관점을 기준으로 모듈화 하겠다는 것이다. 여기서 모듈화란 어떤 공통된 로직이나 기능을 하나의 단위로 묶는 것을 말한다. AOP에서 각 관점을 기준으로 모듈화한다는 것은 ...
제목 그대로 다음과 같이 @NoArgsConstructor 애노테이션을 @ModelAttribute로 적용되는 컨트롤러 파라미터 클래스에 추가하니 제대로 쿼리를 날려도 아무것도 안들어가는 이슈가 발생했다. @GetMapping("/article") public ResponseEntity getArticles(@ModelAttribute SelectA...
요청 파라미터(쿼리, form 데이터) HttpServletRequest @RequestMapping("/request-param-v1") public void requestParamV1(HttpServletRequest request, HttpServletResponse response) HttpServletRequest에서 조회해서 꺼내올...
서블릿 예외처리 서블릿의 예외처리 방식 Exception WAS <- 서블릿 컨테이너 <- 필터 <- 서블릿 <- 인터셉터 <- 컨트롤러(예외발생) 웹 애플리케이션에서 발생한 예외를 잡지 못하면, 예외는 서블릿 컨테이너에까지 전달된다. 서블릿 컨테이너는 넘어온 예외를 기준으로 등록된 오류페이지를 조회한...
과정 클라이언트가 서버로 요청하면 먼저 Dispatcher Servlet 받음 Dispatcher Servlet은 http 요청의 URL과 메소드를 보고 이것을 처리할 수 있는 핸들러(컨트롤러)를 찾기 위해 핸들러 매핑 과정을 진행한다. 핸들러를 찾으면 이 핸들러를 처리할 수 있는 핸들러 어댑터를 조회한다. 핸들러 어댑터를 실행시...
서블릿 필터 스프링에서 공통 관심사를 처리하기 위한 방법으로, 스프링 인터셉터와 함께 쓰이는 방법이다. 스프링 AOP를 사용하여 공통관심사를 처리할 수 있지만 웹과 관련된 공통 관심사는 서블릿 필터나 스프링 인터셉터를 사용하는 것이 좋다. 서플릿 필터나 스프링 인터셉터는 HttpServletRequest를 제공해주기 때문이다. 소개 필터 흐름 ...
쿠키 사용자가 로그인하면, 사용자 식별자를 암호화 또는 평문으로 쿠키에 담는 방식. 요청이 오면 쿠키에 담긴 식별자를 보고 유저를 구분한다. 장점 유효한 쿠키인지만 확인하면 되기에 서버자원과 비용을 아낄 수 있다. 서버를 무상태(stateless)로 만들어줌. 암호화를 하면 brute force 대응 ...
프론트 아키텍처 흐름 MVC Model - View -Controller로 나눈 아키텍처 Model 컨트롤러가 호출했을때, 요청에 맞는 역할을 수행한다. 비즈니스 로직을 구현하는 영역으로 응용프로그램에서 데이터를 처리하는 부분 뷰나 컨트롤러에 대해서 어떤 정보도 알지 말아야한다. Contro...
스프링 계층구조 Web 계층 컨트롤러(@Controller)와 JSP/Freemarker 등의 뷰 템플릿 영역 이외에도 필터(@Filter), 인터셉터, 컨트롤러 어드바이스(@Controller Advice) 등 외부 요청과 응답에 대한 전반적인 영역을 나타낸다. 외부 요청과 응답에 대한 전반적인 영역. 어플리케이션의 진입점이기 때...
WAS(Web Application Server) DB 조회나 다양한 로직처리를 요구하는 동적인 컨텐츠를 제공하기 위해 만들어진 Application Server HTTP를 통해 컴퓨터나 장치에 애플리케이션을 수행해주는 미들웨어(소프트웨어 엔진)이다. 웹 컨테이너 혹은 서블릿 컨테이너 라고도 불린다. 컨테이너란, js...
Open Graph 프로토콜 HTML문서의 head에는 <meta> 태그로 사이트의 정보가 표기되어있는 경우가 많다. 이는 크롤러가 무엇이 제목이고, 무엇이 내용인지 파악하기 쉽도록 하기 위해서 표기한 것이다. 페이스북의 Open Graph 프로토콜은 이러한 메타태그의 표기 방법은 통일한 것이다. 이 Open Graph 프로토콜이 우리가...
Mysql의 Select Count(*) 얼마나 빠를까? 사용하는 데이터베이스 엔진에 따라 다르다. InnoDB : O(n) MyISAM : O(1) 이유는 MyISAM의 경우 row가 몇 개 있는지 저장하고 있기에 Count(*) 쿼리가 들어오면 그 저장한 값을 바로 리턴하여 O(1)이 된다. Count(*) vs Count(c...
리액트 리팩토링 useEffect 사용 useEffect 올바른 사용 props, state 변경에 따라 다른 데이터, state를 업데이트해야할 때 useEffect의 사용을 자제하자. useEffect vs EventHandler 중 어느 쪽에서 유저 인터랙션을 처리해야할까? useEffect 내에서 data fetching을 할...
Eclipse 프로젝트 생성 new Java project를 하면 여러 선택지가 나옴. Project layout use project folder as root for sources and class files 빌드 전 소스코드와 빌드 후 생성된 결과물이 root에 한번에 생김...
useEffect 올바른 사용 props, state 변경에 따라 다른 데이터, state를 업데이트해야할 때 useEffect를 사용하면 안된다. props, state가 변경이 되면 리렌더링이 발생하는데, 리렌더링이 끝난 후 useEffect가 호출되어 다시 리렌더링이 발생하기 때문이다. 따라서 다음과 같이 코드를 변경해야한다. 데이터...
바벨 바벨이란? 자바스크립트 트랜스파일러. 보통 모던 자바스크립트를 호환성을 위해 예전 문법으로 변환할때 사용한다. Typescript와 JSX 코드를 변환할 때도 사용한다. 바벨 설정 파일 예시 { "presets": [ [ "@babel/env", { "targets": { ...
선언형, 명령형 그리고 추상화 선언형이란? 명령형은 어떻게(How)에, 선언형은 무엇(What)에 집중한다. 선언형은 명령형 코드에서 ‘어떻게’를 감추고 ‘무엇을’만 노출하는 방식의 추상화이다. 일종의 리팩토링이다. 예시를 들면 다음과 같다. // 명령형 코드 : 배열에 있는 모든 숫자를 하나씩 제곱해서 result 배열에 넣는다. f...
useQuery 설정 React-Query 공식문서상 캐싱개념은 stale과 cachetime을 통해 이루어진다 useQuery의 옵션으로 staletime과 cachetime을 보낼 수 있다. staletime : fetch를 통해 전달받은 데이터는 리액트 쿼리의 자료구조 내용중 캐시에 저장되는데, 이 캐시데이터의 ‘신선한 상태’가 언제까...
페이징 DB 에서 페이징을 구현하는 방법 오프셋 페이징 limit과 offset을 활용하여 페이징을 구현하는 방법. SELECT * FROM table ORDER BY timestamp OFFSET 10 LIMIT 5 장점 구현이 간단하다. 단점 Offset을 정말로 건너 뛰는 게 아니라, 한번은 읽는다. 따라서 만...
실행컨텍스트 코드의 실제 진행상황을 추적하는데 필요한 정보들을 모아둔 구조 함수가 ()로 호출되면 실행컨텍스트가 생성됨. 실행 컨텍스트에는 파라미터를 포함한 지역 메모리와 실행문이 있음. 함수가 종료되면 실행 컨텍스트는 사라진다. 자바스크립트의 함수 객체 서브루틴으로 실행할 ...
정렬 SELECT * FROM ANIMAL_INS ORDER BY ANIMAL_ID ASC ORDER BY ANIMAL_ID DESC ORDER BY NAME ASC, DATETIME DESC 조건 SELECT ANIMAL_ID, NAME FROM ANIMAL_INS WHERE INTAKE_CONDITION="Sick" WHERE I...
CSS 최적화가 필요한 이유 CSS는 렌더링을 막는다. CSS의 존재만으로도, CSS가 파싱되기 전까지 브라우저는 렌더링이 지연된다. 만약 브라우저가 CSS가 없는 페이지를 그대로 노출하면, 스타일적용이 되지않은 페이지가 나타나기 때문이다. 이를 FOUC라고 불린다. CSS는 HTML 파싱도 막을 수 있다 브라우저가 CSS가 파싱되기 전까지...
클래스형 컴포넌트 import React, { Component } from 'react'; class Hello extends Component { static defaultProps = { name: '이름없음' }; render() { const { color, name, isSpecial } = this....
리액트로 개발을 하다가 리스트를 만들면, 다음과 같이 key를 사용하라는 안내문이 뜬다. 평소엔 무시하고 key를 그냥 넣었지만, 왜 그런지 갑자기 궁금해져 찾아보았다. Recursing On Children 해당 내용은 리액트 공식문서에 Recursing On Children으로 나와있다. 리액트 리렌더링 과정에서 리스트를 처리할때, 리액...
문법 for … of : 반복가능한 객체 (Array, String, Set) for … in : 객체. 키를 뽑아냄. Set Set.prototype.add(value) Set.prototype.clear() Set.prototype.delete(value) Set.prototype.forEach((value, k...
프론트엔드 Virtual DOM 리액트의 작동방식은 상태변화 시, 그 컴포넌트와 하위 컴포넌트를 모두 교체하기에 많은 DOM 변화가 일어난다. 이때 리액트에서는 DOM을 추상화한 객체인 Virtual DOM을 변경하고, 변경이 완료되면 실제 DOM과의 차이점을 확인한다음 한번의 리렌더로 해결한다. Virtual DOM은 메모리에 존재하여 메모리...
Virtual DOM은 DOM을 추상화한 가상의 객체이다. DOM 이란? HTML 문서를 파싱하여 문서의 구성요소들을 객체로 구조화하여 나타낸 것. HTML Elements, 속성, CSS style, Events, Methods 를 구조화해서 나타낸 객체고, 이 객체를 이용해서 웹페이지 구성요소를 제어할 수 있다. Virtual DOM...
기존에 React 17을 사용하던 Forkie Player 프로젝트를 React 18로 업데이트 하는 기록 업데이트 하는 이유 automatic batching 동영상이 끝났을때 다음 영상으로 넘어가거나, 현재 영상의 시작부분으로 돌아가기 위해선 동영상의 timeupdate, ready, pause, ended 등등의 상태...
리액트 리렌더링 https://velog.io/@eunbinn/when-does-react-render-your-component children으로 넘어온 컴포넌트는 사용되는 컴포넌트가 리렌더링되도, 리렌더링의 영향을 받지 않는다. 리렌더링은 현재 컴포넌트에서 변화된 것이 없어도, 자식으로 전파된다. but 현재 컴포...
액션, 계산, 데이터 순수함수 vs 부수효과를 대체한 개념들. 데이터 : 이벤트에 대한 사실. 액션에 의해 변화됨 액션 : 데이터를 변화시킬 수 있음. 실행시점이나 횟수에 의존하여 언제하느냐에 따라 결과가 달라지면 액션이다. 계산 : 입력값을 통해 출력을 만들어내는 것. 같은 입력에 대해 항상 같은 출력값만 내놓아야한다. 외부 세계에 영향을 주...
View 다른 테이블을 기반으로 만들어진 가상 테이블. 논리적으로만 존재하는 테이블. 장점 질의문을 쉽게 작성할 수 있음 데이터 보안유지에 도움이 됨. 데이터 관리가 편해짐 특징 ALTER 문으로 뷰를 재정의하는 것은 불가능 기본 테이블 삭제 시 같이 삭제된다. 독자적인 인덱스를 가질 수 없음. **뷰생성 ** ...
IPv6 128비트 사용. Multicast 대신에 Broadcast를 함. ICMPv6 ARP, IGMP 기능흡수 ARP : IP주소를 MAC 주소로 변환하는 프로토콜 IPv4 에서 IPv...
deadlock 발생 조건 아래 4가지 조건을 모두 만족하면 데드락 발생가능성이 있음 상호배제(Mutual Exclusion) 한 리소스는 한번에 한 프로세스만이 사용할 수 있음 Hold and wait No preemption Circular wait deadlock 방지법 Prev...
알고리즘 첫번째와 두번째 원소 사이의 공차를 구함 두번째 원소부터 마지막원소까지의 공차를 만족하는 경우만으로 dfs를 진행함 마지막원소까지 공차를 만족하는 모든 경우의 수를 구하고, 그 중 최소 연산으로 만족하는 경우의 수를 반환함. 위 과정을 첫번째 원소와 두번째 원소 사이의 공차의 경우의수만큼 진행하...
서브네팅 사용가능한 IP 주소 범위를 분할하여 사용하는 것 특징 2의 배수로, 같은 크기로 분할 주소할당 서브넷 마스크는 다음과 같음 네트워크 주소사용부분 모두 1 + 호스트 주소 사용부분 모두 0 각 서브넷에서는 다음과 같이 2개의 주소는 예약되어있음 네트워크 주소 : (기존 네트워크 부 + 분할부분 매핑 주소)...
관계 데이터 모델 용어 릴레이션 : 하나의 개체에 관한 데이터를 2차원 테이블로 저장한 것. 릴레이션 스키마 : 릴레이션의 이름과 속성이름으로 정의. 정적. 내포 릴레이션 인스턴스 : 릴레이션에 존재하는 튜플들의 집합. 동적. 외연 도메인 : 하나의 속성이 가질 수 있는 모든...
반정규화 시스템의 성능 향상, 개발 및 운영의 편의성을 위해 정규화된 데이터 모델을 통합, 중복, 분리하는 과정으로 의도적으로 정규화 원칙을 위배하는 행위. 과도한 반정규화는 성능 저하를 불러일으킴. 시스셈의 성능과 관리효율성은 증가하지만, 데이터의 일관성 및 정합성을 저하될 수 있음. 따라서 사전에 데이터의 일관성 및 ...
응집도 모듈 내부의 기능적인 집중 정도. 높을 수록 좋다. 우연적 응집도 < 논리적 응집도 < 시간적 응집도 < 절차적 응집도 < 교환적 응집도 < 순차적 응집도 < 기능적 응집도 기능적 응집도(Functional Cohesion) : 모듈 내부의 모든 기능이 단일한 목적을 위해 수행되는 경우 순차적 응집...
내부 스키마 데이터베이스가 실제로 저장되는 방법을 정의한 것. 개념 스키마 데이터베이스 전체의 논리적 구조를 정의한 것. 데이터베이스 하나에 하나만 존재. 개체, 관계, 제약조건, 보안정책 등을 정의한다. 외부 스키마 사용자에게 필요한 데이터베이스를 정의한 것
블랙박스 테스트 소프트웨어의 내부 구조나 작동 원리는 모르는 상태에서 동작을 검사하는 방식 기법 동등 분할 기법 : 프로그램 입력 도메인을 테스트 케이스가 산출될 수 있는 데이터 클래스로 분류하는 방법 경계값 분석 기법 : 입력 조건의 중간 값보다 경계값에서 에러가 발생될 확률이 높으므로 오류 예측 기법 : 놓치기 쉬운 오류들을 감각...
전위식 연산자를 먼저 표시하고 연산에 필요한 피연산자를 나중에 표시 (A + B) * (C - D) ((A + B) * (C - D)) *(+(AB)-(CD)) *+AB-CD 후위식 피연산자를 먼저 표시하고, 연산자를 나중에 표시 (A+B) * (C-D) ((A+B) * (C-D)) ((AB)+(CD)-)* AB+CD-*
통합 테스트 상향식 통합 테스트 프로그램의 하위 모듈에서 상위모듈로 통합하면서 테스트하는 기법. 하위 모듈을 클러스터로 결합 더미 모듈인 드라이버 작성 통합된 클러스터 단위로 테스트 테스트 완료 후 클러스터는 프로그램 구조의 상위로 이동해 결합하고, 드라이버는 실제 모듈로 대체 됨. 하향식 통합 테스트 프로그램의 상위모듈...
럼바우 분석기법 모델링 기법중 하나로 그래픽으로 표현한 분석기법 객체 모델링 기법이라고도 한다. 3단계로 구성 객체 모델링 동적 모델링 기능 모델링 1. 객체 모델링(object modeling) 객체 다이어그램을 표시함. 정보 모델링이라고도 하며, 시스템에서 요구되는 객체를 찾아내어 속성과 연산 식별...
UML(Unified Modeling Language) 통합 모델링 언어를 사용하여 시스템 상호작용, 업무 흐름, 시스템 구조, 컴포넌트 관계 등을 그린 도면. 프로그래밍을 단순화 시켜 표현하여 의사소통 하기 좋고, 대규모 프로젝트에서는 로드맵을 만들거나 개발을 위한 시스템 구축의 기본을 마련한다. 요구사항 모델링에 사용되는 기법 중 하나 ...
Coad Yourdon E-R 다이어그램을 사용하여 객체의 행위를 모델링. 객체 식별, 구조 식별, 주제정의, 속성과 인스턴스 연결 정의, 연산과 메시지 연결 정의 등의 과정으로 주로 관계를 분석 하는 기법 Booch 미시적, 거시적 개발 프로세스를 모두 사용하는 분석 방법. 클래스와 객체들을 분석 및 식별하고 클래스의 속성과 연산을 정의...
CASE(Computer Aided Software Engineering) 소프트웨어 개발 시 사용되는 분석 자동화 도구. 소프트웨어 개발 과정의 일부나 전체를 자동화하는 도구이다. CAD 기기와 유사한 것이라고 생각하면 됨. 요구분석 -> 설계 -> 구현 -> 검사 및 디버깅 과정을 CASE를 활용하여 자동화함 CA...
GoF(Gang of Four) GoF에서는 23가지 디자인패턴을 3가지 유형으로 분류함. 생성 패턴(Creation pattern) 객체를 생성하는데 관련된 패턴들 객체가 생성되는 과정의 유연성을 높이고, 코드의 유지를 쉽게함 구조 패턴(Structural Pattern) ...
운영체제 정의 컴퓨터 시스템의 4가지 요소 유저 어플리케이션 OS 하드웨어 운영체제 유저 관점 : 어플리케이션을 수행함. 컴퓨터 사용을 편리하게 해줌 시스템 관점 : 자원할당자. 어플리케이션과 i/o 장치의 수행을 다루는 프로그램 컨트롤러 커널 OS에 속하며, 컴퓨터에서 항상 수행되는 프로그램. 하드웨어...
화살표함수 기존의 function 표현방식보다 간결하게 함수를 표현할 수 있다. 화살표함수는 항상 익명이며, 자신의 this, arguments, super, new.target을 바인딩하지 않는다. 따라서 생성자로는 사용할 수 없다. 화살표함수 도입 영향 : 짧은 함수, 상위 스코프 this 짧은 함수 var materials = ...
Promise 비동기로 처리하기 위한 방법 중 하나. 다음과 같이 사용 //Promise 선언 var _promise = function (param) { return new Promise(function (resolve, reject) { window.setTimeout(function () { if (param) { ...
this에 대해서 자바스크립트에서 모든 함수는 실행될때마다 함수 내부에 this라는 객체가 추가된다. arguments라는 유사배열 객체와 함께 함수 내부로 암묵적으로 전달되는 것이다. 그렇기 때문에 자바스크립트에서의 this는 함수가 호출된 상황에 따라 그 모습을 달리한다. 상황 1. 객체의 메서드를 호출할때 객체의 프로퍼티가 함수일 경우 ...
Closure 두개의 함수로 만들어진 환경으로 이루어진 특별한 객체의 한 종류이다. 여기서 환경이란, 클로저가 생성될 때 그 범위에 있던 여러 지역변수들이 포함된 context를 말한다. 이 클로저를 통해서 자바스크립트에는 없는 private 속성/메소드, public 속성/메소드를 구현할 수 있다. 클로저 생성하기 다음은 클로저가 생성되는 ...
호이스팅은 변수를 끌어올리는 것. var로 선언된 모든 변수 선언을 hoist한다. hoist란 변수의 정의가 그 범위에 따라 선언과 할당으로 분리되는 것을 의미한다. 즉, 함수 내의 선언들을 모두 끌어올려서 해당 함수 유효 범위의 최상단에 선언하는 것 자바스크립트에서 변수의 선언은 끌어올려진다. 다음의 코드를 보자. function getX()...
이벤트 루프 javascript를 공부하다보면 아래와 같은 말을 종종 듣는다. 싱글스레드 기반으로 동작하는 자바스크립트 이벤트 루프를 기반으로 하는 싱글스레드 Node.js 정말 싱글 스레드인가? 어떻게 싱글 스레드인가? 이벤트 루프는 무엇인가? 를 간단히 알아보기 위해 자바스크립트가 동작하는 환경과 엔진에 대해 알아보자. Ja...
DP 복잡한 문제를 간단한 여러 하위문제로 나누어 푸는 방법 두가지 구현방식이 존재함 top-down 여러개의 하위문제로 나누고, 하위문제를 푼 다음, 그것들을 결합하여 최종적으로 최적해를 구한다. 이때 하위문제로 나눌때 같은 하위문제를 가지고 있는 경우가 있다. 이때의 최적해를 저장해서 사용하여 같은 하위문제...
Singleton 패턴 애플리케이션에서 인스턴스를 하나만 만들어 사용하기 위한 패턴이다. 커넥션 풀, 스레드 풀, 디바이스 설정 객체 등의 경우, 인스턴스를 여러 개 만들게하면 자원을 낭비하게 되거나 버그를 발생시킬 수 있으므로 오직 하나만 생성하고 그 인스턴스를 사용하도록 하는 것이 목적이다. 구현 하나의 인스턴스만을 유지하기 위해 인스턴...
데이터베이스 파일시스템의 문제점 앱과 상호 연동되어있기 때문에 다음과 같은 문제가 발생함. 데이터 종속성 데이터 중복성 데이터 무결성 데이터베이스 특징 데이터 독립성 물리적 독립성 : 데이터베이스를 수정하더라도, 응용 프로그램을 수정할 필요는 없음 ...
최근 프로젝트에서 리액트 앱을 배포하였는데, 인터넷 속도가 느린 환경에서 자바스크립트를 다운로드 받는 시간이 오래 걸린다는 걸 눈치챘다. 눈치챘다는 표현이 어울리는데 왜냐하면 사실 당연한 건데 이제까지 신경쓰지 않았던 부분이기 때문이다. 리액트앱은 매우 큰 자바스크립트 파일 하나로 이루어져있고, 이를 다운로드 받는 것은 당연히 오래 걸리는 일이기 때...
알고리즘 LIS를 구하고, LIS를 구성하지 않는 요소들만 배치해주면 됨 LIS를 구하는 방법으론 n이 최대 200이니 O(n^2)을 써도 충분함 LIS 구하는 코드 O(n^2) 이전 요소들 중에 자기보다 작은 것 중, 가장 큰 LIS를 가진 요...
프로세스와 스레드의 차이 프로세스 실행중인 프로그램으로, 메모리에 적재되어 CPU의 할당을 받을 수 있는 것을 말함. OS로부터 주소공간, 파일, 메모리등을 할당받으며, 이것들을 총칭하여 프로세스라고한다. 할당받는 메모리 공간 프로세스 스택 : 함수의 매개변수, 복귀주소, 로컬 변수 같은 임시자료를 저장 데이터 섹션 : 전역변수들을 ...
알고리즘 문자열에서 a의 개수를 ac 라고 할때, 시작점을 문자열의 맨처음부터 맨 끝까지 이동하면서, 길이가 ac인 문자열을 안에 b가 몇개있는지 검사한다. 이때 검사한 b의 개수 중 최소가 필요한 최소의 교환횟수 쉽게 말해서, 길이가 ac인 문자열 안에 b를 최소로 포함한 문자열을 a로 채우는 문제로 치환한 것이다. 코드 #inc...
HTTP의 GET과 POST 비교 GET 데이터가 HTTP Request Message의 헤더부분의 url에 담겨서 전송됨. url의 끝에 ? 뒤에 데이터를 붙여 요청. 데이터의 크기가 제한적임. 데이터가 url에 노출되므로 보안에 약함 POST 데이터가 HTTP Requst Message의 바디부분에 담김 데이터 크기가...
Array vs Linked List Array 논리적 저장 순서와 물리적 저장순서가 일치함. 장점 Random Access : 인덱스로 원하는 원소에 바로 접근이 가능하여, O(1)에 해당원소로 접근가능 언어에따라 다르지만, 필요한 만큼만...
React 에서 Typescript 사용시 참고할만한 Typing 기법을 기록한 곳 React.HTMLArributes<[HTMLElement]> 한 Element에 부여될 속성 값들을 모두 참조할때 사용하면 좋다. 다음과 같이 기본 HTML 엘리먼트를 스타일링해서 사용할때 유용함 export interface ITextButtonPr...
yourlist_web_renewal 중, 한 input 엘리먼트의 placeholder가 보일시와 안보일 시, label 엘리먼트에 각기 다른 스타일을 적용해야하는 일이 있었다. 현재 사용중인 tailwind에선 어떻게 사용해야할지 모르겠으나 순수 CSS 방식으로 하면 다음과 같다. .form_field:placeholder-shown ~ .fo...
최근 프로젝트를 하면서, 다른 요소들의 크기는 정해져있을때 남은 한 요소의 크기를 부모 요소에서 남는 공간만큼 부여하는 부분이 많았다(그리고 앞으로도 많을 것 같다) 위 부분을 구현할때, flex와 grid를 통해 해결했어서 그것을 기록 하는 차원에서 이 글을 적어본다. flex 만약 다음과 같이 div 엘리먼트들이 배치되어있고, 우리는 가운데 ...
알고리즘(내방식) 숫자를 왼쪽에서 오른쪽으로 살펴가면서, 그 수가 나온 인덱스를 기록(saveIdx)한다. i를 기록할때 이미 기록된 인덱스가 있을 경우, 그 인덱스부터 이전에 체크가 안된 인덱스들은 i 까지만 연속해서 숫자를 뽑을 수 있다. 따라서 이에 해당하는 경우의 수를 정답에 추가시켜준다. 알고리즘(투포인터) 내가...
MVVM Model - View - View Model 의 약자로, 프로그램의 비지니스 로직과 프레젠테이션 로직을 UI로 명확하게 분리하는 패턴 구성요소 Model : 데이터를 보관하고 있는 부분으로, 데이터를 불러오거나 업데이트하는 로직이 있음. View Model : Model에 데이터를 요청하고 가공함. 비지니스 로직을 처리. ...
Git GIT의 개발 목표 빠른 속도 단순한 구조 비선형적인 개발(수천 개의 동시다발적인 브랜치) 완벽한 분산(DVCS) 대형 프로젝트에도 유용할 것 Inside of Git Git은 기본적으로 파일시스템의 스냅샷을 저장한다.(커밋 당시의 GIT 디렉터리의 모든 파일 정보를 저장) 또한 파일 및 스냅샷을 해시하여 바뀐 버전...
MVC 컴포넌트의 역할 Model 컨트롤러가 호출했을때, 요청에 맞는 역할을 수행한다. 비즈니스 로직을 구현하는 영역으로 응용프로그램에서 데이터를 처리하는 부분이다. DB에 연결하고 데이터를 추출하거나 CRUD 등의 작업을 수행한다. 상태의 변화가 있을때, 컨트롤러와 뷰에 통보해 후속 조치 명령을 받을 수 있게 된다. 뷰나 컨트롤러...
TDD 란? Test-Driven Development의 약자로, 테스트가 코드 작성을 주도하는 개발방식이며, 매우 짧은 개발 사이클의 반복에 의존하는 소프트웨어 개발 프로세스이다. 우선 개발자는 요구되는 새로운 기능에 대한 자동화된 테스트케이스를 작성하고, 해당 테스트를 통과하는 가장 간단한 코드를 작성한다. 일단 테스트를 통과하는 코드를 작성하...
REST란, REprensentational State Transfer의 약자이다. 따라서, RESTful API는 REST의 기본 원칙을 잘 지킨 API를 의미한다. REST는 하나의 아키텍쳐로, Resource Oriented Architecture이다. API 설계의 중심에 자원(resource)가 있고, HTTP Method를 통해 자원을 처...
매우 어렵게 구현하여 풀긴하였으나, 스택을 사용하면 매우 직관적으로 편하게 구현할 수 있었다. 스택을 사용하여 문제를 푼 경험이 적어서 스택을 떠오르지 못한 것 같다 스택을 사용한 문자열 문제를 몇문제 풀어봐야할 것 같음 내 풀이 : 빡센 구현 알고리즘 앞에서부터 검사하다가 폭발문자열과 일치하는 문자열이 발견되면, 그 문자열을 폭파시키고...
부수 효과가 없는 순수함수를 1급 객체로 간주하여 파라미터로 넘기거나 반환값으로 사용하는 것을 가능하도록 하여, 참조 투명성을 지키도록 하는 프로그래밍 패러다임 순수 함수형 프로그래밍만으로 개발을 하기에는 무리가 있다. 따라서 적절히 조절해가면서 개발을 해나가자. 요약 함수형 프로그래밍의 가장 큰 특징 두 가지 immutable data ...
구조 관련 정렬된 배열의 앞 뒤로 새로운 요소를 삽입 해야되는 경우 필요한 길이의 2배길이의 배열을 선언한 다음, (start, to)로 인덱스를 트래킹해가면서 넣는다. 이때 start, to의 초깃값은 2배 길이의 배열의 딱 중간이어야함(그래야 최솟값만 들어가거나, 최댓값만 들어갈때도 배열이 터지지 않음) 소수판별 floor(...
OOP는 너무 거대한 개념이라 다 다루지는 못하지만 간단히만 알아보자 간단한 설명 OOP : 중심적 프로그래밍 패러다임. 현실 세계의 사물들을 객체라고 보고, 그 객체로부터 개발하고자 하는 애플리케이션에 필요한 특징들을 뽑아와 프로그래밍하는 것(추상화) 장점 OOP로 작성한 코드는 재사용성이 높다. ...
React v18의 정식 출시가 코앞에 있고, 가장 큰 변경점 중 하나가 서버사이드 렌더링에 관한 내용이라는 소식을 듣고 마침 SSR 에 대해 흥미가 있던 터라 한번 React v18의 주요 변경점이 뭔지 공부해보기로 했다. 먼저 기존의 React v17을 v18로 마이그레이션 하는 것은 문제 없다고 한다. 리액트 팀에서 이 부분을 특히 신경써서 만...
좋은 코드란 무엇일까? 일반적으로 좋은 코드라고 하면 다음 세가지를 얘기한다. 읽기 좋은 코드 테스트가 용이한 코드 중복이 없는 코드 그럼 왜 위 세가지가 갖춰진 코드를 좋은 코드라 하는 걸까? 그리고 어떻게 이 세가지를 지키며 코드를 작성할수 있을까? 왜 좋지 않은 코드가 생산되는가? 우리는 항상 좋은 코드를 작성하기 위해 노...
* 아무 표시 없이 사용하면 페이지에 있는 모든 요소가 대상 * { margin : 0; padding : 0; } 특정 요소의 모든 자식 요소에 적용할 수도 있음 #container * { border : 1px solid black; } 주의점 : 남발할 시 성능저하를 불러일으킴 #X id를 대상으로 삼음 #...
Declarative Effects import { takeEvery } from "redux-saga/effects"; import Api from "./path/to/api"; function* watchFetchProducts() { yield takeEvery("PRODUCTS_REQUESTED", fetchProducts); } fu...
Generator 문법 자바스크립트의 기능이며 Redux-saga의 핵심 기능이다. 함수를 특정 구간에 멈춰놓고, 원할때 다시 돌아가게 할 수 있음. 또 반환을 여러번 할수 있다. 예시 function* generate() { yield 1; yield 2; yield 3; return 4; } const generato...
소스코드 깃허브 링크 모델 소개 중국 도시별 미세먼지 PM10 농도와, 서울의 기온, 풍속, 습도를 가지고, 서울의 하루 뒤 미세먼지 PM10 농도를 예측하는 모델 서울의 기온, 풍속, 습도는 현재(중국 미세먼지 데이터 날짜와 일치)와 다음날(서울 미세먼지 데이터 날짜와 일치) 데이터를 모두 넣음. ...
데코레이터 패턴 하나의 코드를 다른 코드로 래핑하거나 javascript 함수를 래핑하는 방법 동일한 클래스의 다른 객체에는 영향을 주지 않고, 정적/동적으로 개별 객체에 동작을 추가할 수 있는 디자인 패턴이다. 문법 let variable = function(object) { obj...
알고리즘 한 점에서 x축으로의 범위를 정하고, 다른 점에서 y축으로의 범위를 정하는 방식으로 모든 두개의 점 조합으로 트래펄린을 설치한다. 코드 #include <iostream> using namespace std; int n, m, l, k; pair<int, int> s[110]; int max(int a,...
알고리즘 문제를 해석하면, 한 점에서 다른 한 점까지 가는데 최소경로를 찾는 문제로 해석할 수 있다. 따라서 다익스트라 알고리즘을 적용하면 쉽게 풀수있다. 이때 한 칸에 저장된 값은, 그 칸으로 접근하는 경로의 길이로 치환하여 품. 여담 문제 내에 다익스트라라는 꽤나 많은 힌트가 있었으나, dfs...
알고리즘 BFS 입력으로 들어온, 알려진 전후관계로 그래프를 만듦. 체크를 해야하는 원소 두개가 들어오면, 먼저 첫번째 거에서 bfs를 시작하여 두번째거가 나오면 첫번째가 앞에 있는 것이므로 -1를 출력 찾지못하면, 두번째에서 첫번째를 BFS로 찾음. 찾으면 1을 출력. 찾지못하면, ...
개요 yourlist 웹 리뉴얼 프로젝트에서 tailwind css를 사용하기로 결정하였고, create-react-app을 사용하여 리액트앱을 만든 후, tailwind css를 추가하였다. 이때 tailwind css는 먼저 css 파일을 컴파일 하고, 컴파일 이후의 css 파일을 import 하는 방식으로 동작한다. 따라서 매번 리...
Props ReactNative 에서 대부분의 컴포넌트는 매겨변수나 속성을 props로 전달함 Flutter에서는 매개변수가 있는 생성자에서 받은 속성을 final로 표시된 지역변수나 함수에 할당함 // Flutter class CustomCard extends StatelessWidget { Cus...
Flutter 위젯 Views View 컨테이너 React Native 에서는 View 가 컨테이너이고 Flexbox를 이용한 레이아웃, 스타일, 터치 핸들링, 접근성제어를 지원 Flutter에서는 Container나, Column, Row, Center같은 위젯 라이브러리의 핵심 레이아웃 위젯을 사용할 수 있음....
기본 앱 생성 IDE 에서 생성하는 방법 커맨드라인에서 생성하는 방법 $ flutter create <projectname> 앱 실행 IDE에서 run 클릭 최상위 디렉토리에서 flutter run 입력 import import 'package:flutter/material.dart'; import 'pa...
진입점 main() { // 항상 최상단 앱의 진입점 main() 이 있어야함. } 콘솔 print("hello world") 변수 dart 는 타입검사를 하는 언어 정적 타입 검사와 런타임 타입검사를 동시에 사용하며, 변수의 값이 변수의 정적타입과 항상 일치하는지 검사함. 타입 추론을 하기에 일부 타입표기는 생략가능 ...
개발 계기 코로나 전에 커피를 마시면서 자주 길거리를 걸어다녔는데, 항상 다 마시고 남은 빈 통만 들고 한참을 쓰레기통을 찾아다녔던 기억이 있었다. 그런데 학과 내에서 학교 생활에 도움을 줄 서비스를 개발하는 공모전을 하였고, 위 기억을 되살려서 학교 내 흡연장소, 쓰레기통의 위치를 알려주는 서비스를 개발해보기로 하였다. 서비스 소개 ...
서비스 소개 사용자가 원하는 유튜브 영상의, 원하는 부분만을 가지고 재생목록을 만들 수 있도록 하는 서비스 회원가입을 통해 회원이 될 수 있고, 회원은 재생목록을 무제한으로 만들 수 있지만, 비회면원 5개까지만 가능 i18n을 통한 글로벌 언어 제공 앱, 웹에서 모두 사용가능하도록 ...
1단계 : Starter Flutter app void main() => runApp(MyApp()); 처럼 화살표 함수 사용가능 한줄 함수에 화살표를 사용한다. 최상단 앱 : StatelessWidget을 상속받아 앱 자체를 위젝으로 만든다. Flutter에서는 정렬, 여백, 레이아웃 등 모든 것이 ...
알고리즘 모든 경우를 따지기 위해서 각 추가 구슬 반대쪽에 올라가는 경우, 저울에 안올라가는 경우, 구슬과 같은 쪽에 올라갈 경우를 모두 고려해야함 배낭문제를 응용하여, 추를 하나씩 모든 무게에 대해 검사를 한다. true이면 구슬 반대쪽 저울에 추만으로 만들 수 있는 무게라는 뜻. 현재 추를 사용하...
여러분은 완벽한 소프트웨어를 만들 수 없다 실용주의 프로그래머는 자신의 실수에 대비한 방어책을 마련한다. Topic 23 : 코드의 공급자와 사용자는 권리와 책임에 대해 동의해야한다 Topic 24 : 버그상황에서 헤어나오는 도중에 어떤 손상도 입히지 않도록 보장해야한다. Topic 25 : 확인을 쉽게하는 방법. 가정(assum...
Topic 16 - 일반 텍스트의 힘 일반 텍스트란? 인쇄 가능한 문자로 이루어지고, 정보를 전달하기에 적합한 형식을 갖추어야한다. 또한 사람이 이해할 수 있어야한다. 일반 텍스트 우유 커피 일반 텍스트가 아님 hlj;uijn bfjxrrctvh jkni’pio6p7gu;vh bjxrdi5rgvhj Field...
Topic 8 - 좋은 설계의 핵심 좋은 설계는 나쁜 설계보다 바꾸기 쉽다. ETC(Easy To Change)는 규칙이 아니라 가치 가치란 결정을 내릴때 도움을 주는 것이다. ETC는 가치로서 내제화되어야하며, 의식적으로 방금 한 일이 ETC 한지 항상 물어봐야한다. 일반적으로 상식선에서 추측이 가능하다. 하지만 결정하기 어려울때가 있는...
Topic 1 - 당신의 인생이다 변화를 피하지 말고 불만이 있는 것이 있으면 고치기 위해 노력하라 업무환경, 적성이 안맞으면 바꾸되, 너무 오래 노력하지는 말기 뒤쳐지는 기분이 들면 여가 시간에 공부하기 기회는 많고 적극적으로 행동해 그 기회를 잡아라 Topic 2 - 고양이가 내 소스 코드를 삼켰어요 실용주의 철학의 초석 중 하나...
발단 서비스를 운영하던 도중 CPU/Memory 사용량은 낮은데 사용자 응답이 매우 느려지는 상황이 발생하였다. 서비스는 쿠버네티스로 띄워져있었고, HPA metric으로 CPU와 memory가 걸려있었는데, CPU와 memory가 올라가지 않으니 scale-out도 발생하지 않아 적은 pod으로 계속 서비스 되고 있었다. 수동으로 pod을 3~...
next.js app router의 caching에 관해 공부한 내용입니다. Overview next.js 에서 제공하는 caching mechanism에는 다음과 같은 것들이 있다. Mechanism What Where Purpose Duration ...
Data sharing (Solving props drilling) next.js 13.4 이상 App router 기준으로 작성하였습니다. props drilling 예시 next.js에서 주로 발생하는 props drilling 형태는 다음과 같습니다. 먼저 필요한 데이터를 서버컴포넌트에서 fetch 합니다. API 노출 방지, 최적화...
웹페이지에서 사용자가 무언가를 입력하고 뒤로가기를 눌렀을때 다음과 같은 경고창을 띄우는 걸 본적이 있다. 이러한 스펙을 개발하기위해서는 다음과 같이 두가지 상황으로 나누어야한다. 새로고침/창닫기/링크이동(외부페이지 이동 or 링크 버튼 클릭) 뒤로가기 그렇다면 리액트에서는 구체적으로 어떻게 이 스펙을 구현할 수 있을지 알아보자 ...
Spec Swiper (ver 4.5.1) 안에 <video> 태그가 slide로 포함되어있음. 현재 가장 가운데 있는 slide 안의 video는 크기를 키우고, slide가 옆으로 이동하면 다시 원래 사이즈로 돌아가도록 함 Issue IOS 16.5 safari에서는 다음과 같...
let, const 키워드를 통한 변수선언 기존 자바스크립트에서는 var 키워드로만 변수선언이 가능했다. 하지만, let const 키워드를 추가하여 보다 예측가능한 코드를 작성할 수 있게 됐다. // es6 이전. // var는 재선언 가능 var a = "This is string"; var a = 1234; // ES6 이후 // let은 ...
알고리즘 구간합 정의 : i ~ j 까지의 구간합 = (1~ j 까지의 구간합) - (1 ~ i -1 까지의 구간합) 위 정의에 따라 우리가 구해야하는 (i ~ j 까지의 구간합) % m = 0 은 ((1~ j 까지의 구간합) % m - (1 ~ i -1 까지의 구간합) % m) % m 과 같음 ...
알고리즘 평범하게 BFS하면 되는데, 방문 표시를 어떻게 하느냐가 이번 문제의 관건이다. 난 각 기둥의 문자열 사이에 “/” 라는 문자를 추가하여 상태를 구분짓고, 이것을 set에 저장하였다. 이렇게 상태를 구분지어본 것은 처음이라, 코드를 짜면서도 계속 내 코드를 의심했다 코드 #incl...
알고리즘 a, b에서 b의 순서대로 정렬 1 2 1 1 이런식으로 입력이 들어오면, 1 2에서 1에 넣고 1 1에선 넣을 수가 없기 때문에. 정렬된 (a, b)를 앞에서부터 검사하는데, a에서 b까지 1씩 증가하면서 가능하면 책을 배정하고, b까지 검사했는데도 남아있는 책이없으면 패스한다. ...
paasta notification 회의 방법들 expo 서버로 보내는 방법 (https://docs.expo.dev/push-notifications/sending-notifications/) expo에서 제공하는 라이브러리를 사용하면 됨. but 자바 sdk를 제공하긴 ...
타입스크립트 연습 tsconfig.json compilerOptions:{ “outDir” : “./dist” // 컴파일된 파일 저장. expo 에선 안해도 될듯 } jsx -> tsx, js -> ts ...
알고리즘 괄호치기 / 는 앞에서부터 가까운 두 괄호를 묶음. 그다음 + - 로 마찬가지로 함. 양쪽에 모두 없으면 패스함 출력 여는괄호, 연산자는 스택에 넣기. 닫는 괄호가 나오면 여는괄호가 나올때까지 쭉 빼기. 알파벳은 그냥 출력. ...
EXPO 앱 google playstore 배포 app.json 수정 expo build:android -t app-bundle google play app signing 이 선행되어야함. https://docs.expo.dev/distribution/app-signing/ ...
react-boilerplate 설명 react-boilerplate 라는, 리액트 프로젝트를 처음 시작할때 create-react-app을 대체하여 사용하기에 아주 좋아보이는 프로젝트가 있다. https://github.com/react-boilerplate/react-boilerplate 상당히 많은 초기...
알고리즘 https://velog.io/@emplam27/%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-%EA%B7%B8%EB%A6%BC%EC%9C%BC%EB%A1%9C-%EC%95%8C%EC%95%84%EB%B3%B4%EB%8A%94-LCS-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-Longest-Comm...
알고리즘 내려올 수 있는 곳은 굉장히 한정되어있고, 순차적으로 가장 작은값을 or 가장 큰값을 구하기만 하면 되는 문제이기에 일차원 DP로 해결이 가능하다. 이런 종류의 문제를 “슬라이딩 윈도우” 라고 부르는 것 같다 코드 #include <iostream> using namespace std; int n, ansMax =...
알고리즘 양 선분이 평행할 경우, 또는 한 쪽이 x축에 평행하고, 다른 축이 y축에 평행할 경우엔 조건문을 통해 범위를 잘 검사하여 처리 나머지 경우엔 다음과 같은 방법을 사용한다. 첫번째 선분을 이루는 직선이 두번째 선분을 양분하고, 그 반대도 양분하면 두 선분은 교차한다. ...
알고리즘 일반적인 다익스트라로 푸는데, 풀면서 이전에 어디서 왔는지를 기록한다. 다익스트라가 끝나고, 끝에서부터 왔던길을 되돌아가며 경로를 찾아낸다. 코드 #include <iostream> #include <queue> #include <vector> #include <cstring> #de...
알고리즘 수를 두개 집합으로 나눔. 나눈 집합 각각에 대해 모든 경우를 살펴봐서 각 집합 내부에서 s에 도달한 횟수를 세고, 만들 수 있는 수와 그 수가 나온 횟수를 센다. 위에서 센 횟수로, 양 집합에서 만들 수 있는 수가 a, b이고, 이 a, b가 각 집합에서 나온 횟수를 c, d라고 하면, ...
알고리즘 1 -> v1 -> v2 -> n 과 1 -> v2 -> v1 -> n 중 어느것이 더 짧은지 확인하면 된다. 즉, 원점이 1일때, v1 일때, v2일때 다익스트라를 진행하고, 거기서 나온 거리로 위 거리를 계산하여 출력하면 된다. 코드 #include <iostream> #inclu...
알고리즘 푸는 방법은 bfs지만, 구현이 더 까다로운 문제이다. visit은 빨간구슬, 파란구슬의 위치를 동시에 기록하여 두 구슬 모두 같은 자리로 다시 가지 않도록 한다. 각 방향으로 기우릴때는 일단 한쪽을 먼저 보낸다고 가정하고, 실제로 먼저 보내는지 검사한 후 아니라면 다른쪽을 먼저 보낸다. 한쪽이 구멍에 먼저 빠지면, (-1,...
알고리즘 dp를 사용 save[101][101] 로 메모이제이션을 위한 배열을 선언 한 곳에는 이제까지 들어간 새로운 곡의 수, 한 곳에는 현재 깊이 원리 m == 0 일때, 현재 깊이 d에서는 이전 곡의 구성이 어찌됐든 간에, 현재~끝에 나와야할 곡의 구성의 수는 같다. ...
알고리즘 save[0] = 1로 초기화 i : 1~3 에서 j : i~m 까지 save[j] += save[j-i] 를 반복 원리 i = 1에서는 1로만 쭉 더한 것(3 = 1 + 1 + 1) 경우만 따짐. i = 2에서는 1로만 더한 것에 2를 ...
알고리즘 save[0][0] = 1 부터 시작해서, 모든 점을 순서대로 방문하며 자신의 위, 왼쪽 점들 중 자신에게로 올 수 있는 모든 점들을 save[i][j]에 저장한다. 코드 #include <iostream> typedef long long ll; using namespace std; int n, map[101][101...
알고리즘 (1,1)에서부터 순서대로 모든 점을 대상으로 visit (i -1, j), (i, j-1), (i-1,j-1) 이 가지고 있는 점 중 가장 큰 점을 visit(i,j) 에 저장한다. 코드 #include <iostream> using namespace std; int visit[1010][1010], n, m, m...
알고리즘 그냥 조건에 맞춰서 풀면 되는 문제이다. 가능한 모든 사각형에 대해 검사하고, pcl을 뽑아낸 다음에, 마지막으로 ‘다른 pcl에 포함되는 pcl’을 제거하고 출력하면 된다. ‘한 색은 연속된 지역이 하나이고, 다른 색은 두개 이상이어야한다. ‘ 라는 조건은 다음과 같이 하면된다. 인접한 같은 색에 대해서만 ...
기본 구조 사용자 인터페이스 브라우저 엔진 : 사용자 인터페이스와 렌더링 엔진 사이의 동작을 제어 렌더링 엔진 : 요청한 콘텐츠를 표시. HTML 을 요청하면 HTML과 CSS를 파싱하여 화면에 표시함. 통신 UI 백엔드 : 콤보박스와 창 같은 기본적인 장치를 그림. 플랫폼에서 명시하지 않은 일반적인 인터페이스로서 OS 사용자 인...
알고리즘 뱀이 성장하면서 생기는 가로직선, 세로직선을 따로 저장. 새롭게 생기는 직선이 이전에 저장된 직선에 걸리는지 확인. 이때, 직선은 정렬하여 뱀이 나아가는 방향에서 가장 가까운 직선에 걸리도록 하자. 여담 깔끔하게 구현하기에 매우 애를 먹었고, 가능하지도 않았다. 그만큼 분리하여 생각해야하는 조건들이 많고, 그렇기에 실...
알고리즘 페어링 쌍을 만들고, 사이클이 있는지 확인하는 작업을 모든 페어링 쌍을 대상으로 하면 됨. 헤멘 부분 사이클을 찾을때 같은 페어링쌍을 다시 방문하는게 아니라, 같은 점을 다시 방문하는지 확인해야함. check 를 언제 초기화해야하는지 헷갈림 -> 확실히하려면 매 시작점마다하면 됨. ...
알고리즘 BFS 사용 시작할때 C는 떨구고 시작. bfs를 진행하는데 왼쪽, 오른쪽, 중력 바꿔서 검사하고 떨군다. 떨어지는 도중에 D를 만나면, 만났다고 표시 -> 끝나고 바로 ans 업데이트 이때 visit은 해당 위치에서 해당 중력일때 최소 flip을 저장함 나는 ...
개발환경 만들기 필요한 것 : 안드로이드 스튜디오, expo, 안드로이드 emulator npm install -g expo-cli 안드로이드 스튜디오 설치 -> 설치 후 sdk도 설치 안드로이드 스튜디오을 키고, configuration에 들어가서 AVD manager을 누르고, cr...
알고리즘 모든 소를 대상으로 ‘길’이 있는 길로 다니지 말고 BFS를 함 다른 소를 만날때마다 count를 1씩 증가시키고, 한 소의 bfs가 다 끝나면 n - count를 ans에 저장 ans / 2를 출력 코드 #include <iostream> #include <list> #include <cstri...
알고리즘 브루트포스로 함. 서로 이웃한 정수끼리 연산을 하는 조합을 하는데, 모든 조합을 전부 다 돌린다. 숫자는 최대 10개이고, 브루트포스로 했을때 O(n!) 이므로, 충분히 시간안에 돌릴 수 있다. 코드 #include <iostream> using namespace std; long...
알고리즘 2933 미네랄과 상당히 유사한 문제이지만, “분리된 클러스터의 각 열중 맨 아래 부분이 아닌 부분이 다른 클러스터 위에 떨어질 수 있다”라는 조건을 하나 더 생각해야함. 막대를 던지고 클러스터가 분리되면 바닥에 닿았는지 판단. 닿지 않았다면 아래로 내리는데, 내려갈 수 있는 미네랄을 다 검사. 가장 적게 내려갈 수 있는 거...
알고리즘 크루스칼 모든 필드 사이의 거리를 계산하고, 양 쪽 필드의 번호와 거리를 벡터에 저장한다. 거리순으로 정렬하고, 크루스칼 알고리즘 시행 이때, 단순히 union-find 알고리즘으로 하면 find에서 시간초과가 난다. 따라서 set을 활용해서 크루스칼을 하면 된다. 헤맨 지점 set을 이용해서 할때, 서로 다른...
알고리즘 BFS로 하나씩 찾아갈 수 있지만, 나는 연결되어있는 타일을 그래프로 표현한 다음 BFS를 하였다. BFS를 할땐, visit을 -1로 초기화하고, 이전에 온 곳을 기록하는 형식으로 하자. 그러면 마지막에서부터 온곳을 탐색하며 가서 첫번째 타일까지 가면 된다. 코드 #include <io...
설치 yarn add @apollo/react-hooks apollo-boost graphql 사용법 GraphQL API로 요청을 보낼때는, 요청문을 axios나 fetch를 사용하여 POST 메소드로 보내야함. 하지만 Apollo를 사용하면, 위와같이 하지 않아도 된다. 먼저, Apollo ...
Qraph QL 이 해결할 수 있는 문제 over-fetching : 요청한 것보다 많이 보내줌. ex) username만 필요한데, 프로필 사진도 보냄 under-fetching : 하나의 작업을 위해 여러 요청을 보내게 하는 것. QraphQL에는 URL이 존재하지 않음. 하나의 엔드포인트만 있고, ...
알고리즘 겹치는 사각형을 각기 다른 집합으로 분류 + (0,0) 점이 속하는 집합이 있는지 확인 앞에서부터 겹치는 사각형을 확인하고, 겹치면, 큐의 맨 앞에 넣어서 DFS 방식으로 집합을 분류 매번 모든 사각형을 검사하는데, 이미 분류된 사각형은 다시 검사하지 않아도 됨. 이때 (0,0,0,0)인 사각형(사실은 점)을 1개 더 저장하...
알고리즘 DP 사용. bottom-up 방식으로 끝까지 간 후, 하나씩 올리면서 가장 큰 걸 반환 0<= i < j <= M 일때, array[i] == 0 이고, j == M이면 바꾸지 않음. 10 이하는 무조건 -1, 나머지는 0이 반환되면 한번도 끝까지 도달하지 못한 것이므로 K번 바꾸기 연산이 불가능한 것. 즉...
Junctions/Seoul 2021 해커톤 Junction 은 핀란드에서 시작된 국제 해커톤으로, 2박 3일동안 진행된다. Autocrypto, Microsoft, SIA, AWS game tech 4개의 기업이 파트너로 참가하고, 참가자들은 이 4개의 기업 중 하나를 자신이 참가할 track으로 선택하여 참여한다. 수상은 track ...
lottie 애니메이션 Junction 해커톤을 하며 lottie 애니메이션을 접하게 되었다. 간단히 코드로 불러올 수 있으며, json 파일로 불러올 경우 색상 변경 등의 커스터마이징도 가능하여 활용도가 높다. 불러오는 법(react 기준) npm install @lottiefiles/react-lottie-player ...
em : 부모의 단위에 배수를 더하는 것. body { font-size:14px; } div { font-size:1.2em; } 면 div엔 16.8px로 들어간다. 이때 부모의 크기에서 배수를 더하는 거라서, 자식마다 em을 써서 내려가면 크기는 계속 배수로 증가하게 된다. rem root의 단위에 배수를 더하는 것. ...
static 기본 속성 원래 있어야할 위치에 있다. top, left, right, bottom 으로 위치 조절 불가능 relative static 일 때의 위치를 기준으로 조절 가능. 겹치는 element 가 있으면, z-index로 결정한다. absolute position:static 을 가지고 있지 않은 ...
결과 AWS game tech 트랙 우승! 후기 해커톤 첫 참여였지만 좋은 팀원들과 함께해서 트랙 우승을 이루어내 기뻤다. front-end 참여하여 메인 기능과는 보다는 디자이너님이 만들어주신 뷰 구현에 힘을 쏟았다. 배운 것도 많았고, 더 공부할 것도 많이 보였다. 배운 것 tool 관련 ...
알고리즘 BFS로 가능한 경우를 찾아가면 된다. 그런데 주의점은, 뱀을 타는게 더 이득일 경우가 있다는 것만 주의하자 ex) 2 1 2 60 30 99 65 29 코드 #include <bits/stdc++.h> using namespace std; int N, M,...
알고리즘 DP 사용 앞에서부터 백트래킹처럼 조건이 맞을때 전진 만약 끝까지 갔으면 gotAns = true 설정하여, true이면 바로 종료. 만약 끝까지 안갔으면, save에 저장 이때 save[현재-2 문자][현재-1문자][남은 A][남은 B][남은 C] 로 함 현재 상태를 결정하는 건, 전전문자, 전 문자...
알고리즘 정렬 후 앞에서부터 검사 (이전까지 연속적으로 잴 수 있는 무게의 최댓값 + 1) 보다 현재 추가 더 무거우면 break. 최댓값 + 1이 잴수없는 최소의 값임. 코드 #include <bits/stdc++.h> using namespace std; int n, weights[1010]; int main() {...
알고리즘 BFS로 시작 정점부터, 이제까지 경로 중에 있었던 가장 큰 weight(bigest)와 이제까지의 weight를 모두 합한 값(length)을 저장해나가며 진행. 이때 visit을 표시할 때, true/false 값이 아닌, length을 저장. BFS를 진행할 땐, node에 저장된 length와 현재 로봇의 length와 ...
firebase cloud function에서 firestore와 storage의 이벤트트리거를 등록하는 예제는 firebase 문서에 자세히 설명되어있다. 여기서는 cloud functions에서 firestore와 storage에 접근하여 읽고 쓰는 법을 간단한 코드로 보여줄 것이다. firestore firebase ...
일반 노드에서의 환경과 같이 사용하면 된다. 홈페이지에 접속 후 스크린샷을 찍어 스토리지에 업로드하는 예시 const puppeteer = require("puppeteer"); const { Storage } = require("@google-cloud/storage"); const storage = new Storage(); rout...
이미 서버에 올라간 백엔드 API 와 로그인 작업을 하던 도중에, 백엔드에서 보내는 쿠키를 브라우저가 저장하지 않는 문제를 발견했다. 찾아보니 CORS 위반으로 생기지 않는 것이라고 하였다. 그럴때 해결방법은 두가지가 있다. package.json에 proxy 설정 추가 //package.json { ... "proxy" ...
MySQL 데이터베이스란 DBMS : 데이터베이스 관리시스템 RDBMS : 관계형 DBMS. 대표적으로 Oracle, mysql, mssql 등이 있음. Datagrip 사용 Datagrip : 데이터베이스를 위한 IDE. 학생인증을 하면 무료사용가능 프로젝트 생성 alt+insert 혹은 좌측 + 클릭 -> ...
Express 로 웹서버 만들기 6.1 익스프레스 프로젝트 시작 const express = require("express"); const app = express(); app.set("port", process.env.PORT || 3000); app.get("/", (req, res) => { res.send("Hello, Ex...
http 모듈로 서버 만들기 4.1 요청과 응답 이해하기 - req : 요청에 관한 정보 - res : 응답에 관한 정보. - .writeHead : 헤더. 응답에 대한 정보를 기록하는 메서드. - 첫번째 인수 : 코드 - 두번째 인수 : 응답에 대한 정보를 알림. - .write :...
8980 택배 풀이(그리디) 1. 각 도착지별로 정보를 따로 관리함.(같이해도 되긴함) 2. 도착지 1~N번까지 입력받은 C로 트럭 용량을 초기화함. 3. 도착지 2번부터 정보를 하나씩 뽑아가며 검사. 시작지점~현재 도착지-1 까지에서의 최소값을 뽑고, 그만큼을 2의 배열에서 빼줌.(물론 그 최솟값이 현재 정보에서의 택배량보다 많으면 택배량으로 제...
패키지매지저 package.json 설치한 패키지의 버전 관리 노드 프로젝트를 시작하기 전에 무조건 package.json부터 만들고 시작해야함. npm init 으로 프로젝트 생성하면 만들어짐. scripts npm 명령어를 저장해두는 부분. 저장된 명령어를 npm run 으로 실행한다. ...
Node 3장 REPL 사용하기 노드 콘솔은 REPL이라하는데 이유는 Read : 입력한 코드를 읽고 Eval : 해석하고 Print : 결과물을 반환하고 Loop : 종료할 때가지 반복함. 터미널에 node를 입력함으로서 접속가능 간단한 명령어 수행 JS...
13303 장애물 경기 알고리즘 1. 장애물을 x 좌표 순으로 정렬. 도착지점의 Y좌표와 걸린 길이(y축 이동만 고려)를 저장하는 set을 선언 후, {startY, 0} 를 추가 2. 장애물을 하나씩 꺼내며, 그 장애물에 걸리는 원소만 set에서 꺼내고 하나씩 위로갔을때 거리와 아래로 갔을때 거리를 계산 이때, 꺼낸 것이 10개여도 장애물...
9095 1,2,3 더하기 코드 #include <iostream> using namespace std; int tc; long long save[12]; long long dp(int n); int main() { cin >> tc; while (tc--) { int n; cin >> n; ...
5373 Samsung sw test 코드 #include <iostream> #include <cstring> #define MAX_ROTATE 1000 #define MAX_TESTCASE 100 #define WHITE 100 #define YELLOW 200 #define RED 300 #define ORANGE 400...
3568 iSharp 코드 #include <iostream> #include <string> using namespace std; string def, append; char input[130]; void print(); int main() { cin.getline(input, 130); int i = 0; w...
2623 MusicPropram 코드 #include <iostream> #include <vector> #include <list> #include <cstring> #define MAX_SINGER 1000 #define MAX_PD 100 using namespace std; typedef str...
2473 Three Liquid 코드 #include <iostream> #include <algorithm> #include <set> #define MAX_LIQUID 5000 using namespace std; int liquid[MAX_LIQUID]; int numOfLiquid; int threeLiq...
20058 Samsung sw test 코드 #include <iostream> #include <list> #include <cstring> #define MAX_WIDTH 64 #define MAX_COMMAND 1000 using namespace std; typedef struct Location { i...
20057 Samsung sw test 코드 #include <iostream> #define MAX_WIDTH 499 using namespace std; int map[MAX_WIDTH][MAX_WIDTH]; bool visit[MAX_WIDTH][MAX_WIDTH]; int width, amountOfSand = 0; int t...
20056 Samsung sw test 코드 #include <iostream> #include <cstring> #include <vector> #define MAX_WIDTH 50 using namespace std; typedef struct Fire { int mass; int direction; //...
19238 Samsung sw test 코드 #include <iostream> #include <list> #include <vector> #include <algorithm> #define MAX_WIDTH 20 #define MAX_CUSTOMER 400 #define CUSTOMER 123 usi...
19236 Samsung sw test 코드 #include <iostream> #include <cstring> #define WIDTH 4 #define SHARK 100 #define BLANK -1 using namespace std; typedef struct Fish { int num; int row; in...
1799 bishop 코드 #include <iostream> #include <cstring> #define MAX_N 10 using namespace std; int map[MAX_N][MAX_N]; bool tempMap[MAX_N][MAX_N] = { 0, }; int width, maxCount = 0; voi...
17825 Samsung sw test 코드 #include <iostream> #include <vector> using namespace std; typedef struct Map { int score; int next; int blueNext; } Map; int dice[10]; Map map[33] = { {...
17822 Samsung sw test 코드 #include <iostream> #include <cstring> #include <vector> #define MAX_BOARD 50 #define MAX_TURN 50 using namespace std; int board[MAX_BOARD][MAX_BOARD]...
17779 Samsung sw test 코드 #include <iostream> #define MAX_WIDTH 21 using namespace std; int map[MAX_WIDTH][MAX_WIDTH]; int width; int minDifference(); int getMin(int d1, int d2, int x, in...
1748 수 이어쓰기 1 코드 #include <iostream> using namespace std; int N; int main() { cin >> N; long long result = 0; int d = 1, count = 0; while (N / d != 0) { // 1~9 : 1 / 10~99 :...
17142 Samsung sw test 코드 #include <iostream> #include <cstring> #include <vector> #include <list> #include <algorithm> #define MAX_WIDTH 50 #define WALL 1 using nam...
17140 Samsung sw test 코드 #include <iostream> #include <algorithm> #include <cstring> #include <vector> #define MAX_NUM 101 using namespace std; typedef struct Cell { in...
1629 곱셈 코드 #include <iostream> using namespace std; long long A, B, C; long long result = 1; int main() { cin >> A >> B >> C; while (B != 0) { if (B % 2 == 1) { ...
16236 Samsung sw test 코드 #include <iostream> #include <list> #define MAX_WIDTH 20 using namespace std; typedef struct Location { int row; int col; int distance; bool operator &l...
16235 Samsung sw test 코드 #include <iostream> #include <algorithm> #include <vector> #define MAX_WIDTH 10 using namespace std; typedef struct Tree { int age; bool isAlive; b...
16234 Samsung sw test 코드 #include <iostream> #include <list> #include <cstring> #define MAX_WIDTH 50 using namespace std; typedef struct Location { int row; int col; } Locat...
15686 Samsung sw test 코드 #include <iostream> #define MAX_WIDTH 50 #define MAX_CHIKEN 13 using namespace std; typedef struct Location { int row; int col; } Location; int width, maxChike...
15685 Samsung sw test 코드 #include <iostream> #include <vector> #define MAP 101 #define MAX_DRAGON 20 #define MAX_GENERATION 10 using namespace std; typedef struct Location { int ro...
15684 Samsung sw test 코드 #include <iostream> #define MAX_VERTICAL 10 #define MAX_HORIZONTAL 30 #define MAX_LINE 270 using namespace std; typedef struct Ladder { bool left; bool right; }...
15683 Samsung sw test 코드 #include <iostream> #include <cstring> #define MAX_WIDTH 8 #define WALL 6 #define BLINDSPOT 0 using namespace std; typedef struct CCTV { int row; int col;...
15486 퇴사2 코드 #include <iostream> using namespace std; int N, T[1500000], P[1500000], DP[1500000]; int dp(int deep); int max(int a, int b) { return a > b ? a : b; } int main() { ios:...
14891 Samsung sw test 코드 #include <iostream> #include <cstdio> #define MAX_ROTATE 100 #define LEFT 6 #define RIGHT 2 using namespace std; int command[MAX_ROTATE][2]; int gear[4][8];...
14890 Samsung sw test 코드 #include <iostream> #include <cstring> #define MAX_N 100 using namespace std; int map[MAX_N][MAX_N]; int width; int need; int checkEveryArr(); bool checkSi...
14889 Samsung sw test 코드 #include <iostream> #include <cstring> #define MAX_WIDTH 20 using namespace std; int numOfPeople; int map[MAX_WIDTH][MAX_WIDTH]; int minDifferenceBetweenTw...
14888 Samsung sw test 코드 #include <iostream> #define MAX_NUM 11 using namespace std; int num[MAX_NUM]; int numOfNum; int operators[4]; // + - * / int operatorPerm[MAX_NUM - 1]; // 1 : +, ...
14863 서울에서 경산까지 알고리즘 (dp) 1. dp를 평범하게 진행. dp배열은 dp[101][100001] 로 앞에는 현재 위치, 뒤에는 시간 2. 시간이 맞으면 진행하되, 안맞으면 result 를 초기화해둔 -20000000이 그대로 있음. 3. 0보다 낮으면, 현재 시간포함 0초까지 -20000000로 초기화. 같은 상태에 더 낮은 시간...
14503 Samsung sw test 코드 #include <iostream> #define MAX_WIDTH 50 using namespace std; int direction; int location[2]; int map[MAX_WIDTH][MAX_WIDTH]; int height, width; int robot(); bool...
14502 Samsung sw test 코드 #include <iostream> #include <list> #include <cstring> #define MAX_WIDTH 8 using namespace std; typedef struct Cell { int row; int col; } Cell; int...
14501 Samsung sw test 코드 #include <iostream> #define MAX_DAY 15 using namespace std; int day; int time[MAX_DAY]; int proceeds[MAX_DAY]; int DP(int d, int proceed); int max(int a, int b);...
13460 Gold 2 코드 #include <iostream> #include <algorithm> #include <cstring> #define MAX_WIDTH 10 #define MAX_DEEP 10 using namespace std; char map[MAX_WIDTH][MAX_WIDTH]; int w...
12865 평범한 배낭 코드 #include <iostream> using namespace std; int numOfObject, weight, DP[101][100001]; int main() { cin >> numOfObject >> weight; for (int i = 1; i <= numOfO...
9527 1의 개수세기 알고리즘(수학) 1. 2^n 마다 규칙이 있음 2. f(n)을 2^n ~ 2^(n+1)-1 에서의 1의 개수라고 한다면, f(n) = 2^n + f(i) ( 0 <= i <= n-1 ) 이 성립한다. 3. 그리고 들어오는 수 A,B에 대해 (1~B 까지의 1의 개수) - (1~A-1 까지의 1의 개수) 를 하면 ...
9466 Term project 알고리즘 (DFS, 그래프) 1. 각 학생들이 가리키는 학생을 저장한 student 배열, cycle에 몇명이 있는지 체크하는 cycleCcount 변수, 사이클이 형성됐는지 확인하는 cycleCheck bool형 배열. 검사중인 학생들을 저장하는 q배열 2. 첫번째 학생부터 검사 -student가 -1 이면...
9328 key 알고리즘(BFS, 구현) 1. 방문한 곳을 체크하는 check 이차원 배열, 키를 저장하는 key 배열, 닫힌문을 저장하는 closedDoor 벡터가 필요 2. 먼저 키 배열은 26개의 원소로 이루어진 bool 자료형 배열로 선언. 각 알파벳에 해당하는 키가 들어오면 1을 저장한다. 3. 방문가능한지 체크하는 checkCell 함수...
9252 LCS2 알고리즘(최장 공통 부분 수열) 1. LCS 알고리즘 사용하면 됨 구현법 1. 문자열 입력 받을 땐. cin.getline(char *c, size) 넣으면 된다. 코드 #include <iostream> #include <cstring> #define MAX_LENGTH 1000 using nam...
7579 app 알고리즘(배낭정리, DP) 1. 배낭정리 응용. 최대 비용을 가방에 담을 수 있는 최대 무게로 보고, 메모리를 가치로 본다 2. 이렇게 2차원 배열을 완성하고, 필요한 메모리 이상이며 비용이 최소인 칸을 판별하고 출력하면 된다. 구현법 1. 최대 앱 개수는 100개이므로, 101행, 앱 당 최대 비용은 100 이므로 10001...
7453 four Integer’s sum should be zero 알고리즘(정렬, 이분탐색) 1. 앞 두개 정수의 합 배열, 뒤 두개 정수의 합 배열을 만듬.(배열 개수^2 가 합 배열의 길이) 2. 두 배열을 정렬 3. 앞 합 배열의 원소를 하나씩 빼며 검사 -> 뒤 합 배열에서, upper_bound - lower_bound 값이, 현...
6087 레이저통신 알고리즘(BFS) 1. visit 배열을 int로 선언. 이제까지 온 것들의 거울 개수를 저장 2. 갈 수 잇고, visit에 저장된 거울 개수와 같거나 작으면 이동 시킴 주의점 같은 레이저에 도달하지 않기위해 설정한 row != start.row && col != start.col 은 작동하지 않음 ->...
6064 카잉달력 알고리즘(수학) 1. n 을 M과 N으로 나누었을때 나온 수가 x와 y 이면 된다. 단, 나누었을때 나오는 수는 0~M-1 or N-1인데 문제에선 1~M, 1~N 까지이므로 이걸 고려해야한다. 2. 하나씩 증가시켜가면서하면 너무 오래걸리니, M과 N 중 더 큰수를 더하는 수로 삼고, 그것과 연결된 수부터 시작한다(M-x, N-...
5014 스타트링크 알고리즘 (BFS) - 직선으로의 BFS 를 사용하면 됨 - DP를 사용하면 시간초과가 발생함. - 도달시 다 종료한다고 해도, 그게 최소로 간건지 몰라서 결국 더 검사해야함. 코드 #include <iostream> #include <list> using namespace std; list<...
4991 로봇청소기 알고리즘(BFS, 브루트포스) 1. 구현이 더 중요한 문제. 2. 그냥 시작 + 각 더러운 곳(DT) 에서 다른 DT로의 최소 거리를 저장한 2차원 배열을 BFS로 만들고 3. 시작부터 모든 경로를 탐색하여 최소 거리를 뽑아내면 됨. 4. 방문 할 수 없는지 판별은 시작에서 갈 수 없는 DT가 있는지 확인하면 됨 구현 1....
4811 알약 알고리즘 (dp) 1. 하나의 완전한 알약을 one, 반쪽 알약을 half 라고 하면, dp[1001][1001] 를 선언하고, one, half를 기준으로 dp를 저장함 2. dp를 진행하면서 밑으로 내려가면서 one이 1개 이상이면 1 줄이고 half 1 증가하고 밑으로 내려갈 수 있고, half가 1개 이상이면 마찬가지로. ...
다음과 같은 요구사항을 가지는 웹페이지를 개발하고 있었다. swiper로 여러 슬라이드를 띄움 슬라이드 내에는 영상이 존재하고, 각 영상은 자동으로 재생되어야함. 단순히 swiper를 연동하고 video 태그에 autoplay 속성을 주면 될거라 생각하여 다음과 같이 코드를 작성했었다. <li className="swiper-sl...
## 인덱스란? DBMS에서 데이터베이스 테이블의 모든 데이터를 검색하여 데이터를 찾기에는 시간이 오래 걸리기에, 데이터의 칼럼의 값과 그 데이터가 저장된 레코드의 주소를 키와 값의 쌍으로 만든 것. DBMS의 인덱스는 항상 정렬된 상태를 유지하기 때문에, 원하는 값을 탐색하는데는 빠르지만, 추가/삭제/수정에는 쿼리문 실행 속도가 느려진다.(작업...
딥링크는 웹사이트에서 사용자 기기에 설치된 앱을 URI로 실행시킬 수 있도록하는 기술이다. 딥링크의 세가지 유형 이러한 딥링크에는 세가지 유형이 있다. URI Scheme (초기 형태) 보완 Universal Link (IOS) App Link (Android) URI Scheme 앱...
BFCache 사용자가 브라우저 내에서 뒤로가기/앞으로가기를 할 때 이전 페이지를 자바스크립트 heap 영역까지 전체 캐싱하여 메모리에 저장하는 것 HTTP 캐시는 리소스만을 캐시하고 JS 작업까지 캐시하지 않기에 BFCache보다 빠르지 않다. BFCache 작동을 판단할 수 있는 API pageshow, pagehide pag...
ios 모바일에서 새로고침시 현재 스크롤 위치를 고정하기 위해 다음과 같은 코드를 사용하였다. if (sessionStorage.scrollPosition) { window.scrollTo(0, sessionStorage.scrollPosition); } window.onbeforeunload = function () { sessionSto...
State 변경 시 어떤 일이 벌어질까? 리액트의 함수형 컴포넌트는 최초에 한번 실행이 되면서 초기값으로 설정해놓은 상태를 기억한다. const [state, setState] = useState(0); 이후 setState가 호출되어 상태가 변경된다면 다시 함수형 컴포넌트가 실행되고 virtual DOM을 리턴한다. 그리고 이전에 리턴했던 v...
타입 스크립트 2.8부터 다음과 같은 조건부 타입을 사용할 수 있다. T extends U ? X : Y 뜻은 T가 U의 서브타입이거나 같은 타입이면 X, 아니면 Y 타입을 할당한다는 것이다. T가 유니온 타입일 경우 다음과 같이 T가 유니온 타입일 경우가 있다. type T = "A" | "B" | "C" 이러한 경우엔 분배법칙이 성립...
Javscript 메모리 관리 이해하기 Garbage collector 자바스크립트 엔진은 더이상 사용하지 않을 메모리를 놓아주기 위해 garbage collector를 사용한다. garbage collector(GC)는 앱에서 더이상 사용하지 않을 객체를 찾아내고 삭제한다. 따라서 GC는 앱의 object와 변수를 계속 모니터링하고 어떤 것이 여...
typescript 5.0이 나왔다고 하여 간단히 어떤 기능들이 추가되었는지 살펴보았다. 자세한 내용은 Typescript 5.0 번역에서 확인 가능하다. 데코레이터 데코레이터는 재사용 가능한 방식으로 클래스와 그 멤버를 사용자 정의하는 ECMAScript의 기능이다. 데코레이터는 이전부터 지원되었으나 Typescript 5.0부터는 공식 기능으로...
AppDir next.js에서 layout과 routing 경험을 개선시키고 React 최신 기술을 지원하기위해, next.js 13부터 지원하는 디렉터리 방식. 기존의 pages 디렉터리를 대체한다. 23년 04월 기준으로 아직은 베타버전으로 프로덕션에서 사용하는 건 추천하지 않는다고 한다. 하지만, 좋은 기능들이 많기에 학습해봐도 괜찮을 거 같...
4386 make constellation 알고리즘(MST) 1. 모든 별들 사이의 거리를 구한 다음에, 두 별의 위치, 거리를 저장한 구조체 배열을 거리순으로 오름차순 정렬 2. 구조체 배열에서 하나씩 빼가며 크루스칼 시행 -> edge == numOfStar -1 이면 중지 후 출력 코드 #include <iostream>...
3197 백조의 호수 알고리즘(구현) 처음 방법 1. 한 백조에서 BFS 실시하여 다른 백조를 만날 수 있는지 검사 2. 전체 맵을 검사해서 녹일 수 있는 걸 녹임 3. day 추가하고 다시 1부터 -> 시간이 너무 걸림. 특히 맵 초기화하는 부분이 많이 걸림 두번째 방법 1. 1번은 유지 2. 녹을 수 있는 얼음만 저장한 q에서 ...
3190 Samsung sw test 알고리즘 1. 그냥 대가리 옮기고 꼬리 잡히는지, 칸 밖인지 확인하고, 또 사과있는지 확인하고, 또 시간이 바꿀때가 됐는지 확인 2. 뱀 몸은 vector로 저장 / 사과 위치는 2차원 bool 배열로 저장하여 메모리랑 참조시간 아낌. / 시간은 Direction 구조체에 저장하고, directionInde...
2933 미네랄 알고리즘(구현, 시뮬레이션) 1. 들어온 위치의 미네랄을 지움 2. 지운 위치에서 상하좌우에 인접한 칸들을 root로 BFS 시행 -> 바닥에 닿는 칸이 있으면 공중에 뜬 클러스터가 아님 3. 공중에 뜬 클러스터이면 BFS 시 넣은 칸들을 열순, 열이 같으면 행이 큰 순으로 정렬 4. 각 열별로 가장 밑에 있는 칸만 검사하여 ...
2931 가스관 알고리즘(구현) 1. M에서 시작해 갈 수 있는 방향으로 가다가 빈칸을 마주하면 스탑. 만약 빈칸이 없으면 아예 처음부터 연결이 안된 것. 이때는 Z 부터 시작해 빈칸을 찾는다. 2. 빈칸을 찾으면 빈칸 주변을 검색. 인접한 칸에 바로 연결되는 파이프가 있으면 그 칸을 true로 표시. 표시된 것에 따라 빈칸에 넣을 수 있는 가...
2887 planet tunnel 알고리즘(정렬, MST) 1. 모든 행성들의 x좌표, y좌표, z좌표를 꺼내 따로 저장하고, 오름차순으로 정렬 2. 정렬한 것에서 인접한 것끼리 비용을 계산, (인접한 점 두개 + 비용)을 구조체로 n-1개의 원소를 가지는 배열 3개를 선언하고 집어넣음 3. 그 구조체배열 3개는 비용을 기준으로 오름차순으로 정렬 ...
2568 전기줄 알고리즘(LIS) 1. LIS를 구하면 그것들이 겹치지 않고 최대로 연결가능한 전깃줄들이다. 2. 따라서 LIS를 구하고 전체 전깃줄에서 LIS를 빼면 빼야하는 전깃줄의 수와 전깃줄의 종류가 나오게 된다. 코드 #include <bits/stdc++.h> #define MAX_WIRE 100001 using nam...
2529 부등호 알고리즘(브루트포스, 백트래킹) 1. 모든 경우를 탐색하되, 앞에서부터 하나씩 채워가면서 재귀형태로 하면 백트래킹도 적용하기 쉽다. 2. 조건에 맞는 경우만 탐색하면 됨. 3. 낮은 거 먼저 탐색하도록하면 굳이 뭘 저장할 필요없이 맨처음것만 minimum에 저장하고, 제일 나중 것을 maxnimum에 저장하면 된다. 코드 #i...
2342 Dance Dance Revolution 알고리즘(DP) 1. 왼발 위치, 오른발 위치, 명령 번호를 기준으로 dp 자료를 만듬 dp[5][5][MAX_COMMAND] 2. 명령과 같은 칸에 있을 경우 그대로, 다른 위치에 있을 경우 가능한 위치엔 전부 옮기는 식으로 DP 시행. 코드 #include <iostream> ...
2252 줄세우기 알고리즘(위상정렬) 1. 그냥 위상정렬하면된다. 구현 1. Student 구조체 : beforeCount : 이전에 몇개있는지 셈, next : 큰 학생들 나열, isChecked : 라인에 넣어졌는지 확인 2. 처음에 beforeCount가 0인 학생들을 큐에 넣고, isCheked에 체크함 3. 하나씩 큐에서 빼면서 아래...
2239 sudoku 알고리즘(백트래킹) 1. 칸을 하나씩 탐방하면서, 0으로 기록돼있다면 수직, 수평, 3x3사각형을 검사하여 가능한 숫자를 하나씩 뽑아서 넣고 다음 칸 검사 2. 만약 0으로 기록되지않은 칸으로 갔다면 다음칸으로 넘겨주되, 마지막 칸일 경우 스도쿠가 완성된 것이므로 true를 반환한다. 3. 마찬가지로, 넣고 다음 칸으로 이동하...
2186 문자판 알고리즘(DFS, DP) 1. 문자판을 주어진 조건대로 순회하되, 결과값이 int 안이라는 걸보고 엄청 클 수도 잇다는 걸 예측 or 빙글빙글 계속 돌 수 있으니 DP가 잇어야겠다고 예측 2. DP를 DP[r][c][d] 로 구현하되, -1로 초기화를 시키고, 0인것도 기록 -> 문자열이 아예 없을 수도 잇으니 0도 기록하여 ...
2166 areaOfPolygon 알고리즘(기하학) 1. 사선정리 사용 구현법 1. 최대 4000000000000이 나올 수 있으므로, int대신 long long, float은 쓰지말고 double로 통일 시킨다. 2. double은 최대 15자리수를 표현가능하므로, 위 값도 충분히 들어갈 수 있다. 코드 #include <ios...
2151 거울설치 알고리즘 (BFS) 1. 자기 방향으로만 쭉 가다가 ! 를 만나면 자기방향 + 양옆으로 이동. 양옆으로 이동할 땐 거울을 설치하는 것이므로 거울 + 1. 2. 이때 visit으로 이미왔던곳을 안가면, 다른 루트로 가는 빛은 중간에 끊기기에, visit에 빛이 그곳에 도착했을 때의 거울의 개수를 저장함. 그리고 다음 빛이 그곳에...
2143 sumOfTwoArray 알고리즘(이분탐색, 누적합) 1. A배열은 그대로 두고, B 배열은 가능한 모든 누적합의 집합을 만들고, 그것을 정렬함 -> 이때 그냥 배열에 집어넣으면 최대 500500개의 원소가 있어서 메모리에서 박살나고, 찾는데 시간도 박살남 -> 난 set을 택했음 -> Pair 구조체를 선언해서...
2098 TSP 알고리즘(외판원 순회, DP, 비트마스크) 1. 비트마스크로 각 비트마다 하나의 도시라고 치고, 검사를 함. 2. 방문하지 않았고, 갈수 있는 도시를 방문하는 식으로 끝까지감. -> 끝까지 갔을 때 다시 돌아갈 수 있는 길이 있으면 그 값 반환, 없으면 IMPOSSIBLE 반환 -> 그 전 재귀로 돌아와서 가장 최솟값...
2056 task 알고리즘(위상정렬) 1. Task 구조체를 선언하여, time : 현재 task가 걸리는 시간을 저장 / timeTaken : 현재까지 오는데 선행으로 필요한 작업을 수행하면서 걸리는 시간 중 가장 긴 시간 저장 next : 다음으로 이어지는 작업들을 저장 2. Task 구조체 배열을 앞에서부터 검사 -> 현재 tas...
20055 Samsung sw test 알고리즘 (구현) 1. durability와 isThereRobot 변수로 구성된 Cell 구조체로 컨베이어 벨트를 만듦 2. 무한 루프 안에서, 이동시키고 -> 내리는 위치 로봇빼고 -> 로봇이동 시키고(이동시 내구도 1감소) -> 내리는 위치 로봇빼고 -> 올리는 위치 로봇 올리고(내...
1987 Alphabet 알고리즘(백트래킹) 1. 어떤 알파벳을 검사했는지 기록하는 건 check[26] 배열을 선언하고, 각 알파벳에서 65 값을 빼서 각 자리로 접근한다.('A' - 65 == 0) 2. 인접한 칸을 검사하고, 가능하면 check 표시하고 인접한 칸으로 이동. 안되면 돌아와서(Back Tracking) 다른 인접한 칸 검사 3....
1956 운동 알고리즘(플로이드 워셜) 1. 문제 파악 : 그래프 상의 어떤 점들 집합이건 최소로 사이클을 이루는 집합이면 됨 2. 그래프 관련 알고리즘 1. 다익스트라 : 출발점에서 모든 정점까지의 거리 -> 해당 x 2. 밸만포드 : 다익스트라와 마찬가지 3. MST : 최소신장트리 -> 사이클은 감지할 수 있으나, 그것이 최소...
19235 모노미노도미노 알고리즘(구현) 1. 파란 맵과 초록 맵을 따로 만듬.(bool 형으로 해서 true면 블록이 있고, false면 없는 거로 취급) 2. 매 실행마다 블록을 잘 놓고 -> 업데이트 하면서 점수 얻고 -> 연한부분 있으면 당긴 다음에 -> 다음 실행 3. 실행마다 얻은 점수를 잘 기록해서 리턴함. 그리고 남은...
1865 웜홀 코드 #include <bits/stdc++.h> using namespace std; int tc, N, M, W, road[501][501]; long long d[501]; bool check[501][501]; vector<int> connect[501]; bool belmanford(); int ...
1806 partial sum 알고리즘 (브루트포스) 1. 길이를 1부터 N까지 검사 2. 한 길이를 검사할 때 다음을 실행 1. 수열의 처음부터 길이만큼 더하고 sum에 저장, 첫번째를 따로 first에 저장. -> S를 넘는지 확인하고 안넘으면 2 실행 2. 수열의 (길이)번째부터 검사. 위에서 구한 sum에서 first를 빼고, 현재...
17837 새로운게임2 Samsung sw test 알고리즘(구현) 1. 색깔을 저장한 map, 말을 저장하는 3차원 배열 맵(각 칸마다 4칸만 있으면 됨), 각 칸에 말이 몇개있는지 저장하는 인덱스맵 2. 턴을 계속 진행함. 각 말을 순차적으로 검사함. 이때 각 말들을 몇 번 검사했는지 저장하는 temp 배열을 생성. 방향과 색깔에 맞춰 이...
1753 최단경로 알고리즘 1. 다익스트라 코드 #include <iostream> #include <queue> #include <vector> #define INF 2000000000; using namespace std; int V, E, s, length[20001]; vector<pair<...
17404 RGB Distance 2 알고리즘 : DP 1. bottom-top 방식으로 품 2. DP 구성 : (현재 깊이, 이전에 고른 색깔)칸에 현재 깊이에서의 최솟값 저장. 3. DP 작동 a. 첫번째 집은 for문으로 하나씩 들어감. b. 두번째 집부터 이전에 고른 색이 아닌 색으로 이동 c. 마지막집 + 1에 도착하면 0을 리턴 ...
17144 Samsung sw test 알고리즘 1. 기존 map에서 미세먼지가 있는 부분만, 기존에 있던 미세먼지만 확산시키는 게 관건 2. 따라서 tempMap을 만들어서 map을 복사한 다음에, map에 있는 미세먼지 양을 받아서, tempMap에 확산시키고, 다 확산하면 tempMap을 map에 복사하고 순환하여야 한다. 3. 자꾸 갱신되는...
16954 움직이는 미로탈출 알고리즘(BFS) 1. q와 nextq를 선언 2. q엔 현재 노드를 저장. 하나식 꺼내서 이동가능한 인접 칸을 nextq에 추가. 3. 다 추가하면, 벽을 한칸 내림 4. 이후 q에 nextq를 넣고, nextq는 비운채 다음 루프 시작. 5. 루프 중에 q에서 꺼낸 노드가 벽이 있는 칸이라면 추가안하고 다음 노드로,...
16946 벽부수고 이동하기 4 알고리즘 (BFS) 1. 각 맵의 빈공간마다 각자의 크기를 BFS로 구함 2. 이때, 각자의 id를 지정하여 같은 집합에 속하면 같은 id를 갖도록 하자 3. BFS가 끝나면 각 벽을 검사 -> 주변에 인접한 모든 빈공간의 아까 구한 크기를 모두 더하고 자기자신 + 1해서 리턴 -> 이때, 주변에 인접...
16724 피리부는 사나이 알고리즘 (DFS) 1. 맵에 있는 서로 이어져있는 그래프의 개수를 세면 됨. 2. visit을 만들어, 이미 검사한 그래프의 원소엔 true를 표시한다. 그리고 tempVisit을 만들어, 현재 검사하고 있는 그래프의 원소에 true를 표시한다. 3. 먼저, 첫번째 셀부터 검사하지 않았으면 DFS를 실시한다. ->...
16566 카드게임 알고리즘(이분탐색, 정렬, 분리집합, 세그먼트트리?) 1. 고른 카드를 버킷정렬함(400만개이므로 버킷정렬이 훨씬 빠르다. sort는 NlogN) 2. 범위를 저장하는 set<pair<int,int>>을 선언하고 첫 범위를 넣음(0-m) 3. 철수가 뽑은 카드의 수가 저장된 범위의 끝의 수보다 작을 때의 범...
16562 친구비 알고리즘 (union find) 1. unionfind 를 구현하되, 루트에 친구비가 적은 것이 오도록함 2. 루트만 골라 친구비를 정산한다. 코드 #include <iostream> #include <vector> #include <cstring> #include <algorithm&g...
1655 가운데를 말해요 내 방식 (multiset) 1. 멀티셋으로 가운데를 트래킹해가면서 구함 2. 첫번째 원소를 넣고, s.begin()으로 첫번째 iter를 middle로 받고 그대로 출력 3. 두번째부턴 middle과 같은 원소가 들어오면, s.insert(s.upperbound(*middle), input) 으로 가장 앞에 넣음 아...
1647 split town 알고리즘(MST) 1. MST를 만들고, 가장 거리가 긴 길을 빼면 된다. 2. n개의 노드에 대해 n-1개의 간선만 연결되어있으므로, 1개만 빼면 딱 두개로 나눌 수 있는데, 뺀다면 가장 거리가 긴 길이기 때문이다.(2개 이상 빼면 3개이상으로 나눠짐) 코드 #include <iostream> #inc...
1644 소수의 연속합 알고리즘(에라토스테네스의 체, 두 포인터) 1. 에라토스테네스의 체로, N이하의 소수를 모두 구함 2. 두 포인터로 일치하는 해당하는 연속합을 구함 초기 : start = 0, end = 1, sum = prime[0] while start < end if sum == N count++ ...
1562 계단수 알고리즘(DP, 비트마스킹) 1. 숫자를 기록하는 num[101] 배열과, DP[101][10][1 << 10] 배열을 이용하여 DP로 품 2. 앞에서부터 길이에 맞게 숫자를 하나하나 기록해감. 기록하면서 비트마스킹으로 0~9가 있는지 표시 -> 이때 이미 표시된 비트에 또 표시하면 기록이 망가짐. 따라서 &...
1516 Developing game 알고리즘(위상정렬, 그래프. DP) 1. 어떤 건물을 짓기 위해 필요한 건물을 짓는 시간의 최대 + 이 건물을 짓는데 걸리는 시간을 출력하면 됨. 2. 예를 들어 A -> -> D C B -> -> E 로 그래프가 이루어져 있을 때, A : A를 짓는 시간 B ...
1509 팰린드롬 분할 알고리즘(Manacher’s Algorithm, DP) 1. 2차원 bool 형 배열 palindrome에 모든 팰린드롬을 저장. -> palindrome[i][j] 엔 시작이 i이고 끝이 j인 문자열이 팰린드롬인지 아닌지 저장돼있음 -> 구하는 법은 처음부터 i = 0~length, j = i~length; ...
14939 불끄기 알고리즘(브루트, 그리디, 비트마스킹) 1. 최소한으로 눌러야하는 경우 : 한 칸은 한번만 눌러야함. 두번 이상누르면 최소가 아니고, 무한 루프가 될 수 잇음 2. 모든 방법을 다 검사해봐야 정답을 얻을 수 있음 -> 브루트 포스 3. 한번씩만 누르면 누르는 순서는 중요하지않음 -> 첫줄부터 차례대로 누름 4. 이때 첫...
14938 서강그라운드 알고리즘(플로이드워셜) 1. 접근 방법 - 처음엔 DFS 또는 BFS로 접근 - 근데 해보니 이전에 왔던 것보다 적은 거리를 써서온건 보내고, 보낸 다음부터 이어지는 건 겹치면 빼야함. - 결국 플로이드워셜로 최소거리를 모두 구한 후, 탐색범위 안에 들어오는 지역의 아이템을 모두 더하는 방식과 동일함. 코드 #in...
14500 Samsung sw test 알고리즘 1. 가능한 모든 모양으로 검사. 코드 #include <iostream> #define MAX_WIDTH 501 using namespace std; int width, height; int map[MAX_WIDTH][MAX_WIDTH]; void getProperties();...
14499 Samsung sw test 알고리즘 1. 각 명령별로 검사. 초기 주사위 상태 (top : 1, north : 2, east : 3, south : 5, western : 4, bottom : 6) 2. 명령대로 주사위를 굴리고 -> 그 위치가 맵 밖이면 다음 명령 실행 맵 안이면 이동시키고, 주사위 상태 변경 ->...
14003 LIS5 알고리즘 (LIS) 1. LIS 로 구함 2. 수열 출력 1. LIS구하면서, 현재 LIS의 인덱스를 항상 저장함 2. LIS를 구하면, 가장 뒤에있는 LIS의 가장 뒤 원소의 인덱스가 저장됨 3. 그 인덱스로부터 길이를 하나씩줄여가며 앞으로 가면서 길이가 맞는걸 뒤에서부터 저장 4. 길이가 0이되면 종료 5. 이렇게하...
13549 숨바꼭질 3 알고리즘(BFS) 1. BFS로 가능한 곳은 가되, check엔 이전에 온 것보다 적은 시간을 걸리며 온 것을 받아주기 위해 시간을 저장하자. 코드 #include <iostream> #include <cstring> #include <list> using namespace std; ...
13458 Samsung sw test 알고리즘 1. 오직 1명은 무조건 1명 있어야한다는 말 2. 총감독관이 감시할 수 있는 응시자 수만큼 빼고, 감독관 수 1명 늘린다음에, 넣어야하는 부감독관 수를 더함. -> 이를 모든 시험장에 적용 3. 이때 총 필요한 감독관을 저장하는 변수는 long long으로 해야함(응시자 수 100만명, 시험장...
1339 단어 수학 알고리즘(브루트포스, 그리디) - 브루트포스 1. 어떤 알파벳이 나왔는지 기록하고, 거기에 맞춰 알파벳의 종류의 개수만큼 모든 가능한 수를 뽑아 검사한다. - 그리디 1. 들어오는 단어를 알파벳 단위로 분류하고 다음처럼 자릿수를 곱해준다. ABC -> 100A + 10B + C BCA -> 100B + 10...
12969 ABC 알고리즘(dp) 1. 현재 깊이 d, 이전에 나왔던 a의 개수, 이전에 나왔던 b의 개수, 이제까지의 k 수를 기준으로 dp를 만들어야함. k도 결과에 영향을 주기 때문. 2. 즉, dp[d][a][b][k] 를 선언하고, 이 상태가 검사되면 true로 지정하여 다시 검사하지않음. 3. 정답을 찾았을 때는 전역변수 got에 tru...
12849 본대산책 알고리즘(DP) 1. a라는 건물에 x분을 남기고 들어가는 것은, a에 연결된 모든 건물 b에 x+1분을 남기고 들어온 것과 같음 2. 즉, 정보과학관에 0분을 남기고 들어오는 것을 시작으로 모든 경우를 탐색하면 된다. 3. 쭉쭉 내려가다가 D분에 도달했을때, 장소가 정보과학관이면 1, 아니면 0을 리턴하여 바텀업으로 함 4. ...
1248 맞춰봐 알고리즘 (백트래킹) 1. 그냥 앞에서부터 가능한 수를 채워나가는 백트래킹 방식을 사용하면 된다. 2. 이때, 가능한 수는 ans를 채워간다는 얘기다. 즉, 가능한 경우만을 탐색하여 가서 정답만을 하나하나 채워가는 식으로 모든 경우를 탐색하면 됨. 코드 #include <bits/stdc++.h> using nam...
12100 Samsung sw test 알고리즘(DFS 재귀) 1. 위, 오른쪽, 아래, 왼쪽으로 차례로 보냄. 보낼때, 보내는 쪽에 가까운 곳부터 하나씩 검사. 2. 주의 사항 : 2 4 8 2 8 16 4 2 32 에서 위로 한번 보내면 맨 왼쪽 맨 위는 4가 되야하고 그 밑에 4가 와야함. 하지만 내가 처음 짠 코드에서는 한번 업데이...
1202 Jewelry thief 알고리즘 1. 보석을 가치순으로 내림차순으로 정렬 2. 가방을 multiset에 저장함 3. 가치가 큰 보석부터 차례대로 꺼내면서 적절한 가방을 선택하고, 집어넣음 -적절한 가방 : 무게가 같으면 가장 적절. 같지 않으면 남는 무게가 가장 적은 가방 -찾는 법 1. 같은 게 있는지 확인 2. 없으면, 현...
1197 MST 알고리즘(크루스칼 알고리즘 사용) 1. 가장 가중차가 작은 간선부터 검사 2. 사이클 검사 1. 간선의 양단이 전부 이미 안들어갔으면 양단을 같은 벡터에 집어넣고, set 벡터에 집어넣음 2. 한쪽만 들어갔다면, 들어가 있는 한쪽의 set벡터에 안들어간 쪽을 집어넣음 3. 두개 다 들어가 있고, 들어간 집합이 같다면, 사이클 ...
1167 트리의 지름 알고리즘 (dfs, dp) 1. 1번 노드를 최상위 노드라고 가정하고 품 2. 1번 노드부터 시작하여 트리를 밑으로 탐색함. 3. 끝까지 닿으면, 거리를 올리면서(bottom-top) 다시 위로 올라감(재귀로 탐색하면 됨) 4. 한 노드에서 재귀로 반환하는 건, 자신의 자식 노드에서 올라오는 것중 가장 큰 값(끝까지 갔을 때의...
11657 타임머신 알고리즘(밸만포드) 1. 밸만포드로 푼다. 2. 길이는 long long으로 저장한다. 코드 #include <bits/stdc++.h> using namespace std; struct Road { int to; int time; }; struct City { vector<Road> next...
1149 RGB 거리 알고리즘(dp) 1. 그냥 현재 노드에서 이전의 상태가 X였을때의 최솟값을 저장하는 dp 배열 DP[1000][3] 을 선언하고 DP를 해주면 된다. 2. 첫번째와 마지막이 상관이없으므로 매번 값을 초기화 시켜줄 필요는 없다. 코드 #include <iostream> #define INF 2000000000 u...
11437 LCA 알고리즘 (BFS, LCA) 1. 트리만들기 1. check 배열을 만들고, 1번 노드만 true 표시함 2. 정점 쌍이 들어왔을 때, 둘중에 check 표시된 것이 A, 안된 것이 B라고 할때, B의 부모엔 A를, 깊이엔 A+1을 넣고, check[B] 에 true 표시함 3. true 표시가 끝나고, B에 인접한 정점들을...
11401 이항계수 3 알고리즘(페르마의 소정리, 거듭제곱) 1. 페르마의 소정리 적용 nCk = n! / k!(n-k)! % 1000000007 에서 A = n!, B = k!(n-k)!, p = 1000000007 이라고 할 때 위 식은 (A * B^(-1)) % p 를 성립 페르마의 소정리는 p가 소수일때, p와 서로소인 a가 있으면,...
1107 리모컨 알고리즘(브루트 포스) 1. 0~100만까지 하나씩 올라가며, 되는지 검사하고, 가장 적게 누르는 건지 저장 2. 되는지 검사할 때는, 고장난 버튼을 bool 배열에 저장하여 바로바로 참조가능하게 하고, 뒤에서부터 하나씩 검사하자 헛발질 기록 1. 처음엔 들어온 버튼의 자릿수에 맞게, 모든 숫자를 검사하되 재귀로 수를 하나씩 ...
11066 파일합치기 알고리즘(DP) 1. 긴 한 줄의 파일들을 두조각으로 분리해서 찾는 방식으로 DP를 함 2. 먼저 0, k-1를 넣음 3. (0, k-1)의 파일 크기의 합을 구한 후, (0,0)-(1,k-1), (0, 1)-(2,k-1) ... 로 모든 두 조각을 만든 후, 그 조각의 비용을 구함 -> start == end 일 경우...
11054 가장 긴 바이토닉 부분수열 알고리즘(LIS) 1. 왼쪽에서 오른쪽으로 LIS, 오른쪽에서 왼쪽으로 LIS 후, 모든 점에 대하여 l[i] + r[i] - 1 (길이가 1이면 1일때, 0일경우는 + 1 해줌) 가 최대가 되는 점을 찾고 그점에서의 l[i] + r[i] -1 를 출력하면 됨. 2. 길이가 최대1000이므로 dp로 안해도 ...
11049 행렬곱셈순서 알고리즘(DP) 1. 연속된 원소를 크게 이등분하여 계산할 수 있음 ex) (start ~ i, i+1~end) 2. dp(start, end)는 start에서 end까지의 범위를 계산할 때 최소비용. 3. 현재 비용은, matrixt[start][0]*matrix[i][1]*matrix[end][1] 로 계산할 수 있음. ...
10942 Palindrome 알고리즘(DP) 1. 입력으로 받은 것이 팰린드롬인지 확인 2. 팰린드롬이면 from-to 사이에 있는 모든 건 다 팰린드롬이다. -> DP에 팰린드롬임을 표시 아니면, from-to에서 팰린드롬이 아님을 판별한 곳까지 팰린드롬이 아니다 -> DP에 팰린드롬이 아님을 표시 주의점 아무리 잘 짜도 i...
10830 행렬제곱 알고리즘 (거듭제곱, 행렬곱) 1. 그냥 행렬 거듭제곱으로 풀면됨 주의점 1. 입력의 B를 long long으로 받아야한다 2. AB = A 가 나오도록 하는 B행렬은 대각선이 모두 1이고 나머지는 0인 행렬이다 코드 #include <iostream> #include <cstring> using...
10775 airport 알고리즘(자료구조, 트리를 이용한 이진탐색) 1. 게이트의 개수에 맞게 1~G를 set에 넣음 2. bool형 check 배열에서, gi에 아무것도 없으면 gi에 넣고 set에서 gi 삭제 3. 이미 gi에 들어가 있으면, set에서 upperbound로 gi초과하는 첫번째를 찾음 -> 만약 그 첫번째가 begin...
1043 거짓말 알고리즘(DFS) 1. 처음 진실을 알고있는 사람과 연결돼있는 파티 그룹과, 절대 연결되지 않은 그룹을 나눠야함. 2. 나는 단순히 변화가 발생하지 않을 때까지 반복하였음. 그리고 그런 사람이 없는 그룹의 개수만 세서 출력함. 다른 풀이 1. 내꺼에서 좀더 최적화된 풀이 2. 처음에 입력을 받으면서, 각 사람들이 어디 파티와...
10217 KCM Travel 알고리즘(다익스트라, DP) 1. 기본적으로 다익스트라를 사용하여 최소경로를 찾아야하는 것을 맞으나, 비용이 넘어버릴경우 이전의 최소경로로 간 것이 의미가 없어진다. 따라서 현재 큐에서 꺼낸 노드가, 이전에 지나간 노드보다 같은 비용일때 더 시간이 많이 걸렸을 경우만 패스. DP[101][10001] 선언 2...
10165 KOI 2014_Elementary 알고리즘 1. 각 버스노선의 출발점, 도착점, 번호를 기록한 구조체를 만들고, 출발점을 기준으로 정렬. 출발점이 같으면 도착점이 작은 것이 앞에 위치하도록함. 2. 버스노선인덱스를 저장하는 배열을 만들어, 버스노선을 하나씩 검사함. -초기 : 첫번째 버스노선을 넣음 3. 검사내용 -출발점이 이전 버...
1007 vector matching 알고리즘 1. 각 테스트 케이스 별로 모든 x좌표와 y좌표를 더함 2. n/2개의 점을 고르고, 그 고른 점들의 모든 x좌표와 y좌표를 더함 3. 1에서 구한 x,y 에 2에서 구한 x,y를 2곱하고 뺌. (sumOfEveryX - 2*sumOfChoosedX) 4. 3.에서 구한 벡터의 길이를 구한 후 반환....
1005 ACM Craft 알고리즘(위상정렬, DP) 1. 1516 게임개발과 비슷한 유형이다 2. 위상정렬하여 푼다. 단, 1516과는 다르게 목표건물을 지었다는게 확인되면 while문을 종료하고 출력해도 됨. 3. 단, 진짜로 위상정렬한 배열을 만들 필요는 없고, 위상정렬식으로 풀어도 시간은 비슷하다. 오히려 위상정렬을 굳이 안만드는 편이 더 ...
원글에서는 TMDB의 클라이언트 웹 어플리케이션을 만들고, 여러번의 실험을 거쳐 성능 최적화에 달성하는 과정을 서술하였습니다. 이 글은 기본적으로 원글을 학습하면서 제가 읽기 편한 방식으로 번역/정리한 글입니다. 정확한 내용을 알고 싶으시면 원글을 보시는 걸 추천드립니다. 용어 정의 FCP : First Contentful Paint. ...
최근 create-react-app 대신에 vite를 공식으로 사용하자는 얘기가 나오고 있다. https://github.com/reactjs/reactjs.org/pull/5487 번역본 여기서 지적한 문제점들은 다음과 같다 SSR/SSG 지원의 부족 빈 페이지 로드 -> 리액트 번들 로드 -> 리...
Headless CMS 란? 웹사이트를 만들 때는 반드시 컨텐츠(데이터)가 필요하다. Headless CMS는 컨텐츠를 보여줄 수단인 Head와 컨텐츠를 분리한 구조로, 컨텐츠가 Head에 독립적으로 동작할 수 있도록 하는 구조이다. 로부터 데이터를 반환한 후, fetch 요청(revalidate)을 하고, 최종적으로 최신화된 데이터를 가져오는 전략이다. 이름은 HTTP 캐시 무효 전략인 stale-while-revalidate에서 유래되었다. 공식사이트 전체적인 기능은 React Query와...
Next.js의 컴파일러는 바벨 대신에 Rust 기반의 SWC를 JS 번들링에 사용한다. 이는 바벨보다 17배 빠르며, Next.js 12부터 디폴트로 쓰인다. 만약 바벨을 사용하고 싶다면, 다음을 참고하면 된다. Next.js Compiler의 자세한 내용은 공식 가이드에 나와있다. 이 글에서는 주로 사용할만한 요소만 요약하여 정리하였다. S...
next.js는 빌드 시 자동으로 모든 페이지와 그 의존성을 트랙킹하여 배포시 필요한 파일을 알아낸다. 이렇게 함으로써 배포될 파일의 크기를 줄일 수 있다. 이전에 도커로 배포할 땐, 모든 의존성을 가져온 후 next start를 실행해야했다. 하지만 next.js 12부터는 Output File Tracing을 통해 .next/ 디렉터리만 있으면 ...
Next build API next build를 실행하면, 작성한 소스코드가 최적화된 상태도 빌드된다. 빌드된 결과물 .next 아래에 위치하며 구조는 다음과 같다. .next/static/chunks/pages : 라우트되는 이름 그대로 생성된 js 파일이 위치한다. (/about –> .next/static/chunks/pages/a...
next.js로 만든 앱을 배포하기 전 체크리스트 가능한만큼 캐싱을 적용했는가? 데이터베이스와 백엔드가 같은 region에 배포되어있는가? 가능한 최소한의 Javascript를 사용하는 것을 목표로 해라 Javascript 로딩을 가능한 연기하라 logging이 구현되어 있는가? errorHandling이 설정되어있는가? ...
next.js 에서는 페이지 성능 개선을 위해 서드파티 script를 가져올 수 있는 next/script 컴포넌트를 제공한다. 사용법 import import Script from 'next/script' Page script 페이지 컴포넌트에서 사용될 수 있으며, 페이지가 브라우저에 로드되면 script를 fetch하고 실행한다. im...
next export 명령어를 통해 next.js 어플리케이션을 static HTML으로 만들 수 있다. 이렇게 만들어진 Static HTML은 Node.js 서버없이 운영이 가능하다. 다음과 같은 기능이 필요없다면, next export를 사용하는 것이 권장된다. Image Optimization (default loader) Intern...
next.js에서는 어떤 페이지가 getServerSideProps 또는 getInitialProps를 가지고 있지 않다면, static 페이지로 결정한다. 이렇게 static 페이지로 결정되면, 빌드시 그 페이지는 static 페이지로 빌드된다. static 페이지는 서버사이드에서 렌더되지 않고 바로 유저에게 전달된다. end-user와 서버 사이...
next.js에서는 next/image로 자체적인 이미지 컴포넌트를 제공한다. 일반적인 img 태그와는 달리 여러 성능 최적화기법이 내장되어있다. 기본적으로 다음과 같은 기능을 제공한다. 성능 향상 : 각 디바이스에 정확히 맞는 이미지를 모던 웹 포맷에 맞게 제공한다. Visual Stability : Cumulative Layout Shi...
next.js는 기본적으로 node.js runtime에서 작동된다. 하지만 node.js 는 싱글 스레드 기반이고, 따라서 트래픽이 많은 환경에서 multi-core를 사용하여 node.js 앱을 구동하기 위해선 다음과 같은 방법이 있다. worker thread child process cluster 필자는 next.js에서 가장...
next.js에서 사용자의 요청을 받고, 페이지를 만들어낼 때 외부 서버로 필요한 데이터를 요청해야할 때 사용하는 기법이다. data fetching은 기본적으로 페이지 컴포넌트에서 사용할 수 있고 경우에 따라 Custom App 컴포넌트에서도 사용할 수 있다. next 13부터는 app/ 구조를 사용한다면 일반 컴포넌트에서도 가능하다고 하지만, 현...
PHP 기초 PHP의 원리 웹브라우저에서 웹 서버로 index.php을 달라고 요청보냄 웹서버는 index.php을 처리할 수 있는 프로그램인 php에게 위임함 php는 index.php를 찾고, 해석해서 html 파일을 만듬. 웹 서버는 html을 받고 웹브라우저로 보내줌. PHP의 데이터 타입 숫자와 산술연산자 ...
쿠버네티스 Ingress ingress는 일반적으로 외부로부터 서버 내부로 유입되는 네트워크 트래픽을 뜻한다. 쿠버네티스에서는 ingress라는 리소스 오브젝트가 존재한다. 쿠버네티스의 ingress는 외부에서 쿠버네티스 클러스터 내부로 들어오는 http, https 요청을 어떻게 처리할지 정의한다. 즉, 외부에서 쿠버네티스에서 실행 중인 depl...
nginx.conf 에서 환경변수 사용 nginx.conf에서 환경변수를 사용하여 동적으로 nginx 설정을 변경하는 방법을 알아보자. envsubst 사용하는 방법 envsubst는 인풋으로부터 $VARIABLE 또는 ${VARIABLE}로 되어있는 값을 읽어 환경변수로 바꾸어주는 프로그램이다. envsubst을 활용해서 nginx.templa...
이 포스트는 subicura 님의 kubenetes 안내서을 읽으며 요약/기록한 게시글입니다. Kubenetes 실습 Pod 생성하기 YAML로 설정파일 작성하여 생성하기 apiVersion: v1 kind: Pod metadata: name: echo labels: app: echo spec: containers: -...
이 포스트는 subicura 님의 kubenetes 게시글을 읽으며 요약/기록한 게시글입니다. Kubenetes 쿠버네티스(kubenetes, k8s)는 도커 컨테이너를 쉽고 빠르게 배포/확장하고 관리를 자동화해주는 오픈소스 플랫폼이다. 단순한 컨테이너 플랫폼이 아닌 마이크로 서비스, 클라우드 플랫폼을 지향하고 컨테이너로 이루어진 것들을 손쉽게 담...
nginx + spring boot+ react로 구성된 앱 dockerfile 작성 docker flow 도커에서 이미지를 빌드하고, 앱이 실행되는 컨테이너를 실행하는 과정은 크게 이미지 빌드, 이미지 푸시, 컨테이너 실행 단계로 나뉜다. nginx + spring boot + react로 구성된 앱을 도커 이미지로 관리하려면 먼저 이미지를 ...
SockJS 주로 Spring을 사용할 때, WebSocket Emulation 을 위한 라이브러리이다. WebSocket Emulation 이란 우선 웹 소켓으로 소켓 연결을 시도하고, 실패할 경우 HTTP Streaming, Long-Polling 같은 HTTP 기반의 다른 기술로 전환해 다시 연결을 시도하는 것을 말한다. 따라서 다음과 같은 ...
서블릿 컨테이너는 서블릿들의 생성, 실행, 파괴를 담당하며 서블릿을 관리해준다. 서블릿 컨테이너는 클라이언트의 요청을 받고 응답할 수 있게, 웹 서버와 소켓을 만들어 통신한다. 서블릿 컨테이너의 대표적인 무료 서비스로 톰캣이 있다. 톰캣은 웹 서버와 소켓을 만들어 통신하며 JSP와 서블릿이 작동할 수 있는 환경을 제공한다. 서블릿이란? ...
Elasticsearch는 시간이 갈수록 증가하는 문제를 처리하는 분산형 RESTful 검색 및 분석 엔진입니다. Elastic Stack의 핵심 제품인 Elasticsearch는 데이터를 중앙에 저장하여 손쉽게 확장되는 광속에 가까운 빠른 검색, 정교하게 조정된 정확도, 강력한 분석을 제공합니다. (ElasticSearch 공식 문구) ...
Apache Kafka는 빠르고 확장 가능한 작업을 위해 데이터 피드의 분산 스트리밍, 파이프 라이닝 및 재생을 위한 실시간 스트리밍 데이터를 처리하기 위한 목적으로 설계된 오픈 소스 분산형 게시-구독 메시징 플랫폼이다. Kafka는 서버 클러스터 내에서 데이터 스트림을 레코드로 유지하는 방식으로 작동하는 브로커 기반 솔루션이다. Kafka 서버는...
Annotation 애노테이션은 Java 5 부터 등장한 기능으로, 사전적의미는 “주석”이지만, 클래스나 메서드 등 타켓에 라벨을 붙여준다. 비즈니스 로직에는 영향을 주지는 않지만, 해당 타켓의 연결 방법이나 소스 코드의 구조를 변경할 수도 있다. 애노테이션은 소스코드에 메타데이터를 삽입하는 것이기 때문에 잘 이용하면 구독성뿐만 아니라 체계적인 소스...
STOMP(Simple Text Oriented Messaging Protocol)란? 웹소켓 위에서 동작하는 서브 프로토콜로, 클라이언트와 서버가 서로 통신하는데 있어 메시지의 형식, 유형, 내용 등을 정의해주는 프로토콜이다. 웹 소켓 프로토콜은 Text 또는 binary 두가지 유형의 메시지 타입을 정의하지만 메시지의 내용에 대해서는 정의하지 ...
mybatis mapper에서 requestType이나 parameterType으로 클래스를 참조할 때 다음과 같이 패키지명을 다 써줘야하는 불편함이 있다. <mapper namespace="com.hello.spring.article.mapper.ArticleMapper"> <select id="selectArticles" ...
이 글은 Logging Best Pratices : The 13 You Should Know를 기반으로 요약, 학습한 글입니다. 좋은 로깅을 위해 알아야할 13가지 Don’t write logs by yourself printf을 사용하거나 파일에 직접 입력하지마라. 로깅을 위한 표준 라이브러리를 사용하라. 표준 라이브러리를 사용할 때 장점...
이 문서는 개인적인 목적이나 배포하기 위해서 복사할 수 있다. 출력물이든 디지털 문서든 각 복사본에 어떤 비용도 청구할 수 없고 모든 복사본에는 이 카피라이트 문구가 있어야 한다. (출처) SpEL - Spring Expression Language 객체를 조회하고 조작하는 기능을 제공하며, 메서드 호출, 물자열 템플릿 기능 등의 여러가지 추가...
빈 스코프는 말 그대로 빈이 존재할 수 있는 범위를 뜻한다. 스프링에서는 다음과 같은 스코프를 지원한다 싱글톤 : 기본 스코프. 스프링 컨테이너의 시작과 종료까지 유지되는 가장 넓은 범위의 스코프 프로토타입 : 스프링 컨테이너는 프로토타입 빈의 생성과 의존관계 주입까지만 관여하고 더는 관리하지 않는 매우 짧은 범위의 스코프이다. 웹 관련...
@ResponseStatus 응답으로 보낼 데이터의 HttpStatus를 명시해주는 방법이다. 컨트롤러에서 Body 데이터만 반환하는 경우 HttpStatus를 명시하기 위해 사용한다. @ResponseStatus(HttpStatus.OK) @GetMapping("/article") public ArticleListDto getArticles...
좋은 OOP 설계에서 지켜져야하는 규칙인 SOLID 중 S인 규칙으로, 하나의 모듈은 하나의 책임을 가져야한다는 원칙을 말한다. 클래스는 단 한개의 책임을 가져야한다. 하나의 모듈은 오직 하나의 액터에 대해서만 책임져야한다. 클래스를 변경하는 이유는 단 한개여야 한다. 여기서 책임은 액터에 대한 책임을 의미한다. 하나의 액터에 ...
스프링에서 지원하는 객체로, 간편하게 Rest 방식 API를 호출할 수 있는 스프링 내장 클래스다. 스프링 3.0부터 지원하였고, json, xml 응답을 모두 받을 수 있다. 특징 Blocking I/O 기반의 동기방식을 사용하는 템플릿 RESTful 형식에 맞추어진 템플릿 Header, Content-Type 등을 설정하여 외부 ...
lombok은 @Getter, @Setter 같은 애노테이션 기반으로 Getter/Setter 메서드를 자동으로 생성해주는 편리한 라이브러리이다. 하지만 편리함에 남용하는 애노테이션들이 있다. lombok 사용 시 주의해야할 애노테이션 @AllArgsConstructor 클래스에 존재하는 모든 필드에 대한 생성자를 자동으로 생성한다. @All...
스프링에서는 Http 메시지 컨버터를 통해 사용자가 보낸 데이터와 서버에서 내보내는 데이터를 자동으로 변환해준다. 만약 다음과 같은 객체를 응답으로 보낼 경우 Content-Type이 application/json이라면, 스프링은 다음 객체를 자동으로 Json 형식으로 바꾸어 내보낸다. @AllArgsConstructor @Getter public...
Mock 객체와는 달리 객체의 특정 메서드만 stub으로 대체할 수 있는 방법을 제공한다. 다음과 같이 만약 테스트 대상 객체의 특정한 메서드를 stub 처리하고 싶을 때 사용한다. @ExtendWith(MockitoExtension.class) public class BoardServiceTest{ @Spy private BoardSe...
equals()와 hashCode() 메서드는 모든 자바 객체의 부모인 Object 클래스에 정의되어있다. 따라서 모든 자바 객체는 equals()와 hashCode() 메서드를 가지고 있다. equals() 현재 객체와 파라미터로 들어온 객체가 같은 지 검사하기 위해 사용한다. 기본적으로는 두 객체의 메모리 주소가 같아야 동일한 객체가 된다. ...
HTTP Response Body에 오는 컨텐츠의 기질/성향을 알려주는 HTTP 헤더 속성이다. inline : 디폴트 값. body에 있는 값이 웹 페이지에 표시되어야한다는 뜻. Content-Disposition : inline 최신 브라우저에서 <a> 태그의 download 속성은 Cont...
[spring] 스프링 캐시 캐시란 반복적으로 데이터를 불러올 때 지속적으로 DBMS 혹은 서버에 요청하는 것이 아닌 메모리에 데이터를 저장하였다가 데이터를 불러다가 쓰는 것을 말한다. 서버나 DBMS의 부담을 줄여주고, 메모리에 저장되어있기 때문에 많은 시스템에서 사용할수 있다. 캐시는 Long Tail 법칙에 따라 시스템 리소스 사용의 대부분을...
[spring] PathPattern과 servletPath 문제 다음과 같이 interceptor를 등록할 때, addPathPatterns()에 /api/**를 등록하였지만, /api/article을 요청했을 때 인터셉터가 제대로 동작하지 않았다. 하지만 /**로 등록하니 제대로 동작하였다. public void addInterceptors(...
[java] checked vs unchecked exception 자바에서 프로그램에 이상이 있을 때 던져지는 Throwable은 Error와 Exception이 있다. Error : 시스템이 비정상적인 상황에 있다는 것을 의미. 시스템 레벨에서 발생하는 심각한 오류이기 때문에 개발자가 미리 예측하거나 처리할 수 없다. ...
[devops] HPA HorizontalPodAutoscaler의 약자로, k8s에서 CPU 사용률을 체크하여 Pod의 개수를 스케일링하는 기술이다. 지정한 메트릭을 controller가 체크하여 부하에 따라 필요한 pod의 replica 수가 되도록 자동으로 pod 수를 늘리거나 줄일 수 있는 기술이다. Auto scaling Auto s...
Helm Kubernetes 패키지 관리를 도와주는 도구. node.js의 npm과 같은 역할을 수행한다. Helm을 사용하면 쿠버네티스 클러스터에서 동작하도록 작성된 패키지들을 관리할 수 있다. 즉, Helm을 사용하면 클러스터에 배포한 애플리케이션을 쉽게 설치, 업데이트, 삭제할 수 있다. 일반적으로 쿠버네티스는 여러 오브젝트로 구성되어있는데...
[devops] Canary 테스트 안정적인 버전을 릴리즈하기 전에 테스트 버전을 일부 사용자에게 배포하는 것을 말한다. 만약 카나리 버전에 심각한 버그가 발생한다해도 사용하는 사용자가 적기 때문에 피해를 최소화할 수 있다. 또한 안정적인 버전과 테스트 버전이 모두 배포된 상태이기 때문에 A/B 테스트가 가능하다. 유저가 직접 카나리 버전을 ...
[devops] blue-green 배포 애플리케이션의 이전 버전에 있던 사용자 트래픽을 이전 버전(blue)과 거의 동일한 새 버전(green)으로 점진적으로 이전하는 애플리케이션 배포 모델이다. 이때 두 버전 모두 프로덕션 환경에서 실행 상태를 유지한다. blue에서 green으로 완전히 이전되면 blue는 롤백에 대비하여 대기 상태에 두거나 ...
[spring] 파일 업/다운로드 HTML 폼 전송 방식 HTML에서 폼을 전송하는 방식(Content-Type)에는 다음 두가지가 있다. application/x-www-form-urlencoded : 문자와 같은 데이터를 키와 함께 전송하는 방식 ex) username=Kim&age=20 ...
[spring] 파라미터 validation BindingResult HTTP 메세지 컨버터에서 발생한 데이터 바인딩 오류를 담아 컨트롤러에서 이용할 수 있는 객체. 다음과 같이 바인딩 오류가 발생할 수 있는 파라미터 바로 다음에 파라미터로서 추가한다. @PostMapping("/add") public String addItemV1(@ModelA...
비즈니스 코드를 먼저 작성하고 유닛테스트를 작성할 때, 완성된 코드를 보고 테스트 코드를 작성하다보면 내부 구현에 맞추어 테스트를 작성하게 되고, 구현 자체를 검증하게 되는 일이 많이 발생하였다. 유닛 테스트에서는 구현이 아닌 행동을 검증(test behaviour, not implementation)해야한다. 따라서 구현을 검증한 테스트 코드를 고...
아래와 같이 http 헤더를 보다보면 keep-alive라고 명시된 부분이 보일 때가 있다. connection : keep-alive Keep-Alive:timeout=5, max=1000 이 keep-alive는 무슨 뜻일까 궁금하여 찾아보았다. keep-alive connection : keep-alive connec...
CORS : Cross-Origin Resource Sharing(교차 출처 리소스 공유) 서로 다른 출처(Origin)에서 리소스를 공유할 때 적용되는 정책이다. 출처(Origin)이란? URL은 다음과 같이 여러 개의 구성요소로 이루어져있다. 여기서 출처란 protocol + host + port 을 뜻한다. 이 조합이 같아야...
게시글 검색을 개발하는 도중 검색의 대상이 되는 field(title | nickname | content)를 동적으로 mybatis 쿼리문 상에 사용해야할 일이 있었다. 따라서 다음과 같이 #{} 를 사용하여 변수를 넣었으나 오류가 발생했다. <where> <when test="type != 'hashtag'"> atc....
@ResquestBody로 받는 매개변수의 클래스에 @NoArgsConstructor를 빼니 InvalidDefinitionException 에러가 발생했다. @PostMapping("/login") public String login(@Valid @RequestBody LoginRequestBody loginRequestBody) @Getter...
스프링 인터셉터는 스프링 MVC가 제공하는 기술로, 서블릿 필터하고는 적용순서, 범위, 사용방법이 다르다. 소개 스프링 인터셉터 흐름 HTTP 요청 -> WAS -> 필터 -> 서블릿 -> 스프링 인터셉터 -> 컨트롤러 스프링 인터셉터는 디스패처 서블릿과 컨트롤러 사이에서 컨트롤러 호출 직전에...
스프링에서 컨트롤러를 개발하다보면, url 파라미터를 long 으로 받아도 문제없이 작동된다. @GetMapping(path = "/article/{articleId}") public String getArticleDetail(@PathVariable long articleId) { 위와 같은 컨트롤러가 있을 때, 유저는 /article/123라...
이 포스트는 참고문서를 필자가 이해하기 쉽게 정리한 내용입니다. DI는 IoC를 사용하지 않아도 된다 DI(Dependency Injection) 다음 PizzaStore 클래스는 정해진 개수의 Pizza인스턴스를 가지고 있다. 만약 Pizza가 더 필요하면 PizzaStore를 직접 수정해야하다. 이는 OCP를 위반하며 DI로 해결해줄 수 있다...
controller 인자로 enum 받는 문제를 해결했던 것은 enum 타입에 맞춘 Converter를 bean에 등록하는 것이었다. 단순히 bean에 등록하는 것으로 controller에서 httpConverter 동작할 때 이것을 적용한 것이다. 이 뒤에 무엇이 있을까 하여 조사해보았다. 스프링에서는 기본적인 타입 변환은 자동으로 지원한다. 따라...
검색 API를 개발하는 과정에서 다음과 같이 검색 타입을 enum 으로 지정하였고, controller의 param으로 받으려고 했다. @Getter @AllArgsConstructor public enum SearchType { TITLE("title"), CONTENT("content"), HASHTAG("hashtag"), NICKNAM...
ArgumentResolver 활용 ArgumentResolver는 스프링 MVC 구조의 어댑터 핸들러에서 핸들러에 필요한 파라미터를 만들어주는데 호출하는 부분이다. 이 ArgumentResolver를 직접 구현하여 활용하면 다양한 상황에서 편리하게 적용할 수 있다. 로그인 회원 정보를 편리하게 받아오는 예제 컨트롤러 @GetMapping("/...
@Valid JSR-303 표준 객체 제약조건 검증 어노테이션 ArgumentResolver에 의해 처리된다. 검증에 오류가 있다면 MethodArgumentNotValidException 예외가 발생하며 디스패처 서블릿에 기본으로 등록된 예외 리졸버인 DefaultHandlerExceptionResolver에 의해 400 에러가 발생한...
yourlist_web_renewal 중, 한 input 엘리먼트의 placeholder가 보일시와 안보일 시, label 엘리먼트에 각기 다른 스타일을 적용해야하는 일이 있었다.
현재 사용중인 tailwind에선 어떻게 사용해야할지 모르겠으나 순수 CSS 방식으로 하면 다음과 같다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
.form_field:placeholder-shown ~ .form__label {
+ font-size: 1rem;
+ top: 0;
+ cursor: text;
+}
+.form_field:focus ~ .form__label {
+ top: -1.2rem;
+ font-size: 1rem;
+ font-weight: 700;
+ color: var(--primary-redrose-light);
+}
+.form_field:not(:focus) ~ .form__label {
+ color: var(--blackberry-lightest);
+}
+.form_field:not(:placeholder-shown) ~ .form__label {
+ top: -1.2rem;
+ font-size: 1rem;
+}
+
위와 같이, [이벤트 발생] [선택자] [대상] 로 한 엘리먼트의 이벤트 발생 시 선택자로 적용할 엘리먼트를 선택하면 된다.
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+
#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <cstring>
+#include <set>
+using namespace std;
+
+struct node {
+ int first;
+ int second;
+ int length;
+
+ bool operator< (node a) {
+ return length < a.length;
+ }
+};
+
+vector<pair<int, int>> field;
+vector<node> lengths;
+vector<set<int>> unionset;
+int N, C, parent[2000];
+long long result;
+
+void calcLengths();
+bool kruskal();
+int power(int a) {
+ return a * a;
+}
+
+int main() {
+ cin >> N >> C;
+ int a, b;
+ while (N--) {
+ cin >> a >> b;
+ field.push_back({ a, b });
+ }
+ N = field.size();
+
+ calcLengths();
+ memset(parent, -1, sizeof(parent));
+ sort(lengths.begin(), lengths.end());
+
+ if (kruskal())
+ cout << result;
+ else
+ cout << "-1";
+}
+
+void calcLengths() {
+ for (int i = 0; i < N; i++)
+ for (int j = i + 1; j < N; j++)
+ lengths.push_back({ i, j, power((field[i].first - field[j].first)) + power((field[i].second - field[j].second)) });
+}
+
+bool kruskal() {
+ for (int i = 0; i < lengths.size(); i++) {
+ int f = lengths[i].first, s = lengths[i].second, l = lengths[i].length;
+ int sp = parent[s], fp = parent[f];
+ if (l < C)
+ continue;
+
+ if (fp == -1 && sp == -1) {
+ set<int> t;
+ t.insert(f);
+ t.insert(s);
+ unionset.push_back(t);
+ parent[f] = unionset.size()-1;
+ parent[s] = parent[f];
+ result += l;
+ }
+ else if (fp == -1) {
+ unionset[sp].insert(f);
+ parent[f] = sp;
+ result += l;
+ }
+ else if (sp == -1) {
+ unionset[fp].insert(s);
+ parent[s] = fp;
+ result += l;
+ }
+ else if(fp != sp) {
+ for (auto iter = unionset[sp].begin(); iter != unionset[sp].end(); iter++) {
+ parent[*iter] = fp;
+ unionset[fp].insert(*iter);
+ }
+ result += l;
+ unionset[sp].clear();
+ }
+ }
+ int root = parent[0];
+ for (int i = 0; i < N; i++) {
+ if (parent[i] != root)
+ return false;
+ }
+
+ return true;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+
1. 1516 게임개발과 비슷한 유형이다
+2. 위상정렬하여 푼다. 단, 1516과는 다르게 목표건물을 지었다는게 확인되면 while문을 종료하고 출력해도 됨.
+3. 단, 진짜로 위상정렬한 배열을 만들 필요는 없고, 위상정렬식으로 풀어도 시간은 비슷하다. 오히려 위상정렬을 굳이 안만드는 편이 더 빠를 수있다.
+4. 더 빠르게 하는 방법은, 목표건물이 속한 그래프만을 검사하는 것.
+
1
+
1. DP : 왜 알고리즘 분류에 DP가 들어갔나 했더만, 이미 검사한 거는 check표시하여 검사하지않고, 최댓값을 다음 노드로 계속 넘겨주는 형태가 DP인거 같다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+
#include <iostream>
+#include <cstring>
+#include <vector>
+#define MAX_CRAFT 1000
+
+using namespace std;
+
+typedef struct Craft {
+ int time;
+ int timeTaken;
+ int before;
+ bool isChecked;
+ vector<int> next;
+} Craft;
+
+Craft craft[MAX_CRAFT];
+vector<int> answer;
+
+int main() {
+ int numOfTc;
+ cin >> numOfTc;
+ for (int i = 0; i < numOfTc; i++) {
+ memset(craft, 0, sizeof(craft));
+
+ //입력
+ int numOfCraft, numOfOrder, targetCraft;
+ cin >> numOfCraft >> numOfOrder;
+ for (int j = 0; j < numOfCraft; j++)
+ cin >> craft[j].time;
+ for (int j = 0; j < numOfOrder; j++) {
+ int temp, temp2;
+ cin >> temp >> temp2;
+ temp--;
+ temp2--;
+ craft[temp].next.push_back(temp2);
+ craft[temp2].before++;
+ }
+ cin >> targetCraft;
+ targetCraft--;
+
+ //계산
+ bool check = true;
+ while (check) {
+ for (int j = 0; j < numOfCraft; j++) {
+ if (!craft[j].isChecked && craft[j].before == 0) {
+ int tempTime = craft[j].time + craft[j].timeTaken;
+ for (int k = 0; k < craft[j].next.size(); k++) {
+ if (craft[craft[j].next[k]].timeTaken < tempTime)
+ craft[craft[j].next[k]].timeTaken = tempTime;
+ craft[craft[j].next[k]].before--;
+ }
+ craft[j].isChecked = true;
+ if (j == targetCraft)
+ check = false;
+ }
+ }
+ }
+
+ answer.push_back(craft[targetCraft].time + craft[targetCraft].timeTaken);
+ }
+ for (int i = 0; i < answer.size(); i++)
+ cout << answer[i] << endl;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+
1. 각 테스트 케이스 별로 모든 x좌표와 y좌표를 더함
+2. n/2개의 점을 고르고, 그 고른 점들의 모든 x좌표와 y좌표를 더함
+3. 1에서 구한 x,y 에 2에서 구한 x,y를 2곱하고 뺌. (sumOfEveryX - 2*sumOfChoosedX)
+4. 3.에서 구한 벡터의 길이를 구한 후 반환. 반환 받은 곳은 최솟값을 다시 반환
+
1
+2
+
들어오는 점들이 짝수이고, 두개씩 짝 지어준다면 벡터를 구했을 때 반은 더하는 형태이고, 반은 빼는 형태이다.
+따라서 빼줄 반을 고르고, 전체 X의 합에서 빼면 됨. 근데 전체 X의 합이므로 빼줄 반은 두배로 곱하고 빼야한다.
+
1
+2
+3
+4
+5
+
처음에 모든 쌍을 지어주고, 모든 방향을 검사하여 길이를 구해도 시간안에 될 줄 알았음
+-> 하지만 계산해보니 미친듯이 시간이 많이 걸림
+-> 다른 방법으로 빠르게 전환했어야했다
+
+그리고 문제를 푸는데 머리로만 푸는 버릇이 들었는데 이걸 고치고 이런 수학적인 문제는 적으면서 풀어보자.
+
1
+2
+
1. 생각난 알고리즘이 있으면 한번 복잡도 계산해보자
+2. 수학적인 문제의 경우 식을 적으면서 풀어보자.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+
#include <iostream>
+#include <cstdio>
+#include <cmath>
+#include <vector>
+#include <cstring>
+
+using namespace std;
+
+typedef struct Point {
+ int x;
+ int y;
+} Point;
+
+vector<vector<Point>> tc;
+vector<Point> currentPoint;
+int sumOfEveryX, sumOfEveryY;
+
+void generateTc();
+long double solveSingleTC(vector<int> choosed, int deep);
+
+int main() {
+ int numOfTc;
+ cin >> numOfTc;
+ for (int i = 0; i < numOfTc; i++) {
+ int numOfPoint;
+ cin >> numOfPoint;
+ vector<Point> tempPoint;
+ for (int j = 0; j < numOfPoint; j++) {
+ int x, y;
+ cin >> x >> y;
+ tempPoint.push_back({ x, y });
+ }
+ tc.push_back(tempPoint);
+ }
+ generateTc();
+}
+
+void generateTc() {
+ for (int i = 0; i < tc.size(); i++) {
+ currentPoint = tc[i];
+ sumOfEveryX = 0;
+ sumOfEveryY = 0;
+ for (int j = 0; j < currentPoint.size(); j++) {
+ sumOfEveryX += currentPoint[j].x;
+ sumOfEveryY += currentPoint[j].y;
+ }
+ vector<int> choosed;
+ cout << "test" << endl;
+ cout.precision(50);
+ cout << solveSingleTC(choosed, 0) << endl;
+ }
+}
+
+long double solveSingleTC(vector<int> choosed, int deep) {
+ if (choosed.size() == currentPoint.size() / 2) {
+ long long sumOfChoosedX = 0;
+ long long sumOfChoosedY = 0;
+ for (int i = 0; i < choosed.size(); i++) {
+ sumOfChoosedX += currentPoint[choosed[i]].x;
+ sumOfChoosedY += currentPoint[choosed[i]].y;
+ }
+ long long length = (sumOfEveryX - 2 * sumOfChoosedX) * (sumOfEveryX - 2 * sumOfChoosedX) +
+ (sumOfEveryY - 2 * sumOfChoosedY) * (sumOfEveryY - 2 * sumOfChoosedY);
+ return sqrt(length);
+ }
+ else if (currentPoint.size() - deep < (currentPoint.size() / 2) - choosed.size())
+ return 2000000000;
+
+ long double a = solveSingleTC(choosed, deep + 1);
+ choosed.push_back(deep);
+ long double b = solveSingleTC(choosed, deep + 1);
+ return a < b ? a : b;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+
1. 각 버스노선의 출발점, 도착점, 번호를 기록한 구조체를 만들고, 출발점을 기준으로 정렬. 출발점이 같으면 도착점이 작은 것이 앞에 위치하도록함.
+2. 버스노선인덱스를 저장하는 배열을 만들어, 버스노선을 하나씩 검사함.
+ -초기 : 첫번째 버스노선을 넣음
+3. 검사내용
+ -출발점이 이전 버스노선과 같은가
+ -이전 버스노선이 0을 지나치고, 현재 버스노선도 0을 지나치는가 (정렬로 인해 자동으로 현재버스노선이 이전버스노선을 감싸는 형태가 됨.)
+ -현재버스 노선을 넣었을 때 지워지는 노선을 전부 지움
+ -이전버스노선도 지워졌으므로, 이전 버스노선인덱스 위치에 현재 버스노선의 인덱스를 넣음
+ -이전 버스노선이 0을 지나치지만, 현재 버스노선은 0을 지나치지 앟음
+ -현재버스노선 스킵
+ -이전 버스노선이 0을 지나치지 않음
+ -이전 버스노선을 지우고, 현재 버스노선을 저장
+ -출발점이 이전 버스노선과 다른가
+ -현재 버스노선이 0을 지나치는가
+ -이전 버스노선이 0을 지나치고, 현재 버스노선을 감싸는가
+ -스킵
+ -그 외
+ -현재버스 노선을 넣었을 때 지워지는 노선을 전부 지움
+ -이전 버스노선이 지워졌으면 이전 위치에 넣고, 아니면 이어서 넣자
+ -현재 버스노선이 0을 지나치치 않는가
+ -이전 버스노선이 0을 지나치지 않고, 현재 버스노선을 감싸지 않을 때
+ -현재 버스노선을 이어서 넣음
+ -그 외 스킵
+4. 검사 끝나고, 버스노선 인덱스들로부터 남은 버스노선의 번호들을 추출하고, 번호들을 정렬하여 출력.
+
1
+2
+3
+
1. 0번 정류장을 안지나는 그룹을 A, 지나는 그룹을 B라고 하자.
+2. A그룹 먼저 내 방식대로 정렬 후 겹치는 거 있는지 확인 후 집어넣어 기록
+3. B그룹을 적절하게 정렬 후 검사 -> A그룹을 포함하는지, 같은 B그룹 내 다른 노선을 포함하는지 확인하여 기록.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+
//busLine.java
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.LinkedList;
+
+public class BusLine {
+ private int numOfBusStop;
+ private BusLineInfo[] busLines;
+
+ private class BusLineInfo implements Comparable<BusLineInfo> {
+ int num;
+ int start;
+ int end;
+
+ public BusLineInfo(int num, int start, int end) {
+ this.num = num;
+ this.start = start;
+ this.end = end;
+ }
+ @Override
+ public int compareTo(BusLineInfo info) {
+ // TODO Auto-generated method stub
+ int temp = this.start - info.start;
+ return temp != 0 ? temp : (this.end - info.end);
+ }
+ }
+
+ public BusLine() {
+ getProperties();
+ }
+
+ private void getProperties() {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ try {
+ this.numOfBusStop = Integer.parseInt(br.readLine());
+ } catch(Exception e) {
+ e.printStackTrace();
+ }
+
+ int numOfBusLine = 0;
+ try {
+ numOfBusLine = Integer.parseInt(br.readLine());
+ } catch(Exception e) {
+ e.printStackTrace();
+ }
+
+ this.busLines = new BusLineInfo[numOfBusLine];
+ try {
+ for(int i = 0; i<numOfBusLine; i++) {
+ String[] str = br.readLine().split(" ");
+ this.busLines[i] = new BusLineInfo(i+1, Integer.parseInt(str[0]), Integer.parseInt(str[1]));
+ }
+ } catch(Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ public int[] deleteDuplicateLine() {
+ LinkedList<Integer> lineAfterDelete = new LinkedList<Integer>();
+
+ Arrays.sort(this.busLines);
+
+ lineAfterDelete.add(0);
+ for(int i = 1; i<this.busLines.length; i++) {
+ int beforeIndex = lineAfterDelete.getLast();
+ boolean isBeforeExceed0 = this.busLines[beforeIndex].end < this.busLines[beforeIndex].start;
+ boolean isCurrentExceed0 = this.busLines[i].end < this.busLines[i].start;
+
+ if(this.busLines[i].start == this.busLines[beforeIndex].start) {
+ if(isBeforeExceed0 && !isCurrentExceed0)
+ continue;
+ else if(isBeforeExceed0 && isCurrentExceed0) {
+ lineAfterDelete = deleteAnyCan(lineAfterDelete, i);
+ }
+ lineAfterDelete.removeLast();
+ lineAfterDelete.add(i);
+ }
+ else {
+ if(isCurrentExceed0) { //출발지점이 더 나중인 게 0을 넘을 경우
+ //이전게 0을 넘고, 현재 end보다 이전 end이 더 크면 현재게 잡아먹힘. continue
+ if(isBeforeExceed0 && this.busLines[beforeIndex].end >= this.busLines[i].end)
+ continue;
+
+ //위같은 경우가 아니면, 잡아 먹지 않음. 현재가 이전에 먹을 게 있는지 확인하고 먹은 건 -1로 표시
+ lineAfterDelete = deleteAnyCan(lineAfterDelete, i);
+
+ //바로 이전에 -1로 표시되었다면 이전위치에 현재 위치를 집어넣고, 아니면 현재위치에 넣고 1증가
+ lineAfterDelete.add(i);
+ }
+ else { //안넘을 경우
+ //이전에 넘으면 무조건 잡아먹힘
+ //넘지않으면 이전 end가 현재 end보다 클때 잡아먹음.
+ //아니면 현재걸 기록.
+ if(!isBeforeExceed0 && this.busLines[i].end > this.busLines[beforeIndex].end)
+ lineAfterDelete.add(i);
+ }
+ }
+ }
+
+ int[] numsLine = new int[lineAfterDelete.size()];
+ for(int i = 0; i<numsLine.length; i++)
+ numsLine[i] = lineAfterDelete.get(i);
+
+ Arrays.sort(numsLine);
+
+ return numsLine;
+ }
+
+ private LinkedList<Integer> deleteAnyCan(LinkedList<Integer> lineAfterDelete, int current) {
+ int currentEnd = this.busLines[current].end;
+ LinkedList<Integer> temp = new LinkedList<Integer>();
+
+ for(int i = 0; i<lineAfterDelete.size(); i++) { //현재의 end가 어떤 것의 start와 end보다 크면 -1로 바꿈. 이때 어떤 것은 0을 넘지 말아야한다.
+ int currentIndex = lineAfterDelete.get(i);
+ if(currentEnd >= this.busLines[currentIndex].end && this.busLines[currentIndex].end > this.busLines[currentIndex].start) {
+ ;
+ }
+ else
+ temp.add(lineAfterDelete.get(i));
+ }
+
+ return temp;
+ }
+
+}
+
+//Main.java
+
+public class Main {
+
+ public static void main(String[] args) {
+ // TODO Auto-generated method stub
+ BusLine test = new BusLine();
+ int[] temp = test.deleteDuplicateLine();
+ for(int i : temp)
+ System.out.print(i + " ");
+ }
+
+}
+
+
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+
1. 기본적으로 다익스트라를 사용하여 최소경로를 찾아야하는 것을 맞으나, 비용이 넘어버릴경우 이전의 최소경로로 간 것이 의미가 없어진다.
+ 따라서 현재 큐에서 꺼낸 노드가, 이전에 지나간 노드보다 같은 비용일때 더 시간이 많이 걸렸을 경우만 패스.
+ DP[101][10001] 선언
+2. 첫번째를 제외하고, 모든 노드를 INF 로 초기화
+3. 다익스트라를 진행하면서, 현재 큐에서 꺼낸 노드의 시간이 DP[현재노드][현재노드의 비용] 보다 클 때 패스 (같은 거는 현재 일 수 있음)
+4. 인접한 노드를 업데이트할때, (다음노드로 가는비용 ~ 최대비용) 까지 이미 저장된 값보다 작을 때 DP[다음노드][비용] 을 다음 시간으로 업데이트
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+
#include <bits/stdc++.h>
+#define INF 2000000000
+
+using namespace std;
+
+struct Line {
+ int to;
+ int m;
+ int time;
+};
+
+vector<Line> airport[101];
+int N, M, K, DP[101][10001];
+queue<Line> q;
+
+void dijkstra();
+void init() {
+ for (int i = 1; i <= N; i++) {
+ airport[i].clear();
+ for(int j = 1; j<=M; j++)
+ DP[i][j] = INF;
+ }
+}
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ int tc;
+ cin >> tc;
+ for (int i = 0; i < tc; i++) {
+ cin >> N >> M >> K;
+ init();
+
+ for (int j = 0; j < K; j++) {
+ int a, b, c, d;
+ cin >> a >> b >> c >> d;
+ airport[a].push_back({ b, c, d });
+ }
+
+ dijkstra();
+
+ int answer = INF;
+ for (int j = 1; j <= M; j++)
+ answer = min(answer, DP[N][M]);
+
+ if (answer == INF)
+ cout << "Poor KCM" << "\n";
+ else
+ cout << answer << "\n";
+ }
+}
+
+void dijkstra() {
+ q.push({1, 0, 0});
+
+ while (!q.empty()) {
+ Line a = q.front();
+ q.pop();
+
+ if (a.time > DP[a.to][a.m])
+ continue;
+
+ for (int j = 0; j < airport[a.to].size(); j++) {
+ Line next = airport[a.to][j];
+ int nm = a.m + next.m, nt = a.time + next.time, to = next.to;
+
+ if (nm <= M && nt < DP[to][nm]) {
+ q.push({ to, nm, nt });
+ for (int k = nm; k <= M; k++)
+ if(nt < DP[to][k])
+ DP[to][k] = nt;
+ }
+ }
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+
#include <iostream>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+
+int N, K, length, inputArray[7];
+int dp[1000001][11];
+
+void nIntoArray(int n, int* a);
+int arrayIntoN(int* a);
+int dynamic(int deep);
+void swap(int* a, int* b);
+
+int main() {
+ cin >> N >> K;
+
+ int index = 7;
+ for (int i = 1000000; i >= 1; i /= 10) {
+ if (N >= i) {
+ length = index;
+ break;
+ }
+ index--;
+ }
+
+ nIntoArray(N, inputArray);
+ if (N < 10)
+ cout << -1;
+ else {
+ int ans = dynamic(0);
+ if (ans == 0)
+ cout << -1;
+ else
+ cout << ans;
+ }
+}
+
+void nIntoArray(int n, int* a) {
+ for (int i = 0; i < length; i++) {
+ a[i] = n % 10;
+ n /= 10;
+ }
+}
+int dynamic(int deep) {
+ int num = arrayIntoN(inputArray);
+ if (deep == K)
+ return num;
+ if (dp[num][deep] != 0)
+ return dp[num][deep];
+
+ int ans = 0;
+ for (int i = 0; i < length-1; i++) {
+ for (int j = i+1; j < length; j++) {
+ if (inputArray[i] != 0 || j != length - 1) {
+ swap(&inputArray[i], &inputArray[j]);
+ ans = max(dynamic(deep + 1), ans);
+ swap(&inputArray[j], &inputArray[i]);
+ }
+ }
+ }
+ dp[num][deep] = ans;
+ return ans;
+}
+
+void swap(int* a, int* b) {
+ int temp = *a;
+ *a = *b;
+ *b = temp;
+}
+
+int arrayIntoN(int* a) {
+ int result = 0, multi = 1;
+ for (int i = 0; i < length; i++) {
+ result += a[i] * multi;
+ multi *= 10;
+ }
+ return result;
+}
+
Comments powered by Disqus.
1
+2
+3
+
1. 처음 진실을 알고있는 사람과 연결돼있는 파티 그룹과, 절대 연결되지 않은 그룹을 나눠야함.
+
+2. 나는 단순히 변화가 발생하지 않을 때까지 반복하였음. 그리고 그런 사람이 없는 그룹의 개수만 세서 출력함.
+
1
+2
+3
+4
+5
+6
+
1. 내꺼에서 좀더 최적화된 풀이
+2. 처음에 입력을 받으면서, 각 사람들이 어디 파티와 연결되어있는지 벡터에 저장.
+3. 처음부터 진실을 알고 있는 사람들이 있는 그룹을 큐에 넣고, 거짓말을 할 수 있는 그룹인지 체크하는 배열에 표시
+4. 큐에 넣어진 그룹들을 하나씩 빼가며, 그 그룹에 있는 사람들이 속한 그룹도 큐에 추가.
+ 이미 검사한 사람이거나, 검사한 그룹이면 패스
+5. 그렇게해서 탐색이 끝나면, 표시안된 그룹의 개수를 세서 출력
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+
#include <iostream>
+
+using namespace std;
+
+int N, M, party[51][51];
+bool knowTruth[51], alreadyCheck[51];
+
+int getAns();
+void makeKnow();
+
+int main() {
+ cin >> N >> M;
+ int t;
+ cin >> t;
+ while(t--) {
+ int a;
+ cin >> a;
+ knowTruth[a] = true;
+ }
+
+ for (int i = 0; i < M; i++) {
+ int n;
+ cin >> n;
+ for (int j = 0; j < n; j++)
+ cin >> party[i][j];
+ }
+ makeKnow();
+ cout << getAns();
+}
+
+void makeKnow() {
+ bool change = true;
+ while (change) {
+ change = false;
+
+ for (int i = 0; i < M; i++) {
+ if (alreadyCheck[i])
+ continue;
+
+ int index = 0;
+ bool check = false;
+ while (party[i][index] != 0) {
+ if (knowTruth[party[i][index]]) {
+ check = true;
+ break;
+ }
+ index++;
+ }
+
+ if (check) {
+ change = true;
+ alreadyCheck[i] = true;
+ index = 0;
+ while (party[i][index] != 0) {
+ knowTruth[party[i][index]] = true;
+ index++;
+ }
+ }
+ }
+ }
+}
+
+int getAns() {
+ int result = 0;
+ for (int i = 0; i < M; i++) {
+ int index = 0;
+ bool check = true;
+ while (party[i][index] != 0) {
+ if (knowTruth[party[i][index]]) {
+ check = false;
+ break;
+ }
+ index++;
+ }
+ if (check)
+ result++;
+ }
+ return result;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+
1. 게이트의 개수에 맞게 1~G를 set에 넣음
+2. bool형 check 배열에서, gi에 아무것도 없으면 gi에 넣고 set에서 gi 삭제
+3. 이미 gi에 들어가 있으면, set에서 upperbound로 gi초과하는 첫번째를 찾음
+ -> 만약 그 첫번째가 begin()이면 없는 것 -> false 반환 후 입력 종료
+ -> begin()이 아니면 그 곳에서 한칸 아래에 도킹하고, true반환
+
1
+
1. set의 erase는 iterator를 받는다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+
#include <iostream>
+#include <set>
+#define MAX 100001
+
+using namespace std;
+
+int numOfGate, numOfPlane, planeCount;
+bool gate[MAX];
+set<int> s;
+
+//gateIndex에 넣을 자리에 넣기
+//넣을 곳은 최대한 큰 곳에 넣는게 좋다.
+//따라서 5가 들어오면, gateIndex에서 5를 조회해서, 가리키는 위치에 넣기
+//가리키는 위치는 처음엔 자기자신, 그 후엔 넣어질때마다 1칸씩 앞으로 당기기.
+//대신 그 앞에 것도 적절히 조절
+//ex) 5 5 5 계속 들어오면, gateIndex는 1 2 3 4 5 6 -> 1 2 3 4 4 6-> 1 2 3 3 3 6-> 1 2 2 2 2 6-> 1 1 1 1 1 6-> 0 0 0 0 0 6-> 0자리엔 못넣게 함.
+//1씩 줄여주는과정에서 시간초과가 뜸.
+bool canPut(int max);
+void makeSet();
+
+int main() {
+ cin >> numOfGate >> numOfPlane;
+ makeSet();
+ int temp;
+ bool check = true;
+ for (int i = 0; i < numOfPlane; i++) {
+ cin >> temp;
+ if (check && canPut(temp))
+ planeCount++;
+ else
+ check = false;
+ }
+ cout << planeCount << endl;
+
+}
+
+void makeSet() {
+ for (int i = 1; i <= numOfGate; i++)
+ s.insert(i);
+}
+
+bool canPut(int max) {
+ if (!gate[max]) {
+ gate[max] = true;
+ s.erase(s.find(max));
+ return true;
+ }
+ else {
+ set<int>::iterator iter = s.upper_bound(max);
+ if (iter == s.begin())
+ return false;
+ else {
+ iter--;
+ gate[*iter] = true;
+ s.erase(iter);
+ return true;
+ }
+ }
+}
+
Comments powered by Disqus.
1
+
1. 그냥 행렬 거듭제곱으로 풀면됨
+
1
+2
+
1. 입력의 B를 long long으로 받아야한다
+2. AB = A 가 나오도록 하는 B행렬은 대각선이 모두 1이고 나머지는 0인 행렬이다
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+
#include <iostream>
+#include <cstring>
+using namespace std;
+
+long long N, B;
+long long map[5][5], result[5][5] = { {1,0,0,0,0}, {0,1,0,0,0}, {0,0,1,0,0}, {0,0,0,1,0}, {0,0,0,0,1} };
+
+void multiMap(bool isResult);
+void powerMap();
+
+int main() {
+ cin >> N >> B;
+ for (int i = 0; i < N; i++)
+ for (int j = 0; j < N; j++)
+ cin >> map[i][j];
+
+ powerMap();
+ for (int i = 0; i < N; i++) {
+ for (int j = 0; j < N; j++)
+ cout << result[i][j] << " ";
+ cout << endl;
+ }
+}
+
+void powerMap() {
+ while (B >= 1) {
+ if (B % 2 == 1) {
+ multiMap(true);
+ if (B == 1)
+ break;
+ }
+ multiMap(false);
+ B /= 2;
+ }
+}
+
+void multiMap(bool isResult) {
+ long long temp[5][5];
+ memset(temp, 0, sizeof(temp));
+
+ if (isResult) {
+ for (int i = 0; i < N; i++) {
+ for (int j = 0; j < N; j++) {
+ for (int k = 0; k < N; k++)
+ temp[i][j] = ((temp[i][j] % 1000)+ ((result[i][k] * map[k][j]) % 1000));
+ temp[i][j] %= 1000;
+ }
+ }
+ memcpy(result, temp, sizeof(temp));
+ }
+ else {
+ for (int i = 0; i < N; i++) {
+ for (int j = 0; j < N; j++) {
+ for (int k = 0; k < N; k++)
+ temp[i][j] = ((temp[i][j] % 1000) + ((map[i][k] * map[k][j]) % 1000));
+ temp[i][j] %= 1000;
+ }
+ }
+ memcpy(map, temp, sizeof(temp));
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+
#include <iostream>
+#include <set>
+
+typedef long long LL;
+
+using namespace std;
+
+set<pair<LL, pair<LL, LL>>> v, h;
+LL l, n, ans, curDir = 1, cr, cc;
+
+bool add(int, int);
+bool check(LL, LL);
+
+int main() {
+ cin >> l >> n;
+
+ pair<LL, pair<LL, LL>> t[3] = { { l + 1, {-l, l} },{ -l - 1, {-l, l} }, { 0,{0,0} } };
+ for (int i = 0; i < 3; i++) {
+ h.insert(t[i]);
+ v.insert(t[i]);
+ }
+
+ int a;
+ char b;
+ bool check = false;
+ while (n--) {
+ cin >> a >> b;
+ if (!add(a, b)) {
+ check = true;
+ break;
+ }
+ }
+
+ if(!check)
+ add(2000000010, 'L');
+
+ cout << ans;
+ return 0;
+}
+
+bool add(int t, int dir) {
+ LL nr = curDir == 0 ? cr + t : cr - t, nc = curDir == 1 ? cc + t : cc - t;
+ if (curDir % 2 == 0) {
+ cr += curDir == 0 ? 1 : -1;
+ if (!check(nr, cc))
+ return false;
+
+ curDir == 0 ? v.insert({ cc, {cr, nr} }) : v.insert({ cc, {nr, cr} });
+ cr = nr;
+ }
+ else {
+ cc += curDir == 1 ? 1 : -1;
+ if (!check(cr, nc))
+ return false;
+
+ curDir == 1 ? h.insert({ cr, {cc, nc} }) : h.insert({ cr, {nc, cc} });
+ cc = nc;
+ }
+ ans += t;
+
+ if ((curDir == 1 && dir == 'L') || (curDir == 3 && dir =='R'))
+ curDir = 0;
+ else if ((curDir == 2 && dir == 'L') || (curDir == 0 && dir == 'R'))
+ curDir = 1;
+ else if ((curDir == 3 && dir == 'L') || (curDir == 1 && dir == 'R'))
+ curDir = 2;
+ else if ((curDir == 0 && dir == 'L') || (curDir == 2 && dir == 'R'))
+ curDir = 3;
+ return true;
+}
+
+bool check(LL nr, LL nc) {
+ if (curDir % 2 == 0) {
+ LL higher = curDir == 0 ? nr : cr, lower = curDir == 0 ? cr : nr;
+ if (curDir == 0) {
+ for (auto iter = h.begin(); iter != h.end(); iter++) {
+ if (lower <= (*iter).first && higher >= (*iter).first && (*iter).second.first <= cc && (*iter).second.second >= cc) {
+ ans += (*iter).first - lower + 1;
+ return false;
+ }
+ }
+ }
+ else {
+ auto iter = h.end();
+ iter--;
+ for (; iter != h.begin(); iter--) {
+ if (lower <= (*iter).first && higher >= (*iter).first && (*iter).second.first <= cc && (*iter).second.second >= cc) {
+ ans += higher - (*iter).first + 1;
+ return false;
+ }
+ }
+ if (lower <= (*iter).first && higher >= (*iter).first && (*iter).second.first <= cc && (*iter).second.second >= cc) {
+ ans += higher - (*iter).first + 1;
+ return false;
+ }
+ }
+ for (auto iter = v.begin(); iter != v.end(); iter++) {
+ int vc = (*iter).first, vlh = (*iter).second.first, vhh = (*iter).second.second;
+
+ if (cc == vc && ((higher >= vlh && higher <= vhh) || (lower >= vlh && lower <= vhh) || (higher > vhh && lower < vlh))) {
+ ans += curDir == 0 ? vlh - lower + 1 : higher - vhh + 1;
+ return false;
+ }
+ }
+ }
+ else {
+ LL higher = curDir == 1 ? nc : cc, lower = curDir == 1 ? cc : nc;
+ if (curDir == 1) {
+ for (auto iter = v.begin(); iter != v.end(); iter++)
+ if (lower <= (*iter).first && higher >= (*iter).first && (*iter).second.first <= cr && (*iter).second.second >= cr) {
+ ans += (*iter).first - lower + 1;
+ return false;
+ }
+ }
+ else {
+ auto iter = v.end();
+ iter--;
+ for (; iter != v.begin(); iter--)
+ if (lower <= (*iter).first && higher >= (*iter).first && (*iter).second.first <= cr && (*iter).second.second >= cr) {
+ ans += higher - (*iter).first + 1;
+ return false;
+ }
+ if (lower <= (*iter).first && higher >= (*iter).first && (*iter).second.first <= cc && (*iter).second.second >= cc) {
+ ans += higher - (*iter).first + 1;
+ return false;
+ }
+ }
+ for (auto iter = h.begin(); iter != h.end(); iter++) {
+ int hh = (*iter).first, hlc = (*iter).second.first, hhc = (*iter).second.second;
+
+ if (cr == hh && ((higher >= hlc && higher <= hhc) || (lower >= hlc && lower <= hhc) || (higher > hhc && lower < hlc))) {
+ ans += curDir == 1 ? hlc - lower + 1: higher - hhc + 1;
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
Comments powered by Disqus.
1
+2
+3
+
1. 입력으로 받은 것이 팰린드롬인지 확인
+2. 팰린드롬이면 from-to 사이에 있는 모든 건 다 팰린드롬이다. -> DP에 팰린드롬임을 표시
+ 아니면, from-to에서 팰린드롬이 아님을 판별한 곳까지 팰린드롬이 아니다 -> DP에 팰린드롬이 아님을 표시
+
1
+2
+3
+4
+
아무리 잘 짜도
+ios::sync_with_stdio(false);
+cin.tie(0);
+를 써줘야 통과가 됨.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+
#include <iostream>
+#include <cstring>
+#define MAX_LENGTH 2001
+
+using namespace std;
+
+int n[MAX_LENGTH], numOfN, DP[MAX_LENGTH][MAX_LENGTH];
+
+bool isPalindrome(int from, int to);
+
+int main() {
+ ios::sync_with_stdio(false);
+ cin.tie(0);
+ cin >> numOfN;
+ for (int i = 1; i <= numOfN; i++) {
+ cin >> n[i];
+ }
+ int numOfQ;
+ cin >> numOfQ;
+ for (int i = 0; i < numOfQ; i++) {
+ int from, to;
+ cin >> from >> to;
+ if (isPalindrome(from, to))
+ cout << 1 << '\n';
+ else
+ cout << 0 << '\n';
+ }
+}
+
+bool isPalindrome(int from, int to) {
+ if (DP[from][to] == 1)
+ return true;
+ else if (DP[from][to] == 2)
+ return false;
+ else {
+ int fromEnd = (from + to) / 2, toEnd, tempFromEnd, temptoEnd;
+ if ((from + to) % 2 == 0)
+ toEnd = (from + to) / 2;
+ else
+ toEnd = fromEnd + 1;
+
+ bool check = true;
+ for (int i = from, j = to; i <= fromEnd && j >= toEnd; i++, j--) {
+ if (DP[i][j] == 2) {
+ check = false;
+ tempFromEnd = i;
+ temptoEnd = j;
+ break;
+ }
+ if (DP[i][j] == 1)
+ break;
+ if (n[i] != n[j]) {
+ check = false;
+ tempFromEnd = i;
+ temptoEnd = j;
+ break;
+ }
+ }
+
+ if (check) {
+ for (int i = from, j = to; i <= fromEnd && j >= toEnd; i++, j--) {
+ if (DP[i][j] != 1)
+ DP[i][j] = 1;
+ else
+ break;
+ }
+ return true;
+ }
+ else {
+ for (int i = from, j = to; i <= tempFromEnd && j >= temptoEnd; i++, j--) {
+ DP[i][j] = 2;
+ }
+ return false;
+ }
+ }
+}
+
Comments powered by Disqus.
구간합 정의 : i ~ j 까지의 구간합 = (1~ j 까지의 구간합) - (1 ~ i -1 까지의 구간합)
위 정의에 따라 우리가 구해야하는 (i ~ j 까지의 구간합) % m = 0 은
((1~ j 까지의 구간합) % m - (1 ~ i -1 까지의 구간합) % m) % m 과 같음
따라서 (1~ j 까지의 구간합) % m = (1 ~ i -1 까지의 구간합) % m 인 (i, j) 가 조건을 만족함.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+
#include <iostream>
+
+typedef long long ll;
+using namespace std;
+
+int n, m, num[1000100], save[1100];
+ll sum[1000100];
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+
+ cin >> n >> m;
+ cin >> num[0];
+ sum[0] = num[0];
+ for (int i = 1; i < n; i++) {
+ cin >> num[i];
+ sum[i] = sum[i - 1] + num[i];
+ }
+
+ save[0] = 1;
+ for (int i = 0; i < n; i++)
+ save[sum[i] % m]++;
+
+ ll cnt = 0;
+ for (int i = 0; i < m; i++) {
+ ll x = save[i] -1;
+ cnt += (x * (x + 1) / 2);
+ }
+ cout << cnt;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+
#include <iostream>
+
+using namespace std;
+
+int visit[1010][1010], n, m, map[1010][1010];
+
+int max(int a, int b) {
+ return a > b ? a : b;
+}
+
+int main() {
+ ios::sync_with_stdio(false);
+ cin.tie(NULL);
+ cin >> n >> m;
+ for (int i = 1; i <= n; i++)
+ for (int j = 1; j <= m; j++) {
+ cin >> map[i][j];
+ }
+
+ for (int i = 1; i <= n; i++)
+ for (int j = 1; j <= m; j++)
+ visit[i][j] = map[i][j] + max(max(visit[i - 1][j], visit[i][j - 1]), visit[i - 1][j - 1]);
+
+ cout << visit[n][m];
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+
1. 연속된 원소를 크게 이등분하여 계산할 수 있음 ex) (start ~ i, i+1~end)
+2. dp(start, end)는 start에서 end까지의 범위를 계산할 때 최소비용.
+3. 현재 비용은, matrixt[start][0]*matrix[i][1]*matrix[end][1] 로 계산할 수 있음.
+4. start == end 일때 비용은 0
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+
#include <iostream>
+#define MAX_MATRIX 501
+
+using namespace std;
+
+int numOfMatrix, matrix[MAX_MATRIX][2], DP[MAX_MATRIX][MAX_MATRIX];
+
+int getMinCalulate(int start, int end);
+long long min(long long a, int b) {
+ return a < b ? a : b;
+}
+
+int main() {
+ cin >> numOfMatrix;
+
+ for (int i = 0; i < numOfMatrix; i++)
+ cin >> matrix[i][0] >> matrix[i][1];
+
+ cout << getMinCalulate(0, numOfMatrix - 1);
+}
+
+int getMinCalulate(int start, int end) {
+ if (start == end)
+ return 0;
+ if (DP[start][end] != 0)
+ return DP[start][end];
+
+ long long result = 3000000000;
+ for (int i = start; i < end; i++) {
+ result = min(result, getMinCalulate(start, i) + getMinCalulate(i + 1, end) + (matrix[start][0]*matrix[i][1]*matrix[end][1]));
+
+ }
+
+ return DP[start][end] = result;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+
1. 왼쪽에서 오른쪽으로 LIS, 오른쪽에서 왼쪽으로 LIS 후, 모든 점에 대하여 l[i] + r[i] - 1 (길이가 1이면 1일때, 0일경우는 + 1 해줌) 가 최대가 되는 점을 찾고
+ 그점에서의 l[i] + r[i] -1 를 출력하면 됨.
+
+2. 길이가 최대1000이므로 dp로 안해도 되는데 해도 무방
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+
#include <iostream>
+#include <algorithm>
+#include <cstring>
+
+using namespace std;
+
+int N, num[1001], l[1001], r[1001], t[1001], ind;
+
+int generateLIS();
+void left();
+void right();
+
+int main() {
+ cin >> N;
+ for (int i = 0; i < N; i++)
+ cin >> num[i];
+
+ cout << generateLIS() << endl;
+}
+
+int generateLIS() {
+ left();
+ memset(t, 0, sizeof(t));
+ right();
+
+ for (int i = 0; i < N; i++) {
+ cout << l[i] << " ";
+ }
+ cout << endl;
+ for (int i = 0; i < N; i++) {
+ cout << r[i] << " ";
+ }
+ cout << endl;
+
+ int result = 0;
+ for (int i = 0; i < N; i++) {
+ int c = l[i] + r[i] + 1;
+ result = result > c ? result : c;
+ }
+ return result;
+}
+
+void left() {
+ l[0] = 0;
+ t[0] = num[0];
+ ind = 1;
+ for (int i = 1; i < N; i++) {
+ int* p = lower_bound(&t[0], &t[ind], num[i]);
+
+ if (*p == num[i])
+ l[i] = p - t;
+ else {
+ l[i] = p - t;
+ *p = num[i];
+ if (p - t == ind)
+ ind++;
+ }
+ }
+ for (int i = 0; i < N; i++)
+ cout << t[i] << " ";
+ cout << endl;
+}
+
+void right() {
+ r[N - 1] = 0;
+ t[0] = num[N - 1];
+ ind = 1;
+ for (int i = N - 2; i >= 0; i--) {
+ int* p = lower_bound(&t[0], &t[ind], num[i]);
+
+ if (*p == num[i])
+ r[i] = p - t;
+ else {
+ r[i] = p - t;
+ *p = num[i];
+ if (p - t == ind)
+ ind++;
+ }
+ }
+ for (int i = 0; i < N; i++)
+ cout << t[i] << " ";
+ cout << endl;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+
1. 긴 한 줄의 파일들을 두조각으로 분리해서 찾는 방식으로 DP를 함
+2. 먼저 0, k-1를 넣음
+3. (0, k-1)의 파일 크기의 합을 구한 후, (0,0)-(1,k-1), (0, 1)-(2,k-1) ... 로 모든 두 조각을 만든 후, 그 조각의 비용을 구함
+ -> start == end 일 경우 합치지 않으므로 비용은 0
+ ex) (0,1) 일 경우, 0 + 0 + file[0] + file[1]
+4. 각 조각의 비용은 dp[start][end]에 저장함.
+
1
+
이전 tc의 결과가 dp를 오염시킬 수 있으므로, dp배열은 항상 초기화한다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+
#include <iostream>
+#include <cstring>
+#define MAX_FILE 501
+
+using namespace std;
+
+int k, file[MAX_FILE], DP[MAX_FILE][MAX_FILE], fileSum[MAX_FILE][MAX_FILE], output;
+
+int dp(int start, int end);
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+
+int main() {
+ int tc;
+ cin >> tc;
+ for (int i = 0; i < tc; i++) {
+ cin >> k;
+ for (int j = 0; j < k; j++) {
+ cin >> file[j];
+ }
+ cout << dp(0, k - 1) << endl;
+ memset(DP, 0, sizeof(DP));
+ memset(fileSum, 0, sizeof(DP));
+ }
+}
+
+int dp(int start, int end) {
+ if (start == end)
+ return 0;
+ if (DP[start][end] != 0)
+ return DP[start][end];
+
+ int cur = fileSum[start][end];
+ if (cur == 0) {
+ for (int i = start; i <= end; i++)
+ cur += file[i];
+ fileSum[start][end] = cur;
+ }
+
+ int result = 2000000000;
+ for (int i = start; i < end; i++) {
+ result = min(result, dp(start, i) + dp(i + 1, end));
+ }
+
+ //cout << start << "\t" << end << "\t" << result << "\t" << cur <<endl;
+ return DP[start][end] = result + cur;
+}
+
Comments powered by Disqus.
1
+2
+
1. 0~100만까지 하나씩 올라가며, 되는지 검사하고, 가장 적게 누르는 건지 저장
+2. 되는지 검사할 때는, 고장난 버튼을 bool 배열에 저장하여 바로바로 참조가능하게 하고, 뒤에서부터 하나씩 검사하자
+
1
+2
+3
+
1. 처음엔 들어온 버튼의 자릿수에 맞게, 모든 숫자를 검사하되 재귀로 수를 하나씩 채워하는 식으로 하여 안되는 건 미리 제거하는 식으로 함
+ -> ex) 2528이면 모든 4자리수를 검사하되, 앞에서부터 안되는건 배제하며 채워감
+2. 그러나 자릿수를 더 크게 해도 최소가 될 경우가 존재. 따라서 자릿수를 꽉채워서 모든 수를 검사하였으나 설계에 어려움을 느낌
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+
#include <iostream>
+#include <cstring>
+#include <cmath>
+
+using namespace std;
+
+int to;
+bool isable[10];
+
+int pushButton();
+int check(int cur);
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+
+int main() {
+ cin >> to;
+
+ int n, t;
+ cin >> n;
+ memset(isable, 1, sizeof(isable));
+ for (int i = 0; i < n; i++) {
+ cin >> t;
+ isable[t] = false;
+ }
+
+ cout << min(abs(100 - to), pushButton());
+}
+
+
+int pushButton() {
+ int result = 2000000000, end = to * 10;
+
+ for (int i = 0; i <= end; i++) {
+ int length = check(i);
+ if(length != -1)
+ result = min(result, abs(to - i) + length);
+ }
+
+ return result;
+}
+
+int check(int cur) {
+ int t = 10, index = 0, end = cur * 10;
+
+ if (end == 0)
+ end = 10;
+
+ while (t <= end) {
+ int c = cur % t;
+ c = c / (t / 10);
+
+ if (!isable[c])
+ return -1;
+
+ t *= 10;
+ index++;
+ }
+
+ return index;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
1. 페르마의 소정리 적용
+ nCk = n! / k!(n-k)! % 1000000007 에서 A = n!, B = k!(n-k)!, p = 1000000007 이라고 할 때
+
+ 위 식은 (A * B^(-1)) % p 를 성립
+ 페르마의 소정리는 p가 소수일때, p와 서로소인 a가 있으면, a^p mod p = a mod p 가 성립. -> a^p-1 mod p = 1 mod p 이므로 a^p-1 mod p = 1 이 성립함을 알려주는 공식
+ 여기서 양변에 a를 한번 더 나누면
+ a^p-2 mod p = a^(-1) 이 성립함을 알 수 있음
+ 따라서 위 이항 계수 식은 다음처럼 변형된다.
+ (A * B^(-1)) % p = (A * B^(p-2)) % p
+2. A = n!과 B = k!(n-k)! 를 구한 후, 거듭제곱 공식으로 B^(p-2)를 구하면 됨.
+
+
+ A = n*...*(n-k+1), B = k! 로 두고 풀어도 됨
+-> 처음에 틀렸던 이유는 (k!)^(p-2)가 아니라 (k)^(p-2)로 풀었기 때문
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+
#include <iostream>
+#define DIVIDE 1000000007
+
+using namespace std;
+
+long long getCoefficient(int n, int k);
+long long getPower(long long n, long long k);
+
+int main() {
+ int n, k;
+ cin >> n >> k;
+ cout << getCoefficient(n, k) << endl;
+
+}
+
+long long getCoefficient(int n, int k) {
+ if (k == 0 || k == n)
+ return 1;
+
+ long long top = 1, bottom = 1, bottom2 = 1;
+
+ for (int i = n; i >= 1; i--)
+ top = (top * i) % DIVIDE;
+ top %= DIVIDE;ㅁ
+ for (int i = k; i >= 1; i--)
+ bottom = (bottom * i) % DIVIDE;
+ bottom %= DIVIDE;
+ for (int i = n - k; i >= 1; i--)
+ bottom2 = (bottom2 * i) % DIVIDE;
+ bottom2 %= DIVIDE;
+
+
+ bottom = (bottom * bottom2) % DIVIDE;
+ top %= DIVIDE;
+
+ return (top * (getPower(bottom, DIVIDE - 2))) % DIVIDE;
+}
+
+long long getPower(long long n, long long k) {
+ long long result = 1, temp = n;
+
+ while (k > 0) {
+ if (k % 2 == 1) {
+ result = (result * temp) % DIVIDE;
+ }
+ temp = (temp * temp) % DIVIDE;
+ k /= 2;
+ }
+
+ return result % DIVIDE;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
1. 트리만들기
+ 1. check 배열을 만들고, 1번 노드만 true 표시함
+ 2. 정점 쌍이 들어왔을 때, 둘중에 check 표시된 것이 A, 안된 것이 B라고 할때, B의 부모엔 A를, 깊이엔 A+1을 넣고, check[B] 에 true 표시함
+ 3. true 표시가 끝나고, B에 인접한 정점들을 BFS로 끝까지 방문하면서 깊이를 부여하고 check 표시함.
+ 4. 만약 둘 다 check에 표시가 안돼있으면, 두 정점의 인접한 정점 벡터에 둘다 추가한다.
+2. LCA 찾기
+
+ 1. log2의 부모를 찾는 방법으로 풀면 아주 빠르게 가능. 하지만, 이 방법은 어렵다
+ 2. 간단하게 두 정점 중 깊이가 더 깊은 것을 부모를 찾아가면서 덜 깊은 것과 깊이를 똑같이 맞춤
+ 3. 깊이가 같아지면, 정점이 같아질때까지 둘다 부모를 찾아감
+ -> 1초대.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+
#include <iostream>
+#include <vector>
+#include <algorithm>
+#define MAX_NODE 50001
+
+using namespace std;
+
+typedef struct Node {
+ int depth;
+ int parent;
+ vector<int> closeNode;
+} Node;
+Node node[MAX_NODE];
+int numOfNode, list[MAX_NODE];
+bool check[MAX_NODE];
+
+int findLCS(int first, int second);
+void makeTree(int root);
+
+int main() {
+ ios_base::sync_with_stdio(false);
+ cin.tie(NULL);
+ cout.tie(NULL);
+
+ cin >> numOfNode;
+ check[1] = true;
+ int temp1, temp2, numOfPair;
+
+ for (int i = 0; i < numOfNode-1; i++) {
+ cin >> temp1 >> temp2;
+ if (check[temp1]) {
+ node[temp2].depth = node[temp1].depth + 1;
+ node[temp2].parent = temp1;
+ check[temp2] = true;
+ if(node[temp2].closeNode.size() > 0)
+ makeTree(temp2);
+ }
+ else if (check[temp2]) {
+ node[temp1].depth = node[temp2].depth + 1;
+ node[temp1].parent = temp2;
+ check[temp1] = true;
+ if (node[temp1].closeNode.size() > 0)
+ makeTree(temp1);
+ }
+ else {
+ node[temp1].closeNode.push_back(temp2);
+ node[temp2].closeNode.push_back(temp1);
+ }
+ }
+
+ cin >> numOfPair;
+ for (int i = 0; i < numOfPair; i++) {
+ cin >> temp1 >> temp2;
+ int curResult = node[temp1].depth < node[temp2].depth ? findLCS(temp1, temp2) : findLCS(temp2, temp1);
+ cout << curResult << "\n";
+ }
+}
+
+void makeTree(int root) {
+ int index = 0, length = 0;
+ list[length++] = root;
+
+ while (index < length) {
+ int cur = list[index++];
+ int depth = node[cur].depth + 1;
+
+ for (int i = 0; i < node[cur].closeNode.size(); i++) {
+ int t = node[cur].closeNode[i];
+ if (!check[t]) {
+ node[t].depth = depth;
+ node[t].parent = cur;
+ check[t] = true;
+ list[length++] = t;
+ }
+ }
+ node[cur].closeNode.clear();
+ }
+ return;
+}
+
+int findLCS(int first, int second) {
+ while (node[first].depth != node[second].depth)
+ second = node[second].parent;
+ while (first != second) {
+ first = node[first].parent;
+ second = node[second].parent;
+ }
+ return first;
+}
+
Comments powered by Disqus.
1
+2
+
1. 그냥 현재 노드에서 이전의 상태가 X였을때의 최솟값을 저장하는 dp 배열 DP[1000][3] 을 선언하고 DP를 해주면 된다.
+2. 첫번째와 마지막이 상관이없으므로 매번 값을 초기화 시켜줄 필요는 없다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+
#include <iostream>
+#define INF 2000000000
+using namespace std;
+
+int N, cost[1000][3], DP[1000][3];
+
+int getMin(int deep, int bf);
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+int main() {
+ cin >> N;
+ for (int i = 0; i < N; i++)
+ cin >> cost[i][0] >> cost[i][1] >> cost[i][2];
+
+ int result = INF;
+ for (int i = 0; i < 3; i++) {
+ result = min(result, getMin(1, i) + cost[0][i]);
+ }
+
+ cout << result;
+}
+
+int getMin(int deep, int bf) {
+ if (deep == N) {
+ return 0;
+ }
+ if (DP[deep][bf] != 0)
+ return DP[deep][bf];
+
+ int result = INF;
+
+ for (int i = 0; i < 3; i++)
+ if (i != bf)
+ result = min(result, getMin(deep + 1, i)+ cost[deep][i]);
+
+ return DP[deep][bf] = result;
+}
+
Comments powered by Disqus.
1
+2
+
1. 밸만포드로 푼다.
+2. 길이는 long long으로 저장한다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+
#include <bits/stdc++.h>
+
+using namespace std;
+
+struct Road {
+ int to;
+ int time;
+};
+struct City {
+ vector<Road> next;
+ long long minTime;
+ int before;
+};
+
+City city[501];
+list<Road> q;
+int N, M;
+bool generateMinTime();
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cin >> N >> M;
+
+ int a, b, c;
+ for (int i = 0; i < M; i++) {
+ cin >> a >> b >> c;
+ city[a].next.push_back({ b, c });
+ }
+ for (int i = 2; i <= N; i++)
+ city[i].minTime = 2000000000000;
+
+ if (generateMinTime()) {
+ for (int i = 2; i <= N; i++) {
+ if (city[i].minTime != 2000000000000)
+ cout << city[i].minTime << "\n";
+ else
+ cout << -1 << "\n";
+ }
+ }
+ else
+ cout << -1 << "\n";
+}
+
+bool generateMinTime() {
+ for (int i = 0; i < N - 1; i++) {
+ for (int j = 1; j <= N; j++) {
+ if (city[j].minTime != 2000000000000) {
+ for (int k = 0; k < city[j].next.size(); k++) {
+ Road t = city[j].next[k];
+ long long nt = city[j].minTime + t.time;
+
+ if (nt < city[t.to].minTime)
+ city[t.to].minTime = nt;
+ }
+ }
+ }
+ }
+
+ for (int j = 1; j <= N; j++) {
+ if (city[j].minTime != 2000000000000) {
+ for (int k = 0; k < city[j].next.size(); k++) {
+ Road t = city[j].next[k];
+ long long nt = city[j].minTime + t.time;
+
+ if (nt < city[t.to].minTime)
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+
1. 1번 노드를 최상위 노드라고 가정하고 품
+2. 1번 노드부터 시작하여 트리를 밑으로 탐색함.
+3. 끝까지 닿으면, 거리를 올리면서(bottom-top) 다시 위로 올라감(재귀로 탐색하면 됨)
+4. 한 노드에서 재귀로 반환하는 건, 자신의 자식 노드에서 올라오는 것중 가장 큰 값(끝까지 갔을 때의 값들 중 가장 큰 값)
+5. 또 한 노드에선, 자식 노드에서 올라오는 것 중 가장 큰 값 2개를 저장하여, 탐색이 끝나면, 그 두개의 합이 전역으로 저장되어있는 length값보다 크면 저장.
+6. 탐색이 모두 끝나면, 전역 length에 트리의 지름이 저장되어있음
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+
#include <iostream>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+vector<pair<int, int>> point[100001];
+int N, maxLength;
+bool check[100001];
+
+long long getLength(int cur);
+long long max(long long a, long long b) {
+ return a > b ? a : b;
+}
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cout.tie(0);
+
+ cin >> N;
+ for (int i = 1; i <= N; i++) {
+ int cur, a, b;
+ cin >> cur;
+ cin >> a;
+ while (a != -1) {
+ cin >> b;
+ point[cur].push_back({ a, b });
+ cin >> a;
+ }
+ }
+
+ getLength(1);
+ cout << maxLength;
+}
+
+long long getLength(int cur) {
+ check[cur] = true;
+
+ bool isLast = true;
+ long long result[2] = { 0, 0 };
+ for (int i = 0; i < point[cur].size(); i++) {
+ if (!check[point[cur][i].first]) {
+ long long tmp = getLength(point[cur][i].first) + point[cur][i].second;
+
+ result[1] = max(result[1], tmp);
+ if (result[1] > result[0]) {
+ tmp = result[0];
+ result[0] = result[1];
+ result[1] = tmp;
+ }
+
+ isLast = false;
+ }
+ }
+
+ if (isLast)
+ return 0;
+ else {
+ maxLength =max(maxLength, result[0] + result[1]);
+ return max(result[0], result[1]);
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+
#include <iostream>
+#include <queue>
+#include <vector>
+#include <cstring>
+#define INF 2000000000000
+
+typedef long long ll;
+using namespace std;
+
+int n, m, s, e, path[1001];
+vector<int> p;
+vector<pair<int, int>> to[1001];
+priority_queue<pair<ll, int>> q;
+ll cost[1001];
+
+void dijkstra();
+void checkPath();
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cout.tie(0);
+ cin >> n >> m;
+ while (m--) {
+ int a, b, c;
+ cin >> a >> b >> c;
+ to[a].push_back({ b, c });
+ }
+ cin >> s >> e;
+
+ dijkstra();
+ checkPath();
+ cout << cost[e] << "\n";
+ cout << p.size() << "\n";
+ for (int i = p.size()-1; i >= 0; i--)
+ cout << p[i] << " ";
+}
+
+void dijkstra() {
+ for (int i = 0; i <= n; i++)
+ cost[i] = INF;
+
+ cost[s] = 0;
+ path[s] = -1;
+ q.push({ 0, s });
+ while (!q.empty()) {
+ ll c = -q.top().first;
+ int cur = q.top().second;
+ q.pop();
+
+ if (c > cost[cur])
+ continue;
+
+ for (int i = 0; i < to[cur].size(); i++) {
+ ll nc = c + to[cur][i].second;
+ int ncur = to[cur][i].first;
+
+ if (nc < cost[ncur]) {
+ cost[ncur] = nc;
+ path[ncur] = cur;
+ q.push({ -nc, ncur });
+ }
+ }
+ }
+ return;
+}
+
+void checkPath() {
+ int cur = e;
+ while (path[cur] != -1) {
+ p.push_back(cur);
+ cur = path[cur];
+ }
+ p.push_back(cur);
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+
1. 가장 가중차가 작은 간선부터 검사
+2. 사이클 검사
+ 1. 간선의 양단이 전부 이미 안들어갔으면 양단을 같은 벡터에 집어넣고, set 벡터에 집어넣음
+ 2. 한쪽만 들어갔다면, 들어가 있는 한쪽의 set벡터에 안들어간 쪽을 집어넣음
+ 3. 두개 다 들어가 있고, 들어간 집합이 같다면, 사이클 형성 -> false 반환
+ 4. 두개 다 들어가 있고, 들어간 집합이 다르다면, 두개를 합침.
+
1
+2
+3
+
간선을 저장하는 Edge 배열
+노드를 저장하는 Node 배열. - 배열의 인덱스가 노드의 번호이고, 저장돼있는 정보는 들어가있는 셋의 번호. 아직 포함안됐으면 -1
+셋을 저장하는 set 벡터 - vector<vector<int>> set 으로 선언하여, set안에 각 vector<int>는 하나의 집합을 표현.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+
#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <cstring>
+#define MAX_EDGE 1000000
+#define MAX_NODE 10000
+
+using namespace std;
+
+typedef struct Edge {
+ int node1;
+ int node2;
+ int value;
+
+ bool operator < (Edge e) {
+ return value < e.value;
+ }
+} Edge;
+
+Edge edge[MAX_EDGE];
+int nodeSetNum[MAX_NODE];
+vector<vector<int>> set;
+int numOfNode, numOfEdge;
+
+long long getMST();
+bool unionFind(int index);
+
+int main() {
+ cin >> numOfNode >> numOfEdge;
+ for (int i = 0; i < numOfEdge; i++)
+ cin >> edge[i].node1 >> edge[i].node2 >> edge[i].value;
+ for (int i = 0; i < numOfEdge; i++) {
+ edge[i].node1;
+ edge[i].node2;
+ }
+
+ cout << getMST();
+}
+
+long long getMST() {
+ sort(edge, &edge[numOfEdge]);
+ memset(nodeSetNum, -1, sizeof(nodeSetNum));
+ long long sum = 0;
+ int edgeCount = 0;
+ for(int i = 0; i<numOfEdge; i++) {
+ if (unionFind(i)) {
+ sum += edge[i].value;
+ edgeCount++;
+ }
+ //노드 개수 -1 이면 트리완성
+ if (edgeCount == numOfNode - 1)
+ break;
+ }
+
+ return sum;
+}
+
+bool unionFind(int index) {
+ if (nodeSetNum[edge[index].node1] == -1 && nodeSetNum[edge[index].node2] == -1) {
+ vector<int> temp;
+ temp.push_back(edge[index].node1);
+ temp.push_back(edge[index].node2);
+ set.push_back(temp);
+ nodeSetNum[edge[index].node1] = set.size() - 1;
+ nodeSetNum[edge[index].node2] = set.size() - 1;
+ }
+ else if (nodeSetNum[edge[index].node1] == -1) {
+ nodeSetNum[edge[index].node1] = nodeSetNum[edge[index].node2];
+ set[nodeSetNum[edge[index].node1]].push_back(edge[index].node1);
+ }
+ else if (nodeSetNum[edge[index].node2] == -1) {
+ nodeSetNum[edge[index].node2] = nodeSetNum[edge[index].node1];
+ set[nodeSetNum[edge[index].node2]].push_back(edge[index].node2);
+ }
+ else if (nodeSetNum[edge[index].node1] == nodeSetNum[edge[index].node2])
+ return false;
+ else {
+ if (nodeSetNum[edge[index].node1] < nodeSetNum[edge[index].node2]) {
+ vector<int> move = set[nodeSetNum[edge[index].node2]];
+ for (int i = 0; i < move.size(); i++) {
+ nodeSetNum[move[i]] = nodeSetNum[edge[index].node1];
+ set[nodeSetNum[edge[index].node1]].push_back(move[i]);
+ }
+ }
+ else {
+ vector<int> move = set[nodeSetNum[edge[index].node1]];
+ for (int i = 0; i < move.size(); i++) {
+ nodeSetNum[move[i]] = nodeSetNum[edge[index].node2];
+ set[nodeSetNum[edge[index].node2]].push_back(move[i]);
+ }
+ }
+ }
+ return true;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
1. 보석을 가치순으로 내림차순으로 정렬
+2. 가방을 multiset에 저장함
+3. 가치가 큰 보석부터 차례대로 꺼내면서 적절한 가방을 선택하고, 집어넣음
+ -적절한 가방 : 무게가 같으면 가장 적절. 같지 않으면 남는 무게가 가장 적은 가방
+ -찾는 법
+ 1. 같은 게 있는지 확인
+ 2. 없으면, 현재 검사하는 보석의 무게를 넣고 그대로 빼면 넣었던 자리에 있는 옆 가방의 반복자가 반환되는데
+ 이 반복자가 multiset.end()와 같으면 보석 무게가 너무 무거워서 넣을 수 있는 가방이 없는 것이므로 다음보석 검사
+ 아니면 그 반복자가 가리키는 가방에 집어넣는다.
+ -집어넣은 다음엔 multiset에서 넣은 가방을 삭제한다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
1. 보석은 가치순으로 정렬하고, 무게가 가장 적절한 가방에 넣어야된다고 생각함
+2. 가치순으로 정렬하는 거야 쉬운데 적절한 가방을 택하는 과정이 어려웠음
+ -N*N 방법 : 순차탐색. 가방무게 - 보석무게 의 결과가 0또는 양수인 것중 첫번째를 적절한 가방으로 선택. 끝까지가면 없는 것
+ -> 당연히 시간초과남
+ -NlogN방법 : 이분탐색. 적절한 가방무게를 이분탐색함.
+ -> 가방을 하나씩 찾을 때마다, 빈 가방이 생기는데, 이 빈가방이 많아질수록 탐색의 시간이 더 걸리게 됨.(빈가방을 피하는 시간이 계속 증가함)
+ -> 그리고 보석과 같은 무게를 찾는게 아니다보니 제대로 찾는 것 같지도 않음
+3. 이분탐색식으로 하되, 가방을 선택할 때마다, 그 자료구조에서 가방을 지우되 가방을 지우는 연산이 복잡하지 않은 자료구조를 선택해야겠다는 생각이 듦
+ -> 이진탐색트리로 해야겠다고 생각이 듦
+4. 하지만 솔직히 이진탐색트리를 구현해본적이 한번도 없음
+5. 고민하던 중 set과 multiset에 대해 알게됨
+6. set인 중복이 없는 이진탐색트리처럼, multiset은 중복이 잇는 이진탐색트리처럼 사용할 수 있다는 것을 알게 됨
+
1
+
1. 이진탐색트리 구현 방법을 공부해보자.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+
#include <iostream>
+#include <algorithm>
+#include <set>
+#define MAX 3000000
+
+using namespace std;
+
+typedef struct Jewelry {
+ int weight;
+ int value;
+ bool operator < (Jewelry j) {
+ if (value != j.value)
+ return value > j.value;
+ else
+ return weight < j.weight;
+ }
+} Jewelry;
+
+Jewelry jewelry[MAX];
+multiset<int> bag;
+int numOfJewelry, numOfBag;
+
+long long maxValue();
+
+int main() {
+ cin >> numOfJewelry >> numOfBag;
+ for (int i = 0; i < numOfJewelry; i++)
+ cin >> jewelry[i].weight >> jewelry[i].value;
+ for (int i = 0; i < numOfBag; i++) {
+ int temp;
+ cin >> temp;
+ bag.insert(temp);
+ }
+
+ cout << maxValue();
+}
+
+//무게 넣어서 현재 위치 찾고, 현재 위치의 다음번 가방에 집어넣는 식
+long long maxValue() {
+ sort(jewelry, &jewelry[numOfJewelry]);
+
+ long long value = 0;
+ for (int i = 0; i < numOfJewelry; i++) {
+ if (bag.empty())
+ break;
+ multiset<int>::iterator find = bag.find(jewelry[i].weight);
+ if (find == bag.end()) {
+ multiset<int>::iterator index = bag.insert(jewelry[i].weight);
+ multiset<int>::iterator temp = bag.erase(index);
+ if (temp == bag.end())
+ continue;
+ else
+ bag.erase(temp);
+ }
+ else
+ bag.erase(find);
+ value += jewelry[i].value;
+ }
+
+ return value;
+}
+
Comments powered by Disqus.
수를 두개 집합으로 나눔.
나눈 집합 각각에 대해 모든 경우를 살펴봐서 각 집합 내부에서 s에 도달한 횟수를 세고, 만들 수 있는 수와 그 수가 나온 횟수를 센다.
위에서 센 횟수로, 양 집합에서 만들 수 있는 수가 a, b이고, 이 a, b가 각 집합에서 나온 횟수를 c, d라고 하면,
a + b = s 일때, c * d만큼의 수를 전체 경우의 수에 더한다.
이때 save 배열을 set으로 구현한다면 메모리 사용량이 대폭 줄어든다.(각 집합이 최대 20개이니, 나올 수 있는 수의 개수는 2^20개로, 대략 100만개이므로, 현재보다 1/4로 줄일 수 있음)
#include <iostream>
+
+typedef long long ll;
+using namespace std;
+
+int n, s, num[40], last, save[2][4000001];
+ll ans;
+
+void dp(int cur, int acc, bool isPut);
+
+int main() {
+ cin >> n >> s;
+ for (int i = 0; i < n; i++)
+ cin >> num[i];
+
+ last = n;
+ if (n > 20) {
+ dp(20, 0, false);
+ last = 20;
+ }
+ dp(0, 0, false);
+
+ for (int i = 0; i <= 4000000; i++) {
+ int t = s - i + 4000000;
+ if (t <= 4000000)
+ if (save[0][i] && save[1][t])
+ ans += (ll)save[0][i] * (ll)save[1][t];
+ }
+
+ cout << ans;
+}
+
+void dp(int cur, int acc, bool isPut) {
+ if (cur == last) {
+ if (isPut) {
+ if (cur > 20)
+ save[1][acc + 2000000]++;
+ else
+ save[0][acc + 2000000]++;
+ if (acc == s)
+ ans++;
+ }
+ return;
+ }
+
+ dp(cur + 1, acc + num[cur], true);
+ dp(cur + 1, acc, isPut);
+
+ return;
+}
+Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+
1. 위, 오른쪽, 아래, 왼쪽으로 차례로 보냄. 보낼때, 보내는 쪽에 가까운 곳부터 하나씩 검사.
+2. 주의 사항 :
+ 2 4 8
+ 2 8 16
+ 4 2 32
+ 에서 위로 한번 보내면 맨 왼쪽 맨 위는 4가 되야하고 그 밑에 4가 와야함.
+ 하지만 내가 처음 짠 코드에서는 한번 업데이트 된곳을 저장안하고 그때그때 업데이트된 맵에 하나하나씩 적용했기에 맨왼쪽맨위에 8이 왔음
+ 이점에 주의
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+
#include <iostream>
+#include <cstring>
+#define MAX_WIDTH 21
+#define MAX_DEEP 5
+
+using namespace std;
+
+int map[MAX_WIDTH][MAX_WIDTH];
+int maxCell = 0;
+int width;
+
+void getProperties();
+void moveDP(int (*currentMap)[MAX_WIDTH], int deep = 0);
+void test() {
+ int m[3][3] = { 1,2,3,4,5,6,7,8,9 };
+ int(*map)[3] = m;
+ for (int i = 0; i < 3; i++) {
+ for (int j = 0; j < 3; j++)
+ cout << map[i][j];
+ cout << endl;
+ }
+ cout << endl;
+ int temp[3][3];
+ for (int i = 0; i < 3; i++)
+ memcpy(temp[i], map[i], sizeof(int) * 3);
+
+ temp[0][0] = 0;
+ temp[1][1] = 0;
+ temp[2][2] = 0;
+
+ for (int i = 0; i < 3; i++) {
+ for (int j = 0; j < 3; j++)
+ cout << map[i][j];
+ cout << endl;
+ }
+ cout << endl;
+ for (int i = 0; i < 3; i++) {
+ for (int j = 0; j < 3; j++)
+ cout << temp[i][j];
+ cout << endl;
+ }
+ cout << endl;
+
+ for (int i = 0; i < 3; i++)
+ memcpy(temp[i], map[i], sizeof(int) * 3);
+
+ for (int i = 0; i < 3; i++) {
+ for (int j = 0; j < 3; j++)
+ cout << temp[i][j];
+ cout << endl;
+ }
+ cout << endl;
+
+ temp[0][0] = 0;
+ temp[1][1] = 0;
+ temp[2][2] = 0;
+
+ for (int i = 0; i < 3; i++) {
+ for (int j = 0; j < 3; j++)
+ cout << temp[i][j];
+ cout << endl;
+ }
+ cout << endl;
+}
+int main() {
+ //test();
+ while (true) {
+ getProperties();
+ moveDP(map);
+ cout << maxCell;
+ maxCell = 0;
+ }
+}
+
+void getProperties() {
+ cin >> width;
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++)
+ cin >> map[i][j];
+}
+
+/*
+10
+8 8 4 16 32 0 0 8 8 8
+8 8 4 0 0 8 0 0 0 0
+16 0 0 16 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 16
+0 0 0 0 0 0 0 0 0 2
+위 오오위오 -> 128
+*/
+void moveDP(int(*currentMap)[MAX_WIDTH], int deep) {
+ if (deep == MAX_DEEP) {
+ for (int i = 0; i < width; i++) {
+ for (int j = 0; j < width; j++) {
+ if (currentMap[i][j] > maxCell)
+ maxCell = currentMap[i][j];
+ //cout << currentMap[i][j];
+ }
+ //cout << endl;
+ }
+ //cout << endl;
+ return;
+ }
+ int tempMap[MAX_WIDTH][MAX_WIDTH];
+ bool updated[MAX_WIDTH][MAX_WIDTH] = { 0, };
+ for (int i = 0; i < MAX_WIDTH; i++)
+ memcpy(tempMap[i], currentMap[i], sizeof(int) * MAX_WIDTH);
+
+ //위
+ for (int row = 1; row < width; row++)
+ for (int col = 0; col < width; col++)
+ if (tempMap[row][col] != 0)
+ for (int m = row - 1; m >= 0; m--) {
+ if (tempMap[m][col] != 0) {
+ if (tempMap[m][col] == tempMap[row][col] && !updated[m][col]) {
+ tempMap[m][col] *= 2;
+ tempMap[row][col] = 0;
+ updated[m][col] = true;
+ }
+ else {
+ tempMap[m + 1][col] = tempMap[row][col];
+ tempMap[row][col] = m == (row -1) ? tempMap[row][col] : 0;
+ }
+ break;
+ }
+ else if (m == 0) {
+ tempMap[m][col] = tempMap[row][col];
+ tempMap[row][col] = 0;
+ }
+ }
+ moveDP(tempMap, deep + 1);
+ for (int i = 0; i < MAX_WIDTH; i++) {
+ memcpy(tempMap[i], currentMap[i], sizeof(int) * MAX_WIDTH);
+ memset(updated[i], 0, sizeof(bool) * MAX_WIDTH);
+ }
+
+ //오른쪽
+ for (int col = width-2; col >= 0; col--)
+ for (int row = 0; row < width; row++)
+ if (tempMap[row][col] != 0)
+ for (int m = col + 1; m <= width-1; m++) {
+ if (tempMap[row][m] != 0) {
+ if (tempMap[row][m] == tempMap[row][col] && !updated[row][m]) {
+ tempMap[row][m] *= 2;
+ tempMap[row][col] = 0;
+ updated[row][m] = true;
+ }
+ else {
+ tempMap[row][m-1] = tempMap[row][col];
+ tempMap[row][col] = m == (col + 1) ? tempMap[row][col] : 0;
+ }
+ break;
+ }
+ else if (m == width-1) {
+ tempMap[row][m] = tempMap[row][col];
+ tempMap[row][col] = 0;
+ }
+ }
+ moveDP(tempMap, deep + 1);
+ for (int i = 0; i < MAX_WIDTH; i++) {
+ memcpy(tempMap[i], currentMap[i], sizeof(int) * MAX_WIDTH);
+ memset(updated[i], 0, sizeof(bool) * MAX_WIDTH);
+ }
+
+ //아래
+ for (int row = width-2; row >= 0; row--)
+ for (int col = 0; col < width; col++)
+ if (tempMap[row][col] != 0)
+ for (int m = row + 1; m <= width-1; m++) {
+ if (tempMap[m][col] != 0) {
+ if (tempMap[m][col] == tempMap[row][col] && !updated[m][col]) {
+ tempMap[m][col] *= 2;
+ tempMap[row][col] = 0;
+ updated[m][col] = true;
+ }
+ else {
+ tempMap[m - 1][col] = tempMap[row][col];
+ tempMap[row][col] = m == (row + 1) ? tempMap[row][col] : 0;
+ }
+ break;
+ }
+ else if (m == width-1) {
+ tempMap[m][col] = tempMap[row][col];
+ tempMap[row][col] = 0;
+ }
+ }
+ moveDP(tempMap, deep + 1);
+ for (int i = 0; i < MAX_WIDTH; i++) {
+ memcpy(tempMap[i], currentMap[i], sizeof(int) * MAX_WIDTH);
+ memset(updated[i], 0, sizeof(bool) * MAX_WIDTH);
+ }
+
+ //왼쪽
+ for (int col = 1; col <= width-1; col++)
+ for (int row = 0; row < width; row++)
+ if (tempMap[row][col] != 0)
+ for (int m = col - 1; m >= 0; m--) {
+ if (tempMap[row][m] != 0) {
+ if (tempMap[row][m] == tempMap[row][col] && !updated[row][m]) {
+ tempMap[row][m] *= 2;
+ tempMap[row][col] = 0;
+ updated[row][m] = true;
+ }
+ else {
+ tempMap[row][m + 1] = tempMap[row][col];
+ tempMap[row][col] = m == (col - 1) ? tempMap[row][col] : 0;
+ }
+ break;
+ }
+ else if (m == 0) {
+ tempMap[row][m] = tempMap[row][col];
+ tempMap[row][col] = 0;
+ }
+ }
+ moveDP(tempMap, deep + 1);
+ for (int i = 0; i < MAX_WIDTH; i++) {
+ memcpy(tempMap[i], currentMap[i], sizeof(int) * MAX_WIDTH);
+ memset(updated[i], 0, sizeof(bool) * MAX_WIDTH);
+ }
+}
+
Comments powered by Disqus.
1
+2
+
1. 그냥 앞에서부터 가능한 수를 채워나가는 백트래킹 방식을 사용하면 된다.
+2. 이때, 가능한 수는 ans를 채워간다는 얘기다. 즉, 가능한 경우만을 탐색하여 가서 정답만을 하나하나 채워가는 식으로 모든 경우를 탐색하면 됨.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+
#include <bits/stdc++.h>
+
+using namespace std;
+
+int N, ans[10];
+char S[10][10];
+bool gotAns;
+
+void makeArr(int deep, int beforeSum);
+bool check(int deep, int beforeSum);
+void goNext(int start, int end, int deep, int bs);
+
+int main() {
+ cin >> N;
+ for (int i = 0; i < N; i++)
+ for (int j = i; j < N; j++)
+ cin >> S[i][j];
+
+ makeArr(0, 0);
+ for (int i = 0; i < N; i++)
+ cout << ans[i] << " ";
+}
+
+void makeArr(int deep, int beforeSum) {
+ if (deep == N) {
+ gotAns = true;
+ return;
+ }
+
+ switch (S[deep][deep]) {
+ case '0':
+ goNext(0, 0, deep, beforeSum);
+ break;
+ case '+':
+ goNext(1, 10, deep, beforeSum);
+ break;
+ case '-':
+ goNext(-10, -1, deep, beforeSum);
+ break;
+ }
+}
+
+void goNext(int start, int end, int deep, int bs) {
+ for (int i = start; i <= end; i++) {
+ if (gotAns)
+ return;
+ if (check(deep, bs + i)) {
+ ans[deep] = i;
+ makeArr(deep + 1, bs + i);
+ }
+ }
+}
+
+bool check(int deep, int sum) {
+ int temp = sum;
+
+ for (int i = 0; i < deep; i++) {
+ if (S[i][deep] == '0' && temp != 0)
+ return false;
+ if (S[i][deep] == '+' && temp <= 0)
+ return false;
+ if (S[i][deep] == '-' && temp >= 0)
+ return false;
+ temp -= ans[i];
+ }
+ return true;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+
1. a라는 건물에 x분을 남기고 들어가는 것은, a에 연결된 모든 건물 b에 x+1분을 남기고 들어온 것과 같음
+2. 즉, 정보과학관에 0분을 남기고 들어오는 것을 시작으로 모든 경우를 탐색하면 된다.
+3. 쭉쭉 내려가다가 D분에 도달했을때, 장소가 정보과학관이면 1, 아니면 0을 리턴하여 바텀업으로 함
+4. DP에는 현재 위치와 시간으로 배열을 만들고, 그 위치에서 그 시간이 걸렸을 때의 결과를 1000000007로 나눈 값을 저장함
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+
#include <iostream>
+#include <vector>
+#include <cstring>
+#define MAX_MINUTE 100000
+#define DIVIDE 1000000007
+
+using namespace std;
+
+//0 : 정보, 1 : 전산, 2 : 미래, 3 : 신양 , 4: 한경직,
+//5 : 진리, 6 : 형남, 7 : 학생
+vector<vector<int>> map = { {1,2}, {0,2,3}, {0,1,3,4}, {1,2,4,5}, {2,3,5,6}, {3,4,7}, {4,7}, {5,6} };
+int D;
+int DP[8][MAX_MINUTE];
+
+int getMin(int num, int minute);
+
+int main() {
+ memset(DP, -1, sizeof(DP));
+ cin >> D;
+ cout << getMin(0, 0) << endl;
+}
+/*
+a 에 x를 남기고 들어오는 횟수는
+ a와 연결된 모든 b에 x+1를 남기고 들어오는 횟수와 같음
+*/
+
+int getMin(int num, int minute) {
+ if (minute == D)
+ return num == 0 ? 1 : 0;
+ if (DP[num][minute] != -1)
+ return DP[num][minute];
+
+ long long result = 0;
+ int length = map[num].size();
+ for (int i = 0; i < length; i++)
+ result += getMin(map[num][i], minute + 1);
+
+ return DP[num][minute] = result % DIVIDE;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
#include <iostream>
+
+using namespace std;
+
+int numOfObject, weight, DP[101][100001];
+
+int main() {
+ cin >> numOfObject >> weight;
+ for (int i = 1; i <= numOfObject; i++) {
+ int w, v;
+ cin >> w >> v;
+ for (int j = 1; j <= weight; j++) {
+ if (j >= w)
+ DP[i][j] = DP[i - 1][j - w] + v > DP[i - 1][j] ? DP[i - 1][j - w] + v : DP[i - 1][j];
+ else
+ DP[i][j] = DP[i - 1][j];
+ }
+ }
+ cout << DP[numOfObject][weight];
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+
#include <iostream>
+#include <cstring>
+#define DIV 1000000007
+using namespace std;
+
+int n, m, p, state[101];
+long long save[101][101];
+
+int dp(int d, int count);
+
+int main() {
+ memset(save, -1, sizeof(save));
+ memset(state, -1, sizeof(state));
+ cin >> n >> m >> p;
+ cout << dp(0, 0);
+}
+
+int dp(int d, int count) {
+ if (p - d < n - count)
+ return 0;
+ if (d == p)
+ return 1;
+ if (save[count][d] != -1)
+ return save[count][d];
+
+ long long ans = 0;
+ for (int i = 0; i < n; i++) {
+ if (state[i] == -1 || d - state[i] > m) {
+ int temp = state[i], nc = count;
+ if (temp == -1)
+ nc++;
+ state[i] = d;
+ ans = (ans + dp(d + 1, nc)) % DIV;
+ state[i] = temp;
+ }
+ }
+
+ return save[count][d] = ans % DIV;
+}
+
Comments powered by Disqus.
평범하게 BFS하면 되는데, 방문 표시를 어떻게 하느냐가 이번 문제의 관건이다.
난 각 기둥의 문자열 사이에 “/” 라는 문자를 추가하여 상태를 구분짓고, 이것을 set에 저장하였다.
이렇게 상태를 구분지어본 것은 처음이라, 코드를 짜면서도 계속 내 코드를 의심했다
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+
#include <iostream>
+#include <queue>
+#include <set>
+
+using namespace std;
+
+struct node {
+ string str[3];
+ int cnt;
+};
+
+int num[3];
+queue<node> q;
+set<string> s;
+
+string sumNode(node n) {
+ return n.str[0] + "/" + n.str[1] + "/" + n.str[2];
+}
+
+bool check(node n) {
+ char c[3] = { 'A', 'B', 'C' };
+ for (int i = 0; i < 3; i++) {
+ for (int j = 0; j < n.str[i].size(); j++)
+ if (n.str[i][j] != c[i])
+ return false;
+ }
+ return true;
+}
+
+int main() {
+ int a;
+ node temp;
+ for (int i = 0; i < 3; i++) {
+ cin >> a;
+ if (a != 0)
+ cin >> temp.str[i];
+ else
+ temp.str[i] = "";
+ }
+ temp.cnt = 0;
+ for (int i = 0; i < 3; i++) {
+ for(int j =0; j< temp.str[i].size(); j++)
+ switch (temp.str[i][j]) {
+ case 'A':
+ num[0]++;
+ break;
+ case 'B':
+ num[1]++;
+ break;
+ default:
+ num[2]++;
+ break;
+ }
+ }
+
+ q.push(temp);
+ s.insert(sumNode(temp));
+
+ while (!q.empty()) {
+ node t = q.front();
+ q.pop();
+
+ int sizes[3] = { t.str[0].size(), t.str[1].size() , t.str[2].size() };
+ if (sizes[0] == num[0] && sizes[1] == num[1] && sizes[2] == num[2]) {
+ if (check(t)) {
+ cout << t.cnt;
+ return 0;
+ }
+ }
+
+ for (int i = 0; i < 3; i++) {
+ int size = sizes[i];
+ if (size != 0) {
+ char last = t.str[i][size - 1];
+ t.str[i].pop_back();
+
+ for (int j = 0; j < 3; j++) {
+ if (i != j) {
+ t.str[j] += last;
+
+ string sum = sumNode(t);
+ auto iter = s.find(sum);
+ if (iter == s.end()) {
+ s.insert(sum);
+ q.push({ {t.str[0], t.str[1], t.str[2]}, t.cnt + 1 });
+ }
+
+ t.str[j].pop_back();
+ }
+ }
+ t.str[i] += last;
+ }
+ }
+ }
+}
+
+
Comments powered by Disqus.
1
+2
+3
+
1. 현재 깊이 d, 이전에 나왔던 a의 개수, 이전에 나왔던 b의 개수, 이제까지의 k 수를 기준으로 dp를 만들어야함. k도 결과에 영향을 주기 때문.
+2. 즉, dp[d][a][b][k] 를 선언하고, 이 상태가 검사되면 true로 지정하여 다시 검사하지않음.
+3. 정답을 찾았을 때는 전역변수 got에 true값을 지정하여 바로 다른 모든걸 종료시키고 출력
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+
#include <iostream>
+#include <cstring>
+using namespace std;
+
+int N, K, num[30], ans[30];
+bool save[31][31][31][450], got;
+
+void DP(int d, int a, int b, int n);
+
+int main() {
+ cin >> N >> K;
+ memset(num, -1, sizeof(num));
+ memset(ans, -1, sizeof(ans));
+
+ DP(0, 0, 0, 0);
+ if (!got)
+ cout << -1 << endl;
+ else {
+ for (int i = 0; i < N; i++) {
+ if (ans[i] == 0)
+ cout << 'A';
+ else if (ans[i] == 1)
+ cout << 'B';
+ else if (ans[i] == 2)
+ cout << 'C';
+ }
+ }
+}
+
+void DP(int d, int a, int b, int n) {
+ if (d == N) {
+ if (n == K) {
+ got = true;
+ memcpy(ans, num, sizeof(num));
+ }
+ return;
+ }
+ if (save[d][a][b][n])
+ return;
+ save[d][a][b][n] = true;
+
+ if (got)
+ return;
+
+ num[d] = 0;
+ DP(d + 1, a + 1, b, n);
+ if (!got) {
+ num[d] = 1;
+ DP(d + 1, a, b + 1, n + a);
+ }
+ if (!got) {
+ num[d] = 2;
+ DP(d + 1, a, b, n + a + b);
+ }
+ num[d] = -1;
+}
+
Comments powered by Disqus.
내가 한 방식에서 관점만 바꾸면 투포인터 방법이 된다.
왼쪽에서 오른쪽으로 end를 하나씩 늘려가며 숫자를 살펴가면서, 현재 수를 체크한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+
#include <iostream>
+
+using namespace std;
+
+int n, nums[100010], saveIdx[100010];
+long long ans;
+bool check[100010];
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cout.tie(0);
+ cin >> n;
+ for (int i = 1; i <= n; i++)
+ cin >> nums[i];
+
+ for (int i = 1; i <= n; i++) {
+ if (saveIdx[nums[i]] != 0) {
+ for (int j = saveIdx[nums[i]]; j >= 1; j--) {
+ if (!check[j]) {
+ ans += (i - j);
+ check[j] = true;
+ saveIdx[nums[j]] = 0;
+ }
+ else
+ break;
+ }
+ }
+ saveIdx[nums[i]] = i;
+ }
+ for (int i = n; i >= 1; i--) {
+ if (!check[i]) {
+ ans += (n + 1 - i);
+ check[i] = true;
+ }
+ else
+ break;
+ }
+ cout << ans;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+
1. 장애물을 x 좌표 순으로 정렬. 도착지점의 Y좌표와 걸린 길이(y축 이동만 고려)를 저장하는 set을 선언 후, {startY, 0} 를 추가
+2. 장애물을 하나씩 꺼내며, 그 장애물에 걸리는 원소만 set에서 꺼내고 하나씩 위로갔을때 거리와 아래로 갔을때 거리를 계산
+ 이때, 꺼낸 것이 10개여도 장애물의 위 아래 각각에서 최소거리가 걸리는 것만 set에 다시 저장 -> 즉, 10개 여도 2개만 저장됨.
+3. 2에서 검사한 원소는 set에서 제거한다.
+4. 모든 장애물을 상대로 하면, 이제 최소거리를 구하고, 그때의 y좌표를 저장하고, 출력하면 됨.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+
#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <set>
+
+using namespace std;
+
+struct Line {
+ long long x;
+ long long yl;
+ long long yh;
+
+ bool operator < (Line b) {
+ return x == b.x ? yl < b.yl : x < b.x;
+ }
+};
+
+int n, starty, endx;
+vector<Line> line;
+set<pair<long long, long long>> minY;
+
+long long min(long long a, long long b) {
+ return a < b ? a : b;
+}
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cin >> n >> starty >> endx;
+ for (int i = 0; i < n; i++) {
+ long long a, b, c;
+ cin >> a >> b >> c;
+ line.push_back({ a,b,c });
+ }
+ sort(line.begin(), line.end());
+
+ minY.insert({ starty, 0 });
+
+ for (int i = 0; i < n; i++) {
+ vector<pair<long long, long long>> temp;
+ set<pair<long long, long long>>::iterator s = minY.lower_bound({ line[i].yl, -200000000000000 });
+ set<pair<long long, long long>>::iterator e = minY.upper_bound({ line[i].yh, 200000000000000 });
+ long long up = 20000000000000, down = 200000000000000;
+ for (set<pair<long long, long long>>::iterator j = s; j != e; ++j) {
+ up = min(up, (line[i].yh - j->first) + j->second);
+ down = min(down, (j->first - line[i].yl) + j->second);
+ }
+ minY.erase(s, e);
+ minY.insert({ line[i].yh, up });
+ minY.insert({ line[i].yl, down });
+ }
+
+ long long result = 20000000000000;
+ vector<int> resultY;
+ for (set<pair<long long, long long>>::iterator s = minY.begin(); s != minY.end(); s++) {
+ result = min(result, s->second);
+ }
+ for (set<pair<long long, long long>>::iterator s = minY.begin(); s != minY.end(); s++) {
+ if (result == s->second) {
+ resultY.push_back(s->first);
+ }
+ }
+
+ cout << result + endx<< "\n";
+ cout << resultY.size() << " ";
+ for (int i = 0; i < resultY.size(); i++) {
+ cout << resultY[i] << " ";
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
- 브루트포스
+ 1. 어떤 알파벳이 나왔는지 기록하고, 거기에 맞춰 알파벳의 종류의 개수만큼 모든 가능한 수를 뽑아 검사한다.
+- 그리디
+ 1. 들어오는 단어를 알파벳 단위로 분류하고 다음처럼 자릿수를 곱해준다.
+ ABC -> 100A + 10B + C
+ BCA -> 100B + 10C + A
+ 2. 그리고 모든 단어를 더해준다.
+ 101A + 110B + 11C
+ 3. 이를 앞에 자릿수대로 내림차순 정렬하면, 가장 커야할 수가 나오고, 그에따라 수를 부여하고 계산하면 된다.
+ 110B + 101A + 11C
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+
#include <iostream>
+#include <string>
+#include <algorithm>
+
+using namespace std;
+
+int N, acheck[26], index, result;
+string word;
+
+int main() {
+ cin >> N;
+
+ for (int i = 0; i < N; i++) {
+ cin >> word;
+ int digit = 1;
+ for (int j = word.size() - 1; j >= 0; j--) {
+ if (acheck[word[j] - 'A'] == 0)
+ index++;
+ acheck[word[j] - 'A'] += digit;
+ digit *= 10;
+ }
+ }
+ sort(acheck, acheck + 26);
+
+ int cur = 9 - index + 1;
+ for (int i = 26 - index; i < 26; i++) {
+ result += acheck[i] * cur;
+ cur++;
+ }
+ cout << result;
+}
+
Comments powered by Disqus.
1
+2
+3
+
1. 오직 1명은 무조건 1명 있어야한다는 말
+2. 총감독관이 감시할 수 있는 응시자 수만큼 빼고, 감독관 수 1명 늘린다음에, 넣어야하는 부감독관 수를 더함. -> 이를 모든 시험장에 적용
+3. 이때 총 필요한 감독관을 저장하는 변수는 long long으로 해야함(응시자 수 100만명, 시험장 수 100만개 이므로)
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+
#include <iostream>
+#define MAX_CLASS 1000000
+
+using namespace std;
+
+int testClass[MAX_CLASS];
+int numOfClass;
+int chief;
+int second;
+
+int main() {
+ cin >> numOfClass;
+ for (int i = 0; i < numOfClass; i++)
+ cin >> testClass[i];
+ cin >> chief >> second;
+
+ long long need = numOfClass;
+ for (int i = 0; i < numOfClass; i++) {
+ testClass[i] -= chief;
+ if (testClass[i] <= 0)
+ continue;
+ int temp = testClass[i] / second;
+ need += temp;
+ testClass[i] -= temp * second;
+ need += (testClass[i] > 0 ? 1 : 0);
+ }
+
+ cout << need;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+
#include <iostream>
+#include <algorithm>
+#include <cstring>
+#define MAX_WIDTH 10
+#define MAX_DEEP 10
+
+using namespace std;
+
+char map[MAX_WIDTH][MAX_WIDTH];
+int width;
+int height;
+int R[2];
+int B[2];
+int Hole[2];
+int minDeep;
+
+void getProperties();
+void findMinWay(int tempR[], int tempB[], int deep = 0);
+void print(int tempR[], int tempB[], int deep);
+
+int main() {
+ getProperties();
+ minDeep = 100;
+ findMinWay(R, B);
+ if (minDeep == 100)
+ cout << -1;
+ else
+ cout << minDeep;
+}
+
+void getProperties() {
+ cin >> height >> width;
+
+ for (int h = 0; h < height; h++) {
+ for (int w = 0; w < width; w++) {
+ cin >> map[h][w];
+ if (map[h][w] == 'R') {
+ R[0] = h;
+ R[1] = w;
+ }
+ else if (map[h][w] == 'B') {
+ B[0] = h;
+ B[1] = w;
+ }
+ else if (map[h][w] == 'O') {
+ Hole[0] = h;
+ Hole[1] = w;
+ }
+ }
+ }
+}
+
+
+void findMinWay(int tempR[], int tempB[], int deep) {
+ if (tempB[0] == Hole[0] && tempB[1] == Hole[1])
+ return;
+ if (tempR[0] == Hole[0] && tempR[1] == Hole[1]) {
+ if (deep < minDeep) {
+ minDeep = deep;
+ }
+ return;
+ }
+ if (deep >= MAX_DEEP)
+ return;
+
+ int currentR[2], currentB[2];
+ memcpy(currentR, tempR, sizeof(tempR)*2);
+ memcpy(currentB, tempB, sizeof(tempB)*2);
+
+ //print(tempR, tempB, deep);
+
+ //위
+ while (map[currentR[0]-1][currentR[1]] != '#' && map[currentR[0]][currentR[1]] != 'O')
+ currentR[0]--;
+ while (map[currentB[0]-1][currentB[1]] != '#' && map[currentB[0]][currentB[1]] != 'O')
+ currentB[0]--;
+ if (currentR[0] == currentB[0] && currentR[1] == currentB[1])
+ if (map[currentB[0]][currentB[1]] != 'O') {
+ if (tempR[0] < tempB[0])
+ currentB[0]++;
+ else
+ currentR[0]++;
+ }
+ findMinWay(currentR, currentB, deep + 1);
+ memcpy(currentR, tempR, sizeof(int) * 2);
+ memcpy(currentB, tempB, sizeof(int) * 2);
+
+
+ //오른쪽
+ while (map[currentR[0]][currentR[1]+1] != '#' && map[currentR[0]][currentR[1]] != 'O')
+ currentR[1]++;
+ while (map[currentB[0]][currentB[1]+1] != '#' && map[currentB[0]][currentB[1]] != 'O')
+ currentB[1]++;
+ if (currentR[0] == currentB[0] && currentR[1] == currentB[1])
+ if (map[currentB[0]][currentB[1]] != 'O') {
+ if (tempR[1] < tempB[1])
+ currentR[1]--;
+ else
+ currentB[1]--;
+ }
+ findMinWay(currentR, currentB, deep + 1);
+ memcpy(currentR, tempR, sizeof(int) * 2);
+ memcpy(currentB, tempB, sizeof(int) * 2);
+
+ //아래
+ while (map[currentR[0]+1][currentR[1]] != '#' && map[currentR[0]][currentR[1]] != 'O')
+ currentR[0]++;
+ while (map[currentB[0]+1][currentB[1]] != '#' && map[currentB[0]][currentB[1]] != 'O')
+ currentB[0]++;
+ if (currentR[0] == currentB[0] && currentR[1] == currentB[1])
+ if (map[currentB[0]][currentB[1]] != 'O') {
+ if (tempR[0] < tempB[0])
+ currentR[0]--;
+ else
+ currentB[0]--;
+ }
+ findMinWay(currentR, currentB, deep + 1);
+ memcpy(currentR, tempR, sizeof(int) * 2);
+ memcpy(currentB, tempB, sizeof(int) * 2);
+
+ //왼쪽
+ while (map[currentR[0]][currentR[1]-1] != '#' && map[currentR[0]][currentR[1]] != 'O')
+ currentR[1]--;
+ while (map[currentB[0]][currentB[1]-1] != '#' && map[currentB[0]][currentB[1]] != 'O')
+ currentB[1]--;
+ if (currentR[0] == currentB[0] && currentR[1] == currentB[1])
+ if (map[currentB[0]][currentB[1]] != 'O') {
+ if (tempR[1] < tempB[1])
+ currentB[1]++;
+ else
+ currentR[1]++;
+ }
+ findMinWay(currentR, currentB, deep + 1);
+ memcpy(currentR, tempR, sizeof(int) * 2);
+ memcpy(currentB, tempB, sizeof(int) * 2);
+}
+
+void print(int tempR[], int tempB[], int deep) {
+ cout << "deep : " << deep << "/ R : " << tempR[0] << ' ' << tempR[1] << "/ B : " << tempB[0] << ' ' << tempB[1] << endl;
+}
+
Comments powered by Disqus.
1
+
1. BFS로 가능한 곳은 가되, check엔 이전에 온 것보다 적은 시간을 걸리며 온 것을 받아주기 위해 시간을 저장하자.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+
#include <iostream>
+#include <cstring>
+#include <list>
+
+using namespace std;
+
+int N, K, result = 2000000000;
+int check[200020];
+list<pair<int,int>> q;
+
+int bfs();
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+
+int main() {
+ for (int i = 0; i < 200020; i++)
+ check[i] = 2000000000;
+
+ cin >> N >> K;
+ if (N >= K)
+ cout << N - K;
+ else
+ cout << bfs() << endl;
+
+}
+
+int bfs() {
+ q.push_back({ N, 0 });
+ check[N] = 0;
+
+ while (!q.empty()) {
+ int X = q.front().first, t = q.front().second;
+ q.pop_front();
+
+ if (X >= K) {
+ result = min(result, X - K + t);
+ }
+ else {
+ if (X != 0 && t < check[X * 2]) {
+ q.push_back({ X * 2, t });
+ check[X * 2] = t;
+ }
+ if (t + 1 < check[X + 1]) {
+ q.push_back({ X + 1, t + 1 });
+ check[X + 1] = t + 1;
+ }
+ if (X-1 >= 0 && t + 1 < check[X - 1]) {
+ q.push_back({ X - 1, t + 1 });
+ check[X - 1] = t + 1;
+ }
+ }
+ }
+ return result;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+
1. LIS 로 구함
+2. 수열 출력
+ 1. LIS구하면서, 현재 LIS의 인덱스를 항상 저장함
+ 2. LIS를 구하면, 가장 뒤에있는 LIS의 가장 뒤 원소의 인덱스가 저장됨
+ 3. 그 인덱스로부터 길이를 하나씩줄여가며 앞으로 가면서 길이가 맞는걸 뒤에서부터 저장
+ 4. 길이가 0이되면 종료
+ 5. 이렇게하면 가장 뒤에있는 LIS가 저장된다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+
#include <iostream>
+#include <algorithm>
+#define MAX_LENGTH 1000001
+
+using namespace std;
+
+int lengthOfSequence, sequence[MAX_LENGTH], length[MAX_LENGTH], subSequence[MAX_LENGTH], longest, lis[MAX_LENGTH];
+
+void LIS();
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cin >> lengthOfSequence;
+ for (int i = 1; i <= lengthOfSequence; i++)
+ cin >> sequence[i];ㅁ
+ LIS();
+ cout << longest << "\n";
+ for (int i = 1; i <= longest; i++)
+ cout << lis[i] << " ";
+}
+
+void LIS() {
+ subSequence[0] = -2000000000;
+ int lengthOfSub = 1;
+
+ int longestIndex = 0;
+ for (int i = 1; i <= lengthOfSequence; i++) {
+ int* lb = lower_bound(subSequence, subSequence + lengthOfSub, sequence[i]);
+ *lb = sequence[i];
+ if (lb - subSequence == lengthOfSub)
+ length[i] = lengthOfSub++;
+ else
+ length[i] = lb - subSequence;
+
+ if (length[i] > longest) {
+ longest = length[i];
+ longestIndex = i;
+ }
+ }
+
+ int temp = longest;
+ for (int i = longestIndex; i >= 1; i--) {
+ if (length[i] == temp) {
+ lis[temp] = sequence[i];
+ temp--;
+ }
+ }
+}
+
+
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+
#include <bits/stdc++.h>
+
+using namespace std;
+
+string input;
+int ABC[3], save[3][3][51][51][51];
+char result[100];
+bool gotAns = false;
+
+void dp(int n);
+void goNext(char cur, int n);
+
+int main() {
+ cin >> input;
+
+ for (int i = 0; i < input.size(); i++) {
+ if (input[i] == 'A') {
+ ABC[0]++;
+ }
+ else if (input[i] == 'B')
+ ABC[1]++;
+ else
+ ABC[2]++;
+ }
+
+ dp(0);
+ if (gotAns) {
+ for (int i = 0; i < input.size(); i++)
+ cout << result[i];
+ }
+ else
+ cout << -1;
+}
+
+void goNext(char cur, int n) {
+ ABC[cur - 'A']--;
+ result[n] = cur;
+ dp(n + 1);
+ ABC[cur - 'A']++;
+}
+
+void dp(int n) {
+ if (n == input.size()) {
+ gotAns = true;
+ return;
+ }
+ else if (gotAns || (n > 1 && save[result[n - 2]-'A'][result[n - 1]-'A'][ABC[0]][ABC[1]][ABC[2]]))
+ return;
+
+ if (ABC[0] > 0)
+ goNext('A', n);
+ if (gotAns)
+ return;
+
+ if (ABC[1] > 0 && (n == 0 || result[n-1] != 'B'))
+ goNext('B', n);
+ if (gotAns)
+ return;
+
+ if(ABC[2] > 0 && (n == 0 || result[n - 1] != 'C') && (n <= 1 || result[n - 2] != 'C'))
+ goNext('C', n);
+ if (gotAns)
+ return;
+
+ if (n > 1) {
+ save[result[n - 2]-'A'][result[n - 1]-'A'][ABC[0]][ABC[1]][ABC[2]] = 1;
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+
#include <iostream>
+#include <list>
+#include <cstring>
+#include <vector>
+
+using namespace std;
+
+int n, k, r, map[101][101];
+list<pair<int, int>> l;
+bool visit[101][101], path[101][101][4];
+pair<int, int> cow[101];
+
+int bfs();
+
+int main() {
+ cin >> n >> k >> r;
+ int a, b, c, d, e, f, g;
+ for (int i = 0; i < r; i++) {
+ cin >> a >> b >> c >> d;
+ e = a - c, f = b - d;
+
+ if (e == 1)
+ g = 0;
+ else if (e == -1)
+ g = 2;
+ else if (f == 1)
+ g = 3;
+ else
+ g = 1;
+ path[c][d][g >= 2 ? g - 2 : g + 2] = true;
+ path[a][b][g] = true;
+ }
+ for (int i = 1; i <= k; i++) {
+ cin >> cow[i].first >> cow[i].second;
+ map[cow[i].first][cow[i].second] = i;
+ }
+ cout << bfs();
+}
+
+int bfs() {
+ int ans = 0, offset[4][2] = { {-1,0}, {0, 1}, {1, 0}, {0, -1} };
+
+ for (int i = 1; i <= k; i++) {
+ int count = 0;
+ visit[cow[i].first][cow[i].second] = true;
+ l.push_back({ cow[i].first, cow[i].second });
+
+ while (!l.empty()) {
+ int r = l.front().first, c = l.front().second;
+ l.pop_front();
+
+ if (map[r][c] != 0)
+ count++;
+
+ for (int i = 0; i < 4; i++) {
+ int nr = r + offset[i][0], nc = c + offset[i][1];
+
+ if (nr <= n && nr >= 1 && nc <= n && nc >= 1 && !visit[nr][nc] && !path[r][c][i]) {
+ l.push_back({ nr, nc });
+ visit[nr][nc] = true;
+ }
+ }
+
+ }
+
+ ans += k - count;
+ memset(visit, 0, sizeof(visit));
+ }
+ return ans / 2;
+}
+
Comments powered by Disqus.
1
+2
+3
+
1. 각 명령별로 검사. 초기 주사위 상태 (top : 1, north : 2, east : 3, south : 5, western : 4, bottom : 6)
+2. 명령대로 주사위를 굴리고 -> 그 위치가 맵 밖이면 다음 명령 실행
+ 맵 안이면 이동시키고, 주사위 상태 변경 -> 이후 이동한 칸에 숫자 적용하고 -> 상단 프린트 -> 다음 명령 실행
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+
#include <iostream>
+#include <cstring>
+#define MAX_WIDTH 20
+#define MAX_COMMAND 1000
+
+using namespace std;
+
+typedef struct Location {
+ int row;
+ int col;
+} Location;
+typedef struct Dice {
+ int top;
+ int north;
+ int east;
+ int south;
+ int western;
+ int bottom;
+}Dice;
+
+int width;
+int height;
+int map[MAX_WIDTH][MAX_WIDTH];
+Location locationDice;
+int numOfCommand;
+int command[MAX_COMMAND];
+int dice[7];
+
+
+void getProperties();
+Dice diceChange(Dice d, int direction);
+bool diceMove(int command);
+void game();
+
+int main() {
+ getProperties();
+ game();
+}
+
+void getProperties() {
+ cin >> height >> width >> locationDice.row >> locationDice.col >> numOfCommand;
+
+ for (int i = 0; i < MAX_WIDTH; i++)
+ memset(map, 0, sizeof(int) * MAX_WIDTH);
+ memset(dice, 0, sizeof(int) * 7);
+
+ for (int i = 0; i < height; i++) {
+ for (int j = 0; j < width; j++)
+ cin >> map[i][j];
+ }
+
+ for (int i = 0; i < numOfCommand; i++)
+ cin >> command[i];
+}
+
+void game() {
+ Dice d = { 1, 2, 3, 5, 4, 6 };
+
+ for (int i = 0; i < numOfCommand; i++) {
+ if (diceMove(command[i])) {
+ d = diceChange(d, command[i]);
+ if (map[locationDice.row][locationDice.col] == 0)
+ map[locationDice.row][locationDice.col] = dice[d.bottom];
+ else {
+ dice[d.bottom] = map[locationDice.row][locationDice.col];
+ map[locationDice.row][locationDice.col] = 0;
+ }
+
+ cout << dice[d.top] << endl;
+ }
+ }
+}
+
+bool diceMove(int command) {
+ //temp를 먼저 옮기고, 범위 밖이면 false리턴, 아니면 수정 후 true리턴
+ Location temp = { locationDice.row, locationDice.col };
+ if (command == 1)
+ temp.col++;
+ else if (command == 2)
+ temp.col--;
+ else if (command == 3)
+ temp.row--;
+ else if (command == 4)
+ temp.row++;
+
+ if (temp.col < 0 || temp.col >= width || temp.row < 0 || temp.row >= height)
+ return false;
+
+ locationDice.col = temp.col;
+ locationDice.row = temp.row;
+ return true;
+}
+
+Dice diceChange(Dice d, int direction) {
+ //1 : 동, 2: 서, 3: 북, 4 : 남
+ Dice temp;
+ if (direction == 1) {
+ temp.top = d.western;
+ temp.north = d.north;
+ temp.east = d.top;
+ temp.south = d.south;
+ temp.western = d.bottom;
+ temp.bottom = d.east;
+ }
+ else if (direction == 2) {
+ temp.top = d.east;
+ temp.north = d.north;
+ temp.east = d.bottom;
+ temp.south = d.south;
+ temp.western = d.top;
+ temp.bottom = d.western;
+ }
+ else if (direction == 3) {
+ temp.top = d.south;
+ temp.north = d.top;
+ temp.east = d.east;
+ temp.south = d.bottom;
+ temp.western = d.western;
+ temp.bottom = d.north;
+ }
+ else if (direction == 4) {
+ temp.top = d.north;
+ temp.north = d.bottom;
+ temp.east = d.east;
+ temp.south = d.top;
+ temp.western = d.western;
+ temp.bottom = d.south;
+ }
+ return temp;
+}
+
Comments powered by Disqus.
1
+
1. 가능한 모든 모양으로 검사.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+
#include <iostream>
+#define MAX_WIDTH 501
+
+using namespace std;
+
+int width, height;
+int map[MAX_WIDTH][MAX_WIDTH];
+
+void getProperties();
+int putTetromino();
+
+int main() {
+ while (true) {
+ getProperties();
+ cout << putTetromino();
+ }
+}
+
+void getProperties() {
+ cin >> height >> width;
+ for (int i = 0; i < height; i++)
+ for (int j = 0; j < width; j++)
+ cin >> map[i][j];
+}
+
+
+int putTetromino() {
+ int max = 0;
+
+ //일자 확인
+ for (int row = 0; row < height; row++) {
+ int temp = map[row][0] + map[row][1] + map[row][2];
+ for (int i = 3; i < width; i++) {
+ temp += map[row][i];
+ if (temp > max)
+ max = temp;
+ temp -= map[row][i - 3];
+ }
+ }
+
+ //세로 일자 확인
+ for (int col = 0; col < width; col++) {
+ int temp = map[0][col] + map[1][col] + map[2][col];
+ for (int i = 3; i < height; i++) {
+ temp += map[i][col];
+ if (temp > max)
+ max = temp;
+ temp -= map[i - 3][col];
+ }
+ }
+
+ //네모 확인
+ int lastHeight = height - 1;
+ int lastWidth = width - 1;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row][col] + map[row][col+1] + map[row+1][col] + map[row+1][col+1];
+ max = temp > max ? temp : max;
+ }
+ }
+
+ //L1 확인
+ lastHeight = height - 2;
+ lastWidth = width - 1;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row][col] + map[row + 1][col] + map[row + 2][col] + map[row + 2][col + 1];
+ max = temp > max ? temp : max;
+ }
+ }
+
+ //L2 확인
+ lastHeight = height - 1;
+ lastWidth = width - 2;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row][col] + map[row + 1][col] + map[row][col + 1] + map[row][col + 2];
+ max = temp > max ? temp : max;
+ }
+ }
+
+ //L3 확인
+ lastHeight = height - 2;
+ lastWidth = width - 1;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row][col] + map[row][col + 1] + map[row + 1][col + 1] + map[row + 2][col + 1];
+ max = temp > max ? temp : max;
+ }
+ }
+
+ //L4 확인
+ lastHeight = height - 1;
+ lastWidth = width - 2;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row + 1][col] + map[row + 1][col + 1] + map[row + 1][col + 2] + map[row][col + 2];
+ max = temp > max ? temp : max;
+ }
+ }
+
+ //L5 확인
+ lastHeight = height - 2;
+ lastWidth = width - 1;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row + 2][col] + map[row + 2][col + 1] + map[row + 1][col + 1] + map[row][col + 1];
+ max = temp > max ? temp : max;
+ }
+ }
+
+ //L6 확인
+ lastHeight = height - 1;
+ lastWidth = width - 2;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row][col] + map[row+1][col] + map[row + 1][col + 1] + map[row+1][col + 2];
+ max = temp > max ? temp : max;
+ }
+ }
+
+ //L7 확인
+ lastHeight = height - 2;
+ lastWidth = width - 1;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row][col] + map[row][col + 1] + map[row + 1][col] + map[row+2][col];
+ max = temp > max ? temp : max;
+ }
+ }
+
+ //L8 확인
+ lastHeight = height - 1;
+ lastWidth = width - 2;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row][col] + map[row][col + 1] + map[row][col + 2] + map[row + 1][col + 2];
+ max = temp > max ? temp : max;
+ }
+ }
+
+ //Z1 확인
+ lastHeight = height - 2;
+ lastWidth = width - 1;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row][col+1] + map[row+1][col + 1] + map[row+1][col] + map[row + 2][col];
+ max = temp > max ? temp : max;
+ }
+ }
+ //Z2 확인
+ lastHeight = height - 1;
+ lastWidth = width - 2;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row][col] + map[row][col + 1] + map[row+1][col + 1] + map[row + 1][col + 2];
+ max = temp > max ? temp : max;
+ }
+ }
+ //Z3 확인
+ lastHeight = height - 2;
+ lastWidth = width - 1;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row][col] + map[row+1][col] + map[row+1][col + 1] + map[row + 2][col + 1];
+ max = temp > max ? temp : max;
+ }
+ }
+ //Z4 확인
+ lastHeight = height - 1;
+ lastWidth = width - 2;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row][col+1] + map[row][col + 2] + map[row+1][col] + map[row + 1][col + 1];
+ max = temp > max ? temp : max;
+ }
+ }
+
+ //T1 확인
+ lastHeight = height - 1;
+ lastWidth = width - 2;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row+1][col] + map[row][col + 1] + map[row + 1][col+2] + map[row + 1][col + 1];
+ max = temp > max ? temp : max;
+ }
+ }
+ //T2 확인
+ lastHeight = height - 2;
+ lastWidth = width - 1;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row][col] + map[row+1][col] + map[row + 2][col] + map[row + 1][col + 1];
+ max = temp > max ? temp : max;
+ }
+ }
+ //T3 확인
+ lastHeight = height - 1;
+ lastWidth = width - 2;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row][col] + map[row][col + 1] + map[row][col+2] + map[row + 1][col + 1];
+ max = temp > max ? temp : max;
+ }
+ }
+ //T4 확인
+ lastHeight = height - 2;
+ lastWidth = width - 1;
+ for (int row = 0; row < lastHeight; row++) {
+ for (int col = 0; col < lastWidth; col++) {
+ int temp = map[row][col + 1] + map[row+1][col] + map[row + 1][col+1] + map[row + 2][col + 1];
+ max = temp > max ? temp : max;
+ }
+ }
+
+
+ return max;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+
#include <iostream>
+#define MAX_DAY 15
+
+using namespace std;
+
+int day;
+int time[MAX_DAY];
+int proceeds[MAX_DAY];
+
+int DP(int d, int proceed);
+int max(int a, int b);
+
+int main() {
+ cin >> day;
+ for (int i = 0; i < day; i++)
+ cin >> time[i] >> proceeds[i];
+
+ cout << DP(0, 0);
+ }
+
+int DP(int d, int proceed) {
+ if (d >= day)
+ return proceed;
+
+ int a = 0;
+ if (day - d >= time[d])
+ a = DP(d + time[d], proceed + proceeds[d]);
+ return max(a, DP(d + 1, proceed));
+}
+
+int max(int a, int b) {
+ return a > b ? a : b;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+
#include <iostream>
+#include <list>
+#include <cstring>
+#define MAX_WIDTH 8
+
+using namespace std;
+
+typedef struct Cell {
+ int row;
+ int col;
+} Cell;
+
+int map[MAX_WIDTH][MAX_WIDTH];
+int tempMap[MAX_WIDTH][MAX_WIDTH];
+int width, height;
+
+int getMaxSafeArea();
+
+int main() {
+ cin >> height >> width;
+ for (int i = 0; i < height; i++)
+ for (int j = 0; j < width; j++)
+ cin >> map[i][j];
+
+ cout << getMaxSafeArea();
+}
+
+int getMaxSafeArea() {
+ int maxSafeArea = 0;
+ int last = height * width - 2;
+ int last2 = height * width - 1;
+ int last3 = height * width;
+
+ for (int start = 0; start < last; start++) {
+ int startRow = start / width;
+ int startCol = start % width;
+ if (map[startRow][startCol] != 0)
+ continue;
+ for (int start2 = start + 1; start2 < last2; start2++) {
+ int start2Row = start2 / width;
+ int start2Col = start2 % width;
+ if (map[start2Row][start2Col] != 0)
+ continue;
+ for (int start3 = start2 + 1; start3 < last3; start3++) {
+ int start3Row = start3 / width;
+ int start3Col = start3 % width;
+ if (map[start3Row][start3Col] != 0)
+ continue;
+
+ for (int i = 0; i < MAX_WIDTH; i++)
+ memcpy(tempMap[i], map[i], sizeof(int) * MAX_WIDTH);
+
+ tempMap[startRow][startCol] = 1;
+ tempMap[start2Row][start2Col] = 1;
+ tempMap[start3Row][start3Col] = 1;
+
+ list<Cell> queue;
+ for (int i = 0; i < height; i++)
+ for (int j = 0; j < width; j++)
+ if (tempMap[i][j] == 2)
+ queue.push_back({ i, j });
+
+ while (!queue.empty()) {
+ Cell current = queue.front();
+ queue.pop_front();
+
+ if (current.row - 1 >= 0 && tempMap[current.row - 1][current.col] == 0) {
+ tempMap[current.row - 1][current.col] = 2;
+ queue.push_back({ current.row - 1, current.col });
+ }
+ if (current.row + 1 < height && tempMap[current.row + 1][current.col] == 0) {
+ tempMap[current.row + 1][current.col] = 2;
+ queue.push_back({ current.row + 1, current.col });
+ }
+ if (current.col - 1 >= 0 && tempMap[current.row][current.col - 1] == 0) {
+ tempMap[current.row][current.col - 1] = 2;
+ queue.push_back({ current.row, current.col - 1 });
+ }
+ if (current.col + 1 < width && tempMap[current.row][current.col + 1] == 0) {
+ tempMap[current.row][current.col + 1] = 2;
+ queue.push_back({ current.row, current.col + 1 });
+ }
+ }
+ int temp = 0;
+ for (int i = 0; i < height; i++)
+ for (int j = 0; j < width; j++)
+ if (tempMap[i][j] == 0)
+ temp++;
+ maxSafeArea = temp > maxSafeArea ? temp : maxSafeArea;
+ }
+ }
+ }
+
+ return maxSafeArea;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+
#include <iostream>
+#define MAX_WIDTH 50
+
+using namespace std;
+
+int direction;
+int location[2];
+int map[MAX_WIDTH][MAX_WIDTH];
+int height, width;
+
+int robot();
+bool changeDirection();
+
+int main() {
+ cin >> height >> width;
+ cin >> location[0] >> location[1] >> direction;
+ for (int i = 0; i < height; i++)
+ for (int j = 0; j < width; j++)
+ cin >> map[i][j];
+
+ cout << robot();
+}
+
+int robot() {
+ bool doesStop = false;
+
+ while (!doesStop) {
+ map[location[0]][location[1]] = 2;
+
+ while (!changeDirection()) {
+ if (direction == 0)
+ location[0] += 1;
+ else if (direction == 1)
+ location[1] -= 1;
+ else if (direction == 2)
+ location[0] -= 1;
+ else if (direction == 3)
+ location[1] += 1;
+
+ if (map[location[0]][location[1]] == 1) {
+ doesStop = true;
+ break;
+ }
+ }
+ }
+
+ int count = 0;
+ for (int i = 0; i < height; i++)
+ for (int j = 0; j < width; j++)
+ if (map[i][j] == 2)
+ count++;
+ return count;
+}
+
+bool changeDirection() {
+ for (int i = 0; i < 4; i++) {
+ if (direction == 0) {
+ direction = 3;
+ if (map[location[0]][location[1] - 1] == 0) {
+ location[1] -= 1;
+ return true;
+ }
+ }
+ else if (direction == 1) {
+ direction = 0;
+ if (map[location[0] - 1][location[1]] == 0) {
+ location[0] -= 1;
+ return true;
+ }
+ }
+ else if (direction == 2) {
+ direction = 1;
+ if (map[location[0]][location[1] + 1] == 0) {
+ location[1] += 1;
+ return true;
+ }
+ }
+ else if (direction == 3) {
+ direction = 2;
+ if (map[location[0] + 1][location[1]] == 0) {
+ location[0] += 1;
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+
#include <iostream>
+#include <vector>
+#include <cstring>
+
+using namespace std;
+
+char map[22][22];
+int n, colorCheck[26], os[4][2] = { {-1,0}, {0,1}, {1,0},{0,-1} };
+vector<pair<pair<int, int>, pair<int, int>>> pcl;
+bool visit[22][22];
+pair<int, int> q[420];
+
+void getPCL();
+void checkSingleRectagle(int, int,int,int);
+
+int main() {
+ cin >> n;
+ for (int i = 0; i < n; i++)
+ for (int j = 0; j < n; j++)
+ cin >> map[i][j];
+ getPCL();
+
+ int last = pcl.size() - 1;
+ for (int i = last; i >=0; i--) {
+ int si = pcl[i].first.first, sj = pcl[i].first.second, w = pcl[i].second.first, h = pcl[i].second.second;
+ for (int j = 0; j < i; j++)
+ if (si >= pcl[j].first.first && sj >= pcl[j].first.second && w <= pcl[j].second.first && h <= pcl[j].second.second) {
+ pcl.pop_back();
+ break;
+ }
+ }
+
+ cout << pcl.size() << endl;
+}
+
+void getPCL() {
+ for (int h = n - 1; h >= 0; h--) {
+ for (int w = n - 1; w >= 0; w--) {
+ for (int i = 0; i < n - w; i++) {
+ for (int j = 0; j < n - h; j++) {
+ checkSingleRectagle(i, j, i + w, j + h);
+ memset(colorCheck, 0, sizeof(colorCheck));
+ }
+ }
+ }
+ }
+}
+
+void checkSingleRectagle(int si, int sj, int w, int h) {
+ for (int i = 0; i < pcl.size(); i++)
+ if (si >= pcl[i].first.first && sj >= pcl[i].first.second && w <= pcl[i].second.first && h <= pcl[i].second.second)
+ return;
+
+ int count = 0;
+ for (int i = sj; i <= h; i++) {
+ for (int j = si; j <= w; j++) {
+ if (!colorCheck[map[i][j] - 'A'])
+ count++;
+ colorCheck[map[i][j] - 'A']++;
+ if (count > 2)
+ return;
+ }
+ }
+ if (count != 2)
+ return;
+
+
+ bool check1 = false;
+ int check2 = 0;
+ for (int i = sj; i <= h; i++) {
+ for (int j = si; j <= w; j++) {
+ if (!visit[i][j]) {
+ char c = map[i][j];
+ int temp = colorCheck[c - 'A'], curIdx = 0, lastIdx = 0;
+ visit[i][j] = true;
+ q[lastIdx++] = { i,j };
+ while (curIdx != lastIdx) {
+ int ch = q[curIdx].first, cc = q[curIdx].second;
+ curIdx++;
+ temp--;
+
+ for (int k = 0; k < 4; k++) {
+ int nh = ch + os[k][0], nc = cc + os[k][1];
+ if (nh >= sj && nh <= h && nc >= si && nc <= w && !visit[nh][nc] && map[nh][nc] == c) {
+ q[lastIdx++] = { nh, nc };
+ visit[nh][nc] = true;
+ }
+ }
+ }
+ if (temp == 0)
+ check1 = true;
+ else
+ check2++;
+ }
+ if (check1 && check2 >= 2)
+ break;
+ }
+ }
+ memset(visit, 0, sizeof(visit));
+
+ if (check1 && check2 >= 2)
+ pcl.push_back({ {si, sj}, { w, h} });
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+
#include <iostream>
+
+using namespace std;
+
+int n, m, l, k;
+pair<int, int> s[110];
+
+int max(int a, int b) {
+ return a < b ? b : a;
+}
+
+
+int main() {
+ cin >> n >> m >> l >> k;
+
+ int a, b;
+ for (int i = 0; i < k; i++) {
+ cin >> a >> b;
+ s[i] = { a, b };
+ }
+
+ int cnt = 0;
+ for (int i = 0; i < k; i++) {
+ for (int j = 0; j < k; j++) {
+ int temp = 0;
+ for (int e = 0; e < k; e++) {
+ if (s[i].first <= s[e].first && s[i].first + l >= s[e].first
+ && s[j].second <= s[e].second && s[j].second + l >= s[e].second)
+ temp++;
+ }
+ cnt = max(cnt, temp);
+ }
+ }
+ cout << k - cnt;
+}
+
Comments powered by Disqus.
1
+2
+3
+
1. dp를 평범하게 진행. dp배열은 dp[101][100001] 로 앞에는 현재 위치, 뒤에는 시간
+2. 시간이 맞으면 진행하되, 안맞으면 result 를 초기화해둔 -20000000이 그대로 있음.
+3. 0보다 낮으면, 현재 시간포함 0초까지 -20000000로 초기화. 같은 상태에 더 낮은 시간을 가지고 접근하는 걸 막음.
+
1
+2
+3
+4
+5
+6
+
1. dp[100005] 로 시간만으로 dp를 만듬.
+2. 첫번째 노드의 시간과 값으로 dp 초기화
+3. dp 배열을 t=k 부터 검사하여 값이 있으면, dp[j + a] = max(dp[j+a], dp[j] + b) 로 시간을 올려가며 dp를 수행
+4. 이때 노드는 앞에서부터 검사한다.
+5. 값이 있으면 작업을 수행하고, 끝나면 dp[j] = 0 으로 다시 초기화.
+6. 다 끝나면, 저장된 값중 최고값 뽑아서 리턴
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+
#include <iostream>
+
+using namespace std;
+
+int road[101][4], k, n, dp[101][100001], dp2[100001];
+
+
+//방법 1
+int getMaxDP(int cur, int t);
+//방법 2
+int getMaxDP2();
+
+int max(int a, int b) {
+ return a > b ? a : b;
+}
+int main() {
+ cin >> n >> k;
+
+ for (int i = 0; i < n; i++) {
+ cin >> road[i][0] >> road[i][1] >> road[i][2] >> road[i][3];
+ }
+ cout << getMaxDP2();
+}
+
+int getMaxDP(int cur, int t) {
+ if (cur == n)
+ return 0;
+ if (dp[cur][t] != 0)
+ return dp[cur][t];
+
+ int result = -2000000000;
+ if (t - road[cur][0] >= 0)
+ result = getMaxDP(cur + 1, t - road[cur][0]) + road[cur][1];
+ if (t - road[cur][2] >= 0)
+ result = max(result, getMaxDP(cur + 1, t - road[cur][2]) + road[cur][3]);
+
+ if (result <= 0) {
+ for (int i = t; i >= 0; i--) {
+ if (dp[cur][i] < 0)
+ break;
+ else
+ dp[cur][i] = result;
+ }
+ }
+
+ return dp[cur][t] = result;
+}
+
+int getMaxDP2() {
+ dp2[road[0][0]] = road[0][1];
+ dp2[road[0][2]] = road[0][3];
+
+ for (int i = 1; i < n; i++) {
+ for (int j = k; j >= 0; j--) {
+ if (dp2[j] > 0) {
+ if (j + road[i][0] <= k)
+ dp2[j + road[i][0]] = max(dp2[j + road[i][0]], dp2[j] + road[i][1]);
+ if (j + road[i][2] <= k)
+ dp2[j + road[i][2]] = max(dp2[j + road[i][2]], dp2[j] + road[i][3]);
+ dp2[j] = 0;
+ }
+ }
+ }
+ int result = 0;
+ for (int i = 0; i <= k; i++) {
+ result = max(result, dp2[i]);
+ }
+ return result;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+
#include <iostream>
+#define MAX_NUM 11
+
+using namespace std;
+
+int num[MAX_NUM];
+int numOfNum;
+int operators[4]; // + - * /
+int operatorPerm[MAX_NUM - 1]; // 1 : +, 2 : -, 3 : *, 4 : /
+int min = 1000000001;
+int max = -1000000001;
+void getMinAndMax(int operatorPerm[MAX_NUM-1], int len);
+void swap_arr(int *arr, int i, int j);
+
+int main() {
+ cin >> numOfNum;
+ for (int i = 0; i < numOfNum; i++)
+ cin >> num[i];
+ cin >> operators[0] >> operators[1] >> operators[2] >> operators[3];
+
+ int index = 0;
+ for (int j = 0; j < operators[0]; j++)
+ operatorPerm[index++] = 0;
+ for (int j = 0; j < operators[1]; j++)
+ operatorPerm[index++] = 1;
+ for (int j = 0; j < operators[2]; j++)
+ operatorPerm[index++] = 2;
+ for (int j = 0; j < operators[3]; j++)
+ operatorPerm[index++] = 3;
+
+ getMinAndMax(operatorPerm, 0);
+ cout << max << endl << min << endl;
+}
+
+//각 연산자 수에 맞게 0~numOfNum-1에서 수를 뽑아 각 연산자에 배치
+void getMinAndMax(int operatorPerm[MAX_NUM - 1], int len) {
+ if (len == numOfNum - 1) {
+ int temp = num[0];
+ for (int i = 1; i < numOfNum; i++) {
+ if (operatorPerm[i - 1] == 0)
+ temp += num[i];
+ else if (operatorPerm[i - 1] == 1)
+ temp -= num[i];
+ else if (operatorPerm[i - 1] == 2)
+ temp *= num[i];
+ else
+ temp /= num[i];
+ }
+
+ if (temp > max)
+ max = temp;
+ if (temp < min)
+ min = temp;
+ return;
+ }
+
+ getMinAndMax(operatorPerm, len+1);
+ for (int i = len+1; i < numOfNum - 1; i++) {
+ if (operatorPerm[len] == operatorPerm[i])
+ continue;
+ swap_arr(operatorPerm, i, len);
+ getMinAndMax(operatorPerm, len + 1);
+ swap_arr(operatorPerm, i, len);
+ }
+}
+
+void swap_arr(int *arr, int i, int j) {
+ int temp = arr[j];
+ arr[j] = arr[i];
+ arr[i] = temp;
+}
+
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+
#include <iostream>
+#include <cstring>
+#define MAX_WIDTH 20
+
+using namespace std;
+
+int numOfPeople;
+int map[MAX_WIDTH][MAX_WIDTH];
+
+int minDifferenceBetweenTwoTeam(int arr[10], int len, int deep);
+int getSum(int arr[10]);
+int min(int a, int b);
+
+int main() {
+ cin >> numOfPeople;
+ for (int i = 0; i < numOfPeople; i++)
+ for (int j = 0; j < numOfPeople; j++)
+ cin >> map[i][j];
+
+ int arr[10];
+ memset(arr, -1, sizeof(arr));
+ cout << minDifferenceBetweenTwoTeam(arr, 0, 0);
+}
+
+int minDifferenceBetweenTwoTeam(int arr[10], int len, int deep) {
+ if (len == numOfPeople / 2) {
+ //계산
+ int temp[10];
+ int index = 0;
+ int indext = 0;
+ for (int i = 0; i < numOfPeople; i++) {
+ if (arr[index] == i)
+ index++;
+ else
+ temp[indext++] = i;
+ }
+ int d = getSum(temp) - getSum(arr);
+ return d < 0 ? (-1) * d : d;
+ }
+ else if (numOfPeople - deep < numOfPeople / 2 - len)
+ return 10000000;
+
+ arr[len] = deep;
+ int a = minDifferenceBetweenTwoTeam(arr, len + 1, deep + 1);
+ arr[len] = 0;
+ return min(a, minDifferenceBetweenTwoTeam(arr, len, deep + 1));
+}
+
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+
+int getSum(int arr[10]) {
+ int sum = 0;
+ for (int i = 0; i < numOfPeople/2; i++)
+ for (int j = 0; j < numOfPeople/2; j++)
+ sum += map[arr[i]][arr[j]];
+
+ return sum;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+
#include <iostream>
+#include <cstring>
+#define MAX_N 100
+
+using namespace std;
+
+int map[MAX_N][MAX_N];
+int width;
+int need;
+
+int checkEveryArr();
+bool checkSingleArr(int arr[MAX_N]);
+
+int main() {
+ cin >> width >> need;
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++)
+ cin >> map[i][j];
+ cout << checkEveryArr();
+}
+
+int checkEveryArr() {
+ int count = 0;
+
+ //행
+ int temp[MAX_N];
+ for (int row = 0; row < width; row++) {
+ if (checkSingleArr(map[row])) {
+ count++;
+ }
+ }
+
+ //열
+ for (int col = 0; col < width; col++) {
+ for (int j = 0; j < width; j++)
+ temp[j] = map[j][col];
+ if (checkSingleArr(temp)) {
+ count++;
+ }
+ }
+ return count;
+}
+
+bool checkSingleArr(int arr[MAX_N]) {
+ bool checked[MAX_N];
+ memset(checked, 0, sizeof(bool) * width);
+
+ int ex = arr[0];
+ for (int i = 1; i < width; i++) {
+ if (ex != arr[i]) {
+ int difference = ex - arr[i];
+ if (difference == -2 || difference == 2)
+ return false;
+
+ if (difference == 1) {
+ if (width - i >= need) {
+ for (int k = 0; k < need; k++)
+ if (arr[i] != arr[i + k])
+ return false;
+ for (int k = 0; k < need; k++)
+ checked[i + k] = true;
+ }
+ else
+ return false;
+ }
+ else if (difference == -1) {
+ if (i >= need) {
+ for (int k = 1; k <= need; k++)
+ if (ex != arr[i - k] || checked[i-k])
+ return false;
+ }
+ else
+ return false;
+ }
+ }
+ ex = arr[i];
+ }
+ return true;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+
#include <iostream>
+#include <cstdio>
+#define MAX_ROTATE 100
+#define LEFT 6
+#define RIGHT 2
+
+using namespace std;
+
+int command[MAX_ROTATE][2];
+int gear[4][8];
+int numOfRotate;
+
+int implementCommand();
+void implementSingleCommand(int gearN, int way);
+void rotateSingleGear(int gearN, int way);
+
+int main() {
+ for (int i = 0; i < 4; i++)
+ for (int j = 0; j < 8; j++)
+ scanf_s("%1d", &gear[i][j]);
+ cin >> numOfRotate;
+ for (int i = 0; i < numOfRotate; i++) {
+ cin >> command[i][0] >> command[i][1];
+ command[i][0] -= 1;
+ }
+
+ cout << implementCommand();
+}
+
+int implementCommand() {
+ for (int i = 0; i < numOfRotate; i++)
+ implementSingleCommand(command[i][0], command[i][1]);
+
+ int score = 0;
+ score += gear[0][0] == 0 ? 0 : 1;
+ score += gear[1][0] == 0 ? 0 : 2;
+ score += gear[2][0] == 0 ? 0 : 4;
+ score += gear[3][0] == 0 ? 0 : 8;
+ return score;
+}
+
+void implementSingleCommand(int gearN, int way) {
+ //1 : 시계방향, -1 : 반시계방향
+
+ rotateSingleGear(gearN, way);
+
+ //왼쪽
+ int exWay = way;
+ for (int current = gearN - 1; current >= 0; current--) {
+ if (exWay == 1) {
+ if (gear[current + 1][LEFT + 1] != gear[current][RIGHT]) {
+ rotateSingleGear(current, -1);
+ exWay = -1;
+ }
+ else
+ exWay = 0;
+ }
+ else if (exWay == -1) {
+ if (gear[current + 1][LEFT - 1] != gear[current][RIGHT]) {
+ rotateSingleGear(current, 1);
+ exWay = 1;
+ }
+ else
+ exWay = 0;
+ }
+ else
+ break;
+ }
+
+ //오른쪽
+ exWay = way;
+ for (int current = gearN + 1; current <= 3; current++) {
+ if (exWay == 1) {
+ if (gear[current - 1][RIGHT + 1] != gear[current][LEFT]) {
+ rotateSingleGear(current, -1);
+ exWay = -1;
+ }
+ else
+ exWay = 0;
+ }
+ else if (exWay == -1) {
+ if (gear[current - 1][RIGHT - 1] != gear[current][LEFT]) {
+ rotateSingleGear(current, 1);
+ exWay = 1;
+ }
+ else
+ exWay = 0;
+ }
+ else
+ break;
+ }
+
+}
+
+void rotateSingleGear(int gearN, int way) {
+ if (way == 1) {
+ int temp = gear[gearN][0];
+ for (int i = 1; i < 8; i++) {
+ int temp2 = gear[gearN][i];
+ gear[gearN][i] = temp;
+ temp = temp2;
+ }
+ gear[gearN][0] = temp;
+ }
+ else if (way == -1) {
+ int temp = gear[gearN][7];
+ for (int i = 6; i >= 0; i--) {
+ int temp2 = gear[gearN][i];
+ gear[gearN][i] = temp;
+ temp = temp2;
+ }
+ gear[gearN][7] = temp;
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+
1. 접근 방법
+ - 처음엔 DFS 또는 BFS로 접근
+ - 근데 해보니 이전에 왔던 것보다 적은 거리를 써서온건 보내고, 보낸 다음부터 이어지는 건 겹치면 빼야함.
+ - 결국 플로이드워셜로 최소거리를 모두 구한 후, 탐색범위 안에 들어오는 지역의 아이템을 모두 더하는 방식과 동일함.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+
#include <iostream>
+#include <list>
+#include <cstring>
+using namespace std;
+
+int n, m, r, t, item[31], area[31][31];
+int check[31];
+list<pair<int, pair<int, int>>> q;
+
+int floyd();
+int max(int a, int b) {
+ return a > b ? a : b;
+}
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+
+int main() {
+ cin >> n >> m >> r;
+ for (int i = 1; i <= n; i++)
+ cin >> item[i];
+
+ for (int i = 0; i <= n; i++)
+ for (int j = 0; j <= n; j++)
+ if (i != j)
+ area[i][j] = 200000000;
+
+ for (int i = 0; i < r; i++) {
+ int a, b, c;
+ cin >> a >> b >> c;
+
+ if (c < area[a][b]) {
+ area[a][b] = c;
+ area[b][a] = c;
+ }
+ }
+ cout << floyd() << endl;
+}
+
+int floyd() {
+ int result = 0;
+
+ for (int i = 1; i <= n; i++) {
+ for (int j = 1; j <= n; j++) {
+ for (int k = 1; k <= n; k++) {
+ if (area[j][k] > area[j][i] + area[i][k])
+ area[j][k] = area[j][i] + area[i][k];
+ }
+ }
+ }
+
+ for (int i = 1; i <= n; i++) {
+ int temp = 0;
+ for (int j = 1; j <= n; j++) {
+ if (area[i][j] <= m)
+ temp += item[j];
+ }
+ result = max(result, temp);
+ }
+ return result;
+}
+
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+
1. 최소한으로 눌러야하는 경우 : 한 칸은 한번만 눌러야함. 두번 이상누르면 최소가 아니고, 무한 루프가 될 수 잇음
+2. 모든 방법을 다 검사해봐야 정답을 얻을 수 있음 -> 브루트 포스
+3. 한번씩만 누르면 누르는 순서는 중요하지않음 -> 첫줄부터 차례대로 누름
+4. 이때 첫번째줄은 모든 경우로 누른다고 치고, 두번째 줄부터는 위에 전구가 켜진 경우만 눌러도 해결이 가능하다. -> 그리디
+5. 모든 경우는 0~1023까지 비트마스킹 방식으로 누르자 -> 비트마스킹
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+
#include <bits/stdc++.h>
+
+using namespace std;
+
+bool smap[10][10], tempMap[10][10];
+
+int brute();
+int rest();
+void swit(int r, int c);
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+
+int main() {
+ for (int i = 0; i < 10; i++) {
+ char t;
+ for (int j = 0; j < 10; j++) {
+ cin >> t;
+ if (t == '#')
+ smap[i][j] = 0;
+ else if (t == 'O')
+ smap[i][j] = 1;
+ }
+ }
+
+ int result = brute();
+ if (result >= 2000000000)
+ cout << -1;
+ else
+ cout << result;
+
+}
+
+int brute() {
+ int result = 2000000000;
+ for (int i = 0; i <= 1023; i++) {
+ memcpy(tempMap, smap, sizeof(smap));
+
+ int k = 0, count = 0;
+ for (int j = 512; j >= 1; j /= 2) {
+ if (i & j) {
+ swit(0, k);
+ count++;
+ }
+ k++;
+ }
+ int r = rest();
+ result = min(result, count + r);
+ }
+
+ return result;
+}
+
+int rest() {
+ int count = 0;
+ for (int i = 1; i < 10; i++)
+ for (int j = 0; j < 10; j++)
+ if (tempMap[i - 1][j]) {
+ swit(i, j);
+ count++;
+ }
+
+ for (int j = 0; j < 10; j++) {
+ if (tempMap[9][j])
+ count = 2000000000;
+ }
+
+ return count;
+}
+
+void swit(int r, int c) {
+ tempMap[r][c] = !(tempMap[r][c]);
+ if (r > 0)
+ tempMap[r - 1][c] = !(tempMap[r - 1][c]);
+ if (c < 9 )
+ tempMap[r][c + 1] = !(tempMap[r][c + 1]);
+ if (r < 9)
+ tempMap[r + 1][c] = !(tempMap[r + 1][c]);
+ if (c > 0)
+ tempMap[r][c - 1] = !(tempMap[r][c - 1]);
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+
#include <iostream>
+#include <queue>
+#include <vector>
+#define INF 2100000000;
+
+using namespace std;
+
+int n, m, v1,v2, fromOne[801], fromV1[801], fromV2[801];
+vector<pair<int, int>> e[801];
+priority_queue<pair<int, int>> q;
+
+int getAns();
+void dijkstra(int* from, int c);
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+
+ cin >> n >> m;
+ for (int i = 0; i < m; i++) {
+ int a, b, c;
+ cin >> a >> b >> c;
+ e[a].push_back({ b, c });
+ e[b].push_back({ a, c });
+ }
+ cin >> v1 >> v2;
+
+ cout << getAns();
+}
+
+int getAns() {
+ dijkstra(fromOne, 1);
+ dijkstra(fromV1, v1);
+ dijkstra(fromV2, v2);
+
+ int ans = INF;
+ if (fromOne[v1] == ans || fromV1[v2] == ans || fromV1[n] == ans || fromV2[n] == ans)
+ return -1;
+ return min(fromOne[v1] + fromV1[v2] + fromV2[n], fromOne[v2] + fromV2[v1] + fromV1[n]);
+}
+
+
+void dijkstra(int* from, int c) {
+ for (int i = 1; i <= n; i++)
+ from[i] = INF;
+ from[c] = 0;
+
+ q.push({ 0, c });
+ while (!q.empty()) {
+ int cost = -q.top().first, cur = q.top().second;
+ q.pop();
+
+ if (cost > from[cur])
+ continue;
+
+ for (int i = 0; i < e[cur].size(); i++) {
+ int nc = cost + e[cur][i].second, next = e[cur][i].first;
+
+ if (nc < from[next]) {
+ from[next] = nc;
+ q.push({ -nc, next });
+ }
+ }
+ }
+}
+
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
1. 2차원 bool 형 배열 palindrome에 모든 팰린드롬을 저장.
+ -> palindrome[i][j] 엔 시작이 i이고 끝이 j인 문자열이 팰린드롬인지 아닌지 저장돼있음
+ -> 구하는 법은 처음부터 i = 0~length, j = i~length; 로 가면서 팰린드롬인지 확인하고,
+ 팰린드롬이면 Manacher’s Algorithm 으로 그 사이 팰린드롬을 전부 표시
+ 아니면 그냥 넘어간다
+ -> 팰린드롬일경우 그 사이는 전부 표시했으니, 이중for문 진행하면서 palindrome[i][j]이 true면 그냥 넘어가면 된다.
+
+2. 저장한 palindrome을 바탕으로 바텀업 DP 시행
+ -> DP[length] : 각 시작점이 x일때 이후 최소의 분할수를 기록한 것.
+ -> DP함수 처음 호출할 때 시작을 0으로 하고, 끝점을 0에서 length까지 검사하며 각 끝점에 대해 팰린드롬이면 start + 1를 주며 아래로 내려간다.
+ -> 그리고 start가 length와 같아지면 0을 반환하며 1씩 증가하며 올라간다.
+ -> 이때 각 시작점에선 모든 끝점에 대해 반환값이 최소인 것을 result에 기록하고, 모든 끝점에 대한 검사가 끝나면 DP[start]에 result를 기록하고 반환한다.
+
+바텀업으로 재귀 DP 사용하니 느림
+
1
+2
+3
+4
+5
+
-> 해보니 시간은 비슷하다. 그냥 다른 DP 방식도 있는걸로 알고 넘어가자
+1. 반복문으로, i : 1~length / j : i+1~length 를 검사
+2. 이전에 저장된 값이 있으면, DP[i-1] + 1하고 비교했을 때 더 크면 그걸로 업데이트 아니면 그냥 넘어가기
+3. 저장된값이 없으면 DP[i-1] + 1 저장
+4. 각 시작부분은 시작 시 위 2~3을 한다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
for (int i = 1; i <= length; i++){
+ if ((DP[i] != 0 && DP[i] >DP[i - 1] + 1) || DP[i] == 0)
+
+DP[i] = DP[i - 1] + 1;
+
+for (int j = i + 1; j <= length; j++){
+if (Dp[i][j] != 0)
+{
+if ((DP[j] != 0 && DP[j] >DP[i-1] + 1) || DP[j] == 0)
+DP[j] = DP[i - 1] + 1;
+}
+}
+}
+
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+
#include <iostream>
+#include <string>
+#define MAX_LENGTH 2500
+
+using namespace std;
+//2차원 배열로 모든 팰린드롬 저장
+//첫번째 줄에 팰린드롬인것을 하나씩 넣음
+//그리고 오른쪽 아래로 내려가며 가능한 것을 최대한 넣자.
+//ex) map[0][0] 은 무조건 팰린드롬이니 고름 -> map[1][1]에서 가장가까운 팰린드롬 고름 map[1][1] -> map[2][2] -> ..... 총길이 2500, -> map[1][2] ...map[1][3].. 이렇게 진행?
+//위처럼 진행할 경우 2500*2500 + 2499*2499 + ... 총 26억 계산 -> 시간초과
+//가장가까운이 아닌, 가장 먼곳부터 골라보자. map[0][n] ... 그리고 길이가 이미고른 길이보다 길면 중간종료 하는 식으로?
+//하지만 최악의 경우 또 26억이 됨
+//DP = 위 계산을 바텀업방식으로 하여 DP[x] 에 길이를 저장하는 방식으로 해보자
+
+int length, DP[MAX_LENGTH];
+char input[MAX_LENGTH];
+bool palindrome[MAX_LENGTH][MAX_LENGTH];
+
+void makePalindrome();
+bool isPalindrome(int start, int end);
+void recordPalindrome(int start, int end);
+int getMinSplit(int start);
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+
+int main() {
+ string tempInput;
+ cin >> tempInput;
+ length = tempInput.size();
+ for (int i = 0; i < tempInput.size(); i++)
+ input[i] = tempInput[i];
+
+ makePalindrome();
+ cout << getMinSplit(0);
+
+}
+
+void makePalindrome() {
+ for (int i = 0; i < length; i++) {
+ for (int j = length - 1; j >= i; j--) {
+ if (palindrome[i][j] != 0)
+ continue;
+
+ if (isPalindrome(i, j))
+ recordPalindrome(i, j);
+ else
+ palindrome[i][j] = 0;
+ }
+ }
+}
+
+bool isPalindrome(int start, int end) {
+ for (; start < end; start++, end--)
+ if (input[start] != input[end])
+ return false;
+
+ return true;
+}
+
+void recordPalindrome(int start, int end) {
+ for (; start <= end; start++, end--)
+ palindrome[start][end] = 1;
+}
+
+int getMinSplit(int start) {
+ if (start == length)
+ return 0;
+ if (DP[start])
+ return DP[start];
+
+ int result = 200000000;
+
+ for (int i = length-1; i >= start; i--)
+ if (palindrome[start][i])
+ result = min(result, getMinSplit(i + 1) + 1);
+
+ return DP[start] = result;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
1. 어떤 건물을 짓기 위해 필요한 건물을 짓는 시간의 최대 + 이 건물을 짓는데 걸리는 시간을 출력하면 됨.
+2. 예를 들어
+ A -> -> D
+ C
+ B -> -> E
+ 로 그래프가 이루어져 있을 때,
+
+ A : A를 짓는 시간
+ B : B를 짓는 시간
+ C : max(A, B) + C를 짓는데 걸리는 시간
+ D : C + D를 짓는데 걸리는 시간
+ E : C + E를 짓는데 걸리는 시간
+ 이기 때문이다.
+ 물론 모든 건물은 지어질 수 있는 상태일 때 바로 짓는 것을 가정한다.
+3. 나는 이걸 무한루프로 모든 건물을 검사할 때까지, 모든 건물을 처음부터 끝까지 확인하는 식으로 구현하였다.
+ 최대 건물의 수가 500개이니 선형일경우 최악 25000이기에 충분히 시간이 많다고 생각했기 때문이다.
+ 하지만, 더 빠른 방법은 위상정렬을 하여 하는 방법이다.
+ 그래프가 그려져 있는 대로 정렬을 하여야한다.
+ 예를 들어, 위의 예에선 A B C D E 순으로 정렬이 되어야한다.
+ 이렇게하면, 무한루프로 할 필요없이 처음부터 그냥 쑥훑으면서 검사하면 끝나기 때문이다.
+
1
+2
+
1. 위상정렬 하는 법 알아보기 -> 알아봤는데 굳이 위상정렬 배열을 만들 필요는 없는 거 같다.
+2. DP : 왜 알고리즘 분류에 DP가 들어갔나 했더만, 이미 검사한 거는 check표시하여 검사하지않고, 최댓값을 다음 노드로 계속 넘겨주는 형태가 DP인거 같다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+
#include <bits/stdc++.h>
+#define MAX_LENGTH 100
+#define DIV 1000000000
+#define ALL 1023
+
+using namespace std;
+
+int N, num[101];
+long long DP[101][10][1 << 10];
+
+long long getAnswer(int, int);
+
+int main() {
+ cin >> N;
+ memset(DP, -1, sizeof(DP));
+
+ long long result = 0;
+ for (int i = 1; i <= 9; i++) {
+ num[0] = i;
+ result += getAnswer(1, 1 << i);
+ }
+
+ cout << result % DIV << endl;
+}
+
+long long getAnswer(int deep, int bit) {
+ if (deep == N) {
+ if (bit == ALL)
+ return 1;
+ return 0;
+ }
+ if (DP[deep][num[deep - 1]][bit] != -1)
+ return DP[deep][num[deep - 1]][bit];
+
+ long long result = 0;
+ if (num[deep - 1] != 0) {
+ num[deep] = num[deep - 1] - 1;
+ int b = bit & (1 << num[deep]) ? bit : bit + (1 << num[deep]);
+ result += getAnswer(deep + 1, b);
+ }
+ if (num[deep - 1] != 9) {
+ num[deep] = num[deep - 1] + 1;
+ int b = bit & (1 << num[deep]) ? bit : bit + (1 << num[deep]);
+ result += getAnswer(deep + 1, b);
+ }
+
+ return DP[deep][num[deep-1]][bit] = result % DIV;
+}
+
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+
#include <iostream>
+
+using namespace std;
+
+string str;
+int ans = 2000000000;
+
+int min(int a,int b) {
+ return a < b ? a : b;
+}
+
+void solve(int s, int length) {
+ int bc = 0;
+ for (int i = s; i < s + length; i++) {
+ if (str[i % str.size()] == 'b')
+ bc++;
+ }
+ ans = min(ans, bc);
+}
+
+int main() {
+ cin >> str;
+
+ int ac = 0;
+ for (int i = 0; i < str.size(); i++) {
+ if (str[i] == 'a')
+ ac++;
+ }
+ for (int i = 0; i < str.size(); i ++) {
+ solve(i, ac);
+ }
+
+ cout << ans;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+
#include <iostream>
+
+using namespace std;
+
+int N, T[1500000], P[1500000], DP[1500000];
+
+int dp(int deep);
+int max(int a, int b) {
+ return a > b ? a : b;
+}
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cin >> N;
+
+ for (int i = 0; i < N; i++) {
+ cin >> T[i] >> P[i];
+ }
+
+ cout << dp(0);
+}
+
+int dp(int deep) {
+ if (deep >= N)
+ return 0;
+ if (DP[deep] != 0)
+ return DP[deep];
+
+ int result = 0;
+ if (deep + T[deep] <= N)
+ result = dp(deep + T[deep]) + P[deep];
+ result = max(result, dp(deep + 1));
+
+ return DP[deep] = result;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+
1. 숫자를 기록하는 num[101] 배열과, DP[101][10][1 << 10] 배열을 이용하여 DP로 품
+2. 앞에서부터 길이에 맞게 숫자를 하나하나 기록해감. 기록하면서 비트마스킹으로 0~9가 있는지 표시
+ -> 이때 이미 표시된 비트에 또 표시하면 기록이 망가짐. 따라서 & 연산자로 검사하고 넣음
+ ex) int b = bit & (1 << num[deep]) ? bit : bit + (1 << num[deep]);
+3. 결과값은 DP[deep][num[deep-1]][bit] 에 기록하여 DP를 구현
+ (num[deep-1] 인 이유는 내 구현에선 현재 deep에 기록을 하고 다음 deep으로 넘기므로 num[deep]으로 하면 기록이 망가진다.)
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+
#include <bits/stdc++.h>
+#define MAX_LENGTH 100
+#define DIV 1000000000
+#define ALL 1023
+
+using namespace std;
+
+int N, num[101];
+long long DP[101][10][1 << 10];
+
+long long getAnswer(int, int);
+
+int main() {
+ cin >> N;
+ memset(DP, -1, sizeof(DP));
+
+ long long result = 0;
+ for (int i = 1; i <= 9; i++) {
+ num[0] = i;
+ result += getAnswer(1, 1 << i);
+ }
+
+ cout << result % DIV << endl;
+}
+
+long long getAnswer(int deep, int bit) {
+ if (deep == N) {
+ if (bit == ALL)
+ return 1;
+ return 0;
+ }
+ if (DP[deep][num[deep - 1]][bit] != -1)
+ return DP[deep][num[deep - 1]][bit];
+
+ long long result = 0;
+ if (num[deep - 1] != 0) {
+ num[deep] = num[deep - 1] - 1;
+ int b = bit & (1 << num[deep]) ? bit : bit + (1 << num[deep]);
+ result += getAnswer(deep + 1, b);
+ }
+ if (num[deep - 1] != 9) {
+ num[deep] = num[deep - 1] + 1;
+ int b = bit & (1 << num[deep]) ? bit : bit + (1 << num[deep]);
+ result += getAnswer(deep + 1, b);
+ }
+
+ return DP[deep][num[deep-1]][bit] = result % DIV;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+
#include <iostream>
+#include <list>
+#define INF 2000000000;
+
+using namespace std;
+
+struct node {
+ pair<int, int> r;
+ pair<int, int> b;
+ int d;
+};
+
+int map[10][10], n, m, os[4][2] = { {-1,0}, {0,1}, {1, 0}, {0,-1} };
+pair<int, int> h, r, b;
+bool visit[10][10][10][10];
+list<node> l;
+
+int bfs();
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+
+int main() {
+ cin >> n >> m;
+ for (int i = 0; i < n; i++) {
+ string a;
+ cin >> a;
+ for (int j = 0; j < m; j++) {
+ map[i][j] = a[j];
+ switch (map[i][j]) {
+ case 'R':
+ r = { i,j };
+ break;
+ case 'B':
+ b = { i,j };
+ break;
+ case 'O':
+ h = { i,j };
+ }
+ }
+ }
+
+ cout << bfs();
+}
+
+int bfs() {
+ visit[r.first][r.second][b.first][b.second] = true;
+ l.push_back({ {r.first, r.second}, {b.first, b.second}, 0 });
+
+ int ans = INF;
+ while (!l.empty()) {
+ node cur = l.front();
+ l.pop_front();
+
+ for (int i = 0; i < 4; i++) {
+ int rr = cur.r.first, rc = cur.r.second, br = cur.b.first, bc = cur.b.second, nd = cur.d + 1;
+ bool rf = true;
+ if (i % 2 == 0 && rc == bc) {
+ if (i == 0 && rr > br)
+ rf = false;
+ else if (i == 2 && rr < br)
+ rf = false;
+ }
+ else if (i % 2 == 1 && rr == br) {
+ if (i == 1 && bc > rc)
+ rf = false;
+ else if (i == 3 && bc < rc)
+ rf = false;
+ }
+ bool rh = false, bh = false;
+ if (rf) {
+ while (map[rr + os[i][0]][rc + os[i][1]] != '#') {
+ rr += os[i][0];
+ rc += os[i][1];
+ if (map[rr][rc] == 'O') {
+ rh = true;
+ rr = rc = -1;
+ break;
+ }
+ }
+ while (map[br + os[i][0]][bc + os[i][1]] != '#' && (br + os[i][0] != rr|| bc + os[i][1] != rc)) {
+ br += os[i][0];
+ bc += os[i][1];
+ if (map[br][bc] == 'O') {
+ bh = true;
+ break;
+ }
+ }
+ }
+ else {
+ while (map[br + os[i][0]][bc + os[i][1]] != '#') {
+ br += os[i][0];
+ bc += os[i][1];
+ if (map[br][bc] == 'O') {
+ bh = true;
+ br = bc = -1;
+ break;
+ }
+ }
+ while (map[rr + os[i][0]][rc + os[i][1]] != '#' && (rr + os[i][0] != br || rc + os[i][1] != bc)) {
+ rr += os[i][0];
+ rc += os[i][1];
+ if (map[rr][rc] == 'O') {
+ rh = true;
+ break;
+ }
+ }
+ }
+
+ if (rh && !bh)
+ ans = min(ans, nd);
+ else if (!rh && !bh && !visit[rr][rc][br][bc]) {
+ visit[rr][rc][br][bc] = true;
+ l.push_back({ {rr, rc}, {br, bc}, nd });
+ }
+ }
+ }
+
+ return ans == 2000000000 ? -1 : ans;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+
#include <iostream>
+#include <cstring>
+#define MAX_WIDTH 8
+#define WALL 6
+#define BLINDSPOT 0
+
+using namespace std;
+
+typedef struct CCTV {
+ int row;
+ int col;
+ int direction; // 1 : 북, 2 : 동, 3 : 남, 4 : 서
+ int num;
+} CCTV;
+
+int height, width;
+int map[MAX_WIDTH][MAX_WIDTH];
+int tempMap[MAX_WIDTH][MAX_WIDTH];
+CCTV cctv[MAX_WIDTH];
+int numOfCctv;
+
+int minBlindSpot(CCTV c[MAX_WIDTH], int len = 0);
+int calcBlindSpot(CCTV c[MAX_WIDTH]);
+void up(int i, int j);
+void right(int i, int j);
+void down(int i, int j);
+void left(int i, int j);
+
+int main() {
+ cin >> height >> width;
+ int index = 0;
+ for (int i = 0; i < height; i++)
+ for (int j = 0; j < width; j++) {
+ int temp;
+ cin >> temp;
+ map[i][j] = temp;
+ if (temp != 0 && temp != 6) {
+ cctv[index].row = i;
+ cctv[index].col = j;
+ cctv[index].direction = 0;
+ cctv[index++].num = temp;
+ }
+ }
+ numOfCctv = index;
+ cout << minBlindSpot(cctv);
+}
+
+int minBlindSpot(CCTV c[MAX_WIDTH], int len) {
+ if (len == numOfCctv)
+ return calcBlindSpot(c);
+
+ int temp[4];
+ int last = c[len].num != 1 ? c[len].num != 2 ? c[len].num != 3 ? c[len].num != 4 ? 1 : 4 : 4 : 2 : 4;
+ for (int i = 1; i <= last; i++) {
+ c[len].direction = i;
+ temp[i-1] = minBlindSpot(c, len + 1);
+ }
+
+ int min = temp[0];
+ for (int i = 1; i < last; i++)
+ min = temp[i] < min ? temp[i] : min;
+
+ return min;
+}
+
+int calcBlindSpot(CCTV c[MAX_WIDTH]) {
+ for (int i = 0; i < height; i++)
+ memcpy(tempMap[i], map[i], sizeof(int) * width);
+
+ for (int i = 0; i < numOfCctv; i++) {
+ if (c[i].num == 5) {
+ up(c[i].row, c[i].col);
+ right(c[i].row, c[i].col);
+ down(c[i].row, c[i].col);
+ left(c[i].row, c[i].col);
+ }
+ else if (c[i].num == 2) {
+ if (c[i].direction == 1) {
+ right(c[i].row, c[i].col);
+ left(c[i].row, c[i].col);
+ }
+ else if (c[i].direction == 2) {
+ up(c[i].row, c[i].col);
+ down(c[i].row, c[i].col);
+ }
+ }
+ else {
+ if (c[i].num == 1) {
+ if (c[i].direction == 1)
+ up(c[i].row, c[i].col);
+ else if (c[i].direction == 2)
+ right(c[i].row, c[i].col);
+ else if (c[i].direction == 3)
+ down(c[i].row, c[i].col);
+ else if (c[i].direction == 4)
+ left(c[i].row, c[i].col);
+ }
+ else if (c[i].num == 3) {
+ if (c[i].direction == 1) {
+ up(c[i].row, c[i].col);
+ right(c[i].row, c[i].col);
+ }
+ else if (c[i].direction == 2) {
+ right(c[i].row, c[i].col);
+ down(c[i].row, c[i].col);
+ }
+ else if (c[i].direction == 3) {
+ down(c[i].row, c[i].col);
+ left(c[i].row, c[i].col);
+ }
+ else if (c[i].direction == 4) {
+ left(c[i].row, c[i].col);
+ up(c[i].row, c[i].col);
+ }
+ }
+ else if (c[i].num == 4) {
+ if (c[i].direction == 1) {
+ up(c[i].row, c[i].col);
+ right(c[i].row, c[i].col);
+ left(c[i].row, c[i].col);
+ }
+ else if (c[i].direction == 2) {
+ up(c[i].row, c[i].col);
+ right(c[i].row, c[i].col);
+ down(c[i].row, c[i].col);
+ }
+ else if (c[i].direction == 3) {
+ left(c[i].row, c[i].col);
+ right(c[i].row, c[i].col);
+ down(c[i].row, c[i].col);
+ }
+ else if (c[i].direction == 4) {
+ left(c[i].row, c[i].col);
+ down(c[i].row, c[i].col);
+ up(c[i].row, c[i].col);
+ }
+ }
+ }
+ }
+
+ int count = 0;
+ for (int i = 0; i < height; i++)
+ for (int j = 0; j < width; j++)
+ if (tempMap[i][j] == 0)
+ count++;
+
+ return count;
+}
+
+void up(int i, int j) {
+ for (int k = i - 1; k >= 0; k--) {
+ if (tempMap[k][j] != 6)
+ tempMap[k][j] = -1;
+ else
+ break;
+ }
+}
+void right(int i, int j) {
+ for (int k = j + 1; k < width; k++) {
+ if (tempMap[i][k] != 6)
+ tempMap[i][k] = -1;
+ else
+ break;
+ }
+}
+void down(int i, int j) {
+ for (int k = i+ 1; k < height; k++) {
+ if (tempMap[k][j] != 6)
+ tempMap[k][j] = -1;
+ else
+ break;
+ }
+}
+void left(int i, int j) {
+ for (int k = j - 1; k >= 0; k--) {
+ if (tempMap[i][k] != 6)
+ tempMap[i][k] = -1;
+ else
+ break;
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+
#include <iostream>
+#define MAX_VERTICAL 10
+#define MAX_HORIZONTAL 30
+#define MAX_LINE 270
+
+using namespace std;
+
+typedef struct Ladder {
+ bool left;
+ bool right;
+} Ladder;
+typedef struct Location {
+ int row;
+ int col;
+} Location;
+
+Ladder ladder[MAX_HORIZONTAL][MAX_VERTICAL];
+int numOfVertical, numOfHorizontal, numOfLine;
+
+int getMinLine();
+bool downLadder();
+
+int main() {
+ cin >> numOfVertical >> numOfLine >> numOfHorizontal;
+ for (int i = 0; i < numOfLine; i++) {
+ int temp1, temp2;
+ cin >> temp1 >> temp2;
+
+ ladder[temp1 - 1][temp2 - 1].right = true;
+ ladder[temp1 - 1][temp2].left = true;
+ }
+
+ cout << getMinLine();
+}
+
+int getMinLine() {
+ //0개 추가
+ if (downLadder())
+ return 0;
+
+ Location location[MAX_HORIZONTAL * MAX_VERTICAL];
+ int index = 0;
+ for (int height = 0; height < numOfHorizontal; height++) {
+ for (int width = 0; width < numOfVertical - 1; width++) {
+ if (!ladder[height][width].right && !ladder[height][width].left) {
+ location[index].row = height;
+ location[index++].col = width;
+ }
+ }
+ }
+
+ //1개 추가
+ for (int i = 0; i < index; i++) {
+ ladder[location[i].row][location[i].col].right = true;
+ ladder[location[i].row][location[i].col + 1].left = true;
+ if (downLadder())
+ return 1;
+ ladder[location[i].row][location[i].col].right = false;
+ ladder[location[i].row][location[i].col+1].left = false;
+ }
+
+ //2개 추가
+ for (int i = 0; i < index-1; i++) {
+ ladder[location[i].row][location[i].col].right = true;
+ ladder[location[i].row][location[i].col + 1].left = true;
+ for (int j = i+1; j < index; j++) {
+ if (location[i].row == location[j].row && location[i].col + 1 == location[j].col)
+ continue;
+ ladder[location[j].row][location[j].col].right = true;
+ ladder[location[j].row][location[j].col + 1].left = true;
+ if (downLadder())
+ return 2;
+ ladder[location[j].row][location[j].col].right = false;
+ ladder[location[j].row][location[j].col + 1].left = false;
+ }
+ ladder[location[i].row][location[i].col].right = false;
+ ladder[location[i].row][location[i].col+1].left = false;
+ }
+
+
+ //3개 추가
+ for (int i = 0; i < index - 2; i++) {
+ ladder[location[i].row][location[i].col].right = true;
+ ladder[location[i].row][location[i].col + 1].left = true;
+ for (int j = i + 1; j < index-1; j++) {
+ if (location[i].row == location[j].row && location[i].col + 1 == location[j].col)
+ continue;
+ ladder[location[j].row][location[j].col].right = true;
+ ladder[location[j].row][location[j].col + 1].left = true;
+ for (int k = j + 1; k < index; k++) {
+ if(location[j].row == location[k].row && location[j].col + 1 == location[k].col)
+ continue;
+ ladder[location[k].row][location[k].col].right = true;
+ ladder[location[k].row][location[k].col + 1].left = true;
+ if (downLadder())
+ return 3;
+ ladder[location[k].row][location[k].col].right = false;
+ ladder[location[k].row][location[k].col + 1].left = false;
+ }
+ ladder[location[j].row][location[j].col].right = false;
+ ladder[location[j].row][location[j].col + 1].left = false;
+ }
+ ladder[location[i].row][location[i].col].right = false;
+ ladder[location[i].row][location[i].col + 1].left = false;
+ }
+
+
+ //그외
+ return -1;
+}
+
+bool downLadder() {
+ for (int start = 0; start < numOfVertical; start++) {
+ int current = start;
+ for (int height = 0; height < numOfHorizontal; height++) {
+ if (ladder[height][current].left)
+ current--;
+ else if (ladder[height][current].right)
+ current++;
+ }
+ if (start != current)
+ return false;
+ }
+ return true;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+
#include <iostream>
+#include <vector>
+#define MAP 101
+#define MAX_DRAGON 20
+#define MAX_GENERATION 10
+
+using namespace std;
+
+typedef struct Location {
+ int row;
+ int col;
+}Location;
+
+bool map[MAP][MAP];
+int dragon[MAX_DRAGON][4];
+int numOfdragon;
+
+void dragonCurb();
+void singleDragonCurb(int x, int y, int direction, int generation);
+int checkCell();
+
+int main() {
+ cin >> numOfdragon;
+ for (int i = 0; i < numOfdragon; i++)
+ cin >> dragon[i][0] >> dragon[i][1] >> dragon[i][2] >> dragon[i][3];
+
+ dragonCurb();
+ cout << checkCell();
+}
+
+void dragonCurb() {
+ for (int i = 0; i < numOfdragon; i++)
+ singleDragonCurb(dragon[i][0], dragon[i][1], dragon[i][2], dragon[i][3]);
+}
+
+void singleDragonCurb(int x, int y, int direction, int generation) {
+ vector<Location> v;
+ v.push_back({ y, x });
+ if (direction == 0) v.push_back({ y, x + 1 });
+ else if (direction == 1) v.push_back({ y - 1, x });
+ else if (direction == 2) v.push_back({ y, x - 1 });
+ else if (direction == 3) v.push_back({ y + 1, x });
+
+ for (int i = 0; i < generation; i++) {
+ for (int j = v.size() - 2; j >= 0; j--) {
+ int rowD = v[j].row - v[j + 1].row;
+ int colD = v[j].col - v[j + 1].col;
+ if (rowD == 1) //이전보다 아래
+ v.push_back({ v.back().row, v.back().col - 1 });
+ else if (rowD == -1) //이번보다 위
+ v.push_back({ v.back().row, v.back().col + 1 });
+ else if (colD == 1)
+ v.push_back({ v.back().row + 1, v.back().col });
+ else if (colD == -1)
+ v.push_back({ v.back().row -1, v.back().col });
+ }
+ }
+
+ for (int i = 0; i < v.size(); i++)
+ map[v[i].row][v[i].col] = true;
+}
+
+int checkCell() {
+ int count = 0;
+ for (int i = 0; i < MAP-1; i++) {
+ for (int j = 0; j < MAP-1; j++) {
+ if (map[i][j] && map[i + 1][j] && map[i][j + 1] && map[i + 1][j + 1])
+ count++;
+ }
+ }
+ return count;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+
#include <iostream>
+#define MAX_WIDTH 50
+#define MAX_CHIKEN 13
+
+using namespace std;
+
+typedef struct Location {
+ int row;
+ int col;
+} Location;
+
+int width, maxChiken, numOfHouse, numOfChiken;
+Location house[2 * MAX_WIDTH];
+Location chiken[MAX_CHIKEN];
+int minDistance = 10000000;
+int index[MAX_CHIKEN];
+
+void findMinChikenDistance(int deep = 0, int len = 0);
+
+int main() {
+ cin >> width >> maxChiken;
+ for (int i = 0; i < width; i++) {
+ for (int j = 0; j < width; j++) {
+ int temp;
+ cin >> temp;
+ if (temp == 1)
+ house[numOfHouse++] = { i, j };
+ else if (temp == 2)
+ chiken[numOfChiken++] = { i, j };
+ }
+ }
+
+
+ findMinChikenDistance();
+ cout << minDistance;
+}
+
+void findMinChikenDistance(int deep, int len) {
+ if (len == maxChiken) {
+ //검사
+ int distance = 0;
+ for (int h = 0; h < numOfHouse; h++) {
+ int min = 100000000;
+ for (int c = 0; c < maxChiken; c++) {
+ int rowD = house[h].row - chiken[index[c]].row;
+ int colD = house[h].col - chiken[index[c]].col;
+ rowD = rowD < 0 ? (-1) * rowD : rowD;
+ colD = colD < 0 ? (-1) * colD : colD;
+ min = (rowD + colD) < min ? (rowD + colD) : min;
+ }
+ distance += min;
+ }
+ minDistance = distance < minDistance ? distance : minDistance;
+ return;
+ }
+ if (numOfChiken - deep < maxChiken - len)
+ return;
+
+ index[len] = deep;
+ findMinChikenDistance(deep + 1, len + 1);
+ findMinChikenDistance(deep + 1, len);
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+
#include <bits/stdc++.h>
+
+using namespace std;
+
+struct robot {
+ int bigest;
+ int cur;
+ int length;
+};
+
+vector<pair<int,int>> edges[100010];
+int n, a, b;
+int nodes[100010];
+list<robot> q;
+
+int BFS();
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cin >> n >> a >> b;
+ for (int i = 0; i < n-1; i++) {
+ int t1, t2, t3;
+ cin >> t1 >> t2 >> t3;
+ edges[t1].push_back({ t2, t3 });
+ edges[t2].push_back({ t1, t3 });
+ }
+ for (int i = 1; i <=n; i++) {
+ nodes[i] = 2000000000;
+ }
+ cout << BFS() << "\n";
+}
+
+int BFS() {
+ q.push_back({ 0, a, 0});
+ nodes[a] = 0;
+ int result = 2000000000;
+
+ while (!q.empty()) {
+ int cur = q.front().cur, bigest = q.front().bigest, length = q.front().length;
+ q.pop_front();
+
+ if (cur == b) {
+ result = min(result, length - bigest);
+ continue;
+ }
+
+ for (int i = 0; i < edges[cur].size(); i++) {
+ int to = edges[cur][i].first, w = edges[cur][i].second;
+ if (length + w < nodes[to]) {
+ int bigger = max(bigest, w);
+ nodes[to] = length + w;
+ q.push_back({ bigger, to, nodes[to] });
+ }
+ }
+ }
+
+ return result;
+}
+
Comments powered by Disqus.
원리
i = 1에서는 1로만 쭉 더한 것(3 = 1 + 1 + 1) 경우만 따짐.
i = 2에서는 1로만 더한 것에 2를 추가한 경우를 따진다.
i = 3에서도 마찬가지.
ex) m = 4일때
i = 1
1 = 1
2 = 1 + 1
3 = 1 + 1 + 1
4 = 1 + 1 + 1 + 1
i = 2
1 = 1
2 = 1 + 1 / 2
3 = 1 + 1 + 1 / 1 + 2
4 = 1 + 1 + 1 + 1 / 1 + 1 + 2 / 2 + 2
i = 3
1 = 1
2 = 1 + 1 / 2
3 = 1 + 1 + 1 / 1 + 2 / 3
4 = 1 + 1 + 1 + 1 / 1 + 1 + 2 / 2 + 2 / 1 + 3
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+
#include <iostream>
+#include <cstring>
+
+using namespace std;
+
+int n, m;
+long long save[10010];
+
+long long dp();
+
+int main() {
+ cin >> n;
+ while (n--) {
+ cin >> m;
+ cout << dp() << endl;
+ memset(save, 0, sizeof(save));
+ }
+}
+
+long long dp() {
+ save[0] = 1;
+
+ for (int i = 1; i <= 3; i++)
+ for (int j = i; j <= m; j++)
+ save[j] += save[j - i];
+
+ return save[m];
+}
+
Comments powered by Disqus.
입력으로 들어온, 알려진 전후관계로 그래프를 만듦.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+
#include <iostream>
+#define INF 1000000000
+using namespace std;
+
+int n, k, s, map[401][401];
+
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cout.tie(0);
+
+ for (int i = 0; i <= 400; i++) {
+ for (int j = 0; j <= 400; j++) {
+ if(i != j)
+ map[i][j] = INF;
+ }
+ }
+
+ int a, b;
+ cin >> n >> k;
+ for (int i = 0; i < k; i++) {
+ cin >> a >> b;
+ map[a][b] = 1;
+ }
+
+ for (int i = 1; i <= n; i++) {
+ for (int j = 1; j <= n; j++) {
+ for (int k = 1; k <= n; k++) {
+ map[j][k] = min(map[j][k], map[j][i] + map[i][k]);
+ }
+ }
+ }
+
+
+ cin >> s;
+ for (int i = 0; i < s; i++) {
+ cin >> a >> b;
+ if (map[a][b] != INF)
+ cout << -1 << "\n";
+ else if (map[b][a] != INF)
+ cout << 1 << "\n";
+ else
+ cout << 0 << "\n";
+ }
+}
+
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+
#include <iostream>
+#include <list>
+#include <cstring>
+#define MAX_WIDTH 50
+
+using namespace std;
+
+typedef struct Location {
+ int row;
+ int col;
+} Location;
+
+int map[MAX_WIDTH][MAX_WIDTH];
+int tempMap[MAX_WIDTH][MAX_WIDTH];
+int width, lowerBound, upperBound;
+bool visit[MAX_WIDTH][MAX_WIDTH];
+
+int getCountOfImmigration();
+bool checkNeibor(Location l, int way);
+void movePeople(Location l);
+
+int main() {
+ cin >> width >> lowerBound >> upperBound;
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++)
+ cin>>map[i][j];
+
+ cout << getCountOfImmigration();
+}
+
+int getCountOfImmigration() {
+ int count = 0;
+ bool check = true;
+ for (int i = 0; i < width; i++)
+ memcpy(tempMap[i], map[i], sizeof(int) * width);
+
+ while (check) {
+ check = false;
+ bool check2 = false;
+ for (int i = 0; i < width; i++)
+ memset(visit[i], 0, sizeof(bool) * width);
+
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++) {
+ if (visit[i][j])
+ continue;
+ if (i > 0 && checkNeibor({ i, j }, 0)) {
+ movePeople({ i,j });
+ count += check2 ? 0 : 1;
+ check = true;
+ check2 = true;
+ }
+ else if (j < width -1 && checkNeibor({ i, j }, 1)) {
+ movePeople({ i,j });
+ count += check2 ? 0 : 1;
+ check = true;
+ check2 = true;
+ }
+ else if (i < width - 1 && checkNeibor({ i, j }, 2)) {
+ movePeople({ i,j });
+ count += check2 ? 0 : 1;
+ check = true;
+ check2 = true;
+ }
+ else if (j > 0 && checkNeibor({ i, j }, 3)) {
+ movePeople({ i,j });
+ count += check2 ? 0 : 1;
+ check = true;
+ check2 = true;
+ }
+ }
+
+ for (int i = 0; i < width; i++)
+ memcpy(map[i], tempMap[i], sizeof(int) * width);
+
+ }
+
+ return count;
+}
+
+
+bool checkNeibor(Location l, int way) {
+ if (l.row > 0 && way == 0) {
+ int d = map[l.row][l.col] - map[l.row - 1][l.col];
+ d = d < 0 ? (-1) * d : d;
+ if (d >= lowerBound && d <= upperBound)
+ return true;
+ }
+ else if (l.row < width - 1 && way == 2) {
+ int d = map[l.row][l.col] - map[l.row + 1][l.col];
+ d = d < 0 ? (-1) * d : d;
+ if (d >= lowerBound && d <= upperBound)
+ return true;
+ }
+ else if (l.col > 0 && way == 3) {
+ int d = map[l.row][l.col] - map[l.row][l.col - 1];
+ d = d < 0 ? (-1) * d : d;
+ if (d >= lowerBound && d <= upperBound)
+ return true;
+ }
+ else if (l.col < width - 1 && way == 1) {
+ int d = map[l.row][l.col] - map[l.row][l.col + 1];
+ d = d < 0 ? (-1) * d : d;
+ if (d >= lowerBound && d <= upperBound)
+ return true;
+ }
+
+ return false;
+}
+
+void movePeople(Location l) {
+ bool tempVisit[MAX_WIDTH][MAX_WIDTH] = { 0, };
+ list<Location> q;
+ q.push_back({ l.row, l.col });
+
+ list<Location> temp;
+ temp.push_back({ l.row, l.col });
+ tempVisit[l.row][l.col] = true;
+ visit[l.row][l.col] = true;
+ while (!temp.empty()) {
+ Location t = temp.front();
+ temp.pop_front();
+ if (!tempVisit[t.row - 1][t.col] && checkNeibor(t, 0)) {
+ temp.push_back({ t.row - 1, t.col });
+ q.push_back({ t.row - 1, t.col });
+ tempVisit[t.row - 1][t.col] = true;
+ visit[t.row - 1][t.col] = true;
+ }
+ if (!tempVisit[t.row][t.col + 1] && checkNeibor(t, 1)) {
+ temp.push_back({ t.row, t.col +1});
+ q.push_back({ t.row, t.col +1});
+ tempVisit[t.row][t.col + 1] = true;
+ visit[t.row][t.col + 1] = true;
+ }
+ if (!tempVisit[t.row + 1][t.col] && checkNeibor(t, 2)) {
+ temp.push_back({ t.row+1, t.col });
+ q.push_back({ t.row+1, t.col });
+ tempVisit[t.row+1][t.col] = true;
+ visit[t.row + 1][t.col] = true;
+ }
+ if (!tempVisit[t.row][t.col - 1] && checkNeibor(t, 3)) {
+ temp.push_back({ t.row, t.col - 1 });
+ q.push_back({ t.row, t.col - 1 });
+ tempVisit[t.row][t.col - 1] = true;
+ visit[t.row][t.col - 1] = true;
+ }
+ }
+
+ int count = 0;
+ list<Location>::iterator iter;
+ for (iter = q.begin(); iter != q.end(); iter++)
+ count += map[(*iter).row][(*iter).col];
+
+ int people = count / q.size();
+
+ for (iter = q.begin(); iter != q.end(); iter++) {
+ tempMap[(*iter).row][(*iter).col] = people;
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+
#include <iostream>
+#include <algorithm>
+#include <vector>
+#define MAX_WIDTH 10
+
+using namespace std;
+
+typedef struct Tree {
+ int age;
+ bool isAlive;
+ bool operator < (Tree t) {
+ return age < t.age;
+ }
+} Tree;
+typedef struct Cell {
+ int ntr;
+ vector<Tree> tree;
+} Cell;
+
+Cell map[MAX_WIDTH][MAX_WIDTH];
+int nutrition[MAX_WIDTH][MAX_WIDTH];
+int width, maxYear;
+
+void growTrees();
+int checkAliveTree();
+void spring();
+void summer();
+void fall();
+void winter();
+
+int main() {
+ int tempM;
+ cin >> width >> tempM >> maxYear;
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++) {
+ cin >> nutrition[i][j];
+ map[i][j].ntr = 5;
+ }
+ for (int i = 0; i < tempM; i++) {
+ int row, col, age;
+ cin >> row >> col >> age;
+ map[row-1][col-1].tree.push_back({ age, true });
+ }
+
+ growTrees();
+ cout << checkAliveTree();
+}
+
+void growTrees() {
+ for (int i = 0; i < maxYear; i++) {
+ spring();
+ summer();
+ fall();
+ winter();
+ }
+}
+void spring() {
+ //나이순으로 정렬
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++) {
+ sort(map[i][j].tree.begin(), map[i][j].tree.end());
+ }
+
+ //양분을 주고, 죽은 건 false 표시하기
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++)
+ for (int k = 0; k < map[i][j].tree.size(); k++) {
+ if (map[i][j].ntr >= map[i][j].tree[k].age) {
+ map[i][j].ntr -= map[i][j].tree[k].age;
+ map[i][j].tree[k].age++;
+ }
+ else
+ map[i][j].tree[k].isAlive = false;
+ }
+}
+void summer() {
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++) {
+ int count = 0;
+ for (int k = 0; k < map[i][j].tree.size(); k++) {
+ if (!map[i][j].tree[k].isAlive) {
+ map[i][j].ntr += (map[i][j].tree[k].age / 2);
+ count++;
+ }
+ }
+ for (int k = 0; k < count; k++) {
+ map[i][j].tree.pop_back();
+ }
+ }
+}
+void fall() {
+ for (int i = 0; i < width; i++) {
+ for (int j = 0; j < width; j++) {
+ for (int k = 0; k < map[i][j].tree.size(); k++) {
+ if (map[i][j].tree[k].age % 5 == 0) {
+ if (i > 0 && j > 0)
+ map[i - 1][j - 1].tree.push_back({ 1, true });
+
+ if (i > 0)
+ map[i - 1][j].tree.push_back({ 1, true });
+
+ if (i > 0 && j < width - 1)
+ map[i - 1][j + 1].tree.push_back({ 1,true });
+
+ if (j > 0)
+ map[i][j - 1].tree.push_back({ 1, true });
+
+ if (j < width -1)
+ map[i][j+1].tree.push_back({ 1, true });
+
+ if (i < width -1 && j >0)
+ map[i + 1][j - 1].tree.push_back({ 1,true });
+
+ if (i < width -1)
+ map[i+1][j].tree.push_back({ 1, true });
+
+ if (i < width - 1 && j < width -1)
+ map[i +1][j+1].tree.push_back({ 1, true });
+ }
+ }
+ }
+ }
+
+}
+void winter() {
+ for(int i = 0; i<width; i++)
+ for (int j = 0; j < width; j++) {
+ map[i][j].ntr += nutrition[i][j];
+ }
+}
+int checkAliveTree() {
+ int count = 0;
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++)
+ for (int k = 0; k < map[i][j].tree.size(); k++) {
+ if (map[i][j].tree[k].isAlive)
+ count++;
+ else
+ break;
+ }
+ return count;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+
#include <iostream>
+#include <list>
+#define MAX_WIDTH 20
+
+using namespace std;
+
+typedef struct Location {
+ int row;
+ int col;
+ int distance;
+ bool operator < (Location t) {
+ if (distance < t.distance)
+ return true;
+ else if (t.distance < distance)
+ return false;
+ else {
+ if (row < t.row)
+ return true;
+ else if (t.row < row)
+ return false;
+ else if (col < t.col)
+ return true;
+ else
+ return false;
+ }
+ }
+} Location;
+
+int map[MAX_WIDTH][MAX_WIDTH];
+int width;
+Location shark;
+
+int babyShark();
+bool isThereSmallThanMe(int sharkSize);
+
+int main() {
+ cin >> width;
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++) {
+ cin >> map[i][j];
+ if (map[i][j] == 9) {
+ shark.row = i;
+ shark.col = j;
+ shark.distance = 0;
+ map[i][j] = 0;
+ }
+ }
+ cout << babyShark();
+}
+
+int babyShark() {
+ int distance = 0;
+ int sharkSize = 2;
+ int countEat = 0;
+
+ while (true) {
+ if (isThereSmallThanMe(sharkSize)) {
+ list<Location> q;
+ list<Location> canEat;
+ q.push_back(shark);
+ bool visit[MAX_WIDTH][MAX_WIDTH] = { 0, };
+ visit[shark.row][shark.col] = true;
+ while (!q.empty()) {
+ Location temp = q.front();
+ q.pop_front();
+
+ if (map[temp.row][temp.col] != 0 && map[temp.row][temp.col] < sharkSize)
+ canEat.push_back(temp);
+
+ if (temp.row > 0 && !visit[temp.row - 1][temp.col] && map[temp.row - 1][temp.col] <= sharkSize) {
+ q.push_back({ temp.row - 1, temp.col, temp.distance + 1 });
+ visit[temp.row - 1][temp.col] = true;
+ }
+ if (temp.col < width - 1 && !visit[temp.row][temp.col + 1] && map[temp.row][temp.col + 1] <= sharkSize) {
+ q.push_back({ temp.row, temp.col + 1, temp.distance + 1 });
+ visit[temp.row][temp.col + 1] = true;
+ }
+ if (temp.row < width - 1 && !visit[temp.row + 1][temp.col] && map[temp.row + 1][temp.col] <= sharkSize) {
+ q.push_back({ temp.row + 1, temp.col, temp.distance + 1 });
+ visit[temp.row + 1][temp.col] = true;
+ }
+ if (temp.col > 0 && !visit[temp.row][temp.col - 1] && map[temp.row][temp.col - 1] <= sharkSize) {
+ q.push_back({ temp.row, temp.col - 1, temp.distance + 1 });
+ visit[temp.row][temp.col - 1] = true;
+ }
+ }
+
+ //가장 가깝고 왼쪽 위 먹고, visit 초기화, shark 위치, 사이즈 확인, count 1 증가,
+ if (!canEat.empty()) {
+ canEat.sort();
+ Location eat = canEat.front();
+ map[eat.row][eat.col] = 0;
+ shark.row = eat.row;
+ shark.col = eat.col;
+ shark.distance = 0;
+ distance += eat.distance;
+ countEat++;
+ if (countEat == sharkSize) {
+ sharkSize++;
+ countEat = 0;
+ }
+ }
+ else
+ break;
+ }
+ else
+ break;
+ }
+
+ return distance;
+}
+
+bool isThereSmallThanMe(int sharkSize) {
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++)
+ if (map[i][j] != 0 && sharkSize > map[i][j])
+ return true;
+ return false;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
#include <iostream>
+
+using namespace std;
+
+long long A, B, C;
+long long result = 1;
+
+
+int main() {
+ cin >> A >> B >> C;
+
+ while (B != 0) {
+ if (B % 2 == 1) {
+ result = (result * A) % C;
+ }
+ A = (A * A) % C;
+ B /= 2;
+ }
+ cout << result % C;
+}
+
Comments powered by Disqus.
1
+2
+
1. 에라토스테네스의 체로, N이하의 소수를 모두 구함
+2. 두 포인터로 일치하는 해당하는 연속합을 구함
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+
초기 : start = 0, end = 1, sum = prime[0]
+
+ while start < end
+ if sum == N
+ count++
+ sum -= prime[start++] //밑에서 end를 기준으로 끝을 정했으니, start를 조작한다.
+
+ else if sum < N
+ if end == numOfPrime //더이상 커질 수 없으므로 종료
+ break;
+ sum += prime[end++]
+
+ else
+ sum -= prime[start++] //크므로 줄임
+```
+
+## 코드
+```cpp
+#include <iostream>
+#define MAX 4000001
+
+using namespace std;
+
+int prime[290000], tempPrime[MAX];
+int N, numOfPrime = 0;
+
+void generatePrime();
+int getResult();
+
+int main() {
+ ios::sync_with_stdio(0);
+ cout.tie(0);
+ cin >> N;
+ generatePrime();
+ cout << getResult();
+}
+
+void generatePrime() {
+ for (int i = 2; i <= N; i++)
+ tempPrime[i] = i;
+
+ for (int i = 2; i <= N / 2; i++) {
+ if (tempPrime[i] != -1)
+ for (int j = 2 * i; j <= N; j += i) {
+ tempPrime[j] = -1;
+ }
+ }
+ for (int i = 2; i <= N; i++)
+ if (tempPrime[i] != -1)
+ prime[numOfPrime++] = tempPrime[i];
+}
+
+int getResult() {
+ int start = 0, end = 1;
+ int sum = prime[0], count = 0;
+
+
+ while (start < end) {
+ if (sum == N) {
+ count++;
+ sum -= prime[start++];
+ }
+ else if (sum < N) {
+ if (end == numOfPrime)
+ break;
+ sum += prime[end++];
+ }
+ else
+ sum -= prime[start++];
+ }
+ return count;
+}
+
Comments powered by Disqus.
1
+2
+
1. MST를 만들고, 가장 거리가 긴 길을 빼면 된다.
+2. n개의 노드에 대해 n-1개의 간선만 연결되어있으므로, 1개만 빼면 딱 두개로 나눌 수 있는데, 뺀다면 가장 거리가 긴 길이기 때문이다.(2개 이상 빼면 3개이상으로 나눠짐)
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+
#include <iostream>
+#include <vector>
+#include <cstring>
+#include <algorithm>
+#define MAX_WAY 1000000
+#define MAX_NODE 100000
+
+using namespace std;
+
+typedef struct Way {
+ int node1;
+ int node2;
+ int value;
+ bool operator < (Way w) {
+ return value < w.value;
+ }
+} Way;
+
+Way way[MAX_WAY];
+int node[MAX_NODE+1];
+
+vector<vector<int>> set;
+vector<int> MST;
+int numOfWay, numOfHouse;
+
+int getMinValue();
+void makeMST();
+
+int main() {
+ cin >> numOfHouse >> numOfWay;
+ for (int i = 0; i < numOfWay; i++)
+ cin >> way[i].node1 >> way[i].node2 >> way[i].value;
+
+ cout << getMinValue();
+}
+
+int getMinValue() {
+ sort(way, &way[numOfWay]);
+ memset(node, -1, sizeof(node));
+ makeMST();
+
+ sort(MST.begin(), MST.end());
+ MST.pop_back();
+ int value = 0;
+ for (int i = 0; i < MST.size(); i++)
+ value += way[MST[i]].value;
+ return value;
+}
+
+void makeMST() {
+ for (int i = 0; i < numOfWay; i++) {
+ if (node[way[i].node1] == -1 && node[way[i].node2] == -1) {
+ vector<int> temp;
+ temp.push_back(i);
+ set.push_back(temp);
+ node[way[i].node1] = set.size() - 1;
+ node[way[i].node2] = set.size() - 1;
+ }
+ else if (node[way[i].node1] == -1) {
+ node[way[i].node1] = node[way[i].node2];
+ set[node[way[i].node1]].push_back(i);
+ }
+ else if (node[way[i].node2] == -1) {
+ node[way[i].node2] = node[way[i].node1];
+ set[node[way[i].node2]].push_back(i);
+ }
+ else {
+ if (node[way[i].node1] < node[way[i].node2]) {
+ int temp = node[way[i].node2];
+ for (int j = 0; j < set[temp].size(); j++) {
+ node[way[set[temp][j]].node1] = node[way[i].node1];
+ node[way[set[temp][j]].node2] = node[way[i].node1];
+ set[node[way[i].node1]].push_back(set[temp][j]);
+ }
+ set[node[way[i].node1]].push_back(i);
+ set[temp].clear();
+ }
+ else if (node[way[i].node1] > node[way[i].node2]) {
+ int temp = node[way[i].node1];
+ for (int j = 0; j < set[temp].size(); j++) {
+ node[way[set[temp][j]].node1] = node[way[i].node2];
+ node[way[set[temp][j]].node2] = node[way[i].node2];
+ set[node[way[i].node2]].push_back(set[temp][j]);
+ }
+ set[node[way[i].node1]].push_back(i);
+ set[temp].clear();
+ }
+ }
+
+ }
+ MST = set[0];
+ set.clear();
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+
1. 멀티셋으로 가운데를 트래킹해가면서 구함
+2. 첫번째 원소를 넣고, s.begin()으로 첫번째 iter를 middle로 받고 그대로 출력
+3. 두번째부턴 middle과 같은 원소가 들어오면, s.insert(s.upperbound(*middle), input) 으로 가장 앞에 넣음
+ 아니면 그냥 s.insert 로 넣음
+4. 현재 넣는 것이 짝수번째 숫자이고, 넣은 원소가 현재 middle보다 작을 경우 middle-- (작은 원소가 들어왔을 때, middle은 반쪽 바로 앞에 위치하기에)
+ 현재 넣는 것이 홀수번째 숫자이고, 넣은 원소가 현재 middle보다 같거나 클 경우 middle++ (같거나 큰 원소가 들어왔을 때, middle은 반쪽 바로 뒤에 위치하기에)
+5. middle을 출력
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+
1. priority_queue로 최대힙, 최소힙 둘 다 선언
+2. 먼저 최대힙에 넣고, 다음 원소를 최소힙에 넣는 식으로 입력을 받음
+3. 입력을 받을 때마다, 최대힙의 top과 최소힙의 top을 비교하여 최대힙의 top이 더 크면 교환함
+4. 이후 최대힙의 top을 출력(이것이 중간값이니까)
+
+원리
+
+ 2~3 과정을 거치면서, 최대힙에는 작은 수들이 저장되고, 최소힙에는 큰 수들이 저장된다.
+ 그리고 작은 수들의 최대는 중간값이다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+
#include <iostream>
+#include <set>
+
+using namespace std;
+
+multiset<int> s;
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cout.tie(0);
+
+ int numOfN, temp;
+ cin >> numOfN >> temp;
+ s.insert(temp);
+ multiset<int>::iterator middle = s.begin();
+ cout << "result : " << *middle << "\n";
+
+ for (int i = 2; i <= numOfN; i++) {
+ cin >> temp;
+ int cur = *middle;
+ if (temp == cur)
+ s.insert(s.upper_bound(temp), temp);
+ else
+ s.insert(temp);
+
+ if (i % 2 == 1) {
+ if (temp >= cur)
+ middle++;
+ }
+ else if (i % 2 == 0) {
+ if (temp < cur)
+ middle--;
+ }
+ cout << "result : " << *middle << "\n";
+ for (multiset<int>::iterator iter = s.begin(); iter != s.end(); iter++)
+ cout << *iter << " ";
+ cout << "\n\n";
+ }
+}
+
Comments powered by Disqus.
1
+2
+
1. unionfind 를 구현하되, 루트에 친구비가 적은 것이 오도록함
+2. 루트만 골라 친구비를 정산한다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+
#include <iostream>
+#include <vector>
+#include <cstring>
+#include <algorithm>
+#define MAX_STUDENT 10001
+
+using namespace std;
+
+int numOfStudent, numOfFriendship, money, students[MAX_STUDENT], minMoney, studentGroup[MAX_STUDENT];
+
+void unionStudent(int first, int second);
+int find(int element);
+bool makeFriend();
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cin >> numOfStudent >> numOfFriendship >> money;
+ for (int i = 1; i <= numOfStudent; i++) {
+ cin >> students[i];
+ studentGroup[i] = i;
+ }
+ for (int i = 0; i < numOfFriendship; i++) {
+ int first, second;
+ cin >> first >> second;
+ unionStudent(first, second);
+ }
+ if (makeFriend())
+ cout << minMoney;
+ else
+ cout << "Oh no";
+}
+
+//값이 작은 게 루트에 오도록
+void unionStudent(int first, int second) {
+ first = find(first);
+ second = find(second);
+
+ if (students[first] <= students[second])
+ studentGroup[second] = first;
+ else
+ studentGroup[first] = second;
+}
+
+
+int find(int element) {
+ if (studentGroup[element] == element)
+ return element;
+ else
+ return find(studentGroup[element]);
+}
+
+bool makeFriend() {
+ for (int i = 1; i <= numOfStudent; i++) {
+ if (studentGroup[i] == i) {
+ if (money < students[i])
+ return false;
+ minMoney += students[i];
+ money -= students[i];
+ }
+ }
+
+ return true;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
1. 고른 카드를 버킷정렬함(400만개이므로 버킷정렬이 훨씬 빠르다. sort는 NlogN)
+2. 범위를 저장하는 set<pair<int,int>>을 선언하고 첫 범위를 넣음(0-m)
+3. 철수가 뽑은 카드의 수가 저장된 범위의 끝의 수보다 작을 때의 범위를 찾고, 그 범위안에서 uppper_bound로 큰수를 찾고,
+ 그 찾은 공간을 제외한 양쪽의 두 범위를 다시 범위set에 추가하고, 현재 범위는 삭제한다.
+
+ ex) 철수가 뽑은 수 5 / 범위 : 0-3 5-7 / cards : 1 2 3 4 5 6 7 8
+ 1. 범위 앞에서부터 검사
+ 0-3 -> 3번째 카드는 4. 5보다 작으므로 통과
+ 5-7 -> 7번째 카드는 8. 5보다 크므로 스탑
+ 2. 5-7을 기준으로 upper_bound를 실시 : upper_bound(cards + (*iter).first, cards + (*iter).second + 1, 5);
+ -> 나온 포인터를 저장
+ 3. 5-7에서 5보다 큰 것은 6이므로, 포인터는 card + 5를 가리키고 있음.
+ 이 cards + 5를 기준으로 두 범위로 분리시킨 후 저장.
+ -> 이때 첫번째 원소이므로 왼쪽은 없음 따라서 오른쪽범위만 추가(6-7)
+ 4. 기존 5-7범위는 삭제.
+ 5. 찾은 수, 6을 리턴.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+
#include <iostream>
+#include <algorithm>
+#include <utility>
+#include <set>
+#define MAX_CARD 4000000
+#define MAX_DRAW 10000
+
+using namespace std;
+
+int cards[MAX_CARD], draw[MAX_DRAW], numOfCard, m, numOfDraw;
+bool buket[MAX_CARD + 1];
+set<pair<int, int>> bound;
+
+void buketSort();
+int findCard(int drawCard);
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cin >> numOfCard >> m >> numOfDraw;
+ for (int i = 0; i < m; i++) {
+ int temp;
+ cin >> temp;
+ buket[temp] = true;
+ }
+ for (int i = 0; i < numOfDraw; i++) {
+ cin >> draw[i];
+ }
+ buketSort();
+ bound.insert(make_pair(0, m-1));
+
+ for (int i = 0; i < numOfDraw; i++)
+ cout << findCard(draw[i])<< "\n";
+}
+
+
+void buketSort() {
+ int index = 0;
+ for (int i = 1; i < MAX_CARD + 1; i++)
+ if (buket[i]) {
+ cards[index++] = i;
+ }
+}
+
+int findCard(int drawCard) {
+
+ for (set<pair<int, int>>::iterator iter = bound.begin(); iter != bound.end(); iter++) {
+ if (cards[(*iter).second] > drawCard) {
+ int* temp = upper_bound(cards + (*iter).first, cards + (*iter).second + 1, drawCard);
+ if(temp -cards != (*iter).first)
+ bound.insert(make_pair((*iter).first, temp - cards - 1));
+ if(temp - cards != (*iter).second)
+ bound.insert(make_pair(temp - cards + 1, (*iter).second));
+ bound.erase(iter);
+ return *temp;
+ }
+ }
+
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+
#include <iostream>
+using namespace std;
+
+long long N, num[10];
+char op[10];
+
+long long calculate(int deep);
+long long max(long long a, long long b) {
+ return a > b ? a : b;
+}
+
+int main() {
+ cin >> N;
+ for (int i = 0; i < N; i++) {
+ if (i % 2 == 0)
+ cin >> num[i/2];
+ else
+ cin >> op[i/2];
+ }
+
+ cout << calculate(0);
+}
+
+long long calculate(int deep) {
+ if (deep == N / 2) {
+ return num[0];
+ }
+
+ int last = (N - deep * 2) / 2;
+ long long result = -6000000000;
+ for (int i = 0; i < last; i++) {
+ char saveOp = op[i];
+ int saveNum = num[i], saveNum2 = num[i + 1];
+
+ if (saveOp == '+')
+ num[i] = saveNum + saveNum2;
+ else if (saveOp == '-')
+ num[i] = saveNum - saveNum2;
+ else
+ num[i] = saveNum * saveNum2;
+
+ for (int j = i + 1; j < last; j++)
+ num[j] = num[j + 1];
+ for (int j = i; j < last - 1; j++)
+ op[j] = op[j + 1];
+
+ result = max(result, calculate(deep + 1));
+
+ for (int j = last; j > i + 1; j--)
+ num[j] = num[j - 1];
+ for (int j = last - 1; j > i; j--)
+ op[j] = op[j - 1];
+ op[i] = saveOp;
+ num[i] = saveNum;
+ num[i + 1] = saveNum2;
+ }
+
+
+ return result;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
1. 맵에 있는 서로 이어져있는 그래프의 개수를 세면 됨.
+2. visit을 만들어, 이미 검사한 그래프의 원소엔 true를 표시한다. 그리고 tempVisit을 만들어, 현재 검사하고 있는 그래프의 원소에 true를 표시한다.
+3. 먼저, 첫번째 셀부터 검사하지 않았으면 DFS를 실시한다.
+ -> 갈수있는데까지 가면서 tempVisit에 true를 표시
+ -> tempVsit이든 visit 배열이든 true로 표시돼있는 칸에 오면 중지
+ -> 이때 상태는 두가지 : 자기들끼리 돌다 만난건지, 이미 검사한 그래프로 합쳐지는 건지.
+ -> 전체 visit 배열이 true이면 원래 DFS에 합쳐지는 것 -> false 반환
+ -> 전체 visit 배열은 false이고 현재 visit배열도 false 일때 -> 진행
+ -> 전체 visit 배열은 false이고 현재 visit배열은 true일때 -> 자기끼리 만나는 것 -> true반환
+ -> 현재 검사하는 원소를 하나씩 list에 넣고, 하나씩 빼가며 전체 visit배열에 true표시하고 현재 배열은 false로 초기화하기
+4. true로 반환될 때만 새로운 그래프가 만들어지는 것이므로 safezone의 개수 1증가
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+
#include <iostream>
+#include <vector>
+#include <string>
+#define MAX_WIDTH 1000
+
+using namespace std;
+
+typedef struct Location {
+ int row;
+ int col;
+
+} Location;
+
+char map[MAX_WIDTH][MAX_WIDTH];
+int n, m, safezone;
+bool visit[MAX_WIDTH][MAX_WIDTH], tempVisit[MAX_WIDTH][MAX_WIDTH];
+
+void generateSafezone();
+bool DFS(int row, int col);
+Location getNextCell(Location cur);
+
+int main() {
+ cin >> n >> m;
+ for (int i = 0; i < n; i++) {
+ string temp;
+ cin >> temp;
+ for (int j = 0; j < m; j++) {
+ map[i][j] = temp[j];
+ }
+ }
+ generateSafezone();
+ cout << safezone;
+}
+
+
+void generateSafezone() {
+ for (int i = 0; i < n; i++)
+ for (int j = 0; j < m; j++)
+ if (!visit[i][j]) {
+ if (DFS(i, j)) {
+ safezone++;
+ }
+ }
+}
+
+bool DFS(int row, int col) {
+ vector<Location> q;
+ Location cur = { row,col };
+
+ while (!visit[cur.row][cur.col] && !tempVisit[cur.row][cur.col]) {
+ q.push_back({ cur.row, cur.col });
+ tempVisit[cur.row][cur.col] = true;
+ cur = getNextCell(cur);
+ }
+
+ bool result;
+ if (visit[cur.row][cur.col])
+ result = false;
+ else
+ result = true;
+
+ for (int i = 0; i < q.size(); i++) {
+ visit[q[i].row][q[i].col] = true;
+ tempVisit[q[i].row][q[i].col] = false;
+ }
+ return result;
+}
+
+Location getNextCell(Location cur) {
+ if (map[cur.row][cur.col] == 'D')
+ return { cur.row + 1, cur.col };
+ else if (map[cur.row][cur.col] == 'U')
+ return { cur.row - 1, cur.col };
+ else if (map[cur.row][cur.col] == 'L')
+ return { cur.row, cur.col - 1 };
+ else
+ return { cur.row, cur.col + 1 };
+}
+
Comments powered by Disqus.
BFS로 가능한 경우를 찾아가면 된다.
그런데 주의점은, 뱀을 타는게 더 이득일 경우가 있다는 것만 주의하자
ex)
1
+2
+3
+4
+
2 1
+2 60
+30 99
+65 29
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+
#include <bits/stdc++.h>
+
+using namespace std;
+
+int N, M, box[110];
+list<pair<int,int>> q;
+bool visited[110];
+
+int BFS();
+
+int main() {
+ cin >> N >> M;
+ int t;
+ for (int i = 0; i < N; i++) {
+ cin >> t;
+ cin >> box[t];
+ }
+ for (int i = 0; i < M; i++) {
+ cin >> t;
+ cin >> box[t];
+ }
+ cout << BFS();
+}
+
+int BFS() {
+ visited[1] = true;
+ q.push_back({ 1,0 });
+ int result = 2000000000;
+ while (!q.empty()) {
+ int cur = q.front().first, count = q.front().second;
+ q.pop_front();
+
+ if (cur == 100) {
+ result = min(result, count);
+ continue;
+ }
+ else if (cur > 100)
+ continue;
+
+ for (int i = 1; i <= 6; i++) {
+ int next = cur + i;
+ if (!visited[next]) {
+ if (box[next] != 0) {
+ q.push_back({ box[next], count + 1 });
+ visited[box[next]] = true;
+ }
+ else
+ q.push_back({ next, count + 1 });
+ visited[next] = true;
+ }
+ }
+ }
+ return result;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+
1. 각 맵의 빈공간마다 각자의 크기를 BFS로 구함
+2. 이때, 각자의 id를 지정하여 같은 집합에 속하면 같은 id를 갖도록 하자
+3. BFS가 끝나면 각 벽을 검사
+ -> 주변에 인접한 모든 빈공간의 아까 구한 크기를 모두 더하고 자기자신 + 1해서 리턴
+ -> 이때, 주변에 인접한 빈공간들의 id 중 겹치는 것이 있는지 확인하면서 넣자. id가 같은 것이 이미 들어가있으면 그것은 더하지 않는다.
+
1
+2
+
1. memset으로 visit을 매 BFS마다 초기화시켰는데, 최대 10만번 BFS를 실시하니, 10만 x 10만 회의 연산이 진행된다.
+ -> 따라서 BFS로 넣어진 것들만 false로 초기화 시키자
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+
#include <iostream>
+#include <string>
+#include <vector>
+#include <list>
+#include <cstring>
+#define MAX_N 1000
+#define MAX_M 1000
+
+using namespace std;
+
+typedef struct Location {
+ int row;
+ int col;
+} Location;
+
+int n, m, BFSMap[MAX_N][MAX_M][2], result[MAX_N][MAX_M];
+Location q[MAX_N * MAX_M];
+bool map[MAX_N][MAX_M], visit[MAX_N][MAX_M];
+
+void generateBFS();
+void generateResult();
+void BFS(int row, int col, int id);
+int getResult(int row, int col);
+
+int main() {
+ cin >> n >> m;
+ for (int i = 0; i < n; i++) {
+ string s;
+ cin >> s;
+ for (int j = 0; j < m; j++) {
+ map[i][j] = s[j] - '0';
+ }
+ }
+
+ generateBFS();
+ generateResult();
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < m; j++)
+ cout << result[i][j];
+ cout << "\n";
+ }
+}
+
+void generateBFS() {
+ int id = 1;
+ for (int i = 0; i < n; i++)
+ for (int j = 0; j < m; j++)
+ if (map[i][j] == 0 && BFSMap[i][j][0] == 0)
+ BFS(i, j, id++);
+}
+
+void BFS(int row, int col, int id) {
+ int index = 0, first = 0;
+ q[index++] = { row, col };
+ visit[row][col] = true;
+
+ while (first < index) {
+ Location temp = q[first++];
+
+ if (temp.row > 0 && map[temp.row - 1][temp.col] == 0 && !visit[temp.row - 1][temp.col]) {
+ q[index++] = { temp.row - 1, temp.col };
+ visit[temp.row - 1][temp.col] = true;
+ }
+ if (temp.row < n - 1 && map[temp.row + 1][temp.col] == 0 && !visit[temp.row + 1][temp.col]) {
+ q[index++] = { temp.row + 1, temp.col };
+ visit[temp.row + 1][temp.col] = true;
+ }
+ if (temp.col > 0 && map[temp.row][temp.col - 1] == 0 && !visit[temp.row][temp.col - 1]) {
+ q[index++] = { temp.row, temp.col - 1 };
+ visit[temp.row][temp.col - 1] = true;
+ }
+ if (temp.col < m - 1 && map[temp.row][temp.col + 1] == 0 && !visit[temp.row][temp.col + 1]) {
+ q[index++] = { temp.row, temp.col + 1 };
+ visit[temp.row][temp.col + 1] = true;
+ }
+ }
+
+ for (int i = 0; i < index; i++) {
+ BFSMap[q[i].row][q[i].col][0] = index;
+ BFSMap[q[i].row][q[i].col][1] = id;
+ visit[q[i].row][q[i].col] = false;
+ }
+}
+
+void generateResult() {
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < m; j++) {
+ if (map[i][j] == 0)
+ result[i][j] = 0;
+ else
+ result[i][j] = getResult(i, j) % 10;
+ }
+ }
+}
+
+int getResult(int row, int col) {
+ int pickedId[4] = { -1, -1, -1, -1 };
+ int length = 0;
+ int result = 0;
+
+ if (row > 0) {
+ if (BFSMap[row - 1][col][0] != 0) {
+ result += BFSMap[row - 1][col][0];
+ pickedId[length++] = BFSMap[row - 1][col][1];
+ }
+ }
+ if (row < n - 1) {
+ if (BFSMap[row + 1][col][0] != 0) {
+ bool check = true;
+ for (int i = 0; i < length; i++) {
+ if (pickedId[i] == BFSMap[row + 1][col][1])
+ check = false;
+ }
+ if (check) {
+ result += BFSMap[row + 1][col][0];
+ pickedId[length++] = BFSMap[row + 1][col][1];
+ }
+ }
+ }
+ if (col > 0) {
+ if (BFSMap[row][col-1][0] != 0) {
+ bool check = true;
+ for (int i = 0; i < length; i++) {
+ if (pickedId[i] == BFSMap[row][col-1][1])
+ check = false;
+ }
+ if (check) {
+ result += BFSMap[row][col-1][0];
+ pickedId[length++] = BFSMap[row][col-1][1];
+ }
+ }
+ }
+ if (col < m - 1) {
+ if (BFSMap[row][col+1][0] != 0) {
+ bool check = true;
+ for (int i = 0; i < length; i++) {
+ if (pickedId[i] == BFSMap[row][col+1][1])
+ check = false;
+ }
+ if (check) {
+ result += BFSMap[row][col+1][0];
+ }
+ }
+ }
+
+ return result + 1;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+
1. q와 nextq를 선언
+2. q엔 현재 노드를 저장. 하나식 꺼내서 이동가능한 인접 칸을 nextq에 추가.
+3. 다 추가하면, 벽을 한칸 내림
+4. 이후 q에 nextq를 넣고, nextq는 비운채 다음 루프 시작.
+5. 루프 중에 q에서 꺼낸 노드가 벽이 있는 칸이라면 추가안하고 다음 노드로, 최우측상단이라면 종료
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+
#include <bits/stdc++.h>
+
+using namespace std;
+
+char miro[8][8];
+list<pair<int, int>> q, nextq;
+bool visitcheck[8][8];
+
+bool BFS();
+
+int main() {
+ for (int i = 0; i < 8; i++)
+ for (int j = 0; j < 8; j++)
+ cin >> miro[i][j];
+
+ cout << BFS();
+}
+
+bool BFS() {
+ bool check = false;
+ nextq.push_back({ 7,0 });
+
+ while (!nextq.empty() && !check) {
+ q = nextq;
+ nextq.clear();
+ memset(visitcheck, 0, sizeof(visitcheck));
+
+ while (!q.empty()) {
+ int r = q.front().first, c = q.front().second;
+ q.pop_front();
+
+ if (miro[r][c] == '#')
+ continue;
+ if (r == 0 && c == 7) {
+ check = true;
+ break;
+ }
+
+ if (miro[r][c] != '#' && !visitcheck[r][c]) {
+ nextq.push_back({ r, c });
+ visitcheck[r][c] = true;
+ }
+ if (r > 0 && miro[r - 1][c] != '#' && !visitcheck[r - 1][c]) {
+ nextq.push_back({ r - 1,c });
+ visitcheck[r - 1][c] = true;
+ }
+ if (r > 0 && c < 7 && miro[r - 1][c + 1] != '#' && !visitcheck[r - 1][c + 1]) {
+ nextq.push_back({ r - 1,c + 1 });
+ visitcheck[r - 1][c + 1] = true;
+ }
+ if (c < 7 && miro[r][c + 1] != '#' && !visitcheck[r][c + 1]) {
+ nextq.push_back({ r, c + 1 });
+ visitcheck[r][c + 1] = true;
+ }
+ if (r < 7 && c < 7 && miro[r + 1][c + 1] != '#' && !visitcheck[r + 1][c + 1]) {
+ nextq.push_back({ r + 1,c + 1 });
+ visitcheck[r + 1][c + 1] = true;
+ }
+ if (r < 7 && miro[r + 1][c] != '#' && !visitcheck[r + 1][c]) {
+ nextq.push_back({ r + 1,c });
+ visitcheck[r + 1][c] = true;
+ }
+ if (r < 7 && c > 0 && miro[r + 1][c - 1] != '#' && !visitcheck[r + 1][c - 1]) {
+ nextq.push_back({ r + 1,c - 1 });
+ visitcheck[r + 1][c - 1] = true;
+ }
+ if (c > 0 && miro[r][c - 1] != '#' && !visitcheck[r][c - 1]) {
+ nextq.push_back({ r, c - 1 });
+ visitcheck[r][c - 1] = true;
+ }
+ if (r > 0 && c > 0 && miro[r - 1][c - 1] != '#' && !visitcheck[r - 1][c - 1]) {
+ nextq.push_back({ r - 1,c - 1 });
+ visitcheck[r - 1][c - 1] = true;
+ }
+ }
+
+ for (int i = 7; i > 1; i--)
+ for (int j = 0; j < 8; j++)
+ miro[i][j] = miro[i - 1][j];
+ for (int j = 0; j < 8; j++)
+ miro[0][j] = '.';
+ }
+
+ return check;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+
#include <iostream>
+#define INF 2000000000
+using namespace std;
+
+int n, ans = INF, os[9][2] = { {0,0}, {0, 1}, {0, -1}, {1, -1}, {1, 0}, {1, 1}, {-1, -1}, {-1, 0}, {-1, 1} };
+int diff, nums[100010];
+
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+int abs(int a) {
+ return a < 0 ? -a : a;
+}
+
+int dfs(int d, int prev) {
+ if (d == n - 1)
+ return 0;
+
+ int res = INF;
+ for (int j = -1; j <= 1; j++) {
+ nums[d + 1] += j;
+
+ if ((nums[d + 1] - nums[d]) == diff)
+ res = min(res, dfs(d + 1, j) + abs(j));
+
+ nums[d + 1] -= j;
+ }
+ return res;
+}
+
+int main() {
+ cin >> n;
+ for (int i = 0; i < n; i++)
+ cin >> nums[i];
+ if (n <= 2) {
+ cout << 0;
+ return 0;
+ }
+
+ for (int i = 0; i < 9; i++) {
+ nums[0] += os[i][0]; nums[1] += os[i][1];
+ diff = nums[1] - nums[0];
+
+ ans = min(ans, dfs(1, nums[1]) + abs(os[i][0]) + abs(os[i][1]));
+ nums[0] -= os[i][0]; nums[1] -= os[i][1];
+ }
+
+ if (ans >= INF - 200000)
+ cout << -1;
+ else
+ cout << ans;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+
#include <iostream>
+#include <algorithm>
+#include <cstring>
+#include <vector>
+#define MAX_NUM 101
+
+using namespace std;
+
+typedef struct Cell {
+ int value;
+ int count;
+
+ bool operator < (Cell c) {
+ if (count < c.count)
+ return true;
+ else if (c.count < count)
+ return false;
+ else {
+ if (value < c.value)
+ return true;
+ else
+ return false;
+ }
+ }
+} Cell;
+
+int map[MAX_NUM][MAX_NUM];
+int width, height;
+int r, c, k;
+
+int getTimeToReachRCK();
+void print() {
+ cout << endl;
+ for (int i = 0; i < height; i++) {
+ for (int j = 0; j < width; j++)
+ cout << map[i][j] << " ";
+ cout << endl;
+ }
+}
+
+int main() {
+ cin >> r >> c >> k;
+ for (int i = 0; i < MAX_NUM; i++)
+ memset(map[i], 0, sizeof(int) * MAX_NUM);
+
+ for (int i = 0; i < 3; i++)
+ for (int j = 0; j < 3; j++)
+ cin >> map[i][j];
+
+ width = height = 3;
+ cout << getTimeToReachRCK();
+}
+
+int getTimeToReachRCK() {
+ int time = 0;
+
+ for (time; time <= 100; time++) {
+ if (map[r-1][c-1] == k)
+ break;
+
+ int temp[MAX_NUM];
+ memset(temp, 0, sizeof(int) * (MAX_NUM));
+
+ if (height >= width) {
+ int maxWidth = 0;
+ for (int i = 0; i < height; i++) {
+ for (int j = 0; j < width; j++) {
+ temp[map[i][j]]++;
+ }
+
+ vector<Cell> temp2;
+ for (int j = 1; j < MAX_NUM; j++)
+ if (temp[j] != 0)
+ temp2.push_back({ j, temp[j] });
+
+ sort(temp2.begin(), temp2.end());
+ int index = 0;
+ for (int j = 0; j < temp2.size(); j++) {
+ if (index >= 100)
+ break;
+ map[i][index++] = temp2[j].value;
+ map[i][index++] = temp2[j].count;
+ }
+ if (index < width)
+ for (int j = index; j < width; j++)
+ map[i][j] = 0;
+
+ maxWidth = index > maxWidth ? index : maxWidth;
+ memset(temp, 0, sizeof(int) * (MAX_NUM));
+ }
+ width = maxWidth;
+ }
+ else {
+ int maxHeight = 0;
+ for (int i = 0; i < width; i++) {
+ for (int j = 0; j < height; j++) {
+ temp[map[j][i]]++;
+ }
+
+ vector<Cell> temp2;
+ for (int j = 1; j < MAX_NUM; j++)
+ if (temp[j] != 0)
+ temp2.push_back({ j, temp[j] });
+
+ sort(temp2.begin(), temp2.end());
+ int index = 0;
+ for (int j = 0; j < temp2.size(); j++) {
+ if (index >= 100)
+ break;
+ map[index++][i] = temp2[j].value;
+ map[index++][i] = temp2[j].count;
+ }
+ if (index < height)
+ for (int j = index; j < height; j++)
+ map[j][i] = 0;
+
+ maxHeight = index > maxHeight ? index : maxHeight;
+ memset(temp, 0, sizeof(int) * MAX_NUM);
+ }
+ height = maxHeight;
+ }
+ }
+
+
+ return (time == 101 ? -1 : time);
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+
#include <iostream>
+#include <cstring>
+#include <vector>
+#include <list>
+#include <algorithm>
+#define MAX_WIDTH 50
+#define WALL 1
+
+using namespace std;
+int map[MAX_WIDTH][MAX_WIDTH];
+
+typedef struct Virus {
+ int row;
+ int col;
+ int time;
+
+ bool operator < (Virus v) {
+ if (map[row][col] == 2 && map[v.row][v.col] != 2)
+ return false;
+ else if (map[row][col] != 2 && map[v.row][v.col] == 2)
+ return true;
+ else
+ return time > v.time;
+ }
+} Virus;
+
+int width, numOfActiveVirus, numOfVirus;
+vector<Virus> virus;
+bool canSpread = false;
+
+int minToSpreadVirus(vector<Virus> active, int deep);
+int min(int a, int b);
+
+int main() {
+ cin >> width >> numOfActiveVirus;
+ numOfVirus = 0;
+ for (int i = 0; i < width; i++) {
+ for (int j = 0; j < width; j++) {
+ cin >> map[i][j];
+ if (map[i][j] == 2) {
+ virus.push_back({ i, j, 0});
+ numOfVirus++;
+ }
+ }
+ }
+ vector<Virus> temp;
+ int result = minToSpreadVirus(temp, 0);
+ if (result == -1 && canSpread)
+ cout << 0;
+ else
+ cout << minToSpreadVirus(temp, 0);
+}
+
+int minToSpreadVirus(vector<Virus> active, int deep) {
+ if (active.size() == numOfActiveVirus) {
+ //퍼트리기
+ list<Virus> q;
+ bool visit[MAX_WIDTH][MAX_WIDTH] = { 0, };
+ for (int i = 0; i < active.size(); i++) {
+ q.push_back(active[i]);
+ visit[active[i].row][active[i].col] = true;
+ }
+
+ vector<Virus> minTimeCandidate;
+ while (!q.empty()) {
+ Virus v = q.front();
+ q.pop_front();
+
+ int count = 0;
+ if (v.row > 0 && !visit[v.row - 1][v.col] && map[v.row - 1][v.col] != 1) {
+ q.push_back({ v.row - 1, v.col, v.time + 1 });
+ visit[v.row - 1][v.col] = true;
+ if(map[v.row-1][v.col] == 0)
+ count++;
+ }
+ if (v.col < width - 1 && !visit[v.row][v.col + 1] && map[v.row][v.col + 1] != 1) {
+ q.push_back({ v.row, v.col + 1, v.time + 1 });
+ visit[v.row][v.col + 1] = true;
+ if(map[v.row][v.col+1] == 0)
+ count++;
+ }
+ if (v.row < width - 1 && !visit[v.row + 1][v.col] && map[v.row + 1][v.col] != 1) {
+ q.push_back({ v.row + 1, v.col, v.time + 1 });
+ visit[v.row + 1][v.col] = true;
+ if(map[v.row+1][v.col]==0)
+ count++;
+ }
+ if (v.col > 0 && !visit[v.row][v.col - 1] && map[v.row][v.col - 1] != 1) {
+ q.push_back({ v.row, v.col - 1, v.time + 1 });
+ visit[v.row][v.col - 1] = true;
+ if(map[v.row][v.col-1] == 0)
+ count++;
+ }
+
+ if (count == 0)
+ minTimeCandidate.push_back(v);
+ }
+
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++)
+ if (!visit[i][j] && map[i][j] != 1)
+ return -1;
+
+ canSpread = true;
+ sort(minTimeCandidate.begin(), minTimeCandidate.end());
+ if (map[minTimeCandidate[0].row][minTimeCandidate[0].col] == 2)
+ return -1;
+ else
+ return minTimeCandidate[0].time;
+
+ }
+ if (numOfVirus - deep < numOfActiveVirus - active.size())
+ return -1;
+
+ int a = minToSpreadVirus(active, deep + 1);
+ active.push_back(virus[deep]);
+ int b = minToSpreadVirus(active, deep + 1);
+
+ return min(a, b);
+}
+int min(int a, int b) {
+ if (a == -1)
+ return b;
+ else if (b == -1)
+ return a;
+ else
+ return a < b ? a : b;
+}
+
Comments powered by Disqus.
1
+2
+3
+
1. 기존 map에서 미세먼지가 있는 부분만, 기존에 있던 미세먼지만 확산시키는 게 관건
+2. 따라서 tempMap을 만들어서 map을 복사한 다음에, map에 있는 미세먼지 양을 받아서, tempMap에 확산시키고, 다 확산하면 tempMap을 map에 복사하고 순환하여야 한다.
+3. 자꾸 갱신되는 상황을 잊지 말자
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+
#include <iostream>
+#include <cstring>
+#define MAX_WIDTH 50
+
+using namespace std;
+
+int map[MAX_WIDTH][MAX_WIDTH];
+int tempMap[MAX_WIDTH][MAX_WIDTH];
+int width, height, time;
+int airCirculatorRow[2];
+
+int airCirculator();
+void diffuseDust(int row, int col);
+void runAirCirculator();
+
+int main() {
+ cin >> height >> width >> time;
+ int index = 0;
+ for (int i = 0; i < height; i++) {
+ for (int j = 0; j < width; j++) {
+ cin >> map[i][j];
+ if (map[i][j] == -1)
+ airCirculatorRow[index++] = i;
+ }
+ }
+ cout << endl;
+ cout << airCirculator();
+}
+
+int airCirculator() {
+ for (int second = 0; second < time; second++) {
+ for (int i = 0; i < height; i++)
+ memcpy(tempMap[i], map[i], sizeof(int) * width);
+
+ //확산
+ for (int i = 0; i < height; i++)
+ for (int j = 0; j < width; j++)
+ if(map[i][j] != 0)
+ diffuseDust(i, j);
+
+
+ for (int i = 0; i < height; i++)
+ memcpy(map[i], tempMap[i], sizeof(int) * width);
+
+ cout << endl;
+ for (int i = 0; i < height; i++) {
+ for (int j = 0; j < width; j++)
+ cout << map[i][j] << " ";
+ cout << endl;
+ }
+ //청정기
+ runAirCirculator();
+ }
+
+ int dust = 0;
+ for (int i = 0; i < height; i++)
+ for (int j = 0; j < width; j++)
+ dust += map[i][j];
+ return dust + 2;
+}
+
+void diffuseDust(int row, int col) {
+ int count = 0;
+ int dustDiffusionAmount = map[row][col] / 5;
+
+ if (row > 0 && tempMap[row - 1][col] != -1) {
+ tempMap[row - 1][col] += dustDiffusionAmount;
+ count++;
+ }
+ if (col < width - 1) {
+ tempMap[row][col + 1] += dustDiffusionAmount;
+ count++;
+ }
+ if (row < height - 1 && tempMap[row + 1][col] != -1) {
+ tempMap[row + 1][col] += dustDiffusionAmount;
+ count++;
+ }
+ if (col > 0 && tempMap[row][col-1] != -1) {
+ tempMap[row][col - 1] += dustDiffusionAmount;
+ count++;
+ }
+
+ tempMap[row][col] -= (dustDiffusionAmount * count);
+}
+
+void runAirCirculator() {
+ //위
+ int temp = map[airCirculatorRow[0]][1];
+ map[airCirculatorRow[0]][1] = 0;
+ for (int i = 2; i < width; i++) {
+ int temp2 = map[airCirculatorRow[0]][i];
+ map[airCirculatorRow[0]][i] = temp;
+ temp = temp2;
+ }
+ for (int i = airCirculatorRow[0]-1; i >= 0; i--) {
+ int temp2 = map[i][width - 1];
+ map[i][width - 1] = temp;
+ temp = temp2;
+ }
+ for (int i = width - 2; i >= 0; i--) {
+ int temp2 = map[0][i];
+ map[0][i] = temp;
+ temp = temp2;
+ }
+ for (int i = 1; i < airCirculatorRow[0]; i++) {
+ int temp2 = map[i][0];
+ map[i][0] = temp;
+ temp = temp2;
+ }
+
+ //아래
+ temp = map[airCirculatorRow[1]][1];
+ map[airCirculatorRow[1]][1] = 0;
+ for (int i = 2; i < width; i++) {
+ int temp2 = map[airCirculatorRow[1]][i];
+ map[airCirculatorRow[1]][i] = temp;
+ temp = temp2;
+ }
+ for (int i = airCirculatorRow[1] + 1; i < height; i++) {
+ int temp2 = map[i][width - 1];
+ map[i][width - 1] = temp;
+ temp = temp2;
+ }
+ for (int i = width - 2; i >= 0; i--) {
+ int temp2 = map[height - 1][i];
+ map[height - 1][i] = temp;
+ temp = temp2;
+ }
+ for (int i = height - 2; i > airCirculatorRow[1]; i--) {
+ int temp2 = map[i][0];
+ map[i][0] = temp;
+ temp = temp2;
+ }
+}
+
Comments powered by Disqus.
양 선분이 평행할 경우, 또는 한 쪽이 x축에 평행하고, 다른 축이 y축에 평행할 경우엔 조건문을 통해 범위를 잘 검사하여 처리
나머지 경우엔 다음과 같은 방법을 사용한다.
첫번째 선분을 이루는 직선이 두번째 선분을 양분하고, 그 반대도 양분하면 두 선분은 교차한다.
이때 한 직선이 한 선분을 양분하는지 알아보는 식은 다음과 같다.
f1 = (y21-y11)(x12-x11) - (x21-x11)(y12-y11)
f2 = (y22-y11)(x12-x11) - (x22-x11)(y12-y11)
이고, f1 * f2 < 0 일때 양분함.
이때, 이 문제에서는 끝 점에 지나는 것도 교차한다고 판단하니, f1 * f2 <= 0 일때 참으로 판단하자.
단, 이러면 평행할때도 0이 나오니, 평행 검사는 이 방법보다 먼저 하자.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+
#include <iostream>
+typedef long long ll;
+using namespace std;
+
+struct line {
+ ll h, t, ch, ct;
+};
+
+void swap(ll* a, ll* b) {
+ ll t = *a;
+ *a = *b;
+ *b = t;
+}
+void makeLine(line* l, ll x1, ll x2, ll y1, ll y2) {
+ ll b = x2 - x1, h = y2 - y1;
+ if (b < 0 && h < 0) {
+ b *= -1;
+ h *= -1;
+ }
+
+ ll ch = b * y1 - h * x1, ct = b;
+ *l = { h, b, ch, ct };
+}
+
+bool check(ll x1, ll x2, ll x3, ll y1, ll y2, ll y3) {
+ if ((((x3 >= x1 && x3 <= x2) && (y3 >= y1 && y3 <= y2))|| ((x3 <= x1 && x3 >= x2) && (y3 <= y1 && y3 >= y2))))
+ return true;
+ return false;
+}
+
+bool is_cross(ll x1, ll x2, ll x3, ll x4, ll y1, ll y2, ll y3, ll y4) {
+ ll f1 = ((y3 - y1) * (x2 - x1)) - ((x3 - x1) * (y2 - y1)), f2 = ((y4 - y1) * (x2 - x1)) - ((x4 - x1) * (y2 - y1));
+ if ((f1 <= 0 && f2 >= 0) || (f1 >= 0 && f2 <= 0))
+ return true;
+ return false;
+}
+
+bool solve() {
+ ll x1, x2, x3, x4, y1, y2, y3, y4;
+ cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> x4 >> y4;
+
+ if (x1 > x2) {
+ swap(&x1, &x2);
+ swap(&y1, &y2);
+ }
+ if (x3 > x4) {
+ swap(&x3, &x4);
+ swap(&y3, &y4);
+ }
+
+ line l1, l2;
+ makeLine(&l1, x1, x2, y1, y2);
+ makeLine(&l2, x3, x4, y3, y4);
+
+ if (l1.h * l2.t == l1.t * l2.h) {
+ if (l1.ch * l2.ct == l1.ct * l2.ch && (check(x1, x2, x3, y1, y2, y3) || check(x1, x2, x4, y1, y2, y4) || check(x3, x4, x1, y3, y4, y1) || check(x3, x4, x2, y3, y4, y2)))
+ return 1;
+ return 0;
+ }
+ else if (l1.t == 0 && l2.h == 0) {
+ if (x1 >= x3 && x1 <= x4 && ((y3 >= y1 && y3 <= y2) || (y3 <= y1 && y3 >= y2)))
+ return 1;
+ return 0;
+ }
+ else if (l2.t == 0 && l1.h == 0) {
+ if (x3 >= x1 && x3 <= x2 && ((y1 >= y3 && y1 <= y4) || (y1 <= y3 && y1 >= y4)))
+ return 1;
+ return 0;
+ }
+
+ if (is_cross(x1, x2, x3, x4, y1, y2, y3, y4) && is_cross(x3, x4, x1, x2, y3, y4, y1, y2))
+ return 1;
+ return 0;
+}
+
+int main() {
+ cout << solve();
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+
1. bottom-top 방식으로 품
+2. DP 구성 : (현재 깊이, 이전에 고른 색깔)칸에 현재 깊이에서의 최솟값 저장.
+3. DP 작동
+ a. 첫번째 집은 for문으로 하나씩 들어감.
+ b. 두번째 집부터 이전에 고른 색이 아닌 색으로 이동
+ c. 마지막집 + 1에 도착하면 0을 리턴
+ d. 마지막집은 0리턴 받은 것에 고른 색의 값 더함. 총 가능한 모든 색 값 중의 최솟값을 DP[deep][before]에 저장함
+ e. 하나씩 올라가면서 DP에 저장
+ f. DP에 저장돼있는게 있으면 바로 리턴
+4. 주의점
+ a. 첫번째 집이랑 마지막 집이랑 색깔이 달라야함 -> 첫번째 집의 색깔에 따라서도 상태가 달라짐
+ -> DP구성을 첫번째 집의 상태까지 고려하여 해야함
+ -> 하지만 나는 for문으로 첫번째 집은 하나씩 들어가고 나올때마다 DP를 초기화 해줬기에 괜찮음
+ b. 고를 수 있는 색의 조건문 구성을 조심해야함
+ before != 0 && (deep == numOfHouse -1 && first != 0)
+
+ -> 이 조건문은, deep이 마지막집이 아닐때 뒷 조건문에서 false가 나와 집이 2개가 아닌이상에야 아예 작동을 안함.
+
+ 따라서 밑처럼 짜줘야한다.
+ before != 0 && (deep != numOfHouse -1 || first != 0)
+ 뒷 조건문은, 마지막이 아닐 경우 true를 반환하고, 마지막집일때는 first가 0이 아니여야만 true가 나옴
+ -> 잘 만족한다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+
#include <iostream>
+#include <cstring>
+#define MAX_HOUSE 1001
+#define INFINITE 2000000000
+
+using namespace std;
+
+int numOfHouse, house[MAX_HOUSE][3], DP[MAX_HOUSE][3], first;
+
+int getMinCost(int before, int deep);
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+
+ cin >> numOfHouse;
+ for (int i = 0; i < numOfHouse; i++) {
+ cin >> house[i][0] >> house[i][1] >> house[i][2];
+ }
+
+ int minCost = INFINITE;
+ for (int i = 0; i < 3; i++) {
+ first = i;
+ minCost = min(getMinCost(i, 1) + house[0][i], minCost);
+ memset(DP, 0, sizeof(DP));
+ }
+ cout << minCost;
+}
+
+int getMinCost(int before, int deep) {
+ if (deep == numOfHouse) {
+ return 0;
+ }
+ if (DP[deep][before] != 0) {
+ return DP[deep][before];
+ }
+
+
+
+ int a= INFINITE, b = INFINITE, c = INFINITE;
+ if (before != 0 && (deep != numOfHouse -1 || first != 0))
+ a = getMinCost(0, deep + 1) + house[deep][0];
+ if (before != 1 && (deep != numOfHouse - 1 || first != 1))
+ b = getMinCost(1, deep + 1) + house[deep][1];
+ if (before != 2 && (deep != numOfHouse - 1 || first != 2))
+ c = getMinCost(2, deep + 1) + house[deep][2];
+
+ int tempMin = min(min(a, b), c);
+
+ return DP[deep][before] = tempMin;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+
#include <iostream>
+
+using namespace std;
+
+int N;
+
+int main() {
+ cin >> N;
+
+ long long result = 0;
+
+ int d = 1, count = 0;
+ while (N / d != 0) { // 1~9 : 1 / 10~99 : 2 / 100~999 : 3
+ d *= 10;
+ count++;
+ }
+
+ while (count != 0) {
+ d /= 10;
+ result += count * (N - d + 1);
+
+ N = d - 1;
+ count--;
+ }
+
+ cout << result;
+}
+
Comments powered by Disqus.
1
+
1. 다익스트라
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+
#include <iostream>
+#include <queue>
+#include <vector>
+#define INF 2000000000;
+using namespace std;
+
+int V, E, s, length[20001];
+vector<pair<int, int>> node[20001];
+priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;
+bool check[20001];
+
+void dijkstra();
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cout.tie(0);
+ cin >> V >> E >> s;
+
+ for (int i = 0; i < E; i++) {
+ int a, b, c;
+ cin >> a >> b >> c;
+ node[a].push_back({ b, c });
+ }
+
+ for (int i = 1; i <= V; i++)
+ length[i] = INF;
+
+ length[s] = 0;
+
+ dijkstra();
+
+ for (int i = 1; i <= V; i++) {
+ if (length[i] != 2000000000)
+ cout << length[i] << '\n';
+ else
+ cout << "INF\n";
+ }
+}
+
+void dijkstra() {
+ q.push({ 0, s });
+
+ while (!q.empty()) {
+ int d = q.top().first, cur = q.top().second;
+ q.pop();
+
+ if (d > length[cur] || check[cur])
+ continue;
+
+ for (int i = 0; i < node[cur].size(); i++) {
+ int next = node[cur][i].first, nd = d + node[cur][i].second;
+ if (nd < length[next]) {
+ q.push({ nd, next });
+ length[next] = nd;
+ }
+ }
+ check[cur] = true;
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+
#include <iostream>
+#define MAX_WIDTH 21
+
+using namespace std;
+
+int map[MAX_WIDTH][MAX_WIDTH];
+int width;
+
+int minDifference();
+int getMin(int d1, int d2, int x, int y);
+
+int main() {
+ cin >> width;
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++)
+ cin >> map[i][j];
+
+ cout << minDifference();
+}
+
+int minDifference() {
+ int minDifference = 2000000000;
+ for (int d1 = 1; d1 < width - 1; d1++) {
+ for (int d2 = 1; d2 < width - 1; d2++) {
+ int last = width - (d1 + d2);
+ for (int x = 0; x < last; x++) {
+ for (int y = d1; y < (width - d2); y++) {
+ int temp = getMin(d1, d2, x, y);
+ if (temp < minDifference) {
+ minDifference = temp;
+ }
+ }
+ }
+ }
+ }
+
+ return minDifference;
+}
+
+int getMin(int d1, int d2, int x, int y) {
+ bool tempMap[MAX_WIDTH][MAX_WIDTH] = { 0, };
+
+ int t2 = y;
+ for (int t1 = x; t1 <= (x + d1); t1++) {
+ tempMap[t2][t1] = true;
+ t2--;
+ }
+ t2 = y;
+ for (int t1 = x; t1 <= (x + d2); t1++) {
+ tempMap[t2][t1] = true;
+ t2++;
+ }
+ t2 = y - d1;
+ for (int t1 = x + d1; t1 <= (x + d1 + d2); t1++) {
+ tempMap[t2][t1] = true;
+ t2++;
+ }
+ t2 = y + d2;
+ for (int t1 = x + d2; t1 <= (x + d2 + d1); t1++) {
+ tempMap[t2][t1] = true;
+ t2--;
+ }
+
+ int people[5] = { 0, };
+ for (int i = 0; i < y; i++) {
+ for (int j = 0; j <= (x+d1); j++) {
+ if (tempMap[i][j]) {
+ tempMap[i][j] = false;
+ break;
+ }
+ people[0] += map[i][j];
+ tempMap[i][j] = true;
+ }
+ }
+ bool checkRow = true;
+ for (int i = 0; i <= (y + d2 - d1); i++) {
+ bool check = false;
+ if (checkRow)
+ check = true;
+ for (int j = (x + d1 + 1); j < width; j++) {
+ if (j == (x + d1 + 1) && tempMap[i][j]) {
+ checkRow = false;
+ }
+
+ if (tempMap[i][j]) {
+ tempMap[i][j] = false;
+ check = true;
+ }
+ else if (check) {
+ people[1] += map[i][j];
+ tempMap[i][j] = true;
+ }
+ }
+ }
+ for (int i = y; i < width; i++) {
+ for (int j = 0; j < (x + d2); j++) {
+ if (tempMap[i][j]) {
+ tempMap[i][j] = false;
+ break;
+ }
+ people[2] += map[i][j];
+ tempMap[i][j] = true;
+ }
+ }
+ checkRow = false;
+ for (int i = (y + d2 - d1 + 1); i < width; i++) {
+ bool check = false;
+ if (checkRow)
+ check = true;
+ for (int j = (x + d2); j < width; j++) {
+ if (j == (x + d2) && tempMap[i][j]) {
+ checkRow = true;
+ }
+
+ if (tempMap[i][j]) {
+ check = true;
+ tempMap[i][j] = false;
+ }
+ else if (check) {
+ people[3] += map[i][j];
+ tempMap[i][j] = true;
+ }
+ }
+ }
+ for (int i = 0; i < width; i++) {
+ for (int j = 0; j < width; j++) {
+ if (!tempMap[i][j])
+ people[4] += map[i][j];
+ }
+ }
+
+ int minN = 200000000;
+ int maxN = 0;
+ for (int i = 0; i < 5; i++) {
+ if (people[i] < minN)
+ minN = people[i];
+ if (people[i] > maxN)
+ maxN = people[i];
+ }
+ return maxN - minN;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+
#include <iostream>
+#include <cstring>
+#include <vector>
+#define MAX_BOARD 50
+#define MAX_TURN 50
+
+using namespace std;
+
+int board[MAX_BOARD][MAX_BOARD];
+int numOfTurn, numOfBoard, numOfNum;
+int turn[MAX_TURN][3]; //xi, 0 or 1, ki
+
+int getSumOfBoardNum();
+void rotateBoard(vector<int> rotate, int direction, int ki);
+void updateBoard();
+
+int main() {
+ cin >> numOfBoard >> numOfNum >> numOfTurn;
+ for (int i = 0; i < numOfBoard; i++) {
+ for (int j = 0; j < numOfNum; j++) {
+ cin >> board[i][j];
+ }
+ }
+ for (int i = 0; i < numOfTurn; i++) {
+ cin >> turn[i][0] >> turn[i][1] >> turn[i][2];
+ }
+
+ cout << getSumOfBoardNum();
+}
+
+int getSumOfBoardNum() {
+ for (int current = 0; current < numOfTurn; current++) {
+ int xi = turn[current][0];
+ vector<int> rotate;
+ for (int i = 0; i < numOfBoard; i++) {
+ if (((i + 1) % xi) == 0)
+ rotate.push_back(i);
+ }
+
+ rotateBoard(rotate, turn[current][1], turn[current][2]);
+ updateBoard();
+ }
+
+ int sum = 0;
+ for (int i = 0; i < numOfBoard; i++)
+ for (int j = 0; j < numOfNum; j++)
+ sum += board[i][j];
+ return sum;
+}
+
+void rotateBoard(vector<int> rotate, int direction, int ki) {
+ if (direction == 0) { //시계
+ for (int i = 0; i < rotate.size(); i++) {
+ for (int k = 0; k < ki; k++) {
+ int temp = board[rotate[i]][0];
+ for (int j = 1; j < numOfNum; j++) {
+ int temp2 = board[rotate[i]][j];
+ board[rotate[i]][j] = temp;
+ temp = temp2;
+ }
+ board[rotate[i]][0] = temp;
+ }
+ }
+ }
+ else if (direction == 1) {
+ for (int i = 0; i < rotate.size(); i++) {
+ for (int k = 0; k < ki; k++) {
+ int temp = board[rotate[i]][numOfNum-1];
+ for (int j = numOfNum-1; j >= 0; j--) {
+ int temp2 = board[rotate[i]][j];
+ board[rotate[i]][j] = temp;
+ temp = temp2;
+ }
+ board[rotate[i]][numOfNum-1] = temp;
+ }
+ }
+ }
+}
+
+void updateBoard() {
+ int tempBoard[MAX_BOARD][MAX_BOARD];
+ bool check = false;
+ for (int i = 0; i < numOfBoard; i++) {
+ if (board[i][0] == board[i][1] || board[i][0] == board[i][numOfNum - 1] ||
+ (i != 0 && board[i][0] == board[i - 1][0]) || (i != (numOfBoard - 1) && board[i][0] == board[i + 1][0])) {
+ tempBoard[i][0] = 0;
+ if(board[i][0] != 0) check = true;
+ }
+ else
+ tempBoard[i][0] = board[i][0];
+
+ for (int j = 1; j < numOfNum - 1; j++) {
+ if (board[i][j] == board[i][j + 1] || board[i][j] == board[i][j - 1] ||
+ (i != 0 && board[i][j] == board[i - 1][j]) || (i != (numOfBoard - 1) && board[i][j] == board[i + 1][j])) {
+ tempBoard[i][j] = 0;
+ if(board[i][j] != 0) check = true;
+ }
+ else
+ tempBoard[i][j] = board[i][j];
+ }
+
+ if (board[i][numOfNum - 1] == board[i][0] || board[i][numOfNum - 1] == board[i][numOfNum - 2] ||
+ (i != 0 && board[i][numOfNum - 1] == board[i - 1][numOfNum - 1]) || (i != (numOfBoard - 1) && board[i][numOfNum - 1] == board[i + 1][numOfNum - 1])) {
+ tempBoard[i][numOfNum - 1] = 0;
+ if(board[i][numOfNum - 1] != 0) check = true;
+ }
+ else
+ tempBoard[i][numOfNum - 1] = board[i][numOfNum - 1];
+ }
+ if (!check) {
+ int sum = 0;
+ int count = 0;
+ for (int i = 0; i < numOfBoard; i++) {
+ for (int j = 0; j < numOfNum; j++) {
+ if (tempBoard[i][j] != 0) {
+ sum += tempBoard[i][j];
+ count++;
+ }
+ }
+ }
+ if (count != 0) {
+ float ave = (float)sum / (float)count;
+ for(int i = 0; i<numOfBoard; i++) {
+ for (int j = 0; j < numOfNum; j++) {
+ if (tempBoard[i][j] != 0) {
+ if (tempBoard[i][j] < ave)
+ tempBoard[i][j]++;
+ else if (tempBoard[i][j] > ave)
+ tempBoard[i][j]--;
+ }
+ }
+ }
+ }
+ }
+ memcpy(board, tempBoard, sizeof(tempBoard));
+
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+
#include <iostream>
+#include <vector>
+using namespace std;
+
+typedef struct Map {
+ int score;
+ int next;
+ int blueNext;
+} Map;
+
+int dice[10];
+Map map[33] = { {0, 1, -1},{2, 2, -1}, {4, 3, -1}, {6,4 , -1}, {8, 5, -1},
+ {10, 6, 21}, {12, 7, -1}, {14, 8, -1}, {16, 9, -1}, {18, 10, -1},
+ {20, 11, 24 }, { 22, 12, -1 }, { 24, 13, -1 }, { 26, 14, -1 }, { 28, 15, -1 },
+ {30, 16, 26}, {32, 17, -1}, {34, 18, -1}, {36, 19, -1}, {38, 20, -1},
+ {40, 32, -1}, {13, 22, -1}, {16, 23, -1}, {19, 29, -1}, {22, 25, -1},
+ {24, 29, -1}, {28, 27, -1}, {27, 28, -1}, {26, 29, -1}, {25, 30, -1},
+ {30, 31, -1}, {35, 20, -1}, {0, -1, -1} };
+
+int getScore(int piece[4], int score, int deep);
+
+int main() {
+ for (int i = 0; i < 10; i++)
+ cin >> dice[i];
+
+ int temp[4] = { 0,0,0,0 };
+ cout << getScore(temp, 0, 0);
+
+}
+
+int getScore(int piece[4], int score, int deep) {
+ if (deep == 10)
+ return score;
+ int maxScore = 0;
+ for (int i = 0; i < 4; i++) {
+ int current = piece[i];
+ if (current >= 32)
+ continue;
+ int next = map[current].blueNext != -1 ? map[current].blueNext : map[current].next;
+ for (int j = 0; j < dice[deep]; j++) {
+ current = next;
+ if (current == 32)
+ break;
+ next = map[current].next;
+ }
+
+ int temp[4];
+ for (int j = 0; j < 4; j++) {
+ if (i != j)
+ temp[j] = piece[j];
+ else
+ temp[j] = current;
+ }
+
+ if (current == 32) {
+ int a = getScore(temp, score, deep + 1);
+ maxScore = a > maxScore ? a : maxScore;
+ continue;
+ }
+
+ bool check = false;
+ for (int j = 0; j < 4; j++) {
+ if (piece[j] == current)
+ check = true;
+ }
+ if (!check) {
+ int a = getScore(temp, score + map[current].score, deep + 1);
+ maxScore = a > maxScore ? a : maxScore;
+ }
+ }
+
+ return maxScore;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
1. 색깔을 저장한 map, 말을 저장하는 3차원 배열 맵(각 칸마다 4칸만 있으면 됨), 각 칸에 말이 몇개있는지 저장하는 인덱스맵
+2. 턴을 계속 진행함.
+ 각 말을 순차적으로 검사함. 이때 각 말들을 몇 번 검사했는지 저장하는 temp 배열을 생성.
+ 방향과 색깔에 맞춰 이동 시킴.
+ -두번째면 그냥 넘기고 다음 거 검사
+ -빨강이면 위에서부터 옆으로 이동시킴
+ -흰색이면 현재 말부터 옆으로 이동시킴
+ -파랑이나 맵 밖이면 방향을 바꾸고 현재말을 다시 검사함. 단, 이미 두번째 검사라면 방향은 변화시키지 않음.
+ -어느 순간이든, 4개가 되면 그때의 turn을 리턴.
+
1
+2
+
-파랑이나 맵 밖이면, 방향을 바꿀때, 두번째 검사라면 방향을 변화시키면 안된다.
+ -> 현재거 밑에 뭔가가 있을 수 있고, 그 밑에 있는게 방향이 현재 말과 다르다면 이동 후 크게 달라질 수 있기 때문에.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+
#include <iostream>
+#include <cstring>
+#include <vector>
+#define MAX_WIDTH 13
+
+using namespace std;
+
+typedef struct Piece {
+ int row;
+ int col;
+ int direction; // 1: 오 2 : 왼 3 : 위 4 : 아
+} Piece;
+
+Piece piece[11];
+int map[MAX_WIDTH][MAX_WIDTH];
+int pieceMap[MAX_WIDTH][MAX_WIDTH][4];
+int indexMap[MAX_WIDTH][MAX_WIDTH];
+int width, numOfPiece;
+
+int getLastTurnNum();
+
+int main() {
+ cin >> width >> numOfPiece;
+ for (int i = 0; i < width; i++) {
+ for (int j = 0; j < width; j++) {
+ cin >> map[i][j];
+ }
+ }
+ memset(pieceMap, -1, sizeof(pieceMap));
+ memset(indexMap, 0, sizeof(indexMap));
+ for (int i = 0; i < numOfPiece; i++) {
+ cin >> piece[i].row >> piece[i].col >> piece[i].direction;
+ piece[i].row--;
+ piece[i].col--;
+ pieceMap[piece[i].row][piece[i].col][indexMap[piece[i].row][piece[i].col]++] = i;
+ }
+
+ cout << getLastTurnNum();
+}
+
+int getLastTurnNum() {
+ for (int turn = 1; turn <= 1000; turn++) {
+ int temp[10];
+ memset(temp, 0, sizeof(temp));
+
+ for (int i = 0; i < numOfPiece; i++) {
+ if (temp[i] >= 2)
+ continue;
+ else
+ temp[i]++;
+
+ int row = piece[i].row;
+ int col = piece[i].col;
+ int stackIndex = 0;
+ int lastIndex = indexMap[row][col];
+ for (stackIndex; stackIndex < lastIndex; stackIndex++)
+ if (pieceMap[row][col][stackIndex] == i)
+ break;
+
+ if (piece[i].direction == 1) {
+ if (col >= (width - 1) || map[row][col + 1] == 2) {
+ if(temp[i] != 2)
+ piece[i].direction = 2;
+ i--;
+ }
+ else if (map[row][col + 1] == 1) {
+ for (int j = lastIndex - 1; j >= stackIndex; j--) {
+ pieceMap[row][col + 1][indexMap[row][col + 1]++] = pieceMap[row][col][j];
+ if (indexMap[row][col + 1] >= 4)
+ return turn;
+ piece[pieceMap[row][col][j]].col++;
+ pieceMap[row][col][j] = -1;
+ indexMap[row][col]--;
+ }
+ }
+ else if (map[row][col + 1] == 0) {
+ for (int j = stackIndex; j < lastIndex; j++) {
+ pieceMap[row][col + 1][indexMap[row][col + 1]++] = pieceMap[row][col][j];
+ if (indexMap[row][col + 1] >= 4)
+ return turn;
+ piece[pieceMap[row][col][j]].col++;
+ pieceMap[row][col][j] = -1;
+ indexMap[row][col]--;
+ }
+ }
+ }
+ else if (piece[i].direction == 2) {
+ if (col <= 0 || map[row][col - 1] == 2) {
+ if (temp[i] != 2)
+ piece[i].direction = 1;
+ i--;
+ }
+ else if (map[row][col - 1] == 1) {
+ for (int j = lastIndex - 1; j >= stackIndex; j--) {
+ pieceMap[row][col - 1][indexMap[row][col - 1]++] = pieceMap[row][col][j];
+ if (indexMap[row][col - 1] >= 4)
+ return turn;
+ piece[pieceMap[row][col][j]].col--;
+ pieceMap[row][col][j] = -1;
+ indexMap[row][col]--;
+ }
+ }
+ else if (map[row][col - 1] == 0) {
+ for (int j = stackIndex; j < lastIndex; j++) {
+ pieceMap[row][col - 1][indexMap[row][col - 1]++] = pieceMap[row][col][j];
+ if (indexMap[row][col - 1] >= 4)
+ return turn;
+ piece[pieceMap[row][col][j]].col--;
+ pieceMap[row][col][j] = -1;
+ indexMap[row][col]--;
+ }
+ }
+ }
+ else if (piece[i].direction == 3) {
+ if (row <= 0 || map[row-1][col] == 2) {
+ if (temp[i] != 2)
+ piece[i].direction = 4;
+ i--;
+ }
+ else if (map[row-1][col] == 1) {
+ for (int j = lastIndex - 1; j >= stackIndex; j--) {
+ pieceMap[row-1][col][indexMap[row-1][col]++] = pieceMap[row][col][j];
+ if (indexMap[row-1][col] >= 4)
+ return turn;
+ piece[pieceMap[row][col][j]].row--;
+ pieceMap[row][col][j] = -1;
+ indexMap[row][col]--;
+ }
+ }
+ else if (map[row-1][col] == 0) {
+ for (int j = stackIndex; j < lastIndex; j++) {
+ pieceMap[row - 1][col][indexMap[row - 1][col]++] = pieceMap[row][col][j];
+ if (indexMap[row - 1][col] >= 4)
+ return turn;
+ piece[pieceMap[row][col][j]].row--;
+ pieceMap[row][col][j] = -1;
+ indexMap[row][col]--;
+ }
+ }
+ }
+ else if(piece[i].direction == 4) {
+ if (row >= (width - 1) || map[row+1][col] == 2) {
+ if (temp[i] != 2)
+ piece[i].direction = 3;
+ i--;
+ }
+ else if (map[row+1][col] == 1) {
+ for (int j = lastIndex - 1; j >= stackIndex; j--) {
+ pieceMap[row + 1][col][indexMap[row + 1][col]++] = pieceMap[row][col][j];
+ if (indexMap[row + 1][col] >= 4)
+ return turn;
+ piece[pieceMap[row][col][j]].row++;
+ pieceMap[row][col][j] = -1;
+ indexMap[row][col]--;
+ }
+ }
+ else if (map[row+1][col] == 0) {
+ for (int j = stackIndex; j < lastIndex; j++) {
+ pieceMap[row + 1][col][indexMap[row + 1][col]++] = pieceMap[row][col][j];
+ if (indexMap[row + 1][col] >= 4)
+ return turn;
+ piece[pieceMap[row][col][j]].row++;
+ pieceMap[row][col][j] = -1;
+ indexMap[row][col]--;
+ }
+ }
+ }
+ }
+ }
+
+ return -1;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+
#include <iostream>
+#include <cstring>
+#define MAX_N 10
+
+using namespace std;
+
+int map[MAX_N][MAX_N];
+bool tempMap[MAX_N][MAX_N] = { 0, };
+int width, maxCount = 0;
+
+void findMaxBishop(int diagonal, int count);
+bool check(int row, int col);
+
+int main() {
+ cin >> width;
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++)
+ cin >> map[i][j];
+ findMaxBishop(0, 0);
+ cout << maxCount;
+}
+
+void findMaxBishop(int diagonal, int count) {
+ if (diagonal == 2 * width - 1) {
+ maxCount = maxCount > count ? maxCount : count;
+ return;
+ }
+ if ((2 * (width - 1)) - diagonal < maxCount - count)
+ return;
+
+ int row = 0, col = 0;
+ if (diagonal < width)
+ col = diagonal;
+ else {
+ row = diagonal - width + 1;
+ col = width-1;
+ }
+
+ for (; row < width && col >= 0; row++) {
+ if (map[row][col] == 1 && check(row - 1, col - 1)) {
+ tempMap[row][col] = true;
+ findMaxBishop(diagonal + 1, count + 1);
+ tempMap[row][col] = false;
+ }
+ col--;
+ }
+ findMaxBishop(diagonal + 1, count);
+}
+
+bool check(int row, int col) {
+ for (; row >= 0 && col >= 0; row--)
+ if (tempMap[row][col--])
+ return false;
+ return true;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+
1. 길이를 1부터 N까지 검사
+2. 한 길이를 검사할 때 다음을 실행
+ 1. 수열의 처음부터 길이만큼 더하고 sum에 저장, 첫번째를 따로 first에 저장. -> S를 넘는지 확인하고 안넘으면 2 실행
+ 2. 수열의 (길이)번째부터 검사. 위에서 구한 sum에서 first를 빼고, 현재의 수열원소를 집어넣음. -> 검사 -> 아니면 first에 두번째 저장
+3. 다 했는데도 안되면 0 반환
+-> 통과는 되지만, 아주 느림
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
1. length에 최대 길이를 저장, first = 0, last = 1, sum = num[0] 를 저장.
+2. first <= last 이고 last <= N일때 반복
+ 1. sum이 S보다 작을 때
+ sum += num[last++]
+ 2. sum이 S와 같을 때
+ length = min(length, last-first)
+ sum += num[last++]
+ 3. sum이 S보다 클 떄
+ length = min(length, last - first)
+ sum -= num[first++]
+
+3. 쉽게 얘기해서 검사할 길이의 처음과 끝을 표현하는 두 변수를 선언하고,
+ 끝을 하나씩 늘려가면서 sum을 구하되, sum이 S와 같아지면 길이를 저장하고 끝을 하나 더 늘리고, 커지면 길이를 저장하고 처음을 하나 줄이는 식으로 계속 반복.
+-> 훨씬 빠르다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+
#include <iostream>
+#define MAX_N 100000
+
+using namespace std;
+
+int num[MAX_N];
+int sumNum[MAX_N];
+int N, S;
+
+int shortestSequence(int start);
+
+int main() {
+ cin >> N >> S;
+ for (int i = 0; i < N; i++)
+ cin >> num[i];
+
+ int start = S / 10000;
+ cout << shortestSequence(start);
+}
+
+
+int shortestSequence(int start) {
+ sumNum[0] = num[0];
+ for (int i = 1; i < N; i++) {
+ sumNum[i] = sumNum[i - 1] + num[i];
+ }
+
+ for (int i = start; i <= N; i++) {
+ int first = num[0];
+ int sum = sumNum[i - 1];
+ if (sum >= S)
+ return i;
+
+ for (int j = i; j < N; j++) {
+ sum -= first;
+ sum += num[j];
+ if (sum >= S)
+ return i;
+ first = num[j - i + 1];
+ }
+ }
+ return 0;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+
#include <iostream>
+#include <list>
+#include <algorithm>
+using namespace std;
+
+int R, C, listIdx;
+char map[101][101];
+int offset[4][2] = { {-1, 0}, {0,1}, {1, 0}, {0, -1} };
+bool visit[101][101];
+pair<int, int> l[10010];
+
+void throwStick(int h, bool toRight);
+bool isTouchFloor(int h, int w);
+void downCluster();
+
+int main() {
+ string t;
+ cin >> R >> C;
+ for (int i = 0; i < R; i++) {
+ cin >> t;
+ for (int j = 0; j < C; j++) {
+ map[i][j] = t[j];
+ }
+ }
+
+ int n, input;
+ bool toRight = true;
+ cin >> n;
+ while (n--) {
+ cin >> input;
+ throwStick(input, toRight);
+ toRight = !toRight;
+ }
+ for (int i = 0; i < R; i++) {
+ for (int j = 0; j < C; j++)
+ cout << map[i][j];
+ cout << endl;
+ }
+}
+
+// 던지고 맞으면, 맞은 거부터 상하좌우 검색하여 클러스터 찾고 내리기.
+void throwStick(int h, bool toRight) {
+ bool hit = false;
+ int w = 0;
+ h = R - h;
+ if (toRight) {
+ for (int i = 0; i < C; i++)
+ if (map[h][i] == 'x') {
+ hit = true;
+ w = i;
+ break;
+ }
+ }
+ else {
+ for (int i = C - 1; i >= 0; i--)
+ if (map[h][i] == 'x') {
+ hit = true;
+ w = i;
+ break;
+ }
+ }
+
+ if (!hit)
+ return;
+
+ map[h][w] = '.';
+
+ for (int i = 0; i < 4; i++) {
+ int ho = h + offset[i][0], wo = w + offset[i][1];
+ if (ho >= 0 && ho < R && wo >= 0 && wo < C && map[ho][wo] == 'x') {
+ if (!isTouchFloor(ho, wo))
+ downCluster();
+ for (int i = 0; i < listIdx; i++)
+ visit[l[i].first][l[i].second] = false;
+ listIdx = 0;
+ }
+ }
+}
+
+
+bool isTouchFloor(int h, int w) {
+ int curIdx = 0;
+ listIdx = 0;
+ l[listIdx++] = { h,w };
+ visit[h][w] = true;
+
+ bool touch = false;
+
+ while (curIdx != listIdx) {
+ int h = l[curIdx].first, w=l[curIdx].second;
+ curIdx++;
+
+ if (h == R - 1) {
+ touch = true;
+ break;
+ }
+
+ for (int i = 0; i < 4; i++) {
+ int ho = h + offset[i][0], wo = w + offset[i][1];
+ if (!visit[ho][wo] && ho >= 0 && ho < R && wo >= 0 && wo < C && map[ho][wo] == 'x') {
+ l[listIdx++] = { ho, wo };
+ visit[ho][wo] = true;
+ }
+ }
+ }
+
+ if (touch)
+ return true;
+ return false;
+}
+
+//밑에 딴게 없는 것만 검사 -> 몇칸 내려가면 되는지 추산하기
+
+void downCluster() {
+ sort(&l[0], &l[listIdx]);
+ int minDistance = 2000000000;
+
+ for (int s = listIdx - 1; s >= 0; s--) {
+ if (map[l[s].first + 1][l[s].second] != 'x') {
+ int fromH = l[s].first + 1;
+ for (; fromH < R; fromH++) {
+ if (map[fromH][l[s].second] == 'x') {
+ if (visit[fromH][l[s].second])
+ fromH = 2000000000;
+ break;
+ }
+ }
+ minDistance = min(minDistance, fromH - l[s].first -1);
+
+ }
+ }
+ for (int s = listIdx - 1; s >= 0; s--) {
+ map[l[s].first + minDistance][l[s].second] = 'x';
+ map[l[s].first][l[s].second] = '.';
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+
#include <bits/stdc++.h>
+
+using namespace std;
+
+int tc, N, M, W, road[501][501];
+long long d[501];
+bool check[501][501];
+vector<int> connect[501];
+
+bool belmanford();
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cout.tie(0);
+
+ cin >> tc;
+
+ while (tc--) {
+ cin >> N >> M >> W;
+ int a, b, c;
+
+ for (int i = 1; i <= N; i++) {
+ d[i] = 2000000000000;
+ connect[i].clear();
+ }
+ d[1] = 0;
+ memset(check, 0, sizeof(check));
+
+ for (int i = 0; i < M; i++) {
+ cin >> a >> b >> c;
+ connect[a].push_back(b);
+ connect[b].push_back(a);
+ if (check[a][b])
+ road[a][b] = min(road[a][b], c);
+ else
+ road[a][b] = c;
+ road[b][a] = road[a][b];
+ check[a][b] = true;
+ check[b][a] = true;
+ }
+ for (int i = 0; i < W; i++) {
+ cin >> a >> b >> c;
+ connect[a].push_back(b);
+ road[a][b] = min(road[a][b], -c);
+ }
+ if (belmanford())
+ cout << "YES\n";
+ else
+ cout << "NO\n";
+ }
+}
+
+bool belmanford() {
+ for (int i = 0; i < N - 1; i++) {
+ for (int j = 1; j <= N; j++) {
+ for (int k = 0; k < connect[j].size(); k++)
+ d[connect[j][k]] = min(d[connect[j][k]], d[j] + road[j][connect[j][k]]);
+ }
+ }
+
+ for (int j = 1; j <= N; j++) {
+ for (int k = 0; k < connect[j].size(); k++)
+ if (d[connect[j][k]] > d[j] + road[j][connect[j][k]])
+ return true;
+ }
+ return false;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+
#include <iostream>
+typedef long long ll;
+using namespace std;
+
+int n, map[101][101];
+ll save[101][101];
+
+ll dp();
+
+int main() {
+ cin >> n;
+ for (int i = 0; i < n; i++)
+ for (int j = 0; j < n; j++)
+ cin >> map[i][j];
+ cout << dp();
+}
+
+ll dp() {
+ save[0][0] = 1;
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < n; j++) {
+ for (int ki = i - 1; ki >= 0; ki--)
+ if (map[ki][j] == i - ki)
+ save[i][j] += save[ki][j];
+ for (int kj = j - 1; kj >= 0; kj--)
+ if (map[i][kj] == j - kj)
+ save[i][j] += save[i][kj];
+ }
+ }
+
+ return save[n - 1][n - 1];
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+
#include <iostream>
+#include <string>
+#include <stack>
+
+using namespace std;
+
+string first;
+char result[101];
+int resultl;
+stack<char> s;
+
+void bind(char a, char b);
+
+int main() {
+ cin >> first;
+
+ bind('*', '/');
+ bind('+', '-');
+ for (int i = 0; i < first.size(); i++) {
+ if (first[i] == '(' || first[i] == '*' || first[i] == '+' || first[i] == '-' || first[i] == '/')
+ s.push(first[i]);
+ else if (first[i] == ')') {
+ while (s.top() != '(') {
+ cout << s.top();
+ s.pop();
+ }
+ s.pop();
+ }
+ else
+ cout << first[i];
+ }
+}
+
+void bind(char a, char b) {
+ for (int i = 0; i < first.size(); i++) {
+ int lput = -200, rput = -200, length = first.size(), lc = 0, rc = 0;
+ if (first[i] == a || first[i] == b) {
+ for (int j = i - 1; j >= 0; j--) {
+ if (first[j] == ')')
+ lc++;
+ else if (first[j] == '(' && lc > 0)
+ lc--;
+ if (lc == 0 && (first[j] == '(' || (first[j] >= 'A' && first[j] <= 'Z'))) {
+ lput = j - 1;
+ break;
+ }
+ }
+ for (int j = i + 1; j < length; j++) {
+ if (first[j] == '(')
+ rc++;
+ else if (first[j] == ')' && rc > 0)
+ rc--;
+ if (rc == 0 && (first[j] == ')' || (first[j] >= 'A' && first[j] <= 'Z'))) {
+ rput = j + 1;
+ break;
+ }
+ }
+
+ if (lput == -200 || rput == -200)
+ continue;
+
+ if (lput < 0)
+ first = "(" + first;
+ else
+ first = first.substr(0, lput + 1) + "(" + first.substr(lput + 1, length);
+
+ if (rput == length)
+ first = first + ")";
+ else
+ first = first.substr(0, rput + 1) + ")" + first.substr(rput + 1, first.size());
+ i++;
+ }
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+
1. 파란 맵과 초록 맵을 따로 만듬.(bool 형으로 해서 true면 블록이 있고, false면 없는 거로 취급)
+2. 매 실행마다 블록을 잘 놓고 -> 업데이트 하면서 점수 얻고 -> 연한부분 있으면 당긴 다음에 -> 다음 실행
+3. 실행마다 얻은 점수를 잘 기록해서 리턴함. 그리고 남은 블록 수를 세서 출력.
+4. 단, 모노미노도미노 1인 경우 - bool형이 아닌 int형으로 하고 0이면 블록 없음, 1 이상이면 각 블록을 나타내서, 옮길 때 어떤 블록이 있는지 어떤 것끼리 같은지 확인해야함
+5. 점수가 나서 내릴 때, 파란부분이면 점수 난 열부터 왼쪽으로 열순으로 옮기기 / 녹색부분이면 점수난 행부터 위쪽으로 행순으로 옮긴다.
+6. 이때, 1x1블록이나 파란부분이면 1x2블록, 녹색부분이면 2x1블록은 그냥 옮겨도 괜찮으나, 파란부분-2x1블록, 녹색부분-1x2블록은 잘 검사하여 옮긴다.
+7. 그리고 블록을 만날때까지 옮기고나서는 break문을 써서 더 검사하지 않도록 한다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+253
+254
+255
+256
+257
+258
+259
+260
+261
+262
+263
+264
+265
+266
+267
+268
+269
+270
+271
+272
+273
+
#include <iostream>
+#include <cstring>
+#define MAX_TILE 10000
+#define WIDTH 6
+#define HEIGHT 4
+
+using namespace std;
+
+typedef struct Tile {
+ int type;
+ int row;
+ int col;
+} Tile;
+
+int blueMap[HEIGHT][WIDTH];
+int greenMap[WIDTH][HEIGHT];
+int numOfTile;
+Tile tile[MAX_TILE];
+
+int getScore();
+void putTile(int index);
+void putTile(int row, int col, int map);
+int updateMap();
+int getRestTile();
+
+int main() {
+ cin >> numOfTile;
+ for (int i = 0; i < numOfTile; i++) {
+ cin >> tile[i].type >> tile[i].row >> tile[i].col;
+ }
+ memset(blueMap, 0, sizeof(blueMap));
+ memset(greenMap, 0, sizeof(blueMap));
+
+ cout << getScore() << endl;
+ cout << getRestTile() << endl;
+}
+
+int getScore() {
+ int score = 0;
+ for (int i = 0; i < numOfTile; i++) {
+ putTile(i);
+ score += updateMap();
+ }
+
+ return score;
+}
+
+void putTile(int index) {
+ if (tile[index].type == 1) {
+ for (int i = 2; i < WIDTH; i++) {
+ if (blueMap[tile[index].row][i] != 0) {
+ blueMap[tile[index].row][i - 1] = index+1;
+ break;
+ }
+ else if (i == WIDTH - 1)
+ blueMap[tile[index].row][i] = index+1;
+ }
+
+ for (int i = 2; i < WIDTH; i++) {
+ if (greenMap[i][tile[index].col] != 0) {
+ greenMap[i - 1][tile[index].col] = index+1;
+ break;
+ }
+ else if (i == WIDTH - 1)
+ greenMap[i][tile[index].col] = index+1;
+ }
+ }
+ else if (tile[index].type == 2) { //1x2
+ for (int i = 2; i < WIDTH; i++) {
+ if (blueMap[tile[index].row][i] != 0) {
+ blueMap[tile[index].row][i - 1] = index+1;
+ blueMap[tile[index].row][i - 2] = index+1;
+ break;
+ }
+ else if (i == WIDTH - 1) {
+ blueMap[tile[index].row][i] = index+1;
+ blueMap[tile[index].row][i - 1] = index+1;
+ }
+ }
+
+ for (int i = 2; i < WIDTH; i++) {
+ if (greenMap[i][tile[index].col] != 0|| greenMap[i][tile[index].col + 1] != 0) {
+ greenMap[i - 1][tile[index].col] = index+1;
+ greenMap[i - 1][tile[index].col + 1] = index+1;
+ break;
+ }
+ else if (i == WIDTH - 1) {
+ greenMap[i][tile[index].col] = index+1;
+ greenMap[i][tile[index].col + 1] = index+1;
+ }
+ }
+ }
+ else if (tile[index].type == 3) { //2x1
+ for (int i = 2; i < WIDTH; i++) {
+ if (blueMap[tile[index].row][i] != 0 || blueMap[tile[index].row + 1][i] != 0) {
+ blueMap[tile[index].row][i - 1] = index+1;
+ blueMap[tile[index].row + 1][i - 1] = index+1;
+ break;
+ }
+ else if (i == WIDTH - 1) {
+ blueMap[tile[index].row][i] = index+1;
+ blueMap[tile[index].row + 1][i] = index+1;
+ }
+ }
+
+ for (int i = 2; i < WIDTH; i++) {
+ if (greenMap[i][tile[index].col] != 0) {
+ greenMap[i - 2][tile[index].col] = index+1;
+ greenMap[i - 1][tile[index].col] = index+1;
+ break;
+ }
+ else if (i == WIDTH - 1) {
+ greenMap[i][tile[index].col] = index+1;
+ greenMap[i - 1][tile[index].col] = index+1;
+ }
+ }
+
+ }
+}
+
+void putTile(int row, int col, int map) {
+ if (map == 0) {
+ int temp = blueMap[row][col];
+ blueMap[row][col] = 0;
+ blueMap[row + 1][col] = 0;
+ for (int i = col + 1; i < WIDTH; i++) {
+ if (blueMap[row][i] != 0 || blueMap[row + 1][i] != 0) {
+ blueMap[row][i - 1] = temp;
+ blueMap[row + 1][i - 1] = temp;
+ break;
+ }
+ else if (i == WIDTH - 1) {
+ blueMap[row][i] = temp;
+ blueMap[row + 1][i] = temp;
+ }
+ }
+ }
+ else if (map == 1) {
+ int temp = greenMap[row][col];
+ greenMap[row][col] = 0;
+ greenMap[row][col + 1] = 0;
+ for (int i = row + 1; i < WIDTH; i++) {
+ if (greenMap[i][col] != 0 || greenMap[i][col + 1] != 0) {
+ greenMap[i - 1][col] = temp;
+ greenMap[i - 1][col + 1] = temp;
+ break;
+ }
+ else if (i == WIDTH - 1) {
+ greenMap[i][col] = temp;
+ greenMap[i][col + 1] = temp;
+ }
+ }
+
+ }
+}
+
+int updateMap() {
+ int score = 0;
+ //파랑
+ for (int i = 2; i < WIDTH; i++) {
+ int count = 0;
+ for (int j = 0; j < HEIGHT; j++) {
+ if (blueMap[j][i] != 0)
+ count++;
+ }
+ if (count == 4) {
+ score++;
+ for (int k = 0; k < 4; k++) blueMap[k][i] = 0;
+ //2*1 일때만 따로 처리해주면 됨
+ for (int j = i-1; j >=0; j--) {
+ for (int k = 0; k <= HEIGHT; k++) {
+ if (blueMap[k][j] != 0) {
+ if (k != HEIGHT - 1 && blueMap[k + 1][j] == blueMap[k][j])
+ putTile(k, j, 0);
+ else {
+ int temp = blueMap[k][j];
+ blueMap[k][j] = 0;
+ for (int tempCol = j + 1; tempCol < WIDTH; tempCol++) {
+ if (blueMap[k][tempCol] != 0) {
+ blueMap[k][tempCol - 1] = temp;
+ break;
+ }
+ else if (tempCol == WIDTH - 1)
+ blueMap[k][tempCol] = temp;
+ }
+ }
+ }
+ }
+ }
+ i = 2;
+ }
+ }
+ for (int i = 0; i < 2; i++) {
+ bool check = false;
+ for (int j = 0; j < HEIGHT; j++) {
+ if (blueMap[j][i])
+ check = true;
+ }
+ if (check) {
+ int temp[4] = { blueMap[0][i], blueMap[1][i], blueMap[2][i], blueMap[3][i] };
+ for (int k = 0; k < 4; k++) blueMap[k][i] = 0;
+ for (int col = i + 1; col < WIDTH; col++) {
+ int temp2[4] = { blueMap[0][col], blueMap[1][col], blueMap[2][col], blueMap[3][col] };
+ for (int k = 0; k < 4; k++) blueMap[k][col] = temp[k];
+ memcpy(temp, temp2, sizeof(temp));
+ }
+ }
+ }
+
+ //초록
+ for (int i = 2; i < WIDTH; i++) {
+ int count = 0;
+ for (int j = 0; j < HEIGHT; j++) {
+ if (greenMap[i][j] != 0)
+ count++;
+ }
+ if (count == 4) {
+ score++;
+ for (int k = 0; k < 4; k++) greenMap[i][k] = 0;
+ for (int j = i-1; j >= 0; j--) {
+ for (int k = 0; k < HEIGHT; k++) {
+ if (greenMap[j][k] != 0) {
+ if (k != HEIGHT - 1 && greenMap[j][k] == greenMap[j][k + 1]) {//옯기고, 다음 k에서 출동?
+ putTile(j, k, 1);
+ }
+ else {
+ int temp = greenMap[j][k];
+ greenMap[j][k] = 0;
+ for (int tempRow = j + 1; tempRow < WIDTH; tempRow++) {
+ if (greenMap[tempRow][k] != 0) {
+ greenMap[tempRow - 1][k] = temp;
+ break;
+ }
+ else if (tempRow == WIDTH - 1)
+ greenMap[tempRow][k] = temp;
+ }
+ }
+ }
+ }
+ }
+ i = 2;
+ }
+ }
+ for (int i = 0; i < 2; i++) {
+ bool check = false;
+ for (int j = 0; j < HEIGHT; j++) {
+ if (greenMap[i][j])
+ check = true;
+ }
+ if (check) {
+ int temp[4] = { greenMap[i][0], greenMap[i][1], greenMap[i][2], greenMap[i][3] };
+ for (int k = 0; k < 4; k++) greenMap[i][k] = 0;
+ for (int row = i + 1; row < WIDTH; row++) {
+ int temp2[4] = { greenMap[row][0], greenMap[row][1], greenMap[row][2], greenMap[row][3] };
+ for (int k = 0; k < 4; k++) greenMap[row][k] = temp[k];
+ memcpy(temp, temp2, sizeof(temp));
+ }
+ }
+ }
+
+ return score;
+}
+
+int getRestTile() {
+ int count = 0;
+ for (int i = 0; i < 24; i++) {
+ if (blueMap[i / WIDTH][i % WIDTH] != 0)
+ count++;
+ if (greenMap[i / HEIGHT][i % HEIGHT] != 0)
+ count++;
+ }
+ return count;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+
#include <iostream>
+#include <cstring>
+#define WIDTH 4
+#define SHARK 100
+#define BLANK -1
+
+using namespace std;
+
+typedef struct Fish {
+ int num;
+ int row;
+ int col;
+ int direction; // 위부터 반시계방향으로 1~8
+ bool isAlive;
+} Fish;
+
+int map[WIDTH][WIDTH];
+Fish fish[WIDTH*WIDTH+1];
+Fish shark = { 0,0,0,0 };
+
+int getSumOfFishNum();
+void eat(int row, int col);
+void moveFish();
+void changeFish(int index, int dstIndex, int row = 0, int col = 0);
+int getNextSharkRow() {
+ if (shark.direction == 1 || shark.direction == 2 || shark.direction == 8)
+ return -1;
+ else if (shark.direction == 4 || shark.direction == 5 || shark.direction == 6)
+ return 1;
+ else
+ return 0;
+}
+int getNextSharkCol() {
+ if (shark.direction == 2 || shark.direction == 3 || shark.direction == 4)
+ return -1;
+ else if (shark.direction == 6 || shark.direction == 7 || shark.direction == 8)
+ return 1;
+ else
+ return 0;
+}
+
+int main() {
+ for (int i = 0; i < WIDTH; i++) {
+ for (int j = 0; j < WIDTH; j++) {
+ Fish temp = { 0, i, j, 0, true};
+ cin >> temp.num >> temp.direction;
+ fish[temp.num] = temp;
+ map[i][j] = temp.num;
+ }
+ }
+ /*
+ for (int i = 0; i < WIDTH; i++) {
+ for (int j = 0; j < WIDTH; j++)
+ cout << map[i][j] << " ";
+ cout << endl;
+ }
+ for (int i = 0; i < WIDTH * WIDTH + 1; i++) {
+ cout << fish[i].num << " " << fish[i].row << " " << fish[i].col << " " << fish[i].direction << " " << fish[i].isAlive << endl;
+ }
+ */
+
+ eat(0, 0);
+ cout << getSumOfFishNum();
+}
+
+int getSumOfFishNum() {
+ moveFish();
+
+ //상어 옮기기. 가능한 곳에 옮기고, 옮길때마다 값 저장 후 다시 초기화
+ int nextRow = getNextSharkRow();
+ int nextCol = getNextSharkCol();
+ Fish tempShark = shark;
+ Fish tempFish[WIDTH*WIDTH+1];
+ memcpy(tempFish, fish, sizeof(tempFish));
+ int tempMap[WIDTH][WIDTH];
+ memcpy(tempMap, map, sizeof(map));
+ int deep = 1, maxNum = 0;
+ while (true) {
+ int r = shark.row + deep*nextRow;
+ int c = shark.col + deep*nextCol;
+ if (r < 0 || r >= WIDTH || c < 0 || c >= WIDTH) {
+ break;
+ }
+ else if (map[r][c] == BLANK) {
+ deep++;
+ }
+ else {
+ eat(r, c);
+ int a = getSumOfFishNum();
+ maxNum = a > maxNum ? a : maxNum;
+ memcpy(map, tempMap, sizeof(map));
+ memcpy(fish, tempFish, sizeof(tempFish));
+ shark = tempShark;
+ deep++;
+ }
+ }
+ if (maxNum == 0)
+ return shark.num;
+ return maxNum;
+}
+
+void eat(int row, int col) {
+ int index = map[row][col];
+ map[shark.row][shark.col] = BLANK;
+ map[row][col] = SHARK;
+ shark.row = row;
+ shark.col = col;
+ shark.num += fish[index].num;
+ shark.direction = fish[index].direction;
+ fish[index].isAlive = false;
+}
+
+void moveFish() {
+ int count = 0;
+ for (int i = 1; i <= 16; i++) {
+ if (!fish[i].isAlive)
+ continue;
+
+ if (fish[i].direction == 1 && fish[i].row != 0 && map[fish[i].row - 1][fish[i].col] != SHARK) {
+ changeFish(i, map[fish[i].row - 1][fish[i].col], fish[i].row-1, fish[i].col);
+ count = 0;
+ }
+ else if (fish[i].direction == 2 && (fish[i].row != 0 && fish[i].col != 0) && map[fish[i].row - 1][fish[i].col - 1] != SHARK) {
+ changeFish(i, map[fish[i].row - 1][fish[i].col - 1], fish[i].row - 1, fish[i].col-1);
+ count = 0;
+ }
+ else if (fish[i].direction == 3 && fish[i].col != 0 && map[fish[i].row][fish[i].col - 1] != SHARK) {
+ changeFish(i, map[fish[i].row][fish[i].col - 1], fish[i].row, fish[i].col-1);
+ count = 0;
+ }
+ else if (fish[i].direction == 4 && (fish[i].row != 3 && fish[i].col != 0) && map[fish[i].row + 1][fish[i].col - 1] != SHARK) {
+ changeFish(i, map[fish[i].row + 1][fish[i].col - 1], fish[i].row + 1, fish[i].col-1);
+ count = 0;
+ }
+ else if (fish[i].direction == 5 && fish[i].row != 3 && map[fish[i].row + 1][fish[i].col] != SHARK) {
+ changeFish(i, map[fish[i].row + 1][fish[i].col], fish[i].row + 1, fish[i].col);
+ count = 0;
+ }
+ else if (fish[i].direction == 6 && (fish[i].row != 3 && fish[i].col != 3)&& map[fish[i].row + 1][fish[i].col +1] != SHARK) {
+ changeFish(i, map[fish[i].row + 1][fish[i].col +1], fish[i].row + 1, fish[i].col+1);
+ count = 0;
+ }
+ else if (fish[i].direction == 7 && fish[i].col != 3 && map[fish[i].row][fish[i].col+1] != SHARK) {
+ changeFish(i, map[fish[i].row][fish[i].col+1], fish[i].row, fish[i].col+1);
+ count = 0;
+ }
+ else if (fish[i].direction == 8 && (fish[i].row != 0 && fish[i].col != 3) && map[fish[i].row - 1][fish[i].col+1] != SHARK) {
+ changeFish(i, map[fish[i].row - 1][fish[i].col+1], fish[i].row - 1, fish[i].col+1);
+ count = 0;
+ }
+ else {
+ if (fish[i].direction != 8)
+ fish[i].direction++;
+ else
+ fish[i].direction = 1;
+ count++;
+ if (count >= 8)
+ continue;
+ i--;
+ }
+ }
+}
+
+void changeFish(int index, int dstIndex, int row, int col) {
+ if (dstIndex == BLANK) {
+ map[fish[index].row][fish[index].col] = BLANK;
+ map[row][col] = index;
+ fish[index].row = row;
+ fish[index].col = col;
+ }
+ else {
+ int tempRow = fish[dstIndex].row;
+ int tempCol = fish[dstIndex].col;
+ map[fish[dstIndex].row][fish[dstIndex].col] = index;
+ map[fish[index].row][fish[index].col] = dstIndex;
+ fish[dstIndex].row = fish[index].row;
+ fish[dstIndex].col = fish[index].col;
+ fish[index].row = tempRow;
+ fish[index].col = tempCol;
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+
#include <iostream>
+#include <list>
+#include <vector>
+#include <algorithm>
+#define MAX_WIDTH 20
+#define MAX_CUSTOMER 400
+#define CUSTOMER 123
+
+using namespace std;
+
+typedef struct Taxi {
+ int row;
+ int col;
+ int fuel;
+} Taxi;
+
+typedef struct Customer {
+ int currentRow;
+ int currentCol;
+ int dstRow;
+ int dstCol;
+ int distance;
+} Customer;
+
+typedef struct Candidate {
+ int row;
+ int col;
+ int fuel;
+ int index;
+ bool operator < (Candidate t) {
+ if (fuel < t.fuel)
+ return true;
+ else if (fuel > t.fuel)
+ return false;
+ else {
+ if (row < t.row)
+ return true;
+ else if (row > t.row)
+ return false;
+ else {
+ if (col < t.col)
+ return true;
+ else
+ return false;
+ }
+ }
+ }
+} Candidate;
+
+int map[MAX_WIDTH][MAX_WIDTH];
+int width, numOfCustomer;
+Taxi taxi;
+Customer customer[MAX_CUSTOMER];
+
+
+//nxn 크기 맵에 각 칸엔 벽 또는 빈칸
+//빈칸엔 승객과 택시가 올 수 있음
+//m 명을 태워야하고, m명은 각각 흩어져 있음
+//현재 택시위치에서 가장 가까운 승객을 태우고, 여러명이면 행이 작고, 열이 작은 승객 먼저
+//택시와 승객이 같은 위치면 0, 승객을 성공적으로 태워다주면, 태워다주느라 소모한 연료의 두배가 충전됨.
+//태우는 도중에 연료가 소진되면 그걸로 업무 종료. 도착과 동시에 소진은 괜찮다.
+//승객을 태우러 가는 도중에도 연료는 소모된다.
+
+int startWork();
+void getCustomerDistance();
+bool check();
+
+int main() {
+ cin >> width >> numOfCustomer >> taxi.fuel;
+ for (int i = 0; i < width; i++) {
+ for (int j = 0; j < width; j++)
+ cin >> map[i][j];
+ }
+ cin >> taxi.row >> taxi.col;
+ taxi.row--;
+ taxi.col--;
+ for (int i = 0; i < numOfCustomer; i++) {
+ cin >> customer[i].currentRow >> customer[i].currentCol >> customer[i].dstRow >> customer[i].dstCol;
+ customer[i].currentRow--;
+ customer[i].currentCol--;
+ customer[i].dstRow--;
+ customer[i].dstCol--;
+ customer[i].distance = -1;
+ map[customer[i].currentRow][customer[i].currentCol] = CUSTOMER + i;
+ }
+ getCustomerDistance();
+ if (check())
+ cout << startWork();
+ else
+ cout << -1;
+}
+
+void getCustomerDistance() {
+ for (int i = 0; i < numOfCustomer; i++) {
+ bool visit[MAX_WIDTH][MAX_WIDTH] = { 0, };
+ list<Taxi> q;
+ vector<int> candidate;
+ q.push_back({ customer[i].currentRow, customer[i].currentCol, 0 });
+ visit[customer[i].currentRow][customer[i].currentCol] = true;
+
+ while (!q.empty()) {
+ Taxi temp = q.front();
+ q.pop_front();
+
+ if (temp.row == customer[i].dstRow && temp.col == customer[i].dstCol) {
+ customer[i].distance = temp.fuel;
+ break;
+ }
+
+ if (temp.row != 0 && map[temp.row - 1][temp.col] != 1 && !visit[temp.row - 1][temp.col]) {
+ q.push_back({ temp.row - 1, temp.col, temp.fuel + 1 });
+ visit[temp.row - 1][temp.col] = true;
+ }
+ if (temp.row != width - 1 && map[temp.row + 1][temp.col] != 1 && !visit[temp.row + 1][temp.col]) {
+ q.push_back({ temp.row + 1, temp.col, temp.fuel + 1 });
+ visit[temp.row + 1][temp.col] = true;
+ }
+ if (temp.col != 0 && map[temp.row][temp.col - 1] != 1 && !visit[temp.row][temp.col - 1]) {
+ q.push_back({ temp.row, temp.col - 1, temp.fuel + 1 });
+ visit[temp.row][temp.col - 1] = true;
+ }
+ if (temp.col != width - 1 && map[temp.row][temp.col + 1] != 1 && !visit[temp.row][temp.col + 1]) {
+ q.push_back({ temp.row, temp.col + 1, temp.fuel + 1 });
+ visit[temp.row][temp.col + 1] = true;
+ }
+ }
+ }
+}
+
+bool check() {
+ for (int i = 0; i < numOfCustomer; i++)
+ if (customer[i].distance == -1)
+ return false;
+ return true;
+}
+
+int startWork() {
+ for (int i = 0; i < numOfCustomer; i++) {
+ //가장 가까운 승객 뽑아서 밑 변수에 저장.
+ Customer crtCustomer;
+ int crtCustomerDistance = 0;
+ if (map[taxi.row][taxi.col] >= CUSTOMER)
+ crtCustomer = customer[map[taxi.row][taxi.col] - CUSTOMER];
+ else {
+ bool visit[MAX_WIDTH][MAX_WIDTH] = { 0, };
+ visit[taxi.row][taxi.col] = true;
+ list<Taxi> q;
+ q.push_back({ taxi.row, taxi.col, 0 });
+ vector<Candidate> candidate;
+
+ while (!q.empty()) {
+ Taxi temp = q.front();
+ q.pop_front();
+
+ if(map[temp.row][temp.col] >= CUSTOMER)
+ candidate.push_back({ temp.row , temp.col, temp.fuel, map[temp.row][temp.col] - CUSTOMER });
+
+ if (temp.row != 0 && map[temp.row - 1][temp.col] != 1 && !visit[temp.row - 1][temp.col]) {
+ q.push_back({ temp.row - 1, temp.col, temp.fuel + 1 });
+ visit[temp.row - 1][temp.col] = true;
+ }
+ if (temp.row != width - 1 && map[temp.row + 1][temp.col] != 1 && !visit[temp.row + 1][temp.col]) {
+ q.push_back({ temp.row + 1, temp.col, temp.fuel + 1 });
+ visit[temp.row + 1][temp.col] = true;
+ }
+ if (temp.col != 0 && map[temp.row][temp.col - 1] != 1 && !visit[temp.row][temp.col - 1]) {
+ q.push_back({ temp.row, temp.col - 1, temp.fuel + 1 });
+ visit[temp.row][temp.col - 1] = true;
+ }
+ if (temp.col != width - 1 && map[temp.row][temp.col + 1] != 1 && !visit[temp.row][temp.col + 1]) {
+ q.push_back({ temp.row, temp.col + 1, temp.fuel + 1 });
+ visit[temp.row][temp.col + 1] = true;
+ }
+ }
+ if (candidate.size() == 0)
+ return -1;
+ sort(candidate.begin(), candidate.end());
+ crtCustomer = customer[candidate[0].index];
+ crtCustomerDistance = candidate[0].fuel;
+ }
+
+ //가장 가까운 승객을 데리고, 연료 충분한지, 충분하면 이동시킴
+ map[crtCustomer.currentRow][crtCustomer.currentCol] = 0;
+ int distance = crtCustomer.distance + crtCustomerDistance;
+ if (distance <= taxi.fuel) {
+ taxi.row = crtCustomer.dstRow;
+ taxi.col = crtCustomer.dstCol;
+ taxi.fuel -= distance;
+ taxi.fuel += (2*crtCustomer.distance);
+ }
+ else
+ return -1;
+ }
+
+ return taxi.fuel;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+
1. 문제 파악 : 그래프 상의 어떤 점들 집합이건 최소로 사이클을 이루는 집합이면 됨
+2. 그래프 관련 알고리즘
+ 1. 다익스트라 : 출발점에서 모든 정점까지의 거리 -> 해당 x
+ 2. 밸만포드 : 다익스트라와 마찬가지
+ 3. MST : 최소신장트리 -> 사이클은 감지할 수 있으나, 그것이 최소 사이클인지 모름 and 사이클만을 추출해내기 어려움
+ 4. 플로이드 워셜 : 모든 정점 사이의 거리
+ -> 자기 자신은 원래 0으로 표시하지만, 이 문제에선 INF로 한다면 사이클을 감지할 수 있고 또 최소 사이클도 감지하기 쉬움
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+
#include <bits/stdc++.h>
+#define INF 2000000000
+
+using namespace std;
+
+long long N, E, edges[401][401];
+
+int floid();
+
+int main() {
+ cin >> N >> E;
+ for (int i = 0; i < 401; i++)
+ for (int j = 0; j < 401; j++)
+ edges[i][j] = INF;
+ for (int i = 0; i < E; i++) {
+ int a, b, c;
+ cin >> a >> b >> c;
+ edges[a][b] = c;
+ }
+
+ cout << floid();
+}
+
+int floid() {
+ for (int i = 1; i <= N; i++)
+ for (int j = 1; j <= N; j++)
+ for (int k = 1; k <= N; k++)
+ if (edges[j][k] > edges[j][i] + edges[i][k])
+ edges[j][k] = edges[j][i] + edges[i][k];
+
+ int result = INF;
+ for (int i = 1; i <= N; i++)
+ result = result < edges[i][i] ? result : edges[i][i];
+
+ if (result == INF)
+ return -1;
+ return result;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+
1. 어떤 알파벳을 검사했는지 기록하는 건 check[26] 배열을 선언하고, 각 알파벳에서 65 값을 빼서 각 자리로 접근한다.('A' - 65 == 0)
+2. 인접한 칸을 검사하고, 가능하면 check 표시하고 인접한 칸으로 이동. 안되면 돌아와서(Back Tracking) 다른 인접한 칸 검사
+3. 갈 수 있는 인접한 칸이 없으면 그 칸이 마지막 칸이므로 maxCount 보다 크면 기록 -> 종료
+4. 만약 deep이 27에 다다르면, 알파벳 26개를 전부 검사한 것이므로, maxCount에 26기록후 종료
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+
#include <iostream>
+#include <cstring>
+#define MAX_WIDTH 20
+#define ASCII_A 65
+
+using namespace std;
+
+char map[MAX_WIDTH][MAX_WIDTH];
+bool check[26];
+int height, width, maxCount = 0;
+
+void DFS(int row, int col, int deep);
+
+int main() {
+ cin >> height >> width;
+ for (int i = 0; i < height; i++)
+ for (int j = 0; j < width; j++)
+ cin >> map[i][j];
+
+ check[map[0][0] - ASCII_A] = true;
+ DFS(0,0,1);
+ cout << maxCount;
+}
+
+void DFS(int row, int col, int deep) {
+ if (deep == 27) {
+ maxCount = deep-1;
+ return;
+ }
+
+ bool isEnd = true;
+ if (col < width - 1 && check[map[row][col + 1] - ASCII_A] == false) {
+ check[map[row][col + 1] - ASCII_A] = true;
+ DFS(row, col + 1, deep + 1);
+ check[map[row][col + 1] - ASCII_A] = false;
+ isEnd = false;
+ }
+ if (row < height - 1 && check[map[row + 1][col] - ASCII_A] == false) {
+ check[map[row + 1][col] - ASCII_A] = true;
+ DFS(row + 1, col, deep + 1);
+ check[map[row + 1][col] - ASCII_A] = false;
+ isEnd = false;
+ }
+ if (col > 0 && check[map[row][col - 1] - ASCII_A] == false) {
+ check[map[row][col - 1] - ASCII_A] = true;
+ DFS(row, col - 1, deep + 1);
+ check[map[row][col - 1] - ASCII_A] = false;
+ isEnd = false;
+ }
+ if (row > 0 && check[map[row - 1][col] - ASCII_A] == false) {
+ check[map[row - 1][col] - ASCII_A] = true;
+ DFS(row - 1, col, deep + 1);
+ check[map[row - 1][col] - ASCII_A] = false;
+ isEnd = false;
+ }
+
+ if (isEnd)
+ maxCount = maxCount > deep ? maxCount : deep;
+}
+
Comments powered by Disqus.
1
+2
+3
+
1. durability와 isThereRobot 변수로 구성된 Cell 구조체로 컨베이어 벨트를 만듦
+2. 무한 루프 안에서, 이동시키고 -> 내리는 위치 로봇빼고 -> 로봇이동 시키고(이동시 내구도 1감소) -> 내리는 위치 로봇빼고 -> 올리는 위치 로봇 올리고(내구도 1감소)
+ -> 내구도 0인 칸이 한계점에 닿으면 종료
+
1
+
1. 매번 내구도 0인 칸이 몇개인지 세기보단, 내구도를 깎는 칸에 깎고나서 내구도 0이면 count++를 하여, count가 한계점에 닿는지 확인하는 편이 훨씬 빠르게 할 수 있다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+
#include <iostream>
+#define MAX_WIDTH 100
+
+using namespace std;
+
+typedef struct Cell {
+ int durability;
+ bool robot;
+} Cell;
+
+Cell belt[2][MAX_WIDTH];
+int width, maxDurability;
+
+int getLastSecond();
+bool checkDurability();
+
+int main() {
+ cin >> width >> maxDurability;
+ for (int i = 0; i < width; i++) {
+ cin >> belt[0][i].durability;
+ belt[0][i].robot = false;
+ }
+ for (int i = width - 1; i >= 0; i--) {
+ cin >> belt[1][i].durability;
+ belt[1][i].robot = false;
+ }
+
+ cout << getLastSecond();
+}
+
+int getLastSecond() {
+ int second = 0;
+ int zero = 0;
+ while (true) {
+ second++;
+ //벨트 한칸 씩 이동
+ Cell temp = belt[0][0];
+ for (int i = 1; i < width; i++) {
+ Cell temp2 = belt[0][i];
+ belt[0][i] = temp;
+ temp = temp2;
+ }
+ for (int i = width - 1; i >= 0; i--) {
+ Cell temp2 = belt[1][i];
+ belt[1][i] = temp;
+ temp = temp2;
+ }
+ belt[0][0] = temp;
+ belt[0][width - 1].robot = false;
+
+ //로봇 이동
+ for (int i = width - 2; i >= 0; i--) {
+ if (belt[0][i].robot) {
+ if (!belt[0][i + 1].robot && belt[0][i + 1].durability > 0) {
+ belt[0][i + 1].robot = true;
+ belt[0][i + 1].durability--;
+ if (belt[0][i + 1].durability == 0)
+ zero++;
+ belt[0][i].robot = false;
+ }
+ }
+ }
+ belt[0][width - 1].robot = false;
+
+ //로봇 올리기
+ if (!belt[0][0].robot && belt[0][0].durability > 0) {
+ belt[0][0].durability--;
+ if (belt[0][0].durability == 0)
+ zero++;
+ belt[0][0].robot = true;
+ }
+
+ //체크
+ if (zero >= maxDurability)
+ break;
+ }
+
+ return second;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+
#include <iostream>
+#include <cstring>
+#include <vector>
+#define MAX_WIDTH 50
+
+using namespace std;
+
+typedef struct Fire {
+ int mass;
+ int direction; //0이 위, 시계방향으로 0~7
+ int speed;
+} Fire;
+typedef struct Cell {
+ vector<Fire> fire;
+} Cell;
+
+int width, numOfCommand, numOfFire;
+Cell map[MAX_WIDTH][MAX_WIDTH];
+Cell tempMap[MAX_WIDTH][MAX_WIDTH];
+
+int getRestFireBallMass();
+void moveFireBall();
+void splitFireBall();
+int nextRow(int row, int speed, bool isUp) {
+ int reminder = speed % width;
+ if (isUp) {
+ if (row < reminder)
+ return width - (reminder - row);
+ else
+ return row - reminder;
+ }
+ else {
+ if ((width - 1 - row) < reminder)
+ return reminder - width + row;
+ else
+ return row + reminder;
+ }
+}
+int nextCol(int col, int speed, bool isLeft) {
+ int reminder = speed % width;
+ if (isLeft) {
+ if (col < reminder)
+ return width - (reminder - col);
+ else
+ return col - reminder;
+ }
+ else {
+ if ((width - 1 - col) < reminder)
+ return reminder - width + col;
+ else
+ return col + reminder;
+ }
+}
+
+int main() {
+ cin >> width >> numOfFire >> numOfCommand;
+ for (int i = 0; i < numOfFire; i++) {
+ int row, col;
+ cin >> row >> col;
+ row--;
+ col--;
+ Fire temp;
+ cin >> temp.mass >> temp.speed >> temp.direction;
+ map[row][col].fire.push_back(temp);
+ }
+
+ cout << getRestFireBallMass();
+}
+
+int getRestFireBallMass() {
+ for (int i = 0; i < numOfCommand; i++) {
+ //이동
+ moveFireBall();
+ //분리
+ splitFireBall();
+ }
+
+ int mass = 0;
+ for (int i = 0; i < width; i++) {
+ for (int j = 0; j < width; j++) {
+ for (int k = 0; k < map[i][j].fire.size(); k++)
+ mass += map[i][j].fire[k].mass;
+ }
+ }
+
+ return mass;
+}
+
+void moveFireBall() {
+ for (int i = 0; i < width; i++) {
+ for (int j = 0; j < width; j++) {
+ tempMap[i][j].fire.clear();
+ }
+ }
+ for (int row = 0; row < width; row++) {
+ for (int col = 0; col < width; col++) {
+ for (int i = 0; i < map[row][col].fire.size(); i++) {
+ int direction = map[row][col].fire[i].direction;
+ int speed = map[row][col].fire[i].speed;
+ //스피드가 엄청 빠를때를 처리 안함
+ if (direction == 0)
+ tempMap[nextRow(row, speed, true)][col].fire.push_back(map[row][col].fire[i]);
+ else if (direction == 1)
+ tempMap[nextRow(row, speed, true)][nextCol(col, speed, false)].fire.push_back(map[row][col].fire[i]);
+ else if (direction == 2)
+ tempMap[row][nextCol(col, speed, false)].fire.push_back(map[row][col].fire[i]);
+ else if (direction == 3)
+ tempMap[nextRow(row, speed, false)][nextCol(col, speed, false)].fire.push_back(map[row][col].fire[i]);
+ else if (direction == 4)
+ tempMap[nextRow(row, speed, false)][col].fire.push_back(map[row][col].fire[i]);
+ else if (direction == 5)
+ tempMap[nextRow(row, speed, false)][nextCol(col, speed, true)].fire.push_back(map[row][col].fire[i]);
+ else if (direction == 6)
+ tempMap[row][nextCol(col, speed, true)].fire.push_back(map[row][col].fire[i]);
+ else if (direction == 7)
+ tempMap[nextRow(row, speed, true)][nextCol(col, speed, true)].fire.push_back(map[row][col].fire[i]);
+ }
+
+ }
+ }
+
+ for (int i = 0; i < width; i++) {
+ for (int j = 0; j < width; j++) {
+ map[i][j].fire.resize(tempMap[i][j].fire.size());
+ copy(tempMap[i][j].fire.begin(), tempMap[i][j].fire.end(), map[i][j].fire.begin());
+ }
+ }
+}
+void splitFireBall() {
+ for (int row = 0; row < width; row++) {
+ for (int col = 0; col < width; col++) {
+ if (map[row][col].fire.size() >= 2) {
+ int mass = 0, speed = 0;
+ bool isEven = true, isOdd = true;
+ for (int i = 0; i < map[row][col].fire.size(); i++) {
+ mass += map[row][col].fire[i].mass;
+ speed += map[row][col].fire[i].speed;
+ if (map[row][col].fire[i].direction % 2 == 0) {
+ isEven = isEven && true;
+ isOdd = isOdd && false;
+ }
+ else {
+ isEven = isEven && false;
+ isOdd = isOdd && true;
+ }
+ }
+ mass /= 5;
+ speed /= map[row][col].fire.size();
+ map[row][col].fire.clear();
+ if (mass != 0) {
+ if (isEven || isOdd) {
+ map[row][col].fire.push_back({ mass, 0, speed });
+ map[row][col].fire.push_back({ mass, 2, speed });
+ map[row][col].fire.push_back({ mass, 4, speed });
+ map[row][col].fire.push_back({ mass, 6, speed });
+ }
+ else {
+ map[row][col].fire.push_back({ mass, 1, speed });
+ map[row][col].fire.push_back({ mass, 3, speed });
+ map[row][col].fire.push_back({ mass, 5, speed });
+ map[row][col].fire.push_back({ mass, 7, speed });
+ }
+ }
+ }
+ }
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+
#include <iostream>
+#define MAX_WIDTH 499
+
+using namespace std;
+
+int map[MAX_WIDTH][MAX_WIDTH];
+bool visit[MAX_WIDTH][MAX_WIDTH];
+int width, amountOfSand = 0;
+int ten, seven, five, two, one, rest;
+
+int getLostAmountSand();
+void setNum(int row, int col) {
+ ten = (float)map[row][col] * 0.1;
+ seven = (float)map[row][col] * 0.07;
+ five = (float)map[row][col] * 0.05;
+ two = (float)map[row][col] * 0.02;
+ one = (float)map[row][col] * 0.01;
+ rest = map[row][col] - (2 * ten + 2 * seven + five + 2 * two + 2 * one);
+}
+void spreadLeftSand(int row, int col);
+void spreadRightSand(int row, int col);
+void spreadUpSand(int row, int col);
+void spreadDownSand(int row, int col);
+
+int main() {
+ cin >> width;
+ for (int i = 0; i < width; i++) {
+ for (int j = 0; j < width; j++) {
+ cin >> map[i][j];
+ if (map[i][j] != 0)
+ amountOfSand += map[i][j];
+ }
+ }
+
+ cout << getLostAmountSand();
+}
+
+int getLostAmountSand() {
+ visit[width / 2][width / 2] = true;
+ bool left = true, down = false, right = false, up = false;
+ int row = width / 2, col = width / 2;
+ for (int i = 1; i < width * width; i++) {
+ cout << row << " " << col << endl;
+
+ if (left) {
+ col--;
+ spreadLeftSand(row, col);
+ }
+ else if (down) {
+ row++;
+ spreadDownSand(row, col);
+ }
+ else if (right) {
+ col++;
+ spreadRightSand(row, col);
+ }
+ else if (up) {
+ row--;
+ spreadUpSand(row, col);
+ }
+ visit[row][col] = true;
+ if (left && !visit[row + 1][col]) {
+ left = false;
+ down = true;
+ }
+ else if (down && !visit[row][col + 1]) {
+ down = false;
+ right = true;
+ }
+ else if (right && !visit[row - 1][col]) {
+ right = false;
+ up = true;
+ }
+ else if (up && !visit[row][col - 1]) {
+ up = false;
+ left = true;
+ }
+ for (int j = 0; j < width; j++) {
+ for (int k = 0; k < width; k++) {
+ cout << map[j][k] << " ";
+ }
+ cout << endl;
+ }
+ cout << endl;
+ }
+
+ int sand = 0;
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++)
+ sand += map[i][j];
+ return amountOfSand - sand;
+}
+void spreadLeftSand(int row, int col) {
+ setNum(row, col);
+ if (row > 1)
+ map[row - 2][col] += two;
+ if (row > 0) {
+ map[row - 1][col] += seven;
+ map[row - 1][col + 1] += one;
+ }
+ if (row > 0 && col > 0)
+ map[row - 1][col - 1] += ten;
+ if (col > 1)
+ map[row][col - 2] += five;
+ if (row < width - 1 && col > 0)
+ map[row + 1][col - 1] += ten;
+ if (row < width - 1) {
+ map[row + 1][col] += seven;
+ map[row + 1][col + 1] += one;
+ }
+ if (row < width - 2)
+ map[row + 2][col] += two;
+ if (col > 0)
+ map[row][col - 1] += rest;
+ map[row][col] = 0;
+}
+void spreadRightSand(int row, int col) {
+ setNum(row, col);
+ if (row > 1)
+ map[row - 2][col] += two;
+ if (row > 0) {
+ map[row - 1][col] += seven;
+ map[row - 1][col - 1] += one;
+ }
+ if (row > 0 && col < width -1)
+ map[row - 1][col + 1] += ten;
+ if (col < width - 2)
+ map[row][col + 2] += five;
+ if (row < width - 1 && col < width-1)
+ map[row + 1][col + 1] += ten;
+ if (row < width - 1) {
+ map[row + 1][col] += seven;
+ map[row + 1][col - 1] += one;
+ }
+ if (row < width - 2)
+ map[row + 2][col] += two;
+ if (col < width - 1)
+ map[row][col + 1] += rest;
+ map[row][col] = 0;
+}
+void spreadUpSand(int row, int col) {
+ setNum(row, col);
+ if (col > 1)
+ map[row][col - 2] += two;
+ if (col > 0) {
+ map[row][col - 1] += seven;
+ map[row + 1][col - 1] += one;
+ }
+ if (row > 0 && col > 0)
+ map[row - 1][col - 1] += ten;
+ if (row > 1)
+ map[row - 2][col] += five;
+ if (row > 0 && col < width-1)
+ map[row - 1][col + 1] += ten;
+ if (col < width - 1) {
+ map[row][col + 1] += seven;
+ map[row + 1][col + 1] += one;
+ }
+ if (col < width - 2)
+ map[row][col + 2] += two;
+ if (row > 0)
+ map[row - 1][col] += rest;
+ map[row][col] = 0;
+}
+void spreadDownSand(int row, int col) {
+ setNum(row, col);
+ if (col > 1)
+ map[row][col - 2] += two;
+ if (col > 0) {
+ map[row][col - 1] += seven;
+ map[row - 1][col - 1] += one;
+ }
+ if (row < width - 1 && col < width - 1)
+ map[row + 1][col + 1] += ten;
+ if (row < width - 2)
+ map[row + 2][col] += five;
+ if (row < width - 1 && col > 0)
+ map[row + 1][col - 1] += ten;
+ if (col < width - 1) {
+ map[row][col + 1] += seven;
+ map[row - 1][col + 1] += one;
+ }
+ if (col < width - 2)
+ map[row][col + 2] += two;
+ if (row < width - 1)
+ map[row + 1][col] += rest;
+ map[row][col] = 0;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+
#include <iostream>
+#include <list>
+#include <cstring>
+#define MAX_WIDTH 64
+#define MAX_COMMAND 1000
+
+using namespace std;
+
+typedef struct Location {
+ int row;
+ int col;
+} Location;
+
+int map[MAX_WIDTH][MAX_WIDTH];
+int tempMap[MAX_WIDTH][MAX_WIDTH];
+int command[MAX_COMMAND];
+int width, numOfCommand;
+
+int getRestIce();
+int getBigestIce();
+void rotate(int row, int col, int length);
+
+int main() {
+ cin >> width >> numOfCommand;
+ int temp = 1;
+ for (int i = 0; i < width; i++)
+ temp *= 2;
+ width = temp;
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++)
+ cin >> map[i][j];
+ for (int i = 0; i < numOfCommand; i++)
+ cin >> command[i];
+
+ cout << getRestIce() << endl;
+ cout << getBigestIce();
+}
+
+int getRestIce() {
+ for (int i = 0; i < numOfCommand; i++) {
+ int cmd = command[i];
+ int temp = 1;
+ for (int i = 0; i < cmd; i++)
+ temp *= 2;
+ cmd = temp;
+ for (int row = 0; row < width; row += cmd)
+ for (int col = 0; col < width; col += cmd)
+ rotate(row, col, cmd);
+
+ memset(tempMap, 0, sizeof(tempMap));
+ //얼음 녹이기
+ for (int row = 0; row < width; row++) {
+ for (int col = 0; col < width; col++) {
+ if (map[row][col] > 0) {
+ int count = 0;
+ if (row > 0 && map[row - 1][col] > 0)
+ count++;
+ if (col > 0 && map[row][col - 1] > 0)
+ count++;
+ if (row < width - 1 && map[row + 1][col] >0)
+ count++;
+ if (col < width - 1 && map[row][col + 1] >0)
+ count++;
+ if (count < 3)
+ tempMap[row][col]--;
+ }
+ }
+ }
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++)
+ map[i][j] += tempMap[i][j];
+ }
+
+ int count = 0;
+ for (int i = 0; i < width; i++)
+ for (int j = 0; j < width; j++)
+ count += map[i][j];
+ return count;
+}
+
+void rotate(int row, int col, int length) {
+ for (int i = 0; i < length; i++)
+ for (int j = 0; j < length; j++)
+ tempMap[i][j] = map[row + i][col + j];
+
+ int tempRow = 0;
+ for (int i = length - 1; i >= 0; i--) {
+ for (int j = 0; j < length; j++) {
+ map[row + j][col + i] = tempMap[tempRow][j];
+ }
+ tempRow++;
+ }
+}
+
+int getBigestIce() {
+ bool visit[MAX_WIDTH][MAX_WIDTH] = { 0, };
+
+ int max = 0;
+ for (int i = 0; i < width; i++) {
+ for (int j = 0; j < width; j++) {
+ if (!visit[i][j] && map[i][j] > 0) {
+ list<Location> q;
+ q.push_back({ i,j });
+ int count = -1;
+ while (!q.empty()) {
+ Location temp = q.front();
+ q.pop_front();
+ count++;
+ if (temp.row > 0 && !visit[temp.row - 1][temp.col] && map[temp.row - 1][temp.col] > 0) {
+ q.push_back({ temp.row - 1, temp.col });
+ visit[temp.row - 1][temp.col] = true;
+ }
+ if (temp.col < width - 1 && !visit[temp.row][temp.col + 1] && map[temp.row][temp.col + 1] > 0) {
+ q.push_back({ temp.row, temp.col + 1 });
+ visit[temp.row][temp.col + 1] = true;
+ }
+ if (temp.row < width - 1 && !visit[temp.row + 1][temp.col] && map[temp.row + 1][temp.col] >0) {
+ q.push_back({ temp.row + 1, temp.col });
+ visit[temp.row + 1][temp.col] = true;
+ }
+ if (temp.col > 0 && !visit[temp.row][temp.col - 1] && map[temp.row][temp.col - 1] > 0) {
+ q.push_back({ temp.row, temp.col - 1 });
+ visit[temp.row][temp.col - 1] = true;
+ }
+ }
+ max = count > max ? count : max;
+ }
+ }
+ }
+
+ return max;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+
1. Task 구조체를 선언하여, time : 현재 task가 걸리는 시간을 저장 / timeTaken : 현재까지 오는데 선행으로 필요한 작업을 수행하면서 걸리는 시간 중 가장 긴 시간 저장
+ next : 다음으로 이어지는 작업들을 저장
+2. Task 구조체 배열을 앞에서부터 검사
+ -> 현재 task의 time과 timeTaken을 더해 temp에 저장.
+ -> 이어지는 작업들을 하나씩 검사 -> 이어지는 작업의 timeTaken보다 현재의 temp가 더 길면 temp를 저장
+ -> 검사가 끝나고 현재의 temp가 전체 temp중 가장 큰지 검사.(그냥 이어지는 작업 검사 끝나고 바로 maxTime 검사하면 됨)
+3. 번호와 선행관계가 뒤죽박죽이 아닌, 선행 작업은 무조건 현재번호보다 앞에 있으므로 그냥 for문으로 앞에서부터 검사하면 된다.
+
1
+
선행관계가 똑바로 돼있어서 아주편하게 코딩함
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+
#include <iostream>
+#include <vector>
+#define MAX_TASK 10000
+
+using namespace std;
+
+typedef struct Task {
+ int time;
+ int timeTaken;
+ vector<int> next;
+} Task;
+
+Task task[MAX_TASK];
+int numOfTask;
+
+int minTimeComplete();
+
+int main() {
+ cin >> numOfTask;
+ for (int i = 0; i < numOfTask; i++) {
+ cin >> task[i].time;
+ int numOfBefore;
+ cin >> numOfBefore;
+ for (int j = 0; j < numOfBefore; j++) {
+ int before;
+ cin >> before;
+ task[before-1].next.push_back(i);
+ }
+ }
+
+ cout << minTimeComplete();
+}
+
+int minTimeComplete() {
+ int maxTime = 0;
+ for (int i = 0; i < numOfTask; i++) {
+ int time = task[i].time + task[i].timeTaken;
+ for (int j = 0; j < task[i].next.size(); j++)
+ task[task[i].next[j]].timeTaken = task[task[i].next[j]].timeTaken > time ? task[task[i].next[j]].timeTaken : time;
+ maxTime = maxTime > time ? maxTime : time;
+ }
+ return maxTime;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+
#include <iostream>
+using namespace std;
+
+int n, ansMax = -1, ansMin = 2000000000, cur[2][3], tCur[2][3];
+
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+int max(int a, int b) {
+ return a > b ? a : b;
+}
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+
+ cin >> n;
+
+ int a, b, c;
+ cin >> cur[0][0] >> cur[0][1] >> cur[0][2];
+ for (int i = 0; i < 3; i++)
+ cur[1][i] = cur[0][i];
+
+ for (int i = 1; i < n; i++) {
+ cin >> a >> b >> c;
+ memcpy(tCur, cur, sizeof(cur));
+ cur[0][0] = max(tCur[0][0], tCur[0][1]) + a;
+ cur[0][1] = max(max(tCur[0][0], tCur[0][1]), tCur[0][2]) + b;
+ cur[0][2] = max(tCur[0][1], tCur[0][2]) + c;
+ cur[1][0] = min(tCur[1][0], tCur[1][1]) + a;
+ cur[1][1] = min(min(tCur[1][0], tCur[1][1]), tCur[1][2]) + b;
+ cur[1][2] = min(tCur[1][1], tCur[1][2]) + c;
+ }
+
+ for (int i = 0; i < 3; i++) {
+ ansMax = max(ansMax, cur[0][i]);
+ ansMin = min(ansMin, cur[1][i]);
+ }
+
+ cout << ansMax << " " << ansMin;
+}
+
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+
1. 비트마스크로 각 비트마다 하나의 도시라고 치고, 검사를 함.
+2. 방문하지 않았고, 갈수 있는 도시를 방문하는 식으로 끝까지감.
+ -> 끝까지 갔을 때 다시 돌아갈 수 있는 길이 있으면 그 값 반환, 없으면 IMPOSSIBLE 반환
+ -> 그 전 재귀로 돌아와서 가장 최솟값을 dp[current][bitMask] 에 저장함.
+3. 각 재귀 처음엔 돌아갈 수 마지막인지 확인하고, 이미 방문됐는지 확인한다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
1. 모든 출발점에 대해 실행할 필요는 없다.
+ -> 최소로 가능한 경로가 있을 때, 어디서 출발하든 그 값은 같기 때문에.
+2. 끝까지 갔을 때, 그때부터 값을 하나씩 더해오는 식으로 계산한다.
+ -> 값을 들고가면 INFINITY값과 충돌을 일으켜 잘못된 값이 반환될 수 있게됨.
+ -> 또 이렇게하면 자동으로 dp엔 이후 경로의 최솟값이 저장됨.
+3. 따라서 각 단계에서 최솟값이 INFINITY 값이라 하더라도 무조건 dp에 저장하자.
+ -> INFINITY값이 저장됐다는 거는, 현재상태에서 순회할 수 있는 길이 없다는 뜻이므로.
+4. INFINITY값을 지정할 땐, 현재 value값을 더해도 오버플로우가 발생하지 않도록 지정해둘 필요가 있다.
+5. 비트마스크로 각 도시가 이미 방문됐는지 확인하는 코드는 다음과 같다.
+ bitMask & (1 << i)
+ 이미 방문됐다면 이 값은 참을 가리키게 된다. ( 1011 & 0010 => 0010 => 참 / 1011 & 0100 => 0000 => 거짓)
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+
#include <iostream>
+#include <cstring>
+#define MAX_TOWN 16
+#define INFINITY 2000000123
+
+using namespace std;
+
+bool check[MAX_TOWN];
+int dp[MAX_TOWN][1 << MAX_TOWN];
+int map[MAX_TOWN][MAX_TOWN];
+int numOfTown, start, endBit;
+
+int getMinValue(int current, int bitMask);
+int min(int a, int b);
+
+int main() {
+ cin >> numOfTown;
+ for (int i = 0; i < numOfTown; i++)
+ for (int j = 0; j < numOfTown; j++) {
+ cin >> map[i][j];
+ }
+
+ endBit = (1 << numOfTown) - 1;
+ memset(dp, -1, sizeof(dp));
+ check[0] = true;
+ start = 0;
+ cout << getMinValue(0, 1);
+}
+
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+
+int getMinValue(int current,int bitMask) {
+ if (bitMask == endBit) {
+ if (map[current][start] == 0)
+ return INFINITY;
+ return map[current][start];
+ }
+ if (dp[current][bitMask] != -1)
+ return dp[current][bitMask];
+
+ int tempMin = INFINITY;
+ for (int i = 0; i < numOfTown; i++) {
+ if (!check[i] && map[current][i] != 0) {
+ check[i] = true;
+ tempMin = min(tempMin, map[current][i] + getMinValue(i, bitMask + (1 << i)));
+ check[i] = false;
+ }
+ }
+ return dp[current][bitMask] = tempMin;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
1. A배열은 그대로 두고, B 배열은 가능한 모든 누적합의 집합을 만들고, 그것을 정렬함
+ -> 이때 그냥 배열에 집어넣으면 최대 500500개의 원소가 있어서 메모리에서 박살나고, 찾는데 시간도 박살남
+ -> 난 set을 택했음
+ -> Pair 구조체를 선언해서, 누적합과 그 누적합이 나온 횟수를 저장함. 그리고 정렬과 비교연산자를 오버로딩하여 set에서 활용할 수 있게함
+ -> B의 누적합을 하나씩 만들어가며, set에 있는지 확인 -> 있으면 set에 이미 있는 Pair 객체의 count에 1을 더하고, 새로운 pair 객체에 넣음.
+ 그 다음, 원래 있던 Pair 객체를 지우고, 새로만든 Pair 객체를 집어넣음
+ -> 없으면 set에 구한 누적합과 count에 1을 넣어 만든 Pair 객체를 set에 삽입
+2. A배열의 누적합을 하나씩 만들어가며 B에 (T-누적합)을 가지는 Pair객체가 있는 지 확인
+ -> 있으면, 그 객체의 count를 전체 count에 더함
+ -> 없으면, 그냥 패스
+3. 전체 count는 int 범위를 넘을 수 있음
+
1
+2
+3
+4
+5
+
1. set에 구조체를 넣을때, 구조체 안에 오버로딩을 선언하는 경우 다음처럼 해야한다.
+ bool operator < (const Pair& p) const{
+ return value < p.value;
+ }
+ 안그럼 오류남
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+
#include <iostream>
+#include <set>
+#define MAX_N 1000
+
+using namespace std;
+
+typedef struct Pair {
+ int value;
+ int count;
+ bool operator < (const Pair& p) const{
+ return value < p.value;
+ }
+ bool operator == (const Pair& p) const{
+ return value == p.value;
+ }
+} Pair;
+
+int A[MAX_N];
+int B[MAX_N];
+set<Pair> Bset;
+int numOfA, numOfB, T;
+
+void makeBSet();
+long long getCount();
+
+int main() {
+ cin >> T >> numOfA;
+ for (int i = 0; i < numOfA; i++)
+ cin >> A[i];
+ cin >> numOfB;
+ for (int i = 0; i < numOfB; i++)
+ cin >> B[i];
+
+ makeBSet();
+ cout << getCount();
+}
+
+void makeBSet() {
+ for (int i = 0; i < numOfB; i++) {
+ int arraySum = 0;
+ for (int j = i; j < numOfB; j++) {
+ arraySum += B[j];
+ Pair temp = { arraySum, 1 };
+ set<Pair>::iterator iter = Bset.find(temp);
+ if (iter != Bset.end()) {
+ temp.count += iter->count;
+ Bset.erase(iter);
+ }
+ Bset.insert(temp);
+ }
+ }
+}
+
+long long getCount() {
+ long long count = 0;
+ for (int i = 0; i < numOfA; i++) {
+ int arraySum = 0;
+ for (int j = i; j < numOfA; j++) {
+ arraySum += A[j];
+ set<Pair>::iterator iter = Bset.find({ T - arraySum, 0 });
+ if (iter != Bset.end())
+ count += iter->count;
+ }
+ }
+ return count;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+
1. 자기 방향으로만 쭉 가다가 ! 를 만나면 자기방향 + 양옆으로 이동. 양옆으로 이동할 땐 거울을 설치하는 것이므로 거울 + 1.
+2. 이때 visit으로 이미왔던곳을 안가면, 다른 루트로 가는 빛은 중간에 끊기기에, visit에 빛이 그곳에 도착했을 때의 거울의 개수를 저장함.
+ 그리고 다음 빛이 그곳에 도착했을 때, 거울 개수가 적을 때만 이동 아니면 이동시키지 않는다.
+ ex)
+ if( .... && n + 1 < visit[r][c])
+ visit[r][c] = n + 1
+3. 이때 물론 거울을 사용하지 않고 그냥 자기 방향으로 가는 빛은 visit 검사하지 않는다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+
#include <bits/stdc++.h>
+
+using namespace std;
+
+char house[50][50];
+int DP[50][50];
+list<pair<pair<int, int>, pair<int, int>>> q;
+int N, r, c;
+
+int BFS();
+void nextRC(int* row, int* col, int way);
+
+int main() {
+ cin >> N;
+ for (int i = 0; i < N; i++)
+ for (int j = 0; j < N; j++) {
+ cin >> house[i][j];
+ if (house[i][j] == '#') {
+ r = i;
+ c = j;
+ }
+ DP[i][j] = 2000000000;
+ }
+
+ cout << BFS();
+}
+
+
+int BFS() {
+ int result = 2000000000;
+
+ if(r > 0 && house[r-1][c] != '*')
+ q.push_back({ {r, c}, {1, 0} });
+ if (r < N - 1 && house[r + 1][c] != '*')
+ q.push_back({ {r, c}, {3, 0} });
+ if (c < N - 1 && house[r][c + 1] != '*')
+ q.push_back({ {r, c}, {2, 0} });
+ if (c > 0 && house[r][c - 1] != '*')
+ q.push_back({ {r, c}, {4, 0} });
+
+ while (!q.empty()) {
+ int row = q.front().first.first, col = q.front().first.second, w = q.front().second.first, n = q.front().second.second;
+ q.pop_front();
+
+ if (house[row][col] == '#' && !(row == r && col == c)) {
+ result = result < n ? result : n;
+ continue;
+ }
+
+ nextRC(&row, &col, w);
+
+ //위로 갈수도, 느낌표일경우 좌우 가능
+
+ if ((row >= 0 && row <= N - 1) && (col >= 0 && col <= N - 1) && house[row][col] != '*') {
+ q.push_back({ {row, col}, {w, n} });
+ if (house[row][col] == '!' && n + 1 < DP[row][col]) {
+ DP[row][col] = n + 1;
+ if (w == 1 || w == 3) {
+ q.push_back({ {row, col}, {2, n + 1} });
+ q.push_back({ {row, col}, {4, n + 1} });
+ }
+ else {
+ q.push_back({ { row, col }, { 1, n + 1 } });
+ q.push_back({ { row, col }, { 3, n + 1 } });
+ }
+ }
+ }
+ }
+ return result;
+}
+
+void nextRC(int* row, int* col, int way) {
+ if (way == 1)
+ *row = (*row) - 1;
+ else if (way == 2)
+ *col = (*col) + 1;
+ else if (way == 3)
+ *row = (*row) + 1;
+ else if (way == 4)
+ *col = (*col) - 1;
+}
+
Comments powered by Disqus.
1
+
1. 사선정리 사용
+
1
+2
+
1. 최대 4000000000000이 나올 수 있으므로, int대신 long long, float은 쓰지말고 double로 통일 시킨다.
+2. double은 최대 15자리수를 표현가능하므로, 위 값도 충분히 들어갈 수 있다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+
#include <iostream>
+#include <cstdio>
+#include <cmath>
+#define MAX_POINT 10000
+
+using namespace std;
+
+typedef struct Point {
+ long long x;
+ long long y;
+} Point;
+
+Point point[MAX_POINT];
+int numOfPoint;
+
+double getAreaOfPolygon();
+
+int main() {
+ cin >> numOfPoint;
+ for (int i = 0; i < numOfPoint; i++)
+ cin >> point[i].x >> point[i].y;
+
+ printf("%.1f", getAreaOfPolygon());
+}
+
+double getAreaOfPolygon() {
+ double area = 0;
+
+ for (int i = 0; i < numOfPoint - 1; i++)
+ area += ((point[i].x * point[i + 1].y) - (point[i + 1].x * point[i].y));
+ area += (point[numOfPoint - 1].x * point[0].y) - (point[0].x * point[numOfPoint - 1].y);
+ area = area < 0 ? (-1) * area : area;
+ return area /= 2;
+}
+
+
Comments powered by Disqus.
1
+2
+
1. 문자판을 주어진 조건대로 순회하되, 결과값이 int 안이라는 걸보고 엄청 클 수도 잇다는 걸 예측 or 빙글빙글 계속 돌 수 있으니 DP가 잇어야겠다고 예측
+2. DP를 DP[r][c][d] 로 구현하되, -1로 초기화를 시키고, 0인것도 기록 -> 문자열이 아예 없을 수도 잇으니 0도 기록하여 더 빨리 DP가 가능해짐.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+
#include <bits/stdc++.h>
+
+using namespace std;
+
+int N, M, K, length, DP[101][101][81];
+char board[101][101], keyword[81];
+
+int generateDFS();
+int DFS(int, int, int);
+
+int main() {
+ cin >> N >> M >> K;
+ for (int i = 0; i < N; i++)
+ for (int j = 0; j < M; j++)
+ cin >> board[i][j];
+ string t;
+ cin >> t;
+ for (int i = 0; i < t.size(); i++)
+ keyword[i] = t[i];
+ length = t.size();
+
+ cout << generateDFS();
+}
+
+int generateDFS() {
+ int result = 0;
+ for (int i = 0; i < N; i++)
+ for (int j = 0; j < M; j++)
+ if (board[i][j] == keyword[0])
+ result += DFS(i, j, 0);
+ return result;
+}
+
+int DFS(int r, int c, int d) {
+ if (d == length - 1)
+ return 1;
+ if (DP[r][c][d] != 0)
+ return DP[r][c][d];
+
+ int result = 0;
+ for (int i = 1; i <= K; i++) {
+ if (r - i >= 0 && board[r - i][c] == keyword[d + 1])
+ result += DFS(r - i, c, d + 1);
+ if (r + i <= N - 1 && board[r + i][c] == keyword[d + 1])
+ result += DFS(r + i, c, d + 1);
+ if (c - i >= 0 && board[r][c - i] == keyword[d + 1])
+ result += DFS(r, c - i, d + 1);
+ if (c + i <= M - 1 && board[r][c + i] == keyword[d + 1])
+ result += DFS(r, c + i, d + 1);
+ }
+ return DP[r][c][d] = result;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+
1. 칸을 하나씩 탐방하면서, 0으로 기록돼있다면 수직, 수평, 3x3사각형을 검사하여 가능한 숫자를 하나씩 뽑아서 넣고 다음 칸 검사
+2. 만약 0으로 기록되지않은 칸으로 갔다면 다음칸으로 넘겨주되, 마지막 칸일 경우 스도쿠가 완성된 것이므로 true를 반환한다.
+3. 마찬가지로, 넣고 다음 칸으로 이동하는데, 마지막칸일 경우 스도쿠가 완성된 것이므로 true를 반환한다.
+4. 최소일때를 반환하는 것이므로 먼저 검사하는 칸을 왼쪽 위로하고, 1부터 검사하여 가능한 걸 넣으면 된다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+
1. 내가 구현한 건 맨처음에 가능한 숫자를 먼저 뽑고, 그 가능한 숫자만 가지고 검사하고 넣고 빼고 했다.
+2. 덕분에 시간이 좀 줄었지만, 체크하는데 매번 체크하여 시간이 좀 걸린 거 같다.
+3. 체크하는 걸 좀 더 간결히 하는 방법은 각 칸마다 3개의 9개의 int원소를 가지는 배열을 가진다.
+ ex) int checkMap[WIDTH][WIDTH][3][WIDTH+1];
+ 그리고 맨 처음에, 숫자를 넣었을 때마다 각각 수직, 수평, 3x3 사각형의 각 칸에 원래 가지고 있던 숫자 또는 넣은 숫자를 기록한다.
+ 수평일 경우 checmMap[row][col][0][value], 수직일 경우 checkMap[row][col][1][value], 사각형일경우 checkMap[row][col][2][value]
+ 이렇게하면 넣을 수 있는지 검사할 때 그냥 3개의 배열을 검사하여 있는지만 확인하면 되므로 더 간결해진다.
+ 또, 처음에 가능한 숫자를 먼저 뽑지 않아도 된다. 물론 false가 반환됐을 시, 다시 0으로 바꿔줄 필요도 있다.
+-> 내일 해보자.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+
#include <iostream>
+#include <cstring>
+#include <cmath>
+#define WIDTH 9
+
+using namespace std;
+
+int map[WIDTH][WIDTH];
+int possibleNum[WIDTH][WIDTH][WIDTH+1];
+
+void generatePossibleNum();
+bool solveSudoku(int row, int col);
+bool checkVertical(int row, int col, int value);
+bool checkHorizontal(int row, int col, int value);
+bool checkSquare(int row, int col, int value);
+
+int main() {
+ int input[WIDTH];
+ for (int i = 0; i < WIDTH; i++)
+ cin >> input[i];
+ for (int i = 0; i < WIDTH; i++) {
+ for (int j = WIDTH - 1; j >=0; j--) {
+ map[i][j] = input[i] % 10;
+ input[i] /= 10;
+ }
+ }
+ generatePossibleNum();
+ solveSudoku(0,0);
+
+ for (int i = 0; i < WIDTH; i++) {
+ for (int j = 0; j < WIDTH; j++)
+ cout << map[i][j];
+ cout << endl;
+ }
+}
+
+void generatePossibleNum() {
+ for (int i = 0; i < WIDTH; i++)
+ for (int j = 0; j < WIDTH; j++)
+ if (map[i][j] == 0) {
+ for (int k = 1; k <= WIDTH; k++)
+ possibleNum[i][j][k] = k;
+ for (int vert = 0; vert < WIDTH; vert++)
+ possibleNum[i][j][map[vert][j]] = 0;
+ for (int horiz = 0; horiz < WIDTH; horiz++)
+ possibleNum[i][j][map[i][horiz]] = 0;
+ }
+
+ for (int i = 0; i < 3; i++) {
+ for (int j = 0; j < 3; j++) {
+ int row = i * 3, col = j * 3;
+ for (int r = 0; r < 3; r++) {
+ for (int c = 0; c < 3; c++) {
+ for (int r2 = 0; r2 < 3; r2++)
+ for (int c2 = 0; c2 < 3; c2++)
+ possibleNum[row + r][col + c][map[row + r2][col + c2]] = 0;
+ }
+ }
+ }
+ }
+}
+
+bool solveSudoku(int row, int col) {
+ if (map[row][col] != 0) {
+ if (col < WIDTH - 1)
+ return solveSudoku(row, col + 1);
+ else if (row < WIDTH - 1)
+ return solveSudoku(row + 1, 0);
+ else
+ return true;
+ }
+
+ for (int i = 1; i <= WIDTH; i++) {
+ if (possibleNum[row][col][i] != 0 && checkVertical(row, col, i) && checkHorizontal(row, col, i) && checkSquare(row, col, i)) {
+ map[row][col] = i;
+ if (col < WIDTH - 1) {
+ if (solveSudoku(row, col + 1))
+ return true;
+ }
+ else if (row < WIDTH - 1) {
+ if (solveSudoku(row + 1, 0))
+ return true;
+ }
+ else
+ return true;
+ map[row][col] = 0;
+ }
+ }
+ return false;
+}
+
+bool checkVertical(int row, int col, int value) {
+ for (int vert = 0; vert < WIDTH; vert++) {
+ if (map[vert][col] == value)
+ return false;
+ }
+ return true;
+}
+bool checkHorizontal(int row, int col, int value) {
+ for (int horiz = 0; horiz < WIDTH; horiz++) {
+ if (map[row][horiz] == value)
+ return false;
+ }
+ return true;
+}
+bool checkSquare(int row, int col, int value) {
+ int sr = row / 3, sc = col / 3;
+ sr *= 3;
+ sc *= 3;
+
+ for (int r = 0; r < 3; r++) {
+ for (int c = 0; c < 3; c++) {
+ if (map[sr + r][sc + c] == value)
+ return false;
+ }
+ }
+ return true;
+}
+
Comments powered by Disqus.
1
+
1. 그냥 위상정렬하면된다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+
1. Student 구조체 : beforeCount : 이전에 몇개있는지 셈, next : 큰 학생들 나열, isChecked : 라인에 넣어졌는지 확인
+2. 처음에 beforeCount가 0인 학생들을 큐에 넣고, isCheked에 체크함
+3. 하나씩 큐에서 빼면서 아래 시행
+ -라인에 넣고
+ -next에 있는 학생들의 beforeCount를 1개씩 줄임
+ -이때, 그 학생의 beforeCount가 0이 되면, 임시 큐에 넣고 isChecked에 TRUE 표시
+4. 큐에서 다 빼면, 임시 큐를 큐에 복사
+5. 다 빠질 때까지 반복
+6. 안넣어진 학생들을 따로 뒤에 집어넣음
+
1
+2
+3
+4
+5
+
1. next에 있는 학생들의 beforeCount를 하나씩 줄이고, 0되면 바로 집어넣는 게, 다시 처음부터 검사하고 넣는 것보다 훨씬 빠르다.
+2. for(int i = 0; i<q.size(); i++) {
+ int cur = q.front();
+ q.pop_front();
+ 는 매우 위험하다. pop_front() 될 때마다 size가 달라지므로 size는 처음에 다른 곳에 length로 저장해놓고 하는게 좋다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+
#include <iostream>
+#include <vector>
+#include <list>
+#define MAX_STUDENT 32000
+using namespace std;
+
+typedef struct Student {
+ int beforeCount;
+ bool isChecked;
+ vector<int> next;
+} Student;
+
+Student student[MAX_STUDENT];
+int numOfStudent;
+int line[MAX_STUDENT];
+
+void setLine();
+
+int main() {
+ int numOfCompare;
+ cin >> numOfStudent >> numOfCompare;
+ for (int i = 0; i < numOfCompare; i++) {
+ int a, b;
+ cin >> a >> b;
+ a--;
+ b--;
+ student[a].next.push_back(b);
+ student[b].beforeCount++;
+ }
+
+ setLine();
+ for (int i = 0; i < numOfStudent; i++)
+ cout << line[i] + 1 << " ";
+}
+
+void setLine() {
+ list<int> q;
+ for (int i = 0; i < numOfStudent; i++)
+ if (student[i].beforeCount == 0) {
+ q.push_back(i);
+ student[i].isChecked = true;
+ }
+
+ int lineIndex = 0;
+ while (!q.empty()) {
+ list<int> temp;
+ int length = q.size();
+ //꺼내면서 줄 세우고, next로 연결될 곳 before 하나씩 지우자.
+ for (int i = 0; i < length; i++) {
+ int cur = q.front();
+ q.pop_front();
+ line[lineIndex++] = cur;
+ for (int j = 0; j < student[cur].next.size(); j++) {
+ student[student[cur].next[j]].beforeCount--;
+ if (student[student[cur].next[j]].beforeCount == 0 && !student[student[cur].next[j]].isChecked) {
+ temp.push_back(student[cur].next[j]);
+ student[student[cur].next[j]].isChecked = true;
+ }
+ }
+ }
+ q = temp;
+ }
+
+ //check 안된거 그냥 하나씩 집어넣기
+ for (int i = 0; i < numOfStudent; i++)
+ if (!student[i].isChecked)
+ line[lineIndex++] = i;
+}
+
Comments powered by Disqus.
1
+2
+3
+
1. 왼발 위치, 오른발 위치, 명령 번호를 기준으로 dp 자료를 만듬
+ dp[5][5][MAX_COMMAND]
+2. 명령과 같은 칸에 있을 경우 그대로, 다른 위치에 있을 경우 가능한 위치엔 전부 옮기는 식으로 DP 시행.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+
#include <iostream>
+#include <cstring>
+#define MAX_COMMAND 1000000
+
+using namespace std;
+
+int command[MAX_COMMAND];
+int numOfCommand;
+int foot[2];
+int dp[5][5][MAX_COMMAND];
+
+int getMinEnergy(int cmd);
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+bool isClose(int f, int cmd);
+bool isOpposite(int f, int cmd);
+
+int main() {
+ while (true) {
+ cin >> command[numOfCommand];
+ if (command[numOfCommand] == 0)
+ break;
+ numOfCommand++;
+ }
+
+ cout << getMinEnergy(0);
+}
+
+int getMinEnergy(int cmd) {
+ if (cmd == numOfCommand)
+ return 0;
+ if (dp[foot[0]][foot[1]][cmd] != 0)
+ return dp[foot[0]][foot[1]][cmd];
+
+ int minimum = 2000000000;
+ //같은 자리에 있는 발이 있는지 검사
+ if (command[cmd] == foot[0] || command[cmd] == foot[1]) {
+ minimum = min(minimum, getMinEnergy(cmd + 1) + 1);
+ }
+ else {
+ //중앙에 있는 지 확인
+ if (foot[0] == 0) {
+ foot[0] = command[cmd];
+ minimum = min(minimum, getMinEnergy(cmd + 1) + 2);
+ foot[0] = 0;
+ }
+ if (foot[1] == 0) {
+ foot[1] = command[cmd];
+ minimum = min(minimum, getMinEnergy(cmd + 1) + 2);
+ foot[1] = 0;
+ }
+
+ int tempLeft = foot[0];
+ int tempRight = foot[1];
+ //인접한지 확인
+ if (isClose(foot[0], command[cmd])) {
+ foot[0] = command[cmd];
+ minimum = min(minimum, getMinEnergy(cmd + 1) + 3);
+ foot[0] = tempLeft;
+ }
+ if (isClose(foot[1], command[cmd])) {
+ foot[1] = command[cmd];
+ minimum = min(minimum, getMinEnergy(cmd + 1) + 3);
+ foot[1] = tempRight;
+ }
+ //반대편으로
+ if (isOpposite(foot[0], command[cmd])) {
+ foot[0] = command[cmd];
+ minimum = min(minimum, getMinEnergy(cmd + 1) + 4);
+ foot[0] = tempLeft;
+ }
+ if (isOpposite(foot[1], command[cmd])) {
+ foot[1] = command[cmd];
+ minimum = min(minimum, getMinEnergy(cmd + 1) + 4);
+ foot[1] = tempRight;
+ }
+ }
+ return dp[foot[0]][foot[1]][cmd] = minimum;
+}
+
+bool isClose(int f, int cmd) {
+ if (f == 1 && (cmd == 2 || cmd == 4))
+ return true;
+ if (f == 2 && (cmd == 1 || cmd == 3))
+ return true;
+ if (f == 3 && (cmd == 2 || cmd == 4))
+ return true;
+ if (f == 4 && (cmd == 1 || cmd == 3))
+ return true;
+ return false;
+}
+
+bool isOpposite(int f, int cmd) {
+ if (f == 1 && cmd == 3)
+ return true;
+ if (f == 2 && cmd == 4)
+ return true;
+ if (f == 3 && cmd == 1)
+ return true;
+ if (f == 4 && cmd == 2)
+ return true;
+ return false;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+
#include <bits/stdc++.h>
+
+using namespace std;
+
+int n, weights[1010];
+
+int main() {
+ cin >> n;
+ for (int i = 0; i < n; i++)
+ cin >> weights[i];
+ sort(&weights[0], &weights[n]);
+
+ int result = 0;
+ for (int i = 0; i < n; i++) {
+ if (weights[i] > result + 1)
+ break;
+ result += weights[i];
+ }
+
+ cout << result + 1;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+
#include <iostream>
+#include <algorithm>
+#include <set>
+#define MAX_LIQUID 5000
+
+using namespace std;
+
+int liquid[MAX_LIQUID];
+int numOfLiquid;
+int threeLiquid[3];
+
+void getZerost();
+int abs(int a) {
+ return a < 0 ? (-1) * a : a;
+}
+void setThreeLiquid(int f, int s, int t) {
+ threeLiquid[0] = f;
+ threeLiquid[1] = s;
+ threeLiquid[2] = t;
+}
+
+int main() {
+ cin >> numOfLiquid;
+ for (int i = 0; i < numOfLiquid; i++)
+ cin >> liquid[i];
+
+ getZerost();
+ for (int i = 0; i < 3; i++)
+ cout << threeLiquid[i] << " ";
+}
+
+void getZerost() {
+ sort(liquid, &liquid[numOfLiquid]);
+ int firstPlus = numOfLiquid;
+ for (int i = 0; i < numOfLiquid; i++)
+ if (liquid[i] > 0) {
+ firstPlus = i;
+ break;
+ }
+ if (firstPlus == numOfLiquid) {
+ setThreeLiquid(liquid[numOfLiquid - 3], liquid[numOfLiquid - 2], liquid[numOfLiquid - 1]);
+ return;
+ }
+ if (firstPlus == 0) {
+ setThreeLiquid(liquid[0], liquid[1], liquid[2]);
+ return;
+ }
+
+ int zerostValue = 2000000213;
+ if (firstPlus > 2 && firstPlus <= numOfLiquid - 3) {
+ if (abs(liquid[firstPlus-3] + liquid[firstPlus-2] + liquid[firstPlus-1]) < liquid[firstPlus] + liquid[firstPlus + 1] + liquid[firstPlus + 2]) {
+ zerostValue = abs(liquid[firstPlus - 3] + liquid[firstPlus - 2] + liquid[firstPlus - 1]);
+ setThreeLiquid(liquid[firstPlus - 3], liquid[firstPlus - 2], liquid[firstPlus - 1]);
+ }
+ else {
+ zerostValue = liquid[firstPlus] + liquid[firstPlus + 1] + liquid[firstPlus + 2];
+ setThreeLiquid(liquid[firstPlus], liquid[firstPlus + 1] ,liquid[firstPlus + 2]);
+ }
+ }
+ else if (firstPlus > 2) {
+ zerostValue = abs(liquid[firstPlus - 3] + liquid[firstPlus - 2] + liquid[firstPlus - 1]);
+ setThreeLiquid(liquid[firstPlus - 3], liquid[firstPlus - 2], liquid[firstPlus - 1]);
+ }
+ else if (firstPlus <= numOfLiquid - 3) {
+ zerostValue = liquid[firstPlus] + liquid[firstPlus + 1] + liquid[firstPlus + 2];
+ setThreeLiquid(liquid[firstPlus], liquid[firstPlus + 1], liquid[firstPlus + 2]);
+ }
+
+ //-97 -6 -2 6 98
+ //음수 2개, 양수 1개
+ if (firstPlus >= 2) {
+ set<int> s;
+ for (int i = firstPlus; i < numOfLiquid; i++)
+ s.insert(liquid[i]);
+ for (int first = 0; first <= firstPlus - 2; first++) {
+ for (int second = first + 1; second <= firstPlus - 1; second++) {
+ int cur = liquid[first] + liquid[second];
+ set<int>::iterator iter = s.find(abs(cur));
+ if (iter == s.end()) {
+ iter = s.insert(abs(cur)).first;
+ iter = s.erase(iter);
+ if (iter != s.end() &&(cur + *iter < zerostValue)) {
+ zerostValue = cur + *iter;
+ setThreeLiquid(liquid[first], liquid[second], *iter);
+ }
+ if (iter != s.begin()) {
+ iter--;
+ if (abs(cur + *iter) < zerostValue) {
+ zerostValue = abs(cur + *iter);
+ setThreeLiquid(liquid[first], liquid[second], *iter);
+ }
+ }
+ }
+ else {
+ setThreeLiquid(liquid[first], liquid[second], *iter);
+ return;
+ }
+ }
+ }
+ }
+ //음수 1개, 양수 2개
+ if (firstPlus < numOfLiquid - 1) {
+ set<int> s;
+ for (int i = 0; i < firstPlus; i++)
+ s.insert(liquid[i]);
+ for (int first = 0; first <= firstPlus - 1; first++) {
+ for (int second = firstPlus; second < numOfLiquid - 1; second++) {
+ int cur = liquid[first] + liquid[second];
+ set<int>::iterator iter = s.find(0 - cur);
+ if (iter == s.end()) {
+ iter = s.insert(0 - cur).first;
+ iter = s.erase(iter);
+ if (iter != s.end() && (cur + *iter < zerostValue)) {
+ zerostValue = cur + *iter;
+ setThreeLiquid(*iter, liquid[first], liquid[second]);
+ }
+ if (iter != s.begin()) {
+ iter--;
+ if (abs(cur + *iter) < zerostValue) {
+ zerostValue = abs(cur + *iter);
+ setThreeLiquid(*iter, liquid[first], liquid[second]);
+ }
+ }
+ }
+ else {
+ setThreeLiquid(*iter, liquid[first], liquid[second]);
+ return;
+ }
+ }
+ }
+
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+
1. 모든 경우를 탐색하되, 앞에서부터 하나씩 채워가면서 재귀형태로 하면 백트래킹도 적용하기 쉽다.
+2. 조건에 맞는 경우만 탐색하면 됨.
+3. 낮은 거 먼저 탐색하도록하면 굳이 뭘 저장할 필요없이 맨처음것만 minimum에 저장하고, 제일 나중 것을 maxnimum에 저장하면 된다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+
#include <iostream>
+
+using namespace std;
+
+int N, arr[10];
+char str[9], mini[10], maxi[10];
+bool check[10], isMini;
+
+void brute(int deep);
+
+int main() {
+ cin >> N;
+ for (int i = 0; i < N; i++)
+ cin >> str[i];
+
+ for (int i = 0; i < 10; i++) {
+ arr[0] = i;
+ check[i] = true;
+ brute(0);
+ check[i] = false;
+ }
+
+ cout << maxi << endl;
+ cout << mini << endl;
+}
+
+void brute(int deep) {
+ if (deep == N) {
+ if (!isMini) {
+ for (int i = 0; i < N + 1; i++)
+ mini[i] = arr[i] + '0';
+ isMini = true;
+ }
+ for (int i = 0; i < N + 1; i++)
+ maxi[i] = arr[i] + '0';
+ cout << "check : " << maxi << endl;
+ return;
+ }
+
+ if (str[deep] == '>') {
+ for (int i = 0; i <= arr[deep] - 1; i++) {
+ if (!check[i]) {
+ arr[deep + 1] = i;
+ check[i] = true;
+ brute(deep + 1);
+ check[i] = false;
+ }
+ }
+ }
+ else {
+ for (int i = arr[deep] + 1; i <= 9; i++) {
+ if (!check[i]) {
+ arr[deep + 1] = i;
+ check[i] = true;
+ brute(deep + 1);
+ check[i] = false;
+ }
+ }
+ }
+}
+
Comments powered by Disqus.
1
+2
+
1. LIS를 구하면 그것들이 겹치지 않고 최대로 연결가능한 전깃줄들이다.
+2. 따라서 LIS를 구하고 전체 전깃줄에서 LIS를 빼면 빼야하는 전깃줄의 수와 전깃줄의 종류가 나오게 된다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+
#include <bits/stdc++.h>
+#define MAX_WIRE 100001
+
+using namespace std;
+
+struct Wire {
+ int a;
+ int b;
+ bool check;
+ bool operator <(Wire s) {
+ return a < s.a;
+ }
+};
+
+Wire wire[MAX_WIRE];
+int numOfWire, length[500001], save[500001], numOfSave;
+
+void LIS();
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cout.tie(0);
+
+ cin >> numOfWire;
+ for (int i = 0; i < numOfWire; i++)
+ cin >> wire[i].a >> wire[i].b;
+
+ sort(wire, wire + numOfWire);
+
+ LIS();
+}
+
+void LIS() {
+ int result = 0, index = 0;
+ for (int i = 0; i < numOfWire; i++) {
+ int *lb = lower_bound(save, save + numOfSave, wire[i].b);
+
+ length[wire[i].a] = lb - save + 1;
+ *lb = wire[i].b;
+
+ if (length[wire[i].a] == numOfSave + 1)
+ numOfSave++;
+
+ if (result < length[wire[i].a]) {
+ result = length[wire[i].a];
+ index = i;
+ }
+ }
+
+ cout << numOfWire - result << "\n";
+ for (int i = index; i >= 0; i--) {
+ if (result <= 0)
+ break;
+ if (length[wire[i].a] == result) {
+ wire[i].check = true;
+ result--;
+ }
+ }
+ for (int i = 0; i < numOfWire; i++)
+ if (!wire[i].check)
+ cout << wire[i].a << "\n";
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+
#include <iostream>
+#include <vector>
+#include <list>
+#include <cstring>
+#define MAX_SINGER 1000
+#define MAX_PD 100
+
+using namespace std;
+
+typedef struct Singer {
+ int beforeCount;
+ bool isCheked;
+ vector<int> next;
+} Singer;
+
+Singer singer[MAX_SINGER];
+int order[MAX_SINGER], numOfSinger;
+vector<vector<int>> set;
+int check[MAX_SINGER];
+bool checkDup[MAX_SINGER][MAX_SINGER];
+int pd[MAX_SINGER];
+
+bool unionFind(int forward, int backward);
+void makeOrder();
+
+int main() {
+ memset(check, -1, sizeof(check));
+ int numOfPd;
+ cin >> numOfSinger >> numOfPd;
+ for (int i = 0; i < numOfPd; i++) {
+ int ns;
+ cin >> ns;
+ for (int j = 0; j < ns; j++) {
+ cin >> pd[j];
+ pd[j]--;
+ if (j != 0) {
+ for (int k = 0; k < j; k++) {
+ if (!checkDup[pd[k]][pd[j]]) {
+ if (unionFind(pd[k], pd[j])) {
+ singer[pd[k]].next.push_back(pd[j]);
+ singer[pd[j]].beforeCount++;
+ checkDup[pd[k]][pd[j]] = true;
+ }
+ else {
+ cout << 0 << endl;
+ return 0;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ makeOrder();
+ for (int i = 0; i < numOfSinger; i++)
+ cout << order[i] + 1 << endl;
+}
+
+bool unionFind(int forward, int backward) {
+ if (check[forward] == -1 && check[backward] == -1) {
+ vector<int> temp;
+ temp.push_back(forward);
+ temp.push_back(backward);
+ set.push_back(temp);
+ check[forward] = set.size() - 1;
+ check[backward] = set.size() - 1;
+ }
+ else if (check[forward] == -1) {
+ set[check[backward]].push_back(forward);
+ check[forward] = check[backward];
+ }
+ else if (check[backward] == -1) {
+ set[check[forward]].push_back(backward);
+ check[backward] = check[forward];
+ }
+ else if (check[forward] != check[backward]) {
+ for (int i = 0; i < set[check[backward]].size(); i++) {
+ check[set[check[backward]][i]] = check[forward];
+ set[check[forward]].push_back(set[check[backward]][i]);
+ }
+ set[check[backward]].clear();
+ }
+ else {
+ return false;
+ }
+ return true;
+}
+
+void makeOrder() {
+ list<int> q;
+ int orderIndex = 0;
+ for (int i = 0; i < numOfSinger; i++)
+ if (singer[i].beforeCount == 0) {
+ q.push_back(i);
+ singer[i].isCheked = true;
+ }
+
+ while (!q.empty()) {
+ int length = q.size();
+ for (int i = 0; i < length; i++) {
+ int temp = q.front();
+ q.pop_front();
+ order[orderIndex++] = temp;
+ for (int j = 0; j < singer[temp].next.size(); j++) {
+ singer[singer[temp].next[j]].beforeCount--;
+ if (singer[singer[temp].next[j]].beforeCount == 0 && !singer[singer[temp].next[j]].isCheked) {
+ singer[singer[temp].next[j]].isCheked = true;
+ q.push_back(singer[temp].next[j]);
+ }
+ }
+ }
+ }
+}
+
Comments powered by Disqus.
배낭문제를 응용하여, 추를 하나씩 모든 무게에 대해 검사를 한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+
#include <iostream>
+
+using namespace std;
+
+int n, w[30];
+bool check[31][15001];
+
+int abs(int a) {
+ return a < 0 ? -a : a;
+}
+
+int main() {
+ cin >> n;
+ for (int i = 0; i < n; i++)
+ cin >> w[i];
+ for (int i = 0; i <= 30; i++)
+ check[i][0] = true;
+
+ for (int j = 1; j <= n; j++) {
+ for (int i = 1; i <= 15000; i++) {
+ if (w[j - 1] <= i && check[j - 1][i - w[j - 1]]) {
+ check[j][i] = true;
+ }
+ else if (check[j - 1][i]) {
+ check[j][i] = true;
+ check[j][abs(i - w[j - 1])] = true;
+ }
+ }
+ }
+
+ int c, t;
+ cin >> c;
+ for (int i = 0; i < c; i++) {
+ cin >> t;
+ if (t > 15000)
+ cout << "N ";
+ else if (check[n][t])
+ cout << "Y ";
+ else
+ cout << "N ";
+ }
+
+}
+
Comments powered by Disqus.
LIS를 구하고, LIS를 구성하지 않는 요소들만 배치해주면 됨
LIS를 구하는 방법으론 n이 최대 200이니 O(n^2)을 써도 충분함
LIS 구하는 코드 O(n^2)
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
for (int i = 1; i <= n; i++) {
+ save[i] = 1;
+
+ for (int j = 1; j < n; j++) {
+ if (nums[j] < nums[i])
+ save[i] = max(save[i], save[j] + 1);
+ }
+ ans = max(ans, save[i]);
+}
+
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+
#include <iostream>
+
+using namespace std;
+
+
+int n, nums[220], ans, save[220];
+int max(int a, int b) {
+ return a > b ? a : b;
+}
+
+int main() {
+ cin >> n;
+ for (int i = 1; i <= n; i++)
+ cin >> nums[i];
+
+ for (int i = 1; i <= n; i++) {
+ save[i] = 1;
+
+ for (int j = 1; j < n; j++) {
+ if (nums[j] < nums[i])
+ save[i] = max(save[i], save[j] + 1);
+ }
+ ans = max(ans, save[i]);
+ }
+
+ cout << n - ans;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+
1. 모든 행성들의 x좌표, y좌표, z좌표를 꺼내 따로 저장하고, 오름차순으로 정렬
+2. 정렬한 것에서 인접한 것끼리 비용을 계산, (인접한 점 두개 + 비용)을 구조체로 n-1개의 원소를 가지는 배열 3개를 선언하고 집어넣음
+3. 그 구조체배열 3개는 비용을 기준으로 오름차순으로 정렬
+4. 구조체 배열 3개를 가리키는 3개의 인덱스 변수 xi, yi, zi를 선언
+5. xi, yi, zi 중 최소 비용을 unionFind 알고리즘으로 사이클이 형성되는지 확인하면서 집어넣음. 넣으면 edge 1증가, 넣어도 안넣어도 xi, yi, zi는 최소일시 1 증가시킨다
+6. edge가 n-1개가 되면 정지 -> 총 value 출력
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+
1. MST로 풀어야하는 문제인건 바로 암. 근데 간선이 주어지지 않음 -> 간선을 직접 만들어야함
+2. 모든 행성간의 비용을 구하는건 너무 오래걸리고, 메모리 소모가 심함
+ -> 가장 가까운 것이 될 만한 것들끼리만 비교하여 간선을 만들자
+3. 모든 행성을 정렬하여 인접한 것끼리 할까?
+ -> 어떤 기준으로 정렬할 것인지 문제고, 또 정렬하더라도 인접하지만 거리는 제일 멀 수 있음 -> 비용계산공식이 좌표별로 독립적이기에
+4. 그럼 좌표별로 모든 점들을 정렬하여 인접한 것끼리 비용을 계산하고, 또 그 비용을 정렬하면 되겠구나
+ -> 그럼 비용, 두 인접한 좌표를 가지고 있는 구조체를 선언하는게 좋겠구나
+5. 이렇게 간선을 얻고, 하나씩 집어넣는데 총 edge는 N-1개니까 넣을 때마다 edge를 1개씩 증가시켜 n-1이 되면 정지시키면 되겠구나
+6. 통과
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+
#include <iostream>
+#include <vector>
+#include <cstring>
+#include <algorithm>
+#define MAX_PLANET 100000
+
+using namespace std;
+
+typedef struct Planet {
+ int x;
+ int y;
+ int z;
+} Planet;
+typedef struct Distance {
+ int first;
+ int second;
+ int distance;
+ bool operator < (Distance d) {
+ return distance < d.distance;
+ }
+} Distance;
+
+Planet planet[MAX_PLANET];
+Distance xyz[3][MAX_PLANET];
+int numOfPlanet, checkPlanet[MAX_PLANET], tempXYZ[MAX_PLANET];
+vector<vector<int>> set;
+
+int abs(int a) {
+ return a < 0 ? (-1) * a : a;
+}
+long long getMinValue();
+bool putSet(int a, int b);
+bool compX(int a, int b) {
+ return planet[a].x < planet[b].x;
+}
+bool compY(int a, int b) {
+ return planet[a].y < planet[b].y;
+}
+bool compZ(int a, int b) {
+ return planet[a].z < planet[b].z;
+}
+void initAndSortXYZ();
+
+int main() {
+ cin >> numOfPlanet;
+ for (int i = 0; i < numOfPlanet; i++)
+ cin >> planet[i].x >> planet[i].y >> planet[i].z;
+ for (int i = 0; i < MAX_PLANET; i++)
+ checkPlanet[i] = -1;
+
+ cout << getMinValue();
+}
+
+long long getMinValue() {
+ long long value = 0;
+ int Xi = 0, Yi = 0, Zi = 0, edge = 0;
+ initAndSortXYZ();
+ while (edge < numOfPlanet - 1) {
+ int xd = xyz[0][Xi].distance, yd = xyz[1][Yi].distance, zd = xyz[2][Zi].distance;
+ if (xd <= yd && xd <= zd) {
+ if (putSet(xyz[0][Xi].first, xyz[0][Xi].second)) {
+ value += xd;
+ edge++;
+ }
+ Xi++;
+ }
+ else if (yd <= xd && yd <= zd) {
+ if (putSet(xyz[1][Yi].first, xyz[1][Yi].second)) {
+ value += yd;
+ edge++;
+ }
+ Yi++;
+ }
+ else {
+ if (putSet(xyz[2][Zi].first, xyz[2][Zi].second)) {
+ value += zd;
+ edge++;
+ }
+ Zi++;
+ }
+ }
+
+ return value;
+}
+
+void initAndSortXYZ() {
+ cout << endl;
+ for (int k = 0; k < 3; k++) {
+ for (int i = 0; i < numOfPlanet; i++)
+ tempXYZ[i] = i;
+
+ if(k == 0) sort(tempXYZ, tempXYZ + numOfPlanet, compX);
+ else if(k==1) sort(tempXYZ, tempXYZ + numOfPlanet, compY);
+ else if(k==2) sort(tempXYZ, tempXYZ + numOfPlanet, compZ);
+
+ for (int i = 0; i < numOfPlanet - 1; i++) {
+ xyz[k][i].first = tempXYZ[i];
+ xyz[k][i].second = tempXYZ[i + 1];
+ if (k == 0)
+ xyz[k][i].distance = abs(planet[tempXYZ[i]].x - planet[tempXYZ[i + 1]].x);
+ else if (k == 1)
+ xyz[k][i].distance = abs(planet[tempXYZ[i]].y - planet[tempXYZ[i + 1]].y);
+ else if (k == 2)
+ xyz[k][i].distance = abs(planet[tempXYZ[i]].z - planet[tempXYZ[i + 1]].z);
+ }
+ for (int i = 0; i < numOfPlanet - 1; i++)
+ cout << "( " << xyz[k][i].first << ", " << xyz[k][i].second << ", " << xyz[k][i].distance << ") ";
+ sort(xyz[k], xyz[k] + numOfPlanet -1);
+ for (int i = 0; i < numOfPlanet - 1; i++)
+ cout << "( " << xyz[k][i].first << ", " << xyz[k][i].second << ", " << xyz[k][i].distance << ") ";
+ cout << endl;
+ }
+
+ cout << endl;
+
+}
+
+bool putSet(int a, int b) {
+ if (checkPlanet[a] == -1 && checkPlanet[b] == -1) {
+ vector<int> temp;
+ temp.push_back(a);
+ temp.push_back(b);
+ set.push_back(temp);
+ checkPlanet[a] = set.size() - 1;
+ checkPlanet[b] = set.size() - 1;
+ }
+ else if (checkPlanet[a] == -1) {
+ checkPlanet[a] = checkPlanet[b];
+ set[checkPlanet[b]].push_back(a);
+ }
+ else if (checkPlanet[b] == -1) {
+ checkPlanet[b] = checkPlanet[a];
+ set[checkPlanet[a]].push_back(b);
+ }
+ else if (checkPlanet[a] < checkPlanet[b]) {
+ int temp = checkPlanet[b];
+ for (int i = 0; i < set[temp].size(); i++) {
+ checkPlanet[set[temp][i]] = checkPlanet[a];
+ set[checkPlanet[a]].push_back(set[temp][i]);
+ }
+ set[temp].clear();
+ }
+ else if (checkPlanet[a] > checkPlanet[b]) {
+ int temp = checkPlanet[a];
+ for (int i = 0; i < set[temp].size(); i++) {
+ checkPlanet[set[temp][i]] = checkPlanet[b];
+ set[checkPlanet[b]].push_back(set[temp][i]);
+ }
+ set[temp].clear();
+ }
+ else
+ return false;
+ return true;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+
1. M에서 시작해 갈 수 있는 방향으로 가다가 빈칸을 마주하면 스탑.
+ 만약 빈칸이 없으면 아예 처음부터 연결이 안된 것. 이때는 Z 부터 시작해 빈칸을 찾는다.
+2. 빈칸을 찾으면 빈칸 주변을 검색. 인접한 칸에 바로 연결되는 파이프가 있으면 그 칸을 true로 표시. 표시된 것에 따라 빈칸에 넣을 수 있는 가스관을 배정.
+ ex) 빈칸 | 이면 연결이 안되므로, 오른쪽칸은 false
+ 빈칸 - 이면 연결이 되므로 오른쪽 칸은 true
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+
#include <bits/stdc++.h>
+
+using namespace std;
+
+struct Location {
+ int row;
+ int col;
+ int way; // 1~4 위 오 아 왼
+};
+
+char eumap[25][25], answer;
+int R, C;
+Location M, Z, blank;
+list<Location> q;
+
+bool findBlank(int row, int col); //찾으면 true
+bool goNext(Location cur); // 빈칸 발견시 false. 나머지 true
+Location nextCell(Location c);
+void fillBlank();
+
+int main() {
+ cin >> R >> C;
+ for (int i = 0; i < R; i++)
+ for (int j = 0; j < C; j++) {
+ cin >> eumap[i][j];
+ if (eumap[i][j] == 'M')
+ M = { i, j, 0 };
+ else if (eumap[i][j] == 'Z')
+ Z = { i, j, 0 };
+ }
+
+ if (!findBlank(M.row, M.col))
+ findBlank(Z.row, Z.col);
+
+ fillBlank();
+
+ cout << blank.row + 1 << " " << blank.col + 1 << " " << answer << endl;
+}
+
+bool findBlank(int r, int c) {
+ if (r > 0 && eumap[r - 1][c] != '.')
+ q.push_back({ r, c, 1 });
+ if (c < C - 1 && eumap[r][c + 1] != '.')
+ q.push_back({ r, c, 2 });
+ if (r < R -1 && eumap[r + 1][c] != '.')
+ q.push_back({ r, c, 3 });
+ if (c > 0 && eumap[r][c - 1] != '.')
+ q.push_back({ r, c, 4 });
+
+ while (!q.empty()) {
+ if (goNext(q.front()))
+ q.pop_front();
+ else {
+ q.clear();
+ return true;
+ }
+ }
+ q.clear();
+ return false;
+}
+
+bool goNext(Location cur) {
+ cur = nextCell(cur);
+ int r = cur.row, c = cur.col, w = cur.way;
+
+ char t = eumap[r][c];
+
+ if (t == '.') {
+ blank = { r, c, w };
+ return false;
+ }
+
+ if (w == 1 || w == 3) {
+ if (t == '|' || t == '+')
+ q.push_back({ r , c, w });
+ if (t == '1' || t == '2' || t == '+')
+ q.push_back({ r , c, 2 });
+ if (t == '4' || t == '3' || t == '+')
+ q.push_back({ r , c, 4 });
+ }
+ else {
+ if (t == '-' || t == '+')
+ q.push_back({ r, c , w });
+ if (t == '3' || t == '2' || t == '+')
+ q.push_back({ r, c , 1 });
+ if (t == '4' || t == '1' || t == '+')
+ q.push_back({ r, c , 3 });
+ }
+ return true;
+}
+
+Location nextCell(Location cur) {
+ int r = cur.row, c = cur.col, w = cur.way;
+
+ if (w == 1 && r > 0)
+ return { r - 1, c, w };
+ if (w == 2 && c < C - 1)
+ return { r, c + 1, w };
+ if (w == 3 && r < R - 1)
+ return { r + 1, c, w };
+ if (w == 4 && c > 0)
+ return { r, c - 1,w};
+}
+
+void fillBlank() {
+ int r = blank.row, c = blank.col, w = blank.way;
+ bool check[4] = { 0,0,0,0 };
+ if (r > 0) {
+ char t = eumap[r - 1][c];
+ check[0] = t != '|' ? t != '1' ? t != '4' ? t != '+' ? false : true : true : true : true;
+ }
+ if (c < C - 1) {
+ char t = eumap[r][c + 1];
+ check[1] = t != '-' ? t != '4' ? t != '3' ? t != '+' ? false : true : true : true : true;
+ }
+ if (r < R - 1) {
+ char t = eumap[r + 1][c];
+ check[2] = t != '|' ? t != '2' ? t != '3' ? t != '+' ? false : true : true : true : true;
+ }
+ if (c > 0) {
+ char t = eumap[r][c-1];
+ check[3] = t != '-' ? t != '2' ? t != '1' ? t != '+' ? false : true : true : true : true;
+ }
+
+ if (check[0] && check[1] && check[2] && check[3])
+ answer = '+';
+ else if (check[0] && check[2])
+ answer = '|';
+ else if (check[1] && check[3])
+ answer = '-';
+ else if (check[1] && check[2])
+ answer = '1';
+ else if (check[0] && check[1])
+ answer = '2';
+ else if (check[0] && check[3])
+ answer = '3';
+ else if (check[2] && check[3])
+ answer = '4';
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+
1. 들어온 위치의 미네랄을 지움
+2. 지운 위치에서 상하좌우에 인접한 칸들을 root로 BFS 시행 -> 바닥에 닿는 칸이 있으면 공중에 뜬 클러스터가 아님
+3. 공중에 뜬 클러스터이면 BFS 시 넣은 칸들을 열순, 열이 같으면 행이 큰 순으로 정렬
+4. 각 열별로 가장 밑에 있는 칸만 검사하여 밑 클러스트 또는 바닥과 떨어진 최소 거리를 구함
+5. 정렬한 순으로 최소거리만큼 밑으로 내림
+6. 끝날때까지 1~5 반복
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+
#include <iostream>
+#include <algorithm>
+#define MAX_WIDTH 100
+
+using namespace std;
+
+typedef struct Location {
+ int row;
+ int col;
+ bool operator < (Location l) {
+ if (col != l.col)
+ return col < l.col;
+ else
+ return row > l.row;
+ }
+} Location;
+
+int R, C;
+bool map[MAX_WIDTH][MAX_WIDTH], visit[MAX_WIDTH][MAX_WIDTH];
+Location q[MAX_WIDTH * MAX_WIDTH];
+
+void throwStick(int height, bool isLeft);
+void generateBFS(int r, int c);
+void BFS(int r, int c);
+void initVisit(int length);
+void pushDown(int length);
+
+int main() {
+ cin >> R >> C;
+ for (int i = 0; i < R; i++)
+ for (int j = 0; j < C; j++) {
+ char temp;
+ cin >> temp;
+ if (temp == '.')
+ map[i][j] = false;
+ else
+ map[i][j] = true;
+ }
+
+ int n, temp;
+ cin >> n;
+ for (int i = 0; i < n; i++) {
+ cin >> temp;
+ throwStick(R - temp, i % 2 == 0 ? true : false);
+ }
+
+ for (int i = 0; i < R; i++) {
+ for (int j = 0; j < C; j++) {
+ char c = map[i][j] ? 'x' : '.';
+ cout << c;
+ }
+ cout << endl;
+ }
+}
+
+void throwStick(int height, bool isLeft) {
+ if (isLeft) {
+ int i = 0;
+ for (; i < C; i++)
+ if (map[height][i])
+ break;
+ if (i == C)
+ return;
+
+ map[height][i] = false;
+ generateBFS(height, i);
+ }
+ else {
+ int i = C-1;
+ for (; i >=0; i--)
+ if (map[height][i])
+ break;
+ if (i == -1)
+ return;
+
+ map[height][i] = false;
+ generateBFS(height, i);
+ }
+
+ cout << endl;
+ for (int i = 0; i < R; i++) {
+ for (int j = 0; j < C; j++) {
+ char c = map[i][j] ? 'x' : '.';
+ cout << c;
+ }
+ cout << endl;
+ }
+ cout << endl;
+}
+
+void generateBFS(int r, int c) {
+ if (r > 0 && map[r - 1][c])
+ BFS(r - 1, c);
+ if (r < R - 1 && map[r + 1][c])
+ BFS(r + 1, c);
+ if (c > 0 && map[r][c - 1])
+ BFS(r, c - 1);
+ if (c < C - 1 && map[r][c + 1])
+ BFS(r, c + 1);
+}
+
+void BFS(int r, int c) {
+ int length = 0, index = 0;
+ visit[r][c] = true;
+ q[length++] = { r,c };
+
+ while (index < length) {
+ Location temp = q[index++];
+ int row = temp.row, col = temp.col;
+
+ if (row == R - 1) {
+ initVisit(length);
+ return;
+ }
+
+ if (row > 0 && !visit[row - 1][col] && map[row - 1][col]) {
+ q[length++] = { row - 1, col };
+ visit[row - 1][col] = true;
+ }
+ if (row < R - 1 && !visit[row + 1][col] && map[row + 1][col]) {
+ q[length++] = { row + 1, col };
+ visit[row + 1][col] = true;
+ }
+ if (col > 0 && !visit[row][col - 1] && map[row][col - 1]) {
+ q[length++] = { row, col - 1 };
+ visit[row][col - 1] = true;
+ }
+ if (col < C - 1 && !visit[row][col + 1] && map[row][col + 1]) {
+ q[length++] = { row, col + 1 };
+ visit[row][col + 1] = true;
+ }
+ }
+ pushDown(length);
+ initVisit(length);
+}
+
+void initVisit(int length) {
+ for (int i = 0; i < length; i++)
+ visit[q[i].row][q[i].col] = false;
+}
+
+void pushDown(int length) {
+ sort(q, q + length);
+ //밑이 빈 것들만 뽑고, 그중 밑하고 떨어진 거리가 가장 짧은 것을 따로 길이만 저장
+ //그 길이만큼 하강
+ int minHeight = 1000000, cur = -1;
+ for (int i = 0; i < length; i++) {
+ if (cur != q[i].col) {
+ cur = q[i].col;
+
+ int row = q[i].row + 1;
+ //미네랄을 만나거나 바닥이면 스탑
+ int j = row;
+ for (; j < R; j++)
+ if (map[j][cur])
+ break;
+ minHeight = minHeight < j - row ? minHeight : j - row;
+ }
+ }
+ cout << minHeight << endl;
+
+ //해당 클러스트를 minHeight만큼 내리기
+ //****임시 배열을 만들어서 표시
+ for (int i = 0; i < length; i++) {
+ map[q[i].row][q[i].col] = false;
+ map[q[i].row + minHeight][q[i].col] = true;
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+
#include <iostream>
+#include <cstring>
+#include <list>
+using namespace std;
+
+int N, point[1001][4], classes[1001], classCount;
+bool check[1000];
+list<int> q;
+
+void classify();
+void countClass();
+
+int main() {
+ memset(classes, -1, sizeof(classes));
+
+ cin >> N;
+ for (int i = 0; i < N; i++)
+ cin >> point[i][0] >> point[i][1] >> point[i][2] >> point[i][3];
+
+ classify();
+ countClass();
+
+ for (int i = 0; i < N + 1; i++) {
+ cout << classes[i] << " ";
+ }
+ cout << endl;
+
+ if (classes[N] == -1)
+ cout << classCount;
+ else
+ cout << classCount - 1;
+}
+
+void classify() {
+ int nextClass = 0;
+
+ for (int i = 0; i < N; i++)
+ q.push_back(i);
+
+ while(!q.empty()) {
+ int i = q.front();
+ q.pop_front();
+
+ if (classes[i] == -1)
+ classes[i] = nextClass++;
+
+ int x1 = point[i][0], x2 = point[i][2], y1 = point[i][1], y2 = point[i][3];
+ int iline[4][4] = { {x1, y2, x2, y2}, {x2, y1, x2, y2},{x1, y1, x2, y1},{x1, y1, x1, y2} }; // 위 오 아 왼
+
+ for (int j = 0; j < N + 1; j++) {
+ if (classes[j] != -1)
+ continue;
+ bool same = false;
+
+ x1 = point[j][0], x2 = point[j][2], y1 = point[j][1], y2 = point[j][3];
+ int jline[4][4] = { {x1, y2, x2, y2}, {x2, y1, x2, y2},{x1, y1, x2, y1},{x1, y1, x1, y2} };
+
+ for (int k = 0; k < 4; k++) {
+ for (int p = 0; p < 4; p++) {
+ if (k % 2 == 0 && p % 2 == 0 && iline[k][1] == jline[p][1] && !(iline[k][0] > jline[p][2] || iline[k][2] < jline[p][0]))
+ same = true;
+ else if (k % 2 == 1 && p % 2 == 1 && iline[k][0] == jline[p][0] && (!(iline[k][1] > jline[p][3] || iline[k][3] < jline[p][1])))
+ same = true;
+ else if (k % 2 == 0 && !(iline[k][0] > jline[p][0] || iline[k][2] < jline[p][0] || iline[k][1] > jline[p][3] || iline[k][1] < jline[p][1]))
+ same = true;
+ else if (!(iline[k][0] > jline[p][2] || iline[k][0] < jline[p][0] || iline[k][1] > jline[p][3] || iline[k][3] < jline[p][1]))
+ same = true;
+ }
+ }
+ if (same) {
+ classes[j] = classes[i];
+ q.push_front(j);
+ }
+ }
+ }
+}
+
+void countClass() {
+ for (int i = 0; i < N; i++) {
+ if (!check[classes[i]]) {
+ check[classes[i]] = true;
+ classCount++;
+ }
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+
1. 그냥 대가리 옮기고 꼬리 잡히는지, 칸 밖인지 확인하고, 또 사과있는지 확인하고, 또 시간이 바꿀때가 됐는지 확인
+2. 뱀 몸은 vector로 저장 / 사과 위치는 2차원 bool 배열로 저장하여 메모리랑 참조시간 아낌. /
+ 시간은 Direction 구조체에 저장하고, directionIndex를 선언하여 directionIndex에 있는 시간에 맞으면 방향 바꾸고 index++.
+
+3. 구현문제이므로 내가 생각하는 게임이랑 실제 문제 조건은 다를 수 있다. 따라서 예시를 통해 확인하라.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+
#include <iostream>
+#include <vector>
+#include <cstring>
+#define MAX_APPLE 100
+#define MAX_DIRECTION 100
+
+using namespace std;
+
+typedef struct Location {
+ int row;
+ int col;
+} Location;
+typedef struct Direction {
+ int second;
+ char direction;
+} Direction;
+
+int width;
+int numOfApple;
+bool appleMap[MAX_APPLE][MAX_APPLE];
+int numOfChange;
+Direction direction[MAX_DIRECTION];
+
+void getProperties();
+int getSecond();
+
+int main() {
+ getProperties();
+ cout << getSecond();
+}
+
+void getProperties() {
+ cin >> width;
+ cin >> numOfApple;
+ memset(appleMap, 0, sizeof(bool) * MAX_APPLE * MAX_APPLE);
+ for (int i = 0; i < numOfApple; i++) {
+ int row, col;
+ cin >> row >> col;
+ appleMap[row - 1][col - 1] = true;
+ }
+
+ cin >> numOfChange;
+ for (int i = 0; i < numOfChange; i++) {
+ cin >> direction[i].second >> direction[i].direction;
+ }
+}
+
+int getSecond() {
+ int second = 0;
+ vector<Location> snake;
+ snake.push_back({ 0, 0 });
+ int currentDirection = 2;
+ int directionIndex = 0;
+ bool isEnd = false;
+
+ //현재 헤드 제일 뒤에, 꼬리는 제일 앞에
+ while (!isEnd) {
+ second++;
+ Location s = snake.back();
+ if (currentDirection == 1)
+ snake.push_back({ s.row - 1, s.col });
+ else if (currentDirection == 2)
+ snake.push_back({ s.row, s.col + 1 });
+ else if (currentDirection == 3)
+ snake.push_back({ s.row + 1, s.col });
+ else if (currentDirection == 4)
+ snake.push_back({ s.row, s.col - 1 });
+
+ Location t = snake.back();
+
+ if (t.row < 0 || t.row >= width || t.col < 0 || t.col >= width)
+ isEnd = true;
+ for (int i = 0; i < snake.size(); i++) {
+ if (t.row == snake[i].row && t.col == snake[i].col && i != snake.size() - 1)
+ isEnd = true;
+ }
+
+ if (appleMap[t.row][t.col])
+ appleMap[t.row][t.col] = false;
+ else
+ snake.erase(snake.begin());
+
+ if (direction[directionIndex].second == second) {
+ if (currentDirection == 1)
+ currentDirection = direction[directionIndex].direction == 'D' ? 2 : 4;
+ else if (currentDirection == 2)
+ currentDirection = direction[directionIndex].direction == 'D' ? 3 : 1;
+ else if (currentDirection == 3)
+ currentDirection = direction[directionIndex].direction == 'D' ? 4 : 2;
+ else
+ currentDirection = direction[directionIndex].direction == 'D' ? 1 : 3;
+ directionIndex++;
+ }
+ }
+
+ return second;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+
처음 방법
+ 1. 한 백조에서 BFS 실시하여 다른 백조를 만날 수 있는지 검사
+ 2. 전체 맵을 검사해서 녹일 수 있는 걸 녹임
+ 3. day 추가하고 다시 1부터
+ -> 시간이 너무 걸림. 특히 맵 초기화하는 부분이 많이 걸림
+두번째 방법
+ 1. 1번은 유지
+ 2. 녹을 수 있는 얼음만 저장한 q에서 얼음을 하나씩 꺼내서 녹이고, 주변에 검사되지않은 얼음이 있으면 따로 저장
+ -> q가 끝나면 따로 저장한 얼음을 q에 복사
+ 3. day추가하고 다시 1부터
+ -> 또 시간초과
+세번째 방법
+ 1. 백조가 갈수있는 칸을 전부 각각 L, l 로 바꿈
+ 2. 얼음과 L, l의 경계선을 q에 저장
+ 3. 2방법으로 다 녹이고 나서, q에 있는 칸을 하나씩 꺼내고 주변을 검사하여 또 L, l 로 바꾼다
+ 4. 바꾸는데 다른 문자를 발견하면 스탑 후 출력
+ -> 코드가 너무 복잡하여 헷갈림. 어딘가 잘못됨
+네번째 방법
+ 1. 백조가 갈 수 잇는 칸을 전부 각각 L,l 로 바꿈
+ 2. 얼음을 한칸 녹일 때마다 주변을 검사하여 적절한 문자로 치환
+ 주변에 (L과 l) 두개 있을 때
+ -> 만난 것 -> 출력 후 종료
+ 주변에 L 또는 l 만 있을 때
+ -> 만나지 않음. 그 얼음칸을 중심으로 BFS를 실시하여 갈 수 있는 모든 칸을 L 또는 l로 바꿈
+ 주변에 L, l 둘다 없을 때
+ -> 그냥 . 으로 치환
+ -> 통과
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+
#include <iostream>
+#include <vector>
+#include <list>
+#define MAX_WIDTH 1500
+
+using namespace std;
+
+typedef struct Location {
+ int row;
+ int col;
+} Location;
+
+int row, col, todayLength;
+Location bird1, bird2;
+Location meltToday[MAX_WIDTH*MAX_WIDTH];
+char map[MAX_WIDTH][MAX_WIDTH];
+bool visit[MAX_WIDTH][MAX_WIDTH], meltVisit[MAX_WIDTH][MAX_WIDTH];
+list<Location> q;
+
+bool init();
+void initBird(Location bird, char c);
+bool meltIce();
+bool checkBird(int r, int c);
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cout.tie(0);
+ cin >> row >> col;
+
+ bool check = false;
+ for (int i = 0; i < row; i++) {
+ for (int j = 0; j < col; j++) {
+ cin >> map[i][j];
+ if (map[i][j] == 'L') {
+ if (!check) {
+ bird1.row = i;
+ bird1.col = j;
+ check = true;
+ }
+ else {
+ bird2.row = i;
+ bird2.col = j;
+ map[i][j] = 'l';
+ }
+ }
+ }
+ }
+
+ if (init()) {
+ cout << 0;
+ return 0;
+ }
+
+ int day = 1;
+ while (true) {
+ cout << endl;
+ for (int i = 0; i < row; i++) {
+ for (int j = 0; j < col; j++)
+ cout << map[i][j];
+ cout << endl;
+ }
+ cout << endl;
+ if (meltIce()) {
+ cout << day;
+ break;
+ }
+ day++;
+ }
+}
+
+bool init() {
+ for (int i = 0; i < row; i++) {
+ for (int j = 0; j < col; j++) {
+ if (map[i][j] == 'X') {
+ if (i > 0 && map[i - 1][j] != 'X') {
+ meltToday[todayLength++] = { i, j };
+ meltVisit[i][j] = true;
+ }
+ else if (j < col - 1 && map[i][j + 1] != 'X') {
+ meltToday[todayLength++] = { i, j };
+ meltVisit[i][j] = true;
+ }
+ else if (i < row - 1 && map[i + 1][j] != 'X') {
+ meltToday[todayLength++] = { i, j };
+ meltVisit[i][j] = true;
+ }
+ else if (j > 0 && map[i][j - 1] != 'X') {
+ meltToday[todayLength++] = { i, j };
+ meltVisit[i][j] = true;
+ }
+ }
+ }
+ }
+
+ initBird(bird1, 'L');
+ if (map[bird2.row][bird2.col] == 'L')
+ return true;
+ initBird(bird2, 'l');
+ return false;
+}
+
+void initBird(Location bird, char c) {
+ q.push_back({ bird.row, bird.col });
+ visit[bird.row][bird.col] = true;
+
+ while (!q.empty()) {
+ Location temp = q.front();
+ q.pop_front();
+ map[temp.row][temp.col] = c;
+
+ if (temp.row > 0 && !visit[temp.row - 1][temp.col] && map[temp.row - 1][temp.col] != 'X') {
+ q.push_back({ temp.row - 1, temp.col });
+ visit[temp.row - 1][temp.col] = true;
+ }
+ if (temp.row < row - 1 && !visit[temp.row + 1][temp.col] && map[temp.row + 1][temp.col] != 'X') {
+ q.push_back({ temp.row + 1, temp.col });
+ visit[temp.row + 1][temp.col] = true;
+ }
+ if (temp.col > 0 && !visit[temp.row][temp.col - 1] && map[temp.row][temp.col - 1] != 'X') {
+ q.push_back({ temp.row, temp.col -1 });
+ visit[temp.row][temp.col - 1] = true;
+ }
+ if (temp.col < col - 1 && !visit[temp.row][temp.col + 1] && map[temp.row][temp.col + 1] != 'X') {
+ q.push_back({ temp.row, temp.col + 1});
+ visit[temp.row][temp.col + 1] = true;
+ }
+ }
+}
+
+bool meltIce() {
+ int index = 0;
+ vector<Location> q;
+
+ while (index < todayLength) {
+ if (checkBird(meltToday[index].row, meltToday[index].col))
+ return true;
+
+ if (meltToday[index].row > 0 && map[meltToday[index].row - 1][meltToday[index].col] == 'X' && !meltVisit[meltToday[index].row-1][meltToday[index].col] ) {
+ q.push_back({ meltToday[index].row - 1, meltToday[index].col });
+ meltVisit[meltToday[index].row - 1][meltToday[index].col] = true;
+ }
+
+ if (meltToday[index].col < col - 1 && map[meltToday[index].row][meltToday[index].col + 1] == 'X' && !meltVisit[meltToday[index].row][meltToday[index].col + 1]) {
+ q.push_back({ meltToday[index].row, meltToday[index].col + 1 });
+ meltVisit[meltToday[index].row][meltToday[index].col + 1] = true;
+ }
+
+ if (meltToday[index].row < row - 1 && map[meltToday[index].row + 1][meltToday[index].col] == 'X' && !meltVisit[meltToday[index].row + 1][meltToday[index].col]) {
+ q.push_back({ meltToday[index].row + 1, meltToday[index].col });
+ meltVisit[meltToday[index].row + 1][meltToday[index].col] = true;
+ }
+
+ if (meltToday[index].col > 0 && map[meltToday[index].row][meltToday[index].col - 1] == 'X' && !meltVisit[meltToday[index].row][meltToday[index].col - 1]) {
+ q.push_back({ meltToday[index].row, meltToday[index].col - 1 });
+ meltVisit[meltToday[index].row][meltToday[index].col - 1] = true;
+ }
+
+ index++;
+ }
+ todayLength = 0;
+
+ //넣기
+ for (int i = 0; i < q.size(); i++)
+ meltToday[todayLength++] = q[i];
+
+ return false;
+}
+
+bool checkBird(int r, int c) {
+ bool checkL = false, checkl = false;
+ if (r > 0 && map[r - 1][c] == 'L')
+ checkL = true;
+ else if (r < row - 1 && map[r + 1][c] == 'L')
+ checkL = true;
+ else if (c > 0 && map[r][c - 1] == 'L')
+ checkL = true;
+ else if (c < col - 1 && map[r][c + 1] == 'L')
+ checkL = true;
+
+ if (r > 0 && map[r - 1][c] == 'l')
+ checkl = true;
+ else if (r < row - 1 && map[r + 1][c] == 'l')
+ checkl = true;
+ else if (c > 0 && map[r][c - 1] == 'l')
+ checkl = true;
+ else if (c < col - 1 && map[r][c + 1] == 'l')
+ checkl = true;
+
+ if (checkL && checkl)
+ return true;
+ else if (checkL) {
+ map[r][c] = 'L';
+ initBird({ r,c }, 'L');
+ if (map[bird2.row][bird2.col] == 'L')
+ return true;
+ }
+ else if (checkl) {
+ map[r][c] = 'l';
+ initBird({ r,c }, 'l');
+ if (map[bird1.row][bird1.col] == 'l')
+ return true;
+ }
+ else
+ map[r][c] = '.';
+ return false;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+
#include <iostream>
+#include <string>
+
+using namespace std;
+
+string def, append;
+char input[130];
+
+void print();
+
+int main() {
+ cin.getline(input, 130);
+
+ int i = 0;
+ while (input[i] != ' ') {
+ def.push_back(input[i]);
+ i++;
+ }
+
+ for (; input[i] != ';'; i++) {
+ if (input[i] != ',')
+ append.push_back(input[i]);
+ else
+ print();
+ }
+ print();
+}
+
+void print() {
+ cout << def;
+ int j = append.size() - 1;
+ for (; j >= 0; j--) {
+ if (append[j] == '&' || append[j] == '*')
+ cout << append[j];
+ else if (append[j] == ']') {
+ cout << "[]";
+ j--;
+ }
+ else
+ break;
+ }
+ cout << " ";
+ for (int k = 1; k <= j; k++) {
+ if ((append[k] >= 'a' && append[k] <= 'z') || (append[k] >= 'A' && append[k] <= 'Z'))
+ cout << append[k];
+ }
+ cout << ";" << endl;
+ append.clear();
+}
+
Comments powered by Disqus.
1
+2
+
1. 모든 별들 사이의 거리를 구한 다음에, 두 별의 위치, 거리를 저장한 구조체 배열을 거리순으로 오름차순 정렬
+2. 구조체 배열에서 하나씩 빼가며 크루스칼 시행 -> edge == numOfStar -1 이면 중지 후 출력
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+
#include <iostream>
+#include <vector>
+#include <cmath>
+#include <cstdio>
+#include <algorithm>
+#define MAX_STAR 100
+
+using namespace std;
+
+typedef struct Star {
+ double x;
+ double y;
+} Star;
+typedef struct Distance {
+ int first;
+ int second;
+ double distance;
+ bool operator <(Distance d) {
+ return distance < d.distance;
+ }
+} Distance;
+
+Star star[MAX_STAR];
+Distance dist[(MAX_STAR * (MAX_STAR+1))/2];
+int numOfStar, checkStar[MAX_STAR], distIndex;
+vector<vector<int>> set;
+
+double getMinDistance();
+void generateDistance();
+bool unionFind(int a, int b);
+
+int main() {
+ cin >> numOfStar;
+ for (int i = 0; i < numOfStar; i++) {
+ cin >> star[i].x >> star[i].y;
+ }
+ for (int i = 0; i < numOfStar; i++)
+ checkStar[i] = -1;
+
+ cout.precision(20);
+ cout << getMinDistance();
+}
+
+double getMinDistance() {
+ generateDistance();
+ sort(dist, dist + distIndex);
+
+ double value = 0;
+ int edge = 0;
+ for (int i = 0; i < distIndex; i++) {
+ if (unionFind(dist[i].first, dist[i].second)) {
+ value += dist[i].distance;
+ edge++;
+ }
+ if (edge == numOfStar - 1)
+ break;
+ }
+ return value;
+}
+
+void generateDistance() {
+ for (int i = 0; i < numOfStar; i++) {
+ for (int j = i + 1; j < numOfStar; j++) {
+ dist[distIndex].first = i;
+ dist[distIndex].second = j;
+ dist[distIndex++].distance = sqrt(((star[i].x - star[j].x) * (star[i].x - star[j].x)) + ((star[i].y - star[j].y) * (star[i].y - star[j].y)));
+ }
+ }
+}
+
+bool unionFind(int a, int b) {
+ if (checkStar[a] == -1 && checkStar[b] == -1) {
+ set.push_back({ a, b });
+ checkStar[a] = set.size() - 1;
+ checkStar[b] = set.size() - 1;
+ }
+ else if (checkStar[a] == -1) {
+ set[checkStar[b]].push_back(a);
+ checkStar[a] = checkStar[b];
+ }
+ else if (checkStar[b] == -1) {
+ set[checkStar[a]].push_back(b);
+ checkStar[b] = checkStar[a];
+ }
+ else if (checkStar[a] != checkStar[b]) {
+ int temp = checkStar[b];
+ for (int i = 0; i < set[temp].size(); i++) {
+ set[checkStar[a]].push_back(set[temp][i]);
+ checkStar[set[temp][i]] = checkStar[a];
+ }
+ set[temp].clear();
+ }
+ else
+ return false;
+ return true;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+
#include <iostream>
+#include <queue>
+#define INF 2000000000
+using namespace std;
+
+int n, map[125][125], os[4][2] = { {-1, 0}, {0, 1}, {1, 0}, {0, -1} }, save[125][125];
+bool check[125][125];
+priority_queue<pair<int, pair<int,int>>> q;
+
+int dijk();
+int min(int a, int b) {
+ return a > b ? b : a;
+}
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+
+ int idx = 1;
+ while (true) {
+ cin >> n;
+ if (n == 0)
+ break;
+
+ for (int i = 0; i < n; i++)
+ for (int j = 0; j < n; j++) {
+ cin >> map[i][j];
+ check[i][j] = false;
+ }
+
+ cout << "Problem " << idx++ << ": " << dijk() << endl;
+ }
+}
+
+int dijk() {
+ q.push({ -map[0][0] , {0,0 } });
+ save[0][0] = map[0][0];
+
+ while (!q.empty()) {
+ int cur = -q.top().first, r = q.top().second.first, c = q.top().second.second;
+ q.pop();
+
+ if (check[r][c])
+ continue;
+ check[r][c] = true;
+ save[r][c] = cur;
+
+ for (int i = 0; i < 4; i++) {
+ int nr = r + os[i][0], nc = c + os[i][1];
+
+ if (nr >= 0 && nr < n && nc >= 0 && nc < n && !check[nr][nc]) {
+ int ncur = cur + map[nr][nc];
+ q.push({ -ncur, {nr, nc} });
+ }
+ }
+ }
+
+ return save[n - 1][n - 1];
+}
+
Comments powered by Disqus.
1
+2
+
1. 하나의 완전한 알약을 one, 반쪽 알약을 half 라고 하면, dp[1001][1001] 를 선언하고, one, half를 기준으로 dp를 저장함
+2. dp를 진행하면서 밑으로 내려가면서 one이 1개 이상이면 1 줄이고 half 1 증가하고 밑으로 내려갈 수 있고, half가 1개 이상이면 마찬가지로.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+
#include <iostream>
+
+using namespace std;
+
+long long dp[1001][1001];
+
+long long DP(int one, int half);
+
+int main() {
+ int N;
+ while (true) {
+ cin >> N;
+ if (N == 0)
+ break;
+ cout << DP(N, 0) << endl;
+ }
+}
+
+long long DP(int one, int half) {
+ if (one == 0 && half == 0)
+ return 1;
+ if (dp[one][half] != 0)
+ return dp[one][half];
+
+ long long result = 0;
+ if (one > 0)
+ result += DP(one - 1, half + 1);
+ if (half > 0)
+ result += DP(one, half - 1);
+
+ return dp[one][half] = result;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+
1. 구현이 더 중요한 문제.
+2. 그냥 시작 + 각 더러운 곳(DT) 에서 다른 DT로의 최소 거리를 저장한 2차원 배열을 BFS로 만들고
+3. 시작부터 모든 경로를 탐색하여 최소 거리를 뽑아내면 됨.
+4. 방문 할 수 없는지 판별은 시작에서 갈 수 없는 DT가 있는지 확인하면 됨
+
1
+2
+3
+4
+5
+6
+
1. 거리 저장한 2차원 배열은, 최대 DT가 10개이므로 [11][11] 로 선언함
+ 이때, 0은 시작장소를 뜻함
+ 따라서 각 줄의 0번째 칸과 자기자신은 0이어야함
+
+2. 시작하는 곳과 DT의 위치를 배열에 저장함.
+3. 맵에서 시작하는 곳은 '0' 으로, 나머지 각 DT는 '0' + 2. 배열 상의 index 로 BFS시 바로바로 참조가능하게 한다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+
#include <iostream>
+#include <cstring>
+#define MAX_WIDTH 20
+
+using namespace std;
+
+typedef struct Location {
+ int row;
+ int col;
+ int length;
+} Location;
+
+int w, h, numOfD = 1, eachOther[11][11];
+char map[MAX_WIDTH][MAX_WIDTH];
+Location q[MAX_WIDTH * MAX_WIDTH], node[11];
+bool visit[MAX_WIDTH][MAX_WIDTH], visitDistance[11];
+
+void BFS(Location s);
+int minDistance(int d, int cur);
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+
+int main() {
+ while (true) {
+ cin >> w >> h;
+ if (w == 0 && h == 0)
+ break;
+
+ for (int i = 0; i < h; i++)
+ for (int j = 0; j < w; j++) {
+ cin >> map[i][j];
+ if (map[i][j] == 'o') {
+ map[i][j] = '0'; // start는 0, 더티는 1~10
+ node[0] = { i, j };
+ }
+ else if (map[i][j] == '*') {
+ node[numOfD] = { i, j };
+ map[i][j] = '0' + numOfD++;
+ }
+ }
+
+ for (int i = 0; i < numOfD; i++)
+ BFS(node[i]);
+
+ int count = 0;
+ for (int i = 1; i < numOfD; i++)
+ if (eachOther[0][i] > 0)
+ count++;
+
+ if (count < numOfD - 1)
+ cout << -1 << endl;
+ else
+ cout << minDistance(0, 0) << endl;
+
+ numOfD = 1;
+ memset(eachOther, 0, sizeof(eachOther));
+ }
+}
+
+void BFS(Location s) {
+ //start면 0, 더러운 곳이면 1~10 들어감
+ int cur = map[s.row][s.col] - '0';
+
+ int length = 0, index = 0;
+ q[length++] = { s.row, s.col, 0 };
+ visit[s.row][s.col] = true;
+
+ while (index < length) {
+ int row = q[index].row, col = q[index].col, l = q[index++].length;
+
+ if (map[row][col] - '0' >= 1 && map[row][col] - '0' <= 10) {
+ eachOther[cur][map[row][col] - '0'] = l;
+ }
+
+ if (row > 0 && !visit[row - 1][col] && map[row - 1][col] != 'x') {
+ q[length++] = { row - 1,col, l + 1 };
+ visit[row - 1][col] = true;
+ }
+ if (row < h - 1 && !visit[row + 1][col] && map[row + 1][col] != 'x') {
+ q[length++] = { row + 1,col, l + 1 };
+ visit[row + 1][col] = true;
+ }
+ if (col > 0 && !visit[row][col - 1] && map[row][col - 1] != 'x') {
+ q[length++] = { row,col - 1, l + 1 };
+ visit[row][col - 1] = true;
+ }
+ if (col < w - 1 && !visit[row][col + 1] && map[row][col + 1] != 'x') {
+ q[length++] = { row, col + 1, l + 1 };
+ visit[row][col + 1] = true;
+ }
+ }
+ for (int i = 0; i < length; i++)
+ visit[q[i].row][q[i].col] = false;
+}
+
+int minDistance(int d, int cur) {
+ int result = 2000000000;
+ bool check = true;
+
+ for (int i = 1; i < numOfD; i++) {
+ if (!visitDistance[i]) {
+ visitDistance[i] = true;
+ result = min(result, minDistance(d + eachOther[cur][i], i));
+ visitDistance[i] = false;
+ check = false;
+ }
+ }
+
+ if (check)
+ return d;
+ else
+ return result;
+}
+
Comments powered by Disqus.
1
+2
+3
+
- 직선으로의 BFS 를 사용하면 됨
+- DP를 사용하면 시간초과가 발생함.
+ - 도달시 다 종료한다고 해도, 그게 최소로 간건지 몰라서 결국 더 검사해야함.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+
#include <iostream>
+#include <list>
+
+using namespace std;
+
+list<pair<int, int>> q;
+int F, G, S, U, D;
+bool check[1000001];
+
+int main() {
+ cin >> F >> S >> G >> U >> D;
+
+ q.push_back({ S, 0 });
+ check[S] = true;
+ bool canGo = false;
+ while (!q.empty()) {
+ int c = q.front().first, deep = q.front().second;
+ q.pop_front();
+
+ if (c == G) {
+ cout << deep << endl;
+ canGo = true;
+ break;
+ }
+ if (c + U <= F && !check[c+U]) {
+ q.push_back({ c + U, deep + 1 });
+ check[c + U] = true;
+ }
+ if (c - D >= 1 && !check[c-D]) {
+ q.push_back({ c - D, deep + 1 });
+ check[c - D] = true;
+ }
+ }
+ if (!canGo)
+ cout << "use the stairs" << endl;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+
#include <iostream>
+#include <vector>
+#include <list>
+#include <cstring>
+using namespace std;
+
+int N, tile[250000][2], last, visit[250000];
+vector<int> graph[250000], path;
+list<int> l;
+
+void makeGraph();
+void bfs();
+
+int main() {
+ cin >> N;
+ last = N * N - N / 2;
+ for (int i = 1; i <= last; i++)
+ cin >> tile[i][0] >> tile[i][1];
+
+ makeGraph();
+
+ memset(visit, -1, sizeof(visit));
+ bfs();
+
+ cout << path.size() << endl;
+ for (int j = path.size() -1; j >=0; j--)
+ cout << path[j] << " ";
+}
+
+void makeGraph() {
+ for (int i = 1; i <= N; i++) {
+ int end, start;
+ if (i % 2 == 0) { // 짝수줄
+ end = N - 1;
+ start = N * (i / 2) + (N - 1) * ((i / 2) - 1);
+ }
+ else { // 홀수줄
+ end = N;
+ start = N * (i / 2) + (N - 1) * (i / 2);
+ }
+
+ // 좌우, +-N, +-(N-1), 이때 홀수번째 처음은 +N-1, -N 안되고, 마지막은 +N, -N-1 안됨
+ for (int j = start + 1; j <= start + end; j++) {
+ if (j != start + 1 || i % 2 == 0) { // 왼쪽
+ if (tile[j - 1][1] == tile[j][0] && j != start + 1)
+ graph[j].push_back(j - 1);
+ if (j - N >= 1 && tile[j - N][1] == tile[j][0]) // -N
+ graph[j].push_back(j - N);
+ if (j + N - 1 <= last && tile[j + N - 1][1] == tile[j][0]) // +N-1
+ graph[j].push_back(j + N - 1);
+ }
+ if (j != start + end || i % 2 == 0) { // 오른쪽
+ if (tile[j + 1][0] == tile[j][1] && j != start + end)
+ graph[j].push_back(j + 1);
+ if (j - N + 1 >= 1 && tile[j - N + 1][0] == tile[j][1]) // -(n-1)
+ graph[j].push_back(j - N + 1);
+ if (j + N <= last && tile[j + N][0] == tile[j][1]) // + N
+ graph[j].push_back(j + N);
+ }
+ }
+ }
+}
+// 다익스트라 후 검증으로 길찾기
+void bfs() {
+ visit[1] = 0;
+ l.push_back(1);
+ while (!l.empty()) {
+ int cur = l.front();
+ l.pop_front();
+
+ for (int i = 0; i < graph[cur].size(); i++) {
+ int next = graph[cur][i];
+ if (visit[next] == -1) {
+ visit[next] = cur;
+ l.push_back(next);
+ }
+ }
+ }
+
+ int first = 0;
+ for (int i = last; i >= 1; i--) {
+ if (visit[i] != -1) {
+ first = visit[i];
+ path.push_back(i);
+ break;
+ }
+ }
+
+ int cur = first;
+ while (cur != 0) {
+ path.push_back(cur);
+ cur = visit[cur];
+ }
+ return;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+
#include <iostream>
+#include <cstring>
+#define MAX_ROTATE 1000
+#define MAX_TESTCASE 100
+#define WHITE 100
+#define YELLOW 200
+#define RED 300
+#define ORANGE 400
+#define GREEN 500
+#define BLUE 600
+
+using namespace std;
+
+typedef struct Command {
+ int location; //큐브 면
+ int way; //0이 반시계, 1은 시계
+} Command;
+
+int cube[6][9]; //0이 위, 1이 뒤, 2가 오, 3은 앞, 4는 왼쪽, 5는 아래
+int numOfTestcase;
+Command testcase[MAX_TESTCASE][MAX_ROTATE];
+int numOfCommand[MAX_TESTCASE];
+
+void implementTestcases();
+void implementSingleTC(Command command[MAX_ROTATE], int numCommand);
+void implementSingleCommand(int index[4], int cubeIndex[4][3], int way, int location);
+void printCube();
+void initCube();
+
+int main() {
+ cin >> numOfTestcase;
+ for (int i = 0; i < numOfTestcase; i++) {
+ cin >> numOfCommand[i];
+ for (int j = 0; j < numOfCommand[i]; j++) {
+ char temp;
+ cin >> temp;
+
+ if (temp == 'U') testcase[i][j].location = 0;
+ else if (temp == 'D') testcase[i][j].location = 5;
+ else if (temp == 'F') testcase[i][j].location = 3;
+ else if (temp == 'B') testcase[i][j].location = 1;
+ else if (temp == 'L') testcase[i][j].location = 4;
+ else if (temp == 'R') testcase[i][j].location = 2;
+
+ cin >> temp;
+ if (temp == '+') testcase[i][j].way = 1;
+ else if (temp == '-') testcase[i][j].way = 0;
+ }
+ }
+ implementTestcases();
+}
+
+void initCube() {
+ int colors[6] = { WHITE, ORANGE, BLUE, RED, GREEN, YELLOW };
+ for (int i = 0; i < 6; i++)
+ for (int j = 0; j < 9; j++)
+ cube[i][j] = colors[i];
+}
+
+void implementTestcases() {
+ for (int i = 0; i < numOfTestcase; i++) {
+ initCube();
+ implementSingleTC(testcase[i], numOfCommand[i]);
+ printCube();
+ }
+}
+
+void implementSingleTC(Command command[MAX_ROTATE], int numCommand) {
+ for (int i = 0; i < numCommand; i++) {
+ if (command[i].location == 0) { //윗
+ int index[4] = { 1,2,3,4 };
+ int cubeIndex[4][3] = { {0,1,2},{0,1,2},{0,1,2},{0,1,2} };
+ implementSingleCommand(index, cubeIndex,command[i].way, 0);
+ }
+ else if (command[i].location == 1) { //뒤
+ int index[4] = { 0,4,5,2 };
+ int cubeIndex[4][3] = { {2,1,0}, {0,3,6}, {2,1,0}, {8,5,2} };
+ implementSingleCommand(index, cubeIndex, command[i].way, 1);
+ }
+ else if (command[i].location == 2) { //오
+ int index[4] = { 0,1,5,3 };
+ int cubeIndex[4][3] = { {8,5,2}, {0,3,6}, {0,3,6}, {8,5,2} };
+ implementSingleCommand(index, cubeIndex, command[i].way, 2);
+ }
+ else if (command[i].location == 3) { //앞
+ int index[4] = { 0,2,5,4 };
+ int cubeIndex[4][3] = { {6,7,8}, {0,3,6}, {6,7,8}, {8,5,2} };
+ implementSingleCommand(index, cubeIndex, command[i].way, 3);
+ }
+ else if (command[i].location == 4) { //왼
+ int index[4] = { 0,3,5,1 };
+ int cubeIndex[4][3] = { {0,3,6}, {0,3,6}, {8,5,2}, {8,5,2} };
+ implementSingleCommand(index, cubeIndex, command[i].way, 4);
+ }
+ else if (command[i].location == 5) { //아
+ int index[4] = { 1,4,3,2 };
+ int cubeIndex[4][3] = { {6,7,8}, {6,7,8},{6,7,8},{6,7,8} };
+ implementSingleCommand(index, cubeIndex, command[i].way, 5);
+ }
+ }
+}
+
+void implementSingleCommand(int index[4], int cubeIndex[4][3], int way, int location) {
+ if (way == 1) {
+ int first = index[0];
+ int temp[3] = { cube[first][cubeIndex[0][0]], cube[first][cubeIndex[0][1]], cube[first][cubeIndex[0][2]] };
+ for (int r = 1; r < 4; r++) {
+ int temp2[3] = { cube[index[r]][cubeIndex[r][0]], cube[index[r]][cubeIndex[r][1]], cube[index[r]][cubeIndex[r][2]] };
+ cube[index[r]][cubeIndex[r][0]] = temp[0];
+ cube[index[r]][cubeIndex[r][1]] = temp[1];
+ cube[index[r]][cubeIndex[r][2]] = temp[2];
+ memcpy(temp, temp2, sizeof(int) * 3);
+ }
+ cube[first][cubeIndex[0][0]] = temp[0];
+ cube[first][cubeIndex[0][1]] = temp[1];
+ cube[first][cubeIndex[0][2]] = temp[2];
+ }
+ else {
+ int last = index[3];
+ int temp[3] = { cube[last][cubeIndex[3][0]], cube[last][cubeIndex[3][1]], cube[last][cubeIndex[3][2]] };
+ for (int r = 2; r >= 0; r--) {
+ int temp2[3] = { cube[index[r]][cubeIndex[r][0]], cube[index[r]][cubeIndex[r][1]], cube[index[r]][cubeIndex[r][2]] };
+ cube[index[r]][cubeIndex[r][0]] = temp[0];
+ cube[index[r]][cubeIndex[r][1]] = temp[1];
+ cube[index[r]][cubeIndex[r][2]] = temp[2];
+ memcpy(temp, temp2, sizeof(int) * 3);
+ }
+ cube[last][cubeIndex[3][0]] = temp[0];
+ cube[last][cubeIndex[3][1]] = temp[1];
+ cube[last][cubeIndex[3][2]] = temp[2];
+ }
+
+
+ int tempIndex[4][3] = { {0,1,2}, {2,5,8}, {8,7,6}, {6, 3, 0} };
+ int tempValue[4][3] = { {cube[location][0], cube[location][1], cube[location][2]}, {cube[location][2], cube[location][5], cube[location][8]},
+ {cube[location][8], cube[location][7], cube[location][6] }, {cube[location][6], cube[location][3], cube[location][0]} };
+ if (way == 1) {
+ for (int i = 1; i < 4; i++) {
+ cube[location][tempIndex[i][0]] = tempValue[i - 1][0];
+ cube[location][tempIndex[i][1]] = tempValue[i - 1][1];
+ cube[location][tempIndex[i][2]] = tempValue[i - 1][2];
+ }
+ cube[location][0] = tempValue[3][0];
+ cube[location][1] = tempValue[3][1];
+ cube[location][2] = tempValue[3][2];
+ }
+ else {
+ for (int i = 2; i >= 0; i--) {
+ cube[location][tempIndex[i][0]] = tempValue[i + 1][0];
+ cube[location][tempIndex[i][1]] = tempValue[i + 1][1];
+ cube[location][tempIndex[i][2]] = tempValue[i + 1][2];
+ }
+ cube[location][6] = tempValue[0][0];
+ cube[location][3] = tempValue[0][1];
+ cube[location][0] = tempValue[0][2];
+ }
+}
+
+void printCube() {
+ for (int i = 0; i < 9; i++) {
+ char temp;
+ if (cube[0][i] == WHITE)
+ temp = 'w';
+ else if (cube[0][i] == ORANGE)
+ temp = 'o';
+ else if (cube[0][i] == RED)
+ temp = 'r';
+ else if (cube[0][i] == GREEN)
+ temp = 'g';
+ else if (cube[0][i] == BLUE)
+ temp = 'b';
+ else if (cube[0][i] == YELLOW)
+ temp = 'y';
+ cout << temp;
+ if (i % 3 == 2)
+ cout << endl;
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+
#include <iostream>
+#include <list>
+#define INF 2000000000
+
+using namespace std;
+
+int n, m, os[2] = { 1, -1 }, visit[500][500][2], ans = INF;
+char map[500][500];
+pair<int, int> c;
+list<pair<pair<int, int>, pair<bool, int>>> l;
+bool meetD;
+
+bool fall(bool g, int* r, int* c);
+void bfs();
+void afterCheck(int *r, int *c, bool g, int f);
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+
+int main() {
+ cin >> n >> m;
+ for (int i = 0; i < n; i++) {
+ string s;
+ cin >> s;
+ for (int j = 0; j < m; j++) {
+ map[i][j] = s[j];
+ if (s[j] == 'C')
+ c = { i, j };
+ visit[i][j][0] = visit[i][j][1] = INF;
+ }
+ }
+
+ if (!fall(0, &c.first, &c.second)) {
+ cout << -1;
+ return 0;
+ }
+
+ bfs();
+ if (ans != INF)
+ cout << ans;
+ else
+ cout << -1;
+}
+
+bool fall(bool g, int* r, int* c) {
+ while (((g == 0 && *r < n - 1) || (g == 1 && *r > 0)) && map[*r + os[g]][*c] != '#') {
+ if (map[*r][*c] == 'D')
+ meetD = true;
+ *r += os[g];
+ }
+
+ if (map[*r][*c] == 'D')
+ meetD = true;
+
+ if ((g == 0 && *r == n - 1) || (g == 1 && *r == 0))
+ return false;
+ return true;
+}
+
+void bfs() {
+ l.push_back({ {c.first, c.second}, {0,0} });
+ visit[c.first][c.second][0] = 0;
+
+ while (!l.empty()) {
+ int cr = l.front().first.first, cc = l.front().first.second, g = l.front().second.first, f = l.front().second.second;
+ l.pop_front();
+
+ if (map[cr][cc] == 'D') {
+ ans = min(ans, f);
+ continue;
+ }
+
+ for (int i = 0; i < 2; i++) {
+ int nr = cr, nc = cc + os[i];
+ if (nc >= 0 && nc < m && f < visit[nr][nc][g] && map[nr][nc] != '#')
+ afterCheck(&nr, &nc, g, f);
+ }
+
+ if (++f < visit[cr][cc][!g])
+ afterCheck(&cr, &cc, !g, f);
+ }
+}
+
+void afterCheck(int* r, int* c, bool g, int f) {
+ visit[*r][*c][g] = f;
+ bool temp = fall(g, r, c);
+
+ if (meetD) {
+ meetD = false;
+ ans = min(ans, f);
+ }
+ else if (temp) {
+ visit[*r][*c][g] = f;
+ l.push_back({ {*r,*c}, {g, f} });
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+
1. n 을 M과 N으로 나누었을때 나온 수가 x와 y 이면 된다.
+ 단, 나누었을때 나오는 수는 0~M-1 or N-1인데 문제에선 1~M, 1~N 까지이므로 이걸 고려해야한다.
+2. 하나씩 증가시켜가면서하면 너무 오래걸리니, M과 N 중 더 큰수를 더하는 수로 삼고, 그것과 연결된 수부터 시작한다(M-x, N-y)
+ ex) 10 12 3 4 이면 4부터 시작하여 12씩 더함
+ 각 단계의 수를 10과 12로 나누어서 3과 4가 나오면 가능한 것.
+3. 이때 M과 N이 같을 경우 x, y이 다르게 나오면 바로 -1 을 출력하도록 해야 틀리지 않는다.
+4. 2를 최소공배수 이하일때까지만 검사하는데, 최소공배수 구하긴 귀찮으므로 M*N 이하일 때까지 검사하자.
+ 최대 N 번 검사하는게 고작이고, N 은 최대 4만이다. (M < N일때)
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+
#include <iostream>
+
+using namespace std;
+
+int M, N, x, y;
+
+int main() {
+ int tc;
+ cin >> tc;
+ while (tc--) {
+ cin >> M >> N >> x >> y;
+
+ int result = 0, lap, start;
+
+ if (M > N) {
+ lap = M;
+ start = x;
+ }
+ else if(M < N) {
+ lap = N;
+ start = y;
+ }
+ else if (x != y) {
+ cout << -1 << endl;
+ continue;
+ }
+ else {
+ lap = N;
+ start = y;
+ }
+
+ while (start <= M * N) {
+ int t1 = start % M == 0 ? M : start % M;
+ int t2 = start % N == 0 ? N : start % N;
+
+ if (t1 == x && t2 == y) {
+ result = start;
+ break;
+ }
+ start += lap;
+ }
+
+ if (result == 0)
+ cout << -1 << endl;
+ else
+ cout << result << endl;
+ }
+}
+
Comments powered by Disqus.
1
+2
+
1. visit 배열을 int로 선언. 이제까지 온 것들의 거울 개수를 저장
+2. 갈 수 잇고, visit에 저장된 거울 개수와 같거나 작으면 이동 시킴
+
1
+2
+3
+4
+
같은 레이저에 도달하지 않기위해 설정한 row != start.row && col != start.col 은 작동하지 않음
+-> 같은 줄에만 있어도 애들이 안가기 때문
+-> 따라서 다음처럼 조건문을 짜야함.
+ row != start.row || col != start.col
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+
#include <iostream>
+#include <list>
+
+using namespace std;
+
+typedef struct Location {
+ int row;
+ int col;
+ int direction; // 0 : 초기, 1 : 위 2 오 3 아 4 왼
+ int mirror;
+} Location;
+
+int R, C;
+Location start;
+char map[100][100];
+int visit[100][100];
+int BFS();
+
+int main() {
+ cin >> C >> R;
+ for (int i = 0; i < R; i++)
+ for (int j = 0; j < C; j++) {
+ cin >> map[i][j];
+ if (map[i][j] == 'C') {
+ start.row = i;
+ start.col = j;
+ }
+ visit[i][j] = 2000000000;
+ }
+ cout << BFS();
+}
+int BFS() {
+ list<Location> q;
+ q.push_back({ start.row, start.col, 0, 0 });
+ visit[start.row][start.col] = 0;
+ int minMirror = 2000000000;
+
+ while (!q.empty()) {
+ int row = q.front().row, col = q.front().col, d = q.front().direction, m = q.front().mirror;
+ q.pop_front();
+
+
+ if ( map[row][col] == 'C') {
+ minMirror = m;
+ }
+ if (row > 0 && map[row - 1][col] != '*' && d != 3) {
+ int nextMirror = d != 4 ? d != 2 ? m : m + 1 : m + 1;
+ if (nextMirror <= visit[row - 1][col]) {
+ q.push_back({ row - 1, col, 1, nextMirror });
+ visit[row - 1][col] = nextMirror;
+ }
+ }
+ if (row < R - 1 && map[row + 1][col] != '*' && d != 1) {
+ int nextMirror = d != 4 ? d != 2 ? m : m + 1 : m + 1;
+ if (nextMirror <= visit[row + 1][col]) {
+ q.push_back({ row + 1, col, 3, nextMirror });
+ visit[row + 1][col] = nextMirror;
+ }
+ }
+ if (col > 0 && map[row][col - 1] != '*' && d != 2) {
+ int nextMirror = d != 3 ? d != 1 ? m : m + 1 : m + 1;
+ if (nextMirror <= visit[row][col - 1]) {
+ q.push_back({ row, col - 1, 4, nextMirror });
+ visit[row][col - 1] = nextMirror;
+ }
+ }
+ if (col < C - 1 && map[row][col + 1] != '*'&& d != 4) {
+ int nextMirror = d != 3 ? d != 1 ? m : m + 1 : m + 1;
+ if (nextMirror <= visit[row][col + 1]) {
+ q.push_back({ row, col + 1, 2, nextMirror });
+ visit[row][col + 1] = nextMirror;
+ }
+ }
+ }
+ return minMirror;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+
1. 앞 두개 정수의 합 배열, 뒤 두개 정수의 합 배열을 만듬.(배열 개수^2 가 합 배열의 길이)
+2. 두 배열을 정렬
+3. 앞 합 배열의 원소를 하나씩 빼며 검사 -> 뒤 합 배열에서, upper_bound - lower_bound 값이, 현재 원소에서의 count 값.
+4. count 를 더하고 다음 원소 검사
+5. count 값을 long long 으로 선언
+
1
+
1. lower_bound, upper_bound 로 몇개있는지 구하고, 그걸 count 에 더하는 식으로 구현
+
1
+2
+3
+4
+5
+6
+7
+8
+
1. 합 배열에 중복된 값이 들어가는 게 문제.
+2. 구조체를 선언하고, 합과, 그 합이 몇번 나왔는지 저장하는 방법
+ -> 먼저 합 배열을 만들고, 같은 값이 나올 때마다, 같은 값의 가장 앞에 있는 곳에 count를 하나씩 증가하고 뒤에있는 같은 값은 sum을 -1로 만들어 버린다.
+ -> 그리고 값이 달라질때마다 count를 1씩 증가하여, 압축한 길이가 몇인지 구하기.
+ -> 값을 찾을 때는 이분탐색으로 찾는다.
+3. 앞보단 느리지만, 앞 합배열의 원소를 꺼낼때, 같은 원소면 바로 통과하도록 하기
+ -> 앞에서 연산한 결과를 이용하여 바로 통과시키자.
+ -> 130ms 줄임
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+
#include <iostream>
+#include <algorithm>
+#define MAX_ARRAY 4000
+
+using namespace std;
+
+int intArray[MAX_ARRAY][4];
+int firstTwo[MAX_ARRAY*MAX_ARRAY], lastTwo[MAX_ARRAY * MAX_ARRAY];
+int numOfArray;
+
+void generateSum();
+long long getCount();
+
+int main() {
+ cin >> numOfArray;
+ for (int i = 0; i < numOfArray; i++) {
+ for (int j = 0; j < 4; j++)
+ cin >> intArray[i][j];
+ }
+
+ generateSum();
+ sort(firstTwo, firstTwo + numOfArray*numOfArray);
+ sort(lastTwo, lastTwo + numOfArray*numOfArray);
+ cout << getCount();
+}
+
+void generateSum() {
+ int index = 0;
+ for (int i = 0; i < numOfArray; i++) {
+ for (int j = 0; j < numOfArray; j++) {
+ firstTwo[index] = intArray[i][0] + intArray[j][1];
+ lastTwo[index++] = intArray[i][2] + intArray[j][3];
+ }
+ }
+}
+
+long long getCount() {
+ long long count = 0;
+ int save[2] = { -1,-1 };
+ for (int i = 0; i < numOfArray*numOfArray; i++) {
+ int temp;
+ if (save[0] == firstTwo[i])
+ temp = save[1];
+ else
+ temp = (upper_bound(lastTwo, lastTwo + numOfArray * numOfArray, 0 - firstTwo[i])
+ - lower_bound(lastTwo, lastTwo + numOfArray * numOfArray, 0 - firstTwo[i]));
+ save[0] = firstTwo[i];
+ save[1] = temp;
+ count += temp;
+ }
+ return count;
+}
+
Comments powered by Disqus.
1
+2
+
1. 배낭정리 응용. 최대 비용을 가방에 담을 수 있는 최대 무게로 보고, 메모리를 가치로 본다
+2. 이렇게 2차원 배열을 완성하고, 필요한 메모리 이상이며 비용이 최소인 칸을 판별하고 출력하면 된다.
+
1
+2
+
1. 최대 앱 개수는 100개이므로, 101행, 앱 당 최대 비용은 100 이므로 10001열을 선언하여 구현하면 됨.
+2. 2차원 배열 완성하고나서는 첫번째 원소부터 검사하여, 메모리가 필요이상으로 있는데, 비용이 최소인 것을 찾으면 됨.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+
#include <iostream>
+#define MAX_N 100
+#define MAX_MEMORY 10000000
+
+using namespace std;
+
+int numOfApp, a[MAX_N], c[MAX_N], m, maxValue;
+int DP[105][10020];
+
+int getMin();
+int max(int a, int b) {
+ return a > b ? a : b;
+}
+
+int main() {
+ cin >> numOfApp >> m;
+ for (int i = 0; i < numOfApp; i++)
+ cin >> a[i];
+ for (int i = 0; i < numOfApp; i++) {
+ cin >> c[i];
+ maxValue += c[i];
+ }
+
+ cout << getMin();
+}
+
+int getMin(){
+ for (int i = 1; i <= numOfApp; i++) {
+ for (int j = 1; j <= maxValue; j++) {
+ if (c[i-1] > j)
+ DP[i][j] = DP[i - 1][j];
+ else
+ DP[i][j] = max(a[i-1] + DP[i - 1][j - c[i-1]], DP[i - 1][j]);
+ }
+ }
+
+ int minValue = 2000000000;
+ for (int i = 0; i <= numOfApp; i++) {
+ for (int j = 0; j <= maxValue; j++) {
+ if (DP[i][j] >= m && minValue > j)
+ minValue = j;
+ }
+ }
+ return minValue;
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+
1. 각 도착지별로 정보를 따로 관리함.(같이해도 되긴함)
+2. 도착지 1~N번까지 입력받은 C로 트럭 용량을 초기화함.
+3. 도착지 2번부터 정보를 하나씩 뽑아가며 검사. 시작지점~현재 도착지-1 까지에서의 최소값을 뽑고, 그만큼을 2의 배열에서 빼줌.(물론 그 최솟값이 현재 정보에서의 택배량보다 많으면 택배량으로 제한.)
+
+* 최솟값으로 뽑을 경우, 최대한 많이 담는 것이므로, 그것이 결국 최댓값이 됨.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+
#include <iostream>
+#include <algorithm>
+#include <vector>
+using namespace std;
+
+vector<pair<int, int>> list[2021];
+int N, C, M, capacity[2021];
+
+int min(int a, int b) {
+ return a < b ? a : b;
+}
+
+int main() {
+ cin >> N >> C >> M;
+ for (int i = 0; i < M; i++) {
+ int a, b, c;
+ cin >> a >> b >> c;
+ list[b].push_back({ a,c });
+ }
+ for (int i = 1; i <= N; i++) {
+ capacity[i] = C;
+ sort(list[i].begin(), list[i].end());
+ }
+
+ int shipped = 0;
+
+ for (int i = 2; i <= N; i++) {
+ for (int j = list[i].size() - 1; j >= 0; j--) {
+ int s = list[i][j].first, box = list[i][j].second, m = 2000000000;
+ for (int k = s; k < i; k++) {
+ m = min(m, capacity[k]);
+ }
+ int howMany = min(box, m);
+ for (int k = s; k < i; k++)
+ capacity[k] -= howMany;
+ shipped += howMany;
+ }
+ }
+
+
+ cout<< shipped;
+}
+
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+
#include <iostream>
+
+using namespace std;
+
+int tc;
+long long save[12];
+
+long long dp(int n);
+
+int main() {
+ cin >> tc;
+
+ while (tc--) {
+ int n;
+ cin >> n;
+ cout << dp(n) << endl;
+ }
+}
+
+long long dp(int n) {
+ if (n < 0)
+ return 0;
+ if (n == 0) {
+ return 1;
+ }
+ if (save[n] != 0)
+ return save[n];
+
+ return save[n] = dp(n - 3) + dp(n-2) + dp(n-1);
+
+}
+
Comments powered by Disqus.
https://velog.io/@emplam27/%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-%EA%B7%B8%EB%A6%BC%EC%9C%BC%EB%A1%9C-%EC%95%8C%EC%95%84%EB%B3%B4%EB%8A%94-LCS-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-Longest-Common-Substring%EC%99%80-Longest-Common-Subsequence
LCS 알고리즘을 굉장히 잘 설명한 글이 있어 링크로 대체
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+
#include <iostream>
+using namespace std;
+
+string s[2];
+int map[1011][1011];
+
+int max(int a, int b) {
+ return a < b ? b : a;
+}
+
+int main() {
+ cin >> s[0] >> s[1];
+
+ for (int i = 1; i <= s[1].size(); i++) {
+ for (int j = 1; j <= s[0].size(); j++) {
+ if (s[1][i - 1] == s[0][j - 1])
+ map[i][j] = map[i - 1][j - 1] + 1;
+ else
+ map[i][j] = max(map[i - 1][j], map[i][j - 1]);
+ }
+ }
+
+ cout << map[s[1].size()][s[0].size() ];
+}
+
Comments powered by Disqus.
1
+
1. LCS 알고리즘 사용하면 됨
+
1
+
1. 문자열 입력 받을 땐. cin.getline(char *c, size) 넣으면 된다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+
#include <iostream>
+#include <cstring>
+#define MAX_LENGTH 1000
+using namespace std;
+
+char a[MAX_LENGTH], b[MAX_LENGTH], lcs[MAX_LENGTH];
+int map[MAX_LENGTH + 1][MAX_LENGTH + 1];
+int al, bl, numOfLCS;
+
+void getLCS();
+int max(int a, int b) {
+ return a > b ? a : b;
+}
+
+int main() {
+ cin.getline(a, MAX_LENGTH+1);
+ cin.getline(b, MAX_LENGTH+1);
+ for (int i = 0; i < MAX_LENGTH; i++)
+ if (a[i] != 0)
+ al++;
+ else
+ break;
+ for (int i = 0; i < MAX_LENGTH; i++)
+ if (b[i] != 0)
+ bl++;
+ else
+ break;
+
+ getLCS();
+ cout << numOfLCS << endl;
+ for (int i = numOfLCS-1; i >= 0; i--)
+ cout << lcs[i];
+ cout << endl;
+}
+
+void getLCS() {
+ for (int i = 1; i <= bl; i++) {
+ for (int j = 1; j <= al; j++) {
+ if (b[i-1] == a[j-1])
+ map[i][j] = map[i-1][j-1]+ 1;
+ else
+ map[i][j] = max(map[i - 1][j], map[i][j - 1]);
+ }
+ }
+ int count = 0,start = al, before = map[bl][al]+1;
+ for (int i = bl; i >= 1; i--) {
+ for (int j = start; j >= 1; j--) {
+ if (before - 1 != map[i][j])
+ break;
+ if (map[i][j - 1] != map[i][j] && b[i - 1] == a[j - 1]) {
+ lcs[count++] = a[j - 1];
+ start = j - 1;ㅁ
+ before = map[i][j];
+ break;
+ }
+ }
+ if (start == 0)
+ break;
+ }
+ numOfLCS = count;
+}
+
+
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
1. 방문한 곳을 체크하는 check 이차원 배열, 키를 저장하는 key 배열, 닫힌문을 저장하는 closedDoor 벡터가 필요
+2. 먼저 키 배열은 26개의 원소로 이루어진 bool 자료형 배열로 선언. 각 알파벳에 해당하는 키가 들어오면 1을 저장한다.
+3. 방문가능한지 체크하는 checkCell 함수 선언
+ -> 빈공간이면 true반환, 문서면 빈공간으로 전환 후 document 1증가하고 true반환
+ 소문자면 열쇠 추가하고, 빈공간으로 전환 후 truw반환
+ 대문자고, 열쇠가 있으면 빈공간으로 전환 후 true 반환
+ 대문자고 열쇠가 없으면 closedDoor 벡터에 해당위치 추가하고 false 반환
+4. 처음에 테두리 먼저 검사
+ -> 체크 안됐고, 벽이 아니고, checkCell 통과하면 해당 위치에서 BFS 시행
+ -> 모든 테두리 검사
+5. 테두리 검사 후. cloesedDoor 검사
+ -> 체크 안됐고, 빈공간 전환 안됐고, 열쇠있으면 빈공간으로 전환 후 BFS 시행
+ -> 한번이라도 BFS가 시행되면 다시 처음부터 closedDoor검사를 함.
+ -> BFS가 시행안되면 루프 중단 후 document 수 출력
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
1. 한번 검사한 cell은 다시 검사하지 않는다. -> 검사안된 곳은 열쇠가 없어서 못들어간 곳이므로, closedDoor만 검사하면 된다.
+2. 입력잘받자 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+문자열 입력
+ 1. 길이를 정해줬을 때
+ : 띄어쓰기를 안했다해도, 그냥 map[i][j] 로 받으면 된다.
+ 2. 길이를 안정해줬을 떄
+ : string temp;
+ cin >> tmep;
+ for(int i = 0; i<temp.length(); i++)
+ key[i] = temp[i];
+ 로 받자
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+
#include <iostream>
+#include <cstring>
+#include <list>
+#include <vector>
+#include <string>
+#define MAX_WIDTH 102
+
+using namespace std;
+
+typedef struct Location {
+ int row;
+ int col;
+} Location;
+
+char map[MAX_WIDTH][MAX_WIDTH];
+bool key[27], check[MAX_WIDTH][MAX_WIDTH];
+int width, height, document;
+vector<Location> closedDoor;
+
+void getMaxDocument();
+void BFSfrom(int row, int col);
+bool checkCell(int row, int col);
+
+int main() {
+ int numOfTC;
+ cin >> numOfTC;
+ for (int i = 0; i < numOfTC; i++) {
+ memset(key, false, sizeof(key));
+ cin >> height >> width;
+ cin.ignore();
+ for (int j = 0; j < height; j++) {
+ for (int k = 0; k < width; k++)
+ cin >> map[j][k];
+ }
+ string tempkey;
+ cin >> tempkey;
+
+ for (int j = 0; j < tempkey.length(); j++) {
+ if (tempkey[j] == '0')
+ break;
+ key[tempkey[j] - 'a'] = true;
+ }
+
+ document = 0;
+ getMaxDocument();
+ cout << document << endl;
+ }
+}
+//모든 게이트로 들어감 -> 열수 있는 문은 열고 . 로 바꾸고 안으로 들어감. 열쇠든 문서든 주으면 .으로 바꿈
+ //열수 없는 문은 closedDoor에 추가
+ //들어갈 수 있는 곳 BFS가 끝나면, closedDoor 검사 수행. 새로 열린 곳을 기준으로 다시 BFS 시행 열린 곳이 없으면 그때의 count 반환
+void getMaxDocument() {
+ //모든 게이트 검사. 게이트가 이어지는 경우 고려
+ for (int i = 0; i < width; i++) {
+ if (!check[0][i] && map[0][i] != '*' && checkCell(0, i))
+ BFSfrom(0, i);
+ }
+ for (int i = 0; i < width; i++) {
+ if (!check[height - 1][i] && map[height - 1][i] != '*' && checkCell(height - 1, i))
+ BFSfrom(height - 1, i);
+ }
+ for (int i = 1; i < height - 1; i++) {
+ if (!check[i][0] && map[i][0] != '*' && checkCell(i, 0))
+ BFSfrom(i, 0);
+ }
+ for (int i = 1; i < height - 1; i++) {
+ if (!check[i][width - 1] && map[i][width - 1] != '*' && checkCell(i, width - 1))
+ BFSfrom(i, width - 1);
+ }
+
+ //closedDoor 검사
+ bool loopCheck = true;
+ while (loopCheck) {
+ loopCheck = false;
+ int length = closedDoor.size();
+ for (int i = 0; i < length; i++) {
+ if (!check[closedDoor[i].row][closedDoor[i].col] && map[closedDoor[i].row][closedDoor[i].col] != '.' && key[map[closedDoor[i].row][closedDoor[i].col] - 'A']) {
+ map[closedDoor[i].row][closedDoor[i].col] = '.';
+ BFSfrom(closedDoor[i].row, closedDoor[i].col);
+ loopCheck = true;
+ }
+ }
+ }
+
+ memset(check, 0, sizeof(check));
+ memset(key, 0, sizeof(key));
+ closedDoor.clear();
+ memset(map, 0, sizeof(map));
+}
+
+void BFSfrom(int row, int col) {
+ list<Location> q;
+ q.push_back({ row, col });
+ check[row][col] = true;
+
+ while (!q.empty()) {
+ Location temp = q.front();
+ q.pop_front();
+
+ if (temp.row > 0 && !check[temp.row - 1][temp.col] && map[temp.row - 1][temp.col] != '*') {
+ if (checkCell(temp.row - 1, temp.col)) {
+ check[temp.row - 1][temp.col] = true;
+ q.push_back({ temp.row - 1, temp.col });
+ }
+ }
+ if (temp.col < width - 1 && !check[temp.row][temp.col + 1] && map[temp.row][temp.col + 1] != '*') {
+ if (checkCell(temp.row, temp.col + 1)) {
+ check[temp.row][temp.col + 1] = true;
+ q.push_back({ temp.row, temp.col + 1 });
+ }
+ }
+ if (temp.row < height - 1 && !check[temp.row + 1][temp.col] && map[temp.row + 1][temp.col] != '*') {
+ if (checkCell(temp.row + 1, temp.col)) {
+ check[temp.row + 1][temp.col] = true;
+ q.push_back({ temp.row + 1, temp.col });
+ }
+ }
+ if (temp.col > 0 && !check[temp.row][temp.col - 1] && map[temp.row][temp.col - 1] != '*') {
+ if (checkCell(temp.row, temp.col - 1)) {
+ check[temp.row][temp.col - 1] = true;
+ q.push_back({ temp.row, temp.col - 1 });
+ }
+ }
+ }
+}
+
+bool checkCell(int row, int col) {
+ if (map[row][col] == '.')
+ return true;
+ else if (map[row][col] == '$') {
+ map[row][col] = '.';
+ document++;
+ return true;
+ }
+ else if (map[row][col] >= 'a' && map[row][col] <= 'z') {
+ key[map[row][col] - 'a'] = true;
+ map[row][col] = '.';
+ return true;
+ }
+ else if(map[row][col] >= 'A' && map[row][col] <='Z'){
+ if (key[map[row][col] - 'A']) {
+ map[row][col] = '.';
+ return true;
+ }
+ else {
+ closedDoor.push_back({ row, col });
+ return false;
+ }
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
1. 각 학생들이 가리키는 학생을 저장한 student 배열, cycle에 몇명이 있는지 체크하는 cycleCcount 변수, 사이클이 형성됐는지 확인하는 cycleCheck bool형 배열.
+ 검사중인 학생들을 저장하는 q배열
+2. 첫번째 학생부터 검사
+ -student가 -1 이면 검사안함. (이미 검사된 것)
+ -검사가 시작되면, q에 넣고, cycleCheck 배열에 표시하고, start엔 자기, end엔 다음걸 가리키며, 그래프따라 dfs 시작
+ -그래프 따라가면서 cycleCheck에 표시, end는 항상 다음 걸 가리키게 함.
+ -end가 -1이거나, 이미 검사한 거면 종료
+ -start와 end가 같으면 시작부터 사이클 형성된 것.
+ - q에 넣어진 곳을 전부 -1로 바꾸고, count를 q크기만큼 증가시킴
+ -다르면 end가 -1이 아닌 경우엔 중간에 사이클만 넣어주고, 전부 -1로 변경
+ -1이면 그냥 전부 -1로 변경
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+
#include <iostream>
+#include <cstring>
+#define MAX_STUDENT 100000
+
+using namespace std;
+
+int numOfStudent, student[MAX_STUDENT+1];
+bool checkCycle[MAX_STUDENT+1];
+int queue[MAX_STUDENT + 1], cycleCount;
+
+void generateCheck();
+
+int main() {
+ int tc;
+ cin >> tc;
+ for (int i = 0; i < tc; i++) {
+ cin >> numOfStudent;
+ for (int j = 1; j <= numOfStudent; j++)
+ cin >> student[j];
+
+ cycleCount = 0;
+ generateCheck();
+ cout << numOfStudent - cycleCount << endl;
+ }
+}
+void generateCheck() {
+ for (int i = 1; i <= numOfStudent; i++) {
+ if (student[i] != -1) {
+ int start = i;
+ int end = student[i];
+ int index = 0;
+ queue[index++] = i;
+ checkCycle[start] = true;
+ while (!checkCycle[end]) {
+ queue[index++] = end;
+ checkCycle[end] = true;
+ end = student[end];
+ if (end == -1)
+ break;
+ }
+
+ if (start == end) {
+ for(int j = 0; j<index; j++) {
+ cycleCount++;
+ student[queue[j]] = -1;
+ checkCycle[queue[j]] = false;
+ }
+ }
+ else {
+ int j = index - 1;
+ if (end != -1) {
+ for (; j >= 0; j--) {
+ if (queue[j] != end) {
+ cycleCount++;
+ student[queue[j]] = -1;
+ checkCycle[queue[j]] = false;
+ }
+ else
+ break;
+ }
+ cycleCount++;
+ }
+ for(; j>= 0; j--) {
+ checkCycle[queue[j]] = false;
+ student[queue[j]] = -1;
+ }
+ }
+ }
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
1. 2^n 마다 규칙이 있음
+2. f(n)을 2^n ~ 2^(n+1)-1 에서의 1의 개수라고 한다면, f(n) = 2^n + f(i) ( 0 <= i <= n-1 ) 이 성립한다.
+3. 그리고 들어오는 수 A,B에 대해
+ (1~B 까지의 1의 개수) - (1~A-1 까지의 1의 개수) 를 하면 값이 나온다.
+4. 2에서의 규칙에따라 end가 주어지면 0에서 end까지의 1의 개수를 구하는 함수를 선언한다.
+ -> 이때 end 미만의 최대 2^n의 n를 구한다.
+ -> 2에서의 규칙에 따라 0~n까지의 f(n)을 구한다.
+ -> 그럼 나머지 2^(n+1) ~ end 에서의 1의 개수를 구하면 된다.
+
+5. 나머지를 구하는 함수를 선언한다. 2^(n+1)에서 end까지 구하면 된다.
+ -> 이때 2^(n+1) ~ end 사이의 값들의 맨앞은 전부 1이고, 개수는 end - 2^(n+1) + 1이다.
+ -> 그리고 그 맨앞의 1을 떼고 보면, 0부터 end - 2^(n+1) 까지의 이진수 분포와 동일하다
+ -> 따라서 다시 end - 2^(n+1)을 위 4번 함수에 넣으면 된다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+
#include <iostream>
+#include <cmath>
+
+using namespace std;
+
+long long a, b;
+long long DP[55];
+
+long long getN(int N);
+long long countOne(long long end);
+long long getRest(long long start, long long end);
+
+int main() {
+ cin >> a >> b;
+ DP[0] = 1;
+
+ cout << countOne(b) - countOne(a-1) << endl;
+}
+
+long long countOne(long long end) {
+ if (end <= 2)
+ return end;
+
+ int n = 0;
+ long long temp = 1;
+ while (temp < end) {
+ temp *= 2;
+ n++;
+ }
+ if (temp - end <=1)
+ n -= 1;
+ else
+ n -= 2;
+
+ long long result = 0;
+ for (int i = 0; i <= n; i++)
+ result += getN(i);
+
+ result += getRest(pow(2, n+1), end);
+
+ return result;
+}
+
+long long getN(int N) {
+ if (N == 0)
+ return 1;
+ if (DP[N] != 0)
+ return DP[N];
+
+ long long result = pow(2, N);
+ for (int i = N - 1; i >= 0; i--)
+ result += getN(i);
+
+ return DP[N] = result;
+}
+
+long long getRest(long long start, long long end) {
+ if (start > end)
+ return 0;
+
+ return end - start + 1 + countOne(end - start);
+}
+
Comments powered by Disqus.
a, b에서 b의 순서대로 정렬
1 2
1 1
이런식으로 입력이 들어오면, 1 2에서 1에 넣고 1 1에선 넣을 수가 없기 때문에.
정렬된 (a, b)를 앞에서부터 검사하는데, a에서 b까지 1씩 증가하면서 가능하면 책을 배정하고, b까지 검사했는데도 남아있는 책이없으면 패스한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+
#include <iostream>
+#include <list>
+#include <cstring>
+#include <algorithm>
+#include <vector>
+
+using namespace std;
+
+list<pair<int, int>> l;
+vector<pair<int, int>> v;
+bool card[1001];
+
+
+int main() {
+ int tc;
+ cin >> tc;
+ while (tc--) {
+ int n, m, ans = 0, a, b;
+ cin >> n >> m;
+ for (int i = 0; i < m; i++) {
+ cin >> a >> b;
+ v.push_back({ b, a });
+ }
+ sort(v.begin(), v.end());
+ for (int i = 0; i < v.size(); i++) {
+ l.push_back({ v[i].second, v[i].first });
+ }
+ v.clear();
+
+ auto iter = l.begin();
+ while (iter != l.end()) {
+ int f = iter->first, s = iter->second;
+ if (!card[f]) {
+ card[f] = true;
+ ans++;
+ iter = l.erase(iter);
+ }
+ else {
+ if (f + 1 > s)
+ iter = l.erase(iter);
+ else {
+ bool check = true;
+ for (int i = f + 1; i <= s; i++) {
+ if (!card[i]) {
+ card[i] = true;
+ ans++;
+ iter = l.erase(iter);
+ check = false;
+ break;
+ }
+ }
+ if (check) {
+ iter = l.erase(iter);
+ }
+ }
+ }
+ }
+
+ cout << ans << endl;
+
+ memset(card, 0, sizeof(card));
+ }
+}
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+
#include <iostream>
+#include <cstring>
+#define INF 2000000000
+
+using namespace std;
+
+int n, holes[15][2], ans, pairing[7][2];
+bool visit[15], check[8][2];
+
+void makePair(int cur, int deep);
+bool findCycle(int s, int o);
+
+int main() {
+ cin >> n;
+ for (int i = 0; i < n; i++)
+ cin >> holes[i][0] >> holes[i][1];
+
+ visit[0] = true;
+ makePair(0, 0);
+
+ cout << ans;
+}
+
+void makePair(int cur, int deep) {
+ if (deep == n / 2) {
+ for (int i = 0; i < 2; i++) {
+ for (int j = 0; j < n / 2; j++)
+ if (findCycle(j, i)) {
+ ans++;
+ return;
+ }
+ }
+ return;
+ }
+ pairing[deep][0] = cur;
+ for (int i = cur + 1; i < n; i++) {
+ if (!visit[i]) {
+ visit[i] = true;
+ pairing[deep][1] = i;
+ int j = 0;
+ for (; j < n; j++)
+ if (!visit[j])
+ break;
+ visit[j] = true;
+ makePair(j, deep + 1);
+ visit[i] = false;
+ visit[j] = false;
+ }
+ }
+}
+
+
+bool findCycle(int s, int o) {
+ int next = pairing[s][!o];
+ check[s][o] = true;
+
+ while (next != -1) {
+ int cur = next;
+ next = -1;
+
+ int cr = holes[cur][1], cc = holes[cur][0], ni, nj, close = INF;
+ for (int i = 0; i < n / 2; i++) {
+ for (int j = 0; j < 2; j++) {
+ if (cr == holes[pairing[i][j]][1] && cc < holes[pairing[i][j]][0] && holes[pairing[i][j]][0] < close) {
+ close = holes[pairing[i][j]][0];
+ ni = i;
+ nj = j;
+ }
+ }
+ }
+
+ if (close != INF) {
+ if (check[ni][nj]) {
+ memset(check, 0, sizeof(check));
+ return true;
+ }
+ check[ni][nj] = true;
+ next = pairing[ni][!nj];
+ }
+ }
+ memset(check, 0, sizeof(check));
+ return false;
+}
+
Comments powered by Disqus.
매우 어렵게 구현하여 풀긴하였으나, 스택을 사용하면 매우 직관적으로 편하게 구현할 수 있었다.
스택을 사용하여 문제를 푼 경험이 적어서 스택을 떠오르지 못한 것 같다
스택을 사용한 문자열 문제를 몇문제 풀어봐야할 것 같음
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+
#include <iostream>
+#include <cstring>
+using namespace std;
+
+int to[1000010], from[1000010];
+string f, s;
+
+int main() {
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cout.tie(0);
+
+ cin >> f >> s;
+ memset(to, -1, sizeof(to));
+ memset(from, -1, sizeof(from));
+
+ int start = 0;
+ for (int i = 0; i <= f.size() - s.size(); ) {
+ if (to[i] != -1) {
+ i = to[i];
+ continue;
+ }
+
+ bool check = true;
+
+ int j = i;
+ for (int cnt = 0; cnt < s.size();) {
+ if (j >= f.size()) {
+ check = false;
+ break;
+ }
+ if (to[j] != -1) {
+ j = to[j];
+ continue;
+ }
+ if (f[j] != s[cnt]) {
+ check = false;
+ break;
+ }
+ cnt++;
+ j++;
+ }
+
+ if (check) {
+ to[i] = j;
+ from[j - 1] = i - 1;
+ if (j == f.size())
+ i = j;
+ else if (start == i)
+ start = i = j;
+ else {
+ int t = i - 1;
+ for (int cnt = 0; cnt < s.size();) {
+ if (t < start)
+ break;
+ if (from[t] != -1) {
+ t = from[t];
+ continue;
+ }
+ cnt++;
+ t--;
+ }
+
+ if (t < start)
+ i = start;
+ else
+ i = t;
+ }
+ }
+ else
+ i++;
+ }
+
+ for (int i = 0; i < f.size(); i++)
+ cout << to[i] << " ";
+ cout << endl;
+
+ string ans = "";
+ for (int i = 0; i < f.size(); i++) {
+ if (to[i] != -1) {
+ i = to[i] -1;
+ continue;
+ }
+
+ ans.push_back(f[i]);
+ }
+
+ if (ans.size() == 0)
+ cout << "FRULA";
+ else
+ cout << ans;
+}
+
Comments powered by Disqus.
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
body {
+
+ font-size:14px;
+
+}
+
+div {
+
+ font-size:1.2em;
+
+}
+
면 div엔 16.8px로 들어간다.
이때 부모의 크기에서 배수를 더하는 거라서, 자식마다 em을 써서 내려가면 크기는 계속 배수로 증가하게 된다.
root의 단위에 배수를 더하는 것. 최상위 태그에 대해서 배수로만 구하는 거라, 자식의 깊이가 깊어져도 크기가 기하급수적으로 커지지 않는다.
뷰포트의 높이값과 너비값에 맞추어 사용한다.
뷰포트의 높이, 너비를 100으로 나누어 1vh, 1vw로 표현한다. 100vh, 100vw는 뷰포트와 크기가 동일해진다.
뷰포트의 높이, 너비 값 중 작은 건 vmin에 큰건 vmax에 넣어 100분의 1 단위로 사용한다.
ex) 높이가 700px, 너비가 1100px 이면, 1vmin엔 7px, 1vmax엔 11px가 들어감
뷰포트의 크기에 맞추어, 정사각형을 만들 때 유용하다
둘다 현재 폰트와 폰트사이즈에 의존한다는 점에서 em, rem과 비슷.
하지만 이 두단위는 font-family에 의존함.
ch : 제로문자인 0의 너비값의 고급척도로 정의됨.
ex : 현재폰트의 x높이값 또는 em의 절반값.
Comments powered by Disqus.
Elasticsearch는 시간이 갈수록 증가하는 문제를 처리하는 분산형 RESTful 검색 및 분석 엔진입니다. Elastic Stack의 핵심 제품인 Elasticsearch는 데이터를 중앙에 저장하여 손쉽게 확장되는 광속에 가까운 빠른 검색, 정교하게 조정된 정확도, 강력한 분석을 제공합니다.
(ElasticSearch 공식 문구)
ElasticSearch는 Apache Lucene(아파치 루씬) 기반의 Java 오픈소스 분산 검색엔진이다. ElasticSearch를 통해 루씬 라이브러리를 단독으로 사용할 수 있게 되었으며, 방대한 양의 데이터를 신속하게 거의 실시간으로 저장, 검색, 분석할 수 있다.
ElasticSearch은 검색을 위해 단독으로 사용되기도 하고, ELK(ElasticSearch / logstash / kibana) 스택으로 사용되기도 한다
ELK 스택
- Logstash : 다양한 소스의 로그 또는 트랜잭션 데이터를 수집, 집계, 파싱하여 ElasticSearch로 전달
- ElasticSearch : Logstash로부터 받은 데이터를 검색 및 집계하여 필요한 관심있는 정보를 획득
- Kibana : ElasticSearch의 빠른 검색을 통해 데이터를 시각화 및 모니터링
| RDBMS | ElasticSearch |
|---|---|
| Database | index |
| Table | Type |
| Row | Document |
| Column | Field |
| Index | Analyze |
| Primary key | _id |
| schema | Mapping |
| Physical partition | Shared |
| Logical Partition | Route |
| Relational | Parent/Child, Nested |
| SQL | Query DSL |
Scale out : 샤드를 통해 규모가 수평적으로 늘어날 수 있음
고가용성 : Replica를 통해 데이터의 안정성을 보장
Schema Free : Json 문서를 통해 데이터 검색을 수행하므로 스키마 개념이 없음
Restful : 데이터 CRUD 작업은 HTTP Restful API를 통해 수행하며 각각 다음과 같이 대응한다
| CRUD | Elasticsearch Restful |
|---|---|
| SELECT | GET |
| INSERT | PUT |
| UPDATE | POST |
| DELETE | DELETE |
아파치 루씬은 기본적으로 역색인이라는 구조로 데이터를 저장한다. ElasticSearch도 루씬 기반이므로 역색인을 사용한다.
역색인(inverted index)이란, 책의 맨 뒤에 키워드가 어떤 페이지에 있는지 알려주는 페이지처럼, 값을 통해 위치를 알아내는 방식을 통해 RDBMS보다 전문 검색(full text search)에 빠른 성능을 보인다.
예를 들어 “Lorem Ipsum is simply dummy text of the printing and typesetting industry” 란 문장이 있으면 이 문장을 모두 파싱해서 각 단어들을 저장하고, 대문자는 소문자 처리하고, 유사어도 체크하여 텍스트를 저장한다. 그리고 키워드와 함께 검색 요청이 오면, 키워드를 통해 문서를 찾아내어 검색 성능이 매우 빠르다.
| ElasticSearch | NoSQL | |
|---|---|---|
| 실시간 처리 | 불가능 | 가능 |
| 역색인 자료구조 | 있음 | 없음 |
| 구조 | 검색 엔진 | 데이터 저장소 |
https://steady-coding.tistory.com/573
https://victorydntmd.tistory.com/308
Comments powered by Disqus.
기존에 빌드가 오래 걸렸던 원인들
해커톤을 통해 몇몇 시도한 해결책
실제 서비스 적용
tsc가 너무 느린 문제를 해결하기위해, esbuild-plugin-typecheck를 사용함.Comments powered by Disqus.
일반 노드에서의 환경과 같이 사용하면 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+
const puppeteer = require("puppeteer");
+const { Storage } = require("@google-cloud/storage");
+
+const storage = new Storage();
+
+router.post("/", (req, res) => {
+ (async () => {
+ const browser = await puppeteer.launch({
+ args: ["--no-sandbox", "--disable-setuid-sandbox"],
+ });
+ const page = await browser.newPage();
+
+ await page.goto(req.body.url);
+
+ await page.waitForTimeout(5000);
+ const screenshotBinary = await page.screenshot({
+ fullPage: true,
+ encoding: "binary",
+ });
+
+ const bucket = storage.bucket("스토리지 버켓 토큰");
+
+ const file = bucket.file(`${req.body.uid}/${req.body.uuid}.png`);
+
+ await file.save(screenshotBinary, {
+ metadata: { contentType: "image/png" },
+ });
+ await browser.close();
+
+ res.send({ data: "uploaded" });
+ })();
+});
+
firebase cloud function은 연결된 함수가 실행되고, 종료되면 그 함수를 돌리기위한 환경또한 같이 종료되게 된다.
따라서, cloud function에서 puppeteer를 사용하려면, 작업이 전부 완료될때까지 함수가 종료되지 않도록 해줘야한다.
1
+2
+3
+4
+5
+
...
+return Promise.all(promises).then(async() => {
+ await browser.close();
+})
+...
+
위처럼 puppeteer를 부르는 모든 작업을 promises에 집어넣어, 이 promise 함수들이 전부 끝나기 전까지 종료되지 않도록 하거나, await문을 적절히 사용하여 종료하지 않도록 하면 된다.
Comments powered by Disqus.
GoF에서는 23가지 디자인패턴을 3가지 유형으로 분류함.
주요 패턴
Comments powered by Disqus.
under-fetching : 하나의 작업을 위해 여러 요청을 보내게 하는 것.
https://www.npmjs.com/package/graphql-yoga
yarn add graphql-yoga
기본 구조
1
+2
+3
+4
+5
+
import { GraphQLServer } from "graphql-yoga";
+
+const server = new GraphQLServer({});
+
+server.start(() => console.log("graph Ql server running"));
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+
// /graphql/resolvers.js
+const resolvers = {
+ Query: {
+ name: () => "seongil",
+ },
+};
+export default resolvers;
+
+
+// /graphql/schema.graphql
+type Query {
+ name: String!
+}
+
+// index.js
+...
+import resolvers from "./graphql/resolvers";
+
+const server = new GraphQLServer({
+ typeDefs: "graphql/schema.graphql",
+ resolvers: resolvers,
+});
+...
+
위와 같이 resolver와, Query를 선언해주고, index.js에서 server와 연동시켜주면 된다.
위와 같이 할 경우, 아래와 같이 Query를 보내면
1
+2
+3
+
Query {
+ name
+}
+
아래와 같이 오게 된다.
1
+2
+3
+4
+5
+
{
+ "data": {
+ "name": "seongil"
+ }
+}
+
schema를 다음과 같이 했다.
1
+2
+3
+
type Query {
+ name: String!
+}
+
이 의미는 name에 String 데이터를 반환하는데, !를 주어 required라고 표시하는 것이다.
resolver는 데이터를 어떻게 보내줄 것인지 자바스크립트로 작성하는 것이다.
그럼 객체를 보내고 싶을때는 어떻게 할까
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+
// /graphql/resolvers.js
+const seongil = {
+ name: "seongil",
+ age: 24,
+ gender: "male",
+};
+const resolvers = {
+ Query: {
+ name: () => seongil,
+ },
+};
+export default resolvers;
+
+
+// /graphql/schema.graphql
+type Person {
+ name: String!
+ age: Int!
+ gender: String!
+}
+
+type Query {
+ person: Person!
+}
+
이렇게 해주면 된다.
요청은 다음과 같이 보낸다. 객체 안의 요소를 하나하나 선택하여 받아올 수 있다.
1
+2
+3
+4
+5
+6
+
Query {
+ person {
+ name
+ age
+ }
+}
+
Comments powered by Disqus.
yarn add @apollo/react-hooks apollo-boost graphql
GraphQL API로 요청을 보낼때는, 요청문을 axios나 fetch를 사용하여 POST 메소드로 보내야함.
하지만 Apollo를 사용하면, 위와같이 하지 않아도 된다.
다음과 같이, apollo.js 파일을 생성하고, client를 만들어주자. uri에는 graphQL 서버의 주소가 들어가면 된다.
1
+2
+3
+4
+5
+6
+7
+8
+
// src/apollo.js
+import ApolloClient from "apollo-boost";
+
+const client = new ApolloClient({
+ uri: "http://localhost:4000/",
+});
+
+export default client;
+
그리고 다음과 같이 index.js에서 연결하자
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
// src/index.js
+...
+import client from "./apollo";
+import { ApolloProvider } from "@apollo/react-hooks";
+
+ReactDOM.render(
+ <ApolloProvider client={client}>
+ <App />
+ </ApolloProvider>,
+ document.getElementById("root")
+);
+
1
+2
+
import { useQuery } from "@apollo/client";
+import { gql } from "apollo-boost";
+
아래와 같이 쿼리문 작성
1
+2
+3
+4
+5
+6
+7
+8
+
const GET_MOVIES = gql`
+ {
+ movies {
+ id
+ medium_cover_image
+ }
+ }
+`;
+
아래와 같이 사용. useQuery에 쿼리문을 넣고, loading, error, data를 얻을 수 있다.
1
+2
+3
+4
+5
+6
+7
+
const { loading, error, data } = useQuery(GET_MOVIES);
+
+if (loading) {
+ return "loading...";
+} else if (data && data.movies) {
+ return data.movies.map((m) => <h1>{m.id}</h1>);
+}
+
paremeter가 있는 get
아래와 같이 쿼리문 작성. paremeter가 없을 때는 그냥해도 되지만, 있을 때는 다음과 같이 query getMovie($id:Int!) 라는 이름으로 불러주자.
이때, 꼭 graphQL 서버에 있는 이름으로 호출할 필요는 없다. 즉, 다음코드에서 getMovie 대신 get만 써도 된다는 것이다.
타입만 잘 적어주자.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
const GET_MOVIE = gql`
+ query getMovie($id: Int!) {
+ movie(id: $id) {
+ id
+ title
+ medium_cover_image
+ description_intro
+ }
+ }
+`;
+
호출 : 나머지는 똑같되, useQuery의 두번째 인자에 객체를 넣고, variable 필드에 파라미터를 넣어주자
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
const Detail = () => {
+ const { id } = useParams();
+ const { loading, data } = useQuery(GET_MOVIE, {
+ variables: { id: parseInt(id) },
+ });
+
+ if (loading) {
+ return "loading";
+ }
+ if (data && data.movie) {
+ return data.movie.title;
+ }
+};
+
react apollo가 뭔가를 얻으면 그것을 저장하여 같은 데이터를 요청하면, 그대로 캐시에 있는 것을 보여준다.
모든 걸 apollo client에서 자동으로 해준다.
Apollo cache에 있는 데이터를 client 에서 변경하여 사용하기
client에서 만든 데이터 가져오기
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
// src/routes/Home.js
+const GET_MOVIES = gql`
+ {
+ movies {
+ id
+ medium_cover_image
+ isLiked @client
+ }
+ }
+`;
+
데이터 넣기
1
+2
+3
+4
+5
+
resolvers: {
+ Movie: {
+ isLiked: () => false, // 디폴트로 false 값 지니도록.
+ },
+ },
+
데이터 수정하기
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
resolvers: {
+ ...
+ Mutation: {
+ likeMovie: (_, { id }, { cache }) => {
+ cache.modify({
+ id: `Movie:${id}`,
+ fields: {
+ isLiked: (isLiked) => !isLiked,
+ },
+ });
+ },
+ },
+ },
+
데이터 변경 요청
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
const LIKE_MOVIE = gql`
+ mutation likeMovie($id: Int!) {
+ likeMovie(id: $id) @client
+ }
+`;
+...
+const [likeMovie] = useMutation(LIKE_MOVIE, {
+ variables: { id: parseInt(id) },
+ });
+...
+<button onClick={likeMovie}>{isLiked ? "Unlike" : "Like"}</button>
+
Comments powered by Disqus.
Comments powered by Disqus.
프론트엔드 관련 아티클을 읽다보면 다양한 bundler, package manger, compiler 도구에 대한 얘기가 나온다. 그때마다 익숙지않은 도구의 이름(pnpm, swc, vite 등)이 나오는데 뭐가 뭔지 잘 이해가 안간다. 따라서 각각의 역할이 무엇인지, 어떤 종류가 있고 어떤 장단이 있는지 간단히 정리해보려고 한다.
여러개의 파일을 하나의 파일로 묶어주는 도구이다.
초기에 브라우저는 모듈 시스템을 지원하지 않았다. <script> 간 모듈을 내보낼 수 없었고, 전역 객체를 통해서만 서로를 참조할 수 있었다. 하지만 웹 생태계가 커지면서 점점 더 다양한 요구조건이 생기기 시작했다. (최적화, 모듈 시스템, 코드 호환성(polyfill), 전처리 등). 번들러는 이러한 요구사항에 대응하기 위해 태어났다.
현재 대표적인 번들러는 webpack, rollup, esbuild, vite 이다
webpack
rollup
esbuild
Go를 기반으로 만들어진 번들러로 성능상 큰 강점이 있다. (JS 기반 번들러보다 10 ~ 100x)vite
vue.js 창시자가 만든 frontend build tool로, 두가지 포인트가 있다native ES modules 기반의 강력한 개발서버index.html이 빌드 시작점이고, 순수 JS 번들 생성을 위해서는 라이브러리 모드가 필요하다프로젝트에서 사용하는 패키지를 쉽게 설치, 업데이트해주는 도구이다. 대표적으로는 npm, yarn, pnpm이 있다
npm
yarn
pnpm
npm을 좀 더 편리하게 사용할 수 있도록 도와주는 도구로, npm 레지스트리에서 원하는 패키지를 실행할 수 있는 도구이다.
패키지를 설치하지 않더라도 npm 레지스트리에 올라가있는 패키지의 최신버전을 실행 시키고, 자동으로 설치도 된다. 다음과 같은 경우 사용한다.
Comments powered by Disqus.
Model
비즈니스 로직을 구현하는 영역으로 응용프로그램에서 데이터를 처리하는 부분이다.Controller
View
Client-Server 구조로, 요청을 하면 그에 맞는 응답을 하는 구조를 기본으로 하고 있다.
Comments powered by Disqus.
Model - View - View Model 의 약자로, 프로그램의 비지니스 로직과 프레젠테이션 로직을 UI로 명확하게 분리하는 패턴
데이터를 관리하는 로직과 UI로직을 깔끔하게 분리하여 유지보수에 용이해짐.
Model
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
class Model {
+ constructor() {
+ books = [
+ {id: 'RCB-123',name: "React Cook Book", isFavorite: false},
+ {id: 'VCB-123',name: "Vue Cook Book", isFavorite: false},
+ {id: 'ACB-123',name: "Angular Cook Book", isFavorite: false}
+ ];
+ }
+
+ getBooks() {
+ return this.books
+ }
+
+ toggleFavorite(bookId) {
+ const target = this.books.filter(item => item.id === bookId)[0];
+ target.isFavorite = !target.isFavorite
+ }
+}
+
View Model
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
class ViewModel {
+ constructor(bookStore) {
+ this.store = bookStore
+ }
+
+ getBooks() {
+ return this.store.getBooks()
+ }
+
+ toggleFavorite(bookId) {
+ this.store.toggleFavorite(bookId)
+ }
+}
+
+export default ViewModel
+
View
비지니스 로직은 최대한 피하고, UI에 관련된 로직만 나타내도록 해야함.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
const ViewComponent = ({books, handleToggleFavorite, handleClickNeverView}) => {
+ return (
+ <div>
+ <BooksList
+ books={books}
+ handleToggleFavorite={handleToggleFavorite}
+ handleClickNeverView={handleClickNeverView}
+ />
+ </div>
+ )
+}
+
View Controller
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+
const ViewControllerComponent = ({viewModel}) => {
+ const [isNeverView, setIsNeverView] = useState(false);
+
+ const handleToggleFavorite = useCallback((bookId) => {
+ viewModel.toggleFavorite(bookId)
+ }, [viewModel]);
+
+ const handleClickNeverView = useCallback(() => {
+ setIsNeverView(!isNeverView);
+ }, [isNeverView]);
+
+ return (
+ <ViewComponent
+ books={viewModel.getBooks()}
+ handleToggleFavorite={handleToggleFavorite}
+ handleClickNeverView={handleClickNeverView}
+ />
+ )
+}
+
Provider
1
+2
+3
+4
+5
+6
+7
+8
+
const BooksProvider = () => {
+ const model = new Model()
+ const [viewModel] = useState(new ViewModel(model))
+
+ return (
+ <ViewControllerComponent viewModel={viewModel} />
+ )
+}
+
Model - View - Prensenter
Presenter는 View와 Model의 인스턴스를 가지고 있어 둘을 연결하는 접착제 같은 역할을 한다.
또, Prensenter와 View는 1:1 관계이다.
MVC, MVVM, MVP 등의 디자인 패턴을 공부하면서 그동한 무지성으로 개발했던 내 과거 프로젝트가 과연 어떤 디자인패턴에 가까운지 궁금해져 한번 과거 프로젝트를 살펴보기로 했다.
이글을 작성하고 있는 시점에서의 나의 가장 최근 프로젝트인 yourlist-web-renewal 프로젝트의 디렉터리 구조는 다음과 같다.
간단히 디자인 패턴과 관련이 있는 부분만 적었다.
먼저 modules를 살펴보면, 앱에 필요한 데이터를 가지고 있고, 각종 api와 직접 소통하여 데이터를 받아들이고, 간단한 가공을 담당하는 부분이니 Model 에 해당한다고 볼 수 있다.
그리고 각 컴포넌트의 최상단에 있는 index.tsx 는 모델과 소통하여 데이터를 받아들이고, 그 컴포넌트에서 사용되는 비지니스 로직을 담당한다. 따라서 이는 MVP의 Prensenter나 MVVM의 View Model에 해당한다고 볼 수 있다.
container 는 Model과 대화하지 않고, 자신이 담당하는 view의 이벤트를 처리해주고, 자신이 담당하는 부분에서의 Model과 연관이 없는 비지니스 로직을 처리한다. 따라서 이는 MVVM 구조의 View controller에 가깝다고 보인다.
이때 내 프로젝트에서 view는 container나 index로 데이터를 요청하지 않는다. 상태를 통해 container 또는 index로부터 데이터를 받아서 그것을 활용하여 UI를 구성하고, UI에 관련된 로직만을 포함하고 있다. 이는 MVVM 구조에서의 View에 좀더 가깝다.
따라서 내 프로젝트는 굳이 따지자면, MVVM 구조를 따르고 있다고 볼 수 있다.
하지만 MVVM의 패턴에서 벗어난 부분도 존재한다.
개선 사항
무의식적으로 했던 패턴이 MVVM에 가장 가깝다는 것을 알고, 나에게 MVVM이 가장 잘 맞는다는 것을 알았으나, MVVM 패턴을 지키지 않은 부분도 존재하기에 아래와 같이 개선할 점을 뽑아 보았다.
위와 같이 한다면 좀 더 구조적으로 안정된 프로젝트를 할 수 있을 것이라 생각된다.
하지만 아직 구체적으로 MVVM의 패턴이 실제 프로젝트에 어떻게 적용되는지는 잘 모르기에, 리팩토링을 할때 한번 MVVM 패턴이 지켜진 프로젝트를 참고해보는 것이 좋아보인다.
https://velog.io/@dlrmsghks7/whatismvvmpattern
https://beomy.tistory.com/43
Comments powered by Disqus.
사용하는 데이터베이스 엔진에 따라 다르다.
이유는 MyISAM의 경우 row가 몇 개 있는지 저장하고 있기에 Count(*) 쿼리가 들어오면 그 저장한 값을 바로 리턴하여 O(1)이 된다.
Count(*)이 가장 빠르다.
이유는 Count(*) 의 경우 내부적으로 값을 확인하지 않고, row의 개수만 확인한다.
하지만 column을 주면 내부적으로 값을 확인하여 null이 아닌 row만 리턴하기에 시간이 좀 더 걸리게 된다.
where 조건도 마찬가지다. 값을 확인한다음 조건에 맞는 것만 세기에 Count(*)보다 느리다.
이는 MyISAM 엔진에서도 마찬가지다. MyISAM 엔진에서 빠른 것은 SELECT COUNT(*)이고 Count(column)이나 Count(*) Where 은 InnoDB와 마찬가지로 값을 읽고 리턴하기에 시간이 오래 걸린다.
| MyISAM | InnoDB | |
|---|---|---|
| Count(*) | 빠름 | 보통 |
| Count(col) | 느림 | 느림 |
| Count(*) Where | 느림 | 느림 |
절대적으로 빠름, 느림을 의미하는게 아닌 상대적인 속도를 의미.
https://stackoverflow.com/questions/5257973/mysql-complexity-of-select-count-from-mytable
https://m.blog.naver.com/pjt3591oo/221030483713
https://stackoverflow.com/questions/22352073/improve-innodb-count-performance
https://imnkj.tistory.com/49
Comments powered by Disqus.
REST란, REprensentational State Transfer의 약자이다. 따라서, RESTful API는 REST의 기본 원칙을 잘 지킨 API를 의미한다.
REST는 하나의 아키텍쳐로, Resource Oriented Architecture이다. API 설계의 중심에 자원(resource)가 있고, HTTP Method를 통해 자원을 처리하도록 설계하는 것이다.
www와 같은 분산 하이퍼 미디어 시스템을 위한 소프트웨어 아키텍처의 한 형식으로, 자원을 정의하고 자원에 대한 주소를 지정하는 방법 전반에 대한 패턴
리소스와 행위를 명시적이고 직관적으로 분리한다.
GET, POST, PUT(전체 수정), PATCH(일부 수정), DELETE 가 있다.Message는 Header와 Body를 명확하게 분리해서 사용한다
API 버전을 관리한다.
서버와 클라이언트가 같은 방식을 사용해서 요청하도록 한다.
브라우저와 서버 둘 다 json으로 보내든, form-data 형식으로 보내든 하나로 통일한다.
다른 말로 표현하자면, URI가 플랫폼 중립적이어야한다는 말이다.
https://meetup.toast.com/posts/92
Comments powered by Disqus.
이미 서버에 올라간 백엔드 API 와 로그인 작업을 하던 도중에, 백엔드에서 보내는 쿠키를 브라우저가 저장하지 않는 문제를 발견했다.
찾아보니 CORS 위반으로 생기지 않는 것이라고 하였다.
그럴때 해결방법은 두가지가 있다.
1
+2
+3
+4
+5
+6
+
//package.json
+{
+ ...
+ "proxy" : "백엔드 주소"
+ ...
+}
+
위처럼 하면, proxy에서 통신을 하는 것이라고 하여 CORS 를 위반하지 않고 제대로 쿠키를 저장할 수 있다.
setupProxy.js
npm install http-proxy-middleware
설치후 src 밑에 setupProxy.js 파일을 생성하고 다음과 같이 코드 작성
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
const { createProxyMiddleware } = require("http-proxy-middleware");
+
+module.exports = function (app) {
+ app.use(
+ createProxyMiddleware("/", {
+ target: "백엔드 주소",
+ changeOrigin: true,
+ })
+ );
+};
+
주위점
위처럼 한다음에 axios 를 호출할땐 다음과 같이 도메인을 제외한 주소를 적어야한다.
1
+
await axios.get("/api/product");
+
모든 주소를 적으면, 다른 origin으로 인식하여 다시 쿠키가 생기지 않게 된다
Comments powered by Disqus.
Test-Driven Development의 약자로, 테스트가 코드 작성을 주도하는 개발방식이며, 매우 짧은 개발 사이클의 반복에 의존하는 소프트웨어 개발 프로세스이다.
우선 개발자는 요구되는 새로운 기능에 대한 자동화된 테스트케이스를 작성하고, 해당 테스트를 통과하는 가장 간단한 코드를 작성한다. 일단 테스트를 통과하는 코드를 작성하고, 리팩토링하는 과정을 거치는 것이다.
테스트를 작성하기 전에 개발자는 해당 기능의 요구사항과 명세를 분명히 이해하고 있어야한다. 이는 user-case나 user-story 등으로 이해할 수 있으며, 이는 개발자가 코드를 작성하기 전에 보다 요구사항에 집중할 수 있도록 도와준다. 이는 TDD가 주는 이점 중 하나이다.
새로운 기능을 추가하면, 잘 작동하던 기능이 제대로 동작하지 않을 때가 많다. 또 개발자가 미처 인지하지 못하는 경우도 있다. 이러한 경우를 방지하기 위해 테스트 코드를 작성하여, 새로운 기능을 추가할때 기존의 기능들이 잘 작동하는지 확인해 볼 수 있다.
TDD를 해왔다면 방대한 코드량을 안심하고 리팩토링할 수 있다. 리팩토링을 하면서 해당 기능이 오작동을 일으킨다면 테스트가 잡아줄 것이기때문이다. 결과적으로 리팩토링이 더 빨라지고, 코드의 퀄리티도 그만큼 향상하게 된다.
요구되는 코드량은 분명히 늘어난다. 코드 퀄리티보다 빠른 생산성이 요구되는 시점에서 TDD는 큰 걸림돌이 될 수 있다.
어떤 부분을 테스트해야할지, 어떻게 테스트해야할지, 어떤 테스트 프레임워크가 적합한지에 대한 학습이 필요하고, 익숙해지는데에도 시간이 걸린다. 개발팀 전원이 이에 익숙해져야하기에 이에 대한 코스트는 무시할 수 없다.
다양한 요구사항과 예외 케이스를 맞추다보면, 테스트를 작성하는 것이 불가능하거나 매우 어려울 수 있다. 이때 실제 코드를 변경하여 테스트에 적합한 코드를 만드는 것은 주객전도인 상황이다.
따라서 모든 코드에 대해 테스트를 작성할 수는 없으며, 할 필요도 없다. 테스트코드를 작성한다고 버그가 발생하지 않는 것도 아니다. 또 TDD는 100% coverage와 100% 무결성을 주장하지 않는다.
https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/Development_common_sense#restful-api
Comments powered by Disqus.
통합 모델링 언어를 사용하여 시스템 상호작용, 업무 흐름, 시스템 구조, 컴포넌트 관계 등을 그린 도면.
프로그래밍을 단순화 시켜 표현하여 의사소통 하기 좋고, 대규모 프로젝트에서는 로드맵을 만들거나 개발을 위한 시스템 구축의 기본을 마련한다.
요구사항 모델링에 사용되는 기법 중 하나
기능적 모델
사용자 측면에서 본 시스템 기능, UML에서는 Use Case 다이어그램을 사용한다.
정적 모델
객체, 속성, 연관관계, 오퍼레이션의 시스템 구조를 나타내며, UML에서는 Class 다이어그램을 사용한다.
동적 모델
시스템의 내부 동작을 말하며, UML에서는 Sequence, state, activity 다이어그램을 사용한다.
시스템과 외부와의 상호작용을 묘사. 프로젝트에 대한 요구사항을 정의하고, 세부기능을 분석하며 개발 범위를 정할때 작성함.
구성 요소
시스템에서 사용되는 객체타입을 정의함. 그들 간에 존재하는 정적인 관꼐를 다양한 방식으로 표현한 다이어그램.
구조
이름, 속성, 연산으로 구성되어있음.
관계
시스템이 수행하는 과정을 시각화하기 위한 다이어그램.
Use case 다이어그램의 actor와 개념 클래스 다이어그램의 객체 사이의 상호작용을 표현
종류
패키지는 클래스와 같은 여러 모델 요소들을 그룹화하여 표현하기 위한 수단이며, 패키지 다이어그램은 시스템의 서로 다른 패키지들 사이의 의존 관계를 표현하기 위한 다이어그램
구성 요소
객체가 가질 수 있는 모든 가능한 상태를 표현하며, 특정 객체에 대하여 사건 발생에 따른 상태 천이 과정을 묘사한 다이어그램. 진입 및 탈출 조건, 상태 전이에 필요한 사건에 대한 표현이 가능하며, 설계 단계에서 객체의 동적인 행동을 표현하는데 주로 사용된다.
구성 요소
객체의 로직이나 조건에 따른 처리 흐름을 순서에 따라 정의한 다이어그램. use case의 실체화, 알고리즘의 표현, 비지니스 프로세스의 정의 등에 사용이 가능함.
구성요소
https://m.blog.naver.com/icbanq/221781238065
https://googry.tistory.com/2
Comments powered by Disqus.
next.js에서 layout과 routing 경험을 개선시키고 React 최신 기술을 지원하기위해, next.js 13부터 지원하는 디렉터리 방식. 기존의 pages 디렉터리를 대체한다.
23년 04월 기준으로 아직은 베타버전으로 프로덕션에서 사용하는 건 추천하지 않는다고 한다. 하지만, 좋은 기능들이 많기에 학습해봐도 괜찮을 거 같다.
app directory에서 파일 컨벤션은 다음과 같다.
next.js 13부터는 path가 바뀌더라도 리렌더링 없이 이전 레이아웃을 유지할 수 있다. 이때 상태도 유지된다.
사용법은 다음과 같다.
layout.js로 생성하면, 그것이 레이아웃 컴포넌트이다.1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
// app/dashboard/layout.ts
+export default function DashboardLayout({
+ children, // will be a page or nested layout
+}: {
+ children: React.ReactNode,
+}) {
+ return (
+ <section>
+ {/* Include shared UI here e.g. a header or sidebar */}
+ <nav></nav>
+
+ {children}
+ </section>
+ );
+}
+
참고
layout.js와 page.js를 같은 폴더에 생성할 수 있다. layout.js가 page.js를 감싼다.app directory의 최상단에 반드시 있어야함. 이 root layout을 통해 클라이언트에서 최초에 받는 HTML을 수정할 수 있다. (pages 디렉터리에서의 _document.js 같은 느낌)
참고
<html>, <body>를 반드시 가지고 있어야한다.<head>를 수정하여 SEO를 지원할 수 있음.layout과 같이 child layout, page를 감싸지만, routing에 거쳐 상태가 유지되지않는다. path가 변경되면 리렌더링된다. 사용하려면, route segment에 template.js로 생성하면 된다. 그럼 다음과 같이 layout 아래에서 자식 컴포넌트를 감싸도록 적용된다.
1
+2
+3
+4
+
<Layout>
+ {/* Note that the template is given a unique key. */}
+ <Template key={routeParam}>{children}</Template>
+</Layout>
+
app directory를 사용하면, 서버컴포넌트를 간편하게 사용할 수 있다. 서버컴포넌트를 사용하면, 클라이언트에게 최초로 보내지는 JS 코드를 줄일 수 있어 빠른 페이지로딩에 도움을 준다.
app directory 아래에 있는 모든 컴포넌트는 기본적으로 서버컴포넌트이다. 따라서 서버컴포넌트를 사용하기 위해 별다른 작업이 필요없다.
route가 next.js에서 로딩되면, 최초의 HTML은 서버에서 렌더링 된다. 그리고 그 HTML는 점진적으로 브라우저에 전달된다. 이때 next.js와 react client-side runtime을 비동기적으로 로딩한다. 이로써 클라이언트가 어플리케이션을 다루고, 인터랙션할 수 있게 된다.
서버컴포넌트를 사용하면 최초 페이지 로딩은 빨라지고, client-side runtime은 캐시될 수 있으며 사이즈를 예측할 수 있다. 그리고 이 최초로 내려지는 JS 번들 사이즈는 어플리케이션 크기가 커지는만큼 따라 커지지 않는다. 클라이언트 컴포넌트를 통해 어플리케이션에 추가된 client-side interactivity만큼만 증가하게 된다.
app directory에서 network boundary는 서버 컴포넌트냐, 클라이언트 컴포넌트냐에 달려있다. pages directory에서는 getStaticProps, getServerSideProps에 달려있다.
next.js에서 클라이언트 컴포넌트는 서버에서 prerender 되고 클라이언트에서 hydration 된다. pages/ 디렉터리에서 동작하는 방식이다. app 디렉터리에서는 다음과 같이 파일 상단에 "use client";를 작성하면 클라이언트 컴포넌트가 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
'use client';
+import { useState } from 'react';
+
+export default function Counter() {
+ const [count, setCount] = useState(0);
+
+ return (
+ <div>
+ <p>You clicked {count} times</p>
+ <button onClick={() => setCount(count + 1)}>Click me</button>
+ </div>
+ );
+}
+
이때 클라이언트 번들로 포함되는 컴포넌트들은 다음과 같다.
"use client";가 작성된 컴포넌트"use client";가 작성된 컴포넌트에 import된 모든 컴포넌트들따라서 클라이언트 컴포넌트를 사용할 때는 최대한 말단 컴포넌트에서 사용할 것을 추천하고 있다.
next.js 팀에서는 서버 컴포넌트를 기본으로 사용하다가 클라이언트 컴포넌트는 필요할 때만 사용할 것을 추천한다. 그럼 언제 클라이언트 컴포넌트가 필요할까?
리액트에서 클라이언트 컴포넌트안에 서버컴포넌트를 importing 하는 건 제약이 있다. 서버 컴포넌트는 server-only code 이기 때문이다. 따라서 다음과 같이 클라이언트 컴포넌트에선 서버 컴포넌트를 import할 수 없다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
'use client';
+
+// ❌ This pattern will not work. You cannot import a Server
+// Component into a Client Component
+import ServerComponent from './ServerComponent';
+
+export default function ClientComponent() {
+ return (
+ <>
+ <ServerComponent />
+ </>
+ );
+}
+
하지만 클라이언트 컴포넌트에 props로 넘기는 것은 가능하다
1
+2
+3
+4
+5
+6
+7
+8
+9
+
'use client';
+
+export default function ClientComponent({children}) {
+ return (
+ <>
+ {children}
+ </>
+ );
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
// ✅ This pattern works. You can pass a Server Component
+// as a child or prop of a Client Component.
+import ClientComponent from "./ClientComponent";
+import ServerComponent from "./ServerComponent";
+
+// Pages are Server Components by default
+export default function Page() {
+ return (
+ <ClientComponent>
+ <ServerComponent />
+ </ClientComponent>
+ );
+}
+
이렇게 사용하면 리액트는 클라이언트 컴포넌트로 child를 넘기기 전에 <ServerComponent/>를 서버에서 렌더링해야한다는 것을 안다. 클라이언트 컴포넌트의 입장에서는 child 가 이미 렌더링 되어있다. layout이 이 방식으로 구현되어있다.
서버 컴포넌트에서 클라이언트 컴포넌트로 props를 넘길 땐 serialization 될 필요가 있다. function, Date 등은 직접 클라이언트 컴포넌트로 넘길 수 없다는 것이다.
server-only 패키지를 사용하여, 서버에서만 실행되어야하는 코드가 클라이언트 컴포넌트에서 사용되면 build-time error를 내도록 할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
import "server-only";
+
+export async function getData() {
+ let resp = await fetch("https://external-service.com/data", {
+ headers: {
+ authorization: process.env.API_KEY,
+ },
+ });
+
+ return resp.json();
+}
+
마찬가지로 client-only 패키지도 제공한다. 이 패키지는 window 객체를 사용하는 함수와 같이 클라이언트에서만 사용되어야하는 함수에서 사용할 수 있다.
현재 많은 서드파티 패키지들은 useState 등을 사용함에도 use client를 붙이지 않은 경우가 많다. 이러한 서드파티 패키지를 클라이언트 컴포넌트에서 사용하는 것은 큰 문제가 없다. 클라이언트 컴포넌트에 이미 use client가 붙어있기 때문이다. 하지만 서버 컴포넌트에서 사용할 땐 오류가 뜰 것이다. 따라서 서버 컴포넌트에서 사용할 경우엔 다음과 같이 서드파티 패키지를 감싸고 사용하면 된다.
1
+2
+3
+4
+5
+
'use client';
+
+import { AcmeCarousel } from 'acme-carousel';
+
+export default AcmeCarousel;
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
import Carousel from './carousel';
+
+export default function Page() {
+ return (
+ <div>
+ <p>View pictures</p>
+
+ {/* 🟢 Works, since Carousel is a Client Component */}
+ <Carousel />
+ </div>
+ );
+}
+
클라이언트 컴포넌트에서도 data feching은 할 수 있지만, 가능한 서버 컴포넌트에서 하는 것이 성능상 좋다.
클라이언트 컴포넌트에서는 context나 provider를 사용하여 context를 공유할 수 있다. 하지만, 서버 컴포넌트에서는 react state를 가지고 있지 않고, context는 보통 리렌더링할 때 필요하기 때문이다.
따라서 next.js 팀은 서버 컴포넌트 간에 데이터 교환을 위해 native javascript 패턴을 제안한다. 예를들어 만약 여러 서버 컴포넌트 사이에서 DB connection을 공유해야한다면 다음과 같이 사용할 수 있다.
1
+2
+
// utils/database.js
+export const db = new DatabaseConnection(...);
+
1
+2
+3
+4
+5
+6
+7
+
// app/users/layout.js
+import { db } from "@utils/database";
+
+export async function UsersLayout() {
+ let users = await db.query(...);
+ // ...
+}
+
1
+2
+3
+4
+5
+6
+7
+
// app/users/[id]/pages.js
+import { db } from "@utils/database";
+
+export async function DashboardPage() {
+ let user = await db.query(...);
+ // ...
+}
+
한편, 서버 컴포넌트에서 fetch 요청을 자동으로 중복제거된다. 따라서 fetch request result를 어떻게 공유할지는 걱정하지 않아도 된다. revalidate 등은 어떻게 하는지는 밑에 data fetching 섹션에서 다룬다.
fetch Web API는 React와 next.js에서 확장되었다.
이를 통해 next.js에서는 하나의 API로 SSG, SSR, ISR을 사용가능하다. (fetch에 대해서)
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
// This request should be cached until manually invalidated.
+// Similar to `getStaticProps`.
+// `force-cache` is the default and can be omitted.
+fetch(URL, { cache: 'force-cache' });
+
+// This request should be refetched on every request.
+// Similar to `getServerSideProps`.
+fetch(URL, { cache: 'no-store' });
+
+// This request should be cached with a lifetime of 10 seconds.
+// Similar to `getStaticProps` with the `revalidate` option.
+fetch(URL, { next: { revalidate: 10 } });
+
next.js에서는 웬만하면 서버 컴포넌트에서 data fetching 수행을 권장한다. 다음과 같은 이점이 있기 때문이다.
클라이언트 컴포넌트에서도 data fetching은 가능하지만, 그때는 SWR나 React Query 사용을 추천하고 있다. 향후 React의 use() hook을 사용할 수도 있다고 한다.
컴포넌트에서 data fetching을 수행할때 두가지 모델이 있다.
또한 위에 언급했듯이 fetch()은 자동으로 deduping 된다. 만약 트리내 여러 컴포넌트에서 같은 데이터를 원한다면, next.js는 자동으로 fetch request(GET)를 캐싱하고 같은 요청이 발생하면 저장했던 것을 돌려준다.
fetch 요청에 적용된다.만약 fetch() 를 사용할 수 없는 상황이라면 cache function을 사용해도 된다.
두가지 타입의 데이터가 존재한다.
기본적으로 next.js에서는 static fetch를 한다. 이는 빌드타임에 fetch되어 캐시되고 각 요청마다 사용한다는 말이다. 하지만 dynamic fetch를 해야할 때도 있는데, next.js는 캐시를 무효화하거나 revalidating 하는 방법을 제공한다.
1
+
fetch(URL, { cache: 'no-store' });
+
revalidating
background : time interval을 주어 주기적으로 다시 fetch
1
+
fetch(URL, { next: { revalidate: 10 } });
+
on-demand : update가 있을 때마다 refetch (예제)
next.js에서는 Streaming과 Suspense에 대한 지원도 잘 되어있다. Layout 섹션에서 보았듯이 화면의 일부는 즉시 내려보내고, 일부는 비동기적으로 loading 화면을 보여주었다가 data fetching이 완료되면 내려보낸다. 이를 통해 유저는 페이지의 모든 부분을 로드할 필요가 없다.
The Next.js Cache is a persistent HTTP cache that can be globally distributed. This means the cache can scale automatically and be shared across multiple regions depending on your platform (e.g. Vercel).
next.js는 fetch()의 options 객체를 확장하여 서버에서 이루어지는 각 요청이 persistent caching 동작이 이루어지도록 설정할 수 있다. 이를 통해 데이터를 사용하는 어플리케이션 코드에서 캐싱 동작을 설정할 수 있다.
https://beta.nextjs.org/docs/routing/fundamentals
Comments powered by Disqus.
애플리케이션에서 인스턴스를 하나만 만들어 사용하기 위한 패턴이다.
커넥션 풀, 스레드 풀, 디바이스 설정 객체 등의 경우, 인스턴스를 여러 개 만들게하면 자원을 낭비하게 되거나 버그를 발생시킬 수 있으므로 오직 하나만 생성하고 그 인스턴스를 사용하도록 하는 것이 목적이다.
하나의 인스턴스만을 유지하기 위해 인스턴스 생성에 특별한 제약을 걸어둬야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
public class Singleton {
+ private static Singleton singletonObject;
+
+ private Singleton() {}
+
+ public static Singleton getInstance() {
+ if (singletonObject == null) {
+ singletonObject = new Singleton();
+ }
+ return singletonObject;
+ }
+}
+
위 코드는 멀티 스레딩환경에서 싱글턴 패턴을 적용할떄 문제가 발생한다. 동시에 접근하다가 하나만 생성되어야하는 인스턴스가 두개 생성될 수 있기때문이다. 따라서 getInstance() 메소드를 동기화 시켜야 한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
public class Singleton {
+ private static Singleton singletonObject;
+
+ private Singleton() {}
+
+ public static synchronized Singleton getInstance() {
+ if (singletonObject == null) {
+ singletonObject = new Singleton();
+ }
+ return singletonObject;
+ }
+}
+
좀 더 효율적으로 하려면, DCL(double checking locking)을 써서 getInstance() 에서 동기화 되는 영역을 줄일 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
public class Singleton {
+ private static volatile Singleton singletonObject;
+
+ private Singleton() {}
+
+ public static Singleton getInstance() {
+ if (singletonObject == null) {
+ synchronized (Singleton.class) {
+ if(singletonObject == null) {
+ singletonObject = new Singleton();
+ }
+ }
+ }
+ return singletonObject;
+ }
+}
+
이때 위 코드는, 멀티코어 환경에서 하나의 CPU를 제외하고는 다른 CPU가 lock이 걸리게 된다. 따라서 다른 방법이 필요하다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
public class Singleton {
+ private static volatile Singleton singletonObject = new Singleton();
+
+ private Singleton() {}
+
+ public static Singleton getSingletonObject() {
+ return singletonObject;
+ }
+}
+
volatile : 컴파일러가 특정변수에 대해 옵티마이져가 캐싱을 적용하지 못하도록 하는 키워드이다.
Comments powered by Disqus.
기존의 function 표현방식보다 간결하게 함수를 표현할 수 있다. 화살표함수는 항상 익명이며, 자신의 this, arguments, super, new.target을 바인딩하지 않는다. 따라서 생성자로는 사용할 수 없다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
var materials = ["Hydrogen", "Helium", "Lithium", "Beryllium"];
+
+materials.map(function (material) {
+ return material.length;
+}); // [8, 6, 7, 9]
+
+materials.map((material) => {
+ return material.length;
+}); // [8, 6, 7, 9]
+
+materials.map(({ length }) => length); // [8, 6, 7, 9]
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+
function Person() {
+ this.age = 0;
+
+ setInterval(() => {
+ this.age++; // |this|는 person 객체를 참조
+ }, 1000);
+}
+
+var p = new Person();
+
일반 함수에서 this는 전역객체를 this로 정의한다. 하지만 화살표 함수 this는 상위 스코프의 this와 동일한 값을 갖는다. 따라서 위 예제에서 setInterval로 전달된 this는 Person의 this를 가리키며, Person 객체의 age에 접근한다.
메소드
1
+2
+3
+4
+5
+6
+
const cat = {
+ name: 'meow';
+ callName: () => console.log(this.name);
+}
+
+cat.callName(); // undefined
+
이 경우 화살표함수의 상위 스코프는 전역 this가 된다. 따라서 메소드로 화살표함수를 사용하면 안된다.
메소드의 경우, 호출한 객체의 this로 바인딩되니 일반 함수를 사용하자
1
+2
+
const Foo = () => {};
+const foo = new Foo(); // TypeError: Foo is not a constructor
+
화살표함수에는 prototype이 없기에 생성자로 사용할 수는 없다.
addEventListener()의 콜백함수
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
const button = document.getElementById("myButton");
+
+button.addEventListener("click", () => {
+ console.log(this); // Window
+ this.innerHTML = "clicked";
+});
+
+button.addEventListener("click", function () {
+ console.log(this); // button 엘리먼트
+ this.innerHTML = "clicked";
+});
+
addEventListener의 콜백함수에서 this 는 이벤트리스너가 호출된 엘리먼트로 바인딩된다.
하지만 화살표함수를 사용할 경우 상위스코프로 바인딩되므로, 전역 this가 사용되게 된다.
https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/JavaScript#promise
https://velog.io/@padoling/JavaScript-%ED%99%94%EC%82%B4%ED%91%9C-%ED%95%A8%EC%88%98%EC%99%80-this-%EB%B0%94%EC%9D%B8%EB%94%A9
Comments powered by Disqus.
자바스크립트 트랜스파일러.
보통 모던 자바스크립트를 호환성을 위해 예전 문법으로 변환할때 사용한다.
Typescript와 JSX 코드를 변환할 때도 사용한다.
바벨 설정 파일 예시
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
{
+ "presets": [
+ [
+ "@babel/env",
+ {
+ "targets": {
+ "chrome": "79", // 예시) 크롬 79까지 지원하는 코드를 만든다.
+ "edge": "17",
+ "firefox": "60",
+ "safari": "11.1",
+ },
+ "useBuiltIns": "usage",
+ }
+ ]
+ ]
+}
+
@babel/preset-env : ES6 이상 문법을 ES5 문법의 코드로 변환해주는 규칙을 정의함.@babel/preset-react : 리액트 코드 변환babel을 사용해도 변환할 수 없는 모던자바스크립트 코드들이 있다. 바로 Promise와 같은 것들인데, 이를 변환하기 위해선 Polyfill을 사용하여야한다.
바벨에서 설정하여도 되고, 웹팩에서 설정해도 된다.
바벨에서 사용할때는 @babel/plugin-transform-runtime 사용(@babel/polyfill은 deprecated)
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
{
+ "plugins": [
+ [
+ "@babel/plugin-transform-runtime",
+ {
+ "absoluteRuntime": false,
+ "corejs": 3,
+ "helpers": true,
+ "regenerator": true,
+ "useESModules": false
+ }
+ ]
+ ]
+}
+
https://www.daleseo.com/js-babel/
https://ingg.dev/babel/
https://okchangwon.tistory.com/3
Comments powered by Disqus.
pageshow
pagehide
크롬에서 지원되는 이벤트
freeze
resume
rel="noopener"를 사용하지 않고 열면 새로운 페이지는 window.opener를 가지고 있고, 이 opener를 가지고 있는 페이지는 bfcache에 넣지 않는다.Tabnabbing 보안 취약점 공격과도 연관된 부분이기 때문이다. (Tabnabbing 공격)아래와 같이 Cache-Control 속성을 설정하면 된다.
1
+
Cache-Control: no-store
+
물론 다른 캐시들도 동작하지 않는다.
두 경우 모두 pageshow 이벤트를 사용하여 정상적으로 수행하도록 해야한다.
https://blog.naver.com/PostView.nhn?blogId=qls0147&logNo=222157982248&categoryNo=0&parentCategoryNo=0&viewDate=¤tPage=1&postListTopCurrentPage=1&from=postView
Comments powered by Disqus.
소프트웨어의 내부 구조나 작동 원리는 모르는 상태에서 동작을 검사하는 방식
기법
내부 동작을 알고 디테일하게 검사
기법
https://www.crocus.co.kr/1681
Comments powered by Disqus.
소프트웨어 개발 시 사용되는 분석 자동화 도구. 소프트웨어 개발 과정의 일부나 전체를 자동화하는 도구이다.
CAD 기기와 유사한 것이라고 생각하면 됨.
요구분석 -> 설계 -> 구현 -> 검사 및 디버깅 과정을 CASE를 활용하여 자동화함계획과 분석 설계 단계를 지원. 다이어그램 그리기, 명세서 작성 등의 기능을 제공
CASE 환경의 여러 도구들이 상호연관 되어 동작할 수 있도록 도와주는 구심체 역할을 하는 데이터 저장소. 저장소가 없으면 각 기능간의 데이터 연결이 안되고, 따라서 그때그때 데이터를 다시 입력해줘야함.
https://velog.io/@kipsong/%EC%A0%95%EB%B3%B4%EC%B2%98%EB%A6%AC%EA%B8%B0%EC%82%AC-CASEComputer-Aided-Software-Engineering
Comments powered by Disqus.
두개의 함수로 만들어진 환경으로 이루어진 특별한 객체의 한 종류이다. 여기서 환경이란, 클로저가 생성될 때 그 범위에 있던 여러 지역변수들이 포함된 context를 말한다. 이 클로저를 통해서 자바스크립트에는 없는 private 속성/메소드, public 속성/메소드를 구현할 수 있다.
다음은 클로저가 생성되는 조건이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
var name = `Warning`;
+function outer() {
+ var name = `closure`;
+ return function inner() {
+ console.log(name);
+ };
+}
+
+var callFunc = outer();
+callFunc();
+// console> closure
+
위 코드에서 callFunc을 클로저라고 한다. callFunc호출에 의해 name이라는 값이 console 에 찍히는데, 찍히는 값은 Warning이 아니라 closure라는 값이다. 즉, outer 함수의 context 에 속해있는 변수를 참조하는 것이다. 여기서 outer함수의 지역변수로 존재하는 name변수를 free variable(자유변수)라고 한다.
이렇게 외부함수가 내부함수를 반환할때, 내부함수에서 사용하는 변수도 함께 묶어 반환한다.
이처럼 외부함수 호출이 종료되더라도, 외부 함수의 지역변수 및 변수 스코프 객체의 체인 관계를 유지할 수 있는 구조를 클로저라고 한다. 보다 정확히는 외부 함수에 의해 반환되는 내부함수를 가리키는 말이다.
https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/JavaScript
Comments powered by Disqus.
OS에 속하며, 컴퓨터에서 항상 수행되는 프로그램.
하드웨어의 자원을 자원이 필요한 프로세스에게 나눠주고, 프로세스 제어, 메모리 제어, 시스템 콜 등을 수행하는 부분이다.
cpu, disk(buffer), memory, usb(buffer), graphic adapter(buffer)
각 I/O 장치들은, 각 장치 내부의 디바이스 컨트롤러가 있고, 이 디바이스 컨트롤러가 각 장치를 직접 다룸.
또 로컬버퍼를 가지고 있으며 이것은 시스템 버스에 연결돼있음
디바이스 컨트롤러는 데이터를 디바이스에서 로컬 버퍼로, 또 로컬버퍼에서 디바이스로 옮김
cpu는 메인 메모리를 통해 각 디바이스의 로컬 버퍼로 데이터를 보내거나 받음.
cpu와 각 I/O 디바이스는 각자의 작업을 독립적으로 수행함.
디바이스 컨트롤러는 인터럽트를 통해 CPU에게 작업의 끝을 알림.
키보드를 치는 작은 하나하나의 작업도 인터럽트이다. CPU는 인터럽트가 올때마다 하던일을 멈추고, ISR로 인터럽트를 처리함.
Comments powered by Disqus.
CSS의 존재만으로도, CSS가 파싱되기 전까지 브라우저는 렌더링이 지연된다. 만약 브라우저가 CSS가 없는 페이지를 그대로 노출하면, 스타일적용이 되지않은 페이지가 나타나기 때문이다. 이를 FOUC라고 불린다.
브라우저가 CSS가 파싱되기 전까지 콘텐츠를 보여주지 않더라고, HTML의 로딩된 부분만을 일단 보여줄 수 있다. 그러나 스크립트의 경우 async defer 가 없다면 파싱을 막게 된다. 스크립트는 잠재적으로 페이지를 조작할 여자기 있기때문에 브라우저는 스크립트 실행에 매우 주의를 기울이기 때문이다.
스크립트가 페이지의 스타일에 영향을 줄 수 있기 때문에, 만약 브라우저가 CSS 관련 작업을 진행중이라면, 이 작업이 완료될 때까지 기다렸다가 스크립트를 실행할 것이다. 스크립트가 실행되기 전까지 문서 파싱을 할 수 없기 때문에, CSS는 더이상 렌더링을 차단하는 요소로 작용하지 않는다. 문서의 외부 스타일시트 및 스크립트 순서에 따라서 때로는 HTML 파싱도 중지할 수 있다.
따라서 파싱이 차단되는 상황을 피하기 위해서는 CSS를 최대한 빨리 불러와야하고, 리소스를 최적의 순서로 불러와야한다.
CSS minify
사용하지 않는 CSS 제거
CSS 우선순위 정하기
non-critical CSS는 비동기로 불러오기
1
+2
+3
+4
+5
+6
+
<link
+ rel="stylesheet"
+ href="non-critical.css"
+ media="print"
+ onload="this.media='all'"
+/>
+
media="print"는 사용자가 페이지를 프린트하려고 하는 경우에만 불러오는 스타일시트로, 렌더링에는 영향을 미치지 않는다.
onload="this.media='all'"는 스타일시트 로드가 완료되면 미디어 속성을 다시 all로 바꾸면서 스타일시트가 적용되도록 하는 것이다.
페이지에 애니메이션이 있는 요소가 있는 경우, 브라우저는 종종 문서 내 요소의 위치와 크기를 재계산한다. 예를 들어 어떤 요소의 너비를 바꾸게 되면, 그 자식 요소들까지 영향을 미치면서 페이지 내부에서 큰 레이아웃 변경이 발생할 수 있다. 이 레이아웃의 크기가 커질 수록 성능에 안좋은 영향을 미칠 것이다.
height width 대신 transform: scale() 사용하기top right bottom left 대신 transform :translate()를 사용한다.CSS가 적용되는 4가지 순서
Styles
브라우저가 객체에 적용할 스타일의 값을 계산, 재계산한다.
Layout
| position | display | overflow | width | height |
|---|---|---|---|---|
| min-width | min-height | padding | margin | border |
| top | bottom | left | right | font |
| white-space | line-height | vertical-align | float | clear |
Paint
| color | background | visibility | text-decoration |
|---|---|---|---|
| border-radius | border-style | box-shadow |
Composite
transform, opacity
위 순서에 따르면, width나 height 등 Layout 속성을 바꾸면, Paint, Composite 순서를 거치기 때문에 성능 저하가 이루어진다. 이것을 Reflow라고 한다. 또한 Paint속성을 바꾸면 Composite 를 거치기에 성능저하가 이루어지고, 이것을 Repaint라고 한다.
따라서 성능을 최대로 올리려면 Composite속성만 바꾸는 것이 최고의 방법이다.
GPU 가속을 이용하여 애니메이션 프레임을 최대로 끌어올릴 수 있다. will-change 옵션을 사용하여 GPU 가속을 사용할 수 있다. 브라우저에게 예상되는 변화에 대한 힌트를 미리 제공하여 실제 요소가 변화되기 전에 브라우저가 적절하게 최적화할 수 있도록 하는 방법이다. 하지만 과도하게 사용할 경우 많은 기기 자원을 소모한다. 따라서 적절히 사용한다.
1
+2
+3
+4
+5
+6
+
.app-menu {
+ -webkit-transform: translateX(-100%);
+ transform: translateX(-100%);
+ transition: transform 300ms linear;
+ will-change: transform;
+}
+
이벤트가 끝나면, 해당 이벤트를 위한 html class는 제거해줘야한다. 클래스를 추가하는 것은 자식요소의 DOM Tree를 변경하는 성능저하를 유발하기 때문이다.
contain은 브라우저에 요소와 하위 요소가 그 문서 트리와 무관한 것으로 간주된다는 것을 알려주는 속성이다. 페이지의 하위트리와 나머지 페이를 분리한다. 그런다음, 브라우저는 페이지에서 독립된 부분의 렌더링을 최적화하여 성능을 향상 시킬 수 있다.
contain은 페이지 내부에서 독립적으로 작동하는 위젝 등에서 효과적이다. 위젯 내부의 변경사항이 바깥으로 전파되는 것을 막을 수 있다.
Variable Font는 모든 너비, weight, style에 대해서 별도의 폰트파일이 아니라 하나의 파일에 여러가지 다양한 폰트를 통합해줄 수 있도록 한다. CSS와 단일 @font-face 참조로 지정된 글꼴의 다양한 변형에 액세스할 수 있다.
이는 글꼴의 여러 변형이 필요한 파일 크기를 획기적으로 줄일 수 있다. 일반, 볼드, 기울임꼴 폰트 버전을 각각 로딩하는 대신 모든 정보가 포함된 하나의 단일 파일을 로딩할 수 있다.
브라우저는 셀렉터는 오른쪽에서 왼쪽으로 읽기에 자식에서부터 부모로 거쳐서 올라가게 된다. 예를들어 nav a {}는 먼저 a를 찾고, 그 중 부모가 nav 인것을 찾는다. 따라서 선택자는 짧은게 더 빠르다.
하지만, 브라우저가 선택자를 매칭시키는 속도는 매우 빠르기에 걱정할 필요가 없다.
https://yceffort.kr/2021/03/improve-css-performance
Comments powered by Disqus.
아무 표시 없이 사용하면 페이지에 있는 모든 요소가 대상
1
+2
+3
+4
+
* {
+ margin : 0;
+ padding : 0;
+}
+
특정 요소의 모든 자식 요소에 적용할 수도 있음
1
+2
+3
+
#container * {
+ border : 1px solid black;
+}
+
주의점 : 남발할 시 성능저하를 불러일으킴
id를 대상으로 삼음
1
+2
+3
+4
+
#container {
+ width : 960px;
+ margin : auto;
+}
+
주의점 : id는 유연성이 부족하기 때문에, 꼭 id를 사용해야하는지 자문하자.
class 선택자
id와는 다르게 여러개의 요소를 대상으로 정할 수 있음
1
+2
+3
+
.error {
+ color : red;
+}
+
X요소의 하위 요소중 모든 Y요소에 적용
1
+2
+3
+
li a {
+ text-decoration : none;
+}
+
페이지에 있는 모든 X요소에 적용
1
+2
+3
+4
+5
+6
+
a {
+ color : red;
+}
+ul {
+ margin-left:0;
+}
+
1
+2
+3
+4
+5
+6
+
a:link {
+ color:red;
+}
+a:visited {
+ color : purple;
+}
+
X 요소 바로 뒤에 있는 요소만 선택함
1
+2
+3
+
ul + p {
+ color:red;
+}
+
X 요소의 직계 자식만을 선택함
1
+2
+3
+
div#container > ul {
+ border : 1px solid black;
+}
+
형제 선택자로, X 요소의 아래에 있는 모든 Y 요소에 적용됨
1
+2
+3
+
ul ~ p {
+ color : red;
+}
+
X 요소 중 title 속성이 있는 태그만 선택함
1
+2
+3
+
a[title] {
+ color : green;
+}
+
X 요소의 bar 속성의 값이 “foo” 인 태그만 선택
1
+2
+3
+
a[href="https://naver.com"] {
+ color : #1f6053;
+}
+
X 요소의 bar 속성에 “foo”가 있는 태그를 선택
1
+2
+3
+
a[href*="naver"] {
+ color : #1f6053;
+}
+
ex) https://naver.com, https:www.naver.com, http://www.naver.com 모두에 적용됨
bar 속성이 “foo”로 시작할시 적용
1
+2
+3
+4
+
a[href^="http"] {
+ background: url(path/to/external/icon.png) no-repeat;
+ padding-left: 10px;
+}
+
bar 속성의 값이 “foo” 로 끝날 시 적용
1
+2
+3
+
a[href$=".jpg"] {
+ color: red;
+}
+
foo의 띄어쓰기로 구분되는 속성값 중 “bar”가 있으면 적용
1
+2
+3
+4
+5
+6
+
a[data-info~="external"] {
+ color:red;
+}
+a[data-info~="image"] {
+ border:1px solid black;
+}
+
ex)
1
+2
+3
+4
+5
+6
+
// 두 개 다 적용
+<a href="path/to/image.jpg" data-info="external image"> Click Me, Fool </a>
+// external만 적용
+<a href="path/to/image.jpg" data-info="external"> Click Me, Fool </a>
+// image만 적용
+<a href="path/to/image.jpg" data-info="image"> Click Me, Fool </a>
+
라디오버튼이나 체크박스처럼 체크되는 사용자 인터페이스 요소만을 대상으로 함
1
+2
+3
+
input[type=radio]:checked {
+ border: 1px solid black;
+}
+
이때 content 속성값을 통해 특정 내용을 출력할 수도 있다.
사용자가 요소 위에 마우스를 올렸을때 적용
1
+2
+3
+
div:hover {
+ background : #e3e3e3;
+}
+
모든 X에 적용하고 싶은데, (선택자)로 지정된 것만 빼고 싶을때 사용
1
+2
+3
+4
+5
+6
+7
+
div:not(#container) {
+ color : blue;
+}
+
+*:not(p) {
+ color:green;
+}
+
첫번째 줄이나 첫 글자에 스타일을 적용할때 사용가능.
반드시 블록 레벨 요소에 적용해야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
p::first-line {
+ font-weight :bold;
+ font-size:1.2em;
+}
+p::first-letter {
+ float:left;
+ font-size:2em;
+ font-weight:bold;
+ font-family : cursive;
+ padding-right:2px;
+}
+
::after, ::before 도 가상요소이다.
X의 n번째 자식에만 적용
1
+2
+3
+
li:nth-child(3) {
+ color:red;
+}
+
X의 마지막 n번째 자식에만 적용
1
+2
+3
+
li:nth-last-child(2) {
+ color:red;
+}
+
X와 같은 요소의 n번째 형제를 선택한다.
1
+2
+3
+
li:nth-of-type(3) {
+ border:1px solid black;
+}
+
X와 같은 요소의 형제 중 마지막 n번째를 선택함
1
+2
+3
+
ul:nth-last-of-type(3) {
+ border: 1px solid black;
+}
+
부모 요소의 첫번째/마지막 자식에만 적용 가능
1
+2
+3
+4
+5
+6
+
ul li:first-child {
+ border-top : none;
+}
+ul > li:last-child {
+ border-top : none;
+}
+
부모 요소의 단 하나의 자식요소를 지정할 수 있다.
만약 부모에 여러 X가 있을땐 적용이 되지 않음
1
+2
+3
+
div p:only-child {
+ color :red
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
<div>
+ <p>
+ 적용됨
+ </p>
+</div>
+<div>
+ <p>
+ 적용안됨
+ </p>
+ <p>
+ 적용안됨
+ </p>
+</div>
+
부모 컨테이너에 형제 요소가 없는 요소를 대상으로 함
1
+2
+3
+4
+5
+6
+
li:only-of-type {
+ font-weight:bold;
+}
+ul > li:only-of-type {
+ font-weight:bold;
+}
+
해당 type의 첫번째 형제 선택자를 선택함
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
<div>
+ <p> My paragraph here. </p>
+ <ul>
+ <li> List Item 1 </li>
+ <li> List Item 2 </li>
+ </ul>
+
+ <ul>
+ <li> List Item 3 </li>
+ <li> List Item 4 </li>
+ </ul>
+</div>
+
위 html에서 List Item 2 에만 스타일을 적용하는 방법은 아래와 같이 3가지가 있음
1
+2
+3
+4
+5
+6
+7
+8
+9
+
ul:first-of-type > li:nth-child(2) {
+ font-weight: bold;
+}
+p + ul li:last-child {
+ font-weight: bold;
+}
+ul:first-of-type li:nth-last-child(1) {
+ font-weight: bold;
+}
+
https://code.tutsplus.com/ko/tutorials/the-30-css-selectors-you-must-memorize–net-16048
Comments powered by Disqus.
용어
릴레이션 : 하나의 개체에 관한 데이터를 2차원 테이블로 저장한 것.
도메인 : 하나의 속성이 가질 수 있는 모든 값의 집합. 적합성 판단의 기준이 됨
데이터베이스 스키마 : 데이터베이스의 전체구조. 릴레이션 스키마의 모음
데이터베이스 인스턴스 : 데이터베이스를 구성하는 릴레이션 인스턴스의 모음
데이터의 무결성을 보장하기 위한 규칙
개체 무결성 제약조건 : 기본키를 구성하는 모든 속성은 널 값을 가질 수 없다
참조 무결성 제악조건 : 외래키는 참조할 수 없는 값을 가질 수 없다.
Comments powered by Disqus.
파일시스템의 문제점
데이터베이스 특징
데이터베이스 성능
데이터베이스 성능 이슈는 디스크 I/O를 줄이는 것에서 시작함.
디스크 I/O는 디스크 헤더의 이동을 최소화해야 빨라짐. 따라서 순차 I/O가 랜덤 I/O보다 빠름.
따라서 데이터베이스 쿼리 튜닝은 랜덤 I/O 자체를 줄여주는 것이 목적
다음과 같은 이상현상을 해결하기 위해
관계형 데이터베이스에서 중복을 최소화하기 위해 데이터를 구조화하는 작업이다. 나쁜 릴레이션을 좋은 작은 릴레이션으로 분해하는 작업이다.
정규화 조건
제 1 정규형
각 속성이 오직 원자값만을 포함하도록 하는 것.
제 2 정규형
모든 비주요 애트리뷰트들이 주요 애트리뷰트에 대해서 완전 함수적 종속이면 제 2 정규형을 만족한다고 볼 수 있다. 완전 함수적 종속이란 X -> Y 라고 가정했을 때, X 의 어떠한 애트리뷰트라도 제거하면 더 이상 함수적 종속성이 성립하지 않는 경우를 말한다. 즉, 키가 아닌 열들이 각각 후보키에 대해 결정되는 릴레이션 형태를 말한다.
제 3 정규형
어떠한 비주요 속성도 기본키에 대해서 이행 종속되지 않으면 만족한다.
BCNF 정규형
여러 후보키가 존재하는 릴레이션에 해당하는 정규화 내용. 복잡한 식별자 관계에 의해 발생하는 문제를 해결하기 위해 제 3 정규형을 보완하는데 의미가 있음. 비주요 속성이 후보키의 일부를 결정하는 것을 분해하는 것.
조회를 하는 SQL 문장에서 조인이 많이 발생하여 이로인한 성능저하가 나타나는 경우에 반정규화를 적용해야한다.
반정규화(비정규화)
반정규화는 정규화된 엔티티, 속성, 관계를 시스템의 성능 향상 및 개발과 운영의 단순화를 위해 중복 통합, 분리 등을 수행하는 데이터 모델링 기법 중 하나이다.반정규화의 대상
반정규화의 주의점
반정규화를 과도하게하면, 데이터의 무결성이 깨질수있음. 또한 입력, 수정, 삭제의 질의문에 대한 응답시간이 느려질 수 있음.
하나의 논리적인 작업을 수행하는 쿼리문들을 묶은 것. 트랜잭션에 속한 쿼리문들은 모두 완벽히 수행되거나, 그렇지 않으면 원상복구해야한다.
트랜잭션을 동시에 수행할때, 동시성을 제어해주기 위한 기능. 여러 커넥션에서 동시에 동일한 자원을 요청할 경우 순서대로 한 시점에는 하나의 커넥션만 변경할 수 있게 해주는 역할
원자성 : 트랜잭션 수행중 문제가 발생하면, 트랜잭션의 어떠한 작업도 데이터베이스에 반영되면 안됨.
일관성 : 트랜잭션이 완료된 다음의 상태에서도, 트랜잭션이 일어나기 전의 상황과 동일하게 데이터의 일관성을 보장해야함.
고립성 : 각 트랜잭션은 서로 간섭없이 독립적으로 수행되어야함.
지속성 : 트랜잭션이 정상적으로 종료된 다음에는, 영구적으로 데이터베이스에 작업의 결과가 반영되어야함.
트랜잭션의 범위는 최소화해야한다. 일반적으로 데이터베이스 커넥션은 개수가 제한적이고, 따라서 각 트랜잭션이 커넥션을 소유하는 시간이 길어지면, 다른 트랜잭션은 커넥션을 가져가기 위해 기다려야하는 상황이 발생할 수 있기 때문이다.
두 개 이상의 트랜잭션이 특정 사원의 잠금을 획득한 채, 다른 트랜잭션이 소유하고 있는 잠금을 요구하는 상황이 원형으로 이루어지고 있는 상태. 아무리 기다려도 잠금이 풀리는 일이 없는 상태이다.
예시
교착상태의 빈도를 낮추는 방법
관계형 데이터 모델을 지양함. 대량의 분산된 데이터를 저장하고 조회하는데 특화되어있으며 스키마없이 사용가능하거나 느슨한 스키마를 제공하는 저장소.
종류마다 쓰기/읽기 특화, 2차인덱스 지원, 오토샤딩 지원 같은 고유한 특성을 가짐. 대량의 데이터를 빠르게 처리하기 위해 메모리에 임시저장하고 응답하는 등의 방법을 사용함. 동적인 스케일 아웃을 지원하기도 하며, 가용성을 위하여 데이터복제 등의 방법으로 RDBMS가 제공하지 못하는 성능과 특징을 제공한다.
어떠한 분산시스템도 아래 세가지를 모두 만족할 수 없다는 이론.
1. 일관성(Consistency)
다중 클라이언트에서 같은 시간에 조회하는 데이터는 항상 동일한 데이터임을 보증하는 것을 의미. RDBMS에서는 기본적으로 제공하나, 일관성을 지원하지 않는 NoSQL을 사용하면 데이터의 일관성이 느슨하게 처리되어 동일한 데이터가 나타나지 않을 수 있음.
느슨하게 처리된다는 것은 데이터의 변경을 시간의 흐름에 따라 여러 노드에 전파하는 것을 의미한다.
NoSQL에서 분산 노드 간의 데이터 동기화를 위해 두가지 방법을 사용함.
2. 가용성(Availability)
모든 클라이언트의 읽기와 쓰기 요청에 대해 항상 응답이 가능해야함을 보증하는 것. 가용성을 가진 NoSQL은 클러스터 내에서 몇 개의 노드가 망가지더라도, 정상적인 서비스가 가능함.
몇몇 NoSQL은 가용성을 보장하기 위해 데이터 복제를 사용함. 동일한 데이터를 다중 노드에 중복 저장하여 그 중 몇 대가 고장나도 데이터가 유실되지 않도록 하는 것. 데이터 중복 저장 방법에는 동일한 데이터를 가진 저장소를 하나 더 생성하는 Master-slave와 데이터 단위로 중복저장하는 peer-to-peer 방법이 있다.
3. 네트워크 분할 허용성(partition tolerance)
지역적으로 분할된 네트워크 환경에서 동작하는 시스템에서, 두 지역간의 네트워크가 단절되거나 네트워크 데이터의 유실이 일어나더라도 각 지역내의 시스템은 정상적으로 동작해야함을 의히함.
Key-value model
키 하나로 데이터 하나를 저장하고 조회할 수 있는 단일 키-값 구조를 가짐. 단순한 저장구조이며, 복잡한 조회연산을 지원하지 않는다. 따라서 고속읽기와 쓰기에 최적화되어있다.
사용자의 프로필 정보, 웹 서버 클러스터를 위한 세션정보, 장바구니 정보, URL 단축 정보저장 등에 사용된다.
하나의 서비스 요청에 다수의 데이터 조회 및 수정 연산이 발생하면 트랜잭션 처리가 불가능하여 데이터 정합성을 보장할 수 있음
Redis 등이 있음
Document model
key-value의 확장. 하나의 키에 구조화된 문서를 저장하고 조회하는 방식. 논리적인 데이터 저장과 조회 방법이 RDBMS와 유사함.
키는 문서에 대한 id로 표현됨. 또한 저장된 문서를 컬렉션으로 관리하여 문서 저장과 동시에 문서id에 대한 인덱스를 생성한다. 문서 id에 대한 인덱스를 사용하여 O(1) 시간안에 문서를 조회할 수 있다.
대부분의 문서모델 NoSQL은 B트리 인덱스를 사용하여 2차인덱스를 생성한다. B트리는 크기가 커지면 커질수록 새로운 데이터를 입력하거나 삭제할 때 성능이 떨어지게 된다. 그렇기 때문에 읽기와 쓰기의 비율이 7:3 정도일때 가장 좋은 성능을 보인다.
중앙 집중식 로그 저장, 타임라인 저장, 통계정보저장 등에 사용된다.
MongoDB 등이 있음
Column model
하나의 키에 여러개의 컬럼이름과 컬럼 값의 쌍으로 이루어진 데이터를 저장하고 조회하낟. 모든 컬럼은 항상 타음스탬프 값과 함께 저장된다.
구글의 빅테이블이 대표적인 예로, 차후 컬럼형 NoSQL은 빅테이블의 영향을 받았다. Row key, Column Key, Column Family 같은 빅테이블 개념이 공통적으로 사용된다. 저장의 기본 단위는 컬럼으로 컬럼은 컬럼 이름과 컬럼 값, 타임스탬프로 구성된다. 이러한 컬럼들의 집합이 로우(Row)이며, 로우키(Row key)는 각 로우를 유일하게 식별하는 값이다. 이러한 로우들의 집합은 키 스페이스(Key Space)가 된다.
컬럼모델 NoSQL은 쓰기에 더 특화되어있다. 데이터를 먼저 커밋로그와 메모리에 저장한 후 응답하기 때문에 빠른 응답속도를 제공한다. 그렇기 때문에 읽기 연산 대비 쓰기 연산이 많은 서비스나 빠른 시간 안에 대량의 데이터를 입력하고 조회하는 서비스를 구현할 때 가장 좋은 성능을 보인다.
채팅 내용저장, 실시간 분석을 위한 데이터 저장소 등의 서비스 구현에 적합하다.
https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/Database#%EB%8D%B0%EC%9D%B4%ED%84%B0%EB%B2%A0%EC%9D%B4%EC%8A%A4
Comments powered by Disqus.
Array
논리적 저장 순서와 물리적 저장순서가 일치함.
장점
Random Access : 인덱스로 원하는 원소에 바로 접근이 가능하여, O(1)에 해당원소로 접근가능
언어에따라 다르지만, 필요한 만큼만 메모리를 차지함
단점
Linked List
그럼 왜 Linked List를 쓰는가? -> 다른 로직과 결합한다면 삭제/삽입/찾기의 시간복잡도를 줄일 수 있고, Tree의 근간이 되는 자료구조이기에
비선형 자료구조로, 계층적 관계를 표현하는 자료구조이다.
트리는 표현에 집중하며, 무엇인가를 저장하고 꺼낸다기보다는 어떤 데이터의 구조를 표현하는 것에 집중한다.
트리 용어
Binary Tree
한 부모가 두개의 자식만 가질 수 있는 트리를 말한다. 공집합도 이진트리에 포함된다.
배열로 구성된 Binary Tree는 root가 0이 아닌 1에서 시작할때, 부모노드의 인덱스가 i라고 한다면, 왼쪽 자식은 2i, 오른쪽 자식은 2i + 1이다.
Binary Search Tree
이진탐색트리는 이진트리의 일종으로, 데이터의 탐색을 용이하게 하기 위한 데이터 저장방법으로 고안되었다.
이진탐색트리에 데이터를 저장하는 규칙
이진탐색트리에서 탐색연산은, 높이만큼 탐색하기에 O(h)이며, 완전이진트리일 경우 O(log n)의 시간복잡도를 가진다. 하지만 worst case로 데이터가 편향되어 트리에 들어왔을 경우 한쪽으로 치우치게 되어 O(n)의 복잡도를 가지게 된다.
이를 해결하기 위해 Rebalancing 기법을 사용하여, 트리의 균형을 다시 잡는 작업을 하기도 한다. 이 기법을 구현한 트리로는 Red-Black Tree가 있다.
완전이진트리에 기반한 트리의 일종이다. 최대힙, 최소힙 이 있다.
삽입/삭제 연산은 최대 층수까지만 하니, O(log n)이다.
구현
이진 탐색트리에서, Rebalancing 기법을 적용하여 탐색/삭제/삽입에 O(log n)의 시간이 걸리도록 한 트리이다.
즉, 최대 높이를 log n로 만드는 것으로 완전이진트리에 기반을 둔다.
Red Black Tree 정의
RBT는 아래 성질을 만족하는 이진탐색트리이다.
Red Black tree의 특징
삽입
삭제
해시는 내부적으로 배열을 사용하여 데이터를 저장하기 때문에 빠른 검색속도를 가진다. 특정한 값을 Search할때 데이터 고유의 인덱스(해시값)으로 접근하므로, 탐색연산의 시간복잡도는 평균 O(1)이다.(충돌 때문에 항상 O(1)은 아님)
이 인덱스로 사용될 해시값은 특별한 알고리즘을 통해 저장할 데이터와 연관된 고유한 숫자를 만들어 낸 뒤 이를 인덱스로 사용한다. 이 인덱스는 그 데이터만의 고유한 위치이기에 삽입/삭제 시 다른 데이터로 채울 필요가 없으므로 연산에서 추가적인 비용이 없도록 만들어진 구조이다.
해시값을 만들어내기 위한 함수. 이 함수에 의해 반환된 데이터의 고유숫자값을 hashcode라고 하며, 저장되는 값들의 key값을 hash function을 통해서 작은 범위의 값들로 바꿔준다.
이때 서로 다른 데이터에 동일한 key 값을 도출해낼 수 있고, 이러한 상황을 Collision이라고 한다.
Collision : 서로 다른 두개의 키가 같은 인덱스로 hasing 되면 같은 곳에 저장할 수 없게 된다. collision이 많아질수록 탐색에 필요한 시간복잡도는 O(n)에 가까워진다.
Open Address(개방 주소법)
다른 해시 버킷에 충돌이 발생한 자료를 삽입하는 방식.
다른 해시버킷을 찾는방법 : 최악의 경우 원래 자리로 돌아옴
1
+2
+3
+
1. Linear Probing : 순차적으로 탐색하여 첫번째로 발견한 빈 곳에 넣음
+1. Quadratic probing : 2차함수를 이용해 찾음
+1. Double hashing probing : 2차 해시 함수를 사용해 새로운 주소를 할당함. 많은 연산량이 필요하다.
+
Separate Chaining 방식 (분리연결법)
연결리스트 vs Tree
보조해시함수
key의 해시값을 변형하여 해시 충돌 가능성을 줄이는 것. Separate chaining방식을 사용할때 함께 사용되며, 보조해시함수로 worst case에 가까워 지는 경우를 줄일 수 있다.
Open address vs Separate Chaining
둘다 worst case에서는 O(M)임. 하지만 Open Address 방식은 연속된 공간에 데이터를 저장하기 때문에 Separate Chaining에 비해 캐시 효율이 높다. 따라서 데이터가 충분히 적으면 Open Adderess가 좋다.
하지만 Open Address는 버킷을 계속 사용하기에 테이블의 확장이 자주 일어난다.
해시 버킷 동적확장(resize)
해시버킷의 개수가 적으면 해시 충돌로 성능상 손실이 발생함. 따라서 key-value 쌍 데이터 개수가 일정 개수 이상이 되면 해시 버킷의 개수를 두배로 늘린다. 이렇게 하면 해시 충돌로 인한 성능저하를 어느정도 해결할 수 있다.
이때 두배로 확장하는 임계점은 기존 해시버킷 개수의 75%이다.
Undirected Graph 와 Directed Graph (Digraph)
Degree
각 정점에 연결된 Edge의 개수. 방향그래프일경우 Degree가 둘로 나뉜다.
가중치 그래프
간선이 가중치를 두어서 구성한 그래프
부분그래프
본래 그래프의 일부 정점 및 간선으로 이루어진 그래프
인접행렬
인접 리스트 : 연결리스트
DFS
BFS
크루스칼
가중치가 가장 낮은 edge를 하나씩 추가하되, 사이클을 형성하지 않는 edge를 추가하는 것. V - 1개의 Edge가 추가되면 정지함.
시간 복잡도
Prim
현재까지의 그래프와 아직 추가되지 않은 노드와 연결되어 있는 간선 중에서 가장 작은 가중치를 가지는 간선만 추가함.
시간복잡도 : O(E logv)
Comments powered by Disqus.
아래 4가지 조건을 모두 만족하면 데드락 발생가능성이 있음
Comments powered by Disqus.
딥링크는 웹사이트에서 사용자 기기에 설치된 앱을 URI로 실행시킬 수 있도록하는 기술이다.
이러한 딥링크에는 세가지 유형이 있다.
앱 개발자가 앱 내 특정 페이지마다 고유한 주소를 설정하고, 그 주소를 웹에서 실행시키면 설정한 특정 페이지가 열리는 형태이다. 이때 주소는 다음과 같은 형태이다.
1
+
myapp://post?version=1
+
여기서 myapp:// 부분을 Scheme(프로토콜)이라고 하고, 앱 개발자가 자신만의 Scheme를 등록할 수 있다.
하지만 이 Scheme를 소유권을 증명하지 않고 개발자가 원하는 값으로 등록할 수 있다는 점에서 Scheme값이 중복되는 문제가 발생했다. path까지 모두 동일한 주소를 사용한다면 android는 딥링크로 오픈할 앱 선택창이 노출되고, IOS는 가장 마지막에 설치한 앱이 자동으로 열린다.
이 문제점을 보완하기 위해 나온 것이 Universal Link와 App Link이다.
URI Scheme의 문제점을 보완하여 OS에 앱에 대한 도메인 주소를 등록함으로써 소유권을 증명한다. 도메인은 도메인 소유자만이 관리할 수 있기에 소유권이 증명되기 떄문이다.
앱 빌드 시 앱을 열 도메인을 등록하고 보안을 위해 등록한 도메인의 특정 경로에 인증 텍스트를 심어 놓는다. 그러면 앱이 설치된 후 OS 레벨에서 해당 도메인 경로의 인증 텍스트와 앱 빌드시의 값이 동일한지 검증하여 소유권을 인지한다.
검증된 도메인으로 생성된 딥링크 클릭 시,
이 Universal Link와 App Link는 도메인으로 접속하기에 다음과 같이 일반적인 http, https 도메인 형식을 따른다.
1
+
https://myapp.com/post?version=1
+
1) 딥링크는 OS, 브라우저마다 다르게 동작한다. 내가 겪은 것은 다음과 같다. 좀 더 자세한 OS/브라우저별 동작 차이는 이 글에 표로 정리되어있다.
"{앱이름}"에서 여시겠습니까? 라는 경고창이 뜸주소가 유효하지 않기 때문에 Safari가 해당 페이지를 열 수 없습니다. 경고창이 뜸.Universal LInk을 사용할 때 다음과 같은 상황이 있을 수 있다.
주소창에 링크를 직접 붙여넣기할 경우 동작하지 않음
JS로 트리거 된 경우 리다이렉트가 되지 않음
openUrl과 같이 앱 내에서 프로그래밍 방식으로 링크를 열 경우 작동하지 않음
Android 에서 intent:// .
intent:// 을 사용할 수 있다.1
+
intent://details?id={앱id}&url={마켓주소}#Intent;scheme=market;package=${앱패키지};end;
+
아래 코드는 프로젝트 수행 시 사용했던 코드이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
// 안드로이드
+const openOnAndroid = () => {
+ window.location.href = `${URIscheme}`
+ // 1초간 변화없으면 플레이스토어 열기
+ setTimeout(() => {
+ window.location.href = `market://details?id=${package}`
+ }, 1000)
+ return;
+}
+
setTimeout을 등록하여 1초간 반응이 없을 시 마켓을 연다.intent:// 를 지원하지 않는 상황이라 앱 여는 동작과 앱 없을 시 마켓 여는 동작을 분리했다.market://이라는 URI Scheme을 사용했다.market://으로 URI Scheme을 사용하면 URL이 아니기에 리다이렉트되지 않는다. 다만, 사용자 기기에 원스토어와 같은 다른 마켓이 설치되어있으면 어떤 앱으로 마켓을 열 것인지 선택하는 창이 뜬다.1
+2
+3
+4
+5
+6
+7
+8
+9
+
const openOnIos = () => {
+ window.location.href = `${URIScheme}`''
+ setTimeout(() => {
+ // 크롬에서는 URI 스킴으로 열어야 앱 이동 후 웹 복귀 시 마켓이 안뜸.
+ // ios 사파리에서는 유니버셜 링크로 앱스토어를 열어야 '"AppStore"에서 여시겠습니까?' 라는 알럿창이 뜨지 않음.
+ window.location.href = isChrome ? `itms-apps://itunes.apple.com/app/${appId}` : `https://itunes.apple.com/app/${appId}`
+ }, 1000)
+ }
+}
+
setTimeout을 등록하여 1초간 반응이 없을 시 마켓을 연다."AppStore"에서 여시겠습니까? 라는 알럿창이 뜨기에 유니버셜링크로 마켓을 여는 것이 사용자 경험에 좋다.https://www.airbridge.io/blog-ko/deeplink-101-for-marketers-and-developers
https://www.airbridge.io/blog-ko/deeplink-101-ios-safari-alert
Comments powered by Disqus.
시스템의 성능 향상, 개발 및 운영의 편의성을 위해 정규화된 데이터 모델을 통합, 중복, 분리하는 과정으로 의도적으로 정규화 원칙을 위배하는 행위.
과도한 반정규화는 성능 저하를 불러일으킴.
방법
두개의 테이블이 조인되는 경우가 많아 하나의 테이블로 합쳐 사용하는 것이 성능향상에 도움이 될 경우 수행한다.
테이블을 수직 또는 수평으로 분할하는 것
수평분할
수직 분할
고려사항
여러 테이블에서 데이터를 추출해서 사용해야하거나 다른 서버에 저장된 테이블을 이용해야하는 경우 중복 테이블을 추가하여 작업의 효율성을 향상 시킬 수 있음.
조인해서 데이터를 처리할 떄, 데이터를 조회하는 경로를 단축하기 위해 자주 사용하는 속성을 하나 더 추가하는 것.
중복 속성을 추가하면 데이터의 무결성 확보가 어렵고, 디스크 공간이 추가로 필요하다.
https://lipcoder.tistory.com/337
Comments powered by Disqus.
Apache Kafka는 빠르고 확장 가능한 작업을 위해 데이터 피드의 분산 스트리밍, 파이프 라이닝 및 재생을 위한 실시간 스트리밍 데이터를 처리하기 위한 목적으로 설계된 오픈 소스 분산형 게시-구독 메시징 플랫폼이다.
Kafka는 서버 클러스터 내에서 데이터 스트림을 레코드로 유지하는 방식으로 작동하는 브로커 기반 솔루션이다. Kafka 서버는 여러 데이터 센터에 분산되어 있을 수 있으며 여러 서버 인스턴스에 걸쳐 레코드 스트림(메시지)을 토픽으로 저장하여 데이터 지속성을 제공할 수 있다.
메세지/레코드
Broker Cluster
임의 개수의 노드로 구성되는 클러스터로 토픽을 임의 개수만큼 호스팅할 수 있다
토픽/파티션 확장
실시간으로 통신하고, Pub-Sub 구조로 통신을 하는 방법이 필요하다면 소켓으로도 충분히 해결 가능하다. 소켓이 훨씬 가볍기에 이와 같은 상황에선 소켓이 가장 잘 맞는다. 그럼 kafka는 언제 쓰일까? 먼저 소켓의 단점부터 알아보자.
소켓의 단점
kafka 등 메세징 시스템에서는
이와 같이 kafka는 socket의 단점을 해결해줄 수 있는 방법이며, 따라서 socket의 단점이 문제가 될 때 사용하는 방법이다. 단순히 클라이언트와 실시간 통신을 하는 정도는 socket으로 해결할 수 있지만, 좀 더 복잡한 상황에서는 kafka가 필요하다. 그렇기에 kafka는 주로 백엔드 서비스들 사이의 통신을 하기 위해 사용한다.
예를들어 128대의 서버간 망형태로 연결이 필요한 경우 128^2개의 소켓이 필요하다. 하지만 kafka를 사용하면 128개의 연결만으로도 해결이 가능하다.
Comments powered by Disqus.
좋은 OOP 설계에서 지켜져야하는 규칙인 SOLID 중 S인 규칙으로, 하나의 모듈은 하나의 책임을 가져야한다는 원칙을 말한다.
클래스는 단 한개의 책임을 가져야한다.
하나의 모듈은 오직 하나의 액터에 대해서만 책임져야한다.
클래스를 변경하는 이유는 단 한개여야 한다.
여기서 책임은 액터에 대한 책임을 의미한다. 하나의 액터에 대해 하나의 책임을 지는 객체를 정의하고 사용하라는 것이다. 액터는 시스템과 상호작용하는 시스템 외부의 어떤 존재를 뜻하는 말로, 시스템의 이해관계자로 정의할 수 있다. 쇼핑 앱을 예로 들면, 물건을 구매하려는 고객이 액터이다.
이 정의는 모듈의 응집도를 높이기 위해 사용된다. 단일 액터를 책임지는 코드들을 묶어 응집도를 높여 단일 책임 원칙을 준수함을 통해 모듈의 응집도를 높이는 것이다.
이렇게 모듈의 응집도를 높여 하나의 액터에 대해 하나의 책임을 지는 객체를 정의한다면, 단일 액터만이 단일 객체에 대해 변경할 이유를 가질 수 있다.
한가지 예시를 들며 SRP를 지키는 것이 무엇이며 어떻게 개발 비용을 증가시키는지 알아보자.
만약 도서관의 도서 관리 시스템을 맡게 되었고, 아래와 같은 유즈케이스 다이어그램을 도출하였다고 해보자.
이 유즈케이스 중 대여, 연체관리, 연체금 표시를 묶어 하나의 rental이라는 클래스에 기능을 구현하였고, 회원은 연체금이 10000원이 넘어가면 더이상 책을 대여할 수 없다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class RentalService {
+ async userRentalBook() {
+ // 연체료 계산
+ // 대여 로직 수행
+ }
+
+ async getUserArrears() {
+ // 연체료 계산
+ // 연체료 표시
+ }
+
+ ...
+}
+
위의 두 함수, 책을 대여하는 함수와 연체금을 표시하는 함수는 책의 연체금을 계산하는 로직은 각 메서드 내부에 있다.
위 코드는 잘동작한다. 하지만, 만약 어느날 연체금 정책이 변경되었다고 해보자. 원래는 모든 책이 연체일 하루당 1000원이었지만, 사람들이 많이 읽는 책은 1500원, 잘 읽지 않는 책은 500원으로 변경되었다.
이때 문제가 발생한다. 대여함수와 연체금 표시에서 각각 연체금 계산 로직을 새로 수정해야한다.
원인은?
원인은 하나의 클래스에 속한 두 함수는 연체금 계산이라는 로직을 공유하지만 두 함수가 제공하는 기능의 책임이 다른 곳에 있기 때문이다.
책 대여 함수는 회원 액터에 대한 책임이 있고, 연체금 표시는 관리자 액터에 대한 책임이 있다. 이렇게 두 개의 액테에 대한 책임이 한 클래스에 부여되어 변경사항을 반영해야하는 범위가 넓어진 것이다.
해결책
단일책임원칙을 지켜 대여는 회원 액터만이, 연체금 표시는 사서 액터만이 사용하도록 변경해주면 된다. RestalService 클래스에 있는 두 메서드를 완전히 분리하면 해결할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
@Injectable()
+export class ArrearsService {
+ async calcUserArrears() {
+ // 연체금 계산
+ }
+
+ async getUserArrears() {
+ // 연체금 표시
+ }
+
+ ...
+}
+
+@Injectable()
+export class RentalService {
+ async userRentalBook() {
+ // 책 대여
+ }
+ ...
+}
+
연체금과 관련된 연체금 계산 로직 및 연체금 표시 메서드는 ArrearsService에 위임하고, 대여와 관련된 메서드는 RentalService에 위임하였다. 이로써 ArrearsService는 누가 대여하는지 알지 못한다. 단순히 연체일에 따라 연체금을 표시하도록 변경되었다. RentalService는 연체금 계산 방식에 대해 알지 못한다. 단순히 대여가능 여부만을 알 수 있다.
이렇게 메서드를 분리한 후 아까와 같은 변경사항이 왔다고 해보자. ArrearsService에 연체금 계산 메서드가 변경되겠지만, RentalService는 변경하지 않아도 된다. 어떻게 계산이 되든 10000원이 넘어가는 연체금이라면 대여할 수 없다. 변경사항은 연체금에 대한 수정사항이었고, 관리자 액터로부터 야기된 수정사항이다.
https://velog.io/@qjqdn1568/SOLID-%EB%8B%A8%EC%9D%BC-%EC%B1%85%EC%9E%84-%EC%9B%90%EC%B9%99-SRP
Comments powered by Disqus.
비즈니스 코드를 먼저 작성하고 유닛테스트를 작성할 때, 완성된 코드를 보고 테스트 코드를 작성하다보면 내부 구현에 맞추어 테스트를 작성하게 되고, 구현 자체를 검증하게 되는 일이 많이 발생하였다.
유닛 테스트에서는 구현이 아닌 행동을 검증(test behaviour, not implementation)해야한다. 따라서 구현을 검증한 테스트 코드를 고치려 했으나 어디까지가 구현을 검증한 것인지가 모호했다.
A 메서드 안에서 B 메서드를 제대로 호출했는지를 보는 것도 구현 검증일까?
구현 검증을 피하고자 DB를 검사해도 되는 걸까?
최종 결과물을 내지 않는 void 메서드는 어떻게 테스트하지?
명확한 기준을 세우고 싶어 여러모로 조사하였다.
아래 내용은 유닛테스트에서 내부구현 검증 피하기라는 포스트에서 가져온 내용으로, 구현 검증이 무엇인지 이해하기 위해 살펴봤다.
다음과 같은 클래스가 있다
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+
export class OrderAmountSum {
+ minusSum: number = 0;
+ plusSum: number = 0;
+
+ constructor(amounts: number[]) {
+ this.addPlusAmounts(amounts);
+ this.addMinusAmounts(amounts);
+ }
+
+ get sumAmount(): number {
+ return this.plusSum + this.minusSum;
+ }
+
+ addPlusAmounts(amounts: number[]): void {
+ this.plusSum = amounts
+ .filter((amount) => amount > 0)
+ .reduce((before, current) => before + current);
+ }
+
+ addMinusAmounts(amounts: number[]): void {
+ this.minusSum = amounts
+ .filter((amount) => amount < 0)
+ .reduce((before, current) => before + current);
+ }
+}
+
이 클래스에서 중요한 비즈니스 로직은 sumAmount에 있다. addPlusAmounts, addMinusAmounts은 부차적인 기능에 불과하다. 하지만 여기서 다음과 같이 부차적인 기능에 대한 테스트를 짜는 실수를 할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
it("plusSum에는 양수들의 총합이 등록된다", () => {
+ const sut = new OrderAmountSum([1000, 300, -100, -500]);
+
+ expect(sut.plusSum).toBe(1300);
+});
+
+it("minusSum에는 음수들의 총합이 등록된다", () => {
+ const sut = new OrderAmountSum([1000, 300, -100, -500]);
+
+ expect(sut.minusSum).toBe(-600);
+});
+
+it("전체 합계 금액을 구한다", () => {
+ const sut = new OrderAmountSum([1000, 300, -100, -500]);
+
+ expect(sut.sumAmount).toBe(700);
+});
+
이렇게 되면 만약 다음과 같이 코드가 변경되었을 경우 sumAmount 테스트 말고는 전부 깨질 것이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
export class OrderAmountSum2 {
+ amounts: number[];
+
+ constructor(amounts: number[]) {
+ this.amounts = amounts;
+ }
+
+ get sumAmount(): number {
+ return this.amounts.reduce((before, current) => before + current);
+ }
+}
+
핵심 로직이 아닌 부차적인 기능까지 테스트하여 발생한 문제다. 따라서 OrderAmountSum의 테스트 코드는 다음과 같이 작성되어야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
describe("OrderAmountSum2", () => {
+ it("전체 합계 금액을 구한다", () => {
+ const sut = new OrderAmountSum2([1000, 300, -100, -500]);
+
+ expect(sut.sumAmount).toBe(700);
+ });
+
+ it("-금액들의 합계 금액을 구한다", () => {
+ const sut = new OrderAmountSum2([-1000, -300, -100, -500]);
+
+ expect(sut.sumAmount).toBe(-1900);
+ });
+});
+
다음과 같이 Order를 업데이트하거나 생성하는 메소드가 있다고 해보자.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
export class OrderService {
+ constructor(private readonly orderRepository: OrderRepository) {
+ }
+
+ saveOrUpdate(order: Order): void {
+ const savedOrder = this.orderRepository.findById(order.id);
+ if (savedOrder) {
+ this.orderRepository.update(order);
+ } else {
+ this.orderRepository.save(order);
+ }
+ }
+}
+
이때 stub을 통한 모의 객체를 사용하여 다음과 같은 테스트를 작성할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
it("기존 주문이 있으면 새 정보로 갱신된다", () => {
+ const savedOrder = Order.create(1000, LocalDateTime.now(), "");
+ when(mockedRepository.findById(anyNumber())).thenReturn(savedOrder);
+ const sut = new OrderService(instance(mockedRepository));
+
+ sut.saveOrUpdate(createOrder(savedOrder, 200));
+
+ verify(mockedRepository.update(anything())).called();
+});
+
여기서의 문제는 saveOrUpdate 내부에서 repository를 하나하나 어떻게 쓰는지 검증했다는 점이다. 만약 다음과 같이 saveOrUpdate가 변경된다면 어떻게 될까?
1
+2
+3
+
saveOrUpdate(order: Order): void {
+ this.orderRepository.saveOrUpdate(order);
+}
+
실제로는 잘 저장 또는 업데이트 되어도 테스트는 실패했다고 뜰 것이다. 따라서 테스트는 다음과 같이 진행되어야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
it("[After] 기존 주문이 있으면 새 정보로 갱신된다", () => {
+ const savedOrder = realRepository.save(
+ Order.create(1000, LocalDateTime.now(), "")
+ );
+ const expectAmount = 200;
+
+ const sut = new OrderService(realRepository);
+ sut.saveOrUpdate2(createOrder(savedOrder, expectAmount));
+
+ const result = realRepository.findById(savedOrder.id);
+
+ expect(result.amount).toBe(expectAmount);
+});
+
위에서 살펴본 경우를 보고 한번 글 초반에 작성했던 의문에 대한 답을 생각해보자
구현 검증이다. A 메서드는 B 메서드를 호출하든 안하든 A 메서드에 부여된 일을 수행하면 될 뿐이다.
만약 구현이 변경되어 A메서드는 B 메서드가 아닌 C 메서드를 호출하는 것으로 변경되었으나 기능은 기존과 동일할때, B 메서드에 의존한 테스트는 실패하게 된다. 이는 위 예시로 봤을 때 구현 검증으로 테스트가 깨진 사례에 속한다.
좋지 않은 패턴이다. DB에 의존하여 결과를 확인하는 것은 DB의 상태, 버전 등에 따라 테스트 결과가 달라질 수도 있다. 매번 결과가 다른 테스트가 작성되는 것이고, 이는 테스트의 F.I.R.S.T 원칙의 Repeatable 을 위반한 사례이다.
구현이 아닌 행동를 테스트해야하는 건 잘 알았다. 하지만 결과를 쉽게 알 수 없는 void 메서드일 경우는 어떻게 테스트 해야할까?
테스트 코드 작성 경험이 별로 없는 나에겐 빠르게 생각하기 어려웠다. 따라서 한번 관련 글들을 조사해보았다.
Test behaviour, not implementation이라고 검색한 후 나온 포스트들을 하나씩 보며 구현을 검증하지 않고 행동을 검증하는 것이 무엇인지를 알아보았다
Testing Behavior : 정답이 왜 나오는 지는 모르겠는데, 이 환경에서 이 결과만 나오면 돼!
Testing Implementation : 결과는 신경안쓰고, 과정만 제대로 확인해!
실제로는 결과를 보며 테스트를 하지만, 너무 많은 mock와 stub에 의존하며 결과가 어떻게 나오는지에 대한 많은 assertions을 만들게 된다. 이러한 mocks와 stub은 시스템이 발전함에 따라 문제가 된다.
mocks와 stub가 나쁜 것은 아니다. mocks와 stub은 서로 다른 시나리오와 환경에서 테스트를 할 수 있게 해준다. 이 정도는 supporting implementation이며 testing implementation이 아니다. 하지만 너무 많은 assertions이 mocks와 stub에 의존하여 나온다면 문제가 된다.
Testing behavior와 testing implementation이 같아지는 때가 있다. 테스트하는 메서드가 coordinator 메서드일 경우 그렇다. 이러한 메서드는 결정을 내리고 다른 메서드나 클래스를 호출하는 역할을 한다. 이러한 메서드를 테스트할 때는 메서드가 적절히 불러졌는지 확인하는 것밖에 없다.
Testing begavior와 testing implementation이 같아지는 예시)
다음과 같이 terminalService에서 terminal list을 가져와 하나씩 ContactTerminal 메서드에 넣어 실행시키는 FindTerminals 메서드가 있다고 해보자.
1
+2
+3
+4
+5
+
void FindTerminals() {
+ terminals = terminalService.FindAll();
+ foreach (var terminal in terminals)
+ ContactTerminal(terminal);
+}
+
FindTerminals 에 대한 테스트는 다음과 같다. terminalService.FIndAll() 메서드의 응답으로 3개의 terminal 을 응답하도록 stub 처리하고, FindTerminals을 실행시킨다. 그리고 정확히 3번 ContactTerminal이 실행되는지 확인하는 코드이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
var terminals = new List<Terminal>{ new Terminal(), new Terminal(), new Terminal() };
+terminalServiceMock
+ .Setup(f => f.FindAll())
+ .Returns(terminals);
+
+var activeTerminalLocatorMock = new Mock<ActiveTerminalLocator>(
+ terminalServiceMock.Object,
+ networkServiceFactoryMock.Object,
+ backgroundWorkerFactory
+);
+activeTerminalLocatorMock.Object.FindTerminals(null);
+
+activeTerminalLocatorMock.Verify(
+ f => f.ContactTerminal(It.IsAny<Terminal>()),
+ Times.Exactly(3)
+);
+
위와 같은 테스트는 구현을 검증한 예시이다. 어떤 메서드가 몇번 호출되었는지 확인하는 코드이기 때문이다. 하지만 결과를 검증하는 예시이기도 하다. ContactTerminal이 주어진 terminal만큼 실행시키는 것이 FindTerminals의 목적이고, 그것을 검증하는 코드이기 때문이다. 예를 들어 FindTerminals가 다음과 같이 변경되어도, FindTerminals의 목적은 똑같기에 때문에 테스트 코드는 여전히 유효하다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
void FindTerminals() {
+ terminals = terminalService.FindAll();
+ foreach (var terminal in terminals) {
+ using(var worker = workerFactory.CreateWorker(){
+ worker.DoWork += (o, ea) => ContactTerminal(terminal); // 3번 실행됨.
+ worker.RunWorkerAsync();
+ }
+ }
+}
+
이와 같이 테스트 대상의 목적을 검증하는 것과 구현을 검증하는 것이 같아지는 때가 있다. 이때는 구현이 크게 변경되어도, 목적이 달라지지 않는다면 테스트 코드는 변화하지 않는다.
포스트 후기
이 포스팅에서 얻은 것은 테스트 대상의 목적을 확실히하고, 그 목적을 테스트한다면 구현을 테스트하더라도 위에서 걱정했던 테스트 코드를 변경하는 문제는 나타나지 않는다는 점이다.
예시에서 봤듯이 어떤 메서드를 몇번 호출하였는지를 확인하는 것은 구현 검증이지만, 목적 자체가 ContactTerminal을 호출하는 것이었기에 테스트 코드는 변화하지 않았다.
만약 ContactTerminal를 호출하지 않는 사양으로 메서드가 변경된다면 그것은 목적이 변한 것이니 애초에 메서드를 분리해서 구현하든가, 테스트 코드도 마땅히 바꿔야하는 일이다.
다음과 같이 간단한 메서드가 있다고 해보자.
1
+2
+3
+
public List<Book> getAllBooks() {
+ return bookRepository.getAllBooks();
+}
+
이 메서드에 대한 테스트를 다음과 같이 작성할 수 있다. 이는 bookRepository의 메서드가 제대로 호출되었는지 확인하는 것이므로 구현을 테스트한 것에 속한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
private Book lord_of_the_rings = new Book("Lord of the rings");
+
+@Test
+public void reallyInterestedInWhatThisServiceIsDoing() {
+ BookRepository bookRepository = mock(BookRepository.class);
+ when(bookRepository.getAllBooks()).thenReturn(Collections.singletonList(lord_of_the_rings));
+ BookService bookService = new BookService(bookRepository);
+
+ assertThat(bookService.getAllBooks(), containsInAnyOrder(lord_of_the_rings));
+ verify(bookRepository, times(1)).getAllBooks();
+}
+
우리는 behaviour를 테스트해야한다. 따라서 위 테스트는 아래와 같이 behaviour만 테스트하는 형태로 변경되어야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
private Book lord_of_the_rings = new Book("Lord of the rings");
+
+@Test
+public void shouldGetAllBooks() {
+ BookRepository bookRepository = mock(BookRepository.class);
+ when(bookRepository.getAllBooks()).thenReturn(Collections.singletonList(lord_of_the_rings));
+ BookService bookService = new BookService(bookRepository);
+
+ assertThat(bookService.getAllBooks(), containsInAnyOrder(lord_of_the_rings));
+}
+
물론 테스트가 돌아가게 하기위해 bookRepository은 mock 객체이고, when을 사용하여 behaviour을 정의하고 합치는 collaborator는 필요하다.
Verify behaviour는 mutation에서도 적용된다. 물론 그러한 메서드는 void 타입을 반환을 할 수 있다. 유일한 차이는 결과가 아래에서 나온다는 점이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
public void createBook(Book book) {
+ bookRepository.createBook(book);
+}
+...
+@Test
+public void insertBook() {
+ BookRepository bookRepository = mock(BookRepository.class);
+ BookService bookService = new BookService(bookRepository);
+ Book the_dark_tower = new Book("The Dark Tower");
+ bookService.createBook(the_dark_tower);
+
+ verify(bookRepository, times(1)).createBook(the_dark_tower);
+}
+
mutation의 결과를 반환하는 경우도 있다. 그럴 경우 반환값과 호출 여부를 모두 확인해야한다. 하지만 보통 이런 메서드는 사이드 이펙트를 부르는 안티패턴이고, 두 개의 메서드로 분리되어야한다.
포스트 후기
첫번째 포스트와 비슷하게 다른 메서드 호출이 중요한 메서드의 테스트는 호출여부를 확인하였다.
Q : save X to some data source와 같이 일반적인 service-repotisoty구조에서 구현을 함께 테스트하지 않고 어떻게 테스트를 하는가?
A1)
save X to some data source 과 같은 경우는 외부 의존성과 통신하는 경우이므로, 특정한 메서드가 제대로 호출되었는지 테스트 해야하는 경우에 속한다. 테스트해야할 behaviour가 통신이 예상대로 이뤄졌는가이기 때문이다.
어플리케이션과 외부 의존성 사이의 인터페이스는 구현상세가 아니고 시스템 아키텍쳐 정의이다. 변경될 일이 적다는 의미이다. 따라서 repository 인터페이스를 테스트하는 것은 그리 많은 문제를 내지 않는다.(만약 문제를 많이 내면, 인터페이스가 어플리케이션의 역할을 빼았은 경우에 속한다.)
UI, 데이터베이스, 외부 서비스를 제외한 어플리케이션의 비즈니스 로직만이 테스트와 구현상세를 분리해야하는 부분이다.
A2)
database는 일반적으로 collaborator다. mock되기보단 fake를 붙이는 게 좋다. 손으로 구현하긴 어렵지만, 사용할 수 있는 도구들이 있다. 로그처럼 한번 써지고 다시는 읽히지 않은 database는 output이므로 mock되어야한다.
Input-output-collaborator에 대해 자세히
후기
답변 1에서는 service의 behaviour가 repository와 통신하는 것이므로 메서드 호출 여부를 확인해야하며, repository는 제대로 설계되었다면 변경될 일이 적으므로 괜찮다는 말이다.
답변 2는 input-output-collaborator로 인터페이스를 나눠서 repository와 같은 collaborator는 가짜 구현을 붙여 결과를 테스트 하라고 하였다.
첫번째 답변에서는 repository를 크게 변경하여 테스트가 너무 많이 깨진다면 애초에 설계가 잘못된 것이라는 점을 알았다. 두번째 답변에서는 가짜 데이터베이스를 붙여 결과를 확인하는 것도 가능하는 것을 알았다.
세가지 글을 읽고 나니 구현 검증 없이 테스트를 어떻게 해야하는 것인지 어느정도 감이 잡혔다. 다음과 같은 유형으로 정리할 수 있을 거 같다
주어진 input에 올바른 output을 반환하는 것이 목적인 경우
-> input 값에 따른 output이 올바른지 테스트
다른 메서드를 올바르게 호출하는 것이 목적인 경우
중요한 것은 테스트 대상의 목적을 명확히 하는 것이다. 그 후 그 목적을 테스트한다면, 구현을 검증하더라도 행동을 검증하는 것이 된다.
그리고 좀 더 세부적으로 일반적인 service-repository 구조에서 repository가 제대로 호출되었는지 확인하는 것은 구현을 테스트하는 것이 아니라고 볼수도 있다. repository는 외부 데이터베이스의 인터페이스이므로 구현보다는 시스템 아키텍쳐에 가깝기 때문이다. 따라서 respository의 변경은 일반적으로 테스트를 깨트리지 않고, 만약 테스트를 너무 많이 깨트린다면 repository 설계가 잘못된 것이기에 마땅히 테스트를 수정해야한다.
service-repository 구조에서는 repository를 제대로 호출하는 것으로 검증할수도 있지만, 만약 정말로 데이터가 제대로 저장되는지 확인하고 싶다면 테스트용 DB를 사용하는 방법도 있다.
테스트를 작성하는 것은 완벽히 하기 위해 하는 것이 아니다. 코드를 조금 더 좋게 하기 위해 하는 것이다. 따라서 좋은 테스트를 작성하도록 노력은 하되 너무 집착하여 완벽한 테스트를 작성하고자 하진 않아도 된다.
Comments powered by Disqus.
이 글은 Logging Best Pratices : The 13 You Should Know를 기반으로 요약, 학습한 글입니다.
printf을 사용하거나 파일에 직접 입력하지마라. 로깅을 위한 표준 라이브러리를 사용하라.
표준 라이브러리를 사용할 때 장점
표준 라이브러리 종류
어떤 레벨로 로그를 남겨야할지는 어렵다. 대략적인 팁은 다음과 같다
대부분의 로깅 라이브러리는 category 지정을 지원한다.
적절한 카테고리를 지정해서 알아보기 쉽게하자
로그를 읽는 사람이 프로그램에 대해 잘 알고 있음을 가정하고 남기는 로그보다 나쁜 것은 없다. 로그를 남길 때는 항상 긴급 상황을 상상하라.
로그를 작성할 때는 코드 컨텍스트에 맞춰 작성하기 마련이다. 하지만 실제로 로그를 읽어야할 때는 그러한 컨텍스트는 없고, 로그는 이해하기 어려워진다.
따라서 로그 메세지에 부가정보를 남기든가, 아니면 해당 작업의 목적이 무엇인지, 바람직한 결과는 무엇인지를 남겨라.
또한 이전 로그에 의존한 내용을 작성하지 마라. 이전 로그는 기록되지 않을 수도 있고, 다른 카테고리나 레벨로 기록되었을 수도 있다.
영어로 작성하면 아스키문자로 작성하였다는 것을 의미한다. 이는 어떤 소프트웨어를 사용하든 잘 작동한다는 것이다. UTF-8으로 작성하였다면 어떤 소프트웨어에서는 잘 작동하지 않을 수도 있다.
만약 영어로 작성하지 않을 때는 의미있는 에러 코드를 앞에 작성하라.
만약 로그 메세지가 아래와 같다고 해보자.
1
+2
+3
+
Transaction failed
+User operation succeds
+java.lang.IndexOutOfBoundsException
+
왜 실패했고 성공했는지 알수가 없다. 이처럼 적절한 컨텍스트가 없는 로그는 노이즈다. 따라서 로그는 아래와 같이 작성되어야한다.
1
+2
+3
+
Transaction 2346432 failed : cc number checksum incorrect
+User 54543 successfully registered e-mail user@domain.com
+IndexOutOfBoundsException: index 12 is greater than collection size 10
+
이를 위해선 MDC라는 자바 로깅 라이브러리가 사용될 수 있다. MDC는 한 thread에서 공유되는 연관 배열이다. 로거 설정으로 MDC 내용물이 항상 로그에 남도록 설정할 수 있다. 만약 프로그램이 per-thread paradigm이라면 context를 남기는 것은 MDC를 이용하면 쉽다.
다만 MDC는 비동기 로깅 스키마하고는 잘 동작하지 않는다.
로그 파일을 사람이 일일히 읽기에 힘들 수도 있다. 따라서 자동화 프로그램으로 로그를 읽으려하는데 파싱하기 어려운 형태면 프로그램을 만들 때 문제가 될 수 있다.
파싱하기 어려운 로그
1
+
2013-01-12 17:49:37,656 [T1] INFO c.d.g.UserRequest User 1334563 plays 4 of spades in game 23425656
+
파싱하기 좋은 로그
1
+
2013-01-12 17:49:37,656 [T1] INFO c.d.g.UserRequest User plays {'user':1334563, 'card':'4 of spade', 'game':23425656}
+
로그는 파싱하기는 쉬워야하지만 사람이 읽기에도 편해야한다. 사람도 로그를 읽기 때문이다.
로그 양에는 적절한 밸런스가 중요하다. 이를 달성하기위한 마법의 규칙은 없다.
대신 처음엔 많이 로그를 남겼다가, 실제 배포 후 분석하여 로그를 줄이거나 늘리는 방법으로 조절할 수 있다. 특히 트러블슈팅을 할 때, 더 늘리거나 줄였으면 하는 부분을 고쳐가며 조절하면 좋다. 이 과정에서 ops와 devs 간의 커뮤니케이션이 필요하다
로그를 읽는 사람이 누구냐에 따라 남길 메세지, 컨텍스트, 카테고리, 레벨이 달라진다.
로그는 트러블슈팅 이외에 다른 목적으로도 쓰일 수 있다.
한가지 로깅 라이브러리나 프레임워크에 종속되지 말고, 원할 때 바꿀 수 있어야한다.
로깅 라이브러리를 감싼 wrapper를 만들고, 그 wrapper의 인터페이스로 로그를 남기면 교체를 하고 싶을 때 그 wrapper만 수정하면 되므로 교체가 수월하다.
slf4j 같은 라이브러리는 로깅 프레임워크 교체를 수월하게 해주는 표준화된 추상화를 제공한다.
password, 카드번호, 주민번호와 같은 민감한 정보는 로그에 남겨선 안된다. 유출되거나 악용되면 큰일나기 때문이다.
무엇을 로그로 남기면 안되는지에 대한 법도 존재한다.
https://www.dataset.com/blog/the-10-commandments-of-logging/
Comments powered by Disqus.
안정적인 버전을 릴리즈하기 전에 테스트 버전을 일부 사용자에게 배포하는 것을 말한다.
만약 카나리 버전에 심각한 버그가 발생한다해도 사용하는 사용자가 적기 때문에 피해를 최소화할 수 있다. 또한 안정적인 버전과 테스트 버전이 모두 배포된 상태이기 때문에 A/B 테스트가 가능하다.
유저가 직접 카나리 버전을 설치하는 경우도 있지만, 유저는 모르고 사용하도록 할 수 있다. 일부의 유저만 새로운 버전으로 서비스를 제공하는 방식이다.
https://codechacha.com/ko/what-is-canary-development-test/
Comments powered by Disqus.
HorizontalPodAutoscaler의 약자로, k8s에서 CPU 사용률을 체크하여 Pod의 개수를 스케일링하는 기술이다. 지정한 메트릭을 controller가 체크하여 부하에 따라 필요한 pod의 replica 수가 되도록 자동으로 pod 수를 늘리거나 줄일 수 있는 기술이다.
Auto scaling은 사용자가 정의한 주기(스케줄링)나 이벤트(모니터링 알람)에 따라 서버를 자동으로 생성하거나 삭제한다. 서비스 트래픽에 따라 서버를 늘리거나 줄여 발생하는 요금을 최소화한다.
k8s에서는 다음과 같은 알고리즘을 통해 적절한 pod 개수를 유지한다.
Deployment 설정 예시
초기 Replica(Pod) 개수를 1개로 설정
HPA 설정 예시
리소스 상태에 따라서 10개까지 scaling 가능하도록 설정
auto scaling을 위해서는 k8s에서 서버 메트릭 정보를 수집할 수 있어야한다. k8s에서는 metric server를 통해 pod, node에 대한 리소스 자원들에 대한 metric 정보들을 수집한다.
Metric server가 수집한 metric 정보를 k8s aggregator에게 노티하는 방식으로 metric 정보가 관리된다. 만약 metric 정보를 얻고 싶다면 별도의 tool을 이용해서 aggregator에 있는 metric 정보들을 가져가게 된다.
이러한 metric server는 기본적은 k8s component에 포함되어있지 않기에 별도의 적용이 필요하다.
1
+
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
+
정상적으로 설치됐다면 kubectl top 명령어를 사용할 수 있다. 이 명령도 마찬가지로 metric 정보를 수집한 것을 바탕으로 보여준다.
k8s에서 metric 정보를 기반으로 auto scaling을 지원해주는 component에는 HPA 외에도 VPA가 있다. 둘의 차이점은 다음과 같다.
VPA에서는 metric을 기준으로 리소스를 늘려야한다고 판단되면, 기존 pod의 리소스 할당량을 높여주는 방식으로 작동한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
recommendation:
+ containerRecommendations:
+ - containerName: nginx
+ lowerBound:
+ cpu: 40m
+ memory: 3100k
+ target:
+ cpu: 60m
+ memory: 3500k
+ upperBound:
+ cpu: 831m
+ memory: 8000k
+
하지만 여기에는 큰 단점이 있다. 바로 리소스 제한을 변경시키기 위한 방법이 Restart만 존재 한다는 점이다. 즉, 서비스 중인 pod가 운영정지될 수도 있다는 말이다. 따라서 HPA와 같이 기존 pod는 유지하되 새로운 pod를 추가하여 서비스를 중단시키지 않는 방식이 선호된다.
그럼 k8s에서는 어떻게 클라이언트 트래픽을 여러 pod들로 분산할까?
kubernetes 공식문서에 따르면, k8s는 iptable를 사용하여 pod들로 트래픽을 분산한다. 이때 발생하는 일은 다음과 같다.
kind:service object를 생성한다kube-proxy deamonset에게 iptable을 업데이트하라고 지시한다.로드밸런싱 policy는 기본적으로 round robin 방식이지만, 100% 정확한 표현은 아니다. 자세한 얘기는 다음 게시글에서 확인할 수 있다
Comments powered by Disqus.
Kubernetes 패키지 관리를 도와주는 도구. node.js의 npm과 같은 역할을 수행한다.
Helm을 사용하면 쿠버네티스 클러스터에서 동작하도록 작성된 패키지들을 관리할 수 있다. 즉, Helm을 사용하면 클러스터에 배포한 애플리케이션을 쉽게 설치, 업데이트, 삭제할 수 있다.
일반적으로 쿠버네티스는 여러 오브젝트로 구성되어있는데, 만약 애플리케이션을 새로 업데이트하고 싶으면, 애플리케이션을 포함하는 모든 오브젝트마다 kubectl 명령을 날려야하는데, Helm을 사용하면 하나의 명령으로 애플리케이션을 배포할 수 있다.
helm은 Chart, Repository, Release 로 구성되어있으며 다음과 같이 연계된다.
K8s cluster 내부에 Helm chart를 원하는 repository에서 검색후 설치 -> 각 설치에 따른 새로운 Release 생성
각 구성요소는 다음과 같다.
Chart(차트)
Helm 패키지로, k8s cluster에서 애플리케이션이 기동되기 위해 필요한 모든 리소스들을 포함. 여러 쿠버네티스 오브젝트를 하나로 묶은 것이라 볼 수 있다.
특정 디렉터리 하위에 모여있는 파일들을 통틀어서 chart라고 부른다. 애플리케이션을 Helm으로 배포하려면 애플리케이션을 정의하는 Helm 차트를 작성해야한다. Chart 구성에 관한 자세한 내용은 공식문서에서 확인 가능하며 기본적으로 아래와 같다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
chart/
+ Chart.yaml # 차트의 정보를 담고 있음.
+ LICENSE # OPTIONA
+ README.md # OPTIONAL
+ requirements.yaml # OPTIONAL: 차트의 의존성을 포함한 파일
+ values.yaml # 배포때마다 바뀔 수 있는 값을 포함
+ charts/ # 애플리케이션의 의존성들의 helm chart를 저장
+ # ex) 애플리케이션 helm chart 설치시 필요하면 mysql helm chart를 저장
+ templates/ # 쿠버네티스 오브젝트 템플릿의 디렉터리. 실제 배포시 필요함.
+ # 설정값과 결합하여 쿠버네티스 메니페스트를 생성하는데 사용한다.
+ templates/NOTES.txt # OPTIONAL: A plain text file containing short usage notes
+
위와 같은 구조에 version 정보가 붙어서 tgz 형태로 압축 패키징 된다. ex) nginx-1.2.3.tgz
Repository(저장소)
차트 저장소로, 차트를 모아두고 공유하는 장소
Release(릴리즈)
K8s cluster에서 구동되는 차트 인스턴스. 일반적으로 동일한 chart를 여러 번 설치할 수 있고 이는 새로운 Release로 관리되게 된다. Release 될 때 패키지된 차트와 config가 결합되어 정상 실행되게 된다.
1
+2
+3
+4
+5
+
apiVersion: v1
+appVersion: "1.0"
+description: A Helm chart for Kubernetes
+name: mychart
+version: 0.1.0
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
# Default values for mychart.
+# This is a YAML-formatted file.
+# Declare variables to be passed into your templates.
+
+replicaCount: 1
+
+image:
+ repository: nginx
+ tag: stable
+ pullPolicy: IfNotPresent
+
+imagePullSecrets: []
+nameOverride: ""
+fullnameOverride: ""
+
templates에서 사용할 값들을 저장해놓은 곳. go template
차트를 작성할 때 가장 중요한 부분중 하나는 templates/ 디렉터리이다. 이 디렉터리의 템플릿들이 실제로 생성할 쿠버네티스 오브젝트를 정의하기 때문이다.
Helm 템플릿은 Go의 템플릿 방식을 따른다. \{\{\}\}로 감까진 영역을 템플릿 디렉티브라고 하는데, 이 템플릿 디렉티브를 활용하여 어떤 값을 특정 값으로 치환하거나 if/else와 같은 컨트롤 구조를 나타낼 수 있다. 또한 함수를 사용할 수도 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: \{\{ include "test-chart.fullname" . \}\}
+ labels:
+\{\{ include "test-chart.labels" . | indent 4 \}\}
+...
+\{\{- if .Values.ingress.enabled -\}\}
+
+
templates/ 아래에 있는 모든 파일은 NOTES.txt를 제외하곤 전부 쿠버네티스 메니페스트로 다뤄진다._로 시작하는 파일은 쿠버네티스 메니페스트로 다뤄지지 않는다. 쿠버네티스 오브젝트를 만들지도 않고, 다른 차트 메니페스트에서 사용한다.Comments powered by Disqus.
애플리케이션의 이전 버전에 있던 사용자 트래픽을 이전 버전(blue)과 거의 동일한 새 버전(green)으로 점진적으로 이전하는 애플리케이션 배포 모델이다. 이때 두 버전 모두 프로덕션 환경에서 실행 상태를 유지한다.
blue에서 green으로 완전히 이전되면 blue는 롤백에 대비하여 대기 상태에 두거나 프로덕션에서 가져온 후 업데이트하여 다음 업데이트의 템플릿으로 삼을 수 있다.
k8s는 클라우드 네이티브 애플리케이션의 마이크로서비스를 패키지화하는 컨테이너의 오케스트레이션을 지원하며, 개발자가 애플리케이션 아키텍처를 처음부터 새로 구축할 필요 없이 재사용할 수 있는 아키텍쳐 패턴 컬렉션은 이러한 k8s를 지원한다.
이러한 k8s 패턴 중 선언적 배포 패턴이 가장 유명하다. 선언적 배포 패턴을 사용하면 k8s 아키텍처에서 pod를 배포할 때 수작업의 부담이 줄어든다.
https://www.redhat.com/ko/topics/devops/what-is-blue-green-deployment
Comments powered by Disqus.
도커에서 이미지를 빌드하고, 앱이 실행되는 컨테이너를 실행하는 과정은 크게 이미지 빌드, 이미지 푸시, 컨테이너 실행 단계로 나뉜다. nginx + spring boot + react로 구성된 앱을 도커 이미지로 관리하려면 먼저 이미지를 빌드할 dockerfile을 잘 작성해야한다.
먼저 이번 글에서 사용될 프로젝트(빌드 컨텍스트)의 디렉터리 구조부터 알아보자
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+
.
+├── Dockerfile
+├── nginx.conf
+└── startApp.sh
+├── client
+│ ├── README.md
+│ ├── build
+│ ├── node_modules
+│ ├── package-lock.json
+│ ├── package.json
+│ ├── patches
+│ ├── postcss.config.js
+│ ├── public
+│ ├── src
+│ ├── tailwind.config.js
+│ ├── tsconfig.json
+├── server
+│ ├── bin
+│ ├── build
+│ ├── build.gradle
+│ ├── gradle
+│ ├── gradlew
+│ ├── gradlew.bat
+│ ├── logs
+│ ├── out
+│ ├── settings.gradle
+└── ├── src
+
최상단 디렉터리에 Dockerfile과 nginx 설정에 필요한 nginx.conf를 배치해두었다. startApp.sh는 컨테이너가 실행될 때 스프링과 nginx를 실행할 스크립트 파일이다. React와 Spring boot는 각각 client, server 디렉터리에 배치하였다.
이제 본격적으로 dockerfile을 작성해보자. 이때 dockerfile은 multi stage build로 작성하였고, spring boot 빌드 -> react 빌드 -> nginx 및 spring 설정 및 실행 과정을 거치도록 작성하였다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
# syntax=docker/dockerfile:1.2
+# Stage 1 - spring 빌드
+FROM openjdk:18-jdk-alpine AS spring-builder
+COPY ./server/gradlew ./
+COPY ./server/gradle ./gradle
+COPY ./server/settings.gradle ./
+COPY ./server/build.gradle ./
+COPY ./server/src ./src
+RUN ./gradlew bootJar
+
openjdk를 base image로 삼았다.두가지 해결책이 있다.
빌드 컨텍스트, 즉 내 로컬에 있는 gradlew 파일의 권한을 바꾼다.
베이스 이미지 상에서 gradlew 파일 권한을 바꾼다.
다음과 같이 RUN 하기 전에 바꾸면 됨.
1
+2
+
RUN chmod +x ./gradlew
+RUN ./gradlew bootJar
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
# Stage 2 - react 빌드
+FROM node:alpine AS react-builder
+WORKDIR /usr/src/app
+# 의존성 설치를 위한 파일 복사
+COPY ./client/package-lock.json ./
+COPY ./client/package.json ./
+RUN npm ci # 의존성 설치
+# React 빌드를 위한 파일 복사
+COPY ./client/tailwind.config.js ./tailwind.config.js
+COPY ./client/postcss.config.js ./postcss.config.js
+COPY ./client/tsconfig.json ./
+COPY ./client/public ./public
+COPY ./client/src ./src
+RUN npm run build
+
npm ci를 사용하는 것이 package-lock.json을 지키며 의존성을 설치할 수 있어서 좋다. 버전에 큰 문제가 없다면 npm install을 사용해도 된다React 빌드를 위한 dockerfile을 봤을 때, COPY, RUN 커맨드를 어떤 기준으로 배치하였는지 궁금할 수 있다. docker에서는 이미지는 여러 레이어로 구성되어있다. FROM, RUN, COPY, ADD 등의 커맨드를 기준으로 레이어를 구성한다. 레이어는 이미지 빌드 시간을 최소화하기 위한 것으로, 이미지를 빌드할 때 변경되지 않은 레이어는 기존에 저장된 데이터를 사용하고, 변경된 레이어는 그 레이어부터 상위 레이어까지 새로 명령어를 실행한다.
따라서 COPY, RUN 커맨드를 사용할 땐, 커맨드의 결과물이 자주 변경되지 않는 것은 가능한 상단에 두어 낮은 레이어에 위치시키면 이미지 빌드 속도를 크게 개선할 수 있다.
따라서 위 react 빌드 dockerfile에서는 상대적으로 자주 변경되지않는 package.json 과 같은 의존성 관리 파일을 상단에 두어 먼저 설치하고, 상대적으로 자주 변경되는 소스파일을 복사하는 COPY 명령어를 후순위에 둔 것이다.
이때 RUN, COPY, ADD 커맨드는 도커 이미지 사이즈에 영향을 주는 커맨드들이다. 잘못 쓰일 수록 도커의 이미지가 필요이상으로 커지므로 가능한 적절히 사용하는 것이 좋다.
참고로 도커 레이어 캐시가 저장되는 곳은 OS마다 다르지만, 기본적으로는 사용자 로컬 환경이다. 이미지 빌드시에 --graph 옵션을 주어 레이어 캐시가 저장되는 위치를 변경할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
# Stage 3
+FROM amd64/nginx
+
+# jdk 설치
+WORKDIR /home1/irteam/download
+RUN curl -X GET https://download.oracle.com/java/17/latest/jdk-17_linux-x64_bin.tar.gz --output jdk-17.tar.gz && \
+ tar xvzf jdk-17.tar.gz && \
+ rm jdk-17.tar.gz
+
+# 어플리케이션 준비
+COPY ./nginx.conf /etc/nginx/nginx.conf
+COPY --from=spring-builder /build/libs/*.jar /app/server/spring-server.jar
+COPY --from=react-builder /usr/src/app/client/build /app/client/build
+
amp64/nginx 를 base image로 삼는다.RUN 커맨드는 레이어를 생성하고, 도커 이미지 사이즈에 영향을 준다. 만약 curl로 jdk파일을 가져오는 작업과, 압축해제, 삭제 작업을 분리하여 RUN으로 실행하면 어떻게 될까?jdk 파일마저 이미지에 포함되게 된다.&& 을 사용하여 한줄에 명령어를 모두 작성하였다.1
+2
+3
+
# 실행 스크립트
+COPY ./startApp.sh ./
+ENTRYPOINT ["./startApp.sh"]
+
1
+2
+3
+4
+
#!/bin/sh
+
+nginx
+/jdk-17.0.5/bin/java -jar /app/server/spring-server.jar
+
Comments powered by Disqus.
ingress는 일반적으로 외부로부터 서버 내부로 유입되는 네트워크 트래픽을 뜻한다.
쿠버네티스에서는 ingress라는 리소스 오브젝트가 존재한다. 쿠버네티스의 ingress는 외부에서 쿠버네티스 클러스터 내부로 들어오는 http, https 요청을 어떻게 처리할지 정의한다. 즉, 외부에서 쿠버네티스에서 실행 중인 deployment와 service에 접근하기 위한 일종의 gateway 같은 역할을 담당한다.
ingress를 사용하지 않으면 NodePort나 LoadBalancer를 사용하여 외부 요청을 받을 수 있다. 하지만 NodePort와 LoadBalancer는 일반적으로 L4(TCP, UDP) 에서의 요청을 처리하며, 네트워크 요청에 대한 세부적인 처리 로직을 구현하기는 한계가 있다.
쿠버네티스에서 ingress를 사용하면 L7에서의 요청을 처리할 수 있다.
쿠버네티스에서 ingress를 사용하기위해서는 다음 두가지가 필요하다
kind: Ingress로 정의되는 Ingress 오브젝트Ingress를 정의하는 yaml 파일은 다음과 같다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
apiVersion: extensions/v1beta1
+kind: Ingress
+metadata:
+ name: nginx-ingress
+ annotations:
+ nginx.ingress.kubernetes.io/rewrite-target: /
+spec:
+ rules:
+ - host: callmeshin75.com # 1
+ http: # 2
+ paths:
+ - path: /api/hostname-service # 3
+ backend:
+ serviceName: hostname-service
+ servicePort: 80
+
callmeshin75.com 호스트명으로 접근하는 네트워크 요청에 대해서 ingress 규칙을 적용/api/hostname-service 경로로 접근하는 요청을 대상으로hostname-service라는 서비스의 80 포트로 요청을 전달위 yaml 파일로부터 ingress를 생성해도 아무 일도 일어나지 않는다. ingress는 단지 ingress 규칙을 정의하는 선언적인 오브젝트일 뿐 외부 요청을 받아들이는 실제 서버가 아니기 때문이다.
Ingress는 Ingress controller라고 불리는 서버 컨테이너에 적용되어야만 Ingress에 적용된 규칙이 활성화된다. 즉 Ingress controller는 외부로부터 네트워크 요청을 수신했을 때, Ingress 규칙에 기반해 이 요청을 어떻게 처리할지를 결정한다.
Ingress는 직접 생성해 사용할수도, 클라우드 플랫폼에 위임할 수도 있다. 직접 구동하려면 Nginx 웹 서버 기반의 Nginx Ingress Controller를 사용할 수 있고, 클라우드 플랫폼에 위임하려면 Google Kubernetes Engine을 사용할 수도 있다.
Ingress Controller는 Ingress보다 먼저 생성할 경우, 쿠버네티스로부터 Ingress의 생성을 watch하고 있으므로, Ingress가 생성되면 자동으로 Nginx에 등록된다. 자세한 내용은 이 포스트에 나와있다.
Nginx ingress controller에 관한 자세한 내용은 공식문서를 참고하면 된다. (ingress controller 생성에 사용되는 mandatory.yaml)
kubectl get ingress로 생성한 ingress의 상태를 확인할 수 있다.
1
+2
+
NAME CLASS HOSTS ADDRESS PORTS AGE
+test-ingress external-lb * 203.0.113.123 80 59s
+
host 필드의 값pending으로 표시된다.https://kubernetes.io/ko/docs/concepts/services-networking/ingress/
https://blog.naver.com/alice_k106/221502890249
Comments powered by Disqus.
istio는 service mesh를 위한 tool입니다. istio를 사용하면 MSA(Micro Service Architecture)를 적용할 때 반복적으로 설정해야하는 L7/모니터링을 쉽고 간편하게 설정할 수 있습니다.
Service mesh는 API 등을 사용하여 마이크로 서비스 간 통신을 안전하고, 빠르고, 신뢰할 수 있게 만들기 위해 설계된 전용 인프라 계층이다.
Service mesh는 보통 application 서비스에 경량화 프록시를 사이드카 방식으로 배치하여 서비스 간 통신을 제어하며, Service Discovery, Load Balancing, Dynamic Request Routing, Circuit Breacking, Retry and Timeout, TLS, Distributed Tracing, Metric 수집, Access Control, A/B Testing 기능 등을 지원한다.
MSA 시스템에서 수십개의 마이크로 서비스가 동작할 수 있기에 관리하기가 매우 복잡하다. 또한 인스턴스가 수행되는 네트워크 간의 레이턴시, 신뢰성, 안전성 등을 보장할 수도 없다. 이러한 문제점들은 어플리케이션 계층(7계층)에서 해결할 수도 있지만, 그렇게 되면 application 언어 및 런타임에 종속성이 생기고, 기능 변경 등을 할 때마다 비용이 발생한다.
따라서 MSA 시스템에서는 인프라 레벨에서 별도의 소스 수정 없이 안정적으로 관리할 수 있는 Service mesh가 필요하다.
istio는 Service mesh를 구현할 수 있는 오픈소스 솔루션이다. istio를 사용하면 서비스 코드 변경 없이 로드밸런싱, 서비스 간 인증, 모니터링 등을 적용하여 마이크로 서비스를 쉽게 관리할 수 있다.
마이크로 서비스 간의 모든 네트워크 통신을 담당할 수 있는 프록시인 Envoy를 사이드카 패턴으로 마이크로 서비스들에 배포한다음, 프록시들의 설정값 저장 및 관리/감독을 수행하고, 프록시들에 설정값을 전달하는 컨트롤러 역할을 수행한다.
각 마이크로 서비스에 사이드카 패턴으로 배포된 envoy 프록시를 Data plane이라고 하고, data plane을 컨트롤하는 부분을 control plane이라고 한다.
Data plane
envoy proxy 세트로 구성되어있다. envoy는 사이드카 방식으로 각각의 마이크로 서비스에 배포되어 서비스로 들어오고 나가는 모든 트래픽을 통제하게 된다. envoy를 통해서 서비스를 호출할 때 호출하는 서비스의 IP주소는 파일럿(Pilot)에 저장된 엔드포인트 정보를 활용한다.
Control Plane
Data plane의 Envoy를 컨트롤하는 부분이다. Control plane은 Istiod라는 하나의 모듈로 되어있다.(istio 1.4 버전까지는 별도로 되어있었음)
트래픽 관리
istio의 간편한 규칙 설정과 트래픽 라우팅 기능을 통해 서비스 간의 트래픽 흐름과 API 호출을 제어할 수 있다. 또한 서킷 브레이커, 타임아웃, 재시도 기능과 같은 서비스 레벨의 속성 구성을 단순화하고, 백분율 기반으로 트래픽을 분할하여 A/B test, canary rollout, staged rollout 과 같은 작업을 쉽게 설정할 수 있다.
보안
istio는 기본적인 보안 통신 채널을 제공하며, 대규모 서비스 통신의 인증, 권한부여, 암호화 등을 관리한다. istio를 사용하면 기본적으로 서비스 통신은 보호되기 때문에, 다양한 프로토콜이나 런타임에서 어플리케이션 변경을 거의하지 않고 일관된 정책을 시행할 수 있다. 쿠버네티스 네트워크 정책과 함께 사용하여 pod 간 통신을 보호하는 기능 등의 이점이 있다.
관찰 가능성
트레이싱, 모니터링, 로깅 기능으로 서비스 메쉬에 배포된 서비스들에 대해 더욱 자세히 파악할 수 있다.
플랫폼 지원
istio는 플랫폼에 독립적이며 다양한 환경에서 실행되도록 설계되었다.
통합과 사용자 정의
istio의 구성 요소들은 확장 및 커스터마이징을 통해 ACL, 로깅, 모니터링, 할당량, 감사 등을 위한 기존 솔루션과 통합될 수 있다.
istio는 마이크로 서비스에서 L7 모니터링, 서비스간 인증, 로드밸런싱을 쉽고 빠르게 붙일 수 있는 오픈소스 솔루션이다. 마이크로 서비스 간 통신을 위해 설계된 인프라계층인 service mesh를 구현한다. 각 마이크로 서비스에는 사이드카 패턴으로 배포된 envoy 프록시가 있고, 이 envoy 프록시들을 Data plane이라고 한다. 그리고 Data plane을 컨트롤 하는 부분을 control plane이라고 한다. envoy 프록시는 사이드카 방식으로 각 마이크로 서비스에 들어오고 나가는 모든 트래픽을 통제한다.
Comments powered by Disqus.
이 포스트는 subicura 님의 kubenetes 안내서을 읽으며 요약/기록한 게시글입니다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
apiVersion: v1
+kind: Pod
+metadata:
+ name: echo
+ labels:
+ app: echo
+spec:
+ containers:
+ - name: app
+ image: ghcr.io/subicura/echo:v1
+
| 정의 | 설명 | 예 |
|---|---|---|
| apiVersion | API 서버 버전 | v1, app/v1, autoscaling/v1 |
| kind | 종류 | Pod, ReplicaSet, Deployment, Service |
| metadata | 메타데이터 | name과 label, annotation으로 구성 |
| spec | 상세명세 | 리소스 종류마다 다름. |
apiVersion, kind, metadata, spec은 리소스를 정의할 때 반드시 필요한 요소이다.
apiVersion은 API 서버의 버전을 나타내는 필드로, apiVersion에 따라 지원하는 리소스가 달라 주의해야한다. 어떤 버전을 사용해야하는지 궁금하면 이 게시글을 참고하자.
위 YAML 파일을 작성하고 다음과 같이 테스트해볼 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
# Pod 생성
+kubectl apply -f echo-pod.yml
+
+# Pod 목록 조회
+kubectl get pod
+
+# Pod 로그 확인
+kubectl logs echo
+kubectl logs -f echo
+
+# Pod 컨테이너 접속
+kubectl exec -it echo -- sh
+# ls
+# ps
+# exit
+
+# Pod 제거
+kubectl delete -f echo-pod.yml
+
컨테이너 실행과 실제 서비스 준비는 약간 차이가 있다. 서버를 실행하고 초기화를 거친다음 실제로 접속이 가능할 때 서비스가 준비되었다고 한다.
쿠버네티스는 libenessProbe와 readnessProbe로 컨테이너생성과 서비스 준비를 체크하여 초기화하는 동안 서비스 되는 것을 막을 수 있다. 보통은 둘을 동시에 적용한다.
livenessProbe
livenessProbe는 컨테이너가 정상적으로 동작하는지 체크하고 정상적으로 동작하지 않는다면 컨테이너를 재시작하여 문제를 해결한다. 정상상태인지 체크하는 방식에는 여러 가지가 있는데, http get으로 확인하는 방법은 다음과 같다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
apiVersion: v1
+kind: Pod
+metadata:
+ name: echo-lp
+ labels:
+ app: echo
+spec:
+ containers:
+ - name: app
+ image: ghcr.io/subicura/echo:v1
+ livenessProbe:
+ httpGet:
+ path: /not/exist
+ port: 8080
+ initialDelaySeconds: 5
+ timeoutSeconds: 2 # Default 1
+ periodSeconds: 5 # Defaults 10
+ failureThreshold: 1 # Defaults 3
+
위 예시는 존재하지 않는 path와 port를 입력하여 일부러 실패에 이르게 하였다. kubectl apply로 pod을 생성하고 시간이 지난 후 kubectl get pod을 통해 pod의 상태를 확인하면 CrashLoopBackOff 상태에 빠진 것을 알 수 있다.
http get이외에도 exec, tcpSocket방법으로도 확인이 가능하다
readinessProbe
readinessProbe는 컨테이너가 준비되었는지 체크하고 정상적으로 준비되지 않았다면 pod으로 들어오는 요청을 제외한다. livenessProbe와의 차이점은 문제가 있어도 pod을 재시작하지 않고 pod으로 오는 요청만 제외한다는 점이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
apiVersion: v1
+kind: Pod
+metadata:
+ name: echo-rp
+ labels:
+ app: echo
+spec:
+ containers:
+ - name: app
+ image: ghcr.io/subicura/echo:v1
+ readinessProbe:
+ httpGet:
+ path: /not/exist
+ port: 8080
+ initialDelaySeconds: 5
+ timeoutSeconds: 2 # Default 1
+ periodSeconds: 5 # Defaults 10
+ failureThreshold: 1 # Defaults 3
+
livenessProbe와 똑같이 존재하지않는 곳으로 요청을 보냈지만, CrashLoopBackOff에는 빠지지 않고 pod의 READY 상태만 0/1로 유지된다.
livenessProbe + readinessProbe
보통은 둘을 함께 적용한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
apiVersion: v1
+kind: Pod
+metadata:
+ name: echo-health
+ labels:
+ app: echo
+spec:
+ containers:
+ - name: app
+ image: ghcr.io/subicura/echo:v1
+ livenessProbe:
+ httpGet:
+ path: /
+ port: 3000
+ readinessProbe:
+ httpGet:
+ path: /
+ port: 3000
+
정상적으로 생성된다.
하나의 pod에는 여러개의 컨테이너를 가질 수도 있다. 하나의 Pod에 속한 컨테이너는 서로 네트워크를 localhost로 공유하고 동일한 디렉터리를 공유할 수 있다.
서로 네트워크를 localhost로 공유할 수 있는 이유는 Pod 안의 모든 네트워크는 동일한 IPC namespace 아래에서 시행되기 때문이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
apiVersion: v1
+kind: Pod
+metadata:
+ name: counter
+ labels:
+ app: counter
+spec:
+ containers:
+ - name: app
+ image: ghcr.io/subicura/counter:latest
+ env:
+ - name: REDIS_HOST
+ value: "localhost"
+ - name: db
+ image: redis
+
요청횟수를 redis에 저장하는 웹 어플리케이션이다. 다음과 같이 테스트할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+
# Pod 생성
+kubectl apply -f counter-pod-redis.yml
+
+# Pod 목록 조회
+kubectl get pod
+
+# Pod 로그 확인
+kubectl logs counter # 오류 발생 (컨테이너 지정 필요)
+kubectl logs counter app
+kubectl logs counter db
+
+# Pod의 app컨테이너 접속
+kubectl exec -it counter -c app -- sh
+# curl localhost:3000
+# curl localhost:3000
+# telnet localhost 6379
+ dbsize
+ KEYS *
+ GET count
+ quit
+
+# Pod 제거
+kubectl delete -f counter-pod-redis.yml
+
현재틑 터미널로 테스트하였지만, Service를 적용하면 브라우저 테스트를 할 수 있다.
pod을 단독으로 만들면 pod에 어떤 문제가 생겼을 때 자동으로 복구되지않는다. 이러한 pod을 정해진 만큼 복제하고 관리하는 것이 ReplicaSet이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+
apiVersion: apps/v1
+kind: ReplicaSet
+metadata:
+ name: echo-rs
+spec:
+ replicas: 1
+ selector:
+ matchLabels:
+ app: echo
+ tier: app
+ template:
+ metadata:
+ labels:
+ app: echo
+ tier: app
+ spec:
+ containers:
+ - name: echo
+ image: ghcr.io/subicura/echo:v1
+
| 정의 | 설명 |
|---|---|
| spec.selector | label 체크 조건 |
| spec.replicas | 원하는 pod의 개수 |
| spec.template | 생성할 pod의 명세 |
RepliacaSet은 label을 체크해서 원하는 수의 Pod이 없으면 새로운 Pod을 생성한다.
다음과 같이 테스트 가능하다
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
# ReplicaSet 생성
+kubectl apply -f echo-rs.yml
+
+# 리소스 확인
+kubectl get po,rs
+
+# 생성한 pod의 label을 확인
+kubectl get pod --show-labels
+
+# app- 를 지정하면 app label을 제거
+kubectl label pod/echo-rs-tcdwj app-
+
+# 다시 Pod 확인 -> label을 삭제한 pod은 그대로 있고, label과 일치하는 pod이 새로 생김
+kubectl get pod --show-labels
+
+# app=으로 라벨 추가
+kubectl label pod/echo-rs-tcdwj app=echo
+
+# 다시 Pod 확인 -> 새로 생성된 pod이 제거됨.
+kubectl get pod --show-labels
+
ReplicaSet은 다음과 같이 동작한다.
ReplicaSet Controller는 ReplicaSet조건을 감시하면서 현재 상태와 원하는 상태가 다른 것을 체크ReplicaSet Controller가 원하는 상태가 되도록 Pod을 생성하거나 제거Scheduler는 API서버를 감시하면서 할당되지 않은 unassigned Pod이 있는지 체크Scheduler는 할당되지 않은 새로운 Pod을 감지하고 적절한 노드node에 배치ReplicaSet은 원하는 개수의 Pod을 유지하는 역할을 담당한다. label을 이용하여 Pod을 체크하므로 label이 겹치지 않게 신경써서 정의해야한다.
실전에서 ReplicaSet을 단독으로 쓰는 경우는 거의 없다. Deployment가 ReplicaSet을 이용하고,주로 Deployment를 이용한다.
하나의 배포판을 의미하는 것으로, 쿠버네티스에서 가장 널리 사용되는 오브젝트이다. ReplicaSet을 이용하여 Pod을 업데이트하고 이력을 관리하여 롤백하거나 특정버전으로 돌아갈 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+
apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: echo-deploy
+spec:
+ replicas: 4
+ selector:
+ matchLabels:
+ app: echo
+ tier: app
+ template:
+ metadata:
+ labels:
+ app: echo
+ tier: app
+ spec:
+ containers:
+ - name: echo
+ image: ghcr.io/subicura/echo:v1
+
kind와 metadate.name을 제외하곤 ReplicaSet과 동일한 설정이다.
다음과 같이 테스트 가능하다
1
+2
+3
+4
+5
+
# Deployment 생성
+kubectl apply -f echo-deployment.yml
+
+# 리소스 확인
+kubectl get po,rs,deploy
+
한번 위 yml 파일의 spec.template.spec.containers[0].image를 다음과 같이 변경하고 다시 Deployment를 생성해보자
1
+2
+
...
+ image: ghcr.io/subicura/echo:v2
+
kubectl get po,rs,deploy 명령어로 확인해보면, 새로운 ReplicaSet이 생기고 Pod이 업데이트되는 것을 확인할 수 있다.
Deployment는 새로운 이미지로 업데이트하기 위해 ReplicaSet을 이용한다. 버전을 업데이트하면 새로운 ReplicaSet을 생성하고 해당 ReplicaSet이 새로운 버전의 Pod을 생성한다. 이때 다음과 같은 과정을 거친다.
API 서버와의 통신과정은 다음과 같다.
Deployment Controller는 Deployment 조건을 감시하면서 현재 상태와 원하는 상태가 다른 것을 체크Deployment Controller가 원하는 상태가 되도록 ReplicaSet 설정ReplicaSet Controller는 ReplicaSet 조건을 감시하면서 현재 상태와 원하는 상태가 다른 것을 체크ReplicaSet Controller가 원하는 상태가 되도록 Pod을 생성하거나 제거Scheduler는 API서버를 감시하면서 할당되지 않은 unassigned Pod이 있는지 체크Scheduler는 할당되지 않은 새로운 Pod을 감지하고 적절한 노드에 배치deployment는 변경된 상태를 기록한다
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
# 히스토리 확인
+kubectl rollout history deploy/echo-deploy
+
+# revision 1 히스토리 상세 확인
+kubectl rollout history deploy/echo-deploy --revision=1
+
+# 바로 전으로 롤백
+kubectl rollout undo deploy/echo-deploy
+
+# 특정 버전으로 롤백
+kubectl rollout undo deploy/echo-deploy --to-revision=2
+
Deployment엔 다양한 배포 전략이 있다. 여기선 롤링 업데이트(RollingUpdate) 방식을 사용할 때 동시에 업데이트하는 Pod의 개수를 변경해보자
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+
apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: echo-deploy-st
+spec:
+ replicas: 4
+ selector:
+ matchLabels:
+ app: echo
+ tier: app
+ minReadySeconds: 5
+ strategy:
+ type: RollingUpdate
+ rollingUpdate:
+ maxSurge: 3
+ maxUnavailable: 3
+ template:
+ metadata:
+ labels:
+ app: echo
+ tier: app
+ spec:
+ containers:
+ - name: echo
+ image: ghcr.io/subicura/echo:v1
+ livenessProbe:
+ httpGet:
+ path: /
+ port: 3000
+
다음과 같이 테스트해보면,
1
+2
+3
+4
+5
+6
+7
+8
+
kubectl apply -f echo-strategy.yml
+kubectl get po,rs,deploy
+
+# 이미지 변경 (명령어로)
+kubectl set image deploy/echo-deploy-st echo=ghcr.io/subicura/echo:v2
+
+# 이벤트 확인
+kubectl describe deploy/echo-deploy-st
+
Pod을 하나씩 생성하지 않고, 한번에 3개가 생성된 것을 확인할 수 있다.
Deployment는 가장 흔하게 사용하는 배포방식이다. 이외에 StatefulSet, DaemonSet, CronJob, Job등이 있지만 사용법은 크게 다르지 않다.
Pod을 자체 IP를 가지고 다른 Pod과 통신할 수 있다. 하지만 쉽게 사라지고 생성되며 그 과정에서 Pod의 IP가 변경되기에 직접 통신하는 방법은 권장하지 않는다.
쿠버네티스는 Pod과 직접 통신하는 대신 별도의 고정된 IP를 가진 서비스를 만들고, 그 서비스를 통해 Pod에 접근한다.
ClusterIP는 클러스터 내부에 새로운 IP를 할당하고 여러 개의 Pod을 바라보는 로드밸런서 기능을 제공한다.
서비스 이름을 내부 도메인 서버에 등록하여 Pod 간에 서비스 이름으로 통신할 수 있습니다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+
apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: redis
+spec:
+ selector:
+ matchLabels:
+ app: counter
+ tier: db
+ template:
+ metadata:
+ labels:
+ app: counter
+ tier: db
+ spec:
+ containers:
+ - name: redis
+ image: redis
+ ports:
+ - containerPort: 6379
+ protocol: TCP
+# 하나의 yaml 파일에 여러개의 리소스를 정의할 땐 "---"를 구분자로 사용한다.
+---
+apiVersion: v1
+kind: Service
+metadata:
+ name: redis
+spec:
+ ports:
+ - port: 6379
+ protocol: TCP
+ selector:
+ app: counter
+ tier: db
+
다음과 같이 테스트하면, redis라는 이름의 서비스가 생성되었음을 알 수 있다.
1
+2
+3
+4
+
kubectl apply -f counter-redis-svc.yml
+
+# Pod, ReplicaSet, Deployment, Service 상태 확인
+kubectl get all
+
같은 클러스터에서 생성된 Pod이라면 redis라는 도메인으로 redis Pod에 접근할 수 있다.
ClusterIP 서비스의 설정은 다음과 같다
| 정의 | 설명 |
|---|---|
| spec.ports.port | 서비스가 생성할 Port |
| spec.ports.targetPort | 서비스가 접근할 Pod의 Port(디폴트 : port와 동일) |
| spec.selector | 서비스가 접근할 Pod의 label 조건 |
이제 redis에 접근할 counter앱을 Deployment로 만들어보자
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+
apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: counter
+spec:
+ selector:
+ matchLabels:
+ app: counter
+ tier: app
+ template:
+ metadata:
+ labels:
+ app: counter
+ tier: app
+ spec:
+ containers:
+ - name: counter
+ image: ghcr.io/subicura/counter:latest
+ env:
+ - name: REDIS_HOST
+ value: "redis" # redis 도메인으로 접근
+ - name: REDIS_PORT
+ value: "6379"
+
다음과 같이 테스트할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
kubectl apply -f counter-app.yml
+
+# counter app에 접근
+kubectl get po
+kubectl exec -it counter-<xxxxx> -- sh
+# curl localhost:3000
+# curl localhost:3000
+# telnet redis 6379
+ dbsize
+ KEYS *
+ GET count
+ quit
+
서비스는 각 pod을 바라보는 로드밸런서 역할을 하면서 내부 도메인서버에 새로운 도메인을 생성한다.
서비스는 다음과 같이 동작한다
Endpoint Controller는 Service와 Pod을 감시하면서 조건에 맞는 Pod의 IP를 수집Endpoint Controller가 수집한 IP를 가지고 Endpoint 생성Kube-Proxy는 Endpoint 변화를 감시하고 노드의 iptables을 설정CoreDNS는 Service를 감시하고 서비스 이름과 IP를 CoreDNS에 추가iptables은 커널 레벨의 네트워크 도구이고, CoreDNS는 빠르고 편리하게 사용할 수 있는 클러스터 내부용 도메인 네임 서버이다. iptables 설정으로 여러 IP에 트래픽을 전달하고, CoreDNS를 이용하여 IP 대신 도메인 이름을 사용한다.
iptables 는 규칙이 많아지면 성능이 느려지는 이슈가 있어, ipvs를 사용하는 옵션도 있다
CoreDNS는 클러스터에서 호환성을 위해 kube-dns라는 이름으로 생성된다.
Endpoint는 서비스의 접속 정보를 가지고 있다. Endpoint의 상태는 다음과 같이 확인이 가능하다
1
+2
+3
+4
+5
+
kubectl get endpoints
+kubectl get ep #줄여서
+
+# redis Endpoint 확인
+kubectl describe ep/redis
+
NodePort는 클러스터의 모든 노드에 포트를 오픈한다. 여러개의 노드가 있다면 아무 노드로 접근해도 지정한 pod으로 접근할 수 있다.
참고로 NodePort는 ClusterIP의 기능을 기본으로 포함한다.
NodePort의 단점은 노드가 사라졌을 때 자동으로 다른 노드를 통해 접근이 불가능하다는 점이다. 예를 들어 3개의 노드가 있다면 3개 중에 아무 노드로 접근해도 NodePort로 연결할 수 있지만 어떤 노드가 살아있는지는 알수가 없다.
자동으로 살아있는 노드에 접근하기 위해 모든 노드를 바라보는 Load Balancer가 필요하다. 브라우저는 NodePort에 직접 요청을 보내는 것이 아니라 LoadBalancer에 요청하고 LoadBalancer가 알아서 살아있는 노드에 접근하면 NodePort의 단점을 없앨 수 있다.
실전에서 NodePort와 LoadBalancer는 제한적으로 사용한다. 보통 웹 어플리케이션을 배포하면 80 또는 443 포트만 사용하고 하나의 포트에서 여러 개의 서비스를 도메인이나 경로에 따라 다르게 설정하기 때문이다. 이 부분은 Ingress에서 처리할 수 있다.
하나의 클러스터에서 여러가지 서비스를 운영한다고 해보자. 이때 NodePort를 사용하여 서비스 개수만큼 포트를 열고 사용자에게 어떤 포트인지 알려주는 방법은 유저 경험에 좋지 않다.
좋은 방법은 같은 포트 아래에서 각 서비스를 path로 구분하는 방법이고, Ingress 사용해 구현한다.
Ingress Controller는 Ingress 변화를 체크Ingress Controller는 변경된 내용을 Nginx에 설정하고 프로세스 재시작YAML로 만든 Ingress 설정을 단순히 nginx 설정으로 바꾸는 과정을 Ingress Controller가 자동으로 해주는 것이다.
Ingress는 도메인, 경로만 연동하는 것이 아니라 요청 timeout, 요청 max size 등 다양한 프록시 서버 설정을 할 수 있다.
MySQL과 같은 데이터베이스는 데이터가 유실되지 않도록 반드시 별도의 저장소에 데이터를 저장하고, 컨테이너를 새로 만들 때 이전 데이터를 가져와야한다.
쿠버네티스는 Volume을 사용하여 컨테이너의 디렉토리를 외부 저장소와 연결하고 다양한 플러그인을 지원하여 흔히 사용하는 대부분의 스토리지를 별도 설정없이 사용할 수 있다.
empty-dir은 같은 pod 안에 속한 컨테이너 간 디렉터리를 공유하는 방법으로 보통 사이드카 패턴에서 사용한다. 예를들어 특정 컨테이너에서 생성되는 로그 파일을 별도의 컨테이너가 수집할 수 있다.
아래 예시는 app 컨테이너는 /var/log/example.log에 로그 파일을 만들고, sidecar 컨테이너는 해당 로그파일을 처리하도록 하는 예시다
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+
apiVersion: v1
+kind: Pod
+metadata:
+ name: sidecar
+spec:
+ containers:
+ - name: app
+ image: busybox
+ args:
+ - /bin/sh
+ - -c
+ - >
+ while true;
+ do
+ echo "$(date)\n" >> /var/log/example.log;
+ sleep 1;
+ done
+ volumeMounts:
+ - name: varlog
+ mountPath: /var/log
+ - name: sidecar
+ image: busybox
+ args: [/bin/sh, -c, "tail -f /var/log/example.log"]
+ volumeMounts:
+ - name: varlog
+ mountPath: /var/log
+ volumes:
+ - name: varlog
+ emptyDir: {}
+
다음 명령어로 테스트해볼수 있다.
1
+2
+3
+4
+
kubectl apply -f empty-dir.yml
+
+# sidecar 로그 확인
+kubectl logs -f sidecar -c sidecar
+
호스트(node) 디렉터리를 컨테이너 디렉터리에 연결하는 방법이다.
아래 예시는 호스트의 /var/log를 컨테이너의 /host/var/log 디렉터리로 마운트한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
apiVersion: v1
+kind: Pod
+metadata:
+ name: host-log
+spec:
+ containers:
+ - name: log
+ image: busybox
+ args: ["/bin/sh", "-c", "sleep infinity"]
+ volumeMounts:
+ - name: varlog
+ mountPath: /host/var/log
+ volumes:
+ - name: varlog
+ hostPath:
+ path: /var/log
+
아래 명령어로 마운트된 디렉터리를 확인할 수 있다.
1
+2
+3
+4
+5
+
kubectl apply -f hostpath.yml
+
+# 컨테이너 접속 후 /host/var/log 디렉토리를 확인
+kubectl exec -it host-log -- sh
+ls -al /host/var/log
+
컨테이너에서 설정 파일을 관리하는 방법은 이미지를 빌드할 때 복사하거나, 컨테이너를 실행할 때 외부 파일을 연결하는 방법이 있다.
쿠버네티스는 ConfigMap으로 설정을 관리한다.
ConfigMap을 만드는 방법을 다음 세가지가 있다. 실습
ConfigMap은 컨테이너에서 volume으로 마운트하여 파일을 가져오는 방식으로 사용한다. 하지만 volume이 아닌 환경변수로 설정할 수도 있다. 이때는 다음과 같이 환경 변수를 작성하는 곳에 configMap을 키로 연결하면 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
apiVersion: v1
+kind: Pod
+metadata:
+ name: alpine-env
+spec:
+ containers:
+ - name: alpine
+ image: alpine
+ command: ["sleep"]
+ args: ["100000"]
+ env:
+ - name: hello
+ valueFrom:
+ configMapKeyRef:
+ name: my-config
+ key: hello
+
쿠버네티스에서 비밀번호, SSH 인증, TLS Secret와 같은 보안 정보를 관리하는 방법으로, ConfigMap과 유사하지만, 보안 정보를 관리하기 위해 Secret을 별도로 제공한다.
ConfigMap와의 차이점은 데이터가 base64로 저장되는 거 말고는 거의 없다.
Secret은 암호화 되지 않는다. 있는 정보를 그대로 저장하며, etcd에 접근이 가능하면 누구나 저장된 Secret을 확인할 수 있다. vault와 같은 외부 솔루션을 사용하여 보안을 강화할 수 있다.
https://subicura.com/k8s/
Comments powered by Disqus.
이 포스트는 subicura 님의 kubenetes 게시글을 읽으며 요약/기록한 게시글입니다.
쿠버네티스(kubenetes, k8s)는 도커 컨테이너를 쉽고 빠르게 배포/확장하고 관리를 자동화해주는 오픈소스 플랫폼이다. 단순한 컨테이너 플랫폼이 아닌 마이크로 서비스, 클라우드 플랫폼을 지향하고 컨테이너로 이루어진 것들을 손쉽게 담고 관리할 수 있는 그릇 역할을 한다.
쿠버네티스는 다음과 같은 다양한 배포방식을 지원한다.
다양한 웹 어플리케이션을 하나의 로드 밸런서로 서비스하기 위해 ingress 기능을 제공한다.
웹 어플리케이션은 보통 외부에서 직접 접근할 수 없도록 애플리케이션을 내부망에 설치하고, 외부에서 접근이 가능한 ALB나 nginx, Apache를 프록시 서버로 활용한다. 프록시 서버는 도메인과 Path 조건에 따라 등록된 서버로 요청을 전달하는데 서버가 바뀌거나 IP가 변경되면 매번 설정을 수정해야한다.
쿠버네티스의 ingress는 이를 자동화하여 기존 프록시 서버에서 사용하는 설정을 거의 그대로 사용할 수 있다. 새로운 도메인을 추가하거나 업로드 용량을 제한하기 위해 일일히 프록시 서버에 접속하여 설정할 필요가 없다.
하나의 클러스터에 여러 개의 Ingress 설정을 할 수 있어 관리자 접속용 Ingress와 일반 접속용 Ingress를 따로 관리할 수 있다.
쿠버네티스는 Cloud Controller를 사용하여 클라우드 연동을 손쉽게 확장할 수 있다. AWS 등 많은 클라우드 업체에서 모듈을 제공하여 관리자는 동일한 설정파일을 서로 다른 클라우드에서 동일하게 사용할 수 있다.
하나의 클라스터를 namespace에 따라 논리적으로 구분하여 사용할 수 있다. 더 세부적인 설정으로 Label 기능을 사용하여 유연하고 확장성 있게 리소스를 관리할 수 있다.
각각의 리소스에 대해 유저별로 세부적인 권한을 손쉽게 지정할 수 있다. AWS의 경우 IAM을 연동할 수 있다.
필요한 기능이 쿠버네티스에서 제공하지 않을 수 있다. 이럴때 그러한 기능을 쿠버네티스 기본 기능과 동일한 방식으로 적용하고 사용할 수 있다.
예를 들어 쿠버네티스는 기본적으로 SSL 인증서 관리기능을 제공하지 않지만 cert-manager를 설치하고 Certificate 리소스를 사용하면 쿠버네티스 명령어로 인증서를 관리할 수 있다.
CPU, Memory 사용량, 현재 접속자 수와 같은 메트릭으로 Auto Scaling을 할 수 있다.
컨테이너 개수를 조정하는 Horizontal Pod Autoscaler, 컨테이너의 리소스 할당량을 조정하는 Vertical Pod Autoscaler, 서버 개수를 조정하는 Cluster Autoscaler 방식이 있다.
클라우드에 설치한 쿠버네티스 클러스터와 자체 서버에 설치한 쿠버네티스를 묶어서 하나로 사용할 수 있다. 구글에서 발표한 Anthos를 이용하면 한 곳에서 여러 클라우드의 여러 클러스터를 관리할 수 있다.
Desired State는 관리자가 원하는 시스템의 환경을 의미한다.(ex : 얼마나 많은 웹서버가 동작하면 좋은지, 몇번 포트로 서비스되면 좋은지 등)
쿠버네티스는 현재 상태를 모니터링하면서 관리자가 설정한 원하는 상태를 유지하려고 내부적으로 작업하는 로직을 가지고 있다. 이러한 개념 때문에 쿠버네티스는 관리자가 서버를 배포할 때, 직접적인 동작을 명령하지 않고, 상태를 선언하는 방식을 사용한다.
쿠버네티스는 상태를 관리하기 위한 대상을 오브젝트로 정의한다. 기본으로 수십가지 오브젝트를 제공하고 새로운 오브젝트를 추가하기 쉽기 떄문에 확장성이 좋다. 주요 오브젝트는 다음과 같다.
Pod
ReplicaSet
Service
Volume
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+
apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: nginx-deployment
+spec:
+ selector:
+ matchLabels:
+ app: nginx
+ replicas: 2 # tells deployment to run 2 pods matching the template
+ template:
+ metadata:
+ labels:
+ app: nginx
+ spec:
+ containers:
+ - name: nginx
+ image: nginx:1.14.2
+ ports:
+ - containerPort: 80
+
오브젝트 명세(Spec)은 YAML 파일로 정의하고, 여기에 오브젝트 종류와 원하는 상태를 입력한다. 이러한 명세는 생성, 조회, 삭제로 관리할 수 있기 때문에 REST API로 쉽게 노출할 수 있다. 접근 권한 설정도 같은 개념을 적용하여 누가 어떤 오브젝트에 어떤 요청을 할 수 있는지도 정의할 수 있다.
쿠버네티스는 애플리케이션을 배포하기 위해 원하는 상태(desired state)를 다양한 오브젝트에 라벨을 붙여 정의(yaml)하고 API 서버에 전달하는 방식을 사용한다.
“컨테이너를 2개 배포하고 80 포트로 오픈해줘”라는 간단한 작업을 위해 다음과 같은 구체적인 명령을 전달해야한다.
“컨테이너를 Pod으로 감싸고 type=app, app=web이라는 라벨을 달아줘. type=app, app=web이라는 라벨이 달린 Pod이 2개 있는지 체크하고 없으면 Deployment Spec에 정의된 템플릿을 참고해서 Pod을 생성해줘. 그리고 해당 라벨을 가진 Pod을 바라보는 가상의 서비스 IP를 만들고 외부의 80 포트를 방금 만든 서비스 IP랑 연결해줘.”
쿠버네티스는 중앙(Master)에 API 서버와 상태 저장소를 두고 각 서버(Node)의 에이전트(kubelet)와 통신하는 단순한 구조이다. 하지만 앞에서 얘기한 개념을 여러 모듈로 쪼개어 구현하고, 다양한 오픈소스를 사용하기 떄문에 설치가 까다롭고 구성이 복잡해보이는 것이다.
쿠버네티스는 전체 클러스터를 관리하는 마스터와 컨테이너가 배포되는 노드로 구성되어있다. 모든 명령은 마스터의 API 서버를 호출하고 노드는 마스터와 통신하면서 필요한 작업을 수행한다. 특정 노드의 컨테이너에 명령하거나 로그를 조회할 때도 노드에 직접 명령하는게 아니라, 마스터에 명령을 내리고 마스터가 노드에 접속하여 대신 결과를 응답한다.
마스터 서버는 다양한 모듈이 확장성을 고려하여 기능별로 쪼개져있다. 관리자만 접속할 수 있도록 보안 설정을 해야하고, 마스터 서버가 죽으면 클러스터를 관리할 수 없기 때문에 보통 3대를 구성하여 안정성을 높인다.
AWS EKS 같은 경우 마스터를 AWS에서 자체 관리하여 안정성을 높였고(마스터에 접속 불가), 개발환경이나 소규모 환경에서는 마스터와 노드를 분리하지 않고 같은 서버에 구성하기도 한다.
마스터의 구성요소는 다음과 같다.
kubectl 이라는 명령행 도구를 사용한다노드 서버는 마스터 서버와 통신하면서 필요한 Pod을 생성하고 네트워크와 볼륨을 설정한다. 실제 컨테이너들이 생성되는 곳이며 수백, 수천대로 확장할 수 있다. 각각의 서버에 라벨을 붙여 사용목적을 정의할 수 있다.
노드의 구성요소는 다음과 같다
쿠버네티스를 학습하다보면 노드와 클러스터란 단어를 많이 접할 수 있다. 이 둘의 차이는 무엇일까?
쿠버네티스는 도커 컨테이너 이외에도 CRI(Container Runtime Interface)를 구현한 다양한 컨테이너 런타임을 지원한다. 또한 CNI(네트워크), CSI(스토리지)를 지원하여 인터페이스만 구현한다면 쉽게 확장하여 사용할 수 있게 제공한다.
관리자가 애플리케이션을 배포하기 위해 ReplicaSet을 생성하면 다음과 같은 과정을 거쳐 Pod을 생성한다.
각 모듈은 서로 통신하지 않고 오직 API Server하고만 통신한다. API Server를 통해 etcd에 저장된 상태를 체크하고, 현재 상태와 원하는 상태가 다르면 필요한 작업을 수행한다. 각 모듈을 살펴보자
kubectl
kube controller
Scheduler
Kubelet
https://subicura.com/2019/05/19/kubernetes-basic-1.html
https://subicura.com/k8s/guide/#%E1%84%8B%E1%85%AF%E1%84%83%E1%85%B3%E1%84%91%E1%85%B3%E1%84%85%E1%85%A6%E1%84%89%E1%85%B3-%E1%84%87%E1%85%A2%E1%84%91%E1%85%A9
Comments powered by Disqus.
Pinpoint는 대규모 분산 시스템의 성능을 분석하고 문제를 진단, 처리하는 플랫폼입니다. 2012년 7월에 개발을 시작해 2015년 1월 9일에 오픈소스로 공개했습니다
인터넷 서비스의 시스템 복잡도가 증가함에 따라 장애나 성능 문제가 발생했을 때 해결이 어려워졌다. 네이버의 시스템도 마찬가지였다. 시스템 복잡도가 높아지며 발생하는 문제를 해결하기 위해 n계층 아키텍처를 효과적으로 추적할 수 있는 새로운 플랫폼을 개발하기로 했고 그것이 Pinpoint이다.
Pinpoint에는 n계층 아키텍처를 추적할 수 있는 다음과 같은 특징이 있다.
Pinpoint는 Google Dapper 스타일의 추적 방식을 사용해, 분산된 요청을 하나의 트랜잭션으로 추적한다.
분산 트랜잭션 추적의 핵심은 다음 그림처럼 Node 1에서 Node 2로 메시지를 전송했을 때, 분산된 Node 1과 Node 2가 처리한 메시지의 관계를 찾아내는 것이다.
google dapper에서는 Node 1에서 발송하는 메시지에 태그를 추가하여 각 메시지를 구분하도록 하여 추적이 가능하도록 했다.
Pinpoint에서는 Google Dapper 스타일의 추적 방법을 변형해 호출 추적에 사용한다. 원격 호출 시 분산 트랜잭션의 추적을 위해 애플리케이션 수준에서 태그 데이터를 호출 헤더에 추가한다. 태그 데이터는 키의 집합으로 구성되며, 이 집합을 TraceId라고 정의한다.
Span
Trace
TraceId
Observability 와 APM 필요성
마이크로 서비스가 많아지면서 서비스의 흐름을 파악하기 어려워졌다. 이러한 상황에서 서비스 전반의 Observability를 확보하기 위해 다음 세가지가 필요해졌다.
APM(Application Performance Management)
APM 필요한 이유
Pinpoint 소개
요청 처리 순서
bytecode 주입
overload
pinpoint feature 소개
server map
scatter chart
call stack
inspector
Comments powered by Disqus.
쿠버네티스의 패턴 중 하나로, 어플리케이션 컨테이너와 독립적으로 동작하는 별도의 컨테이너를 붙이는 패턴이다. 어플리케이션 컨테이너의 변경이나 수정 없이 독립적으로 동작하는 컨테이너를 붙였다 뗐다 할 수 있다.
파드는 쿠버네티스에서 가장 기본적인 배포 단위로서 자신에게 속한 컨테이너들에게 런타임제약을 걸 수 있다. 예를 들어 모든 컨테이너는 동일한 노드에 배치되고, 동일한 파드 수명주기를 공유하게 할 수 있다. 파드는 또한 컨테이너들이 볼륨을 공유하고 로컬 네트워크 또는 호스트 IPC를 통해 서로 통신할 수 있게 해준다. 이러한 이유로 컨테이너 그룹을 파드로 만든다.
사이드카 패턴은 컨테이너의 기능을 확장시키기 위해 컨테이너를 파드에 넣는 것과 유사하다. 다음은 HTTP 서버와 깃 동기화 컨테이너가 정의된 파일이다. HTTP가 어플리케이션 컨테이너이고, 깃 동기화 컨테이너가 사이드카 컨테이너이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+
apiVersion: v1
+kind: Pod
+metadata:
+ name: web-app
+spec:
+ containers:
+ - name: app
+ image: docker.io/centos/httpd // HTTP로 파일을 제공하는 기본 애플리케이션 컨테이너
+ ports:
+ - containerPort: 80
+ volumeMounts:
+ - mountPath: /var/www/html //사이드카와 기본 애플리케이션 컨테이너 간에 데이터를 교환하기위해 공유된 장소
+ name: git
+ - name: poll
+ image: axeclbr/git // 깃 서버로부터 데이터를 가져오고 병렬로 실행하는 사이드카 컨테이너
+ volumeMounts:
+ - mountPath: /var/lib/data //사이드카와 기본 애플리케이션 컨테이너 간에 데이터를 교환하기 위해 공유된 장소
+ name: git
+ env:
+ - name: GIT_REPO
+ value: https://github.com/mdn/beginner-html-site-scripted
+ command:
+ - "sh"
+ - "-c"
+ - "git clone ${GIT_REPO} . && watch -n 600 git pull"
+ workingDir: /var/lib/data
+ volumes:
+ - emptyDir: {}
+ name: git
+
사이드카 패턴에서는 기본 컨테이너가 있고, 공동작업을 향상시키는 보조 컨테이너가 있다. 일반적으로 기본 컨테이너는 컨테이너 목록에 나열된 첫번째 컨테이너가 기본 컨테이너다.
사이드카 패턴을 통해 컨테이너는 런타임에 협업이 가능해지며 그와 동시에 두 컨테이너의 관심을 분리시킴으로서 서로의 의존성을 없앤다.
또한 사이드카는 같은 파드 안에서 애플리케이션 컨테이너와 동일한 수명주기를 공유하므로 애플리케이션 컨테이너와 함께 만들어지고 사용중지된다.
장점
단점
Comments powered by Disqus.
기존 자바스크립트에서는 var 키워드로만 변수선언이 가능했다. 하지만, let const 키워드를 추가하여 보다 예측가능한 코드를 작성할 수 있게 됐다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
// es6 이전.
+// var는 재선언 가능
+var a = "This is string";
+var a = 1234;
+
+// ES6 이후
+// let은 재선언 불가능
+let b = "This is string";
+b = 1234;
+
+// const는 재할당 불가능
+const c = "This is string";
+c = 1234; // <-- 에러 발생
+
const는 상수 키워드로 재할당, 재선언이 불가능하다. 변경할 수 없다로 이해하기 쉽지만, let과 var는 헷갈릴 수 있다. 차이는 다음과 같다.
| var | let | |
|---|---|---|
| 재선언 | 가능 | 불가능 |
| 재할당 | 가능 | 가능 |
| scope | function-scope | block-scope |
| 호이스팅 | 일어남 | 안일어남 (정확히는 일어나지만 할당문을 만나기 전까지는 사용불가능) |
문자열 내에 변수사용을 쉽게 만들어주는 문법으로 다음과 같이 사용한다.
1
+2
+3
+4
+5
+6
+7
+
const name = "user-1";
+const count = 324;
+
+// es6 이전
+var str1 = name + " has pushed button " + count + " times.";
+// es6 이후
+const str2 = `${name} has pushed button ${count} times.`;
+
함수 표현식을 화살표함수로 표현하여 간결하게 함수를 작성할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
// es6 이전
+function func(a, b) {
+ return a + b;
+}
+
+// es6 이후
+const func = (a, b) => {
+ return a + b;
+}
+// return 생략
+const func = (a, b) => a + b;
+
객체, 배열의 구조를 분해하여, 새로운 변수에 할당하는 과정이다. 객체/배열에서 값을 꺼낼때 가독성 좋게 가져올 수 있도록 한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
// es6 이전 (배열)
+var arr = [1, 2, 3];
+console.log(arr[0], arr[1], arr[2]);
+// es6 이후 (배열)
+const [first, second, third] = arr;
+console.log(first, second, third);
+
+// es6 이전 (객체)
+var obj = {
+ name : "user-1",
+ count: 123
+}
+console.log(obj.name, obj.count);
+
+// es6 이후 (객체)
+const {name, count} = obj;
+console.log(name, count);
+
ES6 이전에 자바스크립트의 비동기처리는 콜백함수로 이루어졌다. 하지만 비동기 함수가 많아지면서 콜백 지옥이 일어나기도 했다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
// es6 이전
+function callbackHell(callback) {
+ setTimeout(function() {
+ ... // do something
+ setTimeout(function() {
+ ... // do something
+ setTimeout(function() {
+ ... // do something
+ callback();
+ }, 1000)
+ }, 1000)
+ }, 1000)
+}
+
이러한 콜백 지옥을 개션하기 위한 문법으로 다음과 같이 코드가 변경된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+
function callbackFree(callback) {
+ const promise1 = new Promise((resolve, reject) => {
+ setTimeout(() => {
+ ... // do something
+ resolve();
+ }, 1000)
+ })
+
+ const promise2 = promise1.then(() => {
+ return new Promise((resolve, reject) => {
+ setTimeout(() => {
+ ... // do something
+ resolve();
+ }, 1000)
+ })
+ });
+
+ promise2.then(() => {
+ setTimeout(() => {
+ ... // do something
+ callback();
+ }, 1000)
+ })
+}
+
+
자바스크립트에서 객체 지향 프로그래밍이 가능하도록 Class 키워드가 도입되었다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
class Polygon {
+ constructor(height, width) {
+ this.name = 'Polygon';
+ this.height = height;
+ this.width = width;
+ }
+}
+
+class Square extends Polygon {
+ constructor(length) {
+ super(length, length);
+ this.name = 'Square';
+ }
+}
+
자바스크립트에서 코드를 분리하여 관리할 수 있게하여 재사용성과 생산성을 높이기위해 모듈 시스템이 도입되었다.
script 태그 사용 예시
1
+
<script type="module" src="lib.mjs"></script>
+
es6에서 사용 에시
1
+2
+3
+4
+5
+
import compute from "commons/compute";
+
+const result = compute(1,2);
+
+export result;
+
commonsJs에서 사용 예시
1
+2
+3
+4
+5
+
const compute = require("commons/compute");
+
+const result = compute(1,2);
+
+module.exports = { result };
+
require와 import의 차이점
- require/exports
- 구형브라우저나, 브라우저 밖에서 사용하는
CommonJS문법파일의 어디서나 호출 가능
- import/export
- ES6에서 도입된 문법
- 파일의 시작부분에서만 실행가능(import 전용 비동기 문법으로 중간에 불러올 수도 있다.)
필요한 부분만 선택하여 로드 가능. 또한 require보다 성능이 우수함
- 하나의 파일에서 두 키워드를 동시에 사용할 순 없
Comments powered by Disqus.
javascript를 공부하다보면 아래와 같은 말을 종종 듣는다.
싱글스레드 기반으로 동작하는 자바스크립트
이벤트 루프를 기반으로 하는 싱글스레드 Node.js
정말 싱글 스레드인가? 어떻게 싱글 스레드인가? 이벤트 루프는 무엇인가? 를 간단히 알아보기 위해 자바스크립트가 동작하는 환경과 엔진에 대해 알아보자.
javascript로 작성한 코드를 해석하고 실행하는 인터프리터. 주로 웹브라우저에서 사용되지만, node.js에서는 V8 엔진이 사용된다.
구글에서 개발한 V8 엔진을 비롯해, 대부분의 자바스크립트 엔진은 다음 세 영역으로 나뉜다.
추가적으로 Event Loop가 존재하여 Task queue에 들어가는 task들을 관리하게 된다.
자바스크립트는 단 하나의 call stack을 사용한다. 따라서 자바스크립트에서는 하나의 함수가 실행하면, 다른 어떤 task도 수행될 수가 없다.
자바스크립트에서는 요청이 들어올때마다 해당 요청을 순차적으로 call stack에 담아 처리한다. 메소드가 실행될 때 call stack에 새로운 프레임이 생기고, push 되고, 메소드의 실행이 끝나면 해당 프레임은 pop되는 원리이다.
예시)
1
+2
+3
+4
+5
+6
+7
+8
+9
+
function foo(b) {
+ var a = 10;
+ return a + b;
+}
+function bar(x) {
+ var y = 2;
+ return foo((x = y));
+}
+console.log(bar(1));
+
동적으로 생성된 객체(인스턴스)는 힙에 할당된다. 대부분 구조화되지 않는 더미 같은 메모리 영역을 heap이라고 표현한다.
자바스크립트의 런타임 환경에서 처리해야하는 task들을 임시 저장하는 대기 큐. call stack이 비어졌을 때 먼저 대기열에 들어온 순서대로 수행된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
function test1() {
+ setTimeout(function () {
+ console.log("first");
+ }, 0);
+ test2();
+}
+function test2() {
+ console.log("second");
+}
+test1();
+
위 코드는 다음 결과를 낸다.
1
+2
+
second;
+first;
+
자바스크립트에서 비동기로 호출되는 함수들은 call stack에 쌓이지 않고, task queue에 들어가기 때문이다. 따라서 위 작업은 다음 순서로 실행된다.
이때 task queue 안에 들어있는 이벤트를 꺼내거나, 넣는 작업을 하는 것이 이벤트 루프 이다.
다음과 같은 의문이 들 수 있다.
위 질문에 대해 MDN은 다음의 가상 코드로 답을 한다.
1
+2
+3
+
while (queue.waitForMessage()) {
+ queue.processNextMessage();
+}
+
이런 식으로 이벤트루프는 현재 실행중인 태스크가 없는지와 태스크 큐에 이벤트가 있는지 반복적으로 확인한다.
queue에 이벤트가 존재하면 while-loop 안으로 들어가서 해당하는 이벤트를 처리하거나 작업을 수행한다. 그리고 다시 queue로 돌아와 새로운 이벤트가 존재하는지 파악하는 것이다. 따라서 task queue에 있는 작업들은 한번에 하나씩 call stack으로 호출되어 처리된다.
이때 브라우저에서 task queue는 다음과 같이 세가지 큐로 나뉜다.
https://asfirstalways.tistory.com/362
https://sculove.github.io/post/javascriptflow/
Comments powered by Disqus.
Comments powered by Disqus.
firebase cloud function에서 firestore와 storage의 이벤트트리거를 등록하는 예제는 firebase 문서에 자세히 설명되어있다.
여기서는 cloud functions에서 firestore와 storage에 접근하여 읽고 쓰는 법을 간단한 코드로 보여줄 것이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+
const admin = require("firebase-admin");
+admin.initializeApp();
+
+...
+// 한 document 가져오기
+const doc = await admin
+ .firestore()
+ .collection("컬렉션이름")
+ .doc("document이름")
+ .get();
+// document set
+await admin
+ .firestore()
+ .collection("컬렉션이름")
+ .doc("document이름")
+ .set({
+ url: req.body.url,
+ name: req.body.name,
+ createdAt: Date.now(),
+ });
+...
+
storage
@google-cloud/storage 에서 Storage 모듈 가져오기
Storage 객체를 생성
storage.bucket으로 bucket url로 bucket reference 생성
생성한 bucket reference로 file reference를 만들고, save 메소드를 통해 저장
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
const { Storage } = require("@google-cloud/storage");
+
+const storage = new Storage();
+
+...
+const bucket = storage.bucket("버켓 url");
+
+//file ref 생성
+const file = bucket.file(`${req.body.uid}/${req.body.uuid}.png`);
+
+//저장
+await file.save(screenshotBinary, {
+ metadata: { contentType: "image/png" },
+});
+...
+
Comments powered by Disqus.
최근 프로젝트를 하면서, 다른 요소들의 크기는 정해져있을때 남은 한 요소의 크기를 부모 요소에서 남는 공간만큼 부여하는 부분이 많았다(그리고 앞으로도 많을 것 같다)
위 부분을 구현할때, flex와 grid를 통해 해결했어서 그것을 기록 하는 차원에서 이 글을 적어본다.
만약 다음과 같이 div 엘리먼트들이 배치되어있고, 우리는 가운데 expand를 container의 남는 공간만큼 확장 시키고 싶다고 하자.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
.container {
+ display: flex;
+ background-color: burlywood;
+}
+
+.leftItem {
+ height: 100px;
+ width: 100px;
+ background-color: cadetblue;
+}
+.rightItem {
+ height: 100px;
+ width: 100px;
+ background-color: chartreuse;
+}
+.expandItem {
+ width: 100px;
+ height: 100px;
+ background-color: chocolate;
+}
+
만약 expandItem에 width:100%;를 주면 어떻게 될까?
1
+2
+3
+4
+5
+6
+7
+
...
+.expandItem {
+ width: 100%;
+ height: 100px;
+ background-color: chocolate;
+}
+...
+
위와같이, 확장이 된 모습을 볼 수 있다. 하지만 뭔가 첫번째 사진과 좀 다르지 않는가? left와 right가 첫번째 사진보다 작아보이지 않는가?
자바스크립트로 확인해보자. 다음과 같은 코드로 간단히 left 요소의 너비를 찾아봤다
1
+2
+3
+4
+5
+6
+
<script>
+ window.onload = function () {
+ const left = document.getElementById("left");
+ console.log(left.getBoundingClientRect());
+ };
+ </script>
+
결과는 대략 81px. expand 엘리먼트는 다른 요소들의 너비를 침범하여 확장되었다. 이는 실제 UI를 구현할때 상당히 거슬릴 것이다.
그럼 어떤 방법으로 다른 요소를 침범하지 않고 확장이 가능할까?
제목에서와 같이 width :100%말고 flex : 1 0 auto;를 expand 엘리먼트에 주어보자.( flex-grow: 1;로도 되나, 여기선 예시는 flex : 1 0 auto;로 들어본다 )
1
+2
+3
+4
+5
+
.expandItem {
+ flex: 1 0 auto;
+ height: 100px;
+ background-color: chocolate;
+}
+
자바스크립트 수행결과까지 확인해보니, 제대로 다른 요소를 침범하지 않고 확장되었다.
이와 같은 방법으로 세로 방향일때도 적용이 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+
.container {
+ display: flex;
+ width: 100px;
+ height: 500px;
+ flex-direction: column;
+ background-color: burlywood;
+}
+
+.leftItem {
+ height: 100px;
+ width: 100px;
+ background-color: cadetblue;
+}
+.rightItem {
+ height: 100px;
+ width: 100px;
+ background-color: chartreuse;
+}
+.expandItem {
+ flex: 1 0 auto;
+ height: 100px;
+ background-color: chocolate;
+}
+
위와 같이 컨테이너의 높이가 500px이고, 위아래 요소는 100px의 높이를 가질때, expand 엘리먼트에 flex : 1 0 auto를 똑같이 주면 아래와 같이 나온다.
제대로 확장됨을 알 수 있다.
1
+2
+3
+
display: grid;
+grid-template-columns: 100px minmax(0px, auto) 100px;
+grid-template-rows: 100px minmax(0px, auto);
+
2번째 열의 요소들은 수평으로 확장되었고, 2번째 행의 요소들은 수직으로 제대로 확장되었다.
1
+2
+
display: grid;
+grid-template-columns: auto 1fr auto;
+
이때 flex를 활용하여 확장을 할때 주의해야할 점이 있다.
바로 확장해야할 요소를 제외한 요소는 크기가 필요한만큼은 정해져 있어야 한다는 점이다. 그렇지 않으면 expand 요소는 최대한으로 커질 것으로, 그 뜻은 아래 사진과 같이 크기가 정해져있지 않은 요소의 크기는 최소로 정한다는 말이다.
따라서 만약 다른 요소들의 크기를 어느정도는 여유있게 확보해야한다면, 크기를 정해주어야한다.
Comments powered by Disqus.
1
+2
+3
+
main() {
+ // 항상 최상단 앱의 진입점 main() 이 있어야함.
+}
+
1
+
print("hello world")
+
1
+2
+
String name = 'dart'; // 명시적 타입 선언
+var othername = 'dart'; //타입 추론
+
1
+2
+
var name; // null
+int x; // null
+
1
+2
+3
+4
+5
+6
+7
+8
+
var myNull = null;
+if (myNull == null) {
+ print("is null");
+}
+var zero = 0;
+if(zero == 0) {
+ print("is 0")
+}
+
1
+2
+3
+4
+5
+6
+7
+
fn() {
+ return true;
+}
+
+bool fn() {
+ return true;
+}
+
1
+
bool fn() => true;
+
dart에서는 Future 객체를 사용하여 비동기를 지원함
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
import 'dart:convert';
+import 'package:http/http.dart' as http;
+
+class Example {
+ Future<String> _getIPAddress() {
+ final url = 'https://httpbin.org/ip';
+ return http.get(url).then((response) {
+ String ip = jsonDecode(response.body)['origin'];
+ return ip;
+ });
+ }
+}
+
+main() {
+ final example = new Example();
+ example
+ ._getIPAddress()
+ .then((ip) => print(ip))
+ .catchError((error) => print(error));
+}
+
또 async, await로 비동기를 처리할 수 있음.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+
import 'dart:convert';
+import 'package:http/http.dart' as http;
+
+class Example {
+ Future<String> _getIPAddress() async {
+ final url = 'https://httpbin.org/ip';
+ final response = await http.get(url);
+ String ip = jsonDecode(response.body)['origin'];
+ return ip;
+ }
+}
+
+main() async {
+ final example = new Example();
+ try {
+ final ip = await example._getIPAddress();
+ print(ip);
+ } catch (error) {
+ print(error);
+ }
+}
+
Comments powered by Disqus.
1
+
$ flutter create <projectname>
+
1
+2
+3
+4
+
import 'package:flutter/material.dart';
+import 'package:flutter/cupertino.dart'; // ios 위젯
+import 'package:flutter/widgets.dart';
+import 'package:flutter/my_widgets.dart';
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
import 'package:flutter/material.dart';
+
+void main() {
+ runApp(
+ Center(
+ child: Text(
+ 'Hello, world!',
+ textDirection: TextDirection.ltr,
+ ),
+ ),
+ );
+}
+
다음은 hellow world 위젯
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
import 'package:flutter/material.dart';
+
+void main() => runApp(MyApp());
+
+class MyApp extends StatelessWidget {
+ @override
+ Widget build(BuildContext context) {
+ return MaterialApp(
+ title: 'Welcome to Flutter',
+ home: Scaffold(
+ appBar: AppBar(
+ title: Text('Welcome to Flutter'),
+ ),
+ body: Center(
+ child: Text('Hello world'),
+ ),
+ ),
+ );
+ }
+}
+
사용자 입력이나 데이터 수신으로 상태가 동적으로 변화한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
// React Native
+class CustomCard extends React.Component {
+ render() {
+ return (
+ <View>
+ <Text> Card {this.props.index} </Text>
+ <Button
+ title="Press"
+ onPress={() => this.props.onPress(this.props.index)}
+ />
+ </View>
+ );
+ }
+}
+
+// Usage
+<CustomCard onPress={this.onPress} index={item.key} />
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+
// Flutter
+class CustomCard extends StatelessWidget {
+ CustomCard({@required this.index, @required this.onPress});
+
+ final index;
+ final Function onPress;
+
+ @override
+ Widget build(BuildContext context) {
+ return Card(
+ child: Column(
+ children: <Widget>[
+ Text('Card $index'),
+ FlatButton(
+ child: const Text('Press'),
+ onPressed: this.onPress,
+ ),
+ ],
+ )
+ );
+ }
+}
+ ...
+// Usage
+CustomCard(
+ index: index,
+ onPress: () {
+ print('Card $index');
+ },
+)
+ ...
+
1
+2
+3
+4
+
// Dart
+void main(){
+ print('Hello, this is the main function.');
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
┬
+└ projectname
+ ┬
+ ├ android - Android 관련 파일 포함.
+ ├ build - iOS 및 Android 빌드 파일 저장.
+ ├ ios - iOS 관련 파일 포함.
+ ├ lib - 외부에서 접근할 수 있는 Dart 소스 파일 포함.
+ ┬
+ └ src - 추가적인 소스 파일 포함.
+ └ main.dart - Flutter 진입점이며 새로운 앱의 시작.
+ Flutter 프로젝트를 만들 때 자동으로 생성.
+ Dart코드 작성을 시작하는 부분임.
+ ├ test - 자동화 테스트 파일 포함.
+ └ pubspec.yaml - Flutter 앱의 메타데이터 포함.
+ React Native의 package.json 파일과 동일함.
+
1
+2
+3
+4
+
flutter:
+ assets:
+ - assets/my_icon.png
+ - assets/background.png
+
1
+
image: AssetImage('assets/background.png'),
+
1
+2
+
body: Image.network(
+ 'https://flutter-io.kr/images/owl.jpg',
+
1
+2
+3
+4
+
dependencies:
+ flutter:
+ sdk: flutter
+ google_sign_in: ^3.0.3
+
Comments powered by Disqus.
React Native 에서는 View 가 컨테이너이고 Flexbox를 이용한 레이아웃, 스타일, 터치 핸들링, 접근성제어를 지원
Flutter에서는 Container나, Column, Row, Center같은 위젯 라이브러리의 핵심 레이아웃 위젯을 사용할 수 있음.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
// Flutter
+var data = [ ... ];
+ListView.builder(
+ itemCount: data.length,
+ itemBuilder: (context, int index) {
+ return Text(
+ data[index],
+ );
+ },
+)
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+
// Flutter
+class MyCanvasPainter extends CustomPainter {
+
+ @override
+ void paint(Canvas canvas, Size size) {
+ Paint paint = Paint();
+ paint.color = Colors.amber;
+ canvas.drawCircle(Offset(100.0, 200.0), 40.0, paint);
+ Paint paintRect = Paint();
+ paintRect.color = Colors.lightBlue;
+ Rect rect = Rect.fromPoints(Offset(150.0, 300.0), Offset(300.0, 400.0));
+ canvas.drawRect(rect, paintRect);
+ }
+
+ bool shouldRepaint(MyCanvasPainter oldDelegate) => false;
+ bool shouldRebuildSemantics(MyCanvasPainter oldDelegate) => false;
+}
+class _MyCanvasState extends State<MyCanvas> {
+
+ @override
+ Widget build(BuildContext context) {
+ return Scaffold(
+ body: CustomPaint(
+ painter: MyCanvasPainter(),
+ ),
+ );
+ }
+}
+
/canvas-2cc207759f6ab912bf73e1c3298dc2183618ef207ed989f4d83f6c08fd3a3279.png)
React native에서는 style props를 이용해 flexbox 속성을정의함.
1
+2
+3
+4
+
// React Native
+<View
+ style=
+>
+
flutter에서는 컨트롤 위젯 및 스타일 속성을 결합하여 설계된 위젯을 통해 레이아웃을 정의한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+
// Flutter
+Center(
+ child: Column(
+ children: <Widget>[
+ Container(
+ color: Colors.red,
+ width: 100.0,
+ height: 100.0,
+ ),
+ Container(
+ color: Colors.blue,
+ width: 100.0,
+ height: 100.0,
+ ),
+ Container(
+ color: Colors.green,
+ width: 100.0,
+ height: 100.0,
+ ),
+ ],
+ ),
+)
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
// Flutter
+Stack(
+ alignment: const Alignment(0.6, 0.6),
+ children: <Widget>[
+ CircleAvatar(
+ backgroundImage: NetworkImage(
+ 'https://avatars3.githubusercontent.com/u/14101776?v=4'),
+ ),
+ Container(
+ decoration: BoxDecoration(
+ color: Colors.black45,
+ ),
+ child: Text('Flutter'),
+ ),
+ ],
+)
+
/stack-04b7bf2727e1eb71f5dfea8430ee833f24be1ced1893ae86270795b2ab76c5b9.png)
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
<View style={styles.container}>
+ <Text style=>
+ This is a sample text
+ </Text>
+</View>
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ backgroundColor: '#fff',
+ alignItems: 'center',
+ justifyContent: 'center'
+ }
+});
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
var textStyle = TextStyle(fontSize: 32.0, color: Colors.cyan, fontWeight:
+ FontWeight.w600);
+ ...
+Center(
+ child: Column(
+ children: <Widget>[
+ Text(
+ 'Sample text',
+ style: textStyle,
+ ),
+ Padding(
+ padding: EdgeInsets.all(20.0),
+ child: Icon(Icons.lightbulb_outline,
+ size: 48.0, color: Colors.redAccent)
+ ),
+ ],
+ ),
+)
+
1
+
Icon(Icons.lightbulb_outline, color: Colors.redAccent)
+
1
+2
+
name: my_awesome_application
+flutter: uses-material-design: true
+
1
+2
+3
+
name: my_awesome_application
+dependencies:
+ cupertino_icons: ^0.1.0
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
class SampleApp extends StatelessWidget {
+ @override
+ Widget build(BuildContext context) {
+ return MaterialApp(
+ title: 'Sample App',
+ theme: ThemeData(
+ primarySwatch: Colors.blue,
+ textSelectionColor: Colors.red
+ ),
+ home: SampleAppPage(),
+ );
+ }
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
@override
+ Widget build(BuildContext context) {
+ return MaterialApp(
+ theme: ThemeData(
+ primaryColor: Colors.cyan,
+ brightness: Brightness.dark,
+ ),
+ home: StylingPage(),
+ );
+ }
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
@override
+ Widget build(BuildContext context) {
+ return Theme(
+ data: ThemeData(
+ primaryColor: Colors.cyan,
+ brightness: brightness,
+ ),
+ child: Scaffold(
+ backgroundColor: Theme.of(context).primaryColor,
+ ...
+ ...
+ ),
+ );
+ }
+
객체의 자체적인 구성정보나 위젯의 BuildContext 이외의 것에 의존하지 않을때 유용함
setState를 호출하여 Flutter 프레임워크에게 상태가 변경됐음을 알려줌.
아래는 createState() 메서드를 필요로하는 StatefulWidget을 선언하는 예시
1
+2
+3
+4
+5
+6
+7
+
class MyStatefulWidget extends StatefulWidget {
+ MyStatefulWidget({Key key, this.title}) : super(key: key);
+ final String title;
+
+ @override
+ _MyStatefulWidgetState createState() => _MyStatefulWidgetState();
+}
+
아래는 _MyStatefulWidgetState 라는 상태 클래스.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+
class _MyStatefulWidgetState extends State<MyStatefulWidget> {
+ bool showtext=true;
+ bool toggleState=true;
+ Timer t2;
+
+ void toggleBlinkState(){
+ setState((){
+ toggleState=!toggleState;
+ });
+ var twenty = const Duration(milliseconds: 1000);
+ if(toggleState==false) {
+ t2 = Timer.periodic(twenty, (Timer t) {
+ toggleShowText();
+ });
+ } else {
+ t2.cancel();
+ }
+ }
+
+ void toggleShowText(){
+ setState((){
+ showtext=!showtext;
+ });
+ }
+
+ @override
+ Widget build(BuildContext context) {
+ return Scaffold(
+ body: Center(
+ child: Column(
+ children: <Widget>[
+ (showtext
+ ?(Text('This execution will be done before you can blink.'))
+ :(Container())
+ ),
+ Padding(
+ padding: EdgeInsets.only(top: 70.0),
+ child: RaisedButton(
+ onPressed: toggleBlinkState,
+ child: (toggleState
+ ?( Text('Blink'))
+ :(Text('Stop Blinking'))
+ )
+ )
+ )
+ ],
+ ),
+ ),
+ );
+ }
+}
+
위젯이 StatefulWidget인지 StatelessWidget인지 결정하라
어떤 객체가 위젯의 상태를 관리하는지 결정하라
StatefulWidget의 하위 클래스 및 State
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
class MyStatefulWidget extends StatefulWidget {
+ MyStatefulWidget({Key key, this.title}) : super(key: key);
+ final String title;
+
+ @override
+ _MyStatefulWidgetState createState() => _MyStatefulWidgetState();
+}
+
+class _MyStatefulWidgetState extends State<MyStatefulWidget> {
+
+ @override
+ Widget build(BuildContext context) {
+ ...
+ }
+}
+
StatefulWidget을 위젯트리에 추가하기
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
class MyStatelessWidget extends StatelessWidget {
+ // This widget is the root of your application.
+
+ @override
+ Widget build(BuildContext context) {
+ return MaterialApp(
+ title: 'Flutter Demo',
+ theme: ThemeData(
+ primarySwatch: Colors.blue,
+ ),
+ home: MyStatefulWidget(title: 'State Change Demo'),
+ );
+ }
+}
+
Comments powered by Disqus.
ReactNative 에서 대부분의 컴포넌트는 매겨변수나 속성을 props로 전달함
Flutter에서는 매개변수가 있는 생성자에서 받은 속성을 final로 표시된 지역변수나 함수에 할당함
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+
// Flutter
+class CustomCard extends StatelessWidget {
+
+ CustomCard({@required this.index, @required this.onPress});
+ final index;
+ final Function onPress;
+
+ @override
+ Widget build(BuildContext context) {
+ return Card(
+ child: Column(
+ children: <Widget>[
+ Text('Card $index'),
+ FlatButton(
+ child: const Text('Press'),
+ onPressed: this.onPress,
+ ),
+ ],
+ ));
+ }
+}
+ ...
+//Usage
+CustomCard(
+ index: index,
+ onPress: () {
+ print('Card $index');
+ },
+)
+
많은 데이터가 아니라면, 키-값 쌍 형태의 저장소인 shared_preference 플러그인으로 기본 타입(booleans, floats, int, long, string) 데이터를 읽고 쓸 수 있음
1
+2
+3
+4
+
dependencies:
+ flutter:
+ sdk: flutter
+ shared_preferences: ^0.4.3
+
1
+2
+
// Dart
+import 'package:shared_preferences/shared_preferences.dart';
+
데이터 저장 : SharedPreferences 클래스의 setter 메소드 사용
데이터 읽기 : SharedPreferences 클래스의 getter 메소드 사용
1
+2
+3
+4
+5
+6
+7
+
SharedPreferences prefs = await SharedPreferences.getInstance();
+_counter = prefs.getInt('counter');
+prefs.setInt('counter', ++_counter);
+setState(() {
+ _counter = _counter;
+});
+
+
Route 위젯 : 앱의 화면 또는 페이지를 추상화 한 것
Navigator 위젯 : route를 관리하는 위젯
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
// Flutter
+class NavigationApp extends StatelessWidget {
+ // This widget is the root of your application.
+ @override
+ Widget build(BuildContext context) {
+ return MaterialApp(
+ ...
+ routes: <String, WidgetBuilder>{
+ '/a': (BuildContext context) => usualNavscreen(), //Named route 지정
+ '/b': (BuildContext context) => drawerNavscreen(),
+ }
+ ...
+ );
+ }
+}
+
Named route로 이동하기 위해, of메서드를 사용하여 Navigator 위젯의 BuildContext를 지정함.
1
+
Navigator.of(context).pushNamed('/a');
+
Navigator의 push 메서드로 주어진 route를 가장 가까운 context를 가진 네비게이터에 추가하고 이동할 수 있음.
1
+2
+
Navigator.push(context, MaterialPageRoute(builder: (BuildContext context)
+ => UsualNavscreen()));
+
Flutter는 drawer 및 탭 네비게이션을 위한 여러 특수 위젯을 제공함
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
// Flutter
+TabController controller=TabController(length: 2, vsync: this);
+
+TabBar(
+ tabs: <Tab>[
+ Tab(icon: Icon(Icons.person),),
+ Tab(icon: Icon(Icons.email),),
+ ],
+ controller: controller,
+),
+
TickerProvider : Ticker 객체를 제공할 수 있는 클래스에 의해 구현된 인터페이스
Ticker : 프레임이 트리거 될때마다 알림을 받아야하는 모든 객체에서 사용할 수 있음
보통 AnimationController를 통해 간접적으로 사용함
AnimationController는 Ticker를 얻기위해 TickerProvider가 필요함
State에서 AnimationController를 만들고 있다면, TickerProviderStateMixin 또는 SingleTickerProviderStateMixin 클래스를 사용하여 적절한 TickerProvide를 얻음
아래 Scaffold 위젯은 새로운 TabBar 위젯을 감싸고 2개의 탭을 생성
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+
class _NavigationHomePageState extends State<NavigationHomePage> with SingleTickerProviderStateMixin {
+ TabController controller=TabController(length: 2, vsync: this);
+ @override
+ Widget build(BuildContext context) {
+ return Scaffold(
+ bottomNavigationBar: Material (
+ child: TabBar(
+ tabs: <Tab> [
+ Tab(icon: Icon(Icons.person),)
+ Tab(icon: Icon(Icons.email),),
+ ],
+ controller: controller,
+ ),
+ color: Colors.blue,
+ ),
+ body: TabBarView(
+ children: <Widget> [
+ home.homeScreen(),
+ tabScreen.tabScreen()
+ ],
+ controller: controller,
+ )
+ );
+ }
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
// Flutter
+@override
+Widget build(BuildContext context) {
+ return Scaffold(
+ drawer: Drawer(
+ child: ListTile(
+ leading: Icon(Icons.change_history),
+ title: Text('Screen2'),
+ onTap: () {
+ Navigator.of(context).pushNamed('/b');
+ },
+ ),
+ elevation: 20.0,
+ ),
+ appBar: AppBar(
+ title: Text('Home'),
+ ),
+ body: Container(),
+ );
+}
+
ReactNative 에서는 Touchable 컴포넌트를 사용함
Flutter에서는 onPress : field 를 가진 버튼이나 터치 가능한 위젯을 사용함
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+
// Flutter
+GestureDetector(
+ child: Scaffold(
+ appBar: AppBar(
+ title: Text('Gestures'),
+ ),
+ body: Center(
+ child: Column(
+ mainAxisAlignment: MainAxisAlignment.center,
+ children: <Widget>[
+ Text('Tap, Long Press, Swipe Horizontally or Vertically '),
+ ],
+ )
+ ),
+ ),
+ onTap: () {
+ print('Tapped');
+ },
+ onLongPress: () {
+ print('Long Pressed');
+ },
+ onVerticalDragEnd: (DragEndDetails value) {
+ print('Swiped Vertically');
+ },
+ onHorizontalDragEnd: (DragEndDetails value) {
+ print('Swiped Horizontally');
+ },
+);
+
1
+2
+3
+4
+
dependencies:
+ flutter:
+ sdk: flutter
+ http: <latest_version>
+
HTTP 클라이언트 지원에 dart:io 를 사용함.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
import 'dart:io';
+...
+final url = Uri.https('httpbin.org', 'ip');
+final httpClient = HttpClient();
+_getIPAddress() async {
+ var request = await httpClient.getUrl(url);
+ var response = await request.close();
+ var responseBody = await response.transform(utf8.decoder).join();
+ String ip = jsonDecode(responseBody)['origin'];
+ setState(() {
+ _ipAddress = ip;
+ });
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+
// Flutter
+final TextEditingController _controller = TextEditingController();
+ ...
+TextField(
+ controller: _controller,
+ decoration: InputDecoration(
+ hintText: 'Type something', labelText: 'Text Field '
+ ),
+),
+RaisedButton(
+ child: Text('Submit'),
+ onPressed: () {
+ showDialog(
+ context: context,
+ child: AlertDialog(
+ title: Text('Alert'),
+ content: Text('You typed ${_controller.text}'),
+ ),
+ );
+ },
+ ),
+)
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+
final formKey = GlobalKey<FormState>();
+
+...
+
+Form(
+ key:formKey,
+ child: Column(
+ children: <Widget>[
+ TextFormField(
+ validator: (value) => !value.contains('@') ? 'Not a valid email.' : null,
+ onSaved: (val) => _email = val,
+ decoration: const InputDecoration(
+ hintText: 'Enter your email',
+ labelText: 'Email',
+ ),
+ ),
+ RaisedButton(
+ onPressed: _submit,
+ child: Text('Login'),
+ ),
+ ],
+ ),
+)
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
void _submit() {
+ final form = formKey.currentState;
+ if (form.validate()) {
+ form.save();
+ showDialog(
+ context: context,
+ child: AlertDialog(
+ title: Text('Alert'),
+ content: Text('Email: $_email, password: $_password'),
+ )
+ );
+ }
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
// Flutter
+if (Theme.of(context).platform == TargetPlatform.iOS) {
+ return 'iOS';
+} else if (Theme.of(context).platform == TargetPlatform.android) {
+ return 'android';
+} else if (Theme.of(context).platform == TargetPlatform.fuchsia) {
+ return 'fuchsia';
+} else {
+ return 'not recognised ';
+}
+
## 디버깅
AnimationController 객체를 만들고, 기간을 지정
기본적으로 AnimationController는 특정 기간 동안 0.0 ~ 1.0 범위에서 값이 선형적으로 증가함
일반적으로 초당 60 FPS로, 기기에서 새로운 프레임을 보여줄 준비가 됐을 때마다 새로운 값을 생성함
AnimationController를 정의할 때, vsync 객체를 넘겨줘야함
그래야 화면이 꺼져있을때 애니메이션에 불필요한 리소스를 소비하지 않음
클래스 정의에 TickerProviderStateMixin을 추가하여 상태 저장객체를 vsync로 사용할 수 있음
AnimationController 에는 생성자에 vsync 인수를 사용하여 만들어진 TickerProvider가 필요함
Tween은 시작값과 끝 값 사이의 보간 또는 입력 범위에서 출력 범위까지의 매핑을 표현함
아래 예제에서는 FadeTransition 위젯을 사용하고, opacity 속성을 animation 객체에 매핑시킴
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+
// Flutter
+import 'package:flutter/material.dart';
+
+void main() {
+ runApp(Center(child: LogoFade()));
+}
+
+class LogoFade extends StatefulWidget {
+ _LogoFadeState createState() => _LogoFadeState();
+}
+
+class _LogoFadeState extends State<LogoFade> with TickerProviderStateMixin {
+ Animation animation;
+ AnimationController controller;
+
+ initState() {
+ super.initState();
+ controller = AnimationController(
+ duration: const Duration(milliseconds: 3000), vsync: this);
+ final CurvedAnimation curve =
+ CurvedAnimation(parent: controller, curve: Curves.easeIn);
+ animation = Tween(begin: 0.0, end: 1.0).animate(curve);
+ controller.forward();
+ }
+
+ Widget build(BuildContext context) {
+ return FadeTransition(
+ opacity: animation,
+ child: Container(
+ height: 300.0,
+ width: 300.0,
+ child: FlutterLogo(),
+ ),
+ );
+ }
+
+ dispose() {
+ controller.dispose();
+ super.dispose();
+ }
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+
child: Dismissible(
+ key: key,
+ onDismissed: (DismissDirection dir) {
+ cards.removeLast();
+ },
+ child: Container(
+ ...
+ ),
+),
+
Comments powered by Disqus.
설치법
stateless 위젯은 변경 불가능 => 모든 값이 final이어야함.
stateful 위젯은 변경가능
dart 에서는 식별자 앞에 밑줄을 붙이면 private 적용이 된다.
1
+
final _suggestions = <WordPair>[]
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+
function* generate() {
+ yield 1;
+ yield 2;
+ yield 3;
+ return 4;
+}
+const generator = generate();
+
1
+2
+3
+4
+5
+
generator.next() -> {value : 1, done :false}
+generator.next() -> {value : 2, done :false}
+generator.next() -> {value : 3, done :false}
+generator.next() -> {value : 4, done :true}
+generator.next() -> {value : undefined, done :false}
+
1
+2
+3
+4
+5
+
function* sumGenerator() {
+ let a = yield;
+ let b = yield;
+ yield a + b;
+}
+
1
+2
+3
+4
+
generator.next() -> {value : undefined, done :false}
+generator.next(1) -> {value : undefined, done :false}
+generator.next(2) -> {value : undefiend, done :false}
+generator.next() -> {value : 3, done :true}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
function* watchGenerator() {
+ while (true) {
+ const action = yield;
+ if (action.type === "type1") {
+ console.log("type 1");
+ }
+ if (action.type === "type2") {
+ console.log("type 2");
+ }
+ }
+}
+
1
+2
+
generator.next() -> {value : undefined, done : false}
+generator.next({type:'type1'}) -> "type 1"
+
Comments powered by Disqus.
Git은 기본적으로 파일시스템의 스냅샷을 저장한다.(커밋 당시의 GIT 디렉터리의 모든 파일 정보를 저장) 또한 파일 및 스냅샷을 해시하여 바뀐 버전인지 아닌지 빠르게 체크함
이후 스냅샷들의 크기가 커지면, 주기적으로 git gc(garbage collection)을 통해 delta를 만듦
.gitignore 에서는 아래와 같은 glob 패턴을 따름
*.a : 확장자가 .a인 파일을 무시
!lib.a : lib.a 는 무시하지 않도록 함
/TODO : 현재 디렉토리에 있는 TODO 파일은 무시하고, subdir/TODO 처럼 하위 디렉터리에 있는 파일은 무시하지 않음
build/ : build/ 폴더에있는 모든 파일 무시
doc/*.txt : doc/notes.txt는 무시하고, doc/subdir/notes.txt는 무시하지 않음
doc/**/*.pdf : doc 디렉터리 아래의 모든 pdf 파일 무시
main 브랜치는 언제든 배포가능한 상태로
새로운 일을 시작하기 위해 브랜치는 main에서 딴다면, 어떤 일을 하는지 이름에 명확히 작성한다.
원격지 브런치로 수시로 push한다.
피드백이 필요할때, 머지 준비가 완료되었을때는 pull request를 생성한다
pull request는 코드 리뷰를 도와주는 시스템이다.기능에 대한 리뷰와 사인이 끝난 후 main으로 머지한다.
main으로 머지되고 푸시 되었을 때는 즉시 배포되어야한다.
https://www.slideshare.net/ky200223/git-89251791
https://ujuc.github.io/2015/12/16/git-flow-github-flow-gitlab-flow/
Comments powered by Disqus.
호이스팅은 변수를 끌어올리는 것. var로 선언된 모든 변수 선언을 hoist한다. hoist란 변수의 정의가 그 범위에 따라 선언과 할당으로 분리되는 것을 의미한다. 즉, 함수 내의 선언들을 모두 끌어올려서 해당 함수 유효 범위의 최상단에 선언하는 것
자바스크립트에서 변수의 선언은 끌어올려진다. 다음의 코드를 보자.
1
+2
+3
+4
+5
+6
+
function getX() {
+ console.log(x); // undefined;
+ var x = 100;
+ console.log(x); // 100
+}
+getX();
+
다른 언어의 경우 첫번째 console.log 에서 오류가 발생했을 것이다. 하지만 자바스크립트에서는 변수의 선언이 최상위로 끌어올려지기때문에, undefined가 출력된다. 즉 작동순서에 맞게 코드를 재구성하면 다음과 같다.
1
+2
+3
+4
+5
+6
+7
+
function getX() {
+ var x;
+ console.log(x);
+ x = 100;
+ console.log(x);
+}
+getX();
+
이때 할당 구문은 런타임 과정에서 이루어지기 때문에 hoist 되지 않는다.
호이스팅은 함수에서도 발생한다. 하지만 함수 선언식이냐 함수 표현식이냐에 따라 동작이 달라진다.
선언식 : function 함수명() {} 와 같이 함수명을 포함한 함수 선언 형태
1
+2
+3
+4
+
foo();
+function foo() {
+ console.log("hello");
+}
+
표현식 : var 함수명 = function () {}와 같이 익명함수를 변수에 할당하는 방법
1
+2
+3
+4
+
foo(); // Uncaught TypeError: foo is not a function
+var foo = function () {
+ console.log("hello");
+}
+
let과 const는 hoist는 되지만 선언 전 사용은 불가능하다.
https://crushonit.tistory.com/95
https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/JavaScript
Comments powered by Disqus.
##
DBMS에서 데이터베이스 테이블의 모든 데이터를 검색하여 데이터를 찾기에는 시간이 오래 걸리기에, 데이터의 칼럼의 값과 그 데이터가 저장된 레코드의 주소를 키와 값의 쌍으로 만든 것.
DBMS의 인덱스는 항상 정렬된 상태를 유지하기 때문에, 원하는 값을 탐색하는데는 빠르지만, 추가/삭제/수정에는 쿼리문 실행 속도가 느려진다.(작업 후 다시 정렬해야하기에)
결과적으로 DBMS의 인덱스는 데이터 저장 성능을 희생하고, 읽기 성능을 높이는 기능이다. 따라서 모든 컬럼을 대상으로 인덱스를 생성하면 데이터 저장 성능이 떨어지고, 인덱스의 크기가 비대해지기에 역효과가 난다.
인덱스가 많아지면 SELECT는 빨라지지만, INSERT/DELETE/UPDATE는 느려진다. 이유는 인덱스에서 mutation 작업시 다음과 같은 일이 발생하기 떄문이다.
UPDATE, DELETE 작업에서 기존의 인덱스를 그대로 두기에, mutation 작업이 빈번히 발생하면 테이블 로우는 10개인데 인덱스는 100개인 상황이 발생할 수 있다.
또한 데이터의 형식에 따라 인덱스를 만들면 효율적이고 만들면 비효율적인 데이터의 형식이 존재한다. 예를들어, 이름, 나이, 성별 세 가지의 필드가 있을때, 이름에 대해서는 인덱스가 효율적이고 나이,성별에 대해서는 그렇지 않다. 왜냐하면, 데이터의 범위가 작기때문에 겹치는 인덱스가 많아지고 되고, 따라서 추가적으로 원하는 데이터를 다시 검색해야하기 때문이다.
B +- Tree 인덱스 알고리즘
일반적으로 사용되는 알고리즘. 칼럼의 값을 변형하지 않고, 원래의 값을 이용해 인덱싱하는 알고리즘이다.
Hash 인덱스 알고리즘
컬럼의 값으로 해시 값을 계산하여 인덱싱하는 알고리즘으로 매우 빠른 검색을 지원함. 하지만 값을 변경하여 인덱싱하므로, 값의 일부만으로 검색하고자 할때는 해시 인덱스를 사용할 수 없음.
주로 메모리 기반의 데이터베이스에서 많이 사용함.
B 트리를 자주 사용하는 이유
SELECT 질의의 조건에는 부등호 (<>) 연산도 포함됨. 해시 인덱스를 사용하면 이러한 부등호 연산에 문제가 생긴다. 왜냐하면 해시는 동등(=) 연산에 특화되어있기 때문이다.
물리적으로 인접한 장소에 있는 데이터들을 동시에 조회하는 경우가 많으므로(spatial locality), 인접한 것들을 묶어 저장하는 방식의 인덱스
이때 클러스터드 인덱스는 테이블의 primary key에 대해서만 적용된다. 즉 primary key가 비슷한 레코드끼리 묶어 저장한 것을 클러스터드 인덱스라고 표현함. 클러스터드 인덱스에서는 primary key에 의해 레코드의 저장 위치가 결정되며 primary key가 변경되면 레코드의 물리적인 저장위치 또한 변경되어야한다. 따라서 클러스터드 인덱스에서는 primary key를 신중하게 결정해야한다.
클러스터드 인덱스는 테이블 당 한개만 생성할 수 있음(primary key에 대해 적용되기에). non 클러스터드 인덱스는 테이블당 여러개의 인덱스를 만들 수 있음
여러개의 필드로 구성하는 인덱스. 이때 인덱스로 설정하는 필드의 속성이 중요하다.
title, author 이 순서로 인덱스를 설정한다면 title 을 search 하는 경우, index 를 생성한 효과를 볼 수 있지만, author 만으로 search 하는 경우, index 를 생성한 것이 소용이 없어진다. 따라서 SELECT 질의를 어떻게 할 것인가가 인덱스를 어떻게 생성할 것인가에 대해 많은 영향을 끼치게 된다.
Comments powered by Disqus.
프로그램의 하위 모듈에서 상위모듈로 통합하면서 테스트하는 기법.
프로그램의 상위모듈에서 하위모듈로 통합하면서 테스트하는 기법
하위 수준에서는 상향식 통합, 상위 수준에서는 하향식 통합을 사용해 최적의 테스트를 지원함.
샌드위치 식 통합 테스트 방법
https://m.blog.naver.com/wook2124/222108726160
Comments powered by Disqus.
Swiper (ver 4.5.1) 안에 <video> 태그가 slide로 포함되어있음.
현재 가장 가운데 있는 slide 안의 video는 크기를 키우고, slide가 옆으로 이동하면 다시 원래 사이즈로 돌아가도록 함
가운데 video 확대를 위한 코드는 다음과 같이 slide-active 상태일때 스타일을 적용하여 크기를 변경해주는 로직이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
.swiper .swiper-slide video {
+ width: 173px;
+ height: 375px;
+}
+
+.swiper .swiper-slide-active video {
+ width: 238px !important;
+ height: 418px !important;
+}
+
swiper-slide-active 클래스가 적용되면 video 태그의 크기가 정상적으로 커져야했고, 개발자도구로 확인했을떄 문제가 발생했던 기기에서도 제대로 클래스가 적용된 것을 확인할 수 있었다. 하지만 이유는 알수없지만 ios 16.5 safari에서는 video 태그의 크기변화를 잡아내지 못하여 화면에 적용되지 않은 것이다.다음과 같이 swiper 이벤트 중 slideChangeTransitionStart가 발동될 떄 명시적으로 style을 변경하고, 약간의 타이머를 주어 1px 크게 변경하여 브라우저가 크기 변화를 인식할 수 있도록 하였다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+
slideChangeTransitionStart : function() {
+ slides?.forEach(function(item) {
+ if(item.slide.classList.contains("swiper-slide-active")) {
+ if(window.isIOS) {
+ if(window.innerWidth >= 1024) {
+ activeVideo.style.setProperty("width", "236px", "important");
+ activeVideo.style.setProperty("height", "516px", "important");
+ } else {
+ activeVideo.style.setProperty("width", "238px", "important");
+ activeVideo.style.setProperty("height", "418px", "important");
+ }
+
+ setTimeout(() => {
+ if(window.innerWidth >= 1024) {
+ activeVideo.style.setProperty("width", "237px", "important");
+ activeVideo.style.setProperty("height", "517px", "important");
+ } else {
+ activeVideo.style.setProperty("width", "239px", "important");
+ activeVideo.style.setProperty("height", "419px", "important");
+ }
+ }, 30)
+ }
+ } else {
+ if(window.isIOS) {
+ if(window.innerWidth >= 1024) {
+ item.video.style.setProperty("width", "187px", "important");
+ item.video.style.setProperty("height", "405px", "important");
+ } else {
+ item.video.style.setProperty("width", "187px", "important");
+ item.video.style.setProperty("height", "328px", "important");
+ }
+
+ setTimeout(() => {
+ if(window.innerWidth >= 1024) {
+ item.video.style.setProperty("width", "188px", "important");
+ item.video.style.setProperty("height", "406px", "important");
+ } else {
+ item.video.style.setProperty("width", "188px", "important");
+ item.video.style.setProperty("height", "329px", "important");
+ }
+ }, 30)
+ }
+ }
+ })
+},
+
이후 문제없이 동작함을 확인하였다.
Comments powered by Disqus.
128비트 사용.
Multicast 대신에 Broadcast를 함.
ICMPv6
IPv4 에서 IPv6로의 전환 정책
Comments powered by Disqus.
자바에서 프로그램에 이상이 있을 때 던져지는 Throwable은 Error와 Exception이 있다.
그림에서 보이듯이 Unchecked Exception은 RuntimeException을 상속받는다. 하지만 Checked Exception은 상속받지 않는다. 이것이 두 Exception을 구분하는 중요한 포인트이다.
반드시 처리해줘야하는가
스프링 트랜잭션 Rollback 여부
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+
@Service
+@RequiredArgsConstructor
+@Transactional
+public class MemberService {
+ private final MemberRepository memberRepository;
+
+ // (1) RuntimeException 예외 발생
+ public Member createUncheckedException() {
+ final Member member = memberRepository.save(new Member("yun"));
+ if (true) {
+ throw new RuntimeException();
+ }
+ return member;
+ }
+
+ // (2) IOException 예외 발생
+ public Member createCheckedException() throws IOException {
+ final Member member = memberRepository.save(new Member("wan"));
+ if (true) {
+ throw new IOException();
+ }
+ return member;
+ }
+}
+
스프링 트랜잭션 Rollback 관련
checked exception이 날라가도 스프링은 트랜잭션 Rollback을 하지 않는다. 개발자에게 맡기기 때문이다. 실제로 Transaction rollback을 적용할 때 쓰이는 @Transactional 애노테이션의 rollbackFor 옵션의 기본값은 다음과 같다.
1
+
@Transactional(rollbackFor = {RuntimeException.class, Error.class})
+
하지만 현실적으로 개발자가 처리해줄 수 없는 경우도 있다. 이럴 때는 다음과 같은 방법이 있다.
@Transactional(rollbackFor={Exception.class, Error.class})로 변경하여 모든 예외를 대산으로 롤백하기.RollbackRuleAttribute 를 이용해 롤백 규칙 추가하기2,3번째 방법을 사용하면 checked exception에서도 롤백을 진핼할 수 있으나, 스프링 기본 설정을 건드려야한다. 이렇게 기본 설정을 건드는 것은 향후 문제가 될 수 있다. 따라서 웬만하면 unchecked exception으로 바꿔 날리는 것이 좀 더 안전하며, 명확한 exception으로 바꿔 보낸다면 더 좋은 설계가 된다고 생각한다
unchecked exception으로 바꿔 날리기
Checked exception을 throws로 상위 메서드도 throws로 날려야하고, 그 상위 메서드도 throws로 날려야하는 문제가 발생한다. 이는 좋지 않은 패턴이다. 따라서 반드시 예외는 처리 후 더욱 구체적인 unchecked exception으로 날려야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+
// throws 지옥
+public void root() throws IOException {
+ aaa();
+}
+
+public void aaa() throws IOException {
+ bbb();
+}
+
+public void bbb() throws IOException {
+ throw new IOException();
+}
+
+// 처리 후
+public void root() {
+ aaa();
+}
+
+public void aaa() {
+ bbb();
+}
+
+public void bbb() {
+ try {
+ throw new IOException();
+ } catch(IOException e) {
+ throw new JsonDeserializeFailed(e.getMessage());
+ }
+}
+
Comments powered by Disqus.
equals()와 hashCode() 메서드는 모든 자바 객체의 부모인 Object 클래스에 정의되어있다. 따라서 모든 자바 객체는 equals()와 hashCode() 메서드를 가지고 있다.
현재 객체와 파라미터로 들어온 객체가 같은 지 검사하기 위해 사용한다. 기본적으로는 두 객체의 메모리 주소가 같아야 동일한 객체가 된다.
1
+2
+3
+
public boolean equals(Objecet obj) {
+ return (this == obj);
+}
+
이러한 equals 객체를 오버라이드하여 필드값이 같은 객체를 같은 객체라고 판단하게 할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
@AllArgsConstructor
+@Getter
+public class User {
+ private String name;
+
+ @Override
+ public boolean equals(Object obj) {
+ if(obj instanceof User) {
+ return this.getName().equals(obj.getName());
+ } else {
+ return false;
+ }
+ }
+}
+
런타임 중에 객체의 유일한 integer 값을 반환한다. Object 클래스에서는 heap에 저장된 객체의 메모리 주소를 반환하도록 되어있다.
1
+
public native int hashCode();
+
native 키워드
동일한 객체는 동일한 메모리 주소를 갖는다는 것을 의미하므로, 동일한 객체는 동일한 해시태그를 가져야한다. 그렇기 때문에 만약 우리가 equals() 메서드를 오버라이드한다면, hashCode() 메서드도 오버라이드 되어야한다. equals()와 hashCode()는 아래와 같은 관계를 만족해야한다.
https://mangkyu.tistory.com/101
https://kwonnam.pe.kr/wiki/java/equals_hashcode
Comments powered by Disqus.
Mock 객체와는 달리 객체의 특정 메서드만 stub으로 대체할 수 있는 방법을 제공한다.
다음과 같이 만약 테스트 대상 객체의 특정한 메서드를 stub 처리하고 싶을 때 사용한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
@ExtendWith(MockitoExtension.class)
+public class BoardServiceTest{
+ @Spy
+ private BoardService boardService;
+
+ @Test
+ public void 인증_실패시_예외발생() {
+ // boardService의 인증을 담당하는 메서드를 stub 처리함
+ doReturn(false).when(boardService).checkAuthorization(anyLong(), anyString());
+
+ // boardService의 update 메서드는 정상적으로 호출한 후, 예외를 뱉는지 확인
+ assertThrows(ApiException.class, () -> boardService.updateArticle(any()));
+ }
+}
+
Comments powered by Disqus.
lombok은 @Getter, @Setter 같은 애노테이션 기반으로 Getter/Setter 메서드를 자동으로 생성해주는 편리한 라이브러리이다.
하지만 편리함에 남용하는 애노테이션들이 있다.
@AllArgsConstructor
클래스에 존재하는 모든 필드에 대한 생성자를 자동으로 생성한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
@AllArgsConstructor
+public class User {
+ private String name;
+ private String userId;
+
+ // 자동 생성
+ public User(String name, String userId) {
+ this.name = name;
+ this.userId = userId;
+ }
+}
+
이때 생성자의 파라미터 순서는 필드가 선언된 순서와 같다. 여기서 문제가 발생할 수 있다. 만약 위 예시에서 개발자가 name과 userId의 순서를 변경한다면, lombok은 생성자의 파라미터 순서도 바꾼다. 이때 만약 다음과 같은 메서드가 애플리케이션 어딘가에서 사용중이었다면 어떠한 오류도 발견되지 않고 넘어갈 것이다.
1
+
User tempUser = new User("name", "userId");
+
@RequiredArgsConstructor
클래스의 final 필드에 대한 생성자를 생성한다. @AllArgsConstructor와 같은 문제를 가지고 있다.
하지만 빈 주입으로 사용할 경우엔 스프링에서 객체를 생성하므로 크게 신경 안써도 된다.
@EqualsAndHashCode
equals 메서드와 hashcode 메서드를 생성한다. equals 메서드로 두 객체의 필드들이 서로 같은 값을 가지는지 검사하고, hashcode 메서드로 실제로 같은 객체인지 검사한다.
편리하지만, Mutable 객체에 아무런 파라미터 없이 그냥 사용하면 문제가 된다. 객체를 Set에 저장한 뒤 필드 값을 변경하면 hashCode가 변경되면서 이전에 저장한 객체를 찾을 수 없는 문제가 발생하기 때문이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+
@EqualsAndHashCode
+public class User {
+ private String name;
+ private String userId;
+
+ public void setName(String name) {
+ this.name = name;
+ }
+}
+
+User userInfo = new User("Park", "qwer1234");
+
+Set<User> userSet = new HashSet<>();
+userSet.add(userInfo); // Set에 객체 추가
+
+System.out.println("변경전 : " + userSet.contains(userInfo)); // true
+
+userInfo.setName("Shin"); // price 값 변경
+System.out.println("변경후 : " + userSet.contains(userInfo)); // false
+
Set에서는 동일한 객체임을 검사할 때 hashCode() 메서드를 사용하는데, equals()로 같은 객체는 hashCode()로도 같아야하므로 필드 값이 변경될 경우 hachCode도 달라지기 때문이다.
따라서 mutable 객체에서는 다음과 같이 동등성 비교에 필요한 필드를 명시하는 형태로 사용한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
@EqualsAndHashCode(of={"userId"})
+public class User {
+ private String name;
+ private String userId;
+
+ public void setName(String name) {
+ this.name = name;
+ }
+}
+
하지만 막상 개발을 하다보면 immutable 필드를 대상으로만 equals, hashCode를 만들기는 어렵다. 최소한 꼭 필요하고 일반적으로 변하지 않는 필드에 대해서만 만들도록 노력해야한다.
@Value
immutable 클래스를 만들어주는 조합 애노테이션으로, @EqualsAndHashCode, @AllArgsConstructor가 포함된다.
@EqualsAndHashCode는 immutable 클래스이므로 문제가 되지 않지만, @AllArgsConstructor는 위에서 언급한 문제가 있다.
@Data
@Getter, @Setter, @RequiredArgsConstructor, @EqualsAndHashCode, @ToString를 포함하는 조합 애노테이션이다.
위에서 언급한 문제들을 가지고 있다.
https://velog.io/@rosa/Lombok-%EC%A7%80%EC%96%91%ED%95%B4%EC%95%BC-%ED%95%A0-annotation
https://kwonnam.pe.kr/wiki/java/lombok/pitfallhttps://bkjeon1614.tistory.com/657
Comments powered by Disqus.
new Java project를 하면 여러 선택지가 나옴.
Project layout
Module
Create module-info.java file
서로 다른 프로젝트 a,b에 대해 a에서 선언한 클래스를 b에서 불러와 사용할 수 있도록 하는 파일
1
+2
+3
+4
+
// export
+module common.widget {
+ exports com.logicbig; // 외부에 노출하고싶은 패키지
+}
+
1
+2
+3
+4
+5
+
// import
+module data.widget {
+ requires common.widget; // 사용할 패키지
+ requires java.sql;
+}
+
src 아래 HelloWorldApp.java 파일 생성
아래와 같이 작성
1
+2
+3
+4
+5
+
public class HellowWorldApp {
+ public static void main(String[] args) {
+ System.out.println("Hellow World!!");
+ }
+}
+
main 함수는 있어야함.Run 을 눌러 실행
자료형
숫자와 연산
캐스팅
앞에 (자료형) 을 붙여서 함
1
+2
+
int e = (int) 1.1;
+double b = (double) e;
+
정수 -> String
1
+
String f = Integer.toString(1);
+
배열
String[] bear = {"kloud", "Cass", "Guiness"};String[] bear = new String[3];이차원배열
리터럴
1
+2
+3
+4
+5
+
String[][] users = {
+ {"egoing", "1111"},
+ {"jinhuck", "2222"},
+ {"youbin", "3333"}
+}
+
new
1
+
String[][] users = new String[3][2];
+
List 사용반복문
for
1
+2
+3
+4
+5
+
double[] dividendRates = { 0.5, 0.3, 0.2 };
+double[] dividend = new double[3];
+for (int i = 0; i < dividendRates.length; i++) {
+ dividend[i] = income * dividendRates[i];
+}
+
1
+2
+3
+4
+5
+
int[] score = { 78, 70, 65, 98, 58 };
+int sum = 0;
+for (int i : score) {
+ sum += i;
+}
+
while : 다른 언어와 같음.
입력과 출력
입력 다이얼로그
1
+2
+3
+
import javax.swing.JOptionPane;
+...
+String id = JOptionPane.showInputDialog("Enter a Id");
+
Scanner
1
+2
+3
+4
+5
+6
+7
+8
+
import java.util.Scanner;
+...
+Scanner in = new Scanner(System.in);
+int a = in.nextInt(); // int형 입력 및 리턴
+float b = in.nextFloat();
+boolean c = in.nextBoolean();
+String d = in.next(); // String 형 입력 및 리턴 (공백을 기준)
+String e = in.nextLine(); // String 형 입력 및 리턴 (개행을 기준)
+
arguments & parameter
void sum(String a, String...str) 와 같이 작성하여, 여러개 받을 수 있도록 하는거.Run 옆에 화살표 클릭Run configuration 클릭직접 컴파일
컴파일 하고자하는 파일이 있는 곳으로 이동.
javac [파일이름].java 하면 .class 파일 생성
클래스 파일 있는 곳으로 이동
java [파일이름] 하면 실행됨
.class 확장자를 붙이지 않음
또는 .java 파일을 직접 실행시켜도 된다. 이때는 확장자를 붙임
직접 컴파일 : 라이브러리 사용
javac -cp ".;lib" OkJavaGoInHome.java
-cp : --class-path 라는 의미. 구분자를 통해 컴파일할 폴더를 연결 가능.;lib : ; 는 구분자. . (현재폴더)와 lib 를 컴파일 하라는 뜻.실행도 비슷하게 java -cp ".;lib" OkJavaGoInHome 으로 실행.
직접 컴파일 : arguments
java OkJavaGoInHomeInput "JAVA APT 507" 15.0자바용어
패키지, 클래스, 메소드, 변수
인스턴스 : 클래스를 컴퓨터 상에서 실체화 한 것
PrintWriter p1 = new PrintWriter("result1.txt")상속
throws : 메소드 옆에 붙여 어떤 에러를 던질 수 있는지를 표시
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
public static void main(String[] args) {
+ Test test = new Test();
+ try {
+ test.test("1", "r");
+ } catch(NumberFormatException e) {
+ System.out.println("입력하신 값은 숫자가 아닙니다.");
+ }
+}
+
+
+class Text {
+ public void test(String a, String b) throws NumberFormatException {
+ try {
+ int sum = Integer.parseInt(a) + Integer.parseInt(b); // 숫자가 아닐시 NumberFormatException 발생
+ System.out.pringln("합은 " + sum);
+ } catch(NumberFormatException e) {
+ throw e;
+ }
+ }
+}
+
클래스
생성자 : public + 클래스이름으로 선언
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
public class AccountingMethodApp {
+ public double valueOfSupply;
+ public double vatRate;
+ public double expenseRate;
+
+ public AccountingMethodApp(double valueOfSupply, double VatRate, double expenseRate) {
+ this.valueOfSupply = valueOfSupply;
+ this.vatRate = VatRate;
+ this.expenseRate = expenseRate;
+ }
+ ...
+
static : 정적 멤버 선언.(static 변수 : 정적필드, static 메소드 : 정적 메소드)
객체(인스턴스)에 소속된 멤버가 아니라 클래스에 고정된 멤버.
클래스로더가 클래스를 로딩해서 메소드 메모리 영역에 적재할 떄, 클래스별로 관리한다.
정적멤버는 heap이 아닌 static 영역에 할당됨. 프로그램이 종료될 때까지 할당된 상태이므로, static을 남발할 시 프로그램 성능에 악영향을 끼침
인스턴스를 생성하지 않아도 호출 가능하다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+
public class AccountingMethodApp {
+ public static double valueOfSupply;
+ public static double vatRate;
+ public static double expenseRate;
+
+ public static void print() {
+ System.out.println("Value of supply : " + valueOfSupply);
+ System.out.println("VAT : " + getVAT());
+ System.out.println("Total : " + getTotal());
+ System.out.println("Expense : " + getExpense());
+ System.out.println("Income : " + getIncome());
+ }
+ public static double getIncome() {
+ return valueOfSupply - getExpense();
+ }
+ public static double getExpense() {
+ return valueOfSupply * expenseRate;
+ }
+ public static double getTotal() {
+ return valueOfSupply + getVAT();
+ }
+ public static double getVAT() {
+ return valueOfSupply * vatRate;
+ }
+}
+
+
+public class Test {
+ public static void main(String[] args) {
+ AccountingMethodApp.valueOfSupply = 10000.0;
+ AccountingMethodApp.vatRate = 0.5;
+ AccountingMethodApp.expenseRate =0.1;
+
+ AccountingMethodApp.print();
+ }
+}
+
static 메소드에서는 static 메소드와 변수만 참조가능하다.
비교
일반적인 상황에서는 == 등의 비교연산자 사용
String은 equals() 메소드 사용.
== 로 비교시 메모리 주소를 비교. .equals()로 비교해야 내용을 비교한다.
이유
원시데이터 타입일 경우, 변수가 선언되면 stack에 공간이 할당되고, 그 곳에 실제 값이 들어가게 된다. 그래서 == 연산자는 변수가 가리키는 값을 비교한다.
하지만 String과 같이 java.lang.Object 에서 파생된 클래스들은 원시 데이터 타입이 아니다. new로 생성되면 heap에 새로운 공간이 할당되어 값을 저장하고, 변수는 그 값이 저장된 메모리 주소를 가리키게 된다. 따라서 클래스를 ==로 비교하면 메모리 주소를 비교하게 되는 것이다.
하지만 문자열 리터럴로 String을 생성한 경우, 이미 같은 문자열을 생성한 적이 있다면 새로 메모리 공간을 할당하지 않고 새로운 변수는 기존 문자열이 저장된 메모리의 주소를 가리키게 된다. 따라서 == 연산시 true가 나온다. 그래도 내용을 비교하려면 일단 .equals()로 비교하자.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+
// 결과 : False
+String a = new String("1234");
+String b = new String("1234");
+if (a == b) {
+ System.out.println("TRUE");
+} else {
+ System.out.println("False");
+}
+
+
+// 결과 : TRUE (같은 메모리 주소이기에)
+String c = "1234";
+String d = "1234";
+if (c == d) {
+ System.out.println("TRUE");
+} else {
+ System.out.println("False");
+}
+
+// 결과 : False (다른 메모리 주소이기때문)
+if (a == c) {
+ System.out.println("TRUE");
+} else {
+ System.out.println("False");
+}
+
instanceof
객체가 클래스의 인스턴스냐.
a instanceof A
다형성에 따라, 자식 클래스의 객체 instanceof 부모 클래스 하면 true가 나온다. 반대는 false
접근제어자
클래스(형식)
.class 파일로 컴파일된다..class 파일이 나오도록 컴파일 된다는 것생성자와 this
생성자 : 리턴형을 없앤 메소드 형식. 접근제어자는 public이어야함.
1
+2
+3
+4
+5
+6
+
class Print {
+ public String delimiter = "";
+ public Print(String delimiter) {
+ this.delimiter = delimiter;
+ }
+ ...
+
this
OOP
extends
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
class Cal {
+ public int sum(int v1, int v2) {
+ return v1 + v2;
+ }
+}
+class Cal3 extends Cal{
+ public int minus(int v1, int v2) {
+ return v1 - v2;
+ }
+}
+
override
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
class Cal3 extends Cal{
+ @Override
+ public int sum(int v1, int v2) {
+ System.out.println("Cal3!!!");
+ return v1 + v2;
+ }
+
+ // overloading
+ public int sum(int v1, int v2, int v3) {
+ return v1 + v2 + v3;
+ }
+}
+
this super
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
class Cal {
+ public int sum(int v1, int v2) {
+ return v1 + v2;
+ }
+}
+class Cal3 extends Cal{
+ @Override
+ public int sum(int v1, int v2) {
+ System.out.println("Cal3!!!");
+ return super.sum(v1, v2);
+ }
+}
+
super() 를 통해 부모 클래스의 생성자 호출가능
자식 클래스에서 생성자가 없으면 암묵적으로 부모 클래스의 생성자가 호출됨
하지만 아래와 같이 인자를 받는 생성자만 부모클래스에 있다면, 자식 클래스에서도 생성자를 명시적으로 호출하여 부모 클래스의 생성자를 호출해야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+
class Cal {
+ int v1, v2;
+ public Cal(int v1, int v2) {
+ this.v1 = v1;
+ this.v2 = v2;
+ }
+ public int sum() {
+ return this.v1 + this.v2;
+ }
+}
+
+class Cal2 extends Cal {
+ int v3;
+ public Cal2(int v1, int v2, int v3) {
+ super(v1, v2);
+ this.v3 = v3;
+ }
+ @Override
+ public int sum() {
+ return super.sum() + this.v3;
+ }
+}
+
인터페이스
앞으로 만들 클래스의 메소드 규격을 선언할 수 있음
1
+2
+3
+4
+5
+6
+7
+8
+9
+
interface Calculable {
+ int sum(int v1, int v2);
+}
+class RealCal implements Calculable {
+ @Override
+ public int sum(int v1, int v2) {
+ return v1 + v2;
+ }
+}
+
@Override 어노테이션은 들어간다.여러개의 인터페이스를 동시에 적용할 수 있음
1
+2
+3
+4
+5
+6
+7
+
interface Calculable {
+ int sum(int v1, int v2);
+}
+interface Printable {
+ void print();
+}
+class RealCal implements Calculable, Printable {
+
interface 내부에서 변수를 정의할 수 있음. 다만 이때는 반드시 초기화 되어야함. 인터페이스를 적용한 클래스는 변수를 다시 대입할 수 없음
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
interface Calculable {
+ double PI = 3.14;
+ int sum(int v1, int v2);
+}
+class RealCal implements Calculable {
+ public int sum(int v1, int v2) {
+ return v1 + v2;
+ }
+}
+
+public class InterfaceApp {
+ public static void main(String[] args) {
+ RealCal c = new RealCal();
+ System.out.println(c.sum(2, 1));
+ System.out.println(c.PI);
+ }
+}
+
interface도 상속이 가능
1
+2
+3
+4
+5
+6
+7
+
interface Calculable {
+ double PI = 3.14;
+ int sum(int v1, int v2);
+}
+interface Printable extends Calculable {
+ void print();
+}
+
다형성
클래스의 인스턴스를 변수로 선언할 떄, 해당 클래스의 데이터타입으로 선언하지 않고 부모 클래스나 인터페이스를 데이터 타입으로 선언할 수 있다. 이러한 특성을 다형성이라고 부른다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
interface Calculable {
+ double PI = 3.14;
+ int sum(int v1, int v2);
+}
+interface Printable {
+ void print();
+}
+class RealCal implements Calculable, Printable {
+ public int sum(int v1, int v2) {
+ return v1 + v2;
+ }
+
+ public void print() {
+ System.out.println("this is RealCal!!!");
+ }
+}
+
자식 클래스의 객체 instanceof 부모 클래스 하면 true가 나온다.
추상클래스
인터페이스의 일부 메소드를 클래스 내에서 구현시켰을때 사용.
구현하지 않은 메소드의 리턴값 앞과 클래스 앞에 abstract를 붙여야한다
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
interface Calculable {
+ double PI = 3.14;
+
+ int sum(int v1, int v2);
+ int minus(int v1, int v2);
+}
+
+abstract class RealCal implements Calculable {
+ public int sum(int v1, int v2) {
+ return v1 + v2;
+ }
+ public abstract int minus(int v1, int v2); // 메소드는 없어도 되긴함
+}
+
enum
java.lang.Enum 따라서 다른 것을 상속받으면 안됨.final
const 같은 거.예외 처리
try - catch로 가능
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
try {
+ System.out.println(2);
+ System.out.println(scores[3]); //ArrayIndexOutOfBoundsException
+ // 여기까지 실행 -> catch(ArrayIndexOutOfBoundsException e)문으로 이동
+ System.out.println(3);
+ System.out.println(2/0); //ArithmeticException
+ System.out.println(4);
+} catch(ArithmeticException e) {
+ System.out.println("잘못된 계산이네요.");
+} catch(ArrayIndexOutOfBoundsException e) {
+ System.out.println("없는 값을 찾고 계시네요 ^^");
+} catch(Exception e) {
+ System.out.println("알수 없는 에러");
+} finally {
+ System.out.println("무조건 실행")
+}
+
Throwable 클래스를 상속받고 있어, Throwable 클래스의 메소드도 사용가능하다.uncheked Exception vs checked Exception
RuntimeException 클래스로부터 상속된 예외Throwable를 상속받은 클래스 중 RuntimeException을 제외한 모든 에러와 예외들.try-with-resource
Java SE7 부터 추가된 구문
자원을 잡고, 놓아주는 과정을 try-catch-finally로 하면 복잡하기에 이를 간단히 해주는 구문
아래와 같이 try 문에 괄호를 추가하여 그 안에 사용할 자원을 정의한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+
// 전
+try {
+ f = new FileWriter("data.txt");
+ f.write("Hello");
+} catch(IOException e) {
+ e.printStackTrace();
+} finally {
+ if (f != null) {
+ try {
+ f.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+}
+
+// 후
+try (FileWriter f = new FileWriter("data.txt")) {
+ f.write("Hello");
+} catch (IOException e) {
+ e.printStackTrace();
+}
+
throw
예외를 상위로 미루어 처리하는 것.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
public void test(String a, String b) throws NumberFormatException {
+ int sum = Integer.parseInt(a) + Integer.parseInt(b);
+ System.out.println("합 : " + sum);
+}
+
+public void test(String a, String b) throws NumberFormatException {
+ try {
+ int sum = Integer.parseInt(a) + Integer.parseInt(b);
+ System.out.println("합 : " + sum);
+ } catch(NumberFormatException e) {
+ System.out.println("숫자형 문자가 아닙니다.")
+ throw e;
+ }
+}
+
예외처리 전략
다음과 같은 경우 사용함
문법
1
+2
+3
+
부모 클래스 [필드|변수] = new 부모클래스(매개값,...) {
+
+};
+
구현법
예시
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+
class Insect {
+ void attack(){
+ System.out.println("곤충은 공격을 한다");
+ }
+}
+
+public class Anonymous {
+ //★★방법 1 : 필드에 익명자식 객체를 생성
+ Insect spider1 = new Insect(){
+ String name = "무당거미";
+
+ void cobweb(){
+ System.out.println("사각형으로 거미줄을 친다.");
+ }
+ @Override
+ void attack() {
+ System.out.println(name + " 독을 발사한다.");
+ }
+ };
+
+ //★★방법2 : 로컬변수의 초기값으로 대입
+ void method1(){
+ Insect spider2 = new Insect(){
+ String name = "늑대거미";
+
+ //거미줄을 치다.
+ void cobweb(){
+ System.out.println("육각형으로 거미줄을 친다.");
+ }
+ @Override
+ void attack() {
+ System.out.println(name + " 앞니로 문다.");
+ }
+ };
+ //로컬변수이기 때문에 메서드에서 바로 사용
+ spider2.attack();
+
+ // 아래 참고. 접근 불가능
+ spider2.cobweb();
+ }
+
+ //★★방법3 : 익명객체 매개변수로 대입
+ void method2(Insect spider){
+ spider.attack();
+ }
+}
+
참고
패키지
String
+ 연산자를 사용할때보다 속도가 빠르다.제네릭
클래스, 메소드를 다양한 타입에서 사용할 수 있도록 해주는 것
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+
// 클래스에서
+public class GenericDTO<T> implements Serializable {
+ private T object;
+ public void setObject(T obj) {
+ this.object = obj;
+ }
+ public T getObject() {
+ return object;
+ }
+}
+//호출
+GenericDTO<String> dto1 = new GenericDTO<String>();
+GenericDTO<StringBuffer> dto2 = new GenericDTO<StringBuffer>();
+
+
+//메소드에서
+//제네릭 메소드
+public <T> T genericMethod(T c, T addValue) {
+ System.out.println(addValue);
+ System.out.println(c);
+ return c;
+}
+//Bounded Generic 메소드
+public <T extends Car> void genericMethod(WildcardGeneric<T> c, T addValue) {
+ c.setWildcard(addValue);
+ T value = c.getWildcard();
+ System.out.println(value);
+}
+//두 개이상의 제네릭 메소드
+public <S, T extends Car> void genericMethod(WildcardGeneric<T> c, T addValue, S another) {
+ c.setWildcard(addValue);
+ T value = c.getWildcard();
+ System.out.println(value);
+}
+
<?> : 와일드카드
매개변수에서 사용할 때, 어떤 타입이 올지 모르는 경우 사용
1
+
public void wildcardStringMethod(WillcardGeneric<?> c);
+
<? extends Car>
<? super T>
자료형
// 이후로는 키워드만
쓰레드
파일 IO
Serializable 인터페이스
자바 NIO
네트워크
UDP 통신
Java 7
숫자표현방법
switch 문에서 String 사용가능
제네릭을 쉽게 사용할 수 있는 Diamond
1
+
GenericDTO<String> dto1 = new GenericDTO<>();
+
예외 처리시 다중 처리가능
1
+2
+3
+
catch(IllegalArgumentException | FileNotFoundException | NullPointException e){
+ e.printStackTrace();
+}
+
fork/join 관련 클래스
NIO2
JDBC 4.1 : SQL Query를 쉽게 수행할 수 있는 RowSet의 객체를 쉽게 만들어주는 클래스 포함
TransferQueue : 메세지처리에 사용
Objects 클래스 : Object와 같은 static한 메소드 제공. 넘어온 객체가 null이어도 예외가 발생하지 않음
Java8
Lambda 표현식
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+
// 이전
+private void calculateClassic() {
+ Calculate claculateAdd = new Calculate() { //Calculate 는 Functional 인터페이스
+ @Override
+ public int operation(int a, int b) {
+ return a+b;
+ }
+ };
+ System.out.println(calculateAdd.operation(1,2));
+}
+
+// 이후
+private void calculateLambda() {
+ Calculate calculateAdd = (a,b) -> a+b;
+ System.out.println(calculateAdd.operation(1,2));
+}
+
+// 이전
+new Thread(new Runnable() {
+ @Override
+ public void run() {
+ System.out.println("Thread run");
+ }
+}).start();
+
+// 이후
+new Thread(()->System.out.println("Thread run")).start();
+// Thread 생성자로는 Runnable을 넣어줘야하므로 이렇게 해줘도 알아서 Runnable로 들어감.
+
Functional 인터페이스 : java.util.function 패키지에 속함. 추상메서드가 오직 하나인 인터페이스를 뜻하므로 람다식과 호흡이 좋음.
Stream : 연속된 정보를 처리할 때 사용함.
, .forEach(ContainingClass::staticMethodName)`Optional : null이 올 수 있는 값을 감싸기 위해 사용. 값이 null이더라도 NPE이 발생하지않음
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+
// Java8 이전
+List<String> names = getNames();
+List<String> tempNames = names != null
+ ? names
+ : new ArrayList<>();
+
+// Java8 이후
+List<String> nameList = Optional.ofNullable(getNames())
+ .orElseGet(() -> new ArrayList<>());
+
+// Java8 이전
+public String findPostCode() {
+ UserVO userVO = getUser();
+ if (userVO != null) {
+ Address address = user.getAddress();
+ if (address != null) {
+ String postCode = address.getPostCode();
+ if (postCode != null) {
+ return postCode;
+ }
+ }
+ }
+ return "우편번호 없음";
+}
+public String findPostCode() {
+ // 위의 코드를 Optional로 펼쳐놓으면 아래와 같다.
+ Optional<UserVO> userVO = Optional.ofNullable(getUser());
+ Optional<Address> address = userVO.map(UserVO::getAddress);
+ Optional<String> postCode = address.map(Address::getPostCode);
+ String result = postCode.orElse("우편번호 없음");
+
+ // 그리고 위의 코드를 다음과 같이 축약해서 쓸 수 있다.
+ String result = user.map(UserVO::getAddress)
+ .map(Address::getPostCode)
+ .orElse("우편번호 없음");
+}
+
인터페이스의 기본 메소드
1
+2
+3
+4
+5
+
public interface Vehicle {
+ public default void doSomething(int n) {
+ System.out.println("doSomething(Vehicle)");
+ }
+}
+
default 키워드와 함께 인터페이스의 디폴트메소드 선언가능날짜 관련 클래스 추가
병렬배열 정렬
StringJoiner : 순차적으로 나열되는 문자열을 처리할 때 사용함.
https://www.boostcourse.org/cs128
자바의 신
https://mangkyu.tistory.com/70
https://limkydev.tistory.com/226
Comments powered by Disqus.
애노테이션은 Java 5 부터 등장한 기능으로, 사전적의미는 “주석”이지만, 클래스나 메서드 등 타켓에 라벨을 붙여준다. 비즈니스 로직에는 영향을 주지는 않지만, 해당 타켓의 연결 방법이나 소스 코드의 구조를 변경할 수도 있다. 애노테이션은 소스코드에 메타데이터를 삽입하는 것이기 때문에 잘 이용하면 구독성뿐만 아니라 체계적인 소스코드 구성에도 도움을 준다.
1
+2
+3
+
// 애노테이션 예시
+@Service
+public class ArticleService
+
커스텀 애노테이션은 메타 애노테이션을 사용하여 다음과 같은 구조를 가진다.
1
+2
+3
+4
+5
+6
+
@Target({ElementType.[적용대상]})
+@Retention(RetentionPolicy.[정보유지되는 대상])
+public @interface [어노테이션명] {
+ public 타입 elementName() [default 값]
+ ...
+}
+
@Target과 @Retention 등과 같은 메타 애노테이션으로 애노테이션의 성질을 정의한다.
애노테이션이 가질 수 있는 필드 타입은 enum, String, 원시형, 원시형의 배열만 사용할 수 있다.
다음처럼 다른 애노테이션을 추가할 수도 있다.
1
+2
+3
+4
+5
+
@Target({ElementType.[적용대상]})
+@Retention(RetentionPolicy.[정보유지되는 대상])
+@Service
+@RequiredArgsConstructor
+public @interface [어노테이션명]
+
애노테이션을 정의할 땐 마치 인터페이스처럼 다양한 속성을 정의할 수 있다.
1
+2
+3
+4
+5
+6
+
public @interface MyAnnotation {
+ public String name() default "";
+ public int age() default 20;
+ public String value() default "";
+ ...
+}
+
이 중에서 value라는 이름을 가진 속성은 특별한 속성으로, 애노테이션을 사용할 때 아무런 속성이름 없이 하나의 값만 사용하면 자동으로 value 속성에 할당된다.
1
+2
+3
+4
+
// 여러 속성을 부여할 때
+@MyAnnotation(name="Shin", age=20, value="this will be assigned to value")
+// 한가지 값만 넣으면 value에 할당된다.
+@MyAnnotation("this will be assigned to value")
+
어플리케이션 실행시 커스텀 애노테이션을 사용한 곳과 지정한 값들을 얻어오려면 자바 리플랙션을 사용해야한다.
1
+2
+3
+4
+5
+
Method method = MyClass.class.getMethod("doThis"); //자바 리플렉션 getMethod로 메서드 doThis를 얻어온다
+Annotation[] annotations = method.getDeclaredAnnotations(); //메서드에 선언된 어노테이션 객체를 얻어온다
+
+//메서드 doThat에 선언된 MyAnnotation의 어노테이션 객체를 얻어온다
+Annotation annotation = MyClass.class.getMethod("doThat").getAnnotation(MyAnnotation.class);
+
https://www.nextree.co.kr/p5864/
https://jeong-pro.tistory.com/234
https://velog.io/@potato_song/Java-%EC%96%B4%EB%85%B8%ED%85%8C%EC%9D%B4%EC%85%98-%EC%BB%A4%EC%8A%A4%ED%85%80-%EC%96%B4%EB%85%B8%ED%85%8C%EC%9D%B4%EC%85%98-%EB%A7%8C%EB%93%A4%EA%B8%B0
Comments powered by Disqus.
어떤 클래스에 static 변수를 추가했더니 github copilot이 다음과 같은 문장을 추천해주었다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
public class Crypto {
+
+ private static CryptoProperties cryptoProperties;
+
+ // github copilot suggestion
+ static {
+ cryptoProperties = new CryptoProperties();
+ }
+ ...
+
처음보는 문법이기에 조사해보았더니 클래스 초기화 블록이라는 단어를 접할 수 있었다.
클래스의 멤버변수를 초기화 하는 방법으로는 다음과 같은 방법들이 있다.
생성자
필드 초기화
1
+2
+3
+4
+
public class Location {
+ int x = 4;
+ int y = 6;
+}
+
초기화 블록
이 중에서 필드 초기화는 간결하지만 문법상 한줄짜리 구문만 초기화 할 수 있다는 단점이 있다. 이 단점을 보완하기 위해 나온 것이 초기화 블록이다.
초기화 블록은 다음과 같이 사용한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
public class Location {
+ int x;
+ int y;
+ // 초기화 블록
+ {
+ x = 5;
+ x += 10;
+ y = 12;
+ y -= 8;
+ }
+}
+
위와 같이 초기화 블록이 선언되어있으면, 필드 초기화와 같이 인스턴스를 생성할 자동으로 호출된다. 또한 이 초기화 블록은 할당만을 공간이 아니라 다음과 같이 할당문이 아닌 실행문을 사용할 수도 있다.
1
+2
+3
+4
+5
+6
+7
+8
+
public class Location {
+ int x;
+ int y;
+ // 초기화 블록
+ {
+ System.out.println("초기화 블록 호출")
+ }
+}
+
초기화 블록은 static 멤버변수를 초기화할 때도 사용할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
public class Location {
+ static int x;
+ static int y;
+ // 초기화 블록
+ static {
+ x = 5;
+ y = 10;
+ }
+}
+
위와 같이 일반 초기화 블록 앞에 static 키워드를 붙이면 된다.
Comments powered by Disqus.
자바스크립트 엔진은 더이상 사용하지 않을 메모리를 놓아주기 위해 garbage collector를 사용한다. garbage collector(GC)는 앱에서 더이상 사용하지 않을 객체를 찾아내고 삭제한다. 따라서 GC는 앱의 object와 변수를 계속 모니터링하고 어떤 것이 여전히 referenced 되고 있는지 트랙킹한다. 그러다 Object가 더이상 쓰이지 않으면 마킹하고 삭제하여 메모리를 놓아준다.
GC가 사용하는 이 기법은 mark and sweep이다.
이 작업은 주기적으로 수행되며, heap 의 사이즈가 작더라도 수행된다.
자바스크립트의 메모리를 얘기하면 stack과 heap이 주역이다.
stack은 함수 실행 동안 필요한 데이터를 저장한다. 빠르고 효율적이지만 공간은 한정적이다. 함수가 실행되면 자바스크립트 엔진이 그 함수의 변수와 파라미터를 스택에 push하고, 함수가 return 되면 pop 한다. 이렇게 stack은 빠르고 효율적으로 메모리를 관리한다.
반면에 heap은 앱의 생명주기 동안 데이터를 저장하는데 사용한다. stack에 비해 다소 느리고 덜 정리되어있지만 공간은 크다. Heap은 object, array 등 복잡한 데이터 구조를 여러번 접근하기 위해 사용된다.
가장 흔한 케이스 중 하나다. 2개 이상의 object가 서로를 참조하고 있을 때 발생한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
let object1 = {};
+let object2 = {};
+
+// create a circular reference between object1 and object2
+object1.next = object2;
+object2.prev = object1;
+
+// do something with object1 and object2
+// ...
+
+// set object1 and object2 to null to break the circular reference
+object1 = null;
+object2 = null;
+
위 예제에서는 마지막에 object1과 object2를 null로 설정하여 순환 참조를 깨려고 했지만, {next: refenceToObject2}, { prev: refenceToObject1}는 각각 메모리에 남아서 서로를 참조하고 있다. 즉 null로 할당하는 것은 object1, object2에 할당된 reference를 지운것 뿐이고, 순환참조된 obejct들 자체는 메모리에 계속 남아있다. 따라서 GC는 순환 참조를 꺨 수 없다. (하지만 최신 자바스크립트 엔진에서는 GC가 발전하여 메모리 회수를 한다.)
이러한 경우에는 delete 키워드를 사용한 manual memory management가 필요하다. delete를 사용하여 순환참조를 만들어내는 property를 삭제하는 것이다.
1
+2
+
delete object1.next;
+delete object2.prev;
+
또다른 방법은 WeakMap, WeakSet을 사용하는 방법이다. 이 두개는 object와 variable에 대한 약한 참조를 만들 수 있게 한다.
엘리먼트에 Event Listener를 붙이면, listener function의 reference가 생긴다. 그리고 이 reference는 GC가 메모리를 풀어주는걸 막는다. 이는 앨리먼트가 더이상 필요없어져도 listener function이 제거되지 않으므로 memory leak의 원인이 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
let button = document.getElementById("my-button");
+
+// attach an event listener to the button
+button.addEventListener("click", function() {
+ console.log("Button was clicked!");
+});
+
+// do something with the button
+// ...
+
+// remove the button from the DOM
+button.parentNode.removeChild(button);
+
이를 해결하기 위해선 필요없어진 event listener는 삭제해야한다.
1
+2
+3
+4
+5
+6
+
button.removeEventListener("click", function() {
+ console.log("Button was clicked!");
+});
+
+// 전부 삭제
+button.removeAllListeners();
+
전역 변수를 생성하면, 그 변수는 모든 코드에서 접근이 가능하다. 따라서 더 이상 필요한지 아닌지 판단하기가 어렵다. 이는 memory leak로 이어진다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
// create a global variable
+let myData = {
+ largeArray: new Array(1000000).fill("some data"),
+ id: 1
+};
+
+// do something with myData
+// ...
+
+// set myData to null to break the reference
+myData = null;
+
위 코드의 마지막에 myData에 null을 할당하였지만, 전역 변수이기에 모든 코드에서 접근 가능하다. 따라서 더이상 필요한지 아닌지 판단하기 어렵고, 이는 memory leak로 이어진다.
이를 해결하기 위해선 Function Scoping을 사용해야한다. 함수를 생성하고 그 안에서 지역변수로 변수를 생성하는 방법이다. 그러면 그 변수는 오직 그 함수에서만 접근 가능하고, 더이상 필요한지 아닌지 판단하기 쉽다. 즉 필요없어지면 GC에 의해 청소된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
function myFunction() {
+ let myData = {
+ largeArray: new Array(1000000).fill("some data"),
+ id: 1
+ };
+
+ // do something with myData
+ // ...
+}
+myFunction();
+
다른 방법은 var 대신에 let, const를 사용하는 방법이다. let, const는 block-scoped이므로 선언된 block 외에선 사용이 불가능하니 GC에 의해 제거될수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
{
+ let myData = {
+ largeArray: new Array(1000000).fill("some data"),
+ id: 1
+ };
+
+ // do something with myData
+ // ...
+}
+
WeakMap, WeakSet 을 사용하여 object와 variable에 대한 weak reference를 만들 수 있다. Weak reference는 일반적인 reference와는 달리 GC가 object에 의해 사용되는 메모리를 free up 하는 걸 막지 않는다. 이러한 특성은 WeakMap과 WeakSet을 Circular reference를 해결하는데 사용할 수 있도록 한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
let object1 = {};
+let object2 = {};
+
+// create a WeakMap
+let weakMap = new WeakMap();
+
+// create a circular reference by adding object1 to the WeakMap
+// and then adding the WeakMap to object1
+weakMap.set(object1, "some data");
+object1.weakMap = weakMap;
+
+// create a WeakSet and add object2 to it
+let weakSet = new WeakSet();
+weakSet.add(object2);
+
+// in this case, the garbage collector will be able to free up the memory
+// used by object1 and object2, since the references to them are weak
+
위에서 순환참조 때 봤던 예시와 비슷하게 서로 참조하고 있더라도, 이번엔 WeakMap을 사용하여 순환참조가 일어나도 메모리 free up을 막지 않는다.
WeakMap은 약한 참조이므로, key object가 WekMap에 존재하더라도 GC에 의해 메모리를 회수할 수 있도록 해준다. 다른 말로, WeakMap은 key object가 다른 코드에서 접근이 불가능해지면, GC가 key object가 차지하고 있던 메모리를 회수하는 걸 막지않는다. 다음 예제에서 objA, objB는 함수 호출이 끝나면 scope에서 벗어나므로, GC가 메모리를 회수할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
function createCircularReference() {
+ let objA = {};
+ let objB = {};
+
+ let weakMap = new WeakMap();
+ weakMap.set(objA, objB);
+ weakMap.set(objB, objA);
+}
+
+createCircularReference();
+
WeakSet도 비슷하게 WeakSet이 가지고 있는 object를 GC가 회수할 수 있다. WeakSet은 objects의 집합을 GC의 메모리 회수를 막는 거 없이 저장할 수 있는 방법이다. 하지만 WeakSet은 순환 참조에 직접 사용할 수 있는 것은 아니다. key-value를 저장하지 않기 때문이다. 오직 object를 저장만하고 그들 사이에 관계를 만들진 않는다.
GC API를 사용하는 방법도 있다. GC를 수동적으로 동작하게 하고, 현재 heap의 상태를 알 수 있다. 따라서 memory leak나 성능 이슈를 디버깅하는데도 도움을 준다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
let object1 = {};
+let object2 = {};
+
+// create a circular reference between object1 and object2
+object1.next = object2;
+object2.prev = object1;
+
+// manually trigger garbage collection
+gc();
+
gc()를 실행하여 GC를 수동적으로 실행하면 설령 아직 참조되고 있더라도 object에 의해 사용되고 있던 메모리를 비운다.
gc()는 모든 자바스크립트 엔진에서 지원되지는 않는다. 그리고 엔진에 따라 동작이 다르다. 또한 성능에 영향을 줄 수 있기에 신중하게 필요할 떄만 사용해야한다.
heap snapshots and profilersJavascripts는 heap snapshot과 profilers를 제공하여 어플리케이션이 어떻게 메모리를 사용하고 있는지 알려준다.
Heap Snapshot은 현재 heap 상태의 스냅샷을 찍어주고, 그것을 분석하여 어떤 object가 가장 많은 메모리를 사용하고 있는지 알 수 있게 해준다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+
// Start a heap snapshot
+let snapshot1 = performance.heapSnapshot();
+
+// Do some actions that might cause memory leaks
+for (let i = 0; i < 100000; i++) {
+ myArray.push({
+ largeData: new Array(1000000).fill("some data"),
+ id: i
+ });
+}
+
+// Take another heap snapshot
+let snapshot2 = performance.heapSnapshot();
+
+// Compare the two snapshots to see which objects were created
+let diff = snapshot2.compare(snapshot1);
+
+// Analyze the diff to see which objects are using the most memory
+diff.forEach(function(item) {
+ if (item.size > 1000000) {
+ console.log(item.name);
+ }
+});
+
위 예시에서는 루프 실행 전후로 스냅샷을 찍고, 두 스냅샷을 비교하여 어떤 object가 메모리를 많이 차지하는지 알 수 있게 해준다.
Profiler는 어플리케이션의 성능을 트랙킹하고, 메모리 사용이 많은 area를 인식한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+
let profiler = new Profiler();
+
+profiler.start();
+
+// do some actions that might cause memory leaks
+for (let i = 0; i < 100000; i++) {
+ myArray.push({
+ largeData: new Array(1000000).fill("some data"),
+ id: i
+ });
+}
+
+profiler.stop();
+
+let report = profiler.report();
+
+// analyze the report to identify areas where memory usage is high
+for (let func of report) {
+ if (func.memory > 1000000) {
+ console.log(func.name);
+ }
+}
+
heap snapshot과 profilers은 모든 엔진과 브라우저에서 지원되는 것은 아니다.
https://itnext.io/javascript-memory-management-how-to-avoid-common-memory-leaks-and-improve-performance-c018dbbca954#9f04
Comments powered by Disqus.
Map.prototype.set(key, value)
Map.prototype.get(key)
Map.prototype.delete(key)
Map.prototype.has(key)
Map.prototype.forEach((value, key, map) => {})
Number.MAX_VALUE
Number.parseInt(string)
Object.entries(object)
[키, value] 형태로 배열을 반환
1
+2
+3
+4
+5
+6
+7
+8
+
const object1 = {
+ a: 'somestring',
+ b: 42
+};
+
+for (const [key, value] of Object.entries(object1)) {
+ console.log(`${key}: ${value}`);
+}
+
lower_bound
upper_bound
Comments powered by Disqus.
https://drive.google.com/file/d/10euUsveJwcJRgnblyzvXjSq3CRyzONDm/view?usp=sharing
———–이하 서비스 소개
Comments powered by Disqus.
AWS game tech 트랙 우승!
해커톤 첫 참여였지만 좋은 팀원들과 함께해서 트랙 우승을 이루어내 기뻤다.
front-end 참여하여 메인 기능과는 보다는 디자이너님이 만들어주신 뷰 구현에 힘을 쏟았다.
배운 것도 많았고, 더 공부할 것도 많이 보였다.
배운 것
첫 해커톤이라 참여하기 전엔 긴장도 많이 됐고, 부담도 느꼈지만 좋은 결과를 얻은 덕분인지 해커톤의 즐거움을 알게 되었다.
다음에는 backend로 참여하여 좋은 성과를 얻고 싶다.
Comments powered by Disqus.
Junction 해커톤을 하며 lottie 애니메이션을 접하게 되었다.
간단히 코드로 불러올 수 있으며, json 파일로 불러올 경우 색상 변경 등의 커스터마이징도 가능하여 활용도가 높다.
npm install @lottiefiles/react-lottie-player
다음 코드 삽입
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
<Player
+ src={fireVideo}
+ background="transparent"
+ speed="1"
+ style=
+ renderer="svg"
+ loop
+ controls
+ autoplay
+></Player>
+
이때 src 에는 로컬에 있는 json 파일 또는 링크가 들얼 수 있다.
https://lottiefiles.com/tools/json-editor 에 접속하여 원하는 로티 애니메이션의 json 파일을 붙여넣는다.
Toggle source/editor 를 클릭한다.
0~2번째 원소는 각각 RGB 값을 담당한다. 계산방법은 다음과 같다
#123456 코드가 있으면, 이것을 앞에서부터 2개씩 끊고 다음과 같이 계산
12 -> 1 * 16 + 2 -> 18 / 255 = 0.07058823529
34 -> 3 * 16 + 4 -> 52 / 255 = 0.20392156862
56 -> 5 * 16 + 6 -> 86 / 255 = 0.33725490196
Comments powered by Disqus.
GET
HTTP Request Message의 헤더부분의 url에 담겨서 전송됨. url의 끝에 ? 뒤에 데이터를 붙여 요청.POST
HTTP Requst Message의 바디부분에 담김어디에 무엇을 적용할까?
SYN 패킷, ACK 패킷
SYN : Synchronize sequence number
ACK : acknowledgement
TCP 헤더에는 Code bit(flag bit)가 존재함. 이부분을 총 6비트로 이루어져있고, 각 bit는 Urg-ACK-PSH-RST-SYN-FIN 순서로 의미를 가지고 있다. 해당 위치의 비트로 패킷의 의미를 나타내는 것이다.
연결 성립
연결 해제
3way인 이유
TCP 연결은 양방향성이므로, 서로의 연결이 제대로 됐는지 확인해야한다.
따라서 1. 클라이언트가 서버로 요청함. 2. 서버가 확인하고 클라이언트로 요청함. 3. 클라이언트가 확인함.
이렇게 3 과정이 필요하다.
why randomized Sequence number
처음 클라이언트에서 SYN 패킷을 보낼때 Sequence number에는 랜덤한 숫자가 담겨짐. 초기 sequence number를 ISN이라고 함.
이때 랜덤하게 초기 ISN을 설정하는 이유는 클라이언트와 서버가 연결을 맺을때 사용하는 포트는 유한 범위 내에서 사용하고 시간이 지남에 따라 재사용되기때문이다. 따라서 두 통신 호스트가 과거에 사용된 포트번호 쌍을 사용하는 가능성이 존재한다. 서버측은 패킷의 SYN을 보고 패킷을 구분하게 되는데 난수가 아닌 순차적은 number가 전송된다면 이전의 connection으로부터 오는 패킷으로 인식할 수 있다. 이러한 문제가 발생할 가능성을 줄이기 위해 난수로 ISN을 설정하는 것이다.
UDP(User Datagram Protocol)
흐름제어, 오류제어, 손상된 세그먼트 재전송을 하지 않음. 포트를 사용하여 IP 프로토콜에 인터페이스를 제공하는 작업만 함. 클라이언트는 요청/응답이 손실되면 timeout되고 다시 시도하면 된다.
TCP(Transmission Control Protocol)
TCP/IP 구조의 통신은 통신경로 상에서 엿볼 수 있다. 중간에 패킷을 수집하면 된다. 이때 HTTP는 평문통신이기에 패킷이 유출되면 메시지의 의미를 파악할 수 있고, 이때 도청이 이루어진다.
보완
SSL(Secure Socket Layer)나 TLS(Transport Layer Security)라는 다른 프로토콜을 조합함으로써 HTTP 통신 자체를 암호화할 수 있다. 여기서 특히 SSL을 조합한 HTTP를 HTTPS 라고 부른다.HTTP에 의한 통신에는 상대가 누구인지 확인하는 처리가 없기때문에, 누구든지 요청을 보낼 수 있다. 따라서 IP주소나 포트번호의 제한이 없는한 요청이 오면 서버는 무엇이든 응답을 반환한다. 여기서 문제가 발생한다.
보완
SSL로 해결할 수 있다. SSL은 상대를 확인하는 수단으로 증명서를 제공하고 있다. 증명서는 신뢰가능한 제 3자가 발행하는 것이기에 서버나 클라이언트가 실재하는 사실을 증명한다. 이 증명서를 이용함으로써 통신 상대가 내가 통신하고자하는 서버임을 나타내고, 이용자는 개인정보 누설의 위험성이 줄어든다. 또 클라이언트는 이 증명서로 본인확인을 하고, 웹사이트 인증에서도 이용할 수 있다.
송신측에서 보낸 내용과 수신측에서 받은 내용이 일치하다는 것을 보장할 수 없다. 따라서 누가 중간에서 변조하더라도 이사실을 알 수 없다. 이와 같이 중간에서 요청/응답을 빼앗아 변조하는 것을 중간자 공격이라고 한다.
보완
MD5, SHA-1 등의 해시 값을 확인하는 방법과 디지털 서명을 확인하는 방법이 존재하지만 확실하지는 않음
SSL 에는 인증이나 암호화, 다이제스트 기능이 제공되기에, 확실히 방지된다.
HTTP에 SSL을 더한 것으로, HTTP 통신하는 소켓부분을 SSL이나 TLS라는 프로토콜로 대체하는 것뿐이다. HTTP는 원래 TCP와 직접 통신했지만, HTTPS 에는 SSL이 TCP와 통신하게 된다.
HTTPS는 SSL을 사용하여 암호화와 증명서, 안전성 보호를 이용할 수 있게 된다.
SSL에서는 공통키 암호화 방식과 공개키 암호화 방식을 혼합한 암호 시스템을 사용한다. 공통키를 공개키 암호화 방식으로 교환한 다음에 다음부터는 공통키 암호를 사용하는 방식이다.
모든 웹 사이트에서 HTTPS를 사용해야할까?
HTTPS 통신은 암호화 통신이기에 HTTP보다 많은 리소스를 요구한다. 하지만 최근 하드웨어의 발달로 속도저하가 거의 일어나지 않으며, HTTP 2.0을 사용한다면 오히려 HTTPS가 HTTP보다 빠르게 동작한다.
따라서 최근에는 모든 웹페이지에서 HTTPS를 적용하는 방향으로 바뀌어가고 있다.
서버의 수만큼 공인 IP 주소가 필요함
균등하게 분산되지 않음
서버가 다운되도 확인불가
따라서 DNS Round Robin은 부하분산을 위한 방법이지 다중화 방법은 아니므로 다른 방법과 조합해서 관리할 필요가 있다.
Round Robin 방식을 기반으로 단점을 해소하는 DNS 스케쥴링 알고리즘들
사용자가 브라우저에서 특정 URL를 입력했을때 일어나는 일들.
프로토콜 스택은 통신 중 오류가 발생했을때, 이 제어정보를 사용하여 고쳐보내거나, 각종 상황을 조절하는 등 다양한 역할을 하게 된다.
https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/Network
https://asfirstalways.tistory.com/356
https://judo0179.tistory.com/127
Comments powered by Disqus.
next.js app router의 caching에 관해 공부한 내용입니다.
next.js 에서 제공하는 caching mechanism에는 다음과 같은 것들이 있다.
| Mechanism | What | Where | Purpose | Duration |
|---|---|---|---|---|
| Request Memoization | Return values of functions | Server | Re-use data in a React Component tree | Per-request lifecycle |
| Data Cache | Data | Server | Store data across user requests and deployments | Persistent (can be revalidated) |
| Full Route Cache | HTML and RSC payload | Server | Reduce rendering cost and improve performance | Persistent (can be revalidated) |
| Router Cache | RSC Payload | Client | Reduce server requests on navigation | User session or time-based |
next.js는 가능한 많은 캐싱을 적용하려고 하고, 따라서 따로 opt-out하지 않는한 정적으로 렌더링되고, 요청은 캐싱된다. 각 mechanism은 다음 도식처럼 동작한다.
React에서 확장한 fetch API가 자동으로 같은 URL과 옵션으로 보내진 요청의 결과를 기억한다. 따라서 한 route를 렌더링할때 같은 요청이 여러번 발생하면, 딱 한번만 요청을 보내고 그 결과를 여러 곳에서 사용한다.
fetch API에 AbortController signal을 줄 수 있음. 예시fetch 함수의 GET method에서만 동작함fetch를 쓸 수 없는 환경에서는 React cache function을 사용할 수 있음.여러 server requests와 deployments 사이에서 공유되는 캐시로, next.js에서 확장한 fetch API를 사용하면 적용된다. fetch API의 cache, next.revalidate 옵션으로 설정할 수 있으며 자세한 내용은 fetch API references에서 볼 수 있다.
{ next: { revalidate: 60 } } 일 때,PURGE 시킴fetch API 옵션 : { cache: 'no-store' }와 같이 fetch API 옵션으로 Data Cache를 사용하지 않을 수 있음.export const dynamic = 'force-dynamic'export const revalidate = 0{ cache : 'no-store'}와 같이 캐시를 사용하지 않도록 설정해도 Request Memoization은 일어난다. (리액트 동작이기에)next.js는 빌드는 각 route를 렌더링하고 결과를 캐싱한다. 따라서 매 요청마다 렌더링하지 않고 캐시된 route를 응답하여 페이지 로딩을 빠르게 마칠 수 있게한다.
route가 빌드타임에 캐시 되는지 안되는지는 그 route가 정적인지 동적으로 렌더링되는지에 달려있다. Static route는 기본적으로 캐시되며, dynamic route는 요청시 렌더링되고 캐시되지 않는다.
dynamic = 'force-dynamic', revalidate=0 route segment config 옵션 사용fetch API를 캐시하지 않으면 Full Route Cache도 opt-out 된다. 매번 새로운 요청을 보내기 때문이다.next.js가 클라이언트 사이드에서 가지고 있는 in-memory 캐시이다. React Server Component Payload를 저장하며 각 route segments 별로 분리되어있다. 유저가 routes 사이를 이동할 떄마다 prefetch되거나 방문한 route segment를 저장한다. browser의 bfcache와는 다른 것이지만 비슷한 결과를 낸다.
revalidatePath, revalidateTagcookies.set, cookies.delete 사용 (쿠키를 사용하는 route가 stale 되는 것들 방지하기 위해)router.refresh를 사용하면 Router Cache가 전부 clear 됨<Link> 컴포넌트에서 props로 opt-out할 수 있지만 방문한 페이지에 대한 캐시는 여전히 남는다.Route Handler에서 Data Cache를 revalidating하여도 Router Cache가 바로 invalidate 되지 않는다. Router Handler는 특정 route와 묶여있지 않기 때문이다. Router Cache는 유저가 새로고침하거나 Automatic Invalidation Period가 지날때까지 유지된다.revalidatePath, revalidateTag를 사용할 수 있다.각 next.js API가 영향을 끼치는 캐시정리
| API | Router Cache | Full Route Cache | Data Cache | React Cache |
|---|---|---|---|---|
<Link prefetch> | Cache | |||
router.prefetch | Cache | |||
router.refresh | Revalidate | |||
fetch | Cache | Cache | ||
fetch options.cache | Cache or Opt out | |||
fetch options.next.revalidate | Revalidate | Revalidate | ||
fetch options.next.tags | Cache | Cache | ||
revalidateTag | Revalidate | Revalidate | ||
revalidatePath | Revalidate | Revalidate | ||
const revalidate | Revalidate or Opt out | Revalidate or Opt out | ||
const dynamic | Cache or Opt out | Cache or Opt out | ||
cookies | Revalidate | Opt out | ||
headers, useSearchParams, searchParams | Opt out | |||
generateStaticParams | Cache | |||
React.cache | Cache | |||
unstable_cache (Coming Soon) |
현재 공식문서에 따르면 다음 두 설정은 Data Cache과 Full Route Cache를 opt-out 한다고 한다.
const dynamic = 'force-dynamic'const revalidate = 0하지만 다음과 같은 이슈를 찾을 수 있었다.
revalidate = 0을 주어도 캐시가 적용된다는 이슈이다. 해결방법으로는 다음 두가지가 제시되었지만, 공식적인 답변은 없었다.
router.refresh()<Link> 대신 <a> 사용next.js 공식문서에 따르면, revalidate 속성은 한 route에서 가장 낮은 값으로 설정된다고 한다. 그리고 위 설명에서 revalidate = 0은 data cache를 opt-out 한다고 하였으니 route segment config로 revalidate =0을 설정하면, fetch API에서 revalidate : 60을 설정해도 data cache가 무시될 줄 알았다.
하지만 실제로 다음과 같은 코드로 적용해본 결과 data cache가 opt-out 되지 않았다. 캐시가 계속 이루어지고 있었다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
// app/layout.js
+export const dynamic = "force-dynamic"
+
+export default function Layout({ children }) {
+ return (
+ <div>
+ {children}
+ </div>
+ )
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+
// app/post/page.js
+export default function Page() {
+ const posts = await fetch("http://localhost:8080/api/post", { next : {revalidate:60} });
+ return (
+ <div>
+ {posts.map(p => <div>{p.content}</div>)}
+ </div>
+ )
+}
+
1
+2
+3
+
GET /post 200 in 281ms
+ │
+ ├──── GET http://localhost:8080/api/post 200 in 7ms (cache: HIT)
+
이것이 next.js의 의도된 동작인지, 이슈인지는 좀 더 살펴봐야할 것 같다.
Comments powered by Disqus.
next.js 13.4 이상 App router 기준으로 작성하였습니다.
next.js에서 주로 발생하는 props drilling 형태는 다음과 같습니다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
// Server Component A
+import ServerComponentB from "./ServerComponentB"
+
+export default async function ServerComponentA() {
+ const initialCount = await fetch(...);
+
+ return <>
+ <h3>I got {initialCount}</h3>
+ <ServerComponentB initialCount={initialCount} />
+ </>
+}
+
ServerComponentB에서는 initialCount가 필요없지만, 하위 컴포넌트에서 필요하기에 받고, 넘겨줍니다.1
+2
+3
+4
+5
+6
+
// Server Component B
+import ServerComponentC from "./ServerComponentC"
+
+export default function ServerComponentB({ initialCount }) {
+ return <ServerComponentC initialCount={initialCount}/>
+}
+
ServerComponentC에서는 initialCount가 필요합니다. 필요한 작업을 수행 후 하위 컴포넌트를 불러옵니다. 그리고 그 하위 컴포넌트에도 initialCount가 필요하기에 props로 받은 데이터를 넘겨줍니다.1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
// Server Component C
+import ClientComponent from "./ClientComponent"
+
+export default function ServerComponentC({ initialCount }) {
+ return (
+ <div>
+ <h3>initial count is : {initialCount}</h3>
+ <ClientComponent initialCount={initialCount}/>
+ </div>
+ )
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
// Client Component
+'use client'
+
+import {useState} from "react"
+
+export default function ClientComponent({initialCount}) {
+ const [count, setCount] = useState(initialCount);
+
+ return (
+ <>
+ {count}
+ <button onClick={() => setCount(prev => prev + 1)}>+1</button>
+ <button onClick={() => setCount(prev => prev - 1)}>-1</button>
+ </>
+ )
+}
+
이처럼 상위 컴포넌트에 있는 데이터를 하위 컴포넌트에서도 가져야하고 이것을 props로 넘겨줄때, props drilling이 발생합니다. 중간에 ServerComponentB에서는 initialCount가 필요없었지만 하위 컴포넌트에서 필요하기에 받고 넘겨줘야했습니다.
만약 일반적인 React 앱처럼 클라이언트 컴포넌트로만 구성되어있다면 글로벌 상태관리 라이브러리(redux, recoil..)나, Context API를 사용할 수 있습니다. 하지만 서버컴포넌트에서는 상태를 사용할 수 없기에 위와 같은 방법은 사용하기 어렵습니다.
여기서는 서버컴포넌트가 있는 구조에서 props drilling 문제 없이 데이터를 공유할 수 있는 방법을 작성하였습니다.
next.js에서 기본으로 제공해주는 기능인 Automatic fetch() Requst Deduping을 사용할 수 있습니다. next.js 공식문서에서의 설명에 따르면, 서버에서 fetch로 GET한 데이터는 rendering pass 동안 캐시된다고 합니다. 그리고 이 캐시는 server request 생명주기동안 유지되며 렌더링 과정이 끝날때까지 지속된다고 합니다.
따라서 서버컴포넌트끼리는 별도의 data sharing 기법이 필요하지 않고, 매번 필요한 데이터를 불러오면 됩니다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
// Server Component A
+import ServerComponentB from "./ServerComponentB"
+
+export default async function ServerComponentA() {
+ const initialCount = await fetch(...);
+
+ return <>
+ <h3>I got {initialCount}</h3>
+ <ServerComponentB/>
+ </>
+}
+
1
+2
+3
+4
+5
+6
+
// Server Component B
+import ServerComponentC from "./ServerComponentC"
+
+export default function ServerComponentB() {
+ return <ServerComponentC/>
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
// Server Component C
+import ClientComponent from "./ClientComponent"
+
+export default function ServerComponentC() {
+ const initialCount = await fetch(...);
+ return (
+ <div>
+ <h3>initial count is : {initialCount}</h3>
+ <ClientComponent initialCount={initialCount}/>
+ </div>
+ )
+}
+
이제 ServerComponentB에서는 initialCount를 받을 필요도, 넘겨줄 필요도 없습니다. fetch() 동안 결과가 캐시되어있기 때문에 두번이상 API 요청을 보내지 않습니다.
저는 개발을 하면서 서버컴포넌트에서 API 요청을 보낼때 주로 searchParams에 들어온 값을 기준으로 API를 호출했습니다.
1
+2
+3
+4
+5
+6
+
// ex : 클라이언트 요청 주소 -> /notice?categoryId=4&searchValue=test
+// categoryId=4, searchValue=test 로 데이터를 받아옴
+export default async function NoticePage({ searchParams : {categoryId, searchValue } }) {
+ const notices = await getNotices({ categoryId, searchValue })
+ ...
+}
+
하지만 next.js app router에서 page.js가 아닌 서버컴포넌트에서 searchParams를 얻어올 수 있는 공식적으로 제공하는 방법은 없습니다. 따라서 위에서 설명한, 데이터가 필요한 서버컴포넌트에서 api를 요청하는 건 어렵습니다. API 요청에 필요한 searchParams를 얻을 수 없기 때문입니다.
1
+2
+3
+4
+5
+
// page.js가 아닌 어딘가의 서버컴포넌트
+export default function NoticeList() {
+ // error! categoryId, searvhValue를 알아낼 수 없음
+ const notices = await getNotices({ categoryId, searchValue })
+}
+
따라서 Server Component -> Server Component data sharing을 좀 더 잘 활용하려면, 하나의 Request가 살아있는 동안 여러 서버컴포넌트에서 그 Request의 searchParams에 접근가능해야합니다.
공식적인 방법은 아니나 몇가지 생각해본/찾아본 방법은 다음과 같습니다.
웹서버 활용
next.js에서는 서버컴포넌트에 headers()라는 함수를 제공합니다. 요청이 온 Request의 header을 제공해주는 함수입니다. 이 함수는 꼭 page.js만이 아닌 곳에서도 사용가능하기에, header에 searchParams가 들어있다면 page.js가 아닌 서버컴포넌트에서도 searchParams에 접근 가능합니다.
1
+2
+3
+4
+5
+6
+7
+
# nginx 예시
+server {
+ location / {
+ proxy_set_header X-Search-Params $args;
+ proxy_pass http://localhost:3000;
+ }
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+
import { headers } from 'next/headers'
+
+export default function NoticeList() {
+ const header = headers()
+ const { categoryId, searchValue } = parseSearchParams(header.get("X-Search-Params"))
+
+ const notices = await getNotices({ categoryId, searchValue })
+}
+
searchParams 정도는 props로 내려보내기
page.js에서 searchParams가 필요한 서버컴포넌트까지 내려줘야하지만, searchParams 객체 하나만 내려주면 되기에 props drilling을 하나의 객체만 내려보내는 수준으로 유지할 수 있습니다.
1
+2
+3
+
export default function NoticeList({searchParams : {categoryId, searchValue }}) {
+ const notices = await getNotices({ categoryId, searchValue })
+}
+
관련해서 next.js 깃허브 discussions에서 논의된 얘기가 있는데, searchParams에 대한 validation/parsing/error handling 없이 하위 컴포넌트로 searchParams를 넘겨줄 가능성은 적다는 댓글이 있었습니다. 가능성이 적은지는 모르겠으나, 확실히 파싱, 유효성 검증이 필요한 searchParams의 경우 page.js에서 먼저 받아 처리를 한 후, 하위 컴포넌트로 props로 넘겨주는게 더 좋은 방법으로 보입니다.
서버단에서 data sharing 툴 사용
꼭 searchParams에 국한되지 않더라도, 서버컴포넌트들 사이에서 데이터 or context를 공유하면 좋은 경우가 많습니다. (i18n, theme 등). next.js discussions
공식적으로 제공해주는 방법은 없지만, 서드파티 툴을 만드려는 시도는 존재합니다(server-only-context, react cache function 활용). 공식문서에서는 db와 같이 네이티브 JS 패턴을 사용하는 방법을 추천해주고 있습니다. 링크
자주 있는 상황으로, 어떤 클라이언트 컴포넌트와 디렉터리 상 먼 곳에 있는 클라이언트 컴포넌트가 데이터 또는 상태를 공유해야하는 경우가 있을 수 있습니다. 이럴때는 일반적으로 리액트 앱을 개발할때 사용하는 전역 상태 관리 방법을 채택할 수 있습니다. next.js 공식문서에서도 Context API 및 서드파티 라이브러리에 대한 설명에 있습니다. 링크
예시로는 Context API를 사용하였습니다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
// layout.tsx
+import { AppProvider } from '../lib/AppProvider';
+
+export default function RootLayout({ children }) {
+ return (
+ <html lang="en">
+ <body className={inter.className}>
+ <AppProvider>{children}</AppProvider>
+ </body>
+ </html>
+ );
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
// lib/AppProvider.tsx
+'use client';
+import React, { createContext, useState, useContext } from 'react';
+
+const AppContext = createContext();
+
+export const AppProvider = ({ children }) => {
+ const [state, setState] = useState(0);
+ const value = {
+ state,
+ setState,
+ };
+ return <AppContext.Provider value={value}>{children}</AppContext.Provider>;
+}
+export const useAppContext = () => useContext(AppContext);
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
// page.tsx
+import Counter from '../components/counter';
+import ServerComp from '../components/server';
+
+export default function Home() {
+ return (
+ <main className={styles.main}>
+ <ServerComp />
+ <Counter />
+ </main>
+ );
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+
// components/counter.tsx
+'use client';
+
+import { useAppContext } from '../lib/AppProvider';
+
+export default function Counter() {
+ const { state, setState } = useAppContext();
+
+ const increaseHandler = () => {
+ setState(state + 1);
+ };
+
+ const decreaseHandler = () => {
+ setState(state - 1);
+ };
+ // Use the state and setState as needed
+ return (
+ <>
+ <div>{state}</div>
+ <a href="#" onClick={increaseHandler}>
+ increase
+ </a>{' '}
+
+ <a href="#" onClick={decreaseHandler}>
+ decrease
+ </a>
+ </>
+ );
+}
+
Once
"use client"is defined in a file, all other modules imported into it, including child components, are considered part of the client bundlehttps://nextjs.org/docs/getting-started/react-essentials#the-use-client-directive
클라이언트 컴포넌트의 자식 컴포넌트들은 클라이언트 번들로 간주된다는 내용입니다. 따라서 Context API Provider를 상위에 두면 그 하위 서버컴포넌트들도 모두 클라이언트 번들에 포함되어 서버컴포넌트를 사용하는 이유가 없어질것만 같습니다.
하지만 실험해본 결과, 클라이언트 번들에 포함되지 않았습니다. 이유는 ServerComponent가 ClientComponent(Context Provider)에 직접 import 되지 않고, props로 넘어갔기 때문입니다
next.js 공식 문서에 따르면 서버컴포넌트를 클라이언트 컴포넌트 밑에 두려면, import 하지 말고 prop(children)으로 넘겨줘야한다고 되어있습니다. 링크
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+
// Unsupported Pattern: Importing Server Components into Client Components
+
+'use client'
+
+// This pattern will **not** work!
+// You cannot import a Server Component into a Client Component.
+import ExampleServerComponent from './example-server-component'
+
+export default function ExampleClientComponent({
+ children,
+}: {
+ children: React.ReactNode
+}) {
+ const [count, setCount] = useState(0)
+
+ return (
+ <>
+ <button onClick={() => setCount(count + 1)}>{count}</button>
+ <ExampleServerComponent />
+ </>
+ )
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+
// Recommended Pattern: Passing Server Components to Client Components as Props
+
+'use client'
+
+import { useState } from 'react'
+
+export default function ExampleClientComponent({
+ children,
+}: {
+ children: React.ReactNode
+}) {
+ const [count, setCount] = useState(0)
+
+ return (
+ <>
+ <button onClick={() => setCount(count + 1)}>{count}</button>
+
+ {children}
+ </>
+ )
+}
+
공식 문서에 설명되어 있는대로, import 대신 props(children)으로 넘겨주면 클라이언트 컴포넌트는 자식 컴포넌트를 위한 slot을 남기고, 서버컴포넌트 렌더가 종료되면 그 slot에 서버 컴포넌트가 렌더링 됩니다. 이 방식대로 한다면 서버컴포넌트는 클라이언트 번들에 포함되지 않고, 서버컴포넌트로써 동작합니다.
“Server Component -> Server Component”에서 했던 것처럼, 한번 부른 fetch의 결과는 같은 요청이 살아있는 동안 캐시된다는 것을 활용할 수 있습니다. 데이터가 필요한 클라이언트 컴포넌트를 서버컴포넌트로 한번 감싸서 props drilling을 완화할 수 있습니다. 관련 링크(유튜브 영상, 소리주의)
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
// Server Component A
+import ServerComponentB from "./ServerComponentB"
+
+export default async function ServerComponentA() {
+ const initialCount = await fetch(...);
+
+ return <>
+ <h3>I got {initialCount}</h3>
+ <ServerComponentB />
+ </>
+}
+
1
+2
+3
+4
+5
+6
+
// Server Component B
+import ServerComponentC from "./ServerComponentC"
+
+export default function ServerComponentB() {
+ return <ServerComponentC/>
+}
+
1
+2
+3
+4
+5
+6
+7
+
// Server Component C
+import ClientComponent from "./ClientComponent"
+
+export default function ServerComponentC() {
+ const initialCount = await fetch(...);
+ return <ClientComponent initialCount={initialCount}/>
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
// Client Component
+'use client'
+
+import {useState} from "react"
+
+export default function ClientComponent({initialCount}) {
+ const [count, setCount] = useState(initialCount);
+
+ return (
+ <>
+ {count}
+ <button onClick={() => setCount(prev => prev + 1)}>+1</button>
+ <button onClick={() => setCount(prev => prev - 1)}>-1</button>
+ </>
+ )
+}
+
props로 넘겨주는 방법이나, 다음과 같이 cloneElement를 이용한 방법이 있습니다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
import React from "react";
+import ClientComponent from "./ClientComponent"
+
+export default function ParentComponent({ children }) {
+ return (
+ <ClientComponent>
+ <ServerComponent/>
+ </ClientComponent>
+ )
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
'use client'
+
+import React from "react";
+
+export default function ClientComponent({ children }) {
+ return (
+ <div>
+ {React.cloneElement(children, {name:"test props"})}
+ </div>
+ )
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+
import React from "react";
+
+export default function ServerComponent({ name }) {
+ return (
+ <div>
+ {name}
+ </div>
+ )
+}
+
하지만 가능한 것과는 별개로 크게 효용성이 있을지는 모르겠습니다. 이 방법은 클라이언트 컴포넌트의 바로 한단계 밑 서버컴포넌트로만 전달이 가능하기에, 클라이언트 컴포넌트에서 서버컴포넌트를 변경하려면 URL 쿼리를 변경하여 새로 페이지를 fetch하는게 나을 수도 있습니다. URL 쿼리를 변경하는 경우 한단계 밑 서버컴포넌트뿐만 아니라 관련있는 모든 서버컴포넌트들도 변경이 가능하기 떄문입니다.
Comments powered by Disqus.
next.js에서는 어떤 페이지가 getServerSideProps 또는 getInitialProps를 가지고 있지 않다면, static 페이지로 결정한다. 이렇게 static 페이지로 결정되면, 빌드시 그 페이지는 static 페이지로 빌드된다.
static 페이지는 서버사이드에서 렌더되지 않고 바로 유저에게 전달된다. end-user와 서버 사이에 CDN이 있다면 CDN의 적용 또한 받는다.
getServerSideProps 또는 getInitialProps가 없는 페이지는 빌드시 prerender 되어 static 페이지가 생성된다.
prerender 동안은 router의 query는 비어있다. 하지만 hydration이 완료된 이후 next.js는 페이지를 업데이트하며 query객체를 반영한다. 이 과정은 다음과 같은 과정일 때 발생한다.
next.config.js에 설정되어있을 때.query가 완전히 반영되었음을 확인하기 위해선 next/router의 isReady 필드를 확인하면 된다.
next build로 빌드를 마치면 static 페이지는 .next/server/pages/about.html로 결과물이 나온다. 하지만 getServerSideProps 을 사용한 페이지는 .next/server/pages/about.js로 결과물이 나오게 된다.
getInitialProps를 사용하는 Custom App이 있다면, getStaticProps 등을 활용한 Static Generation를 적용하지 않는한 automatic static 최적화가 동작하지 않는다.getInitialProps를 사용하는 Custom Document가 있다면, ctx.req가 빌드시 정의되어있어야한다. prerender 단계에서 ctx.req는 undefined이기 때문이다.next/router의 isReady 필드가 true가 되기 전까지 asPath 값을 사용하지마라.Comments powered by Disqus.
Next.js의 컴파일러는 바벨 대신에 Rust 기반의 SWC를 JS 번들링에 사용한다. 이는 바벨보다 17배 빠르며, Next.js 12부터 디폴트로 쓰인다. 만약 바벨을 사용하고 싶다면, 다음을 참고하면 된다.
Next.js Compiler의 자세한 내용은 공식 가이드에 나와있다. 이 글에서는 주로 사용할만한 요소만 요약하여 정리하였다.
Styled Components : bebel-plugin-styled-components와 연계하여 styled-components를 위한 바벨 설정을 next.js compiler에서도 사용할 수 있다.
Jest : css auto mocking, loading .env 등을 통해 Jest를 이용한 테스트 설정을 간편하게 해준다.
Relay : Graph QL 클라이언트 라이브러리인 Relay에 대한 설정을 제공한다.
Remove React Properties : babel-plugin-react-remove-properties와 비슷하게 JSX 프로퍼티를 제거한다. 테스팅에 용이하다.
Remove Console : 간단한 설정으로 미처 지우지 못한 콘솔 로그를 빌드과정에서 지워준다.
1
+2
+3
+4
+5
+6
+
// next.config.js
+module.exports = {
+ compiler: {
+ removeConsole: true,
+ },
+}
+
일부 로그는 exclude를 통해 남길 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+
// next.config.js
+module.exports = {
+ compiler: {
+ removeConsole: {
+ exclude: ['error'],
+ },
+ },
+}
+
Emotion : `@emotion/babel-plugin의 설정을 next.config.js에서 대신 할 수 있다.
Modularize Imports : 패키지를 불러올 때, “barrel file” 을 default import 처럼 사용할 수 있게 해준다.
1
+2
+3
+4
+
import { Row, Grid as MyGrid } from 'react-bootstrap'
+->
+import Row from 'react-bootstrap/Row'
+import MyGrid from 'react-bootstrap/Grid'
+
이는 다음과 같이 설정한다.
1
+2
+3
+4
+5
+6
+7
+8
+
// next.config.js
+module.exports = {
+ modularizeImports: {
+ 'react-bootstrap': {
+ transform: 'react-bootstrap/',
+ }
+ }
+}
+
좀 더 다양한 설정을 보기 위해선 공식문서 참조
Minifier debug options : minifier 옵션이 아직 실험단계이기 때문에, 그동안 디버그 목적으로 minifier의 설정을 변경할 수 있는 방법을 제공한다. minifier가 stable 단계에 돌입하면, 이 방법은 사라진다.
SWC Plugins : WASM로 쓰여진 SWC 플러그인을 사용하여 swc의 코드 트랜스포메이션 과정을 변경할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
// next.config.js
+module.exports = {
+ experimental: {
+ swcPlugins: [
+ [
+ 'plugin',
+ {
+ ...pluginOptions,
+ },
+ ],
+ ],
+ },
+}
+
swcPlugins는 튜플 배열을 받는다. 첫번째는 plugin으로의 path를 받고, 두번째로는 plugin option 을 받는다. 이때 path는 npm module 패키지명이나 .wasm 바이너리 파일의 절대 경로를 지정할 수 있다.
만약 어플리케이션에서 .babelrc를 가지고 있다면, next.js는 자동으로 next.js compiler 대신 Bebel을 사용한다.
https://nextjs.org/docs/advanced-features/compiler
Comments powered by Disqus.
next build를 실행하면, 작성한 소스코드가 최적화된 상태도 빌드된다. 빌드된 결과물 .next 아래에 위치하며 구조는 다음과 같다.
.next/static/chunks/pages : 라우트되는 이름 그대로 생성된 js 파일이 위치한다. (/about –> .next/static/chunks/pages/about.js).next/static/media : next/image를 사용하여 정적으로 삽입된 이미지가 해시되어 위치한다..next/static/css : 글로벌 CSS 파일이 위치한다..next/server/pages : 서버에서 프리렌더링되는 HTML과 JS의 엔트리 포인트. .nft.json 파일은 Output File Tracing이 활성화되면 생성된다..next/server/chunks : 어플리케이션 전반에서 사용되는 JS chunks.next/cache : node.js server에서 캐시된 이미지, 응답, 페이지들이 존재. 빌드 시간을 줄여주고, 이미지 로딩이 빨라진다..next 폴더 하위에 존재하는 모든 JS 파일은 컴파일되고, 최소화 된다. 그리고 모든 모던 브라우저을 지원한다.
만약 블로그와 같이 정적인 파일로 구성된 어플리케이션이라면, next export를 통해 정적인 파일만 빼서 배포할 수도 있다.
프로세스로부터 SIGTERM이나 SIGINT 신호를 받으면 특정 코드가 실행되도록 설정할 수 있다. 주로 서버 종료시 클린업 코드를 실행하기 위해 사용된다.
환경변수에서 NEXT_MANUAL_SIG_HANDLE를 true로 설정한다. (시스템에서 설정해야하며, .env 파일에서 설정하면 안된다.)
1
+2
+3
+4
+5
+6
+7
+8
+
// package.json
+{
+ "scripts": {
+ "dev": "NEXT_MANUAL_SIG_HANDLE=true next dev",
+ "build": "next build",
+ "start": "NEXT_MANUAL_SIG_HANDLE=true next start"
+ }
+}
+
pages/_document.js에서 시그널 핸들러를 설정한다.ㄴ
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
// pages/_document.js
+
+if (process.env.NEXT_MANUAL_SIG_HANDLE) {
+ process.on('SIGTERM', () => {
+ console.log('Received SIGTERM: ', 'cleaning up')
+ process.exit(0)
+ })
+
+ process.on('SIGINT', () => {
+ console.log('Received SIGINT: ', 'cleaning up')
+ process.exit(0)
+ })
+}
+
https://nextjs.org/docs/deployment
Comments powered by Disqus.
next.js는 빌드 시 자동으로 모든 페이지와 그 의존성을 트랙킹하여 배포시 필요한 파일을 알아낸다. 이렇게 함으로써 배포될 파일의 크기를 줄일 수 있다.
이전에 도커로 배포할 땐, 모든 의존성을 가져온 후 next start를 실행해야했다. 하지만 next.js 12부터는 Output File Tracing을 통해 .next/ 디렉터리만 있으면 된다. 단, standalone 모드를 켜야한다.
next build가 실행되는 동안, next.js는 @vercel/nft를 사용하여 정적으로 import, require, fs를 분석하여 로드될 페이지를 알아낸다.
next.js의 프로덕션 서버 또한 필요한 파일과, .next/next-server.js.nft.json 을 트래킹한다. .nft.json를 활용할 때는 nft.json에 상대적인 모든 trace의 파일리시트를 읽고, 배포할 위치에 복사한다.
next.js는 node_modules에서 필요한 파일을 뽑아내 배포시에 필요한 파일만으로 구성된 standalone 폴더를 구성할수 있다. 이를 활성화하기 위해선 next.config.js에서 다음과 같이 설정해야한다.
1
+2
+3
+
module.exports = {
+ output: 'standalone',
+}
+
이렇게 하면, 빌드시 .next/standalone 폴더가 생성되고, 여기에 node_modules에서 필요한 파일만 저장된다.
또한 최소화된 server.js가 next start 대신에 사용된다. 이 최소화된 서버는 public, .next/static 폴더를 디폴트로 복사하지 않는다. CDN에 저장되는 것이 가장 이상적이기 때문이다. 다만, standalone/.next/static 폴더에 수동으로 복사할 수는 있다.
Note : next.config.js는 next build 시 읽혀져 server.js에 복사된다. 만약 serverRuntimeConfig 또는 publicRuntimeConfig옵션 이 사용된다면, 빌드시 다른 값으로 변경된다.
만약 프로젝트에서 디폴트 로더로 Image Optimization를 사용중이라면, sharp를 설치해야한다.
1
+
npm i sharp
+
모노레포 설정에서 tracing 하면, 프로젝트의 디렉터리가 기본으로 사용된다. next build packages/web-app에서 packages/web-app이 tracing root가 되고, 해당 폴더 밖에 있는 파일들은 포함되지 않는다. 만약 바깥 파일도 tracing에 포함하고 싶으면, experimental.outputFileTracingRoot를 설정할 수 있다.
1
+2
+3
+4
+5
+6
+7
+
// packages/web-app/next.config.js
+module.exports = {
+ experimental: {
+ // this includes files from the monorepo base two directories up
+ outputFileTracingRoot: path.join(__dirname, '../../'),
+ },
+}
+
필요한 파일을 가져오는데 실패하거나 잘못된 파일을 가져오는 경우가 있다. 이러한 경우 unstable_includeFiles, unstable_excludeFiles 같은 page config를 export 하면 된다. 각 prop은 minimatch의 배열을 받는다. 프로젝트 루트를 루트로 삼고 설정하면 된다
현재 Next.js는 .nft.json을 가지고 아무것도 하지 않는다. 이 파일은 어플리케이션이 배포되는 시스템에서 minimal deployment를 위해 사용된다. 향후 .nft.json 를 활용한 커맨드를 낼 계획이 있다.
turbotrace의존성을 tracing하는 것은 느려질 수 있다. 따라서 next.js 팀은 turbotrace를 러스트로 작성하여 이 과정을 빠르게 만들었다.
활성화를 위해선 next.config.js에서 다음과 같이 설정할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+
// next.config.js
+module.exports = {
+ experimental: {
+ turbotrace: {
+ // control the log level of the turbotrace, default is `error`
+ logLevel?:
+ | 'bug'
+ | 'fatal'
+ | 'error'
+ | 'warning'
+ | 'hint'
+ | 'note'
+ | 'suggestions'
+ | 'info',
+ // control if the log of turbotrace should contain the details of the analysis, default is `false`
+ logDetail?: boolean
+ // show all log messages without limit
+ // turbotrace only show 1 log message for each categories by default
+ logAll?: boolean
+ // control the context directory of the turbotrace
+ // files outside of the context directory will not be traced
+ // set the `experimental.outputFileTracingRoot` has the same effect
+ // if the `experimental.outputFileTracingRoot` and this option are both set, the `experimental.turbotrace.contextDirectory` will be used
+ contextDirectory?: string
+ // if there is `process.cwd()` expression in your code, you can set this option to tell `turbotrace` the value of `process.cwd()` while tracing.
+ // for example the require(process.cwd() + '/package.json') will be traced as require('/path/to/cwd/package.json')
+ processCwd?: string
+ // control the maximum memory usage of the `turbotrace`, in `MB`, default is `6000`.
+ memoryLimit?: number
+ },
+ },
+}
+
https://nextjs.org/docs/advanced-features/output-file-tracing
Comments powered by Disqus.
next export 명령어를 통해 next.js 어플리케이션을 static HTML으로 만들 수 있다. 이렇게 만들어진 Static HTML은 Node.js 서버없이 운영이 가능하다. 다음과 같은 기능이 필요없다면, next export를 사용하는 것이 권장된다.
fallback: truegetServerSideProps위와 같은 기능들은 node.js 서버를 필요로 하고, 빌드 시 계산할 수 없는 로직을 포함하고 있기에, 위와 같은 기능을 사용중이라면 next export를 통한 node.js 서버 없는 운영이 가능하다.
package.json을 다음과 같이 변경한다.
1
+2
+3
+4
+5
+6
+7
+
{
+ ...
+ "scripts":{
+ "build": "next build && next export"
+ }
+ ...
+}
+
이후 npm run build를 수행하면, out 디렉터리가 생성된다.
next build 동안 생성된 HTML 파일을 next export를 통해 out 디렉터리에 모아 export 해주는 것이다.
경우에 따라서는 next.config.js에 exportPathMap를 설정하여 어떤 페이지들을 static하게 생성해낼것인지 지정이 가능하다. 이때 getStaticPaths를 사용한 페이지는 exportPathMap에서 설정하지 않아도 자동으로 HTML을 생성한다.
next export를 하더라도 다음과 같은 기능은 지원된다.
getStaticPathsnext/linkgetStaticPropsgetStaticPathsgetInitialProps를 getStaticProps 대신에 사용해도 되지만, 몇가지 주의사항이 존재한다.
getInitialProps는 getStaticProps나 getStaticPaths와 같은 페이지에서 함께 쓰일 수 없다. dynamic route를 사용해야한다면, getStaticPaths를 사용하는 대신에 exportPathMap을 설정하는 것이 좋다.getInitalProps가 export 단계에서 호출될 때, context의 req, res는 비어있다.getInitialProps는 클라이언트 단에서 네비게이트 될 때 호출된다. 빌드시 호출하고 싶다면 getStaticProps를 사용해야한다.getInitialProps는 node.js 라이브러리나 file-system을 사용할 수 없다.위와 같은 주의사항이 있기에, getInitialProps보다는 getStaticProps를 사용하는 것이 권장된다.
Comments powered by Disqus.
next.js 에서는 페이지 성능 개선을 위해 서드파티 script를 가져올 수 있는 next/script 컴포넌트를 제공한다.
1
+
import Script from 'next/script'
+
페이지 컴포넌트에서 사용될 수 있으며, 페이지가 브라우저에 로드되면 script를 fetch하고 실행한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
import Script from 'next/script'
+
+export default function Dashboard() {
+ return (
+ <>
+ <Script src="https://example.com/script.js" />
+ </>
+ )
+}
+
모든 경로에서 같은 script를 추가하고 싶다면 Custom App 에서 다음과 같이 사용할 수 있다. Page script와 마찬가지로 페이지가 로드되면 스크립트를 가져온다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
// pages/_app.js
+
+import Script from 'next/script'
+
+export default function MyApp({ Component, pageProps }) {
+ return (
+ <>
+ <Script src="https://example.com/script.js" />
+ <Component {...pageProps} />
+ </>
+ )
+}
+
어떤 경로로 접근하든 위 스크립트는 불러와지고, next.js는 위 script가 딱 한번만 불러와질수 있도록 보장한다. 하지만, 모든 페이지에서 같은 script를 사용하는 경우는 거의 없으니 쓸모없는 성능 저하를 막기 위해 특정 페이지에서만 script를 불러오도록 설정하는 것이 좋다.
next/script 컴포넌트의 속성인 strategy를 통해 스크립트가 불러오는 타이밍에 대해 설정할 수 있다.
beforeInteractive : 유저에게 전달되는 최초 HTML에 삽입되며, next.js 코드를 불러와 hydration이 일어나기 전에 로드한다. 스크립트 로드는 next.js 로드 전에 이뤄지지만, 스크립트 실행은 next.js 로드를 막지 않는다.
afterInteractive : 디폴트 설정으로, hydration이 어느정도 진행된 후에 불러온다.
lazyOnload : 브라우저가 한가할 때 가져온다.(필요한 모든 리소스를 다 가져온 상태).
worker : 웹 워커 안에서 스크립트를 불러온다. next.js v13.1.2 기준으로 베타 단계인 기능이다.
사용하기 위해선 다음과 같이 next.config.js에 설정해줘야한다.
1
+2
+3
+4
+5
+
module.exports = {
+ experimental: {
+ nextScriptWorkers: true,
+ },
+}
+
다음과 같이 inline으로 스크립트 코드를 직접 작성할 수 있다. 다만 이때는 id 속성을 만드시 지정해야한다.
1
+2
+3
+
<Script id="show-banner">
+ {`document.getElementById('banner').classList.remove('hidden')`}
+</Script>
+
dangerouslySetInnerHTML를 사용할 수도 있다.
1
+2
+3
+4
+
<Script
+ id="show-banner"
+ dangerouslySetInnerHTML=
+/>
+
스크립트 로드 상태에 따라 별도의 코드를 실행시키고 싶을 수 있다. next/script에서는 이를 위해 다음과 같은 속성을 제공한다. 콜백함수 안에서는 스크립트의 코드를 사용할 수 이다.
onLoad : 스크립트의 로딩이 종료되면 콜백함수 실행beforeInteractive 일때는 사용할 수 없음.onReady: 스크립트의 로딩이 종료되고, 네비게이션 등으로 컴포넌트가 마운트 될 때마다 콜백함수 실행한다.onError : 스크립트 로딩에 실패했을 경우 콜백함수 실행1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
import Script from 'next/script'
+
+export default function Page() {
+ return (
+ <>
+ <Script
+ src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/lodash.min.js"
+ onLoad={() => {
+ console.log(_.sample([1, 2, 3, 4])) // lodash 코드 사용가능
+ }}
+ />
+ </>
+ )
+}
+
next/script에서는 일반적인 <script> 태그의 DOM attribute 중 next/script에서 사용하지 않는 attribute를 <script>태그에 부여한다. 따라서 nonce나 data-*로 시작하는 custom data attribute도 사용할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
import Script from 'next/script'
+
+export default function Page() {
+ return (
+ <>
+ <Script
+ src="https://example.com/script.js"
+ id="example-script"
+ nonce="XUENAJFW"
+ data-test="script"
+ />
+ </>
+ )
+}
+
https://nextjs.org/docs/basic-features/script
Comments powered by Disqus.
next.js는 기본적으로 node.js runtime에서 작동된다. 하지만 node.js 는 싱글 스레드 기반이고, 따라서 트래픽이 많은 환경에서 multi-core를 사용하여 node.js 앱을 구동하기 위해선 다음과 같은 방법이 있다.
필자는 next.js에서 가장 사용하기 편한 방식인 cluster를 선택하였고, 편리하게 하기위해 pm2의 cluster 모드를 사용하기로 결정하였다. 환경은 kubernetes 환경으로 하나의 pod에 2~3개의 next.js 인스턴스를 pm2의 cluster 모드로 관리하고자 하였다.
따라서 가이드를 따라 다음과 같이 Dockerfile과 pm2 설정파일을 작성하였다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
// ./ecosystem.config.js
+module.exports = {
+ apps: [
+ {
+ name: "next-app",
+ script: "node_modules/next/dist/bin/next",
+ args: "start --port 80",
+ instances: 2,
+ exec_mode: "cluster",
+ },
+ ],
+};
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+
// package.json
+{
+ ...
+ "script":{
+ ...
+ "start-pm2:dev": "pm2 start ecosystem.config.js",
+ ...
+ }
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
# Stage 0
+FROM node AS nextjs-builder
+
+# next.js 빌드
+WORKDIR /home/deploy/next
+COPY ./package.json ./package.json
+COPY ./package-lock.json ./package-lock.json
+RUN npm ci
+COPY ./ecosystem.config.js ./ecosystem.config.js
+COPY ./.env ./.env
+COPY ./next.config.js ./next.config.js
+COPY ./public ./public
+COPY ./src ./src
+RUN npm run build
+
+# 프로젝트 실행
+ENTRYPOINT ["npm", "run", "start-pm2:dev"]
+
하지만 막상 도커 이미지를 빌드하고, 컨테이너를 실행하니 pm2가 실행되자마자 바로 컨테이너가 종료되었다. 그 후로도 다른 문제가 계속 발생하였는데, 차례대로 해결한 과정을 정리하였다.
pm2를 container에서 실행하려면 pm2 start가 아닌 pm2-runtime start를 사용해야한다. 공식문서 따라서 package.json의 명령문을 다음과 같이 바꿔야한다.
1
+2
+3
+4
+5
+6
+7
+8
+
{
+ ...
+ "script":{
+ ...
+ "start-pm2:dev": "pm2-runtime start ecosystem.config.js",
+ ...
+ }
+}
+
하지만 컨테이너를 실행하니 다음과 같은 오류가 나타났다.
1
+2
+
Error: Could not find a production build in the '/home/deploy/next/ecosystem.config.js/.next' directory. Try building your app with 'next build' before starting the production se
+rver. https://err.sh/vercel/next.js/production-start-no-build-id
+
/home/deploy/next/ecosystem.config.js/.next라는 경로에 빌드 파일이 없다는 말이다. 단순히 빌드오류라고 생각할 수 있지만 뭔가 경로가 이상하다. ecosystem.config.js는 파일인데 이 파일을 마치 디렉터리처럼 인식하고, 이 파일의 하위에서 빌드파일을 찾는다.
현재 프로젝트의 파일 구조는 다음과 같다.
1
+2
+3
+4
+5
+
-- next
+|-- .next (빌드파일)
+|-- package.json
+|-- ecosystem.config.js
+|-- (...기타 소스파일들)
+
Dockerfile에서 마지막 WORKDIR은 /home/deploy/next이므로, 명령어를 실행한 위치는 /home/deploy/next이다. 따라서 home/deploy/next/.next로 빌드파일의 경로를 설정해야하나, ecosystem.config.js로 경로를 설정한 것을 모도 pm2의 문제가 있다고 생각하여 찾아보았다.
검색을 한 결과 나하고 비슷한 문제를 겪은 사람을 발견하였다. 링크 이 사람이 스스로 찾은 답은 다음과 같다.
Adding command pm2 list before pm2-runtime solves the issue, I suppose that the command pm2 list initializes the pm2 and sets the proper path for pm2-runtime.
즉, pm2-runtime을 실행하기 전에 먼저 pm2 list를 실행하라는 뜻이다. 그럼 pm2 가 초기화되어 올바른 경로를 설정한다고 한다. 따라서 package.json을 다음과 같이 변경하였다.
1
+2
+3
+4
+5
+6
+7
+8
+
{
+ ...
+ "script":{
+ ...
+ "start-pm2:dev": "pm2 list && pm2-runtime start ecosystem.config.js",
+ ...
+ }
+}
+
이후 컨테이너를 실행하니 제대로 실행되었다. status를 확인해보니 다음과 같이 나왔다.
1
+2
+3
+4
+
ready - started server on 0.0.0.0:80, url: http://localhost:80
+info - Loaded env from /home/develop/deploy/next/.env
+ready - started server on 0.0.0.0:80, url: http://localhost:80
+info - Loaded env from /home/develop/deploy/next/.env
+
Comments powered by Disqus.
next.js에서 사용자의 요청을 받고, 페이지를 만들어낼 때 외부 서버로 필요한 데이터를 요청해야할 때 사용하는 기법이다. data fetching은 기본적으로 페이지 컴포넌트에서 사용할 수 있고 경우에 따라 Custom App 컴포넌트에서도 사용할 수 있다.
next 13부터는 app/ 구조를 사용한다면 일반 컴포넌트에서도 가능하다고 하지만, 현재(2023.01)는 next 13의 app/ 구조가 베타버전이라 pages/ 구조를 기준으로 작성하였다.
Note: Next.js 13 introduces the
app/directory (beta). This new directory has support for colocated data fetching at the component level, using the new Reactusehook and an extendedfetchWeb API.
1
+2
+3
+4
+5
+
export async function getStaticProps(context) {
+ return {
+ props: {}, // 페이지 컴포넌트에서 필요한 props 값 주입
+ };
+}
+
getStaticProps가 만드는 건 HTML, JSON 파일이다.getStaticProps의 결과가 저장된다.getStaticProps는 HTML, JSON 파일을 만드므로 CDN에 캐시된다.getStaticProps는 항상 server-side에서 실행된다. 따라서 DB 접근과 같은 민감한 작업을 수행할 수 있다. 실행 시점은 다음과 같다.
next build시에 항상 실행된다.fallback: true일 때는 백그라운드에서 실행된다.fallback: blocking 일 때는 최초 페이지 접근 시에 실행된다.revalidate를 사용하면 백그라운드에서 실행된다.revalidate()를 사용하면 최초 페이지 접근 시 백그라운드에서 실행된다.getStaticProps는 static HTML을 만드므로 유저 request에 접근할 순 없다. 만약 접근해야한다면 Middleware를 추가하면 된다._app, _document, _error에서도 사용할 수 없다preview mode를 사용해 빌드타임 대신에 request time에 실행시킬 수 있다.
getStaticPaths에서 반환된 경로는 모두 정적으로 빌드타임에 렌더링되어 정적으로 저장된다.1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
// pages/posts/[id].js
+
+export async function getStaticPaths() {
+ return {
+ paths: [{ params: { id: '1' } }, { params: { id: '2' } }],
+ fallback: false, // false, true, 'blocking'
+ }
+}
+
+export async function getStaticProps(context) {
+ return
+ props: { post: {} },
+ }
+}
+
+export default function Post({ post }) {
+ // Render post...
+}
+
getStaticPaths는 getStaticProps와 함께 사용해야한다.getStaticPaths에서 리턴한 paths마다 getStaticProps가 실행됨getStaticPaths에서 fallback:true를 반환하면 getStaticProps는 백그라운드에서 실행된다.getStaticPaths에서 fallback:blocking을 반환하면 getStaticProps는 최초 호출 시 실행된다.getStaticPaths는 getServerSideProps와 함께 쓰일 수 없음.paths로 반환한 페이지가 너무 많으면 빌드시 시간이 오래 걸릴 수 있다. 따라서 빈 배열을 반환하고, 페이지에 최초 접근 시에 그 페이지를 렌더하도록 fallback: blocking과 함께 쓰일 수 있다.1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+
export async function getStaticPaths() {
+ // 페이지 최초 접근시에만 렌더
+ if (process.env.SKIP_BUILD_STATIC_GENERATION) {
+ return {
+ paths: [],
+ fallback: "blocking",
+ };
+ }
+
+ // SKIP_BUILD_STATIC_GENERATION=false 일땐 paths 생성.
+ const res = await fetch("https://.../posts");
+ const posts = await res.json();
+
+ const paths = posts.map((post) => ({
+ params: { id: post.id },
+ }));
+
+ return { paths, fallback: false };
+}
+
static 페이지를 다시 빌드할 필요가 있을 때, 전체 페이지를 다시 빌드할 필요없이 각 페이지를 일정시간마다 자동으로 빌드해서 새롭게 업데이트 된 페이지를 보여주는 방법이다.
사용법은 getStaticProps의 반환 객체에 revalidate를 추가하면 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
export async function getStaticProps() {
+ const res = await fetch("https://.../posts");
+ const posts = await res.json();
+
+ return {
+ props: {
+ posts,
+ },
+ // Next.js will attempt to re-generate the page:
+ // - When a request comes in
+ // - At most once every 10 seconds
+ revalidate: 10, // In seconds
+ };
+}
+
특정 주기마다 regenerate하는 대신, 필요할 때마다 업데이트하고 싶을 떄 사용한다.
secret key를 생성후, 다음 주소로 요청을 보낸다.
1
+
https://<your-site.com>/api/revalidate?secret=<token>
+
secret key를 환경변수에 추가하고, api/revalidate를 다음과 같이 구성한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
// pages/api/revalidate.js
+
+export default async function handler(req, res) {
+ if (req.query.secret !== process.env.MY_SECRET_TOKEN) {
+ return res.status(401).json({ message: 'Invalid token' })
+ }
+
+ try {
+ await res.revalidate('/path-to-revalidate')
+ return res.json({ revalidated: true })
+ } catch (err)
+ return res.status(500).send('Error revalidating')
+ }
+}
+
useCdn : false 옵션을 사용할 수 있다.매 요청마다 새롭게 값을 불러와야할 경우 사용.
1
+2
+3
+4
+5
+
export async function getServerSideProps(context) {
+ return {
+ props: {}, // will be passed to the page component as props
+ };
+}
+
모든 요청에 대한 계산을 해야하고, CDN 캐시 적용이 되지 않기에 더 느리다. 따라서 꼭 매번 새롭게 불러와야할 경우에만 사용한다.
getServerSideProps는 빌드시 번들로 묶이지 않는다. 따라서 클라이언트 사이드에 전달도 되지 않는다. 그렇기에 서버사이드에서만 실행해야하는 코드(DB 호출)를 사용하기에 좋다.
window.document와 같은 브라우저 API를 사용할 수 없다.context를 인자로 받는데, 다음과 같은 필드가 포함되어있다.
cookies를 포함한 객체이다.setPreviewData로 설정된 preview 데이터가 담겨있다.getServerSideProps에서는 다음과 같은 데이터를 반환할 수 있고, 각 반환값에 따라 페이지 렌더링이 달라진다.
props : 페이지 컴포넌트로 전달되는 데이터를 담는다. 일반적으로 사용하는 반환값으로, props로 넘어간 데이터 가지고 페이지 컴포넌트가 렌더링한다.
1
+2
+3
+4
+5
+
export async function getServerSideProps(context) {
+ return {
+ props: { message: `Next.js is awesome` }, // will be passed to the page component as props
+ };
+}
+
notFound : boolean 값을 담는다. true일 경우 페이지 컴포넌트를 렌더링하지 않고 404 코드를 낸다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
export async function getServerSideProps(context) {
+ const res = await fetch(`https://.../data`);
+ const data = await res.json();
+
+ if (!data) {
+ return {
+ notFound: true,
+ };
+ }
+
+ return {
+ props: { data }, // will be passed to the page component as props
+ };
+}
+
redirect : 다른 페이지로 리다이렉트 시킬 때 사용한다. statusCode 필드를 추가할 수 있으나, 그럴려면 permanent 필드를 설정하면 안된다. (redirect permanent란?)
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
export async function getServerSideProps(context) {
+ const res = await fetch(`https://.../data`);
+ const data = await res.json();
+
+ if (!data) {
+ return {
+ redirect: {
+ destination: "/",
+ permanent: false,
+ },
+ };
+ }
+
+ return {
+ props: {}, // will be passed to the page component as props
+ };
+}
+
타입스크립트와 함께 사용할 때 타이핑 기법들은 다음과 같다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
import { GetServerSideProps } from 'next'
+
+type Data = { ... }
+
+export const getServerSideProps: GetServerSideProps<{ data: Data }> = async (context) => {
+ const res = await fetch('https://.../data')
+ const data: Data = await res.json()
+
+ return {
+ props: {
+ data,
+ },
+ }
+}
+
추론된 타입을 사용하고 싶으면 다음과 같이 할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
import { InferGetServerSidePropsType } from 'next'
+
+type Data = { ... }
+
+export const getServerSideProps = async () => {
+ const res = await fetch('https://.../data')
+ const data: Data = await res.json()
+
+ return {
+ props: {
+ data,
+ },
+ }
+}
+
+function Page({ data }: InferGetServerSidePropsType<typeof getServerSideProps>) {
+ // will resolve data to type Data
+}
+
+export default Page
+
getServerSideProps와 같이 서버사이드에서 페이지 컴포넌트를 렌더하기 전에 필요한 데이터를 불러오기 위한 메서드이다( getStaticProps, getStaticPaths의 기능은 없음). next v9 이전에 사용하였으며 그 이후에는 getServerSideProps가 사용된다. 하지만 레거시 코드를 읽을 때 필요하니 알아둘 필요가 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
export default function Page({ stars }) {
+ return <div>Next stars: {stars}</div>;
+}
+
+Page.getInitialProps = async (ctx: NextPageContext) => {
+ const res = await fetch("https://api.github.com/repos/vercel/next.js");
+ const json = await res.json();
+ return { stars: json.stargazers_count };
+};
+
next/link, next/router로 페이지 네비케이팅 됐을 시에는 클라이언트에서 실행된다.getInitialProps가 Custom App 컴포넌트에 있고, 네비게이팅된 페이지가 getServerSideProps를 사용중이라면, 서버에서 실행된다.context의 구성이 다르다.cookies를 포함한 객체이다.한 페이지 컴포넌트에서는 하나의 getInitialProps만 실행됨.
따라서 _app.tsx와 페이지 컴포넌트 둘 다 getInitialProps가 있다면 먼저 실행되는 _app.tsx의 getInitialProps만 실행된다.
만약 페이지 컴포넌트의 getInitialProps를 실행하려면 _app.tsx를 다음과 같이 변경해야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
function MyApp({ Component, pageProps }) {
+ return <Component ponent {...pageProps} />;
+}
+
+MyApp.getInitialProps = async ({ Component, ctx }) => {
+ let pageProps = {};
+ // 하위 컴포넌트에 getInitialProps가 있다면 추가 (각 개별 컴포넌트에서 사용할 값 추가)
+ if (Component.getInitialProps) {
+ pageProps = await Component.getInitialProps(ctx);
+ }
+
+ // _app에서 props 추가 (모든 컴포넌트에서 공통적으로 사용할 값 추가)
+ pageProps = { ...pageProps, posttt: { title: 11111, content: 3333 } };
+
+ return { pageProps };
+};
+
+export default MyApp;
+
같은 페이지 내에서 화면은 같은데 url만 바뀌는 경우, url이 변경될 떄마다 서버에 새로운 페이지를 달라고 요청을 보낸다고 해보자. 그럼 getInitialProps나 getInitialProps가 매번 실행되어 서버의 연산이 너무 많아지게 된다. 이때 사용할 수 있는 것이 ` shallow route`이다
방법은 아래와 같이 router 객체를 사용하여 쓸 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+
router.push(
+ {
+ pathname: "/cars?model=bmw",
+ query: { ...values, page: 1 }, // 상태값 전달가능
+ },
+ undefined,
+ { shallow: true } // shallow route
+);
+
페이지 변경 감지는 useEffect 또는 componentDidUpdate에서 가능하다
1
+2
+3
+4
+5
+6
+7
+8
+
componentDidUpdate(prevProps) {
+ const { pathname, query } = this.props.router
+ // verify props have changed to avoid an infinite loop
+ if (query.counter !== prevProps.router.query.counter) {
+ // fetch data based on the new query
+ }
+}
+
+
이떄 shallow routing은 동일 페이지의 url 변경에서만 동작하고, 다른 페이지로 이동할 때는 getInitalProps가 그대로 실행된다. 다음 예시는 다른 페이지로 이동하는 예시다.
1
+2
+3
+4
+5
+6
+7
+8
+
router.push(
+ {
+ pathname: "/users",
+ query: { ...values, page: 1 },
+ },
+ undefined,
+ { shallow: true }
+);
+
https://kyounghwan01.github.io/blog/React/next/getInitialProps/#%E1%84%8C%E1%85%AE%E1%84%8B%E1%85%B4%E1%84%89%E1%85%A1%E1%84%92%E1%85%A1%E1%86%BC
https://nextjs.org/docs/basic-features/data-fetching/get-static-props
https://develogger.kro.kr/blog/LKHcoding/133
Comments powered by Disqus.
next.js에서는 next/image로 자체적인 이미지 컴포넌트를 제공한다. 일반적인 img 태그와는 달리 여러 성능 최적화기법이 내장되어있다. 기본적으로 다음과 같은 기능을 제공한다.
1
+
import Image from "next/image"
+
Local Image
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
import profilePic from '../public/me.png'
+
+function Home() {
+ return (
+ <Image
+ src={profilePic}
+ alt="Picture of the author"
+ // width={500} automatically provided
+ // height={500} automatically provided
+ // blurDataURL="data:..." automatically provided
+ // placeholder="blur" // Optional blur-up while loading
+ />
+ )
+}
+
import문이 빌드시 분석되어야하기 때문에 Dynamic await import() 또는 require()는 지원되지 않는다.width, height는 next.js에서 자동으로 계산한다. 이는 Cumulative Layout Shift를 방지하기 위해 쓰인다.blurDataURL도 자동으로 지원된다.Remote image
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
import Image from 'next/image'
+
+export default function Home() {
+ return (
+ <Image
+ src="/me.png"
+ alt="Picture of the author"
+ width={500}
+ height={500}
+ />
+ )
+}
+
public 폴더 이하의 경로이다.width, height를 명시해주어야한다.blurDataURL 또한 직접 입력해야한다.Remote image를 불러오는 예제에서 src 값을 /me.png와 같은 상대경로로 입력하였는데, 이것이 가능한 이유는 Loader가 있기 때문이다.
loader는 이미지의 URL을 생성하는 함수이다. src를 변경하여 다양한 사이즈의 이미지를 요청하는 여러 URL을 생성한다. 이러한 여러 URL은 자동으로 srcset을 생성하고, 사이트에 방문한 유저가 적절한 사이즈의 이미지를 다운 받도록한다.
default loader는 이미지를 가져와 최적화한 다음에 next.js 웹 서버에서 제공한다. 만약 CDN이나 image server에서 직접 이미지를 가져가도록 하고 싶다면, 직접 loader 함수를 작성할 수 있다. next/image컴포넌트마다 loader 속성을 지정할 수 있으며, 아니면 어플리케이션 레벨로 next.config.js에서 loader를 지정할 수 있다.
remote image를 최적화하고 싶을 때, loader 는 디폴트 설정으로 두고, next/image 컴포넌트의 src 에는 절대경로를 입력한다. 악의적인 공격을 막기 위해 remote hostname을 반드시 정의해야한다. 다음과 같이 next.config.js에서 정의할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
module.exports = {
+ images: {
+ remotePatterns: [
+ {
+ protocol: 'https',
+ hostname: 'example.com',
+ port: '',
+ pathname: '/account123/**',
+ },
+ {
+ protocol: 'https',
+ hostname: '**.example.com',
+ },
+ ],
+ },
+}
+
* 는 hostname과 pathname에 모두 쓰일 수 있다.* : 하나의 path segment 또는 subdomain과 매칭된다.** ; 여러 path segment 또는 subdomain과 매칭된다.www.**.com과 같이 중간 부분에서 적용되진 않는다.좀 더 간단하게 domain만 명시할 수도 있다. 하지만 domain은 와일드카드를 지원하지 알고, protocol을 지정할 수 없기에 remotePatterns가 권장된다.
1
+2
+3
+4
+5
+
module.exports = {
+ images: {
+ domains: ['assets.acme.com'],
+ },
+}
+
priority속성을 사용하여 이미지 로딩에 우선순위를 둘 수 있다. LCP 엘리먼트에 쓰일 수 있으며, 이미지가 페이지에 접속하자마자 보여야할 때만 사용하는 것이 좋다,
이미지가 퍼포먼스에 악영향을 미치는 가장 큰 요인은 cumulative layout shift이다 . 이미지가 늦게 로딩되어 다른 엘리먼트를 멀어내는 것을 말한다. 유저의 입장에선 매우 짜증나는 이슈이다.
이 이슈를 막기 위해서는 이미지의 사이즈를 기입해야한다. 이미지의 사이즈를 기업하면, 브라우저는 이미지가 로드되기 전에 이미지를 위한 공간을 미리 잡아둔다.
next/image에서는 다음 세가지 방법중 하나를 사용한다.
static import를 통해 이미지를 가져오면 자동으로 계산한다.
명시적으로 width, height속성을 기입한다.
fill 속성은 부모 요소를 채울 때 사용하며, 이 속성을 사용하면, width, height를 기입하지 않아도 자동으로 계산된다. 다만 부모 요소의 position이 relative, absolute, fixed 중 하나여야한다.
기본적으로는 <img> 태그를 사용할 때와 같지만 아래 주의사항이 있다.
styled-jsx 대신에 className 또는 style을 사용한다.styled-jsx는 글로벌로 사용하지 않는한 현재 컴포넌트에서만 적용되기에 사용할 수 없다.
fill 속성 사용시, 부모 요소는 position:relative여야한다.적절한 사이즈를 계산하기 위해 필요하다.
fill 속성 사용시, 부모요소는 deplay: block여야한다.<div> 엘리먼트일 경우엔 이미 적용되어있지만, 다른 엘리먼트라면 명시적으로 설정해야한다.
next/image 가이드 : https://nextjs.org/docs/basic-features/image-optimization
next/image 레퍼런스 : https://nextjs.org/docs/api-reference/next/image
Comments powered by Disqus.
next.js로 만든 앱을 배포하기 전 체크리스트
next/image에 관한 내용next/font에 관한 내용next/script에 관한 내용next.js는 /_next/static 에서 서빙되는 불변 assets을 클라이언트로 보낼 때 자동으로 caching 헤더를 붙인다.
1
+
Cache-Control: public, max-age=31536000, immutable
+
다른 값을 사용하고 싶다면 next.config.js에서 설정할 수 있다. 만약 캐시를 revalidate 시키고 싶다면 getStaticProps에서 revalidate를 설정하면 된다.
next dev로 실행할 경우엔 자동으로 다음과 같은 값으로 설정되어 캐싱되지 않는다.
1
+
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
+
next/image은 별로의 캐싱 규칙이 존재한다.
getServerSideProps나 API Route에서도 caching 헤더를 사용할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
export async function getServerSideProps({ req, res }) {
+ res.setHeader(
+ 'Cache-Control',
+ 'public, s-maxage=10, stale-while-revalidate=59'
+ )
+
+ return {
+ props: {},
+ }
+}
+
기본적으로는 Cache-Control은 경우에 따라 다르게 설정된다,
getServerSideProps, getInitialProps 를 사용하는 페이지 : next start로 설정된 디폴트 Cache-Control 사용하여 캐싱되는 것을 막는다.getStaticPropsrevalidate가 설정되있지 않으면, s-maxage=REVALIDATE_SECONDS, stale-while-revalidaterevalidate가 설정되어있으면, s-maxage=31536000, stale-while-revalidate다음과 같은 툴을 사용하면 Javascript 번들 사이즈를 줄이는데 도움이 된다.
/pages 디렉터리에 있는 파일들은 next build시 자동으로 코드가 분리되어 번들된다. Dynamic Imports`를 사용해 lazy-load를 적용할 수도 있다.
Core Web Vitals를 사용하여 loading performance를 개선할 수 있다. 개선해야할 점이 보이면 다음과 같은 전략을 취할 수 있다.
stale-while-revalidate를 적절히 사용하라Comments powered by Disqus.
서비스를 운영하던 도중 CPU/Memory 사용량은 낮은데 사용자 응답이 매우 느려지는 상황이 발생하였다. 서비스는 쿠버네티스로 띄워져있었고, HPA metric으로 CPU와 memory가 걸려있었는데, CPU와 memory가 올라가지 않으니 scale-out도 발생하지 않아 적은 pod으로 계속 서비스 되고 있었다. 수동으로 pod을 3~4배 가량 늘려 대응은 하였으나 추후에도 발생할 이슈일 것으로 보여 대응을 하기로 했다.
이 이슈는 next.js로 띄워져있는 페이지 중 하나에 페이지에 갑자기 트래픽이 몰려 발생한 이슈였다. 따라서 당시 리얼환경과 비슷하게 환경 세팅을 하고 ngrinder를 사용하여 대규모 트래픽 테스트를 하였다. 이슈가 발생했던 페이지를 포함하여 다양한 페이지를 테스트한 결과는 다음과 같았다. (TPS가 낮음 -> 성능이 낮음)
해당 페이지들은 다음과 같은 특징을 가지고 있다.
이 결과들을 보고 내린 결론은 다음과 같다.
아래 두 전략을 가지고 최적화를 진행하였다.
자세한 내용은 다음과 같다.
기본적으로 API 요청이 발생하는 페이지에서 성능저하가 발생하였다. 따라서 API 요청을 최소화하는게 최우선 목표라고 생각하였다.
가장 성능이 안좋았던 페이지 A는 A’로 API 요청을 2개 보내고, B’로 1개의 요청을 보낸다. A’로 보내는 두개의 요청은 기존에는 다음과 같이 코드가 짜여있었다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
export const getServerSideProps = async(context) => {
+ ...
+ const userProfileData = await getUserProfileData();
+ const userContentData = await getUserContentData();
+ ...
+ return {
+ props : {
+ userData,
+ userContentData,
+ }
+ }
+}
+
getUserProfileData() 와 getUserContentData()는 유저가 로그인 되어있든 안되어있든 항상 A’로 요청을 보낸다. 그리고 A’는 로그인 되어있지 않으면 null을 응답한다. 처음 이 코드를 짰을때는 성능에 대해 크게 걱정이 없어서 이렇게 항상 요청하는 식으로 짰다.(코드 조금 더 쓰기 귀찮았다..) 하지만 로그인 여부는 next.js 단에서도 API 요청 없이 알 수 있도록 설정이 되어있었다. 따라서 다음과 같이 next.js 에서 먼저 로그인 여부를 확인하고 로그인 되어있으면 요청하는 식으로 코드를 변경하였다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
export const getServerSideProps = async(context) => {
+ const { isLoggedIn } = getAuthentication();
+ ...
+ let userProfileData = null, userContentData = null;
+ if(isLoggedIn) {
+ userProfileData = await getUserProfileData();
+ userContentData = await getUserContentData();
+
+ }
+ ...
+ return {
+ props : {
+ userData,
+ userContentData,
+ }
+ }
+}
+
이로써 미로그인 유저들이 불필요한 API 요청을 보내는 일이 없어졌다. 조금 더 개선을 하자면, getUserProfileData() 와 getUserContentData()를 하나의 API로 합칠 수도 있으나 이건 API 개발자의 작업이니 이 글에선 자세히 작성하진 않겠다.
또 여기서 한번 더 최적화를 한다면 다음과 같이 Promise.all을 사용하여 요청을 동시에 보낼 수도 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
export const getServerSideProps = async(context) => {
+ const { isLoggedIn } = getAuthentication();
+ ...
+ let userProfileData = null, userContentData = null;
+ if(isLoggedIn) {
+ [userProfileData, userContentData] = await Promise.all([getUserProfileData(), getUserContentData()])
+ }
+ ...
+ return {
+ props : {
+ userData,
+ userContentData,
+ }
+ }
+}
+
기존에는 getUserProfileData()의 응답시간 + getUserContentData()의 응답시간으로 최종 응답시간이 정해졌으나, Promise.all을 사용하면 둘 중 더 느린 응답시간으로 최종 응답시간이 결정되기 때문이다.
다음은 B’로 보내는 요청을 최적화한 방법이다. B’는 콘텐츠를 가져오는 API로 기존에는 매요청마다 호출하고 있었다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
export const getServerSideProps = async(context) => {
+ ...
+ const contentData = await getContentData('page-a');
+ ...
+ return {
+ props : {
+ contentData
+ }
+ }
+}
+
콘텐츠의 내용이 변경가능하여 항상 호출하였으나, 변경 사항을 즉시 반영해야할 심각도를 가진 콘텐츠는 아니었다. 즉 캐시를 사용하여 콘텐츠 변경의 반영이 어느정도 늦어져도 문제는 없었다. 따라서 memory-cache라는 in-memory cache 을 쉽게 사용할 수 있게 도와주는 라이브러리를 사용하기로 하였다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
import cacheData from "memory-cache";
+
+export const getServerSideProps = async(context) => {
+ ...
+ const key = "page-a"
+ let contentData = cacheData.get(key);
+ if (!contentData) {
+ contentData = await getContentData(key);
+ cacheData.put(key, contentData, 60000);
+ }
+ ...
+ return {
+ props : {
+ contentData
+ }
+ }
+
+}
+
이렇게 두가지만 적용한 후, 다시 페이지 A를 ngrinder로 테스트한 결과는 다음과 같았다.
이번 이슈를 겪으면서 알게 된 것은 CPU, Memory 사용량이 많아져서 응답이 느리게 갈 가능성은 적다는 것이었다. 정적페이지 및 API 요청 없는 동적페이지의 경우 매우 빠르게 처리하고 있었고, pod 개수도 많아서 예상되는 최대치의 트래픽이 들어오더라도 CPU, Memory 사용량이 많이 점유되는 가능성은 적었다. 반대로 API 요청이 발생하는 페이지에서는 예상보다 훨씬 적은 트래픽이 들어오더라도 터지는 일이 발생하였다.
따라서 서버 응답 장애가 발생한다면, CPU/Memory 사용량은 낮지만 API 요청이 발생하는 페이지에 요청이 몰려 발생할 확률이 훨씬 컸다.
이에따라 기존에는 HPA metric을 다음과 같이 CPU/Memory 기준으로 작성하였는데, network 요청량이 일정 수준이상이 되면 발생하도록 변경하기로 하였다. (아래 yaml 파일들은 실제 파일이 아닌 예시)
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
# 기존 hpa 설정
+apiVersion: autoscaling/v1
+kind: HorizontalPodAutoscaler
+metadata:
+ name: next-app-hpa
+ namespace: default
+spec:
+ scaleTargetRef:
+ apiVersion: apps/v1
+ kind: Deployment
+ name: next-app
+ minReplicas: 1
+ maxReplicas: 10
+ targetCPUUtilizationPercentage: 50 # CPU가 50%로 맞춰지도록 스케일링 발생
+ targetmemoryutilizationpercentage: 50 # Memory가 50%로 맞춰지도록 스케일링 발생
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+
# 변경한 hpa 설정
+apiVersion: autoscaling/v2beta2
+kind: HorizontalPodAutoscaler
+metadata:
+ name: next-app-hpa
+ namespace: default
+spec:
+ scaleTargetRef:
+ apiVersion: apps/v1
+ kind: Deployment
+ name: next-app
+ minReplicas: 1
+ maxReplicas: 10
+ metrics:
+ - object:
+ describedObject:
+ apiVersion: v1
+ kind: Service
+ name: test
+ metric:
+ name: test_requests_per_second
+ target:
+ type: Value
+ value: 200 # 초당 200번 이상 요청이 들어올 시 scale-out 발생
+ type: Object
+ - resource:
+ name: cpu # CPU 설정도 혹시 모르니 남겨둠(CPU가 터지는 상항이 생길 수 있으니..)
+ target:
+ averageUtilization: 50
+ type: Utilization
+ type: Resource
+
다시 ngrinder로 테스트를 하니 scale-out 이 정상적으로 동작하였다. 이 두가지 방법을 적용하여 최적화를 완료하였고, 이후 트래픽이 많이 발생하여도 정상적으로 대응 가능하였다.
Comments powered by Disqus.
원글에서는 TMDB의 클라이언트 웹 어플리케이션을 만들고, 여러번의 실험을 거쳐 성능 최적화에 달성하는 과정을 서술하였습니다.
이 글은 기본적으로 원글을 학습하면서 제가 읽기 편한 방식으로 번역/정리한 글입니다. 정확한 내용을 알고 싶으시면 원글을 보시는 걸 추천드립니다.
앱을 만들 때 사용한 서드파티 리액트 컴포넌트를 분석하여, 무겁거나 메인 스레드를 blocking 하는 컴포넌트들은 다른 컴포넌트로 대체하였다. 그 결과로 다양한 메트릭에서 좋은 결과를 냈다.
@svgr/webpack을 Font-awsome 대신에 사용하니, Speed Index는 34%, LCP는 23%, TBT는 51% 개선되었다.react-burger-menu을 대체하고 resize-sicky-box로부터 resize-observer-polyfill을 제거하고 custom-built component를 사용하였다. 이는 번들 사이즈가 34.28KB 감소하는 결과로 이어졌다.React Select 대신 React Select Search를 사용하니 LCP 35%, CLS 100%, TBT 18% 개선되었다.React Slick 대신 React Glider를 사용하여 TBT 77% 개선되었다.native smooth scrolling 대신에 React Scrolling을 사용하였다.React Rating 대신에 React Stars를 사용하여 TBT가 33% 개선되었다.그럼 상세한 과정을 알아보자
처음에 편리함과 유명세 때문에 Font-Awesome 라이브러리를 사용하였다. 하지만, 라이브러리 로딩시 큰 transfer size 때문에 웹 페이지 로딩 속도에 악영향을 주어 Lighthouse 점수가 안좋게 나왔다.
따라서 @svgr/webpack으로 대체하고, 라이브러리 전체가 아닌 개별 아이콘을 import 하는 방식을 통해 성능을 개선하였다.
1
+2
+3
+4
+5
+6
+7
+8
+
import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
+
+// replaced by
+
+import HeartIcon from "public/assets/svgs/icons/heart.svg";
+import PollIcon from "public/assets/svgs/icons/poll.svg";
+import CalendarIcon from "public/assets/svgs/icons/calendar.svg";
+import DotCircleIcon from "public/assets/svgs/icons/dot-circle.svg";
+
처음에 react-burger-menu를 사용하였으나, 분석해보니 번들 사이즈가 너무 컸다. 다양한 커스터마이징에 대응하기 위해 CSS 스타일이나 애니메이션이 많았기 때문이다. 하지만 그정도의 기능이 필요없었기에 커스텀하여 메뉴를 구현하였다. 이는 번들사이즈를 매우 크게 줄여주었다.
유저가 정렬 옵션을 선택하여 정렬하기 위해 react-select를 처음에 사용하였다. 하지만 react-select에서 제공하는 것만큼 다양한 기능은 필요없었고, 단순한 정렬 컴포넌트만 원했다. 따라서 react-select-search 컴포넌트를 사용하였다. 이로써 번들 사이즈카 크게 줄었고, lighthout 점수도 올랐다.
출연배우를 보여주기 위한 수평 glide를 위해 React-Slick을 사용하였으나, react-glider로 대체하여 번들 사이즈를 크게 줄였다.
앱은 페이지네이션이 구현되어있다. 그리고 이전 페이지, 이후 페이지로 이동할 때마다 페이지의 상단으로 스크롤된다. 이 스크롤을 부드럽게 하기 위해 native smooth scroll 기능을 사용하였다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
window.scroll({
+ top: 0,
+ left: 0,
+ behavior: "smooth",
+});
+
+// and
+
+document.querySelector(`.${SCROLL_TO_ELEMENT}`)?.scrollIntoView({
+ behavior: "smooth",
+});
+
하지만 이 기능은 모든 브라우저에서 지원하진 않았다. 따라서 react-scroll 패키지를 사용하여 대응하였다. 이 패키지는 성능에 조그마한 악영향을 주었지만 같은 스크롤 기능을 구현하였다.
React-rating은 동그라미, 별, 따봉 등 다양한 심볼로 커스터마이징하여 레이팅을 매길 수 있게 해준다. 하지만, 테스트 앱에서는 별만을 사용하기로 하였기에 react-stars로 대체하였다. 이로써 번들사이즈는 줄었으나 크게 줄진 않았지만, React-rating이 SVG 아이콘을 사용한 것에 비해, react-stars는 ★ 심볼을 사용하여 성능에 크게 영향을 주었다. Lighthouse 검사 결과 TBT가 33% 줄었다.
유저가 정말 필요할때만 Menu가 보이도록 Menu 컴포넌트를 lazy-loading 하기 위해 코드를 분리하였다. 따라서 페이지 로딩 후 메뉴 컴포넌트 로딩을 보장하는 LazyLoadingErrorBoundary를 사용하였다. 이로써 FCP, LCP는 그대로지만, TBT는 71% 개선되었다.
CSS는 render-blocking 리소스이다. 페이지가 렌더되기 전에 반드시 로드되고 프로세스되어야한다. 일부 CSS는 최초 페이지에 보여야한다. 이것들은 Critical CSS이다. 하지만 천천히 로드해도 되는 CSS들도 있다.
next.js 문서에 따라 node module CSS 파일을 /pages/_app.js에 import 했다. react-glider와 react-modal-video가 CSS import를 요구했기 떄문이다. 하지만 _app.js에 CSS import 하는 것은 render-blocking을 일으킨다. 하지만, 해당 CSS들은 모든 페이지에서 필요한 것이 아니다.
따라서 이 컴포넌들이 사용하는 CSS는 컴포넌트가 사용되는 곳에 inline으로 처리하였다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
<div ref="{ref}" className="cast">
+ <Glider
+ hasArrows
+ slidesToShow="{slidesToShow}"
+ slidesToScroll="{1}"
+ itemWidth="{GLIDER_ITEM_WIDTH}"
+ >
+ {cast.map(person => (
+ <PersonLink key="{person.id}" person="{person}" baseUrl="{baseUrl}" />
+ ))}
+ </Glider>
+</div>
+<style jsx>
+ {`
+ /*CSS Classes required for Glider*/
+ `}
+</style>
+
이 변화로, FCP, LCP, TTI에 2~5%의 성능향상이 있었다. 전체 성능도 79%에서 81%로 증가하였다.
Lighthouse에서 CLS에 대한 문제점을 짚어주었다. 어떤 이미지가 CLS을 일으키는지도 알려주었다. 3G와 같은 환경에서는 특히 문제가 될 수 있기에 해결하기로 했다.
aspect-ratio-boxes 기법를 사용하여 이미지의 aspect ratio를 지정하였다. 이로써 페이지가 로딩중이라도 이미지가 요구하는 공간을 충분히 확보하여, 이미지가 로드되었을 때 CLS가 일어나지 않도록 하였다. 이로써 CLS가 0.016에서 0으로 줄어들었다.
테스트 앱을 만든 후 CSS aspect ratio의 브라우저 호환성이 향상되어 잘 작동한다. 따라서 이 기능을 사용하는 것도 좋다.
preconnects를 사용하여 브라우저에게 어떤 리소스를 사용할 것인지 힌트를 줄 수 있다. rel=preconnect를 설정하면 브라우저에게 해당 도메인과 연결을 맺으라고 알려주어 이후 과정을 빠르게 할 수 있다. 이로써 리소스를 빠르게 가져올 수 있다.
1
+2
+
<link rel="preconnect" href="https://image.tmdb.org" />
+<link rel="preconnect" href="https://api.themoviedb.org" />
+
차이는 작지만 다음과 같이 조금 더 빨라진 모습을 볼 수 있다.
| Performance Metric | FCP | Speed Index | LCP | TTI | TBT |
|---|---|---|---|---|---|
| Before | 0.9 | 3.9 | 3.43 | 2.93 | 60 |
| After | 0.83 | 3.5 | 2.86 | 2.63 | 53.33 |
| % Change | 7.77 | 10.25 | 16.61 | 10.23 | 6.67 |
여러 API를 호출할 때, 화면을 그리는데 필요한 API는 다른 API에 의해 늦춰지면 안된다. 따라서 다음과 같은 개선를 줄 수 있다.
| BEFORE | AFTER |
|---|---|
| 장르나 설정같은 메타데이터를 불러오기 위한 API 호출 때문에 영화 포스터를 가져오는 API 요청이 put off 됨 | 메타데이터와 영화 포스터를 동시에 가져오도록 함 |
| 영화 포스터 데이터를 fetch함 | 홈화면을 영화 포스터 데이터와 함께 렌더함 |
유저가 처음 접속했을 때, Popular 장르와 첫번째 페이지를 보여준다는 것이 정해져있음. 따라서 처음 접속한 유저의 API 요청 옵션은 다음과 같음 Genre="popular" page=1
이에 기반하여 홈화면에 사용할 데이터를 preload할 수 있다.
1
+2
+3
+4
+5
+6
+
<link
+ rel="preload"
+ as="fetch"
+ href="https://api.themoviedb.org/3/movie/popular?api_key=844dba0bfd8f3a4f3799f6130ef9e335&page=1"
+ crossorigin="true"
+/>
+
하지만 이 데이터가 사용되지 않으면 불필요한 네트워크 비용이 발생하니 잘 사용하자.
모든 페이지에서 보이는 logo와 TMDB tademark를 preloading하여 FCP와 Speed Index를 5~6% 향상시켰다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
<link
+ rel="preload"
+ href="{LOGO_IMAGE_PATH}"
+ as="image"
+ media="(min-width: 80em)"
+/>
+<link
+ rel="preload"
+ href="{DARK_TMDB_IMAGE_PATH}"
+ as="image"
+ media="(prefers-color-scheme: dark) and (min-width: 80em)"
+/>
+<link
+ rel="preload"
+ href="{LIGHT_TMDB_IMAGE_PATH}"
+ as="image"
+ media="(prefers-color-scheme: light) and (min-width: 80em)"
+/>
+
window 객체를 모른다. 따라서 window.matchmedia()와 같은 메서드는 사용할 수 없다. 거기다 client hints 또한 모든 브라우저에서 지원되는 것은 아니다.이러한 어려움을 극복하기 위해 @artsy/fresnel 라이브러리를 사용하였다. 이로써 CSS breakpoint로 DOM의 모든 엘리먼트를 서버에서 렌더할 수 있다. 그리고 그 breakpoint에 일치하는 컴포넌트만 마운트된다. 이 방식으로, 중복된 마크업과 불필요한 렌더링을 방지했다.
| PERFORMANCE PARAMETER | FCP (S) | SPEED INDEX (S) | LCP (S) | TTI (S) | TBT (MS) |
|---|---|---|---|---|---|
| Before | 0.93 | 3.73 | 2.6 | 2.63 | 60 |
| After | 1.06 | 3.23 | 2.66 | 2.66 | 63.33 |
| % Change | 13.97 | 13.4 | 2.3 | 1.14 | 5.55 |
@artsy/fresnel 번들이 포함되어 몇몇 지수에서는 성능이 악화되었으나, Speed Index는 빨라졌다. 마크업 코드를 줄일 수 있는 것도 좋은 trade-off 이다.
Lighthouse의 피드백에 기반하여 몇가지 대책을 세웠으나 성능상 이점이 없었던 아이디어들 모음
react-lazyload 패키지 대체react-lazyload 패키지를 lazy loading image를 위해 사용하고 있었다. 이 패키지는 메인 스레드를 오래 사용하였다. 이것을 native iamge lazy-loading으로 대체하려 했다.react-lazyload는 뷰포트 안에 있는 이미지만을 로드하기 때문일 수 있다.Aspect Ratio for Images를 세팅하기 전에 CLS를 향상시키기 위해 image dimension을 설정하였다.<Image /> 와 달리, HTML/CSS로 이루어진 가벼운 컴포넌트 사용성능 개선을 위해서 다음과 같은 사항을 고려해볼 수 있다.
현재 사용하고 있는 패키지에 불필요한 기능까지 포함하고 있는지, 번들 사이즈는 어느정도인지, 상세 구현이 어떻게 되어있는지(SVG? symbol?) 등을 따져봐서 패키지를 좀 더 가볍고 빠른 것으로 대체할 수 있다.
유저가 최초로 랜딩할 페이지에서 필요없는 자원들을 가져오지 않도록 적절히 코드/리소스를 분리한다.
API, 이미지 등을 불러올 때, 랜딩 페이지에서 우선적으로 보여야하는 것들을 다른 것들보다 느리게 불러오지 않도록 한다.ㄴ
CLS를 줄이기 위해 aspect ratio를 지정하거나, Next.js의 Image 컴포넌트를 사용할 수 있다.
https://www.patterns.dev/posts/nextjs-casestudy
Comments powered by Disqus.
노드 콘솔은 REPL이라하는데 이유는
노드는 코드를 모듈로 만들 수 있다는 점에서 브라우저의 자바스크립트와는 다르다.
require(‘./var’); 로 불러오고, module.exports = 로 export함
자바스크립트 자체 모듈
1
+2
+3
+4
+5
+
exports.a = "a";
+exports.b = "b";
+//이렇게 내보내고
+import importTemp from "./temp";
+//이렇게 받음. 이름은 달라도 됨. exports 객체를 받는 것이기에
+
1
+2
+3
+
const url = require("url");
+const { URL } = url; // WHATWG 방식의 생성자 들어감.
+const myURL = new URL("https://naver.com");
+
1
+2
+3
+4
+5
+
const crypto = require("crypto");
+console.log(
+ "base64",
+ crypto.createHash("sha512").update("비밀번호").digest("base64")
+);
+
1
+2
+3
+4
+5
+6
+7
+8
+
//random으로 64바이트 문자열을 만듬.
+crypto.randomBytes(64, (err, buf) => {
+ const salt = buf.toString("base64");
+ //비밀번호, salt, 반복횟수, 출력바이트, 해시알고리즘 순으로 넣음.
+ crypto.pbkdf2("비밀번호", salt, 100000, 64, "sha512", (err, key) => {
+ console.log("password:", key.toString("base64"));
+ });
+});
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
const algorithm = "aes-256-cbc";
+const key = "abcdefghijklmnopqrstuvwxyz123456";
+const iv = "1234567890123456";
+//암호화
+const cipher = crypto.createCipheriv(algorithm, key, iv);
+let result = cipher.update("암호화할 문장", "utf8", "base64");
+result += cipher.final("base64");
+//복호화
+const decipher = crypto.createDecipheriv(algorithm, key, iv);
+let result2 = decipher.update(result, "base64", "utf8");
+result2 += decipher.final("utf8");
+
1
+2
+3
+4
+5
+6
+7
+8
+
const fs = require("fs"); //require('fs').promises; 로하면 프로미스형태로 사용가능.
+fs.readFile("./readme.txt", (err, data) => {
+ if (err) {
+ throw err;
+ }
+ console.log(data); // 읽은 데이터는 버퍼형식으로 반환됨.
+ console.log(data.toString()); // 읽을 수 없으므로 toString()으로 변환 시켜줌
+});
+
write : fs.writeFile(경로, 내용);
동기 메소드와 비동기메소드
버퍼와 스트림
1
+
const buffer = Buffer.from("저를 버퍼로 바꾸세요");
+
fs.createReadStream(path, option), fs.writeReadStream(path, option)
1
+2
+3
+4
+5
+6
+7
+8
+9
+
const readStream = fs.createReadStream("./readme3.txt", {
+ highWaterMark: 16,
+});
+const data = [];
+
+readStream.on("data", (chunk) => {
+ data.push(chunk);
+ console.log("data :", chunk, chunk.length);
+});
+
기타 fs메소드
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
- req : 요청에 관한 정보
+- res : 응답에 관한 정보.
+ - .writeHead : 헤더. 응답에 대한 정보를 기록하는 메서드.
+ - 첫번째 인수 : 코드
+ - 두번째 인수 : 응답에 대한 정보를 알림.
+ - .write : 본문(Body)
+ - 첫번째 인수 - 클라이언트로 보낼 데이터. 여러번 호출해서 데이터를 여러개 보내도 됨.
+ - .end : 응답을 종료함. 여기에도 데이터를 넣어서 보낼 수 있음.
+- 서버가 실행되면, 해당 포트번호에서 요청이 오기를 기다림
+- listen 메소드 : 포트번호와 콜백함수를 넣음.
+- 이벤트 리스너 : 서버에 이벤트리스너를 등록할 수 있음. ex) server.on('listening', () => {}) 으로 함.
+ - 'listening' : 연결됐을때 발생함. listen 메소드의 콜백함수 대신에 사용해도 됨.
+ - 'error' : 서버에 에러가 발생했을 때 발생.
+
1
+2
+3
+4
+5
+6
+7
+8
+
- 코드
+ - 2xx : 성공
+ - 3xx : 리다이렉션
+ - 4xx : 요청 오류
+ - 5xx : 서버오류
+- 포트번호 : 80번을 사용하면 주소에서 포트를 생략할 수 있음. https 일경우 443번
+ - 실제로 배포할 땐 80번 혹흥 443번 포트를 사용
+- 응답은 무조건 보내야한다. 아니면 클라이언트는 하염없이 기다리게 됨.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
- REST : REpresentational State Transfer. 서버의 자원을 정의하고 자원에 대한 주소를 지정하는 방법. 일종의 약속
+ - 주소뿐만 아니라 GET, POST, PUT, PATCH, DELETE, OPTIONS 등의 메서드와 함께 사용됨.
+ - GET : 자원을 가져올 때. 요청의 본문에 데이터를 넣지 않음. 쿼리 데이터로 보냄.
+ - 브라우저에서 캐싱할 수 있으므로 같은 주소로 보낼때 성능이 좋아짐.
+ - post : 자원을 등록할 때. 요청의 본문에 새로 등록할 데이터를 넣어보냄
+ - PUT : 서버의 자원을 요청에 들어있는 자원으로 치환할때 사용. 본문에 데이터를 넣음
+ - PATCH : 서버의 자원의 일부만 수정하고자할 때 사용. 본문에 데이터를 넣음
+ - DELETE : 서버의 자원을 삭제하고자 할 때 사용. 데이터를 넣지 않음
+ - OPTIONS : 요청을 하기 전에 통신 옵션을 설명하기 위해 사용.
+ - 만약 로그인 같은 애매한 동작이 있다면 그냥 POST 하면 된다.
+
+- 이렇게 REST 방식으로 하게 되면, 클라이언트에 구애받지 않고 사용할 수 있어서 좋다.
+
+- RESTful 서버구조
+
| HTTP 메서드 | 주소 | 역할 |
|---|---|---|
| GET | / | restFront.html 파일 제공 |
| GET | /about | about.html 파일 제공 |
| GET | /users | 사용자 목록 제공 |
| GET | 기타 | 기타정적파일제공 |
| POST | /user | 사용자 등록 |
| PUT | /user/사용자id | 해당 id의 사용자 수정 |
| DELETE | /user/사용자id | 해당 id의 사용자 제거\ |
1
+2
+3
+4
+5
+6
+7
+8
+9
+
- 라우팅
+ - req.method 로 GET, POST 등 HTTP 요청 메소드를 구분할 수 있음
+ - req.url 로 요청한 url을 구분할 수 있음.
+
+- req.on('data', callback)
+ - 요청의 본문에 들어있는 데이터를 꺼내는 작업.
+ - req, res 는 내부적으로 스트림으로 되어있기에 요청/응답의 데이터가 스트림 형식으로 전달.
+ - 또 .on 에서 알수 있듯이 이벤트도 달려있음.
+ - 이때 받은 데이터는 문자열이므로 JSON 형식으로 만드는 JSON.parse 과정이 필요하다.
+
1
+
- res.end 를 한다고 함수가 끝나지 않는다. 따라서 중간에 끝내야할땐 return res.end() 를 한다.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
- 클라이언트가 누구인지 구분하기위해, 서버는 응답을 할 때 쿠키를 생성하여 같이 보냄.
+- 쿠키는 유효기간이 있으며, 단순한 키-값 쌍임.
+- 서버로부터 쿠키가 오면 브라우저는 저장해뒀다가 다음에 요청을 보낼때 쿠키도 함께 보냄.
+- 서버는 동봉된 쿠키를 보고 누구인지 파악함.
+
+- req.headers.cookie 에 쿠키가 들어있음.
+- res.writeHead(200, {'Set-Cookie':'mycookie=test'; Expires= ${expires.toGMTString()}; HttpOnly; Path=/`,});
+ - 쿠키 작성해서 보내는 법은 이렇게. 옵션사이는 ; 로 구분
+ - Expires 옵션으로 언제 삭제할지 설정가능. 기본은 클라이언트가 종료될때까지.
+ - HttpOnly 옵션 : 자바스크립트에서 접근할 수 없도록 함.
+ - Path=URL : 쿠키가 전송될 URL을 특정. 기본은 /. 모든 URL에서 전송가능.
+ - Max-age=초 : 날짜대신 초를 입력할 수 있음.
+ - Secure : HTTPS 일 경우에만 쿠키를 전송함.
+ - Domain=도메인명 : 쿠키가 전송될 도메인을 특정
+
+- 세션 : 서버에 사용자 정보를 저장하고, 클라이언트와는 세션 아이디로만 소통함.
+ - 쿠키에 세션 아이디를 저장하고, 그 세션 아이디로 서버에 있는 정보를 접근하는 것.
+ - 꼭 쿠키를 쓰지 않아도 되는데, 대부분은 쿠키가 간단해서 쿠키를 쓴다. 이를 세션 쿠키라고 함.
+
1
+2
+3
+4
+
- url 모듈
+ - url.parse(req.url) : 요청 url을 파스함
+- qs.parse(query) : 쿼리를 파스하여 JSON 형태로 바꿔줌.
+- encodeURIComponent() : 헤더에는 한글을 설정할 수 없으므로, 인코딩하는 메소드
+
1
+2
+3
+4
+
- https : 웹 서버에 SSL 암호화를 추가합니다.
+ - GET이나 POST 요청을 할 때 오가는 데이터를 암호화해서 중간에 다른 사람이 요청을 가로채더라도 내용을 확인할 수 없게함.
+ - 인증서를 인증기관에서 구입해야 사용가능.(Let's Encrypt 같은 기관에서 무료로 발급)
+ - 인증서가 있다면 다음과 같이
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+
const https = require("https");
+
+const fs = require("fs");
+
+https
+ .createServer(
+ {
+ cert: fs.readFileSync("도메인 인증서 경로"),
+ key: fs.readFileSync("도메인 비밀키 경로"),
+ ca: [
+ fs.readFileSync("상위 인증서 경로"),
+ fs.readFileSync("상위 인증서 경로"),
+ ],
+ },
+ (req, res) => {
+ res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+ res.write("<h1>Hello Node!</h1>");
+ res.end("<p>Hello Server!</p>");
+ }
+ )
+ .listen(443, () => {
+ console.log("443번 포트에서 서버 대기 중입니다!");
+ });
+
1
+2
+
- http2 : SSL 암호화와 더불어 최신 HTTP 프로토콜인 http/2 를 사용할 수 있게함.
+ - 기존 1.1 보다 요청 및 응답 방식이 개선되고, 속도고 많이 개선 됨.
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+
- cluster 모듈 : 기본적으로 싱글 프로세스로 동작하는 노드가 CPU 코어를 모두 사용할 수 잇도록 하는 모듈. 포트를 공유하는 노드 프로세스를 여러 개 둘 수 있어서, 요청이 많이 들어왔을 때 병렬로 실행된 서버의 개수만큼 요청이 분산되게 함.
+ -> 스레드가 아니라 프로세스임.
+
+- 단점 : 메모리를 공유하지 못함. / 세션을 메모리에 저장하는 경우 문제가 됨. -> 레디스로 해결
+
+- 마스터 프로세스 : 요청이 들어오면, 만들어진 워커 프로세스에 요청을 분배함.
+- 워커 프로세스 : 실질적인 일을 하는 프로세스
+
+- 실무에서는 pm2 등의 모듈로 cluster를 처리함.
+
Comments powered by Disqus.
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
const express = require("express");
+
+const app = express();
+app.set("port", process.env.PORT || 3000);
+
+app.get("/", (req, res) => {
+ res.send("Hello, Express");
+});
+
+app.listen(app.get("port"), () => {
+ console.log(app.get("port"), "번 포트에서 대기 중");
+});
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+
app.use((req, res, next) => {
+ console.log("모든 요청에 다 실행됩니다.");
+ next();
+});
+app.use("/abc", (req, res, next) => {
+ // abc로 시작하는 요청에 실행
+ console.log("abc로 시작하는 요청에 실행됩니다.");
+ next();
+});
+app.get("/abc", (req, res, next) => {
+ // abc로 시작하는 get 요청에 실행.
+ console.log("abc로 시작하는 get 요청에 실행됩니다.");
+ next();
+});
+app.post("/abc", (req, res, next) => {
+ // abc로 시작하는 post 요청에 실행.
+ console.log("abc로 시작하는 post 요청에 실행됩니다.");
+ next();
+});
+app.get(
+ // 여러개 등록
+ "/",
+ (req, res, next) => {
+ console.log("GET / 요청에서만 실행됩니다.");
+ next();
+ },
+ (req, res) => {
+ throw new Error("에러는 에러 처리 미들웨어로 갑니다.");
+ }
+);
+app.use((err, req, res, next) => {
+ console.error(err);
+ res.status(500).send(err.message);
+});
+
위 예에서 볼 수 있듯이, app.get, app.post 등과 같은 것들도 next를 인자로 받아 미들웨어로 활용할 수 있음.
또 마지막 바로 위 예시에서처럼, 여러개를 등록할 수 있다. 여기선 에러가 발생하는데. 이렇게 에러가 발생시 그 아래에 에러처리 미들웨어에 전송됨.
에러처리 미들웨어 : 매개변수가 반드기 네 개여야함. 가장 아래 위치/
미들웨어는 위에서부터 아래로 순서대로 실행됨.
dotenv 패키지
1
+2
+3
+
app.use("요청 경로", express.static("실제 경로"));
+
+app.use("/", express.static(path.join(__dirname, "public")));
+
1
+2
+3
+
app.use(express.json());
+app.use(express.urlencoded({ extended: false }));
+// false이면 내장된 querystring을 사용하고, true면 npm 패키지인 qs를 사용
+
app.use(cookieParser(비밀키));
1
+2
+3
+4
+5
+6
+
res.cookie("name", "zerocho", {
+ expires: new Date(Date.now() + 900000),
+ httpOnly: true,
+ secure: true,
+});
+res.clearCookie("name", "zerocho", { httpOnly: true, secure: true });
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
app.use(
+ session({
+ resave: false,
+ saveUninitialized: false,
+ secret: process.env.COOKIE_SECRET,
+ cookie: {
+ httpOnly: true,
+ secure: false,
+ },
+ name: "session-cookie",
+ })
+);
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
app.use(morgan("dev"));
+// 또는
+app.use((req, res, next) => {
+ morgan("dev")(req, res, next);
+});
+
+// 위 두개는 같은 작업을 함.
+// 아래처럼 할 시 유용하다.
+app.use((req, res, next) => {
+ if (process.env.NODE_ENV === "production") {
+ morgan("combined")(req, res, next);
+ } else {
+ morgan("dev")(req, res, next);
+ }
+});
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+
const multer = require("multer");
+
+// 기본 설정
+const upload = multer({
+ storage: multer.diskStorage({
+ destination(req, file, done) {
+ done(null, "uploads/");
+ },
+ filename(req, file, done) {
+ const ext = path.extname(file.originalname);
+ done(null, path.basename(file.originalname, ext) + Date.now() + ext);
+ },
+ }),
+ limits: { fileSize: 5 * 1024 * 1024 },
+});
+
+//upload 에 있는 미들웨어 사용
+// single : 하나만 업로드하는 경우.
+app.post("/upload", upload.single("image"), (req, res) => {
+ console.log(req.file, req.body);
+ res.send("ok");
+});
+// html form에 multiple로 설정되어 여러가지가 오는 겨웅
+// array로 교체
+app.post("/upload", upload.array("many"), (req, res) => {
+ console.log(req.files, req.body);
+ res.send("ok");
+});
+
+//여러개를 업로드하지만, input 태그나 폼 데이터의 키가 다른 경우엔 fields 사용
+app.post(
+ "/upload",
+ upload.fields([{ name: "image1" }, { name: "image2" }]),
+ (req, res) => {
+ console.log(req.files, req.body);
+ res.send("ok");
+ }
+);
+
+// 파일을 업로드하지 않고, 멀티파트 형식으로 업로드하는 경우. none 사용
+app.post("/upload", upload.none(), (req, res) => {
+ console.log(req.body);
+ res.send("ok");
+});
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
//routes/user.js
+const express = require("express");
+
+const router = express.Router();
+
+router.get("/", (req, res) => {
+ res.send("Hello, User");
+});
+
+module.exports = router;
+
+// app.js
+const userRouter = require("./routes/user");
+app.use("/user", userRouter);
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
router.get(
+ "/",
+ function (req, res, next) {
+ next("route");
+ },
+ function (req, res, next) {
+ console.log("실행되지 않습니다");
+ next();
+ },
+ function (req, res, next) {
+ console.log("실행되지 않습니다");
+ next();
+ }
+);
+router.get("/", function (req, res) {
+ console.log("실행됩니다");
+ res.send("Hello, Express");
+});
+
1
+2
+3
+4
+5
+6
+7
+
router.get("/user/:id", function (req, res) {
+ res.send("Hello, Express");
+});
+// 도달불가
+router.get("/user", function (req, res) {
+ res.send("Hello, Express");
+});
+
1
+2
+3
+4
+5
+6
+7
+8
+
router
+ .route("/abc")
+ .get((req, res) => {
+ res.send("GET /abc");
+ })
+ .post((req, res) => {
+ res.send("POST /abc");
+ });
+
확장된 것들
1
+
res.status(201).cookie("test", "test").redirect("/admin");
+
템플릿 엔진 : 자바스크립트를 사용해서 HTML 을 렌더링 -> 따라서 효율적인 HTML 작성을 하게 해줌.
퍼그(pug)
1
+2
+
app.set("views", path.join(__dirname, "views"));
+app.set("view engine", "pug");
+
1
+
res.render("index", { title: "Express" });
+
1
+2
+
res.locals.title = "Express";
+res.render("index");
+
넌적스
1
+2
+3
+4
+5
+6
+7
+
const nunjucks = require("nunjucks");
+app.set("view engine", "html");
+
+nunjucks.configure("views", {
+ express: app,
+ watch: true,
+});
+
에러처리 미들웨어 : 새로운게 아니라 그냥 배운 템플릿엔진으로 에러처리 미들웨어 구현하는 것.
Comments powered by Disqus.
데이터 베이스 생성 : CREATE SCHEMA [데이터베이스명]
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
CREATE TABLE nodejs.users (
+ -> id INT NOT NULL AUTO_INCREMENT,
+ -> name VARCHAR(20) NOT NULL,
+ -> age INT UNSIGNED NOT NULL,
+ -> married TINYINT NOT NULL,
+ -> comment TEXT NULL,
+ -> created_at DATETIME NOT NULL DEFAULT now(),
+ -> PRIMARY KEY(id),
+ -> UNIQUE INDEX name_UNIQUE (name ASC))
+ -> COMMENT = '사용자 정보'
+ -> DEFAULT CHARACTER SET = utf8
+ -> ENGINE = InnoDB;
+
컬럼 선언 : () 안에 선언함. [컬럼명 자료형 옵션] 으로 구성
ex : id INT NOT NULL AUTO_INCREMENT
자료형
옵션
테이블 자체 옵션
Create : 그냥 데이터를 넣는 것.
read : SELECT (컬럼, 컬럼) FROM [테이블명]
| ORDER BY [컬럼명] [ASC | DESC] |
Update : UPDATE [테이블명] SET [컬럼명=바꿀값] WHRER [조건]
Delete : DELETE FROM [테이블명] WHERE [조건]
설치 : sequelize, sequelize-cli, mysql2
설치 후 sequelize init 명령어로 초기화 -> config, models, migrations, seeders 폴더 생성
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
const Sequelize = require("sequelize");
+
+const env = process.env.NODE_ENV || "development";
+const config = require("../config/config")[env];
+const db = {};
+
+const sequelize = new Sequelize(
+ config.database,
+ config.username,
+ config.password,
+ config
+);
+db.sequelize = sequelize;
+
+module.exports = db;
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
const { sequelize } = require("./models");
+...
+sequelize
+ .sync({ force: false }) // 서버 실행 시 mysql 연결. force:true 일 경우, 서버 실행 시 마다 테이블을 재생성함. 테이블을 잘못만든 경우 true로 설정
+ .then(() => {
+ console.log("데이터베이스 연결 성공");
+ })
+ .catch((err) => {
+ console.error(err);
+ });
+
+
모델 함수
| MySQL | 시퀄라이즈 |
|---|---|
| VARCHAR(100) | STRING(100) |
| INT | INTEGER |
| TINYINT | BOOLEAN |
| DATETIME | DATE |
| INT UNSIGNED | INTEGER.UNSIGNED |
| NOT NULL | allowNull: false |
| UNIQUE | unique: true |
| DEFAULT now() | defaultValue: Sequelize.NOW |
대응
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+
SELECT * FROM nodejs.users;
+User.findAll({});
+
+SELECT * FROM nodejs.users LIMIT 1;
+User.findOne({});
+
+SELECT name, married FROM nodejs.users;
+User.findAll({
+ attributes: ['name', 'married'],
+});
+
+SELECT name, age FROM nodejs.users WHERE married = 1 AND age > 30;
+const { Op } = require('sequelize');
+const { User } = require('../models');
+User.findAll({
+ attributes: ['name', 'age'],
+ where: {
+ married: 1,
+ age: { [Op.gt]: 30 }, // 시퀄라이즈는 자바스크립트 객체를 사용하여 쿼리를 생성하므로, 특수 연산자 사용. Op.gt 은 operator greater than 임.
+ },
+});
+
+//Op.or 사용
+SELECT id, name FROM users WHERE married = 0 OR age > 30;
+const { Op } = require('sequelize');
+const { User } = require('../models');
+User.findAll({
+ attributes: ['id', 'name'],
+ where: {
+ [Op.or]: [{ married: 0 }, { age: { [Op.gt]: 30 } }],
+ },
+});
+
+//Order by
+SELECT id, name FROM users ORDER BY age DESC;
+User.findAll({
+ attributes: ['id', 'name'],
+ order: [['age', 'DESC']],
+});
+
+SELECT id, name FROM users ORDER BY age DESC LIMIT 1;
+User.findAll({
+ attributes: ['id', 'name'],
+ order: [['age', 'DESC']],
+ limit: 1,
+});
+
+SELECT id, name FROM users ORDER BY age DESC LIMIT 1 OFFSET 1;
+User.findAll({
+ attributes: ['id', 'name'],
+ order: ['age', 'DESC'],
+ limit: 1,
+ offset: 1,
+});
+
1
+2
+3
+4
+5
+6
+
UPDATE nodejs.users SET comment = '바꿀 내용' WHERE id = 2;
+User.update({
+ comment: '바꿀 내용',
+}, {
+ where: { id: 2 },
+});
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
+INSERT INTO nodejs.users (name, age, married, comment) VALUES ('zero', 24, 0, '자기소개1');
+const { User } = require('../models');
+User.create({
+ name: 'zero',
+ age: 24,
+ married: false,
+ comment: '자기소개1',
+});
+
+
1
+2
+3
+4
+
DELETE FROM nodejs.users WHERE id = 2;
+User.destory({
+ where: { id: 2 },
+});
+
1
+2
+3
+4
+5
+6
+7
+8
+
// 특정사용자를 가져오면서, 댓글까지 모두 가져오고 싶을때
+const user = await User.findOne({
+ include: [
+ {
+ model: Comment,
+ },
+ ],
+});
+
1
+2
+3
+4
+5
+
db.User.hasMany(db.Comment, {
+ foreignKey: "commenter",
+ sourceKey: "id",
+ as: "Answers",
+});
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
const user = await User.findOne({
+ include: [
+ {
+ model: Comment,
+ where: {
+ id: 1,
+ },
+ attributes: ["id"],
+ },
+ ],
+});
+// 또는
+const comments = await user.getComments({
+ where: {
+ id: 1,
+ },
+ attributes: ["id"],
+});
+
1
+2
+3
+4
+
const user = await User.findOne({});
+const comment1 = await Comment.create();
+const comment2 = await Comment.create();
+await user.addComment([comment1, comment2]);
+
1
+2
+
const [result, metadata] = await sequelize.query("SELECT * from comments");
+console.log(result);
+
Comments powered by Disqus.
E-R 다이어그램을 사용하여 객체의 행위를 모델링.
객체 식별, 구조 식별, 주제정의, 속성과 인스턴스 연결 정의, 연산과 메시지 연결 정의 등의 과정으로 주로 관계를 분석 하는 기법
미시적, 거시적 개발 프로세스를 모두 사용하는 분석 방법.
클래스와 객체들을 분석 및 식별하고 클래스의 속성과 연산을 정의
UseCase를 사용하여 분석.
분석과 설계간 구분이 없으며, 고객 명세서를 평가해서 설계작업까지 연속적으로 수행하는 기법
https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=agopwns&logNo=220998991245
Comments powered by Disqus.
OOP는 너무 거대한 개념이라 다 다루지는 못하지만 간단히만 알아보자
OOP : 중심적 프로그래밍 패러다임. 현실 세계의 사물들을 객체라고 보고, 그 객체로부터 개발하고자 하는 애플리케이션에 필요한 특징들을 뽑아와 프로그래밍하는 것(추상화)
장점
OOP로 작성한 코드는 재사용성이 높다.
자주 사용되는 로직을 라이브러리로 만들어두면 개발로드가 줄어들고, 신뢰성도 확보가 됨
객체 단위로 코드가 나뉘어져있어 디버깅과 유지보수가 쉽다.
데이터 모델링 할때, 객체와 매핑하는 것이 훨씬 수월하기에 요구사항을 보다 명확하게 파악하여 프로그래밍 가능
단점
객체가 상태를 가짐
객체 안에는 변수가 존재하고, 이 변수를 통해 객체가 예측할 수 없는 상태를 갖게 되어 어플리케이션 내부에서 버그를 발생시킴
-> 따라서 함수형 프로그래밍을 발전 시켜 해결하고자 함
객체 지향적 설계원칙(SOLID)
정의
시그니처
인터페이스
메시지
책임
객체마다 자신만이 제공할 수 있는 기능에 대한 책임이 있다.
객체가 갖는 책임의 크기는 작을 수록 좋다.
이것을 해결하기 위해, SBP(Single Responsibility Principle) : 단일 책임 원칙이 필요하다.
개방-폐쇄 원칙
OCP 원칙이다.리스코프 치환 원칙
상위 타입의 객체를 하위 타입의 객체로 치환해도 상위 타입을 사용하는 프로그램은 정상적으로 동작해야한다.
상위 타입인 fruits에 하위타입인 Apple이 있다면, fruits를 사용하는 곳에서는 Apple을 사용해도 문제 없도록 해야한다.
위배한 예시
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
public class Rectangle {
+ private int width;
+ private int height;
+
+ public void setWidth(final int width) {
+ this.width = width;
+ }
+
+ public void setHeight(final int height) {
+ this.height = height;
+ }
+
+ public int getWidth() {
+ return width;
+ }
+
+ public int getHeight() {
+ return height;
+ }
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
public class Square extends Rectangle {
+
+ @Override
+ public void setWidth(final int width) {
+ super.setWidth(width);
+ super.setHeight(width);
+ }
+
+ @Override
+ public void setHeight(final int height) {
+ super.setWidth(height);
+ super.setHeight(height);
+ }
+}
+
리스코프 치환원칙은 기능의 명세와 확장에 대한 것이다.
의존성
DIP(Dependency Inversion Principle) : 의존 역전 원칙이 필요하다인터페이스 분리 원칙
인터페이스는 그 인터페이스를 사용하는 클라이언트를 기준으로 분리해야한다.
특정 클라이언트를 위한 인터페이스를 여러개 만드는 것이 범용 인터페이스 하나보다 낫다
예시
ISP를 적용하기 전
1
+2
+3
+4
+5
+6
+
// ISP를 적용하지 않은 예제
+public interface multifunction {
+ void copy();
+ void fax(Address from, Address to);
+ void print();
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
public class CopyMachine implements multifunction {
+ @Override
+ public void copy() {
+ System.out.println("### 복사 ###");
+ }
+
+ @Override
+ public void fax(Address from, Address to) {
+ // 사용하지 않는 인터페이스가 변경되어도 함께 수정이 일어난다.
+ }
+
+ @Override
+ public print() {
+ // 사용하지 않는 인터페이스가 변경되어도 함께 수정이 일어난다.
+ }
+}
+
ISP를 적용한 이후
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
// ISP가 적용된 예제
+public interface Print{
+ void print();
+}
+
+public interface Copy {
+ void copy();
+}
+
+public interface Fax {
+ void fax(Address from, Address to);
+}
+
1
+2
+3
+4
+5
+6
+
public class copyMachine implements Copy {
+ @Override
+ void copy() {
+ System.out.println("### 복사 ###");
+ }
+}
+
캡슐화
객체가 내부적으로 기능을 어떻게 구현하는지를 숨기는 것
캡슐화를 위한 두 개의 규칙
Tell, Don’t Ask
데이터를 물어보지 않고, 기능을 실행해 달라고 말하라는 규칙이다.
데이터를 읽는 것은 데이터를 중심으로 코드를 작성하게 만드는 원인이 된다.
데이터를 private로 클래스 내부에 숨기고, 메소드를 통해 데이터에 접근해야한다.
1
+2
+3
+4
+5
+6
+
public class Customer {
+ private Wallet wallet;
+ public Wallet getWallet() {
+ return wallet;
+ }
+}
+
데미테르 법칙 : 한 객체 안에서 다른 객체의 메서드를 부를때는 다음 상황일때만이다.
객체 조립 : 위 단점의 해소법
상속은 언제 사용하는가?
https://asfirstalways.tistory.com/177
Comments powered by Disqus.
HTML문서의 head에는 <meta> 태그로 사이트의 정보가 표기되어있는 경우가 많다. 이는 크롤러가 무엇이 제목이고, 무엇이 내용인지 파악하기 쉽도록 하기 위해서 표기한 것이다.
페이스북의 Open Graph 프로토콜은 이러한 메타태그의 표기 방법은 통일한 것이다. 이 Open Graph 프로토콜이 우리가 보는 미리보기 화면의 실체를 구성하는 메타 데이터 표기 방법이다.
작동원리
og:title, og:description, og:image은 각각 제목, 설명, 이미지의 정보를 나타낸다.기본 메타데이터
1
+2
+3
+4
+5
+6
+7
+8
+
<!-- 제목 -->
+<meta property="og:title" content="제목" />
+<!-- type -->
+<meta property="og:type" content="website" />
+<!-- 이미지 -->
+<meta property="og:image" content="이미지 경로" />
+<!-- canonical link(대표 URL) -->
+<meta property="og:url" content="url" />
+
옵션 메타데이터
og:audio
og:description
1
+2
+
<!-- 설명 -->
+<meta property="og:description" content="내용<br/>줄바꿈" />
+
og:determiner
og:locale
og:local:alternate
og:site_name
og:video
트위터는 자사의 메타데이터 표기법을 가지고 있다. 하지만, 웹사이트에 오픈그래프 프로토콜만 있을 경우엔 오픈그래프를 가져온다.
서버 자원을 아끼기 위해 캐싱된 HTML을 불러오기 때문이다.
페이스북에선 Sharing Debugger, 카카오스토리에서는 내부 개발자도구를 통해 캐싱 삭제를 할 수 있다.
내가 바로 쓴 글을 페이스북에 올리면 바로 조회수가 올라간다. 그 이유는 크롤러가 우리 사이트를 한번 미리 방문하기 때문에 조회수 1이 올라가기 때문이다. 구글과 같이 방금 조회한 사람이 크롤러라는 것을 알려주는 경우도 잇지만, 페이스북은 그렇지 않다.
og:title, og:description, og:image 는 반드시 명시한다.
https://blog.ab180.co/posts/open-graph-as-a-website-preview
Comments powered by Disqus.
실행중인 프로그램으로, 메모리에 적재되어 CPU의 할당을 받을 수 있는 것을 말함.
OS로부터 주소공간, 파일, 메모리등을 할당받으며, 이것들을 총칭하여 프로세스라고한다.
할당받는 메모리 공간
프로세스 제어 블록(Process Control Block, PCB)
PCB는 특정 프로세스에 대한 중요한 정보를 저장하고 있는 OS의 자료구조이다. OS는 프로세스를 관리하기 위해 프로세스의 생성과 동시에 고유한 PCB를 생성한다.
프로세스는 CPU를 할당받아 작업을 처리하다가도, 시간이 지나면 진행하던 작업을 저장하고 CPU를 반환해야하는데, 이때 작업의 진행상항은 PCB에 저장하게 된다. 그리고 다시 CPU를 할당 받으면 PCB에 저장된 내용을 불러와 이전에 종료된 시점부터 다시 수행한다.
PCB에 저장되는 정보
프로세스의 실행단위. 한 프로세스 내에서 동작되는 여러 실행흐름으로 프로세스 내의 주소 공간이나 자원을 공유할 수 있음.
스레드는 스레드 ID, 프로그램 카운터, 레지스터 집합, 스택으로 구성된다. 같은 프로세스에 속한 다른 스레드와 코드, 데이터 섹션, 그리고 열린파일이나 신호와 같은 운영체제 자원들을 공유한다.
하나의 프로세스를 다수의 실행단위로 구분하여 자원을 공유하고 자원의 생성과 관리의 중복성을 최소화하여 수행 능력을 향상 시키는 것을 멀티 스레딩이라고 한다. 이 경우 각각의 스레드는 독립적인 작업을 수행해야 하기 때문에 각자의 스택과 PC 레지스터 값을 갖고 있다.
스택을 스레드마다 독립적으로 할당하는 이유
스택은 함수 호출시 전달되는 인자, 되돌아갈 주소값 및 함수 내에서 선언하는 변수 등을 저장하기 위해 사용되는 메모리 공간이므로, 스택 메모리 공간이 독립적이라는 것은 독립적인 함수 호출이 가능하다는 것이고, 이는 독립적인 실행 흐름이 추가되는 것이다. 따라서 스레드의 정의에 따라 독립적인 실행 흐름을 추가하기 위한 최소 조건으로 독립된 스택을 할당한다.
PC 레지스터를 스레드마다 독립적으로 할당하는 이유
PC 값은 스레드가 명령어의 어디까지 수행하였는지를 나타나게 된다. 스레드는 CPU를 할당 받았다가 스케쥴러에 의해 다시 선점당한다. 그렇기 때문에 명령어가 연속적으로 수행되지 못하고 어느 부분까지 수행했는지 기억할 필요가 있다. 따라서 PC 레지스터를 독립적으로 할당한다.
멀티 스레딩의 장점
여러 프로세스를 이용하여 동시에 처리하던 일을 스레드로 구현할 경우, 메모리 공간과 시스템 자원 소모가 줄어들게 된다. 스레드간의 통신이 필요한 경우에도 전역 변수의 공간 또는 Heap 영역을 사용하여 데이터를 주고받을 수 있다. 그렇기 때문에 프로세스 간 통신보다 통신방법이 훨씬 간단하다. 심지어 스레드의 context switch는 프로세스 context switch와는 달리 캐시 메모리를 비울 필요가 없기 때문에 더 빠르다. 따라서 시스템의 throughput이 향상되고 자원소모가 줄어들며, 따라서 프로그램은 더욱 빨라진다.
문제점
공유하는 자원이 있다. 따라서 서로 다른 스레드가 데이터와 힙 영역을 공유하기 때문에 어떤 스레드가 다른 스레드에서 사용중인 변수나 자료구조에 접근하여 엉뚱한 값을 읽어오거나 수정할 수 있다.
따라서 멀티스레딩 환경에서는 동기화 작업이 필요하다. 동기화를 통해 작업처리 순서를 컨트롤 하고 공유자원에 대한 접근을 컨트롤 하는 것이다. 하지만 이로인해 병목 현상이 발생하여 성능이 저하될 가능성이 높다. 그러므로 과도한 락으로 인한 병목현상을 줄여야한다.
멀티 스레드 vs 멀티 프로세스
멀티 스레드
멀티 프로세스
두 가지가 서로 상반된 장/단점을 가지고 있기에, 동작하는 시스템에 따라 적합/부적합이 구분된다. 따라서 시스템의 특징에 따라 적합한 동작 방식을 선택하고 적용해야한다.
프로세스를 스케쥴링 하기 위한 3가지 종류의 Queue
각각의 Queue 에 프로세스들을 넣고 빼주는 스케쥴러에도 크게 세 가지 종류가 존재함
많은 프로세스들이 한번에 메모리에 올라올 경우, 대용량메모리(디스크)에 임시로 저장된다. 이 pool에 저장되어있는 프로세스 중 어떤 프로세스에 메모리를 할당하여 ready queue로 보낼지 결정하는 역할을 함
Ready Queue에 있는 프로세스들 대상
특징
먼저 온 순서대로 처리해줌
비선점형(non-preemptive) 스케줄링 : 한번 CPU을 잡으면 CPU burst가 완료될때까지 CPU를 반환하지 않음.
문제점
문제점
문제점
문제점
장점
주의할 점
할당하는 시간이 너무 커지면 FCFS와 같아지고, 너무 작아지면 잦은 context switch로 overhead가 발생한다. 따라서 적절하게 설정해준다.
SJF의 단점을 개선한 기법. 각 작업의 우선순위로 서비스해주는 스케줄링
우선순위
동일한 자원을 동시에 접근하는 작업을 실행하는 코드 영역
ex) 공유하는 변수 사용, 동일 파일 사용
Requirement
해결책
Lock
Semaphores
소프트웨어상에서 Critical Section 문제를 해결하기 위한 동기화 도구
모니터
고급 언어의 설계 구조물로서, 개발자의 코드를 상호배제 하게끔 만든 추상화된 데이터 형태이다.
공유자원에 접근하기 위한 키 획득, 자원사용 후 해제 를 모두 처리함.(세마포어는 직접 키 해제와 공유자원 접근 처리가 필요함)
Deadlock
Swapping
메모리의 관리를 위해 사용되는 기법.
표준 Swapping 방식으로는 round-robin 과 같은 스케줄링의 다중 프로그래밍 환경에서 CPU 할당 시간이 끝난 프로세스의 메모리를 보조 기억장치(e.g. 하드디스크)로 내보내고 다른 프로세스의 메모리를 불러 들일 수 있다.
주기억장치로 불러들이는 것을 swap-in 이라하고, 보조기억장치로 내보내는 것을 swap-out이라 한다.
작업이 오래 걸리기에 현재는 메모리 공간이 부족할때만 수행됨
단편화
메모리에 남은 공간들이 있으나, 프로세스에 끼여 사용하지 못하는 현상
압축
외부단편화의 해소를 위해, 프로세스가 사용하는 메모리 공간을 모두 한 곳에 모아, 남는 공간을 한곳에 모으는 방법
작업효율이 안좋다.
물리 메모리를 Frame이라는 고정 크기로 분리하고, 논리 메모리(프로세스가 점유하는)를 페이지라 불리는 고정 크기의 블록으로 분리함.
하나의 프로세스가 사용하는 공간은 여러개의 페이지로 나뉘어서 논리메모리에서 관리되고, 개별 페이지는 순서에 상관없이 물리메모리에 있는 프레임에 맵핑되어 저장됨
페이징 기법을 사용하여 논리메모리는 물리메모리에 저장될때, 연속되어 저장될 필요가 없고, 물리 메모리의 남는 프레임에 적절히 배치 됨으로써 외부 단편화를 해결할 수 있다.
단점
논리메모리와 물리메모리를 같은 크기의 블록이 아닌, 서로 다른 크기의 논리적 단위인 세그먼트로 분할하는 방법.
사용자는 두개의 주소를 지정(세그먼트 번호 + offset)하고, 세그먼트 테이블에는 각 세그먼트의 시작 물리주소와 길이를 저장
단점
프로세스 전체가 메모리 내에 올라오지 않더라도 실행이 가능하도록 하는 기법으로, 프로그램이 물리 메모리보다 커도 된다는 장점이 존재.
프로그램의 사이즈가 커짐에 따라 물리메모리에 프로세스 전체를 올릴 수 없거나, 올릴 수 있는 프로세스의 수가 줄어들게 되었다. 또한 가끔씩만 사용되는 코드가 메모리를 차지하게 되는 문제가 발생하였다.
프로그램의 일부분만 메모리에 올릴 수 있게 되면 다음과 같은 장점이 있다.
물리 메모리 크기에 프로그램의 사이즈가 제약받지 않는다.
더 많은 프로그램을 동시에 실행할 수 있게 된다. 이에따라 응답시간은 유지되고, CPU 이용률과 처리율은 높아진다.
swap이 필요한 입출력이 줄어들기 때문에 프로그램들이 빠르게 실행된다.’
가상메모리는 실제의 물리메모리 개념과 사용자의 논리메모리 개념을 분리한 것으로 정리할 수 있다. 이로써 작은 메모리를 가지고도 얼마든지 큰 가상 주소 공간을 프로그래머에게 제공할 수 있다.
가상주소공간
(Heap영역, Stack 영역, 코드, 데이터)의 합이 40KB 라면, 실제 물리 메모리에는 40KB 만 올라가 있고, 나머지 60KB 만큼은 필요시에 물리메모리에 요구한다고 이해할 수 있겠다.프로세스간 페이지 공유
시스템 라이브러리가 여러 프로세스들 사이에 공유될 수 있도록 한다. 각 프로세스들은 공유 라이브러리를 자신의 가상 주소 공간에 두고 사용하는 것처럼 인식하지만, 라이브러리가 올라가있는 물리 메모리 페이지들은 모든 프로세스에 공유되고 있다.fork()를 통한 프로세스 생성 과정에서 페이지들이 공유되는 것을 가능하게 한다.프로그램 실행 시작시에 필요한 것만 메모리에 적재하는 것을 의미. 가상 메모리는 대개 페이지로 관리되고, 요구 페이징을 사용하는 가상 메모리에서는 실행과정에서 필요해질 때만 페이지들을 적재한다. 한번도 접근되지 않은 페이지는 물리메모리에 적재되지 않는다.
프로세스 내의 개별 페이지들은 페이저(pager)에 의해 관리된다. 페이저는 프로세스 실행에 실제 필요한 페이지들만 메모리로 읽어옴으로써, 사용되지 않을 페이지를 가져오는 시간낭비와 메모리 낭비를 줄일 수 있다.
요구 페이징에서 필요한 페이지가 물리메모리에 없는 상태를 page fault(페이지부재)라고 한다. 이때 필요한 페이지는 불러오게 되는데, 만약 물리메모리가 꽉 찬 상태라면, 이미 들어있는 페이지를 빼고 새로운 페이지를 넣어야한다. 이때의 프로세스는 다음과 같다.
페이지 교체 알고리즘에 따라 희생될 페이지를 고른다.페이지 교체 알고리즘
캐시의 hit rate를 극대화시키기위해 locality의 원리를 사용한다. 지역성의 전제조건으로 프로그램은 모든 코드나 데이터를 균등하게 access하지 않는다는 특성을 기본으로 한다. 즉, locality란 기억장치 내의 정보를 균일하게 access하는 것이 아닌 어느 한 순간에 특정 부분을 집중적으로 참조하는 특성인 것이다.
캐시에 저장된 데이터가 어느 곳에 저장되어 있는지 몰라 모든 데이터를 순회해야 한다면 시간이 오래 걸리게 된다. 즉, 캐시에 목적 데이터가 저장되어 있다면 바로 접근하여 출력할 수 있어야 캐시가 의미 있어진다.
따라서 캐시에 데이터를 저장할때 특정 자료구조를 사용하여 묶음으로 저장하게 되는데, 이를 캐싱라인이라고 한다.
프로세스는 다양한 주소에 있는 데이터를 사용하므로 빈번하게 사용하는 데이터의 주소 또한 흩어져있다. 따라서 캐시에 저장하는 데이터에는 데이터의 메모리 주소 등을 기록해 둔 태그를 달아놓을 필요가 있다. 이러한 태그들의 묶음을 캐싱 라인이라고 하고, 메모리로부터 가져올 때도 캐싱라인을 기준으로 가져온다. 종류로는 대표적으로 세가지 방법이 있다.
https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/OS#%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4%EC%99%80-%EC%8A%A4%EB%A0%88%EB%93%9C%EC%9D%98-%EC%B0%A8%EC%9D%B4
Comments powered by Disqus.
Comments powered by Disqus.
ios 모바일에서 새로고침시 현재 스크롤 위치를 고정하기 위해 다음과 같은 코드를 사용하였다.
1
+2
+3
+4
+5
+6
+7
+8
+
if (sessionStorage.scrollPosition) {
+ window.scrollTo(0, sessionStorage.scrollPosition);
+}
+
+window.onbeforeunload = function () {
+ sessionStorage.scrollPosition = document.body.scrollTop || document.documentElement.scrollTop;
+};
+
+
하지만 제대로 동작하지 않았는데, 찾아보니 ios에서는 beforeunload 이벤트를 지원해주지 않는다는 글을 읽었다. (글에서는 ios safari를 지원하지 않는다고 명시되어있지만, 크롬에서도 동작하지 않았다.)
대신에 pagehide를 사용하도록 안내받았고, 실제로 동작했다. 하지만 둘의 차이점에 대해서 명확히 알고 넘어가기로 했다.
beforeunload
unload 리스너가 있으면 bfcache에 페이지를 넣지않는다. 하지만 이는 성능에 악영향을 끼친다. 따라서 성능 악영향을 최소화하기 위해 저장되지 않은 변경 사항이 있을 때만 unload 리스너를 붙이는게 좋다.pagehide
Window에서 발생한다.unload 이벤트와 마찬가지로 모바일에서 안정적으로 동작하지 않는다.beforeunload 는 ios에서 동작하지 않지?beforeunload와 pagehide의 가장 큰 차이는 bfcache와 호환되지는 안되는지라는 건 알았다.
하지만 다시 최초로 돌아가서 왜 beforeunload는 ios에서 동작하지 않는지 의문이 든다. 왜냐면 MDN 공식문서에서는 safari IOS에서 버전 1부터 지원한다고 적혀있기 때문이다.
1시간 정도 조사를 해본 결과 아래와 같은 단서를 찾았다.
이후 좀 더 조사를 해봤지만, ios에서는 지원을 안한다, ios의 버그이다라는 말 이외에 찾을 수 없었다. 추정만 있지 명확한 공식문서는 볼 수 없었다.
향후 beforeunload 이벤트가 필요해졌을 떄 한번 더 찾아봐야할거 같다.
Comments powered by Disqus.
index.php을 달라고 요청보냄index.php을 처리할 수 있는 프로그램인 php에게 위임함index.php를 찾고, 해석해서 html 파일을 만듬.$변수명 으로 선언php 입력으로 URL 쿼리에 접근할 때는 $_GET['key']로 접근한다.
ex)
/index.php?name=shin
-> <?php echo $_GET['name']; ?>
-> shin 출력
php에는 많은 내장함수가 있음. 대표적으로는 문자열의 길이를 알려주는 strlen(), 새줄을 <br>로 바꿔주는 nl2br
array() 함수로 배열을 만든다.
키 없이 생성하면 인덱스로 접근가능하고, 키를 함께 선언하면 키로 접근 가능하다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
<?php
+ $cars=array("volvo", "bmw");
+ echo $cars[1];
+?>
+<?php
+ $cars_with_key = array(
+ 'aaa' => "volvo");
+ echo $cars['aaa'];
+?>
+
FORM의 action으로 php를 주어 데이터를 전송할 수 있고, POST로 넘긴 데이터는 $_POST['key']로 접근할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
<!doctype html>
+<html>
+ <body>
+ <form action="form.php" method="post">
+ <p><input type="text" name="title" placeholder="Title"></p>
+ <p><textarea name="description"></textarea></p>
+ <p><input type="submit"></p>
+ </form>
+ </body>
+</html>
+
+
1
+2
+3
+4
+
// form.php
+<?php
+file_put_contents('data/'.$_POST['title'], $_POST['description']);
+?>
+
php는 html 태그 중간에도 삽입이 가능하다. 이는 문자열인 경우에도 마찬가지이다. 이를 통해 input 태그에 수정할 값을 디폴트 값으로 지정이 가능하다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
<form action="update_process.php" method="post">
+ <input type="hidden" name="old_title" value="<?=$_GET['id']?>">
+ <p>
+ <input type="text" name="title" placeholder="Title" value="<?php print_title(); ?>">
+ </p>
+ <p>
+ <textarea name="description" placeholder="Description">
+ <?php print_description(); >
+ </textarea>
+ </p>
+ <p>
+ <input type="submit">
+ </p>
+</form>
+
파일명 변경은 rename() 메서드를 사용하여 가능하다.
1
+2
+3
+4
+5
+
<?php
+rename('data/'.$_POST['old_title'], 'data/'.$_POST['title']);
+file_put_contents('data/'.$_POST['title'], $_POST['description']);
+header('Location: /index.php?id='.$_POST['title']);
+?>
+
필요한 경우에만 html 태그를 노출 시키는 것도 가능하다. 예를들어 아래 코드는 URL에 id 쿼리값이 있어야만 update 링크를 보이도록 한 예시이다.
1
+2
+3
+
<?php if(isset($_GET['id'])) { ?>
+ <a href="update.php?id=<?=$_GET['id']?>">update</a>
+<?php } ?>
+
require() : 필요한 파일을 불러옴. 파일이 없을 시 fatal error가 나타난다.require_once() : require()와 동일하지만, 여러 모듈에 거쳐 한번만 불러옴.include() : 필요한 파일을 불러옴. 파일이 없을 시 warning이 나타나지만 스크립트가 계속 실행됨.include_once() : include()와 동일. 여러 모듈에 거쳐 한번만 불러옴.htmlspecialchars() : 내부에 스크립트 코드가 있어도 그대로 문자열로 출력함.strip_tags() : allowable_tags로 허용할 태그만 남기고, 나머지 태그는 전부 지운 후 출력basename() : ., .. 와 같은 상대경로를 지우고, 파일명만 남기는 함수../password.txt -> password.txtComments powered by Disqus.
연산자를 먼저 표시하고 연산에 필요한 피연산자를 나중에 표시
1
+2
+3
+4
+
(A + B) * (C - D)
+((A + B) * (C - D))
+*(+(AB)-(CD))
+*+AB-CD
+
피연산자를 먼저 표시하고, 연산자를 나중에 표시
1
+2
+3
+4
+
(A+B) * (C-D)
+((A+B) * (C-D))
+((AB)+(CD)-)*
+AB+CD-*
+
Comments powered by Disqus.
비동기로 처리하기 위한 방법 중 하나.
다음과 같이 사용
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+
//Promise 선언
+var _promise = function (param) {
+ return new Promise(function (resolve, reject) {
+ window.setTimeout(function () {
+ if (param) {
+ resolve("해결 완료");
+ } else {
+ reject(Error("실패!!"));
+ }
+ }, 3000);
+ });
+};
+
+//Promise 실행
+_promise(true).then(
+ function (text) {
+ // 성공시
+ console.log(text);
+ },
+ function (error) {
+ // 실패시
+ console.error(error);
+ }
+);
+
위에서는 .then()에 함수를 두개 넣어서 각각 성공, 실패시에 대응하고 있다. 하지만 에러를 잡아낼때는 다음과 같이 .catch()가 더 자주쓰인다. 체이닝 중간에 넣을 수 있기때문이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+
asyncThing1()
+ .then(function () {
+ return asyncThing2();
+ })
+ .then(function () {
+ return asyncThing3();
+ })
+ .catch(function (err) {
+ return asyncRecovery1();
+ })
+ .then(
+ function () {
+ return asyncThing4();
+ },
+ function (err) {
+ return asyncRecovery2();
+ }
+ )
+ .catch(function (err) {
+ console.log("Don't worry about it");
+ })
+ .then(function () {
+ console.log("All done!");
+ });
+
위 로직을 그림으로 표현하면 다음과 같다
여러 프로미스를 모두 완료될때까지 기다리는 방법이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
var promise1 = new Promise(function (resolve, reject) {
+ window.setTimeout(function () {
+ console.log("첫번째 Promise 완료");
+ resolve("11111");
+ }, Math.random() * 20000 + 1000);
+});
+
+var promise2 = new Promise(function (resolve, reject) {
+ window.setTimeout(function () {
+ console.log("두번째 Promise 완료");
+ resolve("222222");
+ }, Math.random() * 10000 + 1000);
+});
+
+Promise.all([promise1, promise2]).then(function (values) {
+ // values에는 배열 형태로 resolved value가 들어옴
+ console.log("모두 완료됨", values);
+});
+
Promise.all 예시처럼 return 하지 않고 바로 new Promise를 생성하면, 파라미터로 넘겨준 익명함수는 바로 실행된다. 따라서 다음과 같이 사용가능하다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
new Promise(function (resolve, reject) {
+ if (+new Date() % 2 === 0) {
+ resolve("Stuff worked!");
+ } else {
+ reject(Error("It broke"));
+ }
+})
+ .then(alert)
+ .catch(alert);
+
만약 Promise.all 예시에서 return으로 Promise 객체를 반환했다면 코드를 아래와 같이 변경해야한다.
1
+2
+3
+
Promise.all([promise1(), promise2()]).then(function (values) {
+ console.log("모두 완료됨", values);
+});
+
Promise와 같이 비동기를 처리하는 방법이다. 하지만 좀 더 간단하고 이해하기 쉽다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+
function makeRequest() {
+ return getData()
+ .then((data) => {
+ if (data && data.needMoreRequest) {
+ return makeMoreRequest(data)
+ .then((moreData) => {
+ console.log(moreData);
+ return moreData;
+ })
+ .catch((error) => {
+ console.log("Error while makeMoreRequest", error);
+ });
+ } else {
+ console.log(data);
+ return data;
+ }
+ })
+ .catch((error) => {
+ console.log("Error while getData", error);
+ });
+}
+
+const makeRequest = () => {
+ return promise1().then((value1) => {
+ // do something
+ return promise2(value1).then((value2) => {
+ // do something
+ return promise3(value1, value2);
+ });
+ });
+};
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+
async function makeRequest() {
+ try {
+ const data = await getData();
+ if (data && data.needMoreRequest) {
+ const moreData = await makeMoreRequest(data);
+ console.log(moreData);
+ return moreData;
+ } else {
+ console.log(data);
+ return data;
+ }
+ } catch (error) {
+ console.log("Error while getData", error);
+ }
+}
+
+const makeRequest = async () => {
+ const value1 = await promise1();
+ const value2 = await promise2(value1);
+ return promise3(value1, value2);
+};
+
https://programmingsummaries.tistory.com/325
https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/JavaScript#promise
Comments powered by Disqus.
SWR은 vercel에서 제작한 React Hooks로, 먼저 캐시(stale)로부터 데이터를 반환한 후, fetch 요청(revalidate)을 하고, 최종적으로 최신화된 데이터를 가져오는 전략이다. 이름은 HTTP 캐시 무효 전략인 stale-while-revalidate에서 유래되었다.
전체적인 기능은 React Query와 비슷하며 React Query 쪽의 커뮤니티가 더 크다. 따라서 사용하기 전에 장단을 잘 비교해보고 둘 중 하나를 선택하는 것이 좋을 것 같다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
import useSWR from 'swr'
+
+function Profile() {
+ const { data, error, isLoading } = useSWR('/api/user', fetcher)
+
+ if (error) return <div>failed to load</div>
+ if (isLoading) return <div>loading...</div>
+ return <div>hello {data.name}!</div>
+}
+
key와 fetcher 함수를 받는다.key는 고유한 식별자이며, fetcher로 전달된다.fetcher는 데이터를 반환하는 어떠한 비동기 함수도 될 수 있다.data와 error, isLoading을 반환한다.전통적으로 리액트에서 비동기적인 데이터 로딩을 처리하는 방식은 다음과 같다.
useEffect를 사용해 데이터를 받아온다.1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+
// 페이지 컴포넌트
+
+function Page () {
+ const [user, setUser] = useState(null)
+
+ // 데이터 가져오기
+ useEffect(() => {
+ fetch('/api/user')
+ .then(res => res.json())
+ .then(data => setUser(data))
+ }, [])
+
+ // 전역 로딩 상태
+ if (!user) return <Spinner/>
+
+ return <div>
+ <Navbar user={user} />
+ <Content user={user} />
+ </div>
+}
+
+// 자식 컴포넌트
+
+function Navbar ({ user }) {
+ return <div>
+ ...
+ <Avatar user={user} />
+ </div>
+}
+
+function Content ({ user }) {
+ return <h1>Welcome back, {user.name}</h1>
+}
+
+function Avatar ({ user }) {
+ return <img src={user.avatar} alt={user.name} />
+}
+
보통 최상위 레벨 컴포넌트에서 가져온 모든 데이터를 유지하고, 트리 아래의 모든 자식 컴포넌트의 props로 추가해야한다. 페이지에 더 많은 데이터 의존성을 추가한다면 코드는 점점 더 유지보수가 어려워진다.
React Context나 global state를 사용하여 props 전달을 막을 수 있지만, 동적콘텐츠 문제가 여전히 존재한다. 페이지 콘텐츠 내 컴포넌트들은 동적일 수 있으며 최상위 레벨 컴포넌트는 자식 컴포넌트가 필요로 하는 데이터가 뭔지 정확히 알 수 없다.
SWR은 이 문제를 해결한다. SWR에서 위 코드는 다음과 같이 리팩토링 할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+
function useUser () {
+ const { data, error, isLoading } = useSWR(`/api/user`, fetcher)
+
+ return {
+ user: data,
+ isLoading,
+ isError: error
+ }
+}
+
+// 페이지 컴포넌트
+function Page () {
+ return <div>
+ <Navbar />
+ <Content />
+ </div>
+}
+
+// 자식 컴포넌트
+function Navbar () {
+ return <div>
+ ...
+ <Avatar />
+ </div>
+}
+
+function Content () {
+ const { user, isLoading } = useUser()
+ if (isLoading) return <Spinner />
+ return <h1>Welcome back, {user.name}</h1>
+}
+
+function Avatar () {
+ const { user, isLoading } = useUser()
+ if (isLoading) return <Spinner />
+ return <img src={user.avatar} alt={user.name} />
+}
+
+
데이터는 이제 데이터가 필요한 컴포넌트로 범위가 제한되었으며 모든 컴포넌트는 서로에게 독립적이다. 모든 부모 컴포넌트들은 데이터나 데이터 전달에 관련된 것들을 알 필요가 없다. 그냥 렌더링만 담당한다.
또한 동일한 SWR 키를 사용한다면, 요청은 중복 제거, 캐시, 공유되므로 단 한번의 요청만 API로 전송되어 네트워크 비용의 낭비도 없다.
또한 애플리케이션은 이제 사용자 포커스나 네트워크 재연결 시에 데이터를 갱신할 수 있다. 브라우저 탭을 전환할 때 자동으로 데이터가 갱신된다는 것을 의미한다.
SWR의 기능에는 다음과 같은 것이 있다고 한다. 다 다루기에는 너무 많기에 이 글에서는 개인적으로 흥미있는 것들만 정리하였다.
React Native
` rel=”preload”를 권장함. 아래와 같이 html 코드를 작성 후, <head>`에 넣기만 하면 됨.
1
+
<link rel="preload" href="/api/data" as="fetch" crossorigin="anonymous">
+
rel="preload"는 페이지 요청 시 해당 소스 자원을 우선적으로 로드하라는 뜻이고, 따라서 JS가 다운로드 되기 전에 데이러를 프리패칭한다. 동일한 URL로 fetch 요청 결과는 재사용된다.
SWR은 preload API를 제공하여 자원을 프리패치하고 캐시 안에 저장할 수 있게 해준다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+
function App({ userId }) {
+ const [show, setShow] = useState(false)
+
+ // preload in effects
+ useEffect(() => {
+ preload('/api/user?id=' + userId, fetcher)
+ }, [userId])
+
+ return (
+ <div>
+ <button
+ onClick={() => setShow(true)}
+ {/* preload in event callbacks */}
+ onHover={() => preload('/api/user?id=' + userId, fetcher)}
+ >
+ Show User
+ </button>
+ {show ? <User /> : null}
+ </div>
+ )
+}
+
next.js 페이지 프리패칭과 함께 다음 페이지와 데이터 모두를 즉시 로드할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
import useSWR, { preload } from 'swr'
+
+// should call before rendering
+preload('/api/user', fetcher);
+preload('/api/movies', fetcher);
+
+const Page = () => {
+ // useSWR hook이 렌더링을 지연시키지만, "/api/user", "/api/movies"는 이미 프리로딩을 시작하고 있고,
+ // 따라서 waterfall 문제는 발생하지 않는다.
+ const { data: user } = useSWR('/api/user', fetcher, { suspense: true });
+ const { data: movies } = useSWR('/api/movies', fetcher, { suspense: true });
+ return (
+ <div>
+ <User user={user} />
+ <Movies movies={movies} />
+ </div>
+ );
+}
+
이미 존재하는 데이터를 SWR 캐시에 미리 채우길 원한다면, fallbackData 옵션을 사용할 수 있다.
1
+
useSWR('/api/data', fetcher, { fallbackData: prefetchedData })
+
SWR가 데이터를 아직 가져오지 않았다면, 폴백으로 prefetchedData를 반환할 것이다.
<SWRConfig> 및 fallback 옵션을 사용하여 모든 SWR hooks 및 다중 키에 대해서도 이것을 구성할 수 있다.
페이지가 프리렌더링 되어야하면, Next.js는 2가지 형태의 프리렌더링을 지원한다.
SWR와 함께 SEO를 위해 페이지를 프리렌더링할 수 있고, 캐싱, 재검증, 포커스 추적, 클라이언트 사이드에서 간격을 두고 다시 가져오기와 같은 기능도 있다.
모든 SWR hooks에 초기값으로 프리패칭된 데이터를 넘겨주기 위해 SWRConfig의 fallback 옵션을 사용할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+
export async function getStaticProps () {
+ // `getStaticProps`는 서버 사이드에서 실행됩니다.
+ const article = await getArticleFromAPI()
+ return {
+ props: {
+ fallback: {
+ '/api/article': article
+ }
+ }
+ }
+}
+
+function Article() {
+ // `data`는 `fallback`에 있기 때문에 항상 사용할 수 있습니다.
+ const { data } = useSWR('/api/article', fetcher)
+ return <h1>{data.title}</h1>
+}
+
+export default function Page({ fallback }) {
+ // `SWRConfig` 경계 내부에 있는 SWR hooks는 해당 값들을 사용합니다.
+ return (
+ <SWRConfig value=>
+ <Article />
+ </SWRConfig>
+ )
+}
+
useSWR은 array나 function 타입을 key로 사용할 수 있다. 이 타입의 키를 이용해 미리 패치된 데이터를 사용하기 위해선 fallback key들을 unstable_serialize와 함께 직렬화 해야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+
import useSWR, { unstable_serialize } from 'swr'
+
+export async function getStaticProps () {
+ const article = await getArticleFromAPI(1)
+ return {
+ props: {
+ fallback: {
+ // unstable_serialize()에 배열 스타일의 키
+ [unstable_serialize(['api', 'article', 1])]: article,
+ }
+ }
+ }
+}
+
+function Article() {
+ // 배열 스타일의 키 사용
+ const { data } = useSWR(['api', 'article', 1], fetcher)
+ return <h1>{data.title}</h1>
+}
+
+export default function Page({ fallback }) {
+ return (
+ <SWRConfig value=>
+ <Article />
+ </SWRConfig>
+ )
+}
+
리액트의 Suspense API와 함께 사용할 수도 있다. suspense 옵션을 활성화하면 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
import { Suspense } from 'react'
+import useSWR from 'swr'
+
+function Profile () {
+ const { data } = useSWR('/api/user', fetcher, { suspense: true })
+ return <div>hello, {data.name}</div>
+}
+
+function App () {
+ return (
+ <Suspense fallback={<div>loading...</div>}>
+ <Profile/>
+ </Suspense>
+ )
+}
+
서스펜스 모드에서 data는 항상 응답을 가져와서 undefined를 검사할 필요가 없다. 하지만 에러가 발생할 경우 ErrorBoundary를 사용해 캐치해야한다.
일반적으로 suspense를 활성화하면 렌더링 시에 data는 undefined를 갖지 않는다.
하지만 conditional fetch나 의존적 fetch와 함께 사용하면 data는 요청이 일시 중단된 경우 undefined가 된다.
1
+2
+3
+4
+5
+6
+
function Profile () {
+ const { data } = useSWR(isReady ? '/api/user' : null, fetcher, { suspense: true })
+
+ // `isReady`가 false이면 `data`는 `undefined`입니다
+ // ...
+}
+
suspense를 SSR에서 사용하려면 fallbackData나 fallback을 통해 초기 데이터를 반드시 넣어줘야한다. 이것은 <Suspense>를 서버사이드에서 데이터를 가져오는데 사용할 수 없고, 클라이언트사이드나 getStaticProps 등 프레임워크에서 제공하는 data fetching 메소드에서만 가져올 수 있다는 말이다.
SWR hook의 전후에 로직을 실행할 수 있도록 해줌. 여러 미들웨어가 존재하면 각 미들웨어는 다음 미들웨어를 감쌈. 마지막 미들웨어가 원본 SWR hook useSWR을 받는다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
function myMiddleware (useSWRNext) {
+ return (key, fetcher, config) => {
+ // hook을 실행하기 전...
+
+ // 다음 미들웨어를 처리하거나, 마지막인 경우 `useSWR` hook을 처리합니다.
+ const swr = useSWRNext(key, fetcher, config)
+
+ // hook을 실행한 후...
+ return swr
+ }
+}
+
1
+2
+3
+4
+5
+
<SWRConfig value=>
+
+// 또는...
+
+useSWR(key, fetcher, { use: [myMiddleware] })
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
function Bar () {
+ useSWR(key, fetcher, { use: [c] })
+ // ...
+}
+
+// useSWR(key, fetcher, { use: [a, b, c] }) 와 같음.
+function Foo() {
+ return (
+ <SWRConfig value=>
+ <SWRConfig value=>
+ <Bar/>
+ </SWRConfig>
+ </SWRConfig>
+ )
+}
+
useSWR의 키가 변경되었더라도 새로운 데이터가 로드되기 전까지는 여전히 이전 결과를 반환받길 원할 수 있다.
이는 useRef와 함께 사용하여 지연 미들웨어로 구축할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+
import { useRef, useEffect, useCallback } from 'react'
+
+// 키가 변경되더라도 데이터를 유지하기 위한 SWR 미들웨어입니다.
+function laggy(useSWRNext) {
+ return (key, fetcher, config) => {
+ // 이전에 반환된 데이터를 저장하기 위해 ref를 사용합니다.
+ const laggyDataRef = useRef()
+
+ // 실제 SWR hook.
+ const swr = useSWRNext(key, fetcher, config)
+
+ useEffect(() => {
+ // 데이터가 undefined가 아니면 ref를 업데이트합니다.
+ if (swr.data !== undefined) {
+ laggyDataRef.current = swr.data
+ }
+ }, [swr.data])
+
+ // 지연 데이터가 존재할 경우 이를 제거하기 위한 메서드를 노출합니다.
+ const resetLaggy = useCallback(() => {
+ laggyDataRef.current = undefined
+ }, [])
+
+ // 현재 데이터가 undefined인 경우에 이전 데이터로 폴백
+ const dataOrLaggyData = swr.data === undefined ? laggyDataRef.current : swr.data
+
+ // 이전 데이터를 보여주고 있나요?
+ const isLagging = swr.data === undefined && laggyDataRef.current !== undefined
+
+ // `isLagging` 필드 또한 SWR에 추가합니다.
+ return Object.assign({}, swr, {
+ data: dataOrLaggyData,
+ isLagging,
+ resetLaggy,
+ })
+ }
+}
+
useSWR이 반환하는 데이터 중 두가지가 현재 데이터의 상태를 알려줌
isLoading : 처음 또는 key 변경으로 데이터를 로딩하고 있을 때 trueisValidading : 데이터를 로딩하거나, revalidaing 할 때 trueComments powered by Disqus.
react-boilerplate 라는, 리액트 프로젝트를 처음 시작할때 create-react-app을 대체하여 사용하기에 아주 좋아보이는 프로젝트가 있다.
https://github.com/react-boilerplate/react-boilerplate
상당히 많은 초기 설정을 하는데, 너무 많아서 뭐가 뭔지 알아보기가 어렵다.
따라서 이 초기설정들을 설명해놓은 글이 있고, 이 포스트는 이 글을 보고 공부한 내용을 적은 것이다.
Comments powered by Disqus.
리액트로 개발을 하다가 리스트를 만들면, 다음과 같이 key를 사용하라는 안내문이 뜬다.
평소엔 무시하고 key를 그냥 넣었지만, 왜 그런지 갑자기 궁금해져 찾아보았다.
해당 내용은 리액트 공식문서에 Recursing On Children으로 나와있다.
리액트 리렌더링 과정에서 리스트를 처리할때, 리액트는 기본적으로 실제 DOM의 리스트와 virtual DOM의 변경된 리스트를 비교한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
// 전
+<ul>
+ <li>first</li>
+ <li>second</li>
+</ul>
+
+// 후
+<ul>
+ <li>first</li>
+ <li>second</li>
+ <li>third</li>
+</ul>
+
예를 들어, 위와 같이 기존 리스트의 마지막에 새로운 요소가 추가되었다고 해보자. 이때 리액트는 비교알고리즘을 통해 리스트를 차례대로 비교한다. 먼저 <li>first</li>이 서로 같다는 걸 확인하고, <li>second</li>이 같다는 걸 확인한다. 그리고 <li>third</li>이 다르다는 걸 확인하고, <li>third</li> 을 트리에 추가하는 리렌더링을 수행한다.
이와 같이 맨 마지막에 요소를 추가하는 경우, 변경된 요소만 추가하기에 문제 없다. 하지만 문제는 다음과 같은 경우이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
<ul>
+ <li>Duke</li>
+ <li>Villanova</li>
+</ul>
+
+<ul>
+ <li>Connecticut</li>
+ <li>Duke</li>
+ <li>Villanova</li>
+</ul>
+
위와 같이 요소를 맨 위에 추가했을 경우 문제가 된다. 첫번째 예시처럼 비교를 했을때, 세 <li> 모두 다르기에, 리액트는 세 자식을 모두 리렌더링 시킨다.
Recursing on children 에서 봤던 문제를 해결하기 위해 리액트는 key 속성을 지원한다. 자식들이 key를 가지고 있다면, 리액트는 key를 통해 기존 트리와 이후 트리의 자식들이 일치하는지 확인한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
<ul>
+ <li key="2015">Duke</li>
+ <li key="2016">Villanova</li>
+</ul>
+
+<ul>
+ <li key="2014">Connecticut</li>
+ <li key="2015">Duke</li>
+ <li key="2016">Villanova</li>
+</ul>
+
이렇게 키를 추가한다면, 리액트는 키가 같은 자식은 이전과 같은 자식이라고 인지하고 리렌더링하지 않는다. 오직 키가 변경된 요소만 리렌더링 하여 매우 효율적이 된다.
key는 형제 사이에서 유일해야한다. 즉, 같은 리스트 안에서 key는 유일해야 한다는 말이다.
key를 추가하라는 안내문이 뜬다는 이유로 나를 포함한 많은 이들이 다음과 같은 실수를 저지른다.
1
+2
+3
+
{state.list.map((todo, index) => (
+ <ToDo key={index} {...todo} />
+))}
+
이처럼 인덱스를 key로 사용하면, 만약 새로운 요소를 리스트의 맨 앞에 추가했을 경우 리스트의 key는 새로 추가된 요소부터 0 ~ n 의 값을 가진다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
<ul>
+ <li key="0">Duke</li>
+ <li key="1">Villanova</li>
+</ul>
+
+<ul>
+ <li key="0">Connecticut</li>
+ <li key="1">Duke</li>
+ <li key="2">Villanova</li>
+</ul>
+
리액트는 key를 통해 리렌더 해야 할 요소를 뽑아낸다. 그런데 이 예시에서는 새로 맨 앞에 추가된 요소가 이전 리스트에 존재했던 key="0"을 갖는다. 이로 인해 리액트는 새로 추가된 요소를 리렌더링 하지 않고, 오히려 기존에 있던 맨 마지막 요소를 리렌더링 한다.(기존 리스트에선 2라는 key는 없었기에)
이와 같이 각 index를 key로 사용하면 의도하지 않는 방식으로 동작할 수 있다. 예시 예시 해결
리스트에 key를 지정해주지 않으면 리액트에서는 기본적으로 index를 key로 사용한다. 따라서 특별한 경우가 아니라면 key는 유일한 값으로 지정해주자.
특별한 경우
- 리스트가 변화되지 않을 경우
- 성능에 신경쓸만큼 긴 리스트가 아닌데, 식별자를 생성하기 어려운 경우
Comments powered by Disqus.
npm install -g expo-cli
안드로이드 스튜디오 설치 -> 설치 후 sdk도 설치
안드로이드 스튜디오을 키고, configuration에 들어가서 AVD manager을 누르고, create virtual device를 눌러 가상머신 만들기
Comments powered by Disqus.
React-Query 공식문서상 캐싱개념은 stale과 cachetime을 통해 이루어진다
useQuery의 옵션으로 staletime과 cachetime을 보낼 수 있다.
refetch 함수
refetch 되는 조건
이때 stale 상태일때만 refetch 된다. 따라서 staletime으로 stale 상태를 관리해주고, cachetime으로 메모리에 남아있을 시간을 지정해준다.
캐싱과 관련된 내용을 담고있는 객체. useQueryClient 로 접근 가능하다.
사용하기 위해선 먼저 다음과 같이 <QueryClientProvider> 로 하위 컴포넌트를 감싸주어야한다. (React Query 자체를 사용하기 위해서도 감싸주어야한다)
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
const queryClient = new QueryClient({
+ defaultOptions : {
+ queries : {
+ refetchOnWindowFocus:false,
+ refetchOnMount:false
+ }
+ }
+})
+
+return (
+ <QueryClientProvider client={queryClient}>
+ <Main>
+ ...
+ </Main>
+ </QueryClientProvider>
+)
+
이후 아래와 같이 useQueryClient로 queryClient 객체를 가져오면 다음과 같이 queriesMap 형태로 캐시된 데이터를 확인할 수 있다.
1
+2
+
const queryClient = useQueryClient();
+console.log(queryClient);
+
사진에서 보이듯이 queriesMap에서는 useQuery에서 사용한 키값으로 캐싱되어있음을 알 수 있다. useQuery를 사용할때, staletime과 cachetime을 지정해주면, 그 설정값에 맞추어 키값에 맞는 캐싱된 데이터를 자동으로 가져온다. 이때 요청은 보내지 않는다.
staletime이 0이라면, 항상 데이터가 stale하다고 여겨지기에 항상 refetching을 진행한다.
enabled:false
useQuery의 옵션으로 enabled:false를 설정해놓으면, 초기 마운트시에 해당 useQuery가 마치 useEffect처럼 첫 마운트시 fetcher 함수 호출을 하고, 실패했을 때는 계속 retry하는 행위를 사전 차단할 수 있다.
그러나 enabled:false는 useQuery 기능을 사용하지 않겠다고 말해주는 것과 같기 때문에, 수동적으로 호출해줘야한다. 그것이 바로 useQuery 함수 호출을 하여 리턴되는 객체에 포함되어있는 refetch 함수다.
refetch함수는 캐싱 데이터를 조회하지 않고 요청을 날린다.
즉, enabled:false 일 경우 초기 마운트 시에는 데이터를 가져오지 않고 refetch 함수를 호출해도 캐시데이터를 조회하지 않으니, enabled:false 일경우 캐시 사용이 불가능하다.
enabled:true
초기 마운트 때, 정해진 동작을 할 것이고 따라서 캐시 데이터를 조회할 것이다. 저장된 캐시데이터가 stale하다면 캐시를 가져오고, 아니면 재요청을 할 것이다.
useQuery의 옵션에 사용하는 onError, onSuccess, onSettled 등의 ajax 요청 결과로 동작하는 이벤트는 캐싱값을 가져올때는 동작하지 않는다.
따라서 캐싱값을 사용할때는, 해당 데이터의 결과값은 변동된다는 사실을 이용하여 이 데이터를 이용한 조건부렌더링을 사용하여야한다.
enabled 속성 조작
enabled 속성을 조작하는 것으로 요청 동작을 막을 수 있다.
예를 들어 searchValue가 있어야 쿼리를 날리는 것이 의미있는 상황이라고 하자.
그럼 다음과 같이 enabled 옵션을 searchValue가 ‘‘이 아닌 상태일때만 true로 만들고, 그 외에는 false로 하여 초기 요청을 통한 retry로 오류를 생성하는 것을 막는다.
1
+2
+3
+
const {data, refetch, ...rest} = useQuery([page, "search"], ..., {
+ enabled : searchValue !== ''
+ })
+
그 뒤, 조건부로 enabled가 true로 변경되면서 요청을 날리게 되어 성공하면 data 프로퍼티에 그 값이 저장되고, 캐싱에도 저장될 것이다.
https://velog.io/@chltjdrhd777/React-Query-%EC%BA%90%EC%8B%B1%EC%97%90-%EB%8C%80%ED%95%9C-%EA%B5%AC%ED%98%84
Comments powered by Disqus.
리액트의 함수형 컴포넌트는 최초에 한번 실행이 되면서 초기값으로 설정해놓은 상태를 기억한다.
1
+
const [state, setState] = useState(0);
+
이후 setState가 호출되어 상태가 변경된다면 다시 함수형 컴포넌트가 실행되고 virtual DOM을 리턴한다. 그리고 이전에 리턴했던 virtual DOM과 비교해서 state 값이 달라졌다면 달라진 부분에 해당하는 DOM만 업데이트한다.
클래스형 컴포넌트는 render() 메서드를 통해 상태 변경을 감지할 수 있다. 반면 함수형 컴포넌트는 렌더링이 발생하면 함수 자체가 다시 호출된다. 그래서 상태 관리를 위해선 함수가 다시 호출되었을 때 이전 상태를 기억하고 있어야한다.
useState는 Closure를 통해 이 문제를 해결한다.
Closure는 내부함수에서 상위 함수 스코프의 변수에 접근할 수 있는 개념
다음은 클로저의 특징을 이용한 MyReact 모듈이다
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
const MyReact = (function() {
+ let _val // hold our state in module scope
+ return {
+ render(Component) {
+ const Comp = Component()
+ Comp.render()
+ return Comp
+ },
+ useState(initialValue) {
+ _val = _val || initialValue
+ function setState(newVal) {
+ _val = newVal
+ }
+ return [_val, setState]
+ }
+ }
+})()
+
_val은 익명함수 scope 안에서 정의된다. 하지만 반환되는 함수의 Closure에서 사용되기에 익명함수가 종료되더라도 메모리에 유지된다.이 MyReact 함수는 다음과 같이 사용할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
function Counter() {
+ const [count, setCount] = MyReact.useState(0)
+ return {
+ click: () => setCount(count + 1),
+ render: () => console.log('render:', { count })
+ }
+}
+let App
+App = MyReact.render(Counter) // render: { count: 0 }
+App.click()
+App = MyReact.render(Counter) // render: { count: 1 }
+
Counter가 일종의 컴포넌트라고 생각해보자.
useState가 실행된다. _val에 아무것도 없기에 초기값으로 설정된다.useState는 반환값으로 상태와 setter를 낸다. 그 후 Counter는 click과 render가 들어있는 객체를 반환해 App에 저장한다.click 이후 render를 실행함으로써 리렌더링을 보여준다._val에 값이 있기에 초기값을 설정하는 대신 업데이트된 값을 계속 유지한다.count가 1인 상태로 동작한다.하지만 위와 같은 useState엔 문제점이 있다. 바로 여러 useState를 사용할 경우 다 같은 _val을 바라본다는 점이다. 이를 해결하기 위해선 다음과 같이 할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+
let state = [];
+let setters = [];
+let cursor = 0;
+let firstrun = true;
+
+const createSetter = (cursor) => {
+ return (newValue) => {
+ state[cursor] = newValue;
+ };
+};
+
+const useState = (initialValue) => {
+ if (firstrun) {
+ state.push(initialValue);
+ setters.push(createSetter(cursor));
+ firstrun = false;
+ }
+
+ const resState = state[cursor];
+ const resSetter = setters[cursor];
+ cursor++;
+
+ return [resState, resSetter];
+};
+
state 배열에 삽입한다. 마찬가지로 setter도 추가한다. 이때 state 배열과 setters 배열은 useState 함수 외부에 위치한다.1
+2
+3
+4
+5
+6
+
export function useState<S>(
+ initialState: (() => S) | S,
+): [S, Dispatch<BasicStateAction<S>>] {
+ const dispatcher = resolveDispatcher();
+ return dispatcher.useState(initialState);
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
function resolveDispatcher() {
+ const dispatcher = ReactCurrentDispatcher.current;
+
+ if (__DEV__) {
+ if (dispatcher === null) {
+ console.error('Some error msg...');
+ }
+ }
+
+ return ((dispatcher: any): Dispatcher);
+}
+
1
+2
+3
+4
+5
+6
+7
+
const ReactCurrentDispatcher = {
+ /**
+ * @internal
+ * @type {ReactComponent}
+ */
+ current: (null: null | Dispatcher),
+};
+
ReactCurrentDispatcher은 전역에 선언된 객체의 프로퍼티이다. useState 리턴 값의 출처가 전역에서 온다는 것이다. 리액트가 실제로 클로저를 활용해 함수 외부의 값에 접근하는 사실을 알 수 있다.
다음 예제에서 increase1의 결과는 1이고 increase2의 결과는 3이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
const Counter = () => {
+ const [count, setCount] = useState(0);
+
+ const increase1 = () => {
+ setCount(count + 1);
+ setCount(count + 1);
+ setCount(count + 1);
+ }
+
+ const increase2 = () => {
+ setCount((count) => count + 1);
+ setCount((count) => count + 1);
+ setCount((count) => count + 1);
+ }
+}
+
+export default Counter;
+
그 이유는 새로운 상태가 바로 이전의 상태를 통해 계산되어야하면 함수를 인자로 넣어야하기 때문인데, 리액트는 퍼포먼스 향상을 위해 특별한 배치 프로세스를 사용하기 때문이다. 여러 setState 업데이트를 한 번에 묶어서 처리한 후 마지막 값을 통해 state를 결정한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+
{
+ memoizedState: 0, // first hook
+ baseState: 0,
+ queue: { /* ... */ },
+ baseUpdate: null,
+ next: { // second hook
+ memoizedState: false,
+ baseState: false,
+ queue: { /* ... */ },
+ baseUpdate: null,
+ next: { // third hook
+ memoizedState: {
+ tag: 192,
+ create: () => {},
+ destory: undefined,
+ deps: [0, false],
+ next: { /* ... */ }
+ },
+ baseState: null,
+ queue: null,
+ baseUpdate: null,
+ next: null
+ }
+ }
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
{
+ memoizedState: 0,
+ baseState: 0,
+ queue: {
+ last: {
+ expirationTime: 1073741823,
+ suspenseConfig: null,
+ action: 1, // setCount를 통해 설정한 값
+ eagerReducer: basicStateReducer(state, action),
+ eagerState: 1, // 상태 업데이트를 마치고 실제 렌더링되는 값
+ next: { /* ... */ },
+ priority: 98
+ },
+ dispatch: dispatchAction.bind(bull, currenctlyRenderingFiber$1, queue),
+ lastRenderedReducer: basicStateReducer(state, action),
+ lastRenderedState: 0,
+ },
+ baseUpdate: null,
+ next: null
+}
+
리액트의 배치 프로세스는 이렇게 묶인 hook들을 한 번에 처리한 뒤 last를 생성한다. 여기서 최종 반환될 eagerState를 계산하는 함수가 Reducer이다.
1
+2
+3
+
function basicStateReducer(state, action) {
+ return typeof action === 'function' ? action(state) : action;
+}
+
이 Reducer에 넘기는 action 타입이 함수일 때 이전 상태를 인자로 받는다. 그래서 기존 상태를 기반으로 새로운 상태를 업데이트할 수 있게 된다.
https://thinkforthink.tistory.com/339 https://seokzin.tistory.com/entry/React-useState%EC%9D%98-%EB%8F%99%EC%9E%91-%EC%9B%90%EB%A6%AC%EC%99%80-%ED%81%B4%EB%A1%9C%EC%A0%80 https://hengxi.tistory.com/22
Comments powered by Disqus.
최근 create-react-app 대신에 vite를 공식으로 사용하자는 얘기가 나오고 있다.
여기서 지적한 문제점들은 다음과 같다
리액트 팀에서 답변한 (잠재적인) CRA의 전환 방향은 CRA를 런쳐로 전환하고, 내부적으로는 vite를 사용하는 방법이다. 그러면서 몇가지 리액트 프레임워크를 추천하는 방식이다.
글을 읽으면서 CRA에 대한 이해가 부족하다는 점을 느꼈고, vite가 무엇인지에 대한 지식이 부족하다는 것을 느껴 이 포스트를 작성하게 되었다.
이 포스트에서는 vite에 대해 알아보고, CRA와의 차이점에 대해 작성하였다.
vite는 빠른 모던 웹 프로젝트 개발 경험을 제공하기 위한 빌드 툴이다. 다음 두가지 메이저 파트로 구성되어있다.
Vue Single File Components나 React Fast Refrash 등 first-party integration을 사용함.create-vite를 통해 프로젝트를 생성하면 이미 설정되어있음.Vite는 다양한 설정이 가장 적절한 값이 디폴트로 설정되어있지만, Plugin API나 Javascript API를 통해 설정이 가능하다. (타입스크립트도 지원)
디폴트로 설정된 빌드 타켓은 native ES Modules, native ESM dynamic import, import.meta을 지원하는 브라우저다. 하지만, 그 이전 브라우저를 위해 공식으로 @vitejs/plugin-legacy을 지원한다.
1
+2
+3
+4
+5
+
npm create vite@latest
+# or
+yarn create vite
+# or
+pnpm create vite
+
위 명령어 입력후 프롬프트 지시에 따라 생성할 수 있음. 기본적으로 다양한 템플릿을 제공하고, 필요한 것이 없다면 커뮤니티 템플릿도 사용가능하다.
커뮤니티 템플릿을 사용할 대는 다음과 같이 커맨드창에 입력한다.
1
+2
+3
+4
+5
+
npx degit user/project my-project
+cd my-project
+
+npm install
+npm run dev
+
가장 큰 차이는 개발서버에서 vite가 CRA보다 훨씬 빠르다는 것이다.
과거에는 브라우저에서 ESM(ES Module)을 지원하지 않았다. 따라서 javscript 모듈화를 위해서는 번들링이라는 우회방법을 사용해야했다. 이때 사용된 툴이 Webpack, Rollup, Parcel이다.
하지만 서비스 복잡도에 따라 모듈이 늘어날 수록 개발 서버를 가동하는 것은 매우 오래걸렸다. 따라서 Vite는 브라우저에서 지원하는 ESM 및 네이티브 언어로 작성된 Javascript 도구 등을 이용해 문제를 해결하였다.
캐시가 없는 상태에서 실행하는 콜드-스타트 방식에서 번들리 기반의 도구는, 애플리케이션 내 모든 소스코드를 확인하고 번들링한다. 하지만, Vite는 다음 두가지로 이 문제를 해결하였다.
pre-bundling 기능은 Esbuild를 사용하여 webpack, parcel 과 같은 기존 번들러 대비 10~100배 빠른 번들링 속도를 보인다.기존 번들러 기반에서는 소스코드 업데이트시 번들링 과정을 다시 겪어야했다. 따라서 서비스가 커질수록 소스코드 갱신 시간 또한 증가했다. HMR(Hot Module Replacement)라는 대안이 나왔지만 명확한 해답은 아니었다.
vite는 HMR을 지원하지만, 번들러가 아닌 ESM을 이용해서 제공한다. 어떤 모듈이 수정되는 vite는 그저 수정된 모듈과 관련된 부분만을 교체하고 브라우저에서 해당 모듈을 요청 시 교체된 모듈을 전달할 뿐이다. 따라서 앱 사이즈가 커져도 HMR을 포함한 갱신 시간에는 영향을 끼치지 않는다.
vite는 또한 HTTP 헤더를 이용해 퍼포먼스를 높였다. 소스코드는 304 Not Modified로, 디펜던시는 Cache-Control: max-age=31536000,immutable을 이용해 캐시되도록 함으로써 한번이라도 요청을 덜보내도록 했다.
create-react-app으로 만들어진 프로젝트는 webpack을 번들러로 사용한다. webpack은 각 모듈을 함수로 감싸 평가한다. 그렇
하지만, vite는 빌드시 Rollup이라는 번들러를 사용한다. Rollup에서는 코드들을 동일한 수준으로 호이스팅하고, 한번에 번들링을 진행하기에 webpack보다 빠르고, 번들링된 결과물도 훨씬 가볍다. 또한 빌드 결과물도 ES6모듈 형태로 출력할 수 있어서 라이브러리나 패키지에 활용할 수 있다.
index.html의 위치vite로 만들어진 리액트 프로젝트는 index.html의 위치가 create-react-app과 달리 프로젝트 루트에 위치한다. 이는 추가적인 번들링 없이 index.html 파일이 앱의 진입점이 되게끔 하기 위함이다.
vite는 index.html을 JS 모듈 그래프를 구성하는 하나로 취급한다. 따라서, <script type="module" src="..."> 태그를 이용해 JavaScript 소스 코드를 가져올 수 있고, 인라인으로 작성된 <script type="module">이나 <link href>와 같은 CSS 역시 Vite에서 취급 가능하다. 또한 create-react-app과는 달리, index.html 내에서 url을 표시할 때 %PUBLIC_URL%과 같은 placeholder없이 사용할 수 있도록 URL 베이스를 자동으로 맞춰준다.
vite는 또한 정적 HTTP 서버와 비슷하게 루트 디렉터리라는 개념을 가지고 있다. <root>라고 언급된 개념이 있는데, 절대경로가 프로젝트 루트를 베이스로 연결된다는 것을 말한다. vite는 또한 프로젝트 루트 밖에 있는 의존성을 가져올 수 있는데, 이로써 모노리포 구성도 가능해진다.
또한 여러 .html 파일을 두어 multi-page apps 를 구현할 수도 있다.
CRA는 vite에 비해 오랜기간동안 사용되어왔고 그만큼 이슈가 많이 픽스되어왔다. 그리고 사용자수또한 CRA의 기반인 webpack이 vite의 기반인 rollup, esbuild보다 훨씬 많다. 그만큼 커뮤니티가 활성화가 되어있고, 개발중 맞닥뜨릴 이슈에 대한 해결책도 많이 제시될 것이다.
따라서 개인적으로는 기존에 잘 돌아가고 있는 프로젝트라면 현재 개발 서버에 큰 문제가 없을시엔 CRA를 유지하는 것이 좋아보인다. 또한 신규 프로젝트라하더라도 안정성이 중요하다면 CRA를 유지하는 것이 좋을 것같다.
반면 Vite는 기존 프로젝트 중에서 개발 서버의 성능문제가 심각한 경우 또는 신규 프로젝트 중에서 안정성이 상대적으로 덜 중요할 경우 Vite를 사용하는 것이 좋아보인다. (결과적으로 CRA도 vite를 내부적으로 사용하는 것을 생각하고 있다고 하니, vite를 사용하는 것이 트렌드이긴 한가보다.)
Comments powered by Disqus.
웹페이지에서 사용자가 무언가를 입력하고 뒤로가기를 눌렀을때 다음과 같은 경고창을 띄우는 걸 본적이 있다.
이러한 스펙을 개발하기위해서는 다음과 같이 두가지 상황으로 나누어야한다.
그렇다면 리액트에서는 구체적으로 어떻게 이 스펙을 구현할 수 있을지 알아보자
새로고침/창닫기/링크이동의 경우는 간단하다. 해당 이벤트들이 발생할때 window 객체에서 발생시키는 beforeunload 이벤트를 취소시키면 된다. 리액트에서 구현하려면 다음과 같이 useEffect 안에 window.onbeforeunload 함수를 등록해주면 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
useEffect(() => {
+ window.onbeforeunload = (e) => {
+ e.preventDefault();
+ return ""
+ }
+
+ return () => {
+ window.onbeforeunload = null
+ }
+}, [])
+
하지만, 이 경우에는 페이지에 접속했을 경우 무조건 이벤트가 등록이 된다. 사용자가 입력했을때만 경고창을 띄우고 싶다면 다음과 같이 할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
const [hasInputFilled, setHasInputFilled] = useState(false);
+
+useEffect(() => {
+ window.onbeforeunload = () => {
+ if (hasInputFilled) {
+ return ""
+ }
+ }
+
+ return () => {
+ window.onbeforeunload = null
+ }
+}, [hasInputFilled])
+
뒤로가기 이벤트는 popstate 이벤트가 발생한다. 하지만 popstate 이벤트는 취소가 불가능하다. 따라서 취소를 하지 않고 뒤로가기를 막아야하는데, 방법을 말하기 전에 먼저 popstate 이벤트에 대해 간략히 알아보자.
우리가 브라우저에서 여러 웹 페이지를 오가다보면 방문기록이 쌓이게 된다. 이때 하나의 탭에서 여러 웹 페이지를 방문하면 그 기록이 차례로 쌓이고, 뒤로가기 시에는 해당 탭에서 마지막으로 방문했던 곳으로 이동하게 된다. 마치 스택처럼 동작한다. popstate는 뒤로가기 시 마지막으로 방문했던 페이지로 이동하기 위해 발생된다.
여기서 뒤로가기를 막기 위한 한가지 아이디어를 찾을 수 있다. 만약 마지막으로 방문했던 페이지가 현재 페이지면, 뒤로가기를 하더라도 현재 페이지에 그대로 남아있을 것이라는 아이디어다. 이를 위해서는 history.pushState()를 사용하면 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
useEffect(() => {
+ const preventGoBack = () => {
+ history.pushState(null, "", location.href);
+ };
+
+ history.pushState(null, "", location.href);
+ window.addEventListener("popstate", preventGoBack);
+
+ return () => {
+ window.removeEventListener("popstate", preventGoBack);
+ }
+}, [])
+
history.pushState()로 현재 페이지를 스택 마지막에 추가popstate 이벤트 콜백 등록popstate 이벤트 발생시, 스택이 하나 줄어듦. but 콜백 함수에서 다시 스택을 추가함하지만 이와같은 방법에는 단점이 있는데, 사용자가 아무리 뒤로가기를 눌러도 뒤로가기가 동작되지 않는 것처럼 보이게 만든다는 점이다. 이를 해소하기 위해 다음과 같이 콜백함수를 수정할 수 있다.
1
+2
+3
+4
+5
+6
+7
+
const preventGoBack = () => {
+ if(confirm("정말 뒤로 가시겠습니까?")) {
+ history.back();
+ } else {
+ history.pushState(null, "", location.href);
+ }
+};
+
스택을 하나 추가하기 전에 사용자에게 경고창을 띄우고, 확인을 눌렀을 경우에는 한번 더 뒤로가기를 시도해 이전 페이지로 이동하는 방법이다.
여기서 새로고침/창닫기/링크이동에서 했던 것처럼 사용자가 입력을 했을때만 뒤로가기를 막도록 하면 다음과 같다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+
const [hasInputFilled, setHasInputFilled] = useState(false);
+
+useEffect(() => {
+ const preventGoBack = () => {
+ if(!hasInputFilled) {
+ return;
+ }
+
+ if(confirm("정말 뒤로 가시겠습니까?")) {
+ history.back();
+ } else {
+ history.pushState(null, "", location.href);
+ }
+ };
+
+ if(hasInputFilled) {
+ history.pushState(null, "", location.href);
+ }
+ window.addEventListener("popstate", preventGoBack);
+
+ return () => {
+ window.removeEventListener("popstate", preventGoBack);
+ }
+}, [hasInputFilled])
+
여기서 스택에 넣어진 현재 페이지의 길이를 저장하여 조금 더 안정적으로 동작하도록 할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+
const [hasInputFilled, setHasInputFilled] = useState(false);
+const [pushedLength, setPushedLength] = useState(0)
+
+useEffect(() => {
+ const preventGoBack = () => {
+ if(pushedLength === 0) {
+ return;
+ }
+
+ if(confirm("정말 뒤로 가시겠습니까?")) {
+ history.back();
+ } else {
+ history.pushState(null, "", location.href);
+ }
+ };
+
+ if(hasInputFilled && pushedLength === 0) {
+ history.pushState(null, "", location.href);
+ setPushedLength(1)
+ } else if(!hasInputFilled && pushedLength === 1) {
+ history.back();
+ setPushedLength(0);
+ }
+
+ window.addEventListener("popstate", preventGoBack);
+
+ return () => {
+ window.removeEventListener("popstate", preventGoBack);
+ }
+}, [hasInputFilled, pushedLength])
+
Comments powered by Disqus.
최근 프로젝트에서 리액트 앱을 배포하였는데, 인터넷 속도가 느린 환경에서 자바스크립트를 다운로드 받는 시간이 오래 걸린다는 걸 눈치챘다.
눈치챘다는 표현이 어울리는데 왜냐하면 사실 당연한 건데 이제까지 신경쓰지 않았던 부분이기 때문이다. 리액트앱은 매우 큰 자바스크립트 파일 하나로 이루어져있고, 이를 다운로드 받는 것은 당연히 오래 걸리는 일이기 때문이다.
따라서 이 시간 동안 단순한 로딩 화면이라도 띄울수있다면 사용자 경험을 향상 시킬 수 있을 것이라 생각되어 관련된 공부를 하게 되었다.
사용자가 우리의 앱에 접근하고, 리액트가 사용자 브라우저에 띄워지기까지 다음과 같은 과정을 거친다.
사용자는 주소창으로 우리의 앱에 접근한다.
이때 우리가 로딩 처리해줄 수 있는 순간은 바로 4번뿐이다. 1 ~ 3번은 우리가 처리할 수 없고, 네트워크과 브라우저에게 맡겨야하는 부분이기 때문이다. 5번에서는 각종 초기화 작업들이 이루어 질텐데, 이미 리액트 앱은 실행된 상태이므로 앱 안에서 로딩처리하면 될 일이다.
자, 그럼 4번을 어떻게 처리해야할까? 이 주제에 관해 얘기하기 전에 먼저 정말로 처리해줘야하는지 알아보자.
다음은 크롬 개발자 도구를 사용하여 보급형 휴대전화에서 필자의 프로젝트의 다운로드 속도를 측정한 것이다.
위 결과를 보면 알겠지만, 보급형 휴대전화를 사용하는 사용자는 리액트 앱이 실행되기까지 15초 가량이 걸리게 된다. 만약 그 시간동안 흰화면만 띄워지고 아무런 인터랙션도 없다면, 필자라면 그냥 그 사이트를 나갈 것이다. 이는 유저이탈을 불러일으켜 서비스 운영에 악영향을 끼치게 된다. 따라서 우리는 시간동안 무엇이든 띄워야한다.
방법은 간단하다.
먼저 리액트 프로젝트를 만들면 생성되는 public/index.html 파일의 초기 상태는 다음과 같다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
<!DOCTYPE html>
+<html lang="ko">
+ <meta charset="utf-8" />
+ <link rel="icon" type="image/png" href="%PUBLIC_URL%/favicon.png" />
+ <meta name="viewport" content="width=device-width, initial-scale=1" />
+ <meta name="theme-color" content="#000000" />
+ <meta
+ name="description"
+ content="Web site created using create-react-app"
+ />
+ <link rel="manifest" href="%PUBLIC_URL%/manifest.json" />
+ <title>React App</title>
+
+ </head>
+ <body>
+ <div id="root"></div>
+ </body>
+</html>
+
여기서 리액트 앱은 body 안의 “root”라는 id를 가지는 div 안에서 실행되니, 우리는 그 밖에서 무언가를 작업하면 js 파일이 다운로드 받기 전에도 무언가를 띄울 수 있다는 것을 짐작할 수 있다.
따라서 필자는 다음과 같이 index.html을 작성하여 로딩 엘리먼트를 띄웠다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+
<!DOCTYPE html>
+<html lang="ko">
+ <meta charset="utf-8" />
+ <link rel="icon" type="image/png" href="%PUBLIC_URL%/favicon.png" />
+ <meta name="viewport" content="width=device-width, initial-scale=1" />
+ <meta name="theme-color" content="#000000" />
+ <meta
+ name="description"
+ content="Web site created using create-react-app"
+ />
+ <link rel="manifest" href="%PUBLIC_URL%/manifest.json" />
+ <title>React App</title>
+
+ <!--
+ index.html에 적용할 css 파일 import
+ -->
+ <link rel="stylesheet" type="text/css" href="%PUBLIC_URL%/index.css" />
+ <style>
+ /* css 파일을 연동하는 시간을 아끼기 위한 내부 스타일시트 선언*/
+ #loadingElement {
+ animation: 1s linear infinite rotateLoadingElement;
+ }
+ @keyframes rotateLoadingElement {
+ from {
+ transform:translate(-50%,-50%) rotate(0deg);
+ }
+ to {
+ transform:translate(-50%,-50%) rotate(360deg);
+ }
+ }
+ </style>
+ </head>
+ <body>
+ <div id="root"></div>
+
+ <!--
+ 번들을 다운로드 받는 동안, 아래 loading화면을 띄움
+ css 파일을 연동하는 시간도 아끼기 위해 inline style도 사용함
+ 번들 다운로드 후, 내부 api 작업을 위한 로딩은 #root 안에서 해결
+ -->
+ <div id="loading">
+ <img id="loadingElement" src="%PUBLIC_URL%/loading.png" style="position:absolute; width:100px; top:50%; left:50%;"/>
+ </div>
+ </body>
+</html>
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
/* index.css */
+#root:not(:empty) ~ #loading {
+ display: none;
+}
+
+#loading {
+ background-color: #f9f9f9;
+ width: 100vw;
+ height: 100vh;
+}
+
그 결과가 다음과 같다.
index.html이 다운로드 받아지고, js 번들파일이 다운로드 되기 전까지 로딩 엘리먼트가 제대로 띄워짐을 알 수 있다. (이후 다른 로딩엘리먼트가 띄워지는데, 이는 리액트 앱 내부에서 렌더되는 것이다.)
이로써 유저는 번들 파일이 다운받아지는 시간동안 최소한 작업이 진행되고 있다는 것을 알 수 있어 조금이라도 더 기다리게 할 수 있다.
여기에 단순 로딩엘리먼트만이 아닌, 작업 안내 페이지를 띄운다면 더욱 효과가 클 것이다.
Comments powered by Disqus.
먼저 Webpack 이 실행되어 src/index.js 부터 살펴본다. 그리고 import 된 모듈을 따라가며 dependency graph를 전부다 살펴볼때까지 진행한다.
이후 모든 자바스크립트 파일들을 Babel로 넘겨주어 ES5+ 로 문법을 번역한다.
웹팩은 모든 자바스크립트 파일을 하나의 파일로 만들고, 서버를 실행한다.
이후 코드가 변경되고 저장이 되면, webpack에 연결된 hot-reload 모듈을 통해 다시 1번부터 과정을 반복한다.
JS 플러그인을 사용하여 CSS를 변환시키는 CSS postprocessor이다. CSS의 babel과 같은 것이다.
postprocessor이므로, preprocessor인 SASS와 다르게, CSS를 processing하여 플러그인을 거쳐 새로운 css로 변환해준다.
1
+
CSS -> Parser -> Plugin -> Stringfier -> New CSS
+
1
+2
+3
+4
+5
+6
+
module.exports = {
+ plugins: {
+ tailwindcss: {},
+ autoprefixer: {},
+ },
+};
+
tailwindcss를 CRA에서 사용하는 방법을 검색해보면 수많은 포스트에서 CRACO를 사용해야한다고 나와있다.
이 CRACO을 통해 postcss를 webpack의 hot-reload 과정에 등록하여 hot-reload가 되는 방식으로 하였다.
CRA v5에서도 tailwind.config.js 가 필요하다. 이를 위해선 npx tailwindcss init -p 가 필요하고, 이 작업을 통해 postcss.config.js도 추가 된다.
Comments powered by Disqus.
기존에 React 17을 사용하던 Forkie Player 프로젝트를 React 18로 업데이트 하는 기록
automatic batchingSuspense
검색, 플레이리스트 수정 등을 할때 Loading일 경우 fallback을 하도록 하는 좀 더 깔끔한 코드를 원했기 때문에 react 18을 도입하였다공식문서에 나온대로 업데이트 하면 된다.
https://reactjs.org/blog/2022/03/08/react-18-upgrade-guide.html
다른 분이 작성한 문서를 보며 해결하였다.
타입스트립트를 사용하지 않을 경우 큰 문제는 없다. 하지만, 타입스크립트를 사용할 경우 패키지와 사용하는 리액트 버전이 차이가 나기에 타입 에러가 발생할 수도 있다.
자주 업데이트가 되는 패키지의 경우 이미 react 18을 대응하여 업데이트를 해놨을테니 해당 버전으로 업데이트를 하면된다.
하지만 문제가 되는 경우가 두가지 있다.
위 두가지 문제를 해결하기 위해선 force-resolution을 하여야한다. 패키지 매니저로 npm을 사용하는 경우와 yarn을 사용하는 경우 다르게 대응하여야한다. 이 글은 yarn을 기준으로 적었다.
yarn 에서는 package.json에 resolution 을 추가함으로써 해결할 수 있다고 공식문서에서 말하고 있다.
forkie에서 적용한 예시는 다음과 같다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
{
+ "name": "forkie-player_web_renewal",
+ "dependencies": {
+ "@types/react": "^18.0.10",
+ "@types/react-dom": "^18.0.5",
+ "react": "^18.1.0",
+ "react-dom": "^18.1.0"
+ },
+ "resolutions": {
+ "react": "^18.1.0",
+ "react-dom": "^18.1.0",
+ "@types/react": "^18.0.10",
+ "@types/react-dom": "^18.0.5"
+ }
+}
+
이후 yarn install을 하면 된다.
Comments powered by Disqus.
React v18의 정식 출시가 코앞에 있고, 가장 큰 변경점 중 하나가 서버사이드 렌더링에 관한 내용이라는 소식을 듣고 마침 SSR 에 대해 흥미가 있던 터라 한번 React v18의 주요 변경점이 뭔지 공부해보기로 했다.
먼저 기존의 React v17을 v18로 마이그레이션 하는 것은 문제 없다고 한다. 리액트 팀에서 이 부분을 특히 신경써서 만들었다고 하니 믿어도 될 것같다.
먼저 리액트의 배치에 대해 알아야한다.
리액트에서 더 나은 성능과 예상치않는 버그의 방지를 위해 여러 개의 상태 업데이트를 한번의 리렌더링으로 묶는 작업
아래 예시를 보자
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
function App() {
+ const [count, setCount] = useState(0);
+ const [flag, setFlag] = useState(false);
+
+ function handleClick() {
+ setCount(c => c + 1); // 아직 리렌더링 되지 않습니다.
+ setFlag(f => !f); // 아직 리렌더링 되지 않습니다.
+ // 리액트는 오직 마지막에만 리렌더링을 한 번 수행합니다. (배치 적용)
+ }
+
+ return (
+ <div>
+ <button onClick={handleClick}>Next</button>
+ <h1 style=>{count}</h1>
+ </div>
+ );
+}
+
handleClick 에서는 총 두번의 상태 업데이트를 했다. 하지만, 리액트에서는 언제나 배치를 수행하여 이 두번의 상태업데이트를 한번의 리렌더링으로 처리한다.
하지만 배치가 수행되지 않는 예외가 존재한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
function App() {
+ const [count, setCount] = useState(0);
+ const [flag, setFlag] = useState(false);
+
+ function handleClick() {
+ fetchSomething().then(() => {
+ // 리액트 17 및 그 이전 버전에서는 배치가 수행되지 않습니다. 왜냐하면
+ // 이 코드들은 이벤트 이후의 콜백에서 실행되기 때문입니다.
+ setCount(c => c + 1); // 리렌더링
+ setFlag(f => !f); // 리렌더링
+ });
+ }
+
+ return (
+ <div>
+ <button onClick={handleClick}>Next</button>
+ <h1 style=>{count}</h1>
+ </div>
+ );
+}
+
위처럼 리액트 v17까지는 이벤트 핸들러 안에서의 상태업데이트에서는 배치가 적용되지 않았다.
하지만 v18부터는 자동배치가 추가되어, 이벤트 핸들러 함수 안에서 상태 업데이트에 대해서도 자동으로 배치를 적용시켜준다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
setTimeout(() => {
+ setCount(c => c + 1);
+ setFlag(f => !f);
+ // 리액트는 오직 마지막에만 리렌더링을 한 번 수행합니다. (배치 적용)
+}, 1000);
+
+fetch(/*...*/).then(() => {
+ setCount(c => c + 1);
+ setFlag(f => !f);
+ // 리액트는 오직 마지막에만 리렌더링을 한 번 수행합니다. (배치 적용)
+})
+
+elm.addEventListener('click', () => {
+ setCount(c => c + 1);
+ setFlag(f => !f);
+ // 리액트는 오직 마지막에만 리렌더링을 한 번 수행합니다. (배치 적용)
+});
+
이 자동 배치를 사용하기위해서는 리액트앱의 최상단에서 ReactDOM.render 함수 대신에 새로운 ReactDOM.createRoot 함수를 사용해야한다.
하지만 자동배치를 하고 싶지 않은 경우도 매우 드물게 있을 것이다. 이때는 다음과 같이 ReactDOM.flushSync라는 함수를 사용하면 해결된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
import { flushSync } from 'react-dom';
+
+function handleClick() {
+ flushSync(() => {
+ setCounter(c => c + 1);
+ }); // 리액트는 즉시 DOM을 업데이트합니다.
+
+ flushSync(() => {
+ setFlag(f => !f);
+ }); // 리액트는 즉시 DOM을 업데이트합니다.
+}
+
startTransition은 동시성(concurrent) API 안에 분류되어있는데, 아직 자세한 내용은 공개되지 않았다고 한다. 추후 조사가 필요함
리액트에서 발생하는 상태업데이트에는 두가지 분류가 있다.
중요한 건 전환업데이트때문에 긴급업데이트가 방해되면 안된다.
React v17까지는 상태 업데이트를 긴급 혹은 전환으로 명시하는 방법은 없었다. 하지만 React v18부터는 startTansition API를 제공함으로써 전환업데이트를 명시적으로 구분하여 상태업데이트를 할 수 있게 되었다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+
import { useTransition } from 'react';
+
+function SearchBar() {
+ const [isPending, startTransition] = useTransition();
+
+ // ...
+
+ function handleChange(e) {
+ const input = e.target.value;
+
+ // 긴급 업데이트: 타이핑 결과를 보여준다.
+ setInputValue(input);
+
+ // 이 안의 모든 상태 업데이트는 전환 업데이트가 된다.
+ startTransition(() => {
+ setSearchQuery(input);
+ });
+ }
+
+ // ...
+}
+
좀 더 이해를 돕기위해 다음 예시를 보자.
React v17 까지의 방식대로 아래와 같이 코드짰다고 해보자
1
+2
+3
+4
+5
+6
+
function handleChange(e) {
+ const input = e.target.value;
+
+ setInputValue(input);
+ setSearchQuery(input);
+}
+
이때, 리액트에서는 배치가 이루어져, setInputValue를 거치고, setSearchQuery를 기다렸다가 한번에 상태업데이트를 했다.
이는 긴급업데이트를 하는데 전환업데이트까지 기다려야하는 UX의 관점에서 안좋은 영향을 끼친다.
하지만, startTansition으로 아래와 같이 코드를 짰다고 해보자.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
function handleChange(e) {
+ const input = e.target.value;
+
+ // 긴급 업데이트: 타이핑 결과를 보여준다.
+ setInputValue(input);
+
+ // 이 안의 모든 상태 업데이트는 전환 업데이트가 된다.
+ startTransition(() => {
+ // 전환 업데이트: 결과를 보여준다.
+ setSearchQuery(input);
+ });
+ }
+
setInputValue을 거치고, startTransition가 수행된 후 바로, startTansition 외부에 있는 상태들이 업데이트되고, 내부에 있는 상태업데이트는 pending 상태가 된다. 따라서 긴급업데이트는 바로 되고, 전환업데이트는 기다렸다가 되도록 하여, UX의 관점에서 더 향상된다.
이때, 소수의 케이스에 대응하기 위해 Hook을 거치지 않고, React.startTransition을 사용할 수도 있다.
startTransition을 사용하는 2가지 케이스
Suspense는 SSR에 관한 컴포넌트이기 때문에 먼저 SSR에 대해서 알아야한다.
React는 자바스크립트로 이루어져있고, 따라서 사용자 브라우저로 자바스크립트가 다운이 되고, 이 자바스크립트를 실행하고, 로드가 완료가 되어야 화면에 컴포넌트들이 보여진다. 즉, 이 자바스크립트를 로딩하는 동안 사용자가 볼수 있는 페이지는 빈페이지 뿐이고, 어플리케이션의 크기가 크다면 이 시간은 더 길어지게 된다.
하지만 SSR을 사용하면, 서버에서 리액트 컴포넌트를 HTML로 렌터링 하여 사용자에게 전송할 수 있다. 이때 자바스크립트는 로딩되지 않았으므로 인터랙션은 불가능하지만, 최소한 사용자가 컨텐츠는 볼 수 있도록 해준다.
자바스크립트가 모두 로딩되면, 이 HTML을 인터랙션이 가능한 상태로 만든다. 이때 우리는 리액트에게 서버에서 생성된 페이지가 있다. 여기에 이벤트 핸들러를 붙여라고 명령하고, 리액트는 이미 생성되어있는 HTML에 이밴트핸들러를 연결한다. 이 작업을 hydration이라고 한다.
위에서 설명한 SSR 과정을 정리하면 다음과 같다.
문제점 1 : 1번에서의 문제점
HTML을 렌더할때 필요한 데이터를 모두 가지고 있어야한다.
예를 들어, 댓글을 서버 HTML 결과물에 포함시킨다고 결정하면 댓글에 필요한 데이터를 API나 데이터베이스를 통해 불러오고 결과 HTML에 포함시켜야한다. 이때 이 댓글 데이터를 불러오는 것 때문에, 이미 작업이 끝난 다른 HTML들도 내려보내지 못한다.
만약 포함시키지 않으면 자바스크립트를 통해 렌더해야하므로 사용자는 자바스크립트 로딩이 끝날때까지 댓글을 볼 수 없다.
문제점 2 : hydration에서의 문제점 1
hydrating 과정에서 리액트는 컴포넌트들을 렌더링하는 동안, 서버에서 생성한 HTML을 순회하면서 이벤트핸들러를 HTML에 연결한다. 이 작업을 수행하려면 브라우저의 컴포넌트에서 생성된 트리가 서버에서 생성된 트리와 일치되어야한다. 그렇지 않으면 React는 이를 맞추지 못하게 된다. 결과적으로 클라이언트에 있는 모든 컴포넌트의 자바스크립트를 로딩해야 hydrate가 가능해진다.
예를 들어 댓글에 복잡한 기능이 포함되어있어 이를 위한 자바스크립트 로딩이 오래걸린다고 해보자.
서버에서 댓글을 HTML에 포함 시킬 경우, hydration은 한번에 일어나야하기떄문에 댓글 위젯에 있는 코드를 로딩하기 전까지는 다른 컴포넌트(ex : 사이드바, 게시글)에 대해서는 hydration을 할 수가 없다.
코드 분할을 통해서 해결할 수 있지만, 이때는 서버 HTML에서 댓글을 제거해야한다. 그렇지 않으면 리액트는 이 HTML을 어떻게 해야할지 모르고 hydration 중에 삭제해 버린다.
문제점 3 : hydration에서의 문제점 2
현재 리액트는 한번에 모든 트리에 hydration을 진행한다. 즉 일단 hydration을 시작하면, 트리 전체에서 이 작업이 완료할 때까지 멈출 수 없다. 따라서 모든 컴포넌트가 hydration을 할 때까지 기다려야만 사용자는 컴포넌트와 상호작용할 수 있다.
만약 사용자가 로딩이 오래 걸려 페이지에서 벗어나고 싶어해도, 브라우저는 hydration 작업으로 바쁘기 때문에 아직 로딩중이고, 다른 페이지로 이동할 수도 없다.
기존 SSR에서의 문제점들의 공통점은 모든 작업들이 전체 앱을 기준으로 일어나고, 한 단계가 끝나야 다음 단계로 넘어가는 방식으로 되어있어 발생한다는 점이다. 따라서 React 18에서는 Suspense를 이용한 두가지 주요 SSR 기능을 제공한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+
<main>
+ <nav>
+ <!--NavBar -->
+ <a href="/">Home</a>
+ </nav>
+ <aside>
+ <!-- Sidebar -->
+ <a href="/profile">Profile</a>
+ </aside>
+ <article>
+ <!-- Post -->
+ <p>Hello world</p>
+ </article>
+ <section>
+ <!-- Comments -->
+ <p>First comment</p>
+ <p>Second comment</p>
+ </section>
+</main>
+
현재 SSR 체계에서 위 HTML을 밭으면 클라이언트를 아래를 그릴 것이다.
그리고 코드를 로딩하고 hydration이 끝나면 아래와 같은 완전한 앱이 완성된다.
하지만 React 18에서는 페이지의 일부를 Suspense로 감쌀 수 있다.
예를들어, 댓글을 Suspense로 감싸고, 로딩되기전까지는 Spinner를 보여지게 할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
<Layout>
+ <NavBar />
+ <Sidebar />
+ <RightPane>
+ <Post />
+ <Suspense fallback={<Spinner />}>
+ <Comments />
+ </Suspense>
+ </RightPane>
+</Layout>
+
<Comments>를 <Suspense>로 감싼 덕분에, 리액트는 댓글 컴포넌트를 기다리지 않고, HTML을 스트리밍할 수 있다.
클라이언트가 받은 최초의 HTML은 다음과 같을 것이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
<main>
+ <nav>
+ <!--NavBar -->
+ <a href="/">Home</a>
+ </nav>
+ <aside>
+ <!-- Sidebar -->
+ <a href="/profile">Profile</a>
+ </aside>
+ <article>
+ <!-- Post -->
+ <p>Hello world</p>
+ </article>
+ <section id="comments-spinner">
+ <!-- Spinner -->
+ <img width="400" src="spinner.gif" alt="Loading..." />
+ </section>
+</main>
+
그리고 댓글 데이터가 준비 된다면, 리액트는 같은 스트림으로 추가적인 HTML을 보낼 텐데, 여기에는 HTML을 올바른 위치에 삽입하기 위한 최소한의 인라인 script 태그가 포함되어있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
<div hidden id="comments">
+ <!-- Comments -->
+ <p>First comment</p>
+ <p>Second comment</p>
+</div>
+<script>
+ // This implementation is slightly simplified
+ document
+ .getElementById('sections-spinner')
+ .replaceChildren(document.getElementById('comments'))
+</script>
+
그 결과 리액트 자체가 클라이언트에 로드되기 이전에, 뒤늦게 댓글용 HTML 코드가 삽입될 것이다.
이로써 첫번째 문제를 해결할 수 있다. 더이상 모든 데이터를 fetch할 때까지 기다릴 필요가 없다. 화면 일부분이 초기 HTML을 지연시킨다면, 모든 HTML을 지연시키거나 HTML에서 일부를 제외시킬 필요가 없다. HTML 스트림에서 나중에 해당 부분을 별도로 삽입할 수 있다.
초기 HTML은 일찍 보낼 수 있지만, 아직 전체 hydration이 끝나야 사용자가 인터랙션할 수 있다는 것에는 변함이 없다.
따라서 큰 번들을 피하기 위해 “코드 스플릿”을 통해 코드의 일부를 동기적으로 로딩하지 않게하거나, 혹은 번들러가 별도의 script 태그로 분할하는 방법도 있다.
이때 React.lazy 로 코드를 분할하여 메인번들에서 댓글 코드를 아래처럼 분리할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
import { lazy } from 'react'
+
+const Comments = lazy(() => import('./Comments.js'));
+
+// ...
+
+<Suspense fallback={<Spinner />}>
+ <Comments />
+</Suspense>
+
과거에는 이 방법은 동작하지 않았다. 왜냐하면, 기존의 SSR에서는 코드스플릿 컴포넌트를 제외하거나 코드를 모둔 로딩한 후 hydration을 하거나 둘 중 하나일뿐이었다. 따라서 코드스플릿의 목적이 다소 손상되었다. 하지만 React v18에서는 Suspense을 통해 댓글 위젯이 로드되기 전에 애플리케이션을 hydration 할 수 있다.
즉, <Comments>를 <Suspense>로 감쌈으로써, 리액트에 페이지의 나머지 부분을 스트리밍하는 것을 차단하지 않게하고, hydration 과정 또한 차단하지 않게 할 수 있다. 이로써 첫번째 두번째 문제점은 해결되었다.
그럼 세번째 문제점인, 전체 앱이 hydration 되기 전까지는 다른 컴포넌트와 인터랙션 할 수 없다는 문제는 어떻게 될까?
React 18에서는 hydration 작업이 브라우저의 다른 작업을 하는 것을 막지 않음으로써 해결된다.
React 18에서는, Suspense 바운더리 내에 있는 hydration 콘텐츠는 브라우저가 이벤트를 처리할 수 있는 한에서만 수행된다. 따라서 사용자가 다른 부분을 클릭하면 그것이 먼저 처리되고, 페이지에서 벗어나고 싶을때도 바로 처리된다.
만약 한 페이지에 여러개의 Suspense로 감싸진 컴포넌트가 있으면 어떻게 동작할까?
예를들어, sidebar와 comments가 Suspense로 감싸져 있다고 해보자. 그러면 sidebar와 comments를 제외한 부분의 작업이 hydration까지 모두 마쳐 다음과 같은 모습을 보이게 될 것이다.
그 다음, sidebar와 comments를 모두 포함하는 번들이 로딩되고, 두 컴포넌트에 대해 hydration을 시도 할 것이다.
이때 만약, 사용자가 댓글위젯에 인터랙션을 시도했다고 해보자. 그럼 아래와 같이 hydration의 우선순위가 바뀌어서 리액트는 comments 부분을 먼저 hydration 하도록 하게된다.
아래와 같이 Suspense를 사용하게 되면 어떻게 될까?
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
<Layout>
+ <NavBar />
+ <Suspense fallback={<BigSpinner />}>
+ <Suspense fallback={<SidebarGlimmer />}>
+ <Sidebar />
+ </Suspense>
+ <RightPane>
+ <Post />
+ <Suspense fallback={<CommentsGlimmer />}>
+ <Comments />
+ </Suspense>
+ </RightPane>
+ </Suspense>
+</Layout>
+
초기 HTML은 <NavBar>만을 포함하지만, 나머지는 사용자가 상호작용한 부분을 우선시하여 관련 코드가 로딩되는 즉시 스트리밍하여 컴포넌트에서 hydration을 할 것이다.
“어떻게 애플리케이션이 전체적으로 hydration 되지 않았는데 동작할 수 있는걸까? 리액트는 개별 컴포넌트에 개별적으로 hydration 하는 것이 아닌
<Suspense>바운더리에 대해 hydration을 발생시킨다<Suspense>는 당장 나타나지 않는 컨텐츠에 사용되므로, 코드는 이 자식 컨텐츠가 즉시 이용할 수 없는 상태에 대해 탄력적으로 대처할 수 있다. 리액트는 항상 부모 컴포넌트를 우선순위로 hydration 하므로, 컴포넌트는 항상 props set을 가지고 있을 수 있다. 리액트는 이벤트가 발생될 때 이벤트 지점에서 전체 상위 트리에 hydration이 진행될 때 까지 이를 보류 시켜 둔다. 마지막으로 상위 항목이 그럼에도 hydration이 되지 않는다면, 리액트는 이를 숨기고 코드가 로드 될 때 까지fallback으로 화면을 바꿔 둔다. 이렇게 하면 트리가 일관되게 유지된다.”
https://codesandbox.io/s/festive-star-9hfqt?file=/src/App.js
위 데모코드에서 sever/delays.js을 조작함으로써 React 18의 SSR을 확인할 수 있다.
리액트 18은 SSR을 위한 두가지 주요 기능을 제공한다.
<script>태그와 함께 추가적으로 스트리밍할 수 있다.이 두가지 기능은 SSR과 관련된 아래 세가지 문제를 해결해준다.
<Suspense>는 이러한 모든 기능에 대한 옵트인 역할을 한다. 이 개선사항은 리액트 내부에서 자동으로 수행되며, 기존 리액트 코드의 대부분과 함께 작동 될 것으로 보인다. 이는 로딩중 상태를 선언적으로 표현하는 역할을 한다. if (isLoading)과 크게 달라보이지 않을 수 있지만, <Suspense>는 이러한 모든 개선사항을 실현해낸다.
클라이언트와 서버 사이의 hydraton missmatch를 피하면서 unique ID를 생성해주는 Hook. SSR을 할때 사용함. 물론 그냥 Id 를 사용하고 싶을때 사용해도 됨.
startTransition을 만들기 위한 Hook
1
+
const deferredValue = useDeferredValue(value);
+
value를 받고, 그 복사본을 반환함. 이 복사본은 좀 더 긴급한 업데이트가 끝날때까지 연기하기위해 사용됨.
user input 같은 긴급한 업데이트가 있다면, deferredValue는 이전의 값을 가리키고, 긴급 업데이트가 끝난 후에 업데이트 됨.
긴급한 업데이트가 진행중일때 자식 컴포넌트가 리렌더링되는 것을 막으려면 useMemo 등과 함께 사용되어야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
function Typeahead() {
+ const query = useSearchQuery('');
+ const deferredQuery = useDeferredValue(query);
+
+ // Memoizing tells React to only re-render when deferredQuery changes,
+ // not when query changes.
+ const suggestions = useMemo(() =>
+ <SearchSuggestions query={deferredQuery} />,
+ [deferredQuery]
+ );
+
+ return (
+ <>
+ <SearchInput query={query} />
+ <Suspense fallback="Loading results...">
+ {suggestions}
+ </Suspense>
+ </>
+ );
+}
+
redux store, 글로벌 변수, dom 상태 등 external store를 구독하여 concurrent read를 지원함.
React 18부터는 렌더링이 렌더링을 잠시 중단할 수 있게된다. 그러면서 각 컴포넌트별로 업데이트 속도가 달라서 발생하는 Tearing(시각적 불일치) 문제가 발생했는데 이를 해결하기 위한 Hook이다.
external data를 구독할때 useEffect 대신에 사용할 수 있다.
1
+
const state = useSyncExternalStore(subscribe, getSnapshot[, getServerSnapshot]);
+
css-in-js 라이브러리가 렌더링 도중에 스타일을 삽입할때 성능문제를 해결할 수 있는 새로운 Hook
모든 DOM mutation이 발생하기 전에 동기적으로 호출됨.
DOM에 스타일을 삽입할때 사용함.
한정된 영역에서 사용되므로, refs나 schedule update가 불가능하다.
1
+
useInsertionEffect(didUpdate)
+
useLayoutEffect 로 dom-layout를 읽기 전에 사용한다.
클릭, 키다운과 같은 이벤트 중에 업데이트가 발생할때, useEffect가 일관된 타이밍에 호출되도록 함.
이전에는 일관되지 않았음.
이제 React는 Promise, Symbol, Object.assign과 같은 최신JS에 의존한다. 따라서 IE와 같은 오래된 브라우저에 대응하려면 bundled application에 polyfill를 사용해야한다.
이전에는 undefined를 렌더할 경우 throw가 발생했으나, 이제는 undefined도 된다.(null은 원래 됐음)
React 18부터는 react-dom의 render함수는 deprecated 되고, createRoot 가 사용됨.
1
+2
+3
+4
+5
+6
+
// ~React 17
+ReactDOM.render(<App />, container);
+
+// React 18
+const root = ReactDOM.createRoot(container);
+root.render(<App />);
+
기존의 redner 함수를 사용하게 되면, 컴포넌트 트리를 React 17과 그 이전의 동작과 동일한 레거시 모드로 동작하도록 함.
새로운 createRoot 함수는 컴포넌트 트리를 동시성 기능들과 자동배치 등 React 18의 기능들이 동작하도록 함.
React 18에서는 렌더링을 위한 3가지 API가 존재함
https://medium.com/naver-place-dev/react-18%EC%9D%84-%EC%A4%80%EB%B9%84%ED%95%98%EC%84%B8%EC%9A%94-8603c36ddb25
https://yceffort.kr/2021/09/react-18-ssr-architecture#%EC%98%A4%EB%8A%98%EB%82%A0-ssr%EC%9D%98-%EB%AC%B8%EC%A0%9C%EC%A0%90%EC%9D%80-%EB%AC%B4%EC%97%87%EC%9D%B8%EA%B0%80
https://velog.io/@moonelysian/React-18-%EC%82%B4%ED%8E%B4%EB%B3%B4%EA%B8%B0
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
import { takeEvery } from "redux-saga/effects";
+import Api from "./path/to/api";
+
+function* watchFetchProducts() {
+ yield takeEvery("PRODUCTS_REQUESTED", fetchProducts);
+}
+
+function* fetchProducts() {
+ const products = yield Api.fetch("/products");
+ console.log(products);
+}
+
1
+2
+
const iterator = fetchProducts()
+assert.deepEqual(iterator.next().value, ??)
+
이때 위 featchProducts()를 테스트하기 위해선, API를 호출해야하는데, 실제로 호출할 순 없으므로 다른 방법을 통해 API를 호출하지 않고 테스트를 진행해야한다.
1
+2
+3
+4
+5
+6
+
import { call } from "redux-saga/effects";
+
+function* fetchProducts() {
+ const products = yield call(Api.fetch, "/products");
+ // ...
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
import { call } from "redux-saga/effects";
+import Api from "...";
+
+const iterator = fetchProducts();
+
+// expects a call instruction
+assert.deepEqual(
+ iterator.next().value,
+ call(Api.fetch, "/products"),
+ "fetchProducts should yield an Effect call(Api.fetch, './products')"
+);
+
1
+2
+
yield call([obj, obj.method], arg1, arg2, ...); // 주어진 object의 주어진 method를 호출
+yield call(fn, arg1, arg2, ...);
+
1
+
yield apply(obj, obj.method, [arg1, arg2, ...]) // call과 같고 arguments 형식만 반대
+
1
+
yield cps(fn, arg1, arg2, ...)
+
제너레이터 함수 안에서, dispatch를 하기 위해 아래와 같이 직접 dispatch를 호출할 수 있다.
1
+2
+3
+4
+
function* fetchProducts(dispatch) {
+ const products = yield call(Api.fetch, "/products");
+ dispatch({ type: "PRODUCTS_RECEIVED", products });
+}
+
하지만 이는 위에서와 같이, 테스트를 하기 위해선 dispatch 함수를 mock 해야할 필요가 있다.
따라서 redux-saga에서는 아래와 같이 “put” effect를 통해 dispatch를 할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+
import { call, put } from "redux-saga/effects";
+// ...
+
+function* fetchProducts() {
+ const products = yield call(Api.fetch, "/products");
+ // create and yield a dispatch Effect
+ yield put({ type: "PRODUCTS_RECEIVED", products });
+}
+
사가에서는 아래와 같은 방식으로 error handling 가능
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
import Api from "./path/to/api";
+import { call, put } from "redux-saga/effects";
+
+// ...
+
+function* fetchProducts() {
+ try {
+ const products = yield call(Api.fetch, "/products");
+ yield put({ type: "PRODUCTS_RECEIVED", products });
+ } catch (error) {
+ yield put({ type: "PRODUCTS_REQUEST_FAILED", error });
+ }
+}
+
아래와 같은 형태로도 가능하다
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
import Api from "./path/to/api";
+import { call, put } from "redux-saga/effects";
+
+function fetchProductsApi() {
+ return Api.fetch("/products")
+ .then((response) => ({ response }))
+ .catch((error) => ({ error }));
+}
+
+function* fetchProducts() {
+ const { response, error } = yield call(fetchProductsApi);
+ if (response) yield put({ type: "PRODUCTS_RECEIVED", products: response });
+ else yield put({ type: "PRODUCTS_REQUEST_FAILED", error });
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+
import { takeEverym, takeLatest } from "redux-saga/effects";
+
+function* watchFetchData() {
+ yield takeEvery("FETCH_REQUESTED", fetchData);
+}
+function* watchFetchData() {
+ yield takeLatest("FETCH_REQUESTED", fetchData);
+}
+
아래와 같이 take/fork 를 통해 여러 요청을 동시적으로 수행할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
import { take, fork, ... } from 'redux-saga/effects'
+
+function* watchRequests() {
+ while (true) {
+ const {payload} = yield take('REQUEST')
+ yield fork(handleRequest, payload)
+ }
+}
+
+function* handleRequest(payload) { ... }
+
이때 REQUEST 요청을 순차적으로 첫번째부터 수행하고 싶을때는, queue를 만들어서 하나가 끝나면 다음 것을 꺼내어 수행하는 방식으로 하면 된다.
이때 redux-sage에서는 actionChannel(pattern)이라는 effect를 사용하여 구현할 수 있다. actionChannel은 saga가 API call 등으로 막혀있을때도 메세지를 받아 큐에 넣을 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
import { take, actionChannel, call, ... } from 'redux-saga/effects'
+
+function* watchRequests() {
+ // 1- Create a channel for request actions
+ const requestChan = yield actionChannel('REQUEST')
+ while (true) {
+ // 2- take from the channel
+ const {payload} = yield take(requestChan)
+ // 3- Note that we're using a blocking call
+ yield call(handleRequest, payload)
+ }
+}
+
+function* handleRequest(payload) { ... }
+
watch에서 call을 yield하면 saga는 call이 끝날때까지 기다린다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
function* fetchPosts() {
+ yield put(actions.requestPosts());
+ const products = yield call(fetchApi, "/products");
+ yield put(actions.receivePosts(products));
+}
+
+function* watchFetch() {
+ while (yield take("FETCH_POSTS")) {
+ yield call(fetchPosts); // waits for the fetchPosts task to terminate
+ }
+}
+
다음과 같이 all 이펙트를 사용하여 여러 제너레이터를 동시에 수행하고, 모두 끝날때까지 기다릴 수도 있다.
1
+2
+3
+4
+
function* mainSaga(getState) {
+ const results = yield all([call(task1), call(task2), ...])
+ yield put(showResults(results))
+}
+
takeEvery와 takeLatest가 어떻게 동시성을 제어하는가?
1
+2
+3
+4
+5
+6
+7
+8
+9
+
import { fork, take } from "redux-saga/effects";
+
+const takeEvery = (pattern, saga, ...args) =>
+ fork(function* () {
+ while (true) {
+ const action = yield take(pattern);
+ yield fork(saga, ...args.concat(action));
+ }
+ });
+
해당하는 pattern이 들어오면 fork를 통해 분리하여 처리한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
import { cancel, fork, take } from "redux-saga/effects";
+
+const takeLatest = (pattern, saga, ...args) =>
+ fork(function* () {
+ let lastTask;
+ while (true) {
+ const action = yield take(pattern);
+ if (lastTask) {
+ yield cancel(lastTask); // cancel is no-op if the task has already terminated
+ }
+ lastTask = yield fork(saga, ...args.concat(action));
+ }
+ });
+
새로운 것이 들어오면 이전에 들어온 것을 취소하고, 새로운 것을 수행한다.
redux-saga에서는 다음 두 이펙트를 통해 fork를 다룬다
Saga는 자기 안의 모든 명령어가 수행되고, 모든 attached forks가 종료되면 종료된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
import { fork, call, put, delay } from "redux-saga/effects";
+import api from "./somewhere/api"; // app specific
+import { receiveData } from "./somewhere/actions"; // app specific
+
+function* fetchAll() {
+ const task1 = yield fork(fetchResource, "users");
+ const task2 = yield fork(fetchResource, "comments");
+ yield delay(1000);
+}
+
+function* fetchResource(resource) {
+ const { data } = yield call(api.fetch, resource);
+ yield put(receiveData(data));
+}
+
+function* main() {
+ yield call(fetchAll);
+}
+
따라서 위 call(fetchAll)은 delay(1000)이 끝나고, fork 된 task1, task2 가 끝나야 종료된다.
이는 아래와 같이 parallel effect와 같은 동작을 한다.
1
+2
+3
+4
+5
+6
+7
+
function* fetchAll() {
+ yield all([
+ call(fetchResource, "users"), // task1
+ call(fetchResource, "comments"), // task2,
+ delay(1000),
+ ]);
+}
+
이때 위 코드는 3개의 child effect 중 하나가 실패하면, Error가 넘어가면서 3개의 child가 전부 실패하고(완료되지 않은 작업들만), Error는 call로 fetchAll을 호출한 함수로 throw된다.
이는 fork를 이용한 모델에서도 똑같이 동작하며 아래와 같이 main에서 try/catch를 통해 에러를 받을 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
//... imports
+
+function* fetchAll() {
+ const task1 = yield fork(fetchResource, "users");
+ const task2 = yield fork(fetchResource, "comments");
+ yield delay(1000);
+}
+
+function* fetchResource(resource) {
+ const { data } = yield call(api.fetch, resource);
+ yield put(receiveData(data));
+}
+
+function* main() {
+ try {
+ yield call(fetchAll);
+ } catch (e) {
+ // handle fetchAll errors
+ }
+}
+
Saga를 cancel하면, 아래 것들이 cancel된다
detached fork는 그 자체러 하나의 수행환경이다. 따라서, 부모는 detached fork의 종료를 기다리지 않고, 에러는 상위 부모로 올라가지 않는다.
또 cancle을 해도 detached fork는 영향을 받지 않는다.
Comments powered by Disqus.
모델링 기법중 하나로 그래픽으로 표현한 분석기법
객체 모델링 기법이라고도 한다.
3단계로 구성
객체 모델링
객체 다이어그램을 표시함.
정보 모델링이라고도 하며, 시스템에서 요구되는 객체를 찾아내어 속성과 연산 식별 및 객체들 간의 관계를 규정하여 클래스 다이어그램으로 표현한 것
상태 다이어그램을 통해 시간의 흐름에 따라 객체들을 모델링한다.
객체들관계 관계에는 제어흐름, 상호작용, 동적순서 등의 관계가 있다.
자료흐름도를 이용하여 프로세스 간 자료를 중심으로 한 모델링
어떤 데이터를 입력 -> 어떤 결과가 나올 것인가를 표현한다.
자료 흐름도
자료 사전(Data Dictionary)
https://velog.io/@kipsong/%EC%A0%95%EB%B3%B4%EC%B2%98%EB%A6%AC%EA%B8%B0%EC%82%AC-%EB%9F%BC%EB%B0%94%EC%9A%B0Rumbaugh-%EB%B6%84%EC%84%9D%EA%B8%B0%EB%B2%95
Comments powered by Disqus.
데이터베이스가 실제로 저장되는 방법을 정의한 것.
데이터베이스 전체의 논리적 구조를 정의한 것. 데이터베이스 하나에 하나만 존재.
개체, 관계, 제약조건, 보안정책 등을 정의한다.
사용자에게 필요한 데이터베이스를 정의한 것
Comments powered by Disqus.
응답으로 보낼 데이터의 HttpStatus를 명시해주는 방법이다. 컨트롤러에서 Body 데이터만 반환하는 경우 HttpStatus를 명시하기 위해 사용한다.
1
+2
+3
+4
+5
+6
+
@ResponseStatus(HttpStatus.OK)
+@GetMapping("/article")
+public ArticleListDto getArticles(SelectArticlesQuery query) {
+ ArticleListDto articleListDto = articleService.getArticleList(query);
+ return articleListDto;
+}
+
스프링에선 HTTP 요청 혹은 응답을 나타내기 위해 제공하는 HttpEntity라는 클래스가 존재하며, HttpEntity는 HttpHeader와 HttpBody를 포함하는 클래스이다.
이러한 HttpEntity를 상속하여 추가적으로 HttpStatus 속성을 더 가지는 클래스가 RequestEntity, ResponseEntity 클래스이다.
제네릭으로 선언되어있으며 해당 부분은 HttpBody 타입을 나타낸다.
1
+2
+3
+4
+5
+
@GetMapping("/article")
+public ResponseEntity<ArticleListDto> getArticles(SelectArticlesQuery query) {
+ ArticleListDto articleListDto = articleService.getArticleList(query);
+ return ResponseEntity.ok(response);
+}
+
@ResponseStatus는 단 하나의 응답 상태 코드를 지정하는 것 외에 다른 작업이 불가능하다는 것이 가장 큰 단점이다. 따라서 보통 @ResponseStatus는 에러 핸들링 컨트롤러에서 주로 사용하고, 실제 서비스를 담당하는 컨트롤러에서는 사용하기에 불편하다.
ResponseEntity의 경우 필요하다면, 컨트롤러 메서드 내부에서 오류 상태 코드를 지정하여 오류를 보낼 수 있다. 또한 Header에 대한 설정도 가능하다. 따라서 @ResponseStatus에 비해 유연성이 좋다.
https://joojimin.tistory.com/54
Comments powered by Disqus.
MethodArgumentNotValidException 예외가 발생하며 디스패처 서블릿에 기본으로 등록된 예외 리졸버인 DefaultHandlerExceptionResolver에 의해 400 에러가 발생한다.@Valid는 기본적으로 컨트롤러에서만 동작하며 다른 계층에서는 검증되지 않는다. 다른 계층에서 파라미터를 검증하기 위해선 @Validated와 결합하여야한다.스프링에서 제공하며, AOP기반으로 메소드의 요청을 가로채서 유효성 검증을 해준다.
유효성 검증에 실패하면 ConstraintViolationException 예외가 발생한다.
@Validated를 클래스로 등록하고, @Valid를 파라미터에 등록하면
클래스레벨이 아닌 메소드 파라미터에 단독으로 등록하는 것 또한 가능하다.
@Valid와 다르게 Group Validation까지 가능하도록 구현되었다.
Group Validation이란 객체 유효성 검증에서, 모든 필드를 검사하지 않고 특정 그룹의 필드만 검증하도록 설정하는 것을 얘기한다.
이때 그룹을 지정할 때는 그룹 인터페이스를 정의하고 필드에 그룹을 추가해야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
public class AccountLevelManagementCommand {
+ @NotBlank(
+ message = "Account ID cannot be empty.",
+ groups = {AccountLevelManagementRequestValidationGroup.class,
+ AccountLevelManagementSubmitValidationGroup.class})
+ private String id;
+
+ @NotNull(
+ message = "Level cannot be null.",
+ groups = {AccountLevelManagementSubmitValidationGroup.class})
+ private ManagerLevel levelName;
+
+ @NotNull(
+ message = "Operation cannot be null.",
+ groups = {AccountLevelManagementSubmitValidationGroup.class})
+ private AccountLevelManagementOperation operation;
+}
+
이 그룹 인터페이스는 비어있어도 좋다.
1
+2
+
public interface AccountLevelManagementRequestValidationGroup {
+}
+
상속도 가능하며 이때는 자식 그룹 인터페이스를 등록하면, 부모 그룹까지 모두 등록되게 된다.
1
+2
+3
+4
+
public interface SubmitValidation {
+}
+public interface AccountLevelSubmit1 extends SubmitValidation {
+}
+
BindingResult
@Valid, @Validated를 사용하는 메서드에 파라미터로 주어, 유효성 검사에 실패하면 그에 대한 에러 정보를 포함하고 있는 객체이다.
BindingResult가 없다면 400 오류를 발생하면서 컨트롤러가 호출되지 않지만, 있다면 에러정보를 담고 컨트롤러를 호출한다.
1
+2
+3
+4
+5
+6
+7
+
@PostMapping("/article/create")
+public String create(@Valid ArticleCreate article, BindingResult bindingResult) {
+ if(bindingResult.hasErrors()) {
+ return "errorpage";
+ }
+ // ... 작업
+}
+
Comments powered by Disqus.
AOP = Aspect Oriented Programming = 관점 지향 프로그래밍
관점 지향이란 어떤 로직을 기준으로 핵심적인 관점, 부가적인 관점으로 나누어서 보고 그 관점을 기준으로 모듈화 하겠다는 것이다. 여기서 모듈화란 어떤 공통된 로직이나 기능을 하나의 단위로 묶는 것을 말한다.
AOP에서 각 관점을 기준으로 모듈화한다는 것은 코드들을 부분적으로 나누어서 모듈화하겠다는 의미다. 개발을 하다보면 서로 다른 파일에서 같은 코드를 반복해서 쓰는 경우가 있는데 이것을 흩어진 관심사(crosscutting concerns)라고 한다. 이처럼 흩어진 관심사를 Aspect로 모듈화하고 핵심적인 비즈니스 로직에서 분리하여 재사용하겠다는 것이 AOP의 취지이다.
AOP의 주요 개념
다양한 AOP 적용 방법
스프링 AOP 특징
Comments powered by Disqus.
ResponseEntity를 사용해서 응답을 보내면 된다.
1
+2
+3
+4
+
public ResponseEntity<String> errorPage500Api() {
+ String result = "error";
+ return new ResponseEntity(result, HttpStatus.BAD_REQUEST.value());
+}
+
ResponseEntity를 사용해서 응답하기 때문세 메시지 컨버터가 동작하면서 클라이언트에 JSON이 반환된다.
BasicErrorController은 스프링부트에서 기본으로 오류를 처리해주는 컨트롤러이다. 따로 등록한 것이 없다면 스프링부트는 예외가 컨트롤러 밖으로 예외가 던져진 경우 /error를 호출한다. 그리고 /error는 BasicErrorController로 매핑되어 아래 메서드를 호출한다.
1
+2
+3
+4
+5
+
@RequestMapping(produces = MediaType.TEXT_HTML_VALUE)
+public ModelAndView errorHtml(HttpServletRequest request, HttpServletResponse response) {}
+
+@RequestMapping
+public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {}
+
produces=MediaType.TEXT_HTML_VALUE 으로 매핑되어, 클라이언트 요청의 Accept 헤더 값이 text/html인 경우 호출하여 에러 view를 제공한다.error 발생 시 스프링부트가 ResponeEntity body에 넣어주는 정보는 다음과 같다
application.properties에서 다음과 같이 응답에 정보를 담을지 말지 선택할 수 있다.
server.error.include-exceptionserver.error.include-messageserver.error.include-stacktraceserver.error.include-binding-errorsBasicErrorController은 HTML 에러 페이지지를 제공할 때는 매우 편리하다. 하지만 API 오류를 내보낼 때는 컨트롤러마다 다른 오류 처리 방법에 대응하기가 어렵다. 따라서 API 오류를 처리할 때는 @ExceptionHandler를 사용하는 것이 좋다.
스프링 MVC는 컨트롤러 밖으로 예외가 던져진 경우, 이 예외를 잡고 처리하는 HandlerExceptionResolver를 제공해준다.
이때 HandlerExceptionResolver는 예외를 해결해도 postHandle()은 호출되지 않는다.
HandlerExceptionResolver 인터페이스
1
+2
+3
+4
+
public interface HandlerExceptionResolver {
+ ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response,
+ Object handler, Exception ex);
+}
+
HandlerExceptionResolver 구현
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
@Slf4j
+public class MyHandlerExceptionResolver implements HandlerExceptionResolver {
+ @Override
+ public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
+ try {
+ if (ex instanceof IllegalArgumentException) {
+ response.sendError(HttpServletResponse.SC_BAD_REQUEST, ex.getMessage());
+ return new ModelAndView();
+ }
+ } catch (IOException e) {
+ log.error("resolver ex", e);
+ }
+ return null;
+ }
+}
+
resolveException 반환 값에 따른 동작방식
new ModelAndView()를 반환하는 경우. 뷰를 렌더링하지 않고, 정상 흐름으로 서블릿이 리턴된다. 즉, API 오류 처리를 할 때 사용한다.ExceptionResolver 활용
ExceptionResolver 등록
1
+2
+3
+4
+
@Override
+public void extendHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
+ resolvers.add(new MyHandlerExceptionResolver());
+}
+
스프링 부트가 기본으로 제공하는 ExceptionResolver와 우선순위는 다음과 같다.(HandlerExceptionResolverComposite에 다음과 같이 등록)
@ExceptionHandler 애노테이션을 사용한 예외처리 방법.
컨트롤러 안에서 @ExceptionHandler 와 처리하고 싶은 예외를 선언해주면 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
@RestController
+public class ApiExceptionV2Controller
+ @ResponseStatus(HttpStatus.BAD_REQUEST)
+ @ExceptionHandler(IllegalArgumentException.class)
+ public ErrorResult illegalExHandle(IllegalArgumentException e) {
+ return new ErrorResult("BAD", e.getMessage()); // @ResponseBody 적용됨
+ }
+
+ @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
+ @ExceptionHandler
+ public ResponseEntity<ErrorResult> exHandle(Exception e) {
+ ErrorResult errorResult = new ErrorResult("EX", "내부 오류");
+ return new ResponseEntity<>(errorResult, HttpStatus.BAD_REQUEST);
+ }
+ ...
+}
+
+
예외가 발생하면 컨트롤러 안의 @ExceptionHandler 애노테이션이 붙은 메서드를 확인하고 예외를 처리한다. 지정한 예외와 그 예외의 자식 클래스는 모두 잡을 수 있다.
부모의 자식 예외가 모두 등록되어있을 때는, 자식 예외 처리가 먼저 호출된다.
다음과 같이 다양한 예외를 한번에 등록할 수도 있다.
1
+
@ExceptionHandler({AException.class, BException.class})
+
다음과 같이 생략할 경우에는 메서드 파라미터의 예외로 지정된다.
1
+2
+
@ExceptionHandler
+public ResponseEntity<ErrorResult> userExHandle(UserException e) {}
+
예외에 따라서 HTTP 상태 코드를 지정해주는 역할을 한다. 다음 두 가지 경우를 처리한다.
@ResponseStatus가 달려있는 예외
다음과 같이 예외에 @ResponseStatus 애노테이션을 적용하면 HTTP 상태코드를 변경해준다.
1
+2
+3
+
@ResponseStatus(code = HttpStatus.NOT_FOUND, reason = "찾을 수 없음")
+public class NotFoundException extends RuntimeException {
+}
+
NotFoundException 커스텀 예외가 컨트롤러 밖으로 넘어가면 ResponseStatusExceptionResolver가 해당 애노테이션을 확인해서 오류 코드를 404로 변경하고 메시지를 담는다.
reason에는 MessageSource를 찾는 기능도 제공한다.
1
+
@ResponseStatus(code = HttpStatus.NOT_FOUND, reason = "error.notfound")
+
1
+2
+
# messages.properties
+error.notfound=찾을 수 없습니다.
+
ResponseStatusException
@ResponseStatus는 개발자가 직접 변경할 수 없는 예외에는 적용할 수 없다. 이때는 ResponseStatusException를 사용하면 된다.`
1
+2
+3
+4
+
@GetMapping("/api/response-status-ex2")
+public String responseStatusEx2() {
+ throw new ResponseStatusException(HttpStatus.NOT_FOUND, "error.notfound", new Exception());
+}
+
스프링 내부에서 발생하는 스프링 예외를 해결한다.
@ExceptionHandler를 컨트롤러 안에서 사용하여 예외를 잡을 수 있지만, 컨트롤러 내의 정상 코드와 예외 처리 코드가 섞여있다. 이를 분리하기 위해선 @ControllerAdvice 또는 @RestControllerAdvice를 사용하면 둘을 분리할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
@RestControllerAdvice
+public class ExControllerAdvice {
+ @ResponseStatus(HttpStatus.BAD_REQUEST)
+ @ExceptionHandler(IllegalArgumentException.class)
+ public ErrorResult illegalExHandle(IllegalArgumentException e) {
+ return new ErrorResult("BAD", e.getMessage());
+ }
+ ...
+}
+
+
@ControllerAdvice는 대상으로 지정한 여러 컨트롤러에 @ExceptionHandler, @InitBinder 기능을 부여해주는 역할을 한다. 대상을 지정하지 않으면 모든 컨트롤러에 적용한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
@ControllerAdvice(annotations = RestController.class)
+public class ExampleAdvice1 {}
+
+
+// Target all Controllers within specific packages
+@ControllerAdvice("org.example.controllers")
+public class ExampleAdvice2 {}
+
+// Target all Controllers assignable to specific classes
+@ControllerAdvice(assignableTypes = {ControllerInterface.class, AbstractController.class})
+public class ExampleAdvice3 {}
+
@RestControllerAdvice는 @ControllerAdvice와 같은 역할을 하며, 내부의 메서드에 @ResponseBody 애노테이션을 추가시켜준다.
@ControllerAdvice에서 Interceptor에서 날아온 에러도 잡는 것을 보고 원리가 신경 쓰여 DispatcherServlet의 doDispatch() 메서드 코드를 살펴봤다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
+ ...
+ try {
+ ...
+ try {
+ ...
+ // Determine handler for the current request.
+ mappedHandler = getHandler(processedRequest);
+
+ // Determine handler adapter for the current request.
+ HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
+
+ ...
+
+ if (!mappedHandler.applyPreHandle(processedRequest, response)) {
+ return;
+ }
+
+ // Actually invoke the handler.
+ mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
+
+ ...
+
+ mappedHandler.applyPostHandle(processedRequest, response, mv);
+ }
+ catch (Exception ex) {
+ dispatchException = ex;
+ }
+ catch (Throwable err) {
+ dispatchException = new NestedServletException("Handler dispatch failed", err);
+ }
+ processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
+ }
+ ...
+}
+
dispatchException에 예외를 저장하고, processDispatchResult로 넘겨준다.processDispatchResult에서는 예외가 있고, ModelAndViewDefiningException이 아닌 경우 processHandlerException를 호출한다.ModelAndViewDefiningException은 예외 페이지를 보여주도록하는 예외processHandlerException에서는 DispatcherServlet에 등록된 HandlerExceptionResolver 을 하나씩 수행한다.HandlerExceptionResolver은 위에도 나와있지만 디폴트로 다음 세가지가 등록된다.ExceptionHandlerExceptionResolver가 ExceptionHandler를 실행한다.@ControllerAdvice로 ExceptionHandler를 등록하면, 디폴트로 모든 컨트롤러에 등록된다. 따라서 interceptor에서 날린 예외도 받을 수 있는 것이다.DispathcerServlet의 코드를 보면 컨트롤러 안에서 선언한 @ExceptionHandler 메서드도 인터셉터에서 날린 예외를 받을 수 있는 걸로 보인다.preHandle에서 날린 예외를 컨트롤러에서 선언한 @ExceptionHandler에서 처리하였다.afterCompletion 은 processDispatchResult에서 실행되는데 따라서 afterCompletion에서 예외를 날려도 @ControllerAdvise와 @ExceptionHandler는 받지 못한다.afterCompletion에서 발생한 예외는 스프링 내에서 처리하는 것이다.processHandlerException에서 예외 처리 이후에도 afterCompletion은 실행된다.HTML 에러 화면을 보여줘야하는 경우
API 에러 응답을 보내야하는 경우
Comments powered by Disqus.
ArgumentResolver는 스프링 MVC 구조의 어댑터 핸들러에서 핸들러에 필요한 파라미터를 만들어주는데 호출하는 부분이다. 이 ArgumentResolver를 직접 구현하여 활용하면 다양한 상황에서 편리하게 적용할 수 있다.
컨트롤러
1
+2
+
@GetMapping("/")
+public String homeLoginV3ArgumentResolver(@Login Member loginMember, Model model)
+
Login 어노테이션
1
+2
+3
+4
+
@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Login {
+}
+
LoginMemberArgumentResolver
HandlerMethodArgumentResolver를 구현하여 만든다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
public class LoginMemberArgumentResolver implements HandlerMethodArgumentResolver {
+ @Override
+ public boolean supportsParameter(MethodParameter parameter) {
+ boolean hasLoginAnnotation = parameter.hasParameterAnnotation(Login.class);
+ boolean hasMemberType = Member.class.isAssignableFrom(parameter.getParameterType());
+ return hasLoginAnnotation && hasMemberType;
+ }
+
+ @Override
+ public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
+ NativeWebRequest webRequest,
+ WebDataBinderFactory binderFactory) throws Exception {
+ HttpServletRequest request = (HttpServletRequest)webRequest.getNativeRequest();
+ HttpSession session = request.getSession(false);
+ if (session == null) {
+ return null;
+ }
+ return session.getAttribute(SessionConst.LOGIN_MEMBER);
+ }
+}
+
@Login 애노테이션이 있으면서 Member 타입이면 해당 ArgumentResolver가 사용되도록 적용WebMvcConfigurer에 설정 추가
1
+2
+3
+4
+5
+6
+7
+
@Configuration
+public class WebConfig implements WebMvcConfigurer {
+ @Override
+ public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
+ resolvers.add(new LoginMemberArgumentResolver());
+ }
+}
+
Comments powered by Disqus.
이 포스트는 참고문서를 필자가 이해하기 쉽게 정리한 내용입니다.
다음 PizzaStore 클래스는 정해진 개수의 Pizza인스턴스를 가지고 있다. 만약 Pizza가 더 필요하면 PizzaStore를 직접 수정해야하다. 이는 OCP를 위반하며 DI로 해결해줄 수 있다
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
public class PizzaStore
+{
+ private readonly Pizza[] pizzas =
+ new Pizza[]
+ {
+ new Pizza(),
+ new Pizza(),
+ new Pizza()
+ };
+
+ public void Sell(int count)
+ {
+
다음과 같이 인수를 취하는 형태의 DI로 해결 가능하다
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
public class PizzaStore
+{
+ private readonly Pizza[] pizzas;
+
+ public PizzaStore(Pizza[] pizzas)
+ {
+ this.pizzas = pizzas;
+ }
+
+ public void Sell(int count)
+ {
+
이처럼 DI는 추상화를 해치지 않고 의존성을 인수로 넘겨주는 방법을 뜻한다.
Rúnar Bjarnason : Dependency Injection is really just a pretentious way to say ‘taking an argument’.
고차원 모듈은 저차원 모듈에 의존해서는 안된다. 이 둘은 추상화된 것에 의존해야한다.
추상화된 것은 구체적인 것에 의존하면 안된다.
위 PizzaStore 클래스는 현재 Pizza 구현체에 의존하고 있다. 이 형태는 DIP를 위반하고 있는 것으로, 다음과 같이 변경되어야한다.
DI는 DIP를 사용한다고 생각하지만 이 둘은 별개다. DI를 사용하면서 DIP가 필요없는 경우도 많다. 아래 CachedUserStore 클래스에서는 일정기간(duration) 동안 캐쉬하는 기능을 제공한다. 이때 duration은 DI를 통해 주입되지만 DIP가 필요한 것은 아니다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
public interface IUserStore
+{
+ User Find(string userId);
+}
+
+public class CachedUserStore : IUserStore
+{
+ ...
+
+ public CachedUserStore(IUserStore innerStore, int duration)
+ {
+ ...
+ }
+
+ public User Find(string userId)
+ {
+
IoC는 라이브러리와 프레임워크의 차이에서 알아볼 수 있다.
라이브러리 : 개발자가 원하는 때에 가져와서 사용할 수 있음. 개발자에게 제어권이 있다
프레임워크 : 개발자가 프레임워크에 맞추어 구성요소를 등록하면 프레임워크가 프로그램을 동작시킴. 제어권이 프레임워크에 있다.
다음과 같이 IoC 컨테이너가 의존성을 주입해준다면 이는 제어권이 IoC 컨테이너에 있는 것으로 IoC가 발생한 사레이다
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
public static void Main()
+{
+ Type[] pizzaTypes = Assembly.GetEntryAssembly()
+ .GetExportedTypes()
+ .Where(typeof(IPizza).IsAssignableFrom);
+
+ var builder = new IoCContainerBuilder();
+ buildr.RegisterTypes(pizzaTypes);
+
+ IoCContainer container = builder.Build();
+
+ IPizza[] allKindsOfPizzas = container.Resolve<IPizza[]>();
+
+ var pizzaStore = new PizzaStore(allKindsOfPizzas);
+
+ ...
+}
+
Mark Seemann은 IoC 컨테이너를 사용하지 않는 DI에 대해 Pure DI라고 했다
DI를 사용한다고 무조건 IoC 컨테이너가 필요한 것은 아니다. 보통은 의존성 등록비용(개발자가 직접 의존성을 주입하는 것) 때문에 IoC 컨테이너로 의존성 주입하지만, IoC 컨테이너를 사용하는 방법에는 Weakly typed 문제가 있다.
Weakly typed 란, IoC 컨테이너에 의존성을 잘못 구성되었을 경우 컴파일 에러대신 런타임 에러가 발생하는 것이다.
따라서 Weakly typed 비용과 의존성 등록 비용 중 어떤 것이 더 큰지 생각하여 IoC 컨테이너로 DI를 구현할지 Pure DI를 사용할지 결정해야한다. (참고문서의 필자는 weakly typed 비용이 더 크다고 함)
중요한 것은 뭘 사용해야할지보다 IoC 컨테이너 없이 Pure DI를 사용할 수 있고, Pure DI에도 장점이 있다는 것이다.
DI는 어떠한 고차원 모듈이 저차원 모듈에 의존해서는 안된다는 DIP와 변경에는 닫혀있고 확장에는 열려있어야하는 OCP를 지키기 위해, 외부에서 의존하는 모듈을 주입해주는 것이다. 보통 DI는 IoC 컨테이너로 주입해주지만, weakly typed 문제가 발생할 수 있다. 따라서 직접 의존성 등록할 때 발생하는 비용과 weakly typed 비용을 잘 비교하여 사용하면 좋다.
Comments powered by Disqus.
스프링에서 컨트롤러를 개발하다보면, url 파라미터를 long 으로 받아도 문제없이 작동된다.
1
+2
+
@GetMapping(path = "/article/{articleId}")
+public String getArticleDetail(@PathVariable long articleId) {
+
위와 같은 컨트롤러가 있을 때, 유저는 /article/123라는 요청을 보내면 자동으로 getArticleDetail의 매개변수인 articleId에 123 값이 문제없이 할당된다.
URL 파라미터는 기본적으로 문자열로 인식다. 하지만 long에 할당이 일어나는 것은 무언가가 중간에서 문자열 123을 long 타입 123으로 변환시켜주는 것이다. 그 무언가가 스프링 MVC에서는 HTTP 메시지 컨버터이다.
스프링 MVC는 다음의 경우에 HTTP 메시지 컨버터를 적용한다
HTTP 요청 : @RequestBody, HttpEntity(RequestEntity)
HTTP 응답 : @ResponseBody, HttpEntity(ResponseEntity)
HttpMessageConverter는 HTTP 메시지 컨버터의 인터페이스로 다음과 같은 메서드를 포함한다
스프링 부트는 다양한 메시지 컨버터를 제공하는데 다음과 같은 메시지 컨버터가 주요하며 적용 우선순위는 나열 순서와 같다
메시지 컨버터가 동작하는 순서는 다음과 같다.
HTTP 요청
canRead()를 호출하여 메시지를 읽을 수 있는지 확인한다.read()를 호출해서 객체를 생성하고 반환한다.HTTP 응답
canWrite()를 호출한다.write()를 호출해서 HTTP 응답 메시지 바디에 데이터를 생성한다.Http 메시지 컨버터는 언제 사용될까? 이것을 알아보기저에 먼저 Argument Resolver와 ReturnValueHandler를 알아보자.
애노테이션 기반의 컨트롤러(@RequestMapping을 사용하는 컨트롤러)를 처리하는 핸들러 어댑터는 RequestMappingHandlerAdapter이다. 이 RequestMappingHandlerAdapter는 핸들러 사이에 Argument Resolver와 ReturnValueHandler를 다음 그림과 같이 둔다.
ArgumentResolver
애노테이션 기반의 컨트롤러는 매우 다양한 파라미터를 사용할 수 있다. HttpServletRequest, Model, @RequestPaaram, @ModelAttribute 등과 같은 애노테이션과 @RequestBody, HttpEntity와 같은 HTTP 메시지도 처리해준다. 이렇게 유연하게 처리해주는 것이 바로 ArgumentResolver이다.
애노테이션 기반 컨트롤러를 처리하는 RequestMappingHandlerAdapter는 이 ArgumentResolver를 호출하여 컨트롤러가 필요로하는 다양한 파라미터의 값을 생성한다.
스프링은 30개가 넘는 ArgumentResolver를 제공한다. 이 ArgumentResolver를 통해 각 파라미터를 처리하는 것이다.
ReturnValueHandler
ArgumentResolver와 마찬가지로 컨트롤러에서 반환되는 다양한 값을 변환하여 ModelAndView 객체로 만들어 RequestMappingHandlerAdapter에게 전달하는 역할을 맡는다.
위와 같은 구조에서 Http 메시지 컨버터는 Argumen Resolver와 ReturnValueHandler가 호출될때 사용된다.
요청
응답
Comments powered by Disqus.
스프링 인터셉터는 스프링 MVC가 제공하는 기술로, 서블릿 필터하고는 적용순서, 범위, 사용방법이 다르다.
스프링 인터셉터 흐름
HTTP 요청 -> WAS -> 필터 -> 서블릿 -> 스프링 인터셉터 -> 컨트롤러
스프링 인터셉터는 디스패처 서블릿과 컨트롤러 사이에서 컨트롤러 호출 직전에 호출됨.
스프링 인터셉터는 스프링 MVC가 제공하는 기능으로, 디스패처 서블릿 이후에 등장하게 된다. 스프링 MVC의 시작점이 디스패처 서블릿이라고 생각하면 됨.
스프링 인터셉터도 URL 패턴을 적용할 수 있다. 서블릿 URL 패턴과는 다르고 매우 정밀하게 설정가능
스프링 인터셉터에서 적절하지 않은 요청이라고 판단하면 거기서 요청을 차단할 수 있다. 컨트롤러까지 가지 않도록 한다.
다음과 같이 체인을 구성할 수도 있다.
서블릿 -> 인터셉터1 -> 인터셉터2 -> 컨트롤러
인터셉터는 싱글톤처럼 사용된다. 따라서 멤버변수를 사용하여 메소드간 값을 공유하면 위험하다.
스프링 인터셉터 인터페이스
스프링 인터셉터를 사용하려면 HandlerInterceptor 인터페이스를 구현하면 된다. 해당 인터페이스에는 다음과 같이 세가지 메서드가 있다
스프링 인터셉터의 메서드에서는 request, response, handler 정보를 받을 수 있다. handler는 호출되는 컨트롤러를 뜻한다.
인터셉터 등록
인터셉터는 WebMvcConfigurer에 다음과 같이 등록해줘야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
@Configuration
+public class WebConfig implements WebMvcConfigurer {
+ @Override
+ public void addInterceptors(InterceptorRegistry registry) {
+ registry.addInterceptor(new LogInterceptor())
+ .order(1)
+ .addPathPatterns("/**")
+ .excludePathPatterns("/css/**", "/*.ico", "/error");
+ }
+}
+
PathPatterns
스프링이 제공하는 URL 경로 기술로, 매우 자세하게 설정할 수 있다.
다음과 같이 전달할 값을 필드로 지닌 클래스를 만들고, request 스코프로 빈에 등록하는 것이 가장 좋다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
@Component
+@Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
+public class CurrentUser {
+ private User currentUser;
+
+ public User getCurrentUser() {
+ return currentUser;
+ }
+
+ public void setCurrentUser(User currentUser) {
+ this.currentUser = currentUser;
+ }
+}
+
필드가 딱 하나만 있거나, 컨트롤러에서도 HttpServletRequest를 사용한다면 다음과 같이 HttpServletRequest에 값을 추가하는 것도 방법이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
@Component
+public class MyInterceptor implements HandlerInterceptor {
+ @Override
+ public boolean preHandle(
+ HttpServletRequest request,
+ HttpServletResponse response, Object handler) throws Exception {
+ request.setAttribute("email", "login@domain.com");
+ return true;
+ }
+}
+
interceptor에서 날아간 예외는 어떻게 처리하는 것이 좋을까?
이에 관해선 API 예외처리 문서의 @ExceptionHandler, @ControllerAdvice 원리 섹션에서 자세히 정리해놓았지만, 간단히 요약하자면 아래와 같다.
@ExceptionHandler로 선언한 핸들러와 @ControllerAdvice로 등록한 핸들러 모두 적용됨Comments powered by Disqus.
@ResquestBody로 받는 매개변수의 클래스에 @NoArgsConstructor를 빼니 InvalidDefinitionException 에러가 발생했다.
1
+2
+
@PostMapping("/login")
+public String login(@Valid @RequestBody LoginRequestBody loginRequestBody)
+
1
+2
+3
+4
+
@Getter
+@AllArgsConstructor
+@ToString
+public class LoginRequestBody {
+
com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of
com.ntscorp.springserver.user.dto.controller.request.LoginRequestBody(no Creators, like default constructor, exist): cannot deserialize from Object value (no delegate- or property-based Creator)
반면에 @NoArgsConstructor를 추가하니 제대로 controller가 실행되었다.
그 이유는 해당 포스트에서 자세히 설명되어있다
application/json을 읽기위해 사용되는 컨버터는 Jackson2HttpMessageConverter다.Jackson2HttpMessageConverter의 read() 에서는 ObjectMapper가 사용된다.ObjectMapper의 변환과정은 다음과 같다위 과정 중 4-1번에서 기본 생성자를 사용하는 과정이 있으므로 기본생성자가 없을 경우 예외가 발생한 것이었다.
물론 이 포스트에서 설명한 것과 같이 기본 생성자없이도 동작가능하도록 할 수 있으나, 웬만하면 기본 설정을 사용하는 것이 나아보인다.
Comments powered by Disqus.
스프링에서는 Http 메시지 컨버터를 통해 사용자가 보낸 데이터와 서버에서 내보내는 데이터를 자동으로 변환해준다. 만약 다음과 같은 객체를 응답으로 보낼 경우 Content-Type이 application/json이라면, 스프링은 다음 객체를 자동으로 Json 형식으로 바꾸어 내보낸다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
@AllArgsConstructor
+@Getter
+public class UserDto {
+ private String userId;
+ private String password;
+}
+
+//
+
+UserDto user = new UserDto("userId", "password");
+
1
+2
+3
+4
+
{
+ "userId":"userid",
+ "password":"password"
+}
+
그런데 만약 예시에서 password는 민감한 데이터이므로 응답으로 보내고 싶지 않다면 어떻게 하면 될까? 응답을 보낼 때 password 필드의 값을 null로 비워서 보낼 수도 있겠지만, 개발자가 실수로 비우지 않을 수도 있고 코드도 깔끔하지 않을 것이다.
@JsonIgnore은 Jackson 패키지의 애노테이션으로, Json의 직력화 및 역직렬화에서 속성을 무시하는데 사용한다.
위와 같은 상황에서 사용하는 것이 @JsonIgnore으로, 클래스 필드에 해당 애노테이션을 추가해주면 HTTP 메시지 컨버터에서 Json으로 직렬화할 때, @JsonIgnore가 붙은 필드는 빼고 변환한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
@AllArgsConstructor
+@Getter
+public class UserDto {
+ private String userId;
+ @JsonIgnore
+ private String password;
+}
+
+//
+
+UserDto user = new UserDto("userId", "password");
+
1
+2
+3
+
{
+ "userId":"userid"
+}
+
Comments powered by Disqus.
다음과 같이 interceptor를 등록할 때, addPathPatterns()에 /api/**를 등록하였지만, /api/article을 요청했을 때 인터셉터가 제대로 동작하지 않았다. 하지만 /**로 등록하니 제대로 동작하였다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
public void addInterceptors(InterceptorRegistry registry) {
+ registry.addInterceptor(authInterceptor)
+ .order(1)
+ .addPathPatterns("/api/**"); // not work
+}
+
+public void addInterceptors(InterceptorRegistry registry) {
+ registry.addInterceptor(authInterceptor)
+ .order(1)
+ .addPathPatterns("/**"); // work
+}
+
내 앱에서 application.properties에 server.servlet.contextPath=/api 로 모든 servlet의 prefix 주소를 /api로 설정한 것을 떠올렸다.
1
+
server.servlet.contextPath=/api
+
이 단서를 중심으로 찾아보니 pathPattern에 등록할 땐 전체 요청 주소에서 contextPath를 땐 servletPath를 사용해야한다는 것을 알게되었다.
만약 /api/article로 요청한다면 contextPath로 /api를 설정하였으므로 servletPath는 /article이 되어 addPathPatterns()에 등록한 /api/**이 작동하지 않았던 것이다.
그렇다면 왜 스프링에서는 contextPath를 떼서 검사하는 것일까? 그것은 context path와 servlet path의 정의와 역할이 다르기 때문이다.
스프링 인터셉터를 등록하기위해 구현한 인터페이스는 WebMvcConfigurer이다. WebMvcConfigurer은 다음과 같이 DispatherServlet 이후에 스프링 MVC 설정을 위해 쓰인다.
인터셉터가 적용되거나(addPathPatterns로 등록된 주소), 적용되지 않는 주소(excludePathPatterns로 등록된 주소)를 검사하는 곳은 스프링 MVC이므로, 스프링에서 처리되는 주소인 Servlet Path가 검사 대상이 된다.
생각해보면 어플리케이션의 루트주소 이후부터 검사하는 것이 타당하긴 하다..
https://www.baeldung.com/spring-context-vs-servlet-path
https://lalwr.blogspot.com/2018/04/spring-annotation.html
Comments powered by Disqus.
스프링에서 지원하는 객체로, 간편하게 Rest 방식 API를 호출할 수 있는 스프링 내장 클래스다.
스프링 3.0부터 지원하였고, json, xml 응답을 모두 받을 수 있다.
클래스
메서드
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+
@Component
+public class sendData {
+ private static RestTemplate restTemplate;
+
+ public static ResponseEntity<SubmitData> sendEngine() {
+ int SubNum = 123;
+ int Pnum = 1;
+ Object Pcode = "코드";
+ SubmitData requestDto = SubmitData.builder()
+ .SubNum(SubNum)
+ .Pnum(Pnum)
+ .Pcode(Pcode)
+ .build();
+
+ HttpHeaders headers = new HttpHeaders();
+ headers.add("Content-Type", "application/json");
+ HttpEntity<SubmitData> entity = new HttpEntity<>(requestDto, headers);
+
+ String url = "http://localhost:8080/send";
+
+ return restTemplate.exchange(url, HttpMethod.POST, entity, SubmitData.class);
+ }
+}
+
https://blog.naver.com/hj_kim97/222295259904
https://velog.io/@soosungp33/%EC%8A%A4%ED%94%84%EB%A7%81-RestTemplate-%EC%A0%95%EB%A6%AC%EC%9A%94%EC%B2%AD-%ED%95%A8
Comments powered by Disqus.
이 문서는 개인적인 목적이나 배포하기 위해서 복사할 수 있다. 출력물이든 디지털 문서든 각 복사본에 어떤 비용도 청구할 수 없고 모든 복사본에는 이 카피라이트 문구가 있어야 한다. (출처)
객체를 조회하고 조작하는 기능을 제공하며, 메서드 호출, 물자열 템플릿 기능 등의 여러가지 추가기능을 제공하는 표현식 언어이다. OGNL 등 자바에서 사용가능한 여러 EL이 있지만, SpEL은 Spring 프로젝트 전반에 걸쳐 사용하기 위해 만들어졌으며 스프링 3.0부터 지원한다.
1
+
#{SpEL 표현식}
+
#{} 안의 표현식을 evaluation 한다.${} 은 SpEL이 아니라 프로퍼티를 참조할 때 사용하는 표기이다. SpEL은 기본적으로 #{}으로 표기한다1
+2
+3
+4
+5
+6
+7
+
ExpressionParser parser = new SpelExpressionParser();
+Expression expression = parser.parseExpression("1+1");
+Object value1 = expression.getValue();
+System.out.println(value1); // 2
+
+int value2 = expression.getValue(Integer.class);
+System.out.println(value2); // 2
+
단순 표현식 파싱이 아닌 객체 정보들의 context가 필요한 경우 EvaluationContext를 사용할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
// name, nationality를 파라미터로 갖는 생성자
+Inventor tesla = new Inventor("Nikola Tesla","Serbian");
+
+ExpressionParser parser = new SpelExpressionParser();
+Expression exp = parser.parseExpression("name"); // name 프로퍼티
+
+// Context에 tesla객체를 넣어준다.
+EvaluationContext context = new StandardEvaluationContext(tesla);
+String name1 = (String) exp.getValue(context); //name = "Nikola Tesla"
+System.out.println(name1); // Nikola Tesla
+
+// getValue 메서드 호출 시 StandardEvaluationContext를 사용하지 않고 객체를 직접 지정
+String name2 = (String) exp.getValue(tesla);
+System.out.println(name2); // Nikola Tesla
+
1
+2
+3
+
String helloWorld = (String) parser.parseExpression("'Hello World'").getValue();
+double avogadrosNumber = (Double) parser.parseExpression("6.0221415E+23").getValue();
+int maxValue = (Integer) parser.parseExpression("0x7FFFFFFF").getValue();
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
int year = (Integer) parser.parseExpression("Birthdate.Year + 1900").getValue(context);
+
+String name = parser.parseExpression("Members[0].Name")
+ .getValue(societyContext, String.class);
+
+// Officer의 딕션어리(맵 접근)
+Inventor pupin = parser.parseExpression("Officers['president']")
+ .getValue(societyContext, Inventor.class);
+
+// 값을 설정한다
+parser.parseExpression("Officers['advisors'][0].PlaceOfBirth.Country")
+ .setValue(societyContext, "Croatia");
+
+// 안전한 탐색 연산자
+city = parser.parseExpression("PlaceOfBirth?.City").getValue(context, String.class);
+
optional chaining 처럼 null이 아닌지 확인하며 프로퍼티에 접근하는 문법도 사용가능하다.1
+2
+3
+
String c = parser.parseExpression("'abc'.substring(2, 3)").getValue(String.class);
+boolean isMember = parser.parseExpression("isMember('Mihajlo Pupin')")
+ .getValue(societyContext, Boolean.class);
+
1
+2
+3
+4
+5
+6
+7
+
boolean trueValue = parser.parseExpression("2 == 2").getValue(Boolean.class);
+boolean falseValue = parser.parseExpression("2 < -5.0").getValue(Boolean.class);
+boolean falseValue = parser.parseExpression("'xyz' instanceof T(int)")
+ .getValue(Boolean.class);
+// 정규표현식과 비교하기 위해서 mathes 키워드를 사용한다.
+boolean trueValue = parser.parseExpression("'5.00' matches '^-?\\d+(\\.\\d{2})?$'")
+ .getValue(Boolean.class);
+
1
+2
+3
+
boolean falseValue = parser.parseExpression("true and false").getValue(Boolean.class);
+boolean trueValue = parser.parseExpression("true or false").getValue(Boolean.class);
+boolean falseValue = parser.parseExpression("!true").getValue(Boolean.class);
+
1
+2
+3
+4
+5
+6
+
int two = parser.parseExpression("1 + 1").getValue(Integer.class); // 2
+int four = parser.parseExpression("1 - -3").getValue(Integer.class); // 4
+int six = parser.parseExpression("-2 * -3").getValue(Integer.class); // 6
+int minusTwo = parser.parseExpression("6 / -3").getValue(Integer.class); // -2
+int three = parser.parseExpression("7 % 4").getValue(Integer.class); // 3
+int minusTwentyOne = parser.parseExpression("1+2-3*8").getValue(Integer.class); // -21
+
1
+2
+3
+4
+5
+6
+7
+8
+
Inventor inventor = new Inventor();
+StandardEvaluationContext inventorContext = new StandardEvaluationContext(inventor);
+
+parser.parseExpression("Name").setValue(inventorContext, "Alexander Seovic2");
+
+// 대신에 getValue()로도 할당이 가능하다.
+String aleks = parser.parseExpression("Name = 'Alexandar Seovic'")
+ .getValue(inventorContext, String.class);
+
1
+2
+3
+4
+5
+6
+7
+8
+
Inventor einstein = p.parseExpression(
+ "new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
+ .getValue(Inventor.class);
+
+//리스트의 add 메서드내에서 새로운 inventor 인스턴스를 생성한다
+p.parseExpression(
+ "Members.add(new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German'))")
+ .getValue(societyContext);
+
1
+2
+3
+4
+5
+6
+7
+8
+
Class dateClass = parser.parseExpression("T(java.util.Date)").getValue(Class.class);
+
+Class stringClass = parser.parseExpression("T(String)").getValue(Class.class);
+
+boolean
+ trueValue = parser.parseExpression(
+ "T(java.math.RoundingMode).CEILING < T(java.math.RoundingMode).FLOOR")
+ .getValue(Boolean.class);
+
T 연산자를 클래스 인스턴스를 지정하는데 사용할 수 있다. 정적 메서드도 이 연산자를 사용해서 호출할 수 있다.1
+2
+3
+4
+5
+6
+
ExpressionParser parser = new SpelExpressionParser();
+StandardEvaluationContext context = new StandardEvaluationContext();
+context.setBeanResolver(new MyBeanResolver());
+
+// 평가하는 동안 MyBeanResolver에서 resolve(context,"foo")를 호출할 것이다
+Object bean = parser.parseExpression("@foo").getValue(context);
+
1
+2
+3
+
int[] numbers1 = (int[]) parser.parseExpression("new int[4]").getValue(context);
+int[] numbers2 = (int[]) parser.parseExpression("new int[]{1,2,3}").getValue(context);
+int[][] numbers3 = (int[][]) parser.parseExpression("new int[4][5]").getValue(context);
+
1
+2
+
// 4개의 숫자를 담고 있는 자바 리스트로 평가된다
+List numbers = (List) parser.parseExpression("{1,2,3,4}").getValue(context);
+
1
+2
+3
+4
+5
+
String falseString = parser.parseExpression("false ? 'trueExp' : 'falseExp'")
+ .getValue(String.class);
+
+// 엘비스 문법 a ? a : b --> a ?: b
+String name = parser.parseExpression("null?:'Unknown'").getValue(String.class);
+
1
+2
+3
+4
+5
+6
+7
+
Inventor tesla = new Inventor("Nikola Tesla", "Serbian");
+StandardEvaluationContext context = new StandardEvaluationContext(tesla);
+context.setVariable("newName", "Mike Tesla");
+
+parser.parseExpression("Name = #newName").getValue(context);
+
+System.out.println(tesla.getName()) // "Mike Tesla"
+
#this와 #root 변수는 항상 정의되어있다. 각각 현재 평가객체, 루트 컨텍스트 객체를 참조한다.1
+2
+3
+4
+5
+6
+7
+8
+
ExpressionParser parser = new SpelExpressionParser();
+StandardEvaluationContext context = new StandardEvaluationContext();
+
+context.registerFunction("reverseString",
+ StringUtils.class.getDeclaredMethod("reverseString",
+ new Class[] { String.class }));
+String helloWorldReversed =
+ parser.parseExpression("#reverseString('hello')").getValue(context, String.class);
+
1
+
List placesOfBirth = (List)parser.parseExpression("Members.![placeOfBirth.city]");
+
1
+2
+3
+4
+5
+
List<Inventor> list = (List<Inventor>)parser.parseExpression(
+ "Members.?[Nationality == 'Serbian']")
+ .getValue(societyContext);
+
+Map newMap = parser.parseExpression("map.?[value<27]").getValue();
+
1
+2
+3
+
String randomPhrase =
+ parser.parseExpression("random number is #{T(java.lang.Math).random()}",
+ new TemplateParserContext()).getValue(String.class);
+
#{}로 구분하여 하나 이상의 평가 블럭을 가진 리터럴 문자를 섞을 수 있다.1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+
@Value("#{1+1}")
+int value;
+
+@Value("#{'hello ' + 'world'}")
+String greeting;
+
+@Value("#{1 eq 5}")
+boolean trueOrFalse;
+
+@Value("Literal String")
+String literalString;
+
+@Override
+public void run(ApplicationArguments args) throws Exception {
+ System.out.println(value); // 2
+ System.out.println(greeting); // hello world
+ System.out.println(trueOrFalse); // false
+ System.out.println(literalString); // Literal String
+}
+
1
+
my.value=100
+
1
+2
+3
+4
+5
+6
+7
+
@Value("#{'${my.value}' eq '100'}")
+boolean isEqual;
+
+@Override
+public void run(ApplicationArguments args) throws Exception {
+ System.out.println(isEqual); // true
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+
@Component
+public class Sample {
+ private int value = 123;
+
+ public int getValue() {
+ return value;
+ }
+}
+
1
+2
+
@Value("#{sample.Value}")
+int sampleValue;
+
SpEL도 해당하는 타입으로 변환할 때 ConversionService를 사용한다
Comments powered by Disqus.
HTTP 메세지 컨버터에서 발생한 데이터 바인딩 오류를 담아 컨트롤러에서 이용할 수 있는 객체. 다음과 같이 바인딩 오류가 발생할 수 있는 파라미터 바로 다음에 파라미터로서 추가한다.
1
+2
+
@PostMapping("/add")
+public String addItemV1(@ModelAttribute Item item, BindingResult bindingResult)
+
컨트롤러에서 데이터 바인딩 오류가 발생하면 400 오류를 클라이언트로 전달한다. 하지만 위와 같이 BindingResult를 파라미터에 추가하면, 400 오류를 바로 보내지 않고 컨트롤러를 호출하여 개발자에게 오류를 해결하도록 한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
@PostMapping("/add")
+public String addItemV1(@ModelAttribute Item item, BindingResult bindingResult) {
+ // 없으면 바로 400 오류를 보냄
+ if (bindingResult.hasErrors()) {
+ log.info("errors={}", bindingResult);
+ return "validation/v2/addForm";
+ }
+ ...
+}
+
BindingResult 객체는 thymeleaf 등에서 사용할 수 있다. th:errors="*{itemName}" 과 같이 접근할 수 있는데, 이를 위해서 개발자가 임의로 BindingResult에 오류를 추가해 줄 수 있다.
1
+2
+3
+4
+5
+
// FieldError : 하나의 필드에 오류가 있을 때 추가하는 객체. 스프링에서 바인딩 오류시 넣어줌
+bindingResult.addError(new FieldError("item", "itemName", "상품 이름은 필수입니다."));
+
+// ObjectError : 특정 필드가 아닌 여러 필트에 걸쳐 발생하거나, 글로벌 오류일 때 추가
+bindingResult.addError(new ObjectError("item", "가격 * 수량의 합은 10,000원 이상이어야 합니다. 현재 값 = " + resultPrice));
+
각각 타임리프에서 접근은 다음과 같이 한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
<!-- FieldError -->
+<div class="field-error" th:errors="*{itemName}">
+상품명 오류
+</div>
+
+<!-- ObjectError -->
+<div th:if="${#fields.hasGlobalErrors()}">
+ <p class="field-error" th:each="err : ${#fields.globalErrors()}" th:text="${err}">
+ 전체 오류 메시지
+ </p>
+</div>
+
BindingResult은 인터페이스이고, Errors 인터페이스를 상속받고 있다. 스프링에서는 BeanPropertyBindingResult라는 구현체로 둘 다 구현하여 넘겨주는데, 따라서 BindingResult 대신 Errors 인터페이스를 사용해도 된다.
하지만 Errors는 단순 오류 저장, 조회만을 포함하고 BindingResult는 좀 더 다양한 기능을 제공한다. 또한 관례적으로 BindingResult를 사용하니 BindingResult를 사용하는 것이 좋다.
스프링은 검증을 체계적으로 제공하기 위해 다음 인터페이스를 제공한다
1
+2
+3
+4
+5
+6
+
public interface Validator {
+ // 이 validator에서 지원하는 클래스인지 확인
+ boolean supports(Class<?> clazz);
+ // 검증 로직
+ void validate(Object target, Errors errors);
+}
+
이 인터페이스를 사용해서 다음과 같이 구현하였다고 해보자.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+
@Component
+public class ItemValidator implements Validator {
+ @Override
+ public boolean supports(Class<?> clazz) {
+ return Item.class.isAssignableFrom(clazz);
+ }
+
+ @Override
+ public void validate(Object target, Errors errors) {
+ Item item = (Item) target;
+
+ if (item.getPrice() != null && item.getQuantity() != null) {
+ int resultPrice = item.getPrice() * item.getQuantity();
+ if (resultPrice < 10000) {
+ errors.reject("totalPriceMin", new Object[]{10000, resultPrice}, null);
+ }
+ }
+ }
+}
+
이렇게 구현한 validator는 스프링의 WebDataBinder를 통해 스프링의 도움을 받을 수 있다. 컨트롤러에 다음과 같이 @InitBinder 설정을 한 메서드를 추가하면, 해당 컨트롤러에서는 validator를 자동으로 적용할 수 있다.
1
+2
+3
+4
+
@InitBinder
+public void init(WebDataBinder dataBinder) {
+ dataBinder.addValidators(itemValidator);
+}
+
이렇게 등록된 검증기를 사용하려면 컨트롤러 메서드 파라미터에 @Validated 또는 @Valid 애노테이션을 추가하면 된다,
1
+2
+
@PostMapping("/add")
+public String addItemV6(@Validated @ModelAttribute Item item, BindingResult bindingResult)
+
글로벌로 모든 컨트롤러에 등록할 수도 있다. @SpringBootApplication 애노테이션이 붙은 루트 클래스에서 validator를 추가해주면 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
@SpringBootApplication
+public class ItemServiceApplication implements WebMvcConfigurer {
+ public static void main(String[] args) {
+ SpringApplication.run(ItemServiceApplication.class, args);
+ }
+
+ // 글로벌 적용
+ @Override
+ public Validator getValidator() {
+ return new ItemValidator();
+ }
+}
+
애노테이션으로 쉽게 검증 로직을 적용할 수 있는 Bean Validation 2.0(JSR-380) 기술 표준이다. 검증 애노테이션과 여러 인터페이스의 모음이다.
스프링에서 Bean Validation을 사용하기 위해선 spring-boot-starter-validation라이브러리를 의존성에 추가해야한다. 추가 후 사용할 땐, 검증하고자하는 필드 위에 검증할 애노테이션을 추가하면 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
@Data
+public class Item {
+ private Long id;
+
+ @NotBlank
+ private String itemName;
+
+ @NotNull
+ @Range(min = 1000, max = 1000000)
+ private Integer price;
+}
+
그리고 컨트롤러에 @Validated 또는 @Valid를 추가해주면 된다.
1
+2
+
@PostMapping("/add")
+public String addItem(@Validated @ModelAttribute Item item, BindingResult bindingResult)
+
javax.validation.constraints.NotNull
org.hibernate.validator.constraints.Range
javax.validation 으로 시작하면 특정 구현에 관계없이 제공되는 표준 인터페이스이고, org.hibernate.validator 로 시작하면 하이버네이트 validator 구현체를 사용할 때만 제공되는 검증 기능이다. 실무에서 대부분 하이버네이트 validator를 사용하므로 자유롭게 사용해도 된다.
스프링은 Bean Validator를 이미 스프링에 완전히 통합해두었다. 스프링부트는 spring-boot-starter-validation 라이브러리를 넣으면 자동으로 Bean Validator를 인지하고 스프링에 통합한다. 이때 스프링부트는 자동으로 Bean Validator를 글로벌 Validator로 등록한다.
이때 개발자가 직접 글로벌 Validator를 등록하면 스프링부트가 추가하는 Bean Validator를 적용되지 않는다. 따라서 Bean Validator를 사용할 때는 직접 등록한 글로벌 Validator를 지워주자.
검증 순서
Bean Validator는 바인딩 된 데이터들을 검증한다. 따라서 애초에 바인딩에서 실패한다면 Bean Validator는 실행되지 않고 FieldError를 추가한다.
검증 순서
- @ModalAttribute 각각의 필드에 타입 변환시도
- 성공하면 다음으로
- 실패하면 typeMismatch로 FieldError 추가
- Validator 적용
오브젝트 오류
Bean Validator에서 특정 필드가 아닌 ObjectError를 처리하기 위해선 @ScriptAssert()를 사용하면 된다.
1
+2
+3
+4
+5
+
@Data
+@ScriptAssert(lang = "javascript", script = "_this.price * _this.quantity >= 10000")
+public class Item {
+ //...
+}
+
하지만 이 방법은 제약이 많고 복잡하다. 그리고 실무에서는 검증기능이 해당 객체 범위를 넘어서는 경우도 종종 등장한다(DB 조회 등). 따라서 Bean Validator에서 ObjectError는 @ScriptAssert()를 사용하기 보단 컨트롤러에서 직접 자바코드로 작성하는 것을 권장한다.
groups
다음과 같이 검증 애노테이션을 그룹지어 경우에 따라 다른 검증 애노테이션이 동작하도록 설정할 수 있다
1
+2
+3
+4
+5
+6
+7
+8
+9
+
@Data
+public class Item {
+ @NotNull(groups = UpdateCheck.class)
+ private String itemName;
+
+ @NotNull(groups = {SaveCheck.class, UpdateCheck.class})
+ @Range(min = 1000, max = 1000000, groups = {SaveCheck.class, UpdateCheck.class})
+ private Integer price;
+}
+
1
+2
+3
+
// SaveCheck 그룹의 애노테이션만 validation 적용
+@PostMapping("/add")
+public String addItemV2(@Validated(SaveCheck.class) @ModelAttribute Item item, BindingResult bindingResult)
+
이때 @Valid 애노테이션에는 groups 기능이 없다. 따라서 이때는 @Validated를 사용해야한다.
하지만 groups 기능을 사용하면 코드의 복잡도가 증가해서 보통 groups 기능을 사용하기보다는 검증을 달리해야하는 그룹마다 따로 객체를 생성해서 처리하는 편이다.
@ModelAttribute vs @RequestBody
Bean Validation은 @RequestBody를 적용하여 파라미터를 받아올 때도 동작한다. 하지만 객체를 바인딩할 떄의 동작은 다소 다르다.
@ModelAttribute에서는 필드 단위로 바인딩이 적용된다. 따라서 한 필드에서 바인딩 실패가 발생했을 경우엔 나머지 필드는 정상 처리하고 validation을 수행한다.
하지만 @RequestBody은 HttpMessageConver 단계에서 바인딩할 떈 전체 객체 단위로 적용된다. 따라서 한 필드에서 바인딩 오류가 발생한다면 전체 필드가 처리되지 않고 예외가 발생한다.
Comments powered by Disqus.
검색 API를 개발하는 과정에서 다음과 같이 검색 타입을 enum 으로 지정하였고, controller의 param으로 받으려고 했다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
@Getter
+@AllArgsConstructor
+public enum SearchType {
+ TITLE("title"),
+ CONTENT("content"),
+ HASHTAG("hashtag"),
+ NICKNAME("nickname");
+
+ private final String type;
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+
public class ArticleSearchQuery {
+ public Optional<Integer> offset;
+ public Optional<Integer> limit;
+ public Optional<Integer> category;
+ @NotBlank
+ public String keyword;
+ @NotNull
+ public SearchType type;
+}
+
1
+2
+3
+4
+5
+
@GetMapping(path = "/search")
+public ResponseEntity<ResponseWrapper<ArticleListDto>> searchArticles(
+ @Valid ArticleSearchQuery articleSearchQuery) {
+ ...
+}
+
하지만 SearchType을 요청을 ModelAttribute로 변환하는 과정에서 다음과 같은 오류가 났다.
1
+
Resolved [org.springframework.web.method.annotation.\ModelAttributeMethodProcessor$1: org.springframework.validation.\BeanPropertyBindingResult: 1 errors<EOL>Field error in object \'articleSearchQuery' on field 'type': rejected value [hashtag];
+
Spring’s @RequestParam with Enum 질문의 답변을 보면 Converter를 구현하고 그것을 빈에 등록하면, 스프링 부트가 자동으로 컨버터를 로드하여 데이터를 변환할 때 쓴다고 한다.
1
+2
+3
+4
+5
+6
+7
+
@Component
+public class SearchTypeConverter implements Converter<String, SearchType> {
+ @Override
+ public SearchType convert(String value) {
+ return SearchType.valueOf(value.toUpperCase());
+ }
+}
+
Comments powered by Disqus.
controller 인자로 enum 받는 문제를 해결했던 것은 enum 타입에 맞춘 Converter를 bean에 등록하는 것이었다. 단순히 bean에 등록하는 것으로 controller에서 httpConverter 동작할 때 이것을 적용한 것이다. 이 뒤에 무엇이 있을까 하여 조사해보았다.
스프링에서는 기본적인 타입 변환은 자동으로 지원한다. 따라서 파라미터로 넘어온 문자 데이터가 컨트롤러에서 직접 Integer 타입으로 변환된다.
1
+2
+3
+
@GetMapping(path = "/{articleId}")
+public String getArticleDetail(@PathVariable long articleId) {
+ ...
+
위와 같이 파라미터로 넘어온 문자데이터를 long 타입으로 받아도 스프링에서는 자동으로 변환시켜주기에 문제 없다.
하지만 지원하지 않는 타입도 존재한다. 이럴땐 Converter 인터페이스를 사용하면 된다. 이때 주의할 것이 아래 경로의 Converter를 가져와야한다.
org.springframework.core.convert.converter.Converter
Converter는 두 개의 제네릭을 받는다. 첫번째는 입력 타입이고, 두번째는 반환 타입이다.
1
+
public class SearchTypeConverter implements Converter<String, SearchType>
+
Converter를 적용하려면 convert 메서드를 오버라이드하고, 스프링 빈에 등록해야한다.
1
+2
+3
+4
+5
+6
+7
+
@Component
+public class SearchTypeConverter implements Converter<String, SearchType> {
+ @Override
+ public SearchType convert(String value) {
+ return SearchType.valueOf(value.toUpperCase());
+ }
+}
+
이렇게 등록을 하고 나면 스프링에서 해당 입력 타입을 반환타입으로 convert 해야할 때 등록한 메서드가 사용된다.
Comments powered by Disqus.
게시글 검색을 개발하는 도중 검색의 대상이 되는 field(title | nickname | content)를 동적으로 mybatis 쿼리문 상에 사용해야할 일이 있었다. 따라서 다음과 같이 #{} 를 사용하여 변수를 넣었으나 오류가 발생했다.
1
+2
+3
+4
+5
+
<where>
+ <when test="type != 'hashtag'">
+ atc.#{type} LIKE concat('%', #{keyword}, '%')
+ </when>
+</where>
+
스택오버플로우 질문의 답변에서 #{}은 mybatis에서 자동으로 값을 ''로 감싸기에 그냥 replace하는 ${}를 사용하라는 답변을 얻었고 해결할 수 있었다.
Comments powered by Disqus.
mybatis mapper에서 requestType이나 parameterType으로 클래스를 참조할 때 다음과 같이 패키지명을 다 써줘야하는 불편함이 있다.
1
+2
+3
+
<mapper namespace="com.hello.spring.article.mapper.ArticleMapper">
+ <select id="selectArticles" resultType="com.hello.spring.article.dto.ArticleDto">
+ ...
+
이럴 땐 application.properties에서 다음과 같이 설정해주면 쿼리 태그에서는 패키지명을 써주지 않고 클래스명만 써줘도 된다.
1
+
mybatis.type-aliases-package=com.hello.spring
+
1
+2
+3
+
<mapper namespace="com.hello.spring.article.mapper.ArticleMapper">
+ <select id="selectArticles" resultType="ArticleDto">
+ ...
+
스프링에서 mybatis.type-aliases-package에 설정된 패키지를 보고 그 하위 경로에서 클래스를 찾는 방식이다.
mybatis.type-aliases-package에서 설정한 패키지 하위 경로를 모두 살펴보는 방식으로 동작하므로, 같은 클래스가 두 개 이상 존재하면 에러가 난다.
1
+2
+3
+4
+5
+
// 파일구조
+dto
+ > test
+ > ArticleDto
+ > ArticleDto
+
1
+
Caused by: org.apache.ibatis.type.TypeException: The alias 'ArticleDto' is already mapped to the value 'com.hello.spring.article.dto.ArticleDto'.
+
이럴 땐 아래와 같이 둘 중 하나를 @Alias 애노테이션으로 다른 이름으로 지정해주면 해결된다.
1
+2
+
@Alias("ArticleDto2")
+public class ArticleDto
+
Comments powered by Disqus.
빈 스코프는 말 그대로 빈이 존재할 수 있는 범위를 뜻한다. 스프링에서는 다음과 같은 스코프를 지원한다
싱글톤 스코프의 빈을 조회하면 스프링 컨테이너는 항상 같은 인스턴스의 스프링 빈을 반환한다. 반면에 프로토타입 스코프를 스프링 컨테이너에 조회하면 스프링 컨테이너는 항상 새로운 인스턴스를 생성해서 반환한다.
스프링 컨테이너는 프로토타입 빈을 관리하지 않는다. 프로토타입 빈을 관리할 책임은 프로토타입 빈을 받은 클라이언트에게 있다. 따라서 @PreDestroy 같은 종료 메서드가 호출되지 않는다.
싱글톤 빈과 함께 사용시 문제점
프로토타입 빈은 매번 새로운 객체 인스턴스를 생성하다는 점에서 싱글톤 빈과 함께 사용시 의도한 대로 동작하지 않을 수 있다.
만약 싱글톤으로 관리되는 빈에서 프로토타입 빈을 의존한다면, 싱글톤 빈이 생성되는 시점에 프로토타입 빈은 단 한번 주입된다. 따라서 클라이언트 요청이 얼마나 많든 싱글톤 빈에 주입된 프로토타입 빈은 새로 생성되지 않는다.
만약 프로토타입 빈은 매 요청마다 새롭게 생성하는 것을 의도하여 사용되는데, 이렇게 된다면 의도한대로 동작하는 것이 아닐 것이다.
참고 : 여러 빈에서 같은 프로토타입 빈을 주입 받으면, 주입 받는 시점에 각각 새로운 프로토타입 빈이 생성된다. 예를 들어서 clientA, clientB가 각각 의존관계 주입을 받으면 각각 다른 인스턴스의 프로토타입 빈을 주입 받는다.
clientA prototypeBean@x01
clientB prototypeBean@x02
물론 사용할 때 마다 새로 생성되는 것은 아니다
싱글톤 빈과 함께 사용시 Provider로 문제 해결
싱글톤 빈과 프로토타입 빈을 함께 사용할 때, 사용할 때마다 항상 새로운 프로토타입 빈을 생성하기 위해선 DI가 아닌 직접 필요한 의존관계를 찾는 것을 의미하는 Dependency Lookup(DL)이 필요하다. DL을 위해선 다음과 같은 방법들이 있다.
스프링 컨테이너에 요청 : ApplicationContext 클래스로 사용할 때마다 프로토타입 빈 직접 가져오기
ObjectFactory, ObjectProvider
1
+2
+3
+4
+5
+6
+7
+8
+9
+
@Autowired
+private ObjectProvider<PrototypeBean> prototypeBeanProvider;
+
+public int logic() {
+ PrototypeBean prototypeBean = prototypeBeanProvider.getObject();
+ prototypeBean.addCount();
+ int count = prototypeBean.getCount();
+ return count;
+}
+
getObject()를 호출하면 내부에서 스프링 컨테이너를 통해 해당 빈을 찾아서 반환한다.JSR-330 Provider
javax.inject.Provider 이라는 JSR-330 자바표준이다javax.inject:javax.inject:1 라이브러리를 추가해줘야함1
+2
+3
+4
+5
+6
+7
+8
+9
+
@Autowired
+private Provider<PrototypeBean> provider;
+
+public int logic() {
+ PrototypeBean prototypeBean = provider.get();
+ prototypeBean.addCount();
+ int count = prototypeBean.getCount();
+ return count;
+}
+
ObjectProvider와 JSR-330 Provider 중에선 만약 코드를 스프링이 아닌 다른 컨테이너에서도 사용할 수 있어야한다면 JSR-330 Provider를 사용하면 된다. 하지만 그럴일은 거의 없다.
웹 스코프는 다음과 같은 특징이 있다.
그리고 종류는 다음과 같다.
Request 스코프 예시
Request 스코프의 경우 매 요청마다 하나의 빈이 관리된다. 따라서 다음과 같이 로그를 남기는 빈에서, 요청을 구분하기 위해 사용될 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+
@Component
+@Scope(value = "request")
+public class MyLogger {
+ private String uuid;
+ private String requestURL;
+
+ public void setRequestURL(String requestURL) {
+ this.requestURL = requestURL;
+ }
+ public void log(String message) {
+ System.out.println("[" + uuid + "]" + "[" + requestURL + "] " + message);
+ }
+
+ @PostConstruct
+ public void init() {
+ uuid = UUID.randomUUID().toString();
+ System.out.println("[" + uuid + "] request scope bean create:" + this);
+ }
+
+ @PreDestroy
+ public void close() {
+ System.out.println("[" + uuid + "] request scope bean close:" + this);
+ }
+}
+
주의점
만약 위와 같은 웹 스코프 빈을 주입받는 빈을 생성하고 애플리케이션을 실행시키면 다음과 같은 오류가 발생한다.
1
+2
+3
+
Error creating bean with name 'myLogger': Scope 'request' is not active for the
+ current thread; consider defining a scoped proxy for this bean if you intend to
+ refer to it from a singleton;
+
request 스코프 빈은 요청이와야 생성되는 빈이므로, 아직 생성도 안됐는데 다른 빈에서 주입받을 수 없다는 뜻이다.
이 문제를 해결해기 위해선 다음과 같은 방법이 있다.
웹 스코프 빈을 사용할 때마다 스프링빈에서 직접 조회 or Provider 사용
ObjectProvider로 필요할 때 꺼내어 사용하면 된다.getIfAvailable() 메서드를 사용하면 된다. 빈을 사용할 수 없는 상황에선 null을 반환하는 메서드이다.프록시 사용
1
+2
+3
+
@Component
+@Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
+public class MyLogger
+
@Scope 애노테이션에 속성으로 proxyMode를 주어 프록시를 사용할 수 있다.TARGET_CLASS, 인터페이스면 INTERFACECS 선택프록시 동작원리
myLogger.logic()을 호출하면 사실은 가짜 프록시 객체의 메서드를 호출한 것이다.Comments powered by Disqus.
서블릿 컨테이너는 서블릿들의 생성, 실행, 파괴를 담당하며 서블릿을 관리해준다. 서블릿 컨테이너는 클라이언트의 요청을 받고 응답할 수 있게, 웹 서버와 소켓을 만들어 통신한다.
서블릿 컨테이너의 대표적인 무료 서비스로 톰캣이 있다. 톰캣은 웹 서버와 소켓을 만들어 통신하며 JSP와 서블릿이 작동할 수 있는 환경을 제공한다.
웹 프로그래밍에서 클라이언트의 HTTP 요청을 처리하고 응답을 보내는 자바 프로그래밍 기술. Servlet 클래스의 구현 규칙을 따른다.
Servlet 은 javax.servlet 패키지에 정의된 인터페이스로, 서블릿의 라이프 사이클을 위한 세가지 필수적인 메서드를 정의한다.
서블릿의 특징
서블릿 컨테이너는 서블릿와 웹서버가 손쉽게 통신할 수 있게 해주어, 소켓을 만들고 listen, accept 등을 API로 제공하여 복잡한 과정을 생략할 수 있게 해준다
이 과정에서 JVM은 클라이언트의 요청들을 각각 분리된 스레드 내부에서 처리한다. 즉, 서블릿을 사용하는 것은 JVM이 각 요청을 분리된 자바 스레드 내부에서 처리하도록 하는 것이다. 각 서블릿은 HTTP 요청에 응답하는 특정한 요소들이 있는 자바 클래스이다.
대부분의 사례에 서블릿 컨테이너는 하나의 JVM에서 동작하지만 컨테이너가 여러 개의 JVM들을 필요로하는 문제가 존재하기도 한다.
서블릿 컨테이너의 가장 중요한 기능은 요청을 올바른 서블릿에 전달해서 처리되도록 하고, JVM이 해당 요청을 처리한 후에는 생성된 결과를 올바른 장소에 동적으로 반환해주는 것이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
@WebServlet(name = "requestHeaderServlet", urlPatterns = "/request-header")
+public class RequestHeaderServlet extends HttpServlet {
+ @Override
+ protected void service(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ System.out.println("request.getMethod() = " + request.getMethod());
+ ...
+ response.getWriter().write("ok");
+ }
+}
+
@WebServlet : 클라이언트의 요청 URL을 보고 서블릿 컨테이너에서 서블릿을 매핑할 때 web.xml을 통해 찾는 방법과 애노테이션으로 찾는 방법이 있다. 여기서는 @WebServlet을 사용하여 애노테이션으로 접근하였다HttpServlet : Servlet인터페이스를 구현한 클래스로, HTTP 요청에 대응하기 좋은 형태로 구현되어있다. WAS가 생성한 HttpServletRequest와 HttpServletResponse을 받아 service나 doGet 등의 메서드를 수행한다.HttpServletRequest, HttpServletResponse : 클라이언트의 요청과, 응답을 위한 데이터는 개발자가 접근하기 어려운 단순 텍스트로 되어있다. 이와 같은 요청/응답에 쉽게 접근할 수 있도록 하는 객체가 이 두가지이다.https://velog.io/@han_been/%EC%84%9C%EB%B8%94%EB%A6%BF-%EC%BB%A8%ED%85%8C%EC%9D%B4%EB%84%88Servlet-Container-%EB%9E%80
https://velog.io/@han_been/Servlet
Comments powered by Disqus.
스프링에서 공통 관심사를 처리하기 위한 방법으로, 스프링 인터셉터와 함께 쓰이는 방법이다. 스프링 AOP를 사용하여 공통관심사를 처리할 수 있지만 웹과 관련된 공통 관심사는 서블릿 필터나 스프링 인터셉터를 사용하는 것이 좋다. 서플릿 필터나 스프링 인터셉터는 HttpServletRequest를 제공해주기 때문이다.
필터 흐름
HTTP 요청 -> WAS -> 필터 -> 디스패처 서블릿 -> 컨트롤러
필터는 디스패처 서블릿이 호출되기 전에 호출된다. 필터를 통해 다음과 같은 것들을 할 수 있다.
필터 제한 : 적절하지 않은 요청을 차단할 수 있다.
필터 체인 : 다음과 같이 필터를 연속으로 적용하여 체인처럼 사용할 수 있다.
HTTP 요청 -> WAS -> 필터1 -> 필터2 -> 필터3 -> 디스패처 서블릿
필터 인터페이스
필터인터페이스는 다음과 같은 메서드가 등록되어있다. 이 필터 인터페이스를 구현하고 등록하면 서블릿 컨테이너가 필터를 싱글톤 객체로 생성하고 관리한다.
필터 등록
스프링 부트에서는 다음과 같이 FilterRegistrationBean를 사용하여 등록하면 된다. 이때 등록하는 메서드는 @Configuration 로 등록한 클래스 아래 위치해야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
@Configuration
+public class WebConfig {
+ @Bean
+ public FilterRegistrationBean logFilter() {
+ FilterRegistrationBean<Filter> filterRegistrationBean = new FilterRegistrationBean<>();
+ filterRegistrationBean.setFilter(new LogFilter());
+ filterRegistrationBean.setOrder(1);
+ filterRegistrationBean.addUrlPatterns("/*");
+ return filterRegistrationBean;
+ }
+}
+
서블릿 URL 패턴이라고 검색하면 된다.이외 @ServletComponentScan, @WebFilter(filterName="logFilter", urlPatterns="/*")으로 필터 등록이 가능하지만, 필터 순서 조절이 안된다. 따라서 FilterRegistrationBean을 사용하는 것이 좋다.
서블릿 필터는 스프링 인터셉터와 함께 웹 요청이 왔을 때 공통 관심사를 처리해주는 방법이다. 서블릿 필터는 스프링 인터셉터와 달리 디스패처 서블릿 이전에 호출된다. 필터 인터페이스를 구현하고, 빈에 등록하여 서블릿 필터를 등록할 수 있다
Comments powered by Disqus.
과정
핸들러 매핑 과정을 진행한다.핸들러 어댑터를 조회한다.ModelAndView로 만들어 Dispatcher Servlet에게 반환해준다.viewResolver 를 호출한다.스프링 MVC는 위와 같이 매우 많은 과정을 거쳐 동작하지만, 개발자는 핸들러를 구현하고 이를 매핑 시켜주는 것만해주면 스프링 프레임워크에서 나머지를 알아서 해준다.
Dispatcher Servlet 구조
HttpServlet을 상속 받아서 사용하고, 서블릿으로 동작한다.urlPatterns="/")에 대해 매핑한다.HttpServlet이 제공하는 service()가 호출된다. Dispatcher Servlet의 부모인 FrameworkServlet은 service()를 오버라이드 해두었다. FrameworkServlet.service()를 시작으로 여러 메서드가 호출되면서 DispatcherServlet.doDispatch()가 호출되고 위 과정을 시작한다.스프링 부트가 자동 등록하는 핸들러 매핑과 핸들러 어댑터
HandlerMapping
HandlerAdapter
핸들러 매핑과 핸들러 어댑터는 이 순서대로 찾고, 없으면 다음 순서로 넘어간다.
스프링 부트가 자동 등록하는 뷰 리졸버
(이외에도 존재함)
출처 : 김영한의 스프링 강의
Comments powered by Disqus.
캐시란 반복적으로 데이터를 불러올 때 지속적으로 DBMS 혹은 서버에 요청하는 것이 아닌 메모리에 데이터를 저장하였다가 데이터를 불러다가 쓰는 것을 말한다. 서버나 DBMS의 부담을 줄여주고, 메모리에 저장되어있기 때문에 많은 시스템에서 사용할수 있다.
캐시는 Long Tail 법칙에 따라 시스템 리소스 사용의 대부분을 차지하는 20%의 요청을 캐싱하면 시스템 전체가 매우 빨라진다고 할 수 있다.
스프링 부트에서 spring-boot-starter-cache을 추가하여 구성할 수 있는 캐시 매니저이다. 기본적으로 별도의 추가적인 서드파티 모듈이 없는 경우에는 Local Memory에 저장이 가능한 ConcurrentMap 기반인 ConcurrentMapCacheManager가 빈으로 자동 생성된다.
이 외에도 EHCache, Redis 등의 서드 파티 모듈을 추가하면 EHCacheCacheManager, RedisCacheManager를 빈으로 등록하여 사용할 수 있다. 이렇게 하면 별도로 다른 설정 없이도 단순 Memory cache가 아닌 cache server를 대상으로 캐시를 저장할 수 있도록 지원하고 있다.
스프링 3.2 이상에서는 7개의 CacheManager 구현체를 지원한다
SimpleCacheManager는 단순히 캐시를 등록하여 사용하는데 사용할 수 있지만, 다른 캐시매니저와는 달리 다양한 캐시를 조합하여 등록할 수 있다는 점에서 편리할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
// ConcurrentMapCacheManager
+// 캐시의 이름만 등록할 수 있고, 모두 ConcurrnetMapCache로 등록된다.
+new ConcurrentMapCacheManager("comment", "category", "user");
+
+// SimpleCacheManager
+// 캐시를 직접 등록하여, 다양한 조합의 캐시로 사용할 수 있다.
+SimpleCacheManager cm = new SimpleCacheManager();
+cm.setCaches(Arrays.asList(
+ defaultCache(),
+ exceptionCache()));
+
Annotation 기반 캐싱 설정을 사용함을 명시하는 애노테이션이다. (내부적으로는 Sprign AOP 사용)
속성
1
+2
+3
+4
+5
+
@Target(value={TYPE,METHOD})
+@Retention(value=RUNTIME)
+@Inherited
+@Documented
+public @interface Cacheable
+
메서드에 붙어, 해당 메서드가 호출된 결과가 캐시 될 수 있다고 알려주는 애노테이션이다.
동작
지시된 메서드가 호출될 때마다, 주어진 파라미터로 이미 호출된 적이 있는지 확인하는 과정이 추가된다. 기본적으론 메서드의 파라미터를 캐시 키로 사용하지만, SpEL expression이 key()로 적용될 수 있다. 또는 커스텀 KeyGenerator 구현이 적용될 수도 있다.
만약 주어진 캐시 키로 값을 찾을 수 없다면, 메서드는 정상적으로 호출되고 반환값을 만든다. 그리고 그 반환값은 캐시 저장소에 저장된다.
주의 : Optional로 감싸진 값은 자동으로 unwrap 된다. Optional 값이 존재하면 그 값이 저장되고, 없으면 null이 저장된다.
속성
unless = “#id == null” –> id가 null일 땐 캐싱이 일어나지 않음.메서드 실행 시, 해당 캐시를 삭제
속성
속성
속성
속성
org.springframework.cache.annotation 아래 있는 애노테이션으로, spring-boot-starter-cache 의존성을 추가해줘야한다.
compile('org.springframework.boot:spring-boot-starter-cache')
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
@Configuration
+@EnableCaching
+public class CachingConfig {
+ @Bean
+ public CacheManager cacheManager() {
+ SimpleCacheManager cacheManager = new SimpleCacheManager();
+ cacheManager.setCaches(Arrays.asList(
+ new ConcurrentMapCache("article")));
+ return cacheManager;
+ }
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
@Service
+public class ArticleService {
+ @Cacheable(value = "article")
+ public String getArticles(long articleId){
+ String article = "";
+
+ System.out.println( code + " article을 조회합니다 ...");
+ if(articleId == 1){
+ article = "첫번째 아티클"
+ }
+ else if(articleId == 2){
+ article = "두번째 아티클";
+ }
+ else if(articleId == 3){
+ article = "세번째 아티클";
+ }
+ }
+}
+
https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/cache/annotation/Cacheable.html
https://bob-full.tistory.com/23
https://jaehun2841.github.io/2018/11/07/2018-10-03-spring-ehcache/#Cache%EB%9E%80
https://shinsunyoung.tistory.com/50
Comments powered by Disqus.
서블릿의 예외처리 방식
Exception
WAS <- 서블릿 컨테이너 <- 필터 <- 서블릿 <- 인터셉터 <- 컨트롤러(예외발생)
500 Internal Server Error 페이지를 클라이언트로 반환한다.response.sendError()
WAS <- 서블릿 컨테이너(sendError 호출 기록 확인) <- 필터 <- 서블릿 <- 인터셉터 <- 컨트롤러(예외발생)
서블릿 오류화면 등록
스프링 부트에서 서블릿 컨테이너는 스브링 부트를 통해 실행되므로 스프링 부트가 제공하는 기능을 사용하여 서블릿 오류 페이지를 등록할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
@Component
+public class WebServerCustomizer implements WebServerFactoryCustomizer<ConfigurableWebServerFactory> {
+ @Override
+ public void customize(ConfigurableWebServerFactory factory) {
+ ErrorPage error404 = new ErrorPage(HttpStatus.NOT_FOUND, "/error-404");
+ ErrorPage errorExtra = new ErrorPage(Exception.class, "/error-extra");
+ factory.addErrorPages(page404, pageExtra);
+ }
+}
+
등록된 에러 페이지는 함께 등록된 주소를 호출하는 방식으로 동작하기에, 해당 주소를 처리해줄 컨트롤러가 필요하다.
1
+2
+
@RequestMapping("/error-404")
+public String error404(HttpServletRequest request, HttpServletResponse response)
+
서블릿 컨테이너에서 담아주는 정보
서블릿 컨테이너는 오류페이지를 호출하기 전에 request attribute에 오류에 관한 정보를 담아준다. 그 정보는 다음과 같다.
DispatcherType : 오류시 필터 넘어가기
서블릿 컨테이너로 넘어온 에러는 다음과 같은 과정을 거친다
서블릿 컨테이너 <- 필터 <- 서블릿 <- 인터셉터 <- 컨트롤러(예외발생)
서블릿 컨테이너 -> 필터 -> 서블릿 -> 인터셉터 -> 컨트롤러(error-404) -> view
하지만 필터를 오류화면을 가져오는 과정에서까지 반복할 필요는 없을 것이다. 서블릿은 이런 문제를 해결하기 위해 DispatcherType을 제공한다.
DispatcherType은 request에 들어있는 정보로 request.getDispatcherType()으로 조회가능하다. DispatcherType에는 다음과 같은 것들이 있다.
FORWARD : 서블릿에서 다른 서블릿이나 JSP를 호출할 때
RequestDispatcher.forward(request, response)
INCLUDE : 서블릿에서 다른 서블릿이나 JSP의 결과를 포함할 때
RequestDispatcher.include(request, response)
REQUEST : 클라이언트 요청
ASYNC : 서블릿 비동기 호출
ERROR : 오류 요청
이 DispatcherType을 활용하여 필터를 등록할 때 DispatcherType 설정을 추가해주면 원하는 DispatcherType일 때만 필터를 호출하도록 설정가능하다
1
+2
+3
+4
+5
+6
+7
+8
+9
+
@Configuration
+public class WebConfig implements WebMvcConfigurer {
+ @Bean
+ public FilterRegistrationBean logFilter() {
+ ...
+ filterRegistrationBean.setDispatcherTypes(DispatcherType.REQUEST,DispatcherType.ERROR);
+ ...
+ }
+}
+
오류시 인터셉터 넘어가기
인터셉터는 스프링에서 제공하는 기능이므로 DispatcherType과 무관하게 항상 호출된다. 하지만 다음과 같이 인터셉터를 등록할 때 오류페이지로 가는 호출을 excludePathPatterns에 등록하면 같은 효과를 얻을 수 있다.
1
+2
+3
+4
+5
+6
+7
+
@Override
+public void addInterceptors(InterceptorRegistry registry) {
+ registry.addInterceptor(new LogInterceptor())
+ .order(1)
+ .addPathPatterns("/**")
+ .excludePathPatterns("/error-page/**");
+}
+
서블릿에 오류페이지를 등록할 때는 다음과 같은 과정을 거쳤다.
하지만 스프링 부트에서는 위와 같은 과정이 필요없다.
오류페이지 등록
스프링부트에서는 아래를 기본으로 제공한다.
/error라는 경로로 기본 오류페이지를 설정하고, 상태코드나 예외를 설정하지 않으면 기본 오류페이지로 사용한다./error를 호출한다./error를 매핑해서 처리하는 컨트롤러다따라서 스프링부트에서는 /error 경로에 오류 페이지 파일을 만들어서 넣어두기만 하면 알아서 오류페이지가 클라이언트로 전달된다.이때 뷰 선택은 BasicErrorController에서 일어나고, 아래와 같은 우선순위로 일어난다.
BasicErrorController가 제공하는 정보들
BasicErrorController는 다음 정보를 model에 담아서 뷰에 전달한다.
하지만 위와 같은 정보를 클라이언트에 노출하는 건 좋지 않다.
application.properties에서 다음과 같이 model에 정보를 담을지 말지 선택할 수 있다.
server.error.include-exceptionserver.error.include-messageserver.error.include-stacktraceserver.error.include-binding-errors스프링 부트 오류 관련 옵션
server.error.whitelabel.enabled : 오류 처리화면을 못 찾을 시, 스프링 whitelabel 오류 페이지 적용server.error.path : 오류 페이지 경로. 스프링이 자동 등록하는 서블릿 글로벌 오류 페이지 경로와 BasicErrorController 오류 컨트롤러 경로에 함께 사용된다.BasicErrorController 확장 방법
스프링 부트에서 자동등록하는 에러 공통처리 컨트롤러의 기능을 변경하고 싶으면 다음과 같이 하면 된다.
Comments powered by Disqus.
HttpServletRequest
1
+2
+
@RequestMapping("/request-param-v1")
+public void requestParamV1(HttpServletRequest request, HttpServletResponse response)
+
HttpServletRequest에서 조회해서 꺼내올 수 있다.
@RequestParam
1
+2
+3
+4
+
@RequestMapping("/request-param-v2")
+ public String requestParamV2(
+ @RequestParam("username") String memberName,
+ @RequestParam("age") int memberAge) {
+
이때 파라미터 이름과, 매개변수에 쓰인 변수명이 같다면 다음과 같이 생략할 수있다.
1
+2
+3
+4
+
@RequestMapping("/request-param-v3")
+public String requestParamV3(
+ @RequestParam String username,
+ @RequestParam int age) {
+
또한 만약 String, int, Integer와 같이 단순 타입이면 @RequestParam을 생략할 수도 있다.
1
+2
+
@RequestMapping("/request-param-v4")
+public String requestParamV4(String username, int age)
+
but 너무 없애면 과할 수도 있다는걸 생각하자.
번외로 다음과 같이 required 옵션을 주면 해당 파라미터가 없을 때 400 예외를 내도록 할 수 있다. defaultValue도 줄 수 있다.
1
+2
+3
+4
+
@RequestMapping("/request-param-required")
+public String requestParamRequired(
+ @RequestParam(required = true, defaultValue = "guest") String username,
+ @RequestParam(required = false, defaultValue = "-1") int age)
+
주의
/request-param?username= –> 이 경우는 빈문자로 통과한다./request-param –> 이 경우에는 required=false 로 지정된 매개변수엔 null이 들어가는데, primitive 타입엔 null 할당이 불가능하므로 500 에러가 난다./request-param?username= –> 빈문자도 defaultValue가 적용된다.다음과 같이 맵으로 조회하는 방법도 있다.
1
+2
+3
+4
+5
+6
+
@RequestMapping("/request-param-map")
+public String requestParamMap(@RequestParam Map<String, Object> paramMap)
+
+// "?value=첫번째&value=두번째" 처럼 여러개가 들어올 땐 MultiValueMap 사용
+@RequestMapping("/request-param-map")
+public String requestParamMap(@RequestParam MultiValueMap<String, Object> paramMap)
+
@ModelAttribute
파라미터를 객체의 형태로 받을 수 있도록 하는 애노테이션이다.
1
+2
+
@RequestMapping("/model-attribute-v1")
+public String modelAttributeV1(@ModelAttribute HelloData helloData)
+
@ModelAttribute 동작원리
바인딩 오류
BindException을 발생시킨다.@ModelAttribute 는 다음과 같이 생략할 수 있다. 하지만, 너무 생략하면 이해하기 어려운 코드가 될 수 있다.
1
+2
+
@RequestMapping("/model-attribute-v2")
+public String modelAttributeV2(HelloData helloData)
+
HttpServletRequest
1
+2
+3
+4
+5
+
@PostMapping("/request-body-string-v1")
+public void requestBodyString(HttpServletRequest request) {
+ ServletInputStream inputStream = request.getInputStream();
+ String messageBody = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);
+}
+
HttpServletRequest를 통해 http request 메시지 전체를 받고, InputStream을 꺼내어 body를 만드는 방법이 있다. 많이 번거로운 방법.
InputStream
1
+2
+3
+4
+
@PostMapping("/request-body-string-v2")
+public void requestBodyStringV2(InputStream inputStream) {
+ String messageBody = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);
+}
+
바로 InputStream을 꺼내는 방법도 가능하다.
HttpEntity
1
+2
+3
+4
+
@PostMapping("/request-body-string-v3")
+ public HttpEntity<String> requestBodyStringV3(HttpEntity<String> httpEntity) {
+ String messageBody = httpEntity.getBody();
+ }
+
HttpEntity로 body를 직접 꺼내올 수 있다. (header도 조회가능)
RequestEntity는 HttpEntity를 상소받아 만든 객체이다. 따라서 마찬가지로 body를 바로 가져올 수 있다.
@RequestBody
1
+2
+
@PostMapping("/request-body-string-v4")
+public String requestBodyStringV4(@RequestBody String messageBody)
+
애노테이션 기반으로 바로 가져올 수도 있다.
HttpServletRequest
1
+2
+3
+4
+5
+6
+7
+8
+
public void requestBodyJsonV1(HttpServletRequest request,
+ HttpServletResponse response) throws IOException {
+ ServletInputStream inputStream = request.getInputStream();
+ String messageBody = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);
+
+ ObjectMapper objectMapper = new ObjectMapper();
+ HelloData data = objectMapper.readValue(messageBody, HelloData.class);
+}
+
InputStream을 가져와 ObjectMapper로 변환시켜주면 된다. 매우 번거로움
@RequestBody
1
+2
+
@PostMapping("/request-body-json-v3")
+public String requestBodyJsonV3(@RequestBody HelloData data)
+
애노테이션 기반으로 객체 형식으로 바로 가져올 수 있다.
이때 @RequestBody 애노테이션은 생략 불가능하다. 그 이유는 스프링에서는 @ModelAttribute, @RequestParam과 같은 애노테이션을 생략할 시 다음과 같은 규칙을 적용하기 때문이다.
따라서 @RequestBody를 생략하면 HelloData는 단순타입이 아니므로 @ModelAttribute가 적용되기에 @RequestBody는 생략해서는 안된다.
HttpEntity
1
+2
+3
+4
+
@PostMapping("/request-body-json-v4")
+public String requestBodyJsonV4(HttpEntity<HelloData> httpEntity) {
+ HelloData data = httpEntity.getBody();
+}
+
정적 리소스, 뷰 템플릿
ModelAndView
1
+2
+3
+4
+5
+
@RequestMapping("/response-view-v1")
+public ModelAndView responseViewV1() {
+ ModelAndView mav = new ModelAndView("response/hello").addObject("data", "hello!");
+ return mav;
+}
+
String 반환
1
+2
+3
+4
+5
+
@RequestMapping("/response-view-v2")
+public String responseViewV2(Model model) {
+ model.addAttribute("data", "hello!!");
+ return "response/hello";
+}
+
void 반환
1
+2
+3
+4
+
@RequestMapping("/response/hello")
+public void responseViewV3(Model model) {
+ model.addAttribute("data", "hello!!");
+}
+
요청 URL을 참고하여 논리 뷰 이름으로 사용한다.
요청 URL : /response/hello
실행 : templates/response/hello.html
하지만 이 방법은 가시성이 떨어지기에 웬만하면 다른 방법을 쓰자.
HttpServletResponse
1
+2
+3
+
public void responseBodyV1(HttpServletResponse response) throws IOException {
+ response.getWriter().write("ok");
+}
+
ResponseEntity
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
public ResponseEntity<String> responseBodyV2() {
+ return new ResponseEntity<>("ok", HttpStatus.OK);
+}
+
+public ResponseEntity<HelloData> responseBodyJsonV1() {
+ HelloData helloData = new HelloData();
+ helloData.setUsername("userA");
+ helloData.setAge(20);
+ return new ResponseEntity<>(helloData, HttpStatus.OK);
+}
+
@ResponseBody
1
+2
+3
+4
+5
+6
+
@ResponseStatus(HttpStatus.OK)
+@ResponseBody
+@GetMapping("/response-body-string-v3")
+public String responseBodyV3() {
+ return "ok";
+}
+
@ResponseBody 로 응답을 보낼 때는 Status 설정을 애노테이션으로 해줘야한다. 또한 컨트롤러에 @RestController를 등록하면, 해당 컨트롤러에 모든 메서드에 @ResponseBody가 적용된다.
주의 : @ResponseBody를 빼고, String을 응답하면 해당 경로에 있는 정적리소스를 반환한다.
Comments powered by Disqus.
제목 그대로 다음과 같이 @NoArgsConstructor 애노테이션을 @ModelAttribute로 적용되는 컨트롤러 파라미터 클래스에 추가하니 제대로 쿼리를 날려도 아무것도 안들어가는 이슈가 발생했다.
1
+2
+
@GetMapping("/article")
+public ResponseEntity getArticles(@ModelAttribute SelectArticlesQuery query)
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+
@Getter
+@AllArgsConstructor
+@NoArgsConstructor
+@ToString
+public class SelectArticlesQuery {
+ private Integer offset;
+ private Integer limit;
+ private Integer category;
+}
+
요청 : /article?limit=20&offset=10
+toString() => SelectArticlesQuery(offset=null, limit=null, category=null)
+이 이슈에 대한 해답은 이 포스트에서 찾을 수 있었다.
Spring은 URL 파라미터 또는 POST Form Data 형태의 파라미터를 위와 같은 특정 클래스로 자동으로 바인딩해주는데 이때 반환되는 객체를 커맨드 객체라고 부른다. 그리고 커맨드 객체의 매핑규칙은 다음과 같다.
따라서 만약 @NoArgsConstuctor가 있다면 @Setter를 통해 setter 메서드를 선언해주어야 필드를 초기화 할 수 있게 된다. 따라서 위 예시에서 SelectArticlesQuery을 다음과 같이 변경하면 문제는 해결된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
@Getter
+@Setter // 추가
+@AllArgsConstructor
+@NoArgsConstructor
+@ToString
+public class SelectArticlesQuery {
+ private Integer offset;
+ private Integer limit;
+ private Integer category;
+}
+
1
+2
+
요청 : /article?limit=20&offset=10
+toString() => SelectArticlesQuery(offset=10, limit=20, category=null)
+
Comments powered by Disqus.
HTML에서 폼을 전송하는 방식(Content-Type)에는 다음 두가지가 있다.
application/x-www-form-urlencoded : 문자와 같은 데이터를 키와 함께 전송하는 방식
multipart/form-data : 여러 개의 데이터를 파트별로 나누어 전송하는 방식. 파일과 같은 바이너리 데이터를 전송할 때 쓰임.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
Content-Type: multipart/form-data; boundary=------XXX
+
+------XXX
+Content-Disposition: form-data; name="username"
+
+kim
+------XXX
+Content-Disposition: form-data; name="age"
+
+20
+------XXX
+Content-Disposition: form-data; name="file"; filename="intro.png"
+Content-Type: Image/png
+
+[이미지 바이너리 데이터]
+------XXX--
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
@PostMapping("/upload")
+public String saveFileV1(HttpServletRequest request) throws ServletException, IOException {
+ Collection<Part> parts = request.getParts(); // 멀티파트 데이터 가져오기
+
+ for (Part part : parts) {
+ //데이터 읽기
+ InputStream inputStream = part.getInputStream();
+ String body = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);
+
+ //파일에 저장하기
+ if (StringUtils.hasText(part.getSubmittedFileName())) {
+ String fullPath = fileDir + part.getSubmittedFileName(); // 클라이언트가 전달한 파일명
+ part.write(fullPath); // 주어진 위치에 저장
+ }
+ }
+ return "upload-form";
+}
+
request.getPart()를 통해 멀티파트 데이터를 가져오고, 각 파트별로 part.write() 메서드를 사용하면 인자로 넣은 주소에 저장된다.
하지만 위와 같은 방법은 ` HttpServletRequest`를 인자로 받아와야하며, 파일을 각자 구분하기 위해 여러 코드를 넣어야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
@PostMapping("/upload")
+public String saveFile(@RequestParam String itemName, @RequestParam MultipartFile file) throws IOException {
+
+ if (!file.isEmpty()) {
+ String fullPath = fileDir + file.getOriginalFilename(); // 파일 원제목 가져오기
+ file.transferTo(new File(fullPath)); // 주어진 위치로 파일 저장
+ }
+ return "upload-form";
+}
+
스프링에서는 멀티파트 파일을 저장하기 위핸 MultipartFile를 제공한다. 따라서 매개변수의 이름을 들어올 파일의 이름과 맞춰준다면 자동으로 해당 매개변수에 파일을 넣어준다.
다음과 같이 @ModelAttribute를 사용하여 받을 수도 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
// MultipartFile
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class MultipartTest {
+ private String itemName;
+ private MultipartFile file;
+}
+
1
+2
+
@PostMapping("/upload")
+public String saveFile(@ModelAttribute MultipartTest item) // work
+
<img> 태그로 조회 시 내려주는 방법. UrlResource로 이미지 파일을 읽어서 body에 넣어 반환한다.
1
+2
+3
+4
+5
+
@ResponseBody
+@GetMapping("/images/{filename}")
+public Resource downloadImage(@PathVariable String filename) throws MalformedURLException {
+ return new UrlResource("file:" + fileStore.getFullPath(filename));
+}
+
Content-Disposition 헤더에 attachment; filename="파일 이름" 값을 넣고, UrlResource를 body에 담아 내려준다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
@GetMapping("/attach/{itemId}")
+public ResponseEntity<Resource> downloadAttach(@PathVariable Long itemId) throws MalformedURLException {
+ // db에 저장된 파일 데이터 가져오기.
+ Item item = itemRepository.findById(itemId);
+ String storeFileName = item.getAttachFile().getStoreFileName();
+ String uploadFileName = item.getAttachFile().getUploadFileName();
+
+ UrlResource resource = new UrlResource("file:" + fileStore.getFullPath(storeFileName));
+
+ String encodedUploadFileName = UriUtils.encode(uploadFileName, StandardCharsets.UTF_8);
+
+ return ResponseEntity.ok()
+ .header(HttpHeaders.CONTENT_DISPOSITION,
+ "attachment; filename=\"" + encodedUploadFileName + "\"")
+ .body(resource);
+ }
+
이미지 다운로드 때와 다른 점은 Content-Disposition 헤더가 설정되었다는 점이다.
Content-Disposition은 HTTP response body에 오는 컨텐츠의 기실/성향을 알려주는 속성으로, default 값은 web에 전달되는 data라고 생각하면된다.
특수한 경우는 Content-Disposition에 attachment를 주는 경우로, 이때 filename과 함께 주면 body에 오는 값을 다운로드 받으라는 뜻이 된다.
https://lannstark.tistory.com/8
다음과 같이 application.properties에서 멀티파트 데이터에 관한 설정을 할 수 있다.
1
+2
+3
+4
+5
+6
+
# 한 파일의 최대 용량
+spring.servlet.multipart.max-file-size=5MB
+# 한 multipart 요청의 최대 크기
+spring.servlet.multipart.max-request-size=10MB
+# multipart 처리를 할 것인가. (false 시 멀티파트 데이터를 처리하지 않음)
+spring.servlet.multipart.enabled=true
+
Comments powered by Disqus.
지도 라이브러리로 앱에서는 react-native-maps, 웹에서는 react-native-web-maps 라이브러리를 사용하였는다.
앱에서 사용한 react-native-maps는 높은 완성도를 가지고 있어 활용에 크게 문제는 없었다.
하지만, 웹에서 사용한 react-native-web-maps 은 관리가 되어있지 않은 오래된 라이브러리였기에 몇몇 컴포넌트가 지원이 되지 않는 문제들이 있었다.
이를 해결하기 위해 patch-package를 사용하여 모듈을 수정하여 사용하였다.
Comments powered by Disqus.
사용가능한 IP 주소 범위를 분할하여 사용하는 것
특징
주소할당
서브넷 마스크는 다음과 같음
각 서브넷에서는 다음과 같이 2개의 주소는 예약되어있음
따라서 서브넷에서 사용가능한 주소 범위는, 네트워크 주소와 브로드캐스트 주소를 제외한 나머지 부분이다. 그 나머지 부분은 다음과 같이 구성
즉, 한 서브넷에서 컴퓨터 주소 할당에 사용가능한 주소는 네트워크주소, 브로드캐스트 주소, 라우터 주소를 제외한 나머지 부분이다.
Comments powered by Disqus.
리액트의 작동방식은 상태변화 시, 그 컴포넌트와 하위 컴포넌트를 모두 교체하기에 많은 DOM 변화가 일어난다.
이때 리액트에서는 DOM을 추상화한 객체인 Virtual DOM을 변경하고, 변경이 완료되면 실제 DOM과의 차이점을 확인한다음 한번의 리렌더로 해결한다.
Virtual DOM은 메모리에 존재하여 메모리를 차지한다는 단점이 있다.
리액트도 DOM API를 사용하여 뷰를 변화시키기에, DOM API보다 더 빠르진 않다. Virtual DOM은 리액트를 빠르게 하기 위한 수단.
리액트에서 리스트를 만들 시, key를 사용하라는 안내문이 뜬다.
그 이유는 리스트에 변화가 생겨 리렌더링이 일어날 시, 변화 전후에 key가 같은 요소는 서로 같은 요소로 받아들여 리렌더링에서 제외시키기 때문에 성능적으로 큰 이점이 있다.
따라서 리스트가 고정되어 변경이 일어나지 않는 경우가 아니라면, key를 인덱스로 사용하자 말자
기존에는 함수형 컴포넌트에서 state나 생명주기함수 사용이 불가능했다.
하지만 hook의 등장으로 두가지 모두 함수형 컴포넌트에서도 사용이 가능해졌다.
생명주기 hook으로는 useEffect와 useLayoutEffect가 있다. useEffect는 컴포넌트가 실제 돔에 반영 된 이후 호출되고, useLayoutEffect는 컴포넌트가 실제 돔에 반영되기 직전에 동기적으로 호출된다.
함수형 컴포넌트는 코드가 간결하고, 클래스형에 비해 메모리를 덜 사용한다는 장점이 있다.
CSS는 렌더링을 막고, HTML 파싱도 막을 수 있다. 따라서 최적화가 필요하다.
CSS 사이즈를 줄이고, 꼭 필요한 Critical CSS를 인라인으로 선언하고, non-Critical CSS는 비동기로 불러올 수 있다.
애니메이션을 최적화하기 위해선, 레이아웃을 변경하는 대신 transform을 사용하는 것이 더 빠르다.
composite에 해당하는 transform, opacity를 변경하는 것이 가장 빠르다.will-change를 통해 애니메이션을 적용할 속성을 미리 브라우저에게 알려주어 GPU 가속을 사용할 수 있다.contain 속성으로 어떤 요소와 그 하위요소가 전체 문서트리와 무관하다는 것을 알려주는 방법도 있다.
variable font로 폰트파일 크기를 줄일 수도 있다.
코드의 실제 진행상황을 추적하는데 필요한 정보들을 모아둔 구조. 함수가 호출되면 생성되고 종료되면 사라짐.
실행컨텍스트에는 지역메모리와 실행문이 있음.
실행컨텍스트는 콜스택에 차례대로 쌓임. 자바스크립트 엔진이 현재 실행중인 함수의 실행컨텍스트를 추적하기 위해 쌓는다.
**스코프체인 **: 현재 실행 컨텍스트에서 변수를 찾을 수 없으면, 상위 스코프의 실행컨텍스트로 탐색범위를 옮기는 것
**클로저 ** : 함수가 함수를 반환할때, 반환되는 함수가 선언된 환경의 스코프를 기억한 상태로 반환되는 것. 상위 스코프를 탐색하기 전 클로저를 먼저 확인한다.
자바스크립트 트랜스파일러로, 주로 모던 자바스크립트를 호환성을 위해 예전 문법으로 변환할 때 사용한다.
플러그인과 프리셋으로 설정을 할 수 있다.
하지만 바벨을 사용해도 변환할 수 없는 모던자바스크립트 코드들이 있다.(Promise 등) 이를 변환하기 위해서는 Polyfill을 사용하여야한다. Polyfill은 바벨에서 설정해도 되고, 웹팩에서 설정해도 된다.
How를 감추고, What을 노출하는 방식의 추상화. 명령형 코드에서 리팩토링하여 생성할 수 있다.
명령형 코드를
- what을 적절히 인터페이스에 노출시키고
- How를 내부에 숨기고
- 언제 어디서 불러와도 동일한 결과가 나와서 재사용하기 편하게 추상화한다면
선언적 코드이다.
명령형 코드를 해석할 땐 시간 흐름에 따라 해석해야한다. 하지만 선언적코드는 흐름에 따라 읽지 않아도 되기에, 디버깅에 용이하다. 코드 자체에 어떤 일이 벌어지는지 설명하기 떄문에 추론하기 좋다
또한 언제 불어와도 동일한 결과를 내니, 재사용하기도 좋다.
따라서 CSR을 사용하면 사용자가 첫 화면을 보는 시점이 SSR에 비해 늦어지게 된다. 또한 SEO에도 문제가 있다.
SSR에도 단점이 있다. 첫페이지를 구성한 이후 다른 페이지로 넘어갈 때, CSR에서는 그 다른 페이지를 렌더링하기 위한 코드가 이미 있고 필요한 부분만 다시 렌더링하면 되기에 다른 페이지로 넘어갈 때는 CSR이 더 빠르다. 또 SSR의 경우 매번 서버로 페이지를 요청하기에 서버의 부담이 크다. 이를 해결하기 위해 CSR와 SSR를 결합하는 방식을 채택하여 해결하는 걸로 알고 있다.
Controller
Model
비즈니스 로직을 수행함. 응용프로그램에서 데이터를 처리하는 부분.View
유닛테스트가 무엇인지
소프트웨어의 가장 작은 단위에서, 그 부분이 예상대로 동작하는지 테스트하는 기법이다.
요구사항에 맞는 테스트 코드를 한번 작성해 놓으면, 나중에 리팩토링할 때 테스트를 실행하는 것만으로 정상적으로 동작함을 보장할 수 있기에 두려움 없이 리팩토링을 할 수 있다.
TDD가 무엇인지
테스트를 미리 작성하고 개발을 하는 방법. 실패하는 테스트 코드를 작성하고, 테스트 코드를 성공시키기 위한 실제코드를 작성한 후 리팩토링을 거치는 작업을 반복하는 개발법.
요구사항에 대한 이해도를 높이고, 테스트 코드를 통과하는 코드를 작성함으로써 코드의 정확성을 보장할 수 있다. 또한 리팩토링이 포함되어있기에 코드 품질도 높일 수 있다.
실제 코드의 작성을 마치고 테스트를 하는 것보다 개발 비용을 절감할 수 있고, 개발자의 특성 상 작업이 끝난 코드에 테스트를 붙이는 것을 싫어하기에 미리 테스트를 작성하는 것이 효율적이다.
UI 테스트를 위한 기법에는 무엇이 있는지
실제 DOM에 보여지는 걸 기준으로 테스트하는 기법(react-testing-library)과, 컴포넌트 내부 동작을 테스트(enzyme)하는 기법 두 가지가 있다.
실제 DOM에 보여지는 걸 테스트할 때는, 보여져야 할 텍스트가 제대로 보여지는지 어떤 버튼을 클릭했을 때 적절한 요소가 등장하는지를 본다.
컴포넌트 내부 동작을 확인할 때는, 매개변수와 상태가 적절한지 확인하고, 컴포넌트 내장 메소드를 직접 호출하기도 한다.
Offset Paging : DB의 Limit과 offset을 활용한 방법
장점
단점
Cursor Paging : 유니크하고 순차적인 컬럼을 기준으로 정렬하여 구현하는 방법
장점
단점
무결성 제약조건
DBMS에서 데이터베이스 테이블의 모든 데이터를 검색하여 데이터를 찾는 것은 비효율적이기에, 데이터의 칼럼 값과 그 데이터가 저장된 레코드의 주소를 키와 값의 쌍으로 만든 것
DBMS의 인덱스는 항상 정렬된 상태를 유지하기에 원하는 값을 탐색하는 빠르지만, 추가/삭제/수정에는 느리다.
즉, 데이터베이스의 탐색성능은 높이되 저장성능은 희생시키는 방법. 따라서 모든 컬럼을 대상으로 인덱스를 생성하면 데이터 저장 성능이 크게 저하되어 역효과가 난다.
하나의 논리적인 작업을 수행하는 쿼리문들을 묶어놓은 것. 트랜잭션에 속한 쿼리문들은 모두 완전히 실행되거나 그렇지 않으면 원상복구해야함.
Comments powered by Disqus.
자바스크립트에서 모든 함수는 실행될때마다 함수 내부에 this라는 객체가 추가된다. arguments라는 유사배열 객체와 함께 함수 내부로 암묵적으로 전달되는 것이다. 그렇기 때문에 자바스크립트에서의 this는 함수가 호출된 상황에 따라 그 모습을 달리한다.
객체의 프로퍼티가 함수일 경우 메서드라고 부른다. this는 함수를 실행할 때 함수를 소유하고 있는 객체를 참조한다. 즉, 해당 메서드를 호출한 객체로 바인딩 된다. A.B일때, B함수 내부에서의 this는 A를 가리키는 것이다.
1
+2
+3
+4
+5
+6
+7
+8
+
var myObject = {
+ name: "foo",
+ sayName: function () {
+ console.log(this);
+ },
+};
+myObject.sayName();
+// console> Object {name: "foo", sayName: sayName()}
+
특정 객체의 메서드가 아니라 함수를 호출하면, 해당 함수 내부코드에서 사용된 this는 전역 객체에 바인딩 된다. A.B라고 생각해보면 A가 전역객체가 되므로, B 함수 내부에서의 this는 전역 객체에 바인딩된다. 즉, A에 해당하는 특정 객체가 없다면 B에서의 this는 전역객체에 바인딩된다는 뜻이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
var value = 100;
+var myObj = {
+ value: 1,
+ func1: function () {
+ console.log(`func1's this.value: ${this.value}`);
+
+ var func2 = function () {
+ console.log(`func2's this.value ${this.value}`);
+ };
+ func2();
+ },
+};
+myObj.func1();
+// console> func1's this.value: 1
+// console> func2's this.value: 100
+
new 키워드를 통해 생성자함수를 호출하여 객체를 만들었을때는, new 키워드를 통해 호출된 함수 내부에서의 this는 객체 자신이 된다. 이는 생성자 함수가 동작하는 방식을 통해 이해할 수 있다.
new 연산자를 통해 함수를 생성자로 호출하게 되면, 일단 빈 객체가 생성되고 this가 바인딩된다. 이 객체는 함수를 통해 생성된 객체이며, 자신의 부모인 프로토타입 객체와 연결되어있다. 그리고 return 문이 명시되어있지 않은 경우에는 this로 바인딩 된 새로 생성한 객체가 리턴된다.
1
+2
+3
+4
+5
+6
+7
+
var Person = function (name) {
+ console.log(this);
+ this.name = name;
+};
+
+var foo = new Person("foo"); // Person
+console.log(foo.name); // foo
+
상황 2에서, func2를 호출할때, func1에서의 this를 주입하기 위해서는 위 세가지 메소드를 사용할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
var value = 100;
+var myObj = {
+ value: 1,
+ func1: function () {
+ console.log(`func1's this.value: ${this.value}`);
+
+ var func2 = function (val1, val2) {
+ console.log(`func2's this.value ${this.value} and ${val1} and ${val2}`);
+ }.bind(this, `param1`, `param2`);
+ func2();
+ },
+};
+
+myObj.func1();
+// console> func1's this.value: 1
+// console> func2's this.value: 1 and param1 and param2
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
var value = 100;
+var myObj = {
+ value: 1,
+ func1: function () {
+ console.log(`func1's this.value: ${this.value}`);
+
+ var func2 = function (val1, val2) {
+ console.log(`func2's this.value ${this.value} and ${val1} and ${val2}`);
+ };
+ func2.call(this, `param1`, `param2`);
+ },
+};
+
+myObj.func1();
+// console> func1's this.value: 1
+// console> func2's this.value: 1 and param1 and param2
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
var value = 100;
+var myObj = {
+ value: 1,
+ func1: function () {
+ console.log(`func1's this.value: ${this.value}`);
+
+ var func2 = function (val1, val2) {
+ console.log(`func2's this.value ${this.value} and ${val1} and ${val2}`);
+ };
+ func2.apply(this, [`param1`, `param2`]);
+ },
+};
+
+myObj.func1();
+// console> func1's this.value: 1
+// console> func2's this.value: 1 and param1 and param2
+
https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/JavaScript#this-%EC%97%90-%EB%8C%80%ED%95%B4%EC%84%9C
Comments powered by Disqus.
타입 스크립트 2.8부터 다음과 같은 조건부 타입을 사용할 수 있다.
1
+
T extends U ? X : Y
+
뜻은 T가 U의 서브타입이거나 같은 타입이면 X, 아니면 Y 타입을 할당한다는 것이다.
다음과 같이 T가 유니온 타입일 경우가 있다.
1
+
type T = "A" | "B" | "C"
+
이러한 경우엔 분배법칙이 성립된다.
1
+
{"A" extends U ? X : Y} | {"B" extends U ? X : Y} | {"C" extends U ? X : Y}
+
https://mugglim.tistory.com/13
Comments powered by Disqus.
React 에서 Typescript 사용시 참고할만한 Typing 기법을 기록한 곳
한 Element에 부여될 속성 값들을 모두 참조할때 사용하면 좋다. 다음과 같이 기본 HTML 엘리먼트를 스타일링해서 사용할때 유용함
1
+2
+3
+
export interface ITextButtonProps extends IProps, React.HTMLAttributes<HTMLDivElement> {
+ text?: string | JSX.Element
+}
+
위와 같이, []로 감싸진 부분에 필요한 엘리먼트를 넣으면 된다.
하지만 위 방법이 통하지 않을 경우, 아래와 같이 엘리먼트 별로 구분된 속성을 사용하면 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
const CustomInput = ({ error, ...props }: React.InputHTMLAttributes<HTMLInputElement> & IProps) => {
+ return (
+ <div>
+ <input
+ {...props}}
+ />
+ <label
+ htmlFor={props.id}
+ >
+ {props.placeholder}
+ </label>
+ <div>{error}</div>
+ </div>
+ )
+}
+
onChange나, onSubmit 의 콜백함수에 사용하면 좋다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
// onChange 콜백
+const onChangeText = (e: React.ChangeEvent<HTMLInputElement>) => {
+ setErrorMsg('')
+ setText(e.target.value)
+}
+
+// onSubmit 콜백
+const onClickComplete = (e: React.FormEvent<HTMLFormElement>) => {
+ e.preventDefault()
+ if (text.length === 0) {
+ setErrorMsg('내용을 입력해주세요')
+ return
+ }
+ const res = onClickCompleteCallback(text)
+ if (typeof res === 'string') {
+ setErrorMsg(res)
+ }
+}
+
어떠한 value의 타입을 한 타입으로 강제로 인식 시키는 방법이다.
1
+2
+3
+4
+
const handleResize = (e: UIEvent) => {
+ const w = e.target as Window
+ setScreenSize(calcCurrentScreen(w.innerWidth))
+}
+
사실은 매우 지양해야할 방법이다. 하지만, Typing이 너무 오래 걸려 개발 시간에 지장을 끼칠때 어쩔 수 없이 사용한다.
Axios를 사용한 API 통신시 에러가 발생했을 경우, Axios에서 에러를 감싸서 throw하는데, 이때 이것을 다음과 같이 AxiosError라고 인식시켜서 Typing에 문제 없도록 하는 방법이다.
1
+2
+3
+4
+5
+6
+7
+
if (axios.isAxiosError(err)) {
+ switch (err.response?.data.message) {
+ case [Strings.ErrorMessageFromServer.EXCEED_NONMEMBER_MAX_PLAYLIST]:
+ errorMessage = Strings.ErrorMessageToUser.EXCEED_NONMEMBER_MAX_PLAYLIST
+ break
+ }
+}
+
Wrapper 컴포넌트와 같이 다른 컴포넌트를 감싸는 컴포넌트를 만들었을때, children 값을 받아서 렌더해줘야하는데, 이때 children의 속성은 React.ReactNode이다.
1
+2
+3
+4
+
export default function AppInit({ children }: { children: React.ReactNode }) {
+ ...
+ return <>{children}</>
+}
+
Comments powered by Disqus.
tsconfig.json
compilerOptions:{
“outDir” : “./dist” // 컴파일된 파일 저장. expo 에선 안해도 될듯
}
jsx -> tsx, js -> ts
1
+2
+3
+4
+
let mightBeUndefined: string | undefined = undefined; // string 일수도 있고 undefined 일수도 있음
+let nullableNumber: number | null = null; // number 일수도 있고 null 일수도 있음
+
+let color: "red" | "orange" | "yellow" = "red"; // red, orange, yellow 중 하나임
+
interface, class 사용
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
interface Shape {
+ getArea(): number;
+}
+class Circle implements Shape {
+ radius: number; // private, public 설정으로 외부에서의 접근 제한 가능
+ constructor(radius: number) {
+ this.radius = radius;
+ }
+ getArea() {
+ return this.radius * this.radius * Math.PI;
+ }
+}
+
+const obj: Shape = new Circle(5); // Shape, Circle 모두 타입으로 넣을 수 있음
+
+console.log(obj.getArea());
+
interface extends
1
+2
+3
+4
+5
+6
+7
+8
+9
+
interface Person {
+ name: string;
+ age?: number; // ? 는 있어도 되고 없어도 된다는 뜻.
+ getAge(age: number): number; // 함수는 이렇게 해도 되고
+ getAge: (age: number) => number; // 이렇게 해도 된다.
+}
+interface Developer extends Person {
+ skills: string[];
+}
+
Type alias
1
+2
+3
+4
+5
+6
+7
+
type Person = {
+ name: string;
+ age?: number;
+};
+type Developer = Person & {
+ skills: string[];
+};
+
interface 와 type 모두 객체를 위해 쓸 수 있는데, interface는 클래스를 위해, type은 일반 객체를 위해 쓰는 것이 좋다.
객체 A와 B를 합치는 함수에서 객체 A, B가 무슨 타입일 지 모를때 다음과 같이 any를 사용할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+
function merge(a: any, b: any): any {
+ return {
+ ...a,
+ ...b,
+ };
+}
+
+const merged = merge({ foo: 1 }, { bar: 1 });
+
하지만 위처럼하면 타입 추정을 깨버리기에 다음과 같이 generics를 사용해서 표현할 수도 있다
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
function merge<A, B>(a: A, b: B): A & B {
+ return {
+ ...a,
+ ...b,
+ };
+}
+
+const merged = merge({ foo: 1 }, { bar: 1 });
+/*
+ 좀더 확실히 하기 위해 아래처럼 지정할 수도 있다.
+ const merged = merge<object, object>({foo:1}, {bar:1});
+*/
+
+function wrap<T>(param: T) {
+ return {
+ param,
+ };
+}
+
+const wrapped = wrap(10);
+
interface, type에서도 사용가능하다
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
interface Items<T> {
+ list: T[];
+}
+type Items<T> {
+ list:T[];
+}
+
+const items: Items<string> = {
+ list: ['a', 'b', 'c']
+};
+
class 에서도 비슷한 방식으로 사용하면 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
class Queue<T> {
+ list: T[] = [];
+ get length() {
+ return this.list.length;
+ }
+ enqueue(item: T) {
+ this.list.push(item);
+ }
+ dequeue() {
+ return this.list.shift();
+ }
+}
+
+const queue = new Queue<number>();
+
+queue.enqueue(0);
+console.log(queue.dequeue());
+
합수 타입을 다음처럼 지정하면 됨
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+
type GreetingsProps = {
+ name: string;
+ mark: string;
+ optional?: string;
+ onClick: (name: string) => void; // 아무것도 리턴하지 않는다는 함수를 의미합니다.
+};
+
+function Greetings({ name, mark, optional, onClick }: GreetingsProps) {
+ const handleClick = () => onClick(name);
+ return (
+ <div>
+ Hello, {name} {mark}
+ {optional && <p>{optional}</p>}
+ <div>
+ <button onClick={handleClick}>Click Me</button>
+ </div>
+ </div>
+ );
+}
+
+function App() {
+ const onClick = (name: string) => {
+ console.log(`${name} says hello`);
+ };
+ return <Greetings name="Hello" onClick={onClick} />;
+}
+
useState
1
+
const [count, setCount] = useState<number>(0);
+
1
+2
+
type Information = { name: string; description: string };
+const [info, setInformation] = useState<Information | null>(null);
+
onPress, onChange 등의 객체타입이 뭔지 모를때는, 커서를 onChange 위에 올려두면 무엇인지 알려준다.
Comments powered by Disqus.
typescript 5.0이 나왔다고 하여 간단히 어떤 기능들이 추가되었는지 살펴보았다. 자세한 내용은 Typescript 5.0 번역에서 확인 가능하다.
데코레이터는 재사용 가능한 방식으로 클래스와 그 멤버를 사용자 정의하는 ECMAScript의 기능이다. 데코레이터는 이전부터 지원되었으나 Typescript 5.0부터는 공식 기능으로 지원한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+
function loggedMethod(originalMethod: any, context: ClassMethodDecoratorContext) {
+ const methodName = String(context.name);
+
+ function replacementMethod(this: any, ...args: any[]) {
+ console.log(`LOG: Entering method '${methodName}'.`)
+ const result = originalMethod.call(this, ...args);
+ console.log(`LOG: Exiting method '${methodName}'.`)
+ return result;
+ }
+
+ return replacementMethod;
+}
+
+class Person {
+ name: string;
+ constructor(name: string) {
+ this.name = name;
+ }
+
+ @loggedMethod
+ greet() {
+ console.log(`Hello, my name is ${this.name}.`);
+ }
+}
+
+const p = new Person("Ron");
+p.greet();
+
특정 문자열로 타입을 구성하고 싶을 때, 주로 as const를 사용하였다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
// The type we wanted:
+// readonly ["Alice", "Bob", "Eve"]
+// The type we got:
+// string[]
+const names1 = getNamesExactly({ names: ["Alice", "Bob", "Eve"]});
+
+// Correctly gets what we wanted:
+// readonly ["Alice", "Bob", "Eve"]
+const names2 = getNamesExactly({ names: ["Alice", "Bob", "Eve"]} as const);
+
하지만 이제는 제네릭에 const를 추가하여 비슷한 효과를 얻을 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
type HasNames = { names: readonly string[] };
+function getNamesExactly<const T extends HasNames>(arg: T): T["names"] {
+// ^^^^^
+ return arg.names;
+}
+
+// Inferred type: readonly ["Alice", "Bob", "Eve"]
+// Note: Didn't need to write 'as const' here
+const names = getNamesExactly({ names: ["Alice", "Bob", "Eve"] });
+
typescript 5.0부터는 다음과 같이 tsconfig.json의 extends에서 여러 파일을 작성할 수 있다. 따라서 여러 파일을 확장할 수 있게 된다.
1
+2
+3
+4
+5
+6
+
{
+ "extends": ["a", "b", "c"],
+ "compilerOptions": {
+ // ...
+ }
+}
+
c는 b를 확장하고, b는 a를 확장하는 것과 비슷한 효과를 가진다. 따라서 설정이 충돌되는 경우 후자의 항목이 우선된다.
typescript 2.0에서 enum literal type이 도입되면서 enum은 좀 더 특별해졌다. enum literal type은 각 enum 멤버에 고유한 타입을 부여하고 enum 자체를 각 멤버타입의 union으로 만들었다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
// Color is like a union of Red | Orange | Yellow | Green | Blue | Violet
+enum Color {
+ Red, Orange, Yellow, Green, Blue, /* Indigo */, Violet
+}
+
+// Each enum member has its own type that we can refer to!
+type PrimaryColor = Color.Red | Color.Green | Color.Blue;
+
+function isPrimaryColor(c: Color): c is PrimaryColor {
+ // Narrowing literal types can catch bugs.
+ // TypeScript will error here because
+ // we'll end up comparing 'Color.Red' to 'Color.Green'.
+ // We meant to use ||, but accidentally wrote &&.
+ return c === Color.Red && c === Color.Green && c === Color.Blue;
+}
+
이때 문제는 멤버 타입이 실제 값과 일부 연관되어있다는 것이다. 그래서 멤버가 함수 호출로 초기화되면 값을 계산할 수 없는 경우가 있다.
1
+2
+3
+
enum E {
+ Blah = Math.random()
+}
+
Typescript 5.0 은 계산된 각 멤버에 대해 고유한 타입을 생성하여 모든 enum을 공용체 enum으로 만들 수 있다.
1
+2
+3
+4
+
// typescript 5.0
+const a : E.Blah = 10; // 문제 없음
+// typescript 5.0 미만
+const a : E.Blah = 10; // Enum type 'E' has members with initializers that are not literals.
+
typesciprt 4.7에는 --module, --moduleResolution에 node16, nodenext 옵션을 도입하여 ECMAScript 모듈에 대한 정확한 조회 규칙을 모델링할 수 있게 되었다. 하지만 이는 몇몇 개발자에겐 번거로운 설정이었다.
5.0에서는 compilerOptionsdp moduleResolution에 bundler 옵션을 추가하여 번들러의 동작을 모델링할 수 있다.
1
+2
+3
+4
+5
+6
+
{
+ "compilerOptions": {
+ "target": "esnext",
+ "moduleResolution": "bundler"
+ }
+}
+
하이브리드 조회 전략을 구현하는 Vite, esbuild, swc, Webpack, Parcel 등의 최신 번들러를 사용 중이라면 새로운 bundler옵션이 적합할 것이다. 하지만, 라이브러리 제작자일 경우 bundler 옵션을 사용하면, 번들러를 사용하지 않는 사용자에게 문제가 생길 수 있으니 node16, nodenext 옵션을 추천한다.
.ts, .mts, .tsx와 같이 Typescript 전용 확장자를 사용하여 서로를 import 할 수 있다.node_modules의 패키지를 읽을 경우, package.json의 exports 필드를 참조하도록 한다.#으로 시작하는 조회를 수행할 때, typescript가 package.json의 import 플드를 참조하도록 강제함{파일 기본 이름}.d.{확장자}.ts 형식의 해당 경로에서 타입을 찾는다.package.json의 exports, imports 필드를 Typescript가 리졸브할 때 성공해야하는 추가 조건의 목록을 받는다. 현존하는 조건에 추가된다.
1
+2
+3
+4
+5
+6
+7
+
{
+ "compilerOptions": {
+ "target": "es2022",
+ "moduleResolution": "bundler",
+ "customConditions": ["my-condition"]
+ }
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
{
+ // ...
+ "exports": {
+ ".": {
+ "my-condition": "./foo.mjs",
+ "node": "./bar.mjs",
+ "import": "./baz.mjs",
+ "require": "./biz.mjs"
+ }
+ }
+}
+
위와 같은 경우 exports, imports 필드를 리졸브할 때 항상 my-condition을 고려한다.
기본적으로 Typescript는 import elision을 수행한다. 예를들어 다음과 같이 import를 type을 가져오기만을 위해 사용한다면, 이를 지운다.
1
+2
+3
+4
+5
+
import { Car } from "./car";
+
+export function drive(car: Car) {
+ // ...
+}
+
1
+2
+3
+4
+
// import 문을 지움
+export function drive(car) {
+ // ...
+}
+
type은 값이 아니기에 지우지 않으면 런타임 에러가 날 수 있기 때문이다. 하지만 몇가지 엣지 케이스가 있을 수 있다. 예를들어 변환된 코드는 import ".car"조차 남기지 않는데, 이는 사이드 이펙트를 일으킬 수도 있다.
따라서 Typescript에서는 type 수정자를 사용하도록 하는 --importsNotUsedAsValues, 일부 모듈 엘리션 동작을 방지하는 --perserveValueImports, Typescript가 여러 컴파일러에서 작동하는지 확인하는 --isolatedModules 플래그가 있다. 하지만 이 플래그들은 이해하기 어렵고, 에지 케이스 역시 존재한다.
Typescript 5.0에서는 --verbatimModuleSyntax 를 적용하여 type 수정자가 없는 모든 import, export는 그대로 유지하도록 했다. type 수정자를 사용하는 모든 항목은 완전히 삭제된다.
1
+2
+3
+4
+5
+6
+7
+8
+
// Erased away entirely.
+import type { A } from "a";
+
+// Rewritten to 'import { b } from "bcd";'
+import { b, type c, type d } from "bcd";
+
+// Rewritten to 'import {} from "xyz";'
+import { type xyz } from "xyz";
+
하지만 이 플래그를 사용하면 ECMAScript import와 export는, 다른 모듈 시스템을 암시하는 파일 확장자 또는 세팅이 있을때 require 로 재작성되지 않는다. 대신 오류를 낸다. 만약 require나 module.exports를 사용하는 코드를 emit 하고 싶다면 ES2015 이전의 Typescript 모듈 구문을 사용해야한다.
| Input Typescript | Output Javascript |
|---|---|
import foo = require("foo"); | const foo = require("foo"); |
| function foo() {} function bar() {} function baz() {} export = { foo, bar, baz }; | function foo() {} function bar() {} function baz() {} module.exports = { foo, bar, baz }; |
이는 몇몇 상황에서 도움이 되는데, 예를들어 개발자가 package.json의 --module node16을 설정하지 않은 경우가 있다. 개발자는 인지하지 못한채 ES 모듈 대신 CommonJS 모듈을 작성하기 시작하여 예상치 못한 조회 규칙과 JavaScript 출력을 제공하게 된다. 이 플래그는 구문이 의도적으로 다르기 때문에 사용중인 파일 형식에 대해 의도적으로 확인할 수 있다.
-verbatimModuleSyntax은 --importsNotUsedAsValues 및 --preserveValueImports보다 더 일관된 스토리를 제공하므로, 기존의 두 플래그는 이 구문으로 대체된다.
기존엔 export * from "module"이나 export * as ns from "module" 처럼 re-export가 불가능했다. Typescript 5.0 부터는 가능하다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
// models/vehicles.ts
+export class Spaceship {
+ // ...
+}
+
+// models/index.ts
+export type * as vehicles from "./vehicles";
+
+// main.ts
+import { vehicles } from "./models";
+
+function takeASpaceship(s: vehicles.Spaceship) {
+ // ✅ ok - `vehicles` only used in a type position
+}
+
+function makeASpaceship() {
+ return new vehicles.Spaceship();
+ // ^^^^^^^^
+ // 'vehicles' cannot be used as a value because it was exported using 'export type'.
+}
+
@satisfies Support in JSDocTypescript 4.9에서 satisfies 연산자가 추가됐다. 이 연산자는 타입에 영향을 주지 않고, 표현식이 타입에 호환되는지만 확인한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+
interface CompilerOptions {
+ strict?: boolean;
+ outDir?: string;
+ // ...
+}
+
+interface ConfigSettings {
+ compilerOptions?: CompilerOptions;
+ extends?: string | string[];
+ // ...
+}
+
+let myConfigSettings = {
+ compilerOptions: {
+ strict: true,
+ outDir: "../lib",
+ // ...
+ },
+
+ extends: [
+ "@tsconfig/strictest/tsconfig.json",
+ "../../../tsconfig.base.json"
+ ],
+
+} satisfies ConfigSettings;
+
위 코드에서 Typescript는 myConfigSettings.extends가 배열임을 아는데, 이는 ConfigSettings와 호환 가능한지만 확인하고, myConfigSettings의 타입을 변경하지는 않았기 떄문이다. 따라서 extends에 map 함수를 사용해도 오류가 나지 않는다.
이 satisfies가 JSDoc 태그에 추가되었다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
// @ts-check
+
+/**
+ * @typedef CompilerOptions
+ * @prop {boolean} [strict]
+ * @prop {string} [outDir]
+ */
+
+/**
+ * @satisfies {CompilerOptions}
+ */
+let myCompilerOptions = {
+ outdir: "../lib",
+// ~~~~~~ oops! we meant outDir
+};
+
다음과 같이 /** @satisfies */ 인라인으로 사용하거나, 함수 호출과 같은 곳에서도 사용할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
let myConfigSettings = /** @satisfies {ConfigSettings} */ ({
+ compilerOptions: {
+ strict: true,
+ outDir: "../lib",
+ },
+ extends: [
+ "@tsconfig/strictest/tsconfig.json",
+ "../../../tsconfig.base.json"
+ ],
+});
+
+// 함수 호출에서 사용
+compileCode(/** @satisfies {ConfigSettings} */ ({
+ // ...
+}));
+
@overload Support in JSDocTypescript에서는 함수 오버로드를 만들 수 있다. 이로써 함수를 사용하는 방법을 제한할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
// Our overloads:
+function printValue(str: string): void;
+function printValue(num: number, maxFractionDigits?: number): void;
+
+// Our implementation:
+function printValue(value: string | number, maximumFractionDigits?: number) {
+ if (typeof value === "number") {
+ const formatter = Intl.NumberFormat("en-US", {
+ maximumFractionDigits,
+ });
+ value = formatter.format(value);
+ }
+
+ console.log(value);
+}
+
이러한 오버로드 기능을 @overload 태그를 사용해서 JSDoc 안에서 사용할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+
// @ts-check
+
+/**
+ * @overload
+ * @param {string} value
+ * @return {void}
+ */
+
+/**
+ * @overload
+ * @param {number} value
+ * @param {number} [maximumFractionDigits]
+ * @return {void}
+ */
+
+/**
+ * @param {string | number} value
+ * @param {number} [maximumFractionDigits]
+ */
+function printValue(value, maximumFractionDigits) {
+ if (typeof value === "number") {
+ const formatter = Intl.NumberFormat("en-US", {
+ maximumFractionDigits,
+ });
+ value = formatter.format(value);
+ }
+
+ console.log(value);
+}
+
--build--build 모드에서 다음 플래그가 추가되었다. 빌드 시 커스터마이징을 위해 사용한다.
--declaration—-emitDeclarationOnly—-declarationMap—-sourceMap—-inlineSourceMapVSCode 와 같은 코드에디터에서 TypeScript는 import, export 목록 정렬을 지원한다. 하지만 Typescript는 기본적으로 대소문자를 구분하여 정렬한다. 아스키 문자 인코딩 상 대문자는 소문자 앞이기에 다음 정렬은 Typescript에서 적절하다.
1
+2
+3
+4
+5
+
import {
+ Toggle,
+ freeze,
+ toBoolean,
+} from "./utils";
+
하지만 대소문자를 구분하지 않고 정렬하고 싶을 수도 있다. 이제는 organizeImports 옵션이 추가되어 해당 설정을 할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+
{
+ "typescript.unstable": {
+ // Should sorting be case-sensitive? Can be:
+ // - true
+ // - false
+ // - "auto" (auto-detect)
+ "organizeImportsIgnoreCase": "auto",
+
+ // Should sorting be "ordinal" and use code points or consider Unicode rules? Can be:
+ // - "ordinal"
+ // - "unicode"
+ "organizeImportsCollation": "ordinal",
+
+ // Under `"organizeImportsCollation": "unicode"`,
+ // what is the current locale? Can be:
+ // - [any other locale code]
+ // - "auto" (use the editor's locale)
+ "organizeImportsLocale": "en",
+
+ // Under `"organizeImportsCollation": "unicode"`,
+ // should upper-case letters or lower-case letters come first? Can be:
+ // - false (locale-specific)
+ // - "upper"
+ // - "lower"
+ "organizeImportsCaseFirst": false,
+
+ // Under `"organizeImportsCollation": "unicode"`,
+ // do runs of numbers get compared numerically (i.e. "a1" < "a2" < "a100")? Can be:
+ // - true
+ // - false
+ "organizeImportsNumericCollation": true,
+
+ // Under `"organizeImportsCollation": "unicode"`,
+ // do letters with accent marks/diacritics get sorted distinctly
+ // from their "base" letter (i.e. is é different from e)? Can be
+ // - true
+ // - false
+ "organizeImportsAccentCollation": true
+ },
+ "javascript.unstable": {
+ // same options valid here...
+ },
+}
+
switch/case Completionsswitch 문을 작성할 때 검사 대상에 리터럴 타입이 있는지 감지한다. 감지되면 발견된지 않은 각 대소문자를 스카폴딩하는 완결성을 제공한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
type Fruit =
+ | { kind : "apple" }
+ | { kind : "orange" }
+ | { kind : "banana" }
+
+function nom(fruit: Fruit) {
+ switch(fruit.kind) {
+ case // case 문을 작성하면 자동 완성으로 case "apple": case "orange": case "banana"가 생김
+ }
+}
+
Typescript 5.0에서는 코드 구조, 데이터 구조, 알고리즘 구현을 변경하여 전체 경험을 좀 더 빠르게 만들었다.
Typescript 5.0부터는 ECMAScript 2018을 대상으로 한다. 또한, Typescipt 패키지는 최소 요구 엔진을 12.20으로 설정했다.
lib.d.ts ChangesDOM 유형이 생성되는 방식이 변경되어 기존 코드에 영향을 미칠 수 있다. 특히 특정 property가 숫자에서 숫자 리터럴 타입으로 변환되었다. 잘라내기, 복사, 붙여넣기 이벤트 처리를 위한 프로퍼티와 메서드가 인터페이스 전반으로 이동되었다.
모듈로 전환하고, 불필요한 인터페이스를 제거했으며 일부 정확성을 개선했다.
Typescript의 특정 연산은 암시적으로 문자열을 숫자로 강제 변환할 수 있는 코드를 작성할 경우 경고하고 있다.
1
+2
+3
+
function func(ns: number | string) {
+ return ns * 4; // Error, possible implicit coercion
+}
+
5.0 부터는 관계 연산자 >, <, <=, >= 에도 이 기능이 적용된다. 원하는 경우 +를 사용하여 피연산자를 숫자로 명시적으로 강제할 수 있다.
1
+2
+3
+4
+5
+6
+7
+
function func(ns: number | string) {
+ return ns > 4; // Now also an error
+}
+
+function func(ns: number | string) {
+ return +ns > 4; // OK
+}
+
Enum을 사용할 때 Enum 유형에 도메인 외부 리터럴을 할당하면 오류가 발생하도록 추가됐다.
1
+2
+3
+4
+5
+6
+7
+8
+
enum SomeEvenDigit {
+ Zero = 0,
+ Two = 2,
+ Four = 4
+}
+
+// Now correctly an error
+let m: SomeEvenDigit = 1;
+
또 숫자와 간접 string enum 참조가 혼합되어 선언된 값이 있는 enum에서 오류를 제대로 생성하도록 변경됐다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
enum Letters {
+ A = "a"
+}
+enum Numbers {
+ one = 1,
+ two = Letters.A
+}
+
+// Now correctly an error
+const t: number = Numbers.two;
+
--experimentalDecoratorsdecorator에 대한 좀 더 정확한 type-checking이 되도록 하는 옵션이 추가되었다. 특히 생성자 파라미터에서 사용할 때 효과적이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
export declare const inject:
+ (entity: any) =>
+ (target: object, key: string | symbol, index?: number) => void;
+
+export class Foo {}
+
+export class C {
+ constructor(@inject(Foo) private x: any) {
+ }
+}
+
key가 string | symbol을 예상하기에 이 호출은 실패하지만 생성자 파라미터는 undefined키를 받는다. 올바른 수정은 inject의 key의 타입을 변경하는 것이다. 만약 변경할 수 없는 라이브러리를 사용중인 경우에는 inject를 좀 더 type-safe한 decorator로 감싸고 key에 type assertion을 사용하는 것이다.
이제 다음 설정값들은 사용되지 않는다.
--target: ES3--out--noImplicitUseStrict--keyofStringsOnly--suppressExcessPropertyErrors--suppressImplicitAnyIndexErrors--noStrictGenericChecks--charset--importsNotUsedAsValues--preserveValueImportsprepend in project referencesTypescript 5.5까지는 허용하지만 이후로는 경고가 발생한다. 단, "ignoreDeperecations": "5.0"을 사용하면 경고를 없앨 수 있다.
프로젝트 내에서 동일한 파일 이름을 참조하는 모든 참조가 케이스에 대해 동의하도록 보장하는 --forceConsistentCasingInFileNames는 이제 true로 기본 설정된다.
https://velog.io/@hustle-dev/TypeScript-5.0-%EB%B2%88%EC%97%AD#%EB%8D%B0%EC%BD%94%EB%A0%88%EC%9D%B4%ED%84%B0
https://devblogs.microsoft.com/typescript/announcing-typescript-5-0/#moduleresolution-bundler
Comments powered by Disqus.
useEffect를 사용하면 안된다.
props, state가 변경이 되면 리렌더링이 발생하는데, 리렌더링이 끝난 후 useEffect가 호출되어 다시 리렌더링이 발생하기 때문이다.
따라서 다음과 같이 코드를 변경해야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
// useEffect로 업데이트
+function TodoList({ todos, filter }) {
+ const [newTodo, setNewTodo] = useState('');
+
+ // Avoid: redundant state and unnecessary Effect
+ const [visibleTodos, setVisibleTodos] = useState([]);
+ useEffect(() => {
+ setVisibleTodos(getFilteredTodos(todos, filter));
+ }, [todos, filter]);
+
+ // ...
+}
+
1
+2
+3
+4
+5
+6
+7
+
// useEffect 사용하지 않음
+function TodoList({ todos, filter }) {
+ const [newTodo, setNewTodo] = useState('');
+ // This is fine if getFilteredTodos() is not slow.
+ const visibleTodos = getFilteredTodos(todos, filter);
+ // ...
+}
+
컴포넌트가 리렌더링할때마다 컴포넌트의 코드가 위에서부터 다시한번씩 실행되며 getFilteredTodos()도 다시 호출되기 때문에, 최신값으로 업데이트 된다.
만약 getFilteredTodos()가 비싼 연산이라면 useMemo()를 통해 최적화를 하자
1
+2
+3
+4
+5
+6
+7
+8
+
import { useMemo, useState } from 'react';
+
+function TodoList({ todos, filter }) {
+ const [newTodo, setNewTodo] = useState('');
+ // Does not re-run getFilteredTodos() unless todos or filter change
+ const visibleTodos = useMemo(() => getFilteredTodos(todos, filter), [todos, filter]);
+ // ...
+}
+
유저 변경에 따라 comment 상태를 초기화해야하는 경우
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
// useEffect 사용
+export default function ProfilePage({ userId }) {
+ const [comment, setComment] = useState('');
+
+ // 🔴 Avoid: Resetting state on prop change in an Effect
+ useEffect(() => {
+ setComment('');
+ }, [userId]);
+ // ...
+}
+
userId 변경 –> 리렌더링 –> comment 변경 –> 리렌더링. 총 2번 리렌더링이 발생한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+
// 리팩토링
+export default function ProfilePage({ userId }) {
+ return (
+ <Profile
+ userId={userId}
+ key={userId}
+ />
+ );
+}
+
+function Profile({ userId }) {
+ // ✅ This and any other state below will reset on key change automatically
+ const [comment, setComment] = useState('');
+ // ...
+}
+
key값을 사용하여, userId가 변경될때마다 Profile 컴포넌트를 초기상태에서 가져오도록 한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
// useEffect 사용
+function List({ items }) {
+ const [isReverse, setIsReverse] = useState(false);
+ const [selection, setSelection] = useState(null);
+
+ // 🔴 Avoid: Adjusting state on prop change in an Effect
+ useEffect(() => {
+ setSelection(null);
+ }, [items]);
+ // ...
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
function List({ items }) {
+ const [isReverse, setIsReverse] = useState(false);
+ const [selection, setSelection] = useState(null);
+
+ // Better: Adjust the state while rendering
+ const [prevItems, setPrevItems] = useState(items);
+ if (items !== prevItems) {
+ setPrevItems(items);
+ setSelection(null);
+ }
+ // ...
+}
+
items의 이전상태를 담는 상태를 생성하여 리렌더링을 하나로 줄였음.
쇼핑몰에서 카트에 물건을 넣었을 때 모달을 통해 정상적으로 물품을 담았는지 유저에게 노티피케이션을 알려줘야한다.
다음은 useEffect를 사용한 예시다. product가 카트에 추가되면, isInCart 상태가 true가 되어 useEffect에 등록한 콜백이 호출되고, Notification이 뜨는 방식이다.
모달을 보여줘야하는 버튼이 여러개이면 일일히 각 핸들러에 showNotification 콜백을 붙이는 것보다 useEffect에 넣는게 바람직하다고 착각할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
function ProductPage({ product, addToCart }) {
+ // 🔴 Avoid: Event-specific logic inside an Effect
+ useEffect(() => {
+ if (product.isInCart) {
+ showNotification(`Added ${product.name} to the shopping cart!`);
+ }
+ }, [product]);
+
+ function handleBuyClick() {
+ addToCart(product);
+ }
+
+ function handleCheckoutClick() {
+ addToCart(product);
+ navigateTo('/checkout');
+ }
+ // ...
+}
+
하지만 아니다.
페이지 전환 시 전역상태 값인 product.isInCart가 true면 예상하지 못한 버그가 생길 수 있기 때문이다.
또 유저는 상태가 변경되었을 때가 아닌, 버튼을 눌렀을 때 Notification이 뜨기를 기대할 것이다.
우리의 코드가 상태를 변경했을 때 작동하는 것이 의도인지, 유저의 이벤트에 따라 UI를 변경하는 것이 주 목적인지 생각해볼때, 버그를 양산할 수 있는 useEffect보다 이벤트 핸들러 내부에서 Notification을 호출하는 것이 바람직하다.
useEffect, eventHandler 둘 중 어디에 코드를 작성해야할지 모르겠다면, 코드가 언제 실행되어야하는지 생각해봐라. useEffect는 컴포넌트가 렌더링 되는 시점에 유저에게 표현되어야할 로직을 실행할 때 사용한다.
data fetching은 해도 된다. 하지만 race condition을 고려해야한다.
리액트18 strict mode에서 컴포넌트 렌더링 시 useEffect 내부에서 ajax가 일어난다면, 렌더 -> fetch -> 리렌더 - refetch가 일어난다.
이는 api 서버 비용이 두 배로 든다는 점만 감안하면 괜찮다. 사용자는 fetch/refetch간 동일한 데이터가 응답된다면 UI에 변경점을 느끼지 못하기 때문이다.
하지만 특정 상태나 Props 변경에 따라 뷰가 바뀌는 경우라면 어떨까?
다음의 코드는 userId가 변경될 때마다 startFetching이 호출된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
useEffect(() => {
+ let ignore = false;
+
+ async function startFetching() {
+ const json = await fetchTodos(userId);
+ if (!ignore) {
+ setTodos(json);
+ }
+ }
+
+ startFetching();
+
+ return () => {
+ ignore = true;
+ };
+}, [userId]);
+
컴포넌트가 언마운트 되었을 때는 ignore를 true로 만들어, 클로져를 사용하는 startFetching내부에서 setTodos는 언마운트 이후에도 호출되지 않는다.
하지만 이러한 로직을 매번 따로 작성해야하는 문제점이 남아있다.
한 페이지에서 특정 id값을 기준으로 모달같은 공통 ui를 그려주는 경우에는 위의 로직이 도움이 되지 않는다.
다음처럼 sartFetching이 테이블 컴포넌트에 있는 open modal을 누를때마다 호출된다고 가정해보자.
id 3의 open modal --> close modal --> id 4의 open modal 과 같은 시나리오에서, id 4가 먼저 응답이 올지, id 3가 먼저 응답이 올지 알수가 없다.
이러한 문제를 race condition이라고 한다. useEffect 에서 setState를 호출하는 것만으로는 이러한 상황을 방지할 순 없다. 특별한 조치를 취해야 막을 수 있다. (서버에서 온 id와 props으로 온 id가 일치하는지 확인, AbortController 등)
서버자원이 동나지 않도록 조심해야한다.
어떤 버그상황에도 대비할 수 있게 useEffect를 써야하고, dependencies의 상태 변경이 예측할 수 있는 속도로 변경되는 것을 보장할 수 있어야한다.
하지만 어려운 일이다.
따라서 동일한 api로 호출하는 경우 이전에 받아온 데이터를 재사용하는 방법으로 해결할 수 있다. 바로 캐시를 이용하는 방법이다. 이 캐시를 이용하기 위해 react-query, swr 등 data fetch 라이브러리를 사용할 수 있다.
https://velog.io/@jay/you-might-need-useEffect-diet
Comments powered by Disqus.
https://velog.io/@eunbinn/when-does-react-render-your-component
Comments powered by Disqus.
다음과 같은 요구사항을 가지는 웹페이지를 개발하고 있었다.
단순히 swiper를 연동하고 video 태그에 autoplay 속성을 주면 될거라 생각하여 다음과 같이 코드를 작성했었다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+
<li className="swiper-slide">
+ <video
+ poster="poster 주소"
+ autoPlay muted playsInline loop>
+ <source
+ src="영상주소"
+ type="video/mp4"/>
+ </video>
+</li>
+<li className="swiper-slide">
+ <video
+ poster="poster 주소"
+ autoPlay muted playsInline loop>
+ <source
+ src="영상주소"
+ type="video/mp4"/>
+ </video>
+</li>
+...
+
실제로 당시 개발 환경(mac, chrome)에서는 문제없이 동작했었다. 하지만 QA 단계에서 영상이 재생되지 않으며 사이트 자체가 매우 느리다는 제보를 받았다. 그리고 이 문제를 해결한 과정은 다음과 같다.
swiper에서 loop 옵션을 사용하고 있었다. 끝까지 가면 다시 처음 슬라이드가 나오도록 하기 위해서였다. 하지만, loop 옵션을 사용하면 다음과 같이 실제로 보여질 swiper-slide 앞 뒤로 swiper-slide-duplicate를 생성한다. 그리고 각 swiper-slide-duplicate는 slide-swiper와 구성이 같다.
즉, 필요한 슬라이드 개수의 3배 정도 슬라이드가 만들어지고, 각 슬라이드 안에는 영상이 포함되어있다는 것이다. 이처럼 많은 영상을 한번에 재생하는 것은 사이트 성능에 악영향을 줄거라 생각했다. 따라서 다음과 같이 swiper에 옵션을 주어 swiper-slide-duplicate 안에 있는 비디오의 재생은 멈추었다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+
new Swiper('.myswiper1', {
+ touchRatio: 0,
+ autoHeight: true,
+ speed: 650,
+ observer: true,
+ observeParents: true,
+ slidesPerView: 'auto',
+ loop:true,
+ navigation: {
+ nextEl: '.swiper-button-next',
+ prevEl: '.swiper-button-prev',
+ },
+ on: {
+ slideChangeTransitionEnd : function() {
+ $('.myswiper1 .swiper-slide.swiper-slide-duplicate')
+ .find(".video_box video")?
+ .each(function(idx, item) {
+ item.pause();
+ })
+ },
+ },
+ });
+
하지만 이렇게 하니 마지막 -> 첫번쨰, 첫번쨰 -> 마지막으로 갈때 이동한 후 슬라이드의 영상이 재생되지 않는 것을 발견했다. 그 이유는 앞 두 경우에는 swiper-slide-duplicate가 화면에 보이는 경우였기 떄문이다. 다음 사진을 보면 swiper-slide-active가 swiper-slide-duplicate에 붙은 걸 확인할 수 있다.
따라서 다음과 같이 이벤트를 수정하여 swiper-slide-active가 붙은건 명시적으로 실행해주어 문제를 해결했다.
new Swiper('.myswiper', {
+ touchRatio: 0,
+ autoHeight: true,
+ speed: 650,
+ observer: true,
+ observeParents: true,
+ slidesPerView: 'auto',
+ loop:true,
+ navigation: {
+ nextEl: '.swiper-button-next',
+ prevEl: '.swiper-button-prev',
+ },
+ on: {
+ slideChangeTransitionEnd : function() {
+ $('.myswiper .swiper-slide.swiper-slide-duplicate')
+ .find(".video_box video")?
+ .each(function(idx, item) {
+ item.pause();
+ })
+ $('.myswiper .swiper-slide.swiper-slide-active')
+ .find(".video_box video")?
+ .each(function(idx, item) {
+ item.play()
+ });
+ },
+ },
+ });
+이렇게 꼭 필요한 영상들만 자동재생을 적용하니 사이트가 빨라졌다는 답변을 받을 수 있었다.
위에서 슬라이드가 복사되는 것을 보고 영상이 너무 많아서 사이트가 느려지고 자동재생이 안되는게 아닐까라는 생각이 들었다. 따라서 영상 자체를 최적화하였다.
위 세가지 작업을 진행하니 영상 사이즈를 90%정도 줄일 수 있었다.
그리고 사이트가 빨라졌으며 자동재생이 안되는 문제도 크게 개선되었다는 답변이 왔다.
하지만 여전히 자동재생은 가끔씩 안되고 있다는 애기를 들었다.
최종 수단으로 chatGPT에게 물어보니 다음과 같은 코드를 실행해보라는 답변을 받았다. 간헐적으로 영상이 자동 재생이 안되면 네트워크 이슈를 비롯하여 다양한 이슈가 있을 수 있으므로 수동으로도 영상을 실행해보라는 얘기였다.
1
+2
+3
+4
+5
+6
+7
+8
+
function playVideo() {
+ var videos = document.querySelectorAll('video');
+ for (var i = 0; i < videos.length; i++) {
+ videos[i].play();
+ }
+}
+playVideo();
+window.addEventListener('load', playVideo);
+
실제로 적용해보니 영상이 제대로 재생되었다..
Comments powered by Disqus.
다른 테이블을 기반으로 만들어진 가상 테이블. 논리적으로만 존재하는 테이블.
장점
특징
CREATE VIEW 뷰_이름[(속성_리스트)] AS SELECT 문 [WITH CHECK OPTION]
DROP VIEW 뷰_이름
Comments powered by Disqus.
Virtual DOM은 DOM을 추상화한 가상의 객체이다.
HTML 문서를 파싱하여 문서의 구성요소들을 객체로 구조화하여 나타낸 것.
HTML Elements, 속성, CSS style, Events, Methods 를 구조화해서 나타낸 객체고, 이 객체를 이용해서 웹페이지 구성요소를 제어할 수 있다.
Virtual DOM은 이러한 DOM을 추상화한 가상의 객체이다.
React 작동 방식은 상태가 변경된 컴포넌트는 그 컴포넌트부터 자식 컴포넌트까지 리렌더링한다. 하지만 이런 식의 교체는 많은 PC자원을 소모하게 된다. 이는 브라우저의 렌더링 방식 때문이다.
만약 변경해야할 사항이 100개라면, 100번 위와 같은 과정을 반복하게 된다.
Virtual DOM이라는 DOM을 추상화한 가상의 객체를 메모리에 만들어 놓고, DOM과 유사한 역할을 담당하게 한다.
만약 변경사항이 발생할 경우, DOM을 직접 수정하는 것이 아니라 중간단계로 Virtual DOM을 수정하고 Virtual DOM을 통해서 DOM을 수정하게 한다. 이를 통해 Virtual DOM에 변경내역을 한 번에 모아서(버퍼링) 실제 DOM과 변경된 Virtual DOM의 차이를 판단한 후, 구성요소의 변경이 필요한 부분만 찾아 그에 따른 렌더링을 한번만 하도록 하여 해결하였다.
즉, 리액트에서 상태변화가 발생했을 경우 교체해야할 컴포넌트를 먼저 Virtual DOM에서 교체한다음 실제 DOM과 비교하여 rerender 해야할 부분만 rerender한다는 뜻이다.
리액트에서 가상돔을 실제 DOM에 반영하는 과정을 재조정이라고 한다. 위 리렌더링 과정의 렌더에 해당한다. 이때 하나의 트리를 다른 트리로 변환하기 위한 최소한의 연산 수는 노드가 n일때 O(n^3)이다.
이는 매우 느리기에 리액트에서는 실제 DOM과 가상 DOM을 비교하기 위해 diffing 알고리즘을 사용한다. 리액트는 아래의 2가지 가정을 기반으로 O(n) 시간 복잡도를 가지는 휴리스틱 알고리즘을 구현하였다.
좀 더 자세히, 리액트에서 두 개의 트리를 비교할 때 두 엘리먼트의 루트 엘리먼트부터 비교한다. 이후의 동작은 루트 엘리먼트의 타입에 따라 달라진다.
<a> 에서 <img>로, <Article>에서 <Comment>로 바뀌는 경우를 말한다.componentWillUnmount()를 실행한다. 새로운 트리가 만들어질 떄 새로운 DOM 노드들이 DOM에 삽입된다. 그에 따라 컴포넌트 인스턴스는 UNSAFE_componentWillMount()가 실행되고 componentDidMount()가 실행된다. 이전 트리와 연관된 모든 state는 사라진다.style= -> style=일때, fontWeight는 건들지 않고, color만 수정한다.componentDidUpdate를 호출한다.이후 render() 메서드가 호출되고 diffing 알고리즘은 재귀적으로 자식에 대해 처리한다. 리액트는 기본적으로 동시에 두 리스트를 순회하고 차이점이 있으면 변경을 생성한다.
예를 들어 리스트 끝에 엘리먼트를 추가하면 두 트리 사이의 변경은 잘 작동한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
<ul>
+ <li>first</li>
+ <li>second</li>
+</ul>
+
+<ul>
+ <li>first</li>
+ <li>second</li>
+ <li>third</li>
+</ul>
+
하지만 리스트의 맨 앞에 엘리먼트를 추가하면 성능은 좋지 않다. 모든 엘리먼트를 다시 생성하기 때문이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
<ul>
+ <li>Duke</li>
+ <li>Villanova</li>
+</ul>
+
+<ul>
+ <li>Connecticut</li>
+ <li>Duke</li>
+ <li>Villanova</li>
+</ul>
+
이러한 문제를 해결하기 위해 리액트는 key 속성을 제공한다. 자식들이 같은 key를 가지고 있으면 React는 key를 통해 기존 트리와 이후 트리의 자식들이 일치하는지 확인한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
<ul>
+ <li key="2015">Duke</li>
+ <li key="2016">Villanova</li>
+</ul>
+
+<ul>
+ <li key="2014">Connecticut</li>
+ <li key="2015">Duke</li>
+ <li key="2016">Villanova</li>
+</ul>
+
리액트는 이제 2014 key를 가진 엘리먼트가 추가되었고, 2015, 2016 key를 가진 엘리먼트는 그저 이동만 하면 되는 것을 알 수 있다. 이때 사용하는 key는 형제들 사이에서 유일하면 된다.
최후의 경우 배열의 인덱스를 key로 사용할 수 있다. 하지만 이 경우 배열이 재배열되면 컴포넌트의 state가 꼬일 수 있다. 컴포넌트 인스턴스는 key를 기반으로 갱신되고 재사용되기 때문에, 인덱스를 key로 사용하면 항목의 순서가 바뀌었을 때 key 또한 바뀌기 때문이다. 예시 개선된 예시
https://jeong-pro.tistory.com/210
https://stackoverflow.com/questions/61245695/how-exactly-is-reacts-virtual-dom-faster
https://narup.tistory.com/272
Comments powered by Disqus.
웹 컨테이너 혹은 서블릿 컨테이너 라고도 불린다.역할
주요 기능
기능
즉, 자원 이용의 효율성 및 장애극복, 배포 및 유지보수의 편의성을 위해 WAS와 웹서버를 분리한다.
protected doGet(HttpServletRequest request, HttpServletResponse response)node.js의 경우 엄밀히 말하면 런타임이지 웹 서버는 아니다. 웹서버를 가진 런타임이라고 보는 것이 타당하다.
기능으로는 정정파일 제공, WAS 기능 모두 수행한다.
https://gmlwjd9405.github.io/2018/10/27/webserver-vs-was.html
Comments powered by Disqus.
CORS : Cross-Origin Resource Sharing(교차 출처 리소스 공유)
서로 다른 출처(Origin)에서 리소스를 공유할 때 적용되는 정책이다.
출처(Origin)이란?
URL은 다음과 같이 여러 개의 구성요소로 이루어져있다.
여기서 출처란 protocol + host + port 을 뜻한다. 이 조합이 같아야 같은 출처로 인정된다.
이때
http,https는 각각80443포트로 추정되어 생략되어도 된다하지만 만약
http://google.com:80같이 포트 번호가 명시되어있다면 포트번호까지 모두 일치해야 같은 출처라고 인정된다.
SOP(Same-Origin Policy)
같은 출처에서만 리소스를 공유할 수 있다는 규칙을 가지며, CORS와 함께 다른 출처로 리소스를 공유할때 적용되는 또다른 정책이다.
하지만 웹은 다른 출처에서 리소스를 가져오는 일이 매우 많기에 몇가지 예외조항을 두었고, 그 중 하나가 “CORS 정책을 지킨 리소스 요청”이다. 따라서 웹에서 다른 출처로 리소스를 요청할 때는 CORS 정책을 지키든가 몇가지 SOP의 예외사항을 지켜야한다.
예외사항 : 실행 가능한 스크립트, 렌더될 이미지, 스타일 시트을 요청하는 경우
CORS 동작원리
웹 클라이언트 어플리케이션에서 다른 출처로 리소스 요청을 할 때, 브라우저는 요청헤더에 다음과 같이 Origin 필드에 출처를 담아 보낸다.
Origin : https://google.com
서버는 이 요청에 대한 응답을 할 때, 응답 헤더에 Access-Control-Allow-Origin이라는 값에 이 리소스를 접근하는 것이 허용된 출처를 내려준다
응답을 받은 브라우저는 자신이 보냈던 요청의 Origin 과 응답의 Access-Control-Allow-Origin를 비교해본 후 이 응답이 유효한지 확인한다.
CORS 정책 로직의 위치
CORS 정책이 적용되어 출처를 비교하는 로직은, 서버가 아니라 브라우저에 구현되어있다.
만약 우리가 CORS 정책을 위반하는 리소스 요청을 하더라도 해당 서버가 같은 출처에서 보낸 요청만 받겠다는 로직을 가지고 있지 않으면 서버는 정상적으로 응답하고, 브라우저가 이 응답을 분석해서 CORS 정책 위반이라고 판단되면 그 응답을 버린다.
따라서 CORS 정책은 브라우저를 통하지 않은 서버간 통신일 때는 적용되지 않는다. 또한 CORS 정책을 위반하는 리소스 요청 때문에 에러가 발생했다고 해도 서버쪽 로그에는 정상적으로 응답을 했다는 로그만 남는다.
Preflight Request
브라우저에서 요청을 보낼 때 한번에 보내지 않고, 예비요청(Preflight Request)과 본 요청으로 나누어서 보낸다. 이 Preflight는 HTTP 메소드 중 OPTIONS 메소드가 사용된다.
이렇게 나누어서 보내는 이유는, 본 요청을 보내기 전에 브라우저 스스로 이 요청을 보내는 것이 안전한지 확인하기 위함이다.
과정
다만 모든 상황에서 이렇게 두 번씩 요청을 보내진 않는다. 이러한 예비요청을 보내지 않는 요청을 Simple Request 라고 한다.
Simple Request
Simple Request를 보낼 때는, 예비 요청을 보내지 않고 바로 서버에게 본 요청을 보낸 후, 서버의 응답 헤더에 Access-Control-Allow-Origin를 확인하여 CORS 정책을 검사하는 방식으로 이루어진다.
Simple Request 조건
GET, HEAD, POST 중 하나여야 한다.Accept, Accept-Language, Content-Language, Content-Type, DPR, Downlink, Save-Data, Viewport-Width, Width를 제외한 헤더를 사용하면 안된다.Content-Type를 사용하는 경우에는 application/x-www-form-urlencoded, multipart/form-data, text/plain만 허용된다.Credentialed Request
쿠키나 인증정보가 헤더에 담긴 요청을 뜻하며, 이 경우에는 CORS 정책 위반을 검사하는 룰에 다음 두가지가 추가된다.
Access-Control-Allow-Origin에는 *를 사용할 수 없으며, 명시적인 URL이어야한다.Access-Control-Allow-Credentials: true가 존재해야한다.CORS를 해결하기 위해 개발 시 지켜야하는 상황
기본적으로 정책을 다 지키면 되지만, 아래 사항을 개발할 때 항상 생각하고 진행하자
Access-Control-Allow-Origin에 항상 명시적으로 세팅하자쿠키의 samesite vs CORS
samesite 옵션은 같은 도메인인지를 판단하는 것이고, CORS 정책은 도메인을 포함한 포트, 프로토콜을 모두 검사하는 정책이다. 둘은 무관계하다.
samesite의 경우 서브도메인도 같은 도메인으로 판별해준다. 다만 모든 서브도메인을 같다고 판별하지는 않고, Public Suffix Lists에 명시된 기준을 참고하여 어느 범위까지 동일할 때 same site로 판단할지를 결정한다.
.co.kr 같이 세번째 자리부터 등록이 가능한 경우는 kr 앞에 co가 이미 추가되어있어서 same-site의 범위가 너무 넓어진다.
Comments powered by Disqus.
HTTP Response Body에 오는 컨텐츠의 기질/성향을 알려주는 HTTP 헤더 속성이다.
inline : 디폴트 값. body에 있는 값이 웹 페이지에 표시되어야한다는 뜻.
Content-Disposition : inline
download 속성은 Content-Disposition : inline으로 가져온다.attachment : body에 있는 데이터를 다운 받아야한다는 뜻. filename이 명시되어있다면, 해당 filename으로 다운 받는다.
Content-Disposition : attachment
Content-Disposition : attachment; filename="filename.jpg"
form-data : body가 multipart/form-datwa일 경우 적용된다. 데이터가 여러 파트로 나눠져서 보내지도록 해줌. 다음과 같이 name으로 나눠진 필드를 나타낸다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
POST /test.html HTTP/1.1
+Host: example.org
+Content-Type: multipart/form-data;boundary="boundary"
+
+--boundary
+Content-Disposition: form-data; name="field1"
+
+value1
+--boundary
+Content-Disposition: form-data; name="field2"; filename="example.txt"
+
+value2
+--boundary--
+
_charset_ 이면 해당 part가 HTML 필드가 아니라, 디폴트 charset을 사용하겠다는 것을 의미한다.https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition
https://lannstark.tistory.com/8
Comments powered by Disqus.
웹사이트를 만들 때는 반드시 컨텐츠(데이터)가 필요하다. Headless CMS는 컨텐츠를 보여줄 수단인 Head와 컨텐츠를 분리한 구조로, 컨텐츠가 Head에 독립적으로 동작할 수 있도록 하는 구조이다.
기존의 CMS는 컨텐츠와 Head가 강하게 묶여있었다. Html에 하드코딩된 문자열들을 생각하면 된다.
1
+2
+3
+4
+
<!-- 기존의 CMS -->
+<div>
+ content
+</div>
+
이렇게하면 구현은 매우 간단하지만, html과 문자열이 하나의 파일로 강하게 결합되어있다.
이때 이러한 html이 배포된 상황이라고 해보자. 시간이 흘러 문자열을 수정하고 싶을 때가 온다. 그럼 이 html 파일을 직접 수정하고, 다시 배포하는 과정을 거쳐야한다. 단순히 html 파일 하나만 배포하면 되는 상황이면 큰 문제는 되지않는다. 하지만, 시스템이 복잡해지고 배포과정이 복잡해지면 배포작업은 큰 부담이 된다. 리얼환경 반영까지 오랜 시간이 걸리수도 있다.
하지만 다음과 같이 Headless CMS로 구현하면 상황은 다르다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
<!-- Headless CMS -->
+<div id="content">
+ <!-- content가 삽입될 곳 -->
+</div>
+<script>
+ const contentDiv = document.getElementById("content")
+ fetch("/path-to-api").then((res) => {
+ contentDib.innerText = res.content;
+ })
+</script>
+
데이터베이스, 스토리지 등에 저장된 컨텐츠를 가져와 적절한 위치에 삽입해줌으로써 배포과정없이 변경된 컨텐츠를 반영할 수 있다. 새로운 문자열을 그저 데이터베이스나 스토리지에서 업데이트하면 되기 때문이다.
물론 코드는 복잡해지고, 네트워크 비용이 발생한다는 단점이 있다. 하지만, 자주 변경될 것이라 예상되는 컨텐츠에만 Headless CMS 방식을 적용하면 배포횟수가 줄어들고 결과적으로 개발자는 다른 일에 집중할 수 있게 된다. 또한 수정이 반영되는 속도도 매우 빠르다.
여기서는 배포횟수와 반영속도만을 가지고 장점을 얘기했지만 다음과 같은 장점들도 존재한다.
Comments powered by Disqus.
웹소켓 위에서 동작하는 서브 프로토콜로, 클라이언트와 서버가 서로 통신하는데 있어 메시지의 형식, 유형, 내용 등을 정의해주는 프로토콜이다.
웹 소켓 프로토콜은 Text 또는 binary 두가지 유형의 메시지 타입을 정의하지만 메시지의 내용에 대해서는 정의하지 않는다. 즉, 웹 소켓만 사용해서 구현하게 되면 해당 메시지가 어떤 요청인지, 어떤 포맷으로 오는지 정해져있지 않아 일일이 구현해야한다.
이때 STOMP라는 프로토콜을 서브 프로토콜로 사용하여, 단순한 binary, text가 아니라 규격을 갖춘 메시지를 보낼 수 있다.
또한 기본적으로 pub/sub 구조로 되어있어 메시지를 전송하고 메시지를 받아 처리하는 부분이 확실히 정해져 있기 때문에 개발자 입장에서 명확하게 인지하고 개발할 수 있는 이점이 있다.
STOMP를 이용하면 메세지의 헤더에 값을 줄 수 있어 헤더 값을 기반으로 통신시 인증 처리를 구현하는 것도 가능하며, STMOP 스펙에 정의한 규칙만 잘 지키면 여러 언어 및 플랫폼간 메시지를 상호 운영할 수 있다.
스프링은 spring-websocket 모듈을 통해서 STOMP를 제공하고 있다.
STOMP는 HTTP에서 모델링되는 Frame 기반 프로토콜이다. Frame은 몇 개의 Test line으로 지정된 구조인데 첫번째 라인은 Text이고, 이후 Key:Value 형태로 Header의 정보를 포함한다. 그 다음 빈 라인을 추가하고 Payload가 존재한다.
아래 형식을 보면 HTTP와 유사하다는 것을 알 수 있다.
1
+2
+3
+4
+5
+
COMMAND
+header1:value1
+header2:value2
+
+Body^@
+
COMMAND
header, value
메시지의 수신 대상과 메시지에 대한 정보를 설명한다.
기존 웹소켓만으로는 표현할 수 없는 형식이다.
destination : 헤더 중 하나로, 이 헤더로 지정한 주소로 메세지를 보내거나 구독할 수 있다.
destination은 의도적으로 정보를 불분명하게 정의하였는데, 이는 STOMP 구현체에서 문자열 구문에 따라 직접 의미를 부여하도록 하기 위함이다.
일반적으로 다음의 형식을 따른다.
1
+2
+
"/topic/..." : publish - subscribe(1:N)
+"/queue/..." : point-to-point (1:1)
+
publisher로부터 전달 받은 메시지를 subscriber로 전달해주는 중간역할을 수행한다. 동작방식은 다음과 같다.
각각 A, B, C라는 유저가 차례로 5번방에 입장한다.
1
+2
+3
+4
+
SUBSCRIBE
+destination:/subscribe/chat/room/5
+
+^@
+
A가 5번방에서 채팅을 전송한다.
1
+2
+3
+4
+5
+
SEND
+content-type:application/json
+destination:/publish/chat
+
+{"chatRoomId":5,"type":"MESSAGE","writer":"clientB"}^@
+
5번방 메시지 브로커가 메시지를 받는다.
5번방 메시지 브로커가 5번방 구독자(A, B, C)에게 메시지를 전송한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
@Configuration
+@EnableWebSocketMessageBroker
+public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
+ @Override
+ public void configureMessageBroker(MessageBrokerRegistry registry) {
+ registry.enableSimpleBroker("/subscribe");
+ registry.setApplicationDestinationPrefixes("/publish");
+ }
+
+ @Override
+ public void registerStompEndpoints(StompEndpointRegistry registry) {
+ registry.addEndpoint("/ws-connection")
+ .setAllowedOrigins("*")
+ .withSockJS();
+ }
+}
+
enableSimpleBroker()로 설정한 값으로 시작하는 주소의 subscriber들에게 메시지를 전달하는 역할을 한다. 예시에서는 /subscribe로 설정하여 /subscribe로 들어온 요청은 구독으로 정해진다.setApplicationDestinationPrefixes()로 설정한 값은 publish를 위해 사용된다,/ws-connection으로 요청을 보내도록 설정하였다.1
+2
+3
+4
+5
+6
+
public class ChatRequest {
+ private Long senderId;
+ private Long receiverId;
+ private Long roomId;
+ private String message;
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
@RestController
+@RequiredArgsConstructor
+public class ChattingController {
+ private final ChattingService chattingService;
+ private final SimpMessagingTemplate simpMessagingTemplate;
+
+ public ChattingController(ChattingService chattingService, SimpMessagingTemplate simpMessagingTemplate) {
+ this.chattingService = chattingService;
+ this.simpMessagingTemplate = simpMessagingTemplate;
+ }
+
+ @MessageMapping("/messages")
+ public void chat(@Valid ChatRequest chatRequest) {
+ chattingService.save(chatRequest);
+ simpMessagingTemplate.convertAndSend("/subscribe/rooms/" + chatRequest.getRoomId(), chatRequest.getMessage());
+ }
+}
+
SimpMessagingTemplate
@EnableWebSocketMessageBroker을 통해서 등록되는 빈이다. 브로커로 메시지를 전달한다.@MessageMapping
클라이언트가 SEND 할 수 있는 경로.
WebSocketConfig 에서 등록한 setApplicationDestinationPrefixes() 주소와 합쳐진다
/publish/messages
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+
function connect() {
+ var socket = new WebSocket('/ws-connection');
+ stompClient = Stomp.over(socket);
+ stompClient.connect({}, function () {
+ setConnected(true);
+ stompClient.subscribe('/subscribe/rooms/5', function (greeting) {
+ console.log(greeting.body);
+ });
+ });
+}
+
+function sendMessage() {
+ stompClient.send("/publish/messages", {}, JSON.stringify({
+ 'message': $("#name").val(),
+ 'senderId': 7,
+ 'receiverId': 14,
+ 'roomId': 5
+ }));
+}
+
https://tecoble.techcourse.co.kr/post/2021-09-05-web-socket-practice/
https://dev-gorany.tistory.com/235
Comments powered by Disqus.
주로 Spring을 사용할 때, WebSocket Emulation 을 위한 라이브러리이다.
WebSocket Emulation 이란 우선 웹 소켓으로 소켓 연결을 시도하고, 실패할 경우 HTTP Streaming, Long-Polling 같은 HTTP 기반의 다른 기술로 전환해 다시 연결을 시도하는 것을 말한다. 따라서 다음과 같은 상황에서 도움이 된다
WebSocket Emulation을 위해서 node.js를 사용한다면 Socket.io를 사용하고, Spring을 사용하면 SockJS를 사용하는 것이 일반적이다.
Spring 프레임워크는 Servlet 스택 위에서 Server/Client 용도의 SockJS 프로토콜을 모두 지원한다
SockJS 클라이언트는 서버의 기본 정보를 얻기위해 GET /info를 호출하는데, 이는 다음과 같은 정보를 얻기 위함이다
이후 SockJS는 어떤 전송 타입을 사용할 지 결정한 후 아래 와 같은 순서대로 사용하려고 시도한다.
모든 전송 요청은 다음의 URL 구조를 갖는다.
https://host:port/myApp/myEndpoint/{server-id}/{session-id}/{transport}
SockJS는 메세지 Frame 크기를 최소화하려고 노력한다. 예를 들어 서버는 다음과 같은 축약 메세지를 보낸다.
["msg1", "msg2"]와 같은 JSON-Encoded 배열로서 전달된다.,스프링에서 웹 소켓을 사용하기 위한 의존성인 spring-websocket은 SockJS 프로토콜을 모두 지원한다. 따라서 간단히 적용가능한데, 웹소켓을 설정하는 곳에서 다음과 같이 .withSockJS()를 사용하면 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
@EnableWebSocketMessageBroker
+@Configuration
+public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
+ @Override
+ public void registerStompEndpoints(StompEndpointRegistry registry) {
+ registry.addEndpoint("/ws-stomp")
+ .setAllowedOrigins("*")
+ .withSockJS(); // SockJS 활성화
+ }
+}
+
SockJS는 Ajax/XHR Streaming을 microsoft의 XDomainRequest(xdr)를 통해 지원하고 있다. 이는 서로 다른 도메인 간에도 동작하지만, Cookie 전송은 지원하지 않는다.
Cookie는 Java 기반 서버에서는 필수적이지만, SockJS는 자바만이 아닌 다양한 서버 타입을 위해 고안되었기에 Cookie를 중요하게 다룰지 여부를 알려줘야한다.
SockJS는 처음에 GET /info 요청을 날리는데, 이때의 응답으로 cookie_needed 속성을 볼 수 있다. 만약 Cookie가 필요하다고 표시되냐 안되냐에 따라 사용하는 기술이 달라진다
스프링에서는 setSessionCookieNeeded를 통해 쿠키 사용여부를 표시할 수 있다. 기본값은 true이다.
여기서 iframe 기반의 기술 사용하려면 X-Frame-Options 응답 헤더에 대해 알아야한다.
X-Frame-Options
X-Frame-Options 속성의 값이 sameorigin이나 allow-from uri이면 iframe에서 동작된다. deny일 경우에는 다음 두가지 SockJS 객체 선언 중 2번째로 선언하였을 때만 동작한다
1
+2
+3
+4
+5
+
1.
+var sockJs = new SockJS("http://localhost:8080/ws/chat");
+
+2.
+var sockJs = new SockJS("http://localhost:8080/ws/chat", null, {transports: ["websocket", "xhr-streaming", "xhr-polling"]});
+
IE 10 이상부터는 웹 소켓이 지원된다. 다만 화살표 함수가 지원되지 않아 이부분만 바벨이나 직접 수정으로 해결해주면 된다.
https://velog.io/@koseungbin/WebSocket
Comments powered by Disqus.
아래와 같이 http 헤더를 보다보면 keep-alive라고 명시된 부분이 보일 때가 있다.
connection : keep-aliveKeep-Alive:timeout=5, max=1000이 keep-alive는 무슨 뜻일까 궁금하여 찾아보았다.
keep-aliveconnection : keep-alive
Keep-Alive:timeout=5, max=1000
3-way handshaking으로 진행되며 총 세번 두 호스트가 통신을 해야 연결이 맺어지며 본래 원하는 통신이 가능해진다. 이렇게 세 번 통신하는 과정은 낭비가 있다.keep-alive를 설정해주면 요청이 종료되어도 connection을 끊지 않아 다음 요청 때 한번 맺은 연결을 재사용할 수 있어 서버 요청/응답이 빨라진다.keep-alive라면 서버는 모든 요청마다 연결을 유지해야하기에 프로세스 수가 기하급수적으로 늘어나 MaxClient 값을 초과하게 된다.http 1.0에서
기본적으로 비연결지향으로 한번 통신을 하면 연결을 끊는다.
http 1.1에서
connection : keep-alive가 디폴트로 설정되어있다.
http/2에서
http/2에서는 keep-alive 기능을 사용할 필요가 없다. 그 이유는 다음과 같다.
http/2에서는 http body가 binary로 전송된다.(과거엔 text로 전송됨). 동시에 이전에는 header-body를 묶은 http message가 전송 최소단위였다면, http/2에서는 binary frame 이 전송 최소 단위가 된다. 이렇게 변화한 이유에는 기존 http 1.x가 가진 다음과 같은 단점 때문이다.
http 1.x가 가진 단점들
이를 해결하기 위해 http/2에서는 하나의 연결에 여러 스트림을 사용하여 multiplexing이 가능하도록 했다. 이것이 가능한 이유는 http/2 패킷을 binary frame 단위로 세분화하여 순서에 상관없이 받는 쪽에서 조립할 수 있도록 설계하였기 때문이다. 이러한 multiplexing 덕분에 http/2 에서는 연결을 유지하기 위한 설정인 keep-alive가 더이상 필요없어지게 되었다.
이외에도 http/2에서는 다음과 같은 성능 향상 기법이 적용되었다.
index.html안에 style.css, script.js, image.jpg가 있다면 http/1.x에서는 매번 [요청-응답]을 반복하며 받아와야했지만, http/2에서는 한번에 내려주어 성능을 개선해준다.Comments powered by Disqus.
여러 개의 개별 빌드가 단일 어플리케이션을 형성할 수 있도록 해주는 webpack의 기능이다. 개별 빌드는 컨테이너처럼 작동하며, 빌드 간에 코드를 노출하고 소비하여 단일 통합 애플리케이션을 생성할 수 있다.
로컬 모듈과 원격 모듈을 구별한다.
원격 모듈을 로드하는 것은 비동기 작업으로 간주된다. 원격 모듈을 사용할 때 이러한 비동기 작업은 원격 모듈과 엔트리포인트 사이에 있는 다음 청크 로드 작업에 배치된다. 청크 로드 작업 없이는 원격 모듈을 사용할 수 없다.
청크 로드작업은 일반적으로 import()를 사용하며, require.ensure 또는 require([...]) 같은 이전 구조도 지원한다.
특정 모듈에 대한 비동기 접근을 노출하는 컨테이너 엔트리를 통해 컨테이너가 생성된다. 노출된 접근은 두 단계로 구분된다.
1단계는 청크 로드 중에 수행된다. 2단계는 다른 로컬 및 원격 모듈과 interleave된 module validation 중에 수행된다. 이렇게 하면 모듈을 로컬에서 원격으로, 또는 그 반대로 변환해도 평가 순서가 영향을 받지 않는다.
컨테이너를 중첩할 수도 있다. 컨테이너가 다른 컨테이너의 모듈을 사용하거나, 컨테이너 간의 순환 의존성도 가능하다.
SPA에서 각 페이지를 서로 다른 빌드에서 컨테이너 빌드로부터 노출된다. 또한 애플리케이션 쉘은 모든 페이지를 원격 모듈로 참조하는 별도의 빌드이다. 이렇게 하면 각 페이지를 별도로 배포할 수 있다.
공통 컴포넌트를 별도의 빌드로 분리하여, 다른 애플리케이션들에서 그 컴포넌트를 불러와 사용할 수 있다. 그 컴포넌트에 변경점이 생기면 그 컴포넌트만 다시 빌드하여 배포하면 된다.
Comments powered by Disqus.
nginx.conf에서 환경변수를 사용하여 동적으로 nginx 설정을 변경하는 방법을 알아보자.
envsubst는 인풋으로부터 $VARIABLE 또는 ${VARIABLE}로 되어있는 값을 읽어 환경변수로 바꾸어주는 프로그램이다. envsubst을 활용해서 nginx.template 파일로 환경변수가 사용된 nginx 설정파일을 작성하고, nginx가 실행될 때 envsubst를 사용해 변환해주면 된다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+
worker_processes 1;
+
+events {
+ worker_connections 1024;
+}
+
+
+http {
+ include mime.types;
+ default_type application/octet-stream;
+
+ sendfile on;
+ keepalive_timeout 65;
+
+ server {
+ listen 80;
+
+ root /home1/irteam/deploy/client/build;
+ index index.html index.htm;
+
+ location / {
+ try_files ${DOLLAR}uri ${DOLLAR}uri/ /index.html = 404;
+ }
+ location /api {
+ proxy_pass http://${SPRING_HOST_NAME}:${SPRING_HOST_PORT};
+ }
+ }
+}
+
${}로 감쌌다.${SPRING_HOST_NAME} : 스프링 서버의 호스트 이름${SPRING_HOST_PORT} : 스프링 서버의 포트번호${DOLLAR} : envsubst을 사용하면 $로 시작하는 값은 전부 치환한다. 값이 존재하지 않을 경우 공백으로 변하므로, DOLLAR 환경변수를 새롭게 선언하여 $가 필요할 땐 ${DOLLAR}로 사용하자.1
+2
+3
+4
+5
+6
+
curl -L https://github.com/a8m/envsubst/releases/download/v1.2.0/envsubst-`uname -s`-`uname -m` -o envsubst # 1
+chmod +x envsubst
+export DOLLAR='$' # 2
+export SPRING_HOST_NAME='localhost'
+export SPRING_HOST_PORT="8080"
+./envsubst '${SPRING_HOST_NAME} ${SPRING_HOST_PORT} ${DOLLAR}' < nginx.template > nginx.conf # 3
+
nginx.template 파일을 nginx.conf 파일로 컴파일했다.다음과 같이 nginx.conf 파일이 환경변수로 설정한 대로 나왔다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+
worker_processes 1;
+
+events {
+ worker_connections 1024;
+}
+
+
+http {
+ include mime.types;
+ default_type application/octet-stream;
+
+ sendfile on;
+ keepalive_timeout 65;
+
+ server {
+ listen 80;
+
+ root /home1/irteam/deploy/client/build;
+ index index.html index.htm;
+
+ location / {
+ try_files $uri $uri/ /index.html = 404;
+ }
+ location /api {
+ proxy_pass http://localhost:8080;
+ }
+ }
+}
+
만약 nginx를 도커 컨테이너에서 사용하고, 베이스 이미지가 nginx라면, 더 쉬운 방법이 있다.
nginx 1.19 이미지부터는 envsubst를 자동으로 지원한다. 다만 docker-compose와 함께 사용해야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
web:
+ image: nginx
+ volumes:
+ - ./templates:/etc/nginx/templates
+ ports:
+ - "8080:80"
+ environment:
+ - NGINX_HOST=foobar.com
+ - NGINX_PORT=80
+
Comments powered by Disqus.
사용자가 로그인하면, 사용자 식별자를 암호화 또는 평문으로 쿠키에 담는 방식. 요청이 오면 쿠키에 담긴 식별자를 보고 유저를 구분한다.
인증이 완료되면 사용자 식별자를 서버(DB 등)에 저장하고 그 저장한 곳에 접근하기 위한 해시 값을 세션 ID로 지정. 이후 세션 ID를 쿠키에 담아 보내주고, 사용자로부터 요청이 오면 세션id로 사용자 식별자를 가져온다.
인증이 되면, JWT 토큰(access token)을 클라이언트로 보내줌. 클라이언트는 헤더에 JWT를 적용하여 서버로 요청을 보내면 서버는 JWT을 디코딩하여 유저를 식별함.
장단점만 보면 쿠키가 서버 확장에도 대응이 돼서 쿠키가 더 좋아보인다. 그런데 왜 사람들은 세션이 좋다고 하는 것일까? 로그인 상태를 저장하기에 동시 로그인 시 하나를 막을 수 있다지만, 서비스에 따라서는 동시로그인을 허용해야하는 경우가 많다. 정확히 어떤 차이점이 있을까?
Session ID in cookies vs. Encrypted cookie
글을 읽었을 때 게임과 같이 동시로그인을 꼭 막아야하는 경우가 아니면, 쿠키 암호화가 성능상/구현상 더 좋은 거 같음. 암호화 알고리즘도 라이브러리화 된 신뢰성 있는 것이 많기에 글에서 본 단점도 상쇄된다. secret key 관리만 개발자가 주의하면 될 거 같음.
ex) PC방에서 A유저가 로그인 하고 자리를 떴는데, B가 와서 그대로 사용할 경우
NID_AUT, NID_SES 사용JSESSIONID란 쿠키가 생성됨. 이름이나 값이 단순 숫자인것으로 보아 세션은 사용하는거 같은데, 로그인 후 새로 생기는 것들은 암호화 되어있고 기존 JSESSIONID와는 독립되어보임.Comments powered by Disqus.
사용자가 원하는 유튜브 영상의, 원하는 부분만을 가지고 재생목록을 만들 수 있도록 하는 서비스
회원가입을 통해 회원이 될 수 있고, 회원은 재생목록을 무제한으로 만들 수 있지만, 비회면원 5개까지만 가능
i18n을 통한 글로벌 언어 제공
앱, 웹에서 모두 사용가능하도록 개발.
Comments powered by Disqus.
하나의 코드를 다른 코드로 래핑하거나 javascript 함수를 래핑하는 방법
동일한 클래스의 다른 객체에는 영향을 주지 않고, 정적/동적으로 개별 객체에 동작을 추가할 수 있는 디자인 패턴이다.
문법
1
+2
+3
+4
+5
+6
+7
+8
+9
+
let variable = function(object) {
+ object.property = 'characteristic';
+}
+
+@variable
+class GFG {
+
+}
+console.log(GFG.property);
+
현재는 아래 두가지 유형의 데코레이터를 지원함
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+
function gfg(target, name, descrioptor) {
+ var fn = descriptor.value;
+
+ if(typeof fn == 'function') {
+ descriptor.value = function(...args) {
+ console.log(`parameters : ${args}`);
+ var result = fn.apply(this, args);
+
+ console.log(`addition : ${result}`);
+
+ return result;
+ }
+ }
+ return descriptor;
+}
+
+class geek {
+ @gfg
+ add(a, b) {
+ return a + b;
+ }
+}
+
+var e = new geek();
+e.add(100, 200);
+
1
+2
+
parameters : 100, 200
+addition : 300
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
function log() {
+ return function decorator() {
+ return (...args) => {
+ console.log(`Parameters : ${args}`)
+ return new Class(...args);
+ }
+ }
+}
+
+@log
+class gfg {
+ constructor(name, category) {
+
+ }
+}
+const e = new gfg('geek', 'code');
+console.log(e);
+
(...args) => {
+ console.log(`Parameter : ${args}`);
+ return new Class(...args);
+}
+Comments powered by Disqus.
주로 API 요청을 보낼 때 발생함. 요청을 여러 번 보낼 때, 앞 요청이 끝나기 전에 뒤 요청이 먼저 끝날 수도 있다. 이러한 상황을 항상 고려하자.
예시
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
const onClickCorrect = async () => {
+ if (
+ selectedUserState !== null
+ ) {
+ try {
+ const res = await applyForUser({selectedUserState})
+ setApplicationId(res.applicationId);
+ navigate('/waiting');
+ } catch (e) {
+ console.log(e);
+ }
+}};
+
selectedUserState 가 null 일 경우 유저는 아무리 클릭을 해도 아무런 반응을 얻지 못할 것이다.else 문을 추가하여 selectedUserState 가 null 일 경우를 대비하자.컴포넌트가 새로고침이나 뒤로가기를 통해 다시 마운트 될 시, 고려 해야 하는 부분이 몇 가지 있다.
아래 코드를 보자. 컴포넌트가 마운트 되면, react-query는 유저타입 데이터를 받아온다. 그리고 useEffect 에서는 그 중 첫 번째 타입을 selectedUserState 상태에 설정한다.
유저타입 데이터는 선택된 상태로 렌더링 되고, 유저가 리스트에서 원하는 Row를 선택하면 그 타입으로 selectedUserState 를 업데이트한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+
export function CreditCardTypePage() {
+ const { data: userTypes } = useQuery(reactQueryKey.USER_TYPE, fetchUserTypes);
+ const [{ userType: selectedUserType }, setSelectedUserState] = useRecoilState(recoil_SelectedUserState);
+
+ useEffect(() => {
+ if (userTypes !== undefined) {
+ setSelectedUserState(prev => ({ ...prev, userType: userTypes[0] }));
+ }
+ }, [userTypes, setSelectedUserState]);
+
+ const onClickUserTypeRow = (userType: UserType) => {
+ setSelectedUserState(prev => ({ ...prev, userType }));
+ };
+
+ return () => {
+ <List>
+ {userTypes?.map(item => (
+ <ListRow.Selectable
+ key={item.id}
+ contents={<ListRow.Text1Row top={item.title} />}
+ right={<Checkbox readOnly={true} checked={selectedUserType !== null && item.id === selectedUserType.id} />}
+ onClick={() => onClickUserTypeRow(item)}
+ />
+ ))}
+ </List>
+ }
+}
+
이 코드에는 새로고침, 뒤로가기 시 유저가 선택한 상태가 초기화 되어 첫 번째 Row가 선택된 상태로 렌더링 된다는 문제점이 존재한다. 이러한 문제점을 해결하기 위해서는 다음과 같이 처리 해주어야 한다.
useEffect내에서 상태를 업데이트할 때, selectedUserType이 null일 때만 업데이트하도록 한다.1번을 통해 새로고침 되어 상태가 전부 초기화 되었을 때를 대응하고, 2번을 통해 유저가 선택된 상태를 유지하도록 한다.
위 코드 예시에서 보여 준 컴포넌트는 recoil_SelectedUserState에서 userType 데이터만 사용한다. 만약 recoil_SelectedUserState가 다음과 같이 작은 상태이고 한 부분에서만 사용한다면 큰 문제는 없다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
const recoil_SelectedUserState = atom<{
+ userType: UserType | null;
+ userDesign: UserDesign | null;
+ userFields: SelectedUserField[] | null;
+}>({
+ key: 'selectedUserState',
+ default: {
+ userType: null,
+ userDesign: null,
+ userFields: null,
+ },
+});
+
하지만 만약 userType만, userDesign만, userFields만 따로 사용하는 부분이 반복된다면 어떻게 될까? 만약 새로고침과 뒤로가기에 대응하느라 그러한 부분들을 전부 같은 형식으로 수정해야 한다면 어떻게 될까?
이럴 때가 바로 중복되는 부분을 분리해줘야 할 때다.
같은 부분을 두 번 이상 반복하고 있다면, 바로 그때가 코드를 분리해야 할 때다.
이러한 부분은 hook이나 컴포넌트로 분리할 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+
// hook
+const reactQueryPropsByUse = {
+ "userType" : {
+ reactQueryKey : reactQueryKey.USER_TYPE,
+ fetch : fetchUserTypes,
+ },
+}
+
+export function SingleSelectedUserState({use = "userType", defaultValue = null}) {
+ const { data } = useQuery(reactQueryPropsByUse[use].reactQueryKey, reactQueryPropsByUse[use].fetch);
+ const [{ [use]: selectedUserData }, setSelectedUserState] = useRecoilState(recoil_SelectedUserState);
+
+ useEffect(() => {
+ if (data !== undefined && selectedUserData === null && defaultValue === null) {
+ setSelectedUserState(prev => ({ ...prev, [use]: data[0] }));
+ }
+ if(defaultValue !== null) {
+ setSelectedUserState(prev => ({ ...prev, [use]: defaultValue ] }));
+ }
+ }, [data, selectedUserData, use, defaultValue, setSelectedUserState]);
+
+ const setSingleSelectedUserState = (userData) => {
+ setSelectedUserState(prev => ({...prev, [use] : userData}));
+ }
+
+
+ return [selectedUserData, setSingleSelectedUserState];
+}
+
컴포넌트로 분리할 때는 원하는 로직을 따로 뺀 후, children으로 그 로직을 사용할 컴포넌트를 불러오면 된다.
1
+2
+3
+4
+5
+6
+7
+8
+
const ModalLayout = (props) => {
+ const {children, setContent, isOpenModal} = props;
+ return (
+ <ModalBox>
+ {React.cloneElement(children, {setContent, isOpenModal})}
+ </ModalBox>
+ )
+}
+
https://velog.io/@hyunjoogo/React-children-Component%EC%97%90-props-%EC%A0%84%EB%8B%AC%ED%95%98%EA%B8%B0
Comments powered by Disqus.
Jeong, Yemin & Youn, Youjeong & Cho, Subin & Kim, Seoyeon & Huh, Morang & Lee, Yangwon (2020). Prediction of Daily PM10 Concentration for Air Korea Stations Using Artificial Intelligence with LDAPS Weather Data, MODIS AOD, and Chinese Air Quality Data. 대한원격탐사학회지, 대한원격탐사학회
Comments powered by Disqus.
파싱 : 브라우저가 코드를 이해하고 사용할 수 있는 구조로 변환하는 것
파서-어휘 분석기 조합
어휘분석 : 자료를 토큰으로 분해하는 과정.
구문분석 : 언어의 구문 규칙을 적용하는 과정
파서 : 문서 -> 어휘분석 -> 구문분석 -> 파싱트리로 만듬.
파싱과정은 반복됨.
변환 : 파싱과정을 통해 나온 파싱트리를 기계코드로 변환시키는 과정
어휘화 구문에 대한 공식적인 정의
파서의 종류
하향식 파서 : 구문의 상위 구조로부터 일치하는 부분을 찾음.
상향식 파서 : 하위 구조로부터 일치하는 부분을 찾음.
부준적으로 일치하는 표현식은 파서 스택에 쌓이며, 오른쪽으로 갈수록 남는 것이 점차 감소하기때문에 이동-감소 파서라고 부름.
파서 자동생성
파서 생성기 : 파서를 생성해 줄 수 있는 도구
웹킷
플렉스(Flex) : 어휘 생성. 토큰의 정규 표현식 정의를 포함하는 파일을 입력 받음.
바이슨(Bison) : 파서 생성. BNF 형식의 언어구문규칙을 입력받음.
Html 마크업을 파싱 트리로 변환함.
문법 정의 : W3C 에서 명세로 정의되어있음.
문맥 자유문법이 아니다. 따라서 BNF로 표현불가능.
HTML vs XML
HTML DTD
DOM : 문서 객체 모델(Document Object Model)
파싱 알고리즘
일반적인 하향식, 상향식 파서로 파싱이 안됨. 그 이유는
파싱 알고리즘은 HTML 문서에 자세히 설명되어있다.
알고리즘은 토큰화와 트리 구축으로 나누어져있음
토큰화 : 어휘 분석으로서 입력값을 토큰으로 파싱함.
토큰화 알고리즘
트리구축 알고리즘
파싱이 끝난 이후의 동작
브라우저의 오류처리
브라우저는 HTML 의 모든 오류구문을 교정해준다.
파서는 적어도 ㄷ음과 같은 오류를 처리해야함
ex)
CSS 파싱
스크립트와 스타일 시트 진행 순서
DOM 트리가 구축되는 동안 브라우저는 렌더 트리를 구축함.
렌더러
렌더러는 자신과 자식 요소를 어떻게 배치하고 그려내야하는지 알고 있음.
웹킷 렌더러 기본 객체 : RenderObject 클래스
1
+2
+3
+4
+5
+6
+7
+8
+
class RenderObject { virtual
+ void layout(); virtual
+ void paint(PaintInfo); virtual
+ void rect repaintRect();
+ Node * node; //the DOM node
+ RenderStyle * style; // the computed style
+ RenderLayer * containgLayer; //the containing z-index layer
+}
+
Dom 트리와 렌더 트리의 관계
렌더러는 DOM 요소에 부합하지만 1:1로 대응하지는 않는다.
여러개의 시각 객체와 대응하는 DOM 요소도 있다.
어떤 렌더객체는 DOM 노드에 대응하지만 트리의 동일한 위치에 있지 않다.
트리를 구축하는 과정
스타일계산
렌더 트리를 구축하려면 각 렌더 객체의 시각적 속성에 대한 계산이 필요한데 이것은 각 요소의 스타일 속성을 계산함으로써 처리된다.
스타일 계산에는 다음과 같은 어려움이 따름.
스타일 데이터는 구성이 매우 광범위한데 수 많은 스타일 속성들을 수용하면서 메모리 문제를 야기할 수 있다.
최적화되어 있지 않다면 각 요소에 할당된 규칙을 찾는 것은 성능 문제를 야기할 수 있다. 예를 들어 이런 복합 선택자가 있다.
div div div div { … }
규칙을 적용할 <div> 요소를 확인하려면 트리로부터 임의의 줄기를 선택하고 탐색하는 과정에서 규칙에 맞지 않는 줄기를 선택했다면 또 다른 줄기를 선택해야 한다.
규칙을 적용하는 것은 계층 구조를 파악해야 하는 복잡한 다단계 규칙을 수반한다.
이 문제를 어떻게 해결하는가? -> 아래 설명-
웹킷 노드 : 스타일 정보 공유
파이어폭스 규칙 트리
파이어폭스는 스타일 계산을 쉽게 처리해주는 규칙 트리와 스타일 문맥 트리라고 하는 두 개의 트리를 더 가지고 있다.
스타일 문맥에는 최종값이 저장되어있다.
값은 올바른 순서 안에서 부합하는 규칙을 적용하고, 논리로부터 구체적인 값으로 변환함으로써 계산된다.
노드 사이에서 이 값을 공유함으로써 다시 계산하는 일을 방지한다.
부합하는 모든 규칙은 트리에 저장하는데, 경로의 하위 노드가 높은 우선순위를 갖는다.
규칙 저장은 느리게 처리된다. 트리는 처음부터 모든 노드를 계산하지 않지만 노드 스타일이 계산될 필요가 있을 때 계산된 경로를 트리에 추가한다.
트리가 작업량을 줄이는 방법
구조체로 분리 :
스타일 문맥을 구조체로 나눈다.
상속할 데이터와 상속하지 않을 데이터를 나눔.
규칙 트리를 사용하여 스타일 문맥을 계산
쉬운 선택을 하기 위한 규칙 다루기
인라인 스타일 속성과 HTML 시각적 속성은 자신이 스타일 속성을 가지고 있거나 HTML 소고성을 이용하여 연결할 수 있기 때문에 요소에 쉽게 연결된다.
1
+2
+
<p style="color:blue"></p>
+<p bgcolor="blue"></p>
+
외부 스타일 시트에 선언하거나, style 요소안에서 선언하면 까다로울 수 있다.
다단계(cascade) 순서에 따라 규칙 적용하기
점진적 처리
크기와 위치정보를 계산하는 것 (렌더러가 생성되어 트리에 추가될 때는 이러한 정보가 없다.)
HTML 은 흐름기반의 배치 모델을 사용함 == 단일 경로를 통해 크기와 위치 정보를 계산할 수 있다는 것을 의미.
배치는 반복되며 HTML 문서의 <html> 요소에 해당하는 최상위 렌더러에서 시작된다.
모든 렌더러는 “배치” 또는 “리플로” 메서드를 갖는데, 각 렌더러는 배치해야할 자식의 배치 메서드를 불러온다.
더티 비트 체제
전역배치와 점증배치
비동기 패치와 동기배치
최적화
배치과정
너비계산
렌더러의 너비는 포함하는 블록의 너비, 렌더러의 너비와 여백, 테두리를 이용하여 계산된다.
웹킷 계산
컨테이너의 너비는 컨테이너 availableWidth와 0 사이의 최대값이다. 이 경우 availableWidth는 다음과 같이 계산된 contentWidth이다.
clientWidth() - paddingLeft() - paddingRight()
clientWidth와 clientHeight는 객체의 테두리와 스크롤바를 제외한 내부 영역을 의미한다.
요소의 너비는 “width” 스타일 속성의 값이다. 이 컨테이너 너비의 백분률 값은 절대 값으로 변환될 것이다.
좌우측 테두리와 패딩 값이 추가된다.
위는 미리 획득한 너비의 계산.
최소 너비와 최대너비 계산
배치할 필요가 있지만 너비가 고정된 경우 값은 캐시에 저장된다.
줄바꿈
캔버스
CSS 박스 모델
위치 결정방법
세가지
박스 유형
위치잡기
층 표현 : z-index 속성에 의해 명시됨.
뒤쪽 요소가 먼저 그려지고 앞쪽 요소는 사용자에게 가까운 쪽으로 나중에 그려진다.
가장 앞쪽에 위치한 요소는 겹치는 이전 요소를 가린다.
https://d2.naver.com/helloworld/59361
Comments powered by Disqus.
명령형은 어떻게(How)에, 선언형은 무엇(What)에 집중한다.
선언형은 명령형 코드에서 ‘어떻게’를 감추고 ‘무엇을’만 노출하는 방식의 추상화이다. 일종의 리팩토링이다.
예시를 들면 다음과 같다.
1
+2
+3
+4
+5
+6
+7
+8
+
// 명령형 코드 : 배열에 있는 모든 숫자를 하나씩 제곱해서 result 배열에 넣는다.
+function double(arr) {
+ let results = [];
+ for (let i = 0; i < arr.length; i++) {
+ results.push(arr[i] * 2);
+ }
+ return results;
+}
+
1
+2
+3
+4
+
// 선언형 코드 : 모든 배열에서 숫자가 제곱된다.
+function double(arr) {
+ return arr.map((item) => item * 2);
+}
+
배열의 모든 요소를 돌며 하나씩 제곱하는 것이 아니라, 배열의 각 요소를 대상으로 제곱이 되라고 선언한 형태이다. How는 map 함수 안에 숨겨져있다.
선언형 프로그래밍의 대중적인 정의 몇가지
- A high-level program that describes what a computation should perform.
- Any programming language that lacks side effects (or more specifically, is referentially transparent)
- A language with a clear correspondence to mathematical logic.
여기서 두 번째 불렛의 사이드 이펙트가 적고 순수하다라는 점이 중요하다.
1
+
moveToEmptyTable(myPosition, tables);
+
위 함수는 충분히 선언적이지 못하다.
moveToEmptyTable()을 호출한다면 빈자리에 찾아갈지 아니면 오류가 날지 모른다.따라서 언제 불러도 같은 결과가 나오도록, 또 순수해지도록 리팩트링하면 다음과 같이 두 함수로 나뉠 수 있다.
1
+2
+
const emptyTablePosition = getEmptyTablePosition(tables);
+move(me, emptyTablePosition);
+
라인 바이 라인의 코드순서가 중요하지 않아질수록 더 선언적이게 된다.
순서의존도가 없기 때문에 사이드이펙트도 줄어들고 이해하기도 더 쉬워진다.
예를들어 리액트 컴포넌트의 props은 순서에 상관없이 동일한 동작을 한다.
1
+2
+3
+4
+5
+
<Modal
+ title="뭐먹지"
+ onClick={() => alert("짬뽕")}
+ description="중국음식?"
+/>
+
여기에 title, onClick, description의 코드 순서는 중요하지 않다.
다음은 동,읍,면 Input이 있고, 동을 입력하면 자동으로 읍으로, 읍을 입력하면 자동으로 면으로 넘어가는 코드이다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
// 명령형 코드 원본
+if (value.length < maxLength) {
+ return;
+}
+if (cursorPosition === "동") {
+ 읍input.focus();
+ 읍input.selectionStart = 읍input.value.length;
+} else if (cursorPosition === "읍") {
+ 면input.focus();
+ 면input.selectionStart = 면input.value.length;
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
// 명령형 추상화
+const isInputFull = value.length === maxLength;
+if (!isInputFull) {
+ return;
+}
+if (cursorPosition === "동") {
+ moveToInput("읍");
+} else if (cursorPosition === "읍") {
+ moveToInput("면");
+}
+
1
+2
+3
+4
+
// 선언형 추상화
+<Input name="동" onFull={() => moveFocusTo('읍')}/>
+<Input name="읍" onFull={() => moveFocusTo('면')}/>
+<Input name="면"/>
+
명령형 코드를
선언적 코드라고 볼 수 있다.
명령형 코드를 해석할 때는, 흐름을 따라가면서 읽어야 하는 시간축이 있다. 하지만 선언적코드는 흐름에 따라 읽지 않아도 되기에 읽기도, 디버깅하기도, 재사용하기도 좋다. 또한 내부를 몰라도 사용할 수 있다는 점에서 사용성이 좋다.
선언적 프로그래밍은 코드 자체에 어떤일이 벌어진지 설명하기 때문에, 좀 더 추론하기 좋다.
아래 예시를 통해 알아보자
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
const loadAndMapMembers = compose(
+ combineWith(sessionStorage, "members"),
+ save(sessionStorage, "members"),
+ scopeMembers(window),
+ logMemberInfoToConsole("name.first"),
+ countMemberBy("location.state"),
+ prepStatesForMapping,
+ save(sessionStorage, "map"),
+ renderUSMap
+);
+
+getFakeMembers(100).then(loadAndMapMembers);
+
많은 함수가 결합되어있지만, 선언형으로 되어있기에 각 함수가 어떻게 구현되어있을 거라고 추론하기 쉬워진다.
https://milooy.github.io/dev/220810-abstraction-and-declarative-programming/
Comments powered by Disqus.
Web 계층
Service 계층
Repository 계층
DTOs
Domain Model
기존에는 서비스 계층에서 처리하였으나, 복잡한 서비스에서는 더 많은 모델을 읽어 서비스를 제공하기 때문에, 서비스 계층은 매우 복잡해짐.
반면 도메인에서 처리할 경우, 각자 본인의 취소 이벤트처리를 하며, 서비스 메소드는 트랜잭션과 도메인간의 순서만 보장한다.
https://loosie.tistory.com/296
https://velog.io/@smallcherry/Spring-%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9B%B9-%EA%B3%84%EC%B8%B5-Spring-Web-Layer
Comments powered by Disqus.
변화를 피하지 말고 불만이 있는 것이 있으면 고치기 위해 노력하라
기회는 많고 적극적으로 행동해 그 기회를 잡아라
실용주의 철학의 초석 중 하나는 자신과 자신의 행동에 대해 책임을 지는 것이다. 아무리 잘해도 발생하는 문제는 있고, 이를 정직하고 솔직하게 인정하고, 처리하려고 노력해야한다.
팀 내 신뢰 팀이 나를 믿고 의지할 수 있어야하고, 나도 팀을 의지할 수 있어야한다. 신뢰를 바탕에 둔 환경에서는 안전하게 아이디어를 교류할 수 있다.
책임지기 책임을 지지 않을 권리는 있지만, 지기로 결정했다면 결과를 감당해야한다.
어설픈 변명 말고 대안을 제시하라.
소프트웨어의 무질서도가 증가하면 이를 ‘소프트웨어의 부패’ (기술 부채)라고 부른다.
깨진 창문을 내버려두지 마라
방치는 다른 어떤 요인보다 부패를 가속화시킨다. 만약 고칠 시간이 없다면 아예 버리거나 새롭게 대체하라
우선 망가트리지 말라 상황을 냉정하게 평가하여 어떤 위기가 왔다고 필요이상의 피해를 주지마라. (= 깨진 창문을 더 만들지 말라)
변화의 촉매가 되라
시작 피로에 빠지기 쉽다. 이때는 개발에 필요한 자원을 얻기 위해 사람들을 설득하는 것은 쉽지 않다.큰 그림을 기억하라
너무 완벽한 소프트웨어를 만들려하지말고, 적당히 괜찮게 만드는 것이 중요하다. 하지만 이때 적당히 괜찮은은 기본적인 성능, 보안, 요구조건을 만족해야한다.
타협과정에 사용자를 참여시켜라 소프트웨어가 얼마나 좋아야하는지 사용자에게 물어라. 좋은 소프트웨어를 위해 요구조건을 무시하거나, 요구조건을 위해 기본적인 것을 빼는 것 모두 전문가답지 못하다.
품질을 요구사항으로 만들어라.
우리는 적당한 타협이 필요한 상황에 자주 처한다. 사용자는 완벽한 내일의 소프트웨어보다 적당한 오늘의 소프트웨어를 원한다. 사용자에게 직접 만질 수 있는 기회를 주면 피드백을 통해 더 나은 해결책에 도달할 수 있다.
멈춰야할 때를 알라 완벽하게 훌륭한 프로그램을 만드느라 망치지마라.
‘기능 블로트’ 소프트웨어가 실제로 사용되는 기능에 비패 훨씬 더 많은 기능을 가지고 있고, 그만큼 버그나 보안 취약점이 생길 가능성이 높은 것을 말함
새로운 것을 배우는 능력은 가장 중요한 전략 자산이다. 그런데 배우는 방법은 어떻게 배워야하고, 무엇을 어떻게 배워야할까?
지식 포트폴리오
목표
한 기술에 익숙해지면 다음으로 나아가라. 직접 사용할일은 없어도, 학습과정에서 사고가 확장될 것이다.
학습의 기회
비판적 사고
읽고 듣는 것을 비판적으로 분석하라
청중을 알라
말하고 싶은 게 무언지 알라 무엇을 말할지 미리 계획하고, 개요를 작성하라. 그리고 자문하라.
때를 골라라 무언가를 말할때 그 때가 적절한지 생각해봐라
스타일을 골라라 청중에 어울리도록 전달하는 스타일을 조정하라
하지만 조정할 수 없는 내용이라면, 사실이 그렇다고 전달하자
멋져보이게 하라 내용만 집중하기보단 멋져보이게 얘기하는 것도 중요하다
청중을 참여시켜라 가능하면 독자를 문서 초안에 참여하도록하여 피드백을 받아라
경청하라 회의를 대화로 바꾸면 생각을 더 효과적으로 전달할 수 있다
응답하라 “다음에 답해 드리겠습니다”라고 하더라도 사람들에게 응답해주면 더 긍정적으로 봐준다.
문서화 문서화는 꼭 필요한 작업이다.
문서를 애초부터 포함하고, 나중에 집어넣으려고 하지 말라.
모듈과 외부로 노출하는 함수에는 주석을 다는 것을 추천한다. But 모든 함수나 자료구조에 주석을 남기는 것은 유지보수를 어렵게 만든다. 주석을 달 때는 코드의 용도와 목적을 논해야한다. 어떻게 동작하는지는 코드가 이미 보여주고 있기 때문이다.
Comments powered by Disqus.
좋은 설계는 나쁜 설계보다 바꾸기 쉽다.
ETC(Easy To Change)는 규칙이 아니라 가치
가치란 결정을 내릴때 도움을 주는 것이다. ETC는 가치로서 내제화되어야하며, 의식적으로 방금 한 일이 ETC 한지 항상 물어봐야한다. 일반적으로 상식선에서 추측이 가능하다. 하지만 결정하기 어려울때가 있는데, 이럴땐 다음 두가지 방법이 있다.
소프트웨어를 신뢰성 높게 개발하는 유일한 길, 유지보수를 쉽게 만드는 유일한 길은 DRY 원칙을 따르는 것이다.
DRY : 반복하지 말라
DRY를 따르지 않으면 똑같은 것이 두 군데 이상 표현될 것이다. 그러면 하나를 바꾸면 나머지를 바꿔야하는데, 언제 잊어버릴지 모른다.
1) DRY는 코드 밖에서도
DRY는 똑같은 개념을 다른 곳에서 표현하면 안된다는 것이다. 코드의 어떤 부분을 바꿔야할때 문서도 바꿔야하는가? 그럼 DRY를 위반한 것이다.
2) 모든 코드 중복이 지식의 중복은 아니다
요구조건) 연령과 주문 수량은 모두 숫자이고, 0보다 커야한다
def validate_age(value):
+ validate_type(value, :integer)
+ validate_min_integer(value, 1)
+
+def validate_quantity(value):
+ validate_type(value, :integer)
+ validate_min_integer(value, 1)
+이때 두 함수가 표현하는 지식은 다르다. 다만 우연히 규칙이 같은 것일 뿐이다. 이건 우연이지 중복이 아니다.
3) 문서화 중복
과도하게 많은 주석은 함수의 의도를 두번 설명하게 한다. 이는 추후 함수를 변경해야할때 주석도 변경해야한다. 따라서 함수명, 변수명 등으로 코드로서 의도를 표현하는 것이 제일 좋다.
4) 데이터의 DRY 위반
자료구조 내에서 중복된 의미의 데이터가 포함될 수 있다.
start, end, length 변수가 있는 경우 -> length를 계산하는 메서드를 만들어라하지만 계산로직이 복잡한 경우 캐싱을 위해 포함할 수도 있는데, 중요한 것은 자료구조 외부로 드러내지 않는 것이다.
start, end만 받고, length는 자동으로 계산되게5) 표현상의 중복
다른 라이브러리나 API와 연결할때 해당 API에 표현된 지식들(스키마, 에러코드 등)을 우리 코드도 알아야한다. 이러한 중복은 다음과 같이 완화될 수 있다.
6) 개발자 간의 중복
같은 기능을 여러 개발자가 각자 개발할 수도 있다. 이러한 것을 발견하려면 소통과 코드리뷰가 중요하다.
재사용하기 쉽게 만들어라
기존의 것을 찾아내고, 재사용하기 쉬운 환경을 조성해야한다. 재사용이 어려우면 중복의 위험을 감수해야한다.
컴퓨터 과학에서 직교성은 결합도 줄이기를 의미한다. 하나가 바뀌어도 나머지에 어떤 영향도 주지 않으면 서로 직교한다고 할 수 있다. 잘 설계가 되어있다면 데이터베이스 코드가 바뀌어도 사용자 인터페이스는 바뀌지 않을 것이다.
직교성의 장점
관련 없는 것들 간에 서로 영향이 없도록 하라
컴포넌트들이 각기 격리되어있으면 어느 하나를 바꿀 때 나머지를 걱정하지 않아도 된다. 직교성은 다음 두가지 큰 장점이 있다.
설계
설계가 직교적인지 확인하는 쉬운 방법은 ‘특정 기능에 대한 요구사항이 대폭 변경되었을때 몇개의 모듈이 영향을 받는가?’를 자문하는 것이다. 정답은 하나여야한다.
또한 현실 세계의 변화와 설계 사이의 결합도를 얼마나 줄였는지도 확인해야한다. 자신의 힘으로 제어할 수 없는 속성에 의존하면 안된다.
툴킷과 라이브러리
같은 팀이 작성한 것이라도 라이브러리의 도입이 코드에 수용해서는 안될 변화를 가져오고, 직교성을 해친다면 도입하면 안된다.
EJB의 데코레이터 패턴이 좋은 라이브러리 예시이다.
코딩
코딩을 할 때 직교성을 유지할 수 있는 몇가지 기법이 있다.
데메테르 법칙을 따르려 노력해보자기회가 있을 때마다 리팩터링하여 직교성을 개선하기 위해 노력하라.
테스트
직교적으로 설계된 시스템은 테스트하기가 더 쉽다. 통합 테스트보다 단위 테스트가 훨씬 쉽기 때문이다.
단위테스트를 작성하는 행위 자체가 직교성을 테스트할 수 있는 기회이다. 단위 테스트를 작성할 때 많은 모듈을 불러와야하면 결합도가 높다는 뜻이다.
버그 수정을 할 때에도, 하나의 모듈만 고치면 되는지 전체를 다 고쳐야하는지 점검해보아라.
더 알아보기
함수형 프로그래밍에서도 결합이 발생할 수 있는데, 한 함수의 결과를 다른 함수의 입력으로 사용하는 경우이다.
프로젝트에서 정답은 하나가 아니다. 중요한 결정이 추후 변경될 수 있고, 큰 비용을 치뤄야하는 경우가 발생한다.
이 책에서 추천하는 방법들 (DRY 원칙, 결합도 줄이기 등)을 따른다면 중요하면서도 되돌릴 수 없는 결정의 수를 가능한한 줄일 수 있다.
최종 결정이란 없다
코드 뿐만이 아니라 아키텍처, 배포, 외부 제품과의 통합 영역도 유연하게 유지하여야한다. 아키텍처는 항상 변화하며 할 수 있는 것은 바꾸기 쉽게 만드는 것 뿐이다. 외부의 API를 추상화 계층 뒤로 숨기고, 코드를 여러 컴포넌트로 쪼개라.
유행을 좇지 마라.
어떤 미래가 펼쳐질지는 알 수 없으며, 코드 스스로 유연하게 대처 가능하도록 해야한다.
프로젝트를 진행할때 마치 예광탄처럼 즉각적인 피드백을 얻는 것은 매우 중요하다.
프로젝트를 진행할때 우리는 미지의 것을 마주한다. 애매모호한 요구사항, 처음보는 라이브러리, 기술 등. 이럴때 전형적인 반응은 시스템을 극도로 명세화하는 것이다. 환경을 제약하고, 요구사항을 일일히 항목으로 만들어서 명세서를 만든 후 맞기를 기도한다.
하지만 실용주의 프로그래머는 소프트웨어 판 예광탄을 선호한다.
예광탄이 효과적인 이유는 일반 탄환과 동일한 환경 및 제약 조건에서 발사되기 때문이다. 코딩에서 동일한 효과를 얻으려면 우리를 요구사항으로부터 최종 시스템의 일부 측면까지 빨리, 눈에 보이게 반복적으로 도달하게 해줄 무언가를 찾아야한다.
시스템을 정의하는 중요한 요구사항을 찾아라. 의문이 드는 부분이나 가장 위험이 커 보이는 곳을 찾아라. 이런 부분의 코드를 가장 먼저 작성하도록 개발 우선순위를 정하라.
목표물을 찾기 위해 예광탄을 써라.
예시들
hello world 를 작성한 후 컴파일, 실행 해보는 것예광탄 코드는 여러 장점이 있다.
프토로타입은 최종 시스템의 어떤 특정한 측면을 탐사해보는 것이 목표이다. 따라서 프로토타입 방식을 따른다면 실험 이후 모두 버려야한다. 그리고 프로토타입을 통해 얻은 교훈으로 코드를 새로 작성한다.
프로토타입은 일종의 예시를 사용자에게 제시하고, 이후 최종 목표환경을 위한 코드로 다시 작성한다.
예광탄 코드는 애플리케이션이 전체적으로 어떻게 연결되는지 알려주고, 사용자에게는 애플리케이션의 요소들이 어떻게 상호작용하는지 보여주고 개발자에게는 아키텍쳐의 골격을 제시한다.
정리하면 프로토타입은 나중에 버리는 코드를 만들고, 예광탄 코드는 기능은 별로 없지만 완결된 코드이며 최종 시스템 골격 중 일부가 된다. 프로토타입은 예광탄을 발사하기 전에 먼저 수행하는 정찰 같은 것이다.
프로토타입은 반드시 코드로 만들 필요는 없다. 그림이나 인터페이스 빌더 등을 통해 만들어 볼 수 있다.
프로토타입은 제한된 몇가지 질문에 답하기 위한 것이기에 세부 사항을 무시하고 실제 제품보다 매우 적은 비용으로 만들 수 있다. 만약 세부 사항을 포기하지 못하는 상황이라면 프로토타입을 만들고 있는 것이 맞는지 자문하라. 이럴때는 예광탄 코드가 적합할 수 있다.
프로토타입으로 조사할 대상은 위험을 수반하는 모든 것이다. 이전에 해본 적 없는 것, 최종 시스템에 매우 중요한 것, 의심이 가는 것 등이 모두 대상이다.
프로토타입의 가치는 프로토타입 자체가 아니라 이를 통해 배우는 교훈에 있다.
프로토타이핑으로 학습하라
프로토타입을 만들 때 무시해도 좋은 세부사항은 무엇일까?
프로그래밍 언어로 사고방식이 제한될 수 있다. 따라서 도메인의 어휘를 사용하여 프로그래밍 하는 방식으로 좀 더 그 도메인에 가깝게 설계할 수 있다
문제 도메인에 가깝게 프로그래밍하라.
예시 :
하지만 우리가 도메인 언어로 코드를 짠다해도 기획자는 읽지 않는다. 스스로 무엇을 원하는지 정확히 모르기 때문이다. 이때는 실제로 동작하는 것을 보여주면 스스로 원하는 것을 말할 것이다.
도메인언어를 사용하며 절약되는 시간보다 더 많은 시간을 쏟지마라. 기본적으로는 통용되는 yaml, json, csv 같은 외부 언어를 사용하라. 다만 외부언어 도입은 사용자가 직접 도메인 언어로 코드를 작성하는 경우에만 추천한다.
모든 답은 추정치이다. 따라서 질문자의 원하는 것이 정확한 답을 요구하는지 큰 그림을 요구하는지 먼저 파악해야한다.
사용하는 단위에 따라서 답의 정확도 해석이 달라질 수 있다. 예를들어 130일이 걸린다고 하면 정확히 130일이라는 느낌이 들지만, 대략 6달이라고하면 5~6개월로 해석된다. 아래 단위를 추천한다. (ex : 125일이 걸릴 거 같으면 대략 6달이라고 말하자)
모든 추정치는 문제의 모델에 기반한다. 그런데 모델을 작성하기 전에 그 일을 해본 사람에게 물어봐라. 다른 사람의 경험을 바탕으로 성공적인 추정치를 낼 수 있다.
무엇을 묻고있는지 이해하라
어떤 추정을 하건 상대방이 무엇을 묻고 있는지 먼저 이해해야한다. 도메인에 존재하는 조건에 대해서도 알아야한다. 상대방이 말해줄 때도 있지만 말하지 않더라도 미리 조건을 생각해보는 습관이 있어야한다.
시스템의 모델을 만들어라
의뢰인의 요청을 이해한 후에는 간단하게 모델을 만들어보라. 모델을 만듦으로써 표현에 드러나지 않은 패턴이나 프로세스를 발견할 수 있고, 초기 질문과는 다른 제안을 할 수도 있다.
모델이 정교해질수록 추정은 정확해지지만, 정확히 비례하진 않는다. 따라서 적절한 수준을 골라야한다.
모델을 컴포넌트로 나눠라
다 만든 모델을 컴포넌트로 분해하여 서로 어떻게 상호작용하는지 수식으로 기술해야한다. 각 노드 별로 전체 시스템에 얼마나 기여하는지 매개변수를 찾을 수 있을 것이다.
각 매개 변수에 값을 할당하라
가장 큰 영향을 미치는 매개변수를 찾아서 이 매개변수의 값을 최대한 정확하게 산출해내라. ex) 대기열시스템에서는 실제 시간당 요청수를 측정하거나, 비슷한 시스템을 찾아봐라
답을 계산하라
주요 매개변수들의 값을 변경시켜가며 여러 번 계산해보고 어느 것이 가장 잘 들어맞는지 찾아내라. 이때 너무 정확한 값이 나오면 아마 잘못계산한 것이다.
여러분의 추정 실력을 기록하라
계산한 추정치를 기록하고 나중에 얼마나 잘 들어맞는지 평가해봐라.
PERT 기법
아무 문제 없다면 10시간, 현실적으로는 18시간, 날씨가 나쁘면 30시간 정도 걸릴거 같습니다.
낙관적 추정치와 가장 가능성 높은 추정치, 비관적 추정치를 갖는다. 과업은 의존성에 따라 네트워크 형태로 배열한 후, 간단한 통계 기법으로 전체 프로젝트의 예상 최소 및 최대 소요 시간을 계산한다.
단순히 값을 부풀리는 것보다, 범위로 추정하는 것이 오류를 피할 수 있는 좋은 방법이다. PERT 속의 통계가 범위로 표현한 불확실성을 분산시켜주고, 전체 프로젝트에 대하여 더 나은 추정치를 얻을 수 있다.
코끼리 먹기
기능을 매우 작은 단위로 나누어 다음과 같은 방식으로 개발하면 추정치는 점점 더 정확해질 것이다.
한 iteration이 끝났을때 리뷰를 거쳐 총 몇번의 iteration이 필요할 지, 각 iteration 마다 뭘할지 추측할 수 있을 것이다.
이 방법은 경영진에게 인기는 없지만 더 정확한 일정을 전달할 수 있다.
Comments powered by Disqus.
인쇄 가능한 문자로 이루어지고, 정보를 전달하기에 적합한 형식을 갖추어야한다. 또한 사람이 이해할 수 있어야한다.
1
+2
+
우유
+커피
+
1
+2
+
hlj;uijn bfjxrrctvh jkni’pio6p7gu;vh bjxrdi5rgvhj
+Field19=467abe
+
형식은 HTML, JSON, YAML 등 다양하다.
일반 텍스트는 데이터를 그 자체로만 이해할 수 있다. 이진포맷은 데이터를 읽는데 필요한 문맥과 데이터가 분리되어있어, 데이터를 읽는 문맥(애플리케이션 등)이 없으면 데이터는 무의미하다.
데이터를 서로 교환하는 시스템 간에 일반 텍스트는 하나의 표준이 된다.
셸 프롬프트를 통해 모든 도구를 불러다 쓸 수 있다. 도구를 조합하여 자동화 시스템을 만들 수도 있으며, 복잡한 명령어 수행도 가능하다. GUI 환경에서는 제공된 기능만 사용가능하지만, 셸에서는 원하는 기능을 만들 수 있다.
명령어 셸의 힘을 사용하라.
셸에 익숙해지면 생산성은 급상승한다.
평소 GUI 에서 수동으로 하는 작업이 있다면 셸로 자동화 해보자
에디터에 유창해지면 작업속도를 빠르게 할 수 있을 뿐 아니라, 에디터 사용법을 생각하지 않고도 작업할 수 있게 된다. 그러면 생각이 자유롭게 흘러갈 것이고 이는 프로그래밍에 큰 도움이 될 것이다.
유창해지기
에디터를 사용하면서 무언가 같은 일을 반복하는 경우가 있을 것이다. 이 작업을 발견하면 더 나은 방법(단축키)가 있는지 찾아봐라. 찾았다면 그것을 의식적으로 사용해봐라. 시간이 지나면 무의식적으로 사용할 수 있게 된다.
VCS은 시스템의 거대한 실행 취소 키와 같은 것으로, 정상적으로 컴파일 되는 지난 버전으로 돌려놓을 수 있도록 해준다. 이외에도 공동 작업, 배포 파이프라인, 이슈 추적, 팀 상호작용까지 아우를 수 있다.
디버깅에 관련된 몇몇 문제들을 살펴보고 버그를 찾아내는 일반적인 전략 몇가지를 알아보자
비난 대신 문제를 해결하라
버그가 누구의 잘못인지는 중요하지 않다. 다만 해결해야할 사람은 나라는 걸 명심하자
당황하지 마라
버그 재현하기
버그를 고치는 가장 좋은 방법은 버그를 재현할 수 있게 하는 것이다. 버그를 명령하나로 재현할 수 있으면 더 좋다.
코드를 고치기 전 실패하는 테스트부터
버그가 발생하는 상황을 다른 것들로부터 분리하면 버그를 고칠 힌트를 얻을 수도 있다.
그놈의 오류 메세지 좀 읽어라
프로그램이 죽었다면 빨간색 예외 메시지를 무시하지마라
프로그램이 죽는 것이 아니라 결과가 이상한 상황이면 어떨까? 디버거를 붙인 다음 실패하는 테스트를 이용하여 문제를 재현하라. 그리고 먼저 디버거에 잘못된 값이 나타나는 지부터 확인하라.
거대한 스택 트레이스가 눈앞에 있을때, 이중에 정확히 어떤 부분에서 문제가 되는지 찾기 위해서는 중간부터 이진 분할 기법으로 찾을 수 있다.
입력값이 따라 버그가 발생하는 경우에도 정확히 어떤 입력값이 범인인지 이진분할을 통해 찾을 수 있다.
어떤 릴리스에서 버그가 발생하는지 찾고 싶은 경우에도 문제가 없던 릴리스와 현재 버전 사이에서 이진분할을 시도할 수 있다.
로깅과 트레이싱
트레이싱 구문은 ‘여기까지 도달’이나 ‘x값 = 2’ 같은 정보를 화면이나 파일에 출력하는 작은 진단용 메시지이다. 트레이싱은 여러 프로세스가 동시에 작동하는 경우, 특히 시간이 중요한 시스템에서는 중요한 정보가 된다.
트레이싱 구문으로 남기는 메세지는 규칙적이어야하며 일관된 형식이어야한다.
고무 오리
누군가(고무 오리도 괜찮다)에게 문제를 설명함으로써 원인을 찾을 수도 있다. 차근차근 코드를 설명함으로써 당연히 여기고 넘어갔을 부분을 명시적으로 이야기하게 되고, 그러면 문제가 보일 수 있다.
소거법
OS, 외부 라이브러리, 외부 제품에서 오류를 찾지 마라. 대개 외부 제품을 잘못 사용하고 있다고 생각하는 것이 더 낫다. 설사 외부 제품에 문제가 있다하더라도 우리 애플리케이션 코드에 문제가 없다는 걸 확인은 해야한다.
만약 하나만 변경했는데 시스템의 작동이 멈춘다면, 관련이 없어보여도 변경된 그 하나에 책임이 있다.
때로는 외부 제품이 새로운 버전으로 바뀌면서 버그가 생길 수도 있다. 따라서 이럴때는 새 조건하에서 시스템을 다시 테스트해봐야한다.
당연하다고 생각되는, 버그가 없을거라 생각되는 부분에서도 버그가 생길 수 있다. 버그가 발생한 데이터로, 맥락으로 다시 그 코드를 테스트하라. 이 경계 조건하에서 증명하라.
가정하지 말라. 증명하라.
이러한 놀라운 버그를 발견했을때는 단순히 고치는 것을 넘어 어떻게하면 미리 잡을 수 있었을지를 생각해보라. 그리고 버그를 고치는 김에 동일한 버그가 있을 법한 다른 코드도 확인하고, 지금 고쳐라.
버그가 누군가의 잘못된 가정으로 발생했다면 이 문제에대해 전체 팀과 함께 토론하라. 한 사람이 오해했다면 다른 사람도 그럴 수 있다.
텍스트에 특화되어 처리해주는 도구가 있다 ex) sed, awk, 파이썬, 루비 등
이러한 텍스트 처리 도구는 중요한 기반 기술이며, 이러한 도구를 사용하면 유틸리티를 쉽게 만들거나, 아이디어를 프로토타입화 해볼 수 있다.
텍스트 처리 언어를 익혀라
회의에서 메모하거나, 작업 내용을 쓸때, 디버깅하다가 변수의 값을 적을때, 무엇을 어디 두었는지, 엉뚱한 생각을 기록할때 등 사용한다.
일지를 쓰면 좋은 점이 있다
Comments powered by Disqus.
여러분은 완벽한 소프트웨어를 만들 수 없다
실용주의 프로그래머는 자신의 실수에 대비한 방어책을 마련한다.
정확한 프로그램이란 자신이 하는 일을 적지도 많지도 않게 그만큼만 수행하는 프로그램이다. 이 주장을 문서화하고 검증하는 것이 DBC 이다.
선행조건
만약 호출자가 모든 선행조건을 충족하면, 루틴은 종료 시 모든 후행조건과 불변식이 참이 되는 것을 보장한다. 따라서 만약 호출자나 루틴 중 어느 한쪽이라도 계약을 지키지 못하면 예외가 발생한다. 그렇기에 선행 조건을 이용해서 사용자 입력값을 검증한다거나 해서는 안된다.
호출자, 루틴 모두 입력값을 검증하지 않음. 호출자는 그냥 호출하고, 루틴은 실행 도중 예외를 발생시킴. 선행 조건은 호출자가 루틴을 부른 뒤, 루틴 자체로 들어가기 전에 보이지 않는 곳에서 검사됨.
클로져, 엘릭서 등이 이러한 DBC를 잘 지원한다.
이 용어가 의미하는 일반적인 개념은 상태이다. 함수형 언어에서는 보통 상태를 함수에 넘긴 후 바뀐 상태를 결과로 받는다.
DBC는 방어적 프로그래밍보다 더 효율적이고 DRY하다. 방어적 프로그램은 아무도 데이터를 검증하지 않는 상황에 대비하여 모든 사람이 데이터를 검증한다.
코드를 작성하기 전에 유효한 입력범위가 무엇인지, 경계조건이 무엇인지, 루틴이 뭘 전달한다고 약속하는지, 무엇을 약속하지 않는지 나열하는 것만으로도 더 나은 코드를 작성할 수 있다. 코드에서 DBC를 지원하지 않으면 이정도가 최선이다. DBC는 설계 기법이고, 자동 검사가 없더라도 계약을 코드에 주석이나 단위 테스트로 넣어둘 수 있다
단정문
컴파일러가 계약을 검사하도록 하면 큰 도움이 된다. 몇몇 언어에서는 단정문으로 부분적으로 흉내낼 수 있다. 다만 단정문은 객체지향에서는 재정의 할때마다 일일이 작성하여야하고, 어떤 환경에서는 단정문에서 발생하는 예외를 무시하기에 완전한 방법은 아니다.
단정문이나 DBC 방식을 사용하여 선행조건, 후행조건, 불변식을 검증하면 더 일찍 멈추고 문제에 대한 정확한 정보를 얻을 수 있다.
시스템에서 영원히 변경되지 않는 요구사항. 비즈니스 정책처럼 유동적으로 변하는 것에 영향을 받으면 안된다.
ex)
프로그램에서 잘못된 것이 있을때 라이브러리나 프레임워크 루틴에서 먼저 잡아낼 수 있다. 빈 데이터를 받았거나, switch-case 문에서 default가 실행되었거나 하는 일이 발생할 수 있다. 이런 있을 수 없는 일이 발생했을때 우리는 그 사실을 알아야한다.
모든 오류는 정보를 준다. 오류 메시지 좀 읽어라.
어떤 개발자는 예외를 잡은 후 로그 좀 찍고 다시 예외를 올려보낸다. 하지만 실용주의 프로그래머는 굳이 잡지 않는다.
일찍 작동을 멈춰라
문제를 빨리 발견하면 가능한 빨리 시스템을 멈출 수 있다.
얼랭과 엘릭서는 “방어적 프로그램은 시간낭비고, 그냥 멈추는 게 낫다”라는 철학을 가지고 있다. 프로그램이 실패하면 멈추고, 이런 실패는 슈퍼바이저가 관리한다. 슈퍼바이저는 코드를 실행하고, 실패 시 처리할 책임이 있다. 슈퍼파이저가 실패하면 슈퍼바이저의 슈퍼바이저가 처리한다. 이러한 슈퍼바이저 트리 기법은 효과적이어서 고가영성, 결함 감내 시스템에서 얼랭이나 엘릭서를 채택하는 요인이 된다.
어떤 환경에서는 멈추는게 적절하지 않을 수 있다. 그러나 있을 수 없는 일이 발생했다면 프로그램은 더이상 유효하지 않다고 할 수 있기에 가능한 빨리 종료되는 것이 좋을 수 있다.
일반적으로 죽은 프로그램이 끼치는 피해는 이상한 상태의 프로그램이 끼치는 피해보다 적다.
단정문으로 불가능한 상황을 예방하라.
코딩할때 절대 일어나지 않을 일은 없다. 그런 생각이 든다면, 그것을 확인하는 코드를 추가하라. 다만, 오류처리를 해야하는 곳에서 단정을 대신 사용하지는 말라. 단정은 결코 일어나면 안되는 것들을 검사한다.
ex) 아래와 간은 코드는 작성해서는 안된다.
1
+2
+3
+
puts("Y나 N을 입력하세요")
+ch = gets[0]
+assert((ch == 'Y') || (ch == 'N'))
+
단정이 실패한다고 바로 프로세스를 종료시킬 필요는 없다. 예외를 잡고 오류처리 루틴을 실행할 수도 있다. 다만, 단정을 실패하게 한 잘못된 정보를 사용하지는 말라.
테스트는 모든 버그를 발견할 수 없고, 일어날 수 없는 일은 일어날 수 있다. 따라서 단정기능을 실제 환경에서 끄는 것은 문제가 될 수 있다.
성능상 이슈가 있다면 정말 문제가 되는 단정문만 꺼라.
리소스 사용을 위한 간단한 팁들이 있다.
자신이 시작한 것은 자신이 끝내라
리소스 사용을 시작한 곳에서 리소스 할당을 해제하여야한다.
지역적으로 행동하라
잘 모르겠으면 스코프를 줄여라.
예외를 처리할때 리소스 해제는 다루기 어려울 수 있다. 이때는 두가지 방법을 사용할 수 있다.
우리는 너무 먼 미래를 내다볼 수 없고 정면에서 벗어난 곳일수록 더 어둡다
작은 단계들을 밟아라. 언제나.
언제나 신중하게 작은 단계들을 밟아라. 더 진행하기 전에 피드백을 확인하고 조정하라. 너무 큰 단계나 작업은 하지 않게 될 것이다.
ex) 피드백이란?
너무 큰 작업이란 예언을 하는 모든 작업을 뜻한다. 불확실한 미래에 대비한 설계를 하기보단 언제나 교체 가능한 코드를 작성하여 대비하여라.
이번 장은 코딩할 때 발생할 수 있는 이슈들에 대비하기 위한 팁들을 소개하는 장이었다.
일어날 수 없는 일이란 없고, 이에 대비하기 위한 단정문에 대한 얘기가 많이 나왔다. 개인적으로 단정문을 사용한 적은 없어서 내용이 잘 이해가 되지 않았다. 평소에는 if 문을 통해 조건을 확인하고 거짓이면 함수를 종료하는 식으로 하였는데, 이 방법과 단정문을 사용한 방법에 어떤 차이가 있는지 확실히 이해가 되지는 않았다.
다만 몇가지 얻어갈 것은 있었다.
Comments powered by Disqus.
이번 장에서는 되돌릴 수 있는 의사결정을 내리는 구체적인 방법을 설명한다.
코드에서 나타나는 결합의 증상
1
+2
+3
+4
+5
+
public void applyDiscount(customer, order_id, discount) {
+ totals = customer.orders.find(order_id).getTotals();
+ totals.grandTotal = totals.grandTotal - discount;
+ totals.discount = discount
+}
+
이 코드를 지원하기 위해 앞으로 바꾸면 안되는 것들이 너무 많다. 기차의 객차가 연결되어있듯이 메서드나 속성들이 모두 연결되어있다. 이런 코드를 열차 코드라고 부른다.
만약 할인율을 변경해야할때는 어떻게 해야할까? totals 객체의 필드는 어디서든 변경할 수 있다. 따라서 다른 곳에서 필드 값을 바꾸는 부분이 있다면 모두 변경해야한다.
이것은 책임의 문제이다. totals 객체가 합계를 관리하는 책임을 져야하는데 그렇게 하고 있지 않다. 누구나 질의하고 갱신할 수 있는 다수의 필드를 가진 컨테이너일 뿐이기에 그렇다.
이를 고치려면 다음 원칙을 적용해야한다.
묻지말고 말하라
다른 객체의 내부 상태에 따라 판단을 내리고 그 객체를 갱신해서는 안된다. 즉, 할인 처리를 totals 객체에 위임해야한다.
1
+2
+3
+
public void applyDiscount(customer, order_id, discount) {
+ customer.orders.find(order_id).getTotals().applyDiscount(discount);
+}
+
더 개선하면 customer 객체에서 주문 컬렉션을 가져오지 말아야한다.
1
+2
+3
+
public void applyDiscount(customer, order_id, discount) {
+ customer.findOrder(order_id).getTotals().applyDiscount(discount);
+}
+
추가로 order 객체가 totals 객체를 가졌다는 걸 굳이 드러낼 필요도 없다.
1
+2
+3
+
public void applyDiscount(customer, order_id, discount) {
+ customer.findOrder(order_id).applyDiscount(discount);
+}
+
여기서 더 숨길 수도 있지만, 여기서는 customer와 order가 최상위 개념이다. 이정도는 드러내도 괜찮을 것이다.
데메테르 법칙
LoD(데메테르 법칙) : 어떤 클래스 C에 정의된 메서드는 다음 목록에 속하는 것만 사용할 수 있다.
다음 말이 좀 더 쉬울 수 있다.
메서드 호출을 엮지 말라
무언가를 접근할 때 .을 딱하나만 사용하도록 노력하라. 다만 엮는 것들이 절대로 바뀌지 않을 것 같다면 괜찮다. (언어에서 기본적으로 포함된 기능들. 외부 라이브러리는 아님)
연쇄와 파이프라인
함수에서 함수로 데이터를 넘겨가며 데이터를 변환하는 것은 열차사고와는 다르다. 숨겨진 구현 세부 사항에 의존하지 않기 때문이다. 하지만 결합이 생기지 않는 것은 아닌데, 한 함수의 결과물이 다음 함수의 입력 형식이어야하기 때문이다. 하지만 이러한 결합은 열차사고보단 문제가 되는 경우가 적다.
전역 데이터는 애플리케이션 컴포넌트 간의 결합을 만들어낸다. 전역 데이터는 시스템 전체에 영향을 줄 수 있다. 변경될 때 바꿔야할 곳을 전부 바꿨는지 확인하기 어려울 수 있다.
전역 데이터를 피하라.
싱글턴도 전역 데이터이다.
외부로 노출된 인스턴스 변수가 많은 싱글턴은 여전히 전역 데이터이다. 메서드 안으로 데이터를 숨기면 한층 낫긴하지만 설정데이터를 단 한 벌만 가지고 있는 것에는 변함이 없다.
외부 리소스도 전역 데이터다
수정 가능한 외부 리소스(DB, API 등)는 모두 전역 데이터다. 이러한 리소스들을 코드로 모두 감싸는 것이 좋다.
전역적이어야 할 만큼 중요하다면 API로 감싸라.
직접적으로 아는 것만 다루는 부끄럼쟁이 코드를 계속 유지하라. 그러면 결합도를 크게 낮출 수 있다.
이번 장은 반응적인 애플리케이션을 작성하는 법을 다룬다.
이벤트는 무언가 정보가 있다는 것을 의미한다. 정보는 외부에서 올 수도 있고, 내부에서 생길 수도 있다. 어디에서 온 것이든 애플리케이션이 이런 이벤트에 반응하고 하는 일을 조절하도록 만들면, 실세계에서 더 잘 작동하는 애플리케이션을 만들 수 있다.
이러한 애플리케이션을 만드는 다음 네가지 전략이 있다.
FSM은 작성해야하는 부분은 적지만, 한번 작성하면 이벤트를 어떻게 처리할지 한눈에 알기 쉽다.
감시자 패턴은 이벤트를 발생시키는 쪽인 감시대상과, 이벤트에 관심이 있는 감시자로 이루어진다.
감시자는 자신이 관심 있는 이벤트를 감시대상으로 등록한다. 보통은 호출될 함수의 참조도 같이 넘긴다. 추후 해당 이벤트가 발생 시, 등록된 감시자 목록을 보며 함수들을 일일이 호출한다.
감시자 패턴은 수십년간 잘 작동해왔지만 한가지 문제점이 있다. 바로 모든 감시자가 감시 대상에 등록해야하는 결합이 생긴다는 것이다. 또 감시 대상이 콜백을 직접 호출하기에 성능 병목이 생길 수 있다. 이러한 문제점은 게시-구독으로 해결한다.
감시자 패턴을 일반화한 것으로 감시자 모델의 결합도를 높이는 문제와 성능 문제를 해결한다.
게시-구독 모델은 게시자와 구독자가 있고, 채널로 연결된다. 채널은 코드 밖에 있으며, 게시자가 채널로 이벤트를 보내고, 구독자는 채널을 통해 이벤트를 받는다. 이는 비동기적으로 이루어진다.
이러한 게시-구독 모델은 대부분의 클라우드 서비스가 제공하기에 직접 구현할 필요는 없다. 또한 추가적인 결합이 없어 기존 코드를 수정하지 않고 이벤트 처리코드를 추가하거나 교체할 수 있다.
단점은 너무 많이 사용하는 시스템에서는 현재 어떤 일이 벌어지는지 파악하기가 어렵다는 것이다. 게시자가 이벤트를 보내고 어떤 구독자가 처리하는지 확인하기 어렵다.
반응형 프로그래밍 : 하나의 값이 바뀌면, 그 값을 사용하는 다른 값이 반응하는 것
스트림 : 이벤트를 일반적인 자료구조처럼 다룰 수 있게 해줌. 이벤트의 리스트. 이벤트를 처리하고, 조합하고, 골라내는 등 일반적인 자료구조처럼 다룰 수 있음
반응형 이벤트의 표준은 https://reactivex.io/ 에서 정의했다. 이 사이트에서는 언어에 무관한 원칙들을 정의하고 몇가지 공통 구현사항을 문서화 했다. 이를 구현한 것으로는 자바스크립트 RxJS 등이 있다.
후기)
스트림 부분은 잘 이해가 안갔음. 사용해본적이 없어서 정확히 어떤 것에서 큰 장점이 있는지 모르겠음. 한번 예제라도 건드려 보는게 좋을거 같다
이벤트는 모든 곳에 있다. 하지만 이벤트가 어디서 발생하든 이벤트를 중심으로 공들여 만든 코드는 일직선으로 수행되는 코드보다 더 잘 반응하고 결합도가 낮다.
모든 프로그램은 데이터를 변환한다. 코드에만 집중하여 핵심을 놓치지말고, 프로그램이란 입력을 출력으로 바꾸는 것이라고 생각하라. 이렇게하면 프로그램 구조는 명확해지고, 결합도 대폭 줄어들 것이다.
프로그래밍은 코드에 관한 것이지만, 프로그램은 데이터에 관한 것이다.
요구사항에서 입력과 출력이 무엇인지 찾으면 전체 프로그램을 나타내는 함수가 정해짐. 이후에는 입력을 출력으로 바꾸는 단계를 차례대로 찾으면 됨. (top-down 방식)
객체지향프로그래밍을 하다보면 데이터를 숨기고, 객체 안에 캡슐화해야한다고 생각한다. 이런 객체들이 서로 대화하며 서로의 상태를 변경하는데, 이런 방식은 결합을 많이 만들어내고, 이는 이후 유지보수가 어려운 코드를 만들게한다.
상태를 쌓아놓지말고 전달하라.
변환 모델은 데이터를 전체 시스템에 흩어놓는 대신, 데이터를 거대한 강으로 생각한다. 데이터는 기능과 동등해져서 파이프라인은 코드 -> 데이터 -> 코드 -> 데이터의 연속이다. 데이터는 특정한 함수들과 묶이지 않는다. 대신 우리 애플리케이션이 입력을 출력으로 바꾸어 나가는 진행 상황을 데이터로 자유롭게 표현하여 결합을 크게 줄일 수 있다. 어떤 함수든 매개변수가 다른 함수의 출력결과와 맞기만 하면 어디서나 재사용할 수 있다.
ex) 보통 객체지향에서는 두번째처럼하는데, 두번째는 앞단계에서 반환하는 객체에 다음 함수가 구현되어있어야한다. 만약 새로운 요구사항이 생겼을때, 두번째는 해당 객체에서 함수를 변경해야하는데 다른 코드에 영향이 갈까 두려움이 생길 것이다. 첫번째 방식은 그냥 한단계를 추가하면 된다.
1
+2
+3
+
const content = File.read(fileName);
+const lines = findMatchingLines(content, pattern);
+const result = truncateLines(lines);
+
1
+2
+3
+
const result = contentOf(fileName)
+ .findMatchingLines(pattern)
+ .truncateLines();
+
공통적으로 연쇄 변환 도중 변환 사이에 값을 날것으로 넘기지 않는 관례가 있다. Wrapper 역할을 하는 자료구조로 값을 싸서 넘긴다.
이런 개념을 이용하여 오류 검사를 변환 안에서 하거나, 변환 바깥에서 할 수 있다.
상속도 일종의 결합이다. 만약 최상위 클래스만 바꾸고 싶을때도 하위 클래스에서 어떻게 사용하고 있는지에따라 코드가 망가질 수 있다. 최상위 클래스의 담당자가 자기는 한 클래스의 변수명을 변경하였는데, 코드 전체가 망가지면 당황할 것이다.
상속을 타입을 정의하기 위해 사용하는 경우도 있다. 이때 클래스 계층도 같은 것을 사용할 수 있다. 하지만 클래스 사이의 미묘한 차이를 위해 계층을 계속 더하다보면 클래스 계층도는 매우 복잡해진다.
다중 상속을 지원하지 않는 것도 문제가 될 수 있는데, 어떤 클래스를 제대로 모델링하려면 다중 상속이 필요해질 수 있기 때문이다.
인터페이스
자바의 인터페이스 같은 것을 사용할 수 있다. 인터페이스는 단순한 선언이고, 아무런 코드도 만들지 않으며 단순히 선언된 메서드를 구현해야한다고 지시할 뿐이다. 또한 이들을 타입으로 사용할 수 있고, 해당 인터페이스를 구현한 클래스라면 무엇이든 그 타입과 호환된다.
다형성은 인터페이스로 표현하는 것이 좋다.
1
+2
+3
+4
+
public interface Locatable {
+ Coordinate getLocation();
+ boolean locationIsValid();
+}
+
위임
상속을 사용하게 되면 딱 2개의 메서드만 필요해도 부모의 20개의 메서드가 한번에 딸려온다. 클래스가 자신의 인터페이스를 제어할 수 없게 되는 것이다.
대신에 위임을 사용하면 클래스는 필요한 것만 노출할 수 있다.
서비스에 위임하라. Has-A 가 Is-A보다 낫다.
믹스인, 트레이트, 카테고리, 프로토콜 확장 등
언어마다 이름은 다르지만, 클래스나 객체에 상속을 사용하지 않고 새로운 기능을 추가하여 확장하고 싶을 떄 사용하는 기능이다.
1
+2
+3
+4
+5
+6
+7
+
mixin CommonFinders {
+ def find(id) {...}
+ def findAll() {...}
+}
+
+class AccountRecord extends BasicRecord with CommonFinders
+class OrderRecord extends BasicRecord with CommonFinders
+
믹스인으로 기능을 공유하라
예를들어 검증을 적용할 수 있는 여러 계층이 있을때, 각 상황에 맞는 전문화된 클래스를 믹스인을 사용하여 만들 수 있다.
1
+2
+3
+
class AccountForCustomer extends Account with AccountValidations, AccountCustomerValidations
+
+class AccountForAdmin extends Account with AccountValidations, AccountAdminValidations
+
상황에 따라 상속보다 더 나은 방법이 있을 것이다. 타입 정보를 교환하고 싶은건지, 기능을 더하고 싶은건지, 메서드를 공유하고 싶은건지에 따라 다르다. 우리의 목표는 의도를 가장 잘 드러내는 기법을 사용하는 것이다. 그리고 정글 전체를 끌어들이지 않도록 조심하다
프로그램 출시 이후 변경될 것이라 생각되는 값들은 프로그램 외부에서 관리하라. 이렇게하면 프로그램을 조정할 수 있게 된다.
외부 설정으로 애플리케이션을 조정할 수 있게하라.
소스 코드 본체 바깥에 표현할 수 있는 것을 찾아라.
대부분의 프레임워크에서는 설정을 일반 파일이나 데이터베이스 테이블로 관리한다. 어떤 형태로 사용하든 설정을 자료구조 형태로 불러온다. 보통 처음 애플리케이션이 실행 될 때 읽어올 것이다.
보통 이 설정을 전역에서 접근할 수 있도록 하는데, 그것보다는 API 뒤로 숨기는 것이 좋다. 그러면 설정을 표현하는 세부 사항으로부터 코드를 떼어놓을 수 있다
설정을 외부에서 관리하긴하지만, 일반 파일이나 데이터베이스가 아니라 서비스 API 뒤에서 관리하는 방식이다. 여기에는 몇가지 장점이 있다.
설정 정보를 바꾸기 위해 코드 빌드가 필요없는 방식이다.
지나치게 모든 변수를 설정할 수 있게하지는 말라.
여담
실무를 경험해본 결과 서비스형 설정이 확실히 좋았다. 이러한 값들은 빌드가 필요없이 바로 참조가 되어 이슈가 발생했을 경우 곧바로 대응을 할 수가 있기 때문이다.
물론 스프링에서 properties 파일과 같은 정적 설정도 장점이 있다. 설정 정보의 성격에 따라 적절히 분리해서 관리하면 될 거 같다.
이번 장은 전체적으로 결합도를 줄이는 것에 집중한 장이다.
topic 28 : 책임을 분명히하고, 자신이 직접적으로 아는 것만 다루는 방식을 통해 결합도를 줄일 수 있다. 전역 변수도 일종의 결합인데, 전역변수 변경 시 필요한 부분을 모두 바꾸었는지 확인하기 어렵기 때문이다.
이 토픽에서는 데메테르 법칙에 대해서도 얘기하였는데, 쉽게 풀이한 “무언가에 접근할 때 .을 두번 이상 사용하지 마라”라는 팁은 이해하기가 쉬웠다.
topic 29 : 이벤트를 구현하는 방식에 네가지 방식(유한 상태 기계, 감시자 패턴, 게시 - 구독, 반응형 프로그래밍과 스트림)에 대해 설명하였다. 유한상태기계를 작성하면 이벤트를 어떻게 다뤄야하는지 알기 쉽다는 팁이 도움될거 같다.
topic 30 : 프로그램은 결국 데이터를 변환하는 것이고, 데이터를 중심으로 구조를 생각하면 어떻게 파이프라인을 구성해야할지 한눈에 보인다.
topic 31 : 상속은 결합을 만들어내기에 사용을 지양해야한다는 파트이다. 상속 대신 인터페이스, 위임, 믹스인 등을 통해 기능을 추가하는 것이 좋다고 한다. 개인적으로 동감하는 파트이고, 상속은 프레임워크에서 제공하는 것 외에는 사용을 자제하는 것이 좋다고 생각한다.
topic 32 : 설정을 소스 본체 바깥에 저장하는 방식을 설명한다. 개인적으로 서비스형 설정이 변화에 대응이 쉬워 더 선호한다.
Comments powered by Disqus.
시스템이 커지면 동시성은 필수다. 어떤 일을 할 때, 한번에 하나씩 순차적으로 수행 하면 시스템이 매우 느려질 것이기 때문이다.
따라서 코드 간의 결합 이외에도, 시간적 결합을 깨는 것도 중요하다.
코드를 짜다보면 순차적 사고를 하기 마련이다. 하지만 유연성과 동시성을 확보하기 위해 시간이나 순서에 의존하는 시간적 결합을 끊어야한다. 그럼 시간 관련 의존성을 줄일 수 있고, 더 빠르고 안정적인 시스템을 만들 수 있다.
동시에 일어나도 되는 일과 반드시 순서대로 일어나야하는 일을 구분하기 위해, 활동 다이어그램 등을 사용하여 작업 흐름을 모델화 할 수 있다.
활동 다이어그램을 통해 동시에 작업할 수 있는 부분들이 있다. 이 중에서 데이터베이스 접근, 외부 서비스 요청 등 우리 코드가 아닌 곳에서 시간이 걸리는 일을 할 때, 우리 코드는 다른 작업을 할 수 있을 것이다.
큰 작업을 독립적인 부분 작업으로 나누어 여러 프로세서에서 동시에 일을 처리할 수 있다.
공유 상태는 틀린 상태다
상태가 공유되면 동시성을 구현할 때 프로그램 오류가 발생할 수 있다. 따라서 어떤 상태가 있다면 이를 원자적으로 갱신하여야한다. 여기에는 다음 방법들이 있다.
어떤 작업을 수행할 때, 여러 리소스가 동시에 필요하면 공유 상태 관리는 더 복잡해진다. 하지만 이때도 여러 리소스를 하나의 리소스로 보고, 이 리소스에 접근하는 코드를 모듈로 옮긴 후, 클라이언트는 그 리소스를 달라고 요청하면 그림이 간단해진다. 클라이언트가 여러 리소스를 직접 호출하는 것보다 훨씬 간단하다.
수정 가능한 리소스를 공유하는 애플리케이션 코드 어디에서나 동시성 문제가 발생할 수 있다. 여기에는 한가지 팁이 있다.
불규칙한 실패는 동시성 문제인 경우가 많다.
액터
자신만의 비공개 지역상태를 가진 독립적인 가상 처리 장치. 우편함을 하나씩 보유하고 있고, 메세지를 받으면 차례대로 처리한다. 메세지를 처리할 때 액터는 다른 액터를 생성하거나, 메세지를 보낼 수 있고, 새로운 상태를 생성할 수 있다.
위 특징들로 액터들은 아무것도 공유하지 않고 비동기적으로 동시에 실행된다. 따라서 동시성을 다루는 코드도 필요없다.
공유 상태 없는 동시성을 위하여 액터를 사용하라
칠판은 일종의 자유방임주의적 동시성으로, 독립된 프로세스, 에이전트 등이 수집한 사실을 붙이고 누군가는 떼어내기도 한다. (ex : 린다, JavaSpace, T Spaces 등)
복잡한 규칙과 과정을 준수해야하는 대출 시스템에서 사용할 수도 있는데, 어떤 사실이 칠판에 올라가면 규칙 엔진이 돌아가서 적절한 규칙을 발동시키면 된다.
카프카와 같은 메시징 시스템은 단순히 메시지를 보내는 것 이상으로 이벤트 로그를 통한 영속성지원, 패턴 매칭으로 메시지 조회를 지원한다. 따라서 메시징 시스템을 칠판으로 사용할 수도 있다.
아키텍처에서 액터, 칠판, 마이크로서비스를 사용하면 애플리케이션에서 생길 수 있는 동시성 문제를 예방할 수 있다. 하지만, 이런 접근 방식은 많은 동작이 간접적으로 일어나서 분석이 어렵다.
이에 대한 기법으로, 처리를 시작할 때 고유한 ‘추적 아이디 (Trace Id)’를 붙일 수 있다.
Comments powered by Disqus.
코딩은 설계내용을 단순히 코드로 바꾸는 과정이 아니다. 이번 장에서는 프로그램을 정확하게 동작하게 하려면 어떻게 해야하는지 다룬다. 운전할 때와 마찬가지로 코딩도 반복적인 일이지만 정신을 늘 기민하게 유지하여야한다.
경험이 늘어날수록 무의식적인 지식이 쌓여져가고, 본능적으로 싸늘한 느낌을 느낄 때가 있다. 이럴 때는 그런 반응을 인지하고, 왜 그런 느낌이 드는지를 알아내야한다. 여기서는 그런 느낌이 드는 몇가지 흔한 상황을 살펴보자.
어떤 일을 시작할때 두려움을 느끼는 경우가 많다. 이 원인은 두가지가 있다.
어떤 날은 코드를 짜는 것이 매우 힘들 수 있다. 이때는 억지로 계속 작성하지말고, 무언가 문제가 있는지 생각해보자. 구조나 설계가 틀렸는가? 엉뚱한 문제가 아닐까?
여러분 내면의 파충류에게 귀 기울여라
일단 하고 있는 일을 멈춰라. 약간의 시간을 두고 뇌가 정리를 할 수 있게 해라. 밥을 먹거나 산책을 해도 된다. 그러면 해결책이 떠오를 때가 있다.
만약 이래도 안되면 문제를 표면으로 끄집어 내라. 작성하는 코드에 대해 그림을 그려보거나 동료에게 설명해봐라. 고무오리도 좋다.
이렇게하여도 해결이 안된다면 뇌에게 우리가 하는 일이 문제가 없다는 걸 알려줘야한다. 프로토타이핑의 시간이다.
이렇게하면 불안감은 사라지고 빨리 해치우고 싶다는 생각이 들 것이다. 그래도 안된다면 다시 첫단계(휴식)부터 시작하라.
다른 사람의 코드를 읽으면서 중요해보이는 곳에 메모를 하고, 실험을 할 수 있다. 이상한 부분이 있다면 적어놓고 패턴을 찾아보아라. 만약 그렇게 코드를 작성한 이유를 찾는다면 코드를 이해하기가 훨씬 쉬워진다. 다른 사람의 패턴을 여러분이 사용할 수도 있다.
설계, 요구사항 등 코드 외적인 것에서도 직감이 발동할 수 있다. 이 직감에 귀를 기울이고 적극적으로 생각하라
몇번 돌려보고 문제가 없는거 같아 코딩을 계속하다보면 어느순간 문제가 생기는 경우가 있다. 이경우 원인을 파악하기 힘든데, 왜 코드가 잘 돌아갔는지 몰랐기 때문이다. 이처럼 우연에 맡겨 코딩을 하는 경우가 있다
입력값이 얼마나 큰 값이 들어올지 스스로 물어봐야한다. 숫자가 외부 요인에 따라 달라지면, 시간/메모리를 다시 계산하라
입력 데이터가 작을땐 선형적이어도, 크면 스래싱이 발생하면서 수행시간이 폭증할 수 있다. 이론적으로 추정을 이미 했더라도 실무적으로 문제가 생길 수 있다
여러분의 추정을 테스트하라
하지만 언제나 가장 빠른 알고리즘이 최고가 아니다. 복잡한 알고리즘을 사용한만큼 디버깅, 유지보수의 시간이 늘어날 수 있다.
성급한 최적화를 조심하고, 그 알고리즘이 정말로 병목인지 먼저 확인하라
밖으로 드러나는 동작은 그대로 유지한 채 내부 구조를 변경함으로써 이미 존재하는 코드를 재구성하는 체계적 기법
- 마틴 파울러
무언가를 더 많이 알게 되었을때, 더이상 코드가 잘 맞지 않을때, 무엇이든 잘못되었다는 생각이 들 때 수행한다.
현실적인 문제
일정의 압박은 리팩터링을 하지 않는 변명이 될 수 있다. 하지만 리팩터링을 하지 않으면 추후 더 큰 문제가 될 수 있다. (마치 종양처럼)
일찍 리팩터링하고, 자주 리팩터링하라
문제가 작을때 코딩하는 동안 함께 진행하는 편이 더 쉽다.
리팩터링의 본질은 재설계이다. 하지만 거대한 코드를 헤집어 놓으면 더 안좋은 상황이 생길 수 있다. 리팩터링은 천천히 신중하게 진행해야하는 작업이다. 관련하여 마틴 파울러의 조언이 몇가지 있다
테스트는 버그를 찾기 위한 것이 아니다
테스트의 이득은 테스트를 실행할 때가 아니라, 테스트를 생각해내고 작성할 때 생긴다
테스트 작성에 대해 생각하는 것은 코드의 작성자가 아니라 사용자인 것처럼 메서드를 외부의 시선에서 볼 수 있게 해준다.
테스트가 코드의 첫번째 사용자다
다른 코드와 긴밀하게 결합된 메서드는 테스트하기가 어렵다. 메서드를 실행하기도 전에 환경 구성을 한참해야하기 때문이다. 따라서 테스트하기 좋게 만들면 결합도도 내려간다.
또 무언가를 테스트하려면 그것을 이해해야한다. 코딩을 시작하기 전에 경계조건 테스트를 생각한다면 함수를 단순하게 만드는 패턴을 찾을 수 있을 것이다. 테스트해야하는 오류조건을 먼저 생각하면 그에 맞게 함수구조를 잡을 것이다
테스트 주도 개발
TDD는 이를 매우 짧은 주기로 반복하여 끊임없는 테스트 작성과 통과를 반복한다. 이는 테스트를 막 배운 사람에게는 효과가 크다. 하지만 이 TDD의 노예가 된 사람들이 있다.
TDD를 실천하되, 너무 중독되지는 말자
TDD는 전체 문제를 작은 단계로 나누어 접근하도록 해주지만, 반대로 전체 문제를 보지 않고 작은 문제에 매몰 되게도 할 수 있다.
테스트를 진행할 때마다 목적지를 항상 떠올려야한다
소프트웨어를 컴포넌트로 나누어 조립하여 구성하는 방식은 자주 쓰인다. 하지만 이때 각 컴포넌트는 연결되기 전에 철저하게 테스트 되어야한다.
이때 각 컴포넌트는 단위 테스트를 거칠 수 있다. 단위 테스트를 통과한다면 조립하더라도 각 개별 부분은 정상 동작한다고 믿을 수 있다.
이때 단위테스트로 계약을 지키는지, 코드로 표현된 계약이 우리가 생각한 것과 일치하는지 확인할 수 있다. 다양한 종류의 케이스와 경계조건 케이스를 가지고 테스트 해볼 수 있다.
임시테스트는 console.log() 나 디버거 등을 직접 실행해보면서 입력하는 코드 조각일 수 있다. 디버깅이 종료되면 이러한 임시테스트는 정식 테스트의 형태로 만들어 놔야한다.
배포한 후에도 테스트할 일이 자주 생긴다. 이때 디버깅을 쉽게하기 위해 다음 방법을 사용할 수 있다
우리가 테스트 안하면 사용자가 테스트하게 된다. 선택지는 세개다
제대로 된 테스트 문화를 가졌다면 모든 테스트가 항상 통과해야한다. 실패해도 무시하는 테스트가 하나 생기면 점점 더 많이 무시하게 된다
우리가 작성한 코드를 스스로 테스트하다보면, 잘못된 가정하에서 테스트를 할 수 있다. 하지만 그렇다고 다른 사람에게 테스트를 맡기면, 테스트를 생각할때 나오는 이점이 없어진다.
이 문제를 해결하기 위해서는 컴퓨너에게 테스트를 맡기는 방법이 있다.
속성 = 계약 + 불변식
코드에서 속성을 찾아내서 테스트 자동화에 사용할 수 있는데, 이걸 속성 기반 테스트라고 한다.
속성 기반 테스트로 가정을 검증하라.
파이썬에서는 Hypothesis 라이브러리와 pytest로 이런 테스트가 가능하다.
대부분의 속성 기반 테스트에서는 데이터를 어떻게 생성할지 지정하는 작은 언어가 있다
1
+2
+
@given(some.integers())
+@given(some.integers(min_value=5, max_value=10).map(lambda x: x * 2))
+
속성 기반 테스트는 입력을 생성하는 규칙과 출력을 검증하는 단정문만 설정한 채 알아서 동작한다. 따라서 정확히 어떤 일이 일어날지 모른다.
만약 속성 기반 테스트가 실패했다면 테스트 함수가 어떤 매개변수를 사용했는지 알아낸다음 그 값을 이용하여 단위테스트를 추가하는 것이 좋다.
단위 테스트는 메서드의 첫번째 사용자로서 코드에 대해 생각하게 해준다.
속성 기반 테스트는 코드를 불변식과 계약이라는 관점으로 바라보게 해준다. 이로써 경계조건은 줄어들고 데이터의 일관성을 해치는 함수는 도드라진다.
둘은 서로를 보완하며 서로 다른 문제를 해결해준다.
코드를 완성한 이후 코드가 잘못될 수 있는 경우를 찾아봐라. 그리고 각 경우에 대한 단위 테스트를 추가해야한다
하지만 이렇게 내부 오류를 찾는것만으로는 불충분하다. 외부의 공격에도 대비해야한다
암호학은 상식과 맞지 않을 수 있다.
암호화의 첫번째이자 가장 중요한 규칙은 절대 직접 만들지말라는 것이다. 암호의 세계에서는 사소한 오류가 전체 암호화를 무용지물로 만들 수 있다. 이미 만들어진 프레임워크를 사용하라. (자주 업데이트 되는)
로그인과 같은 인증서비스도 외부 서비스를 사용하면 외부에서 대신 고민해준다. 따라서 가능하면 해당 서비스를 사용하는 것이 좋을 수 있다
코드에서 하는 역할에 따라 이름을 지어야한다.
예시 1 : 상품 고객 변수 이름을 user 대신 customer나 buyer로 하면 무언가를 구매하려는 사람으로 인식할 수 있게 된다.
예시 2 : 할인을 적용하는 메서드
1
+
public void deductPercent(double amount)
+
이 코드에는 아래 질문점이 생긴다
아래처럼 고칠 수 있다.
1
+
public void applyDiscount(Percentage discount)
+
반복문의 i, j 는 사용하지말라는 얘기가 많지만 C 프로그래밍에서는 많이 사용되는 변수명이다. 물론 해당 관습이 없는 곳에서는 사용하지말라
camelCase나 snake_case도 해당 분야의 문화를 존중해야한다.
팀의 모든 사람이 각 단어의 뜻을 알고 일관성 있게 사용해야한다. 팀에서 특별한 의미가 있는 단어를 모은 사전을 만들 수도 있다.
코드는 계속 변화하며 의미는 계속 변경된다. 그에 맞춰 부지런히 이름을 변경하지 않으면 잘못된 이름이 계속 사용될 수 있다.
이번 장에서는 일반적으로 코딩을 하면서 발생할 수 있는 위험 신호(?)를 어떻게 잘 감지하고, 잘 활용할 수 있는지에 대해 다루었다
Comments powered by Disqus.
자신이 뭘 원하는지 정확히 아는 사람은 아무도 없다.
무엇을 다루든 정확한 명세란 것은 거의 불가능하다. 이때 프로그래머는 사람들이 자신이 무엇을 원하는지 깨닫도록 도와줄수 있다.
프로그래머는 사람들이 자신이 원하는 바를 꺠닫도록 돕는다.
신입 개발자의 실수는 요구사항을 받고 바로 해결책을 구현하는 것이다.
어떤 요구사항을 받았을때 여러 경우를 생각하고 되물어 확인하자 (사소하여 짜증날거 같은 질문이라해도)
우리의 역할은 기획자의 말을 해석해서 그로 인한 영향을 다시 알려주는 것이다.
요구사항은 피드백을 반복하며 알게 된다.
기획자는 우리의 피드백을 받고 자기 생각을 가다듬는다. 이때 피드백을 말로 표현하기 어려울 수도 있다. 그때는 프로토타입이나 목업으로 대화를 진행할 수 있다.
이러한 요구사항 가다듬기는 프로젝트가 끝날때까지도 이어진다. 따라서 프로젝트 전체를 요구사항 수집 단계로 봐야하고, 짧은 주기로 반복하여 피드백을 자주 받는 것이 좋다.
요구사항 문서는 의뢰인을 위한 것이 아니다. 거대한 요구사항 문서를 만들어도 의뢰인은 읽지 않을 것이다. 요구사항 문서는 개발자를 위해서 세부사항을 명시한 것이다.
요구사항 문서화는 계획을 위해서도 좋다. 짧은 설명을 인덱스 카드 형식으로 하여 상태에따라 이리저리 옮길 수 있게 할 수 있다. 설명이 부족할 수도 있는데, 이것을 이용해서 개발자로 하여금 의뢰인에게 질문을 던지게 할 수 있다
요구사항을 만들 때는 추상적으로 작성하는 것이 좋다. 모호하게 적으라는 것이 아니라, 의미론적 불변식을 요구사항으로 잘 갈무리하고, 구체적인 작업방식은 정책으로 문서화해야한다.
요구사항은 아키텍처나 설계가 아니며 필요를 표현하는 것이다
요구사항이 조금씩 늘어나는 것을 막는 방법은 피드백이다. 정기적으로 피드백을 주고받아 요구사항이 늘어날 떄의 영향을 의뢰인이 체험할 수 있도록 하라. 피드백을 주고 받아 추가되는 요구사항을 위해 무엇을 희생 가능할지 함께 고민할 수 있다
프로젝트에서 사용하는 용어를 모은 사전을 만들어라. 최종 사용자에서 말단 직원까지 프로젝트에 참가하는 모든 사람이 동일한 용어를 사용해야한다.
풀기 어려운 문제는 상상 속이 아닌 실제 제약 조건을 알아내고 그 속에서 해법을 찾아야한다. 어떤 제약 조건은 절대적이라 따라야하지만, 어떤 조건은 단순한 지레짐작이다.
생각의 틀을 벗어나지 말고, 틀을 찾아라
모든 선입견을 의심하고 그것이 진짜 바꿀 수 없는 제약인지 가늠해봐야한다. 풀리지 않는 문제를 마주하면 모든 해결책을 생각해봐라. 아무리 쓸모없고 바보 같더라도 버리지 말고 잘 모아두고 왜 쓸모없다고 생각했는지 설명해봐라
어려운 문제를 마주하고 그것이 풀리지 않는다면 잠시 다른 일을 하라. 무의식적으로 문제가 해결될 수도 있다.
간단히 표현하면 딴짓을 한 사람이 의식적으로 노력한 사람보다 복잡한 해결과제를 더 잘 해냈다.
- 사이콜로지 투데이
만약 손을 놓기 싫다면 다른 사람과 이야기 해봐라
무의식적으로 문제를 해결하기 위해서는 원료가 많아야한다. 엔지니어링 일지처럼 일상적인 작업을 할 때 무엇은 잘되고 무엇은 안되는지 피드백을 줄 수 있다.
사람들은 모두 다르기에 다른 배경을 가지고 문제를 푸는데도 다른 접근방법을 사용한다. 주어진 문제에 집중하는 정도나 주의력도 제각각이다. 입력을 담당한 개발자는 문법이나 코딩 스타일에 집중할 수 있고, 다른 개발자는 문제를 더 높은 수준에서 생각할 수 있다.
뇌의 용량은 한정되어있고, 문법이나 코딩스타일에 맞추는 일은 뇌 용량을 많이 소비한다. 두번째 사람이 전체적인 문제를 생각하는 뇌를 맡는다. 또 두번째 사람의 존재로 인해 안좋은 습관이나 꼼수를 덜 쓰게 된다
페어프로그래밍을 넘어 더 많은 사람이 참가할 수도 있다. 이때는 의뢰인처럼 개발팀의 일원이 아닌 사람도 참가할 수 있다
처음에는 어색할 수 있지만 조금씩 시도해볼 수 있다. 이렇게 일하는 동안에는 기술적인 면 외에 인간적인 측면도 신경써야한다.
너무 무턱대고 시도하지는 말고, 사례 보고서를 찾아보고 연구하라. 장점과 걱정되는 점에 대해 감을 잡아라.
코드에 혼자 들어가지는 말라.
애자일은 명사가 아니다. 애자일은 무언가를 하는 방식이다.
애자일은 일하는 방식이지 우리 자신이 아니다. 애자일 선언에서 언급된 애자일의 가치는 아래와 같다.
우리는 소프트웨어를 개발하고, 또 다른 사람의 개발을 도와주면서 소프트웨어 개발의 더 나은 방법들을 찾아가고 있다. 이 과정에서 우리는 다음과 같은 가치들을 찾아냈다.
- 공정과 도구보다 개인과 상호작용
- 포괄적인 문서보다 작동하는 소프트웨어
- 계약 협상보다 고객과의 협력
- 계획을 따르기보다 변화에 대응하기
왼쪽도 가치가 있지만 오른쪽에 더 높은 가치를 둔다
애자일 선언은 고정불변의 문서라기보다는 만들어가는 과정에 대한 제안이다.
애자일, 즉 기민함은 변화에 대응하는 것이다. 소프트웨어를 개발할 때 따라야하는 단 한 가지 계획이란 없다. 애자인 선언의 네가지 가치중 세가지가 이처럼 피드백을 수집하고 그에 대응하라는 얘기다.
이 가치들은 무엇을 하라는 것이 아니라, 할일을 결정할 때 무엇을 추구할지 알려주는 것이다. 그 결정은 상황에 따라 다르다.
피드백고리를 만들어라. 이름 짓기 같은 작은 고리라도 피드백고리를 반복하는 것이 중요하다. 매번 작은 단계를 진행하고, 평가하고, 고칠 것이 있으면 고쳐라
이 과정이 설계를 주도한다. 좋은 설계는 바꾸기 쉬운 결과물을 만들기 때문에 애자일이 잘 작동하려면 좋은 설계를 만들어야한다.
프로젝트 전, 진행 중에 필요한 팁들을 알려준 장이다.
Comments powered by Disqus.
실용주의 팀은 작아야한다. 구성원은 대략 10~12명이고, 구성의 변경이 적어야한다. 서로를 신뢰하고 의존할 수 있어야한다.
작고 안정적인 팀을 유지하라
원하는 바를 실현할 수 있는 환경에 실용주의 개발자 그룹이 만들어진다면, 자신들에게 맞는 역학을 금방 만들고 또 다듬어 낼 것이다
자질구레하게 계속되는 문제를 고치는데 열정을 유지하기 힘들다
팀 전체가 깨진 창문을 용납해서는 안된다. 반드시 제품의 품질에 책임을 져야한다.
팀은 개인보다 더 삶은 개구리가 되기 쉽다. 모든 사람이 적극적으로 환경 변화를 감시하도록 권장하라. 범위의 확장, 일정 단축, 추가기능 등 기존에 인지하던 것과 다른 것들을 늘 깨어서 의식해야한다.
변화를 거부하지 않아도 된다. 단지 그 변화를 인식하고는 있어라
성공을 원하는 팀이면 자신들의 지식과 기술에 투자해야한다. 이때는 계획을 세워서 해야하는데, 시간이 남으면 하겠다는 안하겠다는 말과 같다. 계획을 세울 때 기능개발로만 몽땅 채우지말라. 대신에 아래 것들을 고려하라
팀이라는 것 역시 더 큰 조직의 일부이다. 외부사람들에게 과묵한 프로젝트팀이야말로 최악이다. 나머지 팀들과 의사소통하라.
팀원 간의 중복된 일을 없애기는 어렵다. 좋은 의사소통을 통해 이 문제를 피할 수 있다. 팀 동료에게 질문을 하고 거의 즉각적으로 답을 받을 수 있어야한다. 질문을 하기위해 회의를 기다려야하면 의사소통이 어려워진다.
DRY를 지키려면 서로 관심을 유지하라
시스템의 끝에서 끝까지 전체에 걸쳐있는 단일 기능을 개발하라. 이 작업을 맡은 모든 구성원이 함께 일하는 것이 편안하고 익숙해야한다.
일상적으로 반복되는 일을 자동화하라. 수작업으로 하는 것보다 훨씬 일관적이고 정확하다
각 팀원이 자신의 방식대로 빛나게 하라. 프로젝트의 가치를 만들어 내기에 딱 좋을 만큼의 구조를 제공하라
화물 숭배에 빠지지 말라
특정한 개발 방법이나 프레임워크를 굳이 사용하는 이유가 무엇인가? 유명해서인가? 아니면 현재 프로젝트 또는 팀에 잘 맞아서인가?
유행하는 것이 아니라 실제로 잘 맞는 것을 사용하라
유명한 팀들이 성공한 방식을 따라하기보다는 맥락을 보고 잘 맞는 것을 사용하라.
잘 맞는 방법론이더라도 다 정확히 따라야할 필요는 없다. 좋은 것만 취하고 안맞는 것은 버려라
진짜 목표는 “에자일을 한다”, “린을 한다” 가 아니라 사용자에게 작동하는 소프트웨어를 제공하는 것이다.
CICD가 불가능한 목표라고 생각하는 팀은 많다. 하지만 모든 목표가 그렇듯 계속 올바른 방향을 바라보는 것이 중요하다. 제품 출시 주기를 조금씩 줄여나가라. 최종적으로는 필요할때마다, 사업적으로 의미 있을때마다 배포하는 것이 목표이다.
사용자에게 필요할 때 제공하라
이런 지속적 개발을 위해선 feature 브랜치가 아니라 main 또는 trunk 브랜치에서 개발해야한다. 그리고 사용자에게 시범적 기능을 제공할 때는 ‘기능 스위치’ 같은 기법을 활용하라
생각없이 행할 수 있는 중요한 작업의 수가 늘어남에 따라 문명은 발전한다
- 엘프리드 노스 화이트헤드
프로젝트에서 거듭 발생하는 일상적인 작업은 모두 자동화해야한다. 수작업은 운에 맡기는 것이고, 반복 가능성도 보장 받지 못하다. 그 작업의 절차를 여러 사람이 서로 다르게 해석할 여지가 있으면 더욱 그렇다
여기에는 아래와 같은 프로젝트를 견고하게 만들어주는 도구들이 있다.
소프트웨어 프로젝트 자체가 아니라, 사용자가 실제로 기대하는 것에 진짜 의미가 있다. 소프트웨어는 이런 목적을 달성하기위한 수단일 뿐이다.
이런 숨겨져있는 프로젝트 배후의 가치에 대해 사용자가 기대하는 바의 일부가 드러났다면, 이런 기대를 어떻게 충족시킬 수 있을지 고민하라
사용자를 기쁘게하라. 그저 코드만 내놓지 말라
실용주의 프로그래머는 책임을 회피하지 않는다. 자신의 코드만 좋게보지말고 동료들의 코드를 깎아 내리지 말라. 경계심 때문에 자신의 코드를 방어하지 말라. 같은 맥락에서 다른 사람의 코드를 존중해야 한다.
자신이 만든 코드에 서명을 할 수 있어야하고, 품질을 보증할 수 있어야한다.
소프트웨어는 의도치 않게 디스토피아를 만들어낼 수 있다. 코드를 작성할 때마다 두가지 질문을 던져라
어떤 창의적인 발상은 윤리적 행위의 경계선을 달리기 시작할 때가 있다. 자신이 그런 프로젝트에 참가했다면, 그 프로젝트의 후원자와 같은 책임이 있다.
이번 장은 프로젝트 전체적인 관점에서의 실용주의 팁들을 던진 장이다. 말단 개발자인 나로서는 실천하기 어려운 것들도 많지만, 몇가지는 머리 속에 새겨뒀다가 제안을 할 수 있을 거 같다.
topic 50, 52, 53은 태도에 대한 얘기로 본다. 이부분은 머릿속에 기억하여 항상 실천하려는 자세를 취할 수 있다.
topic 49, 51 에서도 기억하면 팀 또는 프로젝트에 개선할 부분을 더 잘 찾을 수 있을 거 같다.
Comments powered by Disqus.
이 책은 프로젝트 과정 전반에 거쳐 소프트웨어 전문가답게 진행하는 방법에 대해 서술되어있다. 전반적으로 이해가 잘되도록 쓰여져 있고, 현인의 어록과도 같은 책이라 참고할만한 부분도 많이 있다.
하지만 조직문화나 권한의 한계, 물리적인 시간의 한계로 모든 팁을 다 따르기는 어렵다. 또한 이러한 내용은 완전히 습관이 되어야하는데, 긴 책 내용을 전부 기억하기는 현실적으로 어렵다. 따라서 현재 내 상황에서 실천 가능한 팁들을 간단히 정리하였다.
이 문서는 1차, 2차, … 로 비정기적으로 업데이트 해나갈 것이다. 다음 업데이트는 이전 차수 내용이 완전히 체화 되었을 때이다.
.은 하나만)사용자가 기대하는 것이 무엇인지 계속 생각하라. 그것이 진짜 목표이다.
Comments powered by Disqus.
코드의 실제 진행상황을 추적하는데 필요한 정보들을 모아둔 구조
자바스크립트의 함수 객체
스코프 체인이라고 함.1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
// 스코프 체인이 일어나지 않음
+function sum() {
+ return a + b;
+}
+function calc(a, b, expr) {
+ return expr();
+}
+calc(1,3, sum); // 에러
+
+// 스코프 체인이 일어남
+function calc(a, b) {
+ const sum = () => {
+ return a+ b;
+ }
+ return sum();
+}
+calc(1,3) // 4
+
렉시컬 스코프라고 한다.1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
function outer() {
+ var n = 0;
+ function increase() {
+ n += 1;
+ }
+ return increase;
+}
+var newFn = outer();
+newFn(); // n이 1 증가하여 1이 됨.
+newFn(); // n이 1 증가하여 2가 됨
+
https://forward.nhn.com/2021/sessions/17
Comments powered by Disqus.
복잡한 문제를 간단한 여러 하위문제로 나누어 푸는 방법
두가지 구현방식이 존재함
피보나치 예시
top-down
+f (int n) {
+ if n == 0 : return 0
+ elif n == 1: return 1
+
+ if dp[n] has value : return dp[n]
+ else : dp[n] = f(n-2) + f(n-1)
+ return dp[n]
+}
+bottom-up
+f (int n){
+ f[0] = 0
+ f[1] = 1
+ for (i = 2; i <= n; i++) {
+ f[i] = f[i-2] + f[i-1]
+ }
+ return f[n]
+}
+접근방법
각 단계마다 지금 당장 가장 좋은 방법만을 선택해나가는 방법.
접근 방법
인접한 두개의 데이터를 비교해가면서 정렬을 진행하는 방식. 매 회차마다 가장 큰 값이 맨 끝으로 이동된다.
| Space Complexity | Time Complexity |
|---|---|
| O(1) | O(n^2) |
정렬되지 않은 원소 중 가장 작은 값(혹은 가장 큰 값)을 고르고, 해당하는 위치로 교환해주는 방식
| Space Complexity | Time Complexity |
|---|---|
| O(1) | O(n^2) |
i 번째를 정렬할 순서라고 가정하면, 0 부터 i-1 까지의 원소들은 정렬되어있다는 가정하에, i 번째 원소와 i-1 번째 원소부터 0 번째 원소까지 비교하면서 i 번째 원소가 비교하는 원소보다 클 경우 서로의 위치를 바꾸고, 작을 경우 위치를 바꾸지 않고 다음 순서의 원소와 비교하면서 정렬해준다.
| Space Complexity | Time Complexity |
|---|---|
| O(1) | O(n^2) |
더이상 나누어지지 않을 때 까지 반 씩(1/2) 분할하다가 더 이상 나누어지지 않은 경우 반환한다. 이 때 반환한 값끼리 combine하면서, 비교가 이뤄지며, 비교 결과를 기반으로 정렬되어 임시 배열에 저장된다. 그리고 이 임시 배열에 저장된 순서를 합쳐진 값으로 반환한다.
| Space Complexity | Time Complexity |
|---|---|
| O(n) | O(nlogn) |
binary heap 자료구조를 이용한 정렬방법
두가지 방법
heap에 데이터를 저장하는 시간은 O(logn)이고, 삭제 시간은 O(log n)이다.
| Space Complexity | Time Complexity |
|---|---|
| O(1) | O(nlogn) |
가장 빠르지만, 최악의 경우 O(n^2)의 시간복잡도를 가짐. 하지만 constant factor가 작아서 속도가 빠르다.
분할 정복전략을 사용.
Divide 과정에서 pivot이라는 개념이 사용된다. 오름차순으로 정렬한다고 하면, 이 pivot 을 기준으로 좌측은 pivot 보다 작은 값이 위치하고, 우측은 큰 값이 위치하도록 partition된다. 이렇게 나뉜 좌, 우측 각각의 배열을 다시 재귀적으로 Quick Sort 를 시키면 또 partition 과정이 적용된다.이 때 한 가지 주의할 점은 partition 과정에서 pivot 으로 설정된 값은 다음 재귀과정에 포함시키지 않아야 한다. 이미 partition 과정에서 정렬된 자신의 위치를 찾았기 때문이다.
Worse case
pivot이 항상 가장 작은값 또는 가장 큰 값으로 선택되면, 한쪽으로 치우친 분할이 일어나게되고, O(n) 깊이를 갖게 된다.
Balanced-partitioning
배열 내의 원소 중 임의의 원소를 pivot으로 설정하면 입력에 관계없이 일정한 수준의 성능을 얻을 수 있다고 함.
partitioning
가장 마지막 원소를 pivot 으로 설정했다고 가정하자.
이 pivot 은 움직이지 말자. 첫번째 원소부터 비교하는데 만약 그 값이 pivot 보다 작다면 그대로 두고, 크다면 맨 마지막에서 그 앞의 원소와 자리를 바꿔준다. 즉 pivot value 의 index 가 k 라면 k-1 번째와 바꿔주는 것이다.
이것을 모든 원소에 대해 실행하고 마지막 과정에서 작은 값들이 채워지는 인덱스를 가리키고 있는 값에 1 을 더한 index 값과 pivot 값을 바꿔준다. 즉, 최종적으로 결정될 pivot 의 인덱스를 i 라고 했을 때, 0 부터 i-1 까지는 pivot 보다 작은 값이 될 것이고 i+1 부터 k 까지는 pivot 값보다 큰 값이 될 것이다.
| Space Complexity | Time Complexity |
|---|---|
| O(log(n)) | O(nlogn) |
범위와 타입이 정해져있는 입력에서, 각 값이 몇 번 나왔는지 세어 정렬하는 방법이다.
점수와 같이 0~100 으로 구성되는 좁은 범위에 존재하는 데이터들을 정렬할 때 유용하게 사용할 수 있다.
| Space Complexity | Time Complexity |
|---|---|
| O(n) | O(n) |
입력의 데이터의 길이가 동일할때 사용하는 방법.
하나의 기수마다 하나의 버킷을 생성하여, 분류를 한 뒤에, 버킷 안에서 또 정렬을 하는 방식이다.
두가지 방식으로 나뉨
MSD는 중간정렬를 확인할 수 있으나, 정렬이 완료됐는지 확인하는 과정이 필요하고 여기에 메모리가 더 소요된다. 따라서 일반적으로 LSD를 사용
| Space Complexity | Time Complexity |
|---|---|
| O(n) | O(n) |
만일 100 이하의 소수를 모두 찾고 싶다면, 1 부터 100 까지의 자연수를 모두 나열한 후, 먼저 소수도 합성수도 아닌 1을 지우고, 2외의 2의 배수들을 다 지우고, 3외의 3의 배수들을 다 지우는 과정을 100제곱근인 10이하의 소수들에 대해서만 반복하면, 이때 남은 수들이 구하고자 하는 소수들이다.
| Space Complexity | Time Complexity |
|---|---|
| O(n) | O(loglogn) |
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+
int num1, num2;
+ int arr[MAX] = { 0,1 };
+
+ scanf("%d %d", &num1, &num2);
+
+ for (int i = 2; i <= num2; i++)
+ {
+ for (int j = 2; i * j <= num2; j++)
+ arr[i * j] = 1;
+ }
+
+ for (int i = num1; i <= num2; i++)
+ {
+ if (!arr[i])
+ printf("%d\n", i);
+ }
+
https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/Algorithm
Comments powered by Disqus.
정렬된 배열의 앞 뒤로 새로운 요소를 삽입 해야되는 경우
string
Comments powered by Disqus.
모듈 내부의 기능적인 집중 정도. 높을 수록 좋다.
우연적 응집도 < 논리적 응집도 < 시간적 응집도 < 절차적 응집도 < 교환적 응집도 < 순차적 응집도 < 기능적 응집도
기능적 응집도(Functional Cohesion) : 모듈 내부의 모든 기능이 단일한 목적을 위해 수행되는 경우
순차적 응집도(Sequential Cohesion) : 모듈 내에서 한 활동으로 부터 나온 출력값을 다른 활동이 사용할 경우
교환적 응집도(Communication Cohesion) : 동일한 입력과 출력을 사용하여 다른 기능을 수행하는 활동들이 모여있을 경우
절차적 응집도(Procedural Cohesion) : 모듈이 다수의 관련 기능을 가질 떄 모듈 안의 구성요소들이 그 기능을 순차적으로 수행할 경우
시잔적 응집도(Temporal Cohesion) : 연관된 기능이라기 보단 특정 시간에 처리되어야 하는 활동들을 한 모듈에서 처리할 경우
논리적 응집도(Logical Cohesion) : 유사한 성격을 갖거나 특정 형태로 분류되는 처리 요소들이 한 모듈에서 처리되는 경우
우연적 응집도(Coincidental Cohesion) : 모듈 내부의 각 구성요소들이 연관이 없을 경우 -> 서로 영향을 안준다. 즉 뭉쳐는 있는데 딱히 이유는 없다.
결합도는 모듈과 모듈간의 상호 의존 정도. 낮을 수록 좋음
자료 결합도 < 스탬프 결합도 < 제어 결합도 < 외부 결합도 < 공통 결합도 < 내용 결합도
자료 결합도(Data Coupling) : 모듈간의 인터페이스 전달되는 파라미터를 통해서만 모듈간의 상호 작용이 일어나는 경우. 깔끔한 Call by value
스탬프 결합도(Stamp Coupling) : 모듈간의 인터페이스로 배열이나 오브젝트, 스트럭쳐등이 전달되는 경우.
제어 결합도(Control Coupling) : 단순히 처리를 해야할 대상인 값만 전달되는게 아니라 어떻게 처리를 해야 한다는 제어 요소(DCD, Flag등)이 전달되는 경우.
외부 결합도(External Coupling) : 어떤 모듈에서 반환한 값을 다른 모듈에서 참조해서 사용하는 경우
공통 결합도(Common Coupling) : 파라미터가 아닌 모듈 밖에 선언되어 있는 전역 변수를 참조하고 전역변수를 갱신하는 식으로 상호작용하는 경우
내용 결합도(Content Coupling) : 다른 모듈 내부에 있는 변수나 기능을 다른 모듈에서 사용 하는 경우
https://raisonde.tistory.com/entry/%EA%B2%B0%ED%95%A9%EB%8F%84Coupling%EA%B3%BC-%EC%9D%91%EC%A7%91%EB%8F%84Cohension
Comments powered by Disqus.
https://velog.io/@eunbinn/dry-the-common-source-of-bad-abstractions
Article, Menu, Buy 버튼이 있을때, Article, Menu와 Buy 버튼은 서로 성격이 다르지만 같은 팩터리 메서드로 묶는다면, 추후 Buy 버튼만 변경될 우려가 있다.Comments powered by Disqus.
일반적으로 좋은 코드라고 하면 다음 세가지를 얘기한다.
그럼 왜 위 세가지가 갖춰진 코드를 좋은 코드라 하는 걸까? 그리고 어떻게 이 세가지를 지키며 코드를 작성할수 있을까?
우리는 항상 좋은 코드를 작성하기 위해 노력한다.
하지만 언제나 이것을 놓치는 시점이 존재하기에 좋지 않은 코드가 나오게 된다.
그럼 어떠다가 놓치게 되는 것일까?
우리는 언제나 코드를 수정하고, 다시 만든다. 그러는 과정에서 다음과 같은 상황이 발생하게 된다.
수정을 반복하면서 쓰이지 않는 코드가 발생하게 된다. 하지만 우리는 보통 이 코드를 지우지 않고 놔둔다. 바로 어디서 쓰일지 모른다는 불안감 때문이다.
이 불안감은 어디서 오는 것일까?
거리
코드가 동작하는 곳과 코드가 정의된 곳 사이의 물리적 거리가 멀면 파악하기 힘들어진다. 보고 있는 코드가 일정 범위에서만 사용된다면, 그 범위만 확인 후 사용하지 않는 코드라는 것을 확신할 수 있을것이다.
순수하지 않은 함수
함수 외부의 어떤 값을 기반으로 동작하는 함수는 그 side effect를 제어하기 어렵다. 함수의 입출력만 확인하여 함수 내부를 수정할 수 없다면 수정하기 까다롭다.
중복되어서 하나의 모듈로 따로 빼두었지만, 쓰이는 곳에 따라 다르게 동작하도록 로직을 추가해야할 때를 마주친다.
이때 보통 side effect가 두려워서 함수에 입력을 추가하든가, 옵션 값을 추가하여 내부에서 억지로 처리한다. 이때 이 코드는 좋지 않은 코드가 된다.
이런 응급처치가 여러번 반복되면 아무도 알아볼수없는 함수가 탄생한다.
기술부채
물론 응급처치가 필요할때가 존재한다. 급하게 문제를 해결해야할때는 응급처치가 필요하다. 하지만, 언제나 이것을 부채처럼 여기고 수정해야한다.
좋은 코드란 좋지 않은 코드가 없는 코드를 말한다. 따라서 좋지 않은 코드를 줄이고 격리하자. 이렇게 코드를 점진적으로 개선해나가야 한다.
별다른 기준없이 중복 코드를 단순히 밖으로 빼내는 것
대상의 중요 요점들을 재해석해서, 의존성이 있는 것들끼리 묶어 밖으로 빼낸 것
단순히 중복된 코드를 추출하는 것만으로는 재사용하기가 어렵다. 재사용을 위해 또다른 비용을 소모하게 될 뿐이다.
함수를 분리할때는 그 함수의 역할을 인지하고 하나의 역할만 하도록 정의해야한다. 즉, 의존성을 드러내어 의존성이 있는 것들끼리만 묶어서 함수의 추상화를 해야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+
const Spagetti = () => {
+ const [page, setPage] = useState(1);
+ const [totalPage, setTotalPage] = useState(10);
+ const [data, setData] = useState(null);
+ const [isLoading, setLoading] = useState(false);
+
+ const handlePage = () => {};
+ const fetchData = async () => {
+ fetch(page)
+ };
+
+ useEffect(() => {
+ // data fetch
+ }, [])
+
+ return (
+ <Component> ... </Componnet>
+ )
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+
function useSpagettiData(initialPage: number, fetchFunction: () => Promise<Data>) {
+ const [page, setPage] = useState(1);
+ const [totalPage, setTotalPage] = useState(10);
+ const [data, setData] = useState(null);
+ const [isLoading, setLoading] = useState(false);
+
+ const fetchData = async () => {
+ return await fetch(page);
+ };
+
+ const handlePage = () => { ... };
+
+ useEffect(() => {
+ // data fetch
+ }, [])
+
+ return {
+ page, data, isLoading, isError, handlePage, ...
+ }
+}
+
+const Spagetti = () => {
+ const { data } = useSpagettiData(1, fetchData)
+
+ return ( ... );
+}
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+
// pagination을 관리하는 hooks
+function usePagination(initialPage: number) {
+ const [page, setPage] = useState(initialPage);
+ const [totalPage, setTotalPage] = useState(10);
+
+ const handlePage = () => {};
+
+ return { page, totalPage, handlePage };
+}
+
+// data fetch를 관리하는 hooks
+function useFetch<T>(fetchFunction: () => Promise<T>, intialValue = null) {
+ const [data, setData] = useState(intialValue);
+ const [isLoading, setLoading] = useState(false);
+
+ useEffect(() => {
+ // data fetch
+ }, [])
+
+ return { data, isLoading, isError };
+}
+
+const Spagetti = () => {
+ const { page, totalPage, handlePage } = usePagination(1);
+ const { data } = useFetch(() => fetch(page), intialDadtdad);
+
+ return ( ... );
+}
+
그럼 어디에 분리할 것인가?
단순히 컴포넌트를 렌더링하는 함수 컴포넌트일 경우 어느정도 레벨로 공유될지에 따라 정의되는 위치가 달라진다. 어떤 함수는 도메인과 강하게 결합되어있어 특정 페이지에서만 재사용되고, 어떤 함수는 의존 관계없이 어디에서든 사용할 수 있다.
목적에 따라 맞는 위치를 정의해주는 것 또한 중요하다
아무리 깔끔하게 코드를 작성한다 하더라도, 요구사항에 맞추다보면 어쩔 수 없이 복잡한 코드가 작성된다. 사용하고 있는 라이브러리의 문제일수도 있고, 여러 브라우저에 대응하다 탄생한 코드일 수 있다.
이러한 좋지 않지만, 어쩔 수 없는 코드는 제대로 관리할 수 있도록 격리해줘야한다.
이때 주석과 함께 격리해두면 기존 코드의 흐름을 끊지 않고, 복잡한 코드를 이해하는데 도움을 줄 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
/**
+ * @Note event type이 언제든 서버에서 추가될 수 있다. 하드코딩되어 있는 event name에 추가할 수 있도록 한다.
+ */
+const targetEventNameRegex =
+ /click_|impression_|push_|scroll_|swipe_|background_/g;
+/**
+ * @Note eventName에 이전에 선택된 eventType_이 prefix로 붙어서 전달되어 이를 subtract 해준다.
+ */
+useEffect(() => {
+ const refinedEventName = eventName?.replace(targetEventNameRegex, "");
+ setValue(getName("eventName"), `${eventType}_${refinedEventName ?? ""}`);
+}, []);
+
최소한의 가독성을 보장하는 방법은 일관성있는 코드를 작성하는 것이다.
코드에 일관성이 지켜지면 예측이 가능해진다. 예측이 가능하다는 것은 어느 곳에 어떤 코드가 위치하는지 예상할 수 있다는 것이다. 이것이 프로젝트 팀원 간의 그라운드 룰이 필요한 이유이다.
변수 및 함수의 네이밍에 규칙을 만들자.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+
// Case 1.
+// prefix: handle
+// target: button
+// action: click
+const handleButtonClick = () => {};
+
+// Case 2.
+// prefix: on
+// action: click
+// target: button
+const onClickButton = () => {};
+
우선 디렉터리 구조는 아키텍쳐가 아니다. (아키텍처 !== 디렉터리 구조)
일관된 디렉터리 구조는 전체적인 구조를 파악하는데 큰 도움을 주고, 컴포넌트간의 관계를 파악하는데에도 도움을 준다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
src
+├── api
+├── components
+├── hooks
+├── model
+├── pages
+│ ├── contract
+│ └── docs
+└── utils
+
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+
src
+├── @shared
+│ ├── components
+│ ├── hooks
+│ ├── models
+│ └── utils
+├── contract
+│ ├── components
+│ ├── hooks
+│ ├── models
+│ ├── utils
+│ └── index.ts
+├── docs
+│ ├── components
+│ ├── hooks
+│ ├── models
+│ ├── utils
+│ └── index.ts
+└── App.tsx
+
첫번째 구조 : 코드가 하는 역할에 따라 디렉터리를 구분함. 어플리케이션이 커지면, 코드가 정의된 곳과 사용되는 곳이 멀어지는 문제점이 발생함.
두번째 구조 : 도메인 영역에 따라 디렉터리를 구분한 Featured Based 구조. 전반적으로 사용되는 것만 @shared에 넣고, 나머지는 연관이 있는 것끼리만 묶어놔서, 어플리케이션이 커져도 응집도 있게 모여있다.
참고자료
요약 : 프로그래머의 머리를 캐시라고 한다면, temporal locality, spatial locality에 의해 연관이 있는 기능끼리 모아두어 관리하면, 필요한 부분만 머리속에 넣어두어 사용할 수 있으므로, 빠르게 처리 가능하다.
확장이 어려운 코드는 내부에서 많은 변경이 발생하며, 이것은 코드를 읽기 어렵게 만든다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
const Input = styled.input`
+ // styling
+`;
+const Input = ({
+ type,
+ value,
+ onChange,
+}) => {
+ return (
+ <Input type={type} value={value} onChange={onChange}>
+ )
+}
+
위 컴포넌트는 확장에 닫혀있다. 즉, 새로운 이벤트 핸들러나 값을 전달하기 어려운 구조이다.
따라서 아래와 같이 확장이 가능하도록 만들어야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+
const Input = styled.input`
+ // styling
+`;
+
+const Input = (props: HTMLAttributes<HTMLInputElement>) => {
+ return (
+ <Input {...props}>
+ )
+}
+
여기에 아래와 같이 validator에 대한 처리를 추가하면 좀 더 의미있어진다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
const Input = styled.input<{ isValid?: boolean }>`
+ // styling
+ // error styling
+`;
+interface Props extends HTMLAttributes<HTMLInputElement> {
+ isValid?: boolean;
+}
+const Input = ({ isValid, ...props }: Props) => {
+ return (
+ <Input {...props} isValid={isValid}>
+ )
+}
+
https://jbee.io/etc/what-is-good-code/
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+
SELECT *
+FROM ANIMAL_INS
+ORDER BY ANIMAL_ID ASC
+
+ORDER BY ANIMAL_ID DESC
+
+ORDER BY NAME ASC, DATETIME DESC
+
1
+2
+3
+4
+5
+6
+7
+
SELECT ANIMAL_ID, NAME
+FROM ANIMAL_INS
+WHERE INTAKE_CONDITION="Sick"
+
+WHERE INTAKE_CONDITION<>"Aged"
+
+WHERE (A.SEX_UPON_INTAKE<>"Spayed Female" AND A.SEX_UPON_INTAKE<>"Neutered Male")AND (B.SEX_UPON_OUTCOME = "Spayed Female" OR B.SEX_UPON_OUTCOME = "Neutered Male")
+
1
+2
+
ORDER BY DATETIME ASC
+LIMIT 1
+
SELECT MAX(DATETIME)
+FROM ANIMAL_INS;
+
+SELECT MIN(DATETIME)
+FROM ANIMAL_INS;
+
+SELECT COUNT(*)
+FROM ANIMAL_INS;
+
+SELECT COUNT(DISTINCT NAME)
+FROM ANIMAL_INS;
+SELECT ANIMAL_TYPE, COUNT(*)
+FROM ANIMAL_INS
+GROUP BY ANIMAL_TYPE
+ORDER BY ANIMAL_TYPE ASC
+
+
+SELECT NAME, COUNT(NAME)
+FROM ANIMAL_INS
+GROUP BY NAME
+HAVING COUNT(NAME)>=2
+ORDER BY NAME ASC
+
+SELECT HOUR(DATETIME) AS HOUR, COUNT(*)
+FROM ANIMAL_OUTS
+GROUP BY HOUR(DATETIME)
+HAVING HOUR>=9 AND HOUR<20
+ORDER BY HOUR ASC
+1
+2
+3
+4
+5
+6
+7
+8
+
SELECT ANIMAL_ID
+FROM ANIMAL_INS
+WHERE NAME IS NULL
+
+WHERE NAME IS NOT NULL
+
+SELECT ANIMAL_TYPE, IF(NAME IS NULL, "No name", NAME) AS NAME, SEX_UPON_INTAKE
+FROM ANIMAL_INS
+
SELECT * FROM A a [JOIN 문] B b ON a.key=b.key 는 동일WHERE A.NAME IN ("Lucy", "Ella", "Pickle", "Rogan", "Sabrina", "Mitty")
+
+SELECT ANIMAL_ID, NAME, DATE_FORMAT(DATETIME, "%Y-%m-%d") as 날짜
+
+SELECT DATE('2021-08-21 12:34:56') as 날짜,
+ MONTH('2021-08-21 12:34:56') as 월,
+ DAY('2021-08-21 12:34:56') as 일,
+ HOUR('2021-08-21 12:34:56') as 시간,
+ MINUTE('2021-08-21 12:34:56') as 분,
+ SECOND('2021-08-21 12:34:56') as 초;
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+
--A로 시작하는 문자를 찾기--
+SELECT 컬럼명 FROM 테이블 WHERE 컬럼명 LIKE 'A%'
+
+--A로 끝나는 문자 찾기--
+SELECT 컬럼명 FROM 테이블 WHERE 컬럼명 LIKE '%A'
+
+--A를 포함하는 문자 찾기--
+SELECT 컬럼명 FROM 테이블 WHERE 컬럼명 LIKE '%A%'
+
+--A로 시작하는 두글자 문자 찾기--
+SELECT 컬럼명 FROM 테이블 WHERE 컬럼명 LIKE 'A_'
+
+--첫번째 문자가 'A''가 아닌 모든 문자열 찾기--
+SELECT 컬럼명 FROM 테이블 WHERE 컬럼명 LIKE '[^A]'
+
+--첫번째 문자가 'A'또는'B'또는'C'인 문자열 찾기--
+SELECT 컬럼명 FROM 테이블 WHERE 컬럼명 LIKE '[ABC]'
+SELECT 컬럼명 FROM 테이블 WHERE 컬럼명 LIKE '[A-C]'
+
Comments powered by Disqus.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+
import React, { Component } from 'react';
+
+class Hello extends Component {
+ static defaultProps = {
+ name: '이름없음'
+ };
+
+ render() {
+ const { color, name, isSpecial } = this.props;
+ return (
+ <div style=>
+ {isSpecial && <b>*</b>}
+ 안녕하세요 {name}
+ </div>
+ );
+ }
+}
+
+export default Hello;
+
class 키워드로 시작
Component를 상속 받음
render() 함수로 JSX 반환
props를 조회할 때 this 키워드 사용
defaultProps 설정 시 클래스 내부에 static 키워드와 함께 선언
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+
class Counter extends Component {
+ constructor(props) {
+ super(props);
+ this.state = {
+ counter: 0
+ };
+ }
+ handleIncrease = () => {
+ this.setState({
+ counter: this.state.counter + 1
+ });
+ };
+
+ handleDecrease = () => {
+ this.setState({
+ counter: this.state.counter - 1
+ });
+ };
+
+ render() {
+ return (
+ <div>
+ <h1>{this.state.counter}</h1>
+ <button onClick={this.handleIncrease}>+1</button>
+ <button onClick={this.handleDecrease}>-1</button>
+ </div>
+ );
+ }
+}
+
this.state 로 설정this.setState 로 업데이트마운트 단계
constructor
getDerivedStateFromProps
1
+2
+3
+4
+5
+6
+7
+
static getDerivedStateFromProps(nextProps, prevState) {
+ if (nextProps.color !== prevState.color) {
+ return { color: nextProps.color };
+ }
+
+ return null;
+}
+
static 키워드가 필요하고, 함수 내부에서 this 객체에 접근할 수 없다업데이트 단계
언마운트 단계
오류 발생시
함수형 컴포넌트는 자바스크립트 함수의 형태로 된 컴포넌트로, 기존에는 state와 생명주기함수를 사용할 수 없었지만, hook을 통해 가능해짐으로써 많이 사용하기 시작했다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
import React, {useState} from 'react';
+
+function Hello({ color, name, isSpecial }) {
+ const [count, setCount] = useState(0);
+ return (
+ <div style=>
+ {isSpecial && <b>*</b>}
+ 안녕하세요 {name}
+ </div>
+ );
+}
+
+export default Hello;
+
hook을 통해 상태를 관리하고, 생명주기함수를 사용할 수 있다.useEffect hook을 통해 관리할 수있다.
1
+2
+3
+4
+5
+6
+
useEffect(() => {
+
+ return () => {
+ // componentWillUnMount()
+ }
+}, [/* componentDidUpdate() */]) // dependencies를 안넣으면 리렌더링 될때마다 호출됨.
+
마운트 될 때
useEffect가 실행됨.업데이트 될때
dependencies 에 넣은 state나 props가 업데이트 되었을때 useEffect 호출언마운트 될 때
return 문이 실행됨.useLayoutEffect
state 업데이트도 포함된다.클래스형 컴포넌트
this.state를 통해 상태를 관리한다.생명주기함수를 작성할 수 있다.함수형 컴포넌트
hook을 통해 상태와 생명주기를 관리한다.https://velog.io/@seong-dodo/React-%ED%81%B4%EB%9E%98%EC%8A%A4%ED%98%95-%EC%BB%B4%ED%8F%AC%EB%84%8C%ED%8A%B8-vs-%ED%95%A8%EC%88%98%ED%98%95-%EC%BB%B4%ED%8F%AC%EB%84%8C%ED%8A%B8
https://devowen.com/298
https://born-dev.tistory.com/27
https://koras02.tistory.com/178?category=967574
Comments powered by Disqus.
DB 에서 페이징을 구현하는 방법
limit과 offset을 활용하여 페이징을 구현하는 방법.
SELECT * FROM table
+ORDER BY timestamp
+OFFSET 10
+LIMIT 5
+장점
단점
중복데이터가 보일 수 있다.누락된다.오프셋 페이징의 단점을 해결할 수 있는 페이징 기법.
클라이언트가 가져간 마지막 row의 다음 row들을 n개 요청하는 방법이다. id 또는 타임스탬프를 기준으로 정렬하고, LIMIT을 거는 방법을 사용한다.
SELECT id, title
+ FROM `post`
+ WHERE id < (Id Cursor : 996)
+ ORDER BY id DESC
+ LIMIT 5
+이때 사용자 쪽에서는 두 번째 페이지 이상을 조회할 시 기준이 되는 값을 같이 보내줘야 한다.
장점
단점
페이지 스킵 구현법
https://wonyong-jang.github.io/database/2020/09/06/DB-Pagination.html
https://uxdesign.cc/why-facebook-says-cursor-pagination-is-the-greatest-d6b98d86b6c0
Comments powered by Disqus.
비즈니스 로직을 구현하는 영역으로 응용프로그램에서 데이터를 처리하는 부분View
컨트롤러로부터 받은 모델의 결과값을 가지고, 사용자에게 출력할 화면을 만드는 일을 한다.
만들어진 화면을 컨트롤러로 다시 보내고, 컨트롤러는 이를 웹 브라우저에 전송하여 웹 브라우저가 출력하게 한다.
모델과 컨트롤러에 대해 몰라야한다.
구성요소
Model : 데이터를 보관하고 있는 부분으로, 데이터를 불러오거나 업데이트하는 비즈니스 로직이 있음.
특징
장점
데이터를 관리하는 로직과 UI로직을 깔끔하게 분리하여 유지보수에 용이해짐.
코드의 재사용성을 개선
UI 디자이너와 개발자가 쉽게 협업할 수 있는 디자인 패턴
단점
props drilling을 해결. view에서 액션을 디스패치하면 store에서 데이터를 변경하고 다시 뷰로 전달하는 단방향 흐름을 갖는 패턴.
데이터 흐름 : Stores -> view -> action -> dispatcher-> Stores
redux : flux 패턴을 이용한 구현체.
장점 : props drilling을 해결. 거대한 view와 상태관리인 model을 나눔
단점 : redux는 보일러플레이트가 많다.
Model - View - Intent
사용자가 다른 동작을 했는데, 실제로는 같은 데이터의 변화를 의미하는 경우가 있다. 예를들어, 키보드로 위 버튼을 누른 것과, 마우스로 + 버튼을 클릭한 것은 같은 데이터의 변화를 의미할 수 있다.
이떄 우리는 비즈니스 로직을 두 가지 레이어로 나눌 수 있다.
여기서 1번을 Intent라 하고, 2번을 Model이라고 정의하면 MVI 모델이 생긴다.
MVI의 특징
MVI 아키텍쳐의 특징은, MVC, MVVM과 다르게 하나의 컴포넌트가 아니라 앱 전체에 적용된다는 점이다. 그래서 전체적으로 데이터의 방향성이 단방향으로 연결되며, 데이터가 전역적으로 구성되는 것이 특징이다. View는 모델에 의존적이지만, 비즈니스 로직은 View와의 의존성이 없기 때문에 화면변화에 유연하며, 별도로 테스트하기 쉽다. 또한 컴포넌트 간 데이터 통신에 의존하지 않기에 일관성있는 상태를 유지하기도 용이하다.
이를 통해 View에서는 Model로부터 데이터를 조회하는 Query와 데이터를 변화시키는 Command를 언제든 조립해서 사용(CQRS 패턴)할 수 있다. 또한 View는 비즈니스 로직에 의존적이지만, View끼리는 느슨하게 결합하여 UI 요구사항 변화에 긴밀하게 대응할 수 있다.
컴포넌트 관리를 위한 방법론. View를 원자로 나누고 분자, 유기체, 템플릿, 페이지 순으로 결합하여 큰 단위의 View를 그리는 방법.
https://yozm.wishket.com/magazine/detail/1663/
https://velog.io/@teo/%ED%94%84%EB%A1%A0%ED%8A%B8%EC%97%94%EB%93%9C%EC%97%90%EC%84%9C-MV-%EC%95%84%ED%82%A4%ED%85%8D%EC%B3%90%EB%9E%80-%EB%AC%B4%EC%97%87%EC%9D%B8%EA%B0%80%EC%9A%94#mvvm-%EC%95%84%ED%82%A4%ED%85%8D%EC%B3%90—angular-react-vue
Comments powered by Disqus.
부수 효과가 없는 순수함수를 1급 객체로 간주하여 파라미터로 넘기거나 반환값으로 사용하는 것을 가능하도록 하여, 참조 투명성을 지키도록 하는 프로그래밍 패러다임
순수 함수형 프로그래밍만으로 개발을 하기에는 무리가 있다. 따라서 적절히 조절해가면서 개발을 해나가자.
함수형 프로그래밍의 가장 큰 특징 두 가지
각 함수는 외부의 값을 변경하지 않고, side effect를 일으키지 않도록 하는 순수함수여야함.
함수형 프로그래밍 패러다임에서는 함수는 일급객체로 간주됨. 일급객체(first-class citizen) 로서의 함수는 다음과 같은 특징을 가지고 있음
근래의 프로그래밍 패러다임은 크게 아래와 같이 구분할 수 있다.
함수형 반응형 프로그래밍으로 개발을 할 수도 있다.명령형 프로그래밍을 기반으로 개발하던 소프트웨어는, 규모가 커짐에 따라 복잡하게 엉킨 스파게티 코드가 되어 유지보수에 매우 힘들었다. 이를 해결하기 위해 함수형 프로그래밍이라는 패러다임이 등장하여 주목을 받았다. 함수형 프로그래밍은 거의 모든 것을 순수함수로 나누어 문제를 해결하는 기법으로 작은 문제를 해결하기 위한 함수를 작성하여 가독성을 높이고 유지보수를 용이하게 해준다.
클린코드의 저자는 함수형 프로그래밍을 대입문이 없는 프로그래밍이라고 정의하였다.
함수형 프로그래밍은 대입문을 사용하지 않는 프로그래밍이며, 작은 문제를 해결하기 위한 함수를 작성한다.
예시
1
+
process(10, print(num));
+
process 함수는 첫번째 인자로 몇까지 iteration을 돌 것인가를 받고, 두번째 인자로는 전달받은 값을 출력하라는 함수를 매개변수로 받고 있다.
함수형 프로그래밍은 무엇을에 포커스를 두는 프로그래밍이고, 따라서 함수형 프로그래밍에서는 출력을 하는 함수를 파라미터로 넘길 수 있고, 이는 함수형 프로그래밍의 기본 원리 중 First-class Citizen이 보장되기에 가능한 방법이다.
명령형 프로그래밍에서는 메소드를 호출하면 상황에 따라 내부의 값이 바뀔 수 있다. 즉, 우리가 개발한 함수 내에서 선언된 변수의 메모리에 할당된 값이 바뀌는 등의 변화가 발생할 수 있다.
하지만 함수형 프로그래밍에서는 대입문이 없기 때문에 메모리에 한번 할당된 값은 새로운 값으로 변화할 수 없다.
부수 효과가 없는 순수함수를 1급 객체로 간주하여 파라미터로 넘기거나 반환값으로 사용할 수 있으며, 참조 투명성을 지킬 수 있다.
여기서 부수효과(side effect)는 다음과 같다.
이러한 부수효과들을 제거한 함수들을 순수함수라고 부르며, 함수형 프로그래밍에서 사용하는 함수는 이러한 순수함수들이다.
순수함수를 이용하면 얻는 장점들
참조투명성 (Referential Transparency)
명령형 프로그래밍과 함수형 프로그래밍에서 사용되는 함수는 부수효과의 유무에 따라 차이가 있다. 그에따라 함수가 참조에 투명한지 안한지 나뉘어진다.
참조에 투명하다는 것은 같은 값에 항상 동일한 결과를 반환하여 실행결과를 참조(예측)할 수 있다는 말이다. 이렇게 부작용을 제거하여 프로그램의 동작을 이해하고 예측을 용이하게 하는 것이 함수형 프로그래밍으로 개발하려는 핵심 동기이다.
또, 함수형 프로그래밍에서는 값의 대입이 없어 항상 동일한 실행에 동일한 결과를 반환하기 때문에, 병령처리 환경에서 Race condition에 대한 비용을 줄어준다.
1
+2
+3
+4
+5
+6
+7
+
function countAdd(val1, val2) {
+ return val1 + val2;
+}
+console.log(countAdd(5, 10)); // result - 15
+console.log(countAdd(5, 10)); // result - 15
+console.log(countAdd(5, 10)); // result - 15
+console.log(countAdd(10, 20)); // result - 30
+
var number = 1;
+function countAdd2(val1, val2) {
+ return val1 + val2 + number;
+}
+console.log(countAdd2(5, 10)); // result - 16
+number = 10;
+console.log(countAdd2(5, 10)); // result - 25
+var number = 1;
+function countAdd3(val1, val2) {
+ number = val1 + val2;
+ return val1 + val2 + number;
+}
+console.log(countAdd3(5, 10));
+자바스크립트는 함수형 프로그래밍을 위해 좋은 언어지만, 멀티 프로그래밍 패러다임 언어이기에, 함수형 프로그래밍으로 작성하려면 항상 신경을 써야한다.
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
// bad
+let foo = 100
+...
+foo = somthing(foo, "bar")
+
+
+// good
+const foo = 100
+...
+const new_foo = somthing(foo, "bar")
+
push, pop, shift, sort, reverse 등 원본을 mutate하는 method 대신 가급적 spread operator 로 대체하거나 값을 복사해서 사용하라
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+
// bad
+const example = (arr: number[], date: Date) => {
+ arr.push(4);
+ arr.sort();
+ date.setMonth(10);
+};
+// good
+const example = (arr: number[], date: Date) => {
+ const new_arr = [...arr, 4];
+ const sorted_new_arr = [...new_arr].sort();
+ const new_date = new Date(date).setMonth(10);
+ return [new_arr, new_date];
+};
+
1
+2
+3
+4
+5
+6
+7
+8
+
// bad
+const example = (obj: Object) => {
+ obj.foo = 200;
+};
+// good
+const example = (obj: Object) => {
+ return { ...obj, foo: 200 };
+};
+
가급적이라는 표현대로, 극단적으로 지키기보단, 요구사항을 위해 어쩔 수 없다면 어길 수 밖에 없다. 이에 집착하지 마라. 좋은 점을 잘 골라서 취합
Functional Reactive Programming
반응형 프로그래밍을 달성하기 위해, 함수형 프로그래밍 규칙을 강제하는 방법이다.
실제 개발을 하다보면, 순수 함수형으로 개발하는 것은 불가능에 가깝다. 따라서 반응형 프로그래밍과 결합하여 프로그래밍을 할 수 있다.
리액트로 예를들면, 사용자가 입력을 하면 그것을 처리하여 외부의 상태를 업데이트하는 함수가 존재하고, 그 상태에 반응하여 호출되는 함수들이 존재한다.
https://mangkyu.tistory.com/111
https://gyuwon.github.io/blog/2020/07/24/react-has-no-functional-components.html
https://velog.io/@teo/%ED%94%84%EB%A1%A0%ED%8A%B8%EC%97%94%EB%93%9C-%EC%9D%BC%EB%8B%A8-%ED%95%9C%EB%B2%88-%ED%95%B4%EB%B3%B4%EC%84%B8%EC%9A%94-%ED%95%A8%EC%88%98%ED%98%95-%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%B0%8D
Comments powered by Disqus.
순수함수 vs 부수효과를 대체한 개념들.
데이터 : 이벤트에 대한 사실. 액션에 의해 변화됨
액션 : 데이터를 변화시킬 수 있음. 실행시점이나 횟수에 의존하여 언제하느냐에 따라 결과가 달라지면 액션이다.
계산 : 입력값을 통해 출력을 만들어내는 것. 같은 입력에 대해 항상 같은 출력값만 내놓아야한다. 외부 세계에 영향을 주면 안됨.
함수형 프로그래밍 예시)
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+
// 함수형 프로그래밍 관점에서 분리해보자.
+function App() {
+ // 데이터
+ const [count, setCount] = useState(0);
+
+ // 계산
+ const increase = (value) => value + 1;
+
+ // 액션
+ const onClick = () => setCount(increase(count));
+
+ // 선언적 패턴
+ return <button onClick={onClick}>{count}</button>;
+}
+
더 좋은 예시) 계산함수를 아래처럼 변경
1
+
const increase = (value, offset) => value + offset;
+
버튼 클릭시 배열의 값을 하나씩 늘려간다고 해보자.
1
+2
+3
+4
+5
+
const increase = (arr) => {
+ const value = arr[arr.length - 1];
+ arr.push(value + 1);
+ return arr;
+};
+
자바스크립트에서는 pass by reference로 동작하기 때문에, 위처럼 코드를 짜게 되면 원본이 변화한다. 따라서 다음과 같이 원본을 복사하여 사용하여야 불변성을 지킬 수 있다.
1
+2
+3
+4
+5
+6
+7
+8
+
const increase = (arr) => {
+ arr = arr.slice(); // array를 조작하기 전에 복사해서 사용한다.
+ const value = arr[arr.length - 1];
+ arr.push(value + 1);
+ return arr;
+};
+//or
+const increase = (arr) => [...arr, arr[arr.length - 1]];
+
만약 계산이나 액션 중에 우리가 수정할 수 없는 라이브러리를 사용한다면 어떻게 불변성을 지킬 수 있을까?
이때는 방어적 복사를 사용한다.
다음과 같이 structuredClone() 이라는 최근 JS에 추가된 API를 사용하여 구현할 수 있다.
1
+2
+3
+4
+5
+
const someCalcuation = (obj, value) => {
+ const clone = structuredClone(obj); // 완전한 clone을 만들어 낸다.
+ someActionLibray(clone, value); // clone값을 변경해도 원본은 변하지 않는다.
+ return clone;
+};
+
참고) structuredClone 지원 브라우저 목록
IE에서는 polyfill 에서 지원
데이터, 액션, 계산으로 구조를 나누면 자연스럽게 코드 구조에 계층이 생기게 되고, 좋은 설계와 쉬운 리팩토링이 보장됨.
액션으로 갈수록 코드는 무엇을 할지에 대한 기획서에 가까운 코드가 되고, 데이터에 가까워질수록 데이터 중심적 코드를 작성하게 되고, 상대적으로 재사용성이 높고 테스트하고 쉬운 코드가 나오게 된다.
이렇게 계층을 나누고, 각 계층을 침범하지 않도록 코드를 짜다보면 자연스럽게 추상화벽이 만들어지면서 벽 상단으로의 코드변화가 하단에는 영항을 미치지 않고, 하단의 변화도 상위에 영항을 주지 않도록 할 수 있다.
이렇게되면 상위에서는 무엇을 할지 기술하는 선언적 패턴으로 코드를 작성할 수 있고, 하위에서는 테스트 하기 쉬운 코드 조각들로 이루어질 수 있다.
lodash : 데이터의 필수적인 구조를 쉽게 다룰 수 있게끔 도와줌. 설명 lodash/fp 로 함수형 프로그래밍을 지원하는듯
rxjs : 이벤트 기반 프로그래밍에서 함수형 프로그래밍을 이용해 선언적으로 이벤트를 처리할 수 있도록 해줌. 설명
redux
immutable : Map, List 등의 새로운 객체를 제공하여, 변화가 일어나는 구조체는 새로만들고 나머지는 재사용하는 방식으로 불변성을 지킨다. 설명
date-fns : 날짜 관련 라이브러리. 함수형프로그래밍을 지원하는 모듈이 있음.
https://velog.io/@teo/functional-programming
Comments powered by Disqus.
Layout으로 레이아웃 잡고, 데이터 필요없는 거 먼저 렌더
+ +streaming으로 데이터 필요한 컴포넌트 렌더
+ +streaming에 사용하는 컴포넌트는 Server component (+ async Server component)
+ +https://nextjs.org/blog/next-13#layouts
+ +https://nextjs.org/blog/next-13#streaming
+ +서버 컴포넌트
+ +
Lighthouse 검사 결과 이미지, 영상 로딩속도가 문제였음.
+ +최신 포맷을 사용하는 걸 추천했는데, next/image 컴포넌트를 사용하라는 조언을 받음. 자동으로 모던 웹 포맷을 사용한다고.
+ +그런데 브라우저 호환성 문제도 있기에 그 부분에서 조사가 좀 더 필요함.
+ +이미지를 주소로 불러오는 경우, width/height를 지정하든가 fill 속성을 사용해야함.
+ +but, 마크업을 받아서 사용하는 입장에서 css를 조작하기엔 부담스러워서 안쓰고 있다.
+ +https://nextjs.org/blog/next-13#og-image-generation
diff --git a/temp/2023-04-22-value-reference.html b/temp/2023-04-22-value-reference.html new file mode 100644 index 000000000..edbc07df6 --- /dev/null +++ b/temp/2023-04-22-value-reference.html @@ -0,0 +1,7 @@ +passed by value가 일어나는 5가지 데이터 타입(Boolean, Null, undefined, string, number)
+ +https://velog.io/@jakeseo_me/2019-04-01-1904-%EC%9E%91%EC%84%B1%EB%90%A8-2bjty7tuuf#%EC%9E%90%EB%B0%94%EC%8A%A4%ED%81%AC%EB%A6%BD%ED%8A%B8%EC%97%90%EC%84%9C-%EA%B0%92value%EA%B3%BC-%EC%B0%B8%EC%A1%B0reference
diff --git a/temp/2023-05-30-browser-rendering.html b/temp/2023-05-30-browser-rendering.html new file mode 100644 index 000000000..c487d0a7b --- /dev/null +++ b/temp/2023-05-30-browser-rendering.html @@ -0,0 +1,39 @@ +웹 페이지에 접속하면 브라우저는 제일 먼저 해당 페이지의 html을 불러온다. 이후 가져온 html을 읽으며 다음과 같은 렌더링 과정을 수행한다.
브라우저가 html을 파싱하다가 head 태그 내 위치한 script 태그를 만났을 때 파싱이 차단되는 경우가 있다. 이는 script로 불러와지는 코드가 html 을 변경시킬 수 있기에 막는 것이다. 이러한 html 파싱 차단을 막기 위해선 다음과 같은 방법이 있다.
script 를 body 태그 아래에 삽입하여 html 파싱이 종료된 이후 로드
async, defer 속성 사용
async : 로드할 때는 차단하지 않음. 실행할땐 차단함
defer : 로드, 실행할 때 모두 차단하지 않음.
CSS도 간접적으로 차단할 수 있다. script가 페이지 스타일에 영향을 줄 수 있기에 css 파싱이 완료되고 js를 실행하도록하여, 간접적으로 html 파싱이 차단되는 시간이 길어질 수 있다. (링크)
+ +
프론트엔드에서 최적화를 할 수 있는 선택지를 모아놓은 글이다. 순서는 적용하기 비교적 간편한 순으로 정했다.
+ +페이지내 모든 이미지/영상이 페이지가 로드되는 순간에 필요하지 않을 수 있다. 따라서 유저가 보는 뷰포트 근처에 있는 이미지/영상만 로드하여 로딩을 빠르게하는 기법을 lazy loading이라고 한다.
구현법은 다음과 같다.
+ +img 태그에서 loading="lazy"를 주어 적용.
+ picture 태그에서는 img에서만 설정하면 된다.video는 preload를 none이나 metadata로 설정할 수 있음.src 부여 (처음엔 빈상태로 둠)
+ 스크롤, resize 이벤트 콜백함수에서 무거운 작업을 수행하면, 성능에 악영향이 나타날 수 있다. 이때 lodash의 debounce, throttle를 사용하여 이벤트 콜백 호출 횟수를 조절하는 방법이 있다.
+ +Composite 단계에 속하는 tranform 또는 opacity로 애니메이션이 동작할 수 있도록 변경한다.will-change 속성을 사용하여 브라우저에게 일어날 변화에 대해 알려줌으로써 최적화할 수 있다.contain 속성을 사용하여 해당 엘리먼트의 변화가 다른 dom에 영향을 끼치지 않는다는 걸 명시할 수 있다.만약 CSR을 사용중이라면 SSR로 전환하여 사용자가 처음 보는 화면을 더 빠르게 띄워줄 수 있다.
+ +CSR은 리액트가 포함된 자바스크립트를 다운 받고, 리액트를 실행시켜 화면을 렌더링한다. 이때 리액트는 앱 전체를 실행시키기에, 리액트 코드가 방대하다면 그만큼 사용자는 빈 화면에 방치된다.
+ +SSR은 서버에서 미리 첫번째 화면을 생성하고 그 생성된 첫번째 화면의 html, css를 사용자에게 보내는 방법. 사용자 브라우저는 이후 js를 다운 받고 리액트를 실행시켜 인터랙션이 가능하게 한다. 따라서 CSR을 사용하면 사용자가 첫 화면을 보는 시점이 SSR에 비해 늦어지게 된다. 또한 SEO에도 문제가 있다. (검색엔진의 JS 실행에는 한계가 있기에)
+ +SSR에도 단점이 있다. 첫페이지를 구성한 이후 다른 페이지로 넘어갈 때, CSR에서는 그 다른 페이지를 렌더링하기 위한 코드가 이미 있고 필요한 부분만 다시 렌더링하면 되기에 다른 페이지로 넘어갈 때는 CSR이 더 빠르다. 이를 해결하기 위해 CSR와 SSR을 결합하는 방식을 채택한다. (next.js의 next/link 컴포넌트 참고)
또 기존 리액트에서 SSR에서는 리액트 코드를 입히는 hydration 동작을 앱 전체 단위로 진행시켜서 사용자가 최초로 인터랙션을 하는데까지 시간이 오래 걸렸는데, 이번에 react 18 업데이트에 포함된 Suspense API를 통해 컴포넌트 단위로 hydration을 진행시켜 우선도가 높은 컴포넌트부터 먼저 인터랙션이 가능했다 (상세)
+ diff --git a/temp/2023-05-30-pub-sub.html b/temp/2023-05-30-pub-sub.html new file mode 100644 index 000000000..5ad3fae0d --- /dev/null +++ b/temp/2023-05-30-pub-sub.html @@ -0,0 +1,3 @@ +면접 공통질문에 위치
+ +Pub/sub 원리 : 비동기식 메시징 패턴. publisher가 task를 publish하면, 그 publisher를 구독하고 있는 subscriber가 task를 받는다. 내부적으로 웹 소켓을 사용하고 있음.
diff --git a/temp/2023-05-31-browser-storage.html b/temp/2023-05-31-browser-storage.html new file mode 100644 index 000000000..9f415c28c --- /dev/null +++ b/temp/2023-05-31-browser-storage.html @@ -0,0 +1,30 @@ +브라우저에서 웹페이지를 위해 제공하는 저장소과 특징은 다음과 같다.
+ +