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 - Harvarduniversitetet]

3
00:00:05,170 --> 00:00:07,490
[Detta är CS50. CS50.TV]

4
00:00:07,490 --> 00:00:10,750
Okej. Hej, alla, och välkomna till Walkthrough 2.

5
00:00:10,750 --> 00:00:14,330
Först vill jag gratulera dig för efterbehandling pset 1.

6
00:00:14,330 --> 00:00:18,140
Jag vet att det kunde ha varit lite tufft för en del av er,

7
00:00:18,140 --> 00:00:20,460
kunde ha varit din första datorprogram som du skrev,

8
00:00:20,460 --> 00:00:24,500
men kom ihåg att i slutet av detta, när man ser tillbaka i slutet av terminen,

9
00:00:24,500 --> 00:00:29,820
du ser på pset 1 och du säger: "Hej, jag kunde ha gjort det i 5 minuter."

10
00:00:29,820 --> 00:00:35,700
Så vet och litar på att vid slutet av detta du definitivt hittar pset 1 ganska enkelt.

11
00:00:35,700 --> 00:00:40,640
Men nu är det en enorm prestation, och grattis för att få gjort.

12
00:00:40,640 --> 00:00:44,010
Nu även en snabb anteckning innan vi kommer in i köttet på genomgången.

13
00:00:44,010 --> 00:00:48,340
Jag vill bara göra en snabb anteckning om att jag ibland inte har tillräckligt med tid

14
00:00:48,340 --> 00:00:52,500
under genomgångar för att gå igenom varenda sätt att göra problemet inställda

15
00:00:52,500 --> 00:00:56,140
och ganska bara kanske fokusera på 1 eller 2 slag av implementeringar,

16
00:00:56,140 --> 00:00:57,750
sätt som du kan göra detta.

17
00:00:57,750 --> 00:01:01,970
Men det är inte att säga att du är förbjudna från att göra det på ett annat sätt.

18
00:01:01,970 --> 00:01:05,980
Det finns ofta, som med datavetenskap, många sätt att göra saker,

19
00:01:05,980 --> 00:01:12,190
och så definitivt gärna använda en annan typ av lösning än jag kan ha fram.

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 frågorna - 1. Caesar - 2. Vigenère]

22
00:01:17,160 --> 00:01:20,650
Okej. Så problemet som 2: Crypto är en rolig en.

23
00:01:20,650 --> 00:01:24,500
Återigen, med varje pset du börjar med ett avsnitt med frågor

24
00:01:24,500 --> 00:01:29,600
det kommer att ske i dina sektioner med din tilldelade undervisning karl.

25
00:01:29,600 --> 00:01:31,670
Vi kommer inte att gå igenom dessa över genomgång,

26
00:01:31,670 --> 00:01:35,100
men de kommer definitivt att hjälpa dig att slutföra pset.

27
00:01:35,100 --> 00:01:38,100
Så den första delen av problemet uppsättningen är Caesar.

28
00:01:38,100 --> 00:01:43,470
Och så i Caesar någon passerar dig en nyckel med ett heltal,

29
00:01:43,470 --> 00:01:48,420
och du kommer att kryptera en textsträng som de ger dig

30
00:01:48,420 --> 00:01:50,670
och ge dem tillbaka en krypterad sak.

31
00:01:50,670 --> 00:01:56,050
Om någon såg A Christmas Story, det är ett exempel på att det finns.

32
00:01:56,050 --> 00:01:59,090
Sedan den andra delen av problemet uppsättningen är Vigenère,

33
00:01:59,090 --> 00:02:01,790
vilket är en mer avancerad krypteringsteknik.

34
00:02:01,790 --> 00:02:05,640
Och så ska vi chiffrera ett textstycke,

35
00:02:05,640 --> 00:02:09,600
utom i stället med bara en enda heltal, vi kommer faktiskt att koda det

36
00:02:09,600 --> 00:02:13,340
med ett sökord som användaren kommer att ge oss.

37
00:02:16,270 --> 00:02:22,090
Okej, så det första verktyget i verktygslådan idag faktiskt kommer att uppdatera apparaten.

38
00:02:22,090 --> 00:02:26,430
På diskussionsforumet skulle vi se saker som: "Varför inte det här arbetet?"

39
00:02:26,430 --> 00:02:28,110
"Varför inte lämnar in 50 arbete?"

40
00:02:28,110 --> 00:02:31,830
och ofta lösningen är faktiskt bara att uppdatera din apparat.

41
00:02:31,830 --> 00:02:36,730
Och så om du kör bara i ett terminalfönster i apparaten sudo yum-y -

42
00:02:36,730 --> 00:02:40,040
det är en flagga säga ja, uppdatera allt - uppdatering,

43
00:02:40,040 --> 00:02:42,280
då apparaten kommer att uppdatera om så behövs.

44
00:02:42,280 --> 00:02:46,960
Och det gör ont om du redan är på den senaste versionen av apparaten.

45
00:02:46,960 --> 00:02:51,280
Då kommer det att bara säga några nya uppdateringar tillgängliga och du kan fortsätta att arbeta tillsammans.

46
00:02:51,280 --> 00:02:55,800
Men det är bra att köra med varje gång du öppnar apparaten

47
00:02:55,800 --> 00:02:57,140
eftersom vi är fortfarande väldigt mycket -

48
00:02:57,140 --> 00:03:00,320
ibland om vi kommer in i en bugg - fastställande av det i apparaten.

49
00:03:00,320 --> 00:03:03,180
Så se till att du har den senaste versionen av apparaten

50
00:03:03,180 --> 00:03:07,710
och köra den uppdatera där.

51
00:03:07,710 --> 00:03:14,360
Okej. Så eftersom vi har att göra med bokstäver och ändra, chiffrering saker,

52
00:03:14,360 --> 00:03:20,410
vi kommer att verkligen vill bli bästa vänner med vår ASCII diagram.

53
00:03:20,410 --> 00:03:24,350
Det finns många sådana på nätet, om du hittar. Kanske till och med göra din egen.

54
00:03:24,350 --> 00:03:29,950
I grund och botten, med varje bokstav och varje nummer och varje tecken

55
00:03:29,950 --> 00:03:32,210
Det finns ett antal associerade med dem,

56
00:03:32,210 --> 00:03:38,670
och så är det bra att se sina ASCII-värden vid sidan av själva brevet.

57
00:03:38,670 --> 00:03:42,310
Som definitivt kommer att hjälpa dig i problemet set.

58
00:03:42,310 --> 00:03:45,750
En sak som verkligen hjälpte mig i detta problem set var att faktiskt skriva ut den,

59
00:03:45,750 --> 00:03:48,380
och när jag gick igenom, skulle jag dra faktiskt på det,

60
00:03:48,380 --> 00:03:51,150
skriva: "Om detta har att gå till där, då ..."

61
00:03:51,150 --> 00:03:55,270
Typ av rita på den och markera den upp, blir bästa vänner med din ASCII tabellen.

62
00:03:57,240 --> 00:04:00,750
Sedan har vi några andra verktyg till vårt förfogande.

63
00:04:00,750 --> 00:04:03,750
Denna gång i stället för att tillfrågas faktiskt användaren för alla deras bidrag

64
00:04:03,750 --> 00:04:05,230
Vi ska göra en kombination.

65
00:04:05,230 --> 00:04:06,880
Vi ska få dem för några ingång,

66
00:04:06,880 --> 00:04:11,350
men vi kommer även att bara använda kommandoradsargumenten.

67
00:04:11,350 --> 00:04:15,600
Så när de kör sina program, brukar du säga. / Hej, till exempel,

68
00:04:15,600 --> 00:04:17,310
Om ditt program var hej.c.

69
00:04:17,310 --> 00:04:22,500
Men den här gången istället för att bara säga att de kan sätta ord, argument efteråt.

70
00:04:22,500 --> 00:04:27,210
Och så ska vi använda vad de passerar in till oss som deras bidrag också,

71
00:04:27,210 --> 00:04:31,720
så gå längre än bara att fråga efter heltal, men också med hjälp kommandoradsargument.

72
00:04:31,720 --> 00:04:36,590
Och sedan går vi in ​​i matriser och strängar, som vi kommer att använda mycket också.

73
00:04:41,460 --> 00:04:44,810
Här är bara ett exempel på 1 mini ASCII diagram.

74
00:04:44,810 --> 00:04:48,460
Som jag sa, motsvarar varje bokstav till ett antal,

75
00:04:48,460 --> 00:04:52,510
och så bekanta dig med det. Det kommer att komma väl till pass.

76
00:04:52,510 --> 00:04:55,610
Och senare när vi börjar göra lite ASCIIMath behandlar siffrorna -

77
00:04:55,610 --> 00:05:00,110
addition, subtraktion dem - då definitivt bra att hänvisa till denna tabell.

78
00:05:02,860 --> 00:05:06,920
Så här är ett exempel på en Caesar chiffer - något som du kanske har spelat med.

79
00:05:06,920 --> 00:05:11,190
Det är bara ett hjul. I huvudsak finns det en yttre alfabet och sedan finns det en inre alfabet.

80
00:05:11,190 --> 00:05:15,290
Så rätt här är ett exempel på Caesar chiffer, men med en nyckel 0.

81
00:05:15,290 --> 00:05:21,540
I huvudsak är en linje med A, B i linje med B, ända upp till Z.

82
00:05:21,540 --> 00:05:26,590
Men sedan säger vi ville ha en nyckel 3, till exempel.

83
00:05:26,590 --> 00:05:33,280
Då skulle vi rotera det inre hjulet så att A nu ligger i linje med D, etc.

