1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] Sectie Probleem Set 2: Hacker Edition

2
00:00:02,670 --> 00:00:04,910
Rob Bowden, Harvard University

3
00:00:04,910 --> 00:00:07,410
Dit is CS50. CS50.TV

4
00:00:07,410 --> 00:00:15,770
Dus, ik ben Rob. Ik ben een senior in Kirkland. Dit is mijn derde jaar TFing CS50.

5
00:00:15,770 --> 00:00:22,220
Het is de eerste keer dat we veranderen van de traditionele-lezing-style sectie,

6
00:00:22,220 --> 00:00:25,610
waar we gewoon een soort van beoordeling wat er in collegezalen en dan jullie vragen te stellen,

7
00:00:25,610 --> 00:00:32,250
nu het feit dat veel meer probleemgestuurd, waarbij we gebruik maken van Spaces, en -

8
00:00:32,250 --> 00:00:37,410
Oh, dus het idee is om naar die link die ik je gestuurd en dan zul je in mijn Space.

9
00:00:37,410 --> 00:00:42,410
Heeft iemand niet beschikt over een laptop? Oke.

10
00:00:42,410 --> 00:00:47,050
Dus we gaan gebruiken dit, en we gaan moeten doen problemen wonen in paragraaf

11
00:00:47,050 --> 00:00:50,740
en te bespreken en uit te zoeken wat er mis is

12
00:00:50,740 --> 00:00:56,390
en ik kan trek een deel van je code, en ik zou bespreek uw ideeën.

13
00:00:56,390 --> 00:01:02,140
Dus heeft iemand had moeite?

14
00:01:02,140 --> 00:01:07,000
U kunt chatten aan de kant, ik weet niet of we reden voor hebben.

15
00:01:07,000 --> 00:01:12,270
Nu, net als de vorige supersection, als je in die klasse, weet je wat dat over gaat.

16
00:01:12,270 --> 00:01:19,200
Op alle van P sets er gaat worden deze secties.

17
00:01:19,200 --> 00:01:22,550
Dus P-set 2, specificaties, ik denk dat je zag het al op de P-set 1.

18
00:01:22,550 --> 00:01:27,400
Maar we kunnen kijken naar P-set 2 voor wat we gaan te gaan over vandaag.

19
00:01:27,400 --> 00:01:29,460
En zie je een deel van de vragen.

20
00:01:29,460 --> 00:01:37,530
Dus zal dit in alle P-sets, er zal een deel van zijn vragen.

21
00:01:37,530 --> 00:01:41,340
Tot nu toe hebben we gezegd: "Beschouw dit als een kans om te oefenen."

22
00:01:41,340 --> 00:01:44,940
U wordt niet gevraagd om dit programma in te dienen.

23
00:01:44,940 --> 00:01:48,480
Het idee is dat deze worden verondersteld soort hulp die u aan de slag met het probleem set.

24
00:01:48,480 --> 00:01:53,220
Ik denk dat op de Hacker editie, zijn veel van hen zou gewoon nieuwe, interessante dingen te leren.

25
00:01:53,220 --> 00:01:58,590
Zij mogen niet rechtstreeks op het probleem set.

26
00:01:58,590 --> 00:02:01,810
En op dit moment zijn we niet met u stellen door, maar in theorie,

27
00:02:01,810 --> 00:02:07,480
voor later probleem sets, kunt u deze voorleggen, en daarom kun je ofwel komen in hoofdstuk

28
00:02:07,480 --> 00:02:10,380
of kijken naar de sectie om de antwoorden te krijgen, of je kunt ze gewoon te krijgen op je eigen

29
00:02:10,380 --> 00:02:16,350
als je geen zin hebt om te genieten van mijn aanwezigheid.

30
00:02:16,350 --> 00:02:21,010
Dus de - Ik denk dat dit de eerste.

31
00:02:21,010 --> 00:02:29,280
Oh. Ook onder deze secties van vragen die wij ook hebben jullie vragen stellen over de korte broek.

32
00:02:29,280 --> 00:02:33,440
Dus ik denk dat, in theorie, je moet om deze te bekijken voordat ik naar sectie

33
00:02:33,440 --> 00:02:38,550
maar het is fijn als je dat niet doet, zullen we toch te gaan over hen.

34
00:02:38,550 --> 00:02:42,590
Dus we kunnen beginnen met deze: "Hoe kan een while-lus verschillen van een do-while-lus?

35
00:02:42,590 --> 00:02:46,210
Wanneer is deze bijzonder nuttig? "

36
00:02:46,210 --> 00:02:49,390
Dus iemand enig -?

37
00:02:49,390 --> 00:02:52,730
[Student] De do-while-lus zal altijd uit te voeren ten minste een keer.

38
00:02:52,730 --> 00:03:02,950
Ja. Zodat het verschil. Een while-lus - Ik zal doen het gewoon hier te bekijken - maar loop, wij hebben de aandoening

39
00:03:02,950 --> 00:03:19,760
hier, terwijl een do-while, u niet beschikt over een aandoening totdat we hier beneden.

40
00:03:19,760 --> 00:03:24,130
En ja, wanneer je programma's uitvoeren, en het wordt aan de while-lus,

41
00:03:24,130 --> 00:03:26,380
controleert onmiddellijk als deze voorwaarde waar is.

42
00:03:26,380 --> 00:03:30,710
Indien aan deze voorwaarde niet waar is, zal het gewoon overslaan de lus volledig.

43
00:03:30,710 --> 00:03:34,390
Do-while-lus, als het programma wordt uitgevoerd, wordt het naar de "te doen."

44
00:03:34,390 --> 00:03:37,920
Er gebeurt niets op dit punt, maar verder wordt uitgevoerd.

45
00:03:37,920 --> 00:03:42,690
Toen het de "tijd" raakt als de voorwaarde waar is, zal het back-loop en het opnieuw doen

46
00:03:42,690 --> 00:03:46,730
en opnieuw en opnieuw totdat de conditie niet waar is en dan gewoon niet doorgaat.

47
00:03:46,730 --> 00:03:50,600
Dus, het verschil is, dat dit recht kan overslaan vanaf het allereerste begin.

48
00:03:50,600 --> 00:03:56,770
Deze voert noodzakelijkerwijs een keer en dan kan uitvoeren keer als de voorwaarde is nog steeds waar.

49
00:03:56,770 --> 00:04:03,720
Dus de while-lus zal maar een keer doen, of - de while-lus - we misschien niet nodig om het te doen op alle,

50
00:04:03,720 --> 00:04:07,900
omdat zodra we in te gaan als de voorwaarde onwaar is, zullen we precies goed negeren.

51
00:04:07,900 --> 00:04:11,770
Overwegende dat de do-while-lus, zullen we een keer voer het uit, per se.

52
00:04:11,770 --> 00:04:14,560
Dan, als we aan de voorwaarde, controleren we of het waar of onwaar is.

53
00:04:14,560 --> 00:04:19,790
Als het waar is, zullen we nog een keer doen, maar als het is vals, we zullen gewoon blijven gaan.

54
00:04:19,790 --> 00:04:24,680
Dus wanneer is de laatste vooral nuttig?

55
00:04:24,680 --> 00:04:31,190
Dus ik kan zeggen dat in het geheel van de 4 jaar, 3 jaar, wat dan ook,

56
00:04:31,190 --> 00:04:38,780
dat ik heb het programmeren, heb ik gebruik gemaakt van deze, zoals, onder 10 keer.

57
00:04:38,780 --> 00:04:43,140
En waarschijnlijk 5 van hen zijn in CS50 toen introduceren we do-while loops.

58
00:04:43,140 --> 00:04:47,510
Dus wanneer ga je gebruikt do-while loops?

59
00:04:47,510 --> 00:04:49,510
Wanneer is het - ja?

60
00:04:49,510 --> 00:04:53,180
[Student] Als je probeert om invoer van de gebruiker, of iets wat je wilt controleren te krijgen -

61
00:04:53,180 --> 00:04:59,700
Ja. Dus do-while loops, input van de gebruiker is de grote.

62
00:04:59,700 --> 00:05:03,160
Dat is de reden waarom op de eerste paar probleem sets, wanneer u de gebruiker wilt vragen, zoals,

63
00:05:03,160 --> 00:05:08,520
"Geef me een string," je kan niet doorgaan tot je die string.

64
00:05:08,520 --> 00:05:12,980
En dus, per definitie, moet om de string ten minste een keer.

65
00:05:12,980 --> 00:05:16,950
Maar dan, als ze antwoorden iets slechts, dan moet je loop terug en vraag het opnieuw.

66
00:05:16,950 --> 00:05:20,810
Maar anders dan input van de gebruiker, is het zeer zeldzaam dat ik geconfronteerd met een geval

67
00:05:20,810 --> 00:05:27,170
waar ik wil lus "ten minste een keer", maar mogelijk meer.

68
00:05:27,170 --> 00:05:33,370
Vragen of -? Heeft iemand een do-while-lus ergens anders gebruikt?

69
00:05:33,370 --> 00:05:36,780
Oke. Dus de volgende is: "Wat betekent zwartwerk identificatie

70
00:05:36,780 --> 00:05:43,310
meestal aangeven of uitgevoerd door clang? "

71
00:05:43,310 --> 00:05:47,380
Dus wat voor soort code kon ik schrijf om 'zwart identifier?'

72
00:05:47,380 --> 00:05:49,550
[Student] Dat x = 2?

73
00:05:49,550 --> 00:05:52,650
Dus we kunnen het uit te proberen hier, x = 2.

74
00:05:52,650 --> 00:06:04,830
We zullen het uitvoeren van deze - oh, ik heb niet op klikken. Dus hier krijgen we - in orde.

75
00:06:04,830 --> 00:06:07,100
"Gebruik van niet-aangegeven identifier x."

76
00:06:07,100 --> 00:06:11,610
Dus dat is de zwart identifier, een variabele.

77
00:06:11,610 --> 00:06:13,910
Het zal vaak belt een variabele een identifier.

78
00:06:13,910 --> 00:06:17,300
Dus is het misschien niet weet dat het eigenlijk een variabele, maar weet niet wat het is.

79
00:06:17,300 --> 00:06:19,380
Dus het is een identifier.

80
00:06:19,380 --> 00:06:26,060
Dus waarom is het zwartwerk? Ja.

81
00:06:26,060 --> 00:06:32,190
Dus om duidelijk te zijn over de terminologie, de verklaring van een variabele

82
00:06:32,190 --> 00:06:37,360
is als je zegt "int x," of "string y," wat dan ook.

83
00:06:37,360 --> 00:06:41,910
De initialisatie van de variabele of de toewijzing van de variabele

84
00:06:41,910 --> 00:06:44,510
is wanneer je zegt "x = 2."

85
00:06:44,510 --> 00:06:52,950
Dus we kunnen deze doen in afzonderlijke stappen, int x, x = 2, en tot - kunnen we een heleboel dingen hebben hier -

86
00:06:52,950 --> 00:07:00,350
maar tot deze lijn gebeurt, is nog steeds x geïnitialiseerde, maar het is verklaard.

87
00:07:00,350 --> 00:07:06,760
En dus kunnen we natuurlijk doen in 1 lijn, en nu zijn we verklaren en initialiseren.

88
00:07:06,760 --> 00:07:10,730
Vragen?

89
00:07:10,730 --> 00:07:18,390
En tenslotte: "Waarom is de Caesar Cipher niet erg veilig? '

