1
00:00:00,000 --> 00:00:09,572

2
00:00:09,572 --> 00:00:12,030
ロブ·ボウデンは：こんにちは、私は、ロブ·ボーデンよ
そしてそれではquiz0について話しましょう​​。

3
00:00:12,030 --> 00:00:13,280

4
00:00:13,280 --> 00:00:14,545
>> だから、最初の質問。

5
00:00:14,545 --> 00:00:17,750
これは質問場所です
あなたは番号をコード化するために必要な

6
00:00:17,750 --> 00:00:21,270
バイナリ球根127。

7
00:00:21,270 --> 00:00:23,550
あなたが望む場合は、可能性
定期的な変換を行う

8
00:00:23,550 --> 00:00:25,950
bi--から、または、小数からバイナリへ。

9
00:00:25,950 --> 00:00:28,300
しかし、それはおそらく起こっている
多くの時間を取る。

10
00:00:28,300 --> 00:00:31,750
私は、あなたがそれを見つけ出すことができ、意味、
[OK]を、1は2がそこにある、そこにある、

11
00:00:31,750 --> 00:00:33,650
図4は、8がそこにある、そこにある。

12
00:00:33,650 --> 00:00:39,280
簡単な方法は、127は128から1を引いている。

13
00:00:39,280 --> 00:00:42,013
その左端の電球は、128ビットである。

14
00:00:42,013 --> 00:00:43,490

15
00:00:43,490 --> 00:00:47,860
だから、127はちょうど、すべて実際にある
他の電球の、

16
00:00:47,860 --> 00:00:51,420
それは左端のだから
電球マイナス1。

17
00:00:51,420 --> 00:00:52,800
つまり、その質問はこれでおしまい。

18
00:00:52,800 --> 00:00:54,060
>> 質問1。

19
00:00:54,060 --> 00:00:56,710
あなたができる3ビットでそう
8個別の値を表している。

20
00:00:56,710 --> 00:01:01,000
なぜ、その後、7最大の非負で
あなたが表現できる進整数？

21
00:01:01,000 --> 00:01:04,050
さて、唯一の私達ができる場合
8個別の値を表し、

22
00:01:04,050 --> 00:01:07,430
その後、私たちがあることになるだろう
代表は0〜7です。

23
00:01:07,430 --> 00:01:08,745
0のいずれかの値をとる。

24
00:01:08,745 --> 00:01:09,980

25
00:01:09,980 --> 00:01:11,190
>> 質問2。

26
00:01:11,190 --> 00:01:14,610
nビットで、どのように多くの異なる
値は、あなたが表現することができますか？

27
00:01:14,610 --> 00:01:19,080
したがって、nビットでは、2を有している
ビットごとに指定可能な値。

28
00:01:19,080 --> 00:01:22,300
だから我々は2の可能な値を持っている
最初のビット、2の可能な値

29
00:01:22,300 --> 00:01:24,450
第二のために、2
第三の可能な。

30
00:01:24,450 --> 00:01:28,730
そしてそうそれは2倍2倍2だし、
最終的に答えはnに2である。

31
00:01:28,730 --> 00:01:30,010

32
00:01:30,010 --> 00:01:31,100
>> 質問3。

33
00:01:31,100 --> 00:01:33,450
バイナリで0x50のは何ですか？

34
00:01:33,450 --> 00:01:39,490
だから進数が非常に持っていることを覚えている
バイナリへの直接的な変換。

35
00:01:39,490 --> 00:01:43,180
だからここ、私たちは見てする必要があり
5と独立して、0。

36
00:01:43,180 --> 00:01:45,110
だから、バイナリで5何ですか？

37
00:01:45,110 --> 00:01:48,400
0101、それは1ビットおよび4ビットです。

38
00:01:48,400 --> 00:01:49,900
バイナリで0は何ですか？

39
00:01:49,900 --> 00:01:50,520
トリッキーではない。

40
00:01:50,520 --> 00:01:52,180
0000。

41
00:01:52,180 --> 00:01:54,970
だから、それらを一緒に入れて、
それは、バイナリでの完全数です。

42
00:01:54,970 --> 00:01:57,640
01010000。

43
00:01:57,640 --> 00:02:00,439
あなたが望んでいる場合、あなたは可能性
その左端のゼロを脱ぐ。

44
00:02:00,439 --> 00:02:01,105
それは無関係だ。

45
00:02:01,105 --> 00:02:02,920

46
00:02:02,920 --> 00:02:05,733
>> それでは代わりに、
進数で0x50のは何ですか？

47
00:02:05,733 --> 00:02:08,649
あなたが望む場合は、している場合は、could--
バイナリより快適、

48
00:02:08,649 --> 00:02:11,340
あなたはそのバイナリ答えを取ることができる
と小数にそれを変換します。

49
00:02:11,340 --> 00:02:13,870
または私達はただ覚えることができる
その進。

50
00:02:13,870 --> 00:02:21,140
0ようにすると、0番目の場所にあり、かつ
図5は、最初の場所に16である。

51
00:02:21,140 --> 00:02:25,990
だからここでは、5〜16倍を持っている
まず、ゼロにプラス0回16、

52
00:02:25,990 --> 00:02:27,520
80です。

53
00:02:27,520 --> 00:02:29,710
そして、あなたが見ている場合
質問へのタイトル、

54
00:02:29,710 --> 00:02:32,920
それはのようなものだった、CS 80、だった
この問題への答えへのヒント。

55
00:02:32,920 --> 00:02:34,460

56
00:02:34,460 --> 00:02:35,420
>> 質問5。

57
00:02:35,420 --> 00:02:40,320
私たちは、このスクラッチスクリプトを持っている
4回ピーナッツバターゼリーを繰り返す。

58
00:02:40,320 --> 00:02:42,800
では、どのようにC言語でコードになりましたことをやる？

59
00:02:42,800 --> 00:02:47,730
まあ、我々は太字でhere--部分を持っている
あなたが実装しなければならなかった唯一の部分である。

60
00:02:47,730 --> 00:02:51,950
だから我々は4ループだ4ループを持っている
回、printfの -  INGのピーナッツバターゼリー、

61
00:02:51,950 --> 00:02:53,910
問題として持つ新しい行が要求されます。

62
00:02:53,910 --> 00:02:55,250

63
00:02:55,250 --> 00:02:57,490
>> 質問6、別のスクラッチの問題。

64
00:02:57,490 --> 00:03:00,210
私たちは永遠にループしていることがわかります。

