1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] Avsnitt 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
Detta är CS50. CS50.TV

4
00:00:07,410 --> 00:00:15,770
Så, jag Rob. Jag är en senior i Kirkland. Detta är mitt tredje år TFing CS50.

5
00:00:15,770 --> 00:00:22,220
Det är första gången som vi håller på att förändras från traditionell föreläsning stil avsnitt,

6
00:00:22,220 --> 00:00:25,610
där vi bara typ av översyn vad som hände i föreläsning och sedan ni ställa frågor,

7
00:00:25,610 --> 00:00:32,250
nu är mycket mer problembaserad, där vi använder Spaces och -

8
00:00:32,250 --> 00:00:37,410
Åh, så tanken är att gå till den länken jag skickade dig och du kommer att vara i mitt utrymme.

9
00:00:37,410 --> 00:00:42,410
Har någon inte en bärbar dator? Okej.

10
00:00:42,410 --> 00:00:47,050
Så vi kommer att använda detta, och vi kommer att göra problem bor i avsnitt

11
00:00:47,050 --> 00:00:50,740
och diskutera dem och räkna ut vad som är fel

12
00:00:50,740 --> 00:00:56,390
och jag kan dra upp några av din kod, och jag kan diskutera dina idéer.

13
00:00:56,390 --> 00:01:02,140
Så har någon haft problem?

14
00:01:02,140 --> 00:01:07,000
Du kan chatta på sidan, jag vet inte om vi kommer att ha anledning till det.

15
00:01:07,000 --> 00:01:12,270
Nu, liksom tidigare supersection, om du var på den klassen, vet du vad det handlar om.

16
00:01:12,270 --> 00:01:19,200
På alla P uppsättningar det kommer att bli dessa sektioner.

17
00:01:19,200 --> 00:01:22,550
Så P-set 2, specifikationer, antar jag att du såg det på P-set 1 redan.

18
00:01:22,550 --> 00:01:27,400
Men vi kan titta på P-set 2 för vad vi kommer att gå över i dag.

19
00:01:27,400 --> 00:01:29,460
Och du kommer att se en del av frågorna.

20
00:01:29,460 --> 00:01:37,530
Så det här kommer att vara i alla P-set, det kommer att bli en del av frågorna.

21
00:01:37,530 --> 00:01:41,340
Hittills har vi sagt, "Tänk på detta en möjlighet att träna."

22
00:01:41,340 --> 00:01:44,940
Du kommer inte att bli ombedd att lämna programmet.

23
00:01:44,940 --> 00:01:48,480
Tanken är att dessa är tänkta att typ av hjälpa dig komma igång med problemet set.

24
00:01:48,480 --> 00:01:53,220
Jag antar på Hacker upplagan, är många av dem skulle bara vara nya, intressanta saker att lära sig.

25
00:01:53,220 --> 00:01:58,590
De får inte vara direkt tillämplig på problemet set.

26
00:01:58,590 --> 00:02:01,810
Och just nu är vi inte ska ha du skickar dem, men i teorin,

27
00:02:01,810 --> 00:02:07,480
för senare problem apparater kan du skicka dem, och därmed kan du antingen komma till avsnitt

28
00:02:07,480 --> 00:02:10,380
eller titta på avsnittet för att få svar, eller så kan du bara få dem på egen hand

29
00:02:10,380 --> 00:02:16,350
Om du inte känner njuter av min närvaro.

30
00:02:16,350 --> 00:02:21,010
Så - jag tror det är den första.

31
00:02:21,010 --> 00:02:29,280
Åh. Även under dessa delar av frågor vi också ställa frågor om shortsen.

32
00:02:29,280 --> 00:02:33,440
Så jag antar att, i teorin, du ska titta på dem innan han kom till avsnittet

33
00:02:33,440 --> 00:02:38,550
men det är bra om du inte gör det, vi ska gå över dem ändå.

34
00:02:38,550 --> 00:02:42,590
Så vi kan börja med dessa: "Hur en while-slinga skiljer sig från en gör-while-slinga?

35
00:02:42,590 --> 00:02:46,210
När är den senare särskilt användbart? "

36
00:02:46,210 --> 00:02:49,390
Så någon har några -?

37
00:02:49,390 --> 00:02:52,730
[Student] DO-while-slinga alltid köra minst en gång.

38
00:02:52,730 --> 00:03:02,950
Ja. Så det är skillnaden. En while-slinga - Jag ska bara göra det på här - while-slinga, vi har tillstånd

39
00:03:02,950 --> 00:03:19,760
här, medan en gör-tag, har du inte ett villkor tills vi kommer ner hit.

40
00:03:19,760 --> 00:03:24,130
Och så, när programmet är köra, och det blir till while-slingan,

41
00:03:24,130 --> 00:03:26,380
Det kontrollerar omedelbart om detta villkor är sant.

42
00:03:26,380 --> 00:03:30,710
Om detta villkor inte är sant, kommer det att hoppa strax över slingan helt.

43
00:03:30,710 --> 00:03:34,390
Do-while-slinga, eftersom programmet körs, blir det till "göra".

44
00:03:34,390 --> 00:03:37,920
Ingenting händer på denna punkt, bara fortsätter köra.

45
00:03:37,920 --> 00:03:42,690
Sedan när den träffar "medan" om villkoret är sant, det ska slingan tillbaka och göra det igen

46
00:03:42,690 --> 00:03:46,730
och igen och igen tills tillståndet är inte sant och sedan bara faller igenom.

47
00:03:46,730 --> 00:03:50,600
Så skillnaden är att detta kan hoppa rätt från början.

48
00:03:50,600 --> 00:03:56,770
Detta utför nödvändighet en gång och sedan kan utföra fler gånger om villkoret är fortfarande sant.

49
00:03:56,770 --> 00:04:03,720
Så while-slingan kommer bara göra det en gång, eller - while-slingan - vi kanske inte behöver göra det alls,

50
00:04:03,720 --> 00:04:07,900
eftersom så fort vi kommer till det, om villkoret är falskt, vi hoppa bara rätt över den.

51
00:04:07,900 --> 00:04:11,770
Medan gör-while-slinga, kommer vi att köra det en gång, nödvändigtvis.

52
00:04:11,770 --> 00:04:14,560
Sedan, när vi kommer till tillståndet, kontrollera vi om det är sant eller falskt.

53
00:04:14,560 --> 00:04:19,790
Om det är sant, vi gör det igen, om det är falskt, vi bara fortsätta gå.

54
00:04:19,790 --> 00:04:24,680
Så när är den senare särskilt användbart?

55
00:04:24,680 --> 00:04:31,190
Så jag kan säga att i helheten av de 4 år, 3 år, vad som helst,

56
00:04:31,190 --> 00:04:38,780
som jag har programmering, jag har använt detta, liksom under 10 gånger.

57
00:04:38,780 --> 00:04:43,140
Och förmodligen 5 av dem finns i CS50 när vi inför do-while-slingor.

58
00:04:43,140 --> 00:04:47,510
Så när ni använde do-while-slingor?

59
00:04:47,510 --> 00:04:49,510
När är det - ja?

60
00:04:49,510 --> 00:04:53,180
[Student] När du försöker få användarinmatning, eller något du vill kontrollera -

61
00:04:53,180 --> 00:04:59,700
Ja. Så gör-while-slingor, indata är den stora.

62
00:04:59,700 --> 00:05:03,160
Det är därför de första par problem set, när du vill fråga användaren, liknande,

63
00:05:03,160 --> 00:05:08,520
"Ge mig en sträng," du kan inte fortsätta tills du får den strängen.

64
00:05:08,520 --> 00:05:12,980
Och så, med nödvändighet måste be om strängen minst en gång.

65
00:05:12,980 --> 00:05:16,950
Men om de svarar något dåligt, så måste du loop tillbaka och fråga igen.

66
00:05:16,950 --> 00:05:20,810
Men andra än användardata, är det mycket ovanligt att jag stöter på ett fall

67
00:05:20,810 --> 00:05:27,170
där jag vill slinga "minst en gång", men möjligen mer.

68
00:05:27,170 --> 00:05:33,370
Frågor eller -? Har någon använt en gör-while-slinga någon annanstans?

69
00:05:33,370 --> 00:05:36,780
Okej. Så nästa gång det är, "Vad odeklarerat identifierare

70
00:05:36,780 --> 00:05:43,310
vanligtvis ange om matas med klang? "

71
00:05:43,310 --> 00:05:47,380
Så vilken typ av kod kan jag skriva för att få "svart identifierare?

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

73
00:05:49,550 --> 00:05:52,650
Så vi kan bara prova här, x = 2.

74
00:05:52,650 --> 00:06:04,830
Vi ska köra - Åh, jag inte på det. Så här får vi - okej.

75
00:06:04,830 --> 00:06:07,100
"Användning av odeklarerade identifierare X".

76
00:06:07,100 --> 00:06:11,610
Så det är den svarta identifierare, en variabel.

77
00:06:11,610 --> 00:06:13,910
Det kommer ofta kalla en variabel en identifierare.

78
00:06:13,910 --> 00:06:17,300
Så det kanske inte vet det är faktiskt en variabel, det vet inte vad det är.

79
00:06:17,300 --> 00:06:19,380
Så det är en identifierare.

80
00:06:19,380 --> 00:06:26,060
Så varför är det odeklarerat? Ja.

81
00:06:26,060 --> 00:06:32,190
Så för att vara tydlig på terminologi, deklaration av en variabel

82
00:06:32,190 --> 00:06:37,360
är när du säger "int x," eller "sträng y", oavsett.

83
00:06:37,360 --> 00:06:41,910
Initieringen av variabeln, eller tilldelningen av variabeln,

84
00:06:41,910 --> 00:06:44,510
är när du säger "x = 2."

85
00:06:44,510 --> 00:06:52,950
Så vi kan göra dessa i separata steg, int x, x = 2, och tills - vi kan ha en massa saker här -

86
00:06:52,950 --> 00:07:00,350
men tills denna linje sker, X fortfarande oinitierad men den har förklarats.

87
00:07:00,350 --> 00:07:06,760
Och så kan vi naturligtvis göra det i 1 rad, och nu är vi förklara och initieras.

88
00:07:06,760 --> 00:07:10,730
Frågor?

89
00:07:10,730 --> 00:07:18,390
Och slutligen, "Varför är Caesar Cipher inte mycket säker?"

90
00:07:18,390 --> 00:07:23,830
Så först, inte vill att någon ska säga vad Caesar Cipher är?

91
00:07:23,830 --> 00:07:28,100
[Student] Caesar Cipher bara är att du kartlägger, flytta dig varje bokstav,

