1
00:00:00,000 --> 00:00:05,530

2
00:00:05,530 --> 00:00:09,790
>> 教授：那麼對於日程
這個星期，沒有那麼多的東西。

3
00:00:09,790 --> 00:00:12,801
但希望非常，非常有幫助
而相關的你們這個星期。

4
00:00:12,801 --> 00:00:15,550
但是，我們要花費可能15，
20分鐘只是快速地說話

5
00:00:15,550 --> 00:00:17,370
有關鏈接列表。

6
00:00:17,370 --> 00:00:19,694
鏈接列表要
被覆蓋在測驗。

7
00:00:19,694 --> 00:00:22,610
因此，或許這將是非常有益
學習一些關於那是什麼。

8
00:00:22,610 --> 00:00:25,210
>> 我們將花費巨大的
當今的大多數節

9
00:00:25,210 --> 00:00:27,640
去在測驗零的實踐問題。

10
00:00:27,640 --> 00:00:30,970
然後，我們可以節省大概有20，30分
在結束對所存疑問

11
00:00:30,970 --> 00:00:32,850
任何人有。

12
00:00:32,850 --> 00:00:34,610
>> 然後，最後
五分鐘，我要去

13
00:00:34,610 --> 00:00:36,467
給泵了講話測驗。

14
00:00:36,467 --> 00:00:38,050
你們都希望在這裡呆了。

15
00:00:38,050 --> 00:00:39,591
因為這將是一個好時機。

16
00:00:39,591 --> 00:00:42,650

17
00:00:42,650 --> 00:00:49,230
>> 好吧，所以一些
材料上的鏈接列表。

18
00:00:49,230 --> 00:00:52,620
他們是如何結構通常是
你有什麼所謂的節點，對不對？

19
00:00:52,620 --> 00:00:54,870
你有這些東西叫做
節點，這是結構。

20
00:00:54,870 --> 00:00:57,360
我去了如何創建
在下一幻燈片的節點。

21
00:00:57,360 --> 00:01:00,680
但是基本上所有鏈接
列出的是數據

22
00:01:00,680 --> 00:01:03,340
通過指針已經被串在一起。

23
00:01:03,340 --> 00:01:09,110
>> 而這樣做的好處，我們有
使用鍊錶以上的，

24
00:01:09,110 --> 00:01:11,280
或許，像陣列，是
一個事實，即在一個陣列

25
00:01:11,280 --> 00:01:15,000
你需要一個連續的塊
內存都在同一個地方，人們

26
00:01:15,000 --> 00:01:16,870
又一個，以便能夠有。

27
00:01:16,870 --> 00:01:20,200
而一個鍊錶，你可以
有記憶的隨機小位

28
00:01:20,200 --> 00:01:23,020
在你的電腦
通過指針串成。

29
00:01:23,020 --> 00:01:26,270
>> 而這樣你
可以訪問信息

30
00:01:26,270 --> 00:01:28,610
附帶一前一後
其他，後等

31
00:01:28,610 --> 00:01:32,720
而不需要的只是一大塊
內存在計算機中的某個地方。

32
00:01:32,720 --> 00:01:35,910
所以這是一個主要的
原因我們使用鏈接列表。

33
00:01:35,910 --> 00:01:40,300
>> 其次，它很容易動態
調整，因為在數組中的鏈接列表，

34
00:01:40,300 --> 00:01:44,720
當你聲明一個數組，
你有某一設定值。

35
00:01:44,720 --> 00:01:47,340
比方說，我想創建
10整數數組。

36
00:01:47,340 --> 00:01:49,970
我創建了10個陣列
整數，僅此而已。

37
00:01:49,970 --> 00:01:50,580
這是10。

38
00:01:50,580 --> 00:01:52,038
我不知道以後的事。

39
00:01:52,038 --> 00:01:53,680
如果我想讓它11，不能做到這一點。

40
00:01:53,680 --> 00:01:55,710
如果我想使它9，不能做到這一點。

41
00:01:55,710 --> 00:01:59,910
>> 而在鏈接列表，你可以添加和
刪除和插入任何你想要的。

42
00:01:59,910 --> 00:02:04,940
您可以動態地調整你的
構建這裡，你的數據結構。

43
00:02:04,940 --> 00:02:08,370
這給了我們很多
更增加了靈活性

44
00:02:08,370 --> 00:02:11,320
我們通常不
有數組。

45
00:02:11,320 --> 00:02:15,210
>> 任何人混淆就基本
如何鏈接列表結構

46
00:02:15,210 --> 00:02:17,930
為什麼我們要使用一個以上的陣列？

47
00:02:17,930 --> 00:02:20,330
是啊，我們就去了詳細
如何真正創建一個。

48
00:02:20,330 --> 00:02:24,121
但是，這只是一種
一般意義上的現在。

49
00:02:24,121 --> 00:02:24,620
酷。

50
00:02:24,620 --> 00:02:28,770
所以陣列串成
這些可愛的小東西

51
00:02:28,770 --> 00:02:29,960
所謂的節點。

52
00:02:29,960 --> 00:02:32,210
所有節點的是一種結構的。

53
00:02:32,210 --> 00:02:36,090
請記住，一個結構是，如果你想
創造了一定類型的變量

54
00:02:36,090 --> 00:02:39,850
在C，它已經不
存在，你作為一個程序員，

55
00:02:39,850 --> 00:02:42,030
實際上可以創建自己。

56
00:02:42,030 --> 00:02:46,540
>> 因此這種類型的數據
結構被稱為一個節點，

57
00:02:46,540 --> 00:02:50,770
實際上已經由我們創造，即
C內自身不存在。

58
00:02:50,770 --> 00:02:53,150
和使用的方式
創建一個是你有沒有

59
00:02:53,150 --> 00:02:57,170
typedef結構的頭部，
它告訴編譯器，我

60
00:02:57,170 --> 00:02:59,640
要創建一個結構。

61
00:02:59,640 --> 00:03:00,830
>> 我們將其命名為“節點”。

62
00:03:00,830 --> 00:03:03,350
而且裡面我們要
在聲明一個變量，

63
00:03:03,350 --> 00:03:05,060
這是要存儲的值。

64
00:03:05,060 --> 00:03:09,320
然後，我們也將
有人稱指針“下一步”

65
00:03:09,320 --> 00:03:12,090
指向下一
節點在鏈接列表。

66
00:03:12,090 --> 00:03:14,730
然後你完成該關
通過只需再次重複節點，

67
00:03:14,730 --> 00:03:17,490
編譯器知道，OK
這是我的結構的結束。

68
00:03:17,490 --> 00:03:22,540
>> 所以在這種方式，我們是一起
創建一個可愛的小陣列

69
00:03:22,540 --> 00:03:25,450
之類的話了
值和一個指針。

70
00:03:25,450 --> 00:03:27,757
你可以將它們鏈接全部
連同那些指針。

71
00:03:27,757 --> 00:03:30,090
使他們能夠都挺會
串成鏈中。

72
00:03:30,090 --> 00:03:32,920

73
00:03:32,920 --> 00:03:34,162
>> 酷。

74
00:03:34,162 --> 00:03:35,453
你能聽到好一點？

75
00:03:35,453 --> 00:03:36,140
>> 聽眾：是的。

76
00:03:36,140 --> 00:03:38,540
>> 教授：好的。

77
00:03:38,540 --> 00:03:44,280
因此，作為你們可以看到的樣子，
一個典型的鍊錶的結構

78
00:03:44,280 --> 00:03:45,500
是你有一個頭。

79
00:03:45,500 --> 00:03:49,460
你有頭值不
被指向任何其他指針。

80
00:03:49,460 --> 00:03:53,177
但它會指向，
或參考，另一個節點。

81
00:03:53,177 --> 00:03:56,510
該節點之後將要引用
在那之後，等等，等等節點

82
00:03:56,510 --> 00:03:59,170
直到你最終打
您的鏈接列表的末尾。

83
00:03:59,170 --> 00:04:00,980
而你是不會有一個指針在那裡。

84
00:04:00,980 --> 00:04:04,659
>> 因此，認為像，在項鍊上，甚至
如果你們做球員，我不知道，

85
00:04:04,659 --> 00:04:06,450
喜歡用水果循環
當你還小。

86
00:04:06,450 --> 00:04:08,590
你願意把它們串起來
並且穿起來掛在脖子上。

87
00:04:08,590 --> 00:04:09,840
認為這是同樣的事情。

88
00:04:09,840 --> 00:04:12,964
你有這些小東西，你
可以串在一起的點一

89
00:04:12,964 --> 00:04:15,291
之後，以一前一後
它，等等，等等

90
00:04:15,291 --> 00:04:17,040
直到你有一個鏈
的數據結構的

91
00:04:17,040 --> 00:04:21,190
你可以使用你喜歡的。

92
00:04:21,190 --> 00:04:27,370
>> 因此，辦法，這我們會
通常插入或刪除

93
00:04:27,370 --> 00:04:30,020
從鏈路的任何節點
列表非常不同

94
00:04:30,020 --> 00:04:31,970
根據所在的節點。

95
00:04:31,970 --> 00:04:34,880
因此，例如，因為
指針總是

96
00:04:34,880 --> 00:04:38,645
指向一個特定的值，
當您刪除或插入一個節點，

97
00:04:38,645 --> 00:04:41,770
你想確保該指針
在所有指向正確的事情。

98
00:04:41,770 --> 00:04:46,200
>> 所以，如果你想有可能插入
與一個的值的新的節點

99
00:04:46,200 --> 00:04:48,379
排序的內部鏈接
列表中，大家都知道在這裡

100
00:04:48,379 --> 00:04:51,170
從圖片中，那將
去頭和兩者之間的，對不對？

101
00:04:51,170 --> 00:04:52,620
因為一個適合那裡。

102
00:04:52,620 --> 00:04:59,060
但以何種方式，我們會做的
是第一個取消引用指針

103
00:04:59,060 --> 00:05:02,160
從頭部和發送那一個。

104
00:05:02,160 --> 00:05:05,040
>> 但是，我們進入了一個問題在這裡。

105
00:05:05,040 --> 00:05:08,280
任何人都可以看看是什麼問題
就是如果我們先提領

106
00:05:08,280 --> 00:05:10,090
從頭部指針嗎？

107
00:05:10,090 --> 00:05:14,202
有什麼問題可以再碰上，如果我們試圖
把它添加到我們的數組的前面？

108
00:05:14,202 --> 00:05:15,409
>> 聽眾：[聽不清]

109
00:05:15,409 --> 00:05:16,200
教授：沒錯。

110
00:05:16,200 --> 00:05:20,000
所以在這裡，我們有一個指針，是
一旦從頭部指向兩種。

111
00:05:20,000 --> 00:05:23,120
但是，如果你擺脫了
指針，你點它一個，

112
00:05:23,120 --> 00:05:26,500
我們現在不知道
去哪裡找到兩個。

113
00:05:26,500 --> 00:05:29,850
因為正如我之前說的，你已經有了一個
內存在計算機中巨塊。

114
00:05:29,850 --> 00:05:31,860
所有這些節點可以
隨機穿插

115
00:05:31,860 --> 00:05:33,350
在計算機上的任何地方。

116
00:05:33,350 --> 00:05:36,140
而你不知道如何
去尋找的。

117
00:05:36,140 --> 00:05:40,420
>> 所以，你需要有指針
指著在結束所有節點。

118
00:05:40,420 --> 00:05:42,420
否則，如果你不小心
提領1

119
00:05:42,420 --> 00:05:44,485
不先分配
價值第一，你

120
00:05:44,485 --> 00:05:47,410
只是要輸
一切之後。

121
00:05:47,410 --> 00:05:49,720
>> 所以，我們要什麼
做的是，你首先

122
00:05:49,720 --> 00:05:53,270
要在創建一個指針
節點要插入。

123
00:05:53,270 --> 00:05:55,270
它指向您
想將它插入到，

124
00:05:55,270 --> 00:05:59,410
然後事後你
能回點的頭一個。

125
00:05:59,410 --> 00:06:02,800
>> 這是否有意義給大家嗎？

126
00:06:02,800 --> 00:06:03,346
太好了。

127
00:06:03,346 --> 00:06:04,720
把它看成就像一個鏈條。

128
00:06:04,720 --> 00:06:07,420
如果添加鏈，
它是一種直觀

129
00:06:07,420 --> 00:06:10,742
你如何去插入的。

130
00:06:10,742 --> 00:06:15,274
>> 好了，這實際上是多
更短的比我想像的還要好，

131
00:06:15,274 --> 00:06:16,690
在鏈接列出了五分鐘的高談闊論。

132
00:06:16,690 --> 00:06:19,960
只是讓你們有
那是基本的想法。

133
00:06:19,960 --> 00:06:23,580
>> 下面我們就針對測驗零議程。

134
00:06:23,580 --> 00:06:24,895
不要讓這種恐嚇你。

135
00:06:24,895 --> 00:06:26,270
我知道這是一個很大的信息。

136
00:06:26,270 --> 00:06:27,580
它看起來很嚇人。

137
00:06:27,580 --> 00:06:33,130
這也是一個很大的，我
認為，CSC一種術語。

138
00:06:33,130 --> 00:06:37,440
事情是十六進制字符串，
指針，動態內存分配

139
00:06:37,440 --> 00:06:40,120
是非常可怕的冠冕堂皇的條款。

140
00:06:40,120 --> 00:06:42,700
>> 但是，我們要打破他們
下來，做一些練習題

141
00:06:42,700 --> 00:06:44,980
所以，你們所有
準備這個考試。

142
00:06:44,980 --> 00:06:47,104
怎麼你們許多有
已經開始學習？

143
00:06:47,104 --> 00:06:50,040

144
00:06:50,040 --> 00:06:53,670
>> 好了，你們可能想
開始入門

145
00:06:53,670 --> 00:06:56,480
上，因為測驗是明天。

146
00:06:56,480 --> 00:06:58,739
或者週四一些你。

147
00:06:58,739 --> 00:07:01,030
是啊，所以我們要去
對一些實際問題。

148
00:07:01,030 --> 00:07:04,600
如果你們都希望拿
出一張紙，一支鉛筆。

149
00:07:04,600 --> 00:07:07,310
我們將只花了
今天的第絕大多數

150
00:07:07,310 --> 00:07:11,590
在看一些的，這麼你們有
以期望在測驗什麼的想法。

151
00:07:11,590 --> 00:07:14,957

152
00:07:14,957 --> 00:07:16,890
>> 確定。

153
00:07:16,890 --> 00:07:19,730
一對夫婦後勤
詳細信息以及，任何人

154
00:07:19,730 --> 00:07:25,120
誰沒有去過那個環節出現，如果
你去cs50.yale.edu，前面

155
00:07:25,120 --> 00:07:28,566
這個頁面有一個鏈接
上面寫著“關於測驗零。”

156
00:07:28,566 --> 00:07:29,440
鏈接需要你。

157
00:07:29,440 --> 00:07:31,065
如果你還沒有看過，請閱讀。

158
00:07:31,065 --> 00:07:34,470
因為它告訴你真的很重要
有關測驗的信息。

159
00:07:34,470 --> 00:07:37,410
>> 我要拔了這一點，從
只是因為，身體，

160
00:07:37,410 --> 00:07:40,200
如果你們不知道在哪裡
走，我們都會有問題。

161
00:07:40,200 --> 00:07:44,220
所以，如果你在一個方面最後
以N，去法學院禮堂。

162
00:07:44,220 --> 00:07:47,500
如果你的最後一個開始以P
到Z，去戴維斯禮堂。

163
00:07:47,500 --> 00:07:50,240
而這僅適用於
人們在週三的部分。

164
00:07:50,240 --> 00:07:53,420
>> 如果你正在服用的測驗
週四，你去SSS 114

165
00:07:53,420 --> 00:07:55,078
在您的演講通常是。

166
00:07:55,078 --> 00:07:55,953
聽眾：[聽不清]

167
00:07:55,953 --> 00:07:59,316

168
00:07:59,316 --> 00:08:01,940
教授：o到Z，你會
前往戴維斯禮堂。

169
00:08:01,940 --> 00:08:03,273
我要改變這種狀況，對吧？

170
00:08:03,273 --> 00:08:05,670

171
00:08:05,670 --> 00:08:09,698
>> 哦，對了，你剛才自動失效。

172
00:08:09,698 --> 00:08:11,753
>> 噢，那是你克里斯塔。

173
00:08:11,753 --> 00:08:15,190

174
00:08:15,190 --> 00:08:16,030
是啊，是我不好。

175
00:08:16,030 --> 00:08:17,610
是的，哦到Z，你會
前往戴維斯Auditorim。

176
00:08:17,610 --> 00:08:19,140
我要解決這個問題，一旦我上傳。

177
00:08:19,140 --> 00:08:20,320
是啊。

178
00:08:20,320 --> 00:08:22,160
>> 然後也未嘗
重要的是心態

179
00:08:22,160 --> 00:08:25,290
是那個星期三，如果你是正式
就讀於週三部分，

180
00:08:25,290 --> 00:08:26,832
你必須把你的測驗上週三。

181
00:08:26,832 --> 00:08:29,706
如果你參加了週四
你必須把你的測驗週四。

182
00:08:29,706 --> 00:08:31,000
而且它是在上課時間。

183
00:08:31,000 --> 00:08:35,970
其中，我覺得它就像1:00到
2:15週三和下午2:30至3:45

184
00:08:35,970 --> 00:08:37,220
在星期四。

185
00:08:37,220 --> 00:08:41,710
>> 如果你有一個不可調和的矛盾，
院長的藉口是唯一的東西，

186
00:08:41,710 --> 00:08:43,030
不幸的是，我們可以採取。

187
00:08:43,030 --> 00:08:45,560
因為我們有一個
請求絕大部分

188
00:08:45,560 --> 00:08:47,970
從週三切換至週四。

189
00:08:47,970 --> 00:08:51,265
我們不能兌現，除非
我們有一個院長的請求。

190
00:08:51,265 --> 00:08:52,650
>> 確定。

191
00:08:52,650 --> 00:08:57,000
這樣我們就得到一個開始前
夫婦的實際問題，

192
00:08:57,000 --> 00:09:00,540
我剛準備走了過來
安迪的幫助提示成功。

193
00:09:00,540 --> 00:09:04,140
你這傢伙，當你學習，你真的
想練手工編寫代碼。

194
00:09:04,140 --> 00:09:07,050
在我第一次
花了CS測驗，我沒有

195
00:09:07,050 --> 00:09:09,960
手練習寫代碼
之前，它是非常

196
00:09:09,960 --> 00:09:11,890
令人震驚的是多麼困難。

197
00:09:11,890 --> 00:09:16,125
>> 當你們不要進入
打字的一切習慣，

198
00:09:16,125 --> 00:09:20,260
說到很自然的被
能有自動完成

199
00:09:20,260 --> 00:09:22,015
括號和分號那裡。

200
00:09:22,015 --> 00:09:23,890
當你寫出來
手，有時是

201
00:09:23,890 --> 00:09:27,100
很，很容易忘記一個分號，
或忘記關閉一個支架，