90
00:07:18,390 --> 00:07:23,830
Dus eerst, wil iemand zeggen wat de Caesar Cipher is?

91
00:07:23,830 --> 00:07:28,100
[Student] Caesar Cipher precies is dat je in kaart, schuift u elke letter,

92
00:07:28,100 --> 00:07:34,420
een aantal brieven gaan over, en ga terug over, en het is niet erg veilig, omdat

93
00:07:34,420 --> 00:07:42,260
er is slechts 26 mogelijke opties en je moet gewoon om elk 1 proberen van die tot je het.

94
00:07:42,260 --> 00:07:45,470
Oh. Dus, moet ik herhalen?

95
00:07:45,470 --> 00:07:51,600
De Caesar Cipher, het is - ik bedoel, dan heb je te maken met het op de problemen die je -

96
00:07:51,600 --> 00:07:56,110
of ik denk dat de standaard editie van het probleem set die is niet op de hacker editie.

97
00:07:56,110 --> 00:08:01,550
Dus op de standaard editie van het probleem set, krijg je een melding als: "Hallo, wereld,"

98
00:08:01,550 --> 00:08:08,410
en je hebt ook een nummer als 6, en je neemt die boodschap, en elk individueel karakter,

99
00:08:08,410 --> 00:08:11,310
u de foto roteren met 6 posities in het alfabet.

100
00:08:11,310 --> 00:08:16,560
De 'h' in hello zou worden h-i-j-k-l-m-n.

101
00:08:16,560 --> 00:08:19,600
Dus de eerste letter zou zijn n. We doen hetzelfde met e.

102
00:08:19,600 --> 00:08:23,530
Als we een, zoals, z of iets, dan gaan we achterom wikkelen naar 'een.'

103
00:08:23,530 --> 00:08:29,280
Maar elk karakter krijgt gefietst 6 tekens later in het alfabet, en het is niet erg veilig

104
00:08:29,280 --> 00:08:35,440
omdat er slechts 26 mogelijkheden voor hoeveel manieren kun je een letter te wikkelen.

105
00:08:35,440 --> 00:08:42,919
Dus je kunt gewoon proberen alle 26 van hen en, vermoedelijk, voor een lang genoeg bericht,

106
00:08:42,919 --> 00:08:46,860
slechts 1 van die mogelijke 26 dingen gaat worden leesbaar,

107
00:08:46,860 --> 00:08:50,300
en de leesbare men gaat het oorspronkelijke bericht.

108
00:08:50,300 --> 00:08:56,240
Dus het is niet een zeer goede manier van coderen helemaal niets.

109
00:08:56,240 --> 00:08:59,070
Niets te maken met die korte broek, "Wat is een functie?"

110
00:08:59,070 --> 00:09:03,370
Dus wat is een functie? Ja.

111
00:09:03,370 --> 00:09:11,640
[Student] Het is als een apart stuk code die u kunt bellen om te gaan door en dan de return waarde van wat dan ook te krijgen.

112
00:09:11,640 --> 00:09:18,160
Ja. Dus ik zal beantwoorden door ook het beantwoorden van de volgende - of herhalen door ook gewoon het beantwoorden van de volgende.

113
00:09:18,160 --> 00:09:22,410
U kunt gebruik maken van functies in plaats van alleen kopiëren en plakken code over en weer.

114
00:09:22,410 --> 00:09:27,200
Neem de code, zet het in een fuction, en dan kon je gewoon bellen met de functie

115
00:09:27,200 --> 00:09:29,870
waar u ook zijn kopiëren en plakken.

116
00:09:29,870 --> 00:09:33,350
Dus zijn nuttig.

117
00:09:33,350 --> 00:09:35,860
Dus nu doen we de werkelijke problemen.

118
00:09:35,860 --> 00:09:46,490
De eerste. Dus het idee van de eerste is, passeert u het een string, en ongeacht de -

119
00:09:46,490 --> 00:09:52,060
of staat er allemaal kleine letters? Er staat niet dat alle kleine letters.

120
00:09:52,060 --> 00:09:57,730
Dus de boodschap kan van alles zijn, en - oh nee. Het doet.

121
00:09:57,730 --> 00:10:01,610
"Voor de eenvoud, kunt u ervan uitgaan dat de gebruiker zal alleen invoeren kleine letters en spaties."

122
00:10:01,610 --> 00:10:08,180
Dus geven we het een bericht met alleen kleine letters en dan gaan we afwisselen

123
00:10:08,180 --> 00:10:15,450
tussen hoofdletters en kleine - we veranderen de string aan het kapitaal en kleine letters, afgewisseld.

124
00:10:15,450 --> 00:10:22,920
Dus voordat we geven u een tweede om zelfs een duik in het probleem,

125
00:10:22,920 --> 00:10:32,420
wat is het eerste wat we moeten doen?

126
00:10:32,420 --> 00:10:36,900
O, wat heb ik net op? Oh, ik klikte op een e-mail hier.

127
00:10:36,900 --> 00:10:42,870
Dus het eerste wat we moeten doen - kijk ik naar de verkeerde?

128
00:10:42,870 --> 00:10:49,320
Is dit deel van deze?

129
00:10:49,320 --> 00:10:51,320
Nee, dat zijn er nog steeds in, dat wel.

130
00:10:51,320 --> 00:10:55,160
Oke, er nog steeds.

131
00:10:55,160 --> 00:11:03,160
Nu kunnen we er niet van uitgaan -? Ja. Hier kunnen we niet aannemen dat het alleen kleine letters en spaties.

132
00:11:03,160 --> 00:11:07,770
Dus nu hebben we te maken met het feit dat de letters kan zijn wat we willen dat ze zijn.

133
00:11:07,770 --> 00:11:11,910
En dus het eerste wat we willen doen is gewoon de boodschap.

134
00:11:11,910 --> 00:11:19,790
We moeten alleen een string te krijgen, string s = GetString, oke.

135
00:11:19,790 --> 00:11:24,890
Nu dit probleem, er zijn een paar manieren om het te doen.

136
00:11:24,890 --> 00:11:29,840
Maar we gaan hier wilt gebruiken bitwise operators.

137
00:11:29,840 --> 00:11:35,280
Zijn er mensen die ofwel niet waren op de supersection,

138
00:11:35,280 --> 00:11:37,480
of iets, en niet weet wat bitwise operators zijn?

139
00:11:37,480 --> 00:11:41,710
Of hoe zij betrekking hebben op ASCII of andere manier?

140
00:11:41,710 --> 00:11:45,650
[Student] Ik was niet op de supersection, maar ik weet wat bitwise operatoren zijn.

141
00:11:45,650 --> 00:11:49,560
Oke. Dus dan heb ik niet te gaan over de basis van hen, maar ik zal het uitleggen

142
00:11:49,560 --> 00:11:51,830
wat we gaan hier willen gebruiken.

143
00:11:51,830 --> 00:11:59,680
Dus 'A': binaire representatie van het kapitaal A, het nummer 65.

144
00:11:59,680 --> 00:12:07,560
Ik ga gewoon om naar te kijken - 41 gaat worden 01000001.

145
00:12:07,560 --> 00:12:14,170
Dus dat zou moeten zijn 65 in decimaal, dus dit is de binaire representatie van het personage kapitaal A.

146
00:12:14,170 --> 00:12:19,440
Nu de binaire representatie van het teken kleine letter 'a'

147
00:12:19,440 --> 00:12:33,350
gaat om het zelfde ding bijna zijn,. Is dat - 6, ja. Dit is gelijk.

148
00:12:33,350 --> 00:12:37,670
Dus binaire hoofdletter A, binaire kleine letter 'a'.

149
00:12:37,670 --> 00:12:43,940
Dus merken dat het verschil tussen de A en 'een' is dit enkele bit.

150
00:12:43,940 --> 00:12:49,440
En dit gebeurt als de 32 bit, het bit die het nummer 32.

151
00:12:49,440 --> 00:12:53,910
En dat is logisch, omdat A is 65 jaar; 'a' is 97.

152
00:12:53,910 --> 00:12:56,610
Het verschil tussen hen is 32.

153
00:12:56,610 --> 00:13:03,770
Dus nu we weten dat we kunnen van A naar 'een' te zetten door het nemen van een

154
00:13:03,770 --> 00:13:09,710
en bitwise ORing het, met - dat lijkt op een 1.

155
00:13:09,710 --> 00:13:20,900
Dit is een bitwise OR, met 00100000, en dat zal ons 'een.'

156
00:13:20,900 --> 00:13:26,850
En we kunnen krijgen van 'een' naar A door bitwise Anding

157
00:13:26,850 --> 00:13:33,700
met 11, 0 in die plaats, 11111.

158
00:13:33,700 --> 00:13:43,840
Dus dit zal dan geeft ons precies wat 'a' was, maar heffen deze persoon bit,

159
00:13:43,840 --> 00:13:50,070
dus we moeten 01000001, ik weet niet of ik telde rechts.

160
00:13:50,070 --> 00:13:56,750
Maar deze techniek van bitsgewijze Oring om van het kapitaal naar kleine letters,

161
00:13:56,750 --> 00:14:02,080
en bitwise Anding om van kleine letters tot kapitaal is niet exclusief voor A.

162
00:14:02,080 --> 00:14:06,510
Alle letters, K vs k, Z vs z,

163
00:14:06,510 --> 00:14:10,080
alle van hen zijn gewoon gaan verschillen door deze enkele bit.

164
00:14:10,080 --> 00:14:16,290
En dus je kunt dit gebruiken om vanaf een kleine letter veranderen in een hoofdletter en vice versa.

165
00:14:16,290 --> 00:14:26,670
Oke. Dus een makkelijke manier om van deze - dus in plaats van te

166
00:14:26,670 --> 00:14:32,170
schrijven wat 1011111 is - een gemakkelijke manier te vertegenwoordigen dit nummer, en dit is niet een

167
00:14:32,170 --> 00:14:39,710
dat ik ging in de supersection, maar tilde (~) is een andere logische bewerking.

168
00:14:39,710 --> 00:14:42,520
Wat ~ doet is het ziet er op de bit-representatie.

169
00:14:42,520 --> 00:14:45,630
Laten we een willekeurig aantal.

170
00:14:45,630 --> 00:14:53,130
Dit is slechts een binair getal, en welke ~ doet is het gewoon draait alle bits.

171
00:14:53,130 --> 00:15:00,630
Dus dit was een 1, een 0 nu is dit een 0 nu een 1, 010,100.

172
00:15:00,630 --> 00:15:08,320
Dus dat is allemaal ~ doet. Dus 32 is zal het nummer zijn - ontdoen van die te krijgen -

173
00:15:08,320 --> 00:15:23,320
dus 32 gaat het nummer 00100000, enzovoort ~ deze zal worden

174
00:15:23,320 --> 00:15:29,980
dit nummer hier dat ik 'a' ge-AND met.

175
00:15:29,980 --> 00:15:35,600
Heeft iedereen dat? Dit is vrij normaal, zoals wanneer je wilt uitzoeken

176
00:15:35,600 --> 00:15:40,740
voor later dingen die we zouden kunnen zien, wanneer we willen zien of -

177
00:15:40,740 --> 00:15:44,710
of we willen alles, elke bit set met uitzondering van 1

178
00:15:44,710 --> 00:15:47,910
je de neiging om te doen ~ van het beetje dat we niet willen stellen.

179
00:15:47,910 --> 00:15:53,090
Dus we niet de 32 bit set willen, dus we hoeven ~ van 32.

