[Main-Project 개발일지]-26(개천절)

오늘도 사실 리액트를 하려고 했는데 프로그래머스 0점짜리 100문제가 풀려있었다.
코딩자격증 관련해서 나온 문제인 것 같은데 다 풀기 전까지 리액트는 없다.

CT(1).백준 16400 소수화폐 문제는 동전으로 거스름돈 걸러주기 문제와 유사하지만 동전이 소수라는 점과 최대 4만 아래의 소수까지의 모든 동전을 다 구해야 하는 점이 차이점이다.
소수판별함수로 4만아래의 모든 소수를 구한 다음 소수가 input보다 커지는 시점에서 중단하는 방식으로 진행했다.

let input = 40000 // 특정 금액
let prime = [] //소수 넣을 배열
for(let i = 2 ; i < 40000 ; i++){ //2~4만이 제한이라 간단하게 4만아래로 했지만
    if(isPrime(i)){               //지금 보니 input보다 작거나 같다로 하고
        prime.push(i)             //하단 동전계산식을 일반적으로 해도 됐을 것 같다.
    }
}

function isPrime(num) { //소수판별함수(유용)
  let sqrt = parseInt(Math.sqrt(num));

  if (num === 1) {
    return false;
  }

  if (num === 2) {
    return true;
  }

  if (num % 2 === 0) {
    return false;
  }

  for (let i = 3; i <= sqrt; i += 2) {
    if (num % i === 0) {
      return false;
    }
  }

  return true;
}
let dp = new Array(input+1).fill(0) //dp선언
dp[0] = 1
for(let i = 0 ; prime[i] <= input ; i++){ //위에서 언급했듯 범위를 prime.length미만으로 헀어도 됐다(prime에 input보다 작거나 같게 넣어줬다면
    for(let j = 1 ; j <= input ; j++){ //보통의 동전문제 해결방식
        if(j >= prime[i]){
            dp[j] = (dp[j] + dp[j-prime[i]])%123456789
        }
    }
}
console.log(dp[input])

CT(2).프로그래머스 나머지 구하기는 a%b로 풀었다.


CT(3).프로그래머스 두 수의 곱은 a*b로 해결했다.


CT(4).프로그래머스 두 수의 차는 a-b로 해결했다.


CT(5).프로그래머스 숫자 비교하기는 (num1 === num2 ? 1 : -1)로 제출했다.


CT(6).프로그래머스 두 수의 합은 a+b로 제출했다.


CT(7).프로그래머스 몫 구하기는 Math.floor(num1/num2)로 처리했다.


CT(8).프로그래머스 배열의 평균값은 모두 더한 후 길이로 나눠줬다.

function solution(numbers) {
    let answer = 0;
    for(let el of numbers){
        answer += el
    }
    return answer/numbers.length;
}

CT(9).프로그래머스 나이 출력은 2023-age로 해결했다.


CT(10).프로그래머스 두 수의 나눗셈은 정수반환이므로 floor를 사용했다.
Math.floor(num1/num2*1000)

CT(11).프로그래머스 머쓱이보다 키 큰 사람은 height와 배열을 for문으로 비교해 처리했다.

function solution(array, height) {
    let answer = 0;
    for(let el of array){
        if(el > height){
            answer++
        }
    }
    return answer;
}

CT(12).프로그래머스 짝수의 합은 짝수만 더하도록 for문으로 계산했다.

function solution(n) {
    let answer = 0;
    for(let i = 2 ; i <= n ; i+=2){
        answer += i
    }
    return answer;
}

 

CT(13).프로그래머스 세균 증식은 시간의 변화에 따른 마릿수를 구하는 문제로 n*(2**t)로 해결했다.

 

CT(14).프로그래머스 각도기는 각에 따라 1,2,3,4가 출력되게 하는 문제였다. 단순하게 if문 3개를 사용해 해결했다.

function solution(angle) {
    if(angle < 90)return 1
    if(angle === 90)return 2
    if(angle < 180) return 3
    return 4
}

CT(15).프로그래머스 배열 자르기는 slice를 이용했다. 

numbers.slice(num1,num2+1)


CT(16).프로그래머스 배열 두 배 만들기는 map을 사용했다. 

numbers.map(el => el*2)


CT(17).프로그래머스 짝수는 싫어요는 n 이하의 홀수만 담는 문제로 짝수만 담는 문제와 비슷했다.

