1
00:00:00,000 --> 00:00:02,640
[Powered by Google Translate] [讲座：技术访谈]

2
00:00:02,640 --> 00:00:04,630
[肯尼于哈佛大学]

3
00:00:04,630 --> 00:00:08,910
这是CS50。[CS50.TV]

4
00:00:08,910 --> 00:00:12,420
大家好，我是肯尼。我目前正在一个初中学习计算机科学。

5
00:00:12,420 --> 00:00:17,310
我是一个CS TF前，我希望我有这个当我是低年级，

6
00:00:17,310 --> 00:00:19,380
这就是为什么我给本次研讨会。

7
00:00:19,380 --> 00:00:21,370
所以，我希望你喜欢它。

8
00:00:21,370 --> 00:00:23,470
本次研讨会是技术面试，

9
00:00:23,470 --> 00:00:26,650
和我所有的资源，可以发现在这个环节，

10
00:00:26,650 --> 00:00:32,350
此链接在这里，一对夫妇的资源。

11
00:00:32,350 --> 00:00:36,550
所以，我提出的问题清单，实际上，不少问题。

12
00:00:36,550 --> 00:00:40,800
另外，一般的资源页面，在这里我们可以找到提示

13
00:00:40,800 --> 00:00:42,870
如何准备接受记者采访时，

14
00:00:42,870 --> 00:00:46,470
提示在实际的采访中你应该做的，

15
00:00:46,470 --> 00:00:51,910
以及如何处理问题和资源，以备将来参考。

16
00:00:51,910 --> 00:00:53,980
这一切都在网上。

17
00:00:53,980 --> 00:00:58,290
而就在前言本次研讨会，免责声明，

18
00:00:58,290 --> 00:01:00,690
这样不应该 - 你的面试准备

19
00:01:00,690 --> 00:01:02,800
不应该被限制到该列表。

20
00:01:02,800 --> 00:01:04,750
这只是意味着是一个指南，

21
00:01:04,750 --> 00:01:08,890
你一定要我说的一切与一粒盐，

22
00:01:08,890 --> 00:01:14,620
而且还用我来帮助你在你的面试准备的一切。

23
00:01:14,620 --> 00:01:16,400
>> 我要加速通过下面的几张幻灯片

24
00:01:16,400 --> 00:01:18,650
因此，我们可以得到的实际案例研究。

25
00:01:18,650 --> 00:01:23,630
结构的软件工程现在的位置接受记者采访时，

26
00:01:23,630 --> 00:01:26,320
它通常是30到45分钟，

27
00:01:26,320 --> 00:01:29,810
多轮，根据公司。

28
00:01:29,810 --> 00:01:33,090
你经常会在白板上进行编码。

29
00:01:33,090 --> 00:01:35,960
因此，这样的白板，但往往在一个较小的规模。

30
00:01:35,960 --> 00:01:38,540
如果你有一个接受电话采访时，你可能会被使用

31
00:01:38,540 --> 00:01:44,030
collabedit或一个谷歌文档，这样他们就可以看到你住的编码

32
00:01:44,030 --> 00:01:46,500
当你通过电话采访。

33
00:01:46,500 --> 00:01:48,490
接受记者采访时本身通常是2个或3个问题

34
00:01:48,490 --> 00:01:50,620
测试您的计算机科学知识。

35
00:01:50,620 --> 00:01:54,490
它几乎肯定会涉及编码。

36
00:01:54,490 --> 00:01:59,540
的问题的类型，你会看到通常是数据结构和算法。

37
00:01:59,540 --> 00:02:02,210
而在做这些各种各样的问题，

38
00:02:02,210 --> 00:02:07,830
，他们会问你喜欢什么，是时间和空间复杂度，大O？

39
00:02:07,830 --> 00:02:09,800
通常情况下，他们也要求更高层次的问题，

40
00:02:09,800 --> 00:02:12,530
这样，设计系统时，

41
00:02:12,530 --> 00:02:14,770
你怎么会躺在你的代码吗？

42
00:02:14,770 --> 00:02:18,370
什么样的接口，哪个班的，你有什么模块在您的系统，

43
00:02:18,370 --> 00:02:20,900
怎么互动起来呢？

44
00:02:20,900 --> 00:02:26,130
因此，数据结构和算法，以及设计系统。

45
00:02:26,130 --> 00:02:29,180
>> 一些通用的技巧之前，我们深入到我们的案例研究。

46
00:02:29,180 --> 00:02:32,300
我认为最重要的规则总是在想大声。

47
00:02:32,300 --> 00:02:36,980
采访应该是你的机会来炫耀你的思维过程。

48
00:02:36,980 --> 00:02:39,820
在接受记者采访时的点是面试官评估

49
00:02:39,820 --> 00:02:42,660
你怎么想的，你​​如何去通过一个问题。

50
00:02:42,660 --> 00:02:45,210
在整个采访中，最糟糕的事情你能做的就是保持沉默。

51
00:02:45,210 --> 00:02:50,090
这只是没有好。

52
00:02:50,090 --> 00:02:53,230
当你一个问题，你要确保你明白的问题。

53
00:02:53,230 --> 00:02:55,350
因此，重复的问题，早在你自己的话

54
00:02:55,350 --> 00:02:58,920
并尝试工作的深入一些简单的测试用例

55
00:02:58,920 --> 00:03:01,530
以确保您了解的问题。

56
00:03:01,530 --> 00:03:05,510
通过一些测试案例，也会给你一个如何解决这个问题的直觉。

57
00:03:05,510 --> 00:03:11,210
你甚至可能发现一些模式，以帮助您解决问题。

58
00:03:11,210 --> 00:03:14,500
他们的大秘诀是不要沮丧。

59
00:03:14,500 --> 00:03:17,060
不要沮丧。

60
00:03:17,060 --> 00:03:19,060
面试是具有挑战性的，但你可以做的最糟糕的事情，

61
00:03:19,060 --> 00:03:23,330
除了沉默，是明显受挫。

62
00:03:23,330 --> 00:03:27,410
你不想给你那种印象的面试官。

63
00:03:27,410 --> 00:03:33,960
有一件事你 - 所以，很多人，当他们进入接受记者采访时，

64
00:03:33,960 --> 00:03:37,150
他们试图尝试找到最好的解决方案，

65
00:03:37,150 --> 00:03:39,950
当真的，通常一个有目共睹的解决方案。

