Question

我想知道你是否可以帮助我。我正在尝试在Python 3中编写一个嵌套的for循环，它显示一个看起来像的数字金字塔;

                              1
                         1    2   1
                     1   2    4   2   1
                 1   2   4    8   4   2   1
             1   2   4   8   16   8   4   2  1
          1  2   4   8  16   32  16   8   4  2  1
       1  2  4   8  16  32   64  32  16   8  4  2  1
    1  2  4  8  16  32  64  128  64  32  16  8  4  2  1

有人可以帮帮我吗？非常感谢！

这是我到目前为止所做的：

col = 1

for i in range(-1, 18, col*2):        

    for j in range(1, 0, 1):
        print("  ", end = "")

    for j in range(i, 0, -2):
        print(j, end = " ")

    print()

所以，我只能显示金字塔的一半。

我想我遇到的主要问题是：

如何让输出显示增加值然后减小的值（即1,2,4,2,1）？

Answer 1

使用列表推导的另一种方法。

始终将问题分解为可消化的块。每一行都是自己的镜像，所以我们先处理一下我们需要的数字。

这会生成一个字符串列表，其中包含所有2的幂，这就是生成

的内容

lines = []
for i in range(1,9):
  lines.append([str(2**j) for j in range(i)])

但是如果我们只是打印这个列表，a）它只会有一半，而b）它会将数字混合在一起。我们需要用空格缓冲数字。幸运的是，最后一行将包含任何列的最大数字，因此：

首先，每一行最终需要多长时间（我们稍后需要），以及每列中最长的数字是多少。当我们将数字转换为上面的字符串时，我们可以使用len。

b = len(lines[-1])
buffers = [len(x) for x in lines[-1]]

现在我拥有打印字符串所需的一切（我们停止使用上面的数字）：

因此，对于每一行，找出它的长度，并通过用空字符串填充数组的左边将数组扩展到最长行的长度（为此我们仍假装我们只是打印三角形的左半部分）：

for line in lines:
  l = len(line)
  line = [" "]*(b-len(line)) + line

现在每条线都被缓冲，我们将制作一个我们将要打印的新阵列。通过{{1}将线和缓冲区放在一起，我们可以轻松地对齐（String.rjust()）个数字字符串，扩展到所需的长度。

zip()

直到现在，我们仍然只是在金字塔的左半边工作。所以我们取输出数组，反转它（

  out = []
  for x,y in zip(line,buffers):
    out.append(x.rjust(y))

），然后取第一个（array[::-1]）的每一个元素，并将它们与一个字符串连接起来并打印出来。

array[1:]

瞧！完成的代码：

  print(" ".join(out+out[::-1][1:]))

输出：

lines = []
for i in range(1,9):
  lines.append([str(2**j) for j in range(i)])

b = len(lines[-1])
buffers = [len(x) for x in lines[-1]]

for line in lines:
  l = len(line)
  line = [" "]*(b-len(line)) + line
  out = []
  for x,y in zip(line,buffers):
    out.append(x.rjust(y))
  print(" ".join(out+out[::-1][1:]))

Answer 2

height = 8
maxHeight = height - 1
for i in range(height):
    k, Max = 1, i * 2 + 1
    print(maxHeight * "     ", end="")
    maxHeight -= 1
    for j in range(Max):
        print("%5d" % k, end="")
        if (j < (Max // 2)):
            k *= 2
        else:
            k //= 2
    print()

<强>输出：

                                   1
                              1    2    1
                         1    2    4    2    1
                    1    2    4    8    4    2    1
               1    2    4    8   16    8    4    2    1
          1    2    4    8   16   32   16    8    4    2    1
     1    2    4    8   16   32   64   32   16    8    4    2    1
1    2    4    8   16   32   64  128   64   32   16    8    4    2    1

Answer 3

这可能是其他9行解决方案。

以系列
找到需要在每行中添加的偏移量
在打印回文列表之前打印每行的空白区域。
IE中。（偏移*（n - i））次＆＃34; ＆＃34;（空白区域）
通过切片操作构建回文序列，即。 temp + temp [:: - 1] [1：]
打印回文序列并相对于您要打印的数字长度偏移空格。

代码：

n = 8
numbers = [2**x for x in range(n)]                 # Generate interseted series.
offset = len(str(numbers[-1:])) -1                 # Find the max offset for the tree.
for i in range(1, n+1):                            # Iterate n times. 1 to n+1 helps eazy   slicing.
  temp = numbers[:i]                               # Slice series to get first row numbers.
  print(' ' * (offset * (n - i)), end=" ")         # Prefix spaces, multiples of offset.
  for num in temp + temp[::-1][1:]:                # Generate palindromic series for the row.
    print(num, end=" " * (offset - len(str(num)))) # Adjust offset for the number.
  print('')

输出：

                             1   
                         1   2   1   
                     1   2   4   2   1   
                 1   2   4   8   4   2   1   
             1   2   4   8   16  8   4   2   1   
         1   2   4   8   16  32  16  8   4   2   1   
     1   2   4   8   16  32  64  32  16  8   4   2   1   
 1   2   4   8   16  32  64  128 64  32  16  8   4   2   1

数字金字塔嵌套循环

3 个答案:

瞧！完成的代码：