[Main-Project 개발일지]-32(주말)

리팩토링을 진행해도 나쁘지는 않겠지만
시연을 하기 위한 모습과는 전혀 상관없는 내부 state 변경 관련 리팩토링이기도 하고
주말에 진행한다면 정규 시간에는 할일이 더 적어서 애매할 것 같기도 하고
그렇다고 정규 시간에 문제를 푸는 등의 행동을 하는 것은 뭔가 아닌 것 같아서
리팩토링은 화요일 남는 시간에 진행하기로 했다.

오늘은 프로그래머스에서 0레벨 문제를 마무리하고
세자릿수의 등수로 진입할 예정이다.

 

 

CT(1).백준 15340 sim card 문제는 여러가지 통신사들의 가격 정책과 학생들의 데이터 및 통화 사용량을 바탕으로 각 학생들이 낼 수 있는 최저 금액들을 출력하는 문제였다.
Math.min을 사용해 해당하는 요금제에 모두 대입하는 방식으로 쉽게 해결할 수 있다.

let input = `10 60
100 20
24 12
900 400
50 50
0 0`.split('\n')

let result = []
for(let i = 0 ; i < input.length-1 ; i++){
    let [a,b] = input[i].split(' ').map(Number)
    result.push(Math.min(a*30 + b*40 , a*35 + b*30 , a*40 + b*20))
}
console.log(result.join('\n'))

CT(2).프로그래머스 치킨 쿠폰 문제는 간단히 -1 /9로 해결할 수 있었는데 첫번째 조건이 해결되지 않았다. 후반 모든 조건이 해결된 것을 보면 초기값의 0 1 9 등의 위치에서 문제가 발생했을 것이라 생각하고 테스트케이스를 넣어보니 0을 넣었을 때 -1이 나오는데
재미있게도 조건에 치킨 0마리 주문이 있었던 것이다.
if문으로 0일 경우 return 0 추가해 해결했다.

if(chicken === 0) return 0
return Math.floor((chicken-1)/9)

CT(3).프로그래머스 직사각형 넓이 구하기는 x,y축의 좌표의 차이를 통해 구했다.

function solution(dots) {
    let x = []
    let y = []
    for(let i = 0 ; i < 4 ; i++){
        let [a,b] = dots[i]
        x.push(a)
        y.push(b)
    }
    
    return (Math.max(...x) - Math.min(...x))*(Math.max(...y) - Math.min(...y))
}

CT(4).프로그래머스 OX퀴즈는 게산식은 eval을 통해 처리하고 결과 비교를 통해 O 또는 X를 추가해 출력했다.

function solution(quiz) {
    let answer = [];
    for(let i = 0 ; i < quiz.length ; i++){
        let [a,b] = quiz[i].split(' = ')
        if(eval(a) === Number(b)){
            answer.push("O")
        }
        else{
            answer.push("X")
        }
    }
    return answer;
}

CT(5).프로그래머스 캐릭터의 좌표는 x,y축이 일반적 행렬과 달라서 잠깐 당황했고 크기가 중앙의 점을 포함해서 진행된다는 부분에서 두번 당황했지만 Math.floor(size/2)를 통해 최대치를 제한해 간단하게 해결할 수 있었다.(그 전엔 floor없는 size 제한이었다.)

function solution(keyinput, board) {
    let x = 0
    let y = 0
    for(let i = 0 ; i < keyinput.length ; i++){
        if(keyinput[i] === "left"){
            x = Math.max(-Math.floor(board[0]/2),x-1)
        } 
        else if(keyinput[i] === "right"){
            x = Math.min(Math.floor(board[0]/2),x+1)
        } 
        else if(keyinput[i] === "down"){
            y = Math.max(-Math.floor(board[1]/2),y-1)
        } 
        else if(keyinput[i] === "up"){
            y = Math.min(Math.floor(board[1]/2),y+1)
        }  
    }
    return [x,y]
}