65
00:03:00,210 --> 00:03:05,000
私たちは、変数iを言っている
その後iを1だけインクリメントする。

66
00:03:05,000 --> 00:03:09,580
今、私たちはCでありますことをやってみたい
我々はこれを行っている可能性が複数の方法。

67
00:03:09,580 --> 00:03:12,840
ここでは、コーディングすることが起こった
しばらく（真）として永遠にループ。

68
00:03:12,840 --> 00:03:16,600
だから私たちは私はちょうど、変数を宣言
我々はスクラッチで変数iを持っていたような。

69
00:03:16,600 --> 00:03:21,950
変数iを宣言し、永遠に
（真）しながら、我々は変数iを言う。

70
00:03:21,950 --> 00:03:25,260
printfの％i--たり、％dを使用していたかもしれないので。

71
00:03:25,260 --> 00:03:27,985
私たちは、その変数を言うと、
それをインクリメント、私はC ++。

72
00:03:27,985 --> 00:03:29,560

73
00:03:29,560 --> 00:03:30,830
>> 質問7。

74
00:03:30,830 --> 00:03:35,560
今、私たちは非常によく似た何かをしたい
問題からマリオドットcに1を設定します。

75
00:03:35,560 --> 00:03:39,110
我々は、これらのハッシュタグを印刷したい、
私たちは5を印刷したい

76
00:03:39,110 --> 00:03:40,700
これらのハッシュの3長方形で。

77
00:03:40,700 --> 00:03:41,770

78
00:03:41,770 --> 00:03:43,162
では、どのようにそれを行うつもりですか？

79
00:03:43,162 --> 00:03:45,370
さて、私たちはあなたに全体を与える
コー​​ドの束、そしてあなただけの

80
00:03:45,370 --> 00:03:47,560
印刷グリッド機能に記入しなければならない。

81
00:03:47,560 --> 00:03:49,540
>> だから何PrintGridは次のようになりません？

82
00:03:49,540 --> 00:03:51,480
さてあなたは過ぎている
幅と高さ。

83
00:03:51,480 --> 00:03:53,520
だから我々は、外側を持っている4
ループは、それがループだ

84
00:03:53,520 --> 00:03:57,650
これのすべての行の上
私たちはプリントアウトしたいグリッド。

85
00:03:57,650 --> 00:04:01,250
その後、我々は、インターネストされた4ループを持っている
それは各列での印刷です。

86
00:04:01,250 --> 00:04:06,210
だから、行ごとに、私達はのために印刷する
各列は、単一のハッシュ。

87
00:04:06,210 --> 00:04:10,045
その行の終わりに、我々は印刷する
単一の新しい行が次の行に移動します。

88
00:04:10,045 --> 00:04:11,420
そして、それはグリッド全体のためにそれだ。

89
00:04:11,420 --> 00:04:12,810

90
00:04:12,810 --> 00:04:13,675
>> 質問8。

91
00:04:13,675 --> 00:04:17,170
PrintGridのような関数はと言われている
リターン副作用がないの

92
00:04:17,170 --> 00:04:17,670
値。

93
00:04:17,670 --> 00:04:19,209
区別を説明してください。

94
00:04:19,209 --> 00:04:23,080
だから、これは覚えてあなたに依存しています
副作用は何であるか。

95
00:04:23,080 --> 00:04:25,180
さて、復帰value--
我々はPrintGridにはない知っている

96
00:04:25,180 --> 00:04:28,180
ので、戻り値を持つ
右ここでそれは無効と述べています。

97
00:04:28,180 --> 00:04:31,150
voidを返すので、何でも
本当に何も返しません。

98
00:04:31,150 --> 00:04:32,200

99
00:04:32,200 --> 00:04:33,620
だから、副作用は何ですか？

100
00:04:33,620 --> 00:04:36,620
さて、副作用である
ソートの持続するもの

101
00:04:36,620 --> 00:04:39,500
機能終了後
それは、単に返されませんでした

102
00:04:39,500 --> 00:04:41,340
そしてそれだけで入力からではなかった。

103
00:04:41,340 --> 00:04:44,970
>> したがって、たとえば、我々は、可能性がある
グローバル変数を変更します。

104
00:04:44,970 --> 00:04:46,590
つまり副作用であろう。

105
00:04:46,590 --> 00:04:49,000
この特定のケースでは、A
非常に重要な副作用

106
00:04:49,000 --> 00:04:51,070
画面に印刷されている。

107
00:04:51,070 --> 00:04:53,110
だから副作用である
PrintGridが持っていること。

108
00:04:53,110 --> 00:04:54,980
私たちは、画面にこれらの事を印刷してください。

109
00:04:54,980 --> 00:04:56,370
そして、あなたは考えることができます
その副作用として、

110
00:04:56,370 --> 00:04:58,690
それはその何かだから
この関数は終了後に持続する。

111
00:04:58,690 --> 00:05:01,481
つまり、スコープ外の何か
最終的にはこの関数の

112
00:05:01,481 --> 00:05:03,380
変更され、
画面の内容。

113
00:05:03,380 --> 00:05:05,200

114
00:05:05,200 --> 00:05:05,839
>> 質問9。

115
00:05:05,839 --> 00:05:07,880
以下のプログラムを考え、
どのライン番号へ

116
00:05:07,880 --> 00:05:09,740
追加されました
議論のために。

117
00:05:09,740 --> 00:05:13,480
したがって、このプログラムの中で私達はちょうどです
それを保存、のGetStringを呼び出す

118
00:05:13,480 --> 00:05:16,220
この変数sで、その後、
その変数s印刷。

119
00:05:16,220 --> 00:05:16,720
[OK]をクリックします。

120
00:05:16,720 --> 00:05:19,090
ライン1が存在している理由をそう説明する。

121
00:05:19,090 --> 00:05:20,920
インクルードCS50ドット時間。

122
00:05:20,920 --> 00:05:23,820
なぜ我々はCS50ドットhのを#i​​ncludeする必要がありますか？

123
00:05:23,820 --> 00:05:26,180
まあ我々は呼んでいる
のGetString機能、

124
00:05:26,180 --> 00:05:28,840
とのGetStringが定義されている
CS50ライブラリ内の。

125
00:05:28,840 --> 00:05:31,600
だから我々は持っていなかった場合は、
の#include CS50ドットhの、

126
00:05:31,600 --> 00:05:35,760
我々はその暗黙的な宣言になるだろう
のGetString関数エラーの

127
00:05:35,760 --> 00:05:36,840
コンパイラから。

