1
00:00:00,000 --> 00:00:06,370

2
00:00:06,370 --> 00:00:08,150
>> JASONハーシュホーン：ようこそ
週3に、すべての人。

3
00:00:08,150 --> 00:00:11,650
私たちは忙しいが、エキサイティングなを持っている
我々の前にしてください。

4
00:00:11,650 --> 00:00:17,010
そこでまず、我々はいくつかなされているため
コー​​スのある前進が、我々はまだ

5
00:00:17,010 --> 00:00:20,570
学習の多くは、私は、やり残してきた
君たちいくつかのリソースを表示しようとして

6
00:00:20,570 --> 00:00:24,160
それは信じられないほどであることを証明する必要があります
あなたがいないだけにアプローチして投票

7
00:00:24,160 --> 00:00:28,130
問題が設定されますが、また、すべてのダイジェスト
私たちはあなたでは、みんなを与える材料

8
00:00:28,130 --> 00:00:30,800
講義やショートパンツとセクション。

9
00:00:30,800 --> 00:00:34,790
>> その後、我々は最初の20を過ごすつもりだ
セクションでは、上に行くの25分

10
00:00:34,790 --> 00:00:38,630
あなたが持っている、あるいは持っていてもいなくてもよい、GDB、
この時点で使用されるが、それは

11
00:00:38,630 --> 00:00:42,570
その意志信じられないほど便利なツール
あなたのプログラムのデバッグに役立つ。

12
00:00:42,570 --> 00:00:46,060
あなた方の多くは、中のprintfを使用した可能性があり
図のように、プログラムの途中

13
00:00:46,060 --> 00:00:47,430
変数が等しかったのかを。

14
00:00:47,430 --> 00:00:52,060
GDBは、printf関数よりも優れていると
あなたので、あなたのコードを台無しにしない

15
00:00:52,060 --> 00:00:53,320
実行ファイル上で実行します。

16
00:00:53,320 --> 00:00:56,500
だから我々は10最も参考になった上に行くよ
あなたは、GDBのために必要なコマンド、そして我々はしている

17
00:00:56,500 --> 00:01:00,540
そう一緒に練習に行くつもり
問題では、3以降を設定

18
00:01:00,540 --> 00:01:03,320
デバッグを支援するために、GDBを使用することができます
あなたのプログラム。

19
00:01:03,320 --> 00:01:06,420
そして最後に、我々はいくつかの上に行くつもりだ
ソートアルゴリズムと検索

20
00:01:06,420 --> 00:01:10,590
あなたが講義中に見て、我々はあることを
だけではなく、実際にコードに行く

21
00:01:10,590 --> 00:01:17,360
擬似コードが、コード、バイナリ検索、
バブルソート、選択ソート。

22
00:01:17,360 --> 00:01:20,090
>> したがって、最初、私が行ってみたい
資源をめぐる。

23
00:01:20,090 --> 00:01:23,530
これは広範なリストであり、それはだ
私はたくさんあったので、小さいフォント

24
00:01:23,530 --> 00:01:24,390
ここに収まる。

25
00:01:24,390 --> 00:01:26,950
しかし、これらは、あなたを助けるだけでなく、
もう一度、問題セットを持つと

26
00:01:26,950 --> 00:01:30,760
あなたが学習した情報を消化したが、
確かに、クイズの時間、これらの意志を来る

27
00:01:30,760 --> 00:01:32,130
信じられないほど有用である。

28
00:01:32,130 --> 00:01:34,700
したがって、最初の講義ノート。

29
00:01:34,700 --> 00:01:39,480
あなたはcs50.net/lecturesに行けばと
特定の週と曜日までスクロール

30
00:01:39,480 --> 00:01:43,120
あなたはそれぞれにノートがあることがわかります
単純ではない講義、

31
00:01:43,120 --> 00:01:47,250
転写産物が、の編集されたバージョン
コー​​ドでの講演で覆われていたものを

32
00:01:47,250 --> 00:01:49,610
スニペットやその他の有用な一口。

33
00:01:49,610 --> 00:01:52,220
私は非常にそれらの上に行くお勧めします。

34
00:01:52,220 --> 00:01:55,340
してからも、ソースコードがあります
各講義から入手できる。

35
00:01:55,340 --> 00:02:00,050
そして再び、これらのスライドにもなります
cs50.net/sectionsからオンラインで入手でき

36
00:02:00,050 --> 00:02:01,480
この夜。

37
00:02:01,480 --> 00:02:06,860
>> 第2ショーツは毎週されていることを
通常は5から15、トピックをカバー

38
00:02:06,860 --> 00:02:08,090
長さの分。

39
00:02:08,090 --> 00:02:12,310
そして、それらがうまくいけばあなたを与えるだろう
さまざまなトピックに大きなプライマー。

40
00:02:12,310 --> 00:02:12,870
第三 - 

41
00:02:12,870 --> 00:02:16,370
これは、ブランドの新しい本です
年 -  study.cs50.netです。

42
00:02:16,370 --> 00:02:20,110
あなたがそれをチェックアウトしていない場合は、私
非常にあなたがそうすることをお勧めします。

43
00:02:20,110 --> 00:02:21,100
あなたは、トピックを選ぶことを得る。

44
00:02:21,100 --> 00:02:23,040
我々はそこにトピックの数十を持っている。

45
00:02:23,040 --> 00:02:24,770
だからたとえば、関数を選択します。

46
00:02:24,770 --> 00:02:27,270
それはあなたにいくつかのスライドを提供します
と機能についての注意事項。

47
00:02:27,270 --> 00:02:31,190
それらは実際のTFのスライドです
私たちの中に使用することが推奨される

48
00:02:31,190 --> 00:02:32,710
セクションでのプレゼンテーション。

49
00:02:32,710 --> 00:02:35,040
対処するためのヒントやコツもあります
機能を備えた、とあります

50
00:02:35,040 --> 00:02:37,290
役立つ練習問題
あなたが機能を操作します。

51
00:02:37,290 --> 00:02:41,500
我々はまた、短い上にあなたのリンクを与える
機能と機能回

52
00:02:41,500 --> 00:02:42,750
講義で出ている。

53
00:02:42,750 --> 00:02:46,550
こののでstudy.cs50.net、真新しい
今年、素晴らしいリソース。

54
00:02:46,550 --> 00:02:52,180
>> 次に、私は手動で男を持っている
あなたが実行できるコマンド

55
00:02:52,180 --> 00:02:52,770
コマンドライン。

56
00:02:52,770 --> 00:02:57,880
だから、についてご質問がある場合は、
コマンド、例えば、RAND、その私たち

57
00:02:57,880 --> 00:03:00,900
セクションの間に先週発生した
あなたは可能性が高い中で遭遇した

58
00:03:00,900 --> 00:03:05,380
を経由する場合は、あなたの問題は、設定
コー​​ドを生成しますが、男を入力すると

59
00:03:05,380 --> 00:03:09,980
ランドには、そのページを取得します
ランドをするか教えてくれます。

60
00:03:09,980 --> 00:03:14,040
それは、それが必要なものあなたを与える
それが取るのパラメータだけでなく、リターン

61
00:03:14,040 --> 00:03:16,530
種類と簡単な説明
その関数の。

62
00:03:16,530 --> 00:03:17,500
>> だから、ランドをチェックアウト。

63
00:03:17,500 --> 00:03:22,270
それは、少し冗長なと混乱することができます
その時々私はそれを見つける

64
00:03:22,270 --> 00:03:26,150
単に私が知りたいのは何ですかグーグル
答えを見つけるための最善の方法。

65
00:03:26,150 --> 00:03:27,940
だから、Googleと練習。

66
00:03:27,940 --> 00:03:28,600
グーグルが得意ゲット。

67
00:03:28,600 --> 00:03:30,600
それはあなたの親友になります。

68
00:03:30,600 --> 00:03:34,300
>> だけでなく、Googleは、あなたはそれを見つけることができない場合
Googleで、cs50.net/discuss、それはだ

69
00:03:34,300 --> 00:03:35,550
ディスカッション·フォーラム。

70
00:03:35,550 --> 00:03:39,390
あなたが質問がある場合は、1チャンスである
あなたの700 +のピアにもいることがある

71
00:03:39,390 --> 00:03:42,110
質問と尋ねた可能性があります
それはすでに議論中

72
00:03:42,110 --> 00:03:43,540
フォーラムは、それが答えている。

73
00:03:43,540 --> 00:03:48,130
ですから、一般的な質問がある場合、または
あなたが思う疑問を持っている

74
00:03:48,130 --> 00:03:52,300
多分他の人が中に実行した可能性があり、
cs50.net/discussをチェックアウト。

75
00:03:52,300 --> 00:03:55,450
>> 最後に、最後の2、あなたがしたい場合は、
本当の人間、オフィスに話

76
00:03:55,450 --> 00:03:57,770
金曜日を通して時間月曜日。

77
00:03:57,770 --> 00:04:00,850
オンライン営業時間もあります
延長学生のため。

78
00:04:00,850 --> 00:04:04,370
そして最後になりましたが、確かではない、
私、感嘆符。

79
00:04:04,370 --> 00:04:05,960
みなさんは私の連絡先情報を持っている。

80
00:04:05,960 --> 00:04:11,940
あなたは何が必要な場合は、決して喜ばない
私に連絡することを躊躇。

81
00:04:11,940 --> 00:04:14,020
いつもそうして自由に感じる。

82
00:04:14,020 --> 00:04:17,490
あなたの非常に少数はGchatに私を追加し、
だから失望している、

83
00:04:17,490 --> 00:04:20,410
うまくいけば、それは間で変更します
この次のセクション。

84
00:04:20,410 --> 00:04:22,105
これまでの資源へのご質問？

85
00:04:22,105 --> 00:04:25,670

86
00:04:25,670 --> 00:04:27,450
素晴らしい。

87
00:04:27,450 --> 00:04:34,280
>> 最後に、別のプラグインのための
フィードバック、sayat.me/cs50。

88
00:04:34,280 --> 00:04:37,050
あなたは私の匿名のフィードバックを与えることができます
私がやっている方法について。

89
00:04:37,050 --> 00:04:38,320
つまり、先週は本当に役に立ちました。

90
00:04:38,320 --> 00:04:41,890
私はあなたたちからのコメントをいくつか持って
右側のセクションの後に、プラスから

91
00:04:41,890 --> 00:04:44,750
それを見、他の学生
週の間に、それ

92
00:04:44,750 --> 00:04:46,830
信じられないほど親切でした。

93
00:04:46,830 --> 00:04:50,250
私が試してみて、私の使用のを制限するつもりです
単語 "甘い"私は私が表示されます

94
00:04:50,250 --> 00:04:52,410
熱意と興奮
他の方法で。

95
00:04:52,410 --> 00:04:56,550
しかし、他の追加があった
実質的なフィードバック、

96
00:04:56,550 --> 00:04:57,600
プラスとデルタの両方。

97
00:04:57,600 --> 00:05:00,480
だから、私はあなたたちのフィードバックを与えてください
問題のセットで。

98
00:05:00,480 --> 00:05:01,790
私にフィードバックを与えること自由に感じ
私の教えに。

99
00:05:01,790 --> 00:05:04,010
私はあなたたちのためにここにいる。

100
00:05:04,010 --> 00:05:05,270
>> 素晴らしい。

101
00:05:05,270 --> 00:05:07,020
それは私が持っているすべてである
最初のセクション。

102
00:05:07,020 --> 00:05:08,565
誰もがいずれかを持っていますか
質問ここまで？

103
00:05:08,565 --> 00:05:12,370

104
00:05:12,370 --> 00:05:14,640
そして私はのためのノートを持っている
コントロールセンター。

105
00:05:14,640 --> 00:05:21,200
拡張生徒は私をメッセージとして送らきた
彼らはすべてのオーディオを取得していないと言って、

106
00:05:21,200 --> 00:05:23,870
それは修正するために私の力が不足しています。

107
00:05:23,870 --> 00:05:25,280
うまくいけば、それを取得
まもなく解決しました。

108
00:05:25,280 --> 00:05:28,850
こんにちは、あなたがオンラインで見ている場合は、
しかし、あなたは私を聞くことはできません。

109
00:05:28,850 --> 00:05:33,860
>> したがって、最初、私たちは行く
GDBを通過する。

110
00:05:33,860 --> 00:05:37,100
GDB、私が以前に示唆したように、
デバッグ·ツールです

111
00:05:37,100 --> 00:05:39,040
printf関数よりもはるかに良い。

112
00:05:39,040 --> 00:05:44,700
もしそうであれば、GDB、君たちを開始するには
あなたのアプライアンスを開きたい

113
00:05:44,700 --> 00:05:49,070
と私はあなたに電子メールで送信ファイルを取得
それ以前のバージョン - このファイルには、になります

114
00:05:49,070 --> 00:05:51,940
ビットで利用できるオンライン - 

115
00:05:51,940 --> 00:05:55,700
とGDBを実行します。/ファイルの名前。

116
00:05:55,700 --> 00:05:58,580
まず、もちろん、あなたがコンパイルする必要があります
GDBはのみで動作しているため、ファイル

117
00:05:58,580 --> 00:05:59,890
実行可​​能ファイル。

118
00:05:59,890 --> 00:06:02,300
>> しかし、あなたがこれまでに開始したい場合
GDB、あなたが最初に行うこと、

119
00:06:02,300 --> 00:06:04,550
あなたは、GDB /シーザーを実行します。

120
00:06:04,550 --> 00:06:08,340
だから、それは我々がしているプログラムの名前です
今それで行くつもり。

121
00:06:08,340 --> 00:06:12,810
だから私は、シーザーを作る書くつもりどのよ
私に実行可能ファイルを提供します

122
00:06:12,810 --> 00:06:14,100
ここに緑色で強調表示。

123
00:06:14,100 --> 00:06:19,250
そして私は、GDB /セザールを実行するつもりです。

124
00:06:19,250 --> 00:06:19,810
>> そしてそこに行く。

125
00:06:19,810 --> 00:06:24,540
あなたは私たちが私に言っていくつかのテキストを持って参照してください。
GDBのバージョンに関する、私を与える

126
00:06:24,540 --> 00:06:27,570
その後、いくつかの保証情報、そして我々
ソートに見えるのGDPプロンプトを、持っている

127
00:06:27,570 --> 00:06:29,350
我々のコマンドラインプロンプトのように、
しかし、あなたはそれが開いて参照してください。

128
00:06:29,350 --> 00:06:32,510
括弧は、GDB、近くに括弧。

129
00:06:32,510 --> 00:06:36,520
我々は、このファイルを継続し、デバッグする前に
私はあなたのすべてに送信されるので、次に見てみましょう

130
00:06:36,520 --> 00:06:40,220
いくつかの有用なコマンドは、私たちはセンスがある
私たちがカバーしようとしているものの。

131
00:06:40,220 --> 00:06:45,060
>> これらのコマンドは、ここに記載されています
私は一般的にそれらを使用する順番。

132
00:06:45,060 --> 00:06:50,230
だから私は実行することで、私のプログラムを起動する
プログラムのGBD。/名、

133
00:06:50,230 --> 00:06:51,360
この場合は、シーザー。

134
00:06:51,360 --> 00:06:57,430
した後、まず最初に、私は99.9％をする
時間の種類のブレークは平均である。

135
00:06:57,430 --> 00:06:59,070
すなわち、主にブレークポイントを設定します。

136
00:06:59,070 --> 00:07:03,260
基本的には、そこに何をやっている
プログラムがで停止しようとしているされている

137
00:07:03,260 --> 00:07:06,100
主なので、あなたはそれに行を検査し始めることができます
ラインによる、むしろすべて実行するよりも

138
00:07:06,100 --> 00:07:07,040
道を通して。

139
00:07:07,040 --> 00:07:09,730
あなたは、異なる時点で破ることができる
あなたのコードが、メイン一般的である

140
00:07:09,730 --> 00:07:11,870
開始するには良い場所。

141
00:07:11,870 --> 00:07:14,840
>> 私が実行したコマンドが実行されます。

142
00:07:14,840 --> 00:07:17,400
すなわち、プログラムの実行を開始し、
あなたがコマンドラインを入力する必要がある場合

143
00:07:17,400 --> 00:07:19,090
引数は、あなたはそれをそのコマンドを実行します。

144
00:07:19,090 --> 00:07:20,500
引数を指定して実行します。

145
00:07:20,500 --> 00:07:25,000
だから我々はバージョンに上書きしようとしているので、
プログラム君たちは、C、の

146
00:07:25,000 --> 00:07:26,160
PSET 2のために書いた - 

147
00:07:26,160 --> 00:07:29,880
この1は、もちろん、いくつかのバグを持っている
うまくいけば、我々は見つけることができますことを、その中に - 

148
00:07:29,880 --> 00:07:32,810
我々はいくつかのコマンドを使用して実行]を実行するつもり
ライン引数シーザーので、

149
00:07:32,810 --> 00:07:34,860
あなたたちは、問題ごとに知っているように
仕様を設定、一部を取り

150
00:07:34,860 --> 00:07:36,380
コマンドライン引数。

151
00:07:36,380 --> 00:07:40,000
>> コマンドの次のカップル、次の
1は実際には次のと呼ばれています。

152
00:07:40,000 --> 00:07:42,470
その1は、ラインによってあなたのラインを取る
あなたのプログラムを通じて。

153
00:07:42,470 --> 00:07:45,800
そう打つN Enterをすると表示されます
次の行に、実行

154
00:07:45,800 --> 00:07:46,880
前の行。

155
00:07:46,880 --> 00:07:49,440
ステップが移動しますだけでなく、
次の行が、

156
00:07:49,440 --> 00:07:51,070
あなたは関数の内部かかります。

157
00:07:51,070 --> 00:07:54,310
ですから、関数を書かれている場合は、
あなたのコードか、探検したい場合

158
00:07:54,310 --> 00:07:57,820
私には、例えば、あなたは、Sを打つことができ、
むしろの次の行に行くより

159
00:07:57,820 --> 00:08:02,390
あなたが右を通過しているファイル
今、あなたが実際にステップインします

160
00:08:02,390 --> 00:08:04,670
この関数とそのコードを参照してください。

161
00:08:04,670 --> 00:08:12,300
>> リストには、フレンドリーな非常にユーザーに、あなたを示しています
形式、約10行程度

162
00:08:12,300 --> 00:08:14,940
現在、コードのどこにいるか
だから、実際にはファイルを見ることができます

163
00:08:14,940 --> 00:08:17,810
むしろバックスワップを有し、かつより
異なるビュー間など。

164
00:08:17,810 --> 00:08:21,890
プリントは、printfのようなものです
その名前が示すとおり。

165
00:08:21,890 --> 00:08:24,020
つまり、変数が等しいあなたが何を示しています。

166
00:08:24,020 --> 00:08:25,870
>> インフォ地元の人々は本当に便利です。

167
00:08:25,870 --> 00:08:27,740
これは、印刷の特別なバージョンです。

168
00:08:27,740 --> 00:08:31,770
インフォ地元の人々は地元のあなたのすべてを示しています
変数は、あなたのためにそれらのすべてを出力します

169
00:08:31,770 --> 00:08:33,380
現在利用可能であることを。

170
00:08:33,380 --> 00:08:36,360
だからではなくするよりも、一般的に私は、
私は4つの変数をプリントアウト

171
00:08:36,360 --> 00:08:39,929
私はループにいる場合には好奇心のために
たとえば、私は情報の地元の人々を書き、

172
00:08:39,929 --> 00:08:43,470
そしてそれはどのような私のカウンタI私を紹介します
私は、配列だけでなく、等しく

173
00:08:43,470 --> 00:08:45,130
イコールで作業。

174
00:08:45,130 --> 00:08:47,530
>> 最後に、続けています。

175
00:08:47,530 --> 00:08:49,300
休憩を入力すると、あなたを停止します
ブレークポイントで。

176
00:08:49,300 --> 00:08:51,380
次の方法でラインを通って歩くことができます
次のステップに沿って。

177
00:08:51,380 --> 00:08:55,640
あなたの次に実行するプログラムを継続
場合は、ポイントを壊すか、完了まで

178
00:08:55,640 --> 00:08:57,180
これ以上のブレークポイントがあります。

179
00:08:57,180 --> 00:09:00,060
もしあれば無効にするには、ブレークポイントを削除します
メインでのブレークが判断しました

180
00:09:00,060 --> 00:09:01,890
不適切な、あなたがしたい
どこか別の場所に設定してください。

181
00:09:01,890 --> 00:09:05,090
そして最後にQ、終了、GDBから取得します。

182
00:09:05,090 --> 00:09:10,784
>> したがって、このプログラムは、。/シーザー、我々は行く
今に目を通すと我する

183
00:09:10,784 --> 00:09:13,490
見つけて、GDBを使用しようとしている
このプログラムのバグ。

184
00:09:13,490 --> 00:09:18,110
私は以前にこのプログラムを実行したと
50を確認して、私は1しかめ面を得た。

185
00:09:18,110 --> 00:09:22,310
それが存在していたすべてのものは、それは、それをコンパイルした
多くのテストに合格したが、用

186
00:09:22,310 --> 00:09:27,950
何らかの理由で、第5に合格しなかった
BARFOO、すべてのキャップを回すテスト、、へ

187
00:09:27,950 --> 00:09:33,350
E-D-U-I-R-R、すべて大文字、
キーように、3つを使用して。