function solution(n) {
    let answer = [];
    for(let i = 1 ; i <= n ; i+=2){
        answer.push(i)
    }
    return answer;
}

CT(18).프로그래머스 최댓값 만들기는 양수라는 조건이 있었기 때문에 numbers.sort((a,b) => b-a)[0]*numbers.sort((a,b) => b-1)[1]를 통해 해결했다.


CT(19).프로그래머스 옷가게 할인받기는 마지막에 소숫점 버리기를 확인하지 못해 마지막 하나 정확도가 틀려버렸다. js의 처리 오류라고 생각하고 /100*95처럼 100원단위를 처리한다고 생각했는데 금액이 10원이나 1원단위도 있을 수 있다는 부분을 고려하지 못했다.

function solution(price) {
    if(price < 100000) return price
    if(price < 300000) return Math.floor(price*0.95)
    if(price < 500000) return Math.floor(price*0.9)
    return Math.floor(price*0.8);
}

CT(20).프로그래머스 중복된 숫자 개수는 array.filter(el => el===n).length로 해결했다.


CT(21).프로그래머스 중앙값 구하기는 정렬, 중앙위치(/2)로 해결했다.
array.sort((a,b)=>a-b)[Math.floor(array.length/2)]


CT(22).프로그래머스 모음 제거 문제는 모음 문자열을 만든 다음 includes를 사용해 포함여부를 체크했다.

function solution(my_string) {
    let answer = '';
    let str = 'aeiou'
    for(let i = 0 ; i < my_string.length ; i++){
        if(!str.includes(my_string[i])) answer += my_string[i]
    }
    return answer;
}

CT(23).프로그래머스 배열의 유사도는 oncludes를 사용해 첫번째 배열 하나씩 두번째 배열에 포함되었는지를 비교하는 방식으로 해결했다.

function solution(s1, s2) {
    let answer = 0;
    for(let i = 0 ; i < s1.length ; i++){
        if(s2.includes(s1[i])) answer++
    }
    return answer;
}

CT(24).프로그래머스 양꼬치는 혹시 모를 서비스보다 적게 마시는 경우까지 체크했는데 0단계라 그럴 필요가 있었는지는 조금 의문이 든다.

function solution(n, k) {
    let num = Math.floor(n/10)
    if(num > k){
        return n*12000
    }
    else{
        return n*12000 +(k-num)*2000
    }
}

CT(25).프로그래머스 피자 나눠 먹기(1)은 올림을 통해 풀 수 있는 문제였다 

Math.ceil(n/7)


CT(26).프로그래머스 문자열 뒤집기는 비슷한 문제가 1단게에 있었던 것 같은데 reverse를 사용해 해결했다. 

my_string.split('').reverse().join('')


CT(27).프로그래머스 편지는 글자 길이가 2라고 가정한 문제로 message.length*2로 해결했다.


CT(28).프로그래머스 제곱수 판별하기는 (Math.floor(Math.sqrt(n)) === Math.sqrt(n) ? 1 : 2)를 통해 해결했다.


CT(29).프로그래머스 배열 원소의 길이는 strlist.map(el => el.length)로 해결했다.


CT(30).프로그래머스 자릿수 더하기 문제는 숫자를 문자열로 한 다음 split으로 한글자씩 나누고 다시 숫자로 만든 다음 reduce로 합쳤다.
String(n).split('').map(Number).reduce((a,b) => a+b);


CT(31).프로그래머스 문자열안에 문자열은 includes를 사용해서 해결했다.
(str1.includes(str2) ? 1 : 2)


CT(32).프로그래머스 약수 구하기는 약수의 오름차순으로 보내는 문제였다. for문으로 %를 돌려 해당할 경우 push해줬다. 순차적으로 계산하기 때문에 자동적으로 오름차순이다.

function solution(n) {
    let answer = [];
    for(let i = 1 ; i <= n ; i++){
        if(n%i === 0){
            answer.push(i)
        }
    }
    return answer;
}

CT(33).프로그래머스 특정 문자 제거하기는 slice, join으로 해결했다.
my_string.split(letter).join('')


CT(34).프로그래머스 n의 배수 고르기는 filter로 해결했다.
numlist.filter(el => el%n === 0)


CT(35).프로그래머스 문자열 정렬하기 (1)은 숫자만 걸러온 다음 오름차순으로 정리하는 문제로 filter, sort로 해결했다.
my_string.split('').filter(el => num.includes(el)).map(Number).sort((a,b) => a-b)


