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

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-комплект 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
[Student] направи, докато цикълът се изпълнява поне веднъж.

38
00:02:52,730 --> 00:03:02,950
Да. Така че това е разликата. А докато линия - Ще го направя тук - докато контур, имаме състояние

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
И вероятно пет от тях са в 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
[Student] Когато се опитвате да получите потребителски вход, или нещо, което искате да проверите

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
Така че можем да направим това в отделни стъпки, вътр х, х = 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
И накрая, "Защо не е Cipher Цезар много сигурен?

90
00:07:18,390 --> 00:07:23,830
Така че, първо, няма ли някой да каже какво Cipher Цезар?

91
00:07:23,830 --> 00:07:28,100
[Студентски] Цезар 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
Цезар Cipher, 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
Така "з" в здравей ще стане з-и-к-к-л-м-н.

101
00:08:16,560 --> 00:08:19,600
Така че първото писмо ще бъдат н. Ние правим едно и също нещо с електронна поща.

102
00:08:19,600 --> 00:08:23,530
Ако имаме, като, Z или нещо подобно, тогава ние приключи обратно около ".

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
[Student] Това е като отделна част от код, който можете да се обадите, за да мине през и след това получи връщане стойността на каквото.

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
Ние просто трябва да се низ, низ = 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
[Student] не е в 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
Така че, "А": Binary представителство на капитала на, броят им е 65.

144
00:11:59,680 --> 00:12:07,560
Аз съм просто ще да погледнете - 41 ще бъде 01000001.

145
00:12:07,560 --> 00:12:14,170
Така че това трябва да бъде 65 в десетична, така че това е двоичен представителство на характер А. капитал

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, с който изглежда като едно.

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

156
00:13:20,900 --> 00:13:26,850
И можем да получим от "а" от побитови ANDing

157
00:13:26,850 --> 00:13:33,700
с 11, 0 на това място, 11 111.

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
и побитови ANDing да получите от малки до капитал не е само до А.

162
00:14:02,080 --> 00:14:06,510
На буквите, K - к, Z - 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
Така че това беше един, сега е 0, това е на 0, сега е 1, 010 100.

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
този номер, че ANDed "а" с.

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 I = 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
Аз проверих състоянието. I <дължината на S?

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

200
00:17:46,790 --> 00:17:49,670
Така дължина, з-д-л-л-о. Дължината му е 5.

201
00:17:49,670 --> 00:17:57,580
Така че аз = 0, дължина е 5, така че не е по-малко от пет, така че цикълът продължава.

202
00:17:57,580 --> 00:18:02,750
Тогава отиваме отново. Ние проверяваме състоянието. I <дължината на здравей?

203
00:18:02,750 --> 00:18:08,390
Така че нека да проверим дължината на здравей. H-е-л-л-о. Това е 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
[Student казано, неразбираемо]

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
[Student], можете просто да използвате функцията е алфа.

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
така осмото характер на 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
Да. Така че, ако [I] е ≥ 65, и е [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
Използвайте само един цитат герои, самотни цитат константи. Така че, "А" и по-малко от 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
Така че, докато това е в обхвата на капитала на столицата Z, или ние да проверите за малки,

229
00:21:02,100 --> 00:21:17,010
Или, ако това е в диапазона ≥ "а" и ≤ 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 на "Аз, или мод 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
[Student въпрос, неразбираем]

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
Така INT брой = започва от 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 случая.

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
Да. Така че всяка капитала побитови писмо, ANDed с ~ 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, ако искате, но съм склонен да предпочитат да се прави "а" - 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 смисъла "а" - А.

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
[Student] Дали тази стратегия за изваждане на главни от малки работа, ако не беше 32?

290
00:26:33,190 --> 00:26:35,330
Ако е така,, ​​34 или нещо такова?

291
00:26:35,330 --> 00:26:41,840
Така че, трябва да знаят, че разликата между два? >> 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
всички тези първи пет бита, да представляват всичко до 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
[Student] Така че можем да го направим,, защото 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
Но ако беше това, тогава ние все още може да се използва "а" - А.

306
00:28:18,100 --> 00:28:22,650
Това е просто разликата между А и "а" е все пак тези два бита.

307
00:28:22,650 --> 00:28:32,240
Мисля, че е написал 48. Е 32 + 64? Мисля, че е?

308
00:28:32,240 --> 00:28:40,160
Тя все още ще бъде два бита, всеки един характер, като Z и Z, К и К,

309
00:28:40,160 --> 00:28:45,160
те все още ще има абсолютно същите бита, с изключение на тези два бита.

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
ли или 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
Така се отървете от тези празни редове, сега ние ще отпечатаме е,% S е за струнни,

331
00:30:51,070 --> 00:30:56,620
Ние ще отпечата е,

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
Така че това е хубавото звъня тя ви казва какво е,

337
00:31:14,290 --> 00:31:19,140
вместо от Персийския залив, която просто казва: "Хей, сте забравили нещо, аз не знам какво е то."

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
Но ние ще направим техния пример "Благодаря четири добавки".

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
"Изтегли от втората лекция седмица две, че размяна на стойностите на две променливи чрез предаване

348
00:32:24,810 --> 00:32:30,780
тези две променливи функция (дори ако суап), не точно работят, поне не и без "указатели."

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
Но за да се използват тези две променливи, ние не искате да използвате временна променлива.

353
00:32:48,360 --> 00:32:50,770
Има два начина да направите това.

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
Ще уредя проблема като искат. Така че, ако имам две променливи, A, която е само цяло число

358
00:33:12,130 --> 00:33:17,800
, че те ми дават и Б сумата променлива, която е друго число, който съм дал.

359
00:33:17,800 --> 00:33:22,700
Така че, ако имам тези две променливи, сега искам да ги разменят.

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
Бихме могли да прекарат с нещо подобно а = а + б и б = а - б, а = а - б.

364
00:33:52,980 --> 00:34:04,260
Така че, здрав разум проверка, и след това ще видим защо това работи.

365
00:34:04,260 --> 00:34:13,320
Да кажем, = 7, б = 3, А + Б ще бъде 10.

366
00:34:13,320 --> 00:34:18,820
Така че ние сега определя = 10, и след това правим б = а - б.

367
00:34:18,820 --> 00:34:30,250
Така че ние правим б = а - б, което ще бъде 7, и б = а - б отново

368
00:34:30,250 --> 00:34:38,650
или а = а - б. , Която ще бъде 10 - 7, което е три.

369
00:34:38,650 --> 00:34:44,850
Така че сега, правилно, "а", е бил 7, б е 3, а сега б е 7, а "а" е 3.

370
00:34:44,850 --> 00:34:48,679
Така че този вид има смисъл "а" е комбинация от две числа.

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
Да кажем, че нашите два номера 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 и Б е 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
е в крайна сметка ще е 10 000, но ние имаме само 4 бита.

388
00:36:16,780 --> 00:36:22,540
Така че сега е = 0.

389
00:36:22,540 --> 00:36:34,080
И сега искаме да настроите б = а - б - всъщност, това все още работи перфектно.

390
00:36:34,080 --> 00:36:39,630
= а - б - нека видим дали това работи перфектно.

391
00:36:39,630 --> 00:36:53,720
Тогава б = 0 - 1, която все още ще бъде 15, а след това = а - б, която ще бъде една.

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, това ще бъде едно, имате битове 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. Ако някоя от бита са верни, това е едно, но за разлика ИЛИ, той не може да бъде двата бита, които са верни.

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
да се гарантира, че 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
[Student] Е, не е цяло число преливане, когато се опитвате да се сложи там

417
00:39:13,640 --> 00:39:16,640
по-голям от размера на бита, които сте разпределени?

418
00:39:16,640 --> 00:39:23,730
Да. Имаме 4 бита. Това е - имахме 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
[Student ли, че ви хвърли грешка, или това, че ще хвърли грешка?

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 = петнайсет милиона.

430
00:40:15,410 --> 00:40:20,430
Тъй като до края на 0, извадим 1, така че след това просто се загърнала отново около 1111.

431
00:40:20,430 --> 00:40:28,930
Така че този алгоритъм може действително работят, а + б, - б, б - а, може да се оправи.

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 по някакъв начин да получите информация и за двете в един от променливите,

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
[Student отговор, неразбираем]

439
00:41:14,540 --> 00:41:22,220
Така че това трябва да работи, а също така, XOR е комутативен.

440
00:41:22,220 --> 00:41:27,620
Независимо от които за тези две числа се случи да бъде тук,

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
Можете също така да видя това, написано като ^ = б, б ^ = а, ^ = б отново.

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
Отиваме да бъде създаването на "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
вие няма да видите много на отношенията между оригиналния "а" и новия ""

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
Така че (а ^ б) ^ б = оригинала ".

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, а другият е едно.

461
00:43:47,920 --> 00:43:51,080
Така че това е 0000.

462
00:43:51,080 --> 00:43:57,240
Същото е и с това. (^ Б) ^ б е като ^ (B ^ б).

463
00:43:57,240 --> 00:44:03,680
(Б ^ б) ще бъде 0, ^ 0 е просто ще бъде "," тъй като всички битове са 0.

464
00:44:03,680 --> 00:44:08,050
Така единствените, които ще бъдат, където "а" първоначално е бил един - не са имали такива.

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
И ние можем да направим б ^ (^).

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
Използване на нашия нов комбо "" казваме б = комбо 'на' ^ оригиналния б, ще получите оригинала ".

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
Ако ние действително погледна в бита, б = а ^ б, ще да XOR тези две,

476
00:45:22,960 --> 00:45:33,920
и отговорът ще бъде това, и след това A = A ^ B XORing тези 2 и отговорът е това.

477
00:45:33,920 --> 00:45:41,090
Въпроси? Добре. Така последните донякъде е значително по-трудно.

478
00:45:41,090 --> 00:45:43,180
[Student] Мисля, че има съмнение за това. >> О, съжалявам.

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
Където и да са използвали б, тя просто ще използват регистъра, за която вече е била съхраняване ".

494
00:46:56,510 --> 00:47:02,180
Така че не е необходимо да се направи всичко, за да направи суап. Да?

495
00:47:02,180 --> 00:47:05,690
[Student] Но той също така отнема повече памет, нали?

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
ние просто искаме да се намери едно слово. Така че ние може просто да сканира целия речник

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
Така че, основните от които вие ще искате да погледнете се е отворен и след това, неизбежно е затворен,

519
00:49:20,490 --> 00:49:26,540
които ще отидат в края на програмата, и е сканиране е

520
00:49:26,540 --> 00:49:31,060
Можете също да използвате е прочетете, но най-вероятно не искате да

521
00:49:31,060 --> 00:49:34,200
защото това не свърши нуждаят че.

522
00:49:34,200 --> 00:49:41,880
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
Така че мога да направя, харесва, е човек, сканиране е.

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

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, че името на функцията, или човек, три, че името на функцията,

536
00:50:51,620 --> 00:50:58,230
но вие само трябва да направите, че ако името на функцията човек не се случи, да се работи за първи път.

537
00:50:58,230 --> 00:51:03,010
[Student] Така че аз съм четене на човек страница за отворен, но аз съм все още са объркани за това как да го използвате и програмата.

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
Както е сканиране е, също. Тя ви дава информация за всички тези функции,

543
00:51:22,220 --> 00:51:28,120
и един ред тук се случва да се каже, "F сканиране е чете от низ точка или поток".

544
00:51:28,120 --> 00:51:32,360
Но е отвори. Така че, как ще използваме е отворен?

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 / думи."

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
и аз просто ще покажа всичко в променливата е, така *,

557
00:52:37,260 --> 00:52:40,840
отново, това е указател, но ние не искаме да се справят с указатели.

558
00:52:40,840 --> 00:52:46,470
Можете да мислите е, тъй като е в момента е променлива, ти започваш да се използват, за да представлява файл.

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
Така че сега последната функция файл, който ние ще искате да използвате сканиране е, е сканиране е.

564
00:53:12,600 --> 00:53:20,930
И какво, което прави е да го сканира над файла, търси модел, който да съвпада.

565
00:53:20,930 --> 00:53:39,100
Търси в мъжа страница тук, ние виждаме INT е сканиране е, не обръщайте внимание на връщаната стойност за сега.

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

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
Идеята на този формат низ, можете да мислите за сканиране е като противоположност на печат е.

572
00:54:12,490 --> 00:54:17,160
Така печат е, е печат, ние също да използват този тип формат параметър,

573
00:54:17,160 --> 00:54:25,000
но в печатна форма е това, което правим, е - нека да погледнем в еквивалентен.

574
00:54:25,000 --> 00:54:32,550
Отпечатате Така е, и там е всъщност също е печат е, където ще бъде първият аргумент е.

575
00:54:32,550 --> 00:54:40,980
Когато отпечатвате е, ние може да се каже нещо като "печат 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 "в печатния е,

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 сканиране е сега, вместо да гледаме при променлив и печат,

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
Така че нека да кажем, че имахме някои вътр, х = 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, бихме могли просто да се каже печат е% 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
Така низ е - всъщност ние Не можеш - характер, Чар и, да вървим 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, това, което искаме да замени г% е х,

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
Така след този ред на код, ако се печата е,% S на променливата S

606
00:57:21,640 --> 00:57:26,280
ще да отпечатате 4.jpg.

607
00:57:26,280 --> 00:57:38,930
Така е сканиране е същото като сканиране е, освен сега е над този файл

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
Така сканиране е не - какво по дяволите е функция, която прави това?

614
00:58:26,350 --> 00:58:31,650
Така сканиране е няма да вземат число и направи точка JPG.

615
00:58:31,650 --> 00:58:43,490
Това ще [Mumbles].

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

619
00:59:04,950 --> 00:59:09,820
които - това прави много повече смисъл, защо казах, че е много повече като печат е.

620
00:59:09,820 --> 00:59:14,700
Scan е все още е вид като печат е, но ще го сканира и печат е

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

625
00:59:34,510 --> 00:59:38,520
Така че това, което се прави сканиране е - това, което е въпрос ще бъде?

626
00:59:38,520 --> 00:59:40,820
[Student] Аз съм просто объркан от това, което се опитваме да направим тук

627
00:59:40,820 --> 00:59:43,450
че JPEG. Можеш ли да обясниш, че едно повече време?

628
00:59:43,450 --> 00:59:52,710
Така че това беше - това е по-малко relevent е сканиране е сега; се надяваме, че ще вържеш обратно по някакъв начин.

629
00:59:52,710 --> 01:00:02,240
Но това, което първоначално възнамерява да покаже - това е пряко свързани с [? F5]

630
01:00:02,240 --> 01:00:08,520
Вие ще се използват и печат е, когато кажем, че имаме 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 I = 0.

635
01:00:37,660 --> 01:00:46,580
<40, аз + +.

636
01:00:46,580 --> 01:00:51,130
Така% печат е 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
Така че това е, което и отпечатате е прави. Виждате ли какво е отпечатате е сега се прави?

640
01:01:19,550 --> 01:01:25,720
[Student] Добре, така че да поема - тя създава низ, something.jpg, и след това го съхранява.

641
01:01:25,720 --> 01:01:30,360
Да. Тя създава - това е друг формат низ, точно както е сканиране и печат е,

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
Така че ние сме съхранение на вътрешната страна и правилно форматиран низ,% г са заменени с 4.

647
01:02:00,750 --> 01:02:08,080
Студентски Така че, ако ние направихме това, е променлива е просто ще се преразпределят?

648
01:02:08,080 --> 01:02:18,110
Да. Така че ние трябва да закриете първоначалния си е преди да направите това.

649
01:02:18,110 --> 01:02:22,810
Но и след това също така, ако не е отвори тук, тогава ние ще трябва да се каже -

650
01:02:22,810 --> 01:02:29,280
Да. Но това ще отвори стотици различни файлове.

651
01:02:29,280 --> 01:02:37,360
[Student Но ние не ще бъде в състояние за достъп или - Добре.

652
01:02:37,360 --> 01:02:44,230
Добре. Така сканиране е, е сканиране е, е вид на една и съща идея,

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
Можете да използвате сканиране е да се направи разбор нещо подобно 4.jpg и съхранява цялото число 4 в х сума Int.

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

657
01:03:13,430 --> 01:03:16,300
F сканиране е да направите това в командния ред.

658
01:03:16,300 --> 01:03:19,200
Аз всъщност съм сигурен, че това е, което библиотеката CS50.

659
01:03:19,200 --> 01:03:29,050
Така че, когато ви казват, "да INT", това е сканиране е над сканиране е начина, по който можете да получите потребителския вход.

660
01:03:29,050 --> 01:03:34,670
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
и също е сканиране е, мисля, че ще спре най-новата линия без значение какво.

667
01:04:03,310 --> 01:04:06,970
Но ние ще включва нова линия в мача, и -

668
01:04:06,970 --> 01:04:13,960
[Student] Ако ние не включват новата линия няма да го намерите части от една дума?

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
Е сканиране ще се вдигне тази дума.

673
01:04:32,510 --> 01:04:38,750
Ако ние не включват новата линия, а след това е възможно, че следващото е сканиране просто ще чете новата линия.

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
[Student] Но какво, ако търсите думата "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
Ние не търсим дума всички в нашата сканиране е.

683
01:05:23,290 --> 01:05:28,030
Какво правим с сканиране е всяка дума в речника,

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
, докато тя просто така се случва, че ще се върне сканиране е -

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
След това се сравняват дума с 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
или думата е в речника, или каквото искате да отпечатате е.

695
01:06:35,370 --> 01:06:41,450
И после - ние не искаме да е близо отново и отново.

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
[Student коментар, неразбираем]

707
01:07:34,720 --> 01:07:40,870
О, не мога да се отърва от това преди? Чар и, предполагам, че казахме 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