1
00:00:00,000 --> 00:00:01,940
[Powered by Google Translate] [チュートリアル - 問題セット2]

2
00:00:01,940 --> 00:00:04,130
[Zamylaチャン - ハーバード大学]

3
00:00:05,170 --> 00:00:07,490
[これはCS50です。 CS50.TV]

4
00:00:07,490 --> 00:00:10,750
かしこまりました。みなさん、こんにちは、そしてチュートリアル2へようこそ。

5
00:00:10,750 --> 00:00:14,330
まず、私は、pset 1の仕上げにあなたを祝福したい。

6
00:00:14,330 --> 00:00:18,140
私は、それがあなた方のうちの何人かのために少しタフだったかもしれないことを知っている

7
00:00:18,140 --> 00:00:20,460
あなたが書いた最初のコンピュータプログラムだったかもしれない、

8
00:00:20,460 --> 00:00:24,500
しかし、ちょうどあなたが学期の終わりに振り返ると、これの終わりにそれを覚えている

9
00:00:24,500 --> 00:00:29,820
あなたは、pset 1を見てみましょう、あなたは "その5分ぐらいのところにあります。ねえ、私がやったかもしれない"、と言うでしょう

10
00:00:29,820 --> 00:00:35,700
だから、これの終わりに、あなたは間違いなくpsetの1は非常に単純で見つけることを知っていると信頼しています。

11
00:00:35,700 --> 00:00:40,640
しかし今のところ、それは大偉業だし、成し遂げるおめでとうございます。

12
00:00:40,640 --> 00:00:44,010
さて、また簡単なメモ私たちは、チュートリアルの肉に入る前に。

13
00:00:44,010 --> 00:00:48,340
私はちょうど私が時々十分な時間を持っていないことに簡単なメモを作りたい

14
00:00:48,340 --> 00:00:52,500
ウォークスルー中に問題セットを行うための一つ一つの道を通過する可能性があります

15
00:00:52,500 --> 00:00:56,140
というだけで、多分実装の1または2種類に焦点を当てる

16
00:00:56,140 --> 00:00:57,750
あなたがこれを行うことができる方法。

17
00:00:57,750 --> 00:01:01,970
しかし、それはあなたがそれを別の方法をやってから禁止されていると言っているわけではない。

18
00:01:01,970 --> 00:01:05,980
物事の多くの方法は、コンピュータ科学と同じように、多くの場合があります

19
00:01:05,980 --> 00:01:12,190
ので間違いなく私が提示しているかもしれないよりソリューションのさまざまなタイプを使用して自由に感じる。

20
00:01:12,190 --> 00:01:14,520
[PSET 2：暗号 -  Zamylaチャン -  zamyla@cs50.net]

21
00:01:14,520 --> 00:01:17,160
[pset2  -  0。質問のセクション -  1。シーザー -  2。 Vigenere]

22
00:01:17,160 --> 00:01:20,650
かしこまりました。だから問題は、セット2：暗号は楽しいものです。

23
00:01:20,650 --> 00:01:24,500
繰り返しになりますが、すべてのpsetでは、質問のセクションから始めましょう

24
00:01:24,500 --> 00:01:29,600
それは自分に割り当てられたティーチング·フェローであなたのセクションで行われるだろう。

25
00:01:29,600 --> 00:01:31,670
我々は、チュートリアルを介して、これらを通過するつもりはありません

26
00:01:31,670 --> 00:01:35,100
しかし、彼らは間違いなくあなたがpsetを完了するのに役立ちます。

27
00:01:35,100 --> 00:01:38,100
だから問題セットの最初の部分はシーザーです。

28
00:01:38,100 --> 00:01:43,470
それでカエサルの誰かが、あなたに整数を使用してキーを渡します

29
00:01:43,470 --> 00:01:48,420
そしてあなたは、彼らはあなたを提供するテキストの文字列を暗号化します

30
00:01:48,420 --> 00:01:50,670
および暗号化されたものを、それらを返す。

31
00:01:50,670 --> 00:01:56,050
誰もがクリスマスの物語を見た場合、そこの例があります。

32
00:01:56,050 --> 00:01:59,090
次に、問題セットの2番目の部分は、Vigenereです

33
00:01:59,090 --> 00:02:01,790
これは、より高度な暗号化技術である。

34
00:02:01,790 --> 00:02:05,640
それで我々は、テキストの一部を暗号化しようとしている

35
00:02:05,640 --> 00:02:09,600
だけではなく、単一の整数を除いて、我々は実際にそれをエンコードしようとしている

36
00:02:09,600 --> 00:02:13,340
ユーザーが当社に提供することをキーワードと。

37
00:02:16,270 --> 00:02:22,090
さて、今日はツールボックス内の最初のツールは、実際にアプライアンスをアップデートしようとしている。

38
00:02:22,090 --> 00:02:26,430
ディスカッションボード上で我々は、のようなものを見るでしょう "なぜこの仕事をしないのですか？"

39
00:02:26,430 --> 00:02:28,110
"なぜ、50の仕事を提出しないのですか？"

40
00:02:28,110 --> 00:02:31,830
多くの場合、解決策は、単にあなたのアプライアンスを更新するために実際にある。

41
00:02:31,830 --> 00:02:36,730
そしてあなたはちょうどあなたのアプライアンスは、sudoのyum-yの端末ウィンドウで実行する場合 - 

42
00:02:36,730 --> 00:02:40,040
、アップデート - それはそうです、すべてを更新することを示すフラグです

43
00:02:40,040 --> 00:02:42,280
ことが必要な場合は、あなたのアプライアンスは更新されます。

44
00:02:42,280 --> 00:02:46,960
あなたは既にアプライアンスの最新バージョンである場合、それは悪くはない。

45
00:02:46,960 --> 00:02:51,280
それだけではありません新しいアップデートが利用可能と言うだろうし、一緒に作業を続けることができます。

46
00:02:51,280 --> 00:02:55,800
しかし、これも、あなたは、アプライアンスを起動するたびに実行しているのは良いことだ

47
00:02:55,800 --> 00:02:57,140
我々はまだまだだから - 

48
00:02:57,140 --> 00:03:00,320
アプライアンスでそれを修正する - 時には我々はバグが入ってくる場合。

49
00:03:00,320 --> 00:03:03,180
ですから、アプライアンスの最新バージョンを持っていることを確認してください

50
00:03:03,180 --> 00:03:07,710
そしてそこにアップデートすることを実行します。

51
00:03:07,710 --> 00:03:14,360
かしこまりました。だから我々は文字を扱うと変え、物事を暗号化しているので、

52
00:03:14,360 --> 00:03:20,410
我々は本当に私たちのASCIIチャートで最高の友達になるつもりだ。

53
00:03:20,410 --> 00:03:24,350
あなたが見つけた場合は、多数のものが、来店中です。多分自分で作る。

54
00:03:24,350 --> 00:03:29,950
基本的に、すべての文字、すべての数字、すべての文字で

55
00:03:29,950 --> 00:03:32,210
それらに関連付けられている番号は、そこにある

56
00:03:32,210 --> 00:03:38,670
ので、それは実際の手紙と一緒に、それらのASCII値を表示するには良いことだ。

57
00:03:38,670 --> 00:03:42,310
それは間違いなく問題セットのお手伝いを致します。

58
00:03:42,310 --> 00:03:45,750
本当にこの問題セットで助けてくれたことの一つは、実際にそれをプリントアウトすることだった

59
00:03:45,750 --> 00:03:48,380
と私は通過していたとして、私は実際にそれを引く、

60
00:03:48,380 --> 00:03:51,150
"それから、これはそこに行かなければならないなら..."を書く

61
00:03:51,150 --> 00:03:55,270
の種類は、その上に描画し、それをマークアップし、あなたのASCIIテーブルで最高の友達になる。

62
00:03:57,240 --> 00:04:00,750
その後、我々は我々の処理では、他のいくつかのツールを持っている。

63
00:04:00,750 --> 00:04:03,750
この時間の代わりに、実際に自分のすべての入力をユーザーに要求

64
00:04:03,750 --> 00:04:05,230
我々は、組み合わせをやろうとしている。

65
00:04:05,230 --> 00:04:06,880
我々は、いくつかの入力のためにそれらを要求するつもりだ

66
00:04:06,880 --> 00:04:11,350
しかし、我々はまた、単にコマンドライン引数を使用するつもりです。

67
00:04:11,350 --> 00:04:15,600
だから、彼らはプログラムを実行すると、通常、あなたが言う。/こんにちは、例えば、

68
00:04:15,600 --> 00:04:17,310
あなたのプログラムはhello.cであった場合。

69
00:04:17,310 --> 00:04:22,500
しかし、この時だけではなく、それを言って、彼らはその後の言葉は、引数を置くことができます。

70
00:04:22,500 --> 00:04:27,210
彼らは同様に彼らの入力として私たちに渡すものは何でもそして私たちは、使用するつもりです

71
00:04:27,210 --> 00:04:31,720
これだけの整数を求めるプロンプトを越えて移動するだけでなく、コマンドライン引数を使用しています。

72
00:04:31,720 --> 00:04:36,590
そして、我々は、我々は同様に多くのことを使用することがあります、配列や文字列、に行くつもりです。

73
00:04:41,460 --> 00:04:44,810
ここ1ミニASCIIチャートのちょうど例です。

74
00:04:44,810 --> 00:04:48,460
私が言ったように、すべての文字は、番号に対応します

75
00:04:48,460 --> 00:04:52,510
となるように慣れる。それは便利になるだろう。

76
00:04:52,510 --> 00:04:55,610
と後に我々は数値を扱ういくつかのASCIIMathをやって起動したときに - 

77
00:04:55,610 --> 00:05:00,110
次にこのグラフを参照するように確かに良い - それらを引き算して、追加します。

78
00:05:02,860 --> 00:05:06,920
あなたが演じてきたかもしれない何か - だからここには、シーザー暗号の例です。

79
00:05:06,920 --> 00:05:11,190
それはちょうどホイールです。本質的には、外側のアルファベットがあり、その後内側のアルファベットがあります。

80
00:05:11,190 --> 00:05:15,290
だからここには、シーザー暗号のが、0のキーを持つ例です。

81
00:05:15,290 --> 00:05:21,540
本質的に、ZにA、BがBに揃えて配置され、すべての方法と整列される

