1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] Szakasz Probléma Set 2: Hacker Edition

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

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

4
00:00:07,410 --> 00:00:15,770
Szóval, én vagyok Rob. Én vagyok a rangidős a Kirkland. Ez a harmadik év TFing CS50.

5
00:00:15,770 --> 00:00:22,220
Ez az első alkalom, hogy mi változik a hagyományos előadás stílusú szakasz,

6
00:00:22,220 --> 00:00:25,610
ahol csak egyfajta értékelést mi történt Előadás és akkor srácok kérdéseket feltenni,

7
00:00:25,610 --> 00:00:32,250
Most, hogy egy sokkal nagyobb probléma-alapú, ahol az általunk használt Spaces, és -

8
00:00:32,250 --> 00:00:37,410
Ó, tehát az ötlet, hogy megy, hogy a linket, amit küldtem, és akkor te leszel az én Space.

9
00:00:37,410 --> 00:00:42,410
Van valakinek nincs laptop? Oké.

10
00:00:42,410 --> 00:00:47,050
Szóval lesz ezzel, és mi lesz ennek problémák él szakaszban

11
00:00:47,050 --> 00:00:50,740
és megvitatása, és kitalálni, hogy mi a baj

12
00:00:50,740 --> 00:00:56,390
és én is húzza fel néhány kódot, és talán beszélni ötleteit.

13
00:00:56,390 --> 00:01:02,140
Így már valaki nehezen?

14
00:01:02,140 --> 00:01:07,000
A chat oldalán, én nem tudom, ha mi lesz oka.

15
00:01:07,000 --> 00:01:12,270
Most, mint az előző szuperszakasz, ha voltak az osztályban, tudod, hogy mit szól.

16
00:01:12,270 --> 00:01:19,200
Az összes P sorozat ott lesz ezeket a részeket.

17
00:01:19,200 --> 00:01:22,550
Tehát P-set 2, leírások, azt hiszem, láttam azt a P-set 1 már.

18
00:01:22,550 --> 00:01:27,400
De nézd meg a P-set 2, amit mi lesz megy át ma.

19
00:01:27,400 --> 00:01:29,460
És akkor megjelenik egy részét kérdésekre.

20
00:01:29,460 --> 00:01:37,530
Szóval ez lesz az összes P-készletek, ott lesz egy szakasza kérdésekre.

21
00:01:37,530 --> 00:01:41,340
Eddig is azt mondta: "Érdemes ezt a lehetőséget a gyakorlásra."

22
00:01:41,340 --> 00:01:44,940
Önnek nem kell kérni, hogy nyújtson be ezt a programot.

23
00:01:44,940 --> 00:01:48,480
Az elképzelés az, hogy ezeket állítólag a fajta segít elindulni a probléma set.

24
00:01:48,480 --> 00:01:53,220
Azt hiszem, a Hacker kiadás, sokan feltételezik, hogy csak az új, érdekes dolgokat tanulni.

25
00:01:53,220 --> 00:01:58,590
Lehet, hogy nem közvetlenül alkalmazható a probléma halmaz.

26
00:01:58,590 --> 00:02:01,810
És most nem vagyunk tekintettel elküldte őket, de elméletben,

27
00:02:01,810 --> 00:02:07,480
a későbbi probléma készletek, lehet, hogy be őket, és így akkor sem jön szakasza

28
00:02:07,480 --> 00:02:10,380
vagy nézze meg a szakasz, hogy a választ, vagy ha csak kapni őket a saját

29
00:02:10,380 --> 00:02:16,350
Ha nincs kedve élvezem én jelenlétemben.

30
00:02:16,350 --> 00:02:21,010
Tehát az - azt hiszem, ez az első.

31
00:02:21,010 --> 00:02:29,280
Oh. Továbbá, az e szakaszok kérdéseket mi is kérdezed kérdések a rövidnadrág.

32
00:02:29,280 --> 00:02:33,440
Szóval azt hiszem, elméletileg kéne nézni ezeket mielőtt szakasz,

33
00:02:33,440 --> 00:02:38,550
de ez rendben van, ha nem, akkor menjen át őket.

34
00:02:38,550 --> 00:02:42,590
Tehát lehet kezdeni ezekkel: "Hogyan tud egy while különbözik a do-while ciklus?

35
00:02:42,590 --> 00:02:46,210
Amikor ez utóbbi különösen hasznos? "

36
00:02:46,210 --> 00:02:49,390
Tehát bárki bármilyen -?

37
00:02:49,390 --> 00:02:52,730
[Student] A do-while ciklus mindig végrehajtja legalább egyszer.

38
00:02:52,730 --> 00:03:02,950
Igen. Annak érdekében, hogy ez a különbség. A while ciklus - I'll just do it itt - while, megvan a feltétel

39
00:03:02,950 --> 00:03:19,760
itt, mivel a do-while, nincs feltétel, amíg gyere le ide.

40
00:03:19,760 --> 00:03:24,130
És így, amikor a program végrehajtása, és ez lesz a while ciklus,

41
00:03:24,130 --> 00:03:26,380
azonnal ellenőrzi, ha ez a feltétel teljesül.

42
00:03:26,380 --> 00:03:30,710
Amennyiben ez a feltétel nem igaz, akkor ugorja át a hurok teljesen.

43
00:03:30,710 --> 00:03:34,390
Do-while ciklus, a program fut, ez lesz a "nem".

44
00:03:34,390 --> 00:03:37,920
Semmi sem történik ezen a ponton, csak folytatja végrehajtó.

45
00:03:37,920 --> 00:03:42,690
Akkor, amikor eléri a "míg" ha a feltétel igaz, akkor az loop vissza, és újra meg újra

46
00:03:42,690 --> 00:03:46,730
és újra és újra, amíg a feltétel nem igaz, és majd csak esik át.

47
00:03:46,730 --> 00:03:50,600
Szóval, a különbség, hogy ez kihagyhatja már a kezdetektől.

48
00:03:50,600 --> 00:03:56,770
Ez szükségképpen végrehajtja egyszer majd végezhetnek több alkalommal, ha a feltétel mindig igaz.

49
00:03:56,770 --> 00:04:03,720
Tehát a while ciklus csak csinálni egyszer, vagy - a while ciklus -, akkor nem kell csinálni egyáltalán,

50
00:04:03,720 --> 00:04:07,900
hiszen amint megkapjuk hozzá, ha a feltétel hamis, akkor ugorja át jobbra rajta.

51
00:04:07,900 --> 00:04:11,770
Mivel a do-while ciklus, akkor végre egyszer, feltétlenül.

52
00:04:11,770 --> 00:04:14,560
Aztán, amikor eljutunk a feltételt, akkor ellenőrizze, ha ez igaz, vagy hamis.

53
00:04:14,560 --> 00:04:19,790
Ha ez igaz, akkor csináld újra, ha ez hamis, akkor csak tovább megy.

54
00:04:19,790 --> 00:04:24,680
Tehát, ha ez utóbbi különösen hasznos?

55
00:04:24,680 --> 00:04:31,190
Szóval azt lehet mondani, hogy a teljes egészében a 4 év, 3 ​​év, mindegy,

56
00:04:31,190 --> 00:04:38,780
hogy én már programozás, már használta ezt, mint például, a 10-szer.

57
00:04:38,780 --> 00:04:43,140
És valószínűleg 5 őket itt CS50 mikor vagyunk bevezetése do-while ciklusok.

58
00:04:43,140 --> 00:04:47,510
Szóval mikor használják do-while ciklusok?

59
00:04:47,510 --> 00:04:49,510
Mikor van a - igen?

60
00:04:49,510 --> 00:04:53,180
[Student] Amikor megpróbál felhasználói bevitel, vagy valami az ellenőrizni kívánt -

61
00:04:53,180 --> 00:04:59,700
Igen. Tehát nem-while ciklusok, felhasználói a nagy.

62
00:04:59,700 --> 00:05:03,160
Ezért az első pár problémát készletek, ha azt szeretné, hogy kérje meg a felhasználót, mint például,

63
00:05:03,160 --> 00:05:08,520
"Adj egy string", akkor nem tudja folytatni, amíg nem kap, hogy a string.

64
00:05:08,520 --> 00:05:12,980
És így, szükségszerűen meg kell kérni a húr legalább egyszer.

65
00:05:12,980 --> 00:05:16,950
De aztán ha választ valami rossz, akkor meg kell loop vissza és kérdezd meg újra.

66
00:05:16,950 --> 00:05:20,810
De más, mint felhasználói, nagyon ritka, hogy találkozom egy eset

67
00:05:20,810 --> 00:05:27,170
ahol szeretnék hurok "legalább egyszer", de valószínűleg több.

68
00:05:27,170 --> 00:05:33,370
Kérdések vagy -? Valaki felhasználhatja a do-while ciklus bárhol máshol?

69
00:05:33,370 --> 00:05:36,780
Oké. Így a következő egy az, hogy "Mit jelent a be nem jelentett azonosítója

70
00:05:36,780 --> 00:05:43,310
általában azt mutatják, ha a kiadott által csenget? "

71
00:05:43,310 --> 00:05:47,380
Szóval milyen kóddal tudnám írni, hogy "a be nem jelentett azonosító?

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

73
00:05:49,550 --> 00:05:52,650
Így tudjuk csak próbáld meg itt, x = 2.

74
00:05:52,650 --> 00:06:04,830
Fogjuk futtatni ezt - oh, nem kattintson rá. Tehát itt kapunk - rendben.

75
00:06:04,830 --> 00:06:07,100
"A be nem jelentett azonosító x."

76
00:06:07,100 --> 00:06:11,610
Szóval ez a be nem jelentett azonosító változó.

77
00:06:11,610 --> 00:06:13,910
Ez gyakran hívott egy változót azonosítóval.

78
00:06:13,910 --> 00:06:17,300
Szóval lehet, hogy nem tudja, hogy ez valójában egy változót, nem tudom, mi az.

79
00:06:17,300 --> 00:06:19,380
Szóval ez egy azonosítót.

80
00:06:19,380 --> 00:06:26,060
Akkor miért van az, be nem jelentett? Igen.

81
00:06:26,060 --> 00:06:32,190
Tehát egyértelmű a terminológia, a nyilatkozat egy változó

82
00:06:32,190 --> 00:06:37,360
az, amikor azt mondod, "int x" vagy "string y", mindegy.

83
00:06:37,360 --> 00:06:41,910
Az inicializálás a változót, vagy a feladat a változó,

84
00:06:41,910 --> 00:06:44,510
van, amikor azt mondja: "x = 2".

85
00:06:44,510 --> 00:06:52,950
Tehát ezek külön lépésben, int x, x = 2, és amíg - mi lehet egy csomó dolgot itt -

86
00:06:52,950 --> 00:07:00,350
de amíg ezen a vonalon történik, x még nem inicializált, de már bejelentették.

87
00:07:00,350 --> 00:07:06,760
És így nyilvánvalóan csinálni az 1 vonal, és most nyilvánító és inicializálása.

88
00:07:06,760 --> 00:07:10,730
Kérdései vannak?

89
00:07:10,730 --> 00:07:18,390
És végül: "Miért van az, Caesar Cipher nem túl biztonságos?"

90
00:07:18,390 --> 00:07:23,830
Tehát az első, nem akarna bárki is mondani, mi a Caesar Cipher van?

91
00:07:23,830 --> 00:07:28,100
[Student] Caesar Cipher csak az, hogy térképet, akkor váltani minden levél,

