1
00:00:00,000 --> 00:00:02,418
>> [音樂播放]

2
00:00:02,418 --> 00:00:10,542

3
00:00:10,542 --> 00:00:12,000
ALLISON BUCHHOLTZ-AU：嘿大家。

4
00:00:12,000 --> 00:00:15,640
歡迎來到你的第一個
官方CS50部分。

5
00:00:15,640 --> 00:00:19,507
正如你可以，看到這是
部CS50狀，剛

6
00:00:19,507 --> 00:00:20,840
拉了我們今天的議程。

7
00:00:20,840 --> 00:00:23,990
那麼，我是誰，我敢肯定
你們都知道。

8
00:00:23,990 --> 00:00:25,514
我是你的TF。

9
00:00:25,514 --> 00:00:27,930
我不只是一個隨機的學生
誰在冒充你的TF。

10
00:00:27,930 --> 00:00:31,190
>> 而且我會去通過
種有部分會流，

11
00:00:31,190 --> 00:00:34,900
期望我們有，
資源，等等，等等。

12
00:00:34,900 --> 00:00:39,190
我們要談的數組，ASCII
功能，命令行參數，

13
00:00:39,190 --> 00:00:42,020
它不是在這裡，但
我也會幫助

14
00:00:42,020 --> 00:00:45,054
有種你想通過
你的下一個PSET本週。

15
00:00:45,054 --> 00:00:46,720
我相信你會明白一切。

16
00:00:46,720 --> 00:00:48,190

17
00:00:48,190 --> 00:00:53,390
>> 因此，首先question--我是誰，
除了在這裡你旺盛的TF。

18
00:00:53,390 --> 00:00:55,390
我艾莉森Buchholtz金。

19
00:00:55,390 --> 00:00:57,970
這是我第二年TFing CS50。

20
00:00:57,970 --> 00:01:00,570
我也TF CS51的春天。

21
00:01:00,570 --> 00:01:03,930
你可能會看到再次出現
如果你決定接受它。

22
00:01:03,930 --> 00:01:07,370
我也是一個PAF，所以任何Freshmen--
如果你不是一個新生，

23
00:01:07,370 --> 00:01:09,980
這是我第三年
作為建議的傢伙。

24
00:01:09,980 --> 00:01:13,630
我很精通
建議你對生活和課程

25
00:01:13,630 --> 00:01:16,549
CS之內，而不是在CS。

26
00:01:16,549 --> 00:01:18,090
我是一名計算機科學選礦廠。

27
00:01:18,090 --> 00:01:20,800
我在斯樓，最好的房子高級。

28
00:01:20,800 --> 00:01:22,430

29
00:01:22,430 --> 00:01:26,050
還沒等我切換到
CS我大二春天，

30
00:01:26,050 --> 00:01:27,640
我其實是一個生物醫學工程師。

31
00:01:27,640 --> 00:01:29,020
我本來打算去地中海學校。

32
00:01:29,020 --> 00:01:30,530
我將是一個創傷外科醫生。

33
00:01:30,530 --> 00:01:33,000
並具有完全
改變，因為我把CS50。

34
00:01:33,000 --> 00:01:34,250

35
00:01:34,250 --> 00:01:36,310
我把我的課程二年級秋季。

36
00:01:36,310 --> 00:01:38,920
這是我第一次接觸CS如初。

37
00:01:38,920 --> 00:01:44,104
我是你的78％的一個誰
有經驗為零進來，

38
00:01:44,104 --> 00:01:45,520
它徹底改變了我的生活。

39
00:01:45,520 --> 00:01:49,820
現在我在我的工作
微軟，和你可愛的TF。

40
00:01:49,820 --> 00:01:53,500
而CS50大概是1
最好的經驗

41
00:01:53,500 --> 00:01:56,210
說我已經在這裡
Harvard--無論服用類

42
00:01:56,210 --> 00:01:59,040
並能夠幫助
教給學生喜歡你。

43
00:01:59,040 --> 00:02:01,410
>> 所以，我真的很激動
你都在這裡。

44
00:02:01,410 --> 00:02:04,270
如果你進來
晚了，有糖果，

45
00:02:04,270 --> 00:02:07,227
你應該感到
免費搶過來，或者發

46
00:02:07,227 --> 00:02:08,560
別人抓住它給你。

47
00:02:08,560 --> 00:02:09,399
沒關係。

48
00:02:09,399 --> 00:02:10,440
我不想吃。

49
00:02:10,440 --> 00:02:13,350
我的房間有足夠的巧克力，所以
你們應該嘗試並完成了。

50
00:02:13,350 --> 00:02:16,730
我知道的有100件，
但像，在週一4時，

51
00:02:16,730 --> 00:02:19,000
我想每個人都可以利用一些糖。

52
00:02:19,000 --> 00:02:21,750
>> 所以大家誰是
正式在我的部分

53
00:02:21,750 --> 00:02:24,700
應該得到一個電子郵件
從我有我的電話號碼，

54
00:02:24,700 --> 00:02:29,920
電子郵件addr​​ess--隨意添加我的
谷歌聊天軟件，隨意添加我在Facebook，

55
00:02:29,920 --> 00:02:33,360
同時也為您的休息，
你可以發郵件給我就在這裡。

56
00:02:33,360 --> 00:02:34,450
有兩個H的。

57
00:02:34,450 --> 00:02:37,090
每個人都總是這樣
就像兩個L's或兩個C的。

58
00:02:37,090 --> 00:02:38,260
兩個H在姓氏。

59
00:02:38,260 --> 00:02:41,800
否則，它會反彈，並
我不會讓你的電子郵件。

60
00:02:41,800 --> 00:02:46,400
>> 所以，隨時給我發電子郵件，
與我聯繫在任何時間。

61
00:02:46,400 --> 00:02:51,440
我可能不會回去
您應在24分鐘之內，

62
00:02:51,440 --> 00:02:53,760
但我答應回去
你在24小時內。

63
00:02:53,760 --> 00:02:54,900

64
00:02:54,900 --> 00:02:58,067
如果你打電話給我半小時前
您PSET是因為，你是喜歡，

65
00:02:58,067 --> 00:02:59,650
我不知道我在做什麼佳佳。

66
00:02:59,650 --> 00:03:00,160
幫我。

67
00:03:00,160 --> 00:03:04,049
我要你平靜下來，
但在一天結束時，

68
00:03:04,049 --> 00:03:07,340
如果你打電話給我半小時前
您PSET是由於什麼也沒有寫，

69
00:03:07,340 --> 00:03:11,570
我要像，好吧，也許
它的時間來使用該晚一天。

70
00:03:11,570 --> 00:03:15,215
因此，我將所有的回應你
要求在一個非常及時。

71
00:03:15,215 --> 00:03:16,482

72
00:03:16,482 --> 00:03:18,190
我的手機通常是
貼在我的手上。

73
00:03:18,190 --> 00:03:21,530
我通常多回應
快超過24小時，

74
00:03:21,530 --> 00:03:25,650
但我只能保證
24小時響應。

75
00:03:25,650 --> 00:03:26,580
>> 行。

76
00:03:26,580 --> 00:03:28,410
那麼，為什麼我們在這裡？

77
00:03:28,410 --> 00:03:32,160
另外，如果您有問題
任何時候，請讓我知道。

78
00:03:32,160 --> 00:03:32,780
我談了很多。

79
00:03:32,780 --> 00:03:35,320
我說話快，但請
隨時打斷我。

80
00:03:35,320 --> 00:03:36,980
這給了我喘息的餘地為好。

81
00:03:36,980 --> 00:03:38,159

82
00:03:38,159 --> 00:03:40,200
因此，部分是時間
對於我們真的只是潛水

83
00:03:40,200 --> 00:03:44,270
中，獲得一些實踐經驗，
經過我們提到的話題

84
00:03:44,270 --> 00:03:49,760
在課堂上或在學習材料
我們建議你們在網上。

85
00:03:49,760 --> 00:03:52,980
我們將真正經歷
一些有點這些資源。

86
00:03:52,980 --> 00:03:54,300

87
00:03:54,300 --> 00:03:57,400
>> 因此，一些注意事項部分支持。

88
00:03:57,400 --> 00:04:00,250
CS50--的事情之一，使
這是我最喜歡的類別之一

89
00:04:00,250 --> 00:04:02,510
是，你永遠不會孤單的感覺。

90
00:04:02,510 --> 00:04:05,430
我們有超過100名員工
人誰是來幫助你的。

91
00:04:05,430 --> 00:04:08,080
我們的辦公時間
週一至週四。

92
00:04:08,080 --> 00:04:13,230
因此，有這麼多的人誰
愛班只是像我這樣做

93
00:04:13,230 --> 00:04:15,750
，誰是真的在這裡
因為他們要到這裡來。

94
00:04:15,750 --> 00:04:19,390
我們中的大多數是學生，而這
就像第五類除

95
00:04:19,390 --> 00:04:20,390
我們的工作休息。

96
00:04:20,390 --> 00:04:22,723
>> 這是一個大量的工作，但
我們這樣做是因為我們愛它，

97
00:04:22,723 --> 00:04:25,600
我們真的愛教你
並幫助分享我們的興奮

98
00:04:25,600 --> 00:04:27,260
針對這個問題和這個類。

99
00:04:27,260 --> 00:04:28,490
所以，請利用。

100
00:04:28,490 --> 00:04:29,370
再來說說我們。

101
00:04:29,370 --> 00:04:33,034
我感到孤獨時，我的學生
不要跟我說話，所以如果你想，

102
00:04:33,034 --> 00:04:33,950
都掛出了我。

103
00:04:33,950 --> 00:04:35,200
這將是巨大的。

104
00:04:35,200 --> 00:04:37,400
>> 因此，部分顯然是
您的一個最重要的事情。

105
00:04:37,400 --> 00:04:41,770
我們將通過東西
您在演講學會，

106
00:04:41,770 --> 00:04:44,100
做一些簡短的例子
當我們有時間，

107
00:04:44,100 --> 00:04:46,187
和種一般
獲取有關的事情的想法

108
00:04:46,187 --> 00:04:48,270
你應該思考
關於您的問題集。

109
00:04:48,270 --> 00:04:49,540

110
00:04:49,540 --> 00:04:53,591
有多少人真正Shorts--
看著從你從頭視頻

111
00:04:53,591 --> 00:04:54,090
短？

112
00:04:54,090 --> 00:04:55,460

113
00:04:55,460 --> 00:04:57,390
任何人都認識我了？

114
00:04:57,390 --> 00:04:59,720
因此，這些都是非常大的。

115
00:04:59,720 --> 00:05:01,210
你一定要看看那些。

116
00:05:01,210 --> 00:05:02,880
大量的工作已投入其中。

117
00:05:02,880 --> 00:05:06,690
而他們只是意思是
一口大小的塊為你只是看

118
00:05:06,690 --> 00:05:09,760
三，四分鐘，並獲得
更好地理解一個概念。

119
00:05:09,760 --> 00:05:11,147

120
00:05:11,147 --> 00:05:12,980
走throughs--如何
很多人都看過

121
00:05:12,980 --> 00:05:14,880
在穿行於以前的？

122
00:05:14,880 --> 00:05:16,240
Zamyla是驚人的，對不對？

123
00:05:16,240 --> 00:05:18,100
喜歡，我希望我是Zamyla的時候。

124
00:05:18,100 --> 00:05:19,650

125
00:05:19,650 --> 00:05:21,640
所以肯定用你穿行。

126
00:05:21,640 --> 00:05:25,070
她將它分解成
小，一口大小的塊。

127
00:05:25,070 --> 00:05:28,079
而當你擁有這些巨大
從你的習題集規格，

128
00:05:28,079 --> 00:05:30,870
這將是非常重要的
要能隨便找個地方

129
00:05:30,870 --> 00:05:32,600
啟動，並通過它慢慢地工作。

130
00:05:32,600 --> 00:05:33,610

131
00:05:33,610 --> 00:05:40,260
>> 好了，我們也有Study50，這
是study50.harvard.edu，我相信。

132
00:05:40,260 --> 00:05:42,270
你可以谷歌
學習，它會冒出來。

133
00:05:42,270 --> 00:05:45,750
這是一個
最好的資源，我們有。

134
00:05:45,750 --> 00:05:49,800
這是學習認證與筆記
和實踐對你的問題

135
00:05:49,800 --> 00:05:52,430
的解決方案，你
其實可以穿行。

136
00:05:52,430 --> 00:05:57,000
所以，如果你想多練，
比我們多節以上

137
00:05:57,000 --> 00:06:00,700
比你的習題集，這是
真的，我鼓勵你去的地方。

138
00:06:00,700 --> 00:06:03,590
它是建立在去年夏天通過
我的一些非常要好的朋友。

139
00:06:03,590 --> 00:06:04,480
它是驚人的。

140
00:06:04,480 --> 00:06:05,540

141
00:06:05,540 --> 00:06:08,670
事實上，有很多的幻燈片
我將使用的第

142
00:06:08,670 --> 00:06:10,190
將來自Study50。

143
00:06:10,190 --> 00:06:12,000
>> 所以很多的轉錄因子的使用它。

144
00:06:12,000 --> 00:06:13,920
最後，我
所提到的，辦公時間。

145
00:06:13,920 --> 00:06:15,836
如果您遇到問題
家庭作業，你

146
00:06:15,836 --> 00:06:18,270
具有與麻煩
概念，來辦公時間。

147
00:06:18,270 --> 00:06:20,190
去年初，在本週如果可以的話。

148
00:06:20,190 --> 00:06:23,130
走不出來了四，
因為它是一種遠。

149
00:06:23,130 --> 00:06:24,780
沒有人喜歡走在那裡。

150
00:06:24,780 --> 00:06:27,090
但它是你的優勢，
因為那時你

151
00:06:27,090 --> 00:06:29,580
將擁有所有這些轉錄因子，
[聽不清]圍繞著你。

152
00:06:29,580 --> 00:06:31,920
尤其是現在，
只是一個提示，星期四

153
00:06:31,920 --> 00:06:35,310
非常寒冷的，現在在
馬瑟因您的pset

154
00:06:35,310 --> 00:06:36,577
是由於在週四。

155
00:06:36,577 --> 00:06:38,410
並知道要
用你的遲到幾天呢。

156
00:06:38,410 --> 00:06:40,030
>> 所以，如果你有
與概念的麻煩，

157
00:06:40,030 --> 00:06:41,780
有許多轉錄因子的誰
在那裡幫助你。

158
00:06:41,780 --> 00:06:43,196
所以出來馬瑟週四。

159
00:06:43,196 --> 00:06:45,280
如果你想看到我，
我要去那裡。

160
00:06:45,280 --> 00:06:48,870
我通常做我自己的功課，
因為沒有人願意幫助我。

161
00:06:48,870 --> 00:06:50,260
那麼就來看看我們。

162
00:06:50,260 --> 00:06:51,460

163
00:06:51,460 --> 00:06:52,440
>> 我們見面了一半。

164
00:06:52,440 --> 00:06:55,400
那麼有多少人參加
講課或在線觀看呢？

165
00:06:55,400 --> 00:06:56,570

166
00:06:56,570 --> 00:06:59,140
有多少人去了
上週超節？

167
00:06:59,140 --> 00:07:00,171

168
00:07:00,171 --> 00:07:00,670
涼爽。

169
00:07:00,670 --> 00:07:02,190
這實際上是一個公平的數字。

170
00:07:02,190 --> 00:07:05,425
你們有多少人看過你的
SPEC本週，為您PSET？

171
00:07:05,425 --> 00:07:07,081

172
00:07:07,081 --> 00:07:08,461
哦，我是你們的驕傲！

173
00:07:08,461 --> 00:07:09,335
更多糖果你們。

174
00:07:09,335 --> 00:07:11,070

175
00:07:11,070 --> 00:07:13,280
>> 好，讓我們的意思
“我們見面了一半，”是

176
00:07:13,280 --> 00:07:16,440
這章只是
將是超級對你有用

177
00:07:16,440 --> 00:07:19,810
如果你進來看了你
規範的PSET。

178
00:07:19,810 --> 00:07:23,859
因為當我經歷的概述
你應該找出來的東西，

179
00:07:23,859 --> 00:07:25,650
它不會使
如果你是多大意義

180
00:07:25,650 --> 00:07:28,358
不知道你的問題集
是要問你的事。

181
00:07:28,358 --> 00:07:29,020

182
00:07:29,020 --> 00:07:32,590
>> 如果你不來款，顯然
我不能對你有用。

183
00:07:32,590 --> 00:07:36,600
我不打算把它親手如果
你不來我的部分，現在，

184
00:07:36,600 --> 00:07:38,570
但你絕對應該。

185
00:07:38,570 --> 00:07:40,090
如果不能，在線觀看。

186
00:07:40,090 --> 00:07:41,230