188
00:09:33,350 --> 00:09:34,090
私はかなり親しま。

189
00:09:34,090 --> 00:09:35,410
私は、1文字で降りた。

190
00:09:35,410 --> 00:09:37,340
だからここにいくつかの小さなミスがあります。

191
00:09:37,340 --> 00:09:38,070
私は自分のコードを見てきた。

192
00:09:38,070 --> 00:09:38,850
私はそれを把握することができませんでした。

193
00:09:38,850 --> 00:09:41,740
うまくいけば、あなたたちは私を助けることができる
このバグが何であるかを把握。

194
00:09:41,740 --> 00:09:44,610
>> だから、我々はしているエラーです
を検索する。

195
00:09:44,610 --> 00:09:46,090
それでは、GDBに移動しましょう​​。

196
00:09:46,090 --> 00:09:51,100
繰り返しますが、私は、GDB /シーザーを実行した
だから今、私たちは、GDBにいる。

197
00:09:51,100 --> 00:09:54,290
そして、最初は何ですか
私は何をすべきなこと？

198
00:09:54,290 --> 00:09:56,680
私はGDBを入力した。

199
00:09:56,680 --> 00:10:00,316
誰かが私によいを与える
入力するコマンド。

200
00:10:00,316 --> 00:10:01,140
>> 学生：メインブレイク。

201
00:10:01,140 --> 00:10:01,800
>> JASONハーシュホーン：メインブレイク。

202
00:10:01,800 --> 00:10:02,900
幻想的。

203
00:10:02,900 --> 00:10:03,560
それではインチそれを入力してみましょう

204
00:10:03,560 --> 00:10:06,390
君たちはここに見たり、従うことができます
お使いのコンピュータ上に沿って。

205
00:10:06,390 --> 00:10:09,410
メインブレイク、あなたが表示されます
ブレークポイントは、とした - 

206
00:10:09,410 --> 00:10:12,340
それは私にいくつかの奇妙なメモリ·アドレスを与え、
そしてそれはまた、私に行番号を示します。

207
00:10:12,340 --> 00:10:15,310
私は、このファイルを振り返るとしたら、
私はその主を理解するであろう

208
00:10:15,310 --> 00:10:17,700
21行目に起こった。

209
00:10:17,700 --> 00:10:18,950
私は次は何を実行する必要がありますか？

210
00:10:18,950 --> 00:10:22,970

211
00:10:22,970 --> 00:10:25,060
私のプログラムは、実行されている？

212
00:10:25,060 --> 00:10:25,650
いいえ。

213
00:10:25,650 --> 00:10:27,175
だから私は、次は何を実行する必要がありますか？

214
00:10:27,175 --> 00:10:27,520
>> 学生：実行します。

215
00:10:27,520 --> 00:10:28,050
>> JASONハーシュホーン：ファイル名を指定して実行。

216
00:10:28,050 --> 00:10:30,760
私はちょうど実行]を実行するか、すべき必要があります
私は、いくつかの他のものを追加しますか？

217
00:10:30,760 --> 00:10:31,960
>> 学生：引数を指定して実行します。

218
00:10:31,960 --> 00:10:33,320
>> JASONハーシュホーン：で実行
コマンド引数。

219
00:10:33,320 --> 00:10:36,420
と私は非常に特定のデバッグてるので、
場合、私はそれを入力してください

220
00:10:36,420 --> 00:10:37,120
コマンドライン引数。

221
00:10:37,120 --> 00:10:42,290
だから私は、再び、である、3を実行するつもりだ
私がチェック50から得た出力。

222
00:10:42,290 --> 00:10:44,240
プログラムを開始する。

223
00:10:44,240 --> 00:10:45,420
私たちは、数行を通過します。

224
00:10:45,420 --> 00:10:47,700
これで、私たちは21行にしていることがわかります。

225
00:10:47,700 --> 00:10:49,200
どうすれば我々は、ライン21にしていることを知っていますか？

226
00:10:49,200 --> 00:10:52,170
なぜならあなたが左に見れば
そこに私のターミナルウィンドウの

227
00:10:52,170 --> 00:10:53,120
それはライン21を言う。

228
00:10:53,120 --> 00:10:57,010
そして、それは、実際には、私を与える
21行目にあるコード。

229
00:10:57,010 --> 00:10:58,440
だから私は、以前のmisspoke。

230
00:10:58,440 --> 00:10:59,770
メインは21行で、実際にはありません。

231
00:10:59,770 --> 00:11:02,000
メインは21以上の数行です。

232
00:11:02,000 --> 00:11:04,300
しかし、21行目では、それはです
どこで破壊している。

233
00:11:04,300 --> 00:11:06,280
このコード行は、あります
まだ実行されません。

234
00:11:06,280 --> 00:11:06,890
これは重要です。

235
00:11:06,890 --> 00:11:09,120
ご覧の行ではありませんがあります
まだ実行されて。

236
00:11:09,120 --> 00:11:12,650
つまり、次のコード行です
あなたが実行しようとしている。

237
00:11:12,650 --> 00:11:15,860
>> 君たちがいるように、次の行、
と、おそらく馴染みの、これは

238
00:11:15,860 --> 00:11:20,070
条件私が持っているかどうかを確認
コマンドライン引数を入力しました。

239
00:11:20,070 --> 00:11:22,140
と私には、2番目は何ですか
それは何の一部？

240
00:11:22,140 --> 00:11:23,457
私には何ですか？

241
00:11:23,457 --> 00:11:24,950
>> 学生：整数に変更する。

242
00:11:24,950 --> 00:11:25,450
>> JASONハーシュホーン：申し訳ありませんが？

243
00:11:25,450 --> 00:11:27,400
>> 学生：それは変わりつつ
整数の引数。

244
00:11:27,400 --> 00:11:30,890
>> JASONハーシュホーン：だから私に引数を変更
整数への文字列からV1。

245
00:11:30,890 --> 00:11:32,140
そしてそれは何をチェックするのですか？

246
00:11:32,140 --> 00:11:35,414

247
00:11:35,414 --> 00:11:37,112
>> 学生：二がある場合
コマンドライン引数はさておき

248
00:11:37,112 --> 00:11:38,100
プログラムを実行しているから。

249
00:11:38,100 --> 00:11:39,460
>> JASONハーシュホーン：そして、何だ
この年の後半

250
00:11:39,460 --> 00:11:41,220
ブール式をチェック？

251
00:11:41,220 --> 00:11:42,540
こっちにこの部分は、私に？

252
00:11:42,540 --> 00:11:44,080
>> 学生：それは否定的だ場合。

253
00:11:44,080 --> 00:11:45,380
>> JASONハーシュホーン：確かに何を作る？

254
00:11:45,380 --> 00:11:47,120
>> 学生：それを確認すること
正、実際には、である。

255
00:11:47,120 --> 00:11:47,650
>> JASONハーシュホーン：その通りです。

256
00:11:47,650 --> 00:11:50,600
これはだかどうかを確認してい
陰性、そしてそれは、I負である場合

257
00:11:50,600 --> 00:11:53,220
気持ちを次の行のマイトを持っている
私は、ユーザーに叫んでも。

258
00:11:53,220 --> 00:11:55,930
それでは、この行を実行するためにエンドをヒットしてみましょう。

259
00:11:55,930 --> 00:11:59,925
私たちはあなたたち、その行が表示されない
多分叫んで参照することが期待

260
00:11:59,925 --> 00:12:03,030
ユーザー、次に戻って、理由
この行は実行されませんでした。

261
00:12:03,030 --> 00:12:03,840
私は3に入った。

262
00:12:03,840 --> 00:12:06,860
だから私は、実際には、2のコマンドを入力しなかった
ライン引数、および3である

263
00:12:06,860 --> 00:12:07,610
ゼロよりも大きい。

264
00:12:07,610 --> 00:12:09,950
だから我々は、その行を見て、我​​々は実行され、
しかし、我々はステップませんでした

265
00:12:09,950 --> 00:12:11,300
If条件内部。

266
00:12:11,300 --> 00:12:17,060
>> だから今、次の、私は私が設定してい参照
int型のキーは、私は、V1をARGに相当します。

267
00:12:17,060 --> 00:12:18,840
だから私は、変数のキーを作成しています。

268
00:12:18,840 --> 00:12:22,450
だから、私は今、キーを印刷した場合、理由
それはあなたが見ることができます

269
00:12:22,450 --> 00:12:26,040
変数内の値、
キーは47に等しい。

270
00:12:26,040 --> 00:12:28,810
それは奇妙なことだが、もちろん、
私は持っていないためです

271
00:12:28,810 --> 00:12:30,490
まだその行を実行する。

272
00:12:30,490 --> 00:12:35,880
私はNを打つのであれば、今、その行を実行し、
PRINTキーをし、キー​​は、3に等しくなる

273
00:12:35,880 --> 00:12:37,740
我々はそれが等しくなるように期待するものである。

274
00:12:37,740 --> 00:12:41,170
>> だからもう一度、GDB、ラインあなたの中に
あなたはまだ実行されていない参照してください。

275
00:12:41,170 --> 00:12:44,850
あなたは、NまたはSまたは番号にヒットする必要があります
実際に他のコマンドの

276
00:12:44,850 --> 00:12:46,610
その行を実行します。

277
00:12:46,610 --> 00:12:47,380
Printキー。

278
00:12:47,380 --> 00:12:48,280
キーの3時。

279
00:12:48,280 --> 00:12:49,750
ここまでは順調ですね。

280
00:12:49,750 --> 00:12:51,000
文字列はプレーンテキストです。

281
00:12:51,000 --> 00:12:52,270
のは、その行を実行してみましょう。

282
00:12:52,270 --> 00:12:53,970
私は、ユーザーから文字列を取得しています。

283
00:12:53,970 --> 00:12:58,690
>> それでは、私のチェック50で見てみましょう、私
BARFOOすべて大文字を入力するので、

284
00:12:58,690 --> 00:13:01,330
それは私が入るだろうものだ。

285
00:13:01,330 --> 00:13:07,300
私は今、プレインテキストを印刷する場合。

286
00:13:07,300 --> 00:13:08,610
あなたはそれが文字列に等しい表示されます。

287
00:13:08,610 --> 00:13:11,100
それは私にいくつかの他の奇妙進を与えます
数が、それはでない

288
00:13:11,100 --> 00:13:13,620
私の文字列がBARFOOであるという事実を言う。

289
00:13:13,620 --> 00:13:19,308
私は、キーがで等しかったか見たいと思った場合
この時点で、私はどのようにキーをチェックすることができます？

290
00:13:19,308 --> 00:13:20,710
>> 学生：Printキー。

291
00:13:20,710 --> 00:13:22,010
>> JASONハーシュホーン：Printキー、正確に。

292
00:13:22,010 --> 00:13:23,260
そして実際に、ショートカットがあります。

293
00:13:23,260 --> 00:13:25,910
あなたがプリントを入力するのに疲れたなら、
あなただけのPを入力することができます。

294
00:13:25,910 --> 00:13:28,340
だから、pキーがまったく同じことを行います。

295
00:13:28,340 --> 00:13:29,730
そして再び、私はそれが3に等しい参照してください。

296
00:13:29,730 --> 00:13:34,760
>> 私は何キーの両方を検索する場合
そしてBARFOO同時に等しかった

297
00:13:34,760 --> 00:13:37,215
私はそれぞれを入力するのは疲れていた
個別に1つ、私が

298
00:13:37,215 --> 00:13:38,590
インフォ地元の人々と入力することができます。

299
00:13:38,590 --> 00:13:41,170
つまり、キーが3に等しい私に与えます。

300
00:13:41,170 --> 00:13:42,500
プレーンテキストはBARFOOに等しい。

301
00:13:42,500 --> 00:13:45,265
それはまた私に、これら2奇妙なことを提供します
上部には、この変数iと

302
00:13:45,265 --> 00:13:46,590
この変数n。

303
00:13:46,590 --> 00:13:48,460
>> それらは実際に存在している
私のメインプログラム。

304
00:13:48,460 --> 00:13:51,280
私たちは、それらをまだ発生していない
しかし、プレビューとして、それらの

305
00:13:51,280 --> 00:13:52,880
私のループのために存在する。

306
00:13:52,880 --> 00:13:55,360
だから、今、彼らはいくつかの奇妙なと等しく
数字、彼らはされていないため、

307
00:13:55,360 --> 00:13:58,300
まだ初期化されているが、彼らはまだ存在しない
メモリには違いますので単に設定している

308
00:13:58,300 --> 00:14:00,220
いくつかのごみ値に設定します。

309
00:14:00,220 --> 00:14:02,890
しかし、我々は、プレーン内のキーを見ますか？
すぐそこにテキスト。

310
00:14:02,890 --> 00:14:06,390
>> だから私は、この行を実行するつもりです、
ライン34、forループ。

311
00:14:06,390 --> 00:14:08,220
私たちは、に飛び込むつもりだ
Nを押すことで、forループ。

312
00:14:08,220 --> 00:14:10,050
そして、我々は、forループの中にいる。

313
00:14:10,050 --> 00:14:11,360
私たちは、最初のチェックにいる。

314
00:14:11,360 --> 00:14:14,300
そして再び、これらは一種のはず
これがあったので、あなたによく知られ

315
00:14:14,300 --> 00:14:18,080
シーザー書かれたプログラムが、
再び、バグのようなものを持っています。

316
00:14:18,080 --> 00:14:21,940
>> そして今、私はだから、私は、インフォ地元の人々を行う場合
ループのそれの中に、次のように表示されます

317
00:14:21,940 --> 00:14:23,900
我々が期待として、私は、ゼロに等しいこと。

318
00:14:23,900 --> 00:14:26,820
それは我々がそれを設定したものだと、初期化
それのためのループ内に。

319
00:14:26,820 --> 00:14:27,560
nが6に等しい。

320
00:14:27,560 --> 00:14:30,700
我々は設定しているためそれはまた、理にかなっている
それをプレーンテキストのstrlen関数に。

321
00:14:30,700 --> 00:14:34,270
だから私は情報の地元の人や印刷をしたい
変数に、多くの場合、ことを確認する

322
00:14:34,270 --> 00:14:36,370
すべてが常にあるもの
私はそれが等しくなるように期待しています。

323
00:14:36,370 --> 00:14:39,800
この場合は、すべてがある
私はそれが等しくなるように期待するもの。

324
00:14:39,800 --> 00:14:41,850
>> それではを通じて移動を開始しましょう
このループのために。

325
00:14:41,850 --> 00:14:45,715
プレーンな場合、私は上だラインは、ライン36である
テキスト私は、プレーンよりも大きい

326
00:14:45,715 --> 00:14:48,540
テキスト私は、以下のzに等しい。

327
00:14:48,540 --> 00:14:51,880
私は私の問題は私の最初ではない知っている
手紙には、二文字でだ。

328
00:14:51,880 --> 00:14:56,290
私たちは、チェックイン時に戻ってみると
50、Bは、Eの罰金になります。

329
00:14:56,290 --> 00:14:59,010
私はAを取り、としてそれを残している
A、D.だからそれを変更しない

330
00:14:59,010 --> 00:15:00,200
何かが間違っている
番目の文字。

331
00:15:00,200 --> 00:15:01,640
だから私は移動するつもりだ
そこに第二中。

332
00:15:01,640 --> 00:15:06,030
>> しかし、私はどのようなプレーンをチェックしたいなかった場合
私は、この特定のに等しかったテキスト

333
00:15:06,030 --> 00:15:07,760
場合、私はそれが何をすべきだと思います？

334
00:15:07,760 --> 00:15:10,980
私はこのプレーンテキストは何を等しくなければならない
のためのループを通る最初のラウンド？

335
00:15:10,980 --> 00:15:14,046

336
00:15:14,046 --> 00:15:15,110
>> 学生：ゼロ？

337
00:15:15,110 --> 00:15:16,510
>> JASONハーシュホーン：私のプレーンテキスト？

338
00:15:16,510 --> 00:15:21,180
だから、私は、もちろん資本B.でなければなりません
ゼロに等しいが、プレーンテキスト

339
00:15:21,180 --> 00:15:25,600
ブラケットゼロクローズブラケットは、Bに等しい
文字列なので、我々は先週見たように、

340
00:15:25,600 --> 00:15:28,650
配列ですので、取得している
それから、最初の文字。

341
00:15:28,650 --> 00:15:34,960
だからもう一度、私は、プレーンテキストをプリントアウトした場合
私は、実際には、文字を得るのですか

342
00:15:34,960 --> 00:15:36,560
B.とその通り、きちんとしたの？

343
00:15:36,560 --> 00:15:40,380
私は実際にプレーンテキストIを持っていない
それは私が設定した変数の1ではありません

344
00:15:40,380 --> 00:15:42,950
または初期化しますが、印刷することができます
物事の全体のホスト外

345
00:15:42,950 --> 00:15:45,640
あなたがしたい場合。

346
00:15:45,640 --> 00:15:47,340
>> しかし、ここでは間を移動してみましょう。

347
00:15:47,340 --> 00:15:50,050
プレーンテキストIはAよりも大きい場合と
プレーンテキスト私は以下に等しい

348
00:15:50,050 --> 00:15:53,290
我々が持っているので、Zは、それは明らかに真である
私は実行するつもり資本B.

349
00:15:53,290 --> 00:15:54,230
その上にいくつかのコマンドを実行します。

350
00:15:54,230 --> 00:15:58,530
我々は先週、その数学を見たので、よ
それが動作するのは当然だと取る

351
00:15:58,530 --> 00:16:00,900
右50をチェックしてください方法。

352
00:16:00,900 --> 00:16:03,720
>> これらの中括弧、最初の1
私があれば出て行くことを示した

353
00:16:03,720 --> 00:16:07,030
条件、第1は示した
私は、forループから出てること。

354
00:16:07,030 --> 00:16:10,400
私は[次へ]を打ったときなど、今、我々が表示されます
我々は再び戻ってループにいる。

355
00:16:10,400 --> 00:16:11,970
我々は経由つもりだ
再びforループ。

356
00:16:11,970 --> 00:16:18,110
それでは、実際に第二にステップインしましょう
ループとタイプの繰り返し

357
00:16:18,110 --> 00:16:20,520
インフォ地元の人。

358
00:16:20,520 --> 00:16:22,190
>> だから我々は、2回目の反復にいる
私たちのforループの。

359
00:16:22,190 --> 00:16:24,530
私たちは期待している、1に等しい。

360
00:16:24,530 --> 00:16:26,650
Nは我々が期待6に等しい。

361
00:16:26,650 --> 00:16:28,810
キーは、我々が期待3に等しい。

362
00:16:28,810 --> 00:16:32,625
プレーンテキストには、等しく、表示されます
EARFOOは今、もはやBARFOOていないため、

363
00:16:32,625 --> 00:16:37,930
私たちの前の反復で、Bがあった
首都Eに変更だからうとしている

364
00:16:37,930 --> 00:16:40,040
問題が発生したので、このように
我々が行っている場所である

365
00:16:40,040 --> 00:16:41,130
デバッギングに飛び込む。

366
00:16:41,130 --> 00:16:43,365
しかし、誰もが疑問を持っていません
我々はこれまでに何をやったかはどうでしょうか？

367
00:16:43,365 --> 00:16:46,770

368
00:16:46,770 --> 00:16:47,910
幻想的。

369
00:16:47,910 --> 00:16:52,710
>> だから我々は、次の場合に、これを実行しようとしている
条件、私は閉じたプレーンテキストのブラケット

370
00:16:52,710 --> 00:16:57,500
ブラケットAより大きく、プレーンテキストI
以下Zに等しいが前

371
00:16:57,500 --> 00:17:00,450
これはどこにあるので、私は、それに入る
私は私が指すようにしたい、私のエラーが知っている

372
00:17:00,450 --> 00:17:06,859
Iのプレーンテキスト出そう
のプリントを出してみましょう。

373
00:17:06,859 --> 00:17:12,020
そのように、それは、キャラクタAに等しくない
これまでのところ、すべてが順調と良いようです。

374
00:17:12,020 --> 00:17:14,740
>> だから私は、私のロジック当たりの行を期待する
この行は本当でなければなりません。

375
00:17:14,740 --> 00:17:16,099
これは大文字です。

376
00:17:16,099 --> 00:17:20,599
私はNを打つなら、我々はこのことを実現するか
行は、実際には実行されませんでした。

377
00:17:20,599 --> 00:17:22,609
私があれば、他にまで跳ね上がった。

378
00:17:22,609 --> 00:17:25,460
それはなぜ起こるのですか？

379
00:17:25,460 --> 00:17:27,480
>> 学生：あなたが持っているのであなたの状態
プレーンテキストの大きい

380
00:17:27,480 --> 00:17:29,130
A、等しくないか、より大きくより。

381
00:17:29,130 --> 00:17:32,260
>> JASONハーシュホーン：だから、私はプレーンテキストを持っていた
私は、大きくないよりも大きい

382
00:17:32,260 --> 00:17:32,850
イコール。

383
00:17:32,850 --> 00:17:38,130
そう明らかに、資本Aはしませんでした
条件場合は、これをトリガし、私たちはやった

384
00:17:38,130 --> 00:17:40,520
それに足を踏み入れると、私たちはしませんでした
必要なシフトをしない。

385
00:17:40,520 --> 00:17:41,360
だから実際には、これだけです。

386
00:17:41,360 --> 00:17:42,920
私は私のバグを考え出した。

