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
[媒体离线介绍]