- ̗̀ෆෆ ̖́ 02. 기본 입출력에 관한 예제

오늘은 조금 더 간단한 입출력 예제가 다수 포함되어있다.

 

function solution(num1, num2) {
    const answer = num1 - num2;
    return answer;
}

 

간단한 문제였지만, 다른 사람은 화살표 함수를 활용해 문제를 풀었다.

문득 여기서는 왜 funtion이 아니라 const를 사용했을까하는 물음이 생겼다.

const solution = (num1, num2) => num1 - num2

 

검색해봤더니 화살표함수는 원래 'const', 'let', 'var' 키워드와 함께 사용하는 것이라고.

아직 배움이 멀다.

let multiply = (a, b) => a * b;

multiply = (a, b) => a / b; // 재할당 가능

 

이런식으로 let 키워드를 사용하면 재할당 가능하지만,

요즘 코딩 트렌드는 웬만해서는 const를 사용하는 추세이다보니.

 

---

 

나의 코드

function solution(numbers) {
    let sum = 0;
    for (let i = 0; i < numbers.length; i++) {
        sum += numbers[i];
    }
    const average = sum / numbers.length;
    return average;
}

 

문제를 풀면서도 찝찝한게,

코드가 생각보다 기니까 다른 사람들은 얼마나 더 깔끔하게 풀었을까 싶은 걱정이 먼저 든다.

 

아니나 다를까 이런 쌈뽕한 코드가 바로 나왔다.

function solution(numbers) {
    var answer = numbers.reduce((a,b) => a+b, 0) / numbers.length;
    return answer;
}

 

 

reduce
목적	배열을 하나의 값으로 줄이거나 합계 등을 계산할 때 사용
사용 예시	누적 계산을 간결하게 작성하고자 할 때

 

확실히 누적계산 문제였다.

다음부터는 조금 더 배열 메소드를 사용해봐야겠다고 생각했다.

---

function solution(num1, num2) {
    return num1 === num2 ? 1 : -1;
}

 

다행하게 바로 삼항연산자가 떠올라 깔끔하게 풀었다.

 

그리고 이런 기발한 풀이를 봤다.

function solution(num1, num2) {
    return ((num1 == num2)-0.5)*2;
}

 

ㅋㅋㅋㅋ 이정도면 예술인데?

하지만 === 연산자가 더 알맞지 않나란 생각도 든다.

인자로 무조건 숫자만 넘어오지 않을 수도 있으니까

---

function solution(num1, num2) {
    return Math.floor(num1 / num2);
}

 

혹시 소수점으로 문제가 생길 수 있으니

이제 Math.floor 연산자를 잘 사용해준다.

 

다른 사람의 풀이

function solution(num1, num2) {
  return parseInt(num1 / num2);
}

 

이런 간단한 문제에서도 나는 생각지도 못한 방법이 항상 나와서 신기하다.

어느 쪽이 더 효율적인가에 대한 생각을 하며 서치해본 결과,

그래도 Math.floor 연산자가 낫다는 결론에 이르렀다.

방법	동작 방식	장점	단점
Math.floor	아래쪽으로 내림	양수와 음수 모두 일관됨	-
parseInt	정수 부분 추출	양수의 경우 내림과 동일함	음수의 경우 문제 발생

 

음수라는 변수가 있기 때문에 Math.floor 연산자를 주로 사용하기로 결정했다.

---

function solution(n) {
    return Math.ceil(n / 7);
}

 

활자만 보고 무지성으로 if문 쓰면서 고민했는데

생각해보면 무조건 7조각이어야하는거니까,

n명을 7로 나눈 다음에 올려주면 되지않나하는 엄청난 생각이 떠올랐다.

 

물론 이것도 화살표 함수로 변환 가능하다.

const solution = (n) => Math.ceil(n/7)

---

 

이 문제는 이상하게 헤맸다.

왜일까? 뭔가 배열 키워드가 나오는 순간 내가 이상하게 문제를 꼬아보게 된다.

 

