1
00:00:00,000 --> 00:00:01,940
[Powered by Google Translate] [演練 - 習題集2]

2
00:00:01,940 --> 00:00:04,130
[Zamyla陳 - 哈佛大學]

3
00:00:05,170 --> 00:00:07,490
[這是CS50。 CS50.TV]

4
00:00:07,490 --> 00:00:10,750
好的。你好，大家好，歡迎來到演練2。

5
00:00:10,750 --> 00:00:14,330
首先，我要祝賀你完成的pset 1。

6
00:00:14,330 --> 00:00:18,140
我知道，它可能是一個有點艱難一些，

7
00:00:18,140 --> 00:00:20,460
本來是你的，你寫的第一個計算機程序，

8
00:00:20,460 --> 00:00:24,500
但是要記得，在本月底，當你回首在學期結束的時候，

9
00:00:24,500 --> 00:00:29,820
你將看到的pset 1，你會說：“嘿，我可以做了，在5分鐘。”

10
00:00:29,820 --> 00:00:35,700
因此，了解和信任，在本月底，你一定會找到的pset 1很簡單的。

11
00:00:35,700 --> 00:00:40,640
但現在，這是一個巨大的成就，得到完成表示祝賀。

12
00:00:40,640 --> 00:00:44,010
現在，也是一個快速的注意之前，我們得到到肉的演練。

13
00:00:44,010 --> 00:00:48,340
我只想做一個快速的注意，我有時會沒有足夠的時間

14
00:00:48,340 --> 00:00:52,500
在演練通過每一個方式做問題集

15
00:00:52,500 --> 00:00:56,140
，而只是可能集中在1或2種實現，

16
00:00:56,140 --> 00:00:57,750
的方式，你可以做到這一點。

17
00:00:57,750 --> 00:01:01,970
但是，這並不是說，你這樣做的另一種方式是被禁止的。

18
00:01:01,970 --> 00:01:05,980
經常有，作為與計算機科學，無數的做事方式，

19
00:01:05,980 --> 00:01:12,190
所以肯定會覺得自由地使用不同類型的比我可能已經提出的解決方案。

20
00:01:12,190 --> 00:01:14,520
[pset中2：加密 -  Zamyla陳 -  zamyla@cs50.net]

21
00:01:14,520 --> 00:01:17,160
[pset2  -  0。 A組的問題 -  1。凱撒 -  2。維瓊內爾]

22
00:01:17,160 --> 00:01:20,650
好的。所以，問題設置2：加密是一個有趣的。

23
00:01:20,650 --> 00:01:24,500
再有，每pset中，你會開始部分問題

24
00:01:24,500 --> 00:01:29,600
要在你的小節進行分配的教學研究員。

25
00:01:29,600 --> 00:01:31,670
我們不打算在演練中去，通過這些，

26
00:01:31,670 --> 00:01:35,100
但他們肯定會幫你完成的pset。

27
00:01:35,100 --> 00:01:38,100
因此，問題集的第一部分是凱撒。

28
00:01:38,100 --> 00:01:43,470
因此，在凱撒會有人與你擦肩而過的關鍵整數，

29
00:01:43,470 --> 00:01:48,420
你將加密的文本字符串，他們為您提供

30
00:01:48,420 --> 00:01:50,670
並給他們一個加密的東西。

31
00:01:50,670 --> 00:01:56,050
如果有人觀看聖誕故事，有一個例子，有。

32
00:01:56,050 --> 00:01:59,090
問題集的第二部分是維瓊內爾，

33
00:01:59,090 --> 00:02:01,790
這是一個更先進的加密技術。

34
00:02:01,790 --> 00:02:05,640
所以我們要來加密的一段文字，

35
00:02:05,640 --> 00:02:09,600
除，而不是只是一個單一的整數，我們實際上是要編碼

36
00:02:09,600 --> 00:02:13,340
的關鍵字，用戶將提供給我們。

37
00:02:16,270 --> 00:02:22,090
好了，所以今天在工具箱中的工具實際上是將要更新設備。

38
00:02:22,090 --> 00:02:26,430
在討論板中，我們將看到的東西一樣，“為什麼不工作的呢？”

39
00:02:26,430 --> 00:02:28,110
“為什麼不提交50個工作嗎？”

40
00:02:28,110 --> 00:02:31,830
通常的解決方案實際上只是以更新您的設備。

41
00:02:31,830 --> 00:02:36,730
所以，如果你只是運行在一個終端窗口，在您的設備須藤的yum-Y  - 

42
00:02:36,730 --> 00:02:40,040
這是一個標誌，是的，更新的一切 - 更新，

43
00:02:40,040 --> 00:02:42,280
那麼您的設備更新，如果需要的話。

44
00:02:42,280 --> 00:02:46,960
它不會傷害，如果你已經是最新版本的設備。

45
00:02:46,960 --> 00:02:51,280
然後，它會說沒有新的更新可用，您可以繼續工作一起。

46
00:02:51,280 --> 00:02:55,800
但是，這是很好的執行，即使你每次打開設備

47
00:02:55,800 --> 00:02:57,140
因為我們仍然非常 - 

48
00:02:57,140 --> 00:03:00,320
有時，如果我們進入一個錯誤 - 修復它在家電。

49
00:03:00,320 --> 00:03:03,180
因此，請確保您有最新版本的設備

50
00:03:03,180 --> 00:03:07,710
運行該更新存在。

51
00:03:07,710 --> 00:03:14,360
好的。既然我們正在處理的信件和不斷變化的，加密的東西，

52
00:03:14,360 --> 00:03:20,410
我們要真的想成為最好的朋友，我們的ASCII圖。

53
00:03:20,410 --> 00:03:24,350
有無數的人在網上，如果你發現。甚至自己動手做。

54
00:03:24,350 --> 00:03:29,950
基本上，每一個字母，每一個數字，每一個字符

55
00:03:29,950 --> 00:03:32,210
與他們有關聯的數字，

56
00:03:32,210 --> 00:03:38,670
所以這是很好的實際的信一起看他們的ASCII值。

57
00:03:38,670 --> 00:03:42,310
這肯定會幫助你的問題集。

58
00:03:42,310 --> 00:03:45,750
真的幫了我在這個問題上設置的一件事是把它打印出來，

59
00:03:45,750 --> 00:03:48,380
我所經歷的，我會繪製就可以了，

60
00:03:48,380 --> 00:03:51,150
寫，“如果去那裡，然後......”

61
00:03:51,150 --> 00:03:55,270
樣的畫上記號，成為最好的朋友，你的ASCII表。

62
00:03:57,240 --> 00:04:00,750
然後，我們有一些其他的工具，在我們的處置。

63
00:04:00,750 --> 00:04:03,750
這一次，而不是提示用戶的所有輸入

64
00:04:03,750 --> 00:04:05,230
我們要做的組合。

65
00:04:05,230 --> 00:04:06,880
我們要促使他們對於某些輸入，

66
00:04:06,880 --> 00:04:11,350
但我們也將只使用命令行參數。

67
00:04:11,350 --> 00:04:15,600
所以，當他們運行自己的程序，通常你說/你好，例如，

68
00:04:15,600 --> 00:04:17,310
如果你的程序hello.c的。

69
00:04:17,310 --> 00:04:22,500
但是，這一次，而不是只是說，他們可以把字，參數之後。

70
00:04:22,500 --> 00:04:27,210
因此，我們要使用他們傳遞給我們的任何作為自己的輸入，

71
00:04:27,210 --> 00:04:31,720
如此巨大的感染力，不僅僅是提示整數，但也使用命令行參數。

72
00:04:31,720 --> 00:04:36,590
然後，我們將進入數組和字符串，我們將使用了很多。

73
00:04:41,460 --> 00:04:44,810
這只是一個例子，1個mini ASCII圖。

74
00:04:44,810 --> 00:04:48,460
正如我所說的，每一個字母對應一個數字，

75
00:04:48,460 --> 00:04:52,510
如此熟悉。它會派上用場。

76
00:04:52,510 --> 00:04:55,610
後來當我們開始做一些ASCIIMath的處理與數字 - 

77
00:04:55,610 --> 00:05:00,110
加，減他們 - 那麼絕對是一個好參考這個圖表。

78
00:05:02,860 --> 00:05:06,920
因此，這裡是一個愷撒密碼 - 的東西，你可能已經打了一個例子。

79
00:05:06,920 --> 00:05:11,190
這僅僅是一個輪。從本質上講，有一個外字母表，然後有一種內在的字母表。

80
00:05:11,190 --> 00:05:15,290
所以，這裡有一個例子愷撒密碼，但一個關鍵的0。

81
00:05:15,290 --> 00:05:21,540
從本質上講，A是一致的A，B與B對齊，一路到Z

82
00:05:21,540 --> 00:05:26,590
但後​​來說，例如我們希望有一個關鍵的3。

83
00:05:26,590 --> 00:05:33,280
然後，我們會旋轉的內輪使A與D，等等。

