Happy Programmer

숫자 1은 2cm, 숫자 0은 4cm, 나머지는 3cm라고 주어지는데

여백을 포함하려면 숫자 갯수 +1만큼의 값을 더 더해줘야 하기 때문에

초기 세팅 값은 1cm로 두고 1 = 3cm, 0 = 5cm, 나머지 = 4cm 라고 인식하고 푸는 것이 더 편하다.

또한 입력의 마지막은 0이기 때문에 마지막 한줄은 무시하는 방식으로 진행할 수 있으며

전체적인 결과를 result에 담아 한번에 출력해준다.

const input = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n')

const result = []
for(let i = 0 ; i < input.length-1 ; i++){
    let sum = 1
    for(let j = 0 ; j < input[i].length ; j++){
        if(input[i][j] === '0'){
            sum += 5
        }
        else if(input[i][j] === '1'){
            sum += 3
        }
        else{
            sum += 4
        }
    }
    result.push(sum)
}

console.log(result.join('\n'))

const input = `120
5611
100
0`.split('\n')

const result = []
for(let i = 0 ; i < input.length-1 ; i++){
    let sum = 1
    for(let j = 0 ; j < input[i].length ; j++){
        if(input[i][j] === '0'){
            sum += 5
        }
        else if(input[i][j] === '1'){
            sum += 3
        }
        else{
            sum += 4
        }
    }
    result.push(sum)
}

console.log(result.join('\n'))

각각 이용 시간마다 금액이 출력되는데

영식 요금제는 30초마다 10원, 민식 요금제는 60초마다 15원이 청구된다.

각 요금제의 기준에 맞춰 영식, 민식의 요금을 선언된 값에 더해주는데

1초라도 초과할 경우 다음 시간 기준으로 넘어가기 때문에 Math.ceil을 통해 올림 처리를 진행했다.

if문의 분기에서는 요구사항대로 문자열 및 이용요금을 출력했다.

const input = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n')[1].split(' ').map(Number)
let Y = 0
let M = 0
for(let i = 0 ; i < input.length ; i++){
    Y += Math.ceil((input[i]+1)/30)*10
    M += Math.ceil((input[i]|1)/60)*15
}
if(Y === M){
    console.log('Y','M',Y)
}
else if(Y < M){
    console.log('Y', Y)
}
else{
    console.log('M',M)
}

const input = `2
61 10`.split('\n')[1].split(' ').map(Number)
let Y = 0
let M = 0
for(let i = 0 ; i < input.length ; i++){
    Y += Math.ceil((input[i]+1)/30)*10
    M += Math.ceil((input[i]|1)/60)*15
}
if(Y === M){
    console.log('Y','M',Y)
}
else if(Y < M){
    console.log('Y', Y)
}
else{
    console.log('M',M)
}

일단 입력값의 기준치를 보면 엄청나게 큰 숫자라는 것을 바로 알 수 있다.

큰 숫자는 당연히 number type이 아닌 BigInt를 사용해야 한다는 것만 주의하면 간단하게 해결할 수 있는 문제로

각각의 값들을 입력받은 다음 해당 값들의 합을 음, 양, 0 3가지로 구별하면 되는 문제였다.

다만 비교하거나 더할 때도 숫자에 n을 붙여야 BigInt type과 연산이 된다는 사실을 주의해야 한다.

const input = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n').map(BigInt)

const arrs = []
for(let i = 0 ; i < input.length ; i++){
    arrs.push(input.slice(i+1,i+Number(input[i])+1))
    if(Number(input[i]) > 0){
        i = i+Number(input[i])
    }
}

for(let i = 0 ; i < arrs.length; i++){
    arrs[i] = arrs[i].reduce((a,b) => a+b)
    if(arrs[i] > 0n){
        arrs[i] = '+'
    }
    else if(arrs[i] === 0n){
        arrs[i] = 0
    }
    else if(arrs[i] < 0n){
        arrs[i] = '-'
    }
}

console.log(arrs.join('\n'))

const input = `3
0
0
0
10
1
2
4
8
16
32
64
128
256
-512
6
9223372036854775807
9223372036854775806
9223372036854775805
-9223372036854775807
-9223372036854775806
-9223372036854775804`.split('\n').map(BigInt)

