Keep Going

문제

어떤 정수들이 있다. 이 정수들의 절댓값을 차례대로 담은 정수 배열에서, 실제 정수들의 합을 구하여 return해라

수학개념

절댓값(absolute value)

: 어떤 값을 양수로 만들어주기 위한 장치

정수

: 양의정수, 0, 음의 정수의 총칭

코드

const solution = (absolutes, signs) => {
  let answer = absolutes.map((num, idx) => signs[idx] ? num : parseInt(-num)).reduce((a, b) => a + b);
  return answer;
}

문제

정수를 담고 있는 배열 arr의 평균값을 return하는 함수, solution을 완성해라

에러난 코드

const average = (arr) => {
  let answer = 0;

  for (let i of arr) {
    answer += i;
  }

  return answer/arr.length;
}

문제에서 함수 solution을 작성하라고 했는데 나혼자 함수명을 따로 지어버렸다....안될리가 없는데 왜 안되지 싶었네.. 사소한 실수 하지않도록 하자.

코드

const solution = (arr) => {
  let answer = 0;

  for (let i of arr) {
    answer += i;
  }

  return answer/arr.length;
}

완전탐색으로 해결해야하는 문제 -> 조합을 이용

4Combination3 = 4C3

4개 중에 3개씩 선택할 때 나올 수 있는 모든 조합을 구한다. 이 때, 조합의 순서는 상관이 없다. 순서가 바뀌어도 같은 구성이기 때문에 하나의 조합으로 취급한다. 

소수 

: 1과 자기 자신만을 약수로 갖는 수, 자신보다 작은 두 개의 자연수를 곱하여 만들 수 없는 1보다 큰 자연수

처음 시도한 방법

조합으로 모든 경우의 수 배열로 찾아서 다 더한다음에 소수판별할 생각이었다. -> 실패

조합을 이용하기

서로 다른 n개의 물건에서 순서를 생각하지않고 r개를 택할 때, n개에서 r를 택하는 조합 -> nCr

5개 중에서 3개를 더하는 조합 5C3 = 5*4*3 /3*2*1 = 10가지

배열의 처음부터 하나씩 고정하면서 뒤의 나머지 배열에 대해서 조합을 구한다. 

코드

const solution = (nums) => {
  let answer = 0;
  const len = nums.length;

  for (let i = 0; i < len; i++) {
    for (let j = i + 1; j < len; j++) {
      for (let k = j + 1; k < len; k++) {
        const sum = nums[i] + nums[j] + nums[k];
        if (isPrime(sum)) answer++;
      }
    }
  }
  return answer;
}

const isPrime = (sum) => {
  for (let i = 2; i < sum; i++)
    if (sum % i === 0) return false;
  return true;
}

문제

인형이 없는 칸은 빈칸이다. 모든 인형은 1 x 1 크기의 격자 한 칸을 차지, 격자의 가장 아래 칸부터 차곡차곡 쌓임

사용자는 크레인을 좌우로 움직여서 멈춘 위치에서 가장 위에 있는 인형을 집어올릴 수 있다. 

집어올린 인형은 바구니에 쌓인다. 바구니의 가장 아래 칸부터 인형이 순서대로 쌓이게된다.

같은 모양의 인형 두 개가 바구니에 연속해서 쌓이게 되면 두 인형은 터뜨려지면서 바구니에서 사라진다. 

인형이 없는 곳에서 크레인을 작동시키는 경우에는 아무런 일도 일어나지 않는다.

화면의 격자의 상태가 담긴 2차원 배열 board

인형을 집기 위해 크레인을 작동시킨 위치가 담긴 배열 moves

크레인을 모두 작동시킨 후 터트려져 사라진 인형의 개수를 return

[제한사항]

board 의 각 칸의 0은 빈칸을 나타낸다. 

1 ~ 100 의 숫자는 각기 다른 인형의 모양을 의미하며, 같은 숫자는 같은 모양의 인형을 나타낸다. 

코드

stack이용해서 풀 수 있는 문제였다. 

