1
00:00:00,000 --> 00:00:01,940
[Powered by Google Translate] [Passo a passo - Conjunto de Problemas 2]

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

3
00:00:05,170 --> 00:00:07,490
[Esta é CS50. CS50.TV]

4
00:00:07,490 --> 00:00:10,750
Tudo bem. Olá, todos, e bem vindo ao Passo a passo 2.

5
00:00:10,750 --> 00:00:14,330
Primeiro, quero felicitá-lo por terminar pset 1.

6
00:00:14,330 --> 00:00:18,140
Eu sei que poderia ter sido um pouco difícil para alguns de vocês,

7
00:00:18,140 --> 00:00:20,460
poderia ter sido o seu primeiro programa de computador que você escreveu,

8
00:00:20,460 --> 00:00:24,500
mas lembre-se que no final deste, quando você olhar para trás no final do semestre,

9
00:00:24,500 --> 00:00:29,820
você vai olhar para pset 1 e você vai dizer: "Ei, eu poderia ter feito isso em 5 minutos."

10
00:00:29,820 --> 00:00:35,700
Então conhece e confia que no final deste você vai definitivamente achar um pset bastante simples.

11
00:00:35,700 --> 00:00:40,640
Mas por enquanto é uma realização enorme, e parabéns pelo sendo feito.

12
00:00:40,640 --> 00:00:44,010
Agora, também, uma nota rápida antes de entrar na carne do passo a passo.

13
00:00:44,010 --> 00:00:48,340
Eu só quero fazer uma breve nota que às vezes não tem tempo suficiente

14
00:00:48,340 --> 00:00:52,500
durante as orientações que passar por cada única maneira de fazer o conjunto de problemas

15
00:00:52,500 --> 00:00:56,140
e sim talvez apenas se concentrar em um ou dois tipos de implementações,

16
00:00:56,140 --> 00:00:57,750
maneiras que você poderia fazer isso.

17
00:00:57,750 --> 00:01:01,970
Mas isso não quer dizer que você está proibido de fazê-lo de outra maneira.

18
00:01:01,970 --> 00:01:05,980
Existem muitas vezes, como com a informática, inúmeras maneiras de fazer as coisas,

19
00:01:05,980 --> 00:01:12,190
e assim definitivamente se sentir livre para usar um tipo diferente de solução do que eu possa ter apresentado.

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. Uma seção de perguntas - 1. César - 2. Vigenère]

22
00:01:17,160 --> 00:01:20,650
Tudo bem. Então conjunto de problemas 2: Crypto é uma diversão.

23
00:01:20,650 --> 00:01:24,500
Mais uma vez, com todos os pset você vai começar com uma seção de perguntas

24
00:01:24,500 --> 00:01:29,600
que vai ser realizado em suas seções com o seu companheiro de ensino atribuído.

25
00:01:29,600 --> 00:01:31,670
Nós não vamos passar por estes sobre o passo a passo,

26
00:01:31,670 --> 00:01:35,100
mas eles definitivamente vai ajudar a concluir a pset.

27
00:01:35,100 --> 00:01:38,100
Assim, a primeira parte do conjunto de problemas é César.

28
00:01:38,100 --> 00:01:43,470
E assim, em César alguém vai passar-lhe uma chave com um número inteiro,

29
00:01:43,470 --> 00:01:48,420
e você vai criptografar uma seqüência de texto que eles fornecem

30
00:01:48,420 --> 00:01:50,670
e dar-lhes de volta uma coisa criptografada.

31
00:01:50,670 --> 00:01:56,050
Se alguém assistiu Uma História de Natal, há um exemplo de que não há.

32
00:01:56,050 --> 00:01:59,090
Em seguida, a segunda parte do conjunto de problemas é Vigenère,

33
00:01:59,090 --> 00:02:01,790
que é uma técnica mais avançada de criptografia.

34
00:02:01,790 --> 00:02:05,640
E assim vamos codificar uma parte do texto,

35
00:02:05,640 --> 00:02:09,600
exceto em vez de apenas um único número inteiro, na verdade estamos indo para codificá-la

36
00:02:09,600 --> 00:02:13,340
com uma palavra-chave que o usuário irá nos fornecer.

37
00:02:16,270 --> 00:02:22,090
Ok, então a primeira ferramenta na caixa de ferramentas de hoje é realmente vai ser a atualização do aparelho.

38
00:02:22,090 --> 00:02:26,430
No fórum de discussão veríamos coisas como, "Por que não funciona?"

39
00:02:26,430 --> 00:02:28,110
"Por que não 50 Enviar trabalho?"

40
00:02:28,110 --> 00:02:31,830
e muitas vezes a solução é realmente apenas para atualizar o seu aparelho.

41
00:02:31,830 --> 00:02:36,730
E por isso, se você acabou de ser executado em uma janela de terminal em seu aparelho sudo yum-y -

42
00:02:36,730 --> 00:02:40,040
que é uma bandeira dizendo que sim, atualizar tudo - atualização,

43
00:02:40,040 --> 00:02:42,280
em seguida, o aparelho irá atualizar se necessário.

44
00:02:42,280 --> 00:02:46,960
E não faz mal se você já está na versão mais recente do aparelho.

45
00:02:46,960 --> 00:02:51,280
Em seguida, ele vai apenas dizer que não há atualizações disponíveis e você pode continuar a trabalhar junto.

46
00:02:51,280 --> 00:02:55,800
Mas isso é bom para executar até mesmo a cada vez que você abrir o aparelho

47
00:02:55,800 --> 00:02:57,140
porque ainda estamos muito -

48
00:02:57,140 --> 00:03:00,320
por vezes, se entramos em um bug - corrigi-lo no aparelho.

49
00:03:00,320 --> 00:03:03,180
Então, certifique-se que você tem a versão mais recente do aparelho

50
00:03:03,180 --> 00:03:07,710
e executar o que atualizar lá.

51
00:03:07,710 --> 00:03:14,360
Tudo bem. Então, já que estamos lidando com as letras e mudando, cifragem coisas,

52
00:03:14,360 --> 00:03:20,410
vamos realmente quer se tornar o melhor amigo de nossa tabela ASCII.

53
00:03:20,410 --> 00:03:24,350
Há os numerosos online, se você encontrar. Talvez até mesmo fazer o seu próprio.

54
00:03:24,350 --> 00:03:29,950
Basicamente, com cada letra e cada número e cada personagem

55
00:03:29,950 --> 00:03:32,210
existe um número associado a eles,

56
00:03:32,210 --> 00:03:38,670
e por isso é bom de ver seus valores ASCII ao lado da letra real.

57
00:03:38,670 --> 00:03:42,310
Isso vai ajudá-lo definitivamente no conjunto de problemas.

58
00:03:42,310 --> 00:03:45,750
Uma coisa que realmente me ajudou nesse conjunto de problemas era, na verdade, imprimi-lo,

59
00:03:45,750 --> 00:03:48,380
e como eu estava passando, eu realmente utilizá-lo,

60
00:03:48,380 --> 00:03:51,150
escrever: "Se este tem de ir para lá, então ..."

61
00:03:51,150 --> 00:03:55,270
Tipo de utilizá-lo e marcá-lo, tornar-se a melhor amiga de sua tabela ASCII.

62
00:03:57,240 --> 00:04:00,750
Então nós temos algumas outras ferramentas à nossa disposição.

63
00:04:00,750 --> 00:04:03,750
Desta vez, em vez de realmente avisar o usuário para toda a sua entrada

64
00:04:03,750 --> 00:04:05,230
vamos fazer uma combinação.

65
00:04:05,230 --> 00:04:06,880
Nós vamos levá-los para alguma entrada,

66
00:04:06,880 --> 00:04:11,350
mas nós também vamos usar apenas os argumentos de linha de comando.

67
00:04:11,350 --> 00:04:15,600
Então, quando eles correm o programa, geralmente você diz. / Olá, por exemplo,

68
00:04:15,600 --> 00:04:17,310
se o seu programa foi hello.c.

69
00:04:17,310 --> 00:04:22,500
Mas, desta vez, em vez de apenas dizer que, eles podem colocar palavras, argumentos depois.

70
00:04:22,500 --> 00:04:27,210
E assim nós vamos usar o que eles passam para nós como o seu contributo, bem como,

71
00:04:27,210 --> 00:04:31,720
tão comovente além de apenas solicitando inteiro, mas também usando argumentos de linha de comando.

72
00:04:31,720 --> 00:04:36,590
E depois vamos em matrizes e strings, que vamos estar usando muito bem.

73
00:04:41,460 --> 00:04:44,810
Aqui é apenas um exemplo de um gráfico de mini-ASCII.

74
00:04:44,810 --> 00:04:48,460
Como eu disse, cada letra corresponde a um número,

75
00:04:48,460 --> 00:04:52,510
e assim se familiarizar com isso. Ele vai vir a calhar.

76
00:04:52,510 --> 00:04:55,610
E mais tarde, quando começar a fazer alguns ASCIIMath lidar com os números -

77
00:04:55,610 --> 00:05:00,110
adicionar, subtrair-los -, então definitivamente bom para se referir a este gráfico.

78
00:05:02,860 --> 00:05:06,920
Então, aqui está um exemplo de uma cifra de César - algo que você pode ter jogado.

79
00:05:06,920 --> 00:05:11,190
É apenas uma roda. Essencialmente, existe um alfabeto exterior e, em seguida, existe um alfabeto interior.

80
00:05:11,190 --> 00:05:15,290
Então, aqui está um exemplo da cifra de César, mas com uma chave de 0.

81
00:05:15,290 --> 00:05:21,540
Essencialmente, um está alinhada com A, B está alinhado com B, todo o caminho até Z.

82
00:05:21,540 --> 00:05:26,590
Mas, então, dizer que queria uma chave de três, por exemplo.

