1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] 第习题集2：黑客版

2
00:00:02,670 --> 00:00:04,910
罗布·波顿，美国哈佛大学

3
00:00:04,910 --> 00:00:07,410
这是CS50。 CS50.TV

4
00:00:07,410 --> 00:00:15,770
所以，我抢。我是一个高级的柯克兰。这是我第三年TFing CS50。

5
00:00:15,770 --> 00:00:22,220
这是第一次，我们正在从传统的讲座式的部分，

6
00:00:22,220 --> 00:00:25,610
我们只是在课堂上发生了什么事，然后你们问的问题，这种审查

7
00:00:25,610 --> 00:00:32,250
现在到了很多问题为基础的，在这里我们使用空间，以及 - 

8
00:00:32,250 --> 00:00:37,410
哦，这样的想法是链接，我送你去，那么你就在我的空间。

9
00:00:37,410 --> 00:00:42,410
任何人都拥有一台笔记本电脑呢？好吧。

10
00:00:42,410 --> 00:00:47,050
因此，我们将使用这个，我们将做的问题，住在节

11
00:00:47,050 --> 00:00:50,740
和讨论，搞清楚什么是错的

12
00:00:50,740 --> 00:00:56,390
，我可能会拉你的代码，和我讨论您的想法。

13
00:00:56,390 --> 00:01:02,140
所以，有没有人有困难吗？

14
00:01:02,140 --> 00:01:07,000
您可以就在旁边聊天，我不知道我们是否还能有原因的。

15
00:01:07,000 --> 00:01:12,270
现在，像以前supersection，如果你在这个类，你知道这是什么。

16
00:01:12,270 --> 00:01:19,200
在所有的P组有将这些部分。

17
00:01:19,200 --> 00:01:22,550
因此，P-集合，规格，我想你已经看到了1组P-。

18
00:01:22,550 --> 00:01:27,400
但我们可以看看我们今天要为2组P-。

19
00:01:27,400 --> 00:01:29,460
你会看到一条条的问题。

20
00:01:29,460 --> 00:01:37,530
因此，这将是在所有的P-集合，将是一个部分的问题。

21
00:01:37,530 --> 00:01:41,340
到目前为止，我们已经表示，“考虑到这是一个练习的机会。”

22
00:01:41,340 --> 00:01:44,940
你不会被要求提交这一计划。

23
00:01:44,940 --> 00:01:48,480
我们的想法是，这些都是应该种帮助您开始使用的问题集。

24
00:01:48,480 --> 00:01:53,220
我想对黑客版，很多人都应该是新的，有趣的东西需要学习。

25
00:01:53,220 --> 00:01:58,590
他们可能不是直接适用问题集。

26
00:01:58,590 --> 00:02:01,810
而现在，我们没有您提交的，但在理论上，

27
00:02:01,810 --> 00:02:07,480
后面的习题集，您可以提交他们，这样的话你可以第

28
00:02:07,480 --> 00:02:10,380
或观看一节得到的答案，或者你可以让他们在自己的

29
00:02:10,380 --> 00:02:16,350
如果你感觉不一样，享受着我的存在。

30
00:02:16,350 --> 00:02:21,010
所以 - 我想这是第一个。

31
00:02:21,010 --> 00:02:29,280
哦。此外，根据这些条文的问题，我们也有提问的短裤。

32
00:02:29,280 --> 00:02:33,440
所以我想，从理论上讲，你应该看这些，才第，

33
00:02:33,440 --> 00:02:38,550
但它的罚款，如果你不这样做，反正我们就去了他们。

34
00:02:38,550 --> 00:02:42,590
因此，我们可以开始与这些“如何做一个while循环do-whil​​e循环从不同吗？

35
00:02:42,590 --> 00:02:46,210
如果是后者尤其有用吗？“

36
00:02:46,210 --> 00:02:49,390
因此，任何人有任何 - ？

37
00:02:49,390 --> 00:02:52,730
[学生]：do-whil​​e循环将永远都至少执行一次。

38
00:02:52,730 --> 00:03:02,950
是。所以这是其中的差别。 while循环 - 我会在这里只是做 -  while循环中，我们具备的条件

39
00:03:02,950 --> 00:03:19,760
就在这里，而一个做一段时间，你不会有一个条件，直到我们得到了这里。

40
00:03:19,760 --> 00:03:24,130
所以，当你的程序执行，并得到while循环，

41
00:03:24,130 --> 00:03:26,380
立即检查，如果条件为真。

42
00:03:26,380 --> 00:03:30,710
如果这个条件是不正确的，它会跳过整个循环。

43
00:03:30,710 --> 00:03:34,390
-whil​​e循环中，程序执行时，它得到的“。”

44
00:03:34,390 --> 00:03:37,920
在这一点上没有任何反应，只是继续执行。

45
00:03:37,920 --> 00:03:42,690
然后，当它击中“的同时，”如果条件为真时，它会循环备份并再次这样做

46
00:03:42,690 --> 00:03:46,730
和一次又一次，直到条件是不正确的，然后正好落在通过。

47
00:03:46,730 --> 00:03:50,600
因此，所不同的是，这从一开始就可以跳过。

48
00:03:50,600 --> 00:03:56,770
这必然执行一次，然后可以执行更多的时间，如果条件仍然是正确的。

49
00:03:56,770 --> 00:04:03,720
因此while循环只会做一次，或者 - 在while循环 - 我们可能不会在所有需要做的是，

50
00:04:03,720 --> 00:04:07,900
因为一旦我们得到它，如果条件为假，我们就跳过它。

51
00:04:07,900 --> 00:04:11,770
而做while循环中，我们将执行一次，一定。

52
00:04:11,770 --> 00:04:14,560
然后，当我们的条件，我们检查它是否是真还是假。

53
00:04:14,560 --> 00:04:19,790
如果这是真的，我们会再次做它，如果它是假的，我们就继续。

54
00:04:19,790 --> 00:04:24,680
因此，当后者尤其有用吗？

55
00:04:24,680 --> 00:04:31,190
所以，我可以说，在整个的4年，3年，无论

56
00:04:31,190 --> 00:04:38,780
我一直在编程，我使用了这一点，如，根据10倍。

57
00:04:38,780 --> 00:04:43,140
也可能5年，他们在CS50当我们要介绍的do-whil​​e循环。

58
00:04:43,140 --> 00:04:47,510
因此，当你使用do-whil​​e循环？

59
00:04:47,510 --> 00:04:49,510
当是 - 是吗？

60
00:04:49,510 --> 00:04:53,180
[学生]：当你试图获取用户输入的，或者是你要检查 - 

61
00:04:53,180 --> 00:04:59,700
是啊。因此，do-whil​​e循环，用户输入的是大的。

62
00:04:59,700 --> 00:05:03,160
这就是为什么习题集上的第一对夫妇，当你要问的用户，喜欢，

63
00:05:03,160 --> 00:05:08,520
“给我一个字符串，”你不能继续下去，直到你得到的字符串。

64
00:05:08,520 --> 00:05:12,980
所以你一定要问的字符串至少一次。

65
00:05:12,980 --> 00:05:16,950
但如果他们回答什么坏事，那么你需要循环回来再问。

66
00:05:16,950 --> 00:05:20,810
但以外的其他用户输入，这是非常罕见的，我遇到的情况

67
00:05:20,810 --> 00:05:27,170
在这里我要循环“至少一次”，但可能更多。

68
00:05:27,170 --> 00:05:33,370
问题或 - ？有没有人用一个do-whil​​e循环在其他地方吗？

69
00:05:33,370 --> 00:05:36,780
好吧。因此，下一个是，“这是什么未声明的标识符

70
00:05:36,780 --> 00:05:43,310
通常输出铛？“

71
00:05:43,310 --> 00:05:47,380
那么，什么样的代码，我可以写'未声明的标识符？“

72
00:05:47,380 --> 00:05:49,550
[学生]：X = 2？

73
00:05:49,550 --> 00:05:52,650
因此，我们可以尝试在这里，X = 2。

74
00:05:52,650 --> 00:06:04,830
我们将执行这个 - 哦，我没有点击它。所以，在这里我们得到 - 所有权利。

75
00:06:04,830 --> 00:06:07,100
“使用未声明的标识符x”。

76
00:06:07,100 --> 00:06:11,610
所以这是未声明的标识符，变量。

77
00:06:11,610 --> 00:06:13,910
它会频繁调用的变量标识符。

78
00:06:13,910 --> 00:06:17,300
因此，它可能不知道它实际上是一个变量，它不知道它是什么。

79
00:06:17,300 --> 00:06:19,380
所以这是一个标识符。

80
00:06:19,380 --> 00:06:26,060
那么，为什么它未申报的吗？是啊。

81
00:06:26,060 --> 00:06:32,190
所以要明确的术语，声明一个变量

82
00:06:32,190 --> 00:06:37,360
当你说“诠释x”或“串y，”不管。

83
00:06:37,360 --> 00:06:41,910
该变量的初始化或赋值的变量，

84
00:06:41,910 --> 00:06:44,510
无论何时说“X = 2”。

85
00:06:44,510 --> 00:06:52,950
因此，我们可以在不同的步骤，X，X = 2，直到 - 在这里，我们可以有一大堆的东西 - 

86
00:06:52,950 --> 00:07:00,350
但直到这一行发生，X仍然是未初始化的，但它已被宣布。

87
00:07:00,350 --> 00:07:06,760
因此，我们可以明显地做1号线，现在我们的声明和初始化。

88
00:07:06,760 --> 00:07:10,730
有问题吗？

89
00:07:10,730 --> 00:07:18,390
最后，“为什么是恺撒密码不是很安全吗？”

90
00:07:18,390 --> 00:07:23,830
因此，首先，没有人想说的恺撒密码是什么？

