Chikong

문제

풀이 코드

function solution(absolutes, signs) {
  return absolutes.reduce((prev, current, idx) => {
    return signs[idx] === true ? prev + current : prev + -current;
  }, 0);
}

풀이 과정

reduce 함수를 통해 간단히 구현했지만, 아무래도 가독성이 좀 떨어지는거 같았다.

더 간략하게 줄일수 있을거 같아서 다른사람의 풀이를 보고 스스로 자책했다.

다른사람의 풀이

function solution(absolutes, signs) {

    return absolutes.reduce((acc, val, i) => acc + (val * (signs[i] ? 1 : -1)), 0);
}

삼함 연산자에서 참 / 거짓 을 판별하기 때문에 그냥 signs[idx] 만으로도 판별이 가능한데

나는 바보처럼 === true 이거까지 붙여 코드가 더 길어졌다.

생각하고 코딩할것!

문제

풀이 코드

function solution(n, arr1, arr2) {
  let mapArr = arr1.map((item, index) => item | arr2[index]);
  return mapArr
    .map((item) => item.toString(2).padStart(n, '0'))
    .map((binary) =>
      binary
        .split('')
        .map((ii) => (ii === '1' ? '#' : ' '))
        .join('')
    );
}

풀이 과정

문제를 보자마자 비트연산을 해야하는것을 알았다.

OR 연산을 통해, 하나라도 1이라면 #으로, 둘다 0이라면 공백으로 지도를 채우면 된다.

그래서 우선 mapArr 라는 배열에 arr1 의 요소와 arr2 의 요소를 각각 OR 연산한 값을 저장하였고,

mapArr 에서, 해당 값들을 toString(2) 를 통해, 2진법으로 변환하고, n만큼의 자릿수를 확보하기 위하여 padStart 함수를 통해 빈 값들을 앞에서부터 0으로 채워줬다.

이후 각 요소를 나누어 배열로 만든다음, 해당 요소가 1이라면 # 을, 0이라면 공백을 치환한다음, join으로 하나의 문자열로 다시 만들어

해당 배열을 반환했다.

전부터 많이 봐왔던 유형이라 그런지 나름 쉽게 풀어냈다.

다만, 내가 봐도 가독성이 너무 떨어지는걸 느꼇고, 이에따라 다른사람의 풀이를 보게 되었다.

다른사람의 풀이

// 방법 1
function solution(n, arr1, arr2) {
    return arr1.map((v, i) => addZero(n, (v | arr2[i]).toString(2)).replace(/1|0/g, a => +a ? '#' : ' '));
}

const addZero = (n, s) => {
    return '0'.repeat(n - s.length) + s;
}

// 방법 2
var solution=(n,a,b)=>a.map((a,i)=>(a|b[i]).toString(2).padStart(n,0).replace(/0/g,' ').replace(/1/g,'#'))

정규표현식이 확실히 깔끔하다.

이건 공부를 한번 날잡고 제대로 해봐야겠음

문제

풀이 코드

function solution(a, b) {
    let answer = 0;
    for (let i = 0; i < a.length; i++) {
        answer += a[i] * b[i]
    }
    return answer;
}

풀이 과정

간단히 for 루프로 계산하였다.

다른사람의 풀이

function solution(a, b) {
    return a.reduce((acc, _, i) => acc += a[i] * b[i], 0);
}

reduce 를 이용해 한줄로 깔끔하게!

문제

풀이 코드

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 를 적용하여 계산했는데, 

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

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

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

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