1
00:00:00,000 --> 00:00:01,940
[Powered by Google Translate] [Walkthrough - Problem Indstil 2]

2
00:00:01,940 --> 00:00:04,130
[Zamyla Chan - Harvard University]

3
00:00:05,170 --> 00:00:07,490
[Dette er CS50. CS50.TV]

4
00:00:07,490 --> 00:00:10,750
Ok. Hej, alle sammen, og velkommen til Walkthrough 2.

5
00:00:10,750 --> 00:00:14,330
Først vil jeg gerne lykønske dig til efterbehandling Pset 1.

6
00:00:14,330 --> 00:00:18,140
Jeg ved, at det kunne have været en smule hård for nogle af jer,

7
00:00:18,140 --> 00:00:20,460
kunne have været din første computer program, du skrev,

8
00:00:20,460 --> 00:00:24,500
men bare husk, at ved udgangen af ​​dette, når man ser tilbage i slutningen af ​​semestret,

9
00:00:24,500 --> 00:00:29,820
du vil se på Pset 1, og du vil sige, "Hey, jeg kunne have gjort det i 5 minutter."

10
00:00:29,820 --> 00:00:35,700
Så kender og stoler på, at ved udgangen af ​​dette, vil du helt sikkert finde Pset 1 ganske enkel.

11
00:00:35,700 --> 00:00:40,640
Men for nu er det en kæmpe bedrift, og tillykke til at få gjort.

12
00:00:40,640 --> 00:00:44,010
Nu også en hurtig note, før vi kommer ind i kødet på walkthrough.

13
00:00:44,010 --> 00:00:48,340
Jeg ønsker blot at gøre en hurtig bemærkning, at jeg nogle gange ikke vil have tid nok

14
00:00:48,340 --> 00:00:52,500
under walkthroughs til at gå igennem hver eneste måde at gøre det problem sæt

15
00:00:52,500 --> 00:00:56,140
og snarere blot måske fokusere på 1 eller 2 slags implementeringer,

16
00:00:56,140 --> 00:00:57,750
måder, du kan gøre dette.

17
00:00:57,750 --> 00:01:01,970
Men det er ikke til at sige, at du er forbudt fra at gøre det på en anden måde.

18
00:01:01,970 --> 00:01:05,980
Der er ofte, som med datalogi, utallige måder at gøre tingene på,

19
00:01:05,980 --> 00:01:12,190
og så absolut velkommen til at bruge en anden type løsning end jeg måtte have fremlagt.

20
00:01:12,190 --> 00:01:14,520
[Pset 2: Crypto - Zamyla Chan - zamyla@cs50.net]

21
00:01:14,520 --> 00:01:17,160
[Pset2 - 0. En sektion af spørgsmål - 1. Cæsar - 2. Vigenere]

22
00:01:17,160 --> 00:01:20,650
Ok. Så problem sæt 2: Crypto er en sjov én.

23
00:01:20,650 --> 00:01:24,500
Igen, med hver Pset du vil starte med et afsnit med spørgsmål

24
00:01:24,500 --> 00:01:29,600
der kommer til at ske i dine afsnit med dit tildelte undervisning fyr.

25
00:01:29,600 --> 00:01:31,670
Vi vil ikke gå igennem disse over walkthrough,

26
00:01:31,670 --> 00:01:35,100
men de helt sikkert vil hjælpe dig fuldføre Pset.

27
00:01:35,100 --> 00:01:38,100
Så den første del af problemet sættet er Cæsar.

28
00:01:38,100 --> 00:01:43,470
Og så i Cæsar nogen vil passere dig en nøgle med et heltal,

29
00:01:43,470 --> 00:01:48,420
og du vil kryptere en tekststreng, at de giver dig

30
00:01:48,420 --> 00:01:50,670
og give dem tilbage en krypteret ting.

31
00:01:50,670 --> 00:01:56,050
Hvis nogen så A Christmas Story, der er et eksempel på, at der.

32
00:01:56,050 --> 00:01:59,090
Derefter den anden del af problemet sættet Vigenere,

33
00:01:59,090 --> 00:02:01,790
som er en mere avanceret kryptering teknik.

34
00:02:01,790 --> 00:02:05,640
Og så vil vi kryptografere et stykke tekst,

35
00:02:05,640 --> 00:02:09,600
undtagen i stedet med blot et enkelt heltal, vi faktisk kommer til at indkode det

36
00:02:09,600 --> 00:02:13,340
med et søgeord, som brugeren vil give os.

37
00:02:16,270 --> 00:02:22,090
Okay, så det første værktøj i værktøjskassen i dag rent faktisk vil være en opdatering af apparatet.

38
00:02:22,090 --> 00:02:26,430
På diskussionsforummet vi ville se ting som, "Hvorfor ikke dette arbejde?"

39
00:02:26,430 --> 00:02:28,110
"Hvorfor ikke Indsend 50 arbejde?"

40
00:02:28,110 --> 00:02:31,830
og ofte er løsningen faktisk bare at opdatere dit apparat.

41
00:02:31,830 --> 00:02:36,730
Og så hvis du bare køre i en terminal vindue i apparatet sudo yum-y -

42
00:02:36,730 --> 00:02:40,040
det er et flag siger ja, opdatere alt - opdatering,

43
00:02:40,040 --> 00:02:42,280
så apparatet vil opdatere hvis det er nødvendigt.

44
00:02:42,280 --> 00:02:46,960
Og det gør ikke ondt, hvis du allerede er på den seneste version af apparatet.

45
00:02:46,960 --> 00:02:51,280
Så vil det bare sige ingen nye opdateringer tilgængelige, og du kan fortsætte med at arbejde sammen.

46
00:02:51,280 --> 00:02:55,800
Men det er godt at udføre selv hver gang du åbner apparatet

47
00:02:55,800 --> 00:02:57,140
fordi vi er stadig meget -

48
00:02:57,140 --> 00:03:00,320
nogle gange, hvis vi kommer ind i en bug - fastsættelse det i apparatet.

49
00:03:00,320 --> 00:03:03,180
Så sørg for at du har den seneste version af apparatet

50
00:03:03,180 --> 00:03:07,710
og køre der opdateres der.

51
00:03:07,710 --> 00:03:14,360
Ok. Så da vi har at gøre med breve og forandring, enciphering ting,

52
00:03:14,360 --> 00:03:20,410
vi vil virkelig ønsker at blive bedste venner med vores ASCII diagram.

53
00:03:20,410 --> 00:03:24,350
Der er talrige dem online, hvis du finder. Måske endda lave dine egne.

54
00:03:24,350 --> 00:03:29,950
Dybest set, med hvert brev og hver nummer, og hvert tegn

55
00:03:29,950 --> 00:03:32,210
der er et tal forbundet med dem,

56
00:03:32,210 --> 00:03:38,670
og så det er godt at se deres ASCII-værdier siden af ​​den egentlige bogstav.

57
00:03:38,670 --> 00:03:42,310
Det vil helt sikkert hjælpe dig i problemet sæt.

58
00:03:42,310 --> 00:03:45,750
En ting, der virkelig hjalp mig i dette problem sæt var til rent faktisk at printe det ud,

59
00:03:45,750 --> 00:03:48,380
og da jeg gik igennem, ville jeg faktisk trække på det,

60
00:03:48,380 --> 00:03:51,150
skrive, "Hvis dette skal gå til der, så ..."

61
00:03:51,150 --> 00:03:55,270
Kind of trække på det og mærke det op, bliver bedste venner med din ASCII-tabellen.

62
00:03:57,240 --> 00:04:00,750
Så har vi et par andre værktøjer til vores rådighed.

63
00:04:00,750 --> 00:04:03,750
Denne gang i stedet for rent faktisk at spørge brugeren for alle deres input

64
00:04:03,750 --> 00:04:05,230
vi vil gøre en kombination.

65
00:04:05,230 --> 00:04:06,880
Vi vil bede dem for nogle input,

66
00:04:06,880 --> 00:04:11,350
men vi vil også bare bruge de kommandolinjeargumenter.

67
00:04:11,350 --> 00:04:15,600
Så når de kører deres program, du normalt siger. / Hej, for eksempel,

68
00:04:15,600 --> 00:04:17,310
hvis dit program var hello.c.

69
00:04:17,310 --> 00:04:22,500
Men denne gang i stedet for bare at sige, at de kan sætte ord, argumenter bagefter.

70
00:04:22,500 --> 00:04:27,210
Og så vi kommer til at bruge, hvad de passerer ind til os som deres input så godt,

71
00:04:27,210 --> 00:04:31,720
så gå videre end blot at spørge til heltal, men også anvende kommandolinjeargumenter.

72
00:04:31,720 --> 00:04:36,590
Og så vil vi gå ind i arrays og strenge, som vi kommer til at bruge en masse så godt.

73
00:04:41,460 --> 00:04:44,810
Her er bare et eksempel på 1 mini ASCII diagram.

74
00:04:44,810 --> 00:04:48,460
Som jeg sagde, hvert bogstav svarer til et nummer,

75
00:04:48,460 --> 00:04:52,510
og så sætte dig ind i det. Det vil komme i handy.

76
00:04:52,510 --> 00:04:55,610
Og senere, når vi begynder at gøre noget ASCIIMath beskæftiger sig med numre -

77
00:04:55,610 --> 00:05:00,110
tilføjer, subtraktion dem - så absolut gode til at henvise til denne oversigt.

78
00:05:02,860 --> 00:05:06,920
Så her er et eksempel på en Caesar cipher - noget, som du kan have spillet med.

79
00:05:06,920 --> 00:05:11,190
Det er bare et hjul. Det væsentlige, er der et ydre alfabet og så er der en indre alfabet.

80
00:05:11,190 --> 00:05:15,290
Så her er et eksempel på Caesar cipher men med en nøgle fra 0.

81
00:05:15,290 --> 00:05:21,540
Det væsentlige er en linie med A, B på linie med B, hele vejen op til Z.

82
00:05:21,540 --> 00:05:26,590
Men så siger vi ønskede en nøgle på 3, for eksempel.

83
00:05:26,590 --> 00:05:33,280
Så ville vi dreje den indvendige hjul, således at A nu flugter med D osv.

