1
00:00:00,000 --> 00:00:01,940
[Powered by Google Translate] [Walkthrough - Problem Set 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. Hei, alle sammen, og velkommen til Walkthrough 2.

5
00:00:10,750 --> 00:00:14,330
Først vil jeg gratulere deg for etterbehandling pset en.

6
00:00:14,330 --> 00:00:18,140
Jeg vet at det kunne ha vært litt tøft for noen av dere,

7
00:00:18,140 --> 00:00:20,460
kunne ha vært den første dataprogram som du skrev,

8
00:00:20,460 --> 00:00:24,500
men bare husk at på slutten av dette, når du ser tilbake på slutten av semesteret,

9
00:00:24,500 --> 00:00:29,820
du skal se på pset 1, og du vil si: "Hei, jeg kunne ha gjort det i 5 minutter."

10
00:00:29,820 --> 00:00:35,700
Så kjenner og stoler på at på slutten av dette vil du definitivt finne pset en ganske enkel.

11
00:00:35,700 --> 00:00:40,640
Men for nå er det en stor prestasjon, og gratulerer med å få gjort.

12
00:00:40,640 --> 00:00:44,010
Nå også en rask notat før vi kommer inn i kjøtt av walkthrough.

13
00:00:44,010 --> 00:00:48,340
Jeg vil bare gjøre en rask oppmerksom på at jeg noen ganger ikke har nok tid

14
00:00:48,340 --> 00:00:52,500
i løpet av de walkthroughs å gå gjennom hver enkelt måte å gjøre oppgavesettet

15
00:00:52,500 --> 00:00:56,140
og heller bare kanskje fokusere på en eller to slags implementeringer,

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

17
00:00:57,750 --> 00:01:01,970
Men det er ikke å si at du er forbudt fra å gjøre det på en annen måte.

18
00:01:01,970 --> 00:01:05,980
Det er ofte, som med informatikk, mange måter å gjøre ting,

19
00:01:05,980 --> 00:01:12,190
og så definitivt gjerne bruke en annen type løsning enn jeg kan ha presentert.

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 del av spørsmål - 1. Caesar - 2. Vigenere]

22
00:01:17,160 --> 00:01:20,650
OK. Så problemet ligger 2: Crypto er en morsom en.

23
00:01:20,650 --> 00:01:24,500
Igjen, med hver pset vil du begynne med en del av spørsmålene

24
00:01:24,500 --> 00:01:29,600
som kommer til å bli gjennomført i seksjonene dine med din tildelte undervisning kar.

25
00:01:29,600 --> 00:01:31,670
Vi kommer ikke til å gå gjennom disse over walkthrough,

26
00:01:31,670 --> 00:01:35,100
men de definitivt vil hjelpe deg å fullføre pset.

27
00:01:35,100 --> 00:01:38,100
Så den første delen av oppgavesettet er Caesar.

28
00:01:38,100 --> 00:01:43,470
Og så i Caesar noen vil passere deg en nøkkel med et heltall,

29
00:01:43,470 --> 00:01:48,420
og du vil kryptere en tekststreng som de gir deg

30
00:01:48,420 --> 00:01:50,670
og gi dem tilbake en kryptert ting.

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

32
00:01:56,050 --> 00:01:59,090
Deretter den andre delen av problemet sett er Vigenere,

33
00:01:59,090 --> 00:02:01,790
som er en mer avansert kryptering teknikk.

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

35
00:02:05,640 --> 00:02:09,600
bortsett fra i stedet med bare en enkelt heltall, vi faktisk kommer til å kode den

36
00:02:09,600 --> 00:02:13,340
med et søkeord som brukeren vil gi oss.

37
00:02:16,270 --> 00:02:22,090
Ok, så det første verktøyet i verktøykassen i dag er faktisk kommer til å være å oppdatere maskinen.

38
00:02:22,090 --> 00:02:26,430
På diskusjonsforumet vil vi se ting som "Hvorfor ikke dette arbeidet?"

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

40
00:02:28,110 --> 00:02:31,830
og ofte løsningen er egentlig bare for å oppdatere enheten.

41
00:02:31,830 --> 00:02:36,730
Og så hvis du bare kjøre i et terminalvindu i apparatet sudo yum-y -

42
00:02:36,730 --> 00:02:40,040
det er et flagg som sier ja, oppdatere alt - oppdateringen,

43
00:02:40,040 --> 00:02:42,280
da apparatet vil oppdatere hvis behovet være.

44
00:02:42,280 --> 00:02:46,960
Og det gjør ikke vondt hvis du allerede er på den nyeste versjonen av apparatet.

45
00:02:46,960 --> 00:02:51,280
Da vil det bare si ingen nye oppdateringer tilgjengelig, og du kan fortsette å jobbe sammen.

46
00:02:51,280 --> 00:02:55,800
Men dette er bra til å utføre selv hver gang du åpner apparatet

47
00:02:55,800 --> 00:02:57,140
fordi vi er fortsatt veldig mye -

48
00:02:57,140 --> 00:03:00,320
noen ganger hvis vi kommer inn i en bug - fikse det i apparatet.

49
00:03:00,320 --> 00:03:03,180
Så sørg for at du har den nyeste versjonen av apparatet

50
00:03:03,180 --> 00:03:07,710
og kjøre som oppdaterer det.

51
00:03:07,710 --> 00:03:14,360
OK. Så siden vi har å gjøre med bokstaver og endring, enciphering ting,

52
00:03:14,360 --> 00:03:20,410
vi kommer til å virkelig ønsker å bli bestevenn med vår ASCII diagram.

53
00:03:20,410 --> 00:03:24,350
Det er mange som på nettet, hvis du finner. Kanskje til og med lage din egen.

54
00:03:24,350 --> 00:03:29,950
I utgangspunktet, med hver bokstav og hvert tall og hver karakter

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

56
00:03:32,210 --> 00:03:38,670
og så det er godt å se sine ASCII-verdier langs selve brevet.

57
00:03:38,670 --> 00:03:42,310
Det vil definitivt hjelpe deg i oppgavesettet.

58
00:03:42,310 --> 00:03:45,750
En ting som virkelig hjalp meg i dette problemet settet var å faktisk skrive det ut,

59
00:03:45,750 --> 00:03:48,380
og som jeg gikk gjennom, ville jeg faktisk trekke på den,

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

61
00:03:51,150 --> 00:03:55,270
Slags tegne på den og merke det opp, blir bestevenner med ASCII-tabellen.

62
00:03:57,240 --> 00:04:00,750
Så har vi et par andre verktøy til rådighet.

63
00:04:00,750 --> 00:04:03,750
Denne gangen i stedet for å faktisk spørre brukeren for alle innspill

64
00:04:03,750 --> 00:04:05,230
vi kommer til å gjøre en kombinasjon.

65
00:04:05,230 --> 00:04:06,880
Vi kommer til å be dem for noen innspill,

66
00:04:06,880 --> 00:04:11,350
men vi kommer også til å bare bruke kommandolinjeargumentene.

67
00:04:11,350 --> 00:04:15,600
Så når de kjører sitt program, vanligvis du sier. / Hallo, for eksempel,

68
00:04:15,600 --> 00:04:17,310
hvis programmet var hallo.c.

69
00:04:17,310 --> 00:04:22,500
Men denne gangen i stedet for bare å si det, de kan sette ord, argumenter etterpå.

70
00:04:22,500 --> 00:04:27,210
Og så vi kommer til å bruke det de passerer inn til oss som innspill deres også,

71
00:04:27,210 --> 00:04:31,720
så gå utover bare å spørre for heltall, men også ved hjelp av kommandolinjeargumenter.

72
00:04:31,720 --> 00:04:36,590
Og så vil vi gå inn i matriser og strenger, som vi skal bruke mye også.

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

74
00:04:44,810 --> 00:04:48,460
Som jeg sa, tilsvarer hver bokstav til et tall,

75
00:04:48,460 --> 00:04:52,510
og så bli kjent med det. Det vil komme godt med.

76
00:04:52,510 --> 00:04:55,610
Og senere når vi begynner å gjøre noe ASCIIMath håndtere tallene -

77
00:04:55,610 --> 00:05:00,110
legge til, trekke dem - så definitivt godt å referere til denne figuren.

78
00:05:02,860 --> 00:05:06,920
Så her er et eksempel på en Cæsar chiffer - noe som du kanskje har spilt med.

79
00:05:06,920 --> 00:05:11,190
Det er bare et hjul. I hovedsak er det en ytre alfabetet og så er det en indre alfabetet.

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

81
00:05:15,290 --> 00:05:21,540
I hovedsak er en linje med A, B på linje med B, hele veien opp til Z.

82
00:05:21,540 --> 00:05:26,590
Men så sier vi ønsket en nøkkel på 3, for eksempel.

