我正在尝试制作一个看起来像这样的三角形
10
11 12
13 14 15
16 17 18 19
20 21 22 23 24
25 26 27 28 29 30
31 32 33 34 35 36 37
38 39 40 41 42 43 44 45
46 47 48 49 50 51 52 53 54
我试图使用两个for循环，一个嵌套。这和我到目前为止一样接近。
for j in range(11):
print(end='\n')
for i in range(j+1):
print(i+j,'',end='')
print(end='\n')
我很确定我需要创建一个变量，但不确定如何将它合并到循环中。
答案 0 :(得分：2)
如此短而简单如何：
k=10
for i in range(9):
for j in range(i+1):
print(k, end='')
k+=1
print('')
答案 1 :(得分：2)
你走了：
>>> a=range(10, 55)
>>> for i in range(10):
... print(' '.join(repr(e) for e in a[:i+1]))
... a = a[i+1:]
...
10
11 12
13 14 15
16 17 18 19
20 21 22 23 24
25 26 27 28 29 30
31 32 33 34 35 36 37
38 39 40 41 42 43 44 45
46 47 48 49 50 51 52 53 54
答案 2 :(得分：1)
我喜欢Maelstrom简短而又甜蜜的回答，但如果你想以数学的方式看待它，你可能会做这样的事情：
>>> for i in range(1, 10):
... j = 10 + i * (i - 1) // 2
... print(*range(j, j + i)) # This line edited per lvc's comment
...
10
11 12
13 14 15
16 17 18 19
20 21 22 23 24
25 26 27 28 29 30
31 32 33 34 35 36 37
38 39 40 41 42 43 44 45
46 47 48 49 50 51 52 53 54
答案 3 :(得分：1)
这是另一个基于循环的解决方案：
number = 10
for line_length in range(9):
print(*range(number, number + line_length + 1))
number += line_length + 1
，并提供：
10
11 12
13 14 15
16 17 18 19
20 21 22 23 24
25 26 27 28 29 30
31 32 33 34 35 36 37
38 39 40 41 42 43 44 45
46 47 48 49 50 51 52 53 54
答案 4 :(得分：0)
使用一个变量来跟踪当前的数字，并使用一个变量来跟踪您所在的层
num = 10;
tier = 1;
tiers = 10;
for i in range(tiers):
for j in range(tier):
print(num + " ");
num = num + 1;
print("\n");
tier = tier + 1
答案 5 :(得分：0)
您可以通过更改triangle_height调整print_number变量和起始元素来更改三角高度。
print_number = 10
triangle_height = 9
for level_element_count in range(triangle_height):
print('\n')
while level_element_count > -1:
print(print_number, '', end='')
print_number += 1
level_element_count -= 1
print('\n')
答案 6 :(得分：0)
试试这个
counter = 10
for i in range(10):
output = ""
for j in range(i):
output = output + " " + str(counter)
counter += 1
print(output)
输出：
10
11 12
13 14 15
16 17 18 19
20 21 22 23 24
25 26 27 28 29 30
31 32 33 34 35 36 37
38 39 40 41 42 43 44 45
46 47 48 49 50 51 52 53 54
<强>解释
第一个循环控制三角形的宽度，第二个循环控制内容，从而控制高度。我们需要将整数转换为字符串并连接。我们在第二个循环的每次迭代中在字符串变量中创建适当的输出，然后在它完成后显示它。关键是根据第一个循环迭代第二个循环，即尽可能多地循环它
答案 7 :(得分：0)
只是为了好玩。
这与将给定序列（此处为10到54之间的数字）划分为非重叠“窗口”的常见模式有关，例如，一次对10个值进行一些分析。这里的扭曲是每个窗口比最后一个窗口大一个元素。
这看起来像是itertools的工作！
import itertools as it
def increasing_windows(i, start=1, step=1):
'''yield non-overlapping windows from iterable `i`,
increasing in size from `start` by `step`.
'''
pos = 0
for size in it.count(start, step):
yield it.islice(i, pos, pos+size)
pos += size
for line in it.islice(increasing_windows(range(10, 55)), 9):
print(*line)
答案 8 :(得分：0)
不需要嵌套循环：
a = range(10, 55)
flag = 0
current = 0
for i, e in enumerate(a):
print e,
if flag == i:
current += 1
flag = i + 1 + current
print '\n',
答案 9 :(得分：0)
你可以写一个发电机：
def number_triangle(start, nrows):
current = start
for length in range(1, nrows+1):
yield range(current, current+length)
current += length
>>> for row in number_triangle(10, 9):
... print(*row)
10
11 12
13 14 15
16 17 18 19
20 21 22 23 24
25 26 27 28 29 30
31 32 33 34 35 36 37
38 39 40 41 42 43 44 45
46 47 48 49 50 51 52 53 54
>>> for row in number_triangle(1, 12):
... print(*row)
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31 32 33 34 35 36
37 38 39 40 41 42 43 44 45
46 47 48 49 50 51 52 53 54 55
56 57 58 59 60 61 62 63 64 65 66
67 68 69 70 71 72 73 74 75 76 77 78
或者您可以拥有一个无限的生成器并将其留给调用者来控制要生成的行数：
def number_triangle(start=0):
length = 1
while True:
yield range(start, start+length)
start += length
length += 1
>>> nt = number_triangle()
>>> for i in range(15):
... print(*next(nt))
0
1 2
3 4 5
6 7 8 9
10 11 12 13 14
15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30 31 32 33 34 35
36 37 38 39 40 41 42 43 44
45 46 47 48 49 50 51 52 53 54
55 56 57 58 59 60 61 62 63 64 65
66 67 68 69 70 71 72 73 74 75 76 77
78 79 80 81 82 83 84 85 86 87 88 89 90
91 92 93 94 95 96 97 98 99 100 101 102 103 104
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119