84
00:05:33,280 --> 00:05:35,250
Og så dette er væsentligt, hvad vi skal gøre.

85
00:05:35,250 --> 00:05:38,340
Vi har ikke et hjul, men hvad vi vil gøre, er at gøre vores program

86
00:05:38,340 --> 00:05:44,490
slags flytte alfabetet sammen med os en vis mængde numre.

87
00:05:44,490 --> 00:05:48,650
Så som jeg sagde før, vi kommer til at beskæftige sig med kommandolinjeargumenter

88
00:05:48,650 --> 00:05:50,390
samt få et heltal.

89
00:05:50,390 --> 00:05:55,050
Så den måde, at en bruger vil køre din Cæsar program er ved at sige. / Caesar

90
00:05:55,050 --> 00:05:58,090
og derefter indtaste et nummer efter det.

91
00:05:58,090 --> 00:06:01,130
Og det nummer repræsenterer nøglen, skiftet,

92
00:06:01,130 --> 00:06:06,740
hvor mange gange du vil komme til at dreje den indvendige hjul på din Cæsar cipher.

93
00:06:06,740 --> 00:06:08,390
Og så kan du se her et eksempel.

94
00:06:08,390 --> 00:06:14,550
Hvis vi indtastet bogstaver fra A til L i vores Cæsar cipher,

95
00:06:14,550 --> 00:06:19,520
Så ville det input D gennem O, fordi det er hvert bogstav skiftet over 3 gange,

96
00:06:19,520 --> 00:06:22,080
ligesom eksemplet med hjul, som jeg viste dig.

97
00:06:22,080 --> 00:06:25,300
Så hvis du har indtastet, for eksempel, er dette CS50!

98
00:06:25,300 --> 00:06:27,960
så ville det også flytte alle bogstaverne.

99
00:06:27,960 --> 00:06:31,040
Og det er en vigtig ting i både Cæsar og Vigenere

100
00:06:31,040 --> 00:06:34,890
er, at vi kommer til at springe over alle ikke-breve.

101
00:06:34,890 --> 00:06:39,160
Så eventuelle mellemrum, tegn, osv, tal, vi kommer til at holde dem det samme.

102
00:06:39,160 --> 00:06:42,920
Vi kun kommer til at flytte bogstaverne i dette tilfælde.

103
00:06:42,920 --> 00:06:45,870
Så som du kan se i hjulet, vi kun har bogstaverne vi har til rådighed,

104
00:06:45,870 --> 00:06:50,150
så vi kun ønsker at flytte bogstaverne og kryptere breve.

105
00:06:51,370 --> 00:06:56,720
Så den første ting at gøre, så du at anvendelsen til Cæsar i problem sæt 2

106
00:06:56,720 --> 00:07:05,280
er at drive Cæsar og derefter indtaste et nummer, når du kører det i terminalen.

107
00:07:05,280 --> 00:07:10,940
Så hvad vi skal gøre, er at en eller anden måde få denne nøgle og få adgang til det.

108
00:07:10,940 --> 00:07:14,730
Og så vil vi en eller anden måde se det kommer til at være den anden kommandolinje argument.

109
00:07:14,730 --> 00:07:20,950
Den første vil være. / Caesar, og den næste vil være nøglen nummer.

110
00:07:22,190 --> 00:07:29,200
Så før vi havde int main (void) for at starte vores C-programmer.

111
00:07:29,200 --> 00:07:31,790
Vi kommer til at skrælle tilbage et lag lidt

112
00:07:31,790 --> 00:07:34,720
og faktisk se at i stedet for at passere i tomrum til vores vigtigste funktion

113
00:07:34,720 --> 00:07:37,920
Vi er faktisk beskæftiger sig med 2 parametre.

114
00:07:37,920 --> 00:07:44,070
Vi har en int opkaldt argc og derefter en vifte af strenge kaldet argv.

115
00:07:44,070 --> 00:07:46,030
Så argc er et helt tal,

116
00:07:46,030 --> 00:07:49,640
og det repræsenterer antallet af argumenter, der sendes til dit program.

117
00:07:49,640 --> 00:07:53,590
Og derefter argv er faktisk en liste over de passerede argumenter.

118
00:07:53,590 --> 00:08:00,820
Alle argumenter er strenge, og så argv repræsenterer et array, en liste af strenge.

119
00:08:01,830 --> 00:08:03,990
Lad os tale om arrays en lille smule.

120
00:08:03,990 --> 00:08:05,940
Arrays er hovedsagelig en ny datastruktur.

121
00:08:05,940 --> 00:08:09,660
Vi har int'er, har vi fordobler, har vi strenge, og nu har vi arrays.

122
00:08:09,660 --> 00:08:13,820
Arrays er datastrukturer, der kan indeholde flere værdier af samme type,

123
00:08:13,820 --> 00:08:18,320
så væsentlige, en liste af enhver art, du ønsker.

124
00:08:18,320 --> 00:08:24,400
Væsentlige, hvis du ønskede en liste af heltal alt i 1 variabel,

125
00:08:24,400 --> 00:08:29,090
så ville du oprette en ny variabel, der var af typen int array.

126
00:08:29,090 --> 00:08:34,450
Så arrays er nul-indekseret, hvilket betyder, at det første element i array ligger på indeks 0.

127
00:08:34,450 --> 00:08:41,799
Hvis matrixen har længden 4, som i dette eksempel, så det sidste element ville være ved indeks 3,

128
00:08:41,799 --> 00:08:44,810
som er 4-1.

129
00:08:45,940 --> 00:08:48,420
Så for at skabe array, ville du gøre noget som dette.

130
00:08:48,420 --> 00:08:51,440
Sig du ønskede en dobbelt array.

131
00:08:51,440 --> 00:08:56,520
Det gælder for enhver form for datatype, selv om.

132
00:08:56,520 --> 00:09:00,210
Så siger du ønsker et dobbelt array. Sig du vil kalde det postkasse.

133
00:09:00,210 --> 00:09:04,760
Ligesom du ville initialisere nogen anden dobbelt,

134
00:09:04,760 --> 00:09:09,760
ville du sige dobbelt og derefter navnet, men denne gang vi sætter de firkantede parenteser,

135
00:09:09,760 --> 00:09:13,570
og derefter tallet vil der være længden af ​​array'et.

136
00:09:13,570 --> 00:09:16,840
Bemærk, at i arrays kan vi aldrig ændre længden,

137
00:09:16,840 --> 00:09:21,230
så du altid nødt til at definere og vælge, hvor mange kasser,

138
00:09:21,230 --> 00:09:25,440
hvor mange værdier dit array kommer til at holde.

139
00:09:25,440 --> 00:09:31,820
Så for at indstille forskellige værdier i dit array, du vil bruge denne følgende syntaks,

140
00:09:31,820 --> 00:09:33,200
som du kan se på diaset.

141
00:09:33,200 --> 00:09:37,620
Du har postkasse indeks 0 vil blive sat til 1,2,

142
00:09:37,620 --> 00:09:42,180
postkasse indeks 1 sæt til 2,4, etc.

143
00:09:42,180 --> 00:09:47,910
Så nu, at vi har gennemgået arrays lidt, lad os gå tilbage til argc og argv.

144
00:09:47,910 --> 00:09:52,220
Vi ved, at argv er nu et array af strenge.

145
00:09:52,220 --> 00:09:55,080
Så når en bruger går på - siger, at de kører et program -

146
00:09:55,080 --> 00:09:58,740
de siger. / hej David Malan,

147
00:09:58,740 --> 00:10:05,160
hvad programmet vil gøre for dig allerede er faktisk kommet op med, hvad argc og argv er.

148
00:10:05,160 --> 00:10:07,620
Så du behøver ikke at bekymre dig om det.

149
00:10:07,620 --> 00:10:14,370
Argc i dette tilfælde ville være 3, fordi det ser 3 forskellige ord adskilt af mellemrum.

150
00:10:14,370 --> 00:10:18,850
Og så derefter array i dette tilfælde, ville det første indeks være. / Hej,

151
00:10:18,850 --> 00:10:21,770
den næste David, den næste Malan.

152
00:10:21,770 --> 00:10:25,640
Er der nogen se med det samme, hvad forholdet mellem argv,

153
00:10:25,640 --> 00:10:28,990
 array, og argc er?

154
00:10:32,820 --> 00:10:38,090
Yeah. Vi vil komme ind på dette i et eksempel i args.c.

155
00:10:38,090 --> 00:10:42,880
Lad os se, om vi kan drage fordel af forholdet mellem 2.

156
00:10:42,880 --> 00:10:46,550
Her kan du måske finde, at i apparatet standardprogrammet

157
00:10:46,550 --> 00:10:49,450
til at åbne. C-filer er nogle gange Emacs.

158
00:10:49,450 --> 00:10:54,660
Men vi ønsker at beskæftige sig med gedit, så hvad du kan gøre er, kan du højreklikke på dit C-fil,

159
00:10:54,660 --> 00:11:04,580
gå til Egenskaber, Åbn med og derefter vælge gedit, som standard,

160
00:11:04,580 --> 00:11:13,020
og nu dit program skal åbne i gedit stedet for Emacs.

161
00:11:14,710 --> 00:11:16,290
Perfekt.

162
00:11:17,120 --> 00:11:25,520
Så her har jeg et program, som jeg ønsker at udskrive hver Kommandolinjeargumentet.

163
00:11:25,520 --> 00:11:32,050
Så uanset bruger inputs, jeg ønsker at væsentlige leverer det tilbage til dem på en ny linje.

164
00:11:32,050 --> 00:11:36,710
Så hvad er en struktur, som vi kan bruge til at gentage over noget -

165
00:11:36,710 --> 00:11:40,380
noget, som du sikkert brugt i din Pset 1?

166
00:11:40,380 --> 00:11:45,840
Hvis du ønsker at gå igennem et bestemt antal ting? >> [Studerende] For løkke.

167
00:11:45,840 --> 00:11:48,910
For loop. Præcis. Så lad os starte med for-løkken.

168
00:11:48,910 --> 00:11:56,900
Vi har for int i = 0. Lad os bare starte med en standard initialisering variabel.