66
00:03:39,950 --> 00:03:43,500
它可能是缓慢的，它可能是低效的，但你应该只说明它，

67
00:03:43,500 --> 00:03:46,210
只要你有一个起点，更好地工作。

68
00:03:46,210 --> 00:03:48,270
同时，指出了解决的办法是缓慢的，在

69
00:03:48,270 --> 00:03:52,160
大O时间复杂度和空间复杂度，

70
00:03:52,160 --> 00:03:54,450
将展示给面试官，你明白

71
00:03:54,450 --> 00:03:57,510
这些问题在编写代码时。

72
00:03:57,510 --> 00:04:01,440
所以，不要怕先拿出最简单的算法

73
00:04:01,440 --> 00:04:04,950
，然后从那里。

74
00:04:04,950 --> 00:04:09,810
有任何疑问，这么远吗？好吧。

75
00:04:09,810 --> 00:04:11,650
>> 因此，让我们深入到我们的第一个问题。

76
00:04:11,650 --> 00:04:14,790
“给定一个数组，n为整数，写一个函数，打乱数组

77
00:04:14,790 --> 00:04:20,209
等地方的所有排列的n个整数同样有可能。“

78
00:04:20,209 --> 00:04:23,470
假设你有一个随机整数发生器

79
00:04:23,470 --> 00:04:30,980
生成的范围内的整数，从0到i，一半范围。

80
00:04:30,980 --> 00:04:32,970
每个人都理解这个问题呢？

81
00:04:32,970 --> 00:04:39,660
我给你n个整数的数组，我希望你能洗牌。

82
00:04:39,660 --> 00:04:46,050
在我的目录，我写了几个方案，以证明我的意思。

83
00:04:46,050 --> 00:04:48,910
我要洗牌的20个元素的数组，

84
00:04:48,910 --> 00:04:52,490
从-10到+9，

85
00:04:52,490 --> 00:04:57,050
我要你这样输出的列表。

86
00:04:57,050 --> 00:05:02,890
所以这是我已排序的数组中，我希望你能洗牌。

87
00:05:02,890 --> 00:05:07,070
我们将继续这样做。

88
00:05:07,070 --> 00:05:13,780
每个人都明白的问题吗？好吧。

89
00:05:13,780 --> 00:05:16,730
所以这是给你的。

90
00:05:16,730 --> 00:05:21,220
有哪些想法？你能做到这为n ^ 2，N日志N，N？

91
00:05:21,220 --> 00:05:34,400
开放的建议。

92
00:05:34,400 --> 00:05:37,730
好吧。因此，一个想法，建议由艾美奖，

93
00:05:37,730 --> 00:05:45,300
是第一计算一个随机数，随机整数，从0到20的范围内。

94
00:05:45,300 --> 00:05:49,840
因此，假设我们的数组的长度为20。

95
00:05:49,840 --> 00:05:54,800
在我们的20个元素的图，

96
00:05:54,800 --> 00:05:58,560
这是我们的输入数组。

97
00:05:58,560 --> 00:06:04,590
而现在，她的建议是，创建一个新的阵列，

98
00:06:04,590 --> 00:06:08,440
所以这将是输出数组中。

99
00:06:08,440 --> 00:06:12,880
并在此基础上，我回到兰特 - 

100
00:06:12,880 --> 00:06:17,580
所以，如果我是，比方说，17日，

101
00:06:17,580 --> 00:06:25,640
复制17到第一位置的元件。

102
00:06:25,640 --> 00:06:30,300
现在，我们需要删除 - 我们需要将所有元素

103
00:06:30,300 --> 00:06:36,920
过来，使我们有一定的差距结束时，中间没有孔。

104
00:06:36,920 --> 00:06:39,860
现在，我们重复这个过程。

105
00:06:39,860 --> 00:06:46,360
现在，我们选择一个新的0和19之间的随机整数。

106
00:06:46,360 --> 00:06:52,510
我们有一个新的我在这里，和我们这个元素复制到这个位置。

107
00:06:52,510 --> 00:07:00,960
然后我们转移项目结束，我们重复这个过程，直到我们有充分的新的阵列。

108
00:07:00,960 --> 00:07:05,890
该算法的运行时间是什么？

109
00:07:05,890 --> 00:07:08,110
那么，让我们来看看这方面的影响。

110
00:07:08,110 --> 00:07:10,380
我们的每一个元素转移。

111
00:07:10,380 --> 00:07:16,800
当我们除去这个，我，我们将所有的元素后，到左边。

112
00:07:16,800 --> 00:07:21,600
这是一个O（n）的成本

113
00:07:21,600 --> 00:07:26,100
因为如果我们删除第一个元素？

114
00:07:26,100 --> 00:07:29,670
因此，对于每个删除，我们会删除 - 

115
00:07:29,670 --> 00:07:32,170
每次删除会导致O（n）操作，

116
00:07:32,170 --> 00:07:41,520
，因为我们有n清除，这将导致一个O（N ^ 2）洗牌。

117
00:07:41,520 --> 00:07:49,550
好吧。因此，良好的开端。良好的开端。

118
00:07:49,550 --> 00:07:55,290
>> 另一项建议是使用一种被称为高德纳洗牌，

119
00:07:55,290 --> 00:07:57,540
或费雪耶茨洗牌的。

120
00:07:57,540 --> 00:07:59,630
它实际上是一个线性时间的洗牌。

121
00:07:59,630 --> 00:08:02,200
的想法是非常相似的。

122
00:08:02,200 --> 00:08:05,160
同样，我们有我们的输入数组，

123
00:08:05,160 --> 00:08:08,580
但我们的输入/输出，而不是使用两个数组，

124
00:08:08,580 --> 00:08:13,590
我们使用的第一部分的阵列来跟踪我们的混洗部，

125
00:08:13,590 --> 00:08:18,400
我们跟踪，然后我们离开的其余我们的阵列的unshuffled部分的。

126
00:08:18,400 --> 00:08:24,330
因此，这里是我的意思。我们开始 - 我们选择的我，

127
00:08:24,330 --> 00:08:30,910
从0到20的一个数组。

128
00:08:30,910 --> 00:08:36,150
我们当前的指针指向第一个索引。

129
00:08:36,150 --> 00:08:39,590
我们选择了一些我在这里

130
00:08:39,590 --> 00:08:42,740
现在我们交换。

131
00:08:42,740 --> 00:08:47,690
因此，如果这是5，这是4，

132
00:08:47,690 --> 00:08:57,150
生成的数组将有5个在这里和这里。

