1
00:00:00,000 --> 00:00:00,030

2
00:00:00,030 --> 00:00:00,460
>> DAVIDマラン：すべての権利。

3
00:00:00,460 --> 00:00:01,094
我々は戻ってきました。

4
00:00:01,094 --> 00:00:04,260
プログラミング上のこのセグメントのだから何
私たちは物事のミックスで行うだろうと思っていました。

5
00:00:04,260 --> 00:00:06,340
一つは、少しを行います
何かのハンズオンの、

6
00:00:06,340 --> 00:00:08,690
もっと遊び心を使用してもかかわらず
プログラミングenvironment--

7
00:00:08,690 --> 00:00:11,620
の実証である1
アイデアの正確種類

8
00:00:11,620 --> 00:00:14,220
我々は、について話してきました
しかし、もう少し正式に。

9
00:00:14,220 --> 00:00:18,200
二つの一部を見て
より技術的な方法

10
00:00:18,200 --> 00:00:21,520
プログラマは、実際に解決するだろうということ
検索の問題のような問題

11
00:00:21,520 --> 00:00:24,530
私たちは前に見たと
また、より根本的に

12
00:00:24,530 --> 00:00:26,020
仕分けの興味深い問題。

13
00:00:26,020 --> 00:00:28,840
>> 私達はちょうど取りに行くからと仮定します
その電話帳がソートされたことを、

14
00:00:28,840 --> 00:00:31,980
それだけでそれが実際にある種類の
多くの異なる方法で困難な問題

15
00:00:31,980 --> 00:00:32,479
それを解決します。

16
00:00:32,479 --> 00:00:34,366
だから我々は、これらを使用します
問題のクラス

17
00:00:34,366 --> 00:00:36,740
その物事の代表
一般的に解決される可能性があります。

18
00:00:36,740 --> 00:00:38,980
そして、我々は話しましょう
いくつかの詳細には約何

19
00:00:38,980 --> 00:00:42,360
データと呼ばれstructures--
リンクリストのような手の込んだ方法

20
00:00:42,360 --> 00:00:46,290
ハッシュテーブルや木々こと
プログラマは、実際に希望

21
00:00:46,290 --> 00:00:48,890
使用して、一般的に使用
ホワイトボードにペイントします

22
00:00:48,890 --> 00:00:51,840
どのような彼または彼女の絵
実装するための思い描きます

23
00:00:51,840 --> 00:00:52,980
ソフトウェアのいくつかの作品。

24
00:00:52,980 --> 00:00:55,130
>> それでは、最初のハンズオン部分をやらせます。

25
00:00:55,130 --> 00:01:00,090
だからと汚い手を取得
環境と呼ばれるscratch.mit.edu。

26
00:01:00,090 --> 00:01:02,636
これは、我々が使用するツールです
私たちの学部クラスインチ

27
00:01:02,636 --> 00:01:04,510
それは設計されていますにもかかわらず、
12歳以上のため、

28
00:01:04,510 --> 00:01:07,570
我々は最高のためにそれを使用します
そのかなりの部分

29
00:01:07,570 --> 00:01:10,020
それは素晴らしい、楽しいので、
学習のグラフィカルな方法

30
00:01:10,020 --> 00:01:12,160
プログラミングについて少し何か。

31
00:01:12,160 --> 00:01:17,600
だからここであなたは、そのURLに向かいます
非常にこのようなページが表示されます、

32
00:01:17,600 --> 00:01:23,330
そして、先に行くとクリック
右上のスクラッチに参加

33
00:01:23,330 --> 00:01:28,300
ユーザ名とAを選択
パスワード、最終的に自分自身を取得

34
00:01:28,300 --> 00:01:29,970
account-- scratch.mit.edu。

35
00:01:29,970 --> 00:01:32,165

36
00:01:32,165 --> 00:01:34,665
私は私のようにこれを使用しようと思いました
最初にこれを示す機会。

37
00:01:34,665 --> 00:01:39,120
質問はハーフタイムに思いつきました
コー​​ドが実際にどのように見えるかについて。

38
00:01:39,120 --> 00:01:41,315
そして、私たちは話していました
Cについてブレーク中、

39
00:01:41,315 --> 00:01:45,060
でparticular--特に
古い言語の下位レベル。

40
00:01:45,060 --> 00:01:47,750
そして私はちょうどクイックをしました
Cコードを見つけるためにGoogle検索

41
00:01:47,750 --> 00:01:51,574
バイナリサーチのため、アルゴリズムは、我々
以前その電話帳を検索するために使用されます。

42
00:01:51,574 --> 00:01:54,240
この特定の例は、もちろん、
電話帳を検索しません。

43
00:01:54,240 --> 00:01:57,840
それはちょうどの全体の束を検索します
コンピュータのメモリ内の数字。

44
00:01:57,840 --> 00:02:01,000
しかし、あなただけのビジュアルを取得したい場合
どのような実際のプログラミングの意味

45
00:02:01,000 --> 00:02:05,370
、それが見えるように言語が見えます
このような少し何か。

46
00:02:05,370 --> 00:02:09,759
だから、約20プラスです
コー​​ドの30行程度、

47
00:02:09,759 --> 00:02:12,640
しかし、会話我々
休憩の上に持ちました

48
00:02:12,640 --> 00:02:16,000
実際にどのようにこの程度でした
0と1にモーフィングされます

49
00:02:16,000 --> 00:02:19,200
あなたはちょうどそれを元に戻すことができない場合
処理し、0と1から行きます

50
00:02:19,200 --> 00:02:20,210
バックコードに。

51
00:02:20,210 --> 00:02:22,620
>> 残念ながら、プロセス
そう変革であります

52
00:02:22,620 --> 00:02:24,890
それは非常に簡単だと口で言います。

53
00:02:24,890 --> 00:02:29,400
私は先に行って、実際になりました
そのプログラム、バイナリ検索、

54
00:02:29,400 --> 00:02:32,700
を介してゼロと1へ
プログラムは、私のコンパイラと呼ばれます

55
00:02:32,700 --> 00:02:34,400
私のMac上で右ここに持って起こります。

56
00:02:34,400 --> 00:02:37,850
そして、あなたは画面を見れば
ここでは、具体的に焦点を当て

57
00:02:37,850 --> 00:02:43,520
これらの中間の6つの列にのみ、
あなただけの0と1が表示されます。

58
00:02:43,520 --> 00:02:48,290
そして、それらは0と1であること
正確に検索プログラムを構成しています。

59
00:02:48,290 --> 00:02:53,720
>> そして、そのように5ビットの各チャンク、
ここでは0と1の各バイト、

60
00:02:53,720 --> 00:02:57,310
いくつかの命令を表します
典型的には、コンピュータの内部。

61
00:02:57,310 --> 00:03:00,730
そして、実際には、あなたが聞いた場合
マーケティングのスローガン "インテルインサイド」 - つまり、

62
00:03:00,730 --> 00:03:04,610
もちろん、あなたが持っていることを意味
コンピュータ内部のインテルCPUや脳。

63
00:03:04,610 --> 00:03:08,000
そして、それは、CPUがあることを意味するもの
あなたは、命令セットを持っていること、

64
00:03:08,000 --> 00:03:08,840
いわば。

65
00:03:08,840 --> 00:03:11,620
>> 多くの世界のすべてのCPU、
それらは、これらの日、インテル製の、

66
00:03:11,620 --> 00:03:13,690
有限を理解します
命令の数。

67
00:03:13,690 --> 00:03:18,690
そして、それらの命令は非常に低いレベルであります
これら二つの数字を追加します。

68
00:03:18,690 --> 00:03:22,560
一緒にこれらの2つの数値を乗算し、
ここからのデータのこの部分を移動

69
00:03:22,560 --> 00:03:27,340
ここでは、メモリ内に、これを保存します
ここからの情報は、メモリにここまで

70
00:03:27,340 --> 00:03:32,200
そのため、非常に、非常にそうforth--
低レベル、ほとんどの電子詳細。

71
00:03:32,200 --> 00:03:34,780
しかし、数学的なものと
結合された操作

72
00:03:34,780 --> 00:03:37,410
我々は前に述べたもので、
データの表現

73
00:03:37,410 --> 00:03:40,450
0と1のように、することができます
あなたはすべてを構築します

74
00:03:40,450 --> 00:03:44,180
コンピュータがいるかどうか、今日行うことができます
それは、テキスト、グラフィカル、ミュージカルです

75
00:03:44,180 --> 00:03:45,580
もしくはそうでないか。

76
00:03:45,580 --> 00:03:49,450
>> だから、これは得ることは非常に簡単です。
迅速の雑草で失われました。

77
00:03:49,450 --> 00:03:52,150
とがたくさんあり​​ます
構文上の課題

78
00:03:52,150 --> 00:03:56,630
それによってあなたが最も簡単にする場合は、
プログラムのタイプミスなしの愚かな

79
00:03:56,630 --> 00:03:57,860
全く動作します。

80
00:03:57,860 --> 00:04:00,366
だから代わりに使用して、
Cのような言語今朝、

81
00:04:00,366 --> 00:04:02,240
私はそれがだろうと思いました
実際に行うにはもっと楽しいです

82
00:04:02,240 --> 00:04:04,840
より視覚的な何か、どの
子供たちのために設計されている間

83
00:04:04,840 --> 00:04:08,079
実際には完璧な現れであります
実際のプログラミングの

84
00:04:08,079 --> 00:04:10,370
language--だけに起こります
テキストの代わりに画像を使用します

85
00:04:10,370 --> 00:04:11,710
これらのアイデアを表現します。

86
00:04:11,710 --> 00:04:15,470
>> だから、あなたは確かに持っていたら、
scratch.mit.edu上のアカウント、

87
00:04:15,470 --> 00:04:21,070
[作成]ボタンをクリックします。
サイトの左上にあります。

88
00:04:21,070 --> 00:04:24,620
そして、あなたはのような環境が表示されます
私は私の画面上に表示しようとしてよ1

89
00:04:24,620 --> 00:04:26,310
ここに。

90
00:04:26,310 --> 00:04:29,350
そして、私たちはほんの少しを過ごすだろう
ここで遊んで少しの時間。

91
00:04:29,350 --> 00:04:34,080
我々は、すべてのいくつかを解決することはできませんどうかを見てみましょう
以下の方法で問題が一緒に。

92
00:04:34,080 --> 00:04:39,420
>> それでは、あなたはこの内表示されます
environment--と実際にちょうどましょう

93
00:04:39,420 --> 00:04:40,050
私は一時停止します。

94
00:04:40,050 --> 00:04:42,680
誰もがここにいないですか？

95
00:04:42,680 --> 00:04:45,070
ここではありませんか？

96
00:04:45,070 --> 00:04:45,800
OK。

97
00:04:45,800 --> 00:04:49,030
だから、私はいくつかを指摘してみましょう
この環境の特性。

98
00:04:49,030 --> 00:04:55,024
>> 画面の左上にあるだから、我々
スクラッチのステージを持っている、いわば。

99
00:04:55,024 --> 00:04:57,440
スクラッチはない名前だけです
このプログラミング言語の、

100
00:04:57,440 --> 00:05:00,356
それはまた、猫の名前だこと
あなたはそこにオレンジ色にデフォルトで表示されます。

101
00:05:00,356 --> 00:05:02,160
彼は、ステージ上にあるので、
ずっと私が説明したような

102
00:05:02,160 --> 00:05:05,770
であるとして、以前のカメ
長方形のホワイトボード環境。

103
00:05:05,770 --> 00:05:09,800
この猫の世界は完全に閉じ込められています
そこにその矩形までトップに。

104
00:05:09,800 --> 00:05:12,210
>> 一方、右側の
ここで手側は、それはです

105
00:05:12,210 --> 00:05:15,610
ただ、スクリプトエリア、
白紙状態可能ならば。

106
00:05:15,610 --> 00:05:18,590
これは、私たちが書くしようとしているところであります
一瞬で我々のプログラム。

107
00:05:18,590 --> 00:05:22,935
その私たちはものとし、ビルディングブロック
このパズルをprogram--書き込むために使用

108
00:05:22,935 --> 00:05:25,310
ピース、あなたがwill--されている場合
途中で右ここのもの、

109
00:05:25,310 --> 00:05:27,500
そして、彼らは分類しています
機能別に。

110
00:05:27,500 --> 00:05:31,000
だから、例えば、私が先に行くつもりです
これらの少なくとも一つを示します。

111
00:05:31,000 --> 00:05:33,690
私は先に行くとクリックするつもりです
トップアップ制御カテゴリ。

112
00:05:33,690 --> 00:05:35,720
>> したがって、これらは、トップアップカテゴリです。

113
00:05:35,720 --> 00:05:39,410
私は制御カテゴリをクリックするつもりです。

114
00:05:39,410 --> 00:05:44,020
むしろ、私がイベントをクリックするつもりです
カテゴリ、非常に最初の1までトップ。

115
00:05:44,020 --> 00:05:47,790
そして、あなたも一緒に従うしたい場合
我々はこれを行うように、あなたはに非常に歓迎しています。

116
00:05:47,790 --> 00:05:52,180
私はこれをクリックしてドラッグするつもりです
第1、「緑の旗をクリック。 "

117
00:05:52,180 --> 00:05:58,410
そして、私はちょうどそれをドロップするつもりです
大体私の空白のスレートの上部にあります。

118
00:05:58,410 --> 00:06:01,450
>> そして、スクラッチのいいものです
で、このパズルのピース、ときに

119
00:06:01,450 --> 00:06:04,560
他のパズルと連動
作品は、文字通り何をするつもりされています

120
00:06:04,560 --> 00:06:06,460
これらのパズルのピースを行うに言います。

121
00:06:06,460 --> 00:06:09,710
だから、例えば、スクラッチは権利であります
今彼の世界の真ん中インチ

122
00:06:09,710 --> 00:06:14,660
私は先に行くと選択するつもりです
今、のは言わせ、モーションカテゴリー、

123
00:06:14,660 --> 00:06:18,000
あなたは何したい場合は
モーションカテゴリをsame--。

124
00:06:18,000 --> 00:06:20,430
そして今、私は、全体を持って気づきます
ここにパズルのピースの束

125
00:06:20,430 --> 00:06:23,370
それは、再び、一種の彼らが言う何をすべきか。

126
00:06:23,370 --> 00:06:28,110
そして、私は先に行くと、ドラッグして、するつもりです
右ここの上に移動ブロックをドロップします。

127
00:06:28,110 --> 00:06:31,860
>> そして、それとすぐにあなたが得るように注意してください
「緑の旗の下に近接しています

128
00:06:31,860 --> 00:06:34,580
」ボタン、通知をクリックしました
どのように白い線が表示され、

129
00:06:34,580 --> 00:06:36,950
それはほとんどだかのように
磁気、それはそこに行きたいと考えています。

130
00:06:36,950 --> 00:06:43,070
ただ手放す、それがスナップされます
一緒にと形状が一致します。

131
00:06:43,070 --> 00:06:46,620
そして今、あなたはおそらく、ほとんどすることができます
私たちはこれを行っているところだと思います。

132
00:06:46,620 --> 00:06:51,570
>> あなたがスクラッチステージを見れば
こっちとその上部に見て、

133
00:06:51,570 --> 00:06:55,142
あなたは、赤色光を参照してくださいよ、
記号、緑の旗を停止します。

134
00:06:55,142 --> 00:06:57,100
そして、私は先に行くつもりです
そして、私のscreen--を見ます

135
00:06:57,100 --> 00:06:58,460
あなたができれば、ちょっと。

136
00:06:58,460 --> 00:07:01,960
私はクリックするつもりです
今緑の旗、

137
00:07:01,960 --> 00:07:07,850
彼は10のステップであると思われるものを移動しました
または、画面上の10ピクセル、10ドット、。

138
00:07:07,850 --> 00:07:13,390
>> そしてその結果、エキサイティングではありません、
しかし、私が提案してみましょう

139
00:07:13,390 --> 00:07:17,440
だけでも、これを教えることなく、
自分独自のintuition--レットを使用して、

140
00:07:17,440 --> 00:07:22,560
私は、あなたがどの​​ように把握することを提案します
右ステージからスクラッチ散歩をします。

141
00:07:22,560 --> 00:07:28,700
彼は右側のための方法を作る持っています
画面、右にすべての方法。

142
00:07:28,700 --> 00:07:32,200
私はあなたに瞬間を挙げてみましょう
またはようにと格闘します。

143
00:07:32,200 --> 00:07:37,681
あなたが見てみたいことがあります
ブロックの他のカテゴリで。

144
00:07:37,681 --> 00:07:38,180
大丈夫。

145
00:07:38,180 --> 00:07:41,290
だから私たちが持っているときに、要約します
緑色のフラグはここをクリック

146
00:07:41,290 --> 00:07:44,850
そして、10の手順をされている移動
命令だけ、毎回私が

147
00:07:44,850 --> 00:07:46,720
緑の旗をクリックして、何が起きているのでしょうか？

148
00:07:46,720 --> 00:07:50,070
まあ、それは私のプログラムを実行しています。

149
00:07:50,070 --> 00:07:52,450
だから私はこれを行うことができます
多分手動で10倍、

150
00:07:52,450 --> 00:07:55,130
これは少し感じています
いわば、少しハック、

151
00:07:55,130 --> 00:07:57,480
それによって、私は本当にないんだけど
問題を解決します。

152
00:07:57,480 --> 00:08:00,530
私は再びしようとしていると
何度も何度も何度も

153
00:08:00,530 --> 00:08:03,180
私は一種の誤っまで
ディレクティブを達成

154
00:08:03,180 --> 00:08:05,560
私は以前に達成するために着手しています。

155
00:08:05,560 --> 00:08:08,200
>> しかし、我々は我々のから知っています
擬似コード以前があること

156
00:08:08,200 --> 00:08:11,870
ループのプログラミングでこの概念、
何度も何度も何かをすること。

157
00:08:11,870 --> 00:08:14,888
そして、私はそれをあなたの束を見ました
どのようなパズルピースのために達し？

158
00:08:14,888 --> 00:08:17,870

159
00:08:17,870 --> 00:08:18,730
まで繰り返します。

160
00:08:18,730 --> 00:08:21,400
だから我々は何かを行うことができます
以下のようになるまで繰り返します。

161
00:08:21,400 --> 00:08:23,760
そして、あなたは正確になるまで何を繰り返しましたか？

162
00:08:23,760 --> 00:08:27,720

163
00:08:27,720 --> 00:08:28,540
>> OK。

164
00:08:28,540 --> 00:08:31,974
そして、私はだ1で行こう
ちょっとやや単純。

165
00:08:31,974 --> 00:08:33,140
私が先に行くと、これを実行してみましょう。

166
00:08:33,140 --> 00:08:35,559
あなたが持っている可能性があるため、それを注意してください
コントロールの下で発見され、

167
00:08:35,559 --> 00:08:38,409
この反復ブロックは、そこにあります
それは大きいですようには見えません。

168
00:08:38,409 --> 00:08:41,039
ではない多くの部屋があります
これら二つの黄色の線の間。

169
00:08:41,039 --> 00:08:43,539
しかし、あなたのいくつかは持っている可能性がありますように
あなたはドラッグ＆ドロップすれば、気づきました、

170
00:08:43,539 --> 00:08:45,150
それは形を埋めるために成長する様子がわかり。

171
00:08:45,150 --> 00:08:46,274
>> そして、あなたはさらに多くを詰め込むことができます。

172
00:08:46,274 --> 00:08:48,670
それはちょうど場合に成長しておこう
あなたはドラッグして上にカーソルを合わせます。

173
00:08:48,670 --> 00:08:51,110
そして、私は何かわかりません
ここで最高の、そうしましょう

174
00:08:51,110 --> 00:08:54,760
私は、少なくともために、5回繰り返します
例えば、その後、ステージに戻って

175
00:08:54,760 --> 00:08:56,720
そして、緑の旗をクリックします。

176
00:08:56,720 --> 00:08:59,110
そして今、それはかなりありません注意してください。

177
00:08:59,110 --> 00:09:02,400
>> 今、あなたのいくつかは、提案された、として
ビクトリアはちょうど、10回繰り返しました。

178
00:09:02,400 --> 00:09:05,140
そして、それは一般的にありません
彼にすべての方法を取得し、

179
00:09:05,140 --> 00:09:10,510
しかし、より堅牢な存在ではないでしょう
任意に考え出すより道

180
00:09:10,510 --> 00:09:12,640
どのように多くの動きを作るには？

181
00:09:12,640 --> 00:09:17,680
何より良いブロックかもしれません
より10倍はあることを繰り返しますか？

182
00:09:17,680 --> 00:09:20,380
>> ええ、なぜ永遠に何かをしていませんか？

183
00:09:20,380 --> 00:09:24,390
そして今、私はこのパズルのピースを移動させましょう
そこに内側と、この1を取り除きます。

184
00:09:24,390 --> 00:09:28,300
今どんなにスクラッチに気付きます
開始、彼は端に行きます。

185
00:09:28,300 --> 00:09:30,700
そしてありがたいことに、MIT、
人だけで、スクラッチを作ります

186
00:09:30,700 --> 00:09:33,190
必ず彼は決してことになります
完全に消失します。

187
00:09:33,190 --> 00:09:35,360
あなたはいつも彼のしっぽをつかむことができます。

188
00:09:35,360 --> 00:09:37,680
>> そして、ちょうど直感的に、
なぜ彼は動き続けるのでしょうか？

189
00:09:37,680 --> 00:09:38,892
ここで何が起こっていますか？

190
00:09:38,892 --> 00:09:41,440

191
00:09:41,440 --> 00:09:43,824
彼が停止しているようだが、
その後、私がピックアップし、ドラッグした場合

192
00:09:43,824 --> 00:09:45,240
彼はあそこに行きたいし続けます。

193
00:09:45,240 --> 00:09:46,123
何故ですか？

194
00:09:46,123 --> 00:09:51,610

195
00:09:51,610 --> 00:09:54,360
本当に、コンピュータは文字通りです
あなたがすることを教え何をするつもり。

196
00:09:54,360 --> 00:09:58,380
あなたがそれを言ったのであれば、以前の実行
永遠なものを、次の、10のステップを移動し、

197
00:09:58,380 --> 00:10:01,860
行くと続けるために起こっています
私は赤のストップサインを打つまで

198
00:10:01,860 --> 00:10:04,620
そして、完全にプログラムを停止します。

199
00:10:04,620 --> 00:10:06,610
>> だから、あなたがしなかった場合でも、
これを行うには、どのように私でし

200
00:10:06,610 --> 00:10:09,510
より高速なスクラッチを動かします
画面上？

201
00:10:09,510 --> 00:10:12,060

202
00:10:12,060 --> 00:10:13,280
より多くのステップ、右か？

203
00:10:13,280 --> 00:10:15,710
だからではなく、10を行います
一度、なぜ我々はしないでください

204
00:10:15,710 --> 00:10:20,100
先に行くと、それを変更to--
あなたは、50は何propose--でしょうか？

205
00:10:20,100 --> 00:10:24,410
だから今、私は緑をクリックするつもりです
フラグは、実際、彼は本当に速い行きます。

206
00:10:24,410 --> 00:10:27,180
>> これは、もちろん、単にあります
アニメーションの現れ。

207
00:10:27,180 --> 00:10:28,060
アニメーションとは何ですか？

208
00:10:28,060 --> 00:10:33,090
それはちょうどあなたの人間のaを示しています
本当に静止画の全体の束、

209
00:10:33,090 --> 00:10:34,160
本当に、本当に速いです。

210
00:10:34,160 --> 00:10:36,500
だから私たちは言っている場合
彼はより多くのステップを移動し、