202
00:09:27,100 --> 00:09:30,970
或忘記關閉一個冒號，
或者類似的東西。

203
00:09:30,970 --> 00:09:34,322
>> 所以，當你手工編寫代碼，
這是一個非常不同的感覺。

204
00:09:34,322 --> 00:09:37,280
所以你們這些傢伙，當你工作
通過一些實際問題，

205
00:09:37,280 --> 00:09:38,904
那就好，真正實踐的今天。

206
00:09:38,904 --> 00:09:41,770
或者明天，我想，如果你
同時在週四的測驗。

207
00:09:41,770 --> 00:09:45,280
>> 其次，我們有上次一樣，
8年的價值實踐

208
00:09:45,280 --> 00:09:47,070
在線測驗。

209
00:09:47,070 --> 00:09:50,759
今年的測驗可能會
非常，非常相似，所有的人。

210
00:09:50,759 --> 00:09:51,800
他們都非常相似。

211
00:09:51,800 --> 00:09:54,220
有種你進入
問題的類型風格

212
00:09:54,220 --> 00:09:57,250
我們要求，類型
功能，我們將它寫的，

213
00:09:57,250 --> 00:09:58,580
等等，等等。

214
00:09:58,580 --> 00:10:01,980
>> 因此，採取這種做法測驗，
尤其是在時間上的限制。

215
00:10:01,980 --> 00:10:05,390
75分鐘做小測驗
沒有很多的時間量。

216
00:10:05,390 --> 00:10:07,254
這是很長很長。

217
00:10:07,254 --> 00:10:09,670
所以你們真的想
以確保你們是

218
00:10:09,670 --> 00:10:11,990
在寫作的習慣
手工代碼快。

219
00:10:11,990 --> 00:10:15,070
因為你不希望第一
時間一看就知道長度的測驗

220
00:10:15,070 --> 00:10:16,560
在你的測驗。

221
00:10:16,560 --> 00:10:20,540
你們真的要確保
你事先練習。

222
00:10:20,540 --> 00:10:24,550
>> 第四，要查看該
講座和部分幻燈片。

223
00:10:24,550 --> 00:10:25,980
你不必記住的東西。

224
00:10:25,980 --> 00:10:30,430
其實，每個人都被允許
一張白紙筆記，

225
00:10:30,430 --> 00:10:31,090
正面和背面。

226
00:10:31,090 --> 00:10:32,920
你們可以鍵入或寫。

227
00:10:32,920 --> 00:10:37,070
如果你發現自己需要記憶
任何東西，把它倒在了表。

228
00:10:37,070 --> 00:10:40,810
>> 我向你保證，你不想
被卡在了競猜的中間

229
00:10:40,810 --> 00:10:43,890
是象，哦，是的，有什麼
運行時這種抗之類的。

230
00:10:43,890 --> 00:10:46,490
只要把它記下來，把它複製
直接從您的筆記紙。

231
00:10:46,490 --> 00:10:50,420
然後，你可以真正地使用你的
大腦思考的問題

232
00:10:50,420 --> 00:10:52,190
而不必記得事實。

233
00:10:52,190 --> 00:10:55,250
所以，真正的利用
任何利基細節

234
00:10:55,250 --> 00:11:00,140
你認為你需要記住，
撲通下來的審查表。

235
00:11:00,140 --> 00:11:02,680
>> 好了，任何問題後勤
關於測驗

236
00:11:02,680 --> 00:11:05,510
在我們開始之前一些
競猜問題的做法？

237
00:11:05,510 --> 00:11:06,416
是嗎？

238
00:11:06,416 --> 00:11:10,040
>> 聽眾：我還沒有機會
看測驗[聽不清]

239
00:11:10,040 --> 00:11:11,757
但它會是
應用居多，

240
00:11:11,757 --> 00:11:14,090
或者是有也將是，
像，知識的問題？

241
00:11:14,090 --> 00:11:14,940
>> 教授：這是一個很大。

242
00:11:14,940 --> 00:11:16,731
因此，該辦法，我
將描述測驗

243
00:11:16,731 --> 00:11:18,810
is--我放在一起
一些實際問題

244
00:11:18,810 --> 00:11:20,960
我從所有的測驗拉。

245
00:11:20,960 --> 00:11:25,210
但你會看到有兩個主要的
類型的問題，我們會問你。

246
00:11:25,210 --> 00:11:28,750
>> 一個是東西非常低的水平的細節。

247
00:11:28,750 --> 00:11:31,720
我們會給你一個小的代碼塊
並說，有一個錯誤在這裡？

248
00:11:31,720 --> 00:11:33,110
什麼會打印出在這裡？

249
00:11:33,110 --> 00:11:35,980
什麼將這段代碼產生，等等。

250
00:11:35,980 --> 00:11:38,710
因此，非常低的水平信息的詳細信息。

251
00:11:38,710 --> 00:11:42,700
>> 而在另一面，我們將有很
高層次的知識為基礎的問題。

252
00:11:42,700 --> 00:11:45,190
你能解釋一下
二進制搜索之間差

253
00:11:45,190 --> 00:11:46,148
和線性搜索？

254
00:11:46,148 --> 00:11:48,500
為什麼我們要
使用一個比其他？

255
00:11:48,500 --> 00:11:49,960
也許，什麼是GDB？

256
00:11:49,960 --> 00:11:51,560
為什麼我們要使用GDB？

257
00:11:51,560 --> 00:11:54,590
更高的層次，更根本的
理解的問題。

258
00:11:54,590 --> 00:11:58,240
所以，你會看到的混合物
他們對你的測驗兩個。

259
00:11:58,240 --> 00:12:01,462
>> 任何其他操作之前，我們
直奔進去？

260
00:12:01,462 --> 00:12:02,879
確定。

261
00:12:02,879 --> 00:12:03,670
聽眾：還有一個。

262
00:12:03,670 --> 00:12:04,030
教授：哦，多了一個。

263
00:12:04,030 --> 00:12:04,340
抱歉。

264
00:12:04,340 --> 00:12:05,631
>> 聽眾：是的，它的一切權利。

265
00:12:05,631 --> 00:12:10,140
所以你說75分鐘是
過短，像這是不可能

266
00:12:10,140 --> 00:12:11,640
我們將完成？

267
00:12:11,640 --> 00:12:13,571
還是一樣，75分鐘
正是盡可能多的時間

268
00:12:13,571 --> 00:12:15,700
因為我們需要的，如果我們
適當的準備？

269
00:12:15,700 --> 00:12:17,450
教授：好了，所以
測驗是具有挑戰性的。

270
00:12:17,450 --> 00:12:19,550
這肯定是具有挑戰性的。

271
00:12:19,550 --> 00:12:21,092
你會發現自己在很短的時間。

272
00:12:21,092 --> 00:12:24,341
你可能會打，像10，
要走15分鐘，而且是喜歡，狗屎。

273
00:12:24,341 --> 00:12:25,520
我有那麼多剩下的工作。

274
00:12:25,520 --> 00:12:26,520
而這完全罰款。

275
00:12:26,520 --> 00:12:28,740
每個人都會有同樣的感覺。

276
00:12:28,740 --> 00:12:31,074
>> 只是很清楚
你有多少時間。

277
00:12:31,074 --> 00:12:33,490
所以這就是為什麼我告訴你
你們做的練習測驗。

278
00:12:33,490 --> 00:12:36,672
因為它確實給人一種很有成就感
什麼樣的測驗將是喜歡。

279
00:12:36,672 --> 00:12:39,130
所以，如果你發現自己被
能夠完成的做法

280
00:12:39,130 --> 00:12:41,671
在一個良好的金額測驗
時間，你可以自己的步伐好，

281
00:12:41,671 --> 00:12:45,695
那麼，你會不會有問題
在週三或週四。

282
00:12:45,695 --> 00:12:46,575
>> 酷。

283
00:12:46,575 --> 00:12:49,200
所以，如果每個人都wants--我想
大多數人都有的紙張

284
00:12:49,200 --> 00:12:49,810
出來了。

285
00:12:49,810 --> 00:12:52,604
我要去基本上只是
給你的樣題，

286
00:12:52,604 --> 00:12:54,520
給你們一樣，一
幾分鐘的時間做他們。

287
00:12:54,520 --> 00:12:59,610
而我們就去了作為一個階級
什麼是他們的答案是。

288
00:12:59,610 --> 00:13:02,860
>> 所以這是一個非常典型的
早期的問題，我們會

289
00:13:02,860 --> 00:13:06,720
問你，只是轉換
不同的鹼基之間的數字。

290
00:13:06,720 --> 00:13:09,070
二進制，因為你們可以
召回，是基地二期。

291
00:13:09,070 --> 00:13:12,470
十進制為基數10，或者我們
作為人類通常解釋。

292
00:13:12,470 --> 00:13:17,120
十六進制是基地16，這是零
到九，以及A至F

293
00:13:17,120 --> 00:13:19,990
>> 因此，有四位數字我
要求你們在這裡進行轉換。

294
00:13:19,990 --> 00:13:23,909
我給你喜歡的，三
四分鐘思考如何

295
00:13:23,909 --> 00:13:25,200
我們會去解決這一點。

296
00:13:25,200 --> 00:13:32,832

297
00:13:32,832 --> 00:13:35,710
>> 聽眾：我們現在可以計算器？

298
00:13:35,710 --> 00:13:37,630
>> 教授：你不會
需要計算器，是的。

299
00:13:37,630 --> 00:13:42,420
我想基本此外，我認為，是
所有你們會被要求做。

300
00:13:42,420 --> 00:14:41,700

301
00:14:41,700 --> 00:14:45,070
>> 而只是讓我有種有意識
當大家都在做的，抬頭，

302
00:14:45,070 --> 00:14:47,429
波，我不知道，微笑，
看起來很高興，如果你就大功告成了。

303
00:14:47,429 --> 00:14:47,929
是啊。

304
00:14:47,929 --> 00:17:21,680

305
00:17:21,680 --> 00:17:23,945
也許兩分鐘。

306
00:17:23,945 --> 00:18:28,080

307
00:18:28,080 --> 00:18:29,600
>> 好吧，讓我們把它研究。

308
00:18:29,600 --> 00:18:31,580
我特意去
給你們的時間更少

309
00:18:31,580 --> 00:18:33,760
比你可能需要
做的一些問題，

310
00:18:33,760 --> 00:18:37,124
只是因為我想確保
我們經歷了一堆問題得到。

311
00:18:37,124 --> 00:18:39,290
因此，沒有，如果你沒有後顧之憂
有機會完成。

312
00:18:39,290 --> 00:18:43,770
只要你有完全確定
如何去了解這一點的想法。

313
00:18:43,770 --> 00:18:45,850
因此，讓我們繼續前進，做第一個。

314
00:18:45,850 --> 00:18:52,690

315
00:18:52,690 --> 00:18:57,870
>> 因此，首先，有沒有人想告訴我
二進制，什麼做所有這些數字

316
00:18:57,870 --> 00:19:00,484
代表他們的價值觀方面？

317
00:19:00,484 --> 00:19:01,250
是嗎？

318
00:19:01,250 --> 00:19:03,349
>> 聽眾：兩到
功率零，二至之一。

319
00:19:03,349 --> 00:19:04,140
教授：沒錯。

320
00:19:04,140 --> 00:19:04,640
所以。

321
00:19:04,640 --> 00:19:13,430

322
00:19:13,430 --> 00:19:16,430
>> 對，所以一般
當我們以10

323
00:19:16,430 --> 00:19:20,580
所有這些代表都一樣，
10到零的基礎上，對不對？

324
00:19:20,580 --> 00:19:21,810
那是你一個人的地方。

325
00:19:21,810 --> 00:19:24,520
所有的10的地方是
10之一的功率。

326
00:19:24,520 --> 00:19:26,600
你100的地方是10
於兩個的功率。

327
00:19:26,600 --> 00:19:29,570
>> 無論基地你在會
做同樣的事情，

328
00:19:29,570 --> 00:19:31,480
只是用不同的基地。

329
00:19:31,480 --> 00:19:34,130
所以二進制，所有這些都是為基地二期。

330
00:19:34,130 --> 00:19:37,110
你要轉換所有
數字分為二的任何權力

331
00:19:37,110 --> 00:19:38,190
那數字。

332
00:19:38,190 --> 00:19:41,450
因此在這個意義上說，我們
可以有一個更簡單的方法

333
00:19:41,450 --> 00:19:43,800
是能夠加起來或
總結所有號碼，以便

334
00:19:43,800 --> 00:19:46,010
轉換成基10。

335
00:19:46,010 --> 00:19:50,362
>> 因此，沒有人想告訴我是什麼
回答第一個是在基地10？

336
00:19:50,362 --> 00:19:51,674
>> 聽眾：二，[聽不清]

337
00:19:51,674 --> 00:19:52,340
教授：是的。

338
00:19:52,340 --> 00:19:53,230
聽眾：42。

339
00:19:53,230 --> 00:19:56,560
教授：42，你去那裡。

340
00:19:56,560 --> 00:20:00,660
因此，我們得到這個答案的方法是通過
在做兩首，這是兩個。

341
00:20:00,660 --> 00:20:02,760
加上兩個第三，這是8。

342
00:20:02,760 --> 00:20:07,590
加上兩個第五，這
是無論是遺留下來的。

343
00:20:07,590 --> 00:20:09,390
你總結起來，它是42。

344
00:20:09,390 --> 00:20:12,000
>> 有沒有人困惑於我們如何得到呢？

345
00:20:12,000 --> 00:20:15,630
所以基本此外，像
我說，你應該確定。

346
00:20:15,630 --> 00:20:17,410
如果不是，那麼，我們可以實踐這一點。

347
00:20:17,410 --> 00:20:18,720
但是，這一切的權利。

348
00:20:18,720 --> 00:20:20,560
酷。

349
00:20:20,560 --> 00:20:25,570
>> 沒有人想給我
回答第二個呢？

350
00:20:25,570 --> 00:20:26,860
>> 50？

351
00:20:26,860 --> 00:20:27,600
好。

352
00:20:27,600 --> 00:20:30,044
任何人都困惑於如何
我們得到了要么？

353
00:20:30,044 --> 00:20:31,960
酷，我將有
答案下一張幻燈片。

354
00:20:31,960 --> 00:20:34,440
如果讓您無後顧之憂
需要複製下來。

355
00:20:34,440 --> 00:20:38,860
>> 好了，十六進制是一個有點棘手。

356
00:20:38,860 --> 00:20:41,840
但我要告訴你的傢伙
對於如何做到這一點的快捷方式。

357
00:20:41,840 --> 00:20:44,800
所以十六進制，你
記住，所有這是是16。

358
00:20:44,800 --> 00:20:48,920
因為我們作為人類實際上並不
有16個數字來表示，

359
00:20:48,920 --> 00:20:56,940
我們從0到9，而我們的第一個
10的值，然後我們做A到F，

360
00:20:56,940 --> 00:20:58,630
這是接下來的六個值。

361
00:20:58,630 --> 00:21:03,040
>> 這樣一來，最簡單的方法從根本
任何二進制數為十六進制

362
00:21:03,040 --> 00:21:05,350
就是將它們分開成兩部分。

363
00:21:05,350 --> 00:21:10,042
所以任何二進制數，我們會給
你可能會有八位數字。

364
00:21:10,042 --> 00:21:11,750
你可以只破
它們在中間。

365
00:21:11,750 --> 00:21:17,460
>> 所以第埃德蒙頓的一個，
一一，一，一，一一。

366
00:21:17,460 --> 00:21:21,340
有種想起來，你知道，畫
斜線或它們之間的逗號。

367
00:21:21,340 --> 00:21:23,800
而且你可以只是轉換
直接無論

368
00:21:23,800 --> 00:21:26,670
這是與第一
十六進制數，

369
00:21:26,670 --> 00:21:29,880
而無論這裡是
十六進制的第二位。

370
00:21:29,880 --> 00:21:37,584
>> 因此，從通用符號記住，
做十六進制值開始是什麼呢？

371
00:21:37,584 --> 00:21:38,460
>> 聽眾：零。

372
00:21:38,460 --> 00:21:39,270
>> 教授：0X。

373
00:21:39,270 --> 00:21:45,210
因此，我們知道，任何時候，我們問你
到任意數量轉換為十六進制，

374
00:21:45,210 --> 00:21:48,230
或任何時候，你看不到任何
數以0x開始，

375
00:21:48,230 --> 00:21:50,230
你知道，這是一個十六進制值。

376
00:21:50,230 --> 00:21:54,160
>> 然後，你將被要求
確定這兩個數字是。

377
00:21:54,160 --> 00:21:59,690
而你做的方式，總結出
一半和清點了一半。

378
00:21:59,690 --> 00:22:02,870
所以在這個例子中，什麼
將一，一，一，一會？

379
00:22:02,870 --> 00:22:04,890
什麼樣的價值會是這樣？

380
00:22:04,890 --> 00:22:06,040
這會是女，對不對？

381
00:22:06,040 --> 00:22:08,050
這會是15。

382
00:22:08,050 --> 00:22:11,780
>> 因此，這將是F.一，
一，一，人在這裡也

383
00:22:11,780 --> 00:22:21,270
F.所以一，一，一，一，一，一，一，
之一，十六進制，全部是為0xFF。

384
00:22:21,270 --> 00:22:25,350
因為這一半代表
女，15的值，

385
00:22:25,350 --> 00:22:27,331
而這一半代表
F時，值15。

386
00:22:27,331 --> 00:22:29,456
因為記得，我們​​是
計數從0到9。

387
00:22:29,456 --> 00:22:35,290
A像10，B為11一樣，F為15。

388
00:22:35,290 --> 00:22:41,690
>> 這是否有道理給大家如何
從我們得到的二進制十六進制？

389
00:22:41,690 --> 00:22:44,595
>> 聽眾：所以我們是怎麼得到
15從一，一，一，一？

390
00:22:44,595 --> 00:22:46,220
教授：是的，這是二進制的，對不對？

391
00:22:46,220 --> 00:22:48,090
想像一下，這僅僅是一個二進制數。

392
00:22:48,090 --> 00:22:50,792
所以，你有兩個到
零，這是其中之一。

393
00:22:50,792 --> 00:22:51,500
聽眾：哦，好。

394
00:22:51,500 --> 00:22:51,670
所以，你只要合計不出來。

395
00:22:51,670 --> 00:22:52,670
>> 教授：是的，然後
你剛才合計了這一點。

396
00:22:52,670 --> 00:22:53,380
這就是它。

397
00:22:53,380 --> 00:22:54,890
>> 聽眾：OK。

398
00:22:54,890 --> 00:22:55,830
>> 教授：OK。

399
00:22:55,830 --> 00:23:00,740
>> 聽眾：所以，如果你的二進制去
為十進制數為十六進制？

400
00:23:00,740 --> 00:23:04,590
>> 教授：這就是
最簡單的方法，這樣做，是的。

401
00:23:04,590 --> 00:23:11,390
你不會為十進制因為
十進制數只有0到9。

402
00:23:11,390 --> 00:23:13,410
我們只是種
這個分裂成兩個。

