1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] § Problem 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
Dette er CS50. CS50.TV

4
00:00:07,410 --> 00:00:15,770
Så, jeg Rob. Jeg er en senior i Kirkland. Dette er mitt tredje år TFing CS50.

5
00:00:15,770 --> 00:00:22,220
Det er første gang at vi er i endring fra den tradisjonelle forelesningen stil delen,

6
00:00:22,220 --> 00:00:25,610
der vi bare slags vurdere hva som skjedde i foredraget, og deretter dere stille spørsmål,

7
00:00:25,610 --> 00:00:32,250
nå å være mye mer problembasert, der vi bruker Spaces, og -

8
00:00:32,250 --> 00:00:37,410
Oh, så tanken er å gå til den linken jeg sendte deg, og da vil du være i verdensrommet min.

9
00:00:37,410 --> 00:00:42,410
Er det noen som ikke har en bærbar PC? Okay.

10
00:00:42,410 --> 00:00:47,050
Så vi kommer til å bruke dette, og vi kommer til å gjøre problemene lever i seksjon

11
00:00:47,050 --> 00:00:50,740
og diskutere dem og finne ut hva som er galt

12
00:00:50,740 --> 00:00:56,390
og jeg kan trekke opp noen av koden din, og jeg kan diskutere dine ideer.

13
00:00:56,390 --> 00:01:02,140
Så har noen hatt problemer?

14
00:01:02,140 --> 00:01:07,000
Du kan chatte på siden, jeg vet ikke om vi vil ha grunn til det.

15
00:01:07,000 --> 00:01:12,270
Nå, som den forrige supersection, hvis du var på den klassen, vet du hva det handler om.

16
00:01:12,270 --> 00:01:19,200
På alle P sett det kommer til å være disse delene.

17
00:01:19,200 --> 00:01:22,550
Så P-set 2, spesifikasjoner, jeg antar du så det på P-set en allerede.

18
00:01:22,550 --> 00:01:27,400
Men vi kan se på P-set 2 for hva vi kommer til å gå over i dag.

19
00:01:27,400 --> 00:01:29,460
Og du vil se en del av spørsmålene.

20
00:01:29,460 --> 00:01:37,530
Så dette blir i alle P-sett, det vil være en del av spørsmålene.

21
00:01:37,530 --> 00:01:41,340
Så langt har vi sa, "Tenk på dette en mulighet til å praktisere."

22
00:01:41,340 --> 00:01:44,940
Du vil ikke bli bedt om å sende inn dette programmet.

23
00:01:44,940 --> 00:01:48,480
Ideen er at disse er ment å slags hjelpe deg i gang med oppgaven.

24
00:01:48,480 --> 00:01:53,220
Jeg antar på Hacker utgaven, er mange av dem skal bare være nye, interessante ting å lære.

25
00:01:53,220 --> 00:01:58,590
De kan ikke være direkte anvendbart i oppgavesettet.

26
00:01:58,590 --> 00:02:01,810
Og akkurat nå er vi ikke har det du sender dem, men i teorien,

27
00:02:01,810 --> 00:02:07,480
for senere oppgavesett, kan du sende dem, og dermed kan du enten komme til seksjon

28
00:02:07,480 --> 00:02:10,380
eller se delen for å få svar, eller du kan bare få dem på din egen

29
00:02:10,380 --> 00:02:16,350
hvis du ikke føler for å nyte mitt nærvær.

30
00:02:16,350 --> 00:02:21,010
Så - jeg tror dette er den første.

31
00:02:21,010 --> 00:02:29,280
Oh. Også under disse delene av spørsmålene ber vi også at du har spørsmål om shorts.

32
00:02:29,280 --> 00:02:33,440
Så jeg antar, i teorien, du skal se disse før du kommer til delen,

33
00:02:33,440 --> 00:02:38,550
men det er fint hvis du ikke; vi vil gå over dem uansett.

34
00:02:38,550 --> 00:02:42,590
Så vi kan starte med disse: "Hvordan skiller en stund loop fra en do-mens loop?

35
00:02:42,590 --> 00:02:46,210
Når er siste spesielt nyttig? "

36
00:02:46,210 --> 00:02:49,390
Så noen har noen -?

37
00:02:49,390 --> 00:02:52,730
[Student] gjør-mens loop vil alltid utføre minst én gang.

38
00:02:52,730 --> 00:03:02,950
Ja. Så det er forskjellen. En stund loop - Jeg skal bare gjøre det på her - mens loop, vi har tilstanden

39
00:03:02,950 --> 00:03:19,760
akkurat her, mens en do-stund, trenger du ikke har en tilstand før vi får her nede.

40
00:03:19,760 --> 00:03:24,130
Og så, når programmet er å utføre, og det blir til mens loop,

41
00:03:24,130 --> 00:03:26,380
det sjekker umiddelbart hvis denne tilstanden er sant.

42
00:03:26,380 --> 00:03:30,710
Hvis denne betingelsen ikke er sann, vil det bare hoppe over løkken helt.

43
00:03:30,710 --> 00:03:34,390
Do-mens loop, som programmet utfører, blir det til "gjøre."

44
00:03:34,390 --> 00:03:37,920
Ingenting skjer på dette punktet, fortsetter bare å kjøre.

45
00:03:37,920 --> 00:03:42,690
Så når den treffer "mens", hvis betingelsen er sann, vil det loop tilbake og gjøre det igjen

46
00:03:42,690 --> 00:03:46,730
og igjen og igjen før tilstanden er ikke sant, og så bare faller gjennom.

47
00:03:46,730 --> 00:03:50,600
Så forskjellen er at dette kan hoppe rett fra start.

48
00:03:50,600 --> 00:03:56,770
Dette utfører nødvendigvis gang og deretter kan utføre flere ganger hvis tilstanden er fortsatt sant.

49
00:03:56,770 --> 00:04:03,720
Så mens loop vil bare gjøre det en gang, eller - mens loop - vi trenger kanskje ikke å gjøre det i det hele tatt,

50
00:04:03,720 --> 00:04:07,900
siden så snart vi får den, hvis betingelsen er usann, vil vi bare hoppe rett over den.

51
00:04:07,900 --> 00:04:11,770
Mens do-mens loop, vil vi utføre det en gang, nødvendigvis.

52
00:04:11,770 --> 00:04:14,560
Deretter, når vi kommer til tilstanden, sjekker vi om det er sant eller usant.

53
00:04:14,560 --> 00:04:19,790
Hvis det er sant, vil vi gjøre det igjen, hvis det er falsk, vil vi bare fortsette å gå.

54
00:04:19,790 --> 00:04:24,680
Så da er det sistnevnte spesielt nyttig?

55
00:04:24,680 --> 00:04:31,190
Så jeg kan si at i sin helhet av de 4 år, 3 år, uansett,

56
00:04:31,190 --> 00:04:38,780
at jeg har vært programmering, har jeg brukt dette, som, under 10 ganger.

57
00:04:38,780 --> 00:04:43,140
Og sannsynligvis 5 av dem er i CS50 når vi introduserer do-mens sløyfer.

58
00:04:43,140 --> 00:04:47,510
Så når har du brukt do-mens sløyfer?

59
00:04:47,510 --> 00:04:49,510
Når er - ja?

60
00:04:49,510 --> 00:04:53,180
[Student] Når du prøver å få brukerens input, eller noe du ønsker å sjekke -

61
00:04:53,180 --> 00:04:59,700
Ja. Så gjør-mens sløyfer, brukerundersøkelser er den store.

62
00:04:59,700 --> 00:05:03,160
Det er derfor på de første par oppgavesett, når du ønsker å spørre brukeren, som,

63
00:05:03,160 --> 00:05:08,520
"Gi meg en streng," du kan ikke fortsette før du får den strengen.

64
00:05:08,520 --> 00:05:12,980
Og så du, nødvendigvis må be om strengen minst én gang.

65
00:05:12,980 --> 00:05:16,950
Men så hvis de svarer noe dårlig, så må du sløyfe tilbake og spør igjen.

66
00:05:16,950 --> 00:05:20,810
Men annet enn brukerens input, er det svært sjelden at jeg møter en sak

67
00:05:20,810 --> 00:05:27,170
der jeg ønsker å sløyfe "minst en gang", men muligens flere.

68
00:05:27,170 --> 00:05:33,370
Spørsmål eller -? Har noen brukt en do-mens loop noe annet sted?

69
00:05:33,370 --> 00:05:36,780
Okay. Så den neste er, "Hva betyr svart identifikator

70
00:05:36,780 --> 00:05:43,310
vanligvis indikerer om outputted av clang? "

71
00:05:43,310 --> 00:05:47,380
Så hva slags kode jeg kunne skrive for å få 'svart identifikator?

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

73
00:05:49,550 --> 00:05:52,650
Så vi kan bare prøve det her, x = 2.

74
00:05:52,650 --> 00:06:04,830
Vi vil kjøre dette - oh, jeg klikker på den. Så her får vi - alle rett.

75
00:06:04,830 --> 00:06:07,100
"Bruk av svart identifikator x."

76
00:06:07,100 --> 00:06:11,610
Så det er svart identifikator, en variabel.

77
00:06:11,610 --> 00:06:13,910
Det vil ofte kaller en variabel en identifikator.

78
00:06:13,910 --> 00:06:17,300
Så det kanskje ikke vet det er faktisk en variabel, det vet ikke hva det er.

79
00:06:17,300 --> 00:06:19,380
Så det er en identifikator.

80
00:06:19,380 --> 00:06:26,060
Så hvorfor er det svart? Ja.

81
00:06:26,060 --> 00:06:32,190
Så for å være tydelig på terminologi, erklæring av en variabel

82
00:06:32,190 --> 00:06:37,360
er når du sier "int x" eller "streng y", uansett.

83
00:06:37,360 --> 00:06:41,910
Initialisering av variabelen eller tildeling av variabelen,

84
00:06:41,910 --> 00:06:44,510
er når du sier "x = 2".

85
00:06:44,510 --> 00:06:52,950
Så vi kan gjøre disse i separate trinn, int x, x = 2, og inntil - vi kan ha en haug med ting her -

86
00:06:52,950 --> 00:07:00,350
men inntil denne linjen skjer, er x fortsatt initialisert, men det har blitt erklært.

87
00:07:00,350 --> 00:07:06,760
Og så kan vi selvsagt gjøre det i en linje, og nå er vi erklære og initialiseres.

88
00:07:06,760 --> 00:07:10,730
Spørsmål?

89
00:07:10,730 --> 00:07:18,390
Og til slutt: «Hvorfor er Caesar Cipher ikke veldig sikker?"

90
00:07:18,390 --> 00:07:23,830
Så først, ønsker alle å si hva Caesar Cipher er?

91
00:07:23,830 --> 00:07:28,100
[Student] Caesar Cipher bare er at du kartlegge, skifter du hver bokstav,

92
00:07:28,100 --> 00:07:34,420
et visst antall bokstaver går over, og flytte tilbake over, og det er ikke veldig sikker fordi

