1
00:00:00,000 --> 00:00:00,500

2
00:00:00,500 --> 00:00:02,640
陈ZAMYLA：这是一个，我，Zamyla。

3
00:00:02,640 --> 00:00:06,950
今天，我们要实现
马里奥，我们得出马里奥

4
00:00:06,950 --> 00:00:10,730
他一个完整的金字塔跳过。

5
00:00:10,730 --> 00:00:14,430
让我们打破
子任务针对此问题。

6
00:00:14,430 --> 00:00:17,930
>> 首先，我们要提示用户
对于金字塔的高度。

7
00:00:17,930 --> 00:00:20,510
然后，我们要确保
即该输入是有效的。

8
00:00:20,510 --> 00:00:23,280
然后，我们将
要绘制金字塔。

9
00:00:23,280 --> 00:00:26,850
>> 所以，让我们来谈谈提示
和验证用户输入。

10
00:00:26,850 --> 00:00:29,920
它可能看起来像
这一点，do-whil​​e循环的

11
00:00:29,920 --> 00:00:33,250
提示用户输入一个
整数，然后只重复

12
00:00:33,250 --> 00:00:35,700
如果该整数是无效的。

13
00:00:35,700 --> 00:00:38,220
所以，应该这个条件是什么？

14
00:00:38,220 --> 00:00:40,630
>> 对于这一点，让我们回到
到本说明书中。

15
00:00:40,630 --> 00:00:46,240
那么，规范告诉我们，任何有效
高度将是0和23之间，

16
00:00:46,240 --> 00:00:47,350
包括的。

17
00:00:47,350 --> 00:00:51,400
于是这意味着任何无效
高度将是小于0

18
00:00:51,400 --> 00:00:53,840
或超过23。

19
00:00:53,840 --> 00:00:57,220
>> 所以，现在，我们有这个信息，
让我们来设计我们的条件。

20
00:00:57,220 --> 00:00:59,230
但是，我们必须小心，
因为现在我们有

21
00:00:59,230 --> 00:01:02,130
我们要评估2布尔值。

22
00:01:02,130 --> 00:01:04,150
>> 在这里，我向您提供
用真值表。

23
00:01:04,150 --> 00:01:07,520
这使我们可以采取两种
布尔值，布尔一和二。

24
00:01:07,520 --> 00:01:13,600
而且我们可以评估要么BOOL1
和BOOL2或BOOL1或BOOL2。

25
00:01:13,600 --> 00:01:17,390
>> 所以，有什么区别
之间以及和或？

26
00:01:17,390 --> 00:01:21,810
那么，BOOL1和BOOL2会
计算结果为真当且仅

27
00:01:21,810 --> 00:01:25,680
如果两个布尔是真实的，
而或操作

28
00:01:25,680 --> 00:01:30,190
为真，如果任意一方
在布尔或无一不是如此。

29
00:01:30,190 --> 00:01:33,110
因此，考虑到这一点，
看看你能不能找出

30
00:01:33,110 --> 00:01:37,460
什么适当的条件
你对一个无效ñdo-whil​​e循环

31
00:01:37,460 --> 00:01:38,850
将是。

32
00:01:38,850 --> 00:01:43,540
>> 就这样，我们已经提示和确认
用户对于金字塔的高度

33
00:01:43,540 --> 00:01:44,550
他们想要的。

34
00:01:44,550 --> 00:01:47,740
所以，现在，它是由我们
绘制金字塔。

35
00:01:47,740 --> 00:01:50,520
完整的金字塔本
问题看起来有点

36
00:01:50,520 --> 00:01:56,340
这样，我们有一个左金字塔，
一些间隙，然后右金字塔。

37
00:01:56,340 --> 00:01:58,630
因此，让我们打破这一点。

38
00:01:58,630 --> 00:02:03,510
>> 如果我去我的文本编辑器，在这里，我
绘制我们左对齐金字塔。

39
00:02:03,510 --> 00:02:05,160
但是，这是不行的。

40
00:02:05,160 --> 00:02:10,139
我们想要做的是我们要
首先创建一个右对齐的金字塔。

41
00:02:10,139 --> 00:02:13,580
因此，要做到这一点，只是推
我沿着一边哈希，

42
00:02:13,580 --> 00:02:18,240
我只是把一些字符
在两者之间，只是这些点。

43
00:02:18,240 --> 00:02:22,560
然后，我打算把两个在
下一行，和一个在该行。

44
00:02:22,560 --> 00:02:26,070
所以，在这里我有一个
右对齐金字塔。

45
00:02:26,070 --> 00:02:28,540
>> 在那之后，我要去
回到最上面一行