92
00:07:28,100 --> 00:07:34,420
ett visst antal bokstäver går över, och flytta tillbaka över, och det är inte mycket säker eftersom

93
00:07:34,420 --> 00:07:42,260
Det finns bara 26 möjliga alternativ och du bara måste prova varje 1 av dem tills du får det.

94
00:07:42,260 --> 00:07:45,470
Åh. Så ska jag upprepa?

95
00:07:45,470 --> 00:07:51,600
Caesar Cipher, it's - Jag menar, kommer du att göra med det på de problem som du -

96
00:07:51,600 --> 00:07:56,110
eller jag antar standardversionen av problemet uppsättning som inte är på hackare utgåva.

97
00:07:56,110 --> 00:08:01,550
Så på standardversionen på problemet set, får du ett meddelande i stil med "Hej, världen"

98
00:08:01,550 --> 00:08:08,410
och du har också ett antal som 6, och du tar det budskapet, och varje enskild karaktär,

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

100
00:08:11,310 --> 00:08:16,560
Så "h" i hej skulle bli H-I-J-K-L-M-N.

101
00:08:16,560 --> 00:08:19,600
Så den första bokstaven skulle vara n. Vi gör samma sak med e.

102
00:08:19,600 --> 00:08:23,530
Om vi ​​har en, typ, z eller något, då vi linda tillbaka runt till "en."

103
00:08:23,530 --> 00:08:29,280
Men varje karaktär får cyklat 6 tecken senare i alfabetet, och det är inte mycket säker

104
00:08:29,280 --> 00:08:35,440
eftersom det bara finns 26 möjligheter för hur många sätt du kan slå en enda bokstav.

105
00:08:35,440 --> 00:08:42,919
Så du kan bara prova alla 26 av dem och, förmodligen, en tillräckligt lång budskap,

106
00:08:42,919 --> 00:08:46,860
endast 1 av de möjliga 26 saker kommer att vara läsbar,

107
00:08:46,860 --> 00:08:50,300
och lättläst en kommer att vara det ursprungliga meddelandet.

108
00:08:50,300 --> 00:08:56,240
Så det är inte ett bra sätt att kryptera något alls.

109
00:08:56,240 --> 00:08:59,070
Relaterade till dessa shorts, "Vad är en funktion?"

110
00:08:59,070 --> 00:09:03,370
Så vad är en funktion? Ja.

111
00:09:03,370 --> 00:09:11,640
[Student] Det är som en separat del av kod som du kan ringa för att gå igenom och sedan få tillbaka värdet av vad som helst.

112
00:09:11,640 --> 00:09:18,160
Ja. Så jag ska svara genom att också svara på nästa - eller upprepa med också bara svara på nästa.

113
00:09:18,160 --> 00:09:22,410
Du kan använda funktioner istället för att bara kopiera och klistra in koden om och om igen.

114
00:09:22,410 --> 00:09:27,200
Bara ta den koden, lägg den i en fuction, och sedan kan du bara anropa funktionen

115
00:09:27,200 --> 00:09:29,870
var du har att kopiera och klistra in.

116
00:09:29,870 --> 00:09:33,350
Så fungerar är användbara.

117
00:09:33,350 --> 00:09:35,860
Så nu ska vi göra verkliga problem.

118
00:09:35,860 --> 00:09:46,490
Den första. Så tanken på den första är, passerar du den en sträng, och oavsett -

119
00:09:46,490 --> 00:09:52,060
eller står det gemener? Det står inte gemener.

120
00:09:52,060 --> 00:09:57,730
Så budskapet kan vara allt, och - oh no. Det gör det.

121
00:09:57,730 --> 00:10:01,610
"För enkelhets skull kan du anta att användaren kommer bara in små bokstäver och mellanslag."

122
00:10:01,610 --> 00:10:08,180
Så vi ge det ett budskap med bara gemener och vi alternera

123
00:10:08,180 --> 00:10:15,450
mellan stora och små - vi ändra strängen är stora och små, omväxlande.

124
00:10:15,450 --> 00:10:22,920
Så innan vi ger dig en sekund att ens dyka i problemet,

125
00:10:22,920 --> 00:10:32,420
vad är det första som vi måste göra?

126
00:10:32,420 --> 00:10:36,900
Åh, vad jag bara klicka på? Åh, klickade jag bara på ett mail här.

127
00:10:36,900 --> 00:10:42,870
Så det första vi behöver göra - jag tittar på fel en?

128
00:10:42,870 --> 00:10:49,320
Är denna del av en?

129
00:10:49,320 --> 00:10:51,320
Nej, de finns fortfarande där, dock.

130
00:10:51,320 --> 00:10:55,160
Okej, fortfarande här.

131
00:10:55,160 --> 00:11:03,160
Nu kan vi inte anta -? Ja. Här kan vi inte anta att det bara små och utrymmen.

132
00:11:03,160 --> 00:11:07,770
Så nu måste vi ta itu med det faktum att bokstäverna kan vara vad vi vill att de ska vara.

133
00:11:07,770 --> 00:11:11,910
Och så det första vi vill göra är att få precis meddelandet.

134
00:11:11,910 --> 00:11:19,790
Vi behöver bara få en sträng, sträng s = GetString, okej.

135
00:11:19,790 --> 00:11:24,890
Nu detta problem, det finns ett par sätt att göra det.

136
00:11:24,890 --> 00:11:29,840
Men vi kommer att vilja använda bitvisa operatörer här.

137
00:11:29,840 --> 00:11:35,280
Finns det människor som antingen inte var på supersection,

138
00:11:35,280 --> 00:11:37,480
eller något, och inte vet vad bitvisa operatörer?

139
00:11:37,480 --> 00:11:41,710
Eller hur de förhåller sig till ASCII på något sätt?

140
00:11:41,710 --> 00:11:45,650
[Student] Jag var inte på supersection, men jag vet vad bitvisa operatörer.

141
00:11:45,650 --> 00:11:49,560
Okej. Så då jag inte behöver gå över grunderna i dem, men jag ska förklara

142
00:11:49,560 --> 00:11:51,830
vad vi kommer att vilja använda här.

143
00:11:51,830 --> 00:11:59,680
Så A: Binär representation av kapital A är antalet 65.

144
00:11:59,680 --> 00:12:07,560
Jag ska bara titta på - 41 kommer att bli 01.000.001.

145
00:12:07,560 --> 00:12:14,170
Så det borde vara 65 i decimal, så detta är den binära representationen av tecknet kapital A.

146
00:12:14,170 --> 00:12:19,440
Nu, den binära representationen av tecknet gemener 'a'

147
00:12:19,440 --> 00:12:33,350
kommer att bli samma sak, nästan. Är det - 6, ja. Det är rätt.

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

149
00:12:37,670 --> 00:12:43,940
Så märker att skillnaden mellan A och "a" är denna enda bit.

150
00:12:43,940 --> 00:12:49,440
Och detta råkar vara den 32 bitar, den bit som representerar antalet 32.

151
00:12:49,440 --> 00:12:53,910
Och det är rimligt eftersom A är 65, "a" är 97.

152
00:12:53,910 --> 00:12:56,610
Skillnaden mellan dem är 32.

153
00:12:56,610 --> 00:13:03,770
Så nu vet vi att vi kan konvertera från A till "a" genom att ta en

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

155
00:13:09,710 --> 00:13:20,900
Detta är en bitvis OR, med 00100000 och som kommer ge oss "en."

156
00:13:20,900 --> 00:13:26,850
Och vi kan få från "a" till A genom bitvis Anding

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

158
00:13:33,700 --> 00:13:43,840
Så det här kommer sedan att ge oss exakt vad "a" var, men tar ut denna individuella bitar,

159
00:13:43,840 --> 00:13:50,070
så vi får 01000001, jag vet inte om jag räknade rätt.

160
00:13:50,070 --> 00:13:56,750
Men denna teknik för bitvis OR-att ta sig från huvudstaden till gemener,

161
00:13:56,750 --> 00:14:02,080
och bitvis-behandling för att ta sig från gemener till kapital är inte exklusivt till A.

162
00:14:02,080 --> 00:14:06,510
Alla bokstäver, K vs K, Z vs z,

163
00:14:06,510 --> 00:14:10,080
alla av dem är bara att skilja denna enda bit.

164
00:14:10,080 --> 00:14:16,290
Och så kan du använda detta för att växla från någon liten bokstav till någon bokstav och vice versa.

165
00:14:16,290 --> 00:14:26,670
Okej. Så ett enkelt sätt att komma ur denna - så istället för att

166
00:14:26,670 --> 00:14:32,170
skriva ut vad 1011111 är - ett enkelt sätt att representera detta nummer, och detta är inte en

167
00:14:32,170 --> 00:14:39,710
att jag gick över i supersection, men tilde (~) är en annan bitvis operatör.

168
00:14:39,710 --> 00:14:42,520
Vad ~ gör är det ser på lite representation.

169
00:14:42,520 --> 00:14:45,630
Låt oss ta ett nummer.

170
00:14:45,630 --> 00:14:53,130
Detta är bara några binärt tal, och vad ~ gör det bara vänder alla bitarna.

171
00:14:53,130 --> 00:15:00,630
Så detta var en 1, nu en 0, är ​​detta en 0, nu 1, 010.100.

172
00:15:00,630 --> 00:15:08,320
Så det är allt ~ gör. Så 32 kommer att vara nummer - bli av med det -

173
00:15:08,320 --> 00:15:23,320
så 32 kommer att vara nummer 00.100.000, och så ~ detta kommer att bli

174
00:15:23,320 --> 00:15:29,980
detta nummer upp här att jag-behandlas "a" med.

175
00:15:29,980 --> 00:15:35,600
Ser alla det? Detta är ganska vanligt, liksom när du vill ta reda på

176
00:15:35,600 --> 00:15:40,740
för senare saker som vi kanske ser, när vi vill se om -

177
00:15:40,740 --> 00:15:44,710
eller vi vill ha allt, varenda bit set utom 1

178
00:15:44,710 --> 00:15:47,910
du brukar göra ~ av den bit som vi inte vill ha in.

179
00:15:47,910 --> 00:15:53,090
Så vi inte vill att 32 bitar inställda, så vi ~ av 32.

180
00:15:53,090 --> 00:15:57,790
Okej. Så att vi kan använda alla dessa här.

181
00:15:57,790 --> 00:16:03,000
Okej, så det är bra om du inte är klar, ska vi sakta gå över tillsammans,

