Python 巨蟒迷幻游戏

我正在尝试完成这个学校的boggle游戏Python挑战，我创建了一个draw board函数，它创建了一个包含16个随机字母的棋盘。如何使用def函数要求用户输入一个单词，然后根据单词的长度对其进行评分？一旦完成，游戏应该可以正常运行。任何帮助都将不胜感激：）

---

我没有在myslef上玩过很多boggle，但是你可以使用一个解决方案来实现这一点，即获取用户输入的单词，并使用

len（）

命令返回单词的长度。然后取那个长度并得分。下面是一个基本示例（根据游戏规则进行修改）：

raw_input

（在Python 2中）或

input

（在Python 3中）允许读取字符串

然后你需要检查字母表中是否包含所有字母

def wordInLetter(word, letters):
    for i in range(word):
        if word[i] not in letters:
             return False
    return True

或更短：

def wordInLetter(word, letters):
    return all(letter in letters for letter in word)

但是等等，你不想让一个字母被多次使用

让我们使用

计数器

跟踪每个信件在信袋中的次数，并从中开始计算：

from collections import Counter
def wordInLetter(word, letters):
    available = Counter(letters)
    for letter in word:
        if available[letter] == 0:
             return False
        available[letter] -= 1
    return True

这似乎很有效。我希望这就是你需要的

In [3]: wordInLetter('kos','akos')
Out[3]: True

In [4]: wordInLetter('kos','ako')
Out[4]: False

In [5]: wordInLetter('koss','akos')
Out[5]: False

---

编辑

因此，我们不仅关心

word

是否可以组合成

字母

，还想知道是否可以通过匹配相邻字母来实现。那么再试试：

import math
def wordInLetterSearch(word, letters, startX, startY):
    # Assume: letters is a list of X letters, where X is a k*k square
    k = int(len(letters) ** 0.5)

    if len(word) == 0:
        return True

    def letter(x, y):
        return letters[x + y*k]

    def adjacent(x, y):
        if x > 0:
           yield x-1, y
        if x < k-1:
           yield x+1, y
        if y > 0:
           yield x, y-1
        if y < k-1:
           yield x, y+1

    # try to move in all 4 directions
    return any(letter(x2, y2) == word[0] and wordInLetterSearch(word[1:], letters, x2, y2)
               for x2, y2 in adjacent(startX, startY))

def wordInLetter(word, letters):
    k = int(len(letters) ** 0.5)

    def coords(i):
        return i%k, i/k

    # look for a starting point
    return any(letter == word[0]
                    and wordInLetterSearch(word[1:], letters,
                                           coords(i)[0], coords(i)[1])
               for i, letter in enumerate(letters)) coords(i)[1])
                   for i, letter in enumerate(letters))

导入数学
def wordInLetterSearch（单词、字母、startX、startY）：
#假设：字母是X个字母的列表，其中X是k*k正方形
k=整数（长（字母）**0.5）
如果len（word）==0：
返回真值
定义字母（x，y）：
回信[x+y*k]
def相邻（x，y）：
如果x>0：
产量x-1，y
如果x0：
产量x，y-1
如果y

这有点复杂。基本上，这是一个两步搜索：首先，我们寻找一个起点（字母内部的一个位置，字母与单词的第一个字符匹配），然后我们尽可能递归地将snake-like移动到相邻字段

只需少量修改即可精确匹配Boggle规则：

• 修改相邻的

  ，
  以允许使用对角线（简单）

• 禁止访问同一地点两次（中等；提示：向

  wordInLetterSearch

  添加一个参数，使用

  设置

  ）

---

我将把这些留作练习。

这里是另一个变体。它应该更容易阅读，但思想是一样的：简单。有时，在调用者端中止迭代更容易（不，不执行下一步），有时在调用者端中止迭代（在每次迭代中，检查前提条件，如果无效则中止）

