0

我正在创建一个单词搜索求解器，需要一种方法来旋转列表中的单词搜索，所以左下角是“顶部”，右下角是“底部”

我有这个：

 Puzzle = ["FUNCTIONRRIRAI",
              "RAIOONFRCCPWON",
              "PTCSNOBEUITOLO",
              "BNCACIANTOSLIH",
              "RBYOLILYNREFBT",
              "HYYNOGESTIBRIY",
              "AATTSIONCMCENP",
              "UORTENRRCBFVAU",
              "CEBEECVWIERORI",
              "PROCESSORTOPYF",
              "OHCOMPUTERHSOS",
              "YCYPRESREOSMRW",
              "OATHBRMVTHHCTR",
              "PGORWOOUIPSCHP"]

我需要它的形成：

Puzzle = ["F","RU","PAN","BTIC",...]

所以看起来这个词搜索已经旋转了45度

任何建议/帮助将不胜感激

find_horizo​​ntal 和要查找的单词的代码：

def load_words_to_find(file_name):
    word_list = []
    file = open(file_name, "r")
    for line in file.readlines():
        word_list.append(line)
    word_list = list(map(lambda s: s.strip(), word_list))
    return word_list


def find_horizontal(Puzzle, Words, ReplaceWith, Found):
    # Parameters :- List:Puzzle, List:Words, Character:ReplaceWith, List:Found
    # Return :- List:Outpuz, List:Found
    # Find all words which are horizontally in place (left to right and right to left), return the puzzle and list of found words
    rev = ''
    Outpuz = Puzzle

    for line in Puzzle:
        rev = line[::-1]

        for word in Words:

            if word in line:
                Found.append(word)
                Puzzle[Puzzle.index(line)] = line.replace(word, ReplaceWith * len(word))
            if word in rev:
                Found.append(word)
                Puzzle[Puzzle.index(line)] = line.replace(word[::-1], ReplaceWith * len(word))
            else:
                pass

    print("Found: ", Found)
    print(Outpuz)

    return Outpuz, Found


find_horizontal(Puzzle, load_words_to_find("words.txt"), ".", [])
4

4 回答 4

3

有点傻，但是您可以将字符串迭代器插入列表的前面，然后加入并从每个迭代器中产生下一个字符。

rows = [
    "FUNCTIONRRIRAI",
    "RAIOONFRCCPWON",
    "PTCSNOBEUITOLO",
    "BNCACIANTOSLIH",
    "RBYOLILYNREFBT",
    "HYYNOGESTIBRIY",
    "AATTSIONCMCENP",
    "UORTENRRCBFVAU",
    "CEBEECVWIERORI",
    "PROCESSORTOPYF",
    "OHCOMPUTERHSOS",
    "YCYPRESREOSMRW",
    "OATHBRMVTHHCTR",
    "PGORWOOUIPSCHP"
]

def get_next_diagonal(rows):

    iters = []
    for row in rows:
        iters.insert(0, iter(row))
        yield "".join(next(it, "") for it in iters)
    while iters[0].__length_hint__():
        yield "".join(next(it, "") for it in iters)

for diagonal in get_next_diagonal(rows):
    print(diagonal)

输出：

F
RU
PAN
BTIC
RNCOT
HBCSOI
AYYANNO
UAYOCOFN
COTNLIBRR
PERTOIAECR
ORBTSGLNUCI
YHOEEIEYTIPR
OCCCENOSNOTWA
PAYOECRNTRSOOI
GTPMSVRCIELLN
OHRPSWCMBFIO
RBEUOIBCRBH
WRSTREFEIT
OMRETRVNY
OVEROOAP
UTOHPRU
IHSSYI
PHMOF
SCRS
CTW
HR
P
于 2020-02-25T20:24:43.737 回答
2

为缺乏效率而道歉，但这是我的快速解决方案。

我们将网格视为一组坐标。此解决方案基于这样一个事实，即您想要的输出中的每个项目都将具有 X 和 Y 坐标而不是加起来一定数量。例如，第一项“F”的位置为 (0,0)，总和为 0。后两项“RU”位于广告 (1,0) 和 (0,1)，两者相加为 1。第三行“PAN”的字母位于 (0,2)、(1,1) 和 (2,0)，依此类推。在我的解决方案中用“i”跟踪这个数字，它需要足够大才能向下扫描列表，所以这是数组长度的两倍。因此，我们扫描列表以查找位于 x 和 y 坐标的项目，其中 x+y==i。

代码：

Puzzle = ["FUNCTIONRRIRAI",
      "RAIOONFRCCPWON",
      "PTCSNOBEUITOLO",
      "BNCACIANTOSLIH",
      "RBYOLILYNREFBT",
      "HYYNOGESTIBRIY",
      "AATTSIONCMCENP",
      "UORTENRRCBFVAU",
      "CEBEECVWIERORI",
      "PROCESSORTOPYF",
      "OHCOMPUTERHSOS",
      "YCYPRESREOSMRW",
      "OATHBRMVTHHCTR",
      "PGORWOOUIPSCHP"]