84
00:05:33,280 --> 00:05:35,250
Och så detta är i huvudsak vad vi ska göra.

85
00:05:35,250 --> 00:05:38,340
Vi har inte ett hjul, men vad vi ska göra är att vårt program

86
00:05:38,340 --> 00:05:44,490
slags skifta alfabetet tillsammans med oss ​​en viss mängd siffror.

87
00:05:44,490 --> 00:05:48,650
Så som jag sa tidigare, vi kommer att ha att göra med kommandoradsargument

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

89
00:05:50,390 --> 00:05:55,050
Så sätt som en användare kommer att köra din Caesar programmet är genom att säga. / Caesar

90
00:05:55,050 --> 00:05:58,090
och sedan ange ett nummer efter det.

91
00:05:58,090 --> 00:06:01,130
Och att antalet är nyckeln, skiftet,

92
00:06:01,130 --> 00:06:06,740
hur många gånger du kommer att vara rotera det inre hjulet i din Caesar chiffer.

93
00:06:06,740 --> 00:06:08,390
Och så du ser här ett exempel.

94
00:06:08,390 --> 00:06:14,550
Om vi ​​angett bokstäverna från A till L i vår Caesar chiffer,

95
00:06:14,550 --> 00:06:19,520
då skulle ingång D genom O eftersom det är varje brev flyttas över 3 gånger,

96
00:06:19,520 --> 00:06:22,080
precis som exempel hjulet som jag visade dig.

97
00:06:22,080 --> 00:06:25,300
Så då om du angett, till exempel, är här CS50!

98
00:06:25,300 --> 00:06:27,960
då skulle det också flytta alla bokstäver.

99
00:06:27,960 --> 00:06:31,040
Och det är en viktig sak i både Caesar och Vigenère

100
00:06:31,040 --> 00:06:34,890
är att vi kommer att hoppa över alla icke-bokstäver.

101
00:06:34,890 --> 00:06:39,160
Så blanksteg, tecken, etc, siffror, vi kommer att hålla dem samma.

102
00:06:39,160 --> 00:06:42,920
Vi ska bara flytta bokstäverna i detta fall.

103
00:06:42,920 --> 00:06:45,870
Så som du ser i hjulet har vi bara de bokstäver som finns tillgängliga för oss,

104
00:06:45,870 --> 00:06:50,150
så vi vill bara flytta bokstäverna och kryptera bokstäverna.

105
00:06:51,370 --> 00:06:56,720
Så det första du ska göra, du såg att användningen av Caesar i problemet som 2

106
00:06:56,720 --> 00:07:05,280
är att köra Caesar och ange ett nummer när du kör den i terminalen.

107
00:07:05,280 --> 00:07:10,940
Så vad vi behöver göra är att på något sätt få den knappen och komma åt den.

108
00:07:10,940 --> 00:07:14,730
Och så vill vi på något sätt se att det kommer att bli den andra kommandoraden argument.

109
00:07:14,730 --> 00:07:20,950
Den första kommer att bli. / Caesar, och nästa kommer att vara den viktigaste nummer.

110
00:07:22,190 --> 00:07:29,200
Så innan vi hade int main (void) för att starta vår C-program.

111
00:07:29,200 --> 00:07:31,790
Vi kommer att skala tillbaka ett lager lite

112
00:07:31,790 --> 00:07:34,720
och faktiskt se att istället för att passera i tomrum till vår huvuduppgift

113
00:07:34,720 --> 00:07:37,920
vi faktiskt att göra med 2 parametrar.

114
00:07:37,920 --> 00:07:44,070
Vi har en int som heter argc och sedan en array med strängar som kallas argv.

115
00:07:44,070 --> 00:07:46,030
Så argc är ett heltal,

116
00:07:46,030 --> 00:07:49,640
och det representerar antalet argument som skickas in till programmet.

117
00:07:49,640 --> 00:07:53,590
Och då argv är faktiskt en lista över de passerade argumenten.

118
00:07:53,590 --> 00:08:00,820
Alla argumenten är strängar, och så argv representerar en grupp, en lista, av strängar.

119
00:08:01,830 --> 00:08:03,990
Låt oss tala om arrayer lite.

120
00:08:03,990 --> 00:08:05,940
Arrayer är i huvudsak en ny datastruktur.

121
00:08:05,940 --> 00:08:09,660
Vi har Ints har vi dubblar, har vi strängar, och nu har vi arrayer.

122
00:08:09,660 --> 00:08:13,820
Arrayer är datastrukturer som kan hålla flera värden av samma typ,

123
00:08:13,820 --> 00:08:18,320
så i huvudsak en lista över vad du vill ha.

124
00:08:18,320 --> 00:08:24,400
I huvudsak, om du ville ha en lista av heltal All in 1 variabel,

125
00:08:24,400 --> 00:08:29,090
då du skulle skapa en ny variabel som var av typen int array.

126
00:08:29,090 --> 00:08:34,450
Så arrayer är noll-indexerad, vilket innebär att det första elementet i arrayen vid index 0.

127
00:08:34,450 --> 00:08:41,799
Om matrisen är av längd 4, som i detta exempel, då din sista delen skall vara på index 3,

128
00:08:41,799 --> 00:08:44,810
vilket är 4 - 1.

129
00:08:45,940 --> 00:08:48,420
Så för att skapa array, skulle du göra något liknande.

130
00:08:48,420 --> 00:08:51,440
Säg att du ville ha en dubbel uppsättning.

131
00:08:51,440 --> 00:08:56,520
Detta gäller för alla typer av datatyp, dock.

132
00:08:56,520 --> 00:09:00,210
Så säger du vill ha en dubbel uppsättning. Säg att du vill kalla det brevlåda.

133
00:09:00,210 --> 00:09:04,760
Precis som du skulle initiera någon annan dubbel,

134
00:09:04,760 --> 00:09:09,760
du skulle säga dubbel och sedan namnet, men den här gången vi sätta hakparenteser,

135
00:09:09,760 --> 00:09:13,570
och sedan numret kommer det att finnas längden av uppsättningen.

136
00:09:13,570 --> 00:09:16,840
Notera att i matriser vi aldrig kan ändra längden,

137
00:09:16,840 --> 00:09:21,230
så du måste alltid definiera och välja hur många lådor,

138
00:09:21,230 --> 00:09:25,440
hur många värden din matris kommer att hålla.

139
00:09:25,440 --> 00:09:31,820
Så för att ställa in olika värden i arrayen, du kommer att använda denna följande syntax,

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

141
00:09:33,200 --> 00:09:37,620
Du har brevlåda index 0 kommer att sättas till 1,2,

142
00:09:37,620 --> 00:09:42,180
brevlåda index 1 set till 2,4 mm

143
00:09:42,180 --> 00:09:47,910
Så nu när vi har granskat arrayer lite, låt oss gå tillbaka till argc och argv.

144
00:09:47,910 --> 00:09:52,220
Vi vet att argv nu en array med strängar.

145
00:09:52,220 --> 00:09:55,080
Så när en användare går in - säger att de kör ett program -

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

147
00:09:58,740 --> 00:10:05,160
vad programmet kommer att göra för dig redan faktiskt komma med vad argc och argv är.

148
00:10:05,160 --> 00:10:07,620
Så du behöver inte oroa dig för det.

149
00:10:07,620 --> 00:10:14,370
Argc i detta fall skulle vara 3 eftersom det ser 3 olika ord separerade med mellanslag.

150
00:10:14,370 --> 00:10:18,850
Och så då gruppen i detta fall skulle den första indexet vara. / Hej,

151
00:10:18,850 --> 00:10:21,770
nästa David nästa Malan.

152
00:10:21,770 --> 00:10:25,640
Ser någon direkt vad förhållandet mellan argv,

153
00:10:25,640 --> 00:10:28,990
 matrisen och argc är?

154
00:10:32,820 --> 00:10:38,090
Ja. Vi kommer få in den i ett exempel i args.c.

155
00:10:38,090 --> 00:10:42,880
Låt oss se om vi kan dra nytta av förhållandet mellan 2.

156
00:10:42,880 --> 00:10:46,550
Här kanske du upptäcker att i apparaten standardprogrammet

157
00:10:46,550 --> 00:10:49,450
att öppna. C-filer ibland Emacs.

158
00:10:49,450 --> 00:10:54,660
Men vi vill ta itu med gedit, så vad du kan göra är att du rätt kan klicka på C-fil,

159
00:10:54,660 --> 00:11:04,580
Gå till Egenskaper, Öppna med och välj sedan gedit, Ange som standard,

160
00:11:04,580 --> 00:11:13,020
och nu ditt program ska öppnas i gedit istället för Emacs.

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

162
00:11:17,120 --> 00:11:25,520
Så här har jag ett program som jag vill skriva ut varje argument kommandoraden.

163
00:11:25,520 --> 00:11:32,050
Så oavsett användarinmatningar, jag vill i huvudsak tillbaka den tillbaka till dem på en ny rad.

164
00:11:32,050 --> 00:11:36,710
Så vad är en struktur som vi kan använda för att iterera över något -

165
00:11:36,710 --> 00:11:40,380
något som du förmodligen används i din pset 1?

166
00:11:40,380 --> 00:11:45,840
Om du vill gå igenom ett visst antal saker? >> [Elev] För loop.

167
00:11:45,840 --> 00:11:48,910
För loop. Exakt. Så låt oss börja med for-slingan.

168
00:11:48,910 --> 00:11:56,900
Vi har för int i = 0. Låt oss börja med bara en vanlig initiering variabel.