133
00:08:57,150 --> 00:09:00,390
现在，我们注意到这里的标志。

134
00:09:00,390 --> 00:09:05,770
一切的左侧洗牌，

135
00:09:05,770 --> 00:09:15,160
是unshuffled的一切权利。

136
00:09:15,160 --> 00:09:17,260
现在，我们可以重复这个过程。

137
00:09:17,260 --> 00:09:25,210
我们选择一个1到20之间的随机指数现在。

138
00:09:25,210 --> 00:09:30,650
因此，假设我们的新的，我是在这里。

139
00:09:30,650 --> 00:09:39,370
现在，我们交换这方面，我在这里与我们目前的新位置。

140
00:09:39,370 --> 00:09:44,790
所以，我们做了这样的交换来回。

141
00:09:44,790 --> 00:09:51,630
让我的代码，使之更加具体。

142
00:09:51,630 --> 00:09:55,290
我们从我们的选择我 - 

143
00:09:55,290 --> 00:09:58,370
我们开始与我等于0，我们选择一个随机的位置j

144
00:09:58,370 --> 00:10:02,420
在unshuffled一部分阵列，i到n-1。

145
00:10:02,420 --> 00:10:07,280
所以，如果我在这里，在这里，其余的阵列之间选择一个随机指数，

146
00:10:07,280 --> 00:10:12,410
和我们交换。

147
00:10:12,410 --> 00:10:17,550
这是所有的代码需要重新洗牌您的阵列。

148
00:10:17,550 --> 00:10:21,670
有什么问题吗？

149
00:10:21,670 --> 00:10:25,530
>> 那么，一个需要的问题是，为什么这是正确的吗？

150
00:10:25,530 --> 00:10:28,360
为什么每个排列同样有可能吗？

151
00:10:28,360 --> 00:10:30,410
我不会去通过证明了这一点，

152
00:10:30,410 --> 00:10:35,970
但在计算机科学的许多问题可以证明，通过诱导。

153
00:10:35,970 --> 00:10:38,520
你们有多少人是熟悉的感应吗？

154
00:10:38,520 --> 00:10:40,590
好吧。酷。

155
00:10:40,590 --> 00:10:43,610
所以，你可以通过简单的归纳证明该算法的正确性，

156
00:10:43,610 --> 00:10:49,540
归纳假设，假设

157
00:10:49,540 --> 00:10:53,290
我的iPod Shuffle将返回每个置换同样可能

158
00:10:53,290 --> 00:10:56,120
到第i个元素。

159
00:10:56,120 --> 00:10:58,300
现在，我+ 1。

160
00:10:58,300 --> 00:11:02,550
我们选择我们的指标j交换的方式，

161
00:11:02,550 --> 00:11:05,230
这导致了 - 然后你工作的细节，

162
00:11:05,230 --> 00:11:07,390
至少充分证明了该算法返回的原因

163
00:11:07,390 --> 00:11:12,800
每个排列以同样可能的概率。

164
00:11:12,800 --> 00:11:15,940
>> 好吧，下一个问题。

165
00:11:15,940 --> 00:11:19,170
因此，“给定一个整数数组，阳性，零，负，

166
00:11:19,170 --> 00:11:21,290
写一个函数，计算的最高金额

167
00:11:21,290 --> 00:11:24,720
的的任何continueous子数组的输入数组。“

168
00:11:24,720 --> 00:11:28,370
这里的一个例子是，在所有的数字是正的情况下，

169
00:11:28,370 --> 00:11:31,320
那么目前最好的选择是采取全阵列。

170
00:11:31,320 --> 00:11:34,690
1，2，3，4，等于10。

171
00:11:34,690 --> 00:11:36,780
当你有一些底片，在那里，

172
00:11:36,780 --> 00:11:38,690
在这种情况下，我们只是想第一

173
00:11:38,690 --> 00:11:44,590
因为选择-1和/或-3带给我们的一笔。

174
00:11:44,590 --> 00:11:48,120
有时候，我们可能要开始的数组中。

175
00:11:48,120 --> 00:11:53,500
有时候，我们要选择什么都没有，最好不要采取任何。

176
00:11:53,500 --> 00:11:56,490
有时，它采取的秋天，

177
00:11:56,490 --> 00:12:07,510
因为事情后，超级大。因此，任何想法吗？

178
00:12:07,510 --> 00:12:10,970
（学生，不知所云）>>呀。

179
00:12:10,970 --> 00:12:13,560
如果我不采取-1。

180
00:12:13,560 --> 00:12:16,170
任我选择1000和20000，

181
00:12:16,170 --> 00:12:18,630
我只是选择了3亿美元。

182
00:12:18,630 --> 00:12:20,760
那么，最好的选择是把所有的数字。

183
00:12:20,760 --> 00:12:24,350
这个-1，尽管是消极的，

184
00:12:24,350 --> 00:12:31,340
整个的总和比我不采取-1。

185
00:12:31,340 --> 00:12:36,460
所以我前面提到的秘诀之一是要清楚地陈述明显

186
00:12:36,460 --> 00:12:40,540
和暴力的解决方法。

187
00:12:40,540 --> 00:12:44,340
蛮力解决方案，在这个问题上是什么？是吗？

188
00:12:44,340 --> 00:12:46,890
[简]嗯，我觉得蛮力解决方案

189
00:12:46,890 --> 00:12:52,600
将添加所有可能的组合（不知所云）。

190
00:12:52,600 --> 00:12:58,250
记者：好。因此，简的想法是采取一切可能的 - 

191
00:12:58,250 --> 00:13:01,470
我释义 - 是采取一切可能的连续子数组，

192
00:13:01,470 --> 00:13:07,840
计算其总和，然后采取所有可能的连续子数组的最大。

193
00:13:07,840 --> 00:13:13,310
什么唯一地标识一个在我的输入数组子数组？

194
00:13:13,310 --> 00:13:17,380
一样，我需要做两件事情吗？是吗？

195
00:13:17,380 --> 00:13:19,970
（学生，不知所云）>>右。

196
00:13:19,970 --> 00:13:22,130
指数和上界指标的下限

197
00:13:22,130 --> 00:13:28,300
唯一确定一个连续的子数组。

198
00:13:28,300 --> 00:13:31,400
[女学生]我们估计它是一个数组的唯一的数字？

199
00:13:31,400 --> 00:13:34,280
[于]第所以，她的问题是，我们假设我们的阵列 - 

