1
00:00:00,000 --> 00:00:10,982

2
00:00:10,982 --> 00:00:11,940
大衛馬蘭：好吧。

3
00:00:11,940 --> 00:00:16,470
所以這是CS50，這是
現在3週的開始。

4
00:00:16,470 --> 00:00:19,960
>> 所以到現在為止，我們已經
在寫程序用C

5
00:00:19,960 --> 00:00:23,210
這看起來有點
這樣的事情在這裡。

6
00:00:23,210 --> 00:00:25,470
所以，我們有幾個
尖銳包括在頂部。

7
00:00:25,470 --> 00:00:28,490
我們已經得到了詮釋，主要的，無效的，並
然後事情做在中間，

8
00:00:28,490 --> 00:00:30,590
一些代碼位內
的該功能。

9
00:00:30,590 --> 00:00:34,170
但重點一直事實
我們一直在說空在這裡。

10
00:00:34,170 --> 00:00:39,320
因此作廢，這一切的時候，指定
這個程序在運行時，

11
00:00:39,320 --> 00:00:41,300
只能通過其名稱來運行。

12
00:00:41,300 --> 00:00:46,330
你不能輸入其他文字或
該程序的名稱時數後，

13
00:00:46,330 --> 00:00:46,830
運行它。

14
00:00:46,830 --> 00:00:51,200
因此，例如，如果節目是
編譯成一個名為hello的文件，

15
00:00:51,200 --> 00:00:53,480
你可以做./hello，但就是這樣。

16
00:00:53,480 --> 00:00:56,750
>> 唯一的辦法，你可以
提供輸入到該程序

17
00:00:56,750 --> 00:00:57,960
是通過調用一個函數。

18
00:00:57,960 --> 00:00:59,790
例如，什麼功能
使用迄今還我們一直

19
00:00:59,790 --> 00:01:00,950
以獲得來自用戶的輸入？

20
00:01:00,950 --> 00:01:02,117
>> 聽眾：獲取字符串。

21
00:01:02,117 --> 00:01:04,700
大衛馬蘭：要獲得字符串，或
得到int或你見過其他人，

22
00:01:04,700 --> 00:01:07,630
即使你沒有使用它們，
喜歡弄長，長，等等。

23
00:01:07,630 --> 00:01:09,380
但是，假如我們
其實要開始

24
00:01:09,380 --> 00:01:12,760
編寫程序是多一點
多才多藝，而且，坦率地說，多一點

25
00:01:12,760 --> 00:01:15,090
就像你已經命令
已經越來越有希望，

26
00:01:15,090 --> 00:01:16,550
有點習慣了。

27
00:01:16,550 --> 00:01:18,560
如CD空間的Dropbox。

28
00:01:18,560 --> 00:01:20,800
此，當然，改變
您的目錄，假設

29
00:01:20,800 --> 00:01:23,590
你在約翰·哈佛的家
目錄到你的Dropbox文件夾。

30
00:01:23,590 --> 00:01:27,380
同時，這樣的命令
創建一個名為pset2新目錄，

31
00:01:27,380 --> 00:01:30,290
正如你可能已經或
很快就會在問題設置兩個。

32
00:01:30,290 --> 00:01:33,970
當然，做出餵，是一個命令
即建立了一項名為招呼

33
00:01:33,970 --> 00:01:35,770
從一個叫你好點C文件。

34
00:01:35,770 --> 00:01:39,140
和在每個這些
的情況下，現在，我們已經有

35
00:01:39,140 --> 00:01:43,620
在所謂的提供參數
命令行中，閃爍提示，

36
00:01:43,620 --> 00:01:48,540
讓化妝知道要建什麼，等等
這MKDIR知道文件夾的創建，

37
00:01:48,540 --> 00:01:51,110
和使坎德拉知道
您想去的地方。

38
00:01:51,110 --> 00:01:54,720
但是到現在為止，我們一直在說
在主，您的默認功能，

39
00:01:54,720 --> 00:01:58,500
有一個空洞的表達
這些括號內，

40
00:01:58,500 --> 00:02:01,250
這意味著它
不帶任何參數。

41
00:02:01,250 --> 00:02:03,240
>> 所以，從今天起，
我們要做些什麼

42
00:02:03,240 --> 00:02:06,270
是，我們要開始
支持這樣的事情，甚至。

43
00:02:06,270 --> 00:02:08,990
事實上，在這種情況下，你
通常不手動輸入，

44
00:02:08,990 --> 00:02:11,130
讓一直在做這
對我們來說，有沒有

45
00:02:11,130 --> 00:02:15,840
之一，但一個，兩個，三個附加
之後，該程序的命名字符串

46
00:02:15,840 --> 00:02:16,850
鐺。

47
00:02:16,850 --> 00:02:18,240
那麼，如何才能做到這一點？

48
00:02:18,240 --> 00:02:20,260
>> 好了，從今天開始，
在這裡我們要案件

49
00:02:20,260 --> 00:02:22,855
通過提供輸入
所謂的命令行

50
00:02:22,855 --> 00:02:24,980
我們要開始添加
這裡什麼在yellow--

51
00:02:24,980 --> 00:02:30,520
與詮釋的argc逗號代替無效
字符串argv的左括號右括號。

52
00:02:30,520 --> 00:02:32,520
現在，這是有趣的
一對夫婦的原因。

53
00:02:32,520 --> 00:02:35,690
一，這將讓我們寫
程序是多了幾分動感。

54
00:02:35,690 --> 00:02:37,570
不過，更令人信服，
這將打開

55
00:02:37,570 --> 00:02:40,340
現在的對話，以
什麼陣列可真

56
00:02:40,340 --> 00:02:43,300
可以使用，什麼串
真的是引擎蓋下方，

57
00:02:43,300 --> 00:02:47,320
等到下星期我們開始跳水
在更深層次，以機器是如何

58
00:02:47,320 --> 00:02:48,590
讓所有這些東西的工作。

59
00:02:48,590 --> 00:02:51,920
但現在，讓我們來畫，
也許，一個圖片。

60
00:02:51,920 --> 00:02:54,950
>> 當你寫一個程序
與主聲明

61
00:02:54,950 --> 00:02:58,810
以這種方式，使得主
有兩個參數，一個int

62
00:02:58,810 --> 00:03:03,233
還有 - 什麼樣的數據類型
是第二個參數？

63
00:03:03,233 --> 00:03:04,529
>> 聽眾：陣列。

64
00:03:04,529 --> 00:03:05,320
大衛馬蘭：陣列。

65
00:03:05,320 --> 00:03:09,170
所以，第一眼看上去就像是一個
字符串，但要注意的方括號。

66
00:03:09,170 --> 00:03:12,760
還記得我們去年推出的時間
陣列的概念。

67
00:03:12,760 --> 00:03:16,210
和數組使用方括號
在幾個場合。

68
00:03:16,210 --> 00:03:19,160
您可以使用方
括號去到一個數組

69
00:03:19,160 --> 00:03:22,710
並獲得一個特定的元素，如
支架0或1架或支架2。

70
00:03:22,710 --> 00:03:25,500
但是我們看到，如果簡單地說，
上週，你也

71
00:03:25,500 --> 00:03:28,790
使用這些方括號
聲明數組的大小，

72
00:03:28,790 --> 00:03:31,790
如果你事先知道有多少個整數
或者有多少字符串或任何你

73
00:03:31,790 --> 00:03:32,630
其實想。

74
00:03:32,630 --> 00:03:34,790
因此，原來有
這裡三分之一的上下文

75
00:03:34,790 --> 00:03:37,890
這裡面有沒有一些
方括號。

76
00:03:37,890 --> 00:03:41,920
當你指定，因為我這裡有，
的類似的argv名稱，

77
00:03:41,920 --> 00:03:44,550
這只是一種奇特的方式
話說參數向量，這

78
00:03:44,550 --> 00:03:47,750
是另一種奇特的方式
說的參數數組，

79
00:03:47,750 --> 00:03:50,870
開放式托架右方括號只是
意味著你不一定

80
00:03:50,870 --> 00:03:52,960
預先知道有多大
該陣列將是，

81
00:03:52,960 --> 00:03:55,070
但你知道這將是一個數組。

82
00:03:55,070 --> 00:03:57,320
所以，如果你不知道的
一些不把它放在那裡，

83
00:03:57,320 --> 00:04:01,160
開放式托架右方括號
也就是說argv是不是一個字符串，

84
00:04:01,160 --> 00:04:03,124
但一個字符串數組。

85
00:04:03,124 --> 00:04:05,040
所以，語法，如果你
回想上週，

86
00:04:05,040 --> 00:04:09,460
這是非常相似的說法
像整型年齡開支架，

87
00:04:09,460 --> 00:04:10,984
再以後的東西。

88
00:04:10,984 --> 00:04:12,150
那麼，這是什麼樣子的呢？

89
00:04:12,150 --> 00:04:13,399
讓我們來實際繪製的圖片。

90
00:04:13,399 --> 00:04:18,756
所以，當你運行這個程序有主
有兩個參數中定義

91
00:04:18,756 --> 00:04:21,339
這些括號的，你
本質上具有至少兩個組塊

92
00:04:21,339 --> 00:04:23,560
內存就交給你了
引擎蓋下方。

93
00:04:23,560 --> 00:04:26,550
一，我會為繪製這個矩形，
將要被調用的argc。

94
00:04:26,550 --> 00:04:30,645
而只是作為一個快速回顧一下，
什麼是ARGC的數據類型？

95
00:04:30,645 --> 00:04:31,270
所以這是一個int。

96
00:04:31,270 --> 00:04:33,480
因此，一些會
走在argc--圈

97
00:04:33,480 --> 00:04:35,660
出代表參數計數。

98
00:04:35,660 --> 00:04:38,887
同時，我畫的argv為數組。

99
00:04:38,887 --> 00:04:40,970
我真的不知道
多久將是，

100
00:04:40,970 --> 00:04:42,470
所以對於今天的目的，點點點。

101
00:04:42,470 --> 00:04:43,636
它可能會得到一些長度。

102
00:04:43,636 --> 00:04:45,640
但我在這裡想像
至少四個矩形。

103
00:04:45,640 --> 00:04:50,970
所以的argv內存存儲塊
串串串點點點，

104
00:04:50,970 --> 00:04:53,950
和ARGC只是一大塊
的存儲器為一個整數。

105
00:04:53,950 --> 00:04:55,710
>> 所以，現在，讓我們可以更確切的一點。

106
00:04:55,710 --> 00:04:59,200
如果，當我有串
在這個數組，稱為

107
00:04:59,200 --> 00:05:03,290
ARGV，我想向他們
單獨的，就像上​​週，

108
00:05:03,290 --> 00:05:05,670
我們將要使用的符號
像argv的支架0

109
00:05:05,670 --> 00:05:07,650
拿到的第一件事數組。

110
00:05:07,650 --> 00:05:10,440
ARGV支架1得到
第二件事情，等等。

111
00:05:10,440 --> 00:05:14,597
這裡的關鍵是，我們還在0
indexed--我們仍然從0開始計數。

112
00:05:14,597 --> 00:05:16,430
所以，現在讓我們來實際
裝上去的。

113
00:05:16,430 --> 00:05:21,670
如果我要編譯一個調用程序
你好，從一個叫你好點C文件，

114
00:05:21,670 --> 00:05:24,340
然後我運行的程序
用點斜線您好，

115
00:05:24,340 --> 00:05:28,380
什麼我的電腦，我的筆記本電腦，
像機罩下方

116
00:05:28,380 --> 00:05:31,300
那一刻我跑點
濕地打招呼，敲回車？

117
00:05:31,300 --> 00:05:33,500
那麼，這也許是
我們可以描述

118
00:05:33,500 --> 00:05:37,010
為您的計算機的內容
存儲器，或RAM--隨機存取存儲器。

119
00:05:37,010 --> 00:05:40,330
換句話說，計算機
不知怎麼給你神奇，

