JS 프로그래머스 (입문) 15-20일차

 

💡영어가 싫어요

function solution(numbers) {
    const dic = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"];
    let answer = "";

    let currentWord = ""; 

    for (let i = 0; i < numbers.length; i++) {
        const char = numbers[i];

        currentWord += char;
        if (dic.includes(currentWord)) {
            answer += dic.indexOf(currentWord);
            currentWord = ""; 
        }
    }

    return parseInt(answer);
}

answer을 담는 변수와 현재 단어를 담는 변수를 만들어, dic의 index+1만큼 더하는 방식을 적용했다.

객체로 담은 뒤 replace메서드를 콜백 함수와 함께 사용하는 방식이 있어 적어둔다. 

✨ replace 1번째 인자는 정규표현식이 올수 있고 2번째 인자는 콜백이 올 수 있다.

function solution(numbers) {
    const obj = {
        zero: 0, one: 1, two: 2, three: 3, four: 4,
        five: 5, six: 6, seven: 7, eight: 8, nine: 9
    };

    const num = numbers.replace(/zero|one|two|three|four|five|six|seven|eight|nine/g, (v) => {
        return obj[v];
    });

    return Number(num);
}

 

 

💡인덱스 바꾸기

function solution(my_string, num1, num2) {
    var answer = '';
    for(let i=0;i<my_string.length;i++){
        if(i !==num1 && i !==num2){
            answer += my_string[i]
        } else if(i ===num1){
            answer+= my_string[num2]
        } else {
            answer += my_string[num1]
        }
    }
    return answer;
}

사실 답은 어떻게든 맞췄는데 쓰면서도 이건 아니다...라고 생각했던 문제.

split("")로 배열화 해준 뒤 인덱스만 바꿔버리는 방식을 사용할 수 있었다. 

function solution(my_string, num1, num2) {
  let arr = my_string.split("");
  [arr[num1], arr[num2]] = [arr[num2], arr[num1]];
  return arr.join("");
}

---

💡문자열 계산

function solution(my_string) {
    let num = parseInt(my_string[0]);
    
    for(let i = 1; i < my_string.length; i++) {
        if (my_string[i] === "+" || my_string[i] === "-") {
            let operator = my_string[i];
            let nextNum = parseInt(my_string[i + 1]);
            
            if (operator === "+") {
                num += nextNum;
            } else if (operator === "-") {
                num -= nextNum;
            }
        }
    }
    
    return num;
}

my_string은 "3 + 4"처럼 문자로 된 수식이다. 이 값을 리턴해야 한다.

my_string[0]값을 초기값으로 둔 뒤 operator을 "+"인지 "-"인지 걸러낸다. 이후 각 연산자에 따라 +나 -를 해서 계산해준다. 

 

 

💡배열의 유사도

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

두 배열에 같은 값이 있으면 그 값만큼 리턴한다. 일단 이중 for문으로 해결했다. 

하단과 같이 filter로 서로 원소를 포함하는 것이 있는지 살피고 그 길이만큼 리턴하는 것도 가능하다. 

function solution(s1, s2) {
    const intersection = s1.filter((x) => s2.includes(x));
    return intersection.length;
}

---

💡숫자 찾기

function solution(num, k) {
    let answer = -1;
    let kStr = k.toString();
    let numStr = num.toString();
    for(let i=0;i<numStr.length;i++){
        if(numStr[i] === kStr){
            answer = i+1;
            break;
    } }
    return answer;
}

k가 있으면 그 숫자가 있는 자리수를 리턴하고, 없으면 -1을 리턴한다. 

기본 answer을 -1로 정해둔 뒤, num과 k를 모두 string 타입으로 바꾸어 비교했다.

k가 존재하는 경우 answer의 값을 인덱스+1로 교환하여 반환해준다.

 

 

💡자릿수 더하기

function solution(n) {
    var answer = 0;
    let array = n.toString().split("");
    answer = array.reduce((a,b)=>{
       return a+Number(b)
    }, 0)
    return answer;
}

보자마자 reduce로 푸는 문제라는 생각이 들었다.

