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

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

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

4
00:00:08,000 --> 00:00:10,000
>> すべての権利は​​、始めましょう。

5
00:00:10,000 --> 00:00:13,000
CS50の4週目へようこそ。

6
00:00:13,000 --> 00:00:19,000
君たちは、Webブラウザを開いて、PSET 3を開くと、

7
00:00:19,000 --> 00:00:23,000
CS50とスクランブル、我々は行く開始するつもりだ

8
00:00:23,000 --> 00:00:26,000
そこに質問のセクションを通る。

9
00:00:26,000 --> 00:00:32,000
ちょうど先週のように、我々は、CS50 Spacesでの作業になります

10
00:00:32,000 --> 00:00:35,000
あなたも同様にそれを引き上げてあげるなら、

11
00:00:35,000 --> 00:00:43,000
そしてあなたが先に行くと、私がトップでここまで持っていることは、このリンクを訪問した場合。

12
00:00:43,000 --> 00:00:45,000
それが始める時です。

13
00:00:45,000 --> 00:00:51,000
私たちはここで私たちの小さなハイテクのプログラムを持っている。クレイジー何もない。

14
00:00:51,000 --> 00:00:55,000
私は今日皆さんに最初にしたいことの一つは、いくつかの解決策を越えるです

15
00:00:55,000 --> 00:00:58,000
問題セット1、例ソリューションの種類に

16
00:00:58,000 --> 00:01:03,000
ちょうどそうあなたが書いているコードのスタッフのどのような種類の感触を得ることができます

17
00:01:03,000 --> 00:01:07,000
コー​​ドは、他の学生の種類が書いているのか、

18
00:01:07,000 --> 00:01:10,000
私はそれは奇妙なことだと知っているので、持っているあなたはそれを見てみましょう

19
00:01:10,000 --> 00:01:14,000
あなたは、問題のセットに解決策を提出して、コメントを取得するとき

20
00:01:14,000 --> 00:01:18,000
独自のバージョンで、時にはそれが、他の人がやった方法を参照すると便利です

21
00:01:18,000 --> 00:01:22,000
見ていいです特にもの。

22
00:01:22,000 --> 00:01:27,000
ほとんどの部分については、私は本当にあなたたちが製作したソリューションに感銘を受けました。

23
00:01:27,000 --> 00:01:31,000
、私はまだあなたの問題セット2Sを見始めていませんが、彼らは最初のようなものなら

24
00:01:31,000 --> 00:01:34,000
それは何も良いことを意味しません。

25
00:01:34,000 --> 00:01:40,000
>> あなたは私のリビジョンを見れば、リビジョン1にすべての方法を開始してみましょう、

26
00:01:40,000 --> 00:01:47,000
そして我々はマリオ·ソリューションを簡単に見ていくつもりです。

27
00:01:47,000 --> 00:01:54,000
このプルアップした場合、我々が提示しようとしているこれらのプログラムが正しいことを確認します。

28
00:01:54,000 --> 00:01:56,000
、そこにこれらの問題を持つ正当性の問題はありませんでしたが、むしろ

29
00:01:56,000 --> 00:01:59,000
我々はさまざまな設計上の問題について少しお話したいと思います

30
00:01:59,000 --> 00:02:03,000
その方法はここでは使用されていた。

31
00:02:03,000 --> 00:02:08,000
ソリューションについて興味深かったことの一つ

32
00:02:08,000 --> 00:02:11,000
、それは定義ポンドと呼ばれるこの新しい構文を使用したことである

33
00:02:11,000 --> 00:02:15,000
時にはまた、ハッシュは定義と呼ばれます。

34
00:02:15,000 --> 00:02:18,000
私はここでそれにズームインすることができます。

35
00:02:18,000 --> 00:02:24,000
＃defineをあなたのプログラムにこれらの番号に名前を付けることができます。

36
00:02:24,000 --> 00:02:28,000
マリオのピラミッドのこのケースでは、最大の高さ

37
00:02:28,000 --> 00:02:34,000
23というよりは、私には23を入れていたコード

38
00:02:34,000 --> 00:02:37,000
我々は、ハードコーディング23としてその参照することになり - 

39
00:02:37,000 --> 00:02:43,000
代わりに、これは、その数に名前MAX_HEIGHTを与える

40
00:02:43,000 --> 00:02:48,000
ので、ダウンここに私の中でdo-whil​​eループ

41
00:02:48,000 --> 00:02:51,000
あなたが実際にMAX_HEIGHTを参照することができます

42
00:02:51,000 --> 00:02:55,000
数字の代わりに23インチ入れて

43
00:02:55,000 --> 00:02:57,000
[学生]ということの利点は何ですか？

44
00:02:57,000 --> 00:02:59,000
それは素晴らしい質問です。

45
00:02:59,000 --> 00:03:03,000
一つは、読みやすさです。

46
00:03:03,000 --> 00:03:08,000
これは＃defineを使用することの利点は、読みやすさです。

47
00:03:08,000 --> 00:03:11,000
私はこのコードを読んでいるとき、私は何が起こっているかを見ることができます。

48
00:03:11,000 --> 00:03:15,000
>> 私は我々がテストしていることをここでは、この状態で見ることができます

49
00:03:15,000 --> 00:03:19,000
高さのため、我々はまた、定義されている可能性が<0であること

50
00:03:19,000 --> 00:03:22,000
高さの最小値または最小の高さであること。

51
00:03:22,000 --> 00:03:25,000
他の利点は、私がして見て行の残りの部分を読むことができるということです

52
00:03:25,000 --> 00:03:30,000
我々はまた、高さが最大高さを超えていないことを確認するためにチェックしていること

53
00:03:30,000 --> 00:03:35,000
私たちは高さが最大高さよりも大きいながら続けていくつもりですので。

54
00:03:35,000 --> 00:03:40,000
他の利点は、場合、私は少しズームアウトヒア

55
00:03:40,000 --> 00:03:49,000
私はこのプログラムを実行し、私は、今23と、言って、それを実行する場合

56
00:03:49,000 --> 00:03:52,000
それはちょうどそのように、すべての23行を出力します。

57
00:03:52,000 --> 00:03:54,000
しかし、私は最大の高さを変更したいとしよう。

58
00:03:54,000 --> 00:03:57,000
そして今、私はピラミッドの高さの最大値を制限したい

59
00:03:57,000 --> 00:04:06,000
ファンキーだっただけと言う人で、することができます。

60
00:04:06,000 --> 00:04:14,000
＃<stdio.h>を含む、＃、MAX_HEIGHT定義

61
00:04:14,000 --> 00:04:18,000
としてみましょう、我々は10に等しいそれを設定したいとしましょう​​。

62
00:04:18,000 --> 00:04:22,000
今、この時点で、私がしなければならなかったすべてはこの1場所でそれを変更しました。

63
00:04:22,000 --> 00:04:27,000
私は、コードを再コンパイルして、今私がしようとした場合、12を入力することができます

64
00:04:27,000 --> 00:04:30,000
それが再び私を求めるプロンプトが表示されます。

65
00:04:30,000 --> 00:04:33,000
この場合において、我々は一度だけMAX_HEIGHTを使用しています。

66
00:04:33,000 --> 00:04:37,000
それはに行く手間の大ではありません

67
00:04:37,000 --> 00:04:40,000
あなたがする必要がある場合、whileループでそれを変更してください。

68
00:04:40,000 --> 00:04:44,000
しかし、あなたが同じマジックナンバーを参照しているプログラムで

69
00:04:44,000 --> 00:04:47,000
何度も何度も、これは＃メカニズムを定義すると、本当に便利です

70
00:04:47,000 --> 00:04:52,000
あなただけの一番上にそれを1つの時刻を変更するためのファイル、それはあなたがそれらをどこに置いたか、典型的だ

71
00:04:52,000 --> 00:04:57,000
及び変更は、ファイルの残りの部分を通って浸透し。

72
00:04:57,000 --> 00:05:02,000
>> 私は思った、この割当てに注意したかった他のものは、本当にいい感じ

73
00:05:02,000 --> 00:05:05,000
1は、変数の命名だった。

74
00:05:05,000 --> 00:05:14,000
あなたは、私たちは、行と高さと呼ばれるいわゆる整数型の変数を持っていることはここを参照してください。

75
00:05:14,000 --> 00:05:20,000
スペース、ハッシュ、それは、コードがもう少し読みやすく

76
00:05:20,000 --> 00:05:25,000
実際に何が起こっているのか、もう少し理解ができます。

77
00:05:25,000 --> 00:05:31,000
これは、使用して対照的である、ランダムな文字列になって言う

78
00:05:31,000 --> 00:05:35,000
完全にまたは単に無意味な言葉。

79
00:05:35,000 --> 00:05:39,000
私が指摘しておき最終的なものでは、forループ内のことです

80
00:05:39,000 --> 00:05:45,000
しばしば、これらの反復子変数は、forループを自分で使用するこれらのカウンタ、

81
00:05:45,000 --> 00:05:51,000
それは私、次に次にjとkのいずれかでそれらを開始するために、標準と従来の

82
00:05:51,000 --> 00:05:54,000
そしてあなたがより多くの変数が必要な場合は、そこから上に行く、

83
00:05:54,000 --> 00:05:56,000
そして、これはただの慣習です。

84
00:05:56,000 --> 00:05:58,000
規則がたくさんあり​​ます。

85
00:05:58,000 --> 00:06:00,000
それはあなたが使用しているプログラミング言語に依存します。

86
00:06:00,000 --> 00:06:04,000
しかし、C言語では、我々は通常、Iで始まる。

87
00:06:04,000 --> 00:06:08,000
それは、aまたはbと言う、使用しても意味がありません

88
00:06:08,000 --> 00:06:13,000
状況に応じて。

89
00:06:13,000 --> 00:06:15,000
それはこの1つのことです。

90
00:06:15,000 --> 00:06:25,000
あなたは今リビジョン2をプルアップした場合は、別のマリオが表示されます

91
00:06:25,000 --> 00:06:29,000
そしてこの1つは、我々だけで見たことを他のものと似ています

92
00:06:29,000 --> 00:06:32,000
それはクールなの何か一種を行います。

93
00:06:32,000 --> 00:06:38,000
我々は、内側のforループの内側で右ここにこのセクションを見れば、

94
00:06:38,000 --> 00:06:44,000
彼らは右のこの行で、ここでいくつかのクレイジー探しの構文を使用しています。

95
00:06:44,000 --> 00:06:47,000
これは、三項演算子と呼ばれています。

96
00:06:47,000 --> 00:06:53,000
それは1つの行に凝縮IF ELSEステートメントです。

97
00:06:53,000 --> 00:06:57,000
条件は括弧内のこの部分です。

98
00:06:57,000 --> 00:07:05,000
I  -  1  - それは、j <高さと言っている場合と同等です。

99
00:07:05,000 --> 00:07:10,000
し、その内容ブロックがあるならば、スペースは何です

100
00:07:10,000 --> 00:07:16,000
そして次に何か他の内容は、＃このアールであろう。

101
00:07:16,000 --> 00:07:20,000
それは本質的には、この変数に領域を割り当てている。

102
00:07:20,000 --> 00:07:24,000
それは、ブロック変数の内容にスペースを入れている

103
00:07:24,000 --> 00:07:29,000
この条件が満たされた場合、条件が満たされない場合は、

104
00:07:29,000 --> 00:07:32,000
その後ブロック変数は＃これを取得します。

105
00:07:32,000 --> 00:07:37,000
そして、もちろん、その代わりに、文字列全体を造り上げる

106
00:07:37,000 --> 00:07:43,000
時と終了時にすべてのものをプリントアウトし、このソリューションでは、一度に1つの文字を、それをプリントアウトします。

107
00:07:43,000 --> 00:07:48,000
かなりクール。

108
00:07:48,000 --> 00:07:53,000
>> 見て物事の別のカップル。私たちは、貪欲へと移っていきます。

109
00:07:53,000 --> 00:07:58,000
今、私たちは、貪欲、この最初の解を見れば

110
00:07:58,000 --> 00:08:00,000
＃かなりの定義これらを使用しています。

111
00:08:00,000 --> 00:08:06,000
我々は、このプログラムでは異なる番号ごとに定義された定数1を持っている。

112
00:08:06,000 --> 00:08:12,000
我々は、ドル当たり1セントのため、四半期、ダイム、ニッケル、そしてペニーのための1つを持っている

113
00:08:12,000 --> 00:08:15,000
そして今我々は、下にスクロールしてコードを読み取る場合

114
00:08:15,000 --> 00:08:22,000
我々は、標準は、do-whil​​eループの印刷すべてを見ることができます。

115
00:08:22,000 --> 00:08:25,000
この問題の核心の種類があることを実現しました

116
00:08:25,000 --> 00:08:29,000
あなたは整数にユーザからで読んだフロートを変換するために必要な

117
00:08:29,000 --> 00:08:32,000
正確に計算を行う、これがためであるために

118
00:08:32,000 --> 00:08:36,000
浮動小数点数を持つ、我々は簡単に講義で話しように、

119
00:08:36,000 --> 00:08:41,000
それは正確に数直線上のすべての単一値を表すことはできません

120
00:08:41,000 --> 00:08:47,000
3の間と言う、多くの値が3.1であっても無限に存在するからである。

121
00:08:47,000 --> 00:08:54,000
あなたは、3.01と3.001と3.0001を持つことができ、あなたは続けることができます。

122
00:08:54,000 --> 00:09:00,000
あなたがお金で作業しているときはいつも、それは結局のところ、あなたは、多くの場合、それを変換したい

123
00:09:00,000 --> 00:09:05,000
整数フォーマットになるようにあなたは小銭やもののようなものを失っていない。