83
00:05:26,590 --> 00:05:33,280
Da ville vi roter indre hjulet slik at A nå justert med D, etc.

84
00:05:33,280 --> 00:05:35,250
Og så dette er egentlig hva vi skal gjøre.

85
00:05:35,250 --> 00:05:38,340
Vi har ikke et hjul, men hva vi skal gjøre er å gjøre vårt program

86
00:05:38,340 --> 00:05:44,490
slags skifte alfabetet sammen med oss ​​en viss mengde tall.

87
00:05:44,490 --> 00:05:48,650
Så som jeg sa tidligere, vi kommer til å være håndtere kommandolinjeargumenter

88
00:05:48,650 --> 00:05:50,390
så vel som å få et heltall.

89
00:05:50,390 --> 00:05:55,050
Så måten at en bruker vil kjøre Caesar programmet er ved å si. / Caesar

90
00:05:55,050 --> 00:05:58,090
og deretter skrive inn et tall etter det.

91
00:05:58,090 --> 00:06:01,130
Og at antallet representerer nøkkelen, skiftet,

92
00:06:01,130 --> 00:06:06,740
hvor mange ganger du kommer til å være roterende indre hjulet på Caesar cipher.

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

94
00:06:08,390 --> 00:06:14,550
Hvis vi angitt bokstaver fra A til L i vår Caesar cipher,

95
00:06:14,550 --> 00:06:19,520
da ville det inngang D gjennom O fordi det er hver bokstav flyttet over tre ganger,

96
00:06:19,520 --> 00:06:22,080
akkurat som eksempel på hjulet som jeg viste deg.

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

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

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

100
00:06:31,040 --> 00:06:34,890
er at vi kommer til å hoppe over noen ikke-bokstaver.

101
00:06:34,890 --> 00:06:39,160
Så noen mellomrom, tegn, osv., tall, vi kommer til å holde dem samme.

102
00:06:39,160 --> 00:06:42,920
Vi kommer bare til å skifte bokstavene i dette tilfellet.

103
00:06:42,920 --> 00:06:45,870
Så som du ser i hjulet, vi har bare bokstavene tilgjengelig for oss,

104
00:06:45,870 --> 00:06:50,150
slik at vi bare ønsker å skifte bokstavene og kryptere bokstavene.

105
00:06:51,370 --> 00:06:56,720
Så det første du må gjøre, så du at bruken for Caesar i problemet sett 2

106
00:06:56,720 --> 00:07:05,280
er å kjøre Cæsar og deretter skrive inn et tall når du kjører den i terminalen.

107
00:07:05,280 --> 00:07:10,940
Så det vi trenger å gjøre er å liksom få det nøkkel og tilgang til den.

108
00:07:10,940 --> 00:07:14,730
Og så ønsker vi å liksom se det kommer til å bli den andre kommandolinje argument.

109
00:07:14,730 --> 00:07:20,950
Den første kommer til å bli. / Caesar, og den neste kommer til å være nøkkelen nummer.

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

111
00:07:29,200 --> 00:07:31,790
Vi kommer til å trekke tilbake et lag litt

112
00:07:31,790 --> 00:07:34,720
og faktisk se at i stedet for å sende i tomrommet til våre viktigste funksjon

113
00:07:34,720 --> 00:07:37,920
vi faktisk arbeider med to parametere.

114
00:07:37,920 --> 00:07:44,070
Vi har en int heter argc og deretter en rekke strenger som kalles argv.

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

116
00:07:46,030 --> 00:07:49,640
og det representerer antall argumenter som sendes inn til programmet.

117
00:07:49,640 --> 00:07:53,590
Og så argv er faktisk listen over de argumenter som sendes.

118
00:07:53,590 --> 00:08:00,820
Alle av argumentene er strenger, og så argv representerer en matrise, en liste, av strenger.

119
00:08:01,830 --> 00:08:03,990
La oss snakke om arrays litt.

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

121
00:08:05,940 --> 00:08:09,660
Vi har ints, vi har dobler, har vi strenger, og nå har vi arrays.

122
00:08:09,660 --> 00:08:13,820
Arrays er datastrukturer som kan holde flere verdier av samme type,

123
00:08:13,820 --> 00:08:18,320
så egentlig en liste over hva du vil bruke.

124
00:08:18,320 --> 00:08:24,400
Egentlig, hvis du ville ha en liste av heltall alt i en variabel,

125
00:08:24,400 --> 00:08:29,090
så ville du lage en ny variabel som var av type int array.

126
00:08:29,090 --> 00:08:34,450
Så arrays er null-indeksert, noe som betyr at det første elementet i matrisen er på indeks 0.

127
00:08:34,450 --> 00:08:41,799
Hvis matrisen er av lengde 4, som i dette eksempel, så den siste elementet ville være på 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 å lage array, ville du gjøre noe som dette.

130
00:08:48,420 --> 00:08:51,440
Si at du ønsket en dobbel array.

131
00:08:51,440 --> 00:08:56,520
Dette gjelder for alle typer data type, skjønt.

132
00:08:56,520 --> 00:09:00,210
Så si at du ønsker en dobbel array. Si at du ønsker å kalle det postkasse.

133
00:09:00,210 --> 00:09:04,760
Akkurat som du ville sette opp et annet dobbel,

134
00:09:04,760 --> 00:09:09,760
du ville si dobbel og deretter navnet, men denne gangen vi sette hakeparenteser,

135
00:09:09,760 --> 00:09:13,570
og deretter nummeret vil være lengden av tabellen.

136
00:09:13,570 --> 00:09:16,840
Merk at i arrays ikke vi noen gang kan endre lengden,

137
00:09:16,840 --> 00:09:21,230
slik at du alltid må definere og velge hvor mange bokser,

138
00:09:21,230 --> 00:09:25,440
hvor mange verdier arrayet kommer til å holde.

139
00:09:25,440 --> 00:09:31,820
Så for å sette forskjellige verdier i arrayet, du kommer til å bruke denne følgende syntaks,

140
00:09:31,820 --> 00:09:33,200
som du ser på lysbildet.

141
00:09:33,200 --> 00:09:37,620
Du har postkassen indeks 0 vil bli satt til 1,2,

142
00:09:37,620 --> 00:09:42,180
postboks indeks 1 sett til 2,4, etc.

143
00:09:42,180 --> 00:09:47,910
Så nå som vi har anmeldt arrays litt, la oss gå tilbake til argc og argv.

144
00:09:47,910 --> 00:09:52,220
Vi vet at argv er nå en rekke strenger.

145
00:09:52,220 --> 00:09:55,080
Så når en bruker går i - sier de kjører et program -

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

147
00:09:58,740 --> 00:10:05,160
hva programmet vil gjøre for deg allerede er faktisk kommet opp med hva argc og argv er.

148
00:10:05,160 --> 00:10:07,620
Så du trenger ikke å bekymre deg for det.

149
00:10:07,620 --> 00:10:14,370
Argc i dette tilfellet ville være 3 fordi det ser tre forskjellige ord adskilt med mellomrom.

150
00:10:14,370 --> 00:10:18,850
Og så da array i dette tilfellet, vil den første indeksen være. / Hallo,

151
00:10:18,850 --> 00:10:21,770
den neste David, den neste Malan.

152
00:10:21,770 --> 00:10:25,640
Ser noen gang hva forholdet mellom argv,

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

154
00:10:32,820 --> 00:10:38,090
Ja. Vi vil komme inn som i et eksempel i args.c.

155
00:10:38,090 --> 00:10:42,880
La oss se om vi kan dra nytte av forholdet mellom to.

156
00:10:42,880 --> 00:10:46,550
Her kan du finne at i apparatet standardprogrammet

157
00:10:46,550 --> 00:10:49,450
å åpne. c-filer er ofte Emacs.

158
00:10:49,450 --> 00:10:54,660
Men vi ønsker å håndtere gedit, så hva du kan gjøre er at du kan høyreklikke på C-filen,

159
00:10:54,660 --> 00:11:04,580
gå til Egenskaper, Åpne med, og velg deretter gedit, Angi som standard,

160
00:11:04,580 --> 00:11:13,020
og nå programmet skal åpnes 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 å skrive ut hver kommandolinje argument.

163
00:11:25,520 --> 00:11:32,050
Så uansett hva brukeren innganger, jeg ønsker å hovedsak returnere den tilbake til dem på en ny linje.

164
00:11:32,050 --> 00:11:36,710
Så hva er en struktur som vi kan bruke til å iterere over noe -

165
00:11:36,710 --> 00:11:40,380
noe som du sannsynligvis brukt i pset 1?

166
00:11:40,380 --> 00:11:45,840
Hvis du ønsker å gå gjennom et visst antall ting? >> [Student] For loop.