180
00:15:53,090 --> 00:15:57,790
Oke. Dus we kunnen hier gebruik maken van al die.

181
00:15:57,790 --> 00:16:03,000
Oke, dus het is prima als je nog niet klaar, we langzaam zullen samen lopen over,

182
00:16:03,000 --> 00:16:11,870
of lopen over dit, dus - via deze. Loop door deze.

183
00:16:11,870 --> 00:16:20,790
Dus we hebben onze string, en we willen lus over elk teken in die string en iets doen om het.

184
00:16:20,790 --> 00:16:26,710
Dus hoe kunnen we lus over een string? Wat moeten we gebruiken?

185
00:16:26,710 --> 00:16:30,980
Ik ben niet van plan om het te doen hier. Ja.

186
00:16:30,980 --> 00:16:42,940
Dus ik heb mijn iterator, en hij zei, maar hoe weet ik hoeveel tekens zijn in de string?

187
00:16:42,940 --> 00:16:47,030
Strlen (s) en i + +.

188
00:16:47,030 --> 00:16:49,860
Dus wat ik hier heb gedaan is niet de beste manier om dingen te doen.

189
00:16:49,860 --> 00:16:51,860
Weet iemand waarom?

190
00:16:51,860 --> 00:16:55,290
Omdat je het controleren van de taal van de snaar elke keer weer.

191
00:16:55,290 --> 00:17:06,859
Dus we gaan willen strlen bewegen, ik kon hier zeggen op, int lengte = strlen (s),

192
00:17:06,859 --> 00:17:11,900
en dan krijg ik <lengte, en in het geval je dat nog niet eerder gezien,

193
00:17:11,900 --> 00:17:20,410
Ik kon ook doen int i = 0, lengte = strlen (s).

194
00:17:20,410 --> 00:17:25,010
En dus is dit een beetje de voorkeur, want nu heb ik de ruimte beperkt

195
00:17:25,010 --> 00:17:29,150
van de variabele lengte tot net deze 'voor' lus, in plaats van te verklaren voordat

196
00:17:29,150 --> 00:17:34,990
en dat het bestaat altijd, en in het geval je niet vangen waarom dat is slecht,

197
00:17:34,990 --> 00:17:39,410
of waarom de oorspronkelijke was slecht, het is - beginnen bij de for-lus.

198
00:17:39,410 --> 00:17:43,380
Ik controleerde de toestand. Is i <de lengte van s?

199
00:17:43,380 --> 00:17:46,790
Dus de lengte van s, laten we werken met "hallo" de hele tijd.

200
00:17:46,790 --> 00:17:49,670
Zo lang s, h-e-l-l-o. De lengte is 5.

201
00:17:49,670 --> 00:17:57,580
Dus i = 0, lengte 5, dus niet i <5, zodat de lus blijft.

202
00:17:57,580 --> 00:18:02,750
Dan gaan we weer. Wij controleren de conditie. Is i <de lengte van hallo?

203
00:18:02,750 --> 00:18:08,390
Dus laten we gaan kijken naar de lengte van hello. H-e-l-l-o. Dat is 5; i aint <5, dus we blijven weer.

204
00:18:08,390 --> 00:18:13,330
Dus we zijn het berekenen, zijn we gedag te tellen, voor elke iteratie van de lus,

205
00:18:13,330 --> 00:18:17,380
dacht zelfs dat het nooit zal veranderen, het is altijd zal zijn 5.

206
00:18:17,380 --> 00:18:22,530
Dus we alleen niet vergeten 5 aan de voorkant, en nu is alles beter.

207
00:18:22,530 --> 00:18:24,990
Dus itereren over de gehele string.

208
00:18:24,990 --> 00:18:31,470
Wat willen we doen voor elk teken van de string?

209
00:18:31,470 --> 00:18:38,510
[Student spreken, onverstaanbaar]

210
00:18:38,510 --> 00:18:47,000
Ja. Dus, als de karakter is niet-alfabetische, dan we willen gewoon negeren.

211
00:18:47,000 --> 00:18:52,300
Omdat we alleen de zorg over alfabetische letters, we kunnen niet profiteren van een nummer.

212
00:18:52,300 --> 00:19:10,850
Dus hoe kunnen we dit doen? Dus onze toestand, dus als we iets willen - controleren of het is op alfabetische volgorde.

213
00:19:10,850 --> 00:19:14,060
Dus hoe kunnen we dit controleren?

214
00:19:14,060 --> 00:19:18,720
[Student] U kunt gewoon gebruik maken van de functie is alpha.

215
00:19:18,720 --> 00:19:23,160
Is dat in een van deze, of enige zijn, zoals, char.h of zo?

216
00:19:23,160 --> 00:19:32,710
Laten we geen gebruik van de functie is alfa, en de expliciete gebruiken - dus we hebben s [i],

217
00:19:32,710 --> 00:19:40,460
dat is het achtste teken van de s, bedenk dan dat een string is een array van karakters,

218
00:19:40,460 --> 00:19:43,180
zodat de achtste karakter van s.

219
00:19:43,180 --> 00:19:49,280
Nu, als het een hoofdletter, we weten dat moet in een specifiek bereik.

220
00:19:49,280 --> 00:19:54,370
En wat is dat bereik?

221
00:19:54,370 --> 00:20:07,860
Ja. Dus als s [i] is ≥ 65, en s [i] is ≤ 90, wat moet ik dan doen?

222
00:20:07,860 --> 00:20:18,470
Ja. Dus je moet absoluut niet eens nodig om de ASCII-waarden van iets ooit te weten komen.

223
00:20:18,470 --> 00:20:25,640
Nooit denken van de nummers 65, 90, 97 en 102, of wat het ook is.

224
00:20:25,640 --> 00:20:32,470
U hoeft niet - 112 -? Je hoeft niet om die helemaal te leren kennen. Dat is verkeerd ook.

225
00:20:32,470 --> 00:20:41,940
Gebruik alleen de single-aanhalingstekens, enkele aanhalingstekens constanten. Dus 'A' en minder dan 90 is 'Z.'

226
00:20:41,940 --> 00:20:47,930
En dit is veel beter - ik zou het niet weten uit de top van mijn hoofd dat Z 90.

227
00:20:47,930 --> 00:20:52,690
Ik weet uit de top van mijn hoofd dat 'Z' is hoofdletter Z.

228
00:20:52,690 --> 00:21:02,100
Dus zolang dit in het bereik van het kapitaal A tot kapitaal Z, of we kunnen controleren op kleine letters,

229
00:21:02,100 --> 00:21:17,010
Of als het in de range ≥ 'a' en ≤ z.

230
00:21:17,010 --> 00:21:19,010
Dus dat is onze toestand.

231
00:21:19,010 --> 00:21:22,520
De stijl waar je deze dingen varieert.

232
00:21:22,520 --> 00:21:29,520
Ik doe het op deze manier.

233
00:21:29,520 --> 00:21:31,520
Nu, wat we willen doen?

234
00:21:31,520 --> 00:21:39,530
We weten dat deze brief is een karakter, een letter uit het alfabet.

235
00:21:39,530 --> 00:21:46,270
Dus moeten we om te wisselen tussen de vraag of dit moet nu een hoofdletter of een kleine letter.

236
00:21:46,270 --> 00:21:48,820
Hoe kunnen we bijhouden welke we willen dat het?

237
00:21:48,820 --> 00:21:55,520
[Student stemmen, onverstaanbaar]

238
00:21:55,520 --> 00:21:59,150
Dus ja, maar laat me controleren.

239
00:21:59,150 --> 00:22:04,910
Module 0 tot 2 werd gezegd, was een suggestie gegooid, en ik ben het eens met dat.

240
00:22:04,910 --> 00:22:11,780
Behalve merken dat, net als - is dit het geval? Ja.

241
00:22:11,780 --> 00:22:18,270
Het is ieder ander, maar we kunnen niet module 2 van i of i mod 2, omdat

242
00:22:18,270 --> 00:22:22,950
merken dat E is kapitaal en "a" kleine letters? Maar er is een ruimte die hen scheidt?

243
00:22:22,950 --> 00:22:27,150
Dus ze gaan naar dezelfde mod 2 zijn, maar ze zijn verschillende gevallen.

244
00:22:27,150 --> 00:22:29,150
[Student vraag, onverstaanbaar]

245
00:22:29,150 --> 00:22:34,690
Ja. Dus we gaan gewoon om een ​​telling te houden.

246
00:22:34,690 --> 00:22:38,730
We kunnen ook doen dat hier als we wilden, die misschien een beetje onhandig

247
00:22:38,730 --> 00:22:41,300
in de for-lus verklaringen, ik zet het hier.

248
00:22:41,300 --> 00:22:48,840
Dus int count = begint bij 0.

249
00:22:48,840 --> 00:22:54,070
En nu, ga ik tellen hoeveel alfabetische tekens die we hebben gehad.

250
00:22:54,070 --> 00:22:59,550
Dus we onvermijdelijk gaan tellen + + omdat we een andere letter uit het alfabet gevonden.

251
00:22:59,550 --> 00:23:09,130
Maar, dus nu je zegt als tellen mod 2.

252
00:23:09,130 --> 00:23:12,590
Dus wat als tellen mod 2? Oh. Ik doe == 0 voor nu.

253
00:23:12,590 --> 00:23:21,740
We zullen ook gaan over dat. Dus als tellen mod 2 == 0, wat dan?

254
00:23:21,740 --> 00:23:27,830
[Studenten antwoord, onverstaanbaar]

255
00:23:27,830 --> 00:23:32,750
Dus we willen dat het uiteindelijk hoofdletters.

256
00:23:32,750 --> 00:23:37,520
Er zijn 2 gevallen; hoofdletters en kleine letters zijn de 2 gevallen.

257
00:23:37,520 --> 00:23:40,990
Dus als we in kleine letters moeten we maken hoofdletters.

258
00:23:40,990 --> 00:23:43,710
Als het hoofdletters we niet nodig om iets te doen.

259
00:23:43,710 --> 00:23:50,760
Maar is er een manier - shouldn't hebben omgedraaid -

260
00:23:50,760 --> 00:23:54,800
dat we niet eens nodig om te controleren of het hoofdletters of kleine letters?

261
00:23:54,800 --> 00:24:02,240
Wat kunnen we doen om altijd ervoor te zorgen dat we altijd terecht bij hoofdletters?

262
00:24:02,240 --> 00:24:07,830
Dus let op wat we deden voor kleine 'a', wat als we dit precies hetzelfde deed met een hoofdletter?

263
00:24:07,830 --> 00:24:11,900
Doet hoofdletters Een verandering, of is de waarde veranderen?

264
00:24:11,900 --> 00:24:23,100
Ja. Dus elke hoofdletter bitwise ge-AND met ~ 32 gaat diezelfde hoofdletter worden

265
00:24:23,100 --> 00:24:29,220
want voor elke hoofdletter de 32e bit wordt niet ingesteld.

266
00:24:29,220 --> 00:24:40,920
Dus als we willen om het teken s [i], we willen dat het wordt kleine letters of hoofdletters te brengen.

267
00:24:40,920 --> 00:24:46,890
Dus als het was kleine, het is nu hoofdletter, als het hoofdletters, het nog steeds hoofdletters is, en dat is het.

268
00:24:46,890 --> 00:24:54,290
Ik zei dit in de supersection: U kunt gebruik maken van 32 als je wilt, maar ik ben geneigd de voorkeur te geven doen 'een' - A,

