1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [第4項] [あまり快適]

2
00:00:02,000 --> 00:00:04,000
[ネイトHardison] [ハーバード大学]

3
00:00:04,000 --> 00:00:07,000
[これはCS50です。] [CS50.TV]

4
00:00:07,000 --> 00:00:10,000
>> すべての権利は​​、セクションに戻って歓迎する。

5
00:00:10,000 --> 00:00:13,000
今週のセクションでは、私たちは二つのことをやろうとしている。

6
00:00:13,000 --> 00:00:17,000
我々は、最初のリキャップ問題セット2に行くんだ

7
00:00:17,000 --> 00:00:20,000
シーザーとVigenère問題のセットです。

8
00:00:20,000 --> 00:00:23,000
そして、我々はクイズ0件飛び込むつもりだ

9
00:00:23,000 --> 00:00:26,000
そして我々が話した内容を要約し少し時間を費やす

10
00:00:26,000 --> 00:00:30,000
講義のそれぞれで、これまでのところ、我々はまた、いくつかの問題をやる

11
00:00:30,000 --> 00:00:32,000
前年のクイズから。

12
00:00:32,000 --> 00:00:36,000
そうすればあなたたちはそのための準備をするためには、良い方法があります。

13
00:00:36,000 --> 00:00:40,000
>> 開始するには、私は良いソリューションのカップルを起動した

14
00:00:40,000 --> 00:00:45,000
以前の問題セットのため、問題はこの空間に、2を設定します。

15
00:00:45,000 --> 00:00:48,000
あなたたちは、このすべてのリンクをヒットした場合、

16
00:00:48,000 --> 00:00:53,000
そしてあなたが私の名前をクリックして、私の最初のリビジョンをクリックした場合

17
00:00:53,000 --> 00:00:56,000
あなたは、私が見ているものを正確になりcaesar.cを、表示されます。

18
00:00:56,000 --> 00:01:00,000
本当にすぐにこれについて話してみましょう。

19
00:01:00,000 --> 00:01:02,000
これは単なるサンプルソリューションです。

20
00:01:02,000 --> 00:01:05,000
これは完璧なソリューションであるとは限りません。

21
00:01:05,000 --> 00:01:08,000
これを書くために多くの異なる方法がありますが、

22
00:01:08,000 --> 00:01:10,000
しかし、私が強調したかったことがいくつかあります

23
00:01:10,000 --> 00:01:13,000
私はグレーディング、私が思う一般的なミスだったと見ている

24
00:01:13,000 --> 00:01:18,000
このソリューションは、取り扱いが非常に良い仕事をしません。

25
00:01:18,000 --> 00:01:22,000
>> 第一は、上部にヘッダコメントのいくつかの並べ替えを持っています。

26
00:01:22,000 --> 00:01:25,000
7行目まで1日にあなたは詳細を参照してください、

27
00:01:25,000 --> 00:01:28,000
このプログラムは、正確に何をやっている。

28
00:01:28,000 --> 00:01:32,000
あなたがCのコードを書いているの良い標準的な実践

29
00:01:32,000 --> 00:01:35,000
関係なく、あなたのプログラムは、一つのファイル内に含まれる場合は

30
00:01:35,000 --> 00:01:38,000
それが複数のファイルに分割さているかどうかのいくつかの並べ替えを持っていることである

31
00:01:38,000 --> 00:01:40,000
最初のコメントを方向付ける。

32
00:01:40,000 --> 00:01:43,000
これは、外に出て、現実世界でコードを書いている人も対象としています。

33
00:01:43,000 --> 00:01:47,000
彼らは著作権情報を出してあげるところです。

34
00:01:47,000 --> 00:01:50,000
以下の＃含まれています。

35
00:01:50,000 --> 00:01:55,000
16行目で、これは＃私たちは少しだけにして戻ってくる、これを定義あり。

36
00:01:55,000 --> 00:01:59,000
そして、一度関数は、かつてメインスタートを開始

37
00:01:59,000 --> 00:02:03,000
このプログラムはすべて、単一の関数に含まれているため、

38
00:02:03,000 --> 00:02:09,000
起こると、これは非常に慣用句とCプログラムの典型である非常にまず最初に

39
00:02:09,000 --> 00:02:14,000
コマンドラインにかかるということがすぐにチェックする引数である-

40
00:02:14,000 --> 00:02:18,000
>> 引数countは、argcのために。

41
00:02:18,000 --> 00:02:24,000
右ここでは、このプログラムが正確に2つの引数を期待していることがわかります。

42
00:02:24,000 --> 00:02:27,000
特別なものだと、最初の引数があると覚えておいてください

43
00:02:27,000 --> 00:02:29,000
それは、常に実行されているプログラムの名前です

44
00:02:29,000 --> 00:02:31,000
実行可​​能ファイルの名前。

45
00:02:31,000 --> 00:02:36,000
それで、これは何をするかは、それがプログラムを実行したりすることを防ぐためです

46
00:02:36,000 --> 00:02:42,000
より多くのまたはより少ない引数を持つ。

47
00:02:42,000 --> 00:02:44,000
私たちは離れて、この権利があるかどうかをチェックする理由はある

48
00:02:44,000 --> 00:02:52,000
私たちは実際に確実に右ここにこのargv配列にアクセスすることはできません

49
00:02:52,000 --> 00:02:55,000
我々はそれがどのように大きく見て確認するまで。

50
00:02:55,000 --> 00:02:58,000
>> 私が見た一般的なエラーの1つは、人々はすぐに行くことだった

51
00:02:58,000 --> 00:03:01,000
とargv [1]をつかむ。

52
00:03:01,000 --> 00:03:06,000
彼らは外に配列のキー引数をつかむだろうと私は、それをチェックするか

53
00:03:06,000 --> 00:03:11,000
その後彼らは、argcをするためのテストだけでなく、次のテストを行うと思います

54
00:03:11,000 --> 00:03:16,000
最初の引数は、確かに同じ時に整数だったかどうか

55
00:03:16,000 --> 00:03:20,000
ケースで供給引数がないことをため、それは動作しません

56
00:03:20,000 --> 00:03:26,000
あなたはそこではない引数をつかむか、存在しないものをつかむしようとすることでしょう。

57
00:03:26,000 --> 00:03:29,000
>> あなたが気付くべきである他の大きなものは、ということです

58
00:03:29,000 --> 00:03:32,000
あなたは常に有用なエラーメッセージのいくつかの並べ替えをプリントアウトしたい

59
00:03:32,000 --> 00:03:34,000
ユーザへの向きを受けなければならない。

60
00:03:34,000 --> 00:03:37,000
私は、あなたが突然、それがクラッシュのすべてのプログラムの実行をしたと確信しています

61
00:03:37,000 --> 00:03:41,000
そしてあなたがポップアップし、言うこのばかげた小さなダイアログを得る

62
00:03:41,000 --> 00:03:44,000
多分恐ろしく不可解な、何かがあなたに、エラー·コード、またはそのような何かを与える

63
00:03:44,000 --> 00:03:47,000
それは意味をなさない。

64
00:03:47,000 --> 00:03:50,000
あなたが本当に役立つものを提供したいところです

65
00:03:50,000 --> 00:03:54,000
そして、彼らはそれを実行したときに、 "ああ、"顔の手のひらに行くように、ユーザーを対象とした。

66
00:03:54,000 --> 00:03:58,000
"私は何を正確に何を知っています私はこの問題を解決する方法を知っています。"

67
00:03:58,000 --> 00:04:01,000
>> あなたがメッセージを出力しない場合は、実際に終わる

68
00:04:01,000 --> 00:04:04,000
あなたのソースコードを調べて行くことにユーザーを残して

69
00:04:04,000 --> 00:04:07,000
何が悪かったのかを把握する。

70
00:04:07,000 --> 00:04:11,000
あなたが別のエラーコードを使用しますことを、いくつかの回もあります。

71
00:04:11,000 --> 00:04:14,000
ここでは、単にエラーがあったと言うために1つを使用し、

72
00:04:14,000 --> 00:04:16,000
エラーが発生した、エラーが発生しました。

73
00:04:16,000 --> 00:04:20,000
大きなプログラムは、他のプログラムによって呼び出されることが多いプログラムは、

74
00:04:20,000 --> 00:04:25,000
さまざまなシナリオでの特殊なエラーコードのいくつかの並べ替えを返します。

75
00:04:25,000 --> 00:04:28,000
プログラムで何がそうでない場合と通信する

76
00:04:28,000 --> 00:04:32,000
ただのための素敵な英語のメッセージを使用します。

77
00:04:32,000 --> 00:04:35,000
クール。

78
00:04:35,000 --> 00:04:37,000
私たちが降りていくように、あなたは私たちが鍵を引き出し見ることができます。

79
00:04:37,000 --> 00:04:40,000
私たちは、キーが合うかどうかを確認するためにテストします。

80
00:04:40,000 --> 00:04:42,000
私たちは、ユーザからのメッセージを取得します。

81
00:04:42,000 --> 00:04:46,000
ループと、これは我々がカバーする何かである間、我々はこれを行うには、それを行う理由

82
00:04:46,000 --> 00:04:50,000
少し - しかし、で、それはあなたがコントロールDを入力した場合と判明

83
00:04:50,000 --> 00:04:54,000
あなたは、端末上のGetStringメソッドのプロンプトが表示されたとき

84
00:04:54,000 --> 00:04:59,000
実際に何をするかは、それが特殊文字を送信している

85
00:04:59,000 --> 00:05:01,000
プログラムへ。

86
00:05:01,000 --> 00:05:05,000
それはELFまたはファイルの終了文字と呼ばれています。

87
00:05:05,000 --> 00:05:08,000
そして、その場合には、私たちのメッセージ文字列は、nullになります

88
00:05:08,000 --> 00:05:14,000
ので、これが問題に自分自身を設定するために我々はチェックものではありませんでした。

89
00:05:14,000 --> 00:05:17,000
>> 我々は上に行くようにしかし、今、私たちは、ポインタの話を始めたこと

90
00:05:17,000 --> 00:05:21,000
ヒープ上と動的メモリ割り当て、

91
00:05:21,000 --> 00:05:25,000
あなたは可能性がある関数があるときにnullをチェック

92
00:05:25,000 --> 00:05:30,000
値が何をしての習慣で取得したいと思うこと何かであるように、nullを返す。

93
00:05:30,000 --> 00:05:33,000
これは主に、説明のためにここにある。

94
00:05:33,000 --> 00:05:36,000
しかし、あなたは将来のGetStringメソッドを参照して実行した場合、

95
00:05:36,000 --> 00:05:41,000
そうでセット4問題から、あなたは、このことを覚えておいてしたいと思う。

96
00:05:41,000 --> 00:05:44,000
繰り返しますが、これは、我々はまだそれをカバーしていなかったので、どちらかのセット3問題では問題になりません。

97
00:05:44,000 --> 00:05:53,000
最後に、我々は、我々はメインの暗号化ループに到達この部分を取得

98
00:05:53,000 --> 00:05:57,000
そしてここで何が起こっているものがいくつかあります。

99
00:05:57,000 --> 00:06:02,000
まず、我々は全体のメッセージ文字列自体を反復。

100
00:06:02,000 --> 00:06:07,000
ここでは、条件においてstrlen呼び出しを守ってきた

101
00:06:07,000 --> 00:06:12,000
そのあなたの数が指摘してきたが行くのに最適な方法ではありません。

102
00:06:12,000 --> 00:06:15,000
それは、このケースでは、それはまた、素晴らしいではありません判明

103
00:06:15,000 --> 00:06:20,000
我々は、メッセージ自体の内容を変更している理由の一つ

104
00:06:20,000 --> 00:06:27,000
内側ループのために、私たちは10文字の長さのメッセージを持っている場合、

105
00:06:27,000 --> 00:06:32,000
我々はループstrlenは何を返すことを初めて起動したとき？

106
00:06:32,000 --> 00:06:35,000
10。

107
00:06:35,000 --> 00:06:40,000
>> しかし、我々はそのメッセージを変更した場合、我々はその第五の文字を変更言う

108
00:06:40,000 --> 00:06:46,000
そして我々は、第五の位置に '\ 0'文字で投げる

109
00:06:46,000 --> 00:06:49,000
後続の反復ではstrlen（メッセージ）は、それが何をしたかは戻りません

110
00:06:49,000 --> 00:06:52,000
我々は非常に反復初めて、

111
00:06:52,000 --> 00:06:56,000
我々はそのヌルターミネータで投げたので、それは代わりに、5を返します

112
00:06:56,000 --> 00:06:59,000
と文字列の長さが定義されています

113
00:06:59,000 --> 00:07:03,000
その\ 0の位置による。

114
00:07:03,000 --> 00:07:09,000
このケースでは、これは我々の場所でそれを変更しているので、行くのに最適な方法です。

115
00:07:09,000 --> 00:07:13,000
しかし、あなたが、これは暗号化するために、実際には驚くほどシンプルであることに気づく

116
00:07:13,000 --> 00:07:16,000
あなたは数学が正しい得ることができるかどうか。

117
00:07:16,000 --> 00:07:19,000
必要なのは、あなたが見ていることを手紙かどうかをチェックすることです

118
00:07:19,000 --> 00:07:21,000
大文字または小文字です。

119
00:07:21,000 --> 00:07:24,000
>> 我々は唯一それをチェックする必要があり、我々はチェックする必要はありません理由

120
00:07:24,000 --> 00:07:27,000
アルファケースがあるためです

121
00:07:27,000 --> 00:07:30,000
文字が大文字かどうか、またはそれは小文字です

122
00:07:30,000 --> 00:07:33,000
それは、間違いなく英字だ

123
00:07:33,000 --> 00:07:38,000
我々は、大文字と小文字の数字を持っていないため。

124
00:07:38,000 --> 00:07:41,000
我々がやると他の事、これは少しトリッキーです - 

125
00:07:41,000 --> 00:07:45,000
我々は標準的なシーザー暗号の式を変更したさ

126
00:07:45,000 --> 00:07:49,000
我々は問題セット仕様で与えた。

127
00:07:49,000 --> 00:07:52,000
ここで何が異なるのは、我々が減算ということです

128
00:07:52,000 --> 00:07:58,000
大文字小文字の首都で、それから私達は首都追加

129
00:07:58,000 --> 00:08:02,000
バックエンドでインチ

130
00:08:02,000 --> 00:08:05,000
>> 私はあなたのいくつかは、あなたのコードでこれを行っている知っている。

131
00:08:05,000 --> 00:08:09,000
あなた方の誰もが、あなたの提出物でこれをやったの？

132
00:08:09,000 --> 00:08:13,000
あなたがこれをしなかった。あなたは、これが何Sahbを説明できますか？

133
00:08:13,000 --> 00:08:18,000
あなたが右のそれの後にMODをやったので、それを差し引くことにより、

134
00:08:18,000 --> 00:08:21,000
あなたは、あなたが[せき]の位置を得るためにそのようにそれを取らなければならない。

135
00:08:21,000 --> 00:08:25,000
そして、後でそれを追加することにより、あなたが欲しかったいずれかの上にシフトした。

136
00:08:25,000 --> 00:08:27,000
ええ、その通りです。

