1
00:00:00,000 --> 00:00:11,980

2
00:00:11,980 --> 00:00:16,980
>> ROB: Hei, jeg er Rob, og la oss dechiffrere
den Vigenère programmet.

3
00:00:16,980 --> 00:00:21,180
Så det første vi må gjøre er å lage
at brukeren angitt hva vi forventet

4
00:00:21,180 --> 00:00:23,240
dem til på kommandolinjen.

5
00:00:23,240 --> 00:00:28,720
Så hvis argc er ikke to som betyr enten
brukeren har ikke skrevet inn strengen vi

6
00:00:28,720 --> 00:00:31,780
ønsker å bruke som vår kryptering
strengen, eller de

7
00:00:31,780 --> 00:00:32,890
tastet for mange ting.

8
00:00:32,890 --> 00:00:35,130
Og vi vet ikke hva jeg skal gjøre
med de andre tingene.

9
00:00:35,130 --> 00:00:37,960
>> Så vi fortelle dem hva de
skulle ha inngått.

10
00:00:37,960 --> 00:00:39,300
Og vi kommer tilbake.

11
00:00:39,300 --> 00:00:44,570
Nå, forutsatt at argc var to, vi kan
fortsette med resten av programmet.

12
00:00:44,570 --> 00:00:47,890
>> Vi alias navnet argv [1]

13
00:00:47,890 --> 00:00:49,750
inn i variabelen søkeord.

14
00:00:49,750 --> 00:00:51,860
Slik at vi ikke trenger å
bruke navnet argv [1]

15
00:00:51,860 --> 00:00:53,050
gjennom resten av programmet.

16
00:00:53,050 --> 00:00:55,570
Og kanskje vi skal glemme hva
det betyr, og så videre.

17
00:00:55,570 --> 00:00:57,830
Keyword er et mye bedre navn.

18
00:00:57,830 --> 00:01:01,982
Og vi vil umiddelbart ta tak i lengden
av vår nøkkelord her.

19
00:01:01,982 --> 00:01:07,460
>> OK, så nå ønsker vi å kontrollere at
vår søkeordet er faktisk gyldig.

20
00:01:07,460 --> 00:01:11,250
Nøkkelordet vi bruker for å kryptere strenger
bør bare være alfabetisk

21
00:01:11,250 --> 00:01:12,400
tegn.

22
00:01:12,400 --> 00:01:16,830
Hvis brukeren inngått ikke-alfabetisk
tegn, skal vi si, søkeord

23
00:01:16,830 --> 00:01:20,170
må bare inneholde A til
Z og deretter tilbake.

24
00:01:20,170 --> 00:01:24,370
Så dette for løkke gjentar over alt
tegnene i vår søkeord, sjekker

25
00:01:24,370 --> 00:01:31,870
at hvis man ikke er alfabetisk da
vi trenger å skrive ut den advarselen.

26
00:01:31,870 --> 00:01:36,285
>> Nå, når vi kommer til dette punktet, vi vet
at strengen må være riktig.

27
00:01:36,285 --> 00:01:38,230
Nøkkelordet må være riktig.

28
00:01:38,230 --> 00:01:40,880
Og nå må vi få beskjed fra
brukeren om at de vil ha oss til

29
00:01:40,880 --> 00:01:43,910
kryptere med at nøkkelen setning.

30
00:01:43,910 --> 00:01:46,780
Så for å få den meldingen, har vi en
gjøre mens loop som kommer til å

31
00:01:46,780 --> 00:01:52,650
stadig får en streng fra brukeren
før de kommer inn en gyldig streng.

32
00:01:52,650 --> 00:01:58,690
>> Fortsetter, ser vi her denne variabelen,
int nun_letters_seen.

33
00:01:58,690 --> 00:02:01,300
Vi får se hvorfor vi trenger
at det i et andre.

34
00:02:01,300 --> 00:02:07,320
Men dette for loop kommer til å reagere
fra i er lik 0 og helt opp til i

35
00:02:07,320 --> 00:02:10,940
lik n, noe som betyr at vi gjentar
over alt mulig

36
00:02:10,940 --> 00:02:13,020
tegn i vårt budskap.

37
00:02:13,020 --> 00:02:17,370
Fordi vi ønsker å kryptere alle
tegnene i vårt budskap.