167
00:11:45,840 --> 00:11:48,910
For loop. Akkurat. Så la oss starte med for loop.

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

169
00:11:56,900 --> 00:12:02,370
Jeg kommer til å forlate forutsetning for et sett, og deretter si jeg + +, kommer til å gjøre ting der.

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

171
00:12:04,090 --> 00:12:11,590
Så tenker tilbake til argv, hvis argv er listen over argumenter som sendes inn til programmet

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

173
00:12:15,380 --> 00:12:21,280
så det betyr at argc er egentlig lengden på argv, høyre,

174
00:12:21,280 --> 00:12:28,970
fordi det kommer til å være så mange argumenter som verdien av argc.

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

176
00:12:35,910 --> 00:12:43,290
vi kommer til å ønske å hver gang få tilgang til variabelen i argv ved den gitte indeksen.

177
00:12:43,290 --> 00:12:49,060
Som kan representeres med dette, ikke sant?

178
00:12:49,060 --> 00:12:53,430
Denne variabelen her representerer bestemt streng i dette tilfellet

179
00:12:53,430 --> 00:12:57,030
fordi det er en streng array - den spesielle strengen på det gitte indeks.

180
00:12:57,030 --> 00:13:00,690
Hva vi ønsker å gjøre, i dette tilfellet ønsker vi å skrive den ut, så la oss si printf.

181
00:13:00,690 --> 00:13:04,680
Og nå argv er en streng, så vi ønsker å sette det plassholder der.

182
00:13:04,680 --> 00:13:08,430
Vi ønsker en ny linje bare for å gjøre det ser bra ut.

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

184
00:13:12,530 --> 00:13:20,020
Så jeg starter på 0, og deretter hver gang det kommer til å skrive den gitte strengen

185
00:13:20,020 --> 00:13:22,980
på det aktuelle indeksen i tabellen.

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

187
00:13:28,410 --> 00:13:35,720
Når vi er ferdig, ikke sant? Når vi har nådd slutten av tabellen.

188
00:13:35,720 --> 00:13:38,870
Slik at vi ikke ønsker å overskride forbi lengden av tabellen,

189
00:13:38,870 --> 00:13:43,700
og vi allerede vet at vi ikke trenger å faktisk aktivt finne ut hva lengden på argv er

190
00:13:43,700 --> 00:13:47,520
fordi det er gitt til oss, og hva er det? Argc. Akkurat.

191
00:13:47,520 --> 00:13:56,640
Så vi ønsker å gjøre denne prosessen argc antall ganger.

192
00:13:56,640 --> 00:13:59,550
Jeg er ikke i riktig katalog.

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

194
00:14:03,490 --> 00:14:08,990
Nå la oss gjøre args. Ingen feil, og det er flott.

195
00:14:08,990 --> 00:14:11,430
Så la oss bare kjøre args.

196
00:14:11,430 --> 00:14:15,130
Hva dette kommer til å gå tilbake til oss? Det er bare kommer til å skrive den tilbake.

197
00:14:15,130 --> 00:14:18,320
"Du inputted args inn i programmet, jeg kommer til å gi den tilbake til deg."

198
00:14:18,320 --> 00:14:23,170
Så la oss si at vi ønsker å si args deretter foo bar.

199
00:14:23,170 --> 00:14:26,570
Så da er det så skrives det ut tilbake til oss. Greit?

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

201
00:14:30,790 --> 00:14:33,460
vite at argc representerer lengden argv.

202
00:14:33,460 --> 00:14:42,750
Pass på at du ikke noen gang med arrays tilgang en utover lengden av tabellen

203
00:14:42,750 --> 00:14:45,140
fordi C vil definitivt rope på deg.

204
00:14:45,140 --> 00:14:47,560
Du får noe som kalles en segmentering feil,

205
00:14:47,560 --> 00:14:52,470
som er aldri morsomt, i utgangspunktet si at du prøver å få tilgang til noe

206
00:14:52,470 --> 00:14:55,000
som ikke finnes, ikke tilhører deg.

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

208
00:14:59,430 --> 00:15:02,390
Som for eksempel, hvis vi har en rekke lengde 4,

209
00:15:02,390 --> 00:15:07,240
at datatabellindekser 4 eksisterer ikke fordi vi starter på 0, null-indeksen.

210
00:15:07,240 --> 00:15:11,730
Det vil bli andre natur akkurat som for løkker når vi starter på 0.

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

212
00:15:13,610 --> 00:15:22,590
Du ønsker ikke å stadig gå til indeks av en matrise som er utenfor rekkevidde.

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

214
00:15:32,560 --> 00:15:35,930
kommandolinjeargumentene som er gått i.

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

216
00:15:41,330 --> 00:15:45,740
Så det er faktisk ikke et heltall ennå, men i Caesar ønsker vi å håndtere heltall.

217
00:15:45,740 --> 00:15:54,430
Heldigvis er det en funksjon som er opprettet for oss som faktisk kan konvertere en streng til et heltall.

218
00:15:54,430 --> 00:15:58,710
Også her har vi å gjøre med brukerens input der vi spørre dem

219
00:15:58,710 --> 00:16:03,740
for innspill her for nøkkelen, slik at vi ikke kan faktisk reprompt og si,

220
00:16:03,740 --> 00:16:07,840
"Å, gi meg et annet heltall, si, hvis det ikke er gyldig."

221
00:16:07,840 --> 00:16:10,540
Men vi trenger fortsatt å se etter riktig bruk.

222
00:16:10,540 --> 00:16:13,520
I Caesar de bare lov til å passere i en rekke,

223
00:16:13,520 --> 00:16:18,030
og slik at de må løpe. / caesar og deretter må de gi deg et nummer.

224
00:16:18,030 --> 00:16:23,660
Så argc må være et visst antall.

225
00:16:23,660 --> 00:16:29,060
Hvilket nummer ville det være hvis de må passere deg. / Caesar og deretter en nøkkel?

226
00:16:29,060 --> 00:16:32,920
Hva er argc? >> [Student] 2. >> Two. Akkurat.

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

228
00:16:35,490 --> 00:16:39,620
Ellers kan du i utgangspunktet nekte å kjøre programmet.

229
00:16:39,620 --> 00:16:43,040
I main er det en funksjon som sier int main,

230
00:16:43,040 --> 00:16:47,360
så da vi alltid i god praksis return 0 på slutten av et vellykket program.

231
00:16:47,360 --> 00:16:50,840
Så hvis si, de gir deg 3 kommandolinjeargumenter i stedet for 2

232
00:16:50,840 --> 00:16:54,350
eller gi deg en, for eksempel, så hva du skal gjøre er at du vil se etter at

233
00:16:54,350 --> 00:16:59,900
og deretter tilbake 1 sa nei, jeg kan ikke fortsette med dette programmet.

234
00:16:59,900 --> 00:17:03,190
[Student] Det kan ikke være et mellomrom i teksten. >> Unnskyld meg?

235
00:17:03,190 --> 00:17:06,780
[Student] Det kan ikke være et mellomrom i teksten du prøver å kryptere.

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

237
00:17:08,480 --> 00:17:11,280
I form av tekst som vi prøver å kryptere, kommer det faktisk senere

238
00:17:11,280 --> 00:17:13,970
når vi gir teksten.

239
00:17:13,970 --> 00:17:18,260
Så akkurat nå er vi bare akseptere som kommando argumenter det faktiske antallet,

240
00:17:18,260 --> 00:17:21,579
selve skiftet for Caesar kryptering.

241
00:17:21,579 --> 00:17:27,569
[Student] Hvorfor trenger du to i motsetning til bare en argc? Det er definitivt en nummer.

242
00:17:27,569 --> 00:17:32,200
Høyre. Grunnen til at vi trenger 2 for argc stedet for en

243
00:17:32,200 --> 00:17:36,260
er fordi når du kjører et program og si. / caesar eller. / hallo,

244
00:17:36,260 --> 00:17:38,280
som teller faktisk som en kommandolinje argument.

245
00:17:38,280 --> 00:17:43,020
Så da tar allerede opp 1 og så da vi innrykker en ekstra.

246
00:17:45,030 --> 00:17:49,440
Så du skriver inn faktisk en streng i kommandolinjen argument.

247
00:17:49,440 --> 00:17:52,730
Hva du ønsker å gjøre, for Caesar ønsker vi å håndtere et heltall,

248
00:17:52,730 --> 00:17:57,180
slik at du kan bruke denne atoi funksjonen.

249
00:17:57,180 --> 00:18:02,850
Og i utgangspunktet, passerer du den i en streng og deretter vil det kommer du tilbake et heltall

250
00:18:02,850 --> 00:18:06,070
om det er mulig å gjøre det streng til et heltall.

251
00:18:06,070 --> 00:18:10,960
Nå husker da vi arbeider med printf eller GetString, ting som det,