128
00:05:36,840 --> 00:05:40,110
だから我々はlibrary--を含める必要が
我々はヘッダファイルをインクルードする必要があり、

129
00:05:40,110 --> 00:05:42,870
あるいはコンパイラはしません
のGetStringが存在することを認識しています。

130
00:05:42,870 --> 00:05:44,380

131
00:05:44,380 --> 00:05:46,140
>> ライン2が存在する理由を説明する。

132
00:05:46,140 --> 00:05:47,890
だから、標準入出力ドット時間。

133
00:05:47,890 --> 00:05:50,430
それはまったく同じだ
以前の問題として、

134
00:05:50,430 --> 00:05:53,310
代わりに対処するのを除いて
のGetString、我々はprintfの話をしている。

135
00:05:53,310 --> 00:05:56,654
だから我々は我々が必要と言っていなかった場合
標準IOドットhを含めるには、

136
00:05:56,654 --> 00:05:58,820
その後、我々はできないだろう
printf関数を使用するには、

137
00:05:58,820 --> 00:06:00,653
コンパイラ理由
それについて知っているだろう。

138
00:06:00,653 --> 00:06:01,750

139
00:06:01,750 --> 00:06:05,260
>> Why--意義は何ですか
ライン4におけるボイドの？

140
00:06:05,260 --> 00:06:08,010
そこでここではint型メイン（ボイド）がある。

141
00:06:08,010 --> 00:06:10,600
それはちょうど、その私たちを言っている
任意のコマンドラインを取得されていません

142
00:06:10,600 --> 00:06:12,280
主への引数。

143
00:06:12,280 --> 00:06:17,390
我々はint型を言うことができることを忘れないでください
メインint型のargc文字列ARGVブラケット。

144
00:06:17,390 --> 00:06:20,400
そこでここでは、単に私たちに言っても、ボイド言う
コマンドライン引数を無視している。

145
00:06:20,400 --> 00:06:21,840

146
00:06:21,840 --> 00:06:25,225
>> 正確に、メモリに関しては、説明
ライン内の何のGetString 6に戻ります。

147
00:06:25,225 --> 00:06:27,040

148
00:06:27,040 --> 00:06:31,640
のGetStringは、ブロックを返して
メモリ、文字の配列。

149
00:06:31,640 --> 00:06:34,870
それは本当に戻っています
最初の文字へのポインタ。

150
00:06:34,870 --> 00:06:37,170
文字列はchar型の星であることを覚えておいてください。

151
00:06:37,170 --> 00:06:41,360
だから、sが最初にへのポインタである
文字列が何であれ、文字

152
00:06:41,360 --> 00:06:43,510
ユーザーがキーボードで入力されたもの。

153
00:06:43,510 --> 00:06:47,070
そのメモリはmallocされるようなことが起こる、
その結果、メモリはヒープ内である。

154
00:06:47,070 --> 00:06:49,080

155
00:06:49,080 --> 00:06:50,450
>> 質問13。

156
00:06:50,450 --> 00:06:51,960
以下のプログラムを考えてみましょう。

157
00:06:51,960 --> 00:06:55,579
だから、このすべてのプログラムがやっている
10で割ったのprintf  -  INGの1がある。

158
00:06:55,579 --> 00:06:57,370
だから、コンパイルされたとき
実行され、このプログラム

159
00:06:57,370 --> 00:07:01,170
出力は0.0、たとえ
10で割って1が0.1である。

160
00:07:01,170 --> 00:07:02,970
では、なぜそれが0.0である？

161
00:07:02,970 --> 00:07:05,510
まあ、これは理由である
整数除算の。

162
00:07:05,510 --> 00:07:08,580
だから1は10の整数であり、整数である。

163
00:07:08,580 --> 00:07:11,980
だから1すべて、10で割った
整数として扱われ、

164
00:07:11,980 --> 00:07:16,380
とCで、我々は整数の除算を行うときに、
我々はすべて小数点以下を切り捨てる。

165
00:07:16,380 --> 00:07:19,590
だから、1 10で割っている
0、その後、我々はしようとしている

166
00:07:19,590 --> 00:07:24,410
そう、floatとしてそれを印刷する
floatとして印刷されたゼロは0.0です。

167
00:07:24,410 --> 00:07:27,400
我々は0.0を取得した理由、それはです。

168
00:07:27,400 --> 00:07:28,940
>> 以下のプログラムを考えてみましょう。

169
00:07:28,940 --> 00:07:31,280
今、私たちは0.1を印刷している。

170
00:07:31,280 --> 00:07:34,280
だからなし整数除算、
私達はちょうど0.1を印刷している、

171
00:07:34,280 --> 00:07:37,100
しかし、我々はそれを印刷している
28小数点以下まで。

172
00:07:37,100 --> 00:07:41,810
そして、我々はこの0.1000、全体の束を取得
ゼロの、5 5 5、何とか何とか何とか。

173
00:07:41,810 --> 00:07:45,495
それをしない理由ので、ここで質問です
ことを、代わりに正確に0.1印刷？

174
00:07:45,495 --> 00:07:46,620

175
00:07:46,620 --> 00:07:49,640
>> だからここに理由が今ある
浮動小数点の不正確。

176
00:07:49,640 --> 00:07:53,410
フロートが唯一の32ビットであることを覚えておいてください。

177
00:07:53,410 --> 00:07:57,540
だから我々は唯一の有限数を表すことができます
業者32と浮動小数点値

178
00:07:57,540 --> 00:07:58,560
ビット。

179
00:07:58,560 --> 00:08:01,760
まあ、最終的には無限にあります
多くの浮動小数点値、

180
00:08:01,760 --> 00:08:04,940
と浮動多くは無限にあります
0と1の間のポイント値、

181
00:08:04,940 --> 00:08:07,860
そして我々は明らかにすることができるしている
それよりも多くの値を表す。

182
00:08:07,860 --> 00:08:13,230
だから我々はに犠牲をしなければならない
ほとんどの値を表現することができる。

183
00:08:13,230 --> 00:08:16,960
>> だから、0.1のような値、どうやら
我々はそれを正確に表すことはできません。

184
00:08:16,960 --> 00:08:22,500
だからではなく、0.1を表現致しております
最高の私たちは、この0.100000 5を表すことができます

185
00:08:22,500 --> 00:08:23,260
5。

186
00:08:23,260 --> 00:08:26,306
そして、それはかなり近いですが、
多くのアプリケーションのための

187
00:08:26,306 --> 00:08:28,430
あなたが心配する必要は
浮動小数点の不正確さ、