169
00:11:56,900 --> 00:12:02,370
Jeg har tænkt mig at forlade betingelse for et sæt, og derefter sige jeg + +, vil gøre tingene der.

170
00:12:02,370 --> 00:12:04,090
Ok.

171
00:12:04,090 --> 00:12:11,590
Så tænker tilbage til argv, hvis argv er listen over argumenter, der overføres på programmet

172
00:12:11,590 --> 00:12:15,380
og argc er antallet af argumenter i programmet,

173
00:12:15,380 --> 00:12:21,280
så betyder, at argc i det væsentlige længden af ​​argv, højre,

174
00:12:21,280 --> 00:12:28,970
fordi der vil være så mange argumenter som værdien af ​​argc.

175
00:12:28,970 --> 00:12:35,910
Så hvis vi ønsker at gentage over hvert element i argv,

176
00:12:35,910 --> 00:12:43,290
vi vil ønsker at hver gang adgang til variabel i argv ved den givne indeks.

177
00:12:43,290 --> 00:12:49,060
Det kan være repræsenteret med dette, right?

178
00:12:49,060 --> 00:12:53,430
Denne variabel her repræsenterer særlig streng i dette tilfælde

179
00:12:53,430 --> 00:12:57,030
fordi det er en streng array - den særlige streng på det givne indeks.

180
00:12:57,030 --> 00:13:00,690
Hvad vi ønsker at gøre, i dette tilfælde ønsker vi at printe det ud, så lad os sige printf.

181
00:13:00,690 --> 00:13:04,680
Og nu argv er en streng, så vi ønsker at sætte denne pladsholder der.

182
00:13:04,680 --> 00:13:08,430
Vi ønsker en ny linje bare for at gøre det til at se godt ud.

183
00:13:08,430 --> 00:13:12,530
Så her har vi en for-løkke. Vi har ikke den betingelse endnu.

184
00:13:12,530 --> 00:13:20,020
Så jeg starter på 0, og derefter hver gang det kommer til at udskrive den givne streng

185
00:13:20,020 --> 00:13:22,980
på det pågældende indeks i arrayet.

186
00:13:22,980 --> 00:13:28,410
Så når vi ønsker at stoppe udskrive elementer i array?

187
00:13:28,410 --> 00:13:35,720
Når vi er færdige, ikke? Når vi har nået slutningen af ​​array.

188
00:13:35,720 --> 00:13:38,870
Så vi ønsker ikke at overskride forbi længden af ​​array,

189
00:13:38,870 --> 00:13:43,700
og vi ved allerede, at vi ikke behøver at faktisk aktivt finde ud af, hvad længden af ​​argv er

190
00:13:43,700 --> 00:13:47,520
fordi det er givet os, og hvad er det? Argc. Præcis.

191
00:13:47,520 --> 00:13:56,640
Så vi ønsker at gøre denne proces argc antal gange.

192
00:13:56,640 --> 00:13:59,550
Jeg er ikke i den rigtige mappe.

193
00:14:02,100 --> 00:14:03,490
Ok.

194
00:14:03,490 --> 00:14:08,990
Nu lad os gøre args. Ingen fejl, som er stort.

195
00:14:08,990 --> 00:14:11,430
Så lad os bare køre args.

196
00:14:11,430 --> 00:14:15,130
Hvad er dette vil vende tilbage til os? Det er bare at udskrive det igen.

197
00:14:15,130 --> 00:14:18,320
"Du påtrykkes args i programmet, jeg har tænkt mig at give det tilbage til dig."

198
00:14:18,320 --> 00:14:23,170
Så lad os sige at vi vil sige args så foo bar.

199
00:14:23,170 --> 00:14:26,570
Så det udskriver det tilbage til os. Okay?

200
00:14:26,570 --> 00:14:30,790
Så der er et eksempel på, hvordan du kan bruge argc og argv

201
00:14:30,790 --> 00:14:33,460
ved, at argc repræsenterer længden af ​​argv.

202
00:14:33,460 --> 00:14:42,750
Sørg for, at du ikke nogensinde med arrays adgang en ud over længden af ​​array

203
00:14:42,750 --> 00:14:45,140
fordi C helt sikkert vil råbe på dig.

204
00:14:45,140 --> 00:14:47,560
Du får noget, der hedder en segmenteringsfejl,

205
00:14:47,560 --> 00:14:52,470
der er aldrig sjovt, dybest set siger, du forsøger at få adgang til noget

206
00:14:52,470 --> 00:14:55,000
, der ikke eksisterer, ikke tilhører dig.

207
00:14:55,000 --> 00:14:59,430
Så sørg for, og især med nul-indeksering, ønsker vi ikke at -

208
00:14:59,430 --> 00:15:02,390
Ligesom for eksempel, hvis vi har en bred vifte af længde 4,

209
00:15:02,390 --> 00:15:07,240
at arrayindeks 4 ikke eksisterer, fordi vi starter på 0, ved nul indeks.

210
00:15:07,240 --> 00:15:11,730
Det bliver anden karakter ligesom for loops, når vi starter på 0.

211
00:15:11,730 --> 00:15:13,610
Så bare holde det i tankerne.

212
00:15:13,610 --> 00:15:22,590
Du ønsker ikke at nogensinde adgang indekset for et array, der er uden for din rækkevidde.

213
00:15:26,710 --> 00:15:32,560
Så vi kan se nu, hvordan vi kan slags adgang

214
00:15:32,560 --> 00:15:35,930
de kommandolinjeargumenter, der er gået i.

215
00:15:35,930 --> 00:15:41,330
Men da du så strengen, argv er faktisk en streng array.

216
00:15:41,330 --> 00:15:45,740
Så det er faktisk ikke et heltal endnu, men i Cæsar vi ønsker at beskæftige sig med heltal.

217
00:15:45,740 --> 00:15:54,430
Heldigvis er der en funktion, som oprettes for os, der rent faktisk kan konvertere en streng til et heltal.

218
00:15:54,430 --> 00:15:58,710
Også her er vi ikke beskæftiger sig med brugerinput, hvor vi tilskynder dem

219
00:15:58,710 --> 00:16:03,740
for input her for nøglen, så vi kan faktisk ikke reprompt og sige,

220
00:16:03,740 --> 00:16:07,840
"Åh, giv mig en anden heltal, sige, hvis det ikke er gyldigt."

221
00:16:07,840 --> 00:16:10,540
Men vi behøver stadig nødt til at tjekke for korrekt brug.

222
00:16:10,540 --> 00:16:13,520
I Caesar de kun lov til at passere i 1 nummer,

223
00:16:13,520 --> 00:16:18,030
og så de er nødt til at køre. / caesar og derefter de nødt til at give dig et nummer.

224
00:16:18,030 --> 00:16:23,660
Så argc skal være et vist antal.

225
00:16:23,660 --> 00:16:29,060
Hvilket nummer ville det være, hvis de er nødt til at passere dig. / Cæsar og derefter en nøgle?

226
00:16:29,060 --> 00:16:32,920
Hvad er argc? >> [Studerende] 2. >> Two. Præcis.

227
00:16:32,920 --> 00:16:35,490
Så du vil være sikker på, at argc er 2.

228
00:16:35,490 --> 00:16:39,620
Ellers kan du dybest set nægte at køre programmet.

229
00:16:39,620 --> 00:16:43,040
I main det er en funktion, der siger int main,

230
00:16:43,040 --> 00:16:47,360
så da vi altid i god praksis return 0 ved afslutningen af ​​et vellykket program.

231
00:16:47,360 --> 00:16:50,840
Så hvis, siger, de giver dig 3 kommandolinjeargumenter i stedet for 2

232
00:16:50,840 --> 00:16:54,350
eller give dig 1, for eksempel, så hvad du vil gøre, er at du vil få lyst til at kontrollere for det

233
00:16:54,350 --> 00:16:59,900
og derefter vende tilbage 1 siger, nej, jeg kan ikke gå videre med dette program.

234
00:16:59,900 --> 00:17:03,190
[Studerende] Der kan ikke være et mellemrum i din tekst. >> Undskyld mig?

235
00:17:03,190 --> 00:17:06,780
[Elev] Der kan ikke være et mellemrum i teksten, du forsøger at kryptere.

236
00:17:06,780 --> 00:17:08,480
Ah!

237
00:17:08,480 --> 00:17:11,280
Med hensyn til den tekst, vi forsøger at kryptere, faktisk, der kommer senere

238
00:17:11,280 --> 00:17:13,970
når vi giver denne tekst.

239
00:17:13,970 --> 00:17:18,260
Så lige nu er vi bare acceptere som kommando argumenter det faktiske antal,

240
00:17:18,260 --> 00:17:21,579
den faktiske skifte for Cæsar kryptering.

241
00:17:21,579 --> 00:17:27,569
[Studerende] Hvorfor har du brug for 2 i modsætning til blot 1 argc? Der er helt sikkert 1 tal.

242
00:17:27,569 --> 00:17:32,200
Right. Grunden til at vi har brug for 2 for argc i stedet for 1

243
00:17:32,200 --> 00:17:36,260
er fordi, når du kører et program og sige. / Cæsar eller. / hej,

244
00:17:36,260 --> 00:17:38,280
der faktisk tæller som en kommandolinje argument.

245
00:17:38,280 --> 00:17:43,020
Så der allerede fylder 1 og så derefter vi indtaster 1 ekstra.

246
00:17:45,030 --> 00:17:49,440
Så du indtaster faktisk en streng i Kommandolinjeargumentet.

247
00:17:49,440 --> 00:17:52,730
Hvad du vil gøre, for Cæsar vi ønsker at beskæftige sig med et heltal,

248
00:17:52,730 --> 00:17:57,180
så du kan bruge denne atoi funktion.

249
00:17:57,180 --> 00:18:02,850
Og dybest set, du passerer det i en snor, og så vil du gå tilbage et heltal

250
00:18:02,850 --> 00:18:06,070
om det er muligt at foretage denne streng til et heltal.

251
00:18:06,070 --> 00:18:10,960
Nu huske, da vi har at gøre med printf eller GetString, ting som det,

252
00:18:10,960 --> 00:18:13,390
Vi inkluderer de biblioteker, der er specifikke for os.

