현록의 기록저장소

Http Status Code

현록 — Sun, 14 Sep 2025 21:14:40 +0900

https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status

https://developer.mozilla.org/ko/docs/Web/HTTP/Reference/Status

[1XX] 정보 응답

[2XX] 성공 응답

　200: OK

　201: Created

　204: No Content

[3XX] 리다이렉션 메시지: Response Header 의 Location 으로 자동 이동

　301: Moved Permanently

　302: Found

　303: See Other

　304: Not Modified

　307: Temporary Redirect

　308: Permanent Redirect

[4XX] 클라이언트 에러 응답

　400: Bad Request

　401: Unauthorized

　403: Forbidden

　404: Not Found

[5XX] 서버 에러 응답

　500: Internal Sever Error

　501: Not Implemented

　502: Bad Gateway

　503: Service Unavailable

[1XX] 정보 응답

[2XX] 성공 응답

200: OK

ㆍ요청 성공.

201: Created

ㆍ요청 성공.

ㆍ그 결과로 새로운 리소스가 생성됨.

ㆍResponse Header 의 Location에 해당 리소스를 확인할 수 있는 path 를 넣어줌.

　Location: /members/101

202: Accepted

ㆍ요청이 접수되었으나, 처리가 완료되지 않음.

ㆍex) 배치에 요청 접수. 1시간 후 배치 프로세스가 처리.

204: No Content

ㆍ요청 성공.

ㆍResponse Body 는 null.

　(응답 본문에 보낼 데이터가 없음)

[3XX] 리다이렉션 메시지: Response Header 의 Location 으로 자동 이동

301: Moved Permanently

ㆍ영구 리다이렉션(검색 엔진 등에서도 변경 인지).

ㆍ(may) Request Method 가 GET 으로 변하면서 리다이렉션.

ㆍ (may) 본문이 제거될 수도 있음.

(일시 - may 변함: 302, 변함: 303, must 유지: 307)

(영구 - may 변함: 301, 변함: -, must 유지: 308)

302: Found

ㆍ일시적 리다이렉션.

ㆍ(may) Request Method 가 GET 으로 변하면서 리다이렉션.

ㆍ(may) 본문이 제거될 수도 있음.

(일시 - may 변함: 302, 변함: 303, must 유지: 307)

(영구 - may 변함: 301, 변함: -, must 유지: 308)

303: See Other

ㆍ일시적 리다이렉션.

ㆍ(?) Request Method 가 GET 으로 변하면서 리다이렉션.

ㆍ(?) 본문이 제거될 수도 있음.

(일시 - may 변함: 302, 변함: 303, must 유지: 307)

(영구 - may 변함: 301, 변함: -, must 유지: 308)

304: Not Modified

ㆍ 캐시를 목적으로 사용.

ㆍ 클라이언트에게 로컬 리소스를 그대로 사용하라고 알려주는 메시지.

ㆍ Response Body 가 null 이어야 한다.

ㆍ Response Header 에 캐시 관련 정보 담아서 줌.

307: Temporary Redirect

ㆍ일시적 리다이렉션.

ㆍ(must) Request Method 가 기존과 동일하게 유지하면서 리다이렉션.

ㆍ(must) 본문이 제거되지 않고 유지.

(일시 - may 변함: 302, 변함: 303, must 유지: 307)

(영구 - may 변함: 301, 변함: -, must 유지: 308)

308: Permanent Redirect

ㆍ영구 리다이렉션(검색 엔진 등에서도 변경 인지).

ㆍ(must) Request Method 가 기존과 동일하게 유지하면서 리다이렉션.

ㆍ(must) 본문이 제거되지 않고 유지.

(일시 - may 변함: 302, 변함: 303, must 유지: 307)

(영구 - may 변함: 301, 변함: -, must 유지: 308)

[4XX] 클라이언트 에러 응답

400: Bad Request

ㆍ클라이언트가 잘못된 요청을 보냄.

ㆍ요청 파라미터가 잘못되거나, API 스펙에 맞지 않거나.

ㆍ동일한 Request 로는 계속해서 같은 응답일 뿐.

401: Unauthorized

ㆍ비인증 상태.

ㆍ로그인 필요.

ㆍ인증(Authenticate) 되지 않음.

ㆍResponse Header 의 WWW-Authentication 에 인증 방법을 설명.

403: Forbidden

ㆍ비인가 상태.

ㆍ로그인 했지만 권한 불충분.

ㆍ해당 유저에게 인가(Authorize) 되지 않음.

404: Not Found

ㆍ요청 리소스가 서버에 없음.

ㆍ해당 페이지가 없음.

ㆍ또는 클라이언트의 권한이 불충분할 때,

　아예 해당 페이지의 존재 여부도 가리고자 404 로 주기도 함.

[5XX] 서버 에러 응답

500: Internal Sever Error

ㆍ서버 내부 문제로 오류 발생.

501: Not Implemented

ㆍRequest Method-URI 에 대해 서버가 구현하고 있지 않음.

502: Bad Gateway

ㆍ프록시 역할을 하는 서버가 뒷단으로부터 잘못된 응답을 받음.

503: Service Unavailable

ㆍ서비스 이용 불가.

ㆍ일시적인 과부하 또는 예정된 작업으로 잠시 요청 처리 불가능.

ㆍResponse Header 의 Retry-After 에 얼마 뒤 복구되는지 알려줄 수 있음.

　(초단위로 숫자만 보내거나 날짜 표기)

inputPass 사전저장문 입력기

현록 — Tue, 9 Jan 2024 00:10:08 +0900

inputPass.exe

0.85MB

구동환경: Windows 32bit,64bit. 98 이상 모든 Windows GUI 운영체제에서 돌아갈 것으로 예상.

개발언어: Autohotkey

inputPass.exe 옆에 inputPass.txt를 생성합니다.

텍스트 파일에는 항상 짝수로 사전저장문을 입력하여 저장해둡니다.

홀수째에는 [표시될 제목] / 짝수째에는 [실제 입력될 사전저장문구]입니다.

홍길동 IP
192.168.0.172
강우주 IP
192.168.0.241

처럼 저장해두면 됩니다.

프로그램을 실행한 후,

입력칸에 커서를 활성상태로 두고

키보드의 [왼쪽Ctrl키]를 누른채로 마우스의 [휠버튼]을 누르면 마우스 위치에 메뉴가 뜹니다.

이 상태로 왼쪽 Ctrl키만 손에서 떼고(휠버튼은 누르고 있는 채로)

원하는 곳에 마우스 포인터를 이동시킨 후, 휠버튼을 떼면 됩니다.

(클립보드에 원문 복사해주면서, 한글자씩 입력)

포인터가 메뉴 밖에 있거나, Ctrl을 다시 누른 상태를 유지하면 휠버튼을 떼어도 입력이 되지 않고 취소됩니다.

메뉴의 초기화는 프로그램 실행시에만 동작하므로,

inputPass.txt 파일의 내용을 수정한다고 해서 프로그램의 메뉴가 동적으로 바뀌진 않으며,

그냥 프로그램을 종료 후 다시 시작하면 그 때에 새로 반영됩니다.

컨테이너에서 로그나 파일을 생성할 수 없는 문제

현록 — Sat, 11 Nov 2023 22:53:58 +0900

[개요]

[volume mount의 문제]

[volume mount의 문제 해결]

[실행과 상대 경로의 문제]

[실행과 상대 경로의 문제 해결]

Docker container cannot make log file

[개요]

호스트에서 실행할 때는 로그를 잘만 생성하는데,

이걸 컨테이너에서 실행하면 로그를 생성하지 못하는 경우가 있다.

특히 Dockerfile에서 USER ~로 유저를 전환해서 실행할 때 이런 문제에 직면하는 경우가 있다.

[volume mount의 문제]

먼저 컨테이너 실행 예시를 위해 Dockerfile과 docker-compose.yml을 가져왔다.

정말 별거 없는 심플한 상황을 만들었다.

Dockerfile

FROM ubuntu

RUN mkdir /mybind

RUN adduser user001

RUN chown -R user001:user001 /mybind

USER user001

RUN touch /mybind/a

RUN touch /mybind/b

RUN touch /mybind/c

ENTRYPOINT [ "bin/bash", "-c", "while true; do touch /mybind/d; touch /mybind/e; touch /mybind/f; sleep 1; done;" ]

맨 처음 root가 /mybind 디렉터리를 만들어주고,

user001이라는 유저를 생성해준 후,

/mybind 디렉터리의 소유권을 user001이 가지도록 해주고

user001로 유저 전환을 한다.

그리고 /mybind에 a,b,c 파일을 생성한 후,

이제는 d,e,f 파일을 1초마다 생성하는 반복 스크립트를 무한히 동작하게 된다.

docker-compose.yml

services:

bind-test:

build:

context: .

dockerfile: ./Dockerfile

no_cache: true

image: image-bind-test

container_name: cont-bind-test

volumes:

- ./bind-with-container:/mybind

stdin_open: true

tty: true

hostname: bind-test

호스트의 ./bind-with-container 디렉터리를 컨테이너의 /mybind 디렉터리와 연결하는 것 외에

특별한 것은 없다.

(여기선 docker compose로 실행하지만,

docker run ~ -v ./bind-with-container:/mybind ~ 로 컨테이너를 만들어 실행해도 상관없이 같은 상황이 된다.)

desktop@vm:~/Docker/bind-test$ ls -alR

total 16

drwxrwxr-x 2 desktop desktop 4096 11월 11 21:38 .

drwxrwxr-x 3 desktop desktop 4096 11월 11 20:39 ..

-rw-rw-r-- 1 desktop desktop 270 11월 11 21:15 docker-compose.yml

-rw-rw-r-- 1 desktop desktop 280 11월 11 21:34 Dockerfile

호스트의 유저는 desktop이라는 이름이고, 본 디렉터리에는 위 예시 파일만 있을 뿐이다.

이제 컨테이너를 만들어보자.

desktop@vm:~/Docker/bind-test$ docker compose up -d

[+] Running 1/1

✔ Container cont-bind-test Started 0.0s

desktop@vm:~/Docker/bind-test$ ls -alR

total 20

drwxrwxr-x 3 desktop desktop 4096 11월 11 21:39 .

drwxrwxr-x 3 desktop desktop 4096 11월 11 20:39 ..

drwxr-xr-x 2 root root 4096 11월 11 21:39 bind-with-container

-rw-rw-r-- 1 desktop desktop 270 11월 11 21:15 docker-compose.yml

-rw-rw-r-- 1 desktop desktop 280 11월 11 21:34 Dockerfile

./bind-with-container:

total 8

drwxr-xr-x 2 root root 4096 11월 11 21:39 .

drwxrwxr-x 3 desktop desktop 4096 11월 11 21:39 ..

volume mount 설정대로

./bind-with-container가 만들어졌는데,

기대와 달리 안에는 어떤 파일도 없다.

먼저 volume bind mount는

host -> container의 방향으로만 진행하기 때문에,

Dockerfile에서 명시한 RUN touch /mybind/a 들은 실제론 실행되어서 만들어졌으나

volume bind 과정에서 host의 디렉터리가 덮어쓰면서 사라진 것이다.

아쉽게도 반대 방향의 복사를 시작시 자동으로 해올 순 없다.

bind 시점이 Dockerfile의 마지막 줄 이후의 시점이기 때문.

컨테이너의 파일을 가져오고 싶다면,

덮어씌워지지 않게 다른 곳을 bind해서

내부로 들어가 원하는 파일들을 bind된 곳으로 이동시킨 후,

host에서 파일을 가진 채 해당 파일들을 덮어쓸 수 있도록 bind를 설정하는 것 밖에는...

그럼 d,e,f는 왜 없을까??

desktop@vm:~/Docker/bind-test$ docker logs cont-bind-test

touch: cannot touch '/mybind/d': Permission denied

touch: cannot touch '/mybind/e': Permission denied

touch: cannot touch '/mybind/f': Permission denied

touch: cannot touch '/mybind/d': Permission denied

touch: cannot touch '/mybind/e': Permission denied

touch: cannot touch '/mybind/f': Permission denied

음... 무한히 1초마다 파일 생성은 시도하는데, 권한 문제가 발생한다.

내부로 들어가서 보자.

desktop@vm:~/Docker/bind-test$ docker exec -it cont-bind-test /bin/bash

user001@bind-test:/$ ls -al

total 64

drwxr-xr-x 1 root root 4096 Nov 11 12:35 .

drwxr-xr-x 1 root root 4096 Nov 11 12:35 ..

-rwxr-xr-x 1 root root 0 Nov 11 12:35 .dockerenv

lrwxrwxrwx 1 root root 7 Oct 4 02:08 bin -> usr/bin

drwxr-xr-x 2 root root 4096 Apr 18 2022 boot

drwxr-xr-x 5 root root 360 Nov 11 12:39 dev

drwxr-xr-x 1 root root 4096 Nov 11 12:35 etc

drwxr-xr-x 2 root root 4096 Apr 18 2022 home

lrwxrwxrwx 1 root root 7 Oct 4 02:08 lib -> usr/lib

lrwxrwxrwx 1 root root 9 Oct 4 02:08 lib32 -> usr/lib32

lrwxrwxrwx 1 root root 9 Oct 4 02:08 lib64 -> usr/lib64

lrwxrwxrwx 1 root root 10 Oct 4 02:08 libx32 -> usr/libx32

drwxr-xr-x 2 root root 4096 Oct 4 02:08 media

drwxr-xr-x 2 root root 4096 Oct 4 02:08 mnt

drwxr-xr-x 2 root root 4096 Nov 11 12:39 mybind

drwxr-xr-x 2 root root 4096 Oct 4 02:08 opt

dr-xr-xr-x 368 root root 0 Nov 11 12:39 proc

drwx------ 2 root root 4096 Oct 4 02:12 root

drwxr-xr-x 5 root root 4096 Oct 4 02:12 run

lrwxrwxrwx 1 root root 8 Oct 4 02:08 sbin -> usr/sbin

drwxr-xr-x 2 root root 4096 Oct 4 02:08 srv

dr-xr-xr-x 13 root root 0 Nov 11 12:39 sys

drwxrwxrwt 2 root root 4096 Oct 4 02:12 tmp

drwxr-xr-x 14 root root 4096 Oct 4 02:08 usr

drwxr-xr-x 1 root root 4096 Oct 4 02:12 var

user001@bind-test:/$ exit

exit

/mybind 디렉터리의 소유자가 root:root인 것을 볼 수 있다.

그래서 해당 디렉터리 내부에 파일을 생성할 수 없는 것.

그런데, Dockerfile에서 분명 RUN chown -R user001:user001 /mybind를 해줬는데, 왜 소유권이 안 바뀌어있을까?

이게 이번 케이스의 핵심이다.

컨테이너를 돌렸을 때, 자동으로 ./bind-with-container 디렉터리를 만들어주던 것을 위에서 봤었다.

desktop@vm:~/Docker/bind-test$ ls -alR

total 20

drwxrwxr-x 3 desktop desktop 4096 11월 11 21:39 .

drwxrwxr-x 3 desktop desktop 4096 11월 11 20:39 ..

drwxr-xr-x 2 root root 4096 11월 11 21:39 bind-with-container

-rw-rw-r-- 1 desktop desktop 270 11월 11 21:15 docker-compose.yml

-rw-rw-r-- 1 desktop desktop 280 11월 11 21:34 Dockerfile

./bind-with-container:

total 8

drwxr-xr-x 2 root root 4096 11월 11 21:39 .

drwxrwxr-x 3 desktop desktop 4096 11월 11 21:39 ..

나는 desktop 계정으로 docker 명령어를 실행했지만,

디렉터리를 자동으로 만들 때 root가 만든 것이다.

desktop@vm:~/Docker/bind-test$ id

uid=1000(desktop) gid=1000(desktop) groups=1000(desktop),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),

122(lpadmin),135(lxd),136(sambashare),999(docker)

desktop에 docker(999) 그룹을 추가해줬어서

딱히 sudo docker ~ 한 것이 아닌데도.

어쨌든 docker가 자동으로 만들 때 root가 디렉터리를 만들게 된다.

사실 volume mount를 할 때,

host의 디렉터리 소유권 (uid, gid)가 그대로 컨테이너에 전파된다.

desktop@vm:~/Docker/bind-test$ sudo su

root@vm:/home/desktop/Docker/bind-test# id

uid=0(root) gid=0(root) groups=0(root)

root의 uid, gid가 각각 0이라,

컨테이너에도 0:0으로 소유권을 덮어버리는데,

컨테이너에도 0은 root이기 때문에,

/mybind의 소유권이 0:0인 root:root로 덮어써진 것.

실제로 volume 마운트를 하지 않고 컨테이너를 만들면

Dockerfile에 RUN chown -R user001:user001 /mybind 한 대로 user001 소유의 디렉터리로 나온다.

이게 다 마운트시 소유권을 덮어써버려서 그렇다.

해결책은 간단하다.

host의 원본 디렉터리 소유 유저의 uid가 컨테이너 유저의 uid와 같으면 된다.

uid를 맞출 수 없는 상황도 있다. 그럼 gid를 맞추면 된다.

[volume mount의 문제 해결]

컨테이너에서 처음으로 adduser를 별다른 옵션없이 수행했으므로,

user001의 uid는 1000일 것이다.

desktop@vm:~/Docker/bind-test$ docker exec -it cont-bind-test /bin/bash

user001@bind-test:/$ id

uid=1000(user001) gid=1000(user001) groups=1000(user001)

host의 uid도 좋게도 1000으로 일치하는 상황이다.

desktop@vm:~/Docker/bind-test$ id

uid=1000(desktop) gid=1000(desktop) groups=1000(desktop),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),

122(lpadmin),135(lxd),136(sambashare),999(docker)

이러면 아주 간단한 상황이다.

하지만 host의 uid가 2003 같은 상황이라면??

Dockerfile에서 유저생성시 RUN adduser -u 2003 user001 처럼 uid를 지정해서 생성해준다.

뭐 어떻게 해도 uid를 맞추기는 힘든 상황이다?? (혹은 여러 소유권이 다른 여러 디렉터리를 마운트해야한다거나)

만약 host의 원본 디렉터리의 그룹소유권을 통일 시켜주고 해당 gid로 그룹을 맞춰주자.

gid가 4002라고 하면,

Dockerfile에서 먼저 RUN addgroup -g 4002 group001로 gid가 같은 그룹을 생성.

이후 RUN adduser -G 4002 user001 (g는 기본그룹을 수정하지만, G는 기본그룹에 추가되도록)로 추가 그룹을 설정해준다.

유저 생성 후에 RUN addgroup -g 4002 user001로 추가 그룹을 줘도 된다.

위의 경우들이라면 Dockerfile을 수정하고 다시 컨테이너를 만들어야한다.

desktop@vm:~/Docker/bind-test$ docker stop cont-bind-test

cont-bind-test

desktop@vm:~/Docker/bind-test$ docker rm cont-bind-test

cont-bind-test

desktop@vm:~/Docker/bind-test$ docker rmi image-bind-test

Untagged: image-bind-test:latest

Deleted: sha256:61f81705fd4fe64c647d9160517983facd615d231aec3b267a3e3464c3ee8738

(기존 컨테이너 중지, 삭제, 빌드된 이미지 삭제)

이미 uid나 gid가 같다면 그냥 정지만 해두고 해결 후 재실행하자.

desktop@vm:~/Docker/bind-test$ docker stop cont-bind-test

cont-bind-test

desktop@vm:~/Docker/bind-test$ sudo chown -R desktop:desktop ./bind-with-container

desktop@vm:~/Docker/bind-test$ ls -alR

total 20

drwxrwxr-x 3 desktop desktop 4096 11월 11 21:39 .

drwxrwxr-x 3 desktop desktop 4096 11월 11 20:39 ..

drwxr-xr-x 2 desktop desktop 4096 11월 11 21:39 bind-with-container

-rw-rw-r-- 1 desktop desktop 270 11월 11 21:15 docker-compose.yml

-rw-rw-r-- 1 desktop desktop 280 11월 11 21:34 Dockerfile

./bind-with-container:

total 8

drwxr-xr-x 2 desktop desktop 4096 11월 11 21:39 .

drwxrwxr-x 3 desktop desktop 4096 11월 11 21:39 ..

host의 컨테이너 소유권을 수정해주고, 다시 컨테이너를 실행하자.

desktop@vm:~/Docker/bind-test$ docker compose up -d

[+] Running 1/1

✔ Container cont-bind-test Started 0.0s

desktop@vm:~/Docker/bind-test$ ls -alR

total 20

drwxrwxr-x 3 desktop desktop 4096 11월 11 21:39 .

drwxrwxr-x 3 desktop desktop 4096 11월 11 20:39 ..

drwxr-xr-x 2 desktop desktop 4096 11월 11 21:41 bind-with-container

-rw-rw-r-- 1 desktop desktop 270 11월 11 21:15 docker-compose.yml

-rw-rw-r-- 1 desktop desktop 280 11월 11 21:34 Dockerfile

./bind-with-container:

total 8

drwxr-xr-x 2 desktop desktop 4096 11월 11 21:41 .

drwxrwxr-x 3 desktop desktop 4096 11월 11 21:39 ..

-rw-r--r-- 1 desktop desktop 0 11월 11 21:41 d

-rw-r--r-- 1 desktop desktop 0 11월 11 21:41 e

-rw-r--r-- 1 desktop desktop 0 11월 11 21:41 f

d,e,f 파일이 잘 생성되었다.

desktop@vm:~/Docker/bind-test$ docker exec -it cont-bind-test /bin/bash

user001@bind-test:/$ ls -al

total 64

drwxr-xr-x 1 root root 4096 Nov 11 12:35 .

drwxr-xr-x 1 root root 4096 Nov 11 12:35 ..

-rwxr-xr-x 1 root root 0 Nov 11 12:35 .dockerenv

lrwxrwxrwx 1 root root 7 Oct 4 02:08 bin -> usr/bin

drwxr-xr-x 2 root root 4096 Apr 18 2022 boot

drwxr-xr-x 5 root root 360 Nov 11 12:41 dev

drwxr-xr-x 1 root root 4096 Nov 11 12:35 etc

drwxr-xr-x 2 root root 4096 Apr 18 2022 home

lrwxrwxrwx 1 root root 7 Oct 4 02:08 lib -> usr/lib

lrwxrwxrwx 1 root root 9 Oct 4 02:08 lib32 -> usr/lib32

lrwxrwxrwx 1 root root 9 Oct 4 02:08 lib64 -> usr/lib64

lrwxrwxrwx 1 root root 10 Oct 4 02:08 libx32 -> usr/libx32

drwxr-xr-x 2 root root 4096 Oct 4 02:08 media

drwxr-xr-x 2 root root 4096 Oct 4 02:08 mnt

drwxr-xr-x 2 user001 user001 4096 Nov 11 12:41 mybind

drwxr-xr-x 2 root root 4096 Oct 4 02:08 opt

dr-xr-xr-x 366 root root 0 Nov 11 12:41 proc

drwx------ 2 root root 4096 Oct 4 02:12 root

drwxr-xr-x 5 root root 4096 Oct 4 02:12 run

lrwxrwxrwx 1 root root 8 Oct 4 02:08 sbin -> usr/sbin

drwxr-xr-x 2 root root 4096 Oct 4 02:08 srv

dr-xr-xr-x 13 root root 0 Nov 11 12:41 sys

drwxrwxrwt 2 root root 4096 Oct 4 02:12 tmp

drwxr-xr-x 14 root root 4096 Oct 4 02:08 usr

drwxr-xr-x 1 root root 4096 Oct 4 02:12 var

컨테이너의 /mybind 디렉터리의 소유권을 보면 원하는 대로 유지되어있다.

(사실은 원하는 목표의 uid:gid로 덮어쓴거지만)

[실행과 상대 경로의 문제]

어.. 그런데 딱히 위의 문제가 아닌데도 로그 파일들을 생성할 수 없다면..??

특히 로그 파일 생성 위치가 절대 경로가 아니라 상대 경로인 경우일겁니다.

로컬 빌드된 파일을 생성해봅시다.

여기선 java의 .jar 파일로 예시를 들겠습니다.(뭐 go lang이든 python이든...)

.jar 파일을 생성해주세요.

그리고 터미널의 위치를 변경하여 그곳에서 .jar파일을 실행해줍니다.(java -jar ~.jar ~)

그러면 해당 위치를 기준으로 로그 디렉터리를 생성할겁니다.

일부러 위치를 변경하여 그곳에서 다시 .jar파일을 실행해보세요.

또 그 곳 기준으로 로그 디렉터리를 생성할겁니다.

혹시 Dockerfile에서 USER ubuntu001 이후,

WORKDIR ~ 를 빼먹진 않으셨나요?

위의 케이스와 겹치는 문제가 어느 정도 있는데,

user001의 권한을 갖는 /mybind로 이동해서 컨테이너가 빌드 파일을 실행한다면 하위 디렉터리도 만들고 파일도 제대로 생성하지만,

WORKDIR /mybind가 없다면

root:root권한인 /에서 하위 디렉터리나 파일을 생성할 수 없어서 로그 파일을 남기지 못하는 상황입니다.

[실행과 상대 경로의 문제 해결]

[volume mount의 문제 해결]이 된 상태라면 이번 문제는 딱히 어렵지 않습니다.

CMD/ENTRYPOINT [ ~ ] 이전에 user001이 권한을 가진 곳으로 WORKDIR ~를 해주세요.

MongoDB 기초

현록 — Thu, 13 Jul 2023 20:37:23 +0900

이전 포스트에서 mongosh로 MongoDB Shell로 접속한 후의 상황에서 이어진다.

[Study/MongoDB] - Docker Compose로 MongoDB 환경 세팅

blackdeer@Mac mongodb % docker exec -it mongodb /bin/bash

root@mongodb:/# mongo

bash: mongo: command not found

root@mongodb:/# mongosh -u root -p example

Current Mongosh Log ID: 64afa30efd5fb964295551f8

Connecting to: mongodb://<credentials>@127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+1.10.1

Using MongoDB: 6.0.7

Using Mongosh: 1.10.1

For mongosh info see: https://docs.mongodb.com/mongodb-shell/

------

The server generated these startup warnings when booting

2023-07-13T07:01:43.903+00:00: vm.max_map_count is too low

------

test> show databases

admin 100.00 KiB

config 60.00 KiB

local 72.00 KiB

RDB의 용어와 비교하자면 다음과 같다

RDB	MongoDB
Database	Database
Table	Collection
Column	Field
Row	Document

RDB는 Table에 Column설정을 하고 데이터들을 Row 형태로 저장할텐데,

Document형 NoSQL인 MongoDB는 Collection에 json형식의 Document를 저장한다.

json문서가 데이터이며 내부 키(Field)들이 RDB의 Column과 닮았다고 할 수 있는데,

RDB처럼 Table 생성시 정한 Column들만 사용할 수 있는 것이 아니라

문서를 어떻게 작성하느냐에 따라 언제든 스키마 수정 없이(스키마를 정의하지도 않았으니) 가변적으로 활용할 수 있다.

그래서 하위 항목으로 갈 수록(Column, Row) 용어를 1:1로 완벽하게 매칭시킬 순 없다.

유연성은 더 좋지만 반대로 속도나 무결성 등에 대해서는 잃는 것도 있기 때문에 어느 쪽이 반드시 좋다고 할 순 없다.

(그리고 이 수치는 RDB에서 얼마나 JOIN을 하는지, 데이터 디자인이 어떤지에 따라서도 달리지기 때문에

반드시 뒤쳐지고 반드시 좋아진다고 단정지을 수 없는 부분이다.

이러한 이론에 대한 부분은 이 포스트에서 다루지 않는다.)

use 데이터베이스명으로 데이터베이스를 생성한다.

이건 정확하게는 현재 사용할 db를 선택하는 것이다.

test> show databases

admin 100.00 KiB

config 72.00 KiB

local 72.00 KiB

test> use test01

switched to db test01

test01> show dbs

admin 100.00 KiB

config 72.00 KiB

local 72.00 KiB

그런데 쉘 앞만 test에서 우리가 생성한 데이터베이스명(test01)으로 바뀌었을 뿐 데이터베이스는 아직 만들어지지 않은 것 같다.

MongoDB에서는 실제로 document나 collection을 생성해야만 DB가 생성된다.

원문: MongoDB only creates the database when you first store data in that database. This data could be a collection or a document.

