Happy Programmer

별 찍기 - 9는 8을 90도 회전한 느낌으로 모래시계 형태의 별을 찍어야 했다.

별의 갯수가 input*2 -1개로 시작해서 1개까지 점차 줄어든 다음 

다시 시작한 갯수만큼 늘어나야 했기 때문에 공백은 앞에 하나씩 추가하며 별의 갯수는 2개씩 줄여 1개로 만들고

그 뒤로는 다시 역순으로 진행했으며 중간의 별 한칸이 중요했기 때문에 시작점을 input이 아닌 input -1로 지정했다.

이 문제 또한 다른 별 찍기 문제들처럼 템플릿 리터럴(`${}`)과 repeat을 사용해 해결할 수 있는 문제였다. 

const input = Number(require('fs').readFileSync('/dev/stdin').toString().trim())
const result = []

for(let i = 1 ; i <= input ; i++){
    result.push(`${' '.repeat(i-1)}${'*'.repeat(input*2+1-i*2)}`)
}
for(let i = input-1 ; i >= 1 ; i--){
    result.push(`${' '.repeat(i-1)}${'*'.repeat(input*2+1-i*2)}`)
}

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

const input = 10
const result = []

for(let i = 1 ; i <= input ; i++){
    result.push(`${' '.repeat(i-1)}${'*'.repeat(input*2+1-i*2)}`)
}
for(let i = input-1 ; i >= 1 ; i--){
    result.push(`${' '.repeat(i-1)}${'*'.repeat(input*2+1-i*2)}`)
}

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

별 찍기 - 8은 나비모양과 유사한 형태로 별을 찍어야 하는 문제였는데

별 사이에 공백이 (input-i) * 2, 별들은 각각 input개가 앞 뒤에 존재하는 규칙이었다.

다만 input까지의 줄을 입력한 다음에는 다시 위에서 진행한 내용의 역순으로 내려가기 때문에

for문을 통해 역순으로 진행했다.

일반적으로는 .repeat()을 사용해 반복을 진행해야 하지만

아래는 .repeat을 사용하지 못할 때 사용했던 원시적인 해결방법이다.

(그 아래에 제출했던 코드와 console로 찍을 수 있는 코드가 존재한다)

//예전의 특이한 코드인데 지나치게 특이해서 올려봤다
let input = 5
let result = ''
function star(num) {
    let result = ''
    for(let i = 0 ; i < num ; i++){
        result += '*'
    }
    return result
}

function blank(num) {
    let result = ''
    for(let i = 0 ; i < num ; i++){
        result += `  `
    }
    return result    
}
for(let i = 1 ; i <= input ; i++){
    result +=`${star(i)}${blank(input-i)}${star(i)}\n`
}
for(let i = input-1 ; i >= 1 ; i--){
    result +=`${star(i)}${blank(input-i)}${star(i)}\n`
}

console.log(result)

const input = Number(require('fs').readFileSync('/dev/stdin').toString().trim())
const result = []

for(let i = 1 ; i <= input ; i++){
    result.push(`${'*'.repeat(i)}${'  '.repeat(input-i)}${'*'.repeat(i)}`)
}
for(let i = input-1 ; i >= 1 ; i--){
    result.push(`${'*'.repeat(i)}${'  '.repeat(input-i)}${'*'.repeat(i)}`)
}

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

const input = 10
const result = []

for(let i = 1 ; i <= input ; i++){
    result.push(`${'*'.repeat(i)}${'  '.repeat(input-i)}${'*'.repeat(i)}`)
}
for(let i = input-1 ; i >= 1 ; i--){
    result.push(`${'*'.repeat(i)}${'  '.repeat(input-i)}${'*'.repeat(i)}`)
}

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

별을 다이아몬드 모양으로 찍어야 하는 문제로 

input번째 줄 까지는 피라미드 형식으로 진행되고

그 이후로는 다시 역 피라미드 형식으로 별을 줄여나가는 모양이었다.

일단 입력을 지금 보니 공백을 input - i개로 진행한 다음 별의 갯수는 i*2-1로 했어도 될 것 같은데

당시 푼 문제에서는 '**'에 '*'을 추가한 모습이 재미있다.

이전 코드는 얼핏 보기에는 문제가 없었도 const 대신 let이 있는 부분만 수정했었는데

i*2 -1개로 수정하지 않은 부분은 아쉽지만 두 가지 방법을 보며

문제에 따라 저렇게 할 수는 있겠다는 여지를 남기기 위해 그대로 올렸다.

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

