1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Návod] [Problém Set 3]

2
00:00:03,000 --> 00:00:05,000
[Zamyla Chan] [Harvard University]

3
00:00:05,000 --> 00:00:08,000
[To je CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
Dobře, vítejte všichni na Walkthrough 3.

5
00:00:10,000 --> 00:00:12,000
Pset 3 je opravdu legrace jeden.

6
00:00:12,000 --> 00:00:14,000
Je to nový, kdo CS50 tzv. Scramble,

7
00:00:14,000 --> 00:00:18,000
takže pokud jste někdy hráli skrumáž nebo podobný stolní hru vylekat

8
00:00:18,000 --> 00:00:20,000
v podstatě je to hra, kde musíte mřížku dopisů,

9
00:00:20,000 --> 00:00:24,000
a v přiděleném čase budete muset najít co nejvíce

10
00:00:24,000 --> 00:00:28,000
2-dopis nebo delší slova, která existují na palubě,

11
00:00:28,000 --> 00:00:32,000
a tak existují určitá pravidla, jako je můžete používat pouze jedno písmeno

12
00:00:32,000 --> 00:00:37,000
v mřížce, jeden blok v mřížce jednou, a můžete se vrátit zpět k němu.

13
00:00:37,000 --> 00:00:42,000
Můžete vytvářet písmena propojením sousedních písmen,

14
00:00:42,000 --> 00:00:50,000
takže to bude opravdu zábava Pset, tak se pojďme podívat na naši nástrojů.

15
00:00:50,000 --> 00:00:53,000
>> Opět, je spotřebič stále aktualizována, takže se ujistěte,

16
00:00:53,000 --> 00:00:56,000
pokaždé, když vstoupí přístroj doprava otevřete okno terminálu

17
00:00:56,000 --> 00:01:02,000
a na svorkách udělat příkaz sudo yum-y update.

18
00:01:02,000 --> 00:01:04,000
To je důležité také, pokud chcete mít možnost

19
00:01:04,000 --> 00:01:06,000
 spustit služební řešení, které jsme rozhodně doporučujeme.

20
00:01:06,000 --> 00:01:09,000
Někdy je to dobré, jakmile skončíte svůj kód

21
00:01:09,000 --> 00:01:12,000
to vyzkoušet proti zaměstnanci řešení, ujistěte se, že vše, co

22
00:01:12,000 --> 00:01:15,000
zadáte do personální řešení, co přijde tam,

23
00:01:15,000 --> 00:01:18,000
totéž, co se stane s vaším kódem.

24
00:01:18,000 --> 00:01:20,000
Dobře, takže se ujistěte, aktualizujte si spotřebič.

25
00:01:20,000 --> 00:01:23,000
Nyní, i, protože jsme řešení s mřížkou v tomto případě

26
00:01:23,000 --> 00:01:26,000
jsme vlastně bude se pustíme do 2-rozměrné pole.

27
00:01:26,000 --> 00:01:28,000
My jsem se zabýval 1-rozměrné pole,

28
00:01:28,000 --> 00:01:31,000
ale nyní budeme rozšiřovat je tak, že mají

29
00:01:31,000 --> 00:01:35,000
více řádků, stejně jako více sloupců.

30
00:01:35,000 --> 00:01:38,000
Pak budeme určitě používat funkce v tomto PSet,

31
00:01:38,000 --> 00:01:43,000
v podstatě volání funkce, odesílání některých parametrů z

32
00:01:43,000 --> 00:01:46,000
a pak se dostat návratovou hodnotu zpět.

33
00:01:46,000 --> 00:01:50,000
A v Scramble jsme vás nežádám, aby skutečně udělat celou věc od začátku,

34
00:01:50,000 --> 00:01:53,000
ale spíše jsme vlastně dává vám něco, co nazývá distribuce kód,

35
00:01:53,000 --> 00:01:56,000
tak kód funkce, které jsme již napsali, že druh stanovuje

36
00:01:56,000 --> 00:02:00,000
kostra PSet stejně jako se provádějí některá z tvrdších věcí

37
00:02:00,000 --> 00:02:04,000
že budete určitě moci přečíst a pochopit

38
00:02:04,000 --> 00:02:10,000
ale nemusí zcela, aby to ještě.

39
00:02:10,000 --> 00:02:15,000
>> Chcete-li rychle předělávka nad 1-rozměrné pole.

40
00:02:15,000 --> 00:02:18,000
Pole jsou datové struktury, které drží více hodnot stejného typu,

41
00:02:18,000 --> 00:02:21,000
a jako připomínka, tato pole jsou nulové indexované,

42
00:02:21,000 --> 00:02:26,000
takže většina z vás pravděpodobně obeznámeni s řadou, jako je tato.

43
00:02:26,000 --> 00:02:29,000
Pokud bychom chtěli int pole s délkou 3,

44
00:02:29,000 --> 00:02:32,000
pak bychom mohli ji inicializovat s int hodnot

45
00:02:32,000 --> 00:02:35,000
a pak hranaté závorky označující délku tom,

46
00:02:35,000 --> 00:02:39,000
a pak bychom přiřadit hodnoty specifických prvků v daném poli.

47
00:02:39,000 --> 00:02:44,000
Zde máme int pole s první index na indexu 0, 2,

48
00:02:44,000 --> 00:02:47,000
index 1 je 4, index 2 je 6.

49
00:02:47,000 --> 00:02:52,000
Řekněme, že jsme chtěli větší pole a držet více hodnot.

50
00:02:52,000 --> 00:02:55,000
Pak bychom mohli mít 2D pole.

51
00:02:55,000 --> 00:02:58,000
Nyní, to je velmi podobná naší 1-rozměrné pole.

52
00:02:58,000 --> 00:03:02,000
Je to 0 indexovány, takže to znamená, že první sloupec

53
00:03:02,000 --> 00:03:04,000
je indexována na 0.

54
00:03:04,000 --> 00:03:07,000
Další je na 1, a pak další je na 2,

55
00:03:07,000 --> 00:03:11,000
a poté podobně máme řádky, a tak vidíte, že když jsme

56
00:03:11,000 --> 00:03:15,000
prohlásit naší nabídku také, stejně jako před-jsme uvedli velikost pole.

57
00:03:15,000 --> 00:03:18,000
Také podobně ukazují velikost, kde první držák

58
00:03:18,000 --> 00:03:21,000
udává, kolik řádků máte, a druhá označuje

59
00:03:21,000 --> 00:03:25,000
kolik sloupců.

60
00:03:25,000 --> 00:03:30,000
>> Dobře, v tomto PSet budete chtít mít možnost

61
00:03:30,000 --> 00:03:35,000
iteraci 2D pole, přístup k každý element

62
00:03:35,000 --> 00:03:39,000
v této 2D pole, takže v podstatě chcete dosáhnout

63
00:03:39,000 --> 00:03:42,000
všechny možné kombinace řádku a sloupce hodnot.

64
00:03:42,000 --> 00:03:47,000
Chceme dosáhnout řádek 0 ve sloupci 1, 2, 3 a.

65
00:03:47,000 --> 00:03:54,000
Chceme dosáhnout řádek 1 ve sloupci 0, 1 a 2.

66
00:03:54,000 --> 00:03:58,000
Musíme mít nějaký struktury, která nám umožní

67
00:03:58,000 --> 00:04:02,000
iteraci přes všechny řádky a všechny kombinace

68
00:04:02,000 --> 00:04:08,000
sloupců v rámci které.

69
00:04:08,000 --> 00:04:10,000
Tady mám 2D int pole.

70
00:04:10,000 --> 00:04:14,000
Má 3 řádky a 3 sloupce,

71
00:04:14,000 --> 00:04:19,000
a tak je rychlý způsob

72
00:04:19,000 --> 00:04:22,000
najít celou 2D pole.

73
00:04:22,000 --> 00:04:25,000
Říkám první řadě bude mít 2, 4, a 6,

74
00:04:25,000 --> 00:04:30,000
druh obdobné jako v předchozím příkladu v tomto snímku.

75
00:04:30,000 --> 00:04:35,000
Pak budu mít 2. řádek je 3, 6, 9,

76
00:04:35,000 --> 00:04:39,000
a pak 3. řádek je 4, 8, 12.

77
00:04:39,000 --> 00:04:43,000
Máme 2D pole,

78
00:04:43,000 --> 00:04:46,000
a víme, že to vypadá takhle.

79
00:04:46,000 --> 00:04:52,000
Máme 2, 4, 6,

80
00:04:52,000 --> 00:04:55,000
3, 6, 9,

81
00:04:55,000 --> 00:05:02,000
4, 8, 12.

82
00:05:02,000 --> 00:05:05,000
Nyní, když přidáme do indexů,

83
00:05:05,000 --> 00:05:08,000
by to bylo řádek 0.

84
00:05:08,000 --> 00:05:11,000
To by bylo řádek 1.

85
00:05:11,000 --> 00:05:13,000
To by bylo řádek 2.

86
00:05:13,000 --> 00:05:19,000
Podobně máme sloupec 0,

87
00:05:19,000 --> 00:05:23,000
sloupec 1 a sloupec 2.

88
00:05:23,000 --> 00:05:25,000
Ano.

89
00:05:25,000 --> 00:05:28,000
[Muž] Které tři jsou sloupce, a který z nich je řádek?

90
00:05:28,000 --> 00:05:31,000
Sloupce jsou tyhle,

91
00:05:31,000 --> 00:05:34,000
takže vaše sloupce jsou tyhle.

92
00:05:34,000 --> 00:05:37,000
To je sloupec 0, a to je ve sloupci 1.

93
00:05:37,000 --> 00:05:39,000
To je sloupec 2.

94
00:05:39,000 --> 00:05:44,000
[Muž] Kolik v prohlášení int ke stolu [3] [3]?

95
00:05:44,000 --> 00:05:50,000
Když jste s prohlášením o 2D pole, pak první číslo v hranatých závorkách

96
00:05:50,000 --> 00:05:53,000
bude, kolik řádků máte,

97
00:05:53,000 --> 00:05:57,000
a pak druhý bude kolik sloupců.

98
00:05:57,000 --> 00:06:01,000
>> Skvělé, tak chceme nějakou strukturu,

99
00:06:01,000 --> 00:06:06,000
nějaký smyčky, co se děje, aby nám všechny možné kombinace.

100
00:06:06,000 --> 00:06:13,000
Řekněme, že jsme se začít tím, v pořádku, přejděte něco v tomto řádku,

101
00:06:13,000 --> 00:06:18,000
řekněme, podívej se na tuto řádku pro tuto chvíli.

102
00:06:18,000 --> 00:06:20,000
Jedná se o řádky zde.

103
00:06:20,000 --> 00:06:23,000
Víme, že náš index řádku bude 0,

104
00:06:23,000 --> 00:06:27,000
ale k této prvku je to na 0. řádku a sloupci 0.,

105
00:06:27,000 --> 00:06:34,000
takže pak bychom přistupovat indexem [0] [0].

106
00:06:34,000 --> 00:06:38,000
Pak je tato jedna, podobně, je stále na prvním řádku,

107
00:06:38,000 --> 00:06:43,000
ale je to na druhém sloupci, takže jsme přístup, že [0] [1].

108
00:06:43,000 --> 00:06:48,000
Pak poslední by [0] [2].

109
00:06:48,000 --> 00:06:52,000
Kdykoliv jsme na konkrétní řádek budeme chtít

110
00:06:52,000 --> 00:07:00,000
iteraci všech možných hodnot sloupců.

111
00:07:00,000 --> 00:07:06,000
Pojďme začít s pro smyčce

112
00:07:06,000 --> 00:07:15,000
že začíná na hodnotě 0, a jde do délky, kolik řádků máme.

113
00:07:15,000 --> 00:07:26,000
To je na kole přes každý řádek.

114
00:07:26,000 --> 00:07:29,000
Pak to, co chceme udělat, je v to, že

115
00:07:29,000 --> 00:07:33,000
když jsme na konkrétní řádek chceme procházet všechny dostupné sloupce,

116
00:07:33,000 --> 00:07:36,000
takže pak budeme mít další smyčku.

117
00:07:36,000 --> 00:07:38,000
Říkejme tomu j.

118
00:07:38,000 --> 00:07:42,000
I, j a k jsou velmi časté řadové proměnné indexování smyčka,

119
00:07:42,000 --> 00:07:48,000
takže můžete použít tyto, pokud se vám líbí.

120
00:07:48,000 --> 00:07:52,000
Také se snaží, aby se zabránilo pak-li se tyto proměnné běžně používané ve smyčkách

121
00:07:52,000 --> 00:07:56,000
snažte se vyhnout jejich použití jako jsou názvy proměnných pro jiné věci ve vašem kódu

122
00:07:56,000 --> 00:08:04,000
jen proto, že je to obyčejná konvence používat i, j, a k. uvnitř smyčky nebo indexy.

123
00:08:04,000 --> 00:08:11,000
Dobře, pak zde máme pro smyčce, která iteruje přes všechny řádky.

124
00:08:11,000 --> 00:08:14,000
Pak pokaždé, když je to na jiném řádku

125
00:08:14,000 --> 00:08:17,000
budeme iteraci všech různých sloupců.

126
00:08:17,000 --> 00:08:23,000
Tímto způsobem můžeme skutečně dostat do všech možných kombinací

127
00:08:23,000 --> 00:08:27,000
z 0, 1 a 2 s 0, 1 a 2.

128
00:08:27,000 --> 00:08:29,000
To smysl?

129
00:08:29,000 --> 00:08:32,000
Tímto způsobem jsme schopni pro přístup přes každou hodnotu.

130
00:08:32,000 --> 00:08:36,000
Nyní, mohli jsme se rozhodli udělat sloupce první i.

131
00:08:36,000 --> 00:08:39,000
Je to opravdu nezáleží na tom, jak dlouho budete iterovat

132
00:08:39,000 --> 00:08:41,000
všechny sloupce a všechny řádky.

133
00:08:41,000 --> 00:08:44,000
>> Teď pojďme něco udělat s těmito hodnotami.

134
00:08:44,000 --> 00:08:48,000
Řekněme, že tisk.

135
00:08:48,000 --> 00:08:55,000
Nyní se pojďme tisknout své celá čísla

136
00:08:55,000 --> 00:09:02,000
a pak se proměnná na tomto místě je-to bude hodnota n tabulka.

137
00:09:02,000 --> 00:09:07,000
Nyní konkrétní index řádku bude i proto, že jsme, že k iteraci našich řadách,

138
00:09:07,000 --> 00:09:14,000
a potom j iterovat prostřednictvím našich sloupcích.

139
00:09:14,000 --> 00:09:24,000
Nyní pojďme udělat 2D.

140
00:09:24,000 --> 00:09:29,000
Teď, když jsme se spustit 2D vypíše všechny hodnoty

141
00:09:29,000 --> 00:09:32,000
v pořadí, v jakém se výše uvedené,

142
00:09:32,000 --> 00:09:35,000
tak vidíte, že to jde přes všechny řádky první,

143
00:09:35,000 --> 00:09:38,000
tak, že je to na řádek 0, a pak se vytiskne všechny hodnoty v této řadě

144
00:09:38,000 --> 00:09:40,000
a pak pokračuje.

145
00:09:40,000 --> 00:09:43,000
To je příklad způsobem, jakým iteraci

146
00:09:43,000 --> 00:09:52,000
a provádět akce na hodnotách v rámci 2D pole.

147
00:09:52,000 --> 00:09:59,000
Skvělé, teď, co uvidíme v distribuční kódu je mnoho funkcí,

148
00:09:59,000 --> 00:10:01,000
a tak některé z těchto funkcí bude boolean funkce

149
00:10:01,000 --> 00:10:03,000
kde oni se vrátí boolean pro vás.

150
00:10:03,000 --> 00:10:07,000
>> Některé z nich jsou celá čísla, například, a tak v podstatě

151
00:10:07,000 --> 00:10:10,000
Přezkum funguje trochu zásadě to funguje tak mají

152
00:10:10,000 --> 00:10:15,000
návratová hodnota, jméno, pomocí kterého můžete použít k volání programu,

153
00:10:15,000 --> 00:10:21,000
a pak může mít libovolný počet parametrů.

154
00:10:21,000 --> 00:10:25,000
V podstatě při volání funkce v rámci další funkce,

155
00:10:25,000 --> 00:10:27,000
v podstatě jako říkáš teď chci, abyste tuto funkci provedete,

156
00:10:27,000 --> 00:10:31,000
musíte projít v určitých hodnotách, takže v tomto případě je naše funkce foo

157
00:10:31,000 --> 00:10:36,000
bude muset vzít 2 celá čísla, a do této funkce pak

158
00:10:36,000 --> 00:10:40,000
bylo by k nim mají přístup, se na ně odkazovat jako x a y.

159
00:10:40,000 --> 00:10:44,000
Podobný příklad je nižší funkce

160
00:10:44,000 --> 00:10:48,000
které jste možná použity ve vašem programu kryptografické,

161
00:10:48,000 --> 00:10:51,000
a tak v podstatě tyto funkce již byly psány pro vás,

162
00:10:51,000 --> 00:10:57,000
ale v závislosti na jejich zpáteční typu můžete použít ve funkcích.

163
00:10:57,000 --> 00:11:00,000
Řekněme, že máte logickou funkci nazvanou foo.

164
00:11:00,000 --> 00:11:04,000
Pak byste mohli použít, protože víte, že to bude představovat boolean.

165
00:11:04,000 --> 00:11:06,000
V podstatě, když říkáte, že se vrátí zpět boolean,

166
00:11:06,000 --> 00:11:11,000
takže můžete léčit, že to bude představovat boolean.

167
00:11:11,000 --> 00:11:13,000
V rámci svého stavu, můžete jednoduše říct

168
00:11:13,000 --> 00:11:17,000
pokud foo, a pak předat ve svých požadovaných parametrů,

169
00:11:17,000 --> 00:11:20,000
5 a 9 například, 2 celá čísla,

170
00:11:20,000 --> 00:11:22,000
pak víte, že se vrátí true nebo false,

171
00:11:22,000 --> 00:11:26,000
a tak pak můžete použít jako svého stavu sám.

172
00:11:26,000 --> 00:11:30,000
Podobně můžete také říci, foo (5, 9) == true

173
00:11:30,000 --> 00:11:33,000
nebo == false, nebo něco takového,

174
00:11:33,000 --> 00:11:38,000
ale, že je o něco zbytečné, protože samotnou funkci

175
00:11:38,000 --> 00:11:41,000
již hodnoty buď true nebo false.

176
00:11:41,000 --> 00:11:47,000
Budeme mít na paměti, když vidíme několik příkladů v distribučním kódu.

177
00:11:47,000 --> 00:11:50,000
>> Dobrá, zpět k Scramble poté, co jsme se 2D pole

178
00:11:50,000 --> 00:11:53,000
a pochopení funkce v rámci našich pásů.

179
00:11:53,000 --> 00:11:59,000
V Scramble podstatě budete mít mřížku dopisů,

180
00:11:59,000 --> 00:12:02,000
a pak budete pomáhat realizovat program

181
00:12:02,000 --> 00:12:06,000
přičemž uživatel může zadat různé dopisy, které vidíte na roštu,

182
00:12:06,000 --> 00:12:10,000
tak to také znamená, že vy jste také bude muset čerpat hrací desku.

183
00:12:10,000 --> 00:12:13,000
Pak bude uživatel zadáním určitá slova,

184
00:12:13,000 --> 00:12:17,000
ale budete muset zjistit,, zda tato slova jsou platné ve slovníku,

185
00:12:17,000 --> 00:12:23,000
nebo B, se, že skutečně existují v desce, lze nalézt v desce.

186
00:12:23,000 --> 00:12:28,000
Pak v distribuční kódu půjdeme přes, že ve druhé.

187
00:12:28,000 --> 00:12:31,000
Uvidíte, co už za vás,

188
00:12:31,000 --> 00:12:35,000
a pak se v daném struktury distribuční kódu přidat funkce.

189
00:12:35,000 --> 00:12:37,000
Existují některé funkce, které jsou ponechány prázdné.

190
00:12:37,000 --> 00:12:40,000
Existují některé funkce, které stačí jen přidat do.

191
00:12:40,000 --> 00:12:43,000
Určitá funkce, které budete pracovat s je remíza,

192
00:12:43,000 --> 00:12:45,000
takže budete muset implementovat funkce Draw,

193
00:12:45,000 --> 00:12:47,000
vlastně čerpání všechna písmena na desce.

194
00:12:47,000 --> 00:12:51,000
Budeš muset implementovat vyhledávací funkci, kdy budete muset zkontrolovat

195
00:12:51,000 --> 00:12:55,000
zda řetězec, že ​​zadává uživatel je platný slovo,

196
00:12:55,000 --> 00:12:59,000
a tak potom, jak jsem se zmínil výše, která zahrnuje ať už je to ve slovníku, nebo ne

197
00:12:59,000 --> 00:13:03,000
stejně jako to, zda je to platné hra tah.

198
00:13:03,000 --> 00:13:06,000
Pak budete provádět skrumáž

199
00:13:06,000 --> 00:13:11,000
kde do hry, pokud je uživatel, například, potíže najít jakékoliv slovo

200
00:13:11,000 --> 00:13:16,000
pak v případě, že psát v "Scramble" do řádku

201
00:13:16,000 --> 00:13:19,000
pak hrací skutečně otáčí o 90 °,

202
00:13:19,000 --> 00:13:24,000
zachování stejných písmen, ale jen otáčením po směru hodinových ručiček 90 °.

203
00:13:24,000 --> 00:13:27,000
A pak konečně budeme zabývat s pouzdrem a citlivosti,

204
00:13:27,000 --> 00:13:35,000
v podstatě, když všechny ze slov ve slovníku součástí distribučního kódu

205
00:13:35,000 --> 00:13:38,000
jsou uloženy jako velká, ale chceme-li umožnit uživateli, například,

206
00:13:38,000 --> 00:13:41,000
když se do směsi v malých a velkých

207
00:13:41,000 --> 00:13:45,000
nebo jen malá písmena a pak, pokud to slovo je platné

208
00:13:45,000 --> 00:13:50,000
pak by měly mít možnost získat body za to stejně.

209
00:13:50,000 --> 00:13:56,000
>> Dobře, tak distribuční kódu, může to být trochu těžké se dostat přes na první pohled.

210
00:13:56,000 --> 00:13:59,000
Možná se vám nebude chtít číst všechno a jen tak rovnou do

211
00:13:59,000 --> 00:14:03,000
psaní programu, ale prosím, přečtěte si to jednou,

212
00:14:03,000 --> 00:14:06,000
číst dvakrát, přečetl třikrát, přečtěte si ji znovu a znovu

213
00:14:06,000 --> 00:14:09,000
tak, že budete mít dobrý pocit, a může cítit opravdu pohodlně

214
00:14:09,000 --> 00:14:13,000
s kódem, i když jste nenapsal tyto funkce sám,

215
00:14:13,000 --> 00:14:17,000
že tak nějak vědí, co dělají, a můžete očekávat

216
00:14:17,000 --> 00:14:22,000
tak, že by mohly interagovat s funkcemi, které vám umožní realizovat.

217
00:14:22,000 --> 00:14:25,000
Bez dalších okolků, pojďme skutečně dostat do tohoto distribučního kódu,

218
00:14:25,000 --> 00:14:32,000
a já ti pomůžu vy v tom nějaký smysl.

219
00:14:32,000 --> 00:14:36,000
Jsem již stáhli distribuční kód.

220
00:14:36,000 --> 00:14:38,000
Můžete to udělat.

221
00:14:38,000 --> 00:14:41,000
Tam je návod na spec, kde budete muset vytvořit svůj vlastní adresář pro PSet 3,

222
00:14:41,000 --> 00:14:46,000
a pak, pokud spustíte příkaz, který je nalezen v spec

223
00:14:46,000 --> 00:14:49,000
pak budete moci stáhnout slova souboru,

224
00:14:49,000 --> 00:14:56,000
který obsahuje v podstatě soubor slovníku, pokud se jen podívat na to rychle.

225
00:14:56,000 --> 00:15:03,000
To v podstatě obsahuje celý seznam slov, která se bude náš slovník.

226
00:15:03,000 --> 00:15:05,000
>> Dobře, pojďme začít nahoře.

227
00:15:05,000 --> 00:15:11,000
Také zde si všimnete, že dobrý styl tohoto distribučního kódu

228
00:15:11,000 --> 00:15:14,000
Je v náš prospěch, protože můžeme vidět komentáře

229
00:15:14,000 --> 00:15:20,000
že vysvětlit, jak je tento kód používán.

230
00:15:20,000 --> 00:15:22,000
Máme to, včetně našich knihoven.

231
00:15:22,000 --> 00:15:25,000
Všimněte si, že tady jsme # include <time.h>,

232
00:15:25,000 --> 00:15:29,000
a tak, aby knihovna nám umožňuje sledovat čas, protože

233
00:15:29,000 --> 00:15:33,000
v Scramble budete muset zadat v podstatě v co nejvíce slov, jak je to možné

234
00:15:33,000 --> 00:15:36,000
v daném časovém rámci.

235
00:15:36,000 --> 00:15:38,000
Zde máme několik proměnných.

236
00:15:38,000 --> 00:15:42,000
Doba trvání hry jsme nastavili, že na 30 sekund.

237
00:15:42,000 --> 00:15:45,000
My říkáme, že rozměr mřížky-je to čtverec grid-

238
00:15:45,000 --> 00:15:47,000
bude 4 x 4.

239
00:15:47,000 --> 00:15:54,000
Říkáme, že existují slova, počet slov ve slovníku,

240
00:15:54,000 --> 00:16:01,000
nikde mohou mít pouze maximálně 29 písmen.

241
00:16:01,000 --> 00:16:03,000
Pak tady je soubor s názvem log.

242
00:16:03,000 --> 00:16:07,000
V podstatě budeme se automatizuje některé z výsledků z kódu,

243
00:16:07,000 --> 00:16:11,000
tak zkuste neměnit nic do činění s log, protože budeme zabývat s tím.

244
00:16:11,000 --> 00:16:14,000
Nemusíte se docela pochopit, že přesto,

245
00:16:14,000 --> 00:16:19,000
ale jen se snaží neměnit nic do činění s log.

246
00:16:19,000 --> 00:16:25,000
Povšimněte si, že zde tato proměnná mřížka, která je 2D pole znaků,

247
00:16:25,000 --> 00:16:27,000
Je prohlášen ven z našeho hlavní funkce,

248
00:16:27,000 --> 00:16:29,000
tak to je to, co nazýváme globální proměnná.

249
00:16:29,000 --> 00:16:31,000
Vzhledem k tomu, máme co do činění s hrou tady,

250
00:16:31,000 --> 00:16:34,000
pokud si vzpomínáte celou cestu zpět k poškrábání

251
00:16:34,000 --> 00:16:36,000
když jsme měli něco jako skóre, například,

252
00:16:36,000 --> 00:16:39,000
když jsme se zabývali hrou, která musela být přístupné

253
00:16:39,000 --> 00:16:43,000
Mnoho z různých skriptů, takže podobně, máme tuto proměnnou

254
00:16:43,000 --> 00:16:48,000
které musí být přístupné k mnoha funkcích v našem programu,

255
00:16:48,000 --> 00:16:52,000
takže síť je zde 2-rozměrné pole, které bude ukládat

256
00:16:52,000 --> 00:16:55,000
písmena v Scramble hře.

257
00:16:55,000 --> 00:16:59,000
Později uvidíme, využití později,

258
00:16:59,000 --> 00:17:03,000
ale pak jsme také 2D pole booleans názvem značky,

259
00:17:03,000 --> 00:17:07,000
a tak v podstatě, když jdeme do kontroly, zda je slovo

260
00:17:07,000 --> 00:17:12,000
je platná, nebo ne, co potřebujeme vědět, zda jsme byli navštíveni určitý blok,

261
00:17:12,000 --> 00:17:15,000
navštívil určitou dopis, a tak pak značky v podstatě se bude

262
00:17:15,000 --> 00:17:20,000
obsahují buď true nebo false v daném indexu,

263
00:17:20,000 --> 00:17:23,000
tak to bude, dejte nám vědět, jestli jsme tam byli předtím,

264
00:17:23,000 --> 00:17:26,000
zda jsme navštívili tento dopis během našeho určité kontroly,

265
00:17:26,000 --> 00:17:30,000
a tak značky, jak uvidíte později,

266
00:17:30,000 --> 00:17:41,000
bude v podstatě přesně zrcadlit mřížku.

267
00:17:41,000 --> 00:17:46,000
>> Zde jsme se rozhodli, že bychom chtěli naše vlastní datový typ.

268
00:17:46,000 --> 00:17:48,000
Nebyli jsme spokojeni jen s řetězcem.

269
00:17:48,000 --> 00:17:51,000
Vlastně jsme chtěli něco, co nazývá slovo,

270
00:17:51,000 --> 00:17:55,000
takže máme tento typedef struct sem,

271
00:17:55,000 --> 00:17:58,000
a pak v něm, že má boolean názvem nalezeno,

272
00:17:58,000 --> 00:18:01,000
tak, zda tento výraz bylo nalezeno, nebo ne.

273
00:18:01,000 --> 00:18:04,000
Pak to má řadu znaků,

274
00:18:04,000 --> 00:18:10,000
v podstatě na slovo, že je.

275
00:18:10,000 --> 00:18:14,000
Nyní pak, slovo je skutečný nový datový typ, který jsme udělali,

276
00:18:14,000 --> 00:18:17,000
takže může mít řadu slov, například,

277
00:18:17,000 --> 00:18:23,000
nebo můžeme vytvořit slovo a mít více instancí z nich.

278
00:18:23,000 --> 00:18:26,000
Ale máme pouze jednu slovník, a tak to je důvod, proč máme jen

279
00:18:26,000 --> 00:18:29,000
struct volat slovník jak protichůdný k typedef struct.

280
00:18:29,000 --> 00:18:34,000
Struct má celé číslo s velikostí slovníku

281
00:18:34,000 --> 00:18:37,000
stejně jako pole slov, a znovu,

282
00:18:37,000 --> 00:18:41,000
používáme tento globální proměnné slova, která je definována výše,

283
00:18:41,000 --> 00:18:46,000
být počet slov, která je ve skutečnosti v našem slovníku.

284
00:18:46,000 --> 00:18:49,000
Zde máme celý seznam prototypů, funkčních prototypů,

285
00:18:49,000 --> 00:18:52,000
v podstatě říká, dobře, nyní můžete očekávat, že

286
00:18:52,000 --> 00:18:55,000
všechny tyto funkce později v programu.

287
00:18:55,000 --> 00:18:57,000
Budu mít void funkci nazvanou jasné,

288
00:18:57,000 --> 00:19:00,000
boolean funkce se nazývá procházení, která bere v

289
00:19:00,000 --> 00:19:05,000
řetězec a pak 2 celá čísla, et cetera, takže byste vidět něco podobného.

290
00:19:05,000 --> 00:19:09,000
Také pěkný rys v gedit je, že po boku zde

291
00:19:09,000 --> 00:19:14,000
pokud byste se ujistit, že jste vybrali tuto funkce kartu zde,

292
00:19:14,000 --> 00:19:18,000
Zdrojový kód karta, pak to bude ve skutečnosti ukáže všechny funkce

293
00:19:18,000 --> 00:19:20,000
že máte v programu.

294
00:19:20,000 --> 00:19:24,000
To vám ukáže několik věcí, které můžete použít.

295
00:19:24,000 --> 00:19:29,000
Například, tady to má, že jste definovali nový datový typ nazvaný slovo

296
00:19:29,000 --> 00:19:33,000
a pak některé globální proměnné, které mají.

297
00:19:33,000 --> 00:19:37,000
Ale to funguje karta je velmi užitečná, protože můžete kliknout sem a tam

298
00:19:37,000 --> 00:19:42,000
a skok na určité místo programu.

299
00:19:42,000 --> 00:19:48,000
>> Dobře, jsme na hlavní funkci nyní.

300
00:19:48,000 --> 00:19:52,000
Když uživatel zadá v příkazovém,

301
00:19:52,000 --> 00:19:55,000
v podstatě mohou buď říci. / scramble,

302
00:19:55,000 --> 00:19:59,000
nebo se mohou také vstoupit do řady po tom, aby v podstatě naznačují

303
00:19:59,000 --> 00:20:02,000
které rada chtějí hrát.

304
00:20:02,000 --> 00:20:05,000
Obvykle když zadáte pouze v jednom argument příkazového řádku

305
00:20:05,000 --> 00:20:09,000
pak je to jen tak, aby vám náhodný prkno, ale říkají, pro účely ladění

306
00:20:09,000 --> 00:20:12,000
chcete, aby se ujistil, že jste právě zjistili, zda stejný desku znovu a znovu

307
00:20:12,000 --> 00:20:15,000
pak to, co můžete udělat, je jen říct ./scramble1, například,

308
00:20:15,000 --> 00:20:19,000
a bude vždy vám stejnou desku.

309
00:20:19,000 --> 00:20:21,000
Tady je to zajištění řádného používání,

310
00:20:21,000 --> 00:20:26,000
takže pokud uživatel zadá ve více než 2 argumenty příkazového řádku,

311
00:20:26,000 --> 00:20:29,000
pak to bude instruovat je o tom, jak správně používat program

312
00:20:29,000 --> 00:20:34,000
a potom ukončete.

313
00:20:34,000 --> 00:20:38,000
Zde, pokud argc je 2, to znamená, že v případě, že uživatel zadává číslo

314
00:20:38,000 --> 00:20:42,000
specifického slova, které chtějí použít pak

315
00:20:42,000 --> 00:20:47,000
v podstatě, když program později je náhodný desku

316
00:20:47,000 --> 00:20:51,000
pak jsme v podstatě se dávat to semeno, něco jako nutit ji

317
00:20:51,000 --> 00:20:57,000
použít určitou hodnotu.

318
00:20:57,000 --> 00:21:02,000
Pak jsme tady nahrát naše slova souboru.

319
00:21:02,000 --> 00:21:06,000
V podstatě, pokud nelze otevřít slovník, pokud se něco pokazí,

320
00:21:06,000 --> 00:21:08,000
pak se vrátí 1.

321
00:21:08,000 --> 00:21:11,000
Jsme inicializaci mřížky. My se podíváme do této funkce později.

322
00:21:11,000 --> 00:21:13,000
Nastavili jsme skóre 0.

323
00:21:13,000 --> 00:21:18,000
Počítáme-li hra skončí,

324
00:21:18,000 --> 00:21:20,000
tak to je 30 sekund, jak jsme si stanovili.

325
00:21:20,000 --> 00:21:27,000
Pak tu je opět log soubor, který nemusíte měnit.

326
00:21:27,000 --> 00:21:33,000
>> Zde je maso z programu, kde máme while (true) smyčku,

327
00:21:33,000 --> 00:21:36,000
takže si všimnout, že pokud stačí mít while (true) smyčku sám o sobě

328
00:21:36,000 --> 00:21:39,000
pak to bude jen se udržet na provedení, co je v jeho těle,

329
00:21:39,000 --> 00:21:42,000
ale jak uvidíte později, jsme vlastně mít přestávku

330
00:21:42,000 --> 00:21:46,000
takže jsme vlastně dovolit to-máme nějaký způsob, jak to vlastně vypadla

331
00:21:46,000 --> 00:21:50,000
z funkce a neprovádí navždy.

332
00:21:50,000 --> 00:21:52,000
První, co se stane, je obrazovka smaže

333
00:21:52,000 --> 00:21:59,000
takže můžete nakreslit nové desky, a pak to bude mít funkci s názvem draw.

334
00:21:59,000 --> 00:22:03,000
Opět platí, že to log, takže v podstatě pokaždé, když to jde přes tuto smyčku

335
00:22:03,000 --> 00:22:06,000
to bude hlásit skóre pro vás.

336
00:22:06,000 --> 00:22:09,000
Zkontrolujte, zda hra by měla být konec,

337
00:22:09,000 --> 00:22:12,000
ať už jste mimo čas, nebo ne, a pak oznámí, kolik času ještě zbývá

338
00:22:12,000 --> 00:22:15,000
v případě, že hra je stále ve hře.

339
00:22:15,000 --> 00:22:19,000
Pak tu máme výzvu pro slovo,

340
00:22:19,000 --> 00:22:21,000
a pak máme GetString funkci,

341
00:22:21,000 --> 00:22:26,000
tak, že je místo, kde uživatel skutečně vstupy slovo pro vás.

342
00:22:26,000 --> 00:22:31,000
Pak v podstatě v případě, že jste skutečně zadali slovo, pokud to není null,

343
00:22:31,000 --> 00:22:38,000
pak se program bude zaznamenávat ji.

344
00:22:38,000 --> 00:22:41,000
Pak si chcete zkontrolovat, zda je nutné vyškrábat mřížky,

345
00:22:41,000 --> 00:22:44,000
takže v podstatě když zadáte do příkazového rvačky, Word Scramble,

346
00:22:44,000 --> 00:22:48,000
pak to bude otočí o 90 °.

347
00:22:48,000 --> 00:22:51,000
Pak jinak, pokud to není slovo scramble

348
00:22:51,000 --> 00:22:57,000
pak to, co chcete udělat, je budete chtít podívat na slovo.

349
00:22:57,000 --> 00:22:59,000
(Zde (slovo) je pravda. Půjdeme do této funkce později.

350
00:22:59,000 --> 00:23:02,000
A pak budete chtít podívat se nahoru, takže v podstatě je to na roštu,

351
00:23:02,000 --> 00:23:04,000
a je to ve slovníku?

352
00:23:04,000 --> 00:23:08,000
A pokud je tomu tak, pak to bude zvýšit své skóre podle počtu písmen

353
00:23:08,000 --> 00:23:12,000
že slovo je.

354
00:23:12,000 --> 00:23:16,000
To je náš hlavní funkce tam.

355
00:23:16,000 --> 00:23:19,000
>> Tohle je v podstatě jako únikový kód,

356
00:23:19,000 --> 00:23:21,000
takže nemusíte se bát, že tak moc,

357
00:23:21,000 --> 00:23:25,000
ale v podstatě vždy, když zavoláte jasné, že bude jasné, terminál

358
00:23:25,000 --> 00:23:32,000
a přesunout kurzor zpět a druh mazání bez ohledu na to psal předtím.

359
00:23:32,000 --> 00:23:40,000
Pojďme jít lézt docela ještě ne.

360
00:23:40,000 --> 00:23:43,000
Místo toho budeme posouvat dolů a vidět funkce Draw tady,

361
00:23:43,000 --> 00:23:45,000
která je vaším úkolem TODO.

362
00:23:45,000 --> 00:23:48,000
V podstatě budete muset vytisknout mřížku v jeho současném stavu,

363
00:23:48,000 --> 00:23:52,000
takže jsme se už postarala o skutečně inicializaci mřížky,

364
00:23:52,000 --> 00:23:56,000
a tak si nemusíte dělat starosti, kterou dopisy, aby v mřížce

365
00:23:56,000 --> 00:24:01,000
nebo něco takového, ale v kreslení funkci budete chtít

366
00:24:01,000 --> 00:24:04,000
vytisknout všechno, co je v mřížce.

367
00:24:04,000 --> 00:24:07,000
Pak zde máme logickou funkci nazvanou najít,

368
00:24:07,000 --> 00:24:10,000
které jsme viděli výše v hlavní funkci.

369
00:24:10,000 --> 00:24:17,000
Je-li slovo bylo zjištěno, a byl také podíval do slovníku,

370
00:24:17,000 --> 00:24:21,000
pokud oba ti vrátil to pravda, pak by zvýšení skóre.

371
00:24:21,000 --> 00:24:26,000
Zde je najdete funkce, kde se bere v slova jako řetězec,

372
00:24:26,000 --> 00:24:32,000
a to musí být 2 nebo více znaky,

373
00:24:32,000 --> 00:24:36,000
a pak to, co to dělá, je, že prohledává síť pro dané slovo.

374
00:24:36,000 --> 00:24:41,000
Zde vidíme příklad iterace každý prvek v síti

375
00:24:41,000 --> 00:24:47,000
kde iteraci řádků a pak v rámci této iteraci sloupců.

376
00:24:47,000 --> 00:24:50,000
Zde si na znacky 2D pole, které v podstatě ukládá buď true nebo false

377
00:24:50,000 --> 00:24:52,000
zda jsme byli na tento dopis již.

378
00:24:52,000 --> 00:24:58,000
V podstatě to resetuje všech ochranných známek, protože jsme obchoduje pouze s ochrannými

379
00:24:58,000 --> 00:25:01,000
pokaždé, když jsme kontrolu konkrétní slovo.

380
00:25:01,000 --> 00:25:04,000
Pak sem jednou jsme obnovit všechny značky

381
00:25:04,000 --> 00:25:08,000
skutečně hledá slovo, a tak se podívejte na slovo

382
00:25:08,000 --> 00:25:13,000
to je, kde budeme používat procházení funkcí, takže pojďme zpět k procházení

383
00:25:13,000 --> 00:25:16,000
a podívat se na něj.

384
00:25:16,000 --> 00:25:20,000
Co procházení dělá, je, že má v řetězci tzv. dopisy

385
00:25:20,000 --> 00:25:27,000
stejně jako v podstatě x a y, které je počáteční index

386
00:25:27,000 --> 00:25:33,000
, kde má uživatel řekl slovo.

387
00:25:33,000 --> 00:25:38,000
V podstatě kontroluje, zda x je <0 nebo> rozměr

388
00:25:38,000 --> 00:25:41,000
v podstatě to znamená, že tento index ve skutečnosti neexistuje v naší hry,

389
00:25:41,000 --> 00:25:43,000
tak pak to vrátí false.

390
00:25:43,000 --> 00:25:47,000
Pokud jste již navštívili vybrané písmeno

391
00:25:47,000 --> 00:26:02,000
pak, že se to vrátí false dobře, protože pravidlo v Scramble

392
00:26:02,000 --> 00:26:11,000
je, že když máte

393
00:26:11,000 --> 00:26:14,000
písmeno zde, například,

394
00:26:14,000 --> 00:26:20,000
se můžete připojit dopis tím, že půjdete nahoru nebo diagonální takhle,

395
00:26:20,000 --> 00:26:24,000
takže v podstatě svůj další písmeno mohou být v libovolné z těchto přilehlých bloků,

396
00:26:24,000 --> 00:26:31,000
ale to, co nemůžete udělat, například, je jít k tomuto dopisu

397
00:26:31,000 --> 00:26:37,000
a vrátit se do, takže můžete použít pouze každé písmeno pouze jednou.

398
00:26:37,000 --> 00:26:42,000
Pak to dává smysl, že jsou zde známky, že pokud jsme byli už dřív,

399
00:26:42,000 --> 00:26:47,000
Pokud se stopy je nastavena na hodnotu true, pak to není platné slovo.

400
00:26:47,000 --> 00:26:49,000
>> Pak to, co dělá, je, že kontroluje.

401
00:26:49,000 --> 00:26:53,000
To říká, že jdu zkontrolovat, zda v tomto konkrétním místě

402
00:26:53,000 --> 00:26:55,000
dopis, který chceme je tam.

403
00:26:55,000 --> 00:26:57,000
Pokud tomu tak není, vrátí false.

404
00:26:57,000 --> 00:27:02,000
Vzhledem k tomu, že už četl, že blok, pak to bude nastavit značku

405
00:27:02,000 --> 00:27:06,000
v tomto konkrétním bodě jako pravdivé.

406
00:27:06,000 --> 00:27:09,000
Nyní se kontroluje, že v podstatě, pokud budeme pokračovat

407
00:27:09,000 --> 00:27:13,000
to znamená, že budeme hledat další písmeno

408
00:27:13,000 --> 00:27:18,000
ve slově, že uživatel se snaží předložit.

409
00:27:18,000 --> 00:27:20,000
Zde připomenout zpět s pravidly.

410
00:27:20,000 --> 00:27:24,000
Snažíte se kontrolovat všechny sousední hodnoty,

411
00:27:24,000 --> 00:27:28,000
ty nahoře, dole, vlevo a vpravo, stejně jako úhlopříčky,

412
00:27:28,000 --> 00:27:32,000
a tak podobně, když jsme si mysleli, ze iterace 2D pole

413
00:27:32,000 --> 00:27:35,000
, kde jsme chtěli iteraci všechny možné a zkontrolujte

414
00:27:35,000 --> 00:27:41,000
všechny možné permutace mezi řádků indexů a sloupců indexy

415
00:27:41,000 --> 00:27:43,000
zde chceme zkontrolovat všechny možné kombinace,

416
00:27:43,000 --> 00:27:49,000
, pokud je to na levé straně písmene, přímo nad, nebo na pravé straně.

417
00:27:49,000 --> 00:27:56,000
Zde vidíme, že smyčka kontroluje doleva

418
00:27:56,000 --> 00:27:58,000
když jsem je -1.

419
00:27:58,000 --> 00:28:04,000
Když je to na 0 zkontroluje na stejném sloupci, že dopis je,

420
00:28:04,000 --> 00:28:08,000
a pak v případě i = 1, který je jeho konečná hodnota, pak se kontroluje na pravé straně,

421
00:28:08,000 --> 00:28:10,000
a pak, že to není dost, ne?

422
00:28:10,000 --> 00:28:13,000
Je třeba kontrolovat všechny svislých hodnot,

423
00:28:13,000 --> 00:28:19,000
takže pak zde máme smyčku, která se dostane ověřila, zda to jde pod

424
00:28:19,000 --> 00:28:22,000
na stejné úrovni nebo výše, tak pak kombinace, která

425
00:28:22,000 --> 00:28:28,000
bude přístup každý přilehlý blok na A.

426
00:28:28,000 --> 00:28:38,000
Nicméně, to také zkontroluje blok zde na,

427
00:28:38,000 --> 00:28:44,000
takže pak chceme, aby se ujistil, že nemáme kontrolu, že jeden.

428
00:28:44,000 --> 00:28:51,000
Nyní tedy, aby skutečně zkontrolujte, zda předchozí slova jsou platné, nebo ne

429
00:28:51,000 --> 00:28:56,000
pak chceme udělat stejný postup pro zbytek slova

430
00:28:56,000 --> 00:29:00,000
Blokování ten, který jsme již udělali, tak pak je zde předchůdce funkce.

431
00:29:00,000 --> 00:29:03,000
To volá sama sebe, a dostaneme se do toho trochu později,

432
00:29:03,000 --> 00:29:13,000
ale provádí stejný proces pro všechny následné řetězce.

433
00:29:13,000 --> 00:29:16,000
Mluvili jsme o tom najít funkci.

434
00:29:16,000 --> 00:29:18,000
Chápeme, co to dělá.

435
00:29:18,000 --> 00:29:23,000
Je to v podstatě kontrolu, zda toto slovo, které uživatel dal

436
00:29:23,000 --> 00:29:27,000
skutečně existuje na palubě a zda je to oceňují tah.

437
00:29:27,000 --> 00:29:29,000
Zde máme initialize funkci.

438
00:29:29,000 --> 00:29:33,000
Všimněte si, že je to neplatné, takže to nebude návratu nám nic,

439
00:29:33,000 --> 00:29:36,000
ale je to jen bude dělat něco pro nás.

440
00:29:36,000 --> 00:29:39,000
>> Zde vypnutí Wikipedie je tu frekvenci

441
00:29:39,000 --> 00:29:42,000
pro každé písmeno v abecedě na základě toho, jak často

442
00:29:42,000 --> 00:29:45,000
to je používáno v anglickém jazyce.

443
00:29:45,000 --> 00:29:50,000
Ty vidět, že e je, například, jeden z nejpopulárnějších používaných písmeny.

444
00:29:50,000 --> 00:29:52,000
Chceme naplnit mřížky.

445
00:29:52,000 --> 00:29:55,000
Co tato funkce dělá, je naplnění mřížky s písmeny

446
00:29:55,000 --> 00:30:06,000
druh vzhledem k jejich frekvenci v tomto poli.

447
00:30:06,000 --> 00:30:11,000
Nyní, to je použití tohoto jazyka zde

448
00:30:11,000 --> 00:30:14,000
říká velikost frekvencí,

449
00:30:14,000 --> 00:30:16,000
Je to druh pouze v konkrétním případě.

450
00:30:16,000 --> 00:30:21,000
Můžeme skutečně použít velikost frekvencí, takže když si opravdu chcete

451
00:30:21,000 --> 00:30:26,000
najít délku pole pravděpodobně nebudete používat velikosti

452
00:30:26,000 --> 00:30:29,000
ale spíše jen pomocí pole délky.

453
00:30:29,000 --> 00:30:33,000
Můžete požádat své TFS, s tebou mluvit trochu víc o tom,

454
00:30:33,000 --> 00:30:40,000
ale jen vím, že to syntaxe je zde více o zvláštní případ.

455
00:30:40,000 --> 00:30:49,000
Nyní, pro každý prvek v síti

456
00:30:49,000 --> 00:30:53,000
chceme, aby dopis, a to se bude pseudonáhodné,

457
00:30:53,000 --> 00:30:55,000
tak náhodně, ale ne tak docela.

458
00:30:55,000 --> 00:30:58,000
V podstatě to, co to dělá je, že jsme-li nastavit nový double

459
00:30:58,000 --> 00:31:01,000
s náhodnou hodnotou mezi 0 a 1.

460
00:31:01,000 --> 00:31:03,000
Na základě toho budeme mapovat, že

461
00:31:03,000 --> 00:31:08,000
tak říci, že d je nastavena na 0,6, například.

462
00:31:08,000 --> 00:31:13,000
Pak, pokud d je 60% v roce

463
00:31:13,000 --> 00:31:16,000
pak budeme dívat na všechny ty dopisy a najít

464
00:31:16,000 --> 00:31:19,000
vzhledem k tom, jak často jsou zvyklí

465
00:31:19,000 --> 00:31:21,000
Co je 60% v.

466
00:31:21,000 --> 00:31:24,000
Není to jen 60% z abecedy, ale spíše

467
00:31:24,000 --> 00:31:28,000
zabírá tolik místa, a pak b zabírá tolik,

468
00:31:28,000 --> 00:31:31,000
a pak se e, například, zabere tolik.

469
00:31:31,000 --> 00:31:35,000
Na základě relativních délek nebo frekvencí

470
00:31:35,000 --> 00:31:39,000
z těchto dopisů se budeme mapovat tuto náhodnou hodnotu

471
00:31:39,000 --> 00:31:43,000
mezi 0 a 1 na konkrétním písmenem.

472
00:31:43,000 --> 00:31:45,000
To je to, co tento kód dělá tady,

473
00:31:45,000 --> 00:31:52,000
a pak je tu k je jako posun, kde spolu

474
00:31:52,000 --> 00:31:59,000
v dopise chceme být, a tak se nastavit znak v mřížce

475
00:31:59,000 --> 00:32:04,000
být + k.

476
00:32:04,000 --> 00:32:07,000
>> Všimněte si, že zpět myslet na nenasytní

477
00:32:07,000 --> 00:32:11,000
jsme museli použít kulatý funkci řešit s plovoucí desetinnou čárkou nepřesnosti zde,

478
00:32:11,000 --> 00:32:14,000
tak podobně jsme museli vzít v úvahu, že se někdy

479
00:32:14,000 --> 00:32:18,000
plováky nejsou přesně to, co chceme, aby byly,

480
00:32:18,000 --> 00:32:27,000
tak chceme, aby se úlovek za to.

481
00:32:27,000 --> 00:32:32,000
Pak jdeme do souboru I / O, v podstatě čtení a zápis do souborů,

482
00:32:32,000 --> 00:32:34,000
které se dostanete do vyšší, ale ne tak docela,

483
00:32:34,000 --> 00:32:39,000
takže v podstatě to otevře soubor slovníku, přečte, co je v něm,

484
00:32:39,000 --> 00:32:42,000
a pak nastaví ji do pole.

485
00:32:42,000 --> 00:32:46,000
Všimněte si, že jsme se vydali do struct, že jsme deklarované, slovník struct,

486
00:32:46,000 --> 00:32:53,000
a tak slovník má řadu s názvem slova s ​​ním spojené,

487
00:32:53,000 --> 00:33:00,000
tak co to dělá říká slovník, slova v tomto konkrétním indexu

488
00:33:00,000 --> 00:33:04,000
jsou takové a takové hodnoty.

489
00:33:04,000 --> 00:33:10,000
Pak už jsme skoro hotovi s distribuční kódem.

490
00:33:10,000 --> 00:33:13,000
Konečně máme vyhledávací funkci, kde máte připomínky

491
00:33:13,000 --> 00:33:18,000
poučil vás o tom, co, že kodex by měl dělat.

492
00:33:18,000 --> 00:33:21,000
Vyhledávací bude vyhledat slovo ve slovníku

493
00:33:21,000 --> 00:33:24,000
a tak dlouho, jak to slovo nebylo nalezeno již

494
00:33:24,000 --> 00:33:29,000
pak vlajky to jako záznam, takže uživatel může použít znovu

495
00:33:29,000 --> 00:33:33,000
ale také se vrátí skutečný myšlení zpět na hlavní funkci znovu,

496
00:33:33,000 --> 00:33:37,000
vrátí true, tak říká, že to slovo může být bodován.

497
00:33:37,000 --> 00:33:39,000
>> A pak konečně máte Scramble funkci,

498
00:33:39,000 --> 00:33:42,000
což je další void funkce, protože je to něco

499
00:33:42,000 --> 00:33:45,000
ale nevrací nic, takže to, co scramble funkce bude dělat

500
00:33:45,000 --> 00:33:51,000
je otočte mřížku 90 ° ve směru hodinových ručiček.

501
00:33:51,000 --> 00:33:55,000
Vím, že by mohl být trochu drsný, ale je to důležité udělat.

502
00:33:55,000 --> 00:33:57,000
Sledujte mě děje prostřednictvím distribuční kódu,

503
00:33:57,000 --> 00:33:59,000
ale také, zkuste projít sami.

504
00:33:59,000 --> 00:34:04,000
To, co jsem chtěl udělat, je zmapovat to pochopit

505
00:34:04,000 --> 00:34:15,000
co tento program se všemi těmito funkcemi vlastně dělat?

506
00:34:15,000 --> 00:34:18,000
Pokud bych měl jít přes distribuční kód znovu,

507
00:34:18,000 --> 00:34:21,000
Nyní, že jsem tak trochu smysl pro to, co se děje pak bych řekl,

508
00:34:21,000 --> 00:34:28,000
začneme s naší hlavní funkcí,

509
00:34:28,000 --> 00:34:36,000
a pak jsem si první věc, která to dělá, je to volá zatížení,

510
00:34:36,000 --> 00:34:40,000
takže hlavní vyzývá zatížení, ale zatížení je neplatné funkce,

511
00:34:40,000 --> 00:34:45,000
Tak co mám dělat, což znamená, že je jen uvedení jednu šipku

512
00:34:45,000 --> 00:34:48,000
ukázal načíst, protože hlavní nazývá.

513
00:34:48,000 --> 00:34:56,000
Další věc je inicializovat.

514
00:34:56,000 --> 00:34:59,000
Hlavní volání inicializace,

515
00:34:59,000 --> 00:35:02,000
a pak, pokud se podíváme zpět do našeho hlavního funkce

516
00:35:02,000 --> 00:35:06,000
Myslím, že tento další věc, která to dělá,

517
00:35:06,000 --> 00:35:09,000
tady jsou tuny různých věcí, které hlavní je volání,

518
00:35:09,000 --> 00:35:13,000
ale teď jsem jen se zaměřením na nejvíce ty nejdůležitější

519
00:35:13,000 --> 00:35:18,000
relevantní kódu, takže jsem bez na I nebo podobné věci.

520
00:35:18,000 --> 00:35:25,000
Pak další věc, která to dělá je to vymaže ji,

521
00:35:25,000 --> 00:35:29,000
a pak se čerpat,

522
00:35:29,000 --> 00:35:36,000
a tak vím, že remíza je něco, co budeme dělat.

523
00:35:36,000 --> 00:35:38,000
To je remíza funkce.

524
00:35:38,000 --> 00:35:44,000
Později vidíme, že další je bit-

525
00:35:44,000 --> 00:35:57,000
takže pak máme rvačku.

526
00:35:57,000 --> 00:36:02,000
A pak jsme najít, takže najít je další funkce.

527
00:36:02,000 --> 00:36:07,000
Vidíme, že zde je-pokud si vzpomínáte zpět, že je to booleovská funkce,

528
00:36:07,000 --> 00:36:09,000
takže to vlastně bude něco vracet zpět k nám.

529
00:36:09,000 --> 00:36:18,000
Pak tady jsem naznačují, že by jsme najít,

530
00:36:18,000 --> 00:36:29,000
a pak jsme také vyhledávání.

531
00:36:29,000 --> 00:36:32,000
Ale pak si uvědomit, že je tu i tato Funkce procházení

532
00:36:32,000 --> 00:36:35,030
že se nezdá k byli voláni v main,

533
00:36:35,030 --> 00:36:39,000
tak to znamená, že některé další funkce volá procházení,

534
00:36:39,000 --> 00:36:41,000
a pokud hledáte zpět přes distribuční kódu

535
00:36:41,000 --> 00:36:46,000
vidíte, že zde je ten, který používá procházení,

536
00:36:46,000 --> 00:36:52,000
takže pak najít pak také odkazy na procházet,

537
00:36:52,000 --> 00:36:55,090
což je logická hodnota, která vrací něco,

538
00:36:55,090 --> 00:36:58,000
tak jsem přidat další věc, a pak od procházení je rekurzivní

539
00:36:58,000 --> 00:37:03,000
také tvoří záda na sobě.

540
00:37:03,000 --> 00:37:07,000
>> Pak, pokud vidíte tady jsem nakreslil obrázek o tom, co náš program vypadá,

541
00:37:07,000 --> 00:37:10,000
takže pochopení vztahů mezi určitými funkcemi,

542
00:37:10,000 --> 00:37:14,000
a návrat k tomu také viz usnesení ze hry

543
00:37:14,000 --> 00:37:24,000
a logika, jak se hra programu bude pokračovat.

544
00:37:24,000 --> 00:37:27,000
Četli jsme distribuční kód.

545
00:37:27,000 --> 00:37:29,000
První funkce, které budete chtít realizovat,

546
00:37:29,000 --> 00:37:32,000
nebo jedna z funkcí, které chcete implementovat je remíza,

547
00:37:32,000 --> 00:37:37,000
a tak zde máte skutečně trochu svobody s tím.

548
00:37:37,000 --> 00:37:43,000
Podíváme-li se na zaměstnance na řešení

549
00:37:43,000 --> 00:37:54,000
Jdu otevřít okno terminálu, vlastně,

550
00:37:54,000 --> 00:38:05,000
pset3/scramble.

551
00:38:05,000 --> 00:38:09,000
Scratch, že. Myslím, že je třeba aktualizovat svůj přístroj.

552
00:38:09,000 --> 00:38:12,000
Pokud budete hrát se zaměstnancem řešení Scramble-

553
00:38:12,000 --> 00:38:14,000
pokyny jsou v spec pro že-

554
00:38:14,000 --> 00:38:20,000
pak můžete vidět, jak že jsem vytisknout na hrací desku,

555
00:38:20,000 --> 00:38:23,000
ale v podstatě to, co dělají, je, že dát mezery mezi jednotlivými postavami,

556
00:38:23,000 --> 00:38:27,000
ale máte trochu svobody s tím, takže pokud chcete tisknout linky, například,

557
00:38:27,000 --> 00:38:31,000
mezi nimi pak můžete dělat, že.

558
00:38:31,000 --> 00:38:38,000
Chcete-li si vzpomenu, jak jsme iteraci všechny prvky 2D pole,

559
00:38:38,000 --> 00:38:41,000
a budete chtít vytisknout ty, ujistěte se, že máte smyčku

560
00:38:41,000 --> 00:38:49,000
a mít své tiskové funkce, jako že tisknete ve správném pořadí.

561
00:38:49,000 --> 00:38:54,000
Pokud chcete, aby vaše iterační smyčku, když iteraci nad ním

562
00:38:54,000 --> 00:39:03,000
a použít indexy ujistěte se, že tisknete ve správném pořadí.

563
00:39:03,000 --> 00:39:06,000
>> Jednání s 2D poli zpočátku může být trochu matoucí,

564
00:39:06,000 --> 00:39:12,000
tak tady na tomto snímku jsem udělal tabulku, která vám ukáže,

565
00:39:12,000 --> 00:39:16,000
pro každou daném místě v 2D poli, co indexy jsou,

566
00:39:16,000 --> 00:39:19,000
takže pokud chcete vrátit zpět k tomu pro rychlou kontrolu

567
00:39:19,000 --> 00:39:22,000
nebo s odkazem, nebo něco takového, pak můžete použít tento.

568
00:39:22,000 --> 00:39:30,000
Sloupce jsou v modré, a řádky jsou v červené barvě.

569
00:39:30,000 --> 00:39:34,000
Vyhledávací funkce je dvojí.

570
00:39:34,000 --> 00:39:37,000
Vyhledávací a to booleovská funkce, bude nám

571
00:39:37,000 --> 00:39:43,000
true nebo false, zda uživatel-předložil slovo

572
00:39:43,000 --> 00:39:46,000
může být přijata jako platná hodnota,

573
00:39:46,000 --> 00:39:51,000
a tak slovo v vyškrábat je platný pouze

574
00:39:51,000 --> 00:39:56,000
pokud je to ve slovníku, a pokud je to ve skutečnosti nalézt v desce,

575
00:39:56,000 --> 00:40:02,000
a tak si pamatujte, že vyhledávání, musíte provést toto sami,

576
00:40:02,000 --> 00:40:10,000
takže chcete zkontrolovat obě věci,

577
00:40:10,000 --> 00:40:16,000
zda slovo je vlastně ve slovníku a zda to bylo zjištěno již.

578
00:40:16,000 --> 00:40:18,940
Připomeňme zpět do globální proměnné slovníku,

579
00:40:18,940 --> 00:40:24,160
který je struct že jsme vytvořili, který v podstatě nemá int názvem velikosti

580
00:40:24,160 --> 00:40:27,290
s ní spojené, stejně jako pole slov,

581
00:40:27,290 --> 00:40:32,030
kde slovo je nový typ dat.

582
00:40:32,030 --> 00:40:36,910
Tak pro přístup, například, je velikost slovníku nebo slova pole,

583
00:40:36,910 --> 00:40:39,840
pak to, co můžete udělat, je jen napsat "dictionary.size,"

584
00:40:39,840 --> 00:40:42,580
podobným způsobem, který by jen použít jakoukoli jinou proměnnou.

585
00:40:42,580 --> 00:40:48,550
Takže pokud dictionary.size představuje velikost slovníku,

586
00:40:48,550 --> 00:40:51,450
Podobně, dictionary.words představuje pole.

587
00:40:51,450 --> 00:40:54,690
Takže pokud byste chtěli, aby přístup k určité slovo ve slovníku,

588
00:40:54,690 --> 00:40:59,020
pak budete muset přidat index

589
00:40:59,020 --> 00:41:03,130
protože budete muset říct "dictionary.words na indexu i"

590
00:41:03,130 --> 00:41:06,050
a pak něco na základě které.

591
00:41:06,050 --> 00:41:09,950
Tak s vědomím, že slovník má určitou velikost s ním spojené,

592
00:41:09,950 --> 00:41:13,720
stejně jako pole slov, a zkontrolujte, jestli se něco děje ve slovníku,

593
00:41:13,720 --> 00:41:16,870
pak budete muset interate nad slovníku

594
00:41:16,870 --> 00:41:20,610
zkontrolovat, zda to slovo se nachází.

595
00:41:20,610 --> 00:41:25,720
>> Nyní, pokud si myslíte, že zpět k přednášce, když jsme hovořili o různých způsobech, jak vyhledávat věci,

596
00:41:25,720 --> 00:41:30,690
pak si vzpomeňte, že lineární vyhledávání asi není vždy nejlepší způsob, jak jít.

597
00:41:30,690 --> 00:41:36,600
Ale rozhodně to je jeden způsob, jak něco hledat.

598
00:41:36,600 --> 00:41:39,540
Někdy možná zjistíte, že vám realizovat svůj Najít funkci s

599
00:41:39,540 --> 00:41:42,650
lineární vyhledávání na první a pak si zbytek váš program bude.

600
00:41:42,650 --> 00:41:47,480
A pak o něco později se můžete vrátit zpět a změnit způsob, jakým se prohledávat na slovo.

601
00:41:47,480 --> 00:41:52,010
Takže řeší - v podstatě věděl, že - vědět, jak se přístup k

602
00:41:52,010 --> 00:41:55,650
Slova pole slovníku, který řeší chtějí vidět

603
00:41:55,650 --> 00:41:58,190
zda je toto slovo je ve skutečnosti ve slovníku, nebo ne.

604
00:41:58,190 --> 00:42:06,540
Ale pak musíme také řešit, zda je toto slovo na palubě.

605
00:42:06,540 --> 00:42:08,540
A zda to byl nalezen již.

606
00:42:08,540 --> 00:42:12,670
Takže už máme najít funkci, nezapomeňte.

607
00:42:12,670 --> 00:42:18,310
Ukazuje su, ale to, co je slovo?

608
00:42:18,310 --> 00:42:22,330
To není filosofická otázka, ale spíše, podívejte se na definic typu.

609
00:42:22,330 --> 00:42:27,250
Máme boolean názvem 'nalezeno ", jakož i řada znaků

610
00:42:27,250 --> 00:42:29,570
, který představuje to slovo.

611
00:42:29,570 --> 00:42:35,940
Takže když se vrátíte vyhledávání, budete chtít zkontrolovat, zda to slovo byl nalezen nebo není.

612
00:42:35,940 --> 00:42:43,040
Nyní, protože věděl, že našel boolean - našel je název boolean

613
00:42:43,040 --> 00:42:49,660
, který je spojen s každým slovem - jak pak můžete přistupovat k této proměnné,

614
00:42:49,660 --> 00:43:01,590
vzpomínal na to, jak jsme přístup k proměnné v rámci slovníku?

615
00:43:01,590 --> 00:43:05,120
Tak tady jsme měli slovník, a pak jsme si řekli dot velikost, ne?

616
00:43:05,120 --> 00:43:08,170
Podobně, když mají slovo a, v tomto případě, být opatrní, protože

617
00:43:08,170 --> 00:43:13,340
Slovo je jen jiný typ dat, stejně jako int nebo řetězec.

618
00:43:13,340 --> 00:43:19,640
Takže nemůžete prostě říct "slovo", pokud je to jméno jeho.

619
00:43:19,640 --> 00:43:24,540
Budeš muset mít proměnnou s názvem, a pak až budete mít to,

620
00:43:24,540 --> 00:43:29,980
říci, že se říká foo, například, pak si můžete říct "foo.found,"

621
00:43:29,980 --> 00:43:39,560
a že se vrátí vám booleovskou hodnotu, zda to slovo byl nalezen nebo není.

622
00:43:39,560 --> 00:43:46,960
>> Takže další část PSet je realizovat tahanice,

623
00:43:46,960 --> 00:43:51,630
přičemž pokud uživatel vstupy vyškrábat - a to je již zabýval

624
00:43:51,630 --> 00:43:54,280
zde v distribuční kódu - stačí implementovat

625
00:43:54,280 --> 00:44:03,170
funkce tahanice, která již pokyn otočit desku 90 ° po směru hodinových ručiček.

626
00:44:03,170 --> 00:44:07,380
Jak na spec, pokyny říkají, že Rada se otáčí o 90 ° ve směru hodinových ručiček

627
00:44:07,380 --> 00:44:16,180
tak, aby hodnota v mřížce [0] [0] a pak se přesune do sítě [0] [dimenze -1.]

628
00:44:16,180 --> 00:44:38,240
V tomto případě se pro kódování, naše rozměr je 4, takže 0-0 by pak mapovat 0-3.

629
00:44:38,240 --> 00:44:41,210
Pojďme remíza na to, aby viděli, co by to mohlo vypadat.

630
00:44:41,210 --> 00:44:49,620
Nebudu dělat 4 x 4 mřížky, ale spíše 3 x 3 jeden.

631
00:44:49,620 --> 00:44:52,470
Řekněme, že je to palec 2D pole.

632
00:44:52,470 --> 00:45:02,040
Já jsem prostě jít jen mít - v pořádku.

633
00:45:02,040 --> 00:45:12,110
Takže říci, chceme vyškrábat to, chceme otočit o 90 ° ve směru hodinových ručiček.

634
00:45:12,110 --> 00:45:22,320
Víme, že jako výchozí bod, hodnota na 0-0, což je v tomto případě je číslo 0,

635
00:45:22,320 --> 00:45:28,950
bude mapovat do řádku 0, pak sloupec rozměr -1.

636
00:45:28,950 --> 00:45:31,570
A tak, že v tomto případě, rozměr je 3.

637
00:45:31,570 --> 00:45:37,400
Takže 0 by se stěhoval do řádku 0, sloupec 2.

638
00:45:37,400 --> 00:45:41,910
Takže máme číslo 0 tam.

639
00:45:41,910 --> 00:45:45,970
V podstatě to, co děláme, je bereme to,

640
00:45:45,970 --> 00:45:52,840
fyzicky otočením, takže pak 2 by jít do tohoto rohu,

641
00:45:52,840 --> 00:45:57,620
8 by pak jít na tomto rohu, na 6 na tento jeden.

642
00:45:57,620 --> 00:46:07,840
A pak to ostatní bude vypadat -

643
00:46:07,840 --> 00:46:15,180
Takže to, co síť vypadá, když jste úspěšně míchaná ho.

644
00:46:15,180 --> 00:46:17,410
Když jste se provádí Scramble funkci, co budete chtít dělat

645
00:46:17,410 --> 00:46:22,520
je vidět, dobře, jak mohu nahradit tyto hodnoty?

646
00:46:22,520 --> 00:46:26,090
Je tam nějaký vzor nebo nějaký druh vzorce pro stanovení

647
00:46:26,090 --> 00:46:29,900
kde zejména index jde?

648
00:46:29,900 --> 00:46:42,470
Například, já bych mohl vypadat vidět, že 3-4-5 je zde řada.

649
00:46:42,470 --> 00:46:44,650
Kde jinde nevidím 3-4-5?

650
00:46:44,650 --> 00:46:49,410
No já si ji prohlédnout zde.

651
00:46:49,410 --> 00:47:02,360
Podobně, vidím 6-7-8 jako řádek, ale pak je to vlastně sloupec tady.

652
00:47:02,360 --> 00:47:07,830
To je model, který jsem vidět hned, ale tam jsou asi několik dalších z nich.

653
00:47:07,830 --> 00:47:11,980
Na základě toho, že z nějakého druhu vzoru, nějaké cesty.

654
00:47:11,980 --> 00:47:20,290
Jakmile jste identifikovali jednu, pak budete chtít obnovit hodnoty v mřížce.

655
00:47:20,290 --> 00:47:25,480
Takže mřížka 0-0 stane 6, bude mřížka 0-1 stanou 3.

656
00:47:25,480 --> 00:47:32,990
Ale pamatujte si, že budeš - například, když znovu to hned,

657
00:47:32,990 --> 00:47:49,170
říci, že síť 0-2 stává 0 teď, potom ztratíte to, co 2 tam byl.

658
00:47:49,170 --> 00:47:52,380
Tak vzpomínal, že to nestačí jen přiřadit hned.

659
00:47:52,380 --> 00:47:56,420
Pravděpodobně budete chtít, aby se dočasné kopie něco

660
00:47:56,420 --> 00:48:08,380
než je skutečně dát jej na správném místě.

661
00:48:08,380 --> 00:48:11,860
>> Poslední věc, kterou je implementace případ necitlivosti.

662
00:48:11,860 --> 00:48:19,310
Když se podíváte zpět, podívejte se na místě v spec, kde uživatelské vstupy řetězec.

663
00:48:19,310 --> 00:48:22,700
Pokud si vzpomínáte zpět, vzpomínal na - oh, jsem vymazal mapu.

664
00:48:22,700 --> 00:48:30,300
Pokud si myslíte, že zpět na mapu vašeho programu, je to v rámci hlavní funkce,

665
00:48:30,300 --> 00:48:33,850
tak se podívejte, kde máte co do činění s uživatelsky zadaném řetězci,

666
00:48:33,850 --> 00:48:38,260
a pak v tam, myslím, že z nástrojů, které jste se naučili z vašeho

667
00:48:38,260 --> 00:48:43,690
crypto Pset, Pset 2, a pak přemýšlet o způsobech, které by vás mohly být schopni

668
00:48:43,690 --> 00:48:48,640
umožnit vstup uživatele jako smíšené.

669
00:48:48,640 --> 00:48:53,980
Aby mohli mít kombinaci uppercases a velkých písmen, ale to by mělo být stále v platnosti.

670
00:48:53,980 --> 00:48:59,770
Ve slovníku, vzpomínám, když jsme otevřeli tento soubor, byl každé slovo uložen jako všechna velká.

671
00:48:59,770 --> 00:49:05,880
Ale nechceme, aby měl uživatel na vstupu velkým celou dobu.

672
00:49:05,880 --> 00:49:12,150
Může někdo myslet tak, že bychom mohli být schopni umožnit uživateli,

673
00:49:12,150 --> 00:49:18,320
i když vloženy všechny malá písmena, například? Jo?

674
00:49:18,320 --> 00:49:20,540
[Student] Dalo by se udělat to horní?

675
00:49:20,540 --> 00:49:23,470
Jo, přesně tak. Dalo by se udělat to horní.

676
00:49:23,470 --> 00:49:27,670
Takže byste mohli převést všechny dopisy na velká písmena, a pak

677
00:49:27,670 --> 00:49:30,950
Tímto způsobem můžete zajistit, že bude přesná kopie

678
00:49:30,950 --> 00:49:35,410
z co je ve slovníku, pokud je to ve slovníku.

679
00:49:35,410 --> 00:49:40,910
Great. Máme trochu času vlevo.

680
00:49:40,910 --> 00:49:47,530
>> Takže některé věci, které se mohou vyskytnout v tomto PSet je potřeba znát

681
00:49:47,530 --> 00:49:52,400
jaké jsou vaše proměnné jsou v určitém okamžiku v čase.

682
00:49:52,400 --> 00:49:57,000
Protože v spec máme jasnou funkci, která v podstatě

683
00:49:57,000 --> 00:50:05,500
vymaže, co jste nakreslili na tabuli, vymaže to vše a pak přepíše na vrcholu, že

684
00:50:05,500 --> 00:50:10,630
můžete, zatímco vy píšete svůj PSet, opravdu nechci aby se to stalo.

685
00:50:10,630 --> 00:50:13,810
Vzhledem k tomu, že budete chtít vidět, jo, jednou jsem vstoupit do této tahanice, například,

686
00:50:13,810 --> 00:50:19,720
jednou jsem vstoupit do rvačky, co to dělá a co to bylo předtím, jen pro referenční.

687
00:50:19,720 --> 00:50:24,680
Takže to, co budete chtít udělat, je jít zpátky do své hlavní funkce

688
00:50:24,680 --> 00:50:31,530
a zakomentujte jasné, například.

689
00:50:31,530 --> 00:50:34,060
Takže pak při spuštění programu příště,

690
00:50:34,060 --> 00:50:45,210
váš program nebude jasné, že místo toho, a bude pokračovat v tom, tisk na vrcholu toho.

691
00:50:45,210 --> 00:50:47,210
Existují některé další způsoby, jak ladit také.

692
00:50:47,210 --> 00:50:51,500
Co můžete udělat, je, že můžete zahrnout příkazy tisku f, myslím.

693
00:50:51,500 --> 00:50:57,460
Jedna věc, kterou jsem viděl v psets, že jsem se stupněm bylo, že lidé včetně prohlášení tiskové f

694
00:50:57,460 --> 00:51:02,710
vytisknout proměnných v určitém okamžiku sledovat.

695
00:51:02,710 --> 00:51:06,820
Ale jen se ujistěte, že na konci, poté, co jste dopsal všechny vaše prohlášení tiskové f

696
00:51:06,820 --> 00:51:11,610
pro vás sledovat věci, které jste komentář ven poté,

697
00:51:11,610 --> 00:51:15,530
nebo je odstranit, jakmile jste hotovi.

698
00:51:15,530 --> 00:51:21,890
To je další způsob, jak byste mohli udělat něco, vy jste mohli jen psát v prohlášení tiskové f

699
00:51:21,890 --> 00:51:26,260
někde, že je to důležité a uvidíme, na základě toho, co terminál vytiskne,

700
00:51:26,260 --> 00:51:28,950
co to proměnná je.

701
00:51:28,950 --> 00:51:33,320
>> Dalším způsobem, jak to udělat, že půjdeme do detailů během přednášky,

702
00:51:33,320 --> 00:51:36,710
je GDB, který je ladicí nástroj.

703
00:51:36,710 --> 00:51:47,270
V podstatě, když ho spustíte, bude to jít do svého programu, a můžete jej mít předem

704
00:51:47,270 --> 00:51:51,500
jeden krok v době, namísto vyhodnocování všechno.

705
00:51:51,500 --> 00:51:54,770
Takže pak může zlomit to až do malých krocích, a pak na základě cestě -

706
00:51:54,770 --> 00:52:00,230
a pak po cestě tiskové věci a uvidíme, jaké hodnoty jsou.

707
00:52:00,230 --> 00:52:07,830
A že vám pomůže zjistit, kde chyba v kódu může být.

708
00:52:07,830 --> 00:52:12,970
To, co jsme mohli udělat právě teď rychle napsat funkci a pak

709
00:52:12,970 --> 00:52:19,780
vidět, jak bychom mohli být schopni používat GDB, aby viděli, co se děje.

710
00:52:19,780 --> 00:52:23,410
Takže pojďme se mají int main, a pak to, co máme jako parametry main?

711
00:52:23,410 --> 00:52:32,690
Máme int arg c, a string arg v.

712
00:52:32,690 --> 00:52:44,900
Jdu zachránit to v návodu, jak GDB.z. Dobrá.

713
00:52:44,900 --> 00:52:48,300
Budu mít návratnost 0.

714
00:52:48,300 --> 00:52:59,390
Tak jak o tom pojďme si jen tak jednoduchý pro vedení; pojďme se 12.

715
00:52:59,390 --> 00:53:06,750
Pojďme mít také int s názvem counter, a

716
00:53:06,750 --> 00:53:11,910
můžeme začít že při 0. Dobře.

717
00:53:11,910 --> 00:53:17,760
Takže v každém bodě pro smyčce, řekněme, že chceme zvýšit počítadlo

718
00:53:17,760 --> 00:53:26,980
nebo vynásobte to o co jsem je.

719
00:53:26,980 --> 00:53:39,650
To je docela krátký funkce.

720
00:53:39,650 --> 00:53:46,290
Pojďme udělat GDB. Oh! A pak - zvonění je chytrý.

721
00:53:46,290 --> 00:54:03,780
Říká mi, že jsem neměl obsahovat cs50.h.

722
00:54:03,780 --> 00:54:16,160
Dobrá. Takže teď chceme -

723
00:54:16,160 --> 00:54:32,740
Vlastně, je mi líto kluci. Chystám se přejmenovat soubor jen proto, že je to trochu matoucí.

724
00:54:32,740 --> 00:54:43,630
>> Dobrá. Takže teď to, co chceme udělat, je, chceme začít GDB.

725
00:54:43,630 --> 00:54:51,750
Řekl jsem "GDB ladění," takže v podstatě to bude nastavena zaměřit se na tomto ladění,

726
00:54:51,750 --> 00:54:55,540
ladění souboru.

727
00:54:55,540 --> 00:54:57,930
Jdu dát zarážku.

728
00:54:57,930 --> 00:55:01,160
V podstatě, program bude běžet, dokud nenarazí na určité zarážky.

729
00:55:01,160 --> 00:55:04,910
Jdu říct přestávku na hlavní funkci.

730
00:55:04,910 --> 00:55:12,680
Takže teď budu provozovat ladění, takže uvnitř GDB mohu spustit kód.

731
00:55:12,680 --> 00:55:17,710
Je to běh programu, a to i když hlavní je jednou z prvních věcí, které jsme udělali,

732
00:55:17,710 --> 00:55:20,870
máme také hlavičkové soubory,, tam se věci děje již.

733
00:55:20,870 --> 00:55:25,930
To má zarážku na hlavní.

734
00:55:25,930 --> 00:55:29,900
Řekněme, že "další," takže můžeme pokračovat.

735
00:55:29,900 --> 00:55:33,300
To říká, že "int counter = 0".

736
00:55:33,300 --> 00:55:39,310
Já řeknu "tisk proti."

737
00:55:39,310 --> 00:55:42,980
To je zvláštní. Takže v podstatě očekáváme čítače je 0,

738
00:55:42,980 --> 00:55:46,680
ale GDB je jeden krok zpět, takže kdykoliv se říct dál,

739
00:55:46,680 --> 00:55:50,350
říká int counter = 0. To je další věc, že ​​to bude provádět.

740
00:55:50,350 --> 00:55:56,160
Dále klikněte - můžete říct dál znovu, nebo si můžete jen říct 'n',

741
00:55:56,160 --> 00:56:02,400
a teď, pokud tisknete, počítadlo je 0, jak jsme očekávali.

742
00:56:02,400 --> 00:56:07,570
V podstatě, to vytváří svůj vlastní druh proměnných pro něj, ale bez ohledu na to, že -

743
00:56:07,570 --> 00:56:12,120
Líbí tady, to je to, co proti představuje.

744
00:56:12,120 --> 00:56:15,180
Takže budu klepněte na tlačítko Další, a já chci vědět, co jsem je.

745
00:56:15,180 --> 00:56:21,270
Budete tisknout i, i = 0, jak jsme očekávali.

746
00:56:21,270 --> 00:56:25,630
Další, to znamená, že to bude přes smyčky for znovu,

747
00:56:25,630 --> 00:56:32,970
takže když jsem vytisknout i, například, vidím, že jsme na -, že i je 1 v současné době.

748
00:56:32,970 --> 00:56:36,150
Takže je to tak, že pokud nastavíte zarážku na určité funkce

749
00:56:36,150 --> 00:56:39,520
a pak pokračovat dál další, a pak kontrola, co jsem je,

750
00:56:39,520 --> 00:56:45,790
Máte-li odhadovat, že možná někde něco není děje, jak by měl,

751
00:56:45,790 --> 00:56:51,340
a máte podezření, že je to možná na první indexu nebo k poslednímu indexu, nebo tak něco,

752
00:56:51,340 --> 00:57:00,110
můžete použít GDB, mějte na tisk i, aby bylo možné zkontrolovat, co tyto hodnoty.

753
00:57:00,110 --> 00:57:05,830
Takže, v GDB, protože tisk a další jsou takové běžné argumenty,

754
00:57:05,830 --> 00:57:11,240
běžné příkazy, stejně jako já zkráceno u n,

755
00:57:11,240 --> 00:57:22,010
Také mohu jen říct, s. pult, který je stále 0.

756
00:57:22,010 --> 00:57:25,610
Pak jsem klepněte na tlačítko Další. Chci vytisknout počítadlo znovu.

757
00:57:25,610 --> 00:57:26,790
No, tak to je stále 0.

758
00:57:26,790 --> 00:57:39,010
>> A ty jsi trochu přemýšlel - no, chci rozporu se funkce pro výpočet faktoriálu.

759
00:57:39,010 --> 00:57:43,930
Proč - jen v technikách ladění - proč by to mohlo být?

760
00:57:43,930 --> 00:57:48,160
Proč se čítač není zvýšení jejich hodnoty?

761
00:57:48,160 --> 00:57:53,100
Proč je pobyt v 0?

762
00:57:53,100 --> 00:57:59,320
No, tady mám - zpátky sem Já říkám counter = counter x i.

763
00:57:59,320 --> 00:58:02,180
Takže když jsem se vrátit na začátek mé funkce,

764
00:58:02,180 --> 00:58:09,520
Vidím, že když jsem vytiskl i, i je 0, a to, co je 0 x něco?

765
00:58:09,520 --> 00:58:13,700
To je 0, ne? Takže to je asi důvod, proč counter

766
00:58:13,700 --> 00:58:16,960
se nikdy nebude žádné jiné číslo.

767
00:58:16,960 --> 00:58:21,920
Tak co bych mohl chtít udělat, je jít zpátky do mého fuction,

768
00:58:21,920 --> 00:58:27,410
řekněme, dobře, dobře vlastně chci spustit na 1.

769
00:58:27,410 --> 00:58:32,150
Je to, že bude řešit věci?

770
00:58:32,150 --> 00:58:34,550
Ne tak docela, protože čítač je stále 0 zde.

771
00:58:34,550 --> 00:58:42,390
Tak pojďme nastavit, že k 1.

772
00:58:42,390 --> 00:58:49,040
Chceme obnovit naši ladění nástroje, tak se pojďme přestat.

773
00:58:49,040 --> 00:58:54,000
A pak to, co můžeme udělat, je, že jsme si GDB ladění znovu,

774
00:58:54,000 --> 00:59:05,620
dát přestávku na hlavní, a pak spustit ladění znovu, next, next, next.

775
00:59:05,620 --> 00:59:12,520
Jdeme příští několikrát, a pak budeme tisknout pult, vidět, že -

776
00:59:12,520 --> 00:59:16,140
jsme neměli správně, aby soubor znovu.

777
00:59:16,140 --> 00:59:19,500
I když jsme změnili zdrojový kód, pak jsme vlastně

778
00:59:19,500 --> 00:59:21,660
neaktualizoval náš spustitelný.

779
00:59:21,660 --> 00:59:27,310
Věřím, že můžete udělat - jo.

780
00:59:27,310 --> 00:59:29,880
V GDB sám, můžete skutečně udělat soubor.

781
00:59:29,880 --> 00:59:31,880
Takže nemusíte přestat GDB znovu.

782
00:59:31,880 --> 00:59:36,180
Můžete se vrátit do zdrojového souboru, uložte jej, zpět v GDB, můžete jej znovu.

783
00:59:36,180 --> 00:59:40,850
Great. Tak pojďme běžet ladění.

784
00:59:40,850 --> 00:59:45,900
Chceme začít od začátku, protože máme novou spustitelný.

785
00:59:45,900 --> 00:59:54,870
Můžeme projít několikrát, a pak vytisknout i, tisk čítač pokračovat.

786
00:59:54,870 --> 00:59:59,090
Dobrá. Takže teď je vidět, že proti je skutečně zvyšuje svou hodnotu, jak chceme, aby.

787
00:59:59,090 --> 01:00:03,340
>> To je jen malinké bite-sized příklad toho, jak můžete použít GDB

788
01:00:03,340 --> 01:00:09,700
zadejte kód, tisknout určité hodnoty, klepněte na tlačítko Další pokračovat na další řádek,

789
01:00:09,700 --> 01:00:12,960
a zkrátit ji a vytisknout.

790
01:00:12,960 --> 01:00:18,690
Je zřejmé, že kód v vyškrábat je trochu složitější, než to, ale co se dá dělat

791
01:00:18,690 --> 01:00:26,980
je nastavit zarážku na - můžete nastavit zarážku na seznam vyhledávacích funkcí, něco takového.

792
01:00:26,980 --> 01:00:29,440
Takže vždy, když se dostane do bodu, kdy potřebuje vypadat up,

793
01:00:29,440 --> 01:00:37,340
pak GDB poběží vše až do tohoto bodu, a pak můžete začít s tiskem hodnoty ven.

794
01:00:37,340 --> 01:00:42,030
Stejně jako je značky v tomto bodě falešné, nebo je to pravda?

795
01:00:42,030 --> 01:00:46,580
To je asi něco, co budete chtít použít.

796
01:00:46,580 --> 01:00:49,060
GDB, nemusíte zdůrazňovat příliš mnoho o tom,

797
01:00:49,060 --> 01:00:51,270
protože jsme se jít do větších podrobností v přednášce,

798
01:00:51,270 --> 01:00:54,570
ale jen jsem chtěl, aby jste věděli, jak byste měli být schopni používat

799
01:00:54,570 --> 01:01:00,120
pokud jste Začínáme s PSet a chci pochopit

800
01:01:00,120 --> 01:01:05,040
lepší způsob, než jen uvedení prohlášení tiskové f a odhazování je to vše prostřednictvím vašeho kódu.

801
01:01:05,040 --> 01:01:10,430
S GDB skutečně jej pro Vás natiskneme a být schopen nastavit tyto zarážky

802
01:01:10,430 --> 01:01:12,980
tak, aby váš program může běžet až do určitého bodu

803
01:01:12,980 --> 01:01:21,660
a pak vám umožní opravdu krok do něj a zjistit problém tam.

804
01:01:21,660 --> 01:01:29,600
>> Právo. Takže když se podíváme zpět do tahanice, jsme četli distribuční kód.

805
01:01:29,600 --> 01:01:35,670
Mluvili jsme o způsobu, jak iterovat přes 2D pole, a budete určitě

806
01:01:35,670 --> 01:01:40,910
bude chtít iteraci 2D pole, když přijedete do výkresu herní mřížku.

807
01:01:40,910 --> 01:01:45,090
Mluvili jsme o tom vyhledávací funkci, o tom, jak chceme, aby se ujistil o pár věcí.

808
01:01:45,090 --> 01:01:48,300
Chceme se ujistit, že jsme nebyli na slova před.

809
01:01:48,300 --> 01:01:51,220
Chceme také, aby se ujistil, že je to vlastně ve slovníku.

810
01:01:51,220 --> 01:01:54,220
Pak jsme mluvili o rvačce, o tom, jak chceme otočit desku.

811
01:01:54,220 --> 01:01:58,170
A s vědomím, že budete chtít vytvořit kopii něco

812
01:01:58,170 --> 01:02:00,440
aby bylo možné pohybovat.

813
01:02:00,440 --> 01:02:03,250
Nakonec, jsme hovořili o případu a citlivosti, o tom, jak se chcete ujistit,

814
01:02:03,250 --> 01:02:07,290
že i přes jakákoliv kombinace případě, že uživatelské vstupy,

815
01:02:07,290 --> 01:02:10,170
pokud je to platné slovo ve slovníku,

816
01:02:10,170 --> 01:02:14,400
pak to bude nalézt správné.

817
01:02:14,400 --> 01:02:21,290
Takže všechno dohromady je scramble Pset, a že je průchod 3.

818
01:02:21,290 --> 01:02:29,180
Díky všem za účast, a hodně štěstí s bojem.

819
01:02:29,180 --> 01:02:32,180
CS50.TV