92
00:07:28,100 --> 00:07:34,420
egy bizonyos számú levél megy át, és helyezze vissza, és ez nem túl biztonságos, mert

93
00:07:34,420 --> 00:07:42,260
ott csak 26 lehetséges opciókat, és csak ki kell próbálnia minden 1 e, amíg nem kap rá.

94
00:07:42,260 --> 00:07:45,470
Oh. Szóval meg kell ismételni?

95
00:07:45,470 --> 00:07:51,600
A Caesar Cipher, ez - úgy értem, te leszel foglalkozik vele a problémákat, hogy a te -

96
00:07:51,600 --> 00:07:56,110
vagy azt hiszem, a Standard Edition a probléma meg nem ez a hacker kiadás.

97
00:07:56,110 --> 00:08:01,550
Így a standard kiadás a probléma halmaz, akkor kap egy üzenetet, mint a "Hello, world"

98
00:08:01,550 --> 00:08:08,410
és akkor is számos, mint a 6, és hogy ezt az üzenetet, és minden egyes karakter,

99
00:08:08,410 --> 00:08:11,310
akkor forgassuk el 6 pozíciós az ábécé.

100
00:08:11,310 --> 00:08:16,560
Így a "h"-ban helló válna h-i-j-k-L-M-n.

101
00:08:16,560 --> 00:08:19,600
Tehát az első betű lesz n. Mi ugyanezt e.

102
00:08:19,600 --> 00:08:23,530
Ha van, mondjuk, z, vagy valami, akkor tekerje vissza körül "a."

103
00:08:23,530 --> 00:08:29,280
De minden karakter kap ciklikusan 6 karakter később az ábécét, és ez nem nagyon biztonságos

104
00:08:29,280 --> 00:08:35,440
hiszen csak 26 lehetőség, hogy sokféleképpen lehet tekerje egy levelet.

105
00:08:35,440 --> 00:08:42,919
Így csak próbáld mind a 26, és még feltehetően egy elég hosszú üzenetet,

106
00:08:42,919 --> 00:08:46,860
csak 1 e lehetséges 26 dolog lesz olvasható,

107
00:08:46,860 --> 00:08:50,300
, és olvasható az egyik lesz az eredeti üzenetet.

108
00:08:50,300 --> 00:08:56,240
Tehát ez nem egy nagyon jó módja a titkosítható semmit.

109
00:08:56,240 --> 00:08:59,070
Független az említett nadrág, "Mi a funkciója?"

110
00:08:59,070 --> 00:09:03,370
Tehát mi a funkciója? Igen.

111
00:09:03,370 --> 00:09:11,640
[Student] Ez olyan, mint egy különálló darab kódot, akkor hívja, hogy menjen át, és akkor kap a visszatérési értéke bármilyen.

112
00:09:11,640 --> 00:09:18,160
Igen. Szóval majd válaszolni által is választ a következő - vagy ismételt által is csak megválaszolásával a következő alkalommal.

113
00:09:18,160 --> 00:09:22,410
Használhatja funkciókat ahelyett, hogy csak a másolás és beillesztés kód újra és újra.

114
00:09:22,410 --> 00:09:27,200
Csak hogy ezt a kódot helyezze be a fuction, és akkor is csak hívja a függvényt

115
00:09:27,200 --> 00:09:29,870
ahol voltál másolás és beillesztés.

116
00:09:29,870 --> 00:09:33,350
Így funkciók hasznosak.

117
00:09:33,350 --> 00:09:35,860
Tehát most fogunk csinálni a tényleges problémákat.

118
00:09:35,860 --> 00:09:46,490
Az első. Tehát az ötlet az első az, hogy adja át egy string, és függetlenül attól, hogy a -

119
00:09:46,490 --> 00:09:52,060
vagy nincs benne csupa kisbetűvel? Ez nem mond csupa kisbetűvel.

120
00:09:52,060 --> 00:09:57,730
Így az üzenet bármi lehet, és - ó, nem. Ez nem.

121
00:09:57,730 --> 00:10:01,610
"Az egyszerűség kedvéért, akkor feltételezi, hogy a felhasználó csak input kisbetűket és terek."

122
00:10:01,610 --> 00:10:08,180
Így adja át az üzenetet csak kisbetűket, aztán felváltva

123
00:10:08,180 --> 00:10:15,450
a tőke és a kisbetűs - mi változik a húr, hogy a tőke és a kisbetűs, felváltva.

124
00:10:15,450 --> 00:10:22,920
Szóval mielőtt kapsz egy második, még belevetik magukat a probléma,

125
00:10:22,920 --> 00:10:32,420
mi az első dolog, amit tennünk kell?

126
00:10:32,420 --> 00:10:36,900
Ó, mit tettem, csak kattintson a? Ó, csak rákattintott egy e-mailt ide.

127
00:10:36,900 --> 00:10:42,870
Tehát az első dolog, amit tennünk kell - nézem a rossz?

128
00:10:42,870 --> 00:10:49,320
Ez a része ez?

129
00:10:49,320 --> 00:10:51,320
Nem, ezek még mindig ott van, bár.

130
00:10:51,320 --> 00:10:55,160
Oké, még mindig itt van.

131
00:10:55,160 --> 00:11:03,160
Most már nem lehet feltételezni, -? Igen. Itt nem lehet feltételezni, hogy ez csak kisbetűs és terek.

132
00:11:03,160 --> 00:11:07,770
Tehát most meg kell küzdeniük azzal a ténnyel, hogy a betűk is, amit szeretnénk, hogy legyen.

133
00:11:07,770 --> 00:11:11,910
És így az első dolog, amit akarok az csak kap az üzenetet.

134
00:11:11,910 --> 00:11:19,790
Csak kell, hogy egy string, string s = getString, oké.

135
00:11:19,790 --> 00:11:24,890
Most ez a probléma, van egy pár módon csinálja.

136
00:11:24,890 --> 00:11:29,840
De mi lesz a használni kívánt bitenkénti operátorok itt.

137
00:11:29,840 --> 00:11:35,280
Vannak emberek, akik vagy nem voltak meg a szuperszakasz,

138
00:11:35,280 --> 00:11:37,480
vagy valami, és nem tudom, mit bitenkénti operátorok?

139
00:11:37,480 --> 00:11:41,710
Vagy hogyan viszonyulnak ASCII bármilyen módon?

140
00:11:41,710 --> 00:11:45,650
[Student] nem voltam a szuperszakasz, de tudom, hogy mit bitenkénti operátorok.

141
00:11:45,650 --> 00:11:49,560
Oké. Így aztán nem kell, hogy menjen át az alapokat a őket, de elmagyarázom

142
00:11:49,560 --> 00:11:51,830
hogy mit fogunk használni kívánt itt.

143
00:11:51,830 --> 00:11:59,680
Tehát 'A': bináris reprezentációja tőke A, a szám 65.

144
00:11:59,680 --> 00:12:07,560
Én csak fog nézni - 41 lesz 01000001.

145
00:12:07,560 --> 00:12:14,170
Szóval, hogy kell 65 decimális, így ez a bináris a karakter tőke A.

146
00:12:14,170 --> 00:12:19,440
Most, a bináris a karakter kisbetűs "a"

147
00:12:19,440 --> 00:12:33,350
lesz ugyanaz a dolog, majdnem. Ez - 6, igen. Ez helyes.

148
00:12:33,350 --> 00:12:37,670
Szóval bináris tőke A, bináris kisbetűs "a."

149
00:12:37,670 --> 00:12:43,940
Tehát észre, hogy a különbség az A és "a" ez az egyetlen bit.

150
00:12:43,940 --> 00:12:49,440
És ez történik, hogy a 32 bit, a bit a szám 32.

151
00:12:49,440 --> 00:12:53,910
És hogy van értelme, hiszen egy a 65, "a" 97.

152
00:12:53,910 --> 00:12:56,610
A kettő közti különbség 32.

153
00:12:56,610 --> 00:13:03,770
Most már tudjuk, hogy lehet konvertálni tól "a" azáltal, hogy egy

154
00:13:03,770 --> 00:13:09,710
és bitenkénti fejekhez meg, és - úgy néz ki, mint a 1.

155
00:13:09,710 --> 00:13:20,900
Ez egy bitenkénti OR, a 00100000, és akkor nekünk "a."

156
00:13:20,900 --> 00:13:26,850
És mi lehet eljutni az "a"-től a bitenkénti AND művelet

157
00:13:26,850 --> 00:13:33,700
a 11, 0 ezen a helyen, 11111.

158
00:13:33,700 --> 00:13:43,840
Szóval ez majd ad nekünk pontosan mi az "a" volt, de törli ki ezt az egyedi bit,

159
00:13:43,840 --> 00:13:50,070
így lesz 01000001, nem tudom, ha én számított jobbra.

160
00:13:50,070 --> 00:13:56,750
De ez a technika bitenkénti fejekhez, hogy a tőke a kisbetűs,

161
00:13:56,750 --> 00:14:02,080
és bitenkénti AND művelet eljutni kisbetű a tőke, nem kizárólagos A.

162
00:14:02,080 --> 00:14:06,510
Minden betű, K vs k, Z vs z,

163
00:14:06,510 --> 00:14:10,080
mindegyik csak úgy térhet el ezen egyetlen bit.

164
00:14:10,080 --> 00:14:16,290
És így akkor használja ezt módosíthatja bármely kisbetűs minden nagybetűvel, és fordítva.

165
00:14:16,290 --> 00:14:26,670
Oké. Így egy egyszerű módja annak, hogy ebből -, így ahelyett, hogy

166
00:14:26,670 --> 00:14:32,170
kiírja bármi 1011111 jelentése - egy egyszerű módja a képviselő ezt a számot, és ez nem egy

167
00:14:32,170 --> 00:14:39,710
hogy mentem át a szuperszakasz, de a tilde (~) egy másik bitenkénti operátor.

168
00:14:39,710 --> 00:14:42,520
Mi ~ tesz, úgy néz ki, a bit képviselet.

169
00:14:42,520 --> 00:14:45,630
Vegyük minden számát.

170
00:14:45,630 --> 00:14:53,130
Ez csak néhány bináris szám, és mi ~ jelent ez csak fejtetőre összes bitjét.

171
00:14:53,130 --> 00:15:00,630
Tehát ez a 1 volt, most a 0, ez egy 0, most egy 1, 010.100.

172
00:15:00,630 --> 00:15:08,320
Szóval ennyi ~ nem. Tehát a 32 lesz a szám - megszabadulni, hogy -

173
00:15:08,320 --> 00:15:23,320
így 32 lesz a szám 00100000, és így ~ e lesz

174
00:15:23,320 --> 00:15:29,980
ez a szám ide, hogy én ANDed "a"-val.

175
00:15:29,980 --> 00:15:35,600
Mindenki látja, hogy? Ez elég gyakori, mint ha azt szeretné, hogy kitaláljuk,

176
00:15:35,600 --> 00:15:40,740
későbbi dolgok, amiket lehet látni, ha látni akarjuk, ha -

177
00:15:40,740 --> 00:15:44,710
vagy akarunk mindent, minden egyes bit készlet, kivéve az 1

178
00:15:44,710 --> 00:15:47,910
Ön inkább nem ~ a kicsit, hogy nem akarunk beállítani.

179
00:15:47,910 --> 00:15:53,090
Tehát mi nem akarjuk, hogy a 32 bit készlet, ezért ne ~ a 32.

180
00:15:53,090 --> 00:15:57,790
Oké. Így tudjuk használni az összes e itt.