169
00:11:56,900 --> 00:12:02,370
Jag ska lämna tillstånd för en uppsättning och sedan säga att jag + +, kommer att göra saker där.

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

171
00:12:04,090 --> 00:12:11,590
Så tänker tillbaka till argv om argv är listan över argument som skickas in till programmet

172
00:12:11,590 --> 00:12:15,380
och argc är antalet argument i programmet,

173
00:12:15,380 --> 00:12:21,280
då betyder det att argc är i huvudsak längden på argv, höger,

174
00:12:21,280 --> 00:12:28,970
eftersom det kommer att bli så många argument som värdet av argc.

175
00:12:28,970 --> 00:12:35,910
Så om vi vill att iterera över varje element i argv,

176
00:12:35,910 --> 00:12:43,290
vi kommer att vilja varje gång tillgång till variabeln i argv på givet index.

177
00:12:43,290 --> 00:12:49,060
Som kan representeras med detta, eller hur?

178
00:12:49,060 --> 00:12:53,430
Denna variabel här representerar särskilda strängen i detta fall

179
00:12:53,430 --> 00:12:57,030
eftersom det är en sträng array - den speciella strängen vid det givet index.

180
00:12:57,030 --> 00:13:00,690
Vad vi vill göra, i det här fallet vill vi skriva ut det, så låt oss säga printf.

181
00:13:00,690 --> 00:13:04,680
Och nu argv är en sträng, så vi vill sätta den platshållaren där.

182
00:13:04,680 --> 00:13:08,430
Vi vill ha en ny linje bara för att få det att se bra ut.

183
00:13:08,430 --> 00:13:12,530
Så här har vi en for-slinga. Vi har inte tillstånd ännu.

184
00:13:12,530 --> 00:13:20,020
Så jag börjar på 0 och sedan varje gång det kommer att skriva den givna strängen

185
00:13:20,020 --> 00:13:22,980
på den särskilda index i arrayen.

186
00:13:22,980 --> 00:13:28,410
Så när vi vill stoppa skriva ut element i arrayen?

187
00:13:28,410 --> 00:13:35,720
När vi är klara, eller hur? När vi har kommit till slutet av arrayen.

188
00:13:35,720 --> 00:13:38,870
Så vi vill inte överskrida förbi längden av uppsättningen,

189
00:13:38,870 --> 00:13:43,700
och vi vet redan att vi inte behöver faktiskt aktivt ta reda på vad längd argv är

190
00:13:43,700 --> 00:13:47,520
eftersom det har gett oss, och vad är det? Argc. Exakt.

191
00:13:47,520 --> 00:13:56,640
Så vi vill göra detta antal process argc gånger.

192
00:13:56,640 --> 00:13:59,550
Jag är inte i rätt katalog.

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

194
00:14:03,490 --> 00:14:08,990
Nu ska vi göra args. Inga fel, vilket är bra.

195
00:14:08,990 --> 00:14:11,430
Så låt oss bara köra args.

196
00:14:11,430 --> 00:14:15,130
Vad kommer detta att återvända till oss? Det kommer bara att skriva ut den tillbaka.

197
00:14:15,130 --> 00:14:18,320
"Du matas args i programmet, jag ska ge det tillbaka till dig."

198
00:14:18,320 --> 00:14:23,170
Så låt oss säga att vi vill säga args sedan foo bar.

199
00:14:23,170 --> 00:14:26,570
Så då skriver ut tillbaka till oss. Okej?

200
00:14:26,570 --> 00:14:30,790
Så det är ett exempel på hur du kan använda argc och argv

201
00:14:30,790 --> 00:14:33,460
att veta att argc representerar längden på argv.

202
00:14:33,460 --> 00:14:42,750
Se till att du inte någonsin med arrayer tillgång en bortom längden på arrayen

203
00:14:42,750 --> 00:14:45,140
eftersom C kommer definitivt att skrika på dig.

204
00:14:45,140 --> 00:14:47,560
Du får något som kallas ett segmenteringsfel,

205
00:14:47,560 --> 00:14:52,470
vilket är aldrig roligt, i princip säger att du försöker komma åt något

206
00:14:52,470 --> 00:14:55,000
som inte existerar, inte tillhör dig.

207
00:14:55,000 --> 00:14:59,430
Så se till att, och särskilt med noll-indexering, vi vill inte -

208
00:14:59,430 --> 00:15:02,390
Som till exempel, om vi har en array med längden 4,

209
00:15:02,390 --> 00:15:07,240
att fältindex 4 finns inte för att vi börjar på 0, noll index.

210
00:15:07,240 --> 00:15:11,730
Det kommer att bli en andra natur precis som för slingor när vi börjar på 0.

211
00:15:11,730 --> 00:15:13,610
Så bara ha det i åtanke.

212
00:15:13,610 --> 00:15:22,590
Du vill inte att någonsin komma åt index för en array som är bortom räckhåll.

213
00:15:26,710 --> 00:15:32,560
Så vi kan nu se hur vi kan typ av tillgång

214
00:15:32,560 --> 00:15:35,930
de kommandoradsargument som skickas in

215
00:15:35,930 --> 00:15:41,330
Men som ni såg strängen är argv faktiskt en sträng array.

216
00:15:41,330 --> 00:15:45,740
Så det är faktiskt inte ett heltal ännu, men i Caesar vill vi ta itu med heltal.

217
00:15:45,740 --> 00:15:54,430
Lyckligtvis finns det en funktion som skapats för oss som faktiskt kan konvertera en sträng till ett heltal.

218
00:15:54,430 --> 00:15:58,710
Också här vi inte har att göra med användarinmatning där vi uppmanar dem

219
00:15:58,710 --> 00:16:03,740
för inmatning här nyckeln, så vi kan inte faktiskt Fråga igen och säga,

220
00:16:03,740 --> 00:16:07,840
"Åh, ge mig en annan heltal, säg, om det inte är giltigt."

221
00:16:07,840 --> 00:16:10,540
Men vi måste fortfarande kontrollera korrekt användning.

222
00:16:10,540 --> 00:16:13,520
I Caesar de bara tillåts passera i 1 nummer,

223
00:16:13,520 --> 00:16:18,030
och så de måste köra. / caesar och då de måste ge dig ett nummer.

224
00:16:18,030 --> 00:16:23,660
Så argc måste vara ett visst antal.

225
00:16:23,660 --> 00:16:29,060
Vilket tal skulle det vara om de måste passera dig. / Caesar och sedan en nyckel?

226
00:16:29,060 --> 00:16:32,920
Vad är argc? >> [Elev] 2. >> Två. Exakt.

227
00:16:32,920 --> 00:16:35,490
Så du vill vara säker på att argc är 2.

228
00:16:35,490 --> 00:16:39,620
Annars kan du vägra princip att köra programmet.

229
00:16:39,620 --> 00:16:43,040
I främsta det är en funktion som säger int main,

230
00:16:43,040 --> 00:16:47,360
så vi alltid i god praxis retur 0 vid slutet av ett framgångsrikt program.

231
00:16:47,360 --> 00:16:50,840
Så om, säg, de ger dig 3 kommandoradsargument istället för 2

232
00:16:50,840 --> 00:16:54,350
eller ge dig 1, till exempel, vad du ska göra är att du vill söka efter den

233
00:16:54,350 --> 00:16:59,900
och sedan återvända 1 sade nej, jag kan inte fortsätta med det här programmet.

234
00:16:59,900 --> 00:17:03,190
[Elev] Det kan inte finnas en plats i din text. >> Ursäkta mig?

235
00:17:03,190 --> 00:17:06,780
[Elev] Det kan inte finnas ett utrymme i texten du försöker kryptera.

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

237
00:17:08,480 --> 00:17:11,280
När det gäller den text som vi försöker att kryptera, kommer som faktiskt senare

238
00:17:11,280 --> 00:17:13,970
när vi ger den texten.

239
00:17:13,970 --> 00:17:18,260
Så just nu är vi bara acceptera som kommando argument det verkliga antalet,

240
00:17:18,260 --> 00:17:21,579
själva skiftet för Caesar kryptering.

241
00:17:21,579 --> 00:17:27,569
[Elev] Varför behöver du 2 i motsats till bara 1 argc? Det är definitivt en siffra.

242
00:17:27,569 --> 00:17:32,200
Rätt. Anledningen till att vi behöver 2 för argc istället för 1

243
00:17:32,200 --> 00:17:36,260
beror på att när du kör ett program och säga. / caesar eller. / hej,

244
00:17:36,260 --> 00:17:38,280
som räknas faktiskt som ett argument.

245
00:17:38,280 --> 00:17:43,020
Så då tar redan upp 1 och så då vi mata 1 extra.

246
00:17:45,030 --> 00:17:49,440
Så du matar faktiskt en sträng på kommandoraden argument.

247
00:17:49,440 --> 00:17:52,730
Vad du vill göra, för Caesar vill vi ta itu med ett heltal,

248
00:17:52,730 --> 00:17:57,180
så du kan använda den här Atoi funktionen.

249
00:17:57,180 --> 00:18:02,850
Och i princip, passerar du den i en sträng och sedan kommer du tillbaka tillbaka ett heltal

250
00:18:02,850 --> 00:18:06,070
om det är möjligt att göra den strängen till ett heltal.

251
00:18:06,070 --> 00:18:10,960
Nu minns när vi har att göra med printf eller GetString, saker,

252
00:18:10,960 --> 00:18:13,390
Vi inkluderar bibliotek som är specifika för oss.

253
00:18:13,390 --> 00:18:19,450
Så i början vi börjar med en hash tagg standard I / O,. H nåt sånt.