253
00:18:13,390 --> 00:18:19,450
Så i begyndelsen starter vi med en hash tag standard I / O,. H, noget i den retning.

254
00:18:19,450 --> 00:18:22,430
Nå, atoi er ikke under et af disse biblioteker,

255
00:18:22,430 --> 00:18:26,600
så hvad vi skal gøre, er vi nødt til at omfatte retten bibliotek til det.

256
00:18:26,600 --> 00:18:32,720
Så huske tilbage til Walkthrough 1, hvor jeg diskuterede den manuelle funktion.

257
00:18:32,720 --> 00:18:37,110
Du skriver mand i din terminal og derefter efterfulgt af navnet på en funktion.

258
00:18:37,110 --> 00:18:39,720
Og så vil bringe en hel liste af dens brug,

259
00:18:39,720 --> 00:18:42,890
men så godt det vil bringe op, hvilket bibliotek, der hører til.

260
00:18:42,890 --> 00:18:47,000
Så jeg vil overlade det til dig at bruge den manuelle funktion med atoi

261
00:18:47,000 --> 00:18:53,360
og finde ud af hvilket bibliotek du skal inkludere at være i stand til at bruge atoi funktionen.

262
00:18:54,450 --> 00:18:57,670
Så vi har fået nøglen, og nu det kommer til at få den almindelig tekst,

263
00:18:57,670 --> 00:19:01,820
og så rent faktisk bliver brugerinput, hvor du bede.

264
00:19:01,820 --> 00:19:05,540
Vi behandlet GetInt og GetFloat, og så i samme ånd

265
00:19:05,540 --> 00:19:07,670
vi kommer til at beskæftige sig med GetString.

266
00:19:07,670 --> 00:19:12,440
Men i dette tilfælde har vi ikke behøver at gøre noget gøre, mens eller mens løkker til at kontrollere.

267
00:19:12,440 --> 00:19:14,480
GetString vil helt sikkert give os en streng,

268
00:19:14,480 --> 00:19:17,630
og vi vil kryptere hvad brugeren giver os.

269
00:19:17,630 --> 00:19:23,770
Så du kan antage, at alle disse bruger indlæste strenge er korrekte.

270
00:19:23,770 --> 00:19:24,670
Great.

271
00:19:24,670 --> 00:19:27,270
Så når du har fået nøglen og når du har fået teksten,

272
00:19:27,270 --> 00:19:31,660
nu, hvad der er tilbage, er du nødt til at kryptere klarteksten.

273
00:19:31,660 --> 00:19:36,530
Blot for at hurtigt at dække over lingo, alm er, hvad brugeren giver dig,

274
00:19:36,530 --> 00:19:41,030
og ciphertext er hvad du vender tilbage til dem.

275
00:19:42,450 --> 00:19:45,850
Så strenge, være at kunne gå igennem faktisk bogstav for bogstav

276
00:19:45,850 --> 00:19:48,550
fordi vi er nødt til at flytte hvert bogstav,

277
00:19:48,550 --> 00:19:51,390
vi forstå, at strengene, hvis vi slags skrælle laget,

278
00:19:51,390 --> 00:19:54,130
vi se, at de er bare virkelig en liste over tegn.

279
00:19:54,130 --> 00:19:55,930
Den ene kommer efter den anden.

280
00:19:55,930 --> 00:20:01,690
Og så vi kan behandle strenge som arrays, fordi de er arrays af tegn.

281
00:20:01,690 --> 00:20:05,640
Så siger du har en streng ved navn tekst,

282
00:20:05,640 --> 00:20:09,400
og inden for denne variabel tekst lagres Dette er CS50.

283
00:20:09,400 --> 00:20:15,680
Så tekst på indeks 0 ville være en stort T, ville indeks 1 være h, osv.

284
00:20:17,530 --> 00:20:23,970
Og så med arrays, i det argc eksempel i args.c

285
00:20:23,970 --> 00:20:27,090
så vi, at vi var nødt til at gentage over et array

286
00:20:27,090 --> 00:20:32,440
og så havde vi til at gentage fra i = 0 indtil i er mindre end længden.

287
00:20:32,440 --> 00:20:35,560
Så vi har brug for en måde at finde ud af hvad længden af ​​vores streng er

288
00:20:35,560 --> 00:20:37,090
hvis vi kommer til at gentage over det.

289
00:20:37,090 --> 00:20:42,300
Heldigvis igen, er der en funktion der for os, selv om senere i CS50

290
00:20:42,300 --> 00:20:45,860
du vil helt sikkert være i stand til at implementere og lave din egen funktion

291
00:20:45,860 --> 00:20:48,260
der kan beregne længden af ​​en streng.

292
00:20:48,260 --> 00:20:52,120
Men for nu vil vi bruge streng længde, så strlen.

293
00:20:52,120 --> 00:21:00,440
Du passerer i en snor, og så vil det sende dig en int, der repræsenterer længden af ​​din streng.

294
00:21:00,440 --> 00:21:05,840
Lad os se på et eksempel på, hvordan vi kan være i stand til at gentage over hvert tegn i en streng

295
00:21:05,840 --> 00:21:08,470
og gøre noget med det.

296
00:21:08,470 --> 00:21:13,250
Hvad vi ønsker at gøre, er at gentage over hvert tegn af strengen,

297
00:21:13,250 --> 00:21:19,150
og hvad vi ønsker at gøre, er vi printer tilbage hvert tegn 1 af 1

298
00:21:19,150 --> 00:21:22,060
medmindre vi tilføjer noget ved siden af.

299
00:21:22,060 --> 00:21:27,020
Så lad os starte med for-løkken. Int i = 0.

300
00:21:27,020 --> 00:21:30,070
Vi kommer til at efterlade plads til den betingelse.

301
00:21:32,700 --> 00:21:36,840
Vi ønsker at gentage, indtil vi når til slutningen af ​​strengen, ikke?

302
00:21:36,840 --> 00:21:41,340
Så hvilken funktion giver os længden af ​​strengen?

303
00:21:41,340 --> 00:21:43,160
[Uhørlig student svar]

304
00:21:43,160 --> 00:21:46,420
Det er længden af ​​de kommandolinjeargumenter.

305
00:21:46,420 --> 00:21:50,650
Men for en streng vi ønsker at bruge en funktion, der giver os længden af ​​strengen.

306
00:21:50,650 --> 00:21:53,090
Så det er streng længde.

307
00:21:53,090 --> 00:21:57,130
Og så så er du nødt til at passere i en streng til den.

308
00:21:57,130 --> 00:21:59,760
Det er nødvendigt at vide, hvad streng det er nødvendigt at beregne længden af.

309
00:21:59,760 --> 00:22:03,160
Så i dette tilfælde har vi at gøre med snor s.

310
00:22:04,790 --> 00:22:05,860
Great.

311
00:22:05,860 --> 00:22:10,770
Så hvad vi ønsker at gøre, lad os printf.

312
00:22:10,770 --> 00:22:14,850
Nu ønsker vi at beskæftige sig med tegn. Vi ønsker at udskrive hver individuel karakter.

313
00:22:14,850 --> 00:22:22,150
Når du vil have det til at udskrive en float, ville du bruge pladsholderen ligesom% f.

314
00:22:22,150 --> 00:22:24,580
Med en int du ville bruge% d.

315
00:22:24,580 --> 00:22:30,890
Og så på samme måde, med et tegn, du bruger% c til at sige jeg har tænkt mig at udskrive en karakter

316
00:22:30,890 --> 00:22:34,570
, der er gemt inde i en variabel.

317
00:22:34,570 --> 00:22:40,840
Så vi har det, og lad os tilføje en periode og et rum til det.

318
00:22:40,840 --> 00:22:45,430
Hvilke tegn bruger vi?

319
00:22:45,430 --> 00:22:49,780
Vi skal bruge uanset karakter vi er ved af strengen.

320
00:22:49,780 --> 00:22:52,890
Så vi skal bruge noget med snor,

321
00:22:52,890 --> 00:22:56,420
men vi ønsker at være adgang til visse tegn der.

322
00:22:56,420 --> 00:23:02,740
Så hvis en streng er bare et array, så hvordan kan vi få adgang til elementer af arrays?

323
00:23:02,740 --> 00:23:06,480
Vi har de kantede parenteser, og derefter sætter vi indekset derinde.

324
00:23:06,480 --> 00:23:11,820
Så vi har firkantede parenteser. Vores indeks i dette tilfælde kan vi bare bruge i. Præcis.

325
00:23:15,290 --> 00:23:22,370
Så her vi siger at vi vil komme til at udskrive et tegn efterfulgt af et punktum og et mellemrum,

326
00:23:22,370 --> 00:23:30,870
og at karakter vil være den i'te bogstav i vores string s.

327
00:23:32,920 --> 00:23:39,330
Jeg vil bare redde det. Okay.

328
00:23:42,510 --> 00:23:46,840
Nu jeg har tænkt mig at køre streng længde.

329
00:23:46,840 --> 00:23:53,440
Så havde vi en streng kaldet OMG, og nu er det understreget endnu mere.

330
00:23:53,440 --> 00:23:57,870
Tilsvarende, lad os sige, at vi rent faktisk ønsker at få en snor fra brugeren.

331
00:23:57,870 --> 00:23:59,580
Hvordan kan vi gøre det?

332
00:23:59,580 --> 00:24:01,610
Før vidste hvordan vi får en int?

333
00:24:01,610 --> 00:24:08,040
Vi sagde GetInt, right? Men det er ikke int, så lad os GetString.

334
00:24:11,780 --> 00:24:17,770
Lad os gøre streng længde. Her har vi ikke indtaste en bestemt prompt.

335
00:24:17,770 --> 00:24:19,940
Så jeg ved det ikke.

336
00:24:19,940 --> 00:24:23,820
Jeg har tænkt mig at sætte mit navn ind her og så så jeg kan gøre en af ​​de ting

337
00:24:23,820 --> 00:24:29,600
hvor jeg tildele et ord for hvert bogstav eller noget lignende. Cool.

338
00:24:29,600 --> 00:24:31,900
Så det er streng længde.

339
00:24:33,000 --> 00:24:34,640
Så vi er tilbage til Cæsar.