181
00:15:57,790 --> 00:16:03,000
Rendben, rendben van, ha nem történt, akkor az lassan játszott együtt,

182
00:16:03,000 --> 00:16:11,870
vagy gyalog át ezt, ezért - ezen keresztül. Séta ezt.

183
00:16:11,870 --> 00:16:20,790
Tehát a húr, és azt akarjuk, hogy hurkot egyes karakter az adott karakterláncot, és tegyen valamit hozzá.

184
00:16:20,790 --> 00:16:26,710
Szóval hogyan hurkot egy string? Mire kezelhető?

185
00:16:26,710 --> 00:16:30,980
Nem fogok csinálni itt. Igen.

186
00:16:30,980 --> 00:16:42,940
Szóval én iterator, és azt mondta, hogy, de hogyan tudom, hogy hány karakter van a húr?

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

188
00:16:47,030 --> 00:16:49,860
Szóval mit tettem itt nem a legjobb módja a dolgok.

189
00:16:49,860 --> 00:16:51,860
Tudja valaki, hogy miért?

190
00:16:51,860 --> 00:16:55,290
Mert ellenőrzése nyelvét a string minden egyes alkalommal.

191
00:16:55,290 --> 00:17:06,859
Így fogunk mozgatni akarjuk strlen, mondhatnám itt, int length = strlen (s),

192
00:17:06,859 --> 00:17:11,900
majd tegye i <hossza, és abban az esetben, ha még nem látta volna,

193
00:17:11,900 --> 00:17:20,410
Azt is csinálni int i = 0, hossz = strlen (ka) t.

194
00:17:20,410 --> 00:17:25,010
És így ez némileg előnyösebb, mert most már korlátozta

195
00:17:25,010 --> 00:17:29,150
A változó hosszúságú, hogy csak ezt a "a" hurok, ahelyett, megállapító előtt

196
00:17:29,150 --> 00:17:34,990
és hogy mindig létezik, és abban az esetben, ha nem értettem, hogy miért rossz,

197
00:17:34,990 --> 00:17:39,410
vagy miért az eredeti rossz volt, ez - kezdődik az a hurok.

198
00:17:39,410 --> 00:17:43,380
Megnéztem a feltételt. Van I <hosszának s?

199
00:17:43,380 --> 00:17:46,790
Tehát a hossza s, menjünk dolgozni "hello" az egész idő alatt.

200
00:17:46,790 --> 00:17:49,670
Így hossza s, H-E-l-l-o. Hossza 5.

201
00:17:49,670 --> 00:17:57,580
Tehát i = 0, hossza 5, tehát én nem <5, így a ciklus folytatódik.

202
00:17:57,580 --> 00:18:02,750
Aztán megint. Mi ellenőrizze az állapotát. Van I <hosszának hello?

203
00:18:02,750 --> 00:18:08,390
Akkor nézzük a hossza hello. H-E-l-l-o. Ez 5, i nem <5, így tovább újra.

204
00:18:08,390 --> 00:18:13,330
Tehát kiszámításakor, mi számítunk hello, minden egyes iteráció a hurok,

205
00:18:13,330 --> 00:18:17,380
még hittem, hogy soha nem fog változni, hogy mindig lesz 5.

206
00:18:17,380 --> 00:18:22,530
Szóval csak emlékezni 5 elöl, és most minden jobb.

207
00:18:22,530 --> 00:18:24,990
Tehát iterációjával az egész string.

208
00:18:24,990 --> 00:18:31,470
Mit akarunk csinálni minden egyes karakter a húr?

209
00:18:31,470 --> 00:18:38,510
[Diák beszélő, érthetetlen]

210
00:18:38,510 --> 00:18:47,000
Igen. Tehát, ha a karakter nem alfabetikus, akkor csak azt, hogy átugorja azt.

211
00:18:47,000 --> 00:18:52,300
Mert mi csak érdekel ABC betűk, nem tudjuk kihasználni a számot.

212
00:18:52,300 --> 00:19:10,850
Szóval, hogyan lehet ezt megtenni? Így a feltétel, így ha akarunk valamit - ellenőrizni, ha ez ábécé.

213
00:19:10,850 --> 00:19:14,060
Szóval hogyan lehet ellenőrizni ezt?

214
00:19:14,060 --> 00:19:18,720
[Student] Tudod csak használni a funkciót az alfa.

215
00:19:18,720 --> 00:19:23,160
Ez tartalmazza sem ezen, vagy bármely között hasonló char.h vagy ilyesmi?

216
00:19:23,160 --> 00:19:32,710
Ne használja az alfa funkció, és használja az explicit - így van s [i],

217
00:19:32,710 --> 00:19:40,460
hogy a nyolcadik jellege s ne feledjük, hogy egy string egy tömb a karakterek,

218
00:19:40,460 --> 00:19:43,180
így a nyolcadik jellegét s.

219
00:19:43,180 --> 00:19:49,280
Nos, ha ez egy betű, tudjuk, hogy kell lennie egy bizonyos tartományban.

220
00:19:49,280 --> 00:19:54,370
És mi az, hogy a kínálat?

221
00:19:54,370 --> 00:20:07,860
Igen. Tehát, ha s [i] ≥ 65 és s [i] ≤ 90, mit tegyek helyette?

222
00:20:07,860 --> 00:20:18,470
Igen. Szóval akkor nem is feltétlenül kell tudni az ASCII értékek bármi.

223
00:20:18,470 --> 00:20:25,640
Ne gondolj a számok 65, 90, 97 és 102, vagy bármi is legyen az.

224
00:20:25,640 --> 00:20:32,470
Önnek nem kell - 112? - Nem kell tudni, hogy e egyáltalán. Ez rossz is.

225
00:20:32,470 --> 00:20:41,940
Csak az egyszeres idézőjel karaktereket, egyetlen idézet állandók. Így "A" és kevesebb, mint 90 a "Z."

226
00:20:41,940 --> 00:20:47,930
És ez sokkal jobb - Én nem tudom, ki a fejem búbját, hogy a Z-90.

227
00:20:47,930 --> 00:20:52,690
Azt tudom, le a fejem búbját, hogy a "Z" a tőke Z.

228
00:20:52,690 --> 00:21:02,100
Tehát mindaddig, amíg ez a tartomány a tőke A tőke-Z-ig, vagy mi lehet ellenőrizni kisbetű,

229
00:21:02,100 --> 00:21:17,010
Vagy ha ez a tartomány ≥ 'a' és ≤ z.

230
00:21:17,010 --> 00:21:19,010
Szóval ez a feltétel.

231
00:21:19,010 --> 00:21:22,520
A stílus hová tegye ezeket a dolgokat változik.

232
00:21:22,520 --> 00:21:29,520
Megcsinálom, mint ez.

233
00:21:29,520 --> 00:21:31,520
Nos, mit szeretnél csinálni?

234
00:21:31,520 --> 00:21:39,530
Tudjuk, hogy ez a levél egy karakter, egy további alfabetikus karakterrel.

235
00:21:39,530 --> 00:21:46,270
Tehát meg kell váltogatni, hogy ez most már egy nagybetű vagy kisbetű.

236
00:21:46,270 --> 00:21:48,820
Hogyan tudjuk nyomon követni, amelyek közül azt akarjuk, hogy legyen?

237
00:21:48,820 --> 00:21:55,520
[Student hangok, érthetetlen]

238
00:21:55,520 --> 00:21:59,150
Szóval igen, de hadd nézzem.

239
00:21:59,150 --> 00:22:04,910
Modul 0-2 mondták, volt egy javaslat kidobtak, és én egyetértek vele.

240
00:22:04,910 --> 00:22:11,780
Kivéve, vegyük észre, hogy, mint - ez a helyzet? Igen.

241
00:22:11,780 --> 00:22:18,270
Ez minden másik, de nem tudjuk a modul 2-i, vagy i mod 2, mivel

242
00:22:18,270 --> 00:22:22,950
észre, hogy E tőke és "a" kisbetűs? De van egy hely elválasztva őket?

243
00:22:22,950 --> 00:22:27,150
Így leszel ugyanaz mod 2, de ők más esetekben.

244
00:22:27,150 --> 00:22:29,150
[Student kérdés, érthetetlen]

245
00:22:29,150 --> 00:22:34,690
Igen. Szóval csak úgy tartani a gróf.

246
00:22:34,690 --> 00:22:38,730
Azt is megtehetik, hogy itt, ha azt akartuk, hogy lehet, hogy egy kicsit bonyolultnak

247
00:22:38,730 --> 00:22:41,300
A for ciklus nyilatkozatokról; teszem fel ide.

248
00:22:41,300 --> 00:22:48,840
Így int count = 0-tól indul.

249
00:22:48,840 --> 00:22:54,070
És most megyek, hány betű megvolt.

250
00:22:54,070 --> 00:22:59,550
Szóval elkerülhetetlenül fog számolni + + hiszen talált egy másik betű.

251
00:22:59,550 --> 00:23:09,130
De, így most azt mondod, ha count mod 2.

252
00:23:09,130 --> 00:23:12,590
Szóval, mi van, ha számít mod 2? Oh. Megteszek == 0 most.

253
00:23:12,590 --> 00:23:21,740
Akkor is megy fölé. Tehát, ha count mod 2 == 0, akkor mi van?

254
00:23:21,740 --> 00:23:27,830
[Diákok válasz, érthetetlen]

255
00:23:27,830 --> 00:23:32,750
Tehát azt akarjuk, hogy a végén nagybetű.

256
00:23:32,750 --> 00:23:37,520
Van 2 esetben; nagybetűs és kisbetűs a 2 esetben.

257
00:23:37,520 --> 00:23:40,990
Tehát, ha mi vagyunk a kisbetűvel kell tennünk, hogy nagybetűs.

258
00:23:40,990 --> 00:23:43,710
Ha ez nagybetű nem kell tennie semmit.

259
00:23:43,710 --> 00:23:50,760
De, van egy módja - Nem kéne már tükrözött -

260
00:23:50,760 --> 00:23:54,800
hogy nem is kell ellenőrizni, hogy ez a nagy-vagy kisbetűs?

261
00:23:54,800 --> 00:24:02,240
Mit tehetünk, hogy mindig győződjön meg arról, hogy a végén mindig a nagybetűs?

262
00:24:02,240 --> 00:24:07,830
Tehát észre, mit tettünk a kis 'a'; mi lenne, ha ezt tette pontosan ugyanolyan dolog nagybetűssé A?

263
00:24:07,830 --> 00:24:11,900
Vajon nagybetűssé A változás, vagy ez az érték változás?

264
00:24:11,900 --> 00:24:23,100
Igen. Tehát minden betű bitenkénti ANDed a ~ 32 lesz ugyanezen nagybetűs karakter

265
00:24:23,100 --> 00:24:29,220
mert minden nagybetűs karakter a 32. bit nincs beállítva.

266
00:24:29,220 --> 00:24:40,920
Tehát ha azt akarjuk, hogy a karakter s [i], azt akarjuk, hogy legyen kis-vagy nagybetű.

267
00:24:40,920 --> 00:24:46,890
Tehát, ha ez volt kisbetűs, most nagybetűs, ha ez nagybetűs, ez még mindig nagybetűs, és ennyi.

268
00:24:46,890 --> 00:24:54,290
Azt mondta, hogy ez a szuperszakasz: Használhatja 32, ha akarod, de én inkább a csinál "a" - A,

269
00:24:54,290 --> 00:25:01,150
ahelyett, hogy csak sima 32, mivel lehet bármilyen más bit.