211
00:10:36,500 --> 00:10:39,750
私達はちょうど効果がになる持っています
彼が画面に表示されている変更

212
00:10:39,750 --> 00:10:42,900
すべてのより迅速に単位時間あたりの。

213
00:10:42,900 --> 00:10:46,454
>> 私が提案した今、次の課題
彼はエッジを跳ね返ることでした。

214
00:10:46,454 --> 00:10:49,120
そして、何パズル知らず
結構ですので、作品はexist--

215
00:10:49,120 --> 00:10:53,030
あなたがに取得しない場合
何challenge--のステージ

216
00:10:53,030 --> 00:10:54,280
あなたは直感的に何をしたいですか？

217
00:10:54,280 --> 00:10:58,030
どのように我々は彼が立ち直るだろうと
前後、左右の？

218
00:10:58,030 --> 00:11:02,630

219
00:11:02,630 --> 00:11:03,810
>> うん。

220
00:11:03,810 --> 00:11:05,680
だから我々はいくつかの種類を必要とします
条件、および私たちの

221
00:11:05,680 --> 00:11:09,710
のように、条件を持っているように見えます
制御カテゴリの下で、話します。

222
00:11:09,710 --> 00:11:14,110
これらのブロックのどの
我々は、おそらくしたいですか？

223
00:11:14,110 --> 00:11:15,200
うん、多分」であれば、その後。」

224
00:11:15,200 --> 00:11:18,780
だから、黄色のブロック間のことに気付きます
私たちは、この「場合」があり、ここにあります

225
00:11:18,780 --> 00:11:23,920
その意志またはこの "であれば、他の"ブロック
私たちはこれを行うための意思決定を行うことができ

226
00:11:23,920 --> 00:11:25,000
またはそれを行うには。

227
00:11:25,000 --> 00:11:27,380
そして、あなたはそれらを巣を均等することができます
複数の物事を行います。

228
00:11:27,380 --> 00:11:34,910
それともあなたはまだここに行っていないしている場合は、
センシングカテゴリに先に行きます

229
00:11:34,910 --> 00:11:39,612
and--それがここにある場合を見てみましょう。

230
00:11:39,612 --> 00:11:43,050

231
00:11:43,050 --> 00:11:52,050
>> それではブロックは、ここで役に立つかもしれません
彼はステージからだかどうかを検出するには？

232
00:11:52,050 --> 00:11:56,740
うん、これらのブロックのいくつかに気づきます
いわば、パラメータ化することができます。

233
00:11:56,740 --> 00:12:00,706
これらは、一種のではなく、カスタマイズすることができます
HTMLとは異なり、昨日の属性を持ちます、

234
00:12:00,706 --> 00:12:03,330
ここで、それらの属性の種類の
タグの動作をカスタマイズ。

235
00:12:03,330 --> 00:12:08,880
同様にここで、私はこの感動をつかむことができます
ブロックと変化と質問を、

236
00:12:08,880 --> 00:12:11,500
あなたは、マウスに触れています
カーソルなどのポインタ

237
00:12:11,500 --> 00:12:13,250
または、エッジに触れていますか？

238
00:12:13,250 --> 00:12:15,210
>> だから私はで行くと、これをやらせます。

239
00:12:15,210 --> 00:12:18,130
私は一瞬ズームアウトするつもりです。

240
00:12:18,130 --> 00:12:21,320
私はこのパズルのピースをつかむしてみましょう
ここでは、このパズルのピースこの、

241
00:12:21,320 --> 00:12:24,570
そして、私はまぜこぜするつもりです
それまでちょっと。

242
00:12:24,570 --> 00:12:27,620
私は、これを移動するつもりです
エッジに触れることに変更し、

243
00:12:27,620 --> 00:12:38,590
これを行うと私は運動するつもりです。

244
00:12:38,590 --> 00:12:40,490
そこでここではいくつかの成分です。

245
00:12:40,490 --> 00:12:42,570
私は私が望むすべてを持っていると思います。

246
00:12:42,570 --> 00:12:47,710
>> 誰かがどのように私を提案したいと思います
これらは多分上から下へ接続することができます

247
00:12:47,710 --> 00:12:52,020
有するの問題を解決するために
スクラッチ移動に右へ左へ右

248
00:12:52,020 --> 00:12:57,020
それぞれ、左へ左から右へ
時間はちょうど壁に跳ね返っ？

249
00:12:57,020 --> 00:12:58,050
私は何をしたいですか？

250
00:12:58,050 --> 00:13:01,097
どのブロック私はに接続する必要があります
「グリーンフラッグが最初にクリックされましたか」？

251
00:13:01,097 --> 00:13:04,060

252
00:13:04,060 --> 00:13:06,200
>> OK、それでは始めましょう "永遠に。」

253
00:13:06,200 --> 00:13:07,170
次に何が内側に行きますか？

254
00:13:07,170 --> 00:13:10,290
他の誰か。

255
00:13:10,290 --> 00:13:11,850
OK、ステップを移動します。

256
00:13:11,850 --> 00:13:12,350
大丈夫。

257
00:13:12,350 --> 00:13:14,470
じゃあ何？

258
00:13:14,470 --> 00:13:15,120
それでは場合。

259
00:13:15,120 --> 00:13:17,720
そして、それが見えていても、気付きます
しっかりと一緒に挟まれ、

260
00:13:17,720 --> 00:13:19,500
それだけで埋めるために成長します。

261
00:13:19,500 --> 00:13:21,500
それはちょうど私がそれをしたい場所にジャンプします。

262
00:13:21,500 --> 00:13:25,920
>> そして、私は間に何を置きますか
であれば、その後？

263
00:13:25,920 --> 00:13:27,180
おそらく「場合のエッジに触れます。」

264
00:13:27,180 --> 00:13:31,800
そして、通知は、再び、それはあまりにも大きいです
それのために、それが埋めるために成長します。

265
00:13:31,800 --> 00:13:35,002
そして、15度を回しますか？

266
00:13:35,002 --> 00:13:35,710
どのように何度？

267
00:13:35,710 --> 00:13:38,800

268
00:13:38,800 --> 00:13:41,196
うん、だから180が回転します
私の周りのすべての方法。

269
00:13:41,196 --> 00:13:42,570
だから私はこの権利を得た場合を見てみましょう。

270
00:13:42,570 --> 00:13:43,930
私はズームアウトしてみましょう。

271
00:13:43,930 --> 00:13:45,130
>> 私はスクラッチアップをドラッグしてみましょう。

272
00:13:45,130 --> 00:13:50,030
そこで彼は、少し歪みました
今、それは大丈夫です。

273
00:13:50,030 --> 00:13:52,231
どのように私は簡単に彼をリセットすることができますか？

274
00:13:52,231 --> 00:13:59,879

275
00:13:59,879 --> 00:14:01,045
私は少しカンニングするつもりです。

276
00:14:01,045 --> 00:14:04,074

277
00:14:04,074 --> 00:14:05,990
だから私は別のものを追加しています
ブロックは、単に明確にすること。

278
00:14:05,990 --> 00:14:08,424
私は彼が90度を指すようにしたいです
デフォルトでは右に、

279
00:14:08,424 --> 00:14:10,840
私はちょうど彼に言うつもりです
プログラムでそれを行うには。

280
00:14:10,840 --> 00:14:11,632
さあ、いくぞ。

281
00:14:11,632 --> 00:14:14,740

282
00:14:14,740 --> 00:14:15,740
私たちはそれを行っているように見えます。

283
00:14:15,740 --> 00:14:19,980
それはので、少し奇妙なことです
彼は逆さまに歩いています。

284
00:14:19,980 --> 00:14:21,250
バグことを呼ぶことにしましょう​​。

285
00:14:21,250 --> 00:14:22,120
それは間違いです。

286
00:14:22,120 --> 00:14:27,320
バグはA、プログラム内の誤りです
私、人間は、作られた論理エラー。

287
00:14:27,320 --> 00:14:28,985
なぜ彼は逆さまに起こっていますか？

288
00:14:28,985 --> 00:14:33,560

289
00:14:33,560 --> 00:14:35,250
MITは、台無しにまたは私がやったのか？

290
00:14:35,250 --> 00:14:38,840

291
00:14:38,840 --> 00:14:42,550
>> ええ、私は意味、それはMITのではありません
障害が発生しました。彼らは私にパズルのピースを与えました

292
00:14:42,550 --> 00:14:44,970
それは、度のいくつかの数を回すと言います。

293
00:14:44,970 --> 00:14:47,672
ビクトリアの提案で、
私は180度回転です、

294
00:14:47,672 --> 00:14:48,880
これは右の直感です。

295
00:14:48,880 --> 00:14:53,700
しかし、文字通り180度回転
180度回転手段、

296
00:14:53,700 --> 00:14:55,860
それは本当にありません
私が欲しいもの、明らかに。

297
00:14:55,860 --> 00:14:58,026
少なくとも彼は中だから
この2次元の世界、

298
00:14:58,026 --> 00:15:00,740
そのように回転が本当に起こっています
逆さまに彼を反転します。

299
00:15:00,740 --> 00:15:04,030
>> 私はおそらく何のブロックを使用したいです
代わりに、あなたがここで見るものに基づいて？

300
00:15:04,030 --> 00:15:11,890

301
00:15:11,890 --> 00:15:14,790
我々はこれをどのように解決するのでしょうか？

302
00:15:14,790 --> 00:15:18,380
ええ、私たちは指すことが
反対方向インチ

303
00:15:18,380 --> 00:15:22,300
そして、実際にあっても、それはです
十分であることを行っていません、

304
00:15:22,300 --> 00:15:26,410
我々は唯一のハードコードすることができるので
左または右向きに。

305
00:15:26,410 --> 00:15:27,920
>> あなたは、私たちは何ができるか知っていますか？

306
00:15:27,920 --> 00:15:30,160
我々が持っているように見えます
こちらの都合ブロック。

307
00:15:30,160 --> 00:15:32,987
私が見るにはズームインしている場合、参照してください。
何かここでは好きですか？

308
00:15:32,987 --> 00:15:36,120

309
00:15:36,120 --> 00:15:40,020
MITが持っているようなので、それが見えます
抽象化は、ここに建てられました。

310
00:15:40,020 --> 00:15:45,440
このブロックは、同等であると思われます
これに他のブロック、複数の？

311
00:15:45,440 --> 00:15:49,510
>> この1ブロックは、同等であると思われます
このブロックの全体のトリオへ

312
00:15:49,510 --> 00:15:50,880
私たちがここに持っています。

313
00:15:50,880 --> 00:15:54,670
だから、私は私を簡素化することができ判明します
そのすべてを取り除くことにより、プログラム

314
00:15:54,670 --> 00:15:58,270
そして、ここだけでこれを置きます。

315
00:15:58,270 --> 00:16:01,620
そして今、彼はまだ少しです
バギー、それは今のところ大丈夫です。

316
00:16:01,620 --> 00:16:03,370
私たちは、それがあることに残しておきます。

317
00:16:03,370 --> 00:16:06,000
しかし、私のプログラムは偶数であります
単純な、この、あまりにも、

318
00:16:06,000 --> 00:16:09,060
代表になります
programming--でゴール

319
00:16:09,060 --> 00:16:13,430
理想的としてあなたのコードを作ることです
単純な、可能な限りコンパクトなように、

320
00:16:13,430 --> 00:16:15,650
まだのようでありながら
できるだけ可読。

321
00:16:15,650 --> 00:16:20,310
あなたはそれがとても簡潔にする必要はありません
それは難しいことを理解します。

322
00:16:20,310 --> 00:16:22,826
>> しかし、私が交換しまし気付きます
1と3のブロック、

323
00:16:22,826 --> 00:16:24,200
それは間違いなく良いことです。

324
00:16:24,200 --> 00:16:27,280
私は概念を抽象化しました
あなたがしているかどうかをチェックします

325
00:16:27,280 --> 00:16:29,120
わずか1ブロックとエッジで。

326
00:16:29,120 --> 00:16:31,520
今、私たちは、実際には、これで楽しみを持つことができます。

327
00:16:31,520 --> 00:16:35,790
これは、あまり追加しません
知的値ではなく、遊び心の値。

328
00:16:35,790 --> 00:16:39,730
私は先に行くつもりです
ここでこの音をつかみます。

329
00:16:39,730 --> 00:16:42,900

330
00:16:42,900 --> 00:16:46,420
だから私は先に行かせて、私を聞かせて
瞬間のためのプログラムを停止します。

331
00:16:46,420 --> 00:16:52,070
私は次のように記録するつもりです、
私のマイクへのアクセスを可能にします。

332
00:16:52,070 --> 00:16:53,181
>> さあ。

333
00:16:53,181 --> 00:16:53,680
痛いです。

334
00:16:53,680 --> 00:16:58,710

335
00:16:58,710 --> 00:17:01,140
それでは、もう一度これを試してみましょう。

336
00:17:01,140 --> 00:17:02,279
さあ。

337
00:17:02,279 --> 00:17:03,570
[OK]を、私は間違ったことを記録しました。

338
00:17:03,570 --> 00:17:04,580
さあ。

339
00:17:04,580 --> 00:17:05,080
痛いです。

340
00:17:05,080 --> 00:17:07,910

341
00:17:07,910 --> 00:17:08,800
痛いです。

342
00:17:08,800 --> 00:17:09,300
大丈夫。

343
00:17:09,300 --> 00:17:10,791
今、私はそれを取り除くために必要があります。

344
00:17:10,791 --> 00:17:11,290
大丈夫。

345
00:17:11,290 --> 00:17:13,950
>> だから今私が持っています
ただの記録「痛いです。」

346
00:17:13,950 --> 00:17:18,040
だから今、私は行くつもりです
先にこの「痛い。」と呼んで

347
00:17:18,040 --> 00:17:20,270
私は戻って行くつもりです
今、私のスクリプト、およびへ

348
00:17:20,270 --> 00:17:25,460
通知と呼ばれるこのブロックがあります
「痛い。 "音"ニャー "を再生したり、サウンドを再生

349
00:17:25,460 --> 00:17:28,920
私はこれをドラッグします。また、どこです
私はコミカルな効果のためにこれを置く必要がありますか？

350
00:17:28,920 --> 00:17:31,740

351
00:17:31,740 --> 00:17:37,860
うん、だから今は一種のです
今、このblock--のでバギー、

352
00:17:37,860 --> 00:17:42,050
気づくどのようにこの "エッジであれば、
バウンスは、「自己完結型の一種です。

353
00:17:42,050 --> 00:17:43,704
だから私はこの問題を解決する必要があります。

354
00:17:43,704 --> 00:17:44,870
私が先に行くと、これを実行してみましょう。

355
00:17:44,870 --> 00:17:48,630
私は、このを取り除くしようと戻って
私たちの元に、より計画的な

356
00:17:48,630 --> 00:17:49,870
機能性。

357
00:17:49,870 --> 00:18:01,080
「エッジに触れる場合は、「だから私はしたいです
ビクトリアが提案されているように、オンにし、

358
00:18:01,080 --> 00:18:02,480
180度。

359
00:18:02,480 --> 00:18:05,497
そして、私はプレーしたいです
音が「痛いですか」？

360
00:18:05,497 --> 00:18:11,800

361
00:18:11,800 --> 00:18:15,580
>> うん、それは外だ気付きます
その黄色のブロック。

362
00:18:15,580 --> 00:18:17,680
だから、これは、あまりにも、だろう
バグが、私はそれを気づきました。

363
00:18:17,680 --> 00:18:21,290
だから私はここにそれをドラッグするつもりです、
予告は今では内部のだ」であれば。」

364
00:18:21,290 --> 00:18:24,250
したがって、この一種である "場合"
以下のようなアーム状ブロットの

365
00:18:24,250 --> 00:18:26,260
それだけに起こっています
その中に何を行います。

366
00:18:26,260 --> 00:18:30,216
だから今私がズームアウトした場合
annoying--のリスク

367
00:18:30,216 --> 00:18:32,860

368
00:18:32,860 --> 00:18:36,470
>> COMPUTER：痛い、痛い、痛いです。

369
00:18:36,470 --> 00:18:39,910
>> DAVIDマラン：そして、それ
ただ永遠に移動します。

370
00:18:39,910 --> 00:18:44,160
今だけの事を加速します
ここでは、私が先に行くと開いてみましょう、

371
00:18:44,160 --> 00:18:50,460
それでは、私はいくつかに行こうsay--う
クラスから自分のものの。

372
00:18:50,460 --> 00:18:53,000

373
00:18:53,000 --> 00:19:00,220
とのは、このことを言わせて、私が開いてみましょう
私たちの指導員のいずれかによって作られたもの

374
00:19:00,220 --> 00:19:01,500
数年前。

375
00:19:01,500 --> 00:19:04,732
だからの一部が思い出すかもしれません
往年からこのゲーム、

376
00:19:04,732 --> 00:19:05,940
そしてそれは実際に顕著です。

377
00:19:05,940 --> 00:19:08,190
私たちがやったにもかかわらず
今、プログラムの最も簡単な、

378
00:19:08,190 --> 00:19:09,980
それでは、どのようにこれを考えてみましょう
実際のように見えます。

379
00:19:09,980 --> 00:19:10,650
私はプレーをヒットしてみましょう。

380
00:19:10,650 --> 00:19:14,210

381
00:19:14,210 --> 00:19:18,980
>> だから、このゲームでは、我々が持っています
カエル、矢印を使用してkeys--

382
00:19:18,980 --> 00:19:23,340
彼は私よりも大きなステップを取りますremember--
私は、このカエルを制御することができます。

383
00:19:23,340 --> 00:19:29,630
そして目標は、忙しい渡って取得することです
車に実行せずに道路。

384
00:19:29,630 --> 00:19:34,735
そして、私はここに行けばのはsee--ましょうI
ログがによってスクロールするのを待つ必要があります。

385
00:19:34,735 --> 00:19:38,130

386
00:19:38,130 --> 00:19:39,274
これはバグのように感じています。

387
00:19:39,274 --> 00:19:42,240

388
00:19:42,240 --> 00:19:43,495
これはバグの一種です。

389
00:19:43,495 --> 00:19:45,980

390
00:19:45,980 --> 00:19:46,480
大丈夫。

391
00:19:46,480 --> 00:19:51,550
私は、ここではこれによ
そこに、次にあなたが保ちます

392
00:19:51,550 --> 00:19:54,100
あなたはすべてを取得するまで行きます
ユリのパッドにカエル。

393
00:19:54,100 --> 00:19:55,920
さて、これは見えるかもしれません
すべてのより複雑な、

394
00:19:55,920 --> 00:19:57,840
しかし、それでは、破るために試してみましょう
精神的にこのダウン

395
00:19:57,840 --> 00:20:00,040
そして、口頭でそのコンポーネントブロックへ。

396
00:20:00,040 --> 00:20:03,910
だから、おそらくパズルがあります
我々はまだ見ていない作品

397
00:20:03,910 --> 00:20:07,440
それはキーストロークに応答しています、
物事に私はキーボードで打ちます。

398
00:20:07,440 --> 00:20:11,660
>> だから、おそらくいくつかの種類があります
キーがアップ等しい場合、言いブロック、

399
00:20:11,660 --> 00:20:15,965
その後Scratch--で何かを
多分10の手順をこのように移動します。

400
00:20:15,965 --> 00:20:20,240
ダウンキーを押すと、10段階を移動
この方法、または左キーは、10ステップを移動します

401
00:20:20,240 --> 00:20:21,710
このように、10は、ステップ。

402
00:20:21,710 --> 00:20:23,644
私ははっきりとカエルに猫になってきました。

403
00:20:23,644 --> 00:20:26,060
だから、ちょうどどこです
スクラッチ・コールit--我々として衣装、

404
00:20:26,060 --> 00:20:28,440
ちょうどカエルの絵を輸入しました。

405
00:20:28,440 --> 00:20:29,570
>> しかし、他に何が起こっているのでしょうか？

406
00:20:29,570 --> 00:20:32,794
他にどのようなコードの行、
どのような他のパズルのピース

407
00:20:32,794 --> 00:20:35,460
ブレイクした、私たちの指導員、
どうやら、このプログラムで使用？

408
00:20:35,460 --> 00:20:38,320

409
00:20:38,320 --> 00:20:42,730
何がすべてのものを作っていますmove--
どのようなプログラミングが構築しますか？

410
00:20:42,730 --> 00:20:44,950
>> モーション、sure--ので、
確かに、ブロックを移動します。

411
00:20:44,950 --> 00:20:49,330
そして、その移動ブロックは何ですか
内側に、最も可能性が高いですか？

412
00:20:49,330 --> 00:20:52,850
うん、ループのいくつかの種類、多分
永遠に多分繰り返し、ブロックblock--

413
00:20:52,850 --> 00:20:54,070
ブロックされるまで繰り返します。

414
00:20:54,070 --> 00:20:57,330
そしてそれは、ログを作っているものだと
ユリ、パッドと他のすべての動き

415
00:20:57,330 --> 00:20:57,990
行ったり来たり。

416
00:20:57,990 --> 00:21:00,270
それだけで無限に起こっています。

417
00:21:00,270 --> 00:21:03,180
>> なぜ車の一部です
他より速く移動しますか？

418
00:21:03,180 --> 00:21:06,607
これらのプログラムについて異なるとは何ですか？

419
00:21:06,607 --> 00:21:09,690
ええ、おそらくそれらのいくつかは、服用しています
一度、そのうちのいくつかでより多くのステップ

420
00:21:09,690 --> 00:21:10,690
一度に少ない工程。

421
00:21:10,690 --> 00:21:14,670
そして、視覚効果
遅い対高速です。

422
00:21:14,670 --> 00:21:16,030
>> 起こったあなたはどう思いますか？

423
00:21:16,030 --> 00:21:19,700
私は私のカエルを持ってすべての方法
通りや川を渡って

424
00:21:19,700 --> 00:21:23,560
ユリパッド上に、何か
注目すべきは起こりました。

425
00:21:23,560 --> 00:21:26,540
何が、すぐに私はそれをしたとして起こったのか？

426
00:21:26,540 --> 00:21:27,210
それは停止しました。

427
00:21:27,210 --> 00:21:29,680
そのカエルを止め、
私は2番目のカエルを得ました。

428
00:21:29,680 --> 00:21:33,155
だから何の構築物でなければなりません
そこに使用され、どのような機能？

429
00:21:33,155 --> 00:21:36,020

430
00:21:36,020 --> 00:21:38,660
>> うん、そうのいくつかの種類があります
あまりにも、そこまでの状態」であれば」。

431
00:21:38,660 --> 00:21:41,909
そして、それは我々がthis--表示されませんでしたout--なります
それそこに他のブロックがあります

432
00:21:41,909 --> 00:21:45,300
あなたが触れている場合は、言うことができます
画面上の別の事、

433
00:21:45,300 --> 00:21:47,720
あなたはユリパッドに触れている場合、「その後」。

434
00:21:47,720 --> 00:21:50,810
そして、それはときに我々のです
第二のカエルを表示させます。

435
00:21:50,810 --> 00:21:54,969
だから、このゲームは確かにあるにもかかわらず
一見にもかかわらず、非常に時代遅れ

436
00:21:54,969 --> 00:21:58,010
そんなにそこon--行くとブレイクの
2分でこれをかき立てるていませんでした、

437
00:21:58,010 --> 00:22:00,390
それはおそらく、いくつかの彼を連れて行きました
このゲームを作成するための時間

438
00:22:00,390 --> 00:22:03,850
彼の記憶やビデオに基づきます
それの往年のバージョンの。