CT(36).프로그래머스 점의 위치 구하기는 구조분해할당으로 a,b를 나눈 다음 좌표값을 구해 if문으로 분기한 다음 return 했다.

function solution(dot) {
    let [a,b] = dot
    if(a > 0 && b > 0) return 1
    if(a > 0 && b < 0) return 4
    if(a < 0 && b > 0) return 2
    if(a < 0 && b < 0) return 3
}

CT(37).프로그래머스 문자 반복 출력하기는 for문 내부에서 repeat을 사용할 수 있었지만 한줄로 풀기 위해 split한 다음 map으로 길이를 늘리고 join했다.
my_string.split('').map(el => el.repeat(n)).join('')

 

CT(38).프로그래머스 아이스 아메리카노는 5500원인 아메리카노를 몇잔 마실 수 있는지 출력하는 문제였다. 나누기 및 나머지를 통해 해결했다.
[Math.floor(money/5500), money-Math.floor(money/5500)*5500]

 

CT(39).프로그래머스 중복된 문자 제거는 Set을 통해 중복을 제거했다.
[...new Set(my_string.split(''))].join('')


CT(40).프로그래머스 짝수 홀수 개수는 짝수와 홀수에 따라 for문 내부 if문으로 갯수를 구하는 문제 또는 filter로 각자 나눈 다음 길이를 구하는 문제였다.
[num_list.filter(el => el%2 === 0).length, num_list.filter(el => el%2).length]


CT(41).프로그래머스 피자 나눠먹기(3)은 slice가 7이 아닌 변수인 점만 달랐다..
아까의 7 대신 slice를 넣어주면 해결할 수 있다.
Math.ceil(n/slice)


CT(42).프로그래머스 369게임은 3,6,9가 몇개 들어있는지만 보면 되는 문제였기 때문에 String(order).split('').filter(el => '369'.includes(el)).length로 해결했다.


CT(43).프로그래머스 가위 바위 보는 if문을 통해 문자열을 더해주는 방식으로 처리했다.

function solution(rsp) {
    let answer = '';
    for(let i = 0 ; i < rsp.length ; i++){
        if(rsp[i] === '0') answer += '5'
        if(rsp[i] === '2') answer += '0'
        if(rsp[i] === '5') answer += '2'
            
    }
    return answer;
}

CT(44).프로그래머스 삼각형의 완성조건(1)은 구조분해 할당으로 sort한 값을 a,b,c로 넣은 다음 삼항연산자로 결과를 리턴했다.

function solution(sides) {
    let [a,b,c] = sides.sort((a,b) => a-b)
    return (a+b > c ? 1 : 2)
}

CT(45).프로그래머스 외계행성의 나이는 각 글자를 쪼갠 다음 문자열에 index를 대응시켰다.
String(age).split('').map(el => 'abcdefghij'[Number(el)]).join('')


CT(46).프로그래머스 대문자와 소문자는 대문자화한 글자와 현재 글자를 비교해 같으면 대문자니까 소문자로 바꾸고 아니면 대문자로 바꾸는 처리를 했다.

function solution(my_string) {
    let answer = ''
    for(let i = 0 ; i < my_string.length ; i++){
        if(my_string[i].toUpperCase() === my_string[i]){
            answer += my_string[i].toLowerCase()
        }
        else{
            answer += my_string[i].toUpperCase()
        }
    }
    return answer
}

CT(47).프로그래머스 인덱스 바꾸기는 splice가 pop처럼 반환값을 내보내기 때문에 하단에 따로 작성할 수 밖에 없는 단점이 있었다.

function solution(my_string, num1, num2) {
    let a = my_string[num1]
    let b = my_string[num2]
    let arr = my_string.split('')
    arr.splice(num1,1,b)
    arr.splice(num2,1,a)
    return arr.join('')
}

CT(48).프로그래머스 문자열 정렬하기(2)는 소문자 및 알파벳 순서 정렬이었다.
toLower과 sort로 해결했다.
my_string.toLowerCase().split('').sort().join('')


CT(49).프로그래머스 숫자 찾기는 indexOf로 index 위치를 찾으면 쉬운 문제였다.
(String(num).indexOf(k) > -1 ? String(num).indexOf(k)+1 : -1)


