如何使函数允许我们检查字符串列表是否是连续的？

Question

给定一个n x n大小大于4但不大于100的板。如何检查list[str]是否有从左到右、从上到下、以及对角(从左到下/从右上到左下)的连接元素？

例如，如果我们有一个列表：

Matrix = [ 'XXXOO',
           'X.OXX',
           'XOXOO',
           'O.XOO',
           'XXXOO']

我们应该能看到玩家O有一个匹配的四

这是我目前的代码：

Matrix = [ 
        'XXXOO',
        'X.OXX',
        'XOXOO',
        'O.XOO',
        'XXXOO']

def WhoWon(Matrix:list[str]) -> str:
    rows = len(Matrix)
    columns = len(Matrix[0])

    if 4 <= len(Matrix) <= 100:
        for Row in range(rows-3):
            for Col in range(columns-3):
                if Matrix[Row][Col] == Matrix[Row][Col + 1] == Matrix[Row][Col + 2] == Matrix[Row][Col + 3]: # left and right
                    return Matrix[Row][Col]
                elif Matrix[Row][Col] == Matrix[Row + 1][Col] == Matrix[Row + 2][Col] == Matrix[Row + 3][Col]: # up and down
                    return Matrix[Row][Col]
                elif Matrix[Row][Col] == Matrix[Row + 1][Col - 1] == Matrix[Row + 2][Col - 2] == Matrix[Row + 3][Col - 3]:
                    return Matrix[Row][Col]
                elif Matrix[Row][Col] == Matrix[Row + 1][Col + 1] == Matrix[Row + 2][Col + 2] == Matrix[Row + 3][Col + 3]:
                    return Matrix[Row][Col]

print(WhoWon(Matrix))```

Answer 1

你可以把它想象成一个常规的矩阵系统，所以基本上，对于每个单元格来说，如果它是一个向量的行的一部分，那么，为了使一行存在，必须存在一个用指数(i，j)表示的单元格，这样，单元格(i±k，j±k)，单元格(i±k，j±k)或单元格(i，j±k)都是与单元本身相同的符号，当k从0到S1之间运行时，如果S表示一行需要多少符号才能获胜。

用这种数学方法来检查使用索引相对容易：

player1symbol = 'O'
player2symbol = '.'
neutralsymbol = 'X'
Matrix = [ 
        'XXXOO',
        'X.OXX',
        'XOXOO',
        'O.XOO',
        'XXXOO']

def CheckWinner(Matrix, symbol):
    winner = False
    # How many in row to win
    towin = 4
    
    def isSymbol(elem):
        return elem == symbol
    
    def CheckRows(i,j):
        rowE = rowSE = rowS = rowSW = True
        for k in range(1,towin):
            if rowE and j+k<len(Matrix[i]):
                rowE = isSymbol(Matrix[i][j+k])
            if rowSE and j+k<len(Matrix[i]) and i+k<len(Matrix):
                rowSE = isSymbol(Matrix[i+k][j+k])
            if rowS and i+k<len(Matrix):
                rowS = isSymbol(Matrix[i+k][j])
            if rowSW and j-k>=0 and i+k<len(Matrix):
                rowSW = isSymbol(Matrix[i+k][j-k])
        
        if rowE or rowSE or rowS or rowSW:
            return True
        else:
            return False
    
    
    for i in range(len(Matrix)):
        for j in range(len(Matrix[i])):
            if isSymbol(Matrix[i][j]):
                isrow = CheckRows(i,j)
                if isrow:
                    return isrow
    
    return False

print("Player1 has winning row: "+repr(CheckWinner(Matrix,player1symbol)))
print("Player2 has winning row: "+repr(CheckWinner(Matrix,player2symbol)))
print("Neutral has winning row: "+repr(CheckWinner(Matrix,neutralsymbol)))

注意，为了节省一点时间，我们只检查每个单元格是否启动一个获胜的行，因为当从左到右，从上到下，我们将保证首先命中一行的起始单元格。另外，我们只检查8种可能的主要方向中的4种，因为其他4种是不需要的(我们检查的4种已经包括在内)。

我相信你可以清理更多的代码，但这只是一个概念的证明。