188
00:08:28,430 --> 00:08:30,930
我々だけで表すことはできませんので、
すべての浮動ポイントを正確に。

189
00:08:30,930 --> 00:08:32,500

190
00:08:32,500 --> 00:08:33,380
>> 質問15。

191
00:08:33,380 --> 00:08:34,679
以下のコードを考えてみましょう。

192
00:08:34,679 --> 00:08:36,630
私達はちょうど1プラス1を印刷している。

193
00:08:36,630 --> 00:08:38,289
だから、ここにはトリックはありません。

194
00:08:38,289 --> 00:08:41,780
1プラス1が2と評価され、
それから私達はそれを印刷している。

195
00:08:41,780 --> 00:08:42,789
これは単に2を印刷します。

196
00:08:42,789 --> 00:08:43,850

197
00:08:43,850 --> 00:08:44,700
>> 質問16。

198
00:08:44,700 --> 00:08:49,450
今、私たちは、文字を印刷している
1プラス1文字。

199
00:08:49,450 --> 00:08:52,110
では、なぜこのません
同じことを印刷？

200
00:08:52,110 --> 00:08:57,680
さて、文字1文字プラス
図1は、文字1はASCII値49を有している。

201
00:08:57,680 --> 00:09:04,840
だから、これは本当に49プラス49を言っている、と
最終的にはこれが98を印刷しようとしている。

202
00:09:04,840 --> 00:09:06,130
だから、これは2を印刷しません。

203
00:09:06,130 --> 00:09:08,070

204
00:09:08,070 --> 00:09:09,271
>> 質問17。

205
00:09:09,271 --> 00:09:11,520
実装を完了します
そのような方法で、下記の奇数

206
00:09:11,520 --> 00:09:14,615
関数は、以下の場合にtrueを返すこと
nが偶数の場合nが奇数とfalseです。

207
00:09:14,615 --> 00:09:16,710

208
00:09:16,710 --> 00:09:19,330
これは素晴らしい目的です
mod演算子のために。

209
00:09:19,330 --> 00:09:24,530
だから我々は我々の引数nを取り、
n個のmod 2がウェル1に等しい場合

210
00:09:24,530 --> 00:09:28,030
それは、n分割することを意味します
2で、残りを持っていた。

211
00:09:28,030 --> 00:09:33,270
nは、2で割った場合は、残りの部分を持っていた
nが奇数であるので、我々は真を返すことを意味します。

212
00:09:33,270 --> 00:09:34,910
ほかに、我々はfalseを返します。

213
00:09:34,910 --> 00:09:39,070
また、2等号をmod nを行っている可能性が
ゼロは、他に、falseを返すtrueを返す。

214
00:09:39,070 --> 00:09:41,600

215
00:09:41,600 --> 00:09:43,640
>> 下記の再帰関数を考えてみましょう。

216
00:09:43,640 --> 00:09:46,920
だから、nが以下である場合
1戻り、1に等しく、

217
00:09:46,920 --> 00:09:50,430
n個のfの他にリターンn回マイナス1。

218
00:09:50,430 --> 00:09:52,556
この関数は何ですか？

219
00:09:52,556 --> 00:09:54,305
まあ、これはただです
階乗関数。

220
00:09:54,305 --> 00:09:55,410

221
00:09:55,410 --> 00:09:57,405
これがうまく表現されている
n個の階乗として。

222
00:09:57,405 --> 00:09:58,720

223
00:09:58,720 --> 00:10:02,310
>> だから我々がしたい、今19を疑問視
この再帰関数を取る。

224
00:10:02,310 --> 00:10:04,530
我々は、それが反復的にしたい。

225
00:10:04,530 --> 00:10:05,874
だから我々はそれをどのように行うのですか？

226
00:10:05,874 --> 00:10:07,790
よくスタッフのための
ソリューションは、再度あります

227
00:10:07,790 --> 00:10:11,090
あなたが行っている可能性が複数の方法
それが、我々はこのint型の製品で始まる

228
00:10:11,090 --> 00:10:11,812
1に等しい。

229
00:10:11,812 --> 00:10:13,520
そして、この全体
forループ、我々はつもりだ

230
00:10:13,520 --> 00:10:17,590
最終的に製品を掛けるべき
完全要因で終わる。

231
00:10:17,590 --> 00:10:21,870
int型のためにiが2に等しいだから、私はある
n以下は、私は++。

232
00:10:21,870 --> 00:10:24,130
>> iが2に等しいなぜあなたは不思議に思われるかもしれません。

233
00:10:24,130 --> 00:10:28,380
さて、ここで私たちがしなければならないことを覚えている
私たちのベースケースが正しいことを確認してください。

234
00:10:28,380 --> 00:10:32,180
そこで、nが以下である場合
1に、私達はちょうど1を返している。

235
00:10:32,180 --> 00:10:34,830
だからここの上に、我々はiが2に等しいから始まります。

236
00:10:34,830 --> 00:10:39,090
さて私は1であったならば、the--か
nが1であった場合、forループ

237
00:10:39,090 --> 00:10:40,600
まったく実行しないであろう。

238
00:10:40,600 --> 00:10:43,190
だから私達はちょうどだろう
1であるリターン製品。

239
00:10:43,190 --> 00:10:45,920
同様に、nがあった
1--未満のもの

240
00:10:45,920 --> 00:10:49,290
それが0であった場合には負の1、whatever--
我々はまだ、1を返すことだろう

241
00:10:49,290 --> 00:10:52,260
まさにこれです
再帰的なバージョンがやっている。

242
00:10:52,260 --> 00:10:54,660
>> ここで、nが大きい場合
1よりも、我々はつもりだ

243
00:10:54,660 --> 00:10:56,550
少なくとも一つを行うには
このループの繰り返し。

244
00:10:56,550 --> 00:11:00,630
それでは私たちがしている、のnが5であるとしましょう
製品の時間をするつもりは、2に等しい。

245
00:11:00,630 --> 00:11:02,165
だから今の製品は2です。

246
00:11:02,165 --> 00:11:04,040
今、私たちはやろうとしている
製品時間は3に等しい。

247
00:11:04,040 --> 00:11:04,690
今では6です。

248
00:11:04,690 --> 00:11:07,500
製品の倍になりましたそれは24だ、4に等しい。

249
00:11:07,500 --> 00:11:10,420
製品の回今では120ですが、5に等しい。

250
00:11:10,420 --> 00:11:16,730
それでは最終的に、我々は戻っている
正しく5階乗である120、。