CT(50).프로그래머스 배열 뒤집기는 reverse로 해결했다. 

num_list.reverse()



CT(51).프로그래머스 가장 큰 수 찾기는 sort가 array에 영향을 미치는 부분 때문에 새로 변수를 선언해줄 수 밖에 없다고 생각하고 했다가 구조분해할당을 통하면 상관없다는 사실을 알았지만 너무 길어지기 때문에 그냥 유지했다.

function solution(array) {
    let a = [...array].sort((a,b) => b-a)[0]
    return [a, array.indexOf(a)]
}

CT(52).프로그래머스 7의 개수는 7이 몇개 있는지 파악하는 문제로 join, filter를 사용했다.
array.join('').split('').filter(el => el === '7').join('').length


CT(53).프로그래머스 숨어있는 숫자의 덧셈(1)은 자연수들을 분할한 다음 모두 더하는 문제로 split, map, filter, reduce를 사용했다.
my_string.split('').filter(el => '123456789'.includes(el)).map(Number).reduce((a,b) => a+b)


CT(54).프로그래머스 잘라서 배열로 저장하기는 for문으로 slice를 진행하면 해결할 수 있었다.

function solution(my_str, n) {
    var answer = [];
    for(let i = 0 ; i < my_str.length ; i += n){
        answer.push(my_str.slice(i,i+n))
    }
    return answer;
}

CT(55).프로그래머스 최댓값 만들기(2)는 아까 했던 양수조건이 아닌 문제로 Math.max로 앞, 뒤를 체크했다

function solution(numbers) {
    let a = numbers.length
    numbers.sort((a,b)=> a-b)
    return Math.max(numbers[0]*numbers[1] , numbers[a-1]*numbers[a-2])
}

CT(56).프로그래머스 주사위의 개수는 최대 수납문제로 Math.floor로 해결했다.
Math.floor(box[0]/n)*Math.floor(box[1]/n)*Math.floor(box[2]/n)


CT(57).프로그래머스 개미 군단은 사냥감의 체력에 맞는 병력을 데려간다고 한다.
5,3,1인줄 모르고 5,1인줄 알고 풀었다가 결국 조건을 추가할 수 밖에 없었다.

function solution(hp) {
    let sum = Math.floor(hp/5)
    let left = hp%5
    
    return (sum + Math.floor(left/3) + left%3)
}

CT(58).프로그래머스 합성수 찾기는 소수가 아닌 것의 갯수를 찾는 것(1제외)이라고 봐도 될 것 같았다. 에라토스테네스의 체를 이용해 소수배열을 만든 다음 소수가 아닌 0을 filter로 찾아 처리했다.
다만 범위 내 소수찾기가 0단계인건 재미있었다..

function solution(n) {
    let dp = new Array(n+1).fill(1)
    for(let i = 2 ; i <= n ; i++){
        if(dp[i]){
            for(let j = 2 ; i*j <= n ; j++){
                dp[i*j] = 0
            }
        }
    }
    
    return dp.filter(el => el === 0).length
}

CT(59).프로그래머스 배열 회전시키기는 조건에 따라 if로 분기한 후 pop, shift등을 사용해서 해결했다.

function solution(numbers, direction) {
    if(direction === 'right'){
        numbers.unshift(numbers.pop())
        return numbers
    }
    else{
        numbers.push(numbers.shift())
        return numbers
    }
}

CT(60).프로그래머스 옹알이는 복잡한 문제였는데 아기가 발음할 수 있는 특정 알파벳 모음의 소리가 중복되지 않게 이어진 문자열을 카운팅하는 문제였다.
아기가 낼 수 있는 소리를 대문자로 치환(조건은 모두 소문자 문자열)한 다음
대문자가 아닌 글자가 남아있는 경우 또는 중복해서 같은 대문자가 있는 경우 0처리를 한 다음 결과값에 더했다.

function solution(babbling) {
    let arr = babbling.map(el => el.split("aya").join('A').split("ye").join('B').split("woo").join('C').split("ma").join('D'))
    let answer = 0
    for(let i = 0 ; i < arr.length ; i++){
        if(arr[i].toUpperCase() === arr[i]){
            let result = 1
             for(let j = 0 ; j < arr[i].length-1 ; j++){
                 if(arr[i][j] === arr[i][j+1]){
                     result = 0
                 }
             }
            answer += result
        }
    }
    return answer
}