137
00:08:27,000 --> 00:08:32,000
Sahbだった言っている私たちは、追加したいとき

138
00:08:32,000 --> 00:08:36,000
私たちのメッセージと一緒に私たちの鍵

139
00:08:36,000 --> 00:08:42,000
その後モッズ、そのMODそのNUM_LETTERSによって、

140
00:08:42,000 --> 00:08:50,000
我々は、最初に適切な0から25の範囲に私たちのメッセージを拡張しない場合は、

141
00:08:50,000 --> 00:08:54,000
その後、私たちは本当に奇妙な番号を取得するに終わるかもしれない

142
00:08:54,000 --> 00:08:59,000
なぜなら、私たちはメッセージ[i]を見たときを見ていることに価値観、

143
00:08:59,000 --> 00:09:03,000
我々は、プレーンテキストメッセージのi番目の文字を見たとき、

144
00:09:03,000 --> 00:09:08,000
値は、この65から122の範囲でどこかにある

145
00:09:08,000 --> 00:09:13,000
小文字のaからzまでの大文字のASCII値に基づいています。

146
00:09:13,000 --> 00:09:18,000
そして私たちは、26によりまたはNUM_LETTERSによってそれをMODのとき

147
00:09:18,000 --> 00:09:23,000
それ以来、私たちは＃、ここで右上にまで定義されました

148
00:09:23,000 --> 00:09:28,000
私達に0から25の範囲での値を与えるために起こっていること、

149
00:09:28,000 --> 00:09:30,000
そして我々はその背中にスケールアップするための方法が必要

150
00:09:30,000 --> 00:09:32,000
そしてそれ適切なASCII範囲内の取得します。

151
00:09:32,000 --> 00:09:36,000
行う最も簡単な方法は、ちょうどすべてをスケールダウンすることである

152
00:09:36,000 --> 00:09:39,000
0から25の範囲に、始めに

153
00:09:39,000 --> 00:09:43,000
それから、末尾にすべてのファイルのバックアップを作成するシフト。

154
00:09:43,000 --> 00:09:46,000
>> 私は人々が陥る見たもう一つの一般的なエラーがある

155
00:09:46,000 --> 00:09:50,000
あなたは実際にすぐにこのスケーリングをしない場合

156
00:09:50,000 --> 00:09:53,000
と、言うには、一緒にメッセージとキーを追加し、それらを追加する

157
00:09:53,000 --> 00:09:58,000
char型の変数は、その問題に

158
00:09:58,000 --> 00:10:01,000
あるメッセージから[i]を開始するための、比較的大きな数であると、

159
00:10:01,000 --> 00:10:05,000
それは大文字の文字であればそれは少なくとも65であることを忘れないで

160
00:10:05,000 --> 00:10:09,000
あなたは、大きな鍵と言う、100のような何かを持っていたら、

161
00:10:09,000 --> 00:10:13,000
とあなたがオーバーフローを取得するつもりだがsigned charに一緒にそれらの2を追加します。

162
00:10:13,000 --> 00:10:17,000
あなたは、127より大きいの値を取得するつもりだ

163
00:10:17,000 --> 00:10:22,000
これは、char型の変数が保持できる最大の値です。

164
00:10:22,000 --> 00:10:26,000
あなたが最初からそういったことをやってみたいと思いますなぜ、再び、それはです。

165
00:10:26,000 --> 00:10:29,000
一部の人々はif then elseやテストを行うことによって、そのケースを回避した

166
00:10:29,000 --> 00:10:33,000
それがオーバーフローした場合、その作業を行う前に確認するには、

167
00:10:33,000 --> 00:10:36,000
しかし、この方法は、その回避しています。

168
00:10:36,000 --> 00:10:40,000
そして、このソリューションでは、我々は非常に最後に文字列全体をプリントアウト。

169
00:10:40,000 --> 00:10:45,000
他の人々は一度に1文字をプリントアウト。どちらも、素晴らしいです。

170
00:10:45,000 --> 00:10:51,000
この時点で、君たちはどんな質問、これについて何かコメントはありますか？

171
00:10:51,000 --> 00:10:56,000
あなたが好きなもの、あなたが好きではないもの？

172
00:10:56,000 --> 00:10:58,000
>> 私は疑問を持っていた。

173
00:10:58,000 --> 00:11:01,000
たぶん私はあなたの説明の間にそれを逃したが、どのようにこのプログラム

174
00:11:01,000 --> 00:11:07,000
テキストの長さにキーを接続するためのスペースを無視？

175
00:11:07,000 --> 00:11:10,000
これはただのシーザー暗号です。>>ああ、ごめん、うん。

176
00:11:10,000 --> 00:11:13,000
ええ、私たちはそれを見ることができます。

177
00:11:13,000 --> 00:11:16,000
シーザー暗号では我々は回避したので、

178
00:11:16,000 --> 00:11:18,000
我々は唯一の文字を反転します。

179
00:11:18,000 --> 00:11:27,000
彼らは大文字または小文字であった場合、我々はそれらだけを回転させる。

180
00:11:27,000 --> 00:11:32,000
君たちはこれについて、かなり良い感じ？

181
00:11:32,000 --> 00:11:34,000
このホームをコピーしてお気軽に、それを取る

182
00:11:34,000 --> 00:11:37,000
あなたたちが書いたものと比較します。

183
00:11:37,000 --> 00:11:42,000
間違いなくあまりにもそれについての質問を送って自由に感じる。

184
00:11:42,000 --> 00:11:46,000
そして再び、あなたの問題を持つここでの目標は設定していることを実現

185
00:11:46,000 --> 00:11:50,000
あなたたちは、あなたの問題セットに最適なコードを書いてもらうことはありません。

186
00:11:50,000 --> 00:11:57,000
それは、学習経験だ。うん。

187
00:11:57,000 --> 00:12:01,000
>> 戻るためにループしながら、それがnullに等しい場合、

188
00:12:01,000 --> 00:12:06,000
ので、nullがちょうど何の意味もありません、彼らは単にEnterを打つ？

189
00:12:06,000 --> 00:12:12,000
nullの場合は、特別なポインタ値です

190
00:12:12,000 --> 00:12:17,000
我々が言いたいとき、私たちはnullを使用

191
00:12:17,000 --> 00:12:23,000
我々は何を指しているポインタ変数を持っています。

192
00:12:23,000 --> 00:12:28,000
それで、一般的に、それはつまり、この変数は、このメッセージの変数

193
00:12:28,000 --> 00:12:35,000
我々はCS50特殊文字列型を使用しているため、ここでは空であり、

194
00:12:35,000 --> 00:12:37,000
CS50文字列型は何ですか？

195
00:12:37,000 --> 00:12:42,000
あなたは、ダビデが戻って講義中にフードを引っ張ったときに、それが何であるかを見たことがありますか？

196
00:12:42,000 --> 00:12:44,000
それはファンキーなそれはだポインタ、右ですか？

197
00:12:44,000 --> 00:12:48,000
大丈夫、うん。>>それはchar *です。

198
00:12:48,000 --> 00:12:52,000
それで、本当に我々はこれを置き換えることができます

199
00:12:52,000 --> 00:12:56,000
右ここでchar *のメッセージとともに、

200
00:12:56,000 --> 00:13:04,000
などGetStringメソッド機能、それが正常にユーザから文字列を取得していない場合、

201
00:13:04,000 --> 00:13:08,000
それは文字列、それが文字列を解析することはできません1つのケースを解析することはできません

202
00:13:08,000 --> 00:13:11,000
ファイルの文字、コントロールD、の終わりには、ユーザーの種類場合です

203
00:13:11,000 --> 00:13:17,000
どちらが一般的に行うものではありませんが、それが発生した場合

204
00:13:17,000 --> 00:13:20,000
この関数は口癖のように、このNULL値が返されます

205
00:13:20,000 --> 00:13:23,000
"ねえ、私は、文字列を取得できませんでした。"

206
00:13:23,000 --> 00:13:27,000
我々はメッセージ= nullを入れていない場合はどう、どうなるでしょう

207
00:13:27,000 --> 00:13:30,000
我々はまだやっていないことを何かがいるのですか？

208
00:13:30,000 --> 00:13:32,000
なぜそれがここでの問題でしょうか？

209
00:13:32,000 --> 00:13:38,000
私は、我々はメモリリークについての講義で少し話していることを知っているので。

210
00:13:38,000 --> 00:13:42,000
うん、そんなこと、そして何が起こるか見てみましょう。

211
00:13:42,000 --> 00:13:44,000
>> バジルの質問は、私たちが実際に持っていないとどうなるかだった

212
00:13:44,000 --> 00:13:48,000
このメッセージ= nullのテスト？

213
00:13:48,000 --> 00:13:51,000
一番上までスクロールしましょう​​。

214
00:13:51,000 --> 00:13:53,000
君たちは、この行をコメントアウトして下さい。

215
00:13:53,000 --> 00:13:55,000
実は、私は改正に保存します。

216
00:13:55,000 --> 00:13:58,000
これは、リビジョン3になります。

217
00:13:58,000 --> 00:14:02,000
あなたがこのプログラムを実行するために行う必要があるでしょうと、あなたはここまで、この歯車のアイコンをクリックする必要がありますです

218
00:14:02,000 --> 00:14:04,000
そして、あなたはそれに引数を追加する必要があります。

219
00:14:04,000 --> 00:14:10,000
我々は、コマンドライン引数を渡したいので、あなたはそれをkey引数を与えなければならないでしょう。

220
00:14:10,000 --> 00:14:13,000
ここで私はそれを数字の3を与えるつもりだ。私は3が好きです。

221
00:14:13,000 --> 00:14:19,000
さて、戻ってズームアウトプログラムを実行している。

222
00:14:19,000 --> 00:14:24,000
これは、構築、コンパイル、実行している。

223
00:14:24,000 --> 00:14:27,000
ここに私達は行く。これは、プロンプトが表示されるのを待っている。

224
00:14:27,000 --> 00:14:33,000
私は、hello-それは行かなかったような何かを入力すると？

225
00:14:33,000 --> 00:14:38,000
ああ、私のプログラムを実行するには時間がかかりすぎた。私はあまりにも長い間jawingた。

226
00:14:38,000 --> 00:14:40,000
ここに行く。

227
00:14:40,000 --> 00:14:43,000
今、私はハローに入力します。

228
00:14:43,000 --> 00:14:46,000
我々は、それが適切に暗号化していることがわかります。

229
00:14:46,000 --> 00:14:52,000
我々は、nullを返すようにプロンプ​​トがGetStringメソッドをすれば今何が起こりますか？

230
00:14:52,000 --> 00:14:57,000
覚えておいて、私たちは同時にコントロールDキーを押していることをしたと語った。

231
00:14:57,000 --> 00:14:59,000
私はここで上にスクロールします。我々は再びそれを実行することになるでしょう。

232
00:14:59,000 --> 00:15:01,000
建物。そこに行く。

233
00:15:01,000 --> 00:15:04,000
今、私はコントロールDを打ったとき

234
00:15:04,000 --> 00:15:12,000
私は、セグメンテーションフォールトをopt/sandbox50/bin/run.sh言うこの線を得た。

235
00:15:12,000 --> 00:15:15,000
君たちは、その前に見たことがありますか？

236
00:15:15,000 --> 00:15:17,000
>> [学生]なぜ無>>申し訳ありませんがありますか？

237
00:15:17,000 --> 00:15:20,000
[学生]なぜこの場合にはコアダンプがないのでしょうか？

238
00:15:20,000 --> 00:15:26,000
コア·ダンプは-ここにありなしコアダンプである理由疑問がありますか？

239
00:15:26,000 --> 00:15:29,000
質問があるかもしれないことであるが、コア·ダンプがファイルである

240
00:15:29,000 --> 00:15:31,000
それは、ハードドライブ上に保存されます。

241
00:15:31,000 --> 00:15:34,000
このケースでは、コアダンプを無効にしました

242
00:15:34,000 --> 00:15:37,000
実行サーバ上で我々は、断層はseg人々を持っていないように

243
00:15:37,000 --> 00:15:40,000
とコアダンプのトンを構築する。

244
00:15:40,000 --> 00:15:46,000
しかし、あなたは1を得ることができます。

245
00:15:46,000 --> 00:15:48,000
コア·ダンプは、あなたが頻繁に無効にすることができるものの夫婦です

246
00:15:48,000 --> 00:15:52,000
そして時にはその必要があります。

247
00:15:52,000 --> 00:15:55,000
セグメンテーションフォルト、あなたの質問に答えるために、バジル、

248
00:15:55,000 --> 00:16:00,000
我々はポインタにアクセスしようとしたことを言っている

249
00:16:00,000 --> 00:16:05,000
それは何を指すように設定されていませんでした。

250
00:16:05,000 --> 00:16:09,000
BINKYがし​​ようとしたときにビデオにBINKY覚えている

251
00:16:09,000 --> 00:16:12,000
何を指していないポインタにアクセスしに行く？

252
00:16:12,000 --> 00:16:16,000
この場合において、私は技術的にポインタが何を指していると思います。

253
00:16:16,000 --> 00:16:20,000
それは技術的に0であるヌル、、を指している

254
00:16:20,000 --> 00:16:25,000
それは、アクセスできないセグメントになるように定義され

255
00:16:25,000 --> 00:16:28,000
あなたのプログラムで、そのため、セグメンテーションフォールトを取得

256
00:16:28,000 --> 00:16:31,000
有効なセグメントでのメモリにアクセスしていないので

257
00:16:31,000 --> 00:16:38,000
ヒープセグメントまたはスタック·セグメントまたはデータ·セグメントのような。

258
00:16:38,000 --> 00:16:40,000
クール。

259
00:16:40,000 --> 00:16:48,000
シーザーについて、これ以上の質問は？

260
00:16:48,000 --> 00:16:51,000
>> のは、先に進みましょう。本当にすぐにリビジョン2を見てみましょう。

261
00:16:51,000 --> 00:17:00,000
それはVigenèreだ。

262
00:17:00,000 --> 00:17:04,000
ここでVigenère

263
00:17:04,000 --> 00:17:06,000
私たちは、再び、のでかなり早く、このいずれかを介して歩くよ

264
00:17:06,000 --> 00:17:10,000
Vigenèreとシーザーはよく似ています。

265
00:17:10,000 --> 00:17:12,000
ヘッダコメントは、前にある

266
00:17:12,000 --> 00:17:17,000
これらのマジックナンバーを使用しないようにする前に＃defineはある。

267
00:17:17,000 --> 00:17:21,000
良い点は、我々は移動したいと言っている

268
00:17:21,000 --> 00:17:23,000
そのような別のアルファベットか何か。

269
00:17:23,000 --> 00:17:26,000
のではなくすべての26のコードの変更を手動で移動すること

270
00:17:26,000 --> 00:17:30,000
我々は27にこれを変更したり、それをドロップする可能性が

271
00:17:30,000 --> 00:17:34,000
我々は、異なるアルファベット、異なる言語を使用していた場合。

272
00:17:34,000 --> 00:17:38,000
再び、我々は、引き数の場合は、このチェックを持っている

273
00:17:38,000 --> 00:17:42,000
そして実際にあなたはほとんどテンプレートとして、これを取ることができます。