120
00:05:40,330 --> 00:05:45,360
放入的argc數字1，AKA argcount，
它把字面上的字符串

121
00:05:45,360 --> 00:05:48,200
./hello argv中支架0。

122
00:05:48,200 --> 00:05:51,750
我不知道，坦白地說，有什麼
argv中托架1或2或3，

123
00:05:51,750 --> 00:05:55,550
因為如果用戶具有不
什麼類型除了./hello，

124
00:05:55,550 --> 00:05:58,550
我們將假定這些
最有可能的垃圾值

125
00:05:58,550 --> 00:05:59,700
可以這麼說。

126
00:05:59,700 --> 00:06:02,650
內存塊的那些
存在的，但它不是我們

127
00:06:02,650 --> 00:06:05,710
看著他們，因為
該argcount是唯一的一個。

128
00:06:05,710 --> 00:06:07,870
>> 現在，同時，如果我
編寫運行另一個程序，

129
00:06:07,870 --> 00:06:12,250
CD，這是更適當的命令時，
在你眨眼prompt-- CD的空間

130
00:06:12,250 --> 00:06:17,200
當我運行，有效地Dropbox--，
光盤程序運行時，argc個，

131
00:06:17,200 --> 00:06:22,270
我的計算機的內存裡面，是
最簡短的第二數字2。

132
00:06:22,270 --> 00:06:25,936
然後argv的支架O具有
CD，argv的支架1有Dropbox的，

133
00:06:25,936 --> 00:06:28,560
然後當然命令
完成，所以這一切的記憶

134
00:06:28,560 --> 00:06:30,420
基本消失，
用於別的東西。

135
00:06:30,420 --> 00:06:32,270
這就是為什麼我說
只是一個瞬間。

136
00:06:32,270 --> 00:06:35,720
>> 同時，如果我們做的mkdir pset2，
畫面看起來幾乎一樣，

137
00:06:35,720 --> 00:06:37,900
但裡面的argv不同的字符串。

138
00:06:37,900 --> 00:06:42,570
如果我做鐺衝刺打招呼
你好點C，同樣的想法。

139
00:06:42,570 --> 00:06:47,060
更多的東西填充的
的argv和argc個，當然，是4。

140
00:06:47,060 --> 00:06:49,150
因此，換句話說，
儘管這陣

141
00:06:49,150 --> 00:06:52,950
可能會點一些點點，
可變長度的，可以這麼說，

142
00:06:52,950 --> 00:06:56,720
你總是知道它在哪裡結束
是的，因為的argc是要告訴你

143
00:06:56,720 --> 00:07:00,120
在什麼時候你必須停止
看著argv中的元素。

144
00:07:00,120 --> 00:07:03,660
你只能看4
在總在這種情況下。

145
00:07:03,660 --> 00:07:06,600
>> 現在讓我們來看看，
也許，一個簡單的程序。

146
00:07:06,600 --> 00:07:09,070
一個剛剛打招呼
到有人喜歡Zamyla。

147
00:07:09,070 --> 00:07:12,620
所以，我要求我要編寫一個程序
在短短的一瞬間，通過它我可以做

148
00:07:12,620 --> 00:07:16,670
./hello空間Zamyla，然後我想
我的程序打印出來的東西

149
00:07:16,670 --> 00:07:18,520
超級簡單的像“你好，Zamyla。”

150
00:07:18,520 --> 00:07:20,100
現在，在過去，我們使用的GetString。

151
00:07:20,100 --> 00:07:22,850
因此，在過去，即使
你是新來編程，

152
00:07:22,850 --> 00:07:27,180
可能你會掀起
使用GetString的程序

153
00:07:27,180 --> 00:07:29,390
然後使用printf的
說喜Zamyla。

154
00:07:29,390 --> 00:07:31,290
但是，我們不要用GetString的這個時候。

155
00:07:31,290 --> 00:07:37,510
讓我來代替進入Appliant
做包括標準輸入輸出點小時。

156
00:07:37,510 --> 00:07:41,160
讓我也有CS50網點小時。

157
00:07:41,160 --> 00:07:44,730
現在主要的詮釋，而現在我
不會今天做無效。

158
00:07:44,730 --> 00:07:51,200
相反，我該怎麼辦INT ARGC
字符串的argv開括號右括號，

159
00:07:51,200 --> 00:07:52,640
不指定一個數字。

160
00:07:52,640 --> 00:07:54,644
喏，這就是我所謂的做。

161
00:07:54,644 --> 00:07:57,560
我什麼都現在要做的就是，我
打算做一點信仰的飛躍，

162
00:07:57,560 --> 00:08:00,560
我將假設用戶的
要正確地使用這個程序，

163
00:08:00,560 --> 00:08:04,980
而我只是去
這樣做的printf你好，％錫。

164
00:08:04,980 --> 00:08:06,630
所以，沒有什麼新的存在。

165
00:08:06,630 --> 00:08:11,470
但我想現在把什麼字
該程序的名稱後，用戶類型。

166
00:08:11,470 --> 00:08:16,970
所以，如果我這樣做./hello空間Zamyla，我
要以某種方式編程方式訪問

167
00:08:16,970 --> 00:08:20,870
報價引文結束“Zamyla。”所以我
可以進入我的參數向量，

168
00:08:20,870 --> 00:08:25,980
我的字符串數組，並且如果該命令
再次，是./hello空間Zamyla，

169
00:08:25,980 --> 00:08:29,340
什麼數字做我想要
argv中放這裡？

170
00:08:29,340 --> 00:08:29,840
聽眾：1。

171
00:08:29,840 --> 00:08:32,355
大衛馬蘭：1，因為
支架0證明

172
00:08:32,355 --> 00:08:34,230
將是該
節目的名字，正如我們所看到。

173
00:08:34,230 --> 00:08:37,789
所以托架1是第一個字
我的用戶，鍵入。

174
00:08:37,789 --> 00:08:39,559
我要繼續前進，保存這個。

175
00:08:39,559 --> 00:08:42,830
我要進入我的文件夾
在那裡我已經放在這個文件。

176
00:08:42,830 --> 00:08:44,920
我該怎麼辦讓你好3。

177
00:08:44,920 --> 00:08:46,230
比較IO的確定。

178
00:08:46,230 --> 00:08:51,380
./hello Zamyla輸入。

179
00:08:51,380 --> 00:08:54,480
我做了什麼錯？

180
00:08:54,480 --> 00:08:57,270
我措手不及
我自己只是一瞬間出現。

181
00:08:57,270 --> 00:08:58,230
我做了什麼錯？

182
00:08:58,230 --> 00:08:59,220
>> 聽眾：名稱。

183
00:08:59,220 --> 00:09:01,767
>> 大衛馬蘭：該文件的
其實所謂的hello3.c。

184
00:09:01,767 --> 00:09:03,850
我這樣做只是為了
一致性，因為我們已經

185
00:09:03,850 --> 00:09:06,550
有hello.c中的中
過去在聯機代碼。

186
00:09:06,550 --> 00:09:11,550
因此，讓我們解決這個問題./hello
支架衝刺3 Zamyla。

187
00:09:11,550 --> 00:09:12,370
輸入。

188
00:09:12,370 --> 00:09:14,030
現在我們有打招呼，Zamyla。

189
00:09:14,030 --> 00:09:17,650
同時，我可以改變這
是搶，還是真的任何其他文字。

190
00:09:17,650 --> 00:09:19,230
>> 但是，讓我們考慮一個角落的情況下。

191
00:09:19,230 --> 00:09:24,360
什麼，你可能會想到，如果會發生
我不輸入任何人的名字呢？

192
00:09:24,360 --> 00:09:25,270
>> 聽眾：錯誤。

193
00:09:25,270 --> 00:09:27,300
>> 大衛馬蘭：錯誤
的一些，也許。

194
00:09:27,300 --> 00:09:28,200
讓我們來看看。

195
00:09:28,200 --> 00:09:29,440
輸入。

196
00:09:29,440 --> 00:09:30,210
NULL。

197
00:09:30,210 --> 00:09:33,870
所以printf的實際上是被
一點點保護我們

198
00:09:33,870 --> 00:09:38,131
在這裡，和字面移印開括號
空，但更糟糕的事情都可能發生。

199
00:09:38,131 --> 00:09:40,130
而只是為了展示
東西你絕對

200
00:09:40,130 --> 00:09:42,800
不該做的事，讓我們在
在這裡，並開始閒逛。

201
00:09:42,800 --> 00:09:43,300
對不對？

202
00:09:43,300 --> 00:09:46,410
如果我知道，在畫面
內存基本上是這樣，

203
00:09:46,410 --> 00:09:52,660
argv的支架1具有Zamyla，ARGV
托架0具有./hello，或./hello-3。

204
00:09:52,660 --> 00:09:55,400
什麼是支架2？

205
00:09:55,400 --> 00:09:58,210
這樣我就可以回答這個問題
懷疑自己，對不對？

206
00:09:58,210 --> 00:10:00,460
我只能改變1到2。

207
00:10:00,460 --> 00:10:07,270
我現在可以重新編譯您好3，
./hello3讓我們放大並按下回車鍵。

208
00:10:07,270 --> 00:10:08,270
哎呦。

209
00:10:08,270 --> 00:10:10,660
沒有引號。

210
00:10:10,660 --> 00:10:12,540
有意思的。

211
00:10:12,540 --> 00:10:15,530
所以這是一種很酷
看到的是在這裡還有什麼。

212
00:10:15,530 --> 00:10:17,130
>> 那麼，我的筆記本電腦裡還有什麼？

213
00:10:17,130 --> 00:10:20,390
讓我們將它保存與支架3。

214
00:10:20,390 --> 00:10:25,190
請hello3，./hello-3。

215
00:10:25,190 --> 00:10:26,500
好奇的。

216
00:10:26,500 --> 00:10:30,560
現在，讓我們真正bold-- 50。

217
00:10:30,560 --> 00:10:34,340
所以，這真的跳水深
進入我的電腦的內存中。

218
00:10:34,340 --> 00:10:35,930
50指數研究。

219
00:10:35,930 --> 00:10:41,950
所以要餵3 ./hello-3。

220
00:10:41,950 --> 00:10:42,680
好奇的。

221
00:10:42,680 --> 00:10:44,660
好吧，現在我只是
要得到魯莽。

222
00:10:44,660 --> 00:10:47,331
讓我們去到5000。

223
00:10:47,331 --> 00:10:47,830
好吧。

224
00:10:47,830 --> 00:10:49,520
因此，讓我重新編譯。

225
00:10:49,520 --> 00:10:51,460
請hello3，./hello-3。

226
00:10:51,460 --> 00:10:55,780

227
00:10:55,780 --> 00:10:56,460
行。

228
00:10:56,460 --> 00:10:59,250
現在，你們中的一些，可能
一個燈泡去了。

229
00:10:59,250 --> 00:11:01,900
你們有多少人有
之前看過這個消息？

230
00:11:01,900 --> 00:11:03,440
行。

231
00:11:03,440 --> 00:11:04,420
那麼，為什麼呢？

232
00:11:04,420 --> 00:11:07,250
>> 賠率are--並有不同
事情可能會導致此，

233
00:11:07,250 --> 00:11:09,730
並明確你的好
company--我們必須清楚

234
00:11:09,730 --> 00:11:11,900
造成了所謂
分段故障。

235
00:11:11,900 --> 00:11:15,890
而長話短說今天，我
已經觸及記憶的片段

236
00:11:15,890 --> 00:11:17,060
我不應該有。

237
00:11:17,060 --> 00:11:19,970
其中段僅僅意味著一大塊
記憶，我不應該有。

238
00:11:19,970 --> 00:11:25,530
現在的電腦可以保證，如果我
運行./helloZamyla我能觸摸的argv

239
00:11:25,530 --> 00:11:27,760
是支架0和argv支架1。