91
00:07:23,830 --> 00:07:28,100
[学生]：恺撒密码是你映射，你改变每一个字母，

92
00:07:28,100 --> 00:07:34,420
一定数量的字母走了过来，和移动过去，和它不是很安全，因为

93
00:07:34,420 --> 00:07:42,260
只有26个可能的选项，你只需要尝试的人，直到你得到各1。

94
00:07:42,260 --> 00:07:45,470
哦。所以，我要重复？

95
00:07:45,470 --> 00:07:51,600
恺撒密码，it's  - 我的意思是，你会与它打交道的问题，你 - 

96
00:07:51,600 --> 00:07:56,110
我想问题集，这不是对黑客版的标准版。

97
00:07:56,110 --> 00:08:01,550
因此，在标准版的问题集，你得到这样的消息：“你好，世界”

98
00:08:01,550 --> 00:08:08,410
你也有这样的数字6，你把该消息，和每个人的性格，

99
00:08:08,410 --> 00:08:11,310
你转​​动它在字母表中的6个位置。

100
00:08:11,310 --> 00:08:16,560
因此，'h'的在hello会成为H-I-j的-的k-升米 - 正。

101
00:08:16,560 --> 00:08:19,600
因此，第一个字母为N。我们做同样的事情，以e。

102
00:08:19,600 --> 00:08:23,530
如果我们有一个喜欢的，z或什么的，然后我们转回到左右至“A”。

103
00:08:23,530 --> 00:08:29,280
但每个字符得到循环后6个字符的字母，这是不是很安全

104
00:08:29,280 --> 00:08:35,440
因为有可能性有多少种方法，你可以换一个单一的字母只有26个。

105
00:08:35,440 --> 00:08:42,919
所以，你可以尝试26，据推测，足够长的消息，

106
00:08:42,919 --> 00:08:46,860
这些可能的26件事将是清晰的，

107
00:08:46,860 --> 00:08:50,300
和清晰的将是原始邮件。

108
00:08:50,300 --> 00:08:56,240
因此，它不是什么都加密的一个很好的方式。

109
00:08:56,240 --> 00:08:59,070
那些短裤无关，“是什么功能？”

110
00:08:59,070 --> 00:09:03,370
那么，什么是函数？是。

111
00:09:03,370 --> 00:09:11,640
[学生]：这就像一个单独的一段代码，你可以打电话去，然后得到返回值的任何。

112
00:09:11,640 --> 00:09:18,160
是啊。所以我会回答也回答下 - 或重复，也只是回答下一个。

113
00:09:18,160 --> 00:09:22,410
您可以使用功能，而不是只是复制和粘贴代码，并且再次。

114
00:09:22,410 --> 00:09:27,200
只要采取的代码，把它变成一个机能的，然后你就可以调用该函数

115
00:09:27,200 --> 00:09:29,870
只要你已拷贝和粘贴。

116
00:09:29,870 --> 00:09:33,350
因此，功能是有用的。

117
00:09:33,350 --> 00:09:35,860
所以，现在我们要做的实际问题。

118
00:09:35,860 --> 00:09:46,490
第一个。的第一个这样的想法是，你把它传递一个字符串，也不管 - 

119
00:09:46,490 --> 00:09:52,060
它说所有的小写？这并不是说所有的小写字母。

120
00:09:52,060 --> 00:09:57,730
因此，该消息可以是任何东西， - 哦，不。它的作用。

121
00:09:57,730 --> 00:10:01,610
“为了简单起见，你可以假设用户将只能输入小写字母和空格。”

122
00:10:01,610 --> 00:10:08,180
所以我们把它传递消息只有小写字母，然后我们轮流

123
00:10:08,180 --> 00:10:15,450
 - 我们改变资本和小写之间的字符串大小写，交流。

124
00:10:15,450 --> 00:10:22,920
所以，我们给你第二次，甚至潜入的问题，

125
00:10:22,920 --> 00:10:32,420
我们需要做的第一件事是什么？

126
00:10:32,420 --> 00:10:36,900
哦，我只要按一下呢？哦，我只是在这里点击一封电子邮件。

127
00:10:36,900 --> 00:10:42,870
因此，我们需要做的第一件事情 - 我在错误的吗？

128
00:10:42,870 --> 00:10:49,320
这是这其中的一部分吗？

129
00:10:49,320 --> 00:10:51,320
不，这是仍然在那里，虽然。

130
00:10:51,320 --> 00:10:55,160
好了，还在这里。

131
00:10:55,160 --> 00:11:03,160
现在，我们可以不承担 - ？是。在这里，我们不能想当然地认为这只是小写字母和空格。

132
00:11:03,160 --> 00:11:07,770
所以，现在，我们要处理的事实，字母可以是任何我们希望他们。

133
00:11:07,770 --> 00:11:11,910
因此，我们想要做的第一件事情是刚刚得到的消息。

134
00:11:11,910 --> 00:11:19,790
我们只需要得到一个字符串，字符串s = GetString的，没问题。

135
00:11:19,790 --> 00:11:24,890
现在这个问题，有一对夫妇的方法做这件事。

136
00:11:24,890 --> 00:11:29,840
但是，我们将要在这里使用按位运算符。

137
00:11:29,840 --> 00:11:35,280
有没有人无论是在supersection，

138
00:11:35,280 --> 00:11:37,480
什么的，不知道按位运算符是什么？

139
00:11:37,480 --> 00:11:41,710
或者它们如何与ASCII以任何方式？

140
00:11:41,710 --> 00:11:45,650
[学生]：我是不在supersection，但我知道什么是位运算符。

141
00:11:45,650 --> 00:11:49,560
好吧。于是我也没有去他们的基础知识，但我会解释

142
00:11:49,560 --> 00:11:51,830
我们将要在这里使用。

143
00:11:51,830 --> 00:11:59,680
所以'A'：大写字母A的二进制表示，这个数字是65。

144
00:11:59,680 --> 00:12:07,560
我只是去看看 -  41将是01000001。

145
00:12:07,560 --> 00:12:14,170
所以，这应该是十进制的65，所以这是二进制表示的字符大写的A

146
00:12:14,170 --> 00:12:19,440
现在，在二进制表示的字符小写'a'的

147
00:12:19,440 --> 00:12:33,350
是怎么回事，几乎是同样的事情。 -  6，是的。这是正确的。

148
00:12:33,350 --> 00:12:37,670
所以二进制大写的A，二进制小写的“。

149
00:12:37,670 --> 00:12:43,940
所以注意到之间的差异和'A'，这是单位。

150
00:12:43,940 --> 00:12:49,440
而这恰好是32位，该位代表32号。

151
00:12:49,440 --> 00:12:53,910
这是有道理的，因为A是65，“A”是97。

152
00:12:53,910 --> 00:12:56,610
它们之间的差值是32。

153
00:12:56,610 --> 00:13:03,770
所以，现在我们知道，我们可以转换，采取了从A到'A'

154
00:13:03,770 --> 00:13:09,710
按位“或”， - ，看起来像一个1。

155
00:13:09,710 --> 00:13:20,900
这是一个按位OR，和00100000，这会给我们的。“

156
00:13:20,900 --> 00:13:26,850
而且，我们可以从'a'到一个AND运算

157
00:13:26,850 --> 00:13:33,700
11，0，11111在那个地方。

158
00:13:33,700 --> 00:13:43,840
因此，这将给予我们什么'一'，但取消了单独的位，

159
00:13:43,840 --> 00:13:50,070
所以我们不得不01000001，我不知道我算。

160
00:13:50,070 --> 00:13:56,750
但这种技术的按位“或”资本为小写，

161
00:13:56,750 --> 00:14:02,080
AND运算以小写的资本是不排斥为A。

162
00:14:02,080 --> 00:14:06,510
所有的字母，K，Z与Ž，与k

163
00:14:06,510 --> 00:14:10,080
所有的人都只是要本单位不同。

164
00:14:10,080 --> 00:14:16,290
所以你可以用它来从任意小写字母的任何大写字母，反之亦然。

165
00:14:16,290 --> 00:14:26,670
好吧。所以，一个简​​单的方法得到 - 而不必

166
00:14:26,670 --> 00:14:32,170
写出任何1011111是 - 表示此数的一个简单的方法，这是不是一个

167
00:14:32,170 --> 00:14:39,710
，我去在supersection的，但符号（〜）是另一种按位运算符。

168
00:14:39,710 --> 00:14:42,520
〜做的是，它看起来位表示。

169
00:14:42,520 --> 00:14:45,630
让我们任意数量。

170
00:14:45,630 --> 00:14:53,130
这仅仅是一些二进制数，和什么〜是翻转的所有位。

171
00:14:53,130 --> 00:15:00,630
所以这是一个1，现在是0，这是一个0，现在为1，010100。

172
00:15:00,630 --> 00:15:08,320
所以，这一切〜。所以32的要数 - 摆脱了这一点 - 

173
00:15:08,320 --> 00:15:23,320
所以32的要数00100000，等〜这将是

174
00:15:23,320 --> 00:15:29,980
这个数字，在这里，我相与'一'。

175
00:15:29,980 --> 00:15:35,600
是否每个人都看到了吗？这是很常见的，比如当你想弄清楚

176
00:15:35,600 --> 00:15:40,740
后来的事，我们可能会看到，当我们想看看 - 

177
00:15:40,740 --> 00:15:44,710
我们想要的一切，每一个位组除1

178
00:15:44,710 --> 00:15:47,910
〜你会做的，我们不想设置位。

179
00:15:47,910 --> 00:15:53,090
因此，我们不希望32位集，所以我们〜32。

180
00:15:53,090 --> 00:15:57,790
好吧。因此，我们可以使用所有这些在这里。

181
00:15:57,790 --> 00:16:03,000
好，那么它的罚款，如果你不这样做，我们将慢慢地走一起，

182
00:16:03,000 --> 00:16:11,870
或步行，所以 - 通过这个。穿过。

183
00:16:11,870 --> 00:16:20,790
因此，我们有，我们希望我们的字符串，该字符串中的每个字符循环和做东西给它。

184
00:16:20,790 --> 00:16:26,710
那么，我们如何循环一个字符串？我们应该用什么呢？

185
00:16:26,710 --> 00:16:30,980
我不打算在这里做。是啊。

186
00:16:30,980 --> 00:16:42,940
所以，我有我的迭代器，他说，但我怎么知道有多少个字符的字符串？

187
00:16:42,940 --> 00:16:47,030
STRLEN（S），然后我+ +。

188
00:16:47,030 --> 00:16:49,860
所以我在这里所做的是不是最好的方式做事情。

189
00:16:49,860 --> 00:16:51,860
有谁知道为什么吗？

190
00:16:51,860 --> 00:16:55,290
因为你要检查的字符串每一次的语言。

191
00:16:55,290 --> 00:17:06,859
因此，我们将要移动的strlen，我可以说，在这里，长度= strlen的（），

192
00:17:06,859 --> 00:17:11,900
，然后我<长度，和的情况下，你没有看到它之前，

193
00:17:11,900 --> 00:17:20,410
我还可以做INT I = 0，长度= strlen的（）。

194
00:17:20,410 --> 00:17:25,010
因此，这是比较可取的，因为现在我已经限制的范围

195
00:17:25,010 --> 00:17:29,150
的可变长度只是这个'for'循环，而不是声明之前

196
00:17:29,150 --> 00:17:34,990
，它总是存在的情况下，你没赶上为什么这是很糟糕的，

197
00:17:34,990 --> 00:17:39,410
为什么原来的是坏，it's的 - 在for循环的开始。

198
00:17:39,410 --> 00:17:43,380
我检查了条件。 I <s的长度？

199
00:17:43,380 --> 00:17:46,790
所以s的长度，让我们的工作与“你好”的整个时间。

200
00:17:46,790 --> 00:17:49,670
所以，长度，H-E-L-L-O。长度为5。

201
00:17:49,670 --> 00:17:57,580
所以，我= 0，长度为5，所以我是不<5，继续循环。

202
00:17:57,580 --> 00:18:02,750
然后，我们再来一次。我们检查的条件。是我<长度你好？

203
00:18:02,750 --> 00:18:08,390
因此，让我们检查的长度你好。 H-E-L-L-O。这是5，我是不是<5，因此，我们再继续。

204
00:18:08,390 --> 00:18:13,330
因此，我们计算的，我们计数你好，每个循环迭代，

205
00:18:13,330 --> 00:18:17,380
甚至以为它永远不会改变，它总是要为5。

206
00:18:17,380 --> 00:18:22,530
所以我们只记得前面，而现在一切都更好。

207
00:18:22,530 --> 00:18:24,990
因此，遍历整个字符串。

208
00:18:24,990 --> 00:18:31,470
我们想要做的每个字符的字符串是什么？

209
00:18:31,470 --> 00:18:38,510
[学生来说，不知所云]

210
00:18:38,510 --> 00:18:47,000
是啊。所以，如果字符是字母，然后我们只是想跳过它。

211
00:18:47,000 --> 00:18:52,300
因为我们只关心字母，我们可以利用一个数字。

212
00:18:52,300 --> 00:19:10,850
那么，如何才能做到这一点呢？因此，我们的条件，因此，如果我们想要的东西 - 如果是按字母顺序排列的。

213
00:19:10,850 --> 00:19:14,060
那么，我们如何检查呢？

214
00:19:14,060 --> 00:19:18,720
[学生]：您可以只使用功能为α型。

215
00:19:18,720 --> 00:19:23,160
是，其中包括在其中任意一个，或任何的一样，char.h什么？

216
00:19:23,160 --> 00:19:32,710
让我们使用的是α功能，并使用显式的 - 所以，我们有S [I]，

217
00:19:32,710 --> 00:19:40,460
这是第八个字符的s，请记住，一个字符串是一个字符数组，

218
00:19:40,460 --> 00:19:43,180
这样的s的第八个字符。

219
00:19:43,180 --> 00:19:49,280
现在，如果它是一个大写字母，我们知道它是在一个特定的范围内。

220
00:19:49,280 --> 00:19:54,370
那是什么范围？

221
00:19:54,370 --> 00:20:07,860
是啊。因此，如果S [I]≥65，和S [I]是≤90，而不是我应该怎么办呢？

222
00:20:07,860 --> 00:20:18,470
是啊。所以，你应该绝对不会甚至不需要知道任何事情的任何ASCII值。

223
00:20:18,470 --> 00:20:25,640
千万不要以为的数字65，90，97和102，或不管它是什么。

224
00:20:25,640 --> 00:20:32,470
您不需要 -  112  - 你不需要知道那些在所有。这是不对的。

225
00:20:32,470 --> 00:20:41,940
仅使用单引号，单引号的常量。所以'A'和小于90'Z.'

226
00:20:41,940 --> 00:20:47,930
这是明显 - 我不知道，我的头顶部，Z是90。

227
00:20:47,930 --> 00:20:52,690
我知道我的头顶部，'Z'是资本Z.

228
00:20:52,690 --> 00:21:02,100
因此，只要这是在范围内的大写字母A到资本Z，我们可以检查小写字母，

229
00:21:02,100 --> 00:21:17,010
或者，如果它的范围内≥'a'和≤Z。

230
00:21:17,010 --> 00:21:19,010
所以这是我们的条件。

231
00:21:19,010 --> 00:21:22,520
把这些事情的风格各不相同。

232
00:21:22,520 --> 00:21:29,520
我会做这样的。

233
00:21:29,520 --> 00:21:31,520
现在，我们想要做的是什么呢？

234
00:21:31,520 --> 00:21:39,530
我们知道这封信是一个字符，一个字母字符。

235
00:21:39,530 --> 00:21:46,270
因此，我们需要在两者之间，是否现在应该是一个大写字母或小写字母。

236
00:21:46,270 --> 00:21:48,820
我们如何跟踪我们希望它是哪一个？

237
00:21:48,820 --> 00:21:55,520
[学生的声音，不知所云]

238
00:21:55,520 --> 00:21:59,150
所以，是的，但让我看看。

239
00:21:59,150 --> 00:22:04,910
模块0-2有人说，有人建议扔了出去，我同意。

240
00:22:04,910 --> 00:22:11,780
除另行通知，像 - 是这样的吗？是啊。

241
00:22:11,780 --> 00:22:18,270
它的每一个，但我们不能模块的我，我国防部2，自

242
00:22:18,270 --> 00:22:22,950
注意到E是资本和'A'是小写的吗？但是有一个空格分隔它们吗？

243
00:22:22,950 --> 00:22:27,150
因此，他们将是相同的模2，但他们是不同的情况。

244
00:22:27,150 --> 00:22:29,150
[学生提问，不知所云]

245
00:22:29,150 --> 00:22:34,690
是啊。因此，我们只是要保持一个计数。

246
00:22:34,690 --> 00:22:38,730
在这里，我们也可以做到这一点，如果我们想，这可能会有点笨重

247
00:22:38,730 --> 00:22:41,300
在fo​​r循环的声明，我把它在这里。

248
00:22:41,300 --> 00:22:48,840
所以，诠释计数= 0开始的。

249
00:22:48,840 --> 00:22:54,070
所以现在，我要多少个字母字符，我们已经。

250
00:22:54,070 --> 00:22:59,550
因此，我们不可避免地要数+ +，因为我们发现了另外一个英文字母。

251
00:22:59,550 --> 00:23:09,130
但是，现在你说，如果数模2。

252
00:23:09,130 --> 00:23:12,590
那么，如果数模2？哦。现在，我会做== 0。

253
00:23:12,590 --> 00:23:21,740
我们还会去。因此，如果数模2 == 0，然后呢？

254
00:23:21,740 --> 00:23:27,830
[学生回答，不知所云]

255
00:23:27,830 --> 00:23:32,750
因此，我们希望它最终大写。

256
00:23:32,750 --> 00:23:37,520
有2例，2例大写和小写字母。

257
00:23:37,520 --> 00:23:40,990
因此，如果我们在小写我们需要使其大写。

258
00:23:40,990 --> 00:23:43,710
如果是大写的，我们不需要做任何事情。

259
00:23:43,710 --> 00:23:50,760
但是，有没有办法 -  shouldn't已翻 - 

260
00:23:50,760 --> 00:23:54,800
我们甚至不需要检查它是否是大写或小写？

261
00:23:54,800 --> 00:24:02,240
我们可以做什么，一定要确保，我们总是在大写？

262
00:24:02,240 --> 00:24:07,830
所以注意到我们所做的为小写'A';如果我们这样做同样的事情，以大写A？

263
00:24:07,830 --> 00:24:11,900
是否大写的改变，还是值的变化呢？

264
00:24:11,900 --> 00:24:23,100
是啊。因此，任何大写字母相与〜32位将是相同的大写字符

265
00:24:23,100 --> 00:24:29,220
因为任何大写字符的第32位未设置。

266
00:24:29,220 --> 00:24:40,920
因此，如果我们要带来的则s [i]，我们希望它成为小写或大写字符。

267
00:24:40,920 --> 00:24:46,890
所以，如果是小写的，它是现在大写字母，如果是大写的，它仍然是大写的，这就是它。

268
00:24:46,890 --> 00:24:54,290
我说，这的supersection：您可以使用32，如果你想要，但我倾向于更喜欢做'一' -  A，