274
00:17:42,000 --> 00:17:46,000
あなたが書くほとんどすべてのプログラムが持っている必要があります - 

275
00:17:46,000 --> 00:17:50,000
それは、コマンドライン引数-いくつかの行のシーケンスを取る場合

276
00:17:50,000 --> 00:17:55,000
それは冒頭でこのように読める。

277
00:17:55,000 --> 00:17:59,000
それはあなたが最初にしたい健全性テストの一つです。

278
00:17:59,000 --> 00:18:03,000
>> ここで我々が​​何をしたか私たちはそのことを確認しました

279
00:18:03,000 --> 00:18:06,000
キーワードは、有効であり、それは我々がやったことを再度確認しました。

280
00:18:06,000 --> 00:18:11,000
我々はargcおよび2からこれを分離したことに再度注意してください。

281
00:18:11,000 --> 00:18:14,000
この場合、我々がしなければならなかったことが一つではなく、あったことに注意してください

282
00:18:14,000 --> 00:18:18,000
iに使用するのでは、我々は、文字列全体を検証したかった

283
00:18:18,000 --> 00:18:21,000
そしてあなたが実際に文字単位で行かなければならないことを行うために

284
00:18:21,000 --> 00:18:23,000
文字列の上。

285
00:18:23,000 --> 00:18:29,000
その上に何かを呼び出すためには良い方法はありません

286
00:18:29,000 --> 00:18:31,000
さえなぜなら、例えば、iに0を返します

287
00:18:31,000 --> 00:18:37,000
それは整数を解析できない場合であっても動作しないように。

288
00:18:37,000 --> 00:18:42,000
繰り返しになりますが、素敵なメッセージは何が起こったかを正確にユーザに通知する。

289
00:18:42,000 --> 00:18:45,000
その後、ここで、再び、我々はまた、ケースを扱う場所

290
00:18:45,000 --> 00:18:50,000
制御Dランダムな文字でユーザータイプ。

291
00:18:50,000 --> 00:18:54,000
>> そして、シャーロットは、我々はスペースをスキップするように管理する方法については、以前の質問があった

292
00:18:54,000 --> 00:18:57,000
ここで我々の文字列インチ

293
00:18:57,000 --> 00:19:00,000
これは、我々はMyspaceのプログラムで行ったのと同じようなのようなものだった

294
00:19:00,000 --> 00:19:04,000
私たちは、セクションで行っており、この方法は、働いたこと

295
00:19:04,000 --> 00:19:08,000
我々は我々が見たいという文字の数を追跡したということです。

296
00:19:08,000 --> 00:19:13,000
我々が文字で文字の上に歩いている私たちは、メッセージ文字列の上に歩いていると、

297
00:19:13,000 --> 00:19:16,000
我々は、ループのための私達の一部として索引を追跡し、我々はまた、追跡

298
00:19:16,000 --> 00:19:21,000
文字の数なので、非特殊文字は、数字以外の、非空白

299
00:19:21,000 --> 00:19:27,000
我々は独立した変数で見られると思います。

300
00:19:27,000 --> 00:19:33,000
そして、この解決策は、キーを修正

301
00:19:33,000 --> 00:19:41,000
実際のキーの整数を取得し、それはその場でそれを行うためには、

302
00:19:41,000 --> 00:19:47,000
それは、実際のメッセージの文字を暗号化するために行く直前。

303
00:19:47,000 --> 00:19:50,000
あまりにも完璧に素晴らしかった、いくつかの解決策があります。

304
00:19:50,000 --> 00:19:58,000
鍵の妥当性をテストするとき、それは鍵を変更するでしょう。

305
00:19:58,000 --> 00:20:01,000
確実に加えて、その文字とキーワード

306
00:20:01,000 --> 00:20:05,000
英字は、それはまた、その整数になっていた

307
00:20:05,000 --> 00:20:13,000
0から25の範囲で、次にこのforループの後のことをしなければならないことをスキップする。

308
00:20:13,000 --> 00:20:18,000
繰り返しになりますが、あなたはここを参照してください、これは本当にまったく同じコードである

309
00:20:18,000 --> 00:20:22,000
我々はこの時点ではシーザーで使用されている。

310
00:20:22,000 --> 00:20:25,000
あなたは、まったく同じことをやっているので、本当のトリックは見つけ出すことです

311
00:20:25,000 --> 00:20:30,000
整数にキーワードを有効にする方法。

312
00:20:30,000 --> 00:20:35,000
>> 我々は少し濃厚ですがここにいたことの一つ

313
00:20:35,000 --> 00:20:39,000
我々はこのフレーズを繰り返しですが、私は、あなたがそれを呼び出すことができると思います

314
00:20:39,000 --> 00:20:45,000
ライン58、59、および61の3回に分け。

315
00:20:45,000 --> 00:20:52,000
誰かが、まさにこの言葉が何をするのか説明できますか？

316
00:20:52,000 --> 00:20:55,000
あなたが言ったようにそれは、文字にアクセスしている。

317
00:20:55,000 --> 00:20:59,000
ええ、それは、キーワードの[聞こえない]の文字です

318
00:20:59,000 --> 00:21:04,000
あなただけに沿って移動しているので、ので、それは見られる文字の数だ

319
00:21:04,000 --> 00:21:06,000
あなたは手紙を見てきましたら、キーワード、

320
00:21:06,000 --> 00:21:10,000
そう効果的にスペースやそのようなものをスキップするつもりだ。

321
00:21:10,000 --> 00:21:12,000
ええ、その通りです。

322
00:21:12,000 --> 00:21:16,000
あなたの周りに戻って移動するようにしてから、一度あなたが単にMODキーワードを空白にして見てきました。

323
00:21:16,000 --> 00:21:18,000
その通りです。それは完璧な説明を示します。

324
00:21:18,000 --> 00:21:23,000
何ケビンが言ったことは我々がキーワードにインデックスを作成するということです。

325
00:21:23,000 --> 00:21:28,000
可能ならば、我々は、num_letters_seen文字​​を取得したい

326
00:21:28,000 --> 00:21:32,000
しかしnum_letters_seenは、キーワードの長さを超えた場合、

327
00:21:32,000 --> 00:21:37,000
我々は適切な範囲に戻ってくる方法は、我々はmod演算子を使用することです

328
00:21:37,000 --> 00:21:40,000
効果的にラップアラウンドします。

329
00:21:40,000 --> 00:21:43,000
たとえば、短いのように、私たちのキーワードは、ベーコンです

330
00:21:43,000 --> 00:21:46,000
そしてそれは5文字長いです。

331
00:21:46,000 --> 00:21:50,000
しかし、我々は、この時点で私たちのプレーンテキストで6文字を見てきました

332
00:21:50,000 --> 00:21:52,000
と暗号化された6。

333
00:21:52,000 --> 00:21:57,000
我々は、num_letters_seenにアクセスすることになります

334
00:21:57,000 --> 00:22:00,000
これは、キーワードのmod長さ、5、6です

335
00:22:00,000 --> 00:22:04,000
それで我々は1を取得し、私たちは何をしようと我々はよですよ

336
00:22:04,000 --> 00:22:14,000
その時点で私達のキーワードの最初の文字の内部にアクセスすることができます。

337
00:22:14,000 --> 00:22:21,000
>> すべての権利、Vigenère上の任意の質問

338
00:22:21,000 --> 00:22:26,000
我々は、移動する前に？

339
00:22:26,000 --> 00:22:31,000
君たちはこれについて、かなり良い感じ？

340
00:22:31,000 --> 00:22:35,000
偉大な、クール。

341
00:22:35,000 --> 00:22:38,000
私は君たちがコードを見る機会を得ていることを確認したい

342
00:22:38,000 --> 00:22:48,000
我々はよさそうだと思うし、そこから学ぶ機会を持っていること。

343
00:22:48,000 --> 00:22:53,000
これは、我々は、当分の間はスペースを使用することがあります最後になるだろう

344
00:22:53,000 --> 00:22:59,000
私たちは今、移行するつもりだ、と私はcs50.net/lecturesに行くつもりです

345
00:22:59,000 --> 00:23:06,000
従って私達はクイズレビューの少し​​を行うことができます。

346
00:23:06,000 --> 00:23:10,000
私はクイズのレビューをやって起動すると思う最良の方法

347
00:23:10,000 --> 00:23:15,000
この講義のページに来ることになっている、cs50.net/lectures、

348
00:23:15,000 --> 00:23:20,000
そして週の見出しの下に各ので、私は、0週でここ見れば

349
00:23:20,000 --> 00:23:27,000
私は、我々は0週で扱ったトピックのリストを持っていることがわかります。

350
00:23:27,000 --> 00:23:31,000
>> これらのトピックのいずれかがあなたに慣れていないと思われる場合

351
00:23:31,000 --> 00:23:34,000
あなたは間違いなく戻って講義ノートを徹底的に調査したいとことによるとします

352
00:23:34,000 --> 00:23:39,000
したい場合でも、講義を流し読み、再びそれらを見る

353
00:23:39,000 --> 00:23:44,000
これらのトピックのそれぞれで何が起こっているかの感触を得ることができます。

354
00:23:44,000 --> 00:23:49,000
私は、さらに我々が持っているクールなリソースの今年1を言うだろう

355
00:23:49,000 --> 00:23:55,000
我々が作成したこれらのショートパンツです、あなたは0週を見れば、

356
00:23:55,000 --> 00:24:00,000
、我々は、すべてのトピックがカバーされていないが、我々はそれらのかなりの数を持っている

357
00:24:00,000 --> 00:24:03,000
ので、もう一度これらのパンツを見てトリッキーなもののいくつか、

358
00:24:03,000 --> 00:24:08,000
高速化するためにあなたを取得するための良い方法です。

359
00:24:08,000 --> 00:24:15,000
特に、私は私がそれらをやっているので、底に3用プラグに入れてするつもりです。

360
00:24:15,000 --> 00:24:20,000
しかし、あなたがバイナリ、ビット、六角、スタッフのようなもので苦労しているならば、

361
00:24:20,000 --> 00:24:22,000
バイナリが開始するのに最適な場所です。

362
00:24:22,000 --> 00:24:25,000
ASCIIはあまりにも見ることが良いことだ別の1つです。

363
00:24:25,000 --> 00:24:31,000
私はあなたのためにあまりにも遅いつもりなら、あなたも1.5倍の速度で私を見ることができます。

364
00:24:31,000 --> 00:24:35,000
それのレビュー以来、それをすること自由に感じなさい。

365
00:24:35,000 --> 00:24:40,000
>> 本当に迅速に開始するために、我々はこれらのクイズの問題のいくつかを使用して行くつもり

366
00:24:40,000 --> 00:24:44,000
ちょうどすぐにこれらを通じて解約する。

367
00:24:44,000 --> 00:24:50,000
例えば、私はボードの上で右ここまで持っていることを問題16を見てみましょう。

368
00:24:50,000 --> 00:24:54,000
我々は、バイナリでは、この次の計算式を持っている

369
00:24:54,000 --> 00:24:56,000
そして我々はすべての作業を見せてあげたい。

370
00:24:56,000 --> 00:24:59,000
さて、私はこの打撃を与えるつもりです。

371
00:24:59,000 --> 00:25:01,000
君たちは、紙と一緒に従うべきである

372
00:25:01,000 --> 00:25:04,000
そして我々はすぐに実際にこれをやる。

373
00:25:04,000 --> 00:25:06,000
我々はバイナリで、次の計算を実行したい。

374
00:25:06,000 --> 00:25:16,000
私は00110010を持っている。

375
00:25:16,000 --> 00:25:27,000
そして、私はそれに00110010を追加するつもりです。

376
00:25:27,000 --> 00:25:30,000
自宅に一緒に以下の数学の天才のために、

377
00:25:30,000 --> 00:25:35,000
これは効果的に2を乗じている。

378
00:25:35,000 --> 00:25:37,000
始めましょう。

379
00:25:37,000 --> 00:25:39,000
我々は、我々が行うのと同じ加算アルゴリズムに従うつもり

380
00:25:39,000 --> 00:25:43,000
私たちは一緒に十進数を追加するとき。

381
00:25:43,000 --> 00:25:46,000
本当にここの唯一の違いは、バックの周りに、我々はループです

382
00:25:46,000 --> 00:25:51,000
我々は10に到達一度一度我々は、1 + 1の代わりを持っています。

383
00:25:51,000 --> 00:25:53,000
>> 我々は本当にすぐに、右から開始する場合、何が最初の数字ですか？

384
00:25:53,000 --> 00:25:55,000
[学生] 0 >> [ネイトH.] 0。

385
00:25:55,000 --> 00:25:58,000
偉大な、2桁目？

386
00:25:58,000 --> 00:26:00,000
[学生] 1。

387
00:26:00,000 --> 00:26:02,000
[ネイトH.]それは1か？ 1 +1は何ですか？

388
00:26:02,000 --> 00:26:04,000
[学生] 10。

389
00:26:04,000 --> 00:26:08,000
[ネイトH.]正確には、私が一緒に追加されたもの2真下書いた数字だから何ですか？

390
00:26:08,000 --> 00:26:11,000
次に、[学生] 1,0、または0と1を運ぶ。

391
00:26:11,000 --> 00:26:15,000
[ネイトH.] 0と正確に、1を運ぶ。

392
00:26:15,000 --> 00:26:18,000
次の1まで、バジルは、最大だ。

393
00:26:18,000 --> 00:26:20,000
第三は何ですか？>> [バジル] 1。

394
00:26:20,000 --> 00:26:23,000
[ネイト·H] 1、完璧。ケビン？

395
00:26:23,000 --> 00:26:27,000
[ケビン] 0 >> [ネイト·H] 0、シャーロット？

396
00:26:27,000 --> 00:26:30,000
[シャルロット] 0 >> [ネイトH.]ええ、私は何をすればいいですか？

397
00:26:30,000 --> 00:26:32,000
[学生] 1。

398
00:26:32,000 --> 00:26:34,000
[ネイトH.]そして、私は何をすればいいですか？そして私は1を運ぶ。

399
00:26:34,000 --> 00:26:36,000
パーフェクト、Sahb？>> [Sahb]今あなたが1を持っています。

400
00:26:36,000 --> 00:26:40,000
[ネイトH.]そして、私はここでは何をしますか？

401
00:26:40,000 --> 00:26:43,000
[Sahb]次に、1の上まで運ばれたために1を持って次のいずれかの。

402
00:26:43,000 --> 00:26:49,000
[ネイトH.]グレートので、ここで我々はそれを仕上げることができます。

403
00:26:49,000 --> 00:26:51,000
クール。

404
00:26:51,000 --> 00:26:54,000
[学生] 0 + 0 = 0としていますか？

405
00:26:54,000 --> 00:26:56,000
0 + 0 = 0。

406
00:26:56,000 --> 00:27:01,000
1 + 1は、あなたが言ったように、0 10、または1であり、むしろ。

407
00:27:01,000 --> 00:27:07,000
10は私に10は番号10を意味するので、誤った呼称である、

408
00:27:07,000 --> 00:27:12,000
そしてそれは我々がそれを書いているときに我々はそれを表している方法の気まぐれだ。