38
00:02:17,370 --> 00:02:22,970
Så merker vi gjøre hvis (isalphamessage [I],
fordi vi ikke ønsker å kryptere

39
00:02:22,970 --> 00:02:25,660
tegn som ikke er alfabetisk.

40
00:02:25,660 --> 00:02:28,810
Hvis det er symboler, mellomrom,
eller tall, gjør vi ikke

41
00:02:28,810 --> 00:02:30,730
ønsker å kryptere dem.

42
00:02:30,730 --> 00:02:37,220
>> Nå, forutsatt at det er alfabetisk,
vi først ønsker å finne ut hva vi

43
00:02:37,220 --> 00:02:40,890
faktisk ønsker å kryptere
meldingen med.

44
00:02:40,890 --> 00:02:42,710
Så hva mener jeg med det?

45
00:02:42,710 --> 00:02:46,740
>> La oss anta at nøkkelen frasen
den som brukeren var abc.

46
00:02:46,740 --> 00:02:49,070
Det er det vi bruker til å kryptere.

47
00:02:49,070 --> 00:02:54,850
Nå, naivt, tror vi det betyr at
vi ønsker å kryptere det første tegnet

48
00:02:54,850 --> 00:02:59,740
av budskapet med 0, ettersom et middel
roterende tegnet av 0.

49
00:02:59,740 --> 00:03:04,395
>> Vi ønsker å kryptere andre tegn
ved en tredje karakter med 2,

50
00:03:04,395 --> 00:03:09,170
det fjerde tegnet av 0, den femte
med 1, den sjette med 2, og så videre.

51
00:03:09,170 --> 00:03:14,440
Men husk, at vi ønsker å hoppe over
mellomrom og symboler og tall.

52
00:03:14,440 --> 00:03:21,520
Dette betyr at hvis brukeren hadde angitt
hallo verden som meldingen

53
00:03:21,520 --> 00:03:26,590
at de ønsker å kryptere, deretter
vi ønsker å kryptere h av 0

54
00:03:26,590 --> 00:03:32,680
svarende til a, e med 1, den
l med 2, l ved 0, o etter en.

55
00:03:32,680 --> 00:03:41,050
Vi ønsker å hoppe over plassen, kryptert
w med 2, o med 0, 1, 2, 0.

56
00:03:41,050 --> 00:03:45,250
Så legger merke til, hvis vi ikke hadde hoppet over
plass, så vi ville ha kryptert

57
00:03:45,250 --> 00:03:51,240
w ved 0 og endte opp med
den feil streng.

58
00:03:51,240 --> 00:03:57,470
>> OK, dette er hva vi trenger variabelen
num_letters_seen for.

59
00:03:57,470 --> 00:04:04,450
Hvis vi var bare nødt til å kryptere hjelp
denne metoden, som ikke hoppe

60
00:04:04,450 --> 00:04:09,860
symboler, mellomrom og tall, så vi
kunne bare bruke variabelen i som hva

61
00:04:09,860 --> 00:04:12,540
å indeksere i vår nøkkelen setning med.

62
00:04:12,540 --> 00:04:17,620
Vi må bruke num_letters_seen å holde
styr på den aktuelle sted i

63
00:04:17,620 --> 00:04:21,146
nøkkelen setning som vi vil indeksere.

64
00:04:21,146 --> 00:04:32,240
Så her, hvis søkeordet vi har, hvis
num_letter_seen mod keyword_length, så

65
00:04:32,240 --> 00:04:34,570
hvorfor trenger vi å mod
etter nøkkelord lengde?

66
00:04:34,570 --> 00:04:36,630
>> Vel, hallo verden var et godt eksempel.

67
00:04:36,630 --> 00:04:42,310
Hvis søkeordet var abc, så vi trenger
å kontinuerlig kryptere av en så b

68
00:04:42,310 --> 00:04:45,740
deretter c, deretter vikle tilbake rundt,
a, b, c, a, b, c.

69
00:04:45,740 --> 00:04:50,110
Så vi trenger å mod etter nøkkelord lengde
for å vikle tilbake rundt.

70
00:04:50,110 --> 00:04:57,280
>> Så hvis dette er en stor bokstav,
så vi ønsker å kryptere ved

71
00:04:57,280 --> 00:05:01,450
stilling av den bokstaven i alfabetet,
som vi får ved bare

72
00:05:01,450 --> 00:05:06,730
trekke ut kapital A. Og
Tilsvarende for små bokstaver, vi

73
00:05:06,730 --> 00:05:13,000
kan få nøkkel som vi ønsker ved
trekke ut små bokstaver en.

74
00:05:13,000 --> 00:05:16,910
Så uansett om bokstaven
i nøkkelen setning var en kapital eller

75
00:05:16,910 --> 00:05:21,640
liten bokstav, skal vi
kryptere med samme beløp.

76
00:05:21,640 --> 00:05:28,680
>> Nå som vi har våre viktigste, ser vi her,
at hvis meldingen jeg er en stor bokstav

77
00:05:28,680 --> 00:05:32,660
karakter, så vi ønsker å beregne
posisjonen i alfabetet til den

78
00:05:32,660 --> 00:05:39,460
karakter, legge vår nøkkel til det, brytes tilbake
rundt slik at hvis vi gikk forbi en

79
00:05:39,460 --> 00:05:43,170
z vi går tilbake til a, b, c, og så videre.

80
00:05:43,170 --> 00:05:49,070
Så, endelig, legge tilbake på kapital A. Så
vi skifte tilbake i [? Ascii?]

81
00:05:49,070 --> 00:05:52,010
utvalg av disse tegn i stedet for
numeriske posisjon i alfabetet

82
00:05:52,010 --> 00:05:53,540
av disse tegnene.

83
00:05:53,540 --> 00:05:56,610
>> Og vi gjør det samme for
små bokstaver.

84
00:05:56,610 --> 00:06:00,070
Bortsett fra at vi ønsker å trekke ut små bokstaver
en og legge den på igjen i

85
00:06:00,070 --> 00:06:02,900
slutten, små bokstaver en.

86
00:06:02,900 --> 00:06:08,120
Legg merke til at num_letter_seen er bare
økes hvis meldingen jeg var

87
00:06:08,120 --> 00:06:09,640
alfabetisk.

88
00:06:09,640 --> 00:06:15,790
Dette er hvordan vi hoppe mellomrom, symboler, og
Tallene i vår nøkkelen setning, siden

89
00:06:15,790 --> 00:06:20,520
num_letter_seen er hva vi bruker
til indeksen inn søkeord vår.

90
00:06:20,520 --> 00:06:24,540
>> Til slutt, til slutt, nå som melding
Jeg har blitt kryptert, vi

91
00:06:24,540 --> 00:06:26,280
skrive ut meldingen jeg.

92
00:06:26,280 --> 00:06:27,890
Og det er det.

93
00:06:27,890 --> 00:06:28,670
Mitt navn er Rob.

94
00:06:28,670 --> 00:06:31,020
Og dette er Vigenère.

95
00:06:31,020 --> 00:06:32,850
>> [Musikk spilles]

96
00:06:32,850 --> 00:06:36,651