const result = []
for(let i = 1 ; i <= input ; i++){
    result.push(`${' '.repeat(input-i)}${'**'.repeat(i-1)}*`)
}
for(let i = input-1 ; i > 0 ; i--){
    result.push(`${' '.repeat(input-i)}${'**'.repeat(i-1)}*`)
}
console.log(result.join('\n'))

const input = 10

const result = []
for(let i = 1 ; i <= input ; i++){
    result.push(`${' '.repeat(input-i)}${'**'.repeat(i-1)}*`)
}
for(let i = input-1 ; i > 0 ; i--){
    result.push(`${' '.repeat(input-i)}${'**'.repeat(i-1)}*`)
}
console.log(result.join('\n'))

별 찍기 - 5와 유사한 문제지만 앞 뒤 순서만 다른 문제였다.

이 문제 또한 input *2 -1개의 별로 시작해서

앞에 공백의 갯수를 1씩 증가시키며 추가하는 문제였다.

i를 0으로 시작해서 공백에 i를 넣어주고

*의 갯수에는 (input-i)*2 -1로 진행해도 괜찮겠지만

기존에 별 찍기 - 5에서 진행한 코드를 역방향으로 뒤집는 진행 또한 가능하다.

const input = Number(require('fs').readFileSync('/dev/stdin').toString().trim())
const result = []
for(let i = input ; i > 0 ; i--){
    result.push(`${' '.repeat(input-i)}${'*'.repeat(i*2 -1)}`)
}
console.log(result.join('\n'))

const input = Number('5')
const result = []
for(let i = input ; i > 0 ; i--){
    result.push(`${' '.repeat(input-i)}${'*'.repeat(i*2 -1)}`)
}
console.log(result.join('\n'))

트리 형태를 만들어야 하는 문제로

별의 갯수는 1개부터 (input * 2) - 1 만큼의 갯수까지 2개씩 늘어나는 규칙이 있고

공백의 갯수는 input - 1부터 0개까지 진행되기 때문에

for문에서 i의 시작은 1, 조건은 input보다 작거나 같다로 진행했다.

const input = Number(require('fs').readFileSync('/dev/stdin').toString().trim())
const result = []
for(let i = 1 ; i <= input ; i++){
    result.push(`${' '.repeat(input-i)}${'*'.repeat(i*2 -1)}`)
}
console.log(result.join('\n'))

const input = Number('5')
const result = []
for(let i = 1 ; i <= input ; i++){
    result.push(`${' '.repeat(input-i)}${'*'.repeat(i*2 -1)}`)
}
console.log(result.join('\n'))

별을 input의 갯수만큼 시작해서 하나씩 줄여나가며

해당 위치에는 공백을 추가해야 하는 문제로 

각각의 갯수는 .repeat() 메서드를 사용해 처리했으며

공통적으로 공백과 별의 갯수의 합이 input만큼이기 때문에

input으로 시작한 i의 갯수만큼의 별과 input - i만큼의 공백을 주어진 조건에 맞게 출력했다.

제한 조건이 N < 100이기 때문에 딱히 result 배열에 담아서 한번에 출력할 필요는 없지만

일관된 코드 작성이 가독성 면에서 유리하기 때문에 result에 담아서 출력했다.

const input = Number(require('fs').readFileSync('/dev/stdin').toString().trim())
const result = []
for(let i = input ; i > 0 ; i--){
    result.push(`${' '.repeat(input-i)}${'*'.repeat(i)}`)
}
console.log(result.join('\n'))

const input = Number('5')
const result = []
for(let i = input ; i > 0 ; i--){
    result.push(`${' '.repeat(input-i)}${'*'.repeat(i)}`)
}
console.log(result.join('\n'))

멀티탭을 추가하기 위해서는 기존에 있던 콘센트에 끼워야 하기 때문에

총 여유공간에서 1을 차감한 다음 멀티탭의 플러그 수용치를 추가해야 한다.

첫 번째 줄에서는 테스트케이스가 주어지기 때문에 

i의 시작을 1부터 진행했고 그 외 특이사항은 존재하지 않는다.

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

let sum = 1
for(let i = 1 ; i < input.length ; i++){
    sum = sum - 1 + input[i]
}
console.log(sum)

const input = `3
1
1
1`.split('\n').map(Number)

let sum = 1
for(let i = 1 ; i < input.length ; i++){
    sum = sum - 1 + input[i]
}
console.log(sum)

암호의 수준을 판별하는 문제로

앞의 P는 크게 상관할 필요는 없지만 연산을 위해 BigInt로 값을 다뤄야 한다는 부분을 주의해야 하며

K가 100만까지의 숫자기 때문에 결론적으로 K까지의 소수들을 구한 다음

P가 K 이하의 소수 중 하나로 나눠질 경우 BAD와 그 숫자를 출력하고