200
00:13:34,280 --> 00:13:39,000
是我们的一系列独特的数字，答案是否定的。

201
00:13:39,000 --> 00:13:43,390
>> 如果我们用我们的蛮力解决方案，然后开始/结束指数

202
00:13:43,390 --> 00:13:47,200
我们唯一确定的连续子数组。

203
00:13:47,200 --> 00:13:51,680
因此，如果我们遍历所有可能的启动条目，

204
00:13:51,680 --> 00:13:58,320
所有项目>或=开始，和<N，

205
00:13:58,320 --> 00:14:05,570
你计算的金额，然后我们的最高金额，到目前为止，我们已经看到的。

206
00:14:05,570 --> 00:14:07,880
这是清楚了吗？

207
00:14:07,880 --> 00:14:12,230
该解决方案的大O是什么？

208
00:14:12,230 --> 00:14:16,660
在时间上。

209
00:14:16,660 --> 00:14:18,860
不太N ^ 2。

210
00:14:18,860 --> 00:14:25,250
请注意，我们遍历从0到n，

211
00:14:25,250 --> 00:14:27,520
所以这是一个用于环路。

212
00:14:27,520 --> 00:14:35,120
我们再次重复几乎从开始到结束，另一个循环。

213
00:14:35,120 --> 00:14:37,640
而现在，在那个，我们要总结每一个项目，

214
00:14:37,640 --> 00:14:43,810
所以这是一个循环。因此，我们有三个嵌套的for循环，n ^ 3个。

215
00:14:43,810 --> 00:14:46,560
好吧。这正好为出发点。

216
00:14:46,560 --> 00:14:53,180
我们的解决方案是毫不逊色于N ^ 3。

217
00:14:53,180 --> 00:14:55,480
每个人都明白的蛮力解决方案吗？

218
00:14:55,480 --> 00:14:59,950
>> 好吧。一个更好的解决方案是使用的动态规划的想法。

219
00:14:59,950 --> 00:15:03,040
如果你把CS124，这是算法和数据结构，

220
00:15:03,040 --> 00:15:05,680
用这种方法，你就会变得很熟悉。

221
00:15:05,680 --> 00:15:12,190
的想法是，尝试建立小问题的解决方案，以第一。

222
00:15:12,190 --> 00:15:17,990
我的意思是，我们目前担心两件事情：开始和结束。

223
00:15:17,990 --> 00:15:29,340
很烦人。如果我们能够摆脱这些参数之一，怎么办？

224
00:15:29,340 --> 00:15:32,650
一个想法是 - 我们给我们原来的问题，

225
00:15:32,650 --> 00:15:37,470
找到任何子阵列的范围内的最大总和[O，n-1个]。

226
00:15:37,470 --> 00:15:47,400
现在，我们有一个新的子问题，在这里我们知道，在我们目前的索引i，

227
00:15:47,400 --> 00:15:52,520
我们知道我们必须得出结论。我们的子数组必须结束当前索引。

228
00:15:52,520 --> 00:15:57,640
因此，剩下的问题是，我们应该在哪里开始我们的子数组？

229
00:15:57,640 --> 00:16:05,160
这有意义吗？好吧。

230
00:16:05,160 --> 00:16:12,030
所以，我编码这件事，让我们来看看这是什么意思。

231
00:16:12,030 --> 00:16:16,230
在的codirectory，有一个程序叫子阵，

232
00:16:16,230 --> 00:16:19,470
和需要的项目数，

233
00:16:19,470 --> 00:16:25,550
在我拖着列表，它返回的最大子数组的总和。

234
00:16:25,550 --> 00:16:29,920
因此，在这种情况下，我们的最大子阵列是3。

235
00:16:29,920 --> 00:16:34,850
而这只是用2和1的采取。

236
00:16:34,850 --> 00:16:38,050
让我们再次运行它。这也是3。

237
00:16:38,050 --> 00:16:40,950
但是这一次，注意我们是如何走到3。

238
00:16:40,950 --> 00:16:46,690
我们采取了 - 我们只取3本身

239
00:16:46,690 --> 00:16:49,980
因为它的四周底片两侧，

240
00:16:49,980 --> 00:16:55,080
这将带来一个总和<3。

241
00:16:55,080 --> 00:16:57,820
让我们运行10个项目。

242
00:16:57,820 --> 00:17:03,200
这一次，它是7，我们以领先的3和4。

243
00:17:03,200 --> 00:17:09,450
这一次它是8，和我们得到通过服用1，4及3。

244
00:17:09,450 --> 00:17:16,310
所以如何给你的直觉就可以解决这个转变的问题，

245
00:17:16,310 --> 00:17:18,890
让我们来看看在这个子数组。

246
00:17:18,890 --> 00:17:23,460
我们在此输入数组，我们知道，答案是8。

247
00:17:23,460 --> 00:17:26,359
我们以1，4，和3。

248
00:17:26,359 --> 00:17:29,090
但是让我们看看我们如何实际上得到答案。

249
00:17:29,090 --> 00:17:34,160
让我们来看看在最大的子数组的结束，这些指标。

250
00:17:34,160 --> 00:17:40,780
什么是最大的子数组，结束在第一个位置？

251
00:17:40,780 --> 00:17:46,310
[学生]：零。 >>零。只要不采取-5。

252
00:17:46,310 --> 00:17:50,210
这里将是0。是吗？

253
00:17:50,210 --> 00:17:56,470
（学生，不知所云）

254
00:17:56,470 --> 00:17:58,960
记者：哦，对不起，这是一个-3。

255
00:17:58,960 --> 00:18:03,220
因此，这是一个2，这是一个-3。

256
00:18:03,220 --> 00:18:08,690
好吧。因此，-4，什么是最大的子数组结束位置

257
00:18:08,690 --> 00:18:12,910
-4是在哪里呢？零。

258
00:18:12,910 --> 00:18:22,570
一？ 1，5，8。

259
00:18:22,570 --> 00:18:28,060
现在，我必须结束在位置-2是。

260
00:18:28,060 --> 00:18:39,330
因此，6，5，7，和最后一个是4。

261
00:18:39,330 --> 00:18:43,480
要知道，这些都是我的作品

262
00:18:43,480 --> 00:18:48,130
转换的问题，在这里我必须结束这些指标，

263
00:18:48,130 --> 00:18:51,410
然后我最后的答案是，一个横扫，

