1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Avsnitt 3] [mindre bekväm]

2
00:00:03,000 --> 00:00:05,000
>> [Nate Hardison] [Harvard University]

3
00:00:05,000 --> 00:00:08,000
>> [Detta är CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Okej, låt oss komma igång.

5
00:00:10,000 --> 00:00:13,000
Välkommen till vecka 4 av CS50.

6
00:00:13,000 --> 00:00:19,000
Om ni öppnar en webbläsare och öppna upp pset 3,

7
00:00:19,000 --> 00:00:23,000
Scramble med CS50, kommer vi att börja gå

8
00:00:23,000 --> 00:00:26,000
genom den del av frågorna där.

9
00:00:26,000 --> 00:00:32,000
Precis som förra veckan, kommer vi att arbeta i CS50 utrymmen,

10
00:00:32,000 --> 00:00:35,000
Om du också dra upp det också,

11
00:00:35,000 --> 00:00:43,000
och om du gå vidare och besöka denna länk som jag har här uppe i toppen.

12
00:00:43,000 --> 00:00:45,000
Det är dags att komma igång.

13
00:00:45,000 --> 00:00:51,000
Vi har vår lilla hi programmet här. Inget galen.

14
00:00:51,000 --> 00:00:55,000
En av de första saker jag vill göra med er idag är att gå över några lösningar

15
00:00:55,000 --> 00:00:58,000
till problem Set 1, typ av exempelvis lösningar,

16
00:00:58,000 --> 00:01:03,000
bara så du kan få en känsla för vilka typer av kod personal skriver,

17
00:01:03,000 --> 00:01:07,000
vilka typer av kod andra elever skriver,

18
00:01:07,000 --> 00:01:10,000
och har du ta en titt på det eftersom jag vet att det är konstigt

19
00:01:10,000 --> 00:01:14,000
när du skickar en lösning på ett problem set och få kommentarer

20
00:01:14,000 --> 00:01:18,000
på din egen version, men ibland är det bra att se hur andra människor gjorde det,

21
00:01:18,000 --> 00:01:22,000
särskilt de som är snygg.

22
00:01:22,000 --> 00:01:27,000
För det mesta, jag var verkligen imponerad av de lösningar som ni producerat.

23
00:01:27,000 --> 00:01:31,000
Jag har ännu inte börjat titta på dina 2s problembild, men om de är något liknande den första,

24
00:01:31,000 --> 00:01:34,000
det betyder ingenting annat än bra saker.

25
00:01:34,000 --> 00:01:40,000
>> Om du tittar på mina ändringar, låt oss börja hela vägen ner på Revision 1,

26
00:01:40,000 --> 00:01:47,000
och vi kommer att ta en snabb titt på en Mario-lösning.

27
00:01:47,000 --> 00:01:54,000
Om du drar upp detta, dessa program som vi kommer att presentera är korrekta.

28
00:01:54,000 --> 00:01:56,000
Det var inte korrekthet problem med dessa problem, utan snarare,

29
00:01:56,000 --> 00:01:59,000
Vi vill tala lite om de olika utformning frågor

30
00:01:59,000 --> 00:02:03,000
som används här.

31
00:02:03,000 --> 00:02:08,000
En av de saker som var intressant om lösningen

32
00:02:08,000 --> 00:02:11,000
är att det använde denna nya konstruktion som kallas pund definiera,

33
00:02:11,000 --> 00:02:15,000
ibland även kallad en hash definierar.

34
00:02:15,000 --> 00:02:18,000
Låt mig zooma in på det här.

35
00:02:18,000 --> 00:02:24,000
En # define kan du ge namn till dessa nummer i ditt program.

36
00:02:24,000 --> 00:02:28,000
I detta fall, den maximala höjden av en pyramid i Mario

37
00:02:28,000 --> 00:02:34,000
var 23 och i stället sätta 23 i min kod-

38
00:02:34,000 --> 00:02:37,000
Vi hänvisar till den så hårt kodning 23 -

39
00:02:37,000 --> 00:02:43,000
istället detta ger namnet MAX_HEIGHT till det numret,

40
00:02:43,000 --> 00:02:48,000
så att här nere i min do-while-slinga

41
00:02:48,000 --> 00:02:51,000
kan du faktiskt hänvisa till MAX_HEIGHT

42
00:02:51,000 --> 00:02:55,000
istället för att sätta numret 23 tum

43
00:02:55,000 --> 00:02:57,000
[Student] Vad är fördelen med att göra det?

44
00:02:57,000 --> 00:02:59,000
Det är en stor fråga.

45
00:02:59,000 --> 00:03:03,000
En är läsbarheten.

46
00:03:03,000 --> 00:03:08,000
En fördel med att använda denna # define är läsbarheten.

47
00:03:08,000 --> 00:03:11,000
När jag läser denna kod kan jag se vad som händer.

48
00:03:11,000 --> 00:03:15,000
>> Jag kan se i detta tillstånd här att vi testar

49
00:03:15,000 --> 00:03:19,000
för höjden är <0, vilket vi kunde också ha definierat

50
00:03:19,000 --> 00:03:22,000
att vara en minsta höjd eller en höjd min.

51
00:03:22,000 --> 00:03:25,000
Den andra fördelen är att jag sedan kan läsa resten av raden för att se

52
00:03:25,000 --> 00:03:30,000
att vi också kontrollera att se till att höjden inte är större än max höjd,

53
00:03:30,000 --> 00:03:35,000
eftersom vi kommer att fortsätta medan höjden är större än max höjd.

54
00:03:35,000 --> 00:03:40,000
Den andra fördelen är-om jag zoomar ut lite här-

55
00:03:40,000 --> 00:03:49,000
Om jag kör det här programmet och jag kör den, säga med 23 just nu,

56
00:03:49,000 --> 00:03:52,000
Det kommer att skriva ut alla 23 rader precis som det.

57
00:03:52,000 --> 00:03:54,000
Men att jag ville ändra max höjd,

58
00:03:54,000 --> 00:03:57,000
och nu vill jag att begränsa den maximala höjden av pyramiderna

59
00:03:57,000 --> 00:04:06,000
att vara bara säga-man, som var funky.

60
00:04:06,000 --> 00:04:14,000
# Include <stdio.h>, # define MAX_HEIGHT,

61
00:04:14,000 --> 00:04:18,000
och låt oss säga att vi ville ställa in den lika med 10.

62
00:04:18,000 --> 00:04:22,000
Nu vid denna tidpunkt, var allt jag hade att göra ändra det i detta en plats.

63
00:04:22,000 --> 00:04:27,000
Jag kan kompilera koden och nu om jag försöker och skriva in 12,

64
00:04:27,000 --> 00:04:30,000
Det kommer att fråga mig igen.

65
00:04:30,000 --> 00:04:33,000
I det här fallet använder vi bara MAX_HEIGHT gång.

66
00:04:33,000 --> 00:04:37,000
Det är inte så stor av ett besvär att gå i

67
00:04:37,000 --> 00:04:40,000
och ändra det i while-slingan om du behöver.

68
00:04:40,000 --> 00:04:44,000
Men i program där du refererar till samma magiska nummer

69
00:04:44,000 --> 00:04:47,000
om och om igen, det # define mekanism är verkligen praktiskt

70
00:04:47,000 --> 00:04:52,000
eftersom du byter bara det en gång högst upp i filen, det är oftast där du placerar dem-

71
00:04:52,000 --> 00:04:57,000
och förändringen perkolerar genom resten av filen.

72
00:04:57,000 --> 00:05:02,000
>> Andra saker som jag ville att notera i detta uppdrag som jag tyckte såg riktigt nice,

73
00:05:02,000 --> 00:05:05,000
en var namngivning av variabler.

74
00:05:05,000 --> 00:05:14,000
Du ser här att vi har heltalsvariabler kallas rad och kallas höjd.

75
00:05:14,000 --> 00:05:20,000
Utrymmen, hashar, hjälper det att göra koden lite mer lättläst,

76
00:05:20,000 --> 00:05:25,000
gör det lite mer förståeligt vad som faktiskt händer.

77
00:05:25,000 --> 00:05:31,000
Detta är i motsats till användning säga, slumpmässiga bokstäver

78
00:05:31,000 --> 00:05:35,000
eller bara rappakalja helt.

79
00:05:35,000 --> 00:05:39,000
En sista sak jag påpeka är att i för slingor,

80
00:05:39,000 --> 00:05:45,000
ofta dessa iterator variabler, dessa räknare som du använder i din för loopar,

81
00:05:45,000 --> 00:05:51,000
Det är standard och konventionellt att starta dem med antingen i och sedan j och sedan k

82
00:05:51,000 --> 00:05:54,000
och går vidare därifrån om du behöver fler variabler,

83
00:05:54,000 --> 00:05:56,000
och detta är bara en konvention.

84
00:05:56,000 --> 00:05:58,000
Det finns massor av konventioner.

85
00:05:58,000 --> 00:06:00,000
Det beror på programmeringsspråket du använder.

86
00:06:00,000 --> 00:06:04,000
Men i C börjar vi oftast med jag.

87
00:06:04,000 --> 00:06:08,000
Det är inte meningsfullt att använda, säger a eller b

88
00:06:08,000 --> 00:06:13,000
beroende på situationen.

89
00:06:13,000 --> 00:06:15,000
Det var allt för den här.

90
00:06:15,000 --> 00:06:25,000
Om du nu dra upp Revision 2, kommer du att se en annan Mario,

91
00:06:25,000 --> 00:06:29,000
och detta är liknar den andra en som vi just såg,

92
00:06:29,000 --> 00:06:32,000
men det gör något slags cool.

93
00:06:32,000 --> 00:06:38,000
Om vi ​​tittar på det här avsnittet här innanför inre for-slingan,

94
00:06:38,000 --> 00:06:44,000
de använder några galna ser syntaxen här rätt i denna linje.

95
00:06:44,000 --> 00:06:47,000
Detta kallas en ternär operatör.

96
00:06:47,000 --> 00:06:53,000
Det är en om annat uttalande kondenseras till en rad.

97
00:06:53,000 --> 00:06:57,000
Villkoret är denna del inom parentes.

98
00:06:57,000 --> 00:07:05,000
Det är detsamma som att säga om j <höjd - i - 1.

99
00:07:05,000 --> 00:07:10,000
Och vad innehållet i den, om blocket skulle är utrymmet

100
00:07:10,000 --> 00:07:16,000
och sedan innehållet i vad annat skulle vara är det #.

101
00:07:16,000 --> 00:07:20,000
Det är i huvudsak tilldela ett utrymme för denna variabel.

102
00:07:20,000 --> 00:07:24,000
Det sätta ett utrymme i innehållet i blocket variabeln,

103
00:07:24,000 --> 00:07:29,000
om detta villkor är uppfyllt, och om villkoret inte är uppfyllt,

104
00:07:29,000 --> 00:07:32,000
då blocket variabeln blir detta #.

105
00:07:32,000 --> 00:07:37,000
Och sedan, naturligtvis, i stället för att bygga upp en hel sträng

106
00:07:37,000 --> 00:07:43,000
och skriva ut allt i slutet denna lösning skriver ut ett tecken i taget.

107
00:07:43,000 --> 00:07:48,000
Ganska coolt.

108
00:07:48,000 --> 00:07:53,000
>> Ytterligare ett par saker att titta på. Vi ska gå vidare till giriga.

109
00:07:53,000 --> 00:07:58,000
Nu om vi ser på giriga, denna första lösning

110
00:07:58,000 --> 00:08:00,000
använder dessa # definierar en hel del.

111
00:08:00,000 --> 00:08:06,000
Vi har en ständig definieras för varje av de olika numren i detta program.

112
00:08:06,000 --> 00:08:12,000
Vi har en för cent per dollar, en för kvartal, Dimes, Nickels och pennies,

113
00:08:12,000 --> 00:08:15,000
och nu när vi bläddra ner och läsa koden,

114
00:08:15,000 --> 00:08:22,000
Vi kan se en vanlig gör-medan allt slinga utskrift.

115
00:08:22,000 --> 00:08:25,000
Typ av springande punkten i problemet var att inse att

116
00:08:25,000 --> 00:08:29,000
du behövs för att omvandla flottören som du läser in från användaren till ett heltal

117
00:08:29,000 --> 00:08:32,000
att exakt gör matten, och detta beror på

118
00:08:32,000 --> 00:08:36,000
med flyttal, som vi talade om i föreläsning kort,

119
00:08:36,000 --> 00:08:41,000
det är inte möjligt att exakt representera varje enskilt värde på tallinjen

120
00:08:41,000 --> 00:08:47,000
eftersom det finns oändligt många värden mellan 3 och, säg, 3,1 tom.

121
00:08:47,000 --> 00:08:54,000
Du kan ha 3,01 och 3,001 och 3,0001, och du kan fortsätta.

122
00:08:54,000 --> 00:09:00,000
Det visar sig när du arbetar med pengar, vill du ofta konvertera den

123
00:09:00,000 --> 00:09:05,000
till heltal format så att du inte förlorar pennies och sånt.

124
00:09:05,000 --> 00:09:09,000
Göra det och avrundning var nyckeln.

125
00:09:09,000 --> 00:09:14,000
Denna lösning användes en perfekt enkel, stor algoritm,

126
00:09:14,000 --> 00:09:17,000
som minskas antalet cent kvar, först av kvartal,

127
00:09:17,000 --> 00:09:19,000
därefter av Dimes, sedan Nickels, sedan pennies,

128
00:09:19,000 --> 00:09:24,000
och lägga till antalet mynt varje gång.

129
00:09:24,000 --> 00:09:31,000
>> En annan lösning som vi får se, som jag zooma ut och gå till revision 4,

130
00:09:31,000 --> 00:09:40,000
hade en mycket likartad början utan används div och mod

131
00:09:40,000 --> 00:09:44,000
här borta för att beräkna antal cent.

132
00:09:44,000 --> 00:09:50,000
Detta är antalet kvartal som motsvarar det antal cent dividerat med 25,

133
00:09:50,000 --> 00:09:53,000
och anledningen detta fungerar är att vi gör heltalsdivision,

134
00:09:53,000 --> 00:09:58,000
så det är kasta överblivet.

135
00:09:58,000 --> 00:10:02,000
[Student] Har vi för att kommentera sökningen?

136
00:10:02,000 --> 00:10:05,000
Det beror egentligen.

137
00:10:05,000 --> 00:10:08,000
[Student] Du kommenterar mer än kod här.

138
00:10:08,000 --> 00:10:16,000
Ja, och så finns det ett gäng olika filosofier om detta.

139
00:10:16,000 --> 00:10:21,000
Min personliga filosofi är att din kod verkligen är sanningen,

140
00:10:21,000 --> 00:10:24,000
som din kod är det som faktiskt är köra på datorn,

141
00:10:24,000 --> 00:10:29,000
och så din kod bör vara så lättläst som möjligt för att inte kräva så många kommentarer.

142
00:10:29,000 --> 00:10:33,000
Som sagt, när du gör saker som är typ av svårt matematiskt

143
00:10:33,000 --> 00:10:38,000
eller algoritmiskt, är det bra att kommentera dem så att du kan

144
00:10:38,000 --> 00:10:43,000
lägga till en extra dimension, ett extra lager till den som läser din kod.

145
00:10:43,000 --> 00:10:49,000
I dessa lösningar, ofta de kommenteras hårdare bara för

146
00:10:49,000 --> 00:10:52,000
vi vill kunna distribuera dem och har folk plocka upp dem

147
00:10:52,000 --> 00:10:56,000
och läsa dem ganska enkelt.

148
00:10:56,000 --> 00:11:05,000
Men definitivt skulle jag håller med om att det är tungt.

149
00:11:05,000 --> 00:11:07,000
[Student] Men när du är osäker, gå tyngre?

150
00:11:07,000 --> 00:11:10,000
När du är osäker, gå tyngre.

151
00:11:10,000 --> 00:11:17,000
Vissa människor kommer ibland att säga avkastning 0 eller något liknande.

152
00:11:17,000 --> 00:11:20,000
Jag tror att det är en löjlig kommentar.

153
00:11:20,000 --> 00:11:22,000
Klart det är vad som händer.

154
00:11:22,000 --> 00:11:25,000
Jag behöver inte engelska berätta det.

155
00:11:25,000 --> 00:11:28,000
Ibland människor skriver saker som "kthxbai!"

156
00:11:28,000 --> 00:11:32,000
Det är typ av söt men också inte-

157
00:11:32,000 --> 00:11:35,000
som inte är att skillnaden mellan kommentera punkter eller inte.

158
00:11:35,000 --> 00:11:41,000
Dessa typer av kommentarer är bara ha, ha.

159
00:11:41,000 --> 00:11:43,000
Cool.

160
00:11:43,000 --> 00:11:48,000
>> Vid denna punkt, låt oss börja arbeta på problemet Set 3 avsnitt av frågor.

161
00:11:48,000 --> 00:11:52,000
Om ni drar upp detta igen,

162
00:11:52,000 --> 00:11:55,000
som med förra veckan, vi kommer inte att titta på shortsen i detta avsnitt.

163
00:11:55,000 --> 00:12:00,000
Vi låter er göra det på din egen tid och prata om frågorna.

164
00:12:00,000 --> 00:12:05,000
Men nu i det här avsnittet ska vi spendera lite mer tid

165
00:12:05,000 --> 00:12:11,000
talar om mindre av de kodande grunderna

166
00:12:11,000 --> 00:12:15,000
som vi gjorde i förra veckan, och i stället kommer vi att fokusera mer på

167
00:12:15,000 --> 00:12:22,000
lite mer av teorin, så tala om binärsökning och sedan sortering.

168
00:12:22,000 --> 00:12:27,000
Från de av er som har följt tillsammans med föreläsningen,

169
00:12:27,000 --> 00:12:30,000
kan någon ge mig en resumé av vad skillnaden är

170
00:12:30,000 --> 00:12:35,000
mellan binär sökning och linjär sökning?

171
00:12:35,000 --> 00:12:37,000
Vad händer? Visst.

172
00:12:37,000 --> 00:12:42,000
Linjär sökning söker igenom alla element i den sorterade listan

173
00:12:42,000 --> 00:12:45,000
en efter en efter en efter en efter en,

174
00:12:45,000 --> 00:12:50,000
och binär sökning delar listan i 2 grupper,

175
00:12:50,000 --> 00:12:57,000
kontrollerar om tangenterna värde som du söker efter är större eller mindre än mittpunkten värdet

176
00:12:57,000 --> 00:13:00,000
att du hittade bara, och om det är mindre än, går det med den lägre listan

177
00:13:00,000 --> 00:13:03,000
och sedan delar det igen, gör samma funktion

178
00:13:03,000 --> 00:13:07,000
ända tills den finner mittpunkten att vara lika med själva värdet.

179
00:13:07,000 --> 00:13:10,000
Rätt.

180
00:13:10,000 --> 00:13:12,000
>> Varför bryr vi?

181
00:13:12,000 --> 00:13:20,000
Varför talar vi om binärsökning kontra linjär sökning?

182
00:13:20,000 --> 00:13:22,000
Ja.

183
00:13:22,000 --> 00:13:24,000
Binary är mycket snabbare, så om du fördubblar storleken på problemet

184
00:13:24,000 --> 00:13:27,000
det tar ett steg snarare än dubbelt så många.

185
00:13:27,000 --> 00:13:29,000
Exakt.

186
00:13:29,000 --> 00:13:31,000
Det är ett bra svar.

187
00:13:31,000 --> 00:13:36,000
Linjär sökning är mycket kontrollerar ett element i taget,

188
00:13:36,000 --> 00:13:39,000
och som vi såg på den allra första dagen av föreläsning

189
00:13:39,000 --> 00:13:42,000
När David gick igenom hans telefonbok exempel

190
00:13:42,000 --> 00:13:45,000
och slet ut en sida i telefonboken på en gång

191
00:13:45,000 --> 00:13:47,000
och hålls gör det om och om och om igen,

192
00:13:47,000 --> 00:13:51,000
det kommer att ta honom en riktigt lång tid att hitta någon i telefonboken,

193
00:13:51,000 --> 00:13:55,000
Om inte, naturligtvis, han sökte någon i början av alfabetet.

194
00:13:55,000 --> 00:14:00,000
Med binär sökning kan du gå mycket snabbare,

195
00:14:00,000 --> 00:14:05,000
och det är inte bara dubbelt så fort eller 3 gånger så snabb eller 4 gånger så snabbt.

196
00:14:05,000 --> 00:14:13,000
Men problemet blir mindre och mindre och mindre mycket snabbare.

197
00:14:13,000 --> 00:14:17,000
För att illustrera detta kommer vi börja prata om vad som händer

198
00:14:17,000 --> 00:14:21,000
när vi skriver binär sökning.

199
00:14:21,000 --> 00:14:27,000
Problemet till hands är att om jag har en rad siffror,

200
00:14:27,000 --> 00:14:40,000
säga, 1, 2, 3, 5, 7, 23, 45, 78, 12.323,

201
00:14:40,000 --> 00:14:47,000
och därefter 9 med en ton av 0s efter det,

202
00:14:47,000 --> 00:14:52,000
Vi vill kunna räkna ut riktigt snabbt vad som finns i

203
00:14:52,000 --> 00:14:57,000
denna matris med tal.

204
00:14:57,000 --> 00:15:00,000
Jag vet att det verkar lite fånigt och lite krystat,

205
00:15:00,000 --> 00:15:02,000
eftersom just nu är det.

206
00:15:02,000 --> 00:15:05,000
Vi har en matris som inte har många element i den,

207
00:15:05,000 --> 00:15:08,000
och om jag frågar en av er att ta reda på huruvida

208
00:15:08,000 --> 00:15:11,000
23 är i arrayen, kan du göra det ganska snabbt

209
00:15:11,000 --> 00:15:16,000
bara genom att kasta en blick på detta och säger ja eller nej.

210
00:15:16,000 --> 00:15:20,000
Den analoga att tänka på är tänk om det var, säg,

211
00:15:20,000 --> 00:15:27,000
ett Excel-kalkylblad med 10.000 rader, 20.000 rader.

212
00:15:27,000 --> 00:15:31,000
Naturligtvis kan du göra kommandot F eller kontroll F och leta upp något.

213
00:15:31,000 --> 00:15:33,000
Du kan också använda filter och sökandet grejer,

214
00:15:33,000 --> 00:15:37,000
men om du var tvungen att titta igenom den filen rad för rad för rad,

215
00:15:37,000 --> 00:15:40,000
det skulle ta dig lång tid att hitta den.

216
00:15:40,000 --> 00:15:42,000
Det är ungefär som i telefonboken exempel också, där

217
00:15:42,000 --> 00:15:44,000
ingen tittar genom en telefonbok en sida i taget.

218
00:15:44,000 --> 00:15:47,000
Vanligtvis, öppna de det till mitten,

219
00:15:47,000 --> 00:15:50,000
eller i fallet med en massa telefonböcker och lexikon där

220
00:15:50,000 --> 00:15:54,000
du faktiskt har det knappat på den första bokstaven,

221
00:15:54,000 --> 00:16:01,000
du vända till det första bokstaven och öppna och börja gå igenom det.

222
00:16:01,000 --> 00:16:03,000
>> Påminn mig om ditt namn igen. >> Sam.

223
00:16:03,000 --> 00:16:05,000
Sam.

224
00:16:05,000 --> 00:16:11,000
Som Sam sa, är att linjär sökprocess kommer att bli riktigt långsam,

225
00:16:11,000 --> 00:16:15,000
och i stället med binär sökning, är hur det fungerar att

226
00:16:15,000 --> 00:16:21,000
varje gång vi går igenom en iteration av vår sökning algoritm,

227
00:16:21,000 --> 00:16:27,000
vi kommer att dela upp listan i halv huvudsak

228
00:16:27,000 --> 00:16:33,000
i två mindre listor.

229
00:16:33,000 --> 00:16:39,000
Och sedan på nästa iteration i slingan, vi dela upp det igen

230
00:16:39,000 --> 00:16:44,000
i andra mindre listor.

231
00:16:44,000 --> 00:16:48,000
Som ni kan se, håller problem att få mindre och mindre

232
00:16:48,000 --> 00:16:55,000
eftersom vi håller kasta hälften av listan varje gång.

233
00:16:55,000 --> 00:16:59,000
Hur fungerar kasta arbete?

234
00:16:59,000 --> 00:17:05,000
Precis som en påminnelse, vad vi ska göra om vi var en dator

235
00:17:05,000 --> 00:17:11,000
och vi var, säg, söka efter nummer 5 i den här listan

236
00:17:11,000 --> 00:17:15,000
är att vi skulle plocka ett nummer i mitten.

237
00:17:15,000 --> 00:17:26,000
I mitten av denna lista, eftersom det finns 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 siffror,

238
00:17:26,000 --> 00:17:32,000
vi skulle plocka numret antingen vid 4: e eller 5: e positionen,

239
00:17:32,000 --> 00:17:38,000
och vi skulle kalla det i mitten av vår lista.

240
00:17:38,000 --> 00:17:42,000
Välj antal i mitten.

241
00:17:42,000 --> 00:17:51,000
Sedan, precis som Sam sa, vi testar för att se om detta antal är lika

242
00:17:51,000 --> 00:17:59,000
till det nummer vi vill få eller vår önskat nummer.

243
00:17:59,000 --> 00:18:06,000
Om det är lika, då vi har hittat den. Vi vinner.

244
00:18:06,000 --> 00:18:12,000
Om det inte är lika, så finns det ett par fall.

245
00:18:12,000 --> 00:18:15,000
De två fallen är antingen antalet måste vara större än antalet som vi tittar på,

246
00:18:15,000 --> 00:18:19,000
eller det är mindre än.

247
00:18:19,000 --> 00:18:25,000
Om det är större, flyttar vi till höger.

248
00:18:25,000 --> 00:18:33,000
Och om det är mindre går vi till vänster.

249
00:18:33,000 --> 00:18:41,000
Och vi upprepa hela processen igen

250
00:18:41,000 --> 00:18:48,000
på antingen den högra halvan eller den vänstra halvan av listan.

251
00:18:48,000 --> 00:18:51,000
>> Det första problemet i dagens avsnitt är att räkna ut

252
00:18:51,000 --> 00:18:55,000
hur vi kan faktiskt börja att uttrycka detta i C-kod.

253
00:18:55,000 --> 00:18:58,000
Vi har fått pseudokoden här.

254
00:18:58,000 --> 00:19:04,000
Vad vi börja göra är jag dra upp en helt ny plats,

255
00:19:04,000 --> 00:19:09,000
Spara denna översyn så att vi har dessa anteckningar för senare,

256
00:19:09,000 --> 00:19:20,000
Vi kommer att radera allt detta, och sedan kopiera och klistra in från problemet inställda

257
00:19:20,000 --> 00:19:26,000
denna information i våra utrymmen och förhoppningsvis inte går sönder.

258
00:19:26,000 --> 00:19:28,000
Perfekt.

259
00:19:28,000 --> 00:19:33,000
Om ni alla gör det, kopiera och klistra in den här koden i ditt nya rum,

260
00:19:33,000 --> 00:19:43,000
till ett som är tomt.

261
00:19:43,000 --> 00:19:47,000
Låt oss försöka Daniel. Om du kompilera och köra programmet, fungerar det?

262
00:19:47,000 --> 00:19:49,000
Nej >> Vad är det säger?

263
00:19:49,000 --> 00:19:53,000
Det säger kontrollen når slutet av icke-tomma funktion.

264
00:19:53,000 --> 00:19:55,000
Ja, så låt mig försöka köra det.

265
00:19:55,000 --> 00:19:59,000
Har ni sett det här förut? Vet du vad det här betyder?

266
00:19:59,000 --> 00:20:01,000
Okej, låt oss dissekera detta lite.

267
00:20:01,000 --> 00:20:10,000
Det säger i file.c på linje 9, kolumn 1 har vi ett fel, precis som du sa,

268
00:20:10,000 --> 00:20:16,000
och det säger att det är till följd av felet varning och returtyp varning.

269
00:20:16,000 --> 00:20:18,000
Det ser ut som något som händer med avkastningen typ, som är vettigt.

270
00:20:18,000 --> 00:20:21,000
Vi har en icke-void funktion, vilket innebär att vi har en funktion

271
00:20:21,000 --> 00:20:24,000
som inte återvänder ogiltig.

272
00:20:24,000 --> 00:20:27,000
En ogiltig funktion är en som ser ut så här:

273
00:20:27,000 --> 00:20:35,000
void foo (), och det är ogiltigt på grund av avkastningen typ är ogiltigt,

274
00:20:35,000 --> 00:20:38,000
vilket innebär att om vi hade något här

275
00:20:38,000 --> 00:20:45,000
Liksom retur 1, skulle vi få ett kompileringsfel för detta.

276
00:20:45,000 --> 00:20:49,000
Men vi har en icke-void funktion.

277
00:20:49,000 --> 00:20:51,000
Vår icke-void funktion i det här fallet är vår sökfunktion

278
00:20:51,000 --> 00:20:56,000
eftersom det har en avkastning typ bool.

279
00:20:56,000 --> 00:20:59,000
När det säger att kontrollen når slutet av en icke-void funktion,

280
00:20:59,000 --> 00:21:02,000
det är för att sökningen inte har return.

281
00:21:02,000 --> 00:21:04,000
Det är inte returnera någonting av typen bool.

282
00:21:04,000 --> 00:21:09,000
>> Vi kan fixa det, och vad tycker ni

283
00:21:09,000 --> 00:21:13,000
sök skulle återvända som standard?

284
00:21:13,000 --> 00:21:16,000
Vad bör vara standard returvärdet sökning?

285
00:21:16,000 --> 00:21:19,000
Eftersom det är vad vi kan lägga till i slutet.

286
00:21:19,000 --> 00:21:21,000
Charlotte, har du några-?

287
00:21:21,000 --> 00:21:23,000
Sant eller falskt? >> Sant eller falskt.

288
00:21:23,000 --> 00:21:26,000
Vilken?

289
00:21:26,000 --> 00:21:28,000
Falskt. Jag vet inte.

290
00:21:28,000 --> 00:21:30,000
Falskt? Låt oss försöka det.

291
00:21:30,000 --> 00:21:32,000
Varför skulle du säga avkastning falskt? Det är bra intuition.

292
00:21:32,000 --> 00:21:35,000
[Charlotte] Jag vet inte.

293
00:21:35,000 --> 00:21:39,000
Vi kommer att returnera false i detta fall eftersom det kommer att vara vår standard

294
00:21:39,000 --> 00:21:44,000
om det av någon anledning är tom eller nålen

295
00:21:44,000 --> 00:21:46,000
att vi letar efter finns inte.

296
00:21:46,000 --> 00:21:50,000
Sedan i slutet, om vi inte tillbaka riktigt tidigare i denna funktion,

297
00:21:50,000 --> 00:21:55,000
Vi vet alltid att denna funktion kommer att säga Nej, det är inte i arrayen.

298
00:21:55,000 --> 00:21:58,000
Det är inte i höstacken.

299
00:21:58,000 --> 00:22:03,000
Om vi ​​nu kompilera och köra det, låt mig spara så att vi kan dra upp den.

300
00:22:03,000 --> 00:22:08,000
Om vi ​​nu kompilera och köra vårt program, bygger det.

301
00:22:08,000 --> 00:22:12,000
Vi får vår lilla snabb.

302
00:22:12,000 --> 00:22:20,000
Om jag slog 4-uh-oh.

303
00:22:20,000 --> 00:22:25,000
Det tog inte skriva ut något. Det ser ut som allt slutade bra.

304
00:22:25,000 --> 00:22:35,000
Vi måste fylla i.

305
00:22:35,000 --> 00:22:39,000
Vi pratade om algoritmen i pseudokod lite sen.

306
00:22:39,000 --> 00:22:44,000
Låt mig se, spara,

307
00:22:44,000 --> 00:22:49,000
och jag ska dra det algoritm upp igen.

308
00:22:49,000 --> 00:22:51,000
Låt oss slå den här killen. Nix.

309
00:22:51,000 --> 00:22:58,000
Där är det.

310
00:22:58,000 --> 00:23:03,000
Hur gör vi det?

311
00:23:03,000 --> 00:23:11,000
Vad skulle vara en bra strategi för start denna kod?

312
00:23:11,000 --> 00:23:16,000
Du måste välja ett nummer i mitten.

313
00:23:16,000 --> 00:23:23,000
Hur väljer vi ett antal i mitten av en array?

314
00:23:23,000 --> 00:23:25,000
Några förslag?

315
00:23:25,000 --> 00:23:27,000
[Student] strlen delat med 2.

316
00:23:27,000 --> 00:23:32,000
Strlen delat med 2. Det är en stor en.

317
00:23:32,000 --> 00:23:35,000
Strlen arbetar med särskilda typer av arrayer.

318
00:23:35,000 --> 00:23:38,000
Vilka typer av arrayer?

319
00:23:38,000 --> 00:23:44,000
String arrayer, tecken kedjor.

320
00:23:44,000 --> 00:23:48,000
Det är samma typ av koncept som vi vill tillämpa,

321
00:23:48,000 --> 00:23:52,000
men vi kan inte använda strlen eftersom vi inte har en mängd tecken.

322
00:23:52,000 --> 00:23:55,000
Vi har en mängd Ints.

323
00:23:55,000 --> 00:23:58,000
Men vad får strlen för oss?

324
00:23:58,000 --> 00:24:01,000
Vet du vad det blir för oss?

325
00:24:01,000 --> 00:24:03,000
[Student] strlen får oss längden.

326
00:24:03,000 --> 00:24:05,000
Exakt, det blir vi längden.

327
00:24:05,000 --> 00:24:09,000
Strlen får längden av uppsättningen för oss.

328
00:24:09,000 --> 00:24:14,000
>> Hur får vi det i vår binära sökprogram?

329
00:24:14,000 --> 00:24:18,000
Hur skulle du få längden på en array?

330
00:24:18,000 --> 00:24:20,000
[Student] strlen?

331
00:24:20,000 --> 00:24:25,000
Du kan få längden på ett korrekt formaterad C string array med strlen.

332
00:24:25,000 --> 00:24:31,000
Problemet är dock att vi inte har en sträng array.

333
00:24:31,000 --> 00:24:36,000
Om vi ​​ser tillbaka på den här koden, har vi denna heltal array.

334
00:24:36,000 --> 00:24:38,000
Hur vet vi hur lång tid det är?

335
00:24:38,000 --> 00:24:44,000
[Student] Finns det en motsvarande en för endpoint, som int l eller något?

336
00:24:44,000 --> 00:24:49,000
Det visar sig att det faktiskt inte, och det på ett sätt, det är

337
00:24:49,000 --> 00:24:52,000
en av de saker som är bara bra att veta om C,

338
00:24:52,000 --> 00:24:57,000
att det inte finns något sätt att få längden på en matris

339
00:24:57,000 --> 00:24:59,000
om allt jag ger dig är matrisen.

340
00:24:59,000 --> 00:25:02,000
Anledningen till att det fungerar med strängar, anledningen strlen verk,

341
00:25:02,000 --> 00:25:06,000
är att om en sträng är felaktigt formaterad,

342
00:25:06,000 --> 00:25:12,000
det kommer att ha den där speciella \ 0 tecken i slutet.

343
00:25:12,000 --> 00:25:16,000
>> Du kan också tänka sig om man har en felaktigt formaterad sträng

344
00:25:16,000 --> 00:25:20,000
och det finns ingen \ 0 tecken där, så det hela inte fungerar.

345
00:25:20,000 --> 00:25:22,000
[Student] kan du lägga till \ 0?

346
00:25:22,000 --> 00:25:24,000
Vi kunde i detta fall.

347
00:25:24,000 --> 00:25:29,000
Vi skulle kunna lägga någon form av \ 0

348
00:25:29,000 --> 00:25:33,000
eller någon form av betecknar karaktär och sedan använda det.

349
00:25:33,000 --> 00:25:36,000
Men det är inte riktigt kommer att fungera

350
00:25:36,000 --> 00:25:40,000
eftersom \ 0 är en röding typ,

351
00:25:40,000 --> 00:25:43,000
och här har vi Ints.

352
00:25:43,000 --> 00:25:46,000
Den andra saken är att vi skulle använda ett speciellt värde

353
00:25:46,000 --> 00:25:49,000
Liksom -1 för att markera slutet av en array

354
00:25:49,000 --> 00:25:54,000
då vi aldrig kunde lagra en -1 i våra heltal matriser.

355
00:25:54,000 --> 00:25:56,000
Vi skulle vara fast.

356
00:25:56,000 --> 00:26:00,000
Det visar sig att det enda sättet att få längden

357
00:26:00,000 --> 00:26:03,000
av en array i C är att faktiskt komma ihåg det

358
00:26:03,000 --> 00:26:08,000
när du ställer upp och sedan skicka den runt med matrisen

359
00:26:08,000 --> 00:26:14,000
så att när jag har en funktion som kommer att göra en del arbete

360
00:26:14,000 --> 00:26:18,000
på en rad heltal eller flöten eller dubbel eller vad har du,

361
00:26:18,000 --> 00:26:22,000
Jag måste också ge funktionen arrayen längd,

362
00:26:22,000 --> 00:26:26,000
och det är precis vad vi har gjort här i sökfunktionen.

363
00:26:26,000 --> 00:26:30,000
Om man tittar, vad vi har gjort när vi passerar i vår grupp här,

364
00:26:30,000 --> 00:26:36,000
passerar vi också i längd, storlek.

365
00:26:36,000 --> 00:26:41,000
Det händer bara att vi har kallat denna variabel här,

366
00:26:41,000 --> 00:26:43,000
denna parameter eller argument.

367
00:26:43,000 --> 00:26:46,000
Detta kallas en funktion argument lista eller parameterlistan

368
00:26:46,000 --> 00:26:51,000
och dessa kallas även argument eller parametrar.

369
00:26:51,000 --> 00:26:53,000
Människor använder olika termer vid olika tidpunkter.

370
00:26:53,000 --> 00:26:55,000
Jag utbyta Ibland dem själv.

371
00:26:55,000 --> 00:27:00,000
Det råkar vara så att denna variabel här heter liknande

372
00:27:00,000 --> 00:27:03,000
till detta definiera # upp här.

373
00:27:03,000 --> 00:27:06,000
Men de är inte samma sak.

374
00:27:06,000 --> 00:27:11,000
Aktiveringen spelar roll.

375
00:27:11,000 --> 00:27:14,000
>> Om man tittar på vad som händer här, förklarar vi

376
00:27:14,000 --> 00:27:18,000
vår int array, som vi har kallat nummer.

377
00:27:18,000 --> 00:27:23,000
Vi har gett det vår storlek, vilket motsvarar vår # define upp på toppen.

378
00:27:23,000 --> 00:27:27,000
Det kommer att vara 8.

379
00:27:27,000 --> 00:27:35,000
Och sedan när vi kallar då vår sökfunktion nere,

380
00:27:35,000 --> 00:27:40,000
vi passerar i antalet vi vill söka, som vi har uppmanas

381
00:27:40,000 --> 00:27:43,000
fått från användaren.

382
00:27:43,000 --> 00:27:46,000
Vi passerar i arrayen, detta nummer,

383
00:27:46,000 --> 00:27:51,000
och sedan har vi också passera i storleken av arrayen,

384
00:27:51,000 --> 00:27:57,000
och sedan värdet på storlek 8 får lagras

385
00:27:57,000 --> 00:28:01,000
eller skickas till denna heltalsvariabel kallas storlek.

386
00:28:01,000 --> 00:28:08,000
Vi har storleken på matrisen.

387
00:28:08,000 --> 00:28:11,000
Nu om vi går tillbaka till vad vi talade om tidigare,

388
00:28:11,000 --> 00:28:14,000
Jag tror Missy tog upp den punkt som vad vi behövde göra är att få längden på arrayen

389
00:28:14,000 --> 00:28:20,000
och dela det med 2, och det kommer att ge oss mittpunkten.

390
00:28:20,000 --> 00:28:22,000
Låt oss se.

391
00:28:22,000 --> 00:28:25,000
Kan jag ha någon skriver detta och spara det i rymden?

392
00:28:25,000 --> 00:28:27,000
Vad sägs om Leila?

393
00:28:27,000 --> 00:28:31,000
Kan jag få dig att skriva detta i?

394
00:28:31,000 --> 00:28:35,000
Skriv den första raden där du tar längden på arrayen och få mittpunkten

395
00:28:35,000 --> 00:28:41,000
och förvara den i en ny variabel.

396
00:28:41,000 --> 00:28:44,000
Jag ska ge er ett par sekunder. Är du redo?

397
00:28:44,000 --> 00:28:46,000
[Student ohörbart]

398
00:28:46,000 --> 00:28:50,000
Visst, jag kunde ha dig att beräkna mittpunkten

399
00:28:50,000 --> 00:28:55,000
av höstack arrayen inne i sökfunktionen

400
00:28:55,000 --> 00:29:03,000
använda längden av höstack arrayen, vilket är storleken variabeln?

401
00:29:03,000 --> 00:29:08,000
Inget knepigt här.

402
00:29:08,000 --> 00:29:12,000
[Leila] Bara storlek / 2 och just-

403
00:29:12,000 --> 00:29:17,000
Och spara den, och tryck på knappen Spara upp här i toppen,

404
00:29:17,000 --> 00:29:19,000
och vi kommer dra upp den.

405
00:29:19,000 --> 00:29:22,000
Perfekt.

406
00:29:22,000 --> 00:29:28,000
Där kör vi. Toppen.

407
00:29:28,000 --> 00:29:30,000
>> Som kommer detta sammanställa?

408
00:29:30,000 --> 00:29:32,000
[Leila] Nej, den måste vara högre.

409
00:29:32,000 --> 00:29:34,000
[Nate] Ja, så vad behöver vi göra?

410
00:29:34,000 --> 00:29:36,000
[Leila] Liksom int mittpunkt eller något.

411
00:29:36,000 --> 00:29:41,000
Toppen. Ja, låt oss göra det, int mittpunkt = storlek.

412
00:29:41,000 --> 00:29:44,000
Kommer detta sammanställa?

413
00:29:44,000 --> 00:29:47,000
Låt oss ta bort denna kommentar och få det ur vägen.

414
00:29:47,000 --> 00:29:50,000
Vad kommer inte kompilera om detta?

415
00:29:50,000 --> 00:29:52,000
Vi gör inget med heltal,

416
00:29:52,000 --> 00:29:55,000
så vi måste skriva ut det eller nåt sånt.

417
00:29:55,000 --> 00:29:58,000
Ja, exakt.

418
00:29:58,000 --> 00:30:00,000
Vi får en oanvänd variabel.

419
00:30:00,000 --> 00:30:02,000
Vad kommer inte att fungera om det här?

420
00:30:02,000 --> 00:30:06,000
Jag tror att du sa något, Sam. Semikolon.

421
00:30:06,000 --> 00:30:08,000
Ja, jag saknar dem semikolon.

422
00:30:08,000 --> 00:30:14,000
Det kommer att vara en konstant sak under hela mandatperioden.

423
00:30:14,000 --> 00:30:17,000
Det sista jag gör är att jag sätter lite tomt utrymme på båda sidor

424
00:30:17,000 --> 00:30:23,000
av denna aktör här, eftersom det är oftast hur vi gör det

425
00:30:23,000 --> 00:30:26,000
enligt vår stilguide.

426
00:30:26,000 --> 00:30:29,000
Vi har mittpunkten av vår grupp.

427
00:30:29,000 --> 00:30:32,000
Nu om vi minns tillbaka till vår algoritm,

428
00:30:32,000 --> 00:30:37,000
vad var det andra steget som vi var tvungna att göra när vi har mittpunkten?

429
00:30:37,000 --> 00:30:42,000
[Student] Om det är större [ohörbart].

430
00:30:42,000 --> 00:30:48,000
Ja, så vi måste göra någon form av jämförelse, och vad är det vi jämför här?

431
00:30:48,000 --> 00:30:53,000
Du sa att om den är större än. Vad är det i den meningen hänvisar till?

432
00:30:53,000 --> 00:30:57,000
Antalet som kommer upp, om det är större än mittpunkten och sedan gå upp till arrayen?

433
00:30:57,000 --> 00:31:05,000
Exakt, så antalet som kommer upp när vi-

434
00:31:05,000 --> 00:31:10,000
Nålen, så vi jämföra med nålen,

435
00:31:10,000 --> 00:31:12,000
och vad vi jämför mot nålen?

436
00:31:12,000 --> 00:31:15,000
Eftersom nålen är vad vi letar efter.

437
00:31:15,000 --> 00:31:18,000
Vi jämför det att komma till mittpunkten.

438
00:31:18,000 --> 00:31:21,000
>> Men gör det meningsfullt att kontrollera

439
00:31:21,000 --> 00:31:27,000
Om st = mittpunkten?

440
00:31:27,000 --> 00:31:32,000
Verkar det vettigt?

441
00:31:32,000 --> 00:31:35,000
Har oense någon?

442
00:31:35,000 --> 00:31:40,000
Låt oss ge det ett försök, om (nål == mittpunkten).

443
00:31:40,000 --> 00:31:42,000
[Student] Har printf du hittat den.

444
00:31:42,000 --> 00:31:51,000
[Nate] printf ("Vi fann det \ n");

445
00:31:51,000 --> 00:31:56,000
Annars-Jag kommer att börja göra något annat här.

446
00:31:56,000 --> 00:32:00,000
Jag ska börja sätta hängslen runt om uttalanden hela tiden

447
00:32:00,000 --> 00:32:05,000
bara för att om vi lägger mer grejer, sedan

448
00:32:05,000 --> 00:32:07,000
Vi får inte kompilatorer.

449
00:32:07,000 --> 00:32:09,000
Ja, Sam. Du har en poäng.

450
00:32:09,000 --> 00:32:12,000
Problemet är att mittpunkten representerar en position i matrisen,

451
00:32:12,000 --> 00:32:15,000
men du kan få det att representera värdet i den positionen i matrisen.

452
00:32:15,000 --> 00:32:17,000
Det är en bra plats.

453
00:32:17,000 --> 00:32:19,000
Har alla höra vad Sam sa?

454
00:32:19,000 --> 00:32:22,000
Han sade att mittpunkten som är

455
00:32:22,000 --> 00:32:28,000
representerar bara en position i arrayen, men det är inte själva elementet i arrayen.

456
00:32:28,000 --> 00:32:30,000
Om du tänker på koden som skrivits just nu,

457
00:32:30,000 --> 00:32:35,000
om vi ser på denna array här nere, som har 8 element i den,

458
00:32:35,000 --> 00:32:39,000
Vad är värdet av mittpunkten kommer att vara i denna funktion?

459
00:32:39,000 --> 00:32:41,000
[Student] 4.

460
00:32:41,000 --> 00:32:45,000
[Nate] 4.

461
00:32:45,000 --> 00:32:51,000
Om vi ​​ser till antalet 4 -

462
00:32:51,000 --> 00:32:54,000
och vi kan bara köra denna kod och sätta lite sorgset ansikte här

463
00:32:54,000 --> 00:32:58,000
eftersom vi inte tycker att det-om vi kör den här koden

464
00:32:58,000 --> 00:33:04,000
som är just nu, ladda upp den, byggnad, låt mig scrolla ner,

465
00:33:04,000 --> 00:33:09,000
och om vi ser till antalet 4,

466
00:33:09,000 --> 00:33:18,000
vi fann det, men vi fick inte detta att printf ja.

467
00:33:18,000 --> 00:33:23,000
En anledning är att vi inte tillbaka riktigt,

468
00:33:23,000 --> 00:33:26,000
men vi hittade verkligen nummer 4?

469
00:33:26,000 --> 00:33:28,000
Och Sam säger nej.

470
00:33:28,000 --> 00:33:31,000
Vad hittade vi?

471
00:33:31,000 --> 00:33:35,000
Vi hittade verkligen mittpunkten, som om vi tittar på matrisen här nere,

472
00:33:35,000 --> 00:33:38,000
det kommer att bli elementet vid index 4 som vi tittar på,

473
00:33:38,000 --> 00:33:42,000
vilket är 23.

474
00:33:42,000 --> 00:33:46,000
>> Hur får vi faktiskt det elementet vid mittpunkten

475
00:33:46,000 --> 00:33:48,000
och inte bara mittpunkten själv?

476
00:33:48,000 --> 00:33:52,000
[Student] Vi skulle komma in röding eller något?

477
00:33:52,000 --> 00:33:55,000
Vad skulle det göra, bara av nyfikenhet?

478
00:33:55,000 --> 00:33:57,000
Kan du utveckla lite mer?

479
00:33:57,000 --> 00:34:02,000
Du måste omvandla läget i antal,

480
00:34:02,000 --> 00:34:05,000
så du har att göra ett samband, jag tycker det är röding, men det kanske inte.

481
00:34:05,000 --> 00:34:07,000
Ja, det är en bra sak.

482
00:34:07,000 --> 00:34:12,000
Vi har gjort en hel del av detta omvandla positioner i tecken, dessa tecken,

483
00:34:12,000 --> 00:34:14,000
i de första två problemområden uppsättningar.

484
00:34:14,000 --> 00:34:18,000
Det visar sig att här är det nästan lika

485
00:34:18,000 --> 00:34:24,000
tillgång till te tecknet i en sträng, om det är vettigt.

486
00:34:24,000 --> 00:34:30,000
Här vill vi komma åt mittpunkten elementet.

487
00:34:30,000 --> 00:34:34,000
Hur gör vi det?

488
00:34:34,000 --> 00:34:39,000
Kevin, har du några förslag hur vi kan göra det?

489
00:34:39,000 --> 00:34:44,000
Du kan göra höstack, sluten öppen konsol, mitten, hållare.

490
00:34:44,000 --> 00:34:46,000
Kan du skriva det för oss?

491
00:34:46,000 --> 00:34:51,000
Spara den här, och vi kommer dra upp det.

492
00:34:51,000 --> 00:34:56,000
Vi tittar på den här raden 9,

493
00:34:56,000 --> 00:34:59,000
och vi inser att vi inte vill jämföra nålen till mittpunkten,

494
00:34:59,000 --> 00:35:03,000
men i stället vill vi jämföra nålen

495
00:35:03,000 --> 00:35:07,000
till elementet i position mittpunkt i vår höstack matris.

496
00:35:07,000 --> 00:35:10,000
Cool.

497
00:35:10,000 --> 00:35:12,000
Där kör vi.

498
00:35:12,000 --> 00:35:15,000
Ja, det ser det ganska bra, om (nål == höstack [mittpunkt]).

499
00:35:15,000 --> 00:35:18,000
Vi hittade det.

500
00:35:18,000 --> 00:35:22,000
Om vi ​​nu kör koden-Vi säkerhetskopiera lite-

501
00:35:22,000 --> 00:35:26,000
Det sammanställer, det går, och nu när vi letar efter 4,

502
00:35:26,000 --> 00:35:30,000
Vi hittade inte det för nu är vi faktiskt få numret 23.

503
00:35:30,000 --> 00:35:33,000
Vi får värdet 23, och det är vad vi jämför med vår nål.

504
00:35:33,000 --> 00:35:35,000
Men det är bra. Det är ett steg i rätt riktning.

505
00:35:35,000 --> 00:35:37,000
>> Det är vad vi försöker göra.

506
00:35:37,000 --> 00:35:40,000
Vi försöker inte jämföra nålen mot positioner i arrayen

507
00:35:40,000 --> 00:35:44,000
utan snarare mot de faktiska elementen i arrayen.

508
00:35:44,000 --> 00:35:49,000
Om vi ​​ser tillbaka nu på nästa steg i vår algoritm,

509
00:35:49,000 --> 00:35:51,000
vad är nästa steg?

510
00:35:51,000 --> 00:35:57,000
Leila redan nämnt det kort.

511
00:35:57,000 --> 00:36:00,000
[Student] Kontrollera om det är större än eller mindre än och sedan bestämma vilken väg att flytta.

512
00:36:00,000 --> 00:36:03,000
[Nate] Ja, så skulle hur vi gör det?

513
00:36:03,000 --> 00:36:07,000
Kan du sätta i några-Jag sparar denna översyn,

514
00:36:07,000 --> 00:36:13,000
och sedan om du sätter i några rader som kommer att göra det.

515
00:36:13,000 --> 00:36:15,000
Ja, Charlotte. >> Jag har en fråga.

516
00:36:15,000 --> 00:36:19,000
Borde det inte vara mittpunkten - 1 eftersom det första är

517
00:36:19,000 --> 00:36:26,000
det är 0 indexeras, så om vi sätter 4, det är faktiskt inte det tecken vi letar efter?

518
00:36:26,000 --> 00:36:30,000
Ja, och det andra problemet med det är-

519
00:36:30,000 --> 00:36:35,000
Det är en stor fångst, eftersom det kommer att sluta upp händer eventuellt

520
00:36:35,000 --> 00:36:42,000
om vi hålla rörliga och vi inte någonsin ändra början?

521
00:36:42,000 --> 00:36:46,000
Jag antar att vad vi kan sluta göra försöker komma åt

522
00:36:46,000 --> 00:36:49,000
elementet vid den 8: e positionen av arrayen,

523
00:36:49,000 --> 00:36:53,000
som i detta fall inte existerar.

524
00:36:53,000 --> 00:36:56,000
Vi kommer att vilja göra någon form av redovisning av det faktum

525
00:36:56,000 --> 00:36:59,000
att vi har några noll indexering.

526
00:36:59,000 --> 00:37:05,000
[Charlotte] Tyvärr, jag menade mittpunkten - 1 i hakparenteser.

527
00:37:05,000 --> 00:37:08,000
Vi kan göra det.

528
00:37:08,000 --> 00:37:10,000
Vi ska återkomma till denna fråga i bara lite.

529
00:37:10,000 --> 00:37:13,000
När vi börjar komma till den faktiska looping,

530
00:37:13,000 --> 00:37:16,000
det är då vi får verkligen se detta spelar in.

531
00:37:16,000 --> 00:37:21,000
För närvarande kan vi göra det, men du är helt rätt.

532
00:37:21,000 --> 00:37:28,000
Att noll indexering kommer att ha en effekt som vi måste ta hänsyn till.

533
00:37:28,000 --> 00:37:30,000
Låt oss se.

534
00:37:30,000 --> 00:37:34,000
>> Hur är det större än och mindre än?

535
00:37:34,000 --> 00:37:36,000
[Student] Jag får hur man gör det större än och mindre än en del.

536
00:37:36,000 --> 00:37:41,000
Jag var bara inte säker på vad du vill skriva ut om du tycker att det är mindre än höstacken mittpunkten eller större än.

537
00:37:41,000 --> 00:37:43,000
Här kan jag spara det I've-

538
00:37:43,000 --> 00:37:47,000
[Nate] Ja, om du sparar det du har, och vi kommer att dra upp den.

539
00:37:47,000 --> 00:37:49,000
Där kör vi.

540
00:37:49,000 --> 00:37:51,000
[Student] Och jag satte frågetecken för vad jag inte visste.

541
00:37:51,000 --> 00:37:54,000
[Nate] Det ser bra ut.

542
00:37:54,000 --> 00:37:58,000
Här har vi frågetecken eftersom vi fortfarande inte vet

543
00:37:58,000 --> 00:38:06,000
vad vi ska riktigt göra ännu.

544
00:38:06,000 --> 00:38:12,000
Vad skulle vi vilja göra-oops, vi har några hängslen alla funky på oss.

545
00:38:12,000 --> 00:38:15,000
Vi kommer korrigera dessa hängslen.

546
00:38:15,000 --> 00:38:19,000
Där kör vi.

547
00:38:19,000 --> 00:38:22,000
Och så vad vill vi göra, enligt vår algoritm,

548
00:38:22,000 --> 00:38:27,000
Om vi ​​inte hittar nålen?

549
00:38:27,000 --> 00:38:32,000
Säg i det fall att nålen är mindre än vad vi tittar på. Kevin.

550
00:38:32,000 --> 00:38:34,000
Bara titta på den vänstra halvan.

551
00:38:34,000 --> 00:38:40,000
Just det, så vi sätter en kommentar här som säger "titta på vänstra halvan."

552
00:38:40,000 --> 00:38:46,000
Och om nålen är större än höstacken vid mittpunkten, vad vi vill göra?

553
00:38:46,000 --> 00:38:48,000
[Student] om du tittar på den högra halvan.

554
00:38:48,000 --> 00:38:53,000
Titta på den högra halvan, "titta på högra halvan."

555
00:38:53,000 --> 00:38:58,000
Inte så illa.

556
00:38:58,000 --> 00:39:05,000
Okej, så på denna punkt, saker ser ganska bra ut.

557
00:39:05,000 --> 00:39:13,000
Problemet med koden som skrivs är vad?

558
00:39:13,000 --> 00:39:15,000
[Student] Du har inte slutpunkterna för halvorna.

559
00:39:15,000 --> 00:39:18,000
Rätt, vi har inte slutpunkter för halvorna.

560
00:39:18,000 --> 00:39:20,000
Vi är också bara kommer att gå igenom detta en gång.

561
00:39:20,000 --> 00:39:23,000
Vi kommer bara att titta på en mittpunkt.

562
00:39:23,000 --> 00:39:27,000
Antingen elementet är där, eller är det inte.

563
00:39:27,000 --> 00:39:34,000
För att slutföra detta behöver vi göra någon form av upprepning.

564
00:39:34,000 --> 00:39:39,000
Vi måste fortsätta att upprepa tills vi finner att

565
00:39:39,000 --> 00:39:43,000
antingen elementet är där eftersom vi har minskat ner och äntligen hittat det,

566
00:39:43,000 --> 00:39:46,000
eller det är inte där för att vi har tittat igenom alla de saker

567
00:39:46,000 --> 00:39:52,000
i lämpliga halvorna av gruppen och fann att ingenting finns i det.

568
00:39:52,000 --> 00:39:56,000
>> När vi har fått denna upprepning pågår, vad ska vi använda?

569
00:39:56,000 --> 00:39:58,000
[Student] En slinga.

570
00:39:58,000 --> 00:40:00,000
Någon sorts loop. Ja.

571
00:40:00,000 --> 00:40:03,000
[Student] Kan vi göra en gör-while-slinga och få det göra det och sedan när

572
00:40:03,000 --> 00:40:10,000
nålen inte lika-Jag är inte säker på var jag skulle med.

573
00:40:10,000 --> 00:40:18,000
Men ungefär som gör att så länge det inte är lika med värdet som användaren indata.

574
00:40:18,000 --> 00:40:21,000
Ja, så låt oss se, hur kan detta skriver själv?

575
00:40:21,000 --> 00:40:23,000
Du sa låt oss använda en gör-while-slinga.

576
00:40:23,000 --> 00:40:26,000
Var gör starten?

577
00:40:26,000 --> 00:40:33,000
[Student] Direkt efter storlek / 2.

578
00:40:33,000 --> 00:40:42,000
[Nate] Okej, och vad ska vi göra?

579
00:40:42,000 --> 00:40:44,000
Vi ska fylla i medan senare.

580
00:40:44,000 --> 00:40:46,000
Vad ska vi göra?

581
00:40:46,000 --> 00:40:49,000
[Student] Gör inte vi vill göra alla grejer vi har i om delen?

582
00:40:49,000 --> 00:40:52,000
[Nate] Gör allt det här, bra.

583
00:40:52,000 --> 00:40:55,000
Kopiera och klistra in.

584
00:40:55,000 --> 00:40:59,000
Åh, mannen.

585
00:40:59,000 --> 00:41:03,000
Låt oss se om detta fungerar, om vi kan fliken här över.

586
00:41:03,000 --> 00:41:08,000
Vacker.

587
00:41:08,000 --> 00:41:16,000
Okej, och vi sparar detta så ni har det.

588
00:41:16,000 --> 00:41:21,000
Okej, och vi kommer att göra detta samtidigt,

589
00:41:21,000 --> 00:41:25,000
vad var tag skick du var ute efter?

590
00:41:25,000 --> 00:41:31,000
[Student] Medan nålen inte är lika, så som utropstecken.

591
00:41:31,000 --> 00:41:37,000
Men jag är inte säker på exakt vad det är ännu.

592
00:41:37,000 --> 00:41:39,000
[Nate] Ja, det här är ett sätt att göra det.

593
00:41:39,000 --> 00:41:41,000
Sam, har du en kommentar?

594
00:41:41,000 --> 00:41:43,000
[Sam] Jag minns när jag tittade på filmerna,

595
00:41:43,000 --> 00:41:48,000
Jag tog en skärmdump av en av-som när vi gjorde pseudokod för det,

596
00:41:48,000 --> 00:41:52,000
fanns ett visst samband mellan max och min.

597
00:41:52,000 --> 00:41:58,000
Jag tror det var något som om max är allt mindre än min.

598
00:41:58,000 --> 00:42:00,000
Fick det.

599
00:42:00,000 --> 00:42:04,000
[Sam] Eller som om max är inte mindre än min eller något liknande,

600
00:42:04,000 --> 00:42:06,000
eftersom det skulle innebära att du har sökt allt.

601
00:42:06,000 --> 00:42:13,000
>> Ja, så vad låter det som max och min syftade på?

602
00:42:13,000 --> 00:42:16,000
[Sam] Värden som-heltal som kommer att förändra

603
00:42:16,000 --> 00:42:18,000
i förhållande till där vi sätter mittpunkten.

604
00:42:18,000 --> 00:42:20,000
Exakt.

605
00:42:20,000 --> 00:42:24,000
[Sam] Vid denna tidpunkt kommer det att [ohörbart] beräkna max och min.

606
00:42:24,000 --> 00:42:29,000
Mittpunkt är max och min idé.

607
00:42:29,000 --> 00:42:35,000
Gör det meningsfullt att folk?

608
00:42:35,000 --> 00:42:39,000
Om vi ​​skulle börja titta på hur vi ska göra det här iteration,

609
00:42:39,000 --> 00:42:43,000
du är helt rätt att vi vill använda någon form av gör-while-slinga.

610
00:42:43,000 --> 00:42:49,000
Men jag antar att om vi kommer ihåg vad som händer på plats i denna array

611
00:42:49,000 --> 00:42:53,000
och vad som faktiskt händer-Jag ska skriva hit-

612
00:42:53,000 --> 00:42:58,000
vid första iteration av binärsökning har-vi

613
00:42:58,000 --> 00:43:05,000
Jag kommer att använda B och E för att beteckna början.

614
00:43:05,000 --> 00:43:10,000
Och sedan i slutet av vår grupp.

615
00:43:10,000 --> 00:43:14,000
Vi vet att i början är på 4 rätt över här,

616
00:43:14,000 --> 00:43:18,000
och vi vet att slutet är 108.

617
00:43:18,000 --> 00:43:23,000
Säg att vi söker efter numret 15.

618
00:43:23,000 --> 00:43:27,000
Första gången vi gör detta, som vi såg tidigare,

619
00:43:27,000 --> 00:43:30,000
mittpunkten antingen kommer att vara 16 eller 23

620
00:43:30,000 --> 00:43:34,000
beroende på hur vi beräknar saker.

621
00:43:34,000 --> 00:43:37,000
Sedan jämnt dela i mitten skulle ge oss detta utrymme

622
00:43:37,000 --> 00:43:42,000
mellan 16 och 23, kan vi inte jämnt dela den

623
00:43:42,000 --> 00:43:47,000
eller dela den och få på en sann mittpunkt.

624
00:43:47,000 --> 00:43:49,000
Vi ska titta på 16.

625
00:43:49,000 --> 00:43:55,000
Vi kommer att inse "Hej, 16> 15 som vi letar efter."

626
00:43:55,000 --> 00:43:59,000
Att sedan titta på den vänstra halvan av matrisen

627
00:43:59,000 --> 00:44:03,000
vad vi ska sluta göra är kasta

628
00:44:03,000 --> 00:44:07,000
hela denna övre del

629
00:44:07,000 --> 00:44:16,000
och sade: "Okej, nu vår slutpunkt kommer att vara här."

630
00:44:16,000 --> 00:44:22,000
Nästa iteration av vår slinga, vi nu tittar på detta array,

631
00:44:22,000 --> 00:44:25,000
effektivt har kasseras denna del eftersom nu

632
00:44:25,000 --> 00:44:30,000
Om vi ​​tar mittpunkten är skillnaden mellan början och slutet,

633
00:44:30,000 --> 00:44:34,000
finner vi vår mittpunkt är 8,

634
00:44:34,000 --> 00:44:40,000
som vi kan testa 8 för att se var den är i förhållande till antalet vi letar efter,

635
00:44:40,000 --> 00:44:44,000
15, tycker att 15 är större,

636
00:44:44,000 --> 00:44:49,000
så vi måste flytta till den högra delen av listan,

637
00:44:49,000 --> 00:44:51,000
som vi vet att vi är människor och vi kan se det.

638
00:44:51,000 --> 00:44:54,000
Vi vet att den högra delen kommer att vara där vi finner den,

639
00:44:54,000 --> 00:45:01,000
men datorn känner inte det, så vad vi ska göra är att vi kommer faktiskt

640
00:45:01,000 --> 00:45:04,000
ha det gå upp, och nu i början och slutet

641
00:45:04,000 --> 00:45:11,000
är samma plats, så mittpunkten blir den enda numret i listan på den punkten,

642
00:45:11,000 --> 00:45:16,000
som är 15, och vi har hittat den.

643
00:45:16,000 --> 00:45:21,000
Betyder det belysa var det hela max och min notation går,

644
00:45:21,000 --> 00:45:24,000
hålla reda på ändpunkterna i uppsättningen för att räkna ut

645
00:45:24,000 --> 00:45:35,000
hur man kan minska ner saker?

646
00:45:35,000 --> 00:45:42,000
>> Vad skulle hända om det inte var lika med 15 nu?

647
00:45:42,000 --> 00:45:52,000
Tänk om vi letade efter 15 och i stället var denna siffra också 16?

648
00:45:52,000 --> 00:45:54,000
Vi skulle säga "Åh, det är större.

649
00:45:54,000 --> 00:45:57,000
Vi vill gå tillbaka till vänster. "

650
00:45:57,000 --> 00:46:01,000
Och vi skulle flytta vår e till höger,

651
00:46:01,000 --> 00:46:06,000
då vi har en slutpunkt som skulle vara motstridiga.

652
00:46:06,000 --> 00:46:09,000
Det skulle inte kunna söka några fler element

653
00:46:09,000 --> 00:46:13,000
för nu har vi vår slutpunkt och vår startpunkt,

654
00:46:13,000 --> 00:46:16,000
vår max och vår min nu vänt.

655
00:46:16,000 --> 00:46:23,000
Vi söker igenom hela matrisen. Vi kan inte hitta något.

656
00:46:23,000 --> 00:46:27,000
Det är den punkt där vi skulle vilja säga: "Okej, vi kommer att stoppa denna algoritm.

657
00:46:27,000 --> 00:46:34,000
Vi har inte hittat något. Vi vet att det inte här. "

658
00:46:34,000 --> 00:46:36,000
Hur kommer detta?

659
00:46:36,000 --> 00:46:40,000
[Student] Hur exakt kan byta datorn slutet?

660
00:46:40,000 --> 00:46:45,000
Hur avslutar hamnar före början?

661
00:46:45,000 --> 00:46:48,000
Slutet hamnar före början

662
00:46:48,000 --> 00:46:54,000
på grund av den matematik som vi ska göra varje gång vi gör detta.

663
00:46:54,000 --> 00:47:00,000
Det sätt vi byter är om man tittar på den allra första gången vi gör det här swap

664
00:47:00,000 --> 00:47:03,000
där vi har början vid 4 och slutet

665
00:47:03,000 --> 00:47:13,000
hela vägen ned vid 108 och vår mittpunkt, säg, vid 16 -

666
00:47:13,000 --> 00:47:20,000
Jag ska återställa den tillbaka till 15-om vi letar efter 15,

667
00:47:20,000 --> 00:47:25,000
Vi visste att det vi gjorde när vi kontrollerat 16 och såg att det var större

668
00:47:25,000 --> 00:47:28,000
och ville kassera hela högra delen av listan,

669
00:47:28,000 --> 00:47:36,000
Vi såg att vad vi ville göra är att flytta denna e här.

670
00:47:36,000 --> 00:47:44,000
Effektivt, fick e flyttas till en före mittpunkten.

671
00:47:44,000 --> 00:47:48,000
Likaså när vi gjorde denna iteration av algoritmen

672
00:47:48,000 --> 00:47:51,000
och mittpunkten var 8,

673
00:47:51,000 --> 00:47:55,000
fann vi att 8 <15, så vi ville flytta b

674
00:47:55,000 --> 00:48:00,000
en förbi mittpunkten.

675
00:48:00,000 --> 00:48:07,000
Nu, i början och slutet är båda tillsammans i denna 15.

676
00:48:07,000 --> 00:48:10,000
>> Om vi ​​hade hänt för att leta efter något annat värde, inte 15,

677
00:48:10,000 --> 00:48:14,000
eller om denna 15 istället hade varit en 16,

678
00:48:14,000 --> 00:48:20,000
vi skulle ha funnit att e vi vill flytta en före mittpunkten.

679
00:48:20,000 --> 00:48:33,000
Nu e skulle vara där vänt lägre än miljarder.

680
00:48:33,000 --> 00:48:39,000
Låt oss gå igenom hur vi faktiskt hamna kodning denna algoritm.

681
00:48:39,000 --> 00:48:44,000
Vi vet att vi vill ha denna mittpunkt beräkning.

682
00:48:44,000 --> 00:48:48,000
Vi vet också att vi vill följa början och slutet av arrayen

683
00:48:48,000 --> 00:48:51,000
ur vårt nuvarande utbud så att vi kan räkna ut

684
00:48:51,000 --> 00:48:56,000
där denna vänstra halvan av listan är och var den högra halvan av listan är.

685
00:48:56,000 --> 00:49:03,000
Vi gör det med antingen börja och sluta,

686
00:49:03,000 --> 00:49:07,000
eller vi kan kalla dem min och max.

687
00:49:07,000 --> 00:49:10,000
Jag använder börjar och slutar denna gång.

688
00:49:10,000 --> 00:49:15,000
När vi börjar, om vi ser tillbaka på vårt exempel här nere,

689
00:49:15,000 --> 00:49:20,000
vår början sattes till början av arrayen, som naturligt.

690
00:49:20,000 --> 00:49:25,000
Vilken index var detta? Vad ska vi börja vara?

691
00:49:25,000 --> 00:49:27,000
Daniel.

692
00:49:27,000 --> 00:49:30,000
[Daniel] Haystack [0].

693
00:49:30,000 --> 00:49:37,000
[Nate] Ja, så vi kunde ställa in den lika med höstack [0].

694
00:49:37,000 --> 00:49:40,000
Problemet är dock att detta ger oss inte läget för den första elementet.

695
00:49:40,000 --> 00:49:45,000
Det ger oss index för första elementet eller det verkliga värdet på den första positionen.

696
00:49:45,000 --> 00:49:47,000
[Student] Det kommer att konvertera till 0,20?

697
00:49:47,000 --> 00:49:52,000
[Nate] Vad det kommer att göra är-bra kommer det inte att göra någon konvertering.

698
00:49:52,000 --> 00:49:56,000
Vad det kommer att göra är det att lagra en 4 i början,

699
00:49:56,000 --> 00:49:59,000
och då blir det svårt att göra jämförelser mot att börja

700
00:49:59,000 --> 00:50:03,000
eftersom Begin kommer att hålla värdet 4,

701
00:50:03,000 --> 00:50:06,000
vilket är början på vår array,

702
00:50:06,000 --> 00:50:08,000
men vi vill spåra indexen i matrisen

703
00:50:08,000 --> 00:50:11,000
i motsats till värdena.

704
00:50:11,000 --> 00:50:17,000
Vi kommer faktiskt använda en 0, så.

705
00:50:17,000 --> 00:50:20,000
Till slutet av arrayen-Charlotte tog upp lite tidigare.

706
00:50:20,000 --> 00:50:23,000
Det är där vi tar hänsyn till noll indexering.

707
00:50:23,000 --> 00:50:25,000
>> Charlotte, vad är slutet av arrayen?

708
00:50:25,000 --> 00:50:28,000
Vad är index till slutet?

709
00:50:28,000 --> 00:50:30,000
[Charlotte] Storlek - 1.

710
00:50:30,000 --> 00:50:32,000
Ja, och vilken storlek ska vi använda?

711
00:50:32,000 --> 00:50:35,000
Ska vi använda kapitalet storlek eller gemener storlek?

712
00:50:35,000 --> 00:50:37,000
Kapital storlek.

713
00:50:37,000 --> 00:50:42,000
I detta fall kan vi använda kapitalet storlek.

714
00:50:42,000 --> 00:50:45,000
Om vi ​​ville denna funktion för att vara portabel

715
00:50:45,000 --> 00:50:48,000
och använda den här funktionen i andra program,

716
00:50:48,000 --> 00:50:50,000
Vi kan faktiskt använda gemener storlek.

717
00:50:50,000 --> 00:50:52,000
Det är också bra.

718
00:50:52,000 --> 00:51:01,000
Men Charlotte är helt rätt att vi vill ha storlek - 1.

719
00:51:01,000 --> 00:51:03,000
Vid denna punkt-

720
00:51:03,000 --> 00:51:05,000
[Student] Hur kommer det sig att du kan använda versaler storlek?

721
00:51:05,000 --> 00:51:07,000
Hur kommer det sig att vi kunde använda versaler storlek?

722
00:51:07,000 --> 00:51:13,000
Det visar sig att dessa # definierar verkligen,

723
00:51:13,000 --> 00:51:19,000
under huven, en text som sök och ersätt, om det är vettigt.

724
00:51:19,000 --> 00:51:24,000
När du bygger din kod, förbehandlingen fasen

725
00:51:24,000 --> 00:51:27,000
av kompilatorn går igenom filen,

726
00:51:27,000 --> 00:51:31,000
och det ser för överallt att du har skrivit kapital storlek,

727
00:51:31,000 --> 00:51:39,000
och det ersätter det bokstavligen med en 8, precis så.

728
00:51:39,000 --> 00:51:42,000
I det avseendet är det mycket annorlunda från en variabel.

729
00:51:42,000 --> 00:51:45,000
Det tar inte upp någon plats i minnet.

730
00:51:45,000 --> 00:51:52,000
Det är en enkel text ersätta trick.

731
00:51:52,000 --> 00:51:57,000
I det här fallet kommer vi att använda storlek.

732
00:51:57,000 --> 00:52:01,000
Härifrån vi vill göra någon form av upprepning,

733
00:52:01,000 --> 00:52:03,000
och vi är på rätt väg med vår do-while-slinga.

734
00:52:03,000 --> 00:52:08,000
Vi vill göra något tills ett tillstånd håller inte längre,

735
00:52:08,000 --> 00:52:12,000
och som vi såg tidigare, såg vi att detta villkor

736
00:52:12,000 --> 00:52:19,000
var verkligen att vi inte vill att slutet

737
00:52:19,000 --> 00:52:24,000
att vara mindre än den börja.

738
00:52:24,000 --> 00:52:26,000
>> Detta är vår stoppa skick.

739
00:52:26,000 --> 00:52:35,000
Om detta inträffar vill vi stanna upp och förklara som, "Hej, vi har inte hittat något."

740
00:52:35,000 --> 00:52:43,000
För att uttrycka det, vi vill använda någon form av slingan.

741
00:52:43,000 --> 00:52:49,000
I det här fallet skulle det vara en gör-while-slinga, en for-slinga, en while-slinga?

742
00:52:49,000 --> 00:52:51,000
Vi har en gör-while-slinga här.

743
00:52:51,000 --> 00:52:53,000
Har ni såna tillvägagångssätt?

744
00:52:53,000 --> 00:52:59,000
Tror du att vi bör försöka en annan strategi?

745
00:52:59,000 --> 00:53:01,000
Kevin, några tankar?

746
00:53:01,000 --> 00:53:06,000
Vi skulle kunna ha en while-slinga eftersom vi vet maximal

747
00:53:06,000 --> 00:53:11,000
skulle vara större än min vid start ändå.

748
00:53:11,000 --> 00:53:14,000
Ja, så det finns ingen initiering som måste ske.

749
00:53:14,000 --> 00:53:17,000
De gör-while-slingor är bra när man måste initiera något

750
00:53:17,000 --> 00:53:21,000
innan dess testar, medan här

751
00:53:21,000 --> 00:53:26,000
Vi vet att vi inte kommer att hålla återinitialisera både börjar och slutar

752
00:53:26,000 --> 00:53:28,000
varje omgång av slingan.

753
00:53:28,000 --> 00:53:32,000
Vi vet att vi vill initiera dem, så kolla vår kondition.

754
00:53:32,000 --> 00:53:38,000
I det här fallet kommer jag faktiskt gå med en enkel while-slinga.

755
00:53:38,000 --> 00:53:44,000
Det visar sig att göra-while-slingor används ganska sällan.

756
00:53:44,000 --> 00:53:49,000
Många platser inte ens lär göra medan slingor.

757
00:53:49,000 --> 00:53:53,000
De är bra för att hantera användardata, så vi har sett en hel del av dem hittills.

758
00:53:53,000 --> 00:53:59,000
Men normalt för och medan slingor är mycket vanligare.

759
00:53:59,000 --> 00:54:03,000
Det visar sig att detta villkor som skrivits

760
00:54:03,000 --> 00:54:09,000
kommer inte riktigt att göra oss mycket bra, och varför är det?

761
00:54:09,000 --> 00:54:11,000
Jag är ledsen, jag vet inte ditt namn.

762
00:54:11,000 --> 00:54:13,000
Jag är Jerry. >> Ursäkta?

763
00:54:13,000 --> 00:54:15,000
Det är B-O-R-U-I.

764
00:54:15,000 --> 00:54:18,000
Åh, okej.

765
00:54:18,000 --> 00:54:23,000
Jag kan inte se dig på min lista.

766
00:54:23,000 --> 00:54:26,000
Åh, är det för att-OH, det är vettigt.

767
00:54:26,000 --> 00:54:31,000
Har du en idé om varför denna while-slinga kanske inte fungerar som avsett,

768
00:54:31,000 --> 00:54:38,000
som skrivs med villkoret?

769
00:54:38,000 --> 00:54:43,000
[Jerry] Du menar som du vill att alla grejer efter den i-?

770
00:54:43,000 --> 00:54:46,000
Ja, det är så att en.

771
00:54:46,000 --> 00:54:49,000
Vi kanske måste lägga allt det här i while-slingan, som är helt sant.

772
00:54:49,000 --> 00:54:55,000
Den andra saken som är lite mer problematiskt är dock att detta villkor inte fungerar.

773
00:54:55,000 --> 00:54:57,000
[Student] Du behöver vända den.

774
00:54:57,000 --> 00:55:04,000
Rätt, så detta villkor kommer aldrig att vara sant början hur vi pratade om det.

775
00:55:04,000 --> 00:55:08,000
Vi vill göra något till slutet <börja,

776
00:55:08,000 --> 00:55:13,000
men vi vill göra något medan

777
00:55:13,000 --> 00:55:21,000
börja ≤ slut.

778
00:55:21,000 --> 00:55:24,000
>> Det är det omvända logiken där.

779
00:55:24,000 --> 00:55:27,000
Jag är skyldig att göra dessa misstag hela tiden.

780
00:55:27,000 --> 00:55:31,000
[Student] Varför måste det vara mindre än eller lika med?

781
00:55:31,000 --> 00:55:33,000
Eftersom minns du så att vi fick

782
00:55:33,000 --> 00:55:36,000
där det fanns bara en faktor, och vi var nere,

783
00:55:36,000 --> 00:55:43,000
och vi letade i precis 15 i vår grupp?

784
00:55:43,000 --> 00:55:47,000
Och vår början och vår slut var samma element.

785
00:55:47,000 --> 00:55:50,000
Vi vill se till att vi hanterar det fallet.

786
00:55:50,000 --> 00:55:54,000
Om vi ​​gjorde en rak mindre än,

787
00:55:54,000 --> 00:55:58,000
Vi skulle bara kunna komma ner till en 2-inslag array.

788
00:55:58,000 --> 00:56:06,000
När vi kom ner till den sista elementet, om det var vår del, skulle vi aldrig hitta den.

789
00:56:06,000 --> 00:56:10,000
Nu här kan vi göra precis som du sa.

790
00:56:10,000 --> 00:56:15,000
Vi kan börja plopping saker rätt in i mitten av vår while-slinga.

791
00:56:15,000 --> 00:56:20,000
Vi kan plopp i vår mittpunkt.

792
00:56:20,000 --> 00:56:24,000
Vi kan ta alla dessa om uttalanden,

793
00:56:24,000 --> 00:56:30,000
dra dem ur denna gör-while-slinga,

794
00:56:30,000 --> 00:56:34,000
plopp dem,

795
00:56:34,000 --> 00:56:39,000
städa upp saker lite,

796
00:56:39,000 --> 00:56:48,000
och jag ska gå vidare och spara denna översyn.

797
00:56:48,000 --> 00:56:53,000
Och på denna punkt, vi får ganska nära.

798
00:56:53,000 --> 00:56:55,000
Sam.

799
00:56:55,000 --> 00:56:58,000
Jag tror att du också måste ha int mittpunkt = storlek - 1/2.

800
00:56:58,000 --> 00:57:01,000
Fick det, storlek - 1/2.

801
00:57:01,000 --> 00:57:05,000
Finns det något annat vi behöver ändra om den linjen?

802
00:57:05,000 --> 00:57:10,000
Det var en god fångst.

803
00:57:10,000 --> 00:57:14,000
>> Vad gör storlek? Byter vi någonsin storlek?

804
00:57:14,000 --> 00:57:17,000
För att hålla linjen så här måste vi ändra storleken.

805
00:57:17,000 --> 00:57:21,000
Vi måste ändra storleken varje gång vi går runt på slingan.

806
00:57:21,000 --> 00:57:25,000
Men kom ihåg när vi gick igenom vårt exempel bara lite tidigare,

807
00:57:25,000 --> 00:57:30,000
och vi hade i början på 4

808
00:57:30,000 --> 00:57:33,000
och slutet hela vägen över på 108?

809
00:57:33,000 --> 00:57:35,000
Hur kunde vi beräkna mittpunkten?

810
00:57:35,000 --> 00:57:38,000
Om vi ​​använder storlek?

811
00:57:38,000 --> 00:57:40,000
Eller vi använde börjar och slutar i stället?

812
00:57:40,000 --> 00:57:42,000
Det är skillnaden mellan slutet och början.

813
00:57:42,000 --> 00:57:50,000
Exakt, och exakt hur ska jag skriva det, Charlotte?

814
00:57:50,000 --> 00:57:52,000
Bara sluta - börja.

815
00:57:52,000 --> 00:57:55,000
Du skulle inte behöva göra det - 1

816
00:57:55,000 --> 00:57:58,000
eftersom - 1 har inkluderats i slutet och början redan.

817
00:57:58,000 --> 00:58:00,000
[Nate] Stora, du helt rätt.

818
00:58:00,000 --> 00:58:03,000
Vi behöver inte göra det - 1 eftersom det - har 1 tagits

819
00:58:03,000 --> 00:58:08,000
och stod för när vi initiera slutet variabeln.

820
00:58:08,000 --> 00:58:11,000
>> Är det något annat jag behöver göra syntaktiskt ha denna linje vettigt?

821
00:58:11,000 --> 00:58:13,000
[Student] Plus börjar. >> Plus börja?

822
00:58:13,000 --> 00:58:15,000
[Student] i slutet.

823
00:58:15,000 --> 00:58:20,000
Eftersom det är bara beräknat halv längd.

824
00:58:20,000 --> 00:58:26,000
Du måste lägga till börja.

825
00:58:26,000 --> 00:58:31,000
[Nate] Vad skulle detta räkna för oss?

826
00:58:31,000 --> 00:58:35,000
Om vi ​​tänker på slutet på denna första iteration av slingan,

827
00:58:35,000 --> 00:58:40,000
slut kommer att vara på plats index 7.

828
00:58:40,000 --> 00:58:43,000
Börja i läge 0.

829
00:58:43,000 --> 00:58:47,000
Kom ihåg, vi letar efter något

830
00:58:47,000 --> 00:58:52,000
läge 3 eller position 4.

831
00:58:52,000 --> 00:58:56,000
Om vi ​​tittar på den här matte, att bara göra det lite mer konkret,

832
00:58:56,000 --> 00:59:02,000
sätta några siffror här, vi har 7, 0,

833
00:59:02,000 --> 00:59:10,000
så från 7 till 0, och sedan / 2

834
00:59:10,000 --> 00:59:19,000
är 3 i heltalsdivision, dvs.

835
00:59:19,000 --> 00:59:26,000
Då behöver vi sedan lägga tillbaka vår börja?

836
00:59:26,000 --> 00:59:28,000
Vi vill inte i detta fall.

837
00:59:28,000 --> 00:59:31,000
På den allra första iterationen kommer det att vara bra eftersom börja är 0.

838
00:59:31,000 --> 00:59:36,000
Men när vi framsteg gör vi egentligen alla bara behöver

839
00:59:36,000 --> 00:59:42,000
slut - börjar / 2.

840
00:59:42,000 --> 00:59:46,000
Det finns en annan trick här, och det är nämligen en av företräde.

841
00:59:46,000 --> 00:59:49,000
[Student] Behöver vi parentes?

842
00:59:49,000 --> 00:59:53,000
[Nate] Exakt, och det beror på om vi inte sätta dessa parenteser,

843
00:59:53,000 --> 00:59:58,000
då denna linje kommer att tolkas i stället

844
00:59:58,000 --> 01:00:09,000
som (slut) - (börjar / 2), som vi absolut inte vill ha.

845
01:00:09,000 --> 01:00:11,000
Se upp för dessa prioritetsregler regler.

846
01:00:11,000 --> 01:00:15,000
[Student] Varför inte avsluta det + börja?

847
01:00:15,000 --> 01:00:17,000
Varför är det inte slut + börja?

848
01:00:17,000 --> 01:00:19,000
[Student] Varför är det inte det?

849
01:00:19,000 --> 01:00:24,000
Varför skulle det vara +?

850
01:00:24,000 --> 01:00:26,000
Jag tror du har rätt.

851
01:00:26,000 --> 01:00:28,000
[Student] Därför att det är i genomsnitt?

852
01:00:28,000 --> 01:00:31,000
[Nate] Slut + börjar du helt rätt.

853
01:00:31,000 --> 01:00:34,000
Wow, goofed jag helt. Du har rätt.

854
01:00:34,000 --> 01:00:39,000
Om vi ​​gjorde på minus, skulle vi vilja lägga till att börja igen

855
01:00:39,000 --> 01:00:43,000
I det här fallet, är du väldigt rätt i att vi vill ta ett genomsnitt av de två,

856
01:00:43,000 --> 01:00:45,000
så vi vill lägga till dem, i motsats till subtrahera dem.

857
01:00:45,000 --> 01:00:49,000
[Student] Det skulle också fungera om du gjorde slut - börjar / 2 + börja.

858
01:00:49,000 --> 01:00:55,000
Det skulle om vi gör-Jag tror det.

859
01:00:55,000 --> 01:01:00,000
>> Till exempel, om vi tittar på början,

860
01:01:00,000 --> 01:01:04,000
och vi flyttas den hit

861
01:01:04,000 --> 01:01:08,000
till 15.

862
01:01:08,000 --> 01:01:12,000
Nu börjar är i position 2.

863
01:01:12,000 --> 01:01:15,000
End är i position 7.

864
01:01:15,000 --> 01:01:21,000
Om vi ​​subtraherar dem, får vi 5.

865
01:01:21,000 --> 01:01:24,000
Dividera det med 2, får vi 2.

866
01:01:24,000 --> 01:01:27,000
Och då lägger vi till 2 tillbaka,

867
01:01:27,000 --> 01:01:30,000
och som får oss att den 4: e positionen,

868
01:01:30,000 --> 01:01:33,000
vilket är just här, vilket är mittpunkten.

869
01:01:33,000 --> 01:01:36,000
[Student] Behöver vi ta hand om emballage?

870
01:01:36,000 --> 01:01:39,000
I vilken mening behöver vi ta hand om omslag?

871
01:01:39,000 --> 01:01:43,000
Om summan eller skillnaden mellan

872
01:01:43,000 --> 01:01:45,000
beroende på hur vi gör det inte är ett jämnt tal.

873
01:01:45,000 --> 01:01:49,000
Då datorn blir förvirrad om när det är 2,5;

874
01:01:49,000 --> 01:01:52,000
behöver du flytta till vänster eller till höger för att avgöra vilken som är mittpunkten?

875
01:01:52,000 --> 01:01:54,000
Fick det.

876
01:01:54,000 --> 01:01:56,000
Det visar sig att med heltalsdivision,

877
01:01:56,000 --> 01:01:59,000
vi inte någonsin få dessa flyttal.

878
01:01:59,000 --> 01:02:01,000
Vi får aldrig decimal.

879
01:02:01,000 --> 01:02:04,000
Det är helt kasseras.

880
01:02:04,000 --> 01:02:08,000
Om du har en dator dela två int variabler,

881
01:02:08,000 --> 01:02:11,000
och en är 7, och den andra är 2,

882
01:02:11,000 --> 01:02:13,000
du kommer inte få 3,5 som följd.

883
01:02:13,000 --> 01:02:16,000
Det kommer att bli 3.

884
01:02:16,000 --> 01:02:19,000
Resten kommer att kasseras, så det är faktiskt avrundning

885
01:02:19,000 --> 01:02:24,000
inte en runda utan ett golv, om ni känner till att det i matematik,

886
01:02:24,000 --> 01:02:27,000
där du slänger helt decimal,

887
01:02:27,000 --> 01:02:31,000
och så att du i huvudsak trunkering ner till närmaste

888
01:02:31,000 --> 01:02:33,000
Sammanlagt positioner, till närmaste heltal.

889
01:02:33,000 --> 01:02:38,000
[Student] Men så är det problematiskt eftersom om du har en uppsättning av 7 element

890
01:02:38,000 --> 01:02:43,000
då tar automatiskt den 3: e delen ur mittpunkten istället för 4th.

891
01:02:43,000 --> 01:02:46,000
Hur hanterar vi det?

892
01:02:46,000 --> 01:02:49,000
Det är problematiskt eftersom om vi hade en matris med 7,

893
01:02:49,000 --> 01:02:54,000
Det skulle plocka den 3: e istället för 4th.

894
01:02:54,000 --> 01:02:56,000
Kan du förklara lite mer?

895
01:02:56,000 --> 01:02:59,000
[Student] För om du har 7 element då den 4: e elementet

896
01:02:59,000 --> 01:03:04,000
skulle vara mittpunkten, eller hur?

897
01:03:04,000 --> 01:03:07,000
Kom ihåg din kommentar om att vara noll indexerade, dock.

898
01:03:07,000 --> 01:03:10,000
[Student] Ja, så i position 3. Det skulle vara mittpunkten.

899
01:03:10,000 --> 01:03:12,000
Ja.

900
01:03:12,000 --> 01:03:16,000
Åh, okej. Jag förstår vad du menar.

901
01:03:16,000 --> 01:03:19,000
Det är lite konstigt, eftersom vi vänjer hela denna föreställning om

902
01:03:19,000 --> 01:03:22,000
att bli av med decimaler.

903
01:03:22,000 --> 01:03:26,000
Det är en bra plats.

904
01:03:26,000 --> 01:03:30,000
Låt oss avsluta det här.

905
01:03:30,000 --> 01:03:32,000
Vi har beräknat vår mittpunkt.

906
01:03:32,000 --> 01:03:37,000
>> Vi testar för att se om vårt nål är lika med det mittersta värdet.

907
01:03:37,000 --> 01:03:41,000
Vi skriver att vi hittat det, men egentligen, vad vi vill göra i denna situation?

908
01:03:41,000 --> 01:03:46,000
Vi har hittat det, så vi vill låta den som ringer vet att vi hittat den.

909
01:03:46,000 --> 01:03:49,000
Vi har en funktion som är ett booleskt skrivit funktion.

910
01:03:49,000 --> 01:03:54,000
Hur vi signalerar till den som ringer på vår funktion som vi är redo att gå

911
01:03:54,000 --> 01:03:58,000
är vi säger, "Hej, det är sant."

912
01:03:58,000 --> 01:04:00,000
Hur skulle vi göra det, Kevin?

913
01:04:00,000 --> 01:04:02,000
Du nickar huvudet. >> [Kevin] Lägg tillbaka sant.

914
01:04:02,000 --> 01:04:06,000
[Nate] Exakt, return true.

915
01:04:06,000 --> 01:04:12,000
Nu, om det inte är lika, hur skulle vi se på den vänstra halvan?

916
01:04:12,000 --> 01:04:16,000
Några idéer?

917
01:04:16,000 --> 01:04:18,000
Stella, några idéer?

918
01:04:18,000 --> 01:04:21,000
Du måste ange en ny position för slutet.

919
01:04:21,000 --> 01:04:23,000
Ja.

920
01:04:23,000 --> 01:04:29,000
Så vi måste göra läge mittpunkt - slutet.

921
01:04:29,000 --> 01:04:33,000
Jättebra.

922
01:04:33,000 --> 01:04:36,000
Vi måste ställa en ny position för slutet

923
01:04:36,000 --> 01:04:38,000
att titta på den vänstra halvan.

924
01:04:38,000 --> 01:04:41,000
Det var vad vi pratade om innan där

925
01:04:41,000 --> 01:04:44,000
Jag hålla gå tillbaka till detta exempel.

926
01:04:44,000 --> 01:04:50,000
Jag har börja här och så har jag slut hela vägen hit.

927
01:04:50,000 --> 01:04:53,000
>> Återigen, om vi letar efter 15, och vår mittpunkt är 16,

928
01:04:53,000 --> 01:04:56,000
och vi inser, "Oj, är 16 större.

929
01:04:56,000 --> 01:04:59,000
Vi vill flytta till den vänstra halvan. "

930
01:04:59,000 --> 01:05:02,000
Vi skulle då flytta slut på 15,

931
01:05:02,000 --> 01:05:06,000
och vi gör det genom att ta en från mittpunkten

932
01:05:06,000 --> 01:05:09,000
och ställa in det som vår nya ände.

933
01:05:09,000 --> 01:05:12,000
Likaså om vi vill titta på den högra, hur skulle vi göra det?

934
01:05:12,000 --> 01:05:14,000
Har du en idé?

935
01:05:14,000 --> 01:05:22,000
[Student] Du anger bara att börja mittpunkten + 1.

936
01:05:22,000 --> 01:05:24,000
[Nate] Great.

937
01:05:24,000 --> 01:05:29,000
Och nu när det gäller att vi inte hittar något,

938
01:05:29,000 --> 01:05:32,000
blir det tas om hand för oss?

939
01:05:32,000 --> 01:05:36,000
Daniel, det som får tas om hand för oss?

940
01:05:36,000 --> 01:05:38,000
[Daniel] Nej

941
01:05:38,000 --> 01:05:40,000
[Nate] Om vi ​​gör det genom hela matrisen och vi inte hitta något,

942
01:05:40,000 --> 01:05:42,000
där skulle det tas om hand, eller ska vi ta hand om det?

943
01:05:42,000 --> 01:05:44,000
[Daniel] Den tag skick.

944
01:05:44,000 --> 01:05:48,000
[Nate] Ja, tiden skick, exakt.

945
01:05:48,000 --> 01:05:51,000
Det kommer att ta hand om att gå igenom hela arrayen om vi inte hittar något.

946
01:05:51,000 --> 01:05:53,000
Denna while-slinga kommer att sluta.

947
01:05:53,000 --> 01:05:56,000
Vi kommer aldrig stött på detta villkor,

948
01:05:56,000 --> 01:06:03,000
och vi kan returnera false.

949
01:06:03,000 --> 01:06:10,000
Vi kan också lämna detta om här så här

950
01:06:10,000 --> 01:06:14,000
för om detta om påståendet är sant,

951
01:06:14,000 --> 01:06:16,000
och vår funktion kommer tillbaka,

952
01:06:16,000 --> 01:06:21,000
och så vi i huvudsak avbryta denna funktion på denna punkt

953
01:06:21,000 --> 01:06:24,000
när vi kommer tillbaka sant.

954
01:06:24,000 --> 01:06:28,000
Men vad händer med denna struktur här?

955
01:06:28,000 --> 01:06:34,000
Kommer detta att fungera helt, eller finns det någon logisk brist i det?

956
01:06:34,000 --> 01:06:37,000
>> Det finns vissa logiska fel i det, med hur det inrättas.

957
01:06:37,000 --> 01:06:40,000
Vad kan det vara?

958
01:06:40,000 --> 01:06:43,000
[Student] Varför du behöver - och + 1s?

959
01:06:43,000 --> 01:06:47,000
Som sätter vår grupp för att vara vår nya vänstra och högra halvan.

960
01:06:47,000 --> 01:06:51,000
[Student] Men varför kunde du inte göra det utan - 1s och + 1s?

961
01:06:51,000 --> 01:06:53,000
[Nate] Vi kan ställa in den lika med mittpunkten?

962
01:06:53,000 --> 01:07:04,000
Vad kan vara problematiskt om det?

963
01:07:04,000 --> 01:07:08,000
[Student] Jag antar att det är ineffektivt eftersom du kollar ett värde som redan har kontrollerats.

964
01:07:08,000 --> 01:07:11,000
[Nate] Exakt, så Sam är helt rätt.

965
01:07:11,000 --> 01:07:15,000
Om du ställer in slutet och börjar lika mittpunkten

966
01:07:15,000 --> 01:07:18,000
istället för - 1 och + 1 eftertänksamt,

967
01:07:18,000 --> 01:07:22,000
någon gång i framtiden kommer vi att hamna kontrollera mittpunkten igen.

968
01:07:22,000 --> 01:07:26,000
[Student] Jag började pset, och sedan hade jag något liknande

969
01:07:26,000 --> 01:07:30,000
där jag glömde + 1, och det fastnade i en oändlig loop.

970
01:07:30,000 --> 01:07:34,000
Rätt, för någon gång att du aldrig kommer att få börja och sluta

971
01:07:34,000 --> 01:07:39,000
att faktiskt överlappar.

972
01:07:39,000 --> 01:07:41,000
Cool.

973
01:07:41,000 --> 01:07:44,000
Det finns en mer logisk brist, och det är att det definitivt bör vara

974
01:07:44,000 --> 01:07:48,000
en annan om.

975
01:07:48,000 --> 01:07:55,000
Varför kan det vara?

976
01:07:55,000 --> 01:07:59,000
>> Anledningen är om det inte är en annan om-såg du det, Kevin?

977
01:07:59,000 --> 01:08:02,000
[Kevin] Ja, eftersom du ändrar slutpunkten.

978
01:08:02,000 --> 01:08:05,000
[Nate] Exakt.

979
01:08:05,000 --> 01:08:07,000
Vi ändrar slutpunkten,

980
01:08:07,000 --> 01:08:12,000
och om den är skriven så här-Vi gör utrymmena mellan-

981
01:08:12,000 --> 01:08:14,000
Det kommer att kontrollera det här fallet.

982
01:08:14,000 --> 01:08:18,000
Detta fall, om den lyckas, avbryter ur funktion.

983
01:08:18,000 --> 01:08:21,000
Sedan kommer det att kontrollera detta nästa fall,

984
01:08:21,000 --> 01:08:24,000
och om det lyckas, kommer det att justera slutpunkt,

985
01:08:24,000 --> 01:08:28,000
och så kommer det att fortsätta på och kolla det här fallet.

986
01:08:28,000 --> 01:08:31,000
Men på denna punkt, vill vi inte att fortsätta att kontrollera.

987
01:08:31,000 --> 01:08:35,000
Lyckligtvis har återställt vi inte mittpunkten här,

988
01:08:35,000 --> 01:08:39,000
och vi vet att detta fall inte kommer att lyckas.

989
01:08:39,000 --> 01:08:44,000
Men vi vill absolut sätta else if där

990
01:08:44,000 --> 01:08:48,000
även om det kanske i det här fallet

991
01:08:48,000 --> 01:08:52,000
eftersom vi inte justerar mittpunkten, skulle det göra någon skillnad?

992
01:08:52,000 --> 01:08:54,000
Nej, eftersom dessa fall är alla exklusiva.

993
01:08:54,000 --> 01:08:58,000
Återigen, min dåliga.

994
01:08:58,000 --> 01:09:01,000
Vi inte, tror jag, behöver detta annars om.

995
01:09:01,000 --> 01:09:05,000
Vi kan ge det ett försök och köra den och se vad som händer.

996
01:09:05,000 --> 01:09:08,000
Byggnad, inträffade ett fel.

997
01:09:08,000 --> 01:09:12,000
Det är förmodligen därför jag lämnade dessa B och E: s här.

998
01:09:12,000 --> 01:09:14,000
Har jag några fler av dem upp på toppen?

999
01:09:14,000 --> 01:09:16,000
Det ser inte ut som det.

1000
01:09:16,000 --> 01:09:20,000
Vi zoomar ut, bygga,

1001
01:09:20,000 --> 01:09:24,000
där det går, så nu när vi söker efter 15,

1002
01:09:24,000 --> 01:09:28,000
Ja.

1003
01:09:28,000 --> 01:09:30,000
Låt mig zooma in

1004
01:09:30,000 --> 01:09:33,000
15, ja. Vi kan köra den igen.

1005
01:09:33,000 --> 01:09:36,000
Uppladdning källkod, bygga, löpning.

1006
01:09:36,000 --> 01:09:41,000
Vi kan söka efter något som 13,

1007
01:09:41,000 --> 01:09:45,000
och vi får ingenting skrivs ut, så det är inte att hitta det för oss.

1008
01:09:45,000 --> 01:09:51,000
Det är bra, för det är inte i vår lista.

1009
01:09:51,000 --> 01:09:53,000
>> Vi är nu för sent.

1010
01:09:53,000 --> 01:09:55,000
Det kommer att vara det för den här veckan.

1011
01:09:55,000 --> 01:10:00,000
Tack för sammanfogning och ses senare.

1012
01:10:00,000 --> 01:10:02,000
>> [CS50.TV]