269
00:24:54,290 --> 00:25:01,150
而不是只是普通的32，因为它可以是任何其他的位。

270
00:25:01,150 --> 00:25:03,610
后32位的，也可以是其中任何一个，否则，我们将没有足够的

271
00:25:03,610 --> 00:25:05,840
数来表示所有的字符。

272
00:25:05,840 --> 00:25:09,110
因此，如果你的32位，也可能是64位的，也可能是128位。

273
00:25:09,110 --> 00:25:13,990
这些位中的任何位，区分大写和小写。

274
00:25:13,990 --> 00:25:18,350
我不应该需要知道，它是32位的。

275
00:25:18,350 --> 00:25:27,130
我可以用这个'一' - 得到位，两者之间的不同

276
00:25:27,130 --> 00:25:33,000
而不需要依靠神奇的数字是32。

277
00:25:33,000 --> 00:25:38,770
因此，现在，其他算很奇怪，所以我想要做的是什么呢？

278
00:25:38,770 --> 00:25:43,920
[学生回答，不知所云]

279
00:25:43,920 --> 00:25:45,920
[学生]：那是什么？

280
00:25:45,920 --> 00:25:49,850
我会做它在1秒。

281
00:25:49,850 --> 00:25:55,690
所以，现在如果我想 - 我想，以确保现在小写字符，

282
00:25:55,690 --> 00:26:04,140
，所以我可以或32，32，意思是“一个' -  A.

283
00:26:04,140 --> 00:26:06,510
但是，请注意，与前一个同样的道理，如果

284
00:26:06,510 --> 00:26:11,670
这封信已经是小写，然后由32“或”保持小写。

285
00:26:11,670 --> 00:26:16,220
它并没有改变原有的特色。

286
00:26:16,220 --> 00:26:19,910
但现在我不说，“如果是小写的，只是忘了，

287
00:26:19,910 --> 00:26:23,650
如果是大写字母，然后改变它。“

288
00:26:23,650 --> 00:26:26,900
这是更方便的做到这一点。

289
00:26:26,900 --> 00:26:33,190
[学生]：这一战略减去大写小写的工作，如果不是32吗？

290
00:26:33,190 --> 00:26:35,330
如果它是像，34或什么的？

291
00:26:35,330 --> 00:26:41,840
所以，你需要知道之间的差额2  - ？ >> 1位。

292
00:26:41,840 --> 00:26:49,840
它可以是1位以上，只要该位置以下的所有的比特是相同的。

293
00:26:49,840 --> 00:26:58,500
因此，我们需要至少26个字符 - 或者，有26个字符。

294
00:26:58,500 --> 00:27:04,590
因此，我们需要至少26个数字代表的不同 - 

295
00:27:04,590 --> 00:27:07,650
A和'a'的是至少26，之间的差异

296
00:27:07,650 --> 00:27:10,760
否则我们将不会代表所有的资本。

297
00:27:10,760 --> 00:27:18,630
这意味着，如果我们从1开始，它要使用所有这些位，

298
00:27:18,630 --> 00:27:23,900
所有的这些前5位，代表一切到Z

299
00:27:23,900 --> 00:27:32,170
这就是为什么下位，或该位，下位的选择区分A'和'一个是一个。“

300
00:27:32,170 --> 00:27:40,930
这也是为什么，在ASCII表中，有5个大写字母，小写字母符号分离。

301
00:27:40,930 --> 00:27:49,050
由于这些符号，额外带来32是它们之间的区别。

302
00:27:49,050 --> 00:27:51,840
[学生]：因此，我们可以这样做，因为ASCII是这样设计的。

303
00:27:51,840 --> 00:27:57,280
是。但是，ASCII  - 差异也可能是这两位。

304
00:27:57,280 --> 00:28:12,040
一样，如果A是10000001，和'a'11100001  - 我忘了，什么都好。

305
00:28:12,040 --> 00:28:18,100
但是，如果它是，那么我们仍然可以使用'A' -  A.

306
00:28:18,100 --> 00:28:22,650
这是刚才和'a'是这2位之间的差异。

307
00:28:22,650 --> 00:28:32,240
我认为这是写48。它是32 + 64？我认为它是什么？

308
00:28:32,240 --> 00:28:40,160
它仍然是2位，每一个字符一样，Z和Z，K和k，

309
00:28:40,160 --> 00:28:45,160
他们仍然有完全相同的位设置除了这2位。

310
00:28:45,160 --> 00:28:48,870
因此，只要这是真实的，不管，如果我们使用的是ASCII或其他一些系统，

311
00:28:48,870 --> 00:28:53,050
只要有唯一的一组不同的每个字符的比特数，

312
00:28:53,050 --> 00:28:55,050
然后，工作正常。

313
00:28:55,050 --> 00:29:06,110
这只是32成立，因为它是第一个，我们可能使用。 >>酷。

314
00:29:06,110 --> 00:29:14,520
我倾向于选择，如果你还没有看到，如果块是只有一行，

315
00:29:14,520 --> 00:29:24,280
你可以摆脱的花括号，所以我倾向于选择这样做。

316
00:29:24,280 --> 00:29:34,010
另外，你知道我们可以做这样的事情则s [i] + = 1？

317
00:29:34,010 --> 00:29:41,090
你也可以做的[I]位= 32。

318
00:29:41,090 --> 00:29:46,400
和按位OR = 32。

319
00:29:46,400 --> 00:29:51,490
此外，数模2 == 0。

320
00:29:51,490 --> 00:30:00,900
因此请记住 - 我不会写 - 任何非零的值是真实的，0是错误的。

321
00:30:00,900 --> 00:30:07,880
因此，“如果数模2 == 0”是一样说：“如果没有数模2。

322
00:30:07,880 --> 00:30:11,580
我可能会正好相反的线条和说，“如果数模2，

323
00:30:11,580 --> 00:30:15,350
OR 1，还有什么“与”1“，所以，我没有需要”不。“

324
00:30:15,350 --> 00:30:18,650
但是，这一样好。

325
00:30:18,650 --> 00:30:25,660
而且，我还能做什么呢？

326
00:30:25,660 --> 00:30:29,060
你可以将它们组合，如果你想与三元，但后来那只是使事情变得混乱，

327
00:30:29,060 --> 00:30:33,770
可能更难以阅读，因此，我们将无法做到这一点。

328
00:30:33,770 --> 00:30:37,330
任何人有任何其他建议吗？

329
00:30:37,330 --> 00:30:41,580
是要求所有的问题？哦，是的。

330
00:30:41,580 --> 00:30:51,070
因此，摆脱这些空行，现在我们要打印F，％s的一个字符串，

331
00:30:51,070 --> 00:30:56,620
我们将打印的F，S。

332
00:30:56,620 --> 00:30:59,330
现在，让我们来运行它。我做了什么事？

333
00:30:59,330 --> 00:31:03,200
这是一个\“，我想一个n。

334
00:31:03,200 --> 00:31:07,840
好吧。现在我们来运行它。它可能会骂我。

335
00:31:07,840 --> 00:31:11,250
STRLEN是在string.h。

336
00:31:11,250 --> 00:31:14,290
因此，这是铛是美好的事情，它告诉你它在，

337
00:31:14,290 --> 00:31:19,140
而不是GCC，只是说，“嘿，你忘了的东西，我不知道那是什么。”

338
00:31:19,140 --> 00:31:29,220
但是，这会告诉我，“你的意思是包括string.h中。”

339
00:31:29,220 --> 00:31:32,130
所以我也没有提示任何东西，所以它什么也不说。

340
00:31:32,130 --> 00:31:42,540
不过，我们会做他们的榜样，“感谢4”添加“。

341
00:31:42,540 --> 00:31:47,880
这看起来是对的。万岁。

342
00:31:47,880 --> 00:31:52,370
所以回到你的主，我几乎从来没有做到这一点。

343
00:31:52,370 --> 00:31:57,110
它是可选的。主要是它的唯一功能是可选的。

344
00:31:57,110 --> 00:32:07,140
如果你不返回任何东西，从主，假设你的意思是返回0。

345
00:32:07,140 --> 00:32:13,070
有问题吗？

346
00:32:13,070 --> 00:32:20,980
好吧。所以，现在的第二个问题。

347
00:32:20,980 --> 00:32:24,810
“回想一下从第2周的第二场演讲，交换2个变量的值传递

348
00:32:24,810 --> 00:32:30,780
这2个变量的功能（即使称为交换）不完全相同的工作，至少在没有“指针”。“

349
00:32:30,780 --> 00:32:37,020
而忽略直到我们得到的指针。

350
00:32:37,020 --> 00:32:40,070
我们要交换两个变量，我们不使用一个函数来做到这一点。

351
00:32:40,070 --> 00:32:43,410
我们仍然要做到这一点，主像它说。

352
00:32:43,410 --> 00:32:48,360
但是，使用这2个变量，我们不希望使用一个临时变量。

353
00:32:48,360 --> 00:32:50,770
有2种方法来做到这一点。

354
00:32:50,770 --> 00:32:56,310
使用传统的二元运算符，你可以这样做。

355
00:32:56,310 --> 00:33:00,180
因此，没有人知道一个快速和肮脏的方式做到这一点？

356
00:33:00,180 --> 00:33:07,650
实际上，这可能需要一分钟的思考。如果我有 - 

357
00:33:07,650 --> 00:33:12,130
我将设置问题，如他们的要求。所以，如果我有2个变量，A，这是仅仅是一个整数

358
00:33:12,130 --> 00:33:17,800
他们给了我，和变量B，这是我的另一个整数。

359
00:33:17,800 --> 00:33:22,700
所以，如果我有这2个变量，现在我要来交换他们。

360
00:33:22,700 --> 00:33:31,550
传统的，使用常规的二元运算符，我的意思是，如+， - ，÷。

361
00:33:31,550 --> 00:33:36,630
不按位运算符作用于二进制。

362
00:33:36,630 --> 00:33:39,600
因此，使用 - ，+，÷，和所有那些。

363
00:33:39,600 --> 00:33:52,980
我们可以做这样的事情交换A = A + B，和B = A  -  B，A = A  -  B。

364
00:33:52,980 --> 00:34:04,260
因此，合理性检查，然后我们将看到为什么这样的作品。

365
00:34:04,260 --> 00:34:13,320
比方说，= 7，b = 3的，则a + b时，将是10。

366
00:34:13,320 --> 00:34:18,820
因此，我们现在设置= 10，然后我们做B = A  -  B。

367
00:34:18,820 --> 00:34:30,250
因此，我们正在做的B = A  -  B，这将是7，和b =  -  B再次

368
00:34:30,250 --> 00:34:38,650
或a = A  -  B。这是会是10  -  7，它为3。

369
00:34:38,650 --> 00:34:44,850
正确，所以，现在，'a'的为7，b是3，现在b是7和'a'是3。

370
00:34:44,850 --> 00:34:48,679
因此，那种是有道理的，'a'是2号的组合。

371
00:34:48,679 --> 00:34:53,000
在这一点上，“A”的组合，然后我们减去原来的b，

372
00:34:53,000 --> 00:34:56,860
然后我们减去了什么是原来的“一”。

373
00:34:56,860 --> 00:35:01,150
但是，这并不适用于所有的数字。

374
00:35:01,150 --> 00:35:08,880
要看到这一点，让我们考虑一个系统，所以我们通常认为的32位整数。

375
00:35:08,880 --> 00:35:13,050
让我们携手的东西，只有4位。

376
00:35:13,050 --> 00:35:15,450
我希望拿出一个很好的例子，现在。

377
00:35:15,450 --> 00:35:18,680
所以，我知道，这将是容易的。

378
00:35:18,680 --> 00:35:26,720
比方说，我们的2号为1111和1111，所以我们现在是在二进制。

379
00:35:26,720 --> 00:35:34,630
在实际的小数，如果你要觉得这样的说法，A = 15，B = 15。

380
00:35:34,630 --> 00:35:37,630
因此，我们预期，我们交换后，他们 - 他们甚至必须是相同的数字，

381
00:35:37,630 --> 00:35:41,140
但我做了这样的看法。

382
00:35:41,140 --> 00:35:47,100
让我们使它们不相同的数字。让我们做1111和0001。

383
00:35:47,100 --> 00:35:51,860
因此，一个= 15和b = 1。

384
00:35:51,860 --> 00:35:57,670
我们交换之后，我们希望'一'，是1和B为15。

385
00:35:57,670 --> 00:36:01,780
因此，我们的第一步是A = A + B。

386
00:36:01,780 --> 00:36:08,770
我们的人数只有4位，所以“一”，这是1111 +，这是0001，

387
00:36:08,770 --> 00:36:16,780
即将结束为10000，但我们只有4位。

388
00:36:16,780 --> 00:36:22,540
所以，现在为a = 0。

389
00:36:22,540 --> 00:36:34,080
现在，我们要设置B = A  -  B  - 实际上，这仍然工作完美。

390
00:36:34,080 --> 00:36:39,630
A = A  -  B  - 让我们来看看，如果这个工程很完美。

391
00:36:39,630 --> 00:36:53,720
因此，然后b = 0  -  1，这将仍然是15，并且然后=  -  B，这将是1。

392
00:36:53,720 --> 00:36:56,210
也许这样做的工作。

393
00:36:56,210 --> 00:36:59,020
我觉得有一个原因，它不使用常规的工作。

394
00:36:59,020 --> 00:37:06,400
好了，这样的假设，这是行不通的，与普通的二进制运算，

395
00:37:06,400 --> 00:37:15,040
我会看 - 我将谷歌，看看是否是真实的。

396
00:37:15,040 --> 00:37:23,490
因此，我们要做到这一点使用按位运算符，和这里的线索是XOR。

397
00:37:23,490 --> 00:37:28,780
因此，引入XOR（^），如果你没有看到它。

398
00:37:28,780 --> 00:37:34,610
再次，这是位运算符，所以它的作用有点位，it's  - 

399
00:37:34,610 --> 00:37:39,910
如果您有位0和位1，那么这将是1。

400
00:37:39,910 --> 00:37:45,230
如果你有位1和0，这将是1，你的位0和0这将是0，

401
00:37:45,230 --> 00:37:47,640
，如果你有1位和第1，这将是0。

402
00:37:47,640 --> 00:37:56,180
因此，它是或。如果任一的位都为真时，它是1，但不像OR，它不能是两个位都为真。

403
00:37:56,180 --> 00:37:59,320
或将是1，XOR将是0。

404
00:37:59,320 --> 00:38:02,250
因此，我们会想使用XOR这里的。

405
00:38:02,250 --> 00:38:09,960
一分钟想想吧，我去谷歌。

406
00:38:09,960 --> 00:38:16,230
那么，你可以不读了，我目前的XOR交换算法。

407
00:38:16,230 --> 00:38:21,340
希望这将解释为什么我不能做到的 - 

408
00:38:21,340 --> 00:38:34,190
这也正是我们只是做了该算法。

409
00:38:34,190 --> 00:38:37,330
我还是不明白为什么 - 我一定只是选择了一个坏榜样，

410
00:38:37,330 --> 00:38:44,940
但这种情况下，'a'的发生成为0后，得到5位，所以现在“a”为0，

411
00:38:44,940 --> 00:38:48,730
这就是被称为“整数溢出”。

412
00:38:48,730 --> 00:38:54,370
根据维基百科，“不同的是XOR交换，这种变化需要，它采用的一些方法

413
00:38:54,370 --> 00:38:59,780
保证是x + y不会导致整数溢出。“

414
00:38:59,780 --> 00:39:08,350
因此，这确实有问题，这是整数溢出，但我做错了什么。

415
00:39:08,350 --> 00:39:10,520
我不太肯定。我会尽量拿出另一个。

416
00:39:10,520 --> 00:39:13,640
[学生]：那么，是不是整数溢出，当你试图把一些在​​那里

417
00:39:13,640 --> 00:39:16,640
大于您已经分配的比特量？

418
00:39:16,640 --> 00:39:23,730
是啊。我们有4位。 That's  - 我们有4位，然后我们尝试把它加1，所以我们结束了5位。

419
00:39:23,730 --> 00:39:26,690
但在第五位只是被切断，是的。

420
00:39:26,690 --> 00:39:28,970
它实际上可能 - 

421
00:39:28,970 --> 00:39:33,010
[学生]：那你扔一个错误，或者做什么才能 - 会抛出一个错误吗？

422
00:39:33,010 --> 00:39:40,720
号，所以有没有错误。当你得到的装配水平，一个特殊的位

423
00:39:40,720 --> 00:39:47,020
地方是说，有一个溢出，但在C你种不处理。

424
00:39:47,020 --> 00:39:55,160
实际上，你可以不处理它，除非你使用特殊的汇编指令C.

425
00:39:55,160 --> 00:39:58,110
让我们想想XOR交换。

426
00:39:58,110 --> 00:40:02,220
我认为维基百科的文章可能也一直在说 - 

427
00:40:02,220 --> 00:40:07,310
因此，它也带来了模运算，所以我想我是，从理论上讲，这样做的模块化算术

428
00:40:07,310 --> 00:40:11,160
当我说，0  -  1再次是15。

429
00:40:11,160 --> 00:40:15,410
所以，实际上可能 - 定期的处理器，它0  -  1 = 15。

430
00:40:15,410 --> 00:40:20,430
因为我们结束了，我们在0减1，所以它只是绕回大约为1111。

431
00:40:20,430 --> 00:40:28,930
因此，该算法实际工作中，在A + B，A  -  B，B  -  A，这可能是罚款。

432
00:40:28,930 --> 00:40:34,030
但还有一些处理器，不这样做，所以它不会在这些特定的罚款。

433
00:40:34,030 --> 00:40:39,880
XOR交换将处理器的限制。好吧。

434
00:40:39,880 --> 00:40:42,280
我们的想法是，它应该是一样的，虽然。

435
00:40:42,280 --> 00:40:50,120
如果我们使用XOR以某种方式获得的信息都为1的变量，

436
00:40:50,120 --> 00:40:54,120
然后拉出单个变量的信息。

437
00:40:54,120 --> 00:41:04,330
因此，任何人有想法/答案吗？

438
00:41:04,330 --> 00:41:14,540
[学生回答，不知所云]

439
00:41:14,540 --> 00:41:22,220
因此，这应该工作，而且，XOR是可交换的。

440
00:41:22,220 --> 00:41:27,620
无论2号的顺序发生在这里，

441
00:41:27,620 --> 00:41:30,100
这样的结果将是相同的。

442
00:41:30,100 --> 00:41:35,800
因此，一个^ b是B ^一。

443
00:41:35,800 --> 00:41:51,860
你可能也看到了这个写成^ = B，B ^ =，^ = B再次。

444
00:41:51,860 --> 00:42:00,200
因此，这是正确的，为什么这个工程，认为位。

445
00:42:00,200 --> 00:42:10,400
使用一个很小的数字，比方说，11001，01100。

446
00:42:10,400 --> 00:42:12,790
因此，这是'a'，这是B。

447
00:42:12,790 --> 00:42:15,540
因此，一个^ = B。

448
00:42:15,540 --> 00:42:22,380
我们要在'A'=的XOR这些东西的。

449
00:42:22,380 --> 00:42:32,920
因此，1 ^ 0 1; 1 ^ 1是0; 0 ^ 1是1，0 ^ 0是0; 1 ^ 0是1。

450
00:42:32,920 --> 00:42:37,380
所以，“一”，如果你看的十进制数，它会是 - 

451
00:42:37,380 --> 00:42:41,160
你不会看到之间的关系，原有的“a”和新的“一”，

452
00:42:41,160 --> 00:42:45,600
但看着位，'A'是现在像一个网状的信息

453
00:42:45,600 --> 00:42:49,970
原''和原来的b。

454
00:42:49,970 --> 00:42:57,930
因此，如果我们采取B ^，我们看到，我们最终会在原有的“一”。

455
00:42:57,930 --> 00:43:08,910
如果我们把原来的“一个”新的“，”我们看到，我们在原来的B。

456
00:43:08,910 --> 00:43:18,380
所以（^）^ B =原来的“一”。

457
00:43:18,380 --> 00:43:27,910
（^）^ =原来的b。

458
00:43:27,910 --> 00:43:37,010
 - 这是什么XOR本身的另一种方式是始终为0。

459
00:43:37,010 --> 00:43:45,020
所以1101 ^ 1101，所有的位都将是相同的。

460
00:43:45,020 --> 00:43:47,920
因此，永远不会是一个的情况下，其中1为0且另一方为1。

461
00:43:47,920 --> 00:43:51,080
因此，这是0000。

462
00:43:51,080 --> 00:43:57,240
与此相同的。 （^）^ b是一样^（B ^）。

463
00:43:57,240 --> 00:44:03,680
（^ B）为0; ^ 0的只是将“一”，因为所有的位都为0。

464
00:44:03,680 --> 00:44:08,050
因此，唯一的，都将是其中'A'原本是1  - 的。

465
00:44:08,050 --> 00:44:12,070
同样的想法在这里，我敢肯定，这也是交换。

466
00:44:12,070 --> 00:44:17,590
是啊。我是说在此之前，它是交换的。

467
00:44:17,590 --> 00:44:24,680
^'，'和它的关联，所以现在（B ^）^。

468
00:44:24,680 --> 00:44:28,970
我们可以做B ^（^）。

469
00:44:28,970 --> 00:44:31,540
因此，我们再次与原来的b。

470
00:44:31,540 --> 00:44:37,120
因此，“a”为现在的'a'和b的组合在一起。

471
00:44:37,120 --> 00:44:49,660
使用我们的新组合“”我们说B =组合'A'^原来的b，我们原来的'。“

472
00:44:49,660 --> 00:45:05,170
=组合'A'^新的B，这是原来的 - 这是现在什么是'A'或B。

473
00:45:05,170 --> 00:45:13,620
这种情况下，这是在这里。这是老B = B，。

474
00:45:13,620 --> 00:45:16,550
所以，现在一切都恢复的交换顺序。

475
00:45:16,550 --> 00:45:22,960
如果我们确实看着位，B = ^ B，XOR这些，

476
00:45:22,960 --> 00:45:33,920
的答案是这样的，那么A = A ^ b是异或这2个的答案是这样的。

477
00:45:33,920 --> 00:45:41,090
有问题吗？好吧。因此，最后一个是有点明显更加困难。

478
00:45:41,090 --> 00:45:43,180
[学生]：我觉得他有一个关于它的问题。哦，对不起。

479
00:45:43,180 --> 00:45:49,380
[学生]：实际上更快？如果您使用此XOR，或者是如果你声明一个新的变量？

480
00:45:49,380 --> 00:45:55,190
那么，什么是实际上是更快，声明一个新的变量或使用XOR交换？

481
00:45:55,190 --> 00:45:59,600
答案是，在所有的可能性，一个临时变量。

482
00:45:59,600 --> 00:46:05,780
这是因为一旦它的编译 - 所以在装配水平，

483
00:46:05,780 --> 00:46:12,320
有没有这样的东西作为局部变量或临时变量或任何东西。

484
00:46:12,320 --> 00:46:16,060
他们只是想 - 有记忆，有寄存器。

485
00:46:16,060 --> 00:46:20,920
寄存器里的东西都在积极发生。

486
00:46:20,920 --> 00:46:24,750
您在内存中不添加两件事情，你添加在寄存器中的两件事情。

487
00:46:24,750 --> 00:46:28,160
你带的东西从内存到寄存器中，然后将它们添加，

488
00:46:28,160 --> 00:46:33,180
然后你可能把它们放回内存，但所有的动作都发生在寄存器中。

489
00:46:33,180 --> 00:46:38,750
因此，当你使用临时变量的方法，通常会发生什么

490
00:46:38,750 --> 00:46:42,810
这些数字已经在寄存器中。

491
00:46:42,810 --> 00:46:46,570
然后，从这个角度上，在你交换他们，

492
00:46:46,570 --> 00:46:51,540
它会刚开始使用其他寄存器。

493
00:46:51,540 --> 00:46:56,510
任何地方，你一直在使用B，它会使用的寄存器，它已经存储的一个。“

494
00:46:56,510 --> 00:47:02,180
因此，它并不需要做任何事情，其实做掉。是吗？

495
00:47:02,180 --> 00:47:05,690
[学生]：但是，这也需要更多的内存，对不对？

496
00:47:05,690 --> 00:47:10,280
如果需要存储，临时变量，它只会占用更多的内存。

497
00:47:10,280 --> 00:47:14,830
就像如果你以后再次使用该临时变量的地方，

498
00:47:14,830 --> 00:47:18,920
 - 或你指定的东西，临时变量。

499
00:47:18,920 --> 00:47:24,630
因此，如果在任何点在时间'，'b在温度有不同的值或东西，

500
00:47:24,630 --> 00:47:30,680
那么它会在内存中有不同的位置，但它是真实的，

501
00:47:30,680 --> 00:47:34,800
还有很多地方将只存在于寄存器变量。

502
00:47:34,800 --> 00:47:44,370
在这种情况下，它从来没有装入内存，所以你永远不会浪费内存。

503
00:47:44,370 --> 00:47:58,620
好吧。最后一个问题是多一点。

504
00:47:58,620 --> 00:48:04,850
所以在这里，在这CS50设备，是字典。

505
00:48:04,850 --> 00:48:12,390
这样做的原因是因为[B66是一个拼写检查器，你会写？

506
00:48:12,390 --> 00:48:15,780
使用哈希表或者尝试一些数据结构。

507
00:48:15,780 --> 00:48:22,660
你要编写一个拼写检查器，你将要使用这本词典要做到这一点。

508
00:48:22,660 --> 00:48:28,280
但对于这个问题，我们只是去看看看，如果一个字在字典中。

509
00:48:28,280 --> 00:48:31,250
因此，一些数据结构中，而不是存储整个字典

510
00:48:31,250 --> 00:48:35,180
在整个文件中，然后再寻找是否有任何的拼写错误，

511
00:48:35,180 --> 00:48:38,490
我们只是想找到1个字。因此，我们可以扫描整个字典

512
00:48:38,490 --> 00:48:44,300
如果我们永远也找不到这个词在整个字典，那么它是不是在那里。

513
00:48:44,300 --> 00:48:52,150
如果我们扫描整个字典，就看见了这个词的话，我们是很好的，我们发现了它。

514
00:48:52,150 --> 00:48:56,580
它说，在这里，我们要开始寻找C的文件处理功能，

515
00:48:56,580 --> 00:48:59,930
因为我们想读的字典，

516
00:48:59,930 --> 00:49:07,680
但我会给出提示，在这里，你就应该想到的功能。

517
00:49:07,680 --> 00:49:11,510
我把它们写空间上。

518
00:49:11,510 --> 00:49:20,490
因此，主要的，你想看看是F打开，然后，不可避免地，F封闭，

519
00:49:20,490 --> 00:49:26,540
这会在你的程序的结束，和f扫描f。

520
00:49:26,540 --> 00:49:31,060
你也可以使用F读，但你可能不希望

521
00:49:31,060 --> 00:49:34,200
因为那 - 你不结束需要，。

522
00:49:34,200 --> 00:49:41,880
F扫描f是什么，你要使用扫描整个字典。

523
00:49:41,880 --> 00:49:46,370
所以，你需要编写的解决方案，只是尝试和喜欢伪代码的方式

524
00:49:46,370 --> 00:50:05,200
一个解决方案，然后我们将讨论这个问题。

525
00:50:05,200 --> 00:50:14,110
而实际上，因为我已经给你的这些，如果你去到任何终端或设备的外壳，

526
00:50:14,110 --> 00:50:18,250
我想 - 我通常是 - 如果你还没有看到，我不知道，如果你没有在课堂上，

527
00:50:18,250 --> 00:50:23,490
但是，在几乎所有功能的人，所以该名男子的网页，是非常有用的。

528
00:50:23,490 --> 00:50:27,330
所以，我能做的，喜欢的，曼F，扫描f。

529
00:50:27,330 --> 00:50:32,300
这是现在的的扫描F系列的功能的信息有关。

530
00:50:32,300 --> 00:50:37,070
我也可以做男人F，打开，那将让我的细节。

531
00:50:37,070 --> 00:50:40,750
因此，如果你知道你是什么功能，或者你正在阅读的代码

532
00:50:40,750 --> 00:50:43,000
和你看到一些功能，你会说，“这是什么做的？”

533
00:50:43,000 --> 00:50:45,280
正直的人，函数的名称。

534
00:50:45,280 --> 00:50:47,340
奇怪的例子，你可能会说有一对夫妇

535
00:50:47,340 --> 00:50:51,620
等等。男子2，函数名，或人为3，函数名，

536
00:50:51,620 --> 00:50:58,230
但你只有做到这一点，人类如果函数名不会发生在工作的第一次。

537
00:50:58,230 --> 00:51:03,010
[学生]：所以我阅读的手册页开放，但我仍然困惑于如何使用它的程序。

538
00:51:03,010 --> 00:51:06,170
好吧。很多的手册页不到有帮助的。

539
00:51:06,170 --> 00:51:08,470
如果你已经知道他们做了什么，他们更多的帮助

540
00:51:08,470 --> 00:51:12,670
然后你只需要记住的参数或东西的顺序。

541
00:51:12,670 --> 00:51:17,640
或者，他们可以给你的一般概述，但他们中的一些是非常热烈。

542
00:51:17,640 --> 00:51:22,220
如F扫描f。它为您提供了所有这些功能的信息，

543
00:51:22,220 --> 00:51:28,120
和1号线在这里发生说，“F扫描f读取的字符串或流。”

544
00:51:28,120 --> 00:51:32,360
但是，F打开。那么，我们将如何使用f？

545
00:51:32,360 --> 00:51:38,470
这个想法的一个程序，它需要做的文件I / O，

546
00:51:38,470 --> 00:51:45,070
你首先需要打开该文件，你想要做的事情，不可避免的是，

547
00:51:45,070 --> 00:51:51,220
从该文件中读的东西，他们做的东西。

548
00:51:51,220 --> 00:51:55,350
F打开是我们用什么来打开该文件。

549
00:51:55,350 --> 00:52:04,190
我们得到的东西回来，所以我们要打开的文件，它为我们提供了 - 

550
00:52:04,190 --> 00:52:11,970
在这里“/用户/共享/ dict / words中说。”

551
00:52:11,970 --> 00:52:16,740
这是我们要打开的文件，我们想打开它 - 

552
00:52:16,740 --> 00:52:21,440
我们必须明确地指定我们是否要打开它来读取或如果我们想打开它来写。

553
00:52:21,440 --> 00:52:26,490
有一对夫妇的组合之类的东西，但我们要打开阅读。

554
00:52:26,490 --> 00:52:29,380
我们希望从文件中读取。

555
00:52:29,380 --> 00:52:34,290
所以，这是什么回报呢？它返回一个文件星号（*），

556
00:52:34,290 --> 00:52:37,260
我就显示所有的变量f，所以*，

557
00:52:37,260 --> 00:52:40,840
再次，它是一个指针，但我们不希望处理指针。

558
00:52:40,840 --> 00:52:46,470
你可以认为F，F是现在要使用你的变量来表示该文件。

559
00:52:46,470 --> 00:52:49,850
所以，如果你想从文件中读取的，你看，从f。

560
00:52:49,850 --> 00:52:54,820
如果你想关闭文件，关闭F。

561
00:52:54,820 --> 00:53:00,350
因此，在程序结束时，我们不可避免地要关闭的文件，我们应该怎么办？

562
00:53:00,350 --> 00:53:06,750
我们要关闭F。

563
00:53:06,750 --> 00:53:12,600
所以，现在的最后一个文件，我们将要使用的功能是扫描F，F扫描f。

564
00:53:12,600 --> 00:53:20,930
是什么做的是，它会扫描过的文件寻找一个模式来匹配。

565
00:53:20,930 --> 00:53:39,100
在这里的手册页，我们看到的诠释f扫描f，忽略现在的返回值。

566
00:53:39,100 --> 00:53:45,230
第一个参数是文件*流，因此，我们将要通过的第一个参数为f。

567
00:53:45,230 --> 00:53:47,900
我们在F扫描。

568
00:53:47,900 --> 00:53:53,680
第二个参数是一个格式字符串。

569
00:53:53,680 --> 00:53:58,310
我会给你一个格式字符串现在。

570
00:53:58,310 --> 00:54:05,180
我认为我们碰巧说，127S \ n这是不必要的，很多。

571
00:54:05,180 --> 00:54:12,490
格式字符串是什么，这个想法是你能想到的扫描相反的打印f f。

572
00:54:12,490 --> 00:54:17,160
所以，印刷F，印刷f的也可以使用这种类型的格式参数，

573
00:54:17,160 --> 00:54:25,000
但在印刷f我们正在做的是 - 让我们来看看在同等。

574
00:54:25,000 --> 00:54:32,550
所以打印楼，其实也有f打印f，其中第一个参数为f。

575
00:54:32,550 --> 00:54:40,980
当您打印F，我们可以这样说，“打印127S \ n”，那么，如果我们把它传递了一些字符串，

576
00:54:40,980 --> 00:54:44,050
这将打印字符串，然后一个新的生产线。

577
00:54:44,050 --> 00:54:49,690
127个手段，我敢肯定，但我从来没有限制自己，

578
00:54:49,690 --> 00:54:52,470
你甚至不需要说'127'在打印F，

579
00:54:52,470 --> 00:54:57,090
但它的意思是打印前127个字符。

580
00:54:57,090 --> 00:54:59,350
因此，我敢肯定是这样的话。你可以谷歌。

581
00:54:59,350 --> 00:55:03,000
但我几乎可以肯定，这意味着在未来的一。

582
00:55:03,000 --> 00:55:08,880
因此，这是前127个字符，打印一个新行。

583
00:55:08,880 --> 00:55:14,680
F扫描F现在，而不是在看一个变量，并打印出来，

584
00:55:14,680 --> 00:55:22,620
它会看一些字符串，并将其存储到变量的模式。

585
00:55:22,620 --> 00:55:26,360
让实际使用扫描f在一个不同的实施例。

586
00:55:26,360 --> 00:55:31,670
因此，让我们说我们有一些int x = 4时，

587
00:55:31,670 --> 00:55:41,110
我们要创建一个字符串 - 要创建的字符串

588
00:55:41,110 --> 00:55:44,250
这是喜欢，这会更晚，

589
00:55:44,250 --> 00:55:49,020
的东西就像4.JPG。

590
00:55:49,020 --> 00:55:51,870
所以这可能是一个程序，你将不得不和计数器，

591
00:55:51,870 --> 00:55:56,420
总结对付我，你要保存的一组图像。

592
00:55:56,420 --> 00:56:02,430
所以，你要保存i.jpg，我是你的循环迭代。

593
00:56:02,430 --> 00:56:05,500
那么，如何才能使此字符串，JPEG？

594
00:56:05,500 --> 00:56:11,720
如果你想打印4.JPG，我们可以说，印刷F，％D.JPG，

595
00:56:11,720 --> 00:56:14,410
然后它会打印，JPEG。

596
00:56:14,410 --> 00:56:20,050
但是，如果我们要保存的字符串4.JPG，我们使用扫描f。

597
00:56:20,050 --> 00:56:30,860
所以字符串s  - 其实我们不能做到 - 字符，char类型，让我们去100。

598
00:56:30,860 --> 00:56:35,400
所以，我只是声明了一些阵列100个字符，

599
00:56:35,400 --> 00:56:39,830
而这正是我们不可避免地将要存储的JPEG中。

600
00:56:39,830 --> 00:56:47,920
因此，我们要使用扫描f，格式，我们怎么会说％D.JPG

601
00:56:47,920 --> 00:56:54,980
为了打印4.JPG，这样的格式是怎么回事是％D.JPG。

602
00:56:54,980 --> 00:57:04,020
因此，格式的是的％D.JPG，我们要替换％d是x，

603
00:57:04,020 --> 00:57:06,590
现在我们需要将该字符串存储的地方。

604
00:57:06,590 --> 00:57:12,500
我们要去的地方来存储这些字符串数组s。

605
00:57:12,500 --> 00:57:21,640
所以在这行代码，S，如果我们打印F，％s的变量s，

606
00:57:21,640 --> 00:57:26,280
它要打印4.JPG。

607
00:57:26,280 --> 00:57:38,930
所以f的扫描扫描f，f是相同的，但现在它在这个文件

608
00:57:38,930 --> 00:57:43,600
什么存储在s。

609
00:57:43,600 --> 00:57:46,160
这将是最后一个参数。

610
00:57:46,160 --> 00:57:54,170
我们要存储 - 根据格式，尝试下面的“扫描功能扫描的F系列。

611
00:57:54,170 --> 00:58:02,450
如果有任何存储的位置点，您可能会返回 - “

612
00:58:02,450 --> 00:58:12,910
不，我们可能是件好事。让我想到的第二个。

613
00:58:12,910 --> 00:58:26,350
所以扫描 -  f不的功能做，到底是什么呢？

614
00:58:26,350 --> 00:58:31,650
因此，扫描f是不会采取一个整数，做点jpg文件。

615
00:58:31,650 --> 00:58:43,490
它是怎么回事为[曼波斯]。

616
00:58:43,490 --> 00:58:49,360
保存字符串int int变量C.

617
00:58:49,360 --> 00:58:55,940
这是什么变量，这是什么功能叫什么名字？

618
00:58:55,940 --> 00:59:04,950
是。 That's  - 是的。所以我定义你之前的印刷f，

619
00:59:04,950 --> 00:59:09,820
 - 更有道理，所以我说，这是更像打印f。

620
00:59:09,820 --> 00:59:14,700
扫描f是种像打印f，但f是的打印扫描到它

621
00:59:14,700 --> 00:59:17,510
和替换变量并存储在一个字符串中。

622
00:59:17,510 --> 00:59:19,620
而不是打印的，它存储在一个字符串。

623
00:59:19,620 --> 00:59:25,070
所以，完全忽略。您仍然可以认为像印刷f格式说明符。

624
00:59:25,070 --> 00:59:34,510
所以，现在，如果我们想要做的4.JPG的事情，我们会做的印刷f，x的这个。

625
00:59:34,510 --> 00:59:38,520
所以扫描f是做什么 - 什么是你的问题又如何呢？

626
00:59:38,520 --> 00:59:40,820
[学生]：我们试图在这里做什么，我只是困惑

627
00:59:40,820 --> 00:59:43,450
与JPEG。你能解释更多的时间吗？

628
00:59:43,450 --> 00:59:52,710
因此，这是 - 这是减少到f扫描F现在希望，将比分扳成在某种方式的相应和。

629
00:59:52,710 --> 01:00:02,240
但我最初打算显示的是 - 这其实是直接相关的这些[？ F5]

630
01:00:02,240 --> 01:00:08,520
你将要使用的印刷f，在那里，说我们有100个图像，

631
01:00:08,520 --> 01:00:13,630
和你想读的图像1.JPG 2.JPG，3.JPG。

632
01:00:13,630 --> 01:00:21,520
因此，为了做到这一点，你需要f开，然后你要传递的字符串，你要打开。

633
01:00:21,520 --> 01:00:30,020
因此，我们想打开的1.JPG;为了创建的字符串是1.JPG

634
01:00:30,020 --> 01:00:37,660
我们做的印刷f的％D.JPG，我们没有为int i = 0。

635
01:00:37,660 --> 01:00:46,580
我40岁时，我+ +。

636
01:00:46,580 --> 01:00:51,130
所以的印刷的F％D.JPG的我。

637
01:00:51,130 --> 01:00:56,320
因此，此行后，变量或数组s要1.JPG。

638
01:00:56,320 --> 01:01:10,610
或者，0.JPG，1.JPG 2.JPG。因此，我们可以打开，阅读，每幅图像。

639
01:01:10,610 --> 01:01:19,550
所以这是的打印f做。你看什么的打印f是现在做的吗？

640
01:01:19,550 --> 01:01:25,720
[学生]：好了，所以它 - 它创建了一个字符串，something.jpg，然后将它保存下来。

641
01:01:25,720 --> 01:01:30,360
是。它创造 - 这是另一种格式的字符串，就像扫描f和印刷f，

642
01:01:30,360 --> 01:01:37,530
将所有的变量的第二个参数，可能是s，而不是我。

643
01:01:37,530 --> 01:01:42,280
也许 - 我的意思是，那样的话。但是，无论是参数的顺序。

644
01:01:42,280 --> 01:01:45,440
这将插入到的格式字符串中的所有变量

645
01:01:45,440 --> 01:01:52,250
然后将其存储到我们的缓冲区，我们称之为是一个缓冲区，它就是我们要存储的字符串。

646
01:01:52,250 --> 01:02:00,750
所以，我们将存储在s的正确格式的字符串，％d的有4个被替换。

647
01:02:00,750 --> 01:02:08,080
[学生]：所以，如果我们这样做，是要被重新分配的变量f？

648
01:02:08,080 --> 01:02:18,110
是。因此，在这样做之前，我们应该关闭原来的F。

649
01:02:18,110 --> 01:02:22,810
但是 - 再还，如果有一个F打开这里，那么我们就需要说 - 

650
01:02:22,810 --> 01:02:29,280
是啊。但是，它会打开一个100个不同的文件。

651
01:02:29,280 --> 01:02:37,360
[学生]：但是，我们将不能够访问或 - 好吧。

652
01:02:37,360 --> 01:02:44,230
好吧。因此，扫描扫描楼F，F是一种同样的想法，

653
01:02:44,230 --> 01:02:53,610
而是，而不是将其存储到一个字符串，它更像是你现在

654
01:02:53,610 --> 01:03:02,420
超过刺痛，针对该字符串模式匹配的结果存储到变量。

655
01:03:02,420 --> 01:03:11,290
您可以使用扫描的f来解析过类似4.JPG，和存储的整数总和诠释x 4成。

656
01:03:11,290 --> 01:03:13,430
这就是我们可以使用扫描的f。

657
01:03:13,430 --> 01:03:16,300
F扫描f是在命令行中要做到这一点。

658
01:03:16,300 --> 01:03:19,200
实际上，我敢肯定，这是什么CS50库。

659
01:03:19,200 --> 01:03:29,050
所以，当你说“诠释，”它的扫描F-OVER  - 扫描f是您获取用户输入的方式。

660
01:03:29,050 --> 01:03:34,670
F扫描f是打算做同样的事情，但使用扫描过的文件。

661
01:03:34,670 --> 01:03:41,090
所以在这里，我们对这个文件进行扫描。

662
01:03:41,090 --> 01:03:45,460
我们要匹配的模式是一些字符串的长度为127个字符

663
01:03:45,460 --> 01:03:48,100
其次是一个新行

664
01:03:48,100 --> 01:03:54,770
所以，我敢肯定，我们甚至可以说：“匹配小号”，因为在字典中

665
01:03:54,770 --> 01:03:57,770
我们正好有没有字，我们保证的是，长期，

666
01:03:57,770 --> 01:04:03,310
也F扫描f，我认为，在新的生产线停止，无论什么。

667
01:04:03,310 --> 01:04:06,970
但在比赛中，我们将包括新的生产线，并 - 

668
01:04:06,970 --> 01:04:13,960
[学生]：如果我们不包括新的生产线，将它找到一个词的部分吗？

669
01:04:13,960 --> 01:04:22,900
 - 每个 - 在字典 - 

670
01:04:22,900 --> 01:04:26,200
因此，在字典中，这些都是我们的话。

671
01:04:26,200 --> 01:04:30,500
每个人在新的一行。

672
01:04:30,500 --> 01:04:32,510
扫描f是要拿起这个词。

673
01:04:32,510 --> 01:04:38,750
如果我们不包括新的生产线，那么它有可能是在下一次扫描的f将只读取新的线。

674
01:04:38,750 --> 01:04:44,180
但是，包括新的生产线，然后会忽略新的生产线。

675
01:04:44,180 --> 01:04:49,440
但我们永远不会得到一个字的一部分，因为我们一直在阅读了一个新的行，不管是什么。

676
01:04:49,440 --> 01:04:54,530
[学生]：但是，如果你搜索的单词“CISSA，”像CISSA。

677
01:04:54,530 --> 01:04:57,380
它会发现，并说这是一场比赛吗？

678
01:04:57,380 --> 01:05:05,110
所以，我们在这里 - 它会读出 - 这其实是一个很好的点。

679
01:05:05,110 --> 01:05:10,660
我们从来没有使用电流 - 这个词，我们要寻找的是第一个命令行参数。

680
01:05:10,660 --> 01:05:16,460
因此，单词的字符串，= ARGV 1。

681
01:05:16,460 --> 01:05:20,020
因此，我们正在寻找的字符串是：ARGV 1。

682
01:05:20,020 --> 01:05:23,290
我们是不是在找一个字都在我们的扫描f。

683
01:05:23,290 --> 01:05:28,030
我们在做什么用扫描f在字典中的每一个字，

684
01:05:28,030 --> 01:05:34,320
然后，一旦我们有这个词，我们要使用strcmp来比较他们。

685
01:05:34,320 --> 01:05:39,210
我们要比较的话，我们刚刚读入

686
01:05:39,210 --> 01:05:45,110
因此不可避免地，我们要结束了做了一堆扫描FS

687
01:05:45,110 --> 01:05:52,130
直到它碰巧的是，扫描f将返回 - 

688
01:05:52,130 --> 01:05:54,800
它会返回一个，只要它匹配了一个新词，

689
01:05:54,800 --> 01:06:01,360
将尽快返回别的东西，因为它并没有相匹配的单词。

690
01:06:01,360 --> 01:06:08,440
我们正在阅读在整个字典中，一行一行的每一个字存储到变量s。

691
01:06:08,440 --> 01:06:17,240
然后，我们比较单词与s，并且如果比较== 0，

692
01:06:17,240 --> 01:06:21,650
strcmp的发生，使0，如果一个匹配。

693
01:06:21,650 --> 01:06:31,510
所以，如果是0，那么我们可以打印楼匹配，

694
01:06:31,510 --> 01:06:35,370
或字的字典，或任何你想要打印f。

695
01:06:35,370 --> 01:06:41,450
然后 - 我们不想，F关闭一遍又一遍。

696
01:06:41,450 --> 01:06:50,410
这是我们想要做什么样的事情，我们不只是寻找在字典中的字。

697
01:06:50,410 --> 01:06:56,660
因此，我们可以做到这一点，如果我们想看看他们的模式，CISSA，像你说的之前，

698
01:06:56,660 --> 01:07:00,260
如果我们想看看该模式，然后它会失败的情况下

699
01:07:00,260 --> 01:07:08,010
因为实际上，这不是一个字，但发生在字典中的一个的话，在。

700
01:07:08,010 --> 01:07:13,560
因此，这将匹配这个词，但这个子集的字是不是这个词本身。

701
01:07:13,560 --> 01:07:17,250
但是，这不是我们如何使用它，我们正在阅读的每个字

702
01:07:17,250 --> 01:07:19,740
然后比较这个词，我们有这个词。

703
01:07:19,740 --> 01:07:25,780
因此，我们总是比较完整的单词。

704
01:07:25,780 --> 01:07:29,620
我可以给的最终解决方案。

705
01:07:29,620 --> 01:07:32,050
这是一种接近正确的答案，我想。

706
01:07:32,050 --> 01:07:34,720
[学生意见，不知所云]

707
01:07:34,720 --> 01:07:40,870
哦，我摆脱了这一点吗？字符，我想我们说的127  - 我忘了什么最大的是。

708
01:07:40,870 --> 01:07:44,100
我们就做128，现在s是足够长的时间。

709
01:07:44,100 --> 01:07:46,570
我们并不需要打印出任何东西。

710
01:07:46,570 --> 01:07:56,440
我们也将要关闭的文件，而且应该是正确的答案。

711
01:07:56,440 --> 01:07:59,440
CS50.TV