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

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

5
00:00:15,770 --> 00:00:22,220
Det er første gang, at vi skifter fra det traditionelle-foredrag-stil sektion,

6
00:00:22,220 --> 00:00:25,610
hvor vi bare lidt gennemgang hvad der skete i foredrag og så jer stille spørgsmål,

7
00:00:25,610 --> 00:00:32,250
nu at være meget mere problem-baseret, hvor vi bruger Spaces, og -

8
00:00:32,250 --> 00:00:37,410
Åh, så idéen er at gå til dette link jeg sendte dig, og så vil du være i mit Space.

9
00:00:37,410 --> 00:00:42,410
Er der nogen der ikke har en bærbar computer? Okay.

10
00:00:42,410 --> 00:00:47,050
Så vi kommer til at bruge det, og vi vil gøre problemerne bor i afsnit

11
00:00:47,050 --> 00:00:50,740
og diskutere dem og finde ud af hvad der er galt

12
00:00:50,740 --> 00:00:56,390
og jeg kunne trække nogle af din kode, og jeg kunne diskutere dine ideer.

13
00:00:56,390 --> 00:01:02,140
Så har nogen haft svært?

14
00:01:02,140 --> 00:01:07,000
Du kan chatte på siden, jeg ved ikke, om vi vil have grund til.

15
00:01:07,000 --> 00:01:12,270
Nu, ligesom den forrige supersection, hvis du var på den klasse, du ved, hvad det handler om.

16
00:01:12,270 --> 00:01:19,200
På alle P sæt der kommer til at være disse sektioner.

17
00:01:19,200 --> 00:01:22,550
Så P-sæt 2, specifikationer, jeg tror du så det på P-sæt 1 allerede.

18
00:01:22,550 --> 00:01:27,400
Men vi kan se på P-sæt 2 for, hvad vi kommer til at gå over i dag.

19
00:01:27,400 --> 00:01:29,460
Og du vil se et afsnit med spørgsmål.

20
00:01:29,460 --> 00:01:37,530
Så det vil være i alle de P-sæt, der vil være en del af spørgsmålene.

21
00:01:37,530 --> 00:01:41,340
Indtil videre har vi sagde, "Overveje dette en mulighed for at øve."

22
00:01:41,340 --> 00:01:44,940
Du vil ikke blive bedt om at indsende dette program.

23
00:01:44,940 --> 00:01:48,480
Tanken er, at de formodes at slags hjælpe dig i gang med problemet sæt.

24
00:01:48,480 --> 00:01:53,220
Jeg gætter på Hacker udgave bliver en masse af dem formodes at bare være nye, interessante ting at lære.

25
00:01:53,220 --> 00:01:58,590
De kan ikke være direkte anvendelig på problemet sæt.

26
00:01:58,590 --> 00:02:01,810
Og lige nu er vi ikke have du sender dem, men i teorien,

27
00:02:01,810 --> 00:02:07,480
for senere problem sæt, kan du indsende dem, og dermed kan du enten komme til afsnit

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

29
00:02:10,380 --> 00:02:16,350
hvis du ikke har lyst til at nyde min tilstedeværelse.

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

31
00:02:21,010 --> 00:02:29,280
Oh. Også under disse dele af spørgsmål, vi også har du stille spørgsmål om de shorts.

32
00:02:29,280 --> 00:02:33,440
Så jeg gætte, i teorien, du skulle se dem før de kom til afsnittet,

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

34
00:02:38,550 --> 00:02:42,590
Så vi kan starte med disse: "Hvordan kan en while-løkke adskiller sig fra en gør-while-løkke?

35
00:02:42,590 --> 00:02:46,210
Hvornår er det sidste særligt nyttigt? "

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

37
00:02:49,390 --> 00:02:52,730
[Student] gør-while-løkke altid vil udføre mindst én gang.

38
00:02:52,730 --> 00:03:02,950
Ja. Så det er forskellen. En while-løkke - æ bare gøre det på her - mens loop, har vi den betingelse

39
00:03:02,950 --> 00:03:19,760
lige her, mens en gør-mens, behøver du ikke have en tilstand, indtil vi komme herned.

40
00:03:19,760 --> 00:03:24,130
Og så, når dit program er fuldbyrdende, og det bliver til while-løkken,

41
00:03:24,130 --> 00:03:26,380
den straks kontrollerer, om denne tilstand er sand.

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

43
00:03:30,710 --> 00:03:34,390
Gør-while-løkke, som programmet udfører, det bliver til "gør."

44
00:03:34,390 --> 00:03:37,920
Der sker ikke noget på dette punkt, bare fortsætter fuldbyrdende.

45
00:03:37,920 --> 00:03:42,690
Så når det rammer ", mens", hvis betingelsen er sand, vil det loop tilbage og gøre det igen

46
00:03:42,690 --> 00:03:46,730
og igen og igen, indtil tilstanden er ikke sandt, og så bare falder igennem.

47
00:03:46,730 --> 00:03:50,600
Så, idet forskellen er, at det kan springe lige fra starten.

48
00:03:50,600 --> 00:03:56,770
Dette nødvendigvis udfører én gang og derefter kan udføre flere gange, hvis betingelsen er stadig sandt.

49
00:03:56,770 --> 00:04:03,720
Så mens løkken vil kun gøre det én gang, eller - mens loop - vi måske ikke behøver at gøre det på alle,

50
00:04:03,720 --> 00:04:07,900
da så snart vi kommer til det, hvis betingelsen er falsk vil vi bare hoppe direkte over det.

51
00:04:07,900 --> 00:04:11,770
Hvorimod do-while-løkke, vil vi udføre det én gang, nødvendigvis.

52
00:04:11,770 --> 00:04:14,560
Derefter, når vi kommer til den betingelse, vi kontrollere, om det er sandt eller falsk.

53
00:04:14,560 --> 00:04:19,790
Hvis det er sandt, vil vi gøre det igen, hvis det er falsk, vil vi bare fortsætte med at gå.

54
00:04:19,790 --> 00:04:24,680
Så hvornår er det sidstnævnte særligt nyttig?

55
00:04:24,680 --> 00:04:31,190
Så jeg kan sige, at i samtlige de 4 år, 3 år, uanset hvad,

56
00:04:31,190 --> 00:04:38,780
at jeg har været programmering, har jeg brugt dette, ligesom, under 10 gange.

57
00:04:38,780 --> 00:04:43,140
Og sandsynligvis 5 af dem er i CS50 når vi indfører do-while-løkker.

58
00:04:43,140 --> 00:04:47,510
Så når du brugt do-while-løkker?

59
00:04:47,510 --> 00:04:49,510
Hvornår er det - yeah?

60
00:04:49,510 --> 00:04:53,180
[Student] Når du forsøger at få bruger-input, eller noget, du vil kontrollere -

61
00:04:53,180 --> 00:04:59,700
Yeah. Så gør-while-løkker, bruger input er den store.

62
00:04:59,700 --> 00:05:03,160
Det er derfor på de første par problematiske sæt, når du ønsker at spørge brugeren, ligesom,

63
00:05:03,160 --> 00:05:08,520
"Giv mig en streng," du kan ikke fortsætte, indtil du får denne streng.

64
00:05:08,520 --> 00:05:12,980
Og så du, nødvendigvis, nødt til at spørge efter strengen mindst én gang.

65
00:05:12,980 --> 00:05:16,950
Men så hvis de besvarer noget dårligt, så er du nødt til at sløjfe tilbage og spørge igen.

66
00:05:16,950 --> 00:05:20,810
Men bortset fra bruger-input, det er meget sjældent, at jeg støder på en sag

67
00:05:20,810 --> 00:05:27,170
hvor jeg vil sløjfe "mindst én gang", men muligvis mere.

68
00:05:27,170 --> 00:05:33,370
Spørgsmål eller -? Har nogen brugt en gør-while-løkke andre steder?

69
00:05:33,370 --> 00:05:36,780
Okay. Så den næste er, "Hvad betyder sort identifikator

70
00:05:36,780 --> 00:05:43,310
angiver normalt hvis udsendt ved Klang? "

71
00:05:43,310 --> 00:05:47,380
Så hvad slags kode kunne jeg skrive for at få 'kaldenavn der?'

72
00:05:47,380 --> 00:05:49,550
[Student] At 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 køre dette - oh, jeg ikke klikke på det. Så her får vi - okay.

75
00:06:04,830 --> 00:06:07,100
"Brug af kaldenavn x."

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

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

78
00:06:13,910 --> 00:06:17,300
Så det kan ikke vide, det er faktisk en variabel og kan ikke vide, hvad 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 sort? Yeah.

81
00:06:26,060 --> 00:06:32,190
Så for at være klar med terminologi, erklæringen af ​​en variabel

82
00:06:32,190 --> 00:06:37,360
er, når du siger "INT x" eller "string y," hvad.

83
00:06:37,360 --> 00:06:41,910
Initialiseringen af ​​variablen, eller overdragelse af den variable,

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

85
00:06:44,510 --> 00:06:52,950
Så vi kan gøre dem i separate trin, int x, x = 2, og indtil - kan vi få en masse ting herinde -

86
00:06:52,950 --> 00:07:00,350
men indtil denne linje sker, x fortsat initialiseret, men det er blevet erklæret.

87
00:07:00,350 --> 00:07:06,760
Og så kan vi selvfølgelig gøre det i 1 linie, og nu er vi erklære og initialisering.

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

89
00:07:10,730 --> 00:07:18,390
Og endelig: "Hvorfor er det Cæsar Cipher ikke meget sikker?"

90
00:07:18,390 --> 00:07:23,830
Så det første, er der nogen ønsker at sige, hvad Cæsar Cipher er?