264
00:18:51,410 --> 00:18:53,580
的最大数量。

265
00:18:53,580 --> 00:18:55,620
因此，在这种情况下，它的8。

266
00:18:55,620 --> 00:19:00,010
这意味着最大的子阵列端部在这个索引，

267
00:19:00,010 --> 00:19:04,970
和以前在什么地方开始。

268
00:19:04,970 --> 00:19:09,630
每个人都明白这个转换的子数组？

269
00:19:09,630 --> 00:19:22,160
>> 好吧。那么，让我们来看看复发。

270
00:19:22,160 --> 00:19:27,990
让我们只考虑前几个项目。

271
00:19:27,990 --> 00:19:35,930
因此，这里是0，0，0，1，5，8。

272
00:19:35,930 --> 00:19:39,790
然后是-2这里，并把它下降到6。

273
00:19:39,790 --> 00:19:50,800
所以，如果我调用的入口位置，我子问题（一）

274
00:19:50,800 --> 00:19:54,910
我怎么能使用到以前的子问题的答案

275
00:19:54,910 --> 00:19:59,360
以回答此子？

276
00:19:59,360 --> 00:20:04,550
如果我看，让我们说，此项目。

277
00:20:04,550 --> 00:20:09,190
看我怎样才能计算出答案6

278
00:20:09,190 --> 00:20:18,780
阵列和前面的子问题的答案，此数组中的组合？是吗？

279
00:20:18,780 --> 00:20:22,800
[女学生]你把阵列的款项

280
00:20:22,800 --> 00:20:25,430
的位置，所以，

281
00:20:25,430 --> 00:20:32,170
然后添加在当前子。

282
00:20:32,170 --> 00:20:36,460
记者：所以她的建议是看这两个数字，

283
00:20:36,460 --> 00:20:40,090
这个数目和此号码。

284
00:20:40,090 --> 00:20:50,130
所以这个8指的是子问题的答案（I  -  1）。

285
00:20:50,130 --> 00:20:57,300
让我们叫我输入数组A.

286
00:20:57,300 --> 00:21:01,470
为了找到一个最大的子数组，我结束位置，

287
00:21:01,470 --> 00:21:03,980
我有两个选择：我可以继续的子数组

288
00:21:03,980 --> 00:21:09,790
结束在上一个索引，或者开始一个新的数组。

289
00:21:09,790 --> 00:21:14,190
如果我继续开始在以前的指数的子数组，

290
00:21:14,190 --> 00:21:19,260
然后我可以达到的最高金额是前面的子问题的答案

291
00:21:19,260 --> 00:21:24,120
加上当前的数组项。

292
00:21:24,120 --> 00:21:27,550
但是，我也可以选择开始一个新的子阵，

293
00:21:27,550 --> 00:21:30,830
在这种情况下的总和为0。

294
00:21:30,830 --> 00:21:42,860
因此，答案是，子问题我最大的0  -  1，再加上目前的数组项。

295
00:21:42,860 --> 00:21:46,150
这是否复发有意义吗？

296
00:21:46,150 --> 00:21:50,840
我们的复发，我们刚刚发现的部分问题是，我

297
00:21:50,840 --> 00:21:54,740
是等于前面的子加我最大的数组项，

298
00:21:54,740 --> 00:22:01,490
这意味着继续前面的子阵，

299
00:22:01,490 --> 00:22:07,250
或0，在我目前的指数开始一个新的子阵。

300
00:22:07,250 --> 00:22:10,060
一旦我们建立这个表的解决方案，那么我们最终的答案，

301
00:22:10,060 --> 00:22:13,950
只是做了一个线性扫描整个子问题阵列

302
00:22:13,950 --> 00:22:19,890
的最大数量。

303
00:22:19,890 --> 00:22:23,330
我刚才说的，这是一个确切的实施。

304
00:22:23,330 --> 00:22:27,320
因此，我们创建了一个新的子问题阵列，子。

305
00:22:27,320 --> 00:22:32,330
第一项是0或第一个条目，这两个最大。

306
00:22:32,330 --> 00:22:35,670
而对于其余的子

307
00:22:35,670 --> 00:22:39,810
我们使用我们刚刚发现的确切复发。

308
00:22:39,810 --> 00:22:49,960
现在我们计算我们的子阵列的最大的，这就是我们最终的答案。

309
00:22:49,960 --> 00:22:54,130
>> 所以多大的空间，我们在该算法中使用吗？

310
00:22:54,130 --> 00:23:01,470
如果你只有采取CS50，那么你可能没有讨论的空间很大。

311
00:23:01,470 --> 00:23:07,750
嗯，有一点要注意的是，我这里称为malloc的大小为n。

312
00:23:07,750 --> 00:23:13,590
给你什么建议吗？

313
00:23:13,590 --> 00:23:17,450
该算法采用线性空间。

314
00:23:17,450 --> 00:23:21,030
我们可以做的更好吗？

315
00:23:21,030 --> 00:23:30,780
有您发现来计算最终的答案是不必要的？

316
00:23:30,780 --> 00:23:33,290
我想一个更好的问题是，什么样的信息

317
00:23:33,290 --> 00:23:40,680
我们需要随身携带，一路过关斩将，到最后呢？

318
00:23:40,680 --> 00:23:44,280
现在，如果我们看这两条线，

319
00:23:44,280 --> 00:23:47,720
我们只关心前面的子，

320
00:23:47,720 --> 00:23:50,910
我们只关心我们见过的最大的，到目前为止。

321
00:23:50,910 --> 00:23:53,610
为了计算我们最终的答案，我们不需要整个阵列。

322
00:23:53,610 --> 00:23:57,450
我们只需要在最后一个号码，最后两个数字。

323
00:23:57,450 --> 00:24:02,630
最后的是，一阶数组，最后一个数字的最大数量。

324
00:24:02,630 --> 00:24:07,380
因此，事实上，我们可以融合这些循环

325
00:24:07,380 --> 00:24:10,460
从线性空间不变的空间。

326
00:24:10,460 --> 00:24:15,830
目前的总和到目前为止，在这里，替换子问题，子问题阵列的作用。

327
00:24:15,830 --> 00:24:20,020
因此，目前的总和，到目前为止，前面的子问题的答案。

328
00:24:20,020 --> 00:24:23,450
而这一笔，到目前为止，以我们最大的地方。

329
00:24:23,450 --> 00:24:28,100
我们计算最大的，因为我们走。

