1,2차원 배열탐색

1. 큰 수 출력하기

숫자로 이루어진 배열 내에서 자신의 바로 앞 수보다 큰 수만 출력하는 함수 만들기

    function solution(arr) {
      // 나의 풀이
      // let answer = [];
      // answer = arr.filter((num, i) => {
      //   if (i === 0) return num;
      //   else return num > arr[i - 1];
      // });
      // 선생님 풀이
      let answer = [];
      answer.push(arr[0]);
      for (let i = 0; i < arr.length; i++) {
        if (arr[i] > arr[i - 1]) answer.push(arr[i]);
      }
      return answer;
    }

    let arr = [7, 3, 9, 5, 6, 12];
    console.log(solution(arr)); //7 9 6 12
    
    

2. 보이는 학생

일렬로 서 있는 n 명의 학생의 키가 앞에 서부터 순서대로 주어질 때, 맨 앞에 서 있는 선생님이 볼 수 있는 학생의 수를 구하는 함수 만들기 (앞에 서 있는 사람들보다 크면 보이고, 작거나 같으면 보이지 않는다.)

  function solution(arr) {
    // 나의 풀이
    // let answer = 0;
    // let max = 0;
    // for (let i = 0; i < arr.length; i++) {
    //   if (arr[i] > max) {
    //     max = arr[i];
    //     answer++;
    //   }
    // }

    // 선생님 풀이
    let answer = 1,
      max = arr[0];
    for (let i = 1; i < arr.length; i++) {
      if (arr[i] > max) {
        answer++;
        max = arr[i];
      }
    }

    return answer;
  }

  let arr = [130, 135, 148, 140, 145, 150, 150, 153];
  console.log(solution(arr)); //5

3. 가위 바위 보

A, B 두 사람이 가위바위보 게임을 한다. 총 N번의 게임을 하여 A가 이기면 A를 출력하고, B가 이기면 B를 출력한다. 비길 경우에는 D를 출력한다.
(1:가위, 2:바위, 3:보)

  function solution(a, b) {
    // 나의 풀이
    // let answer = [];
    // for (let i = 0; i < a.length; i++) {
    //   if (a[i] > b[i] && a[i] - b[i] === 1) {
    //     answer.push("A");
    //   } else if (a[i] === b[i]) {
    //     answer.push("D");
    //   } else {
    //     answer.push("B");
    //   }
    // }
    let answer = "";
    for (let i = 0; i < a.length; i++) {
      if (a[i] === b[i]) answer += `D `;
      else if (a[i] === 1 && b[i] === 3) answer += `A `;
      else if (a[i] === 2 && b[i] === 1) answer += `A `;
      else if (a[i] === 3 && b[i] === 2) answer += `A `;
      else answer += `B `;
    }

    return answer;
  }


  let a = [2, 3, 3, 1, 3];
  let b = [1, 1, 2, 2, 3];
  console.log(solution(a, b)); //A B A B D

📌 A가 이기는 모든 경우의 수를 고려하여 풀어주면 된다.

4. 점수 계산

정답에 맞을 경우 1점, 오답일 경우 0점이지만 연속으로 정답을 맞춘 경우 1씩 가산한다. 예를들어 3문제를 연속으로 맞았다면 1, 2, 3점 순으로 각 문제에 대한 점수가 계산이 된다.

  function solution(arr) {
    //선생님 풀이
    let answer = 0,
      cnt = 0;
    for (let x of arr) {
      if (x === 1) {
        cnt++;
        answer += cnt;
      } else {
        cnt = 0;
      }
    }

    return answer;
  }
  let arr = [1, 0, 1, 1, 1, 0, 0, 1, 1, 0];
  console.log(solution(arr)); //10

5. 등수 구하기

각 배열에서 크기가 높은 순으로 순서를 출력하는 함수 만들기

  function solution(arr) {
    let n = arr.length;
    let answer = Array.from({ length: n }, () => 1); //[1,1,1,1,1];
    for (let i = 0; i < n; i++) {
      for (j = 0; j < n; j++) {
        if (arr[j] > arr[i]) answer[i]++;
      }
    }

    return answer;
  }
  let arr = [87, 89, 92, 100, 76];
  console.log(solution(arr)); //[4, 3, 2, 1, 5]

📌 배열 내의 item 하나하나를 일일히 비교해야할 때에는 for문 내의 for문 로직을 사용할 수 있다.

6. 격자판 최대합

N*N의 격자판이 주어지면 각 행의 합, 각 열의 합, 두 대각선의 합 중 가 장 큰 합을 출력하는 함수 만들기

  function solution(arr) {
    let answer = Number.MIN_SAFE_INTEGER;
    let n = arr.length;
    let sum1 = (sum2 = 0); // sum1 = 행의 합 ; sum2 = 열의 합
    for (let i = 0; i < n; i++) {
      sum1 = sum2 = 0; // 다음행으로 넘어갔을 때 합의 초기화 0으로 해주기
      for (let j = 0; j < n; j++) {
        sum1 += arr[i][j];
        sum2 += arr[j][i];
      }
      answer = Math.max(answer, sum1, sum2);
    }
    sum1 = sum2 = 0;
    for (let i = 0; i < n; i++) {
      sum1 += arr[i][i];
      sum2 += arr[i][n - i - 1];
    }
    answer = Math.max(answer, sum1, sum2);
    return answer;
  }

  let arr = [
    [10, 13, 10, 12, 15],
    [12, 39, 30, 23, 11],
    [11, 25, 50, 53, 15],
    [19, 27, 29, 37, 27],
    [19, 13, 30, 13, 19],
  ];
  console.log(solution(arr)); //155

7. 봉우리

N*N 격자판에서 각 격자 판의 숫자 중 자신의 상하좌우 숫자보다 큰 숫자는 봉우리 지역이다. 봉우리 지역이 몇 개 있는 지 알아내는 함수 만들기.
격자의 가장자리는 0으로 초기화 되었다고 가정.

  function solution(arr) {
    let answer = 0;
    let n = arr.length;
    const dx = [-1, 0, 1, 0];
    const dy = [0, 1, 0, -1];

    for (let i = 0; i < n; i++) {
      for (let j = 0; j < n; j++) {
        let flag = 1;
        for (let k = 0; k < 4; k++) {
          let nx = i + dx[k];
          let ny = j + dy[k];
          if (
            nx >= 0 &&
            nx < n &&
            ny >= 0 &&
            ny < n &&
            arr[nx][ny] >= arr[i][j]
          ) {
            flag = 0;
            break;
          }
        }
        if (flag) answer++;
      }
    }

    return answer;
  }

  let arr = [
    [5, 3, 7, 2, 3],
    [3, 7, 1, 6, 1],
    [7, 2, 5, 3, 4],
    [4, 3, 6, 4, 1],
    [8, 7, 3, 5, 2],
  ];
  console.log(solution(arr)); //10
  

📌 dx, dy / k포문 자주 쓰이는 로직이니 기억할 것 => 방향 탐색 문제