CT(61).프로그래머스 피자 나눠먹기(2)는 나머지가 0이 나오는 피자 판수까지 증가시키는 for문을 사용했다.

function solution(n) {
    for(let i = 1 ; i <= n ; i++){
        if((i*6)%n === 0){
            return i
        }
    }
}

CT(62).프로그래머스 2차원으로 만들기는 이차원 배열 내부로 값을 넣는 문제였다.

function solution(num_list, n) {
    let answer = []
    for(let i = 0 ; i < Math.ceil(num_list.length/n) ; i++){
        answer.push(new Array())
    }
    for(let i = 0 ; i < num_list.length ; i++){
        answer[Math.floor(i/n)][i%n] = num_list[i]
    }
    return answer;
}

CT(63).프로그래머스 직각삼각형 출력하기는 당황스럽게도 readline 방식의 문제였다. 물론 저번에도 비슷한 방식으로 간단한 문제를 푼 경험이 있어 쉽게 해결할 수 있었다.

const readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

let input = [];

rl.on('line', function (line) {
    input = line.split(' ');
}).on('close', function () {
    for(let i = 1 ; i <= Number(input) ; i++){
        console.log('*'.repeat(i))   
    }
});

CT(64).프로그래머스 암호 해독은 문자열 앞에 공백 하나를 넣은 다음 for문으로 일정 구간마다 answer에 더해주는 방식으로 해결했다.

function solution(cipher, code) {
    let answer = '';
    let str = ' '+cipher
    for(let i = code ; i <= cipher.length ; i += code){
        answer += str[i]        
    }
    return answer
}

CT(65).프로그래머스 종이 자르기는 M*N-1로 해결했다.


CT(66).프로그래머스 순서쌍의 개수는 약수의 갯수를 구하라는 말과 같았기 때문에 약수의 갯수를 구해줬다.

function solution(n) {
    let answer = 0;
    for(let i = 1 ; i <= n ; i++){
        if(n%i === 0){
            answer++
        }
    }
    return answer;
}

CT(67).프로그래머스 팩토리얼은 반복해서 i를 곱하다가 i를 곱한 경우 초과한다면 i-1을 return하는 방식으로 해결했다.

function solution(n) {
    let factorial = 1
    let now = 1
    for(let i = 2 ; i <= n ; i++){
        if(factorial*i > n){
            return i-1
        }
        else{
            factorial *= i
            now = i
        }
    }
    return now
}

CT(68).프로그래머스 A로 B만들기는 배열 상태에서 비교했다 오답이 나와 생각해보니 배열끼리는 같다고 해도 주소값(heap)이 다르기 때문에 join()을 사용해 문자열로 바꾼 후 비교했다.
(before.split('').sort().join() === after.split('').sort().join() ? 1 : 0)


CT(69).프로그래머스 k의 개수는 해당 숫자를 모두 문자열에 더해준 다음 filter로 해당 글자의 갯수를 구했다.

function solution(i, j, k) {
    let str = ''
    for(let a = i ; a <= j ; a++){
        str += a
    }
    return str.split('').filter(el => el == k).length
}

CT(70).프로그래머스 영어가 싫어요는 대체하는 방식으로 해결했다..

function solution(numbers) {
    let arr = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
    
    return Number(numbers.split(arr[0]).join(0).split(arr[1]).join(1).split(arr[2]).join(2).split(arr[3]).join(3).split(arr[4]).join(4).split(arr[5]).join(5).split(arr[6]).join(6).split(arr[7]).join(7).split(arr[8]).join(8).split(arr[9]).join(9))
}

CT(71).프로그래머스 가까운 수는 마지막 테스트케이스가 통과되지 않았다.
개인적으로 추가해도 되지 않아 곰곰히 생각해보니 숫자가 정렬되어 들어가 있다는 말은 없었다.(예제는 모두 오름차순이지만..)
그래서 이중배열화 해서 현재 값과 차이값을 계산한 다음 현재 값을 기준으로 오름차순 정렬한 다음 최소 차이값과 일치하는 값을 return했다.

function solution(array, n) {
    let arr = array.map(el => [el,  Math.abs(el-n)]).sort((a,b) => a[0]-b[0])
    let min = Math.min(...array.map(el => Math.abs(el-n)))
    for(let i = 0 ; i <= arr.length ; i++){
        if(arr[i][1] === min){
            return arr[i][0]
        }
    }
}