91
00:07:23,830 --> 00:07:28,100
[Student] Caesar Cipher bare er, at du kortlægger, du skifter hvert bogstav,

92
00:07:28,100 --> 00:07:34,420
et vist antal bogstaver går over, og flytte tilbage over, og det er ikke meget sikker, fordi

93
00:07:34,420 --> 00:07:42,260
Der er kun 26 mulige løsninger, og du bare nødt til at prøve hver 1 af dem, indtil du får det.

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

95
00:07:45,470 --> 00:07:51,600
The Caesar Cipher, det er - jeg mener, vil du beskæftige sig med det på de problemer, du -

96
00:07:51,600 --> 00:07:56,110
eller jeg gætte standardudgaven af ​​det problem sæt, der ikke er på hacker udgave.

97
00:07:56,110 --> 00:08:01,550
Så på den standard udgave til problemet sæt, får du en besked som: "Hello, world"

98
00:08:01,550 --> 00:08:08,410
og du også har et tal som 6, og du tager den besked, og hver individuel karakter,

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

100
00:08:11,310 --> 00:08:16,560
Så 'h' i hello ville blive h-i-j-k-l-m-n.

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

102
00:08:19,600 --> 00:08:23,530
Hvis vi har en, gerne, z eller noget, så vi wrap tilbage rundt til »en«.

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

104
00:08:29,280 --> 00:08:35,440
da der kun er 26 muligheder for hvor mange måder, du kan vikle et enkelt bogstav.

105
00:08:35,440 --> 00:08:42,919
Så du kan bare prøve alle 26 af dem, og formentlig i lang nok besked,

106
00:08:42,919 --> 00:08:46,860
kun 1 af disse potentielle 26 ting kommer til at være læselig,

107
00:08:46,860 --> 00:08:50,300
og den læselige man vil være den oprindelige meddelelse.

108
00:08:50,300 --> 00:08:56,240
Så det er ikke en meget god måde at kryptere noget som helst.

109
00:08:56,240 --> 00:08:59,070
Relateret til disse shorts, "Hvad er en funktion?"

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

111
00:09:03,370 --> 00:09:11,640
[Student] Det er ligesom et separat stykke kode, som du kan ringe til at gå igennem og derefter få returværdien af ​​hvad som helst.

112
00:09:11,640 --> 00:09:18,160
Yeah. Så jeg vil besvare det ved også at besvare den næste - eller gentag ved også bare besvare den næste.

113
00:09:18,160 --> 00:09:22,410
Du kan bruge funktionerne i stedet for bare at kopiere og indsætte kode igen og igen.

114
00:09:22,410 --> 00:09:27,200
Bare tage denne kode, læg det i en fuction, og så kunne du bare kalde funktionen

115
00:09:27,200 --> 00:09:29,870
hvor du har været kopiere og indsætte.

116
00:09:29,870 --> 00:09:33,350
Så funktioner er hensigtsmæssige.

117
00:09:33,350 --> 00:09:35,860
Så nu vil vi gøre reelle problemer.

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

119
00:09:46,490 --> 00:09:52,060
eller står der med små bogstaver? Det siger ikke alle små bogstaver.

120
00:09:52,060 --> 00:09:57,730
Så budskabet kan være hvad som helst, og - åh nej. Det gør.

121
00:09:57,730 --> 00:10:01,610
"For nemheds skyld kan du antage, at brugeren vil kun input små bogstaver og mellemrum."

122
00:10:01,610 --> 00:10:08,180
Så vi give det en besked med kun små bogstaver og så må vi skifte

123
00:10:08,180 --> 00:10:15,450
mellem kapital og små bogstaver - vi ændre strengen til at være store og små, skiftevis.

124
00:10:15,450 --> 00:10:22,920
Så før vi giver dig en anden til selv dykke ned i problemet,

125
00:10:22,920 --> 00:10:32,420
hvad er den første ting, vi skal gøre?

126
00:10:32,420 --> 00:10:36,900
Åh, hvad gjorde jeg bare klikke på? Åh, jeg lige har klikket på en e-mail her.

127
00:10:36,900 --> 00:10:42,870
Så det første vi skal gøre - jeg kigger på det forkerte?

128
00:10:42,870 --> 00:10:49,320
Er denne del af dette?

129
00:10:49,320 --> 00:10:51,320
Nej, det er stadig derinde, selv om.

130
00:10:51,320 --> 00:10:55,160
Okay, her stadig.

131
00:10:55,160 --> 00:11:03,160
Nu kan vi ikke påtage -? Ja. Her kan vi ikke antage, at det kun er små bogstaver og mellemrum.

132
00:11:03,160 --> 00:11:07,770
Så nu har vi at gøre med det faktum, at bogstaverne kan hvad vi vil have dem til at være.

133
00:11:07,770 --> 00:11:11,910
Og så den første ting, vi ønsker at gøre, er bare få beskeden.

134
00:11:11,910 --> 00:11:19,790
Vi skal bare brug for at få en streng, string s = GetString, okay.

135
00:11:19,790 --> 00:11:24,890
Nu er dette problem, der er et par måder at gøre det.

136
00:11:24,890 --> 00:11:29,840
Men vi vil ønsker at bruge bitvise operatører her.

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

138
00:11:35,280 --> 00:11:37,480
eller noget, behøver og ikke ved, hvad bitvise operatører er?

139
00:11:37,480 --> 00:11:41,710
Eller hvordan de relaterer til ASCII på nogen måde?

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

141
00:11:45,650 --> 00:11:49,560
Okay. Så jeg behøver ikke at gå over det grundlæggende i dem, men jeg vil forklare

142
00:11:49,560 --> 00:11:51,830
hvad vi vil ønsker at bruge her.

143
00:11:51,830 --> 00:11:59,680
Så 'A': Binær repræsentation af kapital A, antallet er 65 år.

144
00:11:59,680 --> 00:12:07,560
Jeg skal bare se på - 41 bliver 01.000.001.

145
00:12:07,560 --> 00:12:14,170
Så det burde være 65 i decimal, så dette er den binære repræsentation af den karakter kapital A.

146
00:12:14,170 --> 00:12:19,440
Nu den binære repræsentation af den karakter små bogstaver "a"

147
00:12:19,440 --> 00:12:33,350
vil være det samme, næsten. Er det - 6, ja. Det er rigtigt.

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å bemærke, at forskellen mellem A og »a« er denne enkelt bit.

150
00:12:43,940 --> 00:12:49,440
Og det sker for at være den 32 bit, den smule, der repræsenterer antallet 32.

151
00:12:49,440 --> 00:12:53,910
Og det giver mening, idet A er 65, »a« er 97.

152
00:12:53,910 --> 00:12:56,610
Forskellen mellem dem er 32 år.

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

154
00:13:03,770 --> 00:13:09,710
og bitvise ORing det med - det ligner en 1.

155
00:13:09,710 --> 00:13:20,900
Dette er en bitvise OR, med 00100000, og det vil give os 'en'.

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

157
00:13:26,850 --> 00:13:33,700
med 11, 0 på dette sted, 11111.

158
00:13:33,700 --> 00:13:43,840
Så dette vil så give os præcis, hvad 'a' var, men annullere denne individuelle bit,

159
00:13:43,840 --> 00:13:50,070
så vi har 01000001, jeg ved ikke, om jeg talte ret.

160
00:13:50,070 --> 00:13:56,750
Men denne teknik bitvis OR-ingsorgan at komme fra kapital til små bogstaver,

161
00:13:56,750 --> 00:14:02,080
og bitvis AND at komme fra små bogstaver til kapital er ikke eksklusiv til A.

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

163
00:14:06,510 --> 00:14:10,080
alle af dem er lige til at afvige fra denne enkelt bit.

164
00:14:10,080 --> 00:14:16,290
Og så kan du bruge denne til at skifte fra en lille bogstav til enhver stort bogstav og vice versa.

165
00:14:16,290 --> 00:14:26,670
Okay. Så en nem måde at komme fra dette - så i stedet for at skulle

166
00:14:26,670 --> 00:14:32,170
skrive ud, hvad 1011111 er - en nem måde at repræsentere dette nummer, og dette er ikke en

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

168
00:14:39,710 --> 00:14:42,520
Hvad ~ gør, er det ser på bit repræsentation.

169
00:14:42,520 --> 00:14:45,630
Lad os tage et vilkårligt antal.

170
00:14:45,630 --> 00:14:53,130
Dette er blot nogle binære tal, og hvad ~ er er det bare vender alle bits.

171
00:14:53,130 --> 00:15:00,630
Så det var en 1, nu et 0, er dette en 0, nu en 1, 010.100.

172
00:15:00,630 --> 00:15:08,320
Så det er alt ~ gør. Så 32 bliver nummeret - slippe af med det -

173
00:15:08,320 --> 00:15:23,320
så 32 vil være nummer 00.100.000, og så ~ af dette vil være

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

175
00:15:29,980 --> 00:15:35,600
Skal alle se det? Det er temmelig almindeligt, ligesom når du ønsker at finde ud af

176
00:15:35,600 --> 00:15:40,740
til senere ting, som vi måske ser, når vi ønsker at se, om -

177
00:15:40,740 --> 00:15:44,710
eller vi vil have det hele, hver eneste bit sæt bortset fra 1

178
00:15:44,710 --> 00:15:47,910
du har tendens til at gøre ~ af bit, som vi ikke ønsker indstillet.

179
00:15:47,910 --> 00:15:53,090
Så vi ønsker ikke, at 32 bit sæt, så vi ~ af 32.

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