def wordinboarder（字母、单词、x、y）：
n=整数（长（字母）**0.5）
如果word==“”：返回True#空-找到所有字母
如果x=n：返回False#板外
如果字母[x+y*n]！=word[0]：return False#我们看错了位置
#进一步：
返回任意（单词boarditer（字母，单词[1:]，x+dx，y+dy）表示dx，dy在[（1,0），（0,1），（-1,0），（0，-1）]中）
def单词内侧（字母、单词）：
n=整数（长（字母）**0.5）
返回范围（n）内x的any（any（wordnboarditer（字母，单词，x，y））范围（n）内y的any）
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
字母=['a'、'h'、'e'、'l'，
“x”、“d”、“l”、“l”，
‘y’、‘v’、‘r’、‘o’，
‘z’、‘w’、‘o’、‘w’]
打印“hello:%s”（“找到”如果字在黑板上（字母，“hello”）否则“找不到”）
打印“helloworld:%s”（“找到”如果字在板内（字母，“helloworld”）否则“找不到”）
打印“foobar:%s%”（如果是内置字（字母，“foobar”）则为“已找到”，否则为“未找到”）

---

在这个版本中有相同的练习（对角线平铺和禁止重复使用相同的字母两次）

因此，用户输入一个单词，然后检查它是否在字典中-但这不是最难的部分吗-即，确保输入的单词确实可以从黑板上拼凑出来？我不知道你的意思，我有一个外部文件来访问一大串单词，然而，我不知道如何保存点数并让用户输入网格中的单词。这是一个很好的开始，但稍微复杂一点（从Wiki）.：

每个玩家都会搜索可以从顺序相邻立方体的字母构造的单词，其中“相邻”立方体是水平排列的，垂直或对角相邻。单词必须至少有三个字母长，可以分别包括单数和复数（或其他派生形式），但每个单词不能使用同一个字母立方体超过一次。[snip]

哦，看起来我描述的是拼字游戏。我将扩展到这些规则。我希望我们现在到家了。

In [3]: wordInLetter('kos','akos')
Out[3]: True

In [4]: wordInLetter('kos','ako')
Out[4]: False

In [5]: wordInLetter('koss','akos')
Out[5]: False

import math
def wordInLetterSearch(word, letters, startX, startY):
    # Assume: letters is a list of X letters, where X is a k*k square
    k = int(len(letters) ** 0.5)

    if len(word) == 0:
        return True

    def letter(x, y):
        return letters[x + y*k]

    def adjacent(x, y):
        if x > 0:
           yield x-1, y
        if x < k-1:
           yield x+1, y
        if y > 0:
           yield x, y-1
        if y < k-1:
           yield x, y+1

    # try to move in all 4 directions
    return any(letter(x2, y2) == word[0] and wordInLetterSearch(word[1:], letters, x2, y2)
               for x2, y2 in adjacent(startX, startY))

def wordInLetter(word, letters):
    k = int(len(letters) ** 0.5)

    def coords(i):
        return i%k, i/k

    # look for a starting point
    return any(letter == word[0]
                    and wordInLetterSearch(word[1:], letters,
                                           coords(i)[0], coords(i)[1])
               for i, letter in enumerate(letters)) coords(i)[1])
                   for i, letter in enumerate(letters))

def wordInBoardIter(letters, word, x, y):
    n = int(len(letters)**0.5)
    if word == "": return True # empty - all letters are found
    if x<0 or y<0 or x>=n or y>= n: return False #outside of board
    if letters[x+y*n] != word[0]: return False # we are looking at the wrong position
    # one step further:
    return any(wordInBoardIter(letters, word[1:], x+dx,y+dy) for dx,dy in [(1,0), (0,1), (-1,0), (0,-1)])


def wordInBoard(letters, word):
    n = int(len(letters)**0.5)
    return any(any(wordInBoardIter(letters, word, x,y) for x in range(n)) for y in range(n))

if __name__ == '__main__':
    letters = ['a', 'h', 'e', 'l',
               'x', 'd', 'l', 'l',
               'y', 'v', 'r', 'o',
               'z', 'w', 'o', 'w']
    print "hello     : %s" % ("found" if wordInBoard(letters, "hello") else "not found")
    print "helloworld: %s" % ("found" if wordInBoard(letters, "helloworld") else "not found")
    print "foobar    : %s" % ("found" if wordInBoard(letters, "foobar") else "not found")