const solution = (board, moves) => {
  // 2차원 배열에서 moves의 순서대로 꺼내서 배열에 담는다.
  // 중복되는 횟수 구해서 리턴
  let answer = 0;
  let basket = [];

  for (let i = 0; i < moves.length; i++) {
    let n = moves[i] - 1; //크레인 위치 n을 기준으로 세로길이만큼 탐색

    for (let j = 0; j < board.length; j++) {
      // 0이 아닌 숫자를 꺼내서 basket 배열에 담는다. 
      if (board[j][n] !== 0) {
        if (basket[basket.length - 1] === board[j][n]) {
          answer += 2;
          basket.pop();
        } else {
          basket.push(board[j][n]);
        }
        board[j][n] = 0; // 꺼낸 자리 0으로 초기화
        break; // 해당 한개만 꺼내기 위해서 (for문 멈추기)
      }
    }
  }
  return answer;
}

const board = [
  [0, 0, 0, 0, 0],
  [0, 0, 1, 0, 3],
  [0, 2, 5, 0, 1],
  [4, 2, 4, 4, 2],
  [3, 5, 1, 3, 1]
];
const moves = [1, 5, 3, 5, 1, 2, 1, 4];
console.log(solution(board, moves));

문제

순서대로 누를 번호가 담긴 배열 numbers

왼손잡이인지 오른손잡이인지를 나타내는 문자열 hand

→ 각 번호를 누른 엄지손가락이 왼손인지 오른손인지를 나타내는 연속된 문자열 형태로 return

코드

const solution = (numbers, hand) => {
  let answer = '';

  let keypad = {
    1: [0, 0],
    2: [0, 1],
    3: [0, 2],
    4: [1, 0],
    5: [1, 1],
    6: [1, 2],
    7: [2, 0],
    8: [2, 1],
    9: [2, 2],
    '*': [3, 0],
    0: [3, 1],
    '#': [3, 2],
  };

  let leftHand = keypad['*'];
  let rightHand = keypad['#'];

  for (let x of numbers) {
    let [i, j] = keypad[x];

    if (j === 0) {
      answer += 'L';
      leftHand = keypad[x];
    }
    else if (j === 2) {
      answer += 'R';
      rightHand = keypad[x];
    }
    else {
      // 왼쪽 손가락 위치와 현재 위치와 떨어진 거리계산
      let leftDistance = Math.abs(i - leftHand[0]) + Math.abs(j - leftHand[1]);
      // 오른쪽 손가락 위치와 현재 위치와 떨어진 거리계산
      let rightDistance = Math.abs(i - rightHand[0]) + Math.abs(j - rightHand[1]);

      if (leftDistance > rightDistance) {
        rightHand = keypad[x];
        answer += 'R';
      }
      else if (leftDistance < rightDistance) {
        leftHand = keypad[x];
        answer += 'L';
      }
      else if (leftDistance === rightDistance) {
        if (hand === 'left') {
          leftHand = keypad[x];
          answer += 'L';
        } else {
          rightHand = keypad[x];
          answer += 'R';
        }
      }
    }
  }
  return answer;
}

문제

부서별로 신청한 금액만큼 모두 지원해줘야한다. 

부서별로 신청한 금액이 들어있는 배열 d, 예산 budget이 주어질 때, 

최대 몇 개의 부서에 물품을 지원할 수 있는지 return 

코드

const solution = (d, budget) => {
  let answer = 0;
  // 가장 작은 예산을 가진 부서부터 총 예산을 차감해가야 지원할 수 있는 부서가 최대로 된다. 
  d.sort((a, b) => a - b); // 오름차순 정렬

  d.reduce((acc, cur) => {
    acc + cur <= budget ? answer++ : answer;
    return acc + cur;
  }, 0);

  return answer;
}

문제

주어진 자연수 n을 3진법 상에서 앞뒤로 뒤집고, 이를 다시 10진법으로 표현한 수를 return

풀이

const solution = (n) => {
  let answer = n.toString(3).split('').reverse().join('');
  return parseInt(answer, 3);
}

사용한 메소드

1) Number.toString()

10진법 -> 2, 8, 16진법으로 변환