182
00:16:03,000 --> 00:16:11,870
eller gå över detta, så - genom denna. Gå igenom detta.

183
00:16:11,870 --> 00:16:20,790
Så vi har vår sträng och vi vill slinga över varje tecken i strängen och göra något till den.

184
00:16:20,790 --> 00:16:26,710
Så hur gör vi slinga över en sträng? Vad ska vi använda?

185
00:16:26,710 --> 00:16:30,980
Jag tänker inte göra det här. Ja.

186
00:16:30,980 --> 00:16:42,940
Så jag har min iterator, och han sa det, men hur vet jag hur många tecken i strängen?

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

188
00:16:47,030 --> 00:16:49,860
Så vad jag har gjort här är inte det bästa sättet att göra saker.

189
00:16:49,860 --> 00:16:51,860
Någon som vet varför?

190
00:16:51,860 --> 00:16:55,290
Eftersom du kollar språket i strängen varje gång.

191
00:16:55,290 --> 00:17:06,859
Så vi kommer att vilja flytta strlen, kunde jag säga upp här, int längd = strlen (s),

192
00:17:06,859 --> 00:17:11,900
och sedan gör jag <längd, och om du inte har sett det förut,

193
00:17:11,900 --> 00:17:20,410
Jag kan också göra int i = 0, längd = strlen (s).

194
00:17:20,410 --> 00:17:25,010
Och så detta är något att föredra, eftersom nu har jag begränsat omfattningen

195
00:17:25,010 --> 00:17:29,150
av variabel längd för att just denna "för" loop, i stället för att förklara det innan

196
00:17:29,150 --> 00:17:34,990
och att det finns alltid, och om du inte fånga varför det är dåligt,

197
00:17:34,990 --> 00:17:39,410
eller varför originalet var dåligt, it's - börja på för slingan.

198
00:17:39,410 --> 00:17:43,380
Jag kollade tillståndet. Är jag <längden s?

199
00:17:43,380 --> 00:17:46,790
Så längden av s, låt oss arbeta med "hej" hela tiden.

200
00:17:46,790 --> 00:17:49,670
Så längd s, H-E-L-L-O. Längd 5.

201
00:17:49,670 --> 00:17:57,580
Så jag = 0, längd 5 är, så jag är inte <5, så slingan fortsätter.

202
00:17:57,580 --> 00:18:02,750
Då kan vi gå igen. Vi kontrollerar villkoret. Är jag <längden hej?

203
00:18:02,750 --> 00:18:08,390
Så låt oss kontrollera längden hej. ^ H-E-L-L-O. Det är 5, jag är inte <5, så vi fortsätter igen.

204
00:18:08,390 --> 00:18:13,330
Så vi beräkna, vi räknar hej, för varje iteration av slingan,

205
00:18:13,330 --> 00:18:17,380
även trodde att det aldrig kommer att förändras, det är alltid kommer att vara 5.

206
00:18:17,380 --> 00:18:22,530
Så minns vi bara 5 på framsidan, och nu allting är bättre.

207
00:18:22,530 --> 00:18:24,990
Så iteration över hela strängen.

208
00:18:24,990 --> 00:18:31,470
Vad vill vi göra för varje tecken i strängen?

209
00:18:31,470 --> 00:18:38,510
[Student sett obegripligt]

210
00:18:38,510 --> 00:18:47,000
Ja. Så om karaktären inte är alfabetisk, då vi bara vill hoppa över den.

211
00:18:47,000 --> 00:18:52,300
Eftersom vi bara bryr oss om alfabetiska bokstäver, vi kan inte kapitalisera ett nummer.

212
00:18:52,300 --> 00:19:10,850
Så hur kan vi göra detta? Så vårt tillstånd, så om vi vill ha något - kolla om den är alfabetisk ordning.

213
00:19:10,850 --> 00:19:14,060
Så hur kontrollerar vi detta?

214
00:19:14,060 --> 00:19:18,720
[Student] Du kan bara använda funktionen är alfa.

215
00:19:18,720 --> 00:19:23,160
Är det ingår i någon av dessa, eller något har liknande char.h eller något?

216
00:19:23,160 --> 00:19:32,710
Låt oss inte använda är alfa-funktionen, och använd den explicita - så vi har s [i],

217
00:19:32,710 --> 00:19:40,460
som är det åttonde tecknet av s, kom ihåg att en sträng är en matris av tecken,

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

219
00:19:43,180 --> 00:19:49,280
Nu, om det är en bokstav, vet vi att det måste vara i ett specifikt område.

220
00:19:49,280 --> 00:19:54,370
Och vad är det intervall?

221
00:19:54,370 --> 00:20:07,860
Ja. Så om s [i] är ≥ 65, och s [i] är ≤ 90, vad ska jag göra istället?

222
00:20:07,860 --> 00:20:18,470
Ja. Så du bör absolut aldrig ens behöver känna till ASCII-värden av något någonsin.

223
00:20:18,470 --> 00:20:25,640
Aldrig tänka på siffrorna 65, 90, 97 och 102, eller vad det nu är.

224
00:20:25,640 --> 00:20:32,470
Du behöver inte - 112 -? Att du inte behöver känna dem alls. Det är fel också.

225
00:20:32,470 --> 00:20:41,940
Använd endast enstaka citat tecken, enda anbud konstanter. Så "A" och mindre än 90 är "Z"

226
00:20:41,940 --> 00:20:47,930
Och detta är betydligt bättre - Jag vet inte från toppen av mitt huvud att Z är 90.

227
00:20:47,930 --> 00:20:52,690
Jag vet från toppen av mitt huvud som "Z" är huvudstad Z.

228
00:20:52,690 --> 00:21:02,100
Så länge som det är i intervallet av kapital A till huvudstaden Z, eller vi kan kontrollera gemener,

229
00:21:02,100 --> 00:21:17,010
Eller om det är i intervallet ≥ "a" och ≤ z..

230
00:21:17,010 --> 00:21:19,010
Så det är vårt tillstånd.

231
00:21:19,010 --> 00:21:22,520
Stil för var att sätta dessa saker varierar.

232
00:21:22,520 --> 00:21:29,520
Jag gör det så här.

233
00:21:29,520 --> 00:21:31,520
Nu, vad vi vill göra?

234
00:21:31,520 --> 00:21:39,530
Vi vet att detta brev är ett tecken, en bokstav.

235
00:21:39,530 --> 00:21:46,270
Så vi måste växla mellan om detta ska nu finnas en bokstav eller en liten bokstav.

236
00:21:46,270 --> 00:21:48,820
Hur håller vi reda på vilka vi vill att det ska vara?

237
00:21:48,820 --> 00:21:55,520
[Student röster, obegripliga]

238
00:21:55,520 --> 00:21:59,150
Så ja, men låt mig kolla.

239
00:21:59,150 --> 00:22:04,910
Modul 0-2 sades, var ett förslag kastas ut, och jag håller med om det.

240
00:22:04,910 --> 00:22:11,780
Utom meddelar att som - är det så? Ja.

241
00:22:11,780 --> 00:22:18,270
Det är alla andra, men vi kan inte modul 2 av i, eller i mod 2, eftersom

242
00:22:18,270 --> 00:22:22,950
märker att E är kapital och "a" är gemener? Men det finns ett utrymme att skilja dem?

243
00:22:22,950 --> 00:22:27,150
Så de kommer att vara samma mod 2, men de är olika fall.

244
00:22:27,150 --> 00:22:29,150
[Student fråga, obegripligt]

245
00:22:29,150 --> 00:22:34,690
Ja. Så vi ska bara hålla räkningen.

246
00:22:34,690 --> 00:22:38,730
Vi skulle också kunna göra det här om vi ville, det kan få lite otymplig

247
00:22:38,730 --> 00:22:41,300
i for-slingan deklarationer, jag ska lägga upp det här.

248
00:22:41,300 --> 00:22:48,840
Så int count = börjar 0.

249
00:22:48,840 --> 00:22:54,070
Och så nu, ska jag räkna hur många bokstäver som vi har haft.

250
00:22:54,070 --> 00:22:59,550
Så vi oundvikligen kommer att räkna + + eftersom vi hittat en annan bokstav.

251
00:22:59,550 --> 00:23:09,130
Men så nu du säger om greve mod 2.

252
00:23:09,130 --> 00:23:12,590
Så vad händer om räkna mod 2? Åh. Jag gör == 0 för nu.

253
00:23:12,590 --> 00:23:21,740
Vi kommer också att gå över det. Så om räkna mod 2 == 0, vad?

254
00:23:21,740 --> 00:23:27,830
[Studenter svar, obegripliga]

255
00:23:27,830 --> 00:23:32,750
Så vi vill att det ska sluta versaler.

256
00:23:32,750 --> 00:23:37,520
Det finns 2 fall, versaler och gemener är de 2 fallen.

257
00:23:37,520 --> 00:23:40,990
Så om vi är i gemener vi måste göra det versaler.

258
00:23:40,990 --> 00:23:43,710
Om det är versaler behöver vi inte göra någonting.

259
00:23:43,710 --> 00:23:50,760
Men, det finns ett sätt - shouldn't har vänt -

260
00:23:50,760 --> 00:23:54,800
att vi inte ens behöver kontrollera om det är versaler eller gemener?

261
00:23:54,800 --> 00:24:02,240
Vad kan vi göra för att alltid se till att vi alltid hamnar på versaler?

262
00:24:02,240 --> 00:24:07,830
Så märker vad vi gjorde för små "a", tänk om vi gjorde detta exakt samma sak till versaler A?

263
00:24:07,830 --> 00:24:11,900
Har versaler En förändring, eller har värdeförändringen?

264
00:24:11,900 --> 00:24:23,100
Ja. Så någon bokstav bitvis-behandlas med ~ 32 kommer att vara samma versala bokstäver

265
00:24:23,100 --> 00:24:29,220
eftersom det för varje versalt tecken den 32: a bit inte är satt.

266
00:24:29,220 --> 00:24:40,920
Så om vi vill ta tecknet s [i], vi vill att det ska bli gemener eller versaler.

267
00:24:40,920 --> 00:24:46,890
Så om det var små, är det nu versaler, om det var versaler, är det fortfarande versaler, och det är det.

268
00:24:46,890 --> 00:24:54,290
Jag sade detta i supersection: Du kan använda 32 om du vill, men jag brukar föredra att göra "en" - A,

269
00:24:54,290 --> 00:25:01,150
istället för att helt enkelt 32, eftersom det kan vara någon annan bit.

270
00:25:01,150 --> 00:25:03,610
Efter 32 bitar, kan det vara någon av dessa, eller skulle vi inte ha tillräckligt