93
00:07:34,420 --> 00:07:42,260
det er bare 26 mulige alternativer, og du trenger bare å prøve hver 1 av dem til du får den.

94
00:07:42,260 --> 00:07:45,470
Oh. Så skal jeg gjenta?

95
00:07:45,470 --> 00:07:51,600
Caesar Cipher, det er - jeg mener, vil du bli håndtere det på de problemene som du -

96
00:07:51,600 --> 00:07:56,110
eller jeg antar standardutgaven av problemet sett som ikke er på hacker utgaven.

97
00:07:56,110 --> 00:08:01,550
Så på standardutgaven til oppgavesettet, får du en melding som "Hei, verden,"

98
00:08:01,550 --> 00:08:08,410
og du har også et tall som 6, og ta deg denne meldingen, og hver enkelt karakter,

99
00:08:08,410 --> 00:08:11,310
du rotere det ved 6 stillinger i alfabetet.

100
00:08:11,310 --> 00:08:16,560
Så 'h' i Hallo ville bli h-I-J-K-L-m-n.

101
00:08:16,560 --> 00:08:19,600
Så det første brevet ville være n. Vi gjør det samme med e.

102
00:08:19,600 --> 00:08:23,530
Hvis vi har en, liker, z eller noe, så vi vikle tilbake rundt til 'en.

103
00:08:23,530 --> 00:08:29,280
Men hver karakter får syklet 6 tegn senere i alfabetet, og det er ikke veldig sikker

104
00:08:29,280 --> 00:08:35,440
siden det er bare 26 muligheter for hvor mange måter du kan pakke en enkelt bokstav.

105
00:08:35,440 --> 00:08:42,919
Så du kan bare prøve alle 26 av dem og, antagelig, for en lang nok melding,

106
00:08:42,919 --> 00:08:46,860
bare 1 av de mulige 26 ting kommer til å være leselig,

107
00:08:46,860 --> 00:08:50,300
og leselig man skal være den opprinnelige meldingen.

108
00:08:50,300 --> 00:08:56,240
Så det er ikke en veldig god måte å kryptere noe som helst.

109
00:08:56,240 --> 00:08:59,070
Relatert til disse shorts, "Hva er en funksjon?"

110
00:08:59,070 --> 00:09:03,370
Så hva er en funksjon? Ja.

111
00:09:03,370 --> 00:09:11,640
[Student] Det er som et eget stykke kode som du kan ringe for å gå gjennom og deretter få tilbake verdien av hva.

112
00:09:11,640 --> 00:09:18,160
Ja. Så jeg skal svare på det ved å også svare på neste - eller gjenta ved også bare svare på neste.

113
00:09:18,160 --> 00:09:22,410
Du kan bruke funksjoner i stedet for bare å kopiere og lime inn koden igjen og igjen.

114
00:09:22,410 --> 00:09:27,200
Bare ta den koden, legg den i en fuction, og deretter kan du bare kalle funksjonen

115
00:09:27,200 --> 00:09:29,870
hvor du har vært kopiere og lime inn.

116
00:09:29,870 --> 00:09:33,350
Så funksjoner er nyttige.

117
00:09:33,350 --> 00:09:35,860
Så nå skal vi gjøre faktiske problemer.

118
00:09:35,860 --> 00:09:46,490
Den første. Så ideen om den første er, passerer du en streng, og uavhengig av -

119
00:09:46,490 --> 00:09:52,060
eller står det med små bokstaver? Det sier ikke alle små bokstaver.

120
00:09:52,060 --> 00:09:57,730
Så meldingen kan være noe, og - oh no. Det gjør.

121
00:09:57,730 --> 00:10:01,610
"For enkelhets skyld kan du anta at brukeren bare innspill små bokstaver og mellomrom."

122
00:10:01,610 --> 00:10:08,180
Så vi passerer det en melding med bare små bokstaver og vi veksle

123
00:10:08,180 --> 00:10:15,450
mellom små og store - vi endre strengen til å være store og små, vekslende.

124
00:10:15,450 --> 00:10:22,920
Så før vi gir deg et sekund å selv dykke ned i problemet,

125
00:10:22,920 --> 00:10:32,420
hva er det første som vi trenger å gjøre?

126
00:10:32,420 --> 00:10:36,900
Oh, hva jeg bare klikke på? Åh, jeg bare klikket på en e-post her.

127
00:10:36,900 --> 00:10:42,870
Så det første vi må gjøre - jeg ser på feil en?

128
00:10:42,870 --> 00:10:49,320
Er denne delen av denne?

129
00:10:49,320 --> 00:10:51,320
Nei, de er fortsatt der, skjønt.

130
00:10:51,320 --> 00:10:55,160
Ok, her fortsatt.

131
00:10:55,160 --> 00:11:03,160
Nå kan vi ikke anta -? Ja. Her kan vi ikke anta at det er bare små og mellomrom.

132
00:11:03,160 --> 00:11:07,770
Så nå må vi håndtere det faktum at bokstavene kan være hva vi vil at de skal være.

133
00:11:07,770 --> 00:11:11,910
Og så det første vi vil gjøre er å få den meldingen.

134
00:11:11,910 --> 00:11:19,790
Vi trenger bare å få en streng, streng s = GetString, ok.

135
00:11:19,790 --> 00:11:24,890
Nå dette problemet, er det et par måter å gjøre det på.

136
00:11:24,890 --> 00:11:29,840
Men vi kommer til å ønske å bruke bitvis operatører her.

137
00:11:29,840 --> 00:11:35,280
Er det folk som enten ikke var på supersection,

138
00:11:35,280 --> 00:11:37,480
eller noe, og ikke vet hva bitvis operatører er?

139
00:11:37,480 --> 00:11:41,710
Eller hvordan de forholder seg til ASCII på noen måte?

140
00:11:41,710 --> 00:11:45,650
[Student] Jeg var ikke på supersection, men jeg vet hva bitvis operatører er.

141
00:11:45,650 --> 00:11:49,560
Okay. Så da jeg ikke trenger å gå over det grunnleggende av dem, men jeg skal forklare

142
00:11:49,560 --> 00:11:51,830
hva vi kommer til å ønske å bruke her.

143
00:11:51,830 --> 00:11:59,680
Så 'A': Binær representasjon av kapital A, er nummer 65.

144
00:11:59,680 --> 00:12:07,560
Jeg skal bare se på - 41 kommer til å bli 01000001.

145
00:12:07,560 --> 00:12:14,170
Så det bør være 65 i desimal, så dette er den binære representasjon av tegnet kapital A.

146
00:12:14,170 --> 00:12:19,440
Nå den binære representasjonen av tegnet små bokstaver 'a'

147
00:12:19,440 --> 00:12:33,350
kommer til å være det samme, nesten. Er det - 6, ja. Dette er rett.

148
00:12:33,350 --> 00:12:37,670
Så binær kapital A, binær små 'a ".

149
00:12:37,670 --> 00:12:43,940
Så merker at forskjellen mellom A og 'a' er dette eneste bit.

150
00:12:43,940 --> 00:12:49,440
Og dette skjer for å være 32 bit, bit representerer nummer 32.

151
00:12:49,440 --> 00:12:53,910
Og det er fornuftig ettersom A er 65, 'a' er 97.

152
00:12:53,910 --> 00:12:56,610
Forskjellen mellom dem er 32.

153
00:12:56,610 --> 00:13:03,770
Så nå vet vi at vi kan konvertere fra A til 'a' ved å ta en

154
00:13:03,770 --> 00:13:09,710
og bitvis øringen det, med - som ser ut som en 1.

155
00:13:09,710 --> 00:13:20,900
Dette er en bitvis OR, med 00100000, og som vil gi oss 'a ".

156
00:13:20,900 --> 00:13:26,850
Og vi kan få fra 'a' til A ved bitvis Anding

157
00:13:26,850 --> 00:13:33,700
med 11, 0 i dette stedet, 11111.

158
00:13:33,700 --> 00:13:43,840
Så dette vil da gi oss nøyaktig hva 'a' var, men utjevne denne personen bit,

159
00:13:43,840 --> 00:13:50,070
så vi har 01000001, jeg vet ikke om jeg regnet rett.

160
00:13:50,070 --> 00:13:56,750
Men denne teknikken bitvis øringen å komme fra hovedstaden til små bokstaver,

161
00:13:56,750 --> 00:14:02,080
og bitvis Anding å komme fra små til kapital er ikke eksklusivt for A.

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

163
00:14:06,510 --> 00:14:10,080
alle av dem er bare kommer til å variere fra dette enkelt bit.

164
00:14:10,080 --> 00:14:16,290
Og så kan du bruke denne til å skifte fra enhver liten bokstav til noen stor bokstav og vice versa.

165
00:14:16,290 --> 00:14:26,670
Okay. Så en enkel måte å komme fra dette - så i stedet for å måtte

166
00:14:26,670 --> 00:14:32,170
skrive ut hva 1011111 er - en enkel måte å representere dette nummeret, og dette er ikke en

167
00:14:32,170 --> 00:14:39,710
at jeg gikk over i supersection, men tilde (~) er et annet bitvis operatør.

168
00:14:39,710 --> 00:14:42,520
Hva ~ gjør er det ser på litt representasjon.

169
00:14:42,520 --> 00:14:45,630
La oss ta noen tall.

170
00:14:45,630 --> 00:14:53,130
Dette er bare noen binært tall, og hva ~ gjør det bare snur alle biter.

171
00:14:53,130 --> 00:15:00,630
Så dette var en 1, nå en 0, er dette en 0, nå en 1, 010 100.

172
00:15:00,630 --> 00:15:08,320
Så det er all ~ gjør. Så 32 kommer til å være nummer - bli kvitt det -

173
00:15:08,320 --> 00:15:23,320
så 32 kommer til å være nummer 00100000, og så ~ av dette kommer til å bli

174
00:15:23,320 --> 00:15:29,980
dette nummeret opp her at jeg ANDed 'a' med.

175
00:15:29,980 --> 00:15:35,600
Ser alle det? Dette er ganske vanlig, som når du ønsker å finne ut

176
00:15:35,600 --> 00:15:40,740
for senere ting som vi kan bli seende, når vi ønsker å se om -

177
00:15:40,740 --> 00:15:44,710
eller vi vil ha alt, hver eneste bit sett med unntak av 1

178
00:15:44,710 --> 00:15:47,910
du har en tendens til å gjøre ~ av den biten som vi ikke ønsker innstilt.

179
00:15:47,910 --> 00:15:53,090
Slik at vi ikke vil at 32 bit sett, så vi ~ av 32 år.

180
00:15:53,090 --> 00:15:57,790
Okay. Så vi kan bruke alle de her.

181
00:15:57,790 --> 00:16:03,000
Greit, så det er fint hvis du ikke er ferdig, skal vi sakte gå over sammen,

182
00:16:03,000 --> 00:16:11,870
eller gå over dette, så - gjennom dette. Gå gjennom denne.

183
00:16:11,870 --> 00:16:20,790
Så vi har vår streng, og vi ønsker å sløyfe over hvert tegn i strengen og gjøre noe til det.

