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

2
00:00:11,980 --> 00:00:16,980
>> ROB: Ciao, mi chiamo Rob e cerchiamo di decifrare
il programma Vigenere.

3
00:00:16,980 --> 00:00:21,180
Quindi prima cosa che dobbiamo fare è rendere
che l'utente ha inserito quello che ci aspettavamo

4
00:00:21,180 --> 00:00:23,240
loro alla linea di comando.

5
00:00:23,240 --> 00:00:28,720
Quindi, se argc non è 2 significa che sia
l'utente non ha inserito la stringa di noi

6
00:00:28,720 --> 00:00:31,780
vogliono essere utilizzando come nostra crittografia
stringa, oppure

7
00:00:31,780 --> 00:00:32,890
inserito troppe cose.

8
00:00:32,890 --> 00:00:35,130
E noi non sappiamo cosa fare
con quelle altre cose.

9
00:00:35,130 --> 00:00:37,960
>> Quindi diciamo loro che cosa
dovrebbe essere entrato.

10
00:00:37,960 --> 00:00:39,300
E torniamo.

11
00:00:39,300 --> 00:00:44,570
Ora, supponendo che argc era 2, possiamo
continuare con il resto del programma.

12
00:00:44,570 --> 00:00:47,890
>> Abbiamo alias il nome di argv [1]

13
00:00:47,890 --> 00:00:49,750
nella parola chiave variabile.

14
00:00:49,750 --> 00:00:51,860
In modo che noi non dobbiamo
utilizzerà il nome argv [1]

15
00:00:51,860 --> 00:00:53,050
tutto il resto del programma.

16
00:00:53,050 --> 00:00:55,570
E forse ci dimentichiamo quello
che significa e così via.

17
00:00:55,570 --> 00:00:57,830
Parola chiave è un nome molto più bello.

18
00:00:57,830 --> 00:01:01,982
E faremo afferrare immediatamente la lunghezza
della nostra parola chiave qui.

19
00:01:01,982 --> 00:01:07,460
>> OK, ora vogliamo verificare che
la nostra parola chiave è effettivamente valido.

20
00:01:07,460 --> 00:01:11,250
La parola chiave che usiamo per criptare stringhe
dovrebbe essere solo alfabetico

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

22
00:01:12,400 --> 00:01:16,830
Se l'utente ha immesso non-alfabetico
personaggi, dovremmo dire, parola chiave

23
00:01:16,830 --> 00:01:20,170
deve contenere solo da A
Z e poi tornare.

24
00:01:20,170 --> 00:01:24,370
Quindi questo ciclo for itera su tutto
personaggi della nostra parola chiave, controllando

25
00:01:24,370 --> 00:01:31,870
che se uno non è alfabetico poi
abbiamo bisogno di stampare tale avvertimento.

26
00:01:31,870 --> 00:01:36,285
>> Ora, una volta che siamo arrivati ​​a questo punto, sappiamo
che la stringa deve essere corretta.

27
00:01:36,285 --> 00:01:38,230
La parola chiave deve essere corretta.

28
00:01:38,230 --> 00:01:40,880
E ora abbiamo bisogno di ottenere il messaggio da
l'utente che ci vogliono

29
00:01:40,880 --> 00:01:43,910
cifrare con quella frase-chiave.

30
00:01:43,910 --> 00:01:46,780
Quindi, per ottenere quel messaggio, abbiamo un
fare mentre ciclo che sta per

31
00:01:46,780 --> 00:01:52,650
continuamente ottenere una stringa dall'utente
fino a quando non entrano in una stringa valida.

32
00:01:52,650 --> 00:01:58,690
>> Proseguendo, vediamo qui questa variabile,
int nun_letters_seen.

33
00:01:58,690 --> 00:02:01,300
Vedremo perché abbiamo bisogno
che in un secondo.

34
00:02:01,300 --> 00:02:07,320
Ma questo per il ciclo sta per iterare
da i è uguale a 0 tutta la strada fino ad i

35
00:02:07,320 --> 00:02:10,940
eguali n, il che significa che stiamo scorrendo
su tutte le possibili

36
00:02:10,940 --> 00:02:13,020
personaggi del nostro messaggio.

37
00:02:13,020 --> 00:02:17,370
Perché vogliamo criptare tutti
i personaggi del nostro messaggio.