187
00:07:41,230 --> 00:07:42,519
他們是有原因的。

188
00:07:42,519 --> 00:07:43,560
礦將在那裡。

189
00:07:43,560 --> 00:07:44,187

190
00:07:44,187 --> 00:07:47,270
當你發現，我們被記錄下來，
所以它會在那裡為你們。

191
00:07:47,270 --> 00:07:49,110

192
00:07:49,110 --> 00:07:51,570
同時，要
lectures--這顯然

193
00:07:51,570 --> 00:07:53,790
你得到的，其中
開始你的材料在這裡。

194
00:07:53,790 --> 00:07:57,430
所以，我一定會嘗試
幫助你盡我所能，

195
00:07:57,430 --> 00:07:58,840
但我只能滿足你們這麼遠。

196
00:07:58,840 --> 00:08:01,220
你要種
迎接我們的一半。

197
00:08:01,220 --> 00:08:04,050
>> Grading--所以，在座的各位
誰從我這裡得到了一封電子郵件，

198
00:08:04,050 --> 00:08:05,445
你是我的正式部分。

199
00:08:05,445 --> 00:08:06,470

200
00:08:06,470 --> 00:08:08,120
我將你的分級pset中。

201
00:08:08,120 --> 00:08:12,870
我只想說，一件事，
你應該注意的

202
00:08:12,870 --> 00:08:13,820
有意見。

203
00:08:13,820 --> 00:08:17,390
該意見往往是比較有用
比實際的分數，我們給你。

204
00:08:17,390 --> 00:08:19,890
和意見實際上是
在那裡我花了我很多時間

205
00:08:19,890 --> 00:08:20,770
當我分級。

206
00:08:20,770 --> 00:08:22,700
所以，我將不勝感激
它，如果你閱讀。

207
00:08:22,700 --> 00:08:26,990
而它們實際上是你如何去
詳細了解設計理念和風格

208
00:08:26,990 --> 00:08:29,860
並且事情是一個
少一些添油加醋。

209
00:08:29,860 --> 00:08:31,770
>> 所以，真正要注意
這些意見。

210
00:08:31,770 --> 00:08:34,720
如果您有關於他們的問題，
或者你的分數問題，

211
00:08:34,720 --> 00:08:37,620
請你跟我說話
無論是部分之前，

212
00:08:37,620 --> 00:08:41,039
我可能會掛出
在大堂，或之後。

213
00:08:41,039 --> 00:08:43,559
如果要計劃
如何單對單會議

214
00:08:43,559 --> 00:08:46,100
你可以幫助改善後
習題集，只是讓我知道。

215
00:08:46,100 --> 00:08:47,520

216
00:08:47,520 --> 00:08:49,750
>> 然後只是一對夫婦
對你們的提示。

217
00:08:49,750 --> 00:08:53,110
這樣的最大的事情之一
我一直強調我的第

218
00:08:53,110 --> 00:08:57,700
當你學習如何編寫代碼是
先寫出來的東西在紙上。

219
00:08:57,700 --> 00:09:01,080
如果你有一個比賽計劃
在您的代碼需要去

220
00:09:01,080 --> 00:09:03,230
和它所需要
這樣做，它的分解

221
00:09:03,230 --> 00:09:06,000
成偽小位
你寫出來的代碼，

222
00:09:06,000 --> 00:09:09,780
你會少
可能使語法錯誤

223
00:09:09,780 --> 00:09:12,355
或創建一個，如果循環
沒有一個人。

224
00:09:12,355 --> 00:09:14,064

225
00:09:14,064 --> 00:09:15,980
如果你知道你
要全面，你

226
00:09:15,980 --> 00:09:19,764
不太可能使這些微小
的錯誤，有時會帶你

227
00:09:19,764 --> 00:09:22,555
小時修復，因為你喜歡，
在那裡我錯過了這架？

228
00:09:22,555 --> 00:09:23,580

229
00:09:23,580 --> 00:09:27,420
>> 關於這一點，請使用Style50。

230
00:09:27,420 --> 00:09:28,820

231
00:09:28,820 --> 00:09:31,590
特別是當你
要去上班時間，

232
00:09:31,590 --> 00:09:34,850
如果你的代碼是所有
切換到一側，

233
00:09:34,850 --> 00:09:37,740
這當然是政策
我們可以說，解決這個問題

234
00:09:37,740 --> 00:09:41,990
因此，它看起來像Style50說
它應該，然後我們會幫你的。

235
00:09:41,990 --> 00:09:43,830
因此，它會讓你的生活更輕鬆。

236
00:09:43,830 --> 00:09:45,030
它會讓我們的生活更輕鬆。

237
00:09:45,030 --> 00:09:46,000
每個人的幸福。

238
00:09:46,000 --> 00:09:47,290
每個人都得到更好的成績。

239
00:09:47,290 --> 00:09:48,760
這不正是我們都想要的嗎？

240
00:09:48,760 --> 00:09:50,420

241
00:09:50,420 --> 00:09:53,860
>> 所以在寫的東西在紙上
你有沒有碰你的電腦。

242
00:09:53,860 --> 00:09:57,540
談出來的東西在一個較高的水平，
確保你知道你要去哪裡。

243
00:09:57,540 --> 00:09:59,940
如果你不確定，
坐下來與人

244
00:09:59,940 --> 00:10:03,340
並通過分步走他們
你的代碼是應該做的。

245
00:10:03,340 --> 00:10:07,940
和九次了10年，你會
像，哦，我忘了一個if條件

246
00:10:07,940 --> 00:10:12,420
還是我忘了分號在這裡或
我更新這個變量是錯誤的。

247
00:10:12,420 --> 00:10:15,740
所以這些都是我成功的秘訣。

248
00:10:15,740 --> 00:10:19,820
>> 如此以來，大約有一半的你
就像你參加超部分，

249
00:10:19,820 --> 00:10:24,080
我只是很
簡要經過循環，

250
00:10:24,080 --> 00:10:26,650
這不是我們原來的議程。

251
00:10:26,650 --> 00:10:28,190
但是他們真的很重要。

252
00:10:28,190 --> 00:10:30,250
所以我要去樣
高速通過那些

253
00:10:30,250 --> 00:10:32,860
在我們進入我們的實際部分。

254
00:10:32,860 --> 00:10:36,269
之前，我這樣做，是有
任何questions--後勤，

255
00:10:36,269 --> 00:10:38,060
就個人而言，是有
什麼都想要

256
00:10:38,060 --> 00:10:40,990
了解我或約
一般一節或一類？

257
00:10:40,990 --> 00:10:43,195

258
00:10:43,195 --> 00:10:43,880
所有的好？

259
00:10:43,880 --> 00:10:45,300
OK，爽。

260
00:10:45,300 --> 00:10:46,781

261
00:10:46,781 --> 00:10:47,280
可愛的。

262
00:10:47,280 --> 00:10:50,071
>> 所以loops--你們應該都
從頭開始認識到這些作品。

263
00:10:50,071 --> 00:10:51,310

264
00:10:51,310 --> 00:10:55,220
因此，循環基本上只是
一種方式為我們做什麼

265
00:10:55,220 --> 00:10:58,900
次一定數量，有的反复
根據某些條件操作。

266
00:10:58,900 --> 00:11:00,140

267
00:11:00,140 --> 00:11:02,090
因此，我們有三個不同的類型。

268
00:11:02,090 --> 00:11:04,860
我們有for循環，同時，和do-whil​​e。

269
00:11:04,860 --> 00:11:06,430

270
00:11:06,430 --> 00:11:11,320
>> 因此，對於loops--我們只是有一個非常
這裡的for循環總體佈局。

271
00:11:11,320 --> 00:11:16,110
這是偉大的，當你知道如何
多次事需要執行。

272
00:11:16,110 --> 00:11:17,040

273
00:11:17,040 --> 00:11:18,790
當我們談論
其他循環，你會

274
00:11:18,790 --> 00:11:20,650
看看為什麼這是一個重要的區別。

275
00:11:20,650 --> 00:11:22,530
但是，for循環的東西集。

276
00:11:22,530 --> 00:11:24,590
你知道你既可以
計算數

277
00:11:24,590 --> 00:11:29,230
或者你知道多少次你
希望此重複開始。

278
00:11:29,230 --> 00:11:32,220
>> 所以，如果你看到這裡，我們
剛剛一般性的

279
00:11:32,220 --> 00:11:34,480
骨骼框架
for循環在這裡。

280
00:11:34,480 --> 00:11:38,080
所以對於初始化，這就是
您的變量被初始化。

281
00:11:38,080 --> 00:11:41,915
馬里奧，我敢肯定，你們做了
像INT i等於0。

282
00:11:41,915 --> 00:11:42,920

283
00:11:42,920 --> 00:11:44,710
這就是將藍色發生。

284
00:11:44,710 --> 00:11:48,290
你有你的條件，這
是什麼檢查每次。

285
00:11:48,290 --> 00:11:52,410
如果這種情況屬實，那麼
代碼的其餘部分執行。

286
00:11:52,410 --> 00:11:54,749
然後它會運行again--問問。

287
00:11:54,749 --> 00:11:57,290
然後我們有更新的，其中
要更新您的變量。

288
00:11:57,290 --> 00:12:01,410
所以，再一次，與像馬里奧，我敢肯定，
你們不喜歡的東西我加再加。

289
00:12:01,410 --> 00:12:04,640
所以每次循環
跑了，我得到了更新，

290
00:12:04,640 --> 00:12:09,370
當我們對檢查它
一定條件下，它是不斷變化的。

291
00:12:09,370 --> 00:12:12,570
>> 因為如果你只是
有一個靜態變量，

292
00:12:12,570 --> 00:12:15,567
如果在執行第一次，這是
只是要無限地執行。

293
00:12:15,567 --> 00:12:18,025
所以，你必須確保你
正確地更新您的變量。

294
00:12:18,025 --> 00:12:19,350

295
00:12:19,350 --> 00:12:23,890
我們也有一個剛
可視化表示形式出現。

296
00:12:23,890 --> 00:12:24,930
大家好？

297
00:12:24,930 --> 00:12:25,630
對於循環。

298
00:12:25,630 --> 00:12:27,540
應該在你的PSET看到了這些。

299
00:12:27,540 --> 00:12:28,840
涼爽。

300
00:12:28,840 --> 00:12:31,870
>> 因此，這裡只是一個簡單的例子。

301
00:12:31,870 --> 00:12:32,860
打印這是CS50！

302
00:12:32,860 --> 00:12:33,360
的10倍。

303
00:12:33,360 --> 00:12:34,850

304
00:12:34,850 --> 00:12:37,906
因此，我們有我們的初始化，
正如我們所看到那裡，我整型

305
00:12:37,906 --> 00:12:41,280
等於0，其中i是少
比10，我加再加。

306
00:12:41,280 --> 00:12:43,090

307
00:12:43,090 --> 00:12:44,540
它會打印出10倍。

308
00:12:44,540 --> 00:12:46,230

309
00:12:46,230 --> 00:12:56,781
>> 因此，儘管loops-- while循環
偉大的，當你這樣做不一定

310
00:12:56,781 --> 00:12:59,530
要知道有多少次它的
去在開始更新。

311
00:12:59,530 --> 00:13:00,640

312
00:13:00,640 --> 00:13:02,580
你只是有一些
這是檢查的條件。

313
00:13:02,580 --> 00:13:09,550
這可能是類似while--
讓我們來舉一個例子，從您的pset。

314
00:13:09,550 --> 00:13:12,540
如果馬里奧，你嘗試
輸入一個負數。

315
00:13:12,540 --> 00:13:13,270
對不對？

316
00:13:13,270 --> 00:13:15,460
你應該
再提示用戶。

317
00:13:15,460 --> 00:13:20,890
所以，你可以說，好吧，如果用戶輸入
東西小於零，再提示

318
00:13:20,890 --> 00:13:21,390
他們。

319
00:13:21,390 --> 00:13:23,890
我敢肯定，有可能
是的東西，你們中的一些

320
00:13:23,890 --> 00:13:24,660
在你的代碼中使用。

321
00:13:24,660 --> 00:13:26,270
>> 所以這是一個簡單的事情。

322
00:13:26,270 --> 00:13:28,490
你有一段時間，一些
有條件的檢查

323
00:13:28,490 --> 00:13:30,460
每當碼去執行。

324
00:13:30,460 --> 00:13:32,660
如果結果為真，我們運行它。

325
00:13:32,660 --> 00:13:33,820
否則，我們不知道。

326
00:13:33,820 --> 00:13:35,650
什麼是真正
important--東西我

327
00:13:35,650 --> 00:13:38,155
認為大衛談到
在lecture--是大括號。

328
00:13:38,155 --> 00:13:40,760

329
00:13:40,760 --> 00:13:42,930
內凡是
括號是什麼執行。

330
00:13:42,930 --> 00:13:45,850
如果你忘記那些
牙套，它一定會

331
00:13:45,850 --> 00:13:48,800
直接成為線
被執行一段時間後。

332
00:13:48,800 --> 00:13:51,040
>> 所以，如果你有三個
事情應該

333
00:13:51,040 --> 00:13:54,020
要發生時，本
條件計算結果為true，

334
00:13:54,020 --> 00:13:58,040
而你沒有這些括號，只有
第一件事情將要發生。

335
00:13:58,040 --> 00:14:01,510
所以要非常的認識
你把你的大括號。

336
00:14:01,510 --> 00:14:04,880
如果你堅持Style50，
這一定會幫助你。

337
00:14:04,880 --> 00:14:06,220

338
00:14:06,220 --> 00:14:06,760
涼爽。

339
00:14:06,760 --> 00:14:10,835
>> 因此，這是從10到零倒計時。

340
00:14:10,835 --> 00:14:12,380

341
00:14:12,380 --> 00:14:16,210
正如你看到這裡，我們初始化
它之外的一些櫃檯。

342
00:14:16,210 --> 00:14:19,250
有一件事，不同的是
我們沒有初始化我們的變量

343
00:14:19,250 --> 00:14:20,300
在我們的while循環。

344
00:14:20,300 --> 00:14:22,150
它在它之外初始化。

345
00:14:22,150 --> 00:14:25,480
我們只是簡單地把
條件為我們的時間。

346
00:14:25,480 --> 00:14:28,630
所以在這種情況下，它們也同時
計數大於零。

347
00:14:28,630 --> 00:14:35,134
我們打印出什麼我們計數，
然後我們我們的遞減變化。

348
00:14:35,134 --> 00:14:36,800
而這也是另外一個需要注意的事情。

349
00:14:36,800 --> 00:14:40,440
我們的更新不會出現在
while循環中的第一部分。

350
00:14:40,440 --> 00:14:44,255
它實際上將發生在
大括號，你的正文。

351
00:14:44,255 --> 00:14:46,820

352
00:14:46,820 --> 00:14:51,860
>> 所以不要-而loops--做-whil​​e循環
非常適合用戶的驗證。

353
00:14:51,860 --> 00:14:54,820
所以，有些人可能有
也用這個在你的PSET。

354
00:14:54,820 --> 00:14:59,960
你可以說，這樣做一樣，
要求用戶輸入。

355
00:14:59,960 --> 00:15:04,690
然後一邊，喜歡的
輸入小於某一數。

356
00:15:04,690 --> 00:15:10,700
>> 因此，對於一個明確的情況下，與馬里奧，它
會做的printf，輸入一個整數，

357
00:15:10,700 --> 00:15:13,820
然後一些整數等於調用getInt。

358
00:15:13,820 --> 00:15:17,060
然後它會實際
第一次執行該代碼。

359
00:15:17,060 --> 00:15:19,120
你居然有
某種整數。

360
00:15:19,120 --> 00:15:23,380
然後你就可以說，而
該整數小於零。

361
00:15:23,380 --> 00:15:26,120
那麼，它要做的是它的
要執行至少一次。

362
00:15:26,120 --> 00:15:27,536
這將檢查情況。

363
00:15:27,536 --> 00:15:29,690
如果條件為
真的，它會再次運行。

364
00:15:29,690 --> 00:15:32,900
>> 所以做-whil​​e循環
巨大的用戶驗證，

365
00:15:32,900 --> 00:15:36,770
因為你知道代碼
會至少執行

366
00:15:36,770 --> 00:15:39,720
一次，而用
while循環，你不

367
00:15:39,720 --> 00:15:41,630
保證它的
要執行一次。

368
00:15:41,630 --> 00:15:45,330
這將檢查情況
，然後再決定要執行它，

369
00:15:45,330 --> 00:15:48,350
而一個做，而會
第一次執行代碼

370
00:15:48,350 --> 00:15:51,110
然後檢查是否
你需要重複它。

371
00:15:51,110 --> 00:15:52,985
這是否區分
道理大家？

372
00:15:52,985 --> 00:15:53,680

373
00:15:53,680 --> 00:15:54,180
行。

374
00:15:54,180 --> 00:15:55,651