252
00:18:10,960 --> 00:18:13,390
vi inkluderer bibliotekene som er spesifikke for oss.

253
00:18:13,390 --> 00:18:19,450
Så i begynnelsen starter vi med en hash tag standard I / O,. H, noe sånt.

254
00:18:19,450 --> 00:18:22,430
Vel, er atoi ikke innen ett av disse bibliotekene,

255
00:18:22,430 --> 00:18:26,600
så hva vi trenger å gjøre er vi nødt til å inkludere retten bibliotek for det.

256
00:18:26,600 --> 00:18:32,720
Så husker tilbake til Walkthrough 1 hvor jeg diskutert den manuelle funksjonen.

257
00:18:32,720 --> 00:18:37,110
Du skriver mannen i terminalen og deretter etterfulgt av navnet til en funksjon.

258
00:18:37,110 --> 00:18:39,720
Og slik at det vil få opp en hel liste av bruken sin,

259
00:18:39,720 --> 00:18:42,890
men også det vil få opp hvilket bibliotek som hører til.

260
00:18:42,890 --> 00:18:47,000
Så jeg skal la det til deg å bruke den manuelle funksjonen med atoi

261
00:18:47,000 --> 00:18:53,360
og finne ut hvilke bibliotek du trenger å inkludere for å kunne bruke atoi funksjonen.

262
00:18:54,450 --> 00:18:57,670
Så vi har nøkkelen og nå det gjelder å få den ren tekst,

263
00:18:57,670 --> 00:19:01,820
og slik at faktisk kommer til å være brukerens input der du be.

264
00:19:01,820 --> 00:19:05,540
Vi har jobbet med GetInt og GetFloat, og så i samme retning

265
00:19:05,540 --> 00:19:07,670
vi kommer til å være håndtere GetString.

266
00:19:07,670 --> 00:19:12,440
Men i dette tilfellet trenger vi ikke å gjøre noe gjøre mens eller mens sløyfer for å sjekke.

267
00:19:12,440 --> 00:19:14,480
GetString vil definitivt gi oss en streng,

268
00:19:14,480 --> 00:19:17,630
og vi kommer til å kryptere hva brukeren gir oss.

269
00:19:17,630 --> 00:19:23,770
Så du kan anta at alle disse bruker lagt inn strengene er riktige.

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

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

272
00:19:27,270 --> 00:19:31,660
nå det som er igjen er du nødt til chiffrering klarteksten.

273
00:19:31,660 --> 00:19:36,530
Bare for å raskt dekke over lingo, er klarteksten hva brukeren gir deg,

274
00:19:36,530 --> 00:19:41,030
og den krypterte teksten er hva du gå tilbake til dem.

275
00:19:42,450 --> 00:19:45,850
Så strenger, for å være i stand til å gå gjennom faktisk bokstav for bokstav

276
00:19:45,850 --> 00:19:48,550
fordi vi må skifte hver bokstav,

277
00:19:48,550 --> 00:19:51,390
Vi forstår at strenger, hvis vi slags skrelle tilbake på laget,

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

279
00:19:54,130 --> 00:19:55,930
En kommer etter hverandre.

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

281
00:20:01,690 --> 00:20:05,640
Så si du har en streng som heter tekst,

282
00:20:05,640 --> 00:20:09,400
og innen den variabelen tekst lagres Dette er CS50.

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

284
00:20:17,530 --> 00:20:23,970
Og deretter med matriser, i argc eksempel i args.c,

285
00:20:23,970 --> 00:20:27,090
Vi så at vi måtte iterere over en rekke

286
00:20:27,090 --> 00:20:32,440
og så vi måtte veksle fra i = 0 opp før jeg er mindre enn lengden.

287
00:20:32,440 --> 00:20:35,560
Så vi trenger en måte å finne ut hva lengden på strengen vår er

288
00:20:35,560 --> 00:20:37,090
hvis vi skal iterere over det.

289
00:20:37,090 --> 00:20:42,300
Heldigvis igjen, det er en funksjon det for oss, men senere i CS50

290
00:20:42,300 --> 00:20:45,860
vil du definitivt være i stand til å implementere og lage din egen funksjon

291
00:20:45,860 --> 00:20:48,260
som kan beregne lengden av en streng.

292
00:20:48,260 --> 00:20:52,120
Men for nå skal vi bruke streng lengde, så strlen.

293
00:20:52,120 --> 00:21:00,440
Du passerer i en streng, og deretter vil det returnere deg en int som representerer lengden på strengen din.

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

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

296
00:21:08,470 --> 00:21:13,250
Hva vi ønsker å gjøre er iterere over hvert tegn i strengen,

297
00:21:13,250 --> 00:21:19,150
og hva vi ønsker å gjøre er å skrive ut vi tilbake hvert tegn 1 til 1

298
00:21:19,150 --> 00:21:22,060
bortsett fra vi legge til noe ved siden av.

299
00:21:22,060 --> 00:21:27,020
Så la oss starte med for loop. Int i = 0.

300
00:21:27,020 --> 00:21:30,070
Vi kommer til å forlate rommet for tilstanden.

301
00:21:32,700 --> 00:21:36,840
Vi ønsker å veksle til vi kommer til slutten av strengen, ikke sant?

302
00:21:36,840 --> 00:21:41,340
Så hva funksjonen gir oss lengden på strengen?

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

304
00:21:43,160 --> 00:21:46,420
Det er lengden på kommandolinjeargumentene.

305
00:21:46,420 --> 00:21:50,650
Men for en streng ønsker vi å bruke en funksjon som gir oss den lengden på strengen.

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

307
00:21:53,090 --> 00:21:57,130
Og så så må du passere i en streng til det.

308
00:21:57,130 --> 00:21:59,760
Den trenger å vite hva streng det er behov for å beregne lengden på.

309
00:21:59,760 --> 00:22:03,160
Så da i dette tilfellet er vi arbeider med streng s.

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

311
00:22:05,860 --> 00:22:10,770
Så hva vi ønsker å gjøre, la oss printf.

312
00:22:10,770 --> 00:22:14,850
Nå ønsker vi å håndtere tegn. Vi ønsker å skrive ut hver enkelt karakter.

313
00:22:14,850 --> 00:22:22,150
Når du vil den skal skrive ut en flåte, vil du bruke plassholderen som% f.

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

315
00:22:24,580 --> 00:22:30,890
Og så på samme måte, med en karakter du bruker% c for å si at jeg kommer til å skrive ut et tegn

316
00:22:30,890 --> 00:22:34,570
som er lagret inne i en variabel.

317
00:22:34,570 --> 00:22:40,840
Så vi har dette, og la oss legge en periode og en plass til den.

318
00:22:40,840 --> 00:22:45,430
Hvilken karakter bruker vi?

319
00:22:45,430 --> 00:22:49,780
Vi kommer til å bruke uansett karakter vi er på av strengen.

320
00:22:49,780 --> 00:22:52,890
Så vi kommer til å bruke noe med streng,

321
00:22:52,890 --> 00:22:56,420
men vi ønsker å være tilgang til viss karakter der.

322
00:22:56,420 --> 00:23:02,740
Så hvis en streng er bare en matrise, så hvordan kan vi oppleve elementer av arrays?

323
00:23:02,740 --> 00:23:06,480
Vi har disse hakeparenteser, og da vi satte indeksen i det.

324
00:23:06,480 --> 00:23:11,820
Så vi har hakeparenteser. Vår indeksen i dette tilfellet kan vi bare bruke jeg. Akkurat.

325
00:23:15,290 --> 00:23:22,370
Så her vi sier vi skal skrive et tegn etterfulgt av et punktum og et mellomrom,

326
00:23:22,370 --> 00:23:30,870
og at karakteren skal være i. brevet i vårt bånd s.

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

328
00:23:42,510 --> 00:23:46,840
Nå skal jeg kjøre streng lengde.

329
00:23:46,840 --> 00:23:53,440
Så vi hadde en streng som heter OMG, og nå er det understreket enda mer.

330
00:23:53,440 --> 00:23:57,870
Tilsvarende, la oss si at vi faktisk ønsker å få en streng fra brukeren.

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

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

333
00:24:01,610 --> 00:24:08,040
Vi sa GetInt, ikke sant? Men dette er ikke int, så la oss GetString.

334
00:24:11,780 --> 00:24:17,770
La oss lage hyssinglengde. Her har vi ikke angi et bestemt spørsmål.

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

336
00:24:19,940 --> 00:24:23,820
Jeg kommer til å sette navnet mitt her, og så kan jeg gjøre en av de tingene

337
00:24:23,820 --> 00:24:29,600
hvor jeg tilordne et ord for hver bokstav eller noe sånt. Cool.

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