254
00:18:19,450 --> 00:18:22,430
Tja, Atoi inte inom en av dessa bibliotek,

255
00:18:22,430 --> 00:18:26,600
så vad vi måste göra är att vi måste ha med rätt biblioteket för det.

256
00:18:26,600 --> 00:18:32,720
Så minns tillbaka till Walkthrough 1 där jag diskuterade den manuella funktionen.

257
00:18:32,720 --> 00:18:37,110
Du skriver man i din terminal och sedan följt av namnet på en funktion.

258
00:18:37,110 --> 00:18:39,720
Och så att kommer att ta upp en hel lista med dess användning,

259
00:18:39,720 --> 00:18:42,890
men även det kommer att ta upp vilka bibliotek som tillhör.

260
00:18:42,890 --> 00:18:47,000
Så jag lämnar det till dig att använda den manuella funktionen med Atoi

261
00:18:47,000 --> 00:18:53,360
och räkna ut vilka bibliotek du vill inkludera för att kunna använda Atoi funktionen.

262
00:18:54,450 --> 00:18:57,670
Så vi har fått nyckeln och nu det gäller att få vanlig text,

263
00:18:57,670 --> 00:19:01,820
och så som faktiskt kommer att vara användarvänlig ingång, där du uppmanas.

264
00:19:01,820 --> 00:19:05,540
Vi behandlat getInt och getFloat, och så i samma anda

265
00:19:05,540 --> 00:19:07,670
vi kommer att ha att göra med GetString.

266
00:19:07,670 --> 00:19:12,440
Men i detta fall behöver vi inte göra något DO WHILE eller medan slingor för att kontrollera.

267
00:19:12,440 --> 00:19:14,480
GetString kommer definitivt ge oss en sträng,

268
00:19:14,480 --> 00:19:17,630
och vi kommer att kryptera allt användaren ger oss.

269
00:19:17,630 --> 00:19:23,770
Så du kan anta att alla dessa användare inmatade strängar är korrekta.

270
00:19:23,770 --> 00:19:24,670
Jättebra.

271
00:19:24,670 --> 00:19:27,270
Så då när du har fått nyckeln och när du har fått texten,

272
00:19:27,270 --> 00:19:31,660
nu vad som är kvar är att du måste chiffrera klartexten.

273
00:19:31,660 --> 00:19:36,530
Bara snabbt för att täcka över fikonspråk är klartexten vad användaren ger,

274
00:19:36,530 --> 00:19:41,030
och chiffertexten är vad du återvänder till dem.

275
00:19:42,450 --> 00:19:45,850
Så strängar, för att kunna gå igenom faktiskt bokstav för bokstav

276
00:19:45,850 --> 00:19:48,550
eftersom vi måste flytta varje bokstav,

277
00:19:48,550 --> 00:19:51,390
vi förstår att strängar, om vi typ av skal tillbaka lagret,

278
00:19:51,390 --> 00:19:54,130
Vi ser att de är bara verkligen en lista med tecken.

279
00:19:54,130 --> 00:19:55,930
Man kommer efter den andra.

280
00:19:55,930 --> 00:20:01,690
Och så kan vi behandla strängar som matriser för att de är kedjor av tecken.

281
00:20:01,690 --> 00:20:05,640
Så säger du har en sträng som heter text,

282
00:20:05,640 --> 00:20:09,400
och inom den variabel text lagras här är CS50.

283
00:20:09,400 --> 00:20:15,680
Då text på index 0 skulle vara en stort T, skulle index 1 vara h, etc.

284
00:20:17,530 --> 00:20:23,970
Och därefter med arrayer i argc exempel args.c,

285
00:20:23,970 --> 00:20:27,090
Vi såg att vi var tvungna att iterera över en array

286
00:20:27,090 --> 00:20:32,440
och så var vi tvungna att iterera från i = 0 fram tills jag är mindre än längden.

287
00:20:32,440 --> 00:20:35,560
Så vi behöver något sätt att räkna ut vad längden på vår sträng är

288
00:20:35,560 --> 00:20:37,090
Om vi ​​ska iterera över den.

289
00:20:37,090 --> 00:20:42,300
Lyckligtvis igen, det är en funktion där för oss, även om senare under CS50

290
00:20:42,300 --> 00:20:45,860
kommer du definitivt att kunna genomföra och göra din egen funktion

291
00:20:45,860 --> 00:20:48,260
som kan beräkna längden på en sträng.

292
00:20:48,260 --> 00:20:52,120
Men nu ska vi använda stränglängd, så strlen.

293
00:20:52,120 --> 00:21:00,440
Du passerar i en sträng, och sedan kommer du tillbaka en int som representerar längden på din sträng.

294
00:21:00,440 --> 00:21:05,840
Låt oss titta på ett exempel på hur vi skulle kunna iterera över varje tecken i en sträng

295
00:21:05,840 --> 00:21:08,470
och göra något med det.

296
00:21:08,470 --> 00:21:13,250
Vad vi vill göra är att iterera över varje tecken i strängen,

297
00:21:13,250 --> 00:21:19,150
och vad vi vill göra är att vi trycka tillbaka varje tecken 1 av 1

298
00:21:19,150 --> 00:21:22,060
förutom att vi lägga till något bredvid.

299
00:21:22,060 --> 00:21:27,020
Så låt oss börja med for-slingan. Int i = 0.

300
00:21:27,020 --> 00:21:30,070
Vi kommer att lämna utrymme för tillståndet.

301
00:21:32,700 --> 00:21:36,840
Vi vill iterera tills vi når slutet av strängen, eller hur?

302
00:21:36,840 --> 00:21:41,340
Så vad funktionen ger oss längden på strängen?

303
00:21:41,340 --> 00:21:43,160
[Ohörbart elev svar]

304
00:21:43,160 --> 00:21:46,420
Det är längden på kommandoradsargumenten.

305
00:21:46,420 --> 00:21:50,650
Men för en sträng som vi vill använda en funktion som ger oss strängens längd.

306
00:21:50,650 --> 00:21:53,090
Så det är stränglängd.

307
00:21:53,090 --> 00:21:57,130
Och så måste du passera en sträng till den.

308
00:21:57,130 --> 00:21:59,760
Det måste veta vad sträng som behövs för att beräkna längden på.

309
00:21:59,760 --> 00:22:03,160
Så då i detta fall vi har att göra med snöre s.

310
00:22:04,790 --> 00:22:05,860
Jättebra.

311
00:22:05,860 --> 00:22:10,770
Så vad vi vill göra, låt oss printf.

312
00:22:10,770 --> 00:22:14,850
Nu vill vi ta itu med tecken. Vi vill skriva ut varje tecken.

313
00:22:14,850 --> 00:22:22,150
När du vill skriva ut en flottör, skulle du använda platshållare som% f.

314
00:22:22,150 --> 00:22:24,580
Med en int du skulle använda% d.

315
00:22:24,580 --> 00:22:30,890
Och så samma sätt, med en karaktär du använder% c för att säga att jag kommer att skriva ett tecken

316
00:22:30,890 --> 00:22:34,570
som lagras inuti en variabel.

317
00:22:34,570 --> 00:22:40,840
Så vi har det här, och låt oss lägga till en tid och en plats för den.

318
00:22:40,840 --> 00:22:45,430
Vilken karaktär använder vi?

319
00:22:45,430 --> 00:22:49,780
Vi kommer att använda allt tecken vi är på den strängen.

320
00:22:49,780 --> 00:22:52,890
Så då ska vi använda något med snöre,

321
00:22:52,890 --> 00:22:56,420
men vi vill vara tillgång till viss karaktär där.

322
00:22:56,420 --> 00:23:02,740
Så om en sträng är bara en array, hur kommer jag åt vi delar av matriser?

323
00:23:02,740 --> 00:23:06,480
Vi har dessa hakparenteser, och sedan sätter vi indexet där.

324
00:23:06,480 --> 00:23:11,820
Så vi har hakparenteser. Vårt index i det här fallet kan vi bara använda i. Exakt.

325
00:23:15,290 --> 00:23:22,370
Så här vi säger att vi kommer att skriva ett tecken följt av en punkt och ett mellanslag,

326
00:23:22,370 --> 00:23:30,870
och att karaktären kommer att vara det i: te bokstaven i vår sträng är.

327
00:23:32,920 --> 00:23:39,330
Jag ska bara rädda. Okej.

328
00:23:42,510 --> 00:23:46,840
Nu ska jag köra stränglängd.

329
00:23:46,840 --> 00:23:53,440
Så vi hade en sträng som heter OMG, och nu är det betonas ännu mer.

330
00:23:53,440 --> 00:23:57,870
Likaså, låt oss säga att vi verkligen vill få en sträng från användaren.

331
00:23:57,870 --> 00:23:59,580
Hur kan vi göra detta?

332
00:23:59,580 --> 00:24:01,610
Före, hur vi får en int?

333
00:24:01,610 --> 00:24:08,040
Vi sa getInt, eller hur? Men detta är inte int, så låt oss GetString.

334
00:24:11,780 --> 00:24:17,770
Låt oss göra stränglängd. Här har vi inte ange ett specifikt snabb.

335
00:24:17,770 --> 00:24:19,940
Så jag vet inte.

336
00:24:19,940 --> 00:24:23,820
Jag ska sätta mitt namn här och så då kan jag göra en av dessa saker

337
00:24:23,820 --> 00:24:29,600
där jag tilldelar ett ord för varje bokstav eller något liknande. Cool.

338
00:24:29,600 --> 00:24:31,900
Så det är stränglängd.

339
00:24:33,000 --> 00:24:34,640
Så vi är tillbaka till Caesar.