(https://www.mongodb.com/basics/create-database)

Mongo Express의 GUI를 통해서 database를 생성해도

내부에는 delete_me 라는 이름의 빈 collection이 포함된 채로 database가 생성되게 된다.

collection을 생성해보자

test01> db.createCollection('book')

{ ok: 1 }

test01> show databases

admin 100.00 KiB

config 108.00 KiB

local 72.00 KiB

test01 8.00 KiB

이제는 database가 생성된 것을 볼 수 있다.

이제 collection 안에 문서를 저장해보자

test01> db.book.find()

test01> db.book.insertOne({"author": "Kim", "title": "Easy Cooking"})

{

acknowledged: true,

insertedId: ObjectId("64afe579952fbf5c1d6a917d")

}

test01> db.book.insertMany([{"author": "Park", "title": "Chemical Science", "publisher": "Han-sam"}, {author: "Lee", title: "Cat Holic"}])

{

acknowledged: true,

insertedIds: {

'0': ObjectId("64afe58e952fbf5c1d6a917e"),

'1': ObjectId("64afe58e952fbf5c1d6a917f")

}

test01> db.book.find()

[

{

_id: ObjectId("64afe579952fbf5c1d6a917d"),

author: 'Kim',

title: 'Easy Cooking'

{

_id: ObjectId("64afe58e952fbf5c1d6a917e"),

author: 'Park',

title: 'Chemical Science',

publisher: 'Han-sam'

{

_id: ObjectId("64afe58e952fbf5c1d6a917f"),

author: 'Lee',

title: 'Cat Holic'

}

]

json형식으로 작성한 문구를 하나씩 혹은 여러개를 저장할 수 있고,

collection을 만들 때 RDB처럼 column을 정해둔 것이 아니기에

문서마다 다른 키를 가져도 상관없이 저장할 수 있다.

기존 문서의 수정과 확인(특정 조건 문서 조회)

test01> db.book.updateOne({_id: ObjectId("64afe58e952fbf5c1d6a917f")}, {$set: {author: "Kim"}})

{

acknowledged: true,

insertedId: null,

matchedCount: 1,

modifiedCount: 1,

upsertedCount: 0

}

test01> db.book.find({author: 'Kim'})

[

{

_id: ObjectId("64afe579952fbf5c1d6a917d"),

author: 'Kim',

title: 'Easy Cooking'

{

_id: ObjectId("64afe58e952fbf5c1d6a917f"),

author: 'Kim',

title: 'Cat Holic'

}

]

문서의 삭제

test01> db.book.deleteOne({_id: ObjectId("64afe579952fbf5c1d6a917d")})

{ acknowledged: true, deletedCount: 1 }

test01> db.book.find({author: "Kim"})

[

{

_id: ObjectId("64afe58e952fbf5c1d6a917f"),

author: 'Kim',

title: 'Cat Holic'

}

]

collection의 삭제

test01> db.book.drop()

true

test01> show dbs

admin 100.00 KiB

config 108.00 KiB

local 72.00 KiB

database에 남은 collection이 하나도 없기 때문에 database도 지워진다.

여전히 test01 db를 사용하는 상태이기 때문에 collection을 추가하면 바로 database와 함께 collection이 생성될 것.

database의 삭제

test01> db.dropDatabase()

{ ok: 1, dropped: 'test01' }

test01> db.dropDatabase()

{ ok: 1, dropped: 'test01' }

database 내부의 collection이나 document들 모두와 함께 지울 수 있다.

MongoDB의 유저 생성은 admin database에 기록된다

test01> use admin

switched to db admin

admin> db.createUser({user: "user01", pwd: "123456", roles: [{role: "readWrite", db: "test01"}]})

{ ok: 1 }

위는 Mongo Express에서 확인한 화면(admin>system.users)

https://www.mongodb.com/docs/v6.0/tutorial/create-users/

https://www.mongodb.com/docs/v6.0/tutorial/manage-users-and-roles/

메뉴얼에서 다른 예제나 수정 및 커스텀 권한 등도 찾아볼 수 있다.

공식 문서 중 기초 부분

https://www.mongodb.com/basics

Beginners Guide: MongoDB Basics

Learn the basics of MongoDB and some of the key concepts.

www.mongodb.com

Docker Compose로 MongoDB 환경 세팅

현록 — Thu, 13 Jul 2023 16:42:56 +0900

아래는 docker-compose.yml 내용

services:

mongodb:

image: mongo

container_name: mongodb

ports:

- 27017:27017

environment:

- MONGO_INITDB_ROOT_USERNAME=root

- MONGO_INITDB_ROOT_PASSWORD=example

volumes:

- ./data/db:/data/db

networks:

- network-mongo

hostname: mongodb

# ----------------------------------------

mongo-express:

depends_on:

- mongodb

image: mongo-express

container_name: mongo-express

ports:

- 27117:8081

environment:

- PORT=8081

- ME_CONFIG_MONGODB_PORT=27017

- ME_CONFIG_MONGODB_SERVER=mongodb

- ME_CONFIG_MONGODB_ADMINUSERNAME=root

- ME_CONFIG_MONGODB_ADMINPASSWORD=example

- ME_CONFIG_MONGODB_URL=mongodb://root:example@mongodb:27017/

networks:

- network-mongo

hostname: mongo-express

# ----------------------------------------

# ========================================

networks:

network-mongo:

driver: bridge

Docker Compose 명령을 실행하면 최신 이미지를 받아 컨테이너를 구성한다

blackdeer@Mac mongodb % docker-compose up -d

[+] Running 19/19

✔ mongo-express 8 layers [⣿⣿⣿⣿⣿⣿⣿⣿] 0B/0B Pulled 21.8s

✔ 6a428f9f83b0 Pull complete 1.7s

✔ f2b1fb32259e Pull complete 12.0s

✔ 40888f2a0a1f Pull complete 12.2s

✔ 4e3cc9ce09be Pull complete 12.2s

✔ eaa1898f3899 Pull complete 12.3s

✔ ab4078090382 Pull complete 18.2s

✔ ae780a42c79e Pull complete 18.2s

✔ e60224d64a04 Pull complete 18.2s

✔ mongodb 9 layers [⣿⣿⣿⣿⣿⣿⣿⣿⣿] 0B/0B Pulled 36.8s

✔ 9d19ee268e0d Pull complete 10.4s

✔ 84c1327991fa Pull complete 10.4s

✔ 1feec59ecd14 Pull complete 11.0s

✔ 3af7480eaf55 Pull complete 11.1s

✔ d7524ee16ced Pull complete 11.1s

✔ f4742175eefc Pull complete 11.2s

✔ 9d688a8d9c18 Pull complete 11.2s

✔ b24ebfb25f44 Pull complete 33.1s

✔ 0ee52198e640 Pull complete 33.2s

[+] Running 3/3

✔ Network mongodb_network-mongo Created 0.0s

✔ Container mongodb Started 0.3s

✔ Container mongo-express Started 0.5s

컨테이너에 접근해본다.

blackdeer@Mac mongodb % docker exec -it mongodb /bin/bash

root@mongodb:/# mongo

bash: mongo: command not found

root@mongodb:/# mongosh -u root -p example

Current Mongosh Log ID: 64afa30efd5fb964295551f8

Connecting to: mongodb://<credentials>@127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+1.10.1

Using MongoDB: 6.0.7

Using Mongosh: 1.10.1

For mongosh info see: https://docs.mongodb.com/mongodb-shell/

------

The server generated these startup warnings when booting

2023-07-13T07:01:43.903+00:00: vm.max_map_count is too low

------

test> show databases

admin 100.00 KiB

config 60.00 KiB

local 72.00 KiB

MongoDB 6.0부터는 mongo 명령이 아닌 mongosh 명령으로 쉘을 실행한다.

mongosh 접속 관련 문서는 여기

https://www.mongodb.com/docs/mongodb-shell/connect/

Connect to a Deployment — MongoDB Shell

Docs Home → MongoDB Shell This page shows how to use the MongoDB Shell to connect to a MongoDB deployment.To use the MongoDB Shell, you must have a MongoDB deployment to connect to.You can use the MongoDB Shell to connect to MongoDB version 4.2 or greate

www.mongodb.com

웹브라우저로

http://localhost:27117/

(위는 도커 컨테이너가 localhost에서 돌아가고 있을 때의 예시)

로 접근하면 Mongo Express의 GUI로 DB를 볼 수 있다.

(docker-compose.yml에서 mongo-express의 내부 8081포트를 외부 27117로 포워딩했었다)

iOS ChatGPT 단축어

현록 — Mon, 15 May 2023 15:40:15 +0900

먼저 ChatGPT를 이용하기 위한 계정이 필요합니다.
https://platform.openai.com/
에서 회원가입을 한 후(이미 사용하고 있었다면 그냥 로그인),

https://platform.openai.com/account/api-keys
여기로 들어가서 API key를 생성합니다.

위 버튼을 눌러 키를 생성합니다.
키는 한 번 보여준 후 다시는 공개하지 않으니, 잘 복사해둡니다.
잊어버렸다면 다시 생성하면되지만...

그리고 단축어를 복제받은 애플기기(iOS/iPad OS/Mac)에서
위 키를 복사한 상태로 진행합니다.
그래야 아래 복제 단계에서 키를 입력하기 수월합니다.

iOS/iPad OS/Mac 등 애플 기기에서 아래의 단축어 공유 링크를 클릭하여 단축어를 복제받습니다.

① [텍스트 직접 입력형 + 취소 전까지 반복]
직접 눌러서 사용에 추천
https://www.icloud.com/shortcuts/8758a78c9dc84adc9aa5ab4bc8917971

② [음성 받아 넘김형 + 취소 전까지 반복]
Siri에 추천 (Siri야, 단축어이름)
https://www.icloud.com/shortcuts/f033d9fe68e2486e9d8cb1707e6cdc64

③ [음성 받아 넘김형 + 한 번만 실행]
Apple Watch에 추천 (Apple Watch에서 단축어앱을 실행하여 직접 눌러서 사용에 추천)
https://www.icloud.com/shortcuts/610fbcc06c2d4a0fb2482eca52b33110

복제받을 때 두 가지를 설정하도록 되어있습니다.
ㆍ하나는 위에서 작성한 API key입니다. 복사해두었으니 붙여넣으면 됩니다.
ㆍ두번째는 temperature인데, 0.0~2.0의 값으로,
　0.0에 가까울 수록 정확한 답만을 할 뿐, 부정확한 정보는 아예 걸러버리며,
　2.0에 가까울 수록 사람처럼 답하려고 하며, 조금 부정확하더라도 제공해주려고 합니다.
　기본값은 1.0입니다.

이렇게 생성한 단축어들은 모두 ChatGPT로 넘기고 응답을 받아야 하므로
권한 동의가 최초 실행시에 한 번 뜹니다.
항상 허용해주면 됩니다.

위 셋 모두 현재 시간, 질문, 응답을 하나로 묶어 메모앱에 기록하는 로그 기능이 있습니다.
이런 기능들은 입맛에 맞게 수정하거나 삭제하시면 됩니다.

Siri에게 음성으로 묻기에는 ②가 제일 적합합니다.(음성으로 넘기고, 반복해서 물어볼 수 있기 때문)
②의 이름을 '알려줘'라고 지정해둔다면,
"Siri야, 알려줘"의 발화문을 Siri가 들었을 때 실행되어 음성을 받아 ChatGPT로 넘기고 응답을 받아 읽어줍니다.
(Siri로 실행했을 때는 응답을 읽어줍니다)
(잠금상태가 아닐 때는 자연스럽게 반복되지만, 잠금 상태에서는 로그를 메모에 작성하려고 잠금 해제를 하려고 합니다.
이런 부분이 싫다면 로그 작성 부분을 지우시면 됩니다.)
①과 ③은 Siri로 실행되지 않을 법한 이름으로 지정해두시면 Siri의 혼선을 피할 수 있습니다.

①은 텍스트를 직접 입력하기에 음성 받아쓰기의 부정확함을 피할 수 있습니다.

③은 Apple Watch의 음성 받아쓰기는 어차피 '완료'를 누르기 까지는 음성 종료를 인식하지 않으며,
응답 결과를 직접 닫기도 해야하기에,
반복형이라 종료시에 취소를 눌러야 하는 형태가 아니라
그냥 한 번만 실행되게 하였습니다.
①과 ②는 Apple Watch에서 보기를 꺼주시고, ③만 켜주시면 혼잡해지지 않습니다.

위의 단축어들은 가장 기본적인 request로 작성했습니다.
REST API의 다른 옵션들은 아래의 링크 문서에서 확인
https://platform.openai.com/docs/api-reference/completions/create

[Lv4] 징검다리 - 이분탐색(BS)

현록 — Mon, 17 Apr 2023 14:38:57 +0900

출발지점부터 distance만큼 떨어진 곳에 도착지점이 있습니다.

그리고 그사이에는 바위들이 놓여있습니다.

바위 중 몇 개를 제거하려고 합니다.

예를 들어, 도착지점이 25만큼 떨어져 있고,

바위가 [2, 14, 11, 21, 17] 지점에 놓여있을 때 바위 2개를 제거하면

출발지점, 도착지점, 바위 간의 거리가 아래와 같습니다.

제거한 바위의 위치	각 바위 사이의 거리	거리의 최솟값
[21, 17]	[2, 9, 3, 11]	2
[2, 21]	[11, 3, 3, 8]	3
[2, 11]	[14, 3, 4, 4]	3
[11, 21]	[2, 12, 3, 8]	2
[2, 14]	[11, 6, 4, 4]	4

위에서 구한 거리의 최솟값 중에 가장 큰 값은 4입니다.

출발지점부터 도착지점까지의 거리 distance,

바위들이 있는 위치를 담은 배열 rocks,

제거할 바위의 수 n이 매개변수로 주어질 때,

바위를 n개 제거한 뒤 각 지점 사이의 거리의 최솟값 중에 가장 큰 값을 return 하도록

solution 함수를 작성해주세요.

제한사항

ㆍ도착지점까지의 거리 distance는 1 이상 1,000,000,000 이하입니다.

ㆍ바위는 1개 이상 50,000개 이하가 있습니다.

ㆍn 은 1 이상 바위의 개수 이하입니다.

입출력 예

distance	rocks	n	return
25	[2, 14, 11, 21, 17]	2	4

ㆍ제한사항의 1항에서 10억의 숫자를 보고 이진 탐색의 힌트를 얻는다.

ㆍ각 바위 사이의 거리를 벌리는 것이다. '거리'를 대상으로 푼다.

ㆍ주어지는 배열 rocks는 정렬된 상태가 아니다. 거리를 구하기 위해 먼저 rocks 배열을 정렬하고 시작한다.

최단 간격을 갖는 바위를 우선적으로 제거하고,

최단 간격 양 옆 중의 바위의 선택은, 바위가 없어져서 반대편 거리와 합쳐질 때 그 합쳐진 거리가 더 짧은 쪽을 선택하면 될 것 같지만...

아래의 예시를 보자.

(8) 돌 (8) 돌 (12) 돌 (13) 돌 (8) 돌 (8) 돌 (14) 돌 (19)

빨간 돌도 파란 돌도 양 옆의 간격이 8씩으로, 8도 같고, 8+8=16도 동일하다.

어느 돌을 선택하느냐에 따라 다음 번에 영향을 주고, 바위의 수는 최대 5만 개에 거리는 10억.

단순히 모든 경우의 수를 반복하기엔 메모리가 부족할 수도 있고 속도도 나오지 않는다.

이제 이분 탐색에서 뭘 기준으로 삼는가를 잘 캐치할 수 있어야 한다.

이건 많은 문제를 풀어보고 경험치를 높여야 한다는데...

여기서는 왼쪽에서 오른쪽으로 무작정(모든 간격의 최소치나 간격의 합 등을 고려하지 않고) '제거해나갈 수 있는 기준'으로 삼는다.

바위의 왼쪽 간격이 이 기준치 이하라면 제거한다.

(왼쪽 간격을 보면, 반복문에서 가장 마지막 간격은 검토 대상에서 제외된다. 이 간격은 바위 기준 오른쪽 distance와의 간격이라)

기준치를 초과한다면 제거하지 않고 다음 바위로 넘어간다.

모든 바위를 검토했을 때, 이 기준치에서 제거한 총 바위의 수를 센다.

바위를 n보다 더 많이 제거했다면 기준치가 높은 것이니 내려야한다(더 적게 부수도록. high = mid).

바위를 n보다 더 적게 제거했다면 기준치가 낮은 것이니 높여야한다(더 많이 부수도록. low = mid).

바위를 n만큼 딱 부수었어도 기준치는 높여본다. n보다 초과하지는 않지만 n만큼인 선에서 최대한 제거하도록 기준치를 높인다.

(우리가 이분 탐색하면서 찾는 것이 n이 아니며, 바위를 제거하는 기준임. 또한 최종 정답이 이 기준도 아닌 것도 기억)

이분 탐색시 맨 처음 low ~ high 값은 무엇이겠는가?

기준치로 간격을 판정한다고 했으니 이것도 간격이다.

모든 바위를 제거했다면 간격이 최대가 되고, 이 값은 distance와 일치한다.

즉, 0 ~ distance로 이분 탐색을 시작하면 된다.

이제 이분 탐색을 하면서 바위를 제거하는 횟수가 n이면서 바위를 부수는 기준이 한 곳으로 수렴할 수 있다.

근데 최종 제출 답이 이 기준이 아니라 n만큼 제거했을 때의 경우들 중에서

간격 중 가장 작은 값들을 대표로 했을 때에 그 중 최대인 값이다(얼마나 간격들을 고르게 넓게 퍼뜨렸냐는).

이분 탐색을 하면서 찾는 값과 최종 제출 값이 다르기 때문에, 이분 탐색을 하면서(기준을 구하면서) 마지막엔 간격 중 최솟값을 저장해둬야한다. 이 최솟값이 커져야하므로, 저장하는 값은 가장 큰 값 하나면 된다.

간격들은 최대 50002개가 될 수 있으니, 이 간격들을 훑는 때도 생각해보자.

만약 n이 3이라고 해보자.

이분 탐색에서 어떤 기준으로 바위들을 모두 제거했을 때, 제거한 수가 3보다 더 많을 때(4 이상인 때)의 간격들은 딱히 도움이 안된다.

n보다 더 많이 제거할 수 있다면 그냥 다 제거해서 최대 간격도 나올테니...

이분 탐색시 제거하는 수가 n과 같아질 때 간격의 최솟값을 구한다. 그리고 n보다 높아질 땐 더 이상 진행하지 않고 바로 기준치를 낮추는 다음 루프를 진행해도 된다.

n보다 더 적게 제거한 상황은 어떨까?(기준치가 낮아서 모든 간격을 훑었지만 n보다 적게 제거하고 끝난 상태)

이분 탐색으로 기준치를 시험해보는 과정에서 기준치가 낮다는 것을 안 것과 별개로

이 경우는 확실히 n보다 더 적게 제거하고도 간격을 많이 벌린 훌륭한 경우이다. 여기서 부족한 수 만큼 더 제거한다면 최소 간격은 더 벌어질 수 있다! 그러니 이 때의 간격 중 최솟값도 저장해야한다.

즉, 최솟값을 저장하는 때는 'n과 일치하게 제거했을 때'와 'n보다 적게 제거하고도 모든 간격을 훑게 되었을 때'이다.

기준치로 바위를 제거하는 과정도 보자.

물론 바위를 제거하면 바위 기준 왼쪽의 간격과 오른쪽의 간격이 합쳐지겠지만,

매 번 새로운 간격 배열을 재생성하는 것은 메모리 측면에서도 속도 측면에서도 비효율적이다.

(2)₀ (4)₁ (8)₂ (4)₃ (7)₄ (2)₅ (12)₆ (8)₇

인 배열을 보자(아래 첨자로 index 표기). 기준치가 7인 상황.

맨 처음에는 0번 index(값:2)를 오른쪽과 합칠지 말지 결정할 것이다(바위로 생각하면 0번과 1번 사이의 바위가 제거되어 양 간격이 합쳐지는 상황)

2는 7보다 작으니, 합쳐지면 된다.

(-)₀ (6)₁ (8)₂ (4)₃ (7)₄ (2)₅ (12)₆ (8)₇

합쳐진다면 index가 증가하고(이번엔 1번 index(값:6 =2+4)를 보게되니), 제거될 값이 다음 검토시에 합쳐지도록 기억만 하면 된다.

6(=2+4)도 7보다 작으니 합쳐질 것이다.

(-)₀ (-)₁ (14)₂ (4)₃ (7)₄ (2)₅ (12)₆ (8)₇

이번에도 index도 증가하고(이번엔 2번 index(값:14 =2+4+8)를 보게되니), 제거된 값도 합쳐졌다.(배열에 값을 변화시키면 다시 원복하거나 원본을 복제받거나 해야하니, 그냥 sum용 변수에 합치도록 한다)

14(=2+4+8)는 7보다 크니, 합쳐지지 않는다.

(-)₀ (-)₁ (14)₂ (4)₃ (7)₄ (2)₅ (12)₆ (8)₇

이번에는 index만 증가하고(이번엔 3번 index(값:4)를 보게되니), 검토하는 값은 3번 index의 값만 검토하면 된다.

바위를 제거할 때(간격이 합쳐질 때)는 index증가, 다음 번 검토시에 합친 값이 검토되도록 값을 저장.

바위를 제거하지 않을 때(넘길 때)는 index만 증가, 검토시에 같이 검토하던 값을 0으로.

(즉, index는 항상 증가. 검토시 같이 보는 값에 누적하거나 초기화하거나.)

이 간격을 훑는 과정에서 간격의 최솟값도 함께 구해야 시간복잡도를 늘리지 않을 수 있다.

(min은 이번 이분 탐색에서의 간격 중 최솟값. result는 전체 케이스에서 최솟값들 중 최댓값)

아직 바위를 제거한 수가 n을 넘기지 않은 때라면

바위를 제거하지 않을 때엔 넘어가면서 기존 값을 min과 비교하여 기록.

바위를 제거할 땐 계속 변할 값(더 누적될 수도 있는)이니 당장 신경쓰지 않아도 된다.

하지만 제거하는 수가 n이 된 순간에는 더 이상의 제거는 의미가 없으니,

n이 된 순간에 현재 검토하던 값과 그 뒤로의 간격들을 끝까지 모두 훑으면서 값들을 min과 비교하여 기록.

모두 훑은 후, 이 min이 result와 비교하여 그보다 크다면 기록 후 이분 탐색을 다시 하도록 한다.

n보다 적게 바위를 제거하고도 모든 간격을 훑은 경우라면, '마지막 간격'만 한 번 더 min을 검토하고

(바위 제거 반복문에서는 바위 기준 왼쪽 간격을 검토했기 때문에, 맨 마지막 바위의 오른쪽 간격에 해당하는 마지막 간격은 훑지 않았어서),

min이 result와 비교하여 그보다 크다면 기록 후 이분 탐색을 다시 하게 된다.

이렇게 이분 탐색에서 low ~ high가 한 곳으로 수렴한 상황에서

그동안 매 회 min들 중 최댓값을 기록한 result를 반환하면 된다.

그런데, 정말로 무작정 제거를 위한 기준을 찾는 이분 탐색 과정이

바위를 n개 제거하는 모든 경우를 훑어서 올바른 result를 기록하는 것이 맞냐는 물음에는 나도 확신이 안 선다.

이 포스팅은 나도 다른 사람들의 힌트와 전략을 내 방식대로 설명한 것에 그치지 않는다.

이 부분에 대해서는 알게되는 바가 있으면 더 기록하도록 하겠다.

다운로드 파일 hash check용 certutil bat

현록 — Mon, 6 Mar 2023 12:13:17 +0900

@echo off
echo %1
For /F Delims^= %%G In ('certutil -hashfile %1 MD5 ^| FindStr /VRC:"[^a-f 0-9]"') Do Set "md5=%%G"
echo.
echo    MD5: %md5%
For /F Delims^= %%G In ('certutil -hashfile %1 SHA1 ^| FindStr /VRC:"[^a-f 0-9]"') Do Set "sha1=%%G"
echo.
echo   SHA1: %sha1%
For /F Delims^= %%G In ('certutil -hashfile %1 SHA256 ^| FindStr /VRC:"[^a-f 0-9]"') Do Set "sha256=%%G"
echo.
echo SHA256: %sha256%
For /F Delims^= %%G In ('certutil -hashfile %1 SHA512 ^| FindStr /VRC:"[^a-f 0-9]"') Do Set "sha512=%%G"
echo.
echo SHA512: %sha512%
For /F Delims^= %%G In ('certutil -hashfile %1 MD2 ^| FindStr /VRC:"[^a-f 0-9]"') Do Set "md2=%%G"
echo.
echo    MD2: %md2%
For /F Delims^= %%G In ('certutil -hashfile %1 MD4 ^| FindStr /VRC:"[^a-f 0-9]"') Do Set "md4=%%G"
echo.
echo    MD4: %md4%
For /F Delims^= %%G In ('certutil -hashfile %1 SHA384 ^| FindStr /VRC:"[^a-f 0-9]"') Do Set "sha384=%%G"
echo.
echo SHA384: %sha384%
echo.
pause

작성한 .bat 아이콘 위에 파일을 드래그앤드롭으로 실행

(분석하려는 파일의 용량이 클 수록 오래 걸리기 때문에(특히 MD2),

필요한 hash algorithm만 남기고 제거해도 됨)

TransNOCR 1.8.0 업데이트 후기

현록 — Thu, 2 Mar 2023 18:17:26 +0900

최근에 플로팅 번역의 폰트 관련하여 받은 요청사항이 있어서 해당 기능을 중점으로 수정했다.

그러면서 그동안엔 모두 수직으로만 글자를 인식하려고 했단 것도 깨닫고

각도를 계산하여 원문과 동일하게 출력하도록 했다.

문단의 모든 처음과 끝이 동일한 크기이면 좋으련만, ...으로 끝나는 등 갑자기 높이가 극단적으로 낮아지면 고려할 사항이 더 생긴다.

그래서 모자형태(_■■■■■_)의 문단을 가정하여 이리저리 계산해봤다.

다만, Google Vision OCR이 항상 네 꼭지점을 동일한 순서대로만 주지 않고 가끔씩 뒤틀려 주기도 해서

네 점의 순서대로만 각도를 계산하면 가끔씩 버그가 발생했다.

직각이 아닐 때는 오히려 괜찮은데, 직각일 때 가끔씩 순서를 엉망으로 준다.

그래서 직각일 때는 가로/세로 중 긴 것으로만 판단하여 0˚, 270˚로만 출력.

세로가 가로가 되고 가로가 세로가 되는 버그보다는 낫다고 판단하여...ㅠ

오랜만에 삼각함수를 들여다보니 재미는 있었다.

어차피 공대생이라 대학교에서도 미적분이니 매트릭스니 계속 사용했지만,

고등학생 때도 알고 있었다. 다 쓸 데가 있고, 우리는 어지간해서는 아마 쓸 것이라고...ㅎㅎ

프로그램은 개발 키를 사용하는 특성상 일반인들이 설치하기에도 좀 번거로운 부분이 있는데,

그 중 jre도 그렇다.

Java를 다루기 전에는 jre가 필요한 3D 모델링 프로그램을 사용할 때 이걸 왜 경로에 둬야하는지도 모르겠던 경험이 있으니,

그런 분들이 계실 것이라 생각했고,

차라리 Windows에 더 친화적인 Qt로 포팅(이래봤자 새로 짜는 것이지만)해보려고 했는데...

OCR까지는 잘 진행이 되었는데,

그 외에 사용했던 라이브러리가 Java에는 있으나 C++에는 없는 것들이 많다.

특히 Google 라이브러리는 공식 문서에 C++은 없고(그래도 Github에서 googleapis 검색하면 vision은 찾을 수 있음. vcpkg에도 있고),

Google Drive나 Sheets는 모두 중단된 프로젝트에 Deprecated 코드들이라 어차피 새로 짜야하고...

C++로 웹드라이버는 영 아닌가?? 웹드라이버도 없고...

이럴거면 그냥 Dart에 Flutter로 하는게 아예 더 빠를 듯ㅎ

첨에 qmake도 삽질했다가, CMake로 갈아엎고, vcpkg도 써보고...

배운건 있지만 결국 끝까진 가지 못한 상태ㅎ

사용하는 기능들이 모두 REST API였다면 별 문제도 아니었겠지만, 그렇지 않다...

특히 Google쪽은 gRPC나 자체 규격들이라ㅠ

이번에 너무 시간을 할애한 바... 다음 번에 다시 방향을 고려해보거나 할 듯.

그래도 Qt는 qml로 Model/View에 Binding을 하는게 역시 편했다.

Xamarin 때도 yaml로 나눠둔게 편했었는데.

한참 Qt로 짜다가 Java 버전을 업데이트한건데, 그러다보니 새삼 Model/View가 참 편했구나 싶더라...

사실 Java로 GUI 프로그램 짜는게 맞나 싶기도 하다. 이건 만들 때부터 그랬긴 했는데, 필요한 기능들이 쓰기 좋게 펼쳐져 있던지라...ㅠ

C++에 대한 사랑으로 괜히 Qt로 방향을 잡았나 싶더라.

그냥 Xamarin으로 갔으면 .Net Framework를 썼을테니 라이브러리가 그나마 더 있었을 거고(Google 라이브러리도 C#은 있다).

아니면 Dart에 Flutter를 갔어야했나ㅎㅎ

AWS CodeDeploy에서 대상을 AutoScaling으로 했을 때 발생할 수 있는 문제들

현록 — Wed, 8 Feb 2023 23:37:57 +0900

The IAM role arn:aws:iam::????????????:role/롤네임 does not give you permission to perform operations in the following AWS service: AmazonAutoScaling.

Contact your AWS administrator if you need help.

If you ar AWS administrator, you can grant permissions to your users or groups by creating IAM policies.

공식 문서: https://docs.aws.amazon.com/ko_kr/codedeploy/latest/userguide/getting-started-create-service-role.html

Code Deploy 배포 그룹의 대상이 EC2 Auto Scaling 그룹이라면, 권한이 더 필요하다.

'Code Deploy 배포 그룹'의 서비스 역할에 필요했던 AWSCodeDeployRole 정책 외에도

위의 권한을 추가로 줘야한다.

The following validation error occurred: Target group not attached to the Auto Scaling group (Service: AmazonAutoScaling; Status Code: 400; Error Code: ValidationError; Request ID: ????????-????-????-????-????????????; Proxy: null)

'Code Deploy 배포 그룹'의 배포 유형을 블루/그린(Blue/Green)으로 했을 때 나타날 수 있는 오류이다.

미안하지만 아직 해결법을 찾지 못했다.

오래 전부터 알려진 이슈라고는 하는데...

Auto Scaling 그룹으로 가보면 Code Deploy가 만든 그룹이 그대로 남아있다.

원본의 로드 밸런서 대상 그룹(Target Group)에 연결하지 못한 채 배포가 진행되지 못하고 캔슬된다.

누군가는 Auto Scaling 그룹의 크기 조정 정책이 '대상당 Application Load Balancer 요청 수'인 상태에서 오류가 발생해서,

'평균 CPU 사용률'로 돌렸더니 되었다고 하는데... 시도해보았지만 되진 않았다.

(https://stackoverflow.com/questions/72963563/i-got-target-group-not-attached-to-the-auto-scaling-group-error-while-doing-blue)

더 볼 자료: https://cvortmann.medium.com/fixing-aws-codedeploy-issue-where-auto-scaling-group-is-not-attached-to-target-group-5822d1a577e2

AWS EC2 Auto Scaling

현록 — Wed, 8 Feb 2023 18:23:28 +0900

[구성]

[준비]

[설정]

[확인]

[구성]

인터넷 ━ (AWS) Application Load Balancer ━ (AWS) [ EC2 Auto Scaling ]

로 간단하게 구성해볼 것이다.

[준비]

로드 밸런서의 대상 그룹을 준비

로드 밸런서 준비

로드 밸런서의 대상 그룹을 준비

대상인 Auto Scaling 그룹을 나중에 만드니 비워두고 생성한다.

Auto Scaling 그룹을 생성할 때 연결지어주면 된다.

로드 밸런서 준비

[설정]

EC2 인스턴스의 자동 생성을 위한 시작 템플릿 생성

Auto Scaling 그룹 생성

EC2 인스턴스의 자동 생성을 위한 시작 템플릿 생성

EC2 인스턴스를 만들 때처럼 원하는 대로 설정해준다.

이 예제에서는 Auto Scaling 그룹에 Code Deploy까지 연계할 예정이라 해당 정책이 포함된 Role을 부여했고,

사용자 데이터에는 CodeDeploy Agent도 설치하도록 되어있다.

또한 jdk 설치와 S3 버킷으로부터 애플리케이션을 내려받아 서비스로 등록 및 실행까지 하도록 했다.

증설이 이루어졌을 때 자동으로 제 역할을 수행할 수 있도록 설정해준다.

예시에 적은 스크립트는 아래와 같다.

#!/bin/bash

yum update -y

yum install -y ruby

yum install -y wget

yum install -y java-17-amazon-corretto.x86_64

# /opt/codedeploy-agent/bin/codedeploy-agent stop

# yum erase codedeploy-agent -y

cd /home/ec2-user

wget https://aws-codedeploy-ap-northeast-2.s3.ap-northeast-2.amazonaws.com/latest/install

chmod +x ./install

sudo ./install auto

rm ./install

aws s3 cp --region ap-northeast-2 s3://s3-blackdeer/codedeploy/github/simple-http-rest/build.zip /home/ec2-user/spring-simple-http-rest/build.zip

unzip -o /home/ec2-user/spring-simple-http-rest/build.zip -d /home/ec2-user/spring-simple-http-rest

rm /home/ec2-user/spring-simple-http-rest/build.zip

chown -R ec2-user:ec2-user /home/ec2-user/spring-simple-http-rest

aws s3 cp --region ap-northeast-2 s3://s3-blackdeer/codedeploy/github/simple-http-rest/spring-simple-http-rest.service /lib/systemd/system/spring-simple-http-rest.service

chmod 644 /lib/systemd/system/spring-simple-http-rest.service

systemctl daemon-reload

systemctl enable spring-simple-http-rest

service spring-simple-http-rest start

아래는 서비스 등록에 사용한 spring-simple-http-rest.service

[Unit]

Description=Spring Boot Application for Simple Http REST

ConditionFileNotEmpty=/home/ec2-user/spring-simple-http-rest/build/libs/simple-http-rest-1.0.0.war

[Service]

ExecStart=/bin/java -jar /home/ec2-user/spring-simple-http-rest/build/libs/simple-http-rest-1.0.0.war

Restart=on-failure

RestartPreventExitStatus=9

User=ec2-user

Group=ec2-user

[Install]

WantedBy=multi-user.target

Auto Scaling 그룹 생성

위에서 생성한 시작 템플릿을 선택한다.

ㆍ준비해둔 로드 밸런서의 대상 그룹을 선택해준다.

ㆍAuto Scaling에서는 EC2 인스턴스 자체의 CPU나 네트워크 등 머신에 대한 상태 확인을 기본으로 하고,

　로드 밸런서 사용시에는 대상 그룹의 상태 확인도 Auto Scaling의 상태 확인에 포함할지 설정할 수 있다.

　(준비 과정에서 로드 밸런서 대상 그룹에서는 애플리케이션의 API 응답여부를 척도로 설정했었다.)

※ 예시에서는 선택 사항은 많이 넘겼다. 필요하면 사용하도록 한다.

ㆍ예시에서는 로드 밸런서가 EC2 인스턴스로 요청을 분배할 때,

　하나의 인스턴스가 처리하게 되는 분당 요청 수로 설정했다.

　예시에서는 자동 증감을 보기 위해 낮게 설정했다.

ㆍ축소 비활성화를 하거나, 축소 보호를 인스턴스에 주게되면

　조정 정책보다 여유로워진 상황에서도 인스턴스를 줄이지 않고 유지하게 된다.

필요하면 사용한다. 예시에서는 모두 넘겼다.

[확인]

생성한 Auto Scaling 그룹에서 작동하고 있는 인스턴스들의 상태를 확인할 수 있다.

최소 1대를 설정했기에 Auto Scaling 그룹이 생성되자마자 EC2 인스턴스 1대를 생성한 것을 볼 수 있다.

연결한 로드 밸런서의 대상 그룹에서도 해당 EC2 인스턴스가 연결되어 애플리케이션을 제대로 실행하고 있는 것을 볼 수 있다.

(준비 과정에서 로드 밸런서 대상 그룹에서는 애플리케이션의 API 응답여부를 척도로 설정했었다.)

로드 밸런서로 애플리케이션의 API를 사용했을 때 응답을 받을 수 있었다.

이제 로드 밸런서에 많은 API Call을 줘서 기대한대로 EC2 인스턴스가 늘어나는지 볼 것이다.

blackdeer@Mac ~ % ab -n 20000 -c 20 -m POST http://elb-spring-simple-http-rest-??????????.ap-northeast-2.elb.amazonaws.com:80/simple/info

This is ApacheBench, Version 2.3 <$Revision: 1901567 $>

Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking elb-spring-simple-http-rest-??????????.ap-northeast-2.elb.amazonaws.com (be patient)

Completed 2000 requests

Completed 4000 requests

Completed 6000 requests

Completed 8000 requests

Completed 10000 requests

Completed 12000 requests

Completed 14000 requests

Completed 16000 requests

Completed 18000 requests

Completed 20000 requests

Finished 20000 requests

Server Software:

Server Hostname: elb-spring-simple-http-rest-??????????.ap-northeast-2.elb.amazonaws.com

Server Port: 80

Document Path: /simple/info

Document Length: 742 bytes

Concurrency Level: 20

Time taken for tests: 197.915 seconds

Complete requests: 20000

Failed requests: 0

Total transferred: 17520000 bytes

HTML transferred: 14840000 bytes

Requests per second: 101.05 [#/sec] (mean)

Time per request: 197.915 [ms] (mean)

Time per request: 9.896 [ms] (mean, across all concurrent requests)

Transfer rate: 86.45 [Kbytes/sec] received

Connection Times (ms)

min mean[+/-sd] median max

Connect: 85 99 6.0 100 201

Processing: 85 99 10.9 100 403

Waiting: 85 98 6.1 100 250

Total: 170 198 13.7 200 503

Percentage of the requests served within a certain time (ms)

50% 200

66% 200

75% 201

80% 201

90% 202

95% 203

98% 209

99% 246

100% 503 (longest request)

동시에 20개의 클라이언트로 총 20000회의 요청을 주었다.

우리가 설정한 값은 분당 60회이니 아주 낮은 값이었지만... 확실한 결과를 위해 과하게 주었다.

그랬더니 최대 수까지 늘어났다.

인스턴스 수명 주기를 보면 Pending으로 생성하고 InService로 구동되는 것을 볼 수 있다.

대상 그룹에서도 InService된 EC2 인스턴스는 이제 ELB의 상태 확인을 받게 된다.

로드 밸런서로 요청을 보내서 다른 EC2 인스턴스로 요청들을 넘겨주는 것을 확인했다.

그리고 요청을 보내지 않고 기다려본다.

정책에 따라 인스턴스당 요청 수가 줄어들면서 이제 EC2 인스턴스들을 줄이는 것을 볼 수 있다.

Terminating되면서 EC2 인스턴스들을 제거한다.

AWS CodeDeploy와 Github Action으로 자동 배포 설정

현록 — Sat, 4 Feb 2023 16:46:05 +0900

[Workflow]

[준비사항]

[설정]

[확인]

[Workflow]

Workflow는 다음과 같다.

Github의 특정 branch에 코드 push

↓

gradle이나 maven 등으로 build(test를 포함하고 있다면 수행)

↓

빌드 결과물(jar, war, ...)과 배포 설정(appspec.yml) 등을 압축하여 AWS S3 버킷에 업로드

↓

AWS CodeDeploy 서비스에 설정한 대로 배포 요청(배포 생성)

↓

AWS EC2에서는 설치했던 AWS CodeDeploy Agent가

AWS S3 버킷에서 배포본을 받고 압축을 푼 후, 압축 파일 내부의 appspec.yml에 정의된대로 스크립트를 실행

(실행 중이던 기존 애플리케이션/서비스를 중지하고, 새 애플리케이션으로 교체 후 재실행)

[준비사항]

AWS IAM Role에서 AWS EC2가 AWS CodeDeployAgent를 사용하기 위한 역할(Role)을 생성한다.

AWS IAM Role에서 AWS CodeDeploy 서비스를 위한 역할(Role)을 생성한다.

AWS IAM User에서 Github Action이

S3에 압축파일을 업로드하고, AWS CodeDeploy 서비스에 배포 요청을 할 수 있는

권한을 부여한 사용자를 생성하고, 액세스 키(ID, SECRET)를 발급한다.

참고로 예시에서 사용하는 최소 정책은 다음과 같다.

(작성하려면 S3 버킷과 CodeDeploy 애플리케이션 및 배포 그룹 생성을 먼저 하고 리소스를 지정할 수 있다)

{

"Version": "2012-10-17",

"Statement": [

{

"Sid": "VisualEditor0",

"Effect": "Allow",

"Action": [

"s3:PutObject",

"codedeploy:CreateDeployment",

"codedeploy:GetApplicationRevision",

"codedeploy:RegisterApplicationRevision",

"codedeploy:GetDeploymentConfig"

"Resource": [

"arn:aws:codedeploy:ap-northeast-2:1290????7149:deploymentconfig:CodeDeployDefault.OneAtATime",

"arn:aws:codedeploy:ap-northeast-2:1290????7149:application:CODEDEPLOY애플리케이션이름",

"arn:aws:codedeploy:ap-northeast-2:1290????7149:deploymentgroup:CODEDEPLOY애플리케이션이름/배포그룹이름",

"arn:aws:s3:::S3버킷이름/디렉터리명.../파일명"

]

}

]

}

IAM User가 생성된 것을 확인할 수 있다.

생성한 사용자를 선택하고, '보안 자격 증명' 탭으로 가서 '액세스 키 만들기'로 진입한다.

액세스 키보다 보안성이 높은 대체 권장 서비스를 권유하는 부분이다.

우리는 액세스 키를 사용해야하니 '기타'를 선택한다.

설명 태그는 선택 사항이다. 필요하면 사용한다.

위의 알림대로 이 페이지를 벗어나면 다시는 비밀 액세스 키는 볼 수 없으니,

'.csv 파일 다운로드'를 통해 안전한 곳에 저장해둔다.

위의 액세스 키를 Github의 자동 배포를 수행하려는 Repository의 설정에서 Secrets에 저장해둔다.

Github에서 배포하려는 Repository의 설정 탭으로 가서,

Security > Secrets and variables > Actions 항목에서 secret 생성으로 진입한다.

발급받았던 액세스 키와 비밀 액세스 키 쌍을 각각 따로 저장한다.

AWS S3 서비스에서 S3 버킷을 생성한다.

버킷의 root(/) 디렉터리에 업로드할 것이 아니라면, '폴더 만들기'를 통해 원하는 위치 구조를 만들어둔다.

AWS EC2 서비스에서 EC2 인스턴스를 생성한다.

ㆍ위에서 생성했던 Role 중 AmazonEC2RoleForAWSCodeDeploy 정책이 연결된 Role을 선택해준다.

ㆍEC2가 생성되면 접속해서 AWS CodeDeploy agent를 설치해야하는데,

　사용자 데이터에 명령어들을 입력해두면 인스턴스 생성시 해당 명령어들을 수행해준다.

#!/bin/bash

sudo yum update -y

sudo yum install -y ruby

sudo yum install -y wget

/opt/codedeploy-agent/bin/codedeploy-agent stop

yum erase codedeploy-agent -y

cd /home/ec2-user

wget https://aws-codedeploy-ap-northeast-2.s3.ap-northeast-2.amazonaws.com/latest/install

chmod +x ./install

sudo ./install auto

rm ./install

※ https://docs.aws.amazon.com/ko_kr/codedeploy/latest/userguide/codedeploy-agent-operations-install-linux.html

※ https://docs.aws.amazon.com/ko_kr/codedeploy/latest/userguide/resource-kit.html#resource-kit-bucket-names

만약 기존 사용 중인 EC2 인스턴스라면, 우클릭 메뉴에서 IAM Role을 수정할 수 있다.

기존에 아무 Role도 없었다면 생성했던 Role을 선택하면 되지만,

기존에 Role이 존재한다면 기존 Role에 AmazonEC2RoleForAWSCodeDeploy 정책을 추가하거나 합친 형태의 Role을 추가로 생성해야할 수 있다.

IAM Role을 수정했다면, 재부팅을 해야 올바르게 적용된다.

[ec2-user@ip-***-**-**-** ~]$ sudo service codedeploy-agent status

The AWS CodeDeploy agent is running as PID 3468

EC2 인스턴스로 접속하여 AWS CodeDeploy agent가 설치되어 실행 중인지 확인한다.

설치가 안됐다면 위의 사용자 데이터에 열거했던 명령어들을 입력해보고, 서비스 start로 실행하고 status로 확인한다.

AWS CodeDeploy 서비스에서 CodeDeploy 애플리케이션을 생성하고, 배포 그룹을 생성한다.

배포 그룹을 생성해야한다.

애플리케이션의 배포 그룹을 확인해보면 생성한 배포 그룹을 볼 수 있다.

참고로 배포 그룹을 선택해서 '배포 생성'을 하면 배포 이벤트를 생성할 수 있다.

자동 배포와는 관련 없이,

이미 S3 버킷에 업로드한 압축파일이나 Github의 Commit ID를 바탕으로 프로젝트를 내려받아 수행할 수 있는데,

이는 자동 배포 부분이 아니므로 여기서는 다루지 않겠다.

(직접 배포를 생성하더라도 EC2 대상들에 대해서는 일괄적으로 배포 스크립트를 수행하니,

CI/CD pipeline과는 관련 없지만 배포부터는 자동화라 각각 인스턴스에 수동으로 접속하여 수행할 때의 실수는 줄일 수 있다.)

[설정]

appspec.yml 파일을 git 프로젝트의 root(/) 디렉터리에 생성한다.

version: 0.0

os: linux

files:

# - source: /

# destination: /home/ec2-user/spring-simple-http-rest

- source: /build/libs

destination: /home/ec2-user/spring-simple-http-rest/build/libs

- source: /.aws/aws-codedeploy-scripts

destination: /home/ec2-user/spring-simple-http-rest/.aws/aws-codedeploy-scripts

file_exists_behavior: OVERWRITE

permissions:

- object: /

pattern: "**"

owner: ec2-user

group: ec2-user

hooks:

AfterInstall:

- location: ./.aws/aws-codedeploy-scripts/stop.sh

timeout: 30

runas: ec2-user

ApplicationStart:

- location: ./.aws/aws-codedeploy-scripts/start.sh

timeout: 60

runas: ec2-user

※ https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html

ㆁ files 섹션

　ㆍsource: 압축파일 기준으로 압축을 풀 디렉터리/파일

　ㆍdestination: EC2 인스턴스 기준으로 설치가 될 디렉터리/파일

　※ https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file-structure-files.html

ㆁhooks 섹션

　ㆍ배포 lifecycle의 각 event에 실행할 스크립트 파일을 설정할 수 있다.

　ㆍ이 스크립트 파일은 기존에 존재하든, 이번 배포 압축 파일에 포함되든 둘 다 가능하지만,

　　기존에 존재하는 스크립트 파일이 아니라면 AfterInstall 이벤트부터 사용 가능하다.

　　BeforeInstall에서는 압축을 풀기 전이라 해당 스크립트 파일을 찾지 못하고 이후 과정은 캔슬되어 전체 배포 과정을 실패로 마감한다.

　※ https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file-structure-hooks.html

※ 이 appspec.yml은 압축 파일의 root(/)에 포함되어야 AWS CodeDeploy agent가 이를 토대로 작업들을 수행하지만,

　OS에 설치될 필요는 없는 파일이니, files 섹션에서 appspec.yml 자신은 빠져도 상관없다.

배포가 수행될 때 실행될 스크립트파일(*.sh)들을 git 프로젝트의 원하는 디렉터리에 작성한다.

예시에서 사용한 두 개의 스크립트 파일이다.

stop.sh

#sudo systemctl stop springserver

PID=$(ps -ef | grep -v grep | grep 'java -jar /home/ec2-user/spring-simple-http-rest/build/libs/simple-http-rest-1.0.0.war' | awk '{print $2}')

if [ -n "$PID" ] then

kill -9 $PID

sleep 10

start.sh

#sudo systemctl start springserver

nohup java -jar /home/ec2-user/spring-simple-http-rest/build/libs/simple-http-rest-1.0.0.war 1>/dev/null 2>&1 &

appspec.yml과 스크립트들을 작성한 커밋들을 master branch에 push하고,

Github에서 repository로 들어가서 Github Action을 생성한다.

템플릿을 검색해서 수정해서 사용해도 되지만, 처음부터 기본판으로도 작성할 수 있다.

어차피 예시를 보여줄 것이니 이것으로 선택.

# This workflow uses actions that are not certified by GitHub.

# They are provided by a third-party and are governed by

# separate terms of service, privacy policy, and support

# documentation.

# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time

# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle

name: Java CI with Gradle and CD by AWS CodeDeploy

on:

push:

branches: [ "main" ]

pull_request:

branches: [ "main" ]

permissions:

contents: read

jobs:

ci-and-cd:

runs-on: ubuntu-latest

steps:

- uses: actions/checkout@v3

- name: Set up JDK 17

uses: actions/setup-java@v3

with:

java-version: '17'

distribution: 'corretto'

- name: Run chmod to make gradlew executable

run: chmod +x ./gradlew

- name: Build with Gradle

uses: gradle/gradle-build-action@67421db6bd0bf253fb4bd25b31ebb98943c375e1

with:

arguments: build

- name: Make zip File

run: zip -r ./build.zip ./build/libs/simple-http-rest-1.0.0.war ./appspec.yml ./.aws/aws-codedeploy-scripts

# run: zip -r ./build.zip ./build/libs/*.war ./appspec.yml ./.aws/aws-codedeploy-scripts

- name: Configure AWS credentials

uses: aws-actions/configure-aws-credentials@v1

with:

aws-access-key-id: ${{ secrets.AWS_CD_ID }}

aws-secret-access-key: ${{ secrets.AWS_CD_SECRET }}

aws-region: ap-northeast-2

- name: Upload to S3

run: aws s3 cp --region ap-northeast-2 ./build.zip s3://s3-cd-blackdeer/spring-simple-http-rest/build.zip

- name: AWS CodeDeploy

run: >

aws deploy create-deployment

--application-name test-spring-simple-rest

--deployment-group-name cd-deploy-group-spring-simple-http-rest

--deployment-config-name CodeDeployDefault.OneAtATime

--s3-location bucket=s3-cd-blackdeer,bundleType=zip,key=spring-simple-http-rest/build.zip

'main' branch에 push나 pr이 완료되면,

gradle로 빌드 후,

빌드 파일(*.war)과 appspec.yml, 스크립트 파일들(*.sh)을 압축하고,

이 압축 파일을 AWS S3 버킷에 업로드 한 후,

AWS CodeDeploy 서비스에 배포를 요청한다.

※ https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle

※ https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html

※ https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html

AWS S3 버킷에 압축 파일 업로드와 AWS CodeDeploy 요청에

AWS Credential이 필요하며, 그래서 IAM User와 액세스 키를 발급했던 것이다.

Repository의 Secrets에 저장했던 ID와 SECRET을 여기에서 사용한다.

[확인]

Github Action을 작성한 커밋 이후로,

main branch에 push될 때마다 해당 작업이 수행될 것이다.

Repository의 Actions 탭에서

진행 상태와 결과 및 로그 등을 확인할 수 있다.

re-run도 가능하다.

S3 버킷의 지정한 경로에 압축 파일이 업로드된 것도 확인할 수 있다.

CodeDeploy의 애플리케이션이나 배포 그룹에서는 요청된 배포 내역을 확인할 수 있다.

각 배포 ID를 누르면 인스턴스별 진행 정도나 가장 최근 이벤트 등을 알 수 있다.

아래의 'View events'를 누르면 더 상세한 lifecycle 위치를 알 수 있다.

EC2 인스턴스에서는 해당 머신에 대해 더 자세한 로그를 뒤져볼 수 있다.

/var/log/aws/codedeploy-agent/codedeploy-agent.log

원클릭 모니터변경 종결 (다중모니터,해상도,주사율,배율,회전,위치,...)

현록 — Fri, 3 Feb 2023 18:07:12 +0900

[서론]

[소개]

[사용법]

[추가 팁]

[서론]

(본 프로그램 사용 예)

원격 제어를 애용하면서 그동안 사용했던 모니터 설정 방법을 공유했었다.

PC에 모니터를 3개나 연결해보면서 원하는 모니터 그룹만 켜두는 것이 Windows 기본 기능으로는 어려웠고(레지스트리를 변경해두어도...),

다시 복귀시켰을 때 원래 위치나 해상도 등이 다른 현상이 있었다.

그래서 MSDN을 뒤지면서 또 Windows API를 삽질해보고 있었는데, 강력한 툴을 발견하여 또 소개한다.

Nir Sofer라는 분이 만드신 Freeware이다.

https://www.nirsoft.net/utils/multi_monitor_tool.html

Enable/disable/configure multiple monitors on Windows

MultiMonitorTool v2.00 - Enable/disable/configure multiple monitors on Windows Copyright (c) 2012 - 2023 Nir Sofer See Also ControlMyMonitor - View and modify the settings of your monitor (brightness, contrast, sharpness, input source, and more...) M

www.nirsoft.net

다운로드 링크는 페이지의 아래 부분에서 찾을 수 있다.

웹페이지 주소나 구조를 변경하시면 달라질 수 있지만 링크도 그대로 아래에 첨부한다.

https://www.nirsoft.net/utils/multimonitortool.zip (32bit)

https://www.nirsoft.net/utils/multimonitortool-x64.zip (64bit)

백업용으로도 함께 올려두겠음.

multimonitortool.zip

0.20MB

multimonitortool-x64.zip

0.22MB

본인의 Windows가 64비트 운영체제라면 아래의 x64를 권장하고,

32비트라면 위의 것을 받으면 된다.

[소개]

압축을 풀고 MultiMonitorTool.exe를 실행해보자.

PC에 연결된 모니터들이 뜨며, 우클릭해보면 여러 가지 설정을 할 수 있다.

주모니터 설정, 방향, 전원(물리적 버튼으로 끄는 절전 효과. 통하지 않는 모니터도 있음), 활성화여부(소프트웨어적으로 비활성화) 등이 있다.

여기에서 설정해도 되지만 직관적으로는 []+[i]에서 디스플레이 설정을 통해 설정하는 것이 편할 수 있다.

[]+[i]의 디스플레이 설정에서도 모두 설정 가능한 항목들이다.

참고로 존재하지 않는 해상도는 역시나 설정할 수 없으니, 없는 해상도의 추가는 아래의 포스트를 참고.

[PC원격제어/help] - 해상도 추가하기

해상도 추가하기

[PC원격제어/help] - 원클릭 해상도 변경 원클릭 해상도 변경하기에서, 해상도 목록에 없는 해상도는 당장 사용할 수 없었습니다. 이제, 목록에 없는 해상도를 추가해봅시다. 저는 NVIDIA계열 그래픽

ydeer.tistory.com

[사용법]

중요한 건 이런 설정들을 하는 부분이 아니라, 원클릭으로 원하는 상태를 오가는 것이다.

1. 원하는 전체 상태별로 저장(cfg)

2. cfg마다 bat 파일 작성

3. 이제 그냥 bat 파일 실행만 하면 끝

모니터들을 원하는 상태로 맞춘 상태에서,

위의 메뉴를 통해 현재 상태를 파일로 저장한다. (이게 cfg파일)

(이름은 이왕이면 공백이 들어가지 않도록 한다.)

이 저장은 현재 연결된 모든 모니터들의 상태를 통합적으로 갖는다.

그러니 원하는 상태들마다 cfg파일로 저장한다.

(ex: 모두 켜진 상태, 하나만 켜진 상태, 둘이 켜졌으나 두번째는 세로로 회전한 상태, ...)

이제 bat 파일을 작성해보자.

메모장을 열어서(※ []+[R] → "notepad" → 확인), 아래의 예시처럼 작성한다.

@echo off
"D:\Utilities\multimonitortool-x64\MultiMonitorTool.exe"   /LoadConfig   "D:\Utilities\multimonitortool-x64\Only_PC.cfg"

"exe프로그램의_절대경로" /LoadConfig "저장한_cfg파일의_절대경로" 는 본인 상황에 맞게 작성한다.

중간에 폴더 이름 등에 공백이 들어갈 수 있어서 큰따옴표(")로 묶은 것이다.

만약 위처럼 적는게 어렵다면, exe프로그램과 cfg파일과 bat파일을 모두 같은 폴더 안에 둔다는 가정 하에

MultiMonitorTool.exe /LoadConfig cfg파일이름.cfg 라고 상대경로로 적는 것 만으로도 간단하게 작성할 수 있다.

cfg파일 이름에 공백이 들어간다면 위 예시처럼 큰따옴표(")로 묶거나, 아예 공백을 뺀 이름으로 수정한다.

이걸 아무이름.bat 이름으로 저장한다(이름은 cfg파일과 통일하는 것이 구분하기 쉽다).

저장시 파일 형식이 텍스트 문서(*.txt)라면 이름을 ~.bat으로 지정했어도 ~.txt로 텍스트 문서로 저장될 수도 있다.

결과물을 확인해보고 그런 상황이라면 파일 형식을 모든 파일 (*.*)로 지정하여 저장해준다.

이 ~.bat 파일들을 ~.cfg 파일마다 작성해준다.

이제 작성한 ~.bat 파일을 실행하기만 해도 원하는 상태로 전환된다.

실행하여 확인해보자.

[추가 팁]

이 bat파일을 우클릭하여 바로 가기를 생성한 후, 원하는 곳마다 두어 편리하게 사용할 수 있다.

참고로 맨 위 사용예 영상에서의 Windows 10의 타일 메뉴는

C(윈도우설치드라이브):\Users\로그온한사용자\AppData\Roaming\Microsoft\Windows\Start Menu\Programs에 두면 된다.

여기에서 찾은 항목을 우클릭하여, 시작 화면에 고정해두면

타일 메뉴에서 볼 수 있다.

AWS ALB(Application Load Balancer) 기초

현록 — Fri, 3 Feb 2023 15:47:30 +0900

EC2 > 로드 밸런서로 이동하여 로드 밸런서 생성

Application Load Balancer 선택

이름 및 기본적인 설정을 지정하고,

리스너에서 프로토콜, 포트, 대상 그룹을 지정한다.

필요하면 리스너는 더 추가한다.

대상 그룹이 없다면, 대상 그룹 생성을 한 후 지정해준다.

이름과 연결할 프로토콜 및 포트 등을 지정한다.

상태 검사 역시 필요하면 수정하도록 한다.

앞서 프로토콜과 포트를 지정했지만, 인스턴스마다 포트는 다르게 할 수 있다.

상태 검사는 다르게 할 수 없다.

필요하면 포트를 수정하고 아래에 포함시킨다.

아래에 추가된 대상과 포트들을 확인하고 대상 그룹을 생성한다.

추가된 로드 밸런서를 확인할 수 있다.

대상 그룹에서는 설정했던대로 상태 검사를 하여 상태를 보여준다.

↑위는 EC2에 직접 요청한 결과이고,

↓아래는 로드 밸런서에 요청하여 로드 밸런서가 EC2로 전달하고 받은 요청을 전달해준 것이다.

NGINX 오픈소스 버전에 upstream health check 모듈 추가

현록 — Tue, 31 Jan 2023 22:42:13 +0900

[개요]

[설치]

[설정]

[실행]

[개요]

NGINX는 점유율 1위(2022년 5월 기준)의 웹서버로, 비동기식 처리 방식으로 로드밸런싱이 가능하다.

리버스 프록시로 동작하며, 이를 응용하여 무중단 배포 등을 가능하도록 한다.

https://docs.nginx.com/nginx/admin-guide/load-balancer/http-health-check/

HTTP Health Checks | NGINX Plus

HTTP Health Checks Monitor the health of HTTP servers in an upstream group by sending periodic health checks, including customizable active health checks in NGINX Plus. Introduction NGINX and NGINX Plus can continually test your upstream servers, avoid the

docs.nginx.com

들어온 요청을 뒷단(upstream) 중 하나로 전달하고 응답을 받아와서 넘겨주는데,

로직에 따라 서버를 선택하지만, 그 서버가 살아있는지 지속적으로 health check하는 기능은 NGINX Plus(commercial 버전. 구독료 버전)에만 있다.

오픈소스 버전에도 제공하는 옵션은 각 서버에 max_fails(기본값 1회), fail_timeout(기본값 10초) 을 지정하는 것 밖에 없다.

upstream spring-simple-rest {
    least_conn;
    server nginx-spring-01:8091 max_fails=1 fail_timeout=3s;
    server nginx-spring-02:8092 max_fails=1 fail_timeout=3s;
    server nginx-spring-03:8093 max_fails=1 fail_timeout=3s;
}

특정 API가 평균 소요시간이 길다면 fail_timeout은 그보다 길어야할 것이다.

설정에 따라 다르지만, 뒷단이 죽어있어도 fail_timeout만큼 기다린 후에야 다른 쪽으로 요청을 넘기기도 한다.

또한 fail_timeout만큼은 해당 쪽으로는 요청을 보내지 않지만, 그 이후로는 다시 해당 쪽으로 요청을 보낼 수 있으며 그 때마다 지연이 발생한다.

요청이 들어올 때 무작정 보내보고 실패하면 다른 쪽으로 넘기는 방식이 아니라,

특정 시간마다 개별적으로 health check를 하고, 뒷단들의 상태를 갖고 있어서

요청이 들어오면 살아있는 쪽들만 후보로 하면, upstream 중 일부에 장애가 있을 때 불필요한 지연을 없앨 수 있다.

그런데 이 기능이 NGINX Plus에만 제공되고 있다.

하지만 오픈소스 모듈을 설치 가능하니, 가장 많이 사용하는 upstream health check 모듈을 설치하여 사용해본다.

https://github.com/yaoweibin/nginx_upstream_check_module

GitHub - yaoweibin/nginx_upstream_check_module: Health checks upstreams for nginx

Health checks upstreams for nginx. Contribute to yaoweibin/nginx_upstream_check_module development by creating an account on GitHub.

github.com

[설치]

위의 오픈소스 모듈 git 프로젝트(https://github.com/yaoweibin/nginx_upstream_check_module)를 내려받는다.

오픈소스 모듈의 버전 업이 NGINX에 비해 원활하지 않은 것 같다.

NGINX가 너무 상위 버전이라면 아직 이 모듈이 적용되는 범위를 벗어날 수 있으니, 이를 참고하여 NGINX 역시 받는다.

https://nginx.org/download/

Index of /download/

nginx.org

NGINX의 압축도 풀어둔다.

patch 명령어로 풀어둔 NGINX들에 패치를 할 것이다.

※ patch 명령어는 Docker 이미지류에는 어디에도 존재하지 않는다.

　Docker가 이미 레이어 타입이기 때문.

　다른 Linux/Unix에서 패치 후 디렉터리들을 COPY하는 방식으로 사용하자.

~ % cd nginx-1.20.1

nginx-1.20.1 % patch -p1 < ~/Downloads/nginx_upstream_check_module/check_1.20.1+.patch

patching file 'src/http/modules/ngx_http_upstream_hash_module.c'

patching file 'src/http/modules/ngx_http_upstream_ip_hash_module.c'

patching file 'src/http/modules/ngx_http_upstream_least_conn_module.c'

patching file 'src/http/ngx_http_upstream_round_robin.c'

patching file 'src/http/ngx_http_upstream_round_robin.h'

nginx 디렉터리 내부에 ./src/http/...에 위 파일들이 수정된 것을 수정된 날짜나 내용등을 통해 확인할 수 있다.

이제 이대로 컴파일 후 빌드할텐데, c로 작성된 프로그램이니 c 컴파일러가 필요하다.

※ 여기서부터의 과정을 Docker 방식으로 하고 싶다면, 과정 아래에 Dockerfile로 간략하게 수록했으니 참고.

nginx-1.20.1 % ./configure --add-module=~/Downloads/nginx_upstream_check_module

Configuration summary

+ using system PCRE library

+ OpenSSL library is not used

+ using system zlib library

nginx path prefix: "/usr/local/nginx"

nginx binary file: "/usr/local/nginx/sbin/nginx"

nginx modules path: "/usr/local/nginx/modules"

nginx configuration prefix: "/usr/local/nginx/conf"

nginx configuration file: "/usr/local/nginx/conf/nginx.conf"

nginx pid file: "/usr/local/nginx/logs/nginx.pid"

nginx error log file: "/usr/local/nginx/logs/error.log"

nginx http access log file: "/usr/local/nginx/logs/access.log"

nginx http client request body temporary files: "client_body_temp"

nginx http proxy temporary files: "proxy_temp"

nginx http fastcgi temporary files: "fastcgi_temp"

nginx http uwsgi temporary files: "uwsgi_temp"

nginx http scgi temporary files: "scgi_temp"

우선 nginx/configure에 --add-module 옵션을 주어 실행해보면 컴파일이 가능한지 확인해주며,

빌드할 때 프로그램 설치 경로가 어떨지 설정을 잡아준다.

※ 전체 설치 경로 시작(NGINX_PREFIX)의 기본값은 /usr/local/nginx인데, --prefix=경로 옵션을 주어 전체 설치 경로를 지정할 수 있다.

　다른 옵션은 https://docs.nginx.com/nginx/admin-guide/installing-nginx/installing-nginx-open-source/의 Configuring NGINX Paths에서 확인.

이제 빌드와 설치를 진행한다.

nginx-1.20.1 % make

...

nginx-1.20.1 % make install

...

오류 없이 설치되었다면 설치 경로를 확인해본다.

% ls -al /usr/local/nginx

total 4

drwxr-xr-x 11 root root 352 Jan 31 12:52 .

drwxr-xr-x 1 root root 4096 Jan 31 12:27 ..

drwx------ 2 nobody root 64 Jan 31 12:52 client_body_temp

drwxr-xr-x 18 root root 576 Feb 1 00:49 conf

drwx------ 2 nobody root 64 Jan 31 12:52 fastcgi_temp

drwxr-xr-x 4 root root 128 Jan 31 12:24 html

drwxr-xr-x 5 root root 160 Jan 31 13:10 logs

drwx------ 2 nobody root 64 Jan 31 12:52 proxy_temp

drwxr-xr-x 3 root root 96 Jan 31 12:24 sbin

drwx------ 2 nobody root 64 Jan 31 12:52 scgi_temp

drwx------ 2 nobody root 64 Jan 31 12:52 uwsgi_temp

실행할 프로그램은 ./sbin/nginx 이다.

% /usr/local/nginx/sbin/nginx -V

nginx version: nginx/1.20.1

built by gcc 12.2.0 (GCC)

configure arguments: --add-module=/nginx_upstream_check_module

-V 옵션으로 실행시키면 버전 확인과 빌드 설정시 지정했던 옵션 등을 확인할 수 있다.

./configure, make, make install의 Dockerfile 예시를 수록한다.

c 컴파일러로 gcc 이미지를 사용했다.(예시의 이미지는 용량이 무려 1.27 GB이니, 가벼운 c 컴파일러 수록 이미지를 찾아보는 것을 추천)

FROM gcc:12.2.0

COPY --chown=0:0 --chmod=775 ./nginx-1.20.1 /nginx-1.20.1
COPY --chown=0:0 --chmod=775 ./nginx_upstream_check_module /nginx_upstream_check_module
WORKDIR /nginx-1.20.1
RUN [ "./configure", "--add-module=/nginx_upstream_check_module" ]
RUN [ "make" ]
RUN [ "make", "install" ]

WORKDIR /
ENTRYPOINT [ "bin/bash" ]

EXPOSE 8081

[설정]

설치한 nginx의 conf 디렉터리(/usr/local/nginx/conf)를 확인해보자.

% ls -al /usr/local/nginx/conf

total 76

drwxr-xr-x 18 root root 576 Feb 1 00:49 .

drwxr-xr-x 11 root root 352 Jan 31 12:52 ..

-rwxr-xr-x 1 root root 1077 Jan 31 12:24 fastcgi.conf

-rwxr-xr-x 1 root root 1077 Jan 31 12:24 fastcgi.conf.default

-rwxr-xr-x 1 root root 1007 Jan 31 12:24 fastcgi_params

-rwxr-xr-x 1 root root 1007 Jan 31 12:24 fastcgi_params.default

-rwxr-xr-x 1 root root 2837 Jan 31 12:24 koi-utf

-rwxr-xr-x 1 root root 2223 Jan 31 12:24 koi-win

-rwxr-xr-x 1 root root 5231 Jan 31 12:24 mime.types

-rwxr-xr-x 1 root root 5231 Jan 31 12:24 mime.types.default

-rwxr-xr-x 1 root root 2656 Jan 31 12:24 nginx.conf

-rwxr-xr-x 1 root root 2656 Jan 31 12:24 nginx.conf.default

-rwxr-xr-x 1 root root 636 Jan 31 12:24 scgi_params

-rwxr-xr-x 1 root root 636 Jan 31 12:24 scgi_params.default

-rwxr-xr-x 1 root root 664 Jan 31 12:24 uwsgi_params

-rwxr-xr-x 1 root root 664 Jan 31 12:24 uwsgi_params.default

-rwxr-xr-x 1 root root 3610 Jan 31 12:24 win-utf

여기서 nginx.conf 파일을 수정해보자.

http {} 블록 내부 맨 아래에 include my.conf; 한 줄만 추가해주자.

그리고 빠져나온 후, my.conf 문서를 생성하여 원하는 옵션을 작성해보자.

아래는 모듈을 설치하지 않은 my.conf 예시이다.

server_tokens off;

upstream spring-simple-rest {

least_conn;

server nginx-spring-01:8091 max_fails=1 fail_timeout=3s;

server nginx-spring-02:8092 max_fails=1 fail_timeout=3s;

server nginx-spring-03:8093 max_fails=1 fail_timeout=3s;

}

server {

listen 8081;

# server_name *;

location / {

proxy_pass http://spring-simple-rest;

proxy_http_version 1.1;

proxy_set_header Host $http_host;

# proxy_set_header X-Real-IP $remote_addr;

# proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

# proxy_set_header X-Forwarded-Proto $scheme;

proxy_redirect off;

}

아래는 모듈을 설치하여 upstream health check를 하는 my.conf의 예시이다.

server_tokens off;

upstream spring-simple-rest {

least_conn;

server nginx-spring-01:8091 max_fails=1 fail_timeout=3s;

server nginx-spring-02:8092 max_fails=1 fail_timeout=3s;

server nginx-spring-03:8093 max_fails=1 fail_timeout=3s;

check interval=1000 rise=1 fall=4 timeout=200 type=http;

check_http_send "HEAD /simple/healthcheck HTTP/1.0\r\n\r\n";

check_http_expect_alive http_2xx http_3xx;

}

server {

listen 8081;

# server_name *;

location / {

proxy_pass http://spring-simple-rest;

proxy_http_version 1.1;

proxy_set_header Host $http_host;

# proxy_set_header X-Real-IP $remote_addr;

# proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

# proxy_set_header X-Forwarded-Proto $scheme;

proxy_redirect off;

}

location = /nginx_status {

check_status;

}

upstream 부분에 check로 시작하는 3줄과

server { ..., location = /nginx_status {} } 부분을 추가한 것이다.

check interval=1000 rise=1 fall=4 timeout=200 type=http; 로

　체크 주기, 성공 판단 수, 몇 번 실패해야 최종 실패로 보는지, 요청당 최대 시간, 요청 타입을 지정할 수 있다.

check_http_send "HEAD /simple/healthcheck HTTP/1.0\r\n\r\n"; 로

　체크 request method, api 주소 등을 지정할 수 있다. 예시에서는 HEAD 방식으로 http://nginx-spring-01:8091/simple/healthcheck 등으로 API Call로 응답을 확인할 것이다.

check_http_expect_alive http_2xx http_3xx; 로

　성공 판단 요청의 http status code를 지정할 수 있다.

server 블록 중 아래 check_status; 부분은 listen 포트(예시에서는 8081)의 해당 경로(예시에서는 ./nginx_status)로 접속하면 upstream 들의 상태를 확인할 수 있다.

더 상세한 설명 및 다른 추가 옵션들은 역시 공식 문서를 보시라.

https://github.com/yaoweibin/nginx_upstream_check_module#readme

[실행]

nginx 서버 실행은 그냥 옵션 없이 실행하면 된다.

% /usr/local/nginx/sbin/nginx

실행하여 upstream 서버 중 일부를 끄고 켜보면서 확인해본다.

참고로 stop, reload 등은 -s 옵션으로 가능하다.

% /usr/local/nginx/sbin/nginx -s stop|reload|...

Kafka 설정

현록 — Wed, 25 Jan 2023 19:23:24 +0900

간단한 설정 실습

https://github.com/BlackdeerY/docker-kafka-example

환경변수 등의 설정 없이

기본 openjdk 환경에 ZooKeeper, Kafka 쌩 파일에 설정 파일만으로 가동하고 테스트하는 예시를 두었다.

(Docker Compose 사용)

분산된 머신들과 사용하는 포트 및 데이터 저장 디렉터리, 사용 명령어 등에 대해 감을 잡고 나면,

좀 더 세밀한 설정으로 넘어가기 수월할 것.

Kafka 공식 문서

https://kafka.apache.org/documentation/

Apache Kafka

Apache Kafka: A Distributed Streaming Platform.

kafka.apache.org

Broker 설정 - server.properties

ㆍauto.create.topics.enable: 기본값은 true이다. false로 명시해주지 않으면,

　　　　　　　　　　　　　　　　해당 토픽으로 produce될 때 메시지를 거부하지 않고 자동으로 토픽을 생성한다.

　　　　　　　　　　　　　　　　이 때에 원하는 파티션의 수와 복제 수와 다르게 생성될 수 있으니, 싫다면 명시해두면 된다.

　　　　　　　　　　　　　　　　https://kafka.apache.org/documentation/#brokerconfigs_auto.create.topics.enable

ㆍnum.partitions: 기본값은 1이다. 토픽 생성시 파티션 수를 지정하지 않았을 때 이 값으로 생성된다.

　　　　　　　　　　https://kafka.apache.org/documentation/#brokerconfigs_num.partitions

ㆍdefault.replication.factor: 기본값은 1이다. 토픽 생성시 복제 수를 지정하지 않았을 때 이 값으로 생성된다.

　　　　　　　　　　　　　　　　https://kafka.apache.org/documentation/#brokerconfigs_default.replication.factor

ㆍlog.cleaner.enable: 기본값은 true이다. 닫힌 세그먼트가 특정 시간이 경과하거나 특정 용량이 되었을 때 처리할지의 여부를 정한다.

　　　　　　　　　　　　https://kafka.apache.org/documentation/#brokerconfigs_log.cleaner.enable

ㆍlog.cleanup.policy: 기본값은 delete이다. { compact, delete } 중에서 값을 선택하여 사용한다.

　　　　　　　　　　　　log.cleaner.enable=true일 때 처리할 파일의 처리 방법을 결정한다.

　　　　　　　　　　　　delete면 파일을 지우고, compact면 파일을 압축한다.

　　　　　　　　　　　　https://kafka.apache.org/documentation/#brokerconfigs_log.cleanup.policy

ㆍreplica.lag.time.max.ms: 기본값은 30000(30초)이다. 0 이상의 long 값을 사용할 수 있다.

　　　　　　　　　　　　　　　만약 Follower가 이 시간까지도 복제 요청을 보내지 않거나, 마지막 offset까지 가져가지 않는다면,

　　　　　　　　　　　　　　　Leader는 Follower가 ISR 상태가 아니라고 판단한다.

　　　　　　　　　　　　　　　https://kafka.apache.org/documentation/#brokerconfigs_replica.lag.time.max.ms

Broker 설정 - 환경변수

server.properties의 항목들은 환경 변수로도 설정할 수 있다.

예를 들면...

ㆍKAFKA_BROKER_ID == broker.id

ㆍKAFKA_ADVERTISED_LISTENERS == advertised.listeners

ㆍKAFKA_ZOOKEEPER_CONNECT == zookeeper.connect

...

※ ZooKeepr의 myid나 zoo.cfg의 항목들도 해당한다.

ㆍZOOKEEPER_SERVER_ID == myid파일

ㆍZOOKEEPER_CLIENT_PORT == clientPort

ㆍZOOKEEPER_TICK_TIME == tickTime

ㆍZOOKEEPER_INIT_LIMIT == initLimit

ㆍZOOKEEPER_SYNC_LIMIT == syncLimit

...

Producer 설정

ㆍacks: 기본값은 all이다. { 0, 1, all == -1 } 중에서 값을 선택하여 사용한다.

　　　　0이면 파티션에 제대로 전달되었는지 여부를 확인하지 않는다. 그러므로 retries로 설정한 실패시 재수행 횟수 역시 실패 여부를 알 수 없으니 수행하지 않는다.

　　　　1이면 파티션의 Leader에게만 기록되었는지를 확인한다.

　　　　all(== -1)이면 파티션의 Leader 외에 Follower들까지 모두 복제하고 ISR이 형성되었는지 확인한다.

　　　　신뢰성과 속도 측면에서 필요에 따라 설정한다.

　　　　https://kafka.apache.org/documentation/#producerconfigs_acks

ㆍretries: 기본값은 2147483647이다. [ 0, 2147483647 ] 범위의 값을 선택하여 사용한다.

　　　　　　acks 옵션이 0이 아니여서 전송 실패 여부를 알 수 있을 때, 실패시 메시지의 재전송 횟수이다.

　　　　　　횟수만큼 메시지를 다 보내기 전에 delivery.timeout.ms 시간이 경과하면 재전송을 중단한다.

　　　　　　보통 이 값을 수정하기 보다는 delivery.timeout.ms 옵션을 조절하여 재전송을 제어하는 것을 권장한다.

　　　　　　(Users should generally prefer to leave this config unset and instead use delivery.timeout.ms to control retry behavior.)

　　　　　　https://kafka.apache.org/documentation/#producerconfigs_retries

ㆍdelivery.timeout.ms: 기본값은 120000(2분)이다. 0 이상의 int 값을 사용할 수 있다.

　　　　　　　　　　　　메시지를 보내고 성공 혹은 최종 실패까지의 상한 시간이다.

　　　　　　　　　　　　이 값은 request.timeout.ms 와 linger.ms 의 합보다 이상이어야 한다.

　　　　　　　　　　　　https://kafka.apache.org/documentation/#producerconfigs_delivery.timeout.ms

ㆍlinger.ms: 기본값은 0이다. 0 이상의 long 값을 사용할 수 있다.

　　　　　　　Producer는 Broker로 request할 때, 생성한 레코드들을 그룹지어 단일 batch request로 보낼 수 있다.

　　　　　　　일반적으론 부하 상태(여러 레코드들마다 전송되는 것보다 한꺼번에 전송되는 것이 빠를 때)에만 일어난다.

　　　　　　　하지만 몇몇 상황에서는 적당한 부하이더라도 request 수를 줄이고자 할 수 있다.

　　　　　　　이 설정은 작은 인위적인 지연을 발생시켜, 레코드들이 함께 묶여서 request될 수 있도록 한다.

　　　　　　　이것은 TCP의 Nagle 알고리즘과 유사하다고 생각될 수 있다.

　　　　　　　이 설정은 일괄처리(batch)에 대한 상한을 제공하는 것이다.

　　　　　　　만약 레코드가 batch.size 이상이라면 이 설정과는 상관 없이 바로 보내겠지만,

　　　　　　　그 미만이라면 함께 보내기 위해 다른 레코드들이 발생하길 기다린다.

　　　　　　　기본값은 0이라 설정이 없으면 즉시 보낸다.

　　　　　　　예를 들어 5ms로 설정하면, 부하가 없는 상황에서도 5ms의 지연을 추가하게 되지만 request 수는 줄이는 효과를 기대할 수 있다.

　　　　　　　https://kafka.apache.org/documentation/#producerconfigs_linger.ms

ㆍbatch.size: 기본값은 16384(bytes)이다. 0 이상의 int 값을 사용할 수 있다.

　　　　　　　Producer는 여러 레코드를 함께 request하여 적은 수의 요청으로 많은 레코드를 처리하려고 한다.

　　　　　　　이는 클라이언트와 서버 모두 성능에 도움이 된다.

　　　　　　　이 설정은 기본 batch의 bytes 크기를 제어한다.

　　　　　　　이 크기보다 큰 레코드는 함께 묶어서 처리하려고 하지 않고 즉시 보낸다.

　　　　　　　Broker에 전송된 요청들에는 여러 batch가 있으며(Producer나 Topic이 하나는 아니니까),

　　　　　　　각각은 파티션에 보낼 데이터를 갖는다.

　　　　　　　batch 크기가 작으면 개별적이고 한번에 처리할 양은 줄어든다(0이면 완전히 batch가 비활성화되어 개별 레코드로만).

　　　　　　　매우 큰 batch 크기는 많은 레코드들을 예상하여 그만큼의 버퍼를 할당해야하므로, 메모리를 좀 더 낭비할 수 있다.

　　　　　　　https://kafka.apache.org/documentation/#producerconfigs_batch.size

ㆍrequest.timeout.ms: 기본값은 30000(30초)이다. 0 이상의 int 값을 사용할 수 있다.

　　　　　　　　　　　　이 설정은 Producer가 Broker로 보낸 메시지의 응답을 기다리는 최대 시간이다.

　　　　　　　　　　　　이 시간 안에 응답이 오지 않으면 Producer는 필요한 경우(retries가 설정된 경우) 요청을 다시 보내며,

　　　　　　　　　　　　retries 만큼 보냈거나, delivery.timeout.ms 만큼의 시간이 경과해버리면 최종 실패한다.

　　　　　　　　　　　　acks=all(== -1)이라 Broker가 ISR 형성까지한 후 응답을 보내는 경우도 있으니,

　　　　　　　　　　　　불필요한 재시도와 중복 가능성을 줄이기 위해 Broker의 replica.lag.time.max.ms 보다 커야 한다.

　　　　　　　　　　　　https://kafka.apache.org/documentation/#producerconfigs_request.timeout.ms

Consumer 설정

ㆍallow.auto.create.topics: 기본값은 true이다. boolean(true/false)을 사용한다.

　　　　　　　　　　　　　　　브로커의 설정이 auto.create.topics.enable=true인 경우에,

　　　　　　　　　　　　　　　없는 토픽을 consume하려고 하면 해당 토픽을 자동으로 생성 요청한다.

　　　　　　　　　　　　　　　버전 0.11.0 미만의 브로커를 사용한다면, consumer에서는 이 설정을 필히 false로 해두어야 해당 상황에서 안전하다.

　　　　　　　　　　　　　　　https://kafka.apache.org/documentation/#consumerconfigs_allow.auto.create.topics

ㆍauto.offset.reset: 기본값은 latest이다. { latest, earliest, none } 중에서 값을 선택하여 사용한다.

　　　　　　　　　　　Consumer가 초기에 offest이 없거나 읽던 offset이 Broker에서 삭제된 경우,

　　　　　　　　　　　offset값을 어떻게 재구성할지에 대한 설정이다.

　　　　　　　　　　　latest면 Topic Partition의 가장 최근(이제부터 발생하는)부터 가져오려고 하고,

　　　　　　　　　　　earliest면 Topic Partition 중 Broker에 존재하는(아직 열려있는) 데이터 중 가장 오래된 것부터 가져오기 시작한다.

　　　　　　　　　　　none이면 Consumer에서 exception이 발생한다.

　　　　　　　　　　　https://kafka.apache.org/documentation/#consumerconfigs_auto.offset.reset

Kafka 기본 개념 및 용어

현록 — Wed, 18 Jan 2023 10:38:12 +0900

Kafka의 정말 기본 개념

Kafka는 데이터 처리를 위한 플랫폼이다.

'느슨한 결합'을 목표로 한다.

기존의 데이터 처리 플랫폼은 애플리케이션과 강하게 결합되어 있어,

같은 데이터를 처리하려고 해도 애플리케이션마다 별도의 창구가 필요하거나,

그마저도 바로 되지 않아 더 길고 복잡한 경로나 새로운 저장소가 추가되거나 하여 시스템을 복잡하게 만들었다.

출처:　https://www.confluent.io/blog/event-streaming-platform-1/

출처:　https://www.confluent.io/blog/event-streaming-platform-2/

Kafka는 느슨하게 결합되어 있기에,

애플리케이션에서 통일된 형태로 바로 데이터를 생산/소비하고,

이 데이터를 연결된 다른 모든 애플리케이션에서 바로 사용할 수 있다.

출처:　https://www.confluent.io/blog/event-streaming-platform-1/

출처:　https://www.confluent.io/blog/event-streaming-platform-2/

Kafka는 이벤트 브로커 (※ 이 부분은 하나의 견해인지 잘 모르겠다. 나도 이 모두를 사용해본 것이 아니라...)

Redis, MQTT가 메시지 브로커라면,

Kafka, AWS Kinesis는 이벤트 브로커이다.

이벤트 브로커는 메시지 브로커의 역할도 수행할 수 있지만,

반대로 메시지 브로커가 이벤트 브로커의 역할을 수행할 순 없다.

메시지 브로커는 당장의 메시지 전달에 초점을 맞추며, 지난 시점의 메시지는 지난 메시지일 뿐이다.

이걸 보존하지도 않는다. 필요하면 연결된 애플리케이션에서 보존할 뿐, 브로커가 보존을 수행하진 않는다.

이벤트 브로커는 당장의 메시지 전달 뿐 아니라, 지난 메시지 역시 그로 인한 이벤트 발생이든 재처리든 할 수 있다.

지난 메시지 역시 브로커가 보존하고 있다.

ZooKeeper는 또 뭐야??

apache Kafka는 apache ZooKeeper와 연동하여 사용한다.

이 의존성을 향후에는 없애겠다고 했으나, 현재에는 그렇다.

(Kafka 3.3에서는 ZooKeeper 없이 Kafka 독자적으로 가능하도록 KRaft를 옵션으로 탑재하고 있으며,

향후 4에서는 제거할 계획이라고 한다.)

ZooKeeper는 분산 애플리케이션을 관리하는 코디네이터이다.

Kafka만을 위한 것이 아니라 그보다 먼저 존재해왔던 프로젝트로,

빅데이터 생태계에 동물형 심볼을 갖는 애플리케이션들이 많고, 이들의 사육사(ZooKeeper)격으로 만들어졌다.

분산 시스템에서 부분 실패 등을 안전하게 처리하기 위한 도구이다.

ZooKeeper는 Kafka 브로커들(서버들)의 메타 데이터를 관리한다.

Kafka는 멀티 브로커가 가능하며, 브로커 ID, 컨트롤러 ID 등의 데이터를 ZooKeeper가 관리해준다.

메시지의 저장은 Kafka 내부에 적재된다.

ZooKeeper는 Kafka 서버들의 정보를 관리하는 것이고, 둘을 혼동하면 곤란하다.

그래도 ZooKeeper에 대해 간단히..

출처: https://hadooptechblog.wordpress.com/2015/12/29/introduction-to-apache-zookeeper/

ZooKeeper 역시 단일로 실행되기보다는 스스로도 멀티 클러스터 환경으로 구성된다.

이 여러 클러스터들이 앙상블(Ensemble)을 이룬다.

설정에서 (묶인 클러스터들의 총 갯수) / 2 + 1 이 서로 통신이 되고 있어야 ZooKeeper를 이용할 수 있다.

분산 시스템에서 이러한 최소 필요 수를 쿼럼(Quorum)이라고 한다.

기본적으로 tcp/2181 로 다른 애플리케이션(ex. Kafka. 주키퍼 입장에선 클라이언트.)이 ZooKeeper를 이용하며,

tcp/2888 로 ZooKeeper의 클러스터들끼리 동기화를 한다.

tcp/3888 은 ZooKeeper의 클러스터들끼리의 leader/follower 선출에 사용한다.

ZooKeeper끼리는 설정으로 서로의 주소와 포트를 알고 있어야하지만,

ZooKeeper를 이용하는 애플리케이션들(ex. Kafka. 주키퍼 입장에선 클라이언트.)은 서로를 알 필요 없이

ZooKeeper가 분산된 애플리케이션들을 연결시켜주며,

애플리케이션은 설정에서 ZooKeeper 하나만 알아도 ZooKeeper들은 메타 데이터들을 스스로 동기화를 하는 점이 장점이다.

ZooKeeper와 애플리케이션이 같은 머신에서 돌 수 없는 것은 아니나,

ZooKeeper는 메모리에서 데이터들을 처리하고 있으므로,

머신의 메모리를 고려하거나 장애 분산 등을 고려하면 다른 머신에서 가동하는 것이 좋다.

Kafka 용어

※ Pub/Sub, Broker, Topic 등 메시지 브로커의 기본 공통 개념은 생략

※ 데이터의 저장: 데이터는 Kafka를 실행하는 머신의 설정한 디렉터리에 bytes 형태의 파일로 저장된다.

　　　　　　　　그러므로 producer→Kafka 에는 직렬화, Kafka→consumer 에는 역직렬화가 수행된다.

ㆍSegment 파일: bytes들은 파일들(00000000000000000000.index, 00000000000000000000.log, 00000000000000000000.timeindex)로 저장된다.

　　　　　　　　현재 사용되는 파일은 열려있는 상태이며, 설정한 시간 및 용량에 따라 파일을 닫고 새 파일을 열어 쓴다.

　　　　　　　　닫힌 파일은 설정한 시간 및 용량에 따라 압축되거나 삭제된다.

ㆍController(컨트롤러): 멀티 브로커 환경에서, 브로커 1대는 컨트롤러 기능을 수행한다.

　　　　　　　　　　컨트롤러는 각 브로커들에게 담당 파티션을 할당하며, 브로커들이 정상 동작하는지 모니터링 및 관리한다.

　　　　　　　　　　누가 컨트롤러인지는 메타 데이터이므로, ZooKeeper에 저장된다.

ㆍOffset(오프셋): 토픽으로 들어온 메시지는 순서대로 오프셋이 매겨진다.

　　　　　　　　컨슈머 그룹에서 메시지를 가져가더라도, 컨슈머마다 읽은 오프셋(컨슈머 오프셋)이 늘어날 뿐 데이터가 지워지진 않는다.

　　　　　　　　다른 컨슈머가 사용할 수도 있고, 원하면 재사용도 가능하다.

　　　　　　　　그러니 지우는 것이 아니라 데이터는 그대로이면서, 컨슈머마다 컨슈머 오프셋으로 어디까지 읽은지를 구분한다.

　　　　　　　　데이터는 쌓인 용량이 설정한만큼의 용량이 되거나, 설정한만큼의 기간이 지나면 지운다.

ㆍPartition(파티션): 한 토픽은 여러 파티션으로 나뉠 수 있다.

　　　　　　　　　파티션의 수는 브로커의 수에 제한받지 않는다(하나의 브로커가 여러 파티션을 가질 수 있다. 섹션 맨 아래 무지개색 이미지 참고.).

　　　　　　　　　Producer의 Partitioner에 따라 레코드들이 분배되는데, 기본으로는 UniformStickyPartitioner를 사용한다.

　　　　　　　　　UniformStickyPartitioner는 레코드에 Key를 주어, Key-Value 쌍의 형태를 사용하면 Key로 Hash 계산을 하여 파티션에 분배하고,

　　　　　　　　　Key가 null이면 Round-Robbin으로 레코드들을 파티션들에 분배한다.

　　　　　　　　　파티션마다 오프셋이 매겨진다.

　　　　　　　　　토픽의 파티션은 언제든 늘릴 수 있지만, 줄일 수는 없다.

ㆍConsumer Group: 컨슈머 그룹은 한 토픽으로부터 데이터를 가져온다.

　　　　　　　　　다른 컨슈머 그룹이 동일한 토픽으로부터 데이터를 가져올 수 있다.

　　　　　　　　　컨슈머 오프셋은 컨슈머마다 계산되므로, 다른 그룹이 같은 토픽을 읽어도 서로 순서가 혼선될 일은 없다.

ㆍConsumer: 컨슈머는 자신이 속한 그룹이 가져올 토픽에 대하여, 그 토픽의 파티션으로부터 데이터를 가져온다.

　　　　　　그룹 내의 컨슈머들의 수가 토픽의 파티션 수보다 적다면, 어느 컨슈머는 해당 토픽의 여러 파티션으로부터 데이터를 가져온다.

　　　　　　그룹 내의 컨슈머들의 수가 토픽의 파티션 수와 일치한다면, 한 컨슈머가 해당 토픽의 한 파티션으로부터만 데이터를 가져온다.

　　　　　　그룹 내의 컨슈머들의 수가 토픽의 파티션 수보다 많다면, 초과된 수의 컨슈머는 놀게 된다.

　　　　　　그러므로 컨슈머 그룹 내의 컨슈머 숫자는 해당 토픽의 파티션 수 이하가 되도록 구성한다.

ㆍRebalance(리밸런스): 컨슈머 그룹 내부의 특정 컨슈머에 장애가 발생하면, 컨슈머들은 담당 파티션들을 다시 조정한다.

출처:　https://ibm-cloud-architecture.github.io/refarch-eda/technology/kafka-consumers/

ㆍReplication(복제): 토픽의 파티션은 안전을 위해 다른 브로커들에게 복제되도록 할 수 있다.

　　　　　　　　　복제 수는 최대로는 브로커의 수만큼이 되도록 설정할 수 있다(그 넘어서는 브로커가 더 없으니 할 수 없는 것.. 바로 아래 이미지 참고.)

　　　　　　　　　브로커 하나가 한 토픽의 여러 파티션 원본을 가질 수는 있지만, 굳이 같은 파티션의 복제본을 여럿 들고있을 필요가 없다는 것을 생각하면 된다.

　　　　　　　　　leader 파티션은 Kafka 클라이언트(프로듀서, 컨슈머)와 데이터를 주고 받으며,

　　　　　　　　　follower 파티션은 leader 파티션으로부터 레코드를 지속 복제한다.

　　　　　　　　　만약 leader 파티션에 장애가 발생하면, 나머지 follower들끼리 새로 leader를 선출한다.

ㆍISR(In-Sync Replica): 특정 파티션의 leader, follower에서 레코드가 모두 복제되어 동기화(sync)가 맞는 상태.

　　　　　　　　　　　만약 ISR이 아닌 상태에서 장애가 발생했다면, unclean.leader.election.enable= 설정에 따라

　　　　　　　　　　　true면 sync 상관 없이 바로 follower들 중에 새로 leader를 선출하고,

　　　　　　　　　　　false면 leader가 살아날 때까지 대기한다. 즉, 그동안은 해당 파티션은 사용불가가 된다.

% kafka-topics.sh --describe --bootstrap-server kafka-01:9092,kafka-03:9092

Topic: mytest TopicId: H0tGCsUcQDOFqD_-8C9bEQ PartitionCount: 7 ReplicationFactor: 1 Configs:

Topic: mytest Partition: 0 Leader: 1 Replicas: 1 Isr: 1

Topic: mytest Partition: 1 Leader: 0 Replicas: 0 Isr: 0

Topic: mytest Partition: 2 Leader: 2 Replicas: 2 Isr: 2

Topic: mytest Partition: 3 Leader: 1 Replicas: 1 Isr: 1

Topic: mytest Partition: 4 Leader: 0 Replicas: 0 Isr: 0

Topic: mytest Partition: 5 Leader: 2 Replicas: 2 Isr: 2

Topic: mytest Partition: 6 Leader: 1 Replicas: 1 Isr: 1

Topic: mytest3 TopicId: 7krfA2U1SjmmZKUWZFEW_w PartitionCount: 7 ReplicationFactor: 2 Configs:

Topic: mytest3 Partition: 0 Leader: 2 Replicas: 2,1 Isr: 2,1

Topic: mytest3 Partition: 1 Leader: 1 Replicas: 1,0 Isr: 1,0

Topic: mytest3 Partition: 2 Leader: 0 Replicas: 0,2 Isr: 0,2

Topic: mytest3 Partition: 3 Leader: 2 Replicas: 2,0 Isr: 2,0

Topic: mytest3 Partition: 4 Leader: 1 Replicas: 1,2 Isr: 1,2

Topic: mytest3 Partition: 5 Leader: 0 Replicas: 0,1 Isr: 0,1

Topic: mytest3 Partition: 6 Leader: 2 Replicas: 2,1 Isr: 2,1

위 조회 중 mytest3 기준으로 작성한 이미지

각각 kafka 머신의 디렉터리 상태

간단한 설정 실습

https://github.com/BlackdeerY/docker-kafka-example

환경변수 등의 설정 없이

기본 openjdk 환경에 ZooKeeper, Kafka 쌩 파일에 설정 파일만으로 가동하고 테스트하는 예시를 두었다.

(Docker Compose 사용)

분산된 머신들과 사용하는 포트 및 데이터 저장 디렉터리, 사용 명령어 등에 대해 감을 잡고 나면,

좀 더 세밀한 설정으로 넘어가기 수월할 것.

Kafka 공식 문서

https://kafka.apache.org/documentation/

Apache Kafka

Apache Kafka: A Distributed Streaming Platform.

kafka.apache.org

Docker Compose 사용 (docker-compose.yml)

현록 — Wed, 4 Jan 2023 10:22:10 +0900

처음 Docker를 배우는 사람들은 막막할 수도 있다.

자꾸 뭔가 새로운 명령어와 파일을 작성하고 사용해서...

가상화와 레이어 개념도 말이 개념 이해지, 이게 된다고?? 싶을 수도 있고.

[Study/Docker] - Dockerfile 작성 (Dockerfile로 배포)

앞서 Dockerfile 작성에서는

라이브러리의 이미지에서 컨테이너를 생성하여 가상 OS를 사용하는 작업을 넘어

그 이미지에서 원하는 작업을 하도록 짠 Dockerfile을 통해

자신의 이미지를 빌드하고,

이 이미지를 컨테이너로 만들어 사용했었다.

그러기 위해 docker run 명령을 수행했다. 필요에 따라 옵션을 주었고.

docker build --no-cache -t 생성될이미지명:태그 Dockerfile경로

docker image prune --filter label=stage=forbuild

docker run -d -it -p 28090:8090 --name 생성될컨테이너명 생성한이미지명

이제 이 run도 원하는 옵션을 미리 짜두고 자동화할 것이다.

이 부분이 Docker Compose이다.

Docker Compose가 단순히 실행 부분만을 맡는 것은 아니다.

여러 컨테이너들을 순서에 맞게 실행시키고, 각 컨테이너들을 이어주고 통합적으로 실행되도록 하는 것이 Docker Compose다.

한 컴퓨터에서 여러 프로그램들을 돌리기도 하지만,

여러 컴퓨터마다 프로그램들이 돌아가는(DB 따로, 메시징서버 따로, ...) 상황도 많지 않나.

그런 상황 역시 가능하다는 것.

이런 Container Orchestration에는 Docker Compose 외에도 Kubernetes[쿠버네티스]라는 프레임워크도 있다.

Docker Compose가 docker를 설치한 하나의 Host에서 돌아가는 여러 컨테이너들을 관리한다면,

Kubernetes는 여러 머신들이 갖는 컨테이너들을 관리한다고 한다.

https://www.theserverside.com/blog/Coffee-Talk-Java-News-Stories-and-Opinions/What-is-Kubernetes-vs-Docker-Compose-How-these-DevOps-tools-compare

나도 현재는 명료하게 설명할 수 없으니, 관심있는 분들은 찾아보시길.

docker-compose.yml

services:
  myproject:
    build:
      context: .
      no_cache: true
      # tags:
        # - "myprojectimagedouble"
        # - "myprojectimagetriple:v.1.0.0"
    image: myprojectimage
    ports:
      - "28090:8090"
    container_name: myprojectcontainer
  git:
    image: bitnami/git:latest
    depends_on:
      - myproject
    container_name: mygitcontainer
    volumes:
      - "./restdocs:/restdocs"
    command: git clone https://github.com/BlackdeerY/restdocs-maven.git restdocs

위 예시에는 v2부터 동작하는 옵션들도 다수 있다.

v2부터는 기본적으로 buildkit을 사용하니, 중간 이미지들은 남지 않고, 실행에 필요한 이미지만 남게 된다.

사용

docker compose up -d

여러 컨테이너를 실행할 수 있으니 괜히 다른 컨테이너도 실행시켰다.

(예시로는 분산시스템이 좋을텐데, 이 짧은 예시를 위해 만들 것까진 아닌 것 같아서...)

포트나 볼륨, 컨테이너명이나 명령 등도 잘 동작하는 것을 확인할 수 있다.

yml에 지정가능한 사항들을 모두 다룰 생각으로 적은 글이 아니어서, 해당 사항은 아래의 공식문서를 참고.

※ 만약 Docker Desktop 환경에서 ERROR [internal] load metadata for docker.io/library/... 에러를 낸다면,

　~/.docker/config.json에서 "credStore": "desktop", 부분을 "credStore": "",로 수정하고 Docker Desktop을 재시작해준다.

※ build > tags 옵션으로 결과 이미지의 복제본들을 둘 수 있다. IMAGE ID는 같으나 다른 이름으로 다수 존재하게 된다.

　용량이 함께 늘어나는 것은 아니고, 원본은 IMAGE ID이고, 다른 이름과 태그는 모두 심볼릭링크로 이해하면 좋다.

Docker Compose 공식문서는 아래

https://docs.docker.com/compose/

Overview

docs.docker.com

https://docs.docker.com/compose/compose-file/

Compose specification

docs.docker.com

https://docs.docker.com/build/bake/compose-file/

Building from Compose file

docs.docker.com

Dockerfile 작성 (Dockerfile로 배포)

현록 — Tue, 3 Jan 2023 18:36:40 +0900

Docker의 계층(Layer)형 구조와 가상화에 대한 이론 내용을 깨우쳤다면,

이제 Docker를 제대로 응용할 차례다.

앞서 본 Docker의 명령어들은 라이브러리에서 원하는 이미지를 내려받고, 실행해보는 것이었다.

이제 Dockerfile을 작성함으로써, 내가 원하는 레이어들을 쌓은 최종이미지를 빌드하여

Docker로 프로젝트를 배포하는 예제를 볼 것이다.

(Dockerfile 작성(이미지 빌드)이 왜 프로젝트 배포로 이어지는 것인지는 [두 번째 예시]에 조금 더 언급)

원하는 환경을 구상해본다.

[첫 번째 예시]

1. 이미 빌드된 파일을 바로 구동환경에서 실행

구동환경에 맞는 빌드된 파일을 준비해놨으니, 빌드과정이 없어 시간이 대폭 줄어든다.

하지만 해당 파일을 Dockerfile과 함께 제공할 수 있어야한다.

[두 번째 예시]

1. git으로 공개 프로젝트를 내려받고

2. 빌드이미지에서 빌드하고

3. 빌드한 파일을 구동환경에서 실행

각 단계마다 다른 이미지에서 작업을 수행하도록 할 것이다.

1단계에서는 내려받는 것만을,

2단계에서는 빌드만을,

3단계에서는 실행만을 담당한다.

최종이미지는 3단계만 가지면 되므로, 1과 2의 내용은 최종 구동환경에 포함되지 않으니 용량을 줄일 수 있다.

[세 번째 예시]

1. 하나의 최종 구동환경 이미지에서 wget, unzip, git, gradle을 설치(리눅스 yum, apt-get 등)

2. wget, unzip 등으로 yum 및 apt-get에 없는 프로그램들을 설치

3. 환경변수 설정

4. 프로젝트를 내려받고

5. 빌드하고

6. 실행

사실 한 번 하고 버리면 될 내려받기나 빌드한 후에도 남는 빌드 프로그램들이 최종 이미지에 포함되므로

용량이 쓸데없이 커진다. 그렇지만 내가 필요한 프로그램이 공개된 이미지에 없을 수 있으니, 명령어 예시용으로 본다.

[첫 번째 예시]

1. 이미 빌드된 파일을 바로 구동환경에서 실행

Dockerfile

FROM amazoncorretto:8u352
LABEL stage=forbuild
COPY ./myproject.war /myproject
WORKDIR /myproject
EXPOSE 8090
ENTRYPOINT [ "java", "-jar", "/myproject/myproject.war" ]

docker 명령

docker build --no-cache -t 생성될이미지명:태그 Dockerfile경로

docker image prune --filter label=stage=forbuild

docker run -d -it -p 28090:8090 --name 생성될컨테이너명 생성한이미지명

※ docker build할 때에 줄마다 레이어 및 캐시를 형성하는데,

　같은 Dockerfile을 또 build할 때에, 명령줄만 비교하고 그 내용이 가리키는 파일까지는 비교해주진 않으니,

　(로컬 파일이든 wget이나 curl이든 git이든...)

　필요에 따라 캐시 사용을 하지 않도록 함 (--no-cache 옵션).

※ 만약 Docker Desktop 환경에서 ERROR [internal] load metadata for docker.io/library/... 에러를 낸다면,

　~/.docker/config.json에서 "credStore": "desktop", 부분을 "credStore": "",로 수정하고 Docker Desktop을 재시작해준다.

FROM 이후 한 줄 마다 레이어로 중간 이미지(intermediate image)가 생성된 채 남게 되는데,

부여했던 LABEL를 필터(--filter 옵션)로 사용하여 docker image prune 명령어로 중간 이미지들을 모두 삭제해줄 수 있다.

buildkit을 사용한다면 FROM 이미지든 중간 이미지든 모두 캐시로 관리하고 이미지로 남기지 않으므로,

해당 과정이 필요없다.

위 예시의 Dockerfile의 명령어들

ㆍFROM 작업할_이미지

ㆍLABEL 라벨명

ㆍCOPY source destination

ㆍWORKDIR 이미지에서_cd될_곳

ㆍEXPOSE 외부로_노출될_포트: -P 옵션으로 컨테이너를 생성하면 해당 포트는 무작위로 배정됨.

ㆍENTRYPOINT 생성된_컨테이너에서_실행될_명령: CMD와는 달리, 컨테이너 생성시 명령을 지정하더라도 이 명령이 실행됨.

[두 번째 예시]

1. git으로 공개 프로젝트를 내려받고

2. 빌드이미지에서 빌드하고

3. 빌드한 파일을 구동환경에서 실행

Dockerfile

FROM bitnami/git:latest
LABEL stage=forbuild
RUN [ "git", "clone", "https://github.com/BlackdeerY/restdocs-maven.git", "myproject" ]

FROM maven:3.8.7-openjdk-18
LABEL stage=forbuild
COPY --from=0 /myproject /myproject
WORKDIR /myproject
RUN [ "mvn", "package" ]

FROM amazoncorretto:8u352
LABEL stage=forbuild
COPY --from=1 /myproject/target/restdocs-maven-0.0.1-SNAPSHOT.war /myproject/myproject.war
WORKDIR /myproject
EXPOSE 8090
ENTRYPOINT [ "java", "-jar", "/myproject/myproject.war" ]

docker 명령

docker build --no-cache -t 생성될이미지명:태그 Dockerfile경로

docker image prune --filter label=stage=forbuild

docker run -d -it -p 28090:8090 --name 생성될컨테이너명 생성한이미지명

위 예시의 추가된 Dockerfile의 명령어들

ㆍCOPY --from=이전이미지번호 source destination: 이전 작업 이미지 영역에서도 파일을 가져올 수 있음

이미지마다 필요한 작업만을 하고, 결과물만 옮겨올 수 있음.

이렇게 최종이미지에 불필요한 프로그램이 없도록 하여 용량을 줄일 수 있음.

실제로 위 명령어를 그대로 따라하여

이미지가 생성된 것을 확인하고, 컨테이너 생성을 했을 때,

http://localhost:28090/docs/v.1.0.0.html

웹브라우저로 위 주소에 접속해보면 바로 서버가 돌아가고 있는 것을 확인할 수 있다.

(위 예시에서의 Restdocs 문서)

사용자가 docker를 설치한 후라면

몇 줄만으로 빠르게 구동환경과 실행까지 바로 제공할 수 있는 것.

[세 번째 예시] (비효율적이지만 명령어 예시)

1. 하나의 최종 구동환경 이미지에서 wget, unzip, git, gradle을 설치(리눅스 yum, apt-get 등)

2. wget, unzip 등으로 yum 및 apt-get에 없는 프로그램들을 설치

3. 환경변수 설정

4. 프로젝트를 내려받고

5. 빌드하고

6. 실행

Dockerfile

FROM amazoncorretto:8u352
LABEL stage=forbuild

RUN yum install wget -y
RUN yum install unzip -y
RUN yum install git -y

RUN wget https://services.gradle.org/distributions/gradle-7.6-bin.zip -P /tmp
RUN unzip -d /opt/gradle -oq /tmp/gradle-7.6-bin.zip
RUN rm /tmp/gradle-7.6-bin.zip
ENV PATH /opt/gradle/gradle-7.6/bin:$PATH

RUN [ "git", "clone", "https://github.com/BlackdeerY/restdocs-maven.git", "restdocs" ]

WORKDIR /restdocs
RUN [ "gradle", "jar" ]

EXPOSE 8090
ENTRYPOINT [ "java", "-jar", "/restdocs/build/libs/restdocs-maven-0.0.1-SNAPSHOT.war" ]

docker 명령

docker build --no-cache -t 생성될이미지명:태그 Dockerfile경로

docker image prune --filter label=stage=forbuild

docker run -d -it -p 28090:8090 --name 생성될컨테이너명 생성한이미지명

위 예시의 추가된 Dockerfile의 명령어들

ㆍENV key value: 환경변수를 설정

결과적으로 최종 이미지에 구동과는 필요 없는 프로그램들이 남은 채이므로,

최종 이미지 용량이 쓸데없이 커진다.

라이브러리에 이미 존재하는 이미지들을 활용하도록 하고,

없더라도 최종 구동과 상관이 없다면 이전 단계의 이미지에서 설치하여 사용 후 결과만 이동시켜서 사용한다.

Dockerfile 공식 문서는

https://docs.docker.com/engine/reference/builder/

Dockerfile reference

docs.docker.com

원클릭 마우스 정확도 향상 끄기

현록 — Wed, 21 Sep 2022 16:37:26 +0900

Moonlight를 포함한 몇몇 원격 프로그램 중에는

Host에 가상 키보드를 세팅하면서 마우스의 '포인터 정확도 향상'을 항상 켜버리는 프로그램들이 있다.

원격 Client에서 제어할 때는 모르다가

다시 직접 Host에 앉아서 제어할 때는 마우스가 뭔가 달라졌단게 느껴질 것이다.

개인 컴퓨터에서 항상 켜두고 사용하는 도구 프로그램에 마우스 정확도 향상 끄기와 US 키보드 제거 등을 탑재해두고 있었으나,

한 번 따로 빼내서 올려본다.

레지스트리를 덮는 방식으로도 끄는 것 같던데,

정확도 향상을 끈 상태의 레지스트리를 따로 빼냈다가 덮어씌워도

왜인지 적용이 안되서, 난 이 방법은 못 써서 아예 함수를 실행하는 쪽을 선택했었다.

MouseNoCorrection.7z

0.00MB

압축 파일의 두 파일(MouseNoCorrection.ps1, MouseNoCorrection.bat)을 한 폴더에 두고,

bat파일만 실행해주면 마우스 정확도 향상 옵션이 꺼진다.

(관리자 권한 필요없음)

두 파일의 코드는 아래와 같다.

위 파일이 안 받아지거나, 찝찝하면 직접 메모장으로 작성해서 확장자와 이름만 잘 맞춰주면 된다.

(MouseNoCorrection.bat)

@echo off
Powershell.exe -noprofile -executionpolicy bypass -file MouseNoCorrection.ps1

(MouseNoCorrection.ps1)

Function MouseNoCorrection { 
$pinvokeCode = @" 
using System; 
using System.Runtime.InteropServices; 
using Microsoft.Win32;
namespace MyMouse { 
    public class MouseCorrection { 
        [DllImport("user32.dll")]
        private static extern int SystemParametersInfo(uint uiAction, uint uiParam, IntPtr pvParam, uint fWinIni);

        public static void SetNoCorrection() { 
            int[] mouseParams = new int[3];
            SystemParametersInfo(0x0003, 0x0000, GCHandle.Alloc(mouseParams, GCHandleType.Pinned).AddrOfPinnedObject(), 0x0000);
            mouseParams[2] = 0;
            SystemParametersInfo(0x0004, 0x0000, GCHandle.Alloc(mouseParams, GCHandleType.Pinned).AddrOfPinnedObject(), 0x0002);
        } 
    } 
} 
"@ 
Add-Type $pinvokeCode -ErrorAction SilentlyContinue 
[MyMouse.MouseCorrection]::SetNoCorrection() 
} 
 
MouseNoCorrection

bat파일의 바로가기를 만들어서 응용하는 방식은 아래 포스트 마지막 부분 참고.

https://ydeer.tistory.com/102

원클릭 해상도 변경 (주사율(Hz) 추가, 모니터 지정 추가)

컴퓨터의 해상도를 클릭 한 번으로 변경하는 방법입니다. 질문 댓글이 달린 김에 백업 겸 정리해둡니다. 윈도우 타일메뉴에 다음과 같이 설치해서 언제든 가로/세로 와 해상도를 바꿀 수 있습니

ydeer.tistory.com

Java - volatile 키워드, synchronized 키워드

현록 — Sun, 7 Aug 2022 18:53:24 +0900

https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/reflect/Modifier.html

package testvolatile;

public abstract class ObjectTest {
    public abstract int getInteger();
    public abstract void setInteger(int integer);
}

package testvolatile;

public class ObjectTestVolatile extends ObjectTest {
    private volatile int integer;

    public ObjectTestVolatile() {
        super();
        this.integer = 0;
    }

    @Override
    public int getInteger() {
        return integer;
    }

    @Override
    public void setInteger(int integer) {
        this.integer = integer;
    }
}

package testvolatile;

public class ObjectTestSync extends ObjectTest  {
    private int integer;

    public ObjectTestSync() {
        super();
        this.integer = 0;
    }

    @Override
    public synchronized int getInteger() {
        return integer;
    }

    @Override
    public synchronized void setInteger(int integer) {
        this.integer = integer;
    }
}

package testvolatile;

import java.util.concurrent.atomic.AtomicInteger;

public class ObjectTestAtomic extends ObjectTest  {
    private AtomicInteger integer;

    public ObjectTestAtomic() {
        super();
        this.integer = new AtomicInteger(0);
    }

    @Override
    public int getInteger() {
        return integer.get();
    }

    @Override
    public void setInteger(int integer) {
        this.integer.set(integer);
    }
}

package testvolatile;

import java.util.concurrent.atomic.AtomicBoolean;

public class TestMain {
    boolean bool = true;
    volatile boolean volatileBool = true;
    AtomicBoolean atomicBoolean = new AtomicBoolean(true);

    public void test() {
        new Thread(() -> {
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
            }
            bool = false;
            System.out.println(String.format("non-volatile: %s", bool));
        }).start();
        new Thread(() -> {
            while (bool) {
                // 아무 명령도 없는 경우에, bool을 갱신하지 않고 캐시 그대로 사용해서 종료되지 않음
            }
            System.out.println("non-volatile 종료됨");
        }).start();
        new Thread(() -> {
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
            }
            volatileBool = false;
            System.out.println(String.format("volatile: %s", volatileBool));
        }).start();
        new Thread(() -> {
            while (volatileBool) {
                // 아무 명령도 없는 경우에도.
            }
            System.out.println("volatile 종료됨");
        }).start();
        new Thread(() -> {
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
            }
            atomicBoolean.set(false);
            System.out.println(String.format("atomicBoolean: %s", atomicBoolean.get()));
        }).start();
        new Thread(() -> {
            while (atomicBoolean.get()) {
                // 아무 명령도 없는 경우에도.
            }
            System.out.println("atomicBoolean 종료됨");
        }).start();
    }

    public static void main(String[] args) {
        TestMain testMain = new TestMain();
        testMain.test();

        try {
            Thread.sleep(3000L);
        } catch (InterruptedException e) {
        }
        System.out.println("--------------------------------------------------");






        ObjectTestVolatile objectTestVolatile = new ObjectTestVolatile();
        for (int i = 0; i < 200; ++i) {
            new Thread(() -> {
                objectTestVolatile.setInteger(objectTestVolatile.getInteger() + 1);
                System.out.println(String.format("%10s: %03d", "volatile", objectTestVolatile.getInteger()));
            }).start();
        }
        try {
            Thread.sleep(5000L);
        } catch (InterruptedException e) {
        }
        System.out.println("--------------------------------------------------");



        ObjectTestSync objectTestSync01 = new ObjectTestSync();
        for (int i = 0; i < 200; ++i) {
            new Thread(() -> {
                objectTestSync01.setInteger(objectTestSync01.getInteger() + 1);
                System.out.println(String.format("%10s: %03d", "sync", objectTestSync01.getInteger()));
            }).start();
        }
        try {
            Thread.sleep(5000L);
        } catch (InterruptedException e) {
        }
        System.out.println("--------------------------------------------------");



        ObjectTestSync objectTestSync02 = new ObjectTestSync();
        for (int i = 0; i < 200; ++i) {
            new Thread(() -> {
                synchronized (objectTestSync02) {
                    objectTestSync02.setInteger(objectTestSync02.getInteger() + 1);
                    System.out.println(String.format("%10s: %03d", "sync-block", objectTestSync02.getInteger()));
                }
            }).start();
        }
        try {
            Thread.sleep(5000L);
        } catch (InterruptedException e) {
        }
        System.out.println("--------------------------------------------------");



        ObjectTestAtomic objectTestAtomic = new ObjectTestAtomic();
        for (int i = 0; i < 200; ++i) {
            new Thread(() -> {
                objectTestAtomic.setInteger(objectTestAtomic.getInteger() + 1);
                System.out.println(String.format("%10s: %03d", "atomic", objectTestAtomic.getInteger()));
            }).start();
        }
        try {
            Thread.sleep(5000L);
        } catch (InterruptedException e) {
        }
        System.out.println("--------------------------------------------------");
    }
}

atomicBoolean 종료됨

volatile 종료됨 (non-volatile 종료됨은 출력되지 않았고, 쓰레드도 계속 도는 상황!)

non-volatile: false

atomicBoolean: false

volatile: false

--------------------------------------------------

volatile: 002

volatile: 003

volatile: 001

volatile: 004

volatile: 005

volatile: 006

volatile: 008

volatile: 009

..........

volatile: 197

volatile: 198

volatile: 199

volatile: 200

--------------------------------------------------

sync: 003

sync: 005

sync: 002

sync: 005

sync: 001

sync: 006

sync: 007

sync: 009

..........

sync: 118

sync: 178

sync: 176

sync: 174

--------------------------------------------------

sync-block: 001

sync-block: 002

sync-block: 003

sync-block: 004

sync-block: 005

sync-block: 006

sync-block: 007

sync-block: 008

..........

sync-block: 197

sync-block: 198

sync-block: 199

sync-block: 200

--------------------------------------------------

atomic: 001

atomic: 002

atomic: 003

atomic: 005

atomic: 004

atomic: 006

atomic: 007

atomic: 008

..........

atomic: 193

atomic: 194

atomic: 196

atomic: 197

atomic: 198

atomic: 199

atomic: 200

--------------------------------------------------

ㆍ코드로 보면 "non-volatile 종료됨"이 출력되어야할 것 같지만,

　while (bool)에서 bool을 캐시에 둔 값만 사용해서 계속 true로 사용하여 종료되지 않는다.

ㆍ반면 while (volatileBool)은 volatileBool을 메인 메모리에 두기 때문에, 정상적으로 종료된다. (volatile 종료됨)

ㆍwhile (bool)도 내부에 코드가 있으면 캐시를 새로 고치려 하기 때문에,

　일부러 이런 상황을 만들기도 어렵지만, 실제로 발생할 수 있는 상황이다.

ㆍvolatile 키워드는 변수를 메인 메모리에 저장할 뿐, 그렇다고 thread-safe한 결과를 내진 않는다.

　값을 읽을 때는 캐시와의 차이는 없더라도, 쓰레드간 순서는 보장하지 않는다.

　volatile이 multi-thread 상황에서 각자의 캐시간 값 차이를 없앨 수 있는 수단 중 하나일 뿐,

　그 순서를 보장해주진 않는다. 순서는 lock의 개념으로 가야한다.

　multi-thread 상황 때문에 둘을 한 범주에 두고 생각해버릴 수 있다.

ㆍvolatile 멤버 변수를 둔 개체라도, multi-thread에서 순서는 보장 되지 않는 것을 결과로 확인할 수 있다.

ㆍgetter()와 setter()가 synchronized 메서드라도,

　System.out.println()이 synchronized 메서드가 아니기 때문에,

　출력에서 순서가 보장되지 않는다.

　(사용하는 모든 메서드가 동일한 개체에 synchronized여야 순서를 보장받을 수 있다.)

ㆍsynchronized () {} 블록으로 묶은 후에야 순서가 보장되었다.

ㆍAtomicWrapper 클래스를 역시 내부에 volatile 키워드를 사용하여 thread별 캐시간 값 차이를 없앨을 뿐,

　순서는 보장해주지 않는다.

ㆍ여러 Thread에서 동시에 접근하는 변수라면, volatile 키워드를 사용한다.

ㆍvolatile 변수라도 자체적으로 lock을 해주는 것은 아니다.

　multi-thread에서 순서를 보장하려면 synchronized 키워드나 Semaphore 클래스가 필요하다.

ㆍ한 mutex에 묶인 synchronized가 아니라면, 그 사이에는 synchronized 되지 않은 채 진행되므로,

　원하는 결과를 얻지 않을 수 있다.

　사용하는 메서드와 흐름을 잘 파악하고 묶어야한다.

ssh-keygen 명령어로 SSH키 쌍 생성

현록 — Sun, 31 Jul 2022 11:13:48 +0900

[SSH 접속과 키 쌍]

[옵션 확인]

[옵션 없이 사용]

[옵션 사용]

[키 파일로부터 정보 확인]

[public key 복구]

[SSH 접속과 키 쌍]

SSH에서

private key는 권한자를 의미하고,

public key는 해당 권한자에게 허용하겠다는 의미이다.

SSH Host에서는 authorized_key 리스트에 public key들을 수록하여,

해당 public key와 쌍을 이루는 private key를 가진 권한자에게 접속을 허용하기로 한다.

Client에서는 private key를 이용하여 Host에 접속한다.

ㆍHost: public key 보유

ㆍClient: private key 사용

[옵션 확인]

% ssh-keygen --help_

로 옵션을 확인하면 된다. (https://www.freebsd.org/cgi/man.cgi?query=ssh-keygen)

[옵션 없이 사용]

% ssh-keygen_

Generating public/private rsa key pair.

Enter file in which to save the key (/Users/blackdeer/.ssh/id_rsa): /Users/blackdeer/.ssh/test01_

Enter passphrase (empty for no passphrase): 숨겨진입력_

Enter same passphrase again: 숨겨진입력_

Your identification has been saved in /Users/blackdeer/.ssh/test01

Your public key has been saved in /Users/blackdeer/.ssh/test01.pub

The key fingerprint is:

SHA256:avOfU8xcBulhus7IR9wD25S4oDikFF17S5gm23ZFu04 blackdeer@Mac.local

The key's randomart image is:

+---[RSA 3072]----+

| . .. . . |

| . . + . .= |

| .. = o o= + |

| . .= o.o+.+ o |

| . o..o.SoE% o |

| . o..o o* O |

| .+. =.. . |

| . oo =. |

| .oo. |

+----[SHA256]-----+

ㆍ-t 타입 옵션으로 타입을 지정해주지 않으면, 기본적으로 RSA방식의 키를 생성한다.

ㆍ-b 길이 옵션으로 길이를 지정해주지 않으면, 기본적으로 3072 Bits의 키를 생성한다. (2022년 07월 기준)

　(※ NIST에서 권장하는 길이 - 2002년: 1024 Bits, 2015년: 2048 Bits, ...)

ㆍ-f 저장경로 옵션으로 파일 생성 위치를 지정하지 않으면,

　처음 질문으로 파일 생성 위치를 묻는다.

　이 때는 ~(/Users/로그온한사용자)의 단축 형식이 통하지 않으니, 절대경로로 적어준다.

ㆍ-N 암호 옵션으로 암호(passphrase)를 지정하지 않으면, 키 생성시 사용할 암호를 물어본다. (Enter passphrase)

　암호를 입력하면, 키를 사용할 때마다 해당 암호를 입력해야 한다.

　그냥 빈 칸으로 입력하면 암호를 사용하지 않는다.

ㆍ-E 지문해시유형 옵션으로 지문 생성의 해시 유형을 지정하지 않으면,

　기본적으로 SHA256으로 생성한다. -E sha256, -E md5로 지정 가능하다.

ㆍ-C 코멘트 옵션으로 코멘트를 지정할 수 있다.

　지정하지 않으면, 로그온한 사용자명 등이 기본으로 들어간다.

ㆍ키는 private key, public key 쌍으로 생성되며, public key의 뒤에는 .pub이 붙는다.

[옵션 사용]

% ssh-keygen -t rsa -b 4096 -f ~/.ssh/test02 -C "코멘트: 예시를 위해 생성" -N ""_

Generating public/private rsa key pair.

Your identification has been saved in /Users/blackdeer/.ssh/test02

Your public key has been saved in /Users/blackdeer/.ssh/test02.pub

The key fingerprint is:

SHA256:RqvdvvVWdpZJyygyLocNj8TgakvTnaqcKpDrduzB6Co 코멘트: 예시를 위해 생성

The key's randomart image is:

+---[RSA 4096]----+

| |

| . |

| . . . . |

| . . o S + +|

|o o ...B.+ . . ==|

|.o.=..ooO + o +.|

|E.o=+ .+ * . .. |

|B+=*o. o o. .. |

+----[SHA256]-----+

옵션들을 지정해서 별다른 대화문 없이 생성했다.

(옵션들의 설명은 위의 [옵션 없이 사용] 참고)

[키 파일로부터 정보 확인]

% ssh-keygen -l -f ~/.ssh/test02_

4096 SHA256:RqvdvvVWdpZJyygyLocNj8TgakvTnaqcKpDrduzB6Co 코멘트: 예시를 위해 생성 (RSA)

ㆁ-l 옵션으로

　ㆍ키의 암호화 방식(위의 예시에선 (RSA))

　ㆍ키의 Bits 길이(위의 예시에선 4096)

　ㆍ지문의 해시 유형(위의 예시에선 SHA256)

　ㆍ지문(위의 예시에선 RqvdvvVWdpZJyygyLocNj8TgakvTnaqcKpDrduzB6Co)

　ㆍ코멘트(위의 예시에선 "코멘트: 예시를 위해 생성")

　를 확인할 수 있다.

[public key 복구]

public key로 private key를 알아낼 순 없지만(비대칭 키 암호화의 의의),

private key로 public key는 언제든 복구할 수 있다.

% ssh-keygen -y -f ~/.ssh/test02_

Enter passphrase: 숨겨진입력_

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDGMOjJebCj8EGU2CFbO68ufFg0CP4iAVwR55AOSBt6gEgkixIoD9pw7qhcb0wTMtn2EzF/F7LCXD9ElT2Q9Bg4WlH02RBkMpzgTSFdO54dSCi3BO45RTMwW0HJDX5pFLANdRwpbbShg8blclQZSNANZQwt8cTnIWRswgerVlCclsMnkYJvFf2BCaXO/uZuUGEh/0vADqSPGb1XeHFPS+Qg4NPBjYOEuTz4btvPARgE0YbYF6cPbUXHWn8QEdUE/T/0SY7Z0V5ueJl78PqLkn+tdaTG7tZnEORaNVkYMSxLtLeLMDTWcBInj74C+5wjzZMtYj+xDy2377cTQyW1jlZ1en4S2rxMvX0BZcOpTknp20bcbj6zyAQISw+Ol+YcfJsFXebiAMsG6/2zhAHF1A2wkOtOUd2E9MzGQZ2P2EM+CnkxDptFXe7Mz4aIr0SSeIeJoq5x32mp1WGBPt2Uzfjrh826EBn2dW2bx3pQsfm8tBluegbqvc2ImKZGbPKgOntBVTPQWsBF6yuCypVV6wFgHUvxMk0cu62N+KdDuueZVEWmROACapXisgAbd6WNg6WXlu6mni+SOeNfruBZDFnDonLwU6AyKDshn0Xdj2e8z8GBzjY27PvRkmXlvq3SYa/Ab0zEmkAl06dTlettjNl9hay4P6+0NZnSBuGyw4W9Aw== 코멘트: 예시를 위해 생성

(만약 키 생성시 암호(passphrase)를 지정했다면, 암호를 입력해야한다.)

% ssh-keygen -y -f ~/.ssh/test02 > ~/.ssh/test02.pub_

-y 옵션의 출력은 기본적으로 stdout이므로,

리눅스 명령어 >로 파일로 출력해서 사용한다.

CP1300 크레딧카드 인쇄 팁

현록 — Tue, 28 Jun 2022 18:56:04 +0900

Cannon 셀피 포토프린터 CP1300

크레딧카드 사이즈(54×86mm: KC-36IP, KF-18IF) 인쇄 팁

psd파일로 300dpi 54mm*85mm를 만들면

638*1004 픽셀의 문서가 만들어진다.

인쇄 특성상 도무송(칼선)에 항상 완벽하게 맞출 수 없어서인지,

이대로 인쇄를 하면 상하좌우로 일정 부분을 깎은 채(▣) 인쇄가 된다.

용지의 각도의 엇나감 등을 고려하여

안전 범위상으로 1mm미만 정도의 오차만 두도록 하여 여백을 두려면,

ㆍ좌에 2.8mm 추가(←),

ㆍ우에 3.2mm 추가(→),

ㆍ상에 2.6mm 추가(↑),

ㆍ하에 3.4mm 추가(↓)

를 해주면 얼추 맞는다.

ㆍ보통 카드가 85.5mm라, 붙인 후 아래 쪽 0.5mm를 잘라낼 거라면, 상 2.5mm/하 3.5mm 후 아래를 잘래내면 됨.

　(여백이 비뚤어질 수 있으니, 안전하게 그냥 2.6/3.4로 이미지 약간을 날리는 선택도 있고... 이건 해보고 판단)

ㆍ인쇄할 때, 용지는 출력방향(↓)이 아닌, 반대방향인 삽입구(↑)에 밀착시킨다.

포토샵용 좌우상하 캔버스 크기 수정 액션(매크로) 파일도 아래에 첨부.

Margin_CP1300_CreditCardSize.atn

0.00MB

Margin_CP1300_CreditCardSize_Cut.atn

0.00MB

액션을 불러오는 방법은
https://helpx.adobe.com/kr/photoshop/using/playing-actions.html

혹은 "포토샵 액션 불러오기" 검색

기본 알고리듬

현록 — Wed, 22 Jun 2022 13:14:51 +0900

[이동용 목차] (항목 클릭)

ㆁ소수(Prime Number)

　＊소수란

　＊소수 판별 - 에라토스테네스의 체 (Sieve of Eratosthenes)

ㆁ최대공약수(greastest common divisor, GCD)

　＊유클리드 호제법 (Euclidean algorithm)

　＊ 개의 수의 공통 최대공약수

ㆁ최소공배수(least common multiple, LCM)

　＊ 개의 수의 공통 최소공배수

ㆁ이진 탐색 (Binary Search)

ㆁ버블 정렬 (Bubble Sort)

ㆁ선택 정렬 (Selection Sort)

　＊기본

　＊개선 1: 순회할 때 최소와 최대를 동시에

　＊개선 2: 같은 최솟값은 한꺼번에

ㆁ삽입 정렬 (Insertion Sort)

ㆁ퀵 정렬 (Quick Sort)

ㆁ합병 정렬 (Merge Sort)

ㆁ힙 정렬 (Heap Sort)

ㆁ소수(Prime Number)

　＊소수란

　　ㆍ1보다 큰 자연수 중, 1과 자기 자신만을 약수로 갖는 수 (1과 자기 자신으로만 나머지가 0으로 나눠 떨어지는 수)

　　ㆍex) 2, 3, 5, 7, 11, 13, 17, 19, 23, 31, 37, 41, ...

　　ㆍ짝수는 모두 2의 배수이기 때문에, 2를 제외하고는 모두 홀수이다. 하지만 2는 소수에 포함된다.

　　ㆍ유클리드의 정리 (Euclid's theorem)에 의하면, 소수는 무한히 존재한다.

　　ㆍ반대의 개념은 합성수(Composite Number)

　　ㆍhttps://en.wikipedia.org/wiki/Prime_number

　　ㆍhttps://ko.wikipedia.org/wiki/소수_(수론)

　　ㆍhttps://en.wikipedia.org/wiki/Euclid's_theorem

　　ㆍhttps://ko.wikipedia.org/wiki/유클리드의_정리

　＊에라토스테네스의 체 (Sieve of Eratosthenes)

https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes

　　ㆍ고대 그리스 수학자 에라토스테네스가 발견한, 소수를 찾는 방법(알고리듬)

　　ㆍhttps://en.wikipedia.org/wiki/Sieve_of_Eratosthenes

　　ㆍhttps://ko.wikipedia.org/wiki/에라토스테네스의_체

public int[] getPrimeNumbersBySieveOfEratosthenes(int max) {
    // boolean은 false로 초기화되므로, '소수가 아니다'의 false는 '소수이다'로 시작.
    boolean[] isNotPrimeNumber = new boolean[max];
    isNotPrimeNumber[0] = true;    // 1은 소수가 아님
    for (int i = 2; i * i <= max; ++i) {
        for (int j = i * i; j <= max; j += i) {    // i * 2 부터 시작이 아니라, i * i 부터 시작. i * i 이전의 i의 배수들은 이전 과정에서 체크되었음.
            isNotPrimeNumber[j - 1] = true;    // 자기 자신을 제외한, 자신의 배수들은 모두 소수가 아님.
        }
    }
    // 소수들의 갯수
    int count = 0;
    for (int i = 0; i < isNotPrimeNumber.length; ++i) {
        if (isNotPrimeNumber[i] == false) {
            ++count;
        }
    }
    // 소수들을 담아 반환할 int[] 배열
    int[] primeNumbers = new int[count];
    int index = 0;
    for (int i = 0; i < isNotPrimeNumber.length && index < count; ++i) {
        if (isNotPrimeNumber[i] == false) {
            primeNumbers[index++] = i + 1;
        }
    }
    return primeNumbers;
}

private boolean[] getBooleanArrayMeansNotPrimeNumbers(int max) {
    // boolean은 false로 초기화되므로, '소수가 아니다'의 false는 '소수이다'로 시작.
    boolean[] isNotPrimeNumber = new boolean[max];
    isNotPrimeNumber[0] = true;    // 1은 소수가 아님
    for (int i = 2; i * i <= max; ++i) {
        for (int j = i * i; j <= max; j += i) {    // i * 2 부터 시작이 아니라, i * i 부터 시작. i * i 이전의 i의 배수들은 이전 과정에서 체크되었음.
            isNotPrimeNumber[j - 1] = true;    // 자기 자신을 제외한, 자신의 배수들은 모두 소수가 아님.
        }
    }
    return isNotPrimeNumber;
}

public int getCountOfPrimeNumbers(int max) {
    return getCountOfPrimeNumbers(max, getBooleanArrayMeansNotPrimeNumbers(max));
}

private int getCountOfPrimeNumbers(int max, boolean[] isNotPrimeNumber) {
    // 소수들의 갯수
    int count = 0;
    for (int i = 0; i < isNotPrimeNumber.length; ++i) {
        if (isNotPrimeNumber[i] == false) {
            ++count;
        }
    }
    return count;
}

public int[] getIntegerArrayMeansPrimeNumbers(int max) {
    boolean[] isNotPrimeNumber = getBooleanArrayMeansNotPrimeNumbers(max);
    int count = getCountOfPrimeNumbers(max, isNotPrimeNumber);

    // 소수들을 담아 반환할 int[] 배열
    int[] primeNumbers = new int[max];
    int index = 0;
    for (int i = 0; i < isNotPrimeNumber.length && index < count; ++i) {
        if (isNotPrimeNumber[i] == false) {
            primeNumbers[index++] = i + 1;
        }
    }
    return primeNumbers;
}

ㆁ최대공약수(greastest common divisor, GCD)

　＊유클리드 호제법 (Euclidean algorithm)

　　ㆍ서로 호(互), 나눌 제(除). 두 개의 양의 정수간의 최대공약수를 구함.

　　ㆍ 와 의 최대공약수는,

　　　 = * + 　( 은 미만의 나머지 형태)

　　　 ↙　 ↙

　　　 = * +

　　　 ↙　 ↙

　　　 = * + ...　를 반복하다가, 상수항(나머지)이 없을 때의 계수가 최대공약수

　　ㆍ570 = 36×15 + 30

　　　 36 = 30×1 + 6

　　　 30 = 6×5

　　　→ ∴ 6

　　ㆍhttps://en.wikipedia.org/wiki/Euclidean_algorithm

　　ㆍhttps://ko.wikipedia.org/wiki/유클리드_호제법

　　ㆍhttps://namu.wiki/w/유클리드 호제법

public int getGCDbyEuclideanAlgorithm(int number1, int number2) {
    if (number1 == number2) {
        return number1;
    }
    int big = 0;
    int small = 0;
    if (number1 > number2) {
        big = number1;
        small = number2;
    } else {
        big = number2;
        small = number1;
    }
    while (true) {
        int residue = big % small;
        if (residue == 0) {
            return small;
        } else {
            big = small;
            small = residue;
        }
    }
}

　＊ 개의 수를 소인수분해하여, 각 수의 소수들 중 공통되는 부분들만 가장 큰 형태로.

　　ㆍ소수는 아니지만, 최소 1은 공통될 수 있으니, 구하려던 수들이 서로소라면 최대공약수는 1이된다.

　　ㆍ60 = 2²×3×5

　　　24 = 2³×3

　　　20 = 2²×5

　　　→ ∴ 2² = 4

public int getGCD(int[] numbers) {
    if (numbers.length == 1) {
        return numbers[0];
    }
    int answer = 1;
    HashMap<Integer, Integer>[] primeNumbers = new HashMap[numbers.length];    // 각각의 소인수분해 결과를 <Key: 밑, Value: 지수> 형태로 담음
    for (int i = 0; i < numbers.length; ++i) {
        primeNumbers[i] = new HashMap<>();
        int thisNumber = numbers[i];
        int divisor = 2;
        while (thisNumber > 1) {
            if (thisNumber % divisor == 0) {
                if (primeNumbers[i].containsKey(divisor)) {
                    primeNumbers[i].put(divisor, primeNumbers[i].get(divisor) + 1);
                } else {
                    primeNumbers[i].put(divisor, 1);
                }
                thisNumber /= divisor;
            } else {
                ++divisor;
            }
        }
    }
    loop1:
    for (Integer primeNumber : primeNumbers[0].keySet()) {    // 공통되어야 하므로, 아무 결과를 하나로 기준으로 해도 됨.
        for (int i = 1; i < numbers.length; ++i) {
            if (primeNumbers[i].containsKey(primeNumber) == false) {    // 소수를 공통으로 지니지 않으면 해당 소수는 결과에 포함되지 않음.
                continue loop1;
            }
        }
        int maxCommonPower = primeNumbers[0].get(primeNumber);    // 지수는 Value들 중의 최소값으로.
        for (int i = 1; i < numbers.length; ++i) {
            int power = primeNumbers[i].get(primeNumber);
            if (power < maxCommonPower) {
                maxCommonPower = power;
            }
        }
        for (int i = 0; i < maxCommonPower; ++i) {
            answer *= primeNumber;
        }
    }
    return answer;
}

ㆁ최소공배수(least common multiple, LCM)

　＊ 개의 수를 소인수분해하여, 각 수의 소수들은 모두 포함하되, 승수는 가장 높도록.

　　ㆍ60 = 2²×3×5

　　　37 = 37

　　　24 = 2³×3

　　　→ ∴ 2³×3×5×37 = 4440

　　ㆍ[Lv2] N개의 최소공배수 (https://ydeer.tistory.com/36)

public int getLCM(int[] numbers) {
    if (numbers.length == 1) {
        return numbers[0];
    }
    int answer = 1;
    HashMap<Integer, Integer>[] primeNumbers = new HashMap[numbers.length];    // 각각의 소인수분해 결과를 <Key: 밑, Value: 지수> 형태로 담음
    for (int i = 0; i < numbers.length; ++i) {
        primeNumbers[i] = new HashMap<>();
        int thisNumber = numbers[i];
        int divisor = 2;
        while (thisNumber > 1) {
            if (thisNumber % divisor == 0) {
                if (primeNumbers[i].containsKey(divisor) == true) {    // 이미 존재하면, 기존보다 +1승.
                    primeNumbers[i].put(divisor, primeNumbers[i].get(divisor) + 1);
                } else {
                    primeNumbers[i].put(divisor, 1);    // 최초라면 1번째 등장이니 1승.
                }
                thisNumber /= divisor;
            } else {
                ++divisor;
            }
        }
    }
    HashMap<Integer, Integer> results = new HashMap<>();    // 결과를 <Key: 밑, Value: 지수> 형태로 저장해 둠. 지수가 점점 커질 수 있으니 저장하면서 진행.
    for (int i = 0; i < numbers.length; ++i) {    // 소인수분해 결과 중 소수(밑. Key)는 어쨌든 다 사용.
        for (Integer base : primeNumbers[i].keySet()) {
            int thisPower = primeNumbers[i].get(base);
            if (results.containsKey(base) == true) {    // 이미 결과에 밑(Key)이 있었으면, 큰 지수(Value) 계산 후 저장.
                int resultsPower = results.get(base);
                if (thisPower > resultsPower) {
                    results.put(base, thisPower);
                }
            } else {    // 최초라면 우선 그냥 저장(소수는 어쨌든 다 사용).
                results.put(base, thisPower);
            }
        }
    }
    for (Integer base : results.keySet()) {
        for (int i = 0; i < results.get(base); ++i) {
            answer *= base;
        }
    }
    return answer;
}

ㆁ이진 탐색 (Binary Search)

　ㆍhttps://en.wikipedia.org/wiki/Binary_search_algorithm

　ㆍhttps://ko.wikipedia.org/wiki/이진_검색_알고리즘

　ㆍhttps://namu.wiki/w/이진 탐색

public int binarySearchRecursive(int integers[], int target) {
    return binarySearchRecursiveCore(integers, 0, integers.length - 1, target);
}

private int binarySearchRecursiveCore(int integers[], int indexStart, int indexEnd, int target) {
    if (indexStart > indexEnd) {
        return -1;
    } else {
        int indexMiddle = (indexStart + indexEnd) / 2;
        if (integers[indexMiddle] == target) {
            return indexMiddle;
        } else if (integers[indexMiddle] < target) {
            return binarySearchRecursiveCore(integers, indexMiddle + 1, indexEnd, target);
        } else {
            return binarySearchRecursiveCore(integers, indexStart, indexMiddle - 1, target);
        }
    }
}

public int binarySearchLoop(int integers[], int target) {
    int indexStart = 0;
    int indexEnd = integers.length - 1;

    while (indexStart <= indexEnd) {
        int indexMiddle = (indexStart + indexEnd) / 2;
        if (integers[indexMiddle] == target) {
            return indexMiddle;
        } else if (integers[indexMiddle] < target) {
            indexStart = indexMiddle + 1;
        } else {
            indexEnd = indexMiddle - 1;
        }
    }
    return -1;
}

ㆁ버블 정렬 (Bubble Sort)

https://en.wikipedia.org/wiki/Bubble_sort

Cortesi, Aldo (27 April 2007). "Visualising Sorting Algorithms". Retrieved 16 March 2017.

https://en.wikipedia.org/wiki/Bubble_sort

　ㆍhttps://ko.wikipedia.org/wiki/거품_정렬

　ㆍhttps://en.wikipedia.org/wiki/Bubble_sort

　ㆍhttps://namu.wiki/w/정렬 알고리즘?from=버블 정렬#s-2.1.1

　ㆍ시간 복잡도: ( ²)

　ㆍ공간 복잡도: (1)

　ㆍ안정성: 보장 됨 (O)

public void bubbleSort(int[] integers) {
    for (int i = 0; i < integers.length - 1; ++i) {
        for (int j = 0; j < integers.length - 1 - i; ++j) {
            if (integers[j] > integers[j + 1]) {
                int temp = integers[j];
                integers[j] = integers[j + 1];
                integers[j + 1] = temp;
            }
        }
    }
}

ㆁ선택 정렬 (Selection Sort)

　＊기본

https://ko.wikipedia.org/wiki/선택_정렬

　　ㆍhttps://en.wikipedia.org/wiki/Selection_sort

　　ㆍhttps://ko.wikipedia.org/wiki/선택_정렬

　　ㆍhttps://namu.wiki/w/정렬 알고리듬?from=선택 정렬#s-2.1.2

　　ㆍ시간 복잡도: ( ²)

　　ㆍ공간 복잡도: (1)

　　ㆍ안정성: 보장 안 됨 (X)

public void selectionSort(int[] integers) {
    for (int i = 0; i < integers.length - 1; ++i) {
        int indexMin = i;
     // for (int j = i + 1; j < integers.length; ++j) {
        for (int j = i;     j < integers.length; ++j) {
            if (integers[indexMin] > integers[j]) {
                indexMin = j;
            }
        }
     // if (indexMin != i) {
            int temp = integers[i];
            integers[i] = integers[indexMin];
            integers[indexMin] = temp;
     // }
    }
}

　＊개선 1: 순회할 때 최소와 최대를 동시에

　　ㆍ약간의 효율성을 높일 뿐, 2중 반복문이므로 시간복잡도는 여전히 ( ²)

public void selectionSortSimultaneous(int[] integers) {
    // 양 끝에 동시에 자리 잡으므로
    // 시작 위치를 n-1 까지가 아닌,
    // 절반(총 요소 수 짝수) 혹은 절반+1(총 요소 수 홀수) 까지로 줄일 수 있다.
    // 약간의 효율성을 높일 뿐, 시간복잡도는 여전히  ( ^2)이다.
    for (int i = 0; i <= integers.length / 2; ++i) {
        int indexMin = i;
        int indexMax = integers.length - 1 - i;
        // 확정된 양 끝이 한 칸씩 줄어든다.
        for (int j = i; j < integers.length - i; ++j) {
            if (integers[indexMin] > integers[j]) {
                indexMin = j;
            }
            if (integers[indexMax] < integers[j]) {
                indexMax = j;
            }
        }
        if (indexMin != i) {
            int temp = integers[i];
            integers[i] = integers[indexMin];
            integers[indexMin] = temp;
            // 만약 최솟값이 자리를 잡았는데(위 if (indexMin != i) 반복문이 실행된 지금),
            // 이번 최솟값 위치(i)의 값이 최댓값이었다면, 바뀐 index(최댓값이 옮겨진)로 indexMax를 갱신해준다.
            if (indexMax == i) {
                indexMax = indexMin;
            }
        }
        if (indexMax != integers.length - 1 - i) {
            int temp = integers[integers.length - 1 - i];
            integers[integers.length - 1 - i] = integers[indexMax];
            integers[indexMax] = temp;
        }
    }
}

　＊개선 2: 같은 최솟값은 한꺼번에

　　ㆍ약간의 효율성을 높일 뿐, 2중 반복문이므로 시간복잡도는 여전히 ( ²)

　　ㆍ같은 값들을 한꺼번에 처리하기 위해 기억해두는 동작으로 인해 더 느려질 수도 있다...

　　　총 요소 수와 같은 칸의 배열을 만들어두면 공간복잡도가 (1)에서 ( )으로 증가하고,

　　　힙 영역을 사용하면 메모리 할당/해제로 더 느려진다.

ㆁ삽입 정렬 (Insertion Sort)

https://ko.wikipedia.org/wiki/삽입_정렬

https://en.wikipedia.org/wiki/Insertion_sort

https://ko.wikipedia.org/wiki/삽입_정렬

　ㆍhttps://en.wikipedia.org/wiki/Insertion_sort

　ㆍhttps://ko.wikipedia.org/wiki/삽입_정렬

　ㆍhttps://namu.wiki/w/정렬 알고리즘?from=삽입 정렬#s-2.1.3

　ㆍ시간 복잡도: ( ²)

　ㆍ공간 복잡도: (1)

　ㆍ안정성: 보장 됨 (O)

public void insertionSort(int[] integers) {
 // for (int i = 1; i < integers.length; ++i) {
    for (int i = 0; i < integers.length; ++i) {
        int index = i;
        while (true) {
            if (index == 0) {
                break;
            }
            if (integers[index] < integers[index - 1]) {
                int temp = integers[index - 1];
                integers[index - 1] = integers[index];
                integers[index] = temp;
                --index;
            } else {
                break;
            }
        }
    }
}

ㆁ퀵 정렬 (Quick Sort)

https://en.wikipedia.org/wiki/Quicksort

　ㆍhttps://en.wikipedia.org/wiki/Quicksort

　ㆍhttps://ko.wikipedia.org/wiki/퀵_정렬

　ㆍhttps://namu.wiki/w/정렬 알고리즘?from=퀵 정렬#s-2.2.3

　ㆍ시간 복잡도 - 평균: ( ·log ), 최악: ( ²)

　ㆍ공간 복잡도: (log )

　ㆍ안정성: 보장 안 됨 (X)

public void quickSortRecursive(int[] integers) {
    quickSortRecursiveCore(integers, 0, integers.length - 1);
}

private void quickSortRecursiveCore(int[] integers, int indexLeft, int indexRight) {
    if (indexLeft >= indexRight) {
        return;
    }
    int pivotValue = integers[indexRight];
    int indexWillBeFixed = indexLeft;
    for (int i = indexLeft; i < indexRight; ++i) {
        if (integers[i] < pivotValue) {
         // if (indexWillBeFixed != i) {
                int temp = integers[i];
                integers[i] = integers[indexWillBeFixed];
                integers[indexWillBeFixed] = temp;
         // }
            ++indexWillBeFixed;
        }
    }
 // if (indexWillBeFixed != indexRight) {
        integers[indexRight] = integers[indexWillBeFixed];
        integers[indexWillBeFixed] = pivotValue;
 // }
    quickSortRecursiveCore(integers, indexLeft, indexWillBeFixed - 1);
    quickSortRecursiveCore(integers, indexWillBeFixed + 1, indexRight);
}

ㆁ합병 정렬 (Merge Sort)

https://ko.wikipedia.org/wiki/합병_정렬

　ㆍhttps://en.wikipedia.org/wiki/Merge_sort

　ㆍhttps://ko.wikipedia.org/wiki/합병_정렬

　ㆍhttps://namu.wiki/w/정렬 알고리즘?from=합병 정렬#s-2.2.1

　ㆍ시간 복잡도: ( ·log )

　ㆍ공간 복잡도: ( )

　ㆍ안정성: 보장 됨 (O)

public void mergeSortRecursive(int[] integers) {
    if (integers.length > 1) {
        int[] arrayNextLeft = new int[integers.length / 2];
        int[] arrayNextRight = new int [integers.length - integers.length / 2];
        for (int i = 0; i < integers.length; ++i) {
            if (i < arrayNextLeft.length) {
                arrayNextLeft[i] = integers[i];
            } else {
                arrayNextRight[i - arrayNextLeft.length] = integers[i];
            }
        }
        mergeSortRecursiveCore(integers, arrayNextLeft, arrayNextRight);
    }
}

private void mergeSortRecursiveCore(final int[] arrayOrigin, final int[] arrayLeft, final int[] arrayRight) {
    if (arrayLeft.length > 1) {
        int[] arrayNextLeft = new int[arrayLeft.length / 2];
        int[] arrayNextRight = new int [arrayLeft.length - arrayLeft.length / 2];
        for (int i = 0; i < arrayLeft.length; ++i) {
            if (i < arrayNextLeft.length) {
                arrayNextLeft[i] = arrayLeft[i];
            } else {
                arrayNextRight[i - arrayNextLeft.length] = arrayLeft[i];
            }
        }
        mergeSortRecursiveCore(arrayLeft, arrayNextLeft, arrayNextRight);
    }
    if (arrayRight.length > 1) {
        int[] arrayNextLeft = new int[arrayRight.length / 2];
        int[] arrayNextRight = new int [arrayRight.length - arrayRight.length / 2];
        for (int i = 0; i < arrayRight.length; ++i) {
            if (i < arrayNextLeft.length) {
                arrayNextLeft[i] = arrayRight[i];
            } else {
                arrayNextRight[i - arrayNextLeft.length] = arrayRight[i];
            }
        }
        mergeSortRecursiveCore(arrayRight, arrayNextLeft, arrayNextRight);
    }
    // 재귀 결과로 arrayLeft와 arrayRight는 각각 정렬된 상태
    // (각각 아래 정렬을 먼저 적용 받은 상태)
    int indexLeft = 0;
    int indexRight = 0;
    for (int i = 0; i < arrayOrigin.length; ++i) {
        if (indexLeft >= arrayLeft.length) {
            arrayOrigin[i] = arrayRight[indexRight++];
        } else if (indexRight >= arrayRight.length) {
            arrayOrigin[i] = arrayLeft[indexLeft++];
        } else {
            if (arrayLeft[indexLeft] <= arrayRight[indexRight]) {
                arrayOrigin[i] = arrayLeft[indexLeft++];
            } else {
                arrayOrigin[i] = arrayRight[indexRight++];
            }
        }
    }
}

ㆁ힙 정렬 (Heap Sort)

https://en.wikipedia.org/wiki/Heapsort

　ㆍhttps://en.wikipedia.org/wiki/Heapsort

　ㆍhttps://ko.wikipedia.org/wiki/힙_정렬

　ㆍhttps://namu.wiki/w/정렬 알고리즘?from=힙 정렬#s-2.2.2

　ㆍ시간 복잡도: ( ·log )

　ㆍ공간 복잡도: (1)

　ㆍ안정성: 보장 안 됨 (X)

class Node {
    public Node(int data) {
        this.data = data;
    }

    private int data;
    private Node parent;
    private Node leftChild;
    private Node rightChild;

    public void changeNodeData(Node other) {
        int temp = this.data;
        this.data = other.data;
        other.data = temp;
    }
}

class Heap {
    private Node rootNode;

    private void addNode(Node node) {
        if (rootNode == null) {
            rootNode = node;
        } else {
            Node parent = getNodeToAdoptNext(rootNode);
            if (parent.leftChild == null) {
                parent.leftChild = node;
            } else {
                parent.rightChild = node;
            }
            node.parent = parent;
            sortBranchFromChild(node);
        }
    }

    private void setNodesFromArrays(int[] integers) {
        rootNode = null;
        for (int i = 0; i < integers.length; ++i) {
            addNode(new Node(integers[i]));
        }
    }

    private void sortBranchFromChild(Node node) {
        if (node.parent == null) {
            return;
        }
        if (node.parent.data < node.data) {
            node.changeNodeData(node.parent);
            sortBranchFromChild(node.parent);
        }
    }

    private int popMax() {
        int result = rootNode.data;
        Node endNode = getEndNode(rootNode);
        if (endNode == rootNode) {
            rootNode = null;
        } else {
            Node endsParent = endNode.parent;
            if (endsParent.leftChild == endNode) {
                endsParent.leftChild = null;
            } else {
                endsParent.rightChild = null;
            }
            endNode.parent = null;
            endNode.changeNodeData(rootNode);
            sortHeapFromParent(rootNode);
        }
        return result;
    }

    private void sortHeapFromParent(Node parentNode) {
        if (parentNode.leftChild == null && parentNode.rightChild == null) {
            return;
        } else if (parentNode.leftChild != null && parentNode.rightChild != null) {
            if (parentNode.data < parentNode.leftChild.data && parentNode.data < parentNode.rightChild.data) {
                if (parentNode.leftChild.data == parentNode.rightChild.data) {
                    parentNode.changeNodeData(parentNode.leftChild);
                    sortHeapFromParent(parentNode.leftChild);
                } else if (parentNode.leftChild.data > parentNode.rightChild.data) {
                    parentNode.changeNodeData(parentNode.leftChild);
                    sortHeapFromParent(parentNode.leftChild);
                } else {
                    parentNode.changeNodeData(parentNode.rightChild);
                    sortHeapFromParent(parentNode.rightChild);
                }
            } else if (parentNode.data < parentNode.leftChild.data) {
                parentNode.changeNodeData(parentNode.leftChild);
                sortHeapFromParent(parentNode.leftChild);
            } else if (parentNode.data < parentNode.rightChild.data) {
                parentNode.changeNodeData(parentNode.rightChild);
                sortHeapFromParent(parentNode.rightChild);
            }
        } else if (parentNode.leftChild != null) {
            if (parentNode.data < parentNode.leftChild.data) {
                parentNode.changeNodeData(parentNode.leftChild);
                sortHeapFromParent(parentNode.leftChild);
            }
        } else {
            if (parentNode.data < parentNode.rightChild.data) {
                parentNode.changeNodeData(parentNode.rightChild);
                sortHeapFromParent(parentNode.rightChild);
            }
        }
    }

    private Node getEndNode(Node parentNode) {
        if (parentNode.leftChild == null && parentNode.rightChild == null) {
            return parentNode;
        } else if (parentNode.leftChild != null && parentNode.rightChild != null) {
            Node leftEnd = getEndNode(parentNode.leftChild);
            Node rightEnd = getEndNode(parentNode.rightChild);
            Node leftParent = leftEnd.parent;
            int leftDepth = 1;
            while (leftParent.parent != null) {
                leftParent = leftParent.parent;
                ++leftDepth;
            }
            Node rightParent = rightEnd.parent;
            int rightDepth = 1;
            while (rightParent.parent != null) {
                rightParent = rightParent.parent;
                ++rightDepth;
            }
            if (leftDepth == rightDepth) {
                return rightEnd;
            } else if (leftDepth < rightDepth) {
                return rightEnd;
            } else {
                return leftEnd;
            }
        } else if (parentNode.leftChild != null) {
            return getEndNode(parentNode.leftChild);
        } else {
            return getEndNode(parentNode.rightChild);
        }
    }

    private Node getNodeToAdoptNext(Node parentNode){
        if (parentNode.leftChild != null && parentNode.rightChild != null) {
            Node leftEnd = getNodeToAdoptNext(parentNode.leftChild);
            Node rightEnd = getNodeToAdoptNext(parentNode.rightChild);
            Node leftParent = leftEnd.parent;
            int leftDepth = 1;
            while (leftParent.parent != null) {
                leftParent = leftParent.parent;
                ++leftDepth;
            }
            Node rightParent = rightEnd.parent;
            int rightDepth = 1;
            while (rightParent.parent != null) {
                rightParent = rightParent.parent;
                ++rightDepth;
            }
            if (leftDepth == rightDepth) {
                return leftEnd;
            } else if (leftDepth < rightDepth) {
                return leftEnd;
            } else {
                return rightEnd;
            }
        } else {
            return parentNode;
        }
    }
}

public void heapSort(int[] integers) {
    Heap heap = new Heap();
    heap.setNodesFromArrays(integers);
    for (int i = integers.length - 1; i >= 0; --i) {
        integers[i] = heap.popMax();
    }
}

원클릭 배율(DPI) 변경

현록 — Mon, 30 May 2022 18:23:44 +0900

[PC원격제어/help] - 원클릭 모니터변경 종결 (다중모니터,해상도,주사율,배율,회전,위치,...)

원클릭 모니터변경 종결 (다중모니터,해상도,주사율,배율,회전,위치,...)

[서론 및 소개] [사용법] [서론 및 소개] 원격 제어를 애용하면서 그동안 사용했던 모니터 설정 방법을 공유했었다. PC에 모니터를 3개나 연결해보면서 원하는 모니터 그룹만 켜두는 것이 Windows 기

ydeer.tistory.com

위 포스트에서 소개한 기능이 더 강력하므로, 위의 포스트를 추천합니다.

디스플레이 설정의 "텍스트, 앱 및 기타 항목의 크기 변경" 부분을 원클릭으로 수정하는 파일들입니다.

DPI라고도 부르는 부분입니다.

Windows 8~10까지는 동작 확인했으며,

Microsoft 문서에서 사용하지 않도록 권장하는 기능이라 향후 Windows 버전에 따라 작동하지 않을 수 있습니다.

(https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-systemparametersinfoa)

(SPI_SETLOGICALDPIOVERRIDE(=0x009F)는 Do not use로 되어있습니다.)

문서를 뒤져도 다른 버전의 DPI 세팅 기능은 없는 것 같고...

그래서 지금의 주모니터만 수정할 수 있는 것 외에 다른 모니터는 수정이 안됩니다.

주모니터 외의 다른 모니터의 DPI를 원클릭으로 수정하길 원하는건... 저도 잘 모르겠습니다.ㅠ

사실 DPI는 설정에서 바꾼다고 하더라도

로그오프 후 다시 들어오지 않는 한 깨지거나 흐릿한 상태로 지속되는 창들이 있는데,

그래서인지 즉각 바꾸는 방향을 원하지 않는 것 같습니다.

이 기능은 아래 개발자분의 코드와 위의 MSDN을 참고하였습니다.

(https://youtu.be/wA1Geom1NiA)

아래에 설명드릴 사용법이 난해하실 분을 위해,

맨 아래에 Sample.zip을 첨부하니, 그걸 바로 사용하셔도 됩니다.

해상도 조절을 위해 윈도우 기본 내장 PowerShell과 cmd명령구문을 사용할겁니다.
먼저, 아래 파일을 다운 받거나,

Set-DPI.ps1

0.00MB

빈 메모장을 연 후, 아래와 같이 입력하고, UTF-8로 Set-DPI.ps1 라는 이름으로 파일을 저장합니다.

Function Set-DPI { 
param ( 
[Parameter(Mandatory=$true, 
           Position = 0)] 
[int] 
$scaling
) 
$pinvokeCode = @" 
using System; 
using System.Runtime.InteropServices; 
namespace DPI
{ 
    public class SetDPI
    { 
        [DllImport("user32.dll", EntryPoint = "SystemParametersInfo")]
        public static extern bool SystemParametersInfo(
            uint uiAction,
            uint uiParam,
            uint pvParam,
            uint fWinIni);
    } 
} 
"@ 
Add-Type $pinvokeCode -ErrorAction SilentlyContinue 
[DPI.SetDPI]::SystemParametersInfo(0x009F,$scaling,$null,1) 
}

또, 아래 파일도 다운받거나,

빈 메모장을 열고 아래와 같이 적습니다.

. $PSScriptRoot\Set-DPI.ps1

Set-DPI 0

(100%는 0,

125%는 1,

150%는 2,

175%는 3)

이걸 원하는 UTF-8로 파일명.ps로 저장합니다.

이 파일들은 위의 Set-DPI.ps1 과 같은 곳에 위치시킵니다.

마지막으로, 아래 파일도 다운받거나,

빈 메모장을 열고 아래와 같이 접습니다.

@echo off
Powershell.exe -noprofile -executionpolicy bypass -file DPI_100.ps1

마지막의 "DPI_100.ps1" 부분이 위에서 작성한 파일명과 일치하도록 해주세요.

이것도 아까의 ps1 파일들과 같은 곳에 위치시킵니다.

그리고 이 bat파일을 실행하기만 하면 주모니터의 DPI가 바뀝니다.

윈도우 시작 메뉴에 두고 싶으시면,

bat파일의 바로가기를

C(윈도우설치드라이브):\Users\로그온한사용자\AppData\Roaming\Microsoft\Windows\Start Menu\Programs
에 만들어주고, 모든 앱 보기 상태에서 타일 메뉴에 등록을 하면 됩니다.

(원클릭 해상도 포스트 참고)

일부러 해상도와는 분리시켰지만,

사용자가 원한다면 한꺼번에 실행되도록 할 수 있습니다.

ps1 파일들은 그대로 내버려두고,

bat 파일을 입맛에 맞게 수정하면 됩니다.

주모니터만 바꾼다고 가정하여,

가로모드로 해상도와 배율을 모두 수정해보겠습니다.

@echo off
D:\~~~\display.exe /device:1 /rotate:0
timeout 2
Powershell.exe -noprofile -executionpolicy bypass -file 1280_960.ps1
Powershell.exe -noprofile -executionpolicy bypass -file DPI_125.ps1

이렇게 하면 가로모드로 한 후(이미 가로면 무시)

해상도를 바꾸는 ps1을 실행한 후 곧바로 배율을 바꾸는 ps1도 실행합니다.

(회전이 완료되어야 가로모드에 맞는 해상도를 선택할 수 있으므로, 2초 기다리는 부분 있음)

원하시는 대로 bat을 작성하시길 바랍니다 :D

Sample.zip

0.00MB

(위의 파일들이 모두 압축되어 있습니다.)

이미지로 보는 Git 개념서

현록 — Wed, 22 Dec 2021 17:24:14 +0900

https://blackdeery.github.io/guide/git/

이미지로 보는 Git 개념서 - 현록

blackdeery.github.io

목차의 편의성을 위해 Tistory가 아닌 웹페이지에 작성하였습니다.

댓글은 이 아래로 달아주시면 됩니다.

Git을 반드시 CLI로 할 필요는 없다고 생각합니다.

GUI에서는 Sourcetree를 비롯한 좋은 툴이 있습니다.(저는 Sourcetree를 애용합니다)

Visual Studio, intelliJ 등에도 기능이 내장되어 있습니다.

CLI든 GUI든 개념만 잡히면 사용하는 것은 어렵지 않은데,

개념이 안 잡혀있으면, 현재 상황도 파악하기 어렵고,

내가 원하는 대로 되려면 어떤 작업을 해야하는지도 모호해집니다.

개념만 잘 잡았으면

작업은 문서를 찾아보든 검색을 하든 해서 잘 해낼 수 있을겁니다.

아래는 다른 분들의 외부 링크입니다.

https://backlog.com/git-tutorial/kr/contents/

누구나 쉽게 이해할 수 있는 Git 입문~버전 관리를 완벽하게 이용해보자~ | Backlog

누구나 쉽게 알 수 있는 Git에 입문하신 것을 환영합니다. Git을 사용해 버전 관리를 할 수 있도록 함께 공부해봅시다!

backlog.com

https://git-scm.com/doc

Git - Documentation

Documentation Reference The official and comprehensive man pages that are included in the Git package itself. Quick reference guides: GitHub Cheat Sheet | Visual Git Cheat Sheet Book Videos Length: 05:59 Length: 04:26 What is Git? Length: 08:15 Length: 05:

git-scm.com

Tistory Replace

현록 — Mon, 17 May 2021 23:10:53 +0900

티스토리 에디터에서

html로 편집해도 기본모드로 전환하면 html을 멋대로 박살내버리는걸 이겨버리기 위해

다시 강제로 치환하는 프로그램을 만듦.

https://blackdeery.github.io/tistory_replace/

Tistory Replace - 현록

blackdeery.github.io

처음부터 워드프레스로 해야했나...

니가 이기나 내가 이기나 가보자...

그래도 언젠가 니가 이길 수 밖에 없게 된다면, 할 수 있는건 다 했으니 그 땐 티스토리 버릴게.

지 멋대로 아작내고 통제도 안되는 애를 누가 쓰겠어...

마트휴일 AI 스피커가 말해주기 (Google Action)

현록 — Tue, 11 May 2021 02:04:19 +0900

구글 홈 미니에 음성으로 마트휴일을 물어볼 수 있도록 Google Action 프로젝트를 생성했다.

(배포하지 않고 가족만 테스터로 초대하여 사용 중이다.)

모바일 앱에서는 음성으로 물으면 텍스트와 음성으로 답해주고, 타이핑하면 그냥 텍스트로만 보여준다.

아마 디스플레이가 있는 구글 네스트 허브 역시 마찬가지일 듯 싶다.

젊은 세대는 그냥 바로 모바일 지도 앱을 열어서 해당 점포가 휴점인지 보겠지만,

어머니는 좀 느리고 불편해하셔서 말로 편하게 알 수 있도록 하기 위해 만들었다.

그래서 부모님 댁 근처의 백화점 및 마트만 구성했으며,

"홈플러스 울산남구점"처럼 묻는 것이 아니라,

그냥 "홈플러스" 정도의 최소한의 질문으로 동작하도록 하였다.

그래서 노브랜드는 엄청 지점이 많아졌는데, 어머니가 잘 다니시지 않는 관계로 우선 저대로 두었다.

(나중에 여쭤보고 다니신다면 다니시는 곳만 나오게 하든가 해야겠다.)

홈서버에서 매일 오전 11시에

백화점이나 마트의 API를 이용하거나, 웹 크롤러로 휴점일 내용을 긁어서 저장해두는 것을 cron으로 하고 있고,

Google Action Project에서는 특정 브랜드를 물을 때, 홈서버의 HTTPS REST Controller를 통해 정보를 가져와 말해준다.

Actions on Google Project

- Platform: All Google Assistant Device(Speaker, Text)

- Framework: Spring Boot 2.4.5

- Language: Java 1.8

- Web Crawler: Selenium

- IDE: IntelliJ IDEA

물론 REST API로 만들었기 때문에 가족용 모바일 웹페이지에도 사용 중

iOS 단축어, Siri로 Smartthings 기기 제어 (REST API)

현록 — Sun, 9 May 2021 19:18:03 +0900

- 본 포스트에서는 Smartthings 기기를 iOS/iPadOS의 단축어 또는 Siri로 제어하는 옵션을 추가하는 내용에 대해 다룹니다.

- Google Assistant를 이용한 구글홈 기기 제어와는 달리, 잠금 상태 및 AppleWatch 및 HomePod에서도 사용 가능합니다.

- 응용으로 자동화(Rule)를 제어할 수도 있으나, 여기에 대해서 다루진 않겠습니다.

https://account.smartthings.com/tokens

먼저, 위의 링크를 클릭하여 Smartthings를 사용하고 있는 계정으로 로그인합니다.

새 토큰 만들기를 누릅니다.

토큰 이름을 원하는대로 정하고, 권한을 설정합니다.

귀찮으면 다 체크하셔도 되지만, 보안을 걱정하시면 필요한 것만 체크합니다.

모든 디바이스 표시, 모든 디바이스 제어는 이후 과정에 필요합니다.

보안 권장사항으로는,

모든 디바이스 표시(l:devices)만을 갖는 "조회용 토큰"을 하나 발급하고,

모든 디바이스 제어(x:devices:*)만을 갖는 "제어용 토큰"을 하나 발급합니다.

이제 발급된 토큰을 복사합니다.

이 토큰을 잊는다면 발급했던 토큰을 삭제하고 다시 발급하면 됩니다.

이제 이 토큰을 갖고 Smartthings의 REST API를 사용할겁니다.

https://developer.smartthings.com/docs/api/public/

본 포스트에서 다루는 내용 외에도 많은 기능을 제공하고 있으니, 살펴보시는 것도 좋습니다.

이제 "조회용 토큰"(모든 디바이스 표시(l:devices))을

https://blackdeery.github.io/st_helper/

에 들어가서 붙여넣은 후, 장치 조회를 누릅니다.

우리가 필요한건 deviceId입니다.

잘 메모해둡니다.

"제어용 토큰"(모든 디바이스 제어(x:devices:*))과 deviceId들을 iOS 단축어를 만들 때 사용해야합니다.

- macOS이고 메모에서 서로 iCloud 연동을 사용한다면, 메모앱에 붙여넣어주면 iOS의 메모앱에서 복사하기 편합니다.

- macOS이고 서로 HandOff를 사용한다면, mac에서 복사한 항목을 그대로 iOS에서 붙여넣기 가능합니다.

- iOS라면 바로 붙여넣어 사용할 수 있도록 합니다.

- 그 외 OS라면 https://www.icloud.com/로 접속하여, 메모에 붙여넣은 후, iOS에 메모앱에서 복사합니다. (메모앱에서 iCloud 사용 필요)

그리고 장치 요소들을 볼 수 있는데,

switch를 갖고 있으면 on/off가 가능하고,

thermostatHeatingSetpoint를 갖고 있으면 난방기의 온도 설정이 가능하고,

fanSpeed를 갖고 있으면 풍속을 1~3단계 조절이 가능하고, ...

이런 기능들을 하나 이상 갖고있습니다.

해당 명령을 내리기 위한 자세한 양식은

접은글로 짧막하게 알려드리고 넘어가겠습니다.

(본 포스트에서는 일부 capability만 제공합니다.)

curl -X "GET" "https://api.smartthings.com/v1/capabilities/이름/버전" -H "Authorization: Bearer 토큰" -H "Content-Type: application/json; charset=utf-8"

위 명령으로 capability의 조회가 가능합니다.

아래 예시처럼 필요한 항목을 채워넣어 줍니다.

curl -X "GET" "https://api.smartthings.com/v1/capabilities/thermostatHeatingSetpoint/1" -H "Authorization: Bearer ********-****-****-****-************" -H "Content-Type: application/json; charset=utf-8"

이를 통해 얻은 상세정보를 갖고,

아래 링크의 문서 양식과 대조하여 원하는 항목을 채워넣어 JSON을 형성하면 됩니다.

https://smartthings.developer.samsung.com/docs/devices/smartthings-schema/smartthings-schema-reference.html#Command

iPhone/iPad에서 아래의 링크들로 접속하여, 단축어 견본을 내려받습니다.

switch를 갖는 기기의 켜기(on)

https://www.icloud.com/shortcuts/24431bc923b948999c4d8159d5ddb3ec

단축어를 가져올 때, deviceId와 토큰을 입력해주시면 양식이 완성됩니다.

(텍스트 on 대신 off로 수정 가능.)

switch를 갖는 기기의 끄기(off)

https://www.icloud.com/shortcuts/201fad930fb94ffda6a3eddf2e9453db

단축어를 가져올 때, deviceId와 토큰을 입력해주시면 양식이 완성됩니다.

(텍스트 off 대신 on으로 수정 가능.)

thermostatMode를 갖는 기기의 난방모드(heat)

https://www.icloud.com/shortcuts/ef6db3ba8cc74a27ba5acecb4d3992ec

단축어를 가져올 때, deviceId와 토큰을 입력해주시면 양식이 완성됩니다.

(텍스트 heat 대신 다른 모드 수정 가능. 하지만 기기에서 모든 동작을 지원하지 않을 수도 있음.)

thermostatMode를 갖는 기기의 외출모드(eco)

https://www.icloud.com/shortcuts/2c6a71b15bf94f05ad7dbcc5fb62a0b3

단축어를 가져올 때, deviceId와 토큰을 입력해주시면 양식이 완성됩니다.

(텍스트 eco 대신 다른 모드 수정 가능. 하지만 기기에서 모든 동작을 지원하지 않을 수도 있음.)

thermostatHeatingSetpoint를 갖는 기기의 목표 온도 설정(setHeatingSetpoint)

https://www.icloud.com/shortcuts/01d39c1b63ba4c7e91f871f76d0075d3

단축어를 가져올 때, deviceId와 토큰과 설정온도를 입력해주시면 양식이 완성됩니다.

fanSpeed를 갖는 기기의 풍속 설정(setFanSpeed) - 강풍(3)

https://www.icloud.com/shortcuts/cd8dbbac078d4cf2a99ae8c5485d4e6e

단축어를 가져올 때, deviceId와 토큰을 입력해주시면 양식이 완성됩니다.

(숫자 3 대신 1~3의 숫자로 수정하여 풍속 수정 가능.)

valve를 갖는 기기의 밸브 잠그기(close)

https://www.icloud.com/shortcuts/dc1d54866f014a82be96f4b405ff43b9

단축어를 가져올 때, deviceId와 토큰을 입력해주시면 양식이 완성됩니다.

(텍스트 close 대신 open으로 수정 가능. 하지만 기기에서 모든 동작을 지원하지 않을 수도 있음.)

elevatorCall을 갖는 기기의 엘리베이터 호출(call)

https://www.icloud.com/shortcuts/5bc64ca53a8a4daca04f660dc5e6ac48

단축어를 가져올 때, deviceId와 토큰을 입력해주시면 양식이 완성됩니다.

이제 내려받은 단축어를 수정할겁니다.

(Siri용 문구 설정 및 추가 옵션)

오른쪽 위의 을 눌러, 세부 사항 수정으로 넘어갑니다.

제목을 수정합니다.

해당 내용은 Siri야, [제목]으로 불릴 수 있도록 해줍니다.

단, "거실 전등 켜줘" 같은 보편적인 내용은 Siri가 애플홈을 우선적으로 인식하려고 하기 때문에,

"라이언 전등 켜줘" 같이 앞에 특정한 단어들을 고려해보시기 바랍니다.

- 홈 화면에 앱 버튼처럼 단축 버튼을 만드시려면 "홈 화면에 추가"를 눌러서 추가하시면 됩니다.

- Apple Watch의 단축어에서 목록에 뜨게 하려면, Apple Watch에서 보기를 켜줍니다.

iOS 단축어, Siri로 구글홈 기기 제어 (Google Assistant)

현록 — Sun, 9 May 2021 13:40:29 +0900

- 본 포스트에서는 구글홈 기기를 iOS/iPadOS의 단축어 또는 Siri로 제어하는 옵션을 추가하는 내용에 대해 다룹니다.

- App Store에서 Google의 Assistant 앱을 다운받아, 직접 특정 문구를 전달시켜서 제어합니다.

- 이런 이유로 iPhone/iPad의 잠금이 해제된 상태에서만 가능합니다.

- 같은 이유로 AppleWatch의 단축어에서는 눌러도 실행할 수 없습니다.

　(미러링된 iPhone에서 앱을 실행시켜야 하는 구조이나, 워치에서는 그럴 수 없기 때문)

- 해당 IoT 기기가 Samsung의 Smartthings에 연동가능하다면,

　아래의 링크를 참조하여, Smartthings용으로 생성해두면 잠금상태이건 워치에서건 가능합니다.

　[IoT] - iOS 단축어, Siri로 Smartthings 기기 제어 (REST API)

　(Smartthings는 REST API를 지원하지만, Google은 그렇지 않음)

　(Smartthings에서 보이스 어시스턴트로 Google Assistant를 추가하면, Google Home에서도 Smartthings 기기가 나타남)

먼저 App Store에서 Google의 Assistant 앱을 내려받습니다.

assistant로 검색하시면 됩니다.

https://www.icloud.com/shortcuts/d83088bffead47e2970eac43f0b1af08

iPhone/iPad에서 위의 링크로 접속하여, 단축어 견본을 내려받습니다.

내려받을 때 어떤 문구를 Google Assistant에 보내어 제어할지 묻습니다.

입력해주시면 되고,

입력하지 않고 넘어갔어도 수정 가능합니다.

단축어의 구성은 간단합니다.

question에 Google Assistant에게 전달할 문구가 들어갑니다.

이제 오른쪽 위의 을 눌러, 세부 사항 수정으로 넘어갑니다.

google_assistant-ex를 수정합니다.

해당 내용은 Siri야, [제목]으로 불릴 수 있도록 해줍니다.

단, "거실 전등 켜줘" 같은 보편적인 내용은 Siri가 애플홈을 우선적으로 인식하려고 하기 때문에,

"라이언 전등 켜줘" 같이 앞에 특정한 단어들을 고려해보시기 바랍니다.

- 홈 화면에 앱 버튼처럼 단축 버튼을 만드시려면 "홈 화면에 추가"를 눌러서 추가하시면 됩니다.

- 맨 위에서 언급했듯이, 어차피 Apple Watch에서는 사용할 수 없습니다.

DuckDNS, Let's Encrypt

현록 — Tue, 4 May 2021 16:31:04 +0900

[DuckDNS 5분마다 자동갱신]

https://www.duckdns.org/

% crontab -e

*/5 * * * * sh파일경로 >/dev/null 2>&1

sh파일내용

echo url="https://www.duckdns.org/update?domains=도메인앞부분&token=토큰&ip=" | curl -k -o ~/duckdns/duck.log -K -

로그파일 내용은, 갱신에 성공하면 OK, 실패하면 KO.

(요청이 잦아서인지 가끔 502 Bad Gateway가 뜨기도 하는데,

DuckDNS의 install부분에서 5분마다를 지침으로 하고 있어서 그대로 따름)

[Let's Encrypt]

% brew install certbot

% sudo certbot certonly -a standalone -d 도메인

매월 1일 새벽3시 갱신요청 및 pkcs12 인증서 생성

% sudo crontab -e

0 18 1 * * sh파일경로 >/dev/null 2>&1

sh파일내용

/usr/local/bin/certbot renew

/usr/bin/openssl pkcs12 -export -in /etc/letsencrypt/live/도메인/fullchain.pem -inkey /etc/letsencrypt/live/도메인/privkey.pem -out 파일명.p12 -name bootalias -CAfile /etc/letsencrypt/live/도메인/chain.pem -caname root -passin pass:비밀번호 -passout pass:비밀번호

[Lv3] 기둥과 보 설치

현록 — Thu, 22 Apr 2021 17:04:45 +0900

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

코딩테스트 연습 - 기둥과 보 설치

5 [[1,0,0,1],[1,1,1,1],[2,1,0,1],[2,2,1,1],[5,0,0,1],[5,1,0,1],[4,2,1,1],[3,2,1,1]] [[1,0,0],[1,1,1],[2,1,0],[2,2,1],[3,2,1],[4,2,1],[5,0,0],[5,1,0]] 5 [[0,0,0,1],[2,0,0,1],[4,0,0,1],[0,1,1,1],[1,1,1,1],[2,1,1,1],[3,1,1,1],[2,0,0,0],[1,1,1,0],[2,2,0,1]] [[

programmers.co.kr

문제 설명

빙하가 깨지면서 스노우타운에 떠내려 온 "죠르디"는 인생 2막을 위해 주택 건축사업에 뛰어들기로 결심하였습니다.

"죠르디"는 기둥과 보를 이용하여 벽면 구조물을 자동으로 세우는 로봇을 개발할 계획인데,

그에 앞서 로봇의 동작을 시뮬레이션 할 수 있는 프로그램을 만들고 있습니다.

프로그램은 2차원 가상 벽면에 기둥과 보를 이용한 구조물을 설치할 수 있는데,

기둥과 보는 길이가 1인 선분으로 표현되며 다음과 같은 규칙을 가지고 있습니다.

기둥은 바닥 위에 있거나 보의 한쪽 끝 부분 위에 있거나, 또는 다른 기둥 위에 있어야 합니다.
보는 한쪽 끝 부분이 기둥 위에 있거나, 또는 양쪽 끝 부분이 다른 보와 동시에 연결되어 있어야 합니다.

단, 바닥은 벽면의 맨 아래 지면을 말합니다.

2차원 벽면은 n x n 크기 정사각 격자 형태이며, 각 격자는 1 x 1 크기입니다. 맨 처음 벽면은 비어있는 상태입니다.

기둥과 보는 격자선의 교차점에 걸치지 않고, 격자 칸의 각 변에 정확히 일치하도록 설치할 수 있습니다.

다음은 기둥과 보를 설치해 구조물을 만든 예시입니다.

예를 들어, 위 그림은 다음 순서에 따라 구조물을 만들었습니다.

(1, 0)에서 위쪽으로 기둥을 하나 설치 후, (1, 1)에서 오른쪽으로 보를 하나 만듭니다.
(2, 1)에서 위쪽으로 기둥을 하나 설치 후, (2, 2)에서 오른쪽으로 보를 하나 만듭니다.
(5, 0)에서 위쪽으로 기둥을 하나 설치 후, (5, 1)에서 위쪽으로 기둥을 하나 더 설치합니다.
(4, 2)에서 오른쪽으로 보를 설치 후, (3, 2)에서 오른쪽으로 보를 설치합니다.

만약 (4, 2)에서 오른쪽으로 보를 먼저 설치하지 않고,

(3, 2)에서 오른쪽으로 보를 설치하려 한다면 2번 규칙에 맞지 않으므로 설치가 되지 않습니다.

기둥과 보를 삭제하는 기능도 있는데 기둥과 보를 삭제한 후에 남은 기둥과 보들 또한 위 규칙을 만족해야 합니다.

만약, 작업을 수행한 결과가 조건을 만족하지 않는다면 해당 작업은 무시됩니다.

벽면의 크기 n, 기둥과 보를 설치하거나 삭제하는 작업이 순서대로 담긴 2차원 배열 build_frame이 매개변수로 주어질 때,

모든 명령어를 수행한 후 구조물의 상태를 return 하도록 solution 함수를 완성해주세요.

제한사항

n은 5 이상 100 이하인 자연수입니다.
build_frame의 세로(행) 길이는 1 이상 1,000 이하입니다.
build_frame의 가로(열) 길이는 4입니다.
build_frame의 원소는 [x, y, a, b]형태입니다.
- x, y는 기둥, 보를 설치 또는 삭제할 교차점의 좌표이며, [가로 좌표, 세로 좌표] 형태입니다.
- a는 설치 또는 삭제할 구조물의 종류를 나타내며, 0은 기둥, 1은 보를 나타냅니다.
- b는 구조물을 설치할 지, 혹은 삭제할 지를 나타내며 0은 삭제, 1은 설치를 나타냅니다.
- 벽면을 벗어나게 기둥, 보를 설치하는 경우는 없습니다.
- 바닥에 보를 설치 하는 경우는 없습니다.
구조물은 교차점 좌표를 기준으로 보는 오른쪽, 기둥은 위쪽 방향으로 설치 또는 삭제합니다.
구조물이 겹치도록 설치하는 경우와, 없는 구조물을 삭제하는 경우는 입력으로 주어지지 않습니다.
최종 구조물의 상태는 아래 규칙에 맞춰 return 해주세요.
- return 하는 배열은 가로(열) 길이가 3인 2차원 배열로, 각 구조물의 좌표를 담고있어야 합니다.
- return 하는 배열의 원소는 [x, y, a] 형식입니다.
- x, y는 기둥, 보의 교차점 좌표이며, [가로 좌표, 세로 좌표] 형태입니다.
- 기둥, 보는 교차점 좌표를 기준으로 오른쪽, 또는 위쪽 방향으로 설치되어 있음을 나타냅니다.
- a는 구조물의 종류를 나타내며, 0은 기둥, 1은 보를 나타냅니다.
- return 하는 배열은 x좌표 기준으로 오름차순 정렬하며, x좌표가 같을 경우 y좌표 기준으로 오름차순 정렬해주세요.
- x, y좌표가 모두 같은 경우 기둥이 보보다 앞에 오면 됩니다.

입출력 예

n	build_frame	result
5	[[1,0,0,1],[1,1,1,1],[2,1,0,1],[2,2,1,1],[5,0,0,1],[5,1,0,1],[4,2,1,1],[3,2,1,1]]	[[1,0,0],[1,1,1],[2,1,0],[2,2,1],[3,2,1],[4,2,1],[5,0,0],[5,1,0]]
5	[[0,0,0,1],[2,0,0,1],[4,0,0,1],[0,1,1,1],[1,1,1,1],[2,1,1,1],[3,1,1,1],[2,0,0,0],[1,1,1,0],[2,2,0,1]]	[[0,0,0],[0,1,1],[1,1,1],[2,1,1],[3,1,1],[4,0,0]]

입출력 예에 대한 설명

입출력 예 #1

문제의 예시와 같습니다.

입출력 예 #2

여덟 번째 작업을 수행 후 아래와 같은 구조물 만들어집니다.

아홉 번째 작업의 경우, (1, 1)에서 오른쪽에 있는 보를 삭제하면 (2, 1)에서 오른쪽에 있는 보는 조건을 만족하지 않으므로 무시됩니다.

열 번째 작업의 경우, (2, 2)에서 위쪽 방향으로 기둥을 세울 경우 조건을 만족하지 않으므로 무시됩니다.

import java.util.Arrays;
import java.util.Comparator;

class Solution {
    public int[][] solution(int n, int[][] build_frame) {
        boolean printLog = false;
        ++n;
        int[][] map = new int[n][n];
        int count = 0;
        for (int i = 0; i < build_frame.length; ++i) {
            int x = build_frame[i][0];
            int y = build_frame[i][1];
            boolean isPillar = build_frame[i][2] == 0;
            boolean isCreate = build_frame[i][3] == 1;
            if (printLog) System.out.print(String.format("%d, %d에 %s을 %s", x, y, isPillar ? "기둥" : "보", isCreate ? "설치" : "삭제"));
            if (isCreate == false) {
                if (isPillar) {
                    if (map[x][y] % 2 != 1) {
                        if (printLog) System.out.println("- 지울 기둥이 없어서 삭제 실패.");
                        continue;
                    }
                    if (y + 1 < n) {
                        boolean able = true;
                        if (map[x][y + 1] % 2 == 1) {
                            able = false;
                            if (printLog) System.out.print("- [지울 기둥 위에 기둥이 있는데,]");
                            if (x - 1 >= 0 && map[x - 1][y + 1] >= 2) {
                                if (printLog) System.out.print("+(대신 지울 기둥 왼편 보가 있어서 지탱 가능하고)");
                                able = true;
                            }
                            if (able == false && map[x][y + 1] >= 2) {
                                if (printLog) System.out.print("+(대신 지울 기둥 오른편 보가 있어서 지탱 가능하고)");
                                able = true;
                            }
                        }
                        if (able == true && map[x][y + 1] >= 2) {
                            able = false;
                            if (printLog) System.out.print("- [지울 기둥 위에 오른쪽으로 보가 있는데,]");
                            if (x + 1 < n && map[x + 1][y] % 2 == 1) {
                                if (printLog) System.out.print("+(이 오른쪽 보는 바로 오른편 아래에 기둥이 있어서)");
                                able = true;
                            }
                            if (able == false && x - 1 >= 0 && map[x - 1][y + 1] >= 2 && x + 1 < n && map[x + 1][y + 1] >= 2) {
                                if (printLog) System.out.print("+(이 오른쪽 보는 양쪽에 다른 보가 있어서)");
                                able = true;
                            }
                        }
                        if (able == true && x - 1 >= 0 && map[x - 1][y + 1] >= 2) {
                            able = false;
                            if (printLog) System.out.print("- [지울 기둥 위에 왼쪽부터 보가 있는데,]");
                            if (map[x - 1][y] % 2 == 1) {
                                if (printLog) System.out.print("+(이 왼쪽 보는 바로 아래에 기둥이 있어서)");
                                able = true;
                            }
                            if (able == false && x - 2 >= 0 && map[x - 2][y + 1] >= 2 && map[x][y + 1] >= 2) {
                                if (printLog) System.out.print("+(이 왼쪽 보는 양쪽에 다른 보가 있어서)");
                                able = true;
                            }
                        }
                        if (able == true) {
                            if (printLog) System.out.println("- 기둥 삭제 성공.");
                            map[x][y] -= 1;
                            --count;
                        } else {
                            if (printLog) System.out.println("- 기둥 삭제 실패.");
                            continue;
                        }
                    } else {
                        if (printLog) System.out.println("- 기둥 삭제 성공.");
                        map[x][y] -= 1;
                        --count;
                    }
                } else {
                    if (map[x][y] < 2) {
                        if (printLog) System.out.println("- 지울 보가 없어서 삭제 실패.");
                        continue;
                    }
                    boolean able = true;
                    if (map[x][y] % 2 == 1) {
                        able = false;
                        if (printLog) System.out.print("- [지울 보 위에 기둥이 있는데,]");
                        if (x - 1 >= 0 && map[x - 1][y] >= 2) {
                            if (printLog) System.out.print("+(지울 보 왼편엔 다른 보가 있고)");
                            able = true;
                        }
                        if (able == false && map[x][y - 1] % 2 == 1) {
                            if (printLog) System.out.print("+(지울 보 아래엔 기둥도 있고)");
                            able = true;
                        }
                    }
                    if (able == true && x + 1 < n && map[x + 1][y] % 2 == 1) {
                        able = false;
                        if (printLog) System.out.print("- [지울 보 오른편 위에 기둥이 있는데,]");
                        if (map[x + 1][y] >= 2) {
                            if (printLog) System.out.print("+(그 기둥 아래엔 다른 보가 있고)");
                            able = true;
                        }
                        if (able == false && map[x + 1][y - 1] % 2 == 1) {
                            if (printLog) System.out.print("+(그 기둥 아래엔 기둥도 있고)");
                            able = true;
                        }
                    }
                    if (able == true && x - 1 >= 0 && map[x - 1][y] >= 2) {
                        able = false;
                        if (printLog) System.out.print("- [지울 보 왼편에 다른 보가 있는데,]");
                        if (map[x][y - 1] % 2 == 1) {
                            if (printLog) System.out.print("+(지울 보 아래의 기둥이 왼편 보를 받칠 수 있고)");
                            able = true;
                        }
                        if (able == false && map[x - 1][y - 1] % 2 == 1) {
                            if (printLog) System.out.print("+(왼편 보 아래의 기둥이 왼편 보를 받칠 수 있고)");
                            able = true;
                        }
                    }
                    if (able == true && x + 1 < n && map[x + 1][y] >= 2) {
                        able = false;
                        if (printLog) System.out.print("- [지울 보 오른편에 다른 보가 있는데,]");
                        if (map[x + 1][y - 1] % 2 == 1) {
                            if (printLog) System.out.print("+(오른편 보 아래의 기둥이 오른편 보를 받칠 수 있고)");
                            able = true;
                        }
                        if (able == false && x + 2 < n && map[x + 2][y - 1] % 2 == 1) {
                            if (printLog) System.out.print("+(오른편 보 보다 오른쪽 아래의 기둥이 오른편 보를 받칠 수 있고)");
                            able = true;
                        }
                    }
                    if (able == true) {
                        if (printLog) System.out.println("- 보 삭제 성공.");
                        map[x][y] -= 2;
                        --count;
                    } else {
                        if (printLog) System.out.println("- 보 삭제 실패.");
                        continue;
                    }
                }
            } else {
                if (isPillar) {
                    if (map[x][y] % 2 == 1) {
                        if (printLog) System.out.println("- 이미 기둥이 있어서 짓기 실패.");
                        continue;
                    }
                    if (y == 0) {
                        if (printLog) System.out.println("- 기둥 짓기 성공.");
                        map[x][y] += 1;
                        ++count;
                    } else {
                        if ((map[x][y - 1] % 2 == 1) || (map[x][y] >= 2) || (x - 1 >= 0 && map[x - 1][y] >= 2)) {
                            if (printLog) System.out.println("- 기둥 짓기 성공.");
                            map[x][y] += 1;
                            ++count;
                        } else {
                            if (printLog) System.out.println("- 조건미달로 기둥 짓기 실패.");
                        }
                    }
                } else {
                    if (map[x][y] >= 2) {
                        if (printLog) System.out.println("- 이미 보가 있어서 짓기 실패.");
                        continue;
                    }
                    if ((map[x][y - 1] % 2 == 1) || (x + 1 < n && map[x + 1][y - 1] % 2 == 1) || ((x + 1 < n && map[x + 1][y] >= 2) && (x - 1 >= 0 && map[x - 1][y] >= 2))) {
                        if (printLog) System.out.println("- 보 짓기 성공.");
                        map[x][y] += 2;
                        ++count;
                    } else {
                        if (printLog) System.out.println("- 조건미달로 보 짓기 실패.");
                    }
                }
            }
        }
        int[][] answer = new int[count][];
        int index = 0;
        for (int x = 0; x < n; ++x) {
            for (int y = 0; y < n; ++y) {
                if (map[x][y] % 2 == 1) {
                    answer[index++] = new int[] { x, y, 0 };
                }
                if (map[x][y] >= 2) {
                    answer[index++] = new int[] { x, y, 1 };
                }
            }
        }
        Comparator<int[]> comparator = new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if (o1[0] == o2[0]) {
                    if (o1[1] == o2[1]) {
                        return o1[2] - o2[2];
                    } else {
                        return o1[1] - o2[1];
                    }
                } else {
                    return o1[0] - o2[0];
                }
            }
        };
        Arrays.sort(answer, comparator);
        return answer;
    }
}

[Lv3] 불량 사용자

현록 — Thu, 22 Apr 2021 01:01:50 +0900

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

코딩테스트 연습 - 불량 사용자

개발팀 내에서 이벤트 개발을 담당하고 있는 "무지"는 최근 진행된 카카오이모티콘 이벤트에 비정상적인 방법으로 당첨을 시도한 응모자들을 발견하였습니다. 이런 응모자들을 따로 모아 불량

programmers.co.kr

문제 설명

개발팀 내에서 이벤트 개발을 담당하고 있는 "무지"는

최근 진행된 카카오이모티콘 이벤트에 비정상적인 방법으로 당첨을 시도한 응모자들을 발견하였습니다.

이런 응모자들을 따로 모아 불량 사용자라는 이름으로 목록을 만들어서

당첨 처리 시 제외하도록 이벤트 당첨자 담당자인 "프로도" 에게 전달하려고 합니다.

이 때 개인정보 보호을 위해 사용자 아이디 중 일부 문자를 '*' 문자로 가려서 전달했습니다.

가리고자 하는 문자 하나에 '*' 문자 하나를 사용하였고 아이디 당 최소 하나 이상의 '*' 문자를 사용하였습니다.

"무지"와 "프로도"는 불량 사용자 목록에 매핑된 응모자 아이디를 제재 아이디 라고 부르기로 하였습니다.

예를 들어, 이벤트에 응모한 전체 사용자 아이디 목록이 다음과 같다면

응모자 아이디

frodo

fradi

crodo

abc123

frodoc

다음과 같이 불량 사용자 아이디 목록이 전달된 경우,

불량 사용자

fr*d*

abc1**

불량 사용자에 매핑되어 당첨에서 제외되어야 야 할 제재 아이디 목록은 다음과 같이 두 가지 경우가 있을 수 있습니다.

제재 아이디

frodo

abc123

제재 아이디

fradi

abc123

이벤트 응모자 아이디 목록이 담긴 배열 user_id와 불량 사용자 아이디 목록이 담긴 배열 banned_id가 매개변수로 주어질 때,

당첨에서 제외되어야 할 제재 아이디 목록은 몇가지 경우의 수가 가능한 지 return 하도록 solution 함수를 완성해주세요.

[제한사항]

user_id 배열의 크기는 1 이상 8 이하입니다.
user_id 배열 각 원소들의 값은 길이가 1 이상 8 이하인 문자열입니다.
- 응모한 사용자 아이디들은 서로 중복되지 않습니다.
- 응모한 사용자 아이디는 알파벳 소문자와 숫자로만으로 구성되어 있습니다.
banned_id 배열의 크기는 1 이상 user_id 배열의 크기 이하입니다.
banned_id 배열 각 원소들의 값은 길이가 1 이상 8 이하인 문자열입니다.
- 불량 사용자 아이디는 알파벳 소문자와 숫자, 가리기 위한 문자 '*' 로만 이루어져 있습니다.
- 불량 사용자 아이디는 '*' 문자를 하나 이상 포함하고 있습니다.
- 불량 사용자 아이디 하나는 응모자 아이디 중 하나에 해당하고 같은 응모자 아이디가 중복해서 제재 아이디 목록에 들어가는 경우는 없습니다.
제재 아이디 목록들을 구했을 때 아이디들이 나열된 순서와 관계없이 아이디 목록의 내용이 동일하다면 같은 것으로 처리하여 하나로 세면 됩니다.

[입출력 예]

user_id	banned_id	result
["frodo", "fradi", "crodo", "abc123", "frodoc"]	["frd", "abc1**"]	2
["frodo", "fradi", "crodo", "abc123", "frodoc"]	["rodo", "rodo", "******"]	2
["frodo", "fradi", "crodo", "abc123", "frodoc"]	["frd", "rodo", "***", "****"]	3

입출력 예에 대한 설명입출력 예 #1

문제 설명과 같습니다.

입출력 예 #2

다음과 같이 두 가지 경우가 있습니다.

제재 아이디

frodo

crodo

abc123

제재 아이디

frodo

crodo

frodoc

입출력 예 #3

다음과 같이 세 가지 경우가 있습니다.

제재 아이디

frodo

crodo

abc123

frodoc

제재 아이디

fradi

crodo

abc123

frodoc

제재 아이디

fradi

frodo

abc123

frodoc

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Solution {
    public void calc(HashSet<Integer> set, ArrayList<Integer>[] variations, int[] selected, int index) {
        if (index >= variations.length) {
            Arrays.sort(selected);
            int hash = 0;
            for (int i = 0; i < selected.length; ++i) {
                hash += selected[i] * Math.pow(10, i);
            }
            set.add(hash);
            return;
        }
        for (Integer able : variations[index]) {
            boolean isAble = true;
            for (int i = 0; i < index; ++i) {
                if (able == selected[i]) {
                    isAble = false;
                    break;
                }
            }
            if (isAble == true) {
                int[] newSelected = selected.clone();
                newSelected[index] = able;
                calc(set, variations, newSelected, index + 1);
            }
        }
    }

    public int solution(String[] user_id, String[] banned_id) {
        ArrayList<Integer>[] ables = new ArrayList[banned_id.length];
        for (int i = 0; i < banned_id.length; ++i) {
            ables[i] = new ArrayList<>(user_id.length);
            String regex = banned_id[i].replaceAll("\\*", "\\.");
            regex = String.format("^%s$", regex);
            for (int j = 0; j < user_id.length; ++j) {
                Matcher matcher = Pattern.compile(regex).matcher(user_id[j]);
                if (matcher.find()) {
                    ables[i].add(j);
                }
            }
        }
        HashSet<Integer> alreadyDone = new HashSet<>(ables.length);
        while (true) {
            boolean isAllDone = true;
            for (int i = 0; i < ables.length; ++i) {
                if (ables[i] != null && ables[i].size() == 1) {
                    isAllDone = false;
                    alreadyDone.add(i);
                    for (int j = 0; j < ables.length; ++j) {
                        if (j == i) {
                            continue;
                        }
                        if (ables[j] != null) {
                            ables[j].remove(Integer.valueOf(ables[i].get(0)));
                        }
                    }
                    ables[i] = null;
                }
            }
            for (int i = 0; i < ables.length; ++i) {
                if (ables[i] != null) {
                    ArrayList<Integer> sames = new ArrayList<>(ables[i].size());
                    sames.add(i);
                    for (int j = 0; j < ables.length; ++j) {
                        if (j == i) {
                            continue;
                        }
                        if (ables[j] != null && ables[j].size() == ables[i].size() && ables[j].containsAll(ables[i])) {
                            sames.add(j);
                        }
                    }
                    if (sames.size() == ables[i].size()) {
                        isAllDone = false;
                        int[] willDel = ables[i].stream().mapToInt(Integer::intValue).toArray();
                        for (Integer index : sames) {
                            alreadyDone.add(index);
                            ables[index] = null;
                        }
                        for (int j = 0; j < ables.length; ++j) {
                            if (ables[j] != null) {
                                for (int k = 0; k < willDel.length; ++k) {
                                    ables[j].remove(Integer.valueOf(willDel[k]));
                                }
                            }
                        }
                    }
                }
            }
            if (isAllDone == true) {
                break;
            }
        }
        if (alreadyDone.size() == ables.length) {
            return 1;
        }
        ArrayList<Integer>[] variations = new ArrayList[ables.length - alreadyDone.size()];
        int index = 0;
        for (int i = 0; i < ables.length; ++i) {
            if (ables[i] != null) {
                variations[index++] = ables[i];
            }
        }
        HashSet<Integer> set = new HashSet<>();
        int[] selected = new int[variations.length];
        calc(set, variations, selected, 0);
        return set.size();
    }
}

[Lv3] 추석 트래픽

현록 — Wed, 21 Apr 2021 18:36:35 +0900

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

코딩테스트 연습 - [1차] 추석 트래픽

입력: [ "2016-09-15 20:59:57.421 0.351s", "2016-09-15 20:59:58.233 1.181s", "2016-09-15 20:59:58.299 0.8s", "2016-09-15 20:59:58.688 1.041s", "2016-09-15 20:59:59.591 1.412s", "2016-09-15 21:00:00.464 1.466s", "2016-09-15 21:00:00.741 1.581s", "2016-09-1

programmers.co.kr

문제 설명

추석 트래픽

이번 추석에도 시스템 장애가 없는 명절을 보내고 싶은 어피치는 서버를 증설해야 할지 고민이다.

장애 대비용 서버 증설 여부를 결정하기 위해

작년 추석 기간인 9월 15일 로그 데이터를 분석한 후 초당 최대 처리량을 계산해보기로 했다.

초당 최대 처리량은 요청의 응답 완료 여부에 관계없이

임의 시간부터 1초(=1,000밀리초)간 처리하는 요청의 최대 개수를 의미한다.

입력 형식

solution 함수에 전달되는 lines 배열은 N(1 ≦ N ≦ 2,000)개의 로그 문자열로 되어 있으며, 각 로그 문자열마다 요청에 대한 응답완료시간 S와 처리시간 T가 공백으로 구분되어 있다.
응답완료시간 S는 작년 추석인 2016년 9월 15일만 포함하여 고정 길이 2016-09-15 hh:mm:ss.sss 형식으로 되어 있다.
처리시간 T는 0.1s, 0.312s, 2s 와 같이 최대 소수점 셋째 자리까지 기록하며 뒤에는 초 단위를 의미하는 s로 끝난다.
예를 들어, 로그 문자열 2016-09-15 03:10:33.020 0.011s은 "2016년 9월 15일 오전 3시 10분 33.010초"부터 "2016년 9월 15일 오전 3시 10분 33.020초"까지 "0.011초" 동안 처리된 요청을 의미한다. (처리시간은 시작시간과 끝시간을 포함)
서버에는 타임아웃이 3초로 적용되어 있기 때문에 처리시간은 0.001 ≦ T ≦ 3.000이다.
lines 배열은 응답완료시간 S를 기준으로 오름차순 정렬되어 있다.

출력 형식

solution 함수에서는 로그 데이터 lines 배열에 대해 초당 최대 처리량을 리턴한다.

입출력 예제

예제1

입력: ["2016-09-15 01:00:04.001 2.0s",]
"2016-09-15 01:00:07.000 2s"
출력: 1

예제2

입력: ["2016-09-15 01:00:04.002 2.0s",]
"2016-09-15 01:00:07.000 2s"
출력: 2
설명: 처리시간은 시작시간과 끝시간을 포함하므로첫 번째 로그는 01:00:02.003 ~ 01:00:04.002에서 2초 동안 처리되었으며,따라서, 첫 번째 로그가 끝나는 시점과 두 번째 로그가 시작하는 시점의 구간인 01:00:04.002 ~ 01:00:05.001 1초 동안 최대 2개가 된다.
두 번째 로그는 01:00:05.001 ~ 01:00:07.000에서 2초 동안 처리된다.

예제3

입력: ["2016-09-15 20:59:57.421 0.351s","2016-09-15 20:59:58.299 0.8s","2016-09-15 20:59:59.591 1.412s","2016-09-15 21:00:00.741 1.581s","2016-09-15 21:00:00.966 0.381s",]
"2016-09-15 21:00:02.066 2.62s"
"2016-09-15 21:00:00.748 2.31s",
"2016-09-15 21:00:00.464 1.466s",
"2016-09-15 20:59:58.688 1.041s",
"2016-09-15 20:59:58.233 1.181s",
출력: 7
설명: 아래 타임라인 그림에서 빨간색으로 표시된 1초 각 구간의 처리량을 구해보면 (1)은 4개, (2)는 7개, (3)는 2개임을 알 수 있다. 따라서 초당 최대 처리량은 7이 되며, 동일한 최대 처리량을 갖는 1초 구간은 여러 개 존재할 수 있으므로 이 문제에서는 구간이 아닌 개수만 출력한다.

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Solution {
    public int[] timestampToNumbers(String timestamp) {
        int[] result = new int[2];
        int hour = (timestamp.charAt(11) - '0') * 10 + (timestamp.charAt(12) - '0');
        int min = (timestamp.charAt(14) - '0') * 10 + (timestamp.charAt(15) - '0');
        int millsec = (timestamp.charAt(17) - '0') * 10000 + (timestamp.charAt(18) - '0') * 1000 + (timestamp.charAt(20) - '0') * 100 + (timestamp.charAt(21) - '0') * 10  + (timestamp.charAt(22) - '0');
        Matcher matcher = Pattern.compile("(\\d+\\.\\d{1,3}s)|(\\d+s)").matcher(timestamp);
        matcher.find();
        String work = matcher.group();
        int indexDot = work.indexOf('.');
        int timeWork = 0;
        if (indexDot == -1) {
            timeWork = Integer.parseInt(work.substring(0, work.length() - 1)) * 1000;
        } else {
            timeWork = Integer.parseInt(work.substring(0, indexDot)) * 1000;
            timeWork += Integer.parseInt(work.substring(indexDot + 1, work.length() - 1));
        }
        result[1] = millsec + min * 60000 + hour * 3600000;
        result[0] = result[1] - timeWork + 1;
        return result;
    }

    public String NumberToTimestamp(int number) {
        int hour = number / 3600000;
        number %= 3600000;
        int min = number / 60000;
        number %= 60000;
        int sec = number / 1000;
        number %= 1000;
        return String.format("%02d:%02d:%02d.%03d", hour, min, sec, number);
    }

    public int solution(String[] lines) {
        Comparator<int[]> comparator = new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if (o1[0] == o2[0]) {
                    return o1[1] - o2[1];
                } else {
                    return o1[0] - o2[0];
                }
            }
        };
        int[][] logs = new int[lines.length][];
        for (int i = 0; i < lines.length; ++i) {
            logs[i] = timestampToNumbers(lines[i]);
        }
        Arrays.sort(logs, comparator);
//        System.out.println("----------");
//        for (int i = 0; i < logs.length; ++i) {
//            System.out.println(String.format("%s ~ %s", NumberToTimestamp(logs[i][0]), NumberToTimestamp(logs[i][1])));
//        }
//        System.out.println("----------");
        int answer = 0;
        int timeStart = logs[0][0];
        int timeComplete = 0;
        for (int i = 0; i < logs.length; ++i) {
            if (logs[i][1] > timeComplete) {
                timeComplete = logs[i][1];
            }
        }
        if (timeComplete < timeStart + 1000) {
            timeComplete = timeStart + 1000;
        }
        HashSet<Integer> set = new HashSet<>(logs.length);
        int indexNext = 0;
        while (true) {
            if (set.isEmpty()) {
                timeStart = logs[indexNext][0];
                set.add(indexNext);
                ++indexNext;
                while (indexNext < logs.length) {
                    if (logs[indexNext][0] >= timeStart && logs[indexNext][0] < timeStart + 1000) {
                        set.add(indexNext);
                        ++indexNext;
                    } else {
                        break;
                    }
                }
            } else {
                int startNext = logs[indexNext][0];
                int endFirst = Integer.MAX_VALUE;
                for (Integer index : set) {
                    if (logs[index][1] < endFirst) {
                        endFirst = logs[index][1];
                    }
                }
                if (endFirst <= startNext - 1000) {
                    int[] array = set.stream().mapToInt(Integer::intValue).toArray();
                    for (int i = 0; i < array.length; ++i) {
                        if (logs[array[i]][1] == endFirst) {
                            set.remove(array[i]);
                        }
                    }
                    timeStart = endFirst;
                }
                if (endFirst >= startNext - 1000) {
                    while (indexNext < logs.length) {
                        if (logs[indexNext][0] == startNext) {
                            set.add(indexNext);
                            ++indexNext;
                        } else {
                            break;
                        }
                    }
                    timeStart = startNext - 1000;
                }
            }
            if (set.size() > answer) {
                answer = set.size();
            }
            if (indexNext >= logs.length) {
                break;
            }
        }
//            System.out.println(String.format("[%s ~ %s]: %d", NumberToTimestamp(timeStart), NumberToTimestamp(timeStart + 1000), count));
        return answer;
    }
}

[Lv3] 순위

현록 — Tue, 20 Apr 2021 16:40:27 +0900

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

코딩테스트 연습 - 순위

5 [[4, 3], [4, 2], [3, 2], [1, 2], [2, 5]] 2

programmers.co.kr

문제 설명

n명의 권투선수가 권투 대회에 참여했고 각각 1번부터 n번까지 번호를 받았습니다.

권투 경기는 1대1 방식으로 진행이 되고, 만약 A 선수가 B 선수보다 실력이 좋다면 A 선수는 B 선수를 항상 이깁니다.

심판은 주어진 경기 결과를 가지고 선수들의 순위를 매기려 합니다.

하지만 몇몇 경기 결과를 분실하여 정확하게 순위를 매길 수 없습니다.

선수의 수 n, 경기 결과를 담은 2차원 배열 results가 매개변수로 주어질 때

정확하게 순위를 매길 수 있는 선수의 수를 return 하도록 solution 함수를 작성해주세요.

제한사항

선수의 수는 1명 이상 100명 이하입니다.
경기 결과는 1개 이상 4,500개 이하입니다.
results 배열 각 행 [A, B]는 A 선수가 B 선수를 이겼다는 의미입니다.
모든 경기 결과에는 모순이 없습니다.

입출력 예

n	results	return
5	[[4, 3], [4, 2], [3, 2], [1, 2], [2, 5]]	2

입출력 예 설명

2번 선수는 [1, 3, 4] 선수에게 패배했고 5번 선수에게 승리했기 때문에 4위입니다.

5번 선수는 4위인 2번 선수에게 패배했기 때문에 5위입니다.

public int solution(int n, int[][] results) {
    int[][] scores = new int[n][n];
    for (int i = 0; i < results.length; ++i) {
        scores[results[i][0] - 1][results[i][1] - 1] = 1;
        scores[results[i][1] - 1][results[i][0] - 1] = -1;
    }
    for (int i = 0; i < scores.length; ++i) {
        for (int j = 0; j < scores.length; ++j) {
            if (j == i) {
                continue;
            }
            if (scores[i][j] != 0) {
                for (int k = 0; k < scores.length; ++k) {
                    if (k == j) {
                        continue;
                    }
                    if (scores[i][k] == scores[i][j] * -1) {
                        scores[k][j] = scores[i][j];
                    }
                }
            }
        }
    }
    int answer = 0;
    for (int i = 0; i < scores.length; ++i) {
        int countZero = 0;
        for (int j = 0; j < scores.length; ++j) {
            if (scores[i][j] == 0) {
                ++countZero;
            }
        }
        if (countZero == 1) {
            ++answer;
        }
    }
    return answer;
}

[Lv3] 셔틀버스

현록 — Tue, 20 Apr 2021 02:33:22 +0900

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

코딩테스트 연습 - [1차] 셔틀버스

10 60 45 ["23:59","23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59"] "18:00"

programmers.co.kr

문제 설명

셔틀버스

카카오에서는 무료 셔틀버스를 운행하기 때문에 판교역에서 편하게 사무실로 올 수 있다.

카카오의 직원은 서로를 '크루'라고 부르는데, 아침마다 많은 크루들이 이 셔틀을 이용하여 출근한다.

이 문제에서는 편의를 위해 셔틀은 다음과 같은 규칙으로 운행한다고 가정하자.

셔틀은 09:00부터 총 n회 t분 간격으로 역에 도착하며, 하나의 셔틀에는 최대 m명의 승객이 탈 수 있다.
셔틀은 도착했을 때 도착한 순간에 대기열에 선 크루까지 포함해서 대기 순서대로 태우고 바로 출발한다.
예를 들어 09:00에 도착한 셔틀은 자리가 있다면 09:00에 줄을 선 크루도 탈 수 있다.

일찍 나와서 셔틀을 기다리는 것이 귀찮았던 콘은, 일주일간의 집요한 관찰 끝에 어떤 크루가 몇 시에 셔틀 대기열에 도착하는지 알아냈다.

콘이 셔틀을 타고 사무실로 갈 수 있는 도착 시각 중 제일 늦은 시각을 구하여라.

단, 콘은 게으르기 때문에 같은 시각에 도착한 크루 중 대기열에서 제일 뒤에 선다.

또한, 모든 크루는 잠을 자야 하므로 23:59에 집에 돌아간다. 따라서 어떤 크루도 다음날 셔틀을 타는 일은 없다.

입력 형식

셔틀 운행 횟수 n, 셔틀 운행 간격 t, 한 셔틀에 탈 수 있는 최대 크루 수 m,

크루가 대기열에 도착하는 시각을 모은 배열 timetable이 입력으로 주어진다.

0 ＜ n ≦ 10
0 ＜ t ≦ 60
0 ＜ m ≦ 45
timetable은 최소 길이 1이고 최대 길이 2000인 배열로, 하루 동안 크루가 대기열에 도착하는 시각이 HH:MM 형식으로 이루어져 있다.
크루의 도착 시각 HH:MM은 00:01에서 23:59 사이이다.

출력 형식

콘이 무사히 셔틀을 타고 사무실로 갈 수 있는 제일 늦은 도착 시각을 출력한다.

도착 시각은 HH:MM 형식이며, 00:00에서 23:59 사이의 값이 될 수 있다.

입출력 예제

n	t	m	timetable	answer
1	1	5	["08:00", "08:01", "08:02", "08:03"]	"09:00"
2	10	2	["09:10", "09:09", "08:00"]	"09:09"
2	1	2	["09:00", "09:00", "09:00", "09:00"]	"08:59"
1	1	5	["00:01", "00:01", "00:01", "00:01", "00:01"]	"00:00"
1	1	1	["23:59"]	"09:00"
10	60	45	["23:59","23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59"]	"18:00"

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

class Solution {
    public int timestampToMinutes(String timestamp) {
        int minute = (timestamp.charAt(3) - '0') * 10 + (timestamp.charAt(4) - '0');
        int hour = (timestamp.charAt(0) - '0') * 10 + timestamp.charAt(1) - '0';
        return hour * 60 + minute;
    }

    public String minutesToTimestamp(int minutes) {
        int hour = minutes / 60;
        int minute = minutes % 60;
        return String.format("%02d:%02d", hour, minute);
    }

    public String solution(int n, int t, int m, String[] timetable) {
        Comparator<String> comparator = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return timestampToMinutes(o1) - timestampToMinutes(o2);
            }
        };
        Arrays.sort(timetable, comparator);
        ArrayList<Integer>[] peoples = new ArrayList[n];
        for (int i = 0; i < n; ++i) {
            peoples[i] = new ArrayList<>(m);
        }
        int index = 0;
        for (int i = 0; i < timetable.length; ++i) {
            if (index >= n) {
                break;
            }
            int pickMinutes = timestampToMinutes(timetable[i]);
            int timeNow = 60 * 9 + t * index;
            if (pickMinutes <= timeNow) {
                if (peoples[index].size() < m) {
                    peoples[index].add(pickMinutes);
                } else {
                    ++index;
                    --i;
                }
            } else {
                ++index;
                --i;
            }
        }
        int[] ables = new int[n];
        for (int i = 0; i < n; ++i) {
            if (peoples[i].size() < m) {
                ables[i] = 60 * 9 + t * i;
            } else {
                int able = -1;
                int prev = 0;
                for (int j = 0; j < peoples[i].size(); ++j) {
                    int now = peoples[i].get(j);
                    if (now > prev) {
                        able = now - 1;
                    }
                    prev = now;
                }
                ables[i] = able;
            }
        }
        for (int i = n - 1; i >= 0; --i) {
            if (ables[i] != -1) {
                return minutesToTimestamp(ables[i]);
            }
        }
        return null;
    }
}

[Lv3] 입국심사

현록 — Mon, 19 Apr 2021 19:34:58 +0900

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

코딩테스트 연습 - 입국심사

n명이 입국심사를 위해 줄을 서서 기다리고 있습니다. 각 입국심사대에 있는 심사관마다 심사하는데 걸리는 시간은 다릅니다. 처음에 모든 심사대는 비어있습니다. 한 심사대에서는 동시에 한

programmers.co.kr

문제 설명

n명이 입국심사를 위해 줄을 서서 기다리고 있습니다.

각 입국심사대에 있는 심사관마다 심사하는데 걸리는 시간은 다릅니다.

처음에 모든 심사대는 비어있습니다. 한 심사대에서는 동시에 한 명만 심사를 할 수 있습니다.

가장 앞에 서 있는 사람은 비어 있는 심사대로 가서 심사를 받을 수 있습니다.

하지만 더 빨리 끝나는 심사대가 있으면 기다렸다가 그곳으로 가서 심사를 받을 수도 있습니다.

모든 사람이 심사를 받는데 걸리는 시간을 최소로 하고 싶습니다.

입국심사를 기다리는 사람 수 n,

각 심사관이 한 명을 심사하는데 걸리는 시간이 담긴 배열 times가매개변수로 주어질 때,

모든 사람이 심사를 받는데 걸리는 시간의 최솟값을 return 하도록 solution 함수를 작성해주세요.

제한사항

입국심사를 기다리는 사람은 1명 이상 1,000,000,000명 이하입니다.
각 심사관이 한 명을 심사하는데 걸리는 시간은 1분 이상 1,000,000,000분 이하입니다.
심사관은 1명 이상 100,000명 이하입니다.

입출력 예

n	times	return
6	[7, 10]	28

입출력 예 설명

가장 첫 두 사람은 바로 심사를 받으러 갑니다.

7분이 되었을 때, 첫 번째 심사대가 비고 3번째 사람이 심사를 받습니다.

10분이 되었을 때, 두 번째 심사대가 비고 4번째 사람이 심사를 받습니다.

14분이 되었을 때, 첫 번째 심사대가 비고 5번째 사람이 심사를 받습니다.

20분이 되었을 때, 두 번째 심사대가 비지만 6번째 사람이 그곳에서 심사를 받지 않고

1분을 더 기다린 후에 첫 번째 심사대에서 심사를 받으면 28분에 모든 사람의 심사가 끝납니다.

import java.util.Arrays;

class Solution {
    public long solution(int n, int[] times) {
        Arrays.sort(times);
        if (n == 1) {
            return times[0];
        }
        long start = times[0];
        long end = (long) n * times[times.length - 1];
        while (true) {
            if (start == end) {
                break;
            }
            long mid = (start + end) / 2;
            long loopAnswer = 0L;
            for (int i = 0; i < times.length; ++i) {
                loopAnswer += (mid / times[i]);
            }
            if (loopAnswer < n) {
                start = mid + 1;
            } else {
                end = mid;
            }
        }
        return start;
    }
}

[Lv2] 뉴스 클러스터링

현록 — Wed, 14 Apr 2021 17:41:53 +0900

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

코딩테스트 연습 - [1차] 뉴스 클러스터링

뉴스 클러스터링 여러 언론사에서 쏟아지는 뉴스, 특히 속보성 뉴스를 보면 비슷비슷한 제목의 기사가 많아 정작 필요한 기사를 찾기가 어렵다. Daum 뉴스의 개발 업무를 맡게 된 신입사원 튜브

programmers.co.kr

문제 설명

뉴스 클러스터링

여러 언론사에서 쏟아지는 뉴스, 특히 속보성 뉴스를 보면 비슷비슷한 제목의 기사가 많아 정작 필요한 기사를 찾기가 어렵다.

Daum 뉴스의 개발 업무를 맡게 된 신입사원 튜브는 사용자들이 편리하게 다양한 뉴스를 찾아볼 수 있도록 문제점을 개선하는 업무를 맡게 되었다.

개발의 방향을 잡기 위해 튜브는 우선 최근 화제가 되고 있는 "카카오 신입 개발자 공채" 관련 기사를 검색해보았다.

카카오 첫 공채..'블라인드' 방식 채용
카카오, 합병 후 첫 공채.. 블라인드 전형으로 개발자 채용
카카오, 블라인드 전형으로 신입 개발자 공채
카카오 공채, 신입 개발자 코딩 능력만 본다
카카오, 신입 공채.. "코딩 실력만 본다"
카카오 "코딩 능력만으로 2018 신입 개발자 뽑는다"

기사의 제목을 기준으로 "블라인드 전형"에 주목하는 기사와 "코딩 테스트"에 주목하는 기사로 나뉘는 걸 발견했다.

튜브는 이들을 각각 묶어서 보여주면 카카오 공채 관련 기사를 찾아보는 사용자에게 유용할 듯싶었다.

유사한 기사를 묶는 기준을 정하기 위해서 논문과 자료를 조사하던 튜브는 "자카드 유사도"라는 방법을 찾아냈다.

자카드 유사도는 집합 간의 유사도를 검사하는 여러 방법 중의 하나로 알려져 있다.

두 집합 A, B 사이의 자카드 유사도 J(A, B)는 두 집합의 교집합 크기를 두 집합의 합집합 크기로 나눈 값으로 정의된다.

예를 들어 집합 A = {1, 2, 3}, 집합 B = {2, 3, 4}라고 할 때, 교집합 A ∩ B = {2, 3}, 합집합 A ∪ B = {1, 2, 3, 4}이 되므로,

집합 A, B 사이의 자카드 유사도 J(A, B) = 2/4 = 0.5가 된다.

집합 A와 집합 B가 모두 공집합일 경우에는 나눗셈이 정의되지 않으니 따로 J(A, B) = 1로 정의한다.

자카드 유사도는 원소의 중복을 허용하는 다중집합에 대해서 확장할 수 있다.

다중집합 A는 원소 "1"을 3개 가지고 있고,

다중집합 B는 원소 "1"을 5개 가지고 있다고 하자.

이 다중집합의 교집합 A ∩ B는 원소 "1"을 min(3, 5)인 3개, 합집합 A ∪ B는 원소 "1"을 max(3, 5)인 5개 가지게 된다.

다중집합 A = {1, 1, 2, 2, 3}, 다중집합 B = {1, 2, 2, 4, 5}라고 하면,

교집합 A ∩ B = {1, 2, 2}, 합집합 A ∪ B = {1, 1, 2, 2, 3, 4, 5}가 되므로, 자카드 유사도 J(A, B) = 3/7, 약 0.42가 된다.

이를 이용하여 문자열 사이의 유사도를 계산하는데 이용할 수 있다. 문자열 "FRANCE"와 "FRENCH"가 주어졌을 때,

이를 두 글자씩 끊어서 다중집합을 만들 수 있다.

각각 {FR, RA, AN, NC, CE}, {FR, RE, EN, NC, CH}가 되며, 교집합은 {FR, NC},

합집합은 {FR, RA, AN, NC, CE, RE, EN, CH}가 되므로,

두 문자열 사이의 자카드 유사도 J("FRANCE", "FRENCH") = 2/8 = 0.25가 된다.

입력 형식

입력으로는 str1과 str2의 두 문자열이 들어온다. 각 문자열의 길이는 2 이상, 1,000 이하이다.
입력으로 들어온 문자열은 두 글자씩 끊어서 다중집합의 원소로 만든다. 이때 영문자로 된 글자 쌍만 유효하고, 기타 공백이나 숫자, 특수 문자가 들어있는 경우는 그 글자 쌍을 버린다. 예를 들어 "ab+"가 입력으로 들어오면, "ab"만 다중집합의 원소로 삼고, "b+"는 버린다.
다중집합 원소 사이를 비교할 때, 대문자와 소문자의 차이는 무시한다. "AB"와 "Ab", "ab"는 같은 원소로 취급한다.

출력 형식

입력으로 들어온 두 문자열의 자카드 유사도를 출력한다.

유사도 값은 0에서 1 사이의 실수이므로, 이를 다루기 쉽도록 65536을 곱한 후에 소수점 아래를 버리고 정수부만 출력한다.

예제 입출력

str1	str2	answer
FRANCE	french	16384
handshake	shake hands	65536
aa1+aa2	AAAA12	43690
E=M*C^2	e=m*c^2	65536

import java.util.ArrayList;
import java.util.Collections;

class Solution {
    public int solution(String str1, String str2) {
        ArrayList<String> list1 = new ArrayList<>(str1.length() - 1);
        ArrayList<String> list2 = new ArrayList<>(str2.length() - 1);
        char[] chars1 = str1.toUpperCase().toCharArray();
        char[] chars2 = str2.toUpperCase().toCharArray();
        for (int i = 0; i < chars1.length - 1; ++i) {
            if (chars1[i] >= 'A' && chars1[i] <= 'Z' && chars1[i + 1] >= 'A' && chars1[i + 1] <= 'Z') {
                list1.add(String.format("%c%c", chars1[i], chars1[i + 1]));
            }
        }
        for (int i = 0; i < chars2.length - 1; ++i) {
            if (chars2[i] >= 'A' && chars2[i] <= 'Z' && chars2[i + 1] >= 'A' && chars2[i + 1] <= 'Z') {
                list2.add(String.format("%c%c", chars2[i], chars2[i + 1]));
            }
        }
        if (list1.isEmpty() && list2.isEmpty()) {
            return 65536;
        }
        Collections.sort(list1);
        Collections.sort(list2);
        String[] strings1 = list1.toArray(new String[list1.size()]);
        String[] strings2 = list2.toArray(new String[list2.size()]);
//        System.out.println(Arrays.toString(strings1));
//        System.out.println(Arrays.toString(strings2));
        String[] small = null;
        String[] big = null;
        if (strings1.length <= strings2.length) {
            small = strings1;
            big = strings2;
        } else {
            small = strings2;
            big = strings1;
        }
        ArrayList<String> intersection = new ArrayList<>(small.length);
        int indexSmall = 0;
        int indexBig = 0;
        while (indexSmall < small.length && indexBig < big.length) {
            int resultCompare = big[indexBig].compareTo(small[indexSmall]);
//            System.out.println(String.format("%d - %s / %s", resultCompare, small[indexSmall], big[indexBig]));
            if (resultCompare == 0) {
                intersection.add(small[indexSmall]);
                ++indexSmall;
                ++indexBig;
            } else if (resultCompare < 0) {
                ++indexBig;
            } else {
                ++indexSmall;
            }
        }
        indexSmall = 0;
        indexBig = 0;
        int indexIntersection = 0;
        ArrayList<String> union = new ArrayList<>(list1.size() + list2.size());
        while (true) {
            if (indexSmall < small.length && indexBig < big.length) {
                int resultCompare = big[indexBig].compareTo(small[indexSmall]);
                if (resultCompare == 0) {
                    String stringSame = big[indexBig];
                    while (indexIntersection < intersection.size()) {
                        String stringIntersection = intersection.get(indexIntersection);
                        if (stringSame.equals(stringIntersection)) {
                            ++indexIntersection;
                        } else {
                            break;
                        }
                    }
                    int countInSmall = 0;
                    while (indexSmall < small.length) {
                        if (small[indexSmall].equals(stringSame) == false) {
                            break;
                        }
                        ++indexSmall;
                        ++countInSmall;
                    }
                    int countInBig = 0;
                    while (indexBig < big.length) {
                        if (big[indexBig].equals(stringSame) == false) {
                            break;
                        }
                        ++indexBig;
                        ++countInBig;
                    }
                    for (int i = 0; i < Math.max(countInSmall, countInBig); ++i) {
                        union.add(stringSame);
                    }
                } else if (resultCompare < 0) {
                    union.add(big[indexBig++]);
                } else {
                    union.add(small[indexSmall++]);
                }
            } else if (indexSmall < small.length) {
                union.add(small[indexSmall++]);
            } else if (indexBig < big.length) {
                union.add(big[indexBig++]);
            } else {
                break;
            }
        }
//        System.out.print(String.format("교집합: %d - [", intersection.size()));
//        for (String str : intersection) {
//            System.out.print(String.format("%s, ", str));
//        }
//        System.out.println("]");
//        System.out.print(String.format("합집합: %d - [", union.size()));
//        for (String str : union) {
//            System.out.print(String.format("%s, ", str));
//        }
//        System.out.println("]");
        return (int) ((double) intersection.size() / union.size() * 65536);
    }
}

[Lv2] 튜플

현록 — Wed, 14 Apr 2021 16:07:06 +0900

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

코딩테스트 연습 - 튜플

"{{2},{2,1},{2,1,3},{2,1,3,4}}" [2, 1, 3, 4] "{{1,2,3},{2,1},{1,2,4,3},{2}}" [2, 1, 3, 4] "{{4,2,3},{3},{2,3,4,1},{2,3}}" [3, 2, 4, 1]

programmers.co.kr

문제 설명

셀수있는 수량의 순서있는 열거 또는 어떤 순서를 따르는 요소들의 모음을 튜플(tuple)이라고 합니다.

n개의 요소를 가진 튜플을 n-튜플(n-tuple)이라고 하며, 다음과 같이 표현할 수 있습니다.

(a1, a2, a3, ..., an)

튜플은 다음과 같은 성질을 가지고 있습니다.

중복된 원소가 있을 수 있습니다. ex : (2, 3, 1, 2)
원소에 정해진 순서가 있으며, 원소의 순서가 다르면 서로 다른 튜플입니다. ex : (1, 2, 3) ≠ (1, 3, 2)
튜플의 원소 개수는 유한합니다.

원소의 개수가 n개이고, 중복되는 원소가 없는 튜플 (a1, a2, a3, ..., an)이 주어질 때(단, a1, a2, ..., an은 자연수),

이는 다음과 같이 집합 기호 '{', '}'를 이용해 표현할 수 있습니다.

{{a1}, {a1, a2}, {a1, a2, a3}, {a1, a2, a3, a4}, ... {a1, a2, a3, a4, ..., an}}

예를 들어 튜플이 (2, 1, 3, 4)인 경우 이는

{{2}, {2, 1}, {2, 1, 3}, {2, 1, 3, 4}}

와 같이 표현할 수 있습니다. 이때, 집합은 원소의 순서가 바뀌어도 상관없으므로

{{2}, {2, 1}, {2, 1, 3}, {2, 1, 3, 4}}
{{2, 1, 3, 4}, {2}, {2, 1, 3}, {2, 1}}
{{1, 2, 3}, {2, 1}, {1, 2, 4, 3}, {2}}

는 모두 같은 튜플 (2, 1, 3, 4)를 나타냅니다.

특정 튜플을 표현하는 집합이 담긴 문자열 s가 매개변수로 주어질 때,

s가 표현하는 튜플을 배열에 담아 return 하도록 solution 함수를 완성해주세요.

[제한사항]

s의 길이는 5 이상 1,000,000 이하입니다.
s는 숫자와 '{', '}', ',' 로만 이루어져 있습니다.
숫자가 0으로 시작하는 경우는 없습니다.
s는 항상 중복되는 원소가 없는 튜플을 올바르게 표현하고 있습니다.
s가 표현하는 튜플의 원소는 1 이상 100,000 이하인 자연수입니다.
return 하는 배열의 길이가 1 이상 500 이하인 경우만 입력으로 주어집니다.

[입출력 예]

s	result
"{{2},{2,1},{2,1,3},{2,1,3,4}}"	[2, 1, 3, 4]
"{{1,2,3},{2,1},{1,2,4,3},{2}}"	[2, 1, 3, 4]
"{{20,111},{111}}"	[111, 20]
"{{123}}"	[123]
"{{4,2,3},{3},{2,3,4,1},{2,3}}"	[3, 2, 4, 1]

입출력 예에 대한 설명입출력 예 #1

문제 예시와 같습니다.

입출력 예 #2

문제 예시와 같습니다.

입출력 예 #3

(111, 20)을 집합 기호를 이용해 표현하면 {{111}, {111,20}}이 되며, 이는 {{20,111},{111}}과 같습니다.

입출력 예 #4

(123)을 집합 기호를 이용해 표현하면 {{123}} 입니다.

입출력 예 #5

(3, 2, 4, 1)을 집합 기호를 이용해 표현하면 {{3},{3,2},{3,2,4},{3,2,4,1}}이 되며, 이는 {{4,2,3},{3},{2,3,4,1},{2,3}}과 같습니다.

import java.util.Arrays;
import java.util.Comparator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Solution {
    public int[] solution(String s) {
        String regex = "\\{((\\d+\\,*)+)\\}";
        Matcher matcher = Pattern.compile(regex).matcher(s);
        int count = 0;
        while (matcher.find()) {
            ++count;
        }
        matcher.reset();
        if (count == 1) {
            matcher.find();
            return new int[] { Integer.parseInt(matcher.group(1)) };
        }
        String[] strings = new String[count];
        for (int i = 0; i < count; ++i) {
            matcher.find();
            strings[i] = matcher.group(1);
        }
        Comparator<String> comparator = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        };
        Arrays.sort(strings, comparator);
        int[] answer = new int[count];
        regex = "\\d+";
        for (int i = 0; i < count; ++i) {
            matcher = Pattern.compile(regex).matcher(strings[i]);
            loop2:
            for (int j = 0; j <= i; ++j) {
                matcher.find();
                int number = Integer.parseInt(matcher.group());
                if (i == 0) {
                    answer[0] = number;
                    break;
                }
                for (int k = 0; k < i; ++k) {
                    if (number == answer[k]) {
                        continue loop2;
                    }
                }
                answer[i] = number;
            }
        }
        return answer;
    }
}

[Lv2] 문자열 압축

현록 — Tue, 13 Apr 2021 17:50:50 +0900

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

코딩테스트 연습 - 문자열 압축

데이터 처리 전문가가 되고 싶은 "어피치"는 문자열을 압축하는 방법에 대해 공부를 하고 있습니다. 최근에 대량의 데이터 처리를 위한 간단한 비손실 압축 방법에 대해 공부를 하고 있는데, 문

programmers.co.kr

문제 설명

데이터 처리 전문가가 되고 싶은 "어피치"는 문자열을 압축하는 방법에 대해 공부를 하고 있습니다.

최근에 대량의 데이터 처리를 위한 간단한 비손실 압축 방법에 대해 공부를 하고 있는데,

문자열에서 같은 값이 연속해서 나타나는 것을 그 문자의 개수와 반복되는 값으로 표현하여

더 짧은 문자열로 줄여서 표현하는 알고리즘을 공부하고 있습니다.

간단한 예로 "aabbaccc"의 경우 "2a2ba3c"(문자가 반복되지 않아 한번만 나타난 경우 1은 생략함)와 같이

표현할 수 있는데, 이러한 방식은 반복되는 문자가 적은 경우 압축률이 낮다는 단점이 있습니다.

예를 들면, "abcabcdede"와 같은 문자열은 전혀 압축되지 않습니다.

"어피치"는 이러한 단점을 해결하기 위해 문자열을 1개 이상의 단위로 잘라서 압축하여

더 짧은 문자열로 표현할 수 있는지 방법을 찾아보려고 합니다.

예를 들어, "ababcdcdababcdcd"의 경우 문자를 1개 단위로 자르면 전혀 압축되지 않지만,

2개 단위로 잘라서 압축한다면 "2ab2cd2ab2cd"로 표현할 수 있습니다.

다른 방법으로 8개 단위로 잘라서 압축한다면 "2ababcdcd"로 표현할 수 있으며,

이때가 가장 짧게 압축하여 표현할 수 있는 방법입니다.

다른 예로, "abcabcdede"와 같은 경우, 문자를 2개 단위로 잘라서 압축하면 "abcabc2de"가 되지만,

3개 단위로 자른다면 "2abcdede"가 되어 3개 단위가 가장 짧은 압축 방법이 됩니다.

이때 3개 단위로 자르고 마지막에 남는 문자열은 그대로 붙여주면 됩니다.

압축할 문자열 s가 매개변수로 주어질 때,

위에 설명한 방법으로 1개 이상 단위로 문자열을 잘라 압축하여 표현한 문자열 중 가장 짧은 것의 길이를 return 하도록

solution 함수를 완성해주세요.

제한사항

s의 길이는 1 이상 1,000 이하입니다.
s는 알파벳 소문자로만 이루어져 있습니다.

입출력 예

s	result
"aabbaccc"	7
"ababcdcdababcdcd"	9
"abcabcdede"	8
"abcabcabcabcdededededede"	14
"xababcdcdababcdcd"	17

입출력 예에 대한 설명

입출력 예 #1

문자열을 1개 단위로 잘라 압축했을 때 가장 짧습니다.

입출력 예 #2

문자열을 8개 단위로 잘라 압축했을 때 가장 짧습니다.

입출력 예 #3

문자열을 3개 단위로 잘라 압축했을 때 가장 짧습니다.

입출력 예 #4

문자열을 2개 단위로 자르면 "abcabcabcabc6de" 가 됩니다.

문자열을 3개 단위로 자르면 "4abcdededededede" 가 됩니다.

문자열을 4개 단위로 자르면 "abcabcabcabc3dede" 가 됩니다.

문자열을 6개 단위로 자를 경우 "2abcabc2dedede"가 되며, 이때의 길이가 14로 가장 짧습니다.

입출력 예 #5

문자열은 제일 앞부터 정해진 길이만큼 잘라야 합니다.

따라서 주어진 문자열을 x / ababcdcd / ababcdcd 로 자르는 것은 불가능 합니다.

이 경우 어떻게 문자열을 잘라도 압축되지 않으므로 가장 짧은 길이는 17이 됩니다.

public int solution(String s) {
    System.out.println(String.format("[000] %s: %d", s, s.length()));
    int answer = s.length();
    for (int i = 1; i <= s.length() / 2; ++i) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int j = 0; j < s.length(); ++j) {
            int endIndex = j + i;
            if (endIndex > s.length()) {
                System.out.printf(String.format("(%s)", s.substring(j)));
                stringBuilder.append(s.substring(j));
                break;
            } else {
                String piece = s.substring(j, j + i);
                for (int k = endIndex; k < s.length(); k += i) {
                    if (k + i > s.length()) {
                        break;
                    }
                    if (s.substring(k, k + i).equals(piece) == true) {
                        endIndex = k + i;
                    } else {
                        break;
                    }
                }
                int repeat = (endIndex - j) / i;
                if (repeat > 1) {
                    stringBuilder.append(repeat);
                    System.out.printf(String.format("{%d%s}", repeat, piece));
                } else {
                    System.out.printf(String.format("[%s]", piece));
                }
                stringBuilder.append(piece);
                j = endIndex - 1;
            }
        }
        int length = stringBuilder.length();
//            if (length > 0 && length < answer) {
        if (length > 0) {
            System.out.println(String.format(" - [%03d] %s: %d", i, stringBuilder.toString(), stringBuilder.length()));
            if (length < answer) {
                answer = length;
            }
        }
    }
    return answer;
}

[Lv1] 3진법 뒤집기

현록 — Tue, 13 Apr 2021 15:58:43 +0900

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

코딩테스트 연습 - 3진법 뒤집기

자연수 n이 매개변수로 주어집니다. n을 3진법 상에서 앞뒤로 뒤집은 후, 이를 다시 10진법으로 표현한 수를 return 하도록 solution 함수를 완성해주세요. 제한사항 n은 1 이상 100,000,000 이하인 자연수

programmers.co.kr

문제 설명

자연수 n이 매개변수로 주어집니다. n을 3진법 상에서 앞뒤로 뒤집은 후, 이를 다시 10진법으로 표현한 수를 return 하도록 solution 함수를 완성해주세요.

제한사항

n은 1 이상 100,000,000 이하인 자연수입니다.

입출력 예

n	result
45	7
125	229

입출력 예 설명

입출력 예 #1

답을 도출하는 과정은 다음과 같습니다.

n (10진법)	n (3진법)	앞뒤 반전(3진법)	10진법으로 표현
45	1200	0021	7

따라서 7을 return 해야 합니다.

입출력 예 #2

답을 도출하는 과정은 다음과 같습니다.

n (10진법)	n (3진법)	앞뒤 반전(3진법)	10진법으로 표현
125	11122	22111	229

따라서 229를 return 해야 합니다.

public int solution(int n) {
    StringBuilder stringBuilder = new StringBuilder();
    while (n > 2) {
        stringBuilder.append(n % 3);
        n /= 3;
    }
    if (n > 0) {
        stringBuilder.append(n);
    }
    char[] array = stringBuilder.reverse().toString().toCharArray();
    int answer = 0;
    for (int i = 0; i < array.length; ++i) {
        answer += (Math.pow(3, i) * (array[i] - '0'));
    }
    return answer;
}

[Lv1] 키패드 누르기

현록 — Tue, 13 Apr 2021 15:41:04 +0900

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

코딩테스트 연습 - 키패드 누르기

[1, 3, 4, 5, 8, 2, 1, 4, 5, 9, 5] "right" "LRLLLRLLRRL" [7, 0, 8, 2, 8, 3, 1, 5, 7, 6, 2] "left" "LRLLRRLLLRR" [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] "right" "LLRLLRLLRL"

programmers.co.kr

문제 설명

스마트폰 전화 키패드의 각 칸에 다음과 같이 숫자들이 적혀 있습니다.

이 전화 키패드에서 왼손과 오른손의 엄지손가락만을 이용해서 숫자만을 입력하려고 합니다.

맨 처음 왼손 엄지손가락은 * 키패드에 오른손 엄지손가락은 # 키패드 위치에서 시작하며, 엄지손가락을 사용하는 규칙은 다음과 같습니다.

엄지손가락은 상하좌우 4가지 방향으로만 이동할 수 있으며 키패드 이동 한 칸은 거리로 1에 해당합니다.
왼쪽 열의 3개의 숫자 1, 4, 7을 입력할 때는 왼손 엄지손가락을 사용합니다.
오른쪽 열의 3개의 숫자 3, 6, 9를 입력할 때는 오른손 엄지손가락을 사용합니다.
가운데 열의 4개의 숫자 2, 5, 8, 0을 입력할 때는 두 엄지손가락의 현재 키패드의 위치에서 더 가까운 엄지손가락을 사용합니다.4-1. 만약 두 엄지손가락의 거리가 같다면, 오른손잡이는 오른손 엄지손가락, 왼손잡이는 왼손 엄지손가락을 사용합니다.

순서대로 누를 번호가 담긴 배열 numbers, 왼손잡이인지 오른손잡이인 지를 나타내는 문자열 hand가 매개변수로 주어질 때,

각 번호를 누른 엄지손가락이 왼손인 지 오른손인 지를 나타내는 연속된 문자열 형태로 return 하도록 solution 함수를 완성해주세요.

[제한사항]

numbers 배열의 크기는 1 이상 1,000 이하입니다.
numbers 배열 원소의 값은 0 이상 9 이하인 정수입니다.
hand는 "left" 또는 "right" 입니다.
- "left"는 왼손잡이, "right"는 오른손잡이를 의미합니다.
왼손 엄지손가락을 사용한 경우는 L, 오른손 엄지손가락을 사용한 경우는 R을 순서대로 이어붙여 문자열 형태로 return 해주세요.

입출력 예

numbers	hand	result
[1, 3, 4, 5, 8, 2, 1, 4, 5, 9, 5]	"right"	"LRLLLRLLRRL"
[7, 0, 8, 2, 8, 3, 1, 5, 7, 6, 2]	"left"	"LRLLRRLLLRR"
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]	"right"	"LLRLLRLLRL"

입출력 예에 대한 설명

입출력 예 #1

순서대로 눌러야 할 번호가 [1, 3, 4, 5, 8, 2, 1, 4, 5, 9, 5]이고, 오른손잡이입니다.

왼손 위치	오른손 위치	눌러야 할 숫자	사용한 손	설명
*	#	1	L	1은 왼손으로 누릅니다.
1	#	3	R	3은 오른손으로 누릅니다.
1	3	4	L	4는 왼손으로 누릅니다.
4	3	5	L	왼손 거리는 1, 오른손 거리는 2이므로 왼손으로 5를 누릅니다.
5	3	8	L	왼손 거리는 1, 오른손 거리는 3이므로 왼손으로 8을 누릅니다.
8	3	2	R	왼손 거리는 2, 오른손 거리는 1이므로 오른손으로 2를 누릅니다.
8	2	1	L	1은 왼손으로 누릅니다.
1	2	4	L	4는 왼손으로 누릅니다.
4	2	5	R	왼손 거리와 오른손 거리가 1로 같으므로, 오른손으로 5를 누릅니다.
4	5	9	R	9는 오른손으로 누릅니다.
4	9	5	L	왼손 거리는 1, 오른손 거리는 2이므로 왼손으로 5를 누릅니다.
5	9	-	-

따라서 "LRLLLRLLRRL"를 return 합니다.

입출력 예 #2

왼손잡이가 [7, 0, 8, 2, 8, 3, 1, 5, 7, 6, 2]를 순서대로 누르면 사용한 손은 "LRLLRRLLLRR"이 됩니다.

입출력 예 #3

오른손잡이가 [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]를 순서대로 누르면 사용한 손은 "LLRLLRLLRL"이 됩니다.

public String solution(int[] numbers, String hand) {
    int[] leftHandPosition = new int[] { 3, 0 };
    int[] rightHandPosition = new int[] { 3, 2 };
    StringBuilder stringBuilder = new StringBuilder();
    for (int i = 0; i < numbers.length; ++i) {
        switch (numbers[i]) {
            case 1:
                leftHandPosition[0] = 0;
                leftHandPosition[1] = 0;
                stringBuilder.append('L');
                break;
            case 4:
                leftHandPosition[0] = 1;
                leftHandPosition[1] = 0;
                stringBuilder.append('L');
                break;
            case 7:
                leftHandPosition[0] = 2;
                leftHandPosition[1] = 0;
                stringBuilder.append('L');
                break;
            case 3:
                rightHandPosition[0] = 0;
                rightHandPosition[1] = 2;
                stringBuilder.append('R');
                break;
            case 6:
                rightHandPosition[0] = 1;
                rightHandPosition[1] = 2;
                stringBuilder.append('R');
                break;
            case 9:
                rightHandPosition[0] = 2;
                rightHandPosition[1] = 2;
                stringBuilder.append('R');
                break;
            default: {
                int y = 0;
                switch (numbers[i]) {
                    case 5:
                        y = 1;
                        break;
                    case 8:
                        y = 2;
                        break;
                    case 0:
                        y = 3;
                        break;
                }
                int farFromLeft = (1 - leftHandPosition[1]) + Math.abs(y - leftHandPosition[0]);
                int farFromRight = (rightHandPosition[1] - 1) + Math.abs(y - rightHandPosition[0]);
                if (farFromLeft < farFromRight) {
                    leftHandPosition[0] = y;
                    leftHandPosition[1] = 1;
                    stringBuilder.append('L');
                } else if (farFromRight < farFromLeft) {
                    rightHandPosition[0] = y;
                    rightHandPosition[1] = 1;
                    stringBuilder.append('R');
                } else if (hand.equals("right")) {
                    rightHandPosition[0] = y;
                    rightHandPosition[1] = 1;
                    stringBuilder.append('R');
                } else {
                    leftHandPosition[0] = y;
                    leftHandPosition[1] = 1;
                    stringBuilder.append('L');
                }
                break;
            }
        }
    }
    return stringBuilder.toString();
}

[Lv1] 다트 게임

현록 — Tue, 13 Apr 2021 15:11:09 +0900

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

코딩테스트 연습 - [1차] 다트 게임

programmers.co.kr

문제 설명

다트 게임

카카오톡 게임별의 하반기 신규 서비스로 다트 게임을 출시하기로 했다.

다트 게임은 다트판에 다트를 세 차례 던져 그 점수의 합계로 실력을 겨루는 게임으로, 모두가 간단히 즐길 수 있다.

갓 입사한 무지는 코딩 실력을 인정받아 게임의 핵심 부분인 점수 계산 로직을 맡게 되었다.

다트 게임의 점수 계산 로직은 아래와 같다.

다트 게임은 총 3번의 기회로 구성된다.
각 기회마다 얻을 수 있는 점수는 0점에서 10점까지이다.
점수와 함께 Single(S), Double(D), Triple(T) 영역이 존재하고 각 영역 당첨 시점수에서 1제곱, 2제곱, 3제곱 (점수1 , 점수2 , 점수3 )으로 계산된다.
옵션으로 스타상(*) , 아차상(#)이 존재하며 스타상(*) 당첨 시 해당 점수와 바로 전에 얻은 점수를 각 2배로 만든다. 아차상(#) 당첨 시 해당 점수는 마이너스된다.
스타상(*)은 첫 번째 기회에서도 나올 수 있다. 이 경우 첫 번째 스타상(*)의 점수만 2배가 된다. (예제 4번 참고)
스타상(*)의 효과는 다른 스타상(*)의 효과와 중첩될 수 있다. 이 경우 중첩된 스타상(*) 점수는 4배가 된다. (예제 4번 참고)
스타상(*)의 효과는 아차상(#)의 효과와 중첩될 수 있다. 이 경우 중첩된 아차상(#)의 점수는 -2배가 된다. (예제 5번 참고)
Single(S), Double(D), Triple(T)은 점수마다 하나씩 존재한다.
스타상(*), 아차상(#)은 점수마다 둘 중 하나만 존재할 수 있으며, 존재하지 않을 수도 있다.

0~10의 정수와 문자 S, D, T, *, #로 구성된 문자열이 입력될 시 총점수를 반환하는 함수를 작성하라.

입력 형식

"점수|보너스|[옵션]"으로 이루어진 문자열 3세트.

예) 1S2D*3T

점수는 0에서 10 사이의 정수이다.
보너스는 S, D, T 중 하나이다.
옵선은 *이나 # 중 하나이며, 없을 수도 있다.

출력 형식

3번의 기회에서 얻은 점수 합계에 해당하는 정수값을 출력한다.

예) 37

입출력 예제

예제	dartResult	answer	설명
1	1S2D*3T	37	11 * 2 + 22 * 2 + 33
2	1D2S#10S	9	12 + 21 * (-1) + 101
3	1D2S0T	3	12 + 21 + 03
4	1S2T3S	23	11 * 2 * 2 + 23 * 2 + 31
5	1D#2S*3S	5	12 * (-1) * 2 + 21 * 2 + 31
6	1T2D3D#	-4	13 + 22 + 32 * (-1)
7	1D2S3T*	59	12 + 21 * 2 + 33 * 2

import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Solution {
    public int solution(String dartResult) {
        String regex = "(10)|(\\d)";
        Matcher m = Pattern.compile(regex).matcher(dartResult);
        int[] scores = new int[3];
        int[] bonuses = new int[3];
        int[] options = new int[3];
        for (int i = 0; i < 3; ++i) {
            m.find();
            scores[i] = Integer.parseInt(m.group());
            switch (dartResult.charAt(m.end())) {
                case 'S':
                    bonuses[i] = 1;
                    break;
                case 'D':
                    bonuses[i] = 2;
                    break;
                case 'T':
                    bonuses[i] = 3;
                    break;
            }
            int optionIndex = m.end() + 1;
            if (optionIndex < dartResult.length()) {
                switch (dartResult.charAt(optionIndex)) {
                    case '*':
                        options[i] = 1;
                        break;
                    case '#':
                        options[i] = -1;
                        break;
                    default:
                        break;
                }
            }
        }
        int answer = 0;
        for (int i = 2; i >= 0; --i) {
            scores[i] = (int) Math.pow(scores[i], bonuses[i]);
        }
        for (int i = 2; i >= 0; --i) {
            if (options[i] == 1) {
                scores[i] *= 2;
                if (i > 0) {
                    scores[i - 1] *= 2;
                }
            } else if (options[i] == -1) {
                scores[i] *= -1;
            }
            answer += scores[i];
        }
        return answer;
    }
}

[Lv1] 비밀지도

현록 — Tue, 13 Apr 2021 14:40:23 +0900

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

코딩테스트 연습 - [1차] 비밀지도

비밀지도 네오는 평소 프로도가 비상금을 숨겨놓는 장소를 알려줄 비밀지도를 손에 넣었다. 그런데 이 비밀지도는 숫자로 암호화되어 있어 위치를 확인하기 위해서는 암호를 해독해야 한다. 다

programmers.co.kr

문제 설명

비밀지도

네오는 평소 프로도가 비상금을 숨겨놓는 장소를 알려줄 비밀지도를 손에 넣었다. 그런데 이 비밀지도는 숫자로 암호화되어 있어 위치를 확인하기 위해서는 암호를 해독해야 한다. 다행히 지도 암호를 해독할 방법을 적어놓은 메모도 함께 발견했다.

지도는 한 변의 길이가 n인 정사각형 배열 형태로, 각 칸은 "공백"(" ") 또는 "벽"("#") 두 종류로 이루어져 있다.
전체 지도는 두 장의 지도를 겹쳐서 얻을 수 있다. 각각 "지도 1"과 "지도 2"라고 하자. 지도 1 또는 지도 2 중 어느 하나라도 벽인 부분은 전체 지도에서도 벽이다. 지도 1과 지도 2에서 모두 공백인 부분은 전체 지도에서도 공백이다.
"지도 1"과 "지도 2"는 각각 정수 배열로 암호화되어 있다.
암호화된 배열은 지도의 각 가로줄에서 벽 부분을 1, 공백 부분을 0으로 부호화했을 때 얻어지는 이진수에 해당하는 값의 배열이다.

네오가 프로도의 비상금을 손에 넣을 수 있도록, 비밀지도의 암호를 해독하는 작업을 도와줄 프로그램을 작성하라.

입력 형식

입력으로 지도의 한 변 크기 n 과 2개의 정수 배열 arr1, arr2가 들어온다.

1 ≦ n ≦ 16
arr1, arr2는 길이 n인 정수 배열로 주어진다.
정수 배열의 각 원소 x를 이진수로 변환했을 때의 길이는 n 이하이다. 즉, 0 ≦ x ≦ 2n - 1을 만족한다.

출력 형식

원래의 비밀지도를 해독하여 '#', 공백으로 구성된 문자열 배열로 출력하라.

입출력 예제

매개변수	값
n	5
arr1	[9, 20, 28, 18, 11]
arr2	[30, 1, 21, 17, 28]
출력	["#####","# # #", "### #", "# ##", "#####"]

매개변수	값
n	6
arr1	[46, 33, 33 ,22, 31, 50]
arr2	[27 ,56, 19, 14, 14, 10]
출력	["######", "### #", "## ##", " #### ", " #####", "### # "]

class Solution {
    public static char[] intToBits(int number, int size) {
        StringBuilder stringBuilder = new StringBuilder();
        while (number > 1) {
            if (number % 2 == 0) {
                stringBuilder.append('0');
            } else {
                stringBuilder.append('1');
            }
            number /= 2;
            --size;
        }
        if (number == 1) {
            stringBuilder.append('1');
            --size;
        }
        for (int i = 0; i < size; ++i) {
            stringBuilder.append('0');
        }
        return stringBuilder.reverse().toString().toCharArray();
    }
    
    public String twoCharsToString(char[] arr1, char[] arr2) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < arr1.length; ++i) {
            if (arr1[i] == '1') {
                stringBuilder.append('#');
            } else if (arr2[i] == '1') {
                stringBuilder.append('#');
            } else {
                stringBuilder.append(' ');
            }
        }
        return stringBuilder.toString();
    }
    
    public String[] solution(int n, int[] arr1, int[] arr2) {
        String[] answer = new String[n];
        for (int i = 0; i < n; ++i) {
            answer[i] = twoCharsToString(intToBits(arr1[i], n), intToBits(arr2[i], n));
        }
        return answer;
    }
}

[Lv1] 크레인 인형뽑기 게임

현록 — Tue, 13 Apr 2021 14:04:19 +0900

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

코딩테스트 연습 - 크레인 인형뽑기 게임

[[0,0,0,0,0],[0,0,1,0,3],[0,2,5,0,1],[4,2,4,4,2],[3,5,1,3,1]] [1,5,3,5,1,2,1,4] 4

programmers.co.kr

문제 설명

게임개발자인 "죠르디"는 크레인 인형뽑기 기계를 모바일 게임으로 만들려고 합니다.

"죠르디"는 게임의 재미를 높이기 위해 화면 구성과 규칙을 다음과 같이 게임 로직에 반영하려고 합니다.

게임 화면은 "1 x 1" 크기의 칸들로 이루어진 "N x N" 크기의 정사각 격자이며 위쪽에는 크레인이 있고

오른쪽에는 바구니가 있습니다. (위 그림은 "5 x 5" 크기의 예시입니다).

각 격자 칸에는 다양한 인형이 들어 있으며 인형이 없는 칸은 빈칸입니다.

모든 인형은 "1 x 1" 크기의 격자 한 칸을 차지하며 격자의 가장 아래 칸부터 차곡차곡 쌓여 있습니다.

게임 사용자는 크레인을 좌우로 움직여서 멈춘 위치에서 가장 위에 있는 인형을 집어 올릴 수 있습니다.

집어 올린 인형은 바구니에 쌓이게 되는 데, 이때 바구니의 가장 아래 칸부터 인형이 순서대로 쌓이게 됩니다.

다음 그림은 [1번, 5번, 3번] 위치에서 순서대로 인형을 집어 올려 바구니에 담은 모습입니다.

만약 같은 모양의 인형 두 개가 바구니에 연속해서 쌓이게 되면 두 인형은 터뜨려지면서 바구니에서 사라지게 됩니다.

위 상태에서 이어서 [5번] 위치에서 인형을 집어 바구니에 쌓으면 같은 모양 인형 두 개가 없어집니다.

크레인 작동 시 인형이 집어지지 않는 경우는 없으나 만약 인형이 없는 곳에서 크레인을 작동시키는 경우에는

아무런 일도 일어나지 않습니다. 또한 바구니는 모든 인형이 들어갈 수 있을 만큼 충분히 크다고 가정합니다.

(그림에서는 화면표시 제약으로 5칸만으로 표현하였음)

게임 화면의 격자의 상태가 담긴 2차원 배열 board와

인형을 집기 위해 크레인을 작동시킨 위치가 담긴 배열 moves가 매개변수로 주어질 때,

크레인을 모두 작동시킨 후 터트려져 사라진 인형의 개수를 return 하도록 solution 함수를 완성해주세요.

[제한사항]

board 배열은 2차원 배열로 크기는 "5 x 5" 이상 "30 x 30" 이하입니다.
board의 각 칸에는 0 이상 100 이하인 정수가 담겨있습니다.
- 0은 빈 칸을 나타냅니다.
- 1 ~ 100의 각 숫자는 각기 다른 인형의 모양을 의미하며 같은 숫자는 같은 모양의 인형을 나타냅니다.
moves 배열의 크기는 1 이상 1,000 이하입니다.
moves 배열 각 원소들의 값은 1 이상이며 board 배열의 가로 크기 이하인 자연수입니다.

입출력 예

board	moves	result
[[0,0,0,0,0],[0,0,1,0,3],[0,2,5,0,1],[4,2,4,4,2],[3,5,1,3,1]]	[1,5,3,5,1,2,1,4]	4

입출력 예에 대한 설명

입출력 예 #1

인형의 처음 상태는 문제에 주어진 예시와 같습니다.

크레인이 [1, 5, 3, 5, 1, 2, 1, 4] 번 위치에서 차례대로 인형을 집어서 바구니에 옮겨 담은 후,

상태는 아래 그림과 같으며 바구니에 담는 과정에서 터트려져 사라진 인형은 4개 입니다.

import java.util.Stack;

class Solution {
    public int solution(int[][] board, int[] moves) {
        int answer = 0;
        Stack<Integer> stack = new Stack<>();
        for (int i = 0 ; i < moves.length; ++i) {
            for (int j = 0; j < board.length; ++j) {
                if (board[j][moves[i] - 1] != 0) {
                    int target = board[j][moves[i] - 1];
                    board[j][moves[i] - 1] = 0;
                    if (stack.isEmpty() == false) {
                        int prev = stack.peek();
                        if (prev == target) {
                            stack.pop();
                            answer += 2;
                            break;
                        }
                    }
                    stack.push(target);
                    break;
                }
            }
        }
        return answer;
    }
}

[Lv2] 이진 변환 반복하기

현록 — Mon, 12 Apr 2021 20:06:31 +0900

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

코딩테스트 연습 - 이진 변환 반복하기

programmers.co.kr

문제 설명

0과 1로 이루어진 어떤 문자열 x에 대한 이진 변환을 다음과 같이 정의합니다.

x의 모든 0을 제거합니다.
x의 길이를 c라고 하면, x를 "c를 2진법으로 표현한 문자열"로 바꿉니다.

예를 들어, x = "0111010"이라면, x에 이진 변환을 가하면 x = "0111010" -> "1111" -> "100" 이 됩니다.

0과 1로 이루어진 문자열 s가 매개변수로 주어집니다. s가 "1"이 될 때까지 계속해서 s에 이진 변환을 가했을 때, 이진 변환의 횟수와 변환 과정에서 제거된 모든 0의 개수를 각각 배열에 담아 return 하도록 solution 함수를 완성해주세요.

제한사항

s의 길이는 1 이상 150,000 이하입니다.
s에는 '1'이 최소 하나 이상 포함되어 있습니다.

입출력 예

s	result
"110010101001"	[3,8]
"01110"	[3,3]
"1111111"	[4,1]

입출력 예 설명

입출력 예 #1

"110010101001"이 "1"이 될 때까지 이진 변환을 가하는 과정은 다음과 같습니다.

회차	이진 변환 이전	제거할 0의 개수	0 제거 후 길이	이진 변환 결과
1	"110010101001"	6	6	"110"
2	"110"	1	2	"10"
3	"10"	1	1	"1"

3번의 이진 변환을 하는 동안 8개의 0을 제거했으므로, [3,8]을 return 해야 합니다.

입출력 예 #2

"01110"이 "1"이 될 때까지 이진 변환을 가하는 과정은 다음과 같습니다.

회차	이진 변환 이전	제거할 0의 개수	0 제거 후 길이	이진 변환 결과
1	"01110"	2	3	"11"
2	"11"	0	2	"10"
3	"10"	1	1	"1"

3번의 이진 변환을 하는 동안 3개의 0을 제거했으므로, [3,3]을 return 해야 합니다.

입출력 예 #3

"1111111"이 "1"이 될 때까지 이진 변환을 가하는 과정은 다음과 같습니다.

회차	이진 변환 이전	제거할 0의 개수	0 제거 후 길이	이진 변환 결과
1	"1111111"	0	7	"111"
2	"111"	0	3	"11"
3	"11"	0	2	"10"
4	"10"	1	1	"1"

4번의 이진 변환을 하는 동안 1개의 0을 제거했으므로, [4,1]을 return 해야 합니다.

public int[] solution(String s) {
    int[] answer = new int[2];
    while (true) {
        if (s.equals("1")) {
            break;
        }
        ++answer[0];
        char[] chars = s.toCharArray();
        int countOne = 0;
        for (int i = 0; i < chars.length; ++i) {
            if (chars[i] == '1') {
                ++countOne;
            }
        }
        answer[1] += (s.length() - countOne);
        StringBuilder stringBuilder = new StringBuilder();
        while (countOne > 1) {
            if (countOne % 2 == 0) {
                stringBuilder.append('0');
            } else {
                stringBuilder.append('1');
            }
            countOne /= 2;
        }
        if (countOne == 1) {
            stringBuilder.append('1');
        }
        s = stringBuilder.reverse().toString();
    }
    return answer;
}

[Lv2] 멀쩡한 사각형

현록 — Mon, 12 Apr 2021 20:01:34 +0900

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

코딩테스트 연습 - 멀쩡한 사각형

가로 길이가 Wcm, 세로 길이가 Hcm인 직사각형 종이가 있습니다. 종이에는 가로, 세로 방향과 평행하게 격자 형태로 선이 그어져 있으며, 모든 격자칸은 1cm x 1cm 크기입니다. 이 종이를 격자 선을

programmers.co.kr

문제 설명

가로 길이가 Wcm, 세로 길이가 Hcm인 직사각형 종이가 있습니다.

종이에는 가로, 세로 방향과 평행하게 격자 형태로 선이 그어져 있으며, 모든 격자칸은 1cm x 1cm 크기입니다.

이 종이를 격자 선을 따라 1cm × 1cm의 정사각형으로 잘라 사용할 예정이었는데,

누군가가 이 종이를 대각선 꼭지점 2개를 잇는 방향으로 잘라 놓았습니다.

그러므로 현재 직사각형 종이는 크기가 같은 직각삼각형 2개로 나누어진 상태입니다.

새로운 종이를 구할 수 없는 상태이기 때문에,

이 종이에서 원래 종이의 가로, 세로 방향과 평행하게 1cm × 1cm로 잘라 사용할 수 있는 만큼만 사용하기로 하였습니다.

가로의 길이 W와 세로의 길이 H가 주어질 때, 사용할 수 있는 정사각형의 개수를 구하는 solution 함수를 완성해 주세요.

제한사항

W, H : 1억 이하의 자연수

입출력 예

W	H	result
8	12	80

입출력 예 설명

입출력 예 #1

가로가 8, 세로가 12인 직사각형을 대각선 방향으로 자르면 총 16개 정사각형을 사용할 수 없게 됩니다.

원래 직사각형에서는 96개의 정사각형을 만들 수 있었으므로, 96 - 16 = 80 을 반환합니다.

public static long solution(int w, int h) {
    int high = Math.max(w, h);
    int low = Math.min(w, h);
    int size_high = 1;
    int size_low = 1;    // 정사각형이면 1:1 비율
    if (high > low) {
        // 정사각형이면 최대공약수는 같은 수인 그 자신, 아니면 구하기
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(Collections.reverseOrder());
        for (int i = low; i >= 1; --i) {
            if (low % i == 0) {
                priorityQueue.add(i);
            }
        }
        int commonDivisor = low;
        for (Integer divisor : priorityQueue) {
            if (high % divisor == 0) {
                commonDivisor = divisor;
                break;
            }
        }
        // 직사각형의 축소판의 길이를 구함.
        // 편의상 low를 가로로, high를 세로로 보고, 항상 위로 길쭉한 직사각형을 떠올리기로 함.
        size_high = high / commonDivisor;
        size_low = low / commonDivisor;
    }
    float slope = ((float) size_high) / size_low;    // y = ax + c의 1차 함수 모델에서, y절편(c)이 0인 모델을 떠올려 봄.
    long trash = 0;
    int prevY = 0;
    // size_low는 반드시 size_high보다 작으며(위로 긴 모델),
    // x가 size_low에 도달하면, y역시 size_high에 도달하며, 이는 반드시 정수임.
    // x가 0~1인 구간부터 보기로 하며,
    // 마지막 size_low는 반복문 아래에서 따로 계산한다. (1:1 정사각형 모델도 그냥 반복문 건너뛰고 계산되도록)
    for (int x = 1; x < size_low; ++x) {
        int y = (int) (slope * x);    // y의 소수점 자리를 버린다.
        // 소수점을 버리기 전의 y는 반복문 안에서 반드시 정수가 되지 못한다.
        // 최대공약수 특성상, y가 최초로 정수가 되는 곳은 x의 끝인 size_low이다.
        // (이 구간의 y는 항상 *.*가 된다.)
        // 즉, 이 구간은 y와 prevY의 차이에서 1씩 더하여도 반드시 성립한다.
        // 0.~라서 아직 한 칸을 못 넘었어도 왼쪽과 같은 진척도라 1칸을 차지하고,
        // 1.~라서 한 칸을 넘었어도, 넘은 칸과 이번 소수점 자리 1칸을 차지한다.
        trash += (y - prevY + 1);
        prevY = y;
    }
    // 처음으로 x와 y가 모두 함께 정수가 되는 종료구간.
    // prevY는 이전에서 소수점 자리를 버린채 낮아진 상태이기 때문에,
    // size_high와의 차이는 반드시 넘은 칸과 소수점 자리 모두 포함한다.
    trash += (size_high - prevY);
    // 위는 size_low와 size_high의 축소형 모델이었고,
    // 실제 직사각형은 최대공약수를 곱한만큼이므로, 곱하면 버리는 픽셀 수를 알 수 있다.
    trash *= (low / size_low);
    // 최종적으로 구하고자 하는 값은 모든 픽셀 중 버리는 픽셀 수.
    return ((long) w) * h - trash;
}

[Lv2] 삼각 달팽이

현록 — Mon, 12 Apr 2021 19:57:07 +0900

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

코딩테스트 연습 - 삼각 달팽이

5 [1,2,12,3,13,11,4,14,15,10,5,6,7,8,9] 6 [1,2,15,3,16,14,4,17,21,13,5,18,19,20,12,6,7,8,9,10,11]

programmers.co.kr

문제 설명

정수 n이 매개변수로 주어집니다.

다음 그림과 같이 밑변의 길이와 높이가 n인 삼각형에서 맨 위 꼭짓점부터 반시계 방향으로 달팽이 채우기를 진행한 후,

첫 행부터 마지막 행까지 모두 순서대로 합친 새로운 배열을 return 하도록 solution 함수를 완성해주세요.

제한사항

n은 1 이상 1,000 이하입니다.

입출력 예

n	result
4	[1,2,9,3,10,8,4,5,6,7]
5	[1,2,12,3,13,11,4,14,15,10,5,6,7,8,9]
6	[1,2,15,3,16,14,4,17,21,13,5,18,19,20,12,6,7,8,9,10,11]

입출력 예 설명

입출력 예 #1

문제 예시와 같습니다.

입출력 예 #2

문제 예시와 같습니다.

입출력 예 #3

문제 예시와 같습니다.

public int[] solution(int n) {
    int[][] triangle = new int[n][];
    for (int i = 0; i < n; ++i) {
        triangle[i] = new int[i + 1];
        triangle[i][0] = i + 1;
    }
    for (int i = 1; i < n; ++i) {
        triangle[n - 1][i] = n + i;
    }
    int number = n * 2;
    int end = 0;
    for (int i = n; i > 0; --i) {
        end += i;
    }
    int y = n - 1;
    int x = y;
    while (number <= end) {
        while (true) {
            if (triangle[y - 1][x - 1] != 0) {
                break;
            }
            --y;
            --x;
            triangle[y][x] = number++;
        }
        if (number > end) {
            break;
        }
        while (true) {
            if (triangle[y + 1][x] != 0) {
                break;
            }
            ++y;
            triangle[y][x] = number++;
        }
        if (number > end) {
            break;
        }
        while (true) {
            if (triangle[y][x + 1] != 0) {
                break;
            }
            ++x;
            triangle[y][x] = number++;
        }
    }
    int[] answer = new int[end];
    int index = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j <= i; ++j) {
            answer[index++] = triangle[i][j];
        }
    }
    return answer;
}

[Lv2] 괄호 변환

현록 — Mon, 12 Apr 2021 19:54:23 +0900

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

코딩테스트 연습 - 괄호 변환

카카오에 신입 개발자로 입사한 "콘"은 선배 개발자로부터 개발역량 강화를 위해 다른 개발자가 작성한 소스 코드를 분석하여 문제점을 발견하고 수정하라는 업무 과제를 받았습니다. 소스를

programmers.co.kr

문제 설명

카카오에 신입 개발자로 입사한 "콘"은 선배 개발자로부터 개발역량 강화를 위해 다른 개발자가 작성한 소스 코드를 분석하여 문제점을 발견하고 수정하라는 업무 과제를 받았습니다. 소스를 컴파일하여 로그를 보니 대부분 소스 코드 내 작성된 괄호가 개수는 맞지만 짝이 맞지 않은 형태로 작성되어 오류가 나는 것을 알게 되었습니다.

수정해야 할 소스 파일이 너무 많아서 고민하던 "콘"은 소스 코드에 작성된 모든 괄호를 뽑아서 올바른 순서대로 배치된 괄호 문자열을 알려주는 프로그램을 다음과 같이 개발하려고 합니다.

용어의 정의

'(' 와 ')' 로만 이루어진 문자열이 있을 경우, '(' 의 개수와 ')' 의 개수가 같다면 이를 균형잡힌 괄호 문자열이라고 부릅니다.

그리고 여기에 '('와 ')'의 괄호의 짝도 모두 맞을 경우에는 이를 올바른 괄호 문자열이라고 부릅니다.

예를 들어, "(()))("와 같은 문자열은 "균형잡힌 괄호 문자열" 이지만 "올바른 괄호 문자열"은 아닙니다.

반면에 "(())()"와 같은 문자열은 "균형잡힌 괄호 문자열" 이면서 동시에 "올바른 괄호 문자열" 입니다.

'(' 와 ')' 로만 이루어진 문자열 w가 "균형잡힌 괄호 문자열" 이라면 다음과 같은 과정을 통해 "올바른 괄호 문자열"로 변환할 수 있습니다.

1. 입력이 빈 문자열인 경우, 빈 문자열을 반환합니다. 2. 문자열 w를 두 "균형잡힌 괄호 문자열" u, v로 분리합니다. 단, u는 "균형잡힌 괄호 문자열"로 더 이상 분리할 수 없어야 하며, v는 빈 문자열이 될 수 있습니다. 3. 문자열 u가 "올바른 괄호 문자열" 이라면 문자열 v에 대해 1단계부터 다시 수행합니다. 3-1. 수행한 결과 문자열을 u에 이어 붙인 후 반환합니다. 4. 문자열 u가 "올바른 괄호 문자열"이 아니라면 아래 과정을 수행합니다. 4-1. 빈 문자열에 첫 번째 문자로 '('를 붙입니다. 4-2. 문자열 v에 대해 1단계부터 재귀적으로 수행한 결과 문자열을 이어 붙입니다. 4-3. ')'를 다시 붙입니다. 4-4. u의 첫 번째와 마지막 문자를 제거하고, 나머지 문자열의 괄호 방향을 뒤집어서 뒤에 붙입니다. 4-5. 생성된 문자열을 반환합니다.

"균형잡힌 괄호 문자열" p가 매개변수로 주어질 때, 주어진 알고리즘을 수행해 "올바른 괄호 문자열"로 변환한 결과를 return 하도록 solution 함수를 완성해 주세요.

매개변수 설명

p는 '(' 와 ')' 로만 이루어진 문자열이며 길이는 2 이상 1,000 이하인 짝수입니다.
문자열 p를 이루는 '(' 와 ')' 의 개수는 항상 같습니다.
만약 p가 이미 "올바른 괄호 문자열"이라면 그대로 return 하면 됩니다.

입출력 예

p	result
"(()())()"	"(()())()"
")("	"()"
"()))((()"	"()(())()"

입출력 예에 대한 설명

입출력 예 #1

이미 "올바른 괄호 문자열" 입니다.

입출력 예 #2

두 문자열 u, v로 분리합니다.
- u = ")("
- v = ""
u가 "올바른 괄호 문자열"이 아니므로 다음과 같이 새로운 문자열을 만듭니다.
- v에 대해 1단계부터 재귀적으로 수행하면 빈 문자열이 반환됩니다.
- u의 앞뒤 문자를 제거하고, 나머지 문자의 괄호 방향을 뒤집으면 ""이 됩니다.
- 따라서 생성되는 문자열은 "(" + "" + ")" + ""이며, 최종적으로 "()"로 변환됩니다.

입출력 예 #3

두 문자열 u, v로 분리합니다.
- u = "()"
- v = "))((()"
문자열 u가 "올바른 괄호 문자열"이므로 그대로 두고, v에 대해 재귀적으로 수행합니다.
다시 두 문자열 u, v로 분리합니다.
- u = "))(("
- v = "()"
u가 "올바른 괄호 문자열"이 아니므로 다음과 같이 새로운 문자열을 만듭니다.
- v에 대해 1단계부터 재귀적으로 수행하면 "()"이 반환됩니다.
- u의 앞뒤 문자를 제거하고, 나머지 문자의 괄호 방향을 뒤집으면 "()"이 됩니다.
- 따라서 생성되는 문자열은 "(" + "()" + ")" + "()"이며, 최종적으로 "(())()"를 반환합니다.
처음에 그대로 둔 문자열에 반환된 문자열을 이어 붙이면 "()" + "(())()" = "()(())()"가 됩니다.

class Solution {
    public String solution(String p) {
        StringBuilder stringBuilder = new StringBuilder();
        int index = 0;
        int openClose = 0;
        int count = 0;
        int secondStartIndex = -1;
        while (index < p.length()) {
            if (p.charAt(index) == '(') {
                ++count;
                ++openClose;
            } else {
                --openClose;
            }
            if (openClose == 0) {
                secondStartIndex = index + 1;
                break;
            }
            ++index;
        }
        boolean isFirstPerfect = true;
        index = 0;
        openClose = 0;
        while (index < secondStartIndex) {
            if (p.charAt(index) == '(') {
                ++openClose;
            } else {
                --openClose;
            }
            if (openClose < 0) {
                isFirstPerfect = false;
                break;
            }
            ++index;
        }
        if (isFirstPerfect == true) {
            stringBuilder.append(p, 0, secondStartIndex);
            if (secondStartIndex < p.length()) {
                stringBuilder.append(solution(p.substring(secondStartIndex)));
            }
            return stringBuilder.toString();
        } else {
            stringBuilder.append('(');
            if (secondStartIndex < p.length()) {
                stringBuilder.append(solution(p.substring(secondStartIndex)));
            }
            stringBuilder.append(')');
            index = 1;
            while (index < secondStartIndex - 1) {
                if (p.charAt(index) == '(') {
                    stringBuilder.append(')');
                } else {
                    stringBuilder.append('(');
                }
                ++index;
            }
            return stringBuilder.toString();
        }
    }
}

[Lv1] 신규 아이디 추천

현록 — Mon, 12 Apr 2021 19:52:05 +0900

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

코딩테스트 연습 - 신규 아이디 추천

카카오에 입사한 신입 개발자 네오는 "카카오계정개발팀"에 배치되어, 카카오 서비스에 가입하는 유저들의 아이디를 생성하는 업무를 담당하게 되었습니다. "네오"에게 주어진 첫 업무는 새로

programmers.co.kr

문제 설명

카카오에 입사한 신입 개발자 네오는 "카카오계정개발팀"에 배치되어, 카카오 서비스에 가입하는 유저들의 아이디를 생성하는 업무를 담당하게 되었습니다. "네오"에게 주어진 첫 업무는 새로 가입하는 유저들이 카카오 아이디 규칙에 맞지 않는 아이디를 입력했을 때, 입력된 아이디와 유사하면서 규칙에 맞는 아이디를 추천해주는 프로그램을 개발하는 것입니다.

다음은 카카오 아이디의 규칙입니다.

아이디의 길이는 3자 이상 15자 이하여야 합니다.
아이디는 알파벳 소문자, 숫자, 빼기(-), 밑줄(_), 마침표(.) 문자만 사용할 수 있습니다.
단, 마침표(.)는 처음과 끝에 사용할 수 없으며 또한 연속으로 사용할 수 없습니다.

"네오"는 다음과 같이 7단계의 순차적인 처리 과정을 통해 신규 유저가 입력한 아이디가 카카오 아이디 규칙에 맞는 지 검사하고 규칙에 맞지 않은 경우 규칙에 맞는 새로운 아이디를 추천해 주려고 합니다.

신규 유저가 입력한 아이디가 new_id 라고 한다면,

1단계 new_id의 모든 대문자를 대응되는 소문자로 치환합니다. 2단계 new_id에서 알파벳 소문자, 숫자, 빼기(-), 밑줄(_), 마침표(.)를 제외한 모든 문자를 제거합니다. 3단계 new_id에서 마침표(.)가 2번 이상 연속된 부분을 하나의 마침표(.)로 치환합니다. 4단계 new_id에서 마침표(.)가 처음이나 끝에 위치한다면 제거합니다. 5단계 new_id가 빈 문자열이라면, new_id에 "a"를 대입합니다. 6단계 new_id의 길이가 16자 이상이면, new_id의 첫 15개의 문자를 제외한 나머지 문자들을 모두 제거합니다. 만약 제거 후 마침표(.)가 new_id의 끝에 위치한다면 끝에 위치한 마침표(.) 문자를 제거합니다. 7단계 new_id의 길이가 2자 이하라면, new_id의 마지막 문자를 new_id의 길이가 3이 될 때까지 반복해서 끝에 붙입니다.

예를 들어, new_id 값이 "...!@BaT#*..y.abcdefghijklm" 라면, 위 7단계를 거치고 나면 new_id는 아래와 같이 변경됩니다.

1단계 대문자 'B'와 'T'가 소문자 'b'와 't'로 바뀌었습니다.

"...!@BaT#*..y.abcdefghijklm" → "...!@bat#*..y.abcdefghijklm"

2단계 '!', '@', '#', '*' 문자가 제거되었습니다.

"...!@bat#*..y.abcdefghijklm" → "...bat..y.abcdefghijklm"

3단계 '...'와 '..' 가 '.'로 바뀌었습니다.

"...bat..y.abcdefghijklm" → ".bat.y.abcdefghijklm"

4단계 아이디의 처음에 위치한 '.'가 제거되었습니다.

".bat.y.abcdefghijklm" → "bat.y.abcdefghijklm"

5단계 아이디가 빈 문자열이 아니므로 변화가 없습니다.

"bat.y.abcdefghijklm" → "bat.y.abcdefghijklm"

6단계 아이디의 길이가 16자 이상이므로, 처음 15자를 제외한 나머지 문자들이 제거되었습니다.

"bat.y.abcdefghijklm" → "bat.y.abcdefghi"

7단계 아이디의 길이가 2자 이하가 아니므로 변화가 없습니다.

"bat.y.abcdefghi" → "bat.y.abcdefghi"

따라서 신규 유저가 입력한 new_id가 "...!@BaT#*..y.abcdefghijklm"일 때, 네오의 프로그램이 추천하는 새로운 아이디는 "bat.y.abcdefghi" 입니다.

[문제]

신규 유저가 입력한 아이디를 나타내는 new_id가 매개변수로 주어질 때, "네오"가 설계한 7단계의 처리 과정을 거친 후의 추천 아이디를 return 하도록 solution 함수를 완성해 주세요.

[제한사항]

new_id는 길이 1 이상 1,000 이하인 문자열입니다.

new_id는 알파벳 대문자, 알파벳 소문자, 숫자, 특수문자로 구성되어 있습니다.

new_id에 나타날 수 있는 특수문자는 -_.~!@#$%^&*()=+[{]}:?,<>/ 로 한정됩니다.

[입출력 예]

no	new_id	result
예1	"...!@BaT#*..y.abcdefghijklm"	"bat.y.abcdefghi"
예2	"z-+.^."	"z--"
예3	"=.="	"aaa"
예4	"123_.def"	"123_.def"
예5	"abcdefghijklmn.p"	"abcdefghijklmn"

입출력 예에 대한 설명

입출력 예 #1

문제의 예시와 같습니다.

입출력 예 #2

7단계를 거치는 동안 new_id가 변화하는 과정은 아래와 같습니다.

1단계 변화 없습니다.

2단계 "z-+.^." → "z-.."

3단계 "z-.." → "z-."

4단계 "z-." → "z-"

5단계 변화 없습니다.

6단계 변화 없습니다.

7단계 "z-" → "z--"

입출력 예 #3

7단계를 거치는 동안 new_id가 변화하는 과정은 아래와 같습니다.

1단계 변화 없습니다.

2단계 "=.=" → "."

3단계 변화 없습니다.

4단계 "." → "" (new_id가 빈 문자열이 되었습니다.)

5단계 "" → "a"

6단계 변화 없습니다.

7단계 "a" → "aaa"

입출력 예 #4

1단계에서 7단계까지 거치는 동안 new_id("123_.def")는 변하지 않습니다. 즉, new_id가 처음부터 카카오의 아이디 규칙에 맞습니다.

입출력 예 #5

1단계 변화 없습니다.

2단계 변화 없습니다.

3단계 변화 없습니다.

4단계 변화 없습니다.

5단계 변화 없습니다.

6단계 "abcdefghijklmn.p" → "abcdefghijklmn." → "abcdefghijklmn"

7단계 변화 없습니다.

class Solution {
    public String solution(String new_id) {
        String answer = new_id.toLowerCase();
        answer = answer.replaceAll("[^a-z0-9-_.]", "");
        answer = answer.replaceAll("\\.{2,}", ".");
        answer = answer.replaceAll("^\\.|\\.$", "");
        if (answer.equals("")) {
            answer = "a";
        } else if (answer.length() > 15) {
            answer = answer.substring(0, 15);
            answer = answer.replaceAll("\\.$", "");
        }
        while (answer.length() < 3) {
            answer = answer + answer.substring(answer.length() - 1);
        }
        return answer;
    }
}