Midnight Coder's Lounge

[JavaScript] .slice()에 음수를 넣을 땐 0을 조심하세요 (백준 18110 solved.ac 3% 반례)

AtomicLiquors — Thu, 20 Feb 2025 13:48:32 +0900

요약

- 배열을 자르는 메서드에 .slice(-N), .splice(-N)처럼 음수 인덱스를 넣으면, 배열 맨 끝에서 N번째 항목을 가리키게 할 수 있다.

- 하지만 N = 0이라면? 배열 맨 끝이 아니라 맨 처음을 가리키게 된다. .slice(-N) = .slice(-0) = .slice(0)이기 때문이다.

상세

JavaScript로 백준 18110번 문제 "solved.ac"를 풀고 있었습니다. 주어진 N의 15%에 해당하는 갯수만큼 배열에서 최댓값 / 최솟값을 각각 제외하고 나머지 수들에 대해 평균을 내는 문제입니다. 그렇기 때문에 입력받은 배열을 정렬하고, N의 15%에 해당하는 값(변수명 offset)만큼 배열의 앞뒤에서 slice하는 방식으로 문제를 풀고자 합니다.

따라서 다음과 같이 코드를 작성했습니다.

/* 오답 코드 */
const fs = require('fs');
const input = fs.readFileSync(0, 'utf-8').trim().split('\\n');

const N = Number(input[0]);
if(N === 0){
    console.log(0);
    return;
}
    
const offset = Math.round(N * 0.15);
const difficulties = input.slice(1, N+1).map(Number).sort((a, b) => a - b);
const sliced = difficulties.slice(offset, -offset);
const sum = sliced.reduce((acc, e) => acc + e, 0);
console.log(Math.round(sum / (N - offset * 2)));

[제출 결과]

3%에서 오답이 나옵니다.

반올림 연산을 잘못한 건가? 평균값을 잘못 구한 건가?
한참 엉뚱한 데서 반례를 찾다가 결국 아래 코드에 문제가 있다는 걸 알게 되었습니다.

const sliced = difficulties.slice(offset, -offset);

N의 15%가 0이 되는 경우 변수 offset의 값은 0이 됩니다.
예를 들면, 다음과 같이 N이 3인 반례를 들 수 있겠습니다.

[반례]

[정답]

2 // slice의 결과는 [1, 2, 3]이 되고 출력 결과는 (1 + 2 + 3) / 3 = 2가 되어야 한다.

[오답]

0 // slice의 결과는 빈 배열 []이 되고 출력 결과는 0으로 나오고 있다.

원래 구상했던 로직대로라면 배열의 앞뒤에서 0만큼을 제외하고 나머지 부분에 대해 평균을 구해야 합니다.

문제는 offset의 값이 0이 되면 .slice(offset, -offset) 은 .slice(0, -0) ⇒ .slice(0, 0) 이 되어 버린다는 겁니다. "배열의 앞에서 0만큼 떨어져서 출발, 뒤에서 0만큼 떨어져서 끝"이 아니라, 그냥 0에서 시작해서 0에서 끝나 버리는 겁니다.

따라서 .slice(offset, -offset) 의 결과는 빈 배열 []가 되어 버립니다.

그렇기 때문에 문제가 되는 코드를 아래와 같이 고쳐야 합니다. 배열 길이인 N에서 offset을 뺀 값, 다시 말해 배열 끝에서 N만큼 떨어진 지점을 사용하겠다는 것을 JavaScript에게 확실하게 알려줘야 합니다.

const sliced = difficulties.slice(offset, N - offset); //-offset에서 N-offset으로 수정.

/* 정답 코드 */
const fs = require('fs');
const input = fs.readFileSync(0, 'utf-8').trim().split('\\n');

const N = Number(input[0]);
if(N === 0){
    console.log(0);
    return;
}
    
const offset = Math.round(N * 0.15);
const difficulties = input.slice(1, N+1).map(Number).sort((a, b) => a - b);
const sliced = difficulties.slice(offset, N - offset)
const sum = sliced.reduce((acc, e) => acc + e, 0);
console.log(Math.round(sum / (N - offset * 2)));

[제출 결과]

저는 한참 헤맸지만 멋쟁이 개발자이신 여러분은 이런 실수 때문에 버그를 내는 일이 없기를 바랍니다.

[JavaScript][백준] 객체는 틀리고, Set은 맞는 이유 (백준 25192번 node.js 풀이 75% 반례)

AtomicLiquors — Sat, 15 Feb 2025 16:15:16 +0900

요약

JavaScript 객체에는 기본적으로 ‘constructor’, ‘toString’ 등 특정한 key에 해당하는 값이 존재한다.
따라서 객체를 사용해서 문제를 푼 경우, 문자열 ‘constructor’, ‘toString’ 등이 포함된 히든 케이스를 만나면 틀린 답을 출력할 수 있다.

const obj = {};

console.log(obj['constructor']);
console.log(obj['toString']);

출력 결과

[Function: Object]
[Function: toString]
// 선언만 하고 아직 아무 값도 넣지 않았는데, 이미 뭔가 들어있는 이유가 뭘까요?

상세

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

node.js로 백준 25192번 문제 ‘인사성 밝은 곰곰이’를 풀고 있었습니다.

이번 문제를 풀기 위해선 “새로운 값이면 갯수를 세고, 이미 저장된 값이면 지나가는” 로직이 필요합니다.

key-value 형태의 자료구조(Map, Set)를 사용하는 문제입니다.

그런데 이번에는 JavaScript의 객체를 활용해서 풀어보기로 했습니다.

객체도 key-value 형태고, 선언도 키 값 접근도 간단한 코드로 가능하고, 무엇보다 Set과는 다르게 ES6부터 존재해 왔기 때문에 근본도 넘칩니다.

/* 순수 객체를 사용한 key-value 접근. */
const obj = {};

obj['myKey'] = 'myValue';
console.log(obj['myKey']); // 출력 결과 : myValue;

JavaScript에서는 특정 값이 null 이나 undefined 와 같은 값(흔히 말하는 ‘falsy’한 값)은 조건문이나 논리 연산자를 만나면 false 로 형변환이 됩니다.

이번 문제에서도 이러한 성질을 이용해 아래와 같은 로직을 작성했습니다.

/* 오답 코드 */
const fs = require("fs");
const input = fs.readFileSync(0, 'utf-8').trim().split('\n');

let obj = null;
let count = 0;

for(line of input.slice(1)){
    const key = line.trim();
    if(key === 'ENTER')
        obj = {}; 
        // 'ENTER'가 입력될 때마다 새로운 객체로 초기화한다.
    else if(!obj[key]){
		    // 입력받은 문자열이 객체에 key로 저장되어 있는지 확인한다.
		    // 존재하지 않을 경우에만 count를 1 증가시키고, 객체에 문자열을 key로 저장한다.
        obj[key] = true;
        count++;
    }    
}

console.log(count);

그런데 틀렸네요.

채점할 때마다 쭉 정답이 나오다가 75%에서 “틀렸습니다”로 끝납니다.

그렇다면 로직 자체가 틀리지는 않았고, 반례가 있는 것 같습니다.

왜 틀렸을까?

input에 해당하는 문자열 중에 특정한 문자열이 포함되어 있다면 오답이 발생합니다.
‘constructor’가 포함된 테스트 케이스를 작성해 보겠습니다.

5
ENTER
constructor
abc
def
ghi

출력 결과

문제가 의도한 대로라면 constructor, abc, def, ghi가 입력될 때마다 정답이 1씩 증가해야 합니다.
따라서 정답은 4여야 합니다.

그런데 막상 코드를 실행하면, 출력 결과는 엉뚱하게 3이 나오죠.

이렇게 되는 이유는 JavaScript 객체에 기본적으로 ‘constructor’라는 key에 해당하는 값이 존재하기 때문입니다.

아래와 같이 새 객체 obj를 생성하고, constructor라는 key에 대응하는 값이 있는지 콘솔로 출력해 보겠습니다.

const obj = {};

console.log(obj['constructor']);

출력 결과

[Function: Object]

Object라는 이름을 가진 함수가 존재한다는 출력 결과가 나옵니다.

이 값은 null 이나 undefined , 0과 같이 boolean으로 변환 시 false 가 되는(falsy한) 값이 아닙니다.

따라서 ! 연산자를 만나면 의도하지 않은 결과를 얻게 됩니다.

const obj = {};
console.log(!obj['abc']); // 임의의 문자열을 키로 사용
console.log(!obj['constructor']); // 'constructor'를 키로 사용

출력 결과

true
// !obj['constructor'] => !undefined => !false => true가 됩니다. 
false
// !obj['constructor'] => !(function Object(){...}) => !true => false가 됩니다.

따라서 우리가 사용했던 것처럼 !obj['...'] 를 사용해 분기처리를 하는 조건문은, 이렇게 특정 문자열이 포함된 반례를 만나서 오답을 출력했던 것입니다.

올바른 풀이