375
00:15:55,651 --> 00:15:56,150
涼爽。

376
00:15:56,150 --> 00:15:57,380

377
00:15:57,380 --> 00:15:59,800
>> 所以在這種情況下，這是一種
什麼，我說的是，

378
00:15:59,800 --> 00:16:02,210
這再提示操作，直至
得到的正數。

379
00:16:02,210 --> 00:16:05,060
因此，我們知道的printf
“輸入一個正數”

380
00:16:05,060 --> 00:16:08,720
實際上要求的
輸入會發生至少一次。

381
00:16:08,720 --> 00:16:12,650
如果用戶是邪惡的，並保持
輸入一個負數，誰

382
00:16:12,650 --> 00:16:14,210
不知有多少次，它會執行。

383
00:16:14,210 --> 00:16:17,500
但是這個代碼是保證
執行至少一次。

384
00:16:17,500 --> 00:16:20,040
這就是為什麼它的偉大
驗證輸入。

385
00:16:20,040 --> 00:16:22,300
你會使用相當多。

386
00:16:22,300 --> 00:16:23,870

387
00:16:23,870 --> 00:16:25,830
>> 好吧，什麼問題這麼遠嗎？

388
00:16:25,830 --> 00:16:27,080

389
00:16:27,080 --> 00:16:28,030
我們都好？

390
00:16:28,030 --> 00:16:29,513
難道我說的太快了？

391
00:16:29,513 --> 00:16:30,520

392
00:16:30,520 --> 00:16:31,130
我們是好？

393
00:16:31,130 --> 00:16:31,630
行。

394
00:16:31,630 --> 00:16:32,960

395
00:16:32,960 --> 00:16:33,800
真棒

396
00:16:33,800 --> 00:16:35,841
>> 因此，我們要繼續前進
談談陣列。

397
00:16:35,841 --> 00:16:36,660

398
00:16:36,660 --> 00:16:37,600
涼爽。

399
00:16:37,600 --> 00:16:40,700
所以數組是基本
只是數據結構

400
00:16:40,700 --> 00:16:43,260
這使我們能夠存儲
同一類型的東西。

401
00:16:43,260 --> 00:16:47,920
因此，如果你曾經有一個數組，它的
或者只是將不得不整數

402
00:16:47,920 --> 00:16:51,590
或者它只是將不得不花車
或者它只是將不得不字符。

403
00:16:51,590 --> 00:16:55,440
你不會有一個int
一個char與雙浮子。

404
00:16:55,440 --> 00:16:56,850
一件事。

405
00:16:56,850 --> 00:17:00,810
陣列只是一個尺寸，
或者他們只是一種類型。

406
00:17:00,810 --> 00:17:05,679
>> 所以在這裡我們有大小的數組
3，在這三個整數。

407
00:17:05,679 --> 00:17:07,970
他們可以浮動，但我們
要說他們是整數。

408
00:17:07,970 --> 00:17:09,310

409
00:17:09,310 --> 00:17:16,970
所以，有一點需要知道的是，數組
是一組大小在初始化

410
00:17:16,970 --> 00:17:22,285
它們，並且它們不easily--
因為大家都不太舒服，

411
00:17:22,285 --> 00:17:25,034
你應該把它們看作
不能夠在尺寸上延伸。

412
00:17:25,034 --> 00:17:26,119

413
00:17:26,119 --> 00:17:28,740
但是大的你設置了
你的數組中的開始，

414
00:17:28,740 --> 00:17:31,070
這就是它的大小是怎麼回事
留下來，因為數組

415
00:17:31,070 --> 00:17:33,070
是連續的存儲器塊。

416
00:17:33,070 --> 00:17:34,007

417
00:17:34,007 --> 00:17:35,840
當你們拿到
進入多一點點

418
00:17:35,840 --> 00:17:40,820
如何存儲的實際佈置在
盤和在所述堆和棧，

419
00:17:40,820 --> 00:17:42,220
它會做一點更有意義。

420
00:17:42,220 --> 00:17:48,310
>> 但是，你可能只是覺得像，這是
只是排在你的磁盤空間。

421
00:17:48,310 --> 00:17:52,540
而且你不能保證有
去後它成為空閒空間。

422
00:17:52,540 --> 00:17:55,290
可以初始化一個數組
3，然後也許你

423
00:17:55,290 --> 00:17:59,190
初始化五個另一個數組
後來，它的後正確的。

424
00:17:59,190 --> 00:18:04,000
所以，如果你走過去點
3在該第一陣列，

425
00:18:04,000 --> 00:18:06,370
你會寫
過別的東西。

426
00:18:06,370 --> 00:18:10,390
所以數組are--為你們，只是
把它們看成一個固定的大小。

427
00:18:10,390 --> 00:18:12,700

428
00:18:12,700 --> 00:18:16,890
>> 所以，創建你要去的array--
需要這個做了不少。

429
00:18:16,890 --> 00:18:18,240

430
00:18:18,240 --> 00:18:22,080
所以在以同樣的方式，我們有一個
一般結構為我們的for循環，

431
00:18:22,080 --> 00:18:24,910
我們有一個很好的通用
結構為我們的數組。

432
00:18:24,910 --> 00:18:28,430
因為它們的一種類型中，所有的
數組中的元素是一種類型的，

433
00:18:28,430 --> 00:18:30,950
您需要初始化
那是什麼類型的。

434
00:18:30,950 --> 00:18:33,804
>> 所以，當你看到這裡，我們有一個
可愛的小支架的數據類型。

435
00:18:33,804 --> 00:18:35,970
因此，如果我們要創建一個int
陣列，這將是int。

436
00:18:35,970 --> 00:18:38,830
如果我們要創建一個char
數組，它會是char。

437
00:18:38,830 --> 00:18:41,890
如果我們要創建一個字符串
陣列，這將是字符串。

438
00:18:41,890 --> 00:18:45,140
然後陣列的名稱，
無論你想的那樣。

439
00:18:45,140 --> 00:18:51,750
因此，也許它的測試成績還是可能
這是學生或也許是糖果。

440
00:18:51,750 --> 00:18:54,440
無論你決定你的名字
數組，這就是它會。

441
00:18:54,440 --> 00:18:57,260
>> 然後在括號中，你會
有你想要的大小。

442
00:18:57,260 --> 00:19:01,350
因此，我們存儲10個學生或
我們存儲15種糖果？

443
00:19:01,350 --> 00:19:03,200

444
00:19:03,200 --> 00:19:03,920
什麼不是。

445
00:19:03,920 --> 00:19:06,830
所以，在這裡我們的例子中，
我們要創建一個數組

446
00:19:06,830 --> 00:19:10,100
大小3，你的傢伙
看到這裡就對了。

447
00:19:10,100 --> 00:19:11,350

448
00:19:11,350 --> 00:19:15,990
當我們第一次初始化
它，一切都設置為零。

449
00:19:15,990 --> 00:19:18,970
所以它只是想
像一張白紙。

450
00:19:18,970 --> 00:19:22,550
我們擁有所有這些空間，我們都
這些盒子，我們可以把我們的數據為，

451
00:19:22,550 --> 00:19:25,530
但他們只是空白
暫且。

452
00:19:25,530 --> 00:19:28,700
>> 因此，如果我們想實際
為其分配這些值，

453
00:19:28,700 --> 00:19:33,050
我們這樣做是正確的在這裡顯示。

454
00:19:33,050 --> 00:19:39,170
所以，你有什麼對你的名字
數組，然後你想要的指標。

455
00:19:39,170 --> 00:19:43,070
因此，該指數僅僅指的是，
就像我們在看什麼插槽。

456
00:19:43,070 --> 00:19:47,830
和重要的事情要注意
是數組索引從零開始。

457
00:19:47,830 --> 00:19:53,160
因此，如果我們想在存儲器中的第一空間
我們的陣列，這將是零。

458
00:19:53,160 --> 00:19:54,740
如果我們希望第二個，它會是一個。

459
00:19:54,740 --> 00:19:56,198
如果我們想在第三​​，這將是兩人。

460
00:19:56,198 --> 00:19:57,820
等等等等。

461
00:19:57,820 --> 00:20:02,130
>> 這也是為什麼，以往，
當我們做loops--我敢肯定，

462
00:20:02,130 --> 00:20:05,030
你們想知道，為什麼
我們開始在0與1？

463
00:20:05,030 --> 00:20:09,909
那是因為，當我們轉換
為使用數組，它映射正確。

464
00:20:09,909 --> 00:20:11,700
所以，如果你想
遍歷到一個數組中，

465
00:20:11,700 --> 00:20:14,830
使得很多更有意義
做i等於0，因為我們

466
00:20:14,830 --> 00:20:17,940
知道將對應
以在存儲器中的第一點。

467
00:20:17,940 --> 00:20:18,990

468
00:20:18,990 --> 00:20:19,990
每個人都好有嗎？

469
00:20:19,990 --> 00:20:21,060

470
00:20:21,060 --> 00:20:21,560
涼爽。

471
00:20:21,560 --> 00:20:26,240
>> 然後在這裡的底部是剛剛
另一種方式來初始化一個數組。

472
00:20:26,240 --> 00:20:29,590
你仍然有你
數據類型和名稱，

473
00:20:29,590 --> 00:20:31,960
但不是實際
把一個規模在那裡，

474
00:20:31,960 --> 00:20:33,830
你可以做的空括號。

475
00:20:33,830 --> 00:20:36,350
然後用這些花
撐桿在底部，

476
00:20:36,350 --> 00:20:40,270
你可以只輸入數據
你想用逗號隔開。

477
00:20:40,270 --> 00:20:43,070
並自動將
說好，我看

478
00:20:43,070 --> 00:20:47,300
你有三個
事情在這些括號。

479
00:20:47,300 --> 00:20:51,410
所以我知道我需要分配3
的存儲器塊，然後存儲這些。

480
00:20:51,410 --> 00:20:55,300

481
00:20:55,300 --> 00:21:01,670
>> 因此，第一個版本，你可以使用
如果你問你的用戶輸入

482
00:21:01,670 --> 00:21:04,770
值，這樣就可以
遍歷數組

483
00:21:04,770 --> 00:21:07,660
和ask--得到一些INT輸入它們。

484
00:21:07,660 --> 00:21:10,500
如果你預先知道的值，
這讓很多更有意義

485
00:21:10,500 --> 00:21:12,110
使用第二種方法。

486
00:21:12,110 --> 00:21:17,270
但在大多數情況下，你可能不知道
什麼這些值將是。

487
00:21:17,270 --> 00:21:19,060

488
00:21:19,060 --> 00:21:19,560
涼爽。

489
00:21:19,560 --> 00:21:20,393
還有沒有其他問題？

490
00:21:20,393 --> 00:21:21,206

491
00:21:21,206 --> 00:21:21,705
好吧。

492
00:21:21,705 --> 00:21:25,960

493
00:21:25,960 --> 00:21:30,370
>> 所以，訪問elements--這麼一
關於陣列的偉大的事情

494
00:21:30,370 --> 00:21:33,310
是，它們是隨機
訪問，這意味著你

495
00:21:33,310 --> 00:21:36,010
不必去翻每個塊。

496
00:21:36,010 --> 00:21:38,150
如果你知道你
想要什麼塊2，

497
00:21:38,150 --> 00:21:40,820
你可以說，給我擋住兩人。

498
00:21:40,820 --> 00:21:44,160
這就是為什麼這些
索引是如此的重要，

499
00:21:44,160 --> 00:21:46,220
這就是我們如何真正訪問它們。

500
00:21:46,220 --> 00:21:50,660
所以在這種情況下，如我們之前的時候看到
我們被賦值，在一

501
00:21:50,660 --> 00:21:55,360
之前，我們有名稱和
指數我們想訪問，對不對？

502
00:21:55,360 --> 00:21:59,370
因此，在以同樣的方式，這就是我們
這樣做實際上是拉出來的數據。

503
00:21:59,370 --> 00:22:02,940
我們的名字，我們
有我們想要的索引。

504
00:22:02,940 --> 00:22:06,710
>> 所以在這種情況下，對環
這兒的底部，任何人

505
00:22:06,710 --> 00:22:09,060
知道它在做什麼，
它會打印出來？

506
00:22:09,060 --> 00:22:13,771

507
00:22:13,771 --> 00:22:14,270
Mmhmm​​？

508
00:22:14,270 --> 00:22:17,790

509
00:22:17,790 --> 00:22:18,520
沒錯。

510
00:22:18,520 --> 00:22:20,130
所以，是的，它只是通過迭代。

511
00:22:20,130 --> 00:22:23,410
i等於zero--我們可以走
通過代碼只是快。

512
00:22:23,410 --> 00:22:26,680
i是等於零，i是少
三多在這一點上，對不對？

513
00:22:26,680 --> 00:22:27,780
這樣檢查出來。

514
00:22:27,780 --> 00:22:33,370
我們說好，打印˚F
無論是在我的溫度。

515
00:22:33,370 --> 00:22:37,990
我是零就在這裡，當我們第一次
迭代，所以我們去這第一點，

516
00:22:37,990 --> 00:22:40,840
我們說好，65是
數我們要打印出來。

517
00:22:40,840 --> 00:22:43,570
所以它會打印出65
然後做一個新的生產線。

518
00:22:43,570 --> 00:22:46,550
我會更新，所以它打印87。

519
00:22:46,550 --> 00:22:48,780
它再次更新，它會打印30。

520
00:22:48,780 --> 00:22:49,810

521
00:22:49,810 --> 00:22:50,630
每個人都很酷吧？

522
00:22:50,630 --> 00:22:51,630

523
00:22:51,630 --> 00:22:52,130
真棒。

524
00:22:52,130 --> 00:22:54,340

525
00:22:54,340 --> 00:22:54,840
>> 行。

526
00:22:54,840 --> 00:22:57,710
因此，這裡的那種之一
的事情，我是說怎麼樣

527
00:22:57,710 --> 00:23:00,020
你可以跟踪
一個人的成績，為什麼

528
00:23:00,020 --> 00:23:03,300
你可以使用第一
初始化它的方式

529
00:23:03,300 --> 00:23:04,890
而不是說第二種方法。

530
00:23:04,890 --> 00:23:06,620
而這只是經過。

531
00:23:06,620 --> 00:23:08,945
並請注意，我們有30類大小。

532
00:23:08,945 --> 00:23:10,690

533
00:23:10,690 --> 00:23:15,770
我們正在初始化這個
整型數組的大小是30的。

534
00:23:15,770 --> 00:23:18,070
然後我們遍歷
通過與我們

535
00:23:18,070 --> 00:23:20,910
要求用戶輸入
分數為每個這些

536
00:23:20,910 --> 00:23:23,700
然後將其分配給
在存儲器中的特定位置

537
00:23:23,700 --> 00:23:24,860
介於該數組。

538
00:23:24,860 --> 00:23:26,700

539
00:23:26,700 --> 00:23:27,890
很酷吧？

540
00:23:27,890 --> 00:23:29,650
這是否有意義大家？

541
00:23:29,650 --> 00:23:30,150
Mmhmm​​？

542
00:23:30,150 --> 00:23:32,910

543
00:23:32,910 --> 00:23:40,360
>> 因此，包括hashtag定義類的大小
30是一個預處理指令，

544
00:23:40,360 --> 00:23:43,780
這只是意味著它gets--有
做這樣的編譯過程。

545
00:23:43,780 --> 00:23:47,595
你可以把它想像
作為全局變量。

546
00:23:47,595 --> 00:23:49,260

547
00:23:49,260 --> 00:23:53,030
我們這樣做的方式是
typically--它可以讓你的代碼

548
00:23:53,030 --> 00:23:54,770
可以更容易地改變。

549
00:23:54,770 --> 00:23:59,480
所以我們可以說，我們的班級規模
突然變從30到15，

550
00:23:59,480 --> 00:24:03,930
如果我沒有定義這種方式，我會
必須要經過我的整個程序

551
00:24:03,930 --> 00:24:07,420
並改變了30的每個實例到15。

552
00:24:07,420 --> 00:24:11,590
但是這一點，我得到改變一個
現貨方面，和其他一切的變化。

553
00:24:11,590 --> 00:24:14,930
>> 如果你想要做的
在一個情況下，散列定義

554
00:24:14,930 --> 00:24:19,020
在那裡你正在跟踪一些
設置分數數一類

555
00:24:19,020 --> 00:24:23,250
或者您使用的是數字
將要使用的，等等，

556
00:24:23,250 --> 00:24:27,740
整個一個很長的程序，它的
更好地限定在一開始

557
00:24:27,740 --> 00:24:34,440
因此，如果以往任何時候都改變了，你會得到
改變一個地方，而不是100。

558
00:24:34,440 --> 00:24:34,940
是嗎？

559
00:24:34,940 --> 00:24:39,830
>> 學生：介於這樣做，只是
過聲明[聽不清]在頂部。