340
00:24:34,640 --> 00:24:38,620
Vi har några verktyg på hur vi iterera över en sträng,

341
00:24:38,620 --> 00:24:41,250
hur vi åt varje enskilt element.

342
00:24:41,250 --> 00:24:44,720
Så nu kan vi komma tillbaka till programmet.

343
00:24:44,720 --> 00:24:48,650
Som jag nämnde tidigare, i ASCII tabellen, din bästa vän,

344
00:24:48,650 --> 00:24:52,300
du kommer att se de nummer som är kopplade till varje bokstav.

345
00:24:52,300 --> 00:24:55,900
Så här säger vår klartext är jag yr!

346
00:24:55,900 --> 00:25:01,090
Då var och en av dessa tecken kommer att ha ett nummer och ASCII-värdet i samband med det,

347
00:25:01,090 --> 00:25:04,710
även apostrofen, även utrymmet, även utropstecken,

348
00:25:04,710 --> 00:25:06,600
så du vill ha det i åtanke.

349
00:25:06,600 --> 00:25:12,360
Så säger vår nyckel som användaren ingår i deras kommandoraden argument är 6.

350
00:25:12,360 --> 00:25:17,770
Det innebär för det första brev, som är jag, som representeras av 73,

351
00:25:17,770 --> 00:25:25,610
du vill återgå till dem oavsett bokstav representeras av ASCII-värdet 73 + 6.

352
00:25:25,610 --> 00:25:29,020
I det här fallet skulle det vara 79.

353
00:25:30,840 --> 00:25:35,040
Nu vill vi gå till nästa tecken.

354
00:25:35,040 --> 00:25:40,960
Så nästa i index 1 i klartext skulle vara apostrof.

355
00:25:40,960 --> 00:25:46,780
Men kom ihåg att vi bara vill kryptera bokstäverna.

356
00:25:46,780 --> 00:25:50,040
Så vi vill se till att apostrofen faktiskt förblir densamma,

357
00:25:50,040 --> 00:25:54,310
att vi inte ändras från 39 till vad 45 är.

358
00:25:54,310 --> 00:25:57,150
Vi vill hålla det som en apostrof.

359
00:25:57,150 --> 00:26:00,780
Så vi vill komma ihåg att endast chiffrera bokstäverna

360
00:26:00,780 --> 00:26:04,560
eftersom vi vill att alla andra symboler för att förbli oförändrad i vårt program.

361
00:26:04,560 --> 00:26:07,130
En annan sak som vi vill är att bevara bokstäver.

362
00:26:07,130 --> 00:26:10,250
Så när du har en stor bokstav, ska det vara som ett versalt.

363
00:26:10,250 --> 00:26:12,830
Gemena bokstäver ska stanna som gemener.

364
00:26:13,620 --> 00:26:19,480
Så några användbara funktioner för att kunna hantera endast chiffrering bokstäver

365
00:26:19,480 --> 00:26:22,380
och hålla bevara aktivering av saker

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

367
00:26:25,130 --> 00:26:29,270
Och så dessa funktioner som returnerar du ett booleskt värde.

368
00:26:29,270 --> 00:26:34,180
I grund och botten, sant eller falskt. Är detta ett versaler? Är alfanumeriska?

369
00:26:34,180 --> 00:26:37,180
Är detta ett brev, i huvudsak.

370
00:26:37,180 --> 00:26:41,070
Så här är 3 exempel på hur du skulle använda denna funktion.

371
00:26:41,070 --> 00:26:47,060
I grund och botten kan du testa om värdet som returneras till dig av den funktionen är sant eller falskt

372
00:26:47,060 --> 00:26:49,400
baserat på denna ingång.

373
00:26:49,400 --> 00:26:54,880
Antingen inte chiffrera något eller chiffrera det eller se till att det är versaler etc.

374
00:26:54,880 --> 00:27:01,080
[Elev] Kan du förklara bara de lite mer och hur du använder dem? >> Ja, säkert.

375
00:27:01,080 --> 00:27:08,470
Så om vi ser tillbaka, här har vi ett kapital jag, eller hur?

376
00:27:08,470 --> 00:27:14,550
Så vi vet att jag går till O eftersom jag + 6 är O.

377
00:27:14,550 --> 00:27:18,740
Men vi vill se till att att O kommer att bli en huvudstad O.

378
00:27:18,740 --> 00:27:22,940
Så i princip är den typen av kommer att förändra vår ingång.

379
00:27:22,940 --> 00:27:26,870
Så om det är versaler eller inte kommer slags ändra sättet som vi handskas med det.

380
00:27:26,870 --> 00:27:32,360
Så då om vi använder isupper funktion på visst index,

381
00:27:32,360 --> 00:27:36,480
så isupper ("I"), som returnerar för oss sant, så vi vet att det är den övre.

382
00:27:36,480 --> 00:27:40,360
Så då utifrån det senare går vi in ​​i en formel

383
00:27:40,360 --> 00:27:42,750
att du kommer att använda för att flytta saker i Caesar,

384
00:27:42,750 --> 00:27:46,560
så då grunden, det kommer att bli en något annorlunda formel om det är versaler

385
00:27:46,560 --> 00:27:50,670
i motsats till gemener. Vettigt?

386
00:27:51,020 --> 00:27:52,760
Ja. Inga bekymmer.

387
00:27:54,900 --> 00:27:58,990
Jag pratade lite om att lägga 6 till ett brev, som inte riktigt vettigt

388
00:27:58,990 --> 00:28:05,500
utom när vi sorts förstå att dessa tecken

389
00:28:05,500 --> 00:28:08,920
är typ av utbytbara heltal.

390
00:28:08,920 --> 00:28:11,250
Vad vi gör är att vi typ av användning implicit gjutning.

391
00:28:11,250 --> 00:28:18,100
Vi kommer att gå in i gjutning lite senare där du tar ett värde och du förvandla den till en annan typ

392
00:28:18,100 --> 00:28:20,440
än den ursprungligen var.

393
00:28:20,440 --> 00:28:25,910
Men med denna pset vi kommer att kunna slags omväxlande använda tecken

394
00:28:25,910 --> 00:28:30,880
och deras motsvarande heltalsvärden.

395
00:28:30,880 --> 00:28:35,140
Så om du bara innesluta en karaktär med bara enkla citattecken,

396
00:28:35,140 --> 00:28:40,390
då kommer du att kunna arbeta med det med heltal, som handlar om det som ett heltal.

397
00:28:40,390 --> 00:28:48,040
Så Capital C avser 67. Gement f avser 102.

398
00:28:48,040 --> 00:28:51,480
Återigen, om du vill veta dessa värden, titta på din ASCII tabellen.

399
00:28:51,480 --> 00:28:56,160
Så låt oss gå in några exempel på hur du skulle kunna dra och lägga till,

400
00:28:56,160 --> 00:29:03,130
hur du faktiskt verkligen kan arbeta med dessa tecken, växla mellan dem.

401
00:29:03,870 --> 00:29:11,350
Jag säger att ASCIIMath kommer att beräkna tillägget av ett tecken till ett heltal

402
00:29:11,350 --> 00:29:17,590
och visar sedan den resulterande karaktär samt det resulterande ASCII-värdet.

403
00:29:17,590 --> 00:29:22,290
Och så här jag säger - we'll hantera denna del senare -

404
00:29:22,290 --> 00:29:29,100
men i grunden, jag säger att användaren ska säga köra ASCIIMath tillsammans med en nyckel,

405
00:29:29,100 --> 00:29:30,880
och jag säger att den nyckeln kommer att vara nummer

406
00:29:30,880 --> 00:29:34,600
som vi kommer att lägga till denna karaktär.

407
00:29:34,600 --> 00:29:38,560
Så här märker att eftersom jag kräver en nyckel,

408
00:29:38,560 --> 00:29:40,590
eftersom jag kräver att de ger mig en sak,

409
00:29:40,590 --> 00:29:45,600
Jag vill bara att acceptera. / Asciimath och en nyckel.

410
00:29:45,600 --> 00:29:49,330
Så jag kommer att kräva att argc är lika med 2.

411
00:29:49,330 --> 00:29:54,360
Om det inte, så jag kommer att återvända 1 och programmet kommer att avslutas.

412
00:29:55,070 --> 00:29:58,540
Så jag säger nyckeln inte kommer att vara den första kommandoraden argument

413
00:29:58,540 --> 00:30:05,080
det kommer att vara den andra en, och som ni ser här,

414
00:30:05,080 --> 00:30:11,790
Jag ska vända det till ett heltal.

415
00:30:15,740 --> 00:30:19,230
Sen ska jag ställa ett tecken att vara r..

416
00:30:19,230 --> 00:30:23,970
Observera att den typ av variabeln chr är faktiskt ett heltal.

417
00:30:23,970 --> 00:30:30,480
Det sätt som jag kan använda r som ett heltal är genom att innesluta det med dessa enkla citattecken.

418
00:30:33,850 --> 00:30:40,560
Så tillbaka till våra printf uttalande där vi har en platshållare för ett tecken

419
00:30:40,560 --> 00:30:43,590
och sedan en platshållare för ett heltal,

420
00:30:43,590 --> 00:30:49,450
tecknet representeras av chr, och heltalet är nyckeln.

421
00:30:49,450 --> 00:30:54,320
Och så då ska vi i resultat lägga till 2 tillsammans.

422
00:30:54,320 --> 00:30:58,420
Så vi kommer att lägga R + vad nyckeln är,

423
00:30:58,420 --> 00:31:03,520
och då ska vi skriva ut resultatet av det.