251
00:11:16,730 --> 00:11:17,510
>> 質問20。

252
00:11:17,510 --> 00:11:22,480
これは、あなたが入力する必要が1である
任意のアルゴリズムを用いて、この表の、

253
00:11:22,480 --> 00:11:25,735
私たちが見てきたもの、その
これらのアルゴリズムの実行にフィット

254
00:11:25,735 --> 00:11:28,060
回これらの漸近実行時間。

255
00:11:28,060 --> 00:11:33,270
だから、そのアルゴリズムは何ですか
1のオメガが、n個の大きなOで？

256
00:11:33,270 --> 00:11:35,970
だから、無限にある可能性があり
ここに多くの答え。

257
00:11:35,970 --> 00:11:39,790
我々は、おそらく最も見てきた1
頻繁にちょうど線形検索です。

258
00:11:39,790 --> 00:11:42,050
>> 最良のケースで非常に
シナリオ、我々はしているアイテム

259
00:11:42,050 --> 00:11:44,050
を探しているである
リストの先頭

260
00:11:44,050 --> 00:11:47,400
したがって1ステップのオメガで、
我々はチェックまず最初、

261
00:11:47,400 --> 00:11:49,740
私達はちょうどすぐに戻り
私達が項目を見つけたこと。

262
00:11:49,740 --> 00:11:52,189
最悪の場合、
項目は、最後にあり

263
00:11:52,189 --> 00:11:53,730
またはアイテムが全くリストにありません。

264
00:11:53,730 --> 00:11:56,700
だから我々は検索する必要が
リスト全体、すべてのn

265
00:11:56,700 --> 00:11:58,480
要素、およびそれがn個のOが理由です。

266
00:11:58,480 --> 00:11:59,670

267
00:11:59,670 --> 00:12:04,880
>> だから今、それは両方だ何か
n個のログのωn、およびnはログnの大きなO。

268
00:12:04,880 --> 00:12:08,650
さて、最も関連性の高いもの
私たちはここで見てきたソートマージである。

269
00:12:08,650 --> 00:12:12,950
だから、マージソート、覚えている、
最終的にはシータです

270
00:12:12,950 --> 00:12:16,920
シータが定義されているn個のログnの
オメガとビッグOの両方が同じである場合。

271
00:12:16,920 --> 00:12:17,580
両方N Nをログに記録します。

272
00:12:17,580 --> 00:12:18,690

273
00:12:18,690 --> 00:12:21,970
>> オメガの何か何ですか
n個の、nがOの二乗？

274
00:12:21,970 --> 00:12:23,990
さて、再びそこだ
複数の可能な答え。

275
00:12:23,990 --> 00:12:26,440
ここでは、バブルソートを言うために起こる。

276
00:12:26,440 --> 00:12:28,840
挿入ソートもここで働くだろう。

277
00:12:28,840 --> 00:12:31,400
そのバブルソートを覚えている
その最適化はどこにあります、

278
00:12:31,400 --> 00:12:34,630
あなたが得ることができる場合
リスト全体を通して

279
00:12:34,630 --> 00:12:37,402
何を必要とせず
どんなスワップ、その後、よく、

280
00:12:37,402 --> 00:12:40,110
我々はすぐにそれを返すことができます
リストはそもそもソートした。

281
00:12:40,110 --> 00:12:43,185
そこで最良のシナリオにおいて、
それはちょうど、オメガ、nのだ。

282
00:12:43,185 --> 00:12:45,960
それだけでうまくはない場合
そもそもリストをソートし、

283
00:12:45,960 --> 00:12:48,270
次に我々は、nのOがスワップを二乗している。

284
00:12:48,270 --> 00:12:49,330

285
00:12:49,330 --> 00:12:55,610
そして最後に、私たちは選択ソートを持っている
nに、オメガとビッグOの両方を乗

286
00:12:55,610 --> 00:12:56,850
>> 質問21。

287
00:12:56,850 --> 00:12:58,870
整数オーバーフローとは何ですか？

288
00:12:58,870 --> 00:13:02,160
さて、再び、以前と同様に、
我々は唯一の有限個のビットを持っている

289
00:13:02,160 --> 00:13:04,255
整数を表現する、
ので、多分32ビット。

290
00:13:04,255 --> 00:13:06,300

291
00:13:06,300 --> 00:13:09,180
それでは私たちは符号付き整数があるとしましょう​​。

292
00:13:09,180 --> 00:13:12,800
そして、最終的に最も高い
私たちが表現できる正の数

293
00:13:12,800 --> 00:13:15,910
ある2から31のマイナス1。

294
00:13:15,910 --> 00:13:19,370
私たちがしようとした場合に何が起こる
その整数をインクリメント？

295
00:13:19,370 --> 00:13:25,320
さて、私たちは2から31に行くつもりだ
マイナス1、ダウン負2へのすべての道

296
00:13:25,320 --> 00:13:26,490
31。

297
00:13:26,490 --> 00:13:29,470
したがって、この整数のオーバーフローがある
あなたがインクリメント保つとき、

298
00:13:29,470 --> 00:13:32,330
そして最終的にあなたがすることはできません
ただの高く、かつそれを得る

299
00:13:32,330 --> 00:13:34,520
すべての道バックラップ
負の値に周り。

300
00:13:34,520 --> 00:13:35,850

301
00:13:35,850 --> 00:13:37,779
>> バッファオーバーフローはどう？

302
00:13:37,779 --> 00:13:39,820
だから、バッファoverflow--
バッファが何であるかを覚えています。

303
00:13:39,820 --> 00:13:41,000
これは、メモリのほんのチャンクです。

304
00:13:41,000 --> 00:13:43,350
配列のようなものがバッファです。

305
00:13:43,350 --> 00:13:46,120
だから、バッファオーバーフローがあるとき
あなたは、メモリにアクセスしよう

306
00:13:46,120 --> 00:13:47,880
その配列の末尾を越えて。

307
00:13:47,880 --> 00:13:50,410
だから、あなたが持っている場合
サイズ5、あなたの配列

308
00:13:50,410 --> 00:13:53,700
配列ブラケットにアクセスしようとする
5またはブラケット6またはブラケット7、

309
00:13:53,700 --> 00:13:56,610
か何かを越えて
最後、あるいは何か

310
00:13:56,610 --> 00:14:00,790
負below--アレイ·ブラケット1--
それらのすべてがバッファオーバーフローである。

311
00:14:00,790 --> 00:14:02,810
あなたが悪いかの方法でメモリに触れている。