83
00:05:26,590 --> 00:05:33,280
Então nós girar a roda interna de modo que A agora se alinha com D, etc

84
00:05:33,280 --> 00:05:35,250
E assim, este é, essencialmente, o que vamos fazer.

85
00:05:35,250 --> 00:05:38,340
Nós não temos uma roda, mas o que vamos fazer é fazer o nosso programa

86
00:05:38,340 --> 00:05:44,490
tipo de deslocar o alfabeto connosco uma certa quantidade de números.

87
00:05:44,490 --> 00:05:48,650
Então, como eu disse antes, nós vamos estar lidando com argumentos de linha de comando

88
00:05:48,650 --> 00:05:50,390
bem como a obtenção de um número inteiro.

89
00:05:50,390 --> 00:05:55,050
Assim, a maneira que um usuário irá executar o seu programa de César é por dizer. / Caesar

90
00:05:55,050 --> 00:05:58,090
e, em seguida, digitar um número depois disso.

91
00:05:58,090 --> 00:06:01,130
E esse número representa a chave, a mudança,

92
00:06:01,130 --> 00:06:06,740
quantas vezes você vai estar girando a roda interior de sua cifra de César.

93
00:06:06,740 --> 00:06:08,390
E assim que você vê aqui um exemplo.

94
00:06:08,390 --> 00:06:14,550
Se entramos as letras de A a L em nossa cifra de César,

95
00:06:14,550 --> 00:06:19,520
então, seria a entrada D a O, porque é cada letra deslocou mais de 3 vezes,

96
00:06:19,520 --> 00:06:22,080
assim como o exemplo da roda que eu mostrei.

97
00:06:22,080 --> 00:06:25,300
Então, se você entrou, por exemplo, esta é CS50!

98
00:06:25,300 --> 00:06:27,960
então seria também mover todas as letras.

99
00:06:27,960 --> 00:06:31,040
E isso é uma coisa importante, tanto César e Vigenère

100
00:06:31,040 --> 00:06:34,890
é que nós vamos desconsiderar quaisquer cartas não-.

101
00:06:34,890 --> 00:06:39,160
Então, todos os espaços, personagens, etc, números, vamos mantê-los o mesmo.

102
00:06:39,160 --> 00:06:42,920
Só vamos mudar as letras neste caso.

103
00:06:42,920 --> 00:06:45,870
Então, como você vê na roda, só temos as letras disponíveis para nós,

104
00:06:45,870 --> 00:06:50,150
por isso só quero mudar as letras e criptografar as letras.

105
00:06:51,370 --> 00:06:56,720
Portanto, a primeira coisa a fazer, você viu que o uso para César em conjunto de problemas 2

106
00:06:56,720 --> 00:07:05,280
é executar César e insira um número quando você executá-lo no terminal.

107
00:07:05,280 --> 00:07:10,940
Então o que precisamos fazer é de alguma forma obter essa chave e acessá-lo.

108
00:07:10,940 --> 00:07:14,730
E assim que nós queremos de alguma forma ver que vai ser o argumento segunda linha de comando.

109
00:07:14,730 --> 00:07:20,950
O primeiro vai ser. / César, eo próximo vai ser o número chave.

110
00:07:22,190 --> 00:07:29,200
Então, antes que nós tivemos int (void) principal para iniciar nossos programas de C.

111
00:07:29,200 --> 00:07:31,790
Estamos indo para descascar uma camada um pouco

112
00:07:31,790 --> 00:07:34,720
e realmente ver que em vez de passar no vazio a nossa função principal

113
00:07:34,720 --> 00:07:37,920
na verdade estamos lidando com dois parâmetros.

114
00:07:37,920 --> 00:07:44,070
Nós temos um int argc chamado e depois um conjunto de cordas chamado argv.

115
00:07:44,070 --> 00:07:46,030
Então argc é um inteiro,

116
00:07:46,030 --> 00:07:49,640
e representa o número de argumentos passados ​​para seu programa.

117
00:07:49,640 --> 00:07:53,590
E então argv é na verdade a lista de argumentos passados.

118
00:07:53,590 --> 00:08:00,820
Todos os argumentos são strings, e assim argv representa uma matriz, uma lista de strings.

119
00:08:01,830 --> 00:08:03,990
Vamos falar sobre matrizes um pouco.

120
00:08:03,990 --> 00:08:05,940
Matrizes são essencialmente uma nova estrutura de dados.

121
00:08:05,940 --> 00:08:09,660
Temos ints, temos dobra, temos cordas, e agora temos matrizes.

122
00:08:09,660 --> 00:08:13,820
Matrizes são estruturas de dados que pode conter vários valores do mesmo tipo,

123
00:08:13,820 --> 00:08:18,320
Então, basicamente, uma lista de tudo o tipo que você quiser.

124
00:08:18,320 --> 00:08:24,400
Essencialmente, se você queria uma lista de inteiros, tudo em uma variável,

125
00:08:24,400 --> 00:08:29,090
então você deve criar uma nova variável, que foi de matriz tipo int.

126
00:08:29,090 --> 00:08:34,450
Então matrizes são com índice zero, o que significa que o primeiro elemento da matriz é no índice 0.

127
00:08:34,450 --> 00:08:41,799
Se a matriz é de comprimento 4, como neste exemplo, então o último elemento seria no índice 3,

128
00:08:41,799 --> 00:08:44,810
o qual é 4 - 1.

129
00:08:45,940 --> 00:08:48,420
Portanto, para criar matriz, você faria algo assim.

130
00:08:48,420 --> 00:08:51,440
Digamos que você queria uma matriz dupla.

131
00:08:51,440 --> 00:08:56,520
Isso vale para qualquer tipo de tipo de dados, no entanto.

132
00:08:56,520 --> 00:09:00,210
Então diga que você quer um conjunto duplo. Digamos que você queira chamá-lo de caixa de correio.

133
00:09:00,210 --> 00:09:04,760
Assim como você inicializar qualquer outro casal,

134
00:09:04,760 --> 00:09:09,760
você diria casal e em seguida o nome, mas desta vez vamos colocar os colchetes,

135
00:09:09,760 --> 00:09:13,570
e, em seguida, o número haverá o comprimento da matriz.

136
00:09:13,570 --> 00:09:16,840
Note-se que nas matrizes que não pode já modificar o comprimento,

137
00:09:16,840 --> 00:09:21,230
assim você sempre tem de definir e escolher quantas caixas,

138
00:09:21,230 --> 00:09:25,440
quantos valores a matriz vai realizar.

139
00:09:25,440 --> 00:09:31,820
Assim, para definir valores diferentes em sua matriz, você vai usar essa sintaxe seguinte,

140
00:09:31,820 --> 00:09:33,200
como você pode ver no slide.

141
00:09:33,200 --> 00:09:37,620
Você tem 0 índice de caixa será definido para 1,2,

142
00:09:37,620 --> 00:09:42,180
caixa de correio índice de 1 set a 2.4, etc

143
00:09:42,180 --> 00:09:47,910
Portanto, agora que nós revimos matrizes um pouco, vamos voltar para argc e argv.

144
00:09:47,910 --> 00:09:52,220
Sabemos que argv é agora uma matriz de strings.

145
00:09:52,220 --> 00:09:55,080
Assim, quando um usuário passa - dizem que está executando um programa -

146
00:09:55,080 --> 00:09:58,740
eles dizem. / Olá David Malan,

147
00:09:58,740 --> 00:10:05,160
o que o programa vai fazer por você já é, na verdade, vir para cima com o argc e argv são.

148
00:10:05,160 --> 00:10:07,620
Assim você não precisa se preocupar com isso.

149
00:10:07,620 --> 00:10:14,370
Argc, neste caso, seria de 3 porque vê três palavras distintas separadas por espaços.

150
00:10:14,370 --> 00:10:18,850
E então a matriz, neste caso, o primeiro índice seria. / Olá,

151
00:10:18,850 --> 00:10:21,770
a próxima Davi, o Malan próximo.

152
00:10:21,770 --> 00:10:25,640
Alguém vê imediatamente que a relação entre argv,

153
00:10:25,640 --> 00:10:28,990
 a matriz, e argc é?

154
00:10:32,820 --> 00:10:38,090
Sim. Nós vamos entrar que em um exemplo de args.c.

155
00:10:38,090 --> 00:10:42,880
Vamos ver se conseguimos tirar proveito da relação entre o 2.

156
00:10:42,880 --> 00:10:46,550
Aqui você pode achar que no aparelho o aplicativo padrão

157
00:10:46,550 --> 00:10:49,450
para abrir arquivos. C às vezes é Emacs.

158
00:10:49,450 --> 00:10:54,660
Mas queremos lidar com gedit, então o que você pode fazer é que você pode clique direito sobre o arquivo C,

159
00:10:54,660 --> 00:11:04,580
vá para Propriedades, Abrir com e, em seguida, escolha gedit, definido como padrão,

160
00:11:04,580 --> 00:11:13,020
e agora o programa deve abrir no gedit em vez de Emacs.

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

162
00:11:17,120 --> 00:11:25,520
Então aqui eu tenho um programa que eu quero imprimir cada argumento de linha de comando.

163
00:11:25,520 --> 00:11:32,050
Então o que o usuário insere, quero essencialmente devolvê-lo de volta para eles em uma nova linha.

164
00:11:32,050 --> 00:11:36,710
Então, o que é uma estrutura que podemos usar para iterar sobre algo -

165
00:11:36,710 --> 00:11:40,380
algo que você provavelmente usado em seu 1 pset?

166
00:11:40,380 --> 00:11:45,840
Se você quer passar por um determinado número de coisas? >> [Aluno] Para loop.

167
00:11:45,840 --> 00:11:48,910
Para loop. Exatamente. Então, vamos começar com o loop for.

168
00:11:48,910 --> 00:11:56,900
Temos para int i = 0. Vamos começar com uma variável de inicialização padrão.