340
00:24:34,640 --> 00:24:38,620
Vi har et par værktøjer til, hvordan vi gentage over en snor,

341
00:24:38,620 --> 00:24:41,250
hvordan vi få adgang til hver enkelt element.

342
00:24:41,250 --> 00:24:44,720
Så nu kan vi komme tilbage til programmet.

343
00:24:44,720 --> 00:24:48,650
Som jeg nævnte før, i ASCII-tabellen, din bedste ven,

344
00:24:48,650 --> 00:24:52,300
du kommer til at se de tal, der er forbundet med hvert bogstav.

345
00:24:52,300 --> 00:24:55,900
Så her sige vores klartekst er jeg svimmel!

346
00:24:55,900 --> 00:25:01,090
Derefter blev hver af disse figurer vil have et antal og ASCII værdi knyttet til sig,

347
00:25:01,090 --> 00:25:04,710
selv apostrof, selv den plads, selv udråbstegn,

348
00:25:04,710 --> 00:25:06,600
så vil du ønsker at holde det i tankerne.

349
00:25:06,600 --> 00:25:12,360
Så siger vores nøgle, som brugeren indgår i deres Kommandolinjeargumentet er 6.

350
00:25:12,360 --> 00:25:17,770
Det betyder for det første bogstav, som er mig, der er repræsenteret med 73,

351
00:25:17,770 --> 00:25:25,610
du ønsker at vende tilbage til dem, hvad bogstav er repræsenteret ved ASCII værdi på 73 + 6.

352
00:25:25,610 --> 00:25:29,020
I dette tilfælde vil være 79.

353
00:25:30,840 --> 00:25:35,040
Nu vil vi gå til det næste tegn.

354
00:25:35,040 --> 00:25:40,960
Så den næste i indeks 1 i alm ville være apostrof.

355
00:25:40,960 --> 00:25:46,780
Men husk at vi kun ønsker at kryptere bogstaverne.

356
00:25:46,780 --> 00:25:50,040
Så vi ønsker at sikre, at den apostrof faktisk forbliver den samme,

357
00:25:50,040 --> 00:25:54,310
at vi ikke ændres fra 39 til hvad 45 er.

358
00:25:54,310 --> 00:25:57,150
Vi ønsker at beholde den som en apostrof.

359
00:25:57,150 --> 00:26:00,780
Så vi ønsker at huske at kun kryptografere bogstaverne

360
00:26:00,780 --> 00:26:04,560
fordi vi ønsker alle de andre symboler for at forblive uændret i vores program.

361
00:26:04,560 --> 00:26:07,130
En anden ting, som vi ønsker, er at bevare kapitalisering.

362
00:26:07,130 --> 00:26:10,250
Så når du har et stort bogstav, bør det forblive som et stort.

363
00:26:10,250 --> 00:26:12,830
Lowercases bør forblive som små bogstaver.

364
00:26:13,620 --> 00:26:19,480
Så nogle nyttige funktioner til at være i stand til at håndtere kun enciphering bogstaver

365
00:26:19,480 --> 00:26:22,380
og holde bevare kapitalisering af ting

366
00:26:22,380 --> 00:26:25,130
er de isalpha, isupper, islower funktioner.

367
00:26:25,130 --> 00:26:29,270
Og så disse er funktioner, der returnerer du en boolesk værdi.

368
00:26:29,270 --> 00:26:34,180
Dybest set, sandt eller falsk. Er det et stort? Er det alfanumeriske?

369
00:26:34,180 --> 00:26:37,180
Er dette et brev, væsentlige.

370
00:26:37,180 --> 00:26:41,070
Så her er 3 eksempler på, hvordan du ville bruge denne funktion.

371
00:26:41,070 --> 00:26:47,060
Dybest set, kan du teste, om værdien returneret til dig af denne funktion er sand eller falsk

372
00:26:47,060 --> 00:26:49,400
baseret på denne indgang.

373
00:26:49,400 --> 00:26:54,880
Enten ikke omsætning til kode noget eller Cipher det eller sørg for, at det er store bogstaver osv.

374
00:26:54,880 --> 00:27:01,080
[Studerende] Kan du ikke bare forklare dem lidt mere, og hvordan du bruger dem? >> Ja, helt sikkert.

375
00:27:01,080 --> 00:27:08,470
Så hvis vi ser tilbage, her har vi en kapital jeg, ikke?

376
00:27:08,470 --> 00:27:14,550
Så vi ved, at jeg går til O, fordi jeg + 6 er O.

377
00:27:14,550 --> 00:27:18,740
Men vi ønsker at sikre, at O ​​bliver et stort O.

378
00:27:18,740 --> 00:27:22,940
Så dybest set, det er slags kommer til at ændre vores input.

379
00:27:22,940 --> 00:27:26,870
Så uanset om det er store eller ikke vil slags ændre den måde, vi håndterer det.

380
00:27:26,870 --> 00:27:32,360
Så hvis vi bruger isupper funktionen på det pågældende indeks,

381
00:27:32,360 --> 00:27:36,480
så isupper ("I"), der returnerer for os sande, så vi ved, at det er øverste.

382
00:27:36,480 --> 00:27:40,360
Så baseret på det, vi senere vil gå ind i en formel

383
00:27:40,360 --> 00:27:42,750
at du skal bruge til at flytte tingene i Cæsar,

384
00:27:42,750 --> 00:27:46,560
ja så dybest set, er der vil være en lidt anden formel, hvis det er store bogstaver

385
00:27:46,560 --> 00:27:50,670
i modsætning til små bogstaver. Give mening?

386
00:27:51,020 --> 00:27:52,760
Yeah. Ingen bekymringer.

387
00:27:54,900 --> 00:27:58,990
Jeg snakkede lidt om at tilføje 6 til et brev, som ikke helt giver mening

388
00:27:58,990 --> 00:28:05,500
undtagen når vi slags forstår, at disse tegn

389
00:28:05,500 --> 00:28:08,920
er slags udskiftes med heltal.

390
00:28:08,920 --> 00:28:11,250
Hvad vi gør, er vi slags brug implicit støbning.

391
00:28:11,250 --> 00:28:18,100
Vi vil gå ind i støbning lidt senere på hvor du tager en værdi, og du gøre den til en anden type

392
00:28:18,100 --> 00:28:20,440
end det oprindeligt var.

393
00:28:20,440 --> 00:28:25,910
Men med denne Pset vi vil være i stand til at slags flæng bruge tegn

394
00:28:25,910 --> 00:28:30,880
og deres tilsvarende heltalsværdier.

395
00:28:30,880 --> 00:28:35,140
Så hvis du blot omslutte en karakter med blot de enkelte anførselstegn,

396
00:28:35,140 --> 00:28:40,390
så vil du være i stand til at arbejde med det med heltal, der beskæftiger sig med det som et heltal.

397
00:28:40,390 --> 00:28:48,040
Så hovedstaden C vedrører 67. Lowercase f vedrører 102.

398
00:28:48,040 --> 00:28:51,480
Igen, hvis du ønsker at vide disse værdier, kig på din ASCII-tabellen.

399
00:28:51,480 --> 00:28:56,160
Så lad os gå ind i nogle eksempler på, hvordan du kan være i stand til at trække og tilføje,

400
00:28:56,160 --> 00:29:03,130
hvordan du kan faktisk virkelig arbejde med disse tegn, bruge dem på skift.

401
00:29:03,870 --> 00:29:11,350
Jeg siger, at ASCIIMath vil beregne tilsætning af et tegn til et heltal

402
00:29:11,350 --> 00:29:17,590
og viser den resulterende karakter og den resulterende ASCII værdi.

403
00:29:17,590 --> 00:29:22,290
Og så her jeg siger - we'll beskæftige sig med denne del senere -

404
00:29:22,290 --> 00:29:29,100
men dybest set, jeg siger, at brugeren skal sige løbe ASCIIMath sammen med en nøgle,

405
00:29:29,100 --> 00:29:30,880
og jeg siger, at nøglen vil være antallet

406
00:29:30,880 --> 00:29:34,600
som vi er ved at tilføje denne karakter.

407
00:29:34,600 --> 00:29:38,560
Så her bemærke, at da jeg kræver en nøgle,

408
00:29:38,560 --> 00:29:40,590
da jeg kræver, at de giver mig 1 ting,

409
00:29:40,590 --> 00:29:45,600
Jeg ønsker kun at acceptere. / Asciimath og en nøgle.

410
00:29:45,600 --> 00:29:49,330
Så jeg har tænkt mig at kræve, at argc er lig med 2.

411
00:29:49,330 --> 00:29:54,360
Hvis det ikke er, så jeg har tænkt mig at returnere 1, og programmet vil afslutte.

412
00:29:55,070 --> 00:29:58,540
Så jeg siger nøglen ikke vil være den første kommandolinie argument,

413
00:29:58,540 --> 00:30:05,080
Det vil være den anden, og som du kan se her,

414
00:30:05,080 --> 00:30:11,790
Jeg har tænkt mig at vende det til et heltal.

415
00:30:15,740 --> 00:30:19,230
Så jeg har tænkt mig at sætte et tegn til at være r.

416
00:30:19,230 --> 00:30:23,970
Bemærk, at typen af ​​den variable chr er faktisk et helt tal.

417
00:30:23,970 --> 00:30:30,480
Den måde, at jeg er i stand til at bruge r som et heltal er ved at omslutte den med disse enkle citationstegn.

418
00:30:33,850 --> 00:30:40,560
Så tilbage til vores printf erklæring, hvor vi har en pladsholder for et tegn

419
00:30:40,560 --> 00:30:43,590
og derefter en pladsholder for et heltal,

420
00:30:43,590 --> 00:30:49,450
karakter er repræsenteret ved den chr, og det heltal er nøglen.

421
00:30:49,450 --> 00:30:54,320
Og så så vi vil i resultat tilføje 2 sammen.

422
00:30:54,320 --> 00:30:58,420
Så vi vil tilføje r + hvad nøglen er,

423
00:30:58,420 --> 00:31:03,520
og så vi kommer til at udskrive resultatet af det.