270
00:25:01,150 --> 00:25:03,610
Után a 32 bit, lehet bármelyik, vagy nem lenne elegendő

271
00:25:03,610 --> 00:25:05,840
számok, hogy képviselje az összes karaktert.

272
00:25:05,840 --> 00:25:09,110
Tehát, ha megkapod a 32 bites, akkor lehet a 64 bites, akkor lehet a 128 bit.

273
00:25:09,110 --> 00:25:13,990
Bármely e bitek lehet a kicsit, hogy különbséget tesz kis-és nagybetűk.

274
00:25:13,990 --> 00:25:18,350
Azt nem kell tudni, hogy ez a 32 bit.

275
00:25:18,350 --> 00:25:27,130
Tudom használni ezt az "a" - Az, hogy a kicsit, hogy különbözik a két

276
00:25:27,130 --> 00:25:33,000
anélkül, hogy támaszkodnak a bűvös szám, ami 32.

277
00:25:33,000 --> 00:25:38,770
És most, még számíthat furcsa volt, és így mit szeretnél csinálni?

278
00:25:38,770 --> 00:25:43,920
[Student válaszok, érthetetlen]

279
00:25:43,920 --> 00:25:45,920
[Student] Mi ez?

280
00:25:45,920 --> 00:25:49,850
Fogok csinálni 1 másodperc.

281
00:25:49,850 --> 00:25:55,690
Tehát most ha akarom - Azt szeretnénk, hogy győződjön meg arról, hogy a karakter már kisbetű,

282
00:25:55,690 --> 00:26:04,140
és így tudok vagy 32, és 32 jelentése 'a' - A.

283
00:26:04,140 --> 00:26:06,510
De közlemény ugyanezen logikán alapul, mint az előző, hogy ha

284
00:26:06,510 --> 00:26:11,670
a levél már kisbetű, majd fejekhez, 32 csak tartja kisbetűre.

285
00:26:11,670 --> 00:26:16,220
Ez nem változott az eredeti jellegét.

286
00:26:16,220 --> 00:26:19,910
De most már nem kell, hogy elkerüljék azt mondja: "Ha kisbetűs, csak felejtsd el,

287
00:26:19,910 --> 00:26:23,650
ha ez nagybetűs, akkor változtassa meg. "

288
00:26:23,650 --> 00:26:26,900
Ez sokkal kényelmesebb, hogy ezt megtehesse.

289
00:26:26,900 --> 00:26:33,190
[Student] Vajon hogy stratégiája vonni a nagybetűs a kisbetűs munka, ha nem lenne 32?

290
00:26:33,190 --> 00:26:35,330
Ha ez, mondjuk, 34 vagy ilyesmi?

291
00:26:35,330 --> 00:26:41,840
Szóval, meg kell tudni, hogy a különbség a 2 -? >> 1 bit.

292
00:26:41,840 --> 00:26:49,840
Ez lehet több mint 1 bit, egészen addig, amíg a bitek alatt ebben a pozícióban található a ugyanaz.

293
00:26:49,840 --> 00:26:58,500
Tehát szükségünk van legalább 26 karakter - vagy, vannak 26 karakter.

294
00:26:58,500 --> 00:27:04,590
Tehát szükségünk van legalább 26 számok jelentik a különbséget -

295
00:27:04,590 --> 00:27:07,650
A különbség az A és az "a" kell, hogy legyen legalább 26,

296
00:27:07,650 --> 00:27:10,760
, különben nem lett volna egészét képviselték a főváros számokat.

297
00:27:10,760 --> 00:27:18,630
Ez azt jelenti, hogy az A, ha elkezdünk 1, ez fog használni az összes ezeket a biteket,

298
00:27:18,630 --> 00:27:23,900
Mindezek a első 5 bit, hogy képviselje minden keresztül Z

299
00:27:23,900 --> 00:27:32,170
Ezért a következő bit, vagy ezt a bitet, a következő bit az, aki döntött, hogy különbséget A és az "a."

300
00:27:32,170 --> 00:27:40,930
Ez is oka annak, ASCII táblázat, van 5 jelek elválasztására nagybetűvel honnan kisbetűs.

301
00:27:40,930 --> 00:27:49,050
Mivel ezek a szimbólumok, az extra 5, hogy hozza fel a 32 pedig a kettő közti különbség.

302
00:27:49,050 --> 00:27:51,840
[Student] Úgyhogy tehetnénk, mert ASCII tervezték így.

303
00:27:51,840 --> 00:27:57,280
Igen. Hanem ASCII - a különbség is lehet mindkét ezeket a biteket.

304
00:27:57,280 --> 00:28:12,040
Like, ha A 10000001 voltak, és "a" volt 11100001 - elfelejtettem, mindegy.

305
00:28:12,040 --> 00:28:18,100
De ha ez az, akkor még mindig használja az "a" - A.

306
00:28:18,100 --> 00:28:22,650
Ez most a különbség, és az "a" még ezen 2 bit.

307
00:28:22,650 --> 00:28:32,240
Azt hiszem, ez van írva 48. Ez 32 + 64? Azt hiszem, ez?

308
00:28:32,240 --> 00:28:40,160
Ez még mindig 2 bit, minden egyes karaktert, mondjuk, Z és Z, k és k,

309
00:28:40,160 --> 00:28:45,160
azok még mindig pontosan ugyanolyan értékű bit kivételével 2 bit.

310
00:28:45,160 --> 00:28:48,870
Tehát amíg ez mindig igaz, függetlenül attól, hogy ha mi ASCII vagy más rendszer,

311
00:28:48,870 --> 00:28:53,050
amíg már csak egy meghatározott számú bitek eltérő minden karaktert,

312
00:28:53,050 --> 00:28:55,050
akkor az működik.

313
00:28:55,050 --> 00:29:06,110
Csak, hogy 32-ben hozták létre, mert ez az első, amit esetleg használni. >> Cool.

314
00:29:06,110 --> 00:29:14,520
Én inkább a, abban az esetben, ha még nem látta, ha a mondat csak egy sor,

315
00:29:14,520 --> 00:29:24,280
lehet megszabadulni a kapcsos zárójelek, úgyhogy inkább a ezt.

316
00:29:24,280 --> 00:29:34,010
Is, tudod, hogy meg tudjuk csinálni dolgokat, mint s [i] + = 1?

317
00:29:34,010 --> 00:29:41,090
Megteheti s [i] bitenkénti AND = 32.

318
00:29:41,090 --> 00:29:46,400
És bitenkénti OR = 32.

319
00:29:46,400 --> 00:29:51,490
Emellett számolni mod 2 == 0.

320
00:29:51,490 --> 00:30:00,900
Úgy emlékszem, hogy - nem fogok írni - bármely nem nulla értéket igaz, és 0 hamis.

321
00:30:00,900 --> 00:30:07,880
Szóval, "ha count mod 2 == 0" ugyanaz, mint a mondás: "ha nem számít mod 2".

322
00:30:07,880 --> 00:30:11,580
Talán éppen megfordult volna a vonalakat, és azt mondta: "ha a gróf mod 2,

323
00:30:11,580 --> 00:30:15,350
akkor az OR 1, mást az AND 1, "úgy, hogy nem kell a" nem ".

324
00:30:15,350 --> 00:30:18,650
De ez ugyanúgy működik is.

325
00:30:18,650 --> 00:30:25,660
És mi mást tehetnék itt?

326
00:30:25,660 --> 00:30:29,060
Lehet kombinálni őket háromkomponensű, ha akart, de aztán, hogy épp most, hogy a dolgok Messier

327
00:30:29,060 --> 00:30:33,770
és valószínűleg nehezebb olvasni, ezért nem fogjuk megtenni.

328
00:30:33,770 --> 00:30:37,330
Bárki bármilyen más javaslatok?

329
00:30:37,330 --> 00:30:41,580
Ez a probléma kérte? Ó, igen.

330
00:30:41,580 --> 00:30:51,070
Szóval, megszabadulni az ilyen üres sorokat, most fogunk nyomtatni f,% s, hogy az egyik a húrok,

331
00:30:51,070 --> 00:30:56,620
Mi nyomtatni f, s.

332
00:30:56,620 --> 00:30:59,330
Most futtatni. Csináltam semmi rosszat?

333
00:30:59,330 --> 00:31:03,200
Ez a \ "; akarok n.

334
00:31:03,200 --> 00:31:07,840
Oké. Most fogjuk futtatni. Ez valószínűleg kiabálj velem.

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

336
00:31:11,250 --> 00:31:14,290
Szóval ez a szép dolog zengés ez megmondja, mi van,

337
00:31:14,290 --> 00:31:19,140
ahelyett, GCC, amely csak azt mondja: "Hé, te elfelejtett valamit, nem tudom, mi volt az."

338
00:31:19,140 --> 00:31:29,220
De ezt fogja mondani nekem, "Te azt jelentette fel string.h."

339
00:31:29,220 --> 00:31:32,130
Szóval nem kérdez semmit, így ez nem mond semmit.

340
00:31:32,130 --> 00:31:42,540
De mi tőlük például "Köszönet 4 the add."

341
00:31:42,540 --> 00:31:47,880
Úgy néz ki, van. Hurrá.

342
00:31:47,880 --> 00:31:52,370
Szóval visszatérve a fő, én szinte soha nem csinálni.

343
00:31:52,370 --> 00:31:57,110
Ez nem kötelező. És a legfontosabb az egyetlen funkció, ami választható.

344
00:31:57,110 --> 00:32:07,140
Ha nem vissza semmit a fő, ez feltételezhető, hogy azt jelentette, hogy vissza 0-ra.

345
00:32:07,140 --> 00:32:13,070
Kérdései vannak?

346
00:32:13,070 --> 00:32:20,980
Oké. Tehát most a második problémát.

347
00:32:20,980 --> 00:32:24,810
"Recall hétről 2 második előadás, hogy a csere 2 változó" értékek áthaladó

348
00:32:24,810 --> 00:32:30,780
E 2 változók egy függvény (még ha az úgynevezett swap) nem igazán működik, legalábbis nem teljesen "mutató".

349
00:32:30,780 --> 00:32:37,020
És figyelmen kívül mutatók amíg megkapjuk őket.

350
00:32:37,020 --> 00:32:40,070
Azt akarjuk, hogy cserélni 2 változó, nem vagyunk függvény segítségével csinálni.

351
00:32:40,070 --> 00:32:43,410
Még mindig fog csinálni, mint a fő mond.

352
00:32:43,410 --> 00:32:48,360
De, hogy az említett 2 változó, mi nem szeretnénk használni egy ideiglenes változót.

353
00:32:48,360 --> 00:32:50,770
2 számos mód van erre.

354
00:32:50,770 --> 00:32:56,310
Meg tudod csinálni használja a hagyományos bináris operátorok.

355
00:32:56,310 --> 00:33:00,180
Szóval Tudja valaki, hogy egy gyors és piszkos módon csinálja ezt?

356
00:33:00,180 --> 00:33:07,650
Lehet, hogy valójában egy perc gondolkodás. Ha van -

357
00:33:07,650 --> 00:33:12,130
Én meg a problémát fel, mint kérnek. Szóval, ha van 2 változók, A, ami csak egy egész

358
00:33:12,130 --> 00:33:17,800
hogy adnak nekem, és B változó összeg, amely egy másik értéke, hogy én vagyok adni.

359
00:33:17,800 --> 00:33:22,700
Tehát, ha van ilyen 2 változó, most akarom cserélni őket.