271
00:25:03,610 --> 00:25:05,840
nummer för att representera alla tecken.

272
00:25:05,840 --> 00:25:09,110
Så om du får 32 bitar, kan det vara det 64 bitar, kan det vara det 128 bitar.

273
00:25:09,110 --> 00:25:13,990
Någon av dessa bitar kan vara lite som skiljer mellan versaler och gemener.

274
00:25:13,990 --> 00:25:18,350
Jag ska inte behöva veta att det är 32-bitars.

275
00:25:18,350 --> 00:25:27,130
Jag kan använda denna A - A för att få den bit som skiljer sig mellan de två

276
00:25:27,130 --> 00:25:33,000
utan att behöva förlita sig på det magiska numret som är 32.

277
00:25:33,000 --> 00:25:38,770
Och så nu, annars räkna var udda, och så vad vill jag göra?

278
00:25:38,770 --> 00:25:43,920
[Student svar, obegripligt]

279
00:25:43,920 --> 00:25:45,920
[Student] Vad är det?

280
00:25:45,920 --> 00:25:49,850
Jag kommer att göra det i 1 sekund.

281
00:25:49,850 --> 00:25:55,690
Så nu om jag vill - jag vill vara säker karaktären nu gemener,

282
00:25:55,690 --> 00:26:04,140
så jag kan eller med 32, och 32 betyder "en" - A.

283
00:26:04,140 --> 00:26:06,510
Men varsel av samma resonemang som den tidigare, att om

284
00:26:06,510 --> 00:26:11,670
brevet var redan gemener, sedan O-ring med 32 bara håller det gemener.

285
00:26:11,670 --> 00:26:16,220
Det har inte förändrats den ursprungliga karaktären.

286
00:26:16,220 --> 00:26:19,910
Men nu har jag inte undvika att säga, "Om det är gemener, bara glömma det,

287
00:26:19,910 --> 00:26:23,650
om det är versaler, sedan ändra det. "

288
00:26:23,650 --> 00:26:26,900
Det är mycket mer praktiskt att göra detta.

289
00:26:26,900 --> 00:26:33,190
[Student] Skulle denna strategi för att subtrahera versaler från gemena arbetet om det inte vore 32?

290
00:26:33,190 --> 00:26:35,330
Om det var, typ, 34 eller något?

291
00:26:35,330 --> 00:26:41,840
Så måste du veta att skillnaden mellan 2 är -? >> 1 bit.

292
00:26:41,840 --> 00:26:49,840
Det kan vara mer än 1 bit, så länge som alla bitarna under denna position är desamma.

293
00:26:49,840 --> 00:26:58,500
Så vi behöver minst 26 tecken - eller finns det 26 karaktärer.

294
00:26:58,500 --> 00:27:04,590
Så vi behöver minst 26 siffror för att representera skillnaden -

295
00:27:04,590 --> 00:27:07,650
Skillnaden mellan A och "a" måste vara minst 26,

296
00:27:07,650 --> 00:27:10,760
annars skulle vi inte ha representerade allt kapital nummer.

297
00:27:10,760 --> 00:27:18,630
Det innebär att A, om vi börjar med 1, det kommer att använda alla dessa bitar,

298
00:27:18,630 --> 00:27:23,900
alla dessa första 5 bitar, för att representera allt genom Z.

299
00:27:23,900 --> 00:27:32,170
Det är därför nästa bit, eller denna bit är nästa bit av en som är valt att skilja mellan A och "en".

300
00:27:32,170 --> 00:27:40,930
Det är också därför, i ASCII tabellen finns 5 symboler skiljer versaler från gemena bokstäver.

301
00:27:40,930 --> 00:27:49,050
Eftersom de är symboler, extra 5 som tar upp 32 är skillnaden mellan dem.

302
00:27:49,050 --> 00:27:51,840
[Student] så vi kunde göra det, eftersom ASCII är utformad på det sättet.

303
00:27:51,840 --> 00:27:57,280
Ja. Men ASCII - skillnaden kan också vara båda dessa bitar.

304
00:27:57,280 --> 00:28:12,040
Liksom, om A var 10000001, och "a" var 11100001 - jag glömmer, vad som helst.

305
00:28:12,040 --> 00:28:18,100
Men om det vore det, så skulle vi kunna fortfarande använda 'a' - A.

306
00:28:18,100 --> 00:28:22,650
Det är just nu skillnaden mellan A och "a" är fortfarande dessa 2 bitar.

307
00:28:22,650 --> 00:28:32,240
Jag tror att det är skrivet 48. Är det 32 ​​+ 64? Jag tror att det är?

308
00:28:32,240 --> 00:28:40,160
Det skulle fortfarande vara 2 bitar, varenda karaktär, liksom, Z och Z, K och K,

309
00:28:40,160 --> 00:28:45,160
De skulle fortfarande ha exakt samma bitar som med undantag för de 2 bitar.

310
00:28:45,160 --> 00:28:48,870
Så länge som det är alltid sant, oavsett om vi använder ASCII eller något annat system,

311
00:28:48,870 --> 00:28:53,050
så länge som det finns bara ett visst antal bitar som är olika för varje tecken,

312
00:28:53,050 --> 00:28:55,050
då fungerar bra.

313
00:28:55,050 --> 00:29:06,110
Det är bara det att 32 inrättades eftersom det är den första som vi skulle kunna använda. >> Cool.

314
00:29:06,110 --> 00:29:14,520
Jag brukar föredra, om du inte har sett, om blocket är bara en enda rad,

315
00:29:14,520 --> 00:29:24,280
Du kan bli av med klammerparenteser, så jag brukar föredra att göra detta.

316
00:29:24,280 --> 00:29:34,010
Dessutom, du vet hur vi kan göra saker som s [i] + = 1?

317
00:29:34,010 --> 00:29:41,090
Du kan också göra s [i] bitvis OCH = 32.

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

319
00:29:46,400 --> 00:29:51,490
Också räkna mod 2 == 0.

320
00:29:51,490 --> 00:30:00,900
Så kom ihåg att - Jag kommer inte skriva det - en icke-noll är sant, och 0 är falsk.

321
00:30:00,900 --> 00:30:07,880
Så "om count mod 2 == 0" är detsamma som att säga "om inte räkna mod 2."

322
00:30:07,880 --> 00:30:11,580
Jag förmodligen skulle ha precis vänt linjerna och sade: "Om greve mod 2,

323
00:30:11,580 --> 00:30:15,350
göra det eller 1, annars gör OCH 1 ", så att jag inte behöver" inte. "

324
00:30:15,350 --> 00:30:18,650
Men detta fungerar lika bra.

325
00:30:18,650 --> 00:30:25,660
Och vad kan jag göra här?

326
00:30:25,660 --> 00:30:29,060
Du kan kombinera dem med ternära om du ville, men då bara skulle göra det stökigare

327
00:30:29,060 --> 00:30:33,770
och förmodligen svårare att läsa, så vi inte kommer att göra det.

328
00:30:33,770 --> 00:30:37,330
Någon har några andra förslag?

329
00:30:37,330 --> 00:30:41,580
Är det allt problemet begärt? Oh yeah.

330
00:30:41,580 --> 00:30:51,070
Så bli av med dessa tomma rader, nu ska vi ut f,% s är den en för stråkar,

331
00:30:51,070 --> 00:30:56,620
Vi kommer att skriva ut F, S.

332
00:30:56,620 --> 00:30:59,330
Nu ska vi köra det. Gjorde jag något fel?

333
00:30:59,330 --> 00:31:03,200
Det är en \ ", jag vill ha en n..

334
00:31:03,200 --> 00:31:07,840
Okej. Nu ska vi köra det. Det kommer nog skrika på mig.

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

336
00:31:11,250 --> 00:31:14,290
Så detta är den fina klang är det talar om för dig vad det är i,

337
00:31:14,290 --> 00:31:19,140
istället för GCC som bara säger "Hej, du glömde något, jag vet inte vad det var."

338
00:31:19,140 --> 00:31:29,220
Men det kommer att säga mig: "Du menade att inkludera string.h."

339
00:31:29,220 --> 00:31:32,130
Så jag inte be om någonting, så det är inte att säga något.

340
00:31:32,130 --> 00:31:42,540
Men vi ska göra deras exempel, "Tack 4 tillägget".

341
00:31:42,540 --> 00:31:47,880
Det ser rätt. Hurra.

342
00:31:47,880 --> 00:31:52,370
Så återvänder till din huvudsakliga, jag nästan aldrig göra det.

343
00:31:52,370 --> 00:31:57,110
Det är valfritt. Och viktigaste är den enda funktionen för vilka det är frivilligt.

344
00:31:57,110 --> 00:32:07,140
Om du inte returnera något från huvud, det förutsätts att du tänkt att returnera 0.

345
00:32:07,140 --> 00:32:13,070
Frågor?

346
00:32:13,070 --> 00:32:20,980
Okej. Så nu det andra problemet.

347
00:32:20,980 --> 00:32:24,810
"Minns från vecka 2 andra föreläsning som byta 2 variabler värderingar genom att

348
00:32:24,810 --> 00:32:30,780
dessa 2 variabler till en funktion (även om kallas swap) inte exakt fungerar, åtminstone inte utan "pekare."

349
00:32:30,780 --> 00:32:37,020
Och ignorera pekare tills vi kommer till dem.

350
00:32:37,020 --> 00:32:40,070
Vi vill byta 2 variabler, vi inte använder en funktion för att göra det.

351
00:32:40,070 --> 00:32:43,410
Vi kommer fortfarande att göra det i huvud som det står.

352
00:32:43,410 --> 00:32:48,360
Men att använda dessa 2 variabler, vill vi inte att använda en temporär variabel.

353
00:32:48,360 --> 00:32:50,770
Det finns 2 sätt att göra detta.

354
00:32:50,770 --> 00:32:56,310
Du kan göra det med din traditionella binära operatorer.

355
00:32:56,310 --> 00:33:00,180
Så någon som vet en snabb och smutsig sätt att göra det?

356
00:33:00,180 --> 00:33:07,650
Det kan faktiskt ta en minut att tänka. Om jag har -

357
00:33:07,650 --> 00:33:12,130
Jag satt problemet upp som de frågar. Så om jag har 2 variabler, A, som bara är ett heltal

358
00:33:12,130 --> 00:33:17,800
att de ger mig och summa variabeln B, som är en annan heltal som jag gett.

359
00:33:17,800 --> 00:33:22,700
Så om jag har dessa 2 variabler, nu vill jag byta dem.