269
00:24:54,290 --> 00:25:01,150
plaats van gewoon 32, omdat het andere beetje.

270
00:25:01,150 --> 00:25:03,610
Na de 32 bit, kan elk van deze of we zouden niet genoeg

271
00:25:03,610 --> 00:25:05,840
nummers alle tekens vertegenwoordigen.

272
00:25:05,840 --> 00:25:09,110
Dus als je de 32-bits te krijgen, het zou de 64-bits zijn, kan het de 128-bits.

273
00:25:09,110 --> 00:25:13,990
Elk van deze bits kan de bit die onderscheid maakt tussen hoofdletters en kleine letters zijn.

274
00:25:13,990 --> 00:25:18,350
Ik zou niet te weten dat het de 32 bit.

275
00:25:18,350 --> 00:25:27,130
Ik kan deze 'a' - A tot de bit die verschilt tussen de twee te krijgen

276
00:25:27,130 --> 00:25:33,000
zonder een beroep te doen op het magische getal dat is 32.

277
00:25:33,000 --> 00:25:38,770
En nu, anders tellen was vreemd, en dus wat wil ik doen?

278
00:25:38,770 --> 00:25:43,920
[Student antwoorden, onverstaanbaar]

279
00:25:43,920 --> 00:25:45,920
[Student] Wat is dat?

280
00:25:45,920 --> 00:25:49,850
Ik zal het doen in 1 seconde.

281
00:25:49,850 --> 00:25:55,690
Dus nu als ik wil - Ik wil ervoor zorgen dat de karakter is nu kleine letters,

282
00:25:55,690 --> 00:26:04,140
en dus ik kan of met 32, en 32 betekent 'een' - A.

283
00:26:04,140 --> 00:26:06,510
Maar let op, door dezelfde redenering als de vorige, dat als

284
00:26:06,510 --> 00:26:11,670
de brief was al kleine letters, dan ORing met 32 ​​blijft maar kleine letters het.

285
00:26:11,670 --> 00:26:16,220
Het is niet veranderd van het oorspronkelijke karakter.

286
00:26:16,220 --> 00:26:19,910
Maar nu heb ik niet om te voorkomen dat te zeggen, "Als het kleine, vergeet het dan maar,

287
00:26:19,910 --> 00:26:23,650
als het hoofdletters, dan veranderen. "

288
00:26:23,650 --> 00:26:26,900
Het is veel handiger om dit te doen.

289
00:26:26,900 --> 00:26:33,190
[Student] Zou dat de strategie van het aftrekken van de hoofdletters van de kleine letters werk als het niet 32?

290
00:26:33,190 --> 00:26:35,330
Als het was, zoals, 34 of zo?

291
00:26:35,330 --> 00:26:41,840
Dus, je moet weten dat het verschil tussen de 2 is -? >> 1 bit.

292
00:26:41,840 --> 00:26:49,840
Het kan meer dan een beetje, zolang alle bits boven dit punt zijn hetzelfde.

293
00:26:49,840 --> 00:26:58,500
Dus we moeten ten minste 26 tekens - of, zijn er 26 tekens.

294
00:26:58,500 --> 00:27:04,590
Dus we moeten ten minste 26 nummers om het verschil te vertegenwoordigen -

295
00:27:04,590 --> 00:27:07,650
Het verschil tussen A en A moet ten minste 26,

296
00:27:07,650 --> 00:27:10,760
of anders zouden we niet hebben vertegenwoordigd alle hoofdstad nummers.

297
00:27:10,760 --> 00:27:18,630
Dat betekent dat A wanneer we beginnen bij 1, het zal al deze bits te gebruiken,

298
00:27:18,630 --> 00:27:23,900
al deze eerste 5 bits, om alles te vertegenwoordigen tot en met Z.

299
00:27:23,900 --> 00:27:32,170
Dat is de reden waarom de volgende bit, of deze bit, de volgende bits is degene die is gekozen om onderscheid te maken tussen A en 'een.'

300
00:27:32,170 --> 00:27:40,930
Dat is ook de reden waarom, in ASCII-tabel, zijn er 5 symbolen te scheiden hoofdletters van kleine letters.

301
00:27:40,930 --> 00:27:49,050
Daar zijn de symbolen, de extra 5 dat brengt de 32 zijnde het verschil tussen hen.

302
00:27:49,050 --> 00:27:51,840
[Student] Dus we konden doen, omdat ASCII is ontworpen op die manier.

303
00:27:51,840 --> 00:27:57,280
Ja. Maar ASCII - het verschil kan ook beide bits.

304
00:27:57,280 --> 00:28:12,040
Zoals, als A waren 10000001, en 'een' was 11100001 - ik het vergeet, wat dan ook.

305
00:28:12,040 --> 00:28:18,100
Maar als het dit, dan kunnen we nog steeds gebruik maken van 'a' - A.

306
00:28:18,100 --> 00:28:22,650
Het is gewoon nu het verschil tussen A en 'a' is nog steeds deze 2 bits.

307
00:28:22,650 --> 00:28:32,240
Ik denk dat het 48 geschreven. Is het 32 ​​+ 64? Ik denk dat het is?

308
00:28:32,240 --> 00:28:40,160
Het zou nog 2 bits; elke letter, zoals, Z en Z, K en k,

309
00:28:40,160 --> 00:28:45,160
zouden ze nog steeds exact dezelfde bits ingesteld met uitzondering van de 2 bits.

310
00:28:45,160 --> 00:28:48,870
Dus zolang die altijd waar is, ongeacht of we met behulp van ASCII of een ander systeem,

311
00:28:48,870 --> 00:28:53,050
zolang er slechts een bepaald aantal bits die verschillend zijn voor elk teken,

312
00:28:53,050 --> 00:28:55,050
dan is dat werkt prima.

313
00:28:55,050 --> 00:29:06,110
Het is gewoon dat 32 is opgezet, want het is de eerste die we zouden kunnen gebruiken. >> Cool.

314
00:29:06,110 --> 00:29:14,520
Ik ben geneigd de voorkeur te geven, voor het geval je dat nog niet gezien, als het blok is slechts een enkele lijn,

315
00:29:14,520 --> 00:29:24,280
je kunt ontdoen van de accolades, dus ik de neiging om de voorkeur om dit te doen.

316
00:29:24,280 --> 00:29:34,010
Ook, je weet hoe we dingen doen zoals s [i] + = 1?

317
00:29:34,010 --> 00:29:41,090
U kunt ook s [i] bitwise AND = 32.

318
00:29:41,090 --> 00:29:46,400
En bitwise OR = 32.

319
00:29:46,400 --> 00:29:51,490
Ook tellen mod 2 == 0.

320
00:29:51,490 --> 00:30:00,900
Dus denk eraan dat - ik zal niet schrijven - elke niet-nul waarde true is, en 0 is onwaar.

321
00:30:00,900 --> 00:30:07,880
Dus "indien count mod 2 == 0" is hetzelfde als zeggen "als deze niet meetellen mod 2."

322
00:30:07,880 --> 00:30:11,580
Ik zou waarschijnlijk net omgekeerd de lijnen en zei: "Als count mod 2,

323
00:30:11,580 --> 00:30:15,350
anders komen de OF 1, zijn de EN 1, "zodat ik geen behoefte aan de" niet. "

324
00:30:15,350 --> 00:30:18,650
Maar dit werkt net zo goed.

325
00:30:18,650 --> 00:30:25,660
En wat kan ik hier doen?

326
00:30:25,660 --> 00:30:29,060
Je zou kunnen combineren ze met ternaire als je wilde, maar dan is dat net had om dingen messier

327
00:30:29,060 --> 00:30:33,770
en waarschijnlijk moeilijker te lezen, dus we zullen dat niet doen.

328
00:30:33,770 --> 00:30:37,330
Iemand nog andere suggesties?

329
00:30:37,330 --> 00:30:41,580
Is dat alles wat het probleem gevraagd? Oh yeah.

330
00:30:41,580 --> 00:30:51,070
Dus ontdoen van deze lege regels, nu wij drukken f,% s, zijnde het voor strijkers,

331
00:30:51,070 --> 00:30:56,620
Wij drukken f, s.

332
00:30:56,620 --> 00:30:59,330
Laten we nu uitvoeren. Heb ik iets verkeerd?

333
00:30:59,330 --> 00:31:03,200
Dat is een \ "; Ik wil een n.

334
00:31:03,200 --> 00:31:07,840
Oke. Nu gaan we draaien. Het zal waarschijnlijk tegen me schreeuwen.

335
00:31:07,840 --> 00:31:11,250
Strlen in string.h.

336
00:31:11,250 --> 00:31:14,290
Dus dit is het leuke van Clang is het vertelt je hoe het is in,

337
00:31:14,290 --> 00:31:19,140
in plaats van GCC die gewoon zegt: "He, je iets vergeten, ik weet niet wat het was."

338
00:31:19,140 --> 00:31:29,220
Maar dit zal mij vertellen, "Je bedoeld string.h op te nemen."

339
00:31:29,220 --> 00:31:32,130
Dus ik heb niet gevraagd voor iets, dus het is niet iets te zeggen.

340
00:31:32,130 --> 00:31:42,540
Maar we zullen doen hun voorbeeld, "Thanks 4 the add".

341
00:31:42,540 --> 00:31:47,880
Dat ziet er goed uit. Hooray.

342
00:31:47,880 --> 00:31:52,370
Dus terug te keren naar uw belangrijkste, ik bijna nooit doen.

343
00:31:52,370 --> 00:31:57,110
Het is optioneel. En de belangrijkste is de enige functie waarvoor het is optioneel.

344
00:31:57,110 --> 00:32:07,140
Als je niet iets terug van de belangrijkste, is ervan uitgegaan dat je bedoelde op 0 terug te keren.

345
00:32:07,140 --> 00:32:13,070
Vragen?

346
00:32:13,070 --> 00:32:20,980
Oke. Dus nu het tweede probleem.

347
00:32:20,980 --> 00:32:24,810
"Recall uit de tweede week 2 van de lezing die ruilt 2 variabelen 'waarden door het passeren van

348
00:32:24,810 --> 00:32:30,780
die 2 variabelen om een ​​functie (ook al genoemd swap) niet precies, werken in ieder geval niet zonder 'pointers'. "

349
00:32:30,780 --> 00:32:37,020
En negeer pointers tot we bij hen.

350
00:32:37,020 --> 00:32:40,070
We willen 2 variabelen wisselen, we zijn niet met behulp van een functie om het te doen.

351
00:32:40,070 --> 00:32:43,410
We zijn nog steeds gaan om het te doen in de belangrijkste, zoals het zegt.

352
00:32:43,410 --> 00:32:48,360
Maar om die 2 variabelen gebruiken, we willen niet naar een tijdelijke variabele te gebruiken.

353
00:32:48,360 --> 00:32:50,770
Er zijn 2 manieren om dit te doen.

354
00:32:50,770 --> 00:32:56,310
U kunt dit doen met behulp van uw traditionele binaire operatoren.

355
00:32:56,310 --> 00:33:00,180
Dus weet iemand een snelle en vuile manier om dat te doen?

356
00:33:00,180 --> 00:33:07,650
Het zou eigenlijk een minuut van denken. Als ik -

357
00:33:07,650 --> 00:33:12,130
Ik zet het probleem op als ze vragen. Dus als ik 2 variabelen hebben, Een, dat is gewoon een geheel getal

358
00:33:12,130 --> 00:33:17,800
dat ze mij geven, en som variabele B, dat is een ander geheel getal dat ik gegeven.

