Question

首先，这是我的代码：

row_1 = [3]
row_2 = [7, 4]
row_3 = [2, 4, 6]
row_4 = [8, 5, 9, 3]

for element in row_3:
    key = row_3.index(element)
    row_3[key] = element + max(row_4[key], row_4[key + 1])

for element in row_2:
    key = row_2.index(element)
    row_2[key] = element + max(row_3[key], row_3[key + 1])

for element in row_1:
    key = row_1.index(element)
    row_1[key] = element + max(row_2[key], row_2[key + 1])

print(row_1)

到目前为止，此代码有效。你可能会注意到，有很多重复，我想知道如何压缩它。理想情况下，我想要像

这样的东西

for element in row_x:
    key = row_x.index(element)
    row_x[key] = element + max(row_(x+1)[key], row_(x+1)[key + 1])

我知道这是完全错误的，但这正是我头脑中的错误。我非常感谢所有的见解。

哦，顺便说一下，这段代码最大化了金字塔中两个相邻数字的总和（见这里：http://projecteuler.net/problem=18）

Answer 1

这正是您所说的（消除循环重复）的翻译：

l = [[3],
     [7, 4],
     [2, 4, 6],
     [8, 5, 9, 3]]

for row in range(len(l)-2, -1, -1)
    for key, element in enumerate(l[row]):
        l[row][key] = element + max(l[row+1][key], l[row+1][key+1])

print(l[0][0])

你的错误是将三角形存储在不同的数据结构中，只需使用嵌套列表并迭代它。

此外，如果在迭代迭代时需要元素和索引，请使用enumerate函数。

由于range(start, end, step)从开始迭代到 end （不包括 end ），并且步骤是增量，range(range(len(l)-2, -1, -1)迭代，如＆＃34; len(l)-2 - ＆gt; len(l)-3 - ＆gt; ... - ＆gt; 1 - ＆gt; 0＆＃34 ;.请注意，我们希望包含0，因此我们将-1作为参数传递。 range函数和切片的良好助记符是＆＃34;您传递了想要的第一个参数，以及您不想要的第一个参数＆＃34;
另外，正如@ user2357112所说，元组打包 - 解包是Python的一个非常好的功能。基本上，当赋值的RHS是可迭代的时，您可以在LHS上使用元组，并相应地分配元素。你可以省略parantheses，还有更多的语法糖：

像：

In [1]: a, b, *c, d = range(5)

In [2]: a, b, d
Out[2]: (0, 1, 4)

In [3]: c
Out[3]: [2, 3]

你也可以在循环中使用解包：

In [1]: l = ["enumerate", "is", "a", "nice", "builtin"]

In [2]: list(enumerate(l))
Out[2]: [(0, 'enumerate'), (1, 'is'), (2, 'a'), (3, 'nice'), (4, 'builtin')]

In [3]: for i, v in enumerate(l):
   ...:     print(i, "->", v)
   ...:     
0 -> enumerate
1 -> is
2 -> a
3 -> nice
4 -> builtin

Answer 2

尝试将所有行放入列表中，然后反向迭代它们：

row_1 = [3]
row_2 = [7, 4]
row_3 = [2, 4, 6]
row_4 = [8, 5, 9, 3]

rows = [row_1, row_2, row_3, row_4]

for row_index, row in reversed(list(enumerate(rows[:-1]))):
  for key, elem in enumerate(row):
    lower_row = rows[row_index+1]
    row[key] = elem + max(lower_row[key], lower_row[key+1])

print rows[0]

Answer 3

此答案基于链接中的问题，而不是您的代码，因此它可能对您没有任何用处。

听起来像是一个“反向”Dijkstra的算法问题（Dijkstra的算法通常会寻找最短路径，而不是最大路径，并且通常应用于图形，但它可以根据您的金字塔进行调整。）
Dijkstra看起来像这样：

为每个节点分配一个暂定距离值：为我们的初始节点设置为零，为所有其他节点设置为无穷大。
标记未访问的所有节点。将初始节点设置为当前节点。创建一组未访问的节点，称为由所有节点组成的未访问集。
对于当前节点，考虑所有未访问的邻居并计算其暂定距离。将新计算的暂定距离与当前指定值进行比较，并指定较小的临时距离。例如，如果当前节点A标记为距离为6，并且将其与邻居B连接的边长度为2，则到B（通过A）的距离将为6 + 2 = 8.如果B先前为标记距离大于8然后将其更改为8.否则，保持当前值。
当我们考虑当前节点的所有邻居时，将当前节点标记为已访问并将其从未访问的集合中删除。永远不会再次检查访问过的节点。
如果目标节点已被标记为已访问（当计划两个特定节点之间的路由时）或未访问集中的节点之间的最小暂定距离是无穷大（计划完整遍历时;当有初始节点和剩余的未访问节点之间没有连接），然后停止。算法已经完成。选择标记有最小暂定距离的未访问节点，并将其设置为新的“当前节点”，然后返回步骤3.

这些步骤来自维基百科的Dijkstra's algorithm

Python重复列表

3 个答案: