1
00:00:14,320 --> 00:00:17,970
所以这是我最大的乐趣
今天在这里欢迎大家

2
00:00:17,970 --> 00:00:20,600
第一个讲座
的，好了，介绍

3
00:00:20,600 --> 00:00:22,510
以计算和编程。

4
00:00:22,510 --> 00:00:29,110
又称CS50或井水，CPSC
100正式在耶鲁。

5
00:00:29,110 --> 00:00:34,820
>> 所以，我们不能更兴奋
在这里欢迎各位。

6
00:00:34,820 --> 00:00:36,620
我的名字是帕特里克Rebeschini。

7
00:00:36,620 --> 00:00:39,180
我的头教练的类。

8
00:00:39,180 --> 00:00:43,600
我在这里代表一组
约60名工作人员

9
00:00:43,600 --> 00:00:46,380
这将与您合作
整个学期。

10
00:00:46,380 --> 00:00:49,040
这个数字几乎是60我们。

11
00:00:49,040 --> 00:00:52,440
沿着尚未非凡
承诺的水平

12
00:00:52,440 --> 00:00:56,555
我们投入这个
类，使CS50类

13
00:00:56,555 --> 00:01:00,690
在耶鲁大学，提供
支持的最大级别

14
00:01:00,690 --> 00:01:01,960
献给你们所有人。

15
00:01:01,960 --> 00:01:05,940
而且我们不能更自豪
在这里再次提供这一类。

16
00:01:05,940 --> 00:01:11,380
>> 事实上，你很快就会体验到，
CS50比类得多。

17
00:01:11,380 --> 00:01:13,120
这是一个社区。

18
00:01:13,120 --> 00:01:15,250
而你将是一部分
很快这个社区。

19
00:01:15,250 --> 00:01:18,730
这是第二年
耶鲁大学是提供此类。

20
00:01:18,730 --> 00:01:21,640
我们正在建设的极端
去年的成功，在那里

21
00:01:21,640 --> 00:01:24,340
首次，
在这里这所大学，

22
00:01:24,340 --> 00:01:28,930
本科学习助手
在课堂上获得通过。

23
00:01:28,930 --> 00:01:32,650
这一切都始于
这个类的最后一年。

24
00:01:32,650 --> 00:01:37,050
>> 所以，如你所知，这个类是教
会同哈佛大学。

25
00:01:37,050 --> 00:01:39,920
教这门课
我们relying--我们可以

26
00:01:39,920 --> 00:01:44,850
指望伟大的专长
大卫·马兰和哈佛团队。

27
00:01:44,850 --> 00:01:48,930
大卫一直教学
CS50的好了，现在10年。

28
00:01:48,930 --> 00:01:51,160
每一年他一直
推动边界

29
00:01:51,160 --> 00:01:54,210
和改善课堂体验。

30
00:01:54,210 --> 00:01:58,940
同样，我们不能更高兴
与他们继续这种合作。

31
00:01:58,940 --> 00:02:01,840
>> 的事实上，人们
最有趣的部分，

32
00:02:01,840 --> 00:02:06,560
我会说，现在运行这个类的，
无论是在哈佛和这里在耶鲁，

33
00:02:06,560 --> 00:02:09,420
是真是不可思议
异体受精

34
00:02:09,420 --> 00:02:13,770
理念，旨在提高
学习经历对你的所有。

35
00:02:13,770 --> 00:02:18,130
因此，作为这一广泛的结果
两者之间的协作

36
00:02:18,130 --> 00:02:23,070
大学，CS50是自豪地
今年发布的新版本

37
00:02:23,070 --> 00:02:24,770
有明显的变化。

38
00:02:24,770 --> 00:02:27,580
大卫都会告诉我们他们现在。

39
00:02:27,580 --> 00:02:31,450
所以please--这之中
说，请和我一起

40
00:02:31,450 --> 00:02:34,220
欢迎给一个
热烈的掌声

41
00:02:34,220 --> 00:02:37,290
欢迎大卫和
哈佛大学专家小组在耶鲁。

42
00:02:37,290 --> 00:02:40,032
>> [掌声]

43
00:02:40,032 --> 00:02:41,882

44
00:02:41,882 --> 00:02:43,247
>> DAVID MALAN：谢谢。

45
00:02:43,247 --> 00:02:43,746
谢谢。

46
00:02:43,746 --> 00:02:46,550

47
00:02:46,550 --> 00:02:51,400
这是CS50，哈佛大学
和耶鲁大学的介绍

48
00:02:51,400 --> 00:02:53,960
到智能
计算机科学的企业

49
00:02:53,960 --> 00:02:55,490
和艺术节目。

50
00:02:55,490 --> 00:02:59,640
而这是什么意思的是，这门课程
最后，是关于解决问题。

51
00:02:59,640 --> 00:03:01,849
事实上，许多人可能
已走出高中

52
00:03:01,849 --> 00:03:04,931
或已经在过去的几年中
想知道你的朋友们

53
00:03:04,931 --> 00:03:06,380
去年做或其他类。

54
00:03:06,380 --> 00:03:08,449
然而，现实
是，不管我们

55
00:03:08,449 --> 00:03:11,740
在这个类做在一天结束时，
这将是关于解决问题。

56
00:03:11,740 --> 00:03:14,320
>> 正因为如此，或许取
一些安慰的事实

57
00:03:14,320 --> 00:03:16,770
的学生有73％的
借此类，都在这里

58
00:03:16,770 --> 00:03:20,235
在耶鲁大学和哈佛大学，
以前从未采取了CS类。

59
00:03:20,235 --> 00:03:22,610
所以，如果你坐在这里
今天观众疑惑

60
00:03:22,610 --> 00:03:24,520
你为什么坐在这里
在今天的听众，

61
00:03:24,520 --> 00:03:26,300
或者，也许你只是跟着
以及一些朋友，

62
00:03:26,300 --> 00:03:28,299
或者你已经是一个
有点好奇，以什么

63
00:03:28,299 --> 00:03:30,194
计算机科学与
编程，实现

64
00:03:30,194 --> 00:03:32,860
大部分同学对
左和向你的权利

65
00:03:32,860 --> 00:03:35,840
在相同的人口非常多。

66
00:03:35,840 --> 00:03:38,120
>> 事实上，如果我们看一下
在去年的统计数据

67
00:03:38,120 --> 00:03:42,760
CS50的学生身上，无论是在
在这里和在哈佛，学生的58％

68
00:03:42,760 --> 00:03:44,630
形容自己不太舒服。

69
00:03:44,630 --> 00:03:46,090
9％是比较舒适的。

70
00:03:46,090 --> 00:03:47,699
然后，33％则介于两者之间。

71
00:03:47,699 --> 00:03:50,240
而且也没有正式的定义
这些桶是什么意思。

72
00:03:50,240 --> 00:03:52,335
你那种知道你
如果你不太舒服。

73
00:03:52,335 --> 00:03:54,840
你感觉有点不安
与类说不定正在。

74
00:03:54,840 --> 00:03:57,840
你不是如果一台计算机很确定
科普类的，最终你，

75
00:03:57,840 --> 00:04:00,009
并意识到你
在非常好的公司。

76
00:04:00,009 --> 00:04:01,800
事实上分级，
和评估，

77
00:04:01,800 --> 00:04:04,466
和反馈，以及所有的那
支撑结构中的类

78
00:04:04,466 --> 00:04:06,550
最终是非常个性化。

79
00:04:06,550 --> 00:04:09,187
更何况比大多数的
其他类设计。

80
00:04:09,187 --> 00:04:11,520
事实上，最终什么
事项该类不

81
00:04:11,520 --> 00:04:14,180
这么多，你结束
达相对于其他，

82
00:04:14,180 --> 00:04:18,070
但如果你在11周或最后，
而相对于自己在一周

83
00:04:18,070 --> 00:04:20,372
0在这里我们的第一个。

84
00:04:20,372 --> 00:04:21,330
那么，是什么意思呢？

85
00:04:21,330 --> 00:04:24,750
那么，这意味着那些73％
学生去年从来没有采取

86
00:04:24,750 --> 00:04:26,917
一个CS课前，由
启动学期他们

87
00:04:26,917 --> 00:04:29,500
在语言涉足了
所谓的划痕，这是我们自己

88
00:04:29,500 --> 00:04:30,340
今天在这里看到。

89
00:04:30,340 --> 00:04:32,190
并通过了结束
学期如果他们走了

90
00:04:32,190 --> 00:04:34,700
通过这个挑战整个列表。

91
00:04:34,700 --> 00:04:36,399
用语言名为c开始。

92
00:04:36,399 --> 00:04:38,190
实施，有什么
乍看之下，去

93
00:04:38,190 --> 00:04:41,010
是有点的挑战
一些，但还算喜人，一旦你

94
00:04:41,010 --> 00:04:44,510
获得超级马里奥弹跳
上下金字塔

95
00:04:44,510 --> 00:04:47,005
实施，虽然，只有
一些所谓的ASCII艺术。

96
00:04:47,005 --> 00:04:49,380
实施最后year--什么
学生去年则

97
00:04:49,380 --> 00:04:53,270
没有以后才实现其
自己的凯撒密码和V @ genere加密。

98
00:04:53,270 --> 00:04:55,180
所以加密算法
与您可以

99
00:04:55,180 --> 00:04:58,920
加密信息，然后解读
信息发送秘密信息。

100
00:04:58,920 --> 00:05:00,010
15游戏。

101
00:05:00,010 --> 00:05:02,260
如果你还记得，从
童年或一些党员的青睐，

102
00:05:02,260 --> 00:05:05,000
那个小塑料的游戏，你移动
的数字上，下，左，右

103
00:05:05,000 --> 00:05:07,500
要尽量让他们按顺序
实际执行的那场比赛

104
00:05:07,500 --> 00:05:09,640
和解决需要有逻辑。

105
00:05:09,640 --> 00:05:11,640
然后我们涉足
取证的最后一年。

106
00:05:11,640 --> 00:05:13,810
>> 因此，通过学期中旬，
学生谁从未

107
00:05:13,810 --> 00:05:16,130
用自己的键盘
为此目的之前，

108
00:05:16,130 --> 00:05:19,030
在编写软件
恢复，可以这么说，

109
00:05:19,030 --> 00:05:21,420
JPEG文件或照片
我们有意外

110
00:05:21,420 --> 00:05:24,430
从数字删除
从相机存储卡。

111
00:05:24,430 --> 00:05:28,130
恢复秘密信息
从位图图像的内部，

112
00:05:28,130 --> 00:05:30,030
和其它这种类型的
显卡为好。

113
00:05:30,030 --> 00:05:32,770
>> 然后我们转移到给
全班同学的字典。

114
00:05:32,770 --> 00:05:36,330
只是一个非常大的文本文件
15万英语单词。

115
00:05:36,330 --> 00:05:39,080
每个人都被质疑
以某种方式读取，可以这么说，

116
00:05:39,080 --> 00:05:40,780
这些话到内存中。

117
00:05:40,780 --> 00:05:42,060
到计算机的内存中。

118
00:05:42,060 --> 00:05:44,310
然后回答问题
的形式下，这是一个字？

119
00:05:44,310 --> 00:05:44,934
这是一个词？

120
00:05:44,934 --> 00:05:45,580
这是一个词？

121
00:05:45,580 --> 00:05:47,880
真的只是实施
拼写检查。

122
00:05:47,880 --> 00:05:50,320
然后每个挑战
另外一个大board--

123
00:05:50,320 --> 00:05:53,040
一个领导委员会，看看谁能够
使用的内存量最少，

124
00:05:53,040 --> 00:05:56,470
在时间到最少
实际上拼写检查大型文档。

125
00:05:56,470 --> 00:05:59,760
>> 我们从过渡再到
那些实现自己的Web服务器。

126
00:05:59,760 --> 00:06:04,070
所以，在没有语言制作网页
像HTML和CSS，如果你熟悉。

127
00:06:04,070 --> 00:06:06,360
但实际执行
该服务器

128
00:06:06,360 --> 00:06:09,260
侦听在互联网上
从浏览器的请求

129
00:06:09,260 --> 00:06:11,022
再响应这些请求。

130
00:06:11,022 --> 00:06:13,230
然后实现我们自己
电子贸易网站一样，在那里

131
00:06:13,230 --> 00:06:15,490
学生可以购买和出售股票。

132
00:06:15,490 --> 00:06:18,590
在绘制近实时
股票报价从雅虎财务。

133
00:06:18,590 --> 00:06:21,200
并让学生看
他们的投资组合如何发展。

134
00:06:21,200 --> 00:06:23,570
然后最后一个混搭
谷歌新闻和谷歌

135
00:06:23,570 --> 00:06:26,540
地图即学生
通过计算最终期限

136
00:06:26,540 --> 00:06:30,110
不得不点击的能力，以及
圆形，和搜索谷歌地图上。

137
00:06:30,110 --> 00:06:32,060
再看看所有的
新闻文章，

138
00:06:32,060 --> 00:06:33,940
是靠近这些特定区域。

139
00:06:33,940 --> 00:06:36,180
因此，要真正实现从零到60。

140
00:06:36,180 --> 00:06:39,420
>> 而一路上有我们有什么
去年叫，黑客补充。

141
00:06:39,420 --> 00:06:41,211
这提高标准
进一步，对于那些你

142
00:06:41,211 --> 00:06:44,390
谁很可能会有着良好的
经验量在9％是

143
00:06:44,390 --> 00:06:45,349
更舒适。

144
00:06:45,349 --> 00:06:47,140
因此，认识到有
一个非常高的天花板

145
00:06:47,140 --> 00:06:49,200
即使在那些
对学生的挑战

146
00:06:49,200 --> 00:06:50,660
来自不同背景的。

147
00:06:50,660 --> 00:06:52,618
因为在年底
那天，我们最终

148
00:06:52,618 --> 00:06:54,910
很简单集中于此。

149
00:06:54,910 --> 00:06:57,010
>> 但是，这是否
意思是说，问题的解决？

150
00:06:57,010 --> 00:06:59,100
因此，让我们提议
我们提炼像这样。

151
00:06:59,100 --> 00:07:01,550
因此，解决问题的能力实在是
正是这种画面。

152
00:07:01,550 --> 00:07:04,675
所以，你得投入到一些问题，
东西你真的想解决的问题。

153
00:07:04,675 --> 00:07:07,020
的目标是获得输出，
解决这一问题的。

154
00:07:07,020 --> 00:07:09,950
然后在中间
我们会打电话给一个黑盒子。

155
00:07:09,950 --> 00:07:13,970
你不一定知道，甚至
不在乎那是什么黑盒子里面。

156
00:07:13,970 --> 00:07:16,670
所有你知道的是，当
你给输入进去，

157
00:07:16,670 --> 00:07:19,890
你希望得到的输出
或从它的溶液。

158
00:07:19,890 --> 00:07:22,380
虽然今天我们来看看
无论是在输入和输出，

159
00:07:22,380 --> 00:07:24,838
我们将长期的，并通过
整个学期的课程，

160
00:07:24,838 --> 00:07:26,880
重点放在盒子里有什么。

161
00:07:26,880 --> 00:07:30,040
>> 并在其中会说谎
所谓算法。

162
00:07:30,040 --> 00:07:33,300
由步说明
其实解决一些问题。

163
00:07:33,300 --> 00:07:35,090
但是，什么是一些输入的例子吗？

164
00:07:35,090 --> 00:07:37,840
所以，也许在一个简单的事情
开始每学年，有人

165
00:07:37,840 --> 00:07:39,090
可能要好好听讲。

166
00:07:39,090 --> 00:07:42,030
因此，我们可以做一，二，
三，四，五，六，

167
00:07:42,030 --> 00:07:44,010
我怎么会养
轨道的信息。

168
00:07:44,010 --> 00:07:46,051
我可能只是去一，二，
三，四，五，六。

169
00:07:46,051 --> 00:07:47,720
而只使用排序个位数。

170
00:07:47,720 --> 00:07:51,210
>> 或者，我可以实际记录
这个长一点的术语。

171
00:07:51,210 --> 00:07:53,340
以及如何我代表全体
在这个房间里的人？

172
00:07:53,340 --> 00:07:54,900
好吧，我可能会做这样的事情，OK。

173
00:07:54,900 --> 00:07:56,070
我看到一个人。

174
00:07:56,070 --> 00:07:56,600
好吧。

175
00:07:56,600 --> 00:08:01,180
我看到另一个人，一个
第三人，等等。

176
00:08:01,180 --> 00:08:04,070
但是，没有人计算人喜欢这个。

177
00:08:04,070 --> 00:08:06,952
所以，从字面上看，我们大多数人，如果我们
甚至将不惜一切画什么，

178
00:08:06,952 --> 00:08:08,910
很可能要去
一二三四，

179
00:08:08,910 --> 00:08:14,240
也许会有点花哨，五，六，
七，八，九，十等。

180
00:08:14,240 --> 00:08:16,960
>> 而这实际上是一个
系统，称为一元。

181
00:08:16,960 --> 00:08:20,549
宇野，像UNO暗示之一，你在哪里
只是有一个字母。

182
00:08:20,549 --> 00:08:21,840
你刚刚得到这个哈希标志。

183
00:08:21,840 --> 00:08:24,570
而我，求效益，只是画
这些散列标记，最终

184
00:08:24,570 --> 00:08:25,500
为直线。

185
00:08:25,500 --> 00:08:27,666
不过，我可以得出他们
作为小棍子数字。

186
00:08:27,666 --> 00:08:29,550
凡代表
一个人，一个输入，

187
00:08:29,550 --> 00:08:32,210
我只画一棒
图或哈希标记。

188
00:08:32,210 --> 00:08:33,910
但是，这是不是所有的表现力。

189
00:08:33,910 --> 00:08:38,020
>> 如果我只有这些哈希
商标，别说简笔画，

190
00:08:38,020 --> 00:08:41,410
我怎么可能代表
像数字15？

191
00:08:41,410 --> 00:08:43,050
或15人在房间里？

192
00:08:43,050 --> 00:08:48,740
我可能会做这样的事情1，
2，3，4，5，6，7，8，9，10，11，12，13，

193
00:08:48,740 --> 00:08:51,270
14，15。

194
00:08:51,270 --> 00:08:52,830
它只是没有很好地进行缩放。

195
00:08:52,830 --> 00:08:55,730
由于投入得到大，我们
需要比这更好的系统。

196
00:08:55,730 --> 00:08:57,910
>> 而且事实证明，
系统计算机使用

197
00:08:57,910 --> 00:09:00,510
是不是所有的不同
你和我知道的。

198
00:09:00,510 --> 00:09:03,301
事实上，大多数人在这个房间里，
即使你是在那些较少

199
00:09:03,301 --> 00:09:06,300
舒适，不一定知道
如何在Mac或PC还真管用，

200
00:09:06,300 --> 00:09:09,810
你可能至少听说过，那
罩下方为0和1的。

201
00:09:09,810 --> 00:09:11,390
的所谓的二元系统。

202
00:09:11,390 --> 00:09:15,340
因此，我们确实，电脑已超过
只是他们的词汇哈希标记，

203
00:09:15,340 --> 00:09:17,450
但不及的一个
词汇表我们人类。

204
00:09:17,450 --> 00:09:19,210
>> 事实上，我们人类不使用二进制。

205
00:09:19,210 --> 00:09:21,160
毕意2，0和1。

206
00:09:21,160 --> 00:09:24,140
但是小数，DECA
这意味着10，0到9。

207
00:09:24,140 --> 00:09:27,660
因此，我们有更多的表现
能力在我们正常人的世界。

208
00:09:27,660 --> 00:09:31,720
但我认为，这些系统中，
二进制，十进制和，和一切

209
00:09:31,720 --> 00:09:35,290
之间和超越，是
其实所有相当熟悉了。

210
00:09:35,290 --> 00:09:39,650
例如，考虑
这里这个例子中，123。

211
00:09:39,650 --> 00:09:43,850
所以，这确实是的，当然，
一些我们所知道的123。

212
00:09:43,850 --> 00:09:47,160
但我只是画只是这个
符号的图案，雕文可以这么说。

213
00:09:47,160 --> 00:09:49,100
排序在粉笔板形状。

214
00:09:49,100 --> 00:09:52,951
>> 但是，为什么我们立即和
直观地掌握这123？

215
00:09:52,951 --> 00:09:54,700
好吧，如果你是象
我在小学的时候，

216
00:09:54,700 --> 00:09:59,920
你可能知道，这是
1秒列，这是10秒列，

217
00:09:59,920 --> 00:10:01,330
这是数百列。

218
00:10:01,330 --> 00:10:02,860
为什么会这样有用吗？

219
00:10:02,860 --> 00:10:06,440
那么，它现在是简单的算术你
执行从符号的方式来获得

220
00:10:06,440 --> 00:10:08,940
到了一些我们直观地理解。

221
00:10:08,940 --> 00:10:14,160
是什么，100次1，然后
10次​​2和1次3，

222
00:10:14,160 --> 00:10:17,860
这当然仅仅是100和
这是20，这是三。

223
00:10:17,860 --> 00:10:19,740
所以，如果我们增加这些together--啊。

224
00:10:19,740 --> 00:10:23,880
所以潜藏的那种推理
为什么这组符号后面

225
00:10:23,880 --> 00:10:26,550
意味着什么真正的和数值。

226
00:10:26,550 --> 00:10:32,030
>> 那么，电脑做同样的事情，
但他们只能算高达之一。

227
00:10:32,030 --> 00:10:34,400
而我能
数高达三种。

228
00:10:34,400 --> 00:10:37,380
而事实上，如果我坚持下来了，我可以
走高达在这个系统九岁。

229
00:10:37,380 --> 00:10:40,430
计算机只有零点
和那些在他们的字母表。

230
00:10:40,430 --> 00:10:41,410
>> 那么，是什么意思呢？

231
00:10:41,410 --> 00:10:46,900
那么，它只是意味着，如果一台计算机
希望代表，说数字0，

232
00:10:46,900 --> 00:10:51,300
也许用三个characters-- 3
英文字母可以这么说，

233
00:10:51,300 --> 00:10:53,050
这是一个计算机如何表示0。

234
00:10:53,050 --> 00:10:54,620
所以，不是所有的吓人为止。

235
00:10:54,620 --> 00:10:56,450
这正是我们人类会做。

236
00:10:56,450 --> 00:10:59,410
而事实上，我们大多数人只是
忽略前导零反正。

237
00:10:59,410 --> 00:11:01,640
>> 一台电脑，如果它想
来存储数字1，

238
00:11:01,640 --> 00:11:03,330
原来是要做到这一点。

239
00:11:03,330 --> 00:11:05,630
和一个计算机存储
数字2是不

240
00:11:05,630 --> 00:11:09,280
打算做一元体系，
我前面提到。

241
00:11:09,280 --> 00:11:11,360
它实际上是要做到这一点。

242
00:11:11,360 --> 00:11:13,570
而这可能是
，该模式启动

243
00:11:13,570 --> 00:11:15,570
成为大多数人不太明显。

244
00:11:15,570 --> 00:11:18,580
这是2，这是3。

245
00:11:18,580 --> 00:11:21,600
奇怪的是，这是现在4。

246
00:11:21,600 --> 00:11:24,120
而现在它确实
似乎是可能隐蔽，

247
00:11:24,120 --> 00:11:26,762
但它不是，如果我们考虑
什么二进制的真正含义。

248
00:11:26,762 --> 00:11:28,720
这意味着你有两个
你的英文字母。

249
00:11:28,720 --> 00:11:31,940
所以，两种可能的字符
每一个占位符。

250
00:11:31,940 --> 00:11:35,970
>> 所以这实际上意味着我们要去
需要一个1秒的地方，或2秒的地方，

251
00:11:35,970 --> 00:11:40,800
一个4S店的地方，然后
8，和16，32和64。

252
00:11:40,800 --> 00:11:42,290
这有什么区别呢？

253
00:11:42,290 --> 00:11:47,150
像这些都是1，2，4，8，16，32，64。

254
00:11:47,150 --> 00:11:50,690
而我们有110个，10万级，万级之前。

255
00:11:50,690 --> 00:11:53,170
有什么相似呢？

256
00:11:53,170 --> 00:11:54,940
又有什么格局？

257
00:11:54,940 --> 00:11:55,505
是啊。

258
00:11:55,505 --> 00:11:57,380
学生：2权力
而不是10的幂。

259
00:11:57,380 --> 00:11:57,660
DAVID MALAN：是的。

260
00:11:57,660 --> 00:11:59,290
2的幂而不是10的幂。

261
00:11:59,290 --> 00:12:02,160
所以如果我想继续
去，8，16和等等forth--

262
00:12:02,160 --> 00:12:05,822
但是现在，如果你有这种
线索的，现在的双星系统

263
00:12:05,822 --> 00:12:07,280
其实很简单。

264
00:12:07,280 --> 00:12:10,910
为什么是0的这种模式
电脑0的世界呢？

265
00:12:10,910 --> 00:12:14,910
就是因为它的4倍0,2
次0，1次0，你会得到0。

266
00:12:14,910 --> 00:12:16,650
>> 为什么这是1号？

267
00:12:16,650 --> 00:12:20,070
同样的道理，但现在我们
在1列中有1。

268
00:12:20,070 --> 00:12:21,840
这是为什么2？

269
00:12:21,840 --> 00:12:24,450
我们在闪柱有一个1。

270
00:12:24,450 --> 00:12:30,190
怎么然后做我代表
就是说，在二进制数字7？

271
00:12:30,190 --> 00:12:31,324
说的更响亮。

272
00:12:31,324 --> 00:12:32,170
>> 学生：三1秒。

273
00:12:32,170 --> 00:12:33,086
>> DAVID MALAN：三1秒。

274
00:12:33,086 --> 00:12:37,110
所以，1，1，1，因为我们只需要
4加2加1给了我7。

275
00:12:37,110 --> 00:12:37,610
好吧。

276
00:12:37,610 --> 00:12:40,410
因此，从那里我们怎么样
代表8 3占位符？

277
00:12:40,410 --> 00:12:43,310

278
00:12:43,310 --> 00:12:43,922
是啊。

279
00:12:43,922 --> 00:12:45,070
>> 学生：1，0，0，0。

280
00:12:45,070 --> 00:12:46,970
>> DAVID MALAN：是1，0，0，0。

281
00:12:46,970 --> 00:12:49,380
然而，也许，我种
技术上需要

282
00:12:49,380 --> 00:12:52,380
另一个占位符添加到董事会。

283
00:12:52,380 --> 00:12:55,480
如果我想适合我确实
需要做这样的事情。

284
00:12:55,480 --> 00:12:58,990
所以其实我现在需要使用
在8S列，这很好。

285
00:12:58,990 --> 00:13:02,680
但在计算好奇的是
这是要花费我们的东西。

286
00:13:02,680 --> 00:13:04,390
您可以在您的电脑现在需要更多的内存。

287
00:13:04,390 --> 00:13:06,348
你需要更多的内存
因为你需要的东西

288
00:13:06,348 --> 00:13:09,650
物理机到存储
另外一点，可以这么说。

289
00:13:09,650 --> 00:13:10,700
二进制数字。

290
00:13:10,700 --> 00:13:13,260
事实上所有发生的事情
这里，象十进制系统中，

291
00:13:13,260 --> 00:13:17,380
如果我们不断增加的数字上升，达到
和起来，我们去5到6到7〜8

292
00:13:17,380 --> 00:13:19,330
它就像背着1，从字面上。

293
00:13:19,330 --> 00:13:21,940
然后一切
追溯到下降到零。

294
00:13:21,940 --> 00:13:25,870
>> 但是，我们如何实际上代表
这些东西在物理计算机？

295
00:13:25,870 --> 00:13:29,380
井，在一天结束时，仅
物理输入进入我的电脑

296
00:13:29,380 --> 00:13:33,630
下面是这个电源线，所以
电力或从墙壁电子。

297
00:13:33,630 --> 00:13:36,920
所以，如何从得到的东西
物理这样的实际

298
00:13:36,920 --> 00:13:40,630
代表这样一个想法来代替。

299
00:13:40,630 --> 00:13:41,930
>> 那么，我们能做什么呢？

300
00:13:41,930 --> 00:13:45,560
我们可以认为，所有的权利，
也许，如果电力流动

301
00:13:45,560 --> 00:13:47,420
我可以储存它，抓住它。

302
00:13:47,420 --> 00:13:49,250
如果我持有
一些电力，

303
00:13:49,250 --> 00:13:51,700
这只是打算
擅自代表1。

304
00:13:51,700 --> 00:13:53,997
如果我拔插头
而且也什么都没有，

305
00:13:53,997 --> 00:13:56,330
你知道，只是将
擅自代表0。

306
00:13:56,330 --> 00:13:57,700
>> 所以，如果有什么地方有，1。

307
00:13:57,700 --> 00:13:59,280
如果什么都没有，0。

308
00:13:59,280 --> 00:14:01,420
或者你可以让这个
多一点的视觉享受。

309
00:14:01,420 --> 00:14:02,704
这里是一个0。

310
00:14:02,704 --> 00:14:05,370
没有什么有趣的持续
在我的手机的背面。

311
00:14:05,370 --> 00:14:08,690
但是，如果我让一个小
用电位流，

312
00:14:08,690 --> 00:14:11,490
即使这是一个有点光明
在这里，我的手电筒继续。

313
00:14:11,490 --> 00:14:15,840
所以我储存电荷，ERGO，
这款手机现在代表1。

314
00:14:15,840 --> 00:14:17,700
所以0 1。

315
00:14:17,700 --> 00:14:23,630
>> 因此，与1 iPhone有多高我
算上使用这种方法？

316
00:14:23,630 --> 00:14:24,490
我的意思是1。

317
00:14:24,490 --> 00:14:25,900
这还不是所有的引人注目。

318
00:14:25,900 --> 00:14:27,170
那么还有什么我们可以做什么？

319
00:14:27,170 --> 00:14:31,180
那么让我们来看看，有没有人对他们的
手机现在，我可以借用？

320
00:14:31,180 --> 00:14:33,800
任何人谁拥有手机
用手电筒内置？

321
00:14:33,800 --> 00:14:34,969
可以借我吗？

322
00:14:34,969 --> 00:14:36,010
我并不需要它解锁。

323
00:14:36,010 --> 00:14:36,510
好吧。

324
00:14:36,510 --> 00:14:37,150
谢谢。

325
00:14:37,150 --> 00:14:37,780
让我借这个。

326
00:14:37,780 --> 00:14:38,279
好吧。

327
00:14:38,279 --> 00:14:45,570
所以，如果我现在向上滚动，并在这里，
那我现在代表？

328
00:14:45,570 --> 00:14:46,070
是啊。

329
00:14:46,070 --> 00:14:49,350
所以这是一个三，因为这是在
1秒柱，这是在2秒列。

330
00:14:49,350 --> 00:14:50,480
因此，1加2是3。

331
00:14:50,480 --> 00:14:53,410
然后，如果我们试图让
真的creative--哦，谢谢你。

332
00:14:53,410 --> 00:14:54,690
非常先发制人。

333
00:14:54,690 --> 00:14:55,560
好吧。

334
00:14:55,560 --> 00:14:57,100
我现在有三个部iPhone。

335
00:14:57,100 --> 00:14:58,810
好吧。

336
00:14:58,810 --> 00:15:02,500
>> 现在this--我不会
做任何比这更进一步。

337
00:15:02,500 --> 00:15:04,380
那我现在代表？

338
00:15:04,380 --> 00:15:05,090
七人制刚。

339
00:15:05,090 --> 00:15:08,000
但我需要身体
多个存储器在这种情况下。

340
00:15:08,000 --> 00:15:08,920
但是，这一切是。

341
00:15:08,920 --> 00:15:12,870
你可以认为这是怎么回事on--的
感谢你 - 你的手机里面

342
00:15:12,870 --> 00:15:16,240
因为只是作为一个开关，是
被打开和关闭。

343
00:15:16,240 --> 00:15:18,350
>> 如果你听说过
字晶体管。

344
00:15:18,350 --> 00:15:21,312
或者，如果你听说过
营销里面说话英特尔，

345
00:15:21,312 --> 00:15:24,270
这是讲的那种硬件
这是你的电脑里面。

346
00:15:24,270 --> 00:15:26,707
英特尔的CPU做，
中央处理单元，

347
00:15:26,707 --> 00:15:28,790
这就像大脑
里面您的计算机。

348
00:15:28,790 --> 00:15:30,640
而这些CPU和
事情他们连

349
00:15:30,640 --> 00:15:32,740
有很多很多的小开​​关。

350
00:15:32,740 --> 00:15:36,440
千万，上亿的开关
这可以是打开或关闭。

351
00:15:36,440 --> 00:15:38,840
>> 于是电脑，幸运的是，
像我们的Mac和PC，

352
00:15:38,840 --> 00:15:43,830
可以指望比7或8一路走高
因为他们有这样三个以上

353
00:15:43,830 --> 00:15:44,660
或4位。

354
00:15:44,660 --> 00:15:48,140
办法比的，相当于多
我们刚刚有三个手电筒。

355
00:15:48,140 --> 00:15:52,110
但是，现在这个开始得到
颇为无趣很快。

356
00:15:52,110 --> 00:15:55,810
如果我现在想真正能够
做一些更有趣的，

357
00:15:55,810 --> 00:16:00,340
我希望能够跳
到这样的事情。

358
00:16:00,340 --> 00:16:03,604
>> 所以ASCII，它不是一个真正的有用
的缩写，但美国标准代码

359
00:16:03,604 --> 00:16:04,770
信息交换。

360
00:16:04,770 --> 00:16:07,450
这只是意味着，有些年份
以前我们人类决定，

361
00:16:07,450 --> 00:16:10,724
你知道吗，我们希望能够做到
更多的电脑不仅仅是数字。

362
00:16:10,724 --> 00:16:12,890
我们不希望他们只是
是昂贵的计算器，

363
00:16:12,890 --> 00:16:16,730
我们希望能够做的事情一样
文字处理，虽然很简单。

364
00:16:16,730 --> 00:16:20,030
后来我们有了电子邮件和其他媒体上。

365
00:16:20,030 --> 00:16:23,700
>> 这样一来，世界决定有些年头
前，根据本系统的ASCII，

366
00:16:23,700 --> 00:16:24,770
你知道吗？

367
00:16:24,770 --> 00:16:26,970
在某些类型的
程序任何时候你

368
00:16:26,970 --> 00:16:30,649
看到号码的等效
65，如比特的图案。

369
00:16:30,649 --> 00:16:32,440
而我们能做的
数学这里在黑板上。

370
00:16:32,440 --> 00:16:34,450
代表65位的格局。

371
00:16:34,450 --> 00:16:37,240
不要把它想成十进制65。

372
00:16:37,240 --> 00:16:41,620
把它看成是任意的，但
全球范围内，一直作为首都

373
00:16:41,620 --> 00:16:42,201
一个。

374
00:16:42,201 --> 00:16:43,950
再世
决定了，你知道吗？

375
00:16:43,950 --> 00:16:45,630
让我们位的另一种模式。

376
00:16:45,630 --> 00:16:47,770
如果我们曾经看到的
66号，我们只

377
00:16:47,770 --> 00:16:50,573
假定是这样的
资本B.快进至H

378
00:16:50,573 --> 00:16:55,510
而我，如果你看到72或73，即
应分别为H和I，。

379
00:16:55,510 --> 00:16:57,780
因此，只要在整个
世界上同意在此。

380
00:16:57,780 --> 00:17:01,342
所以，当你收到一封电子邮件，或
你会得到一个文件在USB记忆棒，

381
00:17:01,342 --> 00:17:03,800
或类似的东西that--时
你看到的位的模式，

382
00:17:03,800 --> 00:17:06,980
你知道，它应该是这个
信件或其他一些信件。

383
00:17:06,980 --> 00:17:08,620
>> 但它的具体情况下，正确的。

384
00:17:08,620 --> 00:17:12,250
电子邮件程序可能将
这些东西的字符，

385
00:17:12,250 --> 00:17:15,760
但图形计算器或
计算器可能代表或解释

386
00:17:15,760 --> 00:17:18,370
这些事情，当然，如字母。

387
00:17:18,370 --> 00:17:21,610
>> 因此，与中说，小巧的审查。

388
00:17:21,610 --> 00:17:25,440
这也许是一个三字符
这就是被发送给我的电子邮件。

389
00:17:25,440 --> 00:17:27,990
在底层这一切都在
0和1，但我们不在乎。

390
00:17:27,990 --> 00:17:31,580
我们将开始抽象
上面的0和1的信件。

391
00:17:31,580 --> 00:17:36,830
如果我看到0和1组成的图案
真正代表72，提示，暗示，73，

392
00:17:36,830 --> 00:17:38,866
然后33，有什么消息？

393
00:17:38,866 --> 00:17:40,348
>> 学生：[听不清]

394
00:17:40,348 --> 00:17:42,639
DAVID MALAN：所以，如果你想
回到刚才，HI

395
00:17:42,639 --> 00:17:47,210
是我试图消息
沟通在这里，因为H是72，

396
00:17:47,210 --> 00:17:50,925
我是73，现在33--你不会
事先一定知道这一点，

397
00:17:50,925 --> 00:17:53,800
但事实证明，如果你真的
看到更多的图表和系统的

398
00:17:53,800 --> 00:17:56,800
人类商定年
以前，它只是一个感叹号。

399
00:17:56,800 --> 00:18:01,590
事实上，有一种模式
符号和数字为每个字符

400
00:18:01,590 --> 00:18:03,849
你可能有你的键盘上。

401
00:18:03,849 --> 00:18:04,389
>> 好吧。

402
00:18:04,389 --> 00:18:05,660
让我们进一步抽象。

403
00:18:05,660 --> 00:18:09,380
如果我们不希望只是有
之类的数字和字母，

404
00:18:09,380 --> 00:18:11,420
实际上我们要实现的图形。

405
00:18:11,420 --> 00:18:13,351
好吧，如果你曾经
听到的缩写RGB。

406
00:18:13,351 --> 00:18:15,559
它现在那种过时，但
它仍然是一种存在。

407
00:18:15,559 --> 00:18:17,380
RGB是红，绿，蓝。

408
00:18:17,380 --> 00:18:19,380
它只是一个系统
他说，你知道吗，

409
00:18:19,380 --> 00:18:21,650
让我们用三套位。

410
00:18:21,650 --> 00:18:25,280
一组8位，另一组8
位，和另一组的8位的。

411
00:18:25,280 --> 00:18:27,710
让我们使用这些位
存储多少我们红

412
00:18:27,710 --> 00:18:31,430
希望我们的屏幕，多少对
绿色的，我们希望我们的屏幕上，

413
00:18:31,430 --> 00:18:34,070
多少蓝，我们希望我们的屏幕上。

414
00:18:34,070 --> 00:18:37,860
而这只是意味着，如果你
有lot--一个巨大的数字为红色，

415
00:18:37,860 --> 00:18:39,200
这意味着给了我很多的红色。

416
00:18:39,200 --> 00:18:41,658
如果你有一个大数目
绿色，给了我很多的绿色。

417
00:18:41,658 --> 00:18:44,660
如果你有只是一点点
的蓝色或少数像33，

418
00:18:44,660 --> 00:18:45,960
给我蓝色的一点点。

419
00:18:45,960 --> 00:18:49,720
如果你碰巧这些结合起来
3大小，可以这么说，

420
00:18:49,720 --> 00:18:53,160
你this--你几乎可以看到
这里的投影机，但这种阴暗

421
00:18:53,160 --> 00:18:54,630
黄色或棕色阴影。

422
00:18:54,630 --> 00:18:58,590
>> 但是，这是说，使用该
8 + 8 +的模式加8-

423
00:18:58,590 --> 00:19:01,710
的24比特模式
是一台电脑怎么会

424
00:19:01,710 --> 00:19:06,460
存储黄色遮阳一
小点在屏幕上的一个像素。

425
00:19:06,460 --> 00:19:10,570
所以我们从0和1为十进制不见了
号码的英文字母。

426
00:19:10,570 --> 00:19:13,680
或者更有意思，彩色圆点。

427
00:19:13,680 --> 00:19:16,200
>> 嗯，当然什么然后是下一个？

428
00:19:16,200 --> 00:19:19,040
那么，什么是一个形象，你
看到Facebook或在一封电子邮件中得到什么？

429
00:19:19,040 --> 00:19:20,172
还是怎么样？

430
00:19:20,172 --> 00:19:22,130
的定义是什么
技术上的图像？

431
00:19:22,130 --> 00:19:25,090

432
00:19:25,090 --> 00:19:27,710
是啊。

433
00:19:27,710 --> 00:19:31,270
是什么，如果你组成的图像
看起来非常接近你的屏幕？

434
00:19:31,270 --> 00:19:31,770
是啊。

435
00:19:31,770 --> 00:19:33,186
这只是一大堆像素。

436
00:19:33,186 --> 00:19:35,220
事实上，如果你把你的
笔记本电脑也许以后，

437
00:19:35,220 --> 00:19:37,180
并期待真正密切
在它 - 这取决于

438
00:19:37,180 --> 00:19:40,370
如何昂贵的笔记本电脑是和
如何高品质的画面，

439
00:19:40,370 --> 00:19:43,480
你很可能会看到所有的
屏幕上的小圆点。

440
00:19:43,480 --> 00:19:45,890
>> 而这些点或像素，
这意味着有

441
00:19:45,890 --> 00:19:49,810
表示在每个像素24位
照片，你在Facebook上看到，

442
00:19:49,810 --> 00:19:52,049
或者说你刚拍
在您的iPhone最近。

443
00:19:52,049 --> 00:19:54,090
所以这就是我们如何获得
喜欢的东西图形。

444
00:19:54,090 --> 00:19:55,120
那么，什么是视频？

445
00:19:55,120 --> 00:19:58,660
视频只是一套图形
由画面再次飞

446
00:19:58,660 --> 00:19:59,780
一次又一次。

447
00:19:59,780 --> 00:20:04,080
所以影片真的，只是图案
代表格，行位

448
00:20:04,080 --> 00:20:06,880
和点列，
通过屏幕图像飞行，

449
00:20:06,880 --> 00:20:09,240
经过图像，图像后，又名

450
00:20:09,240 --> 00:20:10,650
动作照片。

451
00:20:10,650 --> 00:20:12,340
所以这是它的输入和输出。

452
00:20:12,340 --> 00:20:14,420
>> 所有我们现在已经是一个
假设，你

453
00:20:14,420 --> 00:20:17,190
知道吗，如果我们想要一台电脑
来表示信息，

454
00:20:17,190 --> 00:20:18,560
我们有这样做的系统。

455
00:20:18,560 --> 00:20:20,780
我们可以从0做到这一点，
1秒在一天结束。

456
00:20:20,780 --> 00:20:23,160
但是，我们可以抽象，所以
可以说，最重要的是

457
00:20:23,160 --> 00:20:25,140
以便表示更
有趣的东西。

458
00:20:25,140 --> 00:20:28,790
这里就出在CS50，并在
计算机科学更普遍，

459
00:20:28,790 --> 00:20:31,250
我们现在站在肩膀上
所有的人谁

460
00:20:31,250 --> 00:20:33,530
来到了我们面前谁想通了这一点。

461
00:20:33,530 --> 00:20:38,170
而现在只是假设电脑
可以表示输入和输出。

462
00:20:38,170 --> 00:20:41,140
>> 但现在，让我们实际
做他们的东西。

463
00:20:41,140 --> 00:20:44,850
因此，一个算法只是一套
指示，一步一步，

464
00:20:44,850 --> 00:20:46,340
为解决一些问题。

465
00:20:46,340 --> 00:20:48,730
并且可能一个这样的问题是什么。

466
00:20:48,730 --> 00:20:52,440
所以这是一个老同学
技术，电话簿。

467
00:20:52,440 --> 00:20:55,534
和内部的电话簿是一个
一大堆的名称和号码。

468
00:20:55,534 --> 00:20:57,700
而这些名字一般都是
按字母顺序排序。

469
00:20:57,700 --> 00:21:01,310
>> 所以，如果我想要找人
这电话簿像迈克·史密斯，

470
00:21:01,310 --> 00:21:02,930
什么是一个典型的人怎么办呢？

471
00:21:02,930 --> 00:21:06,000
嗯，你可以只需打开
它，看第一页。

472
00:21:06,000 --> 00:21:07,390
我没有看到迈克·史密斯。

473
00:21:07,390 --> 00:21:09,740
翻到第二页，
我没有看到迈克·史密斯。

474
00:21:09,740 --> 00:21:11,830
而就一直走下去，去。

475
00:21:11,830 --> 00:21:14,397
这是一步一步的做法是否正确？

476
00:21:14,397 --> 00:21:17,380

477
00:21:17,380 --> 00:21:18,310
是啊。

478
00:21:18,310 --> 00:21:20,080
这是一种愚蠢的，对吧。

479
00:21:20,080 --> 00:21:21,646
这是低效的，正确的。

480
00:21:21,646 --> 00:21:24,520
因为它要采取永远
去迈克，但它是正确的。

481
00:21:24,520 --> 00:21:26,620
因为如果麦克是在这里
我的确会找到他的。

482
00:21:26,620 --> 00:21:29,030
>> 那么，什么是一个稍
理智的人怎么办呢？

483
00:21:29,030 --> 00:21:32,180
他们可能仍然开到前点，
并通过电话簿也许飞

484
00:21:32,180 --> 00:21:33,250
两页一次。

485
00:21:33,250 --> 00:21:34,840
二，四，六，八。

486
00:21:34,840 --> 00:21:36,830
我不能真正
身体做非常好。

487
00:21:36,830 --> 00:21:39,560
但在理论上，这应该是
快两倍，一次两页。

488
00:21:39,560 --> 00:21:41,152
这是算法是否正确？

489
00:21:41,152 --> 00:21:43,252
>> 学生：[听不清]

490
00:21:43,252 --> 00:21:44,460
DAVID MALAN：不一定。

491
00:21:44,460 --> 00:21:44,960
好。

492
00:21:44,960 --> 00:21:46,112
为什么会警告？

493
00:21:46,112 --> 00:21:50,020
>> 学生：因为他可以在一个
那你跳过页面。

494
00:21:50,020 --> 00:21:50,770
DAVID MALAN：是的。

495
00:21:50,770 --> 00:21:52,260
所以，即使我越走越近。

496
00:21:52,260 --> 00:21:56,150
如果他只是不小心，坏
运气好的话，夹在两个页面之间

497
00:21:56,150 --> 00:21:57,290
我正在飞过来？

498
00:21:57,290 --> 00:21:59,920

499
00:21:59,920 --> 00:22:01,730
因此，我们需要为这个修复。

500
00:22:01,730 --> 00:22:03,590
实际上，我们需要
然后说，等一下，

501
00:22:03,590 --> 00:22:06,240
也许，如果我们走得太远，也许
如果我们打的T形截面，

502
00:22:06,240 --> 00:22:09,670
对于T·史密斯之后来临，那么我们应该
至少两倍于至少一个页面。

503
00:22:09,670 --> 00:22:12,630
这样可固定，但有
有条件的问题在那里。

504
00:22:12,630 --> 00:22:16,159
所以这是快两倍，但你可能
必须原路折回只是一点点。

505
00:22:16,159 --> 00:22:19,200
但是，没有人在自己的房间，就算你
真的不使用电话本了，

506
00:22:19,200 --> 00:22:20,740
会在开始启动。

507
00:22:20,740 --> 00:22:23,317
你会怎样做
找迈克·史密斯？

508
00:22:23,317 --> 00:22:24,900
你会去约到S的。

509
00:22:24,900 --> 00:22:26,820
或者，如果你真的没有
纸上的小抄，

510
00:22:26,820 --> 00:22:28,365
你会至少要
大致中间。

511
00:22:28,365 --> 00:22:30,220
当然不
书的前面。

512
00:22:30,220 --> 00:22:31,130
你要往下看。

513
00:22:31,130 --> 00:22:33,770
和数学上你可能
将会看到M个部分，该部分

514
00:22:33,770 --> 00:22:34,890
大致在中间。

515
00:22:34,890 --> 00:22:36,848
然后，你要
实现的，什么是真的吗？

516
00:22:36,848 --> 00:22:37,968
哪里是迈克？

517
00:22:37,968 --> 00:22:39,170
>> 学生：[听不清]

518
00:22:39,170 --> 00:22:39,920
DAVID MALAN：是的。

519
00:22:39,920 --> 00:22:41,530
于是，他结束了在这一侧。

520
00:22:41,530 --> 00:22:42,710
所以你可以做什么？

521
00:22:42,710 --> 00:22:48,870
那么，这两个比喻和字面
你可以撕成两半的问题一次？

522
00:22:48,870 --> 00:22:54,260
然后知道，你可以扔掉
这个问题的一半的路程。

523
00:22:54,260 --> 00:22:58,170
而现在我们只剩下根本
同样的问题，但它的一半大。

524
00:22:58,170 --> 00:22:59,920
所以现在有什么
指令集？

525
00:22:59,920 --> 00:23:01,753
什么是算法
寻找迈克·史密斯？

526
00:23:01,753 --> 00:23:03,030
这是完全一样的东西。

527
00:23:03,030 --> 00:23:05,750
>> 现在，这恰好是并购
部，这是在Z部分，

528
00:23:05,750 --> 00:23:08,650
但根本
式仍然是相同的。

529
00:23:08,650 --> 00:23:10,800
去大致中间，
往下看，哦，实在可恨。

530
00:23:10,800 --> 00:23:13,160
现在我在T节，
太远了，我走了。

531
00:23:13,160 --> 00:23:16,640
但在这里也可以，你
应用该相同的逻辑。

532
00:23:16,640 --> 00:23:19,189
问题的一半扔
走，现在我们

533
00:23:19,189 --> 00:23:21,230
留下了这是一个问题
的四分之一的尺寸。

534
00:23:21,230 --> 00:23:28,140
我们可以重复的，我们可以重复，
我们可以重复，直到理论上

535
00:23:28,140 --> 00:23:32,190
这里只有一个页面上留下
该麦克要么是或不是。

536
00:23:32,190 --> 00:23:34,014
>> 那么什么是如此强大这个想法？

537
00:23:34,014 --> 00:23:35,680
我的意思是毕竟，这是非常直观的。

538
00:23:35,680 --> 00:23:37,390
没有人会在开始
开始电话簿

539
00:23:37,390 --> 00:23:39,320
和翻转1,000页找到迈克·史密斯。

540
00:23:39,320 --> 00:23:42,319
大多数人都在这个房间是怎么回事
做大致那种算法

541
00:23:42,319 --> 00:23:43,220
保存撕裂。

542
00:23:43,220 --> 00:23:45,480
>> 所以我们为什么这样做呢？

543
00:23:45,480 --> 00:23:47,810
那么，考虑效率。

544
00:23:47,810 --> 00:23:51,500
只是考虑如何更好地此
算法是由它分解

545
00:23:51,500 --> 00:23:52,890
成其组成部分。

546
00:23:52,890 --> 00:23:53,980
所以，我怎么先做？

547
00:23:53,980 --> 00:23:55,389
我拿起电话簿。

548
00:23:55,389 --> 00:23:57,180
和计算机科学家，
和程序员，

549
00:23:57,180 --> 00:24:00,090
更普遍的事实证明，是怎么回事
为从0开始计数的一切。

550
00:24:00,090 --> 00:24:00,610
>> 为什么？

551
00:24:00,610 --> 00:24:03,240
嗯，这是一个有点怪
我们人类算，一般，

552
00:24:03,240 --> 00:24:04,400
从1开始。

553
00:24:04,400 --> 00:24:08,110
因为什么是最小的数
我们可以清楚地表示基于

554
00:24:08,110 --> 00:24:09,930
即使是在我们的老小学数学吗？

555
00:24:09,930 --> 00:24:12,400
嗯，这是0，无论是
它的十进制或二进制。

556
00:24:12,400 --> 00:24:14,900
所以你会在世界上看到
计算和编程的，

557
00:24:14,900 --> 00:24:17,620
具体而言，我们开始
从0开始计数的一切。

558
00:24:17,620 --> 00:24:19,690
>> 于是我拿起电话簿一步0。

559
00:24:19,690 --> 00:24:21,924
我要开到
电话簿的中间。

560
00:24:21,924 --> 00:24:23,840
而这的确是一个
我所做的表达。

561
00:24:23,840 --> 00:24:25,900
然后第二步是看名字。

562
00:24:25,900 --> 00:24:29,110
第三步是一个小
不同的概念。

563
00:24:29,110 --> 00:24:30,600
我问自己一个问题。

564
00:24:30,600 --> 00:24:33,610
如果史密斯是名中，
我将做出决定。

565
00:24:33,610 --> 00:24:36,550
如果他的名字之一，
然后我会打电话给迈克。

566
00:24:36,550 --> 00:24:39,590
而且我会做出决定
根据该资料片。

567
00:24:39,590 --> 00:24:44,100
>> 然而，如果不是，如果史密斯
早先在书的左侧，

568
00:24:44,100 --> 00:24:48,200
我要开到中间
的书的左半部。

569
00:24:48,200 --> 00:24:51,674
然后这里的聪明，
我要回去第二步。

570
00:24:51,674 --> 00:24:53,590
我要去的排序
站在我自己的肩膀

571
00:24:53,590 --> 00:24:55,110
而只是重复过去的工作，我做到了。

572
00:24:55,110 --> 00:24:58,062
但是，我已经离开了工作
以下，更小，和更小。

573
00:24:58,062 --> 00:24:59,270
但它仍然去上班。

574
00:24:59,270 --> 00:25:02,110
但是，如果迈克，反而是后来
在书的权利，

575
00:25:02,110 --> 00:25:04,980
我要开到中间
书的右半部，

576
00:25:04,980 --> 00:25:07,240
然后回到第二步。

577
00:25:07,240 --> 00:25:09,330
>> 但其实还有第四个场景。

578
00:25:09,330 --> 00:25:13,336
迈克的任一位置，
或在此，或在此，or--

579
00:25:13,336 --> 00:25:14,152
>> 学生：不存在。

580
00:25:14,152 --> 00:25:15,110
DAVID MALAN：不存在。

581
00:25:15,110 --> 00:25:18,580
事实上，如果我们不预期
这第四个和最后一个场景

582
00:25:18,580 --> 00:25:21,510
我们的节目可能是越野车
或以某种方式存在缺陷。

583
00:25:21,510 --> 00:25:25,020
否则，退出的情况下
我们还没有发现麦克的。

584
00:25:25,020 --> 00:25:27,720
事实上，如果你曾经注意到
你的电脑挂，或所有

585
00:25:27,720 --> 00:25:30,490
突然字或某些其它的
节目刚刚意外退出，

586
00:25:30,490 --> 00:25:32,614
有时你的错误
消息是从字面上说。

587
00:25:32,614 --> 00:25:34,070
该程序意外退出。

588
00:25:34,070 --> 00:25:35,570
它可以是任何数量的原因。

589
00:25:35,570 --> 00:25:38,120
但有时它的
事情如此简单。

590
00:25:38,120 --> 00:25:40,440
人类的程序员
谁写的软件

591
00:25:40,440 --> 00:25:43,610
没有意识到，哦，还有一个
第四件事，实际上可以发生。

592
00:25:43,610 --> 00:25:46,480
如果你不写代码
捕捉第四种情况，

593
00:25:46,480 --> 00:25:51,342
这的确是意外有时
什么电脑实际上可能做到。

594
00:25:51,342 --> 00:25:53,050
现在让我们请出了
一些这些东西。

595
00:25:53,050 --> 00:25:55,465
因此，在黄色这里，我
突出条款

596
00:25:55,465 --> 00:25:57,590
从今以后，我们只是
要调用的函数。

597
00:25:57,590 --> 00:26:00,700
在世界功能
编程就像动作，

598
00:26:00,700 --> 00:26:01,850
对措施的说明。

599
00:26:01,850 --> 00:26:05,720
所以回暖，开放的，看
在，打电话，开，开，退出。

600
00:26:05,720 --> 00:26:09,350
这是一个函数，程序，
一个动作，任何数量的同义词

601
00:26:09,350 --> 00:26:10,184
也行。

602
00:26:10,184 --> 00:26:11,850
现在什么黄色现在这些东西？

603
00:26:11,850 --> 00:26:14,210
如果其他人，如果别的，如果
否则，这些是什么

604
00:26:14,210 --> 00:26:16,500
我们要呼吁
在规划的条件下，

605
00:26:16,500 --> 00:26:19,270
或分公司，决策
指出，如果你愿意。

606
00:26:19,270 --> 00:26:22,759
但是，你怎么知道哪个叉
在路上拿，可以这么说？

607
00:26:22,759 --> 00:26:24,550
我们需要强调
术语向右

608
00:26:24,550 --> 00:26:27,570
还有，这是这些
是的，没有什么问题。

609
00:26:27,570 --> 00:26:29,040
这些真实的假问题。

610
00:26:29,040 --> 00:26:30,880
名中史密斯？

611
00:26:30,880 --> 00:26:32,190
史密斯此前在书吗？

612
00:26:32,190 --> 00:26:33,260
史密斯后来在书吗？

613
00:26:33,260 --> 00:26:35,490
这些都是问题
其中有一个是或否，

614
00:26:35,490 --> 00:26:42,110
或者等价真的，还是假的，或
等价地，一或零的答案。

615
00:26:42,110 --> 00:26:44,260
>> 而与此同时有
只是一个最后一块。

616
00:26:44,260 --> 00:26:45,940
这在这里有什么样的效果？

617
00:26:45,940 --> 00:26:48,230
不管是不是你的程序
之前，你会如何

618
00:26:48,230 --> 00:26:51,030
描述一下步
七10在做什么？

619
00:26:51,030 --> 00:26:54,110

620
00:26:54,110 --> 00:26:55,027
你说什么？

621
00:26:55,027 --> 00:26:56,110
学生：一个递归步骤。

622
00:26:56,110 --> 00:26:56,980
DAVID MALAN：递归的一步。

623
00:26:56,980 --> 00:26:58,000
是的，本质上。

624
00:26:58,000 --> 00:27:00,384
这是技术上反复
在这里，如果你熟悉的。

625
00:27:00,384 --> 00:27:01,550
但是，我们会回来这一点。

626
00:27:01,550 --> 00:27:03,930
但它清楚地做一些事情。

627
00:27:03,930 --> 00:27:06,370
再次，它的诱导
循环，一个循环，正确的。

628
00:27:06,370 --> 00:27:08,770
你从字面上去
回一些早期的一步。

629
00:27:08,770 --> 00:27:12,592
所以事实上，这是怎么回事
执行某种循环。

630
00:27:12,592 --> 00:27:15,050
但你不会得到
卡在这不休，正确的。

631
00:27:15,050 --> 00:27:19,290
因为如果你经常检查是
麦克此处，或向左，或不在这里，

632
00:27:19,290 --> 00:27:21,360
最终，他不会在那里。

633
00:27:21,360 --> 00:27:24,590
而且你可以完全退出
根据最后一行。

634
00:27:24,590 --> 00:27:25,834
>> 所以这是它的词汇。

635
00:27:25,834 --> 00:27:28,250
这就是我们会
一般称之为伪代码。

636
00:27:28,250 --> 00:27:29,570
这不是一个实际的语言。

637
00:27:29,570 --> 00:27:32,405
这只是很简短的英文，
但它通信的点。

638
00:27:32,405 --> 00:27:33,780
这里没有正式的结构。

639
00:27:33,780 --> 00:27:35,738
你只需要使用它的几
话，但清晰的话

640
00:27:35,738 --> 00:27:37,870
因为你可以传达你的想法。

641
00:27:37,870 --> 00:27:40,580
>> 现在怎么好是算法
是多少比较好？

642
00:27:40,580 --> 00:27:43,570
好了，我们不必进入
数字或任何具体的

643
00:27:43,570 --> 00:27:44,069
像那样。

644
00:27:44,069 --> 00:27:46,300
但是，我们可以看看
塑造这个解决方案。

645
00:27:46,300 --> 00:27:50,194
所以，如果我们只是得到一些XY坐标图
这里这里横轴。

646
00:27:50,194 --> 00:27:51,860
我们只需要调用这个问题的规模。

647
00:27:51,860 --> 00:27:55,540
和一个计算机科学家会
通常使用n作为这里的变量。

648
00:27:55,540 --> 00:27:59,690
所以n页，或n人在房间里，或
不管它是你想计数。

649
00:27:59,690 --> 00:28:03,039
>> 然后上的垂直轴
离开，这将是解决的时候。

650
00:28:03,039 --> 00:28:05,330
那么有多少秒做它
带我找迈克·史密斯？

651
00:28:05,330 --> 00:28:06,621
或多少步没有考虑？

652
00:28:06,621 --> 00:28:08,100
多少翻页没有考虑？

653
00:28:08,100 --> 00:28:11,370
所以，这要花多少钱
我的时间来解决问题。

654
00:28:11,370 --> 00:28:15,030
我们可以绘制的第一个
算法坡，如果你愿意，

655
00:28:15,030 --> 00:28:16,910
在红色仅此一条直线。

656
00:28:16,910 --> 00:28:18,450
我会N通话了。

657
00:28:18,450 --> 00:28:19,117
>> 为什么N'

658
00:28:19,117 --> 00:28:20,950
为什么是仅此一
一个关系？

659
00:28:20,950 --> 00:28:22,700
那么，如果Verizon公司或
无论电话公司

660
00:28:22,700 --> 00:28:25,130
增添了一分页面，
电话簿明年

661
00:28:25,130 --> 00:28:28,370
这可能会推迈克·1
更一步接近年底，

662
00:28:28,370 --> 00:28:29,950
不同的地方是页面。

663
00:28:29,950 --> 00:28:32,380
这样一来，效果可能只是
是增加一个第二。

664
00:28:32,380 --> 00:28:33,520
或者一个更翻页。

665
00:28:33,520 --> 00:28:34,970
一个一比一的比例。

666
00:28:34,970 --> 00:28:37,410
>> 相比之下，第二算法。

667
00:28:37,410 --> 00:28:41,406
如何更快的是直觉？

668
00:28:41,406 --> 00:28:42,780
我在哪里去了一次两页？

669
00:28:42,780 --> 00:28:43,664
是啊。

670
00:28:43,664 --> 00:28:44,497
>> 学生：[听不清]

671
00:28:44,497 --> 00:28:47,255

672
00:28:47,255 --> 00:28:48,080
>> DAVID MALAN：是的。

673
00:28:48,080 --> 00:28:49,220
所以，这将是快两倍。

674
00:28:49,220 --> 00:28:51,344
我们将利用在这里
取决于规模。

675
00:28:51,344 --> 00:28:54,220
它仍然是一条直线，
但比红线低。

676
00:28:54,220 --> 00:28:56,410
因为对于一些数
的页，如果花费

677
00:28:56,410 --> 00:28:58,360
你这许多步骤，
第一算法，

678
00:28:58,360 --> 00:29:00,570
它会带你一半
许多步骤与第二。

679
00:29:00,570 --> 00:29:02,770
这样一来，黄线
描述第二算法

680
00:29:02,770 --> 00:29:03,990
只是要低于它。

681
00:29:03,990 --> 00:29:07,250
>> 但是，什么是真正强大的是
想想第三和最后，

682
00:29:07,250 --> 00:29:10,480
而令人惊奇的最直观
算法，具有此形状。

683
00:29:10,480 --> 00:29:12,720
从技术上讲，我们会打电话
此对数曲线。

684
00:29:12,720 --> 00:29:14,309
在这种情况下登录的n基座2。

685
00:29:14,309 --> 00:29:15,600
但是，这并不重要。

686
00:29:15,600 --> 00:29:19,140
什么事情真的是根本
不同的形状，它有。

687
00:29:19,140 --> 00:29:22,810
你可以考虑是如何
更短的这条线真的

688
00:29:22,810 --> 00:29:24,620
是长远之计。

689
00:29:24,620 --> 00:29:25,870
它的不断增加。

690
00:29:25,870 --> 00:29:27,620
它不会变平完美。

691
00:29:27,620 --> 00:29:34,030
但它更慢以往长得多
因为这个问题变得越来越大。

692
00:29:34,030 --> 00:29:36,710
你可以把它想象这
如果方式 -  Verizon的不只是

693
00:29:36,710 --> 00:29:40,410
添加一个页面明年，但双打
的电话簿中的页数，

694
00:29:40,410 --> 00:29:42,740
第一种算法可能
需要两倍多的步骤。

695
00:29:42,740 --> 00:29:45,360
如果是1000这个页面
今年2000明年页面，

696
00:29:45,360 --> 00:29:47,180
迈克可能是要远得多。

697
00:29:47,180 --> 00:29:49,380
所以这是1000额外的步骤来找到他。

698
00:29:49,380 --> 00:29:51,610
第二算法
可能只有500多

699
00:29:51,610 --> 00:29:55,490
步骤，因为再次找到他，
我通过它每次两个飞行。

700
00:29:55,490 --> 00:29:56,950
>> 但是关于第三个算法呢？

701
00:29:56,950 --> 00:29:59,010
如果Verizon的两倍
电话簿的大小

702
00:29:59,010 --> 00:30:02,620
明年从1000到2000年
页，多少更多的步骤

703
00:30:02,620 --> 00:30:05,540
我的第三个算法将采取？

704
00:30:05,540 --> 00:30:06,630
是的，这只是一个。

705
00:30:06,630 --> 00:30:08,600
这就是强大的主意。

706
00:30:08,600 --> 00:30:12,780
你可以把1000页咬
指出问题的一次。

707
00:30:12,780 --> 00:30:14,510
现在，如果你考虑
一个愚蠢的情况下，

708
00:30:14,510 --> 00:30:17,320
但那种说话的
这种intuition--的力量

709
00:30:17,320 --> 00:30:21,494
如果电话簿了，像四十亿
页面，感觉就像一个真正的大问题。

710
00:30:21,494 --> 00:30:23,410
事实上，它可能
拿我四张十亿页

711
00:30:23,410 --> 00:30:26,549
周折找到迈克·史密斯在
情况下与所述第一算法。

712
00:30:26,549 --> 00:30:28,840
但是，有多少步骤将它
参加第三算法

713
00:30:28,840 --> 00:30:31,585
找到迈克四位，
十亿纸片？

714
00:30:31,585 --> 00:30:34,865

715
00:30:34,865 --> 00:30:36,240
于是四十亿你撕成两半。

716
00:30:36,240 --> 00:30:37,220
你得到两个十亿。

717
00:30:37,220 --> 00:30:42,810
后来有十亿，那么500万元，
2.5亿美元，125 million--但

718
00:30:42,810 --> 00:30:44,780
感觉这是
将需要一段时间。

719
00:30:44,780 --> 00:30:47,340
我可能需要32的手指
以计数那么高。

720
00:30:47,340 --> 00:30:51,340
但它确实为
少至32页的眼泪。

721
00:30:51,340 --> 00:30:54,060
您可以从四个去
十亿一个页面划分

722
00:30:54,060 --> 00:30:57,030
原数
在页半32倍

723
00:30:57,030 --> 00:30:59,290
直到你留下了
只是单页。

724
00:30:59,290 --> 00:31:01,320
>> 现在，当然，我在这里作弊。

725
00:31:01,320 --> 00:31:06,470
这并不是说，我们只是被排序
完全与前两个愚蠢的

726
00:31:06,470 --> 00:31:07,470
算法。

727
00:31:07,470 --> 00:31:11,500
我作弊在某种意义上，或
真的，我利用一个假设。

728
00:31:11,500 --> 00:31:15,610
什么是关于电话本真
在其最初的形式是允许

729
00:31:15,610 --> 00:31:17,450
我甚至使用第三算法？

730
00:31:17,450 --> 00:31:18,110
是吗？

731
00:31:18,110 --> 00:31:19,360
听众：它是按字母顺序排列。

732
00:31:19,360 --> 00:31:21,130
DAVID MALAN：它是按字母顺序排列，对不对？

733
00:31:21,130 --> 00:31:23,500
如果只是随机
秩序，这是一种浪费

734
00:31:23,500 --> 00:31:24,880
的时候，这整个谈话。

735
00:31:24,880 --> 00:31:27,500
我要看看每
如果是按随机顺序页面

736
00:31:27,500 --> 00:31:30,350
我以前找迈克·史密斯
可以断定他的存在与否。

737
00:31:30,350 --> 00:31:32,880
这样一来，我们的角落
削减的是，我有

738
00:31:32,880 --> 00:31:35,752
假设有人在别人
这种情况下所做的工作对我来说。

739
00:31:35,752 --> 00:31:38,460
因此，最终邀请
这个问题，好，等一会儿。

740
00:31:38,460 --> 00:31:41,284
你如何排序1000
姓名和号码的页面？

741
00:31:41,284 --> 00:31:43,200
这实际上是一个不同的
问题，东西

742
00:31:43,200 --> 00:31:44,574
我们会回来的未来。

743
00:31:44,574 --> 00:31:48,130
但是，当你想想网站
像Facebook和谷歌Gmail的

744
00:31:48,130 --> 00:31:50,450
事情就是这样谷歌的
自己的搜索索引，

745
00:31:50,450 --> 00:31:53,800
当你拥有数百万或数十亿
数据块存储这些天，

746
00:31:53,800 --> 00:31:56,660
sea​​rching--别说
排序那些problems--

747
00:31:56,660 --> 00:31:59,450
最终本身就是一个挑战。

748
00:31:59,450 --> 00:32:02,250
事实上，这便是
只是那些挑战之一

749
00:32:02,250 --> 00:32:03,460
我们会关注。

750
00:32:03,460 --> 00:32:05,590
>> 现在让我们花点时间
而看一看CS50

751
00:32:05,590 --> 00:32:09,082
本身并给你的感觉
什么是在商店这个学期。

752
00:32:09,082 --> 00:32:11,540
事实上，如果你还没有，
你看看这个网址。

753
00:32:11,540 --> 00:32:13,880
正如帕特里克暗示
到，今年我们

754
00:32:13,880 --> 00:32:17,130
作出显著全部投资
在使用过程中的支持越多

755
00:32:17,130 --> 00:32:20,170
结构中的TA的条款
和CAS，办公时间，

756
00:32:20,170 --> 00:32:23,520
部分可用性和
数字资料在网上，也是如此。

757
00:32:23,520 --> 00:32:27,489
确实，在使用过程中的计
讲座中，我们今天在这里。

758
00:32:27,489 --> 00:32:29,780
而这种预期
今年正式课程

759
00:32:29,780 --> 00:32:32,370
都参加到今天，课程的
最后一节课，和课程

760
00:32:32,370 --> 00:32:35,161
大约在学期中间
每讲座之间

761
00:32:35,161 --> 00:32:37,280
可用一般
在星期五下午

762
00:32:37,280 --> 00:32:40,240
在网上，无论是耶鲁的学生
今年哈佛学生。

763
00:32:40,240 --> 00:32:42,090
事实上，所述一个
根本的变化是

764
00:32:42,090 --> 00:32:44,310
我们正在采取在
哈佛大学的一个范例非常

765
00:32:44,310 --> 00:32:46,570
像我们在这里做最后的
和今年至今，

766
00:32:46,570 --> 00:32:50,300
这样同样，我们还是电影最
课程在剑桥大学演讲

767
00:32:50,300 --> 00:32:52,900
但让他们更早提供
比我们在过去

768
00:32:52,900 --> 00:32:55,540
使那些你 - 如果你
想，例如，

769
00:32:55,540 --> 00:32:58,400
得到的材料先拔头筹
在第一个周末，而

770
00:32:58,400 --> 00:33:02,000
比第二个周末，你将有
获得这些类型的材料，

771
00:33:02,000 --> 00:33:06,561
可搜索，可嵌入，hyperlinkable
到相关资源的所有早期。

772
00:33:06,561 --> 00:33:09,560
在主题方面，给你
课程的trajectory--感

773
00:33:09,560 --> 00:33:12,365
而一些这可能是行话
现在，但时间不长，放心。

774
00:33:12,365 --> 00:33:15,010
我们会从今天开始，最终，
有在看一个编程

775
00:33:15,010 --> 00:33:16,260
语言称为划痕。

776
00:33:16,260 --> 00:33:19,380
我们将随后过渡
下周的东西称为C

777
00:33:19,380 --> 00:33:22,140
然后看着其他建筑
解决问题的块，

778
00:33:22,140 --> 00:33:26,230
事情称为阵列和算法，
我们如何使用内存来我们的优势

779
00:33:26,230 --> 00:33:28,326
和劣势，以及
之类的东西的数据结构，

780
00:33:28,326 --> 00:33:31,200
然后朝的尾端
一流的看着机器学习

781
00:33:31,200 --> 00:33:33,410
看着另一
语言Python的叫，

782
00:33:33,410 --> 00:33:37,460
网络是如何工作的，怎么上网更
一般的作品，协议如HTTP，

783
00:33:37,460 --> 00:33:40,950
像数据库语言
SQL，JavaScript进行网页，

784
00:33:40,950 --> 00:33:43,000
并最终追平
所有这些在一起。

785
00:33:43,000 --> 00:33:44,708
>> 因此实际上，在
一天结束时，你

786
00:33:44,708 --> 00:33:50,250
在这个类划痕不会学
或C或Python或SQL或JavaScript。

787
00:33:50,250 --> 00:33:53,560
实际上，您将更加普遍学习
计算机科学与基础

788
00:33:53,560 --> 00:33:55,790
它们，会让你
学习如何编程

789
00:33:55,790 --> 00:33:58,800
在任何数量的这些
沿途的语言。

790
00:33:58,800 --> 00:34:00,970
因此，我们确实，目标之一
到底课程

791
00:34:00,970 --> 00:34:04,160
是采取了所有课程的中
训练车轮被那些最后几个星期

792
00:34:04,160 --> 00:34:06,710
所以在这之后，你可以
回到自己的fields--

793
00:34:06,710 --> 00:34:08,510
这是否是或
没有计算机科学

794
00:34:08,510 --> 00:34:12,290
或工程，在自然
科学，艺术，人文，或beyond--

795
00:34:12,290 --> 00:34:14,720
并把一些本
当然的想法和这个领域的

796
00:34:14,720 --> 00:34:17,400
理念和实践
技能你自己的域名

797
00:34:17,400 --> 00:34:19,480
为了解决在其中的问题。

798
00:34:19,480 --> 00:34:22,990
>> 我们会在这里做的同时
在今天之后最星期四

799
00:34:22,990 --> 00:34:26,160
与课程的负责人领先
我们就这么叫演练

800
00:34:26,160 --> 00:34:27,620
的过程中的习题集。

801
00:34:27,620 --> 00:34:29,610
因此，每个星期，当我们
有一个问题集，我们会

802
00:34:29,610 --> 00:34:32,900
在某个地址中穿行
这样的过程中所面临的挑战，

803
00:34:32,900 --> 00:34:35,582
为您提供一些提示和
技巧和设计技术。

804
00:34:35,582 --> 00:34:37,540
但是，如果你不能
使那些亲临现场，

805
00:34:37,540 --> 00:34:39,760
实现这些相同
资源将嵌入

806
00:34:39,760 --> 00:34:41,590
由课程的之一
助教

807
00:34:41,590 --> 00:34:43,860
在这个问题集本身，也是如此。

808
00:34:43,860 --> 00:34:47,124
>> 这个问题在今年集，不像
去年，根据反馈，

809
00:34:47,124 --> 00:34:48,540
仍然会在周五公布。

810
00:34:48,540 --> 00:34:51,310
但是，而不是因
随后的周五，

811
00:34:51,310 --> 00:34:55,079
从而使你只有七天
将有效是由于10天后。

812
00:34:55,079 --> 00:34:57,620
事实上，这将意味着
他们会用一个周末重叠。

813
00:34:57,620 --> 00:34:59,369
但是，我们希望今年
尤其是这会

814
00:34:59,369 --> 00:35:02,320
让学生更好地适应
低潮和在他们的日程安排流程，

815
00:35:02,320 --> 00:35:05,040
无论是学者还是
课外活动或体育

816
00:35:05,040 --> 00:35:06,280
或中期的季节。

817
00:35:06,280 --> 00:35:10,060
您可以前载或背面负载
根据您一周重点CS50

818
00:35:10,060 --> 00:35:12,400
对自己本周的实际课业负担。

819
00:35:12,400 --> 00:35:14,990
>> 这个问题本身设置
将涵盖一系列的语言，

820
00:35:14,990 --> 00:35:17,990
虽然我们将重点
主要是早期基于C

821
00:35:17,990 --> 00:35:23,040
之前，我们以后关注更高
的水平，更多的以网络为中心的语言。

822
00:35:23,040 --> 00:35:25,970
然后几个常见问题的这里 -
你应该像CS50类

823
00:35:25,970 --> 00:35:26,900
作为第一年的？

824
00:35:26,900 --> 00:35:27,970
所以绝对。

825
00:35:27,970 --> 00:35:30,470
事实上，这不是
必然的东西

826
00:35:30,470 --> 00:35:34,440
你应该推迟，直到你砍
你对其他类型的类牙齿。

827
00:35:34,440 --> 00:35:36,290
而是考虑
对于很多学生来说，

828
00:35:36,290 --> 00:35:39,040
包括我自己早在一天，
这是一个非常不熟悉的领域，

829
00:35:39,040 --> 00:35:40,997
特别是如果你
从来没有采取AP CSA

830
00:35:40,997 --> 00:35:42,580
或者类似的东西在高中。

831
00:35:42,580 --> 00:35:44,705
但要意识到早期，
无论是这门课程

832
00:35:44,705 --> 00:35:47,900
或其他一些入门课程，
现在确实是最好的时候，

833
00:35:47,900 --> 00:35:52,082
我想，找一些新的路径或
一些新的学术兴趣，以及。

834
00:35:52,082 --> 00:35:55,040
再与其他courses--服用
因此，这里的主要区别之一

835
00:35:55,040 --> 00:35:57,906
与哈佛，只有我们
每学期四门课程

836
00:35:57,906 --> 00:35:59,030
在哈佛的某些原因。

837
00:35:59,030 --> 00:36:01,494
而你们居然拉
关共约36场

838
00:36:01,494 --> 00:36:04,410
在你四年的过程中，
这通常是指四个或五个

839
00:36:04,410 --> 00:36:05,040
类。

840
00:36:05,040 --> 00:36:08,367
而且我认为这是相当公平地说，
并放弃CS50，在设计上，是

841
00:36:08,367 --> 00:36:10,700
可能不是类的类型
你通常应该

842
00:36:10,700 --> 00:36:13,680
采取与其他四个
课程一共有五个

843
00:36:13,680 --> 00:36:16,249
因为pset中被
设计相当密集。

844
00:36:16,249 --> 00:36:18,040
事实上，我也学会了
这在当天返回。

845
00:36:18,040 --> 00:36:21,110
我不会形容CS50和
计算机科学，程序设计

846
00:36:21,110 --> 00:36:24,477
因为有太多很难，因为它
仅仅是费时。

847
00:36:24,477 --> 00:36:26,560
它不是那种东西
其中，晚餐后，你

848
00:36:26,560 --> 00:36:28,310
可以回到你的宿舍
房间，坐下，并开始

849
00:36:28,310 --> 00:36:29,710
专注于处理器集
想着，没事的，

850
00:36:29,710 --> 00:36:31,340
我要爆炸了这一点
今晚再招

851
00:36:31,340 --> 00:36:33,000
在我的下一个问题的第二天。

852
00:36:33,000 --> 00:36:34,450
有时你只是碰了壁。

853
00:36:34,450 --> 00:36:35,690
你在你的代码中的错误。

854
00:36:35,690 --> 00:36:37,900
你不一定知道
如何解决某些问题。

855
00:36:37,900 --> 00:36:41,670
和的一个主要特点
编程为自己这一天

856
00:36:41,670 --> 00:36:44,480
是您刚才那种需要采取
退一步有时，睡在上面

857
00:36:44,480 --> 00:36:47,870
还是觉得它在路线
慢跑或其他一些活动，

858
00:36:47,870 --> 00:36:49,240
然后回来新鲜。

859
00:36:49,240 --> 00:36:50,930
而你只是需要时间这些窗口。

860
00:36:50,930 --> 00:36:52,910
>> 事实上，这就是为什么我们
加长的时间量

861
00:36:52,910 --> 00:36:55,710
可用于问题集
今年也是，每那个URL

862
00:36:55,710 --> 00:36:57,950
我把先前为
有什么新的这个学期，

863
00:36:57,950 --> 00:37:00,950
修剪的习题集，使
他们根本没有那么严格，

864
00:37:00,950 --> 00:37:03,741
和外卖店也毫不逊色，但
有少了很多正面的事情，

865
00:37:03,741 --> 00:37:07,630
你需要一个少很多跑腿
在做每一个问题集的面前，

866
00:37:07,630 --> 00:37:10,680
如你所见，你才可以
实际上潜入它的肉。

867
00:37:10,680 --> 00:37:13,500
因此，认识到这些问题和其他
变化是在地平线上

868
00:37:13,500 --> 00:37:16,490
为更好地适应学生，
但最终，以确保

869
00:37:16,490 --> 00:37:18,860
该外卖店
的确尽可能高。

870
00:37:18,860 --> 00:37:21,330
因此，尽管比它更多的工作
可能是在一个典型的类，

871
00:37:21,330 --> 00:37:25,120
我们也希望回报
你和你的外卖

872
00:37:25,120 --> 00:37:27,490
而技能和思想
与退出

873
00:37:27,490 --> 00:37:29,921
如结果更加引人注目。

874
00:37:29,921 --> 00:37:32,420
并让你那里 - 这
是关键外卖店之一，

875
00:37:32,420 --> 00:37:35,470
帕特里克先前已经提到的
课程的支撑结构。

876
00:37:35,470 --> 00:37:39,720
所以不仅CS50具有之一
全校最大的当然员工。

877
00:37:39,720 --> 00:37:41,750
它也有一
大多数本科生。

878
00:37:41,750 --> 00:37:43,700
事实上，CS50去年
是一流的

879
00:37:43,700 --> 00:37:45,366
有一个本科教学人员。

880
00:37:45,366 --> 00:37:48,570
并证明了这一成功现在要做的
耶鲁CS中的许多其他课程

881
00:37:48,570 --> 00:37:49,500
有，也是如此。

882
00:37:49,500 --> 00:37:52,906
而对于学生，具体而言，
将这些助教，当然助理

883
00:37:52,906 --> 00:37:55,030
是支持一个整体
支持的人脉资源，

884
00:37:55,030 --> 00:37:58,250
这些部门之间或
朗诵，每周机会

885
00:37:58,250 --> 00:38:01,674
有更亲密的讨论
和材料的审查针对性

886
00:38:01,674 --> 00:38:04,590
对于不同的轨道，为学生
不太舒服，更舒适，

887
00:38:04,590 --> 00:38:05,720
或者介于两者之间。

888
00:38:05,720 --> 00:38:08,886
这些将遵循的可用性
讲座由每个每周都有几天

889
00:38:08,886 --> 00:38:09,970
在星期一和星期二。

890
00:38:09,970 --> 00:38:11,970
然后办公室hours--
单对单的机会

891
00:38:11,970 --> 00:38:15,490
从课程CA和助教的帮助
将在周三和周四

892
00:38:15,490 --> 00:38:18,400
并在多个周日
倍，所有这些都

893
00:38:18,400 --> 00:38:22,180
将在课程的网站上公布，
比去年还要多，也是如此。

894
00:38:22,180 --> 00:38:25,501
>> 但是，什么是关键CS50，如果
不是诚然有点不寻常，

895
00:38:25,501 --> 00:38:27,750
是当然的文化
我们试图培养，

896
00:38:27,750 --> 00:38:30,672
无论在剑桥多年
现在最近在纽黑文。

897
00:38:30,672 --> 00:38:33,130
而事实上，走到这
周六，如果你还没有听说过，

898
00:38:33,130 --> 00:38:36,410
是CS50益智日，其中有
无关计算机科学

899
00:38:36,410 --> 00:38:39,430
但设计完全发
一条消息，计算机科学

900
00:38:39,430 --> 00:38:40,665
有关问题的解决。

901
00:38:40,665 --> 00:38:43,540
事实上，如果你想合作伙伴
与一个或​​两个或三个朋友

902
00:38:43,540 --> 00:38:46,150
并形成一个团队，为CS50
益智日，一起来看看

903
00:38:46,150 --> 00:38:48,010
在那些对出路的广告。

904
00:38:48,010 --> 00:38:51,582
三个小时的比萨饼和
困惑和奖品等待着。

905
00:38:51,582 --> 00:38:53,290
事实上，对于
今年第一次，

906
00:38:53,290 --> 00:38:54,873
它不会与哈佛大学联合举办。

907
00:38:54,873 --> 00:38:57,530
这将独立地在耶鲁。

908
00:38:57,530 --> 00:38:59,815
因此，保持留意
这些如果你还没有。

909
00:38:59,815 --> 00:39:02,440
几乎每个周五在学期
我们试图让一个大班里

910
00:39:02,440 --> 00:39:06,710
感到自己的渺小和带来一些50名学生
同场的工作人员的午餐，

911
00:39:06,710 --> 00:39:08,730
与校友，朋友
从行业讲

912
00:39:08,730 --> 00:39:12,630
关于什么生活就像一后
像类和CS50在夏天

913
00:39:12,630 --> 00:39:14,250
毕业后。

914
00:39:14,250 --> 00:39:16,280
因此，保持留意
邀请了这一点。

915
00:39:16,280 --> 00:39:17,988
首次
以往，今年我们将

916
00:39:17,988 --> 00:39:21,420
举办​​首届CS50编码
比赛中，可选的选入的机会

917
00:39:21,420 --> 00:39:25,580
期中，毕竟我们有过
一些六，七个星期编程

918
00:39:25,580 --> 00:39:30,100
下裤头C到竞争，
如果你这样会再次choose--

919
00:39:30,100 --> 00:39:32,460
在teams--试图
作为解决诸多挑战

920
00:39:32,460 --> 00:39:36,160
你可以在编程
侵害他人你们的朋友。

921
00:39:36,160 --> 00:39:38,850
>> 朝学期的尾巴
我们将一些包租公交车，

922
00:39:38,850 --> 00:39:40,850
实际上花费一些时间
在剑桥，如果你愿意

923
00:39:40,850 --> 00:39:43,460
想加入我们，为
所谓CS50编程马拉松。

924
00:39:43,460 --> 00:39:44,600
晚上7点，我们将开始。

925
00:39:44,600 --> 00:39:45,970
晚上9点左右，我们将有比萨饼。

926
00:39:45,970 --> 00:39:47,650
大约凌晨1:00，我们将有卷饼。

927
00:39:47,650 --> 00:39:50,550
任何人都还醒着的
乘坐巴士回家周围5:00，

928
00:39:50,550 --> 00:39:54,070
我们将停止关闭煎饼
在IHOP的方式home--

929
00:39:54,070 --> 00:39:57,540
12小时的机会沉浸
自己与同学和工作人员

930
00:39:57,540 --> 00:39:59,950
在使用过程中的最后一个项目，
这是一个机会

931
00:39:59,950 --> 00:40:01,870
远远超越了
当然的问题集

932
00:40:01,870 --> 00:40:05,950
设计和实施最
您感兴趣的话，

933
00:40:05,950 --> 00:40:09,170
这最终将
这里展示的下议院。

934
00:40:09,170 --> 00:40:12,510
有史以来第一次CS50公平的最后
今年，一个结束学期的展览

935
00:40:12,510 --> 00:40:15,460
什么大家或庆祝
在类已经完成，

936
00:40:15,460 --> 00:40:19,810
尤其是，再次，从谁去
从无到有，从零到60，

937
00:40:19,810 --> 00:40:22,450
有没有事先背景
和展示，最终，

938
00:40:22,450 --> 00:40:26,960
东西为整个校园，
如果在网上，让全世界都看到，以及。

939
00:40:26,960 --> 00:40:30,780
>> 现在，这些人，只是少数的
助教中科院，使CS50可能。

940
00:40:30,780 --> 00:40:33,034
请允许我邀请任何
这些工作人员

941
00:40:33,034 --> 00:40:35,700
谁在这里来在舞台上，
以及课程的负责人，

942
00:40:35,700 --> 00:40:38,785
提供的一些话
灵感，也是如此。

943
00:40:38,785 --> 00:41:03,138

944
00:41:03,138 --> 00:41:03,950
>> ANDI：嗨，伙计们。

945
00:41:03,950 --> 00:41:05,290
你们能听到我吗？

946
00:41:05,290 --> 00:41:10,260
感谢您对这个加入我们的行列
可爱，阴雨周四下午。

947
00:41:10,260 --> 00:41:11,010
我的名字是安迪。

948
00:41:11,010 --> 00:41:12,070
我在大学伯克利分校的大三学生。

949
00:41:12,070 --> 00:41:17,250
并随着斯泰利奥斯夏季，
我们将是您三目教学

950
00:41:17,250 --> 00:41:19,277
助理这个即将到来的一年。

951
00:41:19,277 --> 00:41:21,110
所以，我想，都显示
hands--你们有多少人

952
00:41:21,110 --> 00:41:26,680
没有成为一名CS意向
主要也不是真的深潜水

953
00:41:26,680 --> 00:41:29,930
进入计算机科学作为一个主要的吗？

954
00:41:29,930 --> 00:41:30,520
真棒。

955
00:41:30,520 --> 00:41:32,730
这是辉煌的。

956
00:41:32,730 --> 00:41:35,850
>> 所以我其实是一个全球事务
与认知科学专业。

957
00:41:35,850 --> 00:41:37,780
我从字面上来
耶鲁大学的意图

958
00:41:37,780 --> 00:41:42,199
从来不需要看一眼
在我的生活以后再数。

959
00:41:42,199 --> 00:41:44,990
当我来到耶鲁大学，这是
这在过去是从来没有在我的雷达。

960
00:41:44,990 --> 00:41:46,460
我想了解诗歌。

961
00:41:46,460 --> 00:41:48,500
我想了解
国际事务。

962
00:41:48,500 --> 00:41:50,510
我想了解
水彩图画。

963
00:41:50,510 --> 00:41:53,360
是的，我们提供了一个类
上水彩图画。

964
00:41:53,360 --> 00:41:57,340
>> 但我从来没有真正感兴趣
在任何STEM相关。

965
00:41:57,340 --> 00:41:59,620
但随后的长大，我
得了，我越意识到

966
00:41:59,620 --> 00:42:03,340
每场确实有些
感觉采用计算机科学，

967
00:42:03,340 --> 00:42:05,700
或者，如果没有计算机科学，计算。

968
00:42:05,700 --> 00:42:08,300
事实上，我的世界
事务顶点项目，

969
00:42:08,300 --> 00:42:12,020
我们使用的数据分析
分析恐怖袭击

970
00:42:12,020 --> 00:42:13,680
对于博科圣地在尼日利亚。

971
00:42:13,680 --> 00:42:17,510
所以你可以看到，无论
什么专业，​​你最终追求

972
00:42:17,510 --> 00:42:21,640
或者你的利益在这里在耶鲁
是，编程和基础

973
00:42:21,640 --> 00:42:24,130
任何的技能是超级有用。

974
00:42:24,130 --> 00:42:29,840
而CS50还真是装备精良，以
那种借了大量的资源，

975
00:42:29,840 --> 00:42:32,060
给你，不管
怎么舒服你

976
00:42:32,060 --> 00:42:34,590
或如何有兴趣的你
在追求一流。

977
00:42:34,590 --> 00:42:37,290
>> 夏天要谈一点
关于你们是什么位

978
00:42:37,290 --> 00:42:39,635
要了解这一年。

979
00:42:39,635 --> 00:42:40,510
夏季：嗨，大家好。

980
00:42:40,510 --> 00:42:41,320
我是夏武。

981
00:42:41,320 --> 00:42:43,090
我在莫尔斯的大三学生。

982
00:42:43,090 --> 00:42:48,100
实际上我开始了
作为CS50学生自己。

983
00:42:48,100 --> 00:42:51,460
所以，三年前，我在一个缺口的一年。

984
00:42:51,460 --> 00:42:53,940
我从来没有采取CS
类高中，

985
00:42:53,940 --> 00:42:57,800
但我认为，在我的空闲时间，
它会是很酷学习如何代码。

986
00:42:57,800 --> 00:43:02,610
所以，我做了一个快速谷歌搜索，
寻找什么是可在网上，

987
00:43:02,610 --> 00:43:06,990
而看到这个视频布偶
和DJ和凉爽的网站。

988
00:43:06,990 --> 00:43:09,450
我当时想，我想
学习如何做到这一点。

989
00:43:09,450 --> 00:43:14,690
>> 于是我带着的过程中，我
只是爱上它。

990
00:43:14,690 --> 00:43:20,410
不过，我记得是嫉妒的
孩子谁可以参加的编程马拉松，

991
00:43:20,410 --> 00:43:24,610
参加益智日，参加办公室
小时，从助教得到帮助的人。

992
00:43:24,610 --> 00:43:27,410
所以，我从来没有想过
我会得到机会

993
00:43:27,410 --> 00:43:30,640
在这里涉及
首先拿到课程

994
00:43:30,640 --> 00:43:33,630
我感兴趣的计算机
科学之所以

995
00:43:33,630 --> 00:43:35,690
我今天计算机科学专业。

996
00:43:35,690 --> 00:43:39,290
所以我会提醒你，这个类
是要伸展你。

997
00:43:39,290 --> 00:43:41,120
这将挑战你。

998
00:43:41,120 --> 00:43:43,910
但它也将
教你如何做的事情

999
00:43:43,910 --> 00:43:45,506
你从来没有想过你能。

1000
00:43:45,506 --> 00:43:49,330

1001
00:43:49,330 --> 00:43:52,160
>> 斯泰利奥斯：嗨，大家好。

1002
00:43:52,160 --> 00:43:53,510
我的名字叫斯泰利奥斯。

1003
00:43:53,510 --> 00:43:58,240
我在布兰福德初中
学院和CS专业。

1004
00:43:58,240 --> 00:44:01,640
我也是从希腊雅典。

1005
00:44:01,640 --> 00:44:03,830
我真的很期待
满足大家，

1006
00:44:03,830 --> 00:44:09,010
跟你聊天的部分，在
办公时间，在周五的午餐。

1007
00:44:09,010 --> 00:44:11,250
我真的很兴奋，因为
我们已经把这么多的努力

1008
00:44:11,250 --> 00:44:14,650
为创造一个独一无二的支持
结构各位

1009
00:44:14,650 --> 00:44:19,170
使你的经验
过程中最好的。

1010
00:44:19,170 --> 00:44:22,640
我也希望，虽然大部分
你可能没有采取CS

1011
00:44:22,640 --> 00:44:27,310
当然之前，我希望这是CS50
对你来说是什么样的火花兴趣

1012
00:44:27,310 --> 00:44:30,260
以进一步推行电脑
科学在未来，

1013
00:44:30,260 --> 00:44:33,270
因为它已经有那么做
许多人过去。

1014
00:44:33,270 --> 00:44:36,740
所以，谢谢您的
在这里，高兴看到你。

1015
00:44:36,740 --> 00:44:38,487
贾森·赫塞豪恩。

1016
00:44:38,487 --> 00:44:39,820
JASON赫塞豪恩：嗨，大家好。

1017
00:44:39,820 --> 00:44:41,700
我的名字是贾森·赫塞豪恩。

1018
00:44:41,700 --> 00:44:43,050
我住在西利曼。

1019
00:44:43,050 --> 00:44:46,910
和我去哈佛大学作为一个本科生
而主修社会学

1020
00:44:46,910 --> 00:44:48,870
在计算机科学辅修。

1021
00:44:48,870 --> 00:44:53,100
我的主要角色，一个在这里
是支持这个奇妙的工作人员

1022
00:44:53,100 --> 00:44:54,630
他们支持你的所有。

1023
00:44:54,630 --> 00:44:56,410
其实，这是不是所有的人。

1024
00:44:56,410 --> 00:45:01,230
有55个本科生，
毕业生在这里支持你所有。

1025
00:45:01,230 --> 00:45:04,420
我敢说数一数二
适合你的课程部分

1026
00:45:04,420 --> 00:45:08,080
所有的越来越一起工作
他们，去了解他们，

1027
00:45:08,080 --> 00:45:12,389
让看到他们，无论是在CS50
和CS50外本学期

1028
00:45:12,389 --> 00:45:13,680
并为许多学期的到来。

1029
00:45:13,680 --> 00:45:16,770
所以希望你拿
当然，因为你希望

1030
00:45:16,770 --> 00:45:21,060
获取与互动
奇妙的工作人员，我们有在舞台上。

1031
00:45:21,060 --> 00:45:24,977
>> 演讲嘉宾：嗯，让我完成
说这会很有趣。

1032
00:45:24,977 --> 00:45:26,810
DAVID MALAN：嗯，
感谢我们整个团队。

1033
00:45:26,810 --> 00:45:29,610
请允许我调暗灯光，
让更多我们的团队，

1034
00:45:29,610 --> 00:45:32,890
无论是从剑桥和纽黑文，
打招呼因为这些家伙的文件了。

1035
00:45:32,890 --> 00:45:36,130
在这之后，我们将过渡到
第一我们的节目交战

1036
00:45:36,130 --> 00:45:37,584
用这种语言称为划痕。

1037
00:45:37,584 --> 00:45:38,500
所以，感谢团队。

1038
00:45:38,500 --> 00:45:40,770
让我们调暗灯光，
从其他几个人听见。

1039
00:45:40,770 --> 00:45:44,207
>> [掌声]

1040
00:45:44,207 --> 00:45:45,680

1041
00:45:45,680 --> 00:45:48,140
>> [视频回放]

1042
00:45:48,140 --> 00:45:53,210
>> CS50的-The使命就是让你
更舒适的全新方式

1043
00:45:53,210 --> 00:45:54,947
的思想，这种计算的心态。

1044
00:45:54,947 --> 00:45:56,780
 - 它取得计算机科学
有趣的，这

1045
00:45:56,780 --> 00:46:00,241
是我并没有真正实现
是可能的，直到我把这个类。

1046
00:46:00,241 --> 00:46:00,990
 - 我当时想，哇。

1047
00:46:00,990 --> 00:46:04,120
我真的翻译我的想法
到计算机现在。

1048
00:46:04,120 --> 00:46:07,970
>>  - 即使如果你没有任何背景做
在计算机科学或任何经验，

1049
00:46:07,970 --> 00:46:10,140
这其实是对你的类。

1050
00:46:10,140 --> 00:46:12,250
>>  - 所以我肯定要
我的学生，只是

1051
00:46:12,250 --> 00:46:14,350
感到兴奋的计算机科学。

1052
00:46:14,350 --> 00:46:17,187
不只是编程，但
想着像计算机科学家

1053
00:46:17,187 --> 00:46:19,270
真的是我想做的
试教我大一。

1054
00:46:19,270 --> 00:46:21,560
>> -CS50是很难和奖励。

1055
00:46:21,560 --> 00:46:22,592
>> -体验。

1056
00:46:22,592 --> 00:46:23,456
>> -Extravaganza。

1057
00:46:23,456 --> 00:46:26,350
>>  - 它是带给我们一个新的水平。

1058
00:46:26,350 --> 00:46:28,850
>> [音乐]

1059
00:46:28,850 --> 00:46:32,167
>> -The转录因子是的，我想，
命脉当然。

1060
00:46:32,167 --> 00:46:34,560
>>  - 我高兴能有
我的学生，我帮

1061
00:46:34,560 --> 00:46:38,027
有惊喜的时刻实现
他们实际上是想

1062
00:46:38,027 --> 00:46:39,610
这样做，找出如何做一个PSET。

1063
00:46:39,610 --> 00:46:41,438
>> -CS50绝对是一个艰难历程。

1064
00:46:41,438 --> 00:46:43,960
但不同于其他任何
当然，真正在耶鲁，

1065
00:46:43,960 --> 00:46:45,759
它有这样一个伟大的，
支持的社区。

1066
00:46:45,759 --> 00:46:47,550
 - 你万万不
需要知道什么

1067
00:46:47,550 --> 00:46:49,341
关于编码，以便能够
参加的课程。

1068
00:46:49,341 --> 00:46:52,270
 - 它是惊人的看多远
人进来一个学期。

1069
00:46:52,270 --> 00:46:55,610
>>  - 你并不孤单坐在
你的房间学习代码，

1070
00:46:55,610 --> 00:46:57,170
但它不仅仅是一个类的更多。

1071
00:46:57,170 --> 00:46:58,044
这是一个经验。

1072
00:46:58,044 --> 00:47:02,500
学习概念 - 最佳方式
处理这些是教别人。

1073
00:47:02,500 --> 00:47:04,033
>>  - 什么是电话分流？

1074
00:47:04,033 --> 00:47:06,934
>> [音乐]

1075
00:47:06,934 --> 00:47:08,080
>>  - 和这是CS50。

1076
00:47:08,080 --> 00:47:10,810
>> [音乐]

1077
00:47:10,810 --> 00:47:11,720

1078
00:47:11,720 --> 00:47:12,380
>>  - 这是CS50。

1079
00:47:12,380 --> 00:47:13,446
>> -Got有问题吗？

1080
00:47:13,446 --> 00:47:14,852
撕裂成两半。

1081
00:47:14,852 --> 00:47:15,804
>> [音乐]

1082
00:47:15,804 --> 00:47:18,184
>> 把它扔掉。

1083
00:47:18,184 --> 00:47:19,520
>> DAVID MALAN：好的。

1084
00:47:19,520 --> 00:47:23,190
因此，让我们在一个小tackle--
位，顺便说一句，这是

1085
00:47:23,190 --> 00:47:25,270
是这个传统，
由于某些原因10年

1086
00:47:25,270 --> 00:47:27,260
服务蛋糕在
启动和CS50的结束。

1087
00:47:27,260 --> 00:47:30,800
所以，等待你的结尾
今天，除了教学大纲，

1088
00:47:30,800 --> 00:47:34,270
将一些蛋糕，以及，
课程的工作人员打招呼。

1089
00:47:34,270 --> 00:47:37,110
但现在，让我们过渡到
首先我们的语言，其中的

1090
00:47:37,110 --> 00:47:40,970
我们只是一个星期，一个人真正花
问题在这个领域，集从零开始。

1091
00:47:40,970 --> 00:47:43,160
你会发现，如果你已经
前编程，很多

1092
00:47:43,160 --> 00:47:46,280
的思路和
可能性是熟悉。

1093
00:47:46,280 --> 00:47:48,160
但是你会发现，
它是沿途乐趣

1094
00:47:48,160 --> 00:47:51,201
要弄清楚到底怎么翻译
一些你已经知道的想法

1095
00:47:51,201 --> 00:47:53,852
这个特定环境
真正打动你的家人

1096
00:47:53,852 --> 00:47:57,060
和你的工作的朋友，它可以
网上去，如果你选择，后来。

1097
00:47:57,060 --> 00:47:58,851
>> 如果你没有
以往的经验，并

1098
00:47:58,851 --> 00:48:01,540
多数之间
学生不舒服，

1099
00:48:01,540 --> 00:48:05,320
意识到很多的想法，我们
只是探索与reality--东西

1100
00:48:05,320 --> 00:48:07,970
喜欢这款手机的书和出席
所以forth--翻译

1101
00:48:07,970 --> 00:48:12,280
相当好听到计算机，
但如果你使用，

1102
00:48:12,280 --> 00:48:13,710
最初，这样的语言。

1103
00:48:13,710 --> 00:48:16,290
因此，这是写的程序
在一个叫做C.语言

1104
00:48:16,290 --> 00:48:18,590
我们会花相当多的
时间在C，最终。

1105
00:48:18,590 --> 00:48:22,560
但赔率是，这看起来有点
神秘的给你的第一眼。

1106
00:48:22,560 --> 00:48:25,760
事实上，有很多奇奇怪怪的
语法，括号，尖括号，

1107
00:48:25,760 --> 00:48:27,422
大括号，报价和分号。

1108
00:48:27,422 --> 00:48:29,880
事实上，如果你潜入
编程首次

1109
00:48:29,880 --> 00:48:33,420
寻找并试图创造的东西
像这样的，说实话，你总是这么深陷

1110
00:48:33,420 --> 00:48:36,500
所以经常只是愚蠢
细节是没有什么

1111
00:48:36,500 --> 00:48:38,240
理智有趣了。

1112
00:48:38,240 --> 00:48:40,980
>> 但想象一下，如果你可以创建
同样program--其中，

1113
00:48:40,980 --> 00:48:46,200
正如你可能有种推断，可能是
打印“你好，世界”好歹。

1114
00:48:46,200 --> 00:48:49,850
我们可以提炼出同样的想法成
只有两个拼图，如果你愿意。

1115
00:48:49,850 --> 00:48:52,850
事实上，划痕很有趣
因为它是这个图形语言。

1116
00:48:52,850 --> 00:48:56,110
你可以拖放这些
拼图，只有联锁

1117
00:48:56,110 --> 00:48:57,940
如果它使逻辑意义这样做。

1118
00:48:57,940 --> 00:48:59,830
所以，在划痕，
我们很快就会看到，这是

1119
00:48:59,830 --> 00:49:03,460
你将如何实现相同的
程序中，只有两个拼图

1120
00:49:03,460 --> 00:49:05,420
这几乎是他们说的去做。

1121
00:49:05,420 --> 00:49:08,870
>> 但是我们会在短短的一瞬间看到，一些
我们提到的积木

1122
00:49:08,870 --> 00:49:12,140
更早，几个都认为
最终要构成

1123
00:49:12,140 --> 00:49:13,460
我们的一些早期的项目。

1124
00:49:13,460 --> 00:49:15,460
我们将有事情
像functions--刚

1125
00:49:15,460 --> 00:49:18,034
该做些什么动作，
好比说你好，世界。

1126
00:49:18,034 --> 00:49:20,200
我们将有循环，
事情引起循环

1127
00:49:20,200 --> 00:49:23,210
一遍又一遍，就像我们
做了刚才与搜索

1128
00:49:23,210 --> 00:49:24,110
麦克·史密斯。

1129
00:49:24,110 --> 00:49:27,190
变量，如代数，如果你
包含X或Y，可以存储一个数字。

1130
00:49:27,190 --> 00:49:29,940
那么，在一个程序，可以实际
存储不仅仅是数字更多。

1131
00:49:29,940 --> 00:49:34,290
您可以存储的单词和句子
和图形和其他东西还在。

1132
00:49:34,290 --> 00:49:37,530
布尔表达式，只是
questions-- yes或no，true或false。

1133
00:49:37,530 --> 00:49:40,680
条件，作出决定
基于这些是/否的答案。

1134
00:49:40,680 --> 00:49:43,890
>> 然后发烧友之类的东西
阵列和线程和事件

1135
00:49:43,890 --> 00:49:46,100
和任何数量的其他
的功能，但所有这些都

1136
00:49:46,100 --> 00:49:48,670
非常漂亮映射到非常
友好块这样。

1137
00:49:48,670 --> 00:49:52,736
这将是一个函数，一个
紫一块拼图，只是说：

1138
00:49:52,736 --> 00:49:54,717
它的名字在这种情况下is--，说。

1139
00:49:54,717 --> 00:49:56,550
然后经常有
白盒，你

1140
00:49:56,550 --> 00:49:58,550
可以键入或拖动某个值成。

1141
00:49:58,550 --> 00:50:01,370
这就是一般的
所谓的参数或参数。

1142
00:50:01,370 --> 00:50:04,110
它的改变的方式
一个谜的默认行为

1143
00:50:04,110 --> 00:50:07,530
片或一个功能以便它
定制的东西对你好像说，

1144
00:50:07,530 --> 00:50:12,570
你好，世界还是你好，安迪还是你好，
杰森或其他一些句子来代替。

1145
00:50:12,570 --> 00:50:15,830
>> 如果你想说，一个
lot--字面上forever--

1146
00:50:15,830 --> 00:50:18,142
你可以采取另一种
所谓永远的一块拼图

1147
00:50:18,142 --> 00:50:20,100
，只是夹在
两者相加是这样的。

1148
00:50:20,100 --> 00:50:24,090
和循环，作为图像显示，
意味着只是说你好，世界永远

1149
00:50:24,090 --> 00:50:25,810
一遍又一遍又一遍。

1150
00:50:25,810 --> 00:50:28,840
或者，如果你只想做它
有限次，如50次，

1151
00:50:28,840 --> 00:50:32,050
还有的将是另一个谜
一块为that--重复50次。

1152
00:50:32,050 --> 00:50:34,190
>> 同时，如果你想
具有可变

1153
00:50:34,190 --> 00:50:36,090
在这门语言我们
约一起玩，

1154
00:50:36,090 --> 00:50:37,880
你可以用这样的橙色块。

1155
00:50:37,880 --> 00:50:40,750
而这个变量我随意
叫我为整数。

1156
00:50:40,750 --> 00:50:42,290
而我只是将它设置为0。

1157
00:50:42,290 --> 00:50:44,780
所以也许我，在这
case--这个变量 -

1158
00:50:44,780 --> 00:50:46,630
代表在一场比赛中一个人的得分。

1159
00:50:46,630 --> 00:50:49,680
您从零开始，每一次你
作出这样的一个目标什么的，

1160
00:50:49,680 --> 00:50:51,270
你会得到一个额外的点。

1161
00:50:51,270 --> 00:50:52,830
>> 你可以问划痕的问题。

1162
00:50:52,830 --> 00:50:55,390
如果我们拖放谜
条这样的时刻，

1163
00:50:55,390 --> 00:50:58,470
你可以问这样的问题，
好了，我是小于50？

1164
00:50:58,470 --> 00:51:00,060
也许你需要50分夺冠。

1165
00:51:00,060 --> 00:51:01,893
因此，这将是
你问的问题。

1166
00:51:01,893 --> 00:51:04,030
或者，更一般地，你
可以说，为x小于y，

1167
00:51:04,030 --> 00:51:05,780
那里的两个变量为何？

1168
00:51:05,780 --> 00:51:08,320
现在，这个人是一个很大
更大的第一眼，

1169
00:51:08,320 --> 00:51:11,470
但真的没有那么复杂。

1170
00:51:11,470 --> 00:51:15,390
>> 这仅仅是一个组合
条件和变量

1171
00:51:15,390 --> 00:51:19,370
和布尔表达式问
3 questions--比Y X少？

1172
00:51:19,370 --> 00:51:20,660
如果是这样，这么说。

1173
00:51:20,660 --> 00:51:22,170
分析称，X小于y。

1174
00:51:22,170 --> 00:51:26,571
否则，如果x大于
Y，否则x必须等于y。

1175
00:51:26,571 --> 00:51:29,070
和而用迈克·史密斯，
有四种情况，在这里

1176
00:51:29,070 --> 00:51:32,270
在数字世界中，x是
小于，大于或等于。

1177
00:51:32,270 --> 00:51:34,531
我们所有的都在三路叉。

1178
00:51:34,531 --> 00:51:36,530
然后还有票友
拼图这样的

1179
00:51:36,530 --> 00:51:39,613
对于像数组，在那里我们
要能够存储信息。

1180
00:51:39,613 --> 00:51:43,590
我们要看到块，使
我们执行多个线程，

1181
00:51:43,590 --> 00:51:46,620
另一个特点，我们将使用和
然后还要所谓的事件。

1182
00:51:46,620 --> 00:51:49,390
但是，在我们获得该
点，创造出，

1183
00:51:49,390 --> 00:51:52,000
最终，我们自己的自定义
拼图，让我们

1184
00:51:52,000 --> 00:51:53,950
实际打开的程序本身。

1185
00:51:53,950 --> 00:51:54,860
>> 因此，这是划痕。

1186
00:51:54,860 --> 00:51:57,490
它可在scratch.mit.edu。

1187
00:51:57,490 --> 00:51:59,650
并欢迎您打
现在或以后，也是如此。

1188
00:51:59,650 --> 00:52:01,330
这恰好是离线版本。

1189
00:52:01,330 --> 00:52:03,129
对于人谁不
一定有伟大的互联网，

1190
00:52:03,129 --> 00:52:04,962
你可以下载
相同的软件，以及。

1191
00:52:04,962 --> 00:52:07,460
还有的真的只有三
组件此软件。

1192
00:52:07,460 --> 00:52:10,860
上的顶部左上角
屏幕是那种舞台

1193
00:52:10,860 --> 00:52:13,800
即刮，默认情况下谁
看起来像一只猫，住进去。

1194
00:52:13,800 --> 00:52:16,799
他能向上，下，左，右
做任何数量的其他事情，

1195
00:52:16,799 --> 00:52:20,520
并可以看基于任何数量的方式
在分配给他的服饰。

1196
00:52:20,520 --> 00:52:22,980
但是，这就是我们会打电话给一个
精灵，一种性格。

1197
00:52:22,980 --> 00:52:25,429
你可以有多个
人物，因为我们很快就会看到。

1198
00:52:25,429 --> 00:52:30,060
>> 在中间现在所有这些拼图
件，这些类别或托盘

1199
00:52:30,060 --> 00:52:30,900
其。

1200
00:52:30,900 --> 00:52:32,429
所以现在，我点击了运动。

1201
00:52:32,429 --> 00:52:35,900
所以，我看到所有的
运动相关的拼图或块，

1202
00:52:35,900 --> 00:52:37,950
使有功能
做往上走，

1203
00:52:37,950 --> 00:52:39,950
向下，向左或向右或
一些其它操作。

1204
00:52:39,950 --> 00:52:43,790
但是，如果我点击长相，你
可以看到的东西像说块

1205
00:52:43,790 --> 00:52:45,084
我们看到刚才。

1206
00:52:45,084 --> 00:52:48,250
如果我点击控制，你会看到
之类的东西重复和永远

1207
00:52:48,250 --> 00:52:50,410
而如果块
我们看到刚才。

1208
00:52:50,410 --> 00:52:51,670
>> 所以，你会发现
我们将只划伤

1209
00:52:51,670 --> 00:52:53,750
的一些表面
拼图在一起，

1210
00:52:53,750 --> 00:52:55,833
但是这一切都非常直观
和指向和点击。

1211
00:52:55,833 --> 00:52:58,219
事实上，划痕设计
对于年轻的学生

1212
00:52:58,219 --> 00:53:00,730
以帮助给他们一个出口
创造性思维。

1213
00:53:00,730 --> 00:53:03,040
然而奇妙的，它的
一个美妙的垫脚石

1214
00:53:03,040 --> 00:53:07,020
恰好我们要想法
探索用C和Python和JavaScript，

1215
00:53:07,020 --> 00:53:07,719
为好。

1216
00:53:07,719 --> 00:53:11,960
>> 在右侧，终于在这里，
是这样的，即所谓的脚本区域。

1217
00:53:11,960 --> 00:53:15,750
而这仅仅是空白的石板用
你开始写程序。

1218
00:53:15,750 --> 00:53:16,897
我会这一点。

1219
00:53:16,897 --> 00:53:19,980
现在，我碰巧知道东西在哪里
因为我这个做了几次。

1220
00:53:19,980 --> 00:53:22,710
但我知道，在
事件类别，

1221
00:53:22,710 --> 00:53:25,520
有此块这里 -
当绿旗点击。

1222
00:53:25,520 --> 00:53:28,790
同时注意，如果我缩小，
早在在这里的舞台上，

1223
00:53:28,790 --> 00:53:31,190
从无到有生活在这个
长方形的小世界，

1224
00:53:31,190 --> 00:53:33,920
顶上是绿色的
国旗和一个红色的停车标志。

1225
00:53:33,920 --> 00:53:36,180
所以，去阻止，分别。

1226
00:53:36,180 --> 00:53:38,710
>> 还等什么做我想做的事
当绿旗被点击？

1227
00:53:38,710 --> 00:53:40,900
好了，让我去，看起来类别。

1228
00:53:40,900 --> 00:53:43,357
让我先走
和拖放这一点。

1229
00:53:43,357 --> 00:53:45,940
并注意一旦它得到
密切，他们是那种磁性。

1230
00:53:45,940 --> 00:53:48,489
所以，如果我现在放开，其卡
一起漂亮和干净。

1231
00:53:48,489 --> 00:53:51,030
而且我要继续前进，
这样说你好，世界

1232
00:53:51,030 --> 00:53:52,190
两秒钟。

1233
00:53:52,190 --> 00:53:56,730
让我缩小，现在的点击
绿旗，说，你好，世界。

1234
00:53:56,730 --> 00:53:57,230
好吧。

1235
00:53:57,230 --> 00:53:58,460
所以这是一切优秀和良好。

1236
00:53:58,460 --> 00:53:59,900
不是所有的精彩。

1237
00:53:59,900 --> 00:54:01,340
让我们把它一点点可爱。

1238
00:54:01,340 --> 00:54:03,494
我知道，在
提前，发生刮擦

1239
00:54:03,494 --> 00:54:05,160
来像这样一些可爱的东西。

1240
00:54:05,160 --> 00:54:07,720
所以玩喵喵的声音，直到完成。

1241
00:54:07,720 --> 00:54:09,531
因此，让我们做到这一点。

1242
00:54:09,531 --> 00:54:10,380
>> [喵]

1243
00:54:10,380 --> 00:54:11,819
>> 噢，那是可爱。

1244
00:54:11,819 --> 00:54:12,860
如果我点击它again--

1245
00:54:12,860 --> 00:54:14,920
>> [喵]

1246
00:54:14,920 --> 00:54:15,460
>> 然后再次。

1247
00:54:15,460 --> 00:54:16,740
>> [喵]

1248
00:54:16,740 --> 00:54:18,760
>> 但我一直有重新加进划伤。

1249
00:54:18,760 --> 00:54:20,010
但我可以做的比这更好。

1250
00:54:20,010 --> 00:54:23,060
为什么不让我只需拖动这三个。

1251
00:54:23,060 --> 00:54:24,821
而现在它的三倍可爱。

1252
00:54:24,821 --> 00:54:26,264
>> [喵喵叫]

1253
00:54:26,264 --> 00:54:28,190
>> OK，其实，这是一个有点让人毛骨悚然。

1254
00:54:28,190 --> 00:54:31,020
因此，我们需要在两者之间有什么。

1255
00:54:31,020 --> 00:54:33,870
如果我去控制，它看起来像
其实有一个等待块。

1256
00:54:33,870 --> 00:54:36,994
所以请注意，如果我将鼠标悬停在那里 -
让我赚这点大。

1257
00:54:36,994 --> 00:54:38,780
如果我悬停，这是怎么回事
以卡入到位。

1258
00:54:38,780 --> 00:54:41,660
所以，等待一秒钟，等待一秒钟。

1259
00:54:41,660 --> 00:54:43,170
让我们再次打绿旗。

1260
00:54:43,170 --> 00:54:46,330
>> [喵喵叫]

1261
00:54:46,330 --> 00:54:47,695

1262
00:54:47,695 --> 00:54:50,660
>> OK，多了几分自然，
但不是非常有效的。

1263
00:54:50,660 --> 00:54:54,300
因此，这是正确的，如果我的程序的
目标是喵三次。

1264
00:54:54,300 --> 00:54:56,410
但它不是非常精心设计的。

1265
00:54:56,410 --> 00:54:57,740
我有点削减一些角落。

1266
00:54:57,740 --> 00:54:58,730
我有点懒。

1267
00:54:58,730 --> 00:55:05,620
什么感觉like--什么我似乎
都做不好，你会说什么？

1268
00:55:05,620 --> 00:55:07,197
是吗？

1269
00:55:07,197 --> 00:55:08,030
是的，在中间。

1270
00:55:08,030 --> 00:55:11,208

1271
00:55:11,208 --> 00:55:13,083
听众：多用
内存比你需要

1272
00:55:13,083 --> 00:55:15,005
因为你使用
这么多不同的路线。

1273
00:55:15,005 --> 00:55:16,380
DAVID MALAN：是的，所以更多的线路。

1274
00:55:16,380 --> 00:55:19,190
它不一定是存储器，
虽然它可以被看作是这样的。

1275
00:55:19,190 --> 00:55:20,898
但它的definitely--
有冗余。

1276
00:55:20,898 --> 00:55:23,440
而且我真的有种拖
和丢弃的同样的事情。

1277
00:55:23,440 --> 00:55:26,564
如果你有种extrapolate--如果
这不是很明显这里 - 好，怎么会

1278
00:55:26,564 --> 00:55:27,910
我喵30倍？

1279
00:55:27,910 --> 00:55:31,450
我会拖放一样，
30多对拼图。

1280
00:55:31,450 --> 00:55:32,890
，肯定有一个更好的办法。

1281
00:55:32,890 --> 00:55:34,056
我们已经看到一个更好的办法。

1282
00:55:34,056 --> 00:55:36,870
什么直观地将
是更好的办法？

1283
00:55:36,870 --> 00:55:37,890
是啊，只要使用一个循环。

1284
00:55:37,890 --> 00:55:38,810
没有复制和粘贴。

1285
00:55:38,810 --> 00:55:40,790
事实上，这种随时随地
学期如果你开始

1286
00:55:40,790 --> 00:55:43,890
发现自己拖放，
还是真的复制和粘贴，

1287
00:55:43,890 --> 00:55:47,050
危险习惯进入，因为
这仅仅是不是很维护。

1288
00:55:47,050 --> 00:55:49,740
举例来说，如果我想改变
声音到别的东西，

1289
00:55:49,740 --> 00:55:52,826
我现在去改变它在三个
位置，而不只是一个。

1290
00:55:52,826 --> 00:55:54,575
因为事实上，如果我
打破这种away--我

1291
00:55:54,575 --> 00:55:56,170
只是要脱钩会这样。

1292
00:55:56,170 --> 00:56:01,900
让我抢了重复块，和
然后单击三，型三种，

1293
00:56:01,900 --> 00:56:04,015
抛出一些这些
程刚放手。

1294
00:56:04,015 --> 00:56:05,890
然后发现它
看起来并不像它适合，

1295
00:56:05,890 --> 00:56:08,139
但磁性，这是怎么回事
不仅入到位

1296
00:56:08,139 --> 00:56:09,510
但长到适合的形状。

1297
00:56:09,510 --> 00:56:10,310
所以这是很好的。

1298
00:56:10,310 --> 00:56:11,530
而现在，如果我点击播放。

1299
00:56:11,530 --> 00:56:13,870
>> [喵喵叫]

1300
00:56:13,870 --> 00:56:14,370

1301
00:56:14,370 --> 00:56:15,620
非常好。

1302
00:56:15,620 --> 00:56:16,126
好吧。

1303
00:56:16,126 --> 00:56:18,500
现在它很容易
改变，也因为我可以

1304
00:56:18,500 --> 00:56:20,670
在一个地方更改一个数字。

1305
00:56:20,670 --> 00:56:22,500
但是，这也并不
那么有趣。

1306
00:56:22,500 --> 00:56:25,350
让我们实际上有
刮不喵的，但移动。

1307
00:56:25,350 --> 00:56:32,680
让我去运动和移动的10个步骤
of--哎呦里面，让我解决这个问题。

1308
00:56:32,680 --> 00:56:37,460
让我把它移到10 steps--
其实，我们不要做重复。

1309
00:56:37,460 --> 00:56:40,670
让我抢一个控制块，
做永远以下。

1310
00:56:40,670 --> 00:56:42,720
永远，移动10步。

1311
00:56:42,720 --> 00:56:45,070
并单击播放。

1312
00:56:45,070 --> 00:56:45,600
>> 好。

1313
00:56:45,600 --> 00:56:46,740
所以，值得庆幸的是，他停止。

1314
00:56:46,740 --> 00:56:49,710
否则，孩子会很心烦
当他们那种失去他们的猫。

1315
00:56:49,710 --> 00:56:52,720
但至少我可以拖动
他回到屏幕。

1316
00:56:52,720 --> 00:56:56,177
但是，这是不是所有的
大的游戏或动画。

1317
00:56:56,177 --> 00:56:58,260
这将是很好，如果可能
他弹开的边缘。

1318
00:56:58,260 --> 00:57:00,020
那么我们该怎么办？

1319
00:57:00,020 --> 00:57:04,302
什么结构我们需要有
SCRATCH决定反弹，你认为，

1320
00:57:04,302 --> 00:57:06,010
即使你从来没有
见过划痕？

1321
00:57:06,010 --> 00:57:06,593
是啊，在后面。

1322
00:57:06,593 --> 00:57:08,359
听众：您需要一个
如果块或IF-THEN。

1323
00:57:08,359 --> 00:57:10,650
DAVID MALAN：是的，所以一些
那种if块或IF-THEN。

1324
00:57:10,650 --> 00:57:12,275
所以实际上，我们这里的其中之一。

1325
00:57:12,275 --> 00:57:14,500
所以if--所以让我拿
摆脱运动。

1326
00:57:14,500 --> 00:57:16,070
让我放大，所以这是更大的。

1327
00:57:16,070 --> 00:57:16,890
那么这个怎么样。

1328
00:57:16,890 --> 00:57:21,920
永远，如果Sensing--
我们还没有见过这个。

1329
00:57:21,920 --> 00:57:23,160
我需要一个布尔表达式。

1330
00:57:23,160 --> 00:57:25,970
而事实证明，如果摸什么？

1331
00:57:25,970 --> 00:57:29,030
如果触及边缘，
我想要做什么？

1332
00:57:29,030 --> 00:57:32,030
好吧，如果我回去运动，
原来，哦，我可以转身。

1333
00:57:32,030 --> 00:57:33,350
我这里拖这一点。

1334
00:57:33,350 --> 00:57:36,430
我为什么不继续前进，
转身180度？

1335
00:57:36,430 --> 00:57:38,190
>> 现在，让我动弹结束。

1336
00:57:38,190 --> 00:57:40,500
我可以把在运动
的开始或结束。

1337
00:57:40,500 --> 00:57:44,452
但在逻辑上，每次我动，我
要检查，我在接触的边缘？

1338
00:57:44,452 --> 00:57:45,410
难道我接触的边缘？

1339
00:57:45,410 --> 00:57:46,490
难道我接触的边缘？

1340
00:57:46,490 --> 00:57:49,200
因此，逻辑上我如果这样转身。

1341
00:57:49,200 --> 00:57:51,190
因此，让我们点击播放。

1342
00:57:51,190 --> 00:57:52,030
>> 好。

1343
00:57:52,030 --> 00:57:53,910
所以这是稍微车，可以这么说。

1344
00:57:53,910 --> 00:57:56,560
而一个错误仅仅是一个错误
在一个计算机程序。

1345
00:57:56,560 --> 00:57:57,800
但至少它的工作。

1346
00:57:57,800 --> 00:57:59,420
而事实上，我可以在这里犹豫。

1347
00:57:59,420 --> 00:58:03,130
而让我在这不是10个步骤
时间，但是这是所有动画。

1348
00:58:03,130 --> 00:58:05,310
这是所有卡通
甚至电影。

1349
00:58:05,310 --> 00:58:07,110
让我移动20步在同一时间。

1350
00:58:07,110 --> 00:58:11,200
因此，20倍，许多事情正在发生
一次，或两倍多，在这种情况下。

1351
00:58:11,200 --> 00:58:12,600
而且他的移动速度更快。

1352
00:58:12,600 --> 00:58:15,150
让我更改为30。

1353
00:58:15,150 --> 00:58:17,450
100。

1354
00:58:17,450 --> 00:58:19,406
1000。

1355
00:58:19,406 --> 00:58:20,530
而且它会非常快。

1356
00:58:20,530 --> 00:58:22,190
而这is--是啊，OK。

1357
00:58:22,190 --> 00:58:24,130
>> 所以，现在我们只是用它搞乱。

1358
00:58:24,130 --> 00:58:24,954
好了，马车。

1359
00:58:24,954 --> 00:58:26,620
但是，我们可以把他拖出来，这里的道路。

1360
00:58:26,620 --> 00:58:28,286
但是我们可以让更多的乐趣，这也算。

1361
00:58:28,286 --> 00:58:30,710
如何this--他的倒挂。

1362
00:58:30,710 --> 00:58:32,800
但事实证明，Scratch--
实际上有，

1363
00:58:32,800 --> 00:58:35,510
我不得不放弃，没有学术
价值是什么，我将做。

1364
00:58:35,510 --> 00:58:40,200
但是，如果我打开麦克风，让我们
阻止他这样做。

1365
00:58:40,200 --> 00:58:41,960
哎哟!

1366
00:58:41,960 --> 00:58:42,884
>> [笑]

1367
00:58:42,884 --> 00:58:45,200

1368
00:58:45,200 --> 00:58:45,990
>> 这是可爱的。

1369
00:58:45,990 --> 00:58:46,740
谢谢。

1370
00:58:46,740 --> 00:58:50,850
现在，这是我的声音
看起来，当我大叫哎哟等。

1371
00:58:50,850 --> 00:58:52,630
我不认为我们抓住了你的笑声。

1372
00:58:52,630 --> 00:58:53,280
没关系。

1373
00:58:53,280 --> 00:58:56,550
让我这个保存为“哎哟”。

1374
00:58:56,550 --> 00:58:57,915
让我们将这个保存为“哎哟”。

1375
00:58:57,915 --> 00:58:59,410
现在，我们将回到脚本。

1376
00:58:59,410 --> 00:59:01,660
现在我need--让我们来看看，声音。

1377
00:59:01,660 --> 00:59:03,160
哦，播放声音哎哟。

1378
00:59:03,160 --> 00:59:08,180
所以，如果我碰的边缘，让我
第一次玩哎哟，然后转身。

1379
00:59:08,180 --> 00:59:10,191
现在，让我们把他夹在中间。

1380
00:59:10,191 --> 00:59:14,754
>> [说：“哎哟”]

1381
00:59:14,754 --> 00:59:15,740
>> 快两倍。

1382
00:59:15,740 --> 00:59:20,660

1383
00:59:20,660 --> 00:59:21,830
>> 好。

1384
00:59:21,830 --> 00:59:23,780
但它的字面
做我在说什么。

1385
00:59:23,780 --> 00:59:27,580
所以它实际上是正确的，它是
只是有点讨厌快。

1386
00:59:27,580 --> 00:59:30,330
因此，让我们添加的东西
更有趣了这一点。

1387
00:59:30,330 --> 00:59:32,950
让我真正打通
一个我提前做，

1388
00:59:32,950 --> 00:59:38,560
形象地称为宠物的
猫，才会这样。

1389
00:59:38,560 --> 00:59:40,340
这里的脚本在这里。

1390
00:59:40,340 --> 00:59:44,510
这是什么打算
在英语方面呢？

1391
00:59:44,510 --> 00:59:45,820
这是什么目的呢？

1392
00:59:45,820 --> 00:59:47,900
是啊，让我们去some--是吗？

1393
00:59:47,900 --> 00:59:49,665
>> 听众：当你
宠物猫，它叫声。

1394
00:59:49,665 --> 00:59:52,290
DAVID MALAN：是的，所以当你
宠物猫，它会喵喵叫。

1395
00:59:52,290 --> 00:59:55,452
因此，换句话说，有现在
一个永远循环的是，合并

1396
00:59:55,452 --> 00:59:57,660
带条件，组合
用布尔表达式，

1397
00:59:57,660 --> 01:00:00,140
再加上一对夫妇
的功能，其效果

1398
01:00:00,140 --> 01:00:02,610
其中，有一次我玩
这个程序，是什么

1399
01:00:02,610 --> 01:00:06,820
反应，直到我移动光标
密切和更​​密切的还有 -

1400
01:00:06,820 --> 01:00:08,029
>> [喵]

1401
01:00:08,029 --> 01:00:09,320
然后，它像抚摸一只猫。

1402
01:00:09,320 --> 01:00:11,210
[喵]

1403
01:00:11,210 --> 01:00:14,270
只有当你真正
将光标移到他。

1404
01:00:14,270 --> 01:00:19,964
现在，我也掀起了不宠
猫，而做到这一点，而不是。

1405
01:00:19,964 --> 01:00:21,350
>> [喵喵叫]

1406
01:00:21,350 --> 01:00:23,485
>> 所以他只是不断地喵喵叫。

1407
01:00:23,485 --> 01:00:24,455
>> [喵喵叫]

1408
01:00:24,455 --> 01:00:27,705
>> 但是，如果我太close--

1409
01:00:27,705 --> 01:00:29,645
>> [喵喵叫]

1410
01:00:29,645 --> 01:00:32,080
>> [怒吼]

1411
01:00:32,080 --> 01:00:33,590
>> 那么如何工作的呢？

1412
01:00:33,590 --> 01:00:35,880
现在，我只是有一个
两路岔路。

1413
01:00:35,880 --> 01:00:38,930
如果触摸鼠标指针，
然后播放狮子的声音。

1414
01:00:38,930 --> 01:00:41,950
否则只是玩喵声，
然后等待三秒钟，这样

1415
01:00:41,950 --> 01:00:43,880
它是一种做
很平静。

1416
01:00:43,880 --> 01:00:44,380
好吧。

1417
01:00:44,380 --> 01:00:47,290
所以这是结合
一些更多的想法依然。

1418
01:00:47,290 --> 01:00:50,870
让我们来看看这个例子
我刮起了所谓的线程。

1419
01:00:50,870 --> 01:00:54,020
而这一次是根本
在它利用不同

1420
01:00:54,020 --> 01:00:56,070
众多的功能
所谓的编程语言

1421
01:00:56,070 --> 01:00:59,970
线程，程序到能力
从字面上同时做两件事情。

1422
01:00:59,970 --> 01:01:03,600
事实上，这些天，如果你使用
谷歌文档或Microsoft Word，

1423
01:01:03,600 --> 01:01:09,620
和你的文档的不断被
拼写检查，即使你类型 - 或者你

1424
01:01:09,620 --> 01:01:11,580
点击Command-P或Control-P
和打印的东西，

1425
01:01:11,580 --> 01:01:13,380
它的打印，而你继续输入。

1426
01:01:13,380 --> 01:01:16,680
今天的节目的确可以做多
齐头并进，就像在刮

1427
01:01:16,680 --> 01:01:17,180
这里。

1428
01:01:17,180 --> 01:01:20,400
>> 所以在这里，我有两个精灵
现在，一只鸟和一只猫。

1429
01:01:20,400 --> 01:01:22,780
如果我点击每个
这些字符一次一个，

1430
01:01:22,780 --> 01:01:25,590
我现在看到的鸟的
脚本在右上角。

1431
01:01:25,590 --> 01:01:27,270
现在我看到猫的。

1432
01:01:27,270 --> 01:01:28,540
鸟，猫的。

1433
01:01:28,540 --> 01:01:30,270
所以，他们每个人都有自己的脚本。

1434
01:01:30,270 --> 01:01:32,700
但通知，什么一块拼图
？他们都与开始的？

1435
01:01:32,700 --> 01:01:34,260
当绿旗点击。

1436
01:01:34,260 --> 01:01:36,890
和鸟类，当绿旗点击。

1437
01:01:36,890 --> 01:01:40,870
所以，当我按一下绿色旗帜，
这两个脚本或程序

1438
01:01:40,870 --> 01:01:42,759
要并行运行。

1439
01:01:42,759 --> 01:01:45,800
你会发现，鸟
只是盲目地反弹的边缘。

1440
01:01:45,800 --> 01:01:50,890
猫显然被编程
具有战略优势。

1441
01:01:50,890 --> 01:01:52,704
和 -

1442
01:01:52,704 --> 01:01:53,490
>> [怒吼]

1443
01:01:53,490 --> 01:01:53,821

1444
01:01:53,821 --> 01:01:54,320
好吧。

1445
01:01:54,320 --> 01:01:57,340
所以猫夹在这种情况下，鸟。

1446
01:01:57,340 --> 01:01:58,390
这是为什么？

1447
01:01:58,390 --> 01:02:03,310
好了，先通知我们只是有
鸟只是盲目地去

1448
01:02:03,310 --> 01:02:05,120
这个最初的位置，
然后永远，

1449
01:02:05,120 --> 01:02:06,774
如果不接触猫，正义之举。

1450
01:02:06,774 --> 01:02:08,190
如果你是在边缘，反弹。

1451
01:02:08,190 --> 01:02:08,870
和正义之举。

1452
01:02:08,870 --> 01:02:10,286
如果你是在边缘，反弹。

1453
01:02:10,286 --> 01:02:12,840
但猫，同时，
有一些附加的逻辑

1454
01:02:12,840 --> 01:02:18,250
上面写着this--第一，就这样
这不是完全偏

1455
01:02:18,250 --> 01:02:21,191
对鸟，注意到我
使用绿色拼图有

1456
01:02:21,191 --> 01:02:22,690
实际上选取一个随机数。

1457
01:02:22,690 --> 01:02:26,179
许多语言的一个特点是给
你随机或伪随机数。

1458
01:02:26,179 --> 01:02:29,220
因此，在这种情况下，猫最初
选择之间，如一个随机数，

1459
01:02:29,220 --> 01:02:31,727
90度和180
度，基本上，这样

1460
01:02:31,727 --> 01:02:33,310
这有偏差一点点。

1461
01:02:33,310 --> 01:02:37,000
然后永远，如果感人
鸟，玩狮子的声音。

1462
01:02:37,000 --> 01:02:38,754
否则，只需朝鸟点。

1463
01:02:38,754 --> 01:02:39,670
朝鸟点。

1464
01:02:39,670 --> 01:02:44,199
点朝向鸟，这是一个
拼图本身就是在这种情况下。

1465
01:02:44,199 --> 01:02:45,740
好了，我们可以在这里做的一件事。

1466
01:02:45,740 --> 01:02:49,820
让我在这里开辟活动计划。

1467
01:02:49,820 --> 01:02:53,520
在这里，我们再次有两个精灵，
这看起来像在这里这两个傀儡。

1468
01:02:53,520 --> 01:02:55,710
而有趣的是这里这个。

1469
01:02:55,710 --> 01:02:59,140
橙色的家伙有这
一套拼图在这里。

1470
01:02:59,140 --> 01:03:01,700
永远做following--
如果按下空格键，

1471
01:03:01,700 --> 01:03:05,430
然后说，马可，和
再播事件。

1472
01:03:05,430 --> 01:03:09,460
而与此同时，蓝色的家伙在这里有
当您收到事件this--，

1473
01:03:09,460 --> 01:03:10,540
说马球。

1474
01:03:10,540 --> 01:03:12,850
因此，原来的划痕
和其它语言，

1475
01:03:12,850 --> 01:03:15,830
有两个节目的方式
或两个脚本，在这种情况下，

1476
01:03:15,830 --> 01:03:20,310
要互通，这样，当我
敲空格键，他说马可。

1477
01:03:20,310 --> 01:03:23,539
而另一听见，所以
说话，和Polo说，在响应。

1478
01:03:23,539 --> 01:03:26,080
所以，你可以编写程序
实际上以这种方式进行交互。

1479
01:03:26,080 --> 01:03:28,630
如果我做这一块，而不是，
我甚至可以添加变量，

1480
01:03:28,630 --> 01:03:31,287
只是用在这种情况下，一个精灵。

1481
01:03:31,287 --> 01:03:32,578
这一次是特别烦人。

1482
01:03:32,578 --> 01:03:36,174
>> [SEAL BARKING]

1483
01:03:36,174 --> 01:03:37,100

1484
01:03:37,100 --> 01:03:42,490
>> 现在，右侧的通知，我们已经得到了
在这里一些额外的逻辑。

1485
01:03:42,490 --> 01:03:45,146
如何从吠叫制止这种密封？

1486
01:03:45,146 --> 01:03:48,320
>> [SEAL BARKING]

1487
01:03:48,320 --> 01:03:52,830

1488
01:03:52,830 --> 01:03:55,630
>> 它看起来像在右手
一边是正在播放的声音。

1489
01:03:55,630 --> 01:03:58,500
但它只是一个打
声若什么是真的吗？

1490
01:03:58,500 --> 01:04:03,390
如果一个变量 - 橙色
block--静音为零。

1491
01:04:03,390 --> 01:04:07,916
如何更改静音为1，
意思是真实的，使这个静音？

1492
01:04:07,916 --> 01:04:12,455
显然，其他的剧本，我可以
按下空格键，现在他停止。

1493
01:04:12,455 --> 01:04:15,080
因此，我们可以有这样的互通
跨脚本，以及，

1494
01:04:15,080 --> 01:04:18,349
只需共享变量
在两个这样的。

1495
01:04:18,349 --> 01:04:19,890
现在，这是不是所有的有趣。

1496
01:04:19,890 --> 01:04:24,360
让我们继续前进，这样做并结合
很多这些想法与此程序