181
00:15:57,790 --> 00:16:03,000
Okay, så det er fint, hvis du ikke er færdig, skal vi langsomt gå over sammen,

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

183
00:16:11,870 --> 00:16:20,790
Så vi har vores streng, og vi ønsker at sløjfe over hvert tegn i denne streng og gøre noget for det.

184
00:16:20,790 --> 00:16:26,710
Så hvordan gør vi sløjfe over en streng? Hvad skal vi bruge?

185
00:16:26,710 --> 00:16:30,980
Jeg har ikke tænkt mig at gøre det på her. Yeah.

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

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

188
00:16:47,030 --> 00:16:49,860
Så hvad jeg har gjort her, er ikke den bedste måde at gøre tingene på.

189
00:16:49,860 --> 00:16:51,860
Er der nogen vide, hvorfor?

190
00:16:51,860 --> 00:16:55,290
Fordi du tjekker sproget i strengen hver eneste gang.

191
00:16:55,290 --> 00:17:06,859
Så vi vil ønsker at flytte strlen, kunne jeg sige op her, int længde = strlen (s),

192
00:17:06,859 --> 00:17:11,900
og derefter skal jeg <længde, og i tilfælde af at du ikke har set det før,

193
00:17:11,900 --> 00:17:20,410
Jeg kunne også gøre int i = 0, længde = strlen (s).

194
00:17:20,410 --> 00:17:25,010
Og så dette er noget at foretrække, da jeg nu har begrænset rækkevidden

195
00:17:25,010 --> 00:17:29,150
af variabel længde til netop denne 'for' loop, i stedet for at erklære det før

196
00:17:29,150 --> 00:17:34,990
og at det altid eksisterer, og i tilfælde af at du ikke fange hvorfor det er dårligt,

197
00:17:34,990 --> 00:17:39,410
eller hvorfor den oprindelige var dårlig, det er - starter på for-løkken.

198
00:17:39,410 --> 00:17:43,380
Jeg tjekkede den betingelse. Er I <længden af ​​s?

199
00:17:43,380 --> 00:17:46,790
Så længden af ​​s, lad os arbejde med "hello" hele tiden.

200
00:17:46,790 --> 00:17:49,670
Så længde s, H-e-l-l-o. Længden er 5.

201
00:17:49,670 --> 00:17:57,580
Så i = 0, længde er 5, så jeg ikke <5, så sløjfen fortsætter.

202
00:17:57,580 --> 00:18:02,750
Så går vi igen. Vi tjekker tilstanden. Er I <længden af ​​hej?

203
00:18:02,750 --> 00:18:08,390
Så lad os se hvor lang hej. H-e-l-l-o. Det er 5, og jeg er ikke <5, så vi fortsætter igen.

204
00:18:08,390 --> 00:18:13,330
Så vi beregne, vi regner goddag, for hver iteration af løkken,

205
00:18:13,330 --> 00:18:17,380
selv troede det aldrig kommer til at ændre, det er altid vil være 5.

206
00:18:17,380 --> 00:18:22,530
Så vi skal bare huske 5 op foran, og nu alt er bedre.

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

208
00:18:24,990 --> 00:18:31,470
Hvad ønsker vi at gøre for hvert tegn i strengen?

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

210
00:18:38,510 --> 00:18:47,000
Yeah. Så hvis karakter er ikke-alfabetisk, så vi bare ønsker at springe over den.

211
00:18:47,000 --> 00:18:52,300
Fordi vi kun bekymrer sig om bogstaver i alfabetet, og vi kan ikke udnytte et nummer.

212
00:18:52,300 --> 00:19:10,850
Så hvordan kan vi gøre det? Så vores tilstand, hvis vi ønsker noget så - tjek om det er alfabetisk.

213
00:19:10,850 --> 00:19:14,060
Så hvordan kan vi kontrollere det?

214
00:19:14,060 --> 00:19:18,720
[Student] Du kan bare bruge funktionen er alpha.

215
00:19:18,720 --> 00:19:23,160
Er det inkluderet i en af ​​disse, eller nogen omfatte lignende, char.h eller noget?

216
00:19:23,160 --> 00:19:32,710
Lad os ikke bruge er alpha-funktionen, og brug den eksplicit - så vi har s [i],

217
00:19:32,710 --> 00:19:40,460
der er den ottende karakter s, så husk at en streng er en række tegn,

218
00:19:40,460 --> 00:19:43,180
så den ottende karakter s.

219
00:19:43,180 --> 00:19:49,280
Nu, hvis det er et stort bogstav, vi ved, det skal være i et bestemt område.

220
00:19:49,280 --> 00:19:54,370
Og hvad er det interval?

221
00:19:54,370 --> 00:20:07,860
Yeah. Så hvis s [i] er ≥ 65, og s [i] er ≤ 90, hvad skal jeg gøre i stedet?

222
00:20:07,860 --> 00:20:18,470
Yeah. Så du bør absolut aldrig selv nødt til at kende ASCII værdier noget nogensinde.

223
00:20:18,470 --> 00:20:25,640
Aldrig tænke på tallene 65, 90, 97 og 102, eller hvad det er.

224
00:20:25,640 --> 00:20:32,470
Du behøver ikke - 112 -? Du behøver ikke at kende dem overhovedet. Det er også forkert.

225
00:20:32,470 --> 00:20:41,940
Brug kun de enkelt-citationstegn, ét tilbud konstanter. Så 'A' og mindre end 90 er 'Z.'

226
00:20:41,940 --> 00:20:47,930
Og det er væsentligt bedre - jeg ville ikke vide fra toppen af ​​mit hoved, at Z er 90.

227
00:20:47,930 --> 00:20:52,690
Jeg kender fra toppen af ​​mit hoved, at 'Z' er hovedstad Z.

228
00:20:52,690 --> 00:21:02,100
Så så længe det er i området for kapital A til kapital Z, eller vi kan tjekke for små bogstaver,

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

230
00:21:17,010 --> 00:21:19,010
Så det er vores betingelse.

231
00:21:19,010 --> 00:21:22,520
Stilen for hvor til at sætte disse ting varierer.

232
00:21:22,520 --> 00:21:29,520
Jeg vil gøre det på denne måde.

233
00:21:29,520 --> 00:21:31,520
Nu, hvad vi ønsker at gøre?

234
00:21:31,520 --> 00:21:39,530
Vi ved, at dette brev er et tegn, et bogstav.

235
00:21:39,530 --> 00:21:46,270
Så vi er nødt til at veksle mellem, om det nu skulle være et stort bogstav eller et lille bogstav.

236
00:21:46,270 --> 00:21:48,820
Hvordan kan vi holde styr på hvilken en vi ønsker 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 lad mig tjekke.

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

240
00:22:04,910 --> 00:22:11,780
Bortset varsel at, ligesom - er dette tilfældet? Yeah.

241
00:22:11,780 --> 00:22:18,270
Det er hver anden, men vi kan ikke modul 2 af i, eller jeg mod 2, da

242
00:22:18,270 --> 00:22:22,950
bemærke, at E er kapital og »a« er små? Men der er en plads, der adskiller dem?

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

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

245
00:22:29,150 --> 00:22:34,690
Yeah. Så vi vil bare holde en optælling.

246
00:22:34,690 --> 00:22:38,730
Vi kunne også gøre det i her, hvis vi ønskede, det kan få en lidt uhåndterlig

247
00:22:38,730 --> 00:22:41,300
i for-løkken erklæringer, vil jeg sætte det op her.

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

249
00:22:48,840 --> 00:22:54,070
Og så nu, jeg skal tælle, hvor mange alfabetiske tegn, vi har haft.

250
00:22:54,070 --> 00:22:59,550
Så vi uundgåeligt kommer til at tælle + +, da vi fandt en anden bogstav.

251
00:22:59,550 --> 00:23:09,130
Men, så nu du siger, hvis tæller mod 2.

252
00:23:09,130 --> 00:23:12,590
Så hvad nu hvis tæller mod 2? Oh. Jeg vil gøre == 0 for nu.

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

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

255
00:23:27,830 --> 00:23:32,750
Så vi vil have det til at ende store bogstaver.

256
00:23:32,750 --> 00:23:37,520
Der er 2 sager, store og små bogstaver er de 2 sager.

257
00:23:37,520 --> 00:23:40,990
Så hvis vi er med små bogstaver er vi nødt til at gøre det store bogstaver.

258
00:23:40,990 --> 00:23:43,710
Hvis det er stort at vi ikke behøver at gøre noget.

259
00:23:43,710 --> 00:23:50,760
Men, er der en måde - Burde er vendt -

260
00:23:50,760 --> 00:23:54,800
at vi ikke engang behøver at kontrollere, om det er store eller små bogstaver?

261
00:23:54,800 --> 00:24:02,240
Hvad kan vi gøre for altid sikre, at vi altid ender hos store bogstaver?

262
00:24:02,240 --> 00:24:07,830
Så mærke til, hvad vi gjorde for små 'a', hvad nu hvis vi gjorde dette samme nøjagtige ting til store bogstaver A?

263
00:24:07,830 --> 00:24:11,900
Har store bogstaver En ændring, eller gør værdien forandring?

264
00:24:11,900 --> 00:24:23,100
Yeah. Så enhver stort bogstav bitvis ANDed med ~ 32 vil være den samme store bogstaver

265
00:24:23,100 --> 00:24:29,220
fordi for enhver store bogstaver den 32. bit ikke er indstillet.

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

267
00:24:40,920 --> 00:24:46,890
Så hvis det var små, er det nu store bogstaver, hvis det var store bogstaver, er det stadig store bogstaver, og det er det.