46
00:02:28,540 --> 00:02:33,930
并把在间隙，这
是，每规范，两个空格。

47
00:02:33,930 --> 00:02:37,680
然后我会填写
金字塔的另一侧。

48
00:02:37,680 --> 00:02:42,030
我会去第二排，写
两个空格的差距，那么双

49
00:02:42,030 --> 00:02:42,920
哈希值。

50
00:02:42,920 --> 00:02:47,020
回到第三行，两个空间
对于缺口和三个哈希值。

51
00:02:47,020 --> 00:02:51,480
并在年底，两个空间
对于缺口和四个哈希值。

52
00:02:51,480 --> 00:02:54,400
所以，这就是一个完整的
金字塔的样子。

53
00:02:54,400 --> 00:02:57,260
>> 当然，我们不希望
这些点中的方式。

54
00:02:57,260 --> 00:03:01,220
所以我们要替换这些
通过把一些空格点。

55
00:03:01,220 --> 00:03:03,720
一个，两个，三个在第一行。

56
00:03:03,720 --> 00:03:05,650
一，二上的第二个。

57
00:03:05,650 --> 00:03:08,200
和一个在第三线路。

58
00:03:08,200 --> 00:03:12,060
因此，这是我们会怎样做，如果我们
希望只是做一个完整的金字塔，

59
00:03:12,060 --> 00:03:13,700
也就是说，在我们的文本编辑器。

60
00:03:13,700 --> 00:03:15,860
>> 因此，让我们借此，
理解模式，

61
00:03:15,860 --> 00:03:19,870
并在将其转换为一些伪。

62
00:03:19,870 --> 00:03:24,500
对于金字塔的每一行，我们希望
打印的左金字塔然后

63
00:03:24,500 --> 00:03:26,580
的差距，再右边的金字塔。

64
00:03:26,580 --> 00:03:30,260
左金字塔，我们打印
的空间所需量，

65
00:03:30,260 --> 00:03:31,740
其次是哈希值。

66
00:03:31,740 --> 00:03:35,030
然后，我们打印差距，这
是每一次只有两个空格。

67
00:03:35,030 --> 00:03:38,080
而在右边的金字塔，我们打印
必要数量的散列。

68
00:03:38,080 --> 00:03:41,410
>> 对于第二行，我们进行了
完全相同的过程。

69
00:03:41,410 --> 00:03:44,510
我们打​​印的空间左
金字塔，所需量

70
00:03:44,510 --> 00:03:49,930
散列，间隙，两个空间，和
那么散列为正确的金字塔。

71
00:03:49,930 --> 00:03:52,490
>> 让我们来解决模式
用于左金字塔。

72
00:03:52,490 --> 00:03:55,660
如果我有，为目的
本实施例的，高度

73
00:03:55,660 --> 00:03:58,790
八所要求的
用户，那么我的第一排

74
00:03:58,790 --> 00:04:01,020
将有一个哈希和7个空格。

75
00:04:01,020 --> 00:04:03,860
我的第二排将有
两个哈希，六个空格。

76
00:04:03,860 --> 00:04:06,749
第三排，三哈希，五个空格。

77
00:04:06,749 --> 00:04:09,040
你也许可以做到这一点
对于自己的八个高度

78
00:04:09,040 --> 00:04:13,470
并确定为每一行多少
哈希多少空间需要。

79
00:04:13,470 --> 00:04:16,209
但是，我们想要做的是什么
我们希望它抽象。

80
00:04:16,209 --> 00:04:22,660
所以我问你任何的第n行，多少
哈希和我们有多少空间需要？

81
00:04:22,660 --> 00:04:25,410
>> 现在，当你确定
模式来多少哈希

82
00:04:25,410 --> 00:04:29,920
多少空间你需要
任何第n行对于一个给定的高度，

83
00:04:29,920 --> 00:04:32,910
切记要小心
如何你索引。

84
00:04:32,910 --> 00:04:37,160
我的意思是，在日常生活
生活中我们最开始由一个计数。

85
00:04:37,160 --> 00:04:39,680
所以，第一行是一个数字。

86
00:04:39,680 --> 00:04:43,620
和第二行是行
第二，等等，等等。

87
00:04:43,620 --> 00:04:47,620
>> 但是，在计算机科学和
CS50，我们是零索引。

88
00:04:47,620 --> 00:04:50,750
所以我们实际上从零开始计数。

89
00:04:50,750 --> 00:04:54,020
因此第一行会
是行数为零。

90
00:04:54,020 --> 00:04:56,640
和第二行
会排第一。