439
00:22:03,850 --> 00:22:07,940
しかし、これらのささいなことのすべて
分離して画面上に行きます

440
00:22:07,940 --> 00:22:11,550
これらの非常にシンプルに煮詰めます
constructs--動きまたは文

441
00:22:11,550 --> 00:22:15,519
我々が議論してきたように、ループし、
条件、それはそれについてです。

442
00:22:15,519 --> 00:22:17,060
他のいくつかの愛好家の特徴があります。

443
00:22:17,060 --> 00:22:19,130
それらのいくつかは、純粋です
美的や音響、

444
00:22:19,130 --> 00:22:20,964
音のように私はと遊びました。

445
00:22:20,964 --> 00:22:23,380
しかし、ほとんどの部分は、あなた
この言語、スクラッチを持っています、

446
00:22:23,380 --> 00:22:25,350
基本のすべて
そのあなたのビルディングブロック

447
00:22:25,350 --> 00:22:29,280
CやJava、JavaScriptで持っています、
PHPやRuby、Pythonの、

448
00:22:29,280 --> 00:22:32,960
そして、他の言語の任意の数。

449
00:22:32,960 --> 00:22:36,720
スクラッチについてのご質問？

450
00:22:36,720 --> 00:22:37,220
大丈夫。

451
00:22:37,220 --> 00:22:40,303
だから我々は、スクラッチに深くに飛び込むません
あなたはこの週末歓迎しているものの、

452
00:22:40,303 --> 00:22:42,860
あなたが子供を持っている場合は特に、または
姪と甥など、

453
00:22:42,860 --> 00:22:44,220
スクラッチにそれらを導入します。

454
00:22:44,220 --> 00:22:47,960
それは実際に素晴らしく遊び心です
環境と、その著者が言うように、

455
00:22:47,960 --> 00:22:49,120
非常に高い天井。

456
00:22:49,120 --> 00:22:51,670
我々は、使用を開始にもかかわらず
非常に低レベルの詳細、

457
00:22:51,670 --> 00:22:54,890
あなたが実際にはかなりビットを行うことができます
これで、これはおそらくです

458
00:22:54,890 --> 00:22:57,360
まさにそれのデモ。

459
00:22:57,360 --> 00:23:02,920
>> しかし、それでは、いくつかの詳細に移行しましょう
洗練された問題、可能ならば、

460
00:23:02,920 --> 00:23:05,870
「検索」として知られており、
より一般的には「ソート」。

461
00:23:05,870 --> 00:23:09,500
我々は、この電話帳を持っていたearlier--ここです
ちょうどdiscussion--のための別の1

462
00:23:09,500 --> 00:23:13,460
我々は検索することができたこと
より効率的理由

463
00:23:13,460 --> 00:23:15,270
重要な仮定の。

464
00:23:15,270 --> 00:23:17,655
そして、ちょうど、明確にするもの
仮定私が作っていました

465
00:23:17,655 --> 00:23:19,280
この電話帳を検索するとき？

466
00:23:19,280 --> 00:23:23,342

467
00:23:23,342 --> 00:23:25,300
マイク・スミスはしていたこと
電話帳、Iかかわらず

468
00:23:25,300 --> 00:23:27,410
扱うことができるだろう
彼なしシナリオ

469
00:23:27,410 --> 00:23:30,720
そこに私は途中で停止した場合。

470
00:23:30,720 --> 00:23:31,806
本はアルファベット順です。

471
00:23:31,806 --> 00:23:33,930
そして、それは非常に寛大なです
仮定、その理由

472
00:23:33,930 --> 00:23:36,580
私は親切だsomeone--意味
コー​​ナーを切断します、

473
00:23:36,580 --> 00:23:40,580
私は誰かので、速くていますように
他には、私のために多くのハードワークをしました。

474
00:23:40,580 --> 00:23:43,120
>> しかし、どのような場合は、電話
この本は、ソートされていないでしたか？

475
00:23:43,120 --> 00:23:47,050
多分Verizonは怠け者だ、ただ投げました
そこにすべての人の名前と番号

476
00:23:47,050 --> 00:23:50,120
多分にある彼らの順序で
電話サービスにサインアップしました。

477
00:23:50,120 --> 00:23:54,570
そして、どのくらいの時間それは私を取るん
マイク・スミスのような人を見つけるには？

478
00:23:54,570 --> 00:23:58,160
千ページの電話はどのように多くのbook--
ページには、私は一読する必要がありますか？

479
00:23:58,160 --> 00:23:58,905
>> それらのすべて。

480
00:23:58,905 --> 00:24:00,030
あなたは、ソートの運の尽きです。

481
00:24:00,030 --> 00:24:03,420
あなたは、文字通りすべてのを見ています
ページ電話帳だけである場合

482
00:24:03,420 --> 00:24:04,450
ランダムに並べ替え。

483
00:24:04,450 --> 00:24:06,910
あなたは幸運を得るとマイクを見つけるかもしれません
非常に最初のページに、彼のため

484
00:24:06,910 --> 00:24:08,826
最初の顧客でした
電話サービスを注文します。

485
00:24:08,826 --> 00:24:10,760
しかし、彼はあまりにも、最後だったかもしれません。

486
00:24:10,760 --> 00:24:12,500
>> だからランダムな順序は良くありません。

487
00:24:12,500 --> 00:24:16,750
だから我々は、ソートすることがあるとし
電話帳や一般的なソートデータで

488
00:24:16,750 --> 00:24:18,520
私たちは与えられてきたこと。

489
00:24:18,520 --> 00:24:19,440
我々はそれをどのように行うことができますか？

490
00:24:19,440 --> 00:24:21,360
>> まあ、私はちょうど試してみましょう
ここでは簡単な例。

491
00:24:21,360 --> 00:24:24,290
私が先に行くと投げてみましょう
ボード上のいくつかの数字。

492
00:24:24,290 --> 00:24:35,480
我々が持っている数であると仮定し、
のは、4、2、1、および3をしましょう​​。

493
00:24:35,480 --> 00:24:38,390
そして、ベンは、私たちのためにこれらの数字を並べ替えます。

494
00:24:38,390 --> 00:24:39,017
>> いいよ。

495
00:24:39,017 --> 00:24:39,850
どうやったの？

496
00:24:39,850 --> 00:24:42,731

497
00:24:42,731 --> 00:24:43,230
大丈夫。

498
00:24:43,230 --> 00:24:44,710
だから、最小で始まります
値と最高、

499
00:24:44,710 --> 00:24:46,084
それは本当に良い直感です。

500
00:24:46,084 --> 00:24:48,080
そして、我々を実現
人間は実際にはかなりあります

501
00:24:48,080 --> 00:24:49,913
問題を解決するのが得意
このように、少なくとも、

502
00:24:49,913 --> 00:24:51,810
データが比較的小さい場合。

503
00:24:51,810 --> 00:24:54,860
すぐに数百を持って始めると
数字、数字の数千人の、

504
00:24:54,860 --> 00:24:58,440
数字の何百万人、ベンは、おそらく
それほど速いそれを行うことができませんでした、

505
00:24:58,440 --> 00:25:00,620
あったと仮定すると
数字のギャップ。

506
00:25:00,620 --> 00:25:03,450
万人にカウントするのは簡単
それ以外の場合は、ちょうど時間がかかります。

507
00:25:03,450 --> 00:25:07,150
>> だから、このアルゴリズムは、それが聞こえます
ベンはちょうど今使用のように

508
00:25:07,150 --> 00:25:08,930
最小数の検索がありました。

509
00:25:08,930 --> 00:25:12,900
だから我々人間が取ることができるにもかかわらず、
視覚的に多くの情報で、

510
00:25:12,900 --> 00:25:14,830
コンピュータが実際にあります
もう少し限られました。

511
00:25:14,830 --> 00:25:17,560
コンピュータができる唯一の
一度に1バイトを見て

512
00:25:17,560 --> 00:25:20,770
time--時または多分4バイト
time--で、これらの日は、多分8バイト

513
00:25:20,770 --> 00:25:24,450
しかし、非常に少ない数
与えられた時間でのバイト。

514
00:25:24,450 --> 00:25:28,480
>> だから私たちは本当に持っていることを考えます
4つの別々の値here--

515
00:25:28,480 --> 00:25:32,440
あなたが持つとベンと考えることができます
彼はそのようなコンピュータであれば上の目隠し

516
00:25:32,440 --> 00:25:36,450
彼は他の何かを見ることができません
time-- 1つの数より

517
00:25:36,450 --> 00:25:39,720
私たちは、一般のように、前提としています
英語では、我々は右から左に読んであげます。

518
00:25:39,720 --> 00:25:42,870
したがって、最初の数ベンはおそらく見えました
で、非常に迅速に、その後4だったと

519
00:25:42,870 --> 00:25:44,770
それはかなり大きいです実現
number--私が探し続けてみましょう。

520
00:25:44,770 --> 00:25:45,357
>> 2があります。

521
00:25:45,357 --> 00:25:45,940
ちょっと待って。

522
00:25:45,940 --> 00:25:47,070
二つは4未満です。

523
00:25:47,070 --> 00:25:47,986
私が覚えているつもりです。

524
00:25:47,986 --> 00:25:49,070
二つは、現在最も小さいです。

525
00:25:49,070 --> 00:25:50,417
今選ぶ - それはさらに良いです。

526
00:25:50,417 --> 00:25:51,250
それはさらに小さいです。

527
00:25:51,250 --> 00:25:54,000
私は約2を忘れるつもりです
そしてちょうど今1を覚えています。

528
00:25:54,000 --> 00:25:56,550
>> そして、彼は見ることをやめるだろうか？

529
00:25:56,550 --> 00:25:58,360
まあ、彼はベースの可能性
この情報について、

530
00:25:58,360 --> 00:26:00,477
彼はより良い検索をいただきたいです
リストの残りの部分。

531
00:26:00,477 --> 00:26:02,060
リストには何がゼロの場合であったため？

532
00:26:02,060 --> 00:26:03,643
どのような負の1がリストにありましたか？

533
00:26:03,643 --> 00:26:07,720
彼は彼の答えを知っています
彼は徹底的な場合は、正しいです

534
00:26:07,720 --> 00:26:08,729
全体のリストをチェックしました。

535
00:26:08,729 --> 00:26:10,020
だから我々は、このの残りの部分を見てください。

536
00:26:10,020 --> 00:26:11,394
そのThree--時間の無駄でした。

537
00:26:11,394 --> 00:26:13,540
不運得たが、私がいました
そうすることが正しいまだ。

538
00:26:13,540 --> 00:26:17,857
そして今、彼おそらく
最小の番号を選択

539
00:26:17,857 --> 00:26:20,440
そしてまだ始まったばかりでそれを置きます
リストの、私はここでやるように。

540
00:26:20,440 --> 00:26:23,480
今、あなたはあっても、次の何をしました
あなたはほとんどそれについて考えていませんでした

541
00:26:23,480 --> 00:26:25,962
この程度まで？

542
00:26:25,962 --> 00:26:27,670
プロセスを繰り返し、
ループのようにいくつかの種類。

543
00:26:27,670 --> 00:26:28,920
おなじみのアイデアがあります。

544
00:26:28,920 --> 00:26:30,860
そこでここでは4です。

545
00:26:30,860 --> 00:26:32,110
それは、現在、最も小さいのです。

546
00:26:32,110 --> 00:26:33,220
それは候補者です。

547
00:26:33,220 --> 00:26:33,900
もう違います。

548
00:26:33,900 --> 00:26:34,770
今、私は2つを見てきました。

549
00:26:34,770 --> 00:26:36,630
それは次の最小要素です。

550
00:26:36,630 --> 00:26:40,800
それはそう、小さくないですThree--
今ベンは2を引き抜くことができます。

551
00:26:40,800 --> 00:26:44,510
>> そして今、我々はプロセスを繰り返し、
もちろん3次引き出されます。

552
00:26:44,510 --> 00:26:45,420
プロセスを繰り返します。

553
00:26:45,420 --> 00:26:46,990
4つが引き出されます。

554
00:26:46,990 --> 00:26:50,140
そして今、我々は数字の外出します、
そのようにリストをソートする必要があります。

555
00:26:50,140 --> 00:26:51,960
>> 実際、これは正式なアルゴリズムです。

556
00:26:51,960 --> 00:26:56,610
コンピュータ科学者だろう
"、選択ソート「これを呼び出します

557
00:26:56,610 --> 00:27:00,880
アイデアは、ソートAであること
再びiteratively--を一覧表示します

558
00:27:00,880 --> 00:27:03,807
そして、何度も何度も選択します
最小数。

559
00:27:03,807 --> 00:27:06,140
そして、何それについての素晴らしいのはあります
それはちょうどので、とても直感的です。

560
00:27:06,140 --> 00:27:07,470
それはとても簡単です。

561
00:27:07,470 --> 00:27:11,100
そして、あなたは同じことを繰り返すことができます
操作何度も何度も。

562
00:27:11,100 --> 00:27:12,150
それは簡単です。

563
00:27:12,150 --> 00:27:17,170
>> この場合、高速であったが
それは実際にどのくらいかかりますか？

564
00:27:17,170 --> 00:27:19,880
のは、それが見えるようにしましょう​​と
もう少し退屈な感じ。

565
00:27:19,880 --> 00:27:24,150
そのように、一つ、二つ、三つ、四つ、5~6、
7つ、8つ、9、10、11、12、13、14、

566
00:27:24,150 --> 00:27:26,160
15、16--任意の数。

567
00:27:26,160 --> 00:27:28,780
私はこの多くを望んでいました
わずか4以上の時間。

568
00:27:28,780 --> 00:27:30,780
だから私は、全体を持っている場合
それnow--数字の束

569
00:27:30,780 --> 00:27:32,420
でも、問題ではありません。
彼らは何をしましょう​​are--

570
00:27:32,420 --> 00:27:34,380
何これについて考えます
アルゴリズムは本当に好きです。

571
00:27:34,380 --> 00:27:35,857
>> そこに数字があるとします。

572
00:27:35,857 --> 00:27:38,190
ここでも、何が問題ではありません。
彼らは、彼らはランダムです。

573
00:27:38,190 --> 00:27:39,679
私はベンのアルゴリズムを適用しています。

574
00:27:39,679 --> 00:27:41,220
私は最小の番号を選択する必要があります。

575
00:27:41,220 --> 00:27:41,761
私は何をしますか？

576
00:27:41,761 --> 00:27:44,240
そして、私は物理的に行きますよ
それはそれを行動するために、この時間を行います。

577
00:27:44,240 --> 00:27:46,099
見て、見て、
見て、見て、見て。

578
00:27:46,099 --> 00:27:48,140
唯一の私は取得時まで
リストの最後にすることができます

579
00:27:48,140 --> 00:27:51,230
私は最小を実現します
数は2この時間でした。

580
00:27:51,230 --> 00:27:52,720
一つは、リストにありません。

581
00:27:52,720 --> 00:27:54,400
だから私は2を下に置きます。

582
00:27:54,400 --> 00:27:55,590
>> 私は次に何をしますか？

583
00:27:55,590 --> 00:27:58,600
見て、見て、見て、見て。

584
00:27:58,600 --> 00:28:02,250
今、私はので、番号7を発見しました
これらnumbers--にギャップがあります

585
00:28:02,250 --> 00:28:03,300
ちょうど任意。

586
00:28:03,300 --> 00:28:03,800
大丈夫。

587
00:28:03,800 --> 00:28:06,030
だから今、私は7を下に置くことができます。

588
00:28:06,030 --> 00:28:08,860
探して、探して探しています。

589
00:28:08,860 --> 00:28:11,030
>> 今私は、のと仮定しています
ベンはないことをもちろん、

590
00:28:11,030 --> 00:28:14,780
余分なRAMを持っている、余分な
メモリはもちろん、なぜなら、

591
00:28:14,780 --> 00:28:16,080
私は、同じ番号で探しています。

592
00:28:16,080 --> 00:28:18,246
確かに私が覚えている可能性が
これらの数字のすべて、

593
00:28:18,246 --> 00:28:19,930
それは絶対に本当です。

594
00:28:19,930 --> 00:28:22,610
しかし、ベンはすべて覚えている場合
彼は見ています数字の、

595
00:28:22,610 --> 00:28:24,430
彼は本当に行われていません
基本的な進展

596
00:28:24,430 --> 00:28:26,170
彼はすでに持っているので
検索する機能

597
00:28:26,170 --> 00:28:27,540
ボード上の数字を通じ。

598
00:28:27,540 --> 00:28:29,373
のすべてを思い出します
数字は、助けにはなりません

599
00:28:29,373 --> 00:28:32,490
彼はコンピュータとしてまだすることができますので、
のみ、私たちが言った、1の数を見て

600
00:28:32,490 --> 00:28:33,080
一度に。

601
00:28:33,080 --> 00:28:35,760
だからチートのない並べ替えはありません
そこにあなたが活用できる​​こと。

602
00:28:35,760 --> 00:28:39,170
>> だから現実には、私のように
リストを検索保ちます、

603
00:28:39,170 --> 00:28:44,200
私は文字通り続けるために持っています
前後にそれを介して、アウト摘採

604
00:28:44,200 --> 00:28:45,710
次の最小数。

605
00:28:45,710 --> 00:28:48,810
そして、あなたは推論の種類をできる限り
私の愚かな動きから、

606
00:28:48,810 --> 00:28:50,860
これはちょうど、非常に取得します
非常に迅速に退屈、

607
00:28:50,860 --> 00:28:54,850
そして、私は戻っているように見えると
前後、前後にかなり。

608
00:28:54,850 --> 00:29:03,220
今公正であることを、私は行く必要はありません
ほど、よく、のが公正であることをsee--せ、

609
00:29:03,220 --> 00:29:06,310
私はかなり歩く必要はありません
など多くのステップ毎時間。

610
00:29:06,310 --> 00:29:09,200
もちろん、私のように、ため、
リストから番号を選択し、

611
00:29:09,200 --> 00:29:11,860
残りのリストが短くなってきています。

612
00:29:11,860 --> 00:29:14,240
>> そしてそうのは、考えてみよう
どのように多くのステップ、私は実際によ

613
00:29:14,240 --> 00:29:16,010
毎回を通してtraipsing。

614
00:29:16,010 --> 00:29:18,950
非常に最初の状況では
我々は、16の数字を持っていました

615
00:29:18,950 --> 00:29:22,210
そしてこれだけしてみましょうmaximally--
discussion--のためにこれを行います

616
00:29:22,210 --> 00:29:25,640
私は16に目を通す必要がありました
最小を見つけるための番号。

617
00:29:25,640 --> 00:29:28,420
しかし、かつて私は摘み取ら
どのように最小数、

618
00:29:28,420 --> 00:29:30,590
長いコースの残りのリストは、でしたか？

619
00:29:30,590 --> 00:29:31,420
わずか15。

620
00:29:31,420 --> 00:29:34,670
だから、どのように多くの数ベンまたは私が持っていました
二度目の周りに目を通すには？

621
00:29:34,670 --> 00:29:36,832
15は、ただ行くと最小を見つけることができます。

622
00:29:36,832 --> 00:29:39,540
しかし、今、もちろん、リストがあり、
あまりにも、それは以前よりも小さいです。

623
00:29:39,540 --> 00:29:42,540
私はやったので、どのように多くの手順
次の時間を取る必要がありますか？

624
00:29:42,540 --> 00:29:49,970
14、次に13、次に12、プラスドット、
私はちょうど1を残しているまでのドットは、点在しています。

625
00:29:49,970 --> 00:29:53,146
だから今、コンピュータ科学者は、希望
すべて同じことを何、よく、頼みますか？

626
00:29:53,146 --> 00:29:55,770
これは、実際にいくつかの具体的に等しいです
その私たちは確かにできた数

627
00:29:55,770 --> 00:30:00,490
算術行うが、我々は話をしたいです
アルゴリズムの効率化について

628
00:30:00,490 --> 00:30:04,940
もう少しformulaically、
リストがあるどのくらいの独立しました。

629
00:30:04,940 --> 00:30:06,240
>> だから、あなたは何を知っていますか？

630
00:30:06,240 --> 00:30:09,860
、これは16ですが、私は前に言ったように
ちょうど問題のサイズを呼ぶことにしましょう

631
00:30:09,860 --> 00:30:10,970
nはいくつかの数であるnは、。

632
00:30:10,970 --> 00:30:13,220
多分それは多分それはだ、16です
3は、多分それは万人です。

633
00:30:13,220 --> 00:30:13,761
知りません。

634
00:30:13,761 --> 00:30:14,390
私は気にしない。

635
00:30:14,390 --> 00:30:16,520
私が本当に欲しいのはあります
式私ができます

636
00:30:16,520 --> 00:30:19,420
このアルゴリズムを比較するために使用
他のアルゴリズムに対する

637
00:30:19,420 --> 00:30:22,350
誰かが主張する可能性があること
良くも悪くもです。

638
00:30:22,350 --> 00:30:25,430
>> だから、判明、と私だけ
小学校からこれを知って、

639
00:30:25,430 --> 00:30:34,790
これは実際には同じということになりますことを
nはプラス2分の1以上のnは事。

640
00:30:34,790 --> 00:30:40,020
そして、これは、等しいことを起こります
コー​​スは、プラスnは2以上の二乗のn。

641
00:30:40,020 --> 00:30:43,250
私は式を望んでいたので、もし
どのように多くのステップのため

642
00:30:43,250 --> 00:30:46,330
全く見に関与していました
何度も何度もそれらの数の

643
00:30:46,330 --> 00:30:52,681
そして、何度も何度も、私は言うだろう
それは、n乗プラスnは2以上です。

644
00:30:52,681 --> 00:30:53,430
しかし、あなたは何を知っていますか？

645
00:30:53,430 --> 00:30:54,500
これは単に乱雑に見えます。

646
00:30:54,500 --> 00:30:56,470
私は本当にしたいです
物事の一般的な意味。

647
00:30:56,470 --> 00:30:58,810
そして、あなたはから思い出すかもしれません
高校その存在

648
00:30:58,810 --> 00:31:00,660
最上位の用語の概念です。

649
00:31:00,660 --> 00:31:05,300
これらの用語のどれ、n個
、N、または半二乗、

650
00:31:05,300 --> 00:31:07,550
時間をかけて、ほとんど影響を与えていますか？

651
00:31:07,550 --> 00:31:11,920
大きなNは、その取得します
もっとも、これらの問題の？

652
00:31:11,920 --> 00:31:15,560
>> 言い換えれば、私はプラグ場合
万人であり、n乗

653
00:31:15,560 --> 00:31:17,900
最も可能性が高いとしています
支配的要因、

654
00:31:17,900 --> 00:31:21,670
なぜなら万回
それ自体は多くの大きいです

655
00:31:21,670 --> 00:31:23,682
以上に加えて、追加百万。

656
00:31:23,682 --> 00:31:24,390
だからあなたは何を知っていますか？

657
00:31:24,390 --> 00:31:27,305
これは、このようなくそが大きいです
数は数を二乗場合。

658
00:31:27,305 --> 00:31:28,430
これは本当に重要ではありません。

659
00:31:28,430 --> 00:31:30,596
私達はちょうど十字を行っていること
アウトし、それを忘れます。

660
00:31:30,596 --> 00:31:34,250
それでコンピュータ科学者は言います
このアルゴリズムの効率は、その

661
00:31:34,250 --> 00:31:37,850
n個のオーダーでありますsquared--
私は本当に近似を意味します。

662
00:31:37,850 --> 00:31:40,810
それは一種のおおよそのn乗です。

663
00:31:40,810 --> 00:31:44,130
時間が経つにつれて、より大きな
そして、大きなnが、これを取得します