560
00:24:39,830 --> 00:24:42,470
>> ALLISON BUCHHOLTZ-AU：所以這
是因為有efficient--

561
00:24:42,470 --> 00:24:45,460
它是一種範圍之內
我們可以在本節涵蓋。

562
00:24:45,460 --> 00:24:49,236
它與效率做多
以及如何實際的東西

563
00:24:49,236 --> 00:24:50,485
在編譯過程中的工作。

564
00:24:50,485 --> 00:24:52,590

565
00:24:52,590 --> 00:24:55,006
如果你想真正了解
這件事，我很高興地向您發送

566
00:24:55,006 --> 00:24:56,450
一封電子郵件，它的資源。

567
00:24:56,450 --> 00:24:57,810

568
00:24:57,810 --> 00:25:03,880
散列定義趨於
最好的東西。

569
00:25:03,880 --> 00:25:06,380
而隨著你的代碼越多，你
種學習的細微差別

570
00:25:06,380 --> 00:25:09,135
當你要使用的
全球對哈希定義。

571
00:25:09,135 --> 00:25:11,010
但暫時，
你真的沒有

572
00:25:11,010 --> 00:25:13,290
擔心的是
這簡短的回答。

573
00:25:13,290 --> 00:25:15,360

574
00:25:15,360 --> 00:25:16,360
每個人都好有嗎？

575
00:25:16,360 --> 00:25:18,151
而且，如果你想
使用散列定義，

576
00:25:18,151 --> 00:25:21,120
這真的很重要要注意
這個名字應該是全部大寫。

577
00:25:21,120 --> 00:25:22,210

578
00:25:22,210 --> 00:25:24,674
我們不只是在做
班級規模是巨大的。

579
00:25:24,674 --> 00:25:26,090
它實際上應該是全部大寫。

580
00:25:26,090 --> 00:25:27,880

581
00:25:27,880 --> 00:25:28,610
涼爽。

582
00:25:28,610 --> 00:25:30,130
還有別的嗎？

583
00:25:30,130 --> 00:25:31,190
我們是好？

584
00:25:31,190 --> 00:25:32,220
可愛的。

585
00:25:32,220 --> 00:25:32,720
歡迎光臨。

586
00:25:32,720 --> 00:25:34,240

587
00:25:34,240 --> 00:25:38,495
>> 好了，我要你們去看看
在此，看你是否能找到的bug。

588
00:25:38,495 --> 00:25:45,580

589
00:25:45,580 --> 00:25:46,507
我會給你一個提示。

590
00:25:46,507 --> 00:25:47,840
它是介於該for循環。

591
00:25:47,840 --> 00:25:53,070

592
00:25:53,070 --> 00:25:53,665
Mmhmm​​？

593
00:25:53,665 --> 00:25:55,704
>> 學生：應小於等於2。

594
00:25:55,704 --> 00:25:56,920

595
00:25:56,920 --> 00:26:01,094
>> 艾里遜：所以它可能比小於或
等於2，或者它可以是小於3。

596
00:26:01,094 --> 00:26:02,510
和有什麼理由是什麼？

597
00:26:02,510 --> 00:26:05,135
>> 學生：[聽不清]，0，1，2。

598
00:26:05,135 --> 00:26:06,080
>> 艾里遜：沒錯。

599
00:26:06,080 --> 00:26:12,180
因此，在大小為n的陣列，我們
只有有n個減1的指數。

600
00:26:12,180 --> 00:26:13,700

601
00:26:13,700 --> 00:26:14,200
涼爽。

602
00:26:14,200 --> 00:26:15,091

603
00:26:15,091 --> 00:26:17,840
然後我們就可以得到真正的瘋狂
並獲得多維數組。

604
00:26:17,840 --> 00:26:19,340

605
00:26:19,340 --> 00:26:23,960
其中的一個問題，當我把它我
一年所需的多維數組，

606
00:26:23,960 --> 00:26:28,720
而且我認為他們中的一個可能需要
就在今年，這樣很舒服。

607
00:26:28,720 --> 00:26:30,140
包裝你的頭左右，現在。

608
00:26:30,140 --> 00:26:33,087
它會回來困擾
你，但在冷靜的方式。

609
00:26:33,087 --> 00:26:35,420
這樣你就可以真的只是想
多維數組的

610
00:26:35,420 --> 00:26:36,870
作為數組的數組。

611
00:26:36,870 --> 00:26:38,060

612
00:26:38,060 --> 00:26:43,809
所以，你可以種覺得這頂
行作為存儲器的第一個塊。

613
00:26:43,809 --> 00:26:45,600
而這一次是
內存第二塊，

614
00:26:45,600 --> 00:26:47,570
和最後一行的
內存三大塊。

615
00:26:47,570 --> 00:26:50,740
和範圍內的，有一個陣列。

616
00:26:50,740 --> 00:26:53,250
不過，當然，它更容易
描繪這樣。

617
00:26:53,250 --> 00:26:55,610
>> 所以，你初始化它以同樣的方式。

618
00:26:55,610 --> 00:26:57,290

619
00:26:57,290 --> 00:27:01,610
這是一個字符
三名由三種。

620
00:27:01,610 --> 00:27:04,180
所以，你有三排
和三列。

621
00:27:04,180 --> 00:27:06,760
我們表示這樣的看法。

622
00:27:06,760 --> 00:27:11,800
而你能訪問它
相同的方式，由排列。

623
00:27:11,800 --> 00:27:14,840
所以1,1我們在這裡看到。

624
00:27:14,840 --> 00:27:18,730
我們分配一個零，零在那裡。

625
00:27:18,730 --> 00:27:21,900
2,0和0,2。

626
00:27:21,900 --> 00:27:26,900
所以你只需訪問them--如果
任何人的做過線性代數，

627
00:27:26,900 --> 00:27:31,580
訪問中的元件以相同的方式
一個矩陣的計算，它在這裡同樣的想法。

628
00:27:31,580 --> 00:27:33,030
這樣你就可以與回數學。

629
00:27:33,030 --> 00:27:34,130

630
00:27:34,130 --> 00:27:36,380
你也不必太擔心
很多關於這個現在。

631
00:27:36,380 --> 00:27:38,671
這是件好事，曝光，
要知道你可以做到這一點。

632
00:27:38,671 --> 00:27:42,700
你可以創建一些
瘋狂number--可以

633
00:27:42,700 --> 00:27:44,750
打造瘋狂陣列的
所有我要說的話。

634
00:27:44,750 --> 00:27:45,250
[聽不清]

635
00:27:45,250 --> 00:27:46,585

636
00:27:46,585 --> 00:27:48,460
它變得有點瘋狂，
但它真的很酷。

637
00:27:48,460 --> 00:27:50,020

638
00:27:50,020 --> 00:27:50,670
真棒。

639
00:27:50,670 --> 00:27:52,550
>> 然後，讓我們有一個例子來說明。

640
00:27:52,550 --> 00:27:54,165
它可以計算一個字符串的長度。

641
00:27:54,165 --> 00:27:55,210

642
00:27:55,210 --> 00:27:59,670
那麼有多少人知道，
您正在使用的字符串

643
00:27:59,670 --> 00:28:01,265
是字符數組只？

644
00:28:01,265 --> 00:28:03,670

645
00:28:03,670 --> 00:28:04,655
好吧，是的。

646
00:28:04,655 --> 00:28:08,000
所以你們可能會認為你沒有
使用數組，但是以往任何時候

647
00:28:08,000 --> 00:28:10,740
您在使用的GetString
CSView庫，你

648
00:28:10,740 --> 00:28:14,690
其實只是要求
字符數組。

649
00:28:14,690 --> 00:28:17,450
我們正在照顧所有的
在後端為您服務。

650
00:28:17,450 --> 00:28:20,184
但你使用過
數組，因為你開始。

651
00:28:20,184 --> 00:28:21,350
你只是不知道它。

652
00:28:21,350 --> 00:28:22,420

653
00:28:22,420 --> 00:28:28,390
>> 而只要你有一個字符數組
或數組的存儲字符串

654
00:28:28,390 --> 00:28:32,050
過去的事情永遠是什麼
叫一個空終止，這

655
00:28:32,050 --> 00:28:33,830
這是在這裡。

656
00:28:33,830 --> 00:28:37,300
那就是在結束時
每次你存儲字。

657
00:28:37,300 --> 00:28:41,170
因此，如果我們想弄清楚的
字符串的長度，我們可以說，

658
00:28:41,170 --> 00:28:45,320
嗯，你知道，
該塊的內容

659
00:28:45,320 --> 00:28:46,867
不等於我們的空終止。

660
00:28:46,867 --> 00:28:49,450
這意味著，有一些
性格有我們實際上是

661
00:28:49,450 --> 00:28:51,540
關心那是字的一部分。

662
00:28:51,540 --> 00:28:52,665
你增加的長度。

663
00:28:52,665 --> 00:28:55,540
然後，當我們真正去
這個詞的結尾，它會終止

664
00:28:55,540 --> 00:28:58,790
它會回報我們的長度我們。

665
00:28:58,790 --> 00:29:00,098
Mmhmm​​？

666
00:29:00,098 --> 00:29:02,906
>> 學生：請問空間
算不算空終止？

667
00:29:02,906 --> 00:29:04,780
艾里遜：那麼一個空間
不是一個空終止。

668
00:29:04,780 --> 00:29:10,590
所以，如果你有multiple--空間
實際上是一個特定的ASCII值。

669
00:29:10,590 --> 00:29:11,719

670
00:29:11,719 --> 00:29:13,552
學生：什麼是
再次感嘆平等？

671
00:29:13,552 --> 00:29:17,080
ALLISON：所以，這就是您參考。

672
00:29:17,080 --> 00:29:21,220
如果你聽到我在辦公時間內，
我總是把它一樣，砰等於。

673
00:29:21,220 --> 00:29:23,520
因此，爆炸沒有。

674
00:29:23,520 --> 00:29:25,370
因此，這是不是等於。

675
00:29:25,370 --> 00:29:28,480

676
00:29:28,480 --> 00:29:32,290
所以，如果你想
看看什麼是假的，

677
00:29:32,290 --> 00:29:35,915
你知道總是這樣，什麼爆炸
變量是，如果它是假的，

678
00:29:35,915 --> 00:29:38,540
它的計算結果為true並
可以做很酷的東西這一點。

679
00:29:38,540 --> 00:29:39,830

680
00:29:39,830 --> 00:29:40,675
後來更多。

681
00:29:40,675 --> 00:29:42,090

682
00:29:42,090 --> 00:29:42,590
涼爽。

683
00:29:42,590 --> 00:29:44,260
一切都很好嗎？

684
00:29:44,260 --> 00:29:44,760
真棒。

685
00:29:44,760 --> 00:29:48,045
>> 所以，現在這是你的男人“的時間
工作，因為我一直在談論。

686
00:29:48,045 --> 00:29:49,220

687
00:29:49,220 --> 00:29:53,200
所以，我希望你只是創建一個數組
與整數1，2，和3，

688
00:29:53,200 --> 00:29:54,660
然後讓他們打印出來。

689
00:29:54,660 --> 00:29:58,050
你不必做的一樣，
主，等等，等等，等等，等等。

690
00:29:58,050 --> 00:30:00,840
我只是想讓你初始化
數組，然後創建

691
00:30:00,840 --> 00:30:04,790
一個for循環打印出來out--
或while循環，給你。

692
00:30:04,790 --> 00:30:07,600
>> 我只給你一對夫婦
分上工作了。

693
00:30:07,600 --> 00:30:09,320
我要休息我的聲音。

694
00:30:09,320 --> 00:30:13,290
如果您有任何問題，我很高興
要過來和你說話的傢伙。

695
00:30:13,290 --> 00:30:15,290
隨時與對方交談。

696
00:30:15,290 --> 00:30:16,125
獲得更多的糖果。

697
00:30:16,125 --> 00:30:17,181

698
00:30:17,181 --> 00:30:18,930
其實，我只是
走動糖果。

699
00:30:18,930 --> 00:30:19,600
怎麼樣？

700
00:30:19,600 --> 00:30:22,974

701
00:30:22,974 --> 00:30:23,938
>> 你願意購買嗎？

702
00:30:23,938 --> 00:30:34,703

703
00:30:34,703 --> 00:30:36,675
任何人在這個房間要糖果？

704
00:30:36,675 --> 00:30:47,030

705
00:30:47,030 --> 00:30:49,206
您也可以不止一個，伙計們。

706
00:30:49,206 --> 00:30:50,330
抓了一把，如果你想要的。

707
00:30:50,330 --> 00:30:52,690

708
00:30:52,690 --> 00:30:53,190
不妨。

709
00:30:53,190 --> 00:30:54,929

710
00:30:54,929 --> 00:30:55,720
其他人都好？

711
00:30:55,720 --> 00:30:57,561

712
00:30:57,561 --> 00:30:58,060
行。

713
00:30:58,060 --> 00:31:02,750

714
00:31:02,750 --> 00:31:07,290
>> 另外，我要創造
匿名谷歌的形式，

715
00:31:07,290 --> 00:31:09,830
並且你們可以只提交
每一段後反饋

716
00:31:09,830 --> 00:31:14,115
如果有什麼東西要
改善後或者是你想要完成的。

717
00:31:14,115 --> 00:31:17,135
如果我是一個有點太強力的
為了你，我可以調下來。

718
00:31:17,135 --> 00:31:18,510

719
00:31:18,510 --> 00:31:20,885
我將創建並發送
出來大家算賬。

720
00:31:20,885 --> 00:32:39,420

721
00:32:39,420 --> 00:32:40,020
>> 行。

722
00:32:40,020 --> 00:32:41,050
因此，讓我們從小事做起。

723
00:32:41,050 --> 00:32:42,740
如何將我們初始化我們的數組？

724
00:32:42,740 --> 00:32:49,690

725
00:32:49,690 --> 00:32:51,670
什麼是我們的陣列的類型？

726
00:32:51,670 --> 00:32:52,410
一個int，不是嗎？

727
00:32:52,410 --> 00:32:54,740
好了，你想要做什麼
打電話給你的數組？

728
00:32:54,740 --> 00:32:57,880

729
00:32:57,880 --> 00:32:59,230
int數組，很酷。

730
00:32:59,230 --> 00:33:04,200
好吧，讓我們有整型int數組
等於，之後，我們有什麼？

731
00:33:04,200 --> 00:33:07,009

732
00:33:07,009 --> 00:33:08,259
學生：[聽不清]括號中。

733
00:33:08,259 --> 00:33:09,140
艾里遜：括號。

734
00:33:09,140 --> 00:33:10,330

735
00:33:10,330 --> 00:33:11,775
然後在大括號內？

736
00:33:11,775 --> 00:33:14,360

737
00:33:14,360 --> 00:33:16,830
一個逗號2逗號三種。

738
00:33:16,830 --> 00:33:17,330
涼爽。

739
00:33:17,330 --> 00:33:18,660
所以這是所有權利。

740
00:33:18,660 --> 00:33:21,480
所以，現在我們有我們的for循環。

741
00:33:21,480 --> 00:33:24,180
所以在第一部分我們的
for循環，我們有什麼？

742
00:33:24,180 --> 00:33:25,796

743
00:33:25,796 --> 00:33:27,420
>> 學生：我等於0？

744
00:33:27,420 --> 00:33:31,400
>> 艾里遜：那麼INT i等於0，
然後呢，是我們的條件？

745
00:33:31,400 --> 00:33:33,750

746
00:33:33,750 --> 00:33:36,120
什麼是我要小於？

747
00:33:36,120 --> 00:33:39,510
不到三年，並
我們怎麼做，我們更新嗎？

748
00:33:39,510 --> 00:33:41,630
我加上加，由一個更新它。

749
00:33:41,630 --> 00:33:46,150
然後我們將有
一些printf的整數中，

750
00:33:46,150 --> 00:33:49,530
什麼是最後一個
一部分實際上

751
00:33:49,530 --> 00:33:51,370
會說什麼，我們應該打印？

752
00:33:51,370 --> 00:33:55,610

753
00:33:55,610 --> 00:33:59,120
這將是的名稱
數組，數據類型為int的數組，對不對？

754
00:33:59,120 --> 00:34:01,090
和什麼在int數組的括號？

755
00:34:01,090 --> 00:34:02,540

756
00:34:02,540 --> 00:34:03,640
我。

757
00:34:03,640 --> 00:34:06,550
[？所以，我？]叫我
例如，但你去那裡。

758
00:34:06,550 --> 00:34:07,939

759
00:34:07,939 --> 00:34:08,480
沒有那麼糟糕。

760
00:34:08,480 --> 00:34:09,250
大家好？

761
00:34:09,250 --> 00:34:10,220

762
00:34:10,220 --> 00:34:10,719
涼爽。

763
00:34:10,719 --> 00:34:12,949

