How to check in a 2d array if the four elements in the row and column are the same?

Question

I am trying to get a forEach nested loop that will find a pair of four in a two dimensional array.

Here is an example of what my array looks like:

[0, 0, 0, 0, 0],
[0, 2, 0, 0, 0],
[0, 1, 2, 0, 0],
[0, 1, 2, 2, 0],
[1, 2, 1, 1, 2],

It should ignore 0 and find only horizontal, vertical and diagonal pairs of four elements with "1" or "2".

Does anyone have any suggestions?

Answer 1

Jonas answer is better than this, but if you don’t understand its syntax, here’s a simplified and more detailed version:

var field = [
  [0, 0, 0, 0, 0],
  [0, 2, 0, 0, 0],
  [0, 1, 2, 0, 0],
  [0, 1, 2, 2, 0],
  [1, 2, 1, 1, 2]
];

function checkVertical(field, player){
  for(i = 0; i < 5; ++i){
    if (field[0][i] === player 
        && field[1][i] === player
        && field[2][i] === player
        && field[3][i] === player
    ) return true;
    
    if (field[1][i] === player 
        && field[2][i] === player
        && field[3][i] === player
        && field[4][i] === player
    ) return true;
  }
  return false;
}

function checkHorizontal(field, player){
  for(i = 0; i < 5; ++i){
    if (field[i][0] === player 
        && field[i][1] === player
        && field[i][2] === player
        && field[i][3] === player
    ) return true;
    
    if (field[i][1] === player 
        && field[i][2] === player
        && field[i][3] === player
        && field[i][4] === player
    ) return true;
  }
  return false;
}

function checkDiagonal1(field, player){
  // exercise for the reader
  return false;
}

function checkDiagonal2(field, player){
  // exercise for the reader
  return false;
}

function isWin(field, player){
  return checkVertical(field, player) 
    || checkHorizontal(field, player)
    || checkDiagonal1(field, player)
    || checkDiagonal2(field, player);
 
}

console.log(isWin(field, 1));

Run codeHide result

Answer 2

, , , .

n , , m*m 2D. a 0 , 1 2 .

m*m n*n ( 1 ) ().

, n*n, n $t20 , n 2 n .

5*5 :

var board = [[0, 0, 2, 0, 0],
             [0, 2, 2, 0, 0],
             [0, 1, 2, 0, 0],
             [0, 1, 2, 2, 0],
             [1, 1, 1, 1, 2]];

(0,0), - (4,4). , n 4, , ,

• (2, 0) (2, 3) 2s
• (0, 4) (3, 4) 1s
• (1, 1) (4, 4) 2s

:

{ 'sx: 2, sy: 0, ex: 2, ey: 3': [ [ 2, 0 ], [ 2, 3 ], 2 ],
  'sx: 0, sy: 4, ex: 3, ey: 4': [ [ 0, 4 ], [ 3, 4 ], 1 ],
  'sx: 1, sy: 1, ex: 4, ey: 4': [ [ 1, 1 ], [ 4, 4 ], 2 ] }

sx sy (x, y) ex ey (x, y) . .

:

function checkBoard(b,n){
  
  function chunk2D(b,n){
    var chunks = [],
        chunk;
    if (!n || b.length < n || b[0].length < n ) return "no way..!";
    for (var i = 0; i <= b.length - n; i++){
      for (var j = 0; j <= b[0].length - n; j++){
        chunk = {x:j, y:i, c:[]};
        for (var k = 0; k < n; k++){
          chunk.c.push(b[i+k].slice(j,j+n));
        }
        chunks.push(chunk);
        chunk = [];
      }
    }
    return chunks;
  }

  function getDiagonals(a){
    var len    = a.length,
        result = [[],[]];
    for (var i = 0; i < len; i++){
      result[0].push(a[i][i]);
      result[1].push(a[i][len-1-i]);
    }
    return result;
  }

  function getColumns(a){
    return a.map((r,i) => r.map((_,j) => a[j][i]));
  }

  var chunks = chunk2D(b,n),
      diags,
      columns,
      found;
  return chunks.reduce(function(r,c,i){
                         diags = getDiagonals(c.c);
                         found = diags[0].reduce((p,d) => p !== 0 && d !== 0 && p == d ? d : 0);
                         found && (r["sx: " + c.x + ", sy: " + c.y + ", ex: " + (c.x+n-1) + ", ey: " + (c.y+n-1)] = [[c.x,c.y],[c.x+n-1,c.y+n-1],found]);
                         found = diags[1].reduce((p,d) => p !== 0 && d !== 0 && p == d ? d : 0);
                         found && (r["sx: " + c.x + ", sy: " + (c.y+n-1) + ", ex: " + (c.x+n-1) + ", ey: " + c.y] = [[c.x,c.y+n-1],[c.x+n-1,c.y],found]);
                         columns = getColumns(c.c);
                         columns.forEach(function(col,j){ // colums check
                                           found = col.reduce((p,d) => p !== 0 && d !== 0 && p == d ? d : 0);
                                           found && (r["sx: " + (c.x+j) + ", sy: " + c.y + ", ex: " + (c.x+j) + ", ey: " + (c.y+n-1)] = [[c.x+j,c.y],[c.x+j,c.y+n-1],found]);
                                         });
                         c.c.forEach(function(row,j){ // rows check
                                       found = row.reduce((p,d) => p !== 0 && d !== 0 && p == d ? d : 0);
                                       found && (r["sx: " + c.x + ", sy: " + (c.y+j) + ", ex: " + (c.x+n-1) + ", ey: " + (c.y+j)] = [[c.x,c.y+j],[c.x+n-1,c.y+j],found]);
                                     });
                         return r;
                       }, {});
}