359
00:33:17,800 --> 00:33:22,700
Dus als ik deze 2 variabelen, nu wil ik om ze te verwisselen.

360
00:33:22,700 --> 00:33:31,550
De traditionele, met behulp van uw reguliere binaire operatoren, ik bedoel, zoals +, -, ÷.

361
00:33:31,550 --> 00:33:36,630
Niet bitwise operatoren die inwerken op binair.

362
00:33:36,630 --> 00:33:39,600
Dus met behulp van -, +, ÷, en al die.

363
00:33:39,600 --> 00:33:52,980
We konden wisselen door het doen van iets als a = a + b en b = a - b, a = a - b.

364
00:33:52,980 --> 00:34:04,260
Dus, geestelijke gezondheid controleren, en dan zien we wel hoe dat werkt.

365
00:34:04,260 --> 00:34:13,320
Stel dat a = 7, b = 3, a + b dan gaat worden 10.

366
00:34:13,320 --> 00:34:18,820
Dus we nu het instellen van een = 10, en dan doen we b = a - b.

367
00:34:18,820 --> 00:34:30,250
Dus we doen b = a - b, die zal worden 7 en b = a - b weer,

368
00:34:30,250 --> 00:34:38,650
of a = a - b. Die zal: 10 - 7, dat is 3.

369
00:34:38,650 --> 00:34:44,850
Dus nu, terecht, 'a' was 7, b was 3, en nu b is 7 en "a" 3.

370
00:34:44,850 --> 00:34:48,679
Dat soort zinvol, 'a' is de combinatie van de 2 getallen.

371
00:34:48,679 --> 00:34:53,000
Op dit punt, 'a' is de combinatie, en dan zijn we af te trekken van de oorspronkelijke b,

372
00:34:53,000 --> 00:34:56,860
en dan gaan we aftrekken van wat was de oorspronkelijke 'een.'

373
00:34:56,860 --> 00:35:01,150
Maar dit werkt niet voor alle nummers.

374
00:35:01,150 --> 00:35:08,880
Om dit te zien, laten we eens kijken een systeem, dus denken we meestal van gehele getallen als 32 bits.

375
00:35:08,880 --> 00:35:13,050
Laten we werken aan iets dat is nog maar net 4 bits.

376
00:35:13,050 --> 00:35:15,450
Hopelijk heb ik komen met een goed voorbeeld op dit moment.

377
00:35:15,450 --> 00:35:18,680
Dus, ik weet het, dit gemakkelijk zal zijn.

378
00:35:18,680 --> 00:35:26,720
Laten we zeggen dat onze 2 nummers zijn 1111, en 1111, dus we zijn in binaire nu.

379
00:35:26,720 --> 00:35:34,630
In werkelijkheid decimalen, als je wilt om te denken van het op die manier, a = 15 en b = 15.

380
00:35:34,630 --> 00:35:37,630
En dus verwachten we, nadat we ruilen - ze niet eens te zijn dezelfde nummers,

381
00:35:37,630 --> 00:35:41,140
maar ik heb het op deze manier.

382
00:35:41,140 --> 00:35:47,100
Laten we hen niet dezelfde nummers. Laten we 1111 en 0001.

383
00:35:47,100 --> 00:35:51,860
Dus a = 15 en b = 1.

384
00:35:51,860 --> 00:35:57,670
Nadat we ruilen ze, verwachten we dat 'een' te zijn 1 en b te zijn 15.

385
00:35:57,670 --> 00:36:01,780
Dus onze eerste stap is a = a + b.

386
00:36:01,780 --> 00:36:08,770
De cijfers zijn slechts 4 bits breed, zodat 'een', dat is 1111, + b, die 0001,

387
00:36:08,770 --> 00:36:16,780
gaat uiteindelijk op een 10000, maar we hebben maar 4 bits.

388
00:36:16,780 --> 00:36:22,540
Dus nu a = 0.

389
00:36:22,540 --> 00:36:34,080
En nu willen we het b = a - b - in feite, nog steeds dit werkt perfect.

390
00:36:34,080 --> 00:36:39,630
a = a - b - laten we eens kijken of dit werkt perfect.

391
00:36:39,630 --> 00:36:53,720
Dus dan b = 0 - 1, wat nog steeds 15 en a = a - b, die zou zijn 1.

392
00:36:53,720 --> 00:36:56,210
Misschien werkt dit wel.

393
00:36:56,210 --> 00:36:59,020
Ik heb het gevoel alsof er een reden waarom het niet werkt met behulp van reguliere.

394
00:36:59,020 --> 00:37:06,400
Oke, dus het werken in de veronderstelling dat het niet werkt met gewone binaire operaties,

395
00:37:06,400 --> 00:37:15,040
en ik zal kijken voor - ik zal Google om te zien of dat waar is.

396
00:37:15,040 --> 00:37:23,490
Dus we willen doen met behulp van bitwise operators, en het idee is hier XOR.

397
00:37:23,490 --> 00:37:28,780
Dus, de invoering van XOR (^) als je het nog niet gezien.

398
00:37:28,780 --> 00:37:34,610
Het is, nogmaals, een logische bewerking dus het werkt beetje bij beetje, en het is -

399
00:37:34,610 --> 00:37:39,910
Als je de bits 0 en 1, dan zal dit 1.

400
00:37:39,910 --> 00:37:45,230
Als je de bits 1 en 0, het zal 1, heb je de bits 0 en 0 het zal 0,

401
00:37:45,230 --> 00:37:47,640
en als je de bits 1 en 1 hebben het zal 0.

402
00:37:47,640 --> 00:37:56,180
Dus het is alsof OR. Als een van de bits waar is, is 1, maar in tegenstelling OR, het kan niet beide bits die waar.

403
00:37:56,180 --> 00:37:59,320
Of zou dit hebben op 1, zou XOR hebben dit 0 zijn.

404
00:37:59,320 --> 00:38:02,250
Dus we gaan hier willen gebruiken XOR.

405
00:38:02,250 --> 00:38:09,960
Denk er eens over voor een minuut, ik ga naar Google.

406
00:38:09,960 --> 00:38:16,230
Nou, je kunt niet lezen dat, ik ben momenteel op de XOR swap algoritme pagina.

407
00:38:16,230 --> 00:38:21,340
Hopelijk zal dit uitleggen waarom Ik kan niet -

408
00:38:21,340 --> 00:38:34,190
Dit is precies het algoritme dat we net gedaan.

409
00:38:34,190 --> 00:38:37,330
Ik snap nog steeds niet waarom - ik moet gewoon hebben gekozen voor een slecht voorbeeld,

410
00:38:37,330 --> 00:38:44,940
maar dit geval waarin a toevallig worden 0, na verkrijgen van 5 bits, zodat nu 'a' is 0,

411
00:38:44,940 --> 00:38:48,730
dat is wat wordt genoemd "integer overflow".

412
00:38:48,730 --> 00:38:54,370
Volgens Wikipedia, "In tegenstelling tot de XOR swap, deze variatie vereist dat het aantal methoden gebruikt

413
00:38:54,370 --> 00:38:59,780
te waarborgen dat x + y geen geheel getal overflow veroorzaken. "

414
00:38:59,780 --> 00:39:08,350
Dus dit heeft wel problemen, dit was integer overflow, maar ik deed iets verkeerd.

415
00:39:08,350 --> 00:39:10,520
Ik weet het niet zeker. Ik zal proberen om te komen met een ander.

416
00:39:10,520 --> 00:39:13,640
[Student] Nou, is niet integer overflow wanneer je probeert om een ​​nummer in daar te zetten

417
00:39:13,640 --> 00:39:16,640
groter dan de hoeveelheid bits die u hebt toegewezen?

418
00:39:16,640 --> 00:39:23,730
Ja. We hebben 4 bits. Dat is - we hadden 4 bits, dan proberen we tot en met 1 toe te voegen, zodat we uiteindelijk met 5 bits.

419
00:39:23,730 --> 00:39:26,690
Maar de vijfde bit net wordt afgesneden, ja.

420
00:39:26,690 --> 00:39:28,970
Het zou kunnen eigenlijk -

421
00:39:28,970 --> 00:39:33,010
[Student] Maakt dat gooi je een fout, of is dat - zou dat een fout optreedt?

422
00:39:33,010 --> 00:39:40,720
Nee Dus er is geen fout. Als je bij de montage-niveau, een bijzonder stukje

423
00:39:40,720 --> 00:39:47,020
ergens is ingesteld dat zei dat er een overloop, maar in C je soort van gewoon niet omgaan met dat.

424
00:39:47,020 --> 00:39:55,160
Je kan eigenlijk niet mee omgaan, tenzij u gebruik maken van speciale montage-instructies in C.

425
00:39:55,160 --> 00:39:58,110
Laten we eens nadenken over XOR swap.

426
00:39:58,110 --> 00:40:02,220
En ik denk dat het Wikipedia artikel kan ook zijn te zeggen dat -

427
00:40:02,220 --> 00:40:07,310
Dus het bracht ook modulaire rekenkunde, dus ik denk dat ik was, in theorie, het doen van modulaire rekenkunde

428
00:40:07,310 --> 00:40:11,160
toen ik zei dat 0 - 1 is weer 15.

429
00:40:11,160 --> 00:40:15,410
Dus dat in feite zou kunnen - op een regelmatige processor die 0 doet - 1 = 15.

430
00:40:15,410 --> 00:40:20,430
Aangezien we eindigen op 0, trekken we 1, dus dan is het wraps gewoon terug rond om 1111.

431
00:40:20,430 --> 00:40:28,930
Dus dit algoritme zou eigenlijk de a + b, de a - b, b - a; mogelijk goed.

432
00:40:28,930 --> 00:40:34,030
Maar er is een aantal processoren die geen doen, en dus het zou niet goed zijn in die specifieke.

433
00:40:34,030 --> 00:40:39,880
XOR swap zal werken op een processor. Oke.

434
00:40:39,880 --> 00:40:42,280
Het idee is dat het zou moeten zijn hetzelfde, hoewel.

435
00:40:42,280 --> 00:40:50,120
Waar maken we gebruik van XOR om de informatie van zowel een of andere manier te krijgen in een van de variabelen,

436
00:40:50,120 --> 00:40:54,120
en trek vervolgens de gegevens van de individuele variabelen weer.

437
00:40:54,120 --> 00:41:04,330
Dus heeft iemand nog ideeën / het antwoord?

438
00:41:04,330 --> 00:41:14,540
[Student antwoord, onverstaanbaar]

439
00:41:14,540 --> 00:41:22,220
Dus dit zou moeten werken, en ook, XOR is commutatief.

440
00:41:22,220 --> 00:41:27,620
Ongeacht welke volgorde deze 2 nummers toevallig in hier,

441
00:41:27,620 --> 00:41:30,100
dit resultaat zal hetzelfde.

442
00:41:30,100 --> 00:41:35,800
Dus een ^ b is b ^ a.

443
00:41:35,800 --> 00:41:51,860
U kunt ook zien geschreven als een ^ = b, b ^ = a, a ^ = b opnieuw.

444
00:41:51,860 --> 00:42:00,200
Dus dit is recht, en te zien waarom dit werkt, denk aan de bits.

445
00:42:00,200 --> 00:42:10,400
Met behulp van een vrij kleine aantal, laten we zeggen 11001, en 01100.

446
00:42:10,400 --> 00:42:12,790
Dus dit is 'a', dit is b.