409
00:27:12,000 --> 00:27:20,000
私たちは、1、0で番号2を表し、数字の10は若干異なります。

410
00:27:20,000 --> 00:27:23,000
>> バイナリについての素晴らしいの一種は何でしょう本当にその多くはそこにはないということです

411
00:27:23,000 --> 00:27:25,000
あなたが学ぶ必要がある例。

412
00:27:25,000 --> 00:27:30,000
0 + 0 = 0、0 +1 = 1は、あります

413
00:27:30,000 --> 00:27:34,000
1 +1は0になり、その後、1を運ぶ

414
00:27:34,000 --> 00:27:37,000
そして、あなたは右から3番目のカラムにここで見ることができる

415
00:27:37,000 --> 00:27:40,000
我々はこの1、1、1を持っていた。

416
00:27:40,000 --> 00:27:43,000
と1 + 1 + 1が1である

417
00:27:43,000 --> 00:27:45,000
と、別の1を運ぶ。

418
00:27:45,000 --> 00:27:48,000
もしバイナリ加算をやっているときに、非常にシンプル。

419
00:27:48,000 --> 00:27:51,000
私は正気では自分自身をチェックするためにこれらのカップルより多くを行うと思います

420
00:27:51,000 --> 00:27:54,000
あなたは、これがあるために行く前に

421
00:27:54,000 --> 00:28:00,000
おそらく我々はクイズで見てくれることでしょう。

422
00:28:00,000 --> 00:28:03,000
今だけでなく、この次のいずれかの操作を実行してみましょう。

423
00:28:03,000 --> 00:28:06,000
問題17を実行してみましょう。

424
00:28:06,000 --> 00:28:12,000
我々は、小数に以下のバイナリ数値を変換しようとしている。

425
00:28:12,000 --> 00:28:28,000
私は10100111001を持っている。

426
00:28:28,000 --> 00:28:33,000
私がしたことはバイナリビデオで覚えている

427
00:28:33,000 --> 00:28:36,000
私は例のカップルを通って歩いて、私は方法を示しました

428
00:28:36,000 --> 00:28:41,000
あなたは小数でそれをやっているときに、すべてが動作します。

429
00:28:41,000 --> 00:28:45,000
あなたは十進表現で作業しているとき、私は、我々がいると思う

430
00:28:45,000 --> 00:28:48,000
そのことで私たちの生活の中で、この時点でとても流暢

431
00:28:48,000 --> 00:28:53,000
それが実際にどのように動作するかの仕組みをうまく取り繕うことは非常に簡単です。

432
00:28:53,000 --> 00:28:59,000
>> しかし、私は番号137を持っている場合、簡単にまとめを行うこと

433
00:28:59,000 --> 00:29:06,000
これは本当に意味と再び、これは10進数で表現され、

434
00:29:06,000 --> 00:29:19,000
進数で数値137は、私が1×100 + 3×10 + 7×1を持っていることを意味します。

435
00:29:19,000 --> 00:29:22,000
これは、すべての画面上に滞在している。

436
00:29:22,000 --> 00:29:29,000
それから、あなたはちょうどここにこれらの数字を見れば、

437
00:29:29,000 --> 00:29:34,000
100、10、1、あなたは、彼らが実際に10のすべての力だということを参照してください。

438
00:29:34,000 --> 00:29:43,000
私は、10㎡、10¹、ゼロ〜10を持っています。

439
00:29:43,000 --> 00:29:48,000
我々は、バイナリ内のものの類似の並べ替えを持っている

440
00:29:48,000 --> 00:29:55,000
ことを除いて我々の基地は、我々はそれを呼び出すように、10の2の代わりになります。

441
00:29:55,000 --> 00:29:58,000
私は一番下にここに書き留めておいたこれらの10S、

442
00:29:58,000 --> 00:30:02,000
この10㎡、10¹、ゼロ、10から10までは、私たちの拠点となってい

443
00:30:02,000 --> 00:30:08,000
と指数、0、1、2のいずれか、

444
00:30:08,000 --> 00:30:14,000
私たちが書いた数の桁の位置が示されている。

445
00:30:14,000 --> 00:30:21,000
我々はそれを見れば1日、この1は第二の位置にある。

446
00:30:21,000 --> 00:30:27,000
3は、第一の位置にある、と7は0番目の位置にある。

447
00:30:27,000 --> 00:30:35,000
それは我々の拠点については、下記の様々な指数を得る方法です。

448
00:30:35,000 --> 00:30:40,000
>> このwe'll  - 実際に、すべての後、あなたは何を知っていますか？

449
00:30:40,000 --> 00:30:43,000
私たちは、私の元に戻すボタンがdo-どこへ行ったのでしょう？

450
00:30:43,000 --> 00:30:45,000
そこに行く。

451
00:30:45,000 --> 00:30:47,000
私はこの事を元に戻すことが大好きです。

452
00:30:47,000 --> 00:30:51,000
これに続いて私は、少なくとも私のためだと思う

453
00:30:51,000 --> 00:30:54,000
進数の変換を開始する最も簡単な方法

454
00:30:54,000 --> 00:30:57,000
baseが16進数または16進数

455
00:30:57,000 --> 00:31:02,000
と10または2ではない先に行くと、書き出すことです

456
00:31:02,000 --> 00:31:09,000
上部にある私の進数の数字のすべての拠点と指数。

457
00:31:09,000 --> 00:31:14,000
我々は、再び右に左から開始する場合、

458
00:31:14,000 --> 00:31:17,000
これは直感に反するの一種であり、

459
00:31:17,000 --> 00:31:23,000
私はここで黒に戻します、我々は、0番目の位置に2を持っている

460
00:31:23,000 --> 00:31:27,000
それから私達は2を持っています¹、2²、

461
00:31:27,000 --> 00:31:33,000
その後2〜3、2 4、2から5まで、6、

462
00:31:33,000 --> 00:31:39,000
7、8、9、10。

463
00:31:39,000 --> 00:31:41,000
私が書いたこれらの数字は、すべての指数です。

464
00:31:41,000 --> 00:31:48,000
私はちょうどスペースの最初の3でここに拠点を書きました。

465
00:31:48,000 --> 00:31:50,000
>> この時点で私は先に行くつもりだと私は実際に消去するつもりです

466
00:31:50,000 --> 00:31:53,000
それは大丈夫だ場合、我々は、小数でやったもの。

467
00:31:53,000 --> 00:31:57,000
あなたはすべてのことを持っている。

468
00:31:57,000 --> 00:32:05,000
私は確信してオンラインで見ているあなたの人々は、あなたが好きなら、私を巻き戻すことができるようになります。

469
00:32:05,000 --> 00:32:07,000
ペンに切り替える。

470
00:32:07,000 --> 00:32:12,000
今、私たちがやる - をした場合何ができるかあなたたちが2のあなたの力でスピードアップすることが全くありませんが、

471
00:32:12,000 --> 00:32:15,000
それは完全にクールだ。

472
00:32:15,000 --> 00:32:18,000
それは起こる。分かりました。

473
00:32:18,000 --> 00:32:23,000
私は私が2のすべての力を知っている必要がありますと言われましたここで私は一度就職の面接がありました

474
00:32:23,000 --> 00:32:26,000
最大2〜30日まで。

475
00:32:26,000 --> 00:32:29,000
それは、私が得た仕事ではなかった。

476
00:32:29,000 --> 00:32:32,000
、とにかく、君たちは先に行くことができ、ここで数学を行う

477
00:32:32,000 --> 00:32:35,000
ですが、バイナリで、それは本当に、意味がありません

478
00:32:35,000 --> 00:32:38,000
そしてまたそれは、10進数または16進数で意味がありません

479
00:32:38,000 --> 00:32:43,000
あなたがゼロを持ってどこに数学を行う。

480
00:32:43,000 --> 00:32:49,000
あなたは、私はここ、ここ、ここ、ここ、ここ、ここ0 0 0 0 0 0を持って見ることができます。

481
00:32:49,000 --> 00:32:52,000
なぜそれが実際の数学をやっても意味がないかもしれません

482
00:32:52,000 --> 00:32:56,000
その位置に2の適切な電力を計算するために？

483
00:32:56,000 --> 00:32:59,000
シャーロットが言ったように正確に、それが0になります。

484
00:32:59,000 --> 00:33:05,000
2のべき乗を計算する場合だけでなく、自分の時間を節約するかもしれないあなたの強いスーツではありません。

485
00:33:05,000 --> 00:33:10,000
この場合、我々は唯一の0から2のためにそれを計算する必要がある - ？

486
00:33:10,000 --> 00:33:12,000
[学生] 1。

487
00:33:12,000 --> 00:33:14,000
3〜[ネイト·H] 1、2です - ？

488
00:33:14,000 --> 00:33:16,000
[学生] 8。>> [ネイト·H] 8。

489
00:33:16,000 --> 00:33:18,000
2から4？

490
00:33:18,000 --> 00:33:21,000
[生徒] 2。私は、申し訳ありませんが1だ。

491
00:33:21,000 --> 00:33:26,000
[ネイト·H] 2〜4正確には、16です。

492
00:33:26,000 --> 00:33:28,000
5から2、ケビン？>> 32。

493
00:33:28,000 --> 00:33:32,000
[ネイトH.] 32、2〜8？

494
00:33:32,000 --> 00:33:38,000
[学生] 32×8、256。

495
00:33:38,000 --> 00:33:41,000
[ネイトH.]パーフ​​ェクト。

496
00:33:41,000 --> 00:33:43,000
と10から2？

497
00:33:43,000 --> 00:33:45,000
[学生] 1024。

498
00:33:45,000 --> 00:33:49,000
[ネイトH.]うん、1024。

499
00:33:49,000 --> 00:33:57,000
>> かつて我々は、我々はそれらをすべてまとめることができますこれらの数値を手に入れました。

500
00:33:57,000 --> 00:34:01,000
そして、これは、それが物事のカップルを行うことが本当に重要な場所です。

501
00:34:01,000 --> 00:34:07,000
一つはゆっくり行くとあなたの仕事をチェックすることです。

502
00:34:07,000 --> 00:34:10,000
あなたは、この番号の末尾に1があることを伝えることができます

503
00:34:10,000 --> 00:34:15,000
ので、私は間違いなく、私の結果として奇数を取得する必要があります

504
00:34:15,000 --> 00:34:18,000
他のすべてのものは、偶数になるだろうしているので、

505
00:34:18,000 --> 00:34:21,000
それは2進数だと与えられた。

506
00:34:21,000 --> 00:34:24,000
あなたはテストでこの点に着く場合の対処方法他の事はある

507
00:34:24,000 --> 00:34:27,000
、あなたがここまでそれを書きました

508
00:34:27,000 --> 00:34:30,000
、あなたは時間が不足している

509
00:34:30,000 --> 00:34:33,000
この問題は価値があるとの点の数を見てみましょう。

510
00:34:33,000 --> 00:34:40,000
この問題は、あなたが参照してください場合にすることができますので、私は本当に私のラップトップにバックフリップをすばやく-

511
00:34:40,000 --> 00:34:44,000
この問題は、2点の価値があるので、これはほかのソートではありません

512
00:34:44,000 --> 00:34:47,000
あなたは本当に時間に追われている場合は、経由して行く必要があります。

513
00:34:47,000 --> 00:34:52,000
しかし、我々はiPadに切り替えるだろう、と私たちは本当に速くそれを介して行くつもりです。

514
00:34:52,000 --> 00:34:54,000
>> 私は最初の小さな数字をやって好き

515
00:34:54,000 --> 00:34:56,000
私はそれが簡単に見つけるため。

516
00:34:56,000 --> 00:35:00,000
彼らはかなり簡単に一緒に行くので、私は32と8が好きで、我々は50を得る。

517
00:35:00,000 --> 00:35:03,000
16と1は17を取得します。

518
00:35:03,000 --> 00:35:05,000
そこでは、57を得る

519
00:35:05,000 --> 00:35:14,000
それから私達は、この残りの部分を行うことができますので、我々は、156〜57を行うことができます。

520
00:35:14,000 --> 00:35:16,000
さあ。

521
00:35:16,000 --> 00:35:19,000
男、まあ、見てみましょう。

522
00:35:19,000 --> 00:35:27,000
我々は、57、256、および1024を持っていた。

523
00:35:27,000 --> 00:35:31,000
この時点で、私はというだけで通過すると思います。

524
00:35:31,000 --> 00:35:35,000
私は手掛かりを持っていません。私は明らかに、この上に読んでする必要があります。

525
00:35:35,000 --> 00:35:40,000
7,6、および4には、17を得る。

526
00:35:40,000 --> 00:35:42,000
1、5、5、2、13。

527
00:35:42,000 --> 00:35:45,000
その後、我々は3を取得してから、我々は1を取得します。

528
00:35:45,000 --> 00:35:52,000
1337年。

529
00:35:52,000 --> 00:35:55,000
イースターエッグは、誰？

530
00:35:55,000 --> 00:35:59,000
誰かがこの番号を認識？

531
00:35:59,000 --> 00:36:02,000
クリスが数を認識します。それが何を意味するのでしょう、クリス？

532
00:36:02,000 --> 00:36:04,000
[クリス]リート。

533
00:36:04,000 --> 00:36:11,000
すご腕ので、あなたはこれを見れば、それはすご腕のように見えます。

534
00:36:11,000 --> 00:36:15,000
ハッカーのもの。中間試験やクイズではなく、上のもののようなものに気をつけろ。

535
00:36:15,000 --> 00:36:19,000
あなたがもののようなものを見て、あなたが迷っている場合、 "はぁ、"

536
00:36:19,000 --> 00:36:22,000
それは実際に何を意味するかもしれません。

537
00:36:22,000 --> 00:36:24,000
知りません。ダビデはそれをインチ入れて好き

538
00:36:24,000 --> 00:36:26,000
それは正気はそれをチェックするには良い方法だ。

539
00:36:26,000 --> 00:36:30,000
大丈夫のように、私は何が起こっているかを見ることができます。

540
00:36:30,000 --> 00:36:34,000
>> それは週1 0/Weekものだ。

541
00:36:34,000 --> 00:36:39,000
我々は今、私たちのラップトップに切り替えた場合、

542
00:36:39,000 --> 00:36:46,000
ズームアウトすると、他の物事のカップル。

543
00:36:46,000 --> 00:36:50,000
我々は問題セットでたくさんやってきた、これはASCIIあります。

544
00:36:50,000 --> 00:36:55,000
資本Aのこの概念は、本当に何ですか？

545
00:36:55,000 --> 00:36:57,000
それは10進数の整数です知っている。

546
00:36:57,000 --> 00:37:00,000
65は、それがASCIIテーブルでにマッピングされているものです

547
00:37:00,000 --> 00:37:03,000
そしてそれは、コンピュータがそれを書き込む方法ゆえだ

548
00:37:03,000 --> 00:37:06,000
そしてそれは我々が実際に書き込みを逃れてきた​​方法です

549
00:37:06,000 --> 00:37:09,000
と文字が小文字の資本

550
00:37:09,000 --> 00:37:14,000
これまで行なってきたことを、これらのソリューションと問題セットのいくつかのインチ