330
00:24:28,100 --> 00:24:30,890
因此，我们从线性空间不变的空间，

331
00:24:30,890 --> 00:24:36,650
我们也有一个线性的解决方案，我们的子数组的问题。

332
00:24:36,650 --> 00:24:40,740
>> 这些类型的问题，你会得到在接受记者采访时。

333
00:24:40,740 --> 00:24:44,450
是什么时间复杂度，空间复杂度是什么？

334
00:24:44,450 --> 00:24:50,600
你可以做的更好吗？是否有不必要的事情是保持周围吗？

335
00:24:50,600 --> 00:24:55,270
我这样做是为了突出自己的分析，你应该考虑

336
00:24:55,270 --> 00:24:57,400
你的工作，通过这些问题。

337
00:24:57,400 --> 00:25:01,710
应始终问自己，“我可以做的更好？”

338
00:25:01,710 --> 00:25:07,800
事实上，我们可以做的比这更好的吗？

339
00:25:07,800 --> 00:25:10,730
排序的一个棘手的问题。你不能，因为你需要

340
00:25:10,730 --> 00:25:13,590
至少读取输入的问题。

341
00:25:13,590 --> 00:25:15,570
因此，事实上，你需要至少读取输入的问题

342
00:25:15,570 --> 00:25:19,580
意味着你不能做的更好不是线性的时间，

343
00:25:19,580 --> 00:25:22,870
你不能这样做比恒定的空间。

344
00:25:22,870 --> 00:25:27,060
因此，这是，事实上，此问题的最佳解决方案。

345
00:25:27,060 --> 00:25:33,040
有问题吗？好吧。

346
00:25:33,040 --> 00:25:35,190
>> 股市的问题：

347
00:25:35,190 --> 00:25:38,350
“n个整数，正的，零或负的给定一个数组，

348
00:25:38,350 --> 00:25:41,680
代表n天的股票价格，

349
00:25:41,680 --> 00:25:44,080
写一个函数来计算最大的利润，你可以使

350
00:25:44,080 --> 00:25:49,350
因为你买入和卖出股票在n天正好是1。“

351
00:25:49,350 --> 00:25:51,690
从本质上讲，我们希望低买高卖。

352
00:25:51,690 --> 00:25:58,580
我们要找出我们可以做最好的利润。

353
00:25:58,580 --> 00:26:11,500
让我们回到我的头，什么是立即清除，最简单的答案，但它的速度慢？

354
00:26:11,500 --> 00:26:17,690
是吗？ （学生，不知所云）“是的。

355
00:26:17,690 --> 00:26:21,470
“等你去你看股票价格

356
00:26:21,470 --> 00:26:30,550
在每个时间点上，（不知所云）。

357
00:26:30,550 --> 00:26:33,990
记者：好了，所以她的解决方案 - 她的建议的计算

358
00:26:33,990 --> 00:26:37,380
最低和计算最高不工作

359
00:26:37,380 --> 00:26:42,470
因为之前可能会出现的最高最低。

360
00:26:42,470 --> 00:26:47,340
那么，什么是蛮力解决这个问题呢？

361
00:26:47,340 --> 00:26:53,150
什么是两件事情，我需要唯一确定的利润，我做吗？右。

362
00:26:53,150 --> 00:26:59,410
蛮力解决方案是 - 哦，所以，我们只需要两天，乔治的建议是

363
00:26:59,410 --> 00:27:02,880
唯一地确定这两天的利润。

364
00:27:02,880 --> 00:27:06,660
因此，我们计算每对，喜欢买/卖，

365
00:27:06,660 --> 00:27:12,850
计算的利润，这可能是负数或正数或零。

366
00:27:12,850 --> 00:27:18,000
计算后遍历所有天对我们最大的利润。

367
00:27:18,000 --> 00:27:20,330
这将是我们最后的答案。

368
00:27:20,330 --> 00:27:25,730
该解决方案将是O（N ^ 2），这是因为n选择2对 - 

369
00:27:25,730 --> 00:27:30,270
，你可以选择结束日期之间的天数。

370
00:27:30,270 --> 00:27:32,580
好了，所以我不打算在这里走了过来蛮力解决方案。

371
00:27:32,580 --> 00:27:37,420
我要告诉你，有一个n日志n解决方案。

372
00:27:37,420 --> 00:27:45,550
什么样的算法你知道这是n日志n？

373
00:27:45,550 --> 00:27:50,730
这是一个棘手的问题。

374
00:27:50,730 --> 00:27:54,790
>> 合并排序。合并排序是n日志n，

375
00:27:54,790 --> 00:27:57,760
而事实上，解决这个问题的一种方式是使用

376
00:27:57,760 --> 00:28:04,400
合并排序样的想法，要求，在一般情况下，分而治之。

377
00:28:04,400 --> 00:28:07,570
其思想是，如下所示。

378
00:28:07,570 --> 00:28:12,400
你想计算出最佳的买/卖对的左半边。

379
00:28:12,400 --> 00:28:16,480
你可以做，只是用了为期两天的第n寻找最佳的利润。

380
00:28:16,480 --> 00:28:19,780
然后，你要oompute最好的买/卖对的右半部分，

381
00:28:19,780 --> 00:28:23,930
所以最后n超过两天。

382
00:28:23,930 --> 00:28:32,400
现在的问题是，我们如何合并这些解决方案一起回来吗？

383
00:28:32,400 --> 00:28:36,320
是吗？ （学生，不知所云）

384
00:28:36,320 --> 00:28:49,890
“好了。因此，让我画一幅画。

385
00:28:49,890 --> 00:29:03,870
是吗？ （乔治，不知所云）

386
00:29:03,870 --> 00:29:06,450
“没错。乔治的解决方案是完全正确的。

387
00:29:06,450 --> 00:29:10,040
因此，他的建议是，首先计算出最佳的买入/卖出一双，

388
00:29:10,040 --> 00:29:16,050
中出现的左半边，让我们的呼吁，左，从左到右。

389
00:29:16,050 --> 00:29:20,790
百思买/卖对发生在右半。

390
00:29:20,790 --> 00:29:25,180
但是，如果我们只比较这两个数字，我们缺少的情况下

391
00:29:25,180 --> 00:29:30,460
在我们这里买和卖的地方的右半边。

392
00:29:30,460 --> 00:29:33,810
我们买的左半边，销售于右半边。

393
00:29:33,810 --> 00:29:38,490
而最好的方法计算出最佳的买入/卖出对跨越两半

