1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] Раздел проблеме Set 2: Hacker издание

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
Так вот, я Роб. Я старший в Kirkland. Это мой третий год 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-набор 2, спецификации, я думаю, вы видели это на P-1 уже множество.

18
00:01:22,550 --> 00:01:27,400
Но мы можем посмотреть на P-комплект 2 за то, что мы собираемся идти на сегодня.

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
Я думаю, на Hacker издание, многие из них должны быть просто новые, интересные вещи, чтобы учиться.

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
Таким образом, мы можем начать с этим: «Как в то время как цикл отличается от сделай то время как цикл?

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
[Студент] сделай то время как цикл будет всегда выполнять по крайней мере, один раз.

38
00:02:52,730 --> 00:03:02,950
Да. Так что есть разница. Время цикла - I'll просто сделать это здесь - в то время как петля, имеем условие

39
00:03:02,950 --> 00:03:19,760
прямо здесь, в то время как сделай то время как, у вас нет условий пока мы не получим здесь.

40
00:03:19,760 --> 00:03:24,130
И поэтому, когда ваши программы выполняется, и он попадает в то время как цикл,

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
Сделай то время как цикл, так как программа выполняется, он добирается до "делать".

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
Таким образом, в то время как цикл будет делать это только один раз, или - в то время как петли - мы не должны делать это на всех,

50
00:04:03,720 --> 00:04:07,900
поскольку, как только мы доберемся до него, если условие ложно, мы просто сразу перейти на него.

51
00:04:07,900 --> 00:04:11,770
Принимая во внимание, сделай то время как цикл, мы будем выполнять его один раз, обязательно.

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, когда мы представляем делать, в то время как петли.

58
00:04:43,140 --> 00:04:47,510
Поэтому, когда вы использовали делать-то время петли?

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
Да. Так что, в то время как петли, что вводит пользователь, большой.

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
Вопросы или -? Кто-нибудь использовал сделай то время как цикл где-нибудь еще?

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
[Студент], что х = 2?

73
00:05:49,550 --> 00:05:52,650
Так что мы можем только попробовать его здесь, х = 2.

74
00:05:52,650 --> 00:06:04,830
Мы будем работать это - ой, я не щелкните по нему. И вот мы получаем - все в порядке.

75
00:06:04,830 --> 00:06:07,100
"Использование необъявленных х идентификатор".

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
это когда вы говорите "Int х", или "у строки," что угодно.

83
00:06:37,360 --> 00:06:41,910
Инициализации переменной или назначение переменной,

84
00:06:41,910 --> 00:06:44,510
это всякий раз, когда вы говорите "х = 2".

85
00:06:44,510 --> 00:06:52,950
Таким образом, мы можем сделать это в отдельных шагов, Int х, х = 2, а пока - мы можем иметь кучу вещей здесь -

86
00:06:52,950 --> 00:07:00,350
но до этой линии происходит, х еще не инициализирована, но она была объявлена.

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
[Студент] Caesar Cipher только то, что Вы карте, вы переложить каждую букву,

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' в Привет станет ч-и-т-к-л-м-н.

101
00:08:16,560 --> 00:08:19,600
Таким образом, первое письмо будет п. Мы делаем то же самое с электронной.

102
00:08:19,600 --> 00:08:23,530
Если у нас есть, вроде бы, г или что-то, то мы закончим обратно к '.

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
только 1 из возможных 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
Просто возьмите этот код, положил его в Fuction, а затем вы можете просто вызвать функцию

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
Нам просто нужно, чтобы получить String, String 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': Двоичное представление капитал, число 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
Теперь, двоичным представлением символов нижнего регистра 'а'

147
00:12:19,440 --> 00:12:33,350
будет то же самое, почти. Это - 6, да. Это правильно.

148
00:12:33,350 --> 00:12:37,670
Таким образом, двоичный капитала, двоичные строчная '.

149
00:12:37,670 --> 00:12:43,940
Так заметить, что разница между А и 'а' это один бит.

150
00:12:43,940 --> 00:12:49,440
И это случается, 32 бит, бит, представляющий число 32.