124
00:09:05,000 --> 00:09:09,000
ことをやって、丸め処理が鍵であった。

125
00:09:09,000 --> 00:09:14,000
このソリューションは、完全に単純な、偉大なアルゴリズムを使用

126
00:09:14,000 --> 00:09:17,000
これは、第1四半期では、残りのセントの数をデクリメント

127
00:09:17,000 --> 00:09:19,000
次にダイムで、その後硬貨によって、その後ペニーによって、

128
00:09:19,000 --> 00:09:24,000
とコインの数に毎回追加。

129
00:09:24,000 --> 00:09:31,000
>> 私はズームアウトしてリビジョン4に行くと我々は、表示されますことを、別の解決策、

130
00:09:31,000 --> 00:09:40,000
非常に類似し始めていたが、代わりにdivとmodを使用

131
00:09:40,000 --> 00:09:44,000
右こっちセントの数を計算することができます。

132
00:09:44,000 --> 00:09:50,000
これは、四半期の数は、25で割ったセントの数に等しくなります

133
00:09:50,000 --> 00:09:53,000
我々は整数の除算をやっているので、これが動作する理由は、ある

134
00:09:53,000 --> 00:09:58,000
ので、それはすべて破棄し、残りです。

135
00:09:58,000 --> 00:10:02,000
[学生]我々は、検索をコメントする必要がありますか？

136
00:10:02,000 --> 00:10:05,000
それは本当に異なります。

137
00:10:05,000 --> 00:10:08,000
[学生]あなたはちょうどここにコードよりもコメントしている。

138
00:10:08,000 --> 00:10:16,000
うん、そう、これに哲学を変えるの束があります。

139
00:10:16,000 --> 00:10:21,000
私の個人的な哲学は、あなたのコードは本当に真実であるということです

140
00:10:21,000 --> 00:10:24,000
あなたのコードのように、実際にコンピュータ上で実行されるものです

141
00:10:24,000 --> 00:10:29,000
ので、あなたのコードは、多くのコメントとして必要としないためにできるだけ読み取り可能でなければなりません。

142
00:10:29,000 --> 00:10:33,000
あなたが数学的にトリッキーなの一種であることをやっているときに、そうは言っても

143
00:10:33,000 --> 00:10:38,000
あなたができるように、またはアルゴリズム、それはそれらのコメントは良いことだ

144
00:10:38,000 --> 00:10:43,000
あなたのコードを読んでいる人には誰に余分な次元、余分なレイヤを追加します。

145
00:10:43,000 --> 00:10:49,000
これらのソリューションには、多くの場合、それらは、より重く理由だけでコメントアウトされています

146
00:10:49,000 --> 00:10:52,000
我々はそれらを配布できるようにしたいと人々がそれらをピックアップしている

147
00:10:52,000 --> 00:10:56,000
とかなり簡単にそれらを読んでください。

148
00:10:56,000 --> 00:11:05,000
しかし、間違いなく、私はこれが重いということに同意するだろう。

149
00:11:05,000 --> 00:11:07,000
[学生]しかし、疑問がある場合は、重い行くとき？

150
00:11:07,000 --> 00:11:10,000
疑問がある場合は、重い行く。

151
00:11:10,000 --> 00:11:17,000
一部の人々は時々、戻り0またはそのような何かを言うだろう。

152
00:11:17,000 --> 00:11:20,000
私はばかげたコメントだと思う。

153
00:11:20,000 --> 00:11:22,000
明らかにすることは、何が起こっているかだ。

154
00:11:22,000 --> 00:11:25,000
私は私をことを伝えるために英語は必要ありません。

155
00:11:25,000 --> 00:11:28,000
時には人々のようなものを書きます "kthxbaiを！"

156
00:11:28,000 --> 00:11:32,000
それがかわいいのようなものだが、また非

157
00:11:32,000 --> 00:11:35,000
それはコメントのポイントかどうかの違いを作ることはない。

158
00:11:35,000 --> 00:11:41,000
これらの種類のコメントがちょうどヘクタール、ヘクタールです。

159
00:11:41,000 --> 00:11:43,000
クール。

160
00:11:43,000 --> 00:11:48,000
>> この時点で、質問の3セクションを設定して問題に取り組んでみましょう。

161
00:11:48,000 --> 00:11:52,000
君たちは再びこれをプルアップした場合、

162
00:11:52,000 --> 00:11:55,000
先週と同じように、私たちはこのセクションでショートパンツを見に行くわけではありません。

163
00:11:55,000 --> 00:12:00,000
私たちは、あなたたちは自分の時間にそれをやらせると質問について話します。

164
00:12:00,000 --> 00:12:05,000
しかし今、このセクションで、私たちは少しより多くの時間を過ごすつもりだ

165
00:12:05,000 --> 00:12:11,000
コー​​ディングの基礎未満の話

166
00:12:11,000 --> 00:12:15,000
我々は先週やったように、その代わりに、我々はに集中するつもりだ

167
00:12:15,000 --> 00:12:22,000
理論のもう少しなので、二分探索の話をしてから、並べ替え。

168
00:12:22,000 --> 00:12:27,000
講義と一緒に従ってきたあなたの人々から、

169
00:12:27,000 --> 00:12:30,000
誰かが私に違いはあるものの要約を与えることができます

170
00:12:30,000 --> 00:12:35,000
二分探索と線形探索の間に？

171
00:12:35,000 --> 00:12:37,000
どうなってるの？かしこまりました。

172
00:12:37,000 --> 00:12:42,000
ソートされたリスト内のすべての要素を通して線形探索検索

173
00:12:42,000 --> 00:12:45,000
一つ一つによって一つずつ、

174
00:12:45,000 --> 00:12:50,000
とバイナリ検索では、2つのグループにリストを分割

175
00:12:50,000 --> 00:12:57,000
チェックあなたが探していることをキー値より大きいか、または中間値未満である場合

176
00:12:57,000 --> 00:13:00,000
あなただけの発見、そしてそれはより小さいなら、それは下のリストに行くこと

177
00:13:00,000 --> 00:13:03,000
そして、その後、再び、同じ機能を行うことを分割

178
00:13:03,000 --> 00:13:07,000
ずっとダウンして値自体に等しくなるように中間点を見つけるまで。

179
00:13:07,000 --> 00:13:10,000
右。

180
00:13:10,000 --> 00:13:12,000
>> なぜ我々は気にしない？

181
00:13:12,000 --> 00:13:20,000
なぜ我々はバイナリ検索対線形探索について話しますか？

182
00:13:20,000 --> 00:13:22,000
うん。

183
00:13:22,000 --> 00:13:24,000
バイナリは、問題のサイズを倍にそうだとすれば、はるかに高速である

184
00:13:24,000 --> 00:13:27,000
それはもう一歩ではなく、倍の数をとります。

185
00:13:27,000 --> 00:13:29,000
その通りです。

186
00:13:29,000 --> 00:13:31,000
それは素晴らしい答えだ。

187
00:13:31,000 --> 00:13:36,000
線形探索は非常に多く、一度に1つの要素をチェックしている

188
00:13:36,000 --> 00:13:39,000
そして我々は講演の非常に最初の日に見たように

189
00:13:39,000 --> 00:13:42,000
ダビデは、電話帳の例を挙げて行ったとき

190
00:13:42,000 --> 00:13:45,000
と一度電話帳の1ページをごリッピング

191
00:13:45,000 --> 00:13:47,000
と、何度も何度も何度もそれをやり続け

192
00:13:47,000 --> 00:13:51,000
それは、彼に電話帳の誰かを見つけるには本当に長い時間がかかるために起こっている

193
00:13:51,000 --> 00:13:55,000
もちろん、しない限り、彼はアルファベットの冒頭に誰かを探していました。

194
00:13:55,000 --> 00:14:00,000
バイナリ検索を使用すると、かなり速く行くことができます

195
00:14:00,000 --> 00:14:05,000
そしてそれはちょうど2倍の速または3倍速いか4倍の速さほどではありません。

196
00:14:05,000 --> 00:14:13,000
しかし、問題はより小さく、より小さく、より速くはるかに小さくなります。

197
00:14:13,000 --> 00:14:17,000
これを説明するために、我々は何が起こっているかについて話し始めるよ

198
00:14:17,000 --> 00:14:21,000
我々はバイナリサーチを書くとき。

199
00:14:21,000 --> 00:14:27,000
当面の問題は、私は数字の配列を持っている場合ということです

200
00:14:27,000 --> 00:14:40,000
発言、1、2、3、5、7、23、45、78、12323、

201
00:14:40,000 --> 00:14:47,000
それ以降0のトンと、その後9日

202
00:14:47,000 --> 00:14:52,000
中に何があるか、私たちは本当に迅速に把握することができるようにしたい

203
00:14:52,000 --> 00:14:57,000
この数値の配列。

204
00:14:57,000 --> 00:15:00,000
私は、これはちょっとアホと少し不自然なようだ知っている

205
00:15:00,000 --> 00:15:02,000
今それがあるためです。

206
00:15:02,000 --> 00:15:05,000
我々は、その中に非常に多くの要素を持っていない配列を持っている

207
00:15:05,000 --> 00:15:08,000
と私はあなたのいずれかを頼むかどうかを把握するかどうか

208
00:15:08,000 --> 00:15:11,000
23が配列されている、あなたはかなり迅速にそれを行うことができる

209
00:15:11,000 --> 00:15:16,000
ただこれをちらっと見てと、yesまたはnoを私に言っていないで。

210
00:15:16,000 --> 00:15:20,000
これがあったかを検討するために、アナログは、言う、想像されている

211
00:15:20,000 --> 00:15:27,000
10,000行、20,000行を使用してExcelスプレッドシート。

212
00:15:27,000 --> 00:15:31,000
もちろん、あなたがコマンドFまたはコントロールFを実行して、何かを調べることができます。

213
00:15:31,000 --> 00:15:33,000
また、フィルタと検索のものを使用することができます

214
00:15:33,000 --> 00:15:37,000
しかし、あなたはライン毎にすることによって、そのファイルの行に目を通す必要があった場合、

215
00:15:37,000 --> 00:15:40,000
それはそれを見つけるためにあなたに長い時間がかかるだろう。

216
00:15:40,000 --> 00:15:42,000
それは、あまりにも、電話帳の例のような種類の場所だ

217
00:15:42,000 --> 00:15:44,000
誰もが一度電話帳1ページに目を通していません。

218
00:15:44,000 --> 00:15:47,000
通常、これらは、中央にそれを開くか

219
00:15:47,000 --> 00:15:50,000
または電話帳や辞書の多くの場合には

220
00:15:50,000 --> 00:15:54,000
あなたが実際にそれは、最初の文字をキーにしています

221
00:15:54,000 --> 00:16:01,000
あなたはその最初の文字を反転させると開いて、そこを通過し始める。

222
00:16:01,000 --> 00:16:03,000
>> もう一度お名前を思い出します。>>サムが。

223
00:16:03,000 --> 00:16:05,000
サム。

224
00:16:05,000 --> 00:16:11,000
サムが言ったように、その線形探索プロセスは、非常に遅くなるだろう

225
00:16:11,000 --> 00:16:15,000
そして代わりに、バイナリ検索で、この作品の方法は、つまり

226
00:16:15,000 --> 00:16:21,000
我々は探索アルゴリズムの繰り返しで行くたびに、

227
00:16:21,000 --> 00:16:27,000
我々は、本質的に、半分にリストを分割するつもりだ

228
00:16:27,000 --> 00:16:33,000
2、小さいリストに。

229
00:16:33,000 --> 00:16:39,000
そして、ループの次の反復では、我々は再びそれを分割します

230
00:16:39,000 --> 00:16:44,000
他の小さいリストに。

231
00:16:44,000 --> 00:16:48,000
あなたが見ることができるように、問題は小さくなり続け

232
00:16:48,000 --> 00:16:55,000
私たちは、毎回リストの破棄半分を保つためです。

233
00:16:55,000 --> 00:16:59,000
これはどのように作業を破棄しますか？

234
00:16:59,000 --> 00:17:05,000
我々はコンピュータだったらちょうどメモとして、私たちは何やろうとしている

235
00:17:05,000 --> 00:17:11,000
そして我々は、このリスト内の5番を探して、言うた

236
00:17:11,000 --> 00:17:15,000
私たちは真ん中の数字を選ぶだろうということです。

237
00:17:15,000 --> 00:17:26,000
このリストの途中で、1、2、3、4、5、6、7、8、9、10の数字は、あるので、

238
00:17:26,000 --> 00:17:32,000
我々は、第四の位置または5位のいずれかで数字を選ぶだろう

239
00:17:32,000 --> 00:17:38,000
そして私達は私達のリストの中間という呼びたい。

240
00:17:38,000 --> 00:17:42,000
途中で数字を選ぶ。

241
00:17:42,000 --> 00:17:51,000
その数が等しい場合はその後、サムが言ったように、我々は見てテストします

242
00:17:51,000 --> 00:17:59,000
我々が取得したい番号または私達の希望の番号に変更します。

243
00:17:59,000 --> 00:18:06,000
それは平等だなら、私たちはそれを見つけた。我々は勝つ。

244
00:18:06,000 --> 00:18:12,000
それが等しくない場合は、例がいくつかあります。

245
00:18:12,000 --> 00:18:15,000
2例はいずれかである数は、我々が見ている数よりも大きくなければならない、

246
00:18:15,000 --> 00:18:19,000
またはそれはより小さいです。

247
00:18:19,000 --> 00:18:25,000
それがより大きいのであれば、我々は右に移動します。

248
00:18:25,000 --> 00:18:33,000
それが少ないのなら、私達は左に移動します。