const arrs = []
for(let i = 0 ; i < input.length ; i++){
    console.log(input.slice(i+1,i+Number(input[i])+1))
    arrs.push(input.slice(i+1,i+Number(input[i])+1))
    if(Number(input[i]) > 0){
        i = i+Number(input[i])
    }
}

for(let i = 0 ; i < arrs.length; i++){
    arrs[i] = arrs[i].reduce((a,b) => a+b)
    if(arrs[i] > 0n){
        arrs[i] = '+'
    }
    else if(arrs[i] === 0n){
        arrs[i] = 0
    }
    else if(arrs[i] < 0n){
        arrs[i] = '-'
    }
}

console.log(arrs.join('\n'))

입력값이 x, y, w, h 순서로 주어지고  0,0과 w,h를 꼭지점으로 하는 직사각형이기 때문에

각 꼭지점의 좌표는 (0,0), (w,0), (0,h), (w,h)라고 볼 수 있다.

x,y에서 직사각형과 가장 가까운 길이는 네 가지의 숫자의 최저값을 구하면 되는 문제로

0과 x의 거리, 0과 y의 거리, x와 w의 거리, y와 h의 거리를 구해야 한다.

여기서 문제가 되는 것은 x와 w 중 어느 값이 큰 값인지 모르기 때문에 x - w를 할 경우 음수가 나올 수 있다는 것인데

이런 문제는 Math.abs()를 사용해 절대값으로 바꾸면 자연스럽게 해결할 수 있으며

x와 w의 대소 비교를 삼항연산자를 통해 진행한 결과를 추가하거나

if문으로 비교 후 값 대입 또는 결과값이 음수일 경우 *(-1)을 통해 양수로 바꾸는 등 여러가지 접근이 가능하다.

하지만 Math.min, Math.abs가 있기 때문에 각각의 값을 구한 다음 Math.min에 넣어 최저값을 출력했다.

const [x, y, w, h] = require('fs').readFileSync('/dev/stdin').toString().trim().split(" ").map(Number)

console.log(Math.min(x, y, Math.abs(y-h), Math.abs(x-w)))

const [x, y, w, h] = `653 375 1000 1000`.split(" ").map(Number)

console.log(Math.min(x, y, Math.abs(y-h), Math.abs(x-w)))

베팅을 할 경우 각 옵션에 따른 배당금을 출력해야 하는 문제였다.

다행히 A 또는 B의 두가지 옵션밖에 없기 때문에 각각 받을 수 있는 배당금에 대해 구하면 되는 문제로

입력값은 첫 번째 옵션을 선택한 사람의 비율이다.

비율이 높으면 높을수록 1에 가깝기 때문에 100/비율을 통해 A 옵션의 배당금을 구할 수 있고

B 옵션의 비율은 100 - A 옵션의 비율(입력된 값)이기 때문에  100 / (100 - A옵션)을 통해 B 옵션의 배당금을 구할 수 있다.

각 값을 출력해 문제를 해결할 수 있다.

const input = Number(require('fs').readFileSync('/dev/stdin').toString().trim())
console.log(100/input)
console.log(100/(100-input))

const input = Number(`80`)
console.log(100/input)
console.log(100/(100-input))

이전 문제들에서 언급했던 for문 다중 출력 시간초과 관련 문제인데

줄바꿈으로 분할된 내용을 for문 내부에서 number type으로 바꿔준 다음

구조분해할당으로 a, b값을 나눠주고 합한 결과를 result 배열에 담아 한번에 출력하면 해결할 수 있다.

배열 방식으로 처리하고 싶지 않다면 수동으로 아래와 같이 처리해도 된다.

let result = ''

result += sum + '\n'

const input = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n')

const result = []

for(i = 1 ; i < input.length ; i++){
    const [a, b] = input[i].split(' ').map(Number)
    result.push(a+b)
}

console.log(result.join('\n'))

const input = `5
1 1
12 34
5 500
40 60
1000 1000`.split('\n')

const result = []

for(i = 1 ; i < input.length ; i++){
    const [a, b] = input[i].split(' ').map(Number)
    result.push(a+b)
}

console.log(result.join('\n'))

문제