1. JavaScript의 Set을 사용하기

정석대로 JavaScript의 Set을 사용하는 풀이방법입니다.

/* 정답 코드 */
const fs = require("fs");
const input = fs.readFileSync(0, 'utf-8').trim().split('\\n');

let set = new Set();
let count = 0;

for(line of input.slice(1)){
    
    const key = line.trim();
    if(key === 'ENTER')
        set = new Set();
    else if(!set.has(key)){
        set.add(key);
        count++;
    }
}

console.log(count);

하지만 아래와 같은 방법들을 사용하면, 그대로 객체를 사용하면서 문제를 푸는 것도 가능합니다.

2. 객체의 key마다 임의의 값을 넣고, 일치여부에 따라 참거짓 판별하기

obj에 key에 해당하는 값이 들어있는지 여부가 아니라, 들어있는 값이 지정한 값과 정확히 일치하는지를 확인하여 보다 정확하게 조건을 판단할 수 있습니다.

const fs = require("fs");
const input = fs.readFileSync(0, 'utf-8').trim().split('\\n');

let obj = null;
let count = 0;

for (line of input.slice(1)) {
    const key = line.trim();
    if (key === 'ENTER')
        obj = {};
    else if (obj[key] !== true) {
		    // 자동 형변환이 일어나지 않도록 !=가 아니라 !==를 사용해야 합니다.
        obj[key] = true;
        count++;
    }
}

console.log(count);

3. {} 대신 Object.create(null)로 객체 생성하기

Object.create(null) 을 사용하면 constructor가 존재하지 않는, 진정한 의미로 비어 있는 객체를 생성할 수 있습니다. 따라서 처음에 의도했던 대로 코드가 동작하는 것을 확인할 수 있습니다.

const fs = require("fs");
const input = fs.readFileSync(0, 'utf-8').trim().split('\\n');

let obj = null;
let count = 0;

for (line of input.slice(1)) {
    const key = line.trim();
    if (key === 'ENTER')
        obj = Object.create(null);
    else if (!obj[key]) {
        obj[key] = true;
        count++;
    }
}

console.log(count);

왜 저런 key와 value가 들어있나요?

JavaScript는 프로토타입(Prototype) 기반의 객체지향 언어입니다.

프로토타입이란 새로운 객체를 생성할 때 원본 역할을 하는, JavaScript 언어에서 이미 만들어 놓은 객체입니다.

일반적으로 JavaScript의 객체는 Object 라는 이름을 가진 프로토타입을 원본으로 만들어지고, Object 라는 프로토타입이 가진 속성(프로퍼티)들을 물려받게 됩니다. (좀 더 구체적으로 말하자면 원본 프로토타입이 가진 속성들을 참조할 수 있게 됩니다.)

다음과 같이 코드를 쳐 보면 어떤 속성들을 물려받게 되는지 확인할 수 있습니다.

console.log(Object.getOwnPropertyNames(Object.prototype));
// Object의 프로토타입에 어떤 속성이 들어있는지 확인해 보겠습니다.

출력 결과

[
  'constructor',
  '__defineGetter__',
  '__defineSetter__',
  'hasOwnProperty',
  '__lookupGetter__',
  '__lookupSetter__',
  'isPrototypeOf',
  'propertyIsEnumerable',
  'toString',
  'valueOf',
  '__proto__',
  'toLocaleString'
]

앞서 예시로 들었던 constructor, toString 등이 포함되어 있는 것을 확인할 수 있습니다.

JavaScript에서는 이렇게 물려받은 속성들도 [] 연산자로 접근할 수 있습니다. 따라서 새 객체 obj를 생성하고 아무것도 넣지 않았는데도, obj[ ] 안에 위와 같은 값들이 존재하는 것을 확인할 수 있습니다.

const obj = {};

console.log(
    obj['constructor']
);

console.log(
    obj['__proto__']
);

console.log(
    obj['toString']
);

출력 결과

[Function: Object]
[Object: null prototype] {}
[Function: toString]

25192번 문제에서 주어진 제약사항은 “닉네임은 숫자 또는 영문 대소문자로 구성되어 있다”라는 것입니다. 공교롭게도 constructor, toString과 같은 프로퍼티는 영문 대소문자로만 구성되어 있고 따라서 반례가 될 수 있었던 것입니다.

Object.create(null)을 사용하면?

3번 풀이에서 Object.create(null) 을 사용해서 반례를 해결했습니다.

Object.create(null) 을 사용하면, 아무 프로토타입도 상속받지 않은 텅 빈 객체를 만들게 됩니다.
(어려운 말로 프로토타입 체인이 없는 순수한 객체를 생성하게 됩니다.)

console.log(Object.getOwnPropertyNames(Object.create(null)));
// Object.create(null)에 어떤 속성이 들어있는지 확인해 보겠습니다.

출력 결과

[]
// 아무 속성도 들어있지 않아 텅 빈 배열이 출력됩니다.

하지만 공식 문서에 따르면 Object.create(null) 이 코드는 실무에 적합한 코드는 아닙니다. Object 의 프로토타입을 상속한 게 아니기 때문에, 일반적인 객체가 갖고 있는 기능이 없기 때문입니다. 그래서 오히려 실무에서 오작동할 가능성도 높고, 디버깅도 어렵습니다.

"An object with a null prototype can behave in unexpected ways, because it doesn't inherit any object methods from Object.prototype. This is especially true when debugging, since common object-property converting/detecting utility functions may generate errors, or lose information (especially if using silent error-traps that ignore errors)."

— mdn web docs

예를 들어서 Object.create(null) 로 만든 객체에 toString() 을 사용하면 에러가 발생합니다.

const normalObj = {}; // 일반적인 객체
const nullProtoObj = Object.create(null); // Object.create(null)로 만든 객체

console.log(normalObj); // 출력 결과 : "[object Object]"
console.log(nullProtoObj); // 에러 발생: Cannot convert object to primitive value

참고자료

이번 게시글 작성하는 데 가장 큰 도움을 주신 백준 @wizardrabbit님께 감사드립니다.

https://www.acmicpc.net/board/view/156013

본문 2번, 3번 풀이는 아래 질의내용을 보고 참고했습니다. (유사한 문제인 백준 1764번 듣보잡 문제에 관한 질의내용입니다.)

https://www.acmicpc.net/board/view/150855

Object 및 프로토타입과 관련된 내용은 아래 공식 문서를 참고했습니다.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object#null-prototype_objects

Object - JavaScript | MDN

The Object type represents one of JavaScript's data types. It is used to store various keyed collections and more complex entities. Objects can be created using the Object() constructor or the object initializer / literal syntax.

developer.mozilla.org

https://developer.mozilla.org/ko/docs/Learn_web_development/Extensions/Advanced_JavaScript_objects/Object_prototypes

Object prototypes - Web 개발 학습하기 | MDN

Javascript에서는 객체를 상속하기 위하여 프로토타입이라는 방식을 사용합니다. 본 문서에서는 프로토타입 체인이 동작하는 방식을 설명하고 이미 존재하는 생성자에 메소드를 추가하기 위해 프

developer.mozilla.org

[백준][JAVA] 2667 - 단지번호붙이기 (11612KB, 64ms, Java 8)

AtomicLiquors — Tue, 24 Dec 2024 18:54:49 +0900

실버1 티어 DFS 문제인 단지번호붙이기 문제 풀이입니다.
제법 많은 분들께서 제 문제 풀이를 조회해 주셔서, 블로그에 직접 문제 해설을 올리기로 마음먹었습니다.

* 선수지식 : DFS, PriorityQueue

문제 링크

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

개요

"이차원 평면 위에 1로 표현된 '집'들을 상하좌우로 연결한 묶음을 '단지'라고 하겠습니다.
첫째 줄에 총 단지 수가 몇 개인지 출력해 주세요.
그 후 단지별로 들어 있는 집의 수를 오름차순 정렬해서 한 줄씩 출력해 주세요."

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.PriorityQueue;

public class Main {
    static int N;
    static boolean[][] map;
    static int[] dR = {0, 0, -1, 1};
    static int[] dC = {-1, 1, 0, 0};

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine());
        map = new boolean[N][N];

        for (int i = 0; i < N; i++) {
            String input = br.readLine();
            for (int j = 0; j < N; j++) {
                map[i][j] = (input.charAt(j) == '1');
            }
        }

        int answer = 0;
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for (int r = 0; r < N; r++) {
            for (int c = 0; c < N; c++) {
                if(map[r][c]){
                    answer++;
                    pq.offer(dfs(r, c));
                }
            }
        }

        StringBuilder sb = new StringBuilder();
        sb.append(residence).append('\n');
        while(!pq.isEmpty()){
            sb.append(pq.poll()).append('\n');
        }
        System.out.print(sb);
    }

    static int dfs(int r, int c){
        map[r][c] = false;
        int nr, nc;
        int houses = 1;
        for (int dir = 0; dir < 4; dir++) {
            nr = r + dR[dir];
            nc = c + dC[dir];
            if(isInBound(nr, nc)){
                houses += dfs(nr, nc);
            }
        }
        return houses;
    }

    static boolean isInBound(int r, int c){
        return r >= 0 && c >= 0 && r < N && c < N && map[r][c];
    }
}