240
00:11:27,760 --> 00:11:32,730
但ARGC是值2，這意味著我
只有allowed--這有點榮譽

241
00:11:32,730 --> 00:11:35,180
系統 - 觸摸
0支架及支架1。

242
00:11:35,180 --> 00:11:37,990
如果我再往前走，有
絕對將是存儲器那裡。

243
00:11:37,990 --> 00:11:40,660
我的內存物理上存在
在計算機中。

244
00:11:40,660 --> 00:11:42,080
但誰知道那裡有什麼？

245
00:11:42,080 --> 00:11:44,450
事實上，我在運行多個
程序在同一時間。

246
00:11:44,450 --> 00:11:46,910
我可能有seen--如果我不
在Appliant這樣做

247
00:11:46,910 --> 00:11:49,937
但在我的Mac或PC--我可能有
觀察的電子郵件的內容。

248
00:11:49,937 --> 00:11:52,270
我可能會看到瞬間
消息我最近發。

249
00:11:52,270 --> 00:11:55,390
任何可能
在內存周圍徘徊

250
00:11:55,390 --> 00:11:59,180
可以通過的方式被訪問
這個任意方括號。

251
00:11:59,180 --> 00:12:02,850
或者，更糟糕的是，你可能有
發現了我的密碼1

252
00:12:02,850 --> 00:12:05,859
我想最近輸入的，一個
方案已存儲在內存中，從而

253
00:12:05,859 --> 00:12:07,900
驗證了我，
然後種剛剛離開它

254
00:12:07,900 --> 00:12:09,910
在內存中，直到我退出該程序。

255
00:12:09,910 --> 00:12:12,860
>> 事實上，這是一
的危險，一個權力

256
00:12:12,860 --> 00:12:15,980
使用類似C的語言
您可以自由訪問

257
00:12:15,980 --> 00:12:18,860
到的全部內容
程序的內存，

258
00:12:18,860 --> 00:12:21,340
什麼壞人能
即使在做這些cases--

259
00:12:21,340 --> 00:12:23,807
特別是當我們
得到Web編程

260
00:12:23,807 --> 00:12:26,890
朝學期結束，我們將
重溫這topic--是閒逛，

261
00:12:26,890 --> 00:12:31,660
可能有人是電腦的
記憶，找到這樣的事情感到好奇

262
00:12:31,660 --> 00:12:32,570
因為我們看到了那裡。

263
00:12:32,570 --> 00:12:36,900
甚至更糟糕的是，口令，他
或者她可以用它來幹壞事。

264
00:12:36,900 --> 00:12:40,240
>> 所以，顯然我不應該這樣做，
因為奇怪的事情開始發生。

265
00:12:40,240 --> 00:12:42,310
的確，這是一個程序崩潰。

266
00:12:42,310 --> 00:12:44,580
這將是等效
的Mac OS的Windows或

267
00:12:44,580 --> 00:12:46,770
程序窗口剛剛消失。

268
00:12:46,770 --> 00:12:48,300
已發生未預期的錯誤。

269
00:12:48,300 --> 00:12:50,840
在命令行環境
我們看到這樣的事情。

270
00:12:50,840 --> 00:12:54,480
但是，這是為什麼，是我只是碰
不屬於我的記憶。

271
00:12:54,480 --> 00:12:57,090
>> 因此，讓我們對這樣的防守
以不同的方式點點

272
00:12:57,090 --> 00:12:59,010
通過看這個節目在這裡。

273
00:12:59,010 --> 00:13:01,000
因此，再次，骨架
我們看到先前已經

274
00:13:01,000 --> 00:13:02,480
我已經強調了這一次詮釋。

275
00:13:02,480 --> 00:13:05,900
而這一切的時候主要有
實際上返回的值。

276
00:13:05,900 --> 00:13:09,120
即使在我們大部分的演講
我們從來沒有使用一次例子

277
00:13:09,120 --> 00:13:10,990
返回主任何東西。

278
00:13:10,990 --> 00:13:13,710
我們只是寫的printf關閉
大括號，就是這樣。

279
00:13:13,710 --> 00:13:16,500
但對於自由，什麼
編譯器已經做了你，

280
00:13:16,500 --> 00:13:19,510
有效，則返回0給你。

281
00:13:19,510 --> 00:13:22,950
打開out--，它是一個小
counterintuitive-- 0是好。

282
00:13:22,950 --> 00:13:24,690
這並不意味著錯誤本身。

283
00:13:24,690 --> 00:13:29,080
0是好，任何非0
值時，世界已經決定，

284
00:13:29,080 --> 00:13:30,619
可以表示一個錯誤。

285
00:13:30,619 --> 00:13:32,910
所以，如果你曾經搞砸
什麼您的計算機上，

286
00:13:32,910 --> 00:13:36,600
或計劃剛剛去世，你和
你已經得到了一些錯誤窗口

287
00:13:36,600 --> 00:13:40,360
在屏幕上，說錯誤
負49或錯誤23--

288
00:13:40,360 --> 00:13:44,170
一些看似隨意的value--這
因為程序員已經硬編碼

289
00:13:44,170 --> 00:13:49,370
像49負或正的值
23代表任意數字，敢說，

290
00:13:49,370 --> 00:13:53,340
四十億可能的事情
可能出錯的程序。

291
00:13:53,340 --> 00:13:55,700
>> 所以，我怎麼可能拿
利用這一點我自己？

292
00:13:55,700 --> 00:13:58,970
好吧，讓我打開一個程序
我提前寫了，

293
00:13:58,970 --> 00:14:01,450
和閒逛在線名為hello 4。

294
00:14:01,450 --> 00:14:05,650
這幾乎是相同的，不同之處在於
它得到了錯誤檢查的一點點。

295
00:14:05,650 --> 00:14:09,660
在這種情況下，我再次聲明
主要是考慮兩個參數，

296
00:14:09,660 --> 00:14:13,180
但是這一次，在第17行，通知
我做了一下仔細的檢查了。

297
00:14:13,180 --> 00:14:17,100
我要確保
的argc等於等於2。

298
00:14:17,100 --> 00:14:18,960
因為如果是，那
意味著我可以安全地

299
00:14:18,960 --> 00:14:21,420
觸摸不僅托架0，但是支架1。

300
00:14:21,420 --> 00:14:24,330
我繼續前進，打印出來，
在這種情況下，Zamyla或搶劫

301
00:14:24,330 --> 00:14:26,020
或什麼字我打出來。

302
00:14:26,020 --> 00:14:28,020
而現在只是為了讓
多一點正確的，

303
00:14:28,020 --> 00:14:31,910
我要明確地返回
0來表示一切都很好。

304
00:14:31,910 --> 00:14:33,300
沒什麼不好的事情發生了。

305
00:14:33,300 --> 00:14:38,590
>> 不過，按照慣例，我要
返回1，或者坦白任何非0值，

306
00:14:38,590 --> 00:14:40,160
如果出事了。

307
00:14:40,160 --> 00:14:43,270
現在，用戶不會
真正注意到發生了什麼事情。

308
00:14:43,270 --> 00:14:50,410
事實上，如果我進入這個目錄，
我們放大，做讓你好4，

309
00:14:50,410 --> 00:14:54,210
./hello-4 Zamyla表現如我所料。

310
00:14:54,210 --> 00:14:58,570
但是，如果我不是不鍵入
什麼，似乎什麼都沒有發生，

311
00:14:58,570 --> 00:14:59,680
但它不會崩潰。

312
00:14:59,680 --> 00:15:04,660
如果我不是做一些事情
像羅布是一個監考人

313
00:15:04,660 --> 00:15:07,550
在Thayer--共享
任意信息。

314
00:15:07,550 --> 00:15:13,680
但通知，argv的1，2，3，4，和
5現在應該存在於內存中。

315
00:15:13,680 --> 00:15:16,540
這也並不是什麼
我的程序需要，

316
00:15:16,540 --> 00:15:20,300
因為我已經檢查是否
的argc等於等於2或沒有。

317
00:15:20,300 --> 00:15:22,140
所以，我現在防禦這一點。

318
00:15:22,140 --> 00:15:25,290
>> 現在，順便說一句，我們的
programmer--或者說我們的users--

319
00:15:25,290 --> 00:15:29,670
從來沒有看到一個0或1，但使用
工具，稱為調試器或其它工具，

320
00:15:29,670 --> 00:15:32,250
和以前一樣，我們會看到
長，你的程序員

321
00:15:32,250 --> 00:15:36,590
其實可以看看可能是什麼
你的程序裡面去錯了。

322
00:15:36,590 --> 00:15:39,170
>> 因此，在ARGC什麼問題嗎？

323
00:15:39,170 --> 00:15:40,873
是啊。

324
00:15:40,873 --> 00:15:45,292
>> 聽眾：我見過他們
還沒有的字符，[聽不清]

325
00:15:45,292 --> 00:15:49,669
剛才說的串星D，如
字符星號逗號。

326
00:15:49,669 --> 00:15:50,710
他們是等價嗎？

327
00:15:50,710 --> 00:15:51,626
>> 大衛馬蘭：他們是。

328
00:15:51,626 --> 00:15:55,080
所以，問題是，你有
偶爾可見的程序

329
00:15:55,080 --> 00:15:57,270
像這樣不
說字符串argv的支架

330
00:15:57,270 --> 00:16:01,015
而是說些什麼
像炭明星argv的支架。

331
00:16:01,015 --> 00:16:03,140
甚至還有其他
變體，你可能會看到。

332
00:16:03,140 --> 00:16:04,264
他們確實是等價的。

333
00:16:04,264 --> 00:16:06,240
現在，我們有這些
這類訓練車輪

334
00:16:06,240 --> 00:16:09,737
在字符串中的CS50的形式
庫，但在短短一個多星期

335
00:16:09,737 --> 00:16:12,570
還是讓我們將刪除
完全梗阻，實際上

336
00:16:12,570 --> 00:16:16,820
看看炭和星
有，以及這些涉及到內存

337
00:16:16,820 --> 00:16:18,140
代表更普遍。

338
00:16:18,140 --> 00:16:19,540
因此，我們會回來的。

339
00:16:19,540 --> 00:16:21,540
>> 在我們的argv和argc個其他的問題嗎？

340
00:16:21,540 --> 00:16:22,397
是啊。

341
00:16:22,397 --> 00:16:24,438
聽眾：為什麼會回來
錯誤[聽不清]？

342
00:16:24,438 --> 00:16:27,147

343
00:16:27,147 --> 00:16:29,230
大衛馬蘭：為什麼會
返回一個錯誤only--哦！

344
00:16:29,230 --> 00:16:31,813
在前面的情況下，當我們
帶記憶功能均圍繞把玩，

345
00:16:31,813 --> 00:16:35,110
為什麼只返回一個錯誤
當我真正輸入一個大數目？

346
00:16:35,110 --> 00:16:36,620
簡短的回答是，我們只是很幸運。

347
00:16:36,620 --> 00:16:39,240
一般來說，一台計算機
在塊分配內存，

348
00:16:39,240 --> 00:16:42,900
它給了我一個足夠大的存儲塊，它
我得到了，而不被發覺，

349
00:16:42,900 --> 00:16:46,280
感人的支架2，支架3，
支架50，但只要我推

350
00:16:46,280 --> 00:16:49,080
我的運氣，我去超越
的存儲器中的數據塊的邊界

351
00:16:49,080 --> 00:16:50,520
操作系統給了我。

352
00:16:50,520 --> 00:16:52,720
這就是當
取締並說，沒有。

353
00:16:52,720 --> 00:16:54,580
分割錯誤。

354
00:16:54,580 --> 00:16:55,692
是啊。

355
00:16:55,692 --> 00:16:58,890
>> 聽眾：如何在電腦
知道的argc的值？

356
00:16:58,890 --> 00:17:02,390
>> 大衛馬蘭：請問該如何
計算機知道的argc的值？