var board = [[0, 0, 2, 0, 0],
             [0, 2, 2, 0, 0],
             [0, 1, 2, 0, 0],
             [0, 1, 2, 2, 0],
             [1, 1, 1, 1, 2]];

console.log(checkBoard(board,4));

Hide result

Answer 3

var horizontal=[[0, 0, 0, 0, 0],[0, 2, 0, 0, 0],[0, 1, 2, 0, 0],[0, 1, 2, 2, 0],[1, 2, 1, 1, 2]];

var vertical=horizontal.reduce(function(arr,row)=>(row.forEach((el,i)=>arr[i].push(el)),arr),[]);

var result=[1,2].some(e=>horizontal.some(row=>row.filter(el=>el===e).length>=4))||vertical.some(row=>row.filter(el=>el===e).length>=4)));

true, .

Answer 4

, . , , @Redu.

. , , , , . , , . , , .

, 0 ( ) , . , 4 .

, . , .

const Matrix = function(matrix) { this.matrix = matrix; }

Matrix.prototype.getHorizontalSequences = function() {
  const matrix = this.matrix, sets = [];

  for(let i = 0; i < matrix.length; ++i) {
    const row = matrix[i];

    for(let j = 0; j < row.length; ++j) {
      const start = j;
      let k = j + 1;

      for(; k < row.length; ++k) {
        if(row[j] !== row[k]) break;
      }

      sets.push({ row: i, val: row[j], start: start, end: k - 1 });
      j = k - 1;
    }
  }
  
  return sets;
};

Matrix.prototype.getVerticalSequences = function() {
  const matrix = this.matrix, sets = [];

  for(let i = 0; i < matrix[0].length; ++i) {
    for(let j = 0; j < matrix.length; ++j) {
      const start = j;
      let k = j + 1;

      for(; k < matrix.length; ++k) {
        if(matrix[j][i] !== matrix[k][i]) break;
      }

      sets.push({ col: i, val: matrix[j][i], start: start, end: k - 1 });
      j = k - 1;
    }
  }
  
  return sets;
};

Matrix.prototype.getDiagonalSequences = function() {
  const matrix = this.matrix, sets = [];

  for(let i = 0; i < matrix[0].length; ++i) {
    for(let j = i; j < matrix.length; ++j) {
      const start = j;
      let k = j + 1;

      for(; k < matrix.length; ++k) {
        if(matrix[j][i] !== (matrix[j + k] || [])[i + k]) break;
      }

      sets.push({ col: i, val: matrix[j][i], start: start, end: k });
      j = k - 1;
    }
  }
  
  return sets;
};

let matrix = new Matrix([
  [0, 0, 0, 0, 0],
  [0, 2, 0, 0, 0],
  [0, 1, 2, 0, 0],
  [0, 1, 2, 2, 0],
  [1, 2, 1, 1, 2]
])

console.log(matrix.getHorizontalSequences().filter(e => (e.end + 1) - e.start >= 4));
console.log(matrix.getVerticalSequences().filter(e => (e.end + 1) - e.start >= 4));
console.log(matrix.getDiagonalSequences().filter(e => (e.end + 1) - e.start >= 4));

.as-console-wrapper { max-height: 100% !important; }

Hide result