387
00:17:42,920 --> 00:17:46,775
私は自分のソース·ファイルに戻って行くことができる、
それを変更し、それを更新し、

388
00:17:46,775 --> 00:17:47,855
再び50をチェックして実行します。

389
00:17:47,855 --> 00:17:52,590
>> しかし、我々は単に教育のために、表示されます
日本酒、私は続けるします。

390
00:17:52,590 --> 00:17:59,580
他の場合は、どちらか実行されませんが、
何の代わりに等しいことはコマンドです

391
00:17:59,580 --> 00:18:00,500
それは変わりません。

392
00:18:00,500 --> 00:18:04,840
だから、それは全く変化しなかったら、私
ここにプレーンテキストを印刷し、我々は行く表示されます

393
00:18:04,840 --> 00:18:08,250
そのループスルーのために、実際にはしませんでした
全くその二文字を変更。

394
00:18:08,250 --> 00:18:09,600
それはまだ資本A.です

395
00:18:09,600 --> 00:18:12,690
>> だからもう一度、私たちは、エラーをデバッグする。

396
00:18:12,690 --> 00:18:17,380
我々があったことに気づいた
不足しているいくつかのロジック。

397
00:18:17,380 --> 00:18:20,590
そして、我々は前に事前にそれをデバッグ
実際にその行を実行すると、

398
00:18:20,590 --> 00:18:24,320
しかし、あなたはちょうど私達が持っていた気づいているだろう
[次へ]をヒットした場合に、そのほかのにジャンプし、

399
00:18:24,320 --> 00:18:26,710
それはつまり、もし条件
本当ではなかった。

400
00:18:26,710 --> 00:18:29,550
私たちは、実際には、取得していない
我々は期待された結果。

401
00:18:29,550 --> 00:18:33,240
それでは、我々は持っていた、プロンプトが表示されている可能性
私たちを見て、そう明敏されていない

402
00:18:33,240 --> 00:18:38,510
その条件と実際には、かどうかを確認する場合
私たちの状態はに評価する必要があります

403
00:18:38,510 --> 00:18:41,150
現在のコンテキストでは真。

404
00:18:41,150 --> 00:18:42,880
>> つまり、このプログラムをデバッグするためのすべてです。

405
00:18:42,880 --> 00:18:45,340
誰もが疑問を持っていますか？

406
00:18:45,340 --> 00:18:50,486
私は、GDBを終了し、どのコマンド打つだろうか？

407
00:18:50,486 --> 00:18:53,900
Q.そして私は要求されます、
とにかく終了しますか？

408
00:18:53,900 --> 00:18:54,390
yesまたはno。

409
00:18:54,390 --> 00:18:58,440
私はイエスのヒットだろう、と私は、GDBを終了しています。

410
00:18:58,440 --> 00:19:00,860
>> だから、GDBへの迅速なプライマーた。

411
00:19:00,860 --> 00:19:03,430
実際に、現実のシナリオでは、
私はオフィスの時間でこれをした。

412
00:19:03,430 --> 00:19:06,710
私は、この正確なプログラムをGDBed
学生と営業時間。

413
00:19:06,710 --> 00:19:12,410
そして、我々は我々が見たコ​​マンドに戻った場合
前に、まず、ブレーク主に使用される

414
00:19:12,410 --> 00:19:13,190
我々が行ったもの。

415
00:19:13,190 --> 00:19:16,060
私たちは、コマンドライン引数にファイル名を指定して実行に使用、
我々が行った二つ目。

416
00:19:16,060 --> 00:19:18,520
我々は移動するには、次のロットを使用
ラインを通して私たち。

417
00:19:18,520 --> 00:19:20,310
そして再び、ショートバージョン
の次のnです。

418
00:19:20,310 --> 00:19:22,920
これはカッコ内にい
スライド上のグレー。

419
00:19:22,920 --> 00:19:28,590
>> 私たちはステップを使用していないが、我々はしませんでした
必ずしもこのような場合のためにする必要があります。

420
00:19:28,590 --> 00:19:32,150
しかし、我々は、後少しでそれを使用する場合があります
今日の上の私たちが、デバッグしている場合は、

421
00:19:32,150 --> 00:19:36,500
たとえば、二分探索するときのバイナリ
検索は別々に呼ばれて

422
00:19:36,500 --> 00:19:38,200
機能だけあります
それに多少の誤差はご了承ください。

423
00:19:38,200 --> 00:19:40,440
私たちは、足を踏み入れるするつもりだ
二分探索の呼び出しと

424
00:19:40,440 --> 00:19:41,840
実際にそれをデバッグします。

425
00:19:41,840 --> 00:19:45,130
我々が持っていたので、我々はどちらを使用していないリスト
我々のコードの良識があれば、私

426
00:19:45,130 --> 00:19:48,420
どのようなコード私の感覚を取得したいんでした
私は、リストを使用することができ、周りのだった。

427
00:19:48,420 --> 00:19:50,310
>> 我々は、我々が使用情報、地元の人々を使用して印刷。

428
00:19:50,310 --> 00:19:53,260
続けて、我々はこの中で使用する必要はありませんでした
ケースは、どちらも我々は使用する必要はありませんでした

429
00:19:53,260 --> 00:19:55,060
無効にするには、我々は使用が終了しました。

430
00:19:55,060 --> 00:19:57,850
再度、これらの10個のコマンド、
それらを実践しています。

431
00:19:57,850 --> 00:20:00,770
これらの10のコマンドを理解していれば、
あなたがいずれかをデバッグするために設定する必要があります

432
00:20:00,770 --> 00:20:02,525
GDBの問題。

433
00:20:02,525 --> 00:20:05,230

434
00:20:05,230 --> 00:20:08,420
>> だから我々はするには、もう一度、上に行くしようとしている
セクションの核心は、今日、上に行く

435
00:20:08,420 --> 00:20:09,720
これらの並べ替えと検索
アルゴリズム。

436
00:20:09,720 --> 00:20:14,075
我々はそうする前に、もう一度、ご質問、
GDBへのコメント、懸念？

437
00:20:14,075 --> 00:20:16,750

438
00:20:16,750 --> 00:20:20,960
だから、誰もが使用しようとする
GDBはなく、printfの？

439
00:20:20,960 --> 00:20:24,550
永遠の便宜上そう皆、、
誰もが自分の頭を右にうなずいている

440
00:20:24,550 --> 00:20:27,400
今、私はオフィスの時間で、あなたが表示されます
そして、すべてのTFはあなたが表示され、

441
00:20:27,400 --> 00:20:29,460
それらは、使用する方法を私を見る、と言うでしょう
GDB、あなたができるようになります

442
00:20:29,460 --> 00:20:31,240
右、それらを表示するには？

443
00:20:31,240 --> 00:20:31,760
のようなもの？

444
00:20:31,760 --> 00:20:32,640
多分うまくいけば。

445
00:20:32,640 --> 00:20:33,670
涼しい。

446
00:20:33,670 --> 00:20:35,790
>> だから我々はに移動しようとしている
ソートや検索を。

447
00:20:35,790 --> 00:20:40,710
あなたは、私がすでにソートされたリストを持って表示されます
私たちが、それを行っていないため

448
00:20:40,710 --> 00:20:42,220
常にそうであると。

449
00:20:42,220 --> 00:20:49,170
だから、問題にするための仕様を設定
問題は3を設定すると、ショートパンツを持っている

450
00:20:49,170 --> 00:20:51,410
あなたが見ることができることと、実際に
これらのショートパンツを見るために要求されます。

451
00:20:51,410 --> 00:20:55,090
また、講義では先週、我々は渡った
これらのアルゴリズムの多くは、私はよ

452
00:20:55,090 --> 00:20:59,150
行くクラスで時間を費やすつもりはない
これらもう一度アルゴリズムや図面の上

453
00:20:59,150 --> 00:21:01,130
どのようにこれらの写真
アルゴリズムが働く。

454
00:21:01,130 --> 00:21:04,030
繰り返しますが、再度見ることができる情報
講義、またはその情報

455
00:21:04,030 --> 00:21:08,570
ショートパンツに抜群に捕獲される
これらの検索のために、すべての

456
00:21:08,570 --> 00:21:10,920
これcs50.netでご利用いただけます。

457
00:21:10,920 --> 00:21:14,200
>> だからではなく、私たちはするつもりだ
行うには、プログラムを書くことです。

458
00:21:14,200 --> 00:21:18,190
私たちは、どのように精神的なモデルを、センスがある
彼らは我々が行っているものをそのように作業し、

459
00:21:18,190 --> 00:21:20,210
やることに対する真のためにそれらをコードです。

460
00:21:20,210 --> 00:21:23,430
我々は、メンタルモデルを有効にするつもりだ、
にその絵、可能ならば、

461
00:21:23,430 --> 00:21:24,960
実際のコード。

462
00:21:24,960 --> 00:21:28,460
そして、あなたは少し混乱した場合には
メンタルモデルにかすんで、私は完全に

463
00:21:28,460 --> 00:21:28,770
理解しています。

464
00:21:28,770 --> 00:21:30,540
>> 私たちは、実際にするつもりはない
コー​​ドすぐににジャンプします。

465
00:21:30,540 --> 00:21:36,030
したがって、このスライドは、このプロンプトが求められている間
あなたバイナリ検索をコーディングすると、

466
00:21:36,030 --> 00:21:39,470
実際には、反復バージョン
バイナリサーチ、まず最初に私が

467
00:21:39,470 --> 00:21:42,370
本当にあなたが何をしているか
いくつかの擬似コードを記述します。

468
00:21:42,370 --> 00:21:47,020
だから、このメンタルモデルを持っている
どのように二分探索の作品。

469
00:21:47,020 --> 00:21:50,060
あなたが持っている場合、紙のシートを取り出し
容易に利用可能な1、または開く

470
00:21:50,060 --> 00:21:52,520
テキストエディタ、そして私がしたい
書いて皆。

471
00:21:52,520 --> 00:21:57,470
書き込みに4分かかる
二分探索のための擬似コード。

472
00:21:57,470 --> 00:21:58,990
>> 繰り返しますが、そのメンタルモデルを考える。

473
00:21:58,990 --> 00:22:01,980
ご質問がある場合、私は周りに来るよ
私たちは絵を描くことができます。

474
00:22:01,980 --> 00:22:06,220
しかし、最初に、我々はプログラミングを開始する前に、
私が書きたいのですが

475
00:22:06,220 --> 00:22:09,920
二分探索のための擬似コードそうときに我々
でのダイビングを、我々はいくつかの方向性を持っている

476
00:22:09,920 --> 00:22:12,110
我々は頭べき場所へ。

477
00:22:12,110 --> 00:22:15,330
>> 学生：私たちは、の配列をとることができる
我々が得る値は、すでにソートされている？

478
00:22:15,330 --> 00:22:17,960
>> JASONハーシュホーン：だから二分探索のための
動作するように - 優秀な質問を - あなたは

479
00:22:17,960 --> 00:22:20,970
ソートされた中で取らなければならない
値の配列。

480
00:22:20,970 --> 00:22:22,290
だから、それが動作すると仮定します。

481
00:22:22,290 --> 00:22:23,480
我々は、このスライドに戻って行きます。

482
00:22:23,480 --> 00:22:27,220
あなたは紫の関数で表示されます
宣言は、ブールbinary_searchのintで

483
00:22:27,220 --> 00:22:29,230
値、int型の値はint nである。

484
00:22:29,230 --> 00:22:32,910
あなたがした場合、これは見覚えがあるはず
すでに近づいたりを得て

485
00:22:32,910 --> 00:22:34,580
問題が設定された汚れた手。

486
00:22:34,580 --> 00:22:35,910
>> しかし、それはあなたの関数宣言です。

487
00:22:35,910 --> 00:22:39,080
繰り返しますが、心配する必要はありません
現時点ではそれだけ。

488
00:22:39,080 --> 00:22:43,660
私が本当にあなたがしたいことは取るです
擬似コードのバイナリへの4分

489
00:22:43,660 --> 00:22:46,380
検索し、我々は行くよ
グループとして、その上に。

490
00:22:46,380 --> 00:22:47,500
そして私の周り来る。

491
00:22:47,500 --> 00:22:49,590
ご質問がございましたら、気軽に
手を上げ、無料です。

492
00:22:49,590 --> 00:25:07,110

493
00:25:07,110 --> 00:25:09,680
>> なぜあなたは2分以上を取ることはありません
擬似コードを仕上げるには？

494
00:25:09,680 --> 00:25:13,690

495
00:25:13,690 --> 00:25:15,820
私はこれがあることをばかげて見えるかもしれません知っている
我々は上に多くの時間を費やしている

496
00:25:15,820 --> 00:25:20,350
にしても、実際にはない何か
Cが、特にこれらの多くのため

497
00:25:20,350 --> 00:25:24,030
挑戦的なアルゴリズムと問題
我々は把握する必要がありセット、

498
00:25:24,030 --> 00:25:27,210
擬似コードで始まる心配はない
構文については、単に気にせ

499
00:25:27,210 --> 00:25:29,150
ロジックは、信じられないほど便利です。

500
00:25:29,150 --> 00:25:32,720
そしてそのように、あなたは2を解決していない
一度に非常に難しい問題。

501
00:25:32,720 --> 00:25:35,390
あなただけのロジックに焦点を当てている、と
あなたは構文に移動します。

502
00:25:35,390 --> 00:25:59,960

503
00:25:59,960 --> 00:26:01,385
>> [OK]をクリックします。

504
00:26:01,385 --> 00:26:03,680
を経由起動してみましょう
擬似コード。

505
00:26:03,680 --> 00:26:05,380
私は、バイナリ、ここには記述されています
検索擬似コード。

506
00:26:05,380 --> 00:26:07,360
私たちは、上でこれを書きます
一緒に乗る。

507
00:26:07,360 --> 00:26:10,040
または私はそれを書くだろうとあなたがあげる
私私は必要なのプロンプト。

508
00:26:10,040 --> 00:26:15,010
だから、誰かが私に最初に与えることができます
擬似コードの行ご

509
00:26:15,010 --> 00:26:18,350
二分探索のために書いた？

510
00:26:18,350 --> 00:26:20,258
はい、アニー？

511
00:26:20,258 --> 00:26:22,698
>> 学生：一方の長さ
リストはゼロより大きい。

512
00:26:22,698 --> 00:26:26,114

513
00:26:26,114 --> 00:26:34,880
>> JASONハーシュホーンます。while長
ゼロより大きいリスト。

514
00:26:34,880 --> 00:26:38,810
そして再び、我々はいくつかのC-探して参照してください。
ここでの構文的なもの。

515
00:26:38,810 --> 00:26:41,550
しかし、これのほとんどは英語です。

516
00:26:41,550 --> 00:26:43,980
誰もが、彼らが置かれた任意の行がありましたか
その擬似コードでは、これは前に？

517
00:26:43,980 --> 00:26:47,280

518
00:26:47,280 --> 00:26:50,210
>> 学生：配列​​を取得
数をソート。

519
00:26:50,210 --> 00:26:53,600
>> JASONハーシュホーン：あなたが書いた "を取得
ソートされた数字の配列。0.138 "

520
00:26:53,600 --> 00:26:56,140
関数宣言は、渡すことができます
ソートされた数字の配列。

521
00:26:56,140 --> 00:26:57,280
>> 学生：[聞こえない]。

522
00:26:57,280 --> 00:26:59,030
>> JASONハーシュホーン：だから
我々はそれを持つことになります。

523
00:26:59,030 --> 00:27:01,820
しかし、はい、私たちは、それを持っていなかった場合、我々
我々の配列をソートする必要があります

524
00:27:01,820 --> 00:27:04,850
数字、なぜならバイナリサーチ
唯一のソートされた配列で動作します。

525
00:27:04,850 --> 00:27:11,300
リストの長さがゼロに等しいのでながら、私は今
いくつかの中括弧に入れに行く

526
00:27:11,300 --> 00:27:15,420
それはもう少しのように見えるようにする
C.が、しばらくは、上にマッピングしているようだ

527
00:27:15,420 --> 00:27:19,550
whileループなので、この間の内部
ループは、我々には何が必要なのですか

528
00:27:19,550 --> 00:27:22,000
二分探索のために何が？

529
00:27:22,000 --> 00:27:25,530
>> 私に与えられていない他の誰か
まだ答えしかし、誰がこれを書いた？

530
00:27:25,530 --> 00:27:31,750

531
00:27:31,750 --> 00:27:33,320
>> 学生：リストの中央に移動します。

532
00:27:33,320 --> 00:27:33,980
>> JASONハーシュホーン：トム。

533
00:27:33,980 --> 00:27:35,230
リストの中間に移動します。

534
00:27:35,230 --> 00:27:43,290

535
00:27:43,290 --> 00:27:45,530
とフォローアップの質問、どのような
私たちがしてもらった上行っておりません

536
00:27:45,530 --> 00:27:46,870
リストの中間？

537
00:27:46,870 --> 00:27:49,310
>> 学生：それはだかどうかチェックを行う
あなたが探している番号。

538
00:27:49,310 --> 00:27:50,120
>> JASONハーシュホーン：優秀。

539
00:27:50,120 --> 00:28:05,500
リストの中間を行くと確認
私たちの価値があるかどうか - 

540
00:28:05,500 --> 00:28:06,515
幻想的。

541
00:28:06,515 --> 00:28:10,460
誰もが何かを持っていました
それは、これよりも違っていた？

542
00:28:10,460 --> 00:28:11,210
それはまさにそうです。

543
00:28:11,210 --> 00:28:13,800
>> 我々はバイナリ検索で最初に行うこと
リストの中間に移動している

544
00:28:13,800 --> 00:28:15,870
私たちの価値があるかどうかを確認してください。

545
00:28:15,870 --> 00:28:19,682
私たちの価値があるので、もし私が想定し
そこに、私たちは何をしますか？

546
00:28:19,682 --> 00:28:21,610
>> 学生：私たちは、[聞こえない]がゼロを返します。

547
00:28:21,610 --> 00:28:23,400
>> JASONハーシュホーン：ええ、私たちの場合
値が存在し、我々はそれを発見した。

548
00:28:23,400 --> 00:28:27,950
だから我々は、しかし、いくつかの方法を伝えることができ、この
関数が定義されている、我々はユーザーに通知

549
00:28:27,950 --> 00:28:28,520
我々はそれを発見した。

550
00:28:28,520 --> 00:28:30,950
それはそこにはない場合、しかし、それはです
これはトリッキー取得する場所。

551
00:28:30,950 --> 00:28:35,120
だから、そこにはない場合、他の誰かが誰
二分探索に取り組んでいる、またはした

552
00:28:35,120 --> 00:28:36,830
今考えを持って、私たちは何をしますか？

553
00:28:36,830 --> 00:28:37,830
>> 学生：質問。

554
00:28:37,830 --> 00:28:38,100
>> JASONハーシュホーン：はい？

555
00:28:38,100 --> 00:28:39,920
>> 学生：配列​​はすでにソートされていますか？

556
00:28:39,920 --> 00:28:42,200
>> JASONハーシュホーン：はい、我々は想定してい
配列はすでにソートされている。

557
00:28:42,200 --> 00:28:46,480
>> 学生：それで、あなたはチェックする必要がある場合
ご覧の値がより大きくなる

558
00:28:46,480 --> 00:28:51,745
必要な値は、あなたが移動することができます
残りの半分の真ん中に。

559
00:28:51,745 --> 00:28:54,110
>> JASONハーシュホーン：もしそうなら中旬
リストには、私たちがしているものよりも大きい

560
00:28:54,110 --> 00:28:57,440
を探して、その後、我々は何をすべきか？

561
00:28:57,440 --> 00:28:58,320
私たちは、どこに移動しますか？

562
00:28:58,320 --> 00:29:01,400
>> 学生：あなたはに移動したい
でリストの半分

563
00:29:01,400 --> 00:29:02,780
それよりも低い数字。

564
00:29:02,780 --> 00:29:04,460
>> JASONハーシュホーン：だから我々はよ
左のその呼び出し。

565
00:29:04,460 --> 00:29:15,435
真ん中の方が大きいのであれば、私たちは検索することができます
リストの左半分。

566
00:29:15,435 --> 00:29:20,620