424
00:31:06,210 --> 00:31:14,220
Så lad os gøre asciimath. Det er op til dato, så lad os bare køre asciimath.

425
00:31:14,220 --> 00:31:18,290
Åh, men se, det ikke gøre noget, fordi vi faktisk ikke give det en nøgle.

426
00:31:18,290 --> 00:31:23,850
Så når det netop vendt tilbage 1, vores vigtigste funktion, det netop vendt tilbage tilbage til os.

427
00:31:23,850 --> 00:31:29,250
Så så lad os gå i en nøgle. Nogen give mig et nummer. >> [Studerende] 4.

428
00:31:29,250 --> 00:31:30,920
4. Okay.

429
00:31:30,920 --> 00:31:39,280
So r steg 4 vil give os v, som svarer til ASCII værdien af ​​118.

430
00:31:39,280 --> 00:31:43,880
Så den slags giver mening, at -

431
00:31:43,880 --> 00:31:51,250
Faktisk kan jeg spørge dig, hvad tror du ASCII værdi af r er hvis r + 4 er 118?

432
00:31:53,070 --> 00:31:55,470
Så yeah, r er 114.

433
00:31:55,470 --> 00:32:03,010
Så hvis du ser på den ASCII-tabellen så sikker nok, vil du se, at r er repræsenteret med 114.

434
00:32:03,010 --> 00:32:08,610
Så nu, hvor vi ved, at vi kan tilføje tal til tegn, dette synes temmelig enkel.

435
00:32:08,610 --> 00:32:12,740
Vi vil bare gentage over en streng som vi så i et eksempel før.

436
00:32:12,740 --> 00:32:17,170
Vi vil se, om det er et brev.

437
00:32:17,170 --> 00:32:20,420
Hvis det er, så vil vi flytte det uanset nøglen er.

438
00:32:20,420 --> 00:32:23,650
Temmelig enkel, undtagen når du kommer til at kunne lide dette,

439
00:32:23,650 --> 00:32:32,140
du se, at z, repræsenteret ved 122, vil derefter give dig en anden karakter.

440
00:32:32,140 --> 00:32:37,770
Vi har faktisk ønsker at bo i vores alfabet, right?

441
00:32:37,770 --> 00:32:43,180
Så vi er nødt til at finde ud af en måde at slags indpakning rundt.

442
00:32:43,180 --> 00:32:47,190
Når du når zed og du ønsker at stige med et bestemt antal,

443
00:32:47,190 --> 00:32:51,230
du ikke ønsker at gå ind over den ASCII alfabet sektionen;

444
00:32:51,230 --> 00:32:54,140
du vil automatisk gå tilbage hele vejen til A.

445
00:32:54,140 --> 00:32:58,550
Men husk du stadig bevare sagen.

446
00:32:58,550 --> 00:33:00,980
Så vel vidende, at breve ikke kan blive symboler

447
00:33:00,980 --> 00:33:05,290
ligesom symboler vil ikke ændre sig så godt.

448
00:33:05,290 --> 00:33:08,170
I det sidste Pset du absolut ikke har brug for,

449
00:33:08,170 --> 00:33:14,310
men en mulighed var at implementere din grådige Pset ved hjælp af modulus-funktionen.

450
00:33:14,310 --> 00:33:17,230
Men nu skal vi faktisk kommer til at bruge modulus,

451
00:33:17,230 --> 00:33:19,900
så lad os bare gå over dette en lille smule.

452
00:33:19,900 --> 00:33:26,920
Væsentlige, når du har x modulo y, der giver dig den resterende del af x divideret med y.

453
00:33:26,920 --> 00:33:30,930
Her er nogle eksempler her. Vi har 27% 15.

454
00:33:30,930 --> 00:33:36,200
Dybest set, når du trækker 15 fra 27 så mange gange som muligt uden at få negativ

455
00:33:36,200 --> 00:33:39,060
så får du 12 til venstre over.

456
00:33:39,060 --> 00:33:44,650
Så det er lidt ligesom i math sammenhæng, men hvordan kan vi egentlig bruge dette?

457
00:33:44,650 --> 00:33:47,100
Det kommer til at være nyttige for vores wrapover.

458
00:33:47,100 --> 00:33:55,420
Til dette, lad os bare sige, jeg bad jer alle til at opdele i 3 grupper.

459
00:33:55,420 --> 00:33:58,010
Sommetider du gøre dette i grupper og sådan noget.

460
00:33:58,010 --> 00:34:01,320
Sig Jeg sagde: "Okay, jeg vil have jer alle til at være opdelt i 3".

461
00:34:01,320 --> 00:34:04,240
Hvordan kan du gøre det?

462
00:34:04,240 --> 00:34:06,810
[Uhørlig student svar] Yeah, præcis. Tælle. Okay.

463
00:34:06,810 --> 00:34:10,260
Lad os rent faktisk gør det. Ønsker du at starte?

464
00:34:10,260 --> 00:34:13,810
[Studerende tælle off] 1, 2, 3, 4.

465
00:34:13,810 --> 00:34:16,620
Men husk ... >> [Studerende] Åh, undskyld.

466
00:34:16,620 --> 00:34:18,730
Det er en rigtig god pointe.

467
00:34:18,730 --> 00:34:24,130
Du sagde 4, men vi faktisk ønsker du at sige 1, fordi vi kun ønsker 3 grupper.

468
00:34:24,130 --> 00:34:30,159
Altsaa, hvordan - Nej, det er et rigtig godt eksempel, fordi så hvordan kan du sige 1?

469
00:34:30,159 --> 00:34:33,370
Hvad er forholdet mellem 4 og 1?

470
00:34:33,370 --> 00:34:36,760
Nå, 4 mod 3 er 1.

471
00:34:36,760 --> 00:34:41,460
Så hvis du fortsætter, vil du være 2.

472
00:34:41,460 --> 00:34:44,540
Så vi har 1, 2, 3, 1, 2.

473
00:34:44,540 --> 00:34:49,420
Igen, du er faktisk den 5. person. Hvordan kan du vide at sige 2 i stedet for 5?

474
00:34:49,420 --> 00:34:53,760
Du siger 5 mod 3 er 2.

475
00:34:53,760 --> 00:34:59,100
Jeg ønsker at se, hvor mange grupper af 3 til overs, så hvilken rækkefølge am I.

476
00:34:59,100 --> 00:35:02,860
Og så så hvis vi fortsatte langs hele rummet,

477
00:35:02,860 --> 00:35:07,760
så ville vi se, at vi altid er faktisk anvender MOD-funktionen til os selv

478
00:35:07,760 --> 00:35:09,990
at slags tælle.

479
00:35:09,990 --> 00:35:14,490
Det er en mere slags håndgribeligt eksempel på, hvordan du kan bruge modulo

480
00:35:14,490 --> 00:35:17,960
fordi jeg er sikker på de fleste af os har sikkert været igennem denne proces

481
00:35:17,960 --> 00:35:19,630
hvor vi har haft til at tælle.

482
00:35:19,630 --> 00:35:21,840
Eventuelle spørgsmål om modulo?

483
00:35:21,840 --> 00:35:25,360
Det vil være temmelig vigtigt at forstå begreberne dette,

484
00:35:25,360 --> 00:35:28,640
så jeg vil være sikker på du fyre forstår.

485
00:35:28,640 --> 00:35:34,660
[Elev] Hvis der ikke er resterende, betyder det giver dig det faktiske antal?

486
00:35:34,660 --> 00:35:40,430
Hvis en af ​​de første 3 af dem havde gjort det, ville det have givet dem, hvad de rent faktisk var,

487
00:35:40,430 --> 00:35:43,310
eller ville det have givet dem [uhørligt] >> Det er et godt spørgsmål.

488
00:35:43,310 --> 00:35:48,750
Når der ikke er resten til modulo - så sige du har 6 mod 3 -

489
00:35:48,750 --> 00:35:52,340
der faktisk giver dig tilbage 0.

490
00:35:53,670 --> 00:35:57,290
Vi vil tale om dette lidt senere.

491
00:35:58,810 --> 00:36:07,720
Oh yeah, for eksempel den 3. person - er 3 mod 3 faktisk 0, men hun sagde 3.

492
00:36:07,720 --> 00:36:14,900
Så det er lidt ligesom en indre fangst, for eksempel,

493
00:36:14,900 --> 00:36:17,620
ligesom okay, I, hvis mod er 0, så har tænkt mig at være den 3. person.

494
00:36:17,620 --> 00:36:22,740
Men vi vil komme ind på slags hvordan vi måske ønsker at beskæftige sig med, hvad 0 er senere.

495
00:36:22,740 --> 00:36:32,750
Så nu har vi en eller anden måde har en måde at kortlægge den zed til det rigtige bogstav.

496
00:36:32,750 --> 00:36:34,920
Så nu har vi gået gennem disse eksempler,

497
00:36:34,920 --> 00:36:37,880
vi slags se, hvordan Cæsar kunne arbejde.

498
00:36:37,880 --> 00:36:42,640
Du kan se de 2 alfabeter og så skal du se dem flytte.

499
00:36:42,640 --> 00:36:44,430
Så lad os prøve og udtrykke at med hensyn til formel.

500
00:36:44,430 --> 00:36:46,940
Denne formel er faktisk givet til dig i spec,

501
00:36:46,940 --> 00:36:52,070
men lad os slags udseende gennem hvad hver variabel betyder.

502
00:36:52,070 --> 00:36:55,000
Vores slutresultatet vil være ciphertext.

503
00:36:55,000 --> 00:36:58,300
Så dette siger, at den i'te karakter ciphertext

504
00:36:58,300 --> 00:37:02,500
vil svare til den i'te karakter klartekst.

505
00:37:02,500 --> 00:37:08,130
Det giver mening, fordi vi ønsker at altid blive kø disse ting op.

506
00:37:08,130 --> 00:37:13,480
Så det vil være den i'te karakter ciphertext plus k, som er vores nøgle -

507
00:37:13,480 --> 00:37:17,230
der giver mening - og så har vi dette mod 26.

508
00:37:17,230 --> 00:37:19,860
Husk tilbage, når vi havde den zed

509
00:37:19,860 --> 00:37:24,190
Vi ønskede ikke at komme ind i karakter, så vi ønskede at mod det