184
00:16:20,790 --> 00:16:26,710
Så hvordan gjør vi sløyfe over en streng? Hva skal vi bruke?

185
00:16:26,710 --> 00:16:30,980
Jeg har ikke tenkt å gjøre det på her. Ja.

186
00:16:30,980 --> 00:16:42,940
Så jeg har min iterator, og han sa det, men hvordan vet jeg hvor mange tegn i strengen?

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

188
00:16:47,030 --> 00:16:49,860
Så det jeg har gjort her er ikke den beste måten å gjøre ting på.

189
00:16:49,860 --> 00:16:51,860
Vet noen hvorfor?

190
00:16:51,860 --> 00:16:55,290
Fordi du sjekker språket strengen hver eneste gang.

191
00:16:55,290 --> 00:17:06,859
Så vi kommer til å ønske å flytte strlen, kunne jeg si opp her, int lengde = strlen (s),

192
00:17:06,859 --> 00:17:11,900
og deretter må jeg <lengde, og i tilfelle du ikke har sett det før,

193
00:17:11,900 --> 00:17:20,410
Jeg kan også gjøre int i = 0, lengde = strlen (s).

194
00:17:20,410 --> 00:17:25,010
Og så dette er noe å foretrekke, siden nå har jeg begrenset omfang

195
00:17:25,010 --> 00:17:29,150
av variabel lengde til nettopp dette "for" loop, i stedet for å erklære det før

196
00:17:29,150 --> 00:17:34,990
og at det alltid finnes, og i tilfelle du ikke ta hvorfor det er dårlig,

197
00:17:34,990 --> 00:17:39,410
eller hvorfor den opprinnelige var dårlig, det er - starte på for loop.

198
00:17:39,410 --> 00:17:43,380
Jeg sjekket tilstanden. Er jeg <lengden på s?

199
00:17:43,380 --> 00:17:46,790
Så lengden på s, la oss jobbe med "hallo" hele tiden.

200
00:17:46,790 --> 00:17:49,670
Slik at lengden av s, h-e-l-l-o. Lengde er 5.

201
00:17:49,670 --> 00:17:57,580
Så i = 0, lengde er 5, så jeg ikke <5, så sløyfen fortsetter.

202
00:17:57,580 --> 00:18:02,750
Så går vi igjen. Vi sjekker tilstanden. Er jeg <lengden på hallo?

203
00:18:02,750 --> 00:18:08,390
Så la oss sjekke lengden på hello. H-e-l-l-o. Det er 5; jeg er ikke <5, så vi fortsetter igjen.

204
00:18:08,390 --> 00:18:13,330
Så vi beregner vi regner hallo, for hver iterasjon av loopen,

205
00:18:13,330 --> 00:18:17,380
selv trodde det aldri kommer til å endre, det er alltid kommer til å være 5.

206
00:18:17,380 --> 00:18:22,530
Så vi bare husker 5 foran, og nå er alt er bedre.

207
00:18:22,530 --> 00:18:24,990
Så iterating over hele strengen.

208
00:18:24,990 --> 00:18:31,470
Hva ønsker vi å gjøre for hvert tegn i strengen?

209
00:18:31,470 --> 00:18:38,510
[Student sett uforståelig]

210
00:18:38,510 --> 00:18:47,000
Ja. Så hvis karakteren er ikke-alfabetisk, så vi vil bare hoppe over det.

211
00:18:47,000 --> 00:18:52,300
Fordi vi bare bryr seg om alfabetiske bokstaver, vi ikke kan kapitalisere et nummer.

212
00:18:52,300 --> 00:19:10,850
Så hvordan kan vi gjøre dette? Så tilstanden vår, så hvis vi vil ha noe - sjekk om det er alfabetisk.

213
00:19:10,850 --> 00:19:14,060
Så hvordan sjekker vi dette?

214
00:19:14,060 --> 00:19:18,720
[Student] Du kan bare bruke funksjonen er alfa.

215
00:19:18,720 --> 00:19:23,160
Er det inkludert i en av disse, eller noen har lignende, char.h eller noe?

216
00:19:23,160 --> 00:19:32,710
La oss ikke bruke er alfa-funksjonen, og bruke den eksplisitte - så vi har s [i],

217
00:19:32,710 --> 00:19:40,460
som er den åttende karakter s, husk at en streng er en rekke tegn,

218
00:19:40,460 --> 00:19:43,180
så det åttende tegnet av s.

219
00:19:43,180 --> 00:19:49,280
Nå, hvis det er en stor bokstav, vet vi at det må være i et bestemt område.

220
00:19:49,280 --> 00:19:54,370
Og hva er det området?

221
00:19:54,370 --> 00:20:07,860
Ja. Så hvis s [i] er ≥ 65, og s [i] er ≤ 90, hva bør jeg gjøre i stedet?

222
00:20:07,860 --> 00:20:18,470
Ja. Så du bør absolutt aldri engang trenger å vite ASCII verdier av noe noen gang.

223
00:20:18,470 --> 00:20:25,640
Aldri tenke på tallene 65, 90, 97 og 102, eller hva det er.

224
00:20:25,640 --> 00:20:32,470
Du trenger ikke - 112 - du trenger ikke å vite de i det hele tatt. Det er også galt.

225
00:20:32,470 --> 00:20:41,940
Bare bruke én sitatteikn, single sitat konstanter. Så 'A' og mindre enn 90 er 'Z.'

226
00:20:41,940 --> 00:20:47,930
Og dette er betydelig bedre - jeg ville ikke vite av toppen av hodet mitt at Z er 90.

227
00:20:47,930 --> 00:20:52,690
Jeg vet av toppen av hodet mitt at "Z" er hovedstaden Z.

228
00:20:52,690 --> 00:21:02,100
Så så lenge dette er i størrelsesorden av kapital A til hovedstaden Z, eller vi kan se etter små bokstaver,

229
00:21:02,100 --> 00:21:17,010
Eller hvis det er i området ≥ 'a' og ≤ z.

230
00:21:17,010 --> 00:21:19,010
Så det er vår tilstand.

231
00:21:19,010 --> 00:21:22,520
Stilen for hvor du skal plassere disse tingene varierer.

232
00:21:22,520 --> 00:21:29,520
Jeg skal gjøre det slik.

233
00:21:29,520 --> 00:21:31,520
Nå, hva vi ønsker å gjøre?

234
00:21:31,520 --> 00:21:39,530
Vi vet at dette brevet er et tegn, en alfabetisk tegn.

235
00:21:39,530 --> 00:21:46,270
Så vi trenger å veksle mellom om dette skal nå være en stor bokstav eller en liten bokstav.

236
00:21:46,270 --> 00:21:48,820
Hvordan skal vi holde styr på hvilken som vi vil det skal være?

237
00:21:48,820 --> 00:21:55,520
[Student stemmer, uforståelige]

238
00:21:55,520 --> 00:21:59,150
Så ja, men la meg sjekke.

239
00:21:59,150 --> 00:22:04,910
Modul 0-2 ble sagt, var et forslag kastet ut, og jeg er enig med det.

240
00:22:04,910 --> 00:22:11,780
Bortsett merke til at, som - er dette tilfelle? Ja.

241
00:22:11,780 --> 00:22:18,270
Det er alle andre, men vi kan ikke modul 2 av i, eller jeg mod 2, siden

242
00:22:18,270 --> 00:22:22,950
merke til at E er kapital og 'a' er små? Men det er en plass skiller dem?

243
00:22:22,950 --> 00:22:27,150
Så de kommer til å være den samme mod 2, men de er forskjellige tilfeller.

244
00:22:27,150 --> 00:22:29,150
[Student spørsmål, uforståelig]

245
00:22:29,150 --> 00:22:34,690
Ja. Så vi bare kommer til å holde en greve.

246
00:22:34,690 --> 00:22:38,730
Vi kan også gjøre det her hvis vi ønsket, det kan bli litt uhåndterlig

247
00:22:38,730 --> 00:22:41,300
i for loop erklæringer; vil jeg sette det opp her.

248
00:22:41,300 --> 00:22:48,840
Så int count = starter på 0.

249
00:22:48,840 --> 00:22:54,070
Og så nå, jeg kommer til å telle hvor mange alfabetiske tegn vi har hatt.

250
00:22:54,070 --> 00:22:59,550
Så vi uunngåelig kommer til å telle + + siden vi fant en annen alfabetisk tegn.

251
00:22:59,550 --> 00:23:09,130
Men, så nå du sier om teller mod 2.

252
00:23:09,130 --> 00:23:12,590
Så hva om telle mod 2? Oh. Jeg skal gjøre == 0 for nå.

253
00:23:12,590 --> 00:23:21,740
Vi vil også gå over det. Så hvis teller mod 2 == 0, hva så?

254
00:23:21,740 --> 00:23:27,830
[Studenter svaret, uforståelige]

255
00:23:27,830 --> 00:23:32,750
Så vi vil at det skal ende opp med store bokstaver.

256
00:23:32,750 --> 00:23:37,520
Det er 2 saker, store og små bokstaver er de to sakene.

257
00:23:37,520 --> 00:23:40,990
Så hvis vi er i små bokstaver vi trenger å gjøre det store bokstaver.

258
00:23:40,990 --> 00:23:43,710
Hvis det er store vi ikke trenger å gjøre noe.

259
00:23:43,710 --> 00:23:50,760
Men, er det en måte - shouldn't har snudd -

260
00:23:50,760 --> 00:23:54,800
at vi ikke engang trenger å sjekke om det er store eller små bokstaver?

261
00:23:54,800 --> 00:24:02,240
Hva kan vi gjøre for å alltid sørge for at vi alltid ender opp på store?

262
00:24:02,240 --> 00:24:07,830
Så legger merke til hva vi gjorde for små 'a', hva om vi gjorde dette samme ting til store bokstaver A?

263
00:24:07,830 --> 00:24:11,900
Har store bokstaver En endring eller gjør verdiendring?

264
00:24:11,900 --> 00:24:23,100
Ja. Så noen stor bokstav bitvis ANDed med ~ 32 kommer til å være den samme stor bokstav

265
00:24:23,100 --> 00:24:29,220
fordi for noen stor bokstav den 32. bit ikke er satt.

266
00:24:29,220 --> 00:24:40,920
Så hvis vi ønsker å bringe tegnet s [i], vi vil ha det til å bli små eller store bokstaver.

267
00:24:40,920 --> 00:24:46,890
Så hvis det var små, er det nå store, hvis det var store, er det fortsatt store bokstaver, og det er det.

268
00:24:46,890 --> 00:24:54,290
Jeg sa dette i supersection: Du kan bruke 32 hvis du vil, men jeg har en tendens til å foretrekke å gjøre "et" - A,

269
00:24:54,290 --> 00:25:01,150
istedenfor bare ren 32, fordi det kan være en hvilken som helst andre bit.

270
00:25:01,150 --> 00:25:03,610
Etter 32 bit, kan det være noen av disse, eller vi ville ikke ha nok