551
00:37:14,000 --> 00:37:16,000
他の物事のカップル。

552
00:37:16,000 --> 00:37:25,000
我々は、文、ブール式、条件、ループ、変数とスレッドを持っている。

553
00:37:25,000 --> 00:37:29,000
>> それらはすべてのほとんどの部分は意味があるように見える？

554
00:37:29,000 --> 00:37:35,000
この用語の中には時々少しファンキーです。

555
00:37:35,000 --> 00:37:46,000
私はセミコロンで終了し、ほとんどの部分の何かのためにのような文を考えるのが好きです。

556
00:37:46,000 --> 00:37:51,000
xのような文= 7、変数を設定し、

557
00:37:51,000 --> 00:37:54,000
おそらくx = 7で呼ばれる。

558
00:37:54,000 --> 00:38:01,000
おそらくxは、また7番を格納できる型です

559
00:38:01,000 --> 00:38:05,000
ので、それは、intやfloatまたは多分短絡やシャア

560
00:38:05,000 --> 00:38:07,000
そのような何か。

561
00:38:07,000 --> 00:38:12,000
ブール式は等しいこれらの二重を使用しています

562
00:38:12,000 --> 00:38:17,000
とビッグバンは、より大きい、より小さい、等しい、または等しくない

563
00:38:17,000 --> 00:38:22,000
より小さいか等しい、すべてのもののようなもの。

564
00:38:22,000 --> 00:38:28,000
条件ははif then else文です。

565
00:38:28,000 --> 00:38:32,000
私は、あなたがした場合に対応することなく、他のを持つことができないことを覚えているだろう。

566
00:38:32,000 --> 00:38:37,000
した場合に、対応がなければ、同様に、あなたは他のを持つことができません。

567
00:38:37,000 --> 00:38:40,000
ループが、我々はあなたに打ってきたループの3種類を思い出す

568
00:38:40,000 --> 00:38:43,000
セクションと問題セットの最後のカップルのために。

569
00:38:43,000 --> 00:38:46,000
使用してユーザー入力を取得しているときのwhile、do

570
00:38:46,000 --> 00:38:51,000
特定の条件が満たされるまで、whileループを使用して

571
00:38:51,000 --> 00:38:56,000
あなたがする必要がある場合、次にforループを使用してそれらの

572
00:38:56,000 --> 00:39:01,000
あなたは、私はそれについてどのように考えるかである現在の通貨ループのどの反復を知っています。

573
00:39:01,000 --> 00:39:07,000
あなたは、文字列内の各文字のためにやっている場合、または私が何かをしたい、

574
00:39:07,000 --> 00:39:15,000
私は、その要素に何かをしたい配列の各要素に対して。

575
00:39:15,000 --> 00:39:18,000
>> スレッドとイベント。

576
00:39:18,000 --> 00:39:21,000
これらは、我々は、C言語で、それを明確に説明していない

577
00:39:21,000 --> 00:39:23,000
しかし、スクラッチからこれを覚えています。

578
00:39:23,000 --> 00:39:26,000
これは、異なるスクリプトを持つことの概念である。

579
00:39:26,000 --> 00:39:32,000
これはまた、イベントをブロードキャストのこの概念です。

580
00:39:32,000 --> 00:39:37,000
一部の人々は、最初は自分たちのプロジェクトに放送を使用していませんでした

581
00:39:37,000 --> 00:39:40,000
これは、完全にクールです

582
00:39:40,000 --> 00:39:46,000
しかし、これらは、同時実行と呼ばれるこの大きな問題を扱う2つの異なる方法があります

583
00:39:46,000 --> 00:39:49,000
これは、どのようにプログラムが実行されるようになるんです

584
00:39:49,000 --> 00:39:54,000
または一見同時に実行？

585
00:39:54,000 --> 00:39:59,000
他のタスクも実行しているときに別のタスクが実行されている。

586
00:39:59,000 --> 00:40:01,000
これは、お使いのオペレーティングシステムが動作するように思われるかということです。

587
00:40:01,000 --> 00:40:04,000
これは、例えば、理由にもかかわらずである

588
00:40:04,000 --> 00:40:10,000
私が実行しているブラウザを持って、私はまた、Spotifyはオンにして曲を再生することができます。

589
00:40:10,000 --> 00:40:14,000
それは理解するための概念的なものなのです。

590
00:40:14,000 --> 00:40:17,000
私は短いのスレッドを見てみましょう

591
00:40:17,000 --> 00:40:21,000
あなたはそのことについてもっと知りたければ。

592
00:40:21,000 --> 00:40:26,000
>> 見てみましょう、私はそこにあったかもしれないと信じて

593
00:40:26,000 --> 00:40:31,000
これらのいずれかでこの上の問題。

594
00:40:31,000 --> 00:40:35,000
繰り返しますが、私は、スレッドとイベントは、我々はC言語でカバーするものではありませんだと思う

595
00:40:35,000 --> 00:40:41,000
それは、ゼロよりも有意に多くの困難だという理由だけで。

596
00:40:41,000 --> 00:40:44,000
あなたは、そこにそれを心配するが、間違いなく概念を理解しておくべきではありません

597
00:40:44,000 --> 00:40:47,000
何が起こっているか理解しています。

598
00:40:47,000 --> 00:40:52,000
先に進む前に、週についてご質問0材？

599
00:40:52,000 --> 00:40:55,000
みんながかなり良い感じ？

600
00:40:55,000 --> 00:41:03,000
理解の変数とどのような変数は何ですか？

601
00:41:03,000 --> 00:41:08,000
>> 上を移動する。週1。

602
00:41:08,000 --> 00:41:12,000
特にカバーされていないここで物事のカップル

603
00:41:12,000 --> 00:41:21,000
クイズのレビューで必ずしも、また考えることより概念的なものです。

604
00:41:21,000 --> 00:41:30,000
第一は、ソースコード、コンパイラ、オブジェクトコードが何であるかは、この概念です。

605
00:41:30,000 --> 00:41:32,000
誰？バジル。

606
00:41:32,000 --> 00:41:37,000
オブジェクトコード - 私は、ソースコードは、あなたが打ち鳴らすに入れたものであることを意味している

607
00:41:37,000 --> 00:41:42,000
とオブジェクトコードが打ち鳴らす、コンピュータがプログラムを読むことができるように出したものです。

608
00:41:42,000 --> 00:41:44,000
その通りです。

609
00:41:44,000 --> 00:41:47,000
ソースコードは、あなたが実際に入力したCコードです。

610
00:41:47,000 --> 00:41:50,000
オブジェクトコードを使用すると、ガチャンという音から抜け出すことです。

611
00:41:50,000 --> 00:41:54,000
それはバイナリ形式で、0と1です。

612
00:41:54,000 --> 00:41:59,000
あなたがオブジェクトファイルの束を持っているときに、次に何が起こるかである、

613
00:41:59,000 --> 00:42:04,000
あなたは、プロジェクトまたは複数のソースコードファイルを使用するプログラムをコンパイルしていると言う

614
00:42:04,000 --> 00:42:09,000
その慣例によりcファイルの拡張子が付与されます。

615
00:42:09,000 --> 00:42:13,000
我々はcaesar.c、vigenère.cを持っている理由です。

616
00:42:13,000 --> 00:42:18,000
Javaプログラムを書いている場合は、それらの拡張子を付ける。javaを。

617
00:42:18,000 --> 00:42:24,000
Pythonプログラムの拡張子は。しばしばPY。

618
00:42:24,000 --> 00:42:26,000
>> 一度に複数のcファイルを持って、あなたはそれらをコンパイルします。

619
00:42:26,000 --> 00:42:29,000
Clangのは、すべてこのバイナリジャンクを吐き出します。

620
00:42:29,000 --> 00:42:33,000
次に、あなたは1つだけのプログラムをしたいので、

621
00:42:33,000 --> 00:42:37,000
あなたは、これらのオブジェクトのすべてが一緒にファイルリンカリンクを持っている

622
00:42:37,000 --> 00:42:40,000
1実行ファイルに変換します。

623
00:42:40,000 --> 00:42:45,000
これは、CS50ライブラリを使用するときに、例えば起こることです。

624
00:42:45,000 --> 00:42:50,000
CS50ライブラリがあることでもあります。hヘッダファイル

625
00:42:50,000 --> 00:42:53,000
あなたがお読みになることを、＃includecs50.hこと。

626
00:42:53,000 --> 00:42:58,000
そしてそれはまた、特別なバイナリライブラリファイルだ

627
00:42:58,000 --> 00:43:02,000
それは、0と1であるコンパイルされている

628
00:43:02,000 --> 00:43:08,000
その-lフラグを、私達が私達のスペースに戻って、我々は本当にすぐに見えるので、もし

629
00:43:08,000 --> 00:43:11,000
私たちはカーンという音コマンドを見ればここで何が起こっているかで、

630
00:43:11,000 --> 00:43:15,000
私たちが持っていることは、これは右ここに私たちのソースコードファイルです。

631
00:43:15,000 --> 00:43:18,000
これらはコンパイラフラグの集まりです。

632
00:43:18,000 --> 00:43:22,000
そして、一番最後に、これらの-lフラグのリンク

633
00:43:22,000 --> 00:43:30,000
次に、これら2つのライブラリの実際のバイナリファイル、CS50ライブラリと数学ライブラリ。

634
00:43:30,000 --> 00:43:35,000
>> ファイル '目的の各タイプを理解する

635
00:43:35,000 --> 00:43:38,000
コンパイルプロセスであなたのことができるようにしたいと思うものです

636
00:43:38,000 --> 00:43:43,000
の少なくとも高レベルの概要を提供します。

637
00:43:43,000 --> 00:43:46,000
ソースコードは、オブジェクト·コードが出てくる出番。

638
00:43:46,000 --> 00:43:53,000
オブジェクトコードファイルは一緒にリンクして、あなたは美しい、実行可能なファイルを取得します。

639
00:43:53,000 --> 00:43:55,000
クール。

640
00:43:55,000 --> 00:43:58,000
あなたが複数のポイントでエラーを得ることができる場所でもあり

641
00:43:58,000 --> 00:44:00,000
コンパイルプロセスインチ

642
00:44:00,000 --> 00:44:04,000
ここで、例えば、あなたがこのリンクフラグを取る場合、これは

643
00:44:04,000 --> 00:44:10,000
あなたのコードを実行しているときCS50フラグ、あなたは、スペースでそれを省略するか、

644
00:44:10,000 --> 00:44:13,000
あなたは、リンクフェーズでエラーが出るところです

645
00:44:13,000 --> 00:44:18,000
とリンカはねえ、あなたは関数GetStringメソッドと呼ばれる "、と言うだろう

646
00:44:18,000 --> 00:44:20,000
それはCS50ライブラリにだ。 "

647
00:44:20,000 --> 00:44:25,000
"あなたはそれがCS50図書館にいた私に言った、私はそれのためのコードを見つけることができません。"

648
00:44:25,000 --> 00:44:28,000
あなたはそれをリンクする必要があります場所です、それは別だ

649
00:44:28,000 --> 00:44:33,000
コンパイラのエラーから、コンパイラが構文とかその種のを見ているので。

650
00:44:33,000 --> 00:44:38,000
それはときに何が起こっているか知って良いことだ。

651
00:44:38,000 --> 00:44:42,000
>> 知っておくと他のもの。

652
00:44:42,000 --> 00:44:49,000
私は、あなたは間違いなくジョーダンによって行わ型キャストに関する短いを見てみたいと思います

653
00:44:49,000 --> 00:44:55,000
intは、ボンネットの下に何かを理解するために、

654
00:44:55,000 --> 00:44:58,000
ボンネットの下に何文字です。

655
00:44:58,000 --> 00:45:02,000
我々は、ASCIIの話、我々が実際にASCIIコード表を見てみると、

656
00:45:02,000 --> 00:45:07,000
何をしては、フードの下で見て私たちに与えている

657
00:45:07,000 --> 00:45:13,000
コンピュータが実際に資本と7桁を表す方法で

658
00:45:13,000 --> 00:45:17,000
コンマと疑問符。

659
00:45:17,000 --> 00:45:20,000
また、コンピュータは、表現するための特別な方法を持っています

660
00:45:20,000 --> 00:45:23,000
値を整数として7。

661
00:45:23,000 --> 00:45:27,000
これは、浮動小数点数として7番を表すための特別な方法があります

662
00:45:27,000 --> 00:45:29,000
そしてそれらは非常に異なっています。

663
00:45:29,000 --> 00:45:32,000
型キャストを使用すると、コンピュータが "ねえ、私はあなたが変換したい言う方法です。

664
00:45:32,000 --> 00:45:37,000
一つの表現から別の表現へ。 "

665
00:45:37,000 --> 00:45:40,000
なぜ我々はそれを見ていません。

666
00:45:40,000 --> 00:45:44,000
>> 私はまた、ライブラリやコンパイラの短い上に短いを見てみましょう。

667
00:45:44,000 --> 00:45:47,000
コンパイルのプロセスに関するものトーク、

668
00:45:47,000 --> 00:45:53,000
ライブラリとは何であり、あなたが質問を受けるかもしれない、これらの質問のいくつかに目を通す。

669
00:45:53,000 --> 00:45:55,000
第1週物質に関する質問？

670
00:45:55,000 --> 00:46:03,000
あなたがカバーしたいのですが困難に見えるここでどんな話題はありますか？

671
00:46:03,000 --> 00:46:07,000
我々が得ることができるように、私はこれらの以前のトピックのほとんどを爆破しようとしている

672
00:46:07,000 --> 00:46:13,000
ポインタと再帰の少しを行う。

673
00:46:13,000 --> 00:46:15,000
考えですか？

674
00:46:15,000 --> 00:46:19,000
カバーするために何か？

675
00:46:19,000 --> 00:46:21,000
おそらくいくつかのチョコレートのための時間？

676
00:46:21,000 --> 00:46:23,000
君たちはそれを介して取り組んでいます。

677
00:46:23,000 --> 00:46:26,000
私はコーヒーを飲み続けるつもりです。

678
00:46:26,000 --> 00:46:31,000
2週目。

679
00:46:31,000 --> 00:46:34,000
グッドコール、良いコール。

680
00:46:34,000 --> 00:46:38,000
週2では関数についてもう少し話をしました。

681
00:46:38,000 --> 00:46:43,000
>> 最初のいくつかの問題セットでは、私たちは本当に全く任意の関数を書いていない

682
00:46:43,000 --> 00:46:45,000
どの関数以外の？

683
00:46:45,000 --> 00:46:47,000
[学生]メイン。>>メイン、正確に。

684
00:46:47,000 --> 00:46:51,000
そして私たちは主が身に着けているさまざまな衣装を見てきました。

685
00:46:51,000 --> 00:46:54,000
それは引数を取らないものでは、あります

686
00:46:54,000 --> 00:46:58,000
私達はちょうど、括弧の間に空隙を言う

687
00:46:58,000 --> 00:47:01,000
その後、我々は、コマンドラインの引数を取るようにしたいです他の1つしかありません

688
00:47:01,000 --> 00:47:08,000
あなたがint argcとargvのストリング·アレイを使用していると我々が見たように、それはだ

