Python 如何识别填字游戏中的非法输出？

我试图让程序识别纵横字谜中的非法输出。到目前为止，我的程序可以水平和垂直地打印纵横字谜中的单词，但它也会将非法输出的单词添加到纵横字谜中。我试图让程序把非法输出放在其他地方，如果不能放在其他地方，跳过它。非法输出的示例如下所示

我的输出：水平添加的单词“prove”将是非法输出，因为它创建了单词“dr”、“do”、“lv”和“ee”；垂直添加的单词“no”将是非法输出，因为它水平添加了额外的单词“no”

            a d d l e               
            p r o v e               
            p                       
            r                       
        c l o w n i n g             
            v     n o               
            e     c
                  l
                  i
                  n
                  e

我的代码：

def printboard(board):
print('--------------------')
for i in range(len(board)):
    for j in range(len(board)):
        print(board[i][j], end = ' ')
    print()
print('--------------------')
blank= ' '
board = [[blank]*20 for i in range(20)]

def firstword(board, word):
D = len(board)
n = len(word)
if n > D:
    return False
else:
    for k in range(n):
        column = D//2-n//2+k
        board[D//2][column] = word[k]
    return True

def checkVertical(board, word, row, col):
D = len(board)
n = len(word)
blank = ' '
if n>(20-row):
    return False
matchesoneletter = False
for k in range(n):
    wordletter = word[k]
    boardletter = board[row + k][col]
    if wordletter == boardletter:
        matchesoneletter = True
    if boardletter == blank:
        continue
    elif boardletter != wordletter:
        return False
return matchesoneletter


def addVertical(board, word):
for i in range(len(board)):
    for j in range(len(board)):
        if checkVertical(board, word, i, j):
            for k in range(len(word)):
                board[i + k][j] = word[k]
            return True 
return False

def checkhorizontal(board, word, row, col):
D = len(board)
n = len(word)
blank = ' '
if n >(20-col):
    return False
matchesoneletter = False
for k in range(n):
    wordletter = word[k]
    boardletter = board[row][col+k]
    if wordletter == boardletter:
        for a in range(n):
            new_col = col + k
        matchesoneletter = True
    if boardletter == blank:
        continue
    elif boardletter != wordletter:
        return False
return matchesoneletter

def addHorizontal(board, word) :
for i in range(len(board)):
    for j in range(len(board)):
        if checkhorizontal(board, word, i, j):
            for k in range(len(word)):
                board[i][j+k] = word[k]
            return True 
return False

firstword(board, "clowning")
addVertical(board, "approve")
addHorizontal(board, "addle")
addHorizontal(board, "prove")
printboard(board)

---

这不是一个微不足道的问题，更不用说一个容易解释堆栈溢出的问题了。然而，在大学里，我碰巧也为一个拼字游戏AI代理做了同样的事情。我们使用了大约3种方法来验证单词的位置。基本上，您必须查看新放置单词周围的每一行/列，并使用

word\u验证

lookup dict或其他方法验证这些行/列

这就是问题所在。你可以随意翻找和窃取任何你想要的代码。我要警告你，由于我们正争先恐后地完成这项工作，所以没有很好的记录

编辑：根据评论中的请求，这里是上面链接的基本代码，以防被删除。我要警告你，要理解上下文已经够难了，所以如果你在阅读本文时链接是有效的，那么我建议你遵循它

    def validate_move(self, word, indices, agent_id, state): # this will need to take in game state

        agent = state.agents[agent_id]
        #Check if agent has required tiles to form a word
        required_tiles = Counter([word[i] for i, index in enumerate(indices) if word[i] != state.board[index]])

        for tile in required_tiles:
            if agent.tiles[tile] < required_tiles[tile]:
                return False

        # Check if all created words are valid
        created_words = self.get_created_word_indices(word, indices, agent_id = agent_id, state = state)
        # return created_words

        for (word, indices) in created_words:
                if not self.valid_word(word):
                    return False

        return True

    def get_created_word_indices(self, word, indices, agent_id, state):
        '''Returns the indices of all newly createds from placing a word in a position'''

        size = self.size
        new_board = state.place(word, indices, agent_id = agent_id, scrabble_rules = self, mock = True)
        hor_grids = [((x, max(indices, key = lambda x: x[1])[1]), [(x, y) for y in range(size)])
                     for x in set([i[0] for i in indices])]
        ver_grids = [((max(indices, key = lambda x: x[0])[0], y),  [(x, y) for x in range(size)])
                     for y in set([i[1] for i in indices])]

        # I am so sorry to whoever has to read this nested, nested, nested listcomp. Buet we needed to make this fast tho...
        affected_indices = [grid[min(ind for ind, board_ind  in enumerate(grid)
                                 if all([new_board[test_ind] for test_ind in grid[ind: grid.index(max_played_ind) + 1]])):
                                 max(ind for ind, board_ind  in enumerate(grid)
                                     if all([new_board[test_ind] for test_ind in grid[grid.index(max_played_ind): ind + 1]])) + 1]
                            for max_played_ind, grid in hor_grids + ver_grids]

        word_indices = [indices for indices in affected_indices if state.unplayed_indices(indices) if len(indices) > 1]
        return [(''.join([new_board[ind] for ind in indices]), indices) for indices in word_indices]

    def valid_word(self, word):
        return self.trie.has_key(word.upper())

def validate_move（self、word、index、agent_id、state）：#这需要在游戏状态下进行
agent=state.agent[agent\u id]
#检查代理是否要求瓷砖形成单词
必需的_tiles=计数器（[word[i]表示i，如果word[i]！=state.board[index]]，则在枚举（索引）中索引）
对于所需瓷砖中的瓷砖：
如果agent.tiles[tile]<必需的\u tiles[tile]：
返回错误
#检查所有创建的单词是否有效
创建的单词=自我。获取创建的单词索引（单词，索引，代理id=代理id，状态=状态）
#返回创建的单词
对于已创建单词中的（单词、索引）：
如果不是自有效的单词（word）：
返回错误
返回真值
def get_created_word_索引（self、word、index、agent_id、state）：
''返回将单词放置在某个位置时新创建的所有单词的索引''
大小=自身大小
new_board=state.place（单词、索引、代理id=代理id、拼字规则=self、mock=True）
水平网格=[（（x，max（索引，键=λx:x[1]）[1]），[（x，y）表示范围内的y（大小）]）
对于集合中的x（[i[0]对于索引中的i]）]
垂直网格=[（最大（索引，键=λx:x[0]）[0]，y），[（x，y）表示范围内的x（大小）]）
对于集合中的y（[i[1]对于索引中的i]）]
#我很抱歉，任何人都必须阅读这个嵌套的，嵌套的，嵌套的listcomp。但是我们需要让这个快速的。。。
受影响的索引=[grid[min（ind代表ind，board_ind代表枚举（grid））
如果全部（[new_board[test_ind]用于网格中的测试索引[ind:grid.index（max_played_ind）+1]）：
最大值（ind的ind，枚举中的板索引（网格）
如果全部（[grid.ind中的测试索引的[new_board[test_ind]）+1]
对于max_played_ind，水平网格中的网格+垂直网格]
word_索引=[受影响_索引中的索引（如果状态为）。未显示的_索引（如果长度（索引）>1]
返回[（''.join（[new_board[ind]表示索引中的索引]），索引）表示单词索引中的索引]
def有效_字（self，word）：
return self.trie.has_键（word.upper（））

---

基本上，

validate\u move

是在游戏板上放置移动的入口点

get\u created\u word\u index

get被

validate\u move

调用，以获取通过放置任意单词创建的所有有效单词的列表。这就是你想模仿它的部分

valid_word

是一种使用称为trie的优化数据结构的简单查找。正如我所说的，这太复杂了，无法全面解释，但我希望这能有所帮助。

您的代码无法执行。请确保格式正确。欢迎使用StackOverflow。看见在您发布MRE代码并准确说明问题之前，我们无法有效地帮助您。我们应该能够将您发布的代码粘贴到文本文件中，并重现您指定的问题。我添加了“算法”标记：正如@Brian所说，这是一个非常重要的问题，但在现有算法的掌握范围内。有了这样的认识，我强烈建议你完成我们期望有人发布算法问题的研究：在线搜索纵横填字游戏中的算法。这是一项人类技能，可以追溯到拼图构建的早期，关于这个主题的文献足够多，你应该能够找到一些有用的东西。我搜索了算法，但它是用java语言编写的，我不熟悉java语言。另外，我想问的是如何将非法输出的单词放在网格的其他地方，或者如果不可能的话跳过它。虽然这个链接可以回答这个问题，但最好在这里包含答案的基本部分，并提供链接供参考。如果链接页面发生更改，仅链接的答案可能无效。-@jrook，这很公平。我考虑过发布代码，但决定不发布，因为代码与其他代码交织在一起，脱离上下文几乎毫无意义。我将为后人的sakeDo添加它，你知道如果没有面向对象编程，它会是什么样子吗？我还没学会yet@user12394062，这将是函数式编程中的一个难题。但在大多数情况下，这是一个具体的问题