91
00:04:56,640 --> 00:05:02,510
所以，如果我有八的高度
我的金字塔，那么n的最后一个值

92
00:05:02,510 --> 00:05:05,850
实际上是七不八强。

93
00:05:05,850 --> 00:05:07,010
>> 所以，要注意此点。

94
00:05:07,010 --> 00:05:10,750
而要知道，当你确定
你的模式是否你的零索引

95
00:05:10,750 --> 00:05:12,360
或一索引

96
00:05:12,360 --> 00:05:13,070
>> 好。

97
00:05:13,070 --> 00:05:15,380
所以，现在，我们有
对于左金字塔图案，

98
00:05:15,380 --> 00:05:18,650
我们需要确定
图案的间隙。

99
00:05:18,650 --> 00:05:20,480
幸运的是，这是很容易的。

100
00:05:20,480 --> 00:05:22,690
这只是总是两个空格。

101
00:05:22,690 --> 00:05:25,240
>> 所以，现在我们进行正确的模式。

102
00:05:25,240 --> 00:05:27,220
第一排将有一个哈希值。

103
00:05:27,220 --> 00:05:28,640
第二行，二。

104
00:05:28,640 --> 00:05:29,530
第三排，三。

105
00:05:29,530 --> 00:05:30,790
等等等等。

106
00:05:30,790 --> 00:05:35,540
如此反复，确定任何抽象
n和任何高度多少哈希

107
00:05:35,540 --> 00:05:38,810
又有多少空间
每一行应该有。

108
00:05:38,810 --> 00:05:39,700
>> 好。

109
00:05:39,700 --> 00:05:45,050
因此，我们知道，对于每一行，我们
需要进行一些处理。

110
00:05:45,050 --> 00:05:46,600
我们怎么办呢？

111
00:05:46,600 --> 00:05:50,440
好了，我们用的循环结构，
由一个初始化，

112
00:05:50,440 --> 00:05:52,310
一个条件，并进行更新。

113
00:05:52,310 --> 00:05:54,830
For循环可使用
重复的过程。

114
00:05:54,830 --> 00:05:59,610
>> 所以说，我希望它打招呼，
世界上50倍，那么我的for循环

115
00:05:59,610 --> 00:06:03,510
会是这个样子，哪里
我初始化我变到零。

116
00:06:03,510 --> 00:06:06,200
条件是i小于50。

117
00:06:06,200 --> 00:06:09,670
然后将更新的是，它
通过每次递增1。

118
00:06:09,670 --> 00:06:14,700
那么，这会做将是
在连续打印你好，世界的50倍。

119
00:06:14,700 --> 00:06:18,080
>> 现在，说我想要迭代
在金字塔的高度。

120
00:06:18,080 --> 00:06:21,560
然后，而不是硬编码
在条件一定的价值，

121
00:06:21,560 --> 00:06:23,280
我只是用可变高度。

122
00:06:23,280 --> 00:06:27,180
那么，这将做的是迭代
以上的高度的每一行。

123
00:06:27,180 --> 00:06:30,280
我可以在里面做一些事情
该循环的机构。

124
00:06:30,280 --> 00:06:32,710
>> 什么是我们想要做的
在循环体内？

125
00:06:32,710 --> 00:06:36,550
嗯，正如我们之前所说，我们希望
打印空间和散列

126
00:06:36,550 --> 00:06:40,730
左金字塔，然后打印
两个空格，然后打印哈希值。

127
00:06:40,730 --> 00:06:42,500
因此，我们已经想通了这一点。

128
00:06:42,500 --> 00:06:45,670
因此，我们可以开始填写
在我们的节目多很多。

129
00:06:45,670 --> 00:06:49,850
>> 在这里，我有一个外部的循环
迭代在金字塔的每一行。

130
00:06:49,850 --> 00:06:53,340
而且身体里面我要去
重复打印的空间，

131
00:06:53,340 --> 00:06:56,860
反复散列，然后该间隙，
然后散列合适的金字塔，

132
00:06:56,860 --> 00:07:00,440
然后，最后，一个新的
行开始的下一行。

133
00:07:00,440 --> 00:07:02,860
>> 就这样，我们已经提示
用户的输入。

134
00:07:02,860 --> 00:07:04,510
我们确信，它是有效的。

135
00:07:04,510 --> 00:07:06,280
然后，我们得出的金字塔。

136
00:07:06,280 --> 00:07:09,540
所以马里奥可以成功
爬上金字塔。

137
00:07:09,540 --> 00:07:10,970
>> 我的名字是Zamyla。

138
00:07:10,970 --> 00:07:13,840
这是CS50。

139
00:07:13,840 --> 00:07:15,419