394
00:29:38,490 --> 00:29:43,480
是计算出最小在这里和在这里计算的最大

395
00:29:43,480 --> 00:29:45,580
它们的区别。

396
00:29:45,580 --> 00:29:50,850
因此，在两种情况下，买/卖对只发生在这里，

397
00:29:50,850 --> 00:30:01,910
只有在这里，这三个数字被定义为两半。

398
00:30:01,910 --> 00:30:06,450
因此，我们的算法，我们的解决方案合并到一起，

399
00:30:06,450 --> 00:30:08,350
我们要计算出最佳的买入/卖出对

400
00:30:08,350 --> 00:30:13,120
在我们的左半边买和卖的右半部分。

401
00:30:13,120 --> 00:30:16,740
而最好的方式做到这一点是上半年最低的价格来计算，

402
00:30:16,740 --> 00:30:20,360
在右半边，最高价和它们的区别。

403
00:30:20,360 --> 00:30:25,390
由此产生的利润，这三个数字，你最大的三个，

404
00:30:25,390 --> 00:30:32,720
这是最好的利润，你可以对这些开始和结束的日子里。

405
00:30:32,720 --> 00:30:36,940
在这里，重要的线是红色的。

406
00:30:36,940 --> 00:30:41,160
这是一个递归调用计算的左半边中的回答。

407
00:30:41,160 --> 00:30:44,760
这是一个递归调用计算的右半部分中的回答。

408
00:30:44,760 --> 00:30:50,720
这些两个for循环计算上的左和右半边的最小和最大，分别。

409
00:30:50,720 --> 00:30:54,970
现在，我计算的利润，跨越了两半，

410
00:30:54,970 --> 00:31:00,530
和最后的答案是这三个最大。

411
00:31:00,530 --> 00:31:04,120
好吧。

412
00:31:04,120 --> 00:31:06,420
>> 所以，肯定的是，我们有一个算法，但更大的问题是，

413
00:31:06,420 --> 00:31:08,290
的时间复杂度是什么？

414
00:31:08,290 --> 00:31:16,190
为什么我提到合并排序的原因是，这种形式的分裂的答案

415
00:31:16,190 --> 00:31:19,200
一分为二，然后合并我们的解决方案

416
00:31:19,200 --> 00:31:23,580
正是归并排序的形式。

417
00:31:23,580 --> 00:31:33,360
所以，让我去的时间。

418
00:31:33,360 --> 00:31:41,340
如果我们定义了一个函数的t（n）的步骤数

419
00:31:41,340 --> 00:31:50,010
n天，

420
00:31:50,010 --> 00:31:54,350
我们的两个递归调用

421
00:31:54,350 --> 00:32:00,460
每个要花费T（N / 2），

422
00:32:00,460 --> 00:32:03,540
和这些调用。

423
00:32:03,540 --> 00:32:10,020
现在我需要计算出最小的左半部分，

424
00:32:10,020 --> 00:32:17,050
我可以做n / 2的时间，再加上​​最大的右半边。

425
00:32:17,050 --> 00:32:20,820
所以，这仅仅是N。

426
00:32:20,820 --> 00:32:25,050
然后再加上一些经常性工作。

427
00:32:25,050 --> 00:32:27,770
而这个递推公式

428
00:32:27,770 --> 00:32:35,560
正是归并排序的递推方程。

429
00:32:35,560 --> 00:32:39,170
我们都知道，归并排序是n日志n时间。

430
00:32:39,170 --> 00:32:46,880
因此，我们的算法也n日志n。

431
00:32:46,880 --> 00:32:52,220
本次迭代中是否有意义吗？

432
00:32:52,220 --> 00:32:55,780
只是一个简单回顾一下：

433
00:32:55,780 --> 00:32:59,170
T（N）的步数计算最大的利润

434
00:32:59,170 --> 00:33:02,750
超过n天的过程中。

435
00:33:02,750 --> 00:33:06,010
这样，我们分手了递归调用

436
00:33:06,010 --> 00:33:11,980
是第n / 2天致电我们的解决方案，

437
00:33:11,980 --> 00:33:14,490
所以这是一个电话，

438
00:33:14,490 --> 00:33:16,940
然后我们再次呼吁对下半年。

439
00:33:16,940 --> 00:33:20,440
所以，这两个通话。

440
00:33:20,440 --> 00:33:25,310
然后，我们找到一个最低的左半边，这是我们可以做的线性时间，

441
00:33:25,310 --> 00:33:29,010
发现的最大的右半边，这是我们可以做的线性时间。

442
00:33:29,010 --> 00:33:31,570
因此n / 2 + n / 2个是仅仅局限于N。

443
00:33:31,570 --> 00:33:36,020
然后，我们有一些固定的工作，这是像做算术。

444
00:33:36,020 --> 00:33:39,860
这个递推公式是完全合并排序的递推方程。

445
00:33:39,860 --> 00:33:55,490
因此，我们的洗牌算法是n日志n。

446
00:33:55,490 --> 00:33:58,520
因此，我们使用了多少空间？

447
00:33:58,520 --> 00:34:04,910
让我们回去的代码。

448
00:34:04,910 --> 00:34:09,420
>> 一个更好的问题是，多少个堆栈帧，我们曾经有在任何给定的时刻吗？

449
00:34:09,420 --> 00:34:11,449
因为我们使用了递归，

450
00:34:11,449 --> 00:34:23,530
堆栈帧的数量决定了我们的空间使用情况。

451
00:34:23,530 --> 00:34:29,440
让我们考虑n = 8。

452
00:34:29,440 --> 00:34:36,889
我们称之为洗牌月8日，

453
00:34:36,889 --> 00:34:41,580
这将调用洗牌的前四个条目，

454
00:34:41,580 --> 00:34:46,250
这将调用一个洗牌的前两个项目。

455
00:34:46,250 --> 00:34:51,550
因此，我们的协议栈是 - 这是我们的协议栈。

456
00:34:51,550 --> 00:34:54,980
然后，我们呼吁再次洗牌月1日，

457
00:34:54,980 --> 00:34:58,070
这就是我们的基本情况是，所以我们立即返回。

458
00:34:58,070 --> 00:35:04,700
我们有更多的比这多的栈帧吗？

459
00:35:04,700 --> 00:35:08,880
因为每次我们做了一个调用，

460
00:35:08,880 --> 00:35:10,770
的递归调用重新洗牌，