84
00:05:33,280 --> 00:05:35,250
所以這基本上就是我們要做的。

85
00:05:35,250 --> 00:05:38,340
我們沒有一個車輪，但我們要做的是使我們的程序

86
00:05:38,340 --> 00:05:44,490
種轉移的字母和我們一起一定量的數字。

87
00:05:44,490 --> 00:05:48,650
因此，正如我之前說的，我們將要處理命令行參數

88
00:05:48,650 --> 00:05:50,390
以及得到的整數。

89
00:05:50,390 --> 00:05:55,050
所以，用戶將您的凱撒程序運行/凱撒說。

90
00:05:55,050 --> 00:05:58,090
然後輸入一個號碼之後。

91
00:05:58,090 --> 00:06:01,130
這個數字代表的關鍵，移位，

92
00:06:01,130 --> 00:06:06,740
有多少次你要旋轉的內輪您的愷撒密碼。

93
00:06:06,740 --> 00:06:08,390
所以你在這裡看到的一個例子。

94
00:06:08,390 --> 00:06:14,550
如果我們在我們的凱撒密碼，輸入的字母從A到L

95
00:06:14,550 --> 00:06:19,520
然後輸入D O的，因為這是每一個字母轉移的3倍以上，

96
00:06:19,520 --> 00:06:22,080
類似的例子，我給你的車輪。

97
00:06:22,080 --> 00:06:25,300
那麼，如果你輸入的，例如，這是CS50！

98
00:06:25,300 --> 00:06:27,960
那麼它也將所有的字母。

99
00:06:27,960 --> 00:06:31,040
這是一個重要的事情在這兩個凱撒和維瓊內爾的

100
00:06:31,040 --> 00:06:34,890
是，我們將跳過任何非字母。

101
00:06:34,890 --> 00:06:39,160
因此，任何空格，字符等，數字，我們要保持相同。

102
00:06:39,160 --> 00:06:42,920
在這種情況下，我們只是要轉移的字母。

103
00:06:42,920 --> 00:06:45,870
因此，正如你看到的，我們只有在車輪提供給我們的信，

104
00:06:45,870 --> 00:06:50,150
所以我們只需要轉移的字母和字母進行加密。

105
00:06:51,370 --> 00:06:56,720
因此，要做的第一件事，你看到的用法凱撒問題集2

106
00:06:56,720 --> 00:07:05,280
是運行凱撒，然後輸入一個數字，當你在終端上運行。

107
00:07:05,280 --> 00:07:10,940
所以，我們需要做的是，以某種方式獲得該密鑰和訪問它。

108
00:07:10,940 --> 00:07:14,730
因此，我們要以某種方式看到它的將是第二個命令行參數。

109
00:07:14,730 --> 00:07:20,950
第一個是/凱撒，將是下一個關鍵的數字。

110
00:07:22,190 --> 00:07:29,200
所以，我們詮釋的主要（無效），開始我們的C程序。

111
00:07:29,200 --> 00:07:31,790
我們要了一層剝開一點點

112
00:07:31,790 --> 00:07:34,720
實際看到的，而不是將我們的主要功能無效

113
00:07:34,720 --> 00:07:37,920
我們實際上是在處理有兩個參數。

114
00:07:37,920 --> 00:07:44,070
我們有一個int，名為ARGC，然後一個字符串數組被稱為argv的。

115
00:07:44,070 --> 00:07:46,030
因此，argc是一個整數，

116
00:07:46,030 --> 00:07:49,640
它代表了傳遞給你的程序中的參數。

117
00:07:49,640 --> 00:07:53,590
然後，argv是實際傳遞的參數列表。

118
00:07:53,590 --> 00:08:00,820
所有的參數都是字符串，所以argv的一個數組，列表，字符串。

119
00:08:01,830 --> 00:08:03,990
讓我們來談談關於數組的一點點。

120
00:08:03,990 --> 00:08:05,940
數組本質上是一種新的數據結構。

121
00:08:05,940 --> 00:08:09,660
我們有整數，我們已增加一倍，我們的字符串，現在我們有陣列。

122
00:08:09,660 --> 00:08:13,820
陣列的數據結構，可容納的相同類型的多個值，

123
00:08:13,820 --> 00:08:18,320
所以基本上，你想要的任何類型的列表。

124
00:08:18,320 --> 00:08:24,400
從本質上講，如果你想要一個整數都在1個變量列表，

125
00:08:24,400 --> 00:08:29,090
然後，您將創建一個新的變量是int類型的陣列。

126
00:08:29,090 --> 00:08:34,450
所以數組是從零開始的索引，這意味著該數組的第一個元素的索引為0。

127
00:08:34,450 --> 00:08:41,799
如果數組的長度為4，在這個例子中，那麼你的最後一個元素將在索引3，

128
00:08:41,799 --> 00:08:44,810
這是4  -  1。

129
00:08:45,940 --> 00:08:48,420
因此，要創建數組，你會做這樣的事情。

130
00:08:48,420 --> 00:08:51,440
假設你想要一個雙陣列。

131
00:08:51,440 --> 00:08:56,520
這也適用於任何類型的數據類型，雖然。

132
00:08:56,520 --> 00:09:00,210
所以說，你想有一個雙陣列。假設你想調用它的郵箱。

133
00:09:00,210 --> 00:09:04,760
就像你會初始化任何其他雙，

134
00:09:04,760 --> 00:09:09,760
雙，然後你會說這個名字，但是這一次我們把方括號，

135
00:09:09,760 --> 00:09:13,570
然後是電話號碼會有陣列的長度。

136
00:09:13,570 --> 00:09:16,840
請注意，在數組中，我們不能永遠改變的長度，

137
00:09:16,840 --> 00:09:21,230
所以你總是要定義和選擇多少箱，

138
00:09:21,230 --> 00:09:25,440
您的陣列將要舉辦多少個值。

139
00:09:25,440 --> 00:09:31,820
因此，要在你的陣列設置不同的值，你要使用下面的語法，

140
00:09:31,820 --> 00:09:33,200
正如你看到的幻燈片上。

141
00:09:33,200 --> 00:09:37,620
你有郵箱索引0將被設置為1.2，

142
00:09:37,620 --> 00:09:42,180
郵箱索引1設置為2.4，等

143
00:09:42,180 --> 00:09:47,910
所以，現在我們已經回顧了陣列位，讓我們回到argc和argv。

144
00:09:47,910 --> 00:09:52,220
我們知道，argv是一個字符串數組。

145
00:09:52,220 --> 00:09:55,080
因此，當用戶通過在 - 說，他們正在運行的程序 - 

146
00:09:55,080 --> 00:09:58,740
他們說/你好大衛·馬蘭，

147
00:09:58,740 --> 00:10:05,160
已經為您實際上是來了什麼argc和argv是什麼程序做。

148
00:10:05,160 --> 00:10:07,620
所以，你不必擔心這個問題。

149
00:10:07,620 --> 00:10:14,370
ARGC在這種情況下，因為它看到3個不同的字之間用空格分隔。

150
00:10:14,370 --> 00:10:18,850
因此，然後在此實例中的陣列，第一個索引將/你好，

151
00:10:18,850 --> 00:10:21,770
下一個，下一個大衛·馬蘭。

152
00:10:21,770 --> 00:10:25,640
有沒有人看到馬上之間的關係是什麼ARGV，

153
00:10:25,640 --> 00:10:28,990
 數組，argc是嗎？

154
00:10:32,820 --> 00:10:38,090
是啊。我們將進入一個例子，args.c.

155
00:10:38,090 --> 00:10:42,880
讓我們來看看，如果我們可以利用的關係2。

156
00:10:42,880 --> 00:10:46,550
在這裡，您可能會發現，在家電的默認應用程序

157
00:10:46,550 --> 00:10:49,450
打開c文件有時是Emacs的。

158
00:10:49,450 --> 00:10:54,660
但是，我們希望用gedit來處理，所以你可以做什麼，你可以用鼠標點擊你的C文件，

159
00:10:54,660 --> 00:11:04,580
去“屬性”，“打開方式”，然後選擇gedit中，設置為默認，

160
00:11:04,580 --> 00:11:13,020
現在你的程序應該打開gedit中，而不是Emacs的。

161
00:11:14,710 --> 00:11:16,290
完美的。

162
00:11:17,120 --> 00:11:25,520
所以在這裡我有一個程序，我想打印出每個命令行參數。

163
00:11:25,520 --> 00:11:32,050
因此，無論用戶輸入，我想基本上是把它送回給他們一個新的生產線。

164
00:11:32,050 --> 00:11:36,710
那麼，什麼是結構，我們可以用它來遍歷東西 - 

165
00:11:36,710 --> 00:11:40,380
的東西，你可能在你的pset 1？

166
00:11:40,380 --> 00:11:45,840
如果你想要去的通過設置一些事情呢？ >> [學生] For循環。

167
00:11:45,840 --> 00:11:48,910
For循環。沒錯。因此，讓我們開始用for循環。