424
00:31:06,210 --> 00:31:14,220
Så låt oss göra asciimath. Det är upp till datum, så låt oss bara köra asciimath.

425
00:31:14,220 --> 00:31:18,290
Åh, men se, det gör det inte något eftersom vi inte faktiskt ge det en nyckel.

426
00:31:18,290 --> 00:31:23,850
Så när det just återvänt 1, vår huvudsakliga funktion, återvände det bara tillbaka till oss.

427
00:31:23,850 --> 00:31:29,250
Så så låt oss gå i en nyckel. Någon ge mig ett nummer. >> [Elev] 4.

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

429
00:31:30,920 --> 00:31:39,280
Så R ökat med 4 kommer att ge oss v, vilket motsvarar ASCII-värdet på 118.

430
00:31:39,280 --> 00:31:43,880
Så då är det slags logiskt att -

431
00:31:43,880 --> 00:31:51,250
Egentligen kan jag be er, vad tror du ASCII värdet för r om r + 4 är 118?

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

433
00:31:55,470 --> 00:32:03,010
Så om du tittar på ASCII tabellen då, mycket riktigt, ser du att R representeras av 114.

434
00:32:03,010 --> 00:32:08,610
Så nu när vi vet att vi kan lägga heltal till tecken, verkar detta ganska enkelt.

435
00:32:08,610 --> 00:32:12,740
Vi ska bara iterera över en sträng som vi såg i ett exempel tidigare.

436
00:32:12,740 --> 00:32:17,170
Vi ska kolla om det är en bokstav.

437
00:32:17,170 --> 00:32:20,420
Om det är så kommer vi flytta den på något nyckeln är.

438
00:32:20,420 --> 00:32:23,650
Ganska enkelt, förutom när du kommer att gilla detta,

439
00:32:23,650 --> 00:32:32,140
du ser att z, företrädd av 122, då skulle ge dig en annan karaktär.

440
00:32:32,140 --> 00:32:37,770
Vi vill faktiskt bo i vårt alfabet, eller hur?

441
00:32:37,770 --> 00:32:43,180
Så vi måste ta reda på ett sätt att typ av omslag runt.

442
00:32:43,180 --> 00:32:47,190
När du når Zed och du vill öka med ett visst antal,

443
00:32:47,190 --> 00:32:51,230
du vill inte gå in mer än ASCII alfabetet sektionen;

444
00:32:51,230 --> 00:32:54,140
du vill linda tillbaka ända till A.

445
00:32:54,140 --> 00:32:58,550
Men kom ihåg att du fortfarande är att bevara fallet.

446
00:32:58,550 --> 00:33:00,980
Så vet att brev inte kan bli symboler

447
00:33:00,980 --> 00:33:05,290
precis som symboler inte kommer att förändras också.

448
00:33:05,290 --> 00:33:08,170
I den sista pset du definitivt inte behöver,

449
00:33:08,170 --> 00:33:14,310
men ett alternativ är att genomföra din giriga pset med modulen funktionen.

450
00:33:14,310 --> 00:33:17,230
Men nu är vi faktiskt kommer att behöva använda modulen,

451
00:33:17,230 --> 00:33:19,900
så låt oss bara gå över denna lite.

452
00:33:19,900 --> 00:33:26,920
I huvudsak, när du har X modulo y, som ger dig resten av x dividerat med y..

453
00:33:26,920 --> 00:33:30,930
Här är några exempel här. Vi har 27% 15.

454
00:33:30,930 --> 00:33:36,200
I grund och botten, när du subtrahera 15 från 27 så många gånger som möjligt utan att bli negativ

455
00:33:36,200 --> 00:33:39,060
då får du 12 kvar.

456
00:33:39,060 --> 00:33:44,650
Så det är ungefär som i matte sammanhang, men hur kan vi faktiskt använder det?

457
00:33:44,650 --> 00:33:47,100
Det kommer att vara till nytta för vår wrapover.

458
00:33:47,100 --> 00:33:55,420
För detta, låt oss bara säga att jag bad er alla att dela in i 3 grupper.

459
00:33:55,420 --> 00:33:58,010
Ibland kan du göra detta i grupper och något liknande.

460
00:33:58,010 --> 00:34:01,320
Säg jag sa: "Okej, jag vill att ni alla ska delas upp i 3."

461
00:34:01,320 --> 00:34:04,240
Hur kan du göra det?

462
00:34:04,240 --> 00:34:06,810
[Ohörbart elev svar] Ja, exakt. Räkna bort. Okej.

463
00:34:06,810 --> 00:34:10,260
Låt oss verkligen göra det. Vill du börja?

464
00:34:10,260 --> 00:34:13,810
[Studenter räkna ut] 1, 2, 3, 4.

465
00:34:13,810 --> 00:34:16,620
Men kom ihåg ... >> [Elev] Åh, förlåt.

466
00:34:16,620 --> 00:34:18,730
Det är en riktigt bra plats.

467
00:34:18,730 --> 00:34:24,130
Du sa 4, men vi faktiskt vill att du ska säga 1 eftersom vi vill bara 3 grupper.

468
00:34:24,130 --> 00:34:30,159
Alltså, hur - Nej, det är en riktigt bra exempel för då hur kan du säga 1?

469
00:34:30,159 --> 00:34:33,370
Vad är förhållandet mellan 4 och 1?

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

471
00:34:36,760 --> 00:34:41,460
Så om du fortsätter, skulle du vara 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
Återigen, du faktiskt den 5: e personen. Hur vet du att säga 2 istället för 5?

474
00:34:49,420 --> 00:34:53,760
Du säger 5 mod 3 är 2.

475
00:34:53,760 --> 00:34:59,100
Jag vill se hur många grupper av 3 lämnas över, sedan vilken ordning är jag

476
00:34:59,100 --> 00:35:02,860
Och så då om vi fortsatte längs hela rummet,

477
00:35:02,860 --> 00:35:07,760
då skulle vi se att vi alltid faktiskt är tillämpar MOD-funktionen till oss

478
00:35:07,760 --> 00:35:09,990
till typ av räkna ut.

479
00:35:09,990 --> 00:35:14,490
Det är en mer typ av konkret exempel på hur du kan använda modulo

480
00:35:14,490 --> 00:35:17,960
eftersom jag är säker på de flesta av oss har nog gått igenom den processen

481
00:35:17,960 --> 00:35:19,630
där vi har haft att räkna ut.

482
00:35:19,630 --> 00:35:21,840
Eventuella frågor om modulo?

483
00:35:21,840 --> 00:35:25,360
Det kommer att vara ganska viktigt att förstå begreppen detta,

484
00:35:25,360 --> 00:35:28,640
så jag vill se till att ni förstår.

485
00:35:28,640 --> 00:35:34,660
[Elev] Om det inte finns någon resterande ger det dig det verkliga antalet?

486
00:35:34,660 --> 00:35:40,430
Om en av de 3 första av dem hade gjort det, skulle det ha gett dem vad de faktiskt var,

487
00:35:40,430 --> 00:35:43,310
eller skulle det ha gett dem [ohörbart] >> Det är en bra fråga.

488
00:35:43,310 --> 00:35:48,750
När det inte finns någon rest för modulo - så att du har 6 mod 3 -

489
00:35:48,750 --> 00:35:52,340
som ger faktiskt tillbaka 0.

490
00:35:53,670 --> 00:35:57,290
Vi pratar om det lite senare.

491
00:35:58,810 --> 00:36:07,720
Åh ja, till exempel den 3: e person - är 3 mod 3 faktiskt 0 men hon sa 3.

492
00:36:07,720 --> 00:36:14,900
Så det är ungefär som en inre fångst, till exempel,

493
00:36:14,900 --> 00:36:17,620
Liksom okej, om mod är 0 så kommer jag att vara den 3: e person.

494
00:36:17,620 --> 00:36:22,740
Men vi får in typ av hur vi kan vill ta itu med det som 0 är senare.

495
00:36:22,740 --> 00:36:32,750
Så nu har vi något ett sätt att kartlägga Zed till rätt bokstav.

496
00:36:32,750 --> 00:36:34,920
Så nu har vi gått igenom dessa exempel,

497
00:36:34,920 --> 00:36:37,880
vi typ av se hur Caesar kan fungera.

498
00:36:37,880 --> 00:36:42,640
Du ser 2 alfabet och sedan se dem flytta.

499
00:36:42,640 --> 00:36:44,430
Så låt oss försöka uttrycka det i termer av formel.

500
00:36:44,430 --> 00:36:46,940
Denna formel är faktiskt ges till dig i spec,

501
00:36:46,940 --> 00:36:52,070
men låt oss typ av utseende genom vad varje variabel betyder.

502
00:36:52,070 --> 00:36:55,000
Vår slutresultatet kommer att bli chiffertexten.

503
00:36:55,000 --> 00:36:58,300
Så detta säger att den i: te karaktär chiffertexten

504
00:36:58,300 --> 00:37:02,500
kommer att motsvara den i: te karaktär klartexten.

505
00:37:02,500 --> 00:37:08,130
Det är klokt att vi vill alltid vara kö dessa saker upp.

506
00:37:08,130 --> 00:37:13,480
Så det kommer att bli den i: te karaktär chiffertexten plus k, som är vår nyckel -

507
00:37:13,480 --> 00:37:17,230
som är vettigt - och då har vi denna mod 26.

508
00:37:17,230 --> 00:37:19,860
Tänk tillbaka när vi hade Zed

509
00:37:19,860 --> 00:37:24,190
Vi ville inte komma in i karaktären, så vi ville mod den

510
00:37:24,190 --> 00:37:26,540
och typ av linda runt alfabetet.

