1
00:00:00,000 --> 00:00:15,059
>> [音乐]

2
00:00:15,059 --> 00:00:19,170
>> 这是哈佛CS50--
大学介绍

3
00:00:19,170 --> 00:00:22,070
到智能
计算机科学的企业

4
00:00:22,070 --> 00:00:23,800
和艺术节目。

5
00:00:23,800 --> 00:00:27,020
我的名字是大卫·马兰和
我只是在想今天上午，

6
00:00:27,020 --> 00:00:33,120
它已经令人惊讶的今天20年
自从我上次坐的地方你们现在要做的。

7
00:00:33,120 --> 00:00:33,840
>> 那是1996年。

8
00:00:33,840 --> 00:00:37,550
我是一个大二了，我正在
CS50的第一次。

9
00:00:37,550 --> 00:00:40,890
而我什至没有得到鼓起勇气
把它自己大一的时候，

10
00:00:40,890 --> 00:00:42,500
部分原因是时间。

11
00:00:42,500 --> 00:00:44,782
计算机科学给我
是那种喜欢，MEH。

12
00:00:44,782 --> 00:00:46,990
我是一个有点怪胎成长
，但我真的不

13
00:00:46,990 --> 00:00:49,180
有任何知识产权
在什么似乎兴趣

14
00:00:49,180 --> 00:00:51,920
仅仅是一大堆
编程的人所有的时间。

15
00:00:51,920 --> 00:00:53,904
>> 而且我很害怕是诚实的。

16
00:00:53,904 --> 00:00:56,820
本课程和计算机科学更多
通常具有和在一定程度上

17
00:00:56,820 --> 00:01:01,230
还有一个领域的这种声誉
当心，如果仅仅是因为我们许多人

18
00:01:01,230 --> 00:01:04,410
不熟悉它并不能确定它。

19
00:01:04,410 --> 00:01:08,480
它真的直到我逛过
这个类大二fall--

20
00:01:08,480 --> 00:01:10,880
即使这样，我只招收
因为professor--

21
00:01:10,880 --> 00:01:13,950
我的第一个导师之一，布赖恩
Kernighan的现在Princeton--

22
00:01:13,950 --> 00:01:15,700
让我走班通失败。

23
00:01:15,700 --> 00:01:18,020
事实上，这就是为什么
今天我们允许和鼓励

24
00:01:18,020 --> 00:01:20,030
学生参加此类SAT /不饱和度。

25
00:01:20,030 --> 00:01:22,040
>> 也只有这样，由
学期结束

26
00:01:22,040 --> 00:01:24,870
我才意识到一样，哇，这
没有这样一个陌生的领域。

27
00:01:24,870 --> 00:01:26,850
实际上，这是一个
非常赋权领域，

28
00:01:26,850 --> 00:01:28,970
而更令人兴奋，
特别是后来，

29
00:01:28,970 --> 00:01:32,809
因为我把课程
话剧艺术101和拉丁

30
00:01:32,809 --> 00:01:34,600
然后最终
研究生院考古学，

31
00:01:34,600 --> 00:01:37,860
我才真正开始看
此领域中，计算机的交点

32
00:01:37,860 --> 00:01:41,979
科学与人文科学，
自然科学，艺术，医药，

33
00:01:41,979 --> 00:01:42,520
和类似物。

34
00:01:42,520 --> 00:01:44,420
所以这就是只是这么
整齐的有关计算机科学

35
00:01:44,420 --> 00:01:46,930
最终，因为我们希望您
see--是它的适用性

36
00:01:46,930 --> 00:01:50,280
这些等领域，以及如何
采取一些今天和本学期的的

37
00:01:50,280 --> 00:01:53,070
理念和实用技巧
回到你自己的域名，

38
00:01:53,070 --> 00:01:58,200
实际上探讨此交汇
的文科和理科。

39
00:01:58,200 --> 00:02:02,690
>> 因此，73％的你，如果最后
今年是任何迹象显示，

40
00:02:02,690 --> 00:02:04,390
以前从未采取了CS课程。

41
00:02:04,390 --> 00:02:06,389
所以，如果像我一样，你是
有点感觉了

42
00:02:06,389 --> 00:02:09,190
害怕，或者坦白地说你不
知道为什么你甚至在这里。

43
00:02:09,190 --> 00:02:11,510
也许你只是跟着一些
在桑德斯的朋友现在。

44
00:02:11,510 --> 00:02:12,490
这是完全正常。

45
00:02:12,490 --> 00:02:15,059
这里的目标是勾
你和向你保证

46
00:02:15,059 --> 00:02:17,100
如果你看
左边和右边，

47
00:02:17,100 --> 00:02:21,480
你会看到有同学
很少或尽可能多的经验

48
00:02:21,480 --> 00:02:22,890
你自己可能有。

49
00:02:22,890 --> 00:02:25,280
事实上，我们将分享
今天有人统计后

50
00:02:25,280 --> 00:02:28,120
至于什么样的人口统计
类典型的模样。

51
00:02:28,120 --> 00:02:31,440
>> 而作为补充reassurance--这个我们
做意味着自从我接手课程

52
00:02:31,440 --> 00:02:33,252
几年ago--在
课程的教学大纲

53
00:02:33,252 --> 00:02:35,460
是this--什么最终
在这个过程中的问题

54
00:02:35,460 --> 00:02:38,040
与其说你在哪里结束
达相对于你的同学，

55
00:02:38,040 --> 00:02:43,110
但如果你在11个星期的结束
学期结束了相对于自己

56
00:02:43,110 --> 00:02:46,280
0周，这是
在这里我们今天在这里。

57
00:02:46,280 --> 00:02:48,704
而这也正是我意识到
所有这些年前。

58
00:02:48,704 --> 00:02:50,620
我知道很多
班说，但它的

59
00:02:50,620 --> 00:02:52,450
在计算机科学中尤其如此。

60
00:02:52,450 --> 00:02:55,320
在一天结束时，此字段
是陌生的，因为它是我的

61
00:02:55,320 --> 00:02:58,590
并可能对你，实在是
只是解决问题。

62
00:02:58,590 --> 00:03:01,324
正因为如此，它确实有这
适用于获取等领域。

63
00:03:01,324 --> 00:03:03,490
而事实上，如果我们试图
蒸馏这意味着什么，

64
00:03:03,490 --> 00:03:06,897
这是解决问题
在本质上，我敢说。

65
00:03:06,897 --> 00:03:09,480
有input--所以无论它
是，你试图解决的问题。

66
00:03:09,480 --> 00:03:12,264
有输出，这是希望
解决这个问题。

67
00:03:12,264 --> 00:03:14,180
然后，当我们将
说，在计算机科学，

68
00:03:14,180 --> 00:03:17,310
有这个黑盒子的
中间的那个你不一定

69
00:03:17,310 --> 00:03:19,450
要关心它是如何工作的。

70
00:03:19,450 --> 00:03:22,230
你自己可能最终
实现那是什么盒子里。

71
00:03:22,230 --> 00:03:25,194
但对于今天的目的且更加
一般在生活中，你所关心

72
00:03:25,194 --> 00:03:26,610
的是，这些问题得到解决。

73
00:03:26,610 --> 00:03:29,340
>> 而这是什么课程
最终的就是探索

74
00:03:29,340 --> 00:03:31,700
的交点
这些输入和输出，

75
00:03:31,700 --> 00:03:34,410
这些所谓的
算法，我们很快就会看到，

76
00:03:34,410 --> 00:03:37,450
实现什么
底下还有，油烟机。

77
00:03:37,450 --> 00:03:40,487
但这些投入和这些outputs--
这是什么实际上意味着？

78
00:03:40,487 --> 00:03:43,570
那么，在这一天结束时，我们需要
表示信息的一些方法。

79
00:03:43,570 --> 00:03:46,660
这是在一个计算机尤其如此，
其中花哨和复杂，因为它

80
00:03:46,660 --> 00:03:48,160
似乎，是一个非常愚蠢的设备。

81
00:03:48,160 --> 00:03:52,240
这需要electricity--无论从
电缆或电池作为input--

82
00:03:52,240 --> 00:03:55,820
然后它产生一些
在屏幕上preprogramed响应。

83
00:03:55,820 --> 00:03:57,970
>> 但是，我们如何从中获取
开始到结束吗？

84
00:03:57,970 --> 00:03:59,470
那么，什么是一个亟待解决的问题？

85
00:03:59,470 --> 00:04:01,050
好吧，也许我们可能在
任何学期的开始，

86
00:04:01,050 --> 00:04:02,841
尝试点名
在一个房间里是这样的。

87
00:04:02,841 --> 00:04:04,750
所以，我可能会做这样一，二，三名。

88
00:04:04,750 --> 00:04:07,060
或者，也许，如果我做到了
要排序的追踪

89
00:04:07,060 --> 00:04:10,560
myself--的跟踪things--
我可能很快用完手指。

90
00:04:10,560 --> 00:04:14,650
所以，我可能只是做散marks-- 1
人，二，三，四，五，六，

91
00:04:14,650 --> 00:04:15,431
七，八。

92
00:04:15,431 --> 00:04:17,930
而我们每个人都有可能
做到了这一点，无论是在你的手中

93
00:04:17,930 --> 00:04:19,680
或在一张纸上。

94
00:04:19,680 --> 00:04:22,140
而这其实只是
所谓一元notation--

95
00:04:22,140 --> 00:04:26,130
在这里，如果你只有一个字母
在字母表中，一个或哈希

96
00:04:26,130 --> 00:04:29,440
标记在这种情况下，对于每一个
要计数输入，

97
00:04:29,440 --> 00:04:32,330
你需要放下其中之一
letters--这些标志之一。

98
00:04:32,330 --> 00:04:32,510
>> 好吧。

99
00:04:32,510 --> 00:04:34,790
这是所有罚款和好，
不是所有的复杂。

100
00:04:34,790 --> 00:04:37,800
但电脑是不是全部
该更复杂。

101
00:04:37,800 --> 00:04:40,770
事实上，大多数人可能
知道即使你不是真的

102
00:04:40,770 --> 00:04:44,080
认为这是什么意思，那
电脑只懂得零

103
00:04:44,080 --> 00:04:45,870
和ones--的所谓的二元系统。

104
00:04:45,870 --> 00:04:49,390
我们人类，相反，是这样
更为复杂的范围内

105
00:04:49,390 --> 00:04:51,770
据我们了解，通过花枝招展零。

106
00:04:51,770 --> 00:04:55,740
>> 但即使是二进制文件，首先
一眼望去，不是所有的熟悉，

107
00:04:55,740 --> 00:05:00,330
事实证明，这就像系统
和想法，我们已经知道了。

108
00:05:00,330 --> 00:05:02,420
因此，例如，考虑一下。

109
00:05:02,420 --> 00:05:03,896
这仅仅是一个码元的序列。

110
00:05:03,896 --> 00:05:05,770
和所有的你，当
看了一眼它，大概

111
00:05:05,770 --> 00:05:09,380
想123--什么
真的很有趣那里。

112
00:05:09,380 --> 00:05:11,940
但为什么这个数字，123？

113
00:05:11,940 --> 00:05:14,440
这些只是对字形
在screen--只是模式

114
00:05:14,440 --> 00:05:16,387
有人可能会得出或打字。

115
00:05:16,387 --> 00:05:18,970
但是，如果你像我一样，你
大概从小学记忆

116
00:05:18,970 --> 00:05:21,610
有几分
这里列或场所。

117
00:05:21,610 --> 00:05:25,340
还有的人的地点和
十位和百位。

118
00:05:25,340 --> 00:05:29,820
其原因，这是123和
不只是三个符号的格局

119
00:05:29,820 --> 00:05:33,090
是因为，当然，如果我们
有数以百计的地方之一，

120
00:05:33,090 --> 00:05:36,610
你做100次一个数学，
然后两人在十位。

121
00:05:36,610 --> 00:05:41,390
所以这是10次2，然后在三个
在一个人的地方，这是1次3。

122
00:05:41,390 --> 00:05:45,670
而当你添加所有这些起来，
当然，你会得到100加20加3。

123
00:05:45,670 --> 00:05:48,220
>> 所以我们开始时只有一个模式
的symbols--的alphabet--

124
00:05:48,220 --> 00:05:51,670
但后来我们被映射到意义
它通过这些列的方式。

125
00:05:51,670 --> 00:05:54,450
那么，事实证明，
电脑是真的不

126
00:05:54,450 --> 00:05:56,300
从你我所有的不同。

127
00:05:56,300 --> 00:06:01,840
但是，而不是使用的10次幂，
所以speak-- 1，10，100，1000，

128
00:06:01,840 --> 00:06:04,330
万到位等
forth--他们实际上

129
00:06:04,330 --> 00:06:08,930
只是使用的权力2--
所以一，二，四，然后

130
00:06:08,930 --> 00:06:12,810
如果我们把更多的数字，8，16，
32，64，128，等等。

131
00:06:12,810 --> 00:06:16,050
所以这是怎样一个计算机
将代表数字0，

132
00:06:16,050 --> 00:06:17,300
就像我们人类。

133
00:06:17,300 --> 00:06:21,660
>> 0，0，0--你可能猜到
什么零和一的格局，

134
00:06:21,660 --> 00:06:24,610
如果一台计算机只能
说话0或1--什么

135
00:06:24,610 --> 00:06:29,110
模式将代表
数我们人类所知道的1？

136
00:06:29,110 --> 00:06:30,590
Yeah-- 0，0，1。

137
00:06:30,590 --> 00:06:31,090
好吧。

138
00:06:31,090 --> 00:06:35,900
所以，0，0，1是我们如何代表
1，所以你可能会再倾斜

139
00:06:35,900 --> 00:06:39,510
代表数字2，如果你有
四的地方，这两个的地方

140
00:06:39,510 --> 00:06:48,290
作为一个地方，你可能会说，好吧，
如果我们在自己的地方有一个1，

141
00:06:48,290 --> 00:06:50,430
现在我们要
数到2，你可能

142
00:06:50,430 --> 00:06:53,310
做到这一点，留给这是一个零。

143
00:06:53,310 --> 00:06:56,397
但当然这不是如何
十进制系统的工作原理无论是。

144
00:06:56,397 --> 00:06:58,230
如果你把一个数字
这两个栏目，

145
00:06:58,230 --> 00:06:59,563
你必须做算术。

146
00:06:59,563 --> 00:07:01,930
那么什么号码我做
意外只是代表什么？

147
00:07:01,930 --> 00:07:06,710
>> 所以这是3，因为2次1加1
次1，当然，给了我们三种。

148
00:07:06,710 --> 00:07:08,340
所以，这将是两个。

149
00:07:08,340 --> 00:07:12,730
位排序的翻转，可以这么说，为0
成为一个，很像一个9角色过

150
00:07:12,730 --> 00:07:14,840
当你携带1变成0。

151
00:07:14,840 --> 00:07:16,510
然后，这将是三道的。

152
00:07:16,510 --> 00:07:20,170
Four--另一个有趣的事情
发生，其中的那些翻转

153
00:07:20,170 --> 00:07:21,750
你随身携带的1，可以这么说。

154
00:07:21,750 --> 00:07:23,320
因此，这当然，为4。

155
00:07:23,320 --> 00:07:25,160
>> 但是，如果你快进了，
这是怎么回事的最大数量

156
00:07:25,160 --> 00:07:26,660
是计算机能够代表什么呢？

157
00:07:26,660 --> 00:07:30,420

158
00:07:30,420 --> 00:07:32,380
所以它只是在这种情况下七，对不对？

159
00:07:32,380 --> 00:07:35,570
因为你必须在四一，
一个在这两个，一个在所述一个。

160
00:07:35,570 --> 00:07:36,900
所以这是4加2加1。

161
00:07:36,900 --> 00:07:37,972
所以，让你七。

162
00:07:37,972 --> 00:07:39,680
事实上，它会
乍一看

163
00:07:39,680 --> 00:07:43,750
计算机能够算
不高于此。

164
00:07:43,750 --> 00:07:45,210
>> 但是，这当然是不正确的。

165
00:07:45,210 --> 00:07:48,243
什么是我们人类做的时候，我们希望
算不是像999高？

166
00:07:48,243 --> 00:07:51,000

167
00:07:51,000 --> 00:07:53,900
只需携带一个公正
加的第四位到左侧。

168
00:07:53,900 --> 00:07:55,070
所以，我们确实可以。

169
00:07:55,070 --> 00:07:57,900
我们可以有一个八的
放置和第16的位置，

170
00:07:57,900 --> 00:08:02,000
和32的地方，64 128--你
可以只保留事情到无穷。

171
00:08:02,000 --> 00:08:04,640
因此，这些零和ones--
的所谓的二元系统 -

172
00:08:04,640 --> 00:08:10,290
什么是计算机科学家会
一般叫了一下，还是二进制数字。

173
00:08:10,290 --> 00:08:13,590
>> 但是现在，我们如何从一开始
概念或这些东西的图形

174
00:08:13,590 --> 00:08:14,620
一个实际的计算机？

175
00:08:14,620 --> 00:08:17,170
我们似乎在这里跳过了一步。

176
00:08:17,170 --> 00:08:20,210
那么，在最后唯一的输入
一天，我的笔记本电脑在这里

177
00:08:20,210 --> 00:08:22,060
是电的这种流动。

178
00:08:22,060 --> 00:08:24,560
即使它是一个漫长的
既然你想过时间

179
00:08:24,560 --> 00:08:26,580
或者从来没有想过
电力是如何工作的，

180
00:08:26,580 --> 00:08:30,909
有一个在流动的电子或
出来，这是我的一种投入。

181
00:08:30,909 --> 00:08:34,659
>> 所以，如果这一切，我们是
让作为输入这里，

182
00:08:34,659 --> 00:08:36,830
我们可以做什么用这些信息？

183
00:08:36,830 --> 00:08:40,040
好了，我们可能会认为一个零的
只是一个没有电。

184
00:08:40,040 --> 00:08:42,540
没有什么是flowinw，没有什么是
动，什么也没有发生。

185
00:08:42,540 --> 00:08:44,690
这只是默认state--为零。

186
00:08:44,690 --> 00:08:48,200
但是，如果有电流淌，为什么
不要我们只是随意，但全球范围内

187
00:08:48,200 --> 00:08:50,250
始终，把那个叫之一。

188
00:08:50,250 --> 00:08:54,760
>> 所以，简单地通过无电，
我们有一个零，是电力，

189
00:08:54,760 --> 00:08:57,520
我们有一个one--没有权力，是权力。

190
00:08:57,520 --> 00:09:01,520
并以这种方式，使用的东西
多个物理或电子

191
00:09:01,520 --> 00:09:05,340
我们开始实施的这个概念
东西要么是1或0。

192
00:09:05,340 --> 00:09:07,230
事实上，我们可以做它在这里。

193
00:09:07,230 --> 00:09:10,590
所以在这里，我不是三个，但
八块光灯泡，其每一个

194
00:09:10,590 --> 00:09:11,810
有它自己的交换机。

195
00:09:11,810 --> 00:09:15,760
>> 所以，如果我想代表
七位数这里，