360
00:33:22,700 --> 00:33:31,550
Den traditionella, med dina vanliga binära operatorer, jag menar, liksom +, -, ÷.

361
00:33:31,550 --> 00:33:36,630
Inte bitvisa operatörer som verkar på binär.

362
00:33:36,630 --> 00:33:39,600
Så använder -, +, ÷, och alla de.

363
00:33:39,600 --> 00:33:52,980
Vi kunde byta genom att göra något som en = a + b, och b = a - b, a = a - b.

364
00:33:52,980 --> 00:34:04,260
Så förnuft kontrollera, och sedan får vi se varför det fungerar.

365
00:34:04,260 --> 00:34:13,320
Låt oss säga en = 7, B = 3, så a + b kommer att bli 10.

366
00:34:13,320 --> 00:34:18,820
Så vi nu sätta a = 10, och vi gör b = a - b.

367
00:34:18,820 --> 00:34:30,250
Så vi gör b = a - b, som kommer att bli 7, och b = a - b igen,

368
00:34:30,250 --> 00:34:38,650
eller en = a - b. Som kommer att vara 10 - 7, som är 3.

369
00:34:38,650 --> 00:34:44,850
Så nu, korrekt "a" var 7, b var 3, och nu b är 7 och "a" är 3.

370
00:34:44,850 --> 00:34:48,679
Så denna typ av vettigt, "a" är en kombination av de 2 siffror.

371
00:34:48,679 --> 00:34:53,000
Vid denna punkt, "a" är kombinationen, och sedan vi subtrahera ut den ursprungliga B,

372
00:34:53,000 --> 00:34:56,860
och då vi subtrahera ut vad som var den ursprungliga "ett".

373
00:34:56,860 --> 00:35:01,150
Men detta fungerar inte för alla nummer.

374
00:35:01,150 --> 00:35:08,880
För att se detta, låt oss betrakta ett system, så vi brukar tänka på heltal som 32 bitar.

375
00:35:08,880 --> 00:35:13,050
Låt oss arbeta med något som är bara som 4 bitar.

376
00:35:13,050 --> 00:35:15,450
Förhoppningsvis kommer jag fram till ett bra exempel just nu.

377
00:35:15,450 --> 00:35:18,680
Så, jag vet, det kommer att bli lätt.

378
00:35:18,680 --> 00:35:26,720
Låt oss säga att våra 2 siffror är 1111, och 1111, så vi är i binärt just nu.

379
00:35:26,720 --> 00:35:34,630
I verkliga decimaler, om du vill tänka på det på det sättet, a = 15 och b = 15.

380
00:35:34,630 --> 00:35:37,630
Och så vi förväntar oss, när vi byter dem - de inte ens vara samma siffror,

381
00:35:37,630 --> 00:35:41,140
men jag gjorde det här sättet.

382
00:35:41,140 --> 00:35:47,100
Låt oss göra dem inte samma siffror. Låt oss göra 1111 och 0001.

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

384
00:35:51,860 --> 00:35:57,670
Efter att vi byter dem räknar vi "a" vara 1 och b är 15.

385
00:35:57,670 --> 00:36:01,780
Så vår första steget är a = a + b.

386
00:36:01,780 --> 00:36:08,770
Våra siffror är bara 4 bitar bred, så "en", som är 1111, + b, som är 0001,

387
00:36:08,770 --> 00:36:16,780
kommer att hamna 10000, men vi har bara 4 bitar.

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

389
00:36:22,540 --> 00:36:34,080
Och nu vill vi ställa b = a - b - faktiskt, det fungerar fortfarande perfekt.

390
00:36:34,080 --> 00:36:39,630
a = a - b - låt oss se om detta fungerar perfekt.

391
00:36:39,630 --> 00:36:53,720
Så då b = 0 till 1, vilket fortfarande skulle vara 15, och sedan en = a - b, vilket skulle vara 1.

392
00:36:53,720 --> 00:36:56,210
Kanske detta fungerar.

393
00:36:56,210 --> 00:36:59,020
Jag tycker det finns en anledning det inte fungerar att använda vanlig.

394
00:36:59,020 --> 00:37:06,400
Okej, så arbetar utifrån antagandet att det inte fungerar med vanliga binära operationer,

395
00:37:06,400 --> 00:37:15,040
och jag kommer att leta efter - jag Google för att se om det är sant.

396
00:37:15,040 --> 00:37:23,490
Så vi vill göra det med hjälp av bitvisa operatörer och ledtråden här är XOR.

397
00:37:23,490 --> 00:37:28,780
Så inför XOR (^) om du inte har sett den ännu.

398
00:37:28,780 --> 00:37:34,610
Det är, återigen, en bitvis så det verkar bit för bit, och it's -

399
00:37:34,610 --> 00:37:39,910
Om du har bitarna 0 och 1, då detta kommer att vara 1.

400
00:37:39,910 --> 00:37:45,230
Om du har bitarna 1 och 0, det blir 1, har du bitarna 0 och 0 det ska vara 0,

401
00:37:45,230 --> 00:37:47,640
och om du har bitarna 1 och 1 det ska vara 0.

402
00:37:47,640 --> 00:37:56,180
Så det är som OR. Om någon av bitarna är sanna, är det 1, men till skillnad från ELLER, kan det inte vara båda bitar som är sanna.

403
00:37:56,180 --> 00:37:59,320
Eller skulle ha detta vara 1, skulle XOR ha detta vara 0.

404
00:37:59,320 --> 00:38:02,250
Så vi kommer att vilja använda XOR här.

405
00:38:02,250 --> 00:38:09,960
Tänk på det en minut, jag ska Google.

406
00:38:09,960 --> 00:38:16,230
Tja, du kan inte läsa det, jag är för närvarande på XOR swap algoritmen sidan.

407
00:38:16,230 --> 00:38:21,340
Förhoppningsvis kommer detta att förklara varför jag Värre -

408
00:38:21,340 --> 00:38:34,190
Detta är exakt den algoritm som vi just gjorde.

409
00:38:34,190 --> 00:38:37,330
Jag kan fortfarande inte se varför - Jag måste ha just plockat ett dåligt exempel,

410
00:38:37,330 --> 00:38:44,940
men det här fallet där a råkade bli 0, efter att få till 5 bitar, så nu "a" är 0,

411
00:38:44,940 --> 00:38:48,730
det är vad som kallas "heltalsspill."

412
00:38:48,730 --> 00:38:54,370
Enligt Wikipedia "Till skillnad från XOR swap, kräver denna variation som den använder vissa metoder

413
00:38:54,370 --> 00:38:59,780
att garantera att x + y inte orsakar en heltalsspill. "

414
00:38:59,780 --> 00:39:08,350
Så detta har problem, det var heltalsspill, men jag gjorde något fel.

415
00:39:08,350 --> 00:39:10,520
Jag är inte säker. Jag ska försöka komma med en annan.

416
00:39:10,520 --> 00:39:13,640
[Student] Tja, inte heltalsspill när du försöker sätta ett nummer i det

417
00:39:13,640 --> 00:39:16,640
större än mängden bitar du har tilldelat?

418
00:39:16,640 --> 00:39:23,730
Ja. Vi har 4 bitar. That - vi hade 4 bitar, vi sedan försöker lägga 1 till den, så vi sluta med 5 bitar.

419
00:39:23,730 --> 00:39:26,690
Men den femte biten bara blir avskurna, ja.

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

421
00:39:28,970 --> 00:39:33,010
[Student] kastar du ett fel eller gör det - skulle det kasta ett fel?

422
00:39:33,010 --> 00:39:40,720
Nej Så det finns inget fel. När du kommer till församlingen nivå, en speciell bit

423
00:39:40,720 --> 00:39:47,020
någonstans är satt som sagt det var ett spill, men i C du typ av bara inte hantera det.

424
00:39:47,020 --> 00:39:55,160
Du faktiskt inte kan hantera det om du använder speciella monteringsanvisningar i C.

425
00:39:55,160 --> 00:39:58,110
Låt oss tänka på XOR swap.

426
00:39:58,110 --> 00:40:02,220
Och jag tror Wikipediaartikeln också kan ha sagt att -

427
00:40:02,220 --> 00:40:07,310
Så det tog också upp modulär aritmetik, så jag antar att jag var i teorin gör modulär aritmetik

428
00:40:07,310 --> 00:40:11,160
När jag sa att 0 till 1 är 15 igen.

429
00:40:11,160 --> 00:40:15,410
Så det kan faktiskt - på en vanlig processor som gör 0 till 1 = 15.

430
00:40:15,410 --> 00:40:20,430
Eftersom vi hamna på 0, vi subtrahera 1, så då är det sveper precis tillbaka runt till 1111.

431
00:40:20,430 --> 00:40:28,930
Så denna algoritm kan faktiskt fungera, a + b, a - b, b - a, som kan vara bra.

432
00:40:28,930 --> 00:40:34,030
Men det finns vissa processorer som inte gör det, och så skulle det inte vara bra i dessa specifika sådana.

433
00:40:34,030 --> 00:40:39,880
XOR swap fungerar på alla datorer. Okej.

434
00:40:39,880 --> 00:40:42,280
Tanken är att det ska vara samma, dock.

435
00:40:42,280 --> 00:40:50,120
Där vi använder XOR att på något sätt få information om både i 1 av variablerna,

436
00:40:50,120 --> 00:40:54,120
och dra sedan ut information om de enskilda variablerna igen.

437
00:40:54,120 --> 00:41:04,330
Så har någon idéer / svaret?

438
00:41:04,330 --> 00:41:14,540
[Student svar, obegripligt]

439
00:41:14,540 --> 00:41:22,220
Så detta borde fungera, och dessutom är XOR kommutativ.

440
00:41:22,220 --> 00:41:27,620
Oavsett vilken ordning dessa 2 nummer råkar vara i upp här,

441
00:41:27,620 --> 00:41:30,100
detta resultat kommer att vara densamma.

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

443
00:41:35,800 --> 00:41:51,860
Du kan också se detta skrivs som en ^ = B, B ^ = a, a ^ = b igen.

444
00:41:51,860 --> 00:42:00,200
Så det här är rätt, och se varför det fungerar, tänk på bitarna.

445
00:42:00,200 --> 00:42:10,400
Med hjälp av en mindre antal, låt oss säga 11.001, och 01.100.

446
00:42:10,400 --> 00:42:12,790
Så detta är "ett", detta är b.

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

448
00:42:15,540 --> 00:42:22,380
Vi kommer att sätta "A" = till XOR dessa 2 saker.