CT(6).프로그래머스 연속된 수의 합은 중앙점을 기준으로 num의 절반만큼 좌측이동한 후 num개의 숫자가 될 때 까지 for문을 돌리는 방향으로 진행했다.

function solution(num, total) {
    let result = []
    if(total%num){
        for(let i = Math.ceil(total/num) - num/2 ;  i < Math.ceil(total/num) - num/2 + num ; i++){
            result.push(i)
        }
    }
    else{
        for(let i = total/num - Math.floor(num/2) ; i < total/num - Math.floor(num/2) + num ; i++){
            result.push(i)
        }
    }
    return result
}

CT(7).프로그래머스 분수의 덧셈은 신기하게 최대공약수가 필요한 문제였다.
물론 이미 1단계쯤과 2단계 몇분제에서 하위계산을 위해 자주 사용했기 때문에 간단하게 사용할 수는 있었지만 정답률이 낮은 이유는 알 수 있었다.

function solution(denum1, num1, denum2, num2) {
    let a = denum1 * num2  + denum2 * num1
    let b = num1*num2
    
    let before = Math.max(a,b)
    let now = Math.min(a,b)
    
    while( now > 0){
        let xxxx = before
        before = now
        now = xxxx % now
            
    }
    return [a/before,b/before]
}

CT(8).프로그래머스 안전지대는 js만 그런건지는 모르겠지만 예외처리가 조금은 귀찮았던 문제였다. undefined의 index 조회요청시 에러가 나기 때문에 arr[-1][1]등의 요청이 가거나 범위 밖의 요청(arr[10000][1] 등)을 할 경우 터져버리기 때문에 예외처리가 필요했다.

function solution(board) {
    let answer = board[0].length ** 2
    for(let i = 0 ; i < board.length ; i++){
        for(let j = 0 ; j < board[0].length ; j++){
            if(board[i][j]){
                answer--
            }
            else if(board[i-1] !== undefined && board[i-1][j] === 1){
                answer--
            }
            else if(board[i+1] !== undefined && board[i+1][j] === 1){
                answer--
            }
            else if(board[i][j-1] !== undefined && board[i][j-1] === 1){
                answer--
            }
            else if(board[i][j+1] !== undefined && board[i][j+1] === 1){
                answer--
            }
            else if(board[i-1] !== undefined && board[i-1][j-1] === 1){
                answer--
            }
            else if(board[i+1] !== undefined && board[i+1][j-1] === 1){
                answer--
            }
            else if(board[i-1] !== undefined && board[i-1][j+1] === 1){
                answer--
            }
            else if(board[i+1] !== undefined && board[i+1][j+1] === 1){
                answer--
            }
        }
    }
    return answer
}

 

 

CT(9).프로그래머스 다항식 더하기는 은근히 조건이 많아서 까다로웠다.
문제의 난이도가 높다기보다는 x의 계수가 1인 경우 x만 적어야 하는 부분과 숫자나 x가 없는 경우는 제외해야 하기 때문에 if를 따로 걸어야 한다는 부분이 그렇다.
난이도는 1단계 보통 또는 그 이하 수준이었지만 0단계에서 함정이 많아서 그런지 8점이나 주는 문제였다.

function solution(polynomial) {
    let arr = polynomial.split(' + ')
    let x = 0
    let num = 0
    for(let i = 0 ; i < arr.length ; i++){
        if( arr[i][0] === 'x'){
            x += 1
        }
        else if(arr[i].slice(-1) === 'x'){
            x += Number(arr[i].slice(0,arr[i].length-1))
        }
        else{
            num += Number(arr[i])
        }
    }
    if(x === 1 && num === 0){
        return `x`
    }
    if(x === 1){
        return `x + ${num}`
    }
    if(num === 0){
        return `${x}x`
    }
    if(x === 0){
        return `${num}`
    }
    return `${x}x + ${num}`
}