339
00:24:33,000 --> 00:24:34,640
Så vi er tilbake til Caesar.

340
00:24:34,640 --> 00:24:38,620
Vi har noen få verktøy på hvordan vi iterere over en streng,

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

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

343
00:24:44,720 --> 00:24:48,650
Som jeg nevnte tidligere, i ASCII-tabellen, din beste venn,

344
00:24:48,650 --> 00:24:52,300
du kommer til å se tallene som er forbundet med hver bokstav.

345
00:24:52,300 --> 00:24:55,900
Så her si vår klartekst er jeg svimmel!

346
00:24:55,900 --> 00:25:01,090
Deretter hver av disse tegnene kommer til å ha et nummer og ASCII-verdi forbundet med det,

347
00:25:01,090 --> 00:25:04,710
selv apostrof, selv plassen, selv utropstegn,

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

349
00:25:06,600 --> 00:25:12,360
Så si vår nøkkel som brukeren inkluderes i deres Kommandolinjeargumentet er 6.

350
00:25:12,360 --> 00:25:17,770
Det betyr for den første bokstaven, som er I, som er representert med 73,

351
00:25:17,770 --> 00:25:25,610
du vil gå tilbake til dem hva brevet er representert ved ASCII-verdi på 73 + 6.

352
00:25:25,610 --> 00:25:29,020
I dette tilfellet som ville være 79.

353
00:25:30,840 --> 00:25:35,040
Nå ønsker vi å gå til neste tegn.

354
00:25:35,040 --> 00:25:40,960
Så neste i indeks 1 av klarteksten ville være apostrof.

355
00:25:40,960 --> 00:25:46,780
Men husk vi bare ønsker å chiffrering bokstavene.

356
00:25:46,780 --> 00:25:50,040
Så vi ønsker å være sikker på at apostrof faktisk forblir den samme,

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

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

359
00:25:57,150 --> 00:26:00,780
Så vi ønsker å huske å bare chiffrering bokstavene

360
00:26:00,780 --> 00:26:04,560
fordi vi vil at alle andre symboler for å forbli uendret i vårt program.

361
00:26:04,560 --> 00:26:07,130
En annen ting som vi ønsker er å bevare store bokstaver.

362
00:26:07,130 --> 00:26:10,250
Så når du har en stor bokstav, bør det holde som en stor.

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

364
00:26:13,620 --> 00:26:19,480
Så noen nyttige funksjoner for å kunne forholde seg til bare enciphering bokstaver

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

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

367
00:26:25,130 --> 00:26:29,270
Og så disse er funksjoner som returnerer du en boolsk verdi.

368
00:26:29,270 --> 00:26:34,180
I utgangspunktet, sant eller usant. Er dette en stor? Er dette alfanumerisk?

369
00:26:34,180 --> 00:26:37,180
Er dette et brev, i hovedsak.

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

371
00:26:41,070 --> 00:26:47,060
I utgangspunktet kan du teste om verdien returnert til deg av den funksjonen er sant eller usant

372
00:26:47,060 --> 00:26:49,400
basert på at innspill.

373
00:26:49,400 --> 00:26:54,880
Enten ikke chiffrering noe eller Cipher det eller sørge for at det er store bokstaver, etc.

374
00:26:54,880 --> 00:27:01,080
[Student] Kan du bare forklare dem litt mer og hvordan du bruker dem? >> Ja, sikkert.

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

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

377
00:27:14,550 --> 00:27:18,740
Men vi vil være sikker på at det O kommer til å bli en stor O.

378
00:27:18,740 --> 00:27:22,940
Så i utgangspunktet, er den slags kommer til å endre våre innspill.

379
00:27:22,940 --> 00:27:26,870
Så enten det er store eller ikke vil slags endre måten vi håndtere det.

380
00:27:26,870 --> 00:27:32,360
Så hvis vi bruker isupper funksjon på den aktuelle indeksen,

381
00:27:32,360 --> 00:27:36,480
så isupper ("I"), som returnerer for oss sant, så vi vet at det er øvre.

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

383
00:27:40,360 --> 00:27:42,750
at du skal bruke til å skifte ting i Caesar,

384
00:27:42,750 --> 00:27:46,560
så da utgangspunktet, kommer det til å være en litt annen formel hvis det er store

385
00:27:46,560 --> 00:27:50,670
i motsetning til små bokstaver. Fornuftig?

386
00:27:51,020 --> 00:27:52,760
Ja. Ingen grunn til bekymring.

387
00:27:54,900 --> 00:27:58,990
Jeg snakket litt om å legge 6 til et brev, som ikke helt fornuftig

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

389
00:28:05,500 --> 00:28:08,920
er slags utbyttbare med heltall.

390
00:28:08,920 --> 00:28:11,250
Hva vi gjør er vi type bruk implisitt casting.

391
00:28:11,250 --> 00:28:18,100
Vi vil gå inn i casting litt senere på hvor du tar en verdi og du slår den inn i en annen type

392
00:28:18,100 --> 00:28:20,440
enn den opprinnelig var.

393
00:28:20,440 --> 00:28:25,910
Men med denne pset vil vi være i stand til å slags hverandre bruke tegn

394
00:28:25,910 --> 00:28:30,880
og deres tilsvarende heltallsverdier.

395
00:28:30,880 --> 00:28:35,140
Så hvis du bare encase en karakter med bare enkle anførselstegn,

396
00:28:35,140 --> 00:28:40,390
så vil du være i stand til å jobbe med det med heltall, som arbeider med det som et heltall.

397
00:28:40,390 --> 00:28:48,040
Så hovedstaden C gjelder til 67 år. Små bokstaver f relaterer til 102.

398
00:28:48,040 --> 00:28:51,480
Igjen, hvis du ønsker å vite disse verdiene, se på din ASCII-tabellen.

399
00:28:51,480 --> 00:28:56,160
Så la oss gå inn i noen eksempler på hvordan du kan være i stand til å trekke og legge til,

400
00:28:56,160 --> 00:29:03,130
hvordan du faktisk kan virkelig jobbe med disse tegnene, kan du bruke dem om hverandre.

401
00:29:03,870 --> 00:29:11,350
Jeg si at ASCIIMath skal beregne tillegg av et tegn til et heltall

402
00:29:11,350 --> 00:29:17,590
og viser deretter den resulterende karakter samt den resulterende ASCII verdi.

403
00:29:17,590 --> 00:29:22,290
Og så her jeg sier - vi vil håndtere denne delen senere -

404
00:29:22,290 --> 00:29:29,100
men innerst inne, jeg sier at brukeren skal si kjøre ASCIIMath sammen med en nøkkel,

405
00:29:29,100 --> 00:29:30,880
og jeg sier at den tasten skal være nummer

406
00:29:30,880 --> 00:29:34,600
som vi kommer til å legge dette tegnet.

407
00:29:34,600 --> 00:29:38,560
Så her legge merke til at siden jeg krevde en nøkkel,

408
00:29:38,560 --> 00:29:40,590
siden jeg krever at de gir meg en ting,

409
00:29:40,590 --> 00:29:45,600
Jeg vil bare godta. / Asciimath og en nøkkel.

410
00:29:45,600 --> 00:29:49,330
Så jeg kommer til å kreve at argc er lik 2.

411
00:29:49,330 --> 00:29:54,360
Hvis det ikke er det, så jeg kommer til å returnere en og programmet vil avslutte.

412
00:29:55,070 --> 00:29:58,540
Så jeg sier nøkkelen ikke kommer til å være den første kommandolinjen argument,

413
00:29:58,540 --> 00:30:05,080
det kommer til å bli den andre, og som du ser her,

414
00:30:05,080 --> 00:30:11,790
Jeg kommer til å slå den inn i et heltall.

415
00:30:15,740 --> 00:30:19,230
Så jeg kommer til å sette en karakter å være r.

416
00:30:19,230 --> 00:30:23,970
Legg merke til at den type av variabelen chr faktisk et heltall.

417
00:30:23,970 --> 00:30:30,480
Slik at jeg er i stand til å bruke r som et heltall er av encasing det med disse enkle anførselstegn.

418
00:30:33,850 --> 00:30:40,560
Så tilbake til vår printf uttalelse der vi har en plassholder for et tegn

419
00:30:40,560 --> 00:30:43,590
og deretter en plassholder for et heltall,

420
00:30:43,590 --> 00:30:49,450
tegnet er representert ved CHR, og heltallet er nøkkelen.

421
00:30:49,450 --> 00:30:54,320
Og så så vi kommer til å i resultatet legge 2 sammen.

422
00:30:54,320 --> 00:30:58,420
Så vi kommer til å legge r + uansett nøkkelen er,

423
00:30:58,420 --> 00:31:03,520
og vi kommer til å skrive ut resultatet av det.