196
00:09:15,760 --> 00:09:18,510
我可能会打开这三个灯泡。

197
00:09:18,510 --> 00:09:21,470
事实上，里面的
我的电脑是数以百万计，

198
00:09:21,470 --> 00:09:25,650
数十亿的东西，只是
小于，称为晶体管，

199
00:09:25,650 --> 00:09:27,330
开关，你只需打开和关闭。

200
00:09:27,330 --> 00:09:30,420
所以这些都是big--比较
我laptop--内big--开关

201
00:09:30,420 --> 00:09:32,150
有很多，很多，很多，
更多的交换机。

202
00:09:32,150 --> 00:09:35,160
但他们做的是完全that--
打开一些东西，把东西掉。

203
00:09:35,160 --> 00:09:38,076
正因为如此，一个计算机可以代表
与百万或数十亿

204
00:09:38,076 --> 00:09:40,480
晶体管，地段和
大量的零和一。

205
00:09:40,480 --> 00:09:43,160
而且还有其他的硬件仍然是
让您存储信息长期，

206
00:09:43,160 --> 00:09:45,243
所以，当你拉
插，你不会失去它。

207
00:09:45,243 --> 00:09:46,900
但是，这是另一天的故事。

208
00:09:46,900 --> 00:09:51,170
>> 那么，我们可以用这些位？

209
00:09:51,170 --> 00:09:54,309
也许我们只是拿
压过的我 -

210
00:09:54,309 --> 00:09:56,600
可能有人要来
在这里，并提供了一​​个演示？

211
00:09:56,600 --> 00:09:57,516
我第一次看到这个手。

212
00:09:57,516 --> 00:09:58,709
你叫什么名字？

213
00:09:58,709 --> 00:09:59,250
MADAY：Maday。

214
00:09:59,250 --> 00:10:00,542
DAVID MALAN：Maday，上来吧。

215
00:10:00,542 --> 00:10:01,250
很高兴见到你。

216
00:10:01,250 --> 00:10:02,390
MADAY：很高兴见到你。

217
00:10:02,390 --> 00:10:02,930
>> DAVID MALAN：这边走。

218
00:10:02,930 --> 00:10:04,182
我不会有嘴唇你。

219
00:10:04,182 --> 00:10:04,682
好吧。

220
00:10:04,682 --> 00:10:11,090
所以在这里，我们有，notice--之一，two--
我们将编辑out--一，二，四，

221
00:10:11,090 --> 00:10:13,350
八，16，32，64，128。

222
00:10:13,350 --> 00:10:14,220
这是经过深思熟虑的。

223
00:10:14,220 --> 00:10:17,370
有八位这里 -
二进制digits--零和一。

224
00:10:17,370 --> 00:10:21,460
和一点是measure--一个有用的单位
不是有用的测量单位

225
00:10:21,460 --> 00:10:21,999
到自身。

226
00:10:21,999 --> 00:10:24,290
通常你至少需要
这些东西八，又名

227
00:10:24,290 --> 00:10:24,790
一个字节。

228
00:10:24,790 --> 00:10:26,230
所以我们这里有位字节。

229
00:10:26,230 --> 00:10:31,130
>> 因此，如果我们想与你来挑战，
例如，拼写出，在二进制

230
00:10:31,130 --> 00:10:33,230
这个值这里 -  42。

231
00:10:33,230 --> 00:10:35,140
要采取的一个刺？

232
00:10:35,140 --> 00:10:36,034
>> MADAY：[听不清]。

233
00:10:36,034 --> 00:10:38,700
DAVID MALAN：是的，只需轻轻一按
白色的小开关在前面。

234
00:10:38,700 --> 00:10:41,290
而你要拼
出42，和待价而沽

235
00:10:41,290 --> 00:10:44,061
这是CS50压力
球，如果你得到这个。

236
00:10:44,061 --> 00:10:44,560
好吧。

237
00:10:44,560 --> 00:10:46,420
所以，你有32个。

238
00:10:46,420 --> 00:10:48,430
我们将需要42。

239
00:10:48,430 --> 00:10:51,410
所以这是一个八，所以这是40。

240
00:10:51,410 --> 00:10:54,160
而excellent--非常好做。

241
00:10:54,160 --> 00:10:55,186
谢谢。

242
00:10:55,186 --> 00:10:58,790
>> [掌声]

243
00:10:58,790 --> 00:10:59,290
好吧。

244
00:10:59,290 --> 00:11:00,623
因此，我们又多了一个压力球。

245
00:11:00,623 --> 00:11:03,595
我们如果我们可以的做一次。

246
00:11:03,595 --> 00:11:05,368
另外一个志愿者？

247
00:11:05,368 --> 00:11:07,970
无压力球，无压力球。

248
00:11:07,970 --> 00:11:08,470
好。

249
00:11:08,470 --> 00:11:11,640
在这里在中间，
你想下来？

250
00:11:11,640 --> 00:11:14,100
好吧。

251
00:11:14,100 --> 00:11:15,552
我知道。

252
00:11:15,552 --> 00:11:16,360
在那里，我们走了。

253
00:11:16,360 --> 00:11:20,818
>> 因此，数字这里 - 下来吧。

254
00:11:20,818 --> 00:11:21,567
你叫什么名字？

255
00:11:21,567 --> 00:11:21,984
>> DAVEY：戴维。

256
00:11:21,984 --> 00:11:22,820
>> DAVID MALAN：戴维。

257
00:11:22,820 --> 00:11:23,320
好。

258
00:11:23,320 --> 00:11:24,810
上来吧，戴维。

259
00:11:24,810 --> 00:11:25,890
很高兴见到你。

260
00:11:25,890 --> 00:11:28,639
而我们要去有你
spell--如果你能留在那里

261
00:11:28,639 --> 00:11:32,810
只是一个moment--是数字50。

262
00:11:32,810 --> 00:11:36,293
但是，但是，但是却，但是，这些都是
小学磁铁的一个原因。

263
00:11:36,293 --> 00:11:39,370

264
00:11:39,370 --> 00:11:43,327
只是有点困难，没事吧？

265
00:11:43,327 --> 00:11:44,160
目前仍然八强。

266
00:11:44,160 --> 00:11:46,820

267
00:11:46,820 --> 00:11:47,320
好吧。

268
00:11:47,320 --> 00:11:48,486
那么，我们有吗？

269
00:11:48,486 --> 00:11:51,356
我们有32个。

270
00:11:51,356 --> 00:11:54,344
尼斯。

271
00:11:54,344 --> 00:11:58,610
32加16给我们48--如此接近。

272
00:11:58,610 --> 00:12:00,390
与精彩。

273
00:12:00,390 --> 00:12:02,831
恭喜戴维为好。

274
00:12:02,831 --> 00:12:05,720
>> [掌声]

275
00:12:05,720 --> 00:12:06,516
>> 好吧。

276
00:12:06,516 --> 00:12:09,390
因此，我们可以长期做这一切的一天，
它没有得到所有的东西更多

277
00:12:09,390 --> 00:12:10,800
有趣和更具挑战性。

278
00:12:10,800 --> 00:12:13,250
但是，这真的是point--
是怎么比较简单

279
00:12:13,250 --> 00:12:16,930
它是，在一天结束时，什么
计算机确实存储信息，

280
00:12:16,930 --> 00:12:21,740
存储投入和最终
存储或代表那些输出。

281
00:12:21,740 --> 00:12:23,750
但仅靠数字不
那么有趣。

282
00:12:23,750 --> 00:12:26,069
>> 所以人类，若干年前，
决定了，你知道吗？

283
00:12:26,069 --> 00:12:27,860
这将是很好的，如果
电脑不只是

284
00:12:27,860 --> 00:12:31,030
计算器算术
操作，但实际上可能

285
00:12:31,030 --> 00:12:35,209
做的事情，如文字处理，或
电子邮件，或更现代的化身

286
00:12:35,209 --> 00:12:36,500
这些种类的技术。

287
00:12:36,500 --> 00:12:40,680
这样一来，世界决定
随意，但普遍，

288
00:12:40,680 --> 00:12:44,380
如果你想存储的资本
在计算机字母A，你知道吗？

289
00:12:44,380 --> 00:12:47,730
就让我们都同意存储
零和ones--的一些模式

290
00:12:47,730 --> 00:12:52,422
bits--最终
代表十进制数65。

291
00:12:52,422 --> 00:12:53,630
我们只都同意这一点。

292
00:12:53,630 --> 00:12:56,620
>> 66将代表B，
67将代表C，

293
00:12:56,620 --> 00:13:00,210
这里面的的其他模式串
零和一，或底层号码

294
00:13:00,210 --> 00:13:02,224
这将是
其他字母依然。

295
00:13:02,224 --> 00:13:04,390
所以，如果你有种精神
这个吸收了一会儿，

296
00:13:04,390 --> 00:13:10,900
我特意提出了一个通过
我，其中H 72，我是73。

297
00:13:10,900 --> 00:13:15,830
如果计算机然后，在的情况下
字处理程序或电子邮件，

298
00:13:15,830 --> 00:13:19,620
引擎盖下显露有
bits--模式这些模式

299
00:13:19,620 --> 00:13:22,500
代表位
72，然后73，然后33--

300
00:13:22,500 --> 00:13:26,640
什么可能这个咒语在该程序？

301
00:13:26,640 --> 00:13:28,150
>> 所以喜，然后什么。

302
00:13:28,150 --> 00:13:31,460
我们不一定知道，但确确实实
33--没有在图表上先前已经

303
00:13:31,460 --> 00:13:33,170
只是一个感叹号。

304
00:13:33,170 --> 00:13:38,870
所以72是H，73是我，发生了33
是一个感叹号依然。

305
00:13:38,870 --> 00:13:41,719
但是，这一切优秀和良好，
而事实上现今，而不是

306
00:13:41,719 --> 00:13:43,760
只需用七八
位，这要感谢的东西

307
00:13:43,760 --> 00:13:46,530
所谓的Unicode相
为ASCII早在一天，

308
00:13:46,530 --> 00:13:50,010
我们实际上可以代表更
有趣的角色不仅仅是

309
00:13:50,010 --> 00:13:52,980
这些原始英文字母偏颇。

310
00:13:52,980 --> 00:13:56,030
但是，我们也可以代表甚至
整洁的东西喜欢的颜色。

311
00:13:56,030 --> 00:13:59,750
>> 如果你曾经听过的缩写
RGB，红，绿，蓝，这

312
00:13:59,750 --> 00:14:03,510
只是意味着一台电脑
通常使用三套bits--

313
00:14:03,510 --> 00:14:06,760
某些数目的位表示
一个号码，你要多少红，

314
00:14:06,760 --> 00:14:08,940
另一组的比特为
多少绿色的你想要的，

315
00:14:08,940 --> 00:14:11,430
而另一组数字
多少蓝你想要的。

316
00:14:11,430 --> 00:14:14,457
因此，一个大的数字意味着大量的
红，数量少意味着没有红。

317
00:14:14,457 --> 00:14:16,290
所以这些都是种
这里的中间值。

318
00:14:16,290 --> 00:14:20,180
>> 所以给我一些红色的，给我一些
绿色，给我的蓝一点点。

319
00:14:20,180 --> 00:14:24,260
如果你混合这三个​​色调
颜色一起的，在这种情况下，

320
00:14:24,260 --> 00:14:26,850
你得到这个黑暗的树荫
黄色或棕色。

321
00:14:26,850 --> 00:14:32,330
但是八个这种模式加
八加eight--所以24 bits--

322
00:14:32,330 --> 00:14:36,550
从左到右，是如何在计算机
将代表特定的颜色。

323
00:14:36,550 --> 00:14:38,090
现在，这只是一个屏幕上的一个点。

324
00:14:38,090 --> 00:14:42,230
如果你看起来真的收于电视的
计算机，你会看到点或像素。

325
00:14:42,230 --> 00:14:45,420
如果你有一整个网格
像素，水平和垂直方向，

326
00:14:45,420 --> 00:14:46,630
你有图像。

327
00:14:46,630 --> 00:14:49,029
然后，如果你拿
一个图像，然后洗

328
00:14:49,029 --> 00:14:52,070
展示自己的另一个形象，另一
图像，另一个图像，另一个图像，

329
00:14:52,070 --> 00:14:54,760
真快，你当然得电影。

330
00:14:54,760 --> 00:14:56,109
>> 因此注意到我们开始的地方。

331
00:14:56,109 --> 00:14:57,650
我们开始与这些零和一。

332
00:14:57,650 --> 00:15:00,570
我们从那里工作为十进制
数字，我们如何代表他们。

333
00:15:00,570 --> 00:15:02,070
现在我们有英文字母。

334
00:15:02,070 --> 00:15:05,664
但在其他情况下等待，我们可以使用
几个比特和表示颜色。

335
00:15:05,664 --> 00:15:07,830
只要你有
表示颜色的能力，

336
00:15:07,830 --> 00:15:11,200
你有代表的能力
图片和GIF动画

337
00:15:11,200 --> 00:15:13,780
及其他这样的字符在屏幕上。

338
00:15:13,780 --> 00:15:17,160
而当你有一大堆的
图像飞被人一次，

339
00:15:17,160 --> 00:15:21,480
它看起来像电影，
所以你得到的视频也是如此。

340
00:15:21,480 --> 00:15:23,460
>> 因此，使用这些非常
简单的基本难道我们

341
00:15:23,460 --> 00:15:28,070
有代表的方式
最终，这些媒体形式的所有。

342
00:15:28,070 --> 00:15:30,450
而我们又抽象
一次又一次，直到我们

343
00:15:30,450 --> 00:15:33,467
从最低水平得到
这个最高水平。

344
00:15:33,467 --> 00:15:35,550
所以这给了我们这个
抽象的总体思路。

345
00:15:35,550 --> 00:15:36,990
但是，我们从这里开始。

346
00:15:36,990 --> 00:15:38,790
>> 在这里，现在，我们不妨
表示在一个计算机

347
00:15:38,790 --> 00:15:41,920
我们与零和的投入，
我们在零和一输出，

348
00:15:41,920 --> 00:15:43,640
但所发生的盒子里面？

349
00:15:43,640 --> 00:15:46,080
这就是计算机
科学变得有趣。

350
00:15:46,080 --> 00:15:49,770
这就是你真正把你
自己的心来承担解决问题。

351
00:15:49,770 --> 00:15:52,590
现在，我们可以规定，对于
本学期剩下的，是的。

352
00:15:52,590 --> 00:15:53,870
我知道如何二进制的作品。

353
00:15:53,870 --> 00:15:57,942
我记得ASCII或Unicode--
映射到letters--作品。

354
00:15:57,942 --> 00:15:59,650
它肯定代表
有理由相信，我们

355
00:15:59,650 --> 00:16:03,470
可能代表红色和绿色和
蓝，和代表多媒体为好。

356
00:16:03,470 --> 00:16:05,390
但是，这是有趣的东西。

357
00:16:05,390 --> 00:16:09,790
这是什么使一个人
能够解决的问题。

358
00:16:09,790 --> 00:16:11,980
>> 和一个这样的问题
我们喜欢做的事，事实上，

359
00:16:11,980 --> 00:16:15,345
正在出席，或
算法这样做。

360
00:16:15,345 --> 00:16:16,470
再次，我可能做到这一点。

361
00:16:16,470 --> 00:16:19,580
我可以做一，二，三，四
五，六，七，八九岁。

362
00:16:19,580 --> 00:16:21,520
我可以把它写
下降到跟踪它。

363
00:16:21,520 --> 00:16:23,769
但是，这只是我如何会
表示的信息。

364
00:16:23,769 --> 00:16:27,550
或者我能做到这一点faster--二，四，
六，八，十，12，14，16，18，20，

365
00:16:27,550 --> 00:16:30,380
22--感觉两倍
以最快的速度，但它仍然是

366
00:16:30,380 --> 00:16:32,050
要采取一个整体大量的时间。

367
00:16:32,050 --> 00:16:35,990
>> 但事实证明，如果我们还充分利用
另一个resource--确实电脑

368
00:16:35,990 --> 00:16:38,940
这些日子有多个CPU或大脑。

369
00:16:38,940 --> 00:16:41,970
原来电脑可以
同时做很多事情，

370
00:16:41,970 --> 00:16:44,460
而事实上，我们在这个房间里，
可能代表正是这一点。

371
00:16:44,460 --> 00:16:47,130
>> 所以这是一个小社会
尴尬，但如果你愿意我的幽默

372
00:16:47,130 --> 00:16:51,550
只是一个三步骤的过程，让
我的地方请大家那里只是

373
00:16:51,550 --> 00:16:54,640
站起来一会儿。

374
00:16:54,640 --> 00:16:57,380
站起来。

375
00:16:57,380 --> 00:17:01,580
所以想给自己，数
one--所以大家在这个房间里，

376
00:17:01,580 --> 00:17:05,010
但谁没有人
成人之美，都在思考一个数字。

377
00:17:05,010 --> 00:17:06,510
所以这是你的号码现在。

378
00:17:06,510 --> 00:17:09,399
这是第一步骤，或作为
计算机科学家或程序员

379
00:17:09,399 --> 00:17:11,827
通常会做的，我们要去
要从零开始计数。

380
00:17:11,827 --> 00:17:14,410
如果最小的数，我们可以
这些灯泡代表

381
00:17:14,410 --> 00:17:17,410
为零，只需让他们
所有的时候，我还不如干脆

382
00:17:17,410 --> 00:17:19,271
从开始计数
零是而不是一个。

383
00:17:19,271 --> 00:17:21,020
所以这就是
计算机科学家做的。

384
00:17:21,020 --> 00:17:23,750
所以零一步，站起来
想到头号。

385
00:17:23,750 --> 00:17:26,339
下一步骤是this--对
了与有人站在

386
00:17:26,339 --> 00:17:27,660
并添加您的数字加在一起。

387
00:17:27,660 --> 00:17:30,660

388
00:17:30,660 --> 00:17:32,850
精彩。

389
00:17:32,850 --> 00:17:37,640
>> 因此，在这个时刻，
从字面上大家参与

390
00:17:37,640 --> 00:17:41,930
正在考虑2号，除了
一个奇怪的人，如果我们有

391
00:17:41,930 --> 00:17:43,450
奇数的人在房间里。

392
00:17:43,450 --> 00:17:50,640
现在这里的第三步骤是要
是你this--应该坐下。

393
00:17:50,640 --> 00:17:54,490
其中一个，你应该坐下来，
如果你仍然屹立不倒，

394
00:17:54,490 --> 00:17:56,590
回到步骤之一。

395
00:17:56,590 --> 00:18:44,799

396
00:18:44,799 --> 00:18:45,790
好吧。

397
00:18:45,790 --> 00:19:00,760

398
00:19:00,760 --> 00:19:01,650
好吧。

399
00:19:01,650 --> 00:19:03,880
因此，越来越多的人
应该坐下。

400
00:19:03,880 --> 00:19:08,280
注意，这已引起
一个loop--某种循环。

401
00:19:08,280 --> 00:19:11,983
你们有些人应该是笨拙卡住，
来回第一步之间

402
00:19:11,983 --> 00:19:14,180
和二，一和二，一和二。

403
00:19:14,180 --> 00:19:21,190

404
00:19:21,190 --> 00:19:21,810
没关系。

405
00:19:21,810 --> 00:19:22,630
我们的第一个错误。

406
00:19:22,630 --> 00:19:24,740
我们会处理这一点。

407
00:19:24,740 --> 00:19:25,320
好吧。

408
00:19:25,320 --> 00:19:27,370
让我尝试以刺激顺水推舟。

409
00:19:27,370 --> 00:19:31,454
>> 理论上，只有一个人站在
大家都继续交配。

410
00:19:31,454 --> 00:19:33,870
但让我加快速度
随着人们仍然屹立不倒。

411
00:19:33,870 --> 00:19:35,480
你在想什么号码？

412
00:19:35,480 --> 00:19:36,070
46。

413
00:19:36,070 --> 00:19:36,570
好。

414
00:19:36,570 --> 00:19:37,820
来吧，坐下。

415
00:19:37,820 --> 00:19:39,190
你们仍然站立。

416
00:19:39,190 --> 00:19:42,130
谁在还站着？

417
00:19:42,130 --> 00:19:45,240
你在想什么号码？

418
00:19:45,240 --> 00:19:46,160
好。

419
00:19:46,160 --> 00:19:47,900
>> 因此，我们会回来给你。

420
00:19:47,900 --> 00:19:49,630
在后面？

421
00:19:49,630 --> 00:19:50,790
那是什么？

422
00:19:50,790 --> 00:19:53,100
22。

423
00:19:53,100 --> 00:19:56,540
确定别人了top--是吗？

424
00:19:56,540 --> 00:19:57,720
34。

425
00:19:57,720 --> 00:19:58,300
好。

426
00:19:58,300 --> 00:20:02,780
在这里我right--在这里？

427
00:20:02,780 --> 00:20:06,820
132，非常漂亮。

428
00:20:06,820 --> 00:20:08,380
22？

429
00:20:08,380 --> 00:20:08,990
>> 好。

430
00:20:08,990 --> 00:20:10,031
又是谁的还站着？

431
00:20:10,031 --> 00:20:11,000
在这里？

432
00:20:11,000 --> 00:20:14,520
46，很不错。

433
00:20:14,520 --> 00:20:16,890
72。

434
00:20:16,890 --> 00:20:18,220
我再也不能拖延。

435
00:20:18,220 --> 00:20:20,520
是吗？

436
00:20:20,520 --> 00:20:22,490
30，美观大方。

437
00:20:22,490 --> 00:20:24,120
在这里？

438
00:20:24,120 --> 00:20:26,200
23？

439
00:20:26,200 --> 00:20:27,270
23。

440
00:20:27,270 --> 00:20:30,920
>> 我认为这是每个人
除了你们，没有压力。

441
00:20:30,920 --> 00:20:32,860
等一下。

442
00:20:32,860 --> 00:20:33,360
28？

443
00:20:33,360 --> 00:20:37,500

444
00:20:37,500 --> 00:20:38,281
只是八强。

445
00:20:38,281 --> 00:20:38,780
好。

446
00:20:38,780 --> 00:20:41,030
只是八强。

447
00:20:41,030 --> 00:20:42,580
到这里？

448
00:20:42,580 --> 00:20:44,570
30。

449
00:20:44,570 --> 00:20:47,344
23。

450
00:20:47,344 --> 00:20:47,843
24。

451
00:20:47,843 --> 00:20:50,810

452
00:20:50,810 --> 00:20:52,310
18。

453
00:20:52,310 --> 00:20:54,690
这是最坏的实施
这个算法永远。

454
00:20:54,690 --> 00:20:55,190
好。

455
00:20:55,190 --> 00:20:59,760
所以其他人？

456
00:20:59,760 --> 00:21:00,421
还有谁？

457
00:21:00,421 --> 00:21:00,920
好。

458
00:21:00,920 --> 00:21:03,300
多一个。

459
00:21:03,300 --> 00:21:04,400
16？

460
00:21:04,400 --> 00:21:04,900
好。

461
00:21:04,900 --> 00:21:05,510
16。

462
00:21:05,510 --> 00:21:06,010
好吧。

463
00:21:06,010 --> 00:21:09,070
所以，如果我没有错过任何人
这里的眩光，当我敲回车，

464
00:21:09,070 --> 00:21:13,091
我们将看到，算法的
总人数的桑德斯中。

465
00:21:13,091 --> 00:21:16,340
因为再次，它好像每个人都
当你坐下来，通过你的号码了

466
00:21:16,340 --> 00:21:19,215
给别人，给别人，
给别人，因此，在理论上，

467
00:21:19,215 --> 00:21:22,304
最终，只有一个尴尬
人要罚站。

468
00:21:22,304 --> 00:21:22,970
但是，这很好。

469
00:21:22,970 --> 00:21:24,290
我们手动加快东西。

470
00:21:24,290 --> 00:21:27,590
这是特别难得一见
在这个特殊的空间。

471
00:21:27,590 --> 00:21:34,200
>> 和人的总数
我们认为这里有546是。

472
00:21:34,200 --> 00:21:37,330
总数有人递给我
通过教学研究员，

473
00:21:37,330 --> 00:21:40,660
谁做旧
学校缓慢的方式，是820。

474
00:21:40,660 --> 00:21:43,660
>> [笑]

475
00:21:43,660 --> 00:21:47,170
>> [掌声]

476
00:21:47,170 --> 00:21:48,670
>> 没关系。

477
00:21:48,670 --> 00:21:50,740
所以那么肯定，有这些错误。

478
00:21:50,740 --> 00:21:51,460
这很好。

479
00:21:51,460 --> 00:21:53,810
等回想起这
在第一时间的东西

480
00:21:53,810 --> 00:21:55,420
你写的不一定工作。

481
00:21:55,420 --> 00:21:57,620
这发生在我这里。

482
00:21:57,620 --> 00:22:00,844
但是，让我们现在考虑我们如何
应用此相同的想法的东西

483
00:22:00,844 --> 00:22:03,760
你可能已经见过的，这
这是老派技术这里 -

484
00:22:03,760 --> 00:22:05,130
一个真正的大电话簿。

485
00:22:05,130 --> 00:22:09,380
并假设该电话簿
有1000页和1000名

486
00:22:09,380 --> 00:22:11,360
和数字字母顺序在它的内部。

487
00:22:11,360 --> 00:22:14,860
>> 嗯，我们可以种应用相似
主意，这个非常实际的问题，

488
00:22:14,860 --> 00:22:16,270
只是在利用我。

489
00:22:16,270 --> 00:22:18,810
我只是有种被骗
通过利用大家

490
00:22:18,810 --> 00:22:23,240
有很多很多不同的CPU
或大脑执行某种算法。

491
00:22:23,240 --> 00:22:25,440
但是，如果它只是小
以前的我，我还是可以

492
00:22:25,440 --> 00:22:29,630
利用一个想法相同的本质
分治的问题

493
00:22:29,630 --> 00:22:32,970
一遍又一遍，这样你一半，
一半的你，你一半，你一半，

494
00:22:32,970 --> 00:22:35,830
理论上保持坐下，
直到我们被留下，理论上

495
00:22:35,830 --> 00:22:36,990
只有一个人。

496
00:22:36,990 --> 00:22:39,810
>> 因此，在这个老同学
技术 - 我们不

497
00:22:39,810 --> 00:22:43,030
需要这个map--这
老派的技术，

498
00:22:43,030 --> 00:22:47,300
我们可能会开始找人
喜欢迈克·史密斯，一次一个页面。

499
00:22:47,300 --> 00:22:49,410
而我看​​到没有，迈克不在这里。

500
00:22:49,410 --> 00:22:51,110
我仍然在A部分。

501
00:22:51,110 --> 00:22:53,900
最后，我发现
自己在B部分。

502
00:22:53,900 --> 00:22:56,910
这是一种算法 -
一步一步的指示。

503
00:22:56,910 --> 00:22:59,890
从头开始，一个页面
在一个时间，找迈克·史密斯。

504
00:22:59,890 --> 00:23:03,410
这是correct--这
算法或方法？

505
00:23:03,410 --> 00:23:04,550
>> 是的，这是正确的。

506
00:23:04,550 --> 00:23:06,840
如果麦克在这里，最终
我会得到他。

507
00:23:06,840 --> 00:23:08,139
但它的效率不高。

508
00:23:08,139 --> 00:23:09,180
这显然​​很慢。

509
00:23:09,180 --> 00:23:11,340
因此，我可以利用
同样twosies接近。

510
00:23:11,340 --> 00:23:15,350
我能做到几分二，
四，六，八，十，十二。

511
00:23:15,350 --> 00:23:16,330
它的快两倍。

512
00:23:16,330 --> 00:23:18,290
我会去麦克
如果他有速度更快。

513
00:23:18,290 --> 00:23:20,770
这是对的吗？

514
00:23:20,770 --> 00:23:22,320
是的，但我听到了little--没有。

515
00:23:22,320 --> 00:23:24,200
现在，我听到了没有。

516
00:23:24,200 --> 00:23:24,700
是啊。

517
00:23:24,700 --> 00:23:26,190
还有一个潜在的错误。

518
00:23:26,190 --> 00:23:29,374
也许只是迈克不慎
夹在两页之间，

519
00:23:29,374 --> 00:23:31,290
因为我飞过
这两个位于一个时间。

520
00:23:31,290 --> 00:23:33,580
所以，至少我们需要一些
这种条件修复。

521
00:23:33,580 --> 00:23:35,330
我需要说，哎，
如果我打的人

522
00:23:35,330 --> 00:23:39,190
名字为T，而不是一个S开始，
我更好的双回至少一个页面。

523
00:23:39,190 --> 00:23:40,767
因此，车在第一，但可以解决的。

524
00:23:40,767 --> 00:23:43,850
但是没有人会去寻找
迈克·史密斯通过1000页的电话

525
00:23:43,850 --> 00:23:45,290
同时预订一页。

526
00:23:45,290 --> 00:23:48,486
什么是正常的人怎么办呢？

527
00:23:48,486 --> 00:23:50,860
你会去到S的，
如果你知道S其中的。

528
00:23:50,860 --> 00:23:54,230
你可以粗略地去中间
或接近尾声略倾斜。

529
00:23:54,230 --> 00:23:56,850
而我在这里往下看，
我在M部分。

530
00:23:56,850 --> 00:23:58,952
但是你怎么知道
这个问题现在，

531
00:23:58,952 --> 00:24:02,160
我们并不一定知道前
与我们所有的人只是计算自己

532
00:24:02,160 --> 00:24:03,030
等效？

533
00:24:03,030 --> 00:24:06,010
那么，迈克显然将
要在这一半的书

534
00:24:06,010 --> 00:24:07,920
如果他在这里，因为在所有它的排序。

535
00:24:07,920 --> 00:24:10,160
>> 所以你可以很dramatically--

536
00:24:10,160 --> 00:24:11,250
>> [喘气]

537
00:24:11,250 --> 00:24:12,300
>> 我知道。

538
00:24:12,300 --> 00:24:16,940
>> [掌声]

539
00:24:16,940 --> 00:24:19,450
>> 它实际上是很容易的，如果
你做下来脊椎那里。

540
00:24:19,450 --> 00:24:22,070
但是你可以再扔
问题的一半的路程。

541
00:24:22,070 --> 00:24:25,950
现在，我留下了相同的problem--
找到迈克·史密斯在接受电话book--

542
00:24:25,950 --> 00:24:29,610
但现在的电话簿在m启动
并进入Z，但它的一半大。

543
00:24:29,610 --> 00:24:30,890
>> 但是，这是何等的令人印象深刻。

544
00:24:30,890 --> 00:24:34,170
就像在理论上，你们这些家伙，当
大家坐下来只有一半的时间，

545
00:24:34,170 --> 00:24:37,150
这个问题得到了一半大，
一半大，一遍又一遍。

546
00:24:37,150 --> 00:24:40,260
所以有这个问题成为了
同样的问题，但一半大。

547
00:24:40,260 --> 00:24:42,670
现在，这是一个250页的问题。

548
00:24:42,670 --> 00:24:45,340
当我意识到，哦，我
在T节意外。

549
00:24:45,340 --> 00:24:46,590
太远了，我走了。

550
00:24:46,590 --> 00:24:48,500
我可以抛出一半
的电话本了。

551
00:24:48,500 --> 00:24:50,410
现在，我到一个
问题的四分之一。

552
00:24:50,410 --> 00:24:53,910
>> 而且可以重复，重复，
重复，直到，在理论上，你

553
00:24:53,910 --> 00:24:55,460
只剩下一个页面。

554
00:24:55,460 --> 00:24:59,010
如果迈克是在该网页上，
我现在可以解决这个问题。

555
00:24:59,010 --> 00:25:00,810
但如何迅速没我解决呢？

556
00:25:00,810 --> 00:25:05,420
在第一种情况下，花了我喜欢
也许1000步找到迈克·史密斯。

557
00:25:05,420 --> 00:25:09,260
它可能采取我 -
我拿起电话本

558
00:25:09,260 --> 00:25:11,440
于是我开始寻找
一个页面的时间，

559
00:25:11,440 --> 00:25:13,480
和迈克可能是1000页之后。

560
00:25:13,480 --> 00:25:16,020
>> 第二条本办法也许
花了我500步，

561
00:25:16,020 --> 00:25:17,960
因为我飞
通过两个一次。

562
00:25:17,960 --> 00:25:21,082
而第三种方法虽然，
这是特别强大。

563
00:25:21,082 --> 00:25:23,790
但是，让我们考虑一下我们实际
做这种第三种方法。

564
00:25:23,790 --> 00:25:27,590
我要什么，我会打电话给这些刚
陈述在这里，一次一个。

565
00:25:27,590 --> 00:25:28,560
拿起电话簿。

566
00:25:28,560 --> 00:25:30,130
打开到电话簿的中间。

567
00:25:30,130 --> 00:25:31,419
看名字。

568
00:25:31,419 --> 00:25:33,960
然后，事情变得有点
更有趣的智力，

569
00:25:33,960 --> 00:25:35,170
如果仍然简单。

570
00:25:35,170 --> 00:25:38,350
如果史密斯是其中
即当前页面上的名字，

571
00:25:38,350 --> 00:25:40,170
然后做一些有条件。

572
00:25:40,170 --> 00:25:41,840
这就像在一个岔路口。

573
00:25:41,840 --> 00:25:42,660
呼叫迈克。

574
00:25:42,660 --> 00:25:44,930
如果迈克是名中
在该网页上，叫麦克。

575
00:25:44,930 --> 00:25:49,720
但只能做四线如果线
树，如果你愿意，是真实的。

576
00:25:49,720 --> 00:25:51,590
在回答这个问题是肯定的。

577
00:25:51,590 --> 00:25:55,520
>> 否则，如果史密斯早在book--
换句话说，如果我在M节

578
00:25:55,520 --> 00:25:58,540
我期待有人来
左边，那么我应该怎么办

579
00:25:58,540 --> 00:26:00,300
是非常类似的东西。

580
00:26:00,300 --> 00:26:03,440
然后，我应该开到中间
的书的左半部。

581
00:26:03,440 --> 00:26:07,930
于是往左走，然后
回到第二步。

582
00:26:07,930 --> 00:26:09,290
看名字在那里。

583
00:26:09,290 --> 00:26:12,779
>> 因此，换句话说，做同样的事情，
但是，一个问题一个已经减半。

584
00:26:12,779 --> 00:26:13,570
你知道还有什么？

585
00:26:13,570 --> 00:26:16,470
如果史密斯后来在书
基于我期待在页面上，

586
00:26:16,470 --> 00:26:18,790
开放的中间
书的右半

587
00:26:18,790 --> 00:26:22,050
然后再回去
步骤二，else--

588
00:26:22,050 --> 00:26:24,000
这里有一个第四种可能性。

589
00:26:24,000 --> 00:26:28,830
迈克的这里或向左
或向右或不存在。

590
00:26:28,830 --> 00:26:30,570
在这里，我们更好地考虑这一点。

591
00:26:30,570 --> 00:26:33,360
而事实上，如果你曾经
您的计算机崩溃只是你，

592
00:26:33,360 --> 00:26:36,822
即有时但不总是，在
只是人类程序员的结果不

593
00:26:36,822 --> 00:26:39,280
实现哦拍，有
其实这第四个场景。

594
00:26:39,280 --> 00:26:41,650
如果你不写代码
处理这种情况，

595
00:26:41,650 --> 00:26:43,220
有时候你不知道
哪些电脑可以做。

596
00:26:43,220 --> 00:26:44,770
事实上一个程序可能会崩溃。

597
00:26:44,770 --> 00:26:47,550
>> 但是，在这种情况下，我想
这件事，和我说，别的不干了，

598
00:26:47,550 --> 00:26:49,850
因为这是第四
逻辑可能的情况。

599
00:26:49,850 --> 00:26:51,950
现在，让我们只需添加
一些词汇，所以我们

600
00:26:51,950 --> 00:26:55,320
可以开始折腾围绕该条款
在其他方面非常直观。

601
00:26:55,320 --> 00:26:57,870
所有的事情我已经只是
以黄色突出显示在这里，

602
00:26:57,870 --> 00:27:00,140
我只是要去
函数或过程。

603
00:27:00,140 --> 00:27:01,590
他们只是一种行动。

604
00:27:01,590 --> 00:27:04,900
所以回暖，开放的，看
在，打电话，开，开，

605
00:27:04,900 --> 00:27:09,170
quit--这些都只是行动，否则我们将
叫他们更正式，功能。

606
00:27:09,170 --> 00:27:11,410
>> 同时，现在在黄，
我强调的东西

607
00:27:11,410 --> 00:27:14,084
that--就让我们开始打电话
这些条件或分支机构。

608
00:27:14,084 --> 00:27:16,750
这些点决定在哪里
你可能会走这条路，这样一来，

609
00:27:16,750 --> 00:27:18,100
或一些其它方向仍。

610
00:27:18,100 --> 00:27:19,430
因此，那些会的条件。

611
00:27:19,430 --> 00:27:20,930
而现在这个有点票友。

612
00:27:20,930 --> 00:27:24,600
让我们把这些问题
布尔表达式，

613
00:27:24,600 --> 00:27:26,530
有人用姓布尔之后。

614
00:27:26,530 --> 00:27:28,340
>> 和布尔表达式
只是事

615
00:27:28,340 --> 00:27:30,290
这是真或假，是或否。

616
00:27:30,290 --> 00:27:35,870
因此，它的回答你的问题
关心，以便在条件

617
00:27:35,870 --> 00:27:39,210
使decision--得到一个答案，
然后去左或右，或东西

618
00:27:39,210 --> 00:27:40,450
否则干脆。

619
00:27:40,450 --> 00:27:42,860
>> 然后最后，这些
线这里 - 回去

620
00:27:42,860 --> 00:27:44,737
步骤二，回去
步骤two--我们可以

621
00:27:44,737 --> 00:27:46,320
实现这个想法的方式不同。

622
00:27:46,320 --> 00:27:49,028
然后，那些有
编程经验，可能会做

623
00:27:49,028 --> 00:27:50,670
或者可以想像不同的这样做。

624
00:27:50,670 --> 00:27:53,170
但是今天的目的，这是
只是重要的想法。

625
00:27:53,170 --> 00:27:55,400
这是什么诱发
我们一般会打电话

626
00:27:55,400 --> 00:28:00,110
一个loop--某种周期的，因为
它使我再做些什么。

627
00:28:00,110 --> 00:28:03,340
>> 所以，现在，我们只考虑
怎么好这种算法。

628
00:28:03,340 --> 00:28:03,899
这是正确的。

629
00:28:03,899 --> 00:28:06,940
如果麦克在书中，这是一个
这四个连连scenarios--

630
00:28:06,940 --> 00:28:08,023
又一次，我们会找到他的。

631
00:28:08,023 --> 00:28:08,890
但是，它有多好？

632
00:28:08,890 --> 00:28:10,150
好了，我们没有
太正式在这里。

633
00:28:10,150 --> 00:28:12,066
但是，我们刚刚绘制
东西，x和y，以获得

634
00:28:12,066 --> 00:28:14,470
这个问题的形状感。

635
00:28:14,470 --> 00:28:17,160
>> 在x轴这里是
我的问题的规模。

636
00:28:17,160 --> 00:28:20,256
他们y轴位置
将要解决的时间。

637
00:28:20,256 --> 00:28:21,630
因此，也许这就是页数。

638
00:28:21,630 --> 00:28:24,400
也许这是秒
turns--任何网页。

639
00:28:24,400 --> 00:28:27,290
然而，你要算的
这是什么画面将代表。

640
00:28:27,290 --> 00:28:30,630
而这第一个算法，我要去
描述只是一个直线。

641
00:28:30,630 --> 00:28:33,120
如果有n个网页
电话簿，然后将其

642
00:28:33,120 --> 00:28:36,010
可能要花费许多
作为n步找迈克。

643
00:28:36,010 --> 00:28:38,930
如果Verizon公司或电话公司
增加了一个更多的页面，明年

644
00:28:38,930 --> 00:28:42,170
它可能需要我多step--
时间一个单位找迈克。

645
00:28:42,170 --> 00:28:44,230
所以这是仅此一比一的比例。

646
00:28:44,230 --> 00:28:45,970
这是一个直线的斜率。

647
00:28:45,970 --> 00:28:49,110
>> 与此同时，第二
算法 - 如果我

648
00:28:49,110 --> 00:28:51,570
在时间 -  2去二，
四，六，八，或double--

649
00:28:51,570 --> 00:28:54,550
通过网页去两次
在一个时间，每次两个，

650
00:28:54,550 --> 00:28:55,710
它仍然是直线。

651
00:28:55,710 --> 00:28:58,720
现在有一到两
比，但只是有点低。

652
00:28:58,720 --> 00:29:02,240
所以，如果有这么多的网页
在此图中黄色，

653
00:29:02,240 --> 00:29:04,800
这可能需要我这个
许多步骤或秒，

654
00:29:04,800 --> 00:29:07,980
否则它会带我
两倍的红线。

655
00:29:07,980 --> 00:29:10,190
>> 但是，绿线是真正的外卖。

656
00:29:10,190 --> 00:29:12,290
这是我们一般什么
调用logorithm--日志

657
00:29:12,290 --> 00:29:13,840
的n，其中n是页数。

658
00:29:13,840 --> 00:29:16,450
但它是重要的形状
今天，因为我们没有

659
00:29:16,450 --> 00:29:17,950
别想绘制点。

660
00:29:17,950 --> 00:29:19,830
>> 想想一个极端的情况。

661
00:29:19,830 --> 00:29:23,070
假设Verizon公司明天的双打
在该电话本的页数，

662
00:29:23,070 --> 00:29:24,900
从1000至2000。

663
00:29:24,900 --> 00:29:28,440
在第一算法，我
可能会浪费额外的1000

664
00:29:28,440 --> 00:29:32,080
步骤寻找迈克，只是因为
Verizon的一倍书的大小。

665
00:29:32,080 --> 00:29:34,740
算法 - 这第二个可能
带我一个额外的500步。

666
00:29:34,740 --> 00:29:38,370
1000多页，我走两头在
时间 -  500多个步骤，找到迈克。

667
00:29:38,370 --> 00:29:41,020
>> 但是，第三算法
是种神奇。

668
00:29:41,020 --> 00:29:44,270
Verizon的双打数量
从1000至2000页，

669
00:29:44,270 --> 00:29:47,730
但究竟有多少更多的步骤做
它带我去找迈克？

670
00:29:47,730 --> 00:29:51,220
这只是一个，因为我可以
撕电话簿一次

671
00:29:51,220 --> 00:29:55,280
从2000页问题一
1000页的问题，瞧。

672
00:29:55,280 --> 00:29:57,030
我已经采取了大规模的咬出来。

673
00:29:57,030 --> 00:29:59,405
>> 如果你去非常极端的，
假设该电话簿

674
00:29:59,405 --> 00:30:03,600
公司有什么样的疯狂
4十亿页电话簿。

675
00:30:03,600 --> 00:30:07,020
那么它多少步可能需要
找到迈克·史密斯在4十亿

676
00:30:07,020 --> 00:30:09,990
页电话簿？

677
00:30:09,990 --> 00:30:16,450
这是一个大数目，但只有4十亿到
2十亿至1十亿至500亿美元，

678
00:30:16,450 --> 00:30:18,720
250 million--仍
听起来像大的数字，

679
00:30:18,720 --> 00:30:20,980
但我很快
得到一个较小值。

680
00:30:20,980 --> 00:30:24,790
>> 而事实上，如果我做数学题
好吧，我只能分4个十亿

681
00:30:24,790 --> 00:30:28,750
前了大约32倍
我踏踏实实地只有一个。

682
00:30:28,750 --> 00:30:31,640
因此，如果这电话簿分别为4
十亿页长，没什么大不了的。

683
00:30:31,640 --> 00:30:35,270
在几秒钟内，也许32
秒，我可以一分为它

684
00:30:35,270 --> 00:30:39,560
并最终找到麦克或
断定他不在那里。

685
00:30:39,560 --> 00:30:42,219
这就是一个企业的本质
算法 - 一个好的算法。

686
00:30:42,219 --> 00:30:44,260
这就是之一
像这样一类的目标，

687
00:30:44,260 --> 00:30:47,350
正在试图找出我怎么
只是正确地解决问题没有，

688
00:30:47,350 --> 00:30:52,360
就像我一直都知道怎么做这件事
在时间 - 页面，但正确和幸福。

689
00:30:52,360 --> 00:30:55,034
如何设计好
解决问题的办法？

690
00:30:55,034 --> 00:30:57,200
因此，让我们花点时间在这里
现在给你一个感觉

691
00:30:57,200 --> 00:31:00,260
CS50的过程itself--介绍
几场的工作人员。

692
00:31:00,260 --> 00:31:02,010
就在凌晨2点之前，我们将
短暂休息

693
00:31:02,010 --> 00:31:03,520
使那些您
谁是购物能

694
00:31:03,520 --> 00:31:05,130
逃避并采取
看一些其他类

695
00:31:05,130 --> 00:31:06,580
看着这个网络的其余部分。

696
00:31:06,580 --> 00:31:09,250
但现在，让我来介绍
CS50，类本身，

697
00:31:09,250 --> 00:31:11,330
特别是什么新鲜事。

698
00:31:11,330 --> 00:31:13,960
>> 因此，在过去的春天，我们
花了相当多的时间 -

699
00:31:13,960 --> 00:31:17,911
课程的工作人员和我 - 思考
它是什么，我们希望CS50是，

700
00:31:17,911 --> 00:31:19,910
和重返第一
的原则，可以这么说，

701
00:31:19,910 --> 00:31:22,760
要考虑什么是我们想要的
本课程的样子，并

702
00:31:22,760 --> 00:31:23,740
像它的学生。

703
00:31:23,740 --> 00:31:26,480
所以你会看到问题
设置零为好，邀请

704
00:31:26,480 --> 00:31:28,780
看看那个
URL其中概述

705
00:31:28,780 --> 00:31:33,270
一些背后的动机
以下2016年秋季的特点。

706
00:31:33,270 --> 00:31:35,570
>> 所以，你可能已经收集
从TL：DR讲义，

707
00:31:35,570 --> 00:31:39,060
今天的课程，以及从
课程目录，今年CS50，

708
00:31:39,060 --> 00:31:42,540
你只是将出席
today--这样的工作做好done--

709
00:31:42,540 --> 00:31:45,960
并在11月21日最后一次演讲。

710
00:31:45,960 --> 00:31:49,150
而你是受欢迎的，但预计不会
参加这些讲座在中间，

711
00:31:49,150 --> 00:31:51,180
因为我们在做什么
今年，正在拍摄

712
00:31:51,180 --> 00:31:52,661
在实时过程中的材料。

713
00:31:52,661 --> 00:31:54,660
所以一切都将保持
当前和合并

714
00:31:54,660 --> 00:31:57,410
作为最好的，我们can--时事
和交谈的人可能

715
00:31:57,410 --> 00:32:00,400
在工业上具有在
世界，但使该材料

716
00:32:00,400 --> 00:32:03,892
可用的，作为结果，即使先前已经
完整的全文成绩单

717
00:32:03,892 --> 00:32:05,850
和检索性
其他资源的链接。

718
00:32:05,850 --> 00:32:07,930
>> 事实上，我们已经
声称了一段时间

719
00:32:07,930 --> 00:32:10,830
而我们现在相信这一点，
我们可以创建，数字化，

720
00:32:10,830 --> 00:32:15,170
更逼真，更引人注目
教育经验，而不是

721
00:32:15,170 --> 00:32:19,110
到这里聚会大约23倍
在人，听见有人喜欢我

722
00:32:19,110 --> 00:32:22,925
简单谈谈计算机科学，
相对于卡合更积极。

723
00:32:22,925 --> 00:32:25,800
所以，你在使用过程中的教学大纲看
本学期的草图在这里，

724
00:32:25,800 --> 00:32:27,840
随着当宣讲会
被拍摄下来，到你

725
00:32:27,840 --> 00:32:29,710
欢迎，但预计不会，
当他们将

726
00:32:29,710 --> 00:32:31,640
在球场上的网站上公布。

727
00:32:31,640 --> 00:32:34,300
>> 而我们会在这里做
周三下周开始，

728
00:32:34,300 --> 00:32:37,362
很多更紧密，只有
谁不想参加那些人，

729
00:32:37,362 --> 00:32:39,820
是所谓的穿行，
在那里我和课程的头

730
00:32:39,820 --> 00:32:41,730
实际上让事情
一点更贴心

731
00:32:41,730 --> 00:32:44,313
到这里的乐队
节中，仍然有一些技术

732
00:32:44,313 --> 00:32:46,365
并通过走
本周的习题集，

733
00:32:46,365 --> 00:32:50,020
并为您提供particularly--如果中间
那些少comfortable--更加

734
00:32:50,020 --> 00:32:52,790
您可能要指导或
需要一周的挑战。

735
00:32:52,790 --> 00:32:55,820
同样，对于那些谁不能
参加那些人，没什么大不了的。

736
00:32:55,820 --> 00:32:58,486
会有由类似地导致
课程的高级职员之一，

737
00:32:58,486 --> 00:33:02,650
Zamalya，同样的机会嵌入式
在习题自己。

738
00:33:02,650 --> 00:33:04,960
>> 问题今年台
将在周五公布

739
00:33:04,960 --> 00:33:08,080
不再做七天后，
但10天later--故意

740
00:33:08,080 --> 00:33:10,910
重叠的每个问题
设置，这样才能更好地适应，

741
00:33:10,910 --> 00:33:13,050
我们希望，潮起潮落
在学生的时间表，

742
00:33:13,050 --> 00:33:16,550
尤其是在期中考试或竞技
或学者或课外活动

743
00:33:16,550 --> 00:33:18,465
往往来去
尤其是期中。

744
00:33:18,465 --> 00:33:21,340
这应该给你多一点
自由裁量权是否你面前

745
00:33:21,340 --> 00:33:25,690
与CS50或背部负荷加载周
它在接下来的周末吧。

746
00:33:25,690 --> 00:33:28,817
所以，看该课程的教学大纲
此处其时间表。

747
00:33:28,817 --> 00:33:30,900
你会发现其中也
今年的变化，

748
00:33:30,900 --> 00:33:34,082
对于那些更熟悉
编程在过去，

749
00:33:34,082 --> 00:33:36,290
我们将启动该学期
我们今天会在划痕，

750
00:33:36,290 --> 00:33:39,730
尤其是注重语言
所谓C，然后过渡不

751
00:33:39,730 --> 00:33:43,430
到PHP，而是一个叫做语言
对学期结束的Python

752
00:33:43,430 --> 00:33:46,565
在web编程的情况下，
随着SQL和JavaScript，

753
00:33:46,565 --> 00:33:48,930
HTML，CSS，并且还更。

754
00:33:48,930 --> 00:33:51,790
>> 而在回答常见问题，
它的确是这样的

755
00:33:51,790 --> 00:33:55,520
即CS并不像我那么可怕一次
以为是，但它是许多工作

756
00:33:55,520 --> 00:33:57,280
因为我听说它可能是。

757
00:33:57,280 --> 00:34:03,210
但是，这是说，这里有一些
从2015年秋季学生身上的统计，

758
00:34:03,210 --> 00:34:06,460
从而水平蓝线
代表的时间的平均数量

759
00:34:06,460 --> 00:34:06,960
报道。

760
00:34:06,960 --> 00:34:10,570
你会看到的平均
六至10〜12--也许16

761
00:34:10,570 --> 00:34:14,580
左右等，但与
高方差予以明确。

762
00:34:14,580 --> 00:34:18,570
因此意识到，不仅有
学生更舒适，减少

763
00:34:18,570 --> 00:34:22,150
舒服在使用过程中，
但相应的支持

764
00:34:22,150 --> 00:34:25,699
结构得到那些学生
通过成功的学期。

765
00:34:25,699 --> 00:34:29,409
>> 事实上，在回答常见问题，应
你把CS50作为第一年？

766
00:34:29,409 --> 00:34:30,139
绝对。

767
00:34:30,139 --> 00:34:32,690
而事实上，我很遗憾
没有发现我的方式

768
00:34:32,690 --> 00:34:35,170
或者发现了一个新的领域
第一年为好。

769
00:34:35,170 --> 00:34:39,149
你应该采取与CS50
其他课程，一定会与well--

770
00:34:39,149 --> 00:34:41,940
和一般建议我们不妨
给学生，这CS50可能是

771
00:34:41,940 --> 00:34:44,929
不是那种类或介绍类
你应该采取三个

772
00:34:44,929 --> 00:34:47,199
其他或其他四名P-设置课程。

773
00:34:47,199 --> 00:34:50,583
但是，如果你正在做另外两个P-集
班，别的东西，和CS50，

774
00:34:50,583 --> 00:34:51,499
绝对的管理。

775
00:34:51,499 --> 00:34:54,900
我有很多学生在
过去这样做相当成功。

776
00:34:54,900 --> 00:34:57,490
>> 并让你往那
终点线成功，

777
00:34:57,490 --> 00:35:00,260
它的过程中有sections--
不同轨道的学生

778
00:35:00,260 --> 00:35:03,100
不太舒服，更舒适，
和介于两者之间，

779
00:35:03,100 --> 00:35:04,850
因此在使用过程中的
第一个问题集，

780
00:35:04,850 --> 00:35:06,360
你会被要求来形容自己。

781
00:35:06,360 --> 00:35:09,151
如果你是在那些较少
舒适，它的那种东西

782
00:35:09,151 --> 00:35:10,420
您刚才宁知。

783
00:35:10,420 --> 00:35:13,010
事实上，这一直是该
在CS50人口不断增长

784
00:35:13,010 --> 00:35:14,090
了好几年。

785
00:35:14,090 --> 00:35:17,680
>> 由于去年秋天对
例如，所述类的58％

786
00:35:17,680 --> 00:35:20,560
言必称
在那些不那么舒服，

787
00:35:20,560 --> 00:35:23,210
用在那些9％
舒服，然后

788
00:35:23,210 --> 00:35:25,900
其他学生那里
红描述自己

789
00:35:25,900 --> 00:35:27,890
如介于两者之间。

790
00:35:27,890 --> 00:35:31,980
你会总体看到这里的主题
和调度部的，所有这些都

791
00:35:31,980 --> 00:35:34,820
均以人，
实时，与课程的

792
00:35:34,820 --> 00:35:38,320
教学研究员惊人的工作人员
当然助理，其中一些人

793
00:35:38,320 --> 00:35:39,660
你会在短短的时刻见面。

794
00:35:39,660 --> 00:35:42,993
>> 自己的部分，因为你会看到，会
是周一和周二和周三，

795
00:35:42,993 --> 00:35:45,910
这样才能让你潜水
在搞，如果你打完

796
00:35:45,910 --> 00:35:48,110
选择，在使用过程中的
那个星期早些时候的演讲。

797
00:35:48,110 --> 00:35:51,420
然后办公时间，这
当然，每过一年，

798
00:35:51,420 --> 00:35:54,110
已经没有任何的少
挑战的课程。

799
00:35:54,110 --> 00:35:57,040
而今年，我们计划不
仅任职hours-- 1

800
00:35:57,040 --> 00:36:00,300
在为帮助，人的机遇
学生在周三周四

801
00:36:00,300 --> 00:36:03,790
周日，最后那些
在下午的设计是

802
00:36:03,790 --> 00:36:06,910
降低一些应力那
与深夜总是出现

803
00:36:06,910 --> 00:36:10,180
加上一个期限对settting looming--
但办公时间也将提供

804
00:36:10,180 --> 00:36:14,920
周一和周二和
星期三和星期五和星期六，

805
00:36:14,920 --> 00:36:17,080
感谢我们的朋友HSA。

806
00:36:17,080 --> 00:36:20,330
>> CS50现在有自己的空间
学生和工作人员CS50，

807
00:36:20,330 --> 00:36:23,070
67之上奥本山街，
正确的，在哈佛广场。

808
00:36:23,070 --> 00:36:26,340
该愿景这是CS50的
课题组中科院整个星期，

809
00:36:26,340 --> 00:36:29,052
在大多数几乎
天，将在那里寻求支持。

810
00:36:29,052 --> 00:36:30,760
所以，如果你有一些
上的p组质询

811
00:36:30,760 --> 00:36:33,093
或者你感觉有点
堵塞或有点困惑，

812
00:36:33,093 --> 00:36:35,640
和Heck，你有一个小时
类之间的一个半小时，

813
00:36:35,640 --> 00:36:38,920
尤其是在square--你能
流行的和有问题的回答

814
00:36:38,920 --> 00:36:41,720
有这混乱clarified--
非常的精神，

815
00:36:41,720 --> 00:36:45,490
你熟悉的数学
部门自身的数学问题中心，

816
00:36:45,490 --> 00:36:49,300
但围绕每个时钟几乎
[？克卡？]我们将在网上发布。

817
00:36:49,300 --> 00:36:52,400
>> 家教也可用于那些
学生，自由地从课程的

818
00:36:52,400 --> 00:36:54,750
自己的员工，如果你想
更贴心的一对一，

819
00:36:54,750 --> 00:36:58,940
或者只有两三个同学，工作
随着病程的工作人员之一。

820
00:36:58,940 --> 00:37:02,320
而事实上，这些在这里都只是
有些课程的工作人员，

821
00:37:02,320 --> 00:37:04,120
其中一些你会
在短短的时刻见面。

822
00:37:04,120 --> 00:37:07,440
事实上，CS50自身
头助教，

823
00:37:07,440 --> 00:37:09,790
和头部课程
助理，导师，

824
00:37:09,790 --> 00:37:12,998
可以上来吧，让
他们打招呼。

825
00:37:12,998 --> 00:37:22,498
>> [掌声]

826
00:37:22,498 --> 00:37:23,456
解说1：[听不清]。

827
00:37:23,456 --> 00:37:51,842

828
00:37:51,842 --> 00:37:57,856
>> [掌声]

829
00:37:57,856 --> 00:37:58,814
解说2：[听不清]。

830
00:37:58,814 --> 00:38:17,240

831
00:38:17,240 --> 00:38:27,238
>> [掌声]

832
00:38:27,238 --> 00:38:28,196
解说3：[听不清]。

833
00:38:28,196 --> 00:38:58,951

834
00:38:58,951 --> 00:39:03,120
>> [掌声]

835
00:39:03,120 --> 00:39:06,740
>> DAVID MALAN：，让我们
带来CS50的董事会两个最

836
00:39:06,740 --> 00:39:09,730
高级职员，罗布和Zamayla为好。

837
00:39:09,730 --> 00:39:15,120
>> [掌声]

838
00:39:15,120 --> 00:39:17,226
>> 事实上，无论是罗布和
Zamayla一直伴随着我们

839
00:39:17,226 --> 00:39:19,940
这么久了，我能够
进入CS50的档案

840
00:39:19,940 --> 00:39:22,470
找到这个非常SD
他们的参与进尺

841
00:39:22,470 --> 00:39:25,402
在舞台上自己几年前。

842
00:39:25,402 --> 00:39:26,110
罗伯：[听不清]。

843
00:39:26,110 --> 00:39:53,660

844
00:39:53,660 --> 00:39:59,247
>> [掌声]

845
00:39:59,247 --> 00:40:00,080
ZAMAYLA：[听不清]

846
00:40:00,080 --> 00:40:50,888

847
00:40:50,888 --> 00:40:52,467
>> [掌声]

848
00:40:52,467 --> 00:40:53,425
DAVID MALAN：谢谢。

849
00:40:53,425 --> 00:40:56,160

850
00:40:56,160 --> 00:40:58,030
所以除了这些
这里的团队成员，

851
00:40:58,030 --> 00:41:01,662
CS50拥有一支近100
工作人员，所有的人

852
00:41:01,662 --> 00:41:04,370
将可用于部分
和办公时间和这么多。

853
00:41:04,370 --> 00:41:06,920
并作为罗布说太，这是
最显著检修

854
00:41:06,920 --> 00:41:09,534
在10年CS50的那
我一直在[听不清]。

855
00:41:09,534 --> 00:41:12,200
[听不清]特别是重点
在提供一个支撑结构，

856
00:41:12,200 --> 00:41:14,050
修剪带走了大量的
这一直是大头

857
00:41:14,050 --> 00:41:16,870
积累在10年内
迭代开发

858
00:41:16,870 --> 00:41:18,120
在球场上的习题集。

859
00:41:18,120 --> 00:41:21,470
>> 所以今年，不仅在课堂上，但
还在使用过程中的问题的形式

860
00:41:21,470 --> 00:41:24,800
集，你应该找事情
更精简，修边机，多

861
00:41:24,800 --> 00:41:26,700
比更便于管理
在过去的几年，因为我们

862
00:41:26,700 --> 00:41:31,330
摆脱一些这就是行李
通过不断发展的一年开发的性质

863
00:41:31,330 --> 00:41:32,970
一年后的迭代。

864
00:41:32,970 --> 00:41:35,110
所以今天的新的和改进的开始。

865
00:41:35,110 --> 00:41:37,860
>> 你会遇到更多的
当然公司在[听不清]的工作人员出来

866
00:41:37,860 --> 00:41:40,186
下午2:30，在那里我们服务，
作为一个传统的蛋糕。

867
00:41:40,186 --> 00:41:42,060
有一个多一点的蛋糕
不仅如此，但你

868
00:41:42,060 --> 00:41:44,690
满足艾琳和Tobias等人还在。

869
00:41:44,690 --> 00:41:46,470
让我给你
我们听到前游

870
00:41:46,470 --> 00:41:49,600
从一些其他工作人员
在类的东西等待为好，。

871
00:41:49,600 --> 00:41:52,730
事实上，我们总是开始CS50的
学期本周六，

872
00:41:52,730 --> 00:41:54,330
什么叫做CS50益智日。

873
00:41:54,330 --> 00:41:56,710
>> 它无关
计算机科学本身，

874
00:41:56,710 --> 00:41:58,669
但随着有关问题
解决更普遍。

875
00:41:58,669 --> 00:42:01,210
如果你这样选择参加，
每部分的邀请，

876
00:42:01,210 --> 00:42:03,460
你可能已经看到门
掉落或在这里的舞台上，

877
00:42:03,460 --> 00:42:05,830
这是在团队中的机会
的两个或三个或四个，

878
00:42:05,830 --> 00:42:10,680
参与的难题和比萨饼
和奖品，并缓慢 - 本周六，

879
00:42:10,680 --> 00:42:12,560
敬请期待更多。

880
00:42:12,560 --> 00:42:15,082
>> 你会发现太多，每
周五，在火与冰，

881
00:42:15,082 --> 00:42:16,790
不CS50带来
一大堆学生

882
00:42:16,790 --> 00:42:19,100
午餐，做一个大的
一流的手感更贴心，

883
00:42:19,100 --> 00:42:21,820
一般汇集
校友和来自业界朋友

884
00:42:21,820 --> 00:42:24,710
谈论他们已经什么
自从毕业以来最高。

885
00:42:24,710 --> 00:42:27,820
同样的，今年，我们将
开创了有史以来第一个50 CS50

886
00:42:27,820 --> 00:42:31,390
编码contest--一期中
机会，让大家

887
00:42:31,390 --> 00:42:35,430
在基础的选择，有一个
针对同学们斗智斗勇的挑战，

888
00:42:35,430 --> 00:42:39,250
再次在两个或三个或团队
四个仅使用编程

889
00:42:39,250 --> 00:42:41,920
精明的你就必须下
只是六七后，你的腰带

890
00:42:41,920 --> 00:42:44,710
类周，参与
在这种竞争

891
00:42:44,710 --> 00:42:50,261
online--如果你想磨练自己
技能都在挑战更多。

892
00:42:50,261 --> 00:42:52,760
在学期结束是
所谓CS50 Hackathon--

893
00:42:52,760 --> 00:42:56,970
开始于7:00一个机会
下午结束于7:00 AM，沿途

894
00:42:56,970 --> 00:43:01,900
是在潜水12日晚小时
到课程的最后project--

895
00:43:01,900 --> 00:43:04,820
一个机会来设计和
实行最感兴趣的东西

896
00:43:04,820 --> 00:43:06,980
你与你的教学
老乡的指引。

897
00:43:06,980 --> 00:43:09,600
大约9:00 AM做，我们通常
服务比萨饼，1:00 AM，

898
00:43:09,600 --> 00:43:13,210
Philippe的，和我们几个
谁是还醒着上午5:00，

899
00:43:13,210 --> 00:43:16,310
梭乘坐大巴下来
路IHOP早餐。

900
00:43:16,310 --> 00:43:19,340
>> 然后几天后
是所谓的CS50 fare--

901
00:43:19,340 --> 00:43:23,450
学期展览在结束
多远这么多的庆祝活动

902
00:43:23,450 --> 00:43:28,200
CS50的学生都来自
周零一路周

903
00:43:28,200 --> 00:43:32,610
并牢记那些73％
同学们和你今年有

904
00:43:32,610 --> 00:43:34,840
以前从未采取了CS类。

905
00:43:34,840 --> 00:43:39,226
实际上，再次强调为多，这里
从CS50的工作人员多了一些面孔。

906
00:43:39,226 --> 00:43:40,184
扬声器4：[听不清]。

907
00:43:40,184 --> 00:43:45,909

908
00:43:45,909 --> 00:43:46,867
SPEAKER 5：[听不清]。

909
00:43:46,867 --> 00:43:51,332

910
00:43:51,332 --> 00:43:52,290
扬声器6：[听不清]。

911
00:43:52,290 --> 00:43:55,276

912
00:43:55,276 --> 00:43:56,234
扬声器7：[听不清]。

913
00:43:56,234 --> 00:44:01,727

914
00:44:01,727 --> 00:44:02,643
SPEAKER 8：[听不清]

915
00:44:02,643 --> 00:44:10,066

916
00:44:10,066 --> 00:44:11,024
扬声器9：[听不清]。

917
00:44:11,024 --> 00:44:14,475

918
00:44:14,475 --> 00:44:15,461
>> 扬声器4：[听不清]。

919
00:44:15,461 --> 00:44:16,461
>> 扬声器10：[听不清]。

920
00:44:16,461 --> 00:44:21,456

921
00:44:21,456 --> 00:44:23,438
扬声器11：[听不清]。

922
00:44:23,438 --> 00:44:24,438
SPEAKER 12：[听不清]。

923
00:44:24,438 --> 00:44:30,438

924
00:44:30,438 --> 00:44:31,396
SPEAKER 13：[听不清]

925
00:44:31,396 --> 00:44:37,360

926
00:44:37,360 --> 00:44:40,342
>> 扬声器14：[听不清]。

927
00:44:40,342 --> 00:44:42,863
>> SPEAKER 13：[听不清]。

928
00:44:42,863 --> 00:44:43,821
SPEAKER 15：[听不清]

929
00:44:43,821 --> 00:44:48,785

930
00:44:48,785 --> 00:44:49,785
SPEAKER 16：[听不清]。

931
00:44:49,785 --> 00:44:53,761

932
00:44:53,761 --> 00:44:55,252
>> 扬声器11：[听不清]

933
00:44:55,252 --> 00:44:57,773

934
00:44:57,773 --> 00:44:58,731
SPEAKER 5：[听不清]。

935
00:44:58,731 --> 00:45:11,250

936
00:45:11,250 --> 00:45:15,130
DAVID MALAN：有些团队
是自己购物类。

937
00:45:15,130 --> 00:45:17,760
但是，如果这些成员
CS50的工作人员都在这里，

938
00:45:17,760 --> 00:45:19,230
能来最多只是一瞬间。

939
00:45:19,230 --> 00:45:23,450
CS50的转录因子和CA和[？工作人员？]
会员这里 - 这些只是少数

940
00:45:23,450 --> 00:45:28,880
其中的faces--一个你刚才
看见了，和几个other--和其他几个人

941
00:45:28,880 --> 00:45:30,020
仍然。

942
00:45:30,020 --> 00:45:33,242
我们为什么不继续前进，让
你们五分钟的休息时间。

943
00:45:33,242 --> 00:45:35,450
如果你需要逃避到
店类，这很好。

944
00:45:35,450 --> 00:45:38,900
五分钟后，我们将重新开始，
采取一看Scratch--第一

945
00:45:38,900 --> 00:45:42,420
我们的编程语言，满足
在此过程中的工作人员多一些，

946
00:45:42,420 --> 00:45:45,020
并注重最终
在问题设置为零。

947
00:45:45,020 --> 00:45:46,710
因此，我们会回来的五分钟。

1
00:45:46,864 --> 00:45:47,370
>> 好吧。

2
00:45:47,370 --> 00:45:48,590
所以我们又回来了。

3
00:45:48,590 --> 00:45:51,330
而在我们剩下的
今天的时间，我们的目标

4
00:45:51,330 --> 00:45:54,320
是公平的竞争环境
在一些术语方面，

5
00:45:54,320 --> 00:45:55,297
在一些观念方面。

6
00:45:55,297 --> 00:45:57,380
因为事实上，按照
一些早期的图表，

7
00:45:57,380 --> 00:46:00,130
那里将是一个范围
在类的经验水平，

8
00:46:00,130 --> 00:46:03,210
其中一些人的学生
前采取了一些节目，

9
00:46:03,210 --> 00:46:04,200
其中一些人还没有。

10
00:46:04,200 --> 00:46:07,430
所以这个第一个问题
置，并与该第一语言

11
00:46:07,430 --> 00:46:10,830
我们有机会启动
拿今天之后批出

12
00:46:10,830 --> 00:46:12,960
一些常用的词汇和概念。

13
00:46:12,960 --> 00:46:15,590
>> 我们会通过的方式做到这一点
课程的第一languages​​--

14
00:46:15,590 --> 00:46:21,070
除了C和Python和
JavaScript和SQL和HTML和CSS，

15
00:46:21,070 --> 00:46:24,450
我们将首先着眼
和公正的问题设置为零

16
00:46:24,450 --> 00:46:28,160
这个图形语言，称为
从无到有，由麻省理工学院媒体实验室开发

17
00:46:28,160 --> 00:46:30,880
下山的路，帮助
学生和孩子尤其是

18
00:46:30,880 --> 00:46:35,070
表达自己algorithmically--
的方式与什么更一致

19
00:46:35,070 --> 00:46:37,300
我们不妨称之为计算思维。

20
00:46:37,300 --> 00:46:40,985
>> 这是一个非常有用的语言，因为
很快下周在一个星期内，

21
00:46:40,985 --> 00:46:44,360
我们过渡到一个更
所谓的传统和神秘语言

22
00:46:44,360 --> 00:46:46,370
C，这是纯粹的文本。

23
00:46:46,370 --> 00:46:48,930
你只用键盘
为了写指令

24
00:46:48,930 --> 00:46:50,230
像这些在屏幕上。

25
00:46:50,230 --> 00:46:52,840
但是，即使你从来没见过
编程语言之前，

26
00:46:52,840 --> 00:46:55,170
在刚刚一眼
这一点，所有的无论是神秘的，

27
00:46:55,170 --> 00:47:00,010
你可能猜到
大概打印Hello World。

28
00:47:00,010 --> 00:47:02,050
但是有一个很大的
句法开销那里。

29
00:47:02,050 --> 00:47:05,770
有怪异的哈希
符号或散列标签往上顶。

30
00:47:05,770 --> 00:47:08,900
有尖括号，一些
括号，大括号，半colon--

31
00:47:08,900 --> 00:47:11,880
这里只有这么多的视觉
语法的方式获得。

32
00:47:11,880 --> 00:47:13,940
我们先从课程
划伤，从而获得

33
00:47:13,940 --> 00:47:17,600
过去所有这些智力
无趣的杂念，

34
00:47:17,600 --> 00:47:20,290
而专注于创意。

35
00:47:20,290 --> 00:47:22,540
>> 事实上，这可能是之前。

36
00:47:22,540 --> 00:47:24,830
此，为此，周须后。

37
00:47:24,830 --> 00:47:26,760
此，在该图形
语言划痕，

38
00:47:26,760 --> 00:47:29,870
是你将如何实现相同的
program--运行时，一个程序，

39
00:47:29,870 --> 00:47:31,340
简单地说，你好世界。

40
00:47:31,340 --> 00:47:34,740
而关于划痕是很不错
它的这种图形化编程

41
00:47:34,740 --> 00:47:38,780
使用拼图或环境
块，只有一起互锁

42
00:47:38,780 --> 00:47:40,440
如果它使逻辑意义这样做。

43
00:47:40,440 --> 00:47:43,810
并与划痕就可以开发
动画和互动游戏

44
00:47:43,810 --> 00:47:47,270
和艺术，以及任何数目的东西
你可能想象你自己的心灵，

45
00:47:47,270 --> 00:47:51,200
而仅仅通过实现它们
拖放拼图。

46
00:47:51,200 --> 00:47:54,265
>> 事实上，我们将有能力
表达一些同样的想法

47
00:47:54,265 --> 00:47:56,890
我只是提了一下
以前，在迈克·史密斯的背景下

48
00:47:56,890 --> 00:48:00,670
和搜索电话book--事
类似的功能，只是动作，

49
00:48:00,670 --> 00:48:03,070
这样的事情做循环
事连连，

50
00:48:03,070 --> 00:48:05,170
变量，这是
这是我们来介绍，

51
00:48:05,170 --> 00:48:08,086
但它也许是熟悉的
algebra--只是一些一种占位符

52
00:48:08,086 --> 00:48:10,840
存放一些价值你可能
需要later--布尔表达式，

53
00:48:10,840 --> 00:48:13,720
如果这些是否或真
从之前假的问题。

54
00:48:13,720 --> 00:48:17,117
条件是在那些叉
road--这些分支可以这么说。

55
00:48:17,117 --> 00:48:19,700
然后还有一些发烧友
特点我们可以看到即使在今天，

56
00:48:19,700 --> 00:48:22,850
所谓的阵列和线程，
事件，我们会再重访

57
00:48:22,850 --> 00:48:24,460
时间在不同的语言。

58
00:48:24,460 --> 00:48:26,790
但划痕让我们
探索所有这些。

59
00:48:26,790 --> 00:48:30,779
所以在这里划痕中，这个紫
块是一个功能是什么通常

60
00:48:30,779 --> 00:48:31,570
将会是什么样的。

61
00:48:31,570 --> 00:48:35,620
有一些这紫一块拼图
字像说，这是动作，

62
00:48:35,620 --> 00:48:38,490
然后它可能具有一个
参数或parameter--某种方式

63
00:48:38,490 --> 00:48:41,140
一种定制的
那是什么呢块

64
00:48:41,140 --> 00:48:45,182
所以，它不是通过预先确定
MIT这是什么紫块说。

65
00:48:45,182 --> 00:48:47,390
事实上，你会看到一个
那一刻，我是能够输入

66
00:48:47,390 --> 00:48:49,931
的话就像世界您好，或
您好大卫，或HELLO Zamayla，

67
00:48:49,931 --> 00:48:53,750
或我想做的事情，在参数
该拼图piece--白盒测试

68
00:48:53,750 --> 00:48:54,251
那里。

69
00:48:54,251 --> 00:48:57,166
同时，如果我想要一个循环，我们将
看到有拼图的

70
00:48:57,166 --> 00:48:58,640
看起来有点橙这样。

71
00:48:58,640 --> 00:49:01,690
而它们的形状样的建议
事情频频发生

72
00:49:01,690 --> 00:49:02,680
在一个周期。

73
00:49:02,680 --> 00:49:06,800
>> 所以，如果我换一个打招呼的世界块
用刮中永远阻止，

74
00:49:06,800 --> 00:49:10,307
它只是要保持打招呼
世界永远的，毫不夸张。

75
00:49:10,307 --> 00:49:12,390
同时，还有另一种
在划痕循环型

76
00:49:12,390 --> 00:49:14,348
我们将see--重演
block--在哪里，如果你

77
00:49:14,348 --> 00:49:17,940
提前知道有多少次
你希望循环执行

78
00:49:17,940 --> 00:49:21,850
次在fact--你有限数量的
可以通过在数字输入指定

79
00:49:21,850 --> 00:49:25,380
或者甚至堵塞在一个变量，
像X或Y作为我们拭目以待。

80
00:49:25,380 --> 00:49:27,690
>> 事实上，变量，如
我在此情况下，这

81
00:49:27,690 --> 00:49:30,109
一个共同的名字为
整型变量

82
00:49:30,109 --> 00:49:31,900
只是存储number--
整数可能是，

83
00:49:31,900 --> 00:49:35,470
在这里使用的橙色块
设置一个变量像我到零。

84
00:49:35,470 --> 00:49:38,900
下面是一个绿色的例子
在划痕布尔表达式。

85
00:49:38,900 --> 00:49:43,700
虽然这看起来像一个数学
公式，数学不等式这样

86
00:49:43,700 --> 00:49:45,320
真的是布尔表达式。

87
00:49:45,320 --> 00:49:46,570
这是真或假。

88
00:49:46,570 --> 00:49:48,300
我是小于50。

89
00:49:48,300 --> 00:49:51,815
它要么是或否的答案
或真或假的答案。

90
00:49:51,815 --> 00:49:53,940
而我们通常会打电话
这些布尔表达式。

91
00:49:53,940 --> 00:49:55,148
它不必须是50。

92
00:49:55,148 --> 00:49:57,970
它可以为x小于y，
大于y，等于y--

93
00:49:57,970 --> 00:50:00,020
任何数量的其他
问题可能会问。

94
00:50:00,020 --> 00:50:03,250
>> 现在，乍一看，这可能看起来
突然很大胆在这里，它是。

95
00:50:03,250 --> 00:50:06,540
但聪明的概念，它是
与以前相当熟悉。

96
00:50:06,540 --> 00:50:09,370
比说如果x小于y，为多。

97
00:50:09,370 --> 00:50:12,230
否则，如果x大于
比Y，然后说那么多。

98
00:50:12,230 --> 00:50:14,260
别人说x等于为y。

99
00:50:14,260 --> 00:50:17,220
因此，我们有一个例子
第三scenario--的有

100
00:50:17,220 --> 00:50:20,600
只有第三possibility-- x是
大于，小于或等于。

101
00:50:20,600 --> 00:50:22,420
因此，我们必须在客场三路叉。

102
00:50:22,420 --> 00:50:26,290
>> 并注意什么很酷这里 - 划痕，
这似乎只有一个谜题

103
00:50:26,290 --> 00:50:28,840
件，在这种情况下，如果else块。

104
00:50:28,840 --> 00:50:32,090
然而，这似乎意味着你可以
只有在路双向叉子。

105
00:50:32,090 --> 00:50:34,631
你可以去左或右，但
什么关于第三种方案？

106
00:50:34,631 --> 00:50:35,760
如果x等于ÿ什么？

107
00:50:35,760 --> 00:50:36,500
没什么大不了。

108
00:50:36,500 --> 00:50:39,640
取一拼图，把
它的另一个内

109
00:50:39,640 --> 00:50:45,759
创建语义等值
如果，否则，如果，else--现在你

110
00:50:45,759 --> 00:50:47,300
在路上你的三路叉。

111
00:50:47,300 --> 00:50:49,091
正如我们看到的，
刮拼图

112
00:50:49,091 --> 00:50:51,820
可拉伸和成长，因此
作为对他们挤更多的东西。

113
00:50:51,820 --> 00:50:54,420
你不必适合
一切都在它的默认大小。

114
00:50:54,420 --> 00:50:56,690
>> 这是我们要
很快看到被称为数组。

115
00:50:56,690 --> 00:51:00,880
这就像一个列表中 - 一些方式
存储的多条信息

116
00:51:00,880 --> 00:51:02,886
在一个变量中，不只是一个数字。

117
00:51:02,886 --> 00:51:05,760
这些我们可以看到代表
所谓多线程。

118
00:51:05,760 --> 00:51:08,280
事实上，所有的
Mac和PC，这些天

119
00:51:08,280 --> 00:51:10,810
支持多线程，
这意味着你可以从字面上

120
00:51:10,810 --> 00:51:12,390
在同一时间做多件事情。

121
00:51:12,390 --> 00:51:15,390
您可以安装Microsoft Word起来的
前景，在一些作文的工作。

122
00:51:15,390 --> 00:51:17,160
你可能有一个浏览器
在后台开口

123
00:51:17,160 --> 00:51:18,720
G-mail或Facebook或类似物。

124
00:51:18,720 --> 00:51:22,730
您的计算机可以做多件事情
今天，因为它是多线程的，

125
00:51:22,730 --> 00:51:26,390
和方案，他们在
特别是还多线程。

126
00:51:26,390 --> 00:51:28,970
>> 有东西叫做事件
以及在划痕的世界里，

127
00:51:28,970 --> 00:51:32,640
再有一种方法也使
我们自己定制拼图，如果事情

128
00:51:32,640 --> 00:51:34,810
事先不实际存在。

129
00:51:34,810 --> 00:51:38,260
因此，让我们这个激励如下。

130
00:51:38,260 --> 00:51:40,580
几年前，当我
首先发现划痕，

131
00:51:40,580 --> 00:51:43,530
当我实际上是一个
在麻省理工学院的研究生，我们

132
00:51:43,530 --> 00:51:45,640
我们大伙儿做的功课。

133
00:51:45,640 --> 00:51:47,614
我implemented--
其中，回想起来，

134
00:51:47,614 --> 00:51:50,780
是一个非常错误的决定，因为它是
在世界上最令人气愤的歌

135
00:51:50,780 --> 00:51:53,321
听八小时
而在您的工作homework--

136
00:51:53,321 --> 00:51:57,180
但有些事我呼吁奥斯卡时间，
这也许是一个熟悉的歌曲。

137
00:51:57,180 --> 00:51:59,820
>> CS50s拥有乔丹林，一
我们更多的高级职员，

138
00:51:59,820 --> 00:52:03,920
已经升级了其2015年和
现在2016年，因为早在一天，

139
00:52:03,920 --> 00:52:06,610
我拥有了一切只是去
进入奥斯卡的垃圾桶。

140
00:52:06,610 --> 00:52:09,320
现在，我们支持回收和堆肥。

141
00:52:09,320 --> 00:52:12,050
>> 但画的图画
什么，我们可以在这里做

142
00:52:12,050 --> 00:52:14,130
并激励一些
较低级别的例子，

143
00:52:14,130 --> 00:52:16,400
我们可以得到一个其他
志愿者刚刚上了

144
00:52:16,400 --> 00:52:18,331
玩我的第一次
家庭作业永远不会消失？

145
00:52:18,331 --> 00:52:18,830
上来吧。

146
00:52:18,830 --> 00:52:19,250
你叫什么名字？

147
00:52:19,250 --> 00:52:20,030
>> 亨利：亨利。

148
00:52:20,030 --> 00:52:22,660
>> DAVID MALAN：亨利​​，上来吧。

149
00:52:22,660 --> 00:52:24,190
上来吧。

150
00:52:24,190 --> 00:52:27,070
头部无论哪种方式，和
你会看到一个时刻，

151
00:52:27,070 --> 00:52:29,870
我要继续前进并击中了
在右上角的绿色标志

152
00:52:29,870 --> 00:52:31,100
角落，这意味着去。

153
00:52:31,100 --> 00:52:33,320
小停止标志图标
会说停，

154
00:52:33,320 --> 00:52:35,490
这就是当你开始
并停止该程序。

155
00:52:35,490 --> 00:52:36,450
很高兴见到你。

156
00:52:36,450 --> 00:52:36,950
好吧。

157
00:52:36,950 --> 00:52:39,100
所以，我们要看到的说明
在短短的瞬间在屏幕上。

158
00:52:39,100 --> 00:52:41,450
而仅仅通过玩这个游戏
几秒 - 相信我，

159
00:52:41,450 --> 00:52:43,670
我们不打算要想玩
一路的end--你会

160
00:52:43,670 --> 00:52:45,470
得到的程序在做什么的感觉。

161
00:52:45,470 --> 00:52:49,170
而不仅仅是专注于亨利
处于这场比赛中，焦点是好是坏

162
00:52:49,170 --> 00:52:52,600
并且又如何能够实现我
最初再由乔丹。

163
00:52:52,600 --> 00:52:54,640
换句话说，在这里是变量？

164
00:52:54,640 --> 00:52:55,520
在哪里循环？

165
00:52:55,520 --> 00:52:56,520
在哪里的功能呢？

166
00:52:56,520 --> 00:53:00,700
我们会看到，如果我们不看
这些引擎盖下方。

167
00:53:00,700 --> 00:53:03,660
>> 只需点击并拖动垃圾桶
以合适的纸槽。

168
00:53:03,660 --> 00:54:02,100
>> [音乐]

169
00:54:02,100 --> 00:54:02,600
好吧。

170
00:54:02,600 --> 00:54:03,160
这是非常好的。

171
00:54:03,160 --> 00:54:04,286
为什么我们不存在停止。

172
00:54:04,286 --> 00:54:04,786
谢谢。

173
00:54:04,786 --> 00:54:05,830
恭喜亨利。

174
00:54:05,830 --> 00:54:07,002
谢谢。

175
00:54:07,002 --> 00:54:10,690
>> [掌声]

176
00:54:10,690 --> 00:54:12,450
>> 试想一下，调试该程序。

177
00:54:12,450 --> 00:54:15,880
如果有一个问题的两种
分进入song--但如此

178
00:54:15,880 --> 00:54:17,430
这是怎么回事这里真的吗？

179
00:54:17,430 --> 00:54:20,900
由于复杂的，因为它可能
开始似乎随着时间的推移，

180
00:54:20,900 --> 00:54:22,910
的确越来越多
东西霏霏，

181
00:54:22,910 --> 00:54:25,370
有什么有趣的左右
这种example--的

182
00:54:25,370 --> 00:54:27,270
我们会看到一些
others--是，如果你

183
00:54:27,270 --> 00:54:30,416
看过去的复杂性或
游戏的复杂性，

184
00:54:30,416 --> 00:54:33,040
有一个很简单的建筑
该演奏成所有的块，

185
00:54:33,040 --> 00:54:35,840
如果他们提炼出那些
积木，都十分便利

186
00:54:35,840 --> 00:54:37,401
和可执行你们自己。

187
00:54:37,401 --> 00:54:39,150
例如，它的
过了一段时间，但我

188
00:54:39,150 --> 00:54:42,900
很肯定我最初做的时候
使得本场比赛的第一次

189
00:54:42,900 --> 00:54:44,787
是我完全像个拖再拖。

190
00:54:44,787 --> 00:54:47,120
我根本不注重
逻辑或拼图，

191
00:54:47,120 --> 00:54:50,810
我专注于图形和发现
街道后和垃圾桶

192
00:54:50,810 --> 00:54:51,540
和所有的。

193
00:54:51,540 --> 00:54:53,456
但是，这些都是必要的
成分在第一。

194
00:54:53,456 --> 00:54:57,220
一旦我完成了拖延，
布局总体框架，

195
00:54:57,220 --> 00:55:00,337
我决定，我只想做一个
一块从天上落下垃圾的。

196
00:55:00,337 --> 00:55:02,170
我们将看到划痕
支持东西叫做

197
00:55:02,170 --> 00:55:06,386
sprites--字符，可以
对因此他们不同的服饰

198
00:55:06,386 --> 00:55:07,010
看起来不同。

199
00:55:07,010 --> 00:55:09,660
>> 所以，我把一个垃圾桶
服装上的这样一个精灵。

200
00:55:09,660 --> 00:55:12,007
我只是需要它
从天上掉下来。

201
00:55:12,007 --> 00:55:14,590
所以事实证明，从无到有，
最喜欢的编程语言，

202
00:55:14,590 --> 00:55:18,099
支持随机数字或
技术上伪随机数，

203
00:55:18,099 --> 00:55:20,390
以便通过拖和
某些下探拼图，

204
00:55:20,390 --> 00:55:22,890
我能够有垃圾桶
首先来自于左侧。

205
00:55:22,890 --> 00:55:25,580
再下一次下跌，从
右，然后从中间。

206
00:55:25,580 --> 00:55:28,060
和所有的游戏都只是
有垃圾从空中落下。

207
00:55:28,060 --> 00:55:29,770
你不能在它指向或点击它。

208
00:55:29,770 --> 00:55:31,103
你不能打开垃圾箱。

209
00:55:31,103 --> 00:55:32,160
你不能做任何事情。

210
00:55:32,160 --> 00:55:34,450
但它是一个小步
对我的终极愿景。

211
00:55:34,450 --> 00:55:36,720
>> 在这之后，我居然
实施某种

212
00:55:36,720 --> 00:55:41,230
传感所以如果你没有点击
并拖动一块垃圾

213
00:55:41,230 --> 00:55:44,350
在垃圾桶，奥斯卡
将盖子打开和关闭。

214
00:55:44,350 --> 00:55:47,650
没有什么会发生在垃圾桶里，但
至少所述盖将打开和关闭。

215
00:55:47,650 --> 00:55:49,642
所以，再检查，第二步中的两个。

216
00:55:49,642 --> 00:55:52,100
这是发生了什么事情是
在这两个问题的关键设置为零

217
00:55:52,100 --> 00:55:55,970
和编程更一般地，是
采取这些非常谨慎的婴儿的步骤。

218
00:55:55,970 --> 00:55:59,390
因为它不仅让你
老实说，感觉完成了多

219
00:55:59,390 --> 00:56:01,250
quickly--它的
在世界上最糟糕的事情

220
00:56:01,250 --> 00:56:06,149
尝试实施所有奥斯卡时间，
然后小时后打绿旗，

221
00:56:06,149 --> 00:56:08,440
并没有什么作品如预期
因为你在哪里，甚至

222
00:56:08,440 --> 00:56:11,150
开始调试或
故障排除程序？

223
00:56:11,150 --> 00:56:12,470
这只是压倒。

224
00:56:12,470 --> 00:56:16,792
>> 所以，真正拥抱这个想法
再次采取steps--婴儿的步骤

225
00:56:16,792 --> 00:56:19,000
和again--建立
东西是，在最后，

226
00:56:19,000 --> 00:56:23,672
真是令人印象深刻和复杂的，但
起初，是不是几乎一样如此。

227
00:56:23,672 --> 00:56:24,630
事实上，让我们做到这一点。

228
00:56:24,630 --> 00:56:28,989
让我先走还有 - 本身划痕
存在于Scratch.MIT.edu在网络上，

229
00:56:28,989 --> 00:56:30,780
你会被告知为
在问题再多

230
00:56:30,780 --> 00:56:34,200
设置为零，规范
这已经是在CS50的网站。

231
00:56:34,200 --> 00:56:35,725
>> 但是，这是什么划痕本身。

232
00:56:35,725 --> 00:56:38,210
而且也真的只是
三个主要领域。

233
00:56:38,210 --> 00:56:40,980
在左上方有
是所谓的阶段。

234
00:56:40,980 --> 00:56:41,810
这是划痕。

235
00:56:41,810 --> 00:56:43,710
默认的服装是一只猫。

236
00:56:43,710 --> 00:56:46,950
这是矩形世界
你可以move--上，下，左，

237
00:56:46,950 --> 00:56:48,130
右侧和一些其他的东西。

238
00:56:48,130 --> 00:56:51,839
在中间这是我们的类别
还是我们的拼图托盘，

239
00:56:51,839 --> 00:56:53,630
和不同的颜色
意味着不同的事情。

240
00:56:53,630 --> 00:56:56,520
如果你闲逛，你会看到
之类的东西循环和条件

241
00:56:56,520 --> 00:56:58,160
和变量等成分。

242
00:56:58,160 --> 00:57:00,060
>> 然后在这里是脚本的区域。

243
00:57:00,060 --> 00:57:03,020
这是我可以拖放
这些拼图做的事情。

244
00:57:03,020 --> 00:57:04,690
因此，让我们做一这样的事情。

245
00:57:04,690 --> 00:57:06,630
让我先走还有 -
我知道它在哪里。

246
00:57:06,630 --> 00:57:10,110
所以，我要立即点击
在那里，我知道的东西都准备好要，

247
00:57:10,110 --> 00:57:13,140
但指向和点击和
四处是不可避免的。

248
00:57:13,140 --> 00:57:15,320
因此，当绿旗点击，
我想要做什么？

249
00:57:15,320 --> 00:57:17,100
我要做到这一点。

250
00:57:17,100 --> 00:57:20,699
我要拖到这个谜题紫
件，问好两秒钟，

251
00:57:20,699 --> 00:57:21,490
让我放大]。

252
00:57:21,490 --> 00:57:23,865
>> 而我要改变这种
是我希望它be--什么

253
00:57:23,865 --> 00:57:26,471
世界你好两秒钟的罚款。

254
00:57:26,471 --> 00:57:28,970
现在，我要点击
绿色食品标志，或者如果我真正想要的，

255
00:57:28,970 --> 00:57:31,820
我可以全屏幕，然后回来。

256
00:57:31,820 --> 00:57:34,060
这将只是保持
一切在一个窗口。

257
00:57:34,060 --> 00:57:36,141
绿色flag--世界你好。

258
00:57:36,141 --> 00:57:36,640
好吧。

259
00:57:36,640 --> 00:57:38,789
不是所有的有趣。

260
00:57:38,789 --> 00:57:40,080
因此，让我继续前进，做到这一点。

261
00:57:40,080 --> 00:57:41,038
让我试试另一个。

262
00:57:41,038 --> 00:57:44,740
当绿旗clicked--让我们
做类似声音。

263
00:57:44,740 --> 00:57:46,880
并注意出
免费你得到的盒子

264
00:57:46,880 --> 00:57:49,910
一只猫的声音，因为是默认的精灵。

265
00:57:49,910 --> 00:57:52,380
所以，现在让我去前进，
打到现在绿色环保标志。

266
00:57:52,380 --> 00:57:53,224
>> [喵喵叫]

267
00:57:53,224 --> 00:57:54,490
>> 胡。

268
00:57:54,490 --> 00:57:55,370
这是可爱的。

269
00:57:55,370 --> 00:57:57,040
我编程。

270
00:57:57,040 --> 00:57:58,550
所以我做了什么？

271
00:57:58,550 --> 00:58:00,430
这是一个程序的等价物。

272
00:58:00,430 --> 00:58:01,600
这显然​​是超级简单。

273
00:58:01,600 --> 00:58:05,300
它并没有真正采取所有的东西
努力和麻省理工学院做了大部分的工作，

274
00:58:05,300 --> 00:58:07,890
但我已经调用的函数。

275
00:58:07,890 --> 00:58:08,940
我已经使用的功能。

276
00:58:08,940 --> 00:58:12,480
我做了一些动作，只使用
一个紫色的一块拼图。

277
00:58:12,480 --> 00:58:15,960
>> 好吧，如果我想要做的
3叫声在一排？

278
00:58:15,960 --> 00:58:18,570
让我继续前进，做两三个。

279
00:58:18,570 --> 00:58:20,910
并注意当你
悬停附近的一块拼图，

280
00:58:20,910 --> 00:58:22,970
显得有点白线
诸如此类的磁性，

281
00:58:22,970 --> 00:58:25,190
它会捕捉
在一起的时候你放手。

282
00:58:25,190 --> 00:58:26,600
让我们来看看这里发生了什么。

283
00:58:26,600 --> 00:58:27,920
>> [喵喵叫]

284
00:58:27,920 --> 00:58:32,390

285
00:58:32,390 --> 00:58:34,510
>> 有一个错误。

286
00:58:34,510 --> 00:58:35,650
我只听到一喵。

287
00:58:35,650 --> 00:58:37,440
为什么会这样呢？

288
00:58:37,440 --> 00:58:39,001
是吗？

289
00:58:39,001 --> 00:58:39,500
是啊。

290
00:58:39,500 --> 00:58:41,650
我们真的不听到它，
但是这是很好的直觉。

291
00:58:41,650 --> 00:58:43,400
他们都打在同一时间。

292
00:58:43,400 --> 00:58:44,000
为什么？

293
00:58:44,000 --> 00:58:46,587
那么，电脑正要
做什么你告诉它做的事。

294
00:58:46,587 --> 00:58:48,670
所以，如果你说，播放声音，
播放声音，播放声音，

295
00:58:48,670 --> 00:58:52,887
但你不告诉它发挥到及至
大功告成，玩到大功告成，

296
00:58:52,887 --> 00:58:54,970
这将通过吹
该计划真快

297
00:58:54,970 --> 00:58:56,830
而且只做你告诉它做的事。

298
00:58:56,830 --> 00:58:59,040
>> 所以，我真的需要修复
这几种方式。

299
00:58:59,040 --> 00:59:00,623
我可以做到这一点，摆脱了这一点。

300
00:59:00,623 --> 00:59:04,180
让我试试这个谜题其他
piece--播放声音喵直到完成，

301
00:59:04,180 --> 00:59:07,072
然后将三
这些和单击播放。

302
00:59:07,072 --> 00:59:09,430
>> [喵喵叫]

303
00:59:09,430 --> 00:59:13,350
>> 这不是真的very--
感谢你 - 很自然的。

304
00:59:13,350 --> 00:59:16,590
那么，为什么我 - 让
我去这里控制。

305
00:59:16,590 --> 00:59:17,090
尼斯。

306
00:59:17,090 --> 00:59:22,230
等待一秒钟，现在让我回去
对声音和播放声音，直到完成，

307
00:59:22,230 --> 00:59:24,620
然后让我等待一秒钟。

308
00:59:24,620 --> 00:59:28,692
然后让我去送一
更多的声音，在这里我们去。

309
00:59:28,692 --> 00:59:31,350
>> [喵喵叫]

310
00:59:31,350 --> 00:59:35,930
>> 多一点自然的，但
这不是很有效。

311
00:59:35,930 --> 00:59:39,830
就像我开始厌烦，都是
简单来说，点击来回

312
00:59:39,830 --> 00:59:42,724
真正复制我的work--
几乎复制和粘贴。

313
00:59:42,724 --> 00:59:44,640
事实上，如果我控制
点击或右键点击，

314
00:59:44,640 --> 00:59:46,500
我可能只是复制和粘贴。

315
00:59:46,500 --> 00:59:49,870
什么会是一个更好的构造使用？

316
00:59:49,870 --> 00:59:51,090
什么想法来自之前？

317
00:59:51,090 --> 00:59:51,990
>> 是啊，这样一个循环。

318
00:59:51,990 --> 00:59:54,580
而事实上，如果我们周围戳，
我们可能会发现这一点。

319
00:59:54,580 --> 00:59:57,730
让我去活动或者说控制。

320
00:59:57,730 --> 00:59:59,650
所以repeat--我不
希望它是10倍。

321
00:59:59,650 --> 01:00:01,370
这是怎么回事招人烦快。

322
01:00:01,370 --> 01:00:03,380
但我会重复三次。

323
01:00:03,380 --> 01:00:06,355
让我回去声
直到把它完成播放声音。

324
01:00:06,355 --> 01:00:08,480
让我回去控制
而只是等待一秒钟。

325
01:00:08,480 --> 01:00:10,271
和通知，您可能
觉得不适合，

326
01:00:10,271 --> 01:00:13,520
但如果再次磁你让它
在单元的地方，它会增长到填满。

327
01:00:13,520 --> 01:00:14,971
它是什么，现在玩吗？

328
01:00:14,971 --> 01:00:18,500
>> [喵喵叫]

329
01:00:18,500 --> 01:00:19,000
好。

330
01:00:19,000 --> 01:00:19,660
尼斯。

331
01:00:19,660 --> 01:00:22,540
而这也正是将被称为
一个程序，也是正确的。

332
01:00:22,540 --> 01:00:27,590
它meowed相当三次
自然地，但它设计得更好。

333
01:00:27,590 --> 01:00:29,580
我使用较少的冗余。

334
01:00:29,580 --> 01:00:30,970
我没有复制和粘贴任何东西。

335
01:00:30,970 --> 01:00:32,470
我只是用一个更好的主意。

336
01:00:32,470 --> 01:00:35,340
>> 现在，这仍然不是所有的
有趣的伤痕累累不做

337
01:00:35,340 --> 01:00:35,930
任何东西。

338
01:00:35,930 --> 01:00:37,388
因此，让我们做别的事情来代替。

339
01:00:37,388 --> 01:00:38,670
让我们做一些事情永远。

340
01:00:38,670 --> 01:00:39,420
你知道吗？

341
01:00:39,420 --> 01:00:40,470
运动似乎很有趣。

342
01:00:40,470 --> 01:00:45,760
让我们动他10
步骤，现在打比赛。

343
01:00:45,760 --> 01:00:46,570
>> 好。

344
01:00:46,570 --> 01:00:49,300
嗯，我们可以种阻力
他回来了，他仍然

345
01:00:49,300 --> 01:00:51,250
运行，因为他永远这样做。

346
01:00:51,250 --> 01:00:53,150
所以循环是做
它在说的事，

347
01:00:53,150 --> 01:00:54,650
但是这并不是那么有趣。

348
01:00:54,650 --> 01:00:55,310
我们开工吧。

349
01:00:55,310 --> 01:00:59,870
让我补充一个控制模块，并使用一个
的首次这些条件。

350
01:00:59,870 --> 01:01:03,119
>> 所以它要移动10 steps--
10个点，10个像素的screen--

351
01:01:03,119 --> 01:01:04,660
然后它会问这个问题。

352
01:01:04,660 --> 01:01:09,340
如果事情是真的，那么做
这事块中。

353
01:01:09,340 --> 01:01:13,060
因此，原来传感有一个整体
一堆布尔expressions--的

354
01:01:13,060 --> 01:01:16,580
Yes（是）的问题没有或真
假form--让我这样做。

355
01:01:16,580 --> 01:01:19,260
>> 如果touching--然后有
这个小下拉菜单。

356
01:01:19,260 --> 01:01:20,410
我可以将其参数化。

357
01:01:20,410 --> 01:01:23,010
如果触摸edge--让我们
做这样的事情。

358
01:01:23,010 --> 01:01:27,310
所以，如果触摸edge--
让我回去运动。

359
01:01:27,310 --> 01:01:32,281
而我们为什么不只是
转身180度？

360
01:01:32,281 --> 01:01:32,780
好吧。

361
01:01:32,780 --> 01:01:35,070
所以永远，移动10步。

362
01:01:35,070 --> 01:01:37,670
如果你接触
边，转180度。

363
01:01:37,670 --> 01:01:39,720
而这还不是该计划的结束
因为你在一个被永远挡，

364
01:01:39,720 --> 01:01:42,053
所以它会再次去
一遍又一遍又一遍。

365
01:01:42,053 --> 01:01:43,980
因此，让我们看看会发生什么。

366
01:01:43,980 --> 01:01:44,785
好。

367
01:01:44,785 --> 01:01:48,270
一个小马车，但那种清凉。

368
01:01:48,270 --> 01:01:51,710
>> 我们可以添加到此一些无聊的事
那是不是所有的智力

369
01:01:51,710 --> 01:01:52,270
有趣。

370
01:01:52,270 --> 01:01:57,210
但是，如果我们打这个小
麦克风button--哎哟。

371
01:01:57,210 --> 01:01:58,480
让我打扫一下。

372
01:01:58,480 --> 01:02:01,540
让我加强这方面的作为
他们会说在电视上。

373
01:02:01,540 --> 01:02:05,400
清理一下，保存，
现在去到脚本。

374
01:02:05,400 --> 01:02:07,500
>> 现在，让我去的声音。

375
01:02:07,500 --> 01:02:09,002
让我给它一个名字。

376
01:02:09,002 --> 01:02:12,440
我会打电话给这个哎哟。

377
01:02:12,440 --> 01:02:13,840
现在播放声音哎哟。

378
01:02:13,840 --> 01:02:16,520
请注意，它出现在
小下拉菜单。

379
01:02:16,520 --> 01:02:17,612
让我们来看看。

380
01:02:17,612 --> 01:02:20,444
>> [哎哟]

381
01:02:20,444 --> 01:02:24,377
>> [笑]

382
01:02:24,377 --> 01:02:25,835
但是，我们可以动态牛逼了改变。

383
01:02:25,835 --> 01:02:28,106
我们可以两倍烦人。

384
01:02:28,106 --> 01:02:31,760
>> [哎哟]

385
01:02:31,760 --> 01:02:35,332
>> 或者，如果我们使它像
在时间 -  1000步

386
01:02:35,332 --> 01:02:39,900

387
01:02:39,900 --> 01:02:40,670
>> 好。

388
01:02:40,670 --> 01:02:42,295
所以，我们要独自离开的那一个。

389
01:02:42,295 --> 01:02:45,290
如此反复，建筑blocks--我
开始与一些超级简单，

390
01:02:45,290 --> 01:02:47,930
然后我增加了一个功能，
增加了一个功能，增加了一个功能。

391
01:02:47,930 --> 01:02:50,721
而我不再需要担心
如何在第一的这些功能

392
01:02:50,721 --> 01:02:53,690
被实现为我继续
在上面一层的东西。

393
01:02:53,690 --> 01:02:55,430
所以，事实上，让我做另外一个在这里。

394
01:02:55,430 --> 01:03:00,580
让我继续前进，打开一个文件
我带来了进步，所谓的羊。

395
01:03:00,580 --> 01:03:03,970
>> 因此它具有略微不同
字符，看起来像这样。

396
01:03:03,970 --> 01:03:07,370
让我看看，如果我不能
使用计数器做些什么

397
01:03:07,370 --> 01:03:09,310
在此case--所谓变量。

398
01:03:09,310 --> 01:03:15,540
我要继续前进，Events--下
让我得到一个绿色的旗帜点击。

399
01:03:15,540 --> 01:03:19,030
然后让我去的数据，我知道
从仅仅玩弄之前，

400
01:03:19,030 --> 01:03:20,214
就是变量。

401
01:03:20,214 --> 01:03:21,880
而且我要继续前进，这拖累。

402
01:03:21,880 --> 01:03:25,144
>> 因此，一个变量，名为计数器，
我将其初始化为零。

403
01:03:25,144 --> 01:03:27,560
我可以称之为anything-- x或
y或z--但在编程，

404
01:03:27,560 --> 01:03:30,410
调用东西语义
有用的方法，如柜台，

405
01:03:30,410 --> 01:03:34,540
描述它是什么，它​​是一个
不少方便以后阅读你的代码。

406
01:03:34,540 --> 01:03:37,460
让我继续前进，得到
一个永远阻塞在这里。

407
01:03:37,460 --> 01:03:41,289
并让我去长相
页面，并做了说块。

408
01:03:41,289 --> 01:03:44,330
但是，什么是酷的变量是我
不必只是在一些类型

409
01:03:44,330 --> 01:03:47,850
像世界你好，我们已经过
完成后，我可以改为向数据

410
01:03:47,850 --> 01:03:50,690
并拖动我的变量，甚至
虽然外形并不完全

411
01:03:50,690 --> 01:03:53,000
看起来像它应该适合，
它会增长到填满。

412
01:03:53,000 --> 01:03:58,396
而我只想说一个计数器
second-- spoiler--他要算。

413
01:03:58,396 --> 01:04:00,380
我们会说这一秒。

414
01:04:00,380 --> 01:04:02,840
然后我会去
让他等待一秒钟，

415
01:04:02,840 --> 01:04:04,650
所以这不算涨得太快。

416
01:04:04,650 --> 01:04:08,430
然后最后，变更计数器
通过换句话说one--，

417
01:04:08,430 --> 01:04:13,520
递增一个计数器
附加价值，永远做到这一点。

418
01:04:13,520 --> 01:04:16,129
>> 所以羊太像一个
程序员，从0计数。

419
01:04:16,129 --> 01:04:20,350

420
01:04:20,350 --> 01:04:23,740
如果我们等待足够长，
他将永远做到这一点。

421
01:04:23,740 --> 01:04:27,740
但是，这并不完全正确，因为
事实上，正如我们将在一个星期内发现，

422
01:04:27,740 --> 01:04:31,871
更一般整数和计算机，
技术上只有一个finite--好，

423
01:04:31,871 --> 01:04:33,829
而计算机上，当
他们表示整数，

424
01:04:33,829 --> 01:04:35,670
只有比特的数量有限。

425
01:04:35,670 --> 01:04:37,860
这些灯泡有
只能算这么高

426
01:04:37,860 --> 01:04:39,239
你出的灯泡了。

427
01:04:39,239 --> 01:04:41,590
和一台电脑也是如此，
只有这么多的内存，

428
01:04:41,590 --> 01:04:44,640
只是有这么多的晶体管，
所以它只能算这么高。

429
01:04:44,640 --> 01:04:47,409
>> 因此，原来的羊，
我认为，可以算为2十亿

430
01:04:47,409 --> 01:04:48,409
什么蛮大的。

431
01:04:48,409 --> 01:04:50,325
因此，我们不打算
等待这种情况发生。

432
01:04:50,325 --> 01:04:54,850
但最终一些bug会发生
可以有一些非常现实世界

433
01:04:54,850 --> 01:04:55,970
后果。

434
01:04:55,970 --> 01:04:58,861
但是，除了羊，那
只是引入了一个变量。

435
01:04:58,861 --> 01:05:01,110
让我们继续前进，开拓
这是我事先做

436
01:05:01,110 --> 01:05:07,430
这里所说的宠物Cat--
宠物猫在这里。

437
01:05:07,430 --> 01:05:10,420
并注意这里的几
块，但是当绿旗

438
01:05:10,420 --> 01:05:12,474
点击后，永远做以下。

439
01:05:12,474 --> 01:05:15,265
如果你去摸鼠标
pointer--使光标在屏幕上，

440
01:05:15,265 --> 01:05:18,529
在arrow--玩喵喵声
然后等待两秒钟。

441
01:05:18,529 --> 01:05:19,570
而就在这样做永远。

442
01:05:19,570 --> 01:05:22,619
只要坚持等待
看是否pointer--

443
01:05:22,619 --> 01:05:24,710
如果猫触摸指针。

444
01:05:24,710 --> 01:05:26,060
>> 所以，我打游戏。

445
01:05:26,060 --> 01:05:26,920
什么也没有发生。

446
01:05:26,920 --> 01:05:28,980
但是，当我将光标移到猫，

447
01:05:28,980 --> 01:05:31,960
>> [喵喵叫]

448
01:05:31,960 --> 01:05:34,750
>> 如果我将其移开，不
再抚摸猫。

449
01:05:34,750 --> 01:05:38,090
因此，一些条件逻辑
嵌套在一个循环内。

450
01:05:38,090 --> 01:05:43,070
怎么样这个例子中，故意
所谓没有宠猫？

451
01:05:43,070 --> 01:05:45,253
这是什么打算做什么？

452
01:05:45,253 --> 01:05:47,880
>> [喵喵叫]

453
01:05:47,880 --> 01:05:50,215
>> 你为什么不应该宠物猫？

454
01:05:50,215 --> 01:05:59,440
>> [喵喵叫]

455
01:05:59,440 --> 01:06:00,699
>> 好。

456
01:06:00,699 --> 01:06:03,880
所以这是的，如果别人的例子。

457
01:06:03,880 --> 01:06:06,482
这是一个决策点和
因为它是坐在环，

458
01:06:06,482 --> 01:06:07,690
他们都得到检查。

459
01:06:07,690 --> 01:06:08,280
这是真的？

460
01:06:08,280 --> 01:06:08,760
这是真的？

461
01:06:08,760 --> 01:06:09,250
这是真的？

462
01:06:09,250 --> 01:06:09,791
这是真的？

463
01:06:09,791 --> 01:06:11,880
最终，一个
那些将要应用

464
01:06:11,880 --> 01:06:16,480
所以你听到的要么喵或
在这种情况下，狮子的吼声。

465
01:06:16,480 --> 01:06:21,400
>> 好吧，让我们做一个稍微看上一眼
我事先太...线程进行。

466
01:06:21,400 --> 01:06:25,210
这样一个线程仅仅是一个
一台计算机可以做的事情。

467
01:06:25,210 --> 01:06:29,349
因此，一个多线程程序是一个程序
可同时做多件事情。

468
01:06:29,349 --> 01:06:31,140
和所有的这些实施例
迄今有

469
01:06:31,140 --> 01:06:35,980
只是一个剧本，所以speak--
一个程序像这样在这里。

470
01:06:35,980 --> 01:06:38,810
但是请注意这个程序有
2精灵，两个字符。

471
01:06:38,810 --> 01:06:40,020
一个是鸟。

472
01:06:40,020 --> 01:06:40,870
一个是猫。

473
01:06:40,870 --> 01:06:45,080
>> 并注意当我点击这些下跌
左，他们每个人都有自己的脚本

474
01:06:45,080 --> 01:06:47,120
或与之相关联的程序。

475
01:06:47,120 --> 01:06:49,420
而这两项的
计划，通知，启动

476
01:06:49,420 --> 01:06:52,600
同当绿旗clicked--
让我们来看看在cat--

477
01:06:52,600 --> 01:06:54,030
当绿旗点击。

478
01:06:54,030 --> 01:06:58,220
所以事实上，当我打到现在的发挥，
两件事情会立刻发生。

479
01:06:58,220 --> 01:07:01,750
猫和鸟都
要同时操作

480
01:07:01,750 --> 01:07:03,815
创造这种效果。

481
01:07:03,815 --> 01:07:05,440
你可能想象发生了什么。

482
01:07:05,440 --> 01:07:08,340
有一个循环和鸟
和猫是在一个循环。

483
01:07:08,340 --> 01:07:11,270
鸟只是喜欢弹跳
我是当我说哎哟之前。

484
01:07:11,270 --> 01:07:13,040
但猫显然具有优势。