82
00:05:21,540 --> 00:05:26,590
しかし、その後、我々は、例えば、3のキーを望んでいたと言う。

83
00:05:26,590 --> 00:05:33,280
その後、我々は今、Dなどと揃うように、内側のホイールを回転するであろう

84
00:05:33,280 --> 00:05:35,250
それで、これは我々がやろうとしているものなのです。

85
00:05:35,250 --> 00:05:38,340
我々は、ホイールを持っていないが、私たちがやろうとしていることは私たちのプログラムを作っている

86
00:05:38,340 --> 00:05:44,490
数字に一定量の私達と一緒にアルファベットをずらすの一種。

87
00:05:44,490 --> 00:05:48,650
私が前に言ったように、我々は、コマンドライン引数を扱うことになるだろう

88
00:05:48,650 --> 00:05:50,390
同様に整数を得る。

89
00:05:50,390 --> 00:05:55,050
したがって、ユーザーがあなたのシーザー·プログラムを実行することの方法は言っています。/シーザー

90
00:05:55,050 --> 00:05:58,090
し、その後の番号を入力する。

91
00:05:58,090 --> 00:06:01,130
その数は、キー、シフトを表し

92
00:06:01,130 --> 00:06:06,740
何回あなたのシーザー暗号の内側のホイールを回転することになるだろう。

93
00:06:06,740 --> 00:06:08,390
そしてあなたはここでの例を参照してください。

94
00:06:08,390 --> 00:06:14,550
我々は、シーザー暗号でのLから文字を入力した場合は、

95
00:06:14,550 --> 00:06:19,520
それは、Oを介して入力Dを3回にわたってシフトすべての文字だからだろう

96
00:06:19,520 --> 00:06:22,080
ちょうど私がお見せしたことを輪の例のように。

97
00:06:22,080 --> 00:06:25,300
それでは、あなたが入力した場合、例えば、これはCS50です！

98
00:06:25,300 --> 00:06:27,960
それはまた、すべての文字を移動します。

99
00:06:27,960 --> 00:06:31,040
そして、それはカエサルとVigenereの両方で重要なことだ

100
00:06:31,040 --> 00:06:34,890
我々は、任意の非文字をスキップするつもりだということです。

101
00:06:34,890 --> 00:06:39,160
だから、スペース、文字など、数字、我々は彼らと同じ維持するつもりだ。

102
00:06:39,160 --> 00:06:42,920
我々は、この場合のみ文字をシフトしようとしている。

103
00:06:42,920 --> 00:06:45,870
あなたは車輪で見るように、我々は唯一の私達に利用できる文字を持っている、

104
00:06:45,870 --> 00:06:50,150
ので、我々は唯一の文字をシフトして、文字を暗号化したい。

105
00:06:51,370 --> 00:06:56,720
最初に行うべきことは、だから、あなたは問題でシーザーのために使用量が2に設定することを見

106
00:06:56,720 --> 00:07:05,280
あなたは、端末でそれを実行したときにシーザーを実行し、数値を入力することです。

107
00:07:05,280 --> 00:07:10,940
だから我々は何をする必要があるか何とかその鍵を取得し、それをアクセスすることです。

108
00:07:10,940 --> 00:07:14,730
そして私たちは何とかそれは2つ目のコマンドライン引数になるだろうと見てみたい。

109
00:07:14,730 --> 00:07:20,950
最初のものは、。/シーザーになるだろうし、次のいずれかのキー番号になるだろう。

110
00:07:22,190 --> 00:07:29,200
だから前に、我々は、Cプログラムを開始するにはint型のmain（void）を持っていた。

111
00:07:29,200 --> 00:07:31,790
我々は戻って皮層を少しするつもりだ

112
00:07:31,790 --> 00:07:34,720
そして実際に見て、その代わりに私たちの主な機能へのvoidを渡すの

113
00:07:34,720 --> 00:07:37,920
私たちは実際に2つのパラメータを扱っている。

114
00:07:37,920 --> 00:07:44,070
我々はargcというintを持っているし、文字列の配列は、argvと呼ばれる。

115
00:07:44,070 --> 00:07:46,030
だからargcは、整数です

116
00:07:46,030 --> 00:07:49,640
そしてそれはあなたのプログラムに渡される引数の数を表します。

117
00:07:49,640 --> 00:07:53,590
そして、argvは、実際に渡された引数のリストです。

118
00:07:53,590 --> 00:08:00,820
すべての引数は文字列であり、そうargvは文字列の配列、リストを表します。

119
00:08:01,830 --> 00:08:03,990
配列について少し話してみましょう。

120
00:08:03,990 --> 00:08:05,940
アレイは、本質的に新しいデータ構造です。

121
00:08:05,940 --> 00:08:09,660
我々は、我々は倍増している、int型を持っている我々は、文字列を持って、今私たちは、配列を持っています。

122
00:08:09,660 --> 00:08:13,820
配列は、同じ型の複数の値を保持できるデータ構造です

123
00:08:13,820 --> 00:08:18,320
ので、本質的に、あなたが好きなタイプのリスト。

124
00:08:18,320 --> 00:08:24,400
本質的に、あなたはすべて1変数に整数のリストを検索したい場合、

125
00:08:24,400 --> 00:08:29,090
次にあなたはint型の配列であった新しい変数を作成することになります。

126
00:08:29,090 --> 00:08:34,450
だから、配列は、配列の最初の要素はインデックス0にあることを意味し、0から始まるインデックスです。

127
00:08:34,450 --> 00:08:41,799
配列は、この例のように、長さ4のものである場合、あなたの最後の要素は、インデックス3にあるであろう

128
00:08:41,799 --> 00:08:44,810
1から4までは、です。

129
00:08:45,940 --> 00:08:48,420
だから、配列を作成するには、このような何かを行うだろう。

130
00:08:48,420 --> 00:08:51,440
あなたは二重配列が欲しかったと言う。

131
00:08:51,440 --> 00:08:56,520
ただし、これはデータ型の任意のタイプのために行く。

132
00:08:56,520 --> 00:09:00,210
ですから、二重配列が欲しいと言う。もしメールボックス呼び出したいと言う。

133
00:09:00,210 --> 00:09:04,760
あなたは他のダブルを初期化と同じように、

134
00:09:04,760 --> 00:09:09,760
、ダブル、名前を言うだろうが、今回は角括弧を置く我々

135
00:09:09,760 --> 00:09:13,570
その後数は、配列の長さがあるでしょう。

136
00:09:13,570 --> 00:09:16,840
配列に私たちが今までの長さを変更できないことに注意して、

137
00:09:16,840 --> 00:09:21,230
したがって、いつでも、どのように多くのボックスを定義して選択する必要があります

138
00:09:21,230 --> 00:09:25,440
どのように多くの値は、アレイは保持しようとしている。

139
00:09:25,440 --> 00:09:31,820
だからあなたの配列内の異なる値を設定するには、この次の構文を使用するつもりだ

140
00:09:31,820 --> 00:09:33,200
あなたは、スライドで見たような。

141
00:09:33,200 --> 00:09:37,620
あなたが持っているメールボックスのインデックス0は、1.2に設定されます

142
00:09:37,620 --> 00:09:42,180
2.4〜メールボックスのインデックス1セット、等

143
00:09:42,180 --> 00:09:47,910
だから今我々は、配列のビットを確認しましたので、次にargcとargvに戻りましょう。

144
00:09:47,910 --> 00:09:52,220
我々は、argvが今や文字列の配列であることを知っている。

145
00:09:52,220 --> 00:09:55,080
だからユーザが通過したときに - 彼らはプログラムを実行していると言う - 

146
00:09:55,080 --> 00:09:58,740
彼らが言うには、。/こんにちはデビッド·マラン

147
00:09:58,740 --> 00:10:05,160
あなたは既に実際にargcとargvは何か思い付くさのためのプログラムは何をするでしょう。

148
00:10:05,160 --> 00:10:07,620
だから、そのことについて心配する必要はありません。

149
00:10:07,620 --> 00:10:14,370
それは空白で区切られた3つの異なる単語を認識するので、この場合はargcは3になります。

150
00:10:14,370 --> 00:10:18,850
それで、このインスタンスの配列は、最初のインデックスは次のようになります。/こんにちは、

151
00:10:18,850 --> 00:10:21,770
次の1デビッド、次の1マラン。

152
00:10:21,770 --> 00:10:25,640
誰もが、argvの間に何の関係がすぐに見ない

153
00:10:25,640 --> 00:10:28,990
 配列、およびargcは何ですか？

154
00:10:32,820 --> 00:10:38,090
うん。我々はargs.c.の例では、その中に買ってあげる

155
00:10:38,090 --> 00:10:42,880
我々は2との関係を活用できる​​かどうか見てみましょう。

156
00:10:42,880 --> 00:10:46,550
ここでは、アプライアンスでそれを見つけるかもしれないデフォルトのアプリケーション

157
00:10:46,550 --> 00:10:49,450
cファイルを開くためには時々emacsです。

158
00:10:49,450 --> 00:10:54,660
しかし、我々はあなたが正しい、あなたのCファイルをクリックすることができているあなたは何ができるように、geditのに対処したい