271
00:25:03,610 --> 00:25:05,840
tall til å representere alle tegnene.

272
00:25:05,840 --> 00:25:09,110
Så hvis du får 32 bit, kan det være 64 bit, kan det være på 128 bit.

273
00:25:09,110 --> 00:25:13,990
Noen av disse bitene kan være litt som skiller mellom store og små bokstaver.

274
00:25:13,990 --> 00:25:18,350
Jeg bør ikke trenger å vite at det er 32 bit.

275
00:25:18,350 --> 00:25:27,130
Jeg kan bruke denne 'a' - A for å få litt som skiller mellom de to

276
00:25:27,130 --> 00:25:33,000
uten å måtte stole på det magiske tallet som er 32.

277
00:25:33,000 --> 00:25:38,770
Og så nå, ellers teller var merkelig, og så hva ønsker jeg å gjøre?

278
00:25:38,770 --> 00:25:43,920
[Student svar, uforståelig]

279
00:25:43,920 --> 00:25:45,920
[Student] Hva er det?

280
00:25:45,920 --> 00:25:49,850
Jeg vil gjøre det i 1 sekund.

281
00:25:49,850 --> 00:25:55,690
Så nå hvis jeg vil - Jeg vil være sikker på at karakteren er nå små,

282
00:25:55,690 --> 00:26:04,140
og så jeg kan eller ved 32, og 32 betyr 'a' - A.

283
00:26:04,140 --> 00:26:06,510
Men legg merke til, av samme resonnement som den forrige, at hvis

284
00:26:06,510 --> 00:26:11,670
brevet var allerede små bokstaver, så øringen med 32 bare holder det små bokstaver.

285
00:26:11,670 --> 00:26:16,220
Det har ikke endret det opprinnelige karakter.

286
00:26:16,220 --> 00:26:19,910
Men nå har jeg ikke trenger å unngå å si: "Hvis det er små, bare glem det,

287
00:26:19,910 --> 00:26:23,650
hvis det er store bokstaver, og deretter endre det. "

288
00:26:23,650 --> 00:26:26,900
Det er mye mer praktisk å gjøre dette.

289
00:26:26,900 --> 00:26:33,190
[Student] Vil at strategien å trekke store fra små arbeid hvis det ikke var 32?

290
00:26:33,190 --> 00:26:35,330
Hvis det var, liker, 34 eller noe?

291
00:26:35,330 --> 00:26:41,840
Så må du vite at forskjellen mellom de 2 er -? >> 1 bit.

292
00:26:41,840 --> 00:26:49,840
Det kan være mer enn 1 bit, så lenge alle biter nedenfor denne posisjonen er de samme.

293
00:26:49,840 --> 00:26:58,500
Så vi trenger minst 26 tegn - eller er det 26 tegn.

294
00:26:58,500 --> 00:27:04,590
Så vi trenger minst 26 tall å representere forskjellen -

295
00:27:04,590 --> 00:27:07,650
Forskjellen mellom A og 'a' må være minst 26,

296
00:27:07,650 --> 00:27:10,760
eller annet vi ikke ville ha representert alle hovedstedene tall.

297
00:27:10,760 --> 00:27:18,630
Det betyr at A, hvis vi starter på 1, det kommer til å bruke alle disse bitene,

298
00:27:18,630 --> 00:27:23,900
alle disse første 5 biter, for å representere alt gjennom Z.

299
00:27:23,900 --> 00:27:32,170
Det er derfor den neste bit, eller dette litt, er neste bit den som er valgt å skille mellom A og 'en.

300
00:27:32,170 --> 00:27:40,930
Det er også grunnen til at, i ASCII-tabellen, det er 5 symboler som skiller store bokstaver fra små bokstaver.

301
00:27:40,930 --> 00:27:49,050
Siden de er symboler, de ekstra 5 som bringer opp 32 er forskjellen mellom dem.

302
00:27:49,050 --> 00:27:51,840
[Student] Så vi kunne gjøre det, fordi ASCII er laget på den måten.

303
00:27:51,840 --> 00:27:57,280
Ja. Men ASCII - forskjellen kan også være både av disse biter.

304
00:27:57,280 --> 00:28:12,040
Som, hvis A var 10000001, og 'a' var 11100001 - jeg glemmer, uansett.

305
00:28:12,040 --> 00:28:18,100
Men hvis det var dette, så vi kan fortsatt bruke 'a' - A.

306
00:28:18,100 --> 00:28:22,650
Det er bare nå forskjellen mellom A og 'a' er fortsatt disse to biter.

307
00:28:22,650 --> 00:28:32,240
Jeg tror det er skrevet 48. Er det 32 ​​+ 64? Jeg tror det er?

308
00:28:32,240 --> 00:28:40,160
Det vil fortsatt være to biter, hver eneste karakter, som, Z og z, K og k,

309
00:28:40,160 --> 00:28:45,160
de ville fortsatt ha de samme bits satt bortsett fra de to biter.

310
00:28:45,160 --> 00:28:48,870
Så lenge det er alltid sant, uavhengig av om vi bruker ASCII eller noen andre systemer,

311
00:28:48,870 --> 00:28:53,050
så lenge det er bare et visst antall biter som er forskjellige for hvert tegn,

312
00:28:53,050 --> 00:28:55,050
så det fungerer fint.

313
00:28:55,050 --> 00:29:06,110
Det er bare at 32 ble satt opp fordi det er den første vi kunne bruke. >> Cool.

314
00:29:06,110 --> 00:29:14,520
Jeg pleier å foretrekke, i tilfelle du ikke har sett, hvis blokken er bare en enkelt linje,

315
00:29:14,520 --> 00:29:24,280
du kan bli kvitt de klammeparentes, så jeg pleier å foretrekke å gjøre dette.

316
00:29:24,280 --> 00:29:34,010
Også, vet du hvordan vi kan gjøre ting som s [i] + = 1?

317
00:29:34,010 --> 00:29:41,090
Du kan også gjøre s [i] bitvis AND = 32.

318
00:29:41,090 --> 00:29:46,400
Og bitvis OR = 32.

319
00:29:46,400 --> 00:29:51,490
Også telle mod 2 == 0.

320
00:29:51,490 --> 00:30:00,900
Så husk det - jeg vil ikke skrive det - noen annen verdi enn null er sant, og 0 er usann.

321
00:30:00,900 --> 00:30:07,880
Så "hvis teller mod 2 == 0" er den samme som å si "hvis ikke telle mod 2."

322
00:30:07,880 --> 00:30:11,580
Jeg ville sannsynligvis ha bare snudd linjene og sa, "hvis teller mod 2,

323
00:30:11,580 --> 00:30:15,350
gjør det eller 1, andre gjør det og 1, "slik at jeg ikke trenger det" ikke ".

324
00:30:15,350 --> 00:30:18,650
Men dette fungerer like bra.

325
00:30:18,650 --> 00:30:25,660
Og hva annet kan jeg gjøre her?

326
00:30:25,660 --> 00:30:29,060
Du kan kombinere dem med trefoldig hvis du ville, men da det ville bare gjøre ting Messier

327
00:30:29,060 --> 00:30:33,770
og sannsynligvis vanskeligere å lese, så vi vil ikke gjøre det.

328
00:30:33,770 --> 00:30:37,330
Alle som har noen andre forslag?

329
00:30:37,330 --> 00:30:41,580
Er det alt problemet bedt om? Oh yeah.

330
00:30:41,580 --> 00:30:51,070
Så bli kvitt disse tomme linjer, nå vil vi ut f,% s er en for strykere,

331
00:30:51,070 --> 00:30:56,620
Vi vil skrive ut f, s.

332
00:30:56,620 --> 00:30:59,330
Nå la oss kjøre den. Gjorde jeg noe galt?

333
00:30:59,330 --> 00:31:03,200
Det er en \ ", jeg vil ha en n.

334
00:31:03,200 --> 00:31:07,840
Okay. Nå skal vi kjøre den. Det vil sannsynligvis kjefte på meg.

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

336
00:31:11,250 --> 00:31:14,290
Så dette er det fine med Clang er den forteller deg hva den er i,

337
00:31:14,290 --> 00:31:19,140
i stedet for GCC som bare sier "Hei, du glemte noe, jeg vet ikke hva det var."

338
00:31:19,140 --> 00:31:29,220
Men dette vil fortelle meg, "Du er ment å inkludere string.h."

339
00:31:29,220 --> 00:31:32,130
Så jeg ikke be om noe, så det er ikke å si noe.

340
00:31:32,130 --> 00:31:42,540
Men vi vil gjøre sitt eksempel, "Takk 4 add".

341
00:31:42,540 --> 00:31:47,880
Det ser rett. Hurra.

342
00:31:47,880 --> 00:31:52,370
Så tilbake til hovedsiden, jeg nesten aldri gjøre det.

343
00:31:52,370 --> 00:31:57,110
Det er valgfritt. Og viktigste er den eneste funksjonen som det er valgfritt.

344
00:31:57,110 --> 00:32:07,140
Hvis du ikke kommer tilbake noe fra main, er det antatt at du mente å returnere 0.

345
00:32:07,140 --> 00:32:13,070
Spørsmål?

346
00:32:13,070 --> 00:32:20,980
Okay. Så nå det andre problemet.

347
00:32:20,980 --> 00:32:24,810
"Recall fra uke 2 nest forelesning på at bytte to variabler verdier ved å sende

348
00:32:24,810 --> 00:32:30,780
de to variablene til en funksjon (selv om kalt swap) ikke akkurat fungerer, i hvert fall ikke uten 'pekere. "

349
00:32:30,780 --> 00:32:37,020
Og ignorere pekere til vi kommer til dem.

350
00:32:37,020 --> 00:32:40,070
Vi ønsker å bytte to variabler, vi bruker ikke en funksjon for å gjøre det.

351
00:32:40,070 --> 00:32:43,410
Vi fremdeles kommer til å gjøre det i hoved som det står.

352
00:32:43,410 --> 00:32:48,360
Men for å bruke disse to variablene, ønsker vi ikke å bruke en midlertidig variabel.

353
00:32:48,360 --> 00:32:50,770
Det er 2 måter å gjøre dette.

354
00:32:50,770 --> 00:32:56,310
Du kan gjøre det ved hjelp av tradisjonelle binære operatorer.

355
00:32:56,310 --> 00:33:00,180
Så vet noen en rask og skitten måte å gjøre det?

356
00:33:00,180 --> 00:33:07,650
Det kan faktisk ta et minutt å tenke på. Hvis jeg har -

357
00:33:07,650 --> 00:33:12,130
Jeg skal sette problemet opp som de spør. Så hvis jeg har to variabler, A, som er bare et heltall

358
00:33:12,130 --> 00:33:17,800
at de gir meg, og summen variabel B, som er en annen heltall som jeg får.

359
00:33:17,800 --> 00:33:22,700
Så hvis jeg har disse to variablene, nå vil jeg bytte dem.

360
00:33:22,700 --> 00:33:31,550
Den tradisjonelle, ved hjelp av din vanlige binære operatører, mener jeg, som +, -, ÷.