169
00:11:56,900 --> 00:12:02,370
Eu vou deixar a condição de um conjunto e, em seguida, dizer que eu + +, vai fazer as coisas lá.

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

171
00:12:04,090 --> 00:12:11,590
Então, pensando de volta para argv, argv, se a lista de argumentos passados ​​para o programa

172
00:12:11,590 --> 00:12:15,380
e argc é o número de argumentos no programa,

173
00:12:15,380 --> 00:12:21,280
em seguida, o que significa que argc é essencialmente do comprimento da argv, direita,

174
00:12:21,280 --> 00:12:28,970
porque não vão ser tantos argumentos como o valor de argc.

175
00:12:28,970 --> 00:12:35,910
Portanto, se queremos iterar sobre cada elemento em argv,

176
00:12:35,910 --> 00:12:43,290
vamos querer cada vez acessar a variável em argv no índice fornecido.

177
00:12:43,290 --> 00:12:49,060
Que pode ser representado com isso, certo?

178
00:12:49,060 --> 00:12:53,430
Esta variável representa aqui a seqüência particular neste caso

179
00:12:53,430 --> 00:12:57,030
porque é uma matriz de cadeia - a string particular naquele determinado índice.

180
00:12:57,030 --> 00:13:00,690
O que nós queremos fazer, neste caso, queremos imprimi-lo, então vamos dizer que printf.

181
00:13:00,690 --> 00:13:04,680
E agora argv é uma string, por isso queremos colocar esse espaço reservado lá.

182
00:13:04,680 --> 00:13:08,430
Queremos uma nova linha apenas para torná-lo bom.

183
00:13:08,430 --> 00:13:12,530
Portanto, temos aqui um laço para. Não temos a condição ainda.

184
00:13:12,530 --> 00:13:20,020
Então eu começa em 0, e depois cada vez que vai imprimir a string dada

185
00:13:20,020 --> 00:13:22,980
em que o índice particular na matriz.

186
00:13:22,980 --> 00:13:28,410
Assim, quando queremos parar de imprimir elementos na matriz?

187
00:13:28,410 --> 00:13:35,720
Quando terminarmos, certo? Quando chegamos ao fim da matriz.

188
00:13:35,720 --> 00:13:38,870
Então, nós não queremos ultrapassar passado o comprimento da matriz,

189
00:13:38,870 --> 00:13:43,700
e já sabemos que não precisamos realmente ativamente descobrir o que o comprimento de argv é

190
00:13:43,700 --> 00:13:47,520
porque é dado a nós, eo que é isso? Argc. Exatamente.

191
00:13:47,520 --> 00:13:56,640
Então, nós queremos fazer este número argc processo de vezes.

192
00:13:56,640 --> 00:13:59,550
Eu não estou no diretório certo.

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

194
00:14:03,490 --> 00:14:08,990
Agora vamos fazer args. Sem erros, o que é ótimo.

195
00:14:08,990 --> 00:14:11,430
Então vamos correr args.

196
00:14:11,430 --> 00:14:15,130
O que é que isto vai voltar para nós? Ele só vai imprimi-lo de volta.

197
00:14:15,130 --> 00:14:18,320
"Você digitou args no programa, eu vou dá-lo de volta para você."

198
00:14:18,320 --> 00:14:23,170
Então, vamos dizer que queremos dizer args então foo bar.

199
00:14:23,170 --> 00:14:26,570
Assim, pois, imprime-lo de volta para nós. Tudo bem?

200
00:14:26,570 --> 00:14:30,790
Portanto, há um exemplo de como você pode usar argc e argv

201
00:14:30,790 --> 00:14:33,460
sabendo que argc representa o comprimento do argv.

202
00:14:33,460 --> 00:14:42,750
Certifique-se de que você não faz nunca, com matrizes de acesso de um além do comprimento da matriz

203
00:14:42,750 --> 00:14:45,140
porque C vai definitivamente gritar com você.

204
00:14:45,140 --> 00:14:47,560
Você vai ter uma coisa chamada falha de segmentação,

205
00:14:47,560 --> 00:14:52,470
que nunca é divertido, basicamente dizendo que você está tentando acessar algo

206
00:14:52,470 --> 00:14:55,000
que não existe, não pertence a você.

207
00:14:55,000 --> 00:14:59,430
Então, certifique-se, e, especialmente, com o zero-indexação, nós não queremos -

208
00:14:59,430 --> 00:15:02,390
Como por exemplo, se temos uma matriz de comprimento 4,

209
00:15:02,390 --> 00:15:07,240
que o índice de matriz 4 não existe, porque nós começamos a 0, no índice zero.

210
00:15:07,240 --> 00:15:11,730
Ele vai se tornar uma segunda natureza como loops quando começamos a 0.

211
00:15:11,730 --> 00:15:13,610
Então, basta manter isso em mente.

212
00:15:13,610 --> 00:15:22,590
Você não quero nunca acessar o índice de uma matriz que está além de seu alcance.

213
00:15:26,710 --> 00:15:32,560
Assim, podemos ver agora como podemos tipo de acesso

214
00:15:32,560 --> 00:15:35,930
os argumentos de linha de comando que são passados ​​dentro

215
00:15:35,930 --> 00:15:41,330
Mas, como você viu a corda, o argv é na verdade uma matriz de cadeia.

216
00:15:41,330 --> 00:15:45,740
Portanto, não é realmente um inteiro ainda, mas em César queremos lidar com números inteiros.

217
00:15:45,740 --> 00:15:54,430
Felizmente, existe uma função criada para nós que pode realmente converter uma string para um inteiro.

218
00:15:54,430 --> 00:15:58,710
Também aqui não estamos lidando com a entrada do usuário para onde estamos levando-os

219
00:15:58,710 --> 00:16:03,740
para a entrada de aqui para a chave, por isso não podemos realmente Reprompt e dizer:

220
00:16:03,740 --> 00:16:07,840
"Oh, me dê outro inteiro, por exemplo, se não é válido."

221
00:16:07,840 --> 00:16:10,540
Mas nós ainda precisamos verificar se há uso correto.

222
00:16:10,540 --> 00:16:13,520
Em César eles só estão autorizados a passar em um número,

223
00:16:13,520 --> 00:16:18,030
e assim que tem que funcionar. / César e então eles têm que dar-lhe um número.

224
00:16:18,030 --> 00:16:23,660
Assim argc tem que ser um número determinado.

225
00:16:23,660 --> 00:16:29,060
Qual o número que seria isso, se eles têm de passar-lhe o. / César e depois uma chave?

226
00:16:29,060 --> 00:16:32,920
O que é argc? >> [Aluno] 2. >> Dois. Exatamente.

227
00:16:32,920 --> 00:16:35,490
Então você quer ter certeza de que argc é 2.

228
00:16:35,490 --> 00:16:39,620
Caso contrário, você basicamente se recusar a executar o programa.

229
00:16:39,620 --> 00:16:43,040
Na principal é uma função que diz int main,

230
00:16:43,040 --> 00:16:47,360
então nós sempre em 0 boas práticas de retorno no final de um programa bem sucedido.

231
00:16:47,360 --> 00:16:50,840
Assim, se, por exemplo, eles dão-lhe três argumentos de linha de comando em vez de 2

232
00:16:50,840 --> 00:16:54,350
ou dar-lhe uma, por exemplo, então o que você vai fazer é você vai querer verificar para que

233
00:16:54,350 --> 00:16:59,900
e depois voltar um dizendo, não, eu não posso continuar com este programa.

234
00:16:59,900 --> 00:17:03,190
[Aluno] Não pode haver um espaço em seu texto. >> Perdoe-me?

235
00:17:03,190 --> 00:17:06,780
[Aluno] Não pode haver um espaço no texto que você está tentando criptografar.

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

237
00:17:08,480 --> 00:17:11,280
Em termos do texto que estamos tentando criptografar, que na verdade vem depois

238
00:17:11,280 --> 00:17:13,970
quando damos esse texto.

239
00:17:13,970 --> 00:17:18,260
Então, agora, nós estamos apenas aceitar como argumentos de comando do número real,

240
00:17:18,260 --> 00:17:21,579
a mudança real para a criptografia de César.

241
00:17:21,579 --> 00:17:27,569
[Aluno] Por que você precisa de 2 ao invés de apenas um argc? Há definitivamente um número.

242
00:17:27,569 --> 00:17:32,200
Direito. A razão pela qual precisamos de 2 para argc, em vez de um

243
00:17:32,200 --> 00:17:36,260
é porque quando você executar um programa e dizer. / César ou. / Olá,

244
00:17:36,260 --> 00:17:38,280
que realmente conta como um argumento de linha de comando.

245
00:17:38,280 --> 00:17:43,020
Assim, então, que já ocupa 1 e assim então nós estamos introduzindo um extra.

246
00:17:45,030 --> 00:17:49,440
Então você está introduzindo na verdade uma seqüência no argumento de linha de comando.

247
00:17:49,440 --> 00:17:52,730
O que você quer fazer, para César que querem lidar com um número inteiro,

248
00:17:52,730 --> 00:17:57,180
assim você pode usar esta função atoi.

249
00:17:57,180 --> 00:18:02,850
E, basicamente, você passá-lo em uma corda e em seguida, ele irá voltar para trás um número inteiro

250
00:18:02,850 --> 00:18:06,070
se é possível fazer essa string em um inteiro.

251
00:18:06,070 --> 00:18:10,960
Agora lembre-se quando estamos lidando com coisas printf ou GetString, assim,

252
00:18:10,960 --> 00:18:13,390
que incluem as bibliotecas que são específicas para nós.

253
00:18:13,390 --> 00:18:19,450
Assim, no início, começamos com uma marca de algo hash padrão I / O,. H, assim.

254
00:18:19,450 --> 00:18:22,430
Bem, atoi não está dentro de uma dessas bibliotecas,