고려대학교에 입학한 새내기 호돌이는 안암역을 지나다가 한 붕어빵 장수를 만났어요.

“안녕, 안녕, 안녕하십니까, 아저씨! 붕어빵 두 개 주세요.”

“안녕을 세 번 외쳤으니 붕어빵 세 개!”

붕어빵 두 개의 값을 내고 세 개를 받은 호돌이는 기분이 좋았어요. 호돌이가 붕어빵 하나를 꺼내어 한 입 물었는데…. 너무 뜨거워서 그만 붕어빵을 떨어뜨리고 말았어요ㅠㅠ

붕어빵은 자유 낙하운동을 하면서 땅에 떨어졌는데 신기하게도 좌우가 뒤집힌 모양으로 착지했답니다. 호돌이가 붕어빵을 한 입 물기 전의 모양이 입력으로 주어지면, 땅에 떨어졌을 때에는 어떤 모양일지 출력하세요.

예제에서 쓸대없는 행, 열의 길이값을 첫 번째 줄에서 제공하기 때문에

첫 번째 줄의 입력은 무시하고 나머지 줄만 좌우반전을 진행하면 된다.

문자열의 순서를 역으로 바꾸려면 for문을 통해 새로운 문자열에 역순으로 한글자씩 넣어줘도 되지만

가독성 및 코드작성의 편의를 위해 .split('').reverse().join('')을 통해 분할, 역순, 결합을 통해 뒤집어진 문자열로 만들어준다.

범위가 작기 때문에 각각 줄마다 출력해도 되겠지만 

테스트케이스의 범위가 클 경우를 대비해 result에 담아서 출력했다.

const input = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n')
const result = []
for(let i = 1 ; i < input.length ; i++){
    result.push(input[i].split('').map(Number).reverse().join(''))
}

console.log(result.join('\n'))

const input = `5 7
0010000
0111010
1111111
0111010
0010000`.split('\n')
const result = []
for(let i = 1 ; i < input.length ; i++){
    result.push(input[i].split('').map(Number).reverse().join(''))
}

console.log(result.join('\n'))

숫자를 공백없이 제공한다는 부분은 조금 황당하고 조건도 부족해보이지만

자세히 보면 한자리 숫자들이라 공백없이 표기할 수 있다는 사실을 알 수 있고

그렇다면 몇개인지는 굳이 알 필요 없이 두 번째 줄의 길이를 통해 갯수를 파악할 수 있기 때문에

첫 번째 줄은 무시하고 작업할 수 있다.

입력값을 줄바꿈으로 분할한 상태에서 바로 [1]을 통해 두 번째 줄에 접근하고

두 번째 줄의 str을 split(' ')으로 나눈 다음 map(Number)를 통해 숫자로 변경하면

기존 숫자를 더하기만 하면 되는 덧셈수준으로 난이도가 떨어진다.

const input = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n')[1].split('').map(Number)

let sum = 0

for(let i = 0 ; i < input.length ; i++){
    sum += input[i]
}

console.log(sum)

const input = `5
54321`.split('\n')[1].split('').map(Number)

let sum = 0

for(let i = 0 ; i < input.length ; i++){
    sum += input[i]
}

console.log(sum)

알파벳 소문자로 이루어진 문자열에 a~z까지의 알파벳이 각각 몇개씩 들어있는지를 출력하는 문제로

가장 간단한 방식은 객체에 a~z까지를 선언한 다음 해당 문자열의 값에 ++처리를 하는 방식으로

obj[input[i]]++와 같은 느낌으로 할 수 있다.

하지만 초기 설정이 귀찮고 덜 알고리즘스럽기 때문에

배열을 이용해서 문제를 해결하면

맨 앞의 0번째 값은 a, 25번째 값은 z라고 할 수 있고

문자열을 숫자로 변경하는 것은 아스키코드를 사용해서 진행할 수 있다.

각각의 문자열을 아스키코드로 변경항 다음 a가 0이 될 수 있게 -97을 하면 

a는 0, b는 1 ..... z는 25로 index값에 매칭이 된다.

new Array(26).fill(0)으로 길이가 26이고 내부는 0으로 차있는 배열을 생성한 다음

아스키코드로 변경된 index에 접근해 ++처리를 해주고