403
00:23:13,410 --> 00:23:15,201
>> 聽眾：[聽不清]
使用十進制找

404
00:23:15,201 --> 00:23:17,809
它匹配到十六進制什麼。

405
00:23:17,809 --> 00:23:20,100
教授：我的意思是，你是
總結出利用基本的數學。

406
00:23:20,100 --> 00:23:20,725
聽眾：是的。

407
00:23:20,725 --> 00:23:22,300
教授：是啊，漂亮多了。

408
00:23:22,300 --> 00:23:23,630
這是一個有點混亂。

409
00:23:23,630 --> 00:23:26,410
但是，僅僅知道你
可以瓜分什麼

410
00:23:26,410 --> 00:23:28,160
這個值是逼到一半。

411
00:23:28,160 --> 00:23:29,570
你看，這是什麼二進制？

412
00:23:29,570 --> 00:23:30,610
什麼號碼是什麼？

413
00:23:30,610 --> 00:23:33,270
這將是
事情從零到F.

414
00:23:33,270 --> 00:23:35,722
>> 這裡也將是
事情從零到F.

415
00:23:35,722 --> 00:23:37,722
然後你可以把
這兩個在那裡。

416
00:23:37,722 --> 00:23:38,263
>> 聽眾：OK。

417
00:23:38,263 --> 00:23:38,910
教授：是的。

418
00:23:38,910 --> 00:23:39,410
確定。

419
00:23:39,410 --> 00:23:42,320
所以你們要
嘗試下一個呢？

420
00:23:42,320 --> 00:23:49,601
零，一，零壹，
1，零，一零。

421
00:23:49,601 --> 00:23:52,350
我給你們喜歡30秒
因為你可能不知道

422
00:23:52,350 --> 00:23:53,850
招要怎麼做這點。

423
00:23:53,850 --> 00:24:24,950

424
00:24:24,950 --> 00:24:27,381
>> 好了，任何人都希望得到這一個鏡頭？

425
00:24:27,381 --> 00:24:28,774
>> 5AH即可。

426
00:24:28,774 --> 00:24:29,440
教授：5AH即可。

427
00:24:29,440 --> 00:24:30,470
5A。

428
00:24:30,470 --> 00:24:31,340
好。

429
00:24:31,340 --> 00:24:37,050
因此，這在這裡將be--你想
告訴我們你是怎麼得到的？

430
00:24:37,050 --> 00:24:38,920
首先，你怎麼五個？

431
00:24:38,920 --> 00:24:42,030
>> 聽眾：因為零，
1，零個，一個是五。

432
00:24:42,030 --> 00:24:45,170
>> 教授：大家是否明白
為什麼零，一，零個，一個是5？

433
00:24:45,170 --> 00:24:46,260
你有一個在這裡。

434
00:24:46,260 --> 00:24:48,010
你有沒有在兩到第一。

435
00:24:48,010 --> 00:24:50,300
在二至第二，則
有一個，其為四。

436
00:24:50,300 --> 00:24:52,600
所以你加四加
一，您有五個。

437
00:24:52,600 --> 00:24:53,600
每個人都好？

438
00:24:53,600 --> 00:24:54,100
確定。

439
00:24:54,100 --> 00:24:56,570
然後，這是什麼，為什麼？

440
00:24:56,570 --> 00:24:58,350
什麼號碼做了對應？

441
00:24:58,350 --> 00:24:59,350
>> 聽眾：10。

442
00:24:59,350 --> 00:25:00,976
>> 教授：而在基地二期這是什麼？

443
00:25:00,976 --> 00:25:01,850
聽眾：[聽不清]

444
00:25:01,850 --> 00:25:03,010
教授：沒錯。

445
00:25:03,010 --> 00:25:06,370
所以在這裡第二個值是5AH即可。

446
00:25:06,370 --> 00:25:08,410
>> 大家好如何轉換？

447
00:25:08,410 --> 00:25:10,770
這是一個簡單了很多比你認為它是。

448
00:25:10,770 --> 00:25:13,330
我只是想確認
你知道有用的技巧

449
00:25:13,330 --> 00:25:14,950
和技巧如何做到這一點。

450
00:25:14,950 --> 00:25:18,432
>> 聽眾：為什麼你只拆分
它在這樣的中間？

451
00:25:18,432 --> 00:25:21,390
只要是這樣，好吧，我只打算
關心這些第一[聽不清]？

452
00:25:21,390 --> 00:25:24,240
>> 教授：因為這是真正的
這樣的十六進制值表示。

453
00:25:24,240 --> 00:25:26,890
0X，這實際上意味著
沒有什麼比告訴你其他

454
00:25:26,890 --> 00:25:28,710
這是一個十六進制數。

455
00:25:28,710 --> 00:25:31,580
這始終代表
前四位數字。

456
00:25:31,580 --> 00:25:34,330
這始終代表
最後四位數字。

457
00:25:34,330 --> 00:25:37,835
所以，這兩個數字只是
對應於不同比特。

458
00:25:37,835 --> 00:25:39,200
>> 聽眾：所以我們會always--

459
00:25:39,200 --> 00:25:41,830
>> 教授：你總是
要達到8位值。

460
00:25:41,830 --> 00:25:44,580
>> 聽眾：是，僅僅喜歡的事情
這裡還是一個東西全？

461
00:25:44,580 --> 00:25:46,883
教授：這只是一個
在電腦的東西，是的。

462
00:25:46,883 --> 00:25:47,424
聽眾：OK。

463
00:25:47,424 --> 00:25:48,240
真棒。

464
00:25:48,240 --> 00:25:51,290
>> 教授：另外，因此在此示例
我們從二進制轉換為十進制，

465
00:25:51,290 --> 00:25:53,290
從二進制為十六進制。

466
00:25:53,290 --> 00:25:56,610
你們想確保你也
練習周圍走另一條路。

467
00:25:56,610 --> 00:26:03,370
所以，如果我給你0xFF時，你可以
得出了二進制，對吧？

468
00:26:03,370 --> 00:26:06,820
>> 您將˚F成二進制，
這是一，一，一，一，

469
00:26:06,820 --> 00:26:09,380
轉換F到二進制，這
是一，一，一，一。

470
00:26:09,380 --> 00:26:11,310
>> 因此，我們可能會要求你做
周圍的其他方法。

471
00:26:11,310 --> 00:26:14,817
因此，小數為二進制，或者
十六進制到二進制文件。

472
00:26:14,817 --> 00:26:16,650
所以，你想
一定要知道兩者兼得。

473
00:26:16,650 --> 00:26:19,371
我們可能會問你一個
兩者的結合。

474
00:26:19,371 --> 00:26:20,660
>> 是啊，你有問題嗎？

475
00:26:20,660 --> 00:26:22,724
我可以see--你是好？

476
00:26:22,724 --> 00:26:23,348
聽眾：是的。

477
00:26:23,348 --> 00:26:24,560
教授：OK。

478
00:26:24,560 --> 00:26:26,101
我是好抹掉呢？

479
00:26:26,101 --> 00:26:26,600
太好了。

480
00:26:26,600 --> 00:26:33,965

481
00:26:33,965 --> 00:26:40,437
>> 好吧，那麼答案在這裡，如果有人
奇怪的是後來上感到困惑。

482
00:26:40,437 --> 00:26:41,844
確定。

483
00:26:41,844 --> 00:26:46,070
>> 聽眾：它的問題，如果我們把
我們在國會大廈或小寫字母？

484
00:26:46,070 --> 00:26:50,360
>> 教授：它確實是因為
十六進制，按照慣例，

485
00:26:50,360 --> 00:26:52,840
所有字符都大寫。

486
00:26:52,840 --> 00:26:54,650
因此，A到F的
將是大寫的。

487
00:26:54,650 --> 00:26:58,660
如果你把一個小寫一個，我不知道
如果我們必然會將其標記為錯誤的。

488
00:26:58,660 --> 00:27:00,679
但理論上，
這不是技術上

489
00:27:00,679 --> 00:27:01,970
如何你應該有它。

490
00:27:01,970 --> 00:27:03,303
因此，他們都應該是大寫的。

491
00:27:03,303 --> 00:27:05,910
是啊，好問題。

492
00:27:05,910 --> 00:27:07,780
>> 確定。

493
00:27:07,780 --> 00:27:08,790
第二個問題。

494
00:27:08,790 --> 00:27:12,750
這裡要考慮這個可愛的計劃。

495
00:27:12,750 --> 00:27:15,180
我要問的問題，
我會回來這一點。

496
00:27:15,180 --> 00:27:23,170
>> 所以，第一，什麼是標準的內
io.h這是感興趣的項目？

497
00:27:23,170 --> 00:27:26,640
其次，什麼是無效
表示在三線？

498
00:27:26,640 --> 00:27:30,572
第三，什麼是無法返回零
主，如六號線，一般意味著什麼？

499
00:27:30,572 --> 00:27:33,280
如果你們想寫那些
下來，因為我要切換回

500
00:27:33,280 --> 00:27:36,810
以幻燈片只是讓你可以看到代碼。

501
00:27:36,810 --> 00:27:40,400
這是一樣，也許是一個例子
更高層次的問題，我們要求你

502
00:27:40,400 --> 00:27:42,435
意味著一個節目是什麼東西。

503
00:27:42,435 --> 00:27:47,290

504
00:27:47,290 --> 00:27:49,215
>> 每個人都對我好到
回到幻燈片？

505
00:27:49,215 --> 00:27:53,400

506
00:27:53,400 --> 00:27:54,361
OK，涼。

507
00:27:54,361 --> 00:27:57,610
所以，我給你們喜歡也許三
幾分鐘來看看這一個真正的快。

508
00:27:57,610 --> 00:28:41,330

509
00:28:41,330 --> 00:28:44,140
>> OK，所以這一塊的像
相當容易，在概念上。

510
00:28:44,140 --> 00:28:49,280
沒有人想告訴我什麼是
首先通過內部哈希包括

511
00:28:49,280 --> 00:28:52,630
我們的標準io.h庫文件？

512
00:28:52,630 --> 00:28:55,510
我們為什麼需要該庫
包括為這個計劃？

513
00:28:55,510 --> 00:28:56,930
這裡是什麼我們需要它？

514
00:28:56,930 --> 00:28:56,980
>> 是嗎？

515
00:28:56,980 --> 00:28:58,340
>> 聽眾：就是當
你把printf的？

516
00:28:58,340 --> 00:28:59,131
>> 教授：沒錯。

517
00:28:59,131 --> 00:29:01,780
所以printf的，任何時候你
取來自用戶的輸入

518
00:29:01,780 --> 00:29:04,140
和打印的東西
到屏幕上，這是

519
00:29:04,140 --> 00:29:05,600
標準輸入，輸出庫。

520
00:29:05,600 --> 00:29:07,170
你可以把它的方式 - 輸入，輸出。

521
00:29:07,170 --> 00:29:08,430
>> 我有一個輸出？

522
00:29:08,430 --> 00:29:09,207
是的，我做的。

523
00:29:09,207 --> 00:29:12,040
所以，我知道，我總是會
需要標準化i.o庫。

524
00:29:12,040 --> 00:29:16,400
>> 所以printf的是功能
由此我們需要訪問

525
00:29:16,400 --> 00:29:19,370
和包括hashtag包括
標準i.o庫。

526
00:29:19,370 --> 00:29:20,280
確定。

527
00:29:20,280 --> 00:29:22,660
>> 其次，它是什麼無效意味著什麼？

528
00:29:22,660 --> 00:29:26,970
我們有INT主要（無效），哪些呢
在這裡作廢這裡的意思三線？

529
00:29:26,970 --> 00:29:28,080
是啊，在後面。

530
00:29:28,080 --> 00:29:29,020
>> 聽眾：[聽不清]

531
00:29:29,020 --> 00:29:29,920
>> 教授：沒錯。

532
00:29:29,920 --> 00:29:33,320
所以請記住，我們已經學會了
首先是我們的PSET

533
00:29:33,320 --> 00:29:35,360
實際上你可以
指定命令行

534
00:29:35,360 --> 00:29:39,010
論據，你的程序，你
主要功能，需要為你的用戶，

535
00:29:39,010 --> 00:29:39,650
調用它。

536
00:29:39,650 --> 00:29:42,650
如果我們有空隙，這意味著你
可以只直接運行程序

537
00:29:42,650 --> 00:29:44,680
不帶任何命令行參數。

538
00:29:44,680 --> 00:29:46,160
每個人都清楚這一點？

539
00:29:46,160 --> 00:29:46,660
確定。

540
00:29:46,660 --> 00:29:52,850
>> 而最後為什麼我們懶得做
這回零事兒嗎？

541
00:29:52,850 --> 00:29:54,740
為什麼我們甚至有一個int主？

542
00:29:54,740 --> 00:29:57,330
為什麼我們不能只是有無效的主要無效？

543
00:29:57,330 --> 00:29:59,216
是嗎？

544
00:29:59,216 --> 00:30:01,590
聽眾：為了讓我們能
可以肯定的是，程序

545
00:30:01,590 --> 00:30:04,247
成功退出，如
相對於它是否被列。

546
00:30:04,247 --> 00:30:06,580
我們都知道，這是
不同類型的錯誤。

547
00:30:06,580 --> 00:30:07,621
>> 教授：是的，沒錯。

548
00:30:07,621 --> 00:30:10,670
這僅僅是一個很
常規的事情，我們做的，

549
00:30:10,670 --> 00:30:13,840
是，就在年底
你的程序，只是為了確保

550
00:30:13,840 --> 00:30:15,830
你的主要功能
運行正常，

551
00:30:15,830 --> 00:30:17,940
我們總是希望做回零。

552
00:30:17,940 --> 00:30:21,160
即使我們不一定
沒有看到打印的任何地方。

553
00:30:21,160 --> 00:30:25,092
>> 因為作為程序員，你知道的，如果
你有很多不同的代碼行

554
00:30:25,092 --> 00:30:27,050
你不知道在哪裡
這些都走錯了，

555
00:30:27,050 --> 00:30:30,240
如果發生錯誤的要
請確保你得到這個錯誤。

556
00:30:30,240 --> 00:30:33,240
所以，通常，如果出現
錯了，我們將有一個返回一剛

557
00:30:33,240 --> 00:30:34,669
以確保我們知道它是。

558
00:30:34,669 --> 00:30:36,460
所以，如果你看一回
零，即通常

559
00:30:36,460 --> 00:30:38,293
意味著你的程序是
成功執行。

560
00:30:38,293 --> 00:30:40,490

561
00:30:40,490 --> 00:30:40,990
好？

562
00:30:40,990 --> 00:30:45,180

563
00:30:45,180 --> 00:30:45,680
酷。

564
00:30:45,680 --> 00:30:48,710

565
00:30:48,710 --> 00:30:52,680
>> 好了，下面第二個節目。

566
00:30:52,680 --> 00:30:54,827
考慮這一點。

567
00:30:54,827 --> 00:30:56,910
而且，如果你們看到一個
浮動，你們大概可以

568
00:30:56,910 --> 00:31:00,810
有一個很好的想法是什麼
我要問你。

569
00:31:00,810 --> 00:31:05,200
>> 所以，當這個節目
執行，你可以看到，

570
00:31:05,200 --> 00:31:09,330
我聲明一個浮點數
在我的主要功能。

571
00:31:09,330 --> 00:31:13,470
我將其命名為“回答，”而且我的設置
通過10，其等於一個分割。

572
00:31:13,470 --> 00:31:17,860
我打印出，一
小數位，即浮動。

573
00:31:17,860 --> 00:31:19,880
然後我回零。

574
00:31:19,880 --> 00:31:24,470
>> 所以在執行程序時，
回想起貪心現在，

575
00:31:24,470 --> 00:31:26,550
該程序將打印0.0。

576
00:31:26,550 --> 00:31:29,993
大家都知道，希望大家都
知道，一除以10不是0.00，

577
00:31:29,993 --> 00:31:32,350
它是0.1。

578
00:31:32,350 --> 00:31:37,810
但是，解釋為什麼這個方案認為
即1除以10打印0.1其他

579
00:31:37,810 --> 00:31:39,504
超過0.1？

580
00:31:39,504 --> 00:31:42,545
我給你們也許就像30
秒，只是快速地想想

581
00:31:42,545 --> 00:31:43,878
我會回去的計劃。

582
00:31:43,878 --> 00:32:17,800

583
00:32:17,800 --> 00:32:20,290
>> 確定。

584
00:32:20,290 --> 00:32:22,205
任何人想給它一個鏡頭？

585
00:32:22,205 --> 00:32:24,330
在三句話以內，
因為通常我們是

586
00:32:24,330 --> 00:32:27,650
要限制所有的答案
以三句話以內

587
00:32:27,650 --> 00:32:31,130
所以你不只是吐出
隨機的東西到你的測驗。

588
00:32:31,130 --> 00:32:32,740
>> 是的，採取了一槍。

589
00:32:32,740 --> 00:32:36,390
>> 聽眾：所以我覺得有這
所謂的，喜歡的東西，[聽不清]

590
00:32:36,390 --> 00:32:42,320
所以有可能是，例如，
有可能是，象，0.09，

591
00:32:42,320 --> 00:32:47,250
但如你打印第一
位，這將是0.0？

592
00:32:47,250 --> 00:32:49,100
>> 教授：關閉，不完全是。

593
00:32:49,100 --> 00:32:49,810
Christabell？

594
00:32:49,810 --> 00:32:51,770
>> 聽眾：你把一和
10，他們倆都是整數。

595
00:32:51,770 --> 00:32:54,610
這樣一來，方式，它是怎麼回事
存儲它是為一個整數。

596
00:32:54,610 --> 00:32:56,480
這樣一來，最接近的整數將是0.0。

597
00:32:56,480 --> 00:32:57,471
所以這就是0.1。

598
00:32:57,471 --> 00:32:58,970
教授：是的，這是真的很好。

599
00:32:58,970 --> 00:33:00,040
這是正確的答案。

600
00:33:00,040 --> 00:33:03,597
所以這是一個非常混亂
概念很多孩子。

601
00:33:03,597 --> 00:33:06,680
我真的想確保
這是在每個人的頭上加強。

602
00:33:06,680 --> 00:33:10,090
>> 因此，我們所說的浮動
點不精確，

603
00:33:10,090 --> 00:33:12,800
其中的原因有很多
在貪婪的程序

604
00:33:12,800 --> 00:33:17,010
沒有工作，最初是因為
你忘了投你的變數。

605
00:33:17,010 --> 00:33:19,370
那麼，什麼Christabell說
是完全正確的。

606
00:33:19,370 --> 00:33:21,990
>> 一個浮點本質上是不準確的。

607
00:33:21,990 --> 00:33:26,400
因為在一台電腦，正確的，我們有
的存儲器比特的有限數量

608
00:33:26,400 --> 00:33:28,480
我們可以用它來表示數字。

609
00:33:28,480 --> 00:33:33,480
因此，舉例來說，此CS50 ID is--
我認為這是一個64位的計算機。

610
00:33:33,480 --> 00:33:37,520
>> 一個浮點只能代表
由這些比特的有限數量。