249
00:18:33,000 --> 00:18:41,000
そして、我々は再び、全体のプロセスを繰り返す

250
00:18:41,000 --> 00:18:48,000
右半分またはリストの左半分のどちらかで。

251
00:18:48,000 --> 00:18:51,000
>> 今日のセクションの最初の問題は把握することです

252
00:18:51,000 --> 00:18:55,000
どのように我々は、実際にはCコードでこれを表現するために始めることができます。

253
00:18:55,000 --> 00:18:58,000
我々はここで擬似コードを持っている。

254
00:18:58,000 --> 00:19:04,000
である我々がやって始めましょう私は、真新しい空間を引き上げます

255
00:19:04,000 --> 00:19:09,000
私たちは後でこれらのノートを持っているように、このリビジョンを保存

256
00:19:09,000 --> 00:19:20,000
我々は、このすべてを削除してから、コピーして、問題セットから貼り付けます

257
00:19:20,000 --> 00:19:26,000
私達のスペースにこの情報が、うまくいけば、これはブレークしません。

258
00:19:26,000 --> 00:19:28,000
パーフェクト。

259
00:19:28,000 --> 00:19:33,000
あなたたちはすべてのことを行う場合、あなたの新しい空間にこのコードをコピーして貼り付ける

260
00:19:33,000 --> 00:19:43,000
空白の1に。

261
00:19:43,000 --> 00:19:47,000
ダニエルを試してみましょう。あなたがこのプログラムをコンパイルして実行する場合、それは動作しますか？

262
00:19:47,000 --> 00:19:49,000
いいえ>>それは何を言ってるの？

263
00:19:49,000 --> 00:19:53,000
それは、コントロールが非void関数の終りに到達したと言います。

264
00:19:53,000 --> 00:19:55,000
ええ、そう私はそれを実行してみましょう。

265
00:19:55,000 --> 00:19:59,000
君たちは前にこれを見たことがありますか？あなたは、これが何を意味するか知っていますか？

266
00:19:59,000 --> 00:20:01,000
さて、のはこの少しを解剖しましょう​​。

267
00:20:01,000 --> 00:20:10,000
それは、あなたが言ったのと同じように、1列目は、我々はエラーを持って、9行目でfile.cを言っている

268
00:20:10,000 --> 00:20:16,000
そしてそれは、エラー、警告および戻り値の型の警告に由来だという。

269
00:20:16,000 --> 00:20:18,000
何かが理にかなっている戻り値の型、で何が行われているように見えます。

270
00:20:18,000 --> 00:20:21,000
我々は、非void関数を持っている、それは我々が機能を持っていることを意味します

271
00:20:21,000 --> 00:20:24,000
それは、voidを返すことはありません。

272
00:20:24,000 --> 00:20:27,000
void関数は次のように見えるものです：

273
00:20:27,000 --> 00:20:35,000
ます。void foo（）、および戻り値の型がvoidであるため、それはvoidですが、

274
00:20:35,000 --> 00:20:38,000
これはつまり、我々はここで何かを持っていた場合

275
00:20:38,000 --> 00:20:45,000
1を返すように、我々はこのためのコンパイラエラーを取得したい。

276
00:20:45,000 --> 00:20:49,000
しかし、我々は非void関数を持っています。

277
00:20:49,000 --> 00:20:51,000
この場合の当社の非void関数は、Googleの検索機能です

278
00:20:51,000 --> 00:20:56,000
それはブール値の戻り値の型を持っているためです。

279
00:20:56,000 --> 00:20:59,000
それは、コントロールが非void関数の終りに到達したことを言っているときは、

280
00:20:59,000 --> 00:21:02,000
検索は、return文を持っていないため、それは。

281
00:21:02,000 --> 00:21:04,000
それは、bool型の何かを返すわけではありません。

282
00:21:04,000 --> 00:21:09,000
>> 我々はそれを修正することができます、そしてあなたたちはどう思いますか

283
00:21:09,000 --> 00:21:13,000
検索はデフォルトで返すべきでしょうか？

284
00:21:13,000 --> 00:21:16,000
何が検索のデフォルトの戻り値である必要があります？

285
00:21:16,000 --> 00:21:19,000
それは我々が終わりに置くことができるものだからです。

286
00:21:19,000 --> 00:21:21,000
シャーロットは、次のものがない任意の - ？

287
00:21:21,000 --> 00:21:23,000
trueまたはfalse？>> trueまたはfalse。

288
00:21:23,000 --> 00:21:26,000
どれ？

289
00:21:26,000 --> 00:21:28,000
falseを指定します。知りません。

290
00:21:28,000 --> 00:21:30,000
偽？それを試してみましょう。

291
00:21:30,000 --> 00:21:32,000
なぜあなたは、falseを返すと思いますか？それは素晴らしい直感だ。

292
00:21:32,000 --> 00:21:35,000
[シャルロット]私は知らない。

293
00:21:35,000 --> 00:21:39,000
我々は、これが私たちのデフォルトになりますので、この場合にはfalseを返すつもりだ

294
00:21:39,000 --> 00:21:44,000
何らかの理由でリストが空であるか、針の場合

295
00:21:44,000 --> 00:21:46,000
我々が探していることは存在しません。

296
00:21:46,000 --> 00:21:50,000
それから一番最後に、我々は以前、この関数でtrueを返していない場合、

297
00:21:50,000 --> 00:21:55,000
私たちは常にこの関数はいや、それが配列ではないと言うことを知っている。

298
00:21:55,000 --> 00:21:58,000
それは干し草の山ではありません。

299
00:21:58,000 --> 00:22:03,000
我々はコンパイルして実行する場合、今我々はそれをプルアップすることができますので、私はこれを保存するには、-letが。

300
00:22:03,000 --> 00:22:08,000
我々は我々のプログラムをコンパイルして実行する場合、今、それが構築されています。

301
00:22:08,000 --> 00:22:12,000
私たちは、私たちの小さなプロンプトが表示されました。

302
00:22:12,000 --> 00:22:20,000
私がヒットした場合、4  - おっと。

303
00:22:20,000 --> 00:22:25,000
それは何かをプリントアウトしませんでした。すべてが正常に終了したように見えます。

304
00:22:25,000 --> 00:22:35,000
我々はこれを記入するんだ

305
00:22:35,000 --> 00:22:39,000
私たちは、少し前に擬似コードでアルゴリズムについて話しました。

306
00:22:39,000 --> 00:22:44,000
どれどれ、これを保存する

307
00:22:44,000 --> 00:22:49,000
そして私は再びそのアルゴリズムをプルアップします。

308
00:22:49,000 --> 00:22:51,000
この男を襲ってみましょう。いや。

309
00:22:51,000 --> 00:22:58,000
そこにそれがある。

310
00:22:58,000 --> 00:23:03,000
どのように我々はこれを行うのですか？

311
00:23:03,000 --> 00:23:11,000
何がこのコードをオフに開始するための良い戦略でしょうか？

312
00:23:11,000 --> 00:23:16,000
あなたが途中で番号を選択する必要があります。

313
00:23:16,000 --> 00:23:23,000
どのように我々は、配列の途中で数字を選ぶのですか？

314
00:23:23,000 --> 00:23:25,000
任意の提案ですか？

315
00:23:25,000 --> 00:23:27,000
[生徒] 2で割っstrlenを。

316
00:23:27,000 --> 00:23:32,000
strlenは、2で割ったものである。それは素晴らしいものだ。

317
00:23:32,000 --> 00:23:35,000
配列の特別な種類のstrlenの作品。

318
00:23:35,000 --> 00:23:38,000
配列のどのような種類？

319
00:23:38,000 --> 00:23:44,000
文字列配列、文字配列。

320
00:23:44,000 --> 00:23:48,000
それは、我々が適用することをコンセプトと同じようなものだ

321
00:23:48,000 --> 00:23:52,000
我々は文字の配列を持っていないので、私たちはstrlenを使用することはできません。

322
00:23:52,000 --> 00:23:55,000
我々は、intの配列を持っている。

323
00:23:55,000 --> 00:23:58,000
しかし、strlenは、私たちのために何を得るのでしょうか？

324
00:23:58,000 --> 00:24:01,000
あなたはそれが私たちのためになるか知っていますか？

325
00:24:01,000 --> 00:24:03,000
[学生] strlenは、私たちに長さを取得します。

326
00:24:03,000 --> 00:24:05,000
まさに、それが我々の長さを取得します。

327
00:24:05,000 --> 00:24:09,000
strlenは、私たちのために、配列の長さを取得します。

328
00:24:09,000 --> 00:24:14,000
>> どのように我々は我々のバイナリ検索プログラムでそれを取得するのですか？

329
00:24:14,000 --> 00:24:18,000
どのように配列の長さになるだろう？

330
00:24:18,000 --> 00:24:20,000
[学生] STRLEN？

331
00:24:20,000 --> 00:24:25,000
あなたはstrlenで正しくフォーマットされたC文字列の配列の長さを取得することができます。

332
00:24:25,000 --> 00:24:31,000
問題は、しかし、我々は文字列配列を持っていないということです。

333
00:24:31,000 --> 00:24:36,000
私たちはこのコードを振り返ってみると、我々は、この整数の配列を持っています。

334
00:24:36,000 --> 00:24:38,000
どのように我々はそれがどのくらい知っていますか？

335
00:24:38,000 --> 00:24:44,000
[学生]はint型リットルまたは何かのように、エンドポイントのためにそこに相当するものか？

336
00:24:44,000 --> 00:24:49,000
これは、実際には存在しないと判明、などの方法で、これは

337
00:24:49,000 --> 00:24:52,000
C言語について知っておくだけで良いものの一つ、

338
00:24:52,000 --> 00:24:57,000
配列の長さを取得する方法はありませんことを

339
00:24:57,000 --> 00:24:59,000
私はあなたを与えるすべてが配列である場合。

340
00:24:59,000 --> 00:25:02,000
それが文字列で動作理由、理由はstrlen作品、

341
00:25:02,000 --> 00:25:06,000
ある文字列が正しくフォーマットされている場合があるため、

342
00:25:06,000 --> 00:25:12,000
それが最後の最後で、その特別な\ 0文字を持つことになります。

343
00:25:12,000 --> 00:25:16,000
>> あなたが不適切にフォーマットされた文字列を持っている場合も、想像することができます

344
00:25:16,000 --> 00:25:20,000
ず、\ 0文字がありませんし、全部が動作しません。

345
00:25:20,000 --> 00:25:22,000
[学生]あなたは '\ 0'を追加できますか？

346
00:25:22,000 --> 00:25:24,000
我々は、このケースでは可能性があります。

347
00:25:24,000 --> 00:25:29,000
我々は\ 0のいくつかの並べ替えを追加することができます

348
00:25:29,000 --> 00:25:33,000
またはその文字を意味するとのいくつかの並べ替えは、それを使用して下さい。

349
00:25:33,000 --> 00:25:36,000
しかし、それは非常に仕事に行くのではない

350
00:25:36,000 --> 00:25:40,000
\ 0はchar型を対象としているため、

351
00:25:40,000 --> 00:25:43,000
そしてここでは、intを持っている。

352
00:25:43,000 --> 00:25:46,000
我々は特別な値を使用した場合、他の事はある

353
00:25:46,000 --> 00:25:49,000
-1のように、配列の末尾をマークする

354
00:25:49,000 --> 00:25:54,000
その後、我々は我々の整数配列に-1を格納することができませんでした。

355
00:25:54,000 --> 00:25:56,000
私たちは身動きが取れないと思います。

356
00:25:56,000 --> 00:26:00,000
それは、長さを取得する唯一の方法が判明

357
00:26:00,000 --> 00:26:03,000
Cの配列の実際にそれを覚えている

358
00:26:03,000 --> 00:26:08,000
あなたはそれを設定し、配列を使って周りに渡すとき

359
00:26:08,000 --> 00:26:14,000
ので、私はいくつかの作業を行うために起こっている機能を持っているときはいつでも

360
00:26:14,000 --> 00:26:18,000
整数や浮動小数点の配列上またはダブルスまたは何を持っている、

361
00:26:18,000 --> 00:26:22,000
私はまた、関数に配列の長さを与える必要がある

362
00:26:22,000 --> 00:26:26,000
そしてそれは我々が検索機能でここにやったことがまさにそれだ。

363
00:26:26,000 --> 00:26:30,000
あなたは私たちがここで我々の配列を渡すときに我々は、何をやったか、見てみると

364
00:26:30,000 --> 00:26:36,000
我々はまた、長さ、サイズを渡します。

365
00:26:36,000 --> 00:26:41,000
それはちょうど、私たちがここでは、この変数を求めていることが起こる

366
00:26:41,000 --> 00:26:43,000
このパラメーターまたは引数。

367
00:26:43,000 --> 00:26:46,000
これは、関数の引数リストまたはパラメータ·リストと呼ばれ、

368
00:26:46,000 --> 00:26:51,000
これらはまた、引数またはパラメータと呼ばれます。

369
00:26:51,000 --> 00:26:53,000
人々は、異なる時間に異なる用語を使用します。

370
00:26:53,000 --> 00:26:55,000
私は時々、それらを自分で交換する。

371
00:26:55,000 --> 00:27:00,000
それはちょうどので、ここでは、この変数が同様に命名されていることが起こる

372
00:27:00,000 --> 00:27:03,000
これに＃ここまで定義。

373
00:27:03,000 --> 00:27:06,000
しかし、彼らは同じことじゃない。

374
00:27:06,000 --> 00:27:11,000
大文字と小文字は区別されません。

375
00:27:11,000 --> 00:27:14,000
>> ここで何が起こるかを見てみると、我々は宣言する