449
00:42:22,380 --> 00:42:32,920
Så en ^ 0 är 1, 1 ^ 1 är 0, 0 ^ 1 är 1, och 0 ^ 0 är 0, 1 ^ 0 är 1.

450
00:42:32,920 --> 00:42:37,380
Så "a" om man tittar på decimaltal, det kommer att bli -

451
00:42:37,380 --> 00:42:41,160
du kommer inte att se mycket av en relation mellan den ursprungliga "a" och den nya "A"

452
00:42:41,160 --> 00:42:45,600
men titta på bitarna, "a" är nu som ett nät av information

453
00:42:45,600 --> 00:42:49,970
av både den ursprungliga "a" och den ursprungliga b..

454
00:42:49,970 --> 00:42:57,930
Så om vi tar b ^ a, ser vi att vi kommer att sluta på den ursprungliga "ett".

455
00:42:57,930 --> 00:43:08,910
Och om vi tar det ursprungliga "a" ^ den nya en, "vi ser att vi hamnar på den ursprungliga miljarder.

456
00:43:08,910 --> 00:43:18,380
Så (a ^ b) ^ b = den ursprungliga "ett".

457
00:43:18,380 --> 00:43:27,910
Och (a ^ b) ^ a = ursprunglig miljarder.

458
00:43:27,910 --> 00:43:37,010
Det är - ett annat sätt att se detta är något XOR själv är alltid 0.

459
00:43:37,010 --> 00:43:45,020
Så 1101 ^ 1101, är alla bitarna kommer att vara densamma.

460
00:43:45,020 --> 00:43:47,920
Så det aldrig kommer att bli ett fall där 1 är en 0 och den andra är 1.

461
00:43:47,920 --> 00:43:51,080
Så detta är 0000.

462
00:43:51,080 --> 00:43:57,240
Samma sak med det här. (A ^ b) ^ b är som en ^ (b ^ b).

463
00:43:57,240 --> 00:44:03,680
(B ^ b) kommer att vara 0, a ^ 0 är bara kommer att bli "en," eftersom alla bitar är 0.

464
00:44:03,680 --> 00:44:08,050
Så de enda som kommer att vara där "a" var ursprungligen en 1 - hade sådana.

465
00:44:08,050 --> 00:44:12,070
Och samma idé här, jag är ganska säker på att det är också kommutativ.

466
00:44:12,070 --> 00:44:17,590
Ja. Jag sa tidigare att det var kommutativ.

467
00:44:17,590 --> 00:44:24,680
Den ^ 'a' och det är associativ, så nu (b ^ a) ^ en.

468
00:44:24,680 --> 00:44:28,970
Och vi kan göra b ^ (a ^ a).

469
00:44:28,970 --> 00:44:31,540
Och så igen, får vi den ursprungliga miljarder.

470
00:44:31,540 --> 00:44:37,120
Så "a" är nu en kombination av "a" och b tillsammans.

471
00:44:37,120 --> 00:44:49,660
Med vår nya combo "a" säger vi b = combo 'a' ^ den ursprungliga B, får vi den ursprungliga "ett".

472
00:44:49,660 --> 00:45:05,170
Och nu a = combo "a" ^ den nya b, som var den ursprungliga - eller som nu vad som var "a" eller b.

473
00:45:05,170 --> 00:45:13,620
Det är detta fall här nere. Detta är = b, gamla B.

474
00:45:13,620 --> 00:45:16,550
Så nu är allt tillbaka i bytte ordning.

475
00:45:16,550 --> 00:45:22,960
Om vi ​​faktiskt tittat på bitarna, b = a ^ b, kommer att XOR dessa 2,

476
00:45:22,960 --> 00:45:33,920
och svaret kommer att bli det, och sedan en = a ^ b är XOR dessa 2 och svaret är.

477
00:45:33,920 --> 00:45:41,090
Frågor? Okej. Så den sista är något betydligt svårare.

478
00:45:41,090 --> 00:45:43,180
[Student] Jag tror att han har en fråga om det. >> Åh, förlåt.

479
00:45:43,180 --> 00:45:49,380
[Student] Vad är egentligen snabbare? Om du använder den här XOR, eller är det om du deklarerar en ny variabel?

480
00:45:49,380 --> 00:45:55,190
Så vad är egentligen snabbare, förklara en ny variabel eller använda XOR byta?

481
00:45:55,190 --> 00:45:59,600
Svaret är, med all sannolikhet en temporär variabel.

482
00:45:59,600 --> 00:46:05,780
Och det beror på att när det är sammanställt ner - så på montering nivå,

483
00:46:05,780 --> 00:46:12,320
det finns inget sådant som lokala variabler eller eventuella tillfälliga variabler eller någon av det här.

484
00:46:12,320 --> 00:46:16,060
De är precis som - det finns minne, och det finns register.

485
00:46:16,060 --> 00:46:20,920
Register är där saker aktivt händer.

486
00:46:20,920 --> 00:46:24,750
Du lägger inte 2 saker i minnet, du lägger 2 saker i register.

487
00:46:24,750 --> 00:46:28,160
Och du tar saker från minnet till register för att sedan lägga till dem,

488
00:46:28,160 --> 00:46:33,180
och då kanske du sätta tillbaka dem i minnet, men alla åtgärder sker i register.

489
00:46:33,180 --> 00:46:38,750
Så när du använder den temporära variabeln strategi oftast vad som händer är

490
00:46:38,750 --> 00:46:42,810
Dessa 2 siffror redan i register.

491
00:46:42,810 --> 00:46:46,570
Och sedan från den tidpunkten, efter att du har bytt dem,

492
00:46:46,570 --> 00:46:51,540
Det ska bara börja använda det andra registret.

493
00:46:51,540 --> 00:46:56,510
Var du hade använt b, det ska bara använda det register som redan lagra "en."

494
00:46:56,510 --> 00:47:02,180
Så det behöver inte göra något för att faktiskt göra swappen. Ja?

495
00:47:02,180 --> 00:47:05,690
[Student] Men det tar också mer minne, eller hur?

496
00:47:05,690 --> 00:47:10,280
Det kommer bara att ta mer minne om det behövs för att lagra den tillfälliga variabeln.

497
00:47:10,280 --> 00:47:14,830
Som om du senare använda den tillfälliga variabeln igen någonstans,

498
00:47:14,830 --> 00:47:18,920
då - eller du tilldela något som tillfälliga variabeln.

499
00:47:18,920 --> 00:47:24,630
Så om vid vilken tidpunkt som helst "a, 'b i temp har tydliga värderingar eller något,

500
00:47:24,630 --> 00:47:30,680
då det kommer att ha olika platser i minnet, men det är sant att

501
00:47:30,680 --> 00:47:34,800
Det finns många lokala variabler som bara kommer att finnas i register.

502
00:47:34,800 --> 00:47:44,370
I vilket fall är det aldrig i minnet, så att du aldrig slösar minne.

503
00:47:44,370 --> 00:47:58,620
Okej. Sista frågan är lite mer.

504
00:47:58,620 --> 00:48:04,850
Så här i CS50 apparat, det finns en ordlista.

505
00:48:04,850 --> 00:48:12,390
Och anledningen till detta är att [? B66] är en stavningskontroll där du ska skriva

506
00:48:12,390 --> 00:48:15,780
med hashtabeller eller försöker eller någon datastruktur.

507
00:48:15,780 --> 00:48:22,660
Du kommer att skriva en stavningskontroll, och du kommer att använda denna ordbok för att göra det.

508
00:48:22,660 --> 00:48:28,280
Men för detta problem kommer vi bara att se upp för att se om ett enda ord i ordlistan.

509
00:48:28,280 --> 00:48:31,250
Så istället för att lagra hela ordlistan i någon datastruktur

510
00:48:31,250 --> 00:48:35,180
och sedan tittar över ett helt dokument för att se om något är felstavat,

511
00:48:35,180 --> 00:48:38,490
Vi vill bara hitta 1 ord. Så vi kan bara skanna över hela ordlistan

512
00:48:38,490 --> 00:48:44,300
och om vi inte hittar ordet i hela ordboken, så det var inte där.

513
00:48:44,300 --> 00:48:52,150
Om vi ​​skannar över hela ordboken och ser ordet, då vi är bra, vi fann det.

514
00:48:52,150 --> 00:48:56,580
Det står här att vi vill börja titta på C: s fil-hantering funktion,

515
00:48:56,580 --> 00:48:59,930
eftersom vi vill läsa ordlistan,

516
00:48:59,930 --> 00:49:07,680
men jag kommer att ge tipset här om vilka funktioner som du bör tänka på.

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

518
00:49:11,510 --> 00:49:20,490
Så de viktigaste du vill titta på är f öppet och sedan oundvikligen stängt f,

519
00:49:20,490 --> 00:49:26,540
som kommer att gå i slutet av ditt program, och f Scan f..

520
00:49:26,540 --> 00:49:31,060
Du kan också använda f läsa, men du förmodligen inte vill

521
00:49:31,060 --> 00:49:34,200
eftersom det - du inte sluta behöver det.

522
00:49:34,200 --> 00:49:41,880
F Scan f är vad du ska använda för att skanna över ordboken.

523
00:49:41,880 --> 00:49:46,370
Och så du behöver inte koda upp lösningen, bara försöka och vilja pseudokod ditt sätt

524
00:49:46,370 --> 00:50:05,200
till en lösning, och sedan kommer vi att diskutera det.

525
00:50:05,200 --> 00:50:14,110
Och faktiskt, eftersom jag redan gett er dessa, om du går in i någon terminal eller din apparat skal,

526
00:50:14,110 --> 00:50:18,250
Jag skulle - jag brukar - om du inte har sett ännu, jag vet inte om du gjorde i klassen,

527
00:50:18,250 --> 00:50:23,490
men människan, så man-sidorna, är ganska bra för att titta på ganska mycket varje funktion.

528
00:50:23,490 --> 00:50:27,330
Så jag kan göra, vill, man f, skanna f..

529
00:50:27,330 --> 00:50:32,300
Detta är nu information om genomsökningen f familjen av funktioner.

530
00:50:32,300 --> 00:50:37,070
Jag kan också göra MAN F, öppna, och det ger mig de detaljer i denna.

531
00:50:37,070 --> 00:50:40,750
Så om du vet vilken funktion du använder, eller du läser koden

532
00:50:40,750 --> 00:50:43,000
och du se några funktionen och du är som, "Vad gör det då?"

533
00:50:43,000 --> 00:50:45,280
Bara mannen som funktionsnamn.

534
00:50:45,280 --> 00:50:47,340
Det finns ett par konstiga exempel där du kanske måste säga