아닐 경우 GOOD을 출력하는 문제였다.

소수 여부를 확인하기 위해서는 소수체크 함수로 모두 체크해도 되겠지만

2부터 k까지의 모든 숫자를 확인해야 하는 문제기 때문에

에라토스테네스의 체를 사용하는 것이 유리하다고 판단했다.

소수 판별 배열의 초기값을 1로 만든 다음

해당 숫자의 배수들을 0으로 바꿔주며

소수일 경우 입력된 암호가 그 소수로 나눠지는지 체크해

나눠질 경우 BAD와 그 소수를 출력하는 방식으로 진행했다.

BigInt를 중간중간 사용하면서 type Error가 생기지 않도록 주의하고

에라토스테네스의 사용법만 알면 부담없이 해결할 수 있는 문제였다.

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

let num = BigInt(input[0])
let k = Number(input[1])

const arr = new Array(k).fill(1)
let result = "GOOD"

for(let i = 2 ; i <= k ; i ++){
    let bigI = BigInt(i)
    if(arr[i]){
        if(num%bigI === 0n){
            result = `BAD ${i}`
            break
        }
        let n = 2
        while(i*n <= k){
            arr[i*n] = 0
            n++
        }
    }
}

console.log(result)

const input = `143 10`.split(' ')

let num = BigInt(input[0])
let k = Number(input[1])

const arr = new Array(k).fill(1)
let result = "GOOD"

for(let i = 2 ; i <= k ; i ++){
    let bigI = BigInt(i)
    if(arr[i]){
        if(num%bigI === 0n){
            result = `BAD ${i}`
            break
        }
        let n = 2
        while(i*n <= k){
            arr[i*n] = 0
            n++
        }
    }
}

console.log(result)

문제

branchorama 나무는 특이한 규칙을 가지고 성장합니다. 어린 branchorama 초목은 하나의 잎을 꼭대기에 가진 가는 묘목이며, 그 잎에는 생장점이 있습니다. 성장하는 계절 동안 나무의 생장점들은 여러 개의 가지로 나뉘게 되며, 성장이 끝나면 각 가지는 생장점을 가진 하나의 잎을 꼭대기에 매달게 됩니다. 놀랍게도 같은 나무의 모든 생장점들은 같은 숫자(splitting factor)의 가지로 나뉘며, 그 숫자는 해가 지남에 따라 변합니다.

아래의 예는 Brown 씨의 과수원에서 한 branchorama 나무가 유목에서부터 3년간 자란 결과를 보여줍니다.

예시에서 예측할 수 있듯이, branchorama 나무는 과밀하게 성장하는 경향이 있습니다. 따라서 Brown 씨는 매 겨울마다 과도하게 성장한 나무들의 가지를 쳐냅니다. 아래는 가지를 쳐낸  branchorama 나무의 예입니다

branchorama 나뭇잎은 굉장히 크고 광합성에 유리하지만, 오직 생장점이 온전히 보존된 가지의 끝에만 달립니다. 따라서 나무가 버티지 못할 정도로 가지를 쳐내는 일은 없어야 합니다.

Brown 씨는 각 나무가 몇 개의 잎을 가졌는지 알고 싶어합니다. 나뭇잎을 일일이 세는 것은 지루하기 때문에, 각 해(level) 성장기의 splitting factor와 그 해 겨울에 쳐낸 가지의 수를 이용해 Brown 씨에게 나뭇잎의 수를 알려주세요.

생장점은 분할, 가지치기를 반복했을 때 최종적으로 남은 가지의 숫자를 구하는 문제다.

잎의 수를 출력하라고 하지만 가지치기를 당하지 않은 나무만 추가로 확장되며

가지치기를 하지 않은 나무만 최종상태에서 잎이 달린다고 하기 때문에

결론적으로는 가지의 숫자를 구하는 것이 맞다.

출력 조건은 다행히 적당한 범위 안에 있다고 하는 것 같기 때문에 BigInt를 사용하지는 않아도 되는 문제로

각각의 케이스를 받아온 다음 

년수가 지날 때 마다 초기값 1로 세팅된 가지의 숫자에 분할될 숫자를 곱해준 다음

가지치기할 숫자를 빼고 다음 년도로 넘어간다.

최종적으로 년도가 끝난 다음 result에 결과를 담아주고 모든 케이스가 끝난 경우 출력해서 해결했다.

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

const result = []

for(let i = 0 ; i < input.length-1 ; i++){
    const eachCase = input[i].split(' ').map(Number)
    let leafNumb = 1
    for(let j = 1 ; j < eachCase.length ; j += 2){
        leafNumb *= eachCase[j]
        leafNumb -= eachCase[j+1]
    }
    result.push(leafNumb)
}

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