268
00:24:46,890 --> 00:24:54,290
Jeg sagde dette i supersection: Du kan bruge 32, hvis du vil, men jeg er tilbøjelig til at foretrække at gøre 'a' - A,

269
00:24:54,290 --> 00:25:01,150
i stedet for bare 32, fordi kan være enhver anden bit.

270
00:25:01,150 --> 00:25:03,610
Efter den 32 bit, kan det være en af ​​disse, eller vi ville ikke have nok

271
00:25:03,610 --> 00:25:05,840
numre til at repræsentere alle tegnene.

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

273
00:25:09,110 --> 00:25:13,990
Enhver af disse bits kunne være lidt, der skelner mellem store og små bogstaver.

274
00:25:13,990 --> 00:25:18,350
Jeg bør ikke være nødvendigt at vide, at det er den 32 bit.

275
00:25:18,350 --> 00:25:27,130
Jeg kan bruge denne 'a' - A for at få den smule, der varierer mellem de to

276
00:25:27,130 --> 00:25:33,000
uden at skulle stole på det magiske tal, der er 32 år.

277
00:25:33,000 --> 00:25:38,770
Og så nu, ellers tæller var ulige, og så hvad jeg ønsker at gøre?

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

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

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

281
00:25:49,850 --> 00:25:55,690
Så nu hvis jeg ønsker at - jeg vil være sikker på den karakter er nu små bogstaver,

282
00:25:55,690 --> 00:26:04,140
og så jeg kan eller henholdsvis 32 og 32 betyder 'et' - A.

283
00:26:04,140 --> 00:26:06,510
Men læg mærke til, af samme begrundelse som den forrige, at hvis

284
00:26:06,510 --> 00:26:11,670
Brevet var allerede små bogstaver, så ORing med 32 bare holder det små bogstaver.

285
00:26:11,670 --> 00:26:16,220
Det har ikke ændret den oprindelige karakter.

286
00:26:16,220 --> 00:26:19,910
Men nu er jeg ikke behøver at undgå at sige, "Hvis det er små, bare glemme alt om det,

287
00:26:19,910 --> 00:26:23,650
hvis det er store bogstaver, derefter ændre det. "

288
00:26:23,650 --> 00:26:26,900
Det er meget mere bekvemt at gøre dette.

289
00:26:26,900 --> 00:26:33,190
[Student] ville denne strategi for at trække det store fra det lille arbejde, hvis det ikke var 32?

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

291
00:26:35,330 --> 00:26:41,840
Så skal du vide, at forskellen mellem de 2 er -? >> 1 bit.

292
00:26:41,840 --> 00:26:49,840
Det kunne være mere end 1 bit, så længe alle bittene under denne position er de samme.

293
00:26:49,840 --> 00:26:58,500
Så vi har brug for mindst 26 tegn - eller, der er 26 tegn.

294
00:26:58,500 --> 00:27:04,590
Så vi har brug for mindst 26 numre til at repræsentere forskellen -

295
00:27:04,590 --> 00:27:07,650
Forskellen mellem A og 'a' skal være mindst 26,

296
00:27:07,650 --> 00:27:10,760
ellers ville vi ikke have repræsenteret hele kapitalen numre.

297
00:27:10,760 --> 00:27:18,630
Det betyder, at A, hvis vi begynder med 1, det vil bruge alle disse bits,

298
00:27:18,630 --> 00:27:23,900
alle disse første 5 bit, til at repræsentere alt gennem Z.

299
00:27:23,900 --> 00:27:32,170
Det er derfor, den næste bit, eller denne bit, den næste bit er den, der har valgt at skelne mellem A og 'a'.

300
00:27:32,170 --> 00:27:40,930
Det er også derfor, i ASCII-tabellen er der 5 symboler adskiller store bogstaver fra små bogstaver.

301
00:27:40,930 --> 00:27:49,050
Da det er de symboler, de ekstra 5, som bringer op 32 er forskellen mellem dem.

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

303
00:27:51,840 --> 00:27:57,280
Ja. Men ASCII - forskellen kan også være begge disse bits.

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

305
00:28:12,040 --> 00:28:18,100
Men hvis det var det, så kunne vi stadig bruge 'a' - A.

306
00:28:18,100 --> 00:28:22,650
Det er bare nu forskellen mellem A og »a« er stadig disse 2 bit.

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 ville stadig være 2 bit, hver enkelt tegn, gerne, Z og z, K og k,

309
00:28:40,160 --> 00:28:45,160
de ville stadig have nøjagtig de samme bits, der bortset fra de 2 bit.

310
00:28:45,160 --> 00:28:48,870
Så så længe det er altid sandt, uanset om vi bruger ASCII eller et andet system,

311
00:28:48,870 --> 00:28:53,050
så længe der er kun et bestemt antal bits, der er forskellige for hver karakter,

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 blev oprettet, fordi det er den første, vi eventuelt kunne bruge. >> Cool.

314
00:29:06,110 --> 00:29:14,520
Jeg har en tendens til at foretrække, hvis du ikke har set, hvis blokken er kun en enkelt linje,

315
00:29:14,520 --> 00:29:24,280
du kan slippe af med de krøllede parenteser, så jeg har tendens til at foretrække at gøre dette.

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

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

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

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

320
00:29:51,490 --> 00:30:00,900
Så husk at - jeg vil ikke skrive det - alle ikke-nul værdi er sandt, og 0 er falsk.

321
00:30:00,900 --> 00:30:07,880
Så "hvis count mod 2 == 0" er det samme som at sige "hvis ikke tælle mod 2".

322
00:30:07,880 --> 00:30:11,580
Jeg ville sandsynligvis har netop vendt linjerne og sagde, "hvis count mod 2,

323
00:30:11,580 --> 00:30:15,350
gør det eller 1, ellers AND 1, "så jeg ikke behøvede den" ikke ".

324
00:30:15,350 --> 00:30:18,650
Men det virker lige så godt.

325
00:30:18,650 --> 00:30:25,660
Og hvad kan jeg gøre her?

326
00:30:25,660 --> 00:30:29,060
Du kan kombinere dem med ternære hvis du ønskede, men så det ville bare gøre tingene Messier

327
00:30:29,060 --> 00:30:33,770
og sandsynligvis sværere at læse, så vi vil ikke gøre det.

328
00:30:33,770 --> 00:30:37,330
Nogen der har nogen andre forslag?

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

330
00:30:41,580 --> 00:30:51,070
Så slippe af med disse tomme linjer, nu vi vil printe f,% s er det år for strygere,

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

332
00:30:56,620 --> 00:30:59,330
Lad os nu køre den. Har jeg gjort noget forkert?

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

334
00:31:03,200 --> 00:31:07,840
Okay. Nu vil vi køre den. Det vil sandsynligvis yell på mig.

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 gode ved Dunk er det fortæller dig, hvad det er i,

337
00:31:14,290 --> 00:31:19,140
i stedet for GCC, som bare siger: "Hey, du glemte noget, jeg ved ikke hvad det var."

338
00:31:19,140 --> 00:31:29,220
Men det vil fortælle mig, "Du skal indbefatte string.h."

339
00:31:29,220 --> 00:31:32,130
Så jeg ikke bede om noget, så det er ikke at sige noget.

340
00:31:32,130 --> 00:31:42,540
Men vi vil gøre deres eksempel, "Thanks 4 the add".

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

342
00:31:47,880 --> 00:31:52,370
Så vender tilbage til din primære, jeg næsten aldrig gør det.

343
00:31:52,370 --> 00:31:57,110
Det er valgfrit. Og main er den eneste funktion, som det er valgfrit.

344
00:31:57,110 --> 00:32:07,140
Hvis du ikke returnerer noget fra vigtigste, er det antaget, at du mente at returnere 0.

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

346
00:32:13,070 --> 00:32:20,980
Okay. Så nu det andet problem.

347
00:32:20,980 --> 00:32:24,810
"Genopkald fra uge 2 andet foredrag at bytte 2 variabler 'værdier ved at passere

348
00:32:24,810 --> 00:32:30,780
disse 2 variabler til en funktion (selvom kaldet swap) ikke ligefrem virker, i hvert fald ikke uden 'pointers'. "

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

350
00:32:37,020 --> 00:32:40,070
Vi ønsker at bytte 2 variabler, og vi bruger ikke en funktion til at gøre det.

351
00:32:40,070 --> 00:32:43,410
Vi vil stadig gøre det i main ligesom det siger.

352
00:32:43,410 --> 00:32:48,360
Men at bruge disse 2 variabler, ønsker vi ikke at bruge en midlertidig variabel.

353
00:32:48,360 --> 00:32:50,770
Der er 2 måder at gøre dette.

354
00:32:50,770 --> 00:32:56,310
Du kan gøre det ved hjælp af dine traditionelle binære operatorer.

355
00:32:56,310 --> 00:33:00,180
Så er der nogen kender en hurtig og beskidt måde at gøre det?

356
00:33:00,180 --> 00:33:07,650
Det kan faktisk tage et minut at tænke på. Hvis jeg har -

357
00:33:07,650 --> 00:33:12,130
Jeg vil sætte problemet op ligesom de spørger. Så hvis jeg har 2 variabler, A, der er lige et heltal

358
00:33:12,130 --> 00:33:17,800
at de giver mig, og sum variabel B, som er en anden heltal, jeg får.

359
00:33:17,800 --> 00:33:22,700
Så hvis jeg har disse 2 variabler, nu vil jeg til at bytte dem.

360
00:33:22,700 --> 00:33:31,550
Den traditionelle, ved hjælp af din almindelige binære operatorer, jeg mener, ligesom +, -, ÷.

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