38
00:02:17,370 --> 00:02:22,970
Così notiamo che facciamo se (isalphamessage [I],
perché non vogliamo per crittografare

39
00:02:22,970 --> 00:02:25,660
caratteri che non sono alfabetico.

40
00:02:25,660 --> 00:02:28,810
Se ci sono simboli, spazi,
o numeri, non lo facciamo

41
00:02:28,810 --> 00:02:30,730
voler cifrare quelle.

42
00:02:30,730 --> 00:02:37,220
>> Ora, supponendo che sia alfabetico,
abbiamo prima vogliamo capire cosa abbiamo

43
00:02:37,220 --> 00:02:40,890
effettivamente desidera crittografare
il messaggio utilizzando.

44
00:02:40,890 --> 00:02:42,710
Così che cosa voglio dire con questo?

45
00:02:42,710 --> 00:02:46,740
>> Supponiamo che la frase chiave
l'utente immesso era abc.

46
00:02:46,740 --> 00:02:49,070
Questo è quello che stiamo usando per crittografare.

47
00:02:49,070 --> 00:02:54,850
Ora, ingenuamente, pensiamo che significa che
vogliamo criptare il primo carattere

48
00:02:54,850 --> 00:02:59,740
del nostro messaggio da 0, da un mezzo
ruotare il personaggio da 0.

49
00:02:59,740 --> 00:03:04,395
>> Vogliamo crittografare il secondo carattere
da 1, terzo personaggio da 2,

50
00:03:04,395 --> 00:03:09,170
il quarto carattere da 0, il quinto
da 1, il sesto da 2, e così via.

51
00:03:09,170 --> 00:03:14,440
Ma ricordate, che vogliamo ignorare
spazi e simboli e numeri.

52
00:03:14,440 --> 00:03:21,520
Ciò significa che se l'utente fosse entrato
ciao mondo come il messaggio

53
00:03:21,520 --> 00:03:26,590
che vogliono cifrare, poi
vogliamo criptare l'h da 0

54
00:03:26,590 --> 00:03:32,680
corrispondente a, l'indirizzo di 1, la
l da 2, l da 0, l'O da 1.

55
00:03:32,680 --> 00:03:41,050
Vogliamo ignorare lo spazio, criptato
il w da 2, l'O da 0, 1, 2, 0.

56
00:03:41,050 --> 00:03:45,250
Quindi notare, se non avessimo saltato il
spazio, quindi ci sarebbe criptato

57
00:03:45,250 --> 00:03:51,240
il w da 0 e si è conclusa con
la stringa non corretta.

58
00:03:51,240 --> 00:03:57,470
>> OK, questo è quello che ci serve la variabile
num_letters_seen per.

59
00:03:57,470 --> 00:04:04,450
Se stavamo andando a crittografare utilizzando
questo metodo, che non salti

60
00:04:04,450 --> 00:04:09,860
simboli, spazi e numeri, allora
potessi utilizzare la variabile i come quello

61
00:04:09,860 --> 00:04:12,540
all'indice nella nostra frase chiave con.

62
00:04:12,540 --> 00:04:17,620
Dobbiamo usare num_letters_seen per mantenere
traccia del luogo effettivo nella

63
00:04:17,620 --> 00:04:21,146
frase-chiave che vogliamo indice.

64
00:04:21,146 --> 00:04:32,240
Ecco, se la parola chiave abbiamo, se
num_letter_seen keyword_length mod, così

65
00:04:32,240 --> 00:04:34,570
perché abbiamo bisogno di mod
per lunghezza parola chiave?

66
00:04:34,570 --> 00:04:36,630
>> Beh, ciao mondo era un buon esempio.

67
00:04:36,630 --> 00:04:42,310
Se la parola chiave è stata abc, allora abbiamo bisogno
per crittografare continuamente da un allora b

68
00:04:42,310 --> 00:04:45,740
poi c, poi avvolgere di nuovo intorno,
a, b, c, a, b, c.

69
00:04:45,740 --> 00:04:50,110
Quindi abbiamo bisogno di mod per lunghezza parola chiave
per avvolgere indietro intorno.

70
00:04:50,110 --> 00:04:57,280
>> Quindi, se si tratta di una lettera maiuscola,
poi vogliamo criptare dal

71
00:04:57,280 --> 00:05:01,450
posizione di tale lettera dell'alfabeto,
che si ottiene semplicemente

72
00:05:01,450 --> 00:05:06,730
sottraendo capitali in A. E
analogamente, per le lettere minuscole, abbiamo

73
00:05:06,730 --> 00:05:13,000
può ottenere la chiave che vogliamo da
sottraendo fuori minuscola.

74
00:05:13,000 --> 00:05:16,910
Quindi, indipendentemente dal fatto che la lettera
nella frase chiave era un capitale o

75
00:05:16,910 --> 00:05:21,640
lettera minuscola, stiamo andando a
crittografare dello stesso importo.

76
00:05:21,640 --> 00:05:28,680
>> Ora che abbiamo la nostra chiave, che vediamo qui,
che se il messaggio i è un maiuscolo

77
00:05:28,680 --> 00:05:32,660
carattere, quindi vogliamo calcolare l'
posizione in alfabeto di tale

78
00:05:32,660 --> 00:05:39,460
carattere, aggiungere la chiave ad esso, avvolgere indietro
intorno in modo che se siamo andati oltre una

79
00:05:39,460 --> 00:05:43,170
z torniamo a, b, c, e così via.

80
00:05:43,170 --> 00:05:49,070
Poi, finalmente, aggiungere di nuovo sul capitale A. Quindi
ci spostiamo di nuovo nel [? Ascii?]

81
00:05:49,070 --> 00:05:52,010
gamma di questi caratteri invece del
posizione numerica in alfabeto

82
00:05:52,010 --> 00:05:53,540
di questi personaggi.

83
00:05:53,540 --> 00:05:56,610
>> E facciamo la stessa cosa per
caratteri minuscoli.

84
00:05:56,610 --> 00:06:00,070
Tranne che vogliamo sottrarre minuscolo
una e inserirlo nuovamente nella

85
00:06:00,070 --> 00:06:02,900
fine, minuscolo a.

86
00:06:02,900 --> 00:06:08,120
Si noti che num_letter_seen è solo
incrementato se il messaggio mi è stato

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

88
00:06:09,640 --> 00:06:15,790
Questo è il modo saltiamo spazi, simboli e
numeri nella nostra frase-chiave, dal momento che

89
00:06:15,790 --> 00:06:20,520
num_letter_seen è quello che stiamo usando
all'indice nella nostra parola chiave.

90
00:06:20,520 --> 00:06:24,540
>> Infine, alla fine, ora che messaggio
i è stato criptato, abbiamo

91
00:06:24,540 --> 00:06:26,280
stampare fuori i messaggi.

92
00:06:26,280 --> 00:06:27,890
E questo è tutto.

93
00:06:27,890 --> 00:06:28,670
Il mio nome è Rob.

94
00:06:28,670 --> 00:06:31,020
E questo è Vigenere.

95
00:06:31,020 --> 00:06:32,850
>> [GIOCO MUSICA]

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