const input = `1 3 0
2 3 0 2 0
3 3 0 2 0 2 0
3 3 0 2 1 2 3
2 4 1 3 4
4 5 0 5 1 5 2 5 101
0`.split('\n')

const result = []

for(let i = 0 ; i < input.length-1 ; i++){
    const eachCase = input[i].split(' ').map(Number)
    let leafNumb = 1
    for(let j = 1 ; j < eachCase.length ; j += 2){
        leafNumb *= eachCase[j]
        leafNumb -= eachCase[j+1]
    }
    result.push(leafNumb)
}

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

문제

동물원에서 막 탈출한 원숭이 한 마리가 세상구경을 하고 있다. 그 녀석은 원주 부근을 돌아다니다가 코레스코 콘도에서 아주 재밌는 놀이를 발견했다. 그 놀이의 이름은 바로 “꼬리를 무는 숫자 나열”. 이제부터 원숭이가 그토록 좋아하던 그 놀이를 파헤쳐보자.

놀이의 방법은 간단하다. 일단 4줄짜리 표에 왼쪽부터 수를 아래로 1부터 순서대로 적어나간다. 다음에 그 예가 잘 나타나있다.

이제 원숭이는 두 개의 자연수를 아무거나 생각한다. 그리고 숫자판에서 두 개의 자연수 사이의 직각거리를 구하면 된다. 여기서 직각거리는 동서방향거리와 남북방향거리의 합을 뜻한다.

예를 들어 저 숫자판에서 11과 33을 생각했다고 하자. 그렇다면 11과 33사이의 직각거리는 8이 된다.(동서방향거리 : 6, 남북방향거리 : 2) 다음 그림에 잘 나타나있다.

하지만 원숭이는 지금 혼란스럽다. 동물원에서 탈출한지 얼마 되지 않아서 계산을 할 수 없는 경지에 이르렀다. 여러분이 불쌍한 원숭이를 좀 도와줘야겠다. 원숭이가 생각한 두 자연수 사이의 직각거리를 구하는 프로그램을 작성하시오.

간단하게 풀어서 말하자면 각각의 x,y축 좌표값을 구해준 다음

그 좌표값의 차이를 구하면 되는 문제다.

a의 위치와 b의 위치의 차이를 구할 때

일반적으로는 a가 작고 b가 크다고 생각해서 앞의 계산에서는 Math.abs를 빼먹을 수 있는데

(실제로 예전 코드를 보니 빼먹고 제출했는데 통과되어있다..  테스트케이스를 대충 짠 느낌이다)

a보다 b가 크다는 보장이 없기 때문에 Math.abs()로 감싸줘야 한다.

이를 방지하기 위해서는 Math.max(a,b), Math.min(a,b)를 통해 max, min으로 좌표값을 수정할 수 있지만

오히려 그게 더 번거로울 수 있다.

결론적으로 좌표값은 5의 경우 (0,1)이 되고 8의 경우 (3,2)가 되는 등

x축의 좌표는 (x-1)/4의 몫, y축의 좌표는 (x-1)%4인 나머지 값임을 알 수 있고

a, b의 x축, y축 값들의 차이를 Math.abs로 처리해 해결했다.

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

console.log(Math.abs(Math.floor((b-1)/4)-Math.floor((a-1)/4))+Math.abs((b-1)%4-(a-1)%4) )

const [a,b] = `11 33`.split(' ').map(Number)

console.log(Math.abs(Math.floor((b-1)/4)-Math.floor((a-1)/4))+Math.abs((b-1)%4-(a-1)%4) )

현재 위치를 now라는 변수에 저장해준 다음

now라는 변수에 할당된 값이 옮겨진 공의 위치(여기서는 a, b라고 칭한다)에 포함되어 있을 경우

a가 now일 경우 now에는 b를 할당하고 b가 now일 경우 now에 a를 할당하는 방식으로

공의 위치가 교환되었음을 나타낼 수 있다.

모든 처리가 끝난 후 now를 출력해 문제를 해결할 수 있다.

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

let now = '1'

for(let i = 1 ; i < input.length ; i++){
    const [a,b] = input[i].split(' ')
    if(a === now){
        now = b
    }
    else if(b === now){
        now = a
    }
}
console.log(now)

const input = `5
2 3
1 3
2 3
2 1
3 1`.split('\n')

let now = '1'

for(let i = 1 ; i < input.length ; i++){
    const [a,b] = input[i].split(' ')
    if(a === now){
        now = b
    }
    else if(b === now){
        now = a
    }
}
console.log(now)

숫자 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'))