361
00:33:31,550 --> 00:33:36,630
Ikke bitvis operatører som virker på binær.

362
00:33:36,630 --> 00:33:39,600
Så bruker -, +, ÷, og alle disse.

363
00:33:39,600 --> 00:33:52,980
Vi kunne bytte ved å gjøre noe som en = a + b, og b = a - b, a = a - b.

364
00:33:52,980 --> 00:34:04,260
Så, sunn fornuft sjekk, og så får vi se hvorfor det fungerer.

365
00:34:04,260 --> 00:34:13,320
La oss si a = 7, b = 3, så a + b kommer til å bli 10 år.

366
00:34:13,320 --> 00:34:18,820
Så vi nå setter a = 10, og deretter vi gjør b = a - b.

367
00:34:18,820 --> 00:34:30,250
Så vi gjør b = a - b, som kommer til å være 7, og b = a - b igjen,

368
00:34:30,250 --> 00:34:38,650
eller a = a - b. Som kommer til å være 10 - 7 som er tre.

369
00:34:38,650 --> 00:34:44,850
Så nå, riktig, 'a' var 7, b var 3, og nå b er 7 og 'a' er 3.

370
00:34:44,850 --> 00:34:48,679
Så den slags er fornuftig, 'a' er kombinasjonen av de to tall.

371
00:34:48,679 --> 00:34:53,000
På dette punktet, 'a' er kombinasjonen, og så skal vi trekke ut den opprinnelige b,

372
00:34:53,000 --> 00:34:56,860
og så skal vi trekke ut hva som var den opprinnelige 'en.'

373
00:34:56,860 --> 00:35:01,150
Men dette fungerer ikke for alle tall.

374
00:35:01,150 --> 00:35:08,880
For å se dette, la oss vurdere et system, så vi vanligvis tenker på heltall som 32 biter.

375
00:35:08,880 --> 00:35:13,050
La oss arbeide med noe som er bare som 4 biter.

376
00:35:13,050 --> 00:35:15,450
Forhåpentligvis kommer jeg opp med et godt eksempel akkurat nå.

377
00:35:15,450 --> 00:35:18,680
Så, jeg vet, dette vil være lett.

378
00:35:18,680 --> 00:35:26,720
La oss si at våre to tall 1111, og 1111, så vi er i binær akkurat nå.

379
00:35:26,720 --> 00:35:34,630
I faktiske desimaler, hvis du ønsker å tenke på det på den måten, a = 15 og b = 15.

380
00:35:34,630 --> 00:35:37,630
Og så vi forventer, etter at vi bytte dem - de trenger ikke engang å være de samme tallene,

381
00:35:37,630 --> 00:35:41,140
men jeg gjorde det på denne måten.

382
00:35:41,140 --> 00:35:47,100
La oss gjøre dem ikke de samme tallene. La oss gjøre 1111 og 0001.

383
00:35:47,100 --> 00:35:51,860
Så en = 15 og b = 1.

384
00:35:51,860 --> 00:35:57,670
Etter at vi bytte dem, forventer vi 'a' for å være 1 og b for å være 15.

385
00:35:57,670 --> 00:36:01,780
Så vår første trinnet er a = a + b.

386
00:36:01,780 --> 00:36:08,770
Våre tall er bare 4 biter bred, så 'en,', som er 1111, + b, som er 0001,

387
00:36:08,770 --> 00:36:16,780
kommer til å ende opp med å bli 10000, men vi har bare 4 biter.

388
00:36:16,780 --> 00:36:22,540
Så nå a = 0.

389
00:36:22,540 --> 00:36:34,080
Og nå ønsker vi å sette b = a - b - faktisk, dette fortsatt fungerer perfekt.

390
00:36:34,080 --> 00:36:39,630
a = a - b - la oss se om dette fungerer perfekt.

391
00:36:39,630 --> 00:36:53,720
Så deretter b = 0 - 1, som ville fremdeles være 15, og deretter en = a - b, noe som ville være en.

392
00:36:53,720 --> 00:36:56,210
Kanskje dette virker.

393
00:36:56,210 --> 00:36:59,020
Jeg føler at det er en grunn til at det ikke fungerer med vanlig.

394
00:36:59,020 --> 00:37:06,400
Ok, så legger til grunn at det ikke fungerer med vanlige binære operasjoner,

395
00:37:06,400 --> 00:37:15,040
og jeg vil se etter - Jeg vil google for å se om det er sant.

396
00:37:15,040 --> 00:37:23,490
Så vi ønsker å gjøre det ved hjelp av bitvis operatører, og ledetråd her er XOR.

397
00:37:23,490 --> 00:37:28,780
Så introduserer XOR (^) hvis du ikke har sett den ennå.

398
00:37:28,780 --> 00:37:34,610
Det er, igjen, en bitvis operatør slik at den fungerer litt etter litt, og det er -

399
00:37:34,610 --> 00:37:39,910
Hvis du har de bit 0 og 1, så dette vil være en.

400
00:37:39,910 --> 00:37:45,230
Hvis du har bitene 1 og 0, vil det være en, har du bit 0 og 0 det vil være 0,

401
00:37:45,230 --> 00:37:47,640
og hvis du har bitene 1 og 1 vil det være 0.

402
00:37:47,640 --> 00:37:56,180
Så det er som OR. Hvis en av bitene er sant, er det en, men i motsetning til OR, kan det ikke være begge biter som er sant.

403
00:37:56,180 --> 00:37:59,320
Eller ville ha dette være en, ville XOR ha dette være 0.

404
00:37:59,320 --> 00:38:02,250
Så vi kommer til å ønske å bruke XOR her.

405
00:38:02,250 --> 00:38:09,960
Tenk på det et øyeblikk, jeg skal til Google.

406
00:38:09,960 --> 00:38:16,230
Vel, du kan ikke lese det, jeg er for tiden på XOR swap algoritmen side.

407
00:38:16,230 --> 00:38:21,340
Forhåpentligvis vil dette forklare hvorfor jeg L ° vernes -

408
00:38:21,340 --> 00:38:34,190
Dette er nøyaktig den algoritmen som vi nettopp gjorde.

409
00:38:34,190 --> 00:38:37,330
Jeg ser fortsatt ikke hvorfor - jeg må ha plukket et dårlig eksempel,

410
00:38:37,330 --> 00:38:44,940
men dette tilfellet hvor 'a' skjedde til å bli 0, etter å komme til 5 biter, så nå 'a' er 0,

411
00:38:44,940 --> 00:38:48,730
det er det som kalles "heltallsoverflyt."

412
00:38:48,730 --> 00:38:54,370
Ifølge Wikipedia, "I motsetning til XOR swap, krever denne varianten at den bruker noen metoder

413
00:38:54,370 --> 00:38:59,780
for å garantere at x + y ikke forårsaker heltalloverflyt. "

414
00:38:59,780 --> 00:39:08,350
Så dette har problemer, dette var heltallsoverflyt, men jeg gjorde noe galt.

415
00:39:08,350 --> 00:39:10,520
Jeg er ikke sikker. Jeg skal prøve å komme opp med en annen.

416
00:39:10,520 --> 00:39:13,640
[Student] Vel, er ikke heltallsoverflyt når du prøver å sette et tall i det

417
00:39:13,640 --> 00:39:16,640
større enn mengden biter du har tildelt?

418
00:39:16,640 --> 00:39:23,730
Ja. Vi har 4 biter. That - vi hadde 4 biter, vi så prøve å legge 1 til det, slik at vi ender opp med 5 biter.

419
00:39:23,730 --> 00:39:26,690
Men den femte bit bare blir avskåret, ja.

420
00:39:26,690 --> 00:39:28,970
Det kan faktisk -

421
00:39:28,970 --> 00:39:33,010
[Student] kaster du en feil, eller gjør det - ville det kaste en feil?

422
00:39:33,010 --> 00:39:40,720
Nei Så det er ingen feil. Når du kommer til forsamlingen nivå, en spesiell bit

423
00:39:40,720 --> 00:39:47,020
et sted er satt som sa at det var en overflyt, men i C snilt av deg bare ikke beskjeftige seg med.

424
00:39:47,020 --> 00:39:55,160
Du faktisk ikke kan takle det, med mindre du bruker spesielle monteringsanvisning i C.

425
00:39:55,160 --> 00:39:58,110
La oss tenke XOR swap.

426
00:39:58,110 --> 00:40:02,220
Og jeg tror Wikipedia-artikkelen har kanskje også vært å si at -

427
00:40:02,220 --> 00:40:07,310
Så det tok også opp modulær aritmetikk, så jeg antar jeg var i teorien gjør modulær aritmetikk

428
00:40:07,310 --> 00:40:11,160
da jeg sa at 0 - 1 er 15 igjen.

429
00:40:11,160 --> 00:40:15,410
Så det kan faktisk - på en vanlig prosessor som gjør 0 - 1 = 15.

430
00:40:15,410 --> 00:40:20,430
Siden vi ender opp på 0, trekker vi en, så da det brytes bare tilbake rundt til 1111.

431
00:40:20,430 --> 00:40:28,930
Så denne algoritmen kan faktisk fungere, a + b, a - b, b - a, det kan være fint.

432
00:40:28,930 --> 00:40:34,030
Men det er noen prosessorer som ikke gjør det, og så det ikke ville være fint i de bestemte seg.

433
00:40:34,030 --> 00:40:39,880
XOR swap vil fungere på alle prosessorer. Okay.

434
00:40:39,880 --> 00:40:42,280
Tanken er at det skal være den samme, skjønt.

435
00:40:42,280 --> 00:40:50,120
Hvor vi bruker XOR å liksom få informasjon både inn en av variablene,

436
00:40:50,120 --> 00:40:54,120
og trekk deretter ut informasjon om de enkelte variablene igjen.

437
00:40:54,120 --> 00:41:04,330
Så har noen ideer / svaret?

438
00:41:04,330 --> 00:41:14,540
[Student svar, uforståelig]

439
00:41:14,540 --> 00:41:22,220
Så dette skal fungere, og også er XOR kommutativ.

440
00:41:22,220 --> 00:41:27,620
Uansett hvilken rekkefølge disse 2 tallene tilfeldigvis er i her oppe,

441
00:41:27,620 --> 00:41:30,100
dette resultatet skal være den samme.

442
00:41:30,100 --> 00:41:35,800
Så en ^ b er b ^ en.

443
00:41:35,800 --> 00:41:51,860
Du kan også se dette skrevet som en ^ = b, b ^ = a, a ^ = b igjen.

444
00:41:51,860 --> 00:42:00,200
Så dette er rett, og for å se hvorfor dette fungerer, tenk på de biter.

445
00:42:00,200 --> 00:42:10,400
Ved hjelp av en smallish nummer, la oss si 11001, og 01100.

446
00:42:10,400 --> 00:42:12,790
Så dette er 'a', dette er b.

447
00:42:12,790 --> 00:42:15,540
Så en ^ = b.