해설

이차원 배열 초기화 : boolean[][] 타입 사용

표현하려는 값이 0과 1밖에 없어서 int[][] 보다 메모리를 적게 사용하는 boolean[][] 을 사용해도 충분합니다.

입력 1로 주어지는 '집'은 true 로, 입력 0으로 주어지는 빈 공간은 false 로 치환합니다.

참고로 이 이차원 배열은 집의 위치를 나타낼 뿐만 아니라 방문 체크 역할까지 겸할 예정입니다.

 map = new boolean[N][N];

for (int i = 0; i < N; i++) {
    String input = br.readLine();
    for (int j = 0; j < N; j++) {
    // 입력을 받아서 값이 1이면 true, 0이면 false를 대입합니다.
        map[i][j] = (input.charAt(j) == '1');
    }
}

dfs 탐색

집을 발견할 때마다 dfs로 탐색하려 합니다.

이 때 집이 총 몇 개인지 갯수를 세기 위해 dfs 함수가 집의 갯수를 저장한 int 값을 반환하도록 만듭니다.

또한 앞서 말씀드린 것처럼 map[][]는 dfs 중복 탐색을 방지하기 위해 방문 여부를 체크하는 용도로도 사용하겠습니다.
추후 집의 위치 정보를 다시 사용할 필요가 없기 때문에, 굳이 2차원 배열을 새로 선언해서 메모리를 추가로 사용하는 게 아니라
기존의 map[][]의 값을 곧바로 false 로 바꿔버릴 것입니다.

static int dfs(int r, int c){
    // 현재 위치의 map값을 false로 바꿔 중복 방문을 방지합니다.
    map[r][c] = false;
    int nr, nc;
    
    // 단지 안에 속한 집의 총 갯수를 저장할 int 변수입니다. 현재 위치에 집이 하나 있었으니 1로 초기화합니다.
    int houses = 1;
    
    for (int dir = 0; dir < 4; dir++) {
    //	4방 델타 탐색
        nr = r + dR[dir];
        nc = c + dC[dir];
        if(isInBound(nr, nc)){
        	// 집이 존재하는 좌표에 대해 dfs 탐색을 재귀적으로 실행합니다.
            // 각각의 탐색 결과 집이 총 몇 개였는지 houses에 저장하겠습니다.
            houses += dfs(nr, nc);
        }
    }
    
    // houses의 총합을 결과값으로 반환하고 탐색을 종료합니다.
    return houses;
}


static boolean isInBound(int r, int c){
    return r >= 0 && c >= 0 && r < N && c < N && map[r][c];
}

PriorityQueue를 사용한 정답 값의 오름차순 정렬

방문하지 않은 집을 발견할 때마다 단지 수를 증가시키고, dfs 결과를 PQ에 저장합니다.

PQ에 저장된 정수 값들은 자동으로 오름차순 정렬되어서 저장될 것입니다.

// 단지의 갯수를 저장할 int변수, 단지별 집의 갯수를 정렬해서 저장할 PQ입니다.
int answer = 0;
PriorityQueue<Integer> pq = new PriorityQueue<>();
for (int r = 0; r < N; r++) {
    for (int c = 0; c < N; c++) {
        if(map[r][c]){
        // 아직 방문하지 않은 집을 발견할 때마다 단지 갯수를 1 증가시킵니다.
            answer++;
            // 그 후 dfs 탐색을 실행하고, 결괏값을 즉시 PQ에 저장합니다.
            pq.offer(dfs(r, c));
        }
    }
}

StringBuilder sb = new StringBuilder();

// 단지의 갯수를 StringBuilder에 저장합니다.
sb.append(answer).append('\n');

while(!pq.isEmpty()){
	// PQ에서 오름차순으로 정렬된 단지별 집의 갯수를 순서대로 뽑아내, StringBuilder에 저장합니다.
    sb.append(pq.poll()).append('\n');
}

// StringBuilder를 출력합니다.
System.out.print(sb);

제출 결과

보통 백준에서 문제 하나를 풀 때마다 한 분 정도 찾아와서 조회해 주시는데,

이번 문제 풀이는 4달 동안 30명 가까운 분들이 조회해 주셨습니다.

많은 분들께 참고가 된 것 같아 이렇게 직접 해설을 올리게 되었습니다.

코드와 관련된 피드백이나 질문이 있으시면 댓글 부탁드립니다.

[Java] Queue의 .add()와 .offer()는 뭐가 다른가요?

AtomicLiquors — Mon, 22 Jul 2024 20:52:00 +0900

요약

.add()와 .offer()는 똑같이 Queue에 요소를 삽입하는 연산이다.
단 Queue에 크기 제한이 있을 경우 동작하는 방식이 다르다.
- .add()는 크기 제한을 넘은 경우 예외를 발생시킨다. 예외처리를 하지 않았다면 프로그램을 비정상적으로 종료한다.
- .offer()는 크기 제한을 넘어도 예외를 발생시키지는 않는다. 대신, 삽입이 되지 못했다는 사실을 사용자가 인지하지 못할 수도 있다.

사전지식

예외, 예외처리, 함수의 반환 값(return value)

상세

".add() 대신 .offer()를 사용하신 이유가 있나요?"

알고리즘 그룹 스터디를 하다가, Queue를 사용하는 문제풀이에 댓글로 문의가 들어와서 글을 작성하게 되었습니다.

사실 평소에 알고리즘을 풀 때는 크게 차이점은 없고, 각자 평소에 익숙한 메서드를 골라서 쓰게 마련입니다.

Queue를 처음 배울 때 한 번 들었을 법도 한데 잘 떠오르지 않아,
이번 기회에 공식 문서를 보고 차이점을 확실히 알아보기로 했습니다.

[ 공식 문서 ]

Java 공식 문서의 Queue 항목을 보겠습니다.

(백준에서 많이 사용하는 JDK 11 문서를 보겠습니다.)

읽기 편하시라고 의역을 많이 섞었으니 양해부탁드립니다.

.add()

먼저 .add()의 설명을 볼게요.

"현재 큐에 지정한 요소를 삽입하되, 크기 제한에 걸리지 않고 즉시 수행 가능한 경우에 실행합니다.

성공할 경우 true 값을 반환하고, 큐에 빈 공간이 없다면 IllegalStateException을 발생시킵니다."

크기 제한이 있는 큐가 꽉 찼을 때, add()를 실행하면 'IllegalStateException'이라는 에러를 발생시킨다고 합니다.

.offer()

다음으로 offer를 봅시다.

"현재 큐에 지정한 요소를 삽입하되, 크기 제한에 걸리지 않고 즉시 수행 가능한 경우에 실행합니다.

크기 제한이 있는 큐를 사용한다면 보통 .add()보다는 이 메서드를 사용하는 것이 더 바람직한데,
.add()는 똑같은 이유로 원소 삽입에 실패한다면 예외를 발생시킬 수밖에 없기 때문입니다."

똑같은 상황일 때 .add()와는 다르게 에러를 발생시키지 않는다고 합니다.

실제로 Throws: 아래에 나와 있는, 각 메서드가 발생시키는 에러 목록을 보면

앞서 .add()에는 'IllegalStateException"이 있었지만,
.offer()에는 없는 것을 확인할 수 있습니다.

추가로 문서에서 대놓고 .add()보다는 .offer()가 더 쓰기 좋다고 얘기하는 것도 인상적인 점이네요.

https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Queue.html#offer(E)

Queue (Java SE 11 & JDK 11 )

A collection designed for holding elements prior to processing. Besides basic Collection operations, queues provide additional insertion, extraction, and inspection operations. Each of these methods exists in two forms: one throws an exception if the opera

docs.oracle.com

[ Java 프로그래밍에서 : .add() ]

사실 알고리즘 문제 풀이를 하면서 큐에 크기 제한을 두고 사용하는 경우는 별로 없을 것입니다.

그렇기 때문에 .add()와 .offer()를 구분할 일은 별로 없을 텐데요.

따라서 .add()와 .offer()의 차이를 확실히 체감하기 위해 간단한 Java 프로그램을 하나 짜 보겠습니다.

public class AddOrOffer {
    public static void main(String[] args) {
        /* 크기 제한을 가진 'ArrayBlockingQueue'를 이용해 최대 크기가 5인 큐를 생성합니다. */
        Queue<Integer> que = new ArrayBlockingQueue<>(5);
        Scanner sc = new Scanner(System.in);
        System.out.println("1 이상의 정수를 입력해서 큐에 저장해 주세요.");
        System.out.println("- 큐의 최대 크기는 5입니다.");
        System.out.println("- -1을 입력하면 큐에서 첫 번째 원소를 제거합니다.");
        System.out.println("- 0을 입력하면 큐를 출력하고, 프로그램을 종료합니다.");

        while(true){
            /* 스캐너로 정수를 입력받아 큐에 삽입합니다. */
            int input = sc.nextInt();
            
            /* -1을 입력한 경우 큐의 맨 첫번째 원소를 제거합니다. */
            if(input == -1){
                int removedItem = que.poll();
                System.out.printf("큐에서 원소 제거됨 : %d\n", removedItem);
                continue;
            }

            /* 0을 입력한 경우 반복문을 종료합니다. */
            if(input == 0)
                break;

            que.add(input);
        }

        System.out.println("큐 상태 : " + que);
    }
}