664
00:31:44,130 --> 00:31:47,610
何のために良い推定で
効率や効率性の欠如

665
00:31:47,610 --> 00:31:49,400
このアルゴリズムの実際です。

666
00:31:49,400 --> 00:31:52,040
そして、私はもちろんのことを引き出します、
実際に数学をやってから。

667
00:31:52,040 --> 00:31:54,040
しかし、今私はちょうど手を振っています
私の手、私はちょうどので、

668
00:31:54,040 --> 00:31:55,790
このアルゴリズムの一般的な意味を求めています。

669
00:31:55,790 --> 00:31:58,850
>> そう一方、同じロジックを使用して、
のは、別のアルゴリズムを考えてみましょう

670
00:31:58,850 --> 00:32:01,162
我々はすでに線形検索at--見えました。

671
00:32:01,162 --> 00:32:02,870
私が探していたとき
電話用book--

672
00:32:02,870 --> 00:32:05,980
検索、それを並べ替えていません
電話を通してbook--

673
00:32:05,980 --> 00:32:09,197
我々はそれがあったことを言い続け
千段階、または500段階。

674
00:32:09,197 --> 00:32:10,280
しかし、ここではそれを一般化してみましょう。

675
00:32:10,280 --> 00:32:12,860
中のnページがある場合は
電話帳、何

676
00:32:12,860 --> 00:32:17,250
走行時間または
線形探索の効率？

677
00:32:17,250 --> 00:32:19,750
それはのためにです
どのように多くの手順見つけるために

678
00:32:19,750 --> 00:32:24,210
マイク・スミスは、線形探索を使用して
最初のアルゴリズム、または偶数秒？

679
00:32:24,210 --> 00:32:27,240

680
00:32:27,240 --> 00:32:31,710
>> 最悪の場合、マイクで
本の最後にあります。

681
00:32:31,710 --> 00:32:35,590
電話帳は、1,000ページを持っているのであれば、
我々は、最悪の場合には、最後の時間を言いました

682
00:32:35,590 --> 00:32:38,380
それは大体どのようにかかることがあります
多くのページには、マイクを見つけるには？

683
00:32:38,380 --> 00:32:38,990
千のように。

684
00:32:38,990 --> 00:32:39,830
それは上限です。

685
00:32:39,830 --> 00:32:41,790
それは最悪の状況です。

686
00:32:41,790 --> 00:32:44,410
しかし、再び、私たちは離れて移動しています
今千のような番号から。

687
00:32:44,410 --> 00:32:45,730
それはちょうどn個です。

688
00:32:45,730 --> 00:32:47,470
>> だから、論理的な結論は何ですか？

689
00:32:47,470 --> 00:32:50,210
電話でマイクを見つけます
nページを持っている書籍

690
00:32:50,210 --> 00:32:55,280
非常に最悪の場合には、かかることがあり、
どのように多くのステップn個のオーダーの？

691
00:32:55,280 --> 00:32:58,110
そして実際コンピュータ
科学者は言います

692
00:32:58,110 --> 00:33:02,340
走行時間、またはその
パフォーマンスや効率性

693
00:33:02,340 --> 00:33:07,470
アルゴリズムのようなのか、非効率、
線形探索は、nのオーダーです。

694
00:33:07,470 --> 00:33:10,010
そして、我々は同じように適用することができます
何かを通過するロジック

695
00:33:10,010 --> 00:33:13,170
私はちょうど第二に行ったように
アルゴリズム我々は、電話帳としていました

696
00:33:13,170 --> 00:33:16,040
ここで、我々は、一度に2つのページに行きました。

697
00:33:16,040 --> 00:33:20,120
>> だから、千ページ電話帳のかもしれません
500ページのターン私たちを取る、プラス1

698
00:33:20,120 --> 00:33:21,910
我々は少し戻って倍増場合。

699
00:33:21,910 --> 00:33:26,590
そのように電話帳がnページがある場合、しかし
私たちは、一度に2つのページをやっています

700
00:33:26,590 --> 00:33:28,900
それは大体何ですか？

701
00:33:28,900 --> 00:33:33,190
2以上のN、そのためには、2以上のn個のようなものです。

702
00:33:33,190 --> 00:33:38,490
しかし、私は主張aを作っ
two--にわたってそのn個前の瞬間

703
00:33:38,490 --> 00:33:41,060
それはちょうどnと同じのようなものです。

704
00:33:41,060 --> 00:33:44,050
それは、単に一定の係数です
コンピュータ科学者は言うでしょう。

705
00:33:44,050 --> 00:33:45,970
のだけに焦点を当ててみましょう
変数、really--

706
00:33:45,970 --> 00:33:47,780
式の最大の変数。

707
00:33:47,780 --> 00:33:52,530
>> 1を行うかどうかだから線形探索、
当時のページまたは一度に2ページ、

708
00:33:52,530 --> 00:33:54,810
ソートの基本的に同じです。

709
00:33:54,810 --> 00:33:56,880
これは、n個のオーダーではまだです。

710
00:33:56,880 --> 00:34:01,930
しかし、私は、以前の私の写真と主張しました
第3のアルゴリズムではなかったこと

711
00:34:01,930 --> 00:34:02,480
リニア。

712
00:34:02,480 --> 00:34:03,605
これは、直線ではありませんでした。

713
00:34:03,605 --> 00:34:08,659
それは、その曲線とし、
代数式何がありましたか？

714
00:34:08,659 --> 00:34:11,812
N--のログは、そのようにn個のベース2を記録します。

715
00:34:11,812 --> 00:34:14,520
そして、我々はあまりにもに行く必要はありません
対数上の多くの詳細は本日、

716
00:34:14,520 --> 00:34:17,394
しかし、ほとんどのコンピュータ科学者はいないだろう
でもベースが何であるかを教えてください。

717
00:34:17,394 --> 00:34:20,639
ので、それだけですべてです
いわば一定の要因、

718
00:34:20,639 --> 00:34:22,659
ただ若干の数値の違い。

719
00:34:22,659 --> 00:34:31,179
そして、これは非常に一般的であろう
特にフォーマルなコンピュータのための方法

720
00:34:31,179 --> 00:34:33,949
ボードの科学者や
ホワイトボードのプログラマー

721
00:34:33,949 --> 00:34:36,889
実際に主張しています
彼らが使用するアルゴリズム

722
00:34:36,889 --> 00:34:39,500
またはどのような効率
それらのアルゴリズムです。

723
00:34:39,500 --> 00:34:42,960
>> そして、これは必ずしもものではありません
あなたは、任意の非常に詳細に議論します

724
00:34:42,960 --> 00:34:47,889
良いプログラマは人です
人は、固体、正式なバックグラウンドを持っています。

725
00:34:47,889 --> 00:34:50,120
彼はに話すことができます
道のこの種で、あなた

726
00:34:50,120 --> 00:34:53,350
実際に作ります
定性的な引数として

727
00:34:53,350 --> 00:34:56,870
なぜ1つのアルゴリズムのか
1つのソフトウェア

728
00:34:56,870 --> 00:35:00,165
別のいくつかの方法で優れています。

729
00:35:00,165 --> 00:35:02,540
あなたは確かに可能性があるため、
たった一人のプログラムを実行します

730
00:35:02,540 --> 00:35:04,980
そして、秒数を数えます
それはいくつかの数字を並べ替えるのにかかります、

731
00:35:04,980 --> 00:35:06,710
あなたは、いくつかを実行することができます
他の人のプログラム

732
00:35:06,710 --> 00:35:08,418
そして、数を数えます
秒のかかります。

733
00:35:08,418 --> 00:35:12,840
しかし、これは、より一般的な方法があること
あなたはアルゴリズムを分析するために使用することができ、

734
00:35:12,840 --> 00:35:15,520
可能ならば、ちょうど
紙または単に口頭で。

735
00:35:15,520 --> 00:35:18,430
なくてもすることなく、それを実行しています
でも、サンプルの入力をしよう

736
00:35:18,430 --> 00:35:20,180
あなたはそれを介して推論することができます。

737
00:35:20,180 --> 00:35:24,670
そのため、開発者を雇うと場合、または
彼またはあなたに主張の彼女の並べ替えを持ちます

738
00:35:24,670 --> 00:35:28,460
なぜ彼らのアルゴリズム、彼らの秘密
十億を検索するためのソース

739
00:35:28,460 --> 00:35:30,580
あなたのWeb​​ページの
同社は、これらの、優れています

740
00:35:30,580 --> 00:35:33,302
引数の種類があり、それら
理想的に作ることができるはずです。

741
00:35:33,302 --> 00:35:35,010
または、少なくともこれらは、
物事の種類

742
00:35:35,010 --> 00:35:40,211
それはでは、議論の中で出てくるだろう
非常にフォーマルな議論の中で最低。

743
00:35:40,211 --> 00:35:40,710
大丈夫。

744
00:35:40,710 --> 00:35:44,400
だから、ベンは何かを提案しました
選択ソートと呼ばれます。

745
00:35:44,400 --> 00:35:48,200
しかし、私はそこだと提案するつもりです
あまりにも、これを行うための他の方法。

746
00:35:48,200 --> 00:35:50,400
私が本当に好きではなかったです
ベンのアルゴリズムについて

747
00:35:50,400 --> 00:35:54,400
彼は歩き続けたということですか、
私は前後に、歩きました

748
00:35:54,400 --> 00:35:56,930
そして前後にし、前後に。

749
00:35:56,930 --> 00:36:04,130
代わりに私がした場合にどのような
ここでは、これらの番号のようなもの

750
00:36:04,130 --> 00:36:08,200
そして、私はそれぞれに対処するました
私はそれを与えているように順番に番号？

751
00:36:08,200 --> 00:36:10,780
>> つまり、ここです
数字の私のリスト。

752
00:36:10,780 --> 00:36:12,944
四一三二つ。

753
00:36:12,944 --> 00:36:14,360
そして、私は次のことをするつもりです。

754
00:36:14,360 --> 00:36:17,230
私は数字を挿入するつもりです
彼らはむしろ属している場所

755
00:36:17,230 --> 00:36:18,980
1回につき1つずつ選択するよりも。

756
00:36:18,980 --> 00:36:20,820
つまり、ここで4番です。

757
00:36:20,820 --> 00:36:22,430
>> ここに私の元のリストです。

758
00:36:22,430 --> 00:36:25,290
そして、私は維持するつもりです
ここでは、本質的に新しいリスト。

759
00:36:25,290 --> 00:36:26,710
だから、これは古いリストです。

760
00:36:26,710 --> 00:36:28,560
これは、新しいリストです。

761
00:36:28,560 --> 00:36:30,220
私は数4が最初に参照してください。

762
00:36:30,220 --> 00:36:34,500
私の新しいリストは、最初は空です
それは些細なケースです

763
00:36:34,500 --> 00:36:36,410
その4は今盛り合わせリストです。

764
00:36:36,410 --> 00:36:39,560
私はちょうど私が与えられている番号を取っています、
そして、私は私の新しいリストでそれを入れています。

765
00:36:39,560 --> 00:36:41,460
>> この新しいリストがソートされていますか？

766
00:36:41,460 --> 00:36:41,990
うん。

767
00:36:41,990 --> 00:36:45,090
ちょうど1がありますので、それは愚かです
要素、それは絶対にソートされています。

768
00:36:45,090 --> 00:36:46,390
場所のうちは何もありません。

769
00:36:46,390 --> 00:36:49,290
それは、このアルゴリズムより面白いです、
私は、次のステップに移動したとき。

770
00:36:49,290 --> 00:36:50,550
>> 今、私は1つを持っています。

771
00:36:50,550 --> 00:36:55,430
それで一つは、もちろん、に属し
始まるか、この新しいリストの最後？

772
00:36:55,430 --> 00:36:56,360
初め。

773
00:36:56,360 --> 00:36:58,530
だから私は今、いくつかの作業を行う必要があります。

774
00:36:58,530 --> 00:37:01,410
私はいくつかを取ってきました
私のマーカーとの自由

775
00:37:01,410 --> 00:37:03,120
物事を描くことにより、
私はそれらを配置したい場所、

776
00:37:03,120 --> 00:37:05,320
それは本当にありません
コンピュータで正確な。

777
00:37:05,320 --> 00:37:08,530
私たちが知っているように、コンピュータは、持っています
RAM、またはランダムアクセスメモリ、

778
00:37:08,530 --> 00:37:12,411
それは1バイトだと
別のバイトおよび別のバイト。

779
00:37:12,411 --> 00:37:14,910
そして、あなたはのギガバイトを持っている場合
RAMは、あなたが億バイトを持って、

780
00:37:14,910 --> 00:37:16,680
しかし、彼らは一箇所に物理的にしています。

781
00:37:16,680 --> 00:37:19,540
あなただけの周りのものを移動することはできません
ボード上に描画することにより、

782
00:37:19,540 --> 00:37:20,750
あなたが好きな場所。

783
00:37:20,750 --> 00:37:24,090
だから、私の新しいリストを持っている場合
メモリ内の4箇所、

784
00:37:24,090 --> 00:37:27,480
残念ながら4は、
すでに間違った場所インチ

785
00:37:27,480 --> 00:37:30,410
>> だから番号を挿入する1
私はここでそれを描画することはできません。

786
00:37:30,410 --> 00:37:31,901
この記憶場所は存在しません。

787
00:37:31,901 --> 00:37:35,150
それは浮気されるだろう、と私はされています
数分間絵浮気

788
00:37:35,150 --> 00:37:35,800
ここに。

789
00:37:35,800 --> 00:37:40,950
だから本当に、私はここに1を入れたい場合は、
私は一時的に4をコピーする必要が

790
00:37:40,950 --> 00:37:43,030
そしてそこ1を置きます。

791
00:37:43,030 --> 00:37:45,500
>> それは大丈夫です、それは正しいです、
それは技術的には可能だが、

792
00:37:45,500 --> 00:37:48,410
しかし、それは余分な作業だ実現しています。

793
00:37:48,410 --> 00:37:50,460
私はちょうど場所に番号を入れていません。

794
00:37:50,460 --> 00:37:53,026
私が最初に移動しなければなりませんでした
番号、その後、場所に置き、

795
00:37:53,026 --> 00:37:54,650
私は一種の仕事の私の量を倍増しました。

796
00:37:54,650 --> 00:37:55,660
だから、心に留めておきます。

797
00:37:55,660 --> 00:37:57,120
>> しかし、私は今、この要素で終わりです。

798
00:37:57,120 --> 00:37:59,056
今、私は数3をつかむしたいです。

799
00:37:59,056 --> 00:38:00,430
もちろん、それはどこに属しているのでしょうか？

800
00:38:00,430 --> 00:38:01,480
間で。

801
00:38:01,480 --> 00:38:03,650
私はもうカンニングすることはできません
ちょうど、そこにそれを置きます

802
00:38:03,650 --> 00:38:06,770
なぜなら、再び、このメモリ
物理的な場所です。

803
00:38:06,770 --> 00:38:10,900
だから私は4をコピーする必要が
ここの上に3を入れました。

804
00:38:10,900 --> 00:38:11,550
ではない大したこと。

805
00:38:11,550 --> 00:38:14,610
それはちょうど1つの余分なステップです
again--非常に安価な感じ。

806
00:38:14,610 --> 00:38:16,445
>> しかし、今私は2つに移動します。

807
00:38:16,445 --> 00:38:17,820
2は、当然のことながら、ここに属しています。

808
00:38:17,820 --> 00:38:20,990
今、あなたはどのように見え始めます
仕事は積み上げることができます。

809
00:38:20,990 --> 00:38:23,520
今、何を私がしなければならないのですか？

810
00:38:23,520 --> 00:38:28,570
ええ、私は4を移動する必要があり、
私は、3をコピーする必要があり、

811
00:38:28,570 --> 00:38:31,200
そして今、私は2を挿入することができます。

812
00:38:31,200 --> 00:38:34,460
そして、これでキャッチ
アルゴリズム、興味深いことに、

813
00:38:34,460 --> 00:38:41,050
それは、我々はより極端があるとされています
それはのは8、7を言わせていた場合、

814
00:38:41,050 --> 00:38:45,150
6、5、4つ、三つ、2個、一つ。

815
00:38:45,150 --> 00:38:49,450
これは、多くの状況で、あります
最悪の場合、

816
00:38:49,450 --> 00:38:51,570
くそ事理由
文字通り後方です。

817
00:38:51,570 --> 00:38:53,670
>> それは本当にありません
ベンのアルゴリズムに影響を与え、

818
00:38:53,670 --> 00:38:55,940
ベンの選択であるため
ソート彼は維持するつもりです

819
00:38:55,940 --> 00:38:58,359
リストを前後に行きます。

820
00:38:58,359 --> 00:39:01,150
そして、彼はいつも見ていたので、
全体の残りのリストを、

821
00:39:01,150 --> 00:39:02,858
それは問題ではありません
どこの要素があります。

822
00:39:02,858 --> 00:39:05,630
しかし、この場合は私の挿入と
approach--のは、これを試してみましょう。

823
00:39:05,630 --> 00:39:08,616
>> そのように、一つ、二つ、三つ、四つ、
5つ、6つ、7つ、8つ。

824
00:39:08,616 --> 00:39:11,630
1 2 3 4、
5つ、6つ、7つ、8つ。

825
00:39:11,630 --> 00:39:14,320
私は、8を取るつもりです
どこ私はそれを置くのですか？

826
00:39:14,320 --> 00:39:17,260
さて、私のリストの先頭に、
この新しいリストがソートされているので。

827
00:39:17,260 --> 00:39:18,760
そして、私はそれを横切ります。

828
00:39:18,760 --> 00:39:20,551
>> どこで7を置けばいいの？

829
00:39:20,551 --> 00:39:21,050
それをくそ。

830
00:39:21,050 --> 00:39:23,174
それは、そこに行く必要があるので、
私はいくつかのコピーを行う必要があります。

831
00:39:23,174 --> 00:39:26,820

832
00:39:26,820 --> 00:39:28,480
そして今、7がここに入ります。

833
00:39:28,480 --> 00:39:29,860
今私は6に移動します。

834
00:39:29,860 --> 00:39:30,980
今ではさらに多くの仕事です。

835
00:39:30,980 --> 00:39:32,570
>> エイトは、ここに行かなければなりません。

836
00:39:32,570 --> 00:39:33,920
セブンはここに行かなければなりません。

837
00:39:33,920 --> 00:39:35,450
今6は、ここに行くことができます。

838
00:39:35,450 --> 00:39:37,950
今、私は5をつかみます。

839
00:39:37,950 --> 00:39:40,560
今8は行かなければなりません
ここで、7はここに行かなければなりません、

840
00:39:40,560 --> 00:39:43,650
6は、ここに行く必要があり、
今5を繰り返し。

841
00:39:43,650 --> 00:39:46,610
そして、私はかなりよ
常にそれを動かします。

842
00:39:46,610 --> 00:39:52,950
>> それで終わりに、このalgorithm--我々はよ
実際sort--挿入それを呼び出します

843
00:39:52,950 --> 00:39:55,020
あまりにも、多くの仕事を持っています。

844
00:39:55,020 --> 00:39:56,970
それはちょうど違います
ベンのより作業の種類。

845
00:39:56,970 --> 00:40:00,090
ベンの仕事は私が行く持っていました
前後にすべての時間、

846
00:40:00,090 --> 00:40:03,510
次の最小を選択
要素何度も何度も。

847
00:40:03,510 --> 00:40:06,660
だから、仕事のこの非常に視覚的なものでした。

848
00:40:06,660 --> 00:40:10,600
>> まだこの他のアルゴリズム、
それは仕事を取得しますcorrect-- done--

849
00:40:10,600 --> 00:40:12,800
ちょうど仕事の量を変更します。

850
00:40:12,800 --> 00:40:15,420
最初にあなたがしているように見えます
あなただけだから、省

851
00:40:15,420 --> 00:40:19,190
各要素を扱います
すべて歩いなしフロントアップ

852
00:40:19,190 --> 00:40:20,930
ベンのようなリストを方法でした。

853
00:40:20,930 --> 00:40:25,300
しかし、問題は、特にこれらの中で、あります
それはすべて後方だ狂った例、

854
00:40:25,300 --> 00:40:27,830
あなただけの種類のです
ハードワークを延期

855
00:40:27,830 --> 00:40:30,360
あなたはあなたの過ちを修正する必要がありますまで。

856
00:40:30,360 --> 00:40:33,919
>> そして、あなたはこれを想像することができる場合
8と7と6と5

857
00:40:33,919 --> 00:40:36,710
以降4と3と2
リストを介して自分の道を移動し、

858
00:40:36,710 --> 00:40:39,060
我々だけ変更しました
私たちがやっている仕事のタイプ。

859
00:40:39,060 --> 00:40:42,340
代わりにそれを行うの
私の反復の開始、

860
00:40:42,340 --> 00:40:45,250
私はちょうどでそれをやっています
各反復の終わり。

861
00:40:45,250 --> 00:40:50,550
だから、このアルゴリズムことが判明します
あまりにも、一般的に呼ばれる挿入ソート、

862
00:40:50,550 --> 00:40:52,190
n個のオーダー乗にもあります。

863
00:40:52,190 --> 00:40:56,480
それは、何より良い実際ません
良いまったくありません。

864
00:40:56,480 --> 00:41:00,810
>> しかし、第三のアプローチがあります
私は、検討する私たちを励まします

865
00:41:00,810 --> 00:41:02,970
これはこれです。

866
00:41:02,970 --> 00:41:07,850
だから簡単にするために、私のリストを考えます
再び、ある4つ、いずれか三つ、

867
00:41:07,850 --> 00:41:11,080
ちょうど4つの数字をtwo--。

868
00:41:11,080 --> 00:41:13,300
ベンは良い勘を持っていました、
良い人間の直感

869
00:41:13,300 --> 00:41:16,340
前に、我々は全体を固定することにより、
eventually--挿入ソートを一覧表示。

870
00:41:16,340 --> 00:41:18,020
私たちに沿ってなだめ。

871
00:41:18,020 --> 00:41:22,530
しかし、それでは、考えてみましょう
このリストを修正する最も簡単な方法。

872
00:41:22,530 --> 00:41:24,110
>> このリストはソートされません。

873
00:41:24,110 --> 00:41:26,130
どうして？

874
00:41:26,130 --> 00:41:31,920
英語では、理由を説明
それは実際にはソートされていません。

875
00:41:31,920 --> 00:41:33,400
それはソートされていない何を意味するのでしょうか？

876
00:41:33,400 --> 00:41:34,220
>> 学生：それは連続していないのです。

877
00:41:34,220 --> 00:41:34,990
>> DAVIDマラン：連続していません。

878
00:41:34,990 --> 00:41:35,822
私の例を与えます。

879
00:41:35,822 --> 00:41:37,180
>> STUDENT：順序でそれらを置きます。

880
00:41:37,180 --> 00:41:37,440
>> DAVIDマラン：OK。

881
00:41:37,440 --> 00:41:38,790
私はより具体的な例を与えます。

882
00:41:38,790 --> 00:41:39,832
>> STUDENT：昇順。

883
00:41:39,832 --> 00:41:41,206
DAVIDマラン：昇順ません。

884
00:41:41,206 --> 00:41:42,100
より正確に。

885
00:41:42,100 --> 00:41:45,190
私はあなたが上昇することによって何を意味するのか分かりません。

886
00:41:45,190 --> 00:41:47,150
どうしましたか？

887
00:41:47,150 --> 00:41:49,930
>> 学生：最小
数字は、第一の空間ではありません。