447
00:42:12,790 --> 00:42:15,540
Dus een ^ = b.

448
00:42:15,540 --> 00:42:22,380
We gaan worden het instellen van "a" = de XOR van deze 2 dingen.

449
00:42:22,380 --> 00:42:32,920
Dus 1 ^ 0 is 1, 1 ^ 1 0, 0 ^ 1 1 en 0 ^ 0 is 0, 1 ^ 0 1.

450
00:42:32,920 --> 00:42:37,380
Dus 'een,' als je kijkt naar het decimale getal, het gaat om -

451
00:42:37,380 --> 00:42:41,160
je bent niet van plan om veel van een relatie tussen de oorspronkelijke 'a' en de nieuwe zie 'a,'

452
00:42:41,160 --> 00:42:45,600
maar gezien de bits, 'a' is nu als een mesh van de informatie

453
00:42:45,600 --> 00:42:49,970
van zowel de oorspronkelijke 'a' en de oorspronkelijke b.

454
00:42:49,970 --> 00:42:57,930
Dus als we b ^ een, zien we dat we uiteindelijk op de oorspronkelijke 'een.'

455
00:42:57,930 --> 00:43:08,910
En als we de oorspronkelijke 'a' ^ de nieuwe 'a,' zien we belanden we op de oorspronkelijke b.

456
00:43:08,910 --> 00:43:18,380
Dus (a ^ b) ^ b = de oorspronkelijke 'een.'

457
00:43:18,380 --> 00:43:27,910
En (a ^ b) ^ a = de oorspronkelijke b.

458
00:43:27,910 --> 00:43:37,010
Er is - een andere manier van kijken is dit iets XOR zelf is altijd 0.

459
00:43:37,010 --> 00:43:45,020
Dus 1101 ^ 1101, worden alle bits naar hetzelfde.

460
00:43:45,020 --> 00:43:47,920
Er zal nooit een geval waarin 1 een 0 en de andere is 1 zijn.

461
00:43:47,920 --> 00:43:51,080
Dus dit is 0000.

462
00:43:51,080 --> 00:43:57,240
Hetzelfde met dit. (A ^ b) ^ b is als een ^ (b ^ b).

463
00:43:57,240 --> 00:44:03,680
(B ^ b) gaat als: 0; a ^ 0 wordt alleen maar als 'een', omdat alle bits 0 zijn.

464
00:44:03,680 --> 00:44:08,050
Dus de enigen die zullen worden waar 'een' was oorspronkelijk een 1 - hadden degenen.

465
00:44:08,050 --> 00:44:12,070
En hetzelfde idee hier, ik ben er vrij zeker van dat het ook commutatief is.

466
00:44:12,070 --> 00:44:17,590
Ja. Ik heb zeggen voordat dat het commutatieve was.

467
00:44:17,590 --> 00:44:24,680
De ^ 'a,' en het is associatief, dus nu (b ^ a) ^ a.

468
00:44:24,680 --> 00:44:28,970
En we kunnen doen b ^ (a ^ a).

469
00:44:28,970 --> 00:44:31,540
En dus nogmaals, we krijgen de oorspronkelijke b.

470
00:44:31,540 --> 00:44:37,120
Dus 'a' is nu de combinatie van 'a' en b samen.

471
00:44:37,120 --> 00:44:49,660
Met behulp van onze nieuwe combo 'a' zeggen we b = combo 'a' ^ de oorspronkelijke b, krijgen we de oorspronkelijke 'een.'

472
00:44:49,660 --> 00:45:05,170
En nu a = combo 'a' ^ de nieuwe b, dat was de oorspronkelijke - of die nu wat was 'a' of b.

473
00:45:05,170 --> 00:45:13,620
Dat is dit geval hier beneden. Dit is = b, oud b.

474
00:45:13,620 --> 00:45:16,550
Dus nu is alles weer in de geruilde volgorde.

475
00:45:16,550 --> 00:45:22,960
Als we echt gekeken naar de bits, b = a ^ b, gaat deze 2 XOR,

476
00:45:22,960 --> 00:45:33,920
en het antwoord zal zijn dit, en dan a = a ^ b is logische XOF-schakeling deze 2 en het antwoord is dit.

477
00:45:33,920 --> 00:45:41,090
Vragen? Oke. Dus de laatste is wat aanzienlijk moeilijker.

478
00:45:41,090 --> 00:45:43,180
[Student] Ik denk dat hij een vraag over het. >> Oh, sorry.

479
00:45:43,180 --> 00:45:49,380
[Student] Wat is eigenlijk sneller? Als u deze XOR is, of is het als declareer je een nieuwe variabele?

480
00:45:49,380 --> 00:45:55,190
Dus wat is eigenlijk sneller, waarbij een nieuwe variabele of met behulp van XOR om te ruilen?

481
00:45:55,190 --> 00:45:59,600
Het antwoord is, naar alle waarschijnlijkheid, een tijdelijke variabele.

482
00:45:59,600 --> 00:46:05,780
En dat komt omdat als het eenmaal is gecompileerd naar beneden - dus op de montage-niveau,

483
00:46:05,780 --> 00:46:12,320
er is niet zoiets als lokale variabelen of een tijdelijke variabelen of voor een van deze spullen.

484
00:46:12,320 --> 00:46:16,060
Ze zijn net als - er is geheugen, en er zijn registers.

485
00:46:16,060 --> 00:46:20,920
Registers zijn waar dingen worden actief gebeuren.

486
00:46:20,920 --> 00:46:24,750
Je hoeft niet toe te voegen 2 dingen in het geheugen, je toe te voegen 2 dingen in de registers.

487
00:46:24,750 --> 00:46:28,160
En breng je dingen uit het geheugen in de registers om vervolgens toe te voegen,

488
00:46:28,160 --> 00:46:33,180
en dan kun je ze terug in het geheugen, maar alle actie gebeurt in de registers.

489
00:46:33,180 --> 00:46:38,750
Dus als je de tijdelijke variabele benadering met behulp van, meestal wat er gebeurt is

490
00:46:38,750 --> 00:46:42,810
deze 2 nummers zijn al in registers.

491
00:46:42,810 --> 00:46:46,570
En dan vanaf dat moment, nadat je ze verwisseld,

492
00:46:46,570 --> 00:46:51,540
het zal gewoon beginnen met de andere register.

493
00:46:51,540 --> 00:46:56,510
Overal waar je was met b, zal het gewoon gebruik maken van het register, dat al was het opslaan van 'een.'

494
00:46:56,510 --> 00:47:02,180
Het maakt dus niet nodig om iets daadwerkelijk doen de swap te doen. Ja?

495
00:47:02,180 --> 00:47:05,690
[Student] Maar er is ook meer geheugen, toch?

496
00:47:05,690 --> 00:47:10,280
Het duurt maar meer geheugen als het nodig heeft om op te slaan die tijdelijke variabele.

497
00:47:10,280 --> 00:47:14,830
Net als je later weer kunt gebruiken die tijdelijke variabele ergens,

498
00:47:14,830 --> 00:47:18,920
dan - of u toewijst iets in die tijdelijke variabele.

499
00:47:18,920 --> 00:47:24,630
Dus als op enig moment in de tijd 'a,' b in temp hebben verschillende waarden of iets,

500
00:47:24,630 --> 00:47:30,680
dan dat het gaat om verschillende locaties hebben in het geheugen, maar het is waar dat

501
00:47:30,680 --> 00:47:34,800
er zijn veel lokale variabelen die alleen bestaan ​​in registers.

502
00:47:34,800 --> 00:47:44,370
In dat geval, is het nooit in het geheugen, en dus je bent nooit verspilt geheugen.

503
00:47:44,370 --> 00:47:58,620
Oke. Laatste vraag is een beetje meer.

504
00:47:58,620 --> 00:48:04,850
Hier, in deze CS50 apparaat is een woordenboek.

505
00:48:04,850 --> 00:48:12,390
En de reden hiervoor is omdat [? B66] is een spellingscontrole waar je het schrijven van

506
00:48:12,390 --> 00:48:15,780
met behulp van hash tabellen of pogingen of een datastructuur.

507
00:48:15,780 --> 00:48:22,660
Je gaat te schrijven van een spellingcontrole, en je gaat worden met behulp van dit woordenboek om dat te doen.

508
00:48:22,660 --> 00:48:28,280
Maar voor dit probleem, zijn we gewoon gaan kijken om te zien of een enkel woord in het woordenboek.

509
00:48:28,280 --> 00:48:31,250
In plaats van opslag van de gehele woordenboek een datastructuur

510
00:48:31,250 --> 00:48:35,180
en dan kijken over een volledig document om te zien of er iets is verkeerd gespeld,

511
00:48:35,180 --> 00:48:38,490
we willen gewoon een woord te vinden. Dus we kunnen gewoon te scannen via het hele woordenboek

512
00:48:38,490 --> 00:48:44,300
en als we nooit vinden het woord in het hele woordenboek, dan was het er niet in.

513
00:48:44,300 --> 00:48:52,150
Als we scannen over het gehele woordenboek en er het woord te zien, dan zijn we goed zijn, we vonden het.

514
00:48:52,150 --> 00:48:56,580
Er staat hier dat we willen gaan kijken naar C's file-handling-functie,

515
00:48:56,580 --> 00:48:59,930
want we willen het woordenboek lezen,

516
00:48:59,930 --> 00:49:07,680
maar ik zal de hint hier aan welke taken u moet bedenken.

517
00:49:07,680 --> 00:49:11,510
Ik schrijf ze op Spaces.

518
00:49:11,510 --> 00:49:20,490
Dus de belangrijkste die je zult willen kijken naar zijn f open en dan, onvermijdelijk, f gesloten,

519
00:49:20,490 --> 00:49:26,540
die zal gaan aan het eind van uw programma, en f scan f.

520
00:49:26,540 --> 00:49:31,060
U kunt ook gebruik maken van f lezen, maar je waarschijnlijk niet wilt

521
00:49:31,060 --> 00:49:34,200
want dat - je uiteindelijk niet nodig dat.

522
00:49:34,200 --> 00:49:41,880
F scan f is wat je gaat om te worden gebruikt om te scannen via het woordenboek.

523
00:49:41,880 --> 00:49:46,370
En zodat u niet hoeft te coderen de oplossing, gewoon proberen en als pseudo-code uw manier

524
00:49:46,370 --> 00:50:05,200
om een ​​oplossing, en dan zullen we bespreken.

525
00:50:05,200 --> 00:50:14,110
En eigenlijk, aangezien ik al gaf je deze, als je in een terminal of uw toestel shell,

526
00:50:14,110 --> 00:50:18,250
Ik zou - ik meestal - als je nog niet hebt gezien, ik weet niet als je dat deed in de klas,

527
00:50:18,250 --> 00:50:23,490
maar de mens, zodat de man pagina's, zijn vrij nuttig om naar te kijken vrijwel elke functie.

528
00:50:23,490 --> 00:50:27,330
Dus ik kan doen, zoals, man f-, scan-f.

529
00:50:27,330 --> 00:50:32,300
Dit is nu de informatie over de scan f familie van functies.

530
00:50:32,300 --> 00:50:37,070
Ik kon ook doen man f, open, en dat geeft me de details van dat.

531
00:50:37,070 --> 00:50:40,750
Dus als je weet wat functie die u gebruikt, of u leest code

532
00:50:40,750 --> 00:50:43,000
en je ziet een functie en je net als, 'Wat heeft dit te doen? "

533
00:50:43,000 --> 00:50:45,280
Rechtvaardig man die functie naam.