511
00:37:26,540 --> 00:37:33,430
Efter zed du skulle gå till a, b, c, d, tills du kom till rätt nummer.

512
00:37:33,430 --> 00:37:44,690
Så vi vet att Zed om + 6, skulle ge oss f för efter zed kommer a, b, c, d, e, f.

513
00:37:44,690 --> 00:37:52,530
Så låt oss komma ihåg att vi vet att zed + 6 kommer att ge oss f..

514
00:37:52,530 --> 00:38:03,530
I ASCII-värden är z 122 och f är 102.

515
00:38:03,530 --> 00:38:10,570
Så vi måste hitta ett sätt att göra vår Caesar formel ger oss 102

516
00:38:10,570 --> 00:38:13,590
efter att i 122.

517
00:38:13,590 --> 00:38:19,550
Så om vi tillämpar just denna formel, ('Z' + 6)% 26, som faktiskt ger 24

518
00:38:19,550 --> 00:38:25,980
eftersom 122 + 6 är 128, 128% 26 ger 24 återstoden.

519
00:38:25,980 --> 00:38:29,140
Men det betyder inte riktigt f.. Det är definitivt inte 102.

520
00:38:29,140 --> 00:38:33,590
Det är inte heller den 6: e bokstaven i alfabetet.

521
00:38:33,590 --> 00:38:41,550
Så uppenbarligen måste vi ha någon form av justeringar detta lite.

522
00:38:42,970 --> 00:38:51,340
När det gäller den vanliga alfabetet, vet vi att z är den 26: e bokstaven och f är den 6: e.

523
00:38:51,340 --> 00:38:55,460
Men vi är i datavetenskap, så vi kommer att index på 0.

524
00:38:55,460 --> 00:39:00,690
Så då istället för z är antalet 26, vi kommer att säga att det är nummer 25

525
00:39:00,690 --> 00:39:02,630
eftersom en är 0.

526
00:39:02,630 --> 00:39:04,770
Så nu ska vi tillämpa denna formel.

527
00:39:04,770 --> 00:39:11,710
Vi har z representeras av 25 + 6, vilket ger dig 31.

528
00:39:11,710 --> 00:39:15,790
Och 31 mod 26 ger 5 som en rest.

529
00:39:15,790 --> 00:39:20,500
Det är perfekt eftersom vi vet att f är den 5: e bokstaven i alfabetet.

530
00:39:20,500 --> 00:39:26,400
Men det är fortfarande inte f, eller hur? Det är fortfarande inte 102.

531
00:39:26,400 --> 00:39:32,730
Så då detta pset kommer en utmaning att försöka ta reda på sambandet

532
00:39:32,730 --> 00:39:36,910
mellan att konvertera mellan dessa ASCII-värden och den alfabetiska index.

533
00:39:36,910 --> 00:39:40,280
I huvudsak, vad du vill göra, vill du börja med ASCII-värden,

534
00:39:40,280 --> 00:39:45,390
men då du vill på något sätt översätta det till ett alfabetiskt register

535
00:39:45,390 --> 00:39:52,610
sedan beräkna vilken bokstav det ska vara - i grund och botten, vad det alfabetiska index

536
00:39:52,610 --> 00:39:57,660
av chiffer karaktär - sedan översätta det tillbaka till ASCII-värden.

537
00:39:57,660 --> 00:40:04,870
Så om du piska ut din ASCII tabellen och sedan försöka hitta samband mellan, säg, 102 och 5

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

539
00:40:12,140 --> 00:40:15,690
Vi har fått vår nyckel från kommandoradsargumenten har vi fått i klartext,

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

541
00:40:17,520 --> 00:40:19,820
Nu är allt vi har kvar att göra är att skriva ut det.

542
00:40:19,820 --> 00:40:22,040
Vi kan göra det här ett par olika sätt.

543
00:40:22,040 --> 00:40:24,570
Vad vi kan göra är att skriva ut faktiskt när vi går tillsammans.

544
00:40:24,570 --> 00:40:28,250
När vi iterera över tecknen i strängen,

545
00:40:28,250 --> 00:40:31,660
Vi kunde helt enkelt bara ut just då när vi beräknar den.

546
00:40:31,660 --> 00:40:36,030
Alternativt kan du även lagra den i en matris och har en rad tecken

547
00:40:36,030 --> 00:40:39,280
och i slutet iterera över den hel rad och skriva ut den.

548
00:40:39,280 --> 00:40:40,980
Så du har ett par alternativ för det.

549
00:40:40,980 --> 00:40:47,280
Och kom ihåg att% c kommer att vara platshållaren för utskrift av en karaktär.

550
00:40:47,280 --> 00:40:50,420
Så där har vi Caesar och nu går vi vidare till Vigenère,

551
00:40:50,420 --> 00:40:57,580
som är mycket lik Caesar men bara något mer komplex.

552
00:40:57,580 --> 00:41:03,310
Så i huvudsak med Vigenère är att du kommer att vara passerar i ett sökord.

553
00:41:03,310 --> 00:41:06,510
Så istället för ett nummer, du kommer att ha en sträng,

554
00:41:06,510 --> 00:41:09,200
och så det kommer att fungera som ditt sökord.

555
00:41:09,200 --> 00:41:14,440
Då, som vanligt, du kommer att få en snabb för en sträng från användaren

556
00:41:14,440 --> 00:41:19,050
och sedan chiffrera den och sedan ge dem chiffertexten tillbaka.

557
00:41:19,050 --> 00:41:24,650
Så som jag sa, det är mycket likt Caesar, utom i stället för att flytta på ett visst antal,

558
00:41:24,650 --> 00:41:30,620
Antalet faktiskt kommer att ändras varje gång från karaktär till karaktär.

559
00:41:30,620 --> 00:41:34,890
För att representera detta verkliga antalet att flytta, det representeras av tangentbordet bokstäver.

560
00:41:34,890 --> 00:41:43,150
Så om du skriver i en förskjutning av en, till exempel, då skulle motsvara en förskjutning av 0.

561
00:41:43,150 --> 00:41:45,900
Så det är återigen tillbaka till det alfabetiska registret.

562
00:41:45,900 --> 00:41:49,100
Vad kan vara användbart om du ser att vi faktiskt har att göra med ASCII-värden

563
00:41:49,100 --> 00:41:51,790
liksom bokstäver, liksom den alfabetiska index,

564
00:41:51,790 --> 00:41:58,020
kanske hitta eller skapa din egen ASCII tabell som visar det alfabetiska indexet 0 till 25,

565
00:41:58,020 --> 00:42:03,750
A till Z, och de ASCII-värden så att du kan typen av se förhållandet

566
00:42:03,750 --> 00:42:07,020
och skissa på och försöka hitta några mönster.

567
00:42:07,020 --> 00:42:11,010
Likaså om du flytta på den säkra instans av F -

568
00:42:11,010 --> 00:42:21,110
och detta är antingen gemener eller versaler f - då skulle motsvara 5.

569
00:42:21,110 --> 00:42:24,180
Är vi bra så här långt?

570
00:42:25,770 --> 00:42:30,050
Formeln för Vigenère är lite annorlunda.

571
00:42:30,050 --> 00:42:32,960
I grund och botten, ser du att det är precis som Caesar,

572
00:42:32,960 --> 00:42:37,390
utom i stället för bara k vi har k index j.

573
00:42:37,390 --> 00:42:44,810
Observera att vi inte använder i grund huvudsak längden på sökordet

574
00:42:44,810 --> 00:42:49,850
är inte nödvändigtvis längden på vår chiffertext.

575
00:42:49,850 --> 00:42:56,130
Detta kommer att vara lite tydligare när vi ser ett exempel på att jag har lite senare.

576
00:42:56,130 --> 00:43:03,160
I grund och botten, om du kör programmet med nyckelordet ohai,

577
00:43:03,160 --> 00:43:08,560
då det betyder att varje gång är ohai kommer att bli ditt skift.

578
00:43:08,560 --> 00:43:11,060
Så beroende på vilken position du befinner dig i ditt sökord,

579
00:43:11,060 --> 00:43:15,800
du kommer att flytta din vissa chiffertexten karaktär med motsvarande belopp.

580
00:43:15,800 --> 00:43:19,630
Igen, precis som Caesar, vill vi se till att vi bevarar kapitaliseringen av saker

581
00:43:19,630 --> 00:43:22,900
och vi bara chiffrera bokstäver, inte tecken eller mellanslag.

582
00:43:22,900 --> 00:43:26,330
Så se tillbaka till Caesar på de funktioner som du kan ha använt,

583
00:43:26,330 --> 00:43:32,570
det sätt som du bestämt hur att flytta saker, och tillämpa det till ditt program här.

584
00:43:32,570 --> 00:43:35,260
Så låt oss kartlägga detta.

585
00:43:35,260 --> 00:43:39,680
Vi har en klartext som vi har fått från användaren från getString

586
00:43:39,680 --> 00:43:44,090
säger detta ... är CS50!

587
00:43:44,090 --> 00:43:47,090
Sedan har vi ett sökord i ohai.

588
00:43:47,090 --> 00:43:50,930
De första 4 tecknen är ganska enkel.

589
00:43:50,930 --> 00:43:55,580
Vi vet att T kommer att skiftas med O,

590
00:43:55,580 --> 00:44:01,990
då h kommer att skiftas med h, jag kommer att flyttas med en.

591
00:44:01,990 --> 00:44:04,610
Här ser du att en representerar 0,

592
00:44:04,610 --> 00:44:11,940
så då slutvärdet är faktiskt precis samma bokstav som tidigare.

593
00:44:11,940 --> 00:44:15,250
Sedan s skiftas av i.