424
00:31:06,210 --> 00:31:14,220
Så la oss gjøre asciimath. Det er opp til dato, så la oss bare kjøre asciimath.

425
00:31:14,220 --> 00:31:18,290
Oh, men se, det gjør ikke gjøre noe fordi vi ikke egentlig gi den en nøkkel.

426
00:31:18,290 --> 00:31:23,850
Så når det nettopp returnert 1, vår viktigste funksjon, det har nettopp returnert tilbake til oss.

427
00:31:23,850 --> 00:31:29,250
Så da la oss passere i en nøkkel. Noen gi meg et nummer. >> [Student] 4.

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

429
00:31:30,920 --> 00:31:39,280
So r økte med 4 kommer til å gi oss v, som svarer til den verdi av ASCII 118.

430
00:31:39,280 --> 00:31:43,880
Så da er det slags fornuftig at -

431
00:31:43,880 --> 00:31:51,250
Egentlig kan jeg spørre deg, hva tror du ASCII verdien av r er hvis r + 4 er 118?

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

433
00:31:55,470 --> 00:32:03,010
Så hvis du ser på ASCII-tabellen da, sikkert nok, vil du se at r er representert med 114.

434
00:32:03,010 --> 00:32:08,610
Så nå som vi vet at vi kan legge heltall til tegn, synes dette ganske enkelt.

435
00:32:08,610 --> 00:32:12,740
Vi er bare nødt til iterere over en streng som vi så i et eksempel før.

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

437
00:32:17,170 --> 00:32:20,420
Hvis det er, så får vi skifte den ved hva nøkkelen er.

438
00:32:20,420 --> 00:32:23,650
Ganske enkelt, bortsett fra når du kommer til å like dette,

439
00:32:23,650 --> 00:32:32,140
du ser at z, representert ved 122, ville da gi deg en annen karakter.

440
00:32:32,140 --> 00:32:37,770
Vi egentlig ønsker å holde seg innenfor alfabetet vår, ikke sant?

441
00:32:37,770 --> 00:32:43,180
Så vi må finne ut noen måte å slags innpakning rundt.

442
00:32:43,180 --> 00:32:47,190
Når du kommer zed og du ønsker å øke med et visst antall,

443
00:32:47,190 --> 00:32:51,230
du ikke ønsker å gå inn utover ASCII alfabetet delen;

444
00:32:51,230 --> 00:32:54,140
du ønsker å pakke tilbake hele veien til A.

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

446
00:32:58,550 --> 00:33:00,980
Så vet at bokstavene ikke kan bli symboler

447
00:33:00,980 --> 00:33:05,290
akkurat som symboler kommer ikke til å være i endring også.

448
00:33:05,290 --> 00:33:08,170
I det siste pset definitivt du ikke trenger å,

449
00:33:08,170 --> 00:33:14,310
men et alternativ var å implementere grådig pset ved hjelp av modulus funksjonen.

450
00:33:14,310 --> 00:33:17,230
Men nå er vi faktisk nødt til å bruke modulus,

451
00:33:17,230 --> 00:33:19,900
så la oss bare gå over denne litt.

452
00:33:19,900 --> 00:33:26,920
I hovedsak, når du har x modulo y, som gir deg resten av x delt på y.

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

454
00:33:30,930 --> 00:33:36,200
I utgangspunktet, når du trekker 15 fra 27 så mange ganger som mulig uten å få negative

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

456
00:33:39,060 --> 00:33:44,650
Så det er typen som i regnestykket sammenheng, men hvordan kan vi faktisk bruke dette?

457
00:33:44,650 --> 00:33:47,100
Det kommer til å være nyttig for taklist vår.

458
00:33:47,100 --> 00:33:55,420
For dette, la oss bare si at jeg ba dere alle til å dele inn i tre grupper.

459
00:33:55,420 --> 00:33:58,010
Noen ganger du gjør dette i grupper og noe sånt.

460
00:33:58,010 --> 00:34:01,320
Si Jeg sa: "OK, jeg vil at dere skal deles inn i tre."

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

462
00:34:04,240 --> 00:34:06,810
[Uhørlig student respons] Nettopp. Telle. Okay.

463
00:34:06,810 --> 00:34:10,260
La oss faktisk gjør det. Vil du begynne?

464
00:34:10,260 --> 00:34:13,810
[Studenter telling av] 1, 2, 3, 4.

465
00:34:13,810 --> 00:34:16,620
Men husk ... >> [Student] Oh, beklager.

466
00:34:16,620 --> 00:34:18,730
Det er en virkelig godt poeng.

467
00:34:18,730 --> 00:34:24,130
Du sa 4, men vi faktisk ønsker å si en, fordi vi bare vil tre grupper.

468
00:34:24,130 --> 00:34:30,159
Så, hvordan - Nei, det er et virkelig godt eksempel fordi så hvordan kan du si en?

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

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

471
00:34:36,760 --> 00:34:41,460
Så hvis du fortsetter, 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
Igjen, er du faktisk den femte personen. Hvordan vet du si 2 i stedet for 5?

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

475
00:34:53,760 --> 00:34:59,100
Jeg ønsker å se hvor mange grupper på 3 er igjen, så hvilken rekkefølge am I.

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

477
00:35:02,860 --> 00:35:07,760
da ville vi se at vi alltid faktisk påføre mod-funksjonen for oss selv

478
00:35:07,760 --> 00:35:09,990
å slags telle.

479
00:35:09,990 --> 00:35:14,490
Det er en mer slags konkret eksempel på hvordan du kan bruke modulo

480
00:35:14,490 --> 00:35:17,960
fordi jeg er sikker på at de fleste av oss har sikkert gått gjennom denne prosessen

481
00:35:17,960 --> 00:35:19,630
hvor vi har måttet telle.

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

483
00:35:21,840 --> 00:35:25,360
Det vil være ganske viktig å forstå begrepene dette,

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

485
00:35:28,640 --> 00:35:34,660
[Student] Hvis det ikke er resten, gir det deg den faktiske tall?

486
00:35:34,660 --> 00:35:40,430
Hvis en av de første 3 av dem hadde gjort det, ville det ha gitt dem det de faktisk var,

487
00:35:40,430 --> 00:35:43,310
eller ville det ha gitt dem [hørbar] >> Det er et godt spørsmål.

488
00:35:43,310 --> 00:35:48,750
Når det ikke er resten for modulo - så si at du har seks mod 3 -

489
00:35:48,750 --> 00:35:52,340
som faktisk gir deg tilbake 0.

490
00:35:53,670 --> 00:35:57,290
Vi skal snakke om det litt senere.

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

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

493
00:36:14,900 --> 00:36:17,620
som greit, hvis mod er 0 så jeg kommer til å være den tredje personen.

494
00:36:17,620 --> 00:36:22,740
Men vi får inn slag av hvordan vi kanskje vil håndtere det 0 er senere.

495
00:36:22,740 --> 00:36:32,750
Så nå har vi en eller annen måte har en måte å kartlegge zed til riktig bokstav.

496
00:36:32,750 --> 00:36:34,920
Så nå har vi gått gjennom disse eksemplene,

497
00:36:34,920 --> 00:36:37,880
Vi slags se hvordan Caesar kan fungere.

498
00:36:37,880 --> 00:36:42,640
Du ser de to alfabeter og deretter se dem skiftende.

499
00:36:42,640 --> 00:36:44,430
Så la oss prøve og uttrykke det i form av formelen.

500
00:36:44,430 --> 00:36:46,940
Denne formelen er faktisk gitt til deg i spec,

501
00:36:46,940 --> 00:36:52,070
men la oss slags utseende gjennom hva hver variabel betyr.

502
00:36:52,070 --> 00:36:55,000
Vår sluttresultatet kommer til å bli den krypterte teksten.

503
00:36:55,000 --> 00:36:58,300
Så dette sier at i. karakter chifferteksten

504
00:36:58,300 --> 00:37:02,500
skal tilsvare ith karakter klarteksten.

505
00:37:02,500 --> 00:37:08,130
Det er fornuftig fordi vi ønsker å alltid stå i kø disse tingene opp.

506
00:37:08,130 --> 00:37:13,480
Så det kommer til å bli den i. karakter chifferteksten pluss k, som er vår nøkkel -

507
00:37:13,480 --> 00:37:17,230
det er fornuftig - og så har vi denne mod 26.

508
00:37:17,230 --> 00:37:19,860
Husker tilbake når vi hadde zed

509
00:37:19,860 --> 00:37:24,190
Vi ønsker ikke å komme inn i karakter, så vi ønsket å mod det

510
00:37:24,190 --> 00:37:26,540
og hva slags sjal rundt alfabetet.

511
00:37:26,540 --> 00:37:33,430
Etter zed ville du gå til a, b, c, d, før du kom til riktig nummer.