888
00:41:49,930 --> 00:41:51,140
>> DAVIDマラン：最小数の
ない最初のスペースインチ

889
00:41:51,140 --> 00:41:52,120
より具体的に。

890
00:41:52,120 --> 00:41:55,000
私がキャッチし始めています。

891
00:41:55,000 --> 00:41:59,470
我々は数えるが、しています
ここで順不同で何ですか？

892
00:41:59,470 --> 00:42:00,707
>> STUDENT：数値の配列。

893
00:42:00,707 --> 00:42:02,040
DAVIDマラン：数値の配列。

894
00:42:02,040 --> 00:42:04,248
保管のみんなの種類
それは非常に高いレベルをhere--。

895
00:42:04,248 --> 00:42:07,450
ただ、文字通り何を教えて
5歳のかもしれないような間違いました。

896
00:42:07,450 --> 00:42:08,310
>> STUDENT：プラス1。

897
00:42:08,310 --> 00:42:08,750
>> DAVIDマラン：それは何ですか？

898
00:42:08,750 --> 00:42:09,610
>> STUDENT：プラス1。

899
00:42:09,610 --> 00:42:11,235
>> DAVIDマラン：あなたは何を意味するのプラスワンのですか？

900
00:42:11,235 --> 00:42:12,754

901
00:42:12,754 --> 00:42:14,170
私に異なる5歳を与えます。

902
00:42:14,170 --> 00:42:16,840

903
00:42:16,840 --> 00:42:18,330
間違って、お母さんは何ですか？

904
00:42:18,330 --> 00:42:19,940
お父さん、何が悪いのでしょうか？

905
00:42:19,940 --> 00:42:22,808
あなたはこれがソートされていないとはどういう意味ですか？

906
00:42:22,808 --> 00:42:24,370
>> 学生：それは右の場所ではありません。

907
00:42:24,370 --> 00:42:25,580
>> DAVIDマラン：何が
ない適切な場所にありますか？

908
00:42:25,580 --> 00:42:26,174
>> 学生：フォー。

909
00:42:26,174 --> 00:42:27,090
DAVIDマラン：OK、良いです。

910
00:42:27,090 --> 00:42:29,110
それがあるべき場所だから4ではありません。

911
00:42:29,110 --> 00:42:30,590
具体的には、この権利はありますか？

912
00:42:30,590 --> 00:42:33,000
四一、第
私が見る二つの数字。

913
00:42:33,000 --> 00:42:34,930
これは正しいですか？

914
00:42:34,930 --> 00:42:36,427
いいえ、彼らは右、順不同でいますか？

915
00:42:36,427 --> 00:42:38,135
実際には、今思います
あまりにも、コンピュータに関する。

916
00:42:38,135 --> 00:42:40,824
それだけで、多分1で見ることができます
once--で多分二つのこと

917
00:42:40,824 --> 00:42:43,240
実際に一つだけ
同時に、それは、少なくとも

918
00:42:43,240 --> 00:42:45,790
その後、一つのことを見て
右隣に次の事。

919
00:42:45,790 --> 00:42:47,380
>> したがって、これらは順になっていますか？

920
00:42:47,380 --> 00:42:48,032
もちろん違います。

921
00:42:48,032 --> 00:42:48,740
だからあなたは何を知っていますか？

922
00:42:48,740 --> 00:42:51,020
なぜ我々は、赤ちゃんを取ることはありません
この問題を修正する手順

923
00:42:51,020 --> 00:42:53,410
代わりに、これらの空想をしているの
ベンのようなアルゴリズム

924
00:42:53,410 --> 00:42:56,440
彼は一種のことで、それを固定しています
リストをループ

925
00:42:56,440 --> 00:42:59,670
その代わりに、ここで私がやったことの
私たちが行くように私はちょうど種類のそれを修正しますか？

926
00:42:59,670 --> 00:43:03,650
ちょうど文字通り分解してみましょう
order--番号順の概念、

927
00:43:03,650 --> 00:43:06,990
あなたはwant--何でもそれを呼び出します
これらの対比較に。

928
00:43:06,990 --> 00:43:07,590
>> 四一。

929
00:43:07,590 --> 00:43:09,970
これは、正しい順序ですか？

930
00:43:09,970 --> 00:43:11,310
それでは、これを修正しましょう​​。

931
00:43:11,310 --> 00:43:14,700
1および4、その後
私達はちょうどそれをコピーします。

932
00:43:14,700 --> 00:43:15,560
すべての権利、良いです。

933
00:43:15,560 --> 00:43:17,022
私は1と4つの固定しました。

934
00:43:17,022 --> 00:43:18,320
スリーと2？

935
00:43:18,320 --> 00:43:18,820
いいえ。

936
00:43:18,820 --> 00:43:21,690
私の言葉は私の指を一致しましょう​​。

937
00:43:21,690 --> 00:43:23,695
四三？

938
00:43:23,695 --> 00:43:27,930
>> それは順序ではありませんので、私は行きますよ
1、3、4、2を行います。

939
00:43:27,930 --> 00:43:28,680
いいよ。

940
00:43:28,680 --> 00:43:32,310
今4と2？

941
00:43:32,310 --> 00:43:33,370
私たちも、この問題を解決する必要があります。

942
00:43:33,370 --> 00:43:36,700
だから、1、3、2、4。

943
00:43:36,700 --> 00:43:39,820
だから、ソートされていますか？

944
00:43:39,820 --> 00:43:43,170
いいえ、それはソートに近いのですか？

945
00:43:43,170 --> 00:43:48,930
>> 我々はこれを固定するのでそれは、あります
間違い、私たちは、この間違いを修正しました

946
00:43:48,930 --> 00:43:50,370
私たちはこの間違いを修正しました。

947
00:43:50,370 --> 00:43:52,420
だから我々は間違いなく3ミスを修正しました。

948
00:43:52,420 --> 00:43:58,100
まだ実際にソートされた見ていませんが、
それは、ソートに客観的に近いです

949
00:43:58,100 --> 00:44:00,080
我々は、これらのミスの一部を固定しているため。

950
00:44:00,080 --> 00:44:02,047
>> 今、私は次に何をしますか？

951
00:44:02,047 --> 00:44:03,630
私は種類のリストの最後に達しました。

952
00:44:03,630 --> 00:44:05,680
私は、固定されているように見えました
すべてのミス、ありません。

953
00:44:05,680 --> 00:44:08,510
この場合には、いくつかの数値ため、
近いバブルアップしている可能性があります

954
00:44:08,510 --> 00:44:10,410
他の番号へ
順不同で残っています。

955
00:44:10,410 --> 00:44:12,951
それでは、もう一度やってみましょう、と私はよ
だけの場所では、この時間は、それを行います。

956
00:44:12,951 --> 00:44:14,170
1と3？

957
00:44:14,170 --> 00:44:14,720
大丈夫だよ。

958
00:44:14,720 --> 00:44:16,070
スリーと2？

959
00:44:16,070 --> 00:44:17,560
もちろん無いので、のはそれを変更してみましょう。

960
00:44:17,560 --> 00:44:19,160
そう二つ、三つ。

961
00:44:19,160 --> 00:44:21,340
3と4？

962
00:44:21,340 --> 00:44:24,370
そして今、ちょうどであるとします
ここでは特に知識をひけらかします。

963
00:44:24,370 --> 00:44:26,350
それはソートされていますか？

964
00:44:26,350 --> 00:44:29,280
あなたの人間は、それがソートされています知っています。

965
00:44:29,280 --> 00:44:30,400
>> 私はもう一度試してみてください。

966
00:44:30,400 --> 00:44:31,900
だから、オリビアは、私はもう一度試して提案しています。

967
00:44:31,900 --> 00:44:32,530
どうして？

968
00:44:32,530 --> 00:44:35,810
コンピュータは持っていないので
私たち人間の目の贅沢

969
00:44:35,810 --> 00:44:38,080
ちょうどback-- OKかすめる、私は終わりです。

970
00:44:38,080 --> 00:44:41,610
どのようにコンピュータが決定しません
リストは、現在ソートされていますか？

971
00:44:41,610 --> 00:44:44,590
機械的に。

972
00:44:44,590 --> 00:44:47,650
>> 私は通過する必要があります
もう一度、と私だけの場合

973
00:44:47,650 --> 00:44:51,190
私は間違いを見つける/ことができますことはありません。
その後うん、コンピュータとして結論付け、

974
00:44:51,190 --> 00:44:51,980
我々は行ってもいいです。

975
00:44:51,980 --> 00:44:54,850
だから、1と2、2と
3、3と4。

976
00:44:54,850 --> 00:44:58,030
今私は決定的にこれがあると言うことができます
私は何も変更を加えていないので、ソート。

977
00:44:58,030 --> 00:45:01,940
今、それはバグだろうとだけ
愚かな私の場合、コンピュータ、

978
00:45:01,940 --> 00:45:05,640
再び、同じ質問をしました
異なった答えを期待。

979
00:45:05,640 --> 00:45:07,110
起こるべきではありません。

980
00:45:07,110 --> 00:45:08,600
>> そして今リストがソートされます。

981
00:45:08,600 --> 00:45:12,630
残念ながら、時間を実行しています
このアルゴリズムでもあるのn乗。

982
00:45:12,630 --> 00:45:13,130
どうして？

983
00:45:13,130 --> 00:45:19,520
nを番号を持っているので、とで
あなたはn個の数字を移動する必要があり、最悪の場合

984
00:45:19,520 --> 00:45:23,637
n回あなたが続けるために持っているので、
バックチェックして、潜在的に修正します

985
00:45:23,637 --> 00:45:24,220
これらの数字。

986
00:45:24,220 --> 00:45:26,280
そして、我々はより多くを行うことができます
フォーマル解析、あまりにも。

987
00:45:26,280 --> 00:45:29,530
>> だから、これは私たちが撮影したと言うことすべてであります
3異なるアプローチ、1

988
00:45:29,530 --> 00:45:32,210
それらのすぐに直感的な
ベンからバットオフ

989
00:45:32,210 --> 00:45:35,170
私の提案の挿入へ
この1へソート

990
00:45:35,170 --> 00:45:38,540
あなたは親切なのを見失うところ
最初にツリーの森。

991
00:45:38,540 --> 00:45:41,760
しかし、その後、あなたは、バックステップを取る場合
出来上がり、私たちはソート概念を修正しました。

992
00:45:41,760 --> 00:45:43,824
だから、これは、あえて言う、あります
おそらく、より低いレベル

993
00:45:43,824 --> 00:45:45,740
それらの他のいくつかより
アルゴリズムが、レッツ

994
00:45:45,740 --> 00:45:48,550
我々は視覚化することができないかどうかを確認
これらの本を介して。

995
00:45:48,550 --> 00:45:51,450
>> だから、これはいくつかの素晴らしいです
ソフトウェア誰か

996
00:45:51,450 --> 00:45:56,110
カラフルなバーのを使って書きました
私たちのために以下のことをするつもり。

997
00:45:56,110 --> 00:45:57,736
これらのバーのそれぞれは、数を表します。

998
00:45:57,736 --> 00:46:00,026
背の高いバー、大きな
数、小さいバー、

999
00:46:00,026 --> 00:46:00,990
数より小さい。

1000
00:46:00,990 --> 00:46:05,880
だから理想的に、私たちは素敵なピラミッドを望みます
それは小さな始まり、大きな取得する場所、

1001
00:46:05,880 --> 00:46:08,330
それはそれを意味します
これらのバーがソートされています。

1002
00:46:08,330 --> 00:46:11,200
だから私は先に行くと選択するつもりです、
例えば、ベンのアルゴリズム

1003
00:46:11,200 --> 00:46:13,990
first--選択ソート。

1004
00:46:13,990 --> 00:46:16,220
>> そして、それはやっているものに気づきます。

1005
00:46:16,220 --> 00:46:18,670
彼らが選んだ道
このアルゴリズムを可視化

1006
00:46:18,670 --> 00:46:22,090
それは私がしただけのようであり、
私のリストを歩いて、

1007
00:46:22,090 --> 00:46:24,710
このプログラムは、歩いています
番号のリストを通じ、

1008
00:46:24,710 --> 00:46:28,160
ピンクのそれぞれにハイライト
それは見ての番号。

1009
00:46:28,160 --> 00:46:32,360
そして今起こることについては何ですか？

1010
00:46:32,360 --> 00:46:35,154
>> その最小数
Iまたはベンは突然発見しました

1011
00:46:35,154 --> 00:46:36,820
リストの先頭に移動します。

1012
00:46:36,820 --> 00:46:40,037
そして、彼らは追い出しをしたに気付きます
あった数、

1013
00:46:40,037 --> 00:46:41,120
それは完全に罰金です。

1014
00:46:41,120 --> 00:46:42,600
私は細部のそのレベルに取得できませんでした。

1015
00:46:42,600 --> 00:46:44,308
しかし、我々は、配置する必要があります
その数はどこか、

1016
00:46:44,308 --> 00:46:47,775
私たちはちょうどにそれを移動しました
作成されたオープンなスポット。

1017
00:46:47,775 --> 00:46:49,900
だから私はこれを高速化するつもりです
アップ、それ以外の場合理由

1018
00:46:49,900 --> 00:46:51,871
すぐに非常に大変な作業となります。

1019
00:46:51,871 --> 00:46:55,800

1020
00:46:55,800 --> 00:46:58,600
アニメーションがspeed--私達は行きます。

1021
00:46:58,600 --> 00:47:01,850
だから今同じ原理
I適用したが、あなた

1022
00:47:01,850 --> 00:47:06,540
もしあれば、アルゴリズムを感じるように開始することができます
意志、あるいはもう少し明確にそれを参照してください。

1023
00:47:06,540 --> 00:47:13,190
このアルゴリズムは、効果を有します
次の最小の要素を選択し、

1024
00:47:13,190 --> 00:47:16,422
あなたはを開始するつもりです
それは左のランプアップを参照してください。

1025
00:47:16,422 --> 00:47:19,130
また、各繰り返しで、私は、
提案された、それは少し作業を行います。

1026
00:47:19,130 --> 00:47:21,921
これは、すべての道を行く必要はありません。
バックリストの左端に、

1027
00:47:21,921 --> 00:47:23,900
すでにので、
ソートされているものが知っています。

1028
00:47:23,900 --> 00:47:28,129
それはだようなので、それは一種の感じ
各ステップであっても、加速

1029
00:47:28,129 --> 00:47:29,420
同じだけの時間を取ります。

1030
00:47:29,420 --> 00:47:31,600
残りわずか少ない手順があります。

1031
00:47:31,600 --> 00:47:35,240
そして今、あなたは一種の感じることができます
このアルゴリズムは、それの終わりをクリーンアップ

1032
00:47:35,240 --> 00:47:37,040
実際、今それがソートされています。

1033
00:47:37,040 --> 00:47:41,620
>> だから、挿入ソートはすべて完了です。

1034
00:47:41,620 --> 00:47:43,600
私は配列を再ランダム化する必要があります。

1035
00:47:43,600 --> 00:47:45,940
そして、ちょうど私ができる気付きます
それをランダムに保ちます、

1036
00:47:45,940 --> 00:47:50,630
そして我々は、の近似値を取得します
同じアプローチ、挿入ソート。

1037
00:47:50,630 --> 00:47:55,050
私はここにそれをスローダウンしてみましょう。

1038
00:47:55,050 --> 00:47:56,915
のはそれを最初からやり直しましょう​​。

1039
00:47:56,915 --> 00:47:57,414
やめる。

1040
00:47:57,414 --> 00:48:00,662

1041
00:48:00,662 --> 00:48:02,410
>> それでは、4をスキップしてみましょう。

1042
00:48:02,410 --> 00:48:03,200
そうしよう。

1043
00:48:03,200 --> 00:48:04,190
それらの配列をランダム。

1044
00:48:04,190 --> 00:48:05,555
そして、ここでは挿入ソートをgo--。

1045
00:48:05,555 --> 00:48:10,260

1046
00:48:10,260 --> 00:48:12,800
遊びます。

1047
00:48:12,800 --> 00:48:17,280
それは各扱っていますことに注意してください
それはすぐに遭遇した要素、

1048
00:48:17,280 --> 00:48:20,282
しかし、それはに属している場合
間違った場所の通知

1049
00:48:20,282 --> 00:48:21,740
起こることがありすべての作業。

1050
00:48:21,740 --> 00:48:24,700
私たちは、より多くのシフト維持する必要があります
そしてより多くの要素が部屋を作るために

1051
00:48:24,700 --> 00:48:27,340
1のために我々は場所に置きたいです。

1052
00:48:27,340 --> 00:48:30,740
>> だから我々は、に焦点を当てています
リストのみの左端。

1053
00:48:30,740 --> 00:48:34,460
私たちも、at--私たちを見ていません注意してください
ピンク何で強調表示されていません

1054
00:48:34,460 --> 00:48:35,610
右の方へ。

1055
00:48:35,610 --> 00:48:38,180
私達はちょうどを扱っています
問題我々が行くように、

1056
00:48:38,180 --> 00:48:40,430
しかし、我々は多くのを作成しています
まだ自分自身のために働きます。

1057
00:48:40,430 --> 00:48:44,410
そして、私たちはこれをスピードアップする場合
今完了に行くために、

1058
00:48:44,410 --> 00:48:46,210
それは確かにそれとは異なる感触を持っています。

1059
00:48:46,210 --> 00:48:50,150
それはちょうど左端に焦点を当てていますが、
needed--としてもう少し仕事をして

1060
00:48:50,150 --> 00:48:53,230
平滑どのような種類のもの
オーバー、物事を固定し、

1061
00:48:53,230 --> 00:48:58,350
しかし、で最終的に扱います
一度に各要素1

1062
00:48:58,350 --> 00:49:07,740
私たちがよくthe--するために取得するまで、我々
すべてはこれが終了しようとしている方法を知って、

1063
00:49:07,740 --> 00:49:09,700
それはおそらく、少しがっかりです。

1064
00:49:09,700 --> 00:49:12,830
>> しかしend--中リスト
spoiler--がソートされようとしています。

1065
00:49:12,830 --> 00:49:15,300
それでは、最後の1を見てみましょう。

1066
00:49:15,300 --> 00:49:16,840
私達はちょうど今スキップすることはできません。

1067
00:49:16,840 --> 00:49:18,000
私たちはほとんどがしています。

1068
00:49:18,000 --> 00:49:19,980
どこへ行くか二つ、行くために1。

1069
00:49:19,980 --> 00:49:22,680
出来上がり。

1070
00:49:22,680 --> 00:49:23,450
優れた。

1071
00:49:23,450 --> 00:49:27,220
>> だから今のは、最後のいずれかを実行してみましょう、
再ランダム化バブルソートと。

1072
00:49:27,220 --> 00:49:31,690
そして、私はそれを遅らせる場合は特に、ここに気付きます
ダウン、これは貫通急降下続けるん。

1073
00:49:31,690 --> 00:49:36,830
しかし、それだけでペアごとになります気づきます
局所解のcomparisons--一種。

1074
00:49:36,830 --> 00:49:39,050
しかし、すぐに、我々はに取るにつれて
ピンクで、リストの末尾、

1075
00:49:39,050 --> 00:49:40,690
何が再び起こるしているつもりですか？

1076
00:49:40,690 --> 00:49:44,539

1077
00:49:44,539 --> 00:49:46,830
ええ、しているつもりです
それだけであるため、最初からやり直します

1078
00:49:46,830 --> 00:49:49,870
固定ペアごとのミス。

1079
00:49:49,870 --> 00:49:53,120
そして、それはまだ他の人が明らかになっている可能性があります。

1080
00:49:53,120 --> 00:49:58,950
あなたがこれをスピードアップするそうなら、あなたはよ
、名前が示す限り、それを参照してください。

1081
00:49:58,950 --> 00:50:01,870
elements--小さいかではなく、
より大きなelements--が開始されています

1082
00:50:01,870 --> 00:50:03,740
バブルへ戻るまで、可能ならば。

1083
00:50:03,740 --> 00:50:07,380
小さい要素があります
ダウン左にバブルに始まります。

1084
00:50:07,380 --> 00:50:10,780
そして実際、それは一種のです
同様に視覚効果。

1085
00:50:10,780 --> 00:50:17,150
そして、これは仕上げてしまいます
非常に類似した方法で、あまりにも。

1086
00:50:17,150 --> 00:50:19,160
>> 私たちは住む必要はありません
この特定の1に。

1087
00:50:19,160 --> 00:50:21,010
私も、今これを開いてみましょう。

1088
00:50:21,010 --> 00:50:24,040
他のいくつかのソートアルゴリズムがあります
世界では、そのいくつかの

1089
00:50:24,040 --> 00:50:25,580
ここで捕捉されます。

1090
00:50:25,580 --> 00:50:29,960
特にありません学習者のための
必ずしも視覚的または数学的、

1091
00:50:29,960 --> 00:50:31,930
我々の前に行ったように、我々はできます
またaudiallyこれを行います

1092
00:50:31,930 --> 00:50:34,210
私たちはこれで音を関連付ける場合。

1093
00:50:34,210 --> 00:50:36,990
そして、ちょうど楽しみのために、ここです
いくつかの異なるアルゴリズム、

1094
00:50:36,990 --> 00:50:40,950
あなたがしている、特にそれらの一つ
呼ばれて気づくことだろう "マージソート。」

1095
00:50:40,950 --> 00:50:43,250
>> それは実際に基本的です
より良いアルゴリズム、

1096
00:50:43,250 --> 00:50:45,860
その結果、マージソート、の1
あなたが見しようとしているもの、

1097
00:50:45,860 --> 00:50:49,170
乗n個の順序ではありません。

1098
00:50:49,170 --> 00:50:57,280
これは、n回のオーダーでの対数い
実際に小さいので、あるnは、

1099
00:50:57,280 --> 00:50:58,940
他の3よりも速いです。

1100
00:50:58,940 --> 00:51:00,670
そして、他のカップルがあります
我々が表示されます愚かなもの。

1101
00:51:00,670 --> 00:51:01,933
>> そこでここではいくつかの音で行きます。

1102
00:51:01,933 --> 00:51:06,620

1103
00:51:06,620 --> 00:51:10,490
これには、もう一度、挿入ソートであります
それだけの要素を扱っています

1104
00:51:10,490 --> 00:51:13,420
彼らが来るように。

1105
00:51:13,420 --> 00:51:17,180
これは、バブルソートであるので、それはです
一度にペアを考えます。

1106
00:51:17,180 --> 00:51:22,030

1107
00:51:22,030 --> 00:51:24,490
そして再び、最大の要素
トップに湧き上がっています。

1108
00:51:24,490 --> 00:51:38,098

1109
00:51:38,098 --> 00:51:41,710
>> 次に選択ソートアップ。

1110
00:51:41,710 --> 00:51:45,420
これはベンのアルゴリズムであり、
再び彼が反復的に選択することです

1111
00:51:45,420 --> 00:51:46,843
次の最小の要素。

1112
00:51:46,843 --> 00:51:49,801

1113
00:51:49,801 --> 00:51:53,900
そして再び、今、あなたは本当にそれを聞くことができます
それが唯一のこれまでのところでスピードアップです

1114
00:51:53,900 --> 00:51:58,230
それが少なくをやっているように
各反復に取り組みます。

1115
00:51:58,230 --> 00:52:04,170
これは、速いものであり、マージソート
数のクラスタをソートしています

1116
00:52:04,170 --> 00:52:05,971
一緒にし、それらを組み合わせます。

1117
00:52:05,971 --> 00:52:07,720
だから、左をlook--
半分はすでにソートされています。