689
00:47:08,000 --> 00:47:13,000
または、今、私たちは実際にそれがあることをchar *で文字列を公開したことを

690
00:47:13,000 --> 00:47:20,000
我々は、char * argvと、ブラケットとしてそれを書き始めるつもりです。

691
00:47:20,000 --> 00:47:22,000
問題セット3では、君たちは機能の束を見て、

692
00:47:22,000 --> 00:47:27,000
そしてあなたは、関数の束を実装し、ルックアップ、スクランブルを描く。

693
00:47:27,000 --> 00:47:31,000
プロトタイプはすべてあなたのためにそこに書かれていました。

694
00:47:31,000 --> 00:47:33,000
>> 私は本当に迅速な機能と一緒にここの話をしたいのか

695
00:47:33,000 --> 00:47:38,000
関数を書くとき、それらに3つの部分があるということです。

696
00:47:38,000 --> 00:47:43,000
あなたは、関数の戻り値の型を指定する必要があります。

697
00:47:43,000 --> 00:47:46,000
これは、関数の名前を指定する必要がありますし、次のように指定する必要があります

698
00:47:46,000 --> 00:47:51,000
引数リストまたはパラメータ·リスト。

699
00:47:51,000 --> 00:47:57,000
私は関数を記述した場合例えば、整数の束を総括する

700
00:47:57,000 --> 00:48:03,000
その後、私に私の戻り値の型がどうなるか和を返す

701
00:48:03,000 --> 00:48:06,000
私は整数を合計してから合計を戻りたい場合はどうなりますか？

702
00:48:06,000 --> 00:48:12,000
次に、関数の名前です。

703
00:48:12,000 --> 00:48:27,000
私が先に行くと緑色で書いた場合、この部分は、戻り値の型です。

704
00:48:27,000 --> 00:48:34,000
この部分は名前です。

705
00:48:34,000 --> 00:48:40,000
そして、括弧の間に

706
00:48:40,000 --> 00:48:46,000
私は引数を与える場所であり、

707
00:48:46,000 --> 00:48:56,000
しばしば、時にはパラメータのparamsを呼び、引数と略す。

708
00:48:56,000 --> 00:49:00,000
あなたがいずれかを持っている場合と、あなただけのいずれかを指定します。

709
00:49:00,000 --> 00:49:06,000
あなたが複数ある場合はコンマでそれぞれを区切ってください。

710
00:49:06,000 --> 00:49:13,000
と各引数に対してあなたはそれをケビンアール2物事を与えるか？

711
00:49:13,000 --> 00:49:18,000
[ケビン]あなたがタイプしてから、名前を付ける必要があります。

712
00:49:18,000 --> 00:49:21,000
そして、名前、および名前は、使用しようとしている名前です。

713
00:49:21,000 --> 00:49:25,000
sum関数内でその引数を参照するために、

714
00:49:25,000 --> 00:49:27,000
あなたが現在書いていることを関数内。

715
00:49:27,000 --> 00:49:32,000
>> あなたは、私が総括するつもりなら、例えばツーのために持っていない

716
00:49:32,000 --> 00:49:41,000
言う、整数-we'llの配列は、int型の配列を行う

717
00:49:41,000 --> 00:49:46,000
と私はそこに、自分自身にいくつかの中括弧をあげる

718
00:49:46,000 --> 00:49:51,000
その後、私はsum関数に配列を渡すとき

719
00:49:51,000 --> 00:49:55,000
私は、引数リストの最初の位置にそれを渡します。

720
00:49:55,000 --> 00:49:59,000
しかし、私が渡した配列は名前arrを持っている必要はありません。

721
00:49:59,000 --> 00:50:07,000
ARRは、私は関数の本体内でその引数を参照する方法になるだろう。

722
00:50:07,000 --> 00:50:10,000
我々は考慮する必要がある他の事、

723
00:50:10,000 --> 00:50:14,000
そして、これは機能とは若干異なりますが、私はそれが重要なポイントだと思う

724
00:50:14,000 --> 00:50:20,000
C言語で、私はこのような関数を書いている時ということです

725
00:50:20,000 --> 00:50:29,000
どのように私はこの配列内の要素数を知っていますか？

726
00:50:29,000 --> 00:50:31,000
これはトリックの質問の幾分である。

727
00:50:31,000 --> 00:50:35,000
我々は先週のセクションで、このことについて少し話をしました。

728
00:50:35,000 --> 00:50:40,000
どのように私はC言語で配列内の要素の数を知っていますか？

729
00:50:40,000 --> 00:50:44,000
方法はありますか？

730
00:50:44,000 --> 00:50:49,000
>> それは知っている方法は存在しないことが判明した。

731
00:50:49,000 --> 00:50:52,000
あなたは、別途で渡す必要があります。

732
00:50:52,000 --> 00:50:55,000
あなたが行うことができますトリックがあります

733
00:50:55,000 --> 00:51:00,000
あなたは配列が宣言された関数と同じ関数内にあるならば、

734
00:51:00,000 --> 00:51:04,000
そしてあなたは、スタック配列で作業している。

735
00:51:04,000 --> 00:51:06,000
あなたは、同じ関数内で使っているのであればそれにのみ機能します。

736
00:51:06,000 --> 00:51:09,000
たら、別の関数に配列を渡すか、配列を宣言した場合

737
00:51:09,000 --> 00:51:12,000
そしてあなたは、ヒープ上にその配列を言えば、あなたは、mallocを使用してきました

738
00:51:12,000 --> 00:51:15,000
 とかのようなものは、すべての賭けがオフになっています。

739
00:51:15,000 --> 00:51:18,000
次に、実際に周りを通過しなければならない

740
00:51:18,000 --> 00:51:21,000
特別な引数または別のパラメータ

741
00:51:21,000 --> 00:51:23,000
配列がどのように大きなことを伝える。

742
00:51:23,000 --> 00:51:28,000
この場合、私は申し訳ありませんが、それは画面をオフに起こっているのコンマは - 私を使用したいと思いますここで、

743
00:51:28,000 --> 00:51:32,000
と私は別の引数を渡したい

744
00:51:32,000 --> 00:51:40,000
 それ長のint len​​の呼び出し。

745
00:51:40,000 --> 00:51:44,000
>> クイズに出てくるかもしれない一つのこと

746
00:51:44,000 --> 00:51:49,000
何かと呼ばれる特定の関数を書くか、または実装を求めている。

747
00:51:49,000 --> 00:51:54,000
私たちはあなたにプロトタイプを与えていない場合は、ので、ここでこの全体のこと、

748
00:51:54,000 --> 00:51:58,000
この全体の混乱は、関数宣言や関数プロトタイプと呼ばれています

749
00:51:58,000 --> 00:52:01,000
これは、それが与えられていない場合には漕ぎ着けたいと思うことを最初のものの一つである

750
00:52:01,000 --> 00:52:03,000
あなたにすぐにクイズに。

751
00:52:03,000 --> 00:52:06,000
私が学んだ他のトリックはということです

752
00:52:06,000 --> 00:52:11,000
私たちはあなたに関数のプロトタイプを与えるかと言うと、我々が言うには、 "ねえ、あなたはそれを書くために持っている。"

753
00:52:11,000 --> 00:52:16,000
あなたがクイズに持っているカッコ内

754
00:52:16,000 --> 00:52:20,000
あなたは、戻り値の型があることがわかり、あなたが気付いた場合は、その戻り値の型

755
00:52:20,000 --> 00:52:25,000
関数は何も返されないことを意味するvoid以外の何かが、ある

756
00:52:25,000 --> 00:52:28,000
その後、あなたは間違いなくやってみたいことが一つ書くことです

757
00:52:28,000 --> 00:52:33,000
関数の最後のreturn文のいくつかの並べ替え。

758
00:52:33,000 --> 00:52:40,000
戻って、我々は空白で埋めたいので、この場合には、我々は空白を置くことにしましょう​​。

759
00:52:40,000 --> 00:52:44,000
しかし、これはあなたはどのように私はこの問題にアプローチしようと思って約正しい方法で思考されますか？

760
00:52:44,000 --> 00:52:49,000
そして、それはあなたが値を返さなければならないとしていることを思い出させる

761
00:52:49,000 --> 00:52:51,000
関数の呼び出し元に。

762
00:52:51,000 --> 00:52:54,000
>> うん。>> [学生]私たちはクイズにコードを書いているときにスタイルが適用されますか？

763
00:52:54,000 --> 00:52:58,000
インデントやもののようなもののような？>> [学生]うん。

764
00:52:58,000 --> 00:53:00,000
いや、同じくらい。

765
00:53:00,000 --> 00:53:09,000
私は、 - これの多くは、我々は当日のクイズを明確になるだろう何かだと思う

766
00:53:09,000 --> 00:53:15,000
が、通常は心配する＃含まれており、スタッフのようなもの、それは外のようなものだ。

767
00:53:15,000 --> 00:53:17,000
[学生]は、手書きのコードをコメントアウトする必要がありますか？

768
00:53:17,000 --> 00:53:19,000
あなたの手書きのコードにコメントをする必要はありますか？

769
00:53:19,000 --> 00:53:24,000
あなたが部分的信用を心配しているならコメントアウトは常に良いです

770
00:53:24,000 --> 00:53:29,000
または年生に自分の意図を伝えたい。

771
00:53:29,000 --> 00:53:33,000
しかし、私は、再び、クイズ自体に、クイズの日に明らかにします

772
00:53:33,000 --> 00:53:39,000
しかし、私はあなたが、いや、コメントを書き込むことが必要になるだろうと信じていません。

773
00:53:39,000 --> 00:53:42,000
典型的ではないが、それは間違いなく事どこのようなものだ

774
00:53:42,000 --> 00:53:45,000
あなたが好き、あなたの意図を伝えることができる "私は、それと付き合ってるところねえ、これは。"

775
00:53:45,000 --> 00:53:49,000
そして、時には、それは部分的な信用を支援することができます。

776
00:53:49,000 --> 00:53:51,000
クール。

777
00:53:51,000 --> 00:53:53,000
>> バジル。

778
00:53:53,000 --> 00:53:56,000
[バジル]と言う、int型langを宣言するの違いは何ですか

779
00:53:56,000 --> 00:54:03,000
関数内で変数を宣言対引数またはパラメータで？

780
00:54:03,000 --> 00:54:05,000
うわー、コーヒーが気管を下りた。

781
00:54:05,000 --> 00:54:07,000
[バジル]我々は引数に入れたいものと同様。

782
00:54:07,000 --> 00:54:09,000
ええ、それは素晴らしい質問です。

783
00:54:09,000 --> 00:54:11,000
どのようにあなたが引数に入れたいものを選ぶ事ない

784
00:54:11,000 --> 00:54:17,000
どんな物事に対しては、関数の内部ですればいいですか？

785
00:54:17,000 --> 00:54:24,000
このケースでは、引数としてこれらの両方が含まれていた

786
00:54:24,000 --> 00:54:29,000
彼らは、sum関数を使おうとしている人は誰でもいるものだから

787
00:54:29,000 --> 00:54:32,000
それらのものを指定する必要があります。

788
00:54:32,000 --> 00:54:35,000
>> sum関数は、我々が話しのように、知る方法はありません

789
00:54:35,000 --> 00:54:40,000
それは、その呼び出し元または誰から取得する方法に大きな配列であるsum関数を使用しています。

790
00:54:40,000 --> 00:54:44,000
それは、その配列がどの程度の大き知る方法はありません。

791
00:54:44,000 --> 00:54:48,000
我々は、引数として、右ここにこの長さを渡す理由

792
00:54:48,000 --> 00:54:51,000
それは、我々は基本的には、関数の呼び出し元に言っていることを何かだからです

793
00:54:51,000 --> 00:54:55,000
sum関数を使おうとしている人は誰でも、 "ねえ、あなたは私たちに配列を与えなければならないだけでなく、

794
00:54:55,000 --> 00:54:59,000
intの、あなたはまた、私たちに与えてきた配列がどの程度の大き教えなければならない。 "

795
00:54:59,000 --> 00:55:03,000
[バジル]それらは両方のコマンドライン引数になりますか？

796
00:55:03,000 --> 00:55:06,000
いいえ、これらは、関数に渡すだろうと実際の引数です。

797
00:55:06,000 --> 00:55:10,000
>> 私はここに新しいページをやってみましょう。

798
00:55:10,000 --> 00:55:13,000
[バジル]名前と同様にパススルーでしょう

799
00:55:13,000 --> 00:55:24,000
[ネイト·H]私は（void）をint型のmainを持っている場合は、

800
00:55:24,000 --> 00:55:27,000
と私は、下部には、ここ私のリターン0で下に置くつもりです

801
00:55:27,000 --> 00:55:31,000
と私は、sum関数を呼び出したいと言う。

802
00:55:31,000 --> 00:55:42,000
私が言いたいのint X = SUM（）;

803
00:55:42,000 --> 00:55:46,000
sum関数を使用するには、私は総括したいアレイの両方に合格する必要があり

804
00:55:46,000 --> 00:55:51,000
と配列の長さは、これがどこにあるの

805
00:55:51,000 --> 00:55:54,000
私は、intの配列を持っていたと仮定して

806
00:55:54,000 --> 00:56:12,000
私が持っていたと言うのint numbaz [] = 1、2、3、

807
00:56:12,000 --> 00:56:16,000
すぐそこの構文をハック使用の種類、

808
00:56:16,000 --> 00:56:21,000
その後、私は何であろうと、私は合格したいと思うの和である

809
00:56:21,000 --> 00:56:27,000
numbazと番号3の両方

810
00:56:27,000 --> 00:56:30,000
"さて、ここで私はあなたが合計する配列です。" sum関数を伝えるために

811
00:56:30,000 --> 00:56:34,000
"ここでは、その大きさだ。"

812
00:56:34,000 --> 00:56:39,000
お分かりでしょうか？それはあなたの質問に答えるのですか？

813
00:56:39,000 --> 00:56:42,000
>> いろいろな意味で、それは我々がメインでやっている平行ん

814
00:56:42,000 --> 00:56:44,000
我々は、コマンドライン引数を持っているとき。

815
00:56:44,000 --> 00:56:47,000
シーザー暗号のようなプログラムは、例えば、それが必要とされる

816
00:56:47,000 --> 00:56:53,000
コマンドライン引数は何もできないでしょう。

817
00:56:53,000 --> 00:56:57,000
あなたがそれを言わなかった場合は、キーを使用するかを暗号化する方法を知っているだろう

818
00:56:57,000 --> 00:57:03,000
またはあなたが暗号化するために何を望むか文字列にそれを言わなかった場合。

819
00:57:03,000 --> 00:57:08,000
我々は2つ​​の異なるメカニズムを持っている場所の入力を求めることは、これは

820
00:57:08,000 --> 00:57:14,000
ユーザーからの情報を取るために、ユーザからの入力を取るため。

821
00:57:14,000 --> 00:57:19,000
問題1を設定するため、我々はこの場合、getIntは、GetString、getFloatは道を見た

822
00:57:19,000 --> 00:57:26,000
入力を求めるプロンプトが表示され、その標準の入力ストリームを使用して呼ばれていた。

823
00:57:26,000 --> 00:57:28,000
それは少し違う。