362
00:33:36,630 --> 00:33:39,600
Så ved hjælp -, +, ÷, og alle dem.

363
00:33:39,600 --> 00:33:52,980
Vi kunne bytte ved at gøre noget i retning af en = a + b, og b = a - b, a = a - b.

364
00:33:52,980 --> 00:34:04,260
Så tilregnelighed kontrollere, og så vil vi se, hvorfor det virker.

365
00:34:04,260 --> 00:34:13,320
Lad os sige a = 7, b = 3, så a + b vil være 10.

366
00:34:13,320 --> 00:34:18,820
Så vi sætter nu a = 10, og så gør vi b = a - b.

367
00:34:18,820 --> 00:34:30,250
Så vi laver b = a - b, som vil være 7, og b = a - b igen,

368
00:34:30,250 --> 00:34:38,650
eller en = a - b. Som vil være 10 - 7, som er 3.

369
00:34:38,650 --> 00:34:44,850
Så nu, rigtigt, »a« var 7, b var 3, og nu b er 7 og »a« er 3.

370
00:34:44,850 --> 00:34:48,679
Så den slags giver mening; 'a' er en kombination af de 2 numre.

371
00:34:48,679 --> 00:34:53,000
På dette tidspunkt, »a« er kombinationen, og så er vi fratrække den oprindelige b,

372
00:34:53,000 --> 00:34:56,860
og så er vi fratrække, hvad der var den oprindelige 'en'.

373
00:34:56,860 --> 00:35:01,150
Men det virker ikke for alle numre.

374
00:35:01,150 --> 00:35:08,880
For at se denne, lad os overveje et system, så vi normalt tænker på heltal som 32 bit.

375
00:35:08,880 --> 00:35:13,050
Lad os arbejde på noget, der er kun ligesom 4 bit.

376
00:35:13,050 --> 00:35:15,450
Forhåbentlig kommer jeg op med et godt eksempel lige nu.

377
00:35:15,450 --> 00:35:18,680
Så jeg ved, det vil være let.

378
00:35:18,680 --> 00:35:26,720
Lad os sige vores 2 tal er 1111, og 1111, så vi er i binær lige nu.

379
00:35:26,720 --> 00:35:34,630
I faktiske decimaler, hvis du ønsker at tænke på det på den måde, en = 15 og b = 15.

380
00:35:34,630 --> 00:35:37,630
Og så forventer vi, efter at vi bytte dem - de behøver ikke engang at være de samme tal,

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

382
00:35:41,140 --> 00:35:47,100
Lad os gøre dem ikke de samme numre. Lad os gøre 1111 og 0001.

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

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

385
00:35:57,670 --> 00:36:01,780
Så vores første skridt er en = a + b.

386
00:36:01,780 --> 00:36:08,770
Vores numre er kun 4 bit brede, så 'en', som er 1111, + b, som er 0001,

387
00:36:08,770 --> 00:36:16,780
kommer til at ende med at blive 10000, men vi har kun 4 bit.

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

389
00:36:22,540 --> 00:36:34,080
Og nu ønsker vi at sætte b = a - b - faktisk, det virker stadig perfekt.

390
00:36:34,080 --> 00:36:39,630
a = a - b - lad os se om det virker perfekt.

391
00:36:39,630 --> 00:36:53,720
Så b = 0 - 1, hvilket stadig ville være 15, og derefter en = a - b, hvilket ville være 1.

392
00:36:53,720 --> 00:36:56,210
Måske dette virker.

393
00:36:56,210 --> 00:36:59,020
Jeg føler som om der er en grund til det ikke virker ved brug af almindeligt.

394
00:36:59,020 --> 00:37:06,400
Okay, så arbejder ud fra den antagelse, at det ikke virker med regelmæssige binære operationer,

395
00:37:06,400 --> 00:37:15,040
og jeg vil kigge efter - jeg vil Google for at se, om det er sandt.

396
00:37:15,040 --> 00:37:23,490
Så vi ønsker at gøre det ved hjælp af bitvise operatører, og clue her er XOR.

397
00:37:23,490 --> 00:37:28,780
Så indfører XOR (^), hvis du ikke har set det endnu.

398
00:37:28,780 --> 00:37:34,610
Det er, igen, en bitvis operatør, så det virker lidt efter lidt, og det er -

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

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

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

402
00:37:47,640 --> 00:37:56,180
Så det er ligesom OR. Hvis en af ​​de bits er sande, det er 1, men i modsætning til OR, kan det ikke være begge bits, der er sande.

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

404
00:37:59,320 --> 00:38:02,250
Så vi vil ønske at bruge XOR her.

405
00:38:02,250 --> 00:38:09,960
Tænk over det et øjeblik, jeg har tænkt mig at Google.

406
00:38:09,960 --> 00:38:16,230
Nå, kan du ikke læse det, jeg er i øjeblikket på XOR swap algoritme side.

407
00:38:16,230 --> 00:38:21,340
Forhåbentlig vil dette forklare, hvorfor jeg kan-ikke -

408
00:38:21,340 --> 00:38:34,190
Det er netop den algoritme, vi lige har gjort.

409
00:38:34,190 --> 00:38:37,330
Jeg kan stadig ikke se hvorfor - jeg må have lige hentet et dårligt eksempel,

410
00:38:37,330 --> 00:38:44,940
men dette tilfælde, hvor 'a' tilfældigvis blive 0, efter at komme til 5 bits, så nu »a« er 0,

411
00:38:44,940 --> 00:38:48,730
det er, hvad der kaldes "heltalsoverløb".

412
00:38:48,730 --> 00:38:54,370
Ifølge Wikipedia, I modsætning til XOR swap ", denne variation kræver, at den bruger nogle metoder

413
00:38:54,370 --> 00:38:59,780
at sikre, at x + y ikke forårsager et heltalsoverløb. "

414
00:38:59,780 --> 00:39:08,350
Så det har dog problemer, og dette var heltalsoverløb, men jeg gjorde noget forkert.

415
00:39:08,350 --> 00:39:10,520
Jeg er ikke sikker. Jeg vil prøve at komme op med en anden.

416
00:39:10,520 --> 00:39:13,640
[Student] Tja, er ikke heltalsoverløb når du forsøger at sætte et nummer i der

417
00:39:13,640 --> 00:39:16,640
større end den mængde bits du har tildelt?

418
00:39:16,640 --> 00:39:23,730
Yeah. Vi har 4 bits. That's - vi havde 4 bits, vi derefter forsøge at lægge 1 til det, så vi ender med 5 bits.

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

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

421
00:39:28,970 --> 00:39:33,010
[Student] Betyder det smider du en fejl, eller er det - ville det kaste en fejl?

422
00:39:33,010 --> 00:39:40,720
Nej Så der er ingen fejl. Når du kommer til forsamlingen niveau, en speciel bit

423
00:39:40,720 --> 00:39:47,020
et eller andet sted er indstillet, at sagde, at der var et overløb, men i C du slags bare ikke beskæftige sig med det.

424
00:39:47,020 --> 00:39:55,160
Du kan faktisk ikke beskæftige sig med det, medmindre du bruge specielle monteringsvejledning i C.

425
00:39:55,160 --> 00:39:58,110
Lad os tænke over XOR swap.

426
00:39:58,110 --> 00:40:02,220
Og jeg tror, ​​at Wikipedia-artiklen kunne have også sagt, at -

427
00:40:02,220 --> 00:40:07,310
Så det også opdraget modulær aritmetik, så jeg gætte, jeg var i teorien gør modulær aritmetik

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

429
00:40:11,160 --> 00:40:15,410
Så det kan faktisk - på en almindelig processor, der gør 0 til 1 = 15.

430
00:40:15,410 --> 00:40:20,430
Da vi ender på 0, vi trækker 1, så så er det bare ombrydes tilbage rundt til 1111.

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

432
00:40:28,930 --> 00:40:34,030
Men der er nogle processorer, der ikke gør det, og så det ville ikke være fint i disse specifikke dem.

433
00:40:34,030 --> 00:40:39,880
XOR swap vil arbejde på en processor. Okay.

434
00:40:39,880 --> 00:40:42,280
Ideen er, at det er meningen at være den samme, selv om.

435
00:40:42,280 --> 00:40:50,120
Hvor vi bruger XOR en eller anden måde få information om begge i 1 af de variabler,

436
00:40:50,120 --> 00:40:54,120
og træk derefter oplysninger om de enkelte variabler igen.

437
00:40:54,120 --> 00:41:04,330
Så er der nogen har 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 bør arbejde, og også, XOR er kommutativ.

440
00:41:22,220 --> 00:41:27,620
Uanset hvilken rækkefølge disse 2 numre tilfældigvis i op her,

441
00:41:27,620 --> 00:41:30,100
dette resultat vil 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 skrives som en ^ = b, b ^ = a, a ^ = b igen.

444
00:41:51,860 --> 00:42:00,200
Så det er rigtigt, og at se, hvorfor det virker, tænk på de bits.

445
00:42:00,200 --> 00:42:10,400
Ved hjælp af en smallish tal, lad os sige 11001, og 01.100.

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

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

448
00:42:15,540 --> 00:42:22,380
Vi vil være fastsættelse 'a' = til XOR af disse 2 ting.

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

450
00:42:32,920 --> 00:42:37,380
Så 'en', hvis man ser på det decimaltal, går det at være -

451
00:42:37,380 --> 00:42:41,160
du kommer ikke til at se meget af et forhold mellem den oprindelige »a« og den nye »a«

452
00:42:41,160 --> 00:42:45,600
men ser man på de bits, »a« er nu ligesom en maske af oplysningerne