448
00:42:15,540 --> 00:42:22,380
Vi kommer til å sette 'a' = til XOR av disse 2 tingene.

449
00:42:22,380 --> 00:42:32,920
Så 1 ^ 0 er 1, 1 ^ 1 er 0, 0 ^ 1 er 1, og 0 ^ 0 er 0, 1 ^ 0 er en.

450
00:42:32,920 --> 00:42:37,380
Så 'a, "hvis du ser på desimaltall, kommer det til å være -

451
00:42:37,380 --> 00:42:41,160
du kommer ikke til å se mye av et forhold mellom den opprinnelige 'a' og den nye 'a'

452
00:42:41,160 --> 00:42:45,600
men ser på bitene, 'a' er nå som en maske av informasjonen

453
00:42:45,600 --> 00:42:49,970
av både den opprinnelige 'A' og den opprinnelige B.

454
00:42:49,970 --> 00:42:57,930
Så hvis vi tar b ^ a, ser vi at vi vil ende opp på den opprinnelige 'en.'

455
00:42:57,930 --> 00:43:08,910
Og hvis vi tar den opprinnelige 'a' ^ den nye 'a, "vi ser vi ender opp på den opprinnelige b.

456
00:43:08,910 --> 00:43:18,380
Så (a ^ b) ^ b = den opprinnelige 'en.'

457
00:43:18,380 --> 00:43:27,910
Og (a ^ b) ^ a = den opprinnelige B.

458
00:43:27,910 --> 00:43:37,010
Det er - en annen måte å se dette er noe XOR selv er alltid 0.

459
00:43:37,010 --> 00:43:45,020
Så 1101 ^ 1101, blir alle biter kommer til å være den samme.

460
00:43:45,020 --> 00:43:47,920
Så det aldri kommer til å bli en sak der en er en 0 og den andre er en.

461
00:43:47,920 --> 00:43:51,080
Så dette er 0000.

462
00:43:51,080 --> 00:43:57,240
Det samme med denne. (A ^ b) ^ b er som en ^ (b ^ b).

463
00:43:57,240 --> 00:44:03,680
(B ^ b) kommer til å være 0, a ^ 0 er bare kommer til å være "en", siden alle bitene er 0.

464
00:44:03,680 --> 00:44:08,050
Så de eneste som kommer til å være der 'a' var opprinnelig en 1 - hadde de.

465
00:44:08,050 --> 00:44:12,070
Og den samme ideen her, jeg er ganske sikker på at det er også kommutativ.

466
00:44:12,070 --> 00:44:17,590
Ja. Jeg sa før at det var kommutativ.

467
00:44:17,590 --> 00:44:24,680
Den ^ 'a', og det er assosiativ, så nå (b ^ a) ^ en.

468
00:44:24,680 --> 00:44:28,970
Og vi kan gjøre b ^ (a ^ a).

469
00:44:28,970 --> 00:44:31,540
Og så igjen, får vi den opprinnelige b.

470
00:44:31,540 --> 00:44:37,120
Så 'a' er nå en kombinasjon av 'a' og b sammen.

471
00:44:37,120 --> 00:44:49,660
Ved hjelp av vår nye combo 'a' vi si b = combo 'a' ^ den opprinnelige b, får vi den opprinnelige 'en.'

472
00:44:49,660 --> 00:45:05,170
Og nå a = combo 'a' ^ den nye b, som var den opprinnelige - eller som nå hva var 'a' eller b.

473
00:45:05,170 --> 00:45:13,620
Det er denne saken her nede. Dette er = b, gamle b..

474
00:45:13,620 --> 00:45:16,550
Så nå er alt tilbake i byttet rekkefølge.

475
00:45:16,550 --> 00:45:22,960
Hvis vi faktisk sett på bitene, b = a ^ b, skal XOR disse to,

476
00:45:22,960 --> 00:45:33,920
og svaret kommer til å bli dette, og deretter a = a ^ b er XORing disse to, og svaret er dette.

477
00:45:33,920 --> 00:45:41,090
Spørsmål? Okay. Så den siste er noe betydelig vanskeligere.

478
00:45:41,090 --> 00:45:43,180
[Student] Jeg tror han har et spørsmål om det. >> Beklager.

479
00:45:43,180 --> 00:45:49,380
[Student] Hva er egentlig raskere? Hvis du bruker denne XOR, eller er det hvis du deklarerer en ny variabel?

480
00:45:49,380 --> 00:45:55,190
Så hva er faktisk raskere, erklærte en ny variabel eller bruke XOR å bytte?

481
00:45:55,190 --> 00:45:59,600
Svaret er, i all sannsynlighet, en midlertidig variabel.

482
00:45:59,600 --> 00:46:05,780
Og det er fordi når den er utarbeidet ned - så i forsamlingen nivå,

483
00:46:05,780 --> 00:46:12,320
Det finnes ikke noe slikt som lokale variabler eller eventuelle midlertidige variabler eller noen av disse greiene.

484
00:46:12,320 --> 00:46:16,060
De er akkurat som - det er minne, og det er registre.

485
00:46:16,060 --> 00:46:20,920
Registrene er hvor ting er aktivt skjer.

486
00:46:20,920 --> 00:46:24,750
Du trenger ikke legge to ting i minnet, du legge til 2 ting i registre.

487
00:46:24,750 --> 00:46:28,160
Og du tar ting fra minnet, i registre for deretter legge dem,

488
00:46:28,160 --> 00:46:33,180
og deretter kan du sette dem tilbake inn i minnet, men all handlingen skjer i registre.

489
00:46:33,180 --> 00:46:38,750
Så når du bruker den midlertidige variabelen tilnærming, vanligvis hva som skjer er

490
00:46:38,750 --> 00:46:42,810
disse to numrene er allerede i registre.

491
00:46:42,810 --> 00:46:46,570
Og deretter fra det punktet på, etter at du har byttet dem,

492
00:46:46,570 --> 00:46:51,540
det vil bare begynne å bruke den andre register.

493
00:46:51,540 --> 00:46:56,510
Uansett hvor du hadde brukt b, vil det bare bruke registeret som allerede lagring 'a ".

494
00:46:56,510 --> 00:47:02,180
Slik at det ikke trenger å gjøre noe for å faktisk gjøre swap. Ja?

495
00:47:02,180 --> 00:47:05,690
[Student] Men det tar også mer minne, ikke sant?

496
00:47:05,690 --> 00:47:10,280
Det vil bare ta mer minne hvis det er behov for å lagre det midlertidig variabel.

497
00:47:10,280 --> 00:47:14,830
Som hvis du senere bruke den midlertidige variabelen igjen et sted,

498
00:47:14,830 --> 00:47:18,920
da - eller du tilordne noe til det midlertidige variabelen.

499
00:47:18,920 --> 00:47:24,630
Så dersom det på noe tidspunkt 'a' b i temp har forskjellige verdier eller noe,

500
00:47:24,630 --> 00:47:30,680
så det kommer til å ha forskjellige steder i minnet, men det er sant at

501
00:47:30,680 --> 00:47:34,800
det er mange lokale variabler som bare eksisterer i registre.

502
00:47:34,800 --> 00:47:44,370
I så fall, er det aldri satt inn i minnet, og slik at du aldri kaster bort minne.

503
00:47:44,370 --> 00:47:58,620
Okay. Siste spørsmål er litt mer.

504
00:47:58,620 --> 00:48:04,850
Så her, i denne CS50 maskinen er det en ordbok.

505
00:48:04,850 --> 00:48:12,390
Og grunnen til dette er fordi [? B66] er en stavekontroll der du skal skrive

506
00:48:12,390 --> 00:48:15,780
bruker hash tabeller eller prøver eller noen datastruktur.

507
00:48:15,780 --> 00:48:22,660
Du kommer til å skrive en stavekontroll, og du kommer til å bruke denne ordboken til å gjøre det.

508
00:48:22,660 --> 00:48:28,280
Men for dette problemet, er vi bare kommer til å se opp for å se om et ord er i ordboken.

509
00:48:28,280 --> 00:48:31,250
Så i stedet for å lagre hele ordboken i noen datastruktur

510
00:48:31,250 --> 00:48:35,180
og deretter se over et helt dokument for å se om noe er stavet feil,

511
00:48:35,180 --> 00:48:38,490
vi bare ønsker å finne en ord. Så vi kan bare skanne over hele ordboken

512
00:48:38,490 --> 00:48:44,300
og hvis vi aldri finne ordet i hele ordboken, så det var ikke der.

513
00:48:44,300 --> 00:48:52,150
Hvis vi skanne over hele ordbok og ser ordet, da vi er gode, vi fant det.

514
00:48:52,150 --> 00:48:56,580
Det står her at vi ønsker å begynne å se på C journal-håndtering funksjon,

515
00:48:56,580 --> 00:48:59,930
siden vi ønsker å lese ordboken,

516
00:48:59,930 --> 00:49:07,680
men jeg vil gi hint her om hvilke funksjoner du bør tenke på.

517
00:49:07,680 --> 00:49:11,510
Jeg skal skrive dem på Spaces.

518
00:49:11,510 --> 00:49:20,490
Så de viktigste du ønsker å se på er f åpen og så, uunngåelig, f lukket,

519
00:49:20,490 --> 00:49:26,540
som vil gå på slutten av programmet, og f scan f.

520
00:49:26,540 --> 00:49:31,060
Du kan også bruke f lese, men du sannsynligvis ikke vil

521
00:49:31,060 --> 00:49:34,200
fordi det - du ikke ender opp som trenger det.

522
00:49:34,200 --> 00:49:41,880
F scan f er hva du skal bruke til å skanne over ordlisten.

523
00:49:41,880 --> 00:49:46,370
Og så du trenger ikke å kode opp løsningen, bare prøve og liker pseudo-koden din vei

524
00:49:46,370 --> 00:50:05,200
til en løsning, og så får vi diskutere det.

525
00:50:05,200 --> 00:50:14,110
Og faktisk, siden jeg allerede ga deg disse, hvis du går inn i noen terminal eller apparatets skall,

526
00:50:14,110 --> 00:50:18,250
Jeg ville - Jeg pleier - hvis du ikke har sett ennå, jeg vet ikke om du gjorde i klassen,

527
00:50:18,250 --> 00:50:23,490
men mannen, så mannen sidene, er ganske nyttig for å se på ganske mye noen funksjon.

528
00:50:23,490 --> 00:50:27,330
Så jeg kan gjøre, liker, mann f, skanning f.

529
00:50:27,330 --> 00:50:32,300
Dette er nå info om skanningen f familien av funksjoner.

530
00:50:32,300 --> 00:50:37,070
Jeg kan også gjøre mannen f, åpne, og som vil gi meg detaljer om det.

531
00:50:37,070 --> 00:50:40,750
Så hvis du vet hvilken funksjon du bruker, eller du leser koden

532
00:50:40,750 --> 00:50:43,000
og du ser noen funksjon, og du er som "Hva gjør dette?"

533
00:50:43,000 --> 00:50:45,280
Bare mannen som funksjon navn.