360
00:33:22,700 --> 00:33:31,550
A hagyományos, használja a szokásos bináris operátorok, úgy értem, mint a +, -, ÷.

361
00:33:31,550 --> 00:33:36,630
Nem bitenkénti szereplők jár bináris.

362
00:33:36,630 --> 00:33:39,600
Tehát használ -, +, ÷, és mindazoknak, akik.

363
00:33:39,600 --> 00:33:52,980
Mi lehet cserélni csinál valamit, mint a = a + b és b = a - b, a = a - b.

364
00:33:52,980 --> 00:34:04,260
Szóval, józanság ellenőrizze, és aztán majd meglátjuk, hogy miért működik.

365
00:34:04,260 --> 00:34:13,320
Tegyük fel, hogy a = 7, b = 3, akkor a + b lesz 10-ig.

366
00:34:13,320 --> 00:34:18,820
Szóval most beállításával = 10, majd csinálunk b = a - b.

367
00:34:18,820 --> 00:34:30,250
Szóval csinálunk b = a - b, ami lesz 7 és b = a - b újra,

368
00:34:30,250 --> 00:34:38,650
vagy = a - b. Melyik lesz a 10-7, amely 3.

369
00:34:38,650 --> 00:34:44,850
Tehát most, helyesen, az "a" 7 volt, b 3 volt, és most b 7, és "a" 3.

370
00:34:44,850 --> 00:34:48,679
Szóval ez a fajta van értelme, "a" a kombináció a 2 számot.

371
00:34:48,679 --> 00:34:53,000
Ezen a ponton, "a" a kombináció, és aztán mi kivonjuk ki az eredeti B,

372
00:34:53,000 --> 00:34:56,860
majd mi levonjuk, hogy mi volt az eredeti "a."

373
00:34:56,860 --> 00:35:01,150
De ez nem működik az összes számot.

374
00:35:01,150 --> 00:35:08,880
Ahhoz, hogy ezt belássuk, nézzük meg a rendszer, ezért általában úgy gondolja, az egész számok, mint 32 bit.

375
00:35:08,880 --> 00:35:13,050
Menjünk dolgozni valamit, csak, mint 4 bit.

376
00:35:13,050 --> 00:35:15,450
Remélem felér egy jó példa most.

377
00:35:15,450 --> 00:35:18,680
Szóval, tudom, hogy ez könnyű lesz.

378
00:35:18,680 --> 00:35:26,720
Tegyük fel, hogy a 2 számok 1111-es, és a 1111, így vagyunk bináris most.

379
00:35:26,720 --> 00:35:34,630
A tényleges tizedes, ha meg akarja gondolni, hogy így, a = 15 és b = 15.

380
00:35:34,630 --> 00:35:37,630
És így azt várjuk, miután cserélni őket - nem is kell, hogy ugyanazokat a számokat,

381
00:35:37,630 --> 00:35:41,140
de én ezt így.

382
00:35:41,140 --> 00:35:47,100
Csináljunk nekik, hogy ne ugyanazt a számot. Csináljuk 1111 és 0001.

383
00:35:47,100 --> 00:35:51,860
Így a = 15 és b = 1.

384
00:35:51,860 --> 00:35:57,670
Miután cserélni őket, várunk 'a', hogy 1 és b 15 lesz.

385
00:35:57,670 --> 00:36:01,780
Tehát az első lépés a = a + b.

386
00:36:01,780 --> 00:36:08,770
A számok csak 4 bit széles, így "egy", amely 1111-es, + b, ami 0001,

387
00:36:08,770 --> 00:36:16,780
lesz a végén, hogy 10000, de csak 4 bit.

388
00:36:16,780 --> 00:36:22,540
Tehát most a = 0.

389
00:36:22,540 --> 00:36:34,080
És most szeretnénk beállítani b = a - b - valójában ez még mindig működik ki tökéletesen.

390
00:36:34,080 --> 00:36:39,630
a = a - b - lássuk, ha ez működik ki tökéletesen.

391
00:36:39,630 --> 00:36:53,720
Így akkor b = 0 - 1, ami még mindig 15, és akkor a = a - b, ami 1.

392
00:36:53,720 --> 00:36:56,210
Lehet, hogy ez működik.

393
00:36:56,210 --> 00:36:59,020
Úgy érzem, van egy oka, hogy nem működik, rendszeres.

394
00:36:59,020 --> 00:37:06,400
Oké, akkor dolgozik, feltételezve, hogy ez nem működik rendszeres bináris műveletek

395
00:37:06,400 --> 00:37:15,040
és én keresni - én a Google, hogy ha ez igaz.

396
00:37:15,040 --> 00:37:23,490
Így akarom csinálni a bitenkénti szereplők, valamint a nyom itt XOR.

397
00:37:23,490 --> 00:37:28,780
Szóval, bevezetése XOR (^), ha még nem látta még.

398
00:37:28,780 --> 00:37:34,610
Ez ismét egy bitenkénti operátor így jár apránként, és ez -

399
00:37:34,610 --> 00:37:39,910
Ha a bit 0 és 1, akkor ez 1 lesz.

400
00:37:39,910 --> 00:37:45,230
Ha a bit 1 és 0, akkor az 1, akkor a biteket 0 és 0 ez lesz 0,

401
00:37:45,230 --> 00:37:47,640
és ha a biteket 1. és 1 ez lesz 0.

402
00:37:47,640 --> 00:37:56,180
Szóval, ez olyan, mint OR. Ha akár a bitek igaz, ez 1, de ellentétben OR, nem lehet egyszerre bitek igazak.

403
00:37:56,180 --> 00:37:59,320
VAGY volna ez 1, XOR volna ezt kell 0-ra.

404
00:37:59,320 --> 00:38:02,250
Így fogunk használni kívánt XOR itt.

405
00:38:02,250 --> 00:38:09,960
Gondolj bele egy pillanatra, megyek Google.

406
00:38:09,960 --> 00:38:16,230
Nos, nem lehet olvasni, hogy, én vagyok jelenleg a swap-XOR algoritmus oldalon.

407
00:38:16,230 --> 00:38:21,340
Remélhetőleg ez miért Nem tudok -

408
00:38:21,340 --> 00:38:34,190
Ez pontosan az az algoritmus, amit csináltál.

409
00:38:34,190 --> 00:38:37,330
Még mindig nem értem, miért - azt kell csak felkapott egy rossz példa,

410
00:38:37,330 --> 00:38:44,940
de ebben az esetben, ha "a" történt válnak 0-után kapok az 5 bit, így most "a" értéke 0,

411
00:38:44,940 --> 00:38:48,730
ez az, amit az úgynevezett "integer overflow".

412
00:38:48,730 --> 00:38:54,370
Szerint a Wikipedia, "Szemben a XOR swap, ez a változás megköveteli, hogy az általa használt egyes módszerek

413
00:38:54,370 --> 00:38:59,780
annak biztosítására, hogy x + y ne okozza egész szám túlcsordulás. "

414
00:38:59,780 --> 00:39:08,350
Szóval ez nem sikerül, ez volt integer túlcsordulás, de valami rosszat tettem.

415
00:39:08,350 --> 00:39:10,520
Nem vagyok benne biztos. Megpróbálom, hogy dolgozzon ki egy másikkal.

416
00:39:10,520 --> 00:39:13,640
[Student] Nos, nem egész túlcsordulás, ha akarsz, hogy egy szám van

417
00:39:13,640 --> 00:39:16,640
nagyobb, mint a bitmennyiséget már kiosztott?

418
00:39:16,640 --> 00:39:23,730
Igen. Jelenleg 4 bit. Ez - volt 4 bit, mi majd próbálja hozzá 1-et, így a végén 5 bit.

419
00:39:23,730 --> 00:39:26,690
De az ötödik bit csak elvágják, igen.

420
00:39:26,690 --> 00:39:28,970
Ez talán ténylegesen -

421
00:39:28,970 --> 00:39:33,010
[Student] Ez azt dobja meg egy hiba, vagy ez - azt, hogy dobja a hibát?

422
00:39:33,010 --> 00:39:40,720
Szóval nincs hiba. Amikor eljut a gyülekezési szintet, egy speciális bit

423
00:39:40,720 --> 00:39:47,020
valahol van beállítva, hogy az említett volt egy túlcsordulás, de a C akkor milyen, csak nem foglalkozik vele.

424
00:39:47,020 --> 00:39:55,160
Te tényleg nem lehet foglalkozni vele, kivéve, ha speciális összeszerelési utasításokat a C.

425
00:39:55,160 --> 00:39:58,110
Gondoljunk XOR swap.

426
00:39:58,110 --> 00:40:02,220
És azt hiszem, a Wikipedia volna is azt mondja, hogy -

427
00:40:02,220 --> 00:40:07,310
Így is nevelkedett moduláris aritmetika, úgyhogy azt hiszem, volt, elméletben, ezzel moduláris aritmetika

428
00:40:07,310 --> 00:40:11,160
mikor azt mondtam, hogy 0 - 1 15 újra.

429
00:40:11,160 --> 00:40:15,410
Annak érdekében, hogy esetleg valóban - rendszeres processzor, amely nem 0-1 = 15.

430
00:40:15,410 --> 00:40:20,430
Mivel a végén a 0, akkor vonjuk 1, így aztán ez csak titokban vissza körül 1111.

431
00:40:20,430 --> 00:40:28,930
Szóval ez az algoritmus is valójában dolgozik, az a + b, az a - b, b - a, hogy lehet jó.

432
00:40:28,930 --> 00:40:34,030
De van néhány processzorokra, amelyek nem tehetem, és ez így nem lenne jó ezekben a konkrét is.

433
00:40:34,030 --> 00:40:39,880
XOR csere fog működni minden processzor. Oké.

434
00:40:39,880 --> 00:40:42,280
Az elképzelés az, hogy ez elvileg ugyanaz, mégis.

435
00:40:42,280 --> 00:40:50,120
Ahol mi használ XOR, hogy valahogy az információt mindkét ba 1 a változók,

436
00:40:50,120 --> 00:40:54,120
majd húzza ki az információkat az egyes változók újra.

437
00:40:54,120 --> 00:41:04,330
Tehát csinál akárki volna ötletek / a válasz?

438
00:41:04,330 --> 00:41:14,540
[Student válasz, érthetetlen]

439
00:41:14,540 --> 00:41:22,220
Szóval ez kell dolgoznia, és azt is, XOR kommutatív.

440
00:41:22,220 --> 00:41:27,620
Függetlenül attól, hogy ezek a 2 szám történetesen itt,

441
00:41:27,620 --> 00:41:30,100
ez az eredmény nem lesz ugyanaz.

442
00:41:30,100 --> 00:41:35,800
Tehát a ^ b = b ^ a.

443
00:41:35,800 --> 00:41:51,860
Lehet is látni ezt, mint egy írásos ^ = b, b ^ = a, a ^ = b újra.

444
00:41:51,860 --> 00:42:00,200
Szóval ez van, és hogy miért is működik ez, gondolj a biteket.

445
00:42:00,200 --> 00:42:10,400
Segítségével egy kisebb számot, mondjuk 11001, és a 01100.

446
00:42:10,400 --> 00:42:12,790
Szóval ez az "a", ez b.

447
00:42:12,790 --> 00:42:15,540
Tehát a ^ = b.

448
00:42:15,540 --> 00:42:22,380
Mi lesz beállítás 'a' = a XOR e 2 dolog.