1118
00:52:07,720 --> 00:52:14,165
>> 今では右半分を並べ替えていますし、
今では1にそれらを組み合わせることが起こっています。

1119
00:52:14,165 --> 00:52:19,160
これはと呼ばれるものである」ノームソート。」

1120
00:52:19,160 --> 00:52:23,460
そして、あなたは一種のそれを見ることができます
それは、前後になるだろう

1121
00:52:23,460 --> 00:52:27,950
少しここで仕事を固定し、
そこにそれが新しい仕事に進みます。

1122
00:52:27,950 --> 00:52:32,900

1123
00:52:32,900 --> 00:52:33,692
以上です。

1124
00:52:33,692 --> 00:52:36,400
別のソートは、あります
本当にただ学術目的のために、

1125
00:52:36,400 --> 00:52:40,980
かかる「愚かなソート」と呼ばれます
あなたのデータを、ランダムにそれをソートし、

1126
00:52:40,980 --> 00:52:43,350
それがソートされている場合、次にチェックします。

1127
00:52:43,350 --> 00:52:47,880
そうでない場合、それは再ソートし、それを
それはソートいた場合、ランダムに、チェックし、

1128
00:52:47,880 --> 00:52:49,440
繰り返すない場合。

1129
00:52:49,440 --> 00:52:52,660
そして、理論的には、確率的に
これは、完了します

1130
00:52:52,660 --> 00:52:54,140
しかし、かなりの時間後。

1131
00:52:54,140 --> 00:52:56,930
これは、ほとんどありません
アルゴリズムの効率的。

1132
00:52:56,930 --> 00:53:02,550
それらの上だからご質問
特定のアルゴリズムか何か

1133
00:53:02,550 --> 00:53:04,720
あまりにも、そこに関連しますか？

1134
00:53:04,720 --> 00:53:09,430
>> さて、今何すべてを離れていじめるしましょう
これらの行は、私が描画されてきたことがあります

1135
00:53:09,430 --> 00:53:15,090
そして、私はコンピュータを仮定しているもの
フードの下に行うことができます。

1136
00:53:15,090 --> 00:53:18,650
私はこれらの数字のすべてのことを主張するだろう
私は、彼らが取得する必要がありdrawing--続けます

1137
00:53:18,650 --> 00:53:21,330
メモリのどこかに保存されています。

1138
00:53:21,330 --> 00:53:24,130
我々はあまりにも、今、この男を取り除くでしょう。

1139
00:53:24,130 --> 00:53:30,110
>> メモリのだから作品
そうRAM DIMMがありますcomputer--

1140
00:53:30,110 --> 00:53:35,480
私たちは、デュアル、昨日検索
インライン・メモリ・module--は次のようになります。

1141
00:53:35,480 --> 00:53:39,370
そして、これらの小さな黒いチップの各
一般的に、バイトのいくつかの数です。

1142
00:53:39,370 --> 00:53:44,380
そして、金のピンは似ています
それをコンピュータに接続するワイヤ、

1143
00:53:44,380 --> 00:53:47,521
そして、緑のシリコン基板だけです
何がすべて一緒にすべてを保持します。

1144
00:53:47,521 --> 00:53:48,770
だから、これは本当に何を意味するのでしょうか？

1145
00:53:48,770 --> 00:53:53,180
私は一種のこの同じ絵を描く場合は、
のは、簡単にするために仮定しましょう

1146
00:53:53,180 --> 00:53:55,280
このDIMM、デュアルその
インラインメモリモジュール、

1147
00:53:55,280 --> 00:54:00,530
RAMの1ギガバイトの1ギガバイトです
どのように多くのバイト数の合計であるメモリ、？

1148
00:54:00,530 --> 00:54:02,100
1ギガバイトは何バイトですか？

1149
00:54:02,100 --> 00:54:04,860

1150
00:54:04,860 --> 00:54:06,030
それ以上。

1151
00:54:06,030 --> 00:54:09,960
1124は、キロ千です。

1152
00:54:09,960 --> 00:54:11,730
メガは百万円であります。

1153
00:54:11,730 --> 00:54:14,570
ギガは十億です。

1154
00:54:14,570 --> 00:54:15,070
>> 私は嘘をついていますか？

1155
00:54:15,070 --> 00:54:16,670
私たちも、ラベルを読むことができますか？

1156
00:54:16,670 --> 00:54:19,920
これは実際には128です
ギガバイトは、それはより多くのです。

1157
00:54:19,920 --> 00:54:22,130
しかし、我々はこれをふり
ちょうど1ギガバイトです。

1158
00:54:22,130 --> 00:54:25,640
だから、億がありますことを意味します
私には利用可能なメモリのバイト

1159
00:54:25,640 --> 00:54:29,770
80億ビットが、我々はつもりか
今バイトの観点で話をします、

1160
00:54:29,770 --> 00:54:30,750
前進。

1161
00:54:30,750 --> 00:54:36,330
>> それでは、それが意味することは、これはされています
1バイトは、これが別のバイトであり、

1162
00:54:36,330 --> 00:54:38,680
これは別のバイトであり、
そして私たちは本当にたい場合

1163
00:54:38,680 --> 00:54:43,280
具体的には我々がしなければなりません
億少し正方形を描きます。

1164
00:54:43,280 --> 00:54:44,320
しかし、それは何を意味するのでしょうか？

1165
00:54:44,320 --> 00:54:46,420
まあ、私はちょうどズームインしてみましょう
この画面上インチ

1166
00:54:46,420 --> 00:54:50,900
私が何かを持っていればそれが見えます
このように、今、それは4バイトです。

1167
00:54:50,900 --> 00:54:53,710
>> だから私はここで4つの数字を入れることができます。

1168
00:54:53,710 --> 00:54:54,990
1 2 3 4。

1169
00:54:54,990 --> 00:55:00,170
または私は4つの文字や記号を置くことができます。

1170
00:55:00,170 --> 00:55:02,620
「おい！」右そこに行くことができ、
文字の各ので、

1171
00:55:02,620 --> 00:55:04,370
我々は先に述べました、
表すことができます

1172
00:55:04,370 --> 00:55:06,650
8ビットまたはASCIIまたはバイトと。

1173
00:55:06,650 --> 00:55:09,370
換言すれば、次のことができます
内部80億ものを入れます

1174
00:55:09,370 --> 00:55:11,137
メモリのこの1スティックの。

1175
00:55:11,137 --> 00:55:14,345
今では戻って物事を置くために何を意味しています
このようにメモリに背中合わせにするには？

1176
00:55:14,345 --> 00:55:17,330
これはどのようなプログラマです
「アレイ」を呼んで

1177
00:55:17,330 --> 00:55:21,250
コンピュータ・プログラムでは、あなたは思いません
基盤となるハードウェアについては、それ自体が。

1178
00:55:21,250 --> 00:55:24,427
あなただけのものとして自分自身を考えます
億バイトの合計へのアクセス、

1179
00:55:24,427 --> 00:55:26,010
あなたは何でもあなたはそれを望むことができます。

1180
00:55:26,010 --> 00:55:27,880
しかし、便宜上
それは一般的に便利です

1181
00:55:27,880 --> 00:55:31,202
あなたの記憶の権利を維持します
このような隣同士に。

1182
00:55:31,202 --> 00:55:33,660
だから私はthis--をズームインするとき、
我々は確かにつもりはないので、

1183
00:55:33,660 --> 00:55:39,310
億少しsquares--を描画します
それでは、このボードが表すと仮定してみましょう

1184
00:55:39,310 --> 00:55:40,610
今メモリのスティック。

1185
00:55:40,610 --> 00:55:43,800
そして、私は同じように多くの私のように描きます
マーカーは、ここで私を与えてしまいます。

1186
00:55:43,800 --> 00:55:46,420

1187
00:55:46,420 --> 00:55:52,300
だから今、私たちは棒を持っています
ボード上のメモリの

1188
00:55:52,300 --> 00:55:56,400
それは、1つ、2つ、3つ、4つ、5を持っています、
6、一つ、二つ、三つ、四つ、五つ、六つ、

1189
00:55:56,400 --> 00:56:01,130
のように42バイトをseven--
画面全体の上のメモリ。

1190
00:56:01,130 --> 00:56:01,630
ありがとうございました。

1191
00:56:01,630 --> 00:56:02,838
はい、私の算術右ました。

1192
00:56:02,838 --> 00:56:05,120
そこでここでは、メモリの42バイト。

1193
00:56:05,120 --> 00:56:06,660
だから、これは実際に何を意味するのでしょうか？

1194
00:56:06,660 --> 00:56:09,830
まあ、コンピュータープログラマー
実際に、一般的だろう

1195
00:56:09,830 --> 00:56:12,450
アドレス指定可能なように、このメモリを考えます。

1196
00:56:12,450 --> 00:56:16,630
換言すれば、これらの一つ一つ
メモリ内の位置、ハードウェアで、

1197
00:56:16,630 --> 00:56:18,030
固有のアドレスを有しています。

1198
00:56:18,030 --> 00:56:22,020
>> それは一つのガタガタ音を立てるような複雑なものではありません
スクエア、ケンブリッジ、マサチューセッツ州、02138。

1199
00:56:22,020 --> 00:56:23,830
その代わりに、それだけの数です。

1200
00:56:23,830 --> 00:56:27,930
これは、このは、バイト数はゼロです
一これが2である、これは3であり、

1201
00:56:27,930 --> 00:56:30,327
これは41です。

1202
00:56:30,327 --> 00:56:30,910
ちょっと待って。

1203
00:56:30,910 --> 00:56:32,510
私は一瞬前42を言ったと思いました。

1204
00:56:32,510 --> 00:56:35,050

1205
00:56:35,050 --> 00:56:37,772
私は、ゼロからカウントを開始しました
そのためには、実際に正しいのです。

1206
00:56:37,772 --> 00:56:40,980
今、私たちは実際にそれを描画する必要はありません
グリッドとして、あなたはグリッドとしてそれを描く場合

1207
00:56:40,980 --> 00:56:43,520
私は実際に物事を考えます
少し誤解を招く取得。

1208
00:56:43,520 --> 00:56:46,650
どのようなプログラマだろう、
彼または彼女自身の心の中で、

1209
00:56:46,650 --> 00:56:50,310
一般的と考えます
メモリちょうどテープのようなものであるとして、

1210
00:56:50,310 --> 00:56:53,340
マスキングテープの一片のような
それはただの、永遠に行きます

1211
00:56:53,340 --> 00:56:54,980
またはあなたがメモリ不足になるまで。

1212
00:56:54,980 --> 00:56:59,200
描画するので、より多くの一般的な方法
そして、メモリだけを考えます

1213
00:56:59,200 --> 00:57:03,710
これはバイトゼロ、1であるということでしょう、
2つ、3つ、その後ドット、ドット、ドット。

1214
00:57:03,710 --> 00:57:07,650
あなたも、42そのようなバイトの合計持っています
物理的に、それは実際にかもしれませんが

1215
00:57:07,650 --> 00:57:09,480
もっとこのようなものになります。

1216
00:57:09,480 --> 00:57:12,850
>> ですから、今、あなたの考える場合
ちょうどテープのように、このようなメモリ、

1217
00:57:12,850 --> 00:57:17,640
これは、どのようなプログラマ再びです
メモリの配列を呼び出します。

1218
00:57:17,640 --> 00:57:20,660
そして、あなたが実際に保存したいとき
コンピュータのメモリで何か、

1219
00:57:20,660 --> 00:57:23,290
あなたは、一般的に店舗の物事を行います
背中合わせ背中合わせします。

1220
00:57:23,290 --> 00:57:25,010
だから我々は、数字の話をしてきました。

1221
00:57:25,010 --> 00:57:30,880
そして、私は問題を解決するために望んでいたとき、
様4、ある三、2つの

1222
00:57:30,880 --> 00:57:33,820
私は描いていたにもかかわらず、
数字のみ4、1、3、

1223
00:57:33,820 --> 00:57:39,490
ボード上の2つの、希望のコンピュータ
本当にメモリで、このセットアップを持っています。

1224
00:57:39,490 --> 00:57:43,347
>> そして隣に何でしょう
コンピュータのメモリ内の2つの？

1225
00:57:43,347 --> 00:57:44,680
まあ、それに対する答えはありません。

1226
00:57:44,680 --> 00:57:45,770
私たちは本当に知りません。

1227
00:57:45,770 --> 00:57:48,200
そして限り、
コンピュータはそれを必要としません、

1228
00:57:48,200 --> 00:57:51,440
それは次の何であるかを気にする必要はありません。
数字には気にしません。

1229
00:57:51,440 --> 00:57:55,130
そして、私はコンピュータことを先に言ったとき
一度に一つのアドレスを見ることができ、

1230
00:57:55,130 --> 00:57:56,170
これはなぜの一種です。

1231
00:57:56,170 --> 00:57:59,490
>> いないレコードとは異なり、
プレーヤーと読み取りヘッド

1232
00:57:59,490 --> 00:58:03,030
のみ、特定のを見てできること
物理的な古い学校レコードの溝

1233
00:58:03,030 --> 00:58:06,500
一度に、同様に
コンピュータのおかげですることができます

1234
00:58:06,500 --> 00:58:09,810
そのCPUへとその
インテル命令セット、

1235
00:58:09,810 --> 00:58:12,480
その命令のうち、
メモリから読み出され

1236
00:58:12,480 --> 00:58:15,590
またはmemory--への保存
コンピュータにのみ見ることができます

1237
00:58:15,590 --> 00:58:19,210
time-- 1つの場所で
時々それらの組み合わせ

1238
00:58:19,210 --> 00:58:21,770
しかし、実際に一度に一つだけの場所。

1239
00:58:21,770 --> 00:58:24,770
だから我々がやっていたとき
これらの様々なアルゴリズム、

1240
00:58:24,770 --> 00:58:28,110
私はちょうどに書いていませんよ
vacuum-- 4、1、3、2。

1241
00:58:28,110 --> 00:58:30,849
これらの数字は、実際に属しています
メモリ内の物理どこか。

1242
00:58:30,849 --> 00:58:32,890
だから、小さな小さながあります
トランジスタまたはいくつかの種類

1243
00:58:32,890 --> 00:58:35,840
下にエレクトロニクスの
フードは、これらの値を記憶します。

1244
00:58:35,840 --> 00:58:40,460
>> そして、合計で、どのように多くのビットであり、
ただ明確にすることが、今の関与？

1245
00:58:40,460 --> 00:58:45,580
だから、これは4バイトである、または
今では32ビットの合計です。

1246
00:58:45,580 --> 00:58:49,280
だから、実際には32のゼロがあると
これら4物事を構成するもの。

1247
00:58:49,280 --> 00:58:52,070
あり、さらにここではオーバーだが、
再び、我々はそれについて気にしません。

1248
00:58:52,070 --> 00:58:55,120
>> だから今のは別のものを尋ねてみましょう
メモリを使用した質問、

1249
00:58:55,120 --> 00:58:57,519
その末尾の理由
一日の差異です。

1250
00:58:57,519 --> 00:59:00,310
どんなに私たちががどう処理されますか
一日の終わりに、コンピュータ、

1251
00:59:00,310 --> 00:59:02,560
ハードウェアはまだあります
ボンネットの下に同じ。

1252
00:59:02,560 --> 00:59:04,670
どのように私はここに単語を保存するのでしょうか？

1253
00:59:04,670 --> 00:59:09,710
さて、コンピュータ内の単語のように
「ちょっと！」ちょうどこのように格納されます。

1254
00:59:09,710 --> 00:59:12,300
そして、あなたは長いを望んでいた場合
言葉は、単にすることができます

1255
00:59:12,300 --> 00:59:19,120
それを上書きして何かを言います
「こんにちは」のような、そのここに格納します。

1256
00:59:19,120 --> 00:59:23,930
>> ので、ここでは、あまりにも、この連続性
利点は、実際に

1257
00:59:23,930 --> 00:59:26,530
コンピュータはちょうどことができるので、
右から左に読みます。

1258
00:59:26,530 --> 00:59:28,680
しかし、ここで質問です。

1259
00:59:28,680 --> 00:59:33,480
この単語の文脈において、
H-E-L-L-O、感嘆符、

1260
00:59:33,480 --> 00:59:38,740
どこでどのようにコンピュータが知っているかもしれません
単語が始まり、言葉が終わるところ？

1261
00:59:38,740 --> 00:59:41,690

1262
00:59:41,690 --> 00:59:43,800
数値の文脈では、
どのようにコンピュータがありません

1263
00:59:43,800 --> 00:59:48,396
どのくらいのシーケンスを知っています
数字であるか、またはそれが始まりますか？

1264
00:59:48,396 --> 00:59:50,270
まあ、それはout--なります
私たちはあまり行くことはありません

1265
00:59:50,270 --> 00:59:54,970
detail--のこのレベルに
コンピュータは、メモリ内の周りのものを移動させます

1266
00:59:54,970 --> 00:59:57,800
文字通り、これらのアドレスを介して。

1267
00:59:57,800 --> 01:00:02,080
コンピュータ内だから、あなたがしている場合
物事を格納するためにコードを書きます

1268
01:00:02,080 --> 01:00:05,800
言葉のように、何をしています
実際に入力されてい

1269
01:00:05,800 --> 01:00:11,320
で覚えているの式
コンピュータのメモリ、これらの言葉があります。

1270
01:00:11,320 --> 01:00:14,370
だから私は非常にやらせます、
非常に簡単な例。

1271
01:00:14,370 --> 01:00:18,260
>> 私は先に行くつもりだと
単純なテキストプログラムを開き、

1272
01:00:18,260 --> 01:00:20,330
そして、私は作成するつもりです
hello.cというファイル。

1273
01:00:20,330 --> 01:00:22,849
この情報のほとんどは、我々
非常に詳細に説明しません、

1274
01:00:22,849 --> 01:00:25,140
私は書くつもりです
その同じ言語でプログラム、

1275
01:00:25,140 --> 01:00:31,140
C.これは、はるかに威圧的です
私はスクラッチよりも、主張するだろう、

1276
01:00:31,140 --> 01:00:32,490
それは精神に非常に似ています。

1277
01:00:32,490 --> 01:00:34,364
実際には、これらの巻き
braces--することができます種類の

1278
01:00:34,364 --> 01:00:37,820
私はちょうどこのように何をしたかと思います。

1279
01:00:37,820 --> 01:00:39,240
>> それでは、実際に、これを実行してみましょう。

1280
01:00:39,240 --> 01:00:45,100
緑の旗をクリックすると、
次の手順を実行します。

1281
01:00:45,100 --> 01:00:50,210
私はプリントアウトしたい "こんにちは。"

1282
01:00:50,210 --> 01:00:51,500
だから、これは今擬似コードです。

1283
01:00:51,500 --> 01:00:53,000
私は種類のラインをぼかしています。

1284
01:00:53,000 --> 01:00:56,750
C言語では、この言語は私が話しています
こんにちはこのラインプリント、約

1285
01:00:56,750 --> 01:01:01,940
実際に「printf関数」になります
いくつかの括弧およびセミコロン。

1286
01:01:01,940 --> 01:01:03,480
>> しかし、それはまったく同じ考えです。

1287
01:01:03,480 --> 01:01:06,730
そして、これは非常にユーザーフレンドリー
「グリーンフラッグがクリックされたとき」になります

1288
01:01:06,730 --> 01:01:10,182
はるかに難解な「int型メイン無効。 "

1289
01:01:10,182 --> 01:01:12,890
そして、これは実際にはマッピングされていません、
私はちょうどそれを無視するつもりです。

1290
01:01:12,890 --> 01:01:17,210
しかし、中括弧のようなものです
このような湾曲したパズルのピース。

1291
01:01:17,210 --> 01:01:18,700
>> だから、一種の推測することができます。

1292
01:01:18,700 --> 01:01:22,357
あなたは以前にプログラムされたことがない場合であっても、
このプログラムは、おそらく何をするのでしょうか？

1293
01:01:22,357 --> 01:01:25,560

1294
01:01:25,560 --> 01:01:28,000
おそらくハロー印刷
感嘆符を持ちます。

1295
01:01:28,000 --> 01:01:29,150
>> それでは、それを試してみましょう。

1296
01:01:29,150 --> 01:01:30,800
私はそれを保存するつもりです。

1297
01:01:30,800 --> 01:01:34,000
そして、これは、再び、非常にあります
古い学校の環境。

1298
01:01:34,000 --> 01:01:35,420
私はドラッグすることはできません、クリックすることはできません。

1299
01:01:35,420 --> 01:01:36,910
私は、コマンドを入力する必要があります。

1300
01:01:36,910 --> 01:01:41,320
だから私は、私のプログラムを実行したいです
私はhello.cのように、これを実行します。

1301
01:01:41,320 --> 01:01:42,292
それは私が走ったファイルです。

1302
01:01:42,292 --> 01:01:43,500
しかし、私はステップを欠けている、待ってください。

1303
01:01:43,500 --> 01:01:46,470
我々は必要です何と言いました
Cのような言語のためのステップ？

1304
01:01:46,470 --> 01:01:49,470
私はソースを書きました
コー​​ドが、私は何が必要なのですか？

1305
01:01:49,470 --> 01:01:50,670
ええ、私はコンパイラが必要です。

1306
01:01:50,670 --> 01:01:57,670
だからここに私のMac上で、私が持っています
GCCと呼ばれるプログラム、GNU Cコンパイラ、

1307
01:01:57,670 --> 01:02:03,990
私はthis--ターンを行うことを可能にします
私のソースコードには、我々はそれを呼ぶことにします、

1308
01:02:03,990 --> 01:02:04,930
マシンコード。

1309
01:02:04,930 --> 01:02:10,180
>> そして、私はそれを見ることができ、
再び、次のように、これらの

1310
01:02:10,180 --> 01:02:14,090
0と1私はちょうどあります
私のソースコードから作成され、

1311
01:02:14,090 --> 01:02:15,730
0と1のすべて。

1312
01:02:15,730 --> 01:02:17,770
そして、私は実行したい場合
それが起こる私のprogram--

1313
01:02:17,770 --> 01:02:23,010
a.outと呼ばれるように
歴史的reasons--「こんにちは。」

1314
01:02:23,010 --> 01:02:24,070
私は再びそれを実行することができます。

1315
01:02:24,070 --> 01:02:25,690
こんにちは、こんにちは、こんにちは。

1316
01:02:25,690 --> 01:02:27,430
そして、それは動作しているようです。

1317
01:02:27,430 --> 01:02:31,000
>> しかし、それはどこかに私の中で意味します
コンピュータのメモリ言葉です

1318
01:02:31,000 --> 01:02:35,279
H-E-L-L-O、感嘆符。

1319
01:02:35,279 --> 01:02:38,070
そして、それはちょうどさておきとして、結局のところ、
どのようなコンピュータが通常と

1320
01:02:38,070 --> 01:02:40,550
それはどこで知っているように行います
物事が起動し、それがですend--

1321
01:02:40,550 --> 01:02:42,460
ここで特殊記号を置くつもり。

1322
01:02:42,460 --> 01:02:46,064
そして大会は置くことです
単語の末尾の数字のゼロ

1323
01:02:46,064 --> 01:02:48,230
あなたはどこで知っているように、
実際に、終了しているので

1324
01:02:48,230 --> 01:02:52,750
より多くのをプリントアウト保持しません
あなたが実際に予定よりも文字。

1325
01:02:52,750 --> 01:02:55,400
>> しかし、ここで持ち帰り、偶数
これはかなり難解ですが、

1326
01:02:55,400 --> 01:02:58,140
それは最終的だということです
比較的単純な。

1327
01:02:58,140 --> 01:03:04,550
あなたは、ブランクテープのようなものを与えられました
あなたは手紙を書くことができたスペース。