255
00:18:22,430 --> 00:18:26,600
Então, o que temos que fazer é que temos de incluir a biblioteca certo para isso.

256
00:18:26,600 --> 00:18:32,720
Então, lembro de volta para Passo a passo 1 onde eu discuti a função manual.

257
00:18:32,720 --> 00:18:37,110
Te tipo homem no seu terminal e, em seguida, seguida pelo nome de uma função.

258
00:18:37,110 --> 00:18:39,720
E para que trará uma lista inteira de seu uso,

259
00:18:39,720 --> 00:18:42,890
mas também vai trazer o que biblioteca que pertence.

260
00:18:42,890 --> 00:18:47,000
Então, eu vou deixar isso para você usar a função manual com atoi

261
00:18:47,000 --> 00:18:53,360
e descobrir qual biblioteca você precisa incluir para ser capaz de usar a função atoi.

262
00:18:54,450 --> 00:18:57,670
Então, nós temos a chave e agora se trata de obter o texto simples,

263
00:18:57,670 --> 00:19:01,820
e para que, na verdade, vai ser a entrada do usuário onde você pedir.

264
00:19:01,820 --> 00:19:05,540
Lidamos com GetInt e GetFloat, e assim na mesma linha

265
00:19:05,540 --> 00:19:07,670
vamos estar lidando com GetString.

266
00:19:07,670 --> 00:19:12,440
Mas, neste caso, não precisamos de fazer qualquer WHILE ou while para verificar.

267
00:19:12,440 --> 00:19:14,480
GetString vai certamente dar-nos uma corda,

268
00:19:14,480 --> 00:19:17,630
e nós estamos indo para criptografar o que o usuário nos dá.

269
00:19:17,630 --> 00:19:23,770
Assim, você pode assumir que todas essas seqüências de usuários inseridos estão corretos.

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

271
00:19:24,670 --> 00:19:27,270
Então uma vez que você tem a chave e uma vez que você tem o texto,

272
00:19:27,270 --> 00:19:31,660
agora o que resta é que você tem que codificar o texto simples.

273
00:19:31,660 --> 00:19:36,530
Só para cobrir rapidamente sobre linguagem, o texto original é o que o usuário lhe dá,

274
00:19:36,530 --> 00:19:41,030
eo texto cifrado é o que você voltar a eles.

275
00:19:42,450 --> 00:19:45,850
Então, cordas, para poder passar por realmente letra por letra

276
00:19:45,850 --> 00:19:48,550
porque temos de mudar cada letra,

277
00:19:48,550 --> 00:19:51,390
entendemos que as seqüências, se nós tipo de descascar a camada,

278
00:19:51,390 --> 00:19:54,130
vemos que eles são apenas realmente uma lista de caracteres.

279
00:19:54,130 --> 00:19:55,930
Um vem a seguir ao outro.

280
00:19:55,930 --> 00:20:01,690
E assim podemos tratar cordas como matrizes, porque elas são matrizes de caracteres.

281
00:20:01,690 --> 00:20:05,640
Então, digamos que você tem uma seqüência chamada de texto,

282
00:20:05,640 --> 00:20:09,400
e dentro desse texto variável é armazenada Este é CS50.

283
00:20:09,400 --> 00:20:15,680
Em seguida, o texto no índice 0 seria um T maiúsculo, índice 1 seria h, etc

284
00:20:17,530 --> 00:20:23,970
E, em seguida, com matrizes, no exemplo em args.c argc,

285
00:20:23,970 --> 00:20:27,090
vimos que tínhamos para iterar sobre um array

286
00:20:27,090 --> 00:20:32,440
e por isso tivemos de repetir a partir de i = 0 até i é menor do que o comprimento.

287
00:20:32,440 --> 00:20:35,560
Então, precisamos de alguma forma de descobrir o que o comprimento da corda é nossa

288
00:20:35,560 --> 00:20:37,090
se vamos para iterar sobre ele.

289
00:20:37,090 --> 00:20:42,300
Felizmente, novamente, há uma função que para nós, embora mais tarde na CS50

290
00:20:42,300 --> 00:20:45,860
você vai certamente ser capaz de implementar e fazer a sua própria função

291
00:20:45,860 --> 00:20:48,260
que pode calcular o comprimento de uma corda.

292
00:20:48,260 --> 00:20:52,120
Mas, por enquanto, vamos usar comprimento da corda, assim strlen.

293
00:20:52,120 --> 00:21:00,440
Você passa uma corda, e então ele irá retornar um int que representa o comprimento da seqüência.

294
00:21:00,440 --> 00:21:05,840
Vejamos um exemplo de como podemos ser capazes de iterar sobre cada caractere em uma string

295
00:21:05,840 --> 00:21:08,470
e fazer algo com isso.

296
00:21:08,470 --> 00:21:13,250
O que queremos fazer é iterar cada caractere da cadeia,

297
00:21:13,250 --> 00:21:19,150
eo que nós queremos fazer é que imprimir voltar cada personagem 1 a 1

298
00:21:19,150 --> 00:21:22,060
exceto acrescentamos algo próximo a ele.

299
00:21:22,060 --> 00:21:27,020
Então, vamos começar com o loop for. Int i = 0.

300
00:21:27,020 --> 00:21:30,070
Nós vamos deixar espaço para a condição.

301
00:21:32,700 --> 00:21:36,840
Queremos repetir até chegar ao final da cadeia, certo?

302
00:21:36,840 --> 00:21:41,340
Então, o que nos dá a função de comprimento da corda?

303
00:21:41,340 --> 00:21:43,160
[Resposta do aluno inaudível]

304
00:21:43,160 --> 00:21:46,420
Esse é o comprimento dos argumentos de linha de comando.

305
00:21:46,420 --> 00:21:50,650
Mas, para uma string que queremos usar uma função que nos dá o comprimento da corda.

306
00:21:50,650 --> 00:21:53,090
Então, isso é comprimento da corda.

307
00:21:53,090 --> 00:21:57,130
E então você tem que passar em uma corda para ele.

308
00:21:57,130 --> 00:21:59,760
Ele precisa saber o que ele precisa de corda para calcular o comprimento de.

309
00:21:59,760 --> 00:22:03,160
Então, neste caso, estamos lidando com cadeia s.

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

311
00:22:05,860 --> 00:22:10,770
Então o que nós queremos fazer, vamos printf.

312
00:22:10,770 --> 00:22:14,850
Agora, queremos lidar com caracteres. Queremos imprimir cada personagem individualmente.

313
00:22:14,850 --> 00:22:22,150
Quando você quiser imprimir um float, você usaria o marcador, como f%.

314
00:22:22,150 --> 00:22:24,580
Com um int você usaria% d.

315
00:22:24,580 --> 00:22:30,890
E assim da mesma forma, com um personagem que você usar c% para dizer que eu vou estar imprimindo um caráter

316
00:22:30,890 --> 00:22:34,570
que está armazenado dentro de uma variável.

317
00:22:34,570 --> 00:22:40,840
Então nós temos isso, e vamos adicionar um período e um espaço para ele.

318
00:22:40,840 --> 00:22:45,430
Qual personagem que estamos usando?

319
00:22:45,430 --> 00:22:49,780
Nós vamos estar usando qualquer personagem que estamos no da cadeia.

320
00:22:49,780 --> 00:22:52,890
Então nós vamos estar usando algo com a corda,

321
00:22:52,890 --> 00:22:56,420
mas nós queremos estar acessando o personagem certo lá.

322
00:22:56,420 --> 00:23:02,740
Então, se uma string é apenas uma matriz, como podemos então acessar elementos de matrizes?

323
00:23:02,740 --> 00:23:06,480
Temos aquelas chaves, e então colocamos o índice lá.

324
00:23:06,480 --> 00:23:11,820
Portanto, temos colchetes. Nosso índice, neste caso, podemos usar apenas i. Exatamente.

325
00:23:15,290 --> 00:23:22,370
Então, aqui estamos dizendo que vamos estar imprimindo um caractere seguido por um ponto e um espaço,

326
00:23:22,370 --> 00:23:30,870
e que o personagem vai ser a letra om em nossa cadeia s.

327
00:23:32,920 --> 00:23:39,330
Eu só vou para salvar isso. Okay.

328
00:23:42,510 --> 00:23:46,840
Agora estou indo para executar comprimento da corda.

329
00:23:46,840 --> 00:23:53,440
Então, nós tivemos uma string chamada OMG, e agora está ainda mais realçado.

330
00:23:53,440 --> 00:23:57,870
Da mesma forma, vamos dizer que realmente deseja obter uma string do usuário.

331
00:23:57,870 --> 00:23:59,580
Como podemos fazer isso?

332
00:23:59,580 --> 00:24:01,610
Antes, como chegamos a um int?

333
00:24:01,610 --> 00:24:08,040
Dissemos GetInt, certo? Mas este não é int, então vamos GetString.

334
00:24:11,780 --> 00:24:17,770
Vamos fazer comprimento da corda. Aqui nós não entrou um aviso específico.

335
00:24:17,770 --> 00:24:19,940
Então, eu não sei.

336
00:24:19,940 --> 00:24:23,820
Eu vou colocar o meu nome aqui e então eu posso fazer uma dessas coisas

337
00:24:23,820 --> 00:24:29,600
onde eu atribuir uma palavra para cada letra ou algo assim. Cool.

338
00:24:29,600 --> 00:24:31,900
Então, isso é comprimento da corda.

339
00:24:33,000 --> 00:24:34,640
Então, estamos de volta a César.

340
00:24:34,640 --> 00:24:38,620
Nós temos algumas ferramentas sobre como nós iterar sobre uma corda,

341
00:24:38,620 --> 00:24:41,250
como podemos acessar cada elemento individual.

342
00:24:41,250 --> 00:24:44,720
Então agora podemos voltar para o programa.