큐에 원하는 숫자를 입력하고, 프로그램 정상 종료 시 큐에 입력한 숫자들을 출력하는 프로그램입니다.

큐의 최대 크기는 5입니다.

하지만 최대 크기를 넘었을 때 .add()와 .offer()가 어떻게 동작하는지 알고 싶기 때문에

일부러 5개가 넘는 숫자들을 입력해 보겠습니다.

먼저 .add()를 사용했을 때입니다. 1부터 6까지 숫자를 넣을 텐데,

여섯 번째 숫자를 넣는 순간 예외가 발생하면서 프로그램이 종료되어 버립니다.

입력값

출력 결과

Exception in thread "main" java.lang.IllegalStateException: Queue full
	at java.util.AbstractQueue.add(AbstractQueue.java:98)
	at java.util.concurrent.ArrayBlockingQueue.add(ArrayBlockingQueue.java:312)
	at Queue.AddOrOffer.main(AddOrOffer.java:31)

Process finished with exit code 1

"Queue full"이라는 메시지와 함께 IllegalStateException이 발생한 것을 확인할 수 있습니다.

[문제점]

우리가 작성한 프로그램에서 -1을 입력하면 큐에 들어있던 항목을 하나 뺄 수 있습니다.

그럼에도 불구하고, 한 번 예외가 발생해 버리면 아무것도 하지 못하고 프로그램이 종료되고 맙니다.

[보완 방법]

이런 문제를 보완하기 위해 IllegalException에 대한 예외처리로 프로그램이 계속 실행될 수 있도록 유지해 줄 수 있겠죠.

다음과 같이 que.add(input) 부분을 try-catch문으로 감싸서, .add() 메서드에서 발생 가능한 예외를 대비해 주었습니다.

try {
    que.add(input);
} catch (IllegalStateException e) {
    System.err.println("에러 : 큐가 가득 찼습니다!");
}

그리고 다시 똑같이 1, 2, 3, 4, 5, 6을 입력해 주면,

6번째 숫자를 입력했을 때 전처럼 프로그램이 종료되지 않고,
대신 다음과 같이 예외상황에 대한 메시지를 확인할 수 있게 됩니다.

1
2
3
4
5
6
에러 : 큐가 가득 찼습니다!

그러면 프로그램 사용자는 큐의 항목을 제거하는 커맨드를 실행하고,
원하는 결과를 얻을 때까지 프로그램을 실행할 수 있게 됩니다.

처음에 넣었던 1과 2를 빼고 큐에 3, 4, 5, 6, 7을 넣고 싶다면 다음과 같은 흐름으로 실행이 될 수 있겠네요.

1
2
3
4
5
6
에러 : 큐가 가득 찼습니다!
-1 // 원소 제거 커맨드
큐에서 원소 제거됨 : 1
6
7
에러 : 큐가 가득 찼습니다!
-1 // 원소 제거 커맨드
큐에서 원소 제거됨 : 2
7
0 // 종료 커맨드
큐 상태 : [3, 4, 5, 6, 7]

[ Java 프로그래밍에서 : .offer() ]

.offer()는 어떨까요? 프로그램을 즉시 종료하지 않으니 더 좋기만 한 걸까요?

개인적으로 경우에 따라 .offer()를 사용하는 것이 더 나쁜 선택이 될 수도 있다고 봅니다.

맨 처음에 사용한 코드에서 que.add(input)만 que.offer(input)으로 바꿔봅시다.

que.offer(input);

입력값

1
2
3
4
5
6
7
8
9
10
0 // 종료 커맨드

이번에는 아까와 다르게 1, 2, 3, 4, 5, 6...

여섯 번째 숫자까지 넣어도 아무런 메시지도 없고, 프로그램도 종료되지 않고 잘 돌아가네요.

숫자를 계속 넣다보니 재미가 들려서, 큐에 7, 8, 9, 10... 까지 넣고 싶은 만큼 숫자를 넣고

프로그램을 종료해 보겠습니다.

출력 결과

큐 상태 : [1, 2, 3, 4, 5]

...왜 6, 7, 8, 9, 10은 큐에 안 들어가고 1, 2, 3, 4, 5만 들어간 거죠?

아! 큐의 최대 크기가 5였다는 걸 깜빡했네요.

숫자를 실컷 넣는 동안 아무도 얘기를 안 해 줘서 전혀 몰랐는걸요.

[문제점]

이런 식으로 아무런 예외를 발생시키지 않는 경우에는

사용자가 전혀 의도하지 않은 결과를 낳을 수 있고,

프로그램은 아무 말 없이 멀쩡하게 실행되고 있으니 이런 문제를 아무도 모르게 될 위험이 존재하는 것입니다.

프로그램이 갑자기 깨진다면 최소한 뭔가 문제가 있다는 것은 인지할 수 있죠.

그런 의미에서 예외가 없다면 프로그램이 갑자기 종료되는 것보다도 나쁜 안티패턴을 낳을 수도 있는 겁니다.

[보완 방법]

다시 공식 문서 내용을 보고 옵시다.

.add()나 .offer()는 boolean 타입을 반환하는 메서드입니다.

Queue에 요소 삽입이 성공했다면 true를, 실패했다면(+그 과정에서 예외를 일으키지 않았다면) false를 반환합니다.

큐가 꽉 찼을 때 .offer()의 반환 값이 false가 된다는 점을 이용해서 코드를 다음과 같이 고쳐볼 수 있겠습니다.

boolean result = que.offer(input);
if (!result) {
    System.err.println("에러 : 큐가 가득 찼습니다!");
}

.offer()의 삽입 연산이 실패하고 false를 반환했을 때,

if문이 발생해서 메시지를 출력합니다.

그렇게 하면 아래와 같이 사용자가 원하는 결과를 얻을 수 있도록 행동을 수정하게 유도할 수 있을 겁니다.

1
2
3
4
5
6
에러 : 큐가 가득 찼습니다!
-1 // 원소 제거 커맨드
큐에서 원소 제거됨 : 1
6
7
에러 : 큐가 가득 찼습니다!
-1 // 원소 제거 커맨드
큐에서 원소 제거됨 : 2
7 
-1 // 원소 제거 커맨드
큐에서 원소 제거됨 : 3
-1 // 원소 제거 커맨드
큐에서 원소 제거됨 : 4
-1 // 원소 제거 커맨드
큐에서 원소 제거됨 : 5
8
9
10
0 // 종료 커맨드
큐 상태 : [6, 7, 8, 9, 10]

마치며

이상으로 Queue의 .add()와 .offer()의 차이점, 실제 프로그래밍에 적용했을 때를 상정한 간단한 예시를 다뤄보았습니다.

이해가 잘 안 되시거나 정정할 내용이 있다면 댓글로 피드백 부탁드립니다.

[백준][JAVA] 2504 - 괄호의 값

AtomicLiquors — Tue, 16 Jul 2024 19:08:19 +0900

스택 자료구조를 다루는 감이 떨어져 스택 문제를 복습했습니다. 풀고 나니 예상보다 티어가 높은 문제였네요.

* 선수지식 : Stack, (List)

문제 링크

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

개요

"괄호의 짝이 맞는지 확인하고, 괄호의 쌍이 나타내는 값의 합계를 구하세요".

- 괄호 '()'는 감싸고 있는 값들을 전부 합해서 2를 곱해줍니다. 괄호 안이 비었다면 2를 나타냅니다.

- 괄호 '[]'는 감싸고 있는 값들을 전부 합해서 3을 곱해줍니다. 괄호 안이 비었다면 3을 나타냅니다.

() = 2
[] = 3
([]) = 2 * 3 = 6
()[] = 2 + 3
[()[]] = 3 * (2 + 3) = 15
[([])[]] = 3 * ( (2 * 3) + 3 ) = 27

이 규칙에 의하여 주어진 문자열을 올바르게 계산해야 하는 문제입니다.

코드

