1

我想知道你能不能帮帮我。我正在尝试在 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）？

4

3 回答 3

6

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

始终将问题分解为可消化的部分。每条线都是自己的一面镜子，所以让我们先处理一下我们需要的一组数字。

这会生成一个字符串列表，其中包含两个的所有幂，这就是它正在生成的内容

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

现在缓冲每一行，我们将创建一个新数组，我们将从中打印。通过zip()将行和缓冲区结合在一起，我们可以轻松地将 ( String.rjust()) 数字字符串右对齐，扩展到所需的长度。

  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:]))

输出：

                   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
于 2013-10-02T06:04:45.027 回答
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
于 2013-10-02T05:51:55.997 回答
1

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

  • 生成两个数的幂作为系列
  • 找到每行需要添加的偏移量
  • 在打印回文列表之前打印每一行的空白区域。
  • IE。(offset * (n - i)) 乘以 " "(空格)
  • 通过切片操作构建回文序列，即。温度 + 温度[::-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
于 2013-10-02T09:10:09.773 回答