376
00:27:14,000 --> 00:27:18,000
我々は数字と呼んでいた私たちのint配列、。

377
00:27:18,000 --> 00:27:23,000
我々はそれに私達の＃上部にまで定義に対応する私たちの大きさを、与えてくれた。

378
00:27:23,000 --> 00:27:27,000
これは8になるだろう。

379
00:27:27,000 --> 00:27:35,000
そして、我々はその後、下方に、Googleの検索機能を呼び出すときに、

380
00:27:35,000 --> 00:27:40,000
我々はプロンプトが表示されてきた我々が検索したい番号に渡す

381
00:27:40,000 --> 00:27:43,000
ユーザーから頂いた。

382
00:27:43,000 --> 00:27:46,000
我々は、この配列に数値を渡す

383
00:27:46,000 --> 00:27:51,000
その後、我々はまた、配列のサイズを渡す必要があります

384
00:27:51,000 --> 00:27:57,000
その後サイズ8の値が格納される

385
00:27:57,000 --> 00:28:01,000
またはサイズと呼ばれるこの整数型の変数に渡されます。

386
00:28:01,000 --> 00:28:08,000
我々は、配列の大きさを持っています。

387
00:28:08,000 --> 00:28:11,000
今、我々は我々が以前話していたものに戻ってしまったら、

388
00:28:11,000 --> 00:28:14,000
私はミッシーが、私たちが行うために必要なことは、配列の長さを取得するという点を育てたと思う

389
00:28:14,000 --> 00:28:20,000
そしてそれを2で割って、それは私達に中間点を与える。

390
00:28:20,000 --> 00:28:22,000
見てみましょう。

391
00:28:22,000 --> 00:28:25,000
私は誰かがこれを書いているとその領域に保存することはできますか？

392
00:28:25,000 --> 00:28:27,000
どのようにレイラはどうですか？

393
00:28:27,000 --> 00:28:31,000
私はあなたがこれをで書くことはできますか？

394
00:28:31,000 --> 00:28:35,000
あなたは配列の長さを取ると中点を取得する最初の行を書く

395
00:28:35,000 --> 00:28:41,000
と新しい変数に格納します。

396
00:28:41,000 --> 00:28:44,000
私はあなたに数秒を与えるでしょう。準備できてるの？

397
00:28:44,000 --> 00:28:46,000
[聞き取れない生徒]

398
00:28:46,000 --> 00:28:50,000
確かに、私は中間点を計算することができた

399
00:28:50,000 --> 00:28:55,000
検索機能の内部haystackの配列の

400
00:28:55,000 --> 00:29:03,000
サイズ可変であるhaystackの配列の長さを使用していますか？

401
00:29:03,000 --> 00:29:08,000
ここでトリッキーなものがありません。

402
00:29:08,000 --> 00:29:12,000
[レイラ]ジャストサイズ/ 2およびジャストイン

403
00:29:12,000 --> 00:29:17,000
そして、それを保存し、上部にここまで保存]ボタンを押す

404
00:29:17,000 --> 00:29:19,000
そして我々はそれをプルアップします。

405
00:29:19,000 --> 00:29:22,000
パーフェクト。

406
00:29:22,000 --> 00:29:28,000
そうしよう。恐ろしい。

407
00:29:28,000 --> 00:29:30,000
>> であるように、これはコンパイルのだろうか？

408
00:29:30,000 --> 00:29:32,000
[レイラ]いいえ、それは高くする必要がある。

409
00:29:32,000 --> 00:29:34,000
[ネイト]ええ、私たちは何をする必要がありますか？