611
00:33:37,520 --> 00:33:42,260
所以0.1與無限的零，
這是0.1的，對不對？

612
00:33:42,260 --> 00:33:45,450
但是，我們不能真正存儲
這個數字在我們的電腦。

613
00:33:45,450 --> 00:33:47,810
我們只是沒有
足夠的內存來這樣做。

614
00:33:47,810 --> 00:33:52,340
>> 等的最近近似
什麼是存儲在內存中實際上是

615
00:33:52,340 --> 00:33:55,390
像0.000東西，
什麼，什麼，什麼的。

616
00:33:55,390 --> 00:34:01,240
其中，一旦截斷
它，幾輪下來到0.0。

617
00:34:01,240 --> 00:34:05,640
>> 所以本實施例只是一個
這說明很多問題

618
00:34:05,640 --> 00:34:08,469
我們每當我們
嘗試錯誤做數學

619
00:34:08,469 --> 00:34:11,000
而無需進行轉換為不同的整數。

620
00:34:11,000 --> 00:34:14,870
所以才要警惕這種情況發生的。

621
00:34:14,870 --> 00:34:18,239
>> 在測驗，如果我們給你
代碼塊，它的樣子，

622
00:34:18,239 --> 00:34:19,510
什麼打印出在結束了嗎？

623
00:34:19,510 --> 00:34:24,096
如果它的一些隨機值你
你們應該知道為什麼會發生的事情。

624
00:34:24,096 --> 00:34:24,909
是嗎？

625
00:34:24,909 --> 00:34:27,926
>> 聽眾：截斷是擺脫
某一點後，一切嗎？

626
00:34:27,926 --> 00:34:28,513
[聽不清]

627
00:34:28,513 --> 00:34:30,929
教授：是的，所以實際上
這是一個非常壞的榜樣，

628
00:34:30,929 --> 00:34:37,870
因為0.100無論實際
將截斷下降到0.1。

629
00:34:37,870 --> 00:34:41,389
但是，如果你要運行它 - 我不知道
還記得，因為去年他們

630
00:34:41,389 --> 00:34:42,830
運行它在不同的程序。

631
00:34:42,830 --> 00:34:45,300
他們跑了一種叫做
在CS50電器，其

632
00:34:45,300 --> 00:34:46,389
是從ID不同。

633
00:34:46,389 --> 00:34:48,520
這是一個32位系統，我想。

634
00:34:48,520 --> 00:34:50,290
因此有不同的號碼。

635
00:34:50,290 --> 00:34:53,330
>> 但實際上，只知道
截斷的整個概念

636
00:34:53,330 --> 00:34:54,815
它只是如何削減的事情了。

637
00:34:54,815 --> 00:34:55,690
所以，如果它rounds--

638
00:34:55,690 --> 00:34:56,300
>> 聽眾：沒有四捨五入。

639
00:34:56,300 --> 00:34:57,370
>> 教授：沒錯。

640
00:34:57,370 --> 00:34:57,870
是啊。

641
00:34:57,870 --> 00:35:02,330

642
00:35:02,330 --> 00:35:04,380
酷。

643
00:35:04,380 --> 00:35:05,250
>> 嗨，在後面。

644
00:35:05,250 --> 00:35:07,634
我們只是在看一些
測驗複習題。

645
00:35:07,634 --> 00:35:08,430
>> 好的。

646
00:35:08,430 --> 00:35:10,150
因此，這裡要考慮一個不同的程序。

647
00:35:10,150 --> 00:35:12,797

648
00:35:12,797 --> 00:35:15,380
我想給你們一個
幾分鐘閱讀過這一點。

649
00:35:15,380 --> 00:35:18,588
這是後話，這是一個非常
最近，我想吹了很多你

650
00:35:18,588 --> 00:35:19,142
人的頭腦。

651
00:35:19,142 --> 00:35:21,100
但是，我們要談
通過這又只是

652
00:35:21,100 --> 00:35:24,152
確保你
完全理解它。

653
00:35:24,152 --> 00:35:24,652
確定。

654
00:35:24,652 --> 00:35:41,280

655
00:35:41,280 --> 00:35:41,780
確定。

656
00:35:41,780 --> 00:35:44,342
任何人都需要更多的時間來
通過這個代碼閱讀？

657
00:35:44,342 --> 00:35:45,650
確定。

658
00:35:45,650 --> 00:35:50,630
>> 因此，在我看來，
該程序中，我

659
00:35:50,630 --> 00:35:53,460
創建兩個字符串使用的GetString。

660
00:35:53,460 --> 00:35:55,180
一位名為S和一個叫噸。

661
00:35:55,180 --> 00:35:58,680
如果他們是平等的
等於彼此

662
00:35:58,680 --> 00:36:00,880
它應該打印“你
鍵入同樣的事情。“

663
00:36:00,880 --> 00:36:04,170
>> 但是elsewise，將打印，“你
輸入不同的東西，“對不對？

664
00:36:04,170 --> 00:36:05,990
似乎非常，非常簡單。

665
00:36:05,990 --> 00:36:08,720
但是，但是，如果我真的
嘗試寫這個程序，

666
00:36:08,720 --> 00:36:12,230
看來，即使我
輸入完全相同的琴弦，

667
00:36:12,230 --> 00:36:15,490
它仍然打印出來，“你
輸入不同的東西！“

668
00:36:15,490 --> 00:36:18,020
有誰要採取
射擊為什麼這個程序會

669
00:36:18,020 --> 00:36:20,370
響應該輸入
是不同的，甚至

670
00:36:20,370 --> 00:36:22,090
當文字本身是一樣的嗎？

671
00:36:22,090 --> 00:36:24,870

672
00:36:24,870 --> 00:36:29,170
>> 所以，如果我是input--大衛·愛
用一個例子像媽媽，是嗎？

673
00:36:29,170 --> 00:36:37,890
小寫M-O-M的S，T
等於小寫的M-O-M。

674
00:36:37,890 --> 00:36:40,340
如果說我是跑這
該代碼，為什麼會

675
00:36:40,340 --> 00:36:44,180
打印出“您輸入不同的東西？”

676
00:36:44,180 --> 00:36:46,336
>> 有沒有人需要更多的
時間去想呢？

677
00:36:46,336 --> 00:36:47,294
好吧，我想我們是很好的。

678
00:36:47,294 --> 00:36:48,716
是嗎？

679
00:36:48,716 --> 00:36:53,930
>> 聽眾：好了，所以它的東西有關
在那裡它存儲在內存中，對不對？

680
00:36:53,930 --> 00:36:54,890
>> 教授：是的。

681
00:36:54,890 --> 00:37:00,400
>> 聽眾：當它像，如果這
字符串s存儲在內存spot--

682
00:37:00,400 --> 00:37:01,689
我發明this--為零。

683
00:37:01,689 --> 00:37:02,355
教授：當然。

684
00:37:02,355 --> 00:37:05,290
聽眾：和串T
存儲在內存現貨，

685
00:37:05,290 --> 00:37:11,000
等，167，然後
零不等於167。

686
00:37:11,000 --> 00:37:12,610
>> 教授：沒錯。

687
00:37:12,610 --> 00:37:18,350
好了，記住這個令人難以置信
啟示我們解釋你們

688
00:37:18,350 --> 00:37:21,530
過去的這個星期，那
字符串不真的存在嗎？

689
00:37:21,530 --> 00:37:25,380
當我們創建一些所謂的
字符串我們，在現實中，

690
00:37:25,380 --> 00:37:29,330
創造一種叫焦明星。

691
00:37:29,330 --> 00:37:34,470
所有這是一個指向
一個字符串或字符數組。

692
00:37:34,470 --> 00:37:39,480
>> 因此在這個例子中，如果我
要輸入M-O-M的方式

693
00:37:39,480 --> 00:37:49,350
我的電腦會保存它
內存反斜線零之內，對不對？

694
00:37:49,350 --> 00:37:53,180
這四個字符，字符，
將存儲在某個地方。

695
00:37:53,180 --> 00:37:59,290
>> 然後這四個
字符，反斜線零，

696
00:37:59,290 --> 00:38:01,275
存儲別的地方，對不對？

697
00:38:01,275 --> 00:38:04,685
我不知道在哪裡的地址
是，他們在我的電腦上的某個地方。

698
00:38:04,685 --> 00:38:07,080
但是，我並不確切地知道他們在哪裡。

699
00:38:07,080 --> 00:38:10,170
>> 當我創建一個字符串
S，所有這確實是

700
00:38:10,170 --> 00:38:15,550
是一個指針，指向
啟動這個字符串。

701
00:38:15,550 --> 00:38:21,130
當我創建這個噸價，
所有這些都是一個指向這裡。

702
00:38:21,130 --> 00:38:23,980
所以，當你試圖
劃上等號，並檢查

703
00:38:23,980 --> 00:38:27,710
看是否s是等於
等於T，計算機

704
00:38:27,710 --> 00:38:31,635
實際上只是回歸
你這個M的地址

705
00:38:31,635 --> 00:38:33,390
且m的地址。

706
00:38:33,390 --> 00:38:36,230
而且因為他們是兩個
獨立的部分數據的

707
00:38:36,230 --> 00:38:38,750
存儲在兩個不同的
在您的計算機的地址，

708
00:38:38,750 --> 00:38:41,750
您的計算機永遠不會
識別它們視為相同。

709
00:38:41,750 --> 00:38:43,500
有沒有人要
給一個鏡頭一下我們

710
00:38:43,500 --> 00:38:46,900
必須做的，如果我們想糾正
這一點，有一個正確的正在運行的程序

711
00:38:46,900 --> 00:38:49,360
呢？

712
00:38:49,360 --> 00:38:52,070
想想看，一個幾秒鐘。

713
00:38:52,070 --> 00:38:54,929
我們究竟需要改變
得到這個程序運作

714
00:38:54,929 --> 00:38:56,220
我們希望它發揮作用的方式嗎？

715
00:38:56,220 --> 00:39:17,260

716
00:39:17,260 --> 00:39:18,918
>> 是的，要採取刺傷它？

717
00:39:18,918 --> 00:39:24,082
>> 聽眾：我們可以嘗試取消引用
指針和檢查通​​過陣列？

718
00:39:24,082 --> 00:39:25,540
教授：這是做到這一點的方法之一。

719
00:39:25,540 --> 00:39:27,880
那麼，你叫什麼名字來著？

720
00:39:27,880 --> 00:39:29,010
對不起，提醒我。

721
00:39:29,010 --> 00:39:29,589
>> ZEE：ZEE。

722
00:39:29,589 --> 00:39:32,130
教授：是的，有什麼Zee的
建議絕對會工作。

723
00:39:32,130 --> 00:39:32,629
對嗎？

724
00:39:32,629 --> 00:39:35,730
我們可以取消引用指針
實際上去訪問

725
00:39:35,730 --> 00:39:38,460
這裡內部的物理數據。

726
00:39:38,460 --> 00:39:40,300
我們可以只是比較
整個屏幕。

727
00:39:40,300 --> 00:39:43,670
>> 我們可以說，OK，指針，
給我裡面有什麼在這裡。

728
00:39:43,670 --> 00:39:44,960
它會返回一個m。

729
00:39:44,960 --> 00:39:47,168
我想說，指針，
給我裡面有什麼在這裡。

730
00:39:47,168 --> 00:39:47,750
返回一個m。

731
00:39:47,750 --> 00:39:48,410
難道那些比賽？

732
00:39:48,410 --> 00:39:49,410
是。

733
00:39:49,410 --> 00:39:50,340
然後我們繼續前進。

734
00:39:50,340 --> 00:39:54,240
>> 我們繼續檢查整雙
字符串一路上揚，直到最後

735
00:39:54,240 --> 00:39:56,635
看看如果這些都是平等的，
如果所有的值是相等的。

736
00:39:56,635 --> 00:39:59,680
如果所有的值相等，
那麼我們知道字符串是真實的。

737
00:39:59,680 --> 00:40:01,600
當然，這是我們如何做到這一點？

738
00:40:01,600 --> 00:40:03,930
>> 沒有人感到困惑的任何的嗎？

739
00:40:03,930 --> 00:40:06,970
如何將字符串的整個概念
其實只是指針，

740
00:40:06,970 --> 00:40:08,440
和他們怎麼不真的存在嗎？

741
00:40:08,440 --> 00:40:10,480
為什麼我們得到的錯誤
就像我們得到它的方式嗎？

742
00:40:10,480 --> 00:40:15,070
因為我保證你們，指針
和字符串分配和內存

743
00:40:15,070 --> 00:40:16,470
要上來了。

744
00:40:16,470 --> 00:40:17,410
>> 是嗎？

745
00:40:17,410 --> 00:40:21,072
>> 聽眾：[聽不清]提領
它，你只要把一個明星[聽不清]

746
00:40:21,072 --> 00:40:21,780
教授：沒錯。

747
00:40:21,780 --> 00:40:28,430
因此，要derererence指針方式
去指示器的該地址

748
00:40:28,430 --> 00:40:30,390
將獲得的數據時，值那裡。

749
00:40:30,390 --> 00:40:32,700
而做到這一點的方法是明星的指針。

750
00:40:32,700 --> 00:40:34,262
不要混淆了。

751
00:40:34,262 --> 00:40:35,186
>> 聽眾：[聽不清]。

752
00:40:35,186 --> 00:40:35,852
>> 教授：是的。

753
00:40:35,852 --> 00:40:39,750
聽眾：所以，你可以只寫
如果明星享有平等平等明星噸。

754
00:40:39,750 --> 00:40:40,630
>> 教授：哦，不。

755
00:40:40,630 --> 00:40:40,960
第

756
00:40:40,960 --> 00:40:41,640
>> 聽眾：這是不夠好，對不對？

757
00:40:41,640 --> 00:40:43,760
>> 教授：這不是，因為你
只檢查的第一個字母。

758
00:40:43,760 --> 00:40:46,010
你可能會
需要某種循環的那

759
00:40:46,010 --> 00:40:49,055
通過每一個迭代
字符兩個字符串。

760
00:40:49,055 --> 00:40:49,837
是啊。

761
00:40:49,837 --> 00:40:52,920
所以，如果你想只檢查
如果他們開始使用同樣的事情，

762
00:40:52,920 --> 00:40:58,220
如果，明星可以做
s等於星噸。

763
00:40:58,220 --> 00:41:01,300
然後，你知道，至少他們
開始使用相同的字符。

764
00:41:01,300 --> 00:41:01,952
>> 是嗎？

765
00:41:01,952 --> 00:41:04,056
>> 聽眾：這樣的方式
你這樣做會

766
00:41:04,056 --> 00:41:06,064
像一個嵌入的for循環或指針？

767
00:41:06,064 --> 00:41:06,730
教授：是的。

768
00:41:06,730 --> 00:41:08,170
差不多就只有一個循環。

769
00:41:08,170 --> 00:41:12,430
請記住，大衛在課堂上提到的
免費的語法糖？

770
00:41:12,430 --> 00:41:17,690
而他有這個非常
明星的T令人困惑的事情

771
00:41:17,690 --> 00:41:22,030
加一，其中，將整合
通過它移動指針？

772
00:41:22,030 --> 00:41:29,910
這樣做的更簡單的方法
這是算了筆的我。

773
00:41:29,910 --> 00:41:31,090
>> 所以它只是一個數組。

774
00:41:31,090 --> 00:41:34,630
你會有一個對的方式
循環從零跑到我，在那裡

775
00:41:34,630 --> 00:41:36,580
我是的長度
字符串，你可以只

776
00:41:36,580 --> 00:41:39,510
寫的，而不是做
整個指針，引用的事。

777
00:41:39,510 --> 00:41:43,510
所以，這些事情是完全
相當於您的計算機。

778
00:41:43,510 --> 00:41:45,905
>> 你們可能不會
需要知道的是，

779
00:41:45,905 --> 00:41:48,280
但它的好，只是一種
在後面你的頭腦。

780
00:41:48,280 --> 00:41:52,630
只要知道電腦
識別代碼不同的塊

781
00:41:52,630 --> 00:41:53,890
作為同樣的事情。

782
00:41:53,890 --> 00:41:57,510
因為這僅僅是更為用戶
友好的為我們展示它喜歡它的

783
00:41:57,510 --> 00:41:58,150
陣列。

784
00:41:58,150 --> 00:42:00,990
這只是更容易。

785
00:42:00,990 --> 00:42:02,719
>> 聽眾：所以使用strlen喜歡，get--

786
00:42:02,719 --> 00:42:03,385
教授：是的。

787
00:42:03,385 --> 00:42:03,926
聽眾：OK。

788
00:42:03,926 --> 00:42:05,940
教授：你可以
使用strlen或者，如果你

789
00:42:05,940 --> 00:42:10,420
沒有strlen的，你可以做起來
直到你打反斜線零為。

790
00:42:10,420 --> 00:42:11,568
要么會工作。

791
00:42:11,568 --> 00:42:12,068
是啊。

792
00:42:12,068 --> 00:42:14,871

793
00:42:14,871 --> 00:42:17,996
聽眾：所以這是取消引用每
單個字符，如果我們實際上

794
00:42:17,996 --> 00:42:21,044
編寫這些代碼，我們
可能只是做T支架我

795
00:42:21,044 --> 00:42:22,460
喜歡跟在它前面的明星？

796
00:42:22,460 --> 00:42:27,700
>> 教授：是的，等於等於小號
支架我，然後繼續前進我

797
00:42:27,700 --> 00:42:29,790
下來，直到你打到最後。

798
00:42:29,790 --> 00:42:31,286
啊，這是你會做什麼。

799
00:42:31,286 --> 00:42:33,660
我會其實有下一個
實際例子中，我們當

800
00:42:33,660 --> 00:42:36,740
寫的strlen所以你們會種
對得到它玩了一下周圍。

801
00:42:36,740 --> 00:42:43,567
>> 那麼，在剛剛內存大家清楚，
字符串，指針，質量地址？

802
00:42:43,567 --> 00:42:46,650
一些更高層次的概念，你
將肯定需要知道測驗

803
00:42:46,650 --> 00:42:48,928
明天。

804
00:42:48,928 --> 00:42:49,904
>> 好的。

805
00:42:49,904 --> 00:42:50,404
好。

806
00:42:50,404 --> 00:42:54,824

807
00:42:54,824 --> 00:42:55,324
是的。

808
00:42:55,324 --> 00:42:58,770

809
00:42:58,770 --> 00:43:04,180
好了，一件事，我們也會問
你，因為我們每年都會做一個測驗，是，

810
00:43:04,180 --> 00:43:08,340
假設你已經忘記了（這
我們似乎忘記每年做）

811
00:43:08,340 --> 00:43:10,810
在頭文件strlen的聲明。

812
00:43:10,810 --> 00:43:13,860
因此，我們不得不重寫它自己。

813
00:43:13,860 --> 00:43:16,350
>> 下面是指南列表
我們可以為您介紹

814
00:43:16,350 --> 00:43:20,660
男人，你去假設
S中的字符串不能為空。

815
00:43:20,660 --> 00:43:23,830
你可以假設旨意是
以反斜線結束零。