764
00:34:12,949 --> 00:34:14,340
>> 因此，我們用數組實現。

765
00:34:14,340 --> 00:34:15,190
恭喜。

766
00:34:15,190 --> 00:34:18,274
你設法迭代
通過所有the--是嗎？

767
00:34:18,274 --> 00:34:19,705
>> 學生：[聽不清]

768
00:34:19,705 --> 00:34:20,659
>> 艾里遜：是的。

769
00:34:20,659 --> 00:34:26,383

770
00:34:26,383 --> 00:34:27,798
>> 學生：我有一個問題。

771
00:34:27,798 --> 00:34:30,288
你應該縮進括號？

772
00:34:30,288 --> 00:34:34,150
>> 艾里遜：那麼大括號應該排隊
用for循環，然後一切

773
00:34:34,150 --> 00:34:35,699
裡面的大括號應縮進。

774
00:34:35,699 --> 00:34:37,824
>> 學生：OK，應
for循環被縮進？

775
00:34:37,824 --> 00:34:41,159
>> 艾里遜：for循環不
需要在這一點上縮進。

776
00:34:41,159 --> 00:34:46,750
如果你是主，如果我們
實際上有一個main函數在這裡，

777
00:34:46,750 --> 00:34:48,929
它會從主縮進。

778
00:34:48,929 --> 00:34:52,590
但在這種情況下，它的罰款。

779
00:34:52,590 --> 00:34:53,354
是的，問題。

780
00:34:53,354 --> 00:34:55,687
>> 學生：你需要有
括號的例子呢？

781
00:34:55,687 --> 00:34:59,050

782
00:34:59,050 --> 00:35:01,260
>> ALLISON：是的，如果你是
初始化這種方式。

783
00:35:01,260 --> 00:35:03,430

784
00:35:03,430 --> 00:35:06,860
所以請記住，這是第二次
初始化數組，其中的方法

785
00:35:06,860 --> 00:35:10,680
我們有括號，然後我們的實際
數據通過在逗號分隔。

786
00:35:10,680 --> 00:35:14,700

787
00:35:14,700 --> 00:35:17,281
>> 學生：我想有
括號內為例子。

788
00:35:17,281 --> 00:35:19,010
>> 艾里遜：不，他們是大括號。

789
00:35:19,010 --> 00:35:20,039
他們是大括號。

790
00:35:20,039 --> 00:35:22,330
如果你正在初始化它
這第二種方法，它的括號。

791
00:35:22,330 --> 00:35:28,780
如果我們說，INT example--如果
我們只是想要一個空白數組int類型，

792
00:35:28,780 --> 00:35:32,270
這將是int例如括號三種。

793
00:35:32,270 --> 00:35:34,670
括號表示的大小。

794
00:35:34,670 --> 00:35:36,720
當你有括號，
它的實際數據

795
00:35:36,720 --> 00:35:39,244
你把它變成這樣。

796
00:35:39,244 --> 00:35:40,535
我們可以回滾真快。

797
00:35:40,535 --> 00:35:42,370

798
00:35:42,370 --> 00:35:48,010
>> 所以在這一塊，這只是我們
最初的數組，初始化。

799
00:35:48,010 --> 00:35:51,640
在這裡，我們是單獨
點分配給他們，

800
00:35:51,640 --> 00:35:56,730
所以這代表的索引我們
數組，這就是為什麼我們有括號。

801
00:35:56,730 --> 00:36:01,630
但在這裡，如果你注意到，我們已經
離開我們沒有括號的尺寸，

802
00:36:01,630 --> 00:36:05,969
我們用它進行初始化
實際數據的所有功能於一身的大括號。

803
00:36:05,969 --> 00:36:08,260
學生：那麼，我們為什麼不有
括號中的這個例子嗎？

804
00:36:08,260 --> 00:36:11,030
ALLISON：那麼，在哪一部分？

805
00:36:11,030 --> 00:36:14,645
學生：會不會我們
比方說，INT例如支架

806
00:36:14,645 --> 00:36:19,710
等於括號[聽不清]
括號內為例子。

807
00:36:19,710 --> 00:36:20,900
>> ALLISON：哦，對不起。

808
00:36:20,900 --> 00:36:21,560
你說得對。

809
00:36:21,560 --> 00:36:22,690
我們確實有支架存在。

810
00:36:22,690 --> 00:36:23,486
對不起你們，是我不好。

811
00:36:23,486 --> 00:36:25,150

812
00:36:25,150 --> 00:36:27,560
是的，你應該有
例如括號後。

813
00:36:27,560 --> 00:36:28,850
你是絕對正確的。

814
00:36:28,850 --> 00:36:29,750
>> 學生：[聽不清]沒有這樣做。

815
00:36:29,750 --> 00:36:31,270
>> 艾里遜：不，你必須有
括號，否則它的

816
00:36:31,270 --> 00:36:32,810
不會聲明數組。

817
00:36:32,810 --> 00:36:33,685
學生：[聽不清]。

818
00:36:33,685 --> 00:36:34,200
我們對此深感抱歉。

819
00:36:34,200 --> 00:36:36,200
>> ALLISON：對不起，您需要
例如括號後。

820
00:36:36,200 --> 00:36:36,620

821
00:36:36,620 --> 00:36:37,120
錯字。

822
00:36:37,120 --> 00:36:40,650

823
00:36:40,650 --> 00:36:43,160
好抓，金星為您服務。

824
00:36:43,160 --> 00:36:47,730
另外，如果你問一個問題，
你們會告訴我你的名字，

825
00:36:47,730 --> 00:36:48,570
我喜歡這一點。

826
00:36:48,570 --> 00:36:50,630
我很想能
知道所有人的名字。

827
00:36:50,630 --> 00:36:53,187
我不會冷
其實給你打電話，我

828
00:36:53,187 --> 00:36:54,520
不只是想知道你的名字。

829
00:36:54,520 --> 00:36:57,530
所以，請居然告訴我你的名字。

830
00:36:57,530 --> 00:36:58,426
>> 利亞利亞。

831
00:36:58,426 --> 00:36:59,340
>> 艾里遜：利亞。

832
00:36:59,340 --> 00:37:03,960
好了，functions--我知道在短暫的
他們的演講中談到了這一點。

833
00:37:03,960 --> 00:37:07,590
所以功能是正中下懷
像這樣的小一口大小的東西

834
00:37:07,590 --> 00:37:11,525
在這裡你傳遞的投入，一些
神奇的發生了，而你得到的輸出。

835
00:37:11,525 --> 00:37:12,680

836
00:37:12,680 --> 00:37:13,180
涼爽。

837
00:37:13,180 --> 00:37:15,013
所以，你實際使用
很多這些了。

838
00:37:15,013 --> 00:37:15,970

839
00:37:15,970 --> 00:37:18,840
獲取整型，字符串獲取，打印F。

840
00:37:18,840 --> 00:37:21,790
這些是所​​有功能
在那裡你只是給他們打電話，

841
00:37:21,790 --> 00:37:24,370
有很多神奇的事情
在後台正在進行

842
00:37:24,370 --> 00:37:27,390
你不一定看，
你得到了你想要的東西。

843
00:37:27,390 --> 00:37:30,280
或者至少你得到
你希望你想要的。

844
00:37:30,280 --> 00:37:31,920

845
00:37:31,920 --> 00:37:35,620
>> 和基本的功能點，
和CS的主題之一，

846
00:37:35,620 --> 00:37:38,700
就是要打破你的代碼
成可管理的片段。

847
00:37:38,700 --> 00:37:41,520
當你開始寫
這些很長的程序，

848
00:37:41,520 --> 00:37:44,970
或划痕，當你有
對於遊戲這個偉大的思想，

849
00:37:44,970 --> 00:37:48,070
您需要能夠打破它
下來一樣，OK，我怎麼開始？

850
00:37:48,070 --> 00:37:50,470
什麼是小件，我需要什麼？

851
00:37:50,470 --> 00:37:53,320
哦，我要問的
用戶的東西。

852
00:37:53,320 --> 00:37:54,830
現在我需要打印的東西。

853
00:37:54,830 --> 00:37:56,590
哦，我需要計算這個值。

854
00:37:56,590 --> 00:38:00,050
>> 並學習如何分手的
碼和大問題，你

855
00:38:00,050 --> 00:38:02,740
有進入這些小塊
和創建功能

856
00:38:02,740 --> 00:38:05,330
實際上是一個
CS大基石。

857
00:38:05,330 --> 00:38:06,440

858
00:38:06,440 --> 00:38:11,740
所以，你能想到的只是作為一個功能
就像一個黑盒子，一個神奇的黑盒子，

859
00:38:11,740 --> 00:38:15,030
你把東西放進
你會得到一些輸出。

860
00:38:15,030 --> 00:38:16,290

861
00:38:16,290 --> 00:38:19,460
和該程序的其餘部分
不需要一定知道

862
00:38:19,460 --> 00:38:21,150
這是怎麼回事內的黑盒子。

863
00:38:21,150 --> 00:38:24,190
它所關心的是什麼
進去和出來的東西。

864
00:38:24,190 --> 00:38:26,230

865
00:38:26,230 --> 00:38:26,730
涼爽。

866
00:38:26,730 --> 00:38:27,820
>> 那麼，為什麼功能呢？

867
00:38:27,820 --> 00:38:33,240
Organization--正如我所說，當你
處理非常大的代碼庫，

868
00:38:33,240 --> 00:38:37,357
你如何組織你的代碼會
如果您使用的功能要容易得多。

869
00:38:37,357 --> 00:38:39,190
因為你可以
要一樣，確定這一點，

870
00:38:39,190 --> 00:38:41,849
就是這個函數和
這裡是另外一個人做。

871
00:38:41,849 --> 00:38:43,890
而且你可以很容易地看到
它們是如何結合在一起的。

872
00:38:43,890 --> 00:38:45,590

873
00:38:45,590 --> 00:38:48,210
因此，將其分成各
這些可管理的子部分。

874
00:38:48,210 --> 00:38:51,860
>> 所以simplification--我敢肯定你們
都看到了這一點，正如我所說，有划痕。

875
00:38:51,860 --> 00:38:53,230

876
00:38:53,230 --> 00:38:56,790
你有這樣的宏偉構想，並
你喜歡，怎麼做這些工作？

877
00:38:56,790 --> 00:38:59,710
但是，如果你接近它
零零碎碎，你說好不好，

878
00:38:59,710 --> 00:39:03,650
我怎麼做一個精靈
漂浮在屏幕上？

879
00:39:03,650 --> 00:39:04,805
這是一個有點容易。

880
00:39:04,805 --> 00:39:06,000

881
00:39:06,000 --> 00:39:09,590
因此，良好的使用功能，使
你的代碼更易於閱讀。

882
00:39:09,590 --> 00:39:13,800
這使得它更容易調試，為
你進入你以後的習題集，

883
00:39:13,800 --> 00:39:15,900
你要真
希望能夠做到的。

884
00:39:15,900 --> 00:39:17,900
而且他們也更容易
設計和實施。

885
00:39:17,900 --> 00:39:21,100
您可以編寫了一個小
功能比較快

886
00:39:21,100 --> 00:39:25,260
並確保它的工作原理與嘗試
創造這整個漫長的程序

887
00:39:25,260 --> 00:39:28,960
然後種經歷和
看看有什麼工作，什麼不是。

888
00:39:28,960 --> 00:39:30,300
>> 然後可重用性。

889
00:39:30,300 --> 00:39:33,380
所以功能只需要
寫一次，

890
00:39:33,380 --> 00:39:35,586
然後，你可以使用它們
多次越好。

891
00:39:35,586 --> 00:39:37,210
所以它的一樣，生態友好的感覺。

892
00:39:37,210 --> 00:39:39,660

893
00:39:39,660 --> 00:39:42,070
如果你有喜​​歡的東西
打印f，其中您

894
00:39:42,070 --> 00:39:47,420
只好寫出來的那張魔法
背後印F中的任意一個時間

895
00:39:47,420 --> 00:39:51,040
你想打印的東西，你
將是非常厭倦了它

896
00:39:51,040 --> 00:39:51,650
由端。

897
00:39:51,650 --> 00:39:52,660

898
00:39:52,660 --> 00:39:55,292
>> 其中一件事，你會
學會在以後的CS類，

899
00:39:55,292 --> 00:39:57,000
還是其中的佼佼者
諮詢件我得到

900
00:39:57,000 --> 00:40:00,870
是，如果你是複製和粘貼
代碼，它應該是一個函數。

901
00:40:00,870 --> 00:40:01,880

902
00:40:01,880 --> 00:40:06,007
如果您有相同的
所有的線條貫穿你的代碼，

903
00:40:06,007 --> 00:40:08,090
如果你分解出來，
你的代碼可能會

904
00:40:08,090 --> 00:40:11,860
是一樣，5倍短
並且更加容易閱讀。

905
00:40:11,860 --> 00:40:15,230
而不是試圖解決
所有這些不同地方的東西

906
00:40:15,230 --> 00:40:18,021
可能會出問題，你有一個函數
您得到解決。

907
00:40:18,021 --> 00:40:19,230

908
00:40:19,230 --> 00:40:21,890
我保證，很多這種
似乎是一種抽象的現在，

909
00:40:21,890 --> 00:40:24,620
但是當你進入後
後來習題集，

910
00:40:24,620 --> 00:40:28,950
它會讓很多更有意義
而真正被趕回家。

911
00:40:28,950 --> 00:40:31,775
有沒有問題
有關功能如何呢？

912
00:40:31,775 --> 00:40:32,650
為什麼我們要使用它們？

913
00:40:32,650 --> 00:40:34,775
我知道我們還沒有得到
進入細節問題呢。

914
00:40:34,775 --> 00:40:40,610
所以定義就像function--
數組，我們需要of--這某種

915
00:40:40,610 --> 00:40:41,860
僅僅是個通用輸出。

916
00:40:41,860 --> 00:40:45,110
因此，這是一個函數，它是
只是要立方體一些輸入。

917
00:40:45,110 --> 00:40:50,120
而接下來的頁面上，實際上，我們有
所有這些真棒這裡的小東西。

918
00:40:50,120 --> 00:40:52,420
因此，每個人都可以讀
即，出於好奇？

919
00:40:52,420 --> 00:40:55,050
我知道紫色和黑色
可能會有點辛苦。

920
00:40:55,050 --> 00:41:00,730
>> 但大的事情知道 - 所以第一
1這裡是我們的返回類型。

921
00:41:00,730 --> 00:41:05,270
因此，這是講的輸出
這個功能的時候，在這種情況下，

922
00:41:05,270 --> 00:41:08,990
我們把一些數字，就是我們
得到的是立方數。

923
00:41:08,990 --> 00:41:11,090
所以，它應該是在這種情況下，一個int。

924
00:41:11,090 --> 00:41:14,055
也許這將是一張雙人床或
別的以後，但在這種情況下，

925
00:41:14,055 --> 00:41:14,555
這是一個int。

926
00:41:14,555 --> 00:41:15,620

927
00:41:15,620 --> 00:41:19,440
>> 用C，你總是需要一個返回類型。

928
00:41:19,440 --> 00:41:20,267
這將是一個int。

929
00:41:20,267 --> 00:41:20,975
這將是一個浮動。

930
00:41:20,975 --> 00:41:22,180
這將是一個雙。

931
00:41:22,180 --> 00:41:25,370
但你必須指定哪些
這個函數會返回。

932
00:41:25,370 --> 00:41:26,480

933
00:41:26,480 --> 00:41:29,170
否則會罵
你，它不會編譯。

934
00:41:29,170 --> 00:41:30,462
你會難過，我會很傷心的。

935
00:41:30,462 --> 00:41:31,420
它只是不好。

936
00:41:31,420 --> 00:41:31,940
行。

937
00:41:31,940 --> 00:41:34,290
>> 然後，我們有我們的函數名。

938
00:41:34,290 --> 00:41:38,440
正如你可以在這裡看到，用c
有這非常符合範式。

939
00:41:38,440 --> 00:41:42,630
什麼是你喜歡的類型，叫什麼名字，
然後在年底一些其他的東西。

940
00:41:42,630 --> 00:41:45,550
因此，我們有我們的返回類型，
我們的函數名，然後

941
00:41:45,550 --> 00:41:49,320
我們有我們的頭與
我們的參數列表。

942
00:41:49,320 --> 00:41:52,080
>> 因此，參數列表，什麼是
此功能會採取？

943
00:41:52,080 --> 00:41:56,360
參數列表是一個簡單的
代名詞，什麼是我們的投入？

944
00:41:56,360 --> 00:42:00,230
並以同樣的方式，我們
必須確定我們的函數

945
00:42:00,230 --> 00:42:03,210
並給它一回
類型，我們每一個輸入

946
00:42:03,210 --> 00:42:05,350
需要有與它相關聯的類型。