168
00:11:48,910 --> 00:11:56,900
我們必須為int i = 0。讓我們開始一個標準的初始化變量。

169
00:11:56,900 --> 00:12:02,370
我要離開的條件為一組，然後說我+ +，要做的事情。

170
00:12:02,370 --> 00:12:04,090
好的。

171
00:12:04,090 --> 00:12:11,590
所以，回想起ARGV，如果argv是列表中的參數傳遞給程序

172
00:12:11,590 --> 00:12:15,380
argc是參數的個數在程序中，

173
00:12:15,380 --> 00:12:21,280
那麼這意味著argc是本質上的argv的長度，右，

174
00:12:21,280 --> 00:12:28,970
因為有將是為argc多個參數的值。

175
00:12:28,970 --> 00:12:35,910
因此，如果我們要遍歷每個元素argv中，

176
00:12:35,910 --> 00:12:43,290
我們會想每次訪問該變量在argv在給定的索引。

177
00:12:43,290 --> 00:12:49,060
這可以表示為這，對不對？

178
00:12:49,060 --> 00:12:53,430
在這種情況下，這個變量代表了特定的字符串

179
00:12:53,430 --> 00:12:57,030
因為它是一個字符串數組 - 特定的字符串，給定的索引。

180
00:12:57,030 --> 00:13:00,690
我們想要做的是什麼，在這種情況下，我們希望將其打印出來，讓我們說printf的。

181
00:13:00,690 --> 00:13:04,680
而現在，argv是一個字符串，所以我們希望把這個佔位符。

182
00:13:04,680 --> 00:13:08,430
我們希望有一個新的生產線，只是為了使它看起來好。

183
00:13:08,430 --> 00:13:12,530
所以，在這裡，我們有一個for循環。我們不具備的條件。

184
00:13:12,530 --> 00:13:20,020
所以，我從0開始，然後每次要打印給定的字符串

185
00:13:20,020 --> 00:13:22,980
在該陣列中的特定索引。

186
00:13:22,980 --> 00:13:28,410
那麼，我們什麼時候要停止打印出數組中的元素呢？

187
00:13:28,410 --> 00:13:35,720
當我們已經完成了，對不對？當我們已經走到了盡頭的數組。

188
00:13:35,720 --> 00:13:38,870
因此，我們不要超過過去的數組的長度，

189
00:13:38,870 --> 00:13:43,700
我們已經知道我們需要積極尋找的長度和argv是什麼

190
00:13:43,700 --> 00:13:47,520
，因為它給我們，那是什麼？ ARGC。沒錯。

191
00:13:47,520 --> 00:13:56,640
所以，我們想要做的這個過程中的argc次數。

192
00:13:56,640 --> 00:13:59,550
我不是在正確的目錄。

193
00:14:02,100 --> 00:14:03,490
好的。

194
00:14:03,490 --> 00:14:08,990
現在讓我們把參數。沒有錯誤，這是偉大的。

195
00:14:08,990 --> 00:14:11,430
因此，讓我們運行ARGS。

196
00:14:11,430 --> 00:14:15,130
這是什麼要回到我們的身邊呢？只是要打印出來。

197
00:14:15,130 --> 00:14:18,320
“您輸入的ARGS到程序中，我要去給它回給你。”

198
00:14:18,320 --> 00:14:23,170
因此，讓我們說我們想說的ARGS富酒吧。

199
00:14:23,170 --> 00:14:26,570
那麼它打印出來寄回給我們。好嗎？

200
00:14:26,570 --> 00:14:30,790
因此，有一個例子，如何使用argc和argv

201
00:14:30,790 --> 00:14:33,460
知道的argc表示argv的長度。

202
00:14:33,460 --> 00:14:42,750
請確保你不會超出了數組的長度與數組訪問一個

203
00:14:42,750 --> 00:14:45,140
因為C肯定會喊你。

204
00:14:45,140 --> 00:14:47,560
你會得到的東西稱為分割故障，

205
00:14:47,560 --> 00:14:52,470
這是從來沒有的樂趣，基本上是說你試圖訪問的東西

206
00:14:52,470 --> 00:14:55,000
不存在的，不屬於你的。

207
00:14:55,000 --> 00:14:59,430
所以一定要確保，特別是零索引，我們不希望 - 

208
00:14:59,430 --> 00:15:02,390
喜歡舉例來說，如果我們有一個數組的長度為4，

209
00:15:02,390 --> 00:15:07,240
該數組的索引4不存在，因為我們從0開始，在零指數。

210
00:15:07,240 --> 00:15:11,730
當我們從0開始，這將成為第二個性質一樣的for循環。

211
00:15:11,730 --> 00:15:13,610
因此，只要記住這一點。

212
00:15:13,610 --> 00:15:22,590
你不想，曾經訪問數組的索引，你也達不到。

213
00:15:26,710 --> 00:15:32,560
因此，我們現在可以看到我們如何才能哪種類型的訪問

214
00:15:32,560 --> 00:15:35,930
命令行參數傳遞的。

215
00:15:35,930 --> 00:15:41,330
但是，正如你看到的字符串，argv是一個字符串數組。

216
00:15:41,330 --> 00:15:45,740
因此，它實際上是整數，但在凱撒我們要處理整數。

217
00:15:45,740 --> 00:15:54,430
幸運的是，為我們創造的功能，實際上可以將字符串轉換為整數。

218
00:15:54,430 --> 00:15:58,710
也正是在這裡，我們不處理用戶輸入我們提示

219
00:15:58,710 --> 00:16:03,740
在這裡輸入的關鍵，所以我們不能實際重新提示，並說，

220
00:16:03,740 --> 00:16:07,840
“”哦，給我另一個整數，也就是說，如果是不正確的。“

221
00:16:07,840 --> 00:16:10,540
但是，我們仍然需要檢查是否有正確的使用方法。

222
00:16:10,540 --> 00:16:13,520
在愷撒只允許他們通過1號，

223
00:16:13,520 --> 00:16:18,030
，所以他們有運行。/凱撒，然後他們給你一個數字。

224
00:16:18,030 --> 00:16:23,660
所以ARGC有一定數目。

225
00:16:23,660 --> 00:16:29,060
這是什麼號碼，如果他們要傳遞給你。/凱撒，然後一鍵嗎？

226
00:16:29,060 --> 00:16:32,920
ARGC是什麼？ >> [學生] 2。 >>雙。沒錯。

227
00:16:32,920 --> 00:16:35,490
所以，你想，以確保argc是2。

228
00:16:35,490 --> 00:16:39,620
否則，你基本上拒絕運行程序。

229
00:16:39,620 --> 00:16:43,040
它主要是說，國際主要的功能，

230
00:16:43,040 --> 00:16:47,360
這樣的話，我們始終在良好的實踐的一檔成功的節目結束時返回0。

231
00:16:47,360 --> 00:16:50,840
因此，如果說，他們給你的命令行參數，而不是2

232
00:16:50,840 --> 00:16:54,350
或給你，例如，你會做什麼是你要檢查

233
00:16:54,350 --> 00:16:59,900
，然後返回說，沒有，我不能繼續進行這項計劃。

234
00:16:59,900 --> 00:17:03,190
[學生]有可以在您的文本中不能有空格。 >>請原諒我嗎？

235
00:17:03,190 --> 00:17:06,780
[學生]你想加密的文字不能有一個空間。

236
00:17:06,780 --> 00:17:08,480
“啊！

237
00:17:08,480 --> 00:17:11,280
，我們正在試圖加密的文本，這實際上是後話

238
00:17:11,280 --> 00:17:13,970
當我們給該文本。

239
00:17:13,970 --> 00:17:18,260
所以現在我們只是接受命令參數的實際數目，

240
00:17:18,260 --> 00:17:21,579
實際位移的凱撒加密。

241
00:17:21,579 --> 00:17:27,569
[學生]：為什麼你需要，而不是僅1 ARGC？ 1號。

242
00:17:27,569 --> 00:17:32,200
右。我們之所以需要2個為argc，而不是1

243
00:17:32,200 --> 00:17:36,260
是因為當你運行一個程序並說/凱撒/個招呼，

244
00:17:36,260 --> 00:17:38,280
實際計算作為命令行參數。

245
00:17:38,280 --> 00:17:43,020
那麼，已經佔據了1，所以後來我們在輸入1張額外的。

246
00:17:45,030 --> 00:17:49,440
所以，你輸入的命令行參數是一個字符串。

247
00:17:49,440 --> 00:17:52,730
你想要做什麼，凱撒，我們要處理一個整數，

248
00:17:52,730 --> 00:17:57,180
所以，你可以使用這個atoi函數。

249
00:17:57,180 --> 00:18:02,850
基本上，你在一個字符串傳遞給它，然後它就會回報你回一個整數

250
00:18:02,850 --> 00:18:06,070
如果可能的話，使該字符串轉換為整數。

251
00:18:06,070 --> 00:18:10,960
現在還記得，當我們正在處理與printf或GetString時，這樣的事情，

252
00:18:10,960 --> 00:18:13,390
包括具體到我們的庫。

253
00:18:13,390 --> 00:18:19,450
因此，在一開始，我們開始與的散列標籤標準I / O，H，類似的東西。

254
00:18:19,450 --> 00:18:22,430
好了，atoi的是在這些庫，

255
00:18:22,430 --> 00:18:26,600
所以我們要做的是，我們必須有正確的庫，。

256
00:18:26,600 --> 00:18:32,720
所以，記得演練1，我討論了手動功能。

257
00:18:32,720 --> 00:18:37,110
您鍵入的人在你的終端，然後由一個函數的名稱。

258
00:18:37,110 --> 00:18:39,720
因此，將其使用帶來了一個全新的名單，

259
00:18:39,720 --> 00:18:42,890
但因為它會帶來哪個庫屬於。

260
00:18:42,890 --> 00:18:47,000
所以我把它留給你使用的手動功能ATOI

261
00:18:47,000 --> 00:18:53,360
你需要包括能夠使用atoi函數庫。

262
00:18:54,450 --> 00:18:57,670
因此，我們已經拿到了鑰匙，現在它得到的純文本，

263
00:18:57,670 --> 00:19:01,820
所以，實際上是向您提示用戶輸入。

264
00:19:01,820 --> 00:19:05,540
我們處理調用getInt和getFloat，因此，在同樣

265
00:19:05,540 --> 00:19:07,670
我們要處理的GetString。

266
00:19:07,670 --> 00:19:12,440
但是，在這種情況下，我們並不需要做任何做或while循環檢查。

267
00:19:12,440 --> 00:19:14,480
GetString的肯定會給我們一個字符串，

268
00:19:14,480 --> 00:19:17,630
我們要進行加密的用戶給我們。

269
00:19:17,630 --> 00:19:23,770
所以，你可以認為所有這些用戶輸入的字符串是正確的。

270
00:19:23,770 --> 00:19:24,670
大。

271
00:19:24,670 --> 00:19:27,270
那麼，一旦你已經拿到了鑰匙，一旦你得到了文本，

272
00:19:27,270 --> 00:19:31,660
現在剩下的就是你來加密明文。

273
00:19:31,660 --> 00:19:36,530
只是為了迅速覆蓋了行話中，明文是用戶給你，

274
00:19:36,530 --> 00:19:41,030
和密文是你返回給他們。

275
00:19:42,450 --> 00:19:45,850
所以字符串，能夠通過實際信信

276
00:19:45,850 --> 00:19:48,550
因為我們要轉移的每一個字母，

277
00:19:48,550 --> 00:19:51,390
據我們了解，字符串，如果我們剝離層，

278
00:19:51,390 --> 00:19:54,130
我們看到，他們真的只是一個字符列表。

279
00:19:54,130 --> 00:19:55,930
一個後。

280
00:19:55,930 --> 00:20:01,690
因此，我們可以將字符串作為數組，因為他們是字符數組。

281
00:20:01,690 --> 00:20:05,640
所以說，你有一個字符串命名的文本，

282
00:20:05,640 --> 00:20:09,400
並在該變量的文本存儲，這是CS50。

283
00:20:09,400 --> 00:20:15,680
然後在索引0的文本將是一個大寫字母T，指數1小時，等等。

284
00:20:17,530 --> 00:20:23,970
然後用陣列中的argc在args.c的例子，

285
00:20:23,970 --> 00:20:27,090
我們看到，我們不得不遍歷一個數組

286
00:20:27,090 --> 00:20:32,440
所以我們必須從i = 0迭代，直到我是小於的長度。

287
00:20:32,440 --> 00:20:35,560
因此，我們需要一些方法搞清楚什麼是我們的字符串的長度是

288
00:20:35,560 --> 00:20:37,090
如果我們要遍歷它。

289
00:20:37,090 --> 00:20:42,300
幸運的了，有一個功能，對於我們來說，雖然後來在CS50

290
00:20:42,300 --> 00:20:45,860
你一定能夠實現自己的功能，使您的

291
00:20:45,860 --> 00:20:48,260
可以計算一個字符串的長度。

292
00:20:48,260 --> 00:20:52,120
但是現在我們要使用字符串的長度，所以strlen的。

293
00:20:52,120 --> 00:21:00,440
你傳遞一個字符串，然後它會返回一個int值，代表你的字符串的長度。

294
00:21:00,440 --> 00:21:05,840
讓我們看一個例子，我們可能能夠遍歷字符串中的每個字符

295
00:21:05,840 --> 00:21:08,470
做一些。

296
00:21:08,470 --> 00:21:13,250
我們想要做的是遍歷每個字符的字符串，

297
00:21:13,250 --> 00:21:19,150
和我們想要做的是，我們打印每個字符1 1

298
00:21:19,150 --> 00:21:22,060
但我們添加的東西在它旁邊。

299
00:21:22,060 --> 00:21:27,020
因此，讓我們開始用for循環。 INT I = 0。

300
00:21:27,020 --> 00:21:30,070
我們就要走了空間的條件。

301
00:21:32,700 --> 00:21:36,840
我們要重複，直到我們到達字符串結尾的，對不對？

302
00:21:36,840 --> 00:21:41,340
那麼，什麼樣的功能為我們提供了字符串的長度？

303
00:21:41,340 --> 00:21:43,160
[聽不見的學生反應]

304
00:21:43,160 --> 00:21:46,420
這是命令行參數的長度。

305
00:21:46,420 --> 00:21:50,650
但我們要使用的功能，讓我們的字符串的長度的字符串。

306
00:21:50,650 --> 00:21:53,090
所以這是字符串的長度。

307
00:21:53,090 --> 00:21:57,130
這樣的話，你有一個字符串，它通過。

308
00:21:57,130 --> 00:21:59,760
它需要知道它需要計算長度的字符串。

309
00:21:59,760 --> 00:22:03,160
那麼在這種情況下，我們要處理的字符串s。

310
00:22:04,790 --> 00:22:05,860
大。

311
00:22:05,860 --> 00:22:10,770
所以，我們想要做的是什麼，讓我們的printf。

312
00:22:10,770 --> 00:22:14,850
現在，我們要處理的字符。我們要打印出每個人的個性。

313
00:22:14,850 --> 00:22:22,150
當你想打印出一個浮動時，你可以使用這樣的佔位符％F。

314
00:22:22,150 --> 00:22:24,580
一個int，你會使用％d。

315
00:22:24,580 --> 00:22:30,890
同樣，一個字符使用％C說我要打印一個字符

316
00:22:30,890 --> 00:22:34,570
是存儲在變量中。

317
00:22:34,570 --> 00:22:40,840
所以，我們都這樣了，讓我們添加一個句號和一個空間給它。

318
00:22:40,840 --> 00:22:45,430
我們使用哪一個角色？

319
00:22:45,430 --> 00:22:49,780
我們將要使用我們的字符串的任何字符。

320
00:22:49,780 --> 00:22:52,890
那麼，我們將要使用的東西，用繩子，

321
00:22:52,890 --> 00:22:56,420
但我們要訪問某些字符。

322
00:22:56,420 --> 00:23:02,740
因此，如果一個字符串就是一個數組，那麼怎麼辦，我們訪問數組中的元素？

323
00:23:02,740 --> 00:23:06,480
我們有那些方括號，然後我們把在那裡的指數。

324
00:23:06,480 --> 00:23:11,820
因此，我們必須方括號內。在這種情況下，我們的索引，我們就可以使用。沒錯。

325
00:23:15,290 --> 00:23:22,370
因此，我們在這裡說，我們要打印一個字符後面跟著一個點和一個空格，

326
00:23:22,370 --> 00:23:30,870
該字符將是我們的字符串s中的第i個字母。

327
00:23:32,920 --> 00:23:39,330
我只是要節省。好吧。

328
00:23:42,510 --> 00:23:46,840
現在，我要執行字符串的長度。

329
00:23:46,840 --> 00:23:53,440
因此，我們有一個字符串名為OMG，現在它更強調。

330
00:23:53,440 --> 00:23:57,870
同樣，讓我們說，我們確實希望得到來自用戶的字符串。

331
00:23:57,870 --> 00:23:59,580
我們怎麼可能這樣做呢？

332
00:23:59,580 --> 00:24:01,610
在此之前，我們是如何得到一個int？

333
00:24:01,610 --> 00:24:08,040
我們說調用getInt，對不對？但是，這是不是int，讓我們的GetString。

334
00:24:11,780 --> 00:24:17,770
讓我們把字符串的長度。在這裡，我們沒有進入一個特定的提示。

335
00:24:17,770 --> 00:24:19,940
所以我不知道。

336
00:24:19,940 --> 00:24:23,820
我要去把我的名字在這裡，那麼我可以做的事情之一

337
00:24:23,820 --> 00:24:29,600
我給你一個單詞的每一個字母或類似的東西。酷。