535
00:50:47,340 --> 00:50:51,620
liknande. Man 2 som fungerar namn, eller man 3 som funktionsnamn,

536
00:50:51,620 --> 00:50:58,230
men du behöver bara göra det om människan funktionsnamn inte råkar arbeta för första gången.

537
00:50:58,230 --> 00:51:03,010
[Student] Så jag läser mansidan för öppet, men jag är fortfarande förvirrad om hur man använder det och programmet.

538
00:51:03,010 --> 00:51:06,170
Okej. En hel del av man-sidor är mindre än hjälpsamma.

539
00:51:06,170 --> 00:51:08,470
De är mer användbar om du redan vet vad de gör

540
00:51:08,470 --> 00:51:12,670
och då behöver du bara komma ihåg ordningen på argument eller något.

541
00:51:12,670 --> 00:51:17,640
Eller de kan ge dig en allmän översikt, men några av dem är mycket överväldigande.

542
00:51:17,640 --> 00:51:22,220
Liksom f Scan f, också. Det ger dig information om alla dessa funktioner,

543
00:51:22,220 --> 00:51:28,120
och 1 rad här nere råkar säga "F Scan f läser ur strängen punkt eller ström."

544
00:51:28,120 --> 00:51:32,360
Men f öppna. Så, hur skulle vi använda f öppen?

545
00:51:32,360 --> 00:51:38,470
Idén om ett program som behöver göra fil I / O är att

546
00:51:38,470 --> 00:51:45,070
måste du först öppna filen du vill göra saker med, och oundvikligen,

547
00:51:45,070 --> 00:51:51,220
Läs saker från den filen och göra saker med dem.

548
00:51:51,220 --> 00:51:55,350
F öppet är vad vi använder för att öppna filen.

549
00:51:55,350 --> 00:52:04,190
Det vi får tillbaka, så vad fil vill vi öppna, det ger oss -

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

551
00:52:11,970 --> 00:52:16,740
Detta är den fil som vi vill öppna, och vi vill öppna den -

552
00:52:16,740 --> 00:52:21,440
Vi måste uttryckligen ange om vi vill öppna den för att läsa eller om vi vill öppna den för att skriva.

553
00:52:21,440 --> 00:52:26,490
Det finns ett par kombinationer och sånt, men vi vill öppna detta för läsning.

554
00:52:26,490 --> 00:52:29,380
Vi vill läsa från filen.

555
00:52:29,380 --> 00:52:34,290
Så vad gör detta tillbaka? Den returnerar en fil stjärna (*),

556
00:52:34,290 --> 00:52:37,260
och jag ska bara visa allt i variabeln f, så *

557
00:52:37,260 --> 00:52:40,840
igen, det är en pekare, men vi vill inte ta itu med pekare.

558
00:52:40,840 --> 00:52:46,470
Du kan tänka på f som är f nu variabel du ska använda för att representera filen.

559
00:52:46,470 --> 00:52:49,850
Så om du vill läsa från filen, du läste från F.

560
00:52:49,850 --> 00:52:54,820
Om du vill stänga filen stänger du f..

561
00:52:54,820 --> 00:53:00,350
Så i slutet av programmet när vi oundvikligen vill stänga filen, vad ska vi göra?

562
00:53:00,350 --> 00:53:06,750
Vi vill avsluta f..

563
00:53:06,750 --> 00:53:12,600
Så nu den sista filen funktion som vi kommer att vilja använda scan f, f Scan f..

564
00:53:12,600 --> 00:53:20,930
Och vad som gör det skannar över filen söker ett mönster för att matcha.

565
00:53:20,930 --> 00:53:39,100
Man tittar på man-sidan här ser vi int f Scan f, ignorera returvärdet för nu.

566
00:53:39,100 --> 00:53:45,230
Det första argumentet är filen * ström, så det första argumentet ska vi vill passera är f.

567
00:53:45,230 --> 00:53:47,900
Vi skannar över f..

568
00:53:47,900 --> 00:53:53,680
Det andra argumentet är en formatsträng.

569
00:53:53,680 --> 00:53:58,310
Jag kommer att ge dig en formatsträng just nu.

570
00:53:58,310 --> 00:54:05,180
Jag tror att vi råkar säga 127s \ n, en hel del som är onödigt.

571
00:54:05,180 --> 00:54:12,490
Tanken på vad det formatsträng är, du kan tänka på Scan f som motsatsen till utskriften f..

572
00:54:12,490 --> 00:54:17,160
Så utskrift f, skriva ut f vi också använda denna typ av format parameter,

573
00:54:17,160 --> 00:54:25,000
men i tryck f. vad vi gör är - låt oss titta på motsvarande.

574
00:54:25,000 --> 00:54:32,550
Så ut f, och det finns faktiskt också F Skriv ut F, där det första argumentet kommer att bli f..

575
00:54:32,550 --> 00:54:40,980
När du skriver ut f, kan vi säga något i stil med "tryck 127s \ n" och sedan om vi passerar det några sträng,

576
00:54:40,980 --> 00:54:44,050
det kommer att skriva ut den här strängen och sedan en ny rad.

577
00:54:44,050 --> 00:54:49,690
Vad 127 betyder, jag är ganska säker, men jag har aldrig begränsat mig till det,

578
00:54:49,690 --> 00:54:52,470
Du skulle inte ens behöva säga '127 'i den tryckta f,

579
00:54:52,470 --> 00:54:57,090
men vad det betyder är ut de första 127 tecknen.

580
00:54:57,090 --> 00:54:59,350
Så jag är ganska säker på att det är fallet. Du kan Google för det.

581
00:54:59,350 --> 00:55:03,000
Men i nästa är jag nästan säker det innebär att.

582
00:55:03,000 --> 00:55:08,880
Så detta är skriva de första 127 tecknen, följt av en ny rad.

583
00:55:08,880 --> 00:55:14,680
F skanna f nu, i stället för att titta på en variabel och skriva ut det,

584
00:55:14,680 --> 00:55:22,620
det kommer att titta på några sträng och lagra mönstret i variabeln.

585
00:55:22,620 --> 00:55:26,360
Låt oss verkligen använda Scan f i en annan exempel.

586
00:55:26,360 --> 00:55:31,670
Så låt oss säga att vi hade en del int, x = 4,

587
00:55:31,670 --> 00:55:41,110
och vi ville skapa en sträng gjord av - ville skapa strängen

588
00:55:41,110 --> 00:55:44,250
det var som detta kommer upp långt senare,

589
00:55:44,250 --> 00:55:49,020
något som är precis som 4.jpg.

590
00:55:49,020 --> 00:55:51,870
Så detta kan vara ett program där du kommer att ha summan räknare,

591
00:55:51,870 --> 00:55:56,420
Sammanfattningsvis motverka i, och du vill spara en massa bilder.

592
00:55:56,420 --> 00:56:02,430
Så du vill spara i.jpg, där i är lite upprepning av din slinga.

593
00:56:02,430 --> 00:56:05,500
Så hur gör vi här strängen för den JPEG?

594
00:56:05,500 --> 00:56:11,720
Om du vill skriva ut 4.jpg, kan vi bara säga print f,% d.jpg,

595
00:56:11,720 --> 00:56:14,410
och då skulle det skrivas ut för den JPEG.

596
00:56:14,410 --> 00:56:20,050
Men om vi vill spara strängen 4.jpg använder vi skanna f..

597
00:56:20,050 --> 00:56:30,860
Så sträng s - faktiskt vi Värre - tecken, röding s, låt oss gå 100.

598
00:56:30,860 --> 00:56:35,400
Så jag förklarade bara några rad 100 tecken,

599
00:56:35,400 --> 00:56:39,830
och det är vad vi oundvikligen kommer att lagra den JPEG i.

600
00:56:39,830 --> 00:56:47,920
Så vi kommer att använda skanna f och formatet, hur vi skulle säga% d.jpg

601
00:56:47,920 --> 00:56:54,980
För att skriva ut 4.jpg är formatet av denna kommer att vara% d.jpg.

602
00:56:54,980 --> 00:57:04,020
Så formatet är% d.jpg, vad vi vill ersätta% d med är x,

603
00:57:04,020 --> 00:57:06,590
och nu måste vi lagra den strängen någonstans.

604
00:57:06,590 --> 00:57:12,500
Och där kommer vi att lagra denna sträng är i arrayen är.

605
00:57:12,500 --> 00:57:21,640
Så efter denna kodrad, s, om vi skriver ut f,% s av den rörliga s,

606
00:57:21,640 --> 00:57:26,280
det kommer att skriva ut 4.jpg.

607
00:57:26,280 --> 00:57:38,930
Så f Scan f är samma som Scan f, förutom nu det ser över den här filen

608
00:57:38,930 --> 00:57:43,600
för vad som ska lagras i talet.

609
00:57:43,600 --> 00:57:46,160
Det är vad det sista argumentet kommer att bli.

610
00:57:46,160 --> 00:57:54,170
Vi vill lagra - "Scan f familjen av funktioner skannar både enligt format som provat nedan.

611
00:57:54,170 --> 00:58:02,450
Om någon är lagrade på platsen poäng du kan återvända - "

612
00:58:02,450 --> 00:58:12,910
Nej, vi kanske vara bra. Låt mig tänka för en sekund.

613
00:58:12,910 --> 00:58:26,350
Så scan f inte - vad sjutton är den funktion som gör det?

614
00:58:26,350 --> 00:58:31,650
Så scan f inte kommer att ta ett heltal och göra punkt jpg.

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

616
00:58:43,490 --> 00:58:49,360
Spara int variabel i sträng int C

617
00:58:49,360 --> 00:58:55,940
Vad är denna variabel, eller vad är denna funktion som kallas?

618
00:58:55,940 --> 00:59:04,950
Ja. That - ja. Så vad jag definierar till dig innan var S Skriv ut f,

619
00:59:04,950 --> 00:59:09,820
vilket - som är mycket vettigare, varför jag sa att det var mycket mer som print f..

620
00:59:09,820 --> 00:59:14,700
Scan f är fortfarande ungefär som print f, men S Skriv ut f kommer att skanna det över

621
00:59:14,700 --> 00:59:17,510
och ersätta variablerna och nu lagra den i en sträng.

622
00:59:17,510 --> 00:59:19,620
Istället för att skriva ut den, lagrar den i en sträng.

623
00:59:19,620 --> 00:59:25,070
Så ignorera det helt. Du kan fortfarande tänka på formatet föreskrivaren som likt utskrift f..

624
00:59:25,070 --> 00:59:34,510
Så nu, om vi ville göra 4.jpg sak, skulle vi göra S Skriv ut f, x av detta.