151
00:12:49,440 --> 00:12:53,910
И это имеет смысл, поскольку является 65; 'а' 97.

152
00:12:53,910 --> 00:12:56,610
Разница между ними 32.

153
00:12:56,610 --> 00:13:03,770
Итак, теперь мы знаем, что можем преобразовать от А до 'а', беря

154
00:13:03,770 --> 00:13:09,710
и битовые ORing это, с - которая выглядит как 1.

155
00:13:09,710 --> 00:13:20,900
Это побитовое ИЛИ, с 00100000, и что даст нам ".

156
00:13:20,900 --> 00:13:26,850
И мы можем получить от 'А' до логического умножения на Побитовая

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
Но эта техника Побитовая ORing, чтобы получить от столицы в нижний регистр,

161
00:13:56,750 --> 00:14:02,080
и битовые операции AND, чтобы получить из нижнего регистра в столицу не только для А.

162
00:14:02,080 --> 00:14:06,510
Все письма, K против K, Z против г,

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
этот номер здесь, что я операция AND '' с.

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 (ы), то я + +.

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 = 0, длина = StrLen (ы).

194
00:17:20,410 --> 00:17:25,010
И так это несколько предпочтительнее, так как теперь я ограничила сферу

195
00:17:25,010 --> 00:17:29,150
переменной длины всего этого 'для' цикл, вместо того, чтобы объявить его до

196
00:17:29,150 --> 00:17:34,990
и что оно всегда существует, и в случае, если вы не заметили, почему это плохо,

197
00:17:34,990 --> 00:17:39,410
или почему оригинальная было плохо, it's - начать с цикла.

198
00:17:39,410 --> 00:17:43,380
Я проверил состояние. Это я <длина с?

199
00:17:43,380 --> 00:17:46,790
Таким образом, длина с, давайте поработаем с "привет" все время.

200
00:17:46,790 --> 00:17:49,670
Таким образом, длина S, Н-е-л-л-о. Длина 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
Так давайте проверим длину привет. Н-е-л-л-о. Это 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
Так что мы просто помним 5 до передней, и теперь все лучше.

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
Давайте не будем использовать это альфа функции, и использовать явное - так у нас с [я],

217
00:19:32,710 --> 00:19:40,460
, что является восьмым характера с, помните, что строка представляет собой массив символов,

218
00:19:40,460 --> 00:19:43,180
так восьмом характера с.

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
Да. Таким образом, если с [я] составляет ≥ 65 лет, и с [я] составляет ≤ 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 является "З."

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
Так что, пока это находится в диапазоне капитала к капиталу Z, или мы можем проверить нижнем регистре,

229
00:21:02,100 --> 00:21:17,010
Или, если она находится в диапазоне ≥ 'а' и ≤ г.

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 я, или я модулю 2, так как

242
00:22:18,270 --> 00:22:22,950
заметить, что E является столицей и 'а' в нижнем регистре? Но есть пространство, разделяющее их?

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
в цикле заявления, я положу его здесь.

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
Так заметить, что мы сделали в нижнем регистре ";, что если бы мы сделали это точно такой же вещи в верхний регистр?

263
00:24:07,830 --> 00:24:11,900
Есть ли верхний регистр изменения, или же изменение значения?

264
00:24:11,900 --> 00:24:23,100
Да. Таким образом, любая буква побитовые операции AND с ~ 32 будет тот же символ верхнего регистра

265
00:24:23,100 --> 00:24:29,220
потому что для любого символа в верхнем регистре 32-й бит не установлен.

266
00:24:29,220 --> 00:24:40,920
Таким образом, если мы хотим принести характера с [я], мы хотим, чтобы он стал строчных или прописных букв.

267
00:24:40,920 --> 00:24:46,890
Так что, если это было в нижнем регистре, то теперь прописными буквами, если бы это был верхний регистр, он по-прежнему прописными буквами, вот и все.

268
00:24:46,890 --> 00:24:54,290
Я сказал об этом в supersection: Вы можете использовать 32, если вы хотите, но я предпочитаю делать "а" -,

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 ORing просто держит его нижний регистр.

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
Разница между и '' должен быть не менее 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
Вот почему следующий бит, или этот бит, следующий бит является тот, который выбран, чтобы различать и '.'