1328
01:03:04,550 --> 01:03:07,150
あなたは、単に持っている必要があります
任意のような特殊記号、

1329
01:03:07,150 --> 01:03:10,316
の末尾に入れて数字のゼロ、
あなたの言葉のコンピュータが知っているように、

1330
01:03:10,316 --> 01:03:13,410
ああ、私は後に印刷を停止する必要があります
私は、感嘆符を参照してください。

1331
01:03:13,410 --> 01:03:16,090
そこに次の事ので、
ゼロのASCII値であり、

1332
01:03:16,090 --> 01:03:19,125
またはnull文字として
誰かがそれを呼び出すことになります。

1333
01:03:19,125 --> 01:03:21,500
しかし、問題のようなものがあります
ここでは、とのが戻すましょう

1334
01:03:21,500 --> 01:03:23,320
瞬間のための番号へ。

1335
01:03:23,320 --> 01:03:28,720
実際には、私が行うこととし、
数字の配列を持っています、

1336
01:03:28,720 --> 01:03:30,730
そして、仮定する
私が書いているプログラムがあります

1337
01:03:30,730 --> 01:03:34,680
教師のためのグレードブックのような
そして、教師の教室。

1338
01:03:34,680 --> 01:03:38,720
そして、このプログラムは、彼または彼女を可能にします
生徒のスコアを入力します

1339
01:03:38,720 --> 01:03:39,960
クイズに。

1340
01:03:39,960 --> 01:03:43,750
そして、学生が取得することを仮定
彼らの最初のクイズに100、多分

1341
01:03:43,750 --> 01:03:49,920
その後、次の1に80、のような
75、次に第四クイズに90。

1342
01:03:49,920 --> 01:03:54,150
>> だから、物語の中で、この時点では、
アレイのサイズは4本です。

1343
01:03:54,150 --> 01:03:58,470
より多くのメモリはで絶対にあります
コンピュータが、いわば配列、

1344
01:03:58,470 --> 01:04:00,350
サイズ4です。

1345
01:04:00,350 --> 01:04:06,060
教師が望んでいることを今仮定
クラスに五クイズを割り当てることができます。

1346
01:04:06,060 --> 01:04:08,510
まあ、物事の一つ、彼
または彼女がしなければならないとしています

1347
01:04:08,510 --> 01:04:10,650
今ここに追加の値を格納されています。

1348
01:04:10,650 --> 01:04:15,490
しかし、配列教師が持っている場合
このプログラムで作成されたがためのサイズです、

1349
01:04:15,490 --> 01:04:22,440
アレイの問題の一つは、ということです
あなただけのメモリに追加し続けることができません。

1350
01:04:22,440 --> 01:04:26,470
そのためどのような場合の別の部分
プログラムはすぐそこに「ちょっと」という言葉を持っていますか？

1351
01:04:26,470 --> 01:04:29,650
>> 換言すれば、私のメモリとすることができます
プログラムの中で何のために使用されます。

1352
01:04:29,650 --> 01:04:33,250
そして、事前に私は、ちょっと、で入力した場合
私は4クイズのスコアを入力したいです、

1353
01:04:33,250 --> 01:04:34,784
彼らはこことここに行くかもしれません。

1354
01:04:34,784 --> 01:04:37,700
そして、あなたは突然、あなたの心を変更した場合
それ以降、私は第五のクイズをしたいと言います

1355
01:04:37,700 --> 01:04:40,872
スコア、あなたがすることはできませんだけで
あなたが好きな場所にそれを置きます、

1356
01:04:40,872 --> 01:04:42,580
何この場合理由
メモリが使用されています

1357
01:04:42,580 --> 01:04:45,990
何かのためにいくつかの他のプログラムをelse--
またはプログラムのいくつかの他の特徴

1358
01:04:45,990 --> 01:04:46,910
あなたが実行していること？

1359
01:04:46,910 --> 01:04:50,650
ですから、事前に考えなければなりません
あなたのデータを保存する方法を、

1360
01:04:50,650 --> 01:04:54,480
今は塗装しましたので、
自分のデジタルコーナーへ。

1361
01:04:54,480 --> 01:04:57,280
>> だから先生ではなくかもしれません
プログラムを書くときに言います

1362
01:04:57,280 --> 01:04:59,360
彼または彼女を保存します
グレードは、あなたは何を知っていますか？

1363
01:04:59,360 --> 01:05:04,180
私は、依頼するつもりです
私のプログラムを書くとき、

1364
01:05:04,180 --> 01:05:12,070
Iは、0個、1個、2個、3個、欲しいこと
4、5、6、8等級は合計します。

1365
01:05:12,070 --> 01:05:15,320
そのように、一つ、二つ、三つ、四つ、
5つ、6つ、7つ、8つ。

1366
01:05:15,320 --> 01:05:18,612
教師はちょうどオーバー割り当てることができます
メモリは、彼または彼女のプログラムを書くとき

1367
01:05:18,612 --> 01:05:19,570
あなたは何を知っている、と言いますか？

1368
01:05:19,570 --> 01:05:22,236
私はより多くを割り当てるつもりはありませんよ
学期中8クイズより。

1369
01:05:22,236 --> 01:05:23,130
それはちょうどクレイジーです。

1370
01:05:23,130 --> 01:05:24,470
私はそれを割り当てることは決してないだろう。

1371
01:05:24,470 --> 01:05:28,270
この方法は、彼または彼女が有するように
店舗の生徒の得点に柔軟性、

1372
01:05:28,270 --> 01:05:33,010
75、90、そしておそらく1つの余分のような
学生は余分な信用、105を得ました。

1373
01:05:33,010 --> 01:05:36,130
>> しかし、もし先生決して
これらの3つのスペースを使用して、

1374
01:05:36,130 --> 01:05:38,860
ここでの直感的なお持ち帰りがあります。

1375
01:05:38,860 --> 01:05:41,410
彼または彼女はただのスペースを無駄にされています。

1376
01:05:41,410 --> 01:05:44,790
換言すれば、これはあり
プログラミングにおける一般的なトレードオフ

1377
01:05:44,790 --> 01:05:48,241
あなたはどちらかに割り当てることができる場所
あなたがしたいと正確に同じだけのメモリ、

1378
01:05:48,241 --> 01:05:51,490
利点は、あなたがスーパーだということです
あなたが無駄にされていませんefficient--

1379
01:05:51,490 --> 01:05:54,640
all--ではなくの欠点
あなたの心を変更した場合どのようなときです

1380
01:05:54,640 --> 01:05:58,780
保存したいプログラムを使用して、
あなたが最初に意図したよりも多くのデータ。

1381
01:05:58,780 --> 01:06:03,030
>> そのため、おそらく解決策は、その後、あります
このような方法であなたのプログラムを書きます

1382
01:06:03,030 --> 01:06:05,605
彼らはより多くのメモリを使用すること
彼らが実際に必要とするよりも。

1383
01:06:05,605 --> 01:06:07,730
あなたがつもりはない。このよう
その問題に実行するには、

1384
01:06:07,730 --> 01:06:09,730
しかし、あなたは無駄にされています。

1385
01:06:09,730 --> 01:06:12,960
そして、あなたのプログラムが使用するより多くのメモリ、
昨日説明したように、少ないです

1386
01:06:12,960 --> 01:06:15,410
利用可能なメモリ
他のプログラムのために、

1387
01:06:15,410 --> 01:06:18,790
早くお使いのコンピュータが遅くなる可能性があります
なぜなら、仮想メモリのダウン。

1388
01:06:18,790 --> 01:06:22,670
そのため、理想的な解決策は何でしょうか？

1389
01:06:22,670 --> 01:06:24,610
>> アンダー割当悪いようです。

1390
01:06:24,610 --> 01:06:27,030
過割当悪いようです。

1391
01:06:27,030 --> 01:06:31,120
それでは、よりよい解決策になるかもしれませんか？

1392
01:06:31,120 --> 01:06:32,390
再割り当てします。

1393
01:06:32,390 --> 01:06:33,590
よりダイナミックです。

1394
01:06:33,590 --> 01:06:37,520
選ぶために自分自身を強制しないでください。
先験的には、始めに、あなたは何をしたいです。

1395
01:06:37,520 --> 01:06:41,370
そして確かに、オーバー配分していません
あなたといけないので無駄なこと。

1396
01:06:41,370 --> 01:06:45,770
>> そのため、その目標を達成するために、我々
このデータ構造をスローする必要があり、

1397
01:06:45,770 --> 01:06:48,100
そう離れて、話します。

1398
01:06:48,100 --> 01:06:51,080
だから何のプログラマ
一般的に使用されます

1399
01:06:51,080 --> 01:06:55,940
何かがないと呼ばれています
配列が、リンクされたリスト。

1400
01:06:55,940 --> 01:07:00,860
言い換えれば、彼または彼女は意志
そのメモリを考え始めます

1401
01:07:00,860 --> 01:07:05,280
彼ら形状の一種であるとして、
次のように描くことができます。

1402
01:07:05,280 --> 01:07:08,520
私は中1の数を格納する場合
それは9月ですのでprogram--、

1403
01:07:08,520 --> 01:07:12,600
私は私の学生クイズを与えてくれました。が欲しいです
学生の最初のクイズを格納するため、

1404
01:07:12,600 --> 01:07:16,220
彼らは私がit--に100を得ました
私のコンピュータをお願いするつもりです、

1405
01:07:16,220 --> 01:07:19,540
私がしたプログラムを介して
メモリの1つのチャンクのために、書かれました。

1406
01:07:19,540 --> 01:07:22,570
そして、私は保存するつもりです
その中の数百、それはそれです。

1407
01:07:22,570 --> 01:07:24,820
>> その後、数週間後に
私は私の第二のクイズを得るとき、

1408
01:07:24,820 --> 01:07:27,890
それが入力する時が来ました
その90％に、私はつもりです

1409
01:07:27,890 --> 01:07:32,129
コンピュータを聞いて、ちょっと、コンピュータ、
私はメモリの別のチャンクを持つことができますか？

1410
01:07:32,129 --> 01:07:34,170
私にこれを与えるために起こっています
メモリの空のチャンク。

1411
01:07:34,170 --> 01:07:39,370
私は、数90に入れるつもりです
しかし、私のプログラムで何とかまたはother--

1412
01:07:39,370 --> 01:07:42,100
私たちは心配しません
私は必要this--の構文

1413
01:07:42,100 --> 01:07:44,430
これらの事を何とか一緒にチェーンに。

1414
01:07:44,430 --> 01:07:47,430
そして、私はそれらを一緒に連鎖します
何がここに矢印のように見えます。

1415
01:07:47,430 --> 01:07:50,050
>> 立ち上がる第三クイズ、
私が言うつもりです、ねえ、コンピュータ、

1416
01:07:50,050 --> 01:07:51,680
私はメモリの別のチャンクを与えます。

1417
01:07:51,680 --> 01:07:54,660
そして、私は下に置くつもりです
何でもそれは75のように、でした、

1418
01:07:54,660 --> 01:07:56,920
そして、私はチェーンにこれを持っています
一緒に今何とか。

1419
01:07:56,920 --> 01:08:00,290
第四にクイズに沿って来て、多分
それは、学期の終わりに向かっています。

1420
01:08:00,290 --> 01:08:03,140
そして、それによって私のプログラムを指します
メモリを使用している可能性があります

1421
01:08:03,140 --> 01:08:05,540
すべての場所の上に、すべての物理的にオーバー。

1422
01:08:05,540 --> 01:08:08,170
そして、これだけキックのために、私はよ
これを引き出すつもり

1423
01:08:08,170 --> 01:08:11,260
quiz--私はそれが何だったか忘れてしまいました。私
多分80またはsomething--を考えます

1424
01:08:11,260 --> 01:08:12,500
こっちの方法。

1425
01:08:12,500 --> 01:08:15,920
>> 絵ので、しかし、それは、大丈夫です
私はこの線を描画するつもりです。

1426
01:08:15,920 --> 01:08:19,063
換言すれば、実際には、
コンピュータのハードウェアで、

1427
01:08:19,063 --> 01:08:20,979
第1のスコアかもしれません
それはだから、ここで終わります

1428
01:08:20,979 --> 01:08:22,529
学期の開始時に右。

1429
01:08:22,529 --> 01:08:25,810
次はここで終わるかもしれません
少し時間が経過しているので、

1430
01:08:25,810 --> 01:08:27,210
プログラムが実行され続けます。

1431
01:08:27,210 --> 01:08:30,060
た次のスコア、
75、こっちかもしれません。

1432
01:08:30,060 --> 01:08:33,420
そして、最後のスコアがあるかもしれません
こっちで80、。

1433
01:08:33,420 --> 01:08:38,729
>> だから実際には、物理​​的に、これは可能性があります
どのようなコンピュータのメモリは次のようになります。

1434
01:08:38,729 --> 01:08:41,569
しかし、これは便利な精神ではありません
コンピュータープログラマーのためのパラダイム。

1435
01:08:41,569 --> 01:08:44,649
なぜあなたはどこに気にする必要があります
一体あなたのデータは終わるのですか？

1436
01:08:44,649 --> 01:08:46,200
あなただけのデータを保存したいです。

1437
01:08:46,200 --> 01:08:49,390
>> これは一種の私達の議論のようなものです
キューブを描画する以前。

1438
01:08:49,390 --> 01:08:52,200
なぜあなたは何を気にしません
角度は立方体であります

1439
01:08:52,200 --> 01:08:53,740
そして、どのようにそれを描画するために有効にする必要がありますか？

1440
01:08:53,740 --> 01:08:54,950
あなただけのキューブをしたいです。

1441
01:08:54,950 --> 01:08:57,359
同様にここで、あなた
ちょうどグレードブックにしたいです。

1442
01:08:57,359 --> 01:08:59,559
あなただけを考えたいです
番号のリストとしてこの。

1443
01:08:59,559 --> 01:09:01,350
それはだどのように誰が気に
ハードウェアで実装？

1444
01:09:01,350 --> 01:09:05,180
>> 今では抽象化
この絵はここにあります。

1445
01:09:05,180 --> 01:09:07,580
これはのように、リンクされたリストであります
プログラマはそれを呼び出すことになります、

1446
01:09:07,580 --> 01:09:10,640
あなたが持っているものであれば、
明らか番号のリスト、。

1447
01:09:10,640 --> 01:09:14,990
しかし、それは絵リンクされています
これらの矢印を介して、

1448
01:09:14,990 --> 01:09:18,510
そして、これらすべての矢印が下にare--
フード、あなたが興味があれば、

1449
01:09:18,510 --> 01:09:23,210
私たちの物理的なハードウェアが持っていることを思い出します
アドレスはゼロ、一つ、二つ、三つ、四つ。

1450
01:09:23,210 --> 01:09:28,465
すべてのこれらの矢印は、地図のようなものです
今の場合90 is--や方向、

1451
01:09:28,465 --> 01:09:29,090
私は数えるようになりました。

1452
01:09:29,090 --> 01:09:31,750
>> ゼロ、1つ、2つ、3つ、
4つ、5、6、7。

1453
01:09:31,750 --> 01:09:35,640
90であるように見えます
メモリアドレス番号7。

1454
01:09:35,640 --> 01:09:38,460
これらのすべての矢印がされています
紙の小さなスクラップのような

1455
01:09:38,460 --> 01:09:42,439
それはに指示を与えています
このマップに従うと言うプログラム

1456
01:09:42,439 --> 01:09:43,880
位置7に到達します。

1457
01:09:43,880 --> 01:09:46,680
そして、そこにあなたが見つけます
学生の第二クイズのスコア。

1458
01:09:46,680 --> 01:09:52,100
一方、75--私はこれを続ければ、
これは、7つ、8つ、9、10、11、12であり、

1459
01:09:52,100 --> 01:09:54,240
13、14、15。

1460
01:09:54,240 --> 01:09:59,080
>> この他の矢印はちょうど表し
メモリ位置15にマップされます。

1461
01:09:59,080 --> 01:10:02,550
しかし、再び、プログラマは一般的にありません
このレベルの詳細を気にしません。

1462
01:10:02,550 --> 01:10:05,530
そして、ほとんどすべてのプログラミングで
言語今日、プログラマ

1463
01:10:05,530 --> 01:10:10,490
どこまでもメモリ内知ることができません
これらの数値は実際にあります。

1464
01:10:10,490 --> 01:10:14,830
彼または彼女は気にしなければならないすべてがあります
彼らは何とか一緒にリンクされていること

1465
01:10:14,830 --> 01:10:18,390
このようなデータ構造です。

1466
01:10:18,390 --> 01:10:21,580
>> しかし、それはない判明します
あまりにも技術的な取得します。

1467
01:10:21,580 --> 01:10:27,430
しかし、単に、おそらく私達ができるので、
ここでこの議論を持っている余裕、

1468
01:10:27,430 --> 01:10:33,630
我々が再訪するとし
ここでは、アレイのこの問題。

1469
01:10:33,630 --> 01:10:35,780
私たちはここに行く後悔どうかを見てみましょう。

1470
01:10:35,780 --> 01:10:42,950
これは100、90、75、および80です。

1471
01:10:42,950 --> 01:10:44,980
>> 私は簡単にこの主張を作ってみましょう。

1472
01:10:44,980 --> 01:10:48,980
これは配列で、再び、
配列の顕著な特徴

1473
01:10:48,980 --> 01:10:52,400
すべてのデータがバックにあるということです
バック文字通りmemory--にバックアップします

1474
01:10:52,400 --> 01:10:56,830
1バイトまたは多分4バイト、
離れバイトのいくつかの固定数。

1475
01:10:56,830 --> 01:11:00,710
リンクされたリストでは、描画可能性があります
このように、ボンネットの下に人

1476
01:11:00,710 --> 01:11:02,000
その原料がどこにあるか知っていますか？

1477
01:11:02,000 --> 01:11:03,630
それも、このような流れにする必要はありません。

1478
01:11:03,630 --> 01:11:06,050
データの一部がかもしれません
戻ってそこまで左へ。

1479
01:11:06,050 --> 01:11:07,530
あなたも知りません。

1480
01:11:07,530 --> 01:11:15,430
>> そして、そのように配列して、あなたが持っています
ランダムアクセスと呼ばれる機能。

1481
01:11:15,430 --> 01:11:20,570
そして、何ランダムアクセス手段は、あります
コンピュータが瞬時にジャンプできます

1482
01:11:20,570 --> 01:11:22,730
アレイ内の任意の場所にコピーします。

1483
01:11:22,730 --> 01:11:23,580
どうして？

1484
01:11:23,580 --> 01:11:26,000
コンピュータが知っているので
最初の場所があることを

1485
01:11:26,000 --> 01:11:29,540
ゼロ、一、二、三。

1486
01:11:29,540 --> 01:11:33,890
>> だからあなたから移動する場合
次の要素にこの要素、

1487
01:11:33,890 --> 01:11:36,099
で文字通り、
コンピュータの心は、ちょうど1を追加します。

1488
01:11:36,099 --> 01:11:39,140
あなたが三番目の要素に行きたい場合は、
ただ単に、次の要素を選ぶ - 追加

1489
01:11:39,140 --> 01:11:40,290
1を追加します。

1490
01:11:40,290 --> 01:11:42,980
ただし、このバージョンで
物語の、仮定

1491
01:11:42,980 --> 01:11:46,080
コンピュータは、現在募集しています
で、または数100を扱います。

1492
01:11:46,080 --> 01:11:49,770
どのようにして、次に行きますか
グレード帳にグレード？

1493
01:11:49,770 --> 01:11:52,560
>> あなたは7を取らなければなりません
任意であるステップ、。

1494
01:11:52,560 --> 01:11:58,120
次のいずれかに取得するには、あなたがする必要はあり
15に到達するために、別の8つのステップを取ります。

1495
01:11:58,120 --> 01:12:02,250
言い換えれば、それはありません
数字の間に一定のギャップ、

1496
01:12:02,250 --> 01:12:04,857
ので、それだけで取ります
コンピュータより多くの時間がポイントです。

1497
01:12:04,857 --> 01:12:06,940
コンピュータが検索する必要があります
順番にメモリを介して、

1498
01:12:06,940 --> 01:12:08,990
あなたが探しているものを見つけることができます。

1499
01:12:08,990 --> 01:12:14,260
>> だからアレイはなる傾向にあるのに対し、
あなたのための高速データstructure--

1500
01:12:14,260 --> 01:12:17,610
文字通り簡単な計算を行うことができます
あなたがしたい場所と、1を追加することにより取得

1501
01:12:17,610 --> 01:12:21,300
リンクリストをinstance--ため、
あなたは、その機能を生け贄に捧げます。

1502
01:12:21,300 --> 01:12:24,020
あなたは最初から行くことができません
第2〜第4の三番目にします。

1503
01:12:24,020 --> 01:12:25,240
あなたがマップに従わなければなりません。

1504
01:12:25,240 --> 01:12:28,160
あなたはより多くのステップを取る必要があります
これらの値を取得するには、どの

1505
01:12:28,160 --> 01:12:30,230
コストを追加するように思われます。

1506
01:12:30,230 --> 01:12:35,910
だから我々は、価格を支払うが、何だったしています
ダンはここに求めていた機能？

1507
01:12:35,910 --> 01:12:38,110
どのようなリンクリストを行います
どうやら私たちが行うことができ、

1508
01:12:38,110 --> 01:12:40,240
の起源でした
この特定の話？

1509
01:12:40,240 --> 01:12:43,250

1510
01:12:43,250 --> 01:12:43,830
>> その通りです。

1511
01:12:43,830 --> 01:12:46,220
それへの動的なサイズ。

1512
01:12:46,220 --> 01:12:48,040
私たちは、このリストに追加することができます。

1513
01:12:48,040 --> 01:12:51,430
我々はそうであっても、リストを縮小することができます
私たちはできるだけ多くのメモリを使用していること

1514
01:12:51,430 --> 01:12:55,560
私たちは、実際に必要となるように
我々は過剰割当んじゃないんです。

1515
01:12:55,560 --> 01:12:58,470
>> 今、本当にNIT-うるさいします、
隠れたコストがあります。

1516
01:12:58,470 --> 01:13:01,980
だからあなたは私だけでは納得せてはなりません
あなたは、これは魅力的なトレードオフであること。

1517
01:13:01,980 --> 01:13:04,190
ここでもう一つの隠れたコストがあります。

1518
01:13:04,190 --> 01:13:06,550
利点は、明確にします
私たちは活力を得ることです。

1519
01:13:06,550 --> 01:13:10,359
私は別の要素が必要な場合、私はちょうどすることができます
それを描き、そこに数字を入れて。

1520
01:13:10,359 --> 01:13:12,150
そして、私はそれをリンクすることができます
ここでは画像と、

1521
01:13:12,150 --> 01:13:14,970
こっちのに対し、再び、私がしている場合
コー​​ナーに自分自身を描きました、

1522
01:13:14,970 --> 01:13:19,410
何か他のものは、すでに使用している場合
ここで、メモリは、私が運の尽きです。

1523
01:13:19,410 --> 01:13:21,700
私はコーナーに自分自身を描いてきました。

1524
01:13:21,700 --> 01:13:24,390
>> しかし、隠しは何ですか
この写真の中のコスト？

1525
01:13:24,390 --> 01:13:27,690
それだけの量ではありません
それにかかる時間

1526
01:13:27,690 --> 01:13:29,870
ここまでここから行くために、
次いで、7つのステップであります

1527
01:13:29,870 --> 01:13:32,820
複数のである8つのステップ、。

1528
01:13:32,820 --> 01:13:34,830
別の隠されたコストは何ですか？