816
00:43:23,830 --> 00:43:26,670
所以，你知道那是什麼
這將結束與。

817
00:43:26,670 --> 00:43:29,500
>> 及，例如，該
您好長度為五位。

818
00:43:29,500 --> 00:43:32,890
所以，你可以假設，你好
將有5，H-E-L-L-O。

819
00:43:32,890 --> 00:43:35,890
你不必假設
擦屁股零佔的長度。

820
00:43:35,890 --> 00:43:39,720

821
00:43:39,720 --> 00:43:42,300
>> 這裡這最後一件事，不
擔心整數溢出。

822
00:43:42,300 --> 00:43:45,270
曾記否
什麼整數溢出是？

823
00:43:45,270 --> 00:43:48,041
>> 聽眾：超越
的[聽不清]的長度。

824
00:43:48,041 --> 00:43:50,740
>> 教授：是的，你能解釋一下
了一下，這是什麼意思？

825
00:43:50,740 --> 00:43:55,330
>> 聽眾：所以，我想它可以追溯到
前面的截斷的例子。

826
00:43:55,330 --> 00:43:58,380
但是，如果你只有這麼多的數字
超越比特數

827
00:43:58,380 --> 00:44:01,409
實際上你可以為它分配
那種它只是切斷。

828
00:44:01,409 --> 00:44:04,242
教授：是啊，所以一個典型的
電腦，有多少位我們有嗎？

829
00:44:04,242 --> 00:44:05,306
聽眾：32？

830
00:44:05,306 --> 00:44:06,430
教授：是的，32了吧。

831
00:44:06,430 --> 00:44:10,030
所以這是什麼，四
十億，二十億？

832
00:44:10,030 --> 00:44:13,579
四十億，最多四十億
正整數，對不對？

833
00:44:13,579 --> 00:44:15,370
二十億負，
的兩個十億積極的，

834
00:44:15,370 --> 00:44:16,900
要看你怎麼想這樣做。

835
00:44:16,900 --> 00:44:21,470
>> 所以，基本上我們可以有
足夠的整數，可以上去

836
00:44:21,470 --> 00:44:25,800
兩到第31減1，對吧？

837
00:44:25,800 --> 00:44:27,980
因為一旦我們打了兩
第32屆，我們不

838
00:44:27,980 --> 00:44:30,040
有那麼多的記憶在我們的電腦。

839
00:44:30,040 --> 00:44:32,310
>> 因此，從理論上說，我
可以用一個數字來向上

840
00:44:32,310 --> 00:44:34,560
即，像，二至第46次。

841
00:44:34,560 --> 00:44:38,040
這是一個巨大的屁股數，但
理論上可以。

842
00:44:38,040 --> 00:44:42,730
所以，整數溢出是，如果你嘗試
創建一個整數，超出了

843
00:44:42,730 --> 00:44:44,790
您的計算機能夠存儲。

844
00:44:44,790 --> 00:44:46,590
>> 所以你們的
本實施例不具有

845
00:44:46,590 --> 00:44:51,330
擔心我們給你一個巨大的
字符串，它是兩到第32個字符

846
00:44:51,330 --> 00:44:51,830
長。

847
00:44:51,830 --> 00:44:54,010
這將是真正的意思。

848
00:44:54,010 --> 00:44:59,430
>> 好吧，所以我只是想給
你們此基礎結構。

849
00:44:59,430 --> 00:45:02,020
你要創建一個
所謂函數int strlen的，其中

850
00:45:02,020 --> 00:45:08,436
一通，一個char明星，或字符串，
指向字符串稱為第

851
00:45:08,436 --> 00:45:10,820
>> 好吧，每個人都複製下來。

852
00:45:10,820 --> 00:45:13,550

853
00:45:13,550 --> 00:45:14,850
酷。

854
00:45:14,850 --> 00:45:17,020
Oops--其他方式。

855
00:45:17,020 --> 00:45:21,360
>> 因此，這是一種像
這塊難問題，

856
00:45:21,360 --> 00:45:25,320
所以我給你們也許五到
六分鐘那種頭腦風暴

857
00:45:25,320 --> 00:45:27,478
寫這個功能了。

858
00:45:27,478 --> 00:45:29,710
>> 聽眾：我們不
賬戶[聽不清]

859
00:45:29,710 --> 00:45:30,200
我們不必使用整數？

860
00:45:30,200 --> 00:45:31,241
>> 教授：不，你沒有。

861
00:45:31,241 --> 00:48:05,847

862
00:48:05,847 --> 00:48:06,930
我給你們一個提示。

863
00:48:06,930 --> 00:48:12,325
while循環可能會非常有用的在這裡。

864
00:48:12,325 --> 00:48:12,825
是啊。

865
00:48:12,825 --> 00:48:44,995

866
00:48:44,995 --> 00:48:45,495
這裡的

867
00:48:45,495 --> 00:48:45,995
糖果。

868
00:48:45,995 --> 00:48:49,980

869
00:48:49,980 --> 00:48:53,410
糖果也將是可利用
對於測驗，我想。

870
00:48:53,410 --> 00:48:55,315
所以，你們將全部
加糖的明天。

871
00:48:55,315 --> 00:49:01,110

872
00:49:01,110 --> 00:49:02,962
可我 - 你得到它。

873
00:49:02,962 --> 00:49:03,718
>> 聽眾：OK。

874
00:49:03,718 --> 00:49:04,384
教授：是的。

875
00:49:04,384 --> 00:49:10,550

876
00:49:10,550 --> 00:49:11,870
>> 也許30秒鐘左右。

877
00:49:11,870 --> 00:50:02,220

878
00:50:02,220 --> 00:50:07,340
>> 好吧，如果你
不這樣做，無後顧之憂。

879
00:50:07,340 --> 00:50:08,810
我們將通過移動了一起。

880
00:50:08,810 --> 00:50:09,310
確定。

881
00:50:09,310 --> 00:50:13,800
所以我要去剛剛佈局
基本結構此功能在這裡。

882
00:50:13,800 --> 00:50:17,255
詮釋strlen的。

883
00:50:17,255 --> 00:50:20,040

884
00:50:20,040 --> 00:50:23,460
首先，沒有人想告訴
我什麼INT表示？

885
00:50:23,460 --> 00:50:25,160
我們需要有在此功能。

886
00:50:25,160 --> 00:50:26,709
>> 聽眾：STRLEN [聽不清]。

887
00:50:26,709 --> 00:50:27,500
教授：沒錯。

888
00:50:27,500 --> 00:50:31,140
因此，在這裡無論發生什麼事情，
我們需要返回一個整數。

889
00:50:31,140 --> 00:50:36,367
和作為指定
規範，我們要return--

890
00:50:36,367 --> 00:50:37,700
為它去的傢伙，只是繼續前進。

891
00:50:37,700 --> 00:50:40,480
這一切都很好。

892
00:50:40,480 --> 00:50:42,960
吃這一切，所以我沒有
拿回來，其實。

893
00:50:42,960 --> 00:50:46,022

894
00:50:46,022 --> 00:50:48,855
通過int只是意味著你
將要返回一個整數。

895
00:50:48,855 --> 00:50:55,350

896
00:50:55,350 --> 00:50:57,106
>> 這是什麼字符星級S'

897
00:50:57,106 --> 00:50:58,640
這是什麼意思？

898
00:50:58,640 --> 00:51:00,879
>> 聽眾：喜歡，什麼是投入研究。

899
00:51:00,879 --> 00:51:01,670
教授：沒錯。

900
00:51:01,670 --> 00:51:04,142
什麼是差不多的
同樣的事情為char明星？

901
00:51:04,142 --> 00:51:04,850
聽眾：字符串？

902
00:51:04,850 --> 00:51:05,641
教授：沒錯。

903
00:51:05,641 --> 00:51:09,080
因此，所有我們正在做的是給
這是一個指向字符串的指針。

904
00:51:09,080 --> 00:51:09,580
確定。

905
00:51:09,580 --> 00:51:12,860

906
00:51:12,860 --> 00:51:13,360
酷。

907
00:51:13,360 --> 00:51:16,650
>> 另外，不要忘了，如果我們忘記了
給你這些支架，

908
00:51:16,650 --> 00:51:18,330
不要忘了給自己寫。

909
00:51:18,330 --> 00:51:20,720
因為從理論上講，你的代碼是
如果你忘了把它們寫不正確。

910
00:51:20,720 --> 00:51:21,803
只要時刻注意。

911
00:51:21,803 --> 00:51:23,750
象，小東西
你不通知

912
00:51:23,750 --> 00:51:26,917
當你編寫你的筆記本電腦，
因為你的筆記本電腦會為你？

913
00:51:26,917 --> 00:51:28,624
不要忘記，當
你寫的手。

914
00:51:28,624 --> 00:51:29,170
是嗎？

915
00:51:29,170 --> 00:51:30,954
>> 聽眾：但如何不正確的？

916
00:51:30,954 --> 00:51:33,190
就像，我們得到了整個問題錯了嗎？

917
00:51:33,190 --> 00:51:34,190
>> 教授：沒有，沒有。

918
00:51:34,190 --> 00:51:34,860
不要擔心。

919
00:51:34,860 --> 00:51:39,270
它實際上是理論上的可能
讓你得到一個問題滿點

920
00:51:39,270 --> 00:51:41,980
即使你的代碼
從未在現實生活中運行。

921
00:51:41,980 --> 00:51:46,052
我建議你不要嘗試
要做到這一點。

922
00:51:46,052 --> 00:51:48,260
例如，像如果一切
這是這裡是正確的，

923
00:51:48,260 --> 00:51:51,850
但你忘了冒號或支架，
您的代碼將不會運行。

924
00:51:51,850 --> 00:51:53,740
但是，我們可能是仁慈的。

925
00:51:53,740 --> 00:51:54,394
>> 是嗎？

926
00:51:54,394 --> 00:51:56,050
>> 聽眾：你必須
我們的筆跡對此有何評論？

927
00:51:56,050 --> 00:51:57,758
>> 教授：不，不，不
有關後顧之憂。

928
00:51:57,758 --> 00:51:58,440
沒有評論。

929
00:51:58,440 --> 00:51:59,400
風格應該是不錯的。

930
00:51:59,400 --> 00:52:01,470
喜歡就不要斯馬什
一切都在同一行。

931
00:52:01,470 --> 00:52:04,580
我們也不會開心
與你，如果你做到這一點。

932
00:52:04,580 --> 00:52:07,250
>> 有沒有人要
給我的第一行？

933
00:52:07,250 --> 00:52:08,633
提示，這是非常容易的。

934
00:52:08,633 --> 00:52:09,320
>> 是嗎？

935
00:52:09,320 --> 00:52:11,920
>> 聽眾：智力，正等於零。

936
00:52:11,920 --> 00:52:13,734
剛剛成立了櫃檯。

937
00:52:13,734 --> 00:52:15,900
教授：所以我們需要一些
這類反了吧？

938
00:52:15,900 --> 00:52:19,780
我只是將它命名為“算”
為了可讀性。

939
00:52:19,780 --> 00:52:21,265
什麼是我們想將它設置為？

940
00:52:21,265 --> 00:52:21,890
>> 聽眾：零。

941
00:52:21,890 --> 00:52:23,840
教授：是的。

942
00:52:23,840 --> 00:52:24,340
分號。

943
00:52:24,340 --> 00:52:26,250
這也是很奇怪的圖紙分號。

944
00:52:26,250 --> 00:52:28,870
只是練習這樣做。

945
00:52:28,870 --> 00:52:31,990
>> 因此，我們要首先
int類型的計數器。

946
00:52:31,990 --> 00:52:35,360
因為我們要計數如何
許多字符或字母

947
00:52:35,360 --> 00:52:36,780
在這個字符串，對不對？

948
00:52:36,780 --> 00:52:38,330
很容易的第一步。

949
00:52:38,330 --> 00:52:42,140
>> 好吧，也許有點更複雜
現在，我們怎麼辦呢？

950
00:52:42,140 --> 00:52:45,400
有沒有人要
給我的代碼行

951
00:52:45,400 --> 00:52:48,450
這或許能夠幫助環
通過什麼這是？

952
00:52:48,450 --> 00:52:54,540

953
00:52:54,540 --> 00:52:56,900
>> 是啊，在後面勇敢的靈魂？

954
00:52:56,900 --> 00:53:06,832
>> 聽眾：好了，而點
星號了呀，星號，

955
00:53:06,832 --> 00:53:09,465
不等於零，然後做什麼？

956
00:53:09,465 --> 00:53:11,090
教授：這是真的，真的非常接近。

957
00:53:11,090 --> 00:53:11,835
真的很近。

958
00:53:11,835 --> 00:53:13,710
所以，我要解決
兩件事情這一點。

959
00:53:13,710 --> 00:53:18,240
首先，它不完全為零。

960
00:53:18,240 --> 00:53:20,110
這是什麼？

961
00:53:20,110 --> 00:53:22,550
這是空終止，
這是反斜線零。

962
00:53:22,550 --> 00:53:24,960
因此，他們在不同的
術語的他們是如何存儲。

963
00:53:24,960 --> 00:53:26,270
所以，你真的很近。

964
00:53:26,270 --> 00:53:30,330
>> 其次，我們不希望
只是移動指針。

965
00:53:30,330 --> 00:53:32,320
我們要以實際
訪問值，對不對？

966
00:53:32,320 --> 00:53:34,050
所以，我們怎麼辦呢？

967
00:53:34,050 --> 00:53:34,550
很容易的。

968
00:53:34,550 --> 00:53:36,841
不要去想指針，
沒有想到的回憶。

969
00:53:36,841 --> 00:53:38,525
回到本場的2星期

970
00:53:38,525 --> 00:53:39,555
>> 聽眾：[聽不清]。

971
00:53:39,555 --> 00:53:40,680
教授：作為，還記得嗎？

972
00:53:40,680 --> 00:53:41,400
什麼是弦？

973
00:53:41,400 --> 00:53:42,650
他們是如何存儲在內存中？

974
00:53:42,650 --> 00:53:43,300
>> 聽眾：他們提出的。

975
00:53:43,300 --> 00:53:43,810
>> 教授：他們提出。

976
00:53:43,810 --> 00:53:45,550
那麼，如何才能獲得
每個角色裡面？

977
00:53:45,550 --> 00:53:46,466
>> 聽眾：[聽不清]。

978
00:53:46,466 --> 00:53:47,530
教授：沒錯。

979
00:53:47,530 --> 00:53:53,195
所以while--發生的事情裡面嗎？

980
00:53:53,195 --> 00:53:54,940
為S  - 

981
00:53:54,940 --> 00:53:55,920
>> 聽眾：一。

982
00:53:55,920 --> 00:53:58,216
>> 教授：哦，我不存在，不是嗎？

983
00:53:58,216 --> 00:53:59,620
>> 聽眾：哦，算什麼？

984
00:53:59,620 --> 00:54:01,640
>> 教授：我們可以只
使用計數，我們不能？

985
00:54:01,640 --> 00:54:03,050
>> 聽眾：對不起，我把它叫做我。

986
00:54:03,050 --> 00:54:04,341
>> 教授：是的，這一切都很好。

987
00:54:04,341 --> 00:54:06,710

988
00:54:06,710 --> 00:54:10,760
我們有一個變量在這裡這就是
已被宣布為我們的櫃檯。

989
00:54:10,760 --> 00:54:13,650
那麼，為什麼我們不使用
移動通過while循環？

990
00:54:13,650 --> 00:54:15,230
這是否有意義？

991
00:54:15,230 --> 00:54:20,864
>> 因此，儘管count--第有誰想
給我後，這裡發生了什麼？

992
00:54:20,864 --> 00:54:22,030
聽眾：這不等於。

993
00:54:22,030 --> 00:54:23,405
教授：不等於，對不對？

994
00:54:23,405 --> 00:54:26,200
這是爆炸等於，
感嘆號等於，

995
00:54:26,200 --> 00:54:28,500
無論你們想
叫它不equal--

996
00:54:28,500 --> 00:54:29,496
>> 聽眾：[聽不清]。

997
00:54:29,496 --> 00:54:30,990
>> 教授：是的。

998
00:54:30,990 --> 00:54:37,110
記住單引號是一個字符，
雙引號是一個字符串。

999
00:54:37,110 --> 00:54:38,630
在使用它們時要小心。

1000
00:54:38,630 --> 00:54:42,430
所以，當我們正在尋找通過
陣列，最後一個字符，

1001
00:54:42,430 --> 00:54:46,420
我們知道我們不希望
它是反斜線為零。

1002
00:54:46,420 --> 00:54:47,340
>> 因此，雖然。

1003
00:54:47,340 --> 00:54:48,840
我們不是在字符串的結尾。

1004
00:54:48,840 --> 00:54:52,335
什麼是我們想要做的裡面？

1005
00:54:52,335 --> 00:54:55,269
>> 聽眾：我們要添加到
計數器所以它計數加上加？

1006
00:54:55,269 --> 00:54:56,060
教授：沒錯。

1007
00:54:56,060 --> 00:55:03,064
所以在這裡，我們要做的
計數，計數加再加。

1008
00:55:03,064 --> 00:55:03,980
缺少下一行。

1009
00:55:03,980 --> 00:55:05,090
我們快到了。

1010
00:55:05,090 --> 00:55:07,398
什麼是我們忘了怎麼辦？

1011
00:55:07,398 --> 00:55:08,770
>> 聽眾：返回零？

1012
00:55:08,770 --> 00:55:10,820
>> 教授：你想回到零？

1013
00:55:10,820 --> 00:55:12,962
>> 聽眾：沒有，返回的strlen。

1014
00:55:12,962 --> 00:55:13,511
等等。

1015
00:55:13,511 --> 00:55:14,760
教授：存儲在？

1016
00:55:14,760 --> 00:55:15,090
聽眾：計數。

1017
00:55:15,090 --> 00:55:15,589
計數。

1018
00:55:15,589 --> 00:55:17,150
教授：沒錯。

1019
00:55:17,150 --> 00:55:20,760
所以在這裡我們要返回計數。

1020
00:55:20,760 --> 00:55:23,450

1021
00:55:23,450 --> 00:55:25,380
>> 因為我們是
在這裡做ultimately--

1022
00:55:25,380 --> 00:55:29,780
我們有一個計數器變量那
要通過增加我們的字符串。

1023
00:55:29,780 --> 00:55:33,050
我們要繼續前進，保持
去，一圈又一圈在這個循環。

1024
00:55:33,050 --> 00:55:37,700
雖然我們不是在本月底
字符串，它是空終止。

1025
00:55:37,700 --> 00:55:40,410
>> 我們每次經過的時間
它，我們加入到我們的專櫃。

1026
00:55:40,410 --> 00:55:42,640
而且我們要進一步
沿著這個數組。

1027
00:55:42,640 --> 00:55:44,880
而在最後，一旦我們
打空終結，

1028
00:55:44,880 --> 00:55:48,469
我們知道，哦，我們可以
打破，返回計數。

1029
00:55:48,469 --> 00:55:49,260
我們有我們的strlen。

1030
00:55:49,260 --> 00:55:52,280