510
00:37:24,190 --> 00:37:26,540
og art wrap around alfabetet.

511
00:37:26,540 --> 00:37:33,430
Efter zed du vil gå til a, b, c, d, indtil du fik til det rigtige nummer.

512
00:37:33,430 --> 00:37:44,690
Vi ved, at zed, hvis + 6, ville give os f fordi efter zed kommer a, b, c, d, e, f.

513
00:37:44,690 --> 00:37:52,530
Så lad os huske, vi ved med sikkerhed, at zed + 6 vil give os f..

514
00:37:52,530 --> 00:38:03,530
I ASCII-værdier, er z 122 og f er 102.

515
00:38:03,530 --> 00:38:10,570
Så vi er nødt til at finde en måde at gøre vores Cæsar formel giver os 102

516
00:38:10,570 --> 00:38:13,590
efter at have taget i 122.

517
00:38:13,590 --> 00:38:19,550
Så hvis vi bare anvende denne formel, ('z' + 6)% 26, der faktisk giver dig 24

518
00:38:19,550 --> 00:38:25,980
fordi 122 + 6 er 128, 128% 26 giver dig 24 resterende.

519
00:38:25,980 --> 00:38:29,140
Men det betyder ikke virkelig betyder f.. Det er bestemt ikke 102.

520
00:38:29,140 --> 00:38:33,590
Det er heller ikke det 6. bogstav i alfabetet.

521
00:38:33,590 --> 00:38:41,550
Så selvfølgelig skal vi have en måde at tweaking dette en lille smule.

522
00:38:42,970 --> 00:38:51,340
Med hensyn til den regelmæssige alfabet, ved vi, at z er den 26. brev og f er den 6..

523
00:38:51,340 --> 00:38:55,460
Men vi er i datalogi, så vi vil indeksere ved 0.

524
00:38:55,460 --> 00:39:00,690
Så i stedet for z er antallet 26, vi kommer til at sige, det er nummer 25

525
00:39:00,690 --> 00:39:02,630
idet a er 0.

526
00:39:02,630 --> 00:39:04,770
Så lad os nu anvende denne formel.

527
00:39:04,770 --> 00:39:11,710
Vi har z repræsenteret ved 25 + 6, som giver dig 31.

528
00:39:11,710 --> 00:39:15,790
Og 31 mod 26 giver dig 5 som en rest.

529
00:39:15,790 --> 00:39:20,500
Det er perfekt, fordi vi ved, at f er den 5. bogstav i alfabetet.

530
00:39:20,500 --> 00:39:26,400
Men det er stadig ikke f, right? Det er stadig ikke 102.

531
00:39:26,400 --> 00:39:32,730
Så for denne Pset, vil en udfordring være at forsøge at finde ud af forholdet

532
00:39:32,730 --> 00:39:36,910
mellem konvertering mellem disse ASCII værdier og det alfabetiske indeks.

533
00:39:36,910 --> 00:39:40,280
Væsentlige, hvad du ønsker at gøre, du ønsker at starte ud med ASCII-værdier,

534
00:39:40,280 --> 00:39:45,390
men så du ønsker at en eller anden måde omsætte det til et alfabetisk indeks

535
00:39:45,390 --> 00:39:52,610
derefter beregne, hvad brev det bør være - dybest set, hvad dens alfabetisk indeks er

536
00:39:52,610 --> 00:39:57,660
af cipher karakter - så oversætte det tilbage til ASCII-værdier.

537
00:39:57,660 --> 00:40:04,870
Så hvis du pisk ud af din ASCII-tabellen, så prøv og finde sammenhænge mellem fx 102 og 5

538
00:40:04,870 --> 00:40:10,440
eller 122 og 25.

539
00:40:12,140 --> 00:40:15,690
Vi har fået vores nøgle fra de kommandolinjeargumenter, har vi fået den klartekst,

540
00:40:15,690 --> 00:40:17,520
vi har krypteres det.

541
00:40:17,520 --> 00:40:19,820
Nu er alt vi har tilbage at gøre, er at udskrive det.

542
00:40:19,820 --> 00:40:22,040
Vi kunne gøre dette et par forskellige måder.

543
00:40:22,040 --> 00:40:24,570
Hvad vi kunne gøre er faktisk udskrives som vi hen ad vejen.

544
00:40:24,570 --> 00:40:28,250
Som vi gentage over de tegn i strengen,

545
00:40:28,250 --> 00:40:31,660
Vi kunne simpelthen bare udskrive helt så når vi beregner det.

546
00:40:31,660 --> 00:40:36,030
Alternativt kan du også gemme den i et array, og har en vifte af karakterer

547
00:40:36,030 --> 00:40:39,280
og i slutningen gentage over at hele array og printe det ud.

548
00:40:39,280 --> 00:40:40,980
Så du har et par muligheder for det.

549
00:40:40,980 --> 00:40:47,280
Og husk, at% c vil være pladsholderen til udskrivning af et tegn.

550
00:40:47,280 --> 00:40:50,420
Så der har vi Cæsar, og nu går vi videre til Vigenere,

551
00:40:50,420 --> 00:40:57,580
hvilket er meget lig Cæsar men blot en smule mere kompliceret.

552
00:40:57,580 --> 00:41:03,310
Så det væsentlige med Vigenere er du kommer til at være passerer på et nøgleord.

553
00:41:03,310 --> 00:41:06,510
Så i stedet for et nummer, er du nødt til at have en streng,

554
00:41:06,510 --> 00:41:09,200
og så der kommer til at fungere som dit søgeord.

555
00:41:09,200 --> 00:41:14,440
Så som sædvanlig, er du nødt til at få en prompt for en streng fra brugeren

556
00:41:14,440 --> 00:41:19,050
og derefter kryptere det og derefter give dem ciphertext tilbage.

557
00:41:19,050 --> 00:41:24,650
Så som jeg sagde, er det meget lig Cæsar, undtagen i stedet for at flytte med et bestemt antal,

558
00:41:24,650 --> 00:41:30,620
nummeret er faktisk kommer til at ændre hver gang fra tegn til tegn.

559
00:41:30,620 --> 00:41:34,890
Til at repræsentere det faktiske antal at skifte, er det repræsenteret af tastaturets bogstaver.

560
00:41:34,890 --> 00:41:43,150
Så hvis du indtaster i en forskydning af en, for eksempel, så ville det svare til et skift på 0.

561
00:41:43,150 --> 00:41:45,900
Så det er igen tilbage til det alfabetiske indeks.

562
00:41:45,900 --> 00:41:49,100
Hvad der kunne være nyttigt, hvis du ser, at vi faktisk har at gøre med ASCII-værdier

563
00:41:49,100 --> 00:41:51,790
samt de bogstaver, samt det alfabetiske indeks,

564
00:41:51,790 --> 00:41:58,020
måske finde eller lave dine egne ASCII tabel, der viser det alfabetiske indeks på 0 til 25,

565
00:41:58,020 --> 00:42:03,750
A til Z, og de ASCII-værdier, så du kan slags se forholdet

566
00:42:03,750 --> 00:42:07,020
og skitsere og forsøge at finde nogle mønstre.

567
00:42:07,020 --> 00:42:11,010
Tilsvarende, hvis du var at flytte på den vis eksempel ved f -

568
00:42:11,010 --> 00:42:21,110
og det er enten små eller store f - så det ville svare til 5.

569
00:42:21,110 --> 00:42:24,180
Er vi godt indtil videre?

570
00:42:25,770 --> 00:42:30,050
Formlen for Vigenere er en smule anderledes.

571
00:42:30,050 --> 00:42:32,960
Dybest set, du kan se, at det er ligesom Cæsar,

572
00:42:32,960 --> 00:42:37,390
undtagen i stedet for blot k vi k indeks j.

573
00:42:37,390 --> 00:42:44,810
Bemærk, at vi ikke bruger i, fordi det væsentlige, længden af ​​søgeordet

574
00:42:44,810 --> 00:42:49,850
er ikke nødvendigvis længden af ​​vores ciffertekst.

575
00:42:49,850 --> 00:42:56,130
Dette vil være en smule klarere, når vi ser et eksempel, som jeg har en smule senere.

576
00:42:56,130 --> 00:43:03,160
Dybest set, hvis du kører dit program med et søgeord på OHAI,

577
00:43:03,160 --> 00:43:08,560
så det betyder, at hver gang, der er OHAI vil være din vagt.

578
00:43:08,560 --> 00:43:11,060
Så afhængigt af, hvilken stilling du er i dit søgeord,

579
00:43:11,060 --> 00:43:15,800
du vil flytte din bestemte ciphertext karakter med dette beløb.

580
00:43:15,800 --> 00:43:19,630
Igen, ligesom Cæsar, ønsker vi at sikre, at vi bevarer kapitalisering af tingene

581
00:43:19,630 --> 00:43:22,900
og vi kun kryptografere bogstaver, ikke tegn eller mellemrum.

582
00:43:22,900 --> 00:43:26,330
Så ser tilbage til Cæsar på de funktioner, som du måske har brugt,

583
00:43:26,330 --> 00:43:32,570
den måde, at du har besluttet, hvordan man ændre tingene, og anvende det til dit program her.

584
00:43:32,570 --> 00:43:35,260
Så lad os kortlægge dette.

585
00:43:35,260 --> 00:43:39,680
Vi har en alm, som vi har fået fra den bruger GetString

586
00:43:39,680 --> 00:43:44,090
siger dette ... er CS50!

587
00:43:44,090 --> 00:43:47,090
Så har vi et søgeord på OHAI.

588
00:43:47,090 --> 00:43:50,930
De første 4 tegn er ret enkle.

589
00:43:50,930 --> 00:43:55,580
Vi ved, at T vil blive forskudt med o,

590
00:43:55,580 --> 00:44:01,990
så h vil blive flyttet af h, er jeg vil blive ændret med et.

591
00:44:01,990 --> 00:44:04,610
Her ser du at et repræsenterer 0,

592
00:44:04,610 --> 00:44:11,940
ja så slutværdien er faktisk bare det samme bogstav som før.

593
00:44:11,940 --> 00:44:15,250
Derefter s forskydes med i.