159
00:10:54,660 --> 00:11:04,580
で開き、[プロパティ]に移動して、[既定に設定geditを、選択

160
00:11:04,580 --> 00:11:13,020
そして今、あなたのプログラムは、Emacsの代わりにgeditで開く必要があります。

161
00:11:14,710 --> 00:11:16,290
パーフェクト。

162
00:11:17,120 --> 00:11:25,520
だからここに私は、各コマンドライン引数を出力するプログラムを持っています。

163
00:11:25,520 --> 00:11:32,050
どんなユーザ入力だから、私は、本質的に新しいラインでそれらに戻ってそれを返すようにしたい。

164
00:11:32,050 --> 00:11:36,710
だから我々は何かを反復処理するために使用できる構造は何ですか - 

165
00:11:36,710 --> 00:11:40,380
おそらくあなたのpset 1で使用したもの？

166
00:11:40,380 --> 00:11:45,840
あなたは物事のセット数を通過したいですか？場合Forループ>> [生徒]。

167
00:11:45,840 --> 00:11:48,910
forループ。その通りです。だから、forループを始めましょう。

168
00:11:48,910 --> 00:11:56,900
我々は、int i = 0のために持っている。ただ標準の初期化変数でみましょう。

169
00:11:56,900 --> 00:12:02,370
私はセットの状態のままにして、次にi + +が、そこの事をやろうと言うつもりです。

170
00:12:02,370 --> 00:12:04,090
かしこまりました。

171
00:12:04,090 --> 00:12:11,590
だから、argvがプログラムに渡された引数のリストである場合、argvに戻って考える

172
00:12:11,590 --> 00:12:15,380
とargcは、プログラム内で引数の数です

173
00:12:15,380 --> 00:12:21,280
次に右、argcは本質的にargvの長さであることを意味し、

174
00:12:21,280 --> 00:12:28,970
argcの値と同じ数の引数があるように起こっているためです。

175
00:12:28,970 --> 00:12:35,910
だから我々は、argvの各要素を反復処理したい場合は、

176
00:12:35,910 --> 00:12:43,290
我々は与えられたインデックスのargvの変数にアクセスするたびにするつもりだ。

177
00:12:43,290 --> 00:12:49,060
それは右、これを使用して表すことができますか？

178
00:12:49,060 --> 00:12:53,430
ここでは、この変数は、このインスタンス内の特定の文字列を表します

179
00:12:53,430 --> 00:12:57,030
それは、文字列の配列だから - その指定されたインデックスにある特定の文字列。

180
00:12:57,030 --> 00:13:00,690
我々が何をしたいのか、この場合、我々はそれをプリントアウトしたいので、printfの言うてみましょう。

181
00:13:00,690 --> 00:13:04,680
そして今、argvは文字列なので、私たちはそこにそのプレースホルダを載せていきたいと思います。

182
00:13:04,680 --> 00:13:08,430
我々は、ちょうどそれが良い見えるように新しい行をしたい。

183
00:13:08,430 --> 00:13:12,530
そこでここでは、forループを持っています。我々はまだ条件を持っていない。

184
00:13:12,530 --> 00:13:20,020
ので、私はそれが与えられた文字列を印字することになっているたびに、次に0から始まり、

185
00:13:20,020 --> 00:13:22,980
配列内の特定のインデックス位置にある。

186
00:13:22,980 --> 00:13:28,410
だから我々は、配列の要素をプリントアウトするのをいつ止めるかをしたいですか？

187
00:13:28,410 --> 00:13:35,720
我々が終わったら、右か？我々は、配列の最後に到達したとき。

188
00:13:35,720 --> 00:13:38,870
だから我々は、配列の長さを超えて超えてしたくない

189
00:13:38,870 --> 00:13:43,700
そして我々はすでに我々が実際に積極的にargvの長さがどうなっているかを知る必要はありません知っている

190
00:13:43,700 --> 00:13:47,520
ので、それは私たちに与えられた、それは何だ？ ARGC。その通りです。

191
00:13:47,520 --> 00:13:56,640
だから我々は時代のこのプロセスのargc数をやってみたい。

192
00:13:56,640 --> 00:13:59,550
私は、正しいディレクトリにないんだけど。

193
00:14:02,100 --> 00:14:03,490
かしこまりました。

194
00:14:03,490 --> 00:14:08,990
今度は、argsを作ってみましょう。素晴らしいですがエラーなし。

195
00:14:08,990 --> 00:14:11,430
だから、argsを実行してみましょう。

196
00:14:11,430 --> 00:14:15,130
これは私たちに戻ります何が起こっている？それはちょうどそれを裏印字することになっている。

197
00:14:15,130 --> 00:14:18,320
"あなたがプログラムに引数を入力し、私はあなたにそれをお返しするつもりです。"

198
00:14:18,320 --> 00:14:23,170
それでは、我々は、args次にfooバーを言いたいとしましょう​​。

199
00:14:23,170 --> 00:14:26,570
だから、それは私達にそれをプリントアウトします。大丈夫か？

200
00:14:26,570 --> 00:14:30,790
ですから、argcとargvを使用する方法の例がある

201
00:14:30,790 --> 00:14:33,460
argcがargvの長さを表していることを知っている。

202
00:14:33,460 --> 00:14:42,750
あなたは配列は配列の長さを超えていずれかにアクセスして今までにないことを確認してください

203
00:14:42,750 --> 00:14:45,140
Cは間違いなくあなた怒鳴るますので。

204
00:14:45,140 --> 00:14:47,560
あなたは、セグメンテーションフォールトと呼ばれるものを買ってあげる

205
00:14:47,560 --> 00:14:52,470
これは、基本的にあなたが何かをアクセスしようとしていると言って、楽しいことはありません

206
00:14:52,470 --> 00:14:55,000
存在しない、あなたには属していません。

207
00:14:55,000 --> 00:14:59,430
だから、特にゼロインデックスを持つことを確認し、我々はしたくない - 

208
00:14:59,430 --> 00:15:02,390
私たちは、長さ4の配列を持っている場合、インスタンスの場合と同様に、

209
00:15:02,390 --> 00:15:07,240
我々はゼロインデックスで、0から始まるため、その配列のインデックス4は存在しません。

210
00:15:07,240 --> 00:15:11,730
我々は0から開始したとき、それだけでforループのように第二の天性になるでしょう。

211
00:15:11,730 --> 00:15:13,610
これだけあるということを忘れないでください。

212
00:15:13,610 --> 00:15:22,590
あなたは今まで手の届かないところの配列のインデックスにアクセスする必要はありません。

213
00:15:26,710 --> 00:15:32,560
どのように我々は、アクセスの種類ができるように、我々は今見ることができる

214
00:15:32,560 --> 00:15:35,930
渡されるコマンドライン引数

215
00:15:35,930 --> 00:15:41,330
あなたは文字列を見たけど、argvは、実際には文字列の配列です。

216
00:15:41,330 --> 00:15:45,740
だから、まだ実際には整数ではありませんが、シーザーに我々は整数に対処したい。

217
00:15:45,740 --> 00:15:54,430
幸いなことに、実際に文字列を整数に変換することができます私たちのために作成された関数があります。

218
00:15:54,430 --> 00:15:58,710
我々は彼らを促しているところも、ここで我々は、ユーザの入力を扱っていない

219
00:15:58,710 --> 00:16:03,740
キーの入力のためにここに、私たちは、実際に求めるプロンプトと言うことはできません

220
00:16:03,740 --> 00:16:07,840
"それが有効ではない場合ああ、、と言う、私に別の整数を与える。"

221
00:16:07,840 --> 00:16:10,540
しかし、我々はまだ正しい使用方法を確認する必要がない。

222
00:16:10,540 --> 00:16:13,520
シーザーでは、それらは1つだけ番号を渡すために許可され、

223
00:16:13,520 --> 00:16:18,030
そして、彼らは。/シーザーを実行する必要があり、その後、彼らはあなたの番号を与える必要があります。

224
00:16:18,030 --> 00:16:23,660
だから、argcは一定数にする必要があります。

225
00:16:23,660 --> 00:16:29,060
彼らはあなたに。/シーザーし、キーを渡す必要がある場合にどのような数字は、そのことでしょうか？

226
00:16:29,060 --> 00:16:32,920
argcは何ですか？ >> [生徒] 2。 >> 2。その通りです。

227
00:16:32,920 --> 00:16:35,490
だから、argcが2であることを確かめたいと思う。

228
00:16:35,490 --> 00:16:39,620
そうでなければ、基本的にプログラムを実行することを拒否する。

229
00:16:39,620 --> 00:16:43,040
メインでは、int型のmain関数だと言う、

230
00:16:43,040 --> 00:16:47,360
それでは、私たちは常に良い習慣リターン0で成功したプログラムの終了時。

231
00:16:47,360 --> 00:16:50,840
と言う、もしそうなら、彼らはあなたに3コマンドライン引数の代わりに2を与える

232
00:16:50,840 --> 00:16:54,350
またはあなたが何をしようとしていた後、例えば、あなたに1を与えると、あなたはそれをチェックしたいと思うです

233
00:16:54,350 --> 00:16:59,900
その後、いや、言って1を返し、私はこのプログラムを続行できません。

234
00:16:59,900 --> 00:17:03,190
[学生]あなたのテキストにスペースがあってはいけません。 >>は、なんですって？

235
00:17:03,190 --> 00:17:06,780
[学生]は、暗号化しようとしているテキスト内のスペースがあってはいけません。

236
00:17:06,780 --> 00:17:08,480
ああ！

237
00:17:08,480 --> 00:17:11,280
我々は暗号化しようとしているテキストの面では、それは実際に後で来る

238
00:17:11,280 --> 00:17:13,970
我々は、そのテキストを与えるとき。

239
00:17:13,970 --> 00:17:18,260
だから今我々は、ちょうど実際の数は、コマンド引数として受け入れておる

240
00:17:18,260 --> 00:17:21,579
シーザーの暗号化のための実際のシフト。

241
00:17:21,579 --> 00:17:27,569
[学生]わずか1 argcは対照的に、なぜあなたは2が必要なのでしょうか？ 1番号は、間違いなくあります。

242
00:17:27,569 --> 00:17:32,200
右。 1の代わりに我々はargcは、2を必要とする理由

243
00:17:32,200 --> 00:17:36,260
あなたがプログラムを実行すると言うときがあるためです。/シーザーまたは。/こんにちは、

244
00:17:36,260 --> 00:17:38,280
それは、実際にコマンドライン引数としてカウントされます。

245
00:17:38,280 --> 00:17:43,020
それでは、それはすでに1を占めているので、次に我々は余分な1を入力している。

246
00:17:45,030 --> 00:17:49,440
だから、実際にコマンドライン引数の文字列を入力している。

247
00:17:49,440 --> 00:17:52,730
あなたが何をしたいのか、シーザーために我々は、整数を扱いたいと考えて

248
00:17:52,730 --> 00:17:57,180
ので、このatoi関数を使用することができます。

249
00:17:57,180 --> 00:18:02,850
そして、基本的には、文字列にそれを渡し、その後、それは整数をあなたに戻ります

250
00:18:02,850 --> 00:18:06,070
それは整数にその文字列を作ることが可能ましょう。

251
00:18:06,070 --> 00:18:10,960
我々はそのようなprintf関数またはGetString、物事を扱っているときに、今、覚えている

252
00:18:10,960 --> 00:18:13,390
我々は我々に固有のライブラリが含まれています。

253
00:18:13,390 --> 00:18:19,450
だから初めに、我々はハッシュタグの標準I / O、H、そのような何かから始まります。

254
00:18:19,450 --> 00:18:22,430
まあ、atoiは、これらのライブラリの1内ではありません

255
00:18:22,430 --> 00:18:26,600
私たちは何をすべきか、私たちはそのために正しいライブラリをインクルードする必要があります。

256
00:18:26,600 --> 00:18:32,720
だから私は、マニュアル機能を議論チュートリアル1に戻って思い出してください。

257
00:18:32,720 --> 00:18:37,110
ご使用の端末で男を入力し、[関数名が続く。

258
00:18:37,110 --> 00:18:39,720
ですから、その使い方のリスト全体が表示されますその

259
00:18:39,720 --> 00:18:42,890
が、同様に、それはそれが属しているライブラリが表示されます。

260
00:18:42,890 --> 00:18:47,000
だから私は、atoi関数とマニュアル機能を使用するには、あなたにそれを残しておきます

261
00:18:47,000 --> 00:18:53,360
そしてあなたはatoi関数を使用できるようにインクルードする必要があるライブラリを見つけ出す。

262
00:18:54,450 --> 00:18:57,670
ので、我々は鍵を持っていると今では、プレーンテキストを得ることになる

263
00:18:57,670 --> 00:19:01,820
ので、それは実際にあなたがプロンプトユーザー入力になるだろう。

264
00:19:01,820 --> 00:19:05,540
私たちは、同じ調子でそうgetIntおよびgetFloatは対処し、

265
00:19:05,540 --> 00:19:07,670
我々は、GetStringメソッドを扱うことになるだろう。

266
00:19:07,670 --> 00:19:12,440
whileまたはループがチェックしながらしかし、今回のケースで我々は、いずれかの操作を行う必要はありません。

267
00:19:12,440 --> 00:19:14,480
GetStringメソッドは間違いなく、私たちに文字列を与える

268
00:19:14,480 --> 00:19:17,630
そして我々は、ユーザが与えてくれるものは何でも暗号化するつもりだ。

269
00:19:17,630 --> 00:19:23,770
ですから、これらのユーザーが入力する文字列のすべてが正しいと仮定することができます。

270
00:19:23,770 --> 00:19:24,670
グレート。

271
00:19:24,670 --> 00:19:27,270
、それでは、一度キーを持っていると一度は、テキストを持っている

272
00:19:27,270 --> 00:19:31,660
今残っているものは、平文を暗号化する必要がある。

273
00:19:31,660 --> 00:19:36,530
ちょうど素早く専門用語の上にカバーするために、プレーンテキストは、ユーザーがあなたを与えるものである

274
00:19:36,530 --> 00:19:41,030
と暗号文は、あなたがそれらに戻すものです。

275
00:19:42,450 --> 00:19:45,850
だから文字列は、文字で実際に手紙を通過できるようにするには

276
00:19:45,850 --> 00:19:48,550
我々はすべての文字をシフトしなければならないので、

277
00:19:48,550 --> 00:19:51,390
裏皮我々は一種の層をした場合、我々は、その文字列を理解する

278
00:19:51,390 --> 00:19:54,130
我々は、彼らが本当に文字のリストだということを参照してください。

279
00:19:54,130 --> 00:19:55,930
一つは、他の後に来る。

280
00:19:55,930 --> 00:20:01,690
彼らは文字の配列であるため、そして私たちは配列​​として文字列を扱うことができます。

281
00:20:01,690 --> 00:20:05,640
ですから、テキストという文字列を、持っていると言う

282
00:20:05,640 --> 00:20:09,400
その変数テキスト内これはCS50で格納されます。

283
00:20:09,400 --> 00:20:15,680
その後、インデックス0のテキストが資本のTだろう、インデックス1は、H、等であろう

284
00:20:17,530 --> 00:20:23,970
そして、配列を持つ、args.cでARGC例では、

285
00:20:23,970 --> 00:20:27,090
我々は配列を反復しなければならなかったことを見た

286
00:20:27,090 --> 00:20:32,440
それで我々は、私は長さよりも小さくなるまでiから= 0を反復しなければならなかった。

287
00:20:32,440 --> 00:20:35,560
だから我々は文字列の長さとは何かを考え出すのいくつかの方法が必要

288
00:20:35,560 --> 00:20:37,090
我々はそれを反復するつもりなら。

289
00:20:37,090 --> 00:20:42,300
幸いにも再び、関数はCS50ではあるが、後に、私たちのためにそこにある

290
00:20:42,300 --> 00:20:45,860
あなたは間違いなく、独自の関数を実装して作ることができるだろう

291
00:20:45,860 --> 00:20:48,260
その文字列の長さを計算することができます。

292
00:20:48,260 --> 00:20:52,120
しかし、今のところ我々はそうstrlenは、文字列の長さを使用するつもりです。

293
00:20:52,120 --> 00:21:00,440
あなたは、文字列を渡すと、それは、あなたの文字列の長さを表すintを返します。

294
00:21:00,440 --> 00:21:05,840
我々は、文字列内の各文字を反復することができるかもしれない方法の例を見てみましょう

295
00:21:05,840 --> 00:21:08,470
そしてそれで何かをする。

296
00:21:08,470 --> 00:21:13,250
私たちがやりたいことは、文字列の各文字を反復している

297
00:21:13,250 --> 00:21:19,150
そして、私たちがやりたいことは、我々は1ずつ文字1をバックプリントです

298
00:21:19,150 --> 00:21:22,060
我々はそれの隣に何かを追加する場合は除きます。

299
00:21:22,060 --> 00:21:27,020
だから、forループを始めましょう。 int型私= 0。

300
00:21:27,020 --> 00:21:30,070
我々は条件のためのスペースを残してするつもりです。

301
00:21:32,700 --> 00:21:36,840
我々は、文字列の末尾に到達するまで、反復したいですよね？

302
00:21:36,840 --> 00:21:41,340
それでは、どのような機能は私たちに、文字列の長さを与えますか？

303
00:21:41,340 --> 00:21:43,160
[聞き取れない生徒の応答]

304
00:21:43,160 --> 00:21:46,420
これはコマンドライン引数の長さです。

305
00:21:46,420 --> 00:21:50,650
しかし、文字列のために、私たちは私たちに、文字列の長さを与える関数を使用したい。

306
00:21:50,650 --> 00:21:53,090
だからそれは文字列の長さです。

307
00:21:53,090 --> 00:21:57,130
それで、あなたはそれに文字列を渡す必要があります。

308
00:21:57,130 --> 00:21:59,760
それはの長さを計算する必要があるか文字列かを知る必要があります。

309
00:21:59,760 --> 00:22:03,160
それでは、この場合、我々は、文字列sを扱っている。

310
00:22:04,790 --> 00:22:05,860
グレート。

311
00:22:05,860 --> 00:22:10,770
それでは、私たちが何をしたいのかは、printfしてみましょう。

312
00:22:10,770 --> 00:22:14,850
今、私たちは文字を扱いたい。私たちは、それぞれの個々の文字をプリントアウトしたい。

313
00:22:14,850 --> 00:22:22,150
あなたはそれがフロートをプリントアウトしたい場合は、％fのようなプレースホルダを使用することになります。

314
00:22:22,150 --> 00:22:24,580
int型を使用すると、％dを使用します。

315
00:22:24,580 --> 00:22:30,890
それで同様に、文字であなたは、私が文字を印刷するつもりだと言うこと％cを使う

316
00:22:30,890 --> 00:22:34,570
変数内に保存されている。

317
00:22:34,570 --> 00:22:40,840
だから我々はこれを持っており、それまでの期間とスペースを追加してみましょう。

318
00:22:40,840 --> 00:22:45,430
我々は、どの文字を使用していますか？

319
00:22:45,430 --> 00:22:49,780
我々は、我々が文字列の時のどのような文字を使用してすることになるだろう。

320
00:22:49,780 --> 00:22:52,890
それでは、我々は、文字列を使って何かを使用してすることになるだろう

321
00:22:52,890 --> 00:22:56,420
しかし、我々はそこに特定の文字にアクセスすることにしたい。

322
00:22:56,420 --> 00:23:02,740
文字列は配列であればそうだとすれば、どのように我々は、配列の要素にアクセスするのですか？

323
00:23:02,740 --> 00:23:06,480
我々は、これらの角括弧を持っているし、我々はそこにインデックスを入れた。

324
00:23:06,480 --> 00:23:11,820
だから我々は、角括弧を持っています。この場合、我々は、ちょうど私が私たちのインデックスを使用することができます。その通りです。

325
00:23:15,290 --> 00:23:22,370
そこでここでは、我々はドットと続く空白文字を印刷することになるだろうと言っている

326
00:23:22,370 --> 00:23:30,870
その文字は私たちの文字列sのi番目の文字であることを行っている。

327
00:23:32,920 --> 00:23:39,330
私はちょうどそれを保存するつもりです。オーケー。

328
00:23:42,510 --> 00:23:46,840
今私は、文字列の長さを実行するつもりです。

329
00:23:46,840 --> 00:23:53,440
だから我々は、OMGと呼ばれる文字列があったが、今ではそれがさらに強調されている。

330
00:23:53,440 --> 00:23:57,870
同様に、聞かせは、私たちが実際にユーザから文字列を取得したいと言う。

331
00:23:57,870 --> 00:23:59,580
どのように我々はこれを行うのでしょうか？

332
00:23:59,580 --> 00:24:01,610
前に、どのように我々はintを取得するのですか？

333
00:24:01,610 --> 00:24:08,040
我々は右、getIntを言ったの？しかし、これはint型ではないので、GetStringをしてみましょう。

334
00:24:11,780 --> 00:24:17,770
文字列の長さを作ってみましょう。ここでは、特定のプロンプトを入力しませんでした。

335
00:24:17,770 --> 00:24:19,940
だから私は知りません。

336
00:24:19,940 --> 00:24:23,820
私はここに私の名前を入れてするつもりですので、私はそれらのもののいずれかを実行できます。

337
00:24:23,820 --> 00:24:29,600
ここで私は、そのようなすべての文字か何かのための単語を割り当てます。クール。

338
00:24:29,600 --> 00:24:31,900
だからそれは文字列の長さです。

339
00:24:33,000 --> 00:24:34,640
だから我々はカエサルに戻っています。

340
00:24:34,640 --> 00:24:38,620
私たちは、文字列を反復するかについて、いくつかのツールを持っている

341
00:24:38,620 --> 00:24:41,250
我々は個々の要素にアクセスする方法。

342
00:24:41,250 --> 00:24:44,720
だから今我々はプログラムに戻ることができます。

343
00:24:44,720 --> 00:24:48,650
私はASCIIテーブルで、前にも述べたように、あなたの親友、

344
00:24:48,650 --> 00:24:52,300
あなたはすべての文字に関連付けられている数値を参照するつもりです。

345
00:24:52,300 --> 00:24:55,900
だからここに私たちの平文が、私はめまいだと言う！

346
00:24:55,900 --> 00:25:01,090
次に、これらの各文字は、数字とそれに関連付けられたASCII値を持っているとしている

347
00:25:01,090 --> 00:25:04,710
でも、アポストロフィー、スペースさえも、感嘆符、

348
00:25:04,710 --> 00:25:06,600
ので、このことを念頭に置いておきたいでしょう。

349
00:25:06,600 --> 00:25:12,360
だからそれらのコマンドライン引数に含まれているユーザが6であるという我々の鍵を言う。

350
00:25:12,360 --> 00:25:17,770
73で表されている私の最初の文字、、、そのための手段

351
00:25:17,770 --> 00:25:25,610
あなたは73 +6のASCII値で表されているものは何でもそれらの手紙に戻りたい。

352
00:25:25,610 --> 00:25:29,020
このケースではそれが79になります。

353
00:25:30,840 --> 00:25:35,040
今、私たちは、次の文字に行きたい。

354
00:25:35,040 --> 00:25:40,960
だから平文のインデックス1の次は、アポストロフィであろう。

355
00:25:40,960 --> 00:25:46,780
しかし、我々は文字だけを暗号化したいことを忘れないでください。

356
00:25:46,780 --> 00:25:50,040
だから我々は、アポストロフィが実際には同じままであることを確認したい

357
00:25:50,040 --> 00:25:54,310
我々は39から45に何でも変更しないこととなります。

358
00:25:54,310 --> 00:25:57,150
我々は、アポストロフィとしてそれを維持したい。

359
00:25:57,150 --> 00:26:00,780
だから我々は文字だけを暗号化するために覚えておきたい

360
00:26:00,780 --> 00:26:04,560
我々は他のシンボルのすべてが我々のプログラムで変更しないままにしたいので。

361
00:26:04,560 --> 00:26:07,130
私たちが望むこともう一つは、大文字と小文字を保持することです。

362
00:26:07,130 --> 00:26:10,250
ですから、大文字を持っているとき、それは大文字として滞在する必要があります。

363
00:26:10,250 --> 00:26:12,830
英小文字は小文字として滞在する必要があります。

364
00:26:13,620 --> 00:26:19,480
そこで、いくつかの便利な機能にのみ暗号文字に対処できるようにするには

365
00:26:19,480 --> 00:26:22,380
物事の総額を維持し続ける

366
00:26:22,380 --> 00:26:25,130
isalphaは、isupperは、islowerは関数です。

367
00:26:25,130 --> 00:26:29,270
ので、これらを使用すると、ブール値を返す関数です。

368
00:26:29,270 --> 00:26:34,180
基本的には、trueまたはfalse。これは大文字ですか？この英数字のですか？

369
00:26:34,180 --> 00:26:37,180
これは本質的に、手紙です。

370
00:26:37,180 --> 00:26:41,070
だからここでは、その関数を使用する方法の3つの例である。

371
00:26:41,070 --> 00:26:47,060
基本的には、その関数によってあなたに返された値がtrueであるかfalseであるかどうかをテストすることができます

372
00:26:47,060 --> 00:26:49,400
その入力に基づいて。

373
00:26:49,400 --> 00:26:54,880
どちらか、またはそれを暗号または、それはそれの大文字を確認してください、などを暗号化しない

374
00:26:54,880 --> 00:27:01,080
[学生]あなたはもう少しだけ、どのようにあなたがそれらを使用するものを説明できますか？ >>うん、確かに。

375
00:27:01,080 --> 00:27:08,470
我々は振り返るのであれば、ここでは右、私は資本を持っている？

376
00:27:08,470 --> 00:27:14,550
だから我々は、私は+6 Oであるので、私はOになることを知っている

377
00:27:14,550 --> 00:27:18,740
しかし、我々はそのOはOの資本であることを行っていることを確認したい

378
00:27:18,740 --> 00:27:22,940
だから、基本的に、それは私たちの入力を変更するつもりのようなものです。

379
00:27:22,940 --> 00:27:26,870
だからそれが大文字かどうかにかかわらず一種のは、我々はそれに対処する方法を変更します。

380
00:27:26,870 --> 00:27:32,360
それでは、我々は、その特定のインデックスにisupperは関数を使用する場合、

381
00:27:32,360 --> 00:27:36,480
本当の私たちのために返すようisupperが（ "I"）、ので、我々はそれが上限だと知っている。

382
00:27:36,480 --> 00:27:40,360
それでは、それに基づいて、後に我々は式に行くよ

383
00:27:40,360 --> 00:27:42,750
あなたはカエサルで物事をシフトするために使用されるだろうと、

384
00:27:42,750 --> 00:27:46,560
それでは、基本的に、それは大文字の場合、若干異なる式が行われる予定です

385
00:27:46,560 --> 00:27:50,670
として小文字に反対した。理にかなって？

386
00:27:51,020 --> 00:27:52,760
うん。心配ありません。

387
00:27:54,900 --> 00:27:58,990
私はかなりの意味をなさない文字に6を加えることについて少し話を

388
00:27:58,990 --> 00:28:05,500
私達は種類のこれらの文字があることを理解する場合を除き、

389
00:28:05,500 --> 00:28:08,920
整数と互換性の一種である。

390
00:28:08,920 --> 00:28:11,250
我々がやっていることは、我々は使用暗黙的キャストの一種である。

391
00:28:11,250 --> 00:28:18,100
我々は、あなたが値を取る場所にちょっと遅れキャスティングに行くよ、あなたは別のタイプに変えて

392
00:28:18,100 --> 00:28:20,440
それはもともとあったより。

393
00:28:20,440 --> 00:28:25,910
しかし、このPSETで、我々は同じ意味で使用する文字の種類にできるようになります

394
00:28:25,910 --> 00:28:30,880
とそれに対応する整数値。

395
00:28:30,880 --> 00:28:35,140
だから、あなたは、単にちょうど単一引用符で文字包む場合、

396
00:28:35,140 --> 00:28:40,390
その後、整数として扱う、整数でそれを使って作業することができるでしょう。

397
00:28:40,390 --> 00:28:48,040
だから大文字のCは67にも関する。小文字のfは102にも関する。

398
00:28:48,040 --> 00:28:51,480
これらの値を知りたい場合は、もう一度、あなたのASCIIコード表を見てみましょう。

399
00:28:51,480 --> 00:28:56,160
それでは、あなたは引いて追加することができるかもしれない方法の例をいくつかに行こう

400
00:28:56,160 --> 00:29:03,130
どのように実際には本当に交互に使用することは、これらの文字を扱うことができます。

401
00:29:03,870 --> 00:29:11,350
私はそのASCIIMath整数に文字を付加を計算するために起こっていると言う

402
00:29:11,350 --> 00:29:17,590
その後、得られた文字だけでなく、結果のASCII値を表示します。

403
00:29:17,590 --> 00:29:22,290
ので、ここで私が言っている - この部分にwe'll取引後 - 

404
00:29:22,290 --> 00:29:29,100
しかし、基本的に、私は、ユーザーがキーと一緒に実行ASCIIMathを言うべきだと言っている

405
00:29:29,100 --> 00:29:30,880
と私は、そのキーが数字であることを行っていることを言っている

406
00:29:30,880 --> 00:29:34,600
いると我々は、この文字を追加しようとしている。

407
00:29:34,600 --> 00:29:38,560
だからここに気付くことが私はキーを要求しているから、

408
00:29:38,560 --> 00:29:40,590
私は彼らが私に1つのことを与えていることを要求しているから、

409
00:29:40,590 --> 00:29:45,600
私は。/ asciimathとキーを受け入れたい。

410
00:29:45,600 --> 00:29:49,330
だから私は、argcは2に等しいことを要求するつもりです。

411
00:29:49,330 --> 00:29:54,360
それがないなら、私は1を返すつもりだとプログラムは終了します。

412
00:29:55,070 --> 00:29:58,540
だから私は、キーが最初のコマンドライン引数であることを行っていないと言っている

413
00:29:58,540 --> 00:30:05,080
それは2番目の1になるだろう、とあなたはここで見られるように、

414
00:30:05,080 --> 00:30:11,790
私はその整数に変身するつもりです。

415
00:30:15,740 --> 00:30:19,230
それから私は、rにする文字を設定するつもりです。

416
00:30:19,230 --> 00:30:23,970
変数CHRの型が実際に整数であることに注意してください。

417
00:30:23,970 --> 00:30:30,480
私は整数としてrを使用することができるよという方法は、これらの単一引用符でそれを包むことである。

418
00:30:33,850 --> 00:30:40,560
だから戻って我々のprintf文に我々は文字のプレースホルダを持つ場所

419
00:30:40,560 --> 00:30:43,590
し、整数のプレースホルダ、

420
00:30:43,590 --> 00:30:49,450
文字はCHRで表され、整数がキーになります。

421
00:30:49,450 --> 00:30:54,320
それで、我々は結果で一緒に2を追加するつもりです。

422
00:30:54,320 --> 00:30:58,420
だから我々はrを追加するつもりだ+キーが何であれ、

423
00:30:58,420 --> 00:31:03,520
その後、我々はその結果を印刷しようとしている。

424
00:31:06,210 --> 00:31:14,220
それではasciimathを作ってみましょう。それが最新なので、ちょうどasciimathを実行してみましょう。

425
00:31:14,220 --> 00:31:18,290
我々は実際には鍵をくれなかったので、ああ、しかし見、それは何もしません。

426
00:31:18,290 --> 00:31:23,850
だから、それだけで、私たちの主な機能は1が返されたときに、それはちょうど私達に戻る。

427
00:31:23,850 --> 00:31:29,250
だからその後の鍵に渡すことができます。誰かが私に番号を与える。 >> [生徒] 4。

428
00:31:29,250 --> 00:31:30,920
4。オーケー。

429
00:31:30,920 --> 00:31:39,280
だから、rは、私たちに118のASCII値に相当するvを与えるために起こっている4増加した。

430
00:31:39,280 --> 00:31:43,880
だから、それは一種のは、という意味になります - 

431
00:31:43,880 --> 00:31:51,250
実際に、私はあなたを求めることができますあなたは、r + 4 118である場合は、rのASCII値が何であるかと思いますか？

432
00:31:53,070 --> 00:31:55,470
その後、ええ、rは114である。

433
00:31:55,470 --> 00:32:03,010
あなたは、ASCIIコード表で見ればそう、確かに、あなたはrが114で表されていることがわかります。

434
00:32:03,010 --> 00:32:08,610
だから今、私たちは文字の整数を追加することができます知っている、これは非常にシンプルに見えます。

435
00:32:08,610 --> 00:32:12,740
私達はちょうど私達が前の例で見たような文字列を反復するつもりだ。

436
00:32:12,740 --> 00:32:17,170
それが手紙の場合我々は確認してみます。

437
00:32:17,170 --> 00:32:20,420
それがあるなら、私たちはキーが何であれでそれをシフトします。

438
00:32:20,420 --> 00:32:23,650
あなたがこれを好きになる場合を除いて、かなりシンプルな、

439
00:32:23,650 --> 00:32:32,140
あなたは、zは、122で表され、その後に別の文字を与えるだろうことがわかります。

440
00:32:32,140 --> 00:32:37,770
私たちは、実際、私たちのアルファベットの中に滞在したいですよね？

441
00:32:37,770 --> 00:32:43,180
だから我々は、ラップアラウンドの種類のいくつかの方法を把握する必要があります。

442
00:32:43,180 --> 00:32:47,190
あなたはZED到達し、あなたが特定の数だけ増やしたい場合、

443
00:32:47,190 --> 00:32:51,230
あなたは、ASCIIアルファベットセクション越えに行きたくない;

444
00:32:51,230 --> 00:32:54,140
あなたはAにすべての道を戻ってラップしたい

445
00:32:54,140 --> 00:32:58,550
しかし、あなたはまだケースを維持している心に留めておいてください。

446
00:32:58,550 --> 00:33:00,980
だから文字が記号になることができないことを知っている

447
00:33:00,980 --> 00:33:05,290
ただの記号のようにも変更するつもりはありません。

448
00:33:05,290 --> 00:33:08,170
あなたは間違いなくする必要はありませんでした最後のpset内、

449
00:33:08,170 --> 00:33:14,310
しかしオプションはモジュラス関数を使用してあなたの貪欲psetを実装することでした。

450
00:33:14,310 --> 00:33:17,230
しかし、今、私たちは実際に、係数を使用する必要があるとしている

451
00:33:17,230 --> 00:33:19,900
そうちょうどこの少し上に行くしてみましょう。

452
00:33:19,900 --> 00:33:26,920
本質的に、あなたがあなたにxをyで割った余りはxをyで割った剰余を持っている場合。

453
00:33:26,920 --> 00:33:30,930
ここではここでいくつかの例があります。我々は27％15を持っています。

454
00:33:30,930 --> 00:33:36,200
基本的には、負の取得せずに、可能な限り多くの27から15を引くとき

455
00:33:36,200 --> 00:33:39,060
その後、残された12を得る。

456
00:33:39,060 --> 00:33:44,650
だから、それは数学の文脈のように親切なのですが、どのように我々は実際にこれを使用することができますか？

457
00:33:44,650 --> 00:33:47,100
それは私達のラップオーバーするのに便利になるだろう。

458
00:33:47,100 --> 00:33:55,420
このためには、ちょうど私が3つのグループに分割するためにあなたのすべてを尋ねましょう。

459
00:33:55,420 --> 00:33:58,010
ときには、グループとそのような何かでこれを行う。

460
00:33:58,010 --> 00:34:01,320
"さて、私は3に分けることができるようにすべてを望んでいる"、私は言ったと言う

461
00:34:01,320 --> 00:34:04,240
どのようにすればいいでしょう？

462
00:34:04,240 --> 00:34:06,810
[聞き取れない生徒の応答]ええ、その通りです。オフ数える。オーケー。

463
00:34:06,810 --> 00:34:10,260
実際にそれを実行してみましょう。あなたが開始しますか？

464
00:34:10,260 --> 00:34:13,810
1、2、3、4 [学生がオフカウント]にします。

465
00:34:13,810 --> 00:34:16,620
しかし、覚えて... >> [生徒]ああ、ごめんね。

466
00:34:16,620 --> 00:34:18,730
それは本当に良い点だ。

467
00:34:18,730 --> 00:34:24,130
あなたは4点を述べたが、我々は唯一の3つのグループにしたいので、我々は実際にあなたが1を言いたい。

468
00:34:24,130 --> 00:34:30,159
それでは、どのように - そしてどのようにあなたが1を言うかもしれないので、いや、それは本当に良い例ですか？

469
00:34:30,159 --> 00:34:33,370
4と1の間の関係は何ですか？

470
00:34:33,370 --> 00:34:36,760
さて、4 MOD 3は1です。

471
00:34:36,760 --> 00:34:41,460
あなたが続けば、それで、あなたは2になります。

472
00:34:41,460 --> 00:34:44,540
だから我々は、1、2、3、1、2を持っています。

473
00:34:44,540 --> 00:34:49,420
繰り返しになりますが、実際に第五人だ。どのようにあなたは2点の代わりに5を言うことを知っていますか？

474
00:34:49,420 --> 00:34:53,760
あなたは5 MOD 3が2であると言います。

475
00:34:53,760 --> 00:34:59,100
私に残されたどのように多くの3つのグループを見たい場合、どのような順序は、I.午前

476
00:34:59,100 --> 00:35:02,860
それで、我々は、部屋全体に沿って継続した場合

477
00:35:02,860 --> 00:35:07,760
次に我々は、我々は常に、実際に自分自身にMOD関数を適用していることを見るでしょう

478
00:35:07,760 --> 00:35:09,990
カウントオフの種類に。

479
00:35:09,990 --> 00:35:14,490
それはあなたがモジュロを使用する方法の具体例のようなものだより

480
00:35:14,490 --> 00:35:17,960
私は確信しているので、私たちのほとんどは、おそらくそのプロセスを経てい

481
00:35:17,960 --> 00:35:19,630
私たちはうまくやってカウントする場所を持っていた。

482
00:35:19,630 --> 00:35:21,840
モジュロ上で何か質問はありますか？

483
00:35:21,840 --> 00:35:25,360
それは、この概念を理解することが非常に重要になるだろう

484
00:35:25,360 --> 00:35:28,640
ので、私はあなたたちが理解していることを確認したい。

485
00:35:28,640 --> 00:35:34,660
[学生]は残りが存在しない場合、それはあなたの実際の数を与えるのですか？

486
00:35:34,660 --> 00:35:40,430
それらの最初の3つはそれを行っていた場合、それは、彼らが実際に何であったか、それらを与えているだろう

487
00:35:40,430 --> 00:35:43,310
または、それが彼らに与えているだろう[聞こえない] >>それは良い質問ですね。

488
00:35:43,310 --> 00:35:48,750
モジュロのための残りの部分が存在しない場合 - あなたは6 modの3を持ってそう言う - 

489
00:35:48,750 --> 00:35:52,340
それは実際には0を戻り与える。

490
00:35:53,670 --> 00:35:57,290
私たちは、少し後でそのことについて話します。

491
00:35:58,810 --> 00:36:07,720
そうそう、例えば、3人目 -  3モッズ3は、実際には0であるが、彼女は3を語った。

492
00:36:07,720 --> 00:36:14,900
だから、例えば、内側のキャッチのような種類のものだ

493
00:36:14,900 --> 00:36:17,620
modが0であれば大丈夫のように、その後、私は3人目になるつもりです。

494
00:36:17,620 --> 00:36:22,740
しかし、我々は、我々は0が後で何かに対処することも方法の一種に入るでしょう。

495
00:36:22,740 --> 00:36:32,750
だから今我々は何とか右の文字にZEDをマッピングする方法を持っている。

496
00:36:32,750 --> 00:36:34,920
だから今我々は、これらの例を経てきました

497
00:36:34,920 --> 00:36:37,880
私達は種類のシーザーがうまくいくかもしれない方法を参照してください。

498
00:36:37,880 --> 00:36:42,640
あなたは2アルファベットを見て、あなたは彼らがシフトしてください。

499
00:36:42,640 --> 00:36:44,430
それでは試してみて、式の面であることを表現しましょう​​。

500
00:36:44,430 --> 00:36:46,940
この式は、実際には、仕様であなたのために与えられた

501
00:36:46,940 --> 00:36:52,070
しかし、各変数が何を意味するかを通して見てみましょうの一種。

502
00:36:52,070 --> 00:36:55,000
私たちの最終的な結果は、暗号文になるだろう。

503
00:36:55,000 --> 00:36:58,300
だから、これによると、暗号文のi番目の文字

504
00:36:58,300 --> 00:37:02,500
平文のi番目の文字に対応する予定です。

505
00:37:02,500 --> 00:37:08,130
我々は常にこれらの事を並べるようにしたいので、それは理にかなっています。

506
00:37:08,130 --> 00:37:13,480
だから、私たちの鍵である暗号文を加えたkのi番目の文字になるだろう - 

507
00:37:13,480 --> 00:37:17,230
それは理にかなっている - そして、我々はこのmod 26を持っています。

508
00:37:17,230 --> 00:37:19,860
我々はZEDを持っていたとき戻って覚えている

509
00:37:19,860 --> 00:37:24,190
私たちは、文字に入るためにしたくなかったので、我々はそれをmodにしたかった

510
00:37:24,190 --> 00:37:26,540
アルファベットラップアラウンドの、やさしい。

511
00:37:26,540 --> 00:37:33,430
後はあなたが正しい数値になったまではA、B、C、Dに行くだろうzedの。

512
00:37:33,430 --> 00:37:44,690
だから我々は知っているZED、ZEDは、A、B、C、D、E、Fの後に来るので+ 6、私達にfを与えるだろう。

513
00:37:44,690 --> 00:37:52,530
だから我々はZED + 6くれfを与えるために起こっていることを確かに知って覚えておきましょう。

514
00:37:52,530 --> 00:38:03,530
ASCII値では、zは122であり、fは102である。

515
00:38:03,530 --> 00:38:10,570
だから我々はシーザー式は私たちに102を与えることのいくつかの方法を見つけなければならない

516
00:38:10,570 --> 00:38:13,590
122で取った後。

517
00:38:13,590 --> 00:38:19,550
私達はちょうどこの式は、実際にあなたに24を与える（ 'Z' + 6）％26を適用するのであれば

518
00:38:19,550 --> 00:38:25,980
122 + 6 128ですので、128％26はあなたに24余りを返します。

519
00:38:25,980 --> 00:38:29,140
しかし、それは実際にfを意味するものではありません。それは間違いなく102ではありません。

520
00:38:29,140 --> 00:38:33,590
それはまた、アルファベットで第六文字ではありません。

521
00:38:33,590 --> 00:38:41,550
だから明らかに、我々は、この少し微調整する何らかの方法を持っている必要があります。

522
00:38:42,970 --> 00:38:51,340
通常のアルファベットの面では、我々は、zは26文字であり、fは6であることを知っている。

523
00:38:51,340 --> 00:38:55,460
しかし、我々はコンピュータサイエンスにしているので、我々は0からインデックスに行くんだ。

524
00:38:55,460 --> 00:39:00,690
代わりに、zは26番であることのそれだから、我々はそれが数25だと言うつもりだ

525
00:39:00,690 --> 00:39:02,630
0であるため。

526
00:39:02,630 --> 00:39:04,770
だから今のこの式を適用することができます。

527
00:39:04,770 --> 00:39:11,710
私たちは、zはあなたに31を与える、25 + 6で表されています。

528
00:39:11,710 --> 00:39:15,790
と31モッズ26は、剰余としてあなたに5を与える。

529
00:39:15,790 --> 00:39:20,500
我々は、fはアルファベットで5番目の文字であることを知っているので、それは最高だ。

530
00:39:20,500 --> 00:39:26,400
しかし、それはまだ右、fはないですか？それはまだ102ではありません。

531
00:39:26,400 --> 00:39:32,730
それではこのpsetに対する、挑戦は関係を見つけるしようとする

532
00:39:32,730 --> 00:39:36,910
これらのASCII値とアルファベット順のインデックスとの間の変換の間。

533
00:39:36,910 --> 00:39:40,280
本質的に、あなたが何をしたいだろう何、あなたは、ASCII値でスタートしたい

534
00:39:40,280 --> 00:39:45,390
しかし、その後は何とかそのアルファベット順の索引に変換したい

535
00:39:45,390 --> 00:39:52,610
それがどうあるべきか手紙計算 - 基本的に、そのアルファベット順のインデックスとは何か

536
00:39:52,610 --> 00:39:57,660
暗号文字の - その背中ASCII値に変換します。

537
00:39:57,660 --> 00:40:04,870
あなたはASCIIテーブルをサッと取り出し、もしそうなら、次に試してみて、102および図5を参照すると、言う間の関係を見つける

538
00:40:04,870 --> 00:40:10,440
または122と25。

539
00:40:12,140 --> 00:40:15,690
私たちは、平文を得て、コマンドライン引数から我々の鍵を手に入れた

540
00:40:15,690 --> 00:40:17,520
我々はそれを暗号化されてきました。

541
00:40:17,520 --> 00:40:19,820
今、私たちがしなければ残っているのは、それを印刷しています。

542
00:40:19,820 --> 00:40:22,040
我々は、このそれぞれに異なるいくつかの方法を行うことができます。

543
00:40:22,040 --> 00:40:24,570
我々に沿って行くと私たちは何ができると、実際に印刷されています。

544
00:40:24,570 --> 00:40:28,250
私たちは、文字列内の文字を繰り返すため、

545
00:40:28,250 --> 00:40:31,660
我々はそれを計算するときに我々は、単にちょうどそれから印刷することができます。

546
00:40:31,660 --> 00:40:36,030
別の方法としては、配列に格納し、文字の配列を作ることができます

547
00:40:36,030 --> 00:40:39,280
そして最後にその配列全体を反復処理し、それをプリントアウトする。

548
00:40:39,280 --> 00:40:40,980
だから、そのためのオプションがいくつかあります。

549
00:40:40,980 --> 00:40:47,280
と％cは文字を印刷するためのプレースホルダーであることを行っていることを覚えておいてください。

550
00:40:47,280 --> 00:40:50,420
だから私たちはシーザーを持って、そして、今、私たちは、Vigenereに移る

551
00:40:50,420 --> 00:40:57,580
これはカエサルに非常に似ていますが、少しだけ複雑です。

552
00:40:57,580 --> 00:41:03,310
だから、本質的にVigenereとは、キーワードを渡すことになるだろうされています。

553
00:41:03,310 --> 00:41:06,510
数字の代わりだから、あなたは、文字列を持っているつもりです

554
00:41:06,510 --> 00:41:09,200
ので、それはあなたのキーワードとして機能するようになるだろう。

555
00:41:09,200 --> 00:41:14,440
その後、いつものように、ユーザーからの文字列の入力を求めるプロンプトを取得するつもりだ

556
00:41:14,440 --> 00:41:19,050
し、それを暗号化してから、それらを暗号文のバックを与える。

557
00:41:19,050 --> 00:41:24,650
私が言ったように、それは、代わりに特定の数でシフトを除いて、シーザーと非常によく似ています

558
00:41:24,650 --> 00:41:30,620
数は、実際には文字から文字へたびに変更する予定です。

559
00:41:30,620 --> 00:41:34,890
シフトすることが実際の数を表すために、それはキーボードの文字で表さだ。

560
00:41:34,890 --> 00:41:43,150
あなたが例えばのシフトに入るようなら、それは0のシフトに対応しているでしょう。

561
00:41:43,150 --> 00:41:45,900
だから、アルファベット順の索引に戻って、再びです。

562
00:41:45,900 --> 00:41:49,100
あなたは私たちが実際にASCII値を扱っていることを見ている場合に便利かもしれないもの

563
00:41:49,100 --> 00:41:51,790
同様に、文字だけでなく、アルファベット順のインデックスとして、

564
00:41:51,790 --> 00:41:58,020
多分、0〜25のアルファベット順のインデックスを示し、独自のASCIIテーブルを見つけるか、または作る

565
00:41:58,020 --> 00:42:03,750
ように、どのような種類の関係をaからzまで、およびASCIIの値を見ることができます

566
00:42:03,750 --> 00:42:07,020
とスケッチし、いくつかのパターンを試してみて、見つける。

567
00:42:07,020 --> 00:42:11,010
同様に、fで特定のインスタンスでシフトされた場合 - 

568
00:42:11,010 --> 00:42:21,110
これは、小文字も大文字fである - そしてそれは5に対応しているでしょう。

569
00:42:21,110 --> 00:42:24,180
我々は、これまでのところ良いですか？

570
00:42:25,770 --> 00:42:30,050
Vigenereための式は少し異なっています。

571
00:42:30,050 --> 00:42:32,960
基本的に、あなたは、それだけでシーザーのようなものだがわかり

572
00:42:32,960 --> 00:42:37,390
除くだけではなく、我々はKインデックスjを持っているK。

573
00:42:37,390 --> 00:42:44,810
我々は、本質的にあるため、キーワードの長さiを使用していないことに注意してください

574
00:42:44,810 --> 00:42:49,850
私たちの暗号文の長さとは必ずしも一致しません。

575
00:42:49,850 --> 00:42:56,130
我々は、私は少し後に持っている例を見たときこれは、ビット鮮明になります。

576
00:42:56,130 --> 00:43:03,160
基本的に、あなたがOHAIのキーワードを使用してプログラムを実行する場合、

577
00:43:03,160 --> 00:43:08,560
そのたびに、OHAIがあなたのシフトであることを行っていることを意味します。

578
00:43:08,560 --> 00:43:11,060
ですから、あなたのキーワードにあるかの位置に応じて、

579
00:43:11,060 --> 00:43:15,800
あなたはその分だけあなたの特定の暗号文の文字をシフトしようとしている。

580
00:43:15,800 --> 00:43:19,630
繰り返しになりますが、ちょうどカエサルのように、我々は、我々は物事の資本を維持することを確認したい

581
00:43:19,630 --> 00:43:22,900
そして我々だけ暗号化する文字ではなく、文字やスペース。

582
00:43:22,900 --> 00:43:26,330
だから、あなたが使用しているかもしれない機能にカエサルを振り返る

583
00:43:26,330 --> 00:43:32,570
あなたが物事をシフトし、ここであなたのプログラムにそれを適用する方法を決定した方法。

584
00:43:32,570 --> 00:43:35,260
それでは、これをマッピングすることができます。

585
00:43:35,260 --> 00:43:39,680
我々は、我々がGetStringメソッドからユーザーから得ていることを平文を持っている

586
00:43:39,680 --> 00:43:44,090
これを言って... CS50です！

587
00:43:44,090 --> 00:43:47,090
その後、我々はOHAIのキーワードがあります。

588
00:43:47,090 --> 00:43:50,930
最初の4文字は非常にシンプルです。

589
00:43:50,930 --> 00:43:55,580
我々は、TはOだけシフトされようとしていることを知っている

590
00:43:55,580 --> 00:44:01,990
hはhによってシフトされようとしているそして、私はシフトすることになるだろう。

591
00:44:01,990 --> 00:44:04,610
ここでは0を表していることがわかり、

592
00:44:04,610 --> 00:44:11,940
それでは、終了値は、実際には前と全く同じ文字です。

593
00:44:11,940 --> 00:44:15,250
するとSは、iによってシフトされます。

594
00:44:15,250 --> 00:44:19,370
しかし、あなたはここで、これらの期間を持っています。

595
00:44:19,370 --> 00:44:25,960
私たちは、それでは我々は何によってそれを変更しないことを暗号化する必要はありません

596
00:44:25,960 --> 00:44:31,280
とちょうど変わらない期間をプリントアウト。

597
00:44:31,280 --> 00:44:38,020
[学生]私はあなたがこれをシフトさせていることを知ってどのように理解していない - あなたはどこをやった -  >>ああ、ごめんね。

598
00:44:38,020 --> 00:44:41,620
ここで上部には、ここではそのコマンドライン引数のOHAI、以下を参照してください

599
00:44:41,620 --> 00:44:43,740
それがキーワードになるだろう。

600
00:44:43,740 --> 00:44:49,550
それで基本的には、キーワードの文字の上にサイクリングしている。

601
00:44:49,550 --> 00:44:52,020
[学生]だからoが同じシフトをされようとしている - 

602
00:44:52,020 --> 00:44:56,260
だからOはアルファベットの特定の番号に対応しています。

603
00:44:56,260 --> 00:44:58,400
[学生]右。しかし、あなたはCS50の部分をどこから得たのですか？

604
00:44:58,400 --> 00:45:02,540
ああ。それはあなたが、似ているところGetStringメソッドでの "私にエンコードする文字列を与えます。"

605
00:45:02,540 --> 00:45:07,510
[学生]彼らはあなたに、シフトさせる、その引数を与えるつもりだ

606
00:45:07,510 --> 00:45:09,380
その後、あなたの最初の文字列をおうかがいします。 >>うん。

607
00:45:09,380 --> 00:45:12,440
そこで、彼らはプログラムを実行するとき、彼らはキーワードを含めるつもりです

608
00:45:12,440 --> 00:45:14,740
それらのコマンドライン引数で、彼らはそれを実行したとき。

609
00:45:14,740 --> 00:45:19,740
次に、あなたは、彼らが実際より少なく、より多くのではないあなたに1を与えられていませんでしたことを確認したら

610
00:45:19,740 --> 00:45:23,750
次に、文字列の入力を要求するつもりだ、と言う、 "私に文字列を与えます。"

611
00:45:23,750 --> 00:45:27,630
だから、このケースでは、彼らはあなたにこれを与えてくれた場所だ... CS50です！

612
00:45:27,630 --> 00:45:32,090
だから、それを使うとOHAIを使用して繰り返し処理するつもりです。

613
00:45:32,090 --> 00:45:38,200
ここではピリオドを暗号飛ばしていることに注意してください、

614
00:45:38,200 --> 00:45:51,660
しかしOHAI、次のいずれかの我々の立場という点で我々はoを使用していました。

615
00:45:51,660 --> 00:45:54,990
このケースでは、4の処理になるため、表示するには少し難しいです

616
00:45:54,990 --> 00:45:57,710
それでは、少し続けていきましょう。ちょうどここに私と一緒に固執する。

617
00:45:57,710 --> 00:46:02,960
その後、我々はその後、それぞれOとHによって翻訳されるiとsを持っています。

618
00:46:02,960 --> 00:46:09,370
その後、我々はスペースを持っており、それでは我々はスペースを暗号化するつもりはないことを知っている。

619
00:46:09,370 --> 00:46:18,930
しかし、代わりに、右ここにこの場所でに行くことに気付く

620
00:46:18,930 --> 00:46:28,330
我々は、することにより暗号化している - 右ここに - あなたはそれを見ることができるかどうかは分からない。

621
00:46:28,330 --> 00:46:33,710
だから、それはあなたが実際に所定のようではない、と言う、oはここに行く、hは、ここに行く

622
00:46:33,710 --> 00:46:39,200
私は、I、O、H、O、H、Iはここに行き、ここに行く。あなたはそれをしない。

623
00:46:39,200 --> 00:46:43,760
あなただけのキーワードで自分の位置をシフト

624
00:46:43,760 --> 00:46:51,020
あなたが実際に実際の文字を暗号化することになるだろうことを知っているとき。

625
00:46:51,020 --> 00:46:53,920
そういうのは理にかなっていますか？

626
00:46:53,920 --> 00:46:55,800
オーケー。

627
00:46:56,490 --> 00:46:58,500
だから、いくつかのリマインダ。

628
00:46:58,500 --> 00:47:03,760
あなたが唯一のあなたのキーワードの次の文字に進むことを確認したい

629
00:47:03,760 --> 00:47:06,390
あなたの平文での文字は英字である場合。

630
00:47:06,390 --> 00:47:09,120
だから我々はoにしていると言う。

631
00:47:09,120 --> 00:47:19,310
我々は、次の文字、平文のiインデックスは、例えば、数値であることに気づく。

632
00:47:19,310 --> 00:47:31,630
我々は、別の文字が表示されるまで、その後、我々は、jは、私たちのキーワードのインデックスを進めません。

633
00:47:31,630 --> 00:47:36,230
繰り返しになりますが、あなたはまた、キーワードの先頭にラップアラウンドことを確認したい

634
00:47:36,230 --> 00:47:37,770
あなたはそれの終わりにいるとき。

635
00:47:37,770 --> 00:47:42,030
あなたは私たちが私にいるここに表示された場合は、次のものは、oである必要があります。

636
00:47:42,030 --> 00:47:47,690
つまり、あなたのキーワードの先頭にラップアラウンドすることができるといういくつかの方法を見つけたいと思って

637
00:47:47,690 --> 00:47:49,470
あなたが最後に到達するたびに。

638
00:47:49,470 --> 00:47:55,040
それで再び、演算の種類は、折り返しのためにそのような場合に役立ちましたか？

639
00:47:56,630 --> 00:47:59,840
例えばオフカウントに好きです。

640
00:47:59,840 --> 00:48:03,710
[学生]パーセント記号。 >>うん、モジュロであるパー​​セント記号、。

641
00:48:03,710 --> 00:48:11,250
だからモジュロは、あなたOHAIでインデックスをオーバーラップしたい場合は、ここに便利になるだろう。

642
00:48:11,250 --> 00:48:17,700
そして、ちょうどクイックヒント：ビットカウントオフのようなキーワードの中でラッピングを考えてみてください、

643
00:48:17,700 --> 00:48:23,590
3グループ、第四人は、どこがあるかどう

644
00:48:23,590 --> 00:48:30,610
彼らが言ったことを、その数は1であった4モッズ3、だった。

645
00:48:30,610 --> 00:48:32,880
だから、そのようにしようと考えることもできます。

646
00:48:34,770 --> 00:48:42,740
あなたが次にKJをciとその後パイを持っていますが、どこでも、式で見たように、

647
00:48:42,740 --> 00:48:44,700
あなたがそれらを追跡することを確認したい。

648
00:48:44,700 --> 00:48:47,580
あなたはそれを私を呼び出す必要はありません、あなたはそれjは呼び出す必要はありません

649
00:48:47,580 --> 00:48:53,270
しかし、あなたはあなたがあなたの平文時だという位置を追跡することを確認したい

650
00:48:53,270 --> 00:48:55,790
同様にあなたがキーワードであるという立場にいるとして

651
00:48:55,790 --> 00:48:59,840
それらは必ずしも同じであることを行っていないためです。

652
00:48:59,840 --> 00:49:06,400
キーワードだけでなく - それはあなたの平文より完全に異なる長さである可能性があります。

653
00:49:06,400 --> 00:49:09,140
また、お使いの平文、数字や文字があります、

654
00:49:09,140 --> 00:49:14,450
ので、それは完全に一緒にマッチアップするつもりはない。はい。

655
00:49:14,450 --> 00:49:19,280
[学生]は大文字と小文字を変更する機能はありますか？

656
00:49:19,280 --> 00:49:24,530
あなたは、資本に変更することはできますか？ >>うん、間違いない。

657
00:49:24,530 --> 00:49:27,890
あなたがチェックアウトすることができます - 私はそれがtoupperが、すべて1つの単語だと思います。

658
00:49:30,650 --> 00:49:36,310
しかし、あなたが物事を暗号化して、テキストを保存しようとしているとき、

659
00:49:36,310 --> 00:49:39,350
それは別の例を持っている基本的にはベストです。

660
00:49:39,350 --> 00:49:42,040
それは大文字の場合は、これによってシフトさせたい

661
00:49:42,040 --> 00:49:46,460
式の中で、あなたが振り返ったときに私達は行くの種類があるので、どのように

662
00:49:46,460 --> 00:49:50,900
同じ意味で数字を表すのASCII方法との間の

663
00:49:50,900 --> 00:49:55,020
と実際のアルファベット順の索引、我々は確認したい

664
00:49:55,020 --> 00:50:01,850
あなたが使用しようとしているパターンのいくつかの種類があるように起こっている。

665
00:50:01,850 --> 00:50:04,580
パターン上の別のノートでは、実際に。

666
00:50:04,580 --> 00:50:07,250
あなたは間違いなく、数値を扱うことになるだろう。

667
00:50:07,250 --> 00:50:11,280
スタイルの一例である、マジックナンバーを使用しないようにしてください。

668
00:50:11,280 --> 00:50:18,470
あなたが好きで毎回シフトに何かしたいそう言う - 

669
00:50:18,470 --> 00:50:22,400
あなたが何かをシフトしようとしているときにわかりましたので、ヒント、別のスポイラーです

670
00:50:22,400 --> 00:50:26,310
一定量のことで、実際の数でそれを表現しないようにしよう

671
00:50:26,310 --> 00:50:32,810
むしろ試してみて、あなたは一種の方が理にかなっているでしょうASCII値を使用することができます参照してください。

672
00:50:32,810 --> 00:50:35,470
別のノート：私達は式を扱っているので、

673
00:50:35,470 --> 00:50:41,200
あなたのTFは種類のあなたが使用している可能性が何パターン知っているにもかかわらず、

674
00:50:41,200 --> 00:50:44,430
あなたのコメントの種類の中でのベストは、ロジック、などを説明

675
00:50:44,430 --> 00:50:51,880
"私はこのパターンを使用していますので..."そして種類のあなたのコメントに簡潔にパターンを説明する。

676
00:50:54,090 --> 00:50:58,990
[これはチュートリアル2であった]他の質問がない場合は、私はほんの少しのためにここにいるよ。

677
00:50:58,990 --> 00:51:04,370
クリプトと来てくれてありがとう：あなたのpset 2で頑張って。

678
00:51:06,070 --> 00:51:08,620
[学生]ありがとうございます。 >>ありがとうございます。

679
00:51:09,220 --> 00:51:10,800
[メディアオフラインイントロ]