1031
00:55:52,280 --> 00:55:56,400
>> 是否每個人都得到如何
這是實施？

1032
00:55:56,400 --> 00:55:58,830
雖然loops--我知道我們有沒有
做了太多的他們，

1033
00:55:58,830 --> 00:56:01,240
但它們通常
如果你非常非常有用

1034
00:56:01,240 --> 00:56:05,390
不知道你在什麼停止
條件不一定必須是。

1035
00:56:05,390 --> 00:56:06,220
>> 問題？

1036
00:56:06,220 --> 00:56:10,080
>> 聽眾：我們可以寫空
在while條件？

1037
00:56:10,080 --> 00:56:10,940
>> 教授：當？

1038
00:56:10,940 --> 00:56:15,304
是啊，所以這個問題我有你
球員認為旨意不能為空。

1039
00:56:15,304 --> 00:56:17,220
因為記得，
從理論上說，如果我給你

1040
00:56:17,220 --> 00:56:21,180
一個指針，過大的內存，
它會給你空了吧？

1041
00:56:21,180 --> 00:56:23,770
這就是操作
系統會做。

1042
00:56:23,770 --> 00:56:26,960
>> 所以，如果我沒告訴你承擔
s就為空，則需要檢查。

1043
00:56:26,960 --> 00:56:32,050
所以在這裡，你會怎麼做，如果s
等於等於空，返回之一。

1044
00:56:32,050 --> 00:56:33,028
類似的東西。

1045
00:56:33,028 --> 00:56:34,153
聽眾：[聽不清]為零。

1046
00:56:34,153 --> 00:56:37,287

1047
00:56:37,287 --> 00:56:39,370
教授：好的，我會告訴
你為什麼我們不能這樣做。

1048
00:56:39,370 --> 00:56:43,357
因為記得在內存中，正確的，在這裡。

1049
00:56:43,357 --> 00:56:43,940
我們會去這裡。

1050
00:56:43,940 --> 00:56:49,940

1051
00:56:49,940 --> 00:56:54,090
>> 你有巨大的塊
內存的所有使用網格

1052
00:56:54,090 --> 00:56:56,680
那家店不同的價值觀，對不對？

1053
00:56:56,680 --> 00:57:00,110
因此所有的字符串is--為
例如，如果我們要輸入你好，

1054
00:57:00,110 --> 00:57:05,490
這將是H-E-L-L-O
反斜杠零，對不對？

1055
00:57:05,490 --> 00:57:09,570
然後誰知道，就像是隨機的
東西都是在這裡經過了。

1056
00:57:09,570 --> 00:57:11,220
>> 我們真的不知道那裡的東西。

1057
00:57:11,220 --> 00:57:13,350
所以，如果你做的
而不是反斜杠零，

1058
00:57:13,350 --> 00:57:15,590
空，但不可以為null。

1059
00:57:15,590 --> 00:57:17,680
因為它只是意味著
一些隨機其他的東西

1060
00:57:17,680 --> 00:57:19,270
不屬於在字符串中。

1061
00:57:19,270 --> 00:57:23,219
這樣一來，方式，我們一直都知道
一個字符串結尾是用反斜杠零。

1062
00:57:23,219 --> 00:57:25,760
所以這總是我們如何
檢查以查看一個字符串的末尾。

1063
00:57:25,760 --> 00:57:30,820
>> 空，一切也就意味著，如果你有
一個不存在的指針，首先，

1064
00:57:30,820 --> 00:57:36,160
或者如果你的內存僅僅是如此之大，
你不能返回，那麼這將會是零。

1065
00:57:36,160 --> 00:57:40,150
因此，差異化的時候要非常小心
空之間的差

1066
00:57:40,150 --> 00:57:42,130
和反斜線零。

1067
00:57:42,130 --> 00:57:43,670
是啊。

1068
00:57:43,670 --> 00:57:46,886
>> 每個人都用這個好不好？

1069
00:57:46,886 --> 00:57:48,150
確定。

1070
00:57:48,150 --> 00:57:50,440
>> 所以，我有你們的strlen寫出來的。

1071
00:57:50,440 --> 00:57:53,790
切實我們也可以問你寫的
從A到我，請記住，“Atwoa”

1072
00:57:53,790 --> 00:57:55,400
或不管你們怎麼稱呼它？

1073
00:57:55,400 --> 00:57:58,010
該函數
的Vigenere和愷撒，這

1074
00:57:58,010 --> 00:58:00,900
轉換成ASCII值的整數？

1075
00:58:00,900 --> 00:58:04,360
這也已經拿出了以往的測驗
功能我們要求你寫。

1076
00:58:04,360 --> 00:58:08,280
>> 幾乎所有的功能
你已經使用，是

1077
00:58:08,280 --> 00:58:11,660
很容易寫自己，
傳感器，如低，

1078
00:58:11,660 --> 00:58:14,620
為上，以降低，到上層。

1079
00:58:14,620 --> 00:58:17,964
功能，將轉換
從小寫的字符串為大寫。

1080
00:58:17,964 --> 00:58:19,380
我們都知道該怎麼做了吧？

1081
00:58:19,380 --> 00:58:21,100
這是很容易的。

1082
00:58:21,100 --> 00:58:24,770
只是想確保你
can--它是相同的思維過程。

1083
00:58:24,770 --> 00:58:26,940
你只要通過迭代
你扭轉乾坤。

1084
00:58:26,940 --> 00:58:30,190
你要么計數或當
你把不同的事情。

1085
00:58:30,190 --> 00:58:32,280
>> 我會suggest--我
不知道，如果我們要

1086
00:58:32,280 --> 00:58:39,080
請你記住什麼資本A或
資本Z或小寫字母A或小寫

1087
00:58:39,080 --> 00:58:42,640
z是在ASCII，但我會建議
也許寫下來的情況下，

1088
00:58:42,640 --> 00:58:44,124
我們做的。

1089
00:58:44,124 --> 00:58:45,540
只是讓你們有一個參考。

1090
00:58:45,540 --> 00:58:47,180
像大寫字母A是什麼，197？

1091
00:58:47,180 --> 00:58:51,320
然後小寫就像50的東西。

1092
00:58:51,320 --> 00:58:52,492
65，是啊，你去那裡。

1093
00:58:52,492 --> 00:58:54,950
所以才非常了解
它們之間的區別是32。

1094
00:58:54,950 --> 00:58:57,670
這是非常重要的。

1095
00:58:57,670 --> 00:58:58,170
是啊。

1096
00:58:58,170 --> 00:59:01,445
我是好上呢？

1097
00:59:01,445 --> 00:59:01,945
確定。

1098
00:59:01,945 --> 00:59:03,109
>> 聽眾：我們可以
理論上寫一些

1099
00:59:03,109 --> 00:59:04,410
這些下降，以及對我們的little--

1100
00:59:04,410 --> 00:59:07,035
>> 教授：你從理論上
可以只複製功能下降。

1101
00:59:07,035 --> 00:59:08,482
這是真的。

1102
00:59:08,482 --> 00:59:11,080
>> 聽眾：不[聽不清]。

1103
00:59:11,080 --> 00:59:12,720
>> 教授：你們有一個表。

1104
00:59:12,720 --> 00:59:14,194
你們有一個筆記紙。

1105
00:59:14,194 --> 00:59:14,860
您可以鍵入它。

1106
00:59:14,860 --> 00:59:15,490
你可以把它寫。

1107
00:59:15,490 --> 00:59:17,031
你可以做任何你想做的事情。

1108
00:59:17,031 --> 00:59:18,530
是啊。

1109
00:59:18,530 --> 00:59:21,406
因此從理論上說，如果
你想，去的。

1110
00:59:21,406 --> 00:59:23,338
>> 聽眾：[聽不清]
但我們真的不

1111
00:59:23,338 --> 00:59:25,994
一定要記住
值，我們可以只

1112
00:59:25,994 --> 00:59:28,914
使用於上或
較低的功能，對不對？

1113
00:59:28,914 --> 00:59:29,580
教授：是的。

1114
00:59:29,580 --> 00:59:32,740
但是，如果我們給你個問題
上面寫著寫上，

1115
00:59:32,740 --> 00:59:34,350
那麼你就需要把它寫。

1116
00:59:34,350 --> 00:59:38,150
所以你們可以假設你
人可以訪問所有功能，

1117
00:59:38,150 --> 00:59:41,523
但如果你要使用上或
較低的，你怎麼還可以做什麼？

1118
00:59:41,523 --> 00:59:43,840
>> 聽眾：[聽不清]
使用CS50 [聽不清]

1119
00:59:43,840 --> 00:59:44,840
>> 教授：是不是CS50.h？

1120
00:59:44,840 --> 00:59:47,320

1121
00:59:47,320 --> 00:59:48,310
要小心在那裡。

1122
00:59:48,310 --> 00:59:50,640
>> 所以要上，以降低，
為上，較低，

1123
00:59:50,640 --> 00:59:52,990
涉及功能
字符串操作是

1124
00:59:52,990 --> 00:59:55,490
所有在任一ASCII碼
或數學庫中

1125
00:59:55,490 --> 00:59:57,350
或串庫中。

1126
00:59:57,350 --> 01:00:00,290
所以，如果你們使用那些
功能，小心要記住

1127
01:00:00,290 --> 01:00:01,451
以包括報頭。

1128
01:00:01,451 --> 01:00:03,950
因此，或許也未嘗您
希望在您的工作表，包括，

1129
01:00:03,950 --> 01:00:04,892
什麼是頭？

1130
01:00:04,892 --> 01:00:06,600
什麼是圖書館
你一直在使用？

1131
01:00:06,600 --> 01:00:08,550
什麼功能
裡面那些庫？

1132
01:00:08,550 --> 01:00:09,230
這一點很重要。

1133
01:00:09,230 --> 01:00:10,420
>> 是嗎？

1134
01:00:10,420 --> 01:00:12,570
>> 聽眾：我們能不能只
警察出去做包括hashtag

1135
01:00:12,570 --> 01:00:14,955
通過絕對
每次我們有生以來信

1136
01:00:14,955 --> 01:00:17,340
見過像所有的問題嗎？

1137
01:00:17,340 --> 01:00:18,320
>> 教授：你可以。

1138
01:00:18,320 --> 01:00:20,361
我不知道有多開心
我們要成為等級

1139
01:00:20,361 --> 01:00:25,090
該測驗時每一段代碼
是兩倍長它需要。

1140
01:00:25,090 --> 01:00:27,200
我不知道，我們可能
騰飛點的風格。

1141
01:00:27,200 --> 01:00:28,790
但理論上你
代碼將是正確的。

1142
01:00:28,790 --> 01:00:30,915
你們能警察出來，
只包含一切。

1143
01:00:30,915 --> 01:00:32,044
這是一件好事，是的。

1144
01:00:32,044 --> 01:00:32,960
聽眾：[聽不清]。

1145
01:00:32,960 --> 01:00:33,270
教授：是的。

1146
01:00:33,270 --> 01:00:34,900
我建議不這樣做，雖然。

1147
01:00:34,900 --> 01:00:35,505
是啊。

1148
01:00:35,505 --> 01:00:36,130
聽眾：酷。

1149
01:00:36,130 --> 01:00:36,620
教授：這個問題問得好。

1150
01:00:36,620 --> 01:00:37,480
聽眾：所以，最壞的情況。

1151
01:00:37,480 --> 01:00:38,563
教授：在最壞的情況下。

1152
01:00:38,563 --> 01:00:40,350
如果你完全忘記了，
你能做到這一點。

1153
01:00:40,350 --> 01:00:40,850
是啊。

1154
01:00:40,850 --> 01:00:43,870

1155
01:00:43,870 --> 01:00:45,400
>> 是的，代碼就在這裡。

1156
01:00:45,400 --> 01:00:49,176
我使用的n個，而不是計數，但你
知道的，不管你的船浮筒。

1157
01:00:49,176 --> 01:00:51,092
聽眾：等等，所以我們
就不必＃標籤

1158
01:00:51,092 --> 01:00:53,460
包括因為我們
在開始的詮釋？

1159
01:00:53,460 --> 01:00:56,150

1160
01:00:56,150 --> 01:00:59,924
>> 教授：是的，我只是假設
我們被要求寫的功能。

1161
01:00:59,924 --> 01:01:02,340
如果你想成為安全起見，你
也許可以把它放在那裡。

1162
01:01:02,340 --> 01:01:05,650
但我只是沒有理會，是的。

1163
01:01:05,650 --> 01:01:09,919
>> 我甚至不知道你
不需要任何庫這一點。

1164
01:01:09,919 --> 01:01:12,710
因為你沒有真正打印
出任何事或任何東西，對不對？

1165
01:01:12,710 --> 01:01:16,500

1166
01:01:16,500 --> 01:01:19,568
是啊，我不知道
你需要一個圖書館。

1167
01:01:19,568 --> 01:01:22,400
>> 確定。

1168
01:01:22,400 --> 01:01:26,020
這也是多一點沿
對內存的處理線。

1169
01:01:26,020 --> 01:01:27,400
這種有點棘手了。

1170
01:01:27,400 --> 01:01:28,960
想想這一點。

1171
01:01:28,960 --> 01:01:30,580
你有一個叫做FUNC功能。

1172
01:01:30,580 --> 01:01:33,570
我可以把它命名什麼的，
但我選擇FUNC命名。

1173
01:01:33,570 --> 01:01:36,000
我有我上面的主力。

1174
01:01:36,000 --> 01:01:39,790
請記住，你想擁有
主後的函數，

1175
01:01:39,790 --> 01:01:42,370
你要確保你
包括頂的雛形。

1176
01:01:42,370 --> 01:01:45,750
>> 但在這種情況下，它是如此之短
我覺得我可以只

1177
01:01:45,750 --> 01:01:47,260
包括它上蓋的主。

1178
01:01:47,260 --> 01:01:51,170
我並不需要有原型的，
因為它已經上面寫的。

1179
01:01:51,170 --> 01:01:55,430
因此，所有我做我的主要功能
正在創建整數x等於10。

1180
01:01:55,430 --> 01:02:00,490
我打電話給我的FUNC功能，
然後打印一些東西。

1181
01:02:00,490 --> 01:02:02,840
>> 然後這實際上
什麼FUNC做。

1182
01:02:02,840 --> 01:02:04,340
你們要思考這一點。

1183
01:02:04,340 --> 01:02:05,423
因為它是一個有點棘手。

1184
01:02:05,423 --> 01:02:07,220
這是非常，非常棘手，其實。

1185
01:02:07,220 --> 01:02:09,549
想通過這是什麼
程序會輸出。

1186
01:02:09,549 --> 01:02:10,840
我給你們兩分鐘。

1187
01:02:10,840 --> 01:03:36,660

1188
01:03:36,660 --> 01:03:37,891
>> 良好的討論？

1189
01:03:37,891 --> 01:03:38,853
>> 聽眾：是的。

1190
01:03:38,853 --> 01:03:39,815
>> 教授：是的。

1191
01:03:39,815 --> 01:03:42,220
好了，所以這是
棘手的一個原因。

1192
01:03:42,220 --> 01:03:44,845
這就是為什麼我想帶
這對大家的關注。

1193
01:03:44,845 --> 01:03:47,870

1194
01:03:47,870 --> 01:03:51,147
沒有人想給我
一個建議，企圖？

1195
01:03:51,147 --> 01:03:52,230
什麼會這樣打印出來？

1196
01:03:52,230 --> 01:03:53,930
如果你錯了完全罰款。

1197
01:03:53,930 --> 01:03:55,619
是嗎？

1198
01:03:55,619 --> 01:03:59,483
>> 觀眾：我認為這是100和
然後在兩個10分開行。

1199
01:03:59,483 --> 01:04:00,940
>> 教授：和一個10？

1200
01:04:00,940 --> 01:04:03,154
沒有人有任何其他的猜測？

1201
01:04:03,154 --> 01:04:04,150
是嗎？

1202
01:04:04,150 --> 01:04:09,040
>> 聽眾：也許只是10，因為
FUNC沒有返回什麼？

1203
01:04:09,040 --> 01:04:11,610
>> 教授：好了，我們
有猜測頭號

1204
01:04:11,610 --> 01:04:14,990
是猜數二是
只是要打印出10。

1205
01:04:14,990 --> 01:04:17,623
沒有人有任何其他的猜測？

1206
01:04:17,623 --> 01:04:19,654
確定。

1207
01:04:19,654 --> 01:04:21,070
因此，讓我們穿行這一點，對不對？

1208
01:04:21,070 --> 01:04:23,903
每當你得到一段代碼，
不只是看它和像，

1209
01:04:23,903 --> 01:04:25,060
啊，那這麼多東西！

1210
01:04:25,060 --> 01:04:26,460
我很困惑！

1211
01:04:26,460 --> 01:04:28,220
像，讓自己平靜下來。

1212
01:04:28,220 --> 01:04:31,602
只要知道你可以只
期待通過代碼一行行。

1213
01:04:31,602 --> 01:04:32,310
這就是它。

1214
01:04:32,310 --> 01:04:33,840
這就像讀一本書。

1215
01:04:33,840 --> 01:04:38,000
>> 因此，與任何功能，
我們總是從主。

1216
01:04:38,000 --> 01:04:40,860
所以，我們要
開始INT主要無效，

1217
01:04:40,860 --> 01:04:43,010
即使該程序的
已經辦下來了吧？

1218
01:04:43,010 --> 01:04:45,070
開始在主無效。

1219
01:04:45,070 --> 01:04:48,030
詮釋x等於10。

1220
01:04:48,030 --> 01:04:50,400
>> 所以，我要刪除這一點。

1221
01:04:50,400 --> 01:04:55,179

1222
01:04:55,179 --> 01:04:58,470
我要畫的內存，所以您
樣的人能看到發生了什麼。

1223
01:04:58,470 --> 01:05:02,190
>> 記得到這裡，我們有我們的堆棧？

1224
01:05:02,190 --> 01:05:05,810
在這裡，我們有我們的
熱鬧的地方在這裡。

1225
01:05:05,810 --> 01:05:07,470
堆棧長大，對不對？

1226
01:05:07,470 --> 01:05:10,150
而在棧中，你有
電源的功能，以及

1227
01:05:10,150 --> 01:05:12,230
所有電源局部變量。

1228
01:05:12,230 --> 01:05:14,310
>> 所以在這裡，詮釋x等於10。

1229
01:05:14,310 --> 01:05:17,670
在我們的主函數我們
創建了一個變量x。

1230
01:05:17,670 --> 01:05:20,590
我們設置了等於10。

1231
01:05:20,590 --> 01:05:24,200
在這裡，你有一些x和你
設置這等於10，沒錯，

1232
01:05:24,200 --> 01:05:25,400
內為主。

1233
01:05:25,400 --> 01:05:27,430
每個人都好？

1234
01:05:27,430 --> 01:05:28,070
>> 功能。

1235
01:05:28,070 --> 01:05:30,330
所以，現在，我們的主要內
功能，我們稱之為

1236
01:05:30,330 --> 01:05:31,810
我們已經寫了上面的功能。