CT(10).프로그래머스 겹치는 선분의 길이는 사악하다면 사악하고 귀엽다면 귀여운 함정이 숨겨져 있는 겹친 포인트의 길이를 구하는 문제였다.
a->b로 출발하기 때문에 시작점의 좌표만 기록해도 중복여부는 판단할 수 있지만 자꾸 오류가 나서 중점으로 잡아보기도 하고 obj로 관리도 해봤지만 오류가 났다.
테스트케이스들을 추가해도 문제가 나서 곰곰히 생각해보니
입력겂의 조건이 -100<a,b<100이었다.
주의해서 보자 -100<a<b<100이 아니다.. b가 크다는 보장이 없기 때문에 a,b중 큰 값을 찾아줘야 했다. 확실히 정답률이 낮은 문제는 작은 함정들이 있는 것 같다.

function solution(lines) {
    let obj = {}
    let answer = 0
    for(let i = 0 ; i < lines.length ; i++){
        let a = Math.min(...lines[i])
        let b = Math.max(...lines[i])
        for(let i = a ; i < b ; i++){
            if(obj[i]){
                obj[i]++
            }
            else{
                obj[i] = 1
            }
        }
    }
    for(let key in obj){
        if(obj[key] > 1){
            answer++
        }
    }
    
    return answer
}

CT(11).프로그래머스 평행은 네개의 점을 가지고 만들 수 있는 두개의 선이 평행인지를 묻는 문제였다. 간단하게 조합할 경우 3가지의 경우밖에 나오지 않기 때문에 3가지를 for문으로 체크했으나 100개중 두번째로 낮은 정답률을 가진 문제답게 바로 통과되지 않았다.
[[0, 1], [0, 2], [17, 1], [17, 10]]로 앞이 0인 경우를 체크했으나 내가 제시한 조건은 뒷 숫자가 분모가 되기 때문에 앞의 공통됨으로 오류가 나지 않았다.
[[1, 0], [2, 0], [180, 5], [17, 5]]로 추가해서 테스트해보니 오류가 난 것을 볼 수 있었고 1/0 === 163/0이 되어 체크가 되지 않았던 것이다.
체크를 할 때 a || b방식으로 분모와 분자를 바꿔 체크하니 잘 제출되었다.

function solution(dots) {
    let arr = [[0,1,2,3],[0,2,1,3],[0,3,1,2]]
    for(let i = 0 ; i < 3 ; i++){
        let [a,b,c,d] = arr[i]
        if((dots[a][0]-dots[b][0])/(dots[a][1]-dots[b][1]) === (dots[c][0]-dots[d][0])/(dots[c][1]-dots[d][1]) || (dots[a][1]-dots[b][1])/(dots[a][0]-dots[b][0]) === (dots[c][1]-dots[d][1])/(dots[c][0]-dots[d][0])){
           return 1
        }
    }
    return 0
}

CT(12).프로그래머스 숫자 짝꿍은 0,1레벨 격파 사진을 찍으려고 보니 추가되어있는 1레벨 문제였다. 각 숫자의 공통된 부분을 찾아준 다음 정렬을 통해 최댓값이 0인 경우 '0'을 리턴하고 공통숫자의 배열의 길이가 0이면 '-1'을 리턴하고 나머지의 경우 내림차순 정렬을 join처리했다.

function solution(X, Y) {
    let arr = []
    let arrX = new Array(10).fill(0)
    let arrY = new Array(10).fill(0)
    for(let i = 0 ; i < X.length ; i++){
        arrX[Number(X[i])]++
    }
    for(let i = 0 ; i < Y.length ; i++){
        arrY[Number(Y[i])]++
    }
    for(let i = 0 ; i < 10 ; i++){
        for(let j = 0 ; j < Math.min(arrX[i],arrY[i]) ; j++){
            arr.push(i)
        }
    }
    arr.sort((a,b) => b-a).join('')
    if(arr.length === 0){
        return "-1"
    }
    if(arr[0] === 0){
        return "0"
    }
    return arr.join('')
}