534
00:50:45,280 --> 00:50:47,340
Det er et par av rare eksempler der du kan ha å si

535
00:50:47,340 --> 00:50:51,620
liker. man 2 som funksjon navn, eller man 3 som fungerer navn,

536
00:50:51,620 --> 00:50:58,230
men du trenger bare å gjøre det hvis man funksjonsnavn skjer ikke å jobbe for første gang.

537
00:50:58,230 --> 00:51:03,010
[Student] Så jeg leser mannen siden for å åpne, men jeg er fortsatt forvirret om hvordan du bruker det, og programmet.

538
00:51:03,010 --> 00:51:06,170
Okay. Mange av man-sidene er mindre enn nyttig.

539
00:51:06,170 --> 00:51:08,470
De er mer nyttig hvis du allerede vet hva de gjør

540
00:51:08,470 --> 00:51:12,670
og du trenger bare å huske rekkefølgen på argumentene eller noe.

541
00:51:12,670 --> 00:51:17,640
Eller de kan gi deg en generell oversikt, men noen av dem er veldig overveldende.

542
00:51:17,640 --> 00:51:22,220
Som f scan f, også. Det gir deg informasjon om alle disse funksjonene,

543
00:51:22,220 --> 00:51:28,120
og 1 linje ned her skjer for å si, "F scan f leser fra strengen punkt eller bekk."

544
00:51:28,120 --> 00:51:32,360
Men f åpne. Så, hvordan ville vi bruke f åpen?

545
00:51:32,360 --> 00:51:38,470
Ideen om et program som må gjøre fil I / O er at

546
00:51:38,470 --> 00:51:45,070
må du først åpne filen du ønsker å gjøre ting med, og uunngåelig,

547
00:51:45,070 --> 00:51:51,220
lese ting fra denne filen og gjøre ting med dem.

548
00:51:51,220 --> 00:51:55,350
F åpen er det vi bruker til å åpne filen.

549
00:51:55,350 --> 00:52:04,190
Ting vi kommer tilbake, så hva filen vil vi åpne, det gir oss -

550
00:52:04,190 --> 00:52:11,970
her står det "/ user / share / dict / ord."

551
00:52:11,970 --> 00:52:16,740
Dette er filen som vi ønsker å åpne, og vi ønsker å åpne den -

552
00:52:16,740 --> 00:52:21,440
vi må eksplisitt angi om vi ønsker å åpne den for å lese eller hvis vi ønsker å åpne den for å skrive.

553
00:52:21,440 --> 00:52:26,490
Det er et par kombinasjoner og sånt, men vi ønsker å åpne dette for lesing.

554
00:52:26,490 --> 00:52:29,380
Vi vil lese fra filen.

555
00:52:29,380 --> 00:52:34,290
Så hva gjør denne avkastningen? Den returnerer en fil stjerne (*),

556
00:52:34,290 --> 00:52:37,260
og jeg vil bare vise alt i variabelen f, så *,

557
00:52:37,260 --> 00:52:40,840
igjen, det er en peker, men vi ønsker ikke å forholde seg til pekere.

558
00:52:40,840 --> 00:52:46,470
Du kan tenke på f som er f nå variabelen du skal bruke til å representere filen.

559
00:52:46,470 --> 00:52:49,850
Så hvis du ønsker å lese fra filen, du leste fra f.

560
00:52:49,850 --> 00:52:54,820
Hvis du ønsker å lukke filen, lukker du f.

561
00:52:54,820 --> 00:53:00,350
Så på slutten av programmet når vi uunngåelig vil lukke filen, hva skal vi gjøre?

562
00:53:00,350 --> 00:53:06,750
Vi ønsker å lukke f.

563
00:53:06,750 --> 00:53:12,600
Så nå den siste filen funksjon som vi kommer til å ønske å bruke er scan f, f scan f.

564
00:53:12,600 --> 00:53:20,930
Og hva det gjør er det skanner over filen på jakt etter et mønster å matche.

565
00:53:20,930 --> 00:53:39,100
Ser på mannen siden her, ser vi int f scan f, ignorere returverdien for nå.

566
00:53:39,100 --> 00:53:45,230
Det første argumentet er filen * stream, så det første argumentet vi kommer til å ønske å passere er f.

567
00:53:45,230 --> 00:53:47,900
Vi skanner enn f.

568
00:53:47,900 --> 00:53:53,680
Det andre argumentet er et format streng.

569
00:53:53,680 --> 00:53:58,310
Jeg vil gi deg et format streng akkurat nå.

570
00:53:58,310 --> 00:54:05,180
Jeg tror vi tilfeldigvis å si, 127s \ n, mye av det er unødvendig.

571
00:54:05,180 --> 00:54:12,490
Ideen om hva som formatstrengen er, er at du kan tenke på scan f som det motsatte av print f.

572
00:54:12,490 --> 00:54:17,160
Så print f, print f vi også bruke denne typen format parameter,

573
00:54:17,160 --> 00:54:25,000
men i print f hva vi gjør er - la oss se på en tilsvarende.

574
00:54:25,000 --> 00:54:32,550
Så ut f, og det er faktisk også f print f, der det første argumentet kommer til å være f.

575
00:54:32,550 --> 00:54:40,980
Når du skriver ut f, kan vi si noe sånt som "print 127s \ n" og hvis vi passerer det noen streng,

576
00:54:40,980 --> 00:54:44,050
det kommer til å skrive ut denne strengen og deretter en ny linje.

577
00:54:44,050 --> 00:54:49,690
Hva 127 betyr, er jeg ganske sikker på, men jeg har aldri innskrenket meg til det,

578
00:54:49,690 --> 00:54:52,470
Du ville ikke engang trenger å si '127 'i utskriften f,

579
00:54:52,470 --> 00:54:57,090
men hva det betyr er skrive de første 127 tegn.

580
00:54:57,090 --> 00:54:59,350
Så jeg er ganske sikker på at det er tilfelle. Du kan google for det.

581
00:54:59,350 --> 00:55:03,000
Men i den neste er jeg nesten positivt, betyr det at.

582
00:55:03,000 --> 00:55:08,880
Så dette er skrive de første 127 tegn, etterfulgt av en ny linje.

583
00:55:08,880 --> 00:55:14,680
F scan f nå, i stedet for å se på en variabel og skrive den ut,

584
00:55:14,680 --> 00:55:22,620
det kommer til å se på noen streng, og lagre mønsteret inn i variabelen.

585
00:55:22,620 --> 00:55:26,360
La oss faktisk bruke skanning f i en annen eksempel.

586
00:55:26,360 --> 00:55:31,670
Så la oss si at vi hadde noen int, x = 4,

587
00:55:31,670 --> 00:55:41,110
og vi ønsket å lage en streng laget av - ønsket å lage strengen

588
00:55:41,110 --> 00:55:44,250
som var som, dette vil komme opp mye senere,

589
00:55:44,250 --> 00:55:49,020
noe som er akkurat som 4.jpg.

590
00:55:49,020 --> 00:55:51,870
Så dette kan være et program der du vil ha summen teller,

591
00:55:51,870 --> 00:55:56,420
oppsummere telleren jeg, og du vil spare en haug med bilder.

592
00:55:56,420 --> 00:56:02,430
Så du vil lagre i.jpg, hvor jeg er noen gjentakelse av loopen din.

593
00:56:02,430 --> 00:56:05,500
Så hvordan skal vi gjøre denne strengen for at JPEG?

594
00:56:05,500 --> 00:56:11,720
Hvis du ønsker å skrive ut 4.jpg, kunne vi bare si print f,% d.jpg,

595
00:56:11,720 --> 00:56:14,410
og da ville det ut for at JPEG.

596
00:56:14,410 --> 00:56:20,050
Men hvis vi ønsker å lagre strengen 4.jpg, bruker vi scan f.

597
00:56:20,050 --> 00:56:30,860
Så streng s - faktisk vi L ° vernes - karakter, røye s, la oss gå 100.

598
00:56:30,860 --> 00:56:35,400
Så jeg nettopp erklært noen utvalg på 100 tegn,

599
00:56:35,400 --> 00:56:39,830
og det er det vi uunngåelig kommer til å bli lagring som JPEG i.

600
00:56:39,830 --> 00:56:47,920
Så vi kommer til å bruke skanning f, og formatet, hvordan vi ville si% d.jpg

601
00:56:47,920 --> 00:56:54,980
for å skrive ut 4.jpg, er formatet på dette kommer til å være% d.jpg.

602
00:56:54,980 --> 00:57:04,020
Så formatet er% d.jpg, hva vi ønsker å erstatte% d med er x,

603
00:57:04,020 --> 00:57:06,590
og nå trenger vi å lagre strengen et sted.

604
00:57:06,590 --> 00:57:12,500
Og hvor vi kommer til å lagre denne strengen er i tabellen er.

605
00:57:12,500 --> 00:57:21,640
Så etter denne linjen med kode, s, hvis vi skriver ut f,% s av den variable s,

606
00:57:21,640 --> 00:57:26,280
det kommer til å skrive ut 4.jpg.

607
00:57:26,280 --> 00:57:38,930
Så f scan f er den samme som skanningen f, bortsett fra nå det ser over denne filen

608
00:57:38,930 --> 00:57:43,600
for hva som kan lagres i s.

609
00:57:43,600 --> 00:57:46,160
Det er hva det siste argumentet skal være.

610
00:57:46,160 --> 00:57:54,170
Vi ønsker å lagre - "Scan f familie av funksjoner skanner både i henhold til formatet som prøvde nedenfor.

611
00:57:54,170 --> 00:58:02,450
Hvis noen blir lagret i festepunktene du kan returnere - "

612
00:58:02,450 --> 00:58:12,910
Nei, vi kan være bra. La meg tenke et sekund.

613
00:58:12,910 --> 00:58:26,350
Så scan f ikke - hva pokker er funksjonen som gjør det?

614
00:58:26,350 --> 00:58:31,650
Så scan f ikke kommer til å ta et heltall og gjøre dot jpg.

615
00:58:31,650 --> 00:58:43,490
Det kommer til å [mumbles].

616
00:58:43,490 --> 00:58:49,360
Lagre int variabel i string int C.

617
00:58:49,360 --> 00:58:55,940
Hva er denne variabelen, eller hva er denne funksjonen heter?

618
00:58:55,940 --> 00:59:04,950
Ja. That - Ja. Så det jeg definerer deg før var s print f,

619
00:59:04,950 --> 00:59:09,820
som - som gjør mye mer fornuftig, hvorfor jeg sa det var mye mer som print f.

620
00:59:09,820 --> 00:59:14,700
Scan f er fortsatt litt som print f, men s print f kommer til å skanne det over

621
00:59:14,700 --> 00:59:17,510
og erstatte variablene og nå lagre det i en streng.

622
00:59:17,510 --> 00:59:19,620
I stedet for å skrive den ut, lagrer den det i en streng.

623
00:59:19,620 --> 00:59:25,070
Så ignorere det helt. Du kan fortsatt tenke på formatet specifier som sånn av print f.