1237
01:05:31,810 --> 01:05:34,550
所以，我們現在進入了第二個功能。

1238
01:05:34,550 --> 01:05:40,120
我們要創建另一個
變量int x等於100。

1239
01:05:40,120 --> 01:05:42,410
這裡發生的堆棧？

1240
01:05:42,410 --> 01:05:46,980
當你調用一個會發生什麼
函數創建新的變量？

1241
01:05:46,980 --> 01:05:50,038
在堆在這裡發生了什麼？

1242
01:05:50,038 --> 01:05:52,134
>> 聽眾：[聽不清]堆在上面？

1243
01:05:52,134 --> 01:05:52,800
教授：是的。

1244
01:05:52,800 --> 01:05:54,050
因此，它實際上創建了一個副本。

1245
01:05:54,050 --> 01:05:56,560

1246
01:05:56,560 --> 01:05:57,740
它種在上面樁。

1247
01:05:57,740 --> 01:06:00,700
想想stack--一疊
書，一疊任何東西。

1248
01:06:00,700 --> 01:06:06,520
樁之上，先在上
出，後進先出。

1249
01:06:06,520 --> 01:06:08,471
>> 因此，這將在這裡打造一個x。

1250
01:06:08,471 --> 01:06:12,080

1251
01:06:12,080 --> 01:06:14,450
>> 這將有
所有funcs中的變量。

1252
01:06:14,450 --> 01:06:14,950
太好了。

1253
01:06:14,950 --> 01:06:20,980
所以，現在我們有兩個不同的x的是
代表了兩種不同的事物。

1254
01:06:20,980 --> 01:06:24,470
然後我們要打印
出x的整數。

1255
01:06:24,470 --> 01:06:26,430
因此，讓我們打印100，對吧？

1256
01:06:26,430 --> 01:06:29,389
因為這裡是100。

1257
01:06:29,389 --> 01:06:31,680
所以這是第一件事情
這是怎麼回事打印出來。

1258
01:06:31,680 --> 01:06:35,710
由於此函數返回什麼，
既然功能，主要是線

1259
01:06:35,710 --> 01:06:37,070
完成。

1260
01:06:37,070 --> 01:06:39,160
大家好我這麼遠嗎？

1261
01:06:39,160 --> 01:06:43,034
>> 所以我們現在是通過兩個出
三行我們的主要功能。

1262
01:06:43,034 --> 01:06:44,450
現在，我們要在第三行。

1263
01:06:44,450 --> 01:06:46,350
我們要去給printf。

1264
01:06:46,350 --> 01:06:48,222
什麼是主內該X？

1265
01:06:48,222 --> 01:06:49,263
這是什麼代表什麼呢？

1266
01:06:49,263 --> 01:06:52,720

1267
01:06:52,720 --> 01:06:54,280
>> 什麼值為x呢？

1268
01:06:54,280 --> 01:06:55,220
>> 聽眾：100。

1269
01:06:55,220 --> 01:06:56,799
>> 教授：這是100？

1270
01:06:56,799 --> 01:06:57,590
聽眾：仍有10。

1271
01:06:57,590 --> 01:06:58,878
教授：還是10。

1272
01:06:58,878 --> 01:07:00,870
是啊。

1273
01:07:00,870 --> 01:07:06,810
因為還記得，在
我們的FUNC，x等於100。

1274
01:07:06,810 --> 01:07:09,690
但是，如果我們返回
我們的主要功能，

1275
01:07:09,690 --> 01:07:12,440
該變量被存儲在一個
不同的地方，我們的堆棧。

1276
01:07:12,440 --> 01:07:16,250
>> 所以，現在我們需要回到
主堆棧，電源局部變量。

1277
01:07:16,250 --> 01:07:18,460
和這裡x等於10。

1278
01:07:18,460 --> 01:07:20,300
所以，我們要打印出10。

1279
01:07:20,300 --> 01:07:22,530
>> 於是，她是絕對正確的。

1280
01:07:22,530 --> 01:07:25,053
我們將有
輸出的100和10。

1281
01:07:25,053 --> 01:07:25,553
是嗎？

1282
01:07:25,553 --> 01:07:28,700
聽眾：當你的malloc，是它的
堆或堆棧中[聽不清]？

1283
01:07:28,700 --> 01:07:31,950
教授：當你的malloc，
你從堆取內存

1284
01:07:31,950 --> 01:07:32,830
和分配它。

1285
01:07:32,830 --> 01:07:34,950
所以，你不必
惹任何這一點。

1286
01:07:34,950 --> 01:07:38,100
所以我想更大的外賣
這裡是一些所謂的範圍。

1287
01:07:38,100 --> 01:07:39,650
>> 對於那些你們誰是在
審查會議昨晚，

1288
01:07:39,650 --> 01:07:41,080
我們短暫交談這件事。

1289
01:07:41,080 --> 01:07:45,380
範圍定義了如何和
當你的變量存在。

1290
01:07:45,380 --> 01:07:48,050
或在什麼框架
做你的變量存在。

1291
01:07:48,050 --> 01:07:51,690
>> 拇指差不多一般規則
是，你variables--如果你創建它們

1292
01:07:51,690 --> 01:07:56,660
大braces--裡面卻存在
只在那些大括號內。

1293
01:07:56,660 --> 01:08:00,312
>> 因此，例如在我們的功能
FUNC，你看這兩個大括號。

1294
01:08:00,312 --> 01:08:02,020
如果您正在創建
它裡面的東西，

1295
01:08:02,020 --> 01:08:06,500
沒準你正在做的是
創建堆棧和存儲有。

1296
01:08:06,500 --> 01:08:07,430
同樣的事情在主。

1297
01:08:07,430 --> 01:08:09,950
這只是存儲的主要內。

1298
01:08:09,950 --> 01:08:13,560
>> 你也想​​成為
非常，非常小心這裡。

1299
01:08:13,560 --> 01:08:18,310
由於範圍還借給
本身不同的例子。

1300
01:08:18,310 --> 01:08:25,950
因此，例如，一個用於
循環，對於int i等於0。

1301
01:08:25,950 --> 01:08:28,460
我不到，我不知道，10。

1302
01:08:28,460 --> 01:08:32,111
我加再加。

1303
01:08:32,111 --> 01:08:34,560
而你得到了它的內部代碼，對不對？

1304
01:08:34,560 --> 01:08:38,830
>> 在什麼地方這個變量，
我，居然只存在嗎？

1305
01:08:38,830 --> 01:08:40,510
只有裡面的for循環。

1306
01:08:40,510 --> 01:08:43,640
所以，我敢打賭，你們的許多球員都有
可能遇到此錯誤時，

1307
01:08:43,640 --> 01:08:45,930
你在做節目的pset中。

1308
01:08:45,930 --> 01:08:49,990
有多少你們都試圖利用我
for循環外有一個錯誤？

1309
01:08:49,990 --> 01:08:53,310
就像一個未引用的整數
或者類似的東西？

1310
01:08:53,310 --> 01:08:56,069
>> 之所以出現這種情況
是因為在這裡你

1311
01:08:56,069 --> 01:08:59,109
創造的東西，只有
存在在你的for循環。

1312
01:08:59,109 --> 01:09:01,972
如果你嘗試使用它，我不
它的外面確實存在。

1313
01:09:01,972 --> 01:09:04,930
因此，基本上一台電腦說，我
不知道你在說什麼。

1314
01:09:04,930 --> 01:09:08,689
我所知道的是，一個我是
在這裡，但現在已不再。

1315
01:09:08,689 --> 01:09:12,580
>> 所以，如果我要創建一個
對於循環內，對不對？

1316
01:09:12,580 --> 01:09:19,080
而且我要創建一個，
如int j和有它做什麼。

1317
01:09:19,080 --> 01:09:23,689
和你有內部的代碼
這個循環，J只存在這裡。

1318
01:09:23,689 --> 01:09:26,029
但是，這也存在內我。

1319
01:09:26,029 --> 01:09:29,310
所以Ĵ只存在
在這個循環，

1320
01:09:29,310 --> 01:09:33,850
而我存在於整個事情。

1321
01:09:33,850 --> 01:09:34,500
>> 大家都清楚了嗎？

1322
01:09:34,500 --> 01:09:37,416
同樣的事情與條件語句
如果您要創建什麼。

1323
01:09:37,416 --> 01:09:40,390
同樣的事情while循環，如果
您要創建什麼。

1324
01:09:40,390 --> 01:09:42,390
這是一件值得
非常，非常小心。

1325
01:09:42,390 --> 01:09:45,681
因此，這是一個很好的問題，在
某種意義上說，它證明了兩件事情。

1326
01:09:45,681 --> 01:09:47,160
這表明第一，適用範圍。

1327
01:09:47,160 --> 01:09:49,550
它證明
同時內存分配。

1328
01:09:49,550 --> 01:09:54,130
因為你們應該知道，
函數棧向上生長。

1329
01:09:54,130 --> 01:09:56,710
而且，當你調用
功能，您正在創建

1330
01:09:56,710 --> 01:09:59,060
內存基本上是一個新的堆棧。

1331
01:09:59,060 --> 01:10:02,100
即從非常不同
你的主內存是什麼。

1332
01:10:02,100 --> 01:10:03,300
是啊。

1333
01:10:03,300 --> 01:10:03,800
呼！

1334
01:10:03,800 --> 01:10:05,470
每個人都在說好不好？

1335
01:10:05,470 --> 01:10:06,750
這是令人困惑的。

1336
01:10:06,750 --> 01:10:09,380
很好的話題走了過來，
因為你可能

1337
01:10:09,380 --> 01:10:12,255
會得到一些棘手
這樣的事情在測驗。

1338
01:10:12,255 --> 01:10:13,350
是啊。

1339
01:10:13,350 --> 01:10:13,850
酷。

1340
01:10:13,850 --> 01:10:16,014

1341
01:10:16,014 --> 01:10:18,430
我會把你一送100
行，然後10上的其他。

1342
01:10:18,430 --> 01:10:21,468
是啊，很不錯。

1343
01:10:21,468 --> 01:10:26,350
>> 好了，現在你們將得到
有機會成為助教。

1344
01:10:26,350 --> 01:10:30,600
你得到回答所有可愛
電子郵件，我有時會。

1345
01:10:30,600 --> 01:10:34,290
>> 所以，親愛的安迪，我看，我認為有些事情是
與我的編譯器會出錯。

1346
01:10:34,290 --> 01:10:37,910
我敢肯定，我的代碼是正確的，
但我不斷收到分段錯誤

1347
01:10:37,910 --> 01:10:39,074
我每次運行。

1348
01:10:39,074 --> 01:10:39,740
這是怎麼回事？

1349
01:10:39,740 --> 01:10:42,844
請幫幫忙，很多的愛。

1350
01:10:42,844 --> 01:10:45,740

1351
01:10:45,740 --> 01:10:49,410
>> 如果你們得到的東西像
那你會如何應對？

1352
01:10:49,410 --> 01:10:51,860
這些其實都是很常見
的問題，我們會問你。

1353
01:10:51,860 --> 01:10:54,090
如果是，我們會給你一個
情況下，我們會給我們

1354
01:10:54,090 --> 01:10:56,350
在發生了什麼事情你最好的猜測。

1355
01:10:56,350 --> 01:11:00,710
任何人都有一個刺在這是怎麼回事？

1356
01:11:00,710 --> 01:11:02,654
是嗎？

1357
01:11:02,654 --> 01:11:06,056
>> 聽眾：也許廢棄的
空，像指針

1358
01:11:06,056 --> 01:11:08,924
指著一些空。

1359
01:11:08,924 --> 01:11:11,590
教授：是啊，這會是一個
例如，當這會發生的。

1360
01:11:11,590 --> 01:11:14,467
但是，什麼是較大的圖片
正在發生的事情就在這裡？

1361
01:11:14,467 --> 01:11:17,050
聽眾：難道你想
訪問內存，你是不是

1362
01:11:17,050 --> 01:11:18,175
應該可以訪問？

1363
01:11:18,175 --> 01:11:19,200
教授：沒錯。

1364
01:11:19,200 --> 01:11:24,800
因此，認為一個賽格故障，關斷
限制，在存儲器禁區

1365
01:11:24,800 --> 01:11:27,780
你不應該動人。

1366
01:11:27,780 --> 01:11:31,670
>> 所以，當你試圖幾乎
到index--像例如

1367
01:11:31,670 --> 01:11:34,110
您已經聲明了
陣從0到9。

1368
01:11:34,110 --> 01:11:37,360
但你嘗試觸摸的第10
價值，你沒有訪問該。

1369
01:11:37,360 --> 01:11:38,694
因為你還沒有宣布它。

1370
01:11:38,694 --> 01:11:40,943
所以，你的電腦是怎麼回事
看那個像，

1371
01:11:40,943 --> 01:11:43,440
嗯哦，你試圖去
外的索引的邊界。

1372
01:11:43,440 --> 01:11:45,270
我想給你
段錯誤。

1373
01:11:45,270 --> 01:11:46,590
>> 想想作為分段，對不對？

1374
01:11:46,590 --> 01:11:49,665
一個額外的段，該故障是
當您試圖突破的東西

1375
01:11:49,665 --> 01:11:50,790
你不應該在那裡。

1376
01:11:50,790 --> 01:11:53,660
段錯誤是隨時
您嘗試觸摸的東西

1377
01:11:53,660 --> 01:11:54,970
你不應該動人。

1378
01:11:54,970 --> 01:11:56,815
>> 因此，常見的例子是一個索引。

1379
01:11:56,815 --> 01:11:58,940
當然，如果你想
觸摸到了那顆為空，

1380
01:11:58,940 --> 01:12:00,220
這也將正常工作。

1381
01:12:00,220 --> 01:12:02,300
如果你的指針試圖
觸摸的東西，不應該接觸，

1382
01:12:02,300 --> 01:12:03,730
也可以正常工作。

1383
01:12:03,730 --> 01:12:07,120
最典型的你會
看到這個數組。

1384
01:12:07,120 --> 01:12:07,740
每個人都好？

1385
01:12:07,740 --> 01:12:10,374
>> 聽眾：所以，如果你想
進入10點

1386
01:12:10,374 --> 01:12:12,290
而且也只有一個極限
九什麼的。

1387
01:12:12,290 --> 01:12:13,160
>> 教授：是的，沒錯。

1388
01:12:13,160 --> 01:12:13,660
漂亮多了。

1389
01:12:13,660 --> 01:12:15,930

1390
01:12:15,930 --> 01:12:16,430
酷。

1391
01:12:16,430 --> 01:12:19,070

1392
01:12:19,070 --> 01:12:19,920
>> 親愛的安迪。

1393
01:12:19,920 --> 01:12:23,440
所以，我們已經得到了這些精彩
東西叫做排序。

1394
01:12:23,440 --> 01:12:25,472
如果合併類別 - 正如我們
例如，當在鋸

1395
01:12:25,472 --> 01:12:27,180
大衛做了全
在分類 - 東西為什麼，

1396
01:12:27,180 --> 01:12:29,760
如果它是比如此之快
任何其他類型的，

1397
01:12:29,760 --> 01:12:33,310
為什麼我們甚至不屑知道
任何其他類型的？

1398
01:12:33,310 --> 01:12:35,100
>> 這個問題真是問你是什麼？

1399
01:12:35,100 --> 01:12:36,659
什麼是三word--

1400
01:12:36,659 --> 01:12:37,950
聽眾：什麼是取捨？

1401
01:12:37,950 --> 01:12:38,530
教授：沒錯。

1402
01:12:38,530 --> 01:12:39,946
這是什麼的問題在問。

1403
01:12:39,946 --> 01:12:43,682
什麼是之間的權衡
合併排序的詩句任何其他類型的？

1404
01:12:43,682 --> 01:12:45,850
>> 聽眾：取內存，對不對？

1405
01:12:45,850 --> 01:12:47,720
>> 教授：你
解釋說，多一點？

1406
01:12:47,720 --> 01:12:49,490
首先，讓我們解釋合併店。

1407
01:12:49,490 --> 01:12:50,970
如何合併排序工作？

1408
01:12:50,970 --> 01:12:55,220
>> 聽眾：所以它的工作方式
一切都劃分成半

1409
01:12:55,220 --> 01:13:00,660
然後將其組合在一起
並重新分配它的秩序，

1410
01:13:00,660 --> 01:13:02,862
就像每次合併集。

1411
01:13:02,862 --> 01:13:03,820
教授：差不多。

1412
01:13:03,820 --> 01:13:06,861
所以，我可以借鑒這一點，但它會
帶我五分鐘就畫出來。

1413
01:13:06,861 --> 01:13:10,220
回首一節幻燈片
在這裡我們討論合併排序。

1414
01:13:10,220 --> 01:13:10,790
沒錯。

1415
01:13:10,790 --> 01:13:13,406
>> 於是方式合併排序工作
它是把事情的一半，

1416
01:13:13,406 --> 01:13:15,780
然後它只是著眼於
所有這些的第一值

1417
01:13:15,780 --> 01:13:17,000
只有進行排序。

1418
01:13:17,000 --> 01:13:20,364
不斷創造新的陣列和
使事情越來越多，為了。

1419
01:13:20,364 --> 01:13:23,030
因此而真的，真的
快，因為你知道it's--，

1420
01:13:23,030 --> 01:13:25,380
二進制搜索是n的n log。

1421
01:13:25,380 --> 01:13:27,880
你創造這麼多
你是不同的陣列

1422
01:13:27,880 --> 01:13:29,700
使用大量的內存。

1423
01:13:29,700 --> 01:13:33,080
因此，雖然它更快，權衡
這裡要說的是，你正在使用更多的內存。

1424
01:13:33,080 --> 01:13:38,490
>> 因此，提示，排序和搜索
今年更是涵蓋了很多

1425
01:13:38,490 --> 01:13:41,610
比他們已經在幾年以前。

1426
01:13:41,610 --> 01:13:45,100
你們應該看到，
因此在測驗反映。

1427
01:13:45,100 --> 01:13:49,160
我一定會花時間去
在什麼所有不同種類

1428
01:13:49,160 --> 01:13:52,320
是，如何二進制搜索，
如何線性搜索工作。

1429
01:13:52,320 --> 01:13:54,750
如何也許是偽代碼
這些代碼了。

1430
01:13:54,750 --> 01:13:55,950
什麼是運行時間？

1431
01:13:55,950 --> 01:13:59,210
類似的運行時間很
容易複製下來到筆記板，

1432
01:13:59,210 --> 01:13:59,710
對不對？

1433
01:13:59,710 --> 01:14:01,420
>> 這真的很難，當你
在中間試驗

1434
01:14:01,420 --> 01:14:02,390
你必須明白這一點。

1435
01:14:02,390 --> 01:14:03,160
它複製下來。

1436
01:14:03,160 --> 01:14:05,550
我向你保證你
將需要知道。

1437
01:14:05,550 --> 01:14:06,860
哪些取捨？

1438
01:14:06,860 --> 01:14:10,064
最糟糕的情況下，最好的情況下，場景
對所有的人都非常了解。

1439
01:14:10,064 --> 01:14:10,564
是嗎？

