1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Review] [Quiz 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Joseph Ong] [Harvardeko Unibertsitateko]

3
00:00:05,000 --> 00:00:08,000
>> [Hau da CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Hey, guztiontzat.

5
00:00:10,000 --> 00:00:15,000
Ongi etorri Quiz 0, hau da, egiten ari Asteazkena hau saio berrikuspena.

6
00:00:15,000 --> 00:00:19,000
Zer da gaur gauean egin behar dugu, naiz 3 TFS beste I,

7
00:00:19,000 --> 00:00:24,000
eta elkarrekin ikastaroaren zer egin dugu hain urruti berrikuspena baten bidez joan goaz.

8
00:00:24,000 --> 00:00:27,000
Ez da% 100 integrala izango du, baina ideia bat hobea eman beharko luke

9
00:00:27,000 --> 00:00:31,000
zer dagoeneko baduzu behera eta zer behar duzun Asteazkena aurretik ikasteko.

10
00:00:31,000 --> 00:00:34,000
Eta sentitzen free eskua altxatzeko galdera ari gara joan,

11
00:00:34,000 --> 00:00:38,000
baina kontuan hartu ahal izango dugun denbora pixka bat ere izan da amaiera-

12
00:00:38,000 --> 00:00:41,000
lortuko dugu bada, minutu gutxiren buruan, ordezko-eta, oro har, galderak egin,

13
00:00:41,000 --> 00:00:47,000
beraz, mantendu kontuan, eta, beraz, Aste 0 hasieran hasi goaz.

14
00:00:47,000 --> 00:00:50,000
>> [0 Review Quiz!] [Taldea 0] [Lexi Ross] Baina egin aurretik let-en buruz hitz egin

15
00:00:50,000 --> 00:00:53,000
galdetegia logistika.

16
00:00:53,000 --> 00:00:55,000
>> [Logistika] [Quiz gertatzen hitzaldi-lieu Asteazkena 10/10]

17
00:00:55,000 --> 00:00:57,000
>> [(Ikus xehetasun gehiagorako http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf)] da, urriaren 10ean, asteazkena.

18
00:00:57,000 --> 00:01:00,000
>> Asteazkena honetan, eta URL honen baduzu hemen,

19
00:01:00,000 --> 00:01:03,000
den ere CS50.net-'s esteka bat besterik ez da

20
00:01:03,000 --> 00:01:06,000
non oinarritzen buruzko informazioa ikusi ahal izango duzu

21
00:01:06,000 --> 00:01:10,000
zure azken izena edo eskola-afiliazio, baita

22
00:01:10,000 --> 00:01:14,000
buruz zehazki zer galdetegiaren eta estali egingo galdera mota iritsi zarela kontatzen du.

23
00:01:14,000 --> 00:01:19,000
Gogoan izan ere aukera izango duzula atalean galdetegia berrikusi,

24
00:01:19,000 --> 00:01:21,000
beraz, zure TFS praktikan arazo batzuk baino gehiago behar da joan,

25
00:01:21,000 --> 00:01:29,000
eta non behar oraindik aztertzeko galdetegia ikusteko beste aukera ona izan da.

26
00:01:29,000 --> 00:01:32,000
Dezagun Bits 'n' Bytes hasieran hasiko da.

27
00:01:32,000 --> 00:01:35,000
Gogoratu pixka bat, besterik gabe, 0 edo 1,

28
00:01:35,000 --> 00:01:38,000
eta byte bat 8 ​​bit horien bilduma bat da.

29
00:01:38,000 --> 00:01:42,000
Dezagun bit bilduma hau begiratu hemen.

30
00:01:42,000 --> 00:01:44,000
Ahal izango zenbat bit ez dira irudikatu behar dugu.

31
00:01:44,000 --> 00:01:48,000
Non gaude zenbatu besterik ez, horietako 8, zortzi 0 edo 1 unitate.

32
00:01:48,000 --> 00:01:51,000
Eta ez baitago 8 bit, byte 1,

33
00:01:51,000 --> 00:01:53,000
eta dezagun bihurtzeko hamaseitarrean.

34
00:01:53,000 --> 00:01:58,000
Hamaseitarra 16 oinarria da, eta nahiko erraza da bihurtu

35
00:01:58,000 --> 00:02:01,000
bitarra zenbaki bat, hau da, zer dela, hamaseitarrean zenbaki bat.

36
00:02:01,000 --> 00:02:04,000
Egiten dugun guztia da, 4 talde ditugu,

37
00:02:04,000 --> 00:02:07,000
eta horiek digitu hamaseitarra egokia bihurtu dugu.

38
00:02:07,000 --> 00:02:11,000
4 talde eskuin-gehienak hasiko gara, eta, beraz, 0011.

39
00:02:11,000 --> 00:02:16,000
Hori bat 1 eta 2 izan behar du, eta, beraz, elkarrekin egiten 3.

40
00:02:16,000 --> 00:02:19,000
Eta gero dezagun 4 bloke beste begiratu.

41
00:02:19,000 --> 00:02:24,000
1101. Hori bat 1, bat 4, eta 8 bat izango da.

42
00:02:24,000 --> 00:02:28,000
Elkarrekin den 13 izango da, eta horrek D.

43
00:02:28,000 --> 00:02:32,000
Eta gogoratu hamaseitarrean ez gara joan 0 9 bidez dugu.

44
00:02:32,000 --> 00:02:36,000
0 joango gara F bidez, eta, beraz, 9 ondoren, 10 A corresponde

45
00:02:36,000 --> 00:02:40,000
11 B, et cetera non F 15.

46
00:02:40,000 --> 00:02:44,000
Hemen 13 D bat da,

47
00:02:44,000 --> 00:02:49,000
beraz, bihurtu hamartarra da egiten dugun guztia dugu benetan

48
00:02:49,000 --> 00:02:52,000
2 botere posizioa tratatzeko bakoitzean.

49
00:02:52,000 --> 00:02:58,000
Ko 1, bat 2, zero 4S, zero 8s, bata 16, et cetera,

50
00:02:58,000 --> 00:03:03,000
eta pixka bat zaila da zure burua konputatzeko, baina hurrengo diapositiba gara

51
00:03:03,000 --> 00:03:05,000
erantzuna ikusi ahal izango dugu hori.

52
00:03:05,000 --> 00:03:09,000
>> Funtsean, eskuineko aurrean ari gara atzera joan ezkerrera,

53
00:03:09,000 --> 00:03:14,000
eta, digitu bakoitzak biderkatzailea 2 dagokion boterea ari gara.

54
00:03:14,000 --> 00:03:19,000
Eta gogoratu, hamaseitarrean zenbaki horiek adierazteko dugu 0x hasieran

55
00:03:19,000 --> 00:03:23,000
beraz, ez dugu nahastu zenbaki hamartar batekin.

56
00:03:23,000 --> 00:03:29,000
On jarraituz, hau ASCII taula bat da,

57
00:03:29,000 --> 00:03:35,000
eta zer ASCII erabiltzen ditugu karaktere zenbakizko balioak mapatzeko.

58
00:03:35,000 --> 00:03:39,000
Kriptografia pset Gogoratu ASCII taula erabilera zabala egin genuen

59
00:03:39,000 --> 00:03:43,000
kriptografia hainbat metodo erabili ahal izateko,

60
00:03:43,000 --> 00:03:47,000
Caesar eta Vigenère zifratze, letrak desberdinak bihurtzeko

61
00:03:47,000 --> 00:03:52,000
Kate batean, erabiltzaileak emandako gakoa arabera.

62
00:03:52,000 --> 00:03:56,000
Dezagun begiratu, ASCII matematika apur bat.

63
00:03:56,000 --> 00:04:02,000
'P' + 1 begira, pertsonaia inprimaki Q izango litzateke,

64
00:04:02,000 --> 00:04:07,000
eta gogoratu '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
Eta, zer egingo bihurtzeko 2 forma horien artean dugu?

66
00:04:10,000 --> 00:04:13,000
Ez da benetan gogorregi.

67
00:04:13,000 --> 00:04:16,000
5 lortzeko '0 kentzen dugu '

68
00:04:16,000 --> 00:04:20,000
5 '0 artean leku 'eta '5 ez delako.'

69
00:04:20,000 --> 00:04:23,000
Beste modu 0 gehitu besterik ez dugu joan,

70
00:04:23,000 --> 00:04:25,000
beraz, sort aritmetika erregular bezala.

71
00:04:25,000 --> 00:04:29,000
Just gogoratu zerbait komatxorik inguruan ditu pertsonaia bat da.

72
00:04:29,000 --> 00:04:37,000
eta, beraz, ASCII taulan balio bat dagokio.

73
00:04:37,000 --> 00:04:40,000
Oro har, informatikako gaiak sartu mugimenduan.

74
00:04:40,000 --> 00:04:43,000
Algoritmo bat zer den eta nola programatzen erabiltzen ikasi genuen

75
00:04:43,000 --> 00:04:45,000
algoritmoak ezartzeko.

76
00:04:45,000 --> 00:04:48,000
Algoritmoak adibide batzuk oso sinplea bezalako zerbait

77
00:04:48,000 --> 00:04:51,000
zenbaki bat bakoiti edo bikoitia den ala ez egiaztatzeko.

78
00:04:51,000 --> 00:04:54,000
Hori dela gogoratzen zenbakia MOD 2 eta egiaztatu emaitza 0 bada.

79
00:04:54,000 --> 00:04:57,000
Hala bada, nahiz da. Hala ez bada, bakoitiak da.

80
00:04:57,000 --> 00:04:59,000
Eta hori benetan oinarrizko algoritmoa adibide bat da.

81
00:04:59,000 --> 00:05:02,000
>> Apur bat gehiago parte hartzen bilaketa bitarra da,

82
00:05:02,000 --> 00:05:05,000
joan beharko dugu, geroago berrikuspena saio.

83
00:05:05,000 --> 00:05:09,000
Eta programazio algoritmo bat hartzeko erabiltzen dugun terminoa da

84
00:05:09,000 --> 00:05:15,000
eta ordenagailua kodea bihurtzeko irakur daiteke.

85
00:05:15,000 --> 00:05:20,000
2 programazioaren adibide da Scratch

86
00:05:20,000 --> 00:05:22,000
hau da, zer egin Astea 0 dugu.

87
00:05:22,000 --> 00:05:25,000
Nahiz eta ez dugu benetan idatzi kodea gauzatzeko modu bat da

88
00:05:25,000 --> 00:05:29,000
algoritmo hau, hau da, zenbakiak 1-10 inprimatzeko,

89
00:05:29,000 --> 00:05:32,000
eta hemen gauza bera egin dugu, C programazio-lengoaia.

90
00:05:32,000 --> 00:05:41,000
Hauek dira funtzionalki baliokideak, hainbat hizkuntzatan edo sintaxi idatzia.

91
00:05:41,000 --> 00:05:44,000
Ondoren, adierazpen boolearra buruz ikasi dugu,

92
00:05:44,000 --> 00:05:48,000
eta boolearra balio bat da bai egia edo gezurra da,

93
00:05:48,000 --> 00:05:51,000
eta hemen, adierazpen boolearra oftentimes

94
00:05:51,000 --> 00:05:55,000
baldintzen barruan, hala badagokio (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
ondo, dagoeneko ezarri dugu, x = 5, beraz, baldintza hori egia ebaluatzeko.

96
00:06:00,000 --> 00:06:03,000
Eta, egia bada, edozein egoera azpian da

97
00:06:03,000 --> 00:06:08,000
ordenagailua ebaluatu, eta, beraz, kate hori inprimatutako egingo da

98
00:06:08,000 --> 00:06:12,000
irteera estandarra, eta epe baldintza

99
00:06:12,000 --> 00:06:16,000
edozein izanda ere, bada adierazpena parentesi barruan egiten dio erreferentzia.

100
00:06:16,000 --> 00:06:20,000
Gogoratu operadore guztiak.

101
00:06:20,000 --> 00:06:26,000
Gogoratu da && eta | | denean saiatzen ari gara baldintza 2 edo gehiago konbinatu

102
00:06:26,000 --> 00:06:30,000
== Ez = 2 gauzak berdinak diren ala ez egiaztatzeko.

103
00:06:30,000 --> 00:06:36,000
Gogoratu = zereginerako == boolearra operadorea da, berriz.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ eta, ondoren, behin betiko 2 dira auto-azalpen.

105
00:06:41,000 --> 00:06:45,000
Logika boolearra berrikuspena, oro har, hemen.

106
00:06:45,000 --> 00:06:48,000
Eta adierazpen boolearrak ere garrantzitsua loops,

107
00:06:48,000 --> 00:06:50,000
joan gara.

108
00:06:50,000 --> 00:06:56,000
3 loops mota ikasi genuen hain urruti CS50, bitartean, eta egin bitartean.

109
00:06:56,000 --> 00:06:59,000
Eta garrantzitsua da jakitea helburu gehienak, berriz,

110
00:06:59,000 --> 00:07:02,000
benetan erabili ahal izango dugu, oro har, begizta mota edozein

111
00:07:02,000 --> 00:07:06,000
xede edo komun eredu mota batzuk daude

112
00:07:06,000 --> 00:07:09,000
programazio zehazki, loops horietako bat deitu

113
00:07:09,000 --> 00:07:13,000
osatzen duten eraginkorrenak edo dotoreak horrela kodea.

114
00:07:13,000 --> 00:07:18,000
Dezagun joan zer loops horietako bakoitzean joera erabili behar den gehienetan.

115
00:07:18,000 --> 00:07:21,000
>> Batean loop dagoeneko, oro har, dakigu zenbat aldiz batetik bestera joateko nahi dugu.

116
00:07:21,000 --> 00:07:24,000
Hori da, zer baldintza jarri dugu.

117
00:07:24,000 --> 00:07:28,000
, I = 0, i <10, adibidez.

118
00:07:28,000 --> 00:07:31,000
Dagoeneko badakigu zerbait 10 aldiz egin nahi dugu.

119
00:07:31,000 --> 00:07:34,000
Orain, berriz, begizta bat, oro har, ez dugu behar

120
00:07:34,000 --> 00:07:36,000
jakin zenbat aldiz begizta exekutatu nahi dugu.

121
00:07:36,000 --> 00:07:39,000
Baina nolabaiteko baldintza jakin nahi dugu eta egiten dugu

122
00:07:39,000 --> 00:07:41,000
beti egia edo beti faltsua.

123
00:07:41,000 --> 00:07:44,000
Esate baterako, berriz, ezartzen da.

124
00:07:44,000 --> 00:07:46,000
Demagun duen aldagai bat boolearra.

125
00:07:46,000 --> 00:07:48,000
Hori egia da bitartean kodea ebaluatu nahi dugu,

126
00:07:48,000 --> 00:07:52,000
beraz, pixka bat gehiago hedagarria, pixka bat baino gehiago, oro har, begizta

127
00:07:52,000 --> 00:07:55,000
baina begizta for edozein ere sar daitezke, berriz, begizta bat bihurtu da.

128
00:07:55,000 --> 00:08:00,000
Azkenik, loops, trickiest izan daiteke berehala ulertu ez, berriz,

129
00:08:00,000 --> 00:08:04,000
erabili ohi dira kodea ebaluatzeko lehenengo nahi dugu

130
00:08:04,000 --> 00:08:06,000
aurretik, lehen aldiz egoera egiaztatu dugu.

131
00:08:06,000 --> 00:08:09,000
Komun bat erabiltzea kasu egin loop bitartean

132
00:08:09,000 --> 00:08:12,000
denean, erabiltzailearen sarrera eskuratu nahi baduzu, eta erabiltzaileak eskatu nahi duzu badakizu

133
00:08:12,000 --> 00:08:15,000
sarrera gutxienez behin, baina eman ez badute sarrera ona berehala

134
00:08:15,000 --> 00:08:18,000
eskatuz ematen dute arte sarrera ona mantendu nahi duzun.

135
00:08:18,000 --> 00:08:21,000
Erabilera ohikoena ez loop, berriz,

136
00:08:21,000 --> 00:08:23,000
eta dezagun loops hauen benetako egitura begiratzen.

137
00:08:23,000 --> 00:08:27,000
Beti izan ohi dute normalean eredu hauek jarraitu.

138
00:08:27,000 --> 00:08:30,000
>> Begizta barruan On 3 osagai izan beharko da:

139
00:08:30,000 --> 00:08:35,000
Hasieratzea, normalean zerbait int i = 0 non counter i,

140
00:08:35,000 --> 00:08:40,000
egoera, non begizta hau exekutatu betiere baldintza hau oraindik antolatzen jo esan nahi dugu,

141
00:08:40,000 --> 00:08:44,000
i <10, eta, ondoren, azkenik, eguneratu, hau da, nola Kontatzailea bezalako

142
00:08:44,000 --> 00:08:47,000
Begizta puntu bakoitzean aldagai counter.

143
00:08:47,000 --> 00:08:50,000
Gauza komun bat dago ikusteko + + i da,

144
00:08:50,000 --> 00:08:52,000
Horrek esan nahi du, Kontatzailea i 1 aldi bakoitzean.

145
00:08:52,000 --> 00:08:55,000
I + = 2 antzeko zerbait ere egin dezakezu,

146
00:08:55,000 --> 00:08:58,000
Horrek esan nahi du, gehitu 2 i denbora bakoitzean begizta bidez.

147
00:08:58,000 --> 00:09:03,000
Eta gero, hori guztia egin loop-zati gisa benetan kodea duen edozein exekutatzen dagokio.

148
00:09:03,000 --> 00:09:09,000
Eta, berriz, begizta bat, une honetan benetan dugu Hasieratzea Begizta kanpo,

149
00:09:09,000 --> 00:09:12,000
Adibidez, demagun begizta mota bera bezala deskribatu egiten saiatzen ari gara.

150
00:09:12,000 --> 00:09:16,000
Int i = 0 begizta hasi aurretik esan nahi dugu.

151
00:09:16,000 --> 00:09:20,000
Ondoren, esan genezake <10 i egin bitartean hau,

152
00:09:20,000 --> 00:09:22,000
beraz, kode-bloke berean, orain arte bezala,

153
00:09:22,000 --> 00:09:26,000
eta oraingoan kodearen zati eguneratzea, adibidez, i + +,

154
00:09:26,000 --> 00:09:29,000
benetan Begizta barruan doa.

155
00:09:29,000 --> 00:09:33,000
Eta, azkenik, egin, bitartean loop antzekoa da berriz,

156
00:09:33,000 --> 00:09:36,000
baina kodea behin ebaluatuko du gogoratu behar dugu

157
00:09:36,000 --> 00:09:40,000
baldintza hautatuta dago aurretik, eta, beraz, askoz gehiago zentzuzkoa da

158
00:09:40,000 --> 00:09:44,000
du begiratzen baduzu ordena goitik behera.

159
00:09:44,000 --> 00:09:49,000
Batean loop kodea ebaluatzen ere bitartean aurretik begiratu bitartean,

160
00:09:49,000 --> 00:09:55,000
bitartean begizta bat, berriz, lehen egiaztatzen du.

161
00:09:55,000 --> 00:09:59,000
Kontuak eta aldagai.

162
00:09:59,000 --> 00:10:04,000
Aldagai berri bat sortu nahi dugu, nahi dugu, lehen abiarazi.

163
00:10:04,000 --> 00:10:07,000
>> Esate baterako, int barra-barra aldakorra initializes

164
00:10:07,000 --> 00:10:10,000
baina ez du ematen balio bat, eta, beraz, zer da gaur egun bar balio?

165
00:10:10,000 --> 00:10:12,000
Ez dakigu.

166
00:10:12,000 --> 00:10:14,000
Batzuk zabor-balio hori memorian gordetzen da lehenago bertan izan daiteke,

167
00:10:14,000 --> 00:10:16,000
eta nahi ez dugun aldagai hori erabili

168
00:10:16,000 --> 00:10:19,000
dugu balio bat eman arte,

169
00:10:19,000 --> 00:10:21,000
beraz, aldarrikatzen dugu hemen.

170
00:10:21,000 --> 00:10:24,000
Ondoren, 42 behean hasieratu dugu.

171
00:10:24,000 --> 00:10:28,000
Baina, noski, hori egin daiteke, lerro bat, int bar = 42 dakigu.

172
00:10:28,000 --> 00:10:30,000
Baina garbitu behar diren hainbat urrats gertatzen da,

173
00:10:30,000 --> 00:10:34,000
adierazpena eta Hasieratzea bereizita gertatzen ari dira hemen.

174
00:10:34,000 --> 00:10:38,000
Urrats bat gertatzen da, eta, hurrengo, int baz = bar + 1

175
00:10:38,000 --> 00:10:44,000
beheko-adierazpen hau, baz-gehikuntzak, beraz, kode-bloke honen amaieran

176
00:10:44,000 --> 00:10:48,000
ginen baz balioa inprimatu nahi izanez gero, 44 ​​izango litzateke

177
00:10:48,000 --> 00:10:52,000
aldarrikatzen dugu, eta delako 1> bar abiarazi,

178
00:10:52,000 --> 00:10:58,000
Kontatzailea eta, ondoren, berriz ere + +.

179
00:10:58,000 --> 00:11:02,000
Hau nahiko laburki baino gehiago joan gara, baina oso ona da orokor bat izan

180
00:11:02,000 --> 00:11:04,000
zer diren hariak eta gertaerak ulertzeko.

181
00:11:04,000 --> 00:11:06,000
Egin dugu, batez ere hau Scratch

182
00:11:06,000 --> 00:11:09,000
beraz, hari dezakezu uste kode hainbat sekuentzia gisa

183
00:11:09,000 --> 00:11:11,000
aldi berean exekutatzen ari da.

184
00:11:11,000 --> 00:11:14,000
Actuality, ziur aski, ez aldi berean exekutatzen

185
00:11:14,000 --> 00:11:17,000
baina sort abstraktuan da pentsatzen dugu modu horretan.

186
00:11:17,000 --> 00:11:20,000
>> Scratch, adibidez, hainbat sprites izan genuen.

187
00:11:20,000 --> 00:11:22,000
Exekutatzean izan daiteke kode desberdin aldi berean.

188
00:11:22,000 --> 00:11:26,000
Oinez-ko beste zerbait esanez

189
00:11:26,000 --> 00:11:29,000
pantailaren beste zati bat.

190
00:11:29,000 --> 00:11:34,000
Ekitaldiak logika bereizten beste modu bat

191
00:11:34,000 --> 00:11:37,000
Zure kodea elementu desberdinen artean,

192
00:11:37,000 --> 00:11:40,000
eta Scratch gertaerak simulatzeko gai Broadcast erabiliz ginen,

193
00:11:40,000 --> 00:11:43,000
eta hori benetan Jaso dut, ez When I Hear

194
00:11:43,000 --> 00:11:47,000
baina funtsean, informazioa transmititzeko modu bat da

195
00:11:47,000 --> 00:11:49,000
, bat Sprite beste.

196
00:11:49,000 --> 00:11:52,000
Esate baterako, nahi jokoa transmititu ahal izango duzu,

197
00:11:52,000 --> 00:11:56,000
eta noiz Sprite beste jasotzen jokoa baino gehiago,

198
00:11:56,000 --> 00:11:58,000
modu jakin batean erantzuten du.

199
00:11:58,000 --> 00:12:03,000
Programazioa ulertzeko eredu garrantzitsu bat da.

200
00:12:03,000 --> 00:12:07,000
Just Aste oinarrizko 0 baino gehiago joan, zer joan dugu, beraz, orain arte,

201
00:12:07,000 --> 00:12:10,000
dezagun C programa erraza da.

202
00:12:10,000 --> 00:12:14,000
Testua pixka bat hemendik txikia izan daiteke, baina joan Pasatuko zait benetan azkarra.

203
00:12:14,000 --> 00:12:20,000
2 goiburua, goi cs50.h eta stdio.h fitxategiak ari gara, besteak beste.

204
00:12:20,000 --> 00:12:23,000
Ondoren, etengabe ari gara izeneko muga definitzen 100 izan behar du.

205
00:12:23,000 --> 00:12:26,000
Ondoren ari gara, gure funtzio nagusia ezartzeko.

206
00:12:26,000 --> 00:12:29,000
Geroztik ez dugu erabili komando lerro argumentoak hemen void jarri behar dugu

207
00:12:29,000 --> 00:12:32,000
nagusiaren argumentu gisa.

208
00:12:32,000 --> 00:12:38,000
Nagusiak gainetik int ikusten dugu. Hori bueltan mota da, eta, beraz, itzultzeko 0 behealdean.

209
00:12:38,000 --> 00:12:41,000
Eta CS50 liburutegiko funtzioa erabiltzen ari gara lortu int

210
00:12:41,000 --> 00:12:45,000
sarrera erabiltzaileari galdetu, eta gordetzeko dugu hau aldagaia x

211
00:12:45,000 --> 00:12:51,000
beraz, x aldarrikatzen dugu batez ere, eta hasieratu dugu x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Egiaztatu ondoren, erabiltzaileari eman zigun ona sarrera ikusteko.

213
00:12:53,000 --> 00:12:59,000
≥ LIMIT 1 kodea errore bat itzuli eta errore-mezu bat inprimatu nahi dugu.

214
00:12:59,000 --> 00:13:02,000
Eta, azkenik, erabiltzaileak ematen badira onak sarrera

215
00:13:02,000 --> 00:13:08,000
zenbakia plazan, eta emaitza hori inprimatu goaz.

216
00:13:08,000 --> 00:13:11,000
Just ziurtatu horiek guztiak hit hasiera

217
00:13:11,000 --> 00:13:17,000
kodea hemen atal ezberdinak etiketak ikusi ahal izango duzu.

218
00:13:17,000 --> 00:13:19,000
Etengabe, goiburu fitxategiak aipatu dut.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Ziurtatu tokiko aldagai bat gogoratzeko.

220
00:13:21,000 --> 00:13:24,000
Hori kontrastatzen aldagai global bat, buruz hitz egin dugu.

221
00:13:24,000 --> 00:13:27,000
pixka bat geroago, berrikuspena saio,

222
00:13:27,000 --> 00:13:30,000
eta liburutegiko funtzioa printf deitzen ari gara,

223
00:13:30,000 --> 00:13:34,000
hala bada ez genuen, stdio.h goiburu fitxategi

224
00:13:34,000 --> 00:13:37,000
printf deitu ahal izango genuke.

225
00:13:37,000 --> 00:13:42,000
Eta gezi hemen got moztu da% d seinalatuz uste dut,

226
00:13:42,000 --> 00:13:45,000
printf Kate formateatzen da.

227
00:13:45,000 --> 00:13:52,000
Zenbaki bat,% d aldagai hau inprimatu dio.

228
00:13:52,000 --> 00:13:58,000
Eta hori da, Aste 0.

229
00:13:58,000 --> 00:14:06,000
Orain Lucas jarraitzea.

230
00:14:06,000 --> 00:14:08,000
Hey, guys. Nire izena Lucas da.

231
00:14:08,000 --> 00:14:10,000
Campusean, Mather etxe onena sophomore bat naiz,

232
00:14:10,000 --> 00:14:14,000
eta 1 eta 2,1 Astea buruz pixka bat hitz egin dut.

233
00:14:14,000 --> 00:14:16,000
[1 eta 2,1 Astea!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Lexi zen bezala, esaten Scratch etatik C zure kodea itzultzen hasi ginen

235
00:14:19,000 --> 00:14:23,000
nabaritu dugun gauza bat da, ez bakarrik ahal izango duzu

236
00:14:23,000 --> 00:14:26,000
Zure kodea idatzi eta exekutatu jada bandera berdea erabiliz.

237
00:14:26,000 --> 00:14:30,000
Egia esan, pauso batzuk erabili zure C programa bat egin behar duzu

238
00:14:30,000 --> 00:14:33,000
fitxategi exekutagarri bat bihurtu da.

239
00:14:33,000 --> 00:14:36,000
Funtsean, zer ez duzu programa bat idazten ari da

240
00:14:36,000 --> 00:14:40,000
zure ideia itzultzeko hizkuntza konpilatzailea ulertzen,

241
00:14:40,000 --> 00:14:44,000
beraz, programa bat idazten ari zaren C

242
00:14:44,000 --> 00:14:47,000
zer egiten ari zaren benetan zerbait idazten zure konpiladore hori ulertzeko,

243
00:14:47,000 --> 00:14:50,000
eta, ondoren, konpiladorea da, kode hori itzuli egingo da

244
00:14:50,000 --> 00:14:53,000
zerbait, zure ordenagailuak ulertzen sartu.

245
00:14:53,000 --> 00:14:55,000
>> Eta gauza da, zure ordenagailua ez da benetan oso muda.

246
00:14:55,000 --> 00:14:57,000
Zure ordenagailua bakarrik ulertu 0 s eta 1s

247
00:14:57,000 --> 00:15:01,000
beraz, benetan lehen ordenagailuak jendea normalean programatu

248
00:15:01,000 --> 00:15:04,000
0 s eta 1s, baina ez, jada, thank God.

249
00:15:04,000 --> 00:15:07,000
Ez dugu 0 s eta 1s sekuentziak memorizatzeko

250
00:15:07,000 --> 00:15:10,000
loop edo, berriz, loop eta abar.

251
00:15:10,000 --> 00:15:13,000
Horregatik konpilatzailea dugu.

252
00:15:13,000 --> 00:15:17,000
Zer konpiladore bat ez da, funtsean, itzultzen C kodea,

253
00:15:17,000 --> 00:15:21,000
Gure kasuan, zure ordenagailuak ulertzeko hizkuntza bat,

254
00:15:21,000 --> 00:15:25,000
objektu-kodean, eta konpilatzailea erabiltzen ari garen

255
00:15:25,000 --> 00:15:30,000
deritzo clang, eta, beraz, hau da, benetan ikurra clang.

256
00:15:30,000 --> 00:15:33,000
Zure programa behar duzu, 2 gauza egin behar duzu.

257
00:15:33,000 --> 00:15:37,000
Lehenik eta behin, zure programa konpilatu behar duzu, eta, ondoren, programa exekutatzen ari zaren.

258
00:15:37,000 --> 00:15:41,000
Horretarako aukera asko duzu zure programa konpilatu.

259
00:15:41,000 --> 00:15:44,000
Ko lehen clang program.c

260
00:15:44,000 --> 00:15:47,000
programa zure programaren izena da.

261
00:15:47,000 --> 00:15:51,000
Kasu honetan, ikusi besterik ez esaten ari dira dezakezu "Hey, konpilatu nire programa."

262
00:15:51,000 --> 00:15:56,000
Ari zara esaten ez edo ezer "nire programa izen hori nahi dut".

263
00:15:56,000 --> 00:15:58,000
>> Bigarren aukera izen bat ematea da programa.

264
00:15:58,000 --> 00:16:02,000
Esan dezakezu clang-o eta, ondoren, nahi duzun izena

265
00:16:02,000 --> 00:16:06,000
fitxategi exekutagarria izendatu behar dira eta, ondoren, program.c.

266
00:16:06,000 --> 00:16:11,000
Eta, halaber, egin ahal duzu egiteko programa, eta ikusi nola 2 lehen kasuak

267
00:16:11,000 --> 00:16:15,000
Jarri dut c, eta hirugarren bat besterik ez dut programa?

268
00:16:15,000 --> 00:16:18,000
Bai, ez litzateke duzu ez jartzea. C denean egiteko erabiltzen duzun.

269
00:16:18,000 --> 00:16:22,000
Bestela konpilatzailea da benetan at Yell.

270
00:16:22,000 --> 00:16:24,000
Eta gainera, ez dakit bada gogoratzen duzu guys,

271
00:16:24,000 --> 00:16:29,000
baina aldiz ere erabiltzen dugu-lcs50 edo-lm asko.

272
00:16:29,000 --> 00:16:31,000
Izeneko lotzen ditu.

273
00:16:31,000 --> 00:16:35,000
Kontatzen besterik ez du konpiladore liburutegi horiek erabili egingo dute bertan,

274
00:16:35,000 --> 00:16:39,000
hala badagokio cs50.h erabili nahi duzu benetan idatzi

275
00:16:39,000 --> 00:16:43,000
program.c-lcs50 clang.

276
00:16:43,000 --> 00:16:45,000
Ez baduzu hori egin, konpiladorea ez da jakin

277
00:16:45,000 --> 00:16:50,000
ari zaren funtzio horiek erabiliz cs50.h.

278
00:16:50,000 --> 00:16:52,000
Eta 2 aukera dituzu zure programa exekutatu nahi duzun.

279
00:16:52,000 --> 00:16:57,000
Zenuen clang program.c Ez baduzu eman izena zure programa.

280
00:16:57,000 --> 00:17:01,000
Exekutatu. / A.out erabiliz duzu.

281
00:17:01,000 --> 00:17:06,000
A.out izena clang zure programa ematen ez baduzu, eman izena estandar bat da.

282
00:17:06,000 --> 00:17:11,000
Bestela, / programa egiten ari zaren izena eman duzu zure programa bada,

283
00:17:11,000 --> 00:17:15,000
eta, gainera, egin duzun programaren izena duen programa bat da, iritsi da

284
00:17:15,000 --> 00:17:23,000
dagoeneko programatu dira izen bereko c fitxategi gisa.

285
00:17:23,000 --> 00:17:26,000
Ondoren Datu-mota eta datu-buruz hitz egin dugu.

286
00:17:26,000 --> 00:17:31,000
>> Funtsean datuak erabiltzen dituzten kaxak little mota gauza bera dira

287
00:17:31,000 --> 00:17:35,000
balioak gordetzeko, beraz, datu-motak, egia esan just Pokémons bezala.

288
00:17:35,000 --> 00:17:39,000
Tamaina eta mota guztiak etortzen dira.

289
00:17:39,000 --> 00:17:43,000
Ez dakit analogia horrek zentzua badu.

290
00:17:43,000 --> 00:17:46,000
Datuak tamaina benetan makinaren arkitektura araberakoa da.

291
00:17:46,000 --> 00:17:49,000
Datuen tamaina naiz hemen erakusteko

292
00:17:49,000 --> 00:17:53,000
32-bit makina, gure tresnaren kasua da, benetan

293
00:17:53,000 --> 00:17:56,000
baina benetan, zure Mac edo Windows ere kodifikazioa

294
00:17:56,000 --> 00:17:59,000
ziurrenik 64-bit makina bat ari zaren,

295
00:17:59,000 --> 00:18:03,000
beraz, gogoratu datuak tamaina naiz dut hemen erakusteko

296
00:18:03,000 --> 00:18:06,000
32-bit makina dira.

297
00:18:06,000 --> 00:18:08,000
Lehen ikusi dugun int bat izan zen,

298
00:18:08,000 --> 00:18:10,000
hau da, nahiko erraza.

299
00:18:10,000 --> 00:18:13,000
Int zenbaki oso bat gordetzeko erabiltzen dituzu.

300
00:18:13,000 --> 00:18:16,000
Pertsonaia, karakterra ere ikusi dugu.

301
00:18:16,000 --> 00:18:20,000
Gutun bat edo sinbolo bat little erabili nahi duzun bada, seguruenik ari zaren char bat erabili du.

302
00:18:20,000 --> 00:18:26,000
Karaktereen A 1 byte da, eta horrek esan nahi du, 8 bit, Lexi esan du.

303
00:18:26,000 --> 00:18:31,000
Funtsean dugu ASCII taula duen 256

304
00:18:31,000 --> 00:18:34,000
0 s eta 1s konbinazio posible,

305
00:18:34,000 --> 00:18:37,000
eta, orduan, char bat idazten duzunean itzuli da

306
00:18:37,000 --> 00:18:44,000
pertsonaia input zenbaki bat duzula ASCII taulan, Lexi bezala esan.

307
00:18:44,000 --> 00:18:48,000
Horrez gain, mugikorra, hamartar zenbakiak gordetzeko erabiltzen ditugu.

308
00:18:48,000 --> 00:18:53,000
3,14 aukeratu nahi duzun bada, adibidez, mugikor bat erabiltzen ari zaren joan

309
00:18:53,000 --> 00:18:55,000
edo bikoitza doitasun gehiago ditu.

310
00:18:55,000 --> 00:18:57,000
Float A 4 byte ditu.

311
00:18:57,000 --> 00:19:01,000
Bikoitza A 8 byte ditu, beraz, desberdintasun bakarra da doitasun.

312
00:19:01,000 --> 00:19:04,000
Era berean, luze bat erabiltzen da zenbaki osoen

313
00:19:04,000 --> 00:19:09,000
eta 32-bit makina bat ikus dezakezu int luze eta tamaina bera dute,

314
00:19:09,000 --> 00:19:13,000
beraz, ez da benetan zentzurik luze bat erabili 32-bit makina bat.

315
00:19:13,000 --> 00:19:17,000
>> Baina ari zaren Mac eta 64-bit makina bat erabiliz gero, benetan luze bat tamaina 8

316
00:19:17,000 --> 00:19:19,000
beraz, arkitektura benetan araberakoa da.

317
00:19:19,000 --> 00:19:22,000
32-bit makina ez du zentzurik luze bat erabili benetan.

318
00:19:22,000 --> 00:19:25,000
Eta gero, luze, beste alde batetik, 8 byte ditu,

319
00:19:25,000 --> 00:19:30,000
beraz, oso ona da jada zenbaki oso bat izan nahi duzun.

320
00:19:30,000 --> 00:19:34,000
Eta, azkenik, kate ditugu, hau da, benetan char *

321
00:19:34,000 --> 00:19:37,000
char bat erakuslea da.

322
00:19:37,000 --> 00:19:40,000
Oso erraza da katea tamaina hori izan bezala uste

323
00:19:40,000 --> 00:19:42,000
karaktere kopurua duzula bertan,

324
00:19:42,000 --> 00:19:45,000
baina benetan bera char *

325
00:19:45,000 --> 00:19:49,000
char bat, hau da, 4 byte erakuslea baten tamaina du.

326
00:19:49,000 --> 00:19:52,000
Char * tamaina 4 byte da.

327
00:19:52,000 --> 00:19:56,000
Ez du axola bada, ez duzu hitz txiki bat edo gutun bat edo ezer.

328
00:19:56,000 --> 00:19:58,000
4 bytes izango da.

329
00:19:58,000 --> 00:20:01,000
Apur bat ere ikasi dugu casting buruz,

330
00:20:01,000 --> 00:20:04,000
beraz, ikusi ahal izango dituzu, baldin baduzu, adibidez, programa bat dela dio

331
00:20:04,000 --> 00:20:08,000
int x = 3 eta, ondoren, printf ("% d", x / 2)

332
00:20:08,000 --> 00:20:12,000
do you guys ezagutzen zer pantailan inprimatu egingo?

333
00:20:12,000 --> 00:20:14,000
>> Norbaitek? >> [Ikasleak] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, bai.

335
00:20:16,000 --> 00:20:20,000
3/2, 1,5 lortu da,

336
00:20:20,000 --> 00:20:24,000
baina ari gara zenbaki oso bat erabiliz geroztik hamartar zatia ez da joan,

337
00:20:24,000 --> 00:20:26,000
eta 1 izan duzu.

338
00:20:26,000 --> 00:20:29,000
Nahi ez baduzu, zer egin ahal izango duzu gertatuko, esate baterako,

339
00:20:29,000 --> 00:20:33,000
mugikor bat aldarrikatu da y = x.

340
00:20:33,000 --> 00:20:40,000
Ondoren, x 3 erabiltzen da gaur egun 3.000 y en.

341
00:20:40,000 --> 00:20:44,000
Eta gero, y / 2 inprimatu ahal izango duzu.

342
00:20:44,000 --> 00:20:50,000
Egia esan, 2 bat izan behar dut. han.

343
00:20:50,000 --> 00:20:55,000
3.00/2.00 egin behar da,

344
00:20:55,000 --> 00:20:58,000
eta 1,5 lortu duzu.

345
00:20:58,000 --> 00:21:06,000
.2 F 2 unitate hamartar hamartar parte eskatu besterik ez dugu.

346
00:21:06,000 --> 00:21:12,000
.3 F bada benetan izan 1.500 da.

347
00:21:12,000 --> 00:21:16,000
Bada, 2 1,50 izango da.

348
00:21:16,000 --> 00:21:18,000
Horrez gain, kasu honetan hemen.

349
00:21:18,000 --> 00:21:22,000
Karroza egin duzu bada, x = 3,14, eta, ondoren, printf x

350
00:21:22,000 --> 00:21:24,000
3,14 lortu duzu.

351
00:21:24,000 --> 00:21:29,000
Eta egiten baduzu x = x int,

352
00:21:29,000 --> 00:21:34,000
Horrek esan nahi du, tratatzeko int gisa x eta x inprimatu

353
00:21:34,000 --> 00:21:36,000
3,00 izan duzu.

354
00:21:36,000 --> 00:21:38,000
Ez duela zentzurik?

355
00:21:38,000 --> 00:21:41,000
Zaren lehen tratatzeko delako x zenbaki oso bat, eta, beraz, parte hamartar ari ez ikusi egin zaio,

356
00:21:41,000 --> 00:21:45,000
eta, ondoren, x ari zaren inprimatzeko.

357
00:21:45,000 --> 00:21:47,000
Eta, azkenik, gainera dezakezu Horretarako,

358
00:21:47,000 --> 00:21:52,000
int x = 65, eta ondoren char c = x deklaratzeko,

359
00:21:52,000 --> 00:21:56,000
eta, ondoren, inprimatu c benetan ari zaren eskuratu du

360
00:21:56,000 --> 00:21:59,000
A, eta, beraz, funtsean, hemen zer egiten ari zaren

361
00:21:59,000 --> 00:22:02,000
osokoa pertsonaia itzultzeko,

362
00:22:02,000 --> 00:22:05,000
ASCII taula ez bezala.

363
00:22:05,000 --> 00:22:08,000
Math operadore buruz ere hitz egin dugu.

364
00:22:08,000 --> 00:22:14,000
Gehienak nahiko erraza da, eta, beraz, +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
eta mod, 2 zenbakien zatiketa baten hondarra da buruz ere hitz egin dugu.

366
00:22:20,000 --> 00:22:23,000
Duzu 10% 3 bada, esate baterako,

367
00:22:23,000 --> 00:22:27,000
zatitzea 3 10 esan nahi du, eta gainerakoa zer den?

368
00:22:27,000 --> 00:22:30,000
1 izango da, eta, beraz, benetan da oso erabilgarria da programa asko.

369
00:22:30,000 --> 00:22:38,000
Vigenère eta Caesar pretty sure you guys guztiak erabili mod naiz.

370
00:22:38,000 --> 00:22:43,000
Math operadore buruz, oso kontuz ibili behar da, * eta / konbinatuz.

371
00:22:43,000 --> 00:22:48,000
>> Adibidez, ez baduzu (3/2) * 2 zer egingo eskuratu duzu?

372
00:22:48,000 --> 00:22:50,000
[Ikasleak] 2.

373
00:22:50,000 --> 00:22:54,000
Bai, 2, 3/2 delako 1,5 izan da,

374
00:22:54,000 --> 00:22:57,000
baina ari zaren eragiketa geroztik egiten 2 zenbaki osoen arteko

375
00:22:57,000 --> 00:22:59,000
benetan ari zaren besterik gabe, 1. kontuan hartu behar,

376
00:22:59,000 --> 00:23:03,000
eta, ondoren, 1 * 2 2 izango da, eta, beraz, oso, oso kontuz ibili

377
00:23:03,000 --> 00:23:07,000
aritmetika egiten osoko zenbakien delako

378
00:23:07,000 --> 00:23:12,000
lortzeko 2 = 3 izan daiteke, kasu horretan.

379
00:23:12,000 --> 00:23:14,000
Eta, gainera, oso kontuz ibili buruz lehentasuna.

380
00:23:14,000 --> 00:23:21,000
Normalean erabili beharko zenuke parentesi ziur badakizula zer egiten ari zaren.

381
00:23:21,000 --> 00:23:27,000
Erabilgarria lasterbideak batzuk, jakina, i + + edo i + = 1 bat da

382
00:23:27,000 --> 00:23:30,000
erabili edo + =.

383
00:23:30,000 --> 00:23:34,000
I = i + 1 egiten gauza bera da.

384
00:23:34,000 --> 00:23:39,000
Ere egin dezakezu i - edo i - = 1,

385
00:23:39,000 --> 00:23:42,000
-1 = i gauza bera da,

386
00:23:42,000 --> 00:23:46,000
guys asko batean erabiltzen duzun zerbait, loops, gutxienez.

387
00:23:46,000 --> 00:23:52,000
Era berean, *, * = egiten baduzu, adibidez bada,

388
00:23:52,000 --> 00:23:57,000
i * = 2 i = i * 2 esatea gauza bera da,

389
00:23:57,000 --> 00:23:59,000
eta zatiketa gauza bera.

390
00:23:59,000 --> 00:24:08,000
Do i / = 2 i = i / 2 gauza bera da.

391
00:24:08,000 --> 00:24:10,000
>> Orain funtzioak.

392
00:24:10,000 --> 00:24:13,000
Zaudete ikasi funtzio oso ona estrategia kodea gorde

393
00:24:13,000 --> 00:24:16,000
ari zaren programazioa bitartean, eta, beraz, nahi duzun lana egiteko

394
00:24:16,000 --> 00:24:20,000
kodea, behin eta berriro, ziurrenik funtzio bat erabili nahi duzun

395
00:24:20,000 --> 00:24:25,000
besterik ez, beraz, ez duzu kodea eta gehiagoko berriz kopiatu eta itsatsi.

396
00:24:25,000 --> 00:24:28,000
Izan ere, funtzio nagusia da, eta erakusteko I funtzio baten formatua

397
00:24:28,000 --> 00:24:32,000
hori dela pretty bistako ikusteko duzu.

398
00:24:32,000 --> 00:24:35,000
Funtzioak ere erabiltzen ditugu, liburutegi batzuk,

399
00:24:35,000 --> 00:24:39,000
Adibidez, printf, GetIn CS50 liburutegia da, eta horrek,

400
00:24:39,000 --> 00:24:43,000
eta toupper bezalako beste funtzioak.

401
00:24:43,000 --> 00:24:46,000
Funtzio horiek guztiak dira benetan beste liburutegi ezarri

402
00:24:46,000 --> 00:24:49,000
eta noiz tether fitxategi horiek jarri duzu zure programaren hasieran

403
00:24:49,000 --> 00:24:53,000
eman me funtzio kodea mesedez esaten ari zaren

404
00:24:53,000 --> 00:24:57,000
beraz, ez dut neure ezartzeko?

405
00:24:57,000 --> 00:25:00,000
Eta, gainera, ahal izango duzu zure funtzioak idatzi, eta, beraz, behin programazioa hasten zara

406
00:25:00,000 --> 00:25:04,000
liburutegiak ez funtzioak behar duzula konturatzen zara.

407
00:25:04,000 --> 00:25:10,000
Azken pset, adibidez, marrazteko, Scramble, eta bilaketak idatzi dugu,

408
00:25:10,000 --> 00:25:13,000
eta oso, oso garrantzitsua da funtzio idatzi ahal izango

409
00:25:13,000 --> 00:25:17,000
dira erabilgarria delako, eta horiek erabiltzen ditugu programazio denbora guztian,

410
00:25:17,000 --> 00:25:19,000
eta kode asko gordetzen du.

411
00:25:19,000 --> 00:25:21,000
Funtzio baten formatua hau da.

412
00:25:21,000 --> 00:25:24,000
Itzulera mota ditugu hasieran. Zer da bueltan mota da?

413
00:25:24,000 --> 00:25:27,000
Besterik ez da zure funtzioa itzuli egingo da.

414
00:25:27,000 --> 00:25:29,000
Funtzio bat behar duzu, adibidez, faktore bada,

415
00:25:29,000 --> 00:25:31,000
hori zenbaki oso bat faktoriala kalkulatzeko,

416
00:25:31,000 --> 00:25:34,000
ziurrenik osoko bat itzuli ere egingo.

417
00:25:34,000 --> 00:25:37,000
Gero, bueltan mota int izango da.

418
00:25:37,000 --> 00:25:41,000
Printf benetan bueltan mota void

419
00:25:41,000 --> 00:25:43,000
ezer ez delako ari zaren itzuli.

420
00:25:43,000 --> 00:25:45,000
Ari zara gauzak inprimatzeko pantaila

421
00:25:45,000 --> 00:25:48,000
eta funtzioa irten ondoren.

422
00:25:48,000 --> 00:25:51,000
Ondoren funtzioa aukeratu ahal izango duzu izena.

423
00:25:51,000 --> 00:25:55,000
Apur bat arrazoizko behar duzu, ez bezala, XYZ bezalako izen bat aukeratu

424
00:25:55,000 --> 00:25:58,000
edo x2f bezala.

425
00:25:58,000 --> 00:26:02,000
Saiatu zentzua duen izen bat osatzen dute.

426
00:26:02,000 --> 00:26:04,000
>> Esate baterako, bada faktore, esan faktore.

427
00:26:04,000 --> 00:26:08,000
Funtzio bat da hori zerbait marrazteko bada, izendatzeko marrazteko.

428
00:26:08,000 --> 00:26:11,000
Eta gero, ere deitzen diren argumentuak parametro dugu,

429
00:26:11,000 --> 00:26:14,000
zure funtzioa behar bezalako baliabideak

430
00:26:14,000 --> 00:26:17,000
Zure kodea bere zeregina burutzeko.

431
00:26:17,000 --> 00:26:20,000
Zenbaki baten faktoriala kalkulatu nahi duzun bada

432
00:26:20,000 --> 00:26:23,000
seguruenik zenbaki bat izan behar du, eta faktore bat kalkulatu behar duzu.

433
00:26:23,000 --> 00:26:27,000
Argudioak behar zarela telefono zenbaki bat bera da.

434
00:26:27,000 --> 00:26:31,000
Eta gero, zerbait egin behar eta balioa itzultzeko amaieran

435
00:26:31,000 --> 00:26:35,000
void funtzioa ezean.

436
00:26:35,000 --> 00:26:37,000
Ikus dezagun adibide bat.

437
00:26:37,000 --> 00:26:40,000
Nahi dut zenbaki guztiak batzen funtzio bat zenbaki osoen array bat idatzi nahi izanez gero,

438
00:26:40,000 --> 00:26:43,000
lehenik eta behin, itzulera mota int izango da

439
00:26:43,000 --> 00:26:46,000
daukat zenbaki osoen array bat delako.

440
00:26:46,000 --> 00:26:51,000
Bezalako izen funtzioa sumArray izan dut,

441
00:26:51,000 --> 00:26:54,000
eta, ondoren, array bera hartu du joan, int nums

442
00:26:54,000 --> 00:26:58,000
eta, ondoren, ezagutzen dut, beraz, zenbat zenbakiak batzea daukat array luzera.

443
00:26:58,000 --> 00:27:02,000
Ondoren, aldakorra izeneko batura, adibidez, 0 abiarazi behar dut,

444
00:27:02,000 --> 00:27:08,000
eta aldi bakoitzean array elementu bat ikusten dut gehitu behar dut batura, beraz, bat egin nuen loop.

445
00:27:08,000 --> 00:27:15,000
Bezala Lexi esan zuen, int i = 0, i <luzera eta i + +.

446
00:27:15,000 --> 00:27:20,000
Array elementu guztietan batura nuen + = nums [i],

447
00:27:20,000 --> 00:27:24,000
eta, ondoren, batura itzuli nuen, eta, beraz, oso erraza da, eta kode asko gordetzen du

448
00:27:24,000 --> 00:27:28,000
zaren funtzio hau erabiliz gero, aldiz asko.

449
00:27:28,000 --> 00:27:32,000
Ondoren, baldintza begirada bat hartu genuen.

450
00:27:32,000 --> 00:27:38,000
Bada, bestela, behar dugu, eta bestela,.

451
00:27:38,000 --> 00:27:42,000
Dezagun zer da horien arteko desberdintasuna ikus-en.

452
00:27:42,000 --> 00:27:45,000
Hartu 2 kode horien begirada bat. Zein da bien arteko aldea?

453
00:27:45,000 --> 00:27:49,000
Lehena funtsean kodeak nahi esan duzu

454
00:27:49,000 --> 00:27:51,000
, edo 0 - +, zenbaki bat baldin bada.

455
00:27:51,000 --> 00:27:55,000
Lehenengo dio> 0 badira, positiboa da.

456
00:27:55,000 --> 00:28:00,000
Da bada, orduan 0 = 0 da, eta <0 bada, negatiboa da.

457
00:28:00,000 --> 00:28:04,000
>> Eta beste bat egiten bada, bestela, bestela.

458
00:28:04,000 --> 00:28:07,000
Bien arteko aldea da, hau da, benetan joan

459
00:28:07,000 --> 00:28:13,000
> 0, <0 edo = 0 hiru aldiz egiaztatu bada,

460
00:28:13,000 --> 00:28:17,000
hala badagokio, kopurua 2 duzu, adibidez, hona etorri eta esan egingo

461
00:28:17,000 --> 00:28:21,000
(x> 0), eta bai esan nahi da, eta, beraz, positiboa inprimatu dut.

462
00:28:21,000 --> 00:28:25,000
Baina, nahiz eta hori> 0 ezagutzen dut, eta ez da 0 edo <0 izango

463
00:28:25,000 --> 00:28:29,000
Jarraitzen dut egingo da 0, 0 <,

464
00:28:29,000 --> 00:28:33,000
beraz, benetan ari naiz IFS barruan baina ez dute

465
00:28:33,000 --> 00:28:38,000
Dagoeneko dudalako ezagutzen dela eta baldintza horiek ez betetzean.

466
00:28:38,000 --> 00:28:41,000
Erabili ahal izango dut, bada, bestela, bestela adierazpena.

467
00:28:41,000 --> 00:28:45,000
Dio funtsean, x = 0 positiboa bada inprimatzen ditut.

468
00:28:45,000 --> 00:28:48,000
Ez bada, hau ere probatu dut.

469
00:28:48,000 --> 00:28:51,000
2 ez bada ez noa.

470
00:28:51,000 --> 00:28:54,000
Funtsean izan nuen x = 2 badira, esan nahi duzun

471
00:28:54,000 --> 00:28:57,000
(x> 0), bai, eta, beraz, inprimatu.

472
00:28:57,000 --> 00:29:00,000
Orain ezagutzen dut> 0 eta lehenengo bazaizu

473
00:29:00,000 --> 00:29:02,000
Ez dut baita kode hau exekutatu.

474
00:29:02,000 --> 00:29:09,000
Kodea exekutatzen azkarrago, egia esan, 3 aldiz azkarrago erabiltzen badituzu.

475
00:29:09,000 --> 00:29:11,000
Ikasi dugu, eta buruz edo.

476
00:29:11,000 --> 00:29:15,000
Ez dut honen bidez Lexi dagoeneko horietako buruz hitz egiten duelako.

477
00:29:15,000 --> 00:29:17,000
Besterik ez da && eta | | operadorea.

478
00:29:17,000 --> 00:29:21,000
>> Gauza bakarra esan dut kontuz 3 baldintza bete behar da.

479
00:29:21,000 --> 00:29:24,000
Erabili parentesi oso nahasgarria delako baldintza bat behar duzu

480
00:29:24,000 --> 00:29:27,000
eta beste bat edo beste bat.

481
00:29:27,000 --> 00:29:30,000
Erabili parentesi ziur zure baldintzak zentzurik izango

482
00:29:30,000 --> 00:29:34,000
Kasu horretan, adibidez, delako, pentsa dezakezu hori

483
00:29:34,000 --> 00:29:38,000
lehenengo baldintza, eta bat edo beste izango da

484
00:29:38,000 --> 00:29:41,000
edo bat konbinatzen 2 baldintzak eta

485
00:29:41,000 --> 00:29:45,000
edo hirugarren bat, beraz, kontuz ibili.

486
00:29:45,000 --> 00:29:48,000
Eta, azkenik, hitz switches gara.

487
00:29:48,000 --> 00:29:53,000
Switch bat oso erabilgarria da, aldagai bat behar duzu.

488
00:29:53,000 --> 00:29:55,000
Demagun n aldagai bat duzula

489
00:29:55,000 --> 00:29:59,000
0, 1 edo 2 izan daiteke, eta Kasu horietan bakoitzean

490
00:29:59,000 --> 00:30:01,000
zeregin bat egiteko joan zaren.

491
00:30:01,000 --> 00:30:04,000
Esan aldatzeko aldagaia dezakezu, eta horrek adierazten du

492
00:30:04,000 --> 00:30:08,000
balioa eta, ondoren, value1 atsegin hau egin nahi dut,

493
00:30:08,000 --> 00:30:12,000
eta, ondoren, hautsi I, horrek esan nahi du, ez dut beste edozein kasu begiratu

494
00:30:12,000 --> 00:30:15,000
dagoeneko badugu pozik delako, kasu horretan

495
00:30:15,000 --> 00:30:20,000
eta, ondoren, balioa2, eta abar, eta nik ere default switch bat izan daiteke.

496
00:30:20,000 --> 00:30:24,000
Horrek esan nahi du, ez badu betetzeko kasuetan izan dut edozein

497
00:30:24,000 --> 00:30:29,000
naiz duten I beste zerbait egin behar du, baina hori aukerakoa.

498
00:30:29,000 --> 00:30:36,000
Hori da dena niretzat. Egin ditzagun orain Tommy.

499
00:30:36,000 --> 00:30:41,000
Ondo da, hau da, Aste 3-ish izango.

500
00:30:41,000 --> 00:30:45,000
Hauek estaltzen dugu, kripto, esparrua, array, et cetera gai batzuk dira.

501
00:30:45,000 --> 00:30:49,000
Just kripto hitz azkar bat. Ez gara hasiera honetan Hammer.

502
00:30:49,000 --> 00:30:52,000
>> Hau egin genuen, 2 pset, baina galdetegirako ziurtatu diferentzia badakizu

503
00:30:52,000 --> 00:30:54,000
Zesarren zifratua eta Vigenère zifratze artean,

504
00:30:54,000 --> 00:30:57,000
zifraketen lan horiek, bai eta zer enkriptatzeko bezala

505
00:30:57,000 --> 00:30:59,000
eta testua desenkriptatu 2 zifraketen horiek erabiliz.

506
00:30:59,000 --> 00:31:03,000
Gogoratu, César zifratze, besterik gabe, pertsonaia bakoitzak biratzen kopuru bera,

507
00:31:03,000 --> 00:31:06,000
duzula mod alfabetoaren letren kopurua.

508
00:31:06,000 --> 00:31:09,000
Eta Vigenère zifratze, beste alde batetik, pertsonaia bakoitzak biratzen

509
00:31:09,000 --> 00:31:12,000
beste kopuru bat, eta, beraz, baizik eta esaten baino

510
00:31:12,000 --> 00:31:15,000
3 Vigenère biratuko pertsonaia bakoitzak pertsonaia bakoitzak biratzeko

511
00:31:15,000 --> 00:31:17,000
zenbatekoa keyword batzuk arabera

512
00:31:17,000 --> 00:31:20,000
non hitzarekin letra bakoitza beste kopuru batzuk adierazten

513
00:31:20,000 --> 00:31:26,000
Testu laueko biratzeko.

514
00:31:26,000 --> 00:31:28,000
Dezagun lehen esparrua aldakorreko buruzko eztabaida.

515
00:31:28,000 --> 00:31:30,000
Aldagai mota desberdinak daude 2.

516
00:31:30,000 --> 00:31:33,000
Aldagai lokalak ditugu, eta horiek definitu egingo da

517
00:31:33,000 --> 00:31:36,000
nagusia edo funtzio edo bloke kanpo kanpo,

518
00:31:36,000 --> 00:31:39,000
eta hauek eskuragarri izango da zure programa edozein.

519
00:31:39,000 --> 00:31:41,000
Funtzio bat bada, eta funtzio hori, berriz, begizta bat da

520
00:31:41,000 --> 00:31:44,000
global handia, aldagaia da nonahi.

521
00:31:44,000 --> 00:31:48,000
Tokiko aldagai bat da, beste alde batetik, bertan definitzen da leku scoped.

522
00:31:48,000 --> 00:31:53,000
>> Funtzio bat bada, hemen duzu, adibidez, funtzio g hau dugu,

523
00:31:53,000 --> 00:31:56,000
eta g barruan aldagai bat dago hemen izeneko y

524
00:31:56,000 --> 00:31:58,000
eta horrek esan nahi du horrek tokiko aldagai bat da.

525
00:31:58,000 --> 00:32:00,000
Nahiz eta aldagai hau deitzen da, y

526
00:32:00,000 --> 00:32:03,000
eta aldagai 2 funtzio hauek deritzo y

527
00:32:03,000 --> 00:32:06,000
ez daki zer diren, bata bestearen aldagai lokalak.

528
00:32:06,000 --> 00:32:10,000
Beste alde batetik, hemen int x = 5 diogunean,

529
00:32:10,000 --> 00:32:12,000
eta funtzioa edozein esparrutik kanpo dago.

530
00:32:12,000 --> 00:32:16,000
Nagusiaren esparrutik kanpo, beraz, aldagai global bat da.

531
00:32:16,000 --> 00:32:20,000
2 funtzio horien barruan, esan nahi du, x diot edo x + +

532
00:32:20,000 --> 00:32:26,000
Horren bidez, y eta y desberdinak dira aldagai bera x naiz sartzen.

533
00:32:26,000 --> 00:32:30,000
Aldagai global eta tokiko aldagai bat arteko aldea da.

534
00:32:30,000 --> 00:32:33,000
Den neurrian, diseinu dagokionez, batzuetan izango da seguru asko ideia bat hobea

535
00:32:33,000 --> 00:32:37,000
aldagai tokiko mantentzeko bakoitzean ziurrenik duzu

536
00:32:37,000 --> 00:32:39,000
aldagai global sorta bat izatea geroztik oso nahasgarria lor daiteke.

537
00:32:39,000 --> 00:32:42,000
Funtzio sorta bat bada, gauza bera aldatzea

538
00:32:42,000 --> 00:32:45,000
ahaztu zer funtzio hau ustekabean aldatzen global honetan dezake,

539
00:32:45,000 --> 00:32:47,000
eta beste funtzio hau ez da buruz jakin,

540
00:32:47,000 --> 00:32:50,000
eta lortu du nahiko nahasgarria gehiago kodea.

541
00:32:50,000 --> 00:32:53,000
Aldagai tokiko mantentzea bakoitzean ziurrenik duzu

542
00:32:53,000 --> 00:32:56,000
diseinu besterik ez ona da.

543
00:32:56,000 --> 00:33:00,000
Arrayak, gogoan, besterik gabe, mota bereko elementu zerrendak.

544
00:33:00,000 --> 00:33:04,000
CI barrualdea ezin izan 1, 2,0 bezalako zerrenda bat, kaixo.

545
00:33:04,000 --> 00:33:06,000
Besterik ez dugu egin.

546
00:33:06,000 --> 00:33:11,000
>> Array bat aldarrikatzen dugu C elementu guztiak mota bereko.

547
00:33:11,000 --> 00:33:14,000
Hemen, 3 zenbaki osoen array bat daukat.

548
00:33:14,000 --> 00:33:18,000
Hemen array luzera izan dut, baina ez dut besterik ez bada ere geratuko sintaxi honetan

549
00:33:18,000 --> 00:33:21,000
non zer elementu guztiak dira zehaztu ez dut 3 teknikoki behar dut.

550
00:33:21,000 --> 00:33:25,000
Konpilatzailea da smart nahikoa izarrekin nola big array izan behar du.

551
00:33:25,000 --> 00:33:28,000
Orain, array bat balio edo ezarri nahi dut

552
00:33:28,000 --> 00:33:30,000
hau da sintaxia hori egin da.

553
00:33:30,000 --> 00:33:33,000
Honek benetan aldatzeko bigarren array-elementu, izan ere, gogoratu,

554
00:33:33,000 --> 00:33:36,000
zenbakitze 0 hasten da, ez 1.

555
00:33:36,000 --> 00:33:42,000
Nahi dut balio irakurri nahi izanez gero, antzeko zerbait esan daiteke I int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Edo nahi dut balio hori ezarri nahi izanez gero, naiz atsegin dut hemen egiten,

557
00:33:44,000 --> 00:33:47,000
Esan array I [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Garai hartan beren indizea by elementuak sartzeko

559
00:33:50,000 --> 00:33:52,000
edo beren posizioa edo non array daude,

560
00:33:52,000 --> 00:33:57,000
eta zerrenda 0 hasten da.

561
00:33:57,000 --> 00:34:00,000
Ere ahal izango dugu array of array,

562
00:34:00,000 --> 00:34:03,000
eta hau deitzen da multi-dimentsioko array bat.

563
00:34:03,000 --> 00:34:05,000
Multi-dimentsioko array bat daukagu

564
00:34:05,000 --> 00:34:07,000
horrek esan nahi du, errenkadak eta zutabeak antzeko zerbait izan dezakegu,

565
00:34:07,000 --> 00:34:11,000
eta hau ikusteko edo pentsatzen modu bat besterik ez da.

566
00:34:11,000 --> 00:34:14,000
Multi-dimentsioko array bat daukat esan beharrik hasteko noa

567
00:34:14,000 --> 00:34:17,000
indizea 1 baino gehiago delako saretako daukat

568
00:34:17,000 --> 00:34:19,000
errenkadan Oraindik duzu esatea ez da zenbaki bat ematen diguten.

569
00:34:19,000 --> 00:34:22,000
Hau da, benetan besterik ez digute zenbakien zerrenda bat egingo da.

570
00:34:22,000 --> 00:34:25,000
Demagun array hau daukat hemen.

571
00:34:25,000 --> 00:34:30,000
Sareta izeneko array bat daukat, eta bere 2 errenkada eta 3 zutabe esaten dut,

572
00:34:30,000 --> 00:34:32,000
eta, beraz, hau da ikusteko modu bat da.

573
00:34:32,000 --> 00:34:37,000
Elementu lortu [1] nahi dut esango dut [2]

574
00:34:37,000 --> 00:34:41,000
horrek esan nahi du, zeren horiek dira lehenik eta, ondoren, errenkadak zutabe

575
00:34:41,000 --> 00:34:44,000
1 errenkada esan dut 1etik aurrera salto egin dut.

576
00:34:44,000 --> 00:34:49,000
>> Ondoren, hemen baino gehiago etorri zutabe 2 naiz joan, eta balioa 6 noa.

577
00:34:49,000 --> 00:34:51,000
Zentzurik?

578
00:34:51,000 --> 00:34:55,000
Multi-dimentsioko array, gogoan, teknikoki horretarako array array bat besterik ez dira.

579
00:34:55,000 --> 00:34:57,000
Array-array array izan ahal izango dugu.

580
00:34:57,000 --> 00:35:00,000
Mantendu egingo dugu, baina benetan, modu batean pentsatu

581
00:35:00,000 --> 00:35:03,000
hau nola ari da banatuta, eta zer gertatzen da ikusteko

582
00:35:03,000 --> 00:35:09,000
hau atsegin sareta batean.

583
00:35:09,000 --> 00:35:12,000
Funtzioak array pasatzen dugu, portatzen ari dira

584
00:35:12,000 --> 00:35:16,000
desberdinak erregularra aldagai pasatzen dugu funtzio baino pixka bat

585
00:35:16,000 --> 00:35:18,000
int edo mugikor bat igaro bezala.

586
00:35:18,000 --> 00:35:21,000
Pasatzen dugu char edo int edo datu horiek beste edozein mota

587
00:35:21,000 --> 00:35:24,000
funtzioa bada aldatzen begirada bat hartu besterik ez dugu

588
00:35:24,000 --> 00:35:28,000
aldagai horren balioa aldaketa hori ez hedatzeko

589
00:35:28,000 --> 00:35:32,000
deitu duen funtziora.

590
00:35:32,000 --> 00:35:35,000
Array batekin, beste alde batetik, hori gertatuko da.

591
00:35:35,000 --> 00:35:39,000
Array bat pasatzen bada, eta funtzio batzuk, funtzio hori elementu batzuk aldatzen

592
00:35:39,000 --> 00:35:43,000
itzuli naiz izeneko funtzioa

593
00:35:43,000 --> 00:35:47,000
nire array ezberdina izan du, eta, horretarako hiztegia

594
00:35:47,000 --> 00:35:50,000
erreferentzia da array gainditu, aurrerago ikusiko dugun bezala dugu.

595
00:35:50,000 --> 00:35:53,000
Hori nola erakusleak lana, non horiek oinarrizko datu-motak,

596
00:35:53,000 --> 00:35:55,000
Beste alde batetik, balioa gainditu.

597
00:35:55,000 --> 00:35:59,000
>> Ezin dugu uste hori aldagai batzuen kopia bat egin eta, ondoren, kopia pasatzen gisa.

598
00:35:59,000 --> 00:36:01,000
Ez du axola aldagai horrekin zer egiten dugun.

599
00:36:01,000 --> 00:36:06,000
Deitu duen funtziora ezin izango jakitun zela aldatu.

600
00:36:06,000 --> 00:36:10,000
Arrayak pixka bat bakarrik Zentzu horretan desberdinak dira.

601
00:36:10,000 --> 00:36:13,000
Esate baterako, besterik ez dugu ikusi bezala, nagusietako bat da, besterik gabe, funtzio bat

602
00:36:13,000 --> 00:36:15,000
2 argumentu hartu dezakete.

603
00:36:15,000 --> 00:36:20,000
Lehen argumentua da funtzio nagusia argc, edo argumentu kopurua,

604
00:36:20,000 --> 00:36:23,000
eta bigarren argumentua deritzo argv

605
00:36:23,000 --> 00:36:27,000
eta horiek argumentuak horien benetako balioak dira.

606
00:36:27,000 --> 00:36:30,000
Demagun izeneko programa bat this.c daukat,

607
00:36:30,000 --> 00:36:34,000
esan dut, eta hau egiteko, eta hau exekutatzeko komando-lerroan noa.

608
00:36:34,000 --> 00:36:38,000
Orain argumentuak batzuk pasatzeko nire programa izeneko hau,

609
00:36:38,000 --> 00:36:42,000
Esan nuen zerbait. /, Hau da cs 50.

610
00:36:42,000 --> 00:36:45,000
Hau da, David egin imajinatu dugu egunero terminalean.

611
00:36:45,000 --> 00:36:48,000
Baina orain, programa hori barruan funtzio nagusia

612
00:36:48,000 --> 00:36:52,000
balio horiek ditu, beraz, argc 4.

613
00:36:52,000 --> 00:36:56,000
Pixka bat nahasgarria izan daiteke benetan, bakarrik ari cs 50 pasatzen dugulako.

614
00:36:56,000 --> 00:36:58,000
Hori da soilik 3.

615
00:36:58,000 --> 00:37:02,000
Baina gogoratu argv lehenengo elementua edo lehen argumentua

616
00:37:02,000 --> 00:37:05,000
funtzioa bertan izena da.

617
00:37:05,000 --> 00:37:07,190
Beraz, horrek esan nahi du, 4 gauza dugula hemen,

618
00:37:07,190 --> 00:37:10,530
eta lehen elementu da. / hau izango da.

619
00:37:10,530 --> 00:37:12,970
Eta hau izango da kate gisa irudikatzen.

620
00:37:12,970 --> 00:37:18,590
Ondoren, gainontzeko elementuak zer idatzi programaren izena ondoren.

621
00:37:18,590 --> 00:37:22,720
Beraz, bezala, bat alde batera utzita, ziurrenik pset 2 ikusi

622
00:37:22,720 --> 00:37:28,780
gogoratu katea 50 ≠ osokoaren 50.

623
00:37:28,780 --> 00:37:32,520
Beraz, ezin dugu esan, antzeko zerbait 'int x = argv 3.

624
00:37:32,520 --> 00:37:36,470
>> Hori ez zentzurik, hau kate bat delako, eta hau oso bat da.

625
00:37:36,470 --> 00:37:38,510
Beraz, bada 2 arteko bihurtu nahi baduzu, gogoan, ari dugu.

626
00:37:38,510 --> 00:37:40,810
izeneko atoi magia funtzio hau.

627
00:37:40,810 --> 00:37:46,270
Kate bat hartzen du, eta kate horren barruan irudikatzen osoko itzultzen du.

628
00:37:46,270 --> 00:37:48,360
Beraz, akats bat da erraza galdetegia egiteko,

629
00:37:48,360 --> 00:37:51,590
besterik gabe, automatikoki mota egokia pentsatzen.

630
00:37:51,590 --> 00:37:53,860
Baina jakin horiek beti izango da kateak

631
00:37:53,860 --> 00:38:00,920
nahiz eta katea, zenbaki oso bat edo pertsonaia bat edo mugikor bat besterik ez dauka.

632
00:38:00,920 --> 00:38:03,380
Beraz, gaur egun utzi iraupena buruz hitz egiteko.

633
00:38:03,380 --> 00:38:06,700
Algoritmo horiek crazy gauza horiek guztiak ez ditugu,

634
00:38:06,700 --> 00:38:11,580
Benetan erabilgarria bihurtzen da galdera, "Zenbat denbora egin dute?"

635
00:38:11,580 --> 00:38:15,500
Zerbait asymptotic notazioa izeneko ordezkatzen dugu.

636
00:38:15,500 --> 00:38:18,430
Beraz, horrek esan nahi du - ondo, demagun gure algoritmoa ematen dugu

637
00:38:18,430 --> 00:38:20,840
Benetan, benetan, benetan big sarrera batzuk.

638
00:38:20,840 --> 00:38:23,840
Galdera nahi dugu, "Zenbat denbora hartu du?

639
00:38:23,840 --> 00:38:26,370
Zenbat urrats dira gure algoritmoa hartu da exekutatu

640
00:38:26,370 --> 00:38:29,980
sarrera tamaina funtzio gisa? "

641
00:38:29,980 --> 00:38:33,080
Exekutatu denbora deskribatzeko ahal izango dugu modu Beraz, lehen big O.

642
00:38:33,080 --> 00:38:35,380
Eta hau gure kasurik txarrenaren lasterketak denbora da.

643
00:38:35,380 --> 00:38:38,590
Beraz, bada, array bat ordenatzeko nahi dugu, eta gure algoritmoa array bat ematen diogu

644
00:38:38,590 --> 00:38:41,000
beheranzko ordenan ordena goranzko behar da,

645
00:38:41,000 --> 00:38:43,130
den kasuan txarrena izan.

646
00:38:43,130 --> 00:38:49,800
Hau da gure goiko denbora hartuko du gure algoritmoa gehienezko luzera aritzeko da.

647
00:38:49,800 --> 00:38:54,740
Beste alde batetik, Ω hori best-kasuan exekutatzen denbora deskribatzeko.

648
00:38:54,740 --> 00:38:58,210
Beraz, bada,, dagoeneko horrela antolatu array bat ematen dugu ordenatzeko algoritmo bat,

649
00:38:58,210 --> 00:39:00,940
zenbat denbora izango da ordenatzeko hartu?

650
00:39:00,940 --> 00:39:06,610
Eta hau, beraz, txikiagoa iraupena doazen deskribatzen du.

651
00:39:06,610 --> 00:39:10,980
Hortaz, hona hemen deskribatzen duten hitz batzuk besterik ez orokor batzuk aldiz.

652
00:39:10,980 --> 00:39:13,120
Hauek ordena gorakorrean daude.

653
00:39:13,120 --> 00:39:16,060
Azkarrena denborak dugu deitzen da etengabe.

654
00:39:16,060 --> 00:39:19,800
>> Horrek ez du axola zenbat elementu gure algoritmoa ematen dugu esan nahi du,

655
00:39:19,800 --> 00:39:22,280
ez du axola nola big da gure array, ordenatzeko

656
00:39:22,280 --> 00:39:26,510
edo edozein dela ere array egiten ari gara egiten, beti izango da denbora kopuru bera hartu.

657
00:39:26,510 --> 00:39:30,270
Beraz, bat besterik ez 1, hau da, konstante bat irudikatu ahal izango dugu.

658
00:39:30,270 --> 00:39:32,410
Run logaritmikoa denbora ere begiratu dugu.

659
00:39:32,410 --> 00:39:34,800
Beraz, bilaketa bitarra antzeko zerbait logaritmikoa da,

660
00:39:34,800 --> 00:39:37,140
non denbora erdian behin, arazoa moztu dugu

661
00:39:37,140 --> 00:39:40,970
eta, ondoren, gauzak besterik ez handiagoa bertatik.

662
00:39:40,970 --> 00:39:43,580
Eta ari zara inoiz bada O bat idazten edozein faktore algoritmoa,

663
00:39:43,580 --> 00:39:47,850
beharko ez kontuan hartu zure eguneko lana gisa.

664
00:39:47,850 --> 00:39:53,910
Martxan aldiz alderatu dugu garrantzitsua da gauza horiek kontuan mantentzeko.

665
00:39:53,910 --> 00:39:57,760
Beraz, bada algoritmoa O (n) bat izan dut, eta beste norbaitek

666
00:39:57,760 --> 00:40:03,590
O algoritmo batek (2n) hauek dira benetan asymptotically baliokidea.

667
00:40:03,590 --> 00:40:06,590
Beraz, bada, kopuru handi bat eleventy milioi bezalako n imajinatu dugu:

668
00:40:06,590 --> 00:40:13,090
beraz, eleventy milioi alderatuz antzeko zerbait eleventy milioi + 3 ari gara,

669
00:40:13,090 --> 00:40:17,640
bat-batean +3 ez du benetan egin diferentzia handi bat jada.

670
00:40:17,640 --> 00:40:20,980
Horregatik, kontuan hartuta hasteko gauza horiek baliokideak izango dugu.

671
00:40:20,980 --> 00:40:24,220
Konstanteak horrelako gauzak hemen, beraz, ez da 2 x honetan, edo 3 gehituz,

672
00:40:24,220 --> 00:40:27,180
horiek besterik ez dira konstanteak, eta horiek jaregiteko.

673
00:40:27,180 --> 00:40:32,480
Beraz, zergatik run garai hauetan 3 guztiak O (n) esaten ari dira berdinak dira.

674
00:40:32,480 --> 00:40:37,490
Era berean, dugu, 2 run aldiz beste bada, demagun O (n ³ + 2n ²), gehitu ahal izango dugu

675
00:40:37,490 --> 00:40:42,070
+ N + 7, eta, ondoren, beste exekuzio-denbora besterik O (n ³) dugu.

676
00:40:42,070 --> 00:40:46,290
berriz, horiek gauza bera dira, zeren eta hauek ez dira berdinak.

677
00:40:46,290 --> 00:40:49,840
Hauek gauza bera dira, barkatu. Beraz, horiek berak dira delako

678
00:40:49,840 --> 00:40:53,090
³ n hori 2n ² menderatzeko.

679
00:40:53,090 --> 00:40:59,130
>> Zer da, ez da gauza bera exekutatzen dugu bada aldiz O (n ³) eta O bezala (n ²)

680
00:40:59,130 --> 00:41:02,820
n ³ n ² hau baino askoz handiagoa delako.

681
00:41:02,820 --> 00:41:05,470
Beraz dugu adierazlerik izanez gero, bat-batean hasten da axola,

682
00:41:05,470 --> 00:41:08,280
baina besterik ez ari gara faktore gara hemen aurre,

683
00:41:08,280 --> 00:41:12,810
ondoren, ez da egingo dira besterik ez delako jaregiteko axola.

684
00:41:12,810 --> 00:41:16,760
Dezagun algoritmo batzuk ikusi dugu hain urruti begirada bat

685
00:41:16,760 --> 00:41:19,260
eta bere exekuzio-denbora buruz hitz egiteko.

686
00:41:19,260 --> 00:41:23,850
Zerrenda batean zenbaki bat begiratzeko modu lehen, ikusi dugu, bilaketa lineala izan zen.

687
00:41:23,850 --> 00:41:26,950
Eta bilaketa lineala ezartzeko super erraza da.

688
00:41:26,950 --> 00:41:30,490
Zerrenda bat besterik ez dugu, eta zerrendako elementu bakoitza begiratu goaz

689
00:41:30,490 --> 00:41:34,260
kopurua aurkituko dugu arte bilatzen ari gara.

690
00:41:34,260 --> 00:41:38,370
Beraz, horrek esan nahi du kasurik okerrenean, O (n).

691
00:41:38,370 --> 00:41:40,860
Eta kasurik okerrenean hemen elementu bada izan liteke

692
00:41:40,860 --> 00:41:45,710
azken elementua eta, ondoren, bilaketa lineala erabiliz elementu bakoitza begiratu behar dugu

693
00:41:45,710 --> 00:41:50,180
azkena zela benetan zerrendan jakin dugu iritsi arte.

694
00:41:50,180 --> 00:41:52,910
Ezin dugu amore eman erdiraino eta esatea, "ziurrenik da ez".

695
00:41:52,910 --> 00:41:55,980
Bilaketa lineala, gauza osoa begiratu behar dugu.

696
00:41:55,980 --> 00:41:59,090
Best-kasuan lasterka, beste alde batetik, etengabeko

697
00:41:59,090 --> 00:42:04,200
Kasu horretan, onena bilatzen ari garen elementua delako zerrendan lehena.

698
00:42:04,200 --> 00:42:08,930
Beraz eramango gaitu, zehazki 1 pausoa, ez du axola nola big zerrenda egingo

699
00:42:08,930 --> 00:42:12,140
ari gara aldi bakoitzean lehenengo elementu bila.

700
00:42:12,140 --> 00:42:15,390
>> Beraz, bilaketa duzunean, gogoan, ez du behar gure zerrenda ordenatuko.

701
00:42:15,390 --> 00:42:19,430
Ari gara, besterik gabe, delako elementu bakoitza baino gehiago begiratu behar, eta ez du benetan axola

702
00:42:19,430 --> 00:42:23,560
zein ordenatan elementu horiek dira sartu

703
00:42:23,560 --> 00:42:28,110
A adimendunak bilaketa algoritmoa bilaketa bitarra antzeko zerbait da.

704
00:42:28,110 --> 00:42:31,500
Gogoan izan, bilaketa bitarra ezartzea da noiz ari zaren

705
00:42:31,500 --> 00:42:34,320
egon zerrendan erdian at bilatzen.

706
00:42:34,320 --> 00:42:38,000
Eta ari gara erdi-erdian delako, zerrenda hori horrela antolatu behar dugu

707
00:42:38,000 --> 00:42:40,580
edo, bestela, ez dakigu non erdi-erdian dago, eta baino gehiago begiratu behar dugu

708
00:42:40,580 --> 00:42:44,480
zerrenda osoa aurkituko, eta, ondoren, puntu horretan ari gara denbora alferrik galtzen.

709
00:42:44,480 --> 00:42:48,480
Beraz, zerrenda ordenatuko dugu, eta erdi-erdian aurkituko dugu, erdian konparatzeko goaz

710
00:42:48,480 --> 00:42:51,590
elementu bilatzen ari gara.

711
00:42:51,590 --> 00:42:54,640
Da oso handia bada, ondoren, eskuineko erdia ahaztu ahal izango dugu

712
00:42:54,640 --> 00:42:57,810
ezagutzen dugulako gure elementu oso handia da dagoeneko

713
00:42:57,810 --> 00:43:01,080
eta elementu horren eskubidea dena handiagoa da,

714
00:43:01,080 --> 00:43:02,760
gero, ez dugu behar dago bilatzeko jada.

715
00:43:02,760 --> 00:43:05,430
Non, beste alde batetik, gure elementu oso baxua bada,

716
00:43:05,430 --> 00:43:08,700
ezagutzen dugu elementu hori ezkerreko dena ere oso baxua da,

717
00:43:08,700 --> 00:43:11,390
beraz, ez da benetan zentzurik han bilatzeko, bai.

718
00:43:11,390 --> 00:43:15,760
Horrela, pauso bakoitzean eta aldi bakoitzean dugu zerrendaren erdigunea,

719
00:43:15,760 --> 00:43:19,060
gure arazoa moztu erdi bat-batean ari gara ezagutzen dugun delako

720
00:43:19,060 --> 00:43:23,040
sorta osoa ezin da zenbaki bat bilatzen ari gara.

721
00:43:23,040 --> 00:43:26,950
>> Pseudocode honetan zerbait bilatzeko hau atsegin dute,

722
00:43:26,950 --> 00:43:30,990
eta zerrenda mozten ari garelako bakoitza denbora erdia,

723
00:43:30,990 --> 00:43:34,920
gure kasuan txarrena-run denbora lineal jauziak logaritmikoa.

724
00:43:34,920 --> 00:43:39,260
Beraz, bat-batean dugu log-zerrenda batean elementu bat aurkitzeko urratsak.

725
00:43:39,260 --> 00:43:42,460
Best-kasuan lasterketak denbora, ordea, oraindik ere etengabe

726
00:43:42,460 --> 00:43:45,180
dezagun orain delako, besterik ez diotenez, bilatzen ari garen elementua dela

727
00:43:45,180 --> 00:43:48,380
beti, jatorrizko zerrenda erdian zehatza.

728
00:43:48,380 --> 00:43:52,080
Beraz, gure zerrendan hazten dugu big nahi dugu, baina bilatzen ari gara elementu erdi-erdian bada,

729
00:43:52,080 --> 00:43:54,910
gero bakarrik, eramango gaitu urrats 1.

730
00:43:54,910 --> 00:44:00,920
Beraz, horregatik, O (log n) eta Ω (1) edo etengabe ari gara.

731
00:44:00,920 --> 00:44:04,510
Dezagun benetan zerrenda honetan bilaketa bitarra exekutatu.

732
00:44:04,510 --> 00:44:08,020
Beraz, demagun 164 elementu bila ari garela.

733
00:44:08,020 --> 00:44:11,650
Lehenik eta behin, egin dugu aurkitu zerrenda honen erdigunea.

734
00:44:11,650 --> 00:44:15,060
Beraz, zerbait gertatzen da erdigunea dela erori 2 zenbakiak horien artean,

735
00:44:15,060 --> 00:44:18,960
beraz, besterik gabe arbitrarioki esan, bere esku dagoen guztia egiten du bere erdigunea 2 zenbakien artean daude,

736
00:44:18,960 --> 00:44:21,150
dezagun biribildu sortu.

737
00:44:21,150 --> 00:44:24,330
Behar dugu, hau egiten dugu bidea pauso bakoitzean.

738
00:44:24,330 --> 00:44:29,040
Beraz biribiltzeko dugu, eta 161 gure zerrendan erdian dela esaten dugu.

739
00:44:29,040 --> 00:44:34,640
Beraz, 161 <164 eta 161 ezkerreko elementu guztietan

740
00:44:34,640 --> 00:44:39,120
<164 ere, eta, beraz, badakigu ez dela gurekin laguntzeko

741
00:44:39,120 --> 00:44:42,690
baino gehiago bilatzen hasteko elementu delako, ezin da ez bilatzen ari gara.

742
00:44:42,690 --> 00:44:47,060
Beraz, zer egin dezakegun da, besterik ezin dugu ahaztu hori zerrenda osoan ezkerreko erdi inguru,

743
00:44:47,060 --> 00:44:51,700
eta gaur egun 161 aurrerantzean eskubidea bakarrik kontuan hartu.

744
00:44:51,700 --> 00:44:54,050
>> Beraz, berriro ere, hau erdigunea da; dezagun biribildu sortu.

745
00:44:54,050 --> 00:44:56,260
Orain 175 handiegia da.

746
00:44:56,260 --> 00:44:59,180
Beraz, ez da hemen edo hemen bilatzen lagunduko digu badakigu,

747
00:44:59,180 --> 00:45:06,610
beraz besterik gabe bota, eta azkenean 164 hit dugu.

748
00:45:06,610 --> 00:45:10,560
Bilaketa bitarra edozein galdera?

749
00:45:10,560 --> 00:45:14,180
Dezagun mugitu dagoeneko horrela antolatu zerrenda baten bidez bilatzen

750
00:45:14,180 --> 00:45:17,660
benetan zenbakien zerrenda bat hartu, edozein ordenatan

751
00:45:17,660 --> 00:45:20,960
eta zerrenda hori egiteko ordena gorakorrean.

752
00:45:20,960 --> 00:45:24,060
Lehenengo begiratu dugu algoritmoa deitzen zen burbuila sort.

753
00:45:24,060 --> 00:45:27,300
Eta hau ikusi ditugun algoritmoak errazagoa izango litzateke.

754
00:45:27,300 --> 00:45:32,970
Bubble sort dio zerrenda barruan 2 elementu edozein leku,

755
00:45:32,970 --> 00:45:36,500
zenbaki handiagoa da kopurua txikiagoa ezkerreko zentzua,

756
00:45:36,500 --> 00:45:40,190
gero swap goaz, horrek esan nahi du, zerrenda hori izango da delako

757
00:45:40,190 --> 00:45:42,860
"Ordenatuko" baino zen.

758
00:45:42,860 --> 00:45:45,180
Eta bakarrik ari gara berriro prozesu hau jarraituko du, eta behin eta berriro

759
00:45:45,180 --> 00:45:52,100
azkenean, bere kokaleku zuzena burbuila mota elementuak eta arte horrela antolatu zerrenda bat dugu.

760
00:45:52,100 --> 00:45:57,230
>> Denbora run O izango da (n ²). Zergatik?

761
00:45:57,230 --> 00:46:00,370
Beno, izan ere, kasurik okerrenean, elementu guztiak hartu behar dugu, eta

762
00:46:00,370 --> 00:46:04,570
amaitzeko konparatzen zerrendako beste elementu bat behin goaz.

763
00:46:04,570 --> 00:46:08,030
Baina kasu horretan, onena,, dagoeneko horrela antolatu zerrenda bat dugu, burbuila sort

764
00:46:08,030 --> 00:46:12,230
behin bitartez, esan du "Laguia ez nuen trukeak edozein egiteko, beraz, egin dut."

765
00:46:12,230 --> 00:46:17,410
Beraz, best-kasuan Ω (n) denbora behar dugu.

766
00:46:17,410 --> 00:46:20,680
Dezagun exekutatu burbuila zerrenda bat ordenatu.

767
00:46:20,680 --> 00:46:23,560
Edo lehen, dezagun begiratu pseudocode batzuk benetan azkar.

768
00:46:23,560 --> 00:46:28,160
Segimendua egiteko, begizta-iterazio guztietan nahi dugu esan nahi dugu,

769
00:46:28,160 --> 00:46:32,190
mantendu ala ez elementu edozein aldatu dugu jarraipena.

770
00:46:32,190 --> 00:46:37,610
Beraz, hau da arrazoia, ez dugu truka edozein elementu gelditzeko dugu.

771
00:46:37,610 --> 00:46:41,980
Beraz, gure begizta Irteeran ez dugu truka ezer egin, beraz, esan hori faltsua dugu.

772
00:46:41,980 --> 00:46:47,170
Orain, zerrendan zehar joan eta elementu alderatu elementu i + 1 i goaz

773
00:46:47,170 --> 00:46:50,310
da eta kasua bada ez dagoela kopurua handiagoa da zenbaki txikiagoa ezkerreko

774
00:46:50,310 --> 00:46:52,310
ondoren ari gara horiek swap.

775
00:46:52,310 --> 00:46:54,490
>> Eta gero trukatu egin dugun elementu bat gogoratzen dugu.

776
00:46:54,490 --> 00:46:58,900
Horrek esan nahi du zerrendan zehar joan, gutxienez, 1 denbora gehiago behar ditugu

777
00:46:58,900 --> 00:47:02,160
dugun egoera gelditu da zerrenda osoa dagoeneko horrela antolatu delako,

778
00:47:02,160 --> 00:47:04,890
trukeak edozein ez dugu egin, alegia.

779
00:47:04,890 --> 00:47:09,960
Beraz, hori dela eta, gure egoera behera hemen 'elementu batzuk trukatu egin dira bitartean.'

780
00:47:09,960 --> 00:47:13,720
Beraz, gaur egun dezagun zerrenda bat begiratu.

781
00:47:13,720 --> 00:47:16,640
Zerrenda 5,0,1,6,4 daukat.

782
00:47:16,640 --> 00:47:19,850
Bubble sort modu guztiak hasteko ezkerreko, eta alderatu egingo

783
00:47:19,850 --> 00:47:24,700
i elementuak, eta, beraz, 0 eta 1 + i, elementu 1.

784
00:47:24,700 --> 00:47:29,020
, Esan ondo 5> 0 da, baina oraintxe bertan 5 ezkerrera,

785
00:47:29,020 --> 00:47:32,500
beraz, 5 eta 0 trukatu behar dut.

786
00:47:32,500 --> 00:47:35,470
Noiz horietako swap I, bat-batean, beste zerrenda hau lortu dut.

787
00:47:35,470 --> 00:47:38,260
Orain 5> 1, eta, beraz, horiek swap dugu.

788
00:47:38,260 --> 00:47:42,160
5> 6 ez da, beraz, ez dugu hemen ezer egin beharko.

789
00:47:42,160 --> 00:47:46,690
Baina 6> 4, eta, beraz, trukatu behar ditugu.

790
00:47:46,690 --> 00:47:49,740
Berriz ere, zerrenda osoa bitartez, azkenean, ezagutzeko exekutatu behar dugu

791
00:47:49,740 --> 00:47:52,330
horiek ordena; horiek swap gara,

792
00:47:52,330 --> 00:47:57,120
eta puntu honetan zerrendan zehar exekutatu 1 denbora gehiago behar ditugu

793
00:47:57,120 --> 00:48:05,390
Ziurtatu dena bere ordena da, eta hau burbuila puntu sort amaitu dadin.

794
00:48:05,390 --> 00:48:10,720
Beste elementu batzuk hartu eta hauek ordenatzeko algoritmoa aukeraketa sort da.

795
00:48:10,720 --> 00:48:15,740
Aukeraketa sort atzean dagoen ideia da eraikitzeko ari gara zerrendaren zati bat ordenatuko joan

796
00:48:15,740 --> 00:48:18,150
1 elementu aldi berean.

797
00:48:18,150 --> 00:48:23,170
>> Eta horretarako goaz ezkerreko zerrendan segmentu eraikitzen da.

798
00:48:23,170 --> 00:48:27,510
Eta, batez ere, behin - Urrats bakoitzean, txikiena utzi dugu elementu ari dugu.

799
00:48:27,510 --> 00:48:32,310
ez dela horrela antolatu oraindik, eta, hori horrela antolatu segmentu eraman dugu.

800
00:48:32,310 --> 00:48:35,850
Horrek esan nahi du etengabe gutxieneko Unsorted elementu aurkitu behar dugu

801
00:48:35,850 --> 00:48:40,720
eta, ondoren, gutxieneko elementu hartu eta edozein dela ere duten swap

802
00:48:40,720 --> 00:48:45,090
utzi-gehienak elementu hori ez da horrela antolatu.

803
00:48:45,090 --> 00:48:50,890
Honen denbora exekutatu O izango da kasu txarrena delako (n ²)

804
00:48:50,890 --> 00:48:55,070
beste elementu bakoitza elementu bakar behin alderatu behar dugu.

805
00:48:55,070 --> 00:48:59,250
Ari gara zerrendaren ezkerreko erdia hasten bada, behar delako esaten

806
00:48:59,250 --> 00:49:02,970
osoan segmentu eskuineko bidez joan txikiena elementua aurkitu.

807
00:49:02,970 --> 00:49:05,430
Eta gero, berriz, osoa baino gehiago joan eta eskuineko segmentu behar dugu

808
00:49:05,430 --> 00:49:08,210
mantentzeko pasa dela eta baino gehiago baino gehiago berriz.

809
00:49:08,210 --> 00:49:11,350
Hori n ² izango da. Bat behar loop beste baten barruan loop goaz

810
00:49:11,350 --> 00:49:13,350
n ² iradokitzen du.

811
00:49:13,350 --> 00:49:16,530
Kasu onena pentsamendu, demagun du ematen diogu, dagoeneko horrela antolatu zerrenda bat;

812
00:49:16,530 --> 00:49:19,270
egia esan, ez dugu ez n ² baino hobeto edozein.

813
00:49:19,270 --> 00:49:21,730
Aukeraketa sort hori ezagutzeko modu ez duelako

814
00:49:21,730 --> 00:49:25,540
gutxieneko elementu besterik ez da bat da bilatzen gertatuko.

815
00:49:25,540 --> 00:49:28,970
Behar du, hala ere, ziur hori da, benetan gutxieneko egiteko.

816
00:49:28,970 --> 00:49:31,670
>> Eta ziur gutxieneko hori egiteko modu bakarra, algoritmo honen bidez,

817
00:49:31,670 --> 00:49:34,640
elementu bakoitza berriro begiratu.

818
00:49:34,640 --> 00:49:38,420
Beraz, benetan, ematen baduzu ematen aukeraketa sort, dagoeneko horrela antolatu zerrenda bat,

819
00:49:38,420 --> 00:49:42,720
ez da edozein zerrenda bat ematen hori oraindik ez da horrela antolatu baino hobeto egin du.

820
00:49:42,720 --> 00:49:46,320
Hain zuzen ere, gertatzen den kasuan izan bada zerbait O (zerbait)

821
00:49:46,320 --> 00:49:50,640
eta zerbait omega, besterik esan gehiago succinctly zerbait θ.

822
00:49:50,640 --> 00:49:52,760
Beraz, bada etorriko dela edonon, hori da hori, besterik gabe esan nahi du ikusten duzu.

823
00:49:52,760 --> 00:49:57,580
>> Zerbait n theta izanez gero ², bai big O (n ²) eta Ω (n ²) da.

824
00:49:57,580 --> 00:49:59,790
Kasu onena eta txarrena kasuan, beraz, ez du diferentzia,

825
00:49:59,790 --> 00:50:04,400
algoritmoa da aldi bakoitzean gauza bera egiten du.

826
00:50:04,400 --> 00:50:06,610
Beraz, hau da, zer aukeraketa sort pseudocode itxura.

827
00:50:06,610 --> 00:50:10,630
Funtsean ari gara baino gehiago batetik bestera joateko zerrendan nahi dut esan nahi du

828
00:50:10,630 --> 00:50:15,180
ezkerretik eskuinera, eta begizta-iterazio bakoitzean, mugitu noa

829
00:50:15,180 --> 00:50:19,780
zerrendaren zati hau horrela antolatu gutxieneko elementu sartu.

830
00:50:19,780 --> 00:50:23,260
Eta behin zerbait mugitu dut, inoiz ez dut elementu hori berriro begiratu behar.

831
00:50:23,260 --> 00:50:28,600
Swap dut elementu bat ezkerreko zerrendatik segmentu bezain laster, delako ordenatuko

832
00:50:28,600 --> 00:50:32,600
ari garen guztia egiten ari delako Orden Gorakorra Minimoetarako erabiliz.

833
00:50:32,600 --> 00:50:38,740
Beraz, esan genuen, ados, posizioa i Oraindik dugu, eta begiratzen elementu guztiak behar dugu

834
00:50:38,740 --> 00:50:42,260
i eskubidea ordena gutxieneko aurkituko.

835
00:50:42,260 --> 00:50:46,150
Beraz, horrek esan nahi du, 1 + i bilatzeko zerrendaren bukaeran nahi dugu.

836
00:50:46,150 --> 00:50:51,610
Eta orain, elementu ari gara gaur egun begira gure gutxieneko baino gutxiago bada, orain arte,

837
00:50:51,610 --> 00:50:54,190
, gogoan, gutxienez off ari gara hasi besterik ez izan

838
00:50:54,190 --> 00:50:57,020
edozein izanda ere elementu ari gara; gutxieneko bere gain hartzen dut.

839
00:50:57,020 --> 00:51:00,270
Elementu bat iruditzen zait hori baino txikiagoa bada, orduan esan nahi dut joan, ados,

840
00:51:00,270 --> 00:51:02,700
ondo, gutxienez, berria aurkitu dut.

841
00:51:02,700 --> 00:51:06,080
Non gutxieneko zela gogoratzen dut.

842
00:51:06,080 --> 00:51:09,560
>> Beraz, gaur egun, behin hori Unsorted eskuineko segmentu bidez dut joan,

843
00:51:09,560 --> 00:51:16,690
Posizioa i elementu gutxieneko elementu swap noa esan dezaket.

844
00:51:16,690 --> 00:51:21,100
Hau da nire zerrenda sortu du, nire horrela antolatu ezkerretik eskuinera zerrenda zati,

845
00:51:21,100 --> 00:51:25,190
eta ez dugu inoiz elementu bat begiratu behar berriro zati horretan behin.

846
00:51:25,190 --> 00:51:27,930
Behin trukatuko dugu.

847
00:51:27,930 --> 00:51:30,260
Hargatik exekutatu aukeraketa sort zerrenda honetan.

848
00:51:30,260 --> 00:51:38,220
Blue elementu hemen i izango da, eta elementu gorri gutxieneko elementu izango da.

849
00:51:38,220 --> 00:51:41,570
Beraz, bide guztiak hasten i zerrendaren ezkerreko, eta, beraz, 5.

850
00:51:41,570 --> 00:51:44,610
Orain gutxieneko Unsorted elementu aurkitu behar dugu.

851
00:51:44,610 --> 00:51:49,480
Beraz, 0 <5, eta, beraz, 0 my new minimoa esaten dugu.

852
00:51:49,480 --> 00:51:53,820
>> Baina ezin dut gelditu, nahiz eta aitortu 0 txikiena dugulako,

853
00:51:53,820 --> 00:51:59,390
beste elementu guztietan ziurtatu zerrenda bidez exekutatu behar dugu.

854
00:51:59,390 --> 00:52:01,760
1 Beraz, handiagoa da, 6 handiagoa da, 4 handiagoa da.

855
00:52:01,760 --> 00:52:05,850
Horrek esan nahi du, elementu horiek guztiak begiratu ondoren, 0 txikiena erabaki dut.

856
00:52:05,850 --> 00:52:09,800
Beraz, 5 eta 0 swap noa.

857
00:52:09,800 --> 00:52:15,480
Behin hori swap I, zerrenda berri bat lortu dut joan, eta inoiz ez 0 dela berriro begiratu behar dut ezagutzen dut

858
00:52:15,480 --> 00:52:19,380
behin trukatuko dugu dudalako, ordenatuko dut da eta egiten gaude.

859
00:52:19,380 --> 00:52:22,730
Orain, beraz, zerbait gertatzen da elementu urdina da berriro 5,

860
00:52:22,730 --> 00:52:26,030
eta 1 begiratu behar dugu, 6 eta 4 1 zehazten duten

861
00:52:26,030 --> 00:52:31,520
gutxieneko elementu txikiena da, beraz, 1 eta 5 swap dugu.

862
00:52:31,520 --> 00:52:36,890
Berriz ere, begiratu behar dugu - compare 5, 6 eta 4,

863
00:52:36,890 --> 00:52:39,830
eta 4 eta 5 swap dugu, eta, azkenik, alderatu

864
00:52:39,830 --> 00:52:45,740
duten 2 zenbakiak, eta horiek swap lortuko dugu gure zerrenda ordenatuko arte.

865
00:52:45,740 --> 00:52:49,730
Aukeraketa sort edozein galdera?

866
00:52:49,730 --> 00:52:56,420
Ongi da. Dezagun azken gaia mugitzeko hemen, eta hori errekurtsio.

867
00:52:56,420 --> 00:52:59,810
>> Errekurtsio, gogoan,, hau benetan meta gauza da, non funtzio bat

868
00:52:59,810 --> 00:53:02,740
behin eta berriz dei egiten die bere burua.

869
00:53:02,740 --> 00:53:05,620
Beraz, uneren batean, gure fuction da berriz, eta behin eta berriz, bera deituz,

870
00:53:05,620 --> 00:53:10,100
geure burua deituz gelditzeko dugu noizbait izan behar.

871
00:53:10,100 --> 00:53:13,670
Hori egiten ez badugu, ondoren, delako besterik ez ari gara Horretarako betirako jarraituko du,

872
00:53:13,670 --> 00:53:16,660
eta, gure programa ez da amaitutzat joan.

873
00:53:16,660 --> 00:53:19,200
Baldintza hau oinarri kasuan deitzen diogu.

874
00:53:19,200 --> 00:53:22,570
Eta oinarri kasuan dio, baizik eta funtzio bat berriro deituz baino,

875
00:53:22,570 --> 00:53:25,330
Besterik ez dut balio batzuk itzuli egingo da.

876
00:53:25,330 --> 00:53:28,080
Beraz, balio bat dugu itzuliko behin, gelditu behar dugu geure burua deituz,

877
00:53:28,080 --> 00:53:32,550
eta gainerako deiak egin dugu hain urruti ere itzultzeko.

878
00:53:32,550 --> 00:53:36,050
Errekurtsiboaren kasuan oinarri kasuan kontrakoa da.

879
00:53:36,050 --> 00:53:39,050
Eta hori dela eta, dei bat egiteko ari gara gaur egun oraindik sartu funtzioa nahi dugu

880
00:53:39,050 --> 00:53:44,690
Eta, seguruenik, ez da beti, nahiz eta, beharbada argumentuak desberdinak erabili.

881
00:53:44,690 --> 00:53:48,940
>> Beraz, bada, deitzen f funtzio bat dugu, eta f izeneko hartu du 1 argumentua,

882
00:53:48,940 --> 00:53:52,010
eta mantendu besterik ez dugu f (1), f (1), f (1) telefonora deituz, eta, beraz, besterik ez da gertatzen

883
00:53:52,010 --> 00:53:56,510
1 argumentua kasu recursive jaitsierak, oraindik ari gara inoiz ez gelditzeko.

884
00:53:56,510 --> 00:54:01,620
Nahiz eta oinarri-kasu bat dugu, ziur azkenean base Kasu horretan, hit dugu egin behar dugu.

885
00:54:01,620 --> 00:54:04,250
Ez dugu mantendu, recursive kasu honetan gelditzea.

886
00:54:04,250 --> 00:54:09,870
Oro har, geure buruari deitzen diogu, ziurrenik ari gara beste argumentu bat izan aldi bakoitzean.

887
00:54:09,870 --> 00:54:12,700
Funtzioa errekurtsiboa oso sinplea da.

888
00:54:12,700 --> 00:54:15,090
Beraz, hau Zenbaki baten faktoriala kalkulatzeko.

889
00:54:15,090 --> 00:54:17,790
Gora Gora hemen dugu gure oinarria kasuan.

890
00:54:17,790 --> 00:54:22,330
Kasu n ≤ 1, ez gabiltza faktore berriro deitzeko.

891
00:54:22,330 --> 00:54:26,490
Geldiarazten ari dugu; besterik ari gara balio batzuk itzuli.

892
00:54:26,490 --> 00:54:30,170
Hau da, ez bada egia, orduan gure recursive kasua sakatu dugu.

893
00:54:30,170 --> 00:54:33,550
Iragarki hemen ari gara ez bakarrik faktore (n), deituz ez litzateke oso lagungarria izan delako.

894
00:54:33,550 --> 00:54:36,810
Beste zerbait faktoriala deitu dugu.

895
00:54:36,810 --> 00:54:40,850
>> Eta horrela, ikus dezakezu, azkenean, faktore (5) edo zerbait pasatzen dugu,

896
00:54:40,850 --> 00:54:45,900
faktore (4), eta, beraz, deitu dugu, eta, azkenean, oinarri kasu honetan hit goaz.

897
00:54:45,900 --> 00:54:51,730
Beraz, itxura ona. Dezagun zer gertatzen den benetan exekutatu dugu hau ikus-en.

898
00:54:51,730 --> 00:54:57,840
Pila da, eta demagun nagusia da funtzio hau deitu argumentu bat behar du (4).

899
00:54:57,840 --> 00:55:02,200
Beraz, behin faktore ikusten eta = 4, faktore bera deituko.

900
00:55:02,200 --> 00:55:05,010
Orain, bat-batean, faktore (3) dugu.

901
00:55:05,010 --> 00:55:10,780
Beraz, funtzio horiek gero eta handiagoa mantentzeko, azkenean, gure base kasuan hit arte.

902
00:55:10,780 --> 00:55:17,830
Puntu honetan, honen balioa bueltan bueltan (NX honen balioa itzulera) da,

903
00:55:17,830 --> 00:55:21,290
honen balioa itzulera NX honen balioa bueltan da.

904
00:55:21,290 --> 00:55:23,290
Azkenean, zenbaki batzuk sakatu behar dugu.

905
00:55:23,290 --> 00:55:26,560
Hemen goian, bueltan 1 esaten dugu.

906
00:55:26,560 --> 00:55:30,650
Horrek esan nahi du, behin zenbaki hori itzuli dugu, hau da, pop dezakegu pila off.

907
00:55:30,650 --> 00:55:36,570
Beraz, faktore hau (1) egiten da.

908
00:55:36,570 --> 00:55:41,190
1 itzultzen du, hau faktore (1) itzulerak, 1 itzulera hau.

909
00:55:41,190 --> 00:55:46,910
Horretarako balio itzulera, gogoan, NX zen honen balioa itzultzeko.

910
00:55:46,910 --> 00:55:50,720
Beraz, bat-batean, lasaia daki 2 itzuli nahi dut.

911
00:55:50,720 --> 00:55:55,910
>> Beraz, gogoratu, itzuli honen balioa besterik ez da NX Itzultzen den balioa sortu hemen.

912
00:55:55,910 --> 00:56:01,160
Beraz, gaur egun esan 3 dezakegu x 2, eta, azkenik, hemen esan ahal izango dugu

913
00:56:01,160 --> 00:56:04,010
hau 4 x 3 x 2 besterik ez da izango.

914
00:56:04,010 --> 00:56:09,570
Eta itzulera behin, nagusi bat barruan osokoaren bakarra lortu dugu.

915
00:56:09,570 --> 00:56:15,460
Errekurtsio edozein galdera?

916
00:56:15,460 --> 00:56:17,090
Guztiak eskubidea. Beraz, amaieran, galderak egiteko denbora gehiago

917
00:56:17,090 --> 00:56:23,360
baina, orain, Joseph gainerako gaiak estaltzeko izango da.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] eskubidea. Beraz, gaur egun ditudan recursions buruz hitz egin,

919
00:56:25,590 --> 00:56:27,840
dezagun eztabaida pixka bat sort batu zer da.

920
00:56:27,840 --> 00:56:31,740
Batu sort da, funtsean, zenbakien zerrenda ordenatzeko beste modu bat.

921
00:56:31,740 --> 00:56:36,430
Eta nola funtzionatzen du, merge sort zerrenda bat duzu, eta zer egiten dugun

922
00:56:36,430 --> 00:56:39,120
, esan dezagun zatitu 2 halves sartu.

923
00:56:39,120 --> 00:56:42,750
Dugu lehenik eta behin exekutatu batu sort berriro ezkerreko erdia,

924
00:56:42,750 --> 00:56:45,040
ondoren exekutatu batu sort eskuineko erdia dugu,

925
00:56:45,040 --> 00:56:50,240
eta horrek ematen digu orain 2 halves antolatuko dira, eta, gaur egun, halves horiek elkarrekin konbinatu goaz.

926
00:56:50,240 --> 00:56:55,010
Pixka bat zaila da adibide bat gabe, beraz, mozioak bidez egingo dugu, eta ikusi zer gertatzen den.

927
00:56:55,010 --> 00:56:59,590
Beraz zerrenda honetan, zatitu dugu 2 halves hasten zara.

928
00:56:59,590 --> 00:57:02,300
Batu sort ezkerreko erdia eskaintzen ditugu.

929
00:57:02,300 --> 00:57:06,660
Beraz, ezker erdian, eta, orain, horiek exekutatu dugu zerrenda honen bidez berriro

930
00:57:06,660 --> 00:57:09,800
lortzen merge sort sartu gainditu, eta, ondoren, berriro begiratzen dugu,

931
00:57:09,800 --> 00:57:13,270
zerrenda honen ezkerraldean eta batu sort on exekutatu dugu.

932
00:57:13,270 --> 00:57:15,880
Orain, behera 2 zenbakien zerrenda bat lortzen dugu,

933
00:57:15,880 --> 00:57:19,010
eta gaur egun ezkerreko erdia 1 bakarrik elementu luze da, eta ezin dugu

934
00:57:19,010 --> 00:57:23,380
zatitu zerrenda bat dituen elementu 1 erdiak bakarrik sartu da, beraz, esatea besterik ez dugu, behin 50 dugu,

935
00:57:23,380 --> 00:57:26,400
1 elementua besterik ez da, dagoeneko ordenatuko da.

936
00:57:26,400 --> 00:57:29,860
>> Ari egin ondoren, ikusi ahal izango dugu

937
00:57:29,860 --> 00:57:32,230
zerrenda honen erdia eskuinera joan,

938
00:57:32,230 --> 00:57:36,480
eta 3 ere ordenatuta, eta, beraz, zerrenda honetako bi halves antolatuko dira

939
00:57:36,480 --> 00:57:39,080
zenbaki horiek itzuli batera sartu ahal izango dugu.

940
00:57:39,080 --> 00:57:45,320
Beraz, itxura, 50 eta 3 3 50 baino txikiagoa da, beraz, hasten da eta, ondoren, 50 dator sartu

941
00:57:45,320 --> 00:57:49,340
Orain, hori egin, atzera egin dugu eskuineko erdia da zerrenda horretan, eta ordenatu.

942
00:57:49,340 --> 00:57:52,440
42 propioa zenbakia da, beraz, dagoeneko horrela antolatu du.

943
00:57:52,440 --> 00:57:57,850
Beraz, gaur egun horiek alderatu dugu, 2 eta 3 42 baino txikiagoa da, eta, beraz, duten lortzen lehen jarri,

944
00:57:57,850 --> 00:58:02,340
Gaur egun, 42 lortzen jarri, eta 50 lortzen jarri sartu

945
00:58:02,340 --> 00:58:07,220
Orain, hori horrela antolatu, modu guztiak joaten gara goian, 1337 eta 15.

946
00:58:07,220 --> 00:58:14,560
Beno, zerrenda honen ezkerreko zatian aztertuko dugu; 1337, berez da, beraz horrela antolatu eta bera, 15.

947
00:58:14,560 --> 00:58:19,020
Beraz, orain 2 zenbakiak hauek konbinatu dugu jatorrizko zerrenda, 15 <1337 ordenatzeko,

948
00:58:19,020 --> 00:58:23,060
hasten da eta, ondoren, 1337 doan sartu

949
00:58:23,060 --> 00:58:26,640
Eta orain, bi halves jatorrizko zerrenda top sortu horrela antolatu dugu.

950
00:58:26,640 --> 00:58:30,440
Eta hori guztia egin behar dugu konbinatu hauek.

951
00:58:30,440 --> 00:58:36,890
Itxura zerrenda honetan lehenengo 2 zenbakiak, 3 <15 ditugu, beraz, doa sort array sartu da lehen aldiz.

952
00:58:36,890 --> 00:58:44,460
15 <42, eta, beraz, sartu jartzen da orain, 42 <1337, doan sartu

953
00:58:44,460 --> 00:58:51,010
50 <1337, eta, beraz, sartu doa eta iragarki-Hori besterik ez dugu hartu 2 zenbakiak off zerrenda honetan.

954
00:58:51,010 --> 00:58:53,640
Beraz, ez ari gara 2 zerrendak artean txandakatuz.

955
00:58:53,640 --> 00:58:56,050
Ari gara hasieran, eta elementu hartzen ari gara

956
00:58:56,050 --> 00:59:00,270
txikiagoa da eta, ondoren, gure array jarriz.

957
00:59:00,270 --> 00:59:04,080
Orain halves guztiak batu dugu, eta egiten gaude.

958
00:59:04,080 --> 00:59:07,780
>> Edozein galdera buruz sort batu? Bai?

959
00:59:07,780 --> 00:59:14,190
[Student] bada splitting talde desberdinetan, zergatik ez zatitu besterik ez dute behin

960
00:59:14,190 --> 00:59:19,970
eta 3 eta 2 talde batean? [Galdera ulertezinak gainerakoa]

961
00:59:19,970 --> 00:59:24,940
Arrazoia - beraz, galdera da, zergatik ezin batu besterik ez dugu lehen urratsa dugu ondoren?

962
00:59:24,940 --> 00:59:29,530
Arrazoia honako hau egin ahal izango dugu, bi aldeetan elementu ezker-gehienak etan hasiko da,

963
00:59:29,530 --> 00:59:33,040
eta, ondoren, txikiago bat hartu eta jarri da, ezagutzen dugun horiek

964
00:59:33,040 --> 00:59:35,290
banakako zerrendak aginduak jaso ditu ordenatuko dira.

965
00:59:35,290 --> 00:59:37,290
Beraz, bada, halves bi elementu ezker gehien bilatzen dut,

966
00:59:37,290 --> 00:59:40,490
Zerrendetan duten elementuak txikiena izan ari dira ezagutzen dut.

967
00:59:40,490 --> 00:59:43,930
Beraz, jarri ahal izango dut handi horren zerrendan elementu lekuak txikiena.

968
00:59:43,930 --> 00:59:47,810
Beste alde batetik, 2 zerrendak horietan han bigarren maila begiratuz gero,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 eta 15, horiek ez dira ordenatuko da.

970
00:59:51,640 --> 00:59:55,770
Beraz, bada, 50 eta 1337 at I, 50 jarri nire zerrendan lehen noa.

971
00:59:55,770 --> 01:00:00,130
Baina hori ez da benetan zentzurik, 3 delako out elementu horien guztien txikiena da.

972
01:00:00,130 --> 01:00:04,390
Beraz, arrazoi bakarra konbinatuz urrats hau egin ahal izango dugu gure zerrendak dagoeneko horrela antolatu direlako.

973
01:00:04,390 --> 01:00:07,010
Zein da zergatik modu guztiak beheraino dugu

974
01:00:07,010 --> 01:00:09,800
bakarra zenbaki bat dugu, zenbaki bakarra delako badakizu

975
01:00:09,800 --> 01:00:14,120
eta bera da dagoeneko horrela antolatu zerrenda bat.

976
01:00:14,120 --> 01:00:19,360
>> Edozein galdera? Ez?

977
01:00:19,360 --> 01:00:24,260
Complexity? Beno, urrats bakoitzaren amaieran zenbakiak dezakezu

978
01:00:24,260 --> 01:00:27,590
eta erdi log n aldiz, zerrenda bat zatitzen ahal izango dugu,

979
01:00:27,590 --> 01:00:31,700
hau da, non n x log n konplexutasuna lortuko dugu.

980
01:00:31,700 --> 01:00:34,940
Eta ikus merge sort kasuan onena da n log n duzu, eta, beraz, besterik ez da gertatzen

981
01:00:34,940 --> 01:00:39,340
txarrena kasuan, edo han Ω dela ere n n saioa.

982
01:00:39,340 --> 01:00:42,480
Kontuan hartu zerbait.

983
01:00:42,480 --> 01:00:45,750
Mugitzea, goazen fitxategi batzuk super oinarrizko I / O.

984
01:00:45,750 --> 01:00:48,830
Scramble begiratu bada, nabarituko sistema nolabaiteko izan genuen duzu

985
01:00:48,830 --> 01:00:51,270
log fitxategi bat idazteko kode bidez irakurriz gero.

986
01:00:51,270 --> 01:00:53,730
Ikus dezagun nola egin dezake.

987
01:00:53,730 --> 01:00:57,450
Beno, fprintf dugu, besterik ez printf dezakezu uste,

988
01:00:57,450 --> 01:01:01,720
baina fitxategi batean ordez inprimatzea, eta, beraz, hasieran f.

989
01:01:01,720 --> 01:01:07,570
Kode sort hemen, zer egiten da, Scramble duzu gisa ikus dezake,

990
01:01:07,570 --> 01:01:12,310
errenkada zenbakiak dira errenkadan out doa 2 dimentsioko array inprimatzeko bidez.

991
01:01:12,310 --> 01:01:17,850
Kasu honetan, printf bistaratzen zure terminal edo zer atal irteera estandarra deitzen dugu.

992
01:01:17,850 --> 01:01:22,170
>> Eta orain, kasu honetan, guztiak egin behar dugu ordezkatu printf fprintf batera,

993
01:01:22,170 --> 01:01:26,770
dira zer fitxategia inprimatu nahi duzun, eta kasu honetan bistaratzen besterik ez da fitxategi hori

994
01:01:26,770 --> 01:01:32,230
ordez inprimatzeko zure terminal.

995
01:01:32,230 --> 01:01:36,500
Beno, gero begs galdera: Non fitxategi moduko hau lortuko dugu, eskuinera?

996
01:01:36,500 --> 01:01:39,840
Fprintf fuction saioa gainditu genuen, baina ez zen ideia izan genuen.

997
01:01:39,840 --> 01:01:43,980
Beno, kodea hasieran, zer egin genuen zatia kode hau hemen baino gehiago izan zen,

998
01:01:43,980 --> 01:01:48,340
funtsean dio irekitako fitxategi log.txt deiak.

999
01:01:48,340 --> 01:01:53,220
Zer ondoren egiten dugu ziurtatu fitxategi hori benetan ondo ireki egin behar dugu.

1000
01:01:53,220 --> 01:01:57,070
Beraz, arrazoi baino gehiago egin dezake huts egin, ez duzu zure ordenagailuan nahikoa leku, adibidez.

1001
01:01:57,070 --> 01:01:59,790
Beraz, garrantzitsua da beti fitxategia duen edozein eragiketa aurretik

1002
01:01:59,790 --> 01:02:03,300
egiaztatu fitxategi hori ez da ondo ireki zen.

1003
01:02:03,300 --> 01:02:09,330
Beraz, zer, fopen argumentu bat behar du, ondo, fitxategi berri bat ireki ahal izango dugu modu askotan.

1004
01:02:09,330 --> 01:02:13,510
Zer da egin ahal izango dugu, gainditu ahal izango dugu w, horrek esan nahi du, gainidatzi fitxategia da irteerak badago,

1005
01:02:13,510 --> 01:02:18,070
Bat gainditu ahal izango dugu, fitxategia amaieran erantsi du gainidazteko ordez,

1006
01:02:18,070 --> 01:02:22,730
edo r zehaztu ahal izango dugu, eta horrek esan nahi du, dezagun ireki fitxategia irakurtzeko-soilik gisa.

1007
01:02:22,730 --> 01:02:24,890
Beraz, bada programa saiatuko da fitxategi edozein aldaketa egiteko,

1008
01:02:24,890 --> 01:02:30,140
Yell horietan, eta ez dezagun egin horiek.

1009
01:02:30,140 --> 01:02:33,320
Azkenik, behin gaude fitxategia egin, egindako eragiketak egiten ari da,

1010
01:02:33,320 --> 01:02:35,860
Ziurtatu fitxategia itxi egiten dugu egin behar dugu.

1011
01:02:35,860 --> 01:02:38,830
Eta horrela, programaren amaieran, horiek berriro pasatzeko zoaz

1012
01:02:38,830 --> 01:02:42,120
fitxategi hau ireki duzun, eta besterik ez da itxi.

1013
01:02:42,120 --> 01:02:44,650
Beraz, hau zerbait garrantzitsua egin duzula egin duzula.

1014
01:02:44,650 --> 01:02:47,180
Beraz, gogoratu fitxategi bat ireki dezakezu, eta ondoren fitxategia idatzi,

1015
01:02:47,180 --> 01:02:51,270
eragiketak egiteko fitxategia, baina gero fitxategia itxi bukaeran izango duzu.

1016
01:02:51,270 --> 01:02:53,270
>> Oinarrizko fitxategia edozein galdera I / O? Bai?

1017
01:02:53,270 --> 01:02:58,050
[Student galdera, ulertezina]

1018
01:02:58,050 --> 01:03:02,480
Eskuin hemen. Galdera da, non log.txt Fitxategi hau ez agertzen?

1019
01:03:02,480 --> 01:03:07,890
Beno, besterik ez duzu log.txt ematen bada, sortzen da exekutagarriaren direktorioa berean.

1020
01:03:07,890 --> 01:03:10,500
Beraz, you're - >> [Student galdera, ulertezina]

1021
01:03:10,500 --> 01:03:18,830
Bai. Karpeta berean, edo direktorio berean, deitzen duzun bezala.

1022
01:03:18,830 --> 01:03:21,400
Orain memoria, pila, eta zeure.

1023
01:03:21,400 --> 01:03:23,400
Beraz, memoria ezarritako ordenagailuan nola?

1024
01:03:23,400 --> 01:03:26,270
Beno, memoria imajinatu dezakezu bloke hau hemen sort gisa.

1025
01:03:26,270 --> 01:03:30,260
Eta memoria zeure han itsatsita, eta hori hor behera pila deitzen dugu.

1026
01:03:30,260 --> 01:03:34,480
Eta zeure hazten beheranzko eta pila hazten goranzko.

1027
01:03:34,480 --> 01:03:38,620
Beraz, aipatu gisa Tommy - oh, ondo, eta beste 4 segmentu dut bigarren bat lortu behar dugu

1028
01:03:38,620 --> 01:03:42,890
Tommy lehenago esan bezala, bere funtzioak nola deitzen bere burua, eta elkarri deitu ezagutzen duzu?

1029
01:03:42,890 --> 01:03:44,930
Sortu dira pilaren markoa moduko hau.

1030
01:03:44,930 --> 01:03:47,360
Beno, nagusia deiak foo foo pilaketan jartzen bada lortzen.

1031
01:03:47,360 --> 01:03:52,430
Foo deiak bar, bar pila jarri, eta hori lortzen pila jarri ondoren.

1032
01:03:52,430 --> 01:03:57,040
Eta itzuliko dute, dute bakoitzean get hartu off pila.

1033
01:03:57,040 --> 01:04:00,140
Zer kokaleku horietan bakoitzean eta memoria eduki sakatuta?

1034
01:04:00,140 --> 01:04:03,110
Beno, goiko aldean, testu-segmentua da, programa bera dauka.

1035
01:04:03,110 --> 01:04:06,390
Hori makina kodea Beraz, han, behin zure programa konpilatu duzu.

1036
01:04:06,390 --> 01:04:08,520
Ondoren, edozein hasieratu global aldagai.

1037
01:04:08,520 --> 01:04:12,660
>> Beraz, zure programan aldagai global duzu, eta esan bezala, = 5,

1038
01:04:12,660 --> 01:04:15,260
lortzen segmentu horretan jarri, eta eskubide hori pean,

1039
01:04:15,260 --> 01:04:18,990
edozein uninitialized global datuak, hau da, besterik ez INT bat behar duzu,

1040
01:04:18,990 --> 01:04:20,990
baina ez duzu esan ezer berdina da.

1041
01:04:20,990 --> 01:04:23,870
Konturatzen global aldagai horiek ez dira, beraz, nagusiaren kanpo ari dira.

1042
01:04:23,870 --> 01:04:28,560
Beraz, horrek esan nahi du edozein global aldagaiak deklaratu dira, baina ez dira hasieratu.

1043
01:04:28,560 --> 01:04:32,310
Beraz, zer zeure en? Memoria esleitu malloc, lortu dugu pixka bat erabiliz.

1044
01:04:32,310 --> 01:04:35,990
Eta, azkenik, tokian tokiko aldagai pila baduzu

1045
01:04:35,990 --> 01:04:39,950
eta beren parametro edozein funtzio deitu dezakezu.

1046
01:04:39,950 --> 01:04:43,720
Azken gauza, ez duzu benetan zer ingurune-aldagai badakite,

1047
01:04:43,720 --> 01:04:46,700
baina bakoitzean programa exekutatzen duzun, zerbait lotutako da, hala nola

1048
01:04:46,700 --> 01:04:49,550
hau programa ran duten pertsona izen hori erabiltzen da.

1049
01:04:49,550 --> 01:04:51,550
Eta hori izan da sort-beheko aldean.

1050
01:04:51,550 --> 01:04:54,540
Memoria helbideak, balio hamaseitarra dagokionez,

1051
01:04:54,540 --> 01:04:58,170
0 goialdeko Irteeran balioak doazenak, eta modu guztiak, beheraino jaisten.

1052
01:04:58,170 --> 01:05:00,440
Kasu honetan, 32-bit sistema baduzu,

1053
01:05:00,440 --> 01:05:05,390
, behealdean helbidea da 0x izango da, af ondoren, 32 bit direlako,

1054
01:05:05,390 --> 01:05:10,890
8 byte da, eta kasu honetan 8 byte 8 hamaseitarrean digituak dagokio.

1055
01:05:10,890 --> 01:05:20,110
Beraz, behera hemen, nahi, 0xffffff ari zaren joan, eta han 0 izan zaren.

1056
01:05:20,110 --> 01:05:23,660
Beraz, zer dira erakusleak? Batzuk, agian, ez dute estaltzen Atal honetan aurretik.

1057
01:05:23,660 --> 01:05:26,660
baina gainean genuen joan hitzaldia, erakuslea datu mota bat da, beraz,

1058
01:05:26,660 --> 01:05:34,030
zein denda, 50 bezalako balioa ordez nolabaiteko, memoria kokapena batzuen helbidea gordetzen.

1059
01:05:34,030 --> 01:05:36,020
Memoria hori Like [ulertezinak].

1060
01:05:36,020 --> 01:05:41,120
Beraz, kasu honetan, zer egin dugu, zenbaki oso bat edo int * erakuslea dugu,

1061
01:05:41,120 --> 01:05:46,210
hamaseitarra hau 0xDEADBEEF helbidea ditu.

1062
01:05:46,210 --> 01:05:50,880
>> Beraz, zer behar dugu, hau da, gaur egun, memoria kokapena batzuk erakuslea puntu honetan,

1063
01:05:50,880 --> 01:05:56,020
eta hori bat besterik ez, balio memoriaren kokaleku honen 50.

1064
01:05:56,020 --> 01:06:01,810
Sistema batzuetan 32-bit, 32 bit-sistema guztietan, erakusleak hartzen dute 32 bit edo 4 bytes.

1065
01:06:01,810 --> 01:06:06,020
Baina, esate baterako, 64-bit sistema bat, erakusleak 64 bit dira.

1066
01:06:06,020 --> 01:06:08,040
Beraz, zerbait nahi duzu kontuan mantentzeko.

1067
01:06:08,040 --> 01:06:12,310
Beraz, azken-bit sistema bat, erakusle bat da amaiera bit luze.

1068
01:06:12,310 --> 01:06:17,320
Erakusleak dira sort zaila digeritzen gauza aparteko gabe,

1069
01:06:17,320 --> 01:06:20,300
beraz memoria dinamikoa esleipena adibide baten bidez joan.

1070
01:06:20,300 --> 01:06:25,130
Zer memoria esleipen dinamikoa ez, edo zer malloc deitzen diogu,

1071
01:06:25,130 --> 01:06:29,280
multzoa kanpo datuak nolabaiteko esleitu duzu aukera.

1072
01:06:29,280 --> 01:06:31,830
Beraz, datu horiek sort Programaren iraupena iraunkorra.

1073
01:06:31,830 --> 01:06:36,430
Ezagutzen duzun delako, aldarrikatu x funtzio baten barruan, eta funtzioak hori bada,

1074
01:06:36,430 --> 01:06:40,910
ez dute gehiago izan zen x gordetzen diren datuak sartzeko.

1075
01:06:40,910 --> 01:06:44,420
Zer erakusleak gaitezen egin da memoria edo denda-balioak gordetzeko dezagun

1076
01:06:44,420 --> 01:06:46,840
memoria segmentu bat, hain zuzen ere, zeure.

1077
01:06:46,840 --> 01:06:49,340
Orain behin izarrekin itzuli dugu funtzioa, betiere, erakuslea

1078
01:06:49,340 --> 01:06:54,960
memoria kokaleku hori, eta gero zer egin ahal izango dugu, bertan balioak begiratu besterik ez dezakegu.

1079
01:06:54,960 --> 01:06:58,020
Dezagun adibide bat bilatzeko: Hau da gure memoria layout da berriro.

1080
01:06:58,020 --> 01:07:00,050
Eta funtzio hau dugu, nagusia.

1081
01:07:00,050 --> 01:07:06,870
Zer egiten da, ados, hain erraza, eskuineko? Int x = 5, pilaketan aldagai nagusia.

1082
01:07:06,870 --> 01:07:12,450
>> Beste alde batetik, gaur egun erakuslea deiak funtzioa giveMeThreeInts aldarrikatzen dugu.

1083
01:07:12,450 --> 01:07:16,800
Eta, beraz, gaur egun funtzio honetan sartu dugu, eta bat besterik ez da, pila marko berria sortzen dugu.

1084
01:07:16,800 --> 01:07:20,440
Hala eta guztiz ere, pila marko honetan, int * temp aldarrikatzen dugu,

1085
01:07:20,440 --> 01:07:23,210
mallocs Gurekin 3 zenbaki osoko.

1086
01:07:23,210 --> 01:07:25,880
Beraz, int tamaina emango digu zenbat byte int hau da,

1087
01:07:25,880 --> 01:07:29,620
eta malloc ematen digu espazio asko byte on zeure.

1088
01:07:29,620 --> 01:07:32,890
Beraz, kasu honetan, 3 zenbaki osoko nahikoa leku sortu ditugu,

1089
01:07:32,890 --> 01:07:36,830
eta zeure modu bat da bertan, hau da, zergatik marrazten dut gorago.

1090
01:07:36,830 --> 01:07:42,900
Gaude egin ondoren, itzuli gara hemen, besterik ez duzu 3 ints itzuli

1091
01:07:42,900 --> 01:07:47,000
eta helbidea itzultzen du, kasu honetan, non memoria hori baino gehiago da.

1092
01:07:47,000 --> 01:07:51,250
Eta erakuslea = switch ezarri dugu, eta han erakuslea beste besterik ez dugu.

1093
01:07:51,250 --> 01:07:54,550
Baina, zer funtzioak hori pilatuta hemen eta desagertu egingo da.

1094
01:07:54,550 --> 01:07:59,250
Beraz, temp desagertzen da, baina oraindik ere mantentzen dugu non helbidea

1095
01:07:59,250 --> 01:08:01,850
3 zenbaki osoko horiek sare barruan daude.

1096
01:08:01,850 --> 01:08:06,180
Beraz, multzo honetan, erakusleak dira scoped lokalean eta pilatuak fotogramaren

1097
01:08:06,180 --> 01:08:09,860
baina memoria dute erreferentzia, zeure da.

1098
01:08:09,860 --> 01:08:12,190
>> Ez duela zentzurik?

1099
01:08:12,190 --> 01:08:14,960
[Student] Hori izan errepikatu duzu? >> [Joseph] Bai.

1100
01:08:14,960 --> 01:08:20,270
Beraz, I itzuli pixka bat izanez gero, temp esleitu ikusiko duzu

1101
01:08:20,270 --> 01:08:23,500
han sortu zeure memoria batzuk.

1102
01:08:23,500 --> 01:08:28,680
Beraz, funtzio hau, giveMeThreeInts itzultzen, pila hau hemen da desagertuko.

1103
01:08:28,680 --> 01:08:35,819
Eta edozein aldagai, kasu honetan, erakusle hau marko pilatuak banatzen zen.

1104
01:08:35,819 --> 01:08:39,649
Hau desagertu egingo da, baina itzuli gara temp geroztik

1105
01:08:39,649 --> 01:08:46,330
eta erakuslea ezarri dugu = aldi baterako, erakuslea da kokapen memoria berean aldi baterako izan zen seinalatu.

1106
01:08:46,330 --> 01:08:50,370
Beraz, gaur egun, nahiz eta temp, tokiko erakuslea hori galduko dugu,

1107
01:08:50,370 --> 01:08:59,109
aldagaia erakuslea horren barruan zer zen seinalatuz helbidea memoria oraindik mantenduko dugu.

1108
01:08:59,109 --> 01:09:03,740
Zalantzak dituzu? Hori da gai bat nahasgarria mota izan daiteke, ez baduzu baino gehiago desagertu atalean.

1109
01:09:03,740 --> 01:09:09,240
, Ezin dugu zure TF behin betiko gainean eta, jakina, galderei erantzun ahal izango dugu

1110
01:09:09,240 --> 01:09:11,500
amaieran, saio berrikuspena.

1111
01:09:11,500 --> 01:09:14,220
Baina gai konplexu bat sort da, eta diren erakusteko adibide gehiago behar dut

1112
01:09:14,220 --> 01:09:18,790
argitzeko zer erakusleak benetan lagunduko du.

1113
01:09:18,790 --> 01:09:22,500
>> Kasu honetan, erakusleak array baliokideak dira,

1114
01:09:22,500 --> 01:09:25,229
beraz, bakarrik erabili ahal izango dut erakuslea hau array bat int gisa gauza bera gisa.

1115
01:09:25,229 --> 01:09:29,840
Beraz, 0 sartu naiz, indexatzeko eta lehen osokoa aldatu 1,

1116
01:09:29,840 --> 01:09:39,689
Bigarren zenbaki aldatu, 2 eta 3. osokoa 3.

1117
01:09:39,689 --> 01:09:44,210
Beraz, erakusleak gehiago. Beno, gogoratzen Binky.

1118
01:09:44,210 --> 01:09:48,319
Kasu honetan banatzen dugu erakuslea, edo erakuslea izendatu dugu.

1119
01:09:48,319 --> 01:09:52,760
baina hasieran, deklaratu dut erakuslea, ez da memorian edozein lekutan seinalatuz.

1120
01:09:52,760 --> 01:09:54,930
Zabor barruan balioak da.

1121
01:09:54,930 --> 01:09:56,470
Beraz, ez daki non erakuslea da seinalatuz daukat.

1122
01:09:56,470 --> 01:10:01,630
Helbide bat besterik ez da, 0 eta 1 non hasieran deklaratu bete ditu.

1123
01:10:01,630 --> 01:10:04,810
Ezin dut ezer egin honekin deitzen diot nik malloc arte

1124
01:10:04,810 --> 01:10:08,390
eta, ondoren, me zeure non balioak jarri ahal izango dut barruan espazio txiki bat ematen dio.

1125
01:10:08,390 --> 01:10:11,980
Ondoren, berriro ere, ez dakit zer memoria honen barruan.

1126
01:10:11,980 --> 01:10:16,780
Beraz, lehenengo gauza egin behar dut egiaztatzeko sistema memoria nahikoa izan zuten ala ez

1127
01:10:16,780 --> 01:10:20,850
me itzuli zenbaki oso 1 lehenengo lekua, hau da, zergatik egiaztatu egiten ari naiz.

1128
01:10:20,850 --> 01:10:25,020
Erakuslea null bada, horrek esan nahi du ez dela nahikoa leku edo beste zenbait errorea gertatu da,

1129
01:10:25,020 --> 01:10:26,320
beraz, irten beharko nuke nire programa.

1130
01:10:26,320 --> 01:10:29,400
 Baina zuen arrakasta izanez gero, gaur egun erakuslea erabili ahal izango dut

1131
01:10:29,400 --> 01:10:35,020
eta zer * erakuslea ez da non helbidea honako hau da

1132
01:10:35,020 --> 01:10:38,480
non balio hori da, eta berdintasuna 1 ezartzen du.

1133
01:10:38,480 --> 01:10:41,850
Beraz, hemen baino gehiago izanez gero, memoria hori existitu egiaztatzen ari gara.

1134
01:10:41,850 --> 01:10:45,380
>> Badakizu badagoela eta gero, jarri dezakezu

1135
01:10:45,380 --> 01:10:50,460
zer balio jarri nahi duzun, baina kasu honetan, 1.

1136
01:10:50,460 --> 01:10:53,060
Gaude berarekin egin ondoren, erakuslea askatzea behar duzu.

1137
01:10:53,060 --> 01:10:57,160
sistema memoria Lehenik eta behin galdetu itzuli behar dugulako.

1138
01:10:57,160 --> 01:10:59,690
Ordenagailua ez delako ezagutzen ari egiten dugunean.

1139
01:10:59,690 --> 01:11:02,510
Kasu honetan esplizituki ari gara kontatzea, ados, gaude memoria horrekin egiten da.

1140
01:11:02,510 --> 01:11:10,780
Beste prozesu batzuk behar izanez gero, beste programa bat behar da, sentitzen free aurrera joan eta eraman.

1141
01:11:10,780 --> 01:11:15,110
Zer ere egin ahal izango dugu, besterik ez gaitezke multzoa aldagai lokalak helbidea.

1142
01:11:15,110 --> 01:11:19,080
Beraz, int x nagusia pilatuak markoaren barruan dago.

1143
01:11:19,080 --> 01:11:23,060
Eta ampersand hau erabiltzen dugu, eta operadorea, zer egiten da

1144
01:11:23,060 --> 01:11:27,310
x hartzen du, eta x memorian datu batzuk besterik ez da, baina helbide bat du.

1145
01:11:27,310 --> 01:11:33,790
Dago nonbait. Beraz deituz & x, zer hau ez da ematen digu x helbidea.

1146
01:11:33,790 --> 01:11:38,430
Hau eginez, erakuslea puntu egiten ari gara non x memoria da.

1147
01:11:38,430 --> 01:11:41,710
Orain ez dugu * antzeko zerbait x, gaude 5 itzuli.

1148
01:11:41,710 --> 01:11:43,820
Star deritzo dereferencing.

1149
01:11:43,820 --> 01:11:46,640
Helbidea jarraitzen duzu, eta gordetzen ez dago balioa lortuko duzu.

1150
01:11:51,000 --> 01:11:53,310
>> Edozein galdera? Bai?

1151
01:11:53,310 --> 01:11:56,500
[Student] 3-puntako gauza egin ez baduzu, ez konpilatu oraindik ere?

1152
01:11:56,500 --> 01:11:59,490
Bai. 3-erakuslea gauza egin ez baduzu, oraindik konpilatu egingo da,

1153
01:11:59,490 --> 01:12:02,720
baina erakutsi dut zer gertatzen da bigarren batean, eta hori egin gabe,

1154
01:12:02,720 --> 01:12:04,860
hori memoria leak deitzen dugun. Ez sistema ematen ari zara

1155
01:12:04,860 --> 01:12:07,850
atzera bere memoria, eta beraz, ondoren programa da pilatzen, berriz, joan

1156
01:12:07,850 --> 01:12:10,940
memoria hori ez erabiltzea, eta, kito erabili daiteke.

1157
01:12:10,940 --> 01:12:15,750
Ikusi duzun inoiz bada Firefox zure ordenagailuan kilobyteko 1,5 milioi,

1158
01:12:15,750 --> 01:12:17,840
zereginen kudeatzailea, zer ari den gertatzen.

1159
01:12:17,840 --> 01:12:20,760
Memoria leak duzu programa ez dutela manipulazioa.

1160
01:12:23,080 --> 01:12:26,240
Beraz, nola ez erakuslea aritmetika lan?

1161
01:12:26,240 --> 01:12:29,480
Beno, erakusle aritmetika indexatzeko bezalako sort da array batean.

1162
01:12:29,480 --> 01:12:36,370
Kasu honetan, erakusle bat daukat, eta zer gertatzen da, hain zuzen ere, erakuslea puntu egin dut lehenengo elementu

1163
01:12:36,370 --> 01:12:42,100
3 zenbaki osoko ditudan esleitu array hau.

1164
01:12:42,100 --> 01:12:46,670
Beraz, gaur egun egiten dudana, star erakuslea besterik ez zerrendan lehenengo elementua aldatzen da.

1165
01:12:46,670 --> 01:12:49,140
Star erakuslea +1 hemen puntu.

1166
01:12:49,140 --> 01:12:53,140
Beraz, erakuslea hemen baino gehiago da, erakuslea +1 da hemen, erakusle +2 da hemen.

1167
01:12:53,140 --> 01:12:56,610
>> Beraz, 1 gehitu array honetan zehar mugitzea gauza bera da.

1168
01:12:56,610 --> 01:12:59,880
Zer egiten dugu, hau da, helbidea, erakuslea +1 egiten dugu hemen baino gehiago,

1169
01:12:59,880 --> 01:13:04,180
eta hemen balioa lortzeko, izar bat jarri adierazpen osoa

1170
01:13:04,180 --> 01:13:05,990
dereference.

1171
01:13:05,990 --> 01:13:09,940
Beraz, kasu honetan, lehen array hau kokapena dut ezartzeko, 1

1172
01:13:09,940 --> 01:13:13,970
bigarren kokalekua, 2 eta hirugarren 3 kokapena.

1173
01:13:13,970 --> 01:13:18,180
Orduan, zer baino gehiago egiten ari naiz hemen gure erakuslea +1 inprimatzeko dut,

1174
01:13:18,180 --> 01:13:19,970
horrek ematen dit 2.

1175
01:13:19,970 --> 01:13:23,650
Orain erakuslea naiz incrementing, beraz erakuslea erakuslea +1 berdinen

1176
01:13:23,650 --> 01:13:26,780
horrek egiten du aurrera.

1177
01:13:26,780 --> 01:13:30,810
Eta beraz, gaur egun inprimatu badut +1 erakuslea da, erakuslea +1 gaur egun 3

1178
01:13:30,810 --> 01:13:33,990
kasu honetan, zein bistaratzen 3.

1179
01:13:33,990 --> 01:13:36,560
Eta ahal izateko free zerbait, erakusle ematen dut

1180
01:13:36,560 --> 01:13:40,540
array back got I malloc hasieran egon behar seinalatuz.

1181
01:13:40,540 --> 01:13:43,430
Beraz, kasu honetan, I 3 deitu hementxe, hau ez litzateke izango eskubidea,

1182
01:13:43,430 --> 01:13:45,070
array-erdian delako.

1183
01:13:45,070 --> 01:13:48,820
Kendu behar dut jatorrizko kokapena

1184
01:13:48,820 --> 01:13:50,420
Leku aurretik I askatzea hasierako lehen.

1185
01:13:56,300 --> 01:13:58,450
Beraz, hona hemen adibide bat gehiago parte hartzen da.

1186
01:13:58,450 --> 01:14:03,360
Kasu honetan, 7 karaktere array batean karaktere ari gara esleitzean.

1187
01:14:03,360 --> 01:14:06,480
>> Eta, kasu honetan, zer egiten ari garen, horietako lehenengoa 6 urtetik gorako begizta batean ari gara,

1188
01:14:06,480 --> 01:14:09,900
eta horiek ezartzen ari gara Z.

1189
01:14:09,900 --> 01:14:13,350
Beraz, int for i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Beraz, erakuslea + just egingo i eman digu, kasu honetan,

1191
01:14:16,220 --> 01:14:20,860
erakuslea, erakuslea +1, erakuslea +2, +3 erakuslea, eta, beraz, eta beraz, loop en aurrera.

1192
01:14:20,860 --> 01:14:24,040
Zer egin egingo da helbide hori lortzen, dereferences balioa lortu du,

1193
01:14:24,040 --> 01:14:27,440
eta aldaketak Z. bat balio

1194
01:14:27,440 --> 01:14:30,350
Gero, amaieran gogoratu honek kate bat da, ezta?

1195
01:14:30,350 --> 01:14:33,560
Kateak guztiak amaitutzat null izaera amaituko da.

1196
01:14:33,560 --> 01:14:38,620
Beraz, ez dut erakuslea 6 amaierako karakterea null jarri dut sartu

1197
01:14:38,620 --> 01:14:43,980
Eta orain zer, batez ere, naiz egiten hemen printf kate bat ezartzeko, ezta?

1198
01:14:43,980 --> 01:14:46,190
>> Beraz, ez printf now denean da kate baten amaiera iritsi?

1199
01:14:46,190 --> 01:14:48,230
Amaierako karakterea null hits.

1200
01:14:48,230 --> 01:14:52,030
Beraz, kasu honetan, nire jatorrizko erakuslea puntu array honen hasieran.

1201
01:14:52,030 --> 01:14:56,410
Lehen karaktere inprimatzen ditut. Bat baino gehiago eraman dut.

1202
01:14:56,410 --> 01:14:58,420
Pertsonaia bat inprimatu dut. Eraman ditut.

1203
01:14:58,420 --> 01:15:02,180
Eta hau egiten iristeko amaiera arte mantendu dut.

1204
01:15:02,180 --> 01:15:07,750
Eta orain amaiera * erakuslea dereference eta amaierako karakterea null itzuli.

1205
01:15:07,750 --> 01:15:11,780
Eta, beraz, nire bitartean begizta bidez balioa legala denean bakarrik ez dela null amaierako pertsonaia.

1206
01:15:11,780 --> 01:15:13,770
Beraz, gaur egun irten I begizta hau.

1207
01:15:18,780 --> 01:15:21,180
Eta, beraz, kendu dut 6 erakuslea honetan,

1208
01:15:21,180 --> 01:15:22,860
Atzera egin nuen hasieran.

1209
01:15:22,860 --> 01:15:27,880
Gogoan izan, hau egiten ari naiz, hasieran joan behar dut askatzea duelako.

1210
01:15:27,880 --> 01:15:30,270
>> Beraz, hori izan zen asko ezagutzen dut. Ba al dago edozein galdera?

1211
01:15:30,270 --> 01:15:31,870
Mesedez, bai?

1212
01:15:31,870 --> 01:15:36,610
[Student galdera ulertezinak]

1213
01:15:36,610 --> 01:15:38,190
Ezin esan ozenago? Sentitzen dugu.

1214
01:15:38,190 --> 01:15:44,140
[Student] diapositiba azken eskuinera erakuslea aurretik askatu On

1215
01:15:44,140 --> 01:15:47,300
non ziren erakuslearen balioa benetan duzun bezala, aldatzen?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Beraz, hementxe. >> [Student] Oh, ados.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Beraz, erakusle ken minus bat daukat, eskuinera,

1218
01:15:51,890 --> 01:15:54,140
gauza bat atzera mugitzen da, eta gero libre I

1219
01:15:54,140 --> 01:15:57,000
erakuslea honetan array-hasieratik adierazi behar duelako.

1220
01:15:57,000 --> 01:16:00,420
[Student] Baina hori ez litzateke da beharrezkoa izan gelditu line ondoren.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Beraz, nuen, gero gelditu, hori kontuan hartu beharko litzateke memoria leak,

1222
01:16:03,130 --> 01:16:04,810
nuen ez delako exekutatu free.

1223
01:16:04,810 --> 01:16:11,290
[Student] I [ulertezinak] lehen hiru lerroak non erakuslea +1 [ulertezina] izan duzu ondoren.

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh huh. Beraz, zein da galdera dago?

1225
01:16:13,140 --> 01:16:14,780
Sentitzen dugu. Ez, ez. Joan, joan, mesedez.

1226
01:16:14,780 --> 01:16:16,870
[Student] Beraz, ez duzu erakusleak balioa aldatuz.

1227
01:16:16,870 --> 01:16:19,130
Erakuslea ken ken egin duzu, ez luke izan.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Bai, zehazki.

1229
01:16:19,730 --> 01:16:21,890
Beraz, erakuslea +1 eta +2 erakuslea do I,

1230
01:16:21,890 --> 01:16:24,410
Ez dut erakuslea egiten berdinen erakuslea +1.

1231
01:16:24,410 --> 01:16:27,260
Beraz, erakusle besterik egonaldi array hasieran seinalatuz.

1232
01:16:27,260 --> 01:16:31,460
Bakarrik da plus egin behar dut plus ezartzen duen balioa erakuslea barruan back,

1233
01:16:31,460 --> 01:16:33,550
benetan dela mugitzen da hau ere.

1234
01:16:36,860 --> 01:16:37,780
Guztiak eskubidea.

1235
01:16:40,550 --> 01:16:42,030
Galdera gehiago?

1236
01:16:44,680 --> 01:16:47,790
>> Berriz ere, hau jasanezinak sort bada, saio egingo dira estali.

1237
01:16:47,790 --> 01:16:50,710
Galdetu zure irakaskuntza fellow da, eta amaieran galderak erantzun ahal izango dugu.

1238
01:16:53,510 --> 01:16:56,600
Eta, normalean, ez dugu nahi minus hori egin.

1239
01:16:56,600 --> 01:16:59,760
Mantenduz me pista zenbat array Nik konpentsatu behar du.

1240
01:16:59,760 --> 01:17:04,520
Beraz, oro har, hau da, besterik gabe, nola erakuslea aritmetika lanak azaltzeko.

1241
01:17:04,520 --> 01:17:07,970
Baina, zer egin izan ohi dugu erakuslea kopia bat sortu nahi dugu, hau da,

1242
01:17:07,970 --> 01:17:11,640
eta, ondoren, kopia hori erabili dugu inguruan mugitzen ari gara, katean.

1243
01:17:11,640 --> 01:17:14,660
Beraz, kasu hauetan kate osoa kopia inprimatu erabili nahi duzun,

1244
01:17:14,660 --> 01:17:19,040
baina ez dugu erakuslea ken 6 ez bezala edo zenbat mugitu dugu segimendua

1245
01:17:19,040 --> 01:17:22,700
besterik ez delako gure jatorrizko puntu hori oraindik zerrendaren hasieran adierazi badakigu

1246
01:17:22,700 --> 01:17:25,340
eta aldatuak dugun kopia hau izan zen.

1247
01:17:25,340 --> 01:17:28,250
Beraz, oro har aldatzeko, zure erakuslea jatorrizko kopiak.

1248
01:17:28,250 --> 01:17:32,350
Ez saiatu bezala ordenatzeko don't aldatzen jatorrizko kopia.

1249
01:17:32,350 --> 01:17:35,290
Zure jatorrizko kopiak bakarrik aldatzen saiatzen.

1250
01:17:41,540 --> 01:17:44,870
Beraz, katea pasatzen dugu printf sartu nabarituko duzu

1251
01:17:44,870 --> 01:17:48,990
ez duzu aurrean izar bat jarri genuen beste dereferences guztietan bezala, ezta?

1252
01:17:48,990 --> 01:17:54,180
Beraz, inprimatu badu kate osoa% s helbide bat espero da,

1253
01:17:54,180 --> 01:17:57,610
eta kasu honetan, erakuslea edo karaktere array bat bezala, kasu honetan.

1254
01:17:57,610 --> 01:18:00,330
>> Pertsonaiak, char * s, eta array gauza bera dira.

1255
01:18:00,330 --> 01:18:03,690
Erakuslea karakteretakoa izan behar da, eta karaktere array dira gauza bera.

1256
01:18:03,690 --> 01:18:05,720
Eta, beraz, guztiak egin behar dugu da erakuslea pasatzeko.

1257
01:18:05,720 --> 01:18:08,150
Ez dugu * erakuslea edo horrelako ezer atsegin pasatzeko.

1258
01:18:13,110 --> 01:18:14,930
Beraz, array-ak eta erakusleak, gauza bera dira.

1259
01:18:14,930 --> 01:18:19,160
Denean zerbait egiten ari zarenean x bezala array bat hemen [y],

1260
01:18:19,160 --> 01:18:21,960
kanpaia azpian egiten esaten da, ados, pertsonaia multzo bat da,

1261
01:18:21,960 --> 01:18:23,690
beraz, erakuslea da.

1262
01:18:23,690 --> 01:18:26,510
Eta, beraz, x gauza bera dira,

1263
01:18:26,510 --> 01:18:28,650
eta, beraz, zer egiten da y gehitzen du x

1264
01:18:28,650 --> 01:18:31,820
aurrera memoria askoz ere gauza bera da.

1265
01:18:31,820 --> 01:18:34,930
Eta orain, x + y helbidea ematen digu nolabaiteko

1266
01:18:34,930 --> 01:18:37,570
eta helbidea dereference edo arrow jarraitu dugu

1267
01:18:37,570 --> 01:18:41,640
non memoria kokapena dela eta balioa lortuko dugu memoria kokaleku horretara.

1268
01:18:41,640 --> 01:18:43,720
Beraz, eta, beraz, bi hauek gauza bera dira.

1269
01:18:43,720 --> 01:18:45,840
Sintaktiko azukre bat besterik ez da.

1270
01:18:45,840 --> 01:18:48,090
Gauza bera egiten dute. Bata bestearen syntactics ezberdinak dira.

1271
01:18:51,500 --> 01:18:57,590
>> Beraz, zer oker joan daiteke erakusleak? , Antzekoa da. Ongi da. Beraz, gauza txarrak.

1272
01:18:57,590 --> 01:19:02,410
Batzuk egin ahal izango duzu, gauza txarrak ez dira egiaztapena zure malloc dei itzultzen null, ezta?

1273
01:19:02,410 --> 01:19:06,560
Kasu honetan, sistema dut galdetuz niri emateko zer da zenbaki hori?

1274
01:19:06,560 --> 01:19:11,200
2 bilioi aldiz 4 bezala, zenbaki oso bat tamaina da, 4 byte delako.

1275
01:19:11,200 --> 01:19:13,810
Galdetzen dut 8 milioi byte bezala.

1276
01:19:13,810 --> 01:19:17,270
Jakina, nire ordenagailua ez da askoz memoria atzera me emateko gai izango da.

1277
01:19:17,270 --> 01:19:20,960
Eta ez genuen egiaztatu null bada, eta, beraz, saiatu dereference han -

1278
01:19:20,960 --> 01:19:24,270
jarraitu arrow non egingo - ez dugu memoria hori.

1279
01:19:24,270 --> 01:19:27,150
Hau da, zer, null erakuslea dereferencing deitzen dugu.

1280
01:19:27,150 --> 01:19:29,710
Eta hori funtsean eragiten nahi duzun segfault.

1281
01:19:29,710 --> 01:19:31,790
Segfault dezakezu modu bat da.

1282
01:19:34,090 --> 01:19:38,090
Beste gauza txarrak egin ahal izango duzu - oh ondo.

1283
01:19:38,090 --> 01:19:40,650
Horixe zen null erakuslea dereferencing. Ongi da.

1284
01:19:40,650 --> 01:19:45,160
Beste gauza txarrak - ondo konpontzen, hori bakarrik ez txeke bat jarri

1285
01:19:45,160 --> 01:19:46,980
egiaztatzen erakuslea den null

1286
01:19:46,980 --> 01:19:51,000
eta irten programaren gertatzen da malloc hori null erakuslea itzultzen bada.

1287
01:19:55,110 --> 01:19:59,850
Hori xkcd komiki. Pertsonak ulertzen da orain. Ordenatzeko.

1288
01:20:06,120 --> 01:20:09,350
>> Beraz, memoria. Eta horren gainean joan nintzen.

1289
01:20:09,350 --> 01:20:12,000
Malloc deituz begizta batean ari gara, baina denbora malloc deitzen dugun bakoitzean

1290
01:20:12,000 --> 01:20:14,370
pista galdu non erakuslea da apuntatzen ari gara,

1291
01:20:14,370 --> 01:20:15,750
ari gara delako clobbering.

1292
01:20:15,750 --> 01:20:18,410
Beraz, dei malloc hasierako ematen dit memoria baino gehiago dago hemen.

1293
01:20:18,410 --> 01:20:19,990
Nire erakuslea honen erakusle.

1294
01:20:19,990 --> 01:20:23,020
Orain, ez dut libre da, eta, beraz, gaur egun malloc deitu dut berriro.

1295
01:20:23,020 --> 01:20:26,070
Orain puntu ezazu hemen. Orain nire memoria seinalatuz hemen.

1296
01:20:26,070 --> 01:20:27,640
Baino gehiago seinalatuz hemen. Baino gehiago seinalatuz hemen.

1297
01:20:27,640 --> 01:20:31,820
Baina pista galdu dut hemen esleitu I baino gehiago memoria helbideak.

1298
01:20:31,820 --> 01:20:35,100
Eta, beraz, gaur egun ez daukat erreferentzia edozein jada.

1299
01:20:35,100 --> 01:20:37,230
Beraz, ezin dut askatzea itzazu begizta honen kanpo.

1300
01:20:37,230 --> 01:20:39,390
Eta beraz, honen antzeko zerbait konpontzeko,

1301
01:20:39,390 --> 01:20:42,250
memoria libratzeko ahaztuz gero eta memoria-leak hau lortuko duzu,

1302
01:20:42,250 --> 01:20:45,810
Memoria libratzeko begizta honen barruan zauden behin egin behar duzu.

1303
01:20:45,810 --> 01:20:51,400
Beno, hau da, zer gertatzen den. Zu asko gorroto hau ezagutzen dut.

1304
01:20:51,400 --> 01:20:55,270
Baina orain YAY! 44.000 kilobyteko bezala.

1305
01:20:55,270 --> 01:20:57,110
Beraz, libre begizta-amaieran,

1306
01:20:57,110 --> 01:20:59,770
eta hori memoria besterik ez askatzea, aldi bakoitzean.

1307
01:20:59,770 --> 01:21:03,620
Funtsean, programa ez da izan memoria leak jada.

1308
01:21:03,620 --> 01:21:08,150
>> Eta orain, beste zerbait egin dezakezu memoria batzuk libre birritan eskatu duzula.

1309
01:21:08,150 --> 01:21:11,060
Kasu honetan, zerbait malloc, bere balioa aldatzeko aukera ematen dizu.

1310
01:21:11,060 --> 01:21:13,140
Askatzea duzu behin duzulako egin ziren esan duzu.

1311
01:21:13,140 --> 01:21:14,940
Baina gero, libratuko dugu berriro.

1312
01:21:14,940 --> 01:21:16,730
Zerbait nahiko txarra da.

1313
01:21:16,730 --> 01:21:18,820
Ez da, hasieran segfault joan

1314
01:21:18,820 --> 01:21:23,350
baina ondoren zer hau ez da bikoitza corrupts hau zure zeure askatzeaz egitura, berriz,

1315
01:21:23,350 --> 01:21:27,200
ikasi eta apur bat gehiago duzu hau aukeratu duzu klase bat hartu CS61 bezala.

1316
01:21:27,200 --> 01:21:30,000
Baina, funtsean, ondoren ordenagailua nahastu ahal izateko, berriz, joan

1317
01:21:30,000 --> 01:21:33,010
oroimena kokapenak dira, non eta bertan gordeta buruz -

1318
01:21:33,010 --> 01:21:34,800
non datuak memorian gordetzen.

1319
01:21:34,800 --> 01:21:38,080
Eta horrela erakuslea uzten birritan gauza txar bat egin nahi ez duzula.

1320
01:21:38,080 --> 01:21:41,600
>> Beste gauzak gaizki joan daiteke, ez da sizeof erabiliz.

1321
01:21:41,600 --> 01:21:44,460
Beraz, kasu honetan 8 byte malloc

1322
01:21:44,460 --> 01:21:46,700
eta hori bi zenbaki osoen gauza bera da, ezta?

1323
01:21:46,700 --> 01:21:49,580
Beraz, Guztiz ziurra da, baina ez da?

1324
01:21:49,580 --> 01:21:52,160
Beno,, Lucas buruz hitz egin zuen gisa arkitekturetan ezberdinetan,

1325
01:21:52,160 --> 01:21:54,220
Osoko zenbaki luzerak desberdinak dira.

1326
01:21:54,220 --> 01:21:57,970
Beraz,-tresnak erabiltzen ari zaren, zenbaki osoen 4 buruz bytes,

1327
01:21:57,970 --> 01:22:02,370
baina beste sistema batzuk on 8 byte izango dute agian edo 16 byte dute agian.

1328
01:22:02,370 --> 01:22:05,680
Beraz, besterik ez dut erabiltzen bada, zenbaki hau hemen

1329
01:22:05,680 --> 01:22:07,310
Programa hori lan-tresnaren,

1330
01:22:07,310 --> 01:22:10,360
baina ez da nahikoa beste sistema batzuk memoria esleitu.

1331
01:22:10,360 --> 01:22:14,020
Kasu honetan, hau da, zer sizeof operadorea erabiltzen da.

1332
01:22:14,020 --> 01:22:16,880
Diegu sizeof (int), hau ez da

1333
01:22:16,880 --> 01:22:21,910
 ematen digu programa martxan dagoela sistema osokoa baten tamaina.

1334
01:22:21,910 --> 01:22:25,490
Beraz, kasu honetan, sizeof (int) 4 itzuliko da aparatuaren antzeko zerbait,

1335
01:22:25,490 --> 01:22:29,980
eta, gaur egun, hau borondate 4 * 2, hau da, 8,

1336
01:22:29,980 --> 01:22:32,330
besterik ez da, bi zenbaki osoen beharrezko espazioa zenbatekoa.

1337
01:22:32,330 --> 01:22:36,710
Beste sistema bat, int 16 byte edo 8 byte bezala bada,

1338
01:22:36,710 --> 01:22:39,380
besterik ez da nahikoa byte itzuli kopuru hori gordetzeko.

1339
01:22:41,830 --> 01:22:45,310
>> Eta, azkenik, structs.

1340
01:22:45,310 --> 01:22:48,340
Beraz, nahi izanez gero, sudoku-taula bat gordetzeko memoria, nola liteke hau egiten dugu?

1341
01:22:48,340 --> 01:22:51,570
Uste duzu Lehenik eta behin, aldagai bat bezala,

1342
01:22:51,570 --> 01:22:53,820
bigarren gauza aldagaia, aldagai bat hirugarren gauza,

1343
01:22:53,820 --> 01:22:56,420
dago gaizki, ezta gauza laugarren aldagai bat?

1344
01:22:56,420 --> 01:23:00,750
Beraz, hobekuntza bat honen gainean egin dezakezu 9 x 9 array egiteko.

1345
01:23:00,750 --> 01:23:04,480
Hori da fina, baina zer bada beste gauza batzuk asoziatu nahi duzun sudoku taula

1346
01:23:04,480 --> 01:23:06,490
nahi zer taula zailtasuna da,

1347
01:23:06,490 --> 01:23:11,740
edo, esate baterako, zein den zure puntuazioa, edo zenbat denbora taula hau konpontzeko neurriak hartu behar duzu?

1348
01:23:11,740 --> 01:23:14,970
Beno, zer egin dezakezu, eta egitura bat sor dezakezu.

1349
01:23:14,970 --> 01:23:18,910
Zer da, funtsean, esaten dut egitura definitzen dut hemen,

1350
01:23:18,910 --> 01:23:23,230
eta sudoku-taula duen taula bat da, 9 x 9 osatzen dute dut definituz.

1351
01:23:23,230 --> 01:23:26,650
>> Eta zer maila izena erakusleak du.

1352
01:23:26,650 --> 01:23:30,730
Horrez gain, x eta y,, non oraintxe nago koordenatuak diren.

1353
01:23:30,730 --> 01:23:35,980
Horrez gain, denbora [ulertezina], eta mugitzen da sartu dut, orain arte, guztira du.

1354
01:23:35,980 --> 01:23:40,010
Eta, beraz, kasu honetan, datu-sorta osoa multzokatzea ahal izango dut bakar bat egitura

1355
01:23:40,010 --> 01:23:42,790
izatea, aldagai desberdinen inguruan hegan bezala atsegin ordez

1356
01:23:42,790 --> 01:23:44,540
ez dut benetan mantentzeko pista.

1357
01:23:44,540 --> 01:23:49,720
Eta hau aukera ematen dizu, eta egitura honen barruan gauza ezberdinak erreferentziatutako sort sintaxia nice dute gurekin.

1358
01:23:49,720 --> 01:23:53,430
Besterik ez dut egin ahal izango board.board, eta sudoku-taula lortu dut.

1359
01:23:53,430 --> 01:23:56,320
Board.level, nola gogorra da.

1360
01:23:56,320 --> 01:24:00,540
Board.x eta board.y eman dit, non taula izan liteke I koordenatuak.

1361
01:24:00,540 --> 01:24:04,730
Eta beraz, zer deitzen dugun egiturari, eremu naiz sartzen.

1362
01:24:04,730 --> 01:24:08,840
Hau sudokuBoard que tengo mota bat da, eta horrek definitzen du.

1363
01:24:08,840 --> 01:24:14,800
Eta orain hemen gaude. "Taula" mota sudokuBoard izeneko aldagai bat daukat.

1364
01:24:14,800 --> 01:24:18,820
Eta horrela, gaur egun osatzen duten egitura hau hemen eremu guztiak sartu ahal izango dut.

1365
01:24:20,830 --> 01:24:22,450
>> Structs buruzko edozein galdera? Bai?

1366
01:24:22,450 --> 01:24:25,890
[Student] int x, y, bai deklaratu lerro bat? >> [Joseph] Uh huh.

1367
01:24:25,890 --> 01:24:27,400
[Student] Beraz, ezin do besterik ez duzu hori horiek guztiak?

1368
01:24:27,400 --> 01:24:31,200
X bezala, y koma aldiz guztira dela?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Bai, zalantzarik izan duzu hori egin, baina arrazoia x eta y lerro berean jarri dut -

1370
01:24:34,460 --> 01:24:36,330
eta galdera da zergatik egin dezaket besterik ez dugu lerro berean?

1371
01:24:36,330 --> 01:24:38,600
Zergatik ez jarri besterik ez dugu horiek guztiak lerro berean

1372
01:24:38,600 --> 01:24:42,090
x eta y dira elkarren artean lotutako

1373
01:24:42,090 --> 01:24:44,780
eta hau besterik ez da estilistikoki zuzena, neurri batean,

1374
01:24:44,780 --> 01:24:46,600
bi gauza delako lerro berean taldekatzea

1375
01:24:46,600 --> 01:24:49,340
horrela sort gauza bera dira.

1376
01:24:49,340 --> 01:24:51,440
Eta zatitu besterik ez dut horiek alde batera utzita. Style gauza bat besterik ez da.

1377
01:24:51,440 --> 01:24:53,720
Diferentzia inolako egiten funtzionalki.

1378
01:24:58,150 --> 01:24:59,270
Structs buruzko galderak beste edozein?

1379
01:25:03,030 --> 01:25:06,620
Bat defini dezakete Pokédex duzu eta egitura batekin.

1380
01:25:06,620 --> 01:25:11,720
Pokemon A zenbaki bat du eta gutun bat, jabea, mota bat du.

1381
01:25:11,720 --> 01:25:16,990
Eta gero Pokemon array bat izanez gero duzu, osatzen dezakezu Pokédex bat, ezta?

1382
01:25:16,990 --> 01:25:20,810
Ados, cool. Beraz, buruzko galderak structs. Hauek dira structs lotutako.

1383
01:25:20,810 --> 01:25:25,270
>> Azkenik, GDB. Zer esan nahi du GDB utzi egin nahi duzu? Zure programa arazteko aukera ematen du.

1384
01:25:25,270 --> 01:25:27,650
Eta ez baduzu erabiltzen GDB, gomendatzen nuke labur begira

1385
01:25:27,650 --> 01:25:31,250
eta besterik ez zer GDB da, nola lan egiten duten, nola erabil dezakezu,

1386
01:25:31,250 --> 01:25:32,900
eta probatzeko programa bat.

1387
01:25:32,900 --> 01:25:37,400
Eta beraz, zer GDB aukera ematen dizu do eteteko [ulertezina] sortu zure programaren bidez

1388
01:25:37,400 --> 01:25:38,920
eta praktikoak line.

1389
01:25:38,920 --> 01:25:42,600
Esate baterako, nahi pausatu exekuzioa dut nire programaren 3. Line atsegin at

1390
01:25:42,600 --> 01:25:46,010
eta linea 3 naiz inprimatu balioak daude guztiak.

1391
01:25:46,010 --> 01:25:49,710
Eta beraz, zer deitzen dugun lerro bat bezala gelditzea

1392
01:25:49,710 --> 01:25:52,350
etendura-puntua jarriz lerro hartan deitzen dugun

1393
01:25:52,350 --> 01:25:55,920
eta, ondoren, inprimatu ahal izango dugu programaren egoera aldagai garai hartan.

1394
01:25:55,920 --> 01:25:58,990
>> Ezin dugu, orduan programaren lerro-lerro zehar.

1395
01:25:58,990 --> 01:26:03,200
Eta gero, pilaren egoera garai hartan ikusi ahal izango dugu.

1396
01:26:03,200 --> 01:26:08,600
Eta beraz, GDB, zer egiten dugun clang deitzen dugun C fitxategia erabili ahal izateko,

1397
01:26:08,600 --> 01:26:11,290
baina pasa-ggdb Ez dugu.

1398
01:26:11,290 --> 01:26:15,850
Eta behin gaude egin duten gdb exekutatu besterik ez dugu Emaitzeko fitxategia irteera.

1399
01:26:15,850 --> 01:26:18,810
Eta, beraz, testu-masa atsegin batzuk lortuko duzu hau atsegin dute,

1400
01:26:18,810 --> 01:26:21,990
baina benetan egin behar duzula komandoak idatzi hasieran.

1401
01:26:21,990 --> 01:26:24,250
Break nagusia etendura jartzen nagusia.

1402
01:26:24,250 --> 01:26:28,470
Zerrenda 400 kode lerro zerrendatzen line 400 inguru.

1403
01:26:28,470 --> 01:26:31,410
Eta, beraz, kasu honetan dezakezu begiratu eta esan, oh,

1404
01:26:31,410 --> 01:26:34,360
Line 397 etendura-puntua, lerro hau ezarri nahi dut,

1405
01:26:34,360 --> 01:26:37,170
eta, ondoren, zure programa Urrats horretan doa eta hondatu.

1406
01:26:37,170 --> 01:26:41,120
Eteteko han da, eta inprimatu dezakezu, adibidez,, baxua edo goi balioa.

1407
01:26:41,120 --> 01:26:46,410
Eta, beraz, jakin behar duzun komando sorta bat daude,

1408
01:26:46,410 --> 01:26:48,660
eta slideshow hau igo dira web orrian,

1409
01:26:48,660 --> 01:26:54,000
hala bada nahi besterik ez duzu hauek erreferentzia edo like jarri zure orriak Cheat, sentitzen free.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Hori Quiz Review 0 izan zen, eta makila inguruan dugu, edozein zalantza izanez gero.

1411
01:27:00,650 --> 01:27:03,850
Guztiak eskubidea.

1412
01:27:03,850 --> 01:27:09,030
>>  [Txalo]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]