let value = 16;

value.toString(2); // 10000
value.toString(8); // 20
value.toString(16); // 10

2) parseInt

문자열을 정수로 해석하여 반환한다. 전달받은 인수가 문자열이 아니면 문자열로 변환한 다음, 정수로 해석하여 반환한다.  

두 번째 인수로 진법을 나타내는 기수를(2~36)을 전달할 수 있다. 기수를 생략하면 첫 번째 인수로 전달된 문자열을 10진수로 해석하여 반환한다. 

parseInt('10', 2); // 문자열 10을 2진수로 해석
parseInt('10', 8); // 문자열 10을 8진수로 해석

문제

다트게임의 3번의 기회에서 얻은 점수 합계에 해당하는 정수값을 출력

입출력예제

다트게임의 점수 계산 로직

・ 총 3번의 기회

・ 각 기회마다 얻을 수 있는 점수는 0점에서 10점 까지

・ S, D, T 영역이 존재하고 각 영역 당첨 시 점수에서 1제곱, 2제곱, 3제곱 (S, D, T는 점수마다 하나씩 존재)

・ 스타상(*) : 해당 점수와 바로 전에 얻은 점수를 각 2배로 만든다.

・ 첫 번째 기회에서도 나올 수 있다.

・ 첫 번째 스타상의 점수만 2배가된다. 

・ 스타상의 효과는 다른 스타상의 효과와 중첩될 수 있다. 중첩된 아차상의 점수는 -2배가 된다. 

・ 아차상(#) - 해당 점수 마이너스

・ 스타상, 아차상은 점수마다 둘 중 하나만 존재할 수 있으며, 존재할지 않을 수도 있다. 

접근방법

문자열 내에서 먼저 문자나 기호 기준으로 구획을 나누어 잘라서 배열화 하고, 다음에 각각 개별 연산을 해준다. 마지막에 한 번에 곱해서 결과값을 찾는다. 

원래 하고싶었던 방법은 정규식으로 각 숫자의 앞에서 자른 다음에 각각 계산을 해주고싶었는데, 생각보다 정규식 가공이 마음대로 되지않았다. 나중에 다시 한 번 풀어보면서 이 방법을 시도해보아야할 것 같다. 

코드

const solution = (dartResult) => {
  let answer = 0;
  let score = 0;
  let scoreArr = [];

  for (let i = 0; i < dartResult.length; i++) {
    // 점수가 10인 경우 찾아줘서 분리
    if (!isNaN(dartResult[i])) {
      score = Number(dartResult[i - 1]) === 1 ? 10 : Number(dartResult[i]);
    }
    else if (dartResult[i] === 'S') { // 1제곱
      scoreArr.push(score);
    }
    else if (dartResult[i] === 'D') { // 2제곱
      scoreArr.push(Math.pow(score, 2));
    }
    else if (dartResult[i] === 'T') { // 3제곱
      scoreArr.push(Math.pow(score, 3));
    }
    else if (dartResult[i] === '*') {
      scoreArr[scoreArr.length - 2] = scoreArr[scoreArr.length - 2] * 2;
      scoreArr[scoreArr.length - 1] = scoreArr[scoreArr.length - 1] * 2;
    }
    else if (dartResult[i] === '#') {
      scoreArr[scoreArr.length - 1] = -1 * scoreArr[scoreArr.length - 1];
    }
  }
  answer = scoreArr.reduce((acc, cur) => acc + cur, 0);
  return answer;
}

1-9까지는 괜찮은데 10을 잘 찾아서 걸러주어야했다. 

Math.pow(밑, 지수)

첫 번째 인수를 '밑'으로 두 번째 인수를 '지수'로 거듭제곱한 결과를 반환한다. 

String.match(찾을단어)

.match()는 정규표현식에 맞는 문자열을 찾아서 배열 객체로 반환

정규표현식에 맞는 문자열이 없다면 null을 반환

특정 텍스트 안에 검색할 단어, 찾고싶은 단어가 있는 경우 해당 텍스트가 문구에 포함되어있는지를 확인