1440
01:14:10,564 --> 01:14:12,730
>> 聽眾：我們是否需要
知道如何編寫合併排序？

1441
01:14:12,730 --> 01:14:15,470
喜歡，我們需要
記得遞歸？

1442
01:14:15,470 --> 01:14:18,950
>> 教授：我很懷疑，只是
因為它像相當複雜的。

1443
01:14:18,950 --> 01:14:22,282
但它可能不是不可行，如果我們
請你用偽出來。

1444
01:14:22,282 --> 01:14:22,781
是啊。

1445
01:14:22,781 --> 01:14:25,470

1446
01:14:25,470 --> 01:14:29,170
>> 是的，好了，多一個。

1447
01:14:29,170 --> 01:14:31,387
這可能已經拿出了
你最後一塊在一個位。

1448
01:14:31,387 --> 01:14:42,101

1449
01:14:42,101 --> 01:14:43,090
是嗎？

1450
01:14:43,090 --> 01:14:44,930
難道大家聽到了嗎？

1451
01:14:44,930 --> 01:14:48,360
>> 好了，幾乎第一
程序的所有，什麼類型

1452
01:14:48,360 --> 01:14:51,000
將讓你像這樣的輸出？

1453
01:14:51,000 --> 01:14:54,350
請記住，我們要求你了解
這種新型的調試工具？

1454
01:14:54,350 --> 01:14:57,340
什麼是它的名字？

1455
01:14:57,340 --> 01:14:59,460
Valgrind的，正確的

1456
01:14:59,460 --> 01:15:02,600
>> 這是一個程序，
你可以調用，可以

1457
01:15:02,600 --> 01:15:05,940
保留所有你的記憶軌跡
使用你的程序，並是怎麼回事。

1458
01:15:05,940 --> 01:15:11,090
所以，如果你已經得到的東西，比如，
肯定輸了，40個字節的一個塊。

1459
01:15:11,090 --> 01:15:14,870
也許你不
記住釋放它。

1460
01:15:14,870 --> 01:15:18,710
因為如果你使用的字節的內存，
這意味著你已經訪問內存，

1461
01:15:18,710 --> 01:15:20,240
但一直沒能釋放。

1462
01:15:20,240 --> 01:15:21,948
所以，你想
相信你也

1463
01:15:21,948 --> 01:15:31,420
使用free--這是一個
function--釋放所有

1464
01:15:31,420 --> 01:15:34,930
的由malloc重新分配的存儲器。

1465
01:15:34,930 --> 01:15:35,500
>> 酷。

1466
01:15:35,500 --> 01:15:37,140
這張幻燈片，我要它。

1467
01:15:37,140 --> 01:15:41,050
它無處不在很多
講座，在很多部分幻燈片。

1468
01:15:41,050 --> 01:15:44,254
你真的要確保
你只知道這一切。

1469
01:15:44,254 --> 01:15:47,170
無論是在你的筆記板，或者如果你
要記住它，隨意。

1470
01:15:47,170 --> 01:15:48,836
這是真的，真的，真的很重要。

1471
01:15:48,836 --> 01:15:53,200

1472
01:15:53,200 --> 01:15:56,890
>> 也是一個非常好的
問題是，我們可能會問。

1473
01:15:56,890 --> 01:16:00,320
為什麼選擇類別 - 看看
選擇類別 - 所有運行時的

1474
01:16:00,320 --> 01:16:02,060
n個平方。

1475
01:16:02,060 --> 01:16:06,714
不管如何列表來
你是，那麼為什麼選擇類別 - 

1476
01:16:06,714 --> 01:16:08,630
我給你們30
第二想一想。

1477
01:16:08,630 --> 01:16:10,700
因為那種它的混亂。

1478
01:16:10,700 --> 01:16:12,710
它涉及到一些概念上的想法。

1479
01:16:12,710 --> 01:16:16,470
為什麼會運行時間是在同
二者最差和最好情況場景？

1480
01:16:16,470 --> 01:16:28,850

1481
01:16:28,850 --> 01:16:30,000
>> 是嗎？

1482
01:16:30,000 --> 01:16:38,084
>> 聽眾：因為選擇排序每個
在這個小陣位或空間

1483
01:16:38,084 --> 01:16:40,350
事或什麼的。

1484
01:16:40,350 --> 01:16:44,430
因此，即使在最好的情況下，
即使它完全排序，

1485
01:16:44,430 --> 01:16:47,380
它仍然只能是這樣，好吧，之一。

1486
01:16:47,380 --> 01:16:49,000
在我的第一個地方，我有一個。

1487
01:16:49,000 --> 01:16:50,250
並通過他們。

1488
01:16:50,250 --> 01:16:51,249
OK，一個是最小的。

1489
01:16:51,249 --> 01:16:53,053
然後它又來了
是想，好，二

1490
01:16:53,053 --> 01:16:54,594
是最小的所有的東西。

1491
01:16:54,594 --> 01:16:56,804
但它仍然有
檢查每一個人。

1492
01:16:56,804 --> 01:16:57,470
教授：是的。

1493
01:16:57,470 --> 01:17:00,490
因此，例如，讓我們只說
我們有一個列表，已經排序，

1494
01:17:00,490 --> 01:17:03,390
陣列之一到五個。

1495
01:17:03,390 --> 01:17:07,100
的方式來選擇排序是
它通過，它會檢查這兩個。

1496
01:17:07,100 --> 01:17:08,234
然後檢查這兩個。

1497
01:17:08,234 --> 01:17:09,650
然後它會檢查，而且檢查。

1498
01:17:09,650 --> 01:17:13,285
它不斷檢查所有的人，
不管是否

1499
01:17:13,285 --> 01:17:14,160
它的實際排序。

1500
01:17:14,160 --> 01:17:16,450
因為這是根本
排序的工作方式。

1501
01:17:16,450 --> 01:17:19,530
>> 所以這個問題是一種像
一個概念性的問題，我們會問。

1502
01:17:19,530 --> 01:17:21,430
其中第一，你
知道什麼選擇排序

1503
01:17:21,430 --> 01:17:23,304
是吧，要能
回答這個問題。

1504
01:17:23,304 --> 01:17:26,200
你必須要能夠理解
從概念上發生了什麼事情。

1505
01:17:26,200 --> 01:17:30,760
然後你可以將它和思考，確定
讓我們試想一下，最糟糕的情況。

1506
01:17:30,760 --> 01:17:32,230
他們都是按降序排列。

1507
01:17:32,230 --> 01:17:33,290
將如何影響呢？

1508
01:17:33,290 --> 01:17:34,650
>> 如果它是升序排列？

1509
01:17:34,650 --> 01:17:35,640
如果它已經排序？

1510
01:17:35,640 --> 01:17:37,240
將如何影響運行時？

1511
01:17:37,240 --> 01:17:40,270
然後選擇排序，你會發現
它實際上並不重要。

1512
01:17:40,270 --> 01:17:43,500
因為你正在檢查所有的
值不管發生了什麼。

1513
01:17:43,500 --> 01:17:45,810
>> 所以，好東西要記住。

1514
01:17:45,810 --> 01:17:50,290
為什麼某些種類從別人不同
以及如何最好的和最壞的情況

1515
01:17:50,290 --> 01:17:52,740
會影響到所有的人。

1516
01:17:52,740 --> 01:17:56,700
>> 我要真打的種類
因為這將是對測驗。

1517
01:17:56,700 --> 01:17:57,199
是啊。

1518
01:17:57,199 --> 01:18:00,820

1519
01:18:00,820 --> 01:18:01,320
確定。

1520
01:18:01,320 --> 01:18:05,590
還有剩下六分鐘時間。

1521
01:18:05,590 --> 01:18:09,880
我可以採取三分鐘的問題。

1522
01:18:09,880 --> 01:18:12,290
我也可以流連
像第20分鐘後

1523
01:18:12,290 --> 01:18:13,850
如果你要問的問題也是如此。

1524
01:18:13,850 --> 01:18:16,330
有誰只是真的簡單
疑問或概念問題

1525
01:18:16,330 --> 01:18:17,360
他們是不清楚的權利嗎？

1526
01:18:17,360 --> 01:18:17,832
是嗎？

1527
01:18:17,832 --> 01:18:19,720
>> 聽眾：你能談一點
關於位運算符位？

1528
01:18:19,720 --> 01:18:20,280
>> 教授：是的。

1529
01:18:20,280 --> 01:18:22,446
所以按位運算符
一些你可能

1530
01:18:22,446 --> 01:18:24,170
可能只是想要把你的表。

1531
01:18:24,170 --> 01:18:27,540
所以quickly--我不想
深入進去太多

1532
01:18:27,540 --> 01:18:31,164
因為哈佛，在其審查
會議上，遮蓋得很好。

1533
01:18:31,164 --> 01:18:33,080
位運算符，還有
五人，對不對？

1534
01:18:33,080 --> 01:18:41,370
>> 有這一點，這是x或功能，
有符號，它是和。

1535
01:18:41,370 --> 01:18:44,050
管，這是或。

1536
01:18:44,050 --> 01:18:46,790
然後你有兩個
不同類型的班次。

1537
01:18:46,790 --> 01:18:50,610
>> 如果我給你兩個值，如果
我給你一樣，一個又一個。

1538
01:18:50,610 --> 01:18:52,390
你會計算結果為？

1539
01:18:52,390 --> 01:18:55,490
如果我給你真實，真實，是真的嗎？

1540
01:18:55,490 --> 01:18:56,930
那麼真的還是假的？

1541
01:18:56,930 --> 01:18:57,830
不過真的吧？

1542
01:18:57,830 --> 01:18:59,762
由於有一個或。

1543
01:18:59,762 --> 01:19:01,220
我們將最有可能給你的數字。

1544
01:19:01,220 --> 01:19:03,780
所以請記住，一等於
如此，零等於false。

1545
01:19:03,780 --> 01:19:07,407
我們可能會給你這些東西
並請您告訴我們發生了什麼。

1546
01:19:07,407 --> 01:19:10,240
哈佛覆蓋它內部的第一
10分鐘他們的研究會議

1547
01:19:10,240 --> 01:19:11,230
真的，真的很好。

1548
01:19:11,230 --> 01:19:14,260
所以，你們要進行
確保您回首這一點。

1549
01:19:14,260 --> 01:19:16,387
>> 聽眾：是pisa5
將要在測驗？

1550
01:19:16,387 --> 01:19:16,970
教授：第

1551
01:19:16,970 --> 01:19:18,240
甚至不看pisa5現在。

1552
01:19:18,240 --> 01:19:18,810
這很難。

1553
01:19:18,810 --> 01:19:22,830
只是不甚至懶得看pisa5。

1554
01:19:22,830 --> 01:19:25,665
>> 然而，由於一些提示
和建議，我

1555
01:19:25,665 --> 01:19:28,320
建議你開始pisa5
只要測驗結束。

1556
01:19:28,320 --> 01:19:30,319
這將是最困難的
上週，但你們

1557
01:19:30,319 --> 01:19:34,590
將通過它在山上
連綿起伏的綠色和小狗的，

1558
01:19:34,590 --> 01:19:36,115
和它的罰款。

1559
01:19:36,115 --> 01:19:39,810
>> 該類得到顯著
第五PSET後更容易。

1560
01:19:39,810 --> 01:19:41,560
聽眾：辦公時間
星期日，星期一？

1561
01:19:41,560 --> 01:19:44,260
教授：是啊，所以辦公時間會
週日到週一為PSET。

1562
01:19:44,260 --> 01:19:47,009
今晚辦公時間基本
也只是審查測驗。

1563
01:19:47,009 --> 01:19:50,350
如果有人想進來，問
助教的問題，我們將在那裡。

1564
01:19:50,350 --> 01:19:53,220
>> 我帶你去也許一個問題
如果任何人有問題？

1565
01:19:53,220 --> 01:19:53,809
是嗎？

1566
01:19:53,809 --> 01:19:55,850
聽眾：當你
定義節點，[聽不清]

1567
01:19:55,850 --> 01:20:00,700
如果你說下一個節點明星，然後，
自動執行電腦

1568
01:20:00,700 --> 01:20:03,610
了解您
談到另一個指針？

1569
01:20:03,610 --> 01:20:04,580
>> 教授：第

1570
01:20:04,580 --> 01:20:06,710
>> 聽眾：你必須
重新鏈接[聽不清]？

1571
01:20:06,710 --> 01:20:09,270
>> 教授：所以基本上
一個節點的結構是，記住，

1572
01:20:09,270 --> 01:20:12,620
這就像你創建的節點，
那麼你有一個被稱為下一個指針。

1573
01:20:12,620 --> 01:20:14,630
所有你正在做的是具有
結構出現。

1574
01:20:14,630 --> 01:20:16,387
您必須分配
該指針的地方。

1575
01:20:16,387 --> 01:20:18,470
因此，計算機不
知道它在做什麼呢。

1576
01:20:18,470 --> 01:20:20,250
你有實際的時候給它分配
你創建你的鏈接列表。

1577
01:20:20,250 --> 01:20:22,170
這就是主要
PSET 5將上。

1578
01:20:22,170 --> 01:20:24,106
所以不愁
任何現在的權利。

1579
01:20:24,106 --> 01:20:26,380
>> 聽眾：所以我們並不需要
過於注重鏈接列表，只

1580
01:20:26,380 --> 01:20:27,440
一般的概念？

1581
01:20:27,440 --> 01:20:30,980
>> 教授：剛才幾乎棧，
隊列，鍊錶，樹，哈希表。

1582
01:20:30,980 --> 01:20:33,639
只要能夠知道它們是什麼。

1583
01:20:33,639 --> 01:20:35,680
我們不會問
你喜歡什麼具體

1584
01:20:35,680 --> 01:20:39,300
因為我們還沒有真正做了
PSET的涵蓋任何的呢。

1585
01:20:39,300 --> 01:20:45,540
>> 因此，在最後兩分鐘前
我給你自由，來殺死這個測驗。

1586
01:20:45,540 --> 01:20:49,370
差不多一樣，想想怎麼
到目前為止你們已經走在這個類。

1587
01:20:49,370 --> 01:20:52,820
>> 我記得當2週
這個類，有些人的

1588
01:20:52,820 --> 01:20:55,720
花3小時寫水。

1589
01:20:55,720 --> 01:20:57,970
多久會帶你
球員現在寫的水？

1590
01:20:57,970 --> 01:20:59,670
30秒後，也許？

1591
01:20:59,670 --> 01:21:01,810
想想多少
你們已經學會了。

1592
01:21:01,810 --> 01:21:04,320
CS是真的，真的很難受。

1593
01:21:04,320 --> 01:21:06,190
還有的是毫無疑問的。

1594
01:21:06,190 --> 01:21:09,160
這很難，這就是為什麼沒有人研究它。

1595
01:21:09,160 --> 01:21:10,730
這只是很難。

1596
01:21:10,730 --> 01:21:11,650
而且它是完全罰款。

1597
01:21:11,650 --> 01:21:14,150
>> 而且我真的很自豪的是，
每個人都已經走到今天這一步。

1598
01:21:14,150 --> 01:21:16,380
的pset是不容易的。

1599
01:21:16,380 --> 01:21:17,790
他們採取了很多時間。

1600
01:21:17,790 --> 01:21:22,580
你這傢伙，我絕不會要求你寫
15人的Vigenere在PSET遊戲。

1601
01:21:22,580 --> 01:21:24,160
沒有必要只是嚇壞了這一點。

1602
01:21:24,160 --> 01:21:28,080
所有我們這裡測試是評估
您的概念性知識，以及

1603
01:21:28,080 --> 01:21:31,524
由於部分編碼的基本技能。

1604
01:21:31,524 --> 01:21:33,440
該試驗的目的是
真正具有挑戰性的。

1605
01:21:33,440 --> 01:21:36,180
像，它被設計
你拿不到100。

1606
01:21:36,180 --> 01:21:39,880
它的設計也為您可能
不能夠在75分鐘結束。

1607
01:21:39,880 --> 01:21:41,995
而這完全罰款。

1608
01:21:41,995 --> 01:21:42,870
我是學生自己。

1609
01:21:42,870 --> 01:21:45,960
我知道，我恨它，當我走
出測驗是這樣，狗屎。

1610
01:21:45,960 --> 01:21:47,044
這是真的很難。

1611
01:21:47,044 --> 01:21:49,460
大概什麼會
happen--而這完全罰款，

1612
01:21:49,460 --> 01:21:50,751
我告訴你們，現在。

1613
01:21:50,751 --> 01:21:53,190
這些東西的手段
不高的。

1614
01:21:53,190 --> 01:21:55,360
>> 而對於那些你們誰
已經越來越像，

1615
01:21:55,360 --> 01:21:57,870
您的問題集三分球，
這並不意味著你

1616
01:21:57,870 --> 01:21:59,536
會得到60％的此類。

1617
01:21:59,536 --> 01:22:01,440
如果你在獲得60％
測驗，這不

1618
01:22:01,440 --> 01:22:03,330
意思是你要
獲得A D在這個類。

1619
01:22:03,330 --> 01:22:05,740
我們看到，尤其是我，對於
在我的部分那些你，

1620
01:22:05,740 --> 01:22:07,406
我看怎麼努力，你們都在努力。

1621
01:22:07,406 --> 01:22:09,190
我跟踪了。

1622
01:22:09,190 --> 01:22:11,420
>> 你們將被罰款。

1623
01:22:11,420 --> 01:22:14,580
有沒有機構記憶
幸福在學期結束。

1624
01:22:14,580 --> 01:22:16,840
因為所有的哈佛孩子們講
他們的朋友，哦，你會沒事的。

1625
01:22:16,840 --> 01:22:18,381
沒有人告訴你們，在這裡。

1626
01:22:18,381 --> 01:22:20,950
所以，我要告訴你們，在這裡。

1627
01:22:20,950 --> 01:22:22,280
>> 你們將被罰款。

1628
01:22:22,280 --> 01:22:24,080
我很自豪所有你們的。

1629
01:22:24,080 --> 01:22:25,680
該測試將是困難的。

1630
01:22:25,680 --> 01:22:28,140
研究它，事後
只是把它扔掉。

1631
01:22:28,140 --> 01:22:31,280
準備好學習新的東西。

1632
01:22:31,280 --> 01:22:33,990
吃糖果。

1633
01:22:33,990 --> 01:22:35,940
我們已經有很多的糖果。

1634
01:22:35,940 --> 01:22:37,760
>> 得到一個良好的夜間睡眠。

1635
01:22:37,760 --> 01:22:40,420
不要不睡覺，因為
那會是非常糟糕的。

1636
01:22:40,420 --> 01:22:41,490
CS是一個很大的邏輯。

1637
01:22:41,490 --> 01:22:44,960
如果你不睡覺，你就無法運作，
你的大腦不能正常工作。

1638
01:22:44,960 --> 01:22:48,780
而且我會在這裡為下一個20
分鐘，如果有人想流連。

1639
01:22:48,780 --> 01:22:51,150
你們要殺死它。

1640
01:22:51,150 --> 01:22:53,000
祝你好運。

1641
01:22:53,000 --> 01:22:55,663