512
00:37:33,430 --> 00:37:44,690
Så vi vet at zed, hvis + 6, ville gi oss f fordi etter Zed kommer a, b, c, d, e, f.

513
00:37:44,690 --> 00:37:52,530
Så la oss huske vet vi med sikkerhet at zed + 6 kommer til å gi oss f.

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

515
00:38:03,530 --> 00:38:10,570
Så vi må finne en måte å gjøre vår Caesar formel gir oss 102

516
00:38:10,570 --> 00:38:13,590
etter å ha tatt i 122.

517
00:38:13,590 --> 00:38:19,550
Så hvis vi bare bruke denne formelen, ('z' + 6)% 26, som faktisk gir deg 24

518
00:38:19,550 --> 00:38:25,980
fordi 122 + 6 er 128, 128% 26 gir deg 24 resten.

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

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

521
00:38:33,590 --> 00:38:41,550
Så åpenbart, må vi ha noen måte å tilpasse dette litt.

522
00:38:42,970 --> 00:38:51,340
I form av den vanlige alfabetet, vet vi at z er 26. brev og f er sjette.

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

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

525
00:39:00,690 --> 00:39:02,630
fordi en er 0.

526
00:39:02,630 --> 00:39:04,770
Så la oss nå bruke denne formelen.

527
00:39:04,770 --> 00:39:11,710
Vi har z representert ved 25 + 6, som gir deg 31.

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

529
00:39:15,790 --> 00:39:20,500
Det er perfekt, fordi vi vet at f er femte bokstaven i alfabetet.

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

531
00:39:26,400 --> 00:39:32,730
Så da for denne pset, vil en utfordring være å prøve å finne ut av forholdet

532
00:39:32,730 --> 00:39:36,910
mellom konvertere mellom disse ASCII-verdier og den alfabetiske indeksen.

533
00:39:36,910 --> 00:39:40,280
Hovedsak, hva du ønsker å gjøre, vil du starte med de ASCII-verdier,

534
00:39:40,280 --> 00:39:45,390
men da vil du liksom oversette det til en alfabetisk indeks

535
00:39:45,390 --> 00:39:52,610
deretter beregne hvilken bokstav det skal være - i utgangspunktet, hva det alfabetiske indeksen er

536
00:39:52,610 --> 00:39:57,660
av chiffer karakter - så oversette det tilbake til ASCII-verdier.

537
00:39:57,660 --> 00:40:04,870
Så hvis du piske ut din ASCII-tabellen, og deretter prøve og finne sammenhenger mellom for eksempel 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ått vår nøkkel fra kommandolinjeargumentene, har vi fått klartekst,

540
00:40:15,690 --> 00:40:17,520
Vi har enciphered det.

541
00:40:17,520 --> 00:40:19,820
Nå er alt vi har igjen å gjøre er å skrive den.

542
00:40:19,820 --> 00:40:22,040
Vi kunne gjøre dette et par forskjellige måter.

543
00:40:22,040 --> 00:40:24,570
Hva vi kan gjøre er å skrive faktisk som vi går langs.

544
00:40:24,570 --> 00:40:28,250
Som vi iterere over tegnene i strengen,

545
00:40:28,250 --> 00:40:31,660
Vi kan ganske enkelt bare skrive akkurat da når vi beregner det.

546
00:40:31,660 --> 00:40:36,030
Alternativt kan du også lagre den i en matrise, og har en rekke tegn

547
00:40:36,030 --> 00:40:39,280
og på slutten iterere over at hele array og skrive det ut.

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

549
00:40:40,980 --> 00:40:47,280
Og husk at% c kommer til å være plassholder for å skrive ut en karakter.

550
00:40:47,280 --> 00:40:50,420
Så det har vi Caesar, og nå går vi over til Vigenere,

551
00:40:50,420 --> 00:40:57,580
som er svært lik Caesar, men bare litt mer komplisert.

552
00:40:57,580 --> 00:41:03,310
Så egentlig med Vigenere er du kommer til å være bestått i et søkeord.

553
00:41:03,310 --> 00:41:06,510
Så i stedet for et tall, du kommer til å ha en streng,

554
00:41:06,510 --> 00:41:09,200
og så det kommer til å fungere som søkeordet ditt.

555
00:41:09,200 --> 00:41:14,440
Da, som vanlig, du kommer til å få en ledetekst for en streng fra brukeren

556
00:41:14,440 --> 00:41:19,050
og deretter chiffrering det og deretter gi dem den krypterte teksten tilbake.

557
00:41:19,050 --> 00:41:24,650
Så som jeg sa, det er veldig likt til keiseren, unntatt i stedet for skiftende av et visst antall,

558
00:41:24,650 --> 00:41:30,620
antallet er faktisk kommer til å endres hver gang fra karakter til karakter.

559
00:41:30,620 --> 00:41:34,890
Å representere det faktiske antallet til å skifte, er det representert ved tastaturet bokstaver.

560
00:41:34,890 --> 00:41:43,150
Så hvis du angir i en forskyvning av en, for eksempel, så som ville tilsvare en forskyvning av 0.

561
00:41:43,150 --> 00:41:45,900
Så det er igjen tilbake til den alfabetiske indeksen.

562
00:41:45,900 --> 00:41:49,100
Hva som kan være nyttig hvis du ser at vi faktisk arbeider med ASCII-verdier

563
00:41:49,100 --> 00:41:51,790
samt brev, samt som alfabetisk indeks,

564
00:41:51,790 --> 00:41:58,020
kanskje finne eller lage din egen ASCII-tabellen som viser den alfabetiske indeksen fra 0 til 25,

565
00:41:58,020 --> 00:42:03,750
A til Z, og de ASCII-verdier, slik at du kan slags se sammenhengen

566
00:42:03,750 --> 00:42:07,020
og skissere og prøve og finne noen mønstre.

567
00:42:07,020 --> 00:42:11,010
Tilsvarende, hvis du var skiftende på visse forekomsten ved f -

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

569
00:42:21,110 --> 00:42:24,180
Er vi bra så langt?

570
00:42:25,770 --> 00:42:30,050
Formelen for Vigenere er litt annerledes.

571
00:42:30,050 --> 00:42:32,960
I utgangspunktet, ser du at det er akkurat som Caesar,

572
00:42:32,960 --> 00:42:37,390
bortsett fra i stedet for bare k har vi k-indeksen j.

573
00:42:37,390 --> 00:42:44,810
Legg merke til at vi ikke bruker jeg fordi egentlig, lengden på søkeordet

574
00:42:44,810 --> 00:42:49,850
er ikke nødvendigvis lengden på chiffertekst vår.

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

576
00:42:56,130 --> 00:43:03,160
I utgangspunktet, hvis du kjører programmet med et nøkkelord for ohai,

577
00:43:03,160 --> 00:43:08,560
så det betyr at hver gang, er ohai kommer til å være din skift.

578
00:43:08,560 --> 00:43:11,060
Så avhengig av hva stilling du er i søkeordet ditt,

579
00:43:11,060 --> 00:43:15,800
du kommer til å skifte viss chiffertekst karakter ved dette beløpet.

580
00:43:15,800 --> 00:43:19,630
Igjen, akkurat som Caesar, vil vi sørge for at vi bevarer kapitaliseringen av ting

581
00:43:19,630 --> 00:43:22,900
og vi bare chiffrering bokstaver, ikke tegn eller mellomrom.

582
00:43:22,900 --> 00:43:26,330
Så se tilbake til Caesar på funksjoner som du kan ha brukt,

583
00:43:26,330 --> 00:43:32,570
den måten at du besluttet hvordan å skifte ting, og bruke det til programmet her.

584
00:43:32,570 --> 00:43:35,260
Så la oss kartlegge dette.

585
00:43:35,260 --> 00:43:39,680
Vi har en klartekst at vi har fått fra brukeren GetString

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

587
00:43:44,090 --> 00:43:47,090
Da har vi et søkeord ohai.

588
00:43:47,090 --> 00:43:50,930
De første fire tegnene er ganske enkel.

589
00:43:50,930 --> 00:43:55,580
Vi vet at T kommer til å bli forskjøvet av o,

590
00:43:55,580 --> 00:44:01,990
da h kommer til å bli forskjøvet av h, er jeg kommer til å bli forskjøvet med en.

591
00:44:01,990 --> 00:44:04,610
Her ser du at en står for 0,

592
00:44:04,610 --> 00:44:11,940
så da sluttverdien er faktisk akkurat det samme brevet som før.

593
00:44:11,940 --> 00:44:15,250
Deretter s skiftes ved jeg.

594
00:44:15,250 --> 00:44:19,370
Men da har du disse periodene her.

595
00:44:19,370 --> 00:44:25,960
Vi ønsker ikke å chiffrering det, så da vi ikke endre den ved noe