594
00:44:15,250 --> 00:44:19,370
Men så har du disse perioder her.

595
00:44:19,370 --> 00:44:25,960
Vi ønsker ikke at kryptere det, så så vi ikke ændre den ved noget

596
00:44:25,960 --> 00:44:31,280
og bare udskrive perioden uændret.

597
00:44:31,280 --> 00:44:38,020
[Studerende] Jeg forstår ikke, hvordan du ved, at dette forskydes med - Hvor har du - >> Åh, undskyld.

598
00:44:38,020 --> 00:44:41,620
Øverst her kan du se, at Kommandolinjeargumentet OHAI her,

599
00:44:41,620 --> 00:44:43,740
der kommer til at være nøgleordet.

600
00:44:43,740 --> 00:44:49,550
Og så dybest set, er du cykle over tegn i søgeordet.

601
00:44:49,550 --> 00:44:52,020
[Studerende] So o vil være at flytte den samme -

602
00:44:52,020 --> 00:44:56,260
Så o svarer til en række i alfabetet.

603
00:44:56,260 --> 00:44:58,400
[Studerende] Right. Men hvor har du fået den CS50 del fra?

604
00:44:58,400 --> 00:45:02,540
Oh. Det er i GetString hvor du er ligesom, "Giv mig en streng at indkode."

605
00:45:02,540 --> 00:45:07,510
[Studerende] De kommer til at give jer dette argument til at skifte med

606
00:45:07,510 --> 00:45:09,380
og så skal du bede om din første streng. >> Yeah.

607
00:45:09,380 --> 00:45:12,440
Så når de kører programmet, kommer de til at inkludere søgeordet

608
00:45:12,440 --> 00:45:14,740
i deres kommandolinjeargumenter, når de kører det.

609
00:45:14,740 --> 00:45:19,740
Så når du har kontrolleret, at de rent faktisk har givet dig 1 og ikke mere, ikke mindre,

610
00:45:19,740 --> 00:45:23,750
så du kommer til at bede dem for en streng, siger: "Giv mig en streng."

611
00:45:23,750 --> 00:45:27,630
Så det er der i dette tilfælde de har givet dig dette ... er CS50!

612
00:45:27,630 --> 00:45:32,090
Så du kommer til at bruge det og bruge OHAI og gentage over.

613
00:45:32,090 --> 00:45:38,200
Bemærk, at vi her sprunget over kryptering de perioder,

614
00:45:38,200 --> 00:45:51,660
men i forhold til vores position til OHAI, den næste vi brugte o.

615
00:45:51,660 --> 00:45:54,990
I dette tilfælde er det en smule sværere at se, fordi det er 4,

616
00:45:54,990 --> 00:45:57,710
så lad os fortsætte lidt. Bare holde med mig her.

617
00:45:57,710 --> 00:46:02,960
Så har vi i og s, som derefter oversat af o og h hhv.

618
00:46:02,960 --> 00:46:09,370
Så har vi en plads, og så ved vi, at vi ikke kommer til at kryptere rummene.

619
00:46:09,370 --> 00:46:18,930
Men bemærk, at i stedet for at gå til en i denne plet lige her,

620
00:46:18,930 --> 00:46:28,330
vi kryptere en - jeg ved ikke, om du kan se det - lige her.

621
00:46:28,330 --> 00:46:33,710
Så det er ikke ligesom du faktisk forudbestemt, siger, o går her, h går her,

622
00:46:33,710 --> 00:46:39,200
en går her, jeg går her, o, h, a, i, o, h, a, dvs. Du behøver ikke gøre det.

623
00:46:39,200 --> 00:46:43,760
Du skal kun flytte din position i søgeordet

624
00:46:43,760 --> 00:46:51,020
når du ved, at du rent faktisk vil komme til at kryptere en egentlig brev.

625
00:46:51,020 --> 00:46:53,920
Betyder den slags mening?

626
00:46:53,920 --> 00:46:55,800
Okay.

627
00:46:56,490 --> 00:46:58,500
Så bare nogle påmindelser.

628
00:46:58,500 --> 00:47:03,760
Du vil være sikker på, at du kun videre til det næste bogstav i dit søgeord

629
00:47:03,760 --> 00:47:06,390
hvis karakter i din klartekst er et brev.

630
00:47:06,390 --> 00:47:09,120
Så siger vi er på o.

631
00:47:09,120 --> 00:47:19,310
Vi bemærker, at det næste tegn, i-indekset på klartekst, er et tal, for eksempel.

632
00:47:19,310 --> 00:47:31,630
Så vi ikke går videre j, indekset for vores søgeord, indtil vi når et andet brev.

633
00:47:31,630 --> 00:47:36,230
Igen, du også vil være sikker på, at du wraparound til begyndelsen af ​​søgeordet

634
00:47:36,230 --> 00:47:37,770
når du er i slutningen af ​​det.

635
00:47:37,770 --> 00:47:42,030
Hvis du ser her er vi ved i, den næste skal være o.

636
00:47:42,030 --> 00:47:47,690
Så du ønsker at finde en måde at være i stand til wraparound til begyndelsen af ​​dit søgeord

637
00:47:47,690 --> 00:47:49,470
hver gang du når slutningen.

638
00:47:49,470 --> 00:47:55,040
Og så igen, hvilken slags operatør er nyttig i dette tilfælde til indpakning rundt?

639
00:47:56,630 --> 00:47:59,840
Ligesom i optællingen off eksempel.

640
00:47:59,840 --> 00:48:03,710
[Studerende] The procenttegn. >> Yeah, procenttegn, der er modulo.

641
00:48:03,710 --> 00:48:11,250
Så modulo vil komme i handy her, når du ønsker at ombryde over indekset i dit OHAI.

642
00:48:11,250 --> 00:48:17,700
Og bare en hurtig tip: Prøv at tænke på indpakning over søgeordet lidt ligesom at tælle fra,

643
00:48:17,700 --> 00:48:23,590
hvor hvis der er 3 grupper, den 4. person,

644
00:48:23,590 --> 00:48:30,610
deres nummer, som de sagde var 4 mod 3, hvilket var 1.

645
00:48:30,610 --> 00:48:32,880
Så prøv og tænk på det på den måde.

646
00:48:34,770 --> 00:48:42,740
Som du så i formlen, hvor du har ci og derefter pi men derefter kj,

647
00:48:42,740 --> 00:48:44,700
du vil være sikker på, at du holder styr på dem.

648
00:48:44,700 --> 00:48:47,580
Du behøver ikke at kalde det i, behøver du ikke at kalde det j,

649
00:48:47,580 --> 00:48:53,270
men du vil være sikker på, at du holder styr på den holdning, at du er i din klartekst

650
00:48:53,270 --> 00:48:55,790
samt den holdning, at du er på i dit søgeord

651
00:48:55,790 --> 00:48:59,840
fordi dem ikke nødvendigvis vil være den samme.

652
00:48:59,840 --> 00:49:06,400
Ikke alene nøgleordet - det kunne være en helt anden længde end din alm.

653
00:49:06,400 --> 00:49:09,140
Også din klartekst, der er tal og tegn,

654
00:49:09,140 --> 00:49:14,450
så det kommer ikke til perfekt match op sammen. Ja.

655
00:49:14,450 --> 00:49:19,280
[Studerende] Er der en funktion til at ændre sagen?

656
00:49:19,280 --> 00:49:24,530
Kan du ændre en til kapital A? >> Ja, der absolut er.

657
00:49:24,530 --> 00:49:27,890
Du kan tjekke ud - Jeg tror, ​​det er toupper, alle 1 ord.

658
00:49:30,650 --> 00:49:36,310
Men når du forsøger at cifferliste tingene og bevare teksten,

659
00:49:36,310 --> 00:49:39,350
er det bedst dybest set at have separate sager.

660
00:49:39,350 --> 00:49:42,040
Hvis det er et stort, så du ønsker at skifte med dette

661
00:49:42,040 --> 00:49:46,460
fordi i din formel, når man ser tilbage, hvordan vi er nødt til at slags gå

662
00:49:46,460 --> 00:49:50,900
flæng mellem ASCII måde at repræsentere tallene

663
00:49:50,900 --> 00:49:55,020
og de faktiske alfabetisk indeks, vi ønsker at sikre,

664
00:49:55,020 --> 00:50:01,850
der kommer til at være en slags mønster, du vil bruge.

665
00:50:01,850 --> 00:50:04,580
Et andet notat om det mønster, faktisk.

666
00:50:04,580 --> 00:50:07,250
Du kommer til at absolut beskæftige sig med tal.

667
00:50:07,250 --> 00:50:11,280
Prøv ikke at bruge magiske tal, der er et eksempel på stil.

668
00:50:11,280 --> 00:50:18,470
Så siger du ønsker at hver gang shift noget ved lignende -

669
00:50:18,470 --> 00:50:22,400
Okay, så hint, er en anden spoiler, når du kommer til at flytte noget

670
00:50:22,400 --> 00:50:26,310
med en vis mængde, så prøv ikke at repræsentere denne ved en faktiske antal

671
00:50:26,310 --> 00:50:32,810
men snarere prøve og se om du kan bruge den ASCII værdi, hvilket vil slags give mere mening.

672
00:50:32,810 --> 00:50:35,470
En anden bemærkning: Fordi vi har at gøre med formler,

673
00:50:35,470 --> 00:50:41,200
selvom din TF vil slags vide, hvad mønster, du bruger måske,

674
00:50:41,200 --> 00:50:44,430
bedst til i din kommentar slags forklare logikken, ligesom,

675
00:50:44,430 --> 00:50:51,880
"Jeg bruger dette mønster, fordi ..." og art forklare mønsteret kortfattet i dine kommentarer.

676
00:50:54,090 --> 00:50:58,990
[Dette var walkthrough 2] Hvis der ikke er nogen andre spørgsmål, så vil jeg bare blive her for en lille smule.

677
00:50:58,990 --> 00:51:04,370
Held og lykke med din Pset 2: Crypto og tak for at du kom.

678
00:51:06,070 --> 00:51:08,620
[Studerende] Tak. >> Tak.

679
00:51:09,220 --> 00:51:10,800
[Media Offline intro]