453
00:42:45,600 --> 00:42:49,970
af både den oprindelige »a« og den oprindelige b.

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

455
00:42:57,930 --> 00:43:08,910
Og hvis vi tager den oprindelige 'a' ^ den nye 'et', ser vi ender vi på den oprindelige b.

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

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

458
00:43:27,910 --> 00:43:37,010
Der er - en anden måde at se dette er noget XOR selv er altid 0.

459
00:43:37,010 --> 00:43:45,020
Så 1101 ^ 1101, er alle delene vil være den samme.

460
00:43:45,020 --> 00:43:47,920
Så der er aldrig kommer til at være et tilfælde, hvor 1 er et 0 og den anden er 1.

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

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

463
00:43:57,240 --> 00:44:03,680
(B ^ b) vil være 0, a ^ 0 er bare at være 'a', da alle bits er 0.

464
00:44:03,680 --> 00:44:08,050
Så de eneste, der kommer til at være, hvor »a« var oprindelig en 1 - havde dem.

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

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

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

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

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

470
00:44:31,540 --> 00:44:37,120
Så »a« er nu en kombination af 'a' og b sammen.

471
00:44:37,120 --> 00:44:49,660
Ved hjælp af vores nye combo 'a' vi sige b = combo 'a' ^ den oprindelige b, får vi den oprindelige 'en'.

472
00:44:49,660 --> 00:45:05,170
Og nu en = combo 'a' ^ den nye b, som var den oprindelige - eller som nu, hvad der var 'a' eller b..

473
00:45:05,170 --> 00:45:13,620
Det er denne sag hernede. Dette er = b, gamle b.

474
00:45:13,620 --> 00:45:16,550
Så nu er alt tilbage i den byttet rækkefølge.

475
00:45:16,550 --> 00:45:22,960
Hvis vi faktisk set på de bits, b = a ^ b, vil XOR disse 2,

476
00:45:22,960 --> 00:45:33,920
og svaret vil være det, og derefter en = a ^ b er XORing disse 2 og svaret er det.

477
00:45:33,920 --> 00:45:41,090
Spørgsmål? Okay. Så den sidste er noget betydeligt vanskeligere.

478
00:45:41,090 --> 00:45:43,180
[Student] Jeg tror, ​​han har et spørgsmål om det. >> Åh, undskyld.

479
00:45:43,180 --> 00:45:49,380
[Student] Hvad er faktisk hurtigere? Hvis du bruger denne XOR, eller er det, hvis du erklærer en ny variabel?

480
00:45:49,380 --> 00:45:55,190
Så hvad er faktisk hurtigere, om en ny variabel eller bruge XOR at bytte?

481
00:45:55,190 --> 00:45:59,600
Svaret er, efter al sandsynlighed, en midlertidig variabel.

482
00:45:59,600 --> 00:46:05,780
Og det er fordi, når den er kompileret ned - så på samlingen niveau,

483
00:46:05,780 --> 00:46:12,320
Der er ikke sådan noget som lokale variabler eller midlertidige variable eller nogen af ​​disse ting.

484
00:46:12,320 --> 00:46:16,060
De er ligesom - der er hukommelse, og der er registre.

485
00:46:16,060 --> 00:46:20,920
Registre er hvor tingene aktivt sker.

486
00:46:20,920 --> 00:46:24,750
Du behøver ikke tilføje 2 ting i hukommelsen, du tilføjer 2 ting i registre.

487
00:46:24,750 --> 00:46:28,160
Og du sætter tingene fra hukommelsen i registre for derefter at tilføje dem,

488
00:46:28,160 --> 00:46:33,180
og så skal du måske sætte dem tilbage i hukommelsen, men alle handlingen sker i registre.

489
00:46:33,180 --> 00:46:38,750
Så når du bruger den midlertidige variable tilgang, som regel, hvad der sker, er

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

491
00:46:42,810 --> 00:46:46,570
Og så fra dette punkt på, efter du har byttet dem,

492
00:46:46,570 --> 00:46:51,540
det vil bare begynde at bruge den anden register.

493
00:46:51,540 --> 00:46:56,510
Overalt du havde brugt b, vil det bare bruge registret, som allerede var lagring 'a'.

494
00:46:56,510 --> 00:47:02,180
Så det behøver ikke at gøre noget til rent faktisk at gøre ombytningen. Ja?

495
00:47:02,180 --> 00:47:05,690
[Student] Men det tager også mere hukommelse, right?

496
00:47:05,690 --> 00:47:10,280
Det vil kun tage mere hukommelse, hvis det er nødvendigt at gemme denne midlertidige variabel.

497
00:47:10,280 --> 00:47:14,830
Ligesom hvis du senere bruge det midlertidige variabel igen et eller andet sted,

498
00:47:14,830 --> 00:47:18,920
så - eller du tildele noget til den midlertidige variabel.

499
00:47:18,920 --> 00:47:24,630
Så hvis du på noget tidspunkt «a, 'b i temp har forskellige værdier eller noget,

500
00:47:24,630 --> 00:47:30,680
så det kommer til at have forskellige steder i hukommelsen, men det er rigtigt,

501
00:47:30,680 --> 00:47:34,800
Der er mange lokale variabler, som kun vil findes i registrene.

502
00:47:34,800 --> 00:47:44,370
I så fald, er det aldrig sat i hukommelsen, og så du aldrig spilder hukommelse.

503
00:47:44,370 --> 00:47:58,620
Okay. Sidste spørgsmål er en smule mere.

504
00:47:58,620 --> 00:48:04,850
Så her i CS50 apparat er der en ordbog.

505
00:48:04,850 --> 00:48:12,390
Og grunden til dette er, fordi [? B66] er en stavekontrol, hvor du vil skrive

506
00:48:12,390 --> 00:48:15,780
bruger hash tabeller eller forsøger eller nogle datastrukturen.

507
00:48:15,780 --> 00:48:22,660
Du kommer til at skrive en stavekontrol, og du skal bruge denne ordbog til at gøre det.

508
00:48:22,660 --> 00:48:28,280
Men for dette problem, er vi bare at kigge op for at se om et enkelt ord findes i ordbogen.

509
00:48:28,280 --> 00:48:31,250
Så i stedet for at gemme hele ordbogen i nogle datastruktur

510
00:48:31,250 --> 00:48:35,180
og derefter kigger over et helt dokument for at se om noget er stavet forkert,

511
00:48:35,180 --> 00:48:38,490
Vi ønsker blot at finde 1 ord. Så vi kan bare scanne hele ordbogen

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

513
00:48:44,300 --> 00:48:52,150
Hvis vi scanner over hele ordbog og kan se ordet, så vi er gode, vi fandt det.

514
00:48:52,150 --> 00:48:56,580
Der står her, at vi ønsker at begynde at kigge på C sagsakter håndtering af funktion,

515
00:48:56,580 --> 00:48:59,930
da vi ønsker at læse i ordbogen,

516
00:48:59,930 --> 00:49:07,680
men jeg vil give tippet her, hvilke funktioner, du bør tænke på.

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

518
00:49:11,510 --> 00:49:20,490
Så de vigtigste, du ønsker at se på, er f åbne og derefter, uundgåeligt, f lukket,

519
00:49:20,490 --> 00:49:26,540
som vil gå i slutningen af ​​dit program, og f scan f..

520
00:49:26,540 --> 00:49:31,060
Du kan også bruge f læse, men du sandsynligvis ikke ønsker at

521
00:49:31,060 --> 00:49:34,200
fordi det - du ikke ender med at skulle det.

522
00:49:34,200 --> 00:49:41,880
F scan f er hvad du skal bruge til at scanne over ordbogen.

523
00:49:41,880 --> 00:49:46,370
Og så behøver du ikke at kode op løsningen, bare prøve og lignende pseudo-kode på din måde

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

525
00:50:05,200 --> 00:50:14,110
Og faktisk, da jeg allerede har givet dig disse, hvis du går ind i enhver terminal eller opvaskemaskinens shell,

526
00:50:14,110 --> 00:50:18,250
Jeg vil - jeg plejer - hvis du ikke har set endnu, jeg ved ikke, hvis du gjorde i klassen,

527
00:50:18,250 --> 00:50:23,490
men mennesket, så manden sider, er ganske nyttigt for at kigge på stort set enhver funktion.

528
00:50:23,490 --> 00:50:27,330
Så jeg kan gøre, ligesom, man f, scan f..

529
00:50:27,330 --> 00:50:32,300
Dette er nu den info om scanningen f familie af funktioner.

530
00:50:32,300 --> 00:50:37,070
Jeg kunne også gøre mennesket f, åbne, og det vil give mig nærmere oplysninger om denne.

531
00:50:37,070 --> 00:50:40,750
Så hvis du ved hvad funktion, du bruger, eller du læser koden

532
00:50:40,750 --> 00:50:43,000
og du kan se nogle funktion, og du er ligesom, "Hvad betyder dette?"

533
00:50:43,000 --> 00:50:45,280
Bare mand, funktion navn.

534
00:50:45,280 --> 00:50:47,340
Der er et par af underlige eksempler, hvor du måske nødt til at sige

535
00:50:47,340 --> 00:50:51,620
gerne. mand 2, at funktionen navn, eller menneskeskabte 3, at funktionsnavn,

536
00:50:51,620 --> 00:50:58,230
men du behøver kun at gøre det, hvis mennesket funktionsnavn ikke sker at arbejde første gang.

537
00:50:58,230 --> 00:51:03,010
[Student] Så jeg læser den mand side for åben, men jeg er stadig forvirret om, hvordan man bruger det, og programmet.

538
00:51:03,010 --> 00:51:06,170
Okay. En masse af man-siderne er mindre end nyttige.