[✅ 정답 코드 - Stack과 List 사용]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class Main_2504 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String input = br.readLine();
        int N = input.length();

        Stack<Character> st = new Stack<>();
        List<Integer> sums = new ArrayList<>();
        int idx = -1;
        int answer = 0;

        for (int i = 0; i < N; i++) {
           char curr = input.charAt(i);

           if(curr == '(' || curr == '['){
               st.push(curr);
               sums.add(0);
               idx++;
           }else{
               if(st.isEmpty() || !isPair(st.peek(), curr)){
                   System.out.println(0);
                   return;
               }else{
                   st.pop();
                   int total = sums.remove(idx);
                   int result = (total == 0 ? 1 : total) * getMult(curr);
                   if(--idx >= 0){
                       sums.set(idx, sums.get(idx) + result);
                   }else{
                       answer += result;
                   }
               }
           }

        }

        System.out.println(st.isEmpty() ? answer : 0);
    }

    static int getMult(char close){
        return close == ']' ? 3 : 2;
    }

    static boolean isPair(char open, char close){
        if( (open == '(' && close == ')') || (open == '[' && close == ']') )
            return true;
        else
            return false;
    }
}

해설

Stack과 List

가장 나중에 입력된 괄호들을 가장 먼저 처리해서 결과값을 내고,
그 다음에 가장 먼저 입력된 괄호들을 처리하는 방식으로 문제풀이가 이루어집니다.

(LIFO, FILO)

이런 특성에 가장 적합한 자료구조인 Stack을 이용하겠습니다.

그리고 겹겹이 중첩되어 있는 각각의 괄호 안에서 구할 합계를 저장할 수 있어야 합니다.

정수를 추가/제거하기 위해 List를 사용하고,

별도로 idx라는 정수 변수를 사용해 현재 몇 번째로 겹쳐진 괄호 안에서 합계를 구하고 있는지 가리키도록 하였습니다.

물론 굳이 List를 쓸 필요는 없고 적당한 크기의 배열을 써도 되지만,
풀이 중에는 한 번 쓰고 제거한다는 점을 좀 더 명확히 하고 혼동을 줄이고자 List를 사용했습니다.

/* 스택과 리스트를 선언합니다. */
Stack<Character> st = new Stack<>();
List<Integer> sums = new ArrayList<>();

/* 
 * 리스트의 최근 인덱스를 가리킬 idx 변수입니다. 
 * 리스트가 비어 있을 땐 초기값이 -1이었다가, 
 * 원소가 들어오면서 0, 1, 2 ... 등 실제 인덱스를 나타낼 것입니다. 
*/
int idx = -1;

/* 정답을 저장할 answer 변수입니다. */
int answer = 0;

열린 괄호를 만난 경우

 for (int i = 0; i < N; i++) {
   char curr = input.charAt(i);

/* 현재 괄호가 ( 또는 [와 같이 열린 괄호일 경우 */
   if(curr == '(' || curr == '['){
       st.push(curr);
       sums.add(0);
       idx++;
   }else{
       // ...
   }

}

- Stack에 현재 괄호를 집어넣습니다.

- List에 0을 집어넣고, 앞으로 현재 괄호 내부의 계산 결과를 여기다 더해주겠습니다.

- idx가 List에서 현재 괄호의 위치를 가리킬 수 있도록 1만큼 증가시킵니다.

닫힌 괄호를 만난 경우

문제의 조건에 따르면,

앞서 조건문 curr == '(' || curr == '[' 를 통과하지 못한 경우는 무조건 닫힌 괄호 ) 또는 ]를 만나게 됩니다.

[1. 괄호 문자의 유효성 확인하기]

짝이 맞는 괄호들을 전부 제거했을 때,
괄호 문자가 유효하지 않는 경우는 크게 두 가지가 있겠습니다.

a. 열려 있는 괄호가 없는데 닫힌 괄호가 등장했을 때

열린 괄호가 없다는 것은 다시 말해 현재 스택에 아무것도 없다는 의미겠지요.

b. 괄호가 있는데 서로 짝이 맞지 않을 때

스택의 최상단에 있는 열린 괄호, 현재 등장한 닫는 괄호가 서로 짝이 맞지 않는 상황입니다.

다음과 같이 구현하였습니다.

/* 스택이 비어 있거나, 사용자 정의 메서드 isPair의 결과가 false일 경우*/
if(st.isEmpty() || !isPair(st.peek(), curr)){

/* 유효하지 않은 괄호 문자열이므로 0을 출력하고 프로그램을 종료합니다. */
   System.out.println(0);
   return;
}else{
   ...
}

/* 사용자 정의 메서드 isPair */ 
/* 두 괄호가 짝이 맞는지 확인하고 true, false를 반환합니다.*/
/* 스택의 최상단에 있는 괄호, 현재 탐색 중인 문자를 비교하는 데 사용하였습니다. */
static boolean isPair(char open, char close){
    if( (open == '(' && close == ')') || (open == '[' && close == ']') )
        return true;
    else
        return false;
}

[2. 괄호 문자의 합계 구하기]

괄호가 유효한 것으로 판명이 났다면 알맞은 값을 계산해 줍니다.

괄호를 닫기 전까지 합계가 얼마였는지 저장해 뒀다가,
괄호가 닫히는 순간 종류에 맞게 2 또는 3을 곱한 뒤

바깥 괄호에서 구하고 있는 합계에 더해 줄 것입니다.

if(st.isEmpty() || !isPair(st.peek(), curr)){
   ...
}else{
	/* 짝을 맞춘 열린 괄호는 스택에서 제거해 줍니다.*/
   st.pop();
   
   /* 
    * 정수 변수 total에 지금까지 괄호 내부에서 구한 합계를 저장합니다. 
    * List의 remove는 항목을 제거함과 동시에 제거된 항목을 반환합니다. 
   */
   int total = sums.remove(idx);
   
   /* 
    * 정수 변수 result에 괄호의 종류에 따라 결괏값을 계산해 줍니다.
    * 사용자 정의 메서드 getMult로 괄호의 종류에 따라 얼마를 곱할지 구해 줍니다. 
    * 만일 '()', '[]'과 같이 빈 괄호라서 합계가 0인 경우, 1을 곱해서 2 또는 3으로 만들어 줍니다.
    */
   int result = (total == 0 ? 1 : total) * getMult(curr);
   
   if(--idx >= 0){
   	/* idx를 하나 줄여서 바깥 괄호를 가리키고, 구한 값을 바깥 괄호의 합계에 더해 줍니다. */
       sums.set(idx, sums.get(idx) + result);
   }else{
   	/* idx가 -1일 경우 현재 더 이상 열린 괄호가 없으므로, 구하고자 하는 총 합계에 더해 줍니다. */
       answer += result;
   }
}

/* 괄호의 종류에 따라 곱할 값을 반환하는 getMult 메서드*/
static int getMult(char close){
	// 매개변수 close가 ]라면 3을, 아니라면 )로 간주하고 2를 반환합니다.
    // 문제 조건에 따라 괄호는 무조건 ] 또는 )로 주어지므로 이렇게 구현해도 충분합니다.
    return close == ']' ? 3 : 2;
}

정답 출력

위와 같은 과정을 끝까지 반복하고 나면 정답을 출력해 줄 것입니다.

다만 출력하기 전에 괄호 문자열이 유효한지 한 번 더 검증할 건데요,

모든 괄호의 짝이 맞았다면 스택에 더 이상 남는 괄호가 없어야 합니다.

그러나 앞선 과정이 정상적으로 실행되었더라도 문자열이 올바르지 않아서

스택에 아직 열린 괄호가 남아있을 가능성이 있습니다.

