Question

在javascript中，我有一个矩阵数组，每个矩阵都是5x5。例如：

25, 32, 26, 27, 29
01, 22, 15, 17, 99
12, 14, 17, 19, 88
16, 14, 12, 17, 19
02, 08, 09, 18, 19

我有一个方法findMatches (a, b, c, d, e)，它取五个数字值。目标是返回一个符合以下任何条件的新矩阵数组：

findMatches (a, b, c, d, e)方法中至少有4个数字匹配任何矩阵行中至少4个连续数字。例如。如果矩阵行有22, 23, **29**, 24, 25则不匹配，因为方法中没有一组四个数字彼此相邻（但是，如果订单与订单的顺序相匹配则无关紧要） ints提供了方法。它可以是a，c，d，e，这很好。）。但是，如果它是22, 26, 23, 24，它将匹配，因为该方法至少有四个连续的数字。例如：

**22**, 32, 26, 27, 29
**26**, 22, 15, 17, 99
**23**, 14, 17, 19, 88
**24**, 14, 12, 17, 19
  02,   08, 09, 18, 19

与上述相同，但在任何矩阵列而不是行

20, 01, 02,  03,  08
01,*22,*23*,*25*,*24*
12, 14, 17, 19, 88
16, 14, 12, 17, 19
02, 08, 09, 18, 19

与最后两个相同但是对角线，而不是行或列

**22**, 32, 26, 27, 29            01, 02, 03,   04,   05
01, **23**, 15, 17, 99            06, 07, 08, **24**, 10
12, 14, **26**, 19, 88            11, 12, **23**, 14, 15
16, 14, 12, **25**, 19            16, **25**, 18, 19, 20
02, 08, 09,   18,   19          **22**, 22,   23, 24, 25

任何矩阵中没有两个数字是相同的。例如，整个矩阵中不会有多次1。

我不太清楚如何处理这个问题。我的第一直觉是坐在那里生成所有可能的矩阵以检查匹配，但考虑到有超过一百万种可能的组合，这显然是不可行的。

Answer 1

所以这是一个使用正则表达式的解决方案：

首先，我假设每个矩阵都以完全按照您所述的文本格式存储（这很重要，因为正则表达式可能需要进行调整）。

我们将使用此模式，（您需要在变量中替换01,02,03,20）。我稍微解释一下

(01|02|03|20), (?!\1)(01|02|03|20), (?!\1)(?!\2)(01|02|03|20), (?!\1)(?!\2)(?!\3)(01|02|03|20)

首先我们匹配任何数字。然后是逗号，然后是任何不是第一个数字的数字。

那(?!\1)做了几件事。首先，它做了一个＆＃34;否定先行断言＆＃34;在不消耗字符的情况下向前看，并确保它们不包含\1，它是我们第一个捕获的数字的后向引用。

将它用于垂直和对角列表是一件简单的事情，只需抓住相应的行并将其转换为水平格式，然后在其上运行正则表达式。

希望这可以帮助您入门。如果你碰壁，请随意回复你的尝试。

Answer 2

非正则表达式方法。

var matrix;

function findMatches(a, b, c, d, e) {
    // Rows
    for (var i = 0; i < matrix.length; i++) {
        if (checkMatch(matrix[i], [a, b, c, d, e]))
            return true;
    }

    // Columns
    for (var i = 0; i < matrix[0].length; i++) {
        if (checkMatch(getColumn(matrix, i), [a, b, c, d, e]))
            return true;
    }

    // Diagonals
    var diagonalArray = [];
    for (var i = 0; i < matrix.length; i++) {
        for (var x = 0; x < matrix[i].length; x++) {
            if (i === x) {
                diagonalArray.push(matrix[i][x]);
                continue;
            }
        }
    }
    if (checkMatch(diagonalArray, [a, b, c, d, e]));
        return true;

    var revDiagonalArray = [];
    for (var i = 0; i < matrix.length; i++) {
        for (var x = 0; x < matrix[i].length; x++) {
            if (i === 4 - x) {
                revDiagonalArray.push(matrix[i][x]);
                continue;
            }
        }
    }
    if (checkMatch(revDiagonalArray, [a, b, c, d, e]));
        return true;

    return false;
}

function getColumn(matrix, columnIndex) {
    var array = [];
    for (var i = 0; i < matrx.length; i++)
        array.push(matrix[i][columnIndex]);
    return array;
}

function checkMatch(array, toMatch) {
    var matchCount = 0;
    for (var i = 0; i < array.length; i++) {
        if (toMatch.indexOf(array[i]) > -1) {
            matchCount++;
            if (matchCount === 4)
                return true;
        }
        else if (i > 0)
            break;
    }
    return false;
}

Javascript模式匹配矩阵

2 个答案: