1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] Дел Проблем Намести 2: Хакер издание

2
00:00:02,670 --> 00:00:04,910
Роб Бауден, Универзитетот Харвард

3
00:00:04,910 --> 00:00:07,410
Ова е CS50. CS50.TV

4
00:00:07,410 --> 00:00:15,770
Значи, јас сум Роб. Јас сум висок во Киркланд. Ова е мојата трета година TFing CS50.

5
00:00:15,770 --> 00:00:22,220
Тоа е прв пат дека ние се менуваат од традиционалниот предавање стил дел,

6
00:00:22,220 --> 00:00:25,610
каде што само вид на преглед што се случи во предавање и потоа вие момци поставуваат прашања,

7
00:00:25,610 --> 00:00:32,250
сега да биде многу повеќе врз база на проблем, каде што ние ги користиме простори, и -

8
00:00:32,250 --> 00:00:37,410
О, па идејата е да се оди со врски што водат Ви испратив, а потоа ќе биде во мојот простор.

9
00:00:37,410 --> 00:00:42,410
Не секој има лаптоп? Во ред.

10
00:00:42,410 --> 00:00:47,050
Па ние ќе биде со користење на овој, а ние ќе се прави проблеми живеат во делот

11
00:00:47,050 --> 00:00:50,740
и да дискутираме за нив и да пронајдат она што не е во ред

12
00:00:50,740 --> 00:00:56,390
и јас може да се повлече до некои од вашиот код, и јас би можеле да разговараат за своите идеи.

13
00:00:56,390 --> 00:01:02,140
Значи има некој имал тешкотии?

14
00:01:02,140 --> 00:01:07,000
Можете да разговарате на страна, јас не знам дали ќе имаме причина за тоа.

15
00:01:07,000 --> 00:01:12,270
Сега, како и претходните supersection, ако сте биле во таа класа, знаеш што тоа е за.

16
00:01:12,270 --> 00:01:19,200
На сите на P поставува таму ќе биде овие секции.

17
00:01:19,200 --> 00:01:22,550
Значи P-сет 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
Претпоставувам за Хакер издание, многу од нив би требало да биде само нови, интересни работи да се научат.

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
Do-додека јамка, како што на програмата се извршува, таа добива на "не".

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
бидејќи штом ќе дојде до тоа, ако состојбата е false, ние само ќе го прескокнете право над неа.

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
обично укажуваат ако outputted со ѕвекот? "

71
00:05:43,310 --> 00:05:47,380
Значи каков вид на код можам да пишувам за се 'непријавена идентификатор?

72
00:05:47,380 --> 00:05:49,550
[Студентски] дека x = 2?

73
00:05:49,550 --> 00:05:52,650
Па ние само да го пробате овде, x = 2.

74
00:05:52,650 --> 00:06:04,830
Ние ќе ја извршите оваа - О, јас не кликнете на неа. Значи тука добиваме - сите права.

75
00:06:04,830 --> 00:06:07,100
"Употреба на непријавена идентификатор х."

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 x," или "стринг y", сеедно.

83
00:06:37,360 --> 00:06:41,910
Почетокот на променлива, или доделување на променлива,

84
00:06:41,910 --> 00:06:44,510
е кога ќе се каже "x = 2."

85
00:06:44,510 --> 00:06:52,950
Значи можеме да направиме овие во одделни чекори, int x, x = 2, а до - можеме да имаме еден куп на работи тука -

86
00:06:52,950 --> 00:07:00,350
но до оваа линија се случува, x се уште деиницијализира, но тоа е декларирана.

87
00:07:00,350 --> 00:07:06,760
И така ние очигледно може да го стори во 1 линија, а ние сега се наведува и иницијализацијата.

88
00:07:06,760 --> 00:07:10,730
Прашања?

89
00:07:10,730 --> 00:07:18,390
И, конечно, "Зошто не е шифра Цезар многу безбедна?"

90
00:07:18,390 --> 00:07:23,830
Значи прво, дали некој сака да каже што Спортот Цезар е?

91
00:07:23,830 --> 00:07:28,100
[Студентски] Цезар шифра само е дека сајтот, можете префрлат секоја буква,

92
00:07:28,100 --> 00:07:34,420
одреден број на букви поминат, и се движи назад во текот, и тоа не е многу безбеден, бидејќи

93
00:07:34,420 --> 00:07:42,260
има само 26 можни опции и вие само треба да се обиде секој 1 на оние додека не го добие.

94
00:07:42,260 --> 00:07:45,470
О. Значи, јас треба да се повторуваат?

95
00:07:45,470 --> 00:07:51,600
На Цезар шифра, it's - мислам, ќе се занимаваат со тоа на проблемите со кои сте -

96
00:07:51,600 --> 00:07:56,110
или Претпоставувам дека стандардна верзија на проблемот сет кој не е на хакерски издание.

97
00:07:56,110 --> 00:08:01,550
Така, на стандардна верзија на проблемот во собата, ќе добиете порака како: "Здраво, свет"

98
00:08:01,550 --> 00:08:08,410
и ти исто така имаат голем број како 6, и да ве однесе на таа порака, и секој индивидуален карактер,

99
00:08:08,410 --> 00:08:11,310
го ротираат со 6 позиции во писмото.

100
00:08:11,310 --> 00:08:16,560
Па 'ж "во здраво ќе стане ж-з-ѕ-к-л-м-н.

101
00:08:16,560 --> 00:08:19,600
Така првото писмо ќе биде n. Ние го правиме истото со e.

102
00:08:19,600 --> 00:08:23,530
Ако имаме, како, z или нешто, тогаш заврши назад околу да "А".

103
00:08:23,530 --> 00:08:29,280
Но, секој карактер добива cycled 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
Ние само треба да се низа, низа s = GetString, во ред.

135
00:11:19,790 --> 00:11:24,890
Сега овој проблем, постојат неколку начини да ја направиш.

136
00:11:24,890 --> 00:11:29,840
Но, ние се случува да сакате да го користите bitwise оператори овде.

137
00:11:29,840 --> 00:11:35,280
Дали постојат луѓе кои или не биле во supersection,

138
00:11:35,280 --> 00:11:37,480
или нешто, и не знам што bitwise оператори?

139
00:11:37,480 --> 00:11:41,710
Или како тие се однесуваат на ASCII на било кој начин?

140
00:11:41,710 --> 00:11:45,650
[Студентски] Јас не сум бил во supersection, но знам што bitwise оператори.

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
Значи "А": бинарно претставување на капитал, бројот е 65.

144
00:11:59,680 --> 00:12:07,560
Јас сум само ќе се погледне - 41 ќе биде 01.000.001.

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
и bitwise тоа oring, со - што личи на 1.

155
00:13:09,710 --> 00:13:20,900
Ова е bitwise ИЛИ, со 00100000, и тоа ќе ни даде "на".

156
00:13:20,900 --> 00:13:26,850
И ние може да се добие од "а" до A од bitwise ANDing

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
Но, оваа техника на bitwise oring да се добие од капиталот во мали букви,

161
00:13:56,750 --> 00:14:02,080
и bitwise ANDing да се добие од мали до капитал не е ексклузивна за А

162
00:14:02,080 --> 00:14:06,510
Сите букви, К vs К Ш vs 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, но тилда (~) е уште bitwise оператор.

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
Ова е само дел бинарен број, и она што ~ се тоа е само flips сите битови.

171
00:14:53,130 --> 00:15:00,630
Значи ова беше 1, а сега е 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 ќе биде бројот 00.100.000, и така ~ на ова ќе биде

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
Значи имам iterator, и тој го рече, но како можам да знам колку карактери се во низа?

187
00:16:42,940 --> 00:16:47,030
Strlen (а), а потоа i + +.

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, можам да кажам се тука, int должина = 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
Јас проверив состојба. Е з <должината на пријавите?

199
00:17:43,380 --> 00:17:46,790
Значи должината на с, ајде да работиме со "здраво" за целото време.

200
00:17:46,790 --> 00:17:49,670
Значи должината на с, ж-е-л-л-о. Должина е 5.

201
00:17:49,670 --> 00:17:57,580
Значи i = 0, должина е 5, па не е <5, па циклусот продолжува.

202
00:17:57,580 --> 00:18:02,750
Потоа одиме повторно. Ние провериш состојбата. Е з <должината на здраво?

203
00:18:02,750 --> 00:18:08,390
Значи, да проверите должината на здраво. H-е-л-л-о. Тоа е 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
Да не го користат е алфа функција, и употреба на експлицитни - па ние имаме s [i],

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
Да. Па ако е [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 е "З"

226
00:20:41,940 --> 00:20:47,930
И ова е значително подобро - јас не знам од врвот на мојата глава дека Z е 90.

227
00:20:47,930 --> 00:20:52,690
Знам од врвот на мојата глава дека '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 од i, или јас современи 2, од

242
00:22:18,270 --> 00:22:22,950
забележите дека Е е капитал и "а" е со мали букви? Но, има простор одделување на нив?

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
Значи int count = започнува од 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
Да. Па секоја буква bitwise ANDed со ~ 32 ќе биде истата голема буква

265
00:24:23,100 --> 00:24:29,220
бидејќи за било голема буква на 32 битна не е поставена.

266
00:24:29,220 --> 00:24:40,920
Значи, ако сакаме да се донесе ликот на [i], ние сакаме тоа да стане мали или големи букви.

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 значење - А

283
00:26:04,140 --> 00:26:06,510
Но, огласот, од ист резонирање, како и претходната, дека ако

284
00:26:06,510 --> 00:26:11,670
писмото беше веќе мали букви, тогаш oring од 32 само чува мали букви.

285
00:26:11,670 --> 00:26:16,220
Тоа не е променет оригиналниот карактер.

286
00:26:16,220 --> 00:26:19,910
Но сега не мора да се избегне велејќи: "Ако тоа е со мали букви, само да заборавите за неа,

287
00:26:19,910 --> 00:26:23,650
ако тоа е големи, тогаш тоа се промени. "

288
00:26:23,650 --> 00:26:26,900
Тоа е многу полесно да го направите тоа.

289
00:26:26,900 --> 00:26:33,190
[Студентски] ќе дека стратегијата на одземање на големи од мали работи, ако не беше 32?

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

291
00:26:35,330 --> 00:26:41,840
Значи, вие треба да знаете дека разликата помеѓу 2 е - >> 1 малку.

292
00:26:41,840 --> 00:26:49,840
Тоа може да биде повеќе од 1 малку, додека сите делови под оваа позиција се исти.

293
00:26:49,840 --> 00:26:58,500
Значи ние треба најмалку 26 карактери - или, постојат 26 карактери.

294
00:26:58,500 --> 00:27:04,590
Значи ние треба најмалку 26 броеви да претставува разликата -

295
00:27:04,590 --> 00:27:07,650
Разликата меѓу А и "а" мора да биде најмалку 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 битови, претставува сe преку З

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
Но, ако се ова, тогаш ние се уште може да се користи "а" - А

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, К и К,

309
00:28:40,160 --> 00:28:45,160
тие се уште ќе имаат исти точно битови во собата, освен за оние 2 бита.

310
00:28:45,160 --> 00:28:48,870
Толку колку што тоа е секогаш точно, без оглед на тоа дали ние сме со користење ASCII или некои други систем,

311
00:28:48,870 --> 00:28:53,050
додека има само одреден број на битови кои се различни за секој лик,

312
00:28:53,050 --> 00:28:55,050
тогаш тоа функционира добро.

313
00:28:55,050 --> 00:29:06,110
Тоа е само дека 32 беше формирана, бидејќи тоа е првиот ние би можеле да го користите. >> Кул.

314
00:29:06,110 --> 00:29:14,520
Имам навика да претпочитаат, во случај да не сте виделе, ако блок е само една линија,

315
00:29:14,520 --> 00:29:24,280
можете да се ослободите од големи загради, па се трудам да преферираат ова.

316
00:29:24,280 --> 00:29:34,010
Исто така, знаеш како можеме да ги правите нештата како и [i] + = 1?

317
00:29:34,010 --> 00:29:41,090
Можете исто така да направам е [i] bitwise И = 32.

318
00:29:41,090 --> 00:29:46,400
И bitwise ИЛИ = 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
Можете да ги комбинирате со троичен ако си сакал, но тогаш тоа само ќе се направат работите Messier

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
Е дека сите проблеми побара? Oh yeah.

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
Тоа е \ "; Сакам n.

334
00:31:03,200 --> 00:31:07,840
Во ред. Сега ќе го работи. Тоа веројатно ќе се развикам мене.

335
00:31:07,840 --> 00:31:11,250
Strlen е во string.h.

336
00:31:11,250 --> 00:31:14,290
Значи ова е убаво нешто за ѕвекот е тоа ти го кажува она што е во,

337
00:31:14,290 --> 00:31:19,140
наместо GCC што само вели: "Еј, ти заборави нешто, не знам што е тоа."

338
00:31:19,140 --> 00:31:29,220
Но, ова ќе ми кажеш, "значи да се вклучат string.h."

339
00:31:29,220 --> 00:31:32,130
Па јас не прашува за ништо, па тоа не е велејќи дека ништо.

340
00:31:32,130 --> 00:31:42,540
Но, ние ќе го направи нивниот пример, "thanks 4 the add".

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 променливи за функција (дури и ако се нарекува swap) не е точно работат, барем не без "совети".

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 променливи, А, што е само целобројна

358
00:33:12,130 --> 00:33:17,800
дека тие ми даде, и збирот променлива Б, што е уште еден цел број кој сум дал.

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
Не bitwise оператори кои дејствуваат на бинарни.

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, b = 3, тогаш a + b ќе биде 10.

366
00:34:13,320 --> 00:34:18,820
Па ние сме сега поставувајќи = 10, а потоа правиме b = a - b.

367
00:34:18,820 --> 00:34:30,250
Значи ние сме прави b = a - б, која ќе биде 7, и b = a - b повторно,

368
00:34:30,250 --> 00:34:38,650
или = а - б. Која ќе биде 10-7 што е 3.

369
00:34:38,650 --> 00:34:44,850
Па сега, правилно, беше "а" 7, б беше 3, а сега b е 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
Во реалниот децимали, ако сакате да се размислува на тој начин, a = 15 и б = 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 и б = 1.

384
00:35:51,860 --> 00:35:57,670
Откако ќе ги трампа, ние очекуваме 'а' да биде 1 и б на 15.

385
00:35:57,670 --> 00:36:01,780
Значи нашиот прв чекор е = a + b.

386
00:36:01,780 --> 00:36:08,770
Нашите броеви се само 4 бита широк, па "на", кој е 1111, + b, која е 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
И сега ние сакаме да го поставите b = a - b - всушност, ова сè уште работи надвор совршено.

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

391
00:36:39,630 --> 00:36:53,720
Па тогаш б = 0-1, која, сепак, ќе биде 15, а потоа = a - б, која ќе биде 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
Значи, ние сакаме да го направи тоа со помош bitwise оператори, а поим овде е XOR.

397
00:37:23,490 --> 00:37:28,780
Значи, воведување на XOR (^), ако не сте го виделе досега.

398
00:37:28,780 --> 00:37:34,610
Тоа е, повторно, операторот bitwise така делува малку од малку, и it's -

399
00:37:34,610 --> 00:37:39,910
Ако имате битови 0 и 1, тогаш ова ќе биде 1.

400
00:37:39,910 --> 00:37:45,230
Ако имате битови 1 и 0, тоа ќе биде 1, имате битови 0 и 0 тоа ќе биде 0,

401
00:37:45,230 --> 00:37:47,640
и ако имате битови 1 и 1 тоа ќе биде 0.

402
00:37:47,640 --> 00:37:56,180
Па тоа е како ИЛИ. Ако било кој од битови се вистинити, тоа е 1, но за разлика ИЛИ, тоа не може да биде и битови кои се вистинити.

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 swap алгоритам страница.

407
00:38:16,230 --> 00:38:21,340
Се надевам ова ќе објасни зошто јас што не се -

408
00:38:21,340 --> 00:38:34,190
Ова е точно алгоритам што ние едноставно не.

409
00:38:34,190 --> 00:38:37,330
Јас се уште не гледам зошто - Јас мора да само зедов еден лош пример,

410
00:38:37,330 --> 00:38:44,940
но овој случај каде што 'A' се случи да стане 0, по добивање на 5 парчиња, па сега "а" е 0,

411
00:38:44,940 --> 00:38:48,730
тоа е она што се нарекува "број претекување."

412
00:38:48,730 --> 00:38:54,370
Според Википедија, "За разлика од XOR, swap, оваа варијација бара тоа што користи некои методи

413
00:38:54,370 --> 00:38:59,780
да се гарантира дека x + y не предизвикува целобројна претекување. "

414
00:38:59,780 --> 00:39:08,350
Значи ова има проблеми, тоа е цел број преливник, но јас не нешто погрешно.

415
00:39:08,350 --> 00:39:10,520
Јас не сум сигурен. Ќе се обидам да излезе со уште еден.

416
00:39:10,520 --> 00:39:13,640
[Студентски] Па, не е цел број претекување кога ќе се обидуваш да се стави број таму

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

418
00:39:16,640 --> 00:39:23,730
Да. Имаме 4 бита. That's - имавме 4 бита, тогаш ние се обидете да додадете 1 до тоа, па на крајот ќе заврши со 5 бита.

419
00:39:23,730 --> 00:39:26,690
Но, петтиот малку само се отсечени, да.

420
00:39:26,690 --> 00:39:28,970
Тоа би можело всушност -

421
00:39:28,970 --> 00:39:33,010
[Студентски] Дали тоа ќе фрли грешка, или дали тоа - тоа ќе фрли грешка?

422
00:39:33,010 --> 00:39:40,720
Не Значи нема грешка. Кога ќе стигнете до собранието ниво, посебно малку

423
00:39:40,720 --> 00:39:47,020
некаде е поставено тоа, вели имаше преливник, но во C сте вид на само не се занимаваат со тоа.

424
00:39:47,020 --> 00:39:55,160
Ти всушност не може да се справи со неа, освен ако не се користат специјални собранието инструкции во C.

425
00:39:55,160 --> 00:39:58,110
Ајде да размислиме за XOR swap.

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
Значи овој алгоритам всушност би можеле да работат, а + б, А - б, б - еден, а тоа може да биде добро.

432
00:40:28,930 --> 00:40:34,030
Но, има некои процесори кои не го сторат тоа, па тоа не би било во ред во овие специфични оние.

433
00:40:34,030 --> 00:40:39,880
XOR swap ќе работи на било кој процесор. Во ред.

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
Вие исто така може да се види ова напишано како ^ = б, б ^ = a, A ^ = b повторно.

444
00:41:51,860 --> 00:42:00,200
Значи ова е во право, и да се види зошто тоа функционира, мислам на битови.

445
00:42:00,200 --> 00:42:10,400
Користење на помала број, да речеме 11.001 и 01.100.

446
00:42:10,400 --> 00:42:12,790
Значи ова е "a", ова е б.

447
00:42:12,790 --> 00:42:15,540
Значи ^ = b.

448
00:42:15,540 --> 00:42:22,380
Ние ќе биде поставување 'A' = на 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
И (a ^ b) ^ а = оригиналниот б.

458
00:43:27,910 --> 00:43:37,010
Постои - уште еден начин на гледање на ова е нешто XOR себе е секогаш 0.

459
00:43:37,010 --> 00:43:45,020
Значи 1101 ^ 1101, сите делови се случува да бидат исти.

460
00:43:45,020 --> 00:43:47,920
Па таму никогаш не се случува да биде случај каде што 1 е 0, а другата е 1.

461
00:43:47,920 --> 00:43:51,080
Па ова е 0000.

462
00:43:51,080 --> 00:43:57,240
Истото со ова. (A ^ b) ^ б е како ^ (б ^ б).

463
00:43:57,240 --> 00:44:03,680
(Б ^ б) ќе биде 0; на ^ 0 е само ќе биде "еден", бидејќи сите битови се 0.

464
00:44:03,680 --> 00:44:08,050
Па само оние кои се случува да биде и онаму каде "a" првично беше 1 - имале оние.

465
00:44:08,050 --> 00:44:12,070
И истата идеја тука, јас сум прилично сигурен дека тоа е комутативен.

466
00:44:12,070 --> 00:44:17,590
Да. Јас реков пред тоа беше комутативен.

467
00:44:17,590 --> 00:44:24,680
На ^ 'а', и тоа е асоцијативно, па сега (б ^ а) ^ а.

468
00:44:24,680 --> 00:44:28,970
И можеме да направиме б ^ (a ^ а).

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
Тоа е овој случај овде. Ова е = b, стари б.

474
00:45:13,620 --> 00:45:16,550
Така, сега сè е назад во сменил ред.

475
00:45:16,550 --> 00:45:22,960
Ако ние всушност погледна на битови, b = a ^ b, ќе XOR овие 2,

476
00:45:22,960 --> 00:45:33,920
а одговорот ќе биде тоа, и тогаш = a ^ b е 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
Па затоа не треба да направите нешто за да всушност направиме swap. Да?

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

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

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
слично. Man 2 дека името на функцијата, или man 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
Во ред. Многу од man страниците се помалку од корисни.

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
и 1 алинеја доле случува да се каже, "Ф скенирање ѓ чита од стрингот точка или поток."

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
тука тој вели: "/ Корисник / share / речник / зборови."

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
Можете да замислите ѓ како, 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
Па сега на последната датотека функција која ние ќе сакате да го користите е скенирање ѓ, ѓ скенирање ѓ.

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
Ние сме скенирање над Ф.

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
Па да речеме имавме некои int, x = 4,

587
00:55:31,670 --> 00:55:41,110
и сакавме да се создаде низа направени од - сакав да се создаде низа

588
00:55:41,110 --> 00:55:44,250
тоа беше како, ова ќе дојде до многу подоцна,

589
00:55:44,250 --> 00:55:49,020
нешто што е исто како 4.jpg.

590
00:55:49,020 --> 00:55:51,870
Значи ова може да биде програма каде што ќе има сума контра,

591
00:55:51,870 --> 00:55:56,420
сумира спротивстави i, а сакате да ги зачувате еден куп на слики.

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
Значи стринг е - всушност ние што не се - карактер, знак е, ајде да одиме 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 со е x,

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,% 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
Ние сакаме да ја запази - "Скенирање ѓ семејството на функции скенира и во согласност со формат како обиде подолу.

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
Тоа се случува да [мрмори].

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 - да. Значи она што јас го дефинирање на вас пред да беше ги печати ѓ,

619
00:59:04,950 --> 00:59:09,820
кој - што го прави многу повеќе смисла, затоа реков дека е многу повеќе како печати ѓ.

620
00:59:09,820 --> 00:59:14,700
Скенирање 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
Значи она што скенирање ѓ прави - што беше твоето прашање ќе биде?

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 да ѓ скенирање ѓ сега, се надевам, ќе врзуваат назад во некој вид на патот.

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
i <40, i + +.

636
01:00:46,580 --> 01:00:51,130
Па ги печати ѓ% d.jpg на i.

637
01:00:51,130 --> 01:00:56,320
Па по оваа линија, сега променлива или низа s ќе 1.jpg.

638
01:00:56,320 --> 01:01:10,610
Или 0.jpg, 1.jpg, 2.jpg. И така ние може да се отвори, пак, секоја слика за читање.

639
01:01:10,610 --> 01:01:19,550
Значи тоа е она што ги печати ѓ прави. Дали ви се види она што е печати ѓ сега правиш?

640
01:01:19,550 --> 01:01:25,720
[Студентски] Океј, па тоа е преземање - тоа создава низа, something.jpg, а потоа продавници неа.

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

642
01:01:30,360 --> 01:01:37,530
каде што го внесува сите променливи во вториот аргумент, може да биде и како што се противат на i.

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
[Студентски] Значи, ако ние го сторивме тоа, е променлива ѓ само ќе биде прераспореден?

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
[Студентски] Но, ние не ќе биде во можност да пристапите или - во ред.

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 x.

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
[Студентски] Ако не вклучува нова линија, не ќе најдат делови на зборот?

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
[Студентски] Но, што ако барате зборот "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
Читаме во текот на целиот речник, чување линија по линија секој збор во променлива s.

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, тогаш можеме да печатиме ѓ, кои се исти,

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
[Студентски коментар, неразбирливо]

707
01:07:34,720 --> 01:07:40,870
О, никако не можев да се ослободи од таа пред тоа? Char е, претпоставувам рековме 127 - заборавам она што најголем е.

708
01:07:40,870 --> 01:07:44,100
Ние само ќе направи 128, па сега s е доволно долго.

709
01:07:44,100 --> 01:07:46,570
Ние не треба да се печати ништо.

710
01:07:46,570 --> 01:07:56,440
Ние сме, исто така, ќе сакаат да имаат да ги затвориме нашите датотека, и дека треба да биде околу вистинскиот одговор.

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