539
00:51:06,170 --> 00:51:08,470
De er mere nyttigt, hvis du allerede ved, hvad de gør

540
00:51:08,470 --> 00:51:12,670
og så er du bare nødt til at huske rækkefølgen af ​​de argumenter eller noget.

541
00:51:12,670 --> 00:51:17,640
Eller de kan give dig et generelt overblik, men nogle af dem er meget overvældende.

542
00:51:17,640 --> 00:51:22,220
Ligesom f scan f,. Også Det giver dig de oplysninger om alle disse funktioner,

543
00:51:22,220 --> 00:51:28,120
og 1 linje hernede sker for at sige, "F scan f læser fra strengen punktet eller stream."

544
00:51:28,120 --> 00:51:32,360
Men f åbne. Så hvordan ville vi bruge f åben?

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

546
00:51:38,470 --> 00:51:45,070
skal du først åbne den fil, du ønsker at gøre ting med, og uundgåeligt,

547
00:51:45,070 --> 00:51:51,220
læse ting fra denne fil og gøre ting med dem.

548
00:51:51,220 --> 00:51:55,350
F åbent er, hvad vi bruger til at åbne filen.

549
00:51:55,350 --> 00:52:04,190
De ting, vi kommer tilbage, så hvad fil vil vi åbne, det giver os -

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

551
00:52:11,970 --> 00:52:16,740
Det er den fil, vi ønsker at åbne, og vi ønsker at åbne den -

552
00:52:16,740 --> 00:52:21,440
vi er nødt til eksplicit at angive, om vi ønsker at åbne det at læse eller hvis vi ønsker at åbne det at skrive.

553
00:52:21,440 --> 00:52:26,490
Der er et par af kombinationer og kram, men vi ønsker at åbne dette for læsning.

554
00:52:26,490 --> 00:52:29,380
Vi ønsker at læse fra filen.

555
00:52:29,380 --> 00:52:34,290
Så hvad betyder dette afkast? Den returnerer en fil stjerne (*),

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

557
00:52:37,260 --> 00:52:40,840
igen, det er en pegepind, men vi ønsker ikke at beskæftige sig med pegepinde.

558
00:52:40,840 --> 00:52:46,470
Du kan tænke på f så, f er nu den variabel, du vil bruge til at repræsentere filen.

559
00:52:46,470 --> 00:52:49,850
Så hvis du ønsker at læse fra filen, du læse fra f.

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

561
00:52:54,820 --> 00:53:00,350
Så i slutningen af ​​programmet, når vi uundgåeligt vil lukke filen, hvad skal vi gøre?

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

563
00:53:06,750 --> 00:53:12,600
Så nu den sidste fil funktion, vi vil ønsker at bruge, er scan f, f scan f..

564
00:53:12,600 --> 00:53:20,930
Og hvad det gør, er det scanner over filen på udkig efter et mønster til at matche.

565
00:53:20,930 --> 00:53:39,100
Ser man på manden side her ser vi int f scan f, ignorere returværdien for nu.

566
00:53:39,100 --> 00:53:45,230
Det første argument er den fil * stream, så det første argument, vi vil ønsker at passere er f.

567
00:53:45,230 --> 00:53:47,900
Vi scanning over f..

568
00:53:47,900 --> 00:53:53,680
Det andet argument er en formatstreng.

569
00:53:53,680 --> 00:53:58,310
Jeg vil give dig en formatstreng lige nu.

570
00:53:58,310 --> 00:54:05,180
Jeg tror, ​​at vi tilfældigvis sige, 127s \ n, en masse, der er unødvendig.

571
00:54:05,180 --> 00:54:12,490
Tanken om, hvad det format strengen er, er du kan tænke på scan f som det modsatte af print f.

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

573
00:54:17,160 --> 00:54:25,000
men i trykt f hvad vi laver, er - lad os se på en tilsvarende.

574
00:54:25,000 --> 00:54:32,550
Så print f, og der er faktisk også f print f, hvor den første argument vil være f..

575
00:54:32,550 --> 00:54:40,980
Når du udskriver f, kunne vi sige noget lignende, "print 127s \ n" og derefter, hvis vi passere det noget snor,

576
00:54:40,980 --> 00:54:44,050
det kommer til at udskrive denne streng, og derefter en ny linje.

577
00:54:44,050 --> 00:54:49,690
Hvad 127 betyder, jeg er temmelig sikker på, men jeg har aldrig begrænset mig til det,

578
00:54:49,690 --> 00:54:52,470
Du ville ikke engang behøver at sige '127 'i print f,

579
00:54:52,470 --> 00:54:57,090
men hvad det betyder er at udskrive de første 127 tegn.

580
00:54:57,090 --> 00:54:59,350
Så jeg er temmelig sikker på det er tilfældet. Du kan google for det.

581
00:54:59,350 --> 00:55:03,000
Men i det næste er jeg næsten positiv betyder det, at.

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

583
00:55:08,880 --> 00:55:14,680
F scan f nu, i stedet for at se på en variabel og udskrive det,

584
00:55:14,680 --> 00:55:22,620
det kommer til at se på nogle snor, og gemme mønsteret i den variable.

585
00:55:22,620 --> 00:55:26,360
Lad os rent faktisk bruger scan f i et andet eksempel.

586
00:55:26,360 --> 00:55:31,670
Så lad os sige vi havde nogle int, x = 4,

587
00:55:31,670 --> 00:55:41,110
og vi ønskede at skabe en streng lavet af - ønskede at skabe strengen

588
00:55:41,110 --> 00:55:44,250
det var ligesom, det vil komme op langt senere,

589
00:55:44,250 --> 00:55:49,020
noget, der er ligesom 4.jpg.

590
00:55:49,020 --> 00:55:51,870
Så dette kunne være et program, hvor du vil have sum tæller,

591
00:55:51,870 --> 00:55:56,420
opsummere imødegå i, og du ønsker at gemme en masse billeder.

592
00:55:56,420 --> 00:56:02,430
Så du vil gemme i.jpg, hvor i er nogle iteration af din løkke.

593
00:56:02,430 --> 00:56:05,500
Så hvordan kan vi gøre denne streng til at JPEG?

594
00:56:05,500 --> 00:56:11,720
Hvis du ønskede at udskrive 4.jpg, kunne vi bare sige print f,% d.jpg,

595
00:56:11,720 --> 00:56:14,410
og så ville det udskrive for at JPEG.

596
00:56:14,410 --> 00:56:20,050
Men hvis vi ønsker at gemme strengen 4.jpg, vi bruger scan f.

597
00:56:20,050 --> 00:56:30,860
Så streng s - faktisk vi kan-ikke - tegn, char s, lad os gå 100.

598
00:56:30,860 --> 00:56:35,400
Så jeg netop erklæret nogle vifte af 100 tegn,

599
00:56:35,400 --> 00:56:39,830
og det er hvad vi uundgåeligt kommer til at gemme, at JPEG i.

600
00:56:39,830 --> 00:56:47,920
Så vi vil bruge scan f, og formatet, hvordan vi ville sige% d.jpg

601
00:56:47,920 --> 00:56:54,980
for at udskrive 4.jpg er formatet af dette vil være% d.jpg.

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

603
00:57:04,020 --> 00:57:06,590
og nu vi er nødt til at gemme denne streng eller andet sted.

604
00:57:06,590 --> 00:57:12,500
Og hvor vi vil gemme denne streng er i array s.

605
00:57:12,500 --> 00:57:21,640
Så efter denne linje kode, s, hvis vi udskriver f,% s af den variable s,

606
00:57:21,640 --> 00:57:26,280
det kommer til at udskrive 4.jpg.

607
00:57:26,280 --> 00:57:38,930
Så f scan f er det samme som scan f, undtagen nu er det kigger over denne fil

608
00:57:38,930 --> 00:57:43,600
for hvad man skal gemme i sek.

609
00:57:43,600 --> 00:57:46,160
Det er, hvad den sidste argument vil være.

610
00:57:46,160 --> 00:57:54,170
Vi ønsker at gemme - "Scan f familie af funktioner scanninger i begge efter format som forsøgte nedenfor.

611
00:57:54,170 --> 00:58:02,450
Hvis nogen er gemt på den placering punkter, du kan vende tilbage - "

612
00:58:02,450 --> 00:58:12,910
Nej, vi kan være godt. Lad mig tænke et sekund.

613
00:58:12,910 --> 00:58:26,350
Så scan f ikke - hvad dælen er den funktion, som gør det?

614
00:58:26,350 --> 00:58:31,650
Så scan f er ikke til at tage et heltal og gøre dot jpg.

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

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

617
00:58:49,360 --> 00:58:55,940
Hvad er denne variabel, eller hvad kaldes denne funktion?

618
00:58:55,940 --> 00:59:04,950
Ja. That's - ja. Så hvad jeg definere til dig før var s print f,

619
00:59:04,950 --> 00:59:09,820
der - det giver meget mere mening, hvorfor jeg sagde det var meget mere som print f..

620
00:59:09,820 --> 00:59:14,700
Scan f er stadig lidt ligesom print f, men s print f kommer til at scanne det over

621
00:59:14,700 --> 00:59:17,510
og erstatte de variable og nu gemme det i en streng.

622
00:59:17,510 --> 00:59:19,620
I stedet for at udskrive det, gemmer den det i en streng.

623
00:59:19,620 --> 00:59:25,070
Så ignorere det helt. Du kan stadig tænke på format Projekteringsvejledning som ligesom i print f.

624
00:59:25,070 --> 00:59:34,510
Så nu, hvis vi ønskede at gøre det 4.jpg ting, ville vi gøre s print f, x af dette.