596
00:44:25,960 --> 00:44:31,280
og bare skrive ut perioden uendret.

597
00:44:31,280 --> 00:44:38,020
[Student] Jeg forstår ikke hvordan du vet at dette er forskjøvet ved - Hvor gjorde du - >> Beklager.

598
00:44:38,020 --> 00:44:41,620
På toppen her ser du at Kommandolinjeargumentet ohai her,

599
00:44:41,620 --> 00:44:43,740
som kommer til å være nøkkelordet.

600
00:44:43,740 --> 00:44:49,550
Og så i utgangspunktet, du sykle over karakterene i søkeordet.

601
00:44:49,550 --> 00:44:52,020
[Student] Så o kommer til å være skiftende det samme -

602
00:44:52,020 --> 00:44:56,260
Så o tilsvarer et visst antall i alfabetet.

603
00:44:56,260 --> 00:44:58,400
[Student] Høyre. Men hvor har du fått den CS50 del fra?

604
00:44:58,400 --> 00:45:02,540
Oh. Det er i GetString der du er som: "Gi meg en streng å kode."

605
00:45:02,540 --> 00:45:07,510
[Student] De kommer til å gi deg som argument for å skifte etter

606
00:45:07,510 --> 00:45:09,380
og da vil du be om din første strengen. >> Ja.

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

608
00:45:12,440 --> 00:45:14,740
i sine kommandolinjeargumenter når de kjører den.

609
00:45:14,740 --> 00:45:19,740
Så når du har sjekket at de faktisk har gitt deg en og ikke mer, ikke mindre,

610
00:45:19,740 --> 00:45:23,750
så du kommer til å be dem for en streng, sier: "Gi meg en streng."

611
00:45:23,750 --> 00:45:27,630
Så det er der i dette tilfellet har de gitt deg dette ... er CS50!

612
00:45:27,630 --> 00:45:32,090
Så da du kommer til å bruke den og bruke ohai og iterere over.

613
00:45:32,090 --> 00:45:38,200
Legg merke til at vi her hoppet over kryptere perioder,

614
00:45:38,200 --> 00:45:51,660
men i form av vår posisjon for ohai, den neste brukte vi o.

615
00:45:51,660 --> 00:45:54,990
I dette tilfellet er det litt vanskeligere å se fordi det er 4,

616
00:45:54,990 --> 00:45:57,710
så la oss fortsette litt. Bare stokk med meg her.

617
00:45:57,710 --> 00:46:02,960
Da har vi i og s, som deretter oversettes av o og h hhv.

618
00:46:02,960 --> 00:46:09,370
Da har vi en plass, og så da vet vi at vi ikke kommer til å chiffrering mellomrom.

619
00:46:09,370 --> 00:46:18,930
Men legg merke til at i stedet for å gå til en i denne situasjonen akkurat her,

620
00:46:18,930 --> 00:46:28,330
vi kryptere av en - Jeg vet ikke om du kan se det - akkurat her.

621
00:46:28,330 --> 00:46:33,710
Så det er ikke som du faktisk forhåndsbestemt, sier, o går her, går h her,

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

623
00:46:39,200 --> 00:46:43,760
Du bare skifte stilling i søkeordet

624
00:46:43,760 --> 00:46:51,020
når du vet at du faktisk kommer til å bli kryptere en faktisk brev.

625
00:46:51,020 --> 00:46:53,920
Gjør den slags fornuftig?

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

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

628
00:46:58,500 --> 00:47:03,760
Du vil være sikker på at du bare gå videre til neste bokstav i søkeordet ditt

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

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

631
00:47:09,120 --> 00:47:19,310
Vi legger merke til at det neste tegnet, på i indeksen av klarteksten, er et tall, for eksempel.

632
00:47:19,310 --> 00:47:31,630
Da vi ikke før j, indeksen for søkeordet vår, før vi kommer til et annet brev.

633
00:47:31,630 --> 00:47:36,230
Igjen, du også ønsker å være sikker på at du wraparound til begynnelsen av søkeordet

634
00:47:36,230 --> 00:47:37,770
når du er på slutten av den.

635
00:47:37,770 --> 00:47:42,030
Hvis du ser her er vi på jeg har den neste til å være o.

636
00:47:42,030 --> 00:47:47,690
Så du ønsker å finne noen måte å være i stand til å wraparound til begynnelsen av søkeordet

637
00:47:47,690 --> 00:47:49,470
hver gang du kommer til enden.

638
00:47:49,470 --> 00:47:55,040
Og så igjen, hva slags operatør er nyttig i så fall for innpakning rundt?

639
00:47:56,630 --> 00:47:59,840
Som i opptellingen off eksempel.

640
00:47:59,840 --> 00:48:03,710
[Student] The prosenttegn. >> Ja, et prosenttegn, som er modulo.

641
00:48:03,710 --> 00:48:11,250
Så modulo vil komme godt med her når du ønsker å bryte over indeksen i ohai din.

642
00:48:11,250 --> 00:48:17,700
Og bare en rask hint: Prøv å tenke på innpakning over søkeord litt som å telle på,

643
00:48:17,700 --> 00:48:23,590
der hvis det er tre grupper, 4. person,

644
00:48:23,590 --> 00:48:30,610
sine tall som sa de var fire mod 3, som var en.

645
00:48:30,610 --> 00:48:32,880
Så prøv og tenk på det på den måten.

646
00:48:34,770 --> 00:48:42,740
Som du så i formelen, hvor du har ci og deretter pi men da 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 trenger ikke å kalle det jeg, trenger du ikke å kalle det j,

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

650
00:48:53,270 --> 00:48:55,790
samt den posisjonen at du er på i søkeordet ditt

651
00:48:55,790 --> 00:48:59,840
fordi de er ikke nødvendigvis kommer til å være den samme.

652
00:48:59,840 --> 00:49:06,400
Ikke bare søkeordet - det kan være en helt annen lengde enn klartekst din.

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

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

655
00:49:14,450 --> 00:49:19,280
[Student] Er det en funksjon for å endre saken?

656
00:49:19,280 --> 00:49:24,530
Kan du endre en til kapital A? >> Ja, det er definitivt.

657
00:49:24,530 --> 00:49:27,890
Du kan sjekke ut - jeg tror det er toupper, alle 1 ord.

658
00:49:30,650 --> 00:49:36,310
Men når du prøver å chiffer ting og bevare teksten,

659
00:49:36,310 --> 00:49:39,350
det er best i utgangspunktet å ha separate tilfeller.

660
00:49:39,350 --> 00:49:42,040
Hvis det er en stor, så du vil skifte av dette

661
00:49:42,040 --> 00:49:46,460
fordi i formelen, når du ser tilbake hvordan vi må slags go

662
00:49:46,460 --> 00:49:50,900
hverandre mellom ASCII måte å representere tallene

663
00:49:50,900 --> 00:49:55,020
og den faktiske alfabetiske listen, ønsker vi å sørge for at

664
00:49:55,020 --> 00:50:01,850
det kommer til å være en slags mønster som du kommer til å bruke.

665
00:50:01,850 --> 00:50:04,580
Et annet notat på mønsteret, faktisk.

666
00:50:04,580 --> 00:50:07,250
Du kommer til å definitivt være å håndtere med tall.

667
00:50:07,250 --> 00:50:11,280
Prøv å ikke bruke magiske tall, som er et eksempel på stilen.

668
00:50:11,280 --> 00:50:18,470
Så si at du vil hver time shift noe av like -

669
00:50:18,470 --> 00:50:22,400
Ok, så hint, er en annen spoiler når du skal skifte noe

670
00:50:22,400 --> 00:50:26,310
av et bestemt beløp, prøv å ikke representere det ved en faktisk nummer

671
00:50:26,310 --> 00:50:32,810
men heller prøve og se om du kan bruke ASCII-verdi, noe som vil slags gjør mer fornuftig.

672
00:50:32,810 --> 00:50:35,470
Et annet notat: Fordi vi arbeider med formler,

673
00:50:35,470 --> 00:50:41,200
selv om din TF vil slags vet hva mønster du kanskje bruker,

674
00:50:41,200 --> 00:50:44,430
beste i din kommentar slags forklare logikken, som,

675
00:50:44,430 --> 00:50:51,880
"Jeg bruker dette mønsteret fordi ..." og hva slags forklare mønsteret konsist i dine kommentarer.

676
00:50:54,090 --> 00:50:58,990
[Dette var walkthrough 2] Hvis det ikke er noen andre spørsmål, så jeg vil bare bo her for en liten bit.

677
00:50:58,990 --> 00:51:04,370
Lykke til med pset 2: Crypto og takk for at du kom.

678
00:51:06,070 --> 00:51:08,620
[Student] Thank you. >> Takk.

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