625
00:59:34,510 --> 00:59:38,520
Så vad Scan f gör - vad din fråga kommer att bli?

626
00:59:38,520 --> 00:59:40,820
[Student] Jag är bara förvirrad på vad vi försöker göra här

627
00:59:40,820 --> 00:59:43,450
med den JPEG. Kan du förklara det 1 gång?

628
00:59:43,450 --> 00:59:52,710
Så detta var - det är mindre relevent att f skanna f. nu, förhoppningsvis kommer det knyta tillbaka i någon form av väg.

629
00:59:52,710 --> 01:00:02,240
Men vad jag ursprungligen hade för avsikt att visa var - detta är faktiskt direkt relevans för dessa [? F5]

630
01:00:02,240 --> 01:00:08,520
Du kommer att använda S Skriv ut f, där säger att vi har 100 bilder,

631
01:00:08,520 --> 01:00:13,630
och du vill läsa bild 1.jpg, 2.jpg, 3.jpg.

632
01:00:13,630 --> 01:00:21,520
Så för att göra det måste du f öppna och då måste man passera i strängen som du vill öppna.

633
01:00:21,520 --> 01:00:30,020
Så vi skulle vilja öppna 1.jpg, för att skapa den sträng som är 1.jpg,

634
01:00:30,020 --> 01:00:37,660
vi S Skriv ut f av% d.jpg--vi inte göra för 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 Skriv ut f% d.jpg av i.

637
01:00:51,130 --> 01:00:56,320
Så efter denna linje, nu variabel eller matrisen s kommer att 1.jpg.

638
01:00:56,320 --> 01:01:10,610
Eller 0.jpg, 1.jpg, 2.jpg. Och så att vi kan öppna i sin tur varje bild för läsning.

639
01:01:10,610 --> 01:01:19,550
Så det är vad S Skriv ut f. gör. Ser du vad han skriver ut f nu gör?

640
01:01:19,550 --> 01:01:25,720
[Student] Okej, så det tar - det skapar en sträng, something.jpg och sedan lagrar det.

641
01:01:25,720 --> 01:01:30,360
Ja. Det skapar - det är en annan formatsträng, precis som Scan f och skriv ut f,

642
01:01:30,360 --> 01:01:37,530
där det infogas alla variabler i det andra argumentet, kan vara s i motsats till i..

643
01:01:37,530 --> 01:01:42,280
Kanske - jag menar, det är fallet. Men oavsett ordningen av argument är.

644
01:01:42,280 --> 01:01:45,440
Det kommer att sätta alla variabler i formatsträngen

645
01:01:45,440 --> 01:01:52,250
och sedan lagra i vår buffert, vi kallar det en buffert, det där vi lagrar strängen.

646
01:01:52,250 --> 01:02:00,750
Så vi lagrar inuti är den riktigt-formaterad sträng, efter% d ersatts med 4.

647
01:02:00,750 --> 01:02:08,080
[Student] Så om vi gjorde detta är den rörliga f bara kommer att bli omplacerad?

648
01:02:08,080 --> 01:02:18,110
Ja. Så vi bör stänga ursprungliga f innan du gör detta.

649
01:02:18,110 --> 01:02:22,810
Men - och sedan också, om det inte fanns en f öppna här, då skulle vi behöva säga -

650
01:02:22,810 --> 01:02:29,280
Ja. Men det skulle öppna en hundra olika filer.

651
01:02:29,280 --> 01:02:37,360
[Student] Men vi skulle inte kunna komma åt eller - okej.

652
01:02:37,360 --> 01:02:44,230
Okej. Så skanna f, f Scan f, är typ av samma idé,

653
01:02:44,230 --> 01:02:53,610
men i stället för, istället för att lagra det i en sträng, är det mer som du är nu

654
01:02:53,610 --> 01:03:02,420
gå över ett sting och mönstermatchning mot den sträng och lagrar resultaten i variablerna.

655
01:03:02,420 --> 01:03:11,290
Du kan använda Scan f för att tolka över något som 4.jpg, och lagra heltal 4 till X summan int.

656
01:03:11,290 --> 01:03:13,430
Det är vad vi kan använda Scan f för.

657
01:03:13,430 --> 01:03:16,300
F skanna f kommer att göra det på kommandoraden.

658
01:03:16,300 --> 01:03:19,200
Jag är faktiskt ganska säker på att detta är vad CS50 biblioteket gör.

659
01:03:19,200 --> 01:03:29,050
Så när du säger "få int," det är Scan f-ing över - scan f är hur du får indata.

660
01:03:29,050 --> 01:03:34,670
F skanna f kommer att göra samma sak, men med hjälp av en fil för att skanna över.

661
01:03:34,670 --> 01:03:41,090
Så här är vi skannar över denna fil.

662
01:03:41,090 --> 01:03:45,460
Mönstret vi försöker matcha en viss sträng som är 127 tecken långt

663
01:03:45,460 --> 01:03:48,100
följt av en ny linje

664
01:03:48,100 --> 01:03:54,770
Så jag är ganska säker på att vi skulle till och med bara säga "matcha s" eftersom ordlistan

665
01:03:54,770 --> 01:03:57,770
Vi råkar ha, vi garanterat inget ord är så länge,

666
01:03:57,770 --> 01:04:03,310
och även f scan f, tror jag, kommer att stanna vid den nya linjen oavsett vad.

667
01:04:03,310 --> 01:04:06,970
Men vi inkludera den nya linjen i matchen, och -

668
01:04:06,970 --> 01:04:13,960
[Student] Om vi ​​inte inkludera den nya linjen, skulle det inte finna delar av ett ord?

669
01:04:13,960 --> 01:04:22,900
Det - varje - att titta på ordlistan -

670
01:04:22,900 --> 01:04:26,200
Så i ordboken, dessa är alla våra ord.

671
01:04:26,200 --> 01:04:30,500
Var och en är på en ny rad.

672
01:04:30,500 --> 01:04:32,510
Skanningen f kommer att plocka upp detta ord.

673
01:04:32,510 --> 01:04:38,750
Om vi ​​inte inkluderar den nya linjen, då är det möjligt att nästa scan f bara kommer att läsa den nya linjen.

674
01:04:38,750 --> 01:04:44,180
Men inklusive nya linjen kommer då att bara ignorera den nya linjen.

675
01:04:44,180 --> 01:04:49,440
Men vi kommer aldrig att få del av ett ord, eftersom vi alltid läser upp till en ny rad, oavsett vad.

676
01:04:49,440 --> 01:04:54,530
[Student] Men om du söker efter ordet "cissa," som cissa.

677
01:04:54,530 --> 01:04:57,380
Kommer det att hitta det, och säger att det är en match?

678
01:04:57,380 --> 01:05:05,110
Så här är vi - det kommer att läsa i - det är faktiskt en bra poäng.

679
01:05:05,110 --> 01:05:10,660
Vi kommer aldrig att använda den nuvarande - ordet vi letar efter är den första kommandoraden argument.

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

681
01:05:16,460 --> 01:05:20,020
Så strängen vi letar efter är argv 1.

682
01:05:20,020 --> 01:05:23,290
Vi är inte ute efter ett ord på alla i vår scan f..

683
01:05:23,290 --> 01:05:28,030
Vad vi gjorde med Scan f blir varje ord i ordlistan,

684
01:05:28,030 --> 01:05:34,320
och sedan när vi har det ord vi ska använda strcmp att jämföra dem.

685
01:05:34,320 --> 01:05:39,210
Vi kommer att jämföra vårt ord och vad vi just läst i.

686
01:05:39,210 --> 01:05:45,110
Så oundvikligen kommer vi att hamna gör en massa skanning fs

687
01:05:45,110 --> 01:05:52,130
tills det råkar vara så att skanning f kommer tillbaka -

688
01:05:52,130 --> 01:05:54,800
det kommer att återvända en, så länge som det har matchade ett nytt ord,

689
01:05:54,800 --> 01:06:01,360
och det kommer tillbaka något annat så snart den har misslyckats med att matcha ord.

690
01:06:01,360 --> 01:06:08,440
Vi läser hela ordboken, lagring rad för rad varje ord i den variabla talet.

691
01:06:08,440 --> 01:06:17,240
Sedan vi jämför ord med s, och om jämförelsen == 0,

692
01:06:17,240 --> 01:06:21,650
strcmp råkar få 0 om en match gjordes.

693
01:06:21,650 --> 01:06:31,510
Så om det var 0, då kan vi trycka f, matchas,

694
01:06:31,510 --> 01:06:35,370
eller ord i ordlistan, eller vad du vill skriva ut f..

695
01:06:35,370 --> 01:06:41,450
Och sedan - vi vill inte f Stäng om och om igen.

696
01:06:41,450 --> 01:06:50,410
Detta är den typ av sak vi vill göra, och vi är inte bara ute efter ord i ordboken.

697
01:06:50,410 --> 01:06:56,660
Så vi kunde göra det, om vi ville söka sin mönster, cissa, som du sa tidigare,

698
01:06:56,660 --> 01:07:00,260
om vi ville titta efter det mönstret, då det skulle misslyckas i fallet

699
01:07:00,260 --> 01:07:08,010
eftersom det är faktiskt inte ett ord, men ett av orden i ordlistan råkar ha det i den.

700
01:07:08,010 --> 01:07:13,560
Så det skulle matcha detta ord, men denna del av ordet är inte ett ord i sig.

701
01:07:13,560 --> 01:07:17,250
Men det är inte hur vi använder den, vi läser i varje ord

702
01:07:17,250 --> 01:07:19,740
och sedan jämföra ordet vi har med det ordet.

703
01:07:19,740 --> 01:07:25,780
Så vi alltid jämföra hela ord.

704
01:07:25,780 --> 01:07:29,620
Jag kan skicka ut de färdiga lösningarna senare.

705
01:07:29,620 --> 01:07:32,050
Detta är typ nästan rätt svar, tror jag.

706
01:07:32,050 --> 01:07:34,720
[Student kommentar, obegripligt]

707
01:07:34,720 --> 01:07:40,870
Åh, jag bli av med det innan? Char s, jag antar att vi sa 127 - Jag glömmer vad den största är.

708
01:07:40,870 --> 01:07:44,100
Vi ska bara göra 128, så nu s är tillräckligt lång.

709
01:07:44,100 --> 01:07:46,570
Vi behöver inte skriva ut något.

710
01:07:46,570 --> 01:07:56,440
Vi kommer även att vilja måste stänga vår fil och det bör vara ungefär rätt svar.

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