824
00:57:28,000 --> 00:57:31,000
それはとは対照的に、一度に行うことができます何か

825
00:57:31,000 --> 00:57:35,000
あなたは、プログラムが実行を開始し、プログラムを起動したとき。

826
00:57:35,000 --> 00:57:41,000
あなたがプログラムの実行を開始するときに、コマンドライン引数はすべて指定されています。

827
00:57:41,000 --> 00:57:47,000
私たちはそれらのうちの2つを混合してきました。

828
00:57:47,000 --> 00:57:52,000
我々は関数の引数を使用する場合、それははるかに主にコマンドライン引数のようなものだ。

829
00:57:52,000 --> 00:57:56,000
あなたがそれを指示する必要があります関数を呼び出すときに、それはだ

830
00:57:56,000 --> 00:58:05,000
まさにそれは、そのタスクを実行するために必要。

831
00:58:05,000 --> 00:58:08,000
でと見て、私は、あなたがお暇な時にはそれを見てみましょうもう一つの良いこと

832
00:58:08,000 --> 00:58:11,000
そしてそれは、スコープのこの概念だった - クイズで覆われていた

833
00:58:11,000 --> 00:58:15,000
変数とグローバル変数とローカル変数。

834
00:58:15,000 --> 00:58:18,000
それに注意を払うか。

835
00:58:18,000 --> 00:58:23,000
>> 今、私たちは、この他のものに乗っていること、

836
00:58:23,000 --> 00:58:27,000
第3週で、我々は、検索とソートの話を始めました。

837
00:58:27,000 --> 00:58:32,000
、少なくともCS50で、検索とソート

838
00:58:32,000 --> 00:58:39,000
非常にコンピュータサイエンスの理論的な部分のいくつかを紹介します。

839
00:58:39,000 --> 00:58:42,000
探索問題、並べ替えの問題

840
00:58:42,000 --> 00:58:46,000
ビッグ、カノニカル問題です。

841
00:58:46,000 --> 00:58:52,000
どのように整数の十億の配列内の特定の番号を見つけるのですか？

842
00:58:52,000 --> 00:58:55,000
どのようにして、電話帳内の特定の名前を見つけるのですか

843
00:58:55,000 --> 00:58:59,000
あなたのラップトップに保存されているということ？

844
00:58:59,000 --> 00:59:04,000
そして私たちは漸近実行時間の概念を導入する

845
00:59:04,000 --> 00:59:11,000
実際にどのくらいの時間、どのようにハード、これらの問題は、アール定量化する

846
00:59:11,000 --> 00:59:14,000
どのくらいの時間が解決するのを取る。

847
00:59:14,000 --> 00:59:20,000
2011年のクイズ、私は信じて、で、私はメリットを考えている問題があります

848
00:59:20,000 --> 00:59:27,000
この1は、問題12である、非常に迅速にカバーしています。

849
00:59:27,000 --> 00:59:32,000
無O、それがオメガです。

850
00:59:32,000 --> 00:59:41,000
>> ここでは、最速の実行時の話をしている

851
00:59:41,000 --> 00:59:46,000
特定のアルゴリズムのために、次に最も遅い可能なランタイム。

852
00:59:46,000 --> 00:59:52,000
このオメガとOは実際には単なるショートカットです。

853
00:59:52,000 --> 00:59:55,000
彼らは言うために表記しているショートカット

854
00:59:55,000 --> 00:59:59,000
最良のケースで我々のアルゴリズムが実行されますどのくらいの速さ、

855
00:59:59,000 --> 01:00:06,000
とどのように考えられる最悪のケースの遅い我々のアルゴリズムは実行するのだろうか？

856
01:00:06,000 --> 01:00:10,000
これらのカップルを行うレッツ、これらも覆われていた

857
01:00:10,000 --> 01:00:13,000
私は非常にお勧め漸近記法、上の短いインチ

858
01:00:13,000 --> 01:00:17,000
ジャクソンは本当に良い仕事をした。

859
01:00:17,000 --> 01:00:23,000
二分探索では、我々は、アルゴリズムとして二分探索の話

860
01:00:23,000 --> 01:00:28,000
そして我々は、通常、そのビッグOの面でそれについて話す

861
01:00:28,000 --> 01:00:30,000
ビッグOとは？

862
01:00:30,000 --> 01:00:34,000
二分探索の中で最も遅い可能ランタイムとは何ですか？

863
01:00:34,000 --> 01:00:36,000
[学生] N²？

864
01:00:36,000 --> 01:00:41,000
閉じる、私はそれに似てますね。

865
01:00:41,000 --> 01:00:43,000
それはそれよりはるかに高速です。

866
01:00:43,000 --> 01:00:45,000
[学生]バイナリ？>>ええ、二分探索。

867
01:00:45,000 --> 01:00:47,000
[学生]それはログnです。

868
01:00:47,000 --> 01:00:49,000
n個のログを記録されるので、ログnが何を意味するのか？

869
01:00:49,000 --> 01:00:51,000
それは、各反復の半分になります。

870
01:00:51,000 --> 01:00:56,000
正確なので、最も遅い可能な場合には、

871
01:00:56,000 --> 01:01:00,000
あなたはソートされた配列を持っている場合と言う

872
01:01:00,000 --> 01:01:08,000
百整数と、あなたが探している番号の

873
01:01:08,000 --> 01:01:14,000
どちらかの配列の配列または非常に最後の要素の一番最初の要素である。

874
01:01:14,000 --> 01:01:18,000
覚えておいて、バイナリ·サーチ·アルゴリズムは、中央の要素を調べることで動作します

875
01:01:18,000 --> 01:01:21,000
それはあなたが捜している試合だか見てください。

876
01:01:21,000 --> 01:01:23,000
それは、偉大である場合は、それを発見した。

877
01:01:23,000 --> 01:01:27,000
>> 最良のケースでは、どのくらいの速バイナリ検索を実行しますか？

878
01:01:27,000 --> 01:01:29,000
[学生] 1。

879
01:01:29,000 --> 01:01:32,000
1、それは、1のビッグOの時定数です。うん。

880
01:01:32,000 --> 01:01:36,000
[学生]私は質問があります。あなたはnのログを言うとき、あなたは右、ベース2に対して意味ですか？

881
01:01:36,000 --> 01:01:40,000
はい、だからそれは他のことだ。

882
01:01:40,000 --> 01:01:44,000
我々は、nを記録するようにしていて、私が高校生だったとき、私は推測する

883
01:01:44,000 --> 01:01:48,000
私は常にログがベース10であったと仮定した。

884
01:01:48,000 --> 01:01:57,000
ええ、はいそう、一般的に我々が使用しているものですベース2をログに記録します。

885
01:01:57,000 --> 01:02:02,000
あなたはどちらかを探している場合は、再度、バイナリ検索に戻って

886
01:02:02,000 --> 01:02:05,000
一番最後の要素または非常に最初の要素、

887
01:02:05,000 --> 01:02:08,000
あなたが途中で起動しているため、あなたは捨てる

888
01:02:08,000 --> 01:02:13,000
いずれかの半分は、あなたが捜している基準を満たしていない

889
01:02:13,000 --> 01:02:15,000
そしてあなたは、次の半分と次の半分と次の半分にアクセスしてください。

890
01:02:15,000 --> 01:02:19,000
私は百整数配列内の最大の要素を探している場合

891
01:02:19,000 --> 01:02:25,000
私は1万回のほとんどのログでそれを半分にするつもりです

892
01:02:25,000 --> 01:02:28,000
私は最終的にテストし、要素は私が探していることを見る前に

893
01:02:28,000 --> 01:02:33,000
は、最大で、または配列の最大インデックスである

894
01:02:33,000 --> 01:02:38,000
それはN、1万回のログのログを取る。

895
01:02:38,000 --> 01:02:40,000
>> バブルソート。

896
01:02:40,000 --> 01:02:43,000
あなたたちは、バブルソートアルゴリズムを覚えていますか？

897
01:02:43,000 --> 01:02:47,000
ケビンは、あなたは私にバブルソートアルゴリズムで何が起こったのかの簡単な要約を与えることができますか？

898
01:02:47,000 --> 01:02:50,000
[ケビン]基本的には、リスト内のすべてのものを通過します。

899
01:02:50,000 --> 01:02:52,000
それは、最初の2つを見ている。

900
01:02:52,000 --> 01:02:55,000
最初のものは、それがスワップそれらを1秒より大きい場合。

901
01:02:55,000 --> 01:02:58,000
そして、それは2番目と3番目、同じこと、スワップを比較して、

902
01:02:58,000 --> 01:03:00,000
3番目と4番目の、すべての方法ダウン。

903
01:03:00,000 --> 01:03:03,000
大きな数字は最後まで続く。

904
01:03:03,000 --> 01:03:07,000
としかし、多くのループ後にすれば完了です。

905
01:03:07,000 --> 01:03:11,000
正確なので、ケビンが言ったこと、我々はより大きな数を見てよということです

906
01:03:11,000 --> 01:03:15,000
配列の最後にバブルアップ。

907
01:03:15,000 --> 01:03:19,000
たとえば、あなたは、これが私たちの配列である場合、この例を通して私たちを歩いて気にしますか？

908
01:03:19,000 --> 01:03:21,000
[ケビン]あなたはテイク2と3があります。

909
01:03:21,000 --> 01:03:23,000
3が2よりも大きいので、それらを交換します。

910
01:03:23,000 --> 01:03:29,000
[ネイト·H]右ので、我々はこれらを入れ替えるので、私たちは、2、3、6、4、および9を得る。

911
01:03:29,000 --> 01:03:31,000
[ケビン]次に、図3及び図6を比較します。

912
01:03:31,000 --> 01:03:33,000
、3は6よりも小さいので、それらを残す

913
01:03:33,000 --> 01:03:37,000
4は6よりも小さいので、6と4は、それらを交換したいと思います。

914
01:03:37,000 --> 01:03:42,000
[ネイト·H]右ので、私は2、3、4、6、9を得る。

915
01:03:42,000 --> 01:03:46,000
[ケビン]そして9は6よりも大きいので、そのままにしておきます。

916
01:03:46,000 --> 01:03:48,000
そして、あなたは再びそれを通って行くと思います。

917
01:03:48,000 --> 01:03:50,000
>> [ネイト·H]私はこの時点で行うのでしょうか？>> [ケビン]いいえ

918
01:03:50,000 --> 01:03:52,000
そして、なぜ私がこの時点で行われていないのですか？

919
01:03:52,000 --> 01:03:54,000
私の配列がソートされているように見えますので。私はそれを探しています。

920
01:03:54,000 --> 01:03:57,000
[ケビン]再びそれを介して移動し、それ以上のスワップがあることを確認してください

921
01:03:57,000 --> 01:04:00,000
する前に、完全に停止することができます。

922
01:04:00,000 --> 01:04:04,000
正確なので、スルーを続けると全くスワップがないことを確認する必要があります

923
01:04:04,000 --> 01:04:06,000
この時点で作ることができる。

924
01:04:06,000 --> 01:04:08,000
あなたが言ったように、それは我々が終わったことを、実際には単なるラッキーだった

925
01:04:08,000 --> 01:04:12,000
を介してのみ1パスを作るために持って、私たちはソートしています。

926
01:04:12,000 --> 01:04:16,000
しかし、一般的なケースでこれを行うには、我々は実際に何度もこれを行う必要があるでしょう。

927
01:04:16,000 --> 01:04:20,000
そして、実際には、これが最良の例の例であった

928
01:04:20,000 --> 01:04:24,000
同じように、我々は問題を見ました。

929
01:04:24,000 --> 01:04:28,000
我々は可能な限り最高のケースがnされたことを見た。

930
01:04:28,000 --> 01:04:32,000
私たちは、アレイ1時間を経て。

931
01:04:32,000 --> 01:04:35,000
このアルゴリズムの最悪のケースは何ですか？

932
01:04:35,000 --> 01:04:37,000
[ケビン] N²。

933
01:04:37,000 --> 01:04:41,000
そして、それは何のように見えるのでしょうか？どのような配列の外観はそのようなn個の²の時間がかかるだろうか？

934
01:04:41,000 --> 01:04:43,000
[ケビン] [聞こえない]ソートされます。

935
01:04:43,000 --> 01:04:51,000
まさに、私は配列9、7、6、5、2、持っていた場合

936
01:04:51,000 --> 01:04:54,000
最初の9は、最大バブルのすべての方法であろう。

937
01:04:54,000 --> 01:04:59,000
1反復の後に我々は7、6、5、2、9を持っていると思います。

938
01:04:59,000 --> 01:05:07,000
その後7を上方にバブル、6、5、2、7、9、などといったようになります。

939
01:05:07,000 --> 01:05:13,000
>> 我々は、配列全体をn回通らなければならないと思います

940
01:05:13,000 --> 01:05:16,000
そして実際にはこれよりわずかにより正確な取得することができます

941
01:05:16,000 --> 01:05:23,000
かつて我々は、その最後の可能な位置に最大9つすべての方法を移動したので、

942
01:05:23,000 --> 01:05:26,000
我々は再びその要素と比較する必要がないことを知っています。

943
01:05:26,000 --> 01:05:29,000
かつて我々は7バブルアップ開始

944
01:05:29,000 --> 01:05:35,000
私たちは、7右9の前になったら、我々は止めることができることを知っている

945
01:05:35,000 --> 01:05:37,000
以来、我々はすでにそれに9を比較しました。

946
01:05:37,000 --> 01:05:46,000
あなたは、スマートな方法でこれを行う場合、それは、私が推測する、本当にそのくらいの時間はありません。

947
01:05:46,000 --> 01:05:49,000
あなたはすべての可能な[聞こえない]の組み合わせを比較するつもりはない

948
01:05:49,000 --> 01:05:55,000
毎回、各イテレーションを通過します。

949
01:05:55,000 --> 01:05:59,000
しかし、それでもまだ、私たちはこの上限について話すとき、我々は言う

950
01:05:59,000 --> 01:06:04,000
あなたは、nを見ている²の比較はすべての道を通って。

951
01:06:04,000 --> 01:06:12,000
>> 戻ろう、と我々は時間に少し短いを取得し始めているので

952
01:06:12,000 --> 01:06:15,000
私は、あなたは間違いなく、この表の残りの部分を通って行くべきだと思います

953
01:06:15,000 --> 01:06:17,000
それをすべて記入してください。

954
01:06:17,000 --> 01:06:20,000
例を考えてみてください。具体的な例を考える。

955
01:06:20,000 --> 01:06:22,000
それはやることは本当に便利と便利です。

956
01:06:22,000 --> 01:06:25,000
それを引き出す。

957
01:06:25,000 --> 01:06:28,000
これは、コンピュータサイエンスの通って行くようにした表のようなものです

958
01:06:28,000 --> 01:06:32,000
あなたは本当に心のことで、これらを知って開始する必要があります。

959
01:06:32,000 --> 01:06:34,000
これらはあなたがインタビューで得る質問の種類があります。

960
01:06:34,000 --> 01:06:36,000
これらは、知っておくと良いです物事のソートです

961
01:06:36,000 --> 01:06:41,000
と本当に考えるする方法を考え出す、それらのエッジケースを考える

