Chikong

문제

풀이 코드

function solution(array, commands) {
  let arr = [];

  for (let i = 0; i < commands.length; i++) {
    arr.push(
      array.slice(commands[i][0] - 1, commands[i][1]).sort((a, b) => a - b)[ commands[i][2] - 1 ]
    );
  }
  return arr;
}

풀이 과정

slice 메서드와 sort메서드를 이요해 비교적 쉽게 풀어낼수 있었다,

다만, 내가 풀면서도 가독성이 너무 떨어지는거 같았다.

하지만 다른 방법이 도저히 생각나지 않았다, 그래서 다른 사람의 풀이를 봤다.

다른사람의

function solution(array, commands) {
    return commands.map(command => {
        const [sPosition, ePosition, position] = command
        const newArray = array
            .filter((value, fIndex) => fIndex >= sPosition - 1 && fIndex <= ePosition - 1)
            .sort((a,b) => a - b)    

        return newArray[position - 1]
    })
}

구조분해 할당을 이용해 보다 직관적으로 분리하여 변수를 사용하셨다,

또한 slice가 아닌, filter를 이용하여 간단히 풀이하셨다.

가독성을 높이기 위해 기초적인 문법을 더 학습 해야 할거같다.

문제

풀이 코드

function solution(left, right) {
  let sum = 0;

  for (let num = left; num <= right; num++) {
    if (primeCount(num)) sum += num;
    else sum -= num;
  }
  return sum;
}

function primeCount(n) {
  let prime = [];

  if (n % Math.sqrt(n) === 0) {
    prime.push(Math.sqrt(n));
  }

  for (let i = 1; i < Math.sqrt(n); i++) {
    if (n % i === 0) {
      prime.push(i);
      prime.push(n / i);
    }
  }
  return prime.length % 2 === 0;
}

풀이 과정

약수를 구하는 함수를 따로 만들어, left 부터 right 까지 해당 함수로 보내고,

각 수의 약수를 구한뒤, 약수를 담은 배열의 길이가 짝수이면 true, 홀수이면 false 를 반환하게 했다.

간단한 문제지만 조금더 간단히 구현할 수 있지 않을까? 생각이 들었다.

그래서 다른사람의 풀이를 봤는데

다른사람의 풀이

function solution(left, right) {
    var answer = 0;
    for (let i = left; i <= right; i++) {
        if (Number.isInteger(Math.sqrt(i))) {
            answer -= i;
        } else {
            answer += i;
        }
    }
    return answer;
}

ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ

내가 너무 깊게 생각을 했다.

약수를 구하는 함수에서도 sqrt 를 적용하여 계산했는데, 

사실 모든 약수의 원소를 구할 필요는 없었다.

해당 수의 약수가 짝구인지 홀수인지만 파악 하면 되는 문제였고,

해당수의 제곱근이 정확히 정수로 나오면 홀수이고, 정수가 아니라면 짝수가된다,

모쪼록 아쉬운 솔루션이였다.

문제

풀이 코드

function solution(numbers) {
  var answer = new Set();
  for (let i = 0; i < numbers.length - 1; i++) {
    for (let j = i + 1; j < numbers.length; j++) {
      answer.add(numbers[i] + numbers[j]);
    }
  }
  return [...answer].sort((a, b) => a - b);
}

풀이 과정

문제를 보자마자 Set 가 생각이 났다.

사실 자바스크립트에서 Set를 공부한 적은 없지만, 객체지향이라면 있을 것 같았다.

Set는 중복없는 콜렉션을 이야기 한다.

입력으로 들어온 배열의 모든 요소를 각각 더해주어야 하고, 

중복을 제거하고, 오름차순으로 정렬해서 반환해야 한다.

그래서 Set 를 생성해 주었고, Set.add 를 통해 요소를 더해준 값을 Set에 포함시켰다. 

이런 과정에서 중복된 값이 들어온다면 당연히 Set에 포함되지 않을것이다.

그렇게 2중 for 문으로 요소들을 구한뒤, 배열로 반환하고, 해당 배열을 오름차순으로 정렬하여 반환하였다.

문제

풀이 코드

function solution(a, b) {
    const monthDays = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    const weekDay = ['FRI','SAT','SUN','MON','TUE','WED','THU'];
    let days = 0;
    for (let i = 0; i < a - 1; i++)
        days += monthDays[i];
    days += b;
    
    const checkDay = days % 7 - 1
    return weekDay[checkDay < 0 ? 6 : checkDay];
}

풀이 과정

우선, 각 달마다 일수를 monthDays 배열에 담아 주었다,

그리고 요일의 정보를 weekDay 배열에 담아 주었다.

문제가 1월 1일부터 시작이니, days 변수에

입력된 월과 일을 계산하여, 해당 일자 까지의 총 일수를 더해주었고,

해당 일수를 7로 나누었을때 나머지값에 해당하는 부분이 해당 요일이 되기 때문에

index 접근을 위해 - 1을 해주었다.

지금 이 글을 적으면서 생각한건데, 요일 정보의 배열을 THU 부터 시작하면 굳이 -1 을 하지 않아도 됐을거같다.

그러면 마지막에 인덱스 범위 넘어갔을때 처리하는 로직을 굳이 하지 않아도 됐는데,

문제를 풀고나서 한번더 코드를 보며 생각을 해봐야 할것 같다!

다른사람의 풀이

function getDayName(a,b){
  var date = new Date(2016, (a - 1), b);
    return date.toString().slice(0, 3).toUpperCase();
}

date 객체를 이용할수도 있었다

대박!

문제

풀이 코드

function solution(sizes) {
  const largeNum = sizes.map((item) => (item[0] < item[1] ? item[1] : item[0]));
  const smallNum = sizes.map((item) => (item[0] > item[1] ? item[1] : item[0]));

  return Math.max(...largeNum) * Math.max(...smallNum);
}

풀이 과정

20분 정도를 어떻게 풀어야 할지 고민을 했다.

해당 문제는 사고력 문제인거 같았고, 스스로 아무리 고민해도 해결할 수 없을것 같았다.

그래서 구글링을 통해 개념만 파악했다.

해당 문제의 해결 방법은 다음과 같다.

1. 각 2차원 배열 내에서, 각 요소마다 큰수와 작은수가 반드시 나뉘어 진다. ( 명함을 정사각형으로 만들지 않을 뿐더러, 정사각형 이라 하여도 크게 문제는 없다 )

2. 각 배열내에서 큰수와 작은수를 각각 나누어 각각의 배열을 생성해 할당한다.

3. 큰수만 모여있는 배열과 작은수만 모여있는 배열에서의 각각 최대값을 뽑아 두수의 곱을 반환한다

해당 문제를 푸는 과정에서 사고력을 좀 키워야 겠다는 생각이 들었다.

다른사람의 풀이

function solution(sizes) {
    const [hor, ver] = sizes.reduce(([h, v], [a, b]) => [Math.max(h, Math.max(a, b)), Math.max(v, Math.min(a, b))], [0, 0])
    return hor * ver;
}

reduce 를 이용해 깔끔히 풀어낸 솔루션도 있지만.

개인적으로 가독성 측면에서 내가 푼 방법이 보기 편하다는 생각을 하게 되었다.

다만, reduce 를 이용해 한줄로 깔끔하게 풀어내신것도 감탄이 나왔다!