300
00:27:32,170 --> 00:27:40,930
Это также, почему в ASCII таблице, существует 5 символов разделения заглавными буквами от строчных букв.

301
00:27:40,930 --> 00:27:49,050
С тех пор являются символами, что дополнительные 5 воспитывает 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
Мол, если были 10000001 и 'а' был 11100001 - я забыл, что угодно.

305
00:28:12,040 --> 00:28:18,100
Но если бы это было, то мы все еще можем использовать '' - A.

306
00:28:18,100 --> 00:28:22,650
Это просто сейчас разница между А и 'а' по-прежнему эти 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 была создана потому, что это первый, который мы могли бы использовать. >> Cool.

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
Кроме того, вы знаете, как мы можем делать такие вещи с [я] + = 1?

317
00:29:34,010 --> 00:29:41,090
Вы также можете сделать с [я] побитовое И = 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, еще у AND 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,% ы быть один для строки,

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
Это \ ", я хочу н.

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
Так что это хорошая вещь о Clang это говорит вам, что он находится в,

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
Мы хотим, чтобы поменять 2 переменные, мы не используем функцию сделать это.

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 + 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, б = 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 = A - B снова,

368
00:34:30,250 --> 00:34:38,650
или = A - B. Какой будет 10 - 7, которая является 3.

369
00:34:38,650 --> 00:34:44,850
Так что теперь, правильно, "а" было 7, б было 3 года, и в настоящее время находится в 7 б и 'а' 3.

370
00:34:44,850 --> 00:34:48,679
Так что вид имеет смысл; «а» является сочетание 2-х номеров.

371
00:34:48,679 --> 00:34:53,000
На данный момент, 'а' это сочетание, а затем мы вычитания из оригинальных б,

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
На самом знаков после запятой, если вы хотите думать о нем, таким образом, = 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
Таким образом, наш первый шаг = а + б.

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
Так что теперь = 0.

389
00:36:22,540 --> 00:36:34,080
А теперь мы хотим установить B = A - B - на самом деле, это все еще работает отлично.

390
00:36:34,080 --> 00:36:39,630
= A - B - давайте посмотрим, если это работает отлично.

391
00:36:39,630 --> 00:36:53,720
Тогда B = 0 - 1, которое все равно будет 15, а затем = A - 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
и я буду искать - я Google, чтобы убедиться, что это правда.

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
Так что это как OR. Если один из битов правда, это 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
Задумайтесь об этом на минуту, я собираюсь Google.

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
но это случай, когда «а» произошло стать 0, после получения до 5 бит, так что теперь "а" равно 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
чтобы гарантировать, что х + у не вызывает переполнение целого ".

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 -, то может быть штраф.

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
Так ^ Ь Ь.

443
00:41:35,800 --> 00:41:51,860
Вы также можете увидеть это в виде = 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
Так что это 'а', это б.

447
00:42:12,790 --> 00:42:15,540
Таким образом, ^ = Ь.

448
00:42:15,540 --> 00:42:22,380
Мы собираемся быть установлен в 'а' = к XOR эти 2 вещи.

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
Вы не увидите большую часть отношений между оригиналом "а" и нового ","

452
00:42:41,160 --> 00:42:45,600
но, глядя на бит "," сейчас, как сетка информации

453
00:42:45,600 --> 00:42:49,970
как оригинал "и оригинальные б.

454
00:42:49,970 --> 00:42:57,930
Таким образом, если мы возьмем Ь, мы видим, что мы в конечном итоге на оригинал ".

455
00:42:57,930 --> 00:43:08,910
А если взять оригинал "'^ новые", "мы видим, мы в конечном итоге на оригинальные б.

456
00:43:08,910 --> 00:43:18,380
Таким образом, (Ь) ^ B = оригинал ".

457
00:43:18,380 --> 00:43:27,910
И (Ь) ^ = оригинальные б.

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
То же и с этим. (Ь) ^ б, как ^ (Ь б).

463
00:43:57,240 --> 00:44:03,680
(Б ^ б) будет 0, а Ф 0 только собирается быть "," так как все биты равны 0.

464
00:44:03,680 --> 00:44:08,050
Таким образом, только те, которые собираются быть там, где «а» изначально был 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
^ ',' И это ассоциативные, так что теперь (Ь) ^.

468
00:44:24,680 --> 00:44:28,970
И мы можем сделать, Ь (^).

469
00:44:28,970 --> 00:44:31,540
И вот снова, мы получим оригинальный б.

470
00:44:31,540 --> 00:44:37,120
Таким образом, '' теперь сочетание 'а' и б вместе.

471
00:44:37,120 --> 00:44:49,660
Используя наш новый комбо "а" мы говорим, B = комбо '' ^ оригинальных б, получаем оригинальный '.

472
00:44:49,660 --> 00:45:05,170
А теперь комбо = 'а' ^ новый б, который был оригинальным - и который теперь, что было "а" или б.

473
00:45:05,170 --> 00:45:13,620
Вот этот случай здесь. Это = б, старая б.

474
00:45:13,620 --> 00:45:16,550
Так что теперь все снова в порядке поменялись местами.

475
00:45:16,550 --> 00:45:22,960
Если бы мы посмотрели на биты, B = ^ B, будет XOR этих 2,

476
00:45:22,960 --> 00:45:33,920
и ответ будет этого, а затем = ^ Ъ XORing эти 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
Вы не добавляете 2 вещи в памяти, вы добавляете 2 вещи в регистрах.

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
эти 2 номера уже находятся в регистрах.

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
Где бы вы ни были использованием Ъ, это будет просто использовать регистр, который был уже хранении ".

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
Так, если в любой момент времени ',' б в температуре имеют различные значения или что-то,

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
, которые пойдут в конце вашей программы, и е е сканирования.

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
Так что я могу сделать, вроде бы, MAN F, сканирование ф.

529
00:50:27,330 --> 00:50:32,300
Это сейчас Информация о семье сканирования F функций.

530
00:50:32,300 --> 00:50:37,070
Я мог бы также сделать MAN 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
Идея программы, которые необходимо сделать файл ввода / вывода является то, что

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 / слова».

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
Так что, если вы хотите прочитать из файла, вы читаете из ф.

560
00:52:49,850 --> 00:52:54,820
Если вы хотите, чтобы закрыть файл, вы закрываете ф.

561
00:52:54,820 --> 00:53:00,350
Так, в конце программы, когда мы неизбежно хотят закрыть файл, то, что мы должны делать?

562
00:53:00,350 --> 00:53:06,750
Мы хотим, чтобы закрыть ф.

563
00:53:06,750 --> 00:53:12,600
Так что теперь последняя функция файл, который мы собираемся хотите использовать сканирование F, F сканирования ф.

564
00:53:12,600 --> 00:53:20,930
И что, что делает это она сканирует на файл ищет шаблоном.

565
00:53:20,930 --> 00:53:39,100
Глядя на мужчину странице здесь, мы видим Int F сканирования F, игнорировать возвращаемое значение на данный момент.

566
00:53:39,100 --> 00:53:45,230
Первым аргументом является файл потока *, так что первый аргумент мы собираемся хотите передать IS-F.

567
00:53:45,230 --> 00:53:47,900
Мы сканирования по ф.

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 \ п, много это ненужным.

571
00:54:05,180 --> 00:54:12,490
Идея о том, что этот формат строки, что вы можете думать о е сканирование как противоположность печати ф.

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, где первый аргумент будет ф.

575
00:54:32,550 --> 00:54:40,980
Когда вы печатаете F, мы могли бы сказать что-то вроде: "печать 127s \ п", а затем, если мы передадим ему некоторые строки,

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
Так что я уверен, что это так. Вы можете Google за это.

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
Давайте реально использовать сканирование е в другой пример.

586
00:55:26,360 --> 00:55:31,670
Так скажем, у нас были некоторые INT, х = 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, мы используем сканирование ф.

597
00:56:20,050 --> 00:56:30,860
Таким образом, строка S - на самом деле мы не можешь - символ, символ S, давай 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
Так что мы собираемся использовать сканирование е, и формат, как мы бы сказали,% 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, является х,

603
00:57:04,020 --> 00:57:06,590
и теперь мы должны хранить эту строку где-то.

604
00:57:06,590 --> 00:57:12,500
А где мы будем хранить эту строку в массиве с.

605
00:57:12,500 --> 00:57:21,640
Таким образом, после этой строки кода, а, если мы печатаем F,% с переменной с,

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
за то, что хранить в с.

609
00:57:43,600 --> 00:57:46,160
Это то, что последний аргумент будет.

610
00:57:46,160 --> 00:57:54,170
Мы хотим, чтобы хранить - "Scan е семейство функций сканирования и в соответствии с форматом, как пытался ниже.

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
который - что намного больше смысла, поэтому я сказал, что это гораздо больше похоже печати ф.

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
Так что игнорировать полностью. Вы все еще можете думать формата, как такие печати ф.

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. Можете ли вы объяснить, что 1 больше времени?

628
00:59:43,450 --> 00:59:52,710
Так что это было - это менее relevent для сканирования 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
Поэтому для того, чтобы сделать это, вам нужно е открытое, а затем вы должны передать в строку, которую вы хотите открыть.

633
01:00:21,520 --> 01:00:30,020
Таким образом, мы хотели бы открыть 1.jpg, для того, чтобы создать строку, которая 1.jpg,

634
01:00:30,020 --> 01:00:37,660
Мы делаем печать с Р% d.jpg--мы не делали для Int = 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
Таким образом, после этой линии, теперь переменная или массив, а собирается 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
, где он вставляет все переменные во втором аргументе, может быть ей, в отличие от меня.

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
Таким образом, мы храним внутри с правильной строки в формате,% D будучи заменены 4.

647
01:02:00,750 --> 01:02:08,080
[Студент] Таким образом, если бы мы сделали это, является переменной F только собирается быть переназначены?

648
01:02:08,080 --> 01:02:18,110
Да. Таким образом, мы должны закрыть оригинальную е, прежде чем делать это.

649
01:02:18,110 --> 01:02:22,810
Но - и тут же, если бы не было F открывают здесь, то мы должны были бы сказать -

650
01:02:22,810 --> 01:02:29,280
Да. Но было бы открыть сотни различных файлов.

651
01:02:29,280 --> 01:02:37,360
[Студент] Но мы не были бы в состоянии получить доступ или - нормально.

652
01:02:37,360 --> 01:02:44,230
Хорошо. Таким образом, сканирование F, 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, и хранить целое число 4 в сумме х Int.

656
01:03:11,290 --> 01:03:13,430
Это то, что мы можем использовать для сканирования е.

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
Поэтому, когда вы говорите: "получить Int", это сканирование F-ния более - сканирование 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 сканирования е, я думаю, будет останавливаться на новой линии ни на что.

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
[Студент] Но что, если вы ищете слово "извращенный аппетит", как извращенный аппетит.

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
Мы не ищем слово вообще в нашем сканирования ф.

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
Таким образом, неизбежно, мы собираемся в конечном итоге делает кучу сканирование фс

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
Мы читаем по всему словарю, хранение строка за строкой каждое слово в переменную с.

691
01:06:08,440 --> 01:06:17,240
Затем мы сравниваем слово с, а если сравнение == 0,

692
01:06:17,240 --> 01:06:21,650
STRCMP происходит довести 0, если матч был сделан.

693
01:06:21,650 --> 01:06:31,510
Так что, если это был 0, то мы можем напечатать F, совпадают,

694
01:06:31,510 --> 01:06:35,370
или слово в словаре, или что вы хотите напечатать ф.

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
Таким образом, мы могли бы сделать это, если бы мы хотели посмотреть на их картины, извращенный аппетит, как вы говорили,

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
О, я избавиться от этого раньше? Char с, я думаю, мы сказали 127 - я забыл, что крупнейший есть.

708
01:07:40,870 --> 01:07:44,100
Мы просто делаем 128; так что теперь ей достаточно долго.

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