594
00:44:15,250 --> 00:44:19,370
Men då har du dessa perioder här.

595
00:44:19,370 --> 00:44:25,960
Vi vill inte att chiffrera det, så vi inte ändra det genom något

596
00:44:25,960 --> 00:44:31,280
och bara skriva ut den period oförändrad.

597
00:44:31,280 --> 00:44:38,020
[Eleven] Jag förstår inte hur ni vet att detta förskjuts med - Var har du - >> Förlåt.

598
00:44:38,020 --> 00:44:41,620
På toppen här ser du att kommandoraden argumentet ohai här,

599
00:44:41,620 --> 00:44:43,740
det kommer att bli nyckelordet.

600
00:44:43,740 --> 00:44:49,550
Och så i princip, du cykla över karaktärerna i sökordet.

601
00:44:49,550 --> 00:44:52,020
[Eleven] Så o kommer att flytta densamma -

602
00:44:52,020 --> 00:44:56,260
Så o motsvarar ett visst antal i alfabetet.

603
00:44:56,260 --> 00:44:58,400
[Elev] Rätt. Men där fick du CS50 del från?

604
00:44:58,400 --> 00:45:02,540
Åh. Det är i getString där du är som, "Ge mig en sträng att koda."

605
00:45:02,540 --> 00:45:07,510
[Eleven] De kommer att ge dig det argumentet att flytta med

606
00:45:07,510 --> 00:45:09,380
och då kommer du be om din första strängen. >> Ja.

607
00:45:09,380 --> 00:45:12,440
Så när de kör programmet, kommer de att inkludera sökordet

608
00:45:12,440 --> 00:45:14,740
i sina kommandoradsargument när de kör det.

609
00:45:14,740 --> 00:45:19,740
Sen när du har kontrollerat att de faktiskt har gett dig 1 och inte mer, inte mindre,

610
00:45:19,740 --> 00:45:23,750
då du kommer att få dem efter en sträng, säger: "Ge mig en sträng."

611
00:45:23,750 --> 00:45:27,630
Så det är där i det här fallet har de gett dig här ... är CS50!

612
00:45:27,630 --> 00:45:32,090
Så då du kommer att använda den och använda ohai och iterera över.

613
00:45:32,090 --> 00:45:38,200
Lägg märke till att vi här hoppat över kryptering perioder,

614
00:45:38,200 --> 00:45:51,660
men när det gäller vår position för ohai, nästa vi använde o..

615
00:45:51,660 --> 00:45:54,990
I det här fallet är det lite svårare att se eftersom det är 4,

616
00:45:54,990 --> 00:45:57,710
så låt oss fortsätta lite. Bara hålla med mig här.

617
00:45:57,710 --> 00:46:02,960
Sedan har vi i och s, som sedan översätts av O och H resp.

618
00:46:02,960 --> 00:46:09,370
Sedan har vi ett utrymme, och så då vet vi att vi inte kommer att chiffrera utrymmen.

619
00:46:09,370 --> 00:46:18,930
Men märker att istället för att gå till en i denna plats här,

620
00:46:18,930 --> 00:46:28,330
vi kryptering med - jag vet inte om du kan se det - här.

621
00:46:28,330 --> 00:46:33,710
Så det är inte som du faktiskt förutbestämd, säg, O går här går h här,

622
00:46:33,710 --> 00:46:39,200
en går här, går jag här, o, h, a, I, O, H, A, I. Man gör inte det.

623
00:46:39,200 --> 00:46:43,760
Du ändrar bara din position i sökordet

624
00:46:43,760 --> 00:46:51,020
när du vet att du faktiskt kommer att kryptera en verklig brev.

625
00:46:51,020 --> 00:46:53,920
Gör en sådan känsla?

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

627
00:46:56,490 --> 00:46:58,500
Så bara några påminnelser.

628
00:46:58,500 --> 00:47:03,760
Du vill vara säker på att du bara vidare till nästa bokstav i sökordet

629
00:47:03,760 --> 00:47:06,390
Om tecknet i klartext är en bokstav.

630
00:47:06,390 --> 00:47:09,120
Så säger vi är på o.

631
00:47:09,120 --> 00:47:19,310
Vi märker att nästa tecken, i-index för klartext, är ett nummer, till exempel.

632
00:47:19,310 --> 00:47:31,630
Då vi överför inte j, index för vår sökord, tills vi når en annan bokstav.

633
00:47:31,630 --> 00:47:36,230
Återigen, vill du också se till att du wraparound till början av sökordet

634
00:47:36,230 --> 00:47:37,770
när du är i slutet av den.

635
00:47:37,770 --> 00:47:42,030
Om du ser här vi på i, har nästa att vara o.

636
00:47:42,030 --> 00:47:47,690
Så du vill hitta något sätt att kunna wraparound till början av sökordet

637
00:47:47,690 --> 00:47:49,470
varje gång du når slutet.

638
00:47:49,470 --> 00:47:55,040
Och så igen, vilken typ av operatör är användbar i detta fall för att slå runt?

639
00:47:56,630 --> 00:47:59,840
Liksom i räkningen av exempel.

640
00:47:59,840 --> 00:48:03,710
[Elev] Den procenttecken. >> Ja, procenttecken, vilket är modulo.

641
00:48:03,710 --> 00:48:11,250
Så modulo kommer väl till hands här när du vill avsluta över index i ohai.

642
00:48:11,250 --> 00:48:17,700
Och bara en snabb ledtråd: Försök att tänka på omslag över sökordet lite som räknar ut,

643
00:48:17,700 --> 00:48:23,590
där om det finns 3 grupper, den 4: e person,

644
00:48:23,590 --> 00:48:30,610
deras antal att de sade var 4 mod 3, vilket var 1.

645
00:48:30,610 --> 00:48:32,880
Så försök och tänka på det sättet.

646
00:48:34,770 --> 00:48:42,740
Som du såg i formeln, där du har CI och sedan pi men då KJ,

647
00:48:42,740 --> 00:48:44,700
du vill vara säker på att du hålla reda på dem.

648
00:48:44,700 --> 00:48:47,580
Du behöver inte kalla det jag behöver du inte kalla det j,

649
00:48:47,580 --> 00:48:53,270
men du vill vara säker på att du håller koll på den position som du är på i din klartext

650
00:48:53,270 --> 00:48:55,790
liksom den position som du är på i ditt sökord

651
00:48:55,790 --> 00:48:59,840
eftersom dessa inte nödvändigtvis kommer att vara samma.

652
00:48:59,840 --> 00:49:06,400
Inte bara sökordet - det kan vara en helt annan längd än din klartext.

653
00:49:06,400 --> 00:49:09,140
Också, din klartext, det finns siffror och tecken,

654
00:49:09,140 --> 00:49:14,450
så det kommer inte att perfekt matcha upp tillsammans. Ja.

655
00:49:14,450 --> 00:49:19,280
[Eleven] Finns det en funktion för att ändra skiftläge?

656
00:49:19,280 --> 00:49:24,530
Kan du ändra en till kapital A? >> Ja, det definitivt är.

657
00:49:24,530 --> 00:49:27,890
Du kan kolla in - jag tror det är toupper, alla 1 ord.

658
00:49:30,650 --> 00:49:36,310
Men när du försöker chiffrera saker och bevara texten,

659
00:49:36,310 --> 00:49:39,350
Det är bäst i grunden att ha separata fall.

660
00:49:39,350 --> 00:49:42,040
Om det är ett versalt, då du vill flytta genom denna

661
00:49:42,040 --> 00:49:46,460
eftersom din formel, när man ser tillbaka på hur vi ska typ av go

662
00:49:46,460 --> 00:49:50,900
omväxlande mellan ASCII sätt att representera siffrorna

663
00:49:50,900 --> 00:49:55,020
och den faktiska alfabetiskt index vill vi se till att

664
00:49:55,020 --> 00:50:01,850
Det kommer att bli någon form av mönster som du kommer att använda.

665
00:50:01,850 --> 00:50:04,580
En annan anmärkning på mönstret, faktiskt.

666
00:50:04,580 --> 00:50:07,250
Du kommer att definitivt att göra med siffror.

667
00:50:07,250 --> 00:50:11,280
Försök att inte använda magi tal, vilket är ett exempel på stil.

668
00:50:11,280 --> 00:50:18,470
Så säga att du vill varje gång skift något av vill -

669
00:50:18,470 --> 00:50:22,400
Okej, så tips är en annan spoiler när du kommer att flytta något

670
00:50:22,400 --> 00:50:26,310
med ett visst belopp, försök att inte representera det genom ett faktiskt antal

671
00:50:26,310 --> 00:50:32,810
utan försök och se om du kan använda ASCII-värdet, vilket slags vettigare.

672
00:50:32,810 --> 00:50:35,470
En annan anmärkning: Eftersom vi har att göra med formler,

673
00:50:35,470 --> 00:50:41,200
även om din TF kommer slags vet vad mönster du kanske använder,

674
00:50:41,200 --> 00:50:44,430
bäst till i din kommentar slags förklara logiken, liksom,

675
00:50:44,430 --> 00:50:51,880
"Jag använder detta mönster eftersom ..." och typ av förklara mönstret kortfattat i dina kommentarer.

676
00:50:54,090 --> 00:50:58,990
[Detta var genomgång 2] Om det inte finns några andra frågor, så jag ska bara stanna här lite.

677
00:50:58,990 --> 00:51:04,370
Lycka till med din pset 2: Crypto och tack för att du kom.

678
00:51:06,070 --> 00:51:08,620
[Elev] Tack. >> Tack.

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