485
01:07:13,040 --> 01:07:16,040
还有另一种感应块
故意指向猫

486
01:07:16,040 --> 01:07:19,836
在这种情况下，这里的鸟。

487
01:07:19,836 --> 01:07:22,960
因此，我们可以梳理出，通过查看
通过这些块，发生了什么。

488
01:07:22,960 --> 01:07:25,460
但这里的关键因素之一。

489
01:07:25,460 --> 01:07:28,520
鸟，让这个游戏是不是
完全boring--或本animation--

490
01:07:28,520 --> 01:07:30,060
开始于一个随机的方向。

491
01:07:30,060 --> 01:07:32,890
和计算机正在复苏
90和180之间的数

492
01:07:32,890 --> 01:07:36,110
基本上，因此它是一个略
每一次不同的动画。

493
01:07:36,110 --> 01:07:39,480
>> 然后注意到这里，如果
猫接触小鸟，然后

494
01:07:39,480 --> 01:07:42,030
玩狮子4 sound--轰鸣声。

495
01:07:42,030 --> 01:07:46,330
但同时在鸟的
调色板，我们有这个。

496
01:07:46,330 --> 01:07:49,229
永远，如果不接触猫，
只是不停的往前三个步骤。

497
01:07:49,229 --> 01:07:50,770
然后这里的另一个拼图。

498
01:07:50,770 --> 01:07:52,030
如果你是在边缘，反弹。

499
01:07:52,030 --> 01:07:54,840
所以鸟是正中下怀
在意自己的业务，

500
01:07:54,840 --> 01:07:57,330
只是飞来飞去，并
弹跳，它真的

501
01:07:57,330 --> 01:08:01,780
该份条件逻辑猫
以确定它是否已经抓到了小鸟。

502
01:08:01,780 --> 01:08:02,280
好吧。

503
01:08:02,280 --> 01:08:08,800
因此，让我们做另外一个在这里，
这个被称为喜喜喜。

504
01:08:08,800 --> 01:08:15,100
而这一次在这里少了点
这一个永远循环。

505
01:08:15,100 --> 01:08:18,925
但是notice--我们怎么停
这很烦人的程序？

506
01:08:18,925 --> 01:08:21,600

507
01:08:21,600 --> 01:08:22,640
敲空格键。

508
01:08:22,640 --> 01:08:27,990
因为如果我这样做，
左手program--

509
01:08:27,990 --> 01:08:31,550
察觉到它的不断listening--
关键是空间按。

510
01:08:31,550 --> 01:08:34,090
如果空格键按下，
如果是这样，它有什么作用？

511
01:08:34,090 --> 01:08:35,980
它非常普遍的技术。

512
01:08:35,980 --> 01:08:38,590
它设置等于某个值的变量。

513
01:08:38,590 --> 01:08:39,741
但是，切换该值。

514
01:08:39,741 --> 01:08:41,490
[？所以外观？]
基于所述shape--我

515
01:08:41,490 --> 01:08:43,160
有一个变量，我
提前编写了一个名为

516
01:08:43,160 --> 01:08:44,770
静音，这只是说yes或no。

517
01:08:44,770 --> 01:08:45,880
是否设置为静音或没有？

518
01:08:45,880 --> 01:08:46,990
对或错？

519
01:08:46,990 --> 01:08:51,580
和通知，我说如果this--
静音是零，然后换到一个，

520
01:08:51,580 --> 01:08:53,840
否则设置静音为零。

521
01:08:53,840 --> 01:08:55,540
所以只是价值翻转从零到一。

522
01:08:55,540 --> 01:08:58,320
我可以done--改变
从两到三和三比二

523
01:08:58,320 --> 01:09:00,162
或四，五或四到六个。

524
01:09:00,162 --> 01:09:01,870
但没关系
我用的号码，

525
01:09:01,870 --> 01:09:04,090
只要我保持
改变它的对面。

526
01:09:04,090 --> 01:09:07,290
>> 而大多数任何程序员只想
选择零和one--虚假和真实，

527
01:09:07,290 --> 01:09:09,510
关闭并on--来表示这一点。

528
01:09:09,510 --> 01:09:10,930
这是仍在运行。

529
01:09:10,930 --> 01:09:12,190
如果我再敲空格键

530
01:09:12,190 --> 01:09:13,590
>> [SEAL声音]

531
01:09:13,590 --> 01:09:15,440
>> 该程序仍在运行。

532
01:09:15,440 --> 01:09:18,400
因为有这等脚本
上面写着，永远做到以下几点。

533
01:09:18,400 --> 01:09:21,390

534
01:09:21,390 --> 01:09:24,770
如果静音变量等于
zero--所以如果你没有静音

535
01:09:24,770 --> 01:09:29,609
是logic--如果它是假的
或者没有，则播放声音，

536
01:09:29,609 --> 01:09:30,650
因为你没有静音。

537
01:09:30,650 --> 01:09:33,358
您应该演奏的声音，然后
想喜喜喜两秒钟

538
01:09:33,358 --> 01:09:35,790
然后等待，并做到这一点
一遍又一遍又一遍。

539
01:09:35,790 --> 01:09:40,760
>> 因此在这种方式我们有一种方法
中场休息的人对程序进行交互。

540
01:09:40,760 --> 01:09:43,120
并且它们不必
像日期为其他。

541
01:09:43,120 --> 01:09:46,280
事实上，戳around--
没有双关语intended--

542
01:09:46,280 --> 01:09:49,250
有人花了一个巨大的量
实施时间在互联网上

543
01:09:49,250 --> 01:09:51,580
PokemonGo在划痕。

544
01:09:51,580 --> 01:09:55,440
它甚至geolocates你
剑桥或奥尔斯顿在这里。

545
01:09:55,440 --> 01:10:03,120
所以，如果你想看到过什么人
能做的就是this--很花哨的菜单。

546
01:10:03,120 --> 01:10:04,780
请点击此处。

547
01:10:04,780 --> 01:10:07,430
>> 这是我与我的箭头键了。

548
01:10:07,430 --> 01:10:09,446
我打算在这之后去。

549
01:10:09,446 --> 01:10:09,946
点击。

550
01:10:09,946 --> 01:10:12,949

551
01:10:12,949 --> 01:10:14,240
现在你点击PokeBall。

552
01:10:14,240 --> 01:10:17,130

553
01:10:17,130 --> 01:10:20,260
我的意思是，我觉得你
应该点击PokeBall。

554
01:10:20,260 --> 01:10:20,760
好吧。

555
01:10:20,760 --> 01:10:22,680
所以，我做到了。

556
01:10:22,680 --> 01:10:23,950
我可以在这里走了过来。

557
01:10:23,950 --> 01:10:27,790
而这个人实施一些
PokeBalls在这里 -  3 PokeBalls。

558
01:10:27,790 --> 01:10:29,950
>> 我们会发布一个链接到这个
网上这样你就可以玩了。

559
01:10:29,950 --> 01:10:32,364
但通知有刚
一些基本的构建块。

560
01:10:32,364 --> 01:10:33,780
它看起来有很多票友，它是。

561
01:10:33,780 --> 01:10:35,905
这是令人印象深刻，更
比我们通常会

562
01:10:35,905 --> 01:10:37,740
期待，当然，对于问题设定为零。

563
01:10:37,740 --> 01:10:40,809
我不知道多久
这个人上网时间。

564
01:10:40,809 --> 01:10:41,850
但是，这一切都只是一个循环。

565
01:10:41,850 --> 01:10:43,180
有一个声音播放。

566
01:10:43,180 --> 01:10:44,850
有一些类型的循环
听了我是否

567
01:10:44,850 --> 01:10:47,558
击中向上或向下
箭头或左和右，

568
01:10:47,558 --> 01:10:49,834
然后如果是这样，它的移动
它的一些数目的像素。

569
01:10:49,834 --> 01:10:51,750
然后如果我点击
另一个精灵，有

570
01:10:51,750 --> 01:10:53,390
某种情况是否存在。

571
01:10:53,390 --> 01:10:54,806
是啊，这是越来越过于激烈。

572
01:10:54,806 --> 01:10:56,100
我们要停下来。

573
01:10:56,100 --> 01:10:57,750
这是所有的基本组成部分。

574
01:10:57,750 --> 01:11:01,530
有其他没有其他成分
比那些我们已经看过了。

575
01:11:01,530 --> 01:11:04,670
>> 然而在这里，让我做
最后一个组的例子

576
01:11:04,670 --> 01:11:06,960
用于绘制的图片太
你可以做这里。

577
01:11:06,960 --> 01:11:10,481
这里是一个非常简单的程序，
少了点this--咳，咳，咳。

578
01:11:10,481 --> 01:11:12,480
与仅基于什么
我们已经看了到目前为止，

579
01:11:12,480 --> 01:11:14,570
哪里是显而易见的
机会改善。

580
01:11:14,570 --> 01:11:15,570
这个程序是正确的。

581
01:11:15,570 --> 01:11:17,980
它咳嗽三次，
这就是我的本意。

582
01:11:17,980 --> 01:11:19,650
但它的执行不力。

583
01:11:19,650 --> 01:11:20,600
它的设计很差。

584
01:11:20,600 --> 01:11:22,000
为什么？

585
01:11:22,000 --> 01:11:22,500
是啊。

586
01:11:22,500 --> 01:11:23,230
这不是一个循环。

587
01:11:23,230 --> 01:11:24,610
而且它是没有这么多
这不是一个循环，

588
01:11:24,610 --> 01:11:26,400
那就是有很多冗余。

589
01:11:26,400 --> 01:11:28,830
有被复制和
粘贴代码，可以这么说。

590
01:11:28,830 --> 01:11:31,830
而可能的解决方案
确实是一个循环。

591
01:11:31,830 --> 01:11:34,350
因此，让我先走
并呼吁改善。

592
01:11:34,350 --> 01:11:36,250
而我要在这里拖这些。

593
01:11:36,250 --> 01:11:39,986
让我先走，并得到一个重复
块，这一变化为三个。

594
01:11:39,986 --> 01:11:41,860
我要扔掉
其中的一些块。

595
01:11:41,860 --> 01:11:43,150
>> 你会发现它非常直观。

596
01:11:43,150 --> 01:11:45,691
拖放和事
出现并最终消失。

597
01:11:45,691 --> 01:11:49,170
而且我可以拖动该在这里了，
现在我有一个更清洁的版本依然。

598
01:11:49,170 --> 01:11:50,730
但是，你知道吗？

599
01:11:50,730 --> 01:11:52,940
有这样的机会
现在abstraction--

600
01:11:52,940 --> 01:11:56,350
开始以限定新的词汇
麻省理工学院没有预料到的。

601
01:11:56,350 --> 01:11:59,110
有等待和重复
永远，如果，

602
01:11:59,110 --> 01:12:02,590
但如果我想要什么介绍
这个词咳嗽作为一个块？

603
01:12:02,590 --> 01:12:06,230
如果我想要一个拼图
他们的生活目的就是咳嗽？

604
01:12:06,230 --> 01:12:10,720
>> 好吧，让我们来看看这个版本
在这里，我提出如下。

605
01:12:10,720 --> 01:12:13,579
奇妙的是，我已经创建
这一块拼图在这里，

606
01:12:13,579 --> 01:12:14,870
其中刮允许你这样做。

607
01:12:14,870 --> 01:12:16,787
事实上C和Python的
和JavaScript

608
01:12:16,787 --> 01:12:18,370
打算让你做这一点。

609
01:12:18,370 --> 01:12:21,830
您可以创建自己的自定义
你打电话给你想要的作品。

610
01:12:21,830 --> 01:12:24,890
在这种情况下，咳嗽感觉
像一个合理的定义。

611
01:12:24,890 --> 01:12:27,880
然后用这些碎片倒
在这里你能定义是什么意思。

612
01:12:27,880 --> 01:12:30,290
>> 我拖着从下降
此调色板这里 - 更多

613
01:12:30,290 --> 01:12:33,500
blocks--这个大紫
块，在那里我的咳嗽类型

614
01:12:33,500 --> 01:12:35,290
作为我的新拼图的名称。

615
01:12:35,290 --> 01:12:39,920
然后我说，任何时候用户
称这种新的咳嗽一块拼图，

616
01:12:39,920 --> 01:12:41,770
做一个发言权和等待。

617
01:12:41,770 --> 01:12:46,160
所以，在这里我重复块，
我只能咳嗽三次。

618
01:12:46,160 --> 01:12:49,972
>> 而且我认为，特别是
如果现在你隐藏这个细节。

619
01:12:49,972 --> 01:12:51,430
谁在乎咳嗽怎么实现？

620
01:12:51,430 --> 01:12:54,390
我所关心的一个
程序员，我可止咳。

621
01:12:54,390 --> 01:12:56,280
我不在乎怎么说的实现。

622
01:12:56,280 --> 01:12:58,620
我只关心的
猫能说些什么。

623
01:12:58,620 --> 01:13:02,720
我可以抽象掉的细节，
只专注于屏幕上这里什么。

624
01:13:02,720 --> 01:13:04,400
但我可以进一步借此一步。

625
01:13:04,400 --> 01:13:08,070
>> 请注意，在这里，我有
实施循环三次。

626
01:13:08,070 --> 01:13:11,560
但是，如果不是我抢这个版本？

627
01:13:11,560 --> 01:13:14,640
而如果不是
这里这个版本，

628
01:13:14,640 --> 01:13:18,730
我只是改变我的拼图拿
参数，并输入你们自己？

629
01:13:18,730 --> 01:13:21,100
而且输入可以是
一些像三个。

630
01:13:21,100 --> 01:13:24,580
所以，现在，如果我写一个程序
我想猫咳嗽，

631
01:13:24,580 --> 01:13:28,270
其实，我可以告诉拼图
拼凑多少次咳嗽，

632
01:13:28,270 --> 01:13:31,990
因为这里的底部，票友
这些定制拼图版

633
01:13:31,990 --> 01:13:34,500
让我指定
咳，其实需要

634
01:13:34,500 --> 01:13:36,951
一个input--需要一个像这样的论点。

635
01:13:36,951 --> 01:13:37,700
你知道吗？

636
01:13:37,700 --> 01:13:38,890
也许我知道，等一下。

637
01:13:38,890 --> 01:13:40,680
咳嗽是same--
这是从根本上

638
01:13:40,680 --> 01:13:42,120
同样的想法打喷嚏。

639
01:13:42,120 --> 01:13:44,040
这只是一个不同的
字在屏幕上。

640
01:13:44,040 --> 01:13:46,550
我可以抽象掉
进一步贯彻

641
01:13:46,550 --> 01:13:48,750
的这个最终版本
咳嗽，乍一看

642
01:13:48,750 --> 01:13:50,660
方法是更复杂的期待。

643
01:13:50,660 --> 01:13:52,140
但是请注意我做了什么。

644
01:13:52,140 --> 01:13:55,930
我现在已经generalized--泛型化
真的 - 这拼图

645
01:13:55,930 --> 01:13:59,900
被称为说字n次。

646
01:13:59,900 --> 01:14:04,410
>> 现在我有两个新的拼图
到这里定义的咳嗽n次。

647
01:14:04,410 --> 01:14:06,790
又是什么止咳的功能呢？

648
01:14:06,790 --> 01:14:08,420
什么是我的自定义拼图吗？

649
01:14:08,420 --> 01:14:11,996
它只是调用发言权块，
传递我想说的话，

650
01:14:11,996 --> 01:14:13,870
传递数
多少次我想说的话。

651
01:14:13,870 --> 01:14:18,210
因为现在我可以实现
简单地说ACHOO打喷嚏，

652
01:14:18,210 --> 01:14:20,320
在这种情况下，一些次数。

653
01:14:20,320 --> 01:14:22,360
>> 所以我分层和层次感。

654
01:14:22,360 --> 01:14:25,690
再次，这里的关键是不
我是如何实现它，但事实

655
01:14:25,690 --> 01:14:28,070
如果我只是从字面上
这些移动关闭屏幕，

656
01:14:28,070 --> 01:14:31,280
怎么看怎么简单，如果不
漂亮的我的计划现在看起来。

657
01:14:31,280 --> 01:14:33,930
因为它做的事情
说，我已经抽象

658
01:14:33,930 --> 01:14:37,640
走什么是黑盒子里面。
它正好是一个紫色的盒子在这里，

659
01:14:37,640 --> 01:14:41,430
但我已经离开受阻里面有什么
因为我不关心它是如何工作。

660
01:14:41,430 --> 01:14:43,650
我刚才它的工作原理在意。

661
01:14:43,650 --> 01:14:46,375
>> 事实上，在问题
设置为零，这正是

662
01:14:46,375 --> 01:14:49,250
那种想法的层次感你会
要探索的机会。

663
01:14:49,250 --> 01:14:53,510
这正是机会
适用于解决问题的技巧，

664
01:14:53,510 --> 01:14:55,550
什么是可能是一个
陌生的环境。

665
01:14:55,550 --> 01:14:57,890
而无论你没有编程
前或编程，

666
01:14:57,890 --> 01:14:59,500
你会发现，有
一个小东西

667
01:14:59,500 --> 01:15:00,874
在这种环境中的每一个人。

668
01:15:00,874 --> 01:15:02,770
并与问题集
之一，一个星期的时间，

669
01:15:02,770 --> 01:15:06,630
我们将过渡到聚焦
在被称为高级语言

670
01:15:06,630 --> 01:15:09,290
C--或相当的低级
所谓的高级语言

671
01:15:09,290 --> 01:15:11,347
C--这更
功能强大，即使它的

672
01:15:11,347 --> 01:15:12,930
有点乍一看更加神秘。

673
01:15:12,930 --> 01:15:16,740
>> 你会每今天的TL意识到：DR，
这个问题设置具有较短

674
01:15:16,740 --> 01:15:19,880
时间会比将来的窗口，只需
因为你应该还算找到它

675
01:15:19,880 --> 01:15:20,420
无障碍。

676
01:15:20,420 --> 01:15:22,211
而不是担心，如果
您添加上课迟到。

677
01:15:22,211 --> 01:15:23,920
我们将解决这个不久。

678
01:15:23,920 --> 01:15:28,480
而之前我们休会的蛋糕，让我们
只有一两分钟的样子完成

679
01:15:28,480 --> 01:15:30,500
什么，你在这里等待着CS50。

680
01:15:30,500 --> 01:15:40,950

681
01:15:40,950 --> 01:17:20,803
[音乐]

682
01:17:20,803 --> 01:17:21,302
好吧。

683
01:17:21,302 --> 01:17:22,690
以上就是CS50。

684
01:17:22,690 --> 01:17:23,650
我们很快就会看到你。

685
01:17:23,650 --> 01:17:25,526
蛋糕现在担任。

686
01:17:25,526 --> 01:17:28,998

687
01:17:28,998 --> 01:18:14,267
[音乐]

688
01:18:14,267 --> 01:18:16,350
扬声器17：你听说过
的休假，首席？

689
01:18:16,350 --> 01:18:29,490

690
01:18:29,490 --> 01:18:31,920
扬声器18：或许有
更引擎盖下。

691
01:18:31,920 --> 01:18:38,279