534
00:50:45,280 --> 00:50:47,340
Er zijn een paar rare voorbeelden waar je zou kunnen hebben om te zeggen

535
00:50:47,340 --> 00:50:51,620
wilt. man 2 die functie naam of man 3 die functie naam,

536
00:50:51,620 --> 00:50:58,230
maar u hoeft te doen dat als de mens de functie naam niet toevallig de eerste keer werken.

537
00:50:58,230 --> 00:51:03,010
[Student] Dus ik ben het lezen van de man pagina voor open, maar ik ben nog steeds verward over hoe het en het programma te gebruiken.

538
00:51:03,010 --> 00:51:06,170
Oke. Een groot deel van de man-pagina's zijn minder dan nuttig.

539
00:51:06,170 --> 00:51:08,470
Ze zijn meer handig als je al weet wat ze doen

540
00:51:08,470 --> 00:51:12,670
en dan hoeft u alleen maar de volgorde van de argumenten of iets te herinneren.

541
00:51:12,670 --> 00:51:17,640
Of ze kunnen geven u een algemeen overzicht, maar sommige van hen zijn zeer overweldigend.

542
00:51:17,640 --> 00:51:22,220
Net als f scan f, ook. Het geeft je de informatie voor al deze functies,

543
00:51:22,220 --> 00:51:28,120
en 1 regel hier beneden gebeurt zeggen, "F scan f leest van de string punt of stroom."

544
00:51:28,120 --> 00:51:32,360
Maar f te openen. Dus, hoe zouden we f open?

545
00:51:32,360 --> 00:51:38,470
Het idee van een programma dat moet doen file I / O, is dat

546
00:51:38,470 --> 00:51:45,070
moet u eerst het bestand dat u wilt om dingen te doen met te openen, en onvermijdelijk,

547
00:51:45,070 --> 00:51:51,220
lees dingen van dat bestand en dingen doen met hen.

548
00:51:51,220 --> 00:51:55,350
F geopend is wat we gebruiken om het bestand te openen.

549
00:51:55,350 --> 00:52:04,190
Het ding we terug, dus wat bestand willen we openen, het geeft ons de -

550
00:52:04,190 --> 00:52:11,970
hier het zegt "/ user / share / dict / words."

551
00:52:11,970 --> 00:52:16,740
Dit is het bestand dat we willen openen, en we willen om het te openen -

552
00:52:16,740 --> 00:52:21,440
moeten we expliciet aangeven of we willen openen om te lezen of als we willen openen om te schrijven.

553
00:52:21,440 --> 00:52:26,490
Er zijn een paar combinaties en zo, maar we willen dit openen om te lezen.

554
00:52:26,490 --> 00:52:29,380
We willen lezen uit het bestand.

555
00:52:29,380 --> 00:52:34,290
Dus wat doet deze terugkeer? Het geeft een bestand ster (*),

556
00:52:34,290 --> 00:52:37,260
en Ik zal gewoon alles laten zien in de variabele f, dus *,

557
00:52:37,260 --> 00:52:40,840
nogmaals, het is een pointer, maar we willen niet om te gaan met pointers.

558
00:52:40,840 --> 00:52:46,470
U kunt denken aan f als, f nu is de variabele die u gaat gebruiken om het bestand te vertegenwoordigen.

559
00:52:46,470 --> 00:52:49,850
Dus als je wilt lezen uit het bestand, je leest van f.

560
00:52:49,850 --> 00:52:54,820
Als u het bestand wilt sluiten, sluit u f.

561
00:52:54,820 --> 00:53:00,350
Dus aan het einde van het programma wanneer we onvermijdelijk het bestand wilt sluiten, wat moeten we doen?

562
00:53:00,350 --> 00:53:06,750
We willen f sluiten.

563
00:53:06,750 --> 00:53:12,600
Dus nu het laatste bestand functie die we gaan wilt gebruiken, is scannen f, f scan f.

564
00:53:12,600 --> 00:53:20,930
En wat dat doet is het scant over het bestand op zoek naar een patroon aan te passen.

565
00:53:20,930 --> 00:53:39,100
Kijkend naar de man pagina hier, we int f scan f te zien, negeer de return waarde voor nu.

566
00:53:39,100 --> 00:53:45,230
Het eerste argument is het bestand * stroom, zodat het eerste argument gaan we langs wilt komen is f.

567
00:53:45,230 --> 00:53:47,900
We scannen via f.

568
00:53:47,900 --> 00:53:53,680
Het tweede argument is een format string.

569
00:53:53,680 --> 00:53:58,310
Ik zal u een format string nu.

570
00:53:58,310 --> 00:54:05,180
Ik denk dat we toevallig om te zeggen, 127S \ n, veel van dat is onnodig.

571
00:54:05,180 --> 00:54:12,490
Het idee van wat dat format string is, is dat je kunt van scan f denken als het tegenovergestelde van print f.

572
00:54:12,490 --> 00:54:17,160
Dus printen f, printen f we ook gebruik maken van dit type parameter format,

573
00:54:17,160 --> 00:54:25,000
maar in print f wat we doen is - laten we eens kijken naar een equivalent.

574
00:54:25,000 --> 00:54:32,550
Zo af te drukken f, en er is eigenlijk ook f afdruk f, waarbij het eerste argument gaat worden f.

575
00:54:32,550 --> 00:54:40,980
Wanneer u afdrukt f, kunnen we iets zeggen als, "print 127S \ n" en dan als we doorgeven stukje tekst,

576
00:54:40,980 --> 00:54:44,050
het gaat om deze string en vervolgens een nieuwe lijn af te drukken.

577
00:54:44,050 --> 00:54:49,690
Wat 127 betekent, ik ben er vrij zeker van, maar ik heb nog nooit me beperkt tot het,

578
00:54:49,690 --> 00:54:52,470
Je zou het niet eens nodig om '127 'te zeggen in de print f,

579
00:54:52,470 --> 00:54:57,090
maar wat het betekent is printen we het eerste 127 tekens.

580
00:54:57,090 --> 00:54:59,350
Dus ik ben er vrij zeker van dat het geval is. U kunt Google voor.

581
00:54:59,350 --> 00:55:03,000
Maar in de volgende ben ik bijna zeker betekent dit dat.

582
00:55:03,000 --> 00:55:08,880
Dus dit is af te drukken de eerste 127 tekens, gevolgd door een nieuwe regel.

583
00:55:08,880 --> 00:55:14,680
F scan f nu, in plaats van te kijken naar een variabele en deze af te drukken,

584
00:55:14,680 --> 00:55:22,620
het gaat om te kijken naar een stukje tekst, en het patroon in de variabele op te slaan.

585
00:55:22,620 --> 00:55:26,360
Laten we eigenlijk scan f gebruiken in een ander voorbeeld.

586
00:55:26,360 --> 00:55:31,670
Dus laten we zeggen dat we hadden een paar int, x = 4,

587
00:55:31,670 --> 00:55:41,110
en we wilden een string gemaakt van te maken - wilde de tekenreeks te maken

588
00:55:41,110 --> 00:55:44,250
dat was als, dit zal komen veel later,

589
00:55:44,250 --> 00:55:49,020
iets dat is net als 4.jpg.

590
00:55:49,020 --> 00:55:51,870
Dus dit zou een programma waar je totaal teller te hebben,

591
00:55:51,870 --> 00:55:56,420
Samengevat tegen te gaan i, en u wilt een bos van beelden op te slaan.

592
00:55:56,420 --> 00:56:02,430
Dus je wilt i.jpg, waarbij i een aantal iteratie van je loop op te slaan.

593
00:56:02,430 --> 00:56:05,500
Dus hoe maken we deze string voor die JPEG?

594
00:56:05,500 --> 00:56:11,720
Als je wilde om af te drukken 4.jpg, kunnen we alleen maar zeggen afdruk f,% d.jpg,

595
00:56:11,720 --> 00:56:14,410
en dan zou het af te drukken voor die JPEG.

596
00:56:14,410 --> 00:56:20,050
Maar als we willen de string 4.jpg opslaan, gebruiken we scan f.

597
00:56:20,050 --> 00:56:30,860
Dus string s - in feite hebben we KAN NIET - karakter, char s, laten we gaan 100.

598
00:56:30,860 --> 00:56:35,400
Dus ik verklaarde enkele array van 100 tekens,

599
00:56:35,400 --> 00:56:39,830
en dat is wat we onvermijdelijk gaat worden het opslaan van die JPEG-inch

600
00:56:39,830 --> 00:56:47,920
Dus we gaan scannen f te gebruiken, en het formaat, hoe we zouden% d.jpg zeggen

601
00:56:47,920 --> 00:56:54,980
met het oog op 4.jpg af te drukken, wordt het formaat van dit gaat% d.jpg zijn.

602
00:56:54,980 --> 00:57:04,020
Dus het formaat% d.jpg, wat we willen% d vervangen door x is,

603
00:57:04,020 --> 00:57:06,590
en nu moeten we die string ergens op te slaan.

604
00:57:06,590 --> 00:57:12,500
En waar gaan we deze string op te slaan is in de array s.

605
00:57:12,500 --> 00:57:21,640
Dus na deze regel code, s, als we drukken f,% s van de variabele s,

606
00:57:21,640 --> 00:57:26,280
het gaat om 4.jpg af te drukken.

607
00:57:26,280 --> 00:57:38,930
Dus f scan f is hetzelfde als scan f, behalve nu is het uitzicht over dit bestand

608
00:57:38,930 --> 00:57:43,600
voor wat te slaan in s.

609
00:57:43,600 --> 00:57:46,160
Dat is wat de laatste argument gaat worden.

610
00:57:46,160 --> 00:57:54,170
We willen slaan - "Scan f familie van functies scans in zowel volgens de indeling zoals hieronder geprobeerd.

611
00:57:54,170 --> 00:58:02,450
Als er worden opgeslagen in de locatie punten die u zou kunnen terugkeren - "

612
00:58:02,450 --> 00:58:12,910
Nee, kunnen we goed zijn. Laat me denken voor een tweede.

613
00:58:12,910 --> 00:58:26,350
Dus scan f niet - wat de heck is de functie die dat doet?

614
00:58:26,350 --> 00:58:31,650
Dus scan f is niet van plan om een ​​geheel getal te nemen en dot jpg doen.

615
00:58:31,650 --> 00:58:43,490
Het gaat om [Mumbles].

616
00:58:43,490 --> 00:58:49,360
Sla int variabele in string int C.

617
00:58:49,360 --> 00:58:55,940
Wat is deze variabele, of wat is deze functie genoemd?

618
00:58:55,940 --> 00:59:04,950
Ja. Dat is - ja. Dus wat ik het definiëren van je eerder was s afdrukken f,

619
00:59:04,950 --> 00:59:09,820
die - dat er veel meer verstand, waarom ik zei dat het nog veel meer, zoals print f maakt.

620
00:59:09,820 --> 00:59:14,700
Scan f is nog steeds een soort afdruk f, maar print van f gaat om het te scannen via

621
00:59:14,700 --> 00:59:17,510
en vervang de variabelen en nu is het op te slaan in een string.

622
00:59:17,510 --> 00:59:19,620
Plaats van deze, slaat in een string.

623
00:59:19,620 --> 00:59:25,070
Dus negeren die volledig. U kunt nog steeds denken aan het formaat specifier als op dat van gedrukte f.

624
00:59:25,070 --> 00:59:34,510
Dus nu, als we wilden de 4.jpg ding te doen, zouden we dat doen is druk f, x van deze.