312
00:14:02,810 --> 00:14:04,090

313
00:14:04,090 --> 00:14:04,730
>> 質問23。

314
00:14:04,730 --> 00:14:05,760

315
00:14:05,760 --> 00:14:09,100
あなたが必要とするこの1中のSO
のstrlenを実装する。

316
00:14:09,100 --> 00:14:11,630
そして、我々はあなたができることを教えてくれ
sがnullにすることはできませんと仮定し、

317
00:14:11,630 --> 00:14:13,790
そうあなたがする必要はありません
ヌルのための任意のチェックを行う。

318
00:14:13,790 --> 00:14:16,190
そして、複数の方法があります
あなたはこれを行っている可能性があります。

319
00:14:16,190 --> 00:14:18,440
ここでは、ただ単純明快を取る。

320
00:14:18,440 --> 00:14:21,780
我々はカウンターで始まり、n個。 nは
ある文字数カウント。

321
00:14:21,780 --> 00:14:25,560
だから我々は0から始まり、その後、私たち
リスト全体を反復処理。

322
00:14:25,560 --> 00:14:29,092
>> Sブラケット0に等しい
ヌル終端文字？

323
00:14:29,092 --> 00:14:31,425
私たちが探している覚えている
ヌル終端文字

324
00:14:31,425 --> 00:14:33,360
私たちの文字列がどのくらいかを決定する。

325
00:14:33,360 --> 00:14:35,890
つまり、終了しようとしている
関連するすべての文字列。

326
00:14:35,890 --> 00:14:39,400
だからSブラケット0が等しい
NULL終止符？

327
00:14:39,400 --> 00:14:42,850
そうでない場合は、我々はするつもりだ
Sブラケット1、Sブラケット2を見てください。

328
00:14:42,850 --> 00:14:45,050
私達は私達まで続ける
ヌルターミネータを見つける。

329
00:14:45,050 --> 00:14:48,580
我々はそれを見つけたら、次にnが含まれています
文字列の長さの合計、

330
00:14:48,580 --> 00:14:49,942
私たちはまさにそれを返すことができます。

331
00:14:49,942 --> 00:14:51,180

332
00:14:51,180 --> 00:14:51,865
>> 質問24。

333
00:14:51,865 --> 00:14:53,010

334
00:14:53,010 --> 00:14:56,050
だから、これは1つのどこにある
トレードオフを確認する必要があります。

335
00:14:56,050 --> 00:14:59,810
だから、一つのことは、一つに良いです
方法があるが、どのような方法でそれが悪いのですか？

336
00:14:59,810 --> 00:15:02,980
だからここに、マージソートする傾向
バブルソートよりも高速。

337
00:15:02,980 --> 00:15:06,530
よく、そこにthat--言っても
複数回答はここにある。

338
00:15:06,530 --> 00:15:12,930
しかし、主な1は、そのバブルソートです
ソートされたリストのためのnのオメガです。

339
00:15:12,930 --> 00:15:14,950
>> 我々だけで前に見たそのテーブルを覚えています。

340
00:15:14,950 --> 00:15:17,600
だからバブルはオメガをソート
nは、最良のシナリオ

341
00:15:17,600 --> 00:15:20,010
それだけでオーバー行くことができますです
一度リスト、決定

342
00:15:20,010 --> 00:15:22,270
ちょっとこの事は既にある
ソートされ、リターン。

343
00:15:22,270 --> 00:15:25,960
どんな、マージソートません
あなたは、n個のログnのオメガです。

344
00:15:25,960 --> 00:15:29,200
だから、ソートされたリストについては、バブル
ソートより速いことになるだろう。

345
00:15:29,200 --> 00:15:30,870

346
00:15:30,870 --> 00:15:32,430
>> 今何リンクリストはどうですか？

347
00:15:32,430 --> 00:15:36,070
だから、リンクリストが成長し、縮小することができます
必要な数の要素を合わせて。

348
00:15:36,070 --> 00:15:38,489
そうthat--言っても
通常、直接比較

349
00:15:38,489 --> 00:15:40,280
リンクされようとしている
配列を持つリスト。

350
00:15:40,280 --> 00:15:41,600

351
00:15:41,600 --> 00:15:44,050
そうであってもアレイができますが
簡単に成長し、縮小

352
00:15:44,050 --> 00:15:47,130
など多くの要素を合わせて
必要に応じて、リンクリストなど

353
00:15:47,130 --> 00:15:49,600
array-- ANに比べ
アレイは、ランダムアクセスを有する。

354
00:15:49,600 --> 00:15:52,960
私たちはどんなへのインデックスができます
配列の特定の要素。

355
00:15:52,960 --> 00:15:56,430
>> だから、リンクリストのために、我々はできない
ちょうど5番目の要素に移動し、

356
00:15:56,430 --> 00:16:00,260
私たちは最初から横断する必要が
私たちは第5要素に到達するまで。

357
00:16:00,260 --> 00:16:03,990
そして、それはから私たちを防ぐために起こっている
バイナリサーチのようなものをやって。

358
00:16:03,990 --> 00:16:08,150
バイナリサーチといえば、バイナリサーチ
線形検索よりも速くなる傾向にある。

359
00:16:08,150 --> 00:16:11,120
that--言っても
そう、一つの可能​​な事

360
00:16:11,120 --> 00:16:13,380
あなたがバイナリを実行することができないということです
リンクリストの検索、

361
00:16:13,380 --> 00:16:14,730
あなただけのアレイ上でそれを行うことができます。

362
00:16:14,730 --> 00:16:18,030
おそらくより重要なことに、
あなたがバイナリ検索を行うことはできません

363
00:16:18,030 --> 00:16:20,690
ソートされていないアレイ上。

364
00:16:20,690 --> 00:16:23,990
Upfrontのあなたはソートする必要があるかもしれません
アレイと、その場合にのみ、

365
00:16:23,990 --> 00:16:25,370
あなたは、バイナリ検索を行う。

366
00:16:25,370 --> 00:16:27,660
だから、あなたのものでない場合
そもそもソート、

367
00:16:27,660 --> 00:16:29,250
線形検索は速くなるかもしれません。

368
00:16:29,250 --> 00:16:30,620

369
00:16:30,620 --> 00:16:31,740
>> 質問27。

370
00:16:31,740 --> 00:16:34,770
だから、下のプログラムを考え、
その次のスライドになります。

371
00:16:34,770 --> 00:16:37,790
そして、これは私たちがしている一つです
明示的に指定したいだろう