357
00:17:02,390 --> 00:17:07,920
當你運行一個程序，該程序，
通過閃爍提示性質，

358
00:17:07,920 --> 00:17:11,359
被傳遞的數組
被輸入的字

359
00:17:11,359 --> 00:17:13,300
在提示符下，這是
鍵入的。

360
00:17:13,300 --> 00:17:16,569
因此，這是你的工作
系統的本質

361
00:17:16,569 --> 00:17:20,329
填充主要的論點為您服務。

362
00:17:20,329 --> 00:17:22,829
所以這是一個服務
之類的，你得到的，偷偷的

363
00:17:22,829 --> 00:17:24,869
的機罩下方
一個操作系統。

364
00:17:24,869 --> 00:17:27,118
其他問題嗎？

365
00:17:27,118 --> 00:17:27,618
是啊。

366
00:17:27,618 --> 00:17:29,787
>> 聽眾：什麼是核心轉儲是什麼意思？

367
00:17:29,787 --> 00:17:31,370
大衛馬蘭：這是什麼核心轉儲是什麼意思？

368
00:17:31,370 --> 00:17:32,950
所以這是一個很好的問題。

369
00:17:32,950 --> 00:17:35,312
讓我重新回到
該目錄在這裡。

370
00:17:35,312 --> 00:17:37,270
而且你會發現，
我有一個新的文件存在。

371
00:17:37,270 --> 00:17:41,670
它確實是叫核心，它的
其實通常一個體面的大小的文件。

372
00:17:41,670 --> 00:17:45,300
這是本質上的快照
我的程序的內存內容

373
00:17:45,300 --> 00:17:46,902
或RAM時墜毀。

374
00:17:46,902 --> 00:17:49,110
並且這將是有用的，
可能，診斷，

375
00:17:49,110 --> 00:17:52,850
當我們談論在未來的演講
而有關調試部分，

376
00:17:52,850 --> 00:17:55,730
因為你實際上可以做的
數字屍檢相當於

377
00:17:55,730 --> 00:18:00,300
在該文件中，以幫助找出
你做錯了什麼在你的程序。

378
00:18:00,300 --> 00:18:01,220
是啊。

379
00:18:01,220 --> 00:18:04,450
>> 聽眾：是的argc的命令
本身，或者你的名字什麼？

380
00:18:04,450 --> 00:18:05,575
>> 大衛馬蘭：好問題。

381
00:18:05,575 --> 00:18:08,040
是的argc命令本身，
或者你能想到的東西嗎？

382
00:18:08,040 --> 00:18:09,290
這絕對不是一個命令。

383
00:18:09,290 --> 00:18:13,500
這是一個簡單的變量
命名或參數的名稱，

384
00:18:13,500 --> 00:18:15,481
所以，我們絕
可以稱之為富，

385
00:18:15,481 --> 00:18:18,480
我們可以把這個吧，這往往
是去到的話，一個計算機

386
00:18:18,480 --> 00:18:19,860
科學家去。

387
00:18:19,860 --> 00:18:22,820
但按照慣例，我們用argc和argv。

388
00:18:22,820 --> 00:18:25,360
但是，這只是一個人
按慣例，僅此而已。

389
00:18:25,360 --> 00:18:25,860
好吧。

390
00:18:25,860 --> 00:18:28,140
所以，事實證明，我已經
講述一個有點白lie--的

391
00:18:28,140 --> 00:18:31,264
坦率地說，在未來，你會看到
我們已經告訴其他善意的謊言。

392
00:18:31,264 --> 00:18:33,510
但現在，我們要
剝離背部的其中之一。

393
00:18:33,510 --> 00:18:37,310
在這種情況下這裡的時候，我在前面
跑起來像./hello或./hello-3方案

394
00:18:37,310 --> 00:18:42,780
Zamyla，我們有內容我
計算機的內存期待大致如下

395
00:18:42,780 --> 00:18:43,280
這個。

396
00:18:43,280 --> 00:18:45,070
但是記得什麼是字符串。

397
00:18:45,070 --> 00:18:49,279
咱們怎麼說的一個星期前有什麼
字符串實際上是引擎蓋底下？

398
00:18:49,279 --> 00:18:50,320
聽眾：字符數組。

399
00:18:50,320 --> 00:18:52,111
大衛馬蘭：這是一個
字符數組的，對不對？

400
00:18:52,111 --> 00:18:55,760
因此，我們可能有一個數組
字符串，但是，反過來，一個字符串

401
00:18:55,760 --> 00:18:57,150
是字符數組。

402
00:18:57,150 --> 00:19:00,010
所以，如果我真的想成為
當我畫這幅畫的肛門，

403
00:19:00,010 --> 00:19:03,290
我真的畫
它有點像這樣，

404
00:19:03,290 --> 00:19:08,000
由此在每個這些
我argv數組的索引，

405
00:19:08,000 --> 00:19:11,432
存在本身就是一個整串
這本身是一個數組。

406
00:19:11,432 --> 00:19:13,140
現在的善意的謊言
我們今天講

407
00:19:13,140 --> 00:19:15,181
就是圖片不
看上去很喜歡這個。

408
00:19:15,181 --> 00:19:19,110
事實上，小廣場都是
一般外面的大矩形

409
00:19:19,110 --> 00:19:19,610
那裡。

410
00:19:19,610 --> 00:19:21,280
但我們會回來用不了多久。

411
00:19:21,280 --> 00:19:25,440
但是，這是./hello反斜線0，
這是特殊字符

412
00:19:25,440 --> 00:19:28,310
劃定一個字符串的結尾，
我們已經得到了一個又一個後

413
00:19:28,310 --> 00:19:29,360
Zamyla的名字。

414
00:19:29,360 --> 00:19:30,900
所以，這是什麼意思？

415
00:19:30,900 --> 00:19:33,410
>> 好了，讓我繼續前進，
打開另外兩個例子

416
00:19:33,410 --> 00:19:35,220
這是在網上提供。

417
00:19:35,220 --> 00:19:40,590
一個被稱為argv1.c
另一種是argv2。

418
00:19:40,590 --> 00:19:44,260
這是一個超級簡單的程序，
與過去不同的方案

419
00:19:44,260 --> 00:19:47,260
在現在，我使用
argc和argv在這裡。

420
00:19:47,260 --> 00:19:54,300
現在我有一個for循環積分
在長達argc那樣線18，從i = 0。

421
00:19:54,300 --> 00:19:56,850
而且我怎麼辦
與這行代碼在這裡？

422
00:19:56,850 --> 00:19:58,270
用英語。

423
00:19:58,270 --> 00:20:00,510
這顯然表明使用的argc的。

424
00:20:00,510 --> 00:20:03,670
但在英語有哪些呢
它這樣做，如果我運行這個程序？

425
00:20:03,670 --> 00:20:04,366
是嗎？

426
00:20:04,366 --> 00:20:07,386
>> 聽眾：這將打印
只要你想篩選多次。

427
00:20:07,386 --> 00:20:08,260
馬蘭大衛：沒錯。

428
00:20:08,260 --> 00:20:10,480
所以，無論話我
在提示符處鍵入，它的

429
00:20:10,480 --> 00:20:13,120
要吐出
他們看著我，每行一個。

430
00:20:13,120 --> 00:20:14,370
因此，讓我們繼續前進，做到這一點。

431
00:20:14,370 --> 00:20:17,862
讓我進入我的目錄
做讓argv1 ./argv1。

432
00:20:17,862 --> 00:20:20,521

433
00:20:20,521 --> 00:20:21,770
現在，讓我們保持簡單。

434
00:20:21,770 --> 00:20:23,834
讓我們什麼也不做第一。

435
00:20:23,834 --> 00:20:26,750
它沒有打印出一件事，
這是確實的程序的名稱，

436
00:20:26,750 --> 00:20:28,240
因為這是在支架0。

437
00:20:28,240 --> 00:20:33,290
如果我現在說富，它會做
這兩個，如果我說富吧，

438
00:20:33,290 --> 00:20:35,580
它會說，這三樣東西。

439
00:20:35,580 --> 00:20:37,740
現在，這是有點有趣，也許。

440
00:20:37,740 --> 00:20:41,450
但記得的argv
是一個字符串數組，

441
00:20:41,450 --> 00:20:45,960
但字符串是字符數組，
所以我們可以拿東西了一個檔次

442
00:20:45,960 --> 00:20:48,560
並應用基本
邏輯，使代碼

443
00:20:48,560 --> 00:20:51,160
看起來多了幾分神秘，無可否認。

444
00:20:51,160 --> 00:20:53,540
但是，有一個嵌套
循環的東西，類似於

445
00:20:53,540 --> 00:20:57,030
什麼，你可能還記得馬里奧，
舉例來說，如果你這樣做，是這樣的。

446
00:20:57,030 --> 00:21:00,380
>> 所以現在看到第19行，我
再次遍歷我的論點，

447
00:21:00,380 --> 00:21:02,410
從0一直到argc那樣。

448
00:21:02,410 --> 00:21:05,510
現在的行21--我
借用去年week--一招

449
00:21:05,510 --> 00:21:11,090
我檢查什麼
長的argv支架I的。

450
00:21:11,090 --> 00:21:12,920
我存儲在正的答案。

451
00:21:12,920 --> 00:21:18,230
然後我從J於一體
到n，其中j被初始化為0。

452
00:21:18,230 --> 00:21:19,460
所以，約定計算。

453
00:21:19,460 --> 00:21:22,335
一旦你使用了我，如果你有一個
嵌套循環，不能再次使用I，

454
00:21:22,335 --> 00:21:25,770
否則你會揍，潛在的，
內環以外的值。

455
00:21:25,770 --> 00:21:27,200
所以我用j通過約定。

456
00:21:27,200 --> 00:21:28,020
我們可以使用k。

457
00:21:28,020 --> 00:21:31,080
如果你比k的多了，你可能
有太多的嵌套，一般。

458
00:21:31,080 --> 00:21:33,800
但現在，我發現的printf
線是略有不同的。

459
00:21:33,800 --> 00:21:37,520
我不打印％S，我
當然，印刷％C，其中，

460
00:21:37,520 --> 00:21:39,460
是一個佔位符字符。

461
00:21:39,460 --> 00:21:40,770
>> 現在看到這個語法。

462
00:21:40,770 --> 00:21:41,270
新。

463
00:21:41,270 --> 00:21:42,630
我們以前沒有見過。

464
00:21:42,630 --> 00:21:47,290
但在邏輯上，這也就意味著
獲得argv中第i個字符串

465
00:21:47,290 --> 00:21:50,067
並獲得第j個什麼？

466
00:21:50,067 --> 00:21:50,900
聽眾：字符。

467
00:21:50,900 --> 00:21:52,800
大衛馬蘭：字符的字符串。

468
00:21:52,800 --> 00:21:57,100
所以可以用方括號
其次是方括號，

469
00:21:57,100 --> 00:22:00,390
這是第一次跳水
進入ARGV的字符串，

470
00:22:00,390 --> 00:22:02,225
然後將第二
方括號內為J

471
00:22:02,225 --> 00:22:06,580
是在深入的字符
argv中的特定字符串。

472
00:22:06,580 --> 00:22:09,562
然後，只為好措施，
我打印了新線在這裡。

473
00:22:09,562 --> 00:22:12,020
所以，現在讓我繼續前進，開
一個稍微大一點的窗口

474
00:22:12,020 --> 00:22:13,600
所以我們可以看到這個動作。

475
00:22:13,600 --> 00:22:15,700
讓我進入該文件夾。

476
00:22:15,700 --> 00:22:22,550
現在做讓argv中，2--
whoops--作出的argv-2，./argv 2。

477
00:22:22,550 --> 00:22:23,110
輸入。

478
00:22:23,110 --> 00:22:24,860
這是一個有點硬
垂直閱讀，

479
00:22:24,860 --> 00:22:27,920
但是這確實是名
程序，其次是一個空行。