625
00:59:34,510 --> 00:59:38,520
Så hvad scan f gør - hvad der var dit spørgsmål vil være?

626
00:59:38,520 --> 00:59:40,820
[Student] Jeg er bare forvirret på, hvad vi forsøger at gøre lige her

627
00:59:40,820 --> 00:59:43,450
med det JPEG. Kan du forklare, at 1 mere tid?

628
00:59:43,450 --> 00:59:52,710
Så det var - det er mindre Relevante til f scan f nu, forhåbentlig, vil det binde tilbage i en slags måde.

629
00:59:52,710 --> 01:00:02,240
Men hvad jeg oprindeligt havde til hensigt at vise var - dette er faktisk direkte relevant for disse [? F5]

630
01:00:02,240 --> 01:00:08,520
Du skal bruge s print f, hvor siger vi har 100 billeder,

631
01:00:08,520 --> 01:00:13,630
og du ønsker at læse billedet 1.jpg, 2.jpg, 3.jpg.

632
01:00:13,630 --> 01:00:21,520
Så for at gøre det, skal du f åben, og så er du nødt til at passere i den streng, du vil åbne.

633
01:00:21,520 --> 01:00:30,020
Så vi ønsker at åbne 1.jpg, for at skabe den streng, der er 1.jpg,

634
01:00:30,020 --> 01:00:37,660
vi gør s print f af% d.jpg--vi ikke gø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 af i.

637
01:00:51,130 --> 01:00:56,320
Så efter denne linje, nu variabel eller array s kommer til at 1.jpg.

638
01:00:56,320 --> 01:01:10,610
Eller 0.jpg, 1.jpg, 2.jpg. Og så vi kan åbne efter tur hvert billede for læsning.

639
01:01:10,610 --> 01:01:19,550
Så det er, hvad s udskriver f gør. Kan du se hvad s udskriver f er nu gør?

640
01:01:19,550 --> 01:01:25,720
[Student] Okay, så det tager - det skaber en streng, something.jpg, og derefter gemmer den.

641
01:01:25,720 --> 01:01:30,360
Ja. Det skaber - det er en anden format streng, ligesom scan f og print f,

642
01:01:30,360 --> 01:01:37,530
hvor den indsætter alle de variabler i det andet argument, kan være s modsætning til i.

643
01:01:37,530 --> 01:01:42,280
Måske - Jeg mener, det er tilfældet. Men uanset rækkefølgen af ​​argumenterne er.

644
01:01:42,280 --> 01:01:45,440
Det kommer til at indsætte alle de variabler i det format strengen

645
01:01:45,440 --> 01:01:52,250
og derefter gemme i vores buffer, vi kalder en buffer, det er hvor vi opbevare strengen.

646
01:01:52,250 --> 01:02:00,750
Så vi gemmer inde i s den korrekt-formateret streng, idet% d blevet erstattet med 4.

647
01:02:00,750 --> 01:02:08,080
[Student] Så hvis vi gjorde dette, er den variable f bare at forflytte?

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

649
01:02:18,110 --> 01:02:22,810
Men - og derefter også, hvis der ikke var en f åbner op her, så ville vi nødt til at sige -

650
01:02:22,810 --> 01:02:29,280
Yeah. Men det ville åbne hundrede forskellige filer.

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

652
01:02:37,360 --> 01:02:44,230
Okay. Så scan f, f scan f, er lidt den samme idé,

653
01:02:44,230 --> 01:02:53,610
men i stedet for, i stedet for at lagre det i en streng, er det mere som om du er nu

654
01:02:53,610 --> 01:03:02,420
går over en brod og mønstertilpasning over denne streng og lagring af resultaterne i variabler.

655
01:03:02,420 --> 01:03:11,290
Du kan bruge scan f for at parse over noget lignende 4.jpg, og gemme heltal 4 i sum int x.

656
01:03:11,290 --> 01:03:13,430
Det er, hvad vi kan bruge scan f for.

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

658
01:03:16,300 --> 01:03:19,200
Jeg er faktisk temmelig sikker på det er, hvad CS50 biblioteket gør.

659
01:03:19,200 --> 01:03:29,050
Så når du siger, "få int," det er scan F-ing over - scan f er den måde, du får input fra brugeren.

660
01:03:29,050 --> 01:03:34,670
F scan f kommer til at gøre det samme, men ved hjælp af en fil til at scanne over.

661
01:03:34,670 --> 01:03:41,090
Så her er vi scanner over denne fil.

662
01:03:41,090 --> 01:03:45,460
Det mønster, vi forsøger at matche er nogle streng, der er 127 tegn lang

663
01:03:45,460 --> 01:03:48,100
efterfulgt af en ny linie

664
01:03:48,100 --> 01:03:54,770
Så jeg er temmelig sikker på, vi kunne endda bare sige "match s," da i ordbogen

665
01:03:54,770 --> 01:03:57,770
vi tilfældigvis har, vi garanteret ingen ord er, at lange,

666
01:03:57,770 --> 01:04:03,310
og også f scan f, jeg tror, ​​vil stoppe ved den nye linje uanset hvad.

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

668
01:04:06,970 --> 01:04:13,960
[Student] Hvis vi ikke inkluderer den nye linje, ville det ikke finde dele af et ord?

669
01:04:13,960 --> 01:04:22,900
Det - hver - se på ordbogen -

670
01:04:22,900 --> 01:04:26,200
Så i ordbogen, er disse alle vores ord.

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

672
01:04:30,500 --> 01:04:32,510
Scanningen f kommer til at afhente dette ord.

673
01:04:32,510 --> 01:04:38,750
Hvis vi ikke medtager den nye linje, så er det muligt, at den næste scanning f bare vil læse den nye linje.

674
01:04:38,750 --> 01:04:44,180
Men herunder nye linje, så vil bare ignorere den nye linje.

675
01:04:44,180 --> 01:04:49,440
Men vi vil aldrig få en del af et ord, da vi altid læser op til en ny linje, uanset hvad.

676
01:04:49,440 --> 01:04:54,530
[Student] Men hvad nu, hvis du søger efter ordet "Cissa," som Cissa.

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

678
01:04:57,380 --> 01:05:05,110
Så her er vi - det vil læse i - det er faktisk en god pointe.

679
01:05:05,110 --> 01:05:10,660
Vi aldrig bruger den nuværende - det ord, vi leder efter, er den første Kommandolinjeargumentet.

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

681
01:05:16,460 --> 01:05:20,020
Så strengen, vi leder efter, er argv 1.

682
01:05:20,020 --> 01:05:23,290
Vi er ikke på udkig efter et ord på alle i vores scan f.

683
01:05:23,290 --> 01:05:28,030
Hvad vi gør med scan f er at få hvert ord i ordbogen,

684
01:05:28,030 --> 01:05:34,320
og så når vi har det ord vi vil bruge strcmp at sammenligne dem.

685
01:05:34,320 --> 01:05:39,210
Vi vil sammenligne vores ord, og hvad vi lige har læst i.

686
01:05:39,210 --> 01:05:45,110
Så uundgåeligt, vi kommer til at ende med at gøre en masse scan fs

687
01:05:45,110 --> 01:05:52,130
indtil det bare så sker det, at scan f vil vende tilbage -

688
01:05:52,130 --> 01:05:54,800
det vil vende tilbage en, så længe det har matchet et nyt ord,

689
01:05:54,800 --> 01:06:01,360
og det vil vende tilbage noget andet, så snart den har undladt at matche ordet.

690
01:06:01,360 --> 01:06:08,440
Vi læser hele ordbogen, lagring linie for linie hvert ord i den variable s.

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

692
01:06:17,240 --> 01:06:21,650
strcmp sker for at bringe 0, hvis en kamp blev lavet.

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

694
01:06:31,510 --> 01:06:35,370
eller ord er i ordbogen, eller hvad du ønsker at udskrive f.

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

696
01:06:41,450 --> 01:06:50,410
Det er den slags ting, vi ønsker at gøre, og vi er ikke bare på udkig efter ord i ordbogen.

697
01:06:50,410 --> 01:06:56,660
Så vi kunne gøre det, hvis vi ønskede at lede efter deres mønster, Cissa, som du sagde før,

698
01:06:56,660 --> 01:07:00,260
hvis vi ønskede at lede efter det mønster, så det ville svigte i sagen

699
01:07:00,260 --> 01:07:08,010
fordi det er faktisk ikke et ord, men et af ordene i ordbogen tilfældigvis har det i det.

700
01:07:08,010 --> 01:07:13,560
Så det ville matche dette ord, men denne delmængde af ordet er ikke et ord i sig selv.

701
01:07:13,560 --> 01:07:17,250
Men det er ikke, hvordan vi bruger det, vi læser i hvert ord

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

703
01:07:19,740 --> 01:07:25,780
Så vi er altid sammenligne hele ord.

704
01:07:25,780 --> 01:07:29,620
Jeg kan sende de færdige løsninger senere.

705
01:07:29,620 --> 01:07:32,050
Dette er slags næsten det rigtige svar, tror jeg.

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

707
01:07:34,720 --> 01:07:40,870
Åh, jeg slippe af med det før? Char s, jeg gætter vi sagde 127 - jeg har glemt hvad det største er.

708
01:07:40,870 --> 01:07:44,100
Vi vil bare gøre 128, så nu s er lang nok.

709
01:07:44,100 --> 01:07:46,570
Vi har ikke brug for at udskrive noget.

710
01:07:46,570 --> 01:07:56,440
Vi vil også gerne have at lukke vores fil, og det burde handle om det rigtige svar.

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