Portfolio

문제

Given an m x n matrix mat, return an array of all the elements of the array in a diagonal order.

Example 1:


Input: mat = [[1,2,3],[4,5,6],[7,8,9]]
Output: [1,2,4,7,5,3,6,8,9]

Example 2:


Input: mat = [[1,2],[3,4]]
Output: [1,2,3,4]

Constraints:

m == mat.length

n == mat[i].length

1 <= m, n <= 104

1 <= m * n <= 104

105 <= mat[i][j] <= 105

풀이

은찬


var findDiagonalOrder = function(mat) {
    const answer = [];
    const diagonalX = [-1, 1];
    const diagonalY = [1, -1];
    const directX = [0, 1, 1, 0];
    const directY = [1, 0, 0, 1];
    const m = mat.length;
    const n = mat[0].length;
    // if state === 0 : up diagonal, else down diagonal
    let state = 0;
    let x = 0;
    let y = 0;
    
    const checkRange = (x, y) => {
        if(x >= 0 && x < m && y >= 0 && y < n){
            return true;
        }
        
        return false;
    }
    
    while(answer.length < m * n){
        let nx = x + diagonalX[state];
        let ny = y + diagonalY[state];
        
        answer.push(mat[x][y]);
        
        if(checkRange(nx, ny)){
            x = nx;
            y = ny;
        } else{
            nx = x + directX[state];
            ny = y + directY[state];
            
            if(checkRange(nx, ny)){
                x = nx;
                y = ny;
            } else{
                nx = x + directX[state + 2];
                ny = y + directY[state + 2];
                
                x = nx;
                y = ny;
            }
        
            state = state ? 0 : 1;
        }
    }
    
    return answer;
};

재영


/**
 * @param {number[][]} mat
 * @return {number[]}
 */
const findDiagonalOrder = (mat) => {
  const result = [];
    
  const rowLength = mat.length;
  const colLength = mat[0].length;

  const diagonalCnt = rowLength + colLength - 1;

  let i = 0;
  let j = 0;

  for (let nowCnt = 0; nowCnt < diagonalCnt; nowCnt += 1) {

    while (i >= 0 && j >= 0 && i < rowLength && j < colLength) {
      result.push(mat[i][j]);

      if (nowCnt % 2 === 0) {
        i -= 1;
        j += 1;
      } else {
        i += 1;
        j -= 1;
      }
    }

    if (nowCnt % 2 === 0) {
      if (j > colLength - 1) {
        i += 2;
        j = colLength - 1;
      } else {
        i = 0;
      }
    } else {
      if (i > rowLength - 1) {
        i -= 1;
        j += 2;
      } else {
        j = 0;
      }
    }
  }

  return result;
};

효성


/**
 * @param {number[][]} mat
 * @return {number[]}
 */
var findDiagonalOrder = function (mat) {
    const R = mat.length, C = mat[0].length;

    const startList = [
        ...Array.from({ length: C }, (_, i) => [0, i]),
        ...Array.from({ length: R - 1 }, (_, i) => [i + 1, C - 1]),
    ];

    const finishList = [
        ...Array.from({ length: R }, (_, i) => [i, 0]),
        ...Array.from({ length: C - 1 }, (_, i) => [R - 1, i + 1]),
    ];

    for (let i = 0; i < startList.length; i += 2) {
        [startList[i], finishList[i]] = [finishList[i], startList[i]];
    }

    const ans = [];

    for (let i = 0; i < startList.length; i++) {
        let [r, c] = startList[i];
        const [fr, fc] = finishList[i];

        ans.push(mat[r][c]);

        while(r != fr || c != fc) {
            if (i % 2 === 0) {
                r += -1;
                c += 1;
            } else {
                r += 1;
                c += -1;
            }
            ans.push(mat[r][c]);
        }
    }

    return ans;
};

Diagonal-traverse

문제

풀이