480
00:22:27,920 --> 00:22:30,210
現在讓我繼續前進，做富。

481
00:22:30,210 --> 00:22:33,210
同樣難讀，但它的
的確打印每行一個字符。

482
00:22:33,210 --> 00:22:36,780
如果我去做吧，這是現在
打印這些一行行。

483
00:22:36,780 --> 00:22:40,140
因此，這裡的外賣是沒有這麼多
，哇，看這整齊的新把戲

484
00:22:40,140 --> 00:22:44,750
在那裡你可以在內容獲取
的陣列的特定字符，

485
00:22:44,750 --> 00:22:48,380
而是如何我們正在採取這些基本
這樣的創意索引到一個數組中，

486
00:22:48,380 --> 00:22:51,620
然後索引到一個
數組是數組，

487
00:22:51,620 --> 00:22:56,180
而在應用了同樣的想法，
稍微複雜的例子。

488
00:22:56,180 --> 00:22:59,560
但基礎實在不
改變，即使是自上週以來。

489
00:22:59,560 --> 00:23:02,350
>> 現在，這是有點及時，
在那，記得，零一周

490
00:23:02,350 --> 00:23:04,110
我們打了一個電話本這樣。

491
00:23:04,110 --> 00:23:06,670
即使這是明顯
物理的紙片，

492
00:23:06,670 --> 00:23:09,150
種你能想到的
電話簿為一個數組。

493
00:23:09,150 --> 00:23:12,770
當然，如果你要重新實現
這件這些紙片

494
00:23:12,770 --> 00:23:15,260
在一台電腦，可能
你會使用的東西

495
00:23:15,260 --> 00:23:20,270
像一個數組來存儲所有這些
從A一路姓名和電話號碼

496
00:23:20,270 --> 00:23:23,800
到Z所以這是很好的，因為
它讓我們有機會，

497
00:23:23,800 --> 00:23:28,310
也許，要考慮你怎麼可能
真正實現類似的東西。

498
00:23:28,310 --> 00:23:31,250
由於有一系列的門這裡。

499
00:23:31,250 --> 00:23:36,380
所以，如果我could--我們需要一個
自願到來吧。

500
00:23:36,380 --> 00:23:36,980
讓我們來看看。

501
00:23:36,980 --> 00:23:40,650
一個陌生的面孔也許，
陌生的臉也許。

502
00:23:40,650 --> 00:23:42,090
怎麼樣在橙色？

503
00:23:42,090 --> 00:23:42,680
這裡。

504
00:23:42,680 --> 00:23:45,870
橙色的襯衫，上來吧。

505
00:23:45,870 --> 00:23:52,230
>> 現在，讓我們和舉措繼續
這些門上的側

506
00:23:52,230 --> 00:23:54,020
將這些閃開了一會兒。

507
00:23:54,020 --> 00:23:56,600

508
00:23:56,600 --> 00:23:57,760
你叫什麼名字？

509
00:23:57,760 --> 00:23:58,580
>> AJAY：

510
00:23:58,580 --> 00:23:58,655
>> 大衛馬蘭：阿賈伊。

511
00:23:58,655 --> 00:23:58,680
大衛。

512
00:23:58,680 --> 00:23:59,451
很高興認識你。

513
00:23:59,451 --> 00:23:59,950
好吧。

514
00:23:59,950 --> 00:24:04,500
因此，我們有這六個背後
門數字上screen--

515
00:24:04,500 --> 00:24:07,810
或者說，七門上
screen--一大堆數字。

516
00:24:07,810 --> 00:24:10,099
我已經告訴你什麼
在advance--同意？

517
00:24:10,099 --> 00:24:11,140
AJAY：事先沒有。

518
00:24:11,140 --> 00:24:14,730
大衛馬蘭：我只想要你做
現在是時候找到我，對我們來說，

519
00:24:14,730 --> 00:24:20,920
真的，數量50，
一步一個腳印的時間。

520
00:24:20,920 --> 00:24:21,830
>> AJAY：50號？

521
00:24:21,830 --> 00:24:22,580
>> 大衛馬蘭：數字50。

522
00:24:22,580 --> 00:24:24,746
而且你可以發現什麼
後面這些門

523
00:24:24,746 --> 00:24:27,930
只需用手指觸摸它。

524
00:24:27,930 --> 00:24:31,364
該死的。 [笑]

525
00:24:31,364 --> 00:24:34,560
>> [掌聲]

526
00:24:34,560 --> 00:24:39,540
>> 非常出色。

527
00:24:39,540 --> 00:24:40,400
行。

528
00:24:40,400 --> 00:24:44,090
我們有一個可愛的禮物
獎你在這裡。

529
00:24:44,090 --> 00:24:46,520
你挑的電影，我們
上週討論。

530
00:24:46,520 --> 00:24:47,362
>> AJAY：哦，伙計。

531
00:24:47,362 --> 00:24:49,050
哦，我從來沒有見過太空砲彈。

532
00:24:49,050 --> 00:24:49,520
>> 大衛馬蘭：太空砲彈。

533
00:24:49,520 --> 00:24:50,140
好吧。

534
00:24:50,140 --> 00:24:53,790
因此，堅持只是一個瞬間。

535
00:24:53,790 --> 00:24:57,430
How--讓我們做這個
受教moment--

536
00:24:57,430 --> 00:25:00,412
你怎麼去
尋找50號？

537
00:25:00,412 --> 00:25:01,370
AJAY：我選擇了隨機。

538
00:25:01,370 --> 00:25:03,420
馬蘭大衛：所以你選擇了
隨機真的很幸運。

539
00:25:03,420 --> 00:25:03,790
AJAY：是的。

540
00:25:03,790 --> 00:25:04,456
大衛馬蘭：確定。

541
00:25:04,456 --> 00:25:05,050
優秀的。

542
00:25:05,050 --> 00:25:08,470
所以，現在，你有沒有
得到幸運的話，還有什麼

543
00:25:08,470 --> 00:25:10,210
可能發生背後的門？

544
00:25:10,210 --> 00:25:12,930
所以，如果我繼續前進，
這裡透露這些數字，

545
00:25:12,930 --> 00:25:15,180
他們實際上是在隨機順序。

546
00:25:15,180 --> 00:25:17,750
而最好的，你可以有
完成後，坦率地說，是，最終，

547
00:25:17,750 --> 00:25:19,410
在最壞的情況下，檢查了他們。

548
00:25:19,410 --> 00:25:23,000
所以，你有超級幸運的，這
是不是我們所說的算法。

549
00:25:23,000 --> 00:25:24,730
是的，恭喜。

550
00:25:24,730 --> 00:25:27,010
但現在let's--幽默我，如果你能。

551
00:25:27,010 --> 00:25:28,310
讓我們在此選項卡在這裡。

552
00:25:28,310 --> 00:25:31,460
這裡是明確的數字
似乎是隨機的順序，

553
00:25:31,460 --> 00:25:32,280
而且他們。

554
00:25:32,280 --> 00:25:35,160
但現在，如果我不是索賠
這背後的門

555
00:25:35,160 --> 00:25:39,070
是被排序號碼。

556
00:25:39,070 --> 00:25:41,780
現在的目標是要還
找到我們的數50。

557
00:25:41,780 --> 00:25:45,910
但這樣做算法上，而
告訴我們你要去了解它。

558
00:25:45,910 --> 00:25:48,020
如果你找到它，你把這部電影。

559
00:25:48,020 --> 00:25:49,520
你不覺得，你給它回來。

560
00:25:49,520 --> 00:25:52,720

561
00:25:52,720 --> 00:25:58,112
AJAY：所以我要去檢查結束
首先，確定是否there's--

562
00:25:58,112 --> 00:26:02,048
[笑聲及掌聲]

563
00:26:02,048 --> 00:26:04,451

564
00:26:04,451 --> 00:26:05,492
大衛馬蘭：在這裡你去。

565
00:26:05,492 --> 00:26:17,080

566
00:26:17,080 --> 00:26:21,700
讓我們來看看1
Ajay的前輩，

567
00:26:21,700 --> 00:26:25,450
肖恩，誰是沒有那麼幸運了。

568
00:26:25,450 --> 00:26:28,670
好了，你在這裡的任務，
肖恩，是下面的內容。

569
00:26:28,670 --> 00:26:32,970
我隱藏在這些
門七位數，

570
00:26:32,970 --> 00:26:37,200
但在一些宗門藏
以及其他的非負數。

571
00:26:37,200 --> 00:26:40,730
你的目標是要想到這
號的最上一行作為僅有的陣列。

572
00:26:40,730 --> 00:26:43,590
我們是件只是一個序列
紙與他們背後的數字。

573
00:26:43,590 --> 00:26:47,640
你的目標是，只有使用頂部
陣這裡，我找了七位數。

574
00:26:47,640 --> 00:26:51,200
我們隨後將要批判
你如何去這樣做。

575
00:26:51,200 --> 00:26:52,920
找到我們七位數，請。

576
00:26:52,920 --> 00:27:02,570

577
00:27:02,570 --> 00:27:03,070
號

578
00:27:03,070 --> 00:27:06,760

579
00:27:06,760 --> 00:27:08,179
5，19，13。

580
00:27:08,179 --> 00:27:16,752

581
00:27:16,752 --> 00:27:17,835
這不是一個腦筋急轉彎。

582
00:27:17,835 --> 00:27:21,420

583
00:27:21,420 --> 00:27:21,920
1。

584
00:27:21,920 --> 00:27:26,715

585
00:27:26,715 --> 00:27:29,840
在這一點上你的分數不是很
好，所以你還不如繼續下去。

586
00:27:29,840 --> 00:27:32,870

587
00:27:32,870 --> 00:27:33,370
3。

588
00:27:33,370 --> 00:27:38,570

589
00:27:38,570 --> 00:27:39,802
去。

590
00:27:39,802 --> 00:27:42,510
坦白說，我不禁懷疑
什麼你甚至想。

591
00:27:42,510 --> 00:27:44,990
>> 肖恩：我可以只從最上面一行。

592
00:27:44,990 --> 00:27:46,240
大衛馬蘭：只有最上面一行。

593
00:27:46,240 --> 00:27:47,281
所以，你有三個左。

594
00:27:47,281 --> 00:27:48,310
所以找我7。

595
00:27:48,310 --> 00:27:54,758

596
00:27:54,758 --> 00:27:59,141
>> [聽眾呼喊幾點建議]

597
00:27:59,141 --> 00:28:22,210

598
00:28:22,210 --> 00:28:26,130
因此，這兩個都是驚人
非常不同的原因。

599
00:28:26,130 --> 00:28:29,150
所以這是我們
離開片刻前，

600
00:28:29,150 --> 00:28:32,530
這裡的關鍵洞察力
在這些門有號

601
00:28:32,530 --> 00:28:37,390
在他們身後被整理的，理想的
外賣的是，你可以做

602
00:28:37,390 --> 00:28:39,670
在根本上更好
本次example--

603
00:28:39,670 --> 00:28:42,380
而事實上，這是肖恩的
第一次嘗試用隨機數

604
00:28:42,380 --> 00:28:45,460
正如before--但只要
作為這些數進行排序，

605
00:28:45,460 --> 00:28:47,980
像電話簿，
你能很明顯嗎？

606
00:28:47,980 --> 00:28:50,090
或者，你如何利用這些知識？

607
00:28:50,090 --> 00:28:51,530
是啊。

608
00:28:51,530 --> 00:28:54,910
>> 聽眾：你走到半路[聽不清]。

609
00:28:54,910 --> 00:28:55,660
馬蘭大衛：是啊。

610
00:28:55,660 --> 00:28:56,160
沒錯。

611
00:28:56,160 --> 00:28:59,680
所以Ajay的初始反應是
檢查結束後，我記得，

612
00:28:59,680 --> 00:29:02,320
然後排序，我們完成
這個例子很快。

613
00:29:02,320 --> 00:29:05,220
但是，如果我們開始做這個多
有條不紊地沿著這些線路，