343
00:24:44,720 --> 00:24:48,650
Como mencionei antes, na tabela ASCII, seu melhor amigo,

344
00:24:48,650 --> 00:24:52,300
você vai ver os números que estão associados a cada letra.

345
00:24:52,300 --> 00:24:55,900
Então aqui dizer que o nosso texto simples é que eu estou tonto!

346
00:24:55,900 --> 00:25:01,090
Em seguida, cada um destes caracteres irá ter um número e valor ASCII associado a ele,

347
00:25:01,090 --> 00:25:04,710
mesmo o apóstrofo, até mesmo o espaço, mesmo a marca de exclamação,

348
00:25:04,710 --> 00:25:06,600
assim que você vai querer manter isso em mente.

349
00:25:06,600 --> 00:25:12,360
Então, dizer que a nossa chave que o usuário incluído em seu argumento de linha de comando é 6.

350
00:25:12,360 --> 00:25:17,770
Isto significa que para a primeira letra, que é I, o qual é representado por 73,

351
00:25:17,770 --> 00:25:25,610
você querer voltar para eles o que letra é representada pelo valor ASCII de 73 + 6.

352
00:25:25,610 --> 00:25:29,020
Neste caso, que seria 79.

353
00:25:30,840 --> 00:25:35,040
Agora, queremos ir para o próximo caractere.

354
00:25:35,040 --> 00:25:40,960
Portanto, a seguinte índice 1 do plaintext seria o apóstrofo.

355
00:25:40,960 --> 00:25:46,780
Mas lembre-se nós só queremos codificar as letras.

356
00:25:46,780 --> 00:25:50,040
Então, nós queremos ter certeza de que o apóstrofo na verdade, permanece o mesmo,

357
00:25:50,040 --> 00:25:54,310
que não mudar de 39 para 45 o que é.

358
00:25:54,310 --> 00:25:57,150
Queremos mantê-lo como uma apóstrofe.

359
00:25:57,150 --> 00:26:00,780
Então, nós queremos lembrar-se de apenas codificar as letras

360
00:26:00,780 --> 00:26:04,560
porque queremos que todos os outros símbolos se mantenha inalterado em nosso programa.

361
00:26:04,560 --> 00:26:07,130
Outra coisa que queremos é preservar a capitalização.

362
00:26:07,130 --> 00:26:10,250
Então, quando você tem uma letra maiúscula, ele deve permanecer como uma maiúscula.

363
00:26:10,250 --> 00:26:12,830
Lowercases deve permanecer como minúsculas.

364
00:26:13,620 --> 00:26:19,480
Por isso, algumas funções úteis para ser capaz de lidar com letras apenas cifragem

365
00:26:19,480 --> 00:26:22,380
preservar e manter a capitalização das coisas

366
00:26:22,380 --> 00:26:25,130
é a função IsLower isalpha, isupper,.

367
00:26:25,130 --> 00:26:29,270
E estes são funções que retornam você um valor booleano.

368
00:26:29,270 --> 00:26:34,180
Basicamente, verdadeiro ou falso. É este um maiúscula? É este o alfanumérico?

369
00:26:34,180 --> 00:26:37,180
É este uma carta, essencialmente.

370
00:26:37,180 --> 00:26:41,070
Então, aqui estão três exemplos de como você deve usar essa função.

371
00:26:41,070 --> 00:26:47,060
Basicamente, você pode testar se o valor devolvido pela função é verdadeira ou falsa

372
00:26:47,060 --> 00:26:49,400
com base em que a entrada.

373
00:26:49,400 --> 00:26:54,880
Quer fazer algo não cifrar ou cifra que ou certifique-se de que é maiúscula, etc

374
00:26:54,880 --> 00:27:01,080
[Estudante] Você pode apenas explicar aqueles um pouco mais e como você usá-los? >> Sim, com certeza.

375
00:27:01,080 --> 00:27:08,470
Então, se olharmos para trás, aqui nós temos um capital I, certo?

376
00:27:08,470 --> 00:27:14,550
Então, nós sabemos que vai para Ó porque eu + 6 é O.

377
00:27:14,550 --> 00:27:18,740
Mas nós queremos ter certeza de que O que vai ser uma capital de O.

378
00:27:18,740 --> 00:27:22,940
Então, basicamente, que é uma espécie de vai mudar a nossa entrada.

379
00:27:22,940 --> 00:27:26,870
Então, se é maiúscula ou não vai tipo de alterar a forma como lidamos com ele.

380
00:27:26,870 --> 00:27:32,360
Então, se nós usamos a função isupper em que determinado índice,

381
00:27:32,360 --> 00:27:36,480
assim isupper ("I"), que retorna para nós verdade, então sabemos que é superior.

382
00:27:36,480 --> 00:27:40,360
Então com base em que, mais tarde vamos entrar em uma fórmula

383
00:27:40,360 --> 00:27:42,750
que você vai usar para mudar as coisas de César,

384
00:27:42,750 --> 00:27:46,560
Então, basicamente, não vai ser uma fórmula um pouco diferente se é maiúscula

385
00:27:46,560 --> 00:27:50,670
ao contrário de minúsculas. Faz sentido?

386
00:27:51,020 --> 00:27:52,760
Sim. Não se preocupe.

387
00:27:54,900 --> 00:27:58,990
Eu falei um pouco sobre a adição de 6 a uma carta, que não chega a fazer sentido

388
00:27:58,990 --> 00:28:05,500
exceto quando tipo de entender que esses personagens

389
00:28:05,500 --> 00:28:08,920
são uma espécie de intercambiáveis ​​com números inteiros.

390
00:28:08,920 --> 00:28:11,250
O que fazemos é que tipo de fundição uso implícito.

391
00:28:11,250 --> 00:28:18,100
Vamos para lançar um pouco mais tarde, onde você toma um valor e transformá-lo em um tipo diferente

392
00:28:18,100 --> 00:28:20,440
do que era originalmente.

393
00:28:20,440 --> 00:28:25,910
Mas com este pset vamos ser capazes de usar indistintamente tipo de caracteres

394
00:28:25,910 --> 00:28:30,880
e os correspondentes seus valores inteiros.

395
00:28:30,880 --> 00:28:35,140
Então, se você simplesmente encerrar um personagem com apenas as aspas simples,

396
00:28:35,140 --> 00:28:40,390
então você vai ser capaz de trabalhar com ele com números inteiros, tratando-o como um número inteiro.

397
00:28:40,390 --> 00:28:48,040
Assim, o capital C refere-se a 67. F minúsculas refere-se a 102.

398
00:28:48,040 --> 00:28:51,480
Novamente, se você quiser saber esses valores, olhar para a sua tabela ASCII.

399
00:28:51,480 --> 00:28:56,160
Então, vamos entrar em alguns exemplos de como você pode ser capaz de subtrair e somar,

400
00:28:56,160 --> 00:29:03,130
como você pode realmente realmente trabalhar com esses personagens, use-os alternadamente.

401
00:29:03,870 --> 00:29:11,350
I dizer que ASCIIMath vai calcular a adição de um caracter para um número inteiro

402
00:29:11,350 --> 00:29:17,590
e, em seguida, apresenta o carácter resultante, bem como o valor resultante ASCII.

403
00:29:17,590 --> 00:29:22,290
E aqui eu estou dizendo - we'll acordo com esta parte mais tarde -

404
00:29:22,290 --> 00:29:29,100
mas, basicamente, eu estou dizendo que o usuário deve dizer ASCIIMath executado juntamente com uma chave,

405
00:29:29,100 --> 00:29:30,880
e eu estou dizendo que a chave vai ser o número

406
00:29:30,880 --> 00:29:34,600
com o qual estamos indo para adicionar este personagem.

407
00:29:34,600 --> 00:29:38,560
Então aqui notar que desde que eu estou exigindo uma chave,

408
00:29:38,560 --> 00:29:40,590
desde que eu estou exigindo que eles estão me dando uma coisa,

409
00:29:40,590 --> 00:29:45,600
Eu só quero aceitar. / Asciimath e uma chave.

410
00:29:45,600 --> 00:29:49,330
Então, eu vou exigir que argc é igual a 2.

411
00:29:49,330 --> 00:29:54,360
Se não é, então eu vou retornar 1 eo programa vai sair.

412
00:29:55,070 --> 00:29:58,540
Então, eu estou dizendo que a chave não vai ser o primeiro argumento da linha de comando,

413
00:29:58,540 --> 00:30:05,080
que vai ser o segundo, e, como você vê aqui,

414
00:30:05,080 --> 00:30:11,790
Eu vou transformar isso em um inteiro.

415
00:30:15,740 --> 00:30:19,230
Então eu estou indo para definir um personagem para ser r.

416
00:30:19,230 --> 00:30:23,970
Note-se que o tipo da variável chr é realmente um número inteiro.

417
00:30:23,970 --> 00:30:30,480
O jeito que eu sou capaz de usar r como um inteiro é encerrando com estas aspas simples.

418
00:30:33,850 --> 00:30:40,560
Então, de volta à nossa declaração de printf onde temos um espaço reservado para um personagem

419
00:30:40,560 --> 00:30:43,590
e um espaço reservado para um número inteiro,

420
00:30:43,590 --> 00:30:49,450
o caracter é representado pelo chr, e o número inteiro é a chave.

421
00:30:49,450 --> 00:30:54,320
E então vamos adicionar o resultado em dois juntos.

422
00:30:54,320 --> 00:30:58,420
Então, nós estamos indo para adicionar r + o que é a chave,

423
00:30:58,420 --> 00:31:03,520
e depois vamos para imprimir o resultado disso.

424
00:31:06,210 --> 00:31:14,220
Então, vamos fazer asciimath. Cabe a data, então vamos correr asciimath.

425
00:31:14,220 --> 00:31:18,290
Ah, mas veja, ele não faz nada, porque nós realmente não dar-lhe uma chave.