그냥 앞서 배운 filter를 이용해 걸러주면 되는 문제였다.

function solution(n, numlist) {
    const result = numlist.filter(num => num % n === 0);
    return result;
}

---

오늘은 이상하게 쉬운 문제들이 많이 걸려있어서

정답률 낮은 순으로 만들어 한 문제를 열심히 풀어봤다.

 

 

앗...아....

오늘은 이 문제에 가장 많은 시간을 할애한 것 같다.

 

별도의 답안 없이 오로지 모질라 사이트만 이용해 풀다보니

거의 2시간을 사용한듯싶다.

 

 

그래도 이 문제를 선택한 이유가 있다.

나는 컴퓨터학부로 전과해 처음 전필을 들으며 만들었던 프로젝트가 바로 지뢰찾기였기 때문!

 

그래서 다음 방식으로 코드를 작성했다.

1. board가 2차원 배열이다.

2. board를 순회해 모든 지뢰의 위치를 찾는다.

3. 지뢰 위치를 기반으로 8방향을 판단한다.

4. 모든 칸을 순회하면, 다시 위험지역이 아닌 칸을 카운트한다.

 

내가 생각했을 때, 이 논리에 따라 코드를 반복문으로 구성하는게 가장 베스트다.

실제로 이 코드가 내가 전과하자마자 만들었던 지뢰찾기 게임의 일부분이다.

function solution(board) {
    const n = board.length;
    const dangerZones = new Set();

    for (let i = 0; i < n; i++) {
        for (let j = 0; j < n; j++) {
            if (board[i][j] === 1) {
                for (let x = -1; x <= 1; x++) {
                    for (let y = -1; y <= 1; y++) {
                        const newRow = i + x;
                        const newCol = j + y;
                        if (newRow >= 0 && newRow < n && newCol >= 0 && newCol < n) {
                            dangerZones.add(`${newRow},${newCol}`);
                        }
                    }
                }
            }
        }
    }

    let safeZoneCount = 0;
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < n; j++) {
            if (!dangerZones.has(`${i},${j}`)) {
                safeZoneCount++;
            }
        }
    }

    return safeZoneCount;
}

 

 

하지만 머쓱이의 할인 문제를 풀며, 분명 8방향을 배열로 표현할 수 있을 것 같은데.

그 다음 forEach를 통해 코드를 순회하면 더 깔끔해지지 않을까?

이런 생각을 했다.

 

function solution(board) {

    let directions = [[-1,0], [-1,-1], [-1,1], [0,-1],[0,1],[1,0], [1,-1], [1,1]];
    let safezone = 0;

    board.forEach(`${함수 내용}`);

    return safezone;
}

 

하지만 이 forEach에 들어갈 함수 본체 부분을 구현하지 못했고,

다른 사람의 풀이를 보게 되었다.

 

board.forEach((row, y, self) => row.forEach((it, x) => {
    if (it === 1) return false;
      return outside.some(([oy, ox]) => !!self[oy + y]?.[ox + x])
            ? false : safezone++;
}));

 

이 코드는 아직 해석이 어려운데 ㅜㅜ

row.forEach((it, x)

 

forEach를 통해 각 행과 요소(it), 해당 요소의 인덱스를 순회함

 

if (it === 1) return false;

요소가 1이라면 return false.

지뢰라면 바로 다음 요소로 이동한다.

 

return outside.some(([oy, ox]) => !!self[oy + y]?.[ox + x]) ? false : safezone++;: outside

이게 제일 헷갈렸는데 그냥 8방향에 지뢰가 있는지 확인하는 코드였다.

! 연산자 때문에 헷갈렸는데, 그냥 Not 연산자였다.

 

나는 단일로 사용하는 건 봤어도 이중으로 사용하는 건 본적이 없는데,

그냥 값을 불리언으로 변환하는 가장 간단한 용도로 사용했던 것이다.

 

이렇게 또 하나 배워가네요.