1529
01:13:34,830 --> 01:13:35,440
だけでなく、時間。

1530
01:13:35,440 --> 01:13:44,790

1531
01:13:44,790 --> 01:13:49,940
追加情報があります
この絵を達成するために必要な。

1532
01:13:49,940 --> 01:13:53,210
>> うん、そのマップのそれらのほとんどのスクラップ
紙、私は、それらを記述しておくように。

1533
01:13:53,210 --> 01:13:55,650
これらのarrows--これらは無料ではありません。

1534
01:13:55,650 --> 01:13:57,660
あなたが知っていますcomputer--
コンピュータが持っているもの。

1535
01:13:57,660 --> 01:13:58,790
これは、0と1を持っています。

1536
01:13:58,790 --> 01:14:03,170
あなたは、矢印や表現したい場合
マップや数は、あなたはいくつかのメモリを必要としています。

1537
01:14:03,170 --> 01:14:05,950
他の価格ですから
リンクリストのために支払います、

1538
01:14:05,950 --> 01:14:09,070
一般的なコンピュータサイエンス
リソースは、スペースもあります。

1539
01:14:09,070 --> 01:14:11,710
>> そして実際そうなので、一般的に、
トレードオフの間で

1540
01:14:11,710 --> 01:14:15,580
ソフトウェアエンジニアリングの設計に
システム時間とspace--です

1541
01:14:15,580 --> 01:14:18,596
あなたの成分の2、2つです
あなたの最も高価な成分の。

1542
01:14:18,596 --> 01:14:21,220
これは私に多くの時間を原価計算されています
私はこのマップに従わなければならないので、

1543
01:14:21,220 --> 01:14:25,730
それはまた、私に多くのスペースを原価計算です
私の周りこのマップを維持する必要があるため。

1544
01:14:25,730 --> 01:14:28,730
私たちは一種のきたようにそう願って、
昨日と今日の上に議論し、

1545
01:14:28,730 --> 01:14:31,720
メリットということです
コストを上回るだろう。

1546
01:14:31,720 --> 01:14:33,870
>> しかし、ここで明らかな解決策はありません。

1547
01:14:33,870 --> 01:14:35,870
多分それはありますbetter--
ラ迅速かつ汚いです、

1548
01:14:35,870 --> 01:14:38,660
カリームはearlier--提案されているように
問題のメモリをスローします。

1549
01:14:38,660 --> 01:14:42,520
ただ、より多くのメモリを購入し、少ないと思います
問題の解決について、ハード、

1550
01:14:42,520 --> 01:14:44,595
そして簡単な方法でそれを解決します。

1551
01:14:44,595 --> 01:14:46,720
そして実際、以前、時
我々は、トレードオフについて話しました、

1552
01:14:46,720 --> 01:14:49,190
それはスペースはありませんでした
コンピュータと時刻。

1553
01:14:49,190 --> 01:14:51,810
それは、その開発者の時間でした
さらに別のリソースです。

1554
01:14:51,810 --> 01:14:54,829
>> だから、再び、それはこの綱渡りです
それらのもののどれを決定しよう

1555
01:14:54,829 --> 01:14:55,870
あなたが費やすことをいといませんか？

1556
01:14:55,870 --> 01:14:57,380
最も安価どれですか？

1557
01:14:57,380 --> 01:15:01,040
どちらが良い結果をもたらしますか？

1558
01:15:01,040 --> 01:15:01,540
ええ？

1559
01:15:01,540 --> 01:15:11,310

1560
01:15:11,310 --> 01:15:12,580
>> 確かに。

1561
01:15:12,580 --> 01:15:15,970
この場合は、あなたがしている場合
maps--で表す数字

1562
01:15:15,970 --> 01:15:18,820
これらは、多くの言語で呼ばれています
「ポインタ」または「アドレス」 - 

1563
01:15:18,820 --> 01:15:20,390
それはダブルスペースです。

1564
01:15:20,390 --> 01:15:24,390
それがあれば、二重のように悪いである必要はありません
今、私たちは数字だけを保存しています。

1565
01:15:24,390 --> 01:15:27,410
私たちが保存されたと仮定し
hospital--で患者記録

1566
01:15:27,410 --> 01:15:30,870
そうピアソンの名前、電話番号、
社会保障番号、医者

1567
01:15:30,870 --> 01:15:31,540
歴史。

1568
01:15:31,540 --> 01:15:34,160
このボックスには、多くの可能性があります
その場合には、はるかに大きいです

1569
01:15:34,160 --> 01:15:38,000
小さな小さなポインタのアドレス
次は、それは大したことではないのですelement--。

1570
01:15:38,000 --> 01:15:40,620
このようなフリンジです
それは問題ではありませんかかります。

1571
01:15:40,620 --> 01:15:43,210
しかし、この場合には、ええ、それは倍増です。

1572
01:15:43,210 --> 01:15:45,290
良い質問。

1573
01:15:45,290 --> 01:15:47,900
>> それでは、時間Aについてお話しましょう
もう少し具体的に。

1574
01:15:47,900 --> 01:15:50,380
走行時間は何ですか
このリストを検索しますか？

1575
01:15:50,380 --> 01:15:53,640
私が検索したいと
すべての生徒の学年を通して、

1576
01:15:53,640 --> 01:15:55,980
そしてnグレードがあります
このデータ構造です。

1577
01:15:55,980 --> 01:15:58,830
ここでは、あまりにも、私たちは借りることができます
以前の語彙。

1578
01:15:58,830 --> 01:16:00,890
これは、線形データ構造です。

1579
01:16:00,890 --> 01:16:04,570
>> n個のビッグOは、取得するために必要なのものです
このデータ構造の終わりに、

1580
01:16:04,570 --> 01:16:08,410
whereas--と我々は見ていません
このアレイはあなたを与えますbefore--

1581
01:16:08,410 --> 01:16:13,555
何を意味し、一定の時間と呼ばれています
1段階または2段階または10 steps--

1582
01:16:13,555 --> 01:16:14,180
関係ない。

1583
01:16:14,180 --> 01:16:15,440
これは、固定された数です。

1584
01:16:15,440 --> 01:16:17,440
これは、とは何の関係もありません
配列のサイズ。

1585
01:16:17,440 --> 01:16:20,130
そして、その理由、
再度、ランダムアクセスです。

1586
01:16:20,130 --> 01:16:23,180
コンピュータは、ちょうどすぐにすることができます
別の場所にジャンプし、

1587
01:16:23,180 --> 01:16:27,770
それらはすべて同じだから
他のすべてからの距離。

1588
01:16:27,770 --> 01:16:29,112
関与しない考えはありません。

1589
01:16:29,112 --> 01:16:31,900

1590
01:16:31,900 --> 01:16:32,400
大丈夫。

1591
01:16:32,400 --> 01:16:39,230
私ができるのであれば、私にしてみましょう
2つの最終絵を描きます。

1592
01:16:39,230 --> 01:16:42,830
ハッシュテーブルとして知られている非常に一般的なもの。

1593
01:16:42,830 --> 01:16:51,120
だから、この議論をやる気にします、
私はこれを行う方法について考えてみましょう。

1594
01:16:51,120 --> 01:16:52,610
>> だから、これはどう？

1595
01:16:52,610 --> 01:16:55,160
問題があるとし
我々は今、解決したいです

1596
01:16:55,160 --> 01:16:58,360
dictionary--に実施しています
英語の単語のように全体の束

1597
01:16:58,360 --> 01:16:59,330
または何でも。

1598
01:16:59,330 --> 01:17:02,724
そして目標はお答えすることができることです
フォームの質問これは言葉ですか？

1599
01:17:02,724 --> 01:17:04,640
だから、実装したいです
ちょうどスペルチェッカー、

1600
01:17:04,640 --> 01:17:07,220
物理的な辞書のような
あなたが物事を見ることができます。

1601
01:17:07,220 --> 01:17:10,490
私は配列でこれを行うためにあったとします。

1602
01:17:10,490 --> 01:17:12,590
私はこれを行うことができます。

1603
01:17:12,590 --> 01:17:20,756
>> そして、言葉はリンゴであると仮定
そして、バナナやメロン。

1604
01:17:20,756 --> 01:17:23,330

1605
01:17:23,330 --> 01:17:26,465
そして、私は果物を​​考えることはできません
それがdで始まるので、私たちはただです

1606
01:17:26,465 --> 01:17:27,590
3果物を持っているつもり。

1607
01:17:27,590 --> 01:17:31,510
だから、これは配列であり、我々はしています
これらの言葉のすべてを保存します

1608
01:17:31,510 --> 01:17:34,200
配列としてこの辞書インチ

1609
01:17:34,200 --> 01:17:39,350
質問は、その後、どのように他であります
あなたは、この情報を保存することができますか？

1610
01:17:39,350 --> 01:17:43,160
>> まあ、私はので、ここでの不正行為のようなものです
ワード内のこれらの各文字

1611
01:17:43,160 --> 01:17:44,490
本当に個々のバイトです。

1612
01:17:44,490 --> 01:17:46,740
だから私は本当にになりたい場合
NIT-うるさい、私は本当にすべき

1613
01:17:46,740 --> 01:17:49,600
はるかにこれを分割すること
メモリの小さな塊、

1614
01:17:49,600 --> 01:17:51,289
私たちはまさにそれを行うことができます。

1615
01:17:51,289 --> 01:17:53,580
しかし、我々はに実行するつもりです
前と同じ問題。

1616
01:17:53,580 --> 01:17:56,674
何メリアム・ウェブスターやオックスフォードなど、場合
すべてのは、彼らが単語を追加year--ん

1617
01:17:56,674 --> 01:17:59,340
dictionary--に我々にはありません
必ずしも自分自身をペイントします

1618
01:17:59,340 --> 01:18:00,780
配列の角に？

1619
01:18:00,780 --> 01:18:05,710
>> だからではなく、多分賢くアプローチ
自ノードまたはボックスにリンゴを置くことです、

1620
01:18:05,710 --> 01:18:11,190
私たちが言うように、バナナ、および
そして、ここではマスクメロンを持っています。

1621
01:18:11,190 --> 01:18:14,990

1622
01:18:14,990 --> 01:18:16,790
そして、我々の文字列これらの事を一緒に。

1623
01:18:16,790 --> 01:18:19,980
だから、これは配列で、
これは、リンクされたリストです。

1624
01:18:19,980 --> 01:18:23,300
あなたは非常に見ることができない場合は、それだけで
「アレイ」は、言うとこれが言う「リスト」

1625
01:18:23,300 --> 01:18:25,780
>> だから我々は同じを持っています
以前のように正確な問題、

1626
01:18:25,780 --> 01:18:28,600
それによって私たちが今持っています
私たちのリンクリスト内のダイナミズム。

1627
01:18:28,600 --> 01:18:31,090
しかし、我々はかなり遅いの辞書を持っています。

1628
01:18:31,090 --> 01:18:32,870
私は単語を検索するとします。

1629
01:18:32,870 --> 01:18:35,430
それは私に、nの大きなOがかかる場合があります
手順、言葉は可能性があるため、

1630
01:18:35,430 --> 01:18:37,840
の終了時にすべての方法であります
マスクメロンのようなリスト、。

1631
01:18:37,840 --> 01:18:40,600
そして、それはことが判明します
プログラミングで、並べ替え

1632
01:18:40,600 --> 01:18:42,700
データの聖杯の
構造は、何かであります

1633
01:18:42,700 --> 01:18:46,620
それはあなたが一定の与え
配列のような時間

1634
01:18:46,620 --> 01:18:50,870
それはまだあなたにダイナミズムを与えます。

1635
01:18:50,870 --> 01:18:52,940
>> だから我々は両方の長所を持つことができますか？

1636
01:18:52,940 --> 01:18:55,570
そして実際、何かがあります
ハッシュテーブルと呼ばれます

1637
01:18:55,570 --> 01:18:59,320
それはあなたが正確に行うことができます
約いえ、その。

1638
01:18:59,320 --> 01:19:03,140
ハッシュテーブルは愛好家であります
我々のデータ構造

1639
01:19:03,140 --> 01:19:06,340
以下のように考えることができます
array--の組み合わせ

1640
01:19:06,340 --> 01:19:12,390
私はそれを描くつもりです
this--とリンクリストのような

1641
01:19:12,390 --> 01:19:17,310
私はここの上にこのよう描くだろうと。

1642
01:19:17,310 --> 01:19:19,760
>> この事と方法
作品は次の通りです。

1643
01:19:19,760 --> 01:19:23,310

1644
01:19:23,310 --> 01:19:29,540
このnow--ハッシュ場合table--
私の第3のデータ構造です、

1645
01:19:29,540 --> 01:19:32,590
そして、私は保存したいです
この内の単語、私はしないでください

1646
01:19:32,590 --> 01:19:35,440
ただのすべてを保存します
言葉が背中合わせに背中合わせにします。

1647
01:19:35,440 --> 01:19:37,430
私はいくつかを利用したいです
情報の一部

1648
01:19:37,430 --> 01:19:40,330
できるようになる言葉について
それは高速ですどこ私はそれを取得します。

1649
01:19:40,330 --> 01:19:43,666
>> だから、言葉のリンゴを与えられました
バナナやメロン、

1650
01:19:43,666 --> 01:19:45,040
私は意図的にそれらの単語を選択しました。

1651
01:19:45,040 --> 01:19:45,340
どうして？

1652
01:19:45,340 --> 01:19:47,631
ソートの根本的に何
3については違うのですか？

1653
01:19:47,631 --> 01:19:49,950

1654
01:19:49,950 --> 01:19:51,484
明白とは何ですか？

1655
01:19:51,484 --> 01:19:52,900
彼らは別の文字で始まります。

1656
01:19:52,900 --> 01:19:53,900
>> だからあなたは何を知っていますか？

1657
01:19:53,900 --> 01:19:57,120
内のすべての私の言葉を置くのではなく
同じバケット、いわば、

1658
01:19:57,120 --> 01:20:00,390
一つの大きなリストのように、なぜしません
私は、少なくとも最適化をしてみてください

1659
01:20:00,390 --> 01:20:04,180
そして、私のリストは1月26日限り行います。

1660
01:20:04,180 --> 01:20:07,440
説得力の最適化
なぜしない可能性があります

1661
01:20:07,440 --> 01:20:10,650
I--単語を挿入するとき
このデータ構造に、

1662
01:20:10,650 --> 01:20:14,300
コンピュータのメモリに、なぜ
私は、ここにすべての ''の単語を入れていません

1663
01:20:14,300 --> 01:20:17,270
ここにすべての 'B'の言葉、
ここでは、すべての 'C'の言葉？

1664
01:20:17,270 --> 01:20:24,610
だから、これはリンゴを入れて終わります
ここでは、ここではバナナ、ここではマスクメロン、

1665
01:20:24,610 --> 01:20:25,730
など。

1666
01:20:25,730 --> 01:20:31,700
>> そして、私は追加している場合
言葉は別の何like--？

1667
01:20:31,700 --> 01:20:36,640
アップル、バナナ、梨。

1668
01:20:36,640 --> 01:20:39,370
誰もがフルーツを考えます
すなわち、B、またはCで始まりますか？

1669
01:20:39,370 --> 01:20:40,570
Blueberry--完璧。

1670
01:20:40,570 --> 01:20:43,990
それがここで終わるしようとしています。

1671
01:20:43,990 --> 01:20:47,530
そして、私たちは持っているように見えます
わずかによりよい解決策、

1672
01:20:47,530 --> 01:20:50,820
今私がしたい場合のため
リンゴを検索するには、I

1673
01:20:50,820 --> 01:20:53,200
first--私はダイビングをしません
私のデータ構造に。

1674
01:20:53,200 --> 01:20:54,850
私は自分のコンピュータのメモリに飛び込むません。

1675
01:20:54,850 --> 01:20:56,530
私は、最初の最初の文字を見てください。

1676
01:20:56,530 --> 01:20:58,610
>> そして、これはどのようなコンピュータであり、
科学者は言うでしょう。

1677
01:20:58,610 --> 01:21:00,760
あなたのデータ構造にハッシュ。

1678
01:21:00,760 --> 01:21:04,100
あなたの入力、中を取ります
この場合は、リンゴのような言葉です。

1679
01:21:04,100 --> 01:21:07,150
あなたが見て、それを分析します
この場合の最初の文字、

1680
01:21:07,150 --> 01:21:08,340
それによって、それをハッシュします。

1681
01:21:08,340 --> 01:21:10,950
ハッシュは、一般的な用語のそれによってです
あなたが入力として何かを取ります

1682
01:21:10,950 --> 01:21:12,116
あなたは、いくつかの出力を生成します。

1683
01:21:12,116 --> 01:21:15,090
そして、その中で出力
場合は、場所です

1684
01:21:15,090 --> 01:21:18,150
あなたは、最初に検索したいです
位置、第二の位置、第三。

1685
01:21:18,150 --> 01:21:22,160
だから入力はリンゴです、
出力は最初のものです。

1686
01:21:22,160 --> 01:21:25,054
入力は、バナナであります
出力は、第2にする必要があります。

1687
01:21:25,054 --> 01:21:27,220
入力は、マスクメロンです
出力は、第三にする必要があります。

1688
01:21:27,220 --> 01:21:30,320
入力は、ブルーベリーであります
出力は再び第二にする必要があります。

1689
01:21:30,320 --> 01:21:34,010
そして、それはあなたが取ることができますものです
あなたの記憶を通じショートカット

1690
01:21:34,010 --> 01:21:39,050
言葉を得るために
またはデータをより効果的に。

1691
01:21:39,050 --> 01:21:43,330
>> さて、これは潜在的に私たちの時間をダウンカット
26のうち1と同じくらいすることにより、

1692
01:21:43,330 --> 01:21:45,850
あなたはあなたと仮定した場合のため
「Z」のように多くの ""の単語を持っています

1693
01:21:45,850 --> 01:21:48,080
「Q」の単語などの単語、どの
本当にrealistic--されていません

1694
01:21:48,080 --> 01:21:50,830
あなたは全体のスキューを持っているつもりです
alphabet--の特定の文字

1695
01:21:50,830 --> 01:21:53,204
これは増分になります
許可しないアプローチ

1696
01:21:53,204 --> 01:21:55,930
あなたがはるかに迅速に言葉を取得します。

1697
01:21:55,930 --> 01:21:59,660
そして、現実には、洗練されました
プログラム、世界のグーグル、

1698
01:21:59,660 --> 01:22:02,180
world--のFacebooks
それらは、ハッシュテーブルを使用します

1699
01:22:02,180 --> 01:22:03,740
異なる目的の多くのために。

1700
01:22:03,740 --> 01:22:06,590
しかし、彼らはほどナイーブではないでしょう
ただ最初の文字を見て

1701
01:22:06,590 --> 01:22:09,700
リンゴやバナナや
梨やメロン、

1702
01:22:09,700 --> 01:22:13,420
あなたはこれらを見ることができるよう理由
リストには、まだ長い得ることができます。

1703
01:22:13,420 --> 01:22:17,130
>> そして、これはまだソート可能性があります
linear--のように一種の遅いです、

1704
01:22:17,130 --> 01:22:19,980
n個の大きなOを持つように
我々は先に説明しました。

1705
01:22:19,980 --> 01:22:25,290
それでは、本当の良いハッシュテーブルはなります
それははるかに大きな配列を持つことになりますdo--。

1706
01:22:25,290 --> 01:22:28,574
そして、それははるかに使用します。
洗練されたハッシュ関数、

1707
01:22:28,574 --> 01:22:30,240
それだけで "。"を見ないように、

1708
01:22:30,240 --> 01:22:35,480
多分それは「-P-P-L-E」を見て、
何とかそれらの5文字を​​変換し、

1709
01:22:35,480 --> 01:22:38,400
どこの場所へ
リンゴが保存されるべきです。

1710
01:22:38,400 --> 01:22:42,660
私達はちょうど単純に文字 ''を使用しています
それは素晴らしく、シンプルだから、一人で。

1711
01:22:42,660 --> 01:22:44,600
>> しかし、ハッシュテーブル、中
最後に、あなたが考えることができます

1712
01:22:44,600 --> 01:22:47,270
の組み合わせとしての
アレイ、各

1713
01:22:47,270 --> 01:22:51,700
その理想的にリンクされたリストを持っています
できるだけ短くあるべきです。

1714
01:22:51,700 --> 01:22:54,364
そして、これは明白な解決策ではありません。

1715
01:22:54,364 --> 01:22:57,280
微調整の実際には、多くの
それはときにボンネットの下に行きます

1716
01:22:57,280 --> 01:22:59,654
これらの種類を実装します
高度なデータ構造

1717
01:22:59,654 --> 01:23:01,640
右が何であるかであります
配列の長さは？

1718
01:23:01,640 --> 01:23:03,250
右のハッシュ関数とは何ですか？

1719
01:23:03,250 --> 01:23:04,830
どのようにメモリに物事を格納していますか？

1720
01:23:04,830 --> 01:23:07,249
>> しかし、どのように迅速に実現
議論のこの種

1721
01:23:07,249 --> 01:23:10,540
これまでのところ、それはようなものだということのいずれか、エスカレート
この時点で、自分の頭の上の、どの

1722
01:23:10,540 --> 01:23:11,360
結構です。

1723
01:23:11,360 --> 01:23:18,820
しかし、我々は本当にと、リコールを開始しました
何か低レベルと電子。

1724
01:23:18,820 --> 01:23:20,819
そしてこれは、再びこれです
抽象化のテーマは、

1725
01:23:20,819 --> 01:23:23,610
どこにあなたが取ることを始めると
付与され、[OK]を、私はそこだit--持っています

1726
01:23:23,610 --> 01:23:26,680
物理メモリ、OK、それを持って、すべての
物理的な位置は、アドレスを持っています

1727
01:23:26,680 --> 01:23:29,910
[OK]を、私はそれは、私が表現することができました
arrows--としてそれらのアドレス

1728
01:23:29,910 --> 01:23:34,650
あなたは非常に迅速に持って始めることができます
より洗練された会話のこと

1729
01:23:34,650 --> 01:23:38,360
最後に私たちを可能にしているように見えます
検索のような問題を解決するために

1730
01:23:38,360 --> 01:23:41,620
そして、より効果的にソート。

1731
01:23:41,620 --> 01:23:44,190
そして、too--安心
私はこれを考えるので

1732
01:23:44,190 --> 01:23:48,700
我々はいくつかに行ってきた最も深いです
私たちがきたproper--これらのCSトピックの

1733
01:23:48,700 --> 01:23:51,880
この時に日半で行われ
あなたは一般的にオーバーするかもしれないものを指します

1734
01:23:51,880 --> 01:23:55,520
学期中の8週間のコース。

1735
01:23:55,520 --> 01:23:59,670
>> これらの上の任意の質問？

1736
01:23:59,670 --> 01:24:01,100
なし？

1737
01:24:01,100 --> 01:24:01,940
大丈夫。

1738
01:24:01,940 --> 01:24:05,610
さて、なぜ私たちはそこに一時停止しませんが、
数分早い昼食を開始し、

1739
01:24:05,610 --> 01:24:07,052
ちょうど約1時間で再開？

1740
01:24:07,052 --> 01:24:08,760
そして、私はのために残りますよ
質問を少し。

1741
01:24:08,760 --> 01:24:11,343
それから私は行かなければならないつもりです
それがOKかどうカップルの呼び出しを取ります。

1742
01:24:11,343 --> 01:24:15,000
私は、その間にいくつかの音楽をオンにします
しかし昼食は、角を回っにする必要があります。

1743
01:24:15,000 --> 01:24:17,862