372
00:16:37,790 --> 00:16:39,980
さまざまな変数の値。

373
00:16:39,980 --> 00:16:41,990
それでは、その見てみましょう。

374
00:16:41,990 --> 00:16:43,160
>> だから、1行目。

375
00:16:43,160 --> 00:16:45,457
我々は整数、xは1に等しいがある。

376
00:16:45,457 --> 00:16:47,040
それは起こっただけのことだ。

377
00:16:47,040 --> 00:16:50,440
だから、行1で、私たちは私たちの中で参照してください。
テーブル、すなわちyは、a、bおよびtmpがすべてである

378
00:16:50,440 --> 00:16:51,540
ブラックアウト。

379
00:16:51,540 --> 00:16:52,280
だから、xは何ですか？

380
00:16:52,280 --> 00:16:53,860
まあ我々はちょうどそれは1に等しくなるように設定。

381
00:16:53,860 --> 00:16:55,020

382
00:16:55,020 --> 00:16:58,770
して、行2、よく、
我々は、yは2に設定されていることがわかる

383
00:16:58,770 --> 00:17:00,550
テーブルがすでにある
私たちのために記入。

384
00:17:00,550 --> 00:17:03,040
そこで、xは1であり、yは2である。

385
00:17:03,040 --> 00:17:05,890
>> さて、ライン3、我々は今だ
スワップ関数内。

386
00:17:05,890 --> 00:17:07,560
私たちは、スワップに合格しましたか？

387
00:17:07,560 --> 00:17:11,609
私達はのためにアンパサンドxを渡す
bについて、およびアンパサンドyを。

388
00:17:11,609 --> 00:17:15,160
どこに問題が早く
のように述べているxのアドレス

389
00:17:15,160 --> 00:17:17,520
が0x10であり、yのアドレス0x14にある。

390
00:17:17,520 --> 00:17:18,970

391
00:17:18,970 --> 00:17:21,909
そこで、bは等しい
それぞれの0x10と0x14に、。

392
00:17:21,909 --> 00:17:23,670

393
00:17:23,670 --> 00:17:26,250
>> 今行3で、xとyは何ですか？

394
00:17:26,250 --> 00:17:28,554
まあ、何も変わっていない
この時点で、xおよびyは約。

395
00:17:28,554 --> 00:17:30,470
彼らがしているにもかかわらず
メインスタックフレームの内側、

396
00:17:30,470 --> 00:17:32,469
彼らはまだ同じを持っている
彼らは前にやった値。

397
00:17:32,469 --> 00:17:34,030
私たちは、任意のメモリを変更していない。

398
00:17:34,030 --> 00:17:35,710
そこで、xは1であり、yは2である。

399
00:17:35,710 --> 00:17:36,550

400
00:17:36,550 --> 00:17:37,050
わかりました。

401
00:17:37,050 --> 00:17:40,300
だから今、私たちは星に等しいint型のtmpが言った。

402
00:17:40,300 --> 00:17:44,410
だから、ライン4、すべてのもので
TMPを除いて同じである。

403
00:17:44,410 --> 00:17:47,130
私たちはどんな値を変更していない
tmpのため除いて何の。

404
00:17:47,130 --> 00:17:49,230
私たちは星に等しいTMPを設定している。

405
00:17:49,230 --> 00:17:50,620
スターaは何ですか？

406
00:17:50,620 --> 00:17:56,240
さて、ポイントはxに、だからスター
1であるに等しいのx、しようとしている。

407
00:17:56,240 --> 00:18:00,080
だから、すべてがコピーされます
ダウン、そしてtmpには1に設定されます。

408
00:18:00,080 --> 00:18:01,110
>> 今すぐ次の行。

409
00:18:01,110 --> 00:18:03,380
スターaはスターBに等しい。

410
00:18:03,380 --> 00:18:10,000
だからラインによって、再びうまくすべてをfive--
スターaは何を除いて同じである。

411
00:18:10,000 --> 00:18:10,830
スターaは何ですか？

412
00:18:10,830 --> 00:18:13,720
さて、私たちは星のaはXであることを特徴とする。

413
00:18:13,720 --> 00:18:16,400
だから我々は同じ星bにxと変更している。

414
00:18:16,400 --> 00:18:18,960
スターbは何ですか？ Y。 yにBポイント。

415
00:18:18,960 --> 00:18:21,030
だから、星bはyです。

416
00:18:21,030 --> 00:18:25,140
だから我々はyに等しいxを設定している、
そして他のすべてが同じです。

417
00:18:25,140 --> 00:18:29,130
だから我々は、xが今であることを次の行に表示
2、残りは単にダウンコピーされる。

418
00:18:29,130 --> 00:18:31,120
>> 今すぐ次の行に、スターbはTMPに等しい。

419
00:18:31,120 --> 00:18:34,740
さて、私たちは星bはYであることを特徴とする、
私たちはtmpに等しいyと設定している。

420
00:18:34,740 --> 00:18:37,450
他のすべてが同じであり、
そうすべてがダウンしてコピーされます。

421
00:18:37,450 --> 00:18:42,050
私たちはあるtmpに、に等しいyと設定している
1、および他のすべてが同じです。

422
00:18:42,050 --> 00:18:43,210
>> さて最後に、ライン7。

423
00:18:43,210 --> 00:18:44,700
我々は戻っメイン関数にしている。

424
00:18:44,700 --> 00:18:46,350
スワップが終了した後に私たちはいる。

425
00:18:46,350 --> 00:18:48,972
私たちは、Bを失い、き
TMPが、最終的に我々

426
00:18:48,972 --> 00:18:51,180
どんな値を変更されていません
この時点では何の、

427
00:18:51,180 --> 00:18:52,800
私達はちょうどxとyを下にコピーします。

428
00:18:52,800 --> 00:18:56,490
そして、我々は、xとyがあることがわかり
今2と1ではなく1と2。

429
00:18:56,490 --> 00:18:58,160
スワップが正常に実行されました。

430
00:18:58,160 --> 00:18:59,500

431
00:18:59,500 --> 00:19:00,105
>> 質問28。

432
00:19:00,105 --> 00:19:01,226

433
00:19:01,226 --> 00:19:03,100
あなたが遭遇すると仮定
エラーメッセージ

434
00:19:03,100 --> 00:19:06,790
営業時間中に下記
CAまたはTFとして来年。

435
00:19:06,790 --> 00:19:08,930
これらのエラーのそれぞれを修正する方法を助言する。