426
00:31:18,290 --> 00:31:23,850
Então, quando ele só voltou uma, a nossa função principal, ele só voltou para nós.

427
00:31:23,850 --> 00:31:29,250
Então vamos passar em uma chave. Alguém me dar um número. >> [Aluno] 4.

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

429
00:31:30,920 --> 00:31:39,280
Assim, um aumento de 4 r vai dar us v, o que corresponde ao valor ASCII 118.

430
00:31:39,280 --> 00:31:43,880
Então que tipo de faz sentido que -

431
00:31:43,880 --> 00:31:51,250
Na verdade, posso te perguntar, o que você acha que o valor ASCII de r é se r + 4 é de 118?

432
00:31:53,070 --> 00:31:55,470
Então, sim, é de 114 r.

433
00:31:55,470 --> 00:32:03,010
Então, se você olhar para a tabela ASCII, então, com certeza, você vai ver que r é representado por 114.

434
00:32:03,010 --> 00:32:08,610
Portanto, agora que sabemos que podemos adicionar inteiros para caracteres, isso parece bastante simples.

435
00:32:08,610 --> 00:32:12,740
Nós apenas estamos indo para repetir uma string como vimos no exemplo anterior.

436
00:32:12,740 --> 00:32:17,170
Vamos verificar se é uma carta.

437
00:32:17,170 --> 00:32:20,420
Se for, então vamos transferi-lo por qualquer que seja a chave.

438
00:32:20,420 --> 00:32:23,650
Muito simples, exceto quando você começa a gostar deste,

439
00:32:23,650 --> 00:32:32,140
você vê que z, representado por 122, em seguida, iria dar-lhe um caráter diferente.

440
00:32:32,140 --> 00:32:37,770
Na verdade, quero ficar dentro do nosso alfabeto, certo?

441
00:32:37,770 --> 00:32:43,180
Portanto, temos de descobrir alguma maneira de tipo de envolvimento em torno.

442
00:32:43,180 --> 00:32:47,190
Quando você chegar zed e pretende aumentar em um determinado número,

443
00:32:47,190 --> 00:32:51,230
você não quer ir para além da secção alfabeto ASCII;

444
00:32:51,230 --> 00:32:54,140
você deseja dispor de volta todo o caminho para A.

445
00:32:54,140 --> 00:32:58,550
Mas tenha em mente que você ainda está preservando o caso.

446
00:32:58,550 --> 00:33:00,980
Então, sabendo que as letras não podem se tornar símbolos

447
00:33:00,980 --> 00:33:05,290
como símbolos não vão estar mudando também.

448
00:33:05,290 --> 00:33:08,170
Na última pset você definitivamente não precisa,

449
00:33:08,170 --> 00:33:14,310
mas uma opção foi implementar o seu pset ganancioso usando a função módulo.

450
00:33:14,310 --> 00:33:17,230
Mas agora nós estamos indo realmente precisa usar módulo,

451
00:33:17,230 --> 00:33:19,900
então vamos apenas passar por cima deste um pouco.

452
00:33:19,900 --> 00:33:26,920
Basicamente, quando você tem x modulo y, que lhe dá o resto de x dividido por y.

453
00:33:26,920 --> 00:33:30,930
Aqui estão alguns exemplos aqui. Nós temos a 27% 15.

454
00:33:30,930 --> 00:33:36,200
Basicamente, quando você subtrair 15 de 27 tantas vezes quanto possível, sem ficar negativo

455
00:33:36,200 --> 00:33:39,060
então você obtém 12 sobraram.

456
00:33:39,060 --> 00:33:44,650
Então, isso é tipo como no contexto de matemática, mas como podemos realmente usar este?

457
00:33:44,650 --> 00:33:47,100
Ele vai ser útil para o nosso wrapover.

458
00:33:47,100 --> 00:33:55,420
Para isso, vamos apenas dizer que eu pedi a todos que se dividem em três grupos.

459
00:33:55,420 --> 00:33:58,010
Às vezes você faz isso em grupos e algo como isso.

460
00:33:58,010 --> 00:34:01,320
Digamos que eu disse: "Ok, eu quero que todos vocês ser dividido em três."

461
00:34:01,320 --> 00:34:04,240
Como você poderia fazer isso?

462
00:34:04,240 --> 00:34:06,810
[Resposta do aluno inaudível] Sim, exatamente. Conte fora. Okay.

463
00:34:06,810 --> 00:34:10,260
Vamos realmente fazer isso. Você quer começar?

464
00:34:10,260 --> 00:34:13,810
[Estudantes contando] 1, 2, 3, 4.

465
00:34:13,810 --> 00:34:16,620
Mas lembre-se ... >> [Aluno] Oh, desculpe.

466
00:34:16,620 --> 00:34:18,730
Esse é um ponto muito bom.

467
00:34:18,730 --> 00:34:24,130
Você disse 4, mas nós realmente quero que você diga uma porque nós só queremos três grupos.

468
00:34:24,130 --> 00:34:30,159
Então, como - Não, isso é um bom exemplo, porque então como você pode dizer uma?

469
00:34:30,159 --> 00:34:33,370
Qual é a relação entre 4 e 1?

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

471
00:34:36,760 --> 00:34:41,460
Então, se você continuar, você seria 2.

472
00:34:41,460 --> 00:34:44,540
Assim, temos 1, 2, 3, 1, 2.

473
00:34:44,540 --> 00:34:49,420
Mais uma vez, você está, na verdade, a 5 ª pessoa. Como você sabe a dizer 2 em vez de 5?

474
00:34:49,420 --> 00:34:53,760
Você diz que 5 mod 3 é 2.

475
00:34:53,760 --> 00:34:59,100
Quero ver quantos grupos de 3 sobram, depois que ordem sou eu

476
00:34:59,100 --> 00:35:02,860
E então se continuou ao longo da sala inteira,

477
00:35:02,860 --> 00:35:07,760
então veríamos que estamos sempre na realidade da aplicação da função mod para nós mesmos

478
00:35:07,760 --> 00:35:09,990
que tipo de contar off.

479
00:35:09,990 --> 00:35:14,490
Isso é um tipo de exemplo mais tangível de como você pode usar modulo

480
00:35:14,490 --> 00:35:17,960
porque eu tenho certeza que a maioria de nós provavelmente já passou por esse processo

481
00:35:17,960 --> 00:35:19,630
onde tivemos que contar fora.

482
00:35:19,630 --> 00:35:21,840
Qualquer dúvida sobre modulo?

483
00:35:21,840 --> 00:35:25,360
Será muito importante para compreender os conceitos desta,

484
00:35:25,360 --> 00:35:28,640
então eu quero ter certeza de que vocês entendem.

485
00:35:28,640 --> 00:35:34,660
[Aluno] Se não houver resto, não é dar-lhe o número real?

486
00:35:34,660 --> 00:35:40,430
Se um dos três primeiro deles tivesse feito isso, teria dado a eles o que eles realmente eram,

487
00:35:40,430 --> 00:35:43,310
ou ele teria dado a eles [inaudível] >> Essa é uma boa pergunta.

488
00:35:43,310 --> 00:35:48,750
Quando não há restante para o módulo - para dizer que você tem 6 mod 3 -

489
00:35:48,750 --> 00:35:52,340
que realmente lhe dá de volta 0.

490
00:35:53,670 --> 00:35:57,290
Nós vamos falar sobre isso um pouco mais tarde.

491
00:35:58,810 --> 00:36:07,720
Ah, sim, por exemplo, a pessoa 3 - 3 mod 3 é realmente 0, mas ela disse 3.

492
00:36:07,720 --> 00:36:14,900
Então, isso é como uma espécie de captura interna, por exemplo,

493
00:36:14,900 --> 00:36:17,620
como bem, se o mod é 0, então eu vou ser a 3 ª pessoa.

494
00:36:17,620 --> 00:36:22,740
Mas nós vamos entrar em tipo de como podemos querer lidar com o que 0 é tarde.

495
00:36:22,740 --> 00:36:32,750
Então agora nós de alguma forma, ter uma maneira de mapear o zed a letra certa.

496
00:36:32,750 --> 00:36:34,920
Então, agora nós passamos por estes exemplos,

497
00:36:34,920 --> 00:36:37,880
que tipo de ver como César poderia funcionar.

498
00:36:37,880 --> 00:36:42,640
Você vê os dois alfabetos e então você vê-los a mudar.

499
00:36:42,640 --> 00:36:44,430
Então, vamos tentar expressar que em termos de fórmula.

500
00:36:44,430 --> 00:36:46,940
Esta fórmula é, na verdade, dada a você na especificação,

501
00:36:46,940 --> 00:36:52,070
mas tipo vamos de olhar através do que significa cada variável.

502
00:36:52,070 --> 00:36:55,000
Nosso resultado final vai ser o texto cifrado.

503
00:36:55,000 --> 00:36:58,300
Portanto, esta diz que o caráter i da cifrado

504
00:36:58,300 --> 00:37:02,500
vai corresponder ao carácter i da de texto simples.

505
00:37:02,500 --> 00:37:08,130
Isso faz sentido porque queremos ser sempre alinhando essas coisas.

506
00:37:08,130 --> 00:37:13,480
Por isso, vai ser o personagem i da mais k cifrado, que é a nossa chave -

507
00:37:13,480 --> 00:37:17,230
que faz sentido - e então temos este mod 26.

508
00:37:17,230 --> 00:37:19,860
Lembre-se de volta quando tivemos o zed

509
00:37:19,860 --> 00:37:24,190
nós não queremos entrar no personagem, então nós queríamos para modificar isso

510
00:37:24,190 --> 00:37:26,540
e do tipo de envoltório em torno do alfabeto.

511
00:37:26,540 --> 00:37:33,430
Após zed você iria para a, b, c, d, até que você tem o número certo.