962
01:06:41,000 --> 01:06:45,000
バブルのために考えられる最悪の配列をソートすることを知っている

963
01:06:45,000 --> 01:06:52,000
それでソートすると、逆の順序での一つです。

964
01:06:52,000 --> 01:06:58,000
>> ポインター。ポインタについて少し話してみましょう。

965
01:06:58,000 --> 01:07:03,000
最後の数分後には、ここにある

966
01:07:03,000 --> 01:07:11,000
私は、これは比較的新しいですファイルと一緒に何かのI / Oであることを知っている。

967
01:07:11,000 --> 01:07:19,000
我々は、我々はポインタのポインタについて話をしたい理由について話をするとき

968
01:07:19,000 --> 01:07:24,000
我々はC言語で作業している1、なぜならば、

969
01:07:24,000 --> 01:07:33,000
我々は、最も近代的なプログラミング言語に比べてかなり低い水準で本当にです。

970
01:07:33,000 --> 01:07:38,000
我々は、実際にメモリ内の変数を操作することができるしている

971
01:07:38,000 --> 01:07:43,000
彼らは実際に私たちのRAM内に位置している場所を把握する。

972
01:07:43,000 --> 01:07:46,000
一度あなたが表示されます、オペレーティングシステムのクラスを取ることで行ってきた

973
01:07:46,000 --> 01:07:48,000
それは、再び、抽象化のようなものだ。

974
01:07:48,000 --> 01:07:50,000
それは実際にそうではない。

975
01:07:50,000 --> 01:07:52,000
私たちは、私たちからこれらの詳細を隠している仮想メモリを持っている。

976
01:07:52,000 --> 01:07:58,000
>> しかし、今のあなたは、あなたがプログラムを持っているときと仮定することができます

977
01:07:58,000 --> 01:08:02,000
例えば、あなたが起動したときには、シーザー暗号のプログラムを実行している

978
01:08:02,000 --> 01:08:06,000
私は本当に迅速に私のiPadに切り替えます

979
01:08:06,000 --> 01:08:12,000
とあなたは言う、持っている場合には、非常に、あなたのプログラムを開始すること

980
01:08:12,000 --> 01:08:15,000
あなたのラップトップ上のRAM 4ギガバイト、

981
01:08:15,000 --> 01:08:21,000
この塊を取っておく取得し、我々は、このRAMと呼ぶことにします。

982
01:08:21,000 --> 01:08:25,000
そしてそれは、我々は0を呼び出すつもりだ場所で開始

983
01:08:25,000 --> 01:08:30,000
そしてそれは我々が4ギガバイトを呼ぶだろうという場所で終わる。

984
01:08:30,000 --> 01:08:37,000
私は実際に書き込むことはできません。ハッキングされた男。

985
01:08:37,000 --> 01:08:40,000
あなたのプログラムが実行されると

986
01:08:40,000 --> 01:08:44,000
オペレーティングシステムは、RAMを刻む

987
01:08:44,000 --> 01:08:51,000
そしてそれは住むあなたのプログラムの異なる部分に異なるセグメントを指定

988
01:08:51,000 --> 01:08:58,000
ダウンここでこの領域がない人の土地のようなものです。

989
01:08:58,000 --> 01:09:02,000
あなたは少し遠く、ここに行くとき

990
01:09:02,000 --> 01:09:05,000
あなたは実際に場所を持っている場所

991
01:09:05,000 --> 01:09:09,000
あなたのプログラムの生活のためのコード。

992
01:09:09,000 --> 01:09:13,000
その実際のバイナリコードは、その実行可能ファイルは、実際にメモリ上にロードされる

993
01:09:13,000 --> 01:09:17,000
あなたがプログラムを実行し、それがコード·セグメントに住んでいたとき。

994
01:09:17,000 --> 01:09:22,000
あなたのプログラムの実行時に、プロセッサはこのコードセグメントを見て

995
01:09:22,000 --> 01:09:24,000
次の命令が何であるかを把握するには？

996
01:09:24,000 --> 01:09:27,000
私は実行する必要があるコードの次の行では、何ですか？

997
01:09:27,000 --> 01:09:31,000
>> そこにデータセグメントもだし、これはどこでそれらの文字列定数である

998
01:09:31,000 --> 01:09:34,000
あなたが使用してきたことが格納される。

999
01:09:34,000 --> 01:09:42,000
そして、遠くまでヒープと呼ばれるこの場所はそこだ。

1000
01:09:42,000 --> 01:09:46,000
我々は、mallocを使用してそこにメモリをアクセス

1001
01:09:46,000 --> 01:09:49,000
して、プログラムの最上位に向かって

1002
01:09:49,000 --> 01:09:52,000
スタックは、そこ

1003
01:09:52,000 --> 01:09:57,000
私たちは初めのほとんどのためにプレーしてきたところ、それはです。

1004
01:09:57,000 --> 01:09:59,000
これは、スケールや何かにありま​​せん。

1005
01:09:59,000 --> 01:10:03,000
これの多くは、非常にマシンに依存します

1006
01:10:03,000 --> 01:10:10,000
オペレーティングシステムに依存しますが、これは物事がアップチャンク化させる方法を相対的になります。

1007
01:10:10,000 --> 01:10:17,000
あなたがプログラムを実行すると、次呼ばx変数を宣言する場合

1008
01:10:17,000 --> 01:10:27,000
私はダウンの下に別のボックスを描画するつもりですが、これはだけでなく、RAMになるだろう。

1009
01:10:27,000 --> 01:10:29,000
そして、私は見に行くよ。

1010
01:10:29,000 --> 01:10:34,000
我々は、これは単にRAMの小さなセクションであることを示すためにギザギザの線を描画します

1011
01:10:34,000 --> 01:10:38,000
それのすべての私たちが一番上に描画されないように。

1012
01:10:38,000 --> 01:10:43,000
>> 私はxという名前の整数変数を宣言する場合は、

1013
01:10:43,000 --> 01:10:49,000
その後、私が実際に取得するマッピングです

1014
01:10:49,000 --> 01:10:54,000
私のプログラムのシンボル·テーブルに格納されている

1015
01:10:54,000 --> 01:11:00,000
それは私が描いたことをこのメモリ領域に名前xを結ぶ

1016
01:11:00,000 --> 01:11:03,000
右ここに縦線の間。

1017
01:11:03,000 --> 01:11:08,000
私はx = 7と言う私のプログラムのコード行を使用している場合

1018
01:11:08,000 --> 01:11:15,000
プロセッサは知っている "ああ、大丈夫、私は知っているメモリ内のこの場所でxに住んでいます。"

1019
01:11:15,000 --> 01:11:25,000
"私が先に行くと、そこに7を書くつもりだ。"

1020
01:11:25,000 --> 01:11:28,000
それはどのようにこれはメモリにあるものの位置を知っていますか？

1021
01:11:28,000 --> 01:11:30,000
まあ、それはすべてコンパイル時に行わている。

1022
01:11:30,000 --> 01:11:34,000
変数の各々が行くに行くところコンパイラが割り当てるの面倒を見る

1023
01:11:34,000 --> 01:11:40,000
と特別なマッピングを作成したり、むしろ、点と点を繋ぐ

1024
01:11:40,000 --> 01:11:43,000
記号とそれが起こっているのは、その変数の名前の間に

1025
01:11:43,000 --> 01:11:46,000
どこでそれがメモリに生きるために起こっている。

1026
01:11:46,000 --> 01:11:50,000
しかし、それは我々が実際にだけでなく、私たちのプログラムの中でそれにアクセスできることが判明した。

1027
01:11:50,000 --> 01:11:55,000
我々は、データ構造のいくつかについて話し始めるとき、これは、重要になっ

1028
01:11:55,000 --> 01:11:58,000
これは、我々は後で紹介しようとしている概念である。

1029
01:11:58,000 --> 01:12:09,000
>> しかし、今のところ、何を知ることができると、私はx、この場所へのポインタを作成することができるということです。

1030
01:12:09,000 --> 01:12:12,000
たとえば、私はポインタ変数を作成することができます。

1031
01:12:12,000 --> 01:12:16,000
我々はポインタ変数を作成するときに我々は、星の表記法を使用します。

1032
01:12:16,000 --> 01:12:21,000
このケースでは、これは私はint型へのポインタを作成するつもりだと言う。

1033
01:12:21,000 --> 01:12:24,000
それはちょうど他のどのようなタイプだ。

1034
01:12:24,000 --> 01:12:27,000
我々はそれをyのような変数を与えて、

1035
01:12:27,000 --> 01:12:32,000
それから私達はアドレスに、アドレスに等しく設定します。

1036
01:12:32,000 --> 01:12:38,000
この場合において、我々はxを指すようにyを設定することができます

1037
01:12:38,000 --> 01:12:43,000
このアンパサンドで我々はxのアドレスを取ることによって、

1038
01:12:43,000 --> 01:12:55,000
それから私達はそれを指すようにyを設定します。

1039
01:12:55,000 --> 01:12:59,000
我々は、RAMを見れば、これは本質的には何ですん

1040
01:12:59,000 --> 01:13:02,000
これは別の変数を作成します。

1041
01:13:02,000 --> 01:13:04,000
それはyを、呼び出すために起こっている

1042
01:13:04,000 --> 01:13:06,000
そして、このコード行が実行されたとき

1043
01:13:06,000 --> 01:13:13,000
それは実際に、我々は一般的に矢印として描く少しのポインタを作成するために起こっている

1044
01:13:13,000 --> 01:13:15,000
そしてそれは、xを指すようにyを設定します。

1045
01:13:15,000 --> 01:13:17,000
はい。

1046
01:13:17,000 --> 01:13:19,000
xはすでにポインタの場合[学生]は、あなただけで行うだろう

1047
01:13:19,000 --> 01:13:22,000
int *にy = xと代わりにアンパサンドを持つ？

1048
01:13:22,000 --> 01:13:24,000
はい。

1049
01:13:24,000 --> 01:13:27,000
xは既にポインタである場合、あなたは、互いに等しい2ポインタを設定することができます

1050
01:13:27,000 --> 01:13:30,000
yはxを指していないでしょう、その場合、

1051
01:13:30,000 --> 01:13:34,000
それが指しているものは何でもXを指してしまうことになります。

1052
01:13:34,000 --> 01:13:37,000
残念なことに、我々は時間がありませんが。

1053
01:13:37,000 --> 01:13:44,000
>> 私は、我々は、このオフラインについて話すことができ、この時点では何と言うだろう

1054
01:13:44,000 --> 01:13:49,000
しかし、私は、この問題を介して作業を開始14位だと思います。

1055
01:13:49,000 --> 01:13:53,000
あなたはあなたのために充填された少しはここにすでにある見ることができます。

1056
01:13:53,000 --> 01:13:57,000
あなたは、int * xと* yを、我々は2のポインタを宣言するときに見ることができ

1057
01:13:57,000 --> 01:14:01,000
と変数の横に*を指すことに注意してくださいは、昨年行われたものだった。

1058
01:14:01,000 --> 01:14:05,000
これが我々が今年やっていることに似ていることが判明した。

1059
01:14:05,000 --> 01:14:11,000
あなたはポインタを宣言しているときは、*を記述する場所は問題ではありません。

1060
01:14:11,000 --> 01:14:17,000
しかし、我々はタイプの横に*を書かれている

1061
01:14:17,000 --> 01:14:24,000
それはそれは非常に明確ではポインタ変数を宣言していることになるので。

1062
01:14:24,000 --> 01:14:27,000
あなたは2点のポインタを宣言すると、私達に2箱を与えていることがわかります。

1063
01:14:27,000 --> 01:14:31,000
ここでは、malloc関数に等しいxを設定したとき

1064
01:14:31,000 --> 01:14:34,000
これが何を言っていると、ヒープ内のメモリを確保しておくことさ。

1065
01:14:34,000 --> 01:14:41,000
右ここにこの小さなボックスに、このサークルは、ヒープ上に位置しています。

1066
01:14:41,000 --> 01:14:43,000
Xはそれを指している。

1067
01:14:43,000 --> 01:14:46,000
yはまだ何を指していないことに注意してください。

1068
01:14:46,000 --> 01:14:50,000
メモリ -  xに数値42を格納するを取得するには

1069
01:14:50,000 --> 01:14:55,000
私たちは何の表記を使うのでしょうか？

1070
01:14:55,000 --> 01:14:59,000
[学生] * X = 42。

1071
01:14:59,000 --> 01:15:01,000
まさに、* X = 42。

1072
01:15:01,000 --> 01:15:06,000
それは矢印をたどると、そこに42を投げることを意味します。

1073
01:15:06,000 --> 01:15:09,000
ここでは、yとxに設定したか、我々はY Xを指しています。

1074
01:15:09,000 --> 01:15:13,000
繰り返しますが、これはちょうど私達がxにyを等しく設定どこにケビンが言ったことのようです。

1075
01:15:13,000 --> 01:15:15,000
YはXを指していない。

1076
01:15:15,000 --> 01:15:19,000
むしろ、それはxは同様に指しているものを指している。

1077
01:15:19,000 --> 01:15:24,000
>> そして最後に、この最後のボックスに我々は何ができるという2つの可能なものがあります。

1078
01:15:24,000 --> 01:15:28,000
一つは、我々が* X = 13と言うことです。

1079
01:15:28,000 --> 01:15:33,000
他の事は私達ができると言う、アレックス、あなたは私たちがここで何ができるか知っていますか？

1080
01:15:33,000 --> 01:15:37,000
あなたが言うことができる* X = 13または-

1081
01:15:37,000 --> 01:15:41,000
[学生]は、int何を言うことができる。

1082
01:15:41,000 --> 01:15:45,000
[ネイト·H]これはint型の変数と呼ばれていましたなら、私たちはそれを行うことができます。

1083
01:15:45,000 --> 01:15:49,000
彼らは両方とも同じ場所を指しているので、我々はまた、* Y = 13と言うことができる

1084
01:15:49,000 --> 01:15:51,000
ので、我々はそこに着くために、変数を使用することができます。

1085
01:15:51,000 --> 01:15:56,000
うん。>> [学生]私たちはただのint xが13であると言う場合と同じように見えるのでしょうか？

1086
01:15:56,000 --> 01:16:00,000
それは働いていないでしょうXと呼ばれる新しい変数を宣言することになる。

1087
01:16:00,000 --> 01:16:04,000
我々はここで、xはポインタアップであると宣言されているため、我々は衝突があると思います。

1088
01:16:04,000 --> 01:16:10,000
[学生]我々はちょうどそれ自体でその文を持っていた場合、それがサークルの面で、どんな風に見えるのでしょうか？

1089
01:16:10,000 --> 01:16:14,000
我々はx = 13を持っていたならば、我々は箱を持っており、むしろ矢を持つのではと思います

1090
01:16:14,000 --> 01:16:16,000
箱から出てくる私達はちょうど13としてそれを描きたいと思います。

1091
01:16:16,000 --> 01:16:19,000
ボックスで[学生]。オーケー。

1092
01:16:19,000 --> 01:16:24,000
>> 見ていただきありがとうございます、とクイズ0の幸運。

1093
01:16:24,000 --> 01:16:28,000
[CS50.TV]