1497
01:04:24,360 --> 01:04:25,940
这里。

1498
01:04:25,940 --> 01:04:28,100
之前我们这样做，不过，
怎么样一名志愿者？

1499
01:04:28,100 --> 01:04:30,558
让我以压断
我，因为我实际上并不

1500
01:04:30,558 --> 01:04:31,280
玩这个游戏。

1501
01:04:31,280 --> 01:04:33,030
让我们的人，我们
以前没有见过的。

1502
01:04:33,030 --> 01:04:36,420
你必须要舒适到来
在舞台上这里，在镜头前。

1503
01:04:36,420 --> 01:04:37,430
好了，上来吧。

1504
01:04:37,430 --> 01:04:38,130
很勇敢。

1505
01:04:38,130 --> 01:04:39,052
你叫什么名字？

1506
01:04:39,052 --> 01:04:39,962
>> 伊德里斯：伊德里斯。

1507
01:04:39,962 --> 01:04:40,753
DAVID MALAN：对不起？

1508
01:04:40,753 --> 01:04:41,196
伊德里斯：伊德里斯。

1509
01:04:41,196 --> 01:04:42,670
DAVID MALAN：伊德里斯，很高兴见到你。

1510
01:04:42,670 --> 01:04:43,170
上来吧。

1511
01:04:43,170 --> 01:04:45,630
而现在，在你自己的移动
手机，你玩口袋妖怪去？

1512
01:04:45,630 --> 01:04:46,567
>> 伊德里斯：否

1513
01:04:46,567 --> 01:04:47,400
DAVID MALAN：真的吗？

1514
01:04:47,400 --> 01:04:48,104
伊德里斯：是的。

1515
01:04:48,104 --> 01:04:48,770
DAVID MALAN：OK。

1516
01:04:48,770 --> 01:04:49,020
好吧。

1517
01:04:49,020 --> 01:04:49,978
很高兴见到你。

1518
01:04:49,978 --> 01:04:50,820
你过来吧。

1519
01:04:50,820 --> 01:04:51,950
我也不会。

1520
01:04:51,950 --> 01:04:55,380
因此，我们将一起找出如何
玩这个，其实它的人

1521
01:04:55,380 --> 01:05:00,140
去和划痕实施
通过改变猫基本上

1522
01:05:00,140 --> 01:05:02,260
不同的人物都在一起。

1523
01:05:02,260 --> 01:05:04,870
如果我全屏
这在这里，我们要

1524
01:05:04,870 --> 01:05:06,860
看看下面一起游戏。

1525
01:05:06,860 --> 01:05:09,560
仍在加载，加载还在。

1526
01:05:09,560 --> 01:05:10,270
来吧。

1527
01:05:10,270 --> 01:05:12,590
让我做到这一点。

1528
01:05:12,590 --> 01:05:14,520
来吧。

1529
01:05:14,520 --> 01:05:17,200
这场比赛是如此之大，它坠毁。

1530
01:05:17,200 --> 01:05:18,980
支持。

1531
01:05:18,980 --> 01:05:22,390
试试这一次。

1532
01:05:22,390 --> 01:05:23,710
来吧。

1533
01:05:23,710 --> 01:05:24,211
好吧。

1534
01:05:24,211 --> 01:05:26,840

1535
01:05:26,840 --> 01:05:27,430
>> 在那里，我们走了。

1536
01:05:27,430 --> 01:05:27,929
好。

1537
01:05:27,929 --> 01:05:29,330
绿旗。

1538
01:05:29,330 --> 01:05:30,190
所以在这里我们去。

1539
01:05:30,190 --> 01:05:30,950
>> [音乐]

1540
01:05:30,950 --> 01:05:32,510
>> 在此选择中等水平。

1541
01:05:32,510 --> 01:05:34,200
点击蓝色的家伙在那里。

1542
01:05:34,200 --> 01:05:34,700
好吧。

1543
01:05:34,700 --> 01:05:37,860
你也可以使用箭头
keys--上，下，左，右。

1544
01:05:37,860 --> 01:05:42,150
现在，让我们考虑一下，因为我们做this--
再有字符后去了。

1545
01:05:42,150 --> 01:05:42,650
是的。

1546
01:05:42,650 --> 01:05:45,786
现在，点击他的鼠标。

1547
01:05:45,786 --> 01:05:46,693
哦耶。

1548
01:05:46,693 --> 01:05:47,193
移动。

1549
01:05:47,193 --> 01:05:47,662
哪来的箭？

1550
01:05:47,662 --> 01:05:48,131
干得好。

1551
01:05:48,131 --> 01:05:48,600
所以点击那里。

1552
01:05:48,600 --> 01:05:48,840
是啊。

1553
01:05:48,840 --> 01:05:49,340
好吧。

1554
01:05:49,340 --> 01:05:56,008
所以，现在，我听说你有一个戳球，
如果点击它，它会做到这一点。

1555
01:05:56,008 --> 01:05:57,932
很好。

1556
01:05:57,932 --> 01:06:00,390
在练了今天，我
发现这个版本的游戏的

1557
01:06:00,390 --> 01:06:01,760
其实并不难。

1558
01:06:01,760 --> 01:06:07,650
所以，如果你想在这里又来了，
走这一捅球。

1559
01:06:07,650 --> 01:06:08,780
然后去右转。

1560
01:06:08,780 --> 01:06:11,200
试着点击就可以了。

1561
01:06:11,200 --> 01:06:13,120
呵呵，其实，这是
商店，显然。

1562
01:06:13,120 --> 01:06:14,170
OK，很接近。

1563
01:06:14,170 --> 01:06:15,150
在此之前从来没有做过。

1564
01:06:15,150 --> 01:06:16,566
也许去到这个东西在这里。

1565
01:06:16,566 --> 01:06:17,460
哦，你去那里。

1566
01:06:17,460 --> 01:06:18,910
等等，还有一那边。

1567
01:06:18,910 --> 01:06:20,412
哦，还有另一种。

1568
01:06:20,412 --> 01:06:21,285
好。

1569
01:06:21,285 --> 01:06:21,785
下。

1570
01:06:21,785 --> 01:06:23,210
是啊，请单击。

1571
01:06:23,210 --> 01:06:24,635
>> OK，这是非常可爱。

1572
01:06:24,635 --> 01:06:27,485

1573
01:06:27,485 --> 01:06:28,810
OK，非常出色。

1574
01:06:28,810 --> 01:06:30,010
这个游戏是不是很辛苦。

1575
01:06:30,010 --> 01:06:30,510
好。

1576
01:06:30,510 --> 01:06:32,150
恭喜。

1577
01:06:32,150 --> 01:06:34,720
在这里，我们有一个CS50
压力球给你。

1578
01:06:34,720 --> 01:06:37,680
但考虑一会儿就好了什么
一些外卖店都在那里。

1579
01:06:37,680 --> 01:06:39,263
不是真正的游戏更轻松，显然。

1580
01:06:39,263 --> 01:06:41,809
但这一切，我们应该继续
在这里是一个字符

1581
01:06:41,809 --> 01:06:44,100
这可能有某种
环的与它相关联。

1582
01:06:44,100 --> 01:06:44,590
这不是一只猫。

1583
01:06:44,590 --> 01:06:45,860
正是这种性格吧。

1584
01:06:45,860 --> 01:06:49,052
而这循环只是不断地
他说，如果向上箭头按下，

1585
01:06:49,052 --> 01:06:51,260
如果向下的箭头按下，如果
左箭头按下或向右

1586
01:06:51,260 --> 01:06:53,960
按下箭头，上移
或向下或向左或向右移动。

1587
01:06:53,960 --> 01:06:57,870
或者，如果有另一块拼图有
上面写着接触到另一个精灵的时候，

1588
01:06:57,870 --> 01:07:01,320
触摸的人物之一时，
要捅球，如果触摸，

1589
01:07:01,320 --> 01:07:02,440
然后做到这一点。

1590
01:07:02,440 --> 01:07:04,800
>> 因此，所有的我们已经思想
一直使用至今真的

1591
01:07:04,800 --> 01:07:09,130
可以只在该特定应用
上下文玩这个游戏，以及。

1592
01:07:09,130 --> 01:07:13,580
让我继续前进，拉
最多一个其他在这里，在事实。

1593
01:07:13,580 --> 01:07:17,060
让我继续前进，拉
起来，让我们说，这。

1594
01:07:17,060 --> 01:07:18,540
这是我们重新混音。

1595
01:07:18,540 --> 01:07:20,329
通过一种使我们
学生在剑桥，

1596
01:07:20,329 --> 01:07:23,370
然后我经历了和改变
哈佛的几乎每一个实例

1597
01:07:23,370 --> 01:07:25,580
耶鲁这个时候。

1598
01:07:25,580 --> 01:07:27,870
会有人喜欢
抗衡常春藤

1599
01:07:27,870 --> 01:07:31,650
这里的另一累积
所有这些想法？

1600
01:07:31,650 --> 01:07:32,662
下来吧，是的。

1601
01:07:32,662 --> 01:07:33,370
你叫什么名字？

1602
01:07:33,370 --> 01:07:34,190
>> DINA：迪娜。

1603
01:07:34,190 --> 01:07:35,015
>> DAVID MALAN：阿迪娜？

1604
01:07:35,015 --> 01:07:35,380
>> DINA：迪娜。

1605
01:07:35,380 --> 01:07:36,410
>> DAVID MALAN：迪娜，下来吧。

1606
01:07:36,410 --> 01:07:37,320
好吧，迪娜。

1607
01:07:37,320 --> 01:07:40,780
因此本场比赛变得更难，
更难，因为在这场比赛中，

1608
01:07:40,780 --> 01:07:43,970
有被用作油井变量
这是不断跟踪

1609
01:07:43,970 --> 01:07:45,930
什么水平你是在游戏中。

1610
01:07:45,930 --> 01:07:47,120
很高兴认识你。

1611
01:07:47,120 --> 01:07:48,250
这里过来。

1612
01:07:48,250 --> 01:07:51,460
所以，这里的目标排序
的让你的方式，通过一个迷宫

1613
01:07:51,460 --> 01:07:52,710
这个学生实施。

1614
01:07:52,710 --> 01:07:55,334
>> 而刚刚设置的舞台​​，每
在屏幕上，这些照片

1615
01:07:55,334 --> 01:07:57,222
是它自己的精灵，它自己的特点。

1616
01:07:57,222 --> 01:07:59,680
所以，这些都是默认的猫，
但学生改变了他们

1617
01:07:59,680 --> 01:08:01,480
这里的各种常春藤徽标。

1618
01:08:01,480 --> 01:08:04,370
然后你会看到，只是
通过使用条件和循环

1619
01:08:04,370 --> 01:08:06,848
和功能多，你得到这个。

1620
01:08:06,848 --> 01:08:07,478
>> [音乐]

1621
01:08:07,478 --> 01:08:09,228
[MUSIC  - 哈默，“U不能碰
 这个”]

1622
01:08:09,228 --> 01:08:13,060

1623
01:08:13,060 --> 01:08:14,018
>> 是啊，OK。

1624
01:08:14,018 --> 01:08:17,371

1625
01:08:17,371 --> 01:08:20,110
是的，继续前进。

1626
01:08:20,110 --> 01:08:21,180
第一级是很容易。

1627
01:08:21,180 --> 01:08:22,554
你刚刚去那边。

1628
01:08:22,554 --> 01:08:25,644
但同样考虑，这仅仅是一个
循环监听箭头keys--

1629
01:08:25,644 --> 01:08:26,560
上下左右。

1630
01:08:26,560 --> 01:08:28,320
而现在一个感应块。

1631
01:08:28,320 --> 01:08:29,345
非常好。

1632
01:08:29,345 --> 01:08:32,600
>> [MUSIC  - 哈默，“U不能碰
 这个”]

1633
01:08:32,600 --> 01:08:40,340

1634
01:08:40,340 --> 01:08:41,288
>> 非常好。

1635
01:08:41,288 --> 01:08:44,550
>> [MUSIC  - 哈默，“U不能碰
 这个”]

1636
01:08:44,550 --> 01:08:55,540

1637
01:08:55,540 --> 01:08:56,430
>> 非常好。

1638
01:08:56,430 --> 01:08:57,975
很简单，深红。

1639
01:08:57,975 --> 01:08:59,060
好吧。

1640
01:08:59,060 --> 01:09:00,250
呃几层哦。

1641
01:09:00,250 --> 01:09:02,380
>> [MUSIC  - 哈默，“U不能碰
 这个”]

1642
01:09:02,380 --> 01:09:04,980

1643
01:09:04,980 --> 01:09:07,150
>> 再次，在这些
3哈佛波峰，

1644
01:09:07,150 --> 01:09:10,334
你只需要逻辑
如果边缘，反弹说。

1645
01:09:10,334 --> 01:09:13,238
>> [MUSIC  - 哈默，“U不能碰
 这个”]

1646
01:09:13,238 --> 01:09:14,690

1647
01:09:14,690 --> 01:09:17,651
>> OK，你在做什么
为什么不是更有趣。

1648
01:09:17,651 --> 01:09:18,150
非常好。

1649
01:09:18,150 --> 01:09:18,810
非常好。

1650
01:09:18,810 --> 01:09:20,270
嗯，哦。

1651
01:09:20,270 --> 01:09:23,350
>> [MUSIC  - 哈默，“U不能碰
 这个”]

1652
01:09:23,350 --> 01:09:26,005

1653
01:09:26,005 --> 01:09:27,630
我认为你必须牺牲自己。

1654
01:09:27,630 --> 01:09:30,372
[MUSIC  - 哈默，“U不能碰
 这个”]

1655
01:09:30,372 --> 01:09:30,872
快！

1656
01:09:30,872 --> 01:09:34,848

1657
01:09:34,848 --> 01:09:38,824
>> [MUSIC  - 哈默，“U不能碰
 这个”]

1658
01:09:38,824 --> 01:09:44,288

1659
01:09:44,288 --> 01:09:44,788
尼斯。

1660
01:09:44,788 --> 01:09:52,240

1661
01:09:52,240 --> 01:09:52,740
没关系。

1662
01:09:52,740 --> 01:09:53,770
你会得到它。

1663
01:09:53,770 --> 01:09:56,304
是的是的！

1664
01:09:56,304 --> 01:09:58,256
非常好。

1665
01:09:58,256 --> 01:10:01,184
>> [欢呼声]

1666
01:10:01,184 --> 01:10:02,160

1667
01:10:02,160 --> 01:10:05,576
>> [MUSIC  - 哈默，“U不能碰
 这个”]

1668
01:10:05,576 --> 01:10:09,480

1669
01:10:09,480 --> 01:10:10,940
>> 太好了！

1670
01:10:10,940 --> 01:10:14,370
>> [MUSIC  - 哈默，“U不能碰
 这个”]

1671
01:10:14,370 --> 01:10:39,050

1672
01:10:39,050 --> 01:10:39,550
得到它了。

1673
01:10:39,550 --> 01:10:41,510
来吧！

1674
01:10:41,510 --> 01:10:43,470
倒数第二的水平。

1675
01:10:43,470 --> 01:10:46,900
>> [MUSIC  - 哈默，“U不能碰
 这个”]

1676
01:10:46,900 --> 01:10:49,588

1677
01:10:49,588 --> 01:10:50,580
>> 好吧。

1678
01:10:50,580 --> 01:10:54,052
>> [MUSIC  - 哈默，“U不能碰
 这个”]

1679
01:10:54,052 --> 01:11:00,992

1680
01:11:00,992 --> 01:11:01,492
是。

1681
01:11:01,492 --> 01:11:06,230

1682
01:11:06,230 --> 01:11:08,020
良好的使用变量在这里。

1683
01:11:08,020 --> 01:11:09,770
[MUSIC  - 哈默，“U不能碰
 这个”]

1684
01:11:09,770 --> 01:11:10,770
是。

1685
01:11:10,770 --> 01:11:14,743
[MUSIC  - 哈默，“U不能碰
 这个”]

1686
01:11:14,743 --> 01:11:16,707

1687
01:11:16,707 --> 01:11:17,689
尼斯。

1688
01:11:17,689 --> 01:11:21,126
[MUSIC  - 哈默，“U不能碰
 这个”]

1689
01:11:21,126 --> 01:11:23,581

1690
01:11:23,581 --> 01:11:24,570
没关系。

1691
01:11:24,570 --> 01:11:25,770
我们一定要到达终点。

1692
01:11:25,770 --> 01:11:26,270
那里。

1693
01:11:26,270 --> 01:11:27,010
哦!

1694
01:11:27,010 --> 01:11:29,980
>> [MUSIC  - 哈默，“U不能碰
 这个”]

1695
01:11:29,980 --> 01:11:32,160

1696
01:11:32,160 --> 01:11:34,866
>> 可能会遇到今天晚了，但
这会是值得的。

1697
01:11:34,866 --> 01:11:38,200
>> [MUSIC  - 哈默，“U不能碰
 这个”]

1698
01:11:38,200 --> 01:11:39,640

1699
01:11:39,640 --> 01:11:42,520
>> 你能行的！

1700
01:11:42,520 --> 01:11:43,480
是啊！

1701
01:11:43,480 --> 01:11:46,278
>> [欢呼声]

1702
01:11:46,278 --> 01:11:47,230

1703
01:11:47,230 --> 01:11:50,086
>> [MUSIC  - 哈默，“U不能碰
 这个”]

1704
01:11:50,086 --> 01:11:51,470
>> 这一次真的很难。

1705
01:11:51,470 --> 01:11:54,070
>> [MUSIC  - 哈默，“U不能碰
 这个”]

1706
01:11:54,070 --> 01:11:57,458

1707
01:11:57,458 --> 01:11:59,000
>> 我们会给你们两个更多的生命。

1708
01:11:59,000 --> 01:11:59,968
你可以做到吗？

1709
01:11:59,968 --> 01:12:03,356
>> [MUSIC  - 哈默，“U不能碰
 这个”]

1710
01:12:03,356 --> 01:12:06,744

1711
01:12:06,744 --> 01:12:07,244
>> 好吧。

1712
01:12:07,244 --> 01:12:09,160
如何又大又圆
掌声不过。

1713
01:12:09,160 --> 01:12:10,800
你得倒数第二级。

1714
01:12:10,800 --> 01:12:11,723
谢谢。

1715
01:12:11,723 --> 01:12:14,964
>> [掌声]

1716
01:12:14,964 --> 01:12:15,890

1717
01:12:15,890 --> 01:12:19,600
>> 所以，这只是说多少你
可以用这些各种各样的事情要做。

1718
01:12:19,600 --> 01:12:21,892
并实现，那就是，当
拼图不exist--

1719
01:12:21,892 --> 01:12:24,891
而事实上，这是打算当
与第一问题的权力

1720
01:12:24,891 --> 01:12:27,080
集和beyond--是
实际创建你自己的。

1721
01:12:27,080 --> 01:12:28,860
而这仅仅是一个片段
的例子之一

1722
01:12:28,860 --> 01:12:30,230
你就可以玩
在线，其中

1723
01:12:30,230 --> 01:12:33,380
如果你没有内置划痕
像咳嗽一块拼图，

1724
01:12:33,380 --> 01:12:35,470
实际上你可以自己做到这一点。

1725
01:12:35,470 --> 01:12:37,387
>> 所以，这一切，更等待着。

1726
01:12:37,387 --> 01:12:39,470
而刚刚画最后
确实有什么图片

1727
01:12:39,470 --> 01:12:43,120
未来在商店为类的你，
根据来自同学的一些照片

1728
01:12:43,120 --> 01:12:46,970
过去，请允许我昏暗的灯光
最后一次，告诉你CS50。

1729
01:12:46,970 --> 01:12:49,580

1730
01:12:49,580 --> 01:12:53,038
>> [音乐]

1731
01:12:53,038 --> 01:14:38,210

1732
01:14:38,210 --> 01:14:38,860
>> 好吧。

1733
01:14:38,860 --> 01:14:41,540
以上就是CS50。

1734
01:14:41,540 --> 01:14:44,964
蛋糕现在担任。

1735
01:14:44,964 --> 01:14:50,610

1736
01:14:50,610 --> 01:14:53,960
>> [音乐]

1737
01:14:53,960 --> 01:15:07,624