449
00:42:22,380 --> 00:42:32,920
Tehát 1 ^ 0 jelentése 1, 1 ^ 1 jelentése 0, 0 ^ 1 1, és 0 ^ 0 jelentése 0, 1 ^ 0 1 lehet.

450
00:42:32,920 --> 00:42:37,380
Tehát "a", ha megnézi a decimális szám, ez lesz -

451
00:42:37,380 --> 00:42:41,160
nem fogod látni sok a kapcsolat az eredeti "a" és az új "A"

452
00:42:41,160 --> 00:42:45,600
de ránézünk a bitek, az "a" most, mint egy háló az információ

453
00:42:45,600 --> 00:42:49,970
mind az eredeti, "a" és az eredeti b.

454
00:42:49,970 --> 00:42:57,930
Tehát, ha veszünk b ^ a, azt látjuk, hogy mi lesz a végén az eredeti "a."

455
00:42:57,930 --> 00:43:08,910
És ha vesszük az eredeti "a" ^ az új "a", azt látjuk, hogy a végén az eredeti b.

456
00:43:08,910 --> 00:43:18,380
Tehát (a ^ b) ^ b = az eredeti "a."

457
00:43:18,380 --> 00:43:27,910
És (a ^ b) ^ a = az eredeti b.

458
00:43:27,910 --> 00:43:37,010
Van - egy másik látásmód ez valami XOR maga mindig 0-ra.

459
00:43:37,010 --> 00:43:45,020
Így 1101 ^ 1101, az összes bit lesz ugyanaz.

460
00:43:45,020 --> 00:43:47,920
Tehát sosem lesz olyan eset, amikor 1 egy 0 és a másik 1 lehet.

461
00:43:47,920 --> 00:43:51,080
Szóval ez a 0000.

462
00:43:51,080 --> 00:43:57,240
Ugyanez ezzel. (A ^ b) ^ b, mint a ^ (b ^ b).

463
00:43:57,240 --> 00:44:03,680
(B ^ b) lesz 0, a ^ 0 csak megy, hogy "a", mivel az összes bit 0.

464
00:44:03,680 --> 00:44:08,050
Tehát az egyetlen is, hogy lesznek, ha "a" eredetileg egy 1 - volt is.

465
00:44:08,050 --> 00:44:12,070
És ugyanez a gondolat itt, biztos vagyok benne, ez is kommutatív.

466
00:44:12,070 --> 00:44:17,590
Igen. Azt mondtam azelőtt, hogy ez kommutatív.

467
00:44:17,590 --> 00:44:24,680
A ^ "a", és ez az asszociatív, így most (b ^ a) ^ a.

468
00:44:24,680 --> 00:44:28,970
És mi tehetünk b ^ (a ^ a).

469
00:44:28,970 --> 00:44:31,540
És megint, megkapjuk az eredeti b.

470
00:44:31,540 --> 00:44:37,120
Így "a" a jelenleg kombinációja "a" és b együtt.

471
00:44:37,120 --> 00:44:49,660
A mi új kombó "a" mondjuk b = combo 'a' ^ eredeti b, megkapjuk az eredeti "a."

472
00:44:49,660 --> 00:45:05,170
És most a = combo 'a' ^ az új b, ami az eredeti - vagy ami most mi volt "a" vagy b.

473
00:45:05,170 --> 00:45:13,620
Ez ebben az esetben idelent. Ez jelentése = b, öreg b.

474
00:45:13,620 --> 00:45:16,550
Tehát most minden visszatért a cserélték sorrendben.

475
00:45:16,550 --> 00:45:22,960
Ha tényleg megnézte a bitek, b = a ^ b, fog XOR e 2,

476
00:45:22,960 --> 00:45:33,920
és a válasz lesz erre, és akkor a = a ^ ab össze XOR-olva e 2 és a válasz ez.

477
00:45:33,920 --> 00:45:41,090
Kérdései vannak? Oké. Így az utolsó egy valamivel lényegesen nehezebb.

478
00:45:41,090 --> 00:45:43,180
[Student] Azt hiszem, van egy kérdés. >> Ó, sajnálom.

479
00:45:43,180 --> 00:45:49,380
[Student] Mi valójában gyorsabb? Ha ezt XOR, vagy pedig, ha nyilvánítja egy új változót?

480
00:45:49,380 --> 00:45:55,190
Tehát mi valójában gyorsabb, nyilvánító új változó vagy használja XOR cserélni?

481
00:45:55,190 --> 00:45:59,600
A válasz az, hogy minden valószínűség szerint egy átmeneti változót.

482
00:45:59,600 --> 00:46:05,780
És ez azért van, mert, ha ez fordított le - így a gyülekezési szinten,

483
00:46:05,780 --> 00:46:12,320
nincs olyan dolog, mint lokális változók vagy bármilyen ideiglenes változók, vagy ez a cucc.

484
00:46:12,320 --> 00:46:16,060
Olyanok, mint - van memória, és vannak nyilvántartások.

485
00:46:16,060 --> 00:46:20,920
Regiszterek, ahol a dolgok aktívan történik.

486
00:46:20,920 --> 00:46:24,750
Ne adjunk hozzá 2 dolgot a memóriában, akkor adjunk hozzá 2 dolgokat nyilvántartásokban.

487
00:46:24,750 --> 00:46:28,160
És hozza a dolgokat memóriába nyilvántartások majd adjunk hozzá őket,

488
00:46:28,160 --> 00:46:33,180
és akkor lehet, tegye vissza a memóriába, de az intézkedés történik nyilvántartásokban.

489
00:46:33,180 --> 00:46:38,750
Tehát amikor Ön használja az ideiglenes változó szemlélet, általában mi történik,

490
00:46:38,750 --> 00:46:42,810
ezek a 2 szám már nyilvántartásokban.

491
00:46:42,810 --> 00:46:46,570
És attól kezdve, miután elcserélték őket,

492
00:46:46,570 --> 00:46:51,540
ez lesz csak kezdje el a másik nyilvántartásba.

493
00:46:51,540 --> 00:46:56,510
Bárhol Ön már használja b, akkor az csak használja a nyilvántartásban már tárolása "a."

494
00:46:56,510 --> 00:47:02,180
Tehát nem kell semmit ténylegesen a csere. Igen?

495
00:47:02,180 --> 00:47:05,690
[Student] De ez is tovább tart, memória, igaz?

496
00:47:05,690 --> 00:47:10,280
Ez csak több memóriát, ha kell tárolni, hogy az ideiglenes változó.

497
00:47:10,280 --> 00:47:14,830
Mint ha a későbbiekben használni, hogy átmeneti változó megint valahol,

498
00:47:14,830 --> 00:47:18,920
majd - vagy rendelni valamit az átmeneti változó.

499
00:47:18,920 --> 00:47:24,630
Tehát, ha bármely pontján az időben "a" b in temp tekintette különböző értékek, vagy valami,

500
00:47:24,630 --> 00:47:30,680
akkor megy, hogy a különböző helyszíneken a memóriában, de igaz, hogy

501
00:47:30,680 --> 00:47:34,800
számos helyi változók, amelyek csak létezik nyilvántartásokban.

502
00:47:34,800 --> 00:47:44,370
Ebben az esetben, ez soha nem a memóriába, és így te soha nem pazarlás memória.

503
00:47:44,370 --> 00:47:58,620
Oké. Utolsó kérdés egy kicsit.

504
00:47:58,620 --> 00:48:04,850
Tehát itt, ebben a CS50 készülék, van egy szótár.

505
00:48:04,850 --> 00:48:12,390
És ennek az az oka, mert [?? B66] egy helyesírás-ellenőrző hol fogsz írni

506
00:48:12,390 --> 00:48:15,780
használatával hash táblákat vagy próbálkozás vagy valami adatszerkezet.

507
00:48:15,780 --> 00:48:22,660
Fogsz írni a helyesírás-ellenőrző, és fogod használni ezt a szótárt csinálni.

508
00:48:22,660 --> 00:48:28,280
De ez a probléma, mi csak fog nézni, hogy ha egy szó szerepel a szótárban.

509
00:48:28,280 --> 00:48:31,250
Tehát ahelyett, hogy tárolja a teljes szótár néhány adatszerkezet

510
00:48:31,250 --> 00:48:35,180
majd keres egy egész dokumentumot, hogy ha bármi van elgépelt,

511
00:48:35,180 --> 00:48:38,490
mi csak szeretnénk találni 1 szó. Így tudjuk csak beolvasni az egész szótár

512
00:48:38,490 --> 00:48:44,300
és ha nem talál a szó az egész szótárban, akkor nem volt ott.

513
00:48:44,300 --> 00:48:52,150
Ha beolvasni az egész szótárt, és nem látja a szót, akkor jók vagyunk, mi megtaláltuk.

514
00:48:52,150 --> 00:48:56,580
Azt mondja, hogy itt akarunk kezdeni a C a file-kezelési funkció,

515
00:48:56,580 --> 00:48:59,930
mert azt akarjuk, hogy olvassa el a szótár,

516
00:48:59,930 --> 00:49:07,680
de adok a célzást itt, hogy mely funkciókat kell gondolni.

517
00:49:07,680 --> 00:49:11,510
Írok őket Spaces.

518
00:49:11,510 --> 00:49:20,490
Tehát a legfontosabbak akkor szeretnénk, hogy nézd meg a f nyitott, majd elkerülhetetlenül f zárt,

519
00:49:20,490 --> 00:49:26,540
ami megy a végén a program, és f szkennelés f.

520
00:49:26,540 --> 00:49:31,060
Akkor is hasznos lehet f olvasni, de akkor valószínűleg nem akar

521
00:49:31,060 --> 00:49:34,200
mert - nem a végén, hogy az igénylő.

522
00:49:34,200 --> 00:49:41,880
F szkennelés f amit fogsz használni, hogy átvizsgálja az szótárban.

523
00:49:41,880 --> 00:49:46,370
És így nem kell kódolni fel a megoldást, csak próbálja meg, és mint pszeudo-kód az utat

524
00:49:46,370 --> 00:50:05,200
a megoldást, és aztán megbeszéljük.

525
00:50:05,200 --> 00:50:14,110
És valóban, hiszen már adtam neked ezeket, ha bemegy bármelyik terminálon, vagy a készülék a shell,

526
00:50:14,110 --> 00:50:18,250
Én - Én általában - ha nem láttam még, nem tudom, ha nem az osztályban,

527
00:50:18,250 --> 00:50:23,490
de az ember, így a man oldalakat, elég hasznos nézi most elég sok olyan funkciót.

528
00:50:23,490 --> 00:50:27,330
Szóval tudom csinálni, mint, ember f, szkennelés f.

529
00:50:27,330 --> 00:50:32,300
Ez most az információk a leolvasó f családnak funkciók.

530
00:50:32,300 --> 00:50:37,070
Azt is megtehetik férfi f, nyitott, és ez ad nekem a részleteket e.

531
00:50:37,070 --> 00:50:40,750
Tehát, ha tudod, hogy mit funkciót használ, vagy olvasod kódot

532
00:50:40,750 --> 00:50:43,000
és látod néhány funkciót és te, mint: "Mit jelent ez csinálni?"

533
00:50:43,000 --> 00:50:45,280
Csak ember függvény neve.

534
00:50:45,280 --> 00:50:47,340
Van egy pár furcsa példák, amikor lehet, hogy azt mondják

535
00:50:47,340 --> 00:50:51,620
tetszik. Man 2 a függvény nevét, vagy man 3 e funkció neve,

536
00:50:51,620 --> 00:50:58,230
de csak meg kell csinálni, ha az ember függvény neve nem történik meg a munka az első alkalommal.

537
00:50:58,230 --> 00:51:03,010
[Student] Szóval olvasom a man oldalt nyitott, de én még mindig zavaros, hogyan kell használni, és a programot.

538
00:51:03,010 --> 00:51:06,170
Oké. Sok a man oldalak kevesebb, mint hasznos.

539
00:51:06,170 --> 00:51:08,470
Ők több hasznos, ha már tudják, mit csinálnak

540
00:51:08,470 --> 00:51:12,670
és akkor csak meg kell emlékezni a sorrendben az érveket, vagy valami.

541
00:51:12,670 --> 00:51:17,640
Vagy adhat egy általános áttekintést, de néhány közülük nagyon nyomasztó.

542
00:51:17,640 --> 00:51:22,220
Mint f f vizsgálat is. Ez adja az információt az összes ezeket a funkciókat,

543
00:51:22,220 --> 00:51:28,120
és 1 vonal idelent történik mondani, "F szkennelés f olvas a húr pontot vagy patak."

544
00:51:28,120 --> 00:51:32,360
De f megnyitni. Szóval, hogyan használjuk f nyitva?

545
00:51:32,360 --> 00:51:38,470
Az ötlet, hogy egy programot, amely a tennivalók fájl I / O, hogy

546
00:51:38,470 --> 00:51:45,070
akkor először meg kell nyitni a fájlt akarsz csinálni dolgokat, és elkerülhetetlenül

547
00:51:45,070 --> 00:51:51,220
olvasott dolgokat, hogy a fájl, és csinálni dolgokat velük.

548
00:51:51,220 --> 00:51:55,350
F nyitott az, amit használ, hogy nyissa meg a fájlt.

549
00:51:55,350 --> 00:52:04,190
A dolog kapjuk vissza, akkor mi fájlt akarunk megnyitni, ez ad nekünk a -

550
00:52:04,190 --> 00:52:11,970
itt azt mondja: "/ user / share / dict / szavak."

551
00:52:11,970 --> 00:52:16,740
Ezt a fájlt szeretnénk megnyitni, és szeretnénk megnyitni -

552
00:52:16,740 --> 00:52:21,440
van, hogy egyértelműen meg akár akarjuk megnyitni vagy olvasni, ha azt akarjuk, hogy nyissa meg a levelet.

553
00:52:21,440 --> 00:52:26,490
Van egy pár kombinációk és a cucc, de mi szeretnénk megnyitni ezt olvasatra.

554
00:52:26,490 --> 00:52:29,380
Azt akarjuk, hogy olvassa el a fájlt.

555
00:52:29,380 --> 00:52:34,290
Szóval mit jelent ez a visszatérés? Visszaküldi egy fájlt csillag (*),

556
00:52:34,290 --> 00:52:37,260
és én csak azt mutatják, mindent a változó f, így a *

557
00:52:37,260 --> 00:52:40,840
megint, ez a mutató, de nem akarunk foglalkozni mutatók.

558
00:52:40,840 --> 00:52:46,470
Azt hiszem, mint f, f most a változó fogsz használni, hogy képviselje a fájlt.

559
00:52:46,470 --> 00:52:49,850
Tehát, ha el szeretnénk olvasni a fájlt, akkor olvassa f.

560
00:52:49,850 --> 00:52:54,820
Ha azt szeretnénk, hogy zárja be a fájlt, akkor zárja f.

561
00:52:54,820 --> 00:53:00,350
Így a végén a program, amikor elkerülhetetlenül szeretné zárni a fájlt, mit tegyünk?

562
00:53:00,350 --> 00:53:06,750
Azt akarjuk zárni f.

563
00:53:06,750 --> 00:53:12,600
Tehát most az utolsó fájl függvényt fogunk használni kívánt a vizsgálat f, f szkennelés f.

564
00:53:12,600 --> 00:53:20,930
És, hogy mi csinál ez ellenőrzi a fájlszintű keres egy minta egyezik.

565
00:53:20,930 --> 00:53:39,100
Keresi a man oldalon van, azt látjuk, int f szkennelés f, figyelmen kívül hagyja a visszatérési érték most.

566
00:53:39,100 --> 00:53:45,230
Az első érv az a fájl * patak, így az első érv fogunk kíván haladni a f.

567
00:53:45,230 --> 00:53:47,900
Mi szkennelés alatt f.

568
00:53:47,900 --> 00:53:53,680
A második érv a format string.

569
00:53:53,680 --> 00:53:58,310
Adok neked egy format string most.

570
00:53:58,310 --> 00:54:05,180
Azt hiszem, éppen mondani, 127s \ n, egy csomó, ami felesleges.

571
00:54:05,180 --> 00:54:12,490
Az az elképzelés, hogy mi formátum string, nem tudsz gondolni vizsgálat f ellentéteként a nyomtatott f.

572
00:54:12,490 --> 00:54:17,160
Szóval print f, print f is használják ezt a fajta formátumot paraméter,

573
00:54:17,160 --> 00:54:25,000
de a nyomtatott f mit csinálunk jelentése - nézzük egyenértékű.

574
00:54:25,000 --> 00:54:32,550
Szóval nyomtatás f, és valójában még f print f, ahol az első érv lesz f.

575
00:54:32,550 --> 00:54:40,980
Amikor nyomtat f, mondhatnánk valami ilyesmit, "print 127s \ n", és majd ha átadjuk neki néhány húr,

576
00:54:40,980 --> 00:54:44,050
ez fog nyomtatni ezt a fonalat, majd egy új sort.

577
00:54:44,050 --> 00:54:49,690
Mi 127 azt jelenti, biztos vagyok benne, de én még soha nem korlátozódik magam hozzá,

578
00:54:49,690 --> 00:54:52,470
Ugye nem is kell mondani, '127 'a nyomtatási f,

579
00:54:52,470 --> 00:54:57,090
de mit jelent ez nyomtassa ki az első 127 karakter.

580
00:54:57,090 --> 00:54:59,350
Szóval biztos vagyok benne, hogy ez a helyzet. A Google erre.

581
00:54:59,350 --> 00:55:03,000
De a következő egy vagyok, majdnem azt jelenti, hogy pozitív.

582
00:55:03,000 --> 00:55:08,880
Szóval ez nyomtassa az első 127 karakter, majd egy új sort.

583
00:55:08,880 --> 00:55:14,680
F f szkennelés most, ahelyett, hogy változó és nyomtatása,

584
00:55:14,680 --> 00:55:22,620
ez fog nézni néhány string, és tárolja a mintát a változót.

585
00:55:22,620 --> 00:55:26,360
Nézzünk ténylegesen használni szkennelési f egy másik példa.

586
00:55:26,360 --> 00:55:31,670
Szóval azt mondom, volt néhány int, x = 4,

587
00:55:31,670 --> 00:55:41,110
, és azt akartuk, hogy hozzon létre egy húr készült - akart létrehozni a húr

588
00:55:41,110 --> 00:55:44,250
olyan volt, mint ez jön ki jóval később,

589
00:55:44,250 --> 00:55:49,020
valami, ami olyan, mint 4.jpg.

590
00:55:49,020 --> 00:55:51,870
Tehát ez lehet egy program, ahol lesz összeget számláló,

591
00:55:51,870 --> 00:55:56,420
Összefoglalva elleni i, és szeretné menteni egy csomó kép.

592
00:55:56,420 --> 00:56:02,430
Szóval azt akarod menteni i.jpg, ahol i néhány iteráció a hurok.

593
00:56:02,430 --> 00:56:05,500
Szóval hogyan lehet, hogy ez a szöveg az adott JPEG?

594
00:56:05,500 --> 00:56:11,720
Ha akarta nyomtatni 4.jpg tudtuk mondjuk print f,% d.jpg,

595
00:56:11,720 --> 00:56:14,410
és akkor lenne kinyomtatni az adott JPEG.

596
00:56:14,410 --> 00:56:20,050
De ha meg akarjuk menteni a húr 4.jpg, az általunk használt beolvasási f.

597
00:56:20,050 --> 00:56:30,860
Szóval húr s - tulajdonképpen mi Nem látom - karakter, char s, menjünk 100.

598
00:56:30,860 --> 00:56:35,400
Szóval én csak bejelentett néhány tömb 100 karakter,

599
00:56:35,400 --> 00:56:39,830
és ez az, amit mi elkerülhetetlenül fognak tárolni, hogy a JPEG-be

600
00:56:39,830 --> 00:56:47,920
Így fogunk használni szkennelési f, és a formátum, hogy azt mondanánk% d.jpg

601
00:56:47,920 --> 00:56:54,980
annak érdekében, hogy nyomtassa 4.jpg, a formátum ennek lesz% d.jpg.

602
00:56:54,980 --> 00:57:04,020
Tehát a formátum% d.jpg, mit akarunk cserélni% d-vel az x,

603
00:57:04,020 --> 00:57:06,590
és most kell tárolni, hogy a húr valahol.

604
00:57:06,590 --> 00:57:12,500
És hol fogunk tárolásához string a tömbben s.

605
00:57:12,500 --> 00:57:21,640
Szóval, miután ezt a kódsort, s, ha nyomtatni f,% s a változó s,

606
00:57:21,640 --> 00:57:26,280
ez nyomdába 4.jpg.

607
00:57:26,280 --> 00:57:38,930
Tehát f szkennelés f ugyanaz, mint a vizsgálat f, kivéve most néz át ezt a fájlt

608
00:57:38,930 --> 00:57:43,600
milyen tárolni s.

609
00:57:43,600 --> 00:57:46,160
Ez az, amit az utolsó érv lesz.

610
00:57:46,160 --> 00:57:54,170
Azt akarjuk, hogy tárolni - "Scan f családnak funkciók vizsgál mindkét szerinti formában próbálta alább.

611
00:57:54,170 --> 00:58:02,450
Ha vannak tárolva a helyét pontok adhatja vissza - "

612
00:58:02,450 --> 00:58:12,910
Nem, talán jó lesz. Hadd gondolkozzam egy kicsit.

613
00:58:12,910 --> 00:58:26,350
Szóval vizsgálat f nem - mi a fene az a funkció, amely nem az?

614
00:58:26,350 --> 00:58:31,650
Tehát vizsgálat f nem fog venni egy egész, és nem pont jpg.

615
00:58:31,650 --> 00:58:43,490
Ez lesz [motyog].

616
00:58:43,490 --> 00:58:49,360
Mentés int változó karakterlánc int C.

617
00:58:49,360 --> 00:58:55,940
Mi ez a változó, vagy mi ez a függvény neve?

618
00:58:55,940 --> 00:59:04,950
Igen. Ez - igen. Szóval, amit én, hogy meghatározzák, mielőtt volt, s print f,

619
00:59:04,950 --> 00:59:09,820
amely - ami sokkal több értelme, hogy miért mondtam, hogy sokkal több volt, mint a print f.

620
00:59:09,820 --> 00:59:14,700
Scan f még mindig olyan, mint nyomtatott f, de s print f fog olvasni rajta

621
00:59:14,700 --> 00:59:17,510
és cserélje ki a változók, és most tárolja a string.

622
00:59:17,510 --> 00:59:19,620
Ahelyett, nyomtatás, ez tárolja a string.

623
00:59:19,620 --> 00:59:25,070
Így figyelmen kívül, hogy az teljesen. Továbbra is úgy gondolja, az a formátum meghatározásakor úgy, mint, hogy a nyomtatott f.