947
00:42:05,350 --> 00:42:08,850
因此，我們知道我們的功能
其實可以一起工作。

948
00:42:08,850 --> 00:42:11,290
>> 所以在這種情況下，我們有一些整數的輸入。

949
00:42:11,290 --> 00:42:14,660
如此反复，這將是該型
和你要調用它。

950
00:42:14,660 --> 00:42:16,500

951
00:42:16,500 --> 00:42:19,040
然後，當你看到
在這裡，我們有我們的身體。

952
00:42:19,040 --> 00:42:23,600
因此，我們有一些INT輸出，即
只是我們投入時間本身

953
00:42:23,600 --> 00:42:25,810
時間本身，它只是立方體它。

954
00:42:25,810 --> 00:42:27,610
然後我們返回輸出。

955
00:42:27,610 --> 00:42:32,140
>> 所以，當你看到這裡，我們有一個
詮釋時代一個int次一個int，

956
00:42:32,140 --> 00:42:35,420
所以它返回一個int，這
已申報存在。

957
00:42:35,420 --> 00:42:38,240
所以，一切都凝聚力。

958
00:42:38,240 --> 00:42:39,210
一切的快樂。

959
00:42:39,210 --> 00:42:40,250
你的函數將運行。

960
00:42:40,250 --> 00:42:41,192

961
00:42:41,192 --> 00:42:42,650
而這僅僅是普通的事情。

962
00:42:42,650 --> 00:42:46,750
所以，總有返回類型，
的名字，你的參數列表。

963
00:42:46,750 --> 00:42:48,830
在每一件事情你
參數列表，或輸入，

964
00:42:48,830 --> 00:42:51,410
需要有與它相關聯的類型。

965
00:42:51,410 --> 00:42:54,210
然後你有你的
機身這裡什麼

966
00:42:54,210 --> 00:42:55,590
你想與你的輸入。

967
00:42:55,590 --> 00:42:57,390

968
00:42:57,390 --> 00:43:00,410
>> 然後顯然你
想回到什麼。

969
00:43:00,410 --> 00:43:02,630
有時候功能將只返回。

970
00:43:02,630 --> 00:43:06,090
它們實際上並不返回
東西供你使用。

971
00:43:06,090 --> 00:43:08,660
但你必須以某種方式返回。

972
00:43:08,660 --> 00:43:12,900
當你正在做
自己的函數，

973
00:43:12,900 --> 00:43:15,430
我們可以進入一個更深一點。

974
00:43:15,430 --> 00:43:18,880
就個人而言，如果你願意，也有很多
不同的東西，你可以在那裡做。

975
00:43:18,880 --> 00:43:21,350

976
00:43:21,350 --> 00:43:22,140
大家好？

977
00:43:22,140 --> 00:43:25,900
什麼這個列表，你要我上
走了過來，說你不明白？

978
00:43:25,900 --> 00:43:27,204

979
00:43:27,204 --> 00:43:28,120
每個人都很好嗎？

980
00:43:28,120 --> 00:43:29,071

981
00:43:29,071 --> 00:43:29,570
涼爽。

982
00:43:29,570 --> 00:43:31,350

983
00:43:31,350 --> 00:43:32,120
真棒。

984
00:43:32,120 --> 00:43:34,700
>> 好了，我們正在把
現在這一切都在一起。

985
00:43:34,700 --> 00:43:35,720

986
00:43:35,720 --> 00:43:41,201
因此，我們有一些整型立方體輸入，因此
這是這裡一個完整的程序。

987
00:43:41,201 --> 00:43:42,950
到現在為止，我已經
種了給你

988
00:43:42,950 --> 00:43:45,699
球員片段，可能
在程序中去。

989
00:43:45,699 --> 00:43:47,240
我們剛剛一直在尋找的功能。

990
00:43:47,240 --> 00:43:48,448
但這裡有一個完整的計劃。

991
00:43:48,448 --> 00:43:49,400

992
00:43:49,400 --> 00:43:53,690
所以，你們有多少人還記得
從演講詞的原型？

993
00:43:53,690 --> 00:43:54,750

994
00:43:54,750 --> 00:43:55,300
涼爽。

995
00:43:55,300 --> 00:43:55,890
我們已經得到了一個。

996
00:43:55,890 --> 00:43:57,160

997
00:43:57,160 --> 00:43:58,110
你叫什麼名字？

998
00:43:58,110 --> 00:43:58,850
>> 斯蒂芬：斯蒂芬。

999
00:43:58,850 --> 00:43:59,475
>> 艾里遜：斯蒂芬？

1000
00:43:59,475 --> 00:44:01,030
OK，真棒。

1001
00:44:01,030 --> 00:44:03,310
所以，你還記得什麼是原型？

1002
00:44:03,310 --> 00:44:04,651

1003
00:44:04,651 --> 00:44:10,230
>> 學生：你說[聽不清]
在你真正對付它。

1004
00:44:10,230 --> 00:44:11,700
>> 艾里遜：你還記得，為什麼？

1005
00:44:11,700 --> 00:44:13,158
>> 學生：沒有。

1006
00:44:13,158 --> 00:44:14,620
>> 艾里遜：OK。

1007
00:44:14,620 --> 00:44:16,090
金名將。

1008
00:44:16,090 --> 00:44:19,470
所以，是的，一個原型，我們有
事先，因為否則

1009
00:44:19,470 --> 00:44:21,260
我們的編譯器是要罵我們。

1010
00:44:21,260 --> 00:44:24,294
它會說，OK，
這是什麼魔方功能？

1011
00:44:24,294 --> 00:44:26,460
就像，你從字面上有
告訴我沒有談到這個。

1012
00:44:26,460 --> 00:44:28,110
這就像當你
走進教室，

1013
00:44:28,110 --> 00:44:29,320
有人的樣子，
今天有一個小測驗。

1014
00:44:29,320 --> 00:44:31,380
和你一樣，你
從來沒有告訴過我這件事。

1015
00:44:31,380 --> 00:44:32,930
我不開心與我們聯繫。

1016
00:44:32,930 --> 00:44:34,300

1017
00:44:34,300 --> 00:44:37,020
原型基本上像
您的大綱說，看。

1018
00:44:37,020 --> 00:44:37,900
當心。

1019
00:44:37,900 --> 00:44:39,570
還有的將是在這一天進行測驗。

1020
00:44:39,570 --> 00:44:41,420
不要驚慌，當你得到它。

1021
00:44:41,420 --> 00:44:42,690
你會好起來的。

1022
00:44:42,690 --> 00:44:48,170
>> 因此，所有的原型確實是告訴
主，我要使用此功能。

1023
00:44:48,170 --> 00:44:51,010
我發誓我以後定義它。

1024
00:44:51,010 --> 00:44:52,260
不要嚇壞了我。

1025
00:44:52,260 --> 00:44:54,750
只是編譯和做什麼，我告訴你。

1026
00:44:54,750 --> 00:44:58,880
因此，我們有原型存在
只是為了讓我們的編譯器高興。

1027
00:44:58,880 --> 00:45:04,360
它基本上是一個承諾
你定義了這個功能以後

1028
00:45:04,360 --> 00:45:07,960
那你是不是剛剛打電話
這種隨意的事情，它

1029
00:45:07,960 --> 00:45:10,070
不知道你在做什麼
將要幹什麼。

1030
00:45:10,070 --> 00:45:11,910
>> 所以在這種情況下，我們有主這裡。

1031
00:45:11,910 --> 00:45:14,660
我們初始化一些整數x。

1032
00:45:14,660 --> 00:45:15,620
這是兩人。

1033
00:45:15,620 --> 00:45:17,510
我們要打印出x的值。

1034
00:45:17,510 --> 00:45:18,800
我們將立方體X。

1035
00:45:18,800 --> 00:45:21,520
正如你看到的，我們有我們的
函數聲明

1036
00:45:21,520 --> 00:45:23,770
到這裡，我們
談到以前。

1037
00:45:23,770 --> 00:45:28,260
這將立方體x，然後，如果我們
請記住，立方體函數實際上

1038
00:45:28,260 --> 00:45:31,340
返回一個整數
我們，它存儲

1039
00:45:31,340 --> 00:45:35,860
在X再一次讓我們可以打印
出8，或者現在立方體X。

1040
00:45:35,860 --> 00:45:37,170

1041
00:45:37,170 --> 00:45:38,920
這是否有意義大家？

1042
00:45:38,920 --> 00:45:40,360
我們是好？

1043
00:45:40,360 --> 00:45:41,160
行。

1044
00:45:41,160 --> 00:45:41,660
真棒。

1045
00:45:41,660 --> 00:45:45,540

1046
00:45:45,540 --> 00:45:46,840
>> 行。

1047
00:45:46,840 --> 00:45:50,879
有多少你們的
記住這所以這

1048
00:45:50,879 --> 00:45:52,670
基本上是你
棧和堆的，

1049
00:45:52,670 --> 00:45:56,510
只是一個可視化
記憶是如何存儲在這裡。

1050
00:45:56,510 --> 00:45:58,200

1051
00:45:58,200 --> 00:46:01,400
所以，我們只是想使
確保您了解

1052
00:46:01,400 --> 00:46:03,680
如何將這些表示在內存中。

1053
00:46:03,680 --> 00:46:07,670
如果你喜歡的類
CS61之類的東西後，

1054
00:46:07,670 --> 00:46:10,570
你了解這更
在深度，它真的很酷。

1055
00:46:10,570 --> 00:46:11,730
我強烈推薦它。

1056
00:46:11,730 --> 00:46:12,740

1057
00:46:12,740 --> 00:46:14,720
但現在，我給
你的全面概述

1058
00:46:14,720 --> 00:46:16,950
所以你不必
知道的細節問題。

1059
00:46:16,950 --> 00:46:20,820
>> 所以頂端只是一個文本段哪
包含了實際的零和一，

1060
00:46:20,820 --> 00:46:23,740
二進制為。

1061
00:46:23,740 --> 00:46:27,510
這被用於存儲
全局變量，如果您有任何。

1062
00:46:27,510 --> 00:46:28,870

1063
00:46:28,870 --> 00:46:32,240
當你向下移動，我們
有，因為你在這裡看到，

1064
00:46:32,240 --> 00:46:34,670
初始化數據，未初始化
數據，然後堆。

1065
00:46:34,670 --> 00:46:35,800

1066
00:46:35,800 --> 00:46:38,584
>> 所以，我們真的不說話
關於堆現在。

1067
00:46:38,584 --> 00:46:39,500
我們會得到它以後。

1068
00:46:39,500 --> 00:46:40,762

1069
00:46:40,762 --> 00:46:42,970
現在，我只是要
波我的手，像，

1070
00:46:42,970 --> 00:46:44,553
你不需要知道這個了。

1071
00:46:44,553 --> 00:46:46,100

1072
00:46:46,100 --> 00:46:49,060
但是，我們會聊一點
關於堆棧位。

1073
00:46:49,060 --> 00:46:53,050
所以堆棧where--我們有放大研究。

1074
00:46:53,050 --> 00:46:58,590
這實際上是如何計劃
我們只是看著發生在內存中。

1075
00:46:58,590 --> 00:47:01,630
>> 那麼，什麼情況是，每
一次，我們調用一個函數，

1076
00:47:01,630 --> 00:47:04,180
我們得到了什麼叫做棧
幀，這是其中之一。

1077
00:47:04,180 --> 00:47:05,870
因此，主要的參數。

1078
00:47:05,870 --> 00:47:07,944
因此，這些都是事
我們通過進入主。

1079
00:47:07,944 --> 00:47:11,110
於是，他們就在這裡的底部，
因為這是我們所說的第一句話。

1080
00:47:11,110 --> 00:47:13,401
然後，我們去主要的
當地人說，當我們說，

1081
00:47:13,401 --> 00:47:15,970
我們指的是局部變量
存儲在主。

1082
00:47:15,970 --> 00:47:19,950

1083
00:47:19,950 --> 00:47:23,620
因此，當地人在這裡會一樣，
x是在這種情況下等於2。

1084
00:47:23,620 --> 00:47:26,350
因為這是定位於主力。

1085
00:47:26,350 --> 00:47:29,745
大家是否還記得範圍，
去了，在演講？

1086
00:47:29,745 --> 00:47:31,517

1087
00:47:31,517 --> 00:47:32,017
行。

1088
00:47:32,017 --> 00:47:36,110
所以，僅僅是變量
在主要的初始化。

1089
00:47:36,110 --> 00:47:38,550
所以這就是為什麼我們有主要的[？主唱。 ？]

1090
00:47:38,550 --> 00:47:40,390
>> 然後在主，我們稱之為立方體。

1091
00:47:40,390 --> 00:47:41,000
對不對？

1092
00:47:41,000 --> 00:47:44,510
因此，我們得到另一個框架
與多維數據集的參數。

1093
00:47:44,510 --> 00:47:47,050
所以在這種情況下，立方體的
參數是現在

1094
00:47:47,050 --> 00:47:50,800
我們通過在x，
我們通過兩個。

1095
00:47:50,800 --> 00:47:55,320
然後立方體的當地人，這是
在實際體積測量發生。

1096
00:47:55,320 --> 00:47:56,450
然後返回。

1097
00:47:56,450 --> 00:48:02,120
>> 那麼，什麼情況是如立方體實際上做
什麼是應該做的，它返回。

1098
00:48:02,120 --> 00:48:07,020
當它返回時，這架離開，
其倒回主。

1099
00:48:07,020 --> 00:48:09,160
然後在主，我們
實際上可以打印出來。

1100
00:48:09,160 --> 00:48:10,840

1101
00:48:10,840 --> 00:48:14,500
因此，當你回來的東西，
當你的函數返回，

1102
00:48:14,500 --> 00:48:19,900
它就像傳遞這些值
它下面的框，然後離開。

1103
00:48:19,900 --> 00:48:22,200
和事物有才能執行。

1104
00:48:22,200 --> 00:48:25,550
>> 而當你得到更大的計劃，
我們可以做出更酷，更複雜

1105
00:48:25,550 --> 00:48:26,470
圖。

1106
00:48:26,470 --> 00:48:29,070
但現在，這是
只是一般概述

1107
00:48:29,070 --> 00:48:31,110
所以你有怎樣的
了解什麼

1108
00:48:31,110 --> 00:48:35,160
當你調用一個函數發生
以及如何實際看起來在內存中。

1109
00:48:35,160 --> 00:48:37,230

1110
00:48:37,230 --> 00:48:37,770
很酷吧？

1111
00:48:37,770 --> 00:48:38,353
大家好？

1112
00:48:38,353 --> 00:48:39,920

1113
00:48:39,920 --> 00:48:40,420
真棒。

1114
00:48:40,420 --> 00:48:42,070

1115
00:48:42,070 --> 00:48:50,575
>> 所以這是一個是
只是想交換的東西。

1116
00:48:50,575 --> 00:48:52,260

1117
00:48:52,260 --> 00:48:54,930
我們在這裡看到，我們有
我們的函數原型

1118
00:48:54,930 --> 00:48:56,900
讓我們的編譯器不罵我們。

1119
00:48:56,900 --> 00:48:59,220
我們有一些主要的，而我們
要切換的x和y。

1120
00:48:59,220 --> 00:49:00,320

1121
00:49:00,320 --> 00:49:04,129
他們沒有這樣做演示
在演講的是，有嗎？

1122
00:49:04,129 --> 00:49:04,670
他們有沒有關係？

1123
00:49:04,670 --> 00:49:05,900
行。

1124
00:49:05,900 --> 00:49:08,450
因此，我們打算去
在這個很簡單。

1125
00:49:08,450 --> 00:49:12,210
你會惹上這個例子更多
深入，我認為，這個星期。

1126
00:49:12,210 --> 00:49:15,680
再接下來的一周，我們才能真正
潛入為什麼這是行不通的。

1127
00:49:15,680 --> 00:49:18,810
>> 因此，我們有這個空間
功能這裡 - 調劑。

1128
00:49:18,810 --> 00:49:20,720
所以虛空只是意味著
不返回任何值。

1129
00:49:20,720 --> 00:49:22,000

1130
00:49:22,000 --> 00:49:24,110
我們有交換INT A和INT B。

1131
00:49:24,110 --> 00:49:27,046
我們有一些暫時的
可變的，這是一個。

1132
00:49:27,046 --> 00:49:30,050
一個被分配給B，然後
B被分配到temp

1133
00:49:30,050 --> 00:49:32,235
使a和b的
現在值被切換。

1134
00:49:32,235 --> 00:49:33,510

1135
00:49:33,510 --> 00:49:36,030
>> 但是，劇情轉折，這是行不通的。

1136
00:49:36,030 --> 00:49:37,390

1137
00:49:37,390 --> 00:49:42,380
而它的一部分實際上有
做的一個事實，即