338
00:24:29,600 --> 00:24:31,900
所以這是字符串的長度。

339
00:24:33,000 --> 00:24:34,640
所以我們又回到了愷撒。

340
00:24:34,640 --> 00:24:38,620
我們有一些工具，我們如何遍歷字符串，

341
00:24:38,620 --> 00:24:41,250
我們如何訪問每個元素。

342
00:24:41,250 --> 00:24:44,720
所以，現在我們可以回去的程序。

343
00:24:44,720 --> 00:24:48,650
正如我之前提到的，在ASCII表，你最好的朋友，

344
00:24:48,650 --> 00:24:52,300
你將看到的數字，都與每一個字母。

345
00:24:52,300 --> 00:24:55,900
所以在這裡說我們的明文是我暈！

346
00:24:55,900 --> 00:25:01,090
然後這些字符有一個數字，它與ASCII值，

347
00:25:01,090 --> 00:25:04,710
即使是單引號，即使是空間，甚至是感嘆號，

348
00:25:04,710 --> 00:25:06,600
所以，你要記住這一點。

349
00:25:06,600 --> 00:25:12,360
所以說，我們的主要用戶在其命令行參數包括6。

350
00:25:12,360 --> 00:25:17,770
這意味著，這是我的第一個字母，這是代表了73，

351
00:25:17,770 --> 00:25:25,610
你想返回到他們的任何字母所代表的ASCII值73 + 6。

352
00:25:25,610 --> 00:25:29,020
在這種情況下這將是79。

353
00:25:30,840 --> 00:25:35,040
現在，我們要進入到下一個字符。

354
00:25:35,040 --> 00:25:40,960
所以接下來的索引1中的明文將單引號。

355
00:25:40,960 --> 00:25:46,780
但是，請記住，我們只希望來加密信件。

356
00:25:46,780 --> 00:25:50,040
因此，我們要確保的撇號保持不變，

357
00:25:50,040 --> 00:25:54,310
我們不改變從39到45什麼是。

358
00:25:54,310 --> 00:25:57,150
我們要保持它作為一個單引號。

359
00:25:57,150 --> 00:26:00,780
因此，我們要記得只加密被字母

360
00:26:00,780 --> 00:26:04,560
因為我們希望所有其它符號在我們的程序中保持不變。

361
00:26:04,560 --> 00:26:07,130
另一件事，我們想要的是保存資本。

362
00:26:07,130 --> 00:26:10,250
所以，當你有一個大寫字母，它應該保持一個大寫。

363
00:26:10,250 --> 00:26:12,830
小寫字母應保持為小寫。

364
00:26:13,620 --> 00:26:19,480
因此，一些有用的功能，能夠處理僅加密信件

365
00:26:19,480 --> 00:26:22,380
並保持維護資本化的東西

366
00:26:22,380 --> 00:26:25,130
因而isalpha，isupper，islower功能。

367
00:26:25,130 --> 00:26:29,270
所以，這些函數返回一個布爾值，。

368
00:26:29,270 --> 00:26:34,180
基本上，true或false。這是一個大寫的嗎？這是字母數字嗎？

369
00:26:34,180 --> 00:26:37,180
這是一個字母，本質上。

370
00:26:37,180 --> 00:26:41,070
因此，這裡有3個例子，你將如何使用該功能。

371
00:26:41,070 --> 00:26:47,060
基本上，你可以測試是否由該函數返回的值是true或false

372
00:26:47,060 --> 00:26:49,400
基於該輸入。

373
00:26:49,400 --> 00:26:54,880
無論是做不加密器的東西或密碼，或確保它的大寫字母，

374
00:26:54,880 --> 00:27:01,080
[學生]：你能不能解釋多一點，你如何使用它們？是啊，肯定的。

375
00:27:01,080 --> 00:27:08,470
因此，如果我們回頭看看，在這裡，我們有資本我，對不對？

376
00:27:08,470 --> 00:27:14,550
因此，我們知道，我去O，因為我是O + 6

377
00:27:14,550 --> 00:27:18,740
但我們要確保的O將是一個資本O.

378
00:27:18,740 --> 00:27:22,940
因此，基本上，這是一種將改變我們的輸入。

379
00:27:22,940 --> 00:27:26,870
因此，無論是大寫或不會種改變我們處理它的方式。

380
00:27:26,870 --> 00:27:32,360
因此，然後在那個特定的索引，如果我們使用isupper函數，

381
00:27:32,360 --> 00:27:36,480
isupper（“I”），返回我們真正的，所以我們知道它的上部。

382
00:27:36,480 --> 00:27:40,360
那麼此基礎上，以後我們將進入一個公式

383
00:27:40,360 --> 00:27:42,750
您將要使用的轉移在凱撒的東西，

384
00:27:42,750 --> 00:27:46,560
這樣的話基本上，會是一個略微不同的公式，如果是大寫

385
00:27:46,560 --> 00:27:50,670
而不是小寫。有意義嗎？

386
00:27:51,020 --> 00:27:52,760
是啊。無後顧之憂。

387
00:27:54,900 --> 00:27:58,990
我討論了一些加入了一封信，沒有引起太大意義

388
00:27:58,990 --> 00:28:05,500
除非我們了解這些字符

389
00:28:05,500 --> 00:28:08,920
是一種互換整數。

390
00:28:08,920 --> 00:28:11,250
我們做的是一種使用隱式轉換。

391
00:28:11,250 --> 00:28:18,100
我們將進入鑄造了一下之後你在哪裡取一個值，你把它變成一個不同的類型

392
00:28:18,100 --> 00:28:20,440
比原來的。

393
00:28:20,440 --> 00:28:25,910
但是，這pset中，我們就可以種交替使用的字符

394
00:28:25,910 --> 00:28:30,880
及其對應的整數值。

395
00:28:30,880 --> 00:28:35,140
所以，如果你只是包住一個只用單引號括起來的字符，

396
00:28:35,140 --> 00:28:40,390
然後你就可以用它來工作的整數，它作為一個整數處理。

397
00:28:40,390 --> 00:28:48,040
因此，大寫字母C至67歲。小寫的F，涉及到102。

398
00:28:48,040 --> 00:28:51,480
同樣，如果你​​想知道這些值，看看您的ASCII表。

399
00:28:51,480 --> 00:28:56,160
因此，讓我們進入一些例子，你也許可以減，並把它們添加到

400
00:28:56,160 --> 00:29:03,130
實際上，你可以真正的工作與這些字符，交替地使用它們。

401
00:29:03,870 --> 00:29:11,350
我說，ASCIIMath是要計算一個字符的另外一個整數

402
00:29:11,350 --> 00:29:17,590
然後顯示所得到的字符，以及所得的AS​​CII值。

403
00:29:17,590 --> 00:29:22,290
所以在這裡我說 - 這部分我們將處理後 - 

404
00:29:22,290 --> 00:29:29,100
但基本上，我是說，用戶應該說運行ASCIIMath沿的一個關鍵，

405
00:29:29,100 --> 00:29:30,880
我的意思是，關鍵是要數

406
00:29:30,880 --> 00:29:34,600
我們要添加這個人物。

407
00:29:34,600 --> 00:29:38,560
所以在這裡請注意，由於我要求的關鍵，

408
00:29:38,560 --> 00:29:40,590
因為我要求他們給我的事情，

409
00:29:40,590 --> 00:29:45,600
我只希望接受/ asciimath和關鍵。

410
00:29:45,600 --> 00:29:49,330
因此，我將要求argc是等於2。

411
00:29:49,330 --> 00:29:54,360
如果不是，那麼我將返回1，程序將退出。

412
00:29:55,070 --> 00:29:58,540
所以我說，關鍵是不能將是第一個命令行參數，

413
00:29:58,540 --> 00:30:05,080
這將是第二個，你在這裡看到，

414
00:30:05,080 --> 00:30:11,790
我打算把它轉換成一個整數。

415
00:30:15,740 --> 00:30:19,230
然後，我將設置一個字符為r。

416
00:30:19,230 --> 00:30:23,970
請注意，可變的字符的類型實際上是一個整數。

417
00:30:23,970 --> 00:30:30,480
我可以使用r為整數的方式，是由這些單引號包圍它。

418
00:30:33,850 --> 00:30:40,560
所以回到我們的printf語句，我們有一個佔位符字符

419
00:30:40,560 --> 00:30:43,590
然後一個佔位符的整數，

420
00:30:43,590 --> 00:30:49,450
的字符所代表的字符，並且的整數是關鍵。

421
00:30:49,450 --> 00:30:54,320
因此，我們要在結果中添加2一起。

422
00:30:54,320 --> 00:30:58,420
因此，我們要新增R +什麼，關鍵是，

423
00:30:58,420 --> 00:31:03,520
然後我們要打印的結果。

424
00:31:06,210 --> 00:31:14,220
所以讓我們asciimath。這是最新的，所以讓我們，只是運行asciimath。

425
00:31:14,220 --> 00:31:18,290
哦，不過看，它不會做任何事情，因為我們沒有給它的一個關鍵。

426
00:31:18,290 --> 00:31:23,850
因此，當它剛剛回來，我們的主要功能，它只是返回給我們。

427
00:31:23,850 --> 00:31:29,250
那麼，讓我們通過在一個關鍵。有人給我一個號。 >> [學生] 4。

428
00:31:29,250 --> 00:31:30,920
4。好吧。

429
00:31:30,920 --> 00:31:39,280
所以R增加了4將會給我們V，對應的ASCII值118。

430
00:31:39,280 --> 00:31:43,880
那麼它是有道理的 - 

431
00:31:43,880 --> 00:31:51,250
其實，我可以問你，你怎麼想的ASCII值的r，如果r + 4 118嗎？

432
00:31:53,070 --> 00:31:55,470
然後，是的，r是114。

433
00:31:55,470 --> 00:32:03,010
因此，如果你在ASCII表中，然後，果然，你會看到，R是代表了114。

434
00:32:03,010 --> 00:32:08,610
所以，現在我們知道，我們可以添加整數的字符，這似乎很簡單。

435
00:32:08,610 --> 00:32:12,740
我們只是要遍歷一個字符串，如我們所看到的一個例子之前。

436
00:32:12,740 --> 00:32:17,170
我們會檢查它是否是一個字母。

437
00:32:17,170 --> 00:32:20,420
如果是的話，那麼我們將它轉移什麼，關鍵是。

438
00:32:20,420 --> 00:32:23,650
很簡單，只是，當你喜歡這個，

439
00:32:23,650 --> 00:32:32,140
你看，Z，代表了122，然後會給你一個不同的角色。

440
00:32:32,140 --> 00:32:37,770
我們其實是想留在我們的字母表，對不對？

441
00:32:37,770 --> 00:32:43,180
因此，我們需要找出一些環繞著種方式。

442
00:32:43,180 --> 00:32:47,190
當你到達ZED你想要增加了一定的數量，

443
00:32:47,190 --> 00:32:51,230
你不想進入超越ASCII字母部分;

444
00:32:51,230 --> 00:32:54,140
你想換一路A.

445
00:32:54,140 --> 00:32:58,550
但請記住，你仍然保留的情況下。

446
00:32:58,550 --> 00:33:00,980
因此，知道字母不能成為符號

447
00:33:00,980 --> 00:33:05,290
就像符號都不會被改變。

448
00:33:05,290 --> 00:33:08,170
在過去的pset你絕對沒有必要，

449
00:33:08,170 --> 00:33:14,310
但一個選擇是使用的模函數來實現你的貪婪的pset。

450
00:33:14,310 --> 00:33:17,230
但現在我們將需要使用模量，

451
00:33:17,230 --> 00:33:19,900
所以我們就在這個有點。

452
00:33:19,900 --> 00:33:26,920
從本質上講，當你有Y，X模，讓你x除以y的其餘部分。

453
00:33:26,920 --> 00:33:30,930
下面是一些例子。我們有27％15。

454
00:33:30,930 --> 00:33:36,200
基本上，當你減去15的27多次可能沒有得到負

455
00:33:36,200 --> 00:33:39,060
那麼你得到12左。

456
00:33:39,060 --> 00:33:44,650
那麼，這有點像在數學方面，但如何才能真正使用這個呢？

457
00:33:44,650 --> 00:33:47,100
這將是有用的為我們的wrapover。

458
00:33:47,100 --> 00:33:55,420
對於這一點，讓我們只想說，我問你，分為3組。

459
00:33:55,420 --> 00:33:58,010
有時候，你這樣做組和類似的東西。

460
00:33:58,010 --> 00:34:01,320
說，我說，“好吧，我希望大家可以分為3個。”

461
00:34:01,320 --> 00:34:04,240
你如何做到這一點？

462
00:34:04,240 --> 00:34:06,810
[聽不見的學生反應]是的，沒錯。數。好吧。

463
00:34:06,810 --> 00:34:10,260
讓我們做到這一點。你要開始？

464
00:34:10,260 --> 00:34:13,810
[學生計數] 1，2，3，4。

465
00:34:13,810 --> 00:34:16,620
但是，請記住... >> [學生]：哦，對不起。

466
00:34:16,620 --> 00:34:18,730
這是一個很好的點。

467
00:34:18,730 --> 00:34:24,130
你說，但我們真的希望你說的，因為我們只需要3組。

468
00:34:24,130 --> 00:34:30,159
那麼，如何 - 不，這是一個很好的例子，因為這樣你可能會說，1？

469
00:34:30,159 --> 00:34:33,370
4和1之間是什麼關係？

470
00:34:33,370 --> 00:34:36,760
好了，4 MOD 3為1。

471
00:34:36,760 --> 00:34:41,460
所以，如果你繼續，你會2。

472
00:34:41,460 --> 00:34:44,540
因此，我們有1，2，3，1，2。

473
00:34:44,540 --> 00:34:49,420
同樣，你實際上是在第5位。你知道如何說，而不是5？

474
00:34:49,420 --> 00:34:53,760
你說5 MOD 3 2。

475
00:34:53,760 --> 00:34:59,100
我想看看多少個組，每組3遺留下來的，然後為了我

476
00:34:59,100 --> 00:35:02,860
這樣的話，如果我們繼續沿著整個房間，

477
00:35:02,860 --> 00:35:07,760
然後我們會看到，我們一直在實際應用對自己的MOD功能

478
00:35:07,760 --> 00:35:09,990
種數。

479
00:35:09,990 --> 00:35:14,490
這是一個更多樣的實實在在的例子，你可能會使用模

480
00:35:14,490 --> 00:35:17,960
因為我敢肯定，大多數人可能都經歷這個過程中

481
00:35:17,960 --> 00:35:19,630
我們不得不計算。

482
00:35:19,630 --> 00:35:21,840
上模有任何疑問？

483
00:35:21,840 --> 00:35:25,360
了解的概念，這將是非常重要的，

484
00:35:25,360 --> 00:35:28,640
所以我想，以確保你們明白。

485
00:35:28,640 --> 00:35:34,660
[學生]如果沒有餘數，它給你的實際數目？

486
00:35:34,660 --> 00:35:40,430
如果其中的第3，他們已經做到了，這給了他們，他們實際上是什麼，

487
00:35:40,430 --> 00:35:43,310
或將它已經給了他們聽不見] >>這是一個很好的問題。

488
00:35:43,310 --> 00:35:48,750
如果沒有剩餘的模 - 所以說，你有6個模3  - 

489
00:35:48,750 --> 00:35:52,340
給你回0。

490
00:35:53,670 --> 00:35:57,290
我們將談論了一下後。

491
00:35:58,810 --> 00:36:07,720
哦，是的，例如，第三人 -  3模3實際上是0，但她說3。

492
00:36:07,720 --> 00:36:14,900
所以，這有點像一個內層的catch，例如，

493
00:36:14,900 --> 00:36:17,620
像好吧，如果MOD為0，那麼我將是第三人。

494
00:36:17,620 --> 00:36:22,740
但是，我們就會陷入一種我們可能會想如何處理是什麼0後。

495
00:36:22,740 --> 00:36:32,750
所以，現在我們有某種正面的方式映射到正確的字母與zed。

496
00:36:32,750 --> 00:36:34,920
所以，現在，我們已經討論了通過這些例子，

497
00:36:34,920 --> 00:36:37,880
我們種凱撒如何可能的工作。

498
00:36:37,880 --> 00:36:42,640
您看到的字母，然後你看到他們轉移。

499
00:36:42,640 --> 00:36:44,430
所以，讓我們試著表達式。

500
00:36:44,430 --> 00:36:46,940
這個公式實際上是在規範中給你，

501
00:36:46,940 --> 00:36:52,070
但還是讓我們通過每一個變量意味著什麼？樣的期待。

502
00:36:52,070 --> 00:36:55,000
我們的最終結果將是密文。

503
00:36:55,000 --> 00:36:58,300
因此，這表示，在第i個字符的密文

504
00:36:58,300 --> 00:37:02,500
將對應的第i個字符的明文。

505
00:37:02,500 --> 00:37:08,130
這是有道理的，因為我們總是要排隊的這些東西。

506
00:37:08,130 --> 00:37:13,480
因此，它是第i個字符的密文加K，這是我們的關鍵 - 

507
00:37:13,480 --> 00:37:17,230
這是有道理的 - 然後我們有這個mod 26。

508
00:37:17,230 --> 00:37:19,860
記得當我們有ZED

509
00:37:19,860 --> 00:37:24,190
我們不希望進入的字符，所以我們希望國防部

510
00:37:24,190 --> 00:37:26,540
種環繞的字母。

511
00:37:26,540 --> 00:37:33,430
後ZED你會去一個，B，C，D，直到你得到了正確的號碼。

512
00:37:33,430 --> 00:37:44,690
因此，我們知道，ZED，+ 6，會給我們f，ZED來，因為在A，B，C，D，E，f。

513
00:37:44,690 --> 00:37:52,530
因此，讓我們記住我們知道，可以肯定的是ZED +將會給我們f。

514
00:37:52,530 --> 00:38:03,530
在ASCII值，z為122，，f是102。

515
00:38:03,530 --> 00:38:10,570
因此，我們必須找到某種方式，使我們的凱撒公式給我們102

516
00:38:10,570 --> 00:38:13,590
後在122。

517
00:38:13,590 --> 00:38:19,550
因此，如果我們只是套用這個公式，（'Z'+ 6）26％，這實際上給你24

518
00:38:19,550 --> 00:38:25,980
因為122 + 128; 1​​28％26為您提供了24餘數。

519
00:38:25,980 --> 00:38:29,140
但是，這並不真正意味著F。這絕對不是102。

520
00:38:29,140 --> 00:38:33,590
這也是不是字母在字母表中的第6。

521
00:38:33,590 --> 00:38:41,550
所以，很顯然，我們需要有某種方式的調整這一點點。

522
00:38:42,970 --> 00:38:51,340
在常規字母，我們知道，z是26日的信，和f是第六屆。

523
00:38:51,340 --> 00:38:55,460
但是，我們在計算機科學，所以我們要去指數在0。

524
00:38:55,460 --> 00:39:00,690
這樣的話，而不是z為26號，我們會說這是25號

525
00:39:00,690 --> 00:39:02,630
因為a是0。

526
00:39:02,630 --> 00:39:04,770
現在讓我們套用這個公式。

527
00:39:04,770 --> 00:39:11,710
我們有z為代表的25 +，它給你31。

528
00:39:11,710 --> 00:39:15,790
31 MOD 26給你5餘數。

529
00:39:15,790 --> 00:39:20,500
這是完美的，因為我們知道f是第5個字母在字母表中。

530
00:39:20,500 --> 00:39:26,400
但它仍然是F，對不對？它仍然是102。

531
00:39:26,400 --> 00:39:32,730
那麼這pset中，是一個挑戰將試圖找出的關係

532
00:39:32,730 --> 00:39:36,910
之間的轉換之間的ASCII值，按字母順序排列的索引。

533
00:39:36,910 --> 00:39:40,280
從本質上講，你會想要做什麼，你想開始的ASCII值，

534
00:39:40,280 --> 00:39:45,390
但你要以某種方式翻譯成一個按字母順序排列的索引

535
00:39:45,390 --> 00:39:52,610
然後計算出它應該是什麼字母 - 基本上，其按字母順序排列的索引是什麼

536
00:39:52,610 --> 00:39:57,660
的密碼字符 - 翻譯，後面的ASCII值。

537
00:39:57,660 --> 00:40:04,870
所以，如果你掀起你的ASCII表，然後嘗試和發現之間的關係，比方說，102和5

538
00:40:04,870 --> 00:40:10,440
或122個和25個。

539
00:40:12,140 --> 00:40:15,690
我們已經得到了我們的主要的命令行參數，我們得到的明文，

540
00:40:15,690 --> 00:40:17,520
我們已經加密了。

541
00:40:17,520 --> 00:40:19,820
現在，我們剩下要做的就是打印出來。

542
00:40:19,820 --> 00:40:22,040
一對夫婦不同的方式，我們能做到這一點。

543
00:40:22,040 --> 00:40:24,570
我們可以做的其實是打印的，因為我們走。

544
00:40:24,570 --> 00:40:28,250
當我們遍歷字符串中的字符，

545
00:40:28,250 --> 00:40:31,660
我們可以簡單地只打印正確的，那麼當我們計算它。

546
00:40:31,660 --> 00:40:36,030
或者，您也可以將其存儲在數組中，有一個字符數組

547
00:40:36,030 --> 00:40:39,280
和迭代結束時，整個數組，並打印出來。

548
00:40:39,280 --> 00:40:40,980
所以，你的選項，有一對夫婦。

549
00:40:40,980 --> 00:40:47,280
請記住，％c是將要打印字符的佔位符。

550
00:40:47,280 --> 00:40:50,420
因此，我們有凱撒，現在我們轉移到維瓊內爾，

551
00:40:50,420 --> 00:40:57,580
這是非常相似，凱撒只是稍微複雜一些。

552
00:40:57,580 --> 00:41:03,310
所以基本上與維瓊內爾的，你要通過一個關鍵字。

553
00:41:03,310 --> 00:41:06,510
因此，而不是一個數字，你將有一個字符串，

554
00:41:06,510 --> 00:41:09,200
等，將作為您的關鍵字。

555
00:41:09,200 --> 00:41:14,440
然後，像往常一樣，你會得到一個提示用戶的字符串

556
00:41:14,440 --> 00:41:19,050
然後加密被它然後給他們的密文回。

557
00:41:19,050 --> 00:41:24,650
所以我說，這是非常類似的凱撒，除了沒有移位了一定的數量，

558
00:41:24,650 --> 00:41:30,620
數實際上是要改變每一個角色對角色的。

559
00:41:30,620 --> 00:41:34,890
代表的實際數量轉移，它代表的字母鍵盤。

560
00:41:34,890 --> 00:41:43,150
所以，如果你在一個移位，例如輸入的，那麼這將對應於0的移位。

561
00:41:43,150 --> 00:41:45,900
因此，它再次返回按字母順序排列的索引。

562
00:41:45,900 --> 00:41:49,100
什麼可能是有用的，如果你看到的，我們實際上是在處理與ASCII值

563
00:41:49,100 --> 00:41:51,790
以及字母，以及按字母順序排列的索引，

564
00:41:51,790 --> 00:41:58,020
也許找到或製作自己的ASCII表顯示按字母順序排列的索引從0到25，

565
00:41:58,020 --> 00:42:03,750
a到z的ASCII值，所以你可以看到種的關係

566
00:42:03,750 --> 00:42:07,020
並勾畫出和嘗試，並找到了一些模式。

567
00:42:07,020 --> 00:42:11,010
同樣，如果您正在發生轉變在一定的情況下，由f  - 

568
00:42:11,010 --> 00:42:21,110
這可以是小寫或大寫的F  - 那將對應5。

569
00:42:21,110 --> 00:42:24,180
我們好為止嗎？

570
00:42:25,770 --> 00:42:30,050
其計算公式為維瓊內爾是一個有點不同。

571
00:42:30,050 --> 00:42:32,960
基本上，你看，它只是像凱撒，

572
00:42:32,960 --> 00:42:37,390
除了恰為k，而不是我們有k個指標j。

573
00:42:37,390 --> 00:42:44,810
請注意，我們不會使用我，因為基本上，關鍵字的長度

574
00:42:44,810 --> 00:42:49,850
不一定是我們的密文的長度。

575
00:42:49,850 --> 00:42:56,130
這將是一個更清楚一點，當我們看到一個例子，我有位以後。

576
00:42:56,130 --> 00:43:03,160
基本上，如果你運行你的程序的關鍵字，ohai，

577
00:43:03,160 --> 00:43:08,560
那麼，這意味著，每一次，，ohai是要成為你的轉變。

578
00:43:08,560 --> 00:43:11,060
因此，這取決於你在什麼位置，在您的關鍵字，

579
00:43:11,060 --> 00:43:15,800
你要改變你的某些密文字符由該金額。

580
00:43:15,800 --> 00:43:19,630
同樣，就像愷撒，我們要確保我們保持資本化的東西

581
00:43:19,630 --> 00:43:22,900
我們只加密器字母，而不是字符或空格。

582
00:43:22,900 --> 00:43:26,330
所以，回頭給該撒，你可能已經使用的功能，

583
00:43:26,330 --> 00:43:32,570
的方式，你決定如何轉移的東西，它應用到你的程序在這裡。

584
00:43:32,570 --> 00:43:35,260
因此，讓我們的地圖了這一點。

585
00:43:35,260 --> 00:43:39,680
我們有明文，我們已經得到用戶的GetString

586
00:43:39,680 --> 00:43:44,090
說這句話的...是CS50！

587
00:43:44,090 --> 00:43:47,090
然後我們有一個關鍵字ohai。

588
00:43:47,090 --> 00:43:50,930
前4個字符是非常簡單的。

589
00:43:50,930 --> 00:43:55,580
我們知道，T是將要由o偏移，

590
00:43:55,580 --> 00:44:01,990
那麼h將被移位由h，i的要被移位了。

591
00:44:01,990 --> 00:44:04,610
這裡你可以看到一個為0，

592
00:44:04,610 --> 00:44:11,940
這樣的話實際上是相同的字母前的終值。

593
00:44:11,940 --> 00:44:15,250
然後，s是由i偏移。

594
00:44:15,250 --> 00:44:19,370
不過，你有這些時期在這裡。

595
00:44:19,370 --> 00:44:25,960
我們不希望來加密，那麼我們不改變它的任何東西

596
00:44:25,960 --> 00:44:31,280
只是打印出期間保持不變。

597
00:44:31,280 --> 00:44:38,020
[學生]我不明白你怎麼知道這是移 - 你在哪裡 - “”哦，對不起。

598
00:44:38,020 --> 00:44:41,620
在頂部在這裡你看到的命令行參數ohai在這裡，

599
00:44:41,620 --> 00:44:43,740
那將是關鍵字。

600
00:44:43,740 --> 00:44:49,550
所以基本上，你騎自行車在字符的關鍵字。

601
00:44:49,550 --> 00:44:52,020
[學生]等將被轉移 - 

602
00:44:52,020 --> 00:44:56,260
因此，O對應字母表中到一定的數量。

603
00:44:56,260 --> 00:44:58,400
[學生]。但是，你在哪裡得到了CS50部分？

604
00:44:58,400 --> 00:45:02,540
哦。這是在GetString的，在那裡你會說，“給我一個字符串進行編碼。”

605
00:45:02,540 --> 00:45:07,510
[學生]他們打算給你這樣的說法轉移的

606
00:45:07,510 --> 00:45:09,380
然後你會問你的第一個字符串。 >>呀。

607
00:45:09,380 --> 00:45:12,440
所以，當他們運行的程序，他們要包含關鍵字

608
00:45:12,440 --> 00:45:14,740
在其命令行參數時，運行它。

609
00:45:14,740 --> 00:45:19,740
然後，一旦你已經檢查了，他們實際上已經給你，而不是更多，而不是更少，

610
00:45:19,740 --> 00:45:23,750
然後你要促使他們為一個字符串，說：“給我一個字符串。”

611
00:45:23,750 --> 00:45:27,630
所以，在這種情況下，他們已經給了你這...是CS50！

612
00:45:27,630 --> 00:45:32,090
那麼你要使用，使用ohai和遍歷。

613
00:45:32,090 --> 00:45:38,200
請注意，這裡我們跳過了加密期間，

614
00:45:38,200 --> 00:45:51,660
但在ohai，下一個我們的立場，我們用O。

615
00:45:51,660 --> 00:45:54,990
在這種情況下，這是一個有點難以看到，因為這是4，

616
00:45:54,990 --> 00:45:57,710
讓我們繼續位。只要堅持，我在這裡。

617
00:45:57,710 --> 00:46:02,960
然後，我們有i和s，然後將其由o和h分別翻譯。

618
00:46:02,960 --> 00:46:09,370
然後我們有一個空間，這樣的話，我們知道，我們是不會來加密空間。

619
00:46:09,370 --> 00:46:18,930
但是請注意，而不是去一個在這個地方，在這裡，

620
00:46:18,930 --> 00:46:28,330
我們加密的 - 我不知道，如果你能看到 - 就在這裡。

621
00:46:28,330 --> 00:46:33,710
因此，它不喜歡你實際上是預定的，說，O都在這裡，H這裡，

622
00:46:33,710 --> 00:46:39,200
一個在這裡，我在這裡，H，O，A，I，O，H，A，I。你不這樣做。

623
00:46:39,200 --> 00:46:43,760
你只能改變你的位置的關鍵字

624
00:46:43,760 --> 00:46:51,020
當你知道你將要加密一個實際的信。

625
00:46:51,020 --> 00:46:53,920
請問那種有意義嗎？

626
00:46:53,920 --> 00:46:55,800
好吧。

627
00:46:56,490 --> 00:46:58,500
因此，只要一些提醒。

628
00:46:58,500 --> 00:47:03,760
你要確保你只在您的關鍵字前進到下一個字母

629
00:47:03,760 --> 00:47:06,390
如果您的明文中的字符是字母。

630
00:47:06,390 --> 00:47:09,120
所以說，我們在鄰。

631
00:47:09,120 --> 00:47:19,310
我們注意到，下一個字符，i索引的明文，是一個數字，例如。

632
00:47:19,310 --> 00:47:31,630
然後，我們不推進J，我們的關鍵字的索引，直到我們達到另一封信。

633
00:47:31,630 --> 00:47:36,230
同樣，你也想開始的關鍵字，以確保您概括的

634
00:47:36,230 --> 00:47:37,770
當你在它的結束。

635
00:47:37,770 --> 00:47:42,030
如果你看到這裡，我們是在我，下一個是O。

636
00:47:42,030 --> 00:47:47,690
所以，你要找到一些能夠概括的方式開始您的關鍵字

637
00:47:47,690 --> 00:47:49,470
每次你到達終點。

638
00:47:49,470 --> 00:47:55,040
如此反复，什麼樣的運營商迴繞在這種情況下是有用的嗎？

639
00:47:56,630 --> 00:47:59,840
例如關閉計數一樣。

640
00:47:59,840 --> 00:48:03,710
[學生]百分號。 “是啊，百分號，這是模。

641
00:48:03,710 --> 00:48:11,250
因此，模將在這裡派上用場，當你想換您的ohai在索引中。

642
00:48:11,250 --> 00:48:17,700
只是一個快速提示：嘗試認為有點像計數包裝過的關鍵字，

643
00:48:17,700 --> 00:48:23,590
在那裡，如果有3組，第4人，

644
00:48:23,590 --> 00:48:30,610
他們的人數，他們說的是4 MOD，這是1。

645
00:48:30,610 --> 00:48:32,880
因此，嘗試，並認為這樣的說法。

646
00:48:34,770 --> 00:48:42,740
正如您所看到的配方，只要您有詞，然後PI，然後KJ，

647
00:48:42,740 --> 00:48:44,700
你想，一定要保持跟踪這些。

648
00:48:44,700 --> 00:48:47,580
你不需要我打電話給它，你不需要把它稱為Ĵ，

649
00:48:47,580 --> 00:48:53,270
但你要確保你跟踪你的位置，在您的明文

650
00:48:53,270 --> 00:48:55,790
以及你的位置在您的關鍵字

651
00:48:55,790 --> 00:48:59,840
因為那些不一定是相同的。

652
00:48:59,840 --> 00:49:06,400
不僅關鍵字 - 它可能是一個完全不同的長度比你的明文。

653
00:49:06,400 --> 00:49:09,140
此外，您的明文，有數字和字符，

654
00:49:09,140 --> 00:49:14,450
所以它不會完全匹配起來。是。

655
00:49:14,450 --> 00:49:19,280
[學生]有一個功能改變的情況下？

656
00:49:19,280 --> 00:49:24,530
你可以改變一個大寫字母A？是啊，肯定有。

657
00:49:24,530 --> 00:49:27,890
您可以檢查出 - 我相信它的TOUPPER，所有1個字。

658
00:49:30,650 --> 00:49:36,310
但是當你試圖密的東西，保存的文本，

659
00:49:36,310 --> 00:49:39,350
這是最好的，基本上有獨立的情況下。

660
00:49:39,350 --> 00:49:42,040
如果它是一個大寫的，那麼你要轉移

661
00:49:42,040 --> 00:49:46,460
因為在公式中，當你回頭看我們如何種下去

662
00:49:46,460 --> 00:49:50,900
代表數字的ASCII方式之間交替

663
00:49:50,900 --> 00:49:55,020
與實際按字母順序排列的索引，我們要確保

664
00:49:55,020 --> 00:50:01,850
將是你要使用某種模式。

665
00:50:01,850 --> 00:50:04,580
另注上的圖案，真的。

666
00:50:04,580 --> 00:50:07,250
你一定要與數字打交道。

667
00:50:07,250 --> 00:50:11,280
盡量不要使用幻數，這是風格的一個例子。

668
00:50:11,280 --> 00:50:18,470
所以說，你想每次移動所喜歡的東西 - 

669
00:50:18,470 --> 00:50:22,400
好了，這樣的提示，另一個擾流板，當你將要轉移的東西

670
00:50:22,400 --> 00:50:26,310
通過一定量時，盡量不要代表一個實際的數字

671
00:50:26,310 --> 00:50:32,810
而是嘗試，看看你是否可以使用ASCII值，這將種更有意義。

672
00:50:32,810 --> 00:50:35,470
另注：因為我們正在處理的公式，

673
00:50:35,470 --> 00:50:41,200
即使你的TF知道你可能會使用什麼模式，

674
00:50:41,200 --> 00:50:44,430
最好在您的寶貴意見種解釋的邏輯，如，

675
00:50:44,430 --> 00:50:51,880
“我使用這種模式，因為......”一種解釋模式，簡潔地在您的寶貴意見。

676
00:50:54,090 --> 00:50:58,990
[這是演練2]如果沒有其他問題，然後我就留在這兒一點點。

677
00:50:58,990 --> 00:51:04,370
祝你好運與您的pset 2：加密的到來，並感謝。

678
00:51:06,070 --> 00:51:08,620
[學生]：謝謝你。 >>謝謝。

679
00:51:09,220 --> 00:51:10,800
[媒體離線介紹]