614
00:29:05,220 --> 00:29:07,860
但是，在可能開始
中間，因為他們排序，

615
00:29:07,860 --> 00:29:10,900
只要我們揭示
16號，所以我們知道 - 

616
00:29:10,900 --> 00:29:14,850
，讓我們做的正是that--我們
因此，知道50，在今天的情況下，

617
00:29:14,850 --> 00:29:16,080
已經該殺到右側。

618
00:29:16,080 --> 00:29:18,735
所以，就像在零一周時
我們在半撕電話簿

619
00:29:18,735 --> 00:29:21,490
扔一半
的問題了，在這裡同樣的想法。

620
00:29:21,490 --> 00:29:23,680
我們可以拋出這個半
這個問題了。

621
00:29:23,680 --> 00:29:25,730
也可能是你
可能會做算法上，

622
00:29:25,730 --> 00:29:28,710
一旦你知道，50必須
在正確的，如果它的任何地方，

623
00:29:28,710 --> 00:29:31,390
是嘗試在那裡，在中間
的其餘的門。

624
00:29:31,390 --> 00:29:33,450
當然，圖50是高
超過42，所以我們可以

625
00:29:33,450 --> 00:29:36,060
拋出這個剩餘
四分之一的問題了，

626
00:29:36,060 --> 00:29:38,510
並且，最後，確定
像50。

627
00:29:38,510 --> 00:29:41,050
但是，就像用
電話簿，這些數字

628
00:29:41,050 --> 00:29:44,560
在給予我們已經
有序，這給我們留下

629
00:29:44,560 --> 00:29:47,450
有問題，你怎麼了
得到的東西進入的排序順序？

630
00:29:47,450 --> 00:29:49,640
而且，坦率地說，代價是什麼？

631
00:29:49,640 --> 00:29:51,390
這是一件事是
遞給電話簿

632
00:29:51,390 --> 00:29:54,810
然後通過找到打動你的朋友
電話號碼真的很快，對不對？

633
00:29:54,810 --> 00:29:58,520
撕裂32頁開始尋找
人出四十億的網頁，

634
00:29:58,520 --> 00:30:00,470
我們說的是一個極端的例子。

635
00:30:00,470 --> 00:30:03,320
但是有多少時候都不需要
Verizon公司進行排序的電話簿？

636
00:30:03,320 --> 00:30:06,170
它沒有多少時間帶我們
這七個數字排序？

637
00:30:06,170 --> 00:30:10,110
這是我們一直的問題
迄今完全忽略。

638
00:30:10,110 --> 00:30:12,330
>> 現在讓我們回答這個問題。

639
00:30:12,330 --> 00:30:15,920
而且我們都出電影了，
但是我們確實有一些壓力球。

640
00:30:15,920 --> 00:30:19,480
如果，比如說，8名志願者
不介意加入我們了嗎？

641
00:30:19,480 --> 00:30:24,100
讓我們繼續做，怎麼樣
你們四個，你們三個在這裡？

642
00:30:24,100 --> 00:30:25,290
得到一些新的面孔。

643
00:30:25,290 --> 00:30:27,220
和你們四個有？

644
00:30:27,220 --> 00:30:30,760
和now--我們不要偏見這裡 - 和
數字8在這裡就完了。

645
00:30:30,760 --> 00:30:32,060
上來吧。

646
00:30:32,060 --> 00:30:32,560
好吧。

647
00:30:32,560 --> 00:30:37,480
所以，我們在這裡為
你們每個人是一個數字。

648
00:30:37,480 --> 00:30:40,055
如果你想去
未來，拿這個號碼。

649
00:30:40,055 --> 00:30:40,763
你叫什麼名字？

650
00:30:40,763 --> 00:30:41,950
>> ARTIE：阿蒂。

651
00:30:41,950 --> 00:30:43,100
>> 大衛馬蘭：阿蒂，好吧。

652
00:30:43,100 --> 00:30:44,297
你是1號。

653
00:30:44,297 --> 00:30:45,310
>> 阿明：阿明。

654
00:30:45,310 --> 00:30:46,060
大衛馬蘭：阿明。

655
00:30:46,060 --> 00:30:46,820
大衛。

656
00:30:46,820 --> 00:30:47,530
你是2號。

657
00:30:47,530 --> 00:30:49,100
並繼續前進，因為我的手
你的紙的片材，

658
00:30:49,100 --> 00:30:52,130
排隊了自己在音樂面前
站在相同的順序在那裡。

659
00:30:52,130 --> 00:30:52,660
>> 安迪：嗨，安迪。

660
00:30:52,660 --> 00:30:53,970
>> 大衛馬蘭：安迪，很高興見到你。

661
00:30:53,970 --> 00:30:54,520
3號。

662
00:30:54,520 --> 00:30:55,310
>> 雅各雅各。

663
00:30:55,310 --> 00:30:56,760
>> 大衛馬蘭：雅各，4號。

664
00:30:56,760 --> 00:30:57,549
歡迎登機。

665
00:30:57,549 --> 00:30:58,090
格蘭特：格蘭特。

666
00:30:58,090 --> 00:30:58,881
大衛馬蘭：格蘭特。

667
00:30:58,881 --> 00:31:00,348
號碼5。

668
00:31:00,348 --> 00:31:01,200
>> ALANNA：Alanna。

669
00:31:01,200 --> 00:31:02,766
>> 大衛馬蘭：Alanna，6號。

670
00:31:02,766 --> 00:31:03,589
>> FRANCES：弗朗西斯。

671
00:31:03,589 --> 00:31:04,880
大衛馬蘭：弗朗西斯，7號。

672
00:31:04,880 --> 00:31:05,200
和？

673
00:31:05,200 --> 00:31:05,830
>> RACHEL：瑞秋。

674
00:31:05,830 --> 00:31:06,815
>> 大衛馬蘭：雷切爾，8號。

675
00:31:06,815 --> 00:31:07,100
好吧。

676
00:31:07,100 --> 00:31:08,766
來吧，讓自己在這個秩序。

677
00:31:08,766 --> 00:31:11,440
讓我把剩下的一個
樂譜架的地方。

678
00:31:11,440 --> 00:31:13,670
你在哪裡需要一個立場？

679
00:31:13,670 --> 00:31:14,170
行。

680
00:31:14,170 --> 00:31:18,710
來吧，只要把你的號碼
那裡的觀眾可以看到他們，

681
00:31:18,710 --> 00:31:20,340
在樂譜架朝外。

682
00:31:20,340 --> 00:31:27,240
並希望，我們的第一個
完整性檢查這裡 -  4，2，6。

683
00:31:27,240 --> 00:31:27,890
哦，哦。

684
00:31:27,890 --> 00:31:29,070
等待一分鐘。

685
00:31:29,070 --> 00:31:31,140
我們沒有8。

686
00:31:31,140 --> 00:31:35,180
我需要從你驅逐
這個例子莫名其妙。

687
00:31:35,180 --> 00:31:35,680
號

688
00:31:35,680 --> 00:31:36,940
不，沒關係。

689
00:31:36,940 --> 00:31:37,890
讓我們來看看。

690
00:31:37,890 --> 00:31:38,880
我們可以做到這一點。

691
00:31:38,880 --> 00:31:39,440
支持。

692
00:31:39,440 --> 00:31:43,970

693
00:31:43,970 --> 00:31:45,740
我們走吧。

694
00:31:45,740 --> 00:31:46,800
正確。

695
00:31:46,800 --> 00:31:47,360
好吧。

696
00:31:47,360 --> 00:31:50,260
所以，現在我們有8個，1，3 7 5。

697
00:31:50,260 --> 00:31:50,760
行。

698
00:31:50,760 --> 00:31:51,360
優秀的。

699
00:31:51,360 --> 00:31:54,400
>> 因此，目前的問題是，在
什麼樣的代價，並通過什麼方法，

700
00:31:54,400 --> 00:31:58,580
可我們實際上這些數字在這裡進行排序
所以那種認為我們可以倒推，

701
00:31:58,580 --> 00:32:02,759
最終，和decide--是不是真的
令人印象深刻的，是不是真的有效，

702
00:32:02,759 --> 00:32:04,550
我可以分裂，
征服電話簿？

703
00:32:04,550 --> 00:32:06,716
是不是真的有效了
我可以分而治之

704
00:32:06,716 --> 00:32:08,600
這些數字件
紙在黑板上，

705
00:32:08,600 --> 00:32:14,500
如果，也許這將花費我們
發跡於時間或精力或CPU週期

706
00:32:14,500 --> 00:32:17,340
真正讓我們的數據
成一些有序？

707
00:32:17,340 --> 00:32:18,930
因此，讓我們問這個問題。

708
00:32:18,930 --> 00:32:22,077
>> 所以，首先，這些數字都是
在幾乎隨機的順序，

709
00:32:22,077 --> 00:32:24,160
而我要建議
一種算法或過程

710
00:32:24,160 --> 00:32:25,970
通過它，我們可以將這些人進行排序。

711
00:32:25,970 --> 00:32:28,100
我要去接近
這個漂亮的天真。

712
00:32:28,100 --> 00:32:30,730
我要去認識
這是種了很多對我來說

713
00:32:30,730 --> 00:32:32,890
環繞在我的腦海
全部數據設定為一次。

714
00:32:32,890 --> 00:32:33,640
但是你知道嗎？

715
00:32:33,640 --> 00:32:37,450
我要做出一些
很簡單的邊際修正。

716
00:32:37,450 --> 00:32:41,152
4和圖2是不按順序，如果
目標是從1到去多達8。

717
00:32:41,152 --> 00:32:41,860
所以，你知道嗎？

718
00:32:41,860 --> 00:32:43,776
我要擁有你
球員交換，如果切換

719
00:32:43,776 --> 00:32:46,380
物理位置和
您的紙片。

720
00:32:46,380 --> 00:32:47,894
現在4和6，這些都是為了。

721
00:32:47,894 --> 00:32:49,060
我要離開的是。

722
00:32:49,060 --> 00:32:50,227
圖6和8中，那些符合規定。

723
00:32:50,227 --> 00:32:51,185
要離開他們是。

724
00:32:51,185 --> 00:32:52,170
8 AND1，亂序。

725
00:32:52,170 --> 00:32:54,790
如果你們兩個不會介意交換。

726
00:32:54,790 --> 00:32:57,300
現在8和3，如果你們可以交換。

727
00:32:57,300 --> 00:32:59,320
8和7，如果你們可以交換。

728
00:32:59,320 --> 00:33:01,790
8和5，如果你們可以交換。

729
00:33:01,790 --> 00:33:03,980
>> 現在，我是不是做了什麼？

730
00:33:03,980 --> 00:33:05,200
不，顯然不是。

731
00:33:05,200 --> 00:33:07,880
但我所做的
情況較好的，對不對？

732
00:33:07,880 --> 00:33:09,430
什麼又是你的名字，8號？

733
00:33:09,430 --> 00:33:10,055
>> RACHEL：瑞秋。

734
00:33:10,055 --> 00:33:12,850
馬蘭大衛：所以瑞秋有
有效地冒泡很遠，

735
00:33:12,850 --> 00:33:15,660
一路的端
我的數字陣列在這裡。

736
00:33:15,660 --> 00:33:17,310
所以這個問題是種解決。

737
00:33:17,310 --> 00:33:21,670
現在，很明顯，2仍需要
動了一下，4和6和1。

738
00:33:21,670 --> 00:33:24,420
但我似乎已經獲得了
更近些的溶液。

739
00:33:24,420 --> 00:33:26,790
因此，讓我們應用同樣的
天真的啟發式一次。

740
00:33:26,790 --> 00:33:27,690
2和4，確定。

741
00:33:27,690 --> 00:33:28,810
4和6，確定。

742
00:33:28,810 --> 00:33:29,930
圖6和1，毫米毫米。