1138
00:49:42,380 --> 00:49:48,800
而B在這裡，那獲得通過的那些
這裡，實際上是x和y的副本。

1139
00:49:48,800 --> 00:49:53,220
因此，當該函數實際上返回，
它切換的副本，但不

1140
00:49:53,220 --> 00:49:55,960
實際的x和y的。

1141
00:49:55,960 --> 00:50:02,370
因此從另一個角度去想它是
that--假裝這些都是掉。

1142
00:50:02,370 --> 00:50:03,130
行？

1143
00:50:03,130 --> 00:50:05,390
所以在主，我們有x和y初始化。

1144
00:50:05,390 --> 00:50:06,530

1145
00:50:06,530 --> 00:50:10,760
但是，當我們真正去了
與交換這些幀

1146
00:50:10,760 --> 00:50:15,740
我們在傳遞的值
它，他們正在初始化。

1147
00:50:15,740 --> 00:50:18,570
>> 他們永遠只能住在這裡。

1148
00:50:18,570 --> 00:50:19,796
因此，A和B住在這裡。

1149
00:50:19,796 --> 00:50:20,670
他們被換。

1150
00:50:20,670 --> 00:50:21,870

1151
00:50:21,870 --> 00:50:26,190
但是，當我們返回時，我們不
做與a和b什麼。一

1152
00:50:26,190 --> 00:50:28,980
和b離開我們的功能。

1153
00:50:28,980 --> 00:50:30,850
所以x和y保持不變。

1154
00:50:30,850 --> 00:50:31,960

1155
00:50:31,960 --> 00:50:39,665
你會得到更多的進入如何解決和
我們如何真正與處理後。

1156
00:50:39,665 --> 00:50:40,750

1157
00:50:40,750 --> 00:50:43,740
>> 但它只是一件事
以種牢記。

1158
00:50:43,740 --> 00:50:45,270
使用它的未來。

1159
00:50:45,270 --> 00:50:48,050
如果沒有做別擔心
所有的意義世界。

1160
00:50:48,050 --> 00:50:49,510

1161
00:50:49,510 --> 00:50:51,440
他們是拷貝是最重要的事情。

1162
00:50:51,440 --> 00:50:54,580
如果你要帶什麼
離，你傳入副本。

1163
00:50:54,580 --> 00:50:56,410
所以原稿保持不變。

1164
00:50:56,410 --> 00:50:58,170

1165
00:50:58,170 --> 00:50:58,770
大家好？

1166
00:50:58,770 --> 00:51:00,280

1167
00:51:00,280 --> 00:51:00,930
涼爽。

1168
00:51:00,930 --> 00:51:02,295
>> 因此，命令行參數。

1169
00:51:02,295 --> 00:51:03,520

1170
00:51:03,520 --> 00:51:07,630
我敢肯定，在開始的時候你們都
有那些偉大一樣，INT主要空隙。

1171
00:51:07,630 --> 00:51:09,517
和你一樣，好涼爽。

1172
00:51:09,517 --> 00:51:10,350
我真的不關心。

1173
00:51:10,350 --> 00:51:12,360
這正是我寫的。

1174
00:51:12,360 --> 00:51:16,349
但是，在你的新計劃，
特別是在這個pset中，

1175
00:51:16,349 --> 00:51:17,890
為什麼有粉筆在地上？

1176
00:51:17,890 --> 00:51:19,640

1177
00:51:19,640 --> 00:51:22,680
>> 隨著你的下一個PSET，你
將要看到這一點。

1178
00:51:22,680 --> 00:51:26,130
INT為主，詮釋ARG C，
弦弧V，支架。

1179
00:51:26,130 --> 00:51:28,770
所以，從我們剛才
今天學什麼

1180
00:51:28,770 --> 00:51:32,190
我們認為，第二個參數
或者說第二個元素是在這裡？

1181
00:51:32,190 --> 00:51:34,830

1182
00:51:34,830 --> 00:51:35,824
這是一個數組。

1183
00:51:35,824 --> 00:51:36,615
什麼類型的數組？

1184
00:51:36,615 --> 00:51:38,430

1185
00:51:38,430 --> 00:51:40,690
String數組，是的。

1186
00:51:40,690 --> 00:51:41,980
涼爽。

1187
00:51:41,980 --> 00:51:45,320
這就是你如何去
現在要宣布這些。

1188
00:51:45,320 --> 00:51:48,570
>> 有誰還記得
這些東西代表什麼？

1189
00:51:48,570 --> 00:51:52,551

1190
00:51:52,551 --> 00:51:53,050
不是嗎？

1191
00:51:53,050 --> 00:51:54,020

1192
00:51:54,020 --> 00:51:54,520
嗯？

1193
00:51:54,520 --> 00:51:55,640
>> 學生：ARG溫度。

1194
00:51:55,640 --> 00:51:56,961

1195
00:51:56,961 --> 00:51:58,950
>> 艾里遜：那麼ARGç保持一個計數器。

1196
00:51:58,950 --> 00:51:59,450
這是一個int。

1197
00:51:59,450 --> 00:52:00,615
這是一個數字，對不對？

1198
00:52:00,615 --> 00:52:02,240
那麼，你認為這個數字呢？

1199
00:52:02,240 --> 00:52:08,260

1200
00:52:08,260 --> 00:52:08,760
是啊。

1201
00:52:08,760 --> 00:52:11,450
所以，ARG c是弦數
構成該命令行。

1202
00:52:11,450 --> 00:52:12,560

1203
00:52:12,560 --> 00:52:18,499
所以，如果我們要真正do--，
有例子在此之後，

1204
00:52:18,499 --> 00:52:19,790
所以我不會提前拿到自己。

1205
00:52:19,790 --> 00:52:21,299

1206
00:52:21,299 --> 00:52:23,840
這是一個數字的字符串是
只是讓你的命令行。

1207
00:52:23,840 --> 00:52:35,080
>> 所以，當你做一樣，點斜線馬里奧，
這是一根弦，使得它了。

1208
00:52:35,080 --> 00:52:38,520
在這一塊，你實際上是
餵東西進入命令行，

1209
00:52:38,520 --> 00:52:41,750
我敢肯定，你們誰
看過規格鋸。

1210
00:52:41,750 --> 00:52:44,470
因此，在這種情況下，也許你會
有兩個或三個參數。

1211
00:52:44,470 --> 00:52:45,652

1212
00:52:45,652 --> 00:52:48,360
這將是一個有用的東西來使用。

1213
00:52:48,360 --> 00:52:51,500
>> 然後ARG V，正如我們所說，
只是一個字符串數組。

1214
00:52:51,500 --> 00:52:57,000
使實際存儲是什麼
您輸入到命令行。

1215
00:52:57,000 --> 00:52:59,960
因此，我們有這些。

1216
00:52:59,960 --> 00:53:02,850
你有一些點斜杠
複製INFILE OUTFILE。

1217
00:53:02,850 --> 00:53:06,670
所以，如果精氨酸c是字符串數
我們正在傳遞到命令

1218
00:53:06,670 --> 00:53:09,080
行，有什麼是我們ARG c。在這種情況下？

1219
00:53:09,080 --> 00:53:14,520

1220
00:53:14,520 --> 00:53:15,850
三。

1221
00:53:15,850 --> 00:53:16,690
沒錯。

1222
00:53:16,690 --> 00:53:20,086
>> 那麼什麼是零ARG V？

1223
00:53:20,086 --> 00:53:21,710
那麼，什麼是我們所存儲的第一件事？

1224
00:53:21,710 --> 00:53:24,640

1225
00:53:24,640 --> 00:53:26,290
點斜線副本，沒錯。

1226
00:53:26,290 --> 00:53:28,065
然後第二個是INFILE。

1227
00:53:28,065 --> 00:53:29,290

1228
00:53:29,290 --> 00:53:30,930
第三個是OUTFILE。

1229
00:53:30,930 --> 00:53:32,390
那麼，關於精氨酸V 3？

1230
00:53:32,390 --> 00:53:35,810

1231
00:53:35,810 --> 00:53:39,370
這將是空的，因為這是
我們的數組的結尾，對不對？

1232
00:53:39,370 --> 00:53:40,600

1233
00:53:40,600 --> 00:53:41,460
涼爽。

1234
00:53:41,460 --> 00:53:44,500
>> 然後怎麼樣第六個？

1235
00:53:44,500 --> 00:53:45,900
這是種一個有趣的問題。

1236
00:53:45,900 --> 00:53:46,400
伊什。

1237
00:53:46,400 --> 00:53:49,027

1238
00:53:49,027 --> 00:53:49,943
我們知道它是什麼？

1239
00:53:49,943 --> 00:53:50,960

1240
00:53:50,960 --> 00:53:51,690
這是不確定的。

1241
00:53:51,690 --> 00:53:53,170
我們不知道，可能是。

1242
00:53:53,170 --> 00:53:57,000
這是什麼是正確的
在存儲器陣列後，

1243
00:53:57,000 --> 00:54:00,220
我們不知道那是什麼。

1244
00:54:00,220 --> 00:54:03,500
和它的危險去觸摸那些
的事情，因為你知道，

1245
00:54:03,500 --> 00:54:07,080
它是內存的一部分，你
不應該訪問或空。

1246
00:54:07,080 --> 00:54:09,000
它可以做瘋狂的事情。

1247
00:54:09,000 --> 00:54:11,690
這就是所謂的過度索引
您綁定到您的陣列。

1248
00:54:11,690 --> 00:54:14,785
不要去的邊​​界之外的
數組，或者壞的事情都可能發生。

1249
00:54:14,785 --> 00:54:16,274

1250
00:54:16,274 --> 00:54:18,940
你回來一樣，法律
物理學已被銷毀

1251
00:54:18,940 --> 00:54:19,481
什麼的。

1252
00:54:19,481 --> 00:54:21,021

1253
00:54:21,021 --> 00:54:21,520
涼爽。

1254
00:54:21,520 --> 00:54:22,895
這是否有意義大家？

1255
00:54:22,895 --> 00:54:23,810

1256
00:54:23,810 --> 00:54:25,025
差不太多。

1257
00:54:25,025 --> 00:54:28,926
>> 所以，現在，大家的
最喜歡的部分，PSET審查。

1258
00:54:28,926 --> 00:54:29,426
耶！

1259
00:54:29,426 --> 00:54:30,530

1260
00:54:30,530 --> 00:54:31,030
行。

1261
00:54:31,030 --> 00:54:33,830
因此，對於那些你們誰
沒有看過的pset規範，

1262
00:54:33,830 --> 00:54:36,790
你正在做一些真正
涼的東西與密碼。

1263
00:54:36,790 --> 00:54:39,360
你要創建一個凱撒
密碼和V @ genere加密。

1264
00:54:39,360 --> 00:54:42,000

1265
00:54:42,000 --> 00:54:45,480
你一定要讀
SPEC怎麼看這些作品。

1266
00:54:45,480 --> 00:54:49,650
如果你有任何麻煩
它實際上應該做的，

1267
00:54:49,650 --> 00:54:52,920
請你跟我說話，
給我發電子郵件或短信我。

1268
00:54:52,920 --> 00:54:53,420
我在周圍。

1269
00:54:53,420 --> 00:54:54,780

1270
00:54:54,780 --> 00:54:57,070
>> 因此，主要有三個
這裡的東西，我們

1271
00:54:57,070 --> 00:55:00,440
要談about--正中下懷
的演講的延伸。

1272
00:55:00,440 --> 00:55:03,645
東西，你可能不知道
約，有用的提示和工具。

1273
00:55:03,645 --> 00:55:05,520
所以，我們要做一個
快速審查ASCII的，

1274
00:55:05,520 --> 00:55:10,420
因為這將是超
重要的V @ genere的密碼。

1275
00:55:10,420 --> 00:55:11,809

1276
00:55:11,809 --> 00:55:14,100
我們要轉換
命令行輸入，

1277
00:55:14,100 --> 00:55:17,160
將是愷撒密碼非常有幫助。

1278
00:55:17,160 --> 00:55:18,133
然後取模。

1279
00:55:18,133 --> 00:55:20,220

1280
00:55:20,220 --> 00:55:21,210
涼爽。

1281
00:55:21,210 --> 00:55:24,005
>> 因此，ASCII字符映射到數字。

1282
00:55:24,005 --> 00:55:25,270

1283
00:55:25,270 --> 00:55:26,365
這是一個偉大的圖表。

1284
00:55:26,365 --> 00:55:28,115
你應該有這
地方添加書籤。

1285
00:55:28,115 --> 00:55:29,310

1286
00:55:29,310 --> 00:55:33,250
你會想它
你的第一個中期。

1287
00:55:33,250 --> 00:55:36,320
我敢肯定每個人都有這種
圖表上的中期板。

1288
00:55:36,320 --> 00:55:37,810
所以，學習它。

1289
00:55:37,810 --> 00:55:38,410
愛它。

1290
00:55:38,410 --> 00:55:39,740
備在手邊。

1291
00:55:39,740 --> 00:55:41,210
這將是有益的。

1292
00:55:41,210 --> 00:55:45,630
>> 和所有它是是一種編碼
映射字母，數字，

1293
00:55:45,630 --> 00:55:47,740
和其他字符
數字對我們的電腦。

1294
00:55:47,740 --> 00:55:49,947
因為，當然，在
最後，我們的一切存儲

1295
00:55:49,947 --> 00:55:52,030
是會得到轉換
下降到零和一，

1296
00:55:52,030 --> 00:55:55,200
所以我們需要一些方法來表示
文本和字符，我們都是

1297
00:55:55,200 --> 00:55:59,105
看慣了的某種數量。

1298
00:55:59,105 --> 00:56:00,370

1299
00:56:00,370 --> 00:56:05,880
>> 所以，我們在這裡看到，我們有
大寫字母A，這是在那裡。

1300
00:56:05,880 --> 00:56:06,555
這是65歲。

1301
00:56:06,555 --> 00:56:07,570

1302
00:56:07,570 --> 00:56:09,660
和小寫字母A是97。

1303
00:56:09,660 --> 00:56:13,170
所以，你自己看著辦out--
正如我剛才所說，

1304
00:56:13,170 --> 00:56:16,532
如果你有多個陣列
字符串，他們每個人

1305
00:56:16,532 --> 00:56:17,490
有一個空終止。

1306
00:56:17,490 --> 00:56:18,480
這將是一個空間。

1307
00:56:18,480 --> 00:56:22,581
空間有自己special--
我忘記了它是在這裡。

1308
00:56:22,581 --> 00:56:23,080
啊。

1309
00:56:23,080 --> 00:56:24,700
圖32是空間。

1310
00:56:24,700 --> 00:56:27,090
所以一切都映射到它。

1311
00:56:27,090 --> 00:56:28,680

1312
00:56:28,680 --> 00:56:29,740
>> 因此，我們有ASCII數學。

1313
00:56:29,740 --> 00:56:31,080

1314
00:56:31,080 --> 00:56:34,290
臨tip--中的V @ genere的，
你可能受到誘惑

1315
00:56:34,290 --> 00:56:39,480
您的數字轉換成整數，
但它實際上是更好的做法

1316
00:56:39,480 --> 00:56:43,860
能夠使用
這樣的人物

1317
00:56:43,860 --> 00:56:45,820
當你真正操縱他們。

1318
00:56:45,820 --> 00:56:48,950
所以，如果你想使用的數字，就可以了。

1319
00:56:48,950 --> 00:56:55,260
但更好的方法，或者一種方式，
我們往往喜歡你們這樣做，

1320
00:56:55,260 --> 00:56:57,830
就是這樣，你是
實際上減去字符。

1321
00:56:57,830 --> 00:56:58,840

1322
00:56:58,840 --> 00:57:02,830
>> 所以我想，你們來
種計算這些的。

1323
00:57:02,830 --> 00:57:05,070
你為什麼不嘗試每隔一個？

1324
00:57:05,070 --> 00:57:07,580

1325
00:57:07,580 --> 00:57:09,830
所以做第一個，
第三個和第五個1。

1326
00:57:09,830 --> 00:57:11,160

1327
00:57:11,160 --> 00:57:15,000
因為我想確保我們討論
一切，我們需要談談。

1328
00:57:15,000 --> 00:57:17,410

1329
00:57:17,410 --> 00:57:20,259
我只是想說，之一
重要的事情to--哦，等等，

1330
00:57:20,259 --> 00:57:21,550
你們還沒有看到這一點。

1331
00:57:21,550 --> 00:57:23,710
確定這樣做前三。

1332
00:57:23,710 --> 00:57:24,430
讓我們做到這一點。

1333
00:57:24,430 --> 00:57:25,971
因為我們要談的模。

1334
00:57:25,971 --> 00:57:27,810

1335
00:57:27,810 --> 00:57:28,310
我知道。

1336
00:57:28,310 --> 00:57:28,851
數學是很難的。

1337
00:57:28,851 --> 00:57:29,870