최종적으로는 join(' ')을 통해 요구하는 형태로 출력할 수 있다.

만약 배열 형태로 처리했다면 for(let key in obj){} 형태로 객체의 각 값을 순차적으로 접근할 수 있다.

주의할 점은 객체는 새로운 키가 추가될 때 마다 키를 정렬해버린다.

하지만 a~z까지의 문자열이기 때문에 이번 문제에서는 걱정할 필요가 없지만

key가 1, 3, 10, 100이 있다면 1, 10, 100, 3으로 정렬되기 때문에

for(let key in obj){}로 접근할 경우 어떤 순서로 키를 추가했다고 하더라도 1, 10 , 100, 3의 순서로 출력되는 것을 볼 수 있다.

const input = require('fs').readFileSync('/dev/stdin').toString().trim()

const alphabet = new Array(26).fill(0)

for(let i = 0 ; i < input.length ; i++){
           alphabet[input[i].charCodeAt() -97]++
}

console.log(alphabet.join(' '))

const input = `baekjoon`

const alphabet = new Array(26).fill(0)

for(let i = 0 ; i < input.length ; i++){
           alphabet[input[i].charCodeAt() -97]++
}

console.log(alphabet.join(' '))

*
**
***
****
*****

별 찍기 문제처럼 별을 찍는 문제지만 여러개의 테스트케이스가 있는 것을 볼 수 있다.

각각의 테스트케이스를 for문을 통해 순회하며 

각각의 내부에서 다시 이중 for문을 통해 문제를 해결할 수 있다.

또는 인쇄를 담당하는 함수를 추가로 생성한 다음 결과값만을 처리하는 방법도 가능하고

테스트케이스의 숫자가 정해져 있지 않은 문제는 출력을 한번에 하는 습관을 들이는 것이 좋다.

또한 예전 코드를 보니 const가 아닌 let으로 처리하는 내용이 많이 보이는데

상수 또는 배열이나 객체를 다룰 때는 const를 사용해 안정성을 유지하는 것이 좋다.

const input = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n').map(Number)

const result = []
for(let i = 0 ; i < input.length-1 ; i++){
    for(let j = 1 ; j <= input[i] ; j++){
        result.push('*'.repeat(j))
    }
}

console.log(result.join('\n'))

const input = `5
3
2
7
0`.split('\n').map(Number)

const result = []
for(let i = 0 ; i < input.length-1 ; i++){
    for(let j = 1 ; j <= input[i] ; j++){
        result.push('*'.repeat(j))
    }
}

console.log(result.join('\n'))

두 숫자와 평균을 기억하고 있던 중 한 숫자를 잃어버렸다는 문제로

두 숫자의 합은 평균*2라는 사실을 알고 있다면 간단히 해결할 수 있다.

평균(S)*2 - R1의 연산을 하면 R2를 구할 수 있기 때문에

S와 R1을 받아오기 위해 입력값을 split, map(Number)로 변환한 다음 구조분해할당으로 값을 받고

S*2 - R1 연산의 결과를 출력했다.

const [r1, s] = require('fs').readFileSync('/dev/stdin').toString().trim().split(" ").map(Number)

console.log(s * 2 - r1)

const [r1, s] = `11 15`.split(" ").map(Number)

console.log(s * 2 - r1)

상근이의 조건인 첫 번째 줄의 밀집도와 넓이를 곱해주면 한 파티에 몇명이 있었는지를 알 수 있다.

두 번째 줄에 입력된 값들에서 곱했던 값을 빼면 각각 정답이 나오고

그 값들을 result에 모아서 join(' ')을 통해 예제와 같은 형태의 출력을 만들 수 있다.

const input = require('fs').readFileSync('/dev/stdin').toString().trim().split('\n')
const [density, dimensions] = input[0].split(' ').map(Number)
const partys = input[1].split(' ').map(Number)
const result = []
for(let el of partys){
  result.push(el - density * dimensions)  
}
console.log(result.join(' '))

const input = `5 20
99 101 1000 0 97`.split('\n')
const [density, dimensions] = input[0].split(' ').map(Number)
const partys = input[1].split(' ').map(Number)
const result = []
for(let el of partys){
  result.push(el - density * dimensions)  
}
console.log(result.join(' '))