436
00:19:08,930 --> 00:19:11,160
のGetStringにとても未定義参照。

437
00:19:11,160 --> 00:19:12,540
なぜあなたはこれが表示されることがあります？

438
00:19:12,540 --> 00:19:15,380
さて、学生が使用している場合
自分のコード内のgetString、

439
00:19:15,380 --> 00:19:20,310
彼らは正しく含まCS50をハッシュしている
ドットhはCS50ライブラリを含めます。

440
00:19:20,310 --> 00:19:22,380
>> さて、彼らが何をすべきか
このエラーを修正する必要がありますか？

441
00:19:22,380 --> 00:19:26,810
彼らは、ダッシュlcs50を行う必要があります
彼らはコンパイルしているコマンドライン。

442
00:19:26,810 --> 00:19:29,501
だから、彼らが通過しない場合は、
打ち鳴らすダッシュlcs50、彼らがしている

443
00:19:29,501 --> 00:19:32,000
実際に持っているつもりはない
のGetStringを実装するコード。

444
00:19:32,000 --> 00:19:33,190

445
00:19:33,190 --> 00:19:34,170
>> 質問29。

446
00:19:34,170 --> 00:19:36,190
暗黙的に宣言
ライブラリ関数のstrlen。

447
00:19:36,190 --> 00:19:37,550

448
00:19:37,550 --> 00:19:40,360
さて、これは今、彼らはそうではありません
適切なハッシュを行っています。

449
00:19:40,360 --> 00:19:41,440

450
00:19:41,440 --> 00:19:45,410
この特定のケースでは、ヘッダファイル
彼らは、文字列のドットhでインクルードする必要があり、

451
00:19:45,410 --> 00:19:48,710
そして今、文字列のドットhを含む
今student--コンパイラ

452
00:19:48,710 --> 00:19:51,750
へのアクセス権を持っている
strlen関数の宣言、

453
00:19:51,750 --> 00:19:54,120
そしてそれはあなたのコードを知っている
strlenを正しく使用しています。

454
00:19:54,120 --> 00:19:55,380

455
00:19:55,380 --> 00:19:56,580
>> 質問30。

456
00:19:56,580 --> 00:20:00,240
もっとパーセントの変換
データ引数より。

457
00:20:00,240 --> 00:20:01,540
だから、これは何ですか？

458
00:20:01,540 --> 00:20:06,470
さて、これらのパーセントがあることを覚えている
彼らはprintfのに関連しているかをsigns--。

459
00:20:06,470 --> 00:20:08,890
だからprintfの中で私たちはpercent--かもしれません
私たちは何かを印刷するかもしれない

460
00:20:08,890 --> 00:20:11,380
パーセントように私はnのスラッシュ。

461
00:20:11,380 --> 00:20:15,310
または私達は、パーセント私のように印刷することがあります
スペース、パーセントI、スペース、パーセントのi。

462
00:20:15,310 --> 00:20:18,950
これらのそれぞれについて、そのように
パーセント記号は、我々は必要とする

463
00:20:18,950 --> 00:20:21,560
のprintfの終わりに変数を渡すことができます。

464
00:20:21,560 --> 00:20:26,980
>> だから、私たちが言う場合は、printfの括弧パーセント
私は、括弧閉じnのスラッシュ

465
00:20:26,980 --> 00:20:30,270
よく、私たちはしていると言う
整数を印刷しようとして、

466
00:20:30,270 --> 00:20:33,970
しかし、その後、我々はprintfのを渡さない
実際に印刷する整数。

467
00:20:33,970 --> 00:20:37,182
だからここにもっとパーセント
データ引数よりもコンバージョン？

468
00:20:37,182 --> 00:20:39,390
それは我々が持っていることを言っている
パーセントの全体の束、

469
00:20:39,390 --> 00:20:42,445
そして我々は十分な変数を持っていない
実際にそれらのパーセントで埋めるために。

470
00:20:42,445 --> 00:20:44,850

471
00:20:44,850 --> 00:20:50,010
>> その後、間違いなく、質問31のため、
間違いなく1ブロックに40バイトを失った。

472
00:20:50,010 --> 00:20:52,350
だから、これはValgrindのエラーです。

473
00:20:52,350 --> 00:20:54,720
これはと言っている
あなたのコード内のどこかに、

474
00:20:54,720 --> 00:20:59,010
あなたは40で割り当てを持っている
あなたが40バイトをmallocさせ、大きなバイト、

475
00:20:59,010 --> 00:21:00,515
そして、あなたはそれを解放したことはありません。

476
00:21:00,515 --> 00:21:02,480

477
00:21:02,480 --> 00:21:05,140
あなただけの必要性が最も高い
いくつかのメモリリークを見つけるために、

478
00:21:05,140 --> 00:21:07,650
そしてあなたがする必要がどこに見つける
このメモリブロックを解放。

479
00:21:07,650 --> 00:21:08,780

480
00:21:08,780 --> 00:21:11,910
>> そして、32を疑問視
サイズ4の無効書き込み。

481
00:21:11,910 --> 00:21:13,250
これもValgrindの誤差がある。

482
00:21:13,250 --> 00:21:15,440
これは行う必要はありません
今メモリリークを持つ。

483
00:21:15,440 --> 00:21:20,750
これは私が意味likely--ほとんどが、それはだ、である
無効なメモリの権利のいくつかの並べ替え。

484
00:21:20,750 --> 00:21:23,270
そして最も可能性が高いこれはいくつかある
バッファオーバーフローの一種。

485
00:21:23,270 --> 00:21:26,560
あなたは多分、アレイを使用している
整数配列、およびレッツ

486
00:21:26,560 --> 00:21:30,115
それはサイズが5だと言う、そしてあなた
アレイ·ブラケット5に触れてみてください。

487
00:21:30,115 --> 00:21:34,150
だから、あなたがそれに書き込みをしようとした場合
値は、それはメモリの一部ではありません

488
00:21:34,150 --> 00:21:37,440
実際にへのアクセスを持ち、こと
だから、このエラーを取得するつもりだ、

489
00:21:37,440 --> 00:21:39,272
サイズ4の無効な書き込みを言って。

490
00:21:39,272 --> 00:21:42,480
Valgrindはあなたがしている認識しようとしている
不適切メモリに触れるしようとしています。

491
00:21:42,480 --> 00:21:43,980
>> そして、それはquiz0のためにそれだ。

492
00:21:43,980 --> 00:21:47,065
私はロブ·ボウデンだし、これはCS50です。

493
00:21:47,065 --> 00:21:51,104