625
00:59:34,510 --> 00:59:38,520
Dus wat scan f doet - wat uw vraag gaat worden?

626
00:59:38,520 --> 00:59:40,820
[Student] Ik ben gewoon in de war over wat we proberen om hier te doen

627
00:59:40,820 --> 00:59:43,450
met die JPEG. Kunt u uitleggen dat nog 1 keer?

628
00:59:43,450 --> 00:59:52,710
Dus dit was - het is minder relevent tot en met f scan f nu, hopelijk, het zal weer aansluiten bij een of andere manier.

629
00:59:52,710 --> 01:00:02,240
Maar wat ik in eerste instantie van plan was om te laten zien was - dit is eigenlijk direct relevant is voor deze [?? F5]

630
01:00:02,240 --> 01:00:08,520
Je gaat worden met behulp van s afdrukken f, waar, zeggen dat we 100 foto's,

631
01:00:08,520 --> 01:00:13,630
en u wilt dat het beeld 1.jpg, 2.jpg, 3.jpg lezen.

632
01:00:13,630 --> 01:00:21,520
Dus om dat te doen, moet je f open, en dan moet je gaan in de tekenreeks die u wilt openen.

633
01:00:21,520 --> 01:00:30,020
Dus we zouden willen openen 1.jpg, om de tekenreeks die 1.jpg creëren,

634
01:00:30,020 --> 01:00:37,660
we doen print van f van% D.jpg--we niet doen voor int i = 0.

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

636
01:00:46,580 --> 01:00:51,130
Dus print van f% D.jpg van i.

637
01:00:51,130 --> 01:00:56,320
Dus na deze lijn, nu de variabele of de array s gaat 1.jpg.

638
01:00:56,320 --> 01:01:10,610
Of, 0.jpg, 1.jpg, 2.jpg. En dus kunnen we, opent op zijn beurt, elk beeld om te lezen.

639
01:01:10,610 --> 01:01:19,550
Dus dat is wat is af te drukken f doet. Zie je wat s af te drukken f is nu aan het doen?

640
01:01:19,550 --> 01:01:25,720
[Student] Oke, dus het neemt - het creëert een string, something.jpg, en dan slaat het.

641
01:01:25,720 --> 01:01:30,360
Ja. Het creëert - dit is een ander format string, net als scan f en printen f,

642
01:01:30,360 --> 01:01:37,530
waar het voegt alle variabelen in het tweede argument, misschien wel s in tegenstelling tot i.

643
01:01:37,530 --> 01:01:42,280
Misschien - ik bedoel, dat is het geval. Maar wat de volgorde van argumenten is.

644
01:01:42,280 --> 01:01:45,440
Het gaat om alle variabelen in te voegen in de format string

645
01:01:45,440 --> 01:01:52,250
en dan op te slaan in onze buffer, we noemen dat een buffer, het is waar we het opslaan van de string.

646
01:01:52,250 --> 01:02:00,750
Dus we zijn binnenkant van s opslaan van de juiste-geformatteerde string,% d te zijn vervangen door 4.

647
01:02:00,750 --> 01:02:08,080
[Student] Dus als we dit deden, is de variabele f gewoon te worden toegewezen?

648
01:02:08,080 --> 01:02:18,110
Ja. Dus we moeten sluit het origineel f voordat je dit doet.

649
01:02:18,110 --> 01:02:22,810
Maar - en dan ook, als er niet een f hier open te stellen, dan zouden we moeten zeggen -

650
01:02:22,810 --> 01:02:29,280
Ja. Maar het zou het openen van een honderd verschillende bestanden.

651
01:02:29,280 --> 01:02:37,360
[Student] Maar we zouden niet in staat zijn om toegang te krijgen of - oke.

652
01:02:37,360 --> 01:02:44,230
Oke. Dus scan f, f scan f, is een soort van hetzelfde idee,

653
01:02:44,230 --> 01:02:53,610
maar in plaats van, in plaats van te slaan in een string, het is meer als je nu bent

654
01:02:53,610 --> 01:03:02,420
gaan over een angel en pattern matching tegen die string en het opslaan van de resultaten in variabelen.

655
01:03:02,420 --> 01:03:11,290
U kunt gebruik maken van scan f te ontleden dan iets als 4.jpg, en het geheel getal 4 op te slaan in som int x.

656
01:03:11,290 --> 01:03:13,430
Dat is wat we kunnen scannen f gebruiken.

657
01:03:13,430 --> 01:03:16,300
F scan f gaat om dat te doen op de opdrachtregel.

658
01:03:16,300 --> 01:03:19,200
Ik ben eigenlijk vrij zeker dat dit is wat de CS50 bibliotheek doet.

659
01:03:19,200 --> 01:03:29,050
Dus als u zegt: "int te krijgen," het is scan f-ing over - scan f is de manier waarop je krijgt input van de gebruiker.

660
01:03:29,050 --> 01:03:34,670
F scan f gaat om hetzelfde te doen, maar met behulp van een bestand om te scannen via.

661
01:03:34,670 --> 01:03:41,090
Dus hier zijn we scannen via dit bestand.

662
01:03:41,090 --> 01:03:45,460
Het patroon waarin we proberen aan te passen is een stukje tekst dat is 127 tekens lang zijn

663
01:03:45,460 --> 01:03:48,100
gevolgd door een nieuwe lijn

664
01:03:48,100 --> 01:03:54,770
Dus ik ben er vrij zeker van dat we konden zelfs alleen maar zeggen: "match s," omdat in het woordenboek

665
01:03:54,770 --> 01:03:57,770
we toevallig hebben, zijn we gegarandeerd geen woord is dat lange,

666
01:03:57,770 --> 01:04:03,310
en ook f scan f, denk ik, zal stoppen bij de nieuwe lijn maakt niet uit wat.

667
01:04:03,310 --> 01:04:06,970
Maar we zullen ook de nieuwe lijn in de wedstrijd, en -

668
01:04:06,970 --> 01:04:13,960
[Student] Als we niet de nieuwe lijn zijn, zou het niet vinden delen van een woord?

669
01:04:13,960 --> 01:04:22,900
Het - per stuk - te kijken naar het woordenboek -

670
01:04:22,900 --> 01:04:26,200
Dus in het woordenboek, het zijn allemaal van onze woorden.

671
01:04:26,200 --> 01:04:30,500
Elke kamer is op een nieuwe regel.

672
01:04:30,500 --> 01:04:32,510
De scan f gaat halen dit woord.

673
01:04:32,510 --> 01:04:38,750
Als we geen rekening met de nieuwe lijn, dan is het mogelijk dat de volgende scan f gewoon lezen de nieuwe lijn.

674
01:04:38,750 --> 01:04:44,180
Maar ook nieuwe lijn zal dan gewoon negeren de nieuwe lijn.

675
01:04:44,180 --> 01:04:49,440
Maar we zullen nooit deel van een woord, want we zijn altijd het lezen tot een nieuwe lijn, wat er ook gebeurt.

676
01:04:49,440 --> 01:04:54,530
[Student] Maar wat als je zoekt naar het woord "Cissa," zoals Cissa.

677
01:04:54,530 --> 01:04:57,380
Zal het zijn dat, en zeggen dat het een wedstrijd?

678
01:04:57,380 --> 01:05:05,110
Dus hier zijn we - het zal lezen in - dit is eigenlijk een goed punt.

679
01:05:05,110 --> 01:05:10,660
We zijn nooit met de huidige - het woord dat we zoeken is de eerste opdrachtregelargument.

680
01:05:10,660 --> 01:05:16,460
Dus string, woord = argv 1.

681
01:05:16,460 --> 01:05:20,020
Dus de string die we zoeken is argv 1.

682
01:05:20,020 --> 01:05:23,290
We zijn niet op zoek naar een woord op alle in onze scan f.

683
01:05:23,290 --> 01:05:28,030
Wat we aan het doen waren met scan f wordt steeds elk woord in het woordenboek,

684
01:05:28,030 --> 01:05:34,320
en dan een keer hebben we dat woord gaan we strcmp gebruiken om ze te vergelijken.

685
01:05:34,320 --> 01:05:39,210
We gaan ons woord te vergelijken en wat we zojuist gelezen inch

686
01:05:39,210 --> 01:05:45,110
Dus onvermijdelijk, we gaan uiteindelijk doen een heleboel scan fs

687
01:05:45,110 --> 01:05:52,130
totdat het gewoon zo gebeurt het dat scan f zal terugkeren -

688
01:05:52,130 --> 01:05:54,800
deze resultaten is, zolang zij een nieuw woord gekoppeld,

689
01:05:54,800 --> 01:06:01,360
en het zal terug iets anders, zodra deze heeft nagelaten het woord te passen.

690
01:06:01,360 --> 01:06:08,440
We lezen over de gehele woordenboek, het opslaan van regel voor regel elk woord in de variabele s.

691
01:06:08,440 --> 01:06:17,240
Dan zijn we het vergelijken woord met s, en als de vergelijking == 0,

692
01:06:17,240 --> 01:06:21,650
strcmp gebeurt op 0 te brengen als er een match is gemaakt.

693
01:06:21,650 --> 01:06:31,510
Dus als het was 0, dan kunnen we afdrukken f, afgestemd,

694
01:06:31,510 --> 01:06:35,370
of woord is in het woordenboek, of wat je wilt tot en met f te drukken.

695
01:06:35,370 --> 01:06:41,450
En dan - we willen niet f sluiten over en weer.

696
01:06:41,450 --> 01:06:50,410
Dit is het soort van wat we willen doen, en we zijn niet alleen op zoek naar woord in het woordenboek.

697
01:06:50,410 --> 01:06:56,660
Dus we konden dat doen, als we wilden om te zoeken naar hun voorbeeld, Cissa, zoals je al eerder zei,

698
01:06:56,660 --> 01:07:00,260
als we wilden om te zoeken naar dat patroon, dan zou het niet in het geval

699
01:07:00,260 --> 01:07:08,010
want dat is niet echt een woord, maar een van de woorden in het woordenboek toevallig dat in het.

700
01:07:08,010 --> 01:07:13,560
Dus het zou overeenkomen met dit woord, maar dit deel van het woord is niet een woord zelf.

701
01:07:13,560 --> 01:07:17,250
Maar dat is niet hoe we met behulp van, we lezen in elk woord

702
01:07:17,250 --> 01:07:19,740
en vervolgens te vergelijken het woord dat we hebben met dat woord.

703
01:07:19,740 --> 01:07:25,780
Dus we zijn altijd op het vergelijken van volledige woorden.

704
01:07:25,780 --> 01:07:29,620
Ik kan het verzenden van de definitieve oplossingen later.

705
01:07:29,620 --> 01:07:32,050
Dit is een soort van bijna het juiste antwoord, denk ik.

706
01:07:32,050 --> 01:07:34,720
[Student reactie, onverstaanbaar]

707
01:07:34,720 --> 01:07:40,870
Oh, had ik te ontdoen van dat voor? Char s, ik denk dat we zeiden 127 - ik vergeten wat de grootste is.

708
01:07:40,870 --> 01:07:44,100
We zullen gewoon doen 128; dus nu is lang genoeg is.

709
01:07:44,100 --> 01:07:46,570
We hoeven niet om iets af te drukken.

710
01:07:46,570 --> 01:07:56,440
We gaan ook willen hebben om ons dossier te sluiten, en dat moet ongeveer het juiste antwoord.

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