624
00:59:25,070 --> 00:59:34,510
Så nå, hvis vi ønsket å gjøre 4.jpg ting, ville vi gjøre s print f, x av dette.

625
00:59:34,510 --> 00:59:38,520
Så hva scan f gjør - hva ble spørsmålet ditt kommer til å bli?

626
00:59:38,520 --> 00:59:40,820
[Student] Jeg er bare forvirret om hva vi prøver å gjøre her

627
00:59:40,820 --> 00:59:43,450
med at JPEG. Kan du forklare det en gang til?

628
00:59:43,450 --> 00:59:52,710
Så dette var - det er mindre relevante for f scan f nå, forhåpentligvis vil det knytte tilbake på noen slags måte.

629
00:59:52,710 --> 01:00:02,240
Men det jeg opprinnelig hadde tenkt å vise var - dette er faktisk direkte relevant for disse [? F5]

630
01:00:02,240 --> 01:00:08,520
Du kommer til å bruke s print f, hvor si vi har 100 bilder,

631
01:00:08,520 --> 01:00:13,630
og du ønsker å lese 1.jpg image, 2.jpg, 3.jpg.

632
01:00:13,630 --> 01:00:21,520
Så for å gjøre det, må du f åpen, og deretter må du passere i strengen du vil åpne.

633
01:00:21,520 --> 01:00:30,020
Så vi ønsker å åpne 1.jpg, for å lage strengen som er 1.jpg,

634
01:00:30,020 --> 01:00:37,660
vi gjør s print f av% d.jpg--vi ikke gjøre for int i = 0.

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

636
01:00:46,580 --> 01:00:51,130
Så s print f% d.jpg av jeg.

637
01:00:51,130 --> 01:00:56,320
Så etter denne linjen, nå variabelen eller matrisen s kommer til å 1.jpg.

638
01:00:56,320 --> 01:01:10,610
Eller, 0.jpg, 1.jpg, 2.jpg. Og så kan vi åpne i sin tur hvert bilde for lesing.

639
01:01:10,610 --> 01:01:19,550
Så det er hva som er ut f gjør. Ser du hva som er ut f nå gjør?

640
01:01:19,550 --> 01:01:25,720
[Student] Ok, så det tar - det skaper en streng, something.jpg, og deretter lagrer den.

641
01:01:25,720 --> 01:01:30,360
Ja. Det skaper - dette er et annet format streng, akkurat som skanning f og print f,

642
01:01:30,360 --> 01:01:37,530
der det settes alle variabler i det andre argumentet, kan være s i motsetning til i.

643
01:01:37,530 --> 01:01:42,280
Kanskje - Jeg mener, det er tilfelle. Men uansett den rekkefølgen som argumentene er.

644
01:01:42,280 --> 01:01:45,440
Det kommer til å sette alle variablene i formatstrengen

645
01:01:45,440 --> 01:01:52,250
og deretter lagre i buffer vår, vi kaller det en buffer, er det der vi lagrer strengen.

646
01:01:52,250 --> 01:02:00,750
Så vi lagrer innsiden av s riktig-formatert streng, etter å ha% d blitt erstattet med 4.

647
01:02:00,750 --> 01:02:08,080
[Student] Så hvis vi gjorde dette, er variabelen f bare kommer til å bli omplassert?

648
01:02:08,080 --> 01:02:18,110
Ja. Så vi bør lukke den opprinnelige f før du gjør dette.

649
01:02:18,110 --> 01:02:22,810
Men - og da også, hvis det ikke var en f åpne opp her, så vi trenger å si -

650
01:02:22,810 --> 01:02:29,280
Ja. Men det ville åpne hundre forskjellige filer.

651
01:02:29,280 --> 01:02:37,360
[Student] Men vi ville ikke være i stand til å få tilgang til eller - OK.

652
01:02:37,360 --> 01:02:44,230
Okay. Så scan f, f scan f, er slags av den samme ideen,

653
01:02:44,230 --> 01:02:53,610
men i stedet for, i stedet for å lagre den i en streng, er det mer som du er nå

654
01:02:53,610 --> 01:03:02,420
gå over en brodd og mønstergjenkjenning mot strengen og lagring av resultatene i variabler.

655
01:03:02,420 --> 01:03:11,290
Du kan bruke skanning f å analysere over noe som 4.jpg, og lagre heltall 4 inn summen int x.

656
01:03:11,290 --> 01:03:13,430
Det er hva vi kan bruke skanning f for.

657
01:03:13,430 --> 01:03:16,300
F scan f kommer til å gjøre det på kommandolinjen.

658
01:03:16,300 --> 01:03:19,200
Jeg er faktisk ganske sikker på at dette er hva CS50 biblioteket gjør.

659
01:03:19,200 --> 01:03:29,050
Så når du sier, "få int," det er scan f-ing over - scan f er måten du får inndata fra brukeren.

660
01:03:29,050 --> 01:03:34,670
F scan f kommer til å gjøre det samme, men ved hjelp av en fil for å søke over.

661
01:03:34,670 --> 01:03:41,090
Så her er vi skanning i denne filen.

662
01:03:41,090 --> 01:03:45,460
Det mønsteret vi prøver å matche er noen streng som er 127 tegn

663
01:03:45,460 --> 01:03:48,100
etterfulgt av en ny linje

664
01:03:48,100 --> 01:03:54,770
Så jeg er ganske sikker på at vi kunne selv bare si "matche s", siden i ordlisten

665
01:03:54,770 --> 01:03:57,770
vi måtte ha, vi garantert ingen ord er så lang,

666
01:03:57,770 --> 01:04:03,310
og også f scan f, tror jeg, vil stoppe på den nye linjen, uansett hva.

667
01:04:03,310 --> 01:04:06,970
Men vi vil inkludere ny linje i kampen, og -

668
01:04:06,970 --> 01:04:13,960
[Student] Hvis vi ikke inkluderer den nye linjen, ville det ikke finne deler av et ord?

669
01:04:13,960 --> 01:04:22,900
It - hver - se på ordlisten -

670
01:04:22,900 --> 01:04:26,200
Så i ordboken, disse er alle våre ord.

671
01:04:26,200 --> 01:04:30,500
Hver og en er på en ny linje.

672
01:04:30,500 --> 01:04:32,510
Skanningen f kommer til å plukke opp dette ordet.

673
01:04:32,510 --> 01:04:38,750
Hvis vi ikke tar med den nye linjen, så er det mulig at den neste scan f vil bare lese den nye linjen.

674
01:04:38,750 --> 01:04:44,180
Men inkludert ny linje da vil bare ignorere den nye linjen.

675
01:04:44,180 --> 01:04:49,440
Men vi vil aldri få en del av et ord, siden vi alltid lese opp til en ny linje, uansett hva.

676
01:04:49,440 --> 01:04:54,530
[Student] Men hva hvis du søker etter ordet "cissa," som cissa.

677
01:04:54,530 --> 01:04:57,380
Vil det finne det, og sier det er en kamp?

678
01:04:57,380 --> 01:05:05,110
Så her er vi - det vil lese i - dette er faktisk et godt poeng.

679
01:05:05,110 --> 01:05:10,660
Vi kommer aldri å bruke den gjeldende - ordet vi leter etter er den første kommandolinjen argument.

680
01:05:10,660 --> 01:05:16,460
Så streng, ord = argv en.

681
01:05:16,460 --> 01:05:20,020
Så strengen vi leter etter er argv en.

682
01:05:20,020 --> 01:05:23,290
Vi er ikke ute etter et ord i det hele tatt i vår scan f.

683
01:05:23,290 --> 01:05:28,030
Hva vi gjorde med skanning f blir hvert ord i ordboken,

684
01:05:28,030 --> 01:05:34,320
og deretter når vi har det ordet vi kommer til å bruke strcmp å sammenligne dem.

685
01:05:34,320 --> 01:05:39,210
Vi kommer til å sammenligne våre ord og hva vi bare lese i.

686
01:05:39,210 --> 01:05:45,110
Så uunngåelig, vi kommer til å ende opp med å gjøre en haug med skanning fs

687
01:05:45,110 --> 01:05:52,130
før det bare så skjer at skanning f vil returnere -

688
01:05:52,130 --> 01:05:54,800
det vil returnere en, så lenge det har matchet et nytt ord,

689
01:05:54,800 --> 01:06:01,360
og det vil returnere noe annet så snart den har ikke klart å matche ordet.

690
01:06:01,360 --> 01:06:08,440
Vi leser over hele ordboken, lagring linje etter linje hvert ord i det variable s.

691
01:06:08,440 --> 01:06:17,240
Deretter vi sammenligner ordet med s, og hvis sammenligningen == 0,

692
01:06:17,240 --> 01:06:21,650
strcmp skjer for å bringe 0 hvis en kamp ble gjort.

693
01:06:21,650 --> 01:06:31,510
Så hvis det var 0, så kan vi skrive ut f, matchet,

694
01:06:31,510 --> 01:06:35,370
eller ordet er i ordboken, eller hva du vil skrive ut f.

695
01:06:35,370 --> 01:06:41,450
Og så - vi ønsker ikke å f lukke igjen og igjen.

696
01:06:41,450 --> 01:06:50,410
Dette er den type ting vi ønsker å gjøre, og vi er ikke bare ute etter ord i ordlisten.

697
01:06:50,410 --> 01:06:56,660
Slik at vi kunne gjøre det, hvis vi ønsket å se etter deres mønster, cissa, som du sa før,

698
01:06:56,660 --> 01:07:00,260
hvis vi ønsket å se etter dette mønsteret, så det ville mislykkes i saken

699
01:07:00,260 --> 01:07:08,010
fordi det er egentlig ikke et ord, men en av de ord i ordboken tilfeldigvis har det i den.

700
01:07:08,010 --> 01:07:13,560
Så det ville matche dette ordet, men denne undergruppen av ordet er ikke et ord i seg selv.

701
01:07:13,560 --> 01:07:17,250
Men det er ikke slik vi bruker det, vi leser i hvert ord

702
01:07:17,250 --> 01:07:19,740
og deretter sammenligne ordet vi har med det ordet.

703
01:07:19,740 --> 01:07:25,780
Så vi alltid sammenligner fulle ord.

704
01:07:25,780 --> 01:07:29,620
Jeg kan sende ut de endelige løsningene senere.

705
01:07:29,620 --> 01:07:32,050
Dette er slags nesten det rette svaret, tror jeg.

706
01:07:32,050 --> 01:07:34,720
[Student kommentar, uforståelig]

707
01:07:34,720 --> 01:07:40,870
Oh, jeg bli kvitt det før? Char s, antar jeg vi sa 127 - jeg glemmer hva den største er.

708
01:07:40,870 --> 01:07:44,100
Vi får bare gjøre 128, så nå er er lang nok.

709
01:07:44,100 --> 01:07:46,570
Vi trenger ikke å skrive noe.

710
01:07:46,570 --> 01:07:56,440
Vi kommer også til å ønske å ha å lukke våre fil, og det bør være om det rette svaret.

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