743
00:33:29,930 --> 00:33:32,230
讓我們來交換。

744
00:33:32,230 --> 00:33:33,200
圖6和3，毫米毫米。

745
00:33:33,200 --> 00:33:34,420
讓我們來交換。

746
00:33:34,420 --> 00:33:35,580
6和7就可以了。

747
00:33:35,580 --> 00:33:36,590
7和5，沒了。

748
00:33:36,590 --> 00:33:37,790
讓我們來交換。

749
00:33:37,790 --> 00:33:38,470
現在圖7和8。

750
00:33:38,470 --> 00:33:39,862
而你叫什麼名字來著？

751
00:33:39,862 --> 00:33:40,570
FRANCES：弗朗西斯。

752
00:33:40,570 --> 00:33:41,445
大衛馬蘭：弗朗西斯。

753
00:33:41,445 --> 00:33:44,230
所以，現在弗朗西斯是，即使一個更好的
位置，因為現在7和8

754
00:33:44,230 --> 00:33:46,440
正確鼓泡到頂部。

755
00:33:46,440 --> 00:33:47,510
因此，2和4，確定。

756
00:33:47,510 --> 00:33:48,720
4和1，我們交換。

757
00:33:48,720 --> 00:33:50,410
4和3，讓我們交換。

758
00:33:50,410 --> 00:33:51,550
4和6，你真行。

759
00:33:51,550 --> 00:33:53,340
6和5，讓我們交換。

760
00:33:53,340 --> 00:33:54,590
而現在那些傢伙都不錯。

761
00:33:54,590 --> 00:33:55,780
我們快到了。

762
00:33:55,780 --> 00:33:57,706
2和1，亂序，所以交換。

763
00:33:57,706 --> 00:33:59,080
現在讓我做一個全面的檢查。

764
00:33:59,080 --> 00:34:03,080
圖2和3，圖3和4，圖4和
5,5和6,6和7,8。

765
00:34:03,080 --> 00:34:05,060
好了，我們就大功告成了。

766
00:34:05,060 --> 00:34:09,310
>> 但代價是什麼沒有我
這些數字在這裡進行排序？

767
00:34:09,310 --> 00:34:13,960
那麼，有多少步驟可能我做
整理這些人的時候走？

768
00:34:13,960 --> 00:34:15,710
好了，我們會回來的問題。

769
00:34:15,710 --> 00:34:18,030
但是，坦率地說，如果你有
有點無聊，這是

770
00:34:18,030 --> 00:34:22,270
種揭示，這是不
也許是最有效的算法。

771
00:34:22,270 --> 00:34:25,230
事實上，坦率地說，我出汗
更來回走動。

772
00:34:25,230 --> 00:34:26,639
這並沒有覺得特別有效率。

773
00:34:26,639 --> 00:34:27,805
因此，讓我們試試別的。

774
00:34:27,805 --> 00:34:31,870
如果你們能重置
你們這八個值。

775
00:34:31,870 --> 00:34:32,969
好工作。

776
00:34:32,969 --> 00:34:36,570
>> 讓我們來看看數字，對於剛
片刻之前，我們嘗試別的東西，

777
00:34:36,570 --> 00:34:38,179
在剛剛發生了什麼。

778
00:34:38,179 --> 00:34:41,330
在這裡，你即將看到一個
這八人的可視化

779
00:34:41,330 --> 00:34:44,719
由此藍色和紅色
線表示數字。

780
00:34:44,719 --> 00:34:46,670
該高了吧，
更大的數目。

781
00:34:46,670 --> 00:34:48,510
酒吧越短，
數字越小。

782
00:34:48,510 --> 00:34:51,560
而且你會看到什麼是在
隨機順序當中超過八人。

783
00:34:51,560 --> 00:34:55,830
你會看到這些酒吧
越來越排序方式是相同的算法，

784
00:34:55,830 --> 00:34:59,890
或指令集，其
我們會打電話給今後冒泡排序。

785
00:34:59,890 --> 00:35:04,000
所以請注意，每一秒左右，
兩個酒吧都照亮了紅色，

786
00:35:04,000 --> 00:35:05,590
由計算機進行比較。

787
00:35:05,590 --> 00:35:08,630
然後如果大條和
小酒吧是亂序，

788
00:35:08,630 --> 00:35:11,220
他們被交換給我。

789
00:35:11,220 --> 00:35:15,120
>> 現在，這是令人難以置信的繁瑣
看這個，當然，

790
00:35:15,120 --> 00:35:18,630
很長，但要注意的
takeaway--大條向右移動，

791
00:35:18,630 --> 00:35:20,460
小棒移動到左側。

792
00:35:20,460 --> 00:35:23,380
讓我們來終止這個進程
並加快這

793
00:35:23,380 --> 00:35:27,330
要快很多，所以我們可以
得到一個什麼樣的高層次感，

794
00:35:27,330 --> 00:35:29,970
的確，冒泡排序在做什麼。

795
00:35:29,970 --> 00:35:33,150
事實上，它的向上冒泡到
列表中的右手側，

796
00:35:33,150 --> 00:35:35,260
或陣列，更大的酒吧。

797
00:35:35,260 --> 00:35:40,020
反之，小酒吧
鼓泡的方式，以左，

798
00:35:40,020 --> 00:35:42,950
雖然以更快的速度
比我們以前做了。

799
00:35:42,950 --> 00:35:45,850
因此，很難看到人，
但在視覺上這確實是

800
00:35:45,850 --> 00:35:46,540
正在發生的事情。

801
00:35:46,540 --> 00:35:49,110
>> 但是，讓我們嘗試從根本上
不同的方法了。

802
00:35:49,110 --> 00:35:52,387
讓我們嘗試不同的
算法即能滿足您

803
00:35:52,387 --> 00:35:59,640
球員開始在這些原
位置，這是這個順序在這裡。

804
00:35:59,640 --> 00:36:00,827
而現在讓我們繼續。

805
00:36:00,827 --> 00:36:02,910
而我要做的事
即使是簡單的，對不對？

806
00:36:02,910 --> 00:36:06,710
現在回想起來，再兩兩交換
又一次，幾乎是小聰明。

807
00:36:06,710 --> 00:36:10,460
讓我們做事情更天真，
在那裡，如果我想這些人進行排序，

808
00:36:10,460 --> 00:36:12,560
讓我繼續找
為最小的元素。

809
00:36:12,560 --> 00:36:14,570
所以現在，4是
最小號我見過。

810
00:36:14,570 --> 00:36:15,695
我要記住這一點。

811
00:36:15,695 --> 00:36:17,750
不，2是更好的，記住這一點。

812
00:36:17,750 --> 00:36:20,730
1更小。

813
00:36:20,730 --> 00:36:21,970
3，7，5。

814
00:36:21,970 --> 00:36:22,470
行。

815
00:36:22,470 --> 00:36:23,750
埃德蒙頓你叫什麼名字來著？

816
00:36:23,750 --> 00:36:24,400
>> ARTIE：阿蒂。

817
00:36:24,400 --> 00:36:24,610
>> 大衛馬蘭：阿蒂。

818
00:36:24,610 --> 00:36:25,460
因此，阿蒂，勇往直前。

819
00:36:25,460 --> 00:36:27,043
我要拉你出來就行了。

820
00:36:27,043 --> 00:36:28,400
如果你能回到這裡來。

821
00:36:28,400 --> 00:36:30,790
我需要騰出空間給他。

822
00:36:30,790 --> 00:36:32,040
我們有一個決策點這裡。

823
00:36:32,040 --> 00:36:36,000
怎麼可能，我們騰出阿蒂這裡
在其中1號所屬的開始？

824
00:36:36,000 --> 00:36:36,770
>> 聽眾：移位。

825
00:36:36,770 --> 00:36:38,950
>> 大衛馬蘭：好了，我們
可能會改變每一個人。

826
00:36:38,950 --> 00:36:40,860
但提出了一個優化。

827
00:36:40,860 --> 00:36:43,410
這感覺有點惱人
我要問四人

828
00:36:43,410 --> 00:36:44,620
一路向下移動。

829
00:36:44,620 --> 00:36:45,520
我還能做什麼？

830
00:36:45,520 --> 00:36:46,360
>> 聽眾：切換。

831
00:36:46,360 --> 00:36:46,850
>> 大衛馬蘭：切換。

832
00:36:46,850 --> 00:36:47,900
而你叫什麼名字來著？

833
00:36:47,900 --> 00:36:48,441
>> 雅各雅各。

834
00:36:48,441 --> 00:36:50,330
大衛馬蘭：雅各移動。

835
00:36:50,330 --> 00:36:54,440
更高效只需要有
與阿蒂雅各互換位置，

836
00:36:54,440 --> 00:36:56,710
而不是迫使
這些人的所有四個，

837
00:36:56,710 --> 00:36:58,734
非常感謝你，給
其正確的位置。

838
00:36:58,734 --> 00:37:01,150
有什麼好的關於阿蒂現在，
他在他的正確位置。

839
00:37:01,150 --> 00:37:02,060
讓我們再次做到這一點。

840
00:37:02,060 --> 00:37:03,730
2，這是最小的數字我見過。

841
00:37:03,730 --> 00:37:05,690
3，7，5。

842
00:37:05,690 --> 00:37:06,190
行。

843
00:37:06,190 --> 00:37:07,467
2，絕對是最小的。

844
00:37:07,467 --> 00:37:08,550
沒有做任何工作。

845
00:37:08,550 --> 00:37:09,320
讓我們再做一次。

846
00:37:09,320 --> 00:37:10,070
6。

847
00:37:10,070 --> 00:37:10,640
最小？

848
00:37:10,640 --> 00:37:11,140
8。

849
00:37:11,140 --> 00:37:11,590
不。

850
00:37:11,590 --> 00:37:11,720
4？

851
00:37:11,720 --> 00:37:12,220
哦。

852
00:37:12,220 --> 00:37:13,420
我記得4。

853
00:37:13,420 --> 00:37:13,950
3。

854
00:37:13,950 --> 00:37:15,110
我記得3。

855
00:37:15,110 --> 00:37:16,080
7,5。

856
00:37:16,080 --> 00:37:18,490
最小的數字我已經
看到這一關就是3。

857
00:37:18,490 --> 00:37:20,340
如果你會來上了。

858
00:37:20,340 --> 00:37:21,986
我們去哪兒把你嗎？

859
00:37:21,986 --> 00:37:22,860
而你叫什麼名字？

860
00:37:22,860 --> 00:37:23,530
>> ALANNA：Alanna。

861
00:37:23,530 --> 00:37:25,780
>> 大衛馬蘭：Alanna，我們
不得不趕你。

862
00:37:25,780 --> 00:37:28,670
但是，這是更有效的，
只是換了兩個人，

863
00:37:28,670 --> 00:37:31,850
比有多人
實際上迴避了。

864
00:37:31,850 --> 00:37:32,850
現在，讓我們再次做到這一點。

865
00:37:32,850 --> 00:37:34,980
我會選擇4，所以就來了。

866
00:37:34,980 --> 00:37:36,540
和誰去動？

867
00:37:36,540 --> 00:37:37,750
8號，當然。

868
00:37:37,750 --> 00:37:40,260
如果我現在發現5號，拜託了。

869
00:37:40,260 --> 00:37:42,104
8號會得到再次驅逐。

870
00:37:42,104 --> 00:37:43,770
我現在要去找到位數6。

871
00:37:43,770 --> 00:37:44,410
7到位。

872
00:37:44,410 --> 00:37:45,080
8就位。

873
00:37:45,080 --> 00:37:48,590
>> 我們剛才所做的是
一些所謂的選擇排序，

874
00:37:48,590 --> 00:37:52,560
如果我們想像這一點，它的
會覺得有一點不同。

875
00:37:52,560 --> 00:37:56,800
讓我們繼續前進，從這個
菜單在這裡，這visualization--

876
00:37:56,800 --> 00:38:02,920
讓我們改變這個to--來吧，Firefox瀏覽器。