(() => 프로그램 실행 후 스택에 '('가 남는다.
(()[]()[ => 프로그램 실행 후 스택에 '(['가 남는다.
()[]()[[[ => 프로그램 실행 후 스택에 '[[['가 남는다.

그러므로 스택이 비어 있는지 확인하고 그렇다면 지금까지 구한 합계를, 그렇지 않다면 0을 출력할 것입니다.

System.out.println(st.isEmpty() ? answer : 0);

[제출 결과]

추가로 List의 역할을 배열로 대체한 코드도 함께 올립니다.

[✅ 정답 코드 - Stack과 배열 사용]

package stack;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class Main_2504_Array {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String input = br.readLine();
        int N = input.length();

        Stack<Character> st = new Stack<>();
        int[] sums = new int[N];
        int idx = -1;
        int answer = 0;

        for (int i = 0; i < N; i++) {
           char curr = input.charAt(i);

           if(curr == '(' || curr == '['){
               st.push(curr);
               sums[++idx] = 0;
           }else{
               if(st.isEmpty() || !isPair(st.peek(), curr)){
                   System.out.println(0);
                   return;
               }else{
                   st.pop();
                   int total = sums[idx];
                   int result = (total == 0 ? 1 : total) * getMult(curr);
                   if(--idx >= 0){
                       sums[idx] = sums[idx] + result;
                   }else{
                       answer += result;
                   }
               }
           }

        }

        System.out.println(st.isEmpty() ? answer : 0);
    }

    static int getMult(char close){
        return close == ']' ? 3 : 2;
    }

    static boolean isPair(char open, char close){
        if( (open == '(' && close == ')') || (open == '[' && close == ']') )
            return true;
        else
            return false;
    }
}

배열로 바꾸기 전과 성능상 큰 차이는 없었습니다.

코드와 관련된 피드백이나 질문이 있으시면 댓글 부탁드립니다.

[Github] 커맨드라인에서 pull request 작성하기

AtomicLiquors — Fri, 12 Jul 2024 01:33:28 +0900

브랜치 작업을 마치고 IDE에서 곧바로 PR을 보내고 싶어서 CLI에서 PR을 보내는 방법을 알아보았습니다.

터미널에서 GitHub CLI(gh)를 사용하여 다음 커맨드를 통해 PR을 작성할 수 있습니다.

gh pr create --base {TARGET_BRANCH} --head {CURRENT_BRANCH} --title "{TITLE}" --body "{BODY}"

--base에 해당하는 {TARGET_BRANCH} 자리에는 변경 사항이 병합될 브랜치 이름을 적어 줍니다.
--head에 해당하는 {CURRENT_BRANCH} 자리에는 변경 사항이 들어있는 브랜치 이름을 적어 줍니다.
{TITLE} 자리에는 PR의 제목을 작성하고 따옴표로 감싸 줍니다.
{BODY} 자리에는 PR의 본문 내용을 작성하고 따옴표로 감싸 줍니다.

[ 예시]

gh pr create --base master --head feat/login 
--title "로그인 기능 추가" --body "OAuth방식을 이용한 로그인 기능을 추가했습니다."

GitHub CLI(gh)가 설치되어 있지 않다면, 아래 설치과정을 따라서 gh를 설치해 주세요.

gh 설치

mac에서는 brew install 등을 이용해 커맨드라인으로 설치해 주면 됩니다.

brew install gh

window에서는 아래 공식 홈페이지에서 설치 파일(.msi)을 받아 설치합니다.

GitHub CLI

Take GitHub to the command line

cli.github.com

커맨드에서 gh를 입력하여 설치를 확인합니다.

(설치가 되지 않았다고 할 경우 컴퓨터를 재시작합니다.)

Github 사용자 인증

아래 커맨드를 입력해 Github CLI에 자신의 계정 정보로 로그인을 시작합니다.

gh auth login

로그인할 계정을 선택하게 됩니다.
Github.com 계정으로 로그인할 거니까 Github.com을 선택하겠습니다.

HTTPS/SSH 중에 원하는 프로토콜을 선택하여 Github와 통신합니다. 전 HTTPS를 사용하겠습니다.

credential을 통해 인증할 것인지 물어보면 Y를 입력합니다.

웹 브라우저를 통해 로그인하거나 인증 토큰을 사용할 수 있습니다.

여기서는 웹 브라우저를 통해 로그인하겠습니다.

인증에 사용할 코드가 터미널에 뜹니다.

엔터키를 누르면 Github 로그인 페이지로 연결됩니다.

로그인을 마치면 Device Activation 화면이 뜹니다.

괜히 Device라고 하니 모바일 기기 인증을 하라는 말인지 헷갈릴 수 있는데, 그건 아닙니다.

바로 방금 터미널에 떴던 코드를 입력해 주는 겁니다.

아까 봤던 이 화면에 있는 코드를 입력하면 됩니다.

인증이 완료되면 아래와 같이 Github CLI에 로그인됩니다.

PR 작성

이제 맨 처음에 소개했던 커맨드를 이용해서 PR을 작성해 봅시다.

gh pr create --base {TARGET_BRANCH} --head {CURRENT_BRANCH} --title "{TITLE}" --body "{BODY}"

--base에 해당하는 {TARGET_BRANCH} 자리에는 변경 사항이 병합될 브랜치 이름을 적어 줍니다.
--head에 해당하는 {CURRENT_BRANCH} 자리에는 변경 사항이 들어있는 브랜치 이름을 적어 줍니다.
{TITLE} 자리에는 PR의 제목을 작성하고 따옴표로 감싸 줍니다.
{BODY} 자리에는 PR의 본문 내용을 작성하고 따옴표로 감싸 줍니다.

예를 들어서 master 브랜치에 feat/login 브랜치를 병합하려면 다음과 같은 커맨드를 입력해 주는 겁니다.

gh pr create --base master --head feat/login 
--title "로그인 기능 추가" --body "OAuth방식을 이용한 로그인 기능을 추가했습니다."

PR 요청이 완료되었고 이제 Github에서 요청을 검토하고 Merge할 수 있게 됩니다.

만일 PR을 검토할 담당자를 지정하고 싶다면 커맨드에 -a 또는 --assignee 옵션을 사용할 수 있습니다.

gh pr create -a "@octocat"
gh pr create --assignee "@octocat"

더 자세한 옵션이나, Github CLI를 이용한 PR에 관해 자세한 내용은 아래 공식 문서를 참고해 주세요.

끌어오기 요청 만들기 - GitHub Docs

리포지토리의 변경 내용을 제안하고 공동 작업하는 끌어오기 요청을 만듭니다. 이러한 변경 내용은 분기에서 제안되어 기본 분기에 완료 및 승인된 작업만 포함되도록 합니다.

docs.github.com

[백준][JAVA] 3273 - 두 수의 합

AtomicLiquors — Mon, 8 Jul 2024 07:40:18 +0900

이른 아침에 산책을 나가서 아침밥을 먹다가 심심해서 예전에 실패했던 백준 문제들을 둘러보았습니다.
실버3 문제 하나를 빠른 방법으로 풀게 되어서 공유하려고 합니다.

문제 링크

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

개요

"주어진 배열에서 서로 다른 원소 두 개의 합이 X가 되는 경우의 수를 구하시오".

알고리즘을 처음 배울 때 조합으로 접근했다가 어리둥절했던 문제입니다.

'분명 배운 대로 했는데 왜 통과를 못하는 거지?'

물론 이제는 순열, 조합과 같은 완전탐색보다 훨씬 빠른 알고리즘이 많다는 걸 깨달았으니

더 빠른 풀이방법을 생각해 낼 줄 알아야겠죠.

조합으로 풀 경우

시간 제한이 1초인 문제입니다. 배열의 크기는 최대 100,000으로 주어집니다.

배열에서 2개의 원소를 찾기 위해서는 이중 반복문을 순회하게 되고, O(N^2) 시간복잡도를 갖게 됩니다.

N^2 = 100,000 * 100,000 = 10,000,000,000이고, O(N^2) 알고리즘이면 그 정도 크기에 준하는 연산 횟수가 발생하게 될 것입니다.

1초 내에 어림잡아 1억 번(100,000,000)의 연산만 가능할 텐데, 필요한 연산 횟수가 과하게 많습니다.

[제출 결과]

* 실패 코드는 게시글 맨 아래에 정답 코드와 함께 올려두겠습니다.

O(N)으로 풀 수 없을까?

배열을 순회하면서 특정 원소 a를 만났을 때,

“앞으로 X-a에 해당하는 원소가 존재한다면 정답 갯수를 1개 늘린다”라고 접근.

이 방법이라면 100,000번 내외의 연산으로 단 한번만 배열을 순회하면서 정답을 구할 수 있습니다.

[✅ 정답 코드]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main_3273 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        int[] arr = new int[N];
        StringTokenizer st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
           arr[i] = Integer.parseInt(st.nextToken());
        }
        int X = Integer.parseInt(br.readLine());
        boolean[] cache = new boolean[X];

        int result = 0;

        for (int a : arr) {
            if(a >= X)
                continue;
            // 모든 원소는 반드시 음수가 아니라 자연수이므,로 X보다 큰 값은 정답에 포함될 수 없습니다.
		        // 모든 원소는 1보다 크거나 같으므로 순서쌍 (X, 0)이라는 정답은 존재하지 않습니다.
		        // 따라서 a == X인 경우도 제거합니다.

            if(cache[a])
                result++;
                // 2. 현재 값이 cache에 true로 체크되어 있다면 정답 갯수를 1만큼 늘립니다.
            else
                cache[X - a] = true;
		            // 1. 구하고자 하는 수 X에서 현재 원소를 뺀 값을 cache에 true로 체크합니다. 
        }
        System.out.println(result);
    }
}

[제출 결과]

아래는 조합으로 풀었던 실패 코드이니 참고해서 보시면 되겠습니다.

[❌실패 코드]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        StringTokenizer st = new StringTokenizer(br.readLine());
        int[] input = new int[N];
        for (int i = 0; i < N; i++) {
            input[i] = Integer.parseInt(st.nextToken());
        }
        int X = Integer.parseInt(br.readLine());
        int result = 0;

        for (int i = 0; i < N; i++) {
            for (int j = i; j < N; j++) {
                if(input[i] + input[j] == X){
                    result++;
                }
            }
        }
        System.out.println(result);
    }
}

코드와 관련된 피드백이나 질문이 있으시면 댓글 부탁드립니다.

[백준][JAVA] 3190 - 뱀

AtomicLiquors — Thu, 9 Mar 2023 00:43:18 +0900

정말 오랜만에 올리는 포스팅입니다.
백준 알고리즘 문제를 하나 풀어보도록 하겠습니다.

3190번: 뱀