567
00:29:20,620 --> 00:29:22,980
と入力し、[検索することにより、どのような
私は、検索によって意味ですか？

568
00:29:22,980 --> 00:29:24,010
>> 学生：[聞こえない]。

569
00:29:24,010 --> 00:29:24,410
>> JASONハーシュホーン：我々は中央に移動します。

570
00:29:24,410 --> 00:29:25,740
私たちは、実際にこの事を繰り返します。

571
00:29:25,740 --> 00:29:29,210
私たちは、whileループを通って行く。

572
00:29:29,210 --> 00:29:31,480
私はあなたの最後の1をあげる - 

573
00:29:31,480 --> 00:29:39,047
他に、真ん中のは何よりも小さい場合など
我々は、我々はここで何をすればよいですか？

574
00:29:39,047 --> 00:29:40,360
>> 学生：右に移動します。

575
00:29:40,360 --> 00:29:41,610
>> JASONハーシュホーン：権利を検索します。

576
00:29:41,610 --> 00:29:47,440

577
00:29:47,440 --> 00:29:51,710
これはよさそうだが、誰もが持っているん
我々は失われることが何か

578
00:29:51,710 --> 00:29:53,200
あなたが置く何か
あなたの擬似コードで？

579
00:29:53,200 --> 00:29:57,080

580
00:29:57,080 --> 00:29:58,410
だから、これは私たちがこれまで何をしています。

581
00:29:58,410 --> 00:30:00,960
リストの長さは大きくなる一方で
ゼロより、私達は行くつもりです

582
00:30:00,960 --> 00:30:03,220
リストの中間にと
私たちの価値があるかどうかを確認してください。

583
00:30:03,220 --> 00:30:06,970
>> 真ん中が大きい場合、我々はするつもりだ
中間であれば、他の左検索

584
00:30:06,970 --> 00:30:09,230
以下、我々は権利を検索しようとしている。

585
00:30:09,230 --> 00:30:14,430
だから我々は、すべてについてある程度の知識を持っていた
我々はコンピュータサイエンスで使用する用語

586
00:30:14,430 --> 00:30:15,550
そして我々が持っているツール。

587
00:30:15,550 --> 00:30:18,300
しかし、あなたはすでに私達がいた気づく
英語で言えば、我々は発見

588
00:30:18,300 --> 00:30:24,790
へマッピングするように見えたことがたくさん
私たちは私たちのコーディングツールキットを持っているツール。

589
00:30:24,790 --> 00:30:27,210
だから、すぐさま、私たちではない
まだ実際にコーディングする予定。

590
00:30:27,210 --> 00:30:33,300
>> 私たちは英語でここに何が見えます、そのマップ
ものにで私達はC言語で書くことができますか？

591
00:30:33,300 --> 00:30:34,560
>> 学生：ながら。

592
00:30:34,560 --> 00:30:35,320
>> JASONハーシュホーンます。while。

593
00:30:35,320 --> 00:30:40,610
したがって、この中に右ここ
何の上のマップ？

594
00:30:40,610 --> 00:30:42,630
>> 学生：whileループ。

595
00:30:42,630 --> 00:30:43,200
>> JASONハーシュホーン：whileループ？

596
00:30:43,200 --> 00:30:44,540
または、おそらく、より一般的には、ループ。

597
00:30:44,540 --> 00:30:46,260
私たちは、何度も何かをしたい。

598
00:30:46,260 --> 00:30:49,050
だから我々は、ループをコーディングするつもりだ。

599
00:30:49,050 --> 00:30:51,640
私たちがやったので、我々はすでに知っている、
この時代のカップルと私たち

600
00:30:51,640 --> 00:30:54,180
、そこに例がたくさんある
どのように実際に書く方法

601
00:30:54,180 --> 00:30:55,310
forループのこのインデックス。

602
00:30:55,310 --> 00:30:56,160
だから、これはかなり簡単なはずです。

603
00:30:56,160 --> 00:30:58,070
我々はそれを得ることができる必要があり
かなり迅速に開始した。

604
00:30:58,070 --> 00:31:01,830
>> 他に何が我々がここで見ていますか？

605
00:31:01,830 --> 00:31:06,820
他にどのような構造の構文は、物事
我々はC言語で精通していることを、私たちは何

606
00:31:06,820 --> 00:31:09,790
すでにベースの感を持っている
我々は使用されている単語のオフ？

607
00:31:09,790 --> 00:31:10,830
はい、アンナ？

608
00:31:10,830 --> 00:31:11,360
[聞こえない]

609
00:31:11,360 --> 00:31:12,990
ほんの冗談です。

610
00:31:12,990 --> 00:31:13,540
アンナは、先に行く。

611
00:31:13,540 --> 00:31:14,530
>> 学生：ifとelse。

612
00:31:14,530 --> 00:31:16,260
>> JASONハーシュホーン：Ifと
他の - ちょうどここ。

613
00:31:16,260 --> 00:31:18,840
それでは、それらは次のようになりますか？

614
00:31:18,840 --> 00:31:20,420
>> 学生：もしelse文。

615
00:31:20,420 --> 00:31:21,560
>> JASONハーシュホーン：ええ、
条件は、右？

616
00:31:21,560 --> 00:31:24,650
だから我々は、おそらくする必要があります
いくつかの条件を記述します。

617
00:31:24,650 --> 00:31:31,185
そして再び、でも多分に混乱
まず、我々は一般的になりました感覚を持っている

618
00:31:31,185 --> 00:31:34,010
条件や書き方の
条件の構文。

619
00:31:34,010 --> 00:31:36,850
もしそうしないと、我々はただ見上げる
条件、カット＆ペーストの構文

620
00:31:36,850 --> 00:31:39,950
我々は我々が知っているので、その
ここでの条件を必要としています。

621
00:31:39,950 --> 00:31:44,910
我々は上にそのマップを参照して、他のもの
我々はC言語で行う必要があるかもしれませんもの？

622
00:31:44,910 --> 00:31:48,312

623
00:31:48,312 --> 00:31:48,960
ええ、Aleha？

624
00:31:48,960 --> 00:31:50,370
>> 学生：これは、明白かもしれない
場合は、単にチェックすることにより、

625
00:31:50,370 --> 00:31:51,990
値が何かに等しい。

626
00:31:51,990 --> 00:31:54,578
>> JASONハーシュホーン：では、どのようにチェックしますか
と - ので、リストの中央に移動します

627
00:31:54,578 --> 00:31:55,610
私たちの価値があるかどうかをチェック？

628
00:31:55,610 --> 00:31:56,570
我々はそれがC言語でどのように行うのですか？

629
00:31:56,570 --> 00:31:58,450
そのための構文は何ですか？

630
00:31:58,450 --> 00:31:59,235
>> 学生：等しい、等しい。

631
00:31:59,235 --> 00:32:00,650
>> JASONハーシュホーンは：等しい、等しい。

632
00:32:00,650 --> 00:32:03,540
このチェックは、おそらく起こっている
対等であるためには、等しくなります。

633
00:32:03,540 --> 00:32:04,510
だから我々は我々がどこかが必要に知っているよ。

634
00:32:04,510 --> 00:32:07,510
そして実際に、それを書面で、
我々は、これらの他のものを参照してください。

635
00:32:07,510 --> 00:32:11,400
我々はいくつかを行う必要があるとしている
そこでの比較演算子 - 

636
00:32:11,400 --> 00:32:12,010
幻想的。

637
00:32:12,010 --> 00:32:14,980
だから、実際にで、のように見え、
大規模な、私たちは書いていないA

638
00:32:14,980 --> 00:32:16,390
まだCコードの言葉。

639
00:32:16,390 --> 00:32:20,610
しかし、我々はダウンメンタルモデルを持って
講義やそれらのショーツを経由。

640
00:32:20,610 --> 00:32:22,350
>> 私たちは、グループとしての擬似コードを書いた。

641
00:32:22,350 --> 00:32:27,110
すでに、私たちは80パーセントを持っていない場合
我々は何をすべきかの90％。

642
00:32:27,110 --> 00:32:28,550
今、私たちは単にコードする必要があります
それは、再び、これは

643
00:32:28,550 --> 00:32:30,110
解決する些細な問題。

644
00:32:30,110 --> 00:32:31,890
しかし、少なくとも我々は論理に立ち往生している。

645
00:32:31,890 --> 00:32:38,040
少なくとも今は営業時間に行くとき、
私は私が必要なものを知っている、と言うことができます

646
00:32:38,040 --> 00:32:40,160
実行するには、しかし、あなたは思い出させることができる
構文の私？

647
00:32:40,160 --> 00:32:42,940
または営業時間は、混雑している場合でも、
むしろ、構文については、Googleができます

648
00:32:42,940 --> 00:32:45,040
ロジックに貼付されているよりも。

649
00:32:45,040 --> 00:32:48,570
>> そして再び、のではなく、解決しようとし
ロジックと構文上の問題のすべて

650
00:32:48,570 --> 00:32:51,900
一度、多くの場合、はるかに良好である
にそれらの2のハードの問題を解消

651
00:32:51,900 --> 00:32:58,280
2より扱いのものは、観光
Cの擬似コード最初にして、コード

652
00:32:58,280 --> 00:33:00,620
それでは、私がやったことを見てみましょう
事前に擬似コード。

653
00:33:00,620 --> 00:33:04,060
>> リストの長さは大きくなる一方で
ゼロより、中を見て

654
00:33:04,060 --> 00:33:05,090
リストの。

655
00:33:05,090 --> 00:33:09,610
番号が見つかった場合はtrueを、返さ
数値が高いほど、検索のままにした場合。

656
00:33:09,610 --> 00:33:13,200
他の数が低い場合は、検索
右、falseを返します。

657
00:33:13,200 --> 00:33:18,710
ていないのであれば、それはほぼ同じに見える
私たちが書いたものとほぼ同じ。

658
00:33:18,710 --> 00:33:23,030
実際には、トム、あなたが最初に言ったこと、
リストの中間を壊すとIF

659
00:33:23,030 --> 00:33:24,880
2文にされた数
私が何をしたか実際にある。

660
00:33:24,880 --> 00:33:25,507
>> 私はそこにそれらを組み合わせる。

661
00:33:25,507 --> 00:33:27,100
私は耳を傾けている必要があります
あなたは初めて。

662
00:33:27,100 --> 00:33:30,640
だから、それは我々が持っている擬似コードである。

663
00:33:30,640 --> 00:33:35,060
あなたが今したい場合は、申し訳ありませんが、行く
私たちの最初の問題にバックアップします。

664
00:33:35,060 --> 00:33:37,780
のコードbinary.cをしてみましょう。

665
00:33:37,780 --> 00:33:40,870
だから、反復バージョンを実装
次を使用してバイナリサーチ

666
00:33:40,870 --> 00:33:42,420
関数宣言。

667
00:33:42,420 --> 00:33:44,550
>> そして、あなたはコピーする必要はありません
それダウンだけではまだありません。

668
00:33:44,550 --> 00:33:49,470
私は実際に開くつもりだ
アップ右ここbinary.c。

669
00:33:49,470 --> 00:33:52,880
だから、関数宣言があります
画面中央の。

670
00:33:52,880 --> 00:33:57,570
そして、あなたは、私は擬似コードを取っ表示されます
私の両側からではなく、ほぼ同一

671
00:33:57,570 --> 00:33:59,740
何を私たちは書いて、
あなたのためにそれを置く。

672
00:33:59,740 --> 00:34:06,010
だから今、のは5分かかりましょう
この機能をコーディングする。

673
00:34:06,010 --> 00:34:08,199
>> そして再び、ご質問がある場合には、
手を上げ、私はよ、私に知らせて

674
00:34:08,199 --> 00:34:08,710
集まってくる。

675
00:34:08,710 --> 00:34:09,800
>> 学生：[聞こえない]。

676
00:34:09,800 --> 00:34:12,380
>> JASONハーシュホーン：だから私は、バイナリを取った
での検索定義

677
00:34:12,380 --> 00:34:14,429
12行目の一番上の、。

678
00:34:14,429 --> 00:34:16,429
それは私が私のスライドのために得たものです。

679
00:34:16,429 --> 00:34:20,940
して、このすべての擬似コードちょうど私
コピーとスライドから貼り付け、

680
00:34:20,940 --> 00:34:22,190
擬似コードスライド。

681
00:34:22,190 --> 00:35:22,830

682
00:35:22,830 --> 00:35:26,786
私はまだ[聞こえない]を聞いていないよ。

683
00:35:26,786 --> 00:37:13,010

684
00:37:13,010 --> 00:37:15,820
>> つまり、あなたが終了した場合
実装は、私はそれを確認したい。

685
00:37:15,820 --> 00:37:19,410
私はあなたにHelpers.hにファイルを電子メールで送信
以前のこのクラスの。

686
00:37:19,410 --> 00:37:22,360
そしてそれは同様にオンラインで利用できるようになります
見ている人々のためにダウンロードする

687
00:37:22,360 --> 00:37:24,750
このセクションでは、時間が遅れる。

688
00:37:24,750 --> 00:37:29,350
と私は一般的なディストリビューションを使用
pset3からコード。

689
00:37:29,350 --> 00:37:34,590
だから、私はHelpers.hにファイルを使用し、find.Cを取った
むしろHelpers.hにファイルよりも

690
00:37:34,590 --> 00:37:36,280
つまり、配布コードに記載されいます。

691
00:37:36,280 --> 00:37:39,310
>> そして、私は中1の他の変更をしなければならなかった
むしろ単に呼び出すよりもfind.C

692
00:37:39,310 --> 00:37:42,770
検索、binary_search呼び出します。

693
00:37:42,770 --> 00:37:49,080
だから、あなたのコードをテストする場合、
それはそれを行う方法であることを知っている。

694
00:37:49,080 --> 00:37:52,530
実際には、ときに我々は、このコードを実行している必要があります
今、私はただのコピーを作った

695
00:37:52,530 --> 00:37:59,820
私pset3ディレクトリには、再び、スワップアウト
そしてヘルパーファイルとは、作った

696
00:37:59,820 --> 00:38:04,695
binary_searchを呼び出すためfind.Cの変化
のではなく、単純に検索します。

697
00:38:04,695 --> 00:40:08,620

698
00:40:08,620 --> 00:40:09,120
>> JASONハーシュホーン：はい。

699
00:40:09,120 --> 00:40:11,258
あなたが質問がありますか？

700
00:40:11,258 --> 00:40:12,150
>> 学生：ネヴァーマインド。

701
00:40:12,150 --> 00:40:12,600
>> JASONハーシュホーン：心配はありません。

702
00:40:12,600 --> 00:40:13,370
さて、を始めましょう。

703
00:40:13,370 --> 00:40:15,090
当社は、グループとしてこれをコーディングします。

704
00:40:15,090 --> 00:40:16,050
もう一つ注意してください。

705
00:40:16,050 --> 00:40:20,600
再度、これは、容易に交換することができる
問題設定された3点がある場合。

706
00:40:20,600 --> 00:40:25,530
むしろ私はHelpers.hにファイルを持っている、
Helpers.hに比べて、我々は与えられている、

707
00:40:25,530 --> 00:40:28,560
二分探索、バブルを宣言
ソート、選択ソート。

708
00:40:28,560 --> 00:40:37,400
そしてfind.cでは、行に気づくでしょう、
ライン68は、我々はバイナリを呼び出す、というものです

709
00:40:37,400 --> 00:40:39,160
検索ではなく、検索。

710
00:40:39,160 --> 00:40:42,930
だからもう一度、利用可能なコード
オンラインであなたがしているコード

711
00:40:42,930 --> 00:40:46,590
今作成は簡単に交換することができます
Pのためにそれをチェックするために3を設定します。

712
00:40:46,590 --> 00:40:50,620
>> しかし、最初に、バイナリサーチをコーディングしてみましょう。

713
00:40:50,620 --> 00:40:53,690
私たちの関数宣言、
私たちは、BOOLを返す。

714
00:40:53,690 --> 00:40:55,810
私たちは、価値と呼ばれる整数値を取る。

715
00:40:55,810 --> 00:40:59,285
私たちは、と呼ばれる整数の配列を取る
値、そして我々はあることN取る

716
00:40:59,285 --> 00:41:00,850
配列のサイズ。

717
00:41:00,850 --> 00:41:05,640
右ここ行10、上、私が持っている
シャープはをインクルードする。

718
00:41:05,640 --> 00:41:07,360
それがあると、なぜ誰もが知っていますか？

719
00:41:07,360 --> 00:41:12,180

720
00:41:12,180 --> 00:41:16,600
だから、このコード行は、何をするのでしょうか？

721
00:41:16,600 --> 00:41:19,880
>> 学生：それはあなたがすることができます
BOOLの戻り値の型を使用します。

722
00:41:19,880 --> 00:41:20,350
>> JASONハーシュホーン：その通りです。

723
00:41:20,350 --> 00:41:22,300
>> 学生：またはそれは可能にするライブラリの
BOOLの戻り値の型を使用します。

724
00:41:22,300 --> 00:41:27,590
>> JASONハーシュホーン：だからシャープは、
stdbool.hラインは私にいくつかを提供します

725
00:41:27,590 --> 00:41:31,340
物事の定義と宣言
私が中に使用させていただくこと

726
00:41:31,340 --> 00:41:32,400
このライブラリ。

727
00:41:32,400 --> 00:41:36,570
だから、それらの中があることを言っている
このタイプのブールと呼ばれ、であることができる

728
00:41:36,570 --> 00:41:37,750
trueまたはfalse。

729
00:41:37,750 --> 00:41:39,010
だから、その行が何をするかだ。

730
00:41:39,010 --> 00:41:41,680
私はそのラインを持っていなかったなら、私はだろう
これを書くためのトラブルに巻き込まれる

731
00:41:41,680 --> 00:41:43,520
右ここで、BOOL、すぐそこに言葉。

732
00:41:43,520 --> 00:41:44,140
まったく正しい。

733
00:41:44,140 --> 00:41:46,430
だから私は、このコードでそれを必要とする。

734
00:41:46,430 --> 00:41:47,690
[OK]をクリックします。

735
00:41:47,690 --> 00:41:51,860
これは、再び、反復的である
バージョンではなく、再帰的1。

736
00:41:51,860 --> 00:41:53,820
だから私たちは、始めましょう。

737
00:41:53,820 --> 00:41:56,200
>> のは、この第一から始めましょう
擬似コードの行。

738
00:41:56,200 --> 00:41:58,770
うまくいけば、我々は意志 - 
かうまくいけば。

739
00:41:58,770 --> 00:42:00,530
私たちは部屋の中を行くつもりです。

740
00:42:00,530 --> 00:42:05,110
私たちは、行ごとに行くよ、と私は助ける
あなたは私たちが必要とするラインを把握

741
00:42:05,110 --> 00:42:06,310
最初に書き込みます。

742
00:42:06,310 --> 00:42:10,550
そうしながら、リストの長さ
ゼロよりも大きい。

743
00:42:10,550 --> 00:42:12,680
前に起動してみましょう。

744
00:42:12,680 --> 00:42:15,190
どのようなライン私が書く必要があります
ここでは、コード内の？

745
00:42:15,190 --> 00:42:19,470
>> 学生：カッコながら
nは0より大きい。

746
00:42:19,470 --> 00:42:21,900
>> JASONハーシュホーンます。while
nは0よりも大きい。

747
00:42:21,900 --> 00:42:26,550
そうnは、リストのサイズです
そして我々は、次の場合にチェックしている - 

748
00:42:26,550 --> 00:42:26,800
>> [声を挟ん]

749
00:42:26,800 --> 00:42:27,660
>> JASONハーシュホーン： - 申し訳ありませんが？

750
00:42:27,660 --> 00:42:29,360
>> 学生：どのように我々は知っていますか
nはリストのサイズですか？

751
00:42:29,360 --> 00:42:29,690
>> JASONハーシュホーン：申し訳ありません。

752
00:42:29,690 --> 00:42:34,690
PSET仕様ごとに、検索
そして、あなたが書く必要がある関数を並べ替える

753
00:42:34,690 --> 00:42:36,230
nは、リストのサイズです。

754
00:42:36,230 --> 00:42:37,710
私はここでそれを説明するのを忘れていました。

755
00:42:37,710 --> 00:42:41,310
しかし、はい。 nはのサイズです
この場合はリスト。

756
00:42:41,310 --> 00:42:44,740
そのようにしながら、nは0より大きい。

757
00:42:44,740 --> 00:42:45,580
[OK]をクリックします。

758
00:42:45,580 --> 00:42:50,090
それは少し問題となるかもしれ
しかし、物事が進んでいる場合。

759
00:42:50,090 --> 00:42:54,510
我々は知っているしていきますので、
この全体リストのサイズ

760
00:42:54,510 --> 00:43:06,640
機能しますが、我々が始めると言う
5整数の配列を持つ。

761
00:43:06,640 --> 00:43:08,950
そして、我々は通過し、我々はしました
今、それを絞り込ん

762
00:43:08,950 --> 00:43:10,310
2整数の配列。

763
00:43:10,310 --> 00:43:12,160
それは2の整数である？

764
00:43:12,160 --> 00:43:15,895
サイズは、今我々がしたいことを2で
を見て、それはその2です？

765
00:43:15,895 --> 00:43:17,720
それは、その質問に意味があるか？

766
00:43:17,720 --> 00:43:18,020
>> [OK]をクリックします。

767
00:43:18,020 --> 00:43:19,120
私は再びそれを聞いてみよう。

768
00:43:19,120 --> 00:43:26,640
だから我々は5のこの配列から始める
整数、nは5に等しいですよね？

769
00:43:26,640 --> 00:43:28,050
私たちはここを実行することになるでしょう。

770
00:43:28,050 --> 00:43:31,560
我々は、おそらくサイズを変更します、
物事が上に行くように、右。

771
00:43:31,560 --> 00:43:32,700
これは我々が何をしたいと言うことです。

772
00:43:32,700 --> 00:43:34,150
我々は検索しない
フル事もう一度。

773
00:43:34,150 --> 00:43:35,480
だから我々は2に変更し言う。

774
00:43:35,480 --> 00:43:36,970
私たちは、奇妙な半リストを取る。

775
00:43:36,970 --> 00:43:38,800
だから2を選択します。

776
00:43:38,800 --> 00:43:40,590
だから今、N 2に等しい。

777
00:43:40,590 --> 00:43:42,780
私は貧しい人々のために謝罪
乾燥消去マーカー。

778
00:43:42,780 --> 00:43:43,080
右？

779
00:43:43,080 --> 00:43:45,670
そして、我々は、リストを検索している
もう一度サイズ2のリスト。

780
00:43:45,670 --> 00:43:48,580
さて、私たちの配列のサイズは5のままです。

781
00:43:48,580 --> 00:43:51,920
我々は我々だけしたいとし
その中に2スポットを検索します。

782
00:43:51,920 --> 00:43:53,590
だから、その2点は、それらのでしょうか？

783
00:43:53,590 --> 00:43:57,640

784
00:43:57,640 --> 00:43:58,815
>> それは理にかなっていますか？

785
00:43:58,815 --> 00:44:00,290
彼らは左の2のスポットはありますか？

786
00:44:00,290 --> 00:44:01,940
彼らは正しい2のスポットはありますか？

787
00:44:01,940 --> 00:44:03,540
彼らは中央の2のスポットはありますか？

788
00:44:03,540 --> 00:44:06,350
私たちは、問題を分解し、しかし、我々している
実際のどの部分がわからない

789
00:44:06,350 --> 00:44:11,600
我々はまだ見ている問題、
ちょうどこれらの2つの変数を持つことによって。

790
00:44:11,600 --> 00:44:16,450
だから我々は、その後、少し多くを必要とする
nが0より大きいいる。

791
00:44:16,450 --> 00:44:21,410
我々はどこにことを知っておく必要があり
nは私たちの実際の配列である。

792
00:44:21,410 --> 00:44:26,660
>> だから、誰もが持っているん
この行に変更しますか？

793
00:44:26,660 --> 00:44:27,970
この行のほとんどはある
完全に正しい。

794
00:44:27,970 --> 00:44:29,170
別の追加はありますか？

795
00:44:29,170 --> 00:44:32,510
我々は、n個のために何かを入れ替えることができます
この行は少し良くする？

796
00:44:32,510 --> 00:44:32,865
MM-HM？

797
00:44:32,865 --> 00:44:38,040
>> 学生：あなたは、変数を初期化することができます
それから使用されますnまでの長さのような

798
00:44:38,040 --> 00:44:39,600
後で関数内の？

799
00:44:39,600 --> 00:44:42,060
>> JASONハーシュホーン：だから初期化
nの可変長、

800
00:44:42,060 --> 00:44:42,900
そして我々は、後でそれを使うのか？

801
00:44:42,900 --> 00:44:47,070
しかし、我々は単に長さと、私たちを更新
まだ我々この問題が発生し

802
00:44:47,070 --> 00:44:51,180
我々の問題の長さを削減、
しかし、我々は、実際には、どこで知っていることはありません

803
00:44:51,180 --> 00:44:52,510
その長さは、上にマッピングされます。

804
00:44:52,510 --> 00:44:54,790
>> 学生：それが起こることを行っていない
あなたが言っている後にすると、左の検索、

805
00:44:54,790 --> 00:44:55,746
右検索？

806
00:44:55,746 --> 00:44:57,640
あなたが別のに行くつもりだ
あなたの地域 - 

807
00:44:57,640 --> 00:44:59,110
>> JASONハーシュホーン：私たちは行くつもりだ
エリアに、しかし、どのように我々は知っている

808
00:44:59,110 --> 00:45:01,150
に行っているでしょうか？

809
00:45:01,150 --> 00:45:03,800
私たちは、配列およびこれを持っている場合
N、どのように我々はを知っていますか

810
00:45:03,800 --> 00:45:05,050
配列にアクセスしてください。

811
00:45:05,050 --> 00:45:05,900
後ろに、はい？

812
00:45:05,900 --> 00:45:07,507
>> 学生：あなたが持っています、のように、下
と上限変数または

813
00:45:07,507 --> 00:45:08,586
そのような何か？

814
00:45:08,586 --> 00:45:09,060
>> JASONハーシュホーン：わかりました。

815
00:45:09,060 --> 00:45:10,780
だから、これはもう一つのアイデアです。

816
00:45:10,780 --> 00:45:13,490
というだけを追跡するよりも
大きさは、下部を追跡し、

817
00:45:13,490 --> 00:45:14,770
上限の変数。

818
00:45:14,770 --> 00:45:17,840
では、どのようにからサイズを計算か
下限と上限？

819
00:45:17,840 --> 00:45:18,520
>> [声を挟ん]

820
00:45:18,520 --> 00:45:19,710
>> JASONハーシュホーン：減算。

821
00:45:19,710 --> 00:45:23,650
また下を追跡する
バインドされ、上側の私たちが知っているようにバインドされ、

822
00:45:23,650 --> 00:45:26,215
我々はこれら2を検索したい

823
00:45:26,215 --> 00:45:28,220
ここでは上で、これらの2を探していますか？

824
00:45:28,220 --> 00:45:29,540
私たちは、真ん中の2を探していますか？

825
00:45:29,540 --> 00:45:32,810
なぜなら、2たぶん真ん中ではない
これは、実際には、二分探索である。

826
00:45:32,810 --> 00:45:37,320
しかし、今、我々はサイズを取得することができるでしょう、
しかし、アレイの限界。

827
00:45:37,320 --> 00:45:40,020
基本的に、我々は我々の巨大なを持っている場合
電話帳、我々はそれを半分に裂く。

828
00:45:40,020 --> 00:45:42,990
我々は今、どこにそれが小さい知って
電話帳である。

829
00:45:42,990 --> 00:45:45,260
しかし、我々は実際にリッピングしていない
半分に電話帳。

830
00:45:45,260 --> 00:45:48,570
我々はまだどこに知っておく必要があります
我々の問題の新たな境界がある。

831
00:45:48,570 --> 00:45:51,645
誰もが疑問を持っていますか
それはどうでしょうか？

832
00:45:51,645 --> 00:45:52,440
はい？

833
00:45:52,440 --> 00:45:56,020
>> 学生：それは作成することにより動作します
変数は、私は、あなたは、ちょうどシフトしていること

834
00:45:56,020 --> 00:46:00,770
そのへのIの位置
現在位置、および長さ、nは？

835
00:46:00,770 --> 00:46:01,710
>> JASONハーシュホーン：私は何ですか？

836
00:46:01,710 --> 00:46:04,110
>> 学生：私は一種のようなもののように - 

837
00:46:04,110 --> 00:46:08,040
あなたは、私がために初期化するのと同じよう
配列の中央の位置。

838
00:46:08,040 --> 00:46:12,540
そして、もし位置の値I IN
に見つかったの配列の真ん中

839
00:46:12,540 --> 00:46:17,870
私は今、あなたが必要とする値よりも小さく
配列の長さとなり、プラス

840
00:46:17,870 --> 00:46:19,215
iの値が2で割った。

841
00:46:19,215 --> 00:46:20,270
同様に、参照して、あなたは私をシフト - 

842
00:46:20,270 --> 00:46:20,770
>> JASONハーシュホーン：右。

843
00:46:20,770 --> 00:46:21,165
>> 学生： - 最大 - 

844
00:46:21,165 --> 00:46:24,010
>> JASONハーシュホーン：だから私はほとんど午前
動作します正。

845
00:46:24,010 --> 00:46:26,800
しかし、ポイントの幸福は、次の2つが必要です
ここでの情報。

846
00:46:26,800 --> 00:46:30,050
あなたは、最初と最後でそれを行うことができます
またはあなたは、サイズでそれを行う、とすることができます

847
00:46:30,050 --> 00:46:31,060
いくつかのマーカー。

848
00:46:31,060 --> 00:46:32,630
しかし、あなたは2枚必要ですか
ここでの情報。

849
00:46:32,630 --> 00:46:34,160
あなただけの1とすることによって得ることができません。

850
00:46:34,160 --> 00:46:35,830
それは理にかなっていますか？

851
00:46:35,830 --> 00:46:39,560
>> だから我々は通過するつもりだ、と
私たちは、やろうとしている[聞こえない]

852
00:46:39,560 --> 00:46:41,330
といくつかのマーカーを作成します。

853
00:46:41,330 --> 00:46:42,690
つまり、あなたのコード内でホワッドを書くのか？

854
00:46:42,690 --> 00:46:46,190
>> 学生：私はちょうど言ったINTバウンド
一方は0に等しい。

855
00:46:46,190 --> 00:46:47,790
>> JASONハーシュホーン：レッツ·コール
そのint型、始まる。

856
00:46:47,790 --> 00:46:49,140
>> 学生：わかりました。

857
00:46:49,140 --> 00:46:50,590
>> JASONハーシュホーン：それが作る
私のためのより多くの意味。

858
00:46:50,590 --> 00:46:51,670
と？

859
00:46:51,670 --> 00:46:54,340
>> 学生：私は終了INT、私は推測する、と述べた。

860
00:46:54,340 --> 00:46:55,870
>> JASONハーシュホーン：エンディングint型。

861
00:46:55,870 --> 00:46:57,640
>> 学生：私は推測、Nマイナス1、
またはそのような何か。

862
00:46:57,640 --> 00:46:59,100
同様に、最後の要素。

863
00:46:59,100 --> 00:47:02,310
>> JASONハーシュホーン：だからあなたが書いた、INT
イコール0、セミコロン、およびINT始まる

864
00:47:02,310 --> 00:47:04,320
エンディングは、nマイナス1、セミコロンに相当します。

865
00:47:04,320 --> 00:47:06,850
ですから、基本的に、私たちは何をやっている
ここで、第1の位置0。

866
00:47:06,850 --> 00:47:09,570
我々は、配列に知っているように、彼らは行っていない
Nまで、彼らはに上がるNマイナス1。

867
00:47:09,570 --> 00:47:11,110
だから我々は我々の配列の一部の境界を持っている。

868
00:47:11,110 --> 00:47:15,730
そして、これらの初期境界はあることが起こる
我々の問題の最初の境界です。

869
00:47:15,730 --> 00:47:16,640
[OK]をクリックします。

870
00:47:16,640 --> 00:47:19,200
だから、いいですね。

871
00:47:19,200 --> 00:47:22,380
その後、我々は、戻って次の行に進みますしばらく
リストの長さは、0よりも大きい

872
00:47:22,380 --> 00:47:24,752
何をする代わりに、N、はず
我々はここに入れて？

873
00:47:24,752 --> 00:47:28,820
>> 学生：マイナス先頭を終了書き込みます。

874
00:47:28,820 --> 00:47:34,780
>> JASONハーシュホーン：マイナスを終了する一方
始まりは0よりも大きい？

875
00:47:34,780 --> 00:47:35,480
[OK]をクリックします。

876
00:47:35,480 --> 00:47:37,730
そして、我々は我々がしたい場合は、可能性
どのような、少しよりよいことを確認

877
00:47:37,730 --> 00:47:38,980
他に私たちは何ができる？

878
00:47:38,980 --> 00:47:41,650

879
00:47:41,650 --> 00:47:43,412
私たちは、きれいにしたい場合
このコードまで少し？

880
00:47:43,412 --> 00:47:46,716

881
00:47:46,716 --> 00:47:48,180
どのように我々は0を取り除くことができますか？

882
00:47:48,180 --> 00:47:51,560

883
00:47:51,560 --> 00:47:52,690
これは単なるスタイルの問題です。

884
00:47:52,690 --> 00:47:53,690
それが今、正しいです。

885
00:47:53,690 --> 00:47:54,870
>> 学生：エンディングません
等しい始まり？

886
00:47:54,870 --> 00:47:55,740
>> JASONハーシュホーン：私たちは何ができるのでしょうか？

887
00:47:55,740 --> 00:47:56,730
>> [声を挟ん]

888
00:47:56,730 --> 00:47:57,330
>> 学生：エンディングは大きい？

889
00:47:57,330 --> 00:47:57,720
>> JASONハーシュホーン：うん。

890
00:47:57,720 --> 00:48:01,110
終了しながら、我々だけで行うことができます
初めよりも大きい。

891
00:48:01,110 --> 00:48:03,580
右。

892
00:48:03,580 --> 00:48:06,240
我々は他の側に始まっ追加
そのことを、私たちは0を処分した。

893
00:48:06,240 --> 00:48:08,000
だから、これは単に見える
少しクリーナー。

894
00:48:08,000 --> 00:48:08,990
[OK]をクリックします。

895
00:48:08,990 --> 00:48:11,460
リストの長さが0である間そう、私たちは書いた
つまり、エンディングが大きいながら

896
00:48:11,460 --> 00:48:12,240
当初より。

897
00:48:12,240 --> 00:48:19,840
私たちは、必要に置くつもりだ
中括弧してから、最初にすること

898
00:48:19,840 --> 00:48:22,090
私たちがやりたいことを見ている
小さなリストに。

899
00:48:22,090 --> 00:48:22,510
あなたは？

900
00:48:22,510 --> 00:48:23,320
あなたは私に与えることができます - 

901
00:48:23,320 --> 00:48:26,460
>> 学生：もしカッコ
値の角括弧 - 

902
00:48:26,460 --> 00:48:30,450
>> JASONハーシュホーン：括弧の場合
値の角括弧。

903
00:48:30,450 --> 00:48:33,210
>> 学生：2で割っ終了する。

904
00:48:33,210 --> 00:48:33,952
>> JASONハーシュホーン：エンディング？

905
00:48:33,952 --> 00:48:35,280
>> 学生：私はあなたに問題があることを参照してください - 

906
00:48:35,280 --> 00:48:35,750
>> JASONハーシュホーン：わかりました。

907
00:48:35,750 --> 00:48:39,150
さて、中を見てみましょう。

908
00:48:39,150 --> 00:48:41,226
どのように我々は真ん中が何であるかを知っていますか？

909
00:48:41,226 --> 00:48:42,450
うん。

910
00:48:42,450 --> 00:48:43,070
だから私は、そのコードを削除してみましょう。

911
00:48:43,070 --> 00:48:46,360
どのように我々は真ん中が何であるかを知っていますか？

912
00:48:46,360 --> 00:48:48,003
何にでも、あなたは初めを持っているとき
そして最後には、どのように見つけるのですか

913
00:48:48,003 --> 00:48:48,876
真ん中？

914
00:48:48,876 --> 00:48:49,590
>> 学生：あなたが平均。

915
00:48:49,590 --> 00:48:51,820
>> 学生：あなたはそれらを追加
一緒にしてから - 

916
00:48:51,820 --> 00:48:53,150
>> JASONハーシュホーン：それらを追加
一緒にしてから？

917
00:48:53,150 --> 00:48:54,090
>> 学生：そして、あなたは平均的。

918
00:48:54,090 --> 00:48:55,050
2で割ります。

919
00:48:55,050 --> 00:48:56,500
>> JASONハーシュホーン：それらを追加
一緒に2で割る。

920
00:48:56,500 --> 00:48:59,400
だから、int型の中間に等しい？

921
00:48:59,400 --> 00:49:01,120
トムは、あなたが私にそれを与えることができますか？

922
00:49:01,120 --> 00:49:03,550
>> 学生：始まりプラス終わる - 

923
00:49:03,550 --> 00:49:04,950
>> JASONハーシュホーン：ビギニング
プラス終了。

924
00:49:04,950 --> 00:49:06,880
>> 学生：すべて、ブラケット、2で割った。

925
00:49:06,880 --> 00:49:10,940
>> JASONハーシュホーン：すべて、（）内の、
2で割った。

926
00:49:10,940 --> 00:49:16,300
だから私に真ん中を与え
何の、正しいですか？

927
00:49:16,300 --> 00:49:18,980
>> 学生：あなたはまた、それを切り上げする必要があります。

928
00:49:18,980 --> 00:49:19,990
>> JASONハーシュホーン：あなたは何をし
意味、私はそれを切り上げする必要がありますか？

929
00:49:19,990 --> 00:49:20,400
>> [声を挟ん]

930
00:49:20,400 --> 00:49:24,520
>> 学生：ので、それは奇妙だ場合は、
数が、それはのようなものだ - 

931
00:49:24,520 --> 00:49:25,440
>> JASONハーシュホーン：そうですね。

932
00:49:25,440 --> 00:49:26,360
だから私はそれを切り上げ可能性があります。

933
00:49:26,360 --> 00:49:33,350
それが奇数で、5の場合しかし、私がすることができます
離れて真ん中から1を取る。

934
00:49:33,350 --> 00:49:35,665
あるいはそれが偶数なら、むしろ、
それは、より良いケースだ。

935
00:49:35,665 --> 00:49:39,600
それが4なら、我々は唯一の4を持って、私が取ることができます
最初の「中」、引用、引用終わりか

936
00:49:39,600 --> 00:49:41,760
第二の「中」1。

937
00:49:41,760 --> 00:49:46,390
どちらかが二分探索のために働くだろう、
私は実際にそれを丸める必要はありません。

938
00:49:46,390 --> 00:49:48,640
しかし、1他の事は私はそこにある
この行を調べる必要があります。

939
00:49:48,640 --> 00:49:50,530
私たちは、まだそれを実現しない可能性があります
しかし、我々はそれに戻ってくる。

940
00:49:50,530 --> 00:49:53,200
実際にはまだこの行理由
1他の事を必要とします。

941
00:49:53,200 --> 00:49:55,990
>> しかし、これまでのところ、私たちは書いてきた
4行のコード。

942
00:49:55,990 --> 00:49:58,120
我々は我々の始まりを持っている
マーカーを終了する。

943
00:49:58,120 --> 00:50:01,320
私たちは、マップする私たちのwhileループを持っている
直接私たちの擬似コードの上。

944
00:50:01,320 --> 00:50:05,790
我々は、地図真ん中を見ている
直接私たちの擬似コードの上に。

945
00:50:05,790 --> 00:50:09,070
私はこれが真ん中に行くと言うでしょう
リストの、次のコード行。

946
00:50:09,070 --> 00:50:11,560
そして、かつて私たちはの真ん中に行く
リスト、我々がする必要がある次の事

947
00:50:11,560 --> 00:50:14,880
私たちの価値がそこにあるかどうかを確認されている
先ほど書いた擬似コード。

948
00:50:14,880 --> 00:50:17,100
>> 私たちの価値のであれば、どのようにチェックしますか
リストの中間にある？

949
00:50:17,100 --> 00:50:17,300
あなた。

950
00:50:17,300 --> 00:50:18,511
なぜあなたはこれをしないのですか？

951
00:50:18,511 --> 00:50:23,070
>> 学生：私たちの価値のであれば
中央に等しい

952
00:50:23,070 --> 00:50:24,592
我々はどのような設定 - 

953
00:50:24,592 --> 00:50:26,190
私は、に等しい等しい平均 - 

954
00:50:26,190 --> 00:50:26,690
>> JASONハーシュホーン：それ - 

955
00:50:26,690 --> 00:50:27,940
[OK]をクリックします。

956
00:50:27,940 --> 00:50:30,080

957
00:50:30,080 --> 00:50:32,170
>> 学生：私は何か分からない
我々は見ている変数

958
00:50:32,170 --> 00:50:32,850
しかしのために、ためである - 

959
00:50:32,850 --> 00:50:33,330
>> [声を挟ん]

960
00:50:33,330 --> 00:50:34,520
>> 学生：[聞こえない]。

961
00:50:34,520 --> 00:50:35,060
>> JASONハーシュホーン：その通りです。

962
00:50:35,060 --> 00:50:37,260
関数の宣言ごとに、
我々は価値を探しています。

963
00:50:37,260 --> 00:50:39,760
だから我々は価値を探している
値の配列中。

964
00:50:39,760 --> 00:50:41,080
だから、正確に正しいです。

965
00:50:41,080 --> 00:50:45,040
あなた致します、もしオープン括弧値ブラケット
真ん中は、ブラケット等号を閉じた

966
00:50:45,040 --> 00:50:49,930
内部そこに価値に等しく、
我々は何をすべきかが必要なのですか？

967
00:50:49,930 --> 00:50:51,230
もし私たちの価値のあり、どのような
私たちが行う必要があるのですか？

968
00:50:51,230 --> 00:50:51,420
>> [声を挟ん]

969
00:50:51,420 --> 00:50:52,160
>> 学生：ゼロでない値を返します。

970
00:50:52,160 --> 00:50:53,070
>> JASONハーシュホーン：trueを返します。

971
00:50:53,070 --> 00:50:54,790
>> 学生：trueを返します。

972
00:50:54,790 --> 00:50:57,856
>> JASONハーシュホーン：マイケル、
この行は何をするのでしょうか？

973
00:50:57,856 --> 00:51:01,105
>> 学生：[聞こえない]プログラムが実行された
そのコースは、それが終わり、

974
00:51:01,105 --> 00:51:01,920
あなたは何をする必要があるかね？

975
00:51:01,920 --> 00:51:03,030
>> JASONハーシュホーン：プログラムまたは何？

976
00:51:03,030 --> 00:51:03,700
この場合は？

977
00:51:03,700 --> 00:51:04,210
>> 学生：機能。

978
00:51:04,210 --> 00:51:05,170
>> JASONハーシュホーン：機能。

979
00:51:05,170 --> 00:51:08,420
だから、と呼ばれる何でもして戻る
それそれに真の価値を与える。

980
00:51:08,420 --> 00:51:09,890
まったく正しい。

981
00:51:09,890 --> 00:51:10,170
メイン。

982
00:51:10,170 --> 00:51:12,035
戻り値の型は何ですか
メインの、マイケル？

983
00:51:12,035 --> 00:51:16,480

984
00:51:16,480 --> 00:51:17,150
>> 学生：int型の整数？

985
00:51:17,150 --> 00:51:18,080
>> JASONハーシュホーン：INT、正確に。

986
00:51:18,080 --> 00:51:18,680
整数。

987
00:51:18,680 --> 00:51:20,980
つまり、確実にするだけで問題だった
あなたたちはその上にあった。

988
00:51:20,980 --> 00:51:24,250
それは通常ならば、何を返さない
すべての物事はうまく働いている？

989
00:51:24,250 --> 00:51:24,520
>> 学生：ゼロ。

990
00:51:24,520 --> 00:51:24,820
>> JASONハーシュホーン：ゼロ。

991
00:51:24,820 --> 00:51:25,430
まったく正しい。

992
00:51:25,430 --> 00:51:28,790
>> 学生：これは単なるtrueを返した場合、
与えられている情報はありません

993
00:51:28,790 --> 00:51:30,675
何について - 

994
00:51:30,675 --> 00:51:34,040
ああ、これはちょうどそのことを言っている
値は、配列の中にあります。

995
00:51:34,040 --> 00:51:35,350
>> JASONハーシュホーン：その通りです。

996
00:51:35,350 --> 00:51:38,080
このプログラムは、情報を提供されていません
正確に値がどこにあるの。

997
00:51:38,080 --> 00:51:41,850
それだけで、はい、我々が発見し、言っている
それか、いや、我々はそれを見つけることができませんでした。

998
00:51:41,850 --> 00:51:42,990
数が見つかったのであれば、trueを返す。

999
00:51:42,990 --> 00:51:45,500
さて、実際に私たちは本当にそれをした
すぐにそのコード1行で。

1000
00:51:45,500 --> 00:51:47,500
だから私は擬似コードのその行を移動します。

1001
00:51:47,500 --> 00:51:50,045
>> 学生：我々は必要としないでください
配列を変更するには？

1002
00:51:50,045 --> 00:51:52,830
それは右、値、値ではなくすべきですか？

1003
00:51:52,830 --> 00:51:53,430
>> JASONハーシュホーン：申し訳ありません。

1004
00:51:53,430 --> 00:51:54,010
ありがとう。

1005
00:51:54,010 --> 00:51:54,800
>> 学生：うん。

1006
00:51:54,800 --> 00:51:55,850
>> JASONハーシュホーン：この行
値でなければなりません。

1007
00:51:55,850 --> 00:51:57,150
まったく正しい。

1008
00:51:57,150 --> 00:51:57,920
[OK]をクリックします。

1009
00:51:57,920 --> 00:51:59,170
だから我々は、中央のリストを見てきました。

1010
00:51:59,170 --> 00:52:00,790
番号が見つかった場合にtrueを返します。

1011
00:52:00,790 --> 00:52:04,470
あれば、私たちの擬似コードでログオンし続けて
真ん中が大きい、検索は左

1012
00:52:04,470 --> 00:52:09,640
もしそうであれば、私は、ここに持っていた数
高いほど、探索は残しました。

1013
00:52:09,640 --> 00:52:12,700

1014
00:52:12,700 --> 00:52:14,462
コンスタンティンは、あなたが与えることができます
私のコード行？

1015
00:52:14,462 --> 00:52:17,240

1016
00:52:17,240 --> 00:52:23,520
>> 学生：真ん中の値の場合 - 

1017
00:52:23,520 --> 00:52:24,890
>> JASONハーシュホーン：そうであれば値 - 

1018
00:52:24,890 --> 00:52:28,890
オープン括弧値ブラケットの場合
真ん中近くにブラケット - 

1019
00:52:28,890 --> 00:52:31,500
>> 学生：値よりも小さい？

1020
00:52:31,500 --> 00:52:32,760
>> JASONハーシュホーンは：未満です。

1021
00:52:32,760 --> 00:52:33,800
>> 学生：値を下回る。

1022
00:52:33,800 --> 00:52:34,060
>> JASONハーシュホーン：値。

1023
00:52:34,060 --> 00:52:35,310
さて、実際に、あなたがしたい
数かどうかを確認する - 

1024
00:52:35,310 --> 00:52:38,310

1025
00:52:38,310 --> 00:52:38,490
申し訳ありません。

1026
00:52:38,490 --> 00:52:39,140
これは少し混乱しています。

1027
00:52:39,140 --> 00:52:43,920
しかし、他の場合の数値
リストの中間に大きい。

1028
00:52:43,920 --> 00:52:45,170
>> 学生：ああ、[OK]をクリックします。

1029
00:52:45,170 --> 00:52:49,800

1030
00:52:49,800 --> 00:52:50,410
>> JASONハーシュホーン：私はそれを変更します。

1031
00:52:50,410 --> 00:52:55,060
真ん中が高ければ、我々は、他の
[OK]を、左の検索したい？

1032
00:52:55,060 --> 00:52:57,310
そして、我々は内部で何をしますか
この状態であれば？

1033
00:52:57,310 --> 00:53:03,660

1034
00:53:03,660 --> 00:53:07,510
>> 学生：私は、小さな変更を加えることができます
場合、条件は、他にそれを変更しますか？

1035
00:53:07,510 --> 00:53:08,380
>> JASONハーシュホーン：他の場合？

1036
00:53:08,380 --> 00:53:09,270
[OK]をクリックします。

1037
00:53:09,270 --> 00:53:12,840
ので、このコードが実行されます
ほぼ同じ。

1038
00:53:12,840 --> 00:53:18,620
しかし、そうでなければ、あれば使用しての良いところ
、もし場合や、他の他の場合、そうでない場合

1039
00:53:18,620 --> 00:53:22,320
それらの一方のみに起こっていることを意味する
チェックすることがなく、それらのすべて3、

1040
00:53:22,320 --> 00:53:23,290
潜在的に。

1041
00:53:23,290 --> 00:53:25,530
そして、それはそれは少しできます
のコンピュータ上でよりよい

1042
00:53:25,530 --> 00:53:26,670
プログラムを実行している。

1043
00:53:26,670 --> 00:53:27,620
>> ので、[？コンスタンティン、？]

1044
00:53:27,620 --> 00:53:31,330
我々は、値があればそれ以外は、この行の中にいる
ブラケット中央の閉じ括弧

1045
00:53:31,330 --> 00:53:32,260
値よりも大きい。

1046
00:53:32,260 --> 00:53:33,150
私たちがしなければならないのですか？

1047
00:53:33,150 --> 00:53:33,970
我々は左に検索する必要があります。

1048
00:53:33,970 --> 00:53:35,220
我々はそれをどのように行うのですか？

1049
00:53:35,220 --> 00:53:46,960

1050
00:53:46,960 --> 00:53:48,720
私はあなたのスタートを与えるつもりだ。

1051
00:53:48,720 --> 00:53:52,210
>> 我々はと呼ばれるこれらの二つのことを持っている
開始と終了。

1052
00:53:52,210 --> 00:53:57,340
だから何が起こる必要がある
先頭に？

1053
00:53:57,340 --> 00:53:59,640
あなたは左側を検索する場合
リストは、我々の現在の先頭を取得します。

1054
00:53:59,640 --> 00:54:01,080
我々はそれを行うには何が必要ですか？

1055
00:54:01,080 --> 00:54:04,220
>> 学生：私たちは、初めに設定
中央に1を加えた。

1056
00:54:04,220 --> 00:54:05,120
>> JASONハーシュホーン：だから我々はしている場合
左をお探しですか？

1057
00:54:05,120 --> 00:54:06,250
>> 学生：申し訳ありませんが、中間のマイナス - 

1058
00:54:06,250 --> 00:54:11,310
その結末は真ん中になります
マイナス1と始まり - 

1059
00:54:11,310 --> 00:54:12,450
>> JASONハーシュホーン：そして、何
最初はどうなるのでしょうか？

1060
00:54:12,450 --> 00:54:13,210
>> 学生：それは同じまま。

1061
00:54:13,210 --> 00:54:14,120
>> JASONハーシュホーン：だから
意味は同じまま。

1062
00:54:14,120 --> 00:54:16,040
我々は左を検索している場合は、している
同じ先頭を使用して - 

1063
00:54:16,040 --> 00:54:16,860
まったく正しい。

1064
00:54:16,860 --> 00:54:17,870
と終了？

1065
00:54:17,870 --> 00:54:19,390
申し訳ありませんが、何をしていますか
再び等しい終わる？

1066
00:54:19,390 --> 00:54:20,750
>> 学生：ミドルマイナス1。

1067
00:54:20,750 --> 00:54:21,620
>> JASONハーシュホーン：中東マイナス1。

1068
00:54:21,620 --> 00:54:23,470
今、なぜマイナス1、中だけではなく？

1069
00:54:23,470 --> 00:54:32,870

1070
00:54:32,870 --> 00:54:35,570
>> 学生：真ん中から外れている
絵はすでに、我々が持っていたので、

1071
00:54:35,570 --> 00:54:36,700
それがだと確認さ？

1072
00:54:36,700 --> 00:54:37,630
>> JASONハーシュホーン：それです。
まったく正しい。

1073
00:54:37,630 --> 00:54:38,580
真ん中は絵の外にある。

1074
00:54:38,580 --> 00:54:39,800
我々はすでに中央をチェックした。

1075
00:54:39,800 --> 00:54:44,730
だから我々は「ミドル」、引用したくない
であり続けるためには、引用終わり

1076
00:54:44,730 --> 00:54:46,110
我々は見ている配列。

1077
00:54:46,110 --> 00:54:47,670
だから、これは素晴らしいです。

1078
00:54:47,670 --> 00:54:50,670
>> それ以外の値ブラケット中央が大きい場合
等号を終了値よりも

1079
00:54:50,670 --> 00:54:51,920
真ん中のマイナス1。

1080
00:54:51,920 --> 00:54:55,060

1081
00:54:55,060 --> 00:54:57,340
ジェフ、どのようなこの最後の行はどうでしょうか？

1082
00:54:57,340 --> 00:54:58,590
>> 学生：そうで。

1083
00:54:58,590 --> 00:55:02,486

1084
00:55:02,486 --> 00:55:06,000
値の中間の値よりも小さい？

1085
00:55:06,000 --> 00:55:07,570
>> JASONハーシュホーン：私たちは、よ
あなたは他に私を与えている。

1086
00:55:07,570 --> 00:55:09,310
あなたが私を与えていないのであれば - 

1087
00:55:09,310 --> 00:55:12,270
>> 学生：それでは始め
真ん中のプラス1になります。

1088
00:55:12,270 --> 00:55:16,100

1089
00:55:16,100 --> 00:55:19,070
>> JASONハーシュホーン：開始等号
同じもののため、もう一度真ん中に1を加え、

1090
00:55:19,070 --> 00:55:20,820
理由そのコンスタンティン
以前の私たちに与えた。

1091
00:55:20,820 --> 00:55:24,280
そして最後に、誰が与えられていません
私はまだコードの行？

1092
00:55:24,280 --> 00:55:26,600
falseを返し、Aleha、どのような
我々はここに書きますか？

1093
00:55:26,600 --> 00:55:28,590
>> 学生：falseを返します。

1094
00:55:28,590 --> 00:55:29,320
>> JASONハーシュホーン：falseを返します。

1095
00:55:29,320 --> 00:55:33,340
そして、我々は、それを行う必要があるためであれば、私たち
それを見つけることはありません、我々は我々を言う必要がある

1096
00:55:33,340 --> 00:55:34,080
それを見つけることができませんでした。

1097
00:55:34,080 --> 00:55:36,270
そして、我々は我々が戻ってするつもりだと述べ
BOOLので、我々は間違いなく返す必要が

1098
00:55:36,270 --> 00:55:38,150
ブールどこか。

1099
00:55:38,150 --> 00:55:42,590
>> それでは、このコードを実行してみましょう。

1100
00:55:42,590 --> 00:55:44,520
私は実際に行くよ - 

1101
00:55:44,520 --> 00:55:45,930
私たちは、ターミナルにいる。

1102
00:55:45,930 --> 00:55:47,230
我々は我々のウィンドウをクリアします。

1103
00:55:47,230 --> 00:55:49,270
のすべてを作成してみましょう。

1104
00:55:49,270 --> 00:55:50,340
私たちは、1エラーがあるとわかった。

1105
00:55:50,340 --> 00:55:54,280
期待15行目にエラーがあります
の末尾にセミコロン

1106
00:55:54,280 --> 00:55:54,890
宣言。

1107
00:55:54,890 --> 00:55:56,454
だから私は何を忘れてしまいましたか？

1108
00:55:56,454 --> 00:55:57,230
>> 学生：セミコロン。

1109
00:55:57,230 --> 00:56:00,200
>> JASONハーシュホーン：セミコロン
ちょうどここまで。

1110
00:56:00,200 --> 00:56:00,950
私はトムのコードだったと思います。

1111
00:56:00,950 --> 00:56:01,870
そうトム、[聞こえない]。

1112
00:56:01,870 --> 00:56:03,120
ほんの冗談です。

1113
00:56:03,120 --> 00:56:05,010

1114
00:56:05,010 --> 00:56:07,310
のすべてを再び確認してみましょう。

1115
00:56:07,310 --> 00:56:10,180
>> 学生：何Dropboxのディレクトリ
我々はこのためにあるべき？

1116
00:56:10,180 --> 00:56:11,345
>> JASONハーシュホーン：だからあなたができる
ただ、このビットを監視します。

1117
00:56:11,345 --> 00:56:16,380
しかし、再び、あなたはこれを移動したい場合
試してみてくださいpset3ディレクトリにコード

1118
00:56:16,380 --> 00:56:17,050
それ外、それは私がやったことだ。

1119
00:56:17,050 --> 00:56:18,600
ここで気づく場合 - 
申し訳ありませんが、良い質問。

1120
00:56:18,600 --> 00:56:19,460
>> [？ LS、？]

1121
00:56:19,460 --> 00:56:24,700
私はここで持っているfind.cコード
今週のディストリビューションのコードから。

1122
00:56:24,700 --> 00:56:26,300
私はHelpers.hにしています。

1123
00:56:26,300 --> 00:56:30,010
私は実際にメイクファイルを持っている
これらの新しいが含まれるように少し編集した

1124
00:56:30,010 --> 00:56:30,710
私たちが書いているファイル。

1125
00:56:30,710 --> 00:56:34,120
そのコードのすべては、利用できませんになります
流通コードが、新しい

1126
00:56:34,120 --> 00:56:39,510
ファイルを作成し、新しいHelpers.hにファイル意志
ダウンロードするオンラインで利用可能であること。

1127
00:56:39,510 --> 00:56:41,800
繰り返しますが、そのものがある
余分なコードは、我々は持っている。

1128
00:56:41,800 --> 00:56:46,130
>> したがって、すべての確認は、この行ごとに、見つけるなり、
バイナリ、バブルの選択 - のmake

1129
00:56:46,130 --> 00:56:50,930
それらのすべての3とにコンパイル
この実行可能コードを検索します。

1130
00:56:50,930 --> 00:56:54,090
だから一般的に、我々はしたくない
check50にまっすぐに。

1131
00:56:54,090 --> 00:56:57,580
我々は我々自身にいくつかのテストを実行したい。

1132
00:56:57,580 --> 00:57:11,750
しかし、単に私たちは、このビットを促進することができます
check50 2013 pset3.findが通過します

1133
00:57:11,750 --> 00:57:14,630
私の悪い -  helpers.cイン。

1134
00:57:14,630 --> 00:57:16,050
>> 私は今それを持っていません。

1135
00:57:16,050 --> 00:57:20,670
だから我々は、実際にするつもりだ
実際にコードを実行します。

1136
00:57:20,670 --> 00:57:23,570
Usage.find /、あなたはそれが何を意味するか知っていますか？

1137
00:57:23,570 --> 00:57:25,970
>> 学生：あなたは秒を必要とする
これでコマンドライン。

1138
00:57:25,970 --> 00:57:26,980
>> JASONハーシュホーン：私が必要とする
目のコマンドライン。

1139
00:57:26,980 --> 00:57:30,640
と仕様ごとに、私が必要とする
私たちが探しているものを入力します。

1140
00:57:30,640 --> 00:57:33,750
それでは、42のために見てみましょう。

1141
00:57:33,750 --> 00:57:37,030
私たちので、私たちは、ソートされたでそれをしておこう
まだソート機能を書いていない - 

1142
00:57:37,030 --> 00:57:41,830
42、43、44。

1143
00:57:41,830 --> 00:57:46,240
>> ·制御Dは見つけられませんでした
干し草の山の中の針。

1144
00:57:46,240 --> 00:57:46,505
そりゃまずい。

1145
00:57:46,505 --> 00:57:47,200
それは間違いなくあります。

1146
00:57:47,200 --> 00:57:48,090
それでは何か他のものを試してみましょう。

1147
00:57:48,090 --> 00:57:49,860
私が置くので、多分それはだ
先頭に。

1148
00:57:49,860 --> 00:57:54,490
>> それでは41、42、43をやってみましょう。

1149
00:57:54,490 --> 00:57:55,012
そこに私達は行く。

1150
00:57:55,012 --> 00:57:56,400
それは、それを発見した。

1151
00:57:56,400 --> 00:58:00,040
それでは、最後にそれを入れさせ、ただ
私たちは徹底的にすることができます - 

1152
00:58:00,040 --> 00:58:03,580
40、41、42。

1153
00:58:03,580 --> 00:58:05,760
針を見つけられませんでした。

1154
00:58:05,760 --> 00:58:07,550
だから私はこの先に言及した。

1155
00:58:07,550 --> 00:58:08,980
残念ながら、私はこれを知っていた
起きようとした。

1156
00:58:08,980 --> 00:58:11,490
>> しかし、教育的な目的のために、
それを探るために良いことだ。

1157
00:58:11,490 --> 00:58:12,990
それは動作しません。

1158
00:58:12,990 --> 00:58:16,020
何らかの理由で、それはそれを見つけることができません。

1159
00:58:16,020 --> 00:58:18,970
我々はそこに何があるか知っているが、
我々はそれを見つけることはありません。

1160
00:58:18,970 --> 00:58:24,140
私たちは何ができる一つのことは通過している
それを見つけるために、GDBが、誰にもないので、

1161
00:58:24,140 --> 00:58:27,850
GDBを経由せずに、持っている
我々はめちゃくちゃにどこ感？

1162
00:58:27,850 --> 00:58:28,480
[？ MADU？ ？]

1163
00:58:28,480 --> 00:58:30,960
>> 学生：私はそれが終了する可能性がある場合と思います
初めに等しく、それはだ

1164
00:58:30,960 --> 00:58:33,090
ただ1要素のリスト。

1165
00:58:33,090 --> 00:58:35,560
それはだけではなく、それを無視します
実際にそれをチェックする。

1166
00:58:35,560 --> 00:58:36,940
>> JASONハーシュホーン：それです。
まったく正しい。

1167
00:58:36,940 --> 00:58:41,110
結末は初めに等しいとき、私たちは何
まだ我々のリストの要素を持っている？

1168
00:58:41,110 --> 00:58:42,480
>> 学生：はい。

1169
00:58:42,480 --> 00:58:45,450
>> JASONハーシュホーン：はい、実際には、我々
1つだけの要素を持っている。

1170
00:58:45,450 --> 00:58:50,500
そして、それは最も可能性が高い場合に発生します、
我々はテストされたコードごとに、我々はである

1171
00:58:50,500 --> 00:58:54,640
干し草の山の、またはフロント·
干し草の山の終わり。

1172
00:58:54,640 --> 00:58:56,000
始まると場所です
エンディングは等しいとしている

1173
00:58:56,000 --> 00:58:57,820
二分探索で1、。

1174
00:58:57,820 --> 00:59:01,440
ので、これらの2例では、動作しませんでした、
終わるためには、初めに等しかった。

1175
00:59:01,440 --> 00:59:06,030
>> しかし、終了した場合は、最初に等しく、
このwhileループが実行されません？

1176
00:59:06,030 --> 00:59:06,390
それはしていません。

1177
00:59:06,390 --> 00:59:08,660
そして、我々はチェックしている可能性が
その再びGDBを通して。

1178
00:59:08,660 --> 00:59:14,000
では、どのように、このコードを修正することができますので、
終了ながらに等しい場合

1179
00:59:14,000 --> 00:59:16,070
から始めて、我々はまた、これが欲しい
ループの実行にしている。

1180
00:59:16,070 --> 00:59:18,620
>> だから我々は18行目に何を修正することができますか？

1181
00:59:18,620 --> 00:59:21,060
>> 学生：[聞こえない]大きい
イコール。

1182
00:59:21,060 --> 00:59:21,700
>> JASONハーシュホーン：まったく正しい。

1183
00:59:21,700 --> 00:59:24,600
終了しながら、より大きくなる
または初めに等しい。

1184
00:59:24,600 --> 00:59:27,300
だから今、我々はそれを得るようにしてください
最後にコーナーケース。

1185
00:59:27,300 --> 00:59:27,870
と見てみましょう。

1186
00:59:27,870 --> 00:59:29,560
のは、この1のより多くの時間を実行してみましょう。

1187
00:59:29,560 --> 00:59:31,266
>> のすべてを作ってみましょう。

1188
00:59:31,266 --> 00:59:33,910
もう一度、あなただけの必要があるでしょう
ここで一緒に従う。

1189
00:59:33,910 --> 00:59:36,280
41この時間を見つける。

1190
00:59:36,280 --> 00:59:37,360
ただそれは、一貫性の維持。

1191
00:59:37,360 --> 00:59:38,210
>> 42を見つける。

1192
00:59:38,210 --> 00:59:38,930
それでは初めにそれを置くことができます - 

1193
00:59:38,930 --> 00:59:41,630
42、43、44。

1194
00:59:41,630 --> 00:59:42,860
我々はそれを発見した。

1195
00:59:42,860 --> 00:59:47,710
だから、実際に変更した
我々は確認する必要がありました。

1196
00:59:47,710 --> 00:59:51,090
>> それは我々のコーディングがたくさんいた
ただ、二分探索しました。

1197
00:59:51,090 --> 00:59:55,760
誰もが前にご質問があるん
私は、私たちが書いた行に移る

1198
00:59:55,760 --> 00:59:58,750
二分探索またはどのように私たちが考え出し
我々は理解しました何を？

1199
00:59:58,750 --> 01:00:01,900

1200
01:00:01,900 --> 01:00:06,270
先に進む前に、私も指すようにしたい
その分、大型うち、我々は、マッピングされた

1201
01:00:06,270 --> 01:00:09,300
私たちの擬似コード1に
私たちのコードの上に1。

1202
01:00:09,300 --> 01:00:11,550
>> 我々は、トリッキーなことをしなければならなかった
で把握する

1203
01:00:11,550 --> 01:00:12,890
開始と終了。

1204
01:00:12,890 --> 01:00:17,380
しかし、あなたはあなたが、それを考え出していなかった
ほとんど書かれていた

1205
01:00:17,380 --> 01:00:20,740
同一のコードでは、保存
これらの最初の2行。

1206
01:00:20,740 --> 01:00:23,380
そして、あなたは時に実現しているだろう
あなたがチェックし、場合によってはそれを作ったこと

1207
01:00:23,380 --> 01:00:24,840
あなたが何か他のものを必要としています。

1208
01:00:24,840 --> 01:00:28,510
だから、あなたが私たちに従っていた場合でも、
ラインへの擬似コード行は、きになる

1209
01:00:28,510 --> 01:00:31,130
の2行が、すべて得
あなたが書くために必要なコード。

1210
01:00:31,130 --> 01:00:33,900
>> そして、私はあなたたちことを賭けることをいとわないだろう
すべてのことを考え出しただろう

1211
01:00:33,900 --> 01:00:37,940
かなり迅速に、あなたが置くために必要なこと
図のようにそこにあるマーカーのいくつかの並べ替え

1212
01:00:37,940 --> 01:00:39,190
あなたがいた場所が不足しています。

1213
01:00:39,190 --> 01:00:41,540

1214
01:00:41,540 --> 01:00:44,550
それを再度、行うための電源である
事前に擬似コード。

1215
01:00:44,550 --> 01:00:47,310
だから我々は、最初のロジックを実行すると、することができます
我々は、構文を心配することができます。

1216
01:00:47,310 --> 01:00:51,470
>> 我々はロジックについて混乱していた
C言語でこのコードを記述しようとしながら、

1217
01:00:51,470 --> 01:00:53,110
我々はすべて台無しに得ているだろう。

1218
01:00:53,110 --> 01:00:56,340
そして、我々は約質問をすると思います
ロジックと構文とメッシュ生成

1219
01:00:56,340 --> 01:00:57,320
一緒にそれらをすべて。

1220
01:00:57,320 --> 01:01:02,170
そして、我々は失われた得ているだろう
迅速になることができるものを中

1221
01:01:02,170 --> 01:01:04,000
非常に難しい問題。

1222
01:01:04,000 --> 01:01:08,680
それでは、これから移動してみましょう
選択ソートする。

1223
01:01:08,680 --> 01:01:10,760
>> 我々は左の20分を持っています。

1224
01:01:10,760 --> 01:01:14,130
だから私は、私たちがすることはできません感じている
選択ソートのすべてを取得する

1225
01:01:14,130 --> 01:01:15,940
そしてバブルソート。

1226
01:01:15,940 --> 01:01:20,670
しかし、私たちは、少なくとも試みてみましょう
選択ソートを終了します。

1227
01:01:20,670 --> 01:01:23,540
だから、使用して選択ソートを実装
関数宣言を次に示します。

1228
01:01:23,540 --> 01:01:27,530
>> 再度、これはから取られ
問題は、仕様を設定してください。

1229
01:01:27,530 --> 01:01:31,560
int型の値、カッコです
整数の配列。

1230
01:01:31,560 --> 01:01:33,490
そしてint.nはその配列のサイズです。

1231
01:01:33,490 --> 01:01:36,840
選択ソートが起こっている
この配列をソートするために。

1232
01:01:36,840 --> 01:01:43,580
>> 選択の私達のメンタルモデルごとにそう
ソートは、プル - 

1233
01:01:43,580 --> 01:01:47,720
まず、リストを最初に行く
時間は、最小の番号を見つける、

1234
01:01:47,720 --> 01:01:52,860
初めにそれを置く、二を見つける
最小数は、に入れて

1235
01:01:52,860 --> 01:01:56,380
我々がしたい場合は、2番目の位置
昇順で並べ替え。

1236
01:01:56,380 --> 01:01:58,440
私は、あなたが書くことが強制されないよ
今の擬似コード。

1237
01:01:58,440 --> 01:02:01,350
>> しかし、我々は、クラスのようなコードを実行する前に、
5分、我々は、書き込みしようとしている

1238
01:02:01,350 --> 01:02:03,550
擬似コードので、我々はいくつかの意味を持っている
のどこに行っている。

1239
01:02:03,550 --> 01:02:05,630
だから、擬似コードを書き込もう
自分で。

1240
01:02:05,630 --> 01:02:08,610
して、それをオンしよう
コー​​ドに擬似コード。

1241
01:02:08,610 --> 01:02:10,740
我々はグループとしてそれを行います
5分ぐらいのところにあります。

1242
01:02:10,740 --> 01:02:32,560

1243
01:02:32,560 --> 01:02:33,895
>> そしてもちろん、私に知らせた場合
何か質問があります。

1244
01:02:33,895 --> 01:03:56,738

1245
01:03:56,738 --> 01:03:58,230
>> 学生：それですか？

1246
01:03:58,230 --> 01:04:00,280
>> JASONハーシュホーン：どこまで参照してください
2分以上に得ることができます。

1247
01:04:00,280 --> 01:04:01,790
私はあなたがいないでしょう理解
終えることができるように。

1248
01:04:01,790 --> 01:04:03,050
しかし、我々はグループとして、この上に行くでしょう。

1249
01:04:03,050 --> 01:04:57,830

1250
01:04:57,830 --> 01:05:00,630
>> あなたはすべての[聞こえない]のでコーディングしているので、私はよ
何をやっているポーズは残念。

1251
01:05:00,630 --> 01:05:02,530
しかし、ここでは、グループとして、この通ししています。

1252
01:05:02,530 --> 01:05:07,590
そして再び、バイナリサーチは、あなたのすべてを与える
コー​​ドの行以上ではないなら、私1。

1253
01:05:07,590 --> 01:05:08,530
そのしていただきありがとうございます。

1254
01:05:08,530 --> 01:05:11,730
私たちは同じことをやろうとしている
ここでは、グループとして一緒にコーディングします。

1255
01:05:11,730 --> 01:05:15,170
>> だから、選択ソート - それでは書いてみましょう
いくつかの簡単な擬似コード。

1256
01:05:15,170 --> 01:05:20,380
メンタルモデルごとに、誰かが私を与えることができます
擬似コードの最初の行、してください？

1257
01:05:20,380 --> 01:05:23,000

1258
01:05:23,000 --> 01:05:24,270
私は何をしたいのですか？

1259
01:05:24,270 --> 01:05:27,070
>> 学生：ながらリスト
故障している。

1260
01:05:27,070 --> 01:05:30,630
>> JASONハーシュホーン：OK、しばらく
リストには、故障している。

1261
01:05:30,630 --> 01:05:33,540
そして、あなたは「順不同？ "何を意味するのか

1262
01:05:33,540 --> 01:05:34,960
>> 学生：ながら[聞こえない]

1263
01:05:34,960 --> 01:05:36,210
ソートされていません。

1264
01:05:36,210 --> 01:05:38,460

1265
01:05:38,460 --> 01:05:40,290
>> JASONハーシュホーンます。whileリスト
故障している、我々は何をしますか？

1266
01:05:40,290 --> 01:05:44,200
私に二行目を付け、
マーカスでお願いします。

1267
01:05:44,200 --> 01:05:47,186
>> 学生：だから次を検索
最小数。

1268
01:05:47,186 --> 01:05:49,000
これはインデントされます。

1269
01:05:49,000 --> 01:05:55,140
>> JASONハーシュホーン：だから見つける
次の最小数。

1270
01:05:55,140 --> 01:05:56,460
して、他の誰か？

1271
01:05:56,460 --> 01:06:01,030
我々は次に小さいが見つかったら
数、我々は何をしますか？

1272
01:06:01,030 --> 01:06:03,010
私が見つけると言うつもりです
最小数。

1273
01:06:03,010 --> 01:06:04,820
それは我々が何をしたいのです。

1274
01:06:04,820 --> 01:06:06,210
>> だから、最小の番号を見つける。

1275
01:06:06,210 --> 01:06:08,061
その後、我々は何をしますか？

1276
01:06:08,061 --> 01:06:09,480
>> 学生：[聞こえない]先頭に。

1277
01:06:09,480 --> 01:06:10,680
>> JASONハーシュホーン：申し訳ありませんが？

1278
01:06:10,680 --> 01:06:12,700
>> 学生：それを置きます
リストの先頭。

1279
01:06:12,700 --> 01:06:18,540
>> JASONハーシュホーン：だからに入れてください
リストの先頭。

1280
01:06:18,540 --> 01:06:20,140
そして、私たちはものに何をしますか
それが始まりだった

1281
01:06:20,140 --> 01:06:20,830
リストの、右？

1282
01:06:20,830 --> 01:06:21,910
私たちは、何かを上書きしています。

1283
01:06:21,910 --> 01:06:23,130
だからここで我々はそれを置くのですか？

1284
01:06:23,130 --> 01:06:24,120
ええ、アンナ？

1285
01:06:24,120 --> 01:06:25,520
>> 学生：最小
数がでしたか？

1286
01:06:25,520 --> 01:06:32,530
>> JASONハーシュホーン：だから始まりを置く
ここで、リストの

1287
01:06:32,530 --> 01:06:35,180
最小の数があった。

1288
01:06:35,180 --> 01:06:38,510
リストには、故障しているので、一方、見つける
最小数、に入れてください

1289
01:06:38,510 --> 01:06:40,630
リストの先頭には、置く
ここで、リストの先頭

1290
01:06:40,630 --> 01:06:42,900
最小の数があった。

1291
01:06:42,900 --> 01:06:45,780
マーカス、この行を言い換えることができます
リストには、故障している間に？

1292
01:06:45,780 --> 01:06:51,160

1293
01:06:51,160 --> 01:06:53,900
>> 学生：数字ながら
ソートされていない？

1294
01:06:53,900 --> 01:06:55,920
>> JASONハーシュホーン：OK、そうするためには
番号がなかったことを知っている

1295
01:06:55,920 --> 01:06:58,670
並べ替え、私たちは何をする必要がありますか？

1296
01:06:58,670 --> 01:07:00,640
我々は、どれだけの必要なのですか
このリストを行く？

1297
01:07:00,640 --> 01:07:09,650
>> 学生：だから私は、forループを推測したり、
一方、番号がチェックながら以下である

1298
01:07:09,650 --> 01:07:11,900
リストの長さよりも？

1299
01:07:11,900 --> 01:07:13,160
>> JASONハーシュホーン：OK、それはいいですね。

1300
01:07:13,160 --> 01:07:15,000
私はmisphrased思う
私の質問が不十分。

1301
01:07:15,000 --> 01:07:15,990
私はただで取得しようとしていた
私達は行く必要があるとしている

1302
01:07:15,990 --> 01:07:17,580
リスト全体を通して。

1303
01:07:17,580 --> 01:07:20,490
リストには、故障している最中に、
私のために、上の地図のは難しいです。

1304
01:07:20,490 --> 01:07:24,940
しかし、基本的に、それは方法です
私はこれを考えてみてください。

1305
01:07:24,940 --> 01:07:28,880
見つけ、リスト全体を経る
最小数、に入れてください

1306
01:07:28,880 --> 01:07:30,130
始まる - 実際に、あなたは正しい。

1307
01:07:30,130 --> 01:07:31,380
それでは、それらの両方を入れてみましょう。

1308
01:07:31,380 --> 01:07:33,470

1309
01:07:33,470 --> 01:07:39,050
>> リストには、故障しているので、一方、私たち
リスト全体を通過する必要が

1310
01:07:39,050 --> 01:07:42,250
一度、最小数、場所を見つける
そのリストの先頭に、置く

1311
01:07:42,250 --> 01:07:45,430
どこで、リストの先頭
場合は、最小の数は、その後で、

1312
01:07:45,430 --> 01:07:47,460
リストには、私たちがした、故障してまだある
この経るようになった

1313
01:07:47,460 --> 01:07:48,620
プロセスを再度、右？

1314
01:07:48,620 --> 01:07:51,610
だからこそ、選択ソート、ビッグオーランタイムの
選択ソートのは、誰？

1315
01:07:51,610 --> 01:07:52,830
>> 学生：N乗。

1316
01:07:52,830 --> 01:07:53,590
>> JASONハーシュホーン：N乗。

1317
01:07:53,590 --> 01:07:57,040
マーカスと私は実現好きだから
ここでは、する必要があるとしている

1318
01:07:57,040 --> 01:08:00,310
リスト一覧を経る
回数。

1319
01:08:00,310 --> 01:08:03,420
そうのようなものを経由
長さnのn回の数

1320
01:08:03,420 --> 01:08:04,990
実際には、n乗。

1321
01:08:04,990 --> 01:08:08,100
>> だから、これは私たちの擬似コードである。

1322
01:08:08,100 --> 01:08:09,360
これは非常によさそうだ。

1323
01:08:09,360 --> 01:08:11,870
誰もが疑問を持っていますか
擬似コードはどうでしょうか？

1324
01:08:11,870 --> 01:08:14,440
実際に選択ソートがなければならないので
おそらく、1からコードを1に来る

1325
01:08:14,440 --> 01:08:14,980
擬似コード。

1326
01:08:14,980 --> 01:08:17,569
そんなにご質問
擬似コードのロジック？

1327
01:08:17,569 --> 01:08:18,819
今すぐお問い合わせください。

1328
01:08:18,819 --> 01:08:22,609

1329
01:08:22,609 --> 01:08:25,379
>> 選択ソート - リストが出ている間
オーダー、我々はそれを通過しようとしている

1330
01:08:25,379 --> 01:08:27,529
最小毎回見つける
そして前に置きます。

1331
01:08:27,529 --> 01:08:33,470
リストには、故障している最中に、することができます
誰かが私に誰がそのコード行を与える

1332
01:08:33,470 --> 01:08:39,689
私にラインを与えていません
してください、まだコードの？

1333
01:08:39,689 --> 01:08:40,939
それは何のように聞こえる？

1334
01:08:40,939 --> 01:08:43,669

1335
01:08:43,669 --> 01:08:44,649
>> 学生：それはforループです。

1336
01:08:44,649 --> 01:08:45,830
>> JASONハーシュホーン：それが鳴ります
forループのような。

1337
01:08:45,830 --> 01:08:47,653
[OK]を、あなたは私に、forループを与えることができますか？

1338
01:08:47,653 --> 01:08:48,925
のための - 

1339
01:08:48,925 --> 01:08:50,219
>> 学生：私は0に等しくなります。

1340
01:08:50,219 --> 01:08:52,705
>> JASONハーシュホーン：iまたは - 

1341
01:08:52,705 --> 01:08:55,111
我々は何が不足している？

1342
01:08:55,111 --> 01:08:56,819
何が右ここに？

1343
01:08:56,819 --> 01:08:57,550
>> 学生：INT。

1344
01:08:57,550 --> 01:08:59,270
>> JASONハーシュホーン：その通りです。

1345
01:08:59,270 --> 01:09:02,590
（I = 0 int型;  - 

1346
01:09:02,590 --> 01:09:07,843
>> 学生：私はN <; I + +）。

1347
01:09:07,843 --> 01:09:09,319
>> JASONハーシュホーン：ジェフ、それを釘付け。

1348
01:09:09,319 --> 01:09:10,660
我々は正しい、リストをつもりだ？

1349
01:09:10,660 --> 01:09:11,880
我々は前にそのコードを見てきました。

1350
01:09:11,880 --> 01:09:12,850
完璧。

1351
01:09:12,850 --> 01:09:14,790
それでは、ここで我々の中括弧を入れてみましょう。

1352
01:09:14,790 --> 01:09:17,859
私はいくつかを置くつもりだ
ここに中括弧。

1353
01:09:17,859 --> 01:09:21,660
>> それは0ですながらそこで、我々は行く必要がある
リスト全体を通して。

1354
01:09:21,660 --> 01:09:26,612
我々はリストを介して進行ので、各時間
私たちは、追跡するために何をしたいですか？

1355
01:09:26,612 --> 01:09:28,260
>> 学生：任意のスワップが行われた場合。

1356
01:09:28,260 --> 01:09:29,069
>> JASONハーシュホーン：見つける
最小数。

1357
01:09:29,069 --> 01:09:31,479
だから我々は、おそらくを追跡する必要があります
最小数毎回。

1358
01:09:31,479 --> 01:09:34,590
だから、私はラインを把握するために行うことができます
最小数の？

1359
01:09:34,590 --> 01:09:37,720
Aleha、どのように維持することができます
何かのトラック？

1360
01:09:37,720 --> 01:09:38,460
>> 学生：新しい変数を起動します。

1361
01:09:38,460 --> 01:09:39,390
>> JASONハーシュホーン：新しい変数を起動します。

1362
01:09:39,390 --> 01:09:40,069
それでは、変数を作成してみましょう。

1363
01:09:40,069 --> 01:09:41,830
どのタイプ？

1364
01:09:41,830 --> 01:09:42,930
>> 学生：INT。

1365
01:09:42,930 --> 01:09:43,710
>> JASONハーシュホーン：INT。

1366
01:09:43,710 --> 01:09:44,939
の最小と呼ぶことにしましょう​​。

1367
01:09:44,939 --> 01:09:47,600
いつ、それは何と等しくない
私達はちょうど出始めている？

1368
01:09:47,600 --> 01:09:48,910
我々はまだリストを行っていない。

1369
01:09:48,910 --> 01:09:50,540
私たちは、最初の部分にいる
を通して私たちの最初の時間を示します。

1370
01:09:50,540 --> 01:09:51,930
それが等しい何を、
最小数？

1371
01:09:51,930 --> 01:09:54,140
>> 学生：値I。

1372
01:09:54,140 --> 01:09:54,900
>> JASONハーシュホーン：値I。

1373
01:09:54,900 --> 01:09:56,980
その通り、正確に右に聞こえる？

1374
01:09:56,980 --> 01:09:59,590
先頭の最小数
私たちがどこにいるかである。

1375
01:09:59,590 --> 01:10:01,960
だから今我々は我々の最小を持っており、我々は必要とする
リスト全体を通過して、

1376
01:10:01,960 --> 01:10:05,080
この最小の比較
他のすべての。

1377
01:10:05,080 --> 01:10:08,150
だから我々は再びリストを行くのですか？

1378
01:10:08,150 --> 01:10:08,630
マイケル？

1379
01:10:08,630 --> 01:10:10,000
>> 学生：あなたが作る必要がある
ループのための別の。

1380
01:10:10,000 --> 01:10:10,383
>> JASONハーシュホーン：ループのもう一つ。

1381
01:10:10,383 --> 01:10:11,276
やってみましょう。

1382
01:10:11,276 --> 01:10:12,540
私にいくつかのコードを与える。

1383
01:10:12,540 --> 01:10:13,790
>> 学生：Forループ - 

1384
01:10:13,790 --> 01:10:16,750

1385
01:10:16,750 --> 01:10:19,470
最小のための - 

1386
01:10:19,470 --> 01:10:23,040

1387
01:10:23,040 --> 01:10:25,770
ちょうどあなたが言うことができ、J int型？

1388
01:10:25,770 --> 01:10:31,150
= 0;よう - 

1389
01:10:31,150 --> 01:10:34,014

1390
01:10:34,014 --> 01:10:35,710
>> JASONハーシュホーン：まあ、私たちが望む場合は、
リスト全体を通過するために - 

1391
01:10:35,710 --> 01:10:37,847
>> 学生：J <N、J + +）。

1392
01:10:37,847 --> 01:10:42,140

1393
01:10:42,140 --> 01:10:42,405
>> JASONハーシュホーン：ファンタスティック。

1394
01:10:42,405 --> 01:10:46,100
私たちは、通過しようとしている
再びforループ。

1395
01:10:46,100 --> 01:10:51,380
そして、我々は見つけるのですか
最小数？

1396
01:10:51,380 --> 01:10:52,630
トム？

1397
01:10:52,630 --> 01:10:54,570

1398
01:10:54,570 --> 01:11:00,520
私たちは、現在の最小の数を持って、
では、どのように新しい最小を見つけるのですか？

1399
01:11:00,520 --> 01:11:07,200
>> 学生：最小の場合は、Googleで確認することができます
我々が持っている数よりも大きい場合

1400
01:11:07,200 --> 01:11:09,040
ブラケットJ値。

1401
01:11:09,040 --> 01:11:14,740
>> JASONハーシュホーン：だから最小である場合に
値ブラケットjよりも大きい。

1402
01:11:14,740 --> 01:11:19,350
もしそうであれば我々の現在の最小
より大きい - 

1403
01:11:19,350 --> 01:11:21,770
私はこれらの2行を移動するつもりです
第二のためにそこのコード。

1404
01:11:21,770 --> 01:11:26,010
ので、我々は任意のスワップを行う前に、私たち
リスト全体を通過する必要があります。

1405
01:11:26,010 --> 01:11:28,880
したがって、この擬似コードは、実際にすべき
forループ、内側外側にある。

1406
01:11:28,880 --> 01:11:30,390
だから、リスト全体を通過します。

1407
01:11:30,390 --> 01:11:34,520
最小よりも大きければ
値jを、その後何？

1408
01:11:34,520 --> 01:11:37,830
>> 学生：その後、最小
値Jに等しい。

1409
01:11:37,830 --> 01:11:41,190

1410
01:11:41,190 --> 01:11:42,600
>> JASONハーシュホーン：ファンタスティック。

1411
01:11:42,600 --> 01:11:44,580
一つ簡単な質問 - 

1412
01:11:44,580 --> 01:11:47,236
我々はこのループを通過する初めて、
私は0に等しくなるように起こっている、Jが起こっている

1413
01:11:47,236 --> 01:11:50,710
我々はここで得れば0に等しくする。

1414
01:11:50,710 --> 01:11:52,410
だから我々は比較することになるだろう
自身への番号。

1415
01:11:52,410 --> 01:11:53,660
それが効率的ですか？

1416
01:11:53,660 --> 01:11:57,260

1417
01:11:57,260 --> 01:11:58,390
いいえ、それは本当に効率的ではありません。

1418
01:11:58,390 --> 01:12:02,915
だから私たちのJは行く必要がありません
0から毎回Nに？

1419
01:12:02,915 --> 01:12:06,310
私たちは常に確認する必要がありますか
リスト全体を通じて？

1420
01:12:06,310 --> 01:12:06,520
[聞こえない]？

1421
01:12:06,520 --> 01:12:07,564
>> 学生：ではなく、私から始めます。

1422
01:12:07,564 --> 01:12:09,405
>> JASONハーシュホーン：J缶
何で始まる？

1423
01:12:09,405 --> 01:12:09,990
>> 学生：私は。

1424
01:12:09,990 --> 01:12:13,040
>> JASONハーシュホーン：JはIから始めることができます。

1425
01:12:13,040 --> 01:12:18,840
だから今我々は始まる比較
1で我々はにしている。

1426
01:12:18,840 --> 01:12:21,020
しかし、その時でさえ、などということです
可能な限り効率的ですか？

1427
01:12:21,020 --> 01:12:22,320
>> 学生：I + 1。

1428
01:12:22,320 --> 01:12:25,420
>> JASONハーシュホーン：I + 1があると思われる
私たちのため、最も効率的な

1429
01:12:25,420 --> 01:12:26,120
すでに私が持っている。

1430
01:12:26,120 --> 01:12:28,100
私たちはそれを述べている
15行目で最小。

1431
01:12:28,100 --> 01:12:29,350
私たちは、で開始するつもりだ
次の1が自動的に。

1432
01:12:29,350 --> 01:12:34,470

1433
01:12:34,470 --> 01:12:38,540
だから我々は、forループを通過します。

1434
01:12:38,540 --> 01:12:39,620
私たちは、毎回通過します。

1435
01:12:39,620 --> 01:12:40,860
私たちは、回数を経るでしょう。

1436
01:12:40,860 --> 01:12:42,860
今、私たちはを通して得ている
ループは、このインナー。

1437
01:12:42,860 --> 01:12:44,350
私たちは、最も小さい値が保存されますがあります。

1438
01:12:44,350 --> 01:12:46,045
我々はでそれを配置する必要があり
リストの先頭。

1439
01:12:46,045 --> 01:12:48,390
それでは、どのよう私はでそれを置けば
リストの先頭？

1440
01:12:48,390 --> 01:12:51,290

1441
01:12:51,290 --> 01:12:55,926
参照する変数とは何ですか
リストの先頭に？

1442
01:12:55,926 --> 01:13:00,500
我々は、forループの外にいるこの
何が指し

1443
01:13:00,500 --> 01:13:01,280
リストの先頭？

1444
01:13:01,280 --> 01:13:02,880
>> 学生：値I。

1445
01:13:02,880 --> 01:13:03,510
>> JASONハーシュホーン：まったく正しい。

1446
01:13:03,510 --> 01:13:04,650
値私はの始まりです - 

1447
01:13:04,650 --> 01:13:06,320
または申し訳ありませんが、最初ではない。

1448
01:13:06,320 --> 01:13:07,090
それは混乱した。

1449
01:13:07,090 --> 01:13:11,620
我々は最初のどこにそれがだ
リストのソートされていない部分。

1450
01:13:11,620 --> 01:13:12,800
私は値を示します。

1451
01:13:12,800 --> 01:13:14,050
そして、何が同じことをしますか？

1452
01:13:14,050 --> 01:13:15,925

1453
01:13:15,925 --> 01:13:17,326
>> 学生：最小。

1454
01:13:17,326 --> 01:13:18,862
>> JASONハーシュホーン：値私は何に等しい？

1455
01:13:18,862 --> 01:13:19,310
>> 学生：最小。

1456
01:13:19,310 --> 01:13:20,030
>> JASONハーシュホーン：最小。

1457
01:13:20,030 --> 01:13:20,980
まったく正しい。

1458
01:13:20,980 --> 01:13:23,510
だから我々は先頭に置くことだ
リストで、そして今、我々は配置する必要があります

1459
01:13:23,510 --> 01:13:25,710
どこで、リストの先頭
最小の数があった。

1460
01:13:25,710 --> 01:13:29,700
それでは、どのよう私はどこに書くのですか
最小の数がでしたか？

1461
01:13:29,700 --> 01:13:31,670
何の値？

1462
01:13:31,670 --> 01:13:33,170
>> 学生：0。

1463
01:13:33,170 --> 01:13:34,090
>> JASONハーシュホーン：小
番号は0から始まりますか？

1464
01:13:34,090 --> 01:13:35,340
>> 学生：うん。

1465
01:13:35,340 --> 01:13:38,680

1466
01:13:38,680 --> 01:13:39,910
>> JASONハーシュホーン：何かの最小
数は、端部であっ

1467
01:13:39,910 --> 01:13:40,860
このソートされていないリスト？

1468
01:13:40,860 --> 01:13:42,460
>> 学生：申し訳ありませんが、質問は何でしたか？

1469
01:13:42,460 --> 01:13:44,020
>> JASONハーシュホーン：あり
最小数？

1470
01:13:44,020 --> 01:13:46,940
私たちは、最小を取り、でそれを置く
右こここの行で、始まる。

1471
01:13:46,940 --> 01:13:48,987
>> 学生：それは持っている必要があります
一部に記憶されて - 

1472
01:13:48,987 --> 01:13:50,510
>> 学生：値J。

1473
01:13:50,510 --> 01:13:51,520
>> JASONハーシュホーン：まあ、それはだ
必ずしもjは値。

1474
01:13:51,520 --> 01:13:54,100
それも、この時点では存在しません。

1475
01:13:54,100 --> 01:13:55,960
>> 学生：あなたが宣言する必要が
変数以前と

1476
01:13:55,960 --> 01:13:58,230
その後に割り当て - 

1477
01:13:58,230 --> 01:14:01,150
あなたが最小の番号を見つけたとき、
にその番号のインデックスを割り当てる

1478
01:14:01,150 --> 01:14:02,480
いくつかの変数またはそのような何か。

1479
01:14:02,480 --> 01:14:04,790
>> JASONハーシュホーン：だからできる
もう一度言う？

1480
01:14:04,790 --> 01:14:08,390
>> 学生：だから、int型を宣言した場合、
最小の、あなたも、intを宣言する必要があります

1481
01:14:08,390 --> 01:14:10,750
最小のインデックス= I、または
そのような何か。

1482
01:14:10,750 --> 01:14:13,280
>> JASONハーシュホーン：だからここで私は、INTを行う
最小、私が追跡しなければならないだけでなく、

1483
01:14:13,280 --> 01:14:16,150
値ではなく、場所の。

1484
01:14:16,150 --> 01:14:20,850
INT smallest_location =この中
場合、私達はちょうど私がやります。

1485
01:14:20,850 --> 01:14:22,390
私たちは、それがどこにあるかを知る必要があります。

1486
01:14:22,390 --> 01:14:26,820
我々は、コードの末尾になった、と我々
我々はそれがあった理解していませんでした実現しました。

1487
01:14:26,820 --> 01:14:29,810
だからもう一度、私たちは、マッピングされ
この一から一に。

1488
01:14:29,810 --> 01:14:32,890
自分の意志でこれをコーディング君たち
おそらく同じ問題に着く。

1489
01:14:32,890 --> 01:14:34,130
私はそれをどのように一体見つけるのですか？

1490
01:14:34,130 --> 01:14:36,720
そして、あなたは私が、待って、実現
それを追跡する必要がある。

1491
01:14:36,720 --> 01:14:38,500
>> そのように、最小の方が大きい場合
値jより。

1492
01:14:38,500 --> 01:14:39,740
私たちは、最小値jに等しい設定してください。

1493
01:14:39,740 --> 01:14:42,090
我々は変更する他には何が必要ですか？

1494
01:14:42,090 --> 01:14:43,710
コンスタンタン、他に何が
我々は変更する必要がありますか？

1495
01:14:43,710 --> 01:14:44,560
>> 学生：場所。

1496
01:14:44,560 --> 01:14:45,270
>> JASONハーシュホーン：その通りです。

1497
01:14:45,270 --> 01:14:46,925
だから、私のコードでその行を与える。

1498
01:14:46,925 --> 01:14:53,310
>> 学生：smallest_location = J。

1499
01:14:53,310 --> 01:14:54,790
>> JASONハーシュホーン：その通りです。

1500
01:14:54,790 --> 01:14:58,210
した後、最後にダウンし、我々がしたい場合は、
リストの先頭に置く場所

1501
01:14:58,210 --> 01:15:00,790
最小の数は、あったか
我々はどこを参照してください

1502
01:15:00,790 --> 01:15:02,200
最小の数がでしたか？

1503
01:15:02,200 --> 01:15:03,580
マーカス？

1504
01:15:03,580 --> 01:15:08,530
>> 学生：最小数た
最小の場所に位置しています。

1505
01:15:08,530 --> 01:15:12,230
>> JASONハーシュホーン：だから値で
smallest_location。

1506
01:15:12,230 --> 01:15:14,700
そして、我々はそこに何を入れますか？

1507
01:15:14,700 --> 01:15:17,600
の始まり
リスト、それは何ですか？

1508
01:15:17,600 --> 01:15:19,710
>> 学生：まあ、我々は本当にわからない
もう我々は上書きので。

1509
01:15:19,710 --> 01:15:23,250
だから、スワップの場所だ
これらの2つのラインの？

1510
01:15:23,250 --> 01:15:26,110
あなたは周りの人の2行を切り替えると。

1511
01:15:26,110 --> 01:15:30,740
>> JASONハーシュホーン：[OK]を、私たちにはありません
もう、私たちはラインをリセットしてきたので、

1512
01:15:30,740 --> 01:15:31,960
値の前に私が最も小さくする。

1513
01:15:31,960 --> 01:15:33,810
だから我々は、その初期値を失った。

1514
01:15:33,810 --> 01:15:37,350
ですから、スワップの2行と述べた。

1515
01:15:37,350 --> 01:15:41,780
だから今、リストの先頭に置く
ここで最小の番号があった。

1516
01:15:41,780 --> 01:15:47,060
そうsmallest_locationはi値に等しくなります。

1517
01:15:47,060 --> 01:15:51,310
つまり、これの始まりを動いている
、リストのソートされていない部分

1518
01:15:51,310 --> 01:15:52,090
最小の場所。

1519
01:15:52,090 --> 01:15:54,860
そして、我々は移動しているi値に
その最小数。

1520
01:15:54,860 --> 01:15:57,450
>> なぜ我々は意味がないことに
そのスワップをしなければならなかった？

1521
01:15:57,450 --> 01:15:59,650
私たちは、その値を上書きしていた - 
あなたはおそらくならないもう一つのこと

1522
01:15:59,650 --> 01:16:02,740
考え出したとGDPで見られる。

1523
01:16:02,740 --> 01:16:05,310
だから我々はお世話になってきた
すべての擬似コード。

1524
01:16:05,310 --> 01:16:10,935
何か他のものはありますか私たち
ここに記述する必要がありますか？

1525
01:16:10,935 --> 01:16:14,911
誰も何も考えることができますか？

1526
01:16:14,911 --> 01:16:16,180
>> 学生：どのように知っていますか
あなたが完了したら？

1527
01:16:16,180 --> 01:16:17,680
>> JASONハーシュホーン：どのように我々は何
我々が完了したら知っていますか？

1528
01:16:17,680 --> 01:16:18,890
偉大な質問。

1529
01:16:18,890 --> 01:16:21,684
では、どのように我々が完了したら、知っている。

1530
01:16:21,684 --> 01:16:24,720
>> 学生：カウントを保持するための変数を作成します。
そこにないようにして、スワップのですかの場合には

1531
01:16:24,720 --> 01:16:27,810
そして、パスを通過します。

1532
01:16:27,810 --> 01:16:30,180
>> JASONハーシュホーン：わかりました。

1533
01:16:30,180 --> 01:16:31,800
つまり、バブルソートで動作します。

1534
01:16:31,800 --> 01:16:35,210
しかし、選択ソートのために我々はしない場合
スワップを行い、それだけかもしれない

1535
01:16:35,210 --> 01:16:38,670
最も小さい値であるためです
それにその右の場所にある。

1536
01:16:38,670 --> 01:16:41,240
我々は、リスト1、2、4、3があるかもしれません。

1537
01:16:41,240 --> 01:16:42,830
我々2回目
任意のスワップをすることはありません。

1538
01:16:42,830 --> 01:16:47,260
私たちは、数2になるだろうが、我々はよ
まだ続ける必要があります。

1539
01:16:47,260 --> 01:16:49,390
だから我々は追跡するために必要なのですか
我々は終わったか、我々だけで行きたくない

1540
01:16:49,390 --> 01:16:50,640
これが終了するまで？

1541
01:16:50,640 --> 01:16:54,098

1542
01:16:54,098 --> 01:16:56,740
>> 学生：私達はちょうど行くことができます
それが終わっれるまで。

1543
01:16:56,740 --> 01:16:58,090
>> JASONハーシュホーン：我々はできるだけ
これが終了するまで移動します。

1544
01:16:58,090 --> 01:17:01,720
バブルソートでは、正確に正しいです
あなたのソリューションとジェフとAleha、 - 

1545
01:17:01,720 --> 01:17:04,990
それは追跡するために素晴らしいですどのよ​​うに多くの
スワップは、作ったので、バブル中

1546
01:17:04,990 --> 01:17:07,920
あなたが実際に行うと、ソート、ありませんがスワップを行いません
これで完了です、あなたは多分あなたのカットすることができます

1547
01:17:07,920 --> 01:17:09,000
問題ダウンビットを。

1548
01:17:09,000 --> 01:17:11,440
しかし、選択ソートのために、あなたが本当にしました
の最後まで行くようになった

1549
01:17:11,440 --> 01:17:14,940
周りのたびにリストアップ。

1550
01:17:14,940 --> 01:17:16,200
>> これはすなわち。

1551
01:17:16,200 --> 01:17:18,530
我々は左の2分している。

1552
01:17:18,530 --> 01:17:21,560
のすべてを作ってみましょう。

1553
01:17:21,560 --> 01:17:24,340
私はちょうどここで見つける開いてみましょう
必ず私が実際に呼び出すんだ - 

1554
01:17:24,340 --> 01:17:25,610
私はバブルソートを呼び出していないよ。

1555
01:17:25,610 --> 01:17:29,230
それでは選択ソートにこれを変更してみましょう。

1556
01:17:29,230 --> 01:17:31,060
すべてを作る。/見つける。

1557
01:17:31,060 --> 01:17:32,360
42を見つけるのをしてみましょう。

1558
01:17:32,360 --> 01:17:38,110
私たちは合格するつもりだこの時間
ソートされていないリストで、それは並べ替える必要があるため

1559
01:17:38,110 --> 01:17:43,790
まず、検索コードごと - 並べ替える必要があります
まず私たちのソート機能を使用し、

1560
01:17:43,790 --> 01:17:44,995
何かを探す。

1561
01:17:44,995 --> 01:17:46,245
指はすべての人を渡った。

1562
01:17:46,245 --> 01:17:48,530

1563
01:17:48,530 --> 01:17:49,370
>> 善良私のオハイオ州。

1564
01:17:49,370 --> 01:17:50,800
おっと、私の心は打ちました。

1565
01:17:50,800 --> 01:17:52,320
だから正しい。

1566
01:17:52,320 --> 01:17:57,270
実際、我々はこの多くを実行した場合
私の知る限りはできるだけ広く、コード、

1567
01:17:57,270 --> 01:17:59,280
完全に正しいことを、教えてください。

1568
01:17:59,280 --> 01:18:02,150
いくつかの提案があります
私はあなたのために持っているでしょう。

1569
01:18:02,150 --> 01:18:06,215
例えば、図15及び図16は思える
少し冗長。

1570
01:18:06,215 --> 01:18:09,450
あなたは必ずしもないようだ
両方それらを保存する必要があります。

1571
01:18:09,450 --> 01:18:12,790
あなたが最小の場所を持っている場合は、
簡単で最小値を見つけることができます

1572
01:18:12,790 --> 01:18:14,750
ちょうど私の値を入力する。

1573
01:18:14,750 --> 01:18:18,100
>> だから私はあなたのコードをグレーディングされるならば、
私は実際には、私はだろうされる

1574
01:18:18,100 --> 01:18:21,160
もしあれば、おそらくポイントを脱ぐ
あなたので、これらの両方が含まれてい

1575
01:18:21,160 --> 01:18:22,670
これらの両方は必要ありません。

1576
01:18:22,670 --> 01:18:25,400
あなたは場所を持っている場合は、次のことが可能
非常に簡単に値を取得する。

1577
01:18:25,400 --> 01:18:27,520
そして、それは少し奇妙なようだ
それらの両方を格納する。

1578
01:18:27,520 --> 01:18:31,070
多分ポイントを取ることではなく、
確かにそれは多分あるとコメント

1579
01:18:31,070 --> 01:18:32,670
いない文体の選択
あなたが確認する必要があります。

1580
01:18:32,670 --> 01:18:35,290
もちろん、コードは
完璧に動作します。

1581
01:18:35,290 --> 01:18:36,860
>> 残念ながら、私たちはしませんでした
バブルソートに着く。

1582
01:18:36,860 --> 01:18:37,940
私はそのことについて申し訳ありません。

1583
01:18:37,940 --> 01:18:39,135
私たちは、仕上げ選択ソートを行いました。

1584
01:18:39,135 --> 01:18:41,450
誰もが任意の最終的な疑問を持っていますか
選択ソートはどうでしょうか？

1585
01:18:41,450 --> 01:18:44,320

1586
01:18:44,320 --> 01:18:47,690
>> 我々は出掛ける前に[OK]を、私はあなたが欲しい
お使いのChromeブラウザを開きます。

1587
01:18:47,690 --> 01:18:54,340
申し訳ありませんが、それはただあからさまプラグだった
インターネットブラウザの1タイプの。

1588
01:18:54,340 --> 01:18:57,770
ブラウザのいずれかのタイプを開くことができ、
それはおそらくChromeのようになります。

1589
01:18:57,770 --> 01:19:01,250
そして、この次のWebサイトにアクセスし - 

1590
01:19:01,250 --> 01:19:06,410
sayat.me/cs50。

1591
01:19:06,410 --> 01:19:07,685
お使いのコンピュータに入力していない場合
今、あなたは明らかにしている

1592
01:19:07,685 --> 01:19:10,210
トム、それをやっていない。

1593
01:19:10,210 --> 01:19:12,870
>> と右のどちらかとさせて頂きます
現在または次の1時間での - 

1594
01:19:12,870 --> 01:19:14,260
私にいくつかのフィードバックを与える。

1595
01:19:14,260 --> 01:19:15,660
これは、セクション2である。

1596
01:19:15,660 --> 01:19:18,060
私たちは一緒に多くのより多くを持っているので、私
改善の余地がたくさんある。

1597
01:19:18,060 --> 01:19:19,620
私はうまくいけば、また同様にいくつかのことをしました。

1598
01:19:19,620 --> 01:19:22,160
だから、私はすべての悪い気分にさせることができますが、もし
あなたも私に笑顔を与えたい

1599
01:19:22,160 --> 01:19:24,250
顔は、私もそれをお願い申し上げます。

1600
01:19:24,250 --> 01:19:25,330
それを記入

1601
01:19:25,330 --> 01:19:28,210
>> そして1分間の左側に、
それは週3であった。

1602
01:19:28,210 --> 01:19:30,750
私は少しのために外に立ってます
ご不明な点がございましたら。

1603
01:19:30,750 --> 01:19:32,220
私はあなたたちにあるが表示されます
明日講義。

1604
01:19:32,220 --> 01:19:34,742