1338
00:57:29,870 --> 00:57:30,980
您可以使用計算器。

1339
00:57:30,980 --> 00:57:31,580
沒關係。

1340
00:57:31,580 --> 00:57:37,464

1341
00:57:37,464 --> 00:57:40,380
或拉了一個ASCII表，因為
你可能會想的。

1342
00:57:40,380 --> 00:58:03,660

1343
00:58:03,660 --> 00:58:04,820
>> 涼爽。

1344
00:58:04,820 --> 00:58:07,960
所以，我會很快走
您完成這些傢伙。

1345
00:58:07,960 --> 00:58:11,120
因此，人們ASCII表拉升？

1346
00:58:11,120 --> 00:58:15,645
什麼是我們的數字
數小寫？

1347
00:58:15,645 --> 00:58:16,270
學生：七。

1348
00:58:16,270 --> 00:58:19,420

1349
00:58:19,420 --> 00:58:24,550
>> 艾里遜：那麼小寫字母A是
97和大寫字母A是65。

1350
00:58:24,550 --> 00:58:26,390
所以97減65？

1351
00:58:26,390 --> 00:58:27,782

1352
00:58:27,782 --> 00:58:28,570
>> 聽眾：32？

1353
00:58:28,570 --> 00:58:33,260

1354
00:58:33,260 --> 00:58:35,630
>> ALLISON：62，是的。

1355
00:58:35,630 --> 00:58:38,675
所以在這種情況下，什麼
將它打印出來？

1356
00:58:38,675 --> 00:58:40,360
這第一次？

1357
00:58:40,360 --> 00:58:43,830
如果我們有百分之D，
那能說明什麼？

1358
00:58:43,830 --> 00:58:45,980

1359
00:58:45,980 --> 00:58:46,730
學生：一個數字。

1360
00:58:46,730 --> 00:58:48,604
艾里遜：我們正在打印
出的實數。

1361
00:58:48,604 --> 00:58:50,770
所以，我們實際上會
在這裡打印出32。

1362
00:58:50,770 --> 00:58:56,360
如果這是百分之C，
32會給我們一個空間。

1363
00:58:56,360 --> 00:58:57,700

1364
00:58:57,700 --> 00:59:01,670
這麼理解的
字符可以被打印

1365
00:59:01,670 --> 00:59:06,140
這兩個數字和為
實際字符

1366
00:59:06,140 --> 00:59:11,080
是非常重要的，和支付
注意實際的類型

1367
00:59:11,080 --> 00:59:12,040
我們在這裡所做的。

1368
00:59:12,040 --> 00:59:14,520

1369
00:59:14,520 --> 00:59:15,020
涼爽。

1370
00:59:15,020 --> 00:59:18,862
所以對於這些每隔1，
什麼是我們將要打印？

1371
00:59:18,862 --> 00:59:19,825
>> 學生：一個字符。

1372
00:59:19,825 --> 00:59:20,830
>> 艾里遜：一個字符。

1373
00:59:20,830 --> 00:59:21,330
涼爽。

1374
00:59:21,330 --> 00:59:24,260
所以，如果你們想知道，你
可以工作，這些在你自己。

1375
00:59:24,260 --> 00:59:25,900
如果您遇到問題，給我發電子郵件。

1376
00:59:25,900 --> 00:59:28,950
但是，第二個會
打印出一個小寫的B。

1377
00:59:28,950 --> 00:59:32,910
第三個會打印出一個
大寫字母B.第四個將打印

1378
00:59:32,910 --> 00:59:36,410
出一個大寫的C，而
最後一個將是一個小寫A.

1379
00:59:36,410 --> 00:59:42,530
最後埃德蒙頓我們實際上會
要進什麼瘋狂的百分比

1380
00:59:42,530 --> 00:59:45,020
標誌甚至意味著一對夫婦的幻燈片。

1381
00:59:45,020 --> 00:59:46,667
因此，嘗試那些你自己。

1382
00:59:46,667 --> 00:59:48,500
如果你有麻煩，
請你跟我說話。

1383
00:59:48,500 --> 00:59:49,655

1384
00:59:49,655 --> 00:59:53,290
如果你通常在亞當斯D廳，
你可能會發現我身邊。

1385
00:59:53,290 --> 00:59:54,760

1386
00:59:54,760 --> 00:59:55,760
>> 所以，ATOI。

1387
00:59:55,760 --> 00:59:59,660
你們有多少人看到了這
功能或聽說過呢？

1388
00:59:59,660 --> 01:00:00,380

1389
01:00:00,380 --> 01:00:00,880
任何人嗎？

1390
01:00:00,880 --> 01:00:02,100

1391
01:00:02,100 --> 01:00:02,600
涼爽。

1392
01:00:02,600 --> 01:00:06,250
那麼，它實際上代表
對於是ASCII為整數。

1393
01:00:06,250 --> 01:00:13,150
所以，你可以做的是，凱撒，
對於那些誰讀的規格，

1394
01:00:13,150 --> 01:00:16,460
你要做點斜線撒
之後，你寫你的程序，

1395
01:00:16,460 --> 01:00:18,690
然後你要
輸入一些數字，你

1396
01:00:18,690 --> 01:00:24,780
想你的秘密消息進行編碼。

1397
01:00:24,780 --> 01:00:30,700
>> 但是，如果我們還記得，我們​​所有的
輸入被存儲為字符串。

1398
01:00:30,700 --> 01:00:31,390
對不對？

1399
01:00:31,390 --> 01:00:35,160
我們有一個ARG V陣列
這是所有類型的字符串。

1400
01:00:35,160 --> 01:00:37,870
所以，如果你只是嘗試
拉那一個，它會

1401
01:00:37,870 --> 01:00:43,240
認為一個或任何數量
你使用的實際上是一個字符。

1402
01:00:43,240 --> 01:00:45,490
所以，你會得到
一些瘋狂的結果。

1403
01:00:45,490 --> 01:00:48,200
所以，如果你真的想
把它變成一個整數

1404
01:00:48,200 --> 01:00:52,060
你可以用它來操縱
你的話或你的消息，

1405
01:00:52,060 --> 01:00:53,366
你想用ATOI。

1406
01:00:53,366 --> 01:00:56,320
ATOI只是轉換
您的字符串轉換為int。

1407
01:00:56,320 --> 01:01:04,530
>> 所以，如果我們有12的字符串，如果我們調用
ATOI月12日，或任何的輸入，

1408
01:01:04,530 --> 01:01:07,370
它實際上將返回
你的整數。

1409
01:01:07,370 --> 01:01:10,610
不是字符或字符串12。

1410
01:01:10,610 --> 01:01:14,230
其中，當你開始
要補充的是，以數字，

1411
01:01:14,230 --> 01:01:17,710
會有很大的不同，
因為字符串12是

1412
01:01:17,710 --> 01:01:21,210
在一些瘋狂的數字
ASCII碼，而整數12

1413
01:01:21,210 --> 01:01:23,390
實際上是12，這是你想要的。

1414
01:01:23,390 --> 01:01:25,630
所以，你要確保使用ATOI。

1415
01:01:25,630 --> 01:01:29,203
>> 你會想這個
在愷撒，因為你

1416
01:01:29,203 --> 01:01:32,520
需要通過提供的INT
用戶在命令行中。

1417
01:01:32,520 --> 01:01:35,230
但是，當他們把它的命令
線，它是作為字符串存儲

1418
01:01:35,230 --> 01:01:35,813
開始。

1419
01:01:35,813 --> 01:01:36,950

1420
01:01:36,950 --> 01:01:38,210
這是否有道理？

1421
01:01:38,210 --> 01:01:40,590
你不一定
需要這個的V @ genere。

1422
01:01:40,590 --> 01:01:43,180
用的V @ genere，正如我所說
之前，你應該嘗試使用

1423
01:01:43,180 --> 01:01:46,600
ASCII數學，看起來更像是
這一點，在那裡你實際上

1424
01:01:46,600 --> 01:01:49,320
使用我們提供給您的字符。

1425
01:01:49,320 --> 01:01:50,970

1426
01:01:50,970 --> 01:01:51,470
涼爽。

1427
01:01:51,470 --> 01:01:52,970

1428
01:01:52,970 --> 01:01:54,170
每個人都很好嗎？

1429
01:01:54,170 --> 01:01:56,530

1430
01:01:56,530 --> 01:01:57,480
真棒。

1431
01:01:57,480 --> 01:01:59,030
>> 所以模。

1432
01:01:59,030 --> 01:02:01,950
所以，如果你正在考慮
這個龐大的數字凱撒？

1433
01:02:01,950 --> 01:02:03,720

1434
01:02:03,720 --> 01:02:07,970
你有這樣的想法，
如果你在Z和你

1435
01:02:07,970 --> 01:02:11,020
給定一個數字2，
這意味著你need--

1436
01:02:11,020 --> 01:02:15,130
ž成為第二
經過自己的信，對不對？

1437
01:02:15,130 --> 01:02:20,800
所以，你需要以某種方式環繞，
和模是做到這一點的方法。

1438
01:02:20,800 --> 01:02:23,310
因此，它是所有這
給你剩下

1439
01:02:23,310 --> 01:02:25,660
的師
由第二首數。

1440
01:02:25,660 --> 01:02:28,660
我們有一些例子，
做出一點更具體。

1441
01:02:28,660 --> 01:02:34,390
但基本上，你用模時
想讓周圍的東西包裹。

1442
01:02:34,390 --> 01:02:36,950
>> 所以，如果你只想要
數字一到八人，

1443
01:02:36,950 --> 01:02:39,670
你可以在任何其他使用模
號，它會永遠

1444
01:02:39,670 --> 01:02:42,960
返回一個數從零到8。

1445
01:02:42,960 --> 01:02:48,750
因此，一些examples--如果
我們有55模數10，

1446
01:02:48,750 --> 01:02:55,350
它只是給你的剩餘
55除以10，這將是5。

1447
01:02:55,350 --> 01:02:56,440

1448
01:02:56,440 --> 01:03:02,470
然後3模5，
有人猜是什麼，這將是？

1449
01:03:02,470 --> 01:03:03,800

1450
01:03:03,800 --> 01:03:04,300
三。

1451
01:03:04,300 --> 01:03:05,570

1452
01:03:05,570 --> 01:03:10,910
>> 所以，如果你面前有一個較小的數字
模，它不能進去均勻。

1453
01:03:10,910 --> 01:03:11,520
這是零。

1454
01:03:11,520 --> 01:03:14,090
所以它只是返回數字本身。

1455
01:03:14,090 --> 01:03:15,920
所以8模8會是什麼？

1456
01:03:15,920 --> 01:03:16,603
>> 學生：零。

1457
01:03:16,603 --> 01:03:18,350
>> 艾里遜：零。

1458
01:03:18,350 --> 01:03:20,160
因為它會在均勻。

1459
01:03:20,160 --> 01:03:22,095
16模15？

1460
01:03:22,095 --> 01:03:23,660
>> 聽眾：一。

1461
01:03:23,660 --> 01:03:24,700
>> 艾里遜：酷。

1462
01:03:24,700 --> 01:03:29,280
然後這最後一個是剛
展示你 - 你可能會想，好吧，

1463
01:03:29,280 --> 01:03:31,800
什麼是這裡的操作順序？

1464
01:03:31,800 --> 01:03:33,100
難道我們把第一個？

1465
01:03:33,100 --> 01:03:34,570
我們做的第一模？

1466
01:03:34,570 --> 01:03:38,730
所以模持有相同的優先級
作為部門或乘法，

1467
01:03:38,730 --> 01:03:39,940
和它的左結合。

1468
01:03:39,940 --> 01:03:41,730
所以它以同樣的方式。

1469
01:03:41,730 --> 01:03:46,520
你總是做括號，
那麼乘法，除法，

1470
01:03:46,520 --> 01:03:49,570
和模數，以便從左至右。

1471
01:03:49,570 --> 01:03:51,050
因此，標準的規則。

1472
01:03:51,050 --> 01:03:55,260
只要把它同日而語
作為除法和乘法。

1473
01:03:55,260 --> 01:03:59,040
>> 所以在這種情況下，我們將
有1加2給了我們3。

1474
01:03:59,040 --> 01:04:02,210
我們乘上2，這樣我們就得到6。

1475
01:04:02,210 --> 01:04:05,050
我們的模2，這給我們嗎？

1476
01:04:05,050 --> 01:04:06,042
>> 學生：0。

1477
01:04:06,042 --> 01:04:07,430
>> 艾里遜：0。

1478
01:04:07,430 --> 01:04:10,270
然後我們加2，所以我們
獲得2在後一種情況下。

1479
01:04:10,270 --> 01:04:12,080

1480
01:04:12,080 --> 01:04:16,360
所以modulo--你肯定會
要考慮如何把

1481
01:04:16,360 --> 01:04:19,520
當你的包裹
周圍的字母表。

1482
01:04:19,520 --> 01:04:24,210
如果你在Z和你需要移動
轉發三個空格才能到C，

1483
01:04:24,210 --> 01:04:26,230
還有的認為整個概念
的纏繞。

1484
01:04:26,230 --> 01:04:28,790
所以我會離開它
你們要弄​​清楚

1485
01:04:28,790 --> 01:04:31,940
究竟你要使用它。

1486
01:04:31,940 --> 01:04:35,660
但絕對是一個很有用的工具
本週你的pset。

1487
01:04:35,660 --> 01:04:36,910

1488
01:04:36,910 --> 01:04:37,730
我真的很喜歡這一點。

1489
01:04:37,730 --> 01:04:39,480
這是我最喜歡的pset之一。

1490
01:04:39,480 --> 01:04:41,230
然後，你這樣做之後，
如果你有朋友，

1491
01:04:41,230 --> 01:04:44,146
你可以一樣，互送的秘密
消息並確保它的工作原理。

1492
01:04:44,146 --> 01:04:45,695
因為它會對其進行解密或什麼的。

1493
01:04:45,695 --> 01:04:46,710

1494
01:04:46,710 --> 01:04:47,390
很多的樂趣。

1495
01:04:47,390 --> 01:04:48,840

1496
01:04:48,840 --> 01:04:51,220
>> 而且是部分的末尾。

1497
01:04:51,220 --> 01:04:52,430

1498
01:04:52,430 --> 01:04:54,040
我很早就完成了。

1499
01:04:54,040 --> 01:04:57,540
我還有15分鐘
你們這些傢伙，所以如果有什麼事，

1500
01:04:57,540 --> 01:05:02,180
你想投奔
另外，我很樂意這樣做。

1501
01:05:02,180 --> 01:05:04,340
任何其他問題
您PSET對於那些​​你

1502
01:05:04,340 --> 01:05:06,355
誰已開始或讀取規格。

1503
01:05:06,355 --> 01:05:07,870

1504
01:05:07,870 --> 01:05:12,060
凡是我們已經談
約在最後一小時

1505
01:05:12,060 --> 01:05:16,880
15分鐘，你會喜歡我
以一種老調重彈，我很樂意。

1506
01:05:16,880 --> 01:05:20,790
或者，我們可以調用它退出，你可以
所有休假，採取更加糖果與你

1507
01:05:20,790 --> 01:05:21,650
當您去。

1508
01:05:21,650 --> 01:05:23,719

1509
01:05:23,719 --> 01:05:26,260
但是，如果有任何揮之不去
問題，請讓我知道。

1510
01:05:26,260 --> 01:05:28,467
您也可以上來，
跟我算賬。

1511
01:05:28,467 --> 01:05:29,425
我發誓我不咬。

1512
01:05:29,425 --> 01:05:32,140

1513
01:05:32,140 --> 01:05:32,795
還要別的嗎？

1514
01:05:32,795 --> 01:05:33,890

1515
01:05:33,890 --> 01:05:35,240
大家的好？

1516
01:05:35,240 --> 01:05:37,540
就像每個人的感覺
他們可以處理這個PSET？

1517
01:05:37,540 --> 01:05:38,820

1518
01:05:38,820 --> 01:05:42,405
你會好起來的傢伙。

1519
01:05:42,405 --> 01:05:43,905
辦公時間是有原因的。

1520
01:05:43,905 --> 01:05:45,930

1521
01:05:45,930 --> 01:05:46,460
涼爽。

1522
01:05:46,460 --> 01:05:47,020
好吧。

1523
01:05:47,020 --> 01:05:49,680
>> 那麼，在這種情況下，謝謝
大家的光臨。

1524
01:05:49,680 --> 01:05:50,940
我希望看到你下週。

1525
01:05:50,940 --> 01:05:52,120
將會有更多的糖果。

1526
01:05:52,120 --> 01:05:53,495
可能還有其他很酷的事情。

1527
01:05:53,495 --> 01:05:55,010

1528
01:05:55,010 --> 01:05:59,090
我期待著得到
要知道你們今年。

1529
01:05:59,090 --> 01:06:00,320