512
00:37:33,430 --> 00:37:44,690
Então, sabemos que zed, se + 6, nos daria f porque depois vem zed a, b, c, d, e, f.

513
00:37:44,690 --> 00:37:52,530
Então, vamos lembrar que sabemos com certeza que zed + 6 vai dar-nos f.

514
00:37:52,530 --> 00:38:03,530
Em valores ASCII, z é de 122 e f é 102.

515
00:38:03,530 --> 00:38:10,570
Então nós temos que encontrar uma maneira de fazer a nossa fórmula César nos dar 102

516
00:38:10,570 --> 00:38:13,590
depois de tomar em 122.

517
00:38:13,590 --> 00:38:19,550
Então, se nós simplesmente aplicamos essa fórmula, o% ('z' + 6) 26, que, na verdade, dá-lhe 24

518
00:38:19,550 --> 00:38:25,980
porque 122 + 6 é de 128; 128% 26 dá-lhe 24 restantes.

519
00:38:25,980 --> 00:38:29,140
Mas isso não significa realmente f. Isso definitivamente não é 102.

520
00:38:29,140 --> 00:38:33,590
Isso não é também a carta 6 no alfabeto.

521
00:38:33,590 --> 00:38:41,550
Então, obviamente, temos de ter alguma forma de ajustar isso um pouco.

522
00:38:42,970 --> 00:38:51,340
Em termos do alfabeto normal, sabemos que z é a letra 26 e f é a sexta.

523
00:38:51,340 --> 00:38:55,460
Mas estamos em ciência da computação, por isso estamos indo para o índice de 0.

524
00:38:55,460 --> 00:39:00,690
Então, em vez de z é o número 26, vamos dizer que é o número 25

525
00:39:00,690 --> 00:39:02,630
porque a é 0.

526
00:39:02,630 --> 00:39:04,770
Então agora vamos aplicar esta fórmula.

527
00:39:04,770 --> 00:39:11,710
Temos z representado por 25 + 6, o que lhe dá 31.

528
00:39:11,710 --> 00:39:15,790
E 31 mod 26 dá-lhe 5 como um resto.

529
00:39:15,790 --> 00:39:20,500
Isso é perfeito, porque sabemos que é a letra f 5 no alfabeto.

530
00:39:20,500 --> 00:39:26,400
Mas ainda não é f, certo? Ele ainda não é 102.

531
00:39:26,400 --> 00:39:32,730
Então para este pset, um desafio será tentar descobrir a relação

532
00:39:32,730 --> 00:39:36,910
entre converter entre estes valores ASCII e do índice alfabético.

533
00:39:36,910 --> 00:39:40,280
Essencialmente, o que você quer fazer, você quer começar com os valores ASCII,

534
00:39:40,280 --> 00:39:45,390
mas depois você quer de alguma forma, traduzir isso em um índice alfabético

535
00:39:45,390 --> 00:39:52,610
em seguida, calcular o que a carta deve ser - basicamente, o que o seu índice alfabético é

536
00:39:52,610 --> 00:39:57,660
do caráter cifra - então traduzir isso para os valores ASCII.

537
00:39:57,660 --> 00:40:04,870
Então, se você sacar sua tabela ASCII, em seguida, tentar encontrar relações entre, digamos, 102 e 5

538
00:40:04,870 --> 00:40:10,440
ou a 122 e 25.

539
00:40:12,140 --> 00:40:15,690
Nós começamos nossa chave dos argumentos de linha de comando, temos obtido o texto simples,

540
00:40:15,690 --> 00:40:17,520
temos cifrada-lo.

541
00:40:17,520 --> 00:40:19,820
Agora tudo o que resta a fazer é imprimi-lo.

542
00:40:19,820 --> 00:40:22,040
Nós poderíamos fazer isso de duas maneiras diferentes.

543
00:40:22,040 --> 00:40:24,570
O que podemos fazer é realmente imprimir à medida que avançamos.

544
00:40:24,570 --> 00:40:28,250
Como nós iterar sobre os caracteres na seqüência,

545
00:40:28,250 --> 00:40:31,660
poderíamos simplesmente imprimir certo, então quando nós calculá-lo.

546
00:40:31,660 --> 00:40:36,030
Alternativamente, você também pode armazená-lo em uma matriz e tem uma matriz de caracteres

547
00:40:36,030 --> 00:40:39,280
e no final iterar sobre essa matriz inteiro e imprimi-lo.

548
00:40:39,280 --> 00:40:40,980
Então você tem duas opções para isso.

549
00:40:40,980 --> 00:40:47,280
E lembre-se que% c vai ser o espaço reservado para a impressão de um personagem.

550
00:40:47,280 --> 00:40:50,420
Portanto, temos de César, e agora vamos passar para Vigenère,

551
00:40:50,420 --> 00:40:57,580
o que é muito semelhante ao Caesar, mas apenas um pouco mais complexo.

552
00:40:57,580 --> 00:41:03,310
Então, basicamente com Vigenère é que você vai estar passando em uma palavra-chave.

553
00:41:03,310 --> 00:41:06,510
Então, em vez de um número, você vai ter uma seqüência,

554
00:41:06,510 --> 00:41:09,200
e assim que vai agir como a palavra-chave.

555
00:41:09,200 --> 00:41:14,440
Então, como sempre, você está indo para obter um prompt para uma string do usuário

556
00:41:14,440 --> 00:41:19,050
e então cifrar-lo e depois dar-lhes a volta cifrado.

557
00:41:19,050 --> 00:41:24,650
Então, como eu disse, é muito semelhante ao César, exceto em vez de deslocar por um determinado número,

558
00:41:24,650 --> 00:41:30,620
o número é realmente vai mudar cada vez de personagem para personagem.

559
00:41:30,620 --> 00:41:34,890
Para representar o número real de mudar, ele é representado pelas letras do teclado.

560
00:41:34,890 --> 00:41:43,150
Então, se você entrar em uma mudança de um, por exemplo, em seguida, que corresponderia a uma mudança de 0.

561
00:41:43,150 --> 00:41:45,900
Então, é mais uma vez de volta ao índice alfabético.

562
00:41:45,900 --> 00:41:49,100
O que pode ser útil se você está vendo que estamos realmente lidando com valores ASCII

563
00:41:49,100 --> 00:41:51,790
bem como as cartas, assim como o índice alfabético,

564
00:41:51,790 --> 00:41:58,020
talvez encontrar ou fazer a sua própria tabela ASCII que mostra o índice alfabético de 0 a 25,

565
00:41:58,020 --> 00:42:03,750
A a Z, e os valores ASCII de modo que você pode tipo de ver a relação

566
00:42:03,750 --> 00:42:07,020
e esboçar e tentar encontrar alguns padrões.

567
00:42:07,020 --> 00:42:11,010
Da mesma forma, se você estivesse mudando na instância determinada por f -

568
00:42:11,010 --> 00:42:21,110
e este é ou f minúscula ou maiúscula -, então, que corresponderia a 5.

569
00:42:21,110 --> 00:42:24,180
Estamos bem até agora?

570
00:42:25,770 --> 00:42:30,050
A fórmula para Vigenère é um pouco diferente.

571
00:42:30,050 --> 00:42:32,960
Basicamente, você vê que é apenas como César,

572
00:42:32,960 --> 00:42:37,390
exceto em vez de apenas k temos k índice j.

573
00:42:37,390 --> 00:42:44,810
Note que não estamos usando i porque essencialmente, o comprimento da palavra-chave

574
00:42:44,810 --> 00:42:49,850
não é necessariamente o comprimento do nosso texto cifrado.

575
00:42:49,850 --> 00:42:56,130
Este será um pouco mais claro quando vemos um exemplo que eu tenho um pouco mais tarde.

576
00:42:56,130 --> 00:43:03,160
Basicamente, se você executar o programa com uma palavra-chave de ohai,

577
00:43:03,160 --> 00:43:08,560
então isso significa que a cada vez, ohai vai ser o seu turno.

578
00:43:08,560 --> 00:43:11,060
Então, dependendo de em que posição você está em sua palavra-chave,

579
00:43:11,060 --> 00:43:15,800
você vai mudar o seu caráter cifrado determinada por essa quantia.

580
00:43:15,800 --> 00:43:19,630
Novamente, assim como César, queremos ter certeza de que nós preservar a capitalização das coisas

581
00:43:19,630 --> 00:43:22,900
e nós apenas letras de encriptação, não caracteres ou espaços.

582
00:43:22,900 --> 00:43:26,330
Então, olhar para trás a César sobre as funções que você pode ter usado,

583
00:43:26,330 --> 00:43:32,570
a maneira que você decidiu como mudar as coisas, e que se aplicam ao seu programa aqui.

584
00:43:32,570 --> 00:43:35,260
Então, vamos mapear isso.

585
00:43:35,260 --> 00:43:39,680
Nós temos um texto simples que temos obtido a partir do usuário a partir de GetString

586
00:43:39,680 --> 00:43:44,090
Esta dizendo ... é CS50!

587
00:43:44,090 --> 00:43:47,090
Então nós temos uma palavra-chave de ohai.

588
00:43:47,090 --> 00:43:50,930
Os primeiros quatro caracteres são bastante simples.

589
00:43:50,930 --> 00:43:55,580
Sabemos que T vai ser deslocada por o,

590
00:43:55,580 --> 00:44:01,990
h, em seguida, vai ser desviado por h, i vai ser desviado por um.

591
00:44:01,990 --> 00:44:04,610
Aqui você vê que a representa 0,

592
00:44:04,610 --> 00:44:11,940
assim, então o valor final é na verdade apenas uma carta a mesma de antes.

593
00:44:11,940 --> 00:44:15,250
Então s é deslocado por i.

594
00:44:15,250 --> 00:44:19,370
Mas então você tem esses períodos aqui.

595
00:44:19,370 --> 00:44:25,960
Nós não queremos para codificar que, então nós não mudá-lo por nada