461
00:35:10,770 --> 00:35:13,950
我们把我们的规模的一半。

462
00:35:13,950 --> 00:35:17,020
因此，堆栈帧的最大数量，我们有过在任何给定的时刻

463
00:35:17,020 --> 00:35:28,460
是的日志n的栈帧顺序。

464
00:35:28,460 --> 00:35:42,460
每个堆栈帧具有恒定的空间，

465
00:35:42,460 --> 00:35:44,410
因此，总的空间量，

466
00:35:44,410 --> 00:35:49,240
我们曾经使用过的最大空间量是O（log n）的空间

467
00:35:49,240 --> 00:36:03,040
其中n是的天数。

468
00:36:03,040 --> 00:36:07,230
>> 现在，要问自己，“我们可以做的更好？”

469
00:36:07,230 --> 00:36:12,390
特别是，我们可以减少这种一个问题，我们已经解决了吗？

470
00:36:12,390 --> 00:36:20,040
一个提示：我们只讨论两个问题，在此之前，它不会被洗牌。

471
00:36:20,040 --> 00:36:26,200
我们可以把这个股市的问题，最大的子数组的问题。

472
00:36:26,200 --> 00:36:40,100
如何才能做到这一点呢？

473
00:36:40,100 --> 00:36:42,570
你们中的一个吗？艾美奖吗？

474
00:36:42,570 --> 00:36:47,680
（艾美奖，不知所云）

475
00:36:47,680 --> 00:36:53,860
记者：没错。

476
00:36:53,860 --> 00:36:59,940
因此，最大的子数组的问题，

477
00:36:59,940 --> 00:37:10,610
我们正在寻找一笔，在一个连续的子数组。

478
00:37:10,610 --> 00:37:16,230
和艾美奖的股票问题的建议，，

479
00:37:16,230 --> 00:37:30,720
考虑更改，或三角洲。

480
00:37:30,720 --> 00:37:37,440
和图片，这是 - 这是一个股票的价格，

481
00:37:37,440 --> 00:37:42,610
但如果我们采取了连续两天之间的差异 - 

482
00:37:42,610 --> 00:37:45,200
所以我们看到的最高价格，最大的利润，我们可以使

483
00:37:45,200 --> 00:37:50,070
如果我们在这里买和卖在这里。

484
00:37:50,070 --> 00:37:54,240
但是让我们看看在连续 - 让我们来看看子数组的问题。

485
00:37:54,240 --> 00:38:02,510
所以在这里，我们可以 - 从这里到这里，

486
00:38:02,510 --> 00:38:08,410
我们有一个积极的变化，然后再从这里到这里，我们有一个负面的变化。

487
00:38:08,410 --> 00:38:14,220
但是，然后，从这里到这里，我们有一个巨大的积极变化。

488
00:38:14,220 --> 00:38:20,930
这些变化，我们要总结，让我们的最终利润。

489
00:38:20,930 --> 00:38:25,160
然后，我们在这里有更多的负面变化。

490
00:38:25,160 --> 00:38:29,990
我们最大的子数组的问题的关键在于减少我们的库存问题

491
00:38:29,990 --> 00:38:36,630
考虑天之间的增量。

492
00:38:36,630 --> 00:38:40,630
因此，我们创建了一个新的数组三角洲，

493
00:38:40,630 --> 00:38:43,000
初始化为0的第一个条目，

494
00:38:43,000 --> 00:38:46,380
，然后为每个三角洲（I），那一定是在差异

495
00:38:46,380 --> 00:38:52,830
我的输入数组（I），和数组（I  -  1）。

496
00:38:52,830 --> 00:38:55,530
然后，我们呼吁我们的常规程序的最大子数组

497
00:38:55,530 --> 00:39:01,500
通过三角洲的阵列中。

498
00:39:01,500 --> 00:39:06,440
而且，由于最大的子数组是线性时间，

499
00:39:06,440 --> 00:39:09,370
这种减少，在这个过程中，创建此增量阵列，

500
00:39:09,370 --> 00:39:11,780
也是线性的时间，

501
00:39:11,780 --> 00:39:19,060
那么股票的最终解决方案是O（n）的工作，加上O（n）的工作，仍然是O（n）的工作。

502
00:39:19,060 --> 00:39:23,900
因此，我们有一个线性时间解决我们的问题。

503
00:39:23,900 --> 00:39:29,610
是否每个人都明白这个转变？

504
00:39:29,610 --> 00:39:32,140
>> 在一般情况下，一个好主意，你应该始终有

505
00:39:32,140 --> 00:39:34,290
尽量减少一个新的问题，你看到。

506
00:39:34,290 --> 00:39:37,700
如果它看起来很像一个老问题，

507
00:39:37,700 --> 00:39:39,590
请尝试降低到一个老问题。

508
00:39:39,590 --> 00:39:41,950
如果你能使用所有的工具，你已经使用的老问题

509
00:39:41,950 --> 00:39:46,450
要解决的新问题。

510
00:39:46,450 --> 00:39:49,010
因此，包装，技术面试是具有挑战性的。

511
00:39:49,010 --> 00:39:52,280
这些问题可能​​是一些比较困难的问题

512
00:39:52,280 --> 00:39:54,700
你可能会看到在接受记者采访时，

513
00:39:54,700 --> 00:39:57,690
所以，如果你不明白，我只是涵盖的所有问题，也没关系。

514
00:39:57,690 --> 00:40:01,080
这些是一些更有挑战性的问题。

515
00:40:01,080 --> 00:40:03,050
实践，实践，再实践。

516
00:40:03,050 --> 00:40:08,170
我给了很多的讲义中存在的问题，所以一定要检查出这些。

517
00:40:08,170 --> 00:40:11,690
祝你好运，你的采访。我所有的资源都贴在这个环节，

518
00:40:11,690 --> 00:40:15,220
我的高中朋友提供了做模拟技术访谈

519
00:40:15,220 --> 00:40:22,050
所以，如果你有兴趣，电子邮件将姚明的电子邮件地址。

520
00:40:22,050 --> 00:40:26,070
如果你有问题，你可以问我。

521
00:40:26,070 --> 00:40:28,780
你们是否有具体问题，相关技术访谈

522
00:40:28,780 --> 00:40:38,440
到目前为止，我们已经看到的任何问题？

523
00:40:38,440 --> 00:40:49,910
好吧。那么你的采访，祝你好运。

524
00:40:49,910 --> 00:40:52,910
[CS50.TV]