877
00:38:02,920 --> 00:38:07,610
讓我們改變這個選擇排序。

878
00:38:07,610 --> 00:38:11,830
讓像以前一樣的加快步伐，
現在開始的可視化。

879
00:38:11,830 --> 00:38:13,990
該算法具有
不同的感覺。

880
00:38:13,990 --> 00:38:16,480
在每次迭代中，坦率地說，
它更簡單。

881
00:38:16,480 --> 00:38:18,385
我只是選擇的最小元素。

882
00:38:18,385 --> 00:38:21,510
現在，坦率地說，我有點幸運，
時間，在它的排序超快。

883
00:38:21,510 --> 00:38:22,660
這些元素是隨機的。

884
00:38:22,660 --> 00:38:25,520
這不是，因為我們最終會
看，根本快。

885
00:38:25,520 --> 00:38:29,400
但是，讓我們看到了第三次也是最後
此方法，因為要發生的事情。

886
00:38:29,400 --> 00:38:36,230
因此，讓我們繼續前進，重新你們
一最後一次是在這裡這個順序。

887
00:38:36,230 --> 00:38:38,450
>> 而現在，我要
有一點更聰明，

888
00:38:38,450 --> 00:38:40,220
只是圓了我們的算法。

889
00:38:40,220 --> 00:38:41,230
我會做到這一點。

890
00:38:41,230 --> 00:38:43,140
我會不會去
來回這麼多。

891
00:38:43,140 --> 00:38:44,900
坦率地說，我已經厭倦了
這一切的穿越。

892
00:38:44,900 --> 00:38:47,691
我只是要帶什麼，我
在列表的開頭給出

893
00:38:47,691 --> 00:38:49,460
我要去排序
那，然後有。

894
00:38:49,460 --> 00:38:50,140
所以，我們在這裡。

895
00:38:50,140 --> 00:38:51,030
4號。

896
00:38:51,030 --> 00:38:53,680
我要插入數
4成排序的列表。

897
00:38:53,680 --> 00:38:54,180
完成。

898
00:38:54,180 --> 00:38:58,300
我現在聲稱，只是讓這個更
顯然，這部分我的列表進行排序。

899
00:38:58,300 --> 00:39:02,610
這是一種愚蠢的索賠，但確確實實
4是按尺寸1的列表。

900
00:39:02,610 --> 00:39:04,210
現在，我要承擔數2。

901
00:39:04,210 --> 00:39:07,670
2號，我現在要
插入到合適的位置。

902
00:39:07,670 --> 00:39:08,680
那麼，這是否屬於2？

903
00:39:08,680 --> 00:39:09,824
顯然，在這裡。

904
00:39:09,824 --> 00:39:11,490
所以，儘管回遷，如果你能。

905
00:39:11,490 --> 00:39:14,406
而為什麼你們不只是把
你的音樂代表了你這一次。

906
00:39:14,406 --> 00:39:17,020
而且，我們強行插入您
到列表的開頭。

907
00:39:17,020 --> 00:39:17,936
所以，更多一點的工作。

908
00:39:17,936 --> 00:39:20,890
我不得不提出雅各布身邊，
而你叫什麼名字？

909
00:39:20,890 --> 00:39:21,420
>> 阿明：阿明。

910
00:39:21,420 --> 00:39:22,270
>> 大衛馬蘭：阿明。

911
00:39:22,270 --> 00:39:24,350
但至少我沒有去來回。

912
00:39:24,350 --> 00:39:25,739
我只是以事，我去。

913
00:39:25,739 --> 00:39:27,530
我只是將它們插入
在正確的地方。

914
00:39:27,530 --> 00:39:29,220
6，其實這是很容易的。

915
00:39:29,220 --> 00:39:31,510
讓我們將你在那邊，如果你
只是想稍微移動了。

916
00:39:31,510 --> 00:39:32,870
8號，也非常的方便。

917
00:39:32,870 --> 00:39:33,741
就在那邊。

918
00:39:33,741 --> 00:39:34,240
該死的。

919
00:39:34,240 --> 00:39:37,590
1號，我們不能只
與阿明在這裡交換，

920
00:39:37,590 --> 00:39:39,340
因為這是怎麼回事
亂了秩序。

921
00:39:39,340 --> 00:39:40,660
因此，我們要多一點聰明。

922
00:39:40,660 --> 00:39:42,770
因此，阿蒂，如果你能
備份了一下。

923
00:39:42,770 --> 00:39:46,550
讓我們繼續前進，現在轉移，
不像我們以前的算法，

924
00:39:46,550 --> 00:39:50,910
讓路給阿蒂
這裡開頭。

925
00:39:50,910 --> 00:39:54,690
所以，在這一天結束時，我種
做什麼，我想避免之前。

926
00:39:54,690 --> 00:39:57,770
所以我的算法排序
逆轉，智，

927
00:39:57,770 --> 00:39:59,070
從它最初是什麼。

928
00:39:59,070 --> 00:40:01,240
我只是在做轉移
在不同的點。

929
00:40:01,240 --> 00:40:02,291
現在，我在3。

930
00:40:02,291 --> 00:40:02,790
哦，該死的。

931
00:40:02,790 --> 00:40:04,039
我們必須重新做更多的工作。

932
00:40:04,039 --> 00:40:05,060
因此，讓我們推你出去。

933
00:40:05,060 --> 00:40:09,360
讓我們繼續前進8,6，4--哦oh--和
3是要去那裡。

934
00:40:09,360 --> 00:40:11,490
所以至少略有節餘這個時候。

935
00:40:11,490 --> 00:40:13,100
7，沒有太多的工作要做。

936
00:40:13,100 --> 00:40:15,370
所以，如果你想彈出
回來了，讓我們來插入你。

937
00:40:15,370 --> 00:40:17,440
最後，圖5，如果你
想彈回，我們

938
00:40:17,440 --> 00:40:22,610
需要轉向你，你，
你，直到5到位。

939
00:40:22,610 --> 00:40:25,670
>> 所以，現在看到了這點
高水平的圖形，

940
00:40:25,670 --> 00:40:31,080
讓我們做這個算法
可視化的一個額外的時間。

941
00:40:31,080 --> 00:40:33,580
所以這個我們稱之為插入排序。

942
00:40:33,580 --> 00:40:37,700
我們會運行它就像
快，從這裡開始吧。

943
00:40:37,700 --> 00:40:39,580
而且，也有不同的感受。

944
00:40:39,580 --> 00:40:42,180
這有點越來越好，
好，但它從來就不是完美

945
00:40:42,180 --> 00:40:44,630
直到我走在光滑的這些差距。

946
00:40:44,630 --> 00:40:47,860
因為，同樣的，我只服用了
我正考慮由左到右。

947
00:40:47,860 --> 00:40:50,350
所以，我沒有那麼幸運了
這一切都是完美的。

948
00:40:50,350 --> 00:40:54,190
這就是為什麼我們有這些小
我們在固定的時間mispositions。

949
00:40:54,190 --> 00:40:58,890
>> 因此，所有這些算法似乎
在略微不同的速度運行。

950
00:40:58,890 --> 00:41:02,030
事實上，你想說的是
最好的或迄今最快？

951
00:41:02,030 --> 00:41:03,450
冒泡排序，第一個？

952
00:41:03,450 --> 00:41:05,000
選擇排序，第二次？

953
00:41:05,000 --> 00:41:08,450
插入排序，第三？

954
00:41:08,450 --> 00:41:10,710
我聽到了一些選擇排序。

955
00:41:10,710 --> 00:41:13,280
其他的想法？

956
00:41:13,280 --> 00:41:16,880
>> 所以，事實證明，
所有這些算法

957
00:41:16,880 --> 00:41:22,400
基本上是一樣有效，因為
每個other--或者相反，正如

958
00:41:22,400 --> 00:41:25,980
低效的，彼此
因為我們能做到從根本上

959
00:41:25,980 --> 00:41:28,120
不是所有的三個好
這些算法。

960
00:41:28,120 --> 00:41:29,990
而這一點善意的謊言的，太。

961
00:41:29,990 --> 00:41:32,580
當我說是有效的
或者效率低下，

962
00:41:32,580 --> 00:41:35,040
這至少為
超級大n值的。

963
00:41:35,040 --> 00:41:38,450
當我們只有八人在這裡，
或者是50元左右吧在屏幕上，

964
00:41:38,450 --> 00:41:41,645
你會發現絕對差異
其中這3種算法。

965
00:41:41,645 --> 00:41:44,020
但隨著N，人數，
或號碼的數目，

966
00:41:44,020 --> 00:41:46,350
或者人在電話號碼
書，或網頁的數

967
00:41:46,350 --> 00:41:48,230
在谷歌的數據庫
變得越來越大，

968
00:41:48,230 --> 00:41:51,650
我們會看到，所有這三個
算法實際上是非常差的。

969
00:41:51,650 --> 00:41:54,060
而我們能做的根本
比這更好。

970
00:41:54,060 --> 00:41:56,830
>> 讓我們來看看，最後，
什麼這些算法可能

971
00:41:56,830 --> 00:41:59,520
聽起來像在
幾人背景

972
00:41:59,520 --> 00:42:03,550
並通過這種方式
可視化在這裡

973
00:42:03,550 --> 00:42:06,860
這將我們介紹給
一些算法。

974
00:42:06,860 --> 00:42:10,330
讓我們繼續前進，並祝賀
在這裡我們的參與者，所有的人

975
00:42:10,330 --> 00:42:11,690
整理自己很好。

976
00:42:11,690 --> 00:42:15,124
如果你想藉此臨別禮物。

977
00:42:15,124 --> 00:42:16,540
你可以把你的號碼也是如此。

978
00:42:16,540 --> 00:42:19,460

979
00:42:19,460 --> 00:42:22,520
你會看到什麼，
或者更確切地說，聽，現在，

980
00:42:22,520 --> 00:42:25,710
是因為我們把聲音
每個這些條

981
00:42:25,710 --> 00:42:28,660
並將其與軟件相關聯，
不同頻率的聲音，

982
00:42:28,660 --> 00:42:33,970
你可以用你的頭腦更audioly
各地各有什麼這些東西

983
00:42:33,970 --> 00:42:34,470
看起來像。

984
00:42:34,470 --> 00:42:39,325
其中第一個是插入排序

985
00:42:39,325 --> 00:42:44,275
>> [音調]

986
00:42:44,275 --> 00:42:47,245

987
00:42:47,245 --> 00:42:49,720
>> 這是冒泡排序。

988
00:42:49,720 --> 00:42:54,175
>> [音調]

989
00:42:54,175 --> 00:43:17,250

990
00:43:17,250 --> 00:43:18,222
>> 選擇排序。

991
00:43:18,222 --> 00:43:22,596
>> [音調]

992
00:43:22,596 --> 00:43:33,570

993
00:43:33,570 --> 00:43:35,150
>> 一些所謂的合併排序。

994
00:43:35,150 --> 00:43:38,140
>> [音調]

995
00:43:38,140 --> 00:43:49,510

996
00:43:49,510 --> 00:43:51,278
>> 侏儒排序。

997
00:43:51,278 --> 00:43:56,390
>> [音調]

998
00:43:56,390 --> 00:44:08,240

999
00:44:08,240 --> 00:44:09,430
>> 這就是它的CS50。

1000
00:44:09,430 --> 00:44:13,360
我們會看到你在星期三。

1001
00:44:13,360 --> 00:44:16,671
>> 旁白：現在，“深
思考“，由Daven法納姆。

1002
00:44:16,671 --> 00:44:19,910

1003
00:44:19,910 --> 00:44:21,590
為什麼一個循環？

1004
00:44:21,590 --> 00:44:23,200
為什麼不讓它變得更好？

1005
00:44:23,200 --> 00:44:25,970
我做了五圈。

1006
00:44:25,970 --> 00:44:28,720
>> [笑]