624
00:59:25,070 --> 00:59:34,510
Tehát most, ha azt akartuk csinálni a 4.jpg dolgot tennénk s print f, x e.

625
00:59:34,510 --> 00:59:38,520
Tehát mi szkennelés f csinál -, hogy mi a kérdés lesz?

626
00:59:38,520 --> 00:59:40,820
[Student] Én csak zavaros, amit mi próbálunk csinálni itt

627
00:59:40,820 --> 00:59:43,450
azzal a JPEG. Meg tudod magyarázni, hogy az 1 több időt?

628
00:59:43,450 --> 00:59:52,710
Szóval ez volt - ez kevésbé Relevent az f f szkennelés most, remélhetőleg, akkor kösse vissza valamilyen módon.

629
00:59:52,710 --> 01:00:02,240
De amit eredetileg is szándékozik mutatni volt - ez valójában közvetlenül kapcsolódik ezekhez [?? F5]

630
01:00:02,240 --> 01:00:08,520
Fogsz használni s print f, ahol azt mondjuk, hogy 100 képet,

631
01:00:08,520 --> 01:00:13,630
és szeretné elolvasni a kép 1.jpg, 2.jpg, 3.jpg.

632
01:00:13,630 --> 01:00:21,520
Annak érdekében tehát, hogy ezt megtehessük, meg kell f nyílt, és akkor át kell adni a string kívánt nyitni.

633
01:00:21,520 --> 01:00:30,020
Szóval mi lenne megnyitni kívánt 1.jpg, annak érdekében, hogy a húr, ami 1.jpg,

634
01:00:30,020 --> 01:00:37,660
mi s nyomtatási f% d.jpg--mi nem megtenni int i = 0.

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

636
01:00:46,580 --> 01:00:51,130
Szóval, s print f% d.jpg i.

637
01:00:51,130 --> 01:00:56,320
Így aztán ebben a sorban, most a változó vagy a tömb s fog 1.jpg.

638
01:00:56,320 --> 01:01:10,610
Vagy 0.jpg, 1.jpg, 2.jpg. És így tudjuk megnyitni, viszont minden egyes kép olvasásra.

639
01:01:10,610 --> 01:01:19,550
Szóval ez az, amit s nyomtassa f nem. Látod, mit s nyomtathat f most csinál?

640
01:01:19,550 --> 01:01:25,720
[Student] Oké, szóval tart - létrehoz egy string, something.jpg, majd tárolja azt.

641
01:01:25,720 --> 01:01:30,360
Igen. Hoz létre - ez egy másik formátum string, mint f szkennelési és nyomtatási f,

642
01:01:30,360 --> 01:01:37,530
ha beilleszti az összes változót a második érv lehet, s ellentétben a i.

643
01:01:37,530 --> 01:01:42,280
Talán - Úgy értem, hogy ez a helyzet. De bármilyen sorrendben érvek.

644
01:01:42,280 --> 01:01:45,440
Ez lesz beszúrni az összes változó a format string

645
01:01:45,440 --> 01:01:52,250
majd tárolja a mi puffer; hívjuk, hogy egy puffer, akkor ott vagyunk tárolása string.

646
01:01:52,250 --> 01:02:00,750
Tehát tároló belsejében s helyesen formázott string,% d miután helyett 4.

647
01:02:00,750 --> 01:02:08,080
[Student] Tehát ha ezt tette, a változó f csak lesz újraosztani?

648
01:02:08,080 --> 01:02:18,110
Igen. Tehát kellene zárni az eredeti f mielőtt ezt.

649
01:02:18,110 --> 01:02:22,810
De - és akkor is, ha nem volt olyan f megnyitása itt, akkor azt kell mondanunk -

650
01:02:22,810 --> 01:02:29,280
Igen. De nyitna száz különböző fájlokat.

651
01:02:29,280 --> 01:02:37,360
[Student] De akkor nem tudja elérni, vagy - oké.

652
01:02:37,360 --> 01:02:44,230
Oké. Szóval vizsgálat f, f szkennelés f, egyfajta ugyanezt a gondolatot,

653
01:02:44,230 --> 01:02:53,610
de ahelyett, ahelyett, tárolás egy string, ez több, mint te most

654
01:02:53,610 --> 01:03:02,420
megy át a szúrás és mintaillesztési ellen húr és tárolása az eredményeket változókat.

655
01:03:02,420 --> 01:03:11,290
Használhatja szkennelés f elemezhető át ilyesmit 4.jpg, és tárolja az egész a 4. összeget int x.

656
01:03:11,290 --> 01:03:13,430
Ez az, amit tudunk használni vizsgálat f a.

657
01:03:13,430 --> 01:03:16,300
F f vizsgálat fog tenni, hogy a parancssorban.

658
01:03:16,300 --> 01:03:19,200
Én valójában nagyon benne, hogy ez az, amit a CS50 könyvtár nem.

659
01:03:19,200 --> 01:03:29,050
Szóval, amikor azt mondod, "get int," ez beolvasás f-nek vége - scan f az út kapsz felhasználói bevitel.

660
01:03:29,050 --> 01:03:34,670
F f vizsgálat fogja ugyanezt csinálja, de a fájlt olvasni át.

661
01:03:34,670 --> 01:03:41,090
Szóval itt vagyunk, szkennelés át ezt a fájlt.

662
01:03:41,090 --> 01:03:45,460
A minta megpróbáljuk meccsek nagyjából karakterlánc, amely 127 karakter hosszú

663
01:03:45,460 --> 01:03:48,100
majd egy új sort

664
01:03:48,100 --> 01:03:54,770
Szóval biztos vagyok benne, hogy akár csak mondani: "meccsek s", mivel a szótárban

665
01:03:54,770 --> 01:03:57,770
mi történik, hogy, mi garantáltan nincs szó, hogy a hosszú,

666
01:03:57,770 --> 01:04:03,310
és f f vizsgálat, azt hiszem, meg fog állni az új vonal nem számít, mit.

667
01:04:03,310 --> 01:04:06,970
De mi tartalmazza az új sort a mérkőzés, és -

668
01:04:06,970 --> 01:04:13,960
[Student] Ha mi nem tartalmazza az új vonal, nem lenne megtalálni részei szóval?

669
01:04:13,960 --> 01:04:22,900
Ez - az egyes - nézett a szótárban -

670
01:04:22,900 --> 01:04:26,200
Tehát a szótárban, ezek mind a mi szó.

671
01:04:26,200 --> 01:04:30,500
Mindegyik új sorban.

672
01:04:30,500 --> 01:04:32,510
A vizsgálat f fog felvenni ezt a szót.

673
01:04:32,510 --> 01:04:38,750
Ha nem tartalmazza az új sort, akkor lehetséges, hogy a következő vizsgálat f majd csak olvasni az új vonal.

674
01:04:38,750 --> 01:04:44,180
De ideértve az új sort, akkor majd csak figyelmen kívül hagyja az új vonal.

675
01:04:44,180 --> 01:04:49,440
De mi soha nem része egy szót, hiszen mi mindig olvasott fel egy új sort, nem számít, mit.

676
01:04:49,440 --> 01:04:54,530
[Student] De mi van, ha keresni a "Cissa," mint Cissa.

677
01:04:54,530 --> 01:04:57,380
Vajon úgy találják, hogy, és azt mondják, hogy ez a mérkőzés?

678
01:04:57,380 --> 01:05:05,110
Tehát itt vagyunk - ez olvasható - ez valójában egy jó pont.

679
01:05:05,110 --> 01:05:10,660
Mi soha nem az aktuális - a szó keresünk az első parancssori argumentum.

680
01:05:10,660 --> 01:05:16,460
Szóval húr, Szó = argv 1.

681
01:05:16,460 --> 01:05:20,020
Tehát a húr keresünk az argv 1.

682
01:05:20,020 --> 01:05:23,290
Mi nem keres egy szót egyáltalán a mi szkennelési f.

683
01:05:23,290 --> 01:05:28,030
Mit csinálunk a vizsgálat f kezd minden szót a szótárban,

684
01:05:28,030 --> 01:05:34,320
majd egyszer már ezt a szót fogunk használni strcmp összehasonlítani őket.

685
01:05:34,320 --> 01:05:39,210
Fogunk összehasonlítani a szót, és amit csak olvasni be

686
01:05:39,210 --> 01:05:45,110
Így elkerülhetetlen, megyünk a végén csinál egy csomó vizsgálat fs

687
01:05:45,110 --> 01:05:52,130
amíg ez csak azért történik, hogy a vizsgálat f vissza fog térni -

688
01:05:52,130 --> 01:05:54,800
tér majd vissza egy, amennyiben azt kiegyenlített egy új szó,

689
01:05:54,800 --> 01:06:01,360
és ez vissza fog térni valami mást, amint azt elmulasztotta, hogy megfeleljen a szót.

690
01:06:01,360 --> 01:06:08,440
Mi olvassa az egész szótárt, tárolása sorról sorra minden szót a változó s.

691
01:06:08,440 --> 01:06:17,240
Aztán hasonlítják szót s, és ha az összehasonlítás == 0,

692
01:06:17,240 --> 01:06:21,650
strcmp történik, hogy 0, ha egy mérkőzés került sor.

693
01:06:21,650 --> 01:06:31,510
Tehát, ha ez 0, akkor tudunk nyomtatni f, kiegyenlített,

694
01:06:31,510 --> 01:06:35,370
vagy szó a szótárban, vagy amit akarsz nyomtatni f.

695
01:06:35,370 --> 01:06:41,450
És aztán - mi nem akarjuk f bezárásához újra és újra.

696
01:06:41,450 --> 01:06:50,410
Ez az a fajta dolog, amit akarok, és mi nem csak a keresett szót a szótárban.

697
01:06:50,410 --> 01:06:56,660
Így tudnánk csinálni, ha akarnánk keresni a motívum, Cissa, ahogy korábban is mondtam,

698
01:06:56,660 --> 01:07:00,260
ha azt akartuk, hogy vizsgálja meg az adott mintát, akkor ez nem abban az esetben,

699
01:07:00,260 --> 01:07:08,010
mert ez valójában nem egy szó, hanem a szavak a szótárban történik, van, hogy benne.

700
01:07:08,010 --> 01:07:13,560
Szóval ez egyezik a szóval, de ez részhalmaza a szó nem egy szó maga.

701
01:07:13,560 --> 01:07:17,250
De ez nem így mi használjuk, mi olvasod minden szó

702
01:07:17,250 --> 01:07:19,740
majd összehasonlítjuk a szó van a szó.

703
01:07:19,740 --> 01:07:25,780
Szóval mindig összehasonlítva a teljes szót.

704
01:07:25,780 --> 01:07:29,620
Tudok küldeni a végleges megoldásokat kínálunk.

705
01:07:29,620 --> 01:07:32,050
Ez a fajta szinte a helyes választ, azt hiszem.

706
01:07:32,050 --> 01:07:34,720
[Student megjegyzést, érthetetlen]

707
01:07:34,720 --> 01:07:40,870
Oh, nem tudok megszabadulni az ilyet? Char s, azt hiszem, azt mondtuk, 127 - Nem emlékszem, mi a legnagyobb is.

708
01:07:40,870 --> 01:07:44,100
Majd csak nem 128, így most s elég hosszú.

709
01:07:44,100 --> 01:07:46,570
Nem kell nyomtatni semmit.

710
01:07:46,570 --> 01:07:56,440
Mi is szeretne majd be kell zárni a fájlt, és hogy kell a helyes választ.

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