596
00:44:25,960 --> 00:44:31,280
e apenas imprimir o período inalterado.

597
00:44:31,280 --> 00:44:38,020
[Estudante] Eu não entendo como você sabe que este é deslocado por - Onde você - >> Oh, desculpe.

598
00:44:38,020 --> 00:44:41,620
No topo aqui você vê que o comando ohai argumento de linha aqui,

599
00:44:41,620 --> 00:44:43,740
que vai ser a palavra-chave.

600
00:44:43,740 --> 00:44:49,550
E por isso, basicamente, você está de bicicleta sobre os personagens a palavra-chave.

601
00:44:49,550 --> 00:44:52,020
[Estudante] Então o que vai estar mudando o mesmo -

602
00:44:52,020 --> 00:44:56,260
Assim, o correspondente a um determinado número no alfabeto.

603
00:44:56,260 --> 00:44:58,400
[Estudante] Direito. Mas de onde você tirou a parte de CS50?

604
00:44:58,400 --> 00:45:02,540
Oh. Isso é em GetString onde você está como, "Dê-me uma corda para codificar."

605
00:45:02,540 --> 00:45:07,510
[Aluno] Eles vão dar-lhe esse argumento para mudar por

606
00:45:07,510 --> 00:45:09,380
e então você vai pedir a sua primeira corda. Sim >>.

607
00:45:09,380 --> 00:45:12,440
Então, quando eles executar o programa, que vão incluir a palavra-chave

608
00:45:12,440 --> 00:45:14,740
em seus argumentos de linha de comando quando executá-lo.

609
00:45:14,740 --> 00:45:19,740
Então, depois de ter verificado que eles realmente lhe deu um, e não mais, não menos,

610
00:45:19,740 --> 00:45:23,750
em seguida, você vai levá-los para uma seqüência, digamos, "Dê-me uma corda".

611
00:45:23,750 --> 00:45:27,630
Então é aí que, neste caso, eles deram-lhe isto ... é CS50!

612
00:45:27,630 --> 00:45:32,090
Então você vai usar isso e usar ohai e iterar.

613
00:45:32,090 --> 00:45:38,200
Note que aqui nós pulamos criptografar os períodos,

614
00:45:38,200 --> 00:45:51,660
mas em termos de nossa posição para ohai, o próximo usamos o.

615
00:45:51,660 --> 00:45:54,990
Neste caso, é um pouco mais difícil de ver porque é 4,

616
00:45:54,990 --> 00:45:57,710
então vamos continuar um pouco. Basta ficar aqui comigo.

617
00:45:57,710 --> 00:46:02,960
Então temos i e s, os quais são, em seguida, traduzido por O e H, respectivamente.

618
00:46:02,960 --> 00:46:09,370
Então, temos um espaço, e então nós sabemos que não vamos para codificar os espaços.

619
00:46:09,370 --> 00:46:18,930
Mas note que, em vez de ir a um neste ponto aqui,

620
00:46:18,930 --> 00:46:28,330
estamos criptografando por um - Eu não sei se você pode ver que - bem aqui.

621
00:46:28,330 --> 00:46:33,710
Então não é como se você realmente predeterminado, digamos, o vai aqui, vai aqui h,

622
00:46:33,710 --> 00:46:39,200
um vai aqui, i vai aqui, o, h, a, i, o, h, a, i. Você não faz isso.

623
00:46:39,200 --> 00:46:43,760
Você só mudar a sua posição na palavra-chave

624
00:46:43,760 --> 00:46:51,020
quando você sabe que você está indo realmente para ser criptografar uma carta real.

625
00:46:51,020 --> 00:46:53,920
Será que esse tipo de faz sentido?

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

627
00:46:56,490 --> 00:46:58,500
Assim, apenas alguns lembretes.

628
00:46:58,500 --> 00:47:03,760
Você quer ter certeza de que você só avançará para a próxima letra a palavra-chave

629
00:47:03,760 --> 00:47:06,390
se o personagem em seu texto original é uma letra.

630
00:47:06,390 --> 00:47:09,120
Então, dizer que estamos no o.

631
00:47:09,120 --> 00:47:19,310
Percebemos que o próximo personagem, o índice i do texto original, é um número, por exemplo.

632
00:47:19,310 --> 00:47:31,630
Então, nós não avançamos j, o índice para a nossa palavra-chave, até chegar outra carta.

633
00:47:31,630 --> 00:47:36,230
Novamente, você também quer ter a certeza de que você envolvente para o início da palavra-chave

634
00:47:36,230 --> 00:47:37,770
quando você está no fim.

635
00:47:37,770 --> 00:47:42,030
Se você ver aqui estamos no i, o próximo tem que ser o.

636
00:47:42,030 --> 00:47:47,690
Então você quer encontrar uma forma de poder envolvente para o início da sua palavra-chave

637
00:47:47,690 --> 00:47:49,470
cada vez que você chegar ao fim.

638
00:47:49,470 --> 00:47:55,040
E assim mais uma vez, que tipo de operador é útil, neste caso para enrolar?

639
00:47:56,630 --> 00:47:59,840
Como na contagem fora exemplo.

640
00:47:59,840 --> 00:48:03,710
[Aluno] O sinal de por cento. >> Sim, o sinal de porcentagem, que é módulo.

641
00:48:03,710 --> 00:48:11,250
Então modulo vai vir a calhar aqui, quando você deseja dispor sobre o índice no seu ohai.

642
00:48:11,250 --> 00:48:17,700
E apenas uma sugestão rápida: Tente pensar de envolver mais a palavra-chave um pouco como o off contando,

643
00:48:17,700 --> 00:48:23,590
onde se há três grupos, a pessoa 4,

644
00:48:23,590 --> 00:48:30,610
seu número que eles disseram foi de 4 mod 3, que foi 1.

645
00:48:30,610 --> 00:48:32,880
Então tente pensar dessa maneira.

646
00:48:34,770 --> 00:48:42,740
Como você viu na fórmula, sempre que tiver ci e depois pi mas depois kj,

647
00:48:42,740 --> 00:48:44,700
você quer ter certeza de que você manter o controle desses.

648
00:48:44,700 --> 00:48:47,580
Você não precisa de chamá-lo de mim, você não precisa de chamá-lo j,

649
00:48:47,580 --> 00:48:53,270
mas você quer ter certeza de que você manter o controle da posição que você está em seu plaintext

650
00:48:53,270 --> 00:48:55,790
bem como a posição que você está na sua palavra-chave

651
00:48:55,790 --> 00:48:59,840
porque aqueles que não são, necessariamente, será o mesmo.

652
00:48:59,840 --> 00:49:06,400
Não só a palavra-chave - que poderia ser uma extensão completamente diferente do que o seu texto simples.

653
00:49:06,400 --> 00:49:09,140
Além disso, o texto simples, existem números e caracteres,

654
00:49:09,140 --> 00:49:14,450
de modo que não vai combinar perfeitamente juntos. Sim.

655
00:49:14,450 --> 00:49:19,280
[Aluno] Existe uma função para mudar caso?

656
00:49:19,280 --> 00:49:24,530
Você pode alterar um ao capital A? >> Sim, há definitivamente.

657
00:49:24,530 --> 00:49:27,890
Você pode conferir - eu acredito que é toupper, toda palavra 1.

658
00:49:30,650 --> 00:49:36,310
Mas quando você está tentando cifra coisas e preservar o texto,

659
00:49:36,310 --> 00:49:39,350
ele é o melhor, basicamente, a ter casos separados.

660
00:49:39,350 --> 00:49:42,040
Se for uma maiúscula, então você quer mudar por este

661
00:49:42,040 --> 00:49:46,460
porque em sua fórmula, quando você olha para trás como temos que tipo de movimento

662
00:49:46,460 --> 00:49:50,900
alternadamente entre o modo ASCII de representar os números

663
00:49:50,900 --> 00:49:55,020
eo índice alfabético real, nós queremos ter certeza de

664
00:49:55,020 --> 00:50:01,850
lá vai ser algum tipo de padrão que você vai usar.

665
00:50:01,850 --> 00:50:04,580
Outra nota sobre o padrão, na verdade.

666
00:50:04,580 --> 00:50:07,250
Você vai definitivamente ser lidar com números.

667
00:50:07,250 --> 00:50:11,280
Tente não usar números mágicos, que é um exemplo de estilo.

668
00:50:11,280 --> 00:50:18,470
Então, dizer que você quer algo a cada mudança de tempo por gosto -

669
00:50:18,470 --> 00:50:22,400
Ok, então dica, outro spoiler é quando você está indo estar mudando alguma coisa

670
00:50:22,400 --> 00:50:26,310
por uma certa quantidade, tente não representa que por um número real

671
00:50:26,310 --> 00:50:32,810
mas tente e veja se você pode usar o valor ASCII, que tipo de fazer mais sentido.

672
00:50:32,810 --> 00:50:35,470
Outra nota: Como estamos a lidar com fórmulas,

673
00:50:35,470 --> 00:50:41,200
mesmo que seu TF vai saber o que tipo de padrão que você pode estar usando,

674
00:50:41,200 --> 00:50:44,430
melhor no seu tipo de comentários de explicar a lógica, como,

675
00:50:44,430 --> 00:50:51,880
"Estou usando esse padrão porque ..." e tipo de explicar o padrão de forma sucinta em seus comentários.

676
00:50:54,090 --> 00:50:58,990
[Este foi passo a passo 2] Se não houver quaisquer outras perguntas, então eu vou ficar aqui por um pouco.

677
00:50:58,990 --> 00:51:04,370
Boa sorte com seu pset 2: Crypto e obrigado por vir.

678
00:51:06,070 --> 00:51:08,620
[Estudante] Obrigado. Graças >>.

679
00:51:09,220 --> 00:51:10,800
[Intro de mídia offline]