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]