'Dummy' 라는 도스게임이 있다. 이 게임에는 뱀이 나와서 기어다니는데, 사과를 먹으면 뱀 길이가 늘어난다. 뱀이 이리저리 기어다니다가 벽 또는 자기자신의 몸과 부딪히면 게임이 끝난다. 게임

www.acmicpc.net

개요

골드 4 난이도 시뮬레이션 문제입니다.

골드 난이도라지만 복잡한 알고리즘 지식이 필요한 문제는 아닙니다.
이차원 배열과 큐 Queue 정도의 자료구조를 문제풀이에 응용할 줄 알고,

문제의 요구사항을 꼼꼼히 구현하는 능력이 있다면 풀 수 있는 문제였습니다.

코드

[제출 결과]

[코드]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main_3190_뱀 {

	static int[] dR = { 0, 1, 0, -1 };
	static int[] dC = { 1, 0, -1, 0 };

	static int[][] board;
	static int N;
	static boolean over;

	static int dir;

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		N = Integer.parseInt(br.readLine());
		int K = Integer.parseInt(br.readLine());

		board = new int[N + 1][N + 1];

		StringTokenizer st;
		for (int i = 0; i < K; i++) {
			st = new StringTokenizer(br.readLine());
			int r = Integer.parseInt(st.nextToken());
			int c = Integer.parseInt(st.nextToken());
			board[r][c] = 1;

		}

		int L = Integer.parseInt(br.readLine());

		
		int r = 1, c = 1;
		int[] tail;

		dir = 0;
		over = false;
		int elapsed = 0;

		Queue<int[]> snake = new ArrayDeque<>();
		snake.offer(new int[] { r, c });
		board[r][c] = -1;

		

		st = new StringTokenizer(br.readLine());
		int X = Integer.parseInt(st.nextToken());
		char cmd = st.nextToken().charAt(0);

		while (!over) {
			
			r += dR[dir];
			c += dC[dir];

			++elapsed;
			if (over = isOuttaBound(r, c))
				break;

			if (board[r][c] == 1) {
				snake.offer(new int[] { r, c });
				board[r][c] = -1;
			} else if (board[r][c] == 0) {
				snake.offer(new int[] { r, c });
				board[r][c] = -1;

				tail = snake.poll();
				board[tail[0]][tail[1]] = 0;

			} else if (board[r][c] == -1) {
				over = true;
				break;
			}
			
			if (elapsed == X) {
				redirect(cmd);

				if(--L > 0) {
					st = new StringTokenizer(br.readLine());
					X = Integer.parseInt(st.nextToken());
					cmd = st.nextToken().charAt(0);
				}else X = -1;	
			}
		}

		System.out.println(elapsed);

	}

	static boolean isOuttaBound(int r, int c) {
		if (r < 1 || c < 1 || r > N || c > N)
			return true;
		return false;
	}

	static void redirect(char cmd) {
		switch (cmd) {
		case 'L':
			dir = (dir + 3) % 4;
			break;

		case 'D':
			dir = (dir + 1) % 4;
			break;
		}
	}

}

상세

[Queue 활용]

뱀의 움직임은 Queue를 이용해 표현할 수 있습니다. Queue 내부에는 행/열을 나타내기 위해 2칸짜리 정수 배열을 저장했습니다.

뱀의 기본 동작은 선입선출 FIFO 구조의 큐로 표현할 수 있습니다.

‘새롭게 한 칸이 추가되면, 가장 오래된 한 칸이 빠져나가는’ 패턴을 갖기 때문입니다.
뱀이 현재 이차원 배열 위에서 차지하고 있는 위치 정보가 필요하기 때문에,

큐에는 행 값과 열 값이 들어갈 수 있는 정수 배열을 저장하겠습니다.

이차원 배열 board 위에서 뱀의 현재 위치는 -1, 사과는 1로 표현됩니다.

[게임판 구성]

이차원 int 배열로 표현합니다. 뱀의 인덱스가 1로 주어지기 때문에 크기는 N+1로 설정합니다.

0 : 아무것도 없는 빈 칸입니다. 배열을 생성할 때 자동으로 할당되는 값인 0으로 표현합니다.
1 : 사과의 위치를 입력받아 게임판에 1로 표현하겠습니다.
-1 : 현재 뱀의 위치를 나타냅니다. 뱀의 다음 위치가 이곳이라면 게임이 종료됩니다.

[뱀의 동작 구현]

델타 탐색을 이용하여 현재 위치에서 지정된 방향으로 r값 또는 c값을 한 칸 전진시킵니다.

0을 만난 경우 :
- [크기 1 늘리기] 새로운 위치 좌표를 큐에 넣고, 게임판에서 해당 위치를 -1로 표시합니다.
- [크기 1 줄이기] 큐에서 가장 오래된 위치 좌표를 제거하고, 게임판에서 해당 위치를 0으로 되돌립니다.
1을 만난 경우 :
- [크기 1 늘리기] 새로운 위치 좌표를 큐에 넣고, 게임판에 해당 위치를 -1로 표시합니다.
- ~~[크기 1 줄이기]~~ 사과를 먹어서 전체 크기가 1 증가하므로, 크기를 줄이는 동작을 실행하지 않습니다.
-1을 만난 경우 / 맵 밖으로 벗어난 경우
- 게임 종료 조건입니다. 반복문을 종료하고 경과한 시간을 출력합니다.

일정 시간이 될 때마다 델타 탐색 배열의 인덱스를 바꿔 이동 방향을 전환합니다.

주의할 점

입력값으로 들어오는 행, 열 위치는 0이 아니라 1부터 시작하는 인덱스로 제시됩니다.
배열 크기 설정과 종료조건 설정에 유의하도록 합니다.

코드와 관련된 피드백이나 질문이 있으시면 댓글 부탁드립니다.

[CS-운영체제] 입문

AtomicLiquors — Sun, 8 Jan 2023 22:55:15 +0900

입과 전 적응기간을 틈타서 후순위로 밀려있던 운영체제 공부를 시작했습니다.

야심차게 공룡책 사서 본가 책꽂이에 꽂아둔 지가 3개월째인데

결국 타지 올라와서 생활할때까지 못 보고 왔네요. 반성해야겠습니다 흑흑

분반 테스트 결과가 어떻게 될진 모르지만 개발자에게 중요한 지식인만큼

시간 내서 한번 배울때 확실히 배우고 넘어가도록 하겠습니다.

[기반 강의] HPC Lab. KOREATECH 운영체제 강의

https://www.youtube.com/watch?v=EdTtGv9w2sA&list=PLBrGAFAIyf5rby7QylRc6JxU5lzQ9c4tN&index=1

운영체제 정의

운영체제의 정의에 대해서는 의견이 분분합니다.
본 강의에서는 운영체제를 다음과 같이 정의하고 있습니다.

1) 하드웨어가 가진 컴퓨터 시스템 자원을 효율적으로 관리하여,

2) 사용자에게 응용 프로그램을 제공하는 소프트웨어

운영체제의 역할

유저 인터페이스 : 편리성 제공
자원관리 : 효율성 제공
프로세스와 쓰레드 관리
시스템 보호

운영체제 분류

운영체제는 크게 다음과 같이 분류됩니다.

- '동시 사용자 수'에 따라 싱글 유저 시스템(PC나 모바일 등 개인용 기기) 또는 멀티 유저 시스템(서버, 클러스터)

- '동시 실행 프로세스 수'에 따라 싱글태스킹 시스템, 멀티태스킹 시스템

그리고 '작업 수행 방식'에 따라 아래와 같이 몇 가지 분류가 나뉘는데,
이는 컴퓨터가 발달해 온 역사와도 궤를 같이합니다.

순차 처리 : 운영체제 없음 (~1940s)

운영체제가 존재하지 않던 시기의 작업방식입니다.

그랬기 때문에 사용자가 기계어로 직접 프로그램을 작성하고, 하드웨어도 직접 제어해야 했습니다.

프로그램이 작성된 '천공 카드'를 입력하면 프로그램이 작동하는 방식이었고

실행하는 작업별로 순차적으로 처리되었으며, 각 작업마다 일정한 준비시간이 소요되었습니다.

일괄 처리 시스템 Batch Processing System (1950s-60s)

모든 시스템을 중앙 기관에서 관리하고 운영하는 방식입니다.

사용자의 작업 요청이 들어있는 천공 카드를 기관에서 모아뒀다가 한 번에 처리하였습니다.

Pros)

중앙기관의 시스템 자원을 여러 사용자가 공유할 수 있었습니다.

Cons)

생산성이 낮다는 문제가 있었습니다.
나의 작업이 처리되기를 기다리기 위해서 같은 유형의 작업이 모일 때까지 기다려야 했고,

그 과정에서 6시간에 가까운 응답 시간이 소요되었습니다.

시분할 시스템 Time Sharing System (1960s-70s)

여러 프로그램이 시간을 조금씩 나눠 교대로 자원을 사용하는 방식입니다.
대화형 시스템, 단말(terminal)의 도입으로 사용자 지향적이라는 특징이 있습니다.

