├── solutions ├── 2557.js ├── README.md ├── 10718.js ├── 10171.js ├── 10172.js ├── 18310.js ├── 1427.js ├── 2437.js ├── 1000.js ├── 1001.js ├── 1008.js ├── 10998.js ├── 10773.js ├── 1904.js ├── 2741.js ├── 2742.js ├── 8393.js ├── 2739.js ├── 2750.js ├── 2753.js ├── 10818.js ├── 10951.js ├── 11650.js ├── 11651.js ├── 1463.js ├── 3052.js ├── 10989.js ├── 2438.js ├── 9461.js ├── 10950.js ├── 1181.js ├── 2751.js ├── 10869.js ├── 19939.js ├── 2562.js ├── 11399.js ├── 1330.js ├── 10814.js ├── 11021.js ├── 1448.js ├── 10952.js ├── 15552.js ├── 10430.js ├── 2439.js ├── 1541.js ├── 1546.js ├── 2884.js ├── 2588.js ├── 11047.js ├── 1337.js ├── 2577.js ├── 9498.js ├── 2480.js ├── 10871.js ├── 8958.js ├── 18870.js ├── 4673.js ├── 1110.js ├── 13305.js ├── 9009.js ├── 1789.js ├── 11022.js ├── 14681.js ├── 2910.js ├── 2606.js ├── 1931.js ├── 2294.js ├── 1932.js ├── 1065.js ├── 11509.js ├── 4344.js ├── 11536.js ├── 12015.js ├── 10828.js ├── 17609.js ├── 2512.js ├── 2805.js ├── 1654.js ├── 1987.js ├── 1449.js ├── 17521.js ├── 18353.js ├── 1240.js ├── 24479.js ├── 24480.js ├── 11403.js ├── 10800.js ├── 1058.js ├── 1343.js ├── 11404.js ├── 2110.js ├── 1072.js ├── 1493.js ├── 1300.js ├── 5052.js ├── 9655.js ├── 10816.js ├── 2164.js ├── 2667.js ├── 2872.js ├── 2644.js ├── 1012.js ├── 1920.js ├── 10815.js ├── 16953.js ├── 10026.js ├── 18258.js ├── 5567.js ├── 2178.js ├── 14395.js ├── 5214.js ├── 2468.js ├── 24444.js ├── 24445.js ├── 7453.js ├── 14867.js ├── 2108.js ├── 10866.js └── 16928.js ├── README.md └── sortingComparison.js /solutions/2557.js: -------------------------------------------------------------------------------- 1 | console.log("Hello World!"); -------------------------------------------------------------------------------- /solutions/README.md: -------------------------------------------------------------------------------- 1 | #### BOJ Solutions in JavaScript 2 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ### BOJ JavaScript 2 | 3 | > BOJ Solutions in JavaScript 4 | -------------------------------------------------------------------------------- /solutions/10718.js: -------------------------------------------------------------------------------- 1 | for (let i = 0; i < 2; i++) { 2 | console.log('강한친구 대한육군'); 3 | } -------------------------------------------------------------------------------- /solutions/10171.js: -------------------------------------------------------------------------------- 1 | // 이스케이프 시퀀스(escape sequence) 2 | console.log('\\ /\\'); 3 | console.log(' ) ( \')'); 4 | console.log('( / )'); 5 | console.log(' \\(__)|') -------------------------------------------------------------------------------- /solutions/10172.js: -------------------------------------------------------------------------------- 1 | // 이스케이프 시퀀스(escape sequence) 2 | console.log('|\\_/|'); 3 | console.log('|q p| /}') 4 | console.log('( 0 )"""\\') 5 | console.log('|"^"` |') 6 | console.log('||_/=\\\\__|') -------------------------------------------------------------------------------- /solutions/18310.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin').toString().split('\n'); 2 | let n = Number(input[0]); 3 | let arr = input[1].split(' ').map(Number); 4 | 5 | arr.sort((a, b) => a - b); 6 | 7 | // 가운데(median) 값을 출력 8 | console.log(arr[parseInt((n - 1) / 2)]); -------------------------------------------------------------------------------- /solutions/1427.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n'); 2 | 3 | let n = input[0]; 4 | let cnt = Array(10).fill(0); 5 | 6 | for (let x of n) { 7 | cnt[Number(x)]++; 8 | } 9 | 10 | let answer = ''; 11 | for (let i = 9; i >= 0; i--) { 12 | for (let j = 0; j < cnt[i]; j++) { 13 | answer += i + ''; 14 | } 15 | } 16 | console.log(answer); -------------------------------------------------------------------------------- /solutions/2437.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin').toString().split('\n'); 2 | 3 | let n = Number(input[0]); 4 | let data = input[1].split(' ').map(Number); 5 | 6 | data.sort((a, b) => a - b); // 오름차순 정렬 7 | 8 | let target = 1; 9 | for (x of data) { 10 | // 잴 수 없는 무게를 찾았을 때 11 | if (target < x) break; // 종료 12 | target += x; 13 | } 14 | 15 | // 잴 수 없는 무게 출력 16 | console.log(target); -------------------------------------------------------------------------------- /solutions/1000.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let a = Number(input[0].split(' ')[0]); 8 | let b = Number(input[0].split(' ')[1]); 9 | 10 | console.log(a + b); -------------------------------------------------------------------------------- /solutions/1001.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let a = Number(input[0].split(' ')[0]); 8 | let b = Number(input[0].split(' ')[1]); 9 | 10 | console.log(a - b); -------------------------------------------------------------------------------- /solutions/1008.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let a = Number(input[0].split(' ')[0]); 8 | let b = Number(input[0].split(' ')[1]); 9 | 10 | console.log(a / b); -------------------------------------------------------------------------------- /solutions/10998.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let a = Number(input[0].split(' ')[0]); 8 | let b = Number(input[0].split(' ')[1]); 9 | 10 | console.log(a * b); -------------------------------------------------------------------------------- /solutions/10773.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync("/dev/stdin").toString().split("\n"); 3 | 4 | let k = Number(input[0]); 5 | 6 | let stack = []; 7 | for (let i = 1; i <= k; i++) { 8 | let x = Number(input[i]); 9 | if (x == 0) stack.pop(); 10 | else stack.push(x); 11 | } 12 | 13 | let result = 0; 14 | for (let x of stack) { 15 | result += x; 16 | } 17 | console.log(result); 18 | -------------------------------------------------------------------------------- /solutions/1904.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | let n = Number(input[0]); 5 | let d = new Array(n + 1).fill(0); 6 | 7 | d[1] = 1; 8 | d[2] = 2; 9 | 10 | for (let x = 3; x <= n; x++) { 11 | d[x] += d[x - 1]; // 길이가 1만큼 작은 경우들에 [1] 타일 붙이기 12 | d[x] += d[x - 2]; // 길이가 2만큼 작은 경우들에 [00] 타일 붙이기 13 | d[x] %= 15746; // 값이 너무 큰 경우를 예방 14 | } 15 | 16 | console.log(d[n]); 17 | -------------------------------------------------------------------------------- /solutions/2741.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let n = Number(input[0]); 8 | let answer = ''; 9 | 10 | for (let i = 1; i <= n; i++) { 11 | answer += i + '\n'; 12 | } 13 | console.log(answer); -------------------------------------------------------------------------------- /solutions/2742.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let n = Number(input[0]); 8 | let answer = ''; 9 | 10 | for (let i = n; i >= 1; i--) { 11 | answer += i + '\n'; 12 | } 13 | console.log(answer); -------------------------------------------------------------------------------- /solutions/8393.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let n = Number(input[0]); 8 | let summary = 0; 9 | 10 | for (let i = 1; i <= n; i++) { 11 | summary += i; 12 | } 13 | 14 | console.log(summary); -------------------------------------------------------------------------------- /solutions/2739.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let n = Number(input[0]); 8 | 9 | for (let i = 1; i <= 9; i++) { 10 | // 템플릿 리터럴을 사용해 문자열 내부에 변수를 포함합니다. (백틱 문자 사용) 11 | console.log(`${n} * ${i} = ${n * i}`); 12 | } -------------------------------------------------------------------------------- /solutions/2750.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let n = Number(input[0]) 7 | let arr = [] 8 | 9 | for (let i = 1; i <= n; i++) { 10 | arr.push(Number(input[i])) 11 | } 12 | 13 | arr.sort((a, b) => a - b); 14 | 15 | for (let i = 0; i < n; i++) { 16 | console.log(arr[i]); 17 | } -------------------------------------------------------------------------------- /solutions/2753.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let year = Number(input[0]); 8 | 9 | if ((year % 4 == 0) && (year % 100 != 0 || year % 400 == 0)) { 10 | console.log(1); 11 | } 12 | else { 13 | console.log(0); 14 | } -------------------------------------------------------------------------------- /solutions/10818.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let n = Number(input[0]); 7 | let data = input[1].split(' ').map(Number); 8 | 9 | let minValue = data.reduce((a, b) => Math.min(a, b)); 10 | let maxValue = data.reduce((a, b) => Math.max(a, b)); 11 | 12 | console.log(minValue, maxValue); -------------------------------------------------------------------------------- /solutions/10951.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 한 줄씩 읽으며 처리 7 | let i = 0; 8 | while (i < input.length - 1) { // BOJ에서는 마지막에 줄바꿈 기호가 포함 9 | let data = input[i].split(' '); 10 | let a = Number(data[0]); 11 | let b = Number(data[1]); 12 | 13 | i += 1; 14 | console.log(a + b); 15 | } -------------------------------------------------------------------------------- /solutions/11650.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n'); 2 | 3 | let n = Number(input[0]); 4 | let arr = []; 5 | for (let i = 1; i <= n; i++) { 6 | arr.push(input[i].split(' ').map(Number)); 7 | } 8 | 9 | arr.sort((a, b) => { 10 | if (a[0] != b[0]) return a[0] - b[0]; 11 | else return a[1] - b[1]; 12 | }); 13 | 14 | let answer = ''; 15 | for (let point of arr) { 16 | answer += point[0] + ' ' + point[1] + '\n'; 17 | } 18 | console.log(answer); -------------------------------------------------------------------------------- /solutions/11651.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n'); 2 | 3 | let n = Number(input[0]); 4 | let arr = []; 5 | for (let i = 1; i <= n; i++) { 6 | arr.push(input[i].split(' ').map(Number)); 7 | } 8 | 9 | arr.sort((a, b) => { 10 | if (a[1] != b[1]) return a[1] - b[1]; 11 | else return a[0] - b[0]; 12 | }); 13 | 14 | let answer = ''; 15 | for (let point of arr) { 16 | answer += point[0] + ' ' + point[1] + '\n'; 17 | } 18 | console.log(answer); -------------------------------------------------------------------------------- /solutions/1463.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | let n = Number(input[0]); 5 | let d = new Array(n + 1).fill(0); 6 | 7 | for (let x = 2; x <= n; x++) { 8 | d[x] = d[x - 1]; // 1을 빼기 9 | if (x % 2 == 0) { 10 | d[x] = Math.min(d[x], d[parseInt(x / 2)]); // 2로 나누기 11 | } 12 | if (x % 3 == 0) { 13 | d[x] = Math.min(d[x], d[parseInt(x / 3)]); // 3으로 나누기 14 | } 15 | d[x]++; 16 | } 17 | 18 | console.log(d[n]); 19 | -------------------------------------------------------------------------------- /solutions/3052.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let data = input.map(Number); 7 | let mySet = new Set(); // 집합 객체 생성 8 | 9 | // 원소를 하나씩 확인하며 10 | for (let i = 0; i < 10; i++) { 11 | mySet.add(data[i] % 42); // 42로 나눈 나머지를 집합의 원소로 삽입 12 | } 13 | 14 | // 집합에 포함된 원소의 개수 출력 15 | console.log(mySet.size); -------------------------------------------------------------------------------- /solutions/10989.js: -------------------------------------------------------------------------------- 1 | /* 2 | 10989번 문제는 메모리 제한 때문에 node.js로 푸는 것이 사실상 불가능한 문제 3 | */ 4 | let input = require('fs').readFileSync('/dev/stdin').toString().split('\n'); 5 | 6 | let n = Number(input[0]); 7 | let cnt = Array(10001).fill(0); 8 | 9 | for (let i = 1; i <= n; i++) { 10 | let cur = Number(input[i]); 11 | cnt[cur] += 1; 12 | } 13 | 14 | let answer = ''; 15 | for (let i = 1; i <= 10000; i++) { 16 | for (let j = 0; j < cnt[i]; j++) { 17 | answer += i + '\n'; 18 | } 19 | } 20 | console.log(answer); -------------------------------------------------------------------------------- /solutions/2438.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let n = Number(input[0]); 8 | let answer = ''; 9 | 10 | for (let i = 1; i <= n; i++) { 11 | for (let j = 0; j < i; j++) { 12 | answer += '*'; 13 | } 14 | answer += '\n'; 15 | } 16 | console.log(answer); -------------------------------------------------------------------------------- /solutions/9461.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | let d = new Array(101).fill(0); // 다이나믹 테이블 초기화 5 | // 초기항 설정 6 | d[1] = 1; 7 | d[2] = 1; 8 | d[3] = 1; 9 | 10 | let testCases = Number(input[0]); 11 | let line = 1; 12 | 13 | while (testCases--) { 14 | let n = Number(input[line]); 15 | 16 | for (let x = 4; x <= n; x++) { 17 | d[x] = d[x - 2] + d[x - 3]; // 점화식에 따라서 계산 18 | } 19 | console.log(d[n]); 20 | 21 | line++; 22 | } 23 | -------------------------------------------------------------------------------- /solutions/10950.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let testCase = Number(input[0]); 8 | 9 | for (let t = 1; t <= testCase; t++) { 10 | let data = input[t].split(' '); 11 | let a = Number(data[0]); 12 | let b = Number(data[1]); 13 | console.log(a + b); 14 | } -------------------------------------------------------------------------------- /solutions/1181.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n'); 2 | 3 | let n = Number(input[0]); 4 | let arr = []; 5 | for (let i = 1; i <= n; i++) { 6 | arr.push(input[i]); 7 | } 8 | arr = [...new Set(arr)]; 9 | 10 | arr.sort((a, b) => { 11 | if (a.length != b.length) return a.length - b.length; 12 | else { 13 | if (a < b) return -1; 14 | else if (a > b) return 1; 15 | else return 0; 16 | } 17 | }); 18 | 19 | for (let x of arr) { 20 | console.log(x); 21 | } -------------------------------------------------------------------------------- /solutions/2751.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let n = Number(input[0]) 7 | let arr = [] 8 | 9 | for (let i = 1; i <= n; i++) { 10 | arr.push(Number(input[i])) 11 | } 12 | 13 | arr.sort((a, b) => a - b); 14 | let answer = ''; 15 | 16 | for (let i = 0; i < n; i++) { 17 | answer += arr[i] + '\n'; 18 | } 19 | console.log(answer); -------------------------------------------------------------------------------- /solutions/10869.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let a = Number(input[0].split(' ')[0]); 8 | let b = Number(input[0].split(' ')[1]); 9 | 10 | console.log(a + b); 11 | console.log(a - b); 12 | console.log(a * b); 13 | console.log(parseInt(a / b)); // 몫만 남기기 14 | console.log(a % b); -------------------------------------------------------------------------------- /solutions/19939.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin').toString().split('\n'); 2 | 3 | // 공의 개수 N과 바구니의 개수 K를 입력받기 4 | let n = Number(input[0].split(' ')[0]); 5 | let k = Number(input[0].split(' ')[1]); 6 | 7 | // 1부터 K까지의 합 8 | let summary = 0; 9 | for (let i = 1; i < k + 1; i++) { 10 | summary += i; 11 | } 12 | 13 | // 공의 개수가 부족한 경우 14 | if (summary > n) { 15 | console.log(-1); 16 | } 17 | else { 18 | n -= summary; 19 | if (n % k == 0) console.log(k - 1); // K개에 각각 1씩 더하기 20 | else console.log(k); 21 | } -------------------------------------------------------------------------------- /solutions/2562.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let maxIndex = 0; 7 | let maxValue = 0; 8 | for (let i = 0; i < 9; i++) { // 모든 데이터를 하나씩 확인하며 9 | let data = Number(input[i]); 10 | if (maxValue < data) { 11 | maxValue = data; 12 | maxIndex = i; 13 | } 14 | } 15 | 16 | console.log(maxValue); 17 | console.log(maxIndex + 1); -------------------------------------------------------------------------------- /solutions/11399.js: -------------------------------------------------------------------------------- 1 | /* 2 | 문제 요약: 각 사람이 돈을 인출하는데 필요한 시간의 합의 최솟값을 계산 3 | 해결 방법: 처리 시간이 빠른 사람부터 처리할 때, 필요한 시간의 합이 최소가 됨 4 | */ 5 | 6 | let input = require('fs').readFileSync('/dev/stdin').toString().split('\n'); 7 | 8 | let n = Number(input[0]); // 회의의 개수 9 | let arr = input[1].split(' ').map(Number); 10 | 11 | // 오름차순 정렬 12 | arr.sort((a, b) => a - b); 13 | 14 | let answer = 0; 15 | let summary = 0; 16 | for (let i = 0; i < n; i++) { 17 | summary += arr[i]; // i번째 사람이 기다린 총 시간 18 | answer += summary; 19 | } 20 | 21 | console.log(answer); -------------------------------------------------------------------------------- /solutions/1330.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let a = Number(input[0].split(' ')[0]); 8 | let b = Number(input[0].split(' ')[1]); 9 | 10 | if (a > b) { 11 | console.log('>'); 12 | } 13 | else if (a < b) { 14 | console.log('<'); 15 | } 16 | else { 17 | console.log('=='); 18 | } -------------------------------------------------------------------------------- /solutions/10814.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n'); 2 | 3 | let n = Number(input[0]); 4 | let arr = []; 5 | for (let i = 1; i <= n; i++) { 6 | let age = Number(input[i].split(' ')[0]); 7 | let name = input[i].split(' ')[1]; 8 | arr.push([age, name]); 9 | } 10 | 11 | // Node.js의 정렬은 기본적으로 stable 12 | arr.sort((a, b) => { 13 | if (a[0] != b[0]) return a[0] - b[0]; 14 | }); 15 | 16 | let answer = ''; 17 | for (let x of arr) { 18 | answer += x[0] + ' ' + x[1] + '\n'; 19 | } 20 | console.log(answer); -------------------------------------------------------------------------------- /solutions/11021.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let testCase = Number(input[0]); 8 | 9 | for (let t = 1; t <= testCase; t++) { 10 | let data = input[t].split(' '); 11 | let a = Number(data[0]); 12 | let b = Number(data[1]); 13 | console.log(`Case #${t}: ${a + b}`); // 템플릿 리터럴을 활용한 문자열 출력 14 | } -------------------------------------------------------------------------------- /solutions/1448.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin').toString().split('\n'); 2 | let n = Number(input[0]); 3 | 4 | let arr = []; 5 | for (let i = 1; i <= n; i++) { 6 | arr.push(Number(input[i])); 7 | } 8 | // 오름차순 정렬 9 | arr.sort((a, b) => a - b); 10 | 11 | let result = -1; 12 | for (let i = 0; i < n - 2; i++) { 13 | // 삼각형 둘레의 최댓값을 구하는 것이므로 인접한 3개만 확인 14 | let a = arr[i]; 15 | let b = arr[i + 1]; 16 | let c = arr[i + 2]; 17 | if (c < a + b) { // 삼각형의 조건에 부합한다면 18 | result = a + b + c; 19 | } 20 | } 21 | 22 | console.log(result); -------------------------------------------------------------------------------- /solutions/10952.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 한 줄씩 읽으며 처리 7 | let i = 0; 8 | while (true) { 9 | let data = input[i].split(' '); 10 | let a = Number(data[0]); 11 | let b = Number(data[1]); 12 | 13 | // a와 b가 모두 0일 때 프로그램 종료 14 | if (a == 0 && b == 0) { 15 | break; 16 | } 17 | else { 18 | console.log(a + b); 19 | } 20 | i++; 21 | } -------------------------------------------------------------------------------- /solutions/15552.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let testCase = Number(input[0]); 8 | let answer = ''; 9 | 10 | for (let t = 1; t <= testCase; t++) { 11 | let data = input[t].split(' '); 12 | let a = Number(data[0]); 13 | let b = Number(data[1]); 14 | answer += a + b + '\n'; 15 | } 16 | 17 | console.log(answer); -------------------------------------------------------------------------------- /solutions/10430.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let a = Number(input[0].split(' ')[0]); 8 | let b = Number(input[0].split(' ')[1]); 9 | let c = Number(input[0].split(' ')[2]); 10 | 11 | console.log((a + b) % c); 12 | console.log(((a % c) + (b % c)) % c); 13 | console.log((a * b) % c); 14 | console.log(((a % c) * (b % c)) % c); -------------------------------------------------------------------------------- /solutions/2439.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let n = Number(input[0]); 8 | let answer = ''; 9 | 10 | for (let i = 1; i <= n; i++) { 11 | for (let j = 0; j < n - i; j++) { 12 | answer += ' '; 13 | } 14 | for (let j = 0; j < i; j++) { 15 | answer += '*'; 16 | } 17 | answer += '\n'; 18 | } 19 | console.log(answer); -------------------------------------------------------------------------------- /solutions/1541.js: -------------------------------------------------------------------------------- 1 | /* 2 | 문제 요약: 덧셈(+)와 뺄셈(-) 연산자로만 구성된 수식이 있을 때, 괄호를 적절히 넣어 값을 최소화 3 | 해결 방법: 뺄셈(-) 연산자를 기준으로 최대한 많은 수를 묶기 4 | */ 5 | 6 | let input = require('fs').readFileSync('/dev/stdin').toString().split('\n'); 7 | 8 | // 뺄셈(-) 연산자를 기준으로 나누어 여러 그룹 만들기 9 | let groups = input[0].split('-'); 10 | let answer = 0; 11 | for (let i = 0; i < groups.length; i++) { 12 | // 각 그룹 내부에서 덧셈(+) 연산 적용 13 | let cur = groups[i].split('+').map(Number).reduce((a, b) => a + b); 14 | if (i == 0) answer += cur; // 첫 번째 그룹은 항상 덧셈(+) 15 | else answer -= cur; // 두 번째 그룹부터 뺄셈(-) 16 | } 17 | 18 | console.log(answer); -------------------------------------------------------------------------------- /solutions/1546.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let n = Number(input[0]); 7 | let scores = input[1].split(' ').map(Number); 8 | 9 | let maxValue = scores.reduce((a, b) => Math.max(a, b)); 10 | let updated = []; 11 | for (let i = 0; i < n; i++) { // 수정된 원소 하나씩 저장 12 | updated.push(scores[i] / maxValue * 100); 13 | } 14 | 15 | // 배열에 포함된 원소의 평균 출력 16 | console.log(updated.reduce((a, b) => a + b) / n); -------------------------------------------------------------------------------- /solutions/2884.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let hour = Number(input[0].split(' ')[0]); 8 | let minute = Number(input[0].split(' ')[1]); 9 | 10 | if (minute >= 45) { 11 | minute -= 45; 12 | } 13 | else { 14 | hour -= 1; 15 | minute = minute + 15; 16 | if (hour == -1) { 17 | hour = 23; 18 | } 19 | } 20 | 21 | console.log(hour, minute); -------------------------------------------------------------------------------- /solutions/2588.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let a = Number(input[0]); 8 | let b = Number(input[1]); 9 | 10 | let b_1 = Number(input[1][2]); // 1의 자리 11 | let b_10 = Number(input[1][1]); // 10의 자리 12 | let b_100 = Number(input[1][0]); // 100의 자리 13 | 14 | console.log(a * b_1); 15 | console.log(a * b_10); 16 | console.log(a * b_100); 17 | console.log(a * b); -------------------------------------------------------------------------------- /solutions/11047.js: -------------------------------------------------------------------------------- 1 | /* 2 | 문제 요약: 동전을 최소한으로 사용해 K원을 만들기 3 | 해결 방법: 가치가 큰 동전부터 나누어 주기, 가치가 큰 동전은 가치가 작은 동전들의 합으로 표현될 수 있기 때문에 성립 4 | */ 5 | 6 | let input = require('fs').readFileSync('/dev/stdin').toString().split('\n'); 7 | 8 | let n = Number(input[0].split(' ')[0]); // 동전의 개수 9 | let k = Number(input[0].split(' ')[1]); // 만들어야 할 금액 10 | 11 | let arr = []; 12 | for (let i = 1; i <= n; i++) { 13 | arr.push(Number(input[i])); 14 | } 15 | 16 | let cnt = 0; 17 | // 가치가 큰 동전부터 확인 18 | for (let i = n - 1; i >= 0; i--) { 19 | cnt += parseInt(k / arr[i]); // 해당 동전을 몇 개 사용해야 하는지 20 | k %= arr[i]; 21 | } 22 | 23 | console.log(cnt); -------------------------------------------------------------------------------- /solutions/1337.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin').toString().split('\n'); 2 | 3 | let n = Number(input[0]); 4 | 5 | let arr = []; 6 | for (let i = 1; i <= n; i++) { 7 | arr.push(Number(input[i])); 8 | } 9 | 10 | // 오름차순 정렬 11 | arr.sort((a, b) => a - b); 12 | 13 | let result = 0; // 연속적인 수열 길이의 최댓값 14 | for (let i = 0; i < n; i++) { 15 | let cnt = 0; // 현재 수부터의 연속적인 수열 길이 16 | for (let j = 0; j < 5; j++) { 17 | // 존재하는지 확인 18 | if (arr.slice(i, i + 5).includes(arr[i] + j)) { 19 | cnt += 1; 20 | } 21 | result = Math.max(result, cnt); 22 | } 23 | } 24 | 25 | console.log(5 - result); -------------------------------------------------------------------------------- /solutions/2577.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let first = Number(input[0]); 7 | let second = Number(input[1]); 8 | let third = Number(input[2]); 9 | let value = first * second * third + ""; // 세 수를 곱하여 문자열로 변환 10 | 11 | let cnt = new Array(10).fill(0); // 값이 0인 10개의 원소를 포함하는 배열 생성 12 | 13 | for (let i = 0; i < value.length; i++) { 14 | cnt[Number(value[i])]++; 15 | } 16 | for (let i = 0; i < 10; i++) { 17 | console.log(cnt[i]); 18 | } -------------------------------------------------------------------------------- /solutions/9498.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let a = Number(input[0].split(' ')[0]); 8 | let b = Number(input[0].split(' ')[1]); 9 | 10 | if (a >= 90) { 11 | console.log('A'); 12 | } 13 | else if (a >= 80) { 14 | console.log('B'); 15 | } 16 | else if (a >= 70) { 17 | console.log('C'); 18 | } 19 | else if (a >= 60) { 20 | console.log('D'); 21 | } 22 | else { 23 | console.log('F'); 24 | } -------------------------------------------------------------------------------- /solutions/2480.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | let a = Number(input[0].split(' ')[0]); 5 | let b = Number(input[0].split(' ')[1]); 6 | let c = Number(input[0].split(' ')[2]); 7 | 8 | // 세 개의 수가 모두 같은 경우 9 | if (a == b && b == c) { 10 | console.log(10000 + a * 1000); 11 | } 12 | // 세 개의 수가 전부 같지는 않지만, 두 개의 수가 같은 경우 13 | else if (a == b) { 14 | console.log(1000 + a * 100); 15 | } 16 | else if (a == c) { 17 | console.log(1000 + a * 100); 18 | } 19 | else if (b == c) { 20 | console.log(1000 + b * 100); 21 | } 22 | // 세 개의 수가 전부 다른 경우 23 | else { 24 | console.log(Math.max(a, b, c) * 100); 25 | } 26 | -------------------------------------------------------------------------------- /solutions/10871.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let n = Number(input[0].split(' ')[0]); 8 | let x = Number(input[0].split(' ')[1]); 9 | let answer = ''; 10 | 11 | // 배열의 모든 원소를 수 자료형으로 변환 12 | let data = input[1].split(' ').map(num => Number(num)); 13 | 14 | // 배열의 값에 하나씩 접근 15 | for (let cur of data) { 16 | // 그 값이 x보다 작은 경우 출력 17 | if (cur < x) { 18 | answer += cur + ' '; 19 | } 20 | } 21 | console.log(answer); -------------------------------------------------------------------------------- /solutions/8958.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let n = Number(input[0]); 7 | 8 | // n개의 문자열을 차례대로 확인 9 | for (let i = 1; i <= n; i++) { 10 | let data = input[i]; 11 | 12 | // 문자열에서 점수 계산 13 | let score = 0; 14 | let length = 0; 15 | for (let char of data) { 16 | // 정답인 경우 17 | if (char == 'O') { 18 | // 연속된 'O'의 개수만큼 점수에 더하기 19 | score += length + 1; 20 | length += 1; 21 | } 22 | else { 23 | length = 0; 24 | } 25 | } 26 | console.log(score); 27 | } -------------------------------------------------------------------------------- /solutions/18870.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n'); 2 | 3 | let n = Number(input[0]); 4 | let arr = input[1].split(' ').map(Number); 5 | 6 | /* 7 | arr = [2, 4, -10, 4, -9] 8 | set = [2, 4, -10, -9] 9 | sorted = [-10, -9, 2, 4] 10 | map = { 11 | '-10': 0, 12 | '-9': 1, 13 | '2': 2, 14 | '4': 3 15 | } 16 | print(map[arr[i]]) 17 | */ 18 | 19 | let uniqueArray = [...new Set(arr)]; 20 | uniqueArray.sort((a, b) => a - b); 21 | 22 | let myMap = new Map(); 23 | for (let i = 0; i < uniqueArray.length; i++) { 24 | myMap.set(uniqueArray[i], i); 25 | } 26 | 27 | answer = ''; 28 | for (x of arr) { 29 | answer += myMap.get(x) + ' '; 30 | } 31 | console.log(answer); -------------------------------------------------------------------------------- /solutions/4673.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | // let fs = require('fs'); 3 | // let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | function d(n) { 7 | let result = 0; 8 | let str = n + ""; 9 | for (let i = 0; i < str.length; i++) { 10 | result += Number(str[i]); 11 | } 12 | return result + n; 13 | } 14 | 15 | let selfNumber = new Array(10001).fill(true); 16 | 17 | for (let i = 1; i <= 10000; i++) { 18 | let cur = d(i); 19 | if (cur <= 10000) { 20 | selfNumber[cur] = false; 21 | } 22 | } 23 | 24 | for (let i = 1; i <= 10000; i++) { 25 | if (selfNumber[i]) { 26 | console.log(i); 27 | } 28 | } -------------------------------------------------------------------------------- /solutions/1110.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let n = Number(input[0]); 7 | let start = n; // 처음에 입력된 수 8 | let cnt = 0; // 사이클의 길이 9 | 10 | while (true) { 11 | // n을 문자열로 변경 12 | n = n + ""; 13 | // 10보다 작은 경우 앞에 0을 붙이기 14 | if (n.length == 1) { 15 | n = "0" + n; 16 | } 17 | // 자릿수의 합 18 | summary = Number(n[0]) + Number(n[1]); 19 | // 주어진 수의 가장 오른쪽 자리 수와 자릿수의 합의 가장 오른쪽 자리 수를 이어 붙이기 20 | n = Number(n[1]) * 10 + summary % 10; 21 | 22 | // 사이클의 길이 23 | cnt += 1; 24 | if (n == start) break; 25 | } 26 | 27 | console.log(cnt); -------------------------------------------------------------------------------- /solutions/13305.js: -------------------------------------------------------------------------------- 1 | /* 2 | 문제 요약: 제일 왼쪽 도시에서 제일 오른쪽 도시로 가는 최소 비용을 계산 3 | 해결 방법: 주유 비용이 내림차순이 되도록 변환한 뒤에, 도로당 이동 비용의 합 계산 4 | */ 5 | 6 | let input = require('fs').readFileSync('/dev/stdin').toString().split('\n'); 7 | 8 | let n = Number(input[0]); 9 | let dist = input[1].split(' ').map(Number); 10 | let cost = input[2].split(' ').map(Number); 11 | 12 | // 주유 비용(cost) 배열의 값을 내림차순이 되도록 변환 13 | // [5, 2, 4, 1] -> [5, 2, 2, 1] 14 | let minCost = cost[0]; 15 | for (let i = 0; i < n; i++) { 16 | minCost = Math.min(minCost, cost[i]); 17 | cost[i] = minCost; 18 | } 19 | 20 | // 도로당 이동 비용의 합 계산 21 | let answer = BigInt(0); 22 | for (let i = 0; i < n - 1; i++) { 23 | answer += BigInt(dist[i]) * BigInt(cost[i]); 24 | } 25 | console.log(String(answer)); // 뒤에 붙는 'n' 제거 -------------------------------------------------------------------------------- /solutions/9009.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin').toString().split('\n'); 2 | 3 | // 피보나치 수들 계산 4 | pibo = []; 5 | pibo.push(0); 6 | pibo.push(1); 7 | while (pibo[pibo.length - 1] < 1e9) pibo.push(pibo[pibo.length - 2] + pibo[pibo.length - 1]); 8 | 9 | let testCases = Number(input[0]); 10 | for (let tc = 1; tc <= testCases; tc++) { 11 | let n = Number(input[tc]); 12 | let result = []; 13 | let i = pibo.length - 1; // 가장 큰 피보나치 수의 인덱스 14 | while (n > 0) { // n이 0이 될 때까지 15 | if (n >= pibo[i]) { // 가능한 큰 피보나치 수부터 빼기 16 | n -= pibo[i]; 17 | result.push(pibo[i]); 18 | } 19 | i--; 20 | } 21 | let answer = ''; 22 | for (let i = result.length - 1; i >= 0; i--) answer += result[i] + ' '; // 오름차순 출력 23 | console.log(answer); 24 | } -------------------------------------------------------------------------------- /solutions/1789.js: -------------------------------------------------------------------------------- 1 | /* 2 | 아이디어: 일단 작은 수부터 더하는 게 좋다. 3 | S = 200일 때, 일단 1부터 더한 뒤에, S를 넘지 않도록 한다. 4 | 5 | 가설: 1, 2, 3, ... 순서대로 더했을 때 S를 넘지 않도록 하되 6 | 최대한 많이 더한다. 그때까지의 수의 개수가 정답이다. 7 | 8 | 검증: 1, 2, 3, 4, 5, 6, ..., 18, 19까지 더하면 190이다. 9 | 이때 19 대신에 29로 바꾸어주면 200이 나온다. 10 | 이것이 최댓값. 따라서 답은 19 11 | */ 12 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽기 13 | let file = require('fs').readFileSync('/dev/stdin'); 14 | let input = file.toString().split('\n'); 15 | 16 | let n = Number(input[0]); // 자연수 N 입력 17 | 18 | let i = 1; // 1부터 더해나가도록 19 | let summary = 0; // 합계 20 | let cnt = 0; 21 | while (true) { 22 | // 현재 i를 더한 경우 N보다 커진다면 종료 23 | if (summary + i > n) break; 24 | // 그렇지 않으면, i를 합계에 더해주고 i를 1만큼 증가 25 | summary += i; 26 | i += 1; 27 | cnt += 1; 28 | } 29 | console.log(cnt); 30 | -------------------------------------------------------------------------------- /solutions/11022.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 7 | let testCase = Number(input[0]); 8 | 9 | for (let t = 1; t <= testCase; t++) { 10 | let data = input[t].split(' '); 11 | let a = Number(data[0]); 12 | let b = Number(data[1]); 13 | console.log(`Case #${t}: ${a} + ${b} = ${a + b}`); // 템플릿 리터럴을 활용한 문자열 출력 14 | } 15 | 16 | /* 17 | let n = Number(input[0]); 18 | for (let i = 1; i <= n; i++) { 19 | let [a, b] = input[i].split(' ').map(Number); 20 | console.log(`Case #${i}: ${a} + ${b} = ${a + b}`); 21 | } 22 | */ 23 | -------------------------------------------------------------------------------- /solutions/14681.js: -------------------------------------------------------------------------------- 1 | // 일부 문제의 경우 fs를 이용하면 permission denied 오류가 발생 2 | // 본 문제에서는 readline 모듈을 이용해 문제를 해결 3 | const readline = require("readline"); 4 | const rl = readline.createInterface({ 5 | input: process.stdin, 6 | output: process.stdout 7 | }); 8 | 9 | let input = []; 10 | 11 | rl.on("line", function (line) { 12 | input.push(line); 13 | }).on("close", function () { 14 | // 문자열을 수로 변환할 때 parseInt에 비하여 Number의 속도가 더 빠르게 동작 15 | let x = Number(input[0]); 16 | let y = Number(input[1]); 17 | 18 | if (x > 0 && y > 0) { 19 | console.log(1); 20 | } 21 | else if (x < 0 && y > 0) { 22 | console.log(2); 23 | } 24 | else if (x < 0 && y < 0) { 25 | console.log(3); 26 | } 27 | else if (x > 0 && y < 0) { 28 | console.log(4); 29 | } 30 | }); -------------------------------------------------------------------------------- /solutions/2910.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin').toString().split('\n'); 2 | let n = Number(input[0].split(' ')[0]); 3 | let c = Number(input[0].split(' ')[1]); 4 | let arr = input[1].split(' ').map(Number); 5 | 6 | // 각 원소마다 출현 빈도수 기록 7 | let counter = new Map(); 8 | for (let i = 0; i < n; i++) { 9 | if (counter.has(arr[i])) counter.set(arr[i], counter.get(arr[i]) + 1); 10 | else counter.set(arr[i], 1); 11 | } 12 | 13 | // JavaScript의 Map은 삽입 순서를 보존 14 | let data = counter.entries(); 15 | // 빈도수를 기준으로 내림차순 정렬 (Node.js의 정렬은 stable) 16 | let sorted = [ ... data].sort((a, b) => b[1] - a[1]); 17 | let answer = ''; 18 | for (let i = 0; i < sorted.length; i++) // 각 원소에 대하여 19 | for (let j = 0; j < sorted[i][1]; j++) // 빈도수만큼 출력 20 | answer += sorted[i][0] + ' '; 21 | console.log(answer); -------------------------------------------------------------------------------- /solutions/2606.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | let n = Number(input[0]); // 노드의 개수(N) 5 | let m = Number(input[1]); // 간선의 개수(M) 6 | 7 | let graph = []; // 전체 그래프(graph) 정보 8 | for (let i = 0; i <= n; i++) graph.push([]); 9 | /// 각 노드에 대한 방문 여부 10 | let visited = new Array(n + 1).fill(false); 11 | let result = 0; // 정답 12 | 13 | for (let i = 2; i < m + 2; i++) { // 전체 간선 입력받기 14 | let [x, y] = input[i].split(' ').map(Number); 15 | graph[x].push(y); 16 | graph[y].push(x); 17 | } 18 | 19 | function dfs(x) { 20 | visited[x] = true; // 방문 처리 21 | result++; // 카운트 22 | for (let i of graph[x]) { 23 | // 인접한 노드 중에서 방문하지 않은 노드 방문 24 | if (visited[i] == false) { 25 | dfs(i); 26 | } 27 | } 28 | } 29 | 30 | dfs(1); 31 | console.log(result - 1); 32 | -------------------------------------------------------------------------------- /solutions/1931.js: -------------------------------------------------------------------------------- 1 | /* 2 | 문제 요약: 각 회의가 겹치지 않게 하면서 회의실을 사용할 수 있는 회의의 최대 개수 계산 (Activity Selection Problem) 3 | 해결 방법: 1) 종료 시점 2) 시작 시점을 우선순위로 오름차순 정렬을 수행한 뒤에, 첫 번째 회의부터 시작해 겹치지 않게 최대한 많은 회의 선택 4 | */ 5 | 6 | let input = require('fs').readFileSync('/dev/stdin').toString().split('\n'); 7 | 8 | let n = Number(input[0]); // 회의의 개수 9 | 10 | let arr = []; 11 | for (let i = 1; i <= n; i++) { 12 | arr.push(input[i].split(' ').map(Number)); 13 | } 14 | 15 | // 1) 종료 시점 2) 시작 시점을 우선순위로 오름차순 정렬 16 | arr.sort(function (a, b) { 17 | if (a[1] != b[1]) return a[1] - b[1]; 18 | else return a[0] - b[0]; 19 | }); 20 | 21 | let cnt = 1; 22 | let cur = 0; // 첫 번째 회의부터 확인 23 | 24 | for (let i = 1; i < n; i++) { 25 | // 현재 회의가 끝난 이후에 회의가 시작되는 경우 카운트 26 | if (arr[cur][1] <= arr[i][0]) { 27 | cur = i; 28 | cnt += 1; 29 | } 30 | } 31 | 32 | console.log(cnt); -------------------------------------------------------------------------------- /solutions/2294.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | /* 5 | 시간 복잡도: O(NM) 6 | 각 동전들을 하나씩 확인하면서, 최소 개수 테이블(정답 테이블)을 갱신 7 | */ 8 | 9 | let INF = 10001; 10 | let [n, k] = input[0].split(' ').map(Number); 11 | let d = new Array(k + 1).fill(INF); // 처음에는 모든 금액 만들 수 없음 12 | let arr = []; 13 | 14 | for (let i = 1; i <= n; i++) { 15 | arr.push(Number(input[i])); // 각 동전 데이터 입력 16 | } 17 | 18 | d[0] = 0; // 동전을 아예 안 쓰면, 0원이 되므로 19 | for (let coin of arr) { // 하나씩 동전을 확인하며 20 | for (let x = 0; x <= k - coin; x++) { // x원을 만들 수 있는지 확인 21 | if (d[x] != INF) { // x원을 만들 수 있다면, (x + coin)원도 만들 수 있음 22 | d[x + coin] = Math.min(d[x + coin], d[x] + 1); 23 | } 24 | } 25 | } 26 | 27 | if (d[k] == INF) console.log(-1); // k원을 만들 수 없는 경우 28 | else console.log(d[k]); // k원을 만들 수 있는 경우 29 | -------------------------------------------------------------------------------- /solutions/1932.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | let n = Number(input[0]); // 정수 삼각형의 크기 5 | let arr = []; // 정수 삼각형 데이터 6 | let d = []; // 최적의 해가 담기는 다이나믹 프로그래밍 테이블 7 | 8 | for (let i = 1; i <= n; i++) { 9 | let line = input[i].split(' ').map(Number); 10 | arr.push(line); 11 | d.push(new Array(i).fill(0)); 12 | } 13 | 14 | d[0][0] = arr[0][0]; // 첫 번째 층(행) 15 | for (let i = 1; i < n; i++) { // 두 번째 층(행)부터 테이블 갱신 16 | for (let j = 0; j <= i; j++) { 17 | // 왼쪽 위에서 오는 경우 18 | let leftUp = 0; 19 | if (j > 0) leftUp = d[i - 1][j - 1]; 20 | // 바로 위에서 오는 경우 21 | let up = 0; 22 | if (j < i) up = d[i - 1][j]; 23 | d[i][j] = Math.max(leftUp, up) + arr[i][j]; 24 | } 25 | } 26 | 27 | // 가장 마지막 층(행)에서 가장 큰 값을 출력 28 | console.log(d[n - 1].reduce((a, b) => Math.max(a, b))); 29 | -------------------------------------------------------------------------------- /solutions/1065.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | function f(n) { 7 | let str = n + ""; 8 | if (n.length == 1) { 9 | return true; 10 | } 11 | else { 12 | // 두 항의 차이 계산 13 | let diff = Number(str[1]) - Number(str[0]); 14 | // 등차 수열인지 확인 15 | for (let i = 1; i < str.length - 1; i++) { 16 | if (Number(str[i + 1]) - Number(str[i]) != diff) { 17 | return false; 18 | } 19 | } 20 | } 21 | return true; 22 | } 23 | 24 | let n = Number(input[0]); 25 | let result = 0; 26 | 27 | // 1부터 n까지 한수의 개수 계산 28 | for (let i = 1; i <= n; i++) { 29 | if (f(i)) { 30 | result += 1; 31 | } 32 | } 33 | console.log(result); -------------------------------------------------------------------------------- /solutions/11509.js: -------------------------------------------------------------------------------- 1 | const rl = require('readline').createInterface({ 2 | input: process.stdin, 3 | output: process.stdout 4 | }); 5 | 6 | let input = []; 7 | rl.on('line', function(line) { 8 | input.push(line); 9 | }).on('close', function() { 10 | solution(input); 11 | process.exit(); 12 | }) 13 | 14 | function solution(input) { 15 | // 풍선의 개수 N 입력받기 16 | let n = Number(input[0]); 17 | // 모든 풍선의 위치 정보 입력받기 18 | let data = input[1].split(' ').map(Number); 19 | 20 | let result = 0; 21 | let arrow = Array(1000001).fill(0); // 각 위치에 있는 화살의 개수 22 | 23 | for (let x of data) { 24 | if (arrow[x] > 0) { // 해당 높이에 화살이 있다면 25 | // 화살이 풍선을 맞추고 높이 감소 26 | arrow[x]--; 27 | arrow[x - 1]++; 28 | } 29 | else { // 해당 높이에 화살이 없다면 30 | // 해당 높이에 화살 쏘기 31 | result += 1; 32 | arrow[x - 1]++; 33 | } 34 | } 35 | console.log(result); 36 | } -------------------------------------------------------------------------------- /solutions/4344.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let testCases = Number(input[0]); 7 | 8 | // 각각의 테스트 케이스를 확인 9 | for (let t = 1; t <= testCases; t++) { 10 | let data = input[t].split(' ').map(Number); 11 | // 첫 번째 수는 데이터의 개수 12 | let n = data[0]; 13 | // n개의 점수에 대하여 평균 계산 14 | let summary = 0; 15 | for (let i = 1; i <= n; i++) { 16 | summary += data[i]; 17 | } 18 | let average = summary / n; 19 | // 점수가 평균을 넘는 학생 수 계산 20 | let cnt = 0; 21 | for (let i = 1; i <= n; i++) { 22 | if (data[i] > average) { 23 | cnt += 1; 24 | } 25 | } 26 | // 점수가 평균을 넘는 학생의 비율에 toFixed()를 이용해 소수점 아래 셋째 자리까지 출력 27 | console.log(`${(cnt / n * 100).toFixed(3)}%`); 28 | } -------------------------------------------------------------------------------- /solutions/11536.js: -------------------------------------------------------------------------------- 1 | const rl = require('readline').createInterface({ 2 | input: process.stdin, 3 | output: process.stdout 4 | }); 5 | 6 | let input = []; 7 | rl.on('line', function(line) { 8 | input.push(line); 9 | }).on("close", function() { 10 | solution(input); 11 | process.exit(); 12 | }); 13 | 14 | function solution(input) { 15 | let n = Number(input[0]); 16 | 17 | let names = []; 18 | for (let i = 1; i <= n; i++) { 19 | names.push(input[i]); 20 | } 21 | 22 | let increasing = true; 23 | let decreasing = true; 24 | 25 | for (let i = 0; i < n - 1; i++) { 26 | if (names[i] < names[i + 1]) { // 증가한다면 27 | decreasing = false; 28 | } 29 | else if (names[i] > names[i + 1]) { // 감소한다면 30 | increasing = false; 31 | } 32 | } 33 | 34 | if (increasing) console.log('INCREASING'); 35 | else if (decreasing) console.log('DECREASING'); 36 | else console.log('NEITHER'); 37 | } -------------------------------------------------------------------------------- /solutions/12015.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | // 정렬된 순서를 유지하면서 배열에 삽입할 가장 왼쪽 인덱스 반환 5 | function lowerBound(arr, target, start, end) { 6 |   while (start < end) { 7 |     let mid = parseInt((start + end) / 2); 8 |     if (arr[mid] >= target) end = mid; // 최대한 왼쪽으로 이동하기 9 |     else start = mid + 1; 10 |   } 11 |   return end; 12 | } 13 | 14 | let n = Number(input[0]); // 데이터의 개수(N) 15 | let arr = input[1].split(' ').map(Number); // 수열 입력 16 | 17 | // LIS 배열 18 | let d = [0]; 19 | 20 | // 이진 탐색을 활용한 LIS 알고리즘 수행 21 | for (let i = 0; i < n; i++) { 22 | let x = arr[i]; 23 |   // 마지막 원소보다 현재 원소 x가 크다면 가장 뒤에 넣기 24 |   if (d[d.length - 1] < x) d.push(x); 25 |   // x 이하인 원소가 있다면, 가능한 왼쪽에 있는 원소와 x를 교체 26 |   else { 27 |     let index = lowerBound(d, x, 0, d.length); 28 |     d[index] = x; 29 |   } 30 | } 31 | 32 | // 가장 긴 증가하는 부분 수열의 길이 출력 33 | console.log(d.length - 1); 34 | -------------------------------------------------------------------------------- /solutions/10828.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | let n = Number(input[0]); // 연산 횟수 5 | let stack = []; // 스택 초기화 6 | 7 | let answer = ''; 8 | for (let i = 1; i <= n; i++) { 9 | let line = input[i].split(' '); 10 | if (line[0] == 'push') { // 원소 삽입 11 | stack.push(Number(line[1])); 12 | } 13 | else if (line[0] == 'pop') { // 원소 삭제 14 | if (stack.length == 0) answer += -1 + '\n'; 15 | else answer += stack.pop() + '\n'; 16 | } 17 | else if (line[0] == 'size') { // 원소의 개수 18 | answer += stack.length + '\n'; 19 | } 20 | else if (line[0] == 'empty') { // 스택이 비어있는지 21 | if (stack.length == 0) answer += 1 + '\n'; 22 | else answer += 0 + '\n'; 23 | } 24 | else if (line[0] == 'top') { // 최상단 원소 출력 25 | if (stack.length == 0) answer += -1 + '\n'; 26 | else answer += stack[stack.length - 1] + '\n'; 27 | } 28 | } 29 | console.log(answer); 30 | -------------------------------------------------------------------------------- /solutions/17609.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin').toString().split('\n'); 2 | 3 | function palindrome(x) { 4 | return x == x.split('').reverse().join(''); 5 | } 6 | 7 | let testCases = Number(input[0]); 8 | for (let tc = 1; tc <= testCases; tc++) { // 문자열을 하나씩 입력받아 처리 9 | let data = input[tc]; 10 | if (palindrome(data)) console.log(0); // 회문인 경우 11 | else { // 회문이 아닌 경우, 유사 회문인지 검사 12 | let found = false; 13 | let n = data.length; // 문자열의 길이 14 | for (let i = 0; i < parseInt(n / 2); i++) { 15 | if (data[i] != data[n - i - 1]) { // 대칭이 아닌 인덱스를 찾은 경우 16 | // 앞쪽에 있는 해당 원소를 제거해 본 뒤에 회문 검사 17 | if (palindrome(data.slice(0, i) + data.slice(i + 1, n))) found = true; 18 | // 뒤쪽에 있는 해당 원소를 제거해 본 뒤에 회문 검사 19 | if (palindrome(data.slice(0, n - i - 1) + data.slice(n - i, n))) found = true; 20 | break; 21 | } 22 | } 23 | if (found) console.log(1); // 유사 회문인 경우 24 | else console.log(2); // 회문도 유사 회문도 아닌 경우 25 | } 26 | } -------------------------------------------------------------------------------- /solutions/2512.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let n = Number(input[0].split(' ')[0]); // 지방의 수(N) 7 | let arr = input[1].split(' ').map(Number); // 각 지방의 예산 요청 8 | let m = Number(input[2]); // 총 예산(M) 9 | 10 | // 이진 탐색을 위한 시작점(start)과 끝점(end) 설정 11 | let start = 1; 12 | let end = arr.reduce((a, b) => Math.max(a, b)); 13 | 14 | // 이진 탐색 수행(반복적) 15 | let result = 0; 16 | while (start <= end) { 17 | let mid = parseInt((start + end) / 2); // 현재의 중간점(상한액) 18 | 19 | // 배정된 예산의 총액 계산 20 | let total = 0; 21 | for (x of arr) { // 각 지방에서 요청한 예산을 하나씩 확인하며 22 | total += Math.min(mid, x); // 예산 배정 23 | } 24 | 25 | if (total <= m) { // 총 예산이 충분하다면, 상한액을 증가시키기 26 | result = mid; 27 | start = mid + 1; 28 | } 29 | else { // 총 예산이 부족하다면, 상한액을 감소시키기 30 | end = mid - 1; 31 | } 32 | } 33 | console.log(result); -------------------------------------------------------------------------------- /solutions/2805.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let n = Number(input[0].split(' ')[0]); // 나무의 수(N) 7 | let m = Number(input[0].split(' ')[1]); // 가져갈 나무의 길이(M) 8 | 9 | let arr = input[1].split(' ').map(Number); // 각 나무의 높이 10 | 11 | // 이진 탐색을 위한 시작점(start)과 끝점(end) 설정 12 | let start = 0; 13 | let end = arr.reduce((a, b) => Math.max(a, b)); 14 | 15 | // 이진 탐색 수행(반복적) 16 | let result = 0; 17 | while (start <= end) { 18 | let mid = parseInt((start + end) / 2); // 현재의 중간점 19 | let total = 0; 20 | for (x of arr) { 21 | if (x > mid) total += x - mid; // mid로 잘랐을 때 얻을 수 있는 나무의 양 계산 22 | } 23 | if (total < m) end = mid - 1; // 나무의 양이 부족한 경우 더 많이 자르기(왼쪽 부분 탐색) 24 | else { // 나무의 양이 충분한 경우 덜 자르기(오른쪽 부분 탐색) 25 | result = mid; // 최대한 덜 잘랐을 때가 정답이므로, result에 기록 26 | start = mid + 1; 27 | } 28 | } 29 | console.log(result); -------------------------------------------------------------------------------- /solutions/1654.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let k = Number(input[0].split(' ')[0]); // 가지고 있는 랜선의 개수(K) 7 | let n = Number(input[0].split(' ')[1]); // 필요한 랜선의 개수(N) 8 | 9 | let arr = []; // 각 랜선의 길이 10 | for (let i = 1; i <= k; i++) { 11 | arr.push(Number(input[i])); 12 | } 13 | 14 | // 이진 탐색을 위한 시작점(start)과 끝점(end) 설정 15 | let start = 1; 16 | let end = arr.reduce((a, b) => Math.max(a, b)); 17 | 18 | // 이진 탐색 수행(반복적) 19 | let result = 0; 20 | while (start <= end) { 21 | let mid = parseInt((start + end) / 2); // 현재의 중간점 22 | let total = 0; 23 | for (x of arr) { // 가지고 있는 각 랜선을 잘라서 24 | total += parseInt(x / mid); // 길이가 mid인 랜선을 몇 개 만들 수 있는지 계산 25 | } 26 | if (total < n) end = mid - 1; // 랜선의 개수가 부족한 경우 길이 줄이기(왼쪽 부분 탐색) 27 | else { // 랜선의 개수가 충분한 경우 길이 늘이기(오른쪽 부분 탐색) 28 | result = mid; // 최대 길이를 찾아야 하므로, result에 기록 29 | start = mid + 1; 30 | } 31 | } 32 | console.log(result); -------------------------------------------------------------------------------- /solutions/1987.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽기 2 | let file = require('fs').readFileSync('/dev/stdin'); 3 | let input = file.toString().split('\n'); 4 | 5 | // 행(r)과 열(c)의 크기 입력 6 | let [r, c] = input[0].split(' ').map(Number); 7 | // 전체 맵 정보 입력 8 | let graph = []; 9 | for (let i = 1; i <= r; i++) { 10 | graph.push(input[i]); 11 | } 12 | 13 | // 상, 하, 좌, 우 방향 정보 14 | let dx = [-1, 1, 0, 0]; 15 | let dy = [0, 0, -1, 1]; 16 | let result = 0; // 최대 거리 17 | let visited = new Set(); // 방문한 알파벳 집합 18 | 19 | function dfs(x, y, dist) { 20 | result = Math.max(result, dist); 21 | // 인접한 위치를 확인하며 22 | for (let i = 0; i < 4; i++) { 23 | let nx = x + dx[i]; 24 | let ny = y + dy[i]; 25 | // 맵을 벗어나는 경우 무시 26 | if (nx < 0 || nx >= r || ny < 0 || ny >= c) { 27 | continue; 28 | } 29 | // 방문하지 않은 알파벳인 경우 30 | if (!visited.has(graph[nx][ny])) { 31 | visited.add(graph[nx][ny]); 32 | dfs(nx, ny, dist + 1); 33 | visited.delete(graph[nx][ny]); 34 | } 35 | } 36 | } 37 | 38 | // 가장 왼쪽 위에서 출발 39 | visited.add(graph[0][0]); 40 | dfs(0, 0, 1); 41 | console.log(result); 42 | -------------------------------------------------------------------------------- /solutions/1449.js: -------------------------------------------------------------------------------- 1 | /* 2 | [테스트 케이스 분석] 3 | N = 4, L = 2 4 | 위치: 1, 2, 100, 101 5 | 1번 테이프: 0.5 ~ 2.5 6 | 2번 테이프: 99.5 ~ 101.5 7 | ================ 8 | N = 4, L = 3 9 | 위치: 1, 2, 3, 4 10 | 1번 테이프: 0.5 ~ 3.5 11 | 2번 테이프: 3.5 ~ 6.5 12 | ================ 13 | N = 3, L = 1 14 | 위치: 1, 2, 3 15 | 1번 테이프: 0.5 ~ 1.5 16 | 2번 테이프: 1.5 ~ 2.5 17 | 3번 테이프: 2.5 ~ 3.5 18 | */ 19 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽기 20 | let file = require('fs').readFileSync('./input.txt'); 21 | let input = file.toString().split('\n'); 22 | 23 | let n = Number(input[0].split(' ')[0]); // 물이 새는 곳 24 | let l = Number(input[0].split(' ')[1]); // 테이프 길이 25 | 26 | let arr = input[1].split(' ').map(Number); 27 | arr.sort((a, b) => a - b); // 오름차순 정렬 28 | 29 | let current = 0; 30 | let answer = 0; 31 | let end = 0; 32 | // 앞에서부터 하나씩 확인하며 33 | while (current < n) { 34 | // 테이프가 커버하지 못하는 곳이라면 35 | if (end < arr[current]) { 36 | // 항상 (현재 위치 - 0.5)에서 (현재 위치 - 0.5 + l)까지 붙임 37 | end = arr[current] - 0.5 + l; 38 | answer += 1; // 붙인 테이프 수 카운트 39 | } 40 | current += 1; // 다음 물이 새는 곳 확인 41 | // console.log(current, end); 42 | } 43 | console.log(answer); 44 | -------------------------------------------------------------------------------- /solutions/17521.js: -------------------------------------------------------------------------------- 1 | /* 2 | 1일: 5원 3 | 2일: 7원 4 | 3일: 5원 5 | 4일: 4원 6 | 5일: 2원 7 | 6일: 7원 8 | 7일: 8원 9 | 8일: 5원 10 | 9일: 3원 11 | 10일: 4원 12 | 가격: [5, 7, 5, 4, 2, 7, 8, 5, 3, 4] 13 | 정답: [b, s, , , b, , s, , b, s] 14 | 15 | 핵심 아이디어: "그냥 매 날짜를 기준으로 16 | 다음 날짜에 가격이 오른다면, 사기" 17 | 따라서, 두 인접한 날짜의 차이만 고려하면 된다. 18 | 19 | 이때 [2, 7, 8]같은 경우는 20 | 2에서 샀다가 8일 때 팔도록 하는 것과 21 | 2에서 샀다가 7일 때 팔고, 다시 7에서 샀다가 8일 때 파는 것과 같다. 22 | 그래서 구현상 매일 사고 팔고 하는 식으로 짜도 된다. 23 | */ 24 | 25 | let fs = require('fs'); 26 | let input = fs.readFileSync('./input.txt').toString().split('\n'); 27 | 28 | let n = Number(input[0].split(' ')[0]); // 날짜 29 | let w = Number(input[0].split(' ')[1]); // 초기 금액 30 | 31 | // 날짜별 가격을 입력받아 배열로 만들기 32 | let prices = []; 33 | for (let i = 1; i <= n; i++) { 34 | prices.push(Number(input[i])); 35 | } 36 | 37 | // 각 날짜를 확인하면서 38 | for (let i = 0; i < n - 1; i++) { 39 | // 다음날에 가격이 오른다면, 오늘 사서 내일 팔기 40 | if (prices[i] < prices[i + 1]) { 41 | // 오늘 구매 가능한 개수 42 | let cnt = parseInt(w / prices[i]); 43 | // (구매한 개수 X 시세 차익)만큼 더해주기 44 | w += cnt * (prices[i + 1] - prices[i]); 45 | } 46 | } 47 | 48 | console.log(w); 49 | -------------------------------------------------------------------------------- /solutions/18353.js: -------------------------------------------------------------------------------- 1 | // 정렬된 순서를 유지하면서 배열에 삽입할 가장 왼쪽 인덱스 반환 2 | function lowerBound(arr, target, start, end) { 3 | while (start < end) { 4 | let mid = parseInt((start + end) / 2); 5 | if (arr[mid] >= target) end = mid; // 최대한 왼쪽으로 이동하기 6 | else start = mid + 1; 7 | } 8 | return end; 9 | } 10 | 11 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 12 | let fs = require('fs'); 13 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 14 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 15 | 16 | let n = Number(input[0]); // 데이터의 개수(N) 17 | let arr = input[1].split(' ').map(Number); // 수열 18 | arr.reverse(); // 순서를 뒤집어 LIS 문제로 변환 19 | 20 | // LIS 배열 21 | let d = [0]; 22 | 23 | // 이진 탐색을 활용한 LIS 알고리즘 수행 24 | for (x of arr) { 25 | // 마지막 원소보다 현재 원소 x가 크다면 가장 뒤에 넣기 26 | if (d[d.length - 1] < x) { 27 | d.push(x); 28 | } 29 | // x 이하인 원소가 있다면, 가능한 왼쪽에 있는 원소와 x를 교체 30 | else { 31 | let index = lowerBound(d, x, 0, d.length); 32 | d[index] = x; 33 | } 34 | } 35 | 36 | // 열외해야 하는 병사의 최소 수를 출력 37 | console.log(n - (d.length - 1)); -------------------------------------------------------------------------------- /solutions/1240.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽기 2 | let file = require('fs').readFileSync('/dev/stdin'); 3 | let input = file.toString().split('\n'); 4 | 5 | // 노드의 개수(N), 쿼리의 개수(M) 6 | let [n, m] = input[0].split(' ').map(Number); 7 | // 트리 정보 입력받기 8 | let graph = []; 9 | for (let i = 1; i <= n; i++) { 10 |   graph[i] = []; 11 | } 12 | for (let i = 1; i < n; i++) { 13 |   let [x, y, cost] = input[i].split(' ').map(Number); 14 |   graph[x].push([y, cost]); 15 |   graph[y].push([x, cost]); 16 | } 17 | 18 | // 깊이 우선 탐색(DFS) 함수 구현 19 | // visited와 distance는 전역 변수처럼 사용 20 | function dfs(x, dist, visited, distance) { 21 |   // 각 노드는 한 번만 방문 22 |   if (visited[x]) return; 23 |   visited[x] = true; // 방문 처리 24 |   distance[x] = dist; 25 |   for (let [y, cost] of graph[x]) { 26 |     dfs(y, dist + cost, visited, distance); 27 |   } 28 | } 29 | 30 | // 각 쿼리(query)마다 매번 DFS를 수행 31 | for (let i = 0; i < m; i++) { 32 |   let [x, y] = input[n + i].split(' ').map(Number); 33 |   let visited = new Array(n + 1).fill(false); 34 |   let distance = new Array(n + 1).fill(-1); 35 |   dfs(x, 0, visited, distance); 36 |   console.log(distance[y]); // y까지의 최단 거리 37 | } 38 | -------------------------------------------------------------------------------- /solutions/24479.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | // 노드의 개수(N), 간선의 개수(M), 시작 노드(R) 5 | let [n, m, r] = input[0].split(' ').map(Number); 6 | 7 | // 노드가 N개인 그래프 초기화 8 | let graph = []; 9 | for (let i = 0; i <= n; i++) { 10 | graph.push([]); 11 | } 12 | 13 | // 그래프 데이터 입력 14 | for (let i = 1; i <= m; i++) { 15 | let [u, v] = input[i].split(' ').map(Number); 16 | graph[u].push(v); 17 | graph[v].push(u); 18 | } 19 | 20 | // 인접 리스트에 대하여 노드 번호 순으로 오름차순 21 | for (let i = 1; i <= n; i++) { 22 | graph[i].sort((a, b) => a - b); 23 | } 24 | 25 | let visited = Array(n + 1).fill(0); // 각 노드에 대한 방문 여부(순서) 26 | let number = 1; // 방문 순서 27 | 28 | // DFS(깊이 우선 탐색) 소스 코드 29 | function dfs(x) { 30 | visited[x] = number; // x를 방문 처리 31 | number++; 32 | for (let y of graph[x]) { // x와 인접한 노드 y를 방문 33 | if (visited[y] == 0) { // 아직 인접 노드 y를 방문하지 않았다면 34 | dfs(y); 35 | } 36 | } 37 | } 38 | 39 | dfs(r); // 시작 노드에서 출발 40 | 41 | let answer = ""; 42 | // 각 노드를 방문한 순서를 출력 43 | for (let i = 1; i <= n; i++) { 44 | answer += visited[i] + "\n"; 45 | } 46 | console.log(answer); 47 | -------------------------------------------------------------------------------- /solutions/24480.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | // 노드의 개수(N), 간선의 개수(M), 시작 노드(R) 5 | let [n, m, r] = input[0].split(' ').map(Number); 6 | 7 | // 노드가 N개인 그래프 초기화 8 | let graph = []; 9 | for (let i = 0; i <= n; i++) { 10 | graph.push([]); 11 | } 12 | 13 | // 그래프 데이터 입력 14 | for (let i = 1; i <= m; i++) { 15 | let [u, v] = input[i].split(' ').map(Number); 16 | graph[u].push(v); 17 | graph[v].push(u); 18 | } 19 | 20 | // 인접 리스트에 대하여 노드 번호 순으로 내림차순 21 | for (let i = 1; i <= n; i++) { 22 | graph[i].sort((a, b) => b - a); 23 | } 24 | 25 | let visited = Array(n + 1).fill(0); // 각 노드에 대한 방문 여부(순서) 26 | let number = 1; // 방문 순서 27 | 28 | // DFS(깊이 우선 탐색) 소스 코드 29 | function dfs(x) { 30 | visited[x] = number; // x를 방문 처리 31 | number++; 32 | for (let y of graph[x]) { // x와 인접한 노드 y를 방문 33 | if (visited[y] == 0) { // 아직 인접 노드 y를 방문하지 않았다면 34 | dfs(y); 35 | } 36 | } 37 | } 38 | 39 | dfs(r); // 시작 노드에서 출발 40 | 41 | let answer = ""; 42 | // 각 노드를 방문한 순서를 출력 43 | for (let i = 1; i <= n; i++) { 44 | answer += visited[i] + "\n"; 45 | } 46 | console.log(answer); 47 | -------------------------------------------------------------------------------- /solutions/11403.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | let INF = 1e9; // 무한을 의미하는 값으로 10억을 설정 5 | let n = Number(input[0]); // 노드의 개수 6 | 7 | // 그래프 초기화 8 | let graph = []; 9 | for (let i = 1; i <= n; i++) { 10 | let line = input[i].split(' ').map(Number); 11 | graph.push(line); 12 | for (let j = 0; j < n; j++) { 13 | if (graph[i - 1][j] == 0) graph[i - 1][j] = INF; 14 | } 15 | } 16 | for (let i = 0; i < n; i++) { 17 | graph[i][i] = INF; // 자기 자신으로 가는 비용은 무한(INF) 원 18 | } 19 | 20 | // 플로이드 워셜 알고리즘 수행 21 | for (let k = 0; k < n; k++) { // K는 거쳐가는 노드 22 | for (let a = 0; a < n; a++) { 23 | for (let b = 0; b < n; b++) { 24 | // K를 거쳐갈 때 비용이 더 저렴하다면 테이블 갱신 25 | if (graph[a][b] > graph[a][k] + graph[k][b]) { 26 | graph[a][b] = graph[a][k] + graph[k][b]; 27 | } 28 | } 29 | } 30 | } 31 | 32 | // 모든 A에서 B로 가는 것이 가능한지 출력 33 | let answer = ''; 34 | for (let a = 0; a < n; a++) { 35 | for (let b = 0; b < n; b++) { 36 | if (graph[a][b] == INF) answer += '0 '; 37 | else answer += '1 '; 38 | } 39 | answer += '\n'; 40 | } 41 | console.log(answer); 42 | -------------------------------------------------------------------------------- /solutions/10800.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin'); 2 | input = input.toString().split('\n'); 3 | 4 | let n = Number(input[0]); 5 | let arr = []; 6 | for (let i = 0; i < n; i++) { 7 | // 색상(c)와 크기(s)를 입력받기 8 |   let c = Number(input[i + 1].split(' ')[0]); 9 |   let s = Number(input[i + 1].split(' ')[1]); 10 |   arr.push([c, s, i]); 11 | } 12 | // 크기를 기준으로 오름차순 정렬 13 | arr.sort((a, b) => a[1] - b[1]); 14 | 15 | let summary = 0; // 전체 누적 합 16 | let colorSummary = Array(200001).fill(0); // 색상별 누적 합 17 | let result = Array(n).fill(0) // 등장 순서(i)별 최종 결과 18 | 19 | let start = 0; 20 | while (start < n) { 21 |   // 크기가 같은 공들이 여러 개일 수 있으므로, 22 | // 이때 start는 시작 인덱스 end는 끝 인덱스 23 |   let end = start; 24 |   while (end < n && arr[start][1] == arr[end][1]) end += 1; 25 |   // 자기보다 작은 공들의 크기 합 – 같은 색상인 공들의 크기 합 26 |   for (let i = start; i < end; i++) { 27 |     result[arr[i][2]] = summary - colorSummary[arr[i][0]]; 28 |   } 29 |   // 합계 값(누적 합) 갱신 30 |   for (let i = start; i < end; i++) { 31 |     colorSummary[arr[i][0]] += arr[i][1]; // 색상별 누적 합 32 |     summary += arr[i][1]; // 전체 누적 합 33 |   } 34 |   start = end; 35 | } 36 | console.log(result.join('\n')); 37 | -------------------------------------------------------------------------------- /solutions/1058.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | let INF = 1e9; // 무한을 의미하는 값으로 10억을 설정 5 | let n = Number(input[0]); // 노드의 개수 6 | 7 | // 그래프 초기화 8 | let graph = []; 9 | for (let i = 1; i <= n; i++) { 10 | graph.push(new Array(n).fill(INF)); 11 | let line = input[i].split(''); 12 | for (let j = 0; j < n; j++) { 13 | if (line[j] == 'Y') graph[i - 1][j] = 1; 14 | } 15 | } 16 | for (let i = 0; i < n; i++) { 17 | graph[i][i] = 0; // 자기 자신으로 가는 비용은 0원 18 | } 19 | 20 | // 플로이드 워셜 알고리즘 수행 21 | for (let k = 0; k < n; k++) { // K는 거쳐가는 노드 22 | for (let a = 0; a < n; a++) { 23 | for (let b = 0; b < n; b++) { 24 | // K를 거쳐갈 때 비용이 더 저렴하다면 테이블 갱신 25 | if (graph[a][b] > graph[a][k] + graph[k][b]) { 26 | graph[a][b] = graph[a][k] + graph[k][b]; 27 | } 28 | } 29 | } 30 | } 31 | 32 | // 모든 A에서 B로 가는 최단 경로 확인 33 | let twoFriends = new Array(n).fill(0); 34 | for (let a = 0; a < n; a++) { 35 | for (let b = 0; b < n; b++) { 36 | // 거리가 2 이하인 노드의 수 세기 37 | if (a != b && graph[a][b] <= 2) twoFriends[a]++; 38 | } 39 | } 40 | // 거리가 2 이하인 노드의 수 중에서 최댓값을 출력 41 | console.log(twoFriends.reduce((a, b) => Math.max(a, b))); 42 | -------------------------------------------------------------------------------- /solutions/1343.js: -------------------------------------------------------------------------------- 1 | /* 2 | 1. "."를 기준으로 문자열을 나눈다. 3 | 2. "X"로만 구성된 묶음을 확인한다. 4 | * 홀수개라면, -1을 출력하고 프로그램 종료. 5 | * 짝수개인 경우 6 | * 4의 배수라면, 전부 A로 채운다. 7 | * 아니라면 (4로 나눈 몫) * 4개만큼 A를 출력하고, B를 2번 출력한다. 8 | */ 9 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽기 10 | let file = require('fs').readFileSync('/dev/stdin'); 11 | let input = file.toString().split('\n'); 12 | 13 | let board = input[0]; 14 | arr = board.split("."); 15 | 16 | let answer = ""; 17 | let odd = false; // 홀수개인 경우 18 | 19 | for (let i = 0; i < arr.length; i++) { 20 | let current = arr[i]; 21 | let length = current.length; // 현재 "X" 묶음의 길이 22 | if (length > 0) { 23 | // 홀수개라면, -1을 출력하고 종료해야 함 24 | if (length % 2 == 1) { 25 | odd = true; 26 | break; 27 | } 28 | else { // 짝수개라면 29 | if (length % 4 == 0) { // 4의 배수라면 30 | // 전부 "AAAA"로 채우기 31 | answer += "AAAA".repeat(parseInt(length / 4)); 32 | } 33 | else { // 4의 배수가 아니라면 34 | // 4의 배수만큼까지는 "AAAA"로 채우기 35 | answer += "AAAA".repeat(parseInt(length / 4)); 36 | // 뒤에 "BB"를 추가하기 37 | answer += "BB"; 38 | } 39 | } 40 | } 41 | if (i != arr.length - 1) answer += "."; 42 | } 43 | if (!odd) console.log(answer); 44 | else console.log(-1); 45 | -------------------------------------------------------------------------------- /solutions/11404.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | let INF = 1e9; // 무한을 의미하는 값으로 10억을 설정 5 | let n = Number(input[0]); // 노드의 개수 6 | let m = Number(input[1]); // 간선의 개수 7 | 8 | // 그래프 초기화 9 | let graph = []; 10 | for (let i = 0; i <= n; i++) { 11 | graph.push(new Array(n + 1).fill(INF)); // 일단 무한으로 초기화 12 | } 13 | for (let i = 1; i <= n; i++) { 14 | graph[i][i] = 0; // 자기 자신으로 가는 비용은 0원 15 | } 16 | for (let i = 2; i <= m + 1; i++) { 17 | let [a, b, c] = input[i].split(' ').map(Number); 18 | // 중복 간선이 있다면 가장 비용이 작은 것만 고려 19 | graph[a][b] = Math.min(graph[a][b], c); 20 | } 21 | 22 | // 플로이드 워셜 알고리즘 수행(최단 경로 계산) 23 | for (let k = 1; k <= n; k++) { // K는 거쳐가는 노드 24 | for (let a = 1; a <= n; a++) { 25 | for (let b = 1; b <= n; b++) { 26 | // K를 거쳐갈 때 비용이 더 저렴하다면 테이블 갱신 27 | if (graph[a][b] > graph[a][k] + graph[k][b]) { 28 | graph[a][b] = graph[a][k] + graph[k][b]; 29 | } 30 | } 31 | } 32 | } 33 | 34 | // 모든 A에서 B로 가는 최단 경로 출력 35 | let answer = ''; 36 | for (let a = 1; a <= n; a++) { 37 | for (let b = 1; b <= n; b++) { 38 | if (graph[a][b] == INF) answer += '0 '; 39 | else answer += graph[a][b] + ' '; 40 | } 41 | answer += '\n'; 42 | } 43 | console.log(answer); 44 | -------------------------------------------------------------------------------- /solutions/2110.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let n = Number(input[0].split(' ')[0]); // 집의 개수(N) 7 | let c = Number(input[0].split(' ')[1]); // 공유기의 개수(C) 8 | 9 | let arr = []; // 전체 집의 좌표 정보를 입력받기 10 | for (let i = 1; i <= n; i++) { 11 | arr.push(Number(input[i])); 12 | } 13 | arr.sort((a, b) => a - b); // 이진 탐색 수행을 위해 오름차순 정렬 수행 14 | 15 | // 이진 탐색을 위한 시작점(start)과 끝점(end) 설정 16 | let start = 1; // 가능한 최소 거리 차이(minimum gap) 17 | let end = arr[n - 1] - arr[0]; // 가능한 최대 거리 차이(maximum gap) 18 | 19 | // 이진 탐색 수행(반복적) 20 | let result = 0; 21 | while (start <= end) { 22 | // 현재의 중간점(mid)은 가장 인접한 두 공유기 사이의 거리(gap)를 의미 23 | let mid = parseInt((start + end) / 2); 24 | // 첫째 집에는 무조건 공유기를 설치한다고 가정 25 | let value = arr[0]; 26 | let cnt = 1; 27 | // 현재의 mid 값을 이용해 공유기를 설치 28 | for (let i = 1; i < n; i++) { 29 | if (arr[i] >= value + mid) { 30 | value = arr[i]; 31 | cnt++; 32 | } 33 | } 34 | if (cnt >= c) { // C개 이상의 공유기를 설치할 수 있는 경우, 거리를 증가시키기 35 | start = mid + 1; 36 | result = mid; // 최적의 결과를 저장 37 | } 38 | else end = mid - 1; // C개 이상의 공유기를 설치할 수 없는 경우, 거리를 감소시키기 39 | } 40 | console.log(result); -------------------------------------------------------------------------------- /solutions/1072.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let x = parseInt(input[0].split(' ')[0]); // 게임 횟수(X) 7 | let y = parseInt(input[0].split(' ')[1]); // 이긴 횟수(Y) 8 | 9 | // 이진 탐색을 위한 시작점(start)과 끝점(end) 설정 10 | let start = 1; 11 | let end = 10 ** 9; // 충분히 큰 수로 설정 12 | 13 | // 100을 곱했을 때 정밀도를 벗어나는 경우(정밀도 오차)를 대비하여 임시적으로 BigInt() 사용 14 | let ratio = parseInt(BigInt(y) * BigInt(100) / BigInt(x)); // 승률 계산 15 | 16 | // 이진 탐색 수행(반복적) 17 | let result = -1; 18 | while (start <= end) { 19 | let mid = parseInt((start + end) / 2); // 현재의 중간점(추가로 이긴 횟수) 20 | 21 | // 승률이 변하는지 확인 22 | let check = false; 23 | // 100을 곱했을 때 정밀도를 벗어나는 경우(정밀도 오차)를 대비하여 임시적으로 BigInt() 사용 24 | let currentRatio = parseInt((BigInt(y + mid) * BigInt(100)) / BigInt(x + mid)); 25 | if (currentRatio != ratio) check = true; 26 | 27 | if (check) { // 승률이 변한다면 "추가로 이긴 횟수"를 감소시키기 28 | result = mid; 29 | end = mid - 1; 30 | } 31 | else { // 승률이 변하지 않는다면 "추가로 이긴 횟수"를 증가시키기 32 | start = mid + 1; 33 | } 34 | } 35 | 36 | // 승률이 절대 변하지 않는다면(승률이 99% 이상인 경우와 동치) 37 | if (result == -1) { 38 | console.log(-1); 39 | } 40 | else { 41 | console.log(result); 42 | } -------------------------------------------------------------------------------- /solutions/1493.js: -------------------------------------------------------------------------------- 1 | let input = require('fs').readFileSync('/dev/stdin').toString().split('\n'); 2 | 3 | // x보다 작거나 같으면서 가장 가까운 2^i를 찾는 함수 4 | function nearestSquare(x) { 5 | let i = 1; 6 | while ((2 ** i) <= x) i += 1; 7 | return i - 1; 8 | } 9 | 10 | let length = Number(input[0].split(' ')[0]); 11 | let width = Number(input[0].split(' ')[1]); 12 | let height = Number(input[0].split(' ')[2]); 13 | let cubes = Array(20).fill(0); 14 | 15 | let n = Number(input[1]); 16 | for (let i = 2; i <= n + 1; i++) { 17 | let a = Number(input[i].split(' ')[0]); 18 | let b = Number(input[i].split(' ')[1]); 19 | cubes[a] = b; 20 | } 21 | 22 | let size = 19; 23 | size = nearestSquare(length); 24 | size = Math.min(size, nearestSquare(width)); 25 | size = Math.min(size, nearestSquare(height)); 26 | 27 | let res = 0; 28 | let used = 0; 29 | 30 | for (let i = size; i >= 0; i--) { 31 | used *= 8; // 채널, 너비, 높이가 2씩 줄었으므로 큐브의 개수는 8배 증가 32 | cur = (2 ** i); // 현재의 정육면체 큐브의 길이 33 | // 채워넣어야 할 큐브의 개수 계산 34 | let required = parseInt(length / cur) 35 | * parseInt(width / cur) 36 | * parseInt(height / cur) 37 | - used; 38 | 39 | let usage = Math.min(required, cubes[i]); // 이번 단계에서 넣을 수 있는 큐브의 개수 40 | res += usage; 41 | used += usage; 42 | } 43 | 44 | if (used == length * width * height) console.log(res); // 박스를 가득 채운 경우 45 | else console.log(-1); // 박스를 가득 채우지 못한 경우 -------------------------------------------------------------------------------- /solutions/1300.js: -------------------------------------------------------------------------------- 1 | /* 2 | 예를 들어 N = 5일 때 배열의 형태는 다음과 같다. 3 | [ 4 | [1, 2, 3, 4, 5], 5 | [2, 4, 6, 8, 10], 6 | [3, 6, 9, 12, 15], 7 | [4, 8, 12, 16, 20], 8 | [5, 10, 15, 20, 25] 9 | ] 10 | 값 x에 대하여 f(x)를 배열에서 x보다 작거나 같은 데이터의 개수로 정의하자. 11 | 따라서 f(x)는 값이 x 이하인 원소들의 인덱스 중에서 upperBound()의 역할을 수행한다. 12 | 참고로 i번째 행에 대하여 min(x // i, N)를 계산하는 방식으로 f(x)를 O(N)에 구할 수 있다. 13 | 그러므로 이진 탐색으로 x를 변경하면서, f(x) >= k일 때마다 x를 기록하면 정답이다. 14 | */ 15 | 16 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 17 | let fs = require('fs'); 18 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 19 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 20 | 21 | let n = Number(input[0]); // 배열의 크기(N) 22 | let k = Number(input[1]); // 인덱스 K 23 | 24 | // 이진 탐색을 위한 시작점(start)과 끝점(end) 설정 25 | let start = 1; // 배열에 존재할 수 있는 가장 작은 값 26 | let end = 10 ** 10; // 배열에 존재할 수 있는 가장 큰 값 27 | 28 | // 이진 탐색 수행(반복적) 29 | let result = 0; 30 | while (start <= end) { 31 | let mid = parseInt((start + end) / 2); // 현재의 중간점 32 | 33 | let total = 0; // mid보다 작거나 같은 데이터의 개수 34 | for (let i = 1; i <= n; i++) { // 각 행마다 계산 35 | total += Math.min(parseInt(mid / i), n); 36 | } 37 | 38 | if (total >= k) { // mid보다 작거나 같은 데이터의 개수가 k 이상이라면 39 | result = mid; // result에 기록 40 | end = mid - 1; 41 | } 42 | else { // mid보다 작거나 같은 데이터의 개수가 k 미만이라면 43 | start = mid + 1; 44 | } 45 | } 46 | console.log(result); -------------------------------------------------------------------------------- /solutions/5052.js: -------------------------------------------------------------------------------- 1 | /* 2 | A = "911" 3 | B = "91125426" 4 | 상황에서, A가 B의 접두어이기 때문에 B에게 전화를 걸 수 없습니다. 5 | 전화번호부가 있을 때, 접두어 관계가 존재하는지 찾는 프로그램을 작성합니다. 6 | 7 | [핵심 아이디어] 8 | 1. 오름차순 정렬을 수행합니다. 9 | 2. 인접한 두 개의 문자열을 확인하면서 접두어 관계인지 확인합니다. 10 | 11 | 정렬된 결과: ["456", "4567", "4576"] 12 | 만약 접두어를 형성하는 경우, 정렬된 이후에 인접한 문자열끼리 봤을 때 13 | 접두어 관계임을 알 수 있다. 14 | */ 15 | 16 | let fs = require('fs'); 17 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 18 | 19 | let testCases = Number(input[0]); 20 | let line = 1; 21 | for (let tc = 0; tc < testCases; tc++) { 22 | let n = Number(input[line]); // 전화번호의 개수 23 | let books = []; // 전화번호부 24 | for (let i = 1; i <= n; i++) { 25 | let code = input[line + i]; 26 | books.push(code); 27 | } 28 | 29 | books.sort(); // 문자열 기준으로 오름차순 정렬 30 | let result = false; 31 | for (let i = 0; i < n - 1; i++) { 32 | // 앞 문자열이 뒤 문자열보다 짧은 경우에만 확인 33 | if (books[i].length < books[i + 1].length) { 34 | let prefix = true; 35 | // 앞 문자열이 뒤 문자열의 접두어라면 36 | for (let j = 0; j < books[i].length; j++) { 37 | if (books[i][j] != books[i + 1][j]) { 38 | prefix = false; 39 | break; 40 | } 41 | } 42 | if (prefix) { // 접두어 관계인 경우 43 | result = true; 44 | break; 45 | } 46 | } 47 | } 48 | if (result) console.log("NO"); // 접두어 관계 있음 49 | else console.log("YES"); // 접두어 관계 없음 50 | 51 | line += n + 1; // 현재 테스트 케이스 종료 52 | } 53 | -------------------------------------------------------------------------------- /solutions/9655.js: -------------------------------------------------------------------------------- 1 | /* 2 | [문제] 항상 돌을 1개 가져가거나, 3개 가져가야 한다. 3 | 4 | 1) N = 1일 때 5 | 상근 1개 승리 6 | (결과) 상근 승리 7 | 8 | 2) N = 2일 때 9 | 상근 1개 → (N = 1)이고, 창영이가 먼저 두는 것과 같으므로, 창영 승리 10 | (결과) 창영 승리 11 | 12 | 3) N = 3일 때 13 | 상근 1개 → (N = 2)이고, 창영이가 먼저 두는 것과 같으므로, 상근 승리 14 | 상근 3개 승리 15 | (결과) 상근 승리 16 | 17 | 4) N = 4일 때 18 | 상근 1개 → (N = 3)이고, 창영이가 먼저 두는 것과 같으므로, 창영 승리 19 | 상근 3개 → (N = 1)이고, 창영이가 먼저 두는 것과 같으므로, 창영 승리 20 | (결과) 창영 승리 21 | 22 | 5) N = 5일 때 23 | 상근 1개 → (N = 4)이고, 창영이가 먼저 두는 때랑 같으므로, 상근 승리 24 | 상근 3개 → (N = 2)이고, 창영이가 먼저 두는 때랑 같으므로, 창영 승리 25 | (결과) 상근 승리 26 | 27 | 6) N = 6일 때 28 | 상근 1개 → (N = 5)이고, 창영이가 먼저 두는 것과 같으므로, 창영 승리 29 | 상근 3개 → (N = 3)이고, 창영이가 먼저 두는 것과 같으므로, 창영 승리 30 | (결과) 창영 승리 31 | 32 | dp[N]: 돌이 N개일 때 상근이가 승리한다면 1, 창영이가 승리한다면 0 33 | dp[1] = 1 34 | dp[2] = 0 35 | dp[3] = 1 36 | * dp[N] = (flip dp[N - 1]) or (flip dp[N - 3]) 37 | dp[4] = 0 38 | dp[5] = 1 39 | */ 40 | 41 | let fs = require('fs'); 42 | let input = fs.readFileSync('./input.txt').toString().split('\n'); 43 | 44 | // dp[N]: 돌이 N개일 때 상근이가 승리한다면 1, 창영이가 승리한다면 0 45 | 46 | // 돌의 수(N) 47 | let n = Number(input[0]); 48 | 49 | // DP 테이블 초기화 50 | let dp = new Array(n + 1).fill(false); 51 | dp[1] = true; // 상근 승 52 | dp[2] = false; // 창영 승 53 | dp[3] = true; // 상근 승 54 | 55 | // dp[N] = (flip dp[N - 1]) or (flip dp[N - 3]) 56 | for (let i = 4; i <= n; i++) { 57 | dp[i] = (!dp[i - 1] || !dp[i - 3]); 58 | } 59 | 60 | if (dp[n] == true) console.log("SK"); 61 | else console.log("CY"); 62 | -------------------------------------------------------------------------------- /solutions/10816.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | // 정렬된 순서를 유지하면서 배열에 삽입할 가장 왼쪽 인덱스 반환 5 | function lowerBound(arr, target, start, end) { 6 |   while (start < end) { 7 |     let mid = parseInt((start + end) / 2); 8 |     if (arr[mid] >= target) end = mid; // 최대한 왼쪽으로 이동하기 9 |     else start = mid + 1; 10 |   } 11 |   return end; 12 | } 13 | 14 | // 정렬된 순서를 유지하면서 배열에 삽입할 가장 오른쪽 인덱스 반환 15 | function upperBound(arr, target, start, end) { 16 |   while (start < end) { 17 |     let mid = parseInt((start + end) / 2); 18 |     if (arr[mid] > target) end = mid; 19 |     else start = mid + 1; // 최대한 오른쪽으로 이동하기 20 |   } 21 |   return end; 22 | } 23 | 24 | // 값이 [leftValue, rightValue]인 데이터의 개수를 반환하는 함수 25 | function countByRange(arr, leftValue, rightValue) { 26 |   // 유의: lowerBound와 upperBound는 end 변수의 값을 배열의 길이로 설정 27 |   let rightIndex = upperBound(arr, rightValue, 0, arr.length); 28 |   let leftIndex = lowerBound(arr, leftValue, 0, arr.length); 29 |   return rightIndex - leftIndex; 30 | } 31 | 32 | let n = Number(input[0]); // 데이터의 개수 33 | let data = input[1].split(' ').map(Number); 34 | let m = Number(input[2]); // 쿼리의 개수 35 | let query = input[3].split(' ').map(Number); 36 | 37 | // 오름차순 정렬 38 | data.sort((a, b) => a - b); 39 | 40 | let answer = ""; // 결과 문자열 41 | for (let i = 0; i < m; i++) { 42 | let x = query[i]; 43 | answer += countByRange(data, x, x) + " "; // 값이 x인 원소의 개수 세기 44 | } 45 | console.log(answer); 46 | -------------------------------------------------------------------------------- /solutions/2164.js: -------------------------------------------------------------------------------- 1 | /* 2 | N = 6이라면, 3 | 카드는 [1, 2, 3, 4, 5, 6] 4 | 5 | 1) 제일 위 카드를 바닥에 버리고, 제일 위 카드를 제일 아래 카드 밑으로 옮긴다. 6 | [3, 4, 5, 6, 2] 7 | 8 | 2) 제일 위 카드를 바닥에 버리고, 제일 위 카드를 제일 아래 카드 밑으로 옮긴다. 9 | [5, 6, 2, 4] 10 | 11 | 3) 제일 위 카드를 바닥에 버리고, 제일 위 카드를 제일 아래 카드 밑으로 옮긴다. 12 | [2, 4, 6] 13 | 14 | 4) 제일 위 카드를 바닥에 버리고, 제일 위 카드를 제일 아래 카드 밑으로 옮긴다. 15 | [6, 4] 16 | 17 | 5) 제일 위 카드를 바닥에 버리고, 제일 위 카드를 제일 아래 카드 밑으로 옮긴다. 18 | [4] 19 | */ 20 | class Queue { 21 |   constructor() { 22 |     this.items = {}; 23 |     this.headIndex = 0; 24 |     this.tailIndex = 0; 25 |   } 26 |   enqueue(item) { 27 |     this.items[this.tailIndex] = item; 28 |     this.tailIndex++; 29 |   } 30 |   dequeue() { 31 |     const item = this.items[this.headIndex]; 32 |     delete this.items[this.headIndex]; 33 |     this.headIndex++; 34 |     return item; 35 |   } 36 |   peek() { 37 |     return this.items[this.headIndex]; 38 |   } 39 |   getLength() { 40 |     return this.tailIndex - this.headIndex; 41 |   } 42 | } 43 | 44 | let fs = require('fs'); 45 | let input = fs.readFileSync("/dev/stdin").toString().split("\n"); 46 | 47 | let n = Number(input[0]); 48 | 49 | // 큐(queue)에 1부터 N까지의 원소를 삽입 50 | let queue = new Queue(); 51 | for (let i = 1; i <= n; i++) { 52 | queue.enqueue(i); 53 | } 54 | 55 | for (let i = 0; i < n - 1; i++) { 56 | let x = queue.dequeue(); // 가장 앞에 있는 원소를 꺼내고 57 | x = queue.dequeue(); // 다시 가장 앞에 있는 원소를 꺼내서 58 | queue.enqueue(x); // 그것을 뒤에 넣기 59 | } 60 | 61 | console.log(queue.peek()); 62 | -------------------------------------------------------------------------------- /solutions/2667.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | let n = Number(input[0]); // 맵의 크기 5 | let data = []; // 맵 정보 6 | let visited = []; // 각 위치에 대한 방문 처리 7 | 8 | for (let i = 1; i <= n; i++) { 9 | let line = input[i].split('').map(Number); 10 | data.push(line); 11 | visited.push(new Array(n).fill(false)); 12 | } 13 | 14 | // 북, 동, 남, 서 15 | let dx = [-1, 0, 1, 0]; 16 | let dy = [0, 1, 0, -1]; 17 | 18 | // 연결된 모든 위치를 방문 처리하는 함수 19 | function dfs(x, y) { 20 | cnt++; 21 | visited[x][y] = true; // 방문 처리 22 | for (let i = 0; i < 4; i++) { // 북, 동, 남, 서 각각 확인 23 | let nx = x + dx[i]; 24 | let ny = y + dy[i]; 25 | // 맵의 범위를 벗어난 경우 무시 26 | if (nx < 0 || ny < 0 || nx >= n || ny >= n) continue; 27 | // 해당 위치가 집이면서, 아직 방문하지 않은 위치인 경우 28 | if (data[nx][ny] == 1 && visited[nx][ny] == false) { 29 | dfs(nx, ny); // 재귀적으로 방문 처리 30 | } 31 | } 32 | } 33 | 34 | let result = 0; 35 | let resultList = []; 36 | let cnt = 0; // 현재 단지에 포함된 집의 수 37 | // 모든 위치를 확인하며 38 | for (let i = 0; i < n; i++) { 39 | for (let j = 0; j < n; j++) { 40 | // 해당 위치가 집이면서, 아직 방문하지 않은 위치인 경우 41 | if (data[i][j] == 1 && visited[i][j] == false) { 42 | dfs(i, j); // 연결된 모든 위치를 방문 처리(단지 형성) 43 | result++; // 단지의 수 카운트 44 | resultList.push(cnt); // 각 단지에 포함된 집의 수 기록 45 | cnt = 0; 46 | } 47 | } 48 | } 49 | 50 | console.log(result); // 단지의 수 출력 51 | resultList.sort((a, b) => a - b); 52 | for (let x of resultList) { // 각 단지에 포함된 집의 수 출력 53 | console.log(x); 54 | } 55 | -------------------------------------------------------------------------------- /solutions/2872.js: -------------------------------------------------------------------------------- 1 | /* 2 | 문제를 풀 때는 먼저 여러 가지 예시를 직접 고려합니다. 3 | 4 | [예시 1] 초기 값: [3, 2, 1] 5 | 1) 2를 꺼내서 위로 올리기 6 | 현재 상태: [2, 3, 1] 7 | 2) 1을 꺼내서 위로 올리기 8 | 현재 상태: [1, 2, 3] 9 | 정답: 2 10 | 11 | [예시 2] 초기 값: [5, 6, 3, 4, 1, 2] 12 | 1) 4를 꺼내서 위로 올리기 13 | 현재 상태: [4, 5, 6, 3, 1, 2] 14 | 2) 3을 꺼내서 위로 올리기 15 | 현재 상태: [3, 4, 5, 6, 1, 2] 16 | 3) 2를 꺼내서 위로 올리기 17 | 현재 상태: [2, 3, 4, 5, 6, 1] 18 | 4) 1을 꺼내서 위로 올리기 19 | 현재 상태: [1, 2, 3, 4, 5, 6] 20 | 21 | 어떤 경우든 가장 큰 값은 위치를 옮길 필요가 없습니다. 22 | 그러면, 위치를 옮길 필요 없는 값들은 무엇일까요? 23 | 24 | [핵심 아이디어] 뒤에서부터 보면서 가장 큰 값부터 25 | 내림차순으로 구성된 원소들은 위치를 바꿀 필요가 없습니다. 26 | 27 | 예시: [4, 1, 2, 5, 6, 3] 28 | 6 → 5 → 4으로 내림차순입니다. (연속될 필요 X) 29 | [4, 5, 6]은 위치를 바꿀 필요가 없습니다. 30 | 정답: 3 31 | 32 | 예시: [4, 5, 1, 6, 7, 2, 3, 8] 33 | 8 → 7 → 6 → 5 → 4로 내림차순입니다. (연속될 필요 X) 34 | [4, 5, 6, 7, 8]은 위치를 바꿀 필요가 없습니다. 35 | 정답: 3 36 | */ 37 | 38 | let fs = require('fs'); 39 | let input = fs.readFileSync('./input.txt').toString().split('\n'); 40 | 41 | let n = Number(input[0]); // 책의 개수 N 입력 42 | let books = []; // 각 책의 번호 배열 43 | 44 | for (let i = 1; i <= n; i++) { 45 | books.push(Number(input[i])); 46 | } 47 | 48 | // 가장 큰 값과 그 인덱스를 찾기 49 | let maxValue = 0; 50 | let maxIndex = -1; 51 | for (let i = 0; i < n; i++) { 52 | if (maxValue < books[i]) { 53 | maxValue = books[i]; 54 | maxIndex = i; 55 | } 56 | } 57 | 58 | // 뒤에서부터 출발해서 내림차순 배열의 크기를 계산 59 | let length = 1; 60 | let target = maxValue - 1; 61 | for (let i = maxIndex - 1; i >= 0; i--) { 62 | if (target == books[i]) { 63 | target--; 64 | length++; 65 | } 66 | } 67 | console.log(n - length); 68 | -------------------------------------------------------------------------------- /solutions/2644.js: -------------------------------------------------------------------------------- 1 | class Queue { 2 | constructor() { 3 | this.items = {}; 4 | this.headIndex = 0; 5 | this.tailIndex = 0; 6 | } 7 | enqueue(item) { 8 | this.items[this.tailIndex] = item; 9 | this.tailIndex++; 10 | } 11 | dequeue() { 12 | const item = this.items[this.headIndex]; 13 | delete this.items[this.headIndex]; 14 | this.headIndex++; 15 | return item; 16 | } 17 | peek() { 18 | return this.items[this.headIndex]; 19 | } 20 | getLength() { 21 | return this.tailIndex - this.headIndex; 22 | } 23 | } 24 | 25 | let fs = require('fs'); 26 | let input = fs 27 | .readFileSync('/dev/stdin') 28 | .toString() 29 | .split('\n'); 30 | 31 | // 노드의 수(N) 32 | let n = Number(input[0]); 33 | // 거리를 계산할 두 사람 34 | let [targetX, targetY] = input[1].split(' ').map(Number); 35 | // 간선의 수(M) 36 | let m = Number(input[2]); 37 | // 그래프(graph) 입력 38 | let graph = []; 39 | for (let i = 0; i <= n; i++) { 40 | graph.push([]); 41 | } 42 | // 간선 정보 입력 43 | for (let i = 3; i < m + 3; i++) { 44 | let [x, y] = input[i].split(' ').map(Number); 45 | graph[x].push(y); 46 | graph[y].push(x); 47 | } 48 | 49 | // 각 노드에 대한 방문 여부(거리) 50 | let visited = Array(n + 1).fill(-1); 51 | queue = new Queue(); 52 | queue.enqueue(targetX); 53 | visited[targetX] = 0; // 출발 노드까지의 거리는 0 54 | // 큐가 빌 때까지 반복 55 | while (queue.getLength() != 0) { 56 | // 큐에서 하나의 원소를 뽑아 출력하기 57 | x = queue.dequeue(); 58 | // 인접 원소를 하나씩 확인 59 | for (y of graph[x]) { 60 | // 처음 방문하는 경우에만 최단 거리를 기록 61 | if (visited[y] == -1) { 62 | queue.enqueue(y); 63 | // 최단 거리 기록 64 | visited[y] = visited[x] + 1; 65 | } 66 | } 67 | } 68 | 69 | console.log(visited[targetY]); 70 | -------------------------------------------------------------------------------- /solutions/1012.js: -------------------------------------------------------------------------------- 1 | let fs = require('fs'); 2 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 3 | 4 | let testCases = Number(input[0]); 5 | let line = 1; 6 | 7 | while (testCases--) { // 테스트 케이스만큼 반복 8 | let [n, m, k] = input[line].split(' ').map(Number); // 맵의 크기 9 | let data = []; // 맵 정보 10 | let visited = []; // 각 위치에 대한 방문 처리 11 | 12 | for (let i = 0; i < n; i++) { 13 | data.push(new Array(m).fill(0)); 14 | visited.push(new Array(m).fill(false)); 15 | } 16 | 17 | for (let i = line + 1; i <= line + k; i++) { 18 | let [x, y] = input[i].split(' ').map(Number); 19 | data[x][y] = 1; // 배추가 있는 위치 20 | } 21 | 22 | // 북, 동, 남, 서 23 | let dx = [-1, 0, 1, 0]; 24 | let dy = [0, 1, 0, -1]; 25 | 26 | // 연결된 모든 위치를 방문 처리하는 함수 27 | function dfs(x, y) { 28 | visited[x][y] = true; // 방문 처리 29 | for (let i = 0; i < 4; i++) { // 북, 동, 남, 서 각각 확인 30 | let nx = x + dx[i]; 31 | let ny = y + dy[i]; 32 | // 맵의 범위를 벗어난 경우 무시 33 | if (nx < 0 || ny < 0 || nx >= n || ny >= m) continue; 34 | // 해당 위치가 배추이면서, 아직 방문하지 않은 위치인 경우 35 | if (data[nx][ny] == 1 && visited[nx][ny] == false) { 36 | dfs(nx, ny); // 재귀적으로 방문 처리 37 | } 38 | } 39 | } 40 | 41 | let result = 0; 42 | // 모든 위치를 확인하며 43 | for (let i = 0; i < n; i++) { 44 | for (let j = 0; j < m; j++) { 45 | // 해당 위치가 배추이면서, 아직 방문하지 않은 위치인 경우 46 | if (data[i][j] == 1 && visited[i][j] == false) { 47 | dfs(i, j); // 연결된 모든 위치를 방문 처리(단지 형성) 48 | result++; 49 | } 50 | } 51 | } 52 | 53 | console.log(result); // 배추흰지렁이 수 출력 54 | line += k + 1; // 다음 테스트 케이스로 넘어가기 55 | } 56 | -------------------------------------------------------------------------------- /solutions/1920.js: -------------------------------------------------------------------------------- 1 | // 정렬된 순서를 유지하면서 배열에 삽입할 가장 왼쪽 인덱스 반환 2 | function lowerBound(arr, target, start, end) { 3 | while (start < end) { 4 | let mid = parseInt((start + end) / 2); 5 | if (arr[mid] >= target) end = mid; // 최대한 왼쪽으로 이동하기 6 | else start = mid + 1; 7 | } 8 | return end; 9 | } 10 | 11 | // 정렬된 순서를 유지하면서 배열에 삽입할 가장 오른쪽 인덱스 반환 12 | function upperBound(arr, target, start, end) { 13 | while (start < end) { 14 | let mid = parseInt((start + end) / 2); 15 | if (arr[mid] > target) end = mid; // 최대한 오른쪽으로 이동하기 16 | else start = mid + 1; 17 | } 18 | return end; 19 | } 20 | 21 | // 값이 [leftValue, rightValue]인 데이터의 개수를 반환하는 함수 22 | function countByRange(arr, leftValue, rightValue) { 23 | // 유의: lowerBound와 upperBound는 end 변수의 값을 배열의 길이로 설정 24 | let rightIndex = upperBound(arr, rightValue, 0, arr.length); 25 | let leftIndex = lowerBound(arr, leftValue, 0, arr.length); 26 | return rightIndex - leftIndex; 27 | } 28 | 29 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 30 | let fs = require('fs'); 31 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 32 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 33 | 34 | let n = Number(input[0]); 35 | let arr = input[1].split(' ').map(Number); 36 | let m = Number(input[2]); 37 | let query = input[3].split(' ').map(Number); 38 | 39 | arr.sort((a, b) => a - b); 40 | 41 | answer = ''; 42 | for (let i = 0; i < m; i++) { 43 | // 값이 query[i]인 데이터의 개수 계산 44 | let cnt = countByRange(arr, query[i], query[i]); 45 | if (cnt != 0) answer += '1\n'; 46 | else answer += '0\n'; 47 | } 48 | console.log(answer); -------------------------------------------------------------------------------- /solutions/10815.js: -------------------------------------------------------------------------------- 1 | // 정렬된 순서를 유지하면서 배열에 삽입할 가장 왼쪽 인덱스 반환 2 | function lowerBound(arr, target, start, end) { 3 | while (start < end) { 4 | let mid = parseInt((start + end) / 2); 5 | if (arr[mid] >= target) end = mid; // 최대한 왼쪽으로 이동하기 6 | else start = mid + 1; 7 | } 8 | return end; 9 | } 10 | 11 | // 정렬된 순서를 유지하면서 배열에 삽입할 가장 오른쪽 인덱스 반환 12 | function upperBound(arr, target, start, end) { 13 | while (start < end) { 14 | let mid = parseInt((start + end) / 2); 15 | if (arr[mid] > target) end = mid; // 최대한 오른쪽으로 이동하기 16 | else start = mid + 1; 17 | } 18 | return end; 19 | } 20 | 21 | // 값이 [leftValue, rightValue]인 데이터의 개수를 반환하는 함수 22 | function countByRange(arr, leftValue, rightValue) { 23 | // 유의: lowerBound와 upperBound는 end 변수의 값을 배열의 길이로 설정 24 | let rightIndex = upperBound(arr, rightValue, 0, arr.length); 25 | let leftIndex = lowerBound(arr, leftValue, 0, arr.length); 26 | return rightIndex - leftIndex; 27 | } 28 | 29 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 30 | let fs = require('fs'); 31 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 32 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 33 | 34 | let n = Number(input[0]); 35 | let arr = input[1].split(' ').map(Number); 36 | let m = Number(input[2]); 37 | let query = input[3].split(' ').map(Number); 38 | 39 | arr.sort((a, b) => a - b); 40 | 41 | answer = ''; 42 | for (let i = 0; i < m; i++) { 43 | // 값이 query[i]인 데이터가 있는지 확인 44 | let cnt = countByRange(arr, query[i], query[i]); 45 | if (cnt != 0) answer += 1 + ' '; 46 | else answer += 0 + ' '; 47 | } 48 | console.log(answer); -------------------------------------------------------------------------------- /solutions/16953.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽기 2 | let file = require('fs').readFileSync('/dev/stdin'); 3 | let input = file.toString().split('\n'); 4 | 5 | class Queue { 6 |   constructor() { 7 |     this.items = {}; 8 |     this.headIndex = 0; 9 |     this.tailIndex = 0; 10 |   } 11 |   enqueue(item) { 12 |     this.items[this.tailIndex] = item; 13 |     this.tailIndex++; 14 |   } 15 |   dequeue() { 16 |     const item = this.items[this.headIndex]; 17 |     delete this.items[this.headIndex]; 18 |     this.headIndex++; 19 |     return item; 20 |   } 21 |   peek() { 22 |     return this.items[this.headIndex]; 23 |   } 24 |   getLength() { 25 |     return this.tailIndex - this.headIndex; 26 |   } 27 | } 28 | 29 | // 시작(s)과 목표(t)를 입력받기 30 | let [s, t] = input[0].split(' ').map(Number); 31 | 32 | // 너비 우선 탐색(BFS) 수행 33 | let queue = new Queue(); 34 | // (값, 최소 연산 횟수) 삽입 35 | queue.enqueue([s, 0]); 36 | let visited = new Set([s]); 37 | let found = false; 38 | 39 | // 큐가 빌 때까지 반복하기 40 | while (queue.getLength() != 0) { 41 |   let [value, dist] = queue.dequeue(); 42 |   if (value > 1e9) continue; // 값의 범위를 벗어나는 경우 43 |   if (value == t) { // 목표 값에 도달한 경우 44 |     console.log(dist + 1); // 최소 연산 횟수 + 1을 출력 45 |     found = true; 46 |     break; 47 |   } 48 |   for (let oper of ['*', '+']) { // 각 연산자로 BFS 수행 49 |     let nextValue = value; 50 |     if (oper == '*') nextValue *= 2; // 2를 곱하기 51 |     if (oper == '+') { // 1을 수의 가장 오른쪽에 추가 52 | nextValue *= 10; 53 | nextValue += 1; 54 | } 55 |     if (!visited.has(nextValue)) { 56 |       queue.enqueue([nextValue, dist + 1]); 57 |       visited.add(nextValue); 58 |     } 59 |   } 60 | } 61 | // 바꿀 수 없는 경우 62 | if (!found) console.log(-1); 63 | -------------------------------------------------------------------------------- /solutions/10026.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽기 2 | let file = require('fs').readFileSync('/dev/stdin'); 3 | let input = file.toString().split('\n'); 4 | 5 | let n = Number(input[0]); // 전체 맵의 크기(N) 6 | let graph = []; // 그래프 정보 입력 7 | for (let i = 1; i <= n; i++) { 8 |   graph.push(input[i].split('')); 9 | } 10 | 11 | // 상, 하, 좌, 우 12 | let dx = [-1, 1, 0, 0]; 13 | let dy = [0, 0, -1, 1]; 14 | 15 | function dfs(x, y) { 16 | if (!visited[x][y]) { // 방문하지 않았다면 17 | visited[x][y] = true; // 방문 처리 18 | // 인접한 영역을 하나씩 확인 19 | for (let i = 0; i < 4; i++) { 20 | let nx = x + dx[i]; 21 | let ny = y + dy[i]; 22 | // 공간을 벗어나는 경우 무시 23 | if (nx < 0 || ny < 0 || nx >= n || ny >= n) { 24 | continue; 25 | } 26 | // 같은 색상이라면 재귀적으로 dfs() 호출 27 | if (graph[x][y] == graph[nx][ny]) { 28 | dfs(nx, ny); 29 | } 30 | } 31 | return true; 32 | } 33 | return false; 34 | } 35 | 36 | // DFS를 이용하여 연결 요소 세기 37 | let res1 = 0; 38 | let visited = []; 39 | for (let i = 0; i < n; i++) { 40 | visited.push(new Array(n).fill(false)); 41 | } 42 | for (let i = 0; i < n; i++) { 43 | for (let j = 0; j < n; j++) { 44 | if (dfs(i, j, 0)) res1++; 45 | } 46 | } 47 | 48 | // R → G 변환 이후에 다시 한 번 연결 요소 세기 49 | for (let i = 0; i < n; i++) { 50 | for (let j = 0; j < n; j++) { 51 | if (graph[i][j] == 'R') graph[i][j] = 'G'; 52 | } 53 | } 54 | 55 | // DFS를 이용하여 연결 요소 세기 56 | let res2 = 0; 57 | visited = []; 58 | for (let i = 0; i < n; i++) { 59 | visited.push(new Array(n).fill(false)); 60 | } 61 | for (let i = 0; i < n; i++) { 62 | for (let j = 0; j < n; j++) { 63 | if (dfs(i, j)) res2++; 64 | } 65 | } 66 | console.log(res1 + ' ' + res2); 67 | -------------------------------------------------------------------------------- /solutions/18258.js: -------------------------------------------------------------------------------- 1 | class Queue { 2 |   constructor() { 3 |     this.items = {}; 4 |     this.headIndex = 0; 5 |     this.tailIndex = 0; 6 |   } 7 |   enqueue(item) { 8 |     this.items[this.tailIndex] = item; 9 |     this.tailIndex++; 10 |   } 11 |   dequeue() { 12 |     const item = this.items[this.headIndex]; 13 |     delete this.items[this.headIndex]; 14 |     this.headIndex++; 15 |     return item; 16 |   } 17 |   peek() { 18 |     return this.items[this.headIndex]; 19 |   } 20 |   back() { 21 |     return this.items[this.tailIndex - 1]; 22 |   } 23 |   getLength() { 24 |     return this.tailIndex - this.headIndex; 25 |   } 26 | } 27 | 28 | let fs = require('fs'); 29 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 30 | 31 | let n = Number(input[0]); // 연산 횟수 32 | let queue = new Queue(); // 큐 초기화 33 | 34 | let answer = ''; 35 | for (let i = 1; i <= n; i++) { 36 | let line = input[i].split(' '); 37 | if (line[0] == 'push') { // 원소 삽입 38 | queue.enqueue(Number(line[1])); 39 | } 40 | else if (line[0] == 'pop') { // 원소 삭제 41 | if (queue.getLength() == 0) answer += -1 + '\n'; 42 | else answer += queue.dequeue() + '\n'; 43 | } 44 | else if (line[0] == 'size') { // 원소의 개수 45 | answer += queue.getLength() + '\n'; 46 | } 47 | else if (line[0] == 'empty') { // 큐가 비어있는지 48 | if (queue.getLength() == 0) answer += 1 + '\n'; 49 | else answer += 0 + '\n'; 50 | } 51 | else if (line[0] == 'front') { // 앞쪽 원소 출력 52 | if (queue.getLength() == 0) answer += -1 + '\n'; 53 | else answer += queue.peek() + '\n'; 54 | } 55 | else if (line[0] == 'back') { // 뒤쪽 원소 출력 56 | if (queue.getLength() == 0) answer += -1 + '\n'; 57 | else answer += queue.back() + '\n'; 58 | } 59 | } 60 | console.log(answer); 61 | -------------------------------------------------------------------------------- /solutions/5567.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽기 2 | let file = require('fs').readFileSync('/dev/stdin'); 3 | let input = file.toString().split('\n'); 4 | 5 | class Queue { 6 | constructor() { 7 | this.items = {}; 8 | this.headIndex = 0; 9 | this.tailIndex = 0; 10 | } 11 | enqueue(item) { 12 | this.items[this.tailIndex] = item; 13 | this.tailIndex++; 14 | } 15 | dequeue() { 16 | const item = this.items[this.headIndex]; 17 | delete this.items[this.headIndex]; 18 | this.headIndex++; 19 | return item; 20 | } 21 | peek() { 22 | return this.items[this.headIndex]; 23 | } 24 | getLength() { 25 | return this.tailIndex - this.headIndex; 26 | } 27 | } 28 | 29 | let n = Number(input[0]); // 학생(노드)의 수 30 | let m = Number(input[1]); // 친구 관계(간선)의 수 31 | // 그래프 정보 32 | let graph = []; 33 | for (let i = 1; i <= n; i++) { 34 |   graph[i] = []; 35 | } 36 | for (let i = 2; i <= m + 1; i++) { 37 |   let [x, y] = input[i].split(' ').map(Number); 38 |   graph[x].push(y); 39 |   graph[y].push(x); 40 | } 41 | 42 | // 모든 친구(노드)에 대한 최단 거리 초기화 43 | let distance = new Array(n + 1).fill(-1); 44 | distance[1] = 0; // 시작점까지의 거리는 0으로 설정 45 | 46 | // 너비 우선 탐색(BFS) 수행 47 | let queue = new Queue(); 48 | queue.enqueue(1); 49 | while (queue.getLength() != 0) { // 큐가 빌 때까지 반복하기 50 |   let now = queue.dequeue(); 51 |   // 현재 노드에서 이동할 수 있는 모든 노드를 확인 52 |   for (let nextNode of graph[now]) { 53 |     if (distance[nextNode] == -1) { // 방문하지 않은 노드라면 54 |       distance[nextNode] = distance[now] + 1; 55 |       queue.enqueue(nextNode); 56 |     } 57 |   } 58 | } 59 | // 최단 거리가 2 이하인 모든 친구(노드)의 수를 계산 60 | let result = 0; 61 | for (let i = 1; i <= n; i++) { 62 |   if (distance[i] != -1 && distance[i] <= 2) { 63 |     result++; 64 |   } 65 | } 66 | console.log(result - 1); // 자기 자신은 제외 67 | -------------------------------------------------------------------------------- /solutions/2178.js: -------------------------------------------------------------------------------- 1 | class Queue { 2 | constructor() { 3 | this.items = {}; 4 | this.headIndex = 0; 5 | this.tailIndex = 0; 6 | } 7 | enqueue(item) { 8 | this.items[this.tailIndex] = item; 9 | this.tailIndex++; 10 | } 11 | dequeue() { 12 | const item = this.items[this.headIndex]; 13 | delete this.items[this.headIndex]; 14 | this.headIndex++; 15 | return item; 16 | } 17 | peek() { 18 | return this.items[this.headIndex]; 19 | } 20 | back() { 21 | return this.items[this.tailIndex - 1]; 22 | } 23 | getLength() { 24 | return this.tailIndex - this.headIndex; 25 | } 26 | } 27 | 28 | let fs = require('fs'); 29 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 30 | 31 | let [n, m] = input[0].split(' ').map(Number) // 맵의 크기 입력(N X M) 32 | let arr = []; // 전체 맵 배열 33 | let visited = []; // 방문 여부 배열 34 | 35 | for (let i = 1; i <= n; i++) { 36 | let line = input[i].split('').map(Number); 37 | arr.push(line); 38 | visited.push(new Array(m).fill(0)); 39 | } 40 | 41 | // 상, 하, 좌, 우 42 | let dx = [-1, 1, 0, 0]; 43 | let dy = [0, 0, -1, 1]; 44 | 45 | let queue = new Queue(); 46 | queue.enqueue([0, 0]); 47 | visited[0][0] = 1; 48 | 49 | // 큐가 빌 때까지 반복 50 | while (queue.getLength() != 0) { 51 | let [x, y] = queue.dequeue(); // 현재 위치 52 | // 현재 위치에서 상, 하, 좌, 우 확인 53 | for (let i = 0; i < 4; i++) { 54 | // 다음 위치 55 | let nx = x + dx[i]; 56 | let ny = y + dy[i]; 57 | // 다음 위치가 미로 범위를 벗어나는 경우 무시 58 | if (nx < 0 || ny < 0 || nx >= n || ny >= m) { 59 | continue; 60 | } 61 | // 해당 위치를 처음 방문하면서 이동할 수 있는 경우 62 | if (visited[nx][ny] == 0 && arr[nx][ny] == 1) { 63 | visited[nx][ny] = visited[x][y] + 1; 64 | queue.enqueue([nx, ny]); 65 | } 66 | } 67 | } 68 | 69 | console.log(visited[n - 1][m - 1]); 70 | -------------------------------------------------------------------------------- /solutions/14395.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽기 2 | let file = require('fs').readFileSync('/dev/stdin'); 3 | let input = file.toString().split('\n'); 4 | 5 | class Queue { 6 |   constructor() { 7 |     this.items = {}; 8 |     this.headIndex = 0; 9 |     this.tailIndex = 0; 10 |   } 11 |   enqueue(item) { 12 |     this.items[this.tailIndex] = item; 13 |     this.tailIndex++; 14 |   } 15 |   dequeue() { 16 |     const item = this.items[this.headIndex]; 17 |     delete this.items[this.headIndex]; 18 |     this.headIndex++; 19 |     return item; 20 |   } 21 |   peek() { 22 |     return this.items[this.headIndex]; 23 |   } 24 |   getLength() { 25 |     return this.tailIndex - this.headIndex; 26 |   } 27 | } 28 | 29 | // 시작(s)과 목표(t)를 입력받기 30 | let [s, t] = input[0].split(' ').map(Number); 31 | 32 | // 너비 우선 탐색(BFS) 수행 33 | let queue = new Queue(); 34 | // (값, 해당 값을 만들기 위한 연산자) 삽입 35 | queue.enqueue([s, '']); 36 | let visited = new Set([s]); 37 | let found = false; 38 | 39 | if (s == t) { // 시작 값과 목표 값이 같은 경우 40 |   console.log(0); 41 |   process.exit(); 42 | } 43 | 44 | // 큐가 빌 때까지 반복하기 45 | while (queue.getLength() != 0) { 46 |   let [value, opers] = queue.dequeue(); 47 |   if (value > 1e9) continue; // 값의 범위를 벗어나는 경우 48 |   if (value == t) { // 목표 값에 도달한 경우 49 |     console.log(opers); // 전체 연산자들을 출력 50 |     found = true; 51 |     break; 52 |   } 53 |   for (let oper of ['*', '+', '-', '/']) { // 각 연산자로 BFS 수행 54 |     let nextValue = value; 55 |     if (oper == '*') nextValue *= value; 56 |     if (oper == '+') nextValue += value; 57 |     if (oper == '-') nextValue -= value; 58 |     if (oper == '/' && value != 0) nextValue = 1; 59 |     if (!visited.has(nextValue)) { 60 |       queue.enqueue([nextValue, opers + oper]); 61 |       visited.add(nextValue); 62 |     } 63 |   } 64 | } 65 | // 바꿀 수 없는 경우 66 | if (!found) console.log(-1); 67 | -------------------------------------------------------------------------------- /solutions/5214.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽기 2 | let file = require('fs').readFileSync('/dev/stdin'); 3 | let input = file.toString().split('\n'); 4 | 5 | class Queue { 6 | constructor() { 7 | this.items = {}; 8 | this.headIndex = 0; 9 | this.tailIndex = 0; 10 | } 11 | enqueue(item) { 12 | this.items[this.tailIndex] = item; 13 | this.tailIndex++; 14 | } 15 | dequeue() { 16 | const item = this.items[this.headIndex]; 17 | delete this.items[this.headIndex]; 18 | this.headIndex++; 19 | return item; 20 | } 21 | peek() { 22 | return this.items[this.headIndex]; 23 | } 24 | getLength() { 25 | return this.tailIndex - this.headIndex; 26 | } 27 | } 28 | 29 | // 역의 개수(N), 간선의 개수(K), 하이퍼튜브의 개수(M) 30 | let [n, k, m] = input[0].split(' ').map(Number); 31 | // 그래프 정보(N개의 역과 M개의 하이퍼튜브는 모두 노드) 32 | // 하이퍼튜브의 노드 번호는 N + 1번부터 출발 33 | let graph = []; 34 | for (let i = 1; i <= n + m; i++) graph[i] = []; 35 | for (let i = 1; i <= m; i++) { 36 |   let arr = input[i].split(' ').map(Number); 37 |   for (let x of arr) { 38 |     graph[x].push(n + i); // 노드 → 하이퍼 튜브 39 |     graph[n + i].push(x); // 하이퍼 튜브 → 노드 40 |   } 41 | } 42 | 43 | let visited = new Set([1]); // 1번 노드에서 출발 44 | let queue = new Queue(); 45 | queue.enqueue([0, 1]); // [거리, 노드 번호] 46 | let found = false; 47 | 48 | while (queue.getLength() != 0) { // 큐가 빌 때까지 반복하기 49 |   let [dist, now] = queue.dequeue(); 50 |   // N번 노드에 도착한 경우 51 |   if (now == n) { 52 |     // 절반은 하이퍼 튜브 53 |     console.log(parseInt(dist / 2) + 1); // 시작 노드도 포함 54 |     found = true; 55 |     break; 56 |   } 57 |   for (let y of graph[now]) { // 인접 노드를 하나씩 확인 58 |     if (!visited.has(y)) { // 아직 방문하지 않았다면 59 |       queue.enqueue([dist + 1, y]); 60 |       visited.add(y); // 방문 처리 61 |     } 62 |   } 63 | } 64 | if (!found) console.log(-1); // N번 노드에 도달 불가능 65 | -------------------------------------------------------------------------------- /solutions/2468.js: -------------------------------------------------------------------------------- 1 | class Queue { 2 | constructor() { 3 | this.items = {}; 4 | this.headIndex = 0; 5 | this.tailIndex = 0; 6 | } 7 | enqueue(item) { 8 | this.items[this.tailIndex] = item; 9 | this.tailIndex++; 10 | } 11 | dequeue() { 12 | const item = this.items[this.headIndex]; 13 | delete this.items[this.headIndex]; 14 | this.headIndex++; 15 | return item; 16 | } 17 | peek() { 18 | return this.items[this.headIndex]; 19 | } 20 | getLength() { 21 | return this.tailIndex - this.headIndex; 22 | } 23 | } 24 | 25 | let fs = require('fs'); 26 | let input = fs 27 | .readFileSync('/dev/stdin') 28 | .toString() 29 | .split('\n'); 30 | 31 | // 맵의 크기(N) 32 | let n = Number(input[0]); 33 | // 전체 맵 입력받기 34 | let graph = []; 35 | for (let i = 1; i <= n; i++) { 36 | let row = input[i].split(' ').map(Number); 37 | graph.push(row); 38 | } 39 | // 방문 처리 배열 40 | let visited = null; 41 | 42 | // 동, 북, 서, 남 43 | let dx = [0, -1, 0, 1]; 44 | let dy = [1, 0, -1, 0]; 45 | 46 | function dfs(x, y) { 47 | // 동, 북, 서, 남 위치로 4가지 방향 확인 48 | for (let i = 0; i < 4; i++) { 49 | let nx = x + dx[i]; 50 | let ny = y + dy[i]; 51 | // 공간을 벗어나는 경우 무시 52 | if (nx < 0 || nx >= n || ny < 0 || ny >= n) { 53 | continue; 54 | } 55 | // 처음 방문하는 위치이면서 높이 이상이라면 재귀적으로 방문 처리 56 | if (!visited[nx][ny] && height < graph[nx][ny]) { 57 | visited[nx][ny] = true; 58 | dfs(nx, ny); 59 | } 60 | } 61 | } 62 | 63 | let maxCnt = 0; 64 | let height = 0; 65 | for (; height <= 100; height++) { 66 | visited = Array.from(Array(n), () => Array(n).fill(false)); 67 | let cnt = 0; // 연결 요소의 개수 68 | for (let i = 0; i < n; i++) { 69 | for (let j = 0; j < n; j++) { 70 | // 연결 요소를 찾은 경우 71 | if (!visited[i][j] && height < graph[i][j]) { 72 | visited[i][j] = true; 73 | dfs(i, j); 74 | cnt++; 75 | } 76 | } 77 | } 78 | maxCnt = Math.max(maxCnt, cnt); 79 | } 80 | 81 | console.log(maxCnt); 82 | -------------------------------------------------------------------------------- /solutions/24444.js: -------------------------------------------------------------------------------- 1 | class Queue { 2 | constructor() { 3 | this.items = {}; 4 | this.headIndex = 0; 5 | this.tailIndex = 0; 6 | } 7 | enqueue(item) { 8 | this.items[this.tailIndex] = item; 9 | this.tailIndex++; 10 | } 11 | dequeue() { 12 | const item = this.items[this.headIndex]; 13 | delete this.items[this.headIndex]; 14 | this.headIndex++; 15 | return item; 16 | } 17 | peek() { 18 | return this.items[this.headIndex]; 19 | } 20 | getLength() { 21 | return this.tailIndex - this.headIndex; 22 | } 23 | } 24 | 25 | let fs = require('fs'); 26 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 27 | 28 | // 노드의 개수(N), 간선의 개수(M), 시작 노드(R) 29 | let [n, m, r] = input[0].split(' ').map(Number); 30 | 31 | // 노드가 N개인 그래프 초기화 32 | let graph = []; 33 | for (let i = 0; i <= n; i++) { 34 | graph.push([]); 35 | } 36 | 37 | // 그래프 데이터 입력 38 | for (let i = 1; i <= m; i++) { 39 | let [u, v] = input[i].split(' ').map(Number); 40 | graph[u].push(v); 41 | graph[v].push(u); 42 | } 43 | 44 | // 인접 리스트에 대하여 노드 번호 순으로 오름차순 45 | for (let i = 1; i <= n; i++) { 46 | graph[i].sort((a, b) => a - b); 47 | } 48 | 49 | let visited = Array(n + 1).fill(0); // 각 노드에 대한 방문 여부(순서) 50 | let number = 1; // 방문 순서 51 | 52 | // BFS(너비 우선 탐색) 소스 코드 53 | function bfs(start) { 54 | queue = new Queue(); 55 | queue.enqueue(start); 56 | // 현재 노드를 방문 처리 57 | visited[start] = number; 58 | number++; 59 | // 큐가 빌 때까지 반복 60 | while (queue.getLength() != 0) { 61 | // 큐에서 하나의 원소를 뽑아 출력하기 62 | v = queue.dequeue(); 63 | // 아직 방문하지 않은 인접한 원소들을 큐에 삽입 64 | for (i of graph[v]) { 65 | if (visited[i] == 0) { 66 | queue.enqueue(i); 67 | visited[i] = number; 68 | number++; 69 | } 70 | } 71 | } 72 | } 73 | 74 | bfs(r); // 시작 노드에서 출발 75 | 76 | let answer = ""; 77 | // 각 노드를 방문한 순서를 출력 78 | for (let i = 1; i <= n; i++) { 79 | answer += visited[i] + "\n"; 80 | } 81 | console.log(answer); 82 | -------------------------------------------------------------------------------- /solutions/24445.js: -------------------------------------------------------------------------------- 1 | class Queue { 2 | constructor() { 3 | this.items = {}; 4 | this.headIndex = 0; 5 | this.tailIndex = 0; 6 | } 7 | enqueue(item) { 8 | this.items[this.tailIndex] = item; 9 | this.tailIndex++; 10 | } 11 | dequeue() { 12 | const item = this.items[this.headIndex]; 13 | delete this.items[this.headIndex]; 14 | this.headIndex++; 15 | return item; 16 | } 17 | peek() { 18 | return this.items[this.headIndex]; 19 | } 20 | getLength() { 21 | return this.tailIndex - this.headIndex; 22 | } 23 | } 24 | 25 | let fs = require('fs'); 26 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 27 | 28 | // 노드의 개수(N), 간선의 개수(M), 시작 노드(R) 29 | let [n, m, r] = input[0].split(' ').map(Number); 30 | 31 | // 노드가 N개인 그래프 초기화 32 | let graph = []; 33 | for (let i = 0; i <= n; i++) { 34 | graph.push([]); 35 | } 36 | 37 | // 그래프 데이터 입력 38 | for (let i = 1; i <= m; i++) { 39 | let [u, v] = input[i].split(' ').map(Number); 40 | graph[u].push(v); 41 | graph[v].push(u); 42 | } 43 | 44 | // 인접 리스트에 대하여 노드 번호 순으로 내림차순 45 | for (let i = 1; i <= n; i++) { 46 | graph[i].sort((a, b) => b - a); 47 | } 48 | 49 | let visited = Array(n + 1).fill(0); // 각 노드에 대한 방문 여부(순서) 50 | let number = 1; // 방문 순서 51 | 52 | // BFS(너비 우선 탐색) 소스 코드 53 | function bfs(start) { 54 | queue = new Queue(); 55 | queue.enqueue(start); 56 | // 현재 노드를 방문 처리 57 | visited[start] = number; 58 | number++; 59 | // 큐가 빌 때까지 반복 60 | while (queue.getLength() != 0) { 61 | // 큐에서 하나의 원소를 뽑아 출력하기 62 | v = queue.dequeue(); 63 | // 아직 방문하지 않은 인접한 원소들을 큐에 삽입 64 | for (i of graph[v]) { 65 | if (visited[i] == 0) { 66 | queue.enqueue(i); 67 | visited[i] = number; 68 | number++; 69 | } 70 | } 71 | } 72 | } 73 | 74 | bfs(r); // 시작 노드에서 출발 75 | 76 | let answer = ""; 77 | // 각 노드를 방문한 순서를 출력 78 | for (let i = 1; i <= n; i++) { 79 | answer += visited[i] + "\n"; 80 | } 81 | console.log(answer); 82 | -------------------------------------------------------------------------------- /solutions/7453.js: -------------------------------------------------------------------------------- 1 | /* 2 | 단순한 접근을 고려하면, 3 | 4중 반복문을 이용해서 O(N^4)의 알고리즘을 설계할 수 있습니다. 4 | 5 | [시간 초과] 6 | let fs = require('fs'); 7 | let input = fs.readFileSync('input.txt').toString().split('\n'); 8 | 9 | let n = Number(input[0]); 10 | let A = [], B = [], C = [], D = []; 11 | 12 | for (let i = 1; i <= n; i++) { 13 | let [a, b, c, d] = [...input[i].split(' ').map(Number)]; 14 | A.push(a), B.push(b), C.push(c), D.push(d); 15 | } 16 | let cnt = 0; 17 | for (let i = 0; i < n; i++) { 18 | for (let j = 0; j < n; j++) { 19 | for (let k = 0; k < n; k++) { 20 | for (let l = 0; l < n; l++) { 21 | if (A[i] + B[j] + C[k] + D[l] == 0) cnt++; 22 | } 23 | } 24 | } 25 | } 26 | console.log(cnt); 27 | 28 | 시간 제한이 12초이기 때문에 29 | O(N^2)이나 O(N^2 * logN) 정도의 알고리즘을 설계하면 문제를 풀 수 있다. 30 | 31 | [핵심 아이디어] 32 | 시간을 줄이기 위해서 메모리를 써서 "미리" 무언가를 계산해 놓기. 33 | 배열 A, B, C, D가 있을 때 34 | A와 B만 사용해서 "모든 합"을 미리 구해놓기. 35 | 36 | */ 37 | 38 | let fs = require('fs'); 39 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 40 | 41 | let n = Number(input[0]); // 각 배열에 들어갈 원소의 개수 N 42 | let A = [], B = [], C = [], D = []; // 4개의 배열(A, B, C, D) 43 | 44 | // 각 배열에 원소 넣기 45 | for (let i = 1; i <= n; i++) { 46 | let [a, b, c, d] = [...input[i].split(' ').map(Number)]; 47 | A.push(a), B.push(b), C.push(c), D.push(d); 48 | } 49 | 50 | // A랑 B만을 고려해서 미리 "가능한 합"의 개수들을 미리 구해 놓기 51 | // A[2] + B[3] = 7이고, A[5] + B[4] = 7이라고 한다면, 52 | // 합계 "7"을 만드는 경우가 2개 존재한다는 의미입니다. 53 | // {7: 2} 54 | let dict = {}; 55 | for (let i = 0; i < n; i++) { 56 | for (let j = 0; j < n; j++) { 57 | let sum = A[i] + B[j]; 58 | if (sum in dict) dict[sum]++; 59 | else dict[sum] = 1; 60 | } 61 | } 62 | 63 | // 이제 C랑 D만을 보면서, 가능한 합계에 해당하는지 확인 64 | let result = 0; 65 | for (let i = 0; i < n; i++) { 66 | for (let j = 0; j < n; j++) { 67 | let sum = C[i] + D[j]; 68 | // -sum이 앞서 A와 B의 가능한 합인지 확인 69 | if (-sum in dict) result += dict[-sum]; 70 | } 71 | } 72 | console.log(result); 73 | -------------------------------------------------------------------------------- /solutions/14867.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽기 2 | let file = require('fs').readFileSync('/dev/stdin'); 3 | let input = file.toString().split('\n'); 4 | 5 | class Queue { 6 | constructor() { 7 | this.items = {}; 8 | this.headIndex = 0; 9 | this.tailIndex = 0; 10 | } 11 | enqueue(item) { 12 | this.items[this.tailIndex] = item; 13 | this.tailIndex++; 14 | } 15 | dequeue() { 16 | const item = this.items[this.headIndex]; 17 | delete this.items[this.headIndex]; 18 | this.headIndex++; 19 | return item; 20 | } 21 | peek() { 22 | return this.items[this.headIndex]; 23 | } 24 | getLength() { 25 | return this.tailIndex - this.headIndex; 26 | } 27 | } 28 | 29 | // (A의 최대 용량, B의 최대 용량, A의 목표 상태, B의 목표 상태) 입력 30 | let [a, b, c, d] = input[0].split(' ').map(Number); 31 | let queue = new Queue(); 32 | queue.enqueue([0, 0, 0]); // 최소 연산 횟수, A 상태, B 상태 33 | let visited = new Set(); 34 | let found = false; 35 | 36 | // 현재의 (A 상태, B 상태)를 방문 처리 37 | function visit(dist, nx, ny) { 38 | // A에 3, B에 7만큼 물이 있다면 "3,7"이라는 문자열을 visited에 삽입 39 |   if (!visited.has(nx + ',' + ny)) { 40 |     queue.enqueue([dist, nx, ny]); 41 |     visited.add(nx + ',' + ny); 42 |   } 43 | } 44 | 45 | while (queue.getLength() != 0) { // 큐가 빌 때까지 반복하기 46 | // 최소 연산 횟수, A 상태, B 상태 47 |   let [dist, x, y] = queue.dequeue(); 48 |   if (x == c && y == d) { // 목표 상태에 도달한 경우 49 |     console.log(dist); // 최소 연산 횟수 출력 50 |     found = true; 51 |     break; 52 |   } 53 | // 6가지 연산을 하나씩 수행하는 방식으로 BFS 수행 54 |   [nx, ny] = [x, 0]; // Empty B 55 |   visit(dist + 1, nx, ny); 56 |   [nx, ny] = [0, y]; // Empty A 57 |   visit(dist + 1, nx, ny); 58 |   [nx, ny] = [x, b]; // Fill B 59 |   visit(dist + 1, nx, ny); 60 |   [nx, ny] = [a, y]; // Fill A 61 |   visit(dist + 1, nx, ny); 62 |   // B에서 A로 물 옮기기 63 |   if (x + y < a) [nx, ny] = [x + y, 0]; 64 |   else [nx, ny] = [a, x + y - a]; 65 |   visit(dist + 1, nx, ny); 66 |   // A에서 B로 물 옮기기 67 |   if (x + y < b) [nx, ny] = [0, x + y]; 68 |   else [nx, ny] = [x + y - b, b]; 69 |   visit(dist + 1, nx, ny); 70 | } 71 | if (!found) console.log(-1); 72 | -------------------------------------------------------------------------------- /solutions/2108.js: -------------------------------------------------------------------------------- 1 | // readline 모듈보다는 fs를 이용해 파일 전체를 읽어 들여 처리하기 2 | let fs = require('fs'); 3 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 4 | // let input = fs.readFileSync('input.txt').toString().split('\n'); 5 | 6 | let n = Number(input[0]) 7 | let arr = [] 8 | 9 | for (let i = 1; i <= n; i++) { 10 | arr.push(Number(input[i])) 11 | } 12 | 13 | // 산술 평균 14 | let summary = arr.reduce((a, b) => a + b); 15 | console.log(Math.round(summary / n)); 16 | // 중앙값 17 | arr.sort((a, b) => a - b); 18 | let median = arr[parseInt(n / 2)]; 19 | console.log(median) 20 | // 각 원소마다 출현 빈도수 계산 21 | let counter = new Map(); 22 | for (let i = 0; i < n; i++) { 23 | if (counter.has(arr[i])) { 24 | counter.set(arr[i], counter.get(arr[i]) + 1); 25 | } 26 | else { 27 | counter.set(arr[i], 1); 28 | } 29 | } 30 | // 가장 빈도수가 높은 원소들을 찾기 31 | let maxValue = 0; 32 | let maxElements = []; 33 | for (let key of counter.keys()) { 34 | if (maxValue < counter.get(key)) { 35 | maxValue = counter.get(key); 36 | maxElements = [key]; 37 | } 38 | else if (maxValue == counter.get(key)) { 39 | maxElements.push(key); 40 | } 41 | } 42 | // 가장 많이 나타나는 값 출력 43 | // JavaScript의 Map은 기본적으로 입력된 순서대로 순회 44 | if (maxElements.length >= 2) { 45 | console.log(maxElements[1]); 46 | } 47 | else { 48 | console.log(maxElements[0]); 49 | } 50 | // 범위 출력 51 | console.log(arr[n - 1] - arr[0]); 52 | 53 | 54 | /* 풀이 방법 2 55 | let fs = require('fs'); 56 | let input = fs.readFileSync('/dev/stdin').toString().split('\n'); 57 | 58 | let n = Number(input[0]); 59 | let arr = []; 60 | for (let i = 1; i <= n; i++) { 61 | arr.push(Number(input[i])); 62 | } 63 | 64 | // 산술 평균 65 | let sum = 0; 66 | for (let i = 0; i < n; i++) sum += arr[i]; 67 | console.log(parseInt(Math.round(sum / n))); 68 | 69 | // 중앙값 70 | arr.sort((a, b) => a - b); 71 | console.log(arr[parseInt(n / 2)]); 72 | 73 | // 최빈값 74 | counter = {}; 75 | let maxCount = -1; 76 | for (let i = 0; i < n; i++) { 77 | if (arr[i] in counter) counter[arr[i]]++; 78 | else counter[arr[i]] = 1; 79 | maxCount = Math.max(maxCount, counter[arr[i]]); 80 | } 81 | let maxValues = []; 82 | for (const [key, value] of Object.entries(counter)) { 83 | if (value == maxCount) { 84 | maxValues.push(key); 85 | } 86 | } 87 | maxValues.sort((a, b) => a - b); 88 | if (maxValues.length == 1) console.log(maxValues[0]); 89 | else console.log(maxValues[1]); 90 | 91 | // 가장 작은 값, 큰 값 출력 92 | let minValue = 4001; 93 | let maxValue = -4001; 94 | for (let i = 0; i < n; i++) { 95 | minValue = Math.min(minValue, arr[i]); 96 | maxValue = Math.max(maxValue, arr[i]); 97 | } 98 | console.log(maxValue - minValue); 99 | */ 100 | -------------------------------------------------------------------------------- /solutions/10866.js: -------------------------------------------------------------------------------- 1 | class Deque { 2 | constructor() { 3 | this.front = this.back = undefined; 4 | this.length = 0; 5 | } 6 | addFront(value) { 7 | if (!this.front) this.front = this.back = { value }; 8 | else this.front = this.front.next = { value, prev: this.front }; 9 | this.length += 1; 10 | } 11 | removeFront() { 12 | let value = this.peekFront(); 13 | if (this.front === this.back) this.front = this.back = undefined; 14 | else (this.front = this.front.prev).next = undefined; 15 | if (this.length > 0) this.length -= 1; 16 | return value; 17 | } 18 | peekFront() { 19 | return this.front && this.front.value; 20 | } 21 | addBack(value) { 22 | if (!this.front) this.front = this.back = { value }; 23 | else this.back = this.back.prev = { value, next: this.back }; 24 | this.length += 1; 25 | } 26 | removeBack() { 27 | let value = this.peekBack(); 28 | if (this.front === this.back) this.front = this.back = undefined; 29 | else (this.back = this.back.next).back = undefined; 30 | if (this.length > 0) this.length -= 1; 31 | return value; 32 | } 33 | peekBack() { 34 | return this.back && this.back.value; 35 | } 36 | getSize() { 37 | return this.length; 38 | } 39 | } 40 | 41 | let fs = require('fs'); 42 | let input = fs.readFileSync("/dev/stdin").toString().split("\n"); 43 | 44 | let n = Number(input[0]); 45 | let answer = ''; 46 | 47 | let deque = new Deque; 48 | for (let i = 1; i <= n; i++) { 49 | let line = input[i].split(' '); 50 | if (line[0] == "push_front") { 51 | let x = Number(line[1]); 52 | deque.addFront(x); 53 | } 54 | else if (line[0] == "push_back") { 55 | let x = Number(line[1]); 56 | deque.addBack(x); 57 | } 58 | else if (line[0] == "pop_front") { 59 | let x = deque.removeFront(); 60 | if (typeof x == "undefined") { 61 | answer += -1 + '\n'; 62 | } 63 | else { 64 | answer += x + '\n'; 65 | } 66 | } 67 | else if (line[0] == "pop_back") { 68 | let x = deque.removeBack(); 69 | if (typeof x == "undefined") { 70 | answer += -1 + '\n'; 71 | } 72 | else { 73 | answer += x + '\n'; 74 | } 75 | } 76 | else if (line[0] == "size") { 77 | let size = deque.getSize(); 78 | answer += size + '\n'; 79 | } 80 | else if (line[0] == "empty") { 81 | let size = deque.getSize(); 82 | if (size == 0) { 83 | answer += 1 + '\n'; 84 | } 85 | else { 86 | answer += 0 + '\n'; 87 | } 88 | } 89 | else if (line[0] == "front") { 90 | let x = deque.peekFront(); 91 | if (typeof x == "undefined") { 92 | answer += -1 + '\n'; 93 | } 94 | else { 95 | answer += x + '\n'; 96 | } 97 | } 98 | else if (line[0] == "back") { 99 | let x = deque.peekBack(); 100 | if (typeof x == "undefined") { 101 | answer += -1 + '\n'; 102 | } 103 | else { 104 | answer += x + '\n'; 105 | } 106 | } 107 | } 108 | 109 | console.log(answer); 110 | -------------------------------------------------------------------------------- /sortingComparison.js: -------------------------------------------------------------------------------- 1 | // 선택 정렬 함수 2 | function selectionSort(arr) { 3 | for (let i = 0; i < arr.length; i++) { 4 |   let minIndex = i // 가장 작은 원소의 인덱스 5 |   for (let j = i + 1; j < arr.length; j++) { 6 |     if (arr[minIndex] > arr[j]) { 7 |       minIndex = j; 8 |     } 9 |   } 10 |   // 스와프(swap) 11 |   let temp = arr[i]; 12 |   arr[i] = arr[minIndex]; 13 |   arr[minIndex] = temp; 14 | } 15 | } 16 | 17 | // 삽입 정렬 함수 18 | function insertionSort(arr) { 19 | for (let i = 1; i < arr.length; i++) { 20 |   for (let j = i; j > 0; j--) { // 인덱스 j부터 1까지 1씩 감소하며 반복 21 |     if (arr[j] < arr[j - 1]) { // 한 칸씩 왼쪽으로 이동 22 |       // 스와프(swap) 23 |       let temp = arr[j]; 24 |       arr[j] = arr[j - 1]; 25 |       arr[j - 1] = temp; 26 |     } 27 |     else { // 자기보다 작은 데이터를 만나면 그 위치에서 멈춤 28 |       break; 29 |     } 30 |   } 31 | } 32 | } 33 | 34 | function quickSort(arr, start, end) { 35 |   if (start >= end) return; // 원소가 1개인 경우 종료 36 |   let pivot = start; // 피벗은 첫 번째 원소 37 |   let left = start + 1; 38 |   let right = end; 39 |   while (left <= right) { 40 |     // 피벗보다 큰 데이터를 찾을 때까지 반복 41 |     while (left <= end && arr[left] <= arr[pivot]) left++; 42 |     // 피벗보다 작은 데이터를 찾을 때까지 반복 43 |     while (right > start && arr[right] >= arr[pivot]) right--; 44 |     // 엇갈렸다면 작은 데이터와 피벗을 교체 45 |     if (left > right) [arr[right], arr[pivot]] = [arr[pivot], arr[right]]; 46 |     // 엇갈리지 않았다면 작은 데이터와 큰 데이터를 교체 47 |     else [arr[left], arr[right]] = [arr[right], arr[left]]; 48 |   } 49 |   // 분할 이후 왼쪽 부분과 오른쪽 부분에서 각각 정렬 수행 50 |   quickSort(arr, start, right - 1); 51 |   quickSort(arr, right + 1, end); 52 | } 53 | 54 | /* 1) 선택 정렬의 수행 시간 측정 */ 55 | // 0부터 999까지의 정수 30000개를 담은 배열 생성 56 | let arr = Array.from({length: 30000}, () => Math.floor(Math.random() * 1000)); 57 | 58 | // getTime(): 1970-01-01부터의 시간차를 ms 단위로 계산 59 | let startTime = new Date().getTime(); 60 | selectionSort(arr); 61 | let endTime = new Date().getTime(); 62 | 63 | // 시간차 출력 64 | console.log("선택 정렬 소요 시간:", endTime - startTime); 65 | 66 | /* 2) 이미 정렬된 배열에 대한 선택 정렬의 수행 시간 측정 */ 67 | // 0부터 999까지의 정수 30000개를 담은 배열 생성 68 | arr = Array.from({length: 30000}, () => 7); 69 | 70 | // getTime(): 1970-01-01부터의 시간차를 ms 단위로 계산 71 | startTime = new Date().getTime(); 72 | selectionSort(arr); 73 | endTime = new Date().getTime(); 74 | 75 | // 시간차 출력 76 | console.log("정렬된 배열에 대한 선택 정렬 소요 시간:", endTime - startTime); 77 | 78 | /* 3) 삽입 정렬의 수행 시간 측정 */ 79 | // 0부터 999까지의 정수 30000개를 담은 배열 생성 80 | arr = Array.from({length: 30000}, () => Math.floor(Math.random() * 1000)); 81 | 82 | // getTime(): 1970-01-01부터의 시간차를 ms 단위로 계산 83 | startTime = new Date().getTime(); 84 | insertionSort(arr); 85 | endTime = new Date().getTime(); 86 | 87 | // 시간차 출력 88 | console.log("삽입 정렬 소요 시간:", endTime - startTime); 89 | 90 | /* 4) 이미 정렬된 배열에 대한 삽입 정렬의 수행 시간 측정 */ 91 | // 0부터 999까지의 정수 30000개를 담은 배열 생성 92 | arr = Array.from({length: 30000}, () => 7); 93 | 94 | // getTime(): 1970-01-01부터의 시간차를 ms 단위로 계산 95 | startTime = new Date().getTime(); 96 | insertionSort(arr); 97 | endTime = new Date().getTime(); 98 | 99 | // 시간차 출력 100 | console.log("정렬된 배열에 대한 삽입 정렬 소요 시간:", endTime - startTime); 101 | 102 | /* 5) 퀵정렬의 수행 시간 측정 */ 103 | // 0부터 999까지의 정수 30000개를 담은 배열 생성 104 | arr = Array.from({length: 30000}, () => Math.floor(Math.random() * 1000)); 105 | 106 | // getTime(): 1970-01-01부터의 시간차를 ms 단위로 계산 107 | startTime = new Date().getTime(); 108 | quickSort(arr, 0, arr.length - 1); 109 | endTime = new Date().getTime(); 110 | 111 | // 시간차 출력 112 | console.log("퀵정렬 소요 시간:", endTime - startTime); 113 | -------------------------------------------------------------------------------- /solutions/16928.js: -------------------------------------------------------------------------------- 1 | /* [풀이 1] 2 | class Queue { 3 | constructor() { 4 | this.items = {}; 5 | this.headIndex = 0; 6 | this.tailIndex = 0; 7 | } 8 | enqueue(item) { 9 | this.items[this.tailIndex] = item; 10 | this.tailIndex++; 11 | } 12 | dequeue() { 13 | const item = this.items[this.headIndex]; 14 | delete this.items[this.headIndex]; 15 | this.headIndex++; 16 | return item; 17 | } 18 | peek() { 19 | return this.items[this.headIndex]; 20 | } 21 | getLength() { 22 | return this.tailIndex - this.headIndex; 23 | } 24 | } 25 | 26 | let fs = require('fs'); 27 | let input = fs 28 | .readFileSync('/dev/stdin') 29 | .toString() 30 | .split('\n'); 31 | 32 | // 사다리 수(N), 뱀의 수(M) 33 | let [n, m] = input[0].split(' ').map(Number); 34 | let ladders = {}; 35 | let snakes = {}; 36 | 37 | 38 | // * 단순히 주사위를 굴리면 간선의 길이가 1인 것으로 이해 가능 39 | // * 사다리나 뱀을 타고 가면 간선의 길이가 0인 것으로 이해 가능 40 | // * 따라서 이 문제는 BFS가 아닌 다익스트라와 같은 최단 경로 알고리즘을 이용해서 해결 가능 41 | // * 하지만 노드의 개수가 100개이므로, BFS 형식으로도 최단 경로를 찾아 해결 가능 42 | 43 | // 사다리 입력 44 | for (let i = 1; i <= n; i++) { 45 | let [x, y] = input[i].split(' ').map(Number); 46 | ladders[x] = y; 47 | } 48 | 49 | // 뱀 입력 50 | for (let i = n + 1; i <= n + m; i++) { 51 | let [u, v] = input[i].split(' ').map(Number); 52 | snakes[u] = v; 53 | } 54 | 55 | // 노드가 1부터 100까지인 그래프를 초기화 56 | let graph = []; 57 | for (let i = 0; i <= 100; i++) { 58 | // 현재 위치 i에서 1~6을 더한 위치로 이동 가능 59 | adj = [i + 1, i + 2, i + 3, i + 4, i + 5, i + 6]; 60 | graph.push(adj); 61 | } 62 | 63 | let visited = Array(101).fill(-1); // 각 노드에 대한 방문 여부(거리) 64 | 65 | queue = new Queue(); 66 | queue.enqueue(1); // 1번 노드에서부터 BFS 수행 67 | visited[1] = 0; // 1번 노드까지의 거리는 0 68 | // 큐가 빌 때까지 반복 69 | while (queue.getLength() != 0) { 70 | // 큐에서 하나의 원소를 뽑아 출력하기 71 | v = queue.dequeue(); 72 | // 사다리나 뱀의 위치인지 검사 (주사위를 굴리는 횟수 추가 X) 73 | if (v in ladders) { 74 | x = ladders[v]; 75 | // 처음 방문하는 경우 최단 거리를 기록 76 | if (visited[x] == -1) { 77 | queue.enqueue(x); 78 | visited[x] = visited[v]; 79 | } 80 | // 방문한 적이 있더라도 더 최단 거리가 있다면 81 | else if (visited[x] > visited[v]) { 82 | queue.enqueue(x); 83 | visited[x] = visited[v]; 84 | } 85 | } else if (v in snakes) { 86 | x = snakes[v]; 87 | // 처음 방문하는 경우 최단 거리를 기록 88 | if (visited[x] == -1) { 89 | queue.enqueue(x); 90 | visited[x] = visited[v]; 91 | } 92 | // 방문한 적이 있더라도 더 최단 거리가 있다면 93 | else if (visited[x] > visited[v]) { 94 | queue.enqueue(x); 95 | visited[x] = visited[v]; 96 | } 97 | } else { 98 | // 아직 방문하지 않은 인접한 원소들을 큐에 삽입 99 | for (x of graph[v]) { 100 | // 범위를 벗어나는 경우 무시 101 | if (x < 1 || x > 100) continue; 102 | // 처음 방문하는 경우 최단 거리를 기록 103 | if (visited[x] == -1) { 104 | queue.enqueue(x); 105 | // 주사위를 굴리는 횟수를 추가 106 | visited[x] = visited[v] + 1; 107 | } 108 | // 방문한 적이 있더라도 더 최단 거리가 있다면 109 | else if (visited[x] > visited[v]) { 110 | queue.enqueue(x); 111 | visited[x] = visited[v] + 1; 112 | } 113 | } 114 | } 115 | } 116 | 117 | console.log(visited[100]); 118 | */ 119 | 120 | class Queue { 121 | constructor() { 122 | this.items = {}; 123 | this.headIndex = 0; 124 | this.tailIndex = 0; 125 | } 126 | enqueue(item) { 127 | this.items[this.tailIndex] = item; 128 | this.tailIndex++; 129 | } 130 | dequeue() { 131 | const item = this.items[this.headIndex]; 132 | delete this.items[this.headIndex]; 133 | this.headIndex++; 134 | return item; 135 | } 136 | peek() { 137 | return this.items[this.headIndex]; 138 | } 139 | getLength() { 140 | return this.tailIndex - this.headIndex; 141 | } 142 | } 143 | 144 | let fs = require('fs'); 145 | let input = fs 146 | .readFileSync('/dev/stdin') 147 | .toString() 148 | .split('\n'); 149 | 150 | // 사다리 수(N), 뱀의 수(M) 151 | let [n, m] = input[0].split(' ').map(Number); 152 | let roads = {}; 153 | 154 | // 사다리 입력 155 | for (let i = 1; i <= n; i++) { 156 | let [x, y] = input[i].split(' ').map(Number); 157 | roads[x] = y; 158 | } 159 | 160 | // 뱀 입력 161 | for (let i = n + 1; i <= n + m; i++) { 162 | let [u, v] = input[i].split(' ').map(Number); 163 | roads[u] = v; 164 | } 165 | 166 | // 노드가 1부터 100까지인 그래프를 초기화 167 | let graph = []; 168 | for (let i = 0; i <= 100; i++) { 169 | // 현재 위치 i에서 1~6을 더한 위치로 이동 가능 170 | adj = [i + 1, i + 2, i + 3, i + 4, i + 5, i + 6]; 171 | graph.push(adj); 172 | } 173 | 174 | let visited = Array(101).fill(-1); // 각 노드에 대한 방문 여부(거리) 175 | 176 | queue = new Queue(); 177 | queue.enqueue(1); // 1번 노드에서부터 BFS 수행 178 | visited[1] = 0; // 1번 노드까지의 거리는 0 179 | // 큐가 빌 때까지 반복 180 | while (queue.getLength() != 0) { 181 | // 큐에서 하나의 원소를 뽑아 출력하기 182 | v = queue.dequeue(); 183 | // 아직 방문하지 않은 인접한 원소들을 큐에 삽입 184 | for (x of graph[v]) { 185 | // 범위를 벗어나는 경우 무시 186 | if (x < 1 || x > 100) continue; 187 | // 사다리나 뱀의 위치인지 검사 (주사위를 굴리는 횟수 추가 X) 188 | // 사다리나 뱀의 위치인 경우, (시작 노드 = 도착 노드)로 간주 가능 189 | while (x in roads) { 190 | x = roads[x]; 191 | } 192 | // 처음 방문하는 경우 최단 거리를 기록 193 | if (visited[x] == -1) { 194 | queue.enqueue(x); 195 | // 주사위를 굴리는 횟수를 추가(최단 거리 기록) 196 | visited[x] = visited[v] + 1; 197 | } 198 | } 199 | } 200 | 201 | console.log(visited[100]); 202 | --------------------------------------------------------------------------------