output = []
i = 0
while i < len(Puzzle)*2:
    single_string = ""
    for y in range(0,len(Puzzle)):
        for x in range(0,len(Puzzle[0])):
            if (x + y) == i:
                single_string += Puzzle[x][y]
    if single_string != "":
        output.append(single_string)
    i += 1

print(output)

输出

['F',
 'RU',
 'PAN',
 'BTIC',
 'RNCOT',
 'HBCSOI',
 'AYYANNO',
 'UAYOCOFN',
 'COTNLIBRR',
 'PERTOIAECR',
 'ORBTSGLNUCI',
 'YHOEEIEYTIPR',
 'OCCCENOSNOTWA',
 'PAYOECRNTRSOOI',
 'GTPMSVRCIELLN',
 'OHRPSWCMBFIO',
 'RBEUOIBCRBH',
 'WRSTREFEIT',
 'OMRETRVNY',
 'OVEROOAP',
 'UTOHPRU',
 'IHSSYI',
 'PHMOF',
 'SCRS',
 'CTW',
 'HR',
 'P']

希望这可以帮助。如果需要，很高兴澄清任何事情

于 2020-02-25T20:14:01.130 回答
0

我发现在两个循环中生成索引更容易和更清晰，从第一列开始沿着行向下，然后从最后一行开始沿着列：

puzzle = ['FUNCTIONRRIRAI',
 'RAIOONFRCCPWON',
 'PTCSNOBEUITOLO',
 'BNCACIANTOSLIH',
 'RBYOLILYNREFBT',
 'HYYNOGESTIBRIY',
 'AATTSIONCMCENP',
 'UORTENRRCBFVAU',
 'CEBEECVWIERORI',
 'PROCESSORTOPYF',
 'OHCOMPUTERHSOS',
 'YCYPRESREOSMRW',
 'OATHBRMVTHHCTR',
 'PGORWOOUIPSCHP']

nrows = len(puzzle)
ncols = len(puzzle[0])
output = []
for ir in range(nrows):
    row = []
    ic = 0
    jr = ir
    while jr >= 0:
        row.append(puzzle[jr][ic])   
        ic += 1
        jr -= 1
    output.append(''.join(row))
for ic in range(1, ncols):
    row = []
    ir = nrows - 1
    jc = ic
    while jc < ncols:
        row.append(puzzle[ir][jc])
        ir -= 1
        jc += 1
    output.append(''.join(row))

for row in output:
    print(row)

输出：

F
RU
PAN
BTIC
RNCOT
HBCSOI
AYYANNO
UAYOCOFN
COTNLIBRR
PERTOIAECR
ORBTSGLNUCI
YHOEEIEYTIPR
OCCCENOSNOTWA
PAYOECRNTRSOOI
GTPMSVRCIELLN
OHRPSWCMBFIO
RBEUOIBCRBH
WRSTREFEIT
OMRETRVNY
OVEROOAP
UTOHPRU
IHSSYI
PHMOF
SCRS
CTW
HR
P
于 2020-02-26T08:43:36.850 回答
0

主题的变化 - 生成对角线索引。
如果您沿着左边缘向下移动手指，则这些是上半部分对角线的起点，而在底部边缘上追踪您的手指则是下半部分对角线的起点。

上半部分：
从每个对角线的起点开始，第一个维度的索引范围从起点到零（负步长），第二个维度的索引范围从零到第二维长度的最大值（正步长）。

下半部分：
从每个对角线的起点开始，第一个维度的索引范围从第一个维度的长度减一到最小值为零（负步长），第二个维度的索引范围从起点到第二个维度的长度（积极的步骤）。

对于这两组对角线，您可以利用在最短迭代用完时 zip将停止的事实。

def cw(dims,ragged=False):
    '''Generate indices for diagonals based on dims.

       dims --> tuple: (nrows,ncolumns)

       Currently only implemented for all rows have same number of columns
       Diagonals as if the rectangle was rotated CW 45 degrees
       bottom-left to upper-right
    '''
    if ragged: raise NotImplementedError
    nrows,ncolumns = dims
    # top half
    index1 = range(0,ncolumns)
    for i in range(nrows):
        yield zip(range(i,-1,-1),index1)
    # bottom half
    index0 = range(nrows-1,-1,-1)
    for i in range(1,nrows):
        yield zip(index0,range(i,ncolumns))

new = []    
for diagonal in cw((len(Puzzle),len(Puzzle[0]))):
    new.append(''.join(Puzzle[j][k] for (j,k) in diagonal))

和逆时针旋转解决方案

def ccw(dims,ragged=False):
    '''Generate indices for diagonals based on dims.

       dims --> tuple: (nrows,ncolumns)

       Currently only implemented for all rows have same number of columns
       Diagonals as if the rectangle was rotated CCW 45 degrees
            top-left to bottom-right
    '''
    if ragged: raise NotImplementedError
    nrows,ncolumns = dims
    # top half
    index0 = range(0,nrows)
    for i in range(ncolumns,-1,-1):
        yield zip(index0,range(i,ncolumns))
    # bottom half
    index1 = range(0,ncolumns)
    for i in range(1,nrows):
        yield zip(range(i,nrows),index1,)
于 2020-02-26T00:26:04.607 回答