Pros)

응답시간이 약 5초 수준으로 단축되었습니다.
프로세서 유휴시간이 감소하였습니다.

Cons)

통신비 증가 : 통신선 단가와 보안 문제로 부담할 비용이 늘어났습니다.
개인 사용자가 체감하는 속도는 오히려 떨어졌습니다.
동시 사용자 수가 늘어나면 시스템 부하도 늘어났고 이는 속도 저하로 이어졌습니다.

병렬처리 시스템 Parallel Processing System

PC의 등장 이후 출현한 시스템입니다.
응답시간은 빨랐지만 성능은 다소 떨어졌던 PC의 단점을 보완해 주었습니다.

'한 시스템에 여러 개의 프로세서를 사용한다'는 특징을 중심으로 아래와 같은 특성이 있습니다.

Tightly-coupled system : 여러 개의 프로세서들이 메모리와 같은 자원을 서로 공유합니다.
신뢰성 향상 : 하나의 프로세서가 망가져도 시스템은 정상적으로 동작할 수 있게 되었습니다.
프로세서 간 관계 및 역할 관리가 추가적으로 필요하게 되었습니다.

분배 프로세스 시스템 Distributed Processing System

“네트워크를 기반으로 병렬처리 시스템을 구축한 것”입니다.

개별적으로 OS가 탑재된 컴퓨터가 네트워크 상에서 하나의 노드가 됩니다.

Loosely-coupled system
분산 운영체제 사용
자원 공유를 통해 성능을 높였습니다.
구축과 관리가 어렵다는 단점이 있습니다.

실시간 시스템 Real-time Systems

작업처리에 제한시간이 걸려있는 시스템입니다.
효율적인 자원 사용보다, 서비스 제공 시간을 엄수하는 것이 우선일 경우 사용됩니다.

Hard real-time task :
시간엄수에 실패하면 치명적 결과가 발생하는 작업입니다.
원자력 발전소 관리, 군사병기 제어 시스템 등이 해당하겠습니다.
Soft real-time task :
동영상 스트리밍처럼 시간이 좀 늦더라도 불편할 뿐인 작업입니다.

하드웨어 종류

프로세서

연산 장치, 모든 컴퓨터 부속 장치의 동작을 제어하는 장치.

“컴퓨터의 두뇌”라고 할 수 있겠습니다.

CPU(Central Processing Unit), GPU(Graphics Processing Unit)가 프로세서에 해당합니다.

메모리

기억 장치, 데이터를 저장하는 장치.

일반적으로 속도가 느리면 단가가 싸고, 용량을 대용량으로 만들 수 있습니다.

레지스터 :
프로세서 내부에 존재하는 메모리. 프로세서가 사용할 데이터를 저장합니다. ”컴퓨터에서 가장 빠른 메모리”입니다.
캐시 :
마찬가지로 프로세서 내부에 존재합니다.
아래의 주기억장치가 가진 데이터를 일부 저장하여, 요청이 있을 때 빠르게 데이터를 조달해 줍니다.
주기억장치 :
프로세서가 수행할 프로그램과 데이터를 저장합니다. 주로 용량이 크고 저렴한 DRAM을 사용합니다.
보조기억장치 :
컴퓨터 전원이 꺼진 뒤에도 프로그램과 데이터를 저장할 수 있는 장치입니다.
다만 이쪽은 엄밀히 메모리 장치로 분류하진 않고 주변장치로 분류하는 것으로 보입니다.

주변장치

프로세서와 메모리를 제외한 하드웨어들입니다.

입력장치, 출력장치, 앞서 언급한 보조기억장치가 있습니다.

위와 같은 내용을 학습한 뒤 운영체제의 구조와 기능에 대해 간단하게 알아보았습니다.

현재 진도

[ 4강 / 총 46강 ]

[논리학] 기초개념 정리

AtomicLiquors — Sat, 7 Jan 2023 18:13:45 +0900

알고리즘 공부를 하던 중 생소하게도 논리학 개념을 접하게 되었습니다.

충분한 논리력이 뒷받침이 되지 않는다면 알고리즘 설명을 아무리 봐도 이해를 못하거나,

코드를 정확하게 고치지 못하고 원하는 실행 결과가 나올 때까지 막연한 수정만 반복하는 함정에 빠질 수 있으므로

논리적으로 정확하게 확인하는 과정을 연습한다는 것이 학습의 취지입니다.

학습한 내용 및 구글링을 통해 배운 개념을 정리합니다.

논리 기호와 개념

F(Function) : '함수' / '개념'

∃(turned E) : '적어도 한 개가 존재한다'

- ∃x : "x가 존재한다" / "적어도 하나의 x가 존재한다"

- ∃xFx : "어떤 x가 F를 만족한다"

∀(turned A) : '모든 ~에 대하여'

- ∀x : "모든 x에 대하여"

- ∀xFx : "모든 x가 F를 만족한다"

￢ (not) : 부정

명제 앞에 붙이면 본래 명제와 반대의 진릿값(참/거짓)을 갖게 된다.

⊥ : 모순

- F→⊥ : 'F를 가정할 경우 모순이 생긴다'

p∧q : 'p and q', p와 q를 모두 충족한다.

- ∀x(Fx∧Gx) : 모든 x는 F와 G를 만족한다.

p∨q : 'p or q', p 또는 q를 충족한다.

p≡q : p와 q는 동치equivalent이다. (p와 q의 진릿값이 서로 같다)

역, 이, 대우 :

p → q 라는 조건문에 대해

- 역(connverse) : q → p

- 이(inverse) : ￢p → ￢q

- 대우 (contrapositive) : ￢q → ￢p

명제식 p → q의 참 / 거짓

1. 전건 p가 항상 거짓이면, 명제식 p → q는 무조건 참이다.

예컨대 어머니가 아들에게 '전교 1등을 하면 → 용돈 백만 원을 주겠다'는 말을 했다고 생각해 봅시다.

상식선에서 보면 아무리 봐도 진짜로 백만 원을 줄 것 같진 않기 때문에 어머니가 참말을 했다고 생각되진 않습니다.

이 때 아들이 한 번도 전교 1등을 하지 못했다면,

어머니가 한 말이 참말인지 거짓말인지는 검증할 방법이 없으니까 '알 수 없다'고 생각하는 게 보통일 텐데,

논리학에서는 의외로 어머니가 '참말'을 했다고 간주하는 모양입니다.
'거짓말은 하지 않았다'는 걸까요.

'논리학'인 만큼 이것이 단순한 약속이라기보단 뭔가 명확한 증명이 있을 것 같은데,

그런 증명이 있는지는 따로 찾아봐야겠습니다.

2. 후건 q가 항상 참이면, 명제식 p → q는 무조건 참이다.

1) 1 + 1 = 3이라면, 2는 짝수이다.

2) 1000 < 10일 때, 3 * 3 = 9다.

위와 같이 전건이 명백히 거짓이더라도, 후건이 명백히 참이라면 명제식은 항상 참이라고 합니다.

명제식 변형

2중 부정법: $∼(∼p)≡p$

교환법칙: $p∧q≡q∧p$, $p∨q≡q∨p$

멱등법칙: $p∧p≡p$, $p∨p≡p$

대우법칙: $(p→q) ≡ (∼q→∼p)$

드 모르간의 법칙(De Morgan's laws)

$∼(p∧q)≡∼p∨∼q$,

$∼(p∨q)≡∼p∧∼q$

결합법칙:

$(p∨q)∨r≡p∨(q∨r),$

$(p∧q)∧r≡p∧(q∧r)$

분배법칙:

$p∧(q∨r)≡(p∧q)∨(p∧r)$

$p∨(q∧r)≡ (p∨q)∧(p∨r)$

진리표

명제식에 대해 각 명제의 진릿값을 나타낸 표를 말합니다.

[예시] $p∧q$의 진리표 :

p	q	p∧q
T	T	T
T	F	F
F	T	F
F	F	F

수학적 귀납법

P(1)이 참이고, 명제식 P(n) → P(n+1)이 참임을 보임으로써 명제 P(n)은 모든 자연수 n에 대해 참임을 증명하는 것

귀류법

참/거짓밖에 존재하지 않는 명제에 대해, 명제를 부정했을 경우 모순이 발생한다는 것을 찾아내어, 명제가 참임을 증명하는 것

수학적 귀납법과 귀류법은 예제를 충분히 풀고 나면 별도 포스팅으로 다뤄보도록 하겠습니다.

[참고자료]

http://sjoh.hannam.ac.kr/Science/proof/index.html

명제의 증명

2.. 명제의 증명 항진(항상 참, tautology): 모든 논리적 가능성에 대하여 참인 명제를 항진이라 한다. p ∼q p∨∼q T F F T T T 이 표를 보면 명제 p

sjoh.hannam.ac.kr

'명제식 변형'과 관련하여 참고한 자료지만 명제의 역에 대한 설명이 틀리게 나와있는 것 같습니다.