모든 자릿수를 더해서 하나의 값으로 반환한다. Number로 바꾸어주는 걸 잊지 말자. 

---

💡문자열 안의 문자열

function solution(str1, str2) {
    return str1.includes(str2) ? 1 : 2;
}

includes는 기억해두면 요긴하다. 삼항연산자로 한 줄로 표현 가능하다.

 

 

💡제곱수 판별하기

function solution(n) {
   return Math.round(Math.sqrt(n))===Math.sqrt(n)?1:2
}

제곱수인 경우에는 1을 리턴한다. 일단 제곱근을 반올림한 결과가 제곱근과 같을 때(즉, 제곱근이 정수일 때) 제곱수라고 생각하여 조건을 주었다.

알아보니 정수인지 판별하는 식은 실제로 Number.isIntegar()이 이미 있었다.

function solution(n) {
  return Number.isInteger(Math.sqrt(n)) ? 1 : 2;
}

 

 

---

💡7의 개수

function solution(array) {
    let str = 0;    
    let answer = 0;
    for(let i=0;i<array.length;i++){
        str += array[i].toString();
    }
    for(let j=0;j<str.length;j++){
        if(str[j]==="7"){
            answer +=1;
        }
    }
    return answer;
}

너무 원론적으로 풀어버린 느낌이었는데...

역시 join()과 split('7')으로 훨씬 간단하게 푼 사람들이 있었다.

split은 해당 조건을 기준으로 나누어준다는 것을 기억하자.

 

function solution(array) {
    return array.join('').split('7').length-1;
}

 

 

💡잘라서 배열로 저장하기

function solution(my_str, n) {
  const answer = [];
  let word = my_str;
  while(word.length>0){
    if(word.length>n){
      answer.push(word.slice(0,n));
      word = word.slice(n);
    } else {
      answer.push(word.slice(0,word.length))
      word = '';
    }
  }
  return answer;
}

n수만큼 my_str을 자른다.  slice()와 배열을 쓰는 것은 똑같으나 조금 더 축약한 방법이 있다.

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

 

 

 

💡중복된 숫자 개수

function solution(array, n) {
    return array.filter(x=>x===n).length;
}

 filter을 사용하여 간단하게 풀어버릴 수 있는 문제. 

---

💡캐릭터의 좌표

function solution(keyinput, board) {
    let [width, height] = [Math.floor(board[0] / 2), Math.floor(board[1] / 2)];
    let [myW, myH] = [0, 0];

    for (let i = 0; i < keyinput.length; i++) {
        if (keyinput[i] === "left" && myW > -width) {
            myW -= 1;
        } else if (keyinput[i] === "right" && myW < width) {
            myW += 1;
        } else if (keyinput[i] === "up" && myH < height) {
            myH += 1;
        } else if (keyinput[i] === "down" && myH > -height) {
            myH -= 1;
        }
    }

    return [myW, myH];
}

구조분해할당을 사용해서 풀어 보았다.

최대 맵의 크기를 고려하여 캐릭터 이동에 맞춘 경우를 생각해준다.

switch문으로도 충분히 풀 수 있을 것 같았는데 약간 헷갈려서 그냥 if else문으로...

하단과 같이 switch문으로 대체 가능하다.

function solution(keyinput, board) {
    let res = [0,0];
    for (let p of keyinput) {
        switch(p){
            case 'left': if (-res[0] < board[0]/2-1) res[0]--; break;
            case 'right': if (res[0] < board[0]/2-1) res[0]++; break;
            case 'up': if (res[1] < board[1]/2-1) res[1]++; break;
            case 'down': if (-res[1] < board[1]/2-1) res[1]--; break;
        }
    }
    return res;
}

 

 

💡최댓값 만들기(2)

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

음수 두 개의 곱이 가장 큰 경우와 양수 두 개의 곱이 가장 큰 경우를 고려해야 한다.

sort로 우선 배열을 정돈한 뒤, 최댓값이 될 수 있는 경우 두 가지를 비교하고 Math.max()로 최댓값만 반환한다.