410
00:29:34,000 --> 00:29:36,000
[レイラ】int中点か何かのように。

411
00:29:36,000 --> 00:29:41,000
恐ろしい。ええ、それは、int中点=サイズ行いましょう。

412
00:29:41,000 --> 00:29:44,000
これはコンパイルされます？

413
00:29:44,000 --> 00:29:47,000
このコメントを削除して、邪魔にならないましょう。

414
00:29:47,000 --> 00:29:50,000
これについてどのようにコンパイルされません？

415
00:29:50,000 --> 00:29:52,000
我々は、整数を使って何をやっていない

416
00:29:52,000 --> 00:29:55,000
ので、我々は、またはそのような何かを印刷する必要があります。

417
00:29:55,000 --> 00:29:58,000
ええ、その通りです。

418
00:29:58,000 --> 00:30:00,000
我々は、未使用の変数を取得します。

419
00:30:00,000 --> 00:30:02,000
ほかに何かこのことについて仕事に行くのではないでしょうか？

420
00:30:02,000 --> 00:30:06,000
私はあなたが何か、サムが言ったと思う。セミコロン。

421
00:30:06,000 --> 00:30:08,000
ええ、私はそれらのセミコロンが欠けている。

422
00:30:08,000 --> 00:30:14,000
それは、長期の経過を通じて一定のものになるだろう。

423
00:30:14,000 --> 00:30:17,000
私がやる最後のことは、私はどちらかの側にいくつかの空白を置くことにしましょう​​です

424
00:30:17,000 --> 00:30:23,000
ここで、我々はそれを行う方法を一般的にだから、この演算子の

425
00:30:23,000 --> 00:30:26,000
私たちのスタイルガイドによる。

426
00:30:26,000 --> 00:30:29,000
我々は、配列の中間点を持っている。

427
00:30:29,000 --> 00:30:32,000
今、我々は我々のアルゴリズムに戻って覚えていれば、

428
00:30:32,000 --> 00:30:37,000
我々は中間点を持っていたら、我々がしなければならなかったことを第二のステップは何でしたか？

429
00:30:37,000 --> 00:30:42,000
[学生]が大きいなら[聞こえない]。

430
00:30:42,000 --> 00:30:48,000
ええ、そう、我々は比較のいくつかの並べ替えを行う必要があり、我々はここで何を比較している？

431
00:30:48,000 --> 00:30:53,000
あなたはそれがより大きい場合に言いました。を参照して、その文の中で、それは何ですか？

432
00:30:53,000 --> 00:30:57,000
それは中間点よりも大きい場合の来る数は、その配列に上がる？

433
00:30:57,000 --> 00:31:05,000
正確なので、その数がアップしたときに我々 - 

434
00:31:05,000 --> 00:31:10,000
針なので、針に比較している、

435
00:31:10,000 --> 00:31:12,000
と私たちは針との比較ですか？

436
00:31:12,000 --> 00:31:15,000
針は、我々が探しているものだからです。

437
00:31:15,000 --> 00:31:18,000
我々は、中間点に到達するために、それを比較しています。

438
00:31:18,000 --> 00:31:21,000
>> しかし、それはどうかを確認しても意味がありません

439
00:31:21,000 --> 00:31:27,000
針=中間点かな？

440
00:31:27,000 --> 00:31:32,000
お分かりでしょうか？

441
00:31:32,000 --> 00:31:35,000
誰もが同意していますか？

442
00:31:35,000 --> 00:31:40,000
（針が==中点）した場合には、試してそれを与えるてみましょう。

443
00:31:40,000 --> 00:31:42,000
[学生]はprintfのあなたはそれを発見してください。

444
00:31:42,000 --> 00:31:51,000
[ネイト]のprintf（ "我々はそれを発見します\ n"）;

445
00:31:51,000 --> 00:31:56,000
それ以外の場合は - 私はここで何か違うことをやって起動するつもり。

446
00:31:56,000 --> 00:32:00,000
私はすべての時間if文の周りにカッコを置く作業を開始するつもりだ

447
00:32:00,000 --> 00:32:05,000
ちょうどその時、我々はより多くのものを追加した場合は理由

448
00:32:05,000 --> 00:32:07,000
我々は、コンパイラを得ることはありません。

449
00:32:07,000 --> 00:32:09,000
うん、サム。あなたはポイントを持っている。

450
00:32:09,000 --> 00:32:12,000
問題は、中点が配列内の位置を表していることである

451
00:32:12,000 --> 00:32:15,000
しかし、あなたはそれが配列のその位置の値を表現するために得ることができます。

452
00:32:15,000 --> 00:32:17,000
それが大きなポイントだ。

453
00:32:17,000 --> 00:32:19,000
皆はサムが言ったことを聞きましたか？

454
00:32:19,000 --> 00:32:22,000
彼は、その中点をそのまま言った

455
00:32:22,000 --> 00:32:28,000
配列内だけでの位置を表しますが、それは配列の実際の要素ではありません。

456
00:32:28,000 --> 00:32:30,000
あなたは今、書かれたようなコードを考える場合、

457
00:32:30,000 --> 00:32:35,000
、我々はここで、この配列を見下ろしてみると、その中の8つの要素を持っている

458
00:32:35,000 --> 00:32:39,000
この関数であることを行って中間の値は何ですか？

459
00:32:39,000 --> 00:32:41,000
[学生] 4。

460
00:32:41,000 --> 00:32:45,000
[ネイト] 4。

461
00:32:45,000 --> 00:32:51,000
我々は数字の4を探している場合 - 

462
00:32:51,000 --> 00:32:54,000
私達はちょうどこのコードを実行し、ここで少し悲しい顔を置くことができます

463
00:32:54,000 --> 00:32:58,000
我々はそれをした場合は見つかりませんでしたので、我々はこのコードを実行する

464
00:32:58,000 --> 00:33:04,000
今あるように、建物、それをアップロード、私は下にスクロールしてみましょう、

465
00:33:04,000 --> 00:33:09,000
そして我々は数字の4を探している場合、

466
00:33:09,000 --> 00:33:18,000
我々はそれを見つけましたが、我々は、printf yesにこれを取得できませんでした。

467
00:33:18,000 --> 00:33:23,000
理由の一つは、我々は、trueを返していなかったということです

468
00:33:23,000 --> 00:33:26,000
しかし、我々は本当に番号4を見つけたのですか？

469
00:33:26,000 --> 00:33:28,000
とサムは言っていません。

470
00:33:28,000 --> 00:33:31,000
我々は何を見つけたのですか？

471
00:33:31,000 --> 00:33:35,000
私たちは本当に我々がダウンしてここに配列を見れば中間点を、発見

472
00:33:35,000 --> 00:33:38,000
それは我々が見ていることインデックス4に要素になるだろう、

473
00:33:38,000 --> 00:33:42,000
これは、23です。

474
00:33:42,000 --> 00:33:46,000
>> どのように我々は、実際には中間点で、その要素を取得するのですか

475
00:33:46,000 --> 00:33:48,000
だけではなく、中間点自体？

476
00:33:48,000 --> 00:33:52,000
[学生]私たちは、charまたは何か入力してくださいだろうか？

477
00:33:52,000 --> 00:33:55,000
そのただ好奇心から、何をするでしょうか？

478
00:33:55,000 --> 00:33:57,000
もう少し手の込んだことはできますか？

479
00:33:57,000 --> 00:34:02,000
あなたは、数字に位置を変換する必要があります

480
00:34:02,000 --> 00:34:05,000
ので、それはcharだと思うが、それはないかもしれないいくつかの私は、接続を確立するために持っている。

481
00:34:05,000 --> 00:34:07,000
ええ、それは良い点だ。

482
00:34:07,000 --> 00:34:12,000
我々は、文字にこれらの文字を変換するこのポジションをたくさんやってきましたが、

483
00:34:12,000 --> 00:34:14,000
最初の二つの問題セットインチ

484
00:34:14,000 --> 00:34:18,000
それはここで、これはほぼ同様であることが判明

485
00:34:18,000 --> 00:34:24,000
それが理にかなっている場合、文字列内のi番目の文字にアクセスする。

486
00:34:24,000 --> 00:34:30,000
ここでは、中間の要素にアクセスしたいと思います。

487
00:34:30,000 --> 00:34:34,000
どのように我々はそれを行うのですか？

488
00:34:34,000 --> 00:34:39,000
ケビンは、あなたは私たちがやるかもしれないか何か提案はありますか？

489
00:34:39,000 --> 00:34:44,000
あなたは、haystackの半ば、閉じブラケットを開いたブラケットを行うことができます。

490
00:34:44,000 --> 00:34:46,000
あなたは私たちのためにそれを書くことができますか？

491
00:34:46,000 --> 00:34:51,000
ここでそれを保存して、我々はそれをプルアップします。

492
00:34:51,000 --> 00:34:56,000
我々は、この9行目で見ている、

493
00:34:56,000 --> 00:34:59,000
そして我々は、我々は中間点に針を比較しないことを実現している

494
00:34:59,000 --> 00:35:03,000
その代わりに、我々は、針を比較したい

495
00:35:03,000 --> 00:35:07,000
私たちのhaystackの配列内の位置の中間点にある要素に。

496
00:35:07,000 --> 00:35:10,000
クール。

497
00:35:10,000 --> 00:35:12,000
そうしよう。

498
00:35:12,000 --> 00:35:15,000
ええ、それはかなりよさそうだ、もし（針== haystackの[中点]）。

499
00:35:15,000 --> 00:35:18,000
我々はそれを発見した。

500
00:35:18,000 --> 00:35:22,000
今、私たちは少しアップコード-we'llバックを実行する場合

501
00:35:22,000 --> 00:35:26,000
それは、我々は4のために見ればすぐにコンパイルし、それが実行され、

502
00:35:26,000 --> 00:35:30,000
今、私たちは、実際に番号23を取得しているので、我々はそれを見つけることができませんでした。

503
00:35:30,000 --> 00:35:33,000
我々は、値23を取得している、そしてそれは私達が私達の針と比較しているものです。

504
00:35:33,000 --> 00:35:35,000
しかし、それは良いことだ。それは正しい方向への第一歩だ。

505
00:35:35,000 --> 00:35:37,000
>> それは我々がやろうとしているものです。

506
00:35:37,000 --> 00:35:40,000
我々は、配列内の位置に対して針を比較しようとしていない

507
00:35:40,000 --> 00:35:44,000
むしろ配列の実際の要素に対して。

508
00:35:44,000 --> 00:35:49,000
我々は我々のアルゴリズムの次のステップで、今再び振り返ってみると、

509
00:35:49,000 --> 00:35:51,000
次のステップは何ですか？

510
00:35:51,000 --> 00:35:57,000
レイラはすでに簡単にそれを述べた。

511
00:35:57,000 --> 00:36:00,000
[学生]それはより大きいか、小さいのかどうかを確認してから移動するかを決定する方法。

512
00:36:00,000 --> 00:36:03,000
[ネイトは]ええので、どのようにすることを私たちはしますか？

513
00:36:03,000 --> 00:36:07,000
このリビジョンを保存し、いくつかの-I'llに置くことができ、

514
00:36:07,000 --> 00:36:13,000
その後あなたはそれを行うことになるいくつかの行に入れます。

515
00:36:13,000 --> 00:36:15,000
うん、シャーロット。>>私は疑問を持っています。

516
00:36:15,000 --> 00:36:19,000
最初のものであるため、1  - それは中間点であってはならない

517
00:36:19,000 --> 00:36:26,000
それは実際に我々が探している文字ではありませんだと、我々は4を入れそうだとすれば、インデックス0の？

518
00:36:26,000 --> 00:36:30,000
はい、そしてもう一つの問題は-

519
00:36:30,000 --> 00:36:35,000
何がおそらく起こってしまうために起こっているので、それは、偉大なキャッチだ

520
00:36:35,000 --> 00:36:42,000
我々は動かし続けるとした場合、我々はこれまでに、当初は調整しません？

521
00:36:42,000 --> 00:36:46,000
私がアクセスしようとしている我々がやって終わるかもしれないかを推測

522
00:36:46,000 --> 00:36:49,000
配列の8番目の位置にある要素、

523
00:36:49,000 --> 00:36:53,000
このケースではそれは存在しません。

524
00:36:53,000 --> 00:36:56,000
我々は実際の会計処理のいくつかの並べ替えを行うことになるでしょう

525
00:36:56,000 --> 00:36:59,000
我々はいくつかのゼロインデックスを持っていること。

526
00:36:59,000 --> 00:37:05,000
角カッコ内に1  -  [シャルロット]は申し訳ありませんが、私は中間点を意味していた。

527
00:37:05,000 --> 00:37:08,000
我々はそれを行うことができる。

528
00:37:08,000 --> 00:37:10,000
我々は少しだけで、この問題に戻るでしょう。

529
00:37:10,000 --> 00:37:13,000
かつて我々は、実際のループに到達するために開始

530
00:37:13,000 --> 00:37:16,000
それは我々が本当にこれが遊びに来たときに表示されますです。

531
00:37:16,000 --> 00:37:21,000
当分の間、我々はこれを行うことができますが、あなたは完全に正しい。

532
00:37:21,000 --> 00:37:28,000
ゼロのインデックス作成は、我々が考慮する必要という効果を持つことになります。

533
00:37:28,000 --> 00:37:30,000
見てみましょう。

534
00:37:30,000 --> 00:37:34,000
>> より大きく、より少ない方法であるよりも？

535
00:37:34,000 --> 00:37:36,000
[学生]私はより大きく、より小さい部分を実行する方法を取得します。

536
00:37:36,000 --> 00:37:41,000
私はちょうどあなたがそれは干し草の山の中間点より小さいか、であることが判明した場合は印刷する内容がわからなかった。

537
00:37:41,000 --> 00:37:43,000
ここで私は保存することができます何I've-

538
00:37:43,000 --> 00:37:47,000
[ネイト]ええ、あなたが持っているものを保存して、我々はそれをプルアップする場合があります。

539
00:37:47,000 --> 00:37:49,000
そうしよう。

540
00:37:49,000 --> 00:37:51,000
[学生]そして私は私が知らなかった何のために疑問符を置く。

541
00:37:51,000 --> 00:37:54,000
[ネイト]偉大に見えること。

542
00:37:54,000 --> 00:37:58,000
我々はまだわからないので、ここでは、疑問符を持っている

543
00:37:58,000 --> 00:38:06,000
我々は非常にまだやろうとしている。

544
00:38:06,000 --> 00:38:12,000
私たちがdo-おっと、我々はいくつかの私たちのすべての括弧ファンキーを持ってしたいと思います。

545
00:38:12,000 --> 00:38:15,000
我々は、これらの括弧を修正します。

546
00:38:15,000 --> 00:38:19,000
そうしよう。

547
00:38:19,000 --> 00:38:22,000
それで我々は、我々のアルゴリズムによると、何をすべきかをしたいですか

548
00:38:22,000 --> 00:38:27,000
我々は、針が見つからない場合はどうなりますか？

549
00:38:27,000 --> 00:38:32,000
針は我々が探しているものを以下の場合で言う。ケビン。

550
00:38:32,000 --> 00:38:34,000
左半分だけを見てみましょう。

551
00:38:34,000 --> 00:38:40,000
右ので、私たちは言うここでコメント出してあげる "左半分を見て。"

552
00:38:40,000 --> 00:38:46,000
針が中間点で干し草の山よりも大きい場合に、我々は何をすべきかをしたいですか？

553
00:38:46,000 --> 00:38:48,000
[学生]次に、右半分を見てみましょう。

554
00:38:48,000 --> 00:38:53,000
右半分を見て、 "右半分を見てみましょう。"

555
00:38:53,000 --> 00:38:58,000
あまりにも粗末ではない。

556
00:38:58,000 --> 00:39:05,000
わかりましたので、この時点では、物事はかなり良い探しています。

557
00:39:05,000 --> 00:39:13,000
として書かれたコードの問題点は何ですか？

558
00:39:13,000 --> 00:39:15,000
[学生]あなたは半分のエンドポイントを持っていない。

559
00:39:15,000 --> 00:39:18,000
右、私たちは半分のエンドポイントを持っていない。

560
00:39:18,000 --> 00:39:20,000
また、これだけ一度通過するつもりです。

561
00:39:20,000 --> 00:39:23,000
我々は1つだけの中間点で見ていくつもりです。

562
00:39:23,000 --> 00:39:27,000
いずれかの要素があるか、そうではありません。

563
00:39:27,000 --> 00:39:34,000
これを完了するために、我々は繰り返しのいくつかの並べ替えを行う必要があります。

564
00:39:34,000 --> 00:39:39,000
我々は、我々が見つけるまで繰り返し続ける必要があり、その

565
00:39:39,000 --> 00:39:43,000
我々は、最終的に絞り込まれ、それを見つけたので、どちらかの要素がそこにある

566
00:39:43,000 --> 00:39:46,000
またはそれは、我々は物事のすべてに目を通してきたので、そこにはありません

567
00:39:46,000 --> 00:39:52,000
配列の適切な半分にしても何もそこにいないことがわかった。

568
00:39:52,000 --> 00:39:56,000
>> 我々は、この繰り返しが起こってしまった時はいつでも、私たちは何に使用するつもりですか？

569
00:39:56,000 --> 00:39:58,000
[学生]ループ。

570
00:39:58,000 --> 00:40:00,000
ループのいくつかの並べ替え。はい。

571
00:40:00,000 --> 00:40:03,000
[学生]我々はこれは、do-whil​​eループを行うことができますし、それがその、その後ながら行うた

572
00:40:03,000 --> 00:40:10,000
針は私はそれで使っていた場所に等しいは - 私がわからないことはありません。

573
00:40:10,000 --> 00:40:18,000
しかし、希望のようなものは、それが値を等しくしない限り、ユーザー入力にそれを行う。

574
00:40:18,000 --> 00:40:21,000
ええ、そう見てみましょう、これはどのように自分自身を書くのでしょうか？

575
00:40:21,000 --> 00:40:23,000
あなたがのはdo-whil​​eループを使用してみましょうと述べた。

576
00:40:23,000 --> 00:40:26,000
スタートをどこで行うのですか？

577
00:40:26,000 --> 00:40:33,000
右のサイズ/ 2後[学生]。

578
00:40:33,000 --> 00:40:42,000
[ネイト]さて、私たちは何をするつもりですか？

579
00:40:42,000 --> 00:40:44,000
我々は、後でしばらく埋めるでしょう。

580
00:40:44,000 --> 00:40:46,000
我々は何をするつもりですか？

581
00:40:46,000 --> 00:40:49,000
[学生]我々は我々がIF部で持っているすべてのものを行うにはしたくない？

582
00:40:49,000 --> 00:40:52,000
[ネイト]このすべてのものを行い、素晴らしい。

583
00:40:52,000 --> 00:40:55,000
コピーして貼り付けます。

584
00:40:55,000 --> 00:40:59,000
ああ、男。

585
00:40:59,000 --> 00:41:03,000
我々はこのタブ上に、可能であれば、この作品かどうかを確認してみましょう。

586
00:41:03,000 --> 00:41:08,000
美しい。

587
00:41:08,000 --> 00:41:16,000
君たちはそれを持っているので、大丈夫、私たちはこれを保存する。

588
00:41:16,000 --> 00:41:21,000
すべての権利、私たちはこれをやろうとしている一方、

589
00:41:21,000 --> 00:41:25,000
あなたが後にあったwhile条件は何でしたか？

590
00:41:25,000 --> 00:41:31,000
[学生]針が等しいわけではありませんが、そう感嘆符のような。

591
00:41:31,000 --> 00:41:37,000
しかし、私はそれはまだ正確にはよく分からない。

592
00:41:37,000 --> 00:41:39,000
[ネイト]うん、これはそれを行うための一つの方法です。

593
00:41:39,000 --> 00:41:41,000
サムは、あなたがコメントを持っていますか？

594
00:41:41,000 --> 00:41:43,000
[サム]私はビデオを見た時、私は思い出した、

595
00:41:43,000 --> 00:41:48,000
我々はそれのための擬似コードをやったとき、私は、のような一つのスクリーンショットを取った

596
00:41:48,000 --> 00:41:52,000
maxとminの間に何らかの関係があった。

597
00:41:52,000 --> 00:41:58,000
私はそれがmaxがminより小さければ、これまでのようなものだったと思います。

598
00:41:58,000 --> 00:42:00,000
それを得た。

599
00:42:00,000 --> 00:42:04,000
[SAM]またはMaxがそのような分、または何かを下回らないときなど、

600
00:42:04,000 --> 00:42:06,000
それはあなたがすべてのものを検索したことを意味するものであろうからである。

601
00:42:06,000 --> 00:42:13,000
>> うん、だから何それがmaxとminが言及したように聞こえるのでしょうか？

602
00:42:13,000 --> 00:42:16,000
[SAM]に変更しようとしている値が、-整数

603
00:42:16,000 --> 00:42:18,000
我々は中間点を置く場所に相対的。

604
00:42:18,000 --> 00:42:20,000
その通りです。

605
00:42:20,000 --> 00:42:24,000
[サム]がその時点で、それは[聞こえない] maxとminを計算するために起こっている。

606
00:42:24,000 --> 00:42:29,000
中点はこのmaxとminの考えです。

607
00:42:29,000 --> 00:42:35,000
それは人々に意味があるか？

608
00:42:35,000 --> 00:42:39,000
我々は、この繰り返しをやろうとしている方法を見て起動した場合、

609
00:42:39,000 --> 00:42:43,000
あなたは私たちがdo-whil​​eループのいくつかの並べ替えを使用することを完全に正しい。

610
00:42:43,000 --> 00:42:49,000
我々は、この配列の現場で何が起こっているかを覚えているのであれば私は推測する

611
00:42:49,000 --> 00:42:53,000
と実際に起こっては - 私以上書こうとしているここで、

612
00:42:53,000 --> 00:42:58,000
バイナリサーチの非常に最初の繰り返しで、我々は持っている - 

613
00:42:58,000 --> 00:43:05,000
私は始まりを表すためにBとEを使用するつもりだ。

614
00:43:05,000 --> 00:43:10,000
そして、我々の配列の終わり。

615
00:43:10,000 --> 00:43:14,000
私たちは、初めはこっち4右側にあることを知っている

616
00:43:14,000 --> 00:43:18,000
そして我々は終わりが108であることを知っています。

617
00:43:18,000 --> 00:43:23,000
我々は15番を探していると言う。

618
00:43:23,000 --> 00:43:27,000
我々はこれを行うのは初めてのように我々は、前に見た

619
00:43:27,000 --> 00:43:30,000
中間点は16または23であることを行っている

620
00:43:30,000 --> 00:43:34,000
我々は物事をどのように計算するかによって異なります。

621
00:43:34,000 --> 00:43:37,000
均等に分割するので、途中で私たちは、この空間を与えるだろう

622
00:43:37,000 --> 00:43:42,000
16と23の間に、我々は均等に分割することはできません

623
00:43:42,000 --> 00:43:47,000
またはそれを分割し、真の中間点で取得します。

624
00:43:47,000 --> 00:43:49,000
我々は、16を見てみましょう。

625
00:43:49,000 --> 00:43:55,000
私たちは、 "我々が探していることをねえ、16> 15。"に気づくでしょう

626
00:43:55,000 --> 00:43:59,000
次に、配列の左半分を見て

627
00:43:59,000 --> 00:44:03,000
私たちがやってしまいますと、捨てることです

628
00:44:03,000 --> 00:44:07,000
この全体の上部

629
00:44:07,000 --> 00:44:16,000
と "さて、私たちのエンドポイントはここになるだろう"と言っ

630
00:44:16,000 --> 00:44:22,000
私たちのループの次の反復では、我々は今、この配列を見ている、

631
00:44:22,000 --> 00:44:25,000
今ので、効果的にこの部分を捨てた

632
00:44:25,000 --> 00:44:30,000
我々は、始まりと終わりの間に違いが中間点を取っている場合、

633
00:44:30,000 --> 00:44:34,000
我々は、我々の中点が8であることがわかりました

634
00:44:34,000 --> 00:44:40,000
その我々が、それは我々が探している番号から見てどこにあるかを見るために8をテストすることができ、

635
00:44:40,000 --> 00:44:44,000
15、15の方が大きいことがわかり、

636
00:44:44,000 --> 00:44:49,000
ので、我々は、リストの右側の部分に移動する必要があります

637
00:44:49,000 --> 00:44:51,000
我々は人間だ、と我々はそれを見ることができるので、その我々は知っている。

638
00:44:51,000 --> 00:44:54,000
我々は、右の部分は、我々はそれを見つける場所であることを行っていることを知っている

639
00:44:54,000 --> 00:45:01,000
しかし、コンピュータは私たちが何をしようが、我々は実際によあることを知りません

640
00:45:01,000 --> 00:45:04,000
これは上がるし、今始まりと終わりました

641
00:45:04,000 --> 00:45:11,000
同じ場所ですが、、中間点はその時点でリスト内の唯一の番号となりますので、

642
00:45:11,000 --> 00:45:16,000
これは15であり、我々はそれを見つけた。

643
00:45:16,000 --> 00:45:21,000
それは、この全体のmaxとminの表記がどこに行っているかいくつかの光を当てるん

644
00:45:21,000 --> 00:45:24,000
把握するために、配列のエンドポイントを追跡する

645
00:45:24,000 --> 00:45:35,000
物事を絞り込むためにどのように？

646
00:45:35,000 --> 00:45:42,000
>> これは現在は15に等しくなかった場合、何が起こるでしょうか？

647
00:45:42,000 --> 00:45:52,000
我々が代わりに15と、探していた場合、この番号は16でしたか？

648
00:45:52,000 --> 00:45:54,000
私たちは、ああ、それは大きいです "、と言うと思います。

649
00:45:54,000 --> 00:45:57,000
我々は左に戻りたい。 "

650
00:45:57,000 --> 00:46:01,000
そして、我々は、右に当社の電子を移動したい

651
00:46:01,000 --> 00:46:06,000
その時点で我々は、競合となるエンドポイントを持っています。

652
00:46:06,000 --> 00:46:09,000
これは、任意の複数の要素を検索することはできないでしょう

653
00:46:09,000 --> 00:46:13,000
今、我々は、エンドポイントと私たちの始点を、持っているので、

654
00:46:13,000 --> 00:46:16,000
私たちのmaxとminは私たちの、今では反転しています。

655
00:46:16,000 --> 00:46:23,000
我々は、全体の配列を検索。我々は何かを見つけることができません。

656
00:46:23,000 --> 00:46:27,000
それは我々がわかりました、我々はこのアルゴリズムを停止するつもりだ "と言いたいと思いますした時点です。

657
00:46:27,000 --> 00:46:34,000
我々は何も見つかっていない。我々は、それがここではないと知っている。 "

658
00:46:34,000 --> 00:46:36,000
これはどのように起こっている？

659
00:46:36,000 --> 00:46:40,000
[学生]どのように正確にコンピュータが終わりを切り替えるのですか？

660
00:46:40,000 --> 00:46:45,000
どのように終わりは始まる前に終わるのでしょうか？

661
00:46:45,000 --> 00:46:48,000
終わりは始まる前に終わる

662
00:46:48,000 --> 00:46:54,000
なぜなら我々はこれを行うたびにやろうとしていることを数学の。

663
00:46:54,000 --> 00:47:00,000
我々は交換する方法は、非常に最初の時間を見れば、我々はこのスワップを行うことである

664
00:47:00,000 --> 00:47:03,000
我々は4時に始まりと終わりがどこに

665
00:47:03,000 --> 00:47:13,000
すべての108でダウンの方法、当社の中間点は、16歳の時、と言う - 

666
00:47:13,000 --> 00:47:20,000
私は、我々は15を探しているなら15にこのバックをリセットするつもりだ、

667
00:47:20,000 --> 00:47:25,000
我々は16をチェックしたときに我々が何をしたことを知っていたし、それが大きかったことを見た

668
00:47:25,000 --> 00:47:28,000
と、リスト全体の右部分を破棄したかった

669
00:47:28,000 --> 00:47:36,000
我々は我々がやりたいことは右ここでは、この電子を移動されていることを見た。

670
00:47:36,000 --> 00:47:44,000
効果的に、eは中間点の前に1に移動してしまった。

671
00:47:44,000 --> 00:47:48,000
同様に、我々はアルゴリズムの反復をしたとき

672
00:47:48,000 --> 00:47:51,000
と中間点は、8時だった

673
00:47:51,000 --> 00:47:55,000
我々は8 <15は、私たちはBを移動したかったことがわかった

674
00:47:55,000 --> 00:48:00,000
中点過去1。

675
00:48:00,000 --> 00:48:07,000
さて、最初と最後は、この15で一緒に両方です。

676
00:48:07,000 --> 00:48:10,000
>> 我々はいくつかの他の値ではなく、15を探すために起こっていたい場合は、

677
00:48:10,000 --> 00:48:14,000
または、この15は代わりに16日に行われた場合、

678
00:48:14,000 --> 00:48:20,000
我々は、電子は、我々は中間前に1つを移動することがわかっていただろう。

679
00:48:20,000 --> 00:48:33,000
今すぐeはb未満が反転することになります。

680
00:48:33,000 --> 00:48:39,000
私たちが実際にこのアルゴリズムをコーディング終わる方法をウォークスルーしてみましょう。

681
00:48:39,000 --> 00:48:44,000
私たちは、この中点の計算をしたいことを知っています。

682
00:48:44,000 --> 00:48:48,000
我々は、我々が最初と配列の末尾を追跡することも知っている

683
00:48:48,000 --> 00:48:51,000
私たちの現在の配列の我々が把握できるように

684
00:48:51,000 --> 00:48:56,000
このリストの左半分であり、リストの右半分がどこにあるか。場所

685
00:48:56,000 --> 00:49:03,000
我々は、いずれか、beginとendを使用して行うこと

686
00:49:03,000 --> 00:49:07,000
または我々は彼らminとmaxを呼び出すことができます。

687
00:49:07,000 --> 00:49:10,000
私はこの時間を開始および終了に使用します。

688
00:49:10,000 --> 00:49:15,000
私たちはここで私たちの例でダウンを振り返る時期になりましたら、場合には、

689
00:49:15,000 --> 00:49:20,000
私たちの始まりは自然なように、配列の先頭に設定されていました。

690
00:49:20,000 --> 00:49:25,000
これはどのような指標だったのですか？私たちのことが何を始めるべきでしょうか？

691
00:49:25,000 --> 00:49:27,000
ダニエル。

692
00:49:27,000 --> 00:49:30,000
[ダニエル]ヘイ[0]。

693
00:49:30,000 --> 00:49:37,000
[ネイトは]ええ、私たちは干し草の山[0]に等しく、それを設定することができます。

694
00:49:37,000 --> 00:49:40,000
問題は、しかし、これは私たちの最初の要素の位置を与えることではないです。

695
00:49:40,000 --> 00:49:45,000
それは私達の最初の要素のインデックスか、その最初の位置で実際の値を与える。

696
00:49:45,000 --> 00:49:47,000
[学生] 0.20に変換されますね？

697
00:49:47,000 --> 00:49:52,000
これが何をするのか[ネイト]は-まあ、それは、任意のA変換を行うことはありません。

698
00:49:52,000 --> 00:49:56,000
それは何を行いますと、それは始まりに4を格納しますです

699
00:49:56,000 --> 00:49:59,000
そして、次に、それは始まるに対して比較を行うことは難しいことでしょう。

700
00:49:59,000 --> 00:50:03,000
beginは、4の値を保持されるため、

701
00:50:03,000 --> 00:50:06,000
これは、我々の配列の先頭です

702
00:50:06,000 --> 00:50:08,000
しかし、我々は、配列内のインデックスを追跡したい

703
00:50:08,000 --> 00:50:11,000
のような値に反対した。

704
00:50:11,000 --> 00:50:17,000
私たちは、実際にそのように、0を使用します。

705
00:50:17,000 --> 00:50:20,000
アレイ·シャーロットの終わりのために少し早くこれを持って来ました。

706
00:50:20,000 --> 00:50:23,000
我々が考慮ゼロインデックスを取るところです。

707
00:50:23,000 --> 00:50:25,000
>> シャーロット、配列の終わりは何ですか？

708
00:50:25,000 --> 00:50:28,000
終わりのインデックスとは何ですか？

709
00:50:28,000 --> 00:50:30,000
[シャルロット]サイズ -  1。

710
00:50:30,000 --> 00:50:32,000
ええ、私たちはどのサイズを使うべきでしょうか？

711
00:50:32,000 --> 00:50:35,000
私たちは、資本金規模または小文字サイズを使うべきでしょうか？

712
00:50:35,000 --> 00:50:37,000
資本金規模。

713
00:50:37,000 --> 00:50:42,000
この場合において、我々は資本の大きさを使用することができます。

714
00:50:42,000 --> 00:50:45,000
我々は、この関数は移植可能にしたい場合

715
00:50:45,000 --> 00:50:48,000
と、他のプログラムでこの関数を使用する

716
00:50:48,000 --> 00:50:50,000
私たちは実際には小文字サイズを使用することができます。

717
00:50:50,000 --> 00:50:52,000
それはあまりにも大丈夫です。

718
00:50:52,000 --> 00:51:01,000
1  - しかし、シャーロットは、我々は大きさを持たせたい完全に右です。

719
00:51:01,000 --> 00:51:03,000
このポイントで

720
00:51:03,000 --> 00:51:05,000
[学生]それはあなたが大文字の大きさを使用することができますどうですか？

721
00:51:05,000 --> 00:51:07,000
それは我々が大文字の大きさを使用することができることをどうですか？

722
00:51:07,000 --> 00:51:13,000
それは、これらの＃defineを実際にあることが判明

723
00:51:13,000 --> 00:51:19,000
ボンネットの下に、検索と置換のようなテキスト、理にかなっている場合。

724
00:51:19,000 --> 00:51:24,000
あなたのコードをコンパイルし、前処理フェーズ

725
00:51:24,000 --> 00:51:27,000
コンパイラでは、ファイルを経由する

726
00:51:27,000 --> 00:51:31,000
そしてそれは、どこに資本金規模を書いてきたことを探し

727
00:51:31,000 --> 00:51:39,000
そして、それはちょうどそのように、8と文字通りそのテキストを置き換えます。

728
00:51:39,000 --> 00:51:42,000
その意味で、これは変数と非常に異なっている。

729
00:51:42,000 --> 00:51:45,000
これは、メモリ内の任意のスペースを取りません。

730
00:51:45,000 --> 00:51:52,000
それは、単純なテキスト置換トリックです。

731
00:51:52,000 --> 00:51:57,000
この場合において、我々はサイズを使用するつもりです。

732
00:51:57,000 --> 00:52:01,000
ここからは繰り返しのいくつかの並べ替えをやってみたいですか、

733
00:52:01,000 --> 00:52:03,000
そして我々は、do-whil​​eループで正しい軌道に乗っている。

734
00:52:03,000 --> 00:52:08,000
条件はもはや成立しないまで、我々は何かをしたい、

735
00:52:08,000 --> 00:52:12,000
我々は前に見たようにと、私たちは、その状態を見た

736
00:52:12,000 --> 00:52:19,000
我々は終わりを望んでいないことを確かにあった

737
00:52:19,000 --> 00:52:24,000
開始未満であること。

738
00:52:24,000 --> 00:52:26,000
>> これは我々の停止条件である。

739
00:52:26,000 --> 00:52:35,000
この問題が発生した場合、我々は、同じように停止して宣言したい "ねえ、私たちは何も見つかっていない。"

740
00:52:35,000 --> 00:52:43,000
これを表現するために、我々はループのいくつかの並べ替えを使用したいです。

741
00:52:43,000 --> 00:52:49,000
この場合、それは、forループ、whileループ、do-whil​​eループでしょうか？

742
00:52:49,000 --> 00:52:51,000
我々はここでdo-whil​​eループを持っています。

743
00:52:51,000 --> 00:52:53,000
あなたはそのアプローチのような連中か？

744
00:52:53,000 --> 00:52:59,000
あなたは、我々は別のアプローチを試みるべきだと思いますか？

745
00:52:59,000 --> 00:53:01,000
ケビン、任意の考え？

746
00:53:01,000 --> 00:53:06,000
私たちは最大のを知っているので、我々は、whileループを及ぼす可能性があります

747
00:53:06,000 --> 00:53:11,000
スタートとにかくアットminより大きいだろう。

748
00:53:11,000 --> 00:53:14,000
ええ、そう起こる必要がない初期化はありません。

749
00:53:14,000 --> 00:53:17,000
あなたが何かを初期化する必要がある場合、それらは、do-whil​​eループは素晴らしいです

750
00:53:17,000 --> 00:53:21,000
次にここのに対し、テストする前に

751
00:53:21,000 --> 00:53:26,000
我々は両方の開始と終了を再初期化しておくつもりはないことを知っている

752
00:53:26,000 --> 00:53:28,000
ループのすべてのラウンド。

753
00:53:28,000 --> 00:53:32,000
我々は、我々がそれらを初期化することを知っているし、私たちの状態を確認してください。

754
00:53:32,000 --> 00:53:38,000
この場合、私は実際には単純なwhileループで行くつもりです。

755
00:53:38,000 --> 00:53:44,000
これはこれは、do-whil​​eループはかなり頻繁に使用されないことが判明した。

756
00:53:44,000 --> 00:53:49,000
ループしながら多くの場所でもない教えていない。

757
00:53:49,000 --> 00:53:53,000
彼らは、ユーザー入力を処理するための良いしているので、我々はこれまで、それらの多くを見てきました。

758
00:53:53,000 --> 00:53:59,000
しかし、通常の場合、ループは、より多くの共通している間。

759
00:53:59,000 --> 00:54:03,000
それは、この条件が書かれているとおりと判明

760
00:54:03,000 --> 00:54:09,000
本当に私達にはるかに良いを行い、その理由ではないだろうか？

761
00:54:09,000 --> 00:54:11,000
ごめんなさい、私はあなたの名前を知りません。

762
00:54:11,000 --> 00:54:13,000
私はジェリーだ。>>申し訳ありませんが？

763
00:54:13,000 --> 00:54:15,000
これは、B-O-R-U-Iです。

764
00:54:15,000 --> 00:54:18,000
ああ、大丈夫。

765
00:54:18,000 --> 00:54:23,000
私は私のリストにあなたが表示されません。

766
00:54:23,000 --> 00:54:26,000
ああ、それは理にかなっているので、ああ、それだ。

767
00:54:26,000 --> 00:54:31,000
あなたは、意図したとおり、このwhileループは動作しない可能性があります理由のアイデアを持っていますか

768
00:54:31,000 --> 00:54:38,000
条件で書かれたように？

769
00:54:38,000 --> 00:54:43,000
あなたにもそれ以降のすべてのものにしたいように[ジェリー]あなたが平均？

770
00:54:43,000 --> 00:54:46,000
うん、だからそれは一つだ。

771
00:54:46,000 --> 00:54:49,000
我々は完全に真であるwhileループ、中にこのようなもののすべてを置く必要があるかもしれません。

772
00:54:49,000 --> 00:54:55,000
もう少し問題だ他のことは、しかし、この状態は動作しないということです。

773
00:54:55,000 --> 00:54:57,000
[学生]あなたはそれを反転する必要があります。

774
00:54:57,000 --> 00:55:04,000
右ので、この条件は、これまで最初に我々はそれについて話した方法は必ずしも当てはまりません。

775
00:55:04,000 --> 00:55:08,000
我々は最後まで何かをしたい、<開始

776
00:55:08,000 --> 00:55:13,000
しかし、我々はしばらくの間何かをしたい

777
00:55:13,000 --> 00:55:21,000
≤終了を開始します。

778
00:55:21,000 --> 00:55:24,000
>> そこに論理のその逆転があります。

779
00:55:24,000 --> 00:55:27,000
私はそれらのミスはすべての時間を作るの罪を犯したんだ。

780
00:55:27,000 --> 00:55:31,000
[学生]なぜそれより小さいか等しくなるように持っていますか？

781
00:55:31,000 --> 00:55:33,000
あなたは我々が得たことを覚えている場合ではないので

782
00:55:33,000 --> 00:55:36,000
ここで、一つしか要素があって、我々は減少しました

783
00:55:36,000 --> 00:55:43,000
と我々の配列内のわずか15を見ていた？

784
00:55:43,000 --> 00:55:47,000
そして、我々の始まりと私たちの終わりは、同じ要素であった。

785
00:55:47,000 --> 00:55:50,000
我々は、我々がそのケースを扱うことを確認したい。

786
00:55:50,000 --> 00:55:54,000
我々は、よりストレート未満を行った場合は、

787
00:55:54,000 --> 00:55:58,000
我々は唯一の2つの要素を持つ配列に取り掛かることができるだろう。

788
00:55:58,000 --> 00:56:06,000
かつて我々はそれが我々の要素であるならば、我々はそれを見つけることは決してないだろうが、その最後の要素に降りた。

789
00:56:06,000 --> 00:56:10,000
今ここに、我々はあなたが言っていたのと全く同じように行うことができます。

790
00:56:10,000 --> 00:56:15,000
我々は右の私達のwhileループの真ん中にものをplopping開始することができます。

791
00:56:15,000 --> 00:56:20,000
私達は私達の中点でウンチすることができます。

792
00:56:20,000 --> 00:56:24,000
文の場合我々は、これらのすべてを取ることができます

793
00:56:24,000 --> 00:56:30,000
それらをこのdo-whil​​eループからの撤退、

794
00:56:30,000 --> 00:56:34,000
ウンチそれらで、

795
00:56:34,000 --> 00:56:39,000
、少し物事をきれいにする

796
00:56:39,000 --> 00:56:48,000
と私は先に行くと、このリビジョンを保存します。

797
00:56:48,000 --> 00:56:53,000
この時点で、我々はかなり近づいた。

798
00:56:53,000 --> 00:56:55,000
サム。

799
00:56:55,000 --> 00:56:58,000
1月2日 - 私はあなたにもint型中点=サイズを持っていると思います。

800
00:56:58,000 --> 00:57:01,000
1月2日 - それは、大きさになった。

801
00:57:01,000 --> 00:57:05,000
我々は、その行については変更する必要がある他に何かありますか？

802
00:57:05,000 --> 00:57:10,000
それは大漁だった。

803
00:57:10,000 --> 00:57:14,000
>> サイズは何をしますか？我々はこれまでに大きさを変えていますか？

804
00:57:14,000 --> 00:57:17,000
このようなラインを保つために、我々は、サイズを変更する必要があります。

805
00:57:17,000 --> 00:57:21,000
我々は大きさに私達が、forループを回るたびに変更する必要があります。

806
00:57:21,000 --> 00:57:25,000
しかし、私たちはほんの少し前の私たちの例を通過したときに覚えている

807
00:57:25,000 --> 00:57:30,000
そして我々は4で始めていた

808
00:57:30,000 --> 00:57:33,000
およびエンド108の上のすべての方法は？

809
00:57:33,000 --> 00:57:35,000
どのように我々は中間点を計算したのですか？

810
00:57:35,000 --> 00:57:38,000
私達はサイズを使用していましたか？

811
00:57:38,000 --> 00:57:40,000
あるいは、我々が開始し、代わりにエンドを使用していましたか？

812
00:57:40,000 --> 00:57:42,000
それは、終わりと始まりの間の差です。

813
00:57:42,000 --> 00:57:50,000
正確に、そして正確にどのように私はシャーロット、次のことを書くべきでしょうか？

814
00:57:50,000 --> 00:57:52,000
ちょうど終了 - 開始。

815
00:57:52,000 --> 00:57:55,000
1  - あなたが行う必要がありません

816
00:57:55,000 --> 00:57:58,000
1末尾に含まれており、すでに開始されていたので - 。

817
00:57:58,000 --> 00:58:00,000
[ネイト]グレート、あなたは完全に正しい。

818
00:58:00,000 --> 00:58:03,000
そのため、1  -  1  - が含まれている我々は実行する必要はありません

819
00:58:03,000 --> 00:58:08,000
そして我々は最後の変数を初期化したときに占めています。

820
00:58:08,000 --> 00:58:11,000
>> 私は、この行が意味をなす持って文法的に行う必要がある他に何かありますか？

821
00:58:11,000 --> 00:58:13,000
[学生]プラスを開始します。>>プラス始まる？

822
00:58:13,000 --> 00:58:15,000
終わりに、[学生]。

823
00:58:15,000 --> 00:58:20,000
それが唯一の半分の長さを計算しているからだ。

824
00:58:20,000 --> 00:58:26,000
あなたが開始を追加する必要があります。

825
00:58:26,000 --> 00:58:31,000
[ネイト]これが私たちのために何を計算するか？

826
00:58:31,000 --> 00:58:35,000
我々はループのこの非常に最初の反復で終了を考えると、

827
00:58:35,000 --> 00:58:40,000
エンド位置index 7であることを行っている。

828
00:58:40,000 --> 00:58:43,000
開始位置は0になっています。

829
00:58:43,000 --> 00:58:47,000
覚えておいて、我々のいずれかを探している

830
00:58:47,000 --> 00:58:52,000
3位又は4位に。

831
00:58:52,000 --> 00:58:56,000
我々はこの数学を見れば、それはもう少し具体的にするために、

832
00:58:56,000 --> 00:59:02,000
ここにいくつかの数字を入れて、私たちは、7,0を持っている

833
00:59:02,000 --> 00:59:10,000
そう7から0、次に/ 2

834
00:59:10,000 --> 00:59:19,000
整数の除算で3であり、それはです。

835
00:59:19,000 --> 00:59:26,000
それから私達は、私達の開始を再度追加する必要がありますか？

836
00:59:26,000 --> 00:59:28,000
我々は、このケースではありません。

837
00:59:28,000 --> 00:59:31,000
開始が0であるため、非常に最初の繰り返しで、それがうまくいくでしょう。

838
00:59:31,000 --> 00:59:36,000
しかし、我々の進歩として、我々は必要なすべての本当にやる

839
00:59:36,000 --> 00:59:42,000
終了 - 開始/ 2。

840
00:59:42,000 --> 00:59:46,000
そこにもう一つのトリックはここにある、そして、それはすなわち、優先順位の一つです。

841
00:59:46,000 --> 00:59:49,000
[学生]私たちは、括弧は必要ですか？

842
00:59:49,000 --> 00:59:53,000
正確には、[ネイト]そして我々は、これらの括弧を入れていない場合ですので、

843
00:59:53,000 --> 00:59:58,000
この行ではなく、解釈されます

844
00:59:58,000 --> 01:00:09,000
（終わり）と - （開始/ 2）、我々は間違いたくない。

845
01:00:09,000 --> 01:00:11,000
それらの優先順位規則に気をつけろ。

846
01:00:11,000 --> 01:00:15,000
[学生]なぜそれが終わりではありません+ +始める？

847
01:00:15,000 --> 01:00:17,000
なぜそれが終わりではありません+ +始める？

848
01:00:17,000 --> 01:00:19,000
[学生]なぜそれがあることではないのですか？

849
01:00:19,000 --> 01:00:24,000
なぜそれが+でしょうか？

850
01:00:24,000 --> 01:00:26,000
私はあなたが正しいと思います。

851
01:00:26,000 --> 01:00:28,000
[学生]それは平均だから？

852
01:00:28,000 --> 01:00:31,000
[ネイト] END +開始、あなたは完全に正しい。

853
01:00:31,000 --> 01:00:34,000
うわー、私は全くgoofed。あなたは正しいです。

854
01:00:34,000 --> 01:00:39,000
我々はマイナスをやっていたなら、私たちはピンを見るには開始を追加したいと思う

855
01:00:39,000 --> 01:00:43,000
このケースでは、我々は2つ​​の平均を取りたいことは非常に正しい、

856
01:00:43,000 --> 01:00:45,000
ので、我々は彼らを減算するとは対照的に、それらを追加したいです。

857
01:00:45,000 --> 01:00:49,000
[学生]は終了しました場合にも動作するだろう - 開始/ 2 +を開始します。

858
01:00:49,000 --> 01:00:55,000
私たちは、私はそう信じていた場合、それはそうするでしょう。

859
01:00:55,000 --> 01:01:00,000
>> 例えば、我々が始まる見ていた場合、

860
01:01:00,000 --> 01:01:04,000
そして我々はそれをここにシフト

861
01:01:04,000 --> 01:01:08,000
15〜。

862
01:01:08,000 --> 01:01:12,000
位置は2になり今始まる。

863
01:01:12,000 --> 01:01:15,000
終わりは7位になります。

864
01:01:15,000 --> 01:01:21,000
我々はそれらを引くと、我々は5を取得します。

865
01:01:21,000 --> 01:01:24,000
2であることを分割する、我々は2を取得します。

866
01:01:24,000 --> 01:01:27,000
そして、我々は、後ろに2を追加

867
01:01:27,000 --> 01:01:30,000
それは、第四の位置に私たちを取得

868
01:01:30,000 --> 01:01:33,000
これは、中間点である、まさにここです。

869
01:01:33,000 --> 01:01:36,000
[学生]私たちは包装の世話をする必要がありますか？

870
01:01:36,000 --> 01:01:39,000
どのような意味で私たちは包装の世話をする必要がありますか？

871
01:01:39,000 --> 01:01:43,000
もし和や違い

872
01:01:43,000 --> 01:01:45,000
我々はそれを行う方法に応じて、偶数番号ではありません。

873
01:01:45,000 --> 01:01:49,000
その後、コンピュータはそれが2.5の時かどうか混乱してしまいます;

874
01:01:49,000 --> 01:01:52,000
あなたが左にまたは中点であるかを決定する権利へ移動するのですか？

875
01:01:52,000 --> 01:01:54,000
それを得た。

876
01:01:54,000 --> 01:01:56,000
それは、その整数の割り算と判明

877
01:01:56,000 --> 01:01:59,000
我々はこれまで、これらの浮動小数点数を得ることはありません。

878
01:01:59,000 --> 01:02:01,000
我々は、小数を取得することはありません。

879
01:02:01,000 --> 01:02:04,000
それは完全に破棄されている。

880
01:02:04,000 --> 01:02:08,000
コンピュータは、2つのint型の変数を分割している場合

881
01:02:08,000 --> 01:02:11,000
そして、1は7であり、もう一つは2です

882
01:02:11,000 --> 01:02:13,000
あなたは、結果として3.5を取得することはありません。

883
01:02:13,000 --> 01:02:16,000
それは、3つを取得します。

884
01:02:16,000 --> 01:02:19,000
残りは破棄されますので、それは事実上の丸め

885
01:02:19,000 --> 01:02:24,000
君たちは数学のそれに精通している場合ではないラウンドではなくフロア、

886
01:02:24,000 --> 01:02:27,000
どこであなたは完全に、小数を破棄

887
01:02:27,000 --> 01:02:31,000
ので、あなたは本質的に最も近いにそれを切り捨てている

888
01:02:31,000 --> 01:02:33,000
最も近い整数に全体の位置。

889
01:02:33,000 --> 01:02:38,000
[学生]は、7つの要素の配列を持っている場合ので、しかし、その後、それは問題だ

890
01:02:38,000 --> 01:02:43,000
その替わりに自動的に第四の中間点の第三の要素を取り出す。

891
01:02:43,000 --> 01:02:46,000
どのように我々はそれに対処するのですか？

892
01:02:46,000 --> 01:02:49,000
それが問題だから我々は7の配列を持っていた場合、

893
01:02:49,000 --> 01:02:54,000
それは代わりに第四の第三を選ぶだろう。

894
01:02:54,000 --> 01:02:56,000
あなたは、もう少し説明してもらえますか？

895
01:02:56,000 --> 01:02:59,000
あなたは、7つの要素第四の要素を持っている場合があるため[学生]

896
01:02:59,000 --> 01:03:04,000
中点、右でしょうか？

897
01:03:04,000 --> 01:03:07,000
しかし、インデックスがゼロであることについてあなたのコメントを覚えています。

898
01:03:07,000 --> 01:03:10,000
[学生]ええ、そう位置3インチそれは中間点であろう。

899
01:03:10,000 --> 01:03:12,000
うん。

900
01:03:12,000 --> 01:03:16,000
ああ、大丈夫。私はあなたが何を意味するかを参照してください。

901
01:03:16,000 --> 01:03:19,000
それは、我々は、この全体の概念に慣れるように、奇妙なものだ

902
01:03:19,000 --> 01:03:22,000
小数を取り払うこと。

903
01:03:22,000 --> 01:03:26,000
それが大きなポイントだ。

904
01:03:26,000 --> 01:03:30,000
このセットアップを終了してみましょう。

905
01:03:30,000 --> 01:03:32,000
私達は私達の中点を計算した。

906
01:03:32,000 --> 01:03:37,000
>> 私達は私達の針が中央値に等しいかどうかを確認するためにテストしている。

907
01:03:37,000 --> 01:03:41,000
私達は私達がそれを見つけたことを印刷しているが、実際、我々はこのような状況で何をすべきかをしたいですか？

908
01:03:41,000 --> 01:03:46,000
私たちはそれを見つけたので、呼び出し側は、我々はそれを見つけたことを知らせたい。

909
01:03:46,000 --> 01:03:49,000
我々は、boolean型指定された関数の機能を持っている。

910
01:03:49,000 --> 01:03:54,000
我々は移動する準備が整いましたことを我々は関数の呼び出し元に知らせる方法

911
01:03:54,000 --> 01:03:58,000
私たちは "ねえ、これが本当である"と言うさ

912
01:03:58,000 --> 01:04:00,000
どのように我々は、ケビンがそれを行うだろうか？

913
01:04:00,000 --> 01:04:02,000
あなたの頭をうなずいています。>> [ケビン]追加trueを返します。

914
01:04:02,000 --> 01:04:06,000
[ネイト]正確には、trueを返します。

915
01:04:06,000 --> 01:04:12,000
さて、それが等しくない場合、どのように我々は左半分に見えるのでしょうか？

916
01:04:12,000 --> 01:04:16,000
任意のアイデア？

917
01:04:16,000 --> 01:04:18,000
ステラ、任意のアイデア？

918
01:04:18,000 --> 01:04:21,000
あなたは最後の新しい位置を設定する必要があります。

919
01:04:21,000 --> 01:04:23,000
うん。

920
01:04:23,000 --> 01:04:29,000
エンド - だから私たちは中間点の位置を行う必要があります。

921
01:04:29,000 --> 01:04:33,000
グレート。

922
01:04:33,000 --> 01:04:36,000
私たちは終わりのための新しい位置を設定する必要が

923
01:04:36,000 --> 01:04:38,000
左半分を見て。

924
01:04:38,000 --> 01:04:41,000
これは、我々がどこに前の話だったもの

925
01:04:41,000 --> 01:04:44,000
私は、この例に戻って続ける。

926
01:04:44,000 --> 01:04:50,000
私はここから始まりましたし、私は終わりにこっちにすべての方法を持っています。

927
01:04:50,000 --> 01:04:53,000
>> 再び、我々は15を探している、と私たちの中点が16である場合、

928
01:04:53,000 --> 01:04:56,000
そして我々はおっと、16の方が大きい "、実現しています。

929
01:04:56,000 --> 01:04:59,000
我々は左半分に移動したい。 "

930
01:04:59,000 --> 01:05:02,000
次に、私たちは15に端を移動する

931
01:05:02,000 --> 01:05:06,000
そして我々は途中から1を奪うことによってそれを行う

932
01:05:06,000 --> 01:05:09,000
その私たちの新しいエンドとして設定。

933
01:05:09,000 --> 01:05:12,000
同様に、我々は右半分を見たい場合、どのように我々はそれをするでしょうか？

934
01:05:12,000 --> 01:05:14,000
あなたのアイデアを持っていますか？

935
01:05:14,000 --> 01:05:22,000
[学生]あなただけの+1の中点を開始に設定します。

936
01:05:22,000 --> 01:05:24,000
[ネイト]グレート。

937
01:05:24,000 --> 01:05:29,000
そして今、我々が何かを見つけていないという場合には、

938
01:05:29,000 --> 01:05:32,000
それは、私たちにとっての世話を取得するのですか？

939
01:05:32,000 --> 01:05:36,000
ダニエルは、その私たちのための世話をするのでしょうか。

940
01:05:36,000 --> 01:05:38,000
[ダニエル]いいえ

941
01:05:38,000 --> 01:05:40,000
[ネイト]我々は、配列全体を介してそれを作ると私達が何も見つからない場合は、

942
01:05:40,000 --> 01:05:42,000
どこでそれが世話をされるであろう、あるいは、我々はそれの世話をする必要がありますか？

943
01:05:42,000 --> 01:05:44,000
[ダニエル] while条件。

944
01:05:44,000 --> 01:05:48,000
[ネイト]ええ、while条件、その通りです。

945
01:05:48,000 --> 01:05:51,000
我々が何かを見つけていないなら、それは全体の配列を通過するの世話をします。

946
01:05:51,000 --> 01:05:53,000
このwhileループが終了します。

947
01:05:53,000 --> 01:05:56,000
我々は、この状況に遭遇したことはなかったでしょう

948
01:05:56,000 --> 01:06:03,000
そして我々はfalseを返すことができます。

949
01:06:03,000 --> 01:06:10,000
このような場合は、ここで我々はまた、このままにしておくことができ

950
01:06:10,000 --> 01:06:14,000
この文の場合はtrueですなぜならもし、

951
01:06:14,000 --> 01:06:16,000
我々の関数は、戻ります

952
01:06:16,000 --> 01:06:21,000
それで我々はこの時点で中止この機能本質的によ

953
01:06:21,000 --> 01:06:24,000
我々は、trueを返したとき。

954
01:06:24,000 --> 01:06:28,000
しかし、何がここでこの構造はどうなるのでしょうか？

955
01:06:28,000 --> 01:06:34,000
これは完全に動作し、またはそこにいくつかの論理的な欠陥があるのだろうか？

956
01:06:34,000 --> 01:06:37,000
>> そこにいくつかの論理的な欠陥は、それが設定されている方法で、あります。

957
01:06:37,000 --> 01:06:40,000
それは何になるのでしょうか？

958
01:06:40,000 --> 01:06:43,000
[学生]なぜあなたが必要ない - と+ 1S？

959
01:06:43,000 --> 01:06:47,000
それは私たちの新しい左半分と右半分になるように私たちの配列を設定します。

960
01:06:47,000 --> 01:06:51,000
[学生]しかし、なぜあなたなしでそれを行うことができませんでした -  1Sと+ 1S？

961
01:06:51,000 --> 01:06:53,000
[ネイト]我々は、中間点に等しく、それを設定することができます？

962
01:06:53,000 --> 01:07:04,000
何がそれについて問題があるのでしょうか？

963
01:07:04,000 --> 01:07:08,000
[学生]私はあなたが既にチェックインされている値をチェックしているので、それは非効率的だと思う。

964
01:07:08,000 --> 01:07:11,000
[ネイト]正確なので、サムは完全に右です。

965
01:07:11,000 --> 01:07:15,000
あなたが最後に設定し、中間点に等しいから始める場合

966
01:07:15,000 --> 01:07:18,000
代わりに -  1と反射的に+ 1

967
01:07:18,000 --> 01:07:22,000
将来のある時点で我々は再び中間点をチェックしてしまいます。

968
01:07:22,000 --> 01:07:26,000
[学生]私はpsetを開始し、その後、私はそのような何かを持っていた

969
01:07:26,000 --> 01:07:30,000
ここで私は、+ 1を忘れて、それが無限ループに捕まってしまった。

970
01:07:30,000 --> 01:07:34,000
右の、ある時点で作業を開始を取得し、終了するつもりはありませんしているので、

971
01:07:34,000 --> 01:07:39,000
実際にオーバーラップする。

972
01:07:39,000 --> 01:07:41,000
クール。

973
01:07:41,000 --> 01:07:44,000
そこにもう一つの論理的な欠陥だし、それは、これは間違いであるべきであるということです

974
01:07:44,000 --> 01:07:48,000
他の場合。

975
01:07:48,000 --> 01:07:55,000
なぜ、そうなのでしょうか？

976
01:07:55,000 --> 01:07:59,000
>> それはあなたがそれをなかったかどうか、他ではない場合の理由は、ケビンですか？

977
01:07:59,000 --> 01:08:02,000
[ケビン]ええ、あなたはエンドポイントを変更しているので。

978
01:08:02,000 --> 01:08:05,000
[ネイト]その通りです。

979
01:08:05,000 --> 01:08:07,000
我々は、エンドポイントを変更している

980
01:08:07,000 --> 01:08:12,000
それがこの、we'llのように書かれている場合は、間にスペースを作る - 

981
01:08:12,000 --> 01:08:14,000
それはこのケースをチェックします。

982
01:08:14,000 --> 01:08:18,000
それが成功した場合この場合は、機能の中断タイムアウトになります。

983
01:08:18,000 --> 01:08:21,000
それは、この次のケースをチェックします

984
01:08:21,000 --> 01:08:24,000
これが成功した場合、それは、エンドポイントを調整します

985
01:08:24,000 --> 01:08:28,000
そして、次に、それは上に続行し、このケースをチェックします。

986
01:08:28,000 --> 01:08:31,000
しかし、この時点で、我々はそれがチェックを継続する必要はありません。

987
01:08:31,000 --> 01:08:35,000
幸いなことに、我々は、ここで中間点をリセットしていない

988
01:08:35,000 --> 01:08:39,000
そして我々はこのケースが成功しないことを知っています。

989
01:08:39,000 --> 01:08:44,000
しかし、我々は間違いなく、そこにあれば、他のを入れたい

990
01:08:44,000 --> 01:08:48,000
でも、その可能性がある - この場合

991
01:08:48,000 --> 01:08:52,000
我々は中間点を調整していないので、その違いを生むだろうか？

992
01:08:52,000 --> 01:08:54,000
いいえ、これらの例はすべて排他的であるためです。

993
01:08:54,000 --> 01:08:58,000
繰り返しますが、私の悪い。

994
01:08:58,000 --> 01:09:01,000
我々は、私が思うに、この他の場合は必要ありません。

995
01:09:01,000 --> 01:09:05,000
我々は試してみて、それを実行し、何が起こるか見てそれを与えることができる。

996
01:09:05,000 --> 01:09:08,000
建物は、エラーが発生しました。

997
01:09:08,000 --> 01:09:12,000
私はここで、これらのbとeのを残したので、それはおそらくです。

998
01:09:12,000 --> 01:09:14,000
私は一番上にそれらの任意のより多くを持っていますか？

999
01:09:14,000 --> 01:09:16,000
それはそれのように見えるものではありません。

1000
01:09:16,000 --> 01:09:20,000
我々は、ズームアウト、ビルド、

1001
01:09:20,000 --> 01:09:24,000
そこにそれが行くので、今、私たちは、15を検索する場合

1002
01:09:24,000 --> 01:09:28,000
はい。

1003
01:09:28,000 --> 01:09:30,000
私はズームインしましょう

1004
01:09:30,000 --> 01:09:33,000
15、はい。我々は再びそれを実行することができます。

1005
01:09:33,000 --> 01:09:36,000
実行、構築、ソースコードをアップロードする。

1006
01:09:36,000 --> 01:09:41,000
私たちは、13のような何かを検索することができます

1007
01:09:41,000 --> 01:09:45,000
私たちはプリントアウトは何も取得しないとので、それは私たちのためにあることを見つけていない。

1008
01:09:45,000 --> 01:09:51,000
それが私たちのリストにないので、それは素晴らしいことだ。

1009
01:09:51,000 --> 01:09:53,000
>> 我々は時間のうち今ある。

1010
01:09:53,000 --> 01:09:55,000
今週はこれそれになるだろう。

1011
01:09:55,000 --> 01:10:00,000
参加のおかげで、後でお会いしましょう​​。

1012
01:10:00,000 --> 01:10:02,000
>> [CS50.TV]