1
00:00:00,000 --> 00:00:03,290
>> [音楽再生]

2
00:00:03,290 --> 00:00:04,989

3
00:00:04,989 --> 00:00:06,280
JASONハーシュホーン：[OK]を、誰もが。

4
00:00:06,280 --> 00:00:07,460
セクションへようこそ。

5
00:00:07,460 --> 00:00:10,840
これは私たちの非常に、CS50です
最初のスーパーセクション。

6
00:00:10,840 --> 00:00:13,700
あなたのすべては、来週知っているように
通常のセクションが開始され、

7
00:00:13,700 --> 00:00:15,580
しかし今週、我々はすべて一緒にいます。

8
00:00:15,580 --> 00:00:17,730
>> 私自身があります。

9
00:00:17,730 --> 00:00:18,840
私の名前はジェイソンです。

10
00:00:18,840 --> 00:00:20,630
私はコンピュータサイエンスの講師です。

11
00:00:20,630 --> 00:00:23,910
我々は、CS50の頭TAだアンディを、持っています。

12
00:00:23,910 --> 00:00:27,630
そしてScaz、教授ブライアンScassellati、
彼はコンピュータサイエンスの教授です。

13
00:00:27,630 --> 00:00:30,970
>> 私たちは、エール大学でCS50ヘッドです。

14
00:00:30,970 --> 00:00:34,992
あなたは、常に電子メールで送信することができます
私たちheads@cs50.yale.edu。

15
00:00:34,992 --> 00:00:35,950
私たちは、講義になります。

16
00:00:35,950 --> 00:00:37,547
私たちは、営業時間になるでしょう。

17
00:00:37,547 --> 00:00:40,130
我々はできるものは今までがある場合
、あなたのためにあなたが必要なものを行うには、

18
00:00:40,130 --> 00:00:42,610
私たちに手を差し伸べるして自由に感じます。

19
00:00:42,610 --> 00:00:44,140
>> それでは、今日はどうするつもりですか？

20
00:00:44,140 --> 00:00:47,790
あるいはそれ以前に、何の
今週来ますか？

21
00:00:47,790 --> 00:00:52,620
だから、営業時間は、月曜日、火曜日です
水曜日、木曜日、午前11時8:00。

22
00:00:52,620 --> 00:00:54,770
ウェブサイト上のスケジュールがあります。

23
00:00:54,770 --> 00:00:57,830
>> セクション、私が述べたように、
来週始めています。

24
00:00:57,830 --> 00:01:01,390
そして、あなたは何をこの週を見つけるだろう
時間あなたのセクションでは、それが何であるかの日、です、

25
00:01:01,390 --> 00:01:03,350
あなたのTAは誰なのか。

26
00:01:03,350 --> 00:01:08,610
>> 問題セット1は、木曜日に起因しています
後半日で正午正午、金曜日。

27
00:01:08,610 --> 00:01:10,817
はい、あなたは9日遅くしています。

28
00:01:10,817 --> 00:01:12,150
そして、9問題のセットがあります。

29
00:01:12,150 --> 00:01:14,320
そして、一つだけを使用することができます
問題セットごと遅く日。

30
00:01:14,320 --> 00:01:17,930
はい、実際には、すべての問題
セットは正午金曜日によるものです。

31
00:01:17,930 --> 00:01:18,550
それがすべてです。

32
00:01:18,550 --> 00:01:20,400
詳細はシラバス上にあるすべてのこと。

33
00:01:20,400 --> 00:01:22,360
>> 毎週金曜日、私たちはランチを持っています。

34
00:01:22,360 --> 00:01:25,230
私たちはこの大きなを作るのが好き
コー​​スは少し小さく感じます。

35
00:01:25,230 --> 00:01:26,580
だから、RSVPに歓迎しています。

36
00:01:26,580 --> 00:01:30,050
仲間と無料のランチ
クラスメートとスタッフ。

37
00:01:30,050 --> 00:01:34,120
cs50.yale.edu/rsvp。

38
00:01:34,120 --> 00:01:36,940
>> これらの事のすべてのこと
私は、画面上に持っています

39
00:01:36,940 --> 00:01:43,330
以上、あなたが見つけることができるcs50.yale.eduか
あなたはハーバード大学に行けばcs50.harvard.edu、

40
00:01:43,330 --> 00:01:46,800
このオンラインを見ています。

41
00:01:46,800 --> 00:01:50,240
>> また、それらのウェブサイト上で、そこに
あなたのための資源のトンです。

42
00:01:50,240 --> 00:01:54,610
すべての講義はビデオを持っているだけでなく、
講義だけでなく、ノートの。

43
00:01:54,610 --> 00:01:58,184
誰かが見てます
講義、あなたのためにメモを取ります。

44
00:01:58,184 --> 00:02:00,100
だから、あなただけ支払うことができます
講義中に注目、

45
00:02:00,100 --> 00:02:03,970
または、あなたは自分のノート/私たちを使用することができます
独自のノートを補足するために指摘しています。

46
00:02:03,970 --> 00:02:04,987
>> スライドは来店中です。

47
00:02:04,987 --> 00:02:07,320
ソースはすべてをcode--
ダビデは、講義中にオーバー行きます

48
00:02:07,320 --> 00:02:09,979
またはScazは、講義を乗り越えること
ソースコードは、オンラインで入手できます。

49
00:02:09,979 --> 00:02:11,750
同様に、私など、動画を述べました。

50
00:02:11,750 --> 00:02:14,257
>> セクションは、同様に、全てを撮影します。

51
00:02:14,257 --> 00:02:15,840
これらのスライドのすべてが利用できるようになります。

52
00:02:15,840 --> 00:02:18,190
そのコードの意志のすべて
あなたのために利用可能です。

53
00:02:18,190 --> 00:02:22,440
ウェブサイト上のどこにショートパンツがあります
CS50のスタッフは5〜10を過ごします

54
00:02:22,440 --> 00:02:24,130
あなたのためのトピックを通過分。

55
00:02:24,130 --> 00:02:26,750
それらのいくつかはすでにしました
問題のセットで発生しました。

56
00:02:26,750 --> 00:02:30,430
>> オフィスアワー、私が述べたように、月曜日
木曜日、11時00 8:00を通して。

57
00:02:30,430 --> 00:02:32,600
CS50研究は素晴らしいリソースです。

58
00:02:32,600 --> 00:02:37,100
練習問題があり、
サンプルスライド、既知のバグ

59
00:02:37,100 --> 00:02:40,920
学生はに実行したいことを、
基本的にすべてのトピック私たちのために

60
00:02:40,920 --> 00:02:42,650
このコースでカバーします。

61
00:02:42,650 --> 00:02:46,350
>> そして最後に、このスライドに
少なくとも、Reference50

62
00:02:46,350 --> 00:02:49,690
これはあなたの情報を提供します
Cの関数のすべての

63
00:02:49,690 --> 00:02:53,160
あなたはおそらく願っでした
使用して、さらに多くします。

64
00:02:53,160 --> 00:02:55,690
>> 繰り返しますが、それはでドットドットドット
画面下部

65
00:02:55,690 --> 00:02:59,990
でもありますことを示すことです
これらの2つのウェブサイト上でより多くの資源：

66
00:02:59,990 --> 00:03:04,270
cs50.yale.edu、cs50.harvard.edu。

67
00:03:04,270 --> 00:03:05,840
>> だから、今日は何をしていますか？

68
00:03:05,840 --> 00:03:08,970
さて、最初に私が与えるつもりです
あなたは、リソースを見てください。

69
00:03:08,970 --> 00:03:10,010
既にその一つでした。

70
00:03:10,010 --> 00:03:11,590
私たちを見てください。

71
00:03:11,590 --> 00:03:16,430
>> 今、私たちはオーバー行くつもりです
Cのデータ型と演算子

72
00:03:16,430 --> 00:03:19,990
その後、アンディは、ここに出てくると
C言語でライブラリの上に行く、のprintf（）、

73
00:03:19,990 --> 00:03:24,570
あなたは既にれる機能
使い慣れたかすぐに非常になります

74
00:03:24,570 --> 00:03:25,530
おなじみ。

75
00:03:25,530 --> 00:03:27,810
そして、あなたはまた、オーバー行きますよ
条件分岐やループ。

76
00:03:27,810 --> 00:03:30,900
>> そして最後に、Scaz
CS50のIDの上に移動します。

77
00:03:30,900 --> 00:03:34,250
あなたがで鳩していない場合
すでに問題セット1で、

78
00:03:34,250 --> 00:03:37,060
同様に使用する方法
端末と便利なコマンド

79
00:03:37,060 --> 00:03:42,280
して、あなたにいくつかのデモを与え、
CS50のIDで練習コーディング。

80
00:03:42,280 --> 00:03:45,130
>> 私はこれにジャンプする前に、
この側のコンテンツ、

81
00:03:45,130 --> 00:03:46,770
誰もがこれまでの任意の質問がありますか？

82
00:03:46,770 --> 00:03:53,190

83
00:03:53,190 --> 00:03:54,030
グレート。

84
00:03:54,030 --> 00:03:54,950
OK。

85
00:03:54,950 --> 00:03:55,810
ギアを変更します。

86
00:03:55,810 --> 00:03:58,760
>> [GEARSを変更]

87
00:03:58,760 --> 00:04:03,070
>> それは私がシフトしました
マニュアル車の中でギア。

88
00:04:03,070 --> 00:04:10,920
だから、C言語のデータ型、あなただけ持つことができません
変数xと、それはライン10上に存在する必要があり、

89
00:04:10,920 --> 00:04:17,170
整数、多分数1、
ライン20の10進数10.5、

90
00:04:17,170 --> 00:04:20,500
して、数行
後で文字列、私はCS50が大好きです。

91
00:04:20,500 --> 00:04:25,052
>> C言語では、変数は、することができます
一つのこと、そして一つだけ。

92
00:04:25,052 --> 00:04:26,510
だから、あなたは、彼らに型を与える必要があります。

93
00:04:26,510 --> 00:04:28,780
そして、この基板上に、我々
タイプのリストを持っています。

94
00:04:28,780 --> 00:04:32,000
これは文字があり、
文字を表します。

95
00:04:32,000 --> 00:04:36,850
だから一文字A、B、C、です
また、空間とすることができますD.、

96
00:04:36,850 --> 00:04:40,290
またはそれはまたすることができます
改行文字。

97
00:04:40,290 --> 00:04:45,030
>> ちょうどある整数があり、
数字、全体numbers--または整数

98
00:04:45,030 --> 00:04:47,130
rather--しかし、誰小数。

99
00:04:47,130 --> 00:04:49,790
>> 小数のために、私たちは持っています
浮動小数点数。

100
00:04:49,790 --> 00:04:53,200
浮動小数点数
小数と数字があります。

101
00:04:53,200 --> 00:04:58,160
>> そして、あるlong型があり、
基本的に長い整数。

102
00:04:58,160 --> 00:05:01,160
あなたが長いことに気づくでしょう
intは4であるのに対し、8です。

103
00:05:01,160 --> 00:05:02,640
私は2番目のものになるでしょう。

104
00:05:02,640 --> 00:05:07,390
long型にも格納できるためです
int型以上の整数を格納することができます。

105
00:05:07,390 --> 00:05:10,100
ダブルは長いフロートです。

106
00:05:10,100 --> 00:05:12,460
>> そして最後に、私たちは持っています
型である文字列、

107
00:05:12,460 --> 00:05:14,430
あなたはおそらく以前に使用していること。

108
00:05:14,430 --> 00:05:21,100
あなたはハッシュタグが含まれている場合
ソースファイル内の＃includeCS50.h、

109
00:05:21,100 --> 00:05:23,170
あなたは文字列型を使用することができます。

110
00:05:23,170 --> 00:05:25,560
これは実際にCに内蔵されていません

111
00:05:25,560 --> 00:05:27,760
>> カップルの他のタイプも同様にあります。

112
00:05:27,760 --> 00:05:32,900
しかし、これらは、主なものとがあります
これはあなたが使用して発生します。

113
00:05:32,900 --> 00:05:36,210
Cと、再び私が述べたように、
すべてのは、それをvariable--

114
00:05:36,210 --> 00:05:38,620
一種類のみ、唯一のタイプにすることができます。

115
00:05:38,620 --> 00:05:42,890
Cは静的であるためです
対照的に、言語を入力

116
00:05:42,890 --> 00:05:45,780
動的型付け言語に
どこで変数を作成した場合

117
00:05:45,780 --> 00:05:50,081
あなたは、に格納されている内容を変更することができます
それはあなたのプログラムの中に行くように。

118
00:05:50,081 --> 00:05:52,580
ここで右手にオーバー
側、私は、異なるサイズを持っています

119
00:05:52,580 --> 00:05:57,440
バイト単位のデータのこれらの種類の。

120
00:05:57,440 --> 00:05:59,710
だから、文字は1バイトです。

121
00:05:59,710 --> 00:06:01,250
それは8ビットです。

122
00:06:01,250 --> 00:06:05,530
そして、それは8を意味しているため
ビット8 0と1をあります。

123
00:06:05,530 --> 00:06:08,280
我々は最初に、これらのデモを見ました
そのバイナリ電球と週。

124
00:06:08,280 --> 00:06:15,680
>> 8ビットまたは1バイトで、我々はできます
0から255までの数を表します。

125
00:06:15,680 --> 00:06:16,180
右。

126
00:06:16,180 --> 00:06:18,770
すべての8ビットは0です0の場合。

127
00:06:18,770 --> 00:06:23,640
最初のビットが1である場合、それは数です
1、というように、255までのすべての方法。

128
00:06:23,640 --> 00:06:28,290
そして、それはあなたができる文字について理由です
基本的にそれらの255まで持っています、

129
00:06:28,290 --> 00:06:31,210
それはすべてをカバーするためにたくさんです
文字は、我々が使用する必要があります。

130
00:06:31,210 --> 00:06:38,060
>> 整数の場合、0を持つことができ、
あなたは32マイナス1に2を持っています。

131
00:06:38,060 --> 00:06:40,340
それらはどのように多くのオプションがあります
あなたは整数のために持っています。

132
00:06:40,340 --> 00:06:44,780
>> 長い間、あなたは0を持っています
64マイナス1から2へ。

133
00:06:44,780 --> 00:06:48,860
だから、多くの、多くを持っています、
long型のためのより多くのオプション。

134
00:06:48,860 --> 00:06:54,220
>> 文字列は、それは疑問符です
それは後でのための接戦だから。

135
00:06:54,220 --> 00:06:55,000
うん。

136
00:06:55,000 --> 00:06:56,350
私は、みんなのを言うことができます
彼らの座席の端に、

137
00:06:56,350 --> 00:06:57,450
以下のようなその疑問符は何ですか？

138
00:06:57,450 --> 00:06:58,390
それはクリフハンガーです。

139
00:06:58,390 --> 00:07:02,340
我々は最終的の大きさをカバーします
文字列と文字列の詳細について話しています。

140
00:07:02,340 --> 00:07:04,692
文字列は、実際にはあるので
補助輪の1

141
00:07:04,692 --> 00:07:06,400
我々は、この中に置きます
先頭のコース

142
00:07:06,400 --> 00:07:09,700
、後に離陸
C言語の文字列のため

143
00:07:09,700 --> 00:07:13,320
実際のポインタであります
文字配列へ。

144
00:07:13,320 --> 00:07:15,810
しかし、再び、それはです
後でクリフハンガー。

145
00:07:15,810 --> 00:07:18,890
私はすべての質問に移る前に、
コメント、このスライドの懸念？

146
00:07:18,890 --> 00:07:25,800

147
00:07:25,800 --> 00:07:26,630
>> OK。

148
00:07:26,630 --> 00:07:30,330
私は素晴らしい説明者でなければなりません。

149
00:07:30,330 --> 00:07:33,210
また、あなたはプログラミングをしているとき、
あなたはこれらの演算子を使用するつもりです。

150
00:07:33,210 --> 00:07:36,730
単純な行うことができます本当に簡単な兆候
操作は、これであなたはおそらくしています

151
00:07:36,730 --> 00:07:38,340
すでに非常に精通。

152
00:07:38,340 --> 00:07:42,580
>> 例えば、右の
手側は、我々が追加表示されます。

153
00:07:42,580 --> 00:07:44,640
追加するには、あなただけのプラス記号を行います。

154
00:07:44,640 --> 00:07:46,850
だから、あなたは可能性があり
二つの変数xとy。

155
00:07:46,850 --> 00:07:48,810
あなたは、あなたのコード内でX + Yを行うことができます。

156
00:07:48,810 --> 00:07:52,790
たぶん、あなたはあなたを言いたいですto--
番号を持つ7と3、

157
00:07:52,790 --> 00:07:55,780
あなたはそれを保存したいです
和と呼ばれる変数です。

158
00:07:55,780 --> 00:08:03,010
あなたは、タイプのためのスペースをint型を行うことができます
和、変数の名前、= + 3 7。

159
00:08:03,010 --> 00:08:05,780
>> 何合計でその店のでしょうか？

160
00:08:05,780 --> 00:08:07,190
誰ですか？

161
00:08:07,190 --> 00:08:09,270
私は合計= 7 + 3に持っていた場合。

162
00:08:09,270 --> 00:08:10,437
合計で何を保存することでしょうか？

163
00:08:10,437 --> 00:08:11,520
あなたはそれを大声で叫ぶことができます。

164
00:08:11,520 --> 00:08:12,120
聴衆：10。

165
00:08:12,120 --> 00:08:12,995
>> JASONハーシュホーン：10！

166
00:08:12,995 --> 00:08:14,870
それはまさにそうです。

167
00:08:14,870 --> 00:08:19,520
合計では約何= 7から3、
私はちょうどそのダッシュ記号を使用。

168
00:08:19,520 --> 00:08:20,871
何が格納されていることになるだろうか？

169
00:08:20,871 --> 00:08:21,370
対象：4。

170
00:08:21,370 --> 00:08:22,203
JASONハーシュホーン：4。

171
00:08:22,203 --> 00:08:25,770
合計は、おそらく間違った名前です。
その変数が、4が格納されます。

172
00:08:25,770 --> 00:08:31,890
>> C言語で乗算するには、少しを使用
スターの文字、あなたは、xを使用しません。

173
00:08:31,890 --> 00:08:35,990
分割するには、フォワードを使用
ない除算記号をスラッシュ。

174
00:08:35,990 --> 00:08:39,580
モジュロに、パーセント記号を使用しています。

175
00:08:39,580 --> 00:08:47,900
>> それでは、私はint型のz =を確認したいとしましょう
7％3、Zに何を保存することでしょうか？

176
00:08:47,900 --> 00:08:51,250
そのように、それは本質的な
モジュロは何をするのか尋ねますか？

177
00:08:51,250 --> 00:08:52,750
誰もがモジュロが何を知っていますか？

178
00:08:52,750 --> 00:08:53,940
うん。

179
00:08:53,940 --> 00:08:54,870
Y 4。

180
00:08:54,870 --> 00:08:56,120
SPEAKER 1：それは、残りのです。

181
00:08:56,120 --> 00:08:58,369
JASONハーシュホーン：それはあります
あなたが分割余り。

182
00:08:58,369 --> 00:09:02,790
だから3で割った7は2余り1です。

183
00:09:02,790 --> 00:09:04,690
そのように1が格納されることになります。

184
00:09:04,690 --> 00:09:06,970
>> あなたは、引き算をしました
それはそれがどのように動作するかです。

185
00:09:06,970 --> 00:09:09,140
これはモジュロ演算子が何をするかです。

186
00:09:09,140 --> 00:09:12,360
それは数がで除算取ります
あなたに別の番号とリターン

187
00:09:12,360 --> 00:09:14,590
残り。

188
00:09:14,590 --> 00:09:19,770
だからもう一度、7％3があるため、あなたに1を与えます
7 2余り1で3で割りました、

189
00:09:19,770 --> 00:09:21,650
余りを返します。

190
00:09:21,650 --> 00:09:24,470
>> 何についてのアップ戻ってみましょう
その除算記号に一歩。

191
00:09:24,470 --> 00:09:29,194
私は3で7 /分割をした場合はありません
誰もがそれが戻ってくる知っていますか？

192
00:09:29,194 --> 00:09:30,090
>> SPEAKER 2：2。

193
00:09:30,090 --> 00:09:32,240
>> JASONハーシュホーン：なぜ2及びませ2.333？

194
00:09:32,240 --> 00:09:34,560
>> SPEAKER 2：私はそれをカット思います
整数の後にオフにします。

195
00:09:34,560 --> 00:09:36,310
JASONハーシュホーン：だから
それがまさにそうです。

196
00:09:36,310 --> 00:09:39,880
Cでは、の分裂をすれば
3で割った二つの整数7、

197
00:09:39,880 --> 00:09:43,430
それは答えを取得します
永遠にこの場合2.3333で

198
00:09:43,430 --> 00:09:47,080
そしてそれは小数点を見つけ、
小数点以下のすべてをオフにチョップ

199
00:09:47,080 --> 00:09:49,240
そして、それはちょうどあなたに2を返します。

200
00:09:49,240 --> 00:09:51,120
>> 私は3で割っ8をしたのであれば。

201
00:09:51,120 --> 00:09:54,010
それは実際に、私たちは知っています
それは、2.666を返します

202
00:09:54,010 --> 00:09:57,050
それはにすべてをオフにチョップ
小数は、それをすべてを切り捨て、

203
00:09:57,050 --> 00:09:58,640
ちょうどあなた2に戻ります。

204
00:09:58,640 --> 00:10:02,090
だから6 3、7分割によって分割
3により、8は3で割りました、

205
00:10:02,090 --> 00:10:04,840
すべてのあなたの2に戻りしようとしています。

206
00:10:04,840 --> 00:10:08,770
>> 誰もが知っている、または推測を持っています、
私は実際に得ることができる方法として、

207
00:10:08,770 --> 00:10:10,790
完全な答え私はその小数をしたい場合は？

208
00:10:10,790 --> 00:10:13,120

209
00:10:13,120 --> 00:10:13,620
うん。

210
00:10:13,620 --> 00:10:14,152
先に行く。

211
00:10:14,152 --> 00:10:15,110
SPEAKER 3：floatを使用しますか？

212
00:10:15,110 --> 00:10:16,942
JASONハーシュホーン：あなたは何を意味するのですか？

213
00:10:16,942 --> 00:10:19,786
SPEAKER 3：あなたが言ったので
フロートが数字のためである[聞こえません]

214
00:10:19,786 --> 00:10:22,900

215
00:10:22,900 --> 00:10:23,900
JASONハーシュホーン：右。

216
00:10:23,900 --> 00:10:26,100
だから、それがまさにそうです。

217
00:10:26,100 --> 00:10:28,440
7は整数です。

218
00:10:28,440 --> 00:10:31,690
しかし、私はそれをオンにしたい場合
浮動小数点数に変換し、

219
00:10:31,690 --> 00:10:34,674
私はそれを保存する必要があります
コンピュータのため7.0として

220
00:10:34,674 --> 00:10:37,090
本当に私たちがいるのを見ましたstupid--されます
PBとJ example--と

221
00:10:37,090 --> 00:10:38,930
それだけで正確に行います
あなたがそれを教えてください。

222
00:10:38,930 --> 00:10:40,846
>> だから、7を書けば、それ
それは整数だと思います。

223
00:10:40,846 --> 00:10:43,640
あなたも私たちも、7.0を記述する場合
それらのものが等価である知っています、

224
00:10:43,640 --> 00:10:45,550
それは次のようにそれを扱います
浮動小数点数。

225
00:10:45,550 --> 00:10:50,441
あなたがしたのであれば7.0を分割
3によって、または3.0で割りました、

226
00:10:50,441 --> 00:10:52,440
それが今、OK、と言うでしょう
私たちは、フロートを扱っています。

227
00:10:52,440 --> 00:10:57,514
私は永遠にあなた2.333333に戻ります。

228
00:10:57,514 --> 00:10:59,930
しかし、本当に永遠に、理由
私たちは講義でも見たように、

229
00:10:59,930 --> 00:11:03,350
これらの浮動小数点数
厳密に正確ではありません。

230
00:11:03,350 --> 00:11:05,940
>> だから、その小数をしたいならば、
またはその小数点以下の部分、

231
00:11:05,940 --> 00:11:08,090
あなたがそれらのいずれかをuse--する必要があります
浮動小数点数でなければなりません

232
00:11:08,090 --> 00:11:11,048
コンピュータが理解する必要があります
これはあなたがしている浮動小数点であります

233
00:11:11,048 --> 00:11:13,350
、ではない整数を扱います。

234
00:11:13,350 --> 00:11:16,760
そのテーブル上の任意の質問に
右側、これまで？

235
00:11:16,760 --> 00:11:22,650
または、左手、あなたの
左、左手。

236
00:11:22,650 --> 00:11:23,264
うん。

237
00:11:23,264 --> 00:11:23,972
スピーカ4：右。

238
00:11:23,972 --> 00:11:26,216
普通等の
整数、あなたはでしょう

239
00:11:26,216 --> 00:11:30,230
write--あなたが浮く記述する必要がありますでしょうか？

240
00:11:30,230 --> 00:11:31,920
>> JASONハーシュホーン：ええそう。

241
00:11:31,920 --> 00:11:34,400
さて、あなたは作成したい場合
フロートだ変数、

242
00:11:34,400 --> 00:11:37,020
あなたはfloatを言う必要があります
zが何かに等しいです。

243
00:11:37,020 --> 00:11:37,640
>> スピーカ4：[OK]をクリックします。

244
00:11:37,640 --> 00:11:41,950
>> JASONハーシュホーン：しかし、私はしたい場合
図7は、3で割って、その小数を得るのですか、

245
00:11:41,950 --> 00:11:48,540
私は、フロートのz = 7.0 / 3.0をすることによってをするだろう。と
それは私に浮動小数点を与えるだろう

246
00:11:48,540 --> 00:11:49,273
番号。

247
00:11:49,273 --> 00:11:50,000
>> スピーカ4：[OK]をクリックします。

248
00:11:50,000 --> 00:11:56,370
>> JASONハーシュホーン：私がやった場合
3によってint型のz = 7 /のようなもの、

249
00:11:56,370 --> 00:12:00,856
それは私に整数を与えるだろう、
これらのため、すべての整数です。

250
00:12:00,856 --> 00:12:01,730
それは理にかなっていますか？

251
00:12:01,730 --> 00:12:02,320
>> スピーカ4：はい。

252
00:12:02,320 --> 00:12:02,950
>> JASONハーシュホーン：[OK]をクリックします。

253
00:12:02,950 --> 00:12:03,450
グレート。

254
00:12:03,450 --> 00:12:06,030
その表についての他の質問？

255
00:12:06,030 --> 00:12:07,220
本当に？

256
00:12:07,220 --> 00:12:08,380
私はとても興奮しています。

257
00:12:08,380 --> 00:12:09,120
OK。

258
00:12:09,120 --> 00:12:13,910
>> だから、あなたが使用するいくつかの他のものは、
しばしば、条件やループで、

259
00:12:13,910 --> 00:12:17,580
operators--のこれらの種類があります
ブール式のこれらのタイプ。

260
00:12:17,580 --> 00:12:23,140
私たちが学んだように、==はあなたのものです
二つのことが等しいかどうかを確認するために使用します。

261
00:12:23,140 --> 00:12:28,170
>> X == yは、のを許可すればだからここに私がチェックしています
再び、xは7であり、yは3であると仮定する。

262
00:12:28,170 --> 00:12:33,220
だから私は7 == 3、何を書いた場合
それは私に戻るのでしょうか？

263
00:12:33,220 --> 00:12:34,220
それは本当か偽か？

264
00:12:34,220 --> 00:12:35,275
>> 者：偽。

265
00:12:35,275 --> 00:12:36,150
JASONハーシュホーン：[OK]をクリックします。

266
00:12:36,150 --> 00:12:37,370
皆はこの1つを得ることができるような気がします。

267
00:12:37,370 --> 00:12:39,054
だから皆、それが何を返すのでしょうか？

268
00:12:39,054 --> 00:12:39,720
者：偽。

269
00:12:39,720 --> 00:12:40,130
JASONハーシュホーン：偽。

270
00:12:40,130 --> 00:12:40,850
グレート。

271
00:12:40,850 --> 00:12:41,930
図7は、3に等しくありません。

272
00:12:41,930 --> 00:12:44,530
だから7 == 3はfalseを返します。

273
00:12:44,530 --> 00:12:50,746
私場合は等しくない記号を持っているので、
7チェック！= 3、それは何を返すのでしょうか？

274
00:12:50,746 --> 00:12:51,370
聴衆：真。

275
00:12:51,370 --> 00:12:52,650
JASONハーシュホーン：真。

276
00:12:52,650 --> 00:12:53,200
優れています。

277
00:12:53,200 --> 00:12:55,990
誰かが非常に強調しましたで
バックして、それを感謝しています。

278
00:12:55,990 --> 00:12:59,070
その後、オペレータ未満を持って、
より小さいか等しい演算子、

279
00:12:59,070 --> 00:13:01,990
オペレータより大きく、大きいです
か等しい演算子。

280
00:13:01,990 --> 00:13:03,490
>> だから、もう一つの健全性チェック。

281
00:13:03,490 --> 00:13:05,660
私が持っていた場合は7が大きいです
よりまたは3に等しいです。

282
00:13:05,660 --> 00:13:06,966
それは何を返すのでしょうか？

283
00:13:06,966 --> 00:13:07,692
>> 聴衆：真。

284
00:13:07,692 --> 00:13:08,650
JASONハーシュホーン：真。

285
00:13:08,650 --> 00:13:10,050
はい。

286
00:13:10,050 --> 00:13:13,290
その奥の部屋、裏面
部屋の、素晴らしいです。

287
00:13:13,290 --> 00:13:16,240
あなたはこれらを組み合わせることができます
式の場合のように、だけでなく、

288
00:13:16,240 --> 00:13:21,880
これは論理積であります
&&や論理和（OR）これは||

289
00:13:21,880 --> 00:13:22,800
||。

290
00:13:22,800 --> 00:13:25,785
そして今、あなたは2をテストすることができます
物事が面白いということですかtogether--？

291
00:13:25,785 --> 00:13:28,250
なぜそれがおかしいのですか？

292
00:13:28,250 --> 00:13:35,200
>> 私が欲しかったのであれば、私は言うことができる7
3より大きく、2が4未満のですか？

293
00:13:35,200 --> 00:13:37,090
さて、7が大きい場合
3よりも、それは本当です。

294
00:13:37,090 --> 00:13:38,400
2が4未満であり、それは本当です。

295
00:13:38,400 --> 00:13:41,140
したがって、この全体のことは、trueを返します。

296
00:13:41,140 --> 00:13:45,130
>> 私は7をテストした場合は3 and--より大きい
私は乱数を選びましたhere--

297
00:13:45,130 --> 00:13:47,340
4が2未満である、よく、それは偽です。

298
00:13:47,340 --> 00:13:49,610
だから、真と偽のメイク偽。

299
00:13:49,610 --> 00:13:54,520
そして、あなたは上に行くことができますし、として組み合わせます
あなたが好きなように一緒に多くの条件。

300
00:13:54,520 --> 00:14:00,000
>> 誰もが任意の質問を持っています、
コメント、これまでの懸念？

301
00:14:00,000 --> 00:14:03,862
そして、私はあなたのいくつかは写真を撮って参照してください。
私の、私は感謝画面、インチ

302
00:14:03,862 --> 00:14:05,070
うまくいけば、それはSnapchatはありません。

303
00:14:05,070 --> 00:14:06,417
うまくいけば、それはあなたのノートのためです。

304
00:14:06,417 --> 00:14:08,500
しかし、これらのすべてが起こっています
オンラインで入手することができます。

305
00:14:08,500 --> 00:14:11,210
だから、あなたがする必要はありません
この写真を撮ります。

306
00:14:11,210 --> 00:14:15,150
私は、すべてを述べたと同様に
あなたのためにオンラインで利用できるようになります。

307
00:14:15,150 --> 00:14:15,650
OK。

308
00:14:15,650 --> 00:14:17,980
私が取得しようとしてよ
オフステージなので、誰もがありません

309
00:14:17,980 --> 00:14:20,350
何を言いたいです
それが起こる前に？

310
00:14:20,350 --> 00:14:21,080
質問？

311
00:14:21,080 --> 00:14:21,680
>> 【声を挟ん]

312
00:14:21,680 --> 00:14:22,250
>> JASONハーシュホーン：ああ、停止します。

313
00:14:22,250 --> 00:14:23,290
君たちもいいです。

314
00:14:23,290 --> 00:14:23,790
OK。

315
00:14:23,790 --> 00:14:26,520
私は、タグアウトするつもりです。

316
00:14:26,520 --> 00:14:27,240
行きましょう。

317
00:14:27,240 --> 00:14:29,570
>> ANDI PENG：私たちは、やろうとしています
今厄介なマイク変更。

318
00:14:29,570 --> 00:14:32,280
>> JASONハーシュホーン：私は
このオフを取るつもり。

319
00:14:32,280 --> 00:14:33,946
ANDI PENG：サポート、みんなに感謝しています。

320
00:14:33,946 --> 00:14:42,250

321
00:14:42,250 --> 00:14:43,180
私の声が聞こえますか？

322
00:14:43,180 --> 00:14:43,930
それは良いですか？

323
00:14:43,930 --> 00:14:44,760
パーフェクト。

324
00:14:44,760 --> 00:14:45,630
美しいです。

325
00:14:45,630 --> 00:14:47,490
私はちょうどにそれを押し込むてみましょう。

326
00:14:47,490 --> 00:14:49,100
OK。

327
00:14:49,100 --> 00:14:54,140
だから、私は巨大なように行うには約です
情報今、君たちにダンプします。

328
00:14:54,140 --> 00:14:57,370
そして、何の心配であれば、あなたはしているん
何のどんな小さなライン以下ではありません

329
00:14:57,370 --> 00:14:58,812
私はあなたを見ることを約です。

330
00:14:58,812 --> 00:15:00,770
ジェイソンが言ったように、すべてのもの
完全にオンラインです。

331
00:15:00,770 --> 00:15:03,780
ちょうど我々が導入しようとするつもりです
カバーされた概念に誰も

332
00:15:03,780 --> 00:15:05,270
これらのスライドの一部です。

333
00:15:05,270 --> 00:15:06,582
だから一緒に従います。

334
00:15:06,582 --> 00:15:09,540
あなたが理解していない場合は心配ありません
すべて;しかし、もし任意の時点で

335
00:15:09,540 --> 00:15:12,820
あなたが失われたと感じ、あなたを上げます
手、私たちは、心配を停止しないでしょう。

336
00:15:12,820 --> 00:15:15,060
クール。

337
00:15:15,060 --> 00:15:19,270
>> だから私はダビデは持っているものだと思います
既に種類の講演で言及

338
00:15:19,270 --> 00:15:23,240
そして、ジェイソンは一種のほのめかしました
今日にライブラリがあるものです。

339
00:15:23,240 --> 00:15:27,510
だからプログラミングで、我々は持っています
これらのことは、ライブラリと呼ばれます。

340
00:15:27,510 --> 00:15:29,690
ここで、基本的に、すべての
彼らはセットされています

341
00:15:29,690 --> 00:15:32,610
機能の、即ち
基本的にただのコードの

342
00:15:32,610 --> 00:15:35,070
すでにによって書かれて
我々はすべてのことができることを他の誰か

343
00:15:35,070 --> 00:15:36,410
我々のプログラム内でご使用ください。

344
00:15:36,410 --> 00:15:38,790
>> それでは、どの通常の処理を行い
図書館の仕事、右？

345
00:15:38,790 --> 00:15:40,030
あなたは、ライブラリのドアを入力してください。

346
00:15:40,030 --> 00:15:41,890
あなたは、これらすべてを持っています
あなたが引き出すことができますブック

347
00:15:41,890 --> 00:15:44,590
あなたが情報にアクセスすることができます
それらの本の中。

348
00:15:44,590 --> 00:15:45,840
プログラミングで同じこと。

349
00:15:45,840 --> 00:15:48,820
>> あなたは既に持っているライブラリがあります
他の人によって書かれて。

350
00:15:48,820 --> 00:15:51,530
ところであなたができること、
プログラマや学生として、

351
00:15:51,530 --> 00:15:55,780
そのライブラリにアクセスすることができます
ハッシュタグの#includeを介して行われます。

352
00:15:55,780 --> 00:15:59,720
>> たとえば、C我々で
3を持っているC--最も

353
00:15:59,720 --> 00:16:03,420
一般的に使用される3つのCの標準
、入力/出力ライブラリをlibraries--

354
00:16:03,420 --> 00:16:05,540
文字列ライブラリ、
そして、数学ライブラリ。

355
00:16:05,540 --> 00:16:07,610
>> だからあなたの最初の内
夫婦の問題は、セット

356
00:16:07,610 --> 00:16:10,940
それらは3になります
あなたが主に使用していること。

357
00:16:10,940 --> 00:16:14,610
すでにデビッドように
講義で説明し、

358
00:16:14,610 --> 00:16:17,460
標準I / Oライブラリ、または
標準入力/出力ライブラリ

359
00:16:17,460 --> 00:16:18,620
まさにそれを行います。

360
00:16:18,620 --> 00:16:23,530
これは、入力に、あなたのコードでは、ことができます
そのユーザと出力から何か

361
00:16:23,530 --> 00:16:25,960
画面に、基本的に
画面にそれを印刷します。

362
00:16:25,960 --> 00:16:29,990
>> だから、いつでもあなたは、任意の関数を使用します
例えば関数のprintf（）します

363
00:16:29,990 --> 00:16:33,319
我々は、次のスライドの上に行くつもりです
I / O規格を含めるようにしてください

364
00:16:33,319 --> 00:16:36,360
他のライブラリまたはあなたがするつもりはありません
printf（）関数を使用することができます。

365
00:16:36,360 --> 00:16:39,110
、あなたので、プログラマーとして
実際に、その関数を書いたことはありません

366
00:16:39,110 --> 00:16:41,840
あなただけの誰かを使用しています
独自のコード内の他の人のコード。

367
00:16:41,840 --> 00:16:43,620
>> そのメイクセンス誰もがしていますか？

368
00:16:43,620 --> 00:16:44,520
クール。

369
00:16:44,520 --> 00:16:48,530
>> そして、我々は基本的に取得します
string.hのライブラリとのmath.h

370
00:16:48,530 --> 00:16:52,970
ただライブラリを意味.hのライブラリー、
そのあなたが最終的によ他のライブラリ

371
00:16:52,970 --> 00:16:55,310
あなたのコード内で使用しています。

372
00:16:55,310 --> 00:16:57,620
>> しかし、目的のために
このライブラリの、私たちも

373
00:16:57,620 --> 00:17:01,170
我々はまた、持っているこのclass--のhave--
何CS50ライブラリと呼ばれ、

374
00:17:01,170 --> 00:17:05,270
cs50.h、どこ、用
あなたの閲覧が作成されました

375
00:17:05,270 --> 00:17:07,369
多くの重要かつ有用な機能。

376
00:17:07,369 --> 00:17:09,550
だからあなたのようなプログラマ
オフピギーバックすることができます

377
00:17:09,550 --> 00:17:14,470
どのように我々はすでに書きました
この関数の使用可能

378
00:17:14,470 --> 00:17:15,599
あなたの使用のために。

379
00:17:15,599 --> 00:17:18,359
>> 私はのカップルをカバーすることになります
関数は、一般的に使用されます、

380
00:17:18,359 --> 00:17:20,839
これらはであることを知っています
すべてgoogleableオンライン。

381
00:17:20,839 --> 00:17:24,904
、気軽CS50ライブラリをプルアップし、
あなたはそこにすべての機能を有しています。

382
00:17:24,904 --> 00:17:25,828
うん。

383
00:17:25,828 --> 00:17:28,140
>> スピーカ5：あなたがいなかったのであれば
ソフトウェアを使用して、その

384
00:17:28,140 --> 00:17:29,916
によって提供されます
クラスは、それを行います

385
00:17:29,916 --> 00:17:32,698
私たちはダウンロードして見つける必要があるだろう意味
このヘッダは、自分自身をファイルと言います

386
00:17:32,698 --> 00:17:33,840
それは、コンピュータ？

387
00:17:33,840 --> 00:17:34,320
>> ANDI PENG：グレート質問。

388
00:17:34,320 --> 00:17:34,820
その通りです。

389
00:17:34,820 --> 00:17:38,194
だから、それはあなたがいないのであればのようなものです
図書館で物理的に存在し、

390
00:17:38,194 --> 00:17:40,360
あなたがするための方法はありません
実際に行くとそれにアクセスします。

391
00:17:40,360 --> 00:17:42,589
同じもので、だから、
C言語でのプログラミングには、

392
00:17:42,589 --> 00:17:45,880
あなたが私たちを使用していることを確認する必要があります
アプライアンスライブラリがすでにだから

393
00:17:45,880 --> 00:17:47,270
それに組み込まれて。

394
00:17:47,270 --> 00:17:50,020
そして、あなたはハッシュタグとき
#include、図書館の存在。

395
00:17:50,020 --> 00:17:50,520
うん。

396
00:17:50,520 --> 00:17:51,920
良い質問。

397
00:17:51,920 --> 00:17:53,461
みんな良いですか？

398
00:17:53,461 --> 00:17:53,960
クール。

399
00:17:53,960 --> 00:17:56,371

400
00:17:56,371 --> 00:17:56,870
大丈夫。

401
00:17:56,870 --> 00:17:59,330
だから我々は、ヒットするつもりです
基本的に、何があります

402
00:17:59,330 --> 00:18:01,620
最初の関数こと
私たちのプログラマーがそうであるように

403
00:18:01,620 --> 00:18:03,900
私たちのコード内で使用することにしよう。

404
00:18:03,900 --> 00:18:05,690
これは、printfの（）関数と呼ばれています。

405
00:18:05,690 --> 00:18:08,450
だから、のprintf（）関数、私がきたように
すでに最後のスライドで述べています、

406
00:18:08,450 --> 00:18:11,830
標準I / Oに含まれ
標準入力/出力、ライブラリ。

407
00:18:11,830 --> 00:18:16,470
>> だから、using--しているものは何でもことを確認してください
ああ、私はレーザーをつかむせpointer--

408
00:18:16,470 --> 00:18:18,660
あなたが使用しているときはいつでも
printf（）関数、

409
00:18:18,660 --> 00:18:21,790
あなたは、I / O規格を含める必要があります
コンパイルライブラリまたは他の、

410
00:18:21,790 --> 00:18:23,760
あなたがエラーを取得するつもりです
コンピュータは次のようになりますので、

411
00:18:23,760 --> 00:18:26,140
printf（）がどこにあるああ、私は知らないが、
あなたが私に言っていないところのprintf（）

412
00:18:26,140 --> 00:18:26,830
です。

413
00:18:26,830 --> 00:18:30,150
まあのprintf（）が中に含まれています
標準I / O、ので、あなたはprintfの（）を使用し、

414
00:18:30,150 --> 00:18:32,960
それを持っていることを確認してください
あなたのコード上の行。

415
00:18:32,960 --> 00:18:36,040
>> ですから、例えば、printfの（）
ここで関数です。

416
00:18:36,040 --> 00:18:40,260
それがないすべては何かをプリントアウトです
ユーザーにかっこ内。

417
00:18:40,260 --> 00:18:44,840
誰もが刺しを利用したいと思います
どのようなコードのこの行が右に

418
00:18:44,840 --> 00:18:46,420
ここでプリントアウトしようとしていますか？

419
00:18:46,420 --> 00:18:48,730
したがって、答えは画面上です。

420
00:18:48,730 --> 00:18:50,480
誰ですか？

421
00:18:50,480 --> 00:18:51,380
>> ヴェルディ：ボトム。

422
00:18:51,380 --> 00:18:53,510
>> ANDI PENG：ヴェルディ、なぜあなたは行っていません
先に全体の文を言いますか？

423
00:18:53,510 --> 00:18:55,718
>> VERDI：こんにちは、私の名前はあります
アンディ、私は20歳です。

424
00:18:55,718 --> 00:18:57,270
ANDI PENG：ああ、美しいです。

425
00:18:57,270 --> 00:19:00,240
この行では、我々がしようとしているそう
、私の名前はアンディです、こんにちは、プリントアウト

426
00:19:00,240 --> 00:19:04,280
私は、これは20歳です
真の文は実際にあります。

427
00:19:04,280 --> 00:19:05,090
>> 構文。

428
00:19:05,090 --> 00:19:08,830
だから、夫婦構文上の問題のこと
あなたたちは、あなたが知っていることを確認したいです。

429
00:19:08,830 --> 00:19:09,360
引用。

430
00:19:09,360 --> 00:19:13,170
二重引用符は言います
コンピュータ内部のすべてのもの

431
00:19:13,170 --> 00:19:14,850
印刷されようとしています。

432
00:19:14,850 --> 00:19:16,620
>> 缶内部のすべて
ただ正確にどのようになります

433
00:19:16,620 --> 00:19:19,920
あなたはを除いて、それを入力
一般的に最後に、

434
00:19:19,920 --> 00:19:23,610
我々が含まれるようにするつもりです
hash--ああsorry--ダッシュN。

435
00:19:23,610 --> 00:19:24,640
だからダッシュN。

436
00:19:24,640 --> 00:19:28,884
>> 誰もが推測を取りたいん
それは私たちのコードに何で？

437
00:19:28,884 --> 00:19:29,465
うん。

438
00:19:29,465 --> 00:19:30,840
スピーカ6：新しい行にそれを置きます。

439
00:19:30,840 --> 00:19:31,650
ANDI PENG：その通り。

440
00:19:31,650 --> 00:19:34,660
だから、すべてこれがされません
起こるものは何でも許します

441
00:19:34,660 --> 00:19:37,520
この後、このステートメントの後、
新しい行に印刷されます。

442
00:19:37,520 --> 00:19:40,030
だから、あなたを書いているとき
あなたはランダムなものを持っていないコード

443
00:19:40,030 --> 00:19:41,738
最後に上のタック
あなたが望んでいないこと。

444
00:19:41,738 --> 00:19:43,700
そのすべてが取得します
きちんと1行を印刷

445
00:19:43,700 --> 00:19:46,870
し、我々は次の行に開始します。

446
00:19:46,870 --> 00:19:50,970
>> 誰もがどのようなことを覚えています
私たちがコーディングしているときセミコロンはいますか？

447
00:19:50,970 --> 00:19:54,580

448
00:19:54,580 --> 00:19:55,330
うん。

449
00:19:55,330 --> 00:19:55,740
>> スピーカ7：声明。

450
00:19:55,740 --> 00:19:56,010
>> ANDI PENG：申し訳ありませんか？

451
00:19:56,010 --> 00:19:57,100
>> スピーカ7：それは文を終了していますか？

452
00:19:57,100 --> 00:19:57,766
>> ANDI PENG：うん。

453
00:19:57,766 --> 00:20:02,670
だから、C、または任意のプログラミングで
言語、セミコロン

454
00:20:02,670 --> 00:20:04,640
プログラミングラインの終わりを表します。

455
00:20:04,640 --> 00:20:09,240
したがって、たとえば、英語で我々はピリオドを使用
言って、ああこれが最後の文です。

456
00:20:09,240 --> 00:20:12,857
プログラミング、同じことで、私たちは持っています
行の終わりを示すためにセミコロン。

457
00:20:12,857 --> 00:20:14,690
多くの場合、あなたがいるとき
プログラムを開始し、

458
00:20:14,690 --> 00:20:17,150
あなたはあなたを実現します
セミコロンを追加することを忘れ

459
00:20:17,150 --> 00:20:19,400
そして、あなたはあなたを実行しようとします
コー​​ドとそれが動作しません。

460
00:20:19,400 --> 00:20:21,520
そして、あなたはああ、似ている、私はしないでください
それが動作する必要がある理由を、知っています。

461
00:20:21,520 --> 00:20:24,394
>> チャンスはおそらく忘れてしまっています
セミコロンやブラケットか何か

462
00:20:24,394 --> 00:20:25,020
どこか。

463
00:20:25,020 --> 00:20:27,740
だから、それは覚えておくことが重要です。

464
00:20:27,740 --> 00:20:29,627
クール。

465
00:20:29,627 --> 00:20:31,960
すべての権利、挙手、どのように
ここで多くの人が今まで持っています

466
00:20:31,960 --> 00:20:37,210
APコンピュータサイエンスまたは撮影
これまでに、前にJavaでプログラムされましたか？

467
00:20:37,210 --> 00:20:37,710
OK。

468
00:20:37,710 --> 00:20:38,210
ラブリー。

469
00:20:38,210 --> 00:20:41,340
それは適用されません
その後、しかし、Javaで、あなた

470
00:20:41,340 --> 00:20:44,960
System.out.printlnと呼ばれるものを持っています
Cに存在しません

471
00:20:44,960 --> 00:20:49,927
>> だからCで、いつでもあなた
変数に追加します

472
00:20:49,927 --> 00:20:51,760
あなたが欲しいものに
プリントアウトするために、あります

473
00:20:51,760 --> 00:20:54,620
これから使用する固有の構文。

474
00:20:54,620 --> 00:20:56,520
それは呼ばれています
基本的にplaceholding--

475
00:20:56,520 --> 00:21:01,180
我々は場所にプレースホルダを追加します
整数または変数の

476
00:21:01,180 --> 00:21:02,580
我々は、印刷すること。

477
00:21:02,580 --> 00:21:07,430
>> あなたたちが見ることができるように、我々は用意しました
ここに新しいライブラリヘッダファイル。

478
00:21:07,430 --> 00:21:09,130
CS50ライブラリ。

479
00:21:09,130 --> 00:21:13,160
そして、そのCS50ライブラリ内に含まれます
私たちが使うことになる一般的な機能であります

480
00:21:13,160 --> 00:21:15,610
私たちのコースで）（GetIntで呼ばれます。

481
00:21:15,610 --> 00:21:21,830
>> 誰もがで刺しを取りたいん
GetIntでは、（）、おそらく何をやっても良いです。

482
00:21:21,830 --> 00:21:22,830
>> 聴衆：[聞こえません]

483
00:21:22,830 --> 00:21:23,550
>> ANDI PENG：申し訳ありません。

484
00:21:23,550 --> 00:21:24,370
あなたを聞くことができませんでした。

485
00:21:24,370 --> 00:21:25,511
Maddie、誰でも。

486
00:21:25,511 --> 00:21:27,260
MADDIE：ああ、それは求められます
整数のためのあなた。

487
00:21:27,260 --> 00:21:28,051
ANDI PENG：その通り。

488
00:21:28,051 --> 00:21:30,670
したがって、この機能は、他の
すでにだ機能

489
00:21:30,670 --> 00:21:33,690
他の誰かによって書かれて
私たちは今、時に呼び出すことができます。

490
00:21:33,690 --> 00:21:38,000
それがすべてでは、ユーザー、プロンプトで、
あなたがコードとして好き入力します

491
00:21:38,000 --> 00:21:41,850
実行していて、それがwhatever--格納されています
このケースでは、我々はGetIntで（）している -  ING、

492
00:21:41,850 --> 00:21:44,060
そのためには、私たちがしていることを意味します
整数値を得ます。

493
00:21:44,060 --> 00:21:46,150
>> そして、我々は店に行っています
その別の整数で

494
00:21:46,150 --> 00:21:48,900
私達はちょうどと呼ばれる時代を作ったこと。

495
00:21:48,900 --> 00:21:51,500
それは誰にでも意味をなさない？

496
00:21:51,500 --> 00:21:52,190
クール。

497
00:21:52,190 --> 00:21:56,400
>> だから今我々はこの整数を格納されたこと、
我々は、ユーザからの入力を求めてきたことを、

498
00:21:56,400 --> 00:22:00,010
この変数には、我々はしました
年齢と呼ばれるint型の作成、

499
00:22:00,010 --> 00:22:03,720
我々は先に行くと場所ができ
私たちのprintf（）関数です。

500
00:22:03,720 --> 00:22:08,970
だからprintfのための通常の構文は、（）であります
どこにあなたの実際の物理的にその

501
00:22:08,970 --> 00:22:14,410
あなたはその整数を含める回線、
あなたは、右がそのシンボルを行います

502
00:22:14,410 --> 00:22:17,800
でパーセント記号、
あなたがしたい変数の型。

503
00:22:17,800 --> 00:22:20,090
>> したがって、この場合には年齢は整数です。

504
00:22:20,090 --> 00:22:25,030
だから、含まれるようになるだろう
％私、それは整数だから。

505
00:22:25,030 --> 00:22:26,860
そして、あなたの後に
声明、あなたが行っています

506
00:22:26,860 --> 00:22:30,370
コンマと行います
変数の名前。

507
00:22:30,370 --> 00:22:33,420
>> そこでここでは、我々は印刷するつもりです
アウト、こんにちは、私の名前は、アンディです

508
00:22:33,420 --> 00:22:35,730
私は空白歳です。

509
00:22:35,730 --> 00:22:38,890
sorry--、Has​​hta--または、
何でも私の入力と年齢。

510
00:22:38,890 --> 00:22:42,790
だから私は、入力した場合
ここに私のGetIntで（）のための20、

511
00:22:42,790 --> 00:22:44,500
それはまったく同じことを印刷します。

512
00:22:44,500 --> 00:22:47,990
しかし、私は入力何かしたい場合
他に、おそらく40または45のような、

513
00:22:47,990 --> 00:22:50,800
あなたは反映していると見ることが
それに応じてコードインチ

514
00:22:50,800 --> 00:22:52,886
>> だから、これは一例です
で何かの

515
00:22:52,886 --> 00:22:55,260
それはプリントアウトし、に見えます
あなた、それは同じことだかのように、

516
00:22:55,260 --> 00:22:57,593
しかし、フードの下に
コンピュータが実際にあります

517
00:22:57,593 --> 00:22:59,560
起こって非常に異なるもの。

518
00:22:59,560 --> 00:23:00,060
クール。

519
00:23:00,060 --> 00:23:02,760

520
00:23:02,760 --> 00:23:03,260
大丈夫。

521
00:23:03,260 --> 00:23:06,940
だから我々は、複数の変数を何をしたい場合は？

522
00:23:06,940 --> 00:23:08,290
かなり簡単。

523
00:23:08,290 --> 00:23:09,150
同じこと。

524
00:23:09,150 --> 00:23:11,930
また、新たな機能を持っています
ここでは、（）のGetStringと呼ばれます

525
00:23:11,930 --> 00:23:15,380
また、CS50ライブラリ内に含ま
それがないすべては、ユーザープロンプトであること

526
00:23:15,380 --> 00:23:18,120
ある文字列のための
文字のセットだけ、

527
00:23:18,120 --> 00:23:19,810
文章のような、または名前のようなので。

528
00:23:19,810 --> 00:23:25,470
>> したがって、この場合には、我々は2つ​​を有するであろう
プレースホルダ％sの文字列と％iについて

529
00:23:25,470 --> 00:23:26,750
整数のため。

530
00:23:26,750 --> 00:23:29,190
そして、我々は従うつもりです
その二つの変数によって、

531
00:23:29,190 --> 00:23:32,670
私たちは順番に、含めます
彼らは文に表示されていること。

532
00:23:32,670 --> 00:23:35,471
したがって、たとえば、私の名前はあります
ブランクは、私は、そこに名前をしたいです

533
00:23:35,471 --> 00:23:36,970
私は最初の名前を持っているつもりです。

534
00:23:36,970 --> 00:23:39,637
そしてその後、私が欲しいです
年齢は、年齢秒を持っていると思います。

535
00:23:39,637 --> 00:23:42,720
だから、私は、入力したい場合は、こんにちは、
私の名前のアンディ、私は20歳です。

536
00:23:42,720 --> 00:23:46,370
私はアンディと20を入力した場合は、
まったく同じことが印刷だろう。

537
00:23:46,370 --> 00:23:51,134
しかし、今、私たちは、2つの保存された持っています
名前の変数と同様にint型。

538
00:23:51,134 --> 00:23:51,634
うん。

539
00:23:51,634 --> 00:23:54,124
>> SPEAKER 8：それは次のようになります
あなたが切り替わった場合に実行することができ

540
00:23:54,124 --> 00:23:55,620
その最後に名前と年齢？

541
00:23:55,620 --> 00:23:55,840
>> ANDI PENG：うん。

542
00:23:55,840 --> 00:23:57,006
それは本当に良い質問ですね。

543
00:23:57,006 --> 00:23:59,520
だから、長い話を短く、ありません。

544
00:23:59,520 --> 00:24:03,070
何を名前とage--ため、
変数の型は名前ですか？

545
00:24:03,070 --> 00:24:03,950
>> SPEAKER 8：文字列。

546
00:24:03,950 --> 00:24:05,440
>> ANDI PENG：そして、何
変数の型は、年齢のですか？

547
00:24:05,440 --> 00:24:06,231
>> SPEAKER 8：整数。

548
00:24:06,231 --> 00:24:10,290
ANDI PENG：そこでここでは、プレースホルダーを持っています
文字列と整数のために、右？

549
00:24:10,290 --> 00:24:13,350
ですから、これらを切り替えることであれば、
コンピュータが知ることはないだろう。

550
00:24:13,350 --> 00:24:16,250
これは、文字列をチェックするために起こっています、
そして、あなたはそれをint型を与えることをしようとすると、

551
00:24:16,250 --> 00:24:18,083
それは次のようになるだろう
、私は困惑しているあなたを待って

552
00:24:18,083 --> 00:24:21,100
私はあるべきである私に言いました
int型のためのメモリを割り当てます。

553
00:24:21,100 --> 00:24:23,760
そして右ここで、
それは整数を期待

554
00:24:23,760 --> 00:24:25,640
そして、あなたはそれに名前を付けます
代わりに、文字列、

555
00:24:25,640 --> 00:24:28,931
それはまた、非常に混乱することになるだろう、それを
正確にあなたがそれを必要とする方法を実行しません。

556
00:24:28,931 --> 00:24:35,280
だからここに、ネーミングおよび構文は次のとおりです。
コー​​ドを実行するために非常に重要。

557
00:24:35,280 --> 00:24:37,991
みんな良いですか？

558
00:24:37,991 --> 00:24:38,490
うん。

559
00:24:38,490 --> 00:24:39,476
Maddie。

560
00:24:39,476 --> 00:24:44,620
>> MADDIE：ここでは、私たちが見てきた知っています
クラスの例では、彼らはどこに依頼

561
00:24:44,620 --> 00:24:46,950
あなたの年齢は何である、あなたの名前は何ですか。

562
00:24:46,950 --> 00:24:50,250
ここでは、それはそれだろうdoesn't--
私たちはこのコードを実行した場合、

563
00:24:50,250 --> 00:24:51,750
そのために聞かないでしょうか？

564
00:24:51,750 --> 00:24:54,740
しかし、あなたは、単に入力2つの数値を希望
そしてそれはそのように実行しますか？

565
00:24:54,740 --> 00:24:55,781
>> ANDI PENG：うん、まさに。

566
00:24:55,781 --> 00:24:58,250
あなたはそれを望んでいたのであれば
ディスプレイには、あなたの年齢を入力してください、

567
00:24:58,250 --> 00:25:01,100
あなただけのprintf（）関数を追加することができます
それがあなたの年齢を入力してください、と言い、

568
00:25:01,100 --> 00:25:01,600
その上。

569
00:25:01,600 --> 00:25:02,711
それはいい質問ですね。

570
00:25:02,711 --> 00:25:03,210
うん。

571
00:25:03,210 --> 00:25:07,964
>> スピーカ9：だから、すでにだろう
GetIntで（）[聞こえない]に含まれています。

572
00:25:07,964 --> 00:25:09,380
ANDI PENG：いいえ、それは実際にはありません。

573
00:25:09,380 --> 00:25:11,809
だから、すべてこれは単なるされません
空の画面を要求します

574
00:25:11,809 --> 00:25:13,100
入力何かをユーザーに。

575
00:25:13,100 --> 00:25:17,420
あなたはそれを印刷したい場合は、それをしたい場合
アウトのようなユーザに伝えるもの、

576
00:25:17,420 --> 00:25:21,110
あなたはその後、私はあなたの年齢を記入してください
（）自分のことをprintfのする必要があります。

577
00:25:21,110 --> 00:25:23,789
誰もがこれを使用しているため
別のもののための機能、

578
00:25:23,789 --> 00:25:26,080
あなたは、年齢を保存することができ、
あなたはアドレスを格納することができ、

579
00:25:26,080 --> 00:25:28,060
あなたは電話番号を格納することができます。

580
00:25:28,060 --> 00:25:31,190
そしてそれは、まで本当にです
あなたの男の個々の用途

581
00:25:31,190 --> 00:25:34,390
あなたはそれが言いたい何のために。

582
00:25:34,390 --> 00:25:34,890
うん。

583
00:25:34,890 --> 00:25:38,236
>> スピーカ10：だから、ちょうど明確にするために、ここで
あなたが入力名前と年齢を行います

584
00:25:38,236 --> 00:25:43,020
それは％sの代わりに表示するように？

585
00:25:43,020 --> 00:25:44,320
>> ANDI PENG：ユーザーのように？

586
00:25:44,320 --> 00:25:47,165
>> スピーカ10：はい、私はどのように行うように
私はアンディを入れて行う場所it--を行い、

587
00:25:47,165 --> 00:25:48,350
どこで私は20を置くのですか？

588
00:25:48,350 --> 00:25:48,640
>> ANDI PENG：うん。

589
00:25:48,640 --> 00:25:50,250
だから、あなたがした場合
実際にこのコードを実行します、

590
00:25:50,250 --> 00:25:52,875
私は実際に実行していません
コー​​ドは、これは今ちょうどここです。

591
00:25:52,875 --> 00:25:56,910
私はコードを実行した場合、私は希望
コー​​ドをコンパイルし、ファイルを作成し、

592
00:25:56,910 --> 00:26:00,760
コー​​ドを実行し、そこでしょう
入力だけそれに私のための2つのスペースです。

593
00:26:00,760 --> 00:26:01,260
うん。

594
00:26:01,260 --> 00:26:03,843
あなたがプレイするとき、あなたたちは表示されます
コー​​ドを自分で周り。

595
00:26:03,843 --> 00:26:05,760

596
00:26:05,760 --> 00:26:09,645
>> 我々が移動しようとしているすべての権利
何の次のセクションへ

597
00:26:09,645 --> 00:26:11,610
今日はカバーされます。

598
00:26:11,610 --> 00:26:13,980
私たちは何の上に行くつもりです
条件文があります。

599
00:26:13,980 --> 00:26:16,500
だからみんなが覚えていれば
そして、講義からリコール

600
00:26:16,500 --> 00:26:19,210
条件文、
彼らはすべてが設定されています

601
00:26:19,210 --> 00:26:24,010
コンピュータ内への指示の
これは特定の条件が真の場合、

602
00:26:24,010 --> 00:26:27,470
あなたがコードを実行します
その状態の内部。

603
00:26:27,470 --> 00:26:30,101
>> だからScratch--で基本的に
今日から大きなテーマ

604
00:26:30,101 --> 00:26:32,850
あなたたちはすでに、すべて持っているということです
すべての背後にあるロジックを見て

605
00:26:32,850 --> 00:26:34,020
私たちがカバーしていること。

606
00:26:34,020 --> 00:26:36,190
そして、私たちがやっているすべてがあります
何かを翻訳

607
00:26:36,190 --> 00:26:39,090
それは非常に直感的でした
スクラッチし、それをハードコーディング

608
00:26:39,090 --> 00:26:41,950
構文に我々が使うことになるでしょう
Cです。クラスの

609
00:26:41,950 --> 00:26:47,550
だから論理的に、このすべてのブロックがありました
コー​​ドのその部分はすぐそこです。

610
00:26:47,550 --> 00:26:49,995
うん。

611
00:26:49,995 --> 00:26:50,900
OK。

612
00:26:50,900 --> 00:26:55,290
>> ...他の場合我々はまたに入ります
今追加した層である声明

613
00:26:55,290 --> 00:26:59,120
if文の複雑さの
コンピュータはこれを見てとる場所

614
00:26:59,120 --> 00:27:04,260
この条件が真である場合と、ない見
これらの2つのブラケットの内側何の、

615
00:27:04,260 --> 00:27:08,470
else--親切のデフォルトのような場合
それはcon​​dition--これを行う満たしていません。

616
00:27:08,470 --> 00:27:10,120
これは、道路の分岐点のようなものです。

617
00:27:10,120 --> 00:27:14,400
それが外に雨が降っていた場合、私は置きます
レインジャケット、何か他のものに

618
00:27:14,400 --> 00:27:16,330
他の私はレインジャケットの上に置かないでください。

619
00:27:16,330 --> 00:27:18,400
>> そのロジックは、みんなに意味がありますか？

620
00:27:18,400 --> 00:27:21,031
クール。

621
00:27:21,031 --> 00:27:21,530
大丈夫。

622
00:27:21,530 --> 00:27:24,970
のハード例のようなので
我々はC言語で見るでしょう、この

623
00:27:24,970 --> 00:27:28,890
私が作成したい場合であります
宿題の時間と呼ばれる変数。

624
00:27:28,890 --> 00:27:32,050
そして、宿題の時間が小さい場合
5よりも、私は人生は素晴らしいですと言います。

625
00:27:32,050 --> 00:27:33,070
それは素晴らしいです。

626
00:27:33,070 --> 00:27:36,450
しかし、闘争はreal--であると言います
この月曜日に私たちすべてがあります

627
00:27:36,450 --> 00:27:39,337
科学ヒルまでの午後です
おそらく正しいやっnow--

628
00:27:39,337 --> 00:27:40,170
聴衆：[笑い]

629
00:27:40,170 --> 00:27:42,510
ANDI PENG：彼らは我々の方法
、そのためにあなたに感謝します。

630
00:27:42,510 --> 00:27:46,180
我々はハードコードするような方法
これはC言語でのはと仮定しましょう​​if--です

631
00:27:46,180 --> 00:27:49,920
我々はすでに型の変数を持っています
右ここに呼ばれる宿題の時間をint型。

632
00:27:49,920 --> 00:27:53,870
宿題の時間未満である場合
5のprintf（）、人生は素晴らしいです。

633
00:27:53,870 --> 00:27:57,330
覚えておいてください保つ/ nのため
あなたは後に新しい行をしたいです。

634
00:27:57,330 --> 00:27:59,660
それ以外の印刷は、闘争は本物です。

635
00:27:59,660 --> 00:28:03,720
>> 誰もがどのように理解しています
私は、このブロックから移行しました

636
00:28:03,720 --> 00:28:07,610
このコードブロックに？

637
00:28:07,610 --> 00:28:08,110
クール。

638
00:28:08,110 --> 00:28:11,030

639
00:28:11,030 --> 00:28:11,840
大丈夫。

640
00:28:11,840 --> 00:28:15,930
>> だから今、私たちは見てみるつもりです
完全に複数のIf文。

641
00:28:15,930 --> 00:28:18,140
それでは、と仮定しましょう
このプログラムの目的

642
00:28:18,140 --> 00:28:20,870
我々はグレードをユーザーに要求しました。

643
00:28:20,870 --> 00:28:24,450
私達はのためのGetIntで（）を使用してプロンプト
グレード、およびそれらの入力値を、

644
00:28:24,450 --> 00:28:27,700
あなたが表示したいです
彼らが得たグレードの種類。

645
00:28:27,700 --> 00:28:30,730
>> 私は、私はプログラムを設計していたので、もし
私たちの目のすべてにおいて一般的に意味し、

646
00:28:30,730 --> 00:28:35,490
90-100はAであり、80〜90であります
Bなどのように。

647
00:28:35,490 --> 00:28:39,040
これで何が問題になっています
そうでないコードの一部

648
00:28:39,040 --> 00:28:41,393
私はそれが何をしたいのかやって。

649
00:28:41,393 --> 00:28:41,892
うん。

650
00:28:41,892 --> 00:28:45,100
>> スピーカ11：彼らは、下限値を持っています
彼らは上限がありません。

651
00:28:45,100 --> 00:28:46,280
>> ANDI PENG：その通り。

652
00:28:46,280 --> 00:28:47,950
誰もが彼女が言ったことを聞いていましたか？

653
00:28:47,950 --> 00:28:50,200
上位があるように起こっています
制限、ない下限値。

654
00:28:50,200 --> 00:28:52,540
申し訳ありませんが、他の方法の周りに、
下限、上限なし。

655
00:28:52,540 --> 00:28:55,090
だから、したいと思い
言うで刺しを取ります

656
00:28:55,090 --> 00:28:58,945
何この上に印刷されることになります
私はこのコードを実行した場合の画面。

657
00:28:58,945 --> 00:28:59,820
スピーカ11：エラー？

658
00:28:59,820 --> 00:29:01,140
ANDI PENG：エラー？

659
00:29:01,140 --> 00:29:02,740
グレート推測、非常に適切ではありません。

660
00:29:02,740 --> 00:29:05,465
誰もが別の刺しを持っていますか？

661
00:29:05,465 --> 00:29:06,640
うん、アーロン。

662
00:29:06,640 --> 00:29:10,099
>> AARON：あなたが入れた場合
90よりも大きいもの、

663
00:29:10,099 --> 00:29:11,640
それはあなたが得たすべてのグレードを示すであろう。

664
00:29:11,640 --> 00:29:13,640
それはあなたがAを持って表示されるでしょう、
あなたはBを持って、あなたがCを得ました

665
00:29:13,640 --> 00:29:13,870
>> ANDI PENG：うん。

666
00:29:13,870 --> 00:29:14,840
それはまさにそうです。

667
00:29:14,840 --> 00:29:17,820
だから、それは素晴らしいだろう。

668
00:29:17,820 --> 00:29:21,781
しかし、それらは相互にあります
排他的な、私は思います。

669
00:29:21,781 --> 00:29:23,280
私はコードのこの部分を実行した場合。

670
00:29:23,280 --> 00:29:26,200
そして、ちょうど、私に言わせて
95の等級を入力。

671
00:29:26,200 --> 00:29:30,360
だから95は今に格納されています
INTはグレードと呼ばれます。

672
00:29:30,360 --> 00:29:33,610
>> だからCは言語であります
それは、上から下にまで実行されます

673
00:29:33,610 --> 00:29:36,000
それは常にに起こっています
ボトムまで実行します。

674
00:29:36,000 --> 00:29:39,420
だから、あれば読んで、ここに来るために起こっています
グレードは、より大きいまたは90に等しいです、

675
00:29:39,420 --> 00:29:42,850
printf（）を使用すると、Aの偉大なを持って、私は
95を有しており、それは90よりも大きいです。

676
00:29:42,850 --> 00:29:44,866
これは、印刷するために起こっています、
私はそれが起こっているAを得ました

677
00:29:44,866 --> 00:29:48,850
場合は、このを見てみると、それが起こっています
95は、また、80以上であるだけでなく、言います

678
00:29:48,850 --> 00:29:52,970
それはあなたにもGOTを持って印刷するために起こっています
Bの感嘆符、などなど

679
00:29:52,970 --> 00:29:53,690
前後。

680
00:29:53,690 --> 00:29:55,890
>> 我々はすべてが見ることができるように、
これは一般的なバグです

681
00:29:55,890 --> 00:30:00,760
私たちがしているときには、発生する可能性があります
以下のために外を見るためにコードを書きます。

682
00:30:00,760 --> 00:30:05,430
誰でも、上の任意の質問
なぜそれが起こったのか？

683
00:30:05,430 --> 00:30:05,930
グレート。

684
00:30:05,930 --> 00:30:08,920

685
00:30:08,920 --> 00:30:09,440
OK。

686
00:30:09,440 --> 00:30:12,110
>> だから我々はこれを修正すればよいか、明らかです
論理的な次の質問。

687
00:30:12,110 --> 00:30:16,290
さて、私たちはこれらの美しいを持っています
それ以外の場合は、他の場合に呼び出さもの

688
00:30:16,290 --> 00:30:18,010
他のif文。

689
00:30:18,010 --> 00:30:22,230
だから、あなたが望んでいたかどうかを確認することができます
その問題を変更し、

690
00:30:22,230 --> 00:30:25,260
あなたはそれぞれのを作りたかったです
相互に排他的な条件、

691
00:30:25,260 --> 00:30:26,860
あなたは他の追加します... if文。

692
00:30:26,860 --> 00:30:30,068
>> そしてcourse--のこれらは、と考えます
はしご、またはladder--上の横木のような

693
00:30:30,068 --> 00:30:34,050
あなたは、これらの多くを追加することができます
あなたが好きな多くの条件のためにしたいです。

694
00:30:34,050 --> 00:30:36,790
私はグレードを入力した場合ので、ここで、95であることを。

695
00:30:36,790 --> 00:30:39,479
グレード95よりも大きい場合、
printf（）、私はA.グレートを得ました。

696
00:30:39,479 --> 00:30:42,020
それは他のを見るために起こっている...場合
それは知っているために起こっている、ああ、いや、

697
00:30:42,020 --> 00:30:43,750
私はすでに最初のelseを実行しました。

698
00:30:43,750 --> 00:30:47,020
私はknow--または最初if--私がことを知っています
私はこれらのいずれかで見てする必要はありません

699
00:30:47,020 --> 00:30:48,920
そのうちの一つ理由
既に真となっています。

700
00:30:48,920 --> 00:30:50,410
だから、トップダウンで実行するようになるだろう。

701
00:30:50,410 --> 00:30:53,650
すぐに最初のいずれかに該当するとして、その後、
それはすべての残りの部分をスキップするために起こっています

702
00:30:53,650 --> 00:30:54,675
他の... IFS。

703
00:30:54,675 --> 00:30:55,550
それは理にかなっていますか？

704
00:30:55,550 --> 00:30:57,841
だから、このようにあなたが持っています
チェックの異なるレベル

705
00:30:57,841 --> 00:31:01,090
すぐにそれらのいずれかが偽であるとして、
残りはまたしている、彼らもチェックしません。

706
00:31:01,090 --> 00:31:03,577

707
00:31:03,577 --> 00:31:04,076
クール。

708
00:31:04,076 --> 00:31:07,680

709
00:31:07,680 --> 00:31:08,180
大丈夫。

710
00:31:08,180 --> 00:31:11,180
>> これは別の例であります
条件文のようなもの

711
00:31:11,180 --> 00:31:15,250
私たちは、あまり頻繁に参照するが、
我々は彼らを見て、それらを使用します。

712
00:31:15,250 --> 00:31:18,120
そして、彼らはしばしば、よりよ
特定のケースのための効率的な。

713
00:31:18,120 --> 00:31:20,020
だから我々は何と呼ばれていています
switch文。

714
00:31:20,020 --> 00:31:25,140
だから我々は他の何覆われて前に
声明、場合... else文。

715
00:31:25,140 --> 00:31:27,790
ここで、我々は何をしている必要があり
switch文と呼ばれます。

716
00:31:27,790 --> 00:31:31,100
>> だから我々はスイッチを使用しないとき
文が鍵？

717
00:31:31,100 --> 00:31:34,090
あなたは、switch文でそう
通常、一般的に、実際に

718
00:31:34,090 --> 00:31:38,010
あなたのための唯一の入力整数缶
あなたがチェックしている変数です。

719
00:31:38,010 --> 00:31:42,390
だから私はどうかを確認したい場合
たとえば、特定のnumber--

720
00:31:42,390 --> 00:31:43,720
グレード、私は90を得た場合。

721
00:31:43,720 --> 00:31:48,190
私は、それがAの場合、それは見てみたいです
B、​​またはC私はここケースを持っている可能性があります。

722
00:31:48,190 --> 00:31:50,840
しかし、ケースは持っています
別の一定です。

723
00:31:50,840 --> 00:31:53,170
>> この意味でそう
switch文缶のみ

724
00:31:53,170 --> 00:31:55,290
2つの数の等価性をチェック。

725
00:31:55,290 --> 00:31:57,242
それは何か他のものをチェックしません。

726
00:31:57,242 --> 00:31:59,950
だから、非常になるように何か
これを使用しているときの慎重な。

727
00:31:59,950 --> 00:32:04,810
だからここに、私はどうかを確認したい場合
90の私のグレードは、90または80に等しい場合

728
00:32:04,810 --> 00:32:08,500
または70または60、次に印刷
対応するグレード、

729
00:32:08,500 --> 00:32:11,420
私はそれを書くことができるだろう
switch文インチ

730
00:32:11,420 --> 00:32:15,120
>> だから、ここに来て起こって、チェックがあります
この定数に等しいこの整数？

731
00:32:15,120 --> 00:32:17,030
ない場合は、スキップするようになるだろう。

732
00:32:17,030 --> 00:32:19,880
それが定数に等しいです
2つの等など、

733
00:32:19,880 --> 00:32:22,390
あなたはデフォルトを打つまで、
それらのどれも同じではない場合。

734
00:32:22,390 --> 00:32:24,590
すぐにそれらの一つとして、
等しくなるように設定されています、

735
00:32:24,590 --> 00:32:27,040
それがこれを行うために起こっています
コー​​ドとブレークのライン。

736
00:32:27,040 --> 00:32:30,990
それはそれを打つために起こっていることを意味
実行、ブレーク、およびだけで完全にスキップ

737
00:32:30,990 --> 00:32:32,240
コー​​ドの下へ。

738
00:32:32,240 --> 00:32:37,550
機能のだから、その意味での種類
if文、他の場合であれば、他のように。

739
00:32:37,550 --> 00:32:40,830
>> そこでここでは具体的です
君たちのための例。

740
00:32:40,830 --> 00:32:46,140
それでは、私がしようとしているとしましょう
年設立という変数を作成します。

741
00:32:46,140 --> 00:32:50,230
そして、私は、入力を促すたい
学校が設立された年。

742
00:32:50,230 --> 00:32:53,300
だから私はここにswitch文を作成することができます。

743
00:32:53,300 --> 00:32:56,650
そして、私は、入力1636、ちょうど言ってみましょう。

744
00:32:56,650 --> 00:33:01,120
>> ここでこのコードは、スイッチを見に行くされています
今年は1636年に等しい設立します。

745
00:33:01,120 --> 00:33:03,940
それはケースを見るために起こっています
1636年、オハイオ州のものが等しいです、

746
00:33:03,940 --> 00:33:06,230
printf（）は、あなたがすべきではありません
ノースアップその学校で？

747
00:33:06,230 --> 00:33:08,770
我々は、彼らがいないと仮定しているので
彼らはハーバード大学に行けばここに行きます、

748
00:33:08,770 --> 00:33:10,380
破壊し、最後に進みます。

749
00:33:10,380 --> 00:33:14,090
>> 私は、入力1701にあった場合は、これ
私は、私たちのすべてが入力だろうと仮定し、

750
00:33:14,090 --> 00:33:17,500
それはこのケースをスキップするだろう、来ます
1701の場合2まで、

751
00:33:17,500 --> 00:33:19,660
そして、エールに印刷ようこそ！

752
00:33:19,660 --> 00:33:21,360
ブレーク、最後までスキップ。

753
00:33:21,360 --> 00:33:25,130
そうでないあなたはおそらくこのコースを取っています
オンラインている素晴らしい歓迎をcase--

754
00:33:25,130 --> 00:33:29,020
それはに行くために起こっているYale--します
デフォルトの印刷、こんにちはインターネット！

755
00:33:29,020 --> 00:33:29,870
ブレーク。

756
00:33:29,870 --> 00:33:30,466
うん。

757
00:33:30,466 --> 00:33:32,090
>> スピーカ12：あなたは他の使用することができます
デフォルトの代わりがありますか？

758
00:33:32,090 --> 00:33:34,550
>> ANDI PENG：いいえ、なぜなら
途中、この関数全体

759
00:33:34,550 --> 00:33:39,170
スイッチは、構文あなたに構築されています
使用する必要がある場合ケースデフォルトです。

760
00:33:39,170 --> 00:33:42,400
それは、もしそうでなければ、この場合のようなものです
一つは、それはケースの場合のデフォルト値です。うん。

761
00:33:42,400 --> 00:33:45,650
スピーカ13：あなたは多分すでにこのように述べ、
しかし、あなたは2例以上のものを持つことができますか？

762
00:33:45,650 --> 00:33:48,066
ANDI PENG：うん、あなたは可能性が
あなたが好きなだけの場合があります。

763
00:33:48,066 --> 00:33:50,050
ただ好きなようにそれを考えます
無限に加えます。

764
00:33:50,050 --> 00:33:52,396
>> スピーカ14：あなたの場合
1636と1701を切り替え、

765
00:33:52,396 --> 00:33:54,187
それは本当にありません
差分ね？

766
00:33:54,187 --> 00:33:55,770
それはちょうどそれをチェックすることになるだろう。

767
00:33:55,770 --> 00:33:56,900
>> ANDI PENG：それは
本当に良い質問です。

768
00:33:56,900 --> 00:33:58,880
そして、我々は触れますよ
この後に、ちょうど

769
00:33:58,880 --> 00:34:01,160
それはスイッチであることを知っています
文は、それはですinfinitely--さ

770
00:34:01,160 --> 00:34:03,536
それ以外とであれば、より効率的
それが動作するためであれば、他の

771
00:34:03,536 --> 00:34:06,660
その機能の異なるタイプを使用して
あなただけに、本質的に、ことができます

772
00:34:06,660 --> 00:34:08,790
にストレートジャンプ
ケースは、あなたがにする必要があります。

773
00:34:08,790 --> 00:34:10,547
うん。

774
00:34:10,547 --> 00:34:11,255
スピーカ14：クール。

775
00:34:11,255 --> 00:34:11,754
ありがとうございます。

776
00:34:11,754 --> 00:34:12,526
ANDI PENG：うん

777
00:34:12,526 --> 00:34:16,687
>> スピーカ14：そして、あなたはできませんでした
例のようにし、より大きな行います。

778
00:34:16,687 --> 00:34:17,270
ANDI PENG：いいえ

779
00:34:17,270 --> 00:34:19,860
だから、それは約制限ているものです
switch文は、あなたが持っているということです

780
00:34:19,860 --> 00:34:21,564
唯一、整数のみの定数を持っています。

781
00:34:21,564 --> 00:34:22,064
うん。

782
00:34:22,064 --> 00:34:25,179

783
00:34:25,179 --> 00:34:25,820
OK。

784
00:34:25,820 --> 00:34:28,659
>> だから、これは何かであることを
人はあまり頻繁に発生します、

785
00:34:28,659 --> 00:34:32,280
しかし、私はちょうどしたかったです
場合にはそれを紹介します。

786
00:34:32,280 --> 00:34:36,210
私たちは何をここにあります
三項演算子と呼ばれます。

787
00:34:36,210 --> 00:34:39,370
、それだけでどこに本質的のようなものです
文は1行にコンパイルした場合。

788
00:34:39,370 --> 00:34:42,630
ここで、私は、次の行に行きますよ
次のページ、それが参照する方が簡単だからです。

789
00:34:42,630 --> 00:34:44,860
>> だから我々は、すべてのこの権利を見てきましたか？

790
00:34:44,860 --> 00:34:46,110
これは従うことは非常に簡単です。

791
00:34:46,110 --> 00:34:51,290
私はと呼ばれる変数を作成したい場合
特定の数の場合は名前付き文字列、

792
00:34:51,290 --> 00:34:54,770
私は、私は、それが100未満である与えます
文字列に低割り当てます、

793
00:34:54,770 --> 00:34:57,240
他の私は、高割り当てます。

794
00:34:57,240 --> 00:35:01,370
>> ここでこれはまったく同じことをやっています
コー​​ドのこれらの8行がやっています。

795
00:35:01,370 --> 00:35:03,600
だからここに私が作成したいです
文字列変数。

796
00:35:03,600 --> 00:35:08,520
そして、これは私が条件であります
数が100未満である場合、チェックします、

797
00:35:08,520 --> 00:35:12,750
あなたは、低の値を割り当てます
他に高いの値を代入します。

798
00:35:12,750 --> 00:35:15,802
>> これらのスライドは、オンライン心配しないであろう
君たちはこれを降りていない場合。

799
00:35:15,802 --> 00:35:18,510
これはちょうど簡単な方法、より多くのです
書き込みコードの効率的な方法。

800
00:35:18,510 --> 00:35:21,290

801
00:35:21,290 --> 00:35:21,810
OK。

802
00:35:21,810 --> 00:35:25,190
>> だから今、私たちはするつもりです
ほとんどの人々のために、何を入力してください

803
00:35:25,190 --> 00:35:28,660
非常に、非常に混乱のようなものです
最初に考える事。

804
00:35:28,660 --> 00:35:30,226
ループ部。

805
00:35:30,226 --> 00:35:32,600
だから、今日、我々は話をするつもりです
ループの約3種類。

806
00:35:32,600 --> 00:35:34,890
私たちはしばらくの間で開始するつもりです
ループは、その後、do-whil​​e文の話を、

807
00:35:34,890 --> 00:35:36,740
して、forループについて話しています。

808
00:35:36,740 --> 00:35:40,010
>> だから、本質的に、より多くのために
そこに視覚的な学習、

809
00:35:40,010 --> 00:35:44,410
我々は、基本的に、グラフィカルなを持っています
whileループが何の描写。

810
00:35:44,410 --> 00:35:48,290
だからプログラミングで、あなたが開始すると
そしてある時点でループに入ります。

811
00:35:48,290 --> 00:35:49,470
あなたは条件をチェックしてください。

812
00:35:49,470 --> 00:35:52,165
そして、条件が真の場合、
あなたは内部のコードを実行します。

813
00:35:52,165 --> 00:35:53,790
そして、あなたは周り戻ってきて、あなたがチェックします。

814
00:35:53,790 --> 00:35:57,190
それはまだ本当の場合は、実行し続けます
周りとの周りのループでこのコード。

815
00:35:57,190 --> 00:36:00,970
>> その一方、第二
条件が偽となります、

816
00:36:00,970 --> 00:36:02,739
あなたは破壊し、ループを終了するつもりです。

817
00:36:02,739 --> 00:36:05,030
そして、これは本質的です
あなたが使用するつもり構文。

818
00:36:05,030 --> 00:36:08,250
特定の条件がある一方
それは本当ではない場合はtrueが、これを行うには、

819
00:36:08,250 --> 00:36:12,920
あなたは最後までスキップするつもりです
そしてあなたのプログラムを進めます。

820
00:36:12,920 --> 00:36:13,690
OK。

821
00:36:13,690 --> 00:36:17,250
>> 誰もが例を持っています
潜在的に何が起こるかについて

822
00:36:17,250 --> 00:36:19,160
私は、コードのこの部分を実行しようとする場合はどうなりますか？

823
00:36:19,160 --> 00:36:22,470
ちなみに、それはScaz、アンディですSAJ--
Jason--私たちは、私たちの電子メールをサインオフします

824
00:36:22,470 --> 00:36:24,830
愛、SAJ。

825
00:36:24,830 --> 00:36:25,573
それは私たちです。

826
00:36:25,573 --> 00:36:26,500
OK。

827
00:36:26,500 --> 00:36:29,829
>> 誰もが例を持っている、または持っています
これは印刷し何のアイデア？

828
00:36:29,829 --> 00:36:30,870
トリックの質問の種類。

829
00:36:30,870 --> 00:36:34,550

830
00:36:34,550 --> 00:36:39,380
だからここに、条件を覚えています
真つつあるため、私たちはチェックしています。

831
00:36:39,380 --> 00:36:42,840
これが真である間、それはですので、
印刷しようと、私はSAJが大好き！

832
00:36:42,840 --> 00:36:48,460
我々はいただきたいれる任意のポイントがあります
そうでなければ何にもこれを変更？

833
00:36:48,460 --> 00:36:49,050
右、なし？

834
00:36:49,050 --> 00:36:51,470
>> そこでここでは、我々が持っています
おそらく何遭遇

835
00:36:51,470 --> 00:36:54,310
の多くを盗聴しようとして
あなたのプログラム、無限ループ。

836
00:36:54,310 --> 00:36:56,268
あなたはどうかことがわかります
コー​​ドのこの部分を実行し、

837
00:36:56,268 --> 00:36:58,160
それだけで維持するつもりです
印刷、私はSAJが大好き！

838
00:36:58,160 --> 00:37:00,701
私たちは支援に感謝しながら、
私たちはあなたのコンピュータをしたくありません

839
00:37:00,701 --> 00:37:02,910
あなたので、クラッシュします
私はSAJを愛して印刷を続けます！

840
00:37:02,910 --> 00:37:05,320
>> だからお願い、お願い、
無限ループを避けます

841
00:37:05,320 --> 00:37:07,320
それは行くことはありませんだから
falseに評価します

842
00:37:07,320 --> 00:37:08,780
あなたが行くことはありませんしています
ループを終了します。

843
00:37:08,780 --> 00:37:10,530
そして、あなたはするつもりです
永遠に吸い込まれます。

844
00:37:10,530 --> 00:37:13,000
クール。

845
00:37:13,000 --> 00:37:13,694
OK。

846
00:37:13,694 --> 00:37:15,610
ループの第二のタイプ
私たちは、今日の話をします

847
00:37:15,610 --> 00:37:17,580
doがdo-whil​​e文、whileループです。

848
00:37:17,580 --> 00:37:20,580
そして、それがdo whileループと呼ばれています
あなたがdoとwhileを持っているので。

849
00:37:20,580 --> 00:37:24,390
だから、これはしばらくの間にかなり似ています
ループが、少し異なります。

850
00:37:24,390 --> 00:37:27,620
ここでは、あなたがやろうとしています
この内の何でも

851
00:37:27,620 --> 00:37:29,747
特定の条件が真である間。

852
00:37:29,747 --> 00:37:32,580
私はCとコンピュータであればだから私はよ
コー​​ドのこの部分を下に実行し、

853
00:37:32,580 --> 00:37:33,880
私はトップを見てみましょう。

854
00:37:33,880 --> 00:37:36,890
私はこのことを行うと言う、Cに移動します。

855
00:37:36,890 --> 00:37:40,550
そして私は、この一方で、チェック
真のですが、私はそれを繰り返す必要があります。

856
00:37:40,550 --> 00:37:42,750
しかし、これは偽である一方で、
私は前方に移動

857
00:37:42,750 --> 00:37:44,700
私は再びそのループに行くことはありません。

858
00:37:44,700 --> 00:37:48,360
>> 誰もが刺しを取ることができます
どのような違いで

859
00:37:48,360 --> 00:37:52,130
このループと1我々の間
ただ事実上だった見ました。

860
00:37:52,130 --> 00:37:52,717
うん。

861
00:37:52,717 --> 00:37:55,050
スピーカ15：条件
前の代わりに、後に来ますか？

862
00:37:55,050 --> 00:37:55,841
ANDI PENG：その通り。

863
00:37:55,841 --> 00:37:57,984
だから、彼女は言った条件
前ではなく、後に来ます。

864
00:37:57,984 --> 00:38:00,400
最終的には、違い
これとwhileループの間

865
00:38:00,400 --> 00:38:03,597
あなただけやろうとしているということです
かかわらず、この内側に何の

866
00:38:03,597 --> 00:38:06,430
あなたの状態であるか否か
真、その後の状態を確認してください。

867
00:38:06,430 --> 00:38:08,304
したがって、この場合には、あなたがしています
always--このように、

868
00:38:08,304 --> 00:38:11,240
あなたは常に確認しています
どのようなのは、内部に少なくとも実行されます

869
00:38:11,240 --> 00:38:14,230
一度見にチェックする前に、
あなたはそれを再度実行したい場合。

870
00:38:14,230 --> 00:38:18,040
>> そして、ここでの例であります
我々はそれを使用するときの。

871
00:38:18,040 --> 00:38:22,570
したがって、たとえば、私が望んでいた場合には持っています
年齢という名前のint型の変数、

872
00:38:22,570 --> 00:38:25,640
私はプロンプトを表示したいです
自分の年齢のためのユーザー、

873
00:38:25,640 --> 00:38:27,910
私は（）のprintfをするつもりです
あなたは何歳ですか？

874
00:38:27,910 --> 00:38:30,330
年齢= GetIntで（）、これは
ユーザに促すています。

875
00:38:30,330 --> 00:38:32,140
>> そして、いくつかの人々は本当に迷惑になります。

876
00:38:32,140 --> 00:38:34,931
そして、あなたはあなたのバグをしたくありません
誰かのプログラムは、のように入力します

877
00:38:34,931 --> 00:38:36,680
ああ、私は4歳以上何でも否定的です。

878
00:38:36,680 --> 00:38:39,900
彼らの場合、その場合には
これが評価され、それを行います

879
00:38:39,900 --> 00:38:43,150
私はするつもりだことを意味し、trueに
戻って、これをやって維持する必要があります。

880
00:38:43,150 --> 00:38:45,310
だから、これは維持しようとしています
再プロンプトをユーザに

881
00:38:45,310 --> 00:38:47,960
本物のようにあなたを与えるために
年齢番号、それです

882
00:38:47,960 --> 00:38:51,930
戻って維持するつもりとやり直し
それは、彼らはあなたの本当の年齢を与えるまで、

883
00:38:51,930 --> 00:38:56,900
1より大きい、またはゼロではありません。

884
00:38:56,900 --> 00:38:58,020
>> だから、ヒントをヒント。

885
00:38:58,020 --> 00:39:02,263
これは非常に、非常に有用であろう
あなたのPSETの問題の1つに。

886
00:39:02,263 --> 00:39:04,155
うん。

887
00:39:04,155 --> 00:39:05,580
>> スピーカ16：おっと、申し訳ありません。

888
00:39:05,580 --> 00:39:06,288
>> ANDI PENG：うん。

889
00:39:06,288 --> 00:39:09,424
>> スピーカ16：あります、ありません
嫌いな人であることを、but--

890
00:39:09,424 --> 00:39:10,340
ANDI PENG：心配はありません。

891
00:39:10,340 --> 00:39:11,990
スピーカ16：そこ--are
ここでは異なるルール、

892
00:39:11,990 --> 00:39:13,810
または、あなただけの忘れました
引用を置きますか？

893
00:39:13,810 --> 00:39:14,250
>> ANDI PENG：うんああ。

894
00:39:14,250 --> 00:39:15,530
申し訳ありませんが、それは完全に私の悪いです。

895
00:39:15,530 --> 00:39:17,100
それは間違いでした
引用することになって。

896
00:39:17,100 --> 00:39:17,690
グッドキャッチ。

897
00:39:17,690 --> 00:39:18,800
それは実行していないだろう。

898
00:39:18,800 --> 00:39:22,070

899
00:39:22,070 --> 00:39:22,830
OK。

900
00:39:22,830 --> 00:39:26,160
>> だから、ループの最後のタイプは、我々が話しましょう
最終的には、ほとんどの種類

901
00:39:26,160 --> 00:39:28,854
複合体は、forループです。

902
00:39:28,854 --> 00:39:30,770
あなたがない場合は心配しないでください
それが何を意味するのか知っています。

903
00:39:30,770 --> 00:39:32,061
最初はかなり混乱です。

904
00:39:32,061 --> 00:39:33,640
ここでは、例の上に行きますよ。

905
00:39:33,640 --> 00:39:37,040
>> forループで起こるすべてのこと
あなたは3つの文を持っているということです

906
00:39:37,040 --> 00:39:38,380
あなたが含まれるようになるだろうということ。

907
00:39:38,380 --> 00:39:42,130
だから、あるもののために、あなたがしています
変数を初期化する予定。

908
00:39:42,130 --> 00:39:45,280
あなたはに条件を追加するつもりです
これは、このループは実行し続けます。

909
00:39:45,280 --> 00:39:47,790
そして、の終わりに
ループは、あなたはそれを更新するつもりです。

910
00:39:47,790 --> 00:39:50,248
あなたは、変数を更新することができます
あなたはを追跡することを。

911
00:39:50,248 --> 00:39:52,530
だから我々は、一般的に使用します
私たちのためのforループ

912
00:39:52,530 --> 00:39:55,390
ループを実行したいです
時間の一定量

913
00:39:55,390 --> 00:39:58,900
私たちはすでにああ、私がしたい、知っています
このループは、10回のように実行します

914
00:39:58,900 --> 00:40:03,060
あなたは私が終わっ行きますよdo--
次のページの例。

915
00:40:03,060 --> 00:40:07,830
>> だからここ例えば、スクラッチで、あなたの場合
10回繰り返すために何かをしたかったです、

916
00:40:07,830 --> 00:40:10,790
すべてあなたがしたと言っていました、
私はSAJが大好き10回繰り返します！

917
00:40:10,790 --> 00:40:15,260
これより許容可能です
私たちのサポートのショー

918
00:40:15,260 --> 00:40:17,120
むしろ無限ループより。

919
00:40:17,120 --> 00:40:19,920
ここでは、どのようにだろう
Cへの移行と書き込み

920
00:40:19,920 --> 00:40:26,040
それは私が作成したりするつもりin​​t--ためのものです
私の名前のint型の変数を宣言します。

921
00:40:26,040 --> 00:40:30,089
私は初期化す​​るつもりです
それを0にするので、私= 0;

922
00:40:30,089 --> 00:40:31,630
これは私の状態になるだろう。

923
00:40:31,630 --> 00:40:33,860
だから私は、10未満です。

924
00:40:33,860 --> 00:40:36,096
そしてend--で
あなたがしている最後の文

925
00:40:36,096 --> 00:40:38,710
持って行くことのアップデートです
何が変数iに起こります

926
00:40:38,710 --> 00:40:40,206
あなたのforループの終わりに。

927
00:40:40,206 --> 00:40:42,830
だからので、一種の混乱を招きます
このラインの異なる部分

928
00:40:42,830 --> 00:40:44,871
別の時に起こっています
ループの種類。

929
00:40:44,871 --> 00:40:46,746
しかし、私は上を行きますよ
その擬似コード例

930
00:40:46,746 --> 00:40:50,360
多分これを説明
少しだけ良いです。

931
00:40:50,360 --> 00:40:51,500
>> だからここに。

932
00:40:51,500 --> 00:40:52,929
それは我々がちょうど見たループです。

933
00:40:52,929 --> 00:40:55,470
基本的に擬似コードで、どのような
このプログラムで起こっています、

934
00:40:55,470 --> 00:40:57,940
最初に私が作成していています
私は、0に初期化。

935
00:40:57,940 --> 00:41:00,440
私は私があるかどうかを確認しています
10未満、場合には

936
00:41:00,440 --> 00:41:02,840
それは初めて
0ため、10未満です。

937
00:41:02,840 --> 00:41:04,727
したがって、ループが実行しようとしています。

938
00:41:04,727 --> 00:41:06,310
そして私は、この行を印刷するつもりです。

939
00:41:06,310 --> 00:41:11,240
そして、この行の末尾に、右
ここで、私は、私は++インクリメントをするつもりです、

940
00:41:11,240 --> 00:41:13,370
すべてのことの手段があります
1によってそれをインクリメントします。

941
00:41:13,370 --> 00:41:15,460
>> だから私は今1です。

942
00:41:15,460 --> 00:41:17,960
私ならば、それは、一度0だったので、
だそれをインクリメント、それは今1です。

943
00:41:17,960 --> 00:41:19,610
そして、私は戻って行くつもりです
ループの先頭に

944
00:41:19,610 --> 00:41:20,730
私は状態を確認。

945
00:41:20,730 --> 00:41:22,080
まだ条件が本当ですか？

946
00:41:22,080 --> 00:41:24,030
はい、1はまだ10以下です。

947
00:41:24,030 --> 00:41:27,370
だから、再びこれを印刷するために起こっています、
移動して、私をインクリメントし、確認してください

948
00:41:27,370 --> 00:41:29,180
条件
継続的に、継続的に、

949
00:41:29,180 --> 00:41:33,290
あなたが最終的に到達するまで
私は10である点に。

950
00:41:33,290 --> 00:41:36,300
>> あなたは、この10回を印刷しようとしています
そして私は10に等しくなるように起こっています。

951
00:41:36,300 --> 00:41:37,800
あなたは状態を確認しようとしています。

952
00:41:37,800 --> 00:41:38,760
10以上10以下ですか？

953
00:41:38,760 --> 00:41:40,370
いいえ、それはfalseです。

954
00:41:40,370 --> 00:41:43,020
このように、このループは行っていません
実行するには、それは破るために起こっています、

955
00:41:43,020 --> 00:41:45,040
あなたがしようとしています
あなたのコードを続行。

956
00:41:45,040 --> 00:41:47,550
>> だから人は、これを見ることができるように
本当に素晴らしい例であり、

957
00:41:47,550 --> 00:41:53,110
あなたはその中にプログラムすることができますループの
時間の指定された量のために実行されます。

958
00:41:53,110 --> 00:41:54,457
一人一人明確な？

959
00:41:54,457 --> 00:41:54,956
うん。

960
00:41:54,956 --> 00:41:59,060
>> スピーカ17：どのように増分について
指数関数的に、それは異なる符号化ですか？

961
00:41:59,060 --> 00:42:02,060
>> ANDI PENG：あなたは、私たちが行きますよcan--
次のスライドでは、このオーバー。

962
00:42:02,060 --> 00:42:03,350
良い質問。

963
00:42:03,350 --> 00:42:05,910
私が移動する前にanyone--です
、誰もまったく混乱on--

964
00:42:05,910 --> 00:42:07,640
これは本当にタフな概念ですので。

965
00:42:07,640 --> 00:42:09,510
心配はありません、you're--ばOK。

966
00:42:09,510 --> 00:42:10,010
クール。

967
00:42:10,010 --> 00:42:12,836

968
00:42:12,836 --> 00:42:13,490
>> 大丈夫。

969
00:42:13,490 --> 00:42:14,610
ただ、一般的なスライド。

970
00:42:14,610 --> 00:42:18,020
このwhileループしています
ループの正確な同じことがありました。

971
00:42:18,020 --> 00:42:19,631
それはちょうど異なる書かれています。

972
00:42:19,631 --> 00:42:22,130
君たちはスライドを閲覧することができます
後で便利に。

973
00:42:22,130 --> 00:42:24,880
しかし、単に複数があることを知っています
同じことを書く方法

974
00:42:24,880 --> 00:42:28,300
異なるループで発生します。

975
00:42:28,300 --> 00:42:28,800
OK。

976
00:42:28,800 --> 00:42:32,380
>> だから、今、私たちは何の問題の取得します
我々は、ループの内部ループを持っている場合。

977
00:42:32,380 --> 00:42:35,810
私たちは本当のに取得しています
ここインセプションタイプのもの。

978
00:42:35,810 --> 00:42:40,640
あなたは物事の複数をしたいとき
他のものの内部回

979
00:42:40,640 --> 00:42:44,129
それは、物事をあなたを複数回行います
ループのネストされたと呼ばれるものとします。

980
00:42:44,129 --> 00:42:47,420
最初にこれを見る人のためにと
非常に混乱、すべての私たちはここでやっています

981
00:42:47,420 --> 00:42:50,580
どこのループを持っています
我々は、行の変数を持っています。

982
00:42:50,580 --> 00:42:54,500
しかし、その中に、我々はまた、別のものを持っています
列と呼ばれる変数のforループ。

983
00:42:54,500 --> 00:42:58,560
そして、私は非常にあなたのすべてを示唆して
誰が最初​​に保つために混乱しています

984
00:42:58,560 --> 00:43:00,310
これを描き、これを引き出しますtrack--。

985
00:43:00,310 --> 00:43:03,000
ちょうど理由にしないでください
それを介して、それを引き出します。

986
00:43:03,000 --> 00:43:06,630
>> あなたの頭の中で、この作品に
紙、または何でも、行を書き、

987
00:43:06,630 --> 00:43:08,614
行がに等しいものを追跡します。

988
00:43:08,614 --> 00:43:10,780
追跡する、列を書きます
何列のと同じです。

989
00:43:10,780 --> 00:43:13,490
そして何であるかを追跡します
反復ごとにプリントアウトします。

990
00:43:13,490 --> 00:43:16,320
このループの各反復ごと
その大きなループの繰り返し、

991
00:43:16,320 --> 00:43:17,820
ちょうどロジック以下に保ちます。

992
00:43:17,820 --> 00:43:20,190
そして、私はあなたを保証します、
あなたが見るものを好きになります、

993
00:43:20,190 --> 00:43:24,307
それは非常にもだから
問題のセットに適用可能。

994
00:43:24,307 --> 00:43:24,806
クール。

995
00:43:24,806 --> 00:43:27,501

996
00:43:27,501 --> 00:43:28,000
大丈夫。

997
00:43:28,000 --> 00:43:30,723
そこで最も重要なこと
君たちはおそらくすべてであることを

998
00:43:30,723 --> 00:43:32,400
今のことを考え、
あなたの問題セット1sがあり、

999
00:43:32,400 --> 00:43:33,650
これは木曜日/金曜日によるものです。

1000
00:43:33,650 --> 00:43:36,890

1001
00:43:36,890 --> 00:43:39,710
>> あなたのwater.cプログラムで、
あなたが必要があるとしているヒント

1002
00:43:39,710 --> 00:43:41,590
ユーザーに入力を促します。

1003
00:43:41,590 --> 00:43:43,640
あなたのmario.cプログラム内
あなたが必要があるとしています

1004
00:43:43,640 --> 00:43:46,431
である、ループのためのネストされたを使用します
forループの内側ループのため、

1005
00:43:46,431 --> 00:43:50,247
基本的に、ピラミッドのブロックを印刷します
マリオが通過ジャンプしているかのように。

1006
00:43:50,247 --> 00:43:53,330
そして、中にあなたgreedy--または多分
すべてのあなたのみんな場合、変更を作ります

1007
00:43:53,330 --> 00:43:55,740
今までthat--の聞いたことがあります
あなたは非常にあることが必要があるとしています

1008
00:43:55,740 --> 00:43:58,160
第1の浮動小数点値を慎重に。

1009
00:43:58,160 --> 00:44:01,860
浮動小数を覚えて
整数は同じものではありません。

1010
00:44:01,860 --> 00:44:03,620
1があるのを追跡します。

1011
00:44:03,620 --> 00:44:05,953
そして、あなたが使用するつもり
条件文だけでなく。

1012
00:44:05,953 --> 00:44:09,070

1013
00:44:09,070 --> 00:44:10,940
>> すべての権利、最後の事。

1014
00:44:10,940 --> 00:44:12,770
私は、左のカップルの分を持っています。

1015
00:44:12,770 --> 00:44:13,460
スタイル。

1016
00:44:13,460 --> 00:44:19,320
だから、これはそうではないものです
実際に効率をもたらします、

1017
00:44:19,320 --> 00:44:21,010
または、コードの実走行。

1018
00:44:21,010 --> 00:44:24,380
しかし、として私たちに影響を与えます
あなた年生、読者として。

1019
00:44:24,380 --> 00:44:27,290
あなたがしている場合は、自分に影響を与えます
問題を発見しようとしています。

1020
00:44:27,290 --> 00:44:30,700
それはあなたのコードの読みやすさに影響を与えます。

1021
00:44:30,700 --> 00:44:34,070
>> あなたがしようとしているときのようなので、スタイル、
あなたがあれば、英語のためのエッセイのスタイル

1022
00:44:34,070 --> 00:44:36,070
段落を持っていませんでした、
あなたは親切なすべてを持っています

1023
00:44:36,070 --> 00:44:39,190
それは、1行にまとめてごちゃ混ぜの
誰のためにそれは本当に困難に

1024
00:44:39,190 --> 00:44:42,620
場合でも、あなたのエッセイを読むには
あなたのポイントは、論理的に健全です。

1025
00:44:42,620 --> 00:44:44,390
プログラミングで同じこと。

1026
00:44:44,390 --> 00:44:47,910
あなたはひどく曖昧なことができます
Scazがカバーするコード、

1027
00:44:47,910 --> 00:44:49,660
そしてそれはまだ実行して機能することができます。

1028
00:44:49,660 --> 00:44:53,110
しかし、私たちのために、あなたの素敵なのTAとして、誰でしょう
読んで、あなたのpsetを評価すること、

1029
00:44:53,110 --> 00:44:54,460
それはとても素敵ではありません。

1030
00:44:54,460 --> 00:44:56,859
>> だからお願い、ために
私たちとあなた自身の、

1031
00:44:56,859 --> 00:44:58,900
あなたが修正しようとしているとき
あなたのコードに問題、

1032
00:44:58,900 --> 00:45:00,774
あなたがしようとしています
独自のコードを読んで、作ります

1033
00:45:00,774 --> 00:45:03,910
あなたには、いくつかの規則に従ってください
我々は、オーバー行くつもりだということ。

1034
00:45:03,910 --> 00:45:04,510
>> したがって、最初。

1035
00:45:04,510 --> 00:45:07,070
あなたの変数に意味のある名前を付けます。

1036
00:45:07,070 --> 00:45:11,450
あなたは、整数を格納する場合
年齢と呼ばれる、年齢と名前を付けてください。

1037
00:45:11,450 --> 00:45:12,875
それを高さに名前を付けないでください。

1038
00:45:12,875 --> 00:45:14,750
あなたがしようとしているとき
高さは年齢を格納し、

1039
00:45:14,750 --> 00:45:16,722
それはすべてを作ります
私たちにとって非常に紛らわしいです。

1040
00:45:16,722 --> 00:45:17,930
私たちは、混同しては好きではありません。

1041
00:45:17,930 --> 00:45:19,180
あなたは混同しては好きではありません。

1042
00:45:19,180 --> 00:45:20,350
誰もが混同して好きではありません。

1043
00:45:20,350 --> 00:45:23,100
あなたが何かを作成するつもりなら、
意味の名前を付けます。

1044
00:45:23,100 --> 00:45:26,440
>> しかし、ループの中で、単一
文字変数は、通常は大丈夫です。

1045
00:45:26,440 --> 00:45:31,350
そして、ループの中で、あなたは私だけしたい場合は、
そして、J、K、ちょうどそれをすること自由に感じ。

1046
00:45:31,350 --> 00:45:32,670
>> 一貫性の初期化。

1047
00:45:32,670 --> 00:45:33,770
だから、何を意味するのでしょうか？

1048
00:45:33,770 --> 00:45:37,600
それは理論的には、技術的に意味し、
あなたが開始し、作成することができます

1049
00:45:37,600 --> 00:45:40,140
同じ行に複数の変数。

1050
00:45:40,140 --> 00:45:42,820
したがって、たとえば、私が作成することができます
整数scaz_ageと呼ばれます

1051
00:45:42,820 --> 00:45:47,110
整数は、20 = andi_ageと呼ばれます
jason_ageと呼ばれる整数

1052
00:45:47,110 --> 00:45:48,090
同じ行に。

1053
00:45:48,090 --> 00:45:52,060
そして、私はまた、のいずれか一方のみを割り当てることができます
彼らと値にはない他のもの。

1054
00:45:52,060 --> 00:45:54,142
私たちは、あなたがそれをしないでくださいお願いします。

1055
00:45:54,142 --> 00:45:57,350
ここでは、基本的に作成したため、
三つの変数が、それらの一方のみ

1056
00:45:57,350 --> 00:45:58,295
実際の値があります。

1057
00:45:58,295 --> 00:46:00,170
そして、我々がいるとき
あなたのコードを読み取ろうとします、

1058
00:46:00,170 --> 00:46:01,850
または、あなたが修正しようとしている場合
あなたのコードに問題、

1059
00:46:01,850 --> 00:46:03,340
それは従うことが非常に紛らわしいです。

1060
00:46:03,340 --> 00:46:09,300
だからあなたの読みやすさのために、用
私たちの読みやすさは、それをしません。

1061
00:46:09,300 --> 00:46:10,355
>> 一貫性の中括弧。

1062
00:46:10,355 --> 00:46:12,980
一部の人々は自分を置くのが好き
別の場所で中括弧。

1063
00:46:12,980 --> 00:46:14,100
それは本当に問題ではありません。

1064
00:46:14,100 --> 00:46:17,900
ちょうどあなたがで一貫していることを確認してくださいあなたの
あなたがそれらを置くのが好きどこに独自のコード。

1065
00:46:17,900 --> 00:46:18,950
>> 一貫した間隔。

1066
00:46:18,950 --> 00:46:22,040
あなたは後にスペースを入れる場合
ループのために、常にそれを行います。

1067
00:46:22,040 --> 00:46:24,930
同じような種類のでそれをしないでください
いくつかの場所では、他の人にそれをしません。

1068
00:46:24,930 --> 00:46:26,580
ただ、一貫して。

1069
00:46:26,580 --> 00:46:29,500
>> 第二に、誰もが希望の場合
CS50スタイルガイドを閲覧するには、

1070
00:46:29,500 --> 00:46:33,230
我々は正式にそのスタイルガイドを持っています
これらの規則のあなたのすべてを指示し、

1071
00:46:33,230 --> 00:46:34,890
加えて、より。

1072
00:46:34,890 --> 00:46:35,530
それはオンラインです。

1073
00:46:35,530 --> 00:46:38,670
それはcs50.net/styleようなものです
またはそのような何か。

1074
00:46:38,670 --> 00:46:40,180
あなたはそれをグーグルことができます。

1075
00:46:40,180 --> 00:46:41,399
>> 一貫性が鍵となります。

1076
00:46:41,399 --> 00:46:43,190
だから何を心配しないでください
他の人がやっています、

1077
00:46:43,190 --> 00:46:46,180
ちょうどあなたがしていることを確認してください
独自のコード内で一貫。

1078
00:46:46,180 --> 00:46:50,570
誰もがそのことについてご質問がありますか？

1079
00:46:50,570 --> 00:46:51,070
うん。

1080
00:46:51,070 --> 00:46:53,370
>> スピーカ18：だから、適切なもの
初期化を行うには、単にあります

1081
00:46:53,370 --> 00:46:56,130
別々にそれらすべてを持っています
行は、あなたが何を言っていることはありますか？

1082
00:46:56,130 --> 00:46:58,850
>> ANDI PENG：だから私はほとんどこれが起こりませんでした。

1083
00:46:58,850 --> 00:47:02,230
しかし、あなたが望む場合は、したい場合
あなたのコード内のスペースを節約するようになり、

1084
00:47:02,230 --> 00:47:04,000
または何でも、あなたはこれを行うことができます。

1085
00:47:04,000 --> 00:47:07,800
私たちはあなただけで初期化しないようお願いいたします
一つのことではなく、他の人。

1086
00:47:07,800 --> 00:47:12,600
ですから、int型scaz_ageをしたい場合は、int型
andi_age、int型のjason_age、それは大丈夫です。

1087
00:47:12,600 --> 00:47:15,600
ちょうど1を初期化しません
そして、ではない他のものが全てです。

1088
00:47:15,600 --> 00:47:18,380

1089
00:47:18,380 --> 00:47:19,904
>> 質問？

1090
00:47:19,904 --> 00:47:20,850
大丈夫。

1091
00:47:20,850 --> 00:47:24,610
私はオフに合格するつもりです
マイク、レーザーポインター、

1092
00:47:24,610 --> 00:47:28,862
そしてこの時点でScazにバトン。

1093
00:47:28,862 --> 00:47:29,808
これは厄介です。

1094
00:47:29,808 --> 00:47:32,650

1095
00:47:32,650 --> 00:47:33,200
ここにあります。

1096
00:47:33,200 --> 00:47:34,408
>> BRIAN SCASSELLATI：ありがとうございます。

1097
00:47:34,408 --> 00:47:42,500

1098
00:47:42,500 --> 00:47:43,380
どのようにそれは音のためですか？

1099
00:47:43,380 --> 00:47:46,420

1100
00:47:46,420 --> 00:47:47,900
音は良いのですか？ 。

1101
00:47:47,900 --> 00:47:49,220
優れています。

1102
00:47:49,220 --> 00:47:50,350
OK。

1103
00:47:50,350 --> 00:47:52,110
だから、皆さん、こんにちは。

1104
00:47:52,110 --> 00:47:56,540
>> 私はを通じて仕事にしようとするつもりです
あなたと実用的な例。

1105
00:47:56,540 --> 00:48:00,850
そして、我々はCS50のを使用しようとしています
呼ばれるものの開発環境、

1106
00:48:00,850 --> 00:48:03,120
統合開発環境。

1107
00:48:03,120 --> 00:48:05,145
そして、あなたはこれを見てきました
講演で明らかにしました。

1108
00:48:05,145 --> 00:48:07,520
そして、問題セット1に、あなたがしています
機会を持つことになります

1109
00:48:07,520 --> 00:48:10,890
それを使用し、で遊んします
それ、それに慣れます、

1110
00:48:10,890 --> 00:48:13,640
我々はそれを使用するつもりだので、
学期の残りの部分を通って。

1111
00:48:13,640 --> 00:48:20,350
>> したがって、このIDEで、あなたは何が見えます持っています
非常に伝統的なファイルブラウザのような

1112
00:48:20,350 --> 00:48:21,890
片側にオーバー。

1113
00:48:21,890 --> 00:48:24,360
あなたは部分を持っています
あなたが行っているトップ

1114
00:48:24,360 --> 00:48:28,850
ソースコードを表示するには、あなたの
CFILE、あなたが書いたコード。

1115
00:48:28,850 --> 00:48:31,880
そして底の下に、あなたはよ
ターミナルウィンドウを持っています

1116
00:48:31,880 --> 00:48:36,330
これはあなたが使うことになるでしょう
両方のプログラムをコンパイル

1117
00:48:36,330 --> 00:48:39,090
して、プログラムを実行したり、実行します。

1118
00:48:39,090 --> 00:48:40,100
OK。

1119
00:48:40,100 --> 00:48:46,560
>> だから私たちの少しを与えるために
基礎、その端末ウィンドウで、

1120
00:48:46,560 --> 00:48:48,930
あなたがすることになるだろう
コマンドのセットを使用して

1121
00:48:48,930 --> 00:48:53,040
全体で標準コマンドであること
UNIXまたはLinuxシステムのほとんど。

1122
00:48:53,040 --> 00:48:55,890
だから、あなたは今まで使用した場合
Unixでは、Ubuntuの任意の形態の、

1123
00:48:55,890 --> 00:48:59,140
または他のフレーバーのいずれか、
これらは見覚えがしようとしています。

1124
00:48:59,140 --> 00:49:00,890
>> あなたがいない場合、心配しないでください。

1125
00:49:00,890 --> 00:49:02,830
それらについての複雑なものは何もありません。

1126
00:49:02,830 --> 00:49:05,330
彼らはただの異なるを使用しています
構文、異なる命名

1127
00:49:05,330 --> 00:49:07,630
あなたが前に見てきたよりも大会。

1128
00:49:07,630 --> 00:49:12,190
>> だからファイルを一覧表示します
特定のディレクトリ内で、

1129
00:49:12,190 --> 00:49:15,310
彼らが使用するつもり
コマンドは、LS、またはリストと呼ばれます。

1130
00:49:15,310 --> 00:49:18,010
あなたはすべてを見たい場合
すべての詳細と、

1131
00:49:18,010 --> 00:49:21,535
次のコマンドを使用します
ls -lでのライン引数。

1132
00:49:21,535 --> 00:49:23,910
そして、それはあなたのすべてを紹介します
より詳細に、含みます

1133
00:49:23,910 --> 00:49:26,270
ファイルのパーミッション。

1134
00:49:26,270 --> 00:49:31,190
>> ディレクトリを変更するには、
あなたは、cdコマンドを使用します。

1135
00:49:31,190 --> 00:49:35,180
そして、あなたはディレクトリを変更することができるでしょう
両方のホームディレクトリに移動します。

1136
00:49:35,180 --> 00:49:38,500
それはすべてでわずかCDです
それ自体、2を収録したCD

1137
00:49:38,500 --> 00:49:42,930
ドットは1をあなたを返します。
あなたの前のディレクトリへのレベル。

1138
00:49:42,930 --> 00:49:46,400
そして、あなたはにcdすることもできます
CDに入力して、サブディレクトリ

1139
00:49:46,400 --> 00:49:48,500
そして、そのサブディレクトリの名前。

1140
00:49:48,500 --> 00:49:50,540
>> また、新しいディレクトリを作成することができます。

1141
00:49:50,540 --> 00:49:52,790
そして、私たちは歩くつもりです
わずか数分でこのを通して。

1142
00:49:52,790 --> 00:49:54,498
しかし、単に置くために
画面上のすべて。

1143
00:49:54,498 --> 00:49:56,310
あなたがそれらを見ることができるように。

1144
00:49:56,310 --> 00:50:00,420
>> また、能力を持っています
直接ファイルを操作します

1145
00:50:00,420 --> 00:50:02,100
コマンドラインから。

1146
00:50:02,100 --> 00:50:06,059
あなたはに、それらをコピーすることができるでしょう
それらを移動するか、それらを削除します、

1147
00:50:06,059 --> 00:50:07,600
それは、それらを削除するために、効果的です。

1148
00:50:07,600 --> 00:50:10,310

1149
00:50:10,310 --> 00:50:15,350
>> CS50 IDEはあなたに完全なを与えます
コマンドライン引数のパワー。

1150
00:50:15,350 --> 00:50:20,280
そして、それはあなたにもできることを意味します
非常に危険なことを行います。

1151
00:50:20,280 --> 00:50:21,560
OK。

1152
00:50:21,560 --> 00:50:25,010
たとえば、次のことができます
、削除、またはそれが削除され

1153
00:50:25,010 --> 00:50:28,750
求めないファイル
確認のため。

1154
00:50:28,750 --> 00:50:31,820
そして、あなたも削除することができます
それはですrecursively--

1155
00:50:31,820 --> 00:50:38,940
ダッシュrは全体をflag--
サブディレクトリとそのすべての内容。

1156
00:50:38,940 --> 00:50:39,660
OK。

1157
00:50:39,660 --> 00:50:42,940
あなたので、彼らは赤で記載されているしています
毎回「危険」を考える必要があります

1158
00:50:42,940 --> 00:50:45,000
あなたはそれらのものを参照してください。

1159
00:50:45,000 --> 00:50:45,920
OK。

1160
00:50:45,920 --> 00:50:46,420
大丈夫。

1161
00:50:46,420 --> 00:50:50,090

1162
00:50:50,090 --> 00:50:53,430
>> さて最後に、物事であること
あなたに本当に価値のあることになるだろう、

1163
00:50:53,430 --> 00:50:57,270
いくつかの良いトリックがありますされています
あなたが移動しているように知っています

1164
00:50:57,270 --> 00:50:59,190
このターミナルウィンドウから。

1165
00:50:59,190 --> 00:51:03,590
まず、あなたはで画面をクリアすることができます
ただ明確に入力して、いつでも。

1166
00:51:03,590 --> 00:51:06,310
そして、あなたは見に行っています
私はかなり頻繁にそれを行います。

1167
00:51:06,310 --> 00:51:09,990
また、単に表示することができます
ファイルのテキスト

1168
00:51:09,990 --> 00:51:13,992
より多くし、ファイル名を入力して。

1169
00:51:13,992 --> 00:51:17,200
その後、スクロールバックすることができるでしょうし、
前後だけでスペースキーとそれに

1170
00:51:17,200 --> 00:51:19,010
そして、矢印キーを。

1171
00:51:19,010 --> 00:51:25,450
>> あなたが持っている場合は、私たちは、講義で、今日をしたとして
継続的に実行されているプログラム

1172
00:51:25,450 --> 00:51:29,190
無限ループで、あなた
そのプログラムを停止することができます

1173
00:51:29,190 --> 00:51:35,160
コントロールに入力して実行するから、
すなわち、制御-Cを押しています。

1174
00:51:35,160 --> 00:51:38,360
そして、あなたがしなければならないこと
この複数回。

1175
00:51:38,360 --> 00:51:40,620
コンピュータがはるかにあなたの前に取得します。

1176
00:51:40,620 --> 00:51:43,380
そして、あなたは時々に必要
それをしようとのカップルを与えます

1177
00:51:43,380 --> 00:51:46,280
それは実際に通ってくるだろう前に。

1178
00:51:46,280 --> 00:51:48,760
>> また、にできるようになります
コマンドによるソート

1179
00:51:48,760 --> 00:51:54,230
あなただけのアップキーを使用して入力したこと、
矢印キー、および下矢印キーを押します。

1180
00:51:54,230 --> 00:51:57,560
そして、何の最も有用なのは代わりにあります
長いファイル名を入力するのは、

1181
00:51:57,560 --> 00:52:02,209
あなたがするために使用するタブにできるようになります
いくつかの指示を自動補完。

1182
00:52:02,209 --> 00:52:04,750
今、私たちは実証しようとしています
ちょうど第二のもののすべて。

1183
00:52:04,750 --> 00:52:06,780
だから、あなたは覚えていない場合
彼らは、心配しないでください。

1184
00:52:06,780 --> 00:52:10,780
これらは、あなたがよものです
ピックアップし、私たちは一緒に行くように使用します。

1185
00:52:10,780 --> 00:52:11,470
OK。

1186
00:52:11,470 --> 00:52:18,830
>> だからC--でScratch--と異なり
Cはコンパイル言語です。

1187
00:52:18,830 --> 00:52:23,210
それは我々がソースを取るしようとしていることを意味します
それはあなたが書く文章ですfile--、

1188
00:52:23,210 --> 00:52:26,500
あなたは、書き込みコマンド
printf（）文、ループ、

1189
00:52:26,500 --> 00:52:32,580
私たちが行っているelse--、すべて
そのファイルを取り、それを手にします

1190
00:52:32,580 --> 00:52:34,670
コンパイラと呼ばれるプログラムに。

1191
00:52:34,670 --> 00:52:39,850
>> 次に、コンパイラは、かかります
あなたが書いたそのテキスト

1192
00:52:39,850 --> 00:52:43,270
とに翻訳
バイナリの命令

1193
00:52:43,270 --> 00:52:46,010
お使いのコンピュータがあること
実際に使用することを行きます。

1194
00:52:46,010 --> 00:52:49,700
これは、オブジェクトと呼ばれています
または実行可能ファイル。

1195
00:52:49,700 --> 00:52:55,320
あなたはこのファイルを見ると、あなたが行っています
あなたが書いたコードを表示します。

1196
00:52:55,320 --> 00:52:59,480
あなたはこのファイルを見ると、あなたが行っています
文字のランダムシーケンスを表示するには

1197
00:52:59,480 --> 00:53:01,680
それは全く意味を成さありません。

1198
00:53:01,680 --> 00:53:03,250
これはバイナリであるためです。

1199
00:53:03,250 --> 00:53:05,560
それはあなたが読んでされるのを意図していません。

1200
00:53:05,560 --> 00:53:08,690
>> しかし、いつでもあなたがしたいです
あなたが行っているものを、何かを実行します

1201
00:53:08,690 --> 00:53:13,670
実行すると、このオブジェクト・ファイルです。

1202
00:53:13,670 --> 00:53:19,110
だから我々は、これらを使用するとき
ファイルは、我々はC言語でファイルを記述します

1203
00:53:19,110 --> 00:53:23,400
それから、使用して、それをコンパイルします
起動するmakeに似たコマンド

1204
00:53:23,400 --> 00:53:27,070
C言語のコンパイラ打ち鳴らします。

1205
00:53:27,070 --> 00:53:31,530
そして、それは、オブジェクトが生成されます
アウトのように、ファイル、またはこの場合には、

1206
00:53:31,530 --> 00:53:36,580
名前、私が置かれている私のファイル、。

1207
00:53:36,580 --> 00:53:37,780
大丈夫。

1208
00:53:37,780 --> 00:53:39,790
>> それでは、実際にこれを試してみましょう。

1209
00:53:39,790 --> 00:53:42,850
だから私は例を思い付きました
私が試してみたかったものの。

1210
00:53:42,850 --> 00:53:47,380
そして、物事のこと
私は魅了アニメーションです。

1211
00:53:47,380 --> 00:53:51,010
だから我々は実行しようとしています
アニメーションの少し

1212
00:53:51,010 --> 00:53:53,760
ただ、ASCII文字を使用して。

1213
00:53:53,760 --> 00:53:56,470
キャラクターは、私たちは今、簡単に印刷することができます。

1214
00:53:56,470 --> 00:54:00,890
>> だからここに私の最高の試みであり、
あなたのために作成で

1215
00:54:00,890 --> 00:54:07,005
バニーのアニメーション
背の高い草を介して実行されています。

1216
00:54:07,005 --> 00:54:07,505
そこに彼はあります。

1217
00:54:07,505 --> 00:54:10,150

1218
00:54:10,150 --> 00:54:10,670
OK。

1219
00:54:10,670 --> 00:54:14,050
そこで彼は、まだ実行していないが、彼はです
背の高い草の中にそこに立って。

1220
00:54:14,050 --> 00:54:17,810
>> 今私はアニメーターであれば、
古い学校で

1221
00:54:17,810 --> 00:54:20,860
アニメーションのバージョン、どのような私
私が生成することになるだろうさ

1222
00:54:20,860 --> 00:54:23,640
草の中に、このウサギの絵。

1223
00:54:23,640 --> 00:54:25,390
そして、私が生成することになります
別のpicture--

1224
00:54:25,390 --> 00:54:30,600
彼らがいることをcell--何と呼ばれる別の
バニーはわずかしか移動していました。

1225
00:54:30,600 --> 00:54:34,870
そして、第1持っていました
バニーは少しさらに移動。

1226
00:54:34,870 --> 00:54:40,610
>> そして、私は全体を生成します
これらの細胞の配列です。

1227
00:54:40,610 --> 00:54:44,220
いくつかの場所のバニーは終わりました
左側へ。

1228
00:54:44,220 --> 00:54:47,050
そして、ゆっくりと一つ移動
中央に向かって一つ。

1229
00:54:47,050 --> 00:54:51,120
そして、途中から
右にオーバー。

1230
00:54:51,120 --> 00:54:55,760
そして、私は本当に、次いで場合
幸運、私はそれを一緒に置くことができます

1231
00:54:55,760 --> 00:54:57,970
そして、私はそれらをアニメーション化できました。

1232
00:54:57,970 --> 00:55:00,370
そして、私のバニーがあります
草を走ります。

1233
00:55:00,370 --> 00:55:02,310
>> それは私の偉大なパワーポイントです
日のトリック。

1234
00:55:02,310 --> 00:55:02,809
OK。

1235
00:55:02,809 --> 00:55:04,760
だから、これは最高です。

1236
00:55:04,760 --> 00:55:05,260
OK。

1237
00:55:05,260 --> 00:55:08,455
だから、ここ、ここでもう一回は、私たちです
草を走るバニー。

1238
00:55:08,455 --> 00:55:09,217
>> スピーカ19：再び。

1239
00:55:09,217 --> 00:55:11,050
BRIAN SCASSELLATI：One
より多くの時間、すべての権利。

1240
00:55:11,050 --> 00:55:11,940
あなたのバニーがあります。

1241
00:55:11,940 --> 00:55:12,940
OK。

1242
00:55:12,940 --> 00:55:15,470
>> だから、今日私たちが行っています
行うために、我々はつもりです

1243
00:55:15,470 --> 00:55:21,110
プロセスを自動化しようとします
これらの細胞を産生します。

1244
00:55:21,110 --> 00:55:24,135
私たちはかなりのポイントに取得することはありません
それらすべてを一緒に置くことができること。

1245
00:55:24,135 --> 00:55:28,900
しかし、私たちは自動化しようとするつもりです
このシーケンスを生成する方法。

1246
00:55:28,900 --> 00:55:32,900
>> そして、これは何の多くであります
アニメーション今日のようなものです。

1247
00:55:32,900 --> 00:55:36,690
つまり、あなたは必ずしも物事をしません
手ですべてを描画することもできます。

1248
00:55:36,690 --> 00:55:40,610
私たちは自動化するためにコンピュータを使用します
そのプロセスの一部。

1249
00:55:40,610 --> 00:55:41,110
OK。

1250
00:55:41,110 --> 00:55:47,720
>> だから、私は切り替えてみましょう
今私たちのCS50のIDEに。

1251
00:55:47,720 --> 00:55:54,260
そして、私はus--とletのために作成されています
私はここで私はしました少しbit--をズームイン

1252
00:55:54,260 --> 00:55:58,420
出発点は、私たちのために作成しました。

1253
00:55:58,420 --> 00:56:03,830
>> 私たちが座ってお聞きするたびに
ダウンし、コードの一部を記述し、

1254
00:56:03,830 --> 00:56:09,250
私たちは本当にすることを求めています
我々は問題を解決するために求めているされています。

1255
00:56:09,250 --> 00:56:11,810
そして、方法は、あなたがすべき
そのことについて考えます

1256
00:56:11,810 --> 00:56:17,900
一部で開始することです
そのソリューションの簡単な一部。

1257
00:56:17,900 --> 00:56:21,730
そして、その部分から構築します。

1258
00:56:21,730 --> 00:56:23,400
そしてそれは我々が今日やろうとしているものです。

1259
00:56:23,400 --> 00:56:27,570
>> そうではなく、に一斉にしよう
コー​​ドの全体の束を書きます

1260
00:56:27,570 --> 00:56:30,770
それらを製造するつもり
10アニメーション細胞

1261
00:56:30,770 --> 00:56:35,506
我々は、代わりに開始するつもりです
働く一枚で。

1262
00:56:35,506 --> 00:56:37,380
そして、我々が構築します
その周りに少し

1263
00:56:37,380 --> 00:56:39,740
もう少しもう少し。

1264
00:56:39,740 --> 00:56:42,550
>> 今の良いところ
問題をこのように解決

1265
00:56:42,550 --> 00:56:46,716
それはあなたが開始することを可能にするということです
いつもあなたが知っているものと

1266
00:56:46,716 --> 00:56:51,130
動作し、1緩やかな変化をご紹介します。

1267
00:56:51,130 --> 00:56:54,090
そして、それは素晴らしい方法です
コー​​ディングする方法を学ぶために、

1268
00:56:54,090 --> 00:56:58,590
あなたが作るたび理由
変更は、あなたはそれが持っているどのような影響を参照してください。

1269
00:56:58,590 --> 00:56:59,540
OK。

1270
00:56:59,540 --> 00:57:01,450
>> だからここに私たちの出発点です。

1271
00:57:01,450 --> 00:57:01,950
OK。

1272
00:57:01,950 --> 00:57:08,030
そこで、私のファイルの先頭に、
私はハッシュ＃インクルードstdio.hのをしました。

1273
00:57:08,030 --> 00:57:12,560
私は得ることができるようにそれはです
printf（）関数が動作します。

1274
00:57:12,560 --> 00:57:15,240
>> 私は、私は私の主な機能を持っています。

1275
00:57:15,240 --> 00:57:18,760
そして、これはまだ少し見えます
難解なまたはあなたのいくつかのあいまいな。

1276
00:57:18,760 --> 00:57:20,010
それで大丈夫です。

1277
00:57:20,010 --> 00:57:23,190
ことは、それが言うすべてであります
主な機能は、取り

1278
00:57:23,190 --> 00:57:27,830
無arguments--空洞手段
C.そして、それには何もありません

1279
00:57:27,830 --> 00:57:29,940
慣例による返品整数。

1280
00:57:29,940 --> 00:57:33,290
メインは常に整数を返し、
物事を言って、通常のコード

1281
00:57:33,290 --> 00:57:35,071
うまくいったかうまく行きませんでした。

1282
00:57:35,071 --> 00:57:35,570
OK。

1283
00:57:35,570 --> 00:57:39,110
しかし、主はそれを有していなければなりません
今、私たちのために形成します。

1284
00:57:39,110 --> 00:57:42,080
>> 私は、3行のコードを入れてきました。

1285
00:57:42,080 --> 00:57:46,760
そして、それぞれのラインと一緒に
コー​​ドは、私がコメントを入れています。

1286
00:57:46,760 --> 00:57:51,340
今ではものの一つに
私たちは、あなたが行うことを主張します

1287
00:57:51,340 --> 00:57:55,320
それが重要なのです
プログラミングの練習、

1288
00:57:55,320 --> 00:57:57,800
常にあなたのコードをコメントすることです。

1289
00:57:57,800 --> 00:58:02,550
常にに書き留めます
英語コメント何か

1290
00:58:02,550 --> 00:58:06,740
あなたが考えること
コー​​ドが行うことになっています。

1291
00:58:06,740 --> 00:58:11,360
あなたが戻ってくるときに、後でその方法
、それは、あなたはそれを見ることができ、あなたが言うことができます

1292
00:58:11,360 --> 00:58:13,800
ああ、私は何であったか覚えています
これを行うにしようとしています。

1293
00:58:13,800 --> 00:58:17,590
またはTAはあなたと一緒に座るとき
営業時間であなたを助けるためにしようと、

1294
00:58:17,590 --> 00:58:20,890
彼らはこれを見て行くことができ、私
あなたがやろうとしたものを参照してください、

1295
00:58:20,890 --> 00:58:25,630
その代わりに、これは
何が本当に起こっています。

1296
00:58:25,630 --> 00:58:26,130
OK。

1297
00:58:26,130 --> 00:58:30,300
>> だから私は、私のコードは3つの部分を持っています
私はすべてのプリントの最初に行きますよ

1298
00:58:30,300 --> 00:58:33,110
開始時にいくつかのドットアウト。

1299
00:58:33,110 --> 00:58:37,480
私はその後、私のを印刷します
極端に派手なバニー。

1300
00:58:37,480 --> 00:58:40,600
そして、最後にドットのいくつかのビット。

1301
00:58:40,600 --> 00:58:45,220
>> そして、これら三つのprint文はすべき
この時点で、あなたに見覚え。

1302
00:58:45,220 --> 00:58:47,350
私がやっているすべてのこと
それらの各々は、私はあります

1303
00:58:47,350 --> 00:58:49,780
一連の文字を印刷します。

1304
00:58:49,780 --> 00:58:51,370
関連する一切の変数がありません。

1305
00:58:51,370 --> 00:58:54,320
すべてがちょうど平らです。

1306
00:58:54,320 --> 00:58:55,270
OK。

1307
00:58:55,270 --> 00:59:07,340
>> だから、私はterminal--に今下る場合
私はこのバックを得ることができるかどうかを見てみましょうout--

1308
00:59:07,340 --> 00:59:09,370
そして、私は再びクリアタイプするつもりです。

1309
00:59:09,370 --> 00:59:12,507
>> スピーカ20：我々が使用しています
二重スラッシュがコメントをするには？

1310
00:59:12,507 --> 00:59:14,340
BRIAN SCASSELLATI：することができます
double--はい]を使用しています。

1311
00:59:14,340 --> 00:59:16,920
に複数の方法があります
C. Oneのコメントを残します

1312
00:59:16,920 --> 00:59:19,440
方法は、ダブルスラッシュを使用することです。

1313
00:59:19,440 --> 00:59:24,910
他には、スラッシュとスターを使用することです
して、スターとスラッシュで閉じます。

1314
00:59:24,910 --> 00:59:26,110
大丈夫。

1315
00:59:26,110 --> 00:59:28,950
>> まず第一に、私はするつもりです
ここの周りのナビゲーションを開始します。

1316
00:59:28,950 --> 00:59:35,350
だから私は私のホームディレクトリに移動した場合、
私は、そこにディレクトリを変更しました

1317
00:59:35,350 --> 00:59:40,230
私が見て、何を見に行きますよ
そのディレクトリに、lsコマンドは、アウトリスト。

1318
00:59:40,230 --> 00:59:43,230
私は私がしたことを見に行きますよ
2つのサブディレクトリを得ました。

1319
00:59:43,230 --> 00:59:47,910
それでは、この少し大きくしてみましょう
ここで、我々はすべてそれを見ることができるように。

1320
00:59:47,910 --> 00:59:50,610
>> 私は私がしたことを見ることができます
2つのサブディレクトリを得ました。

1321
00:59:50,610 --> 00:59:53,510
私は、ディレクトリを変更します
ワークスペースに移動します。

1322
00:59:53,510 --> 00:59:58,380
そして、私はタイプするつもりです
その一部は、その後、ちょうどタブを押してください。

1323
00:59:58,380 --> 01:00:01,520
そして、それは私のために残りの部分を完了します。

1324
01:00:01,520 --> 01:00:03,370
ファンシー。

1325
01:00:03,370 --> 01:00:04,960
>> 私が見て、ワークスペースに表示されます。

1326
01:00:04,960 --> 01:00:08,431
そして今、私が働いています
スーパーセクションに

1327
01:00:08,431 --> 01:00:09,680
私たちは今教えていること。

1328
01:00:09,680 --> 01:00:10,971
だから私は、そのディレクトリに移動します。

1329
01:00:10,971 --> 01:00:14,770

1330
01:00:14,770 --> 01:00:15,970
そして最後に、見て、参照してください。

1331
01:00:15,970 --> 01:00:18,480
そして、私はそのファイルbunny.cを持っています。

1332
01:00:18,480 --> 01:00:20,980
>> すべての権利ので、より多くのかつて私が明らかにしましょう​​。

1333
01:00:20,980 --> 01:00:24,370
そして、私は再び私はnow--するつもりです
まだそのディレクトリでの滞在

1334
01:00:24,370 --> 01:00:27,540
そしてそれは私がにいる私に言っています
そのスーパーセクションディレクトリ。

1335
01:00:27,540 --> 01:00:30,690
私は先に行くつもりだと
私のプログラムのバニーを作ります。

1336
01:00:30,690 --> 01:00:33,730

1337
01:00:33,730 --> 01:00:38,810
そして、そのコマンドは、バニーを行い、
少し奇妙鳴っている間、

1338
01:00:38,810 --> 01:00:42,960
また、打ち鳴らすコンパイラを起動します。

1339
01:00:42,960 --> 01:00:46,470
>> そして、それはのために生産ます
私です出力

1340
01:00:46,470 --> 01:00:52,130
実行funny-- AN
実行可​​能ファイルがバニーと呼ばれます。

1341
01:00:52,130 --> 01:00:52,700
OK。

1342
01:00:52,700 --> 01:00:56,700
私は、することができ、このサウンド
さらに悪いことに、ウサギを実行します。

1343
01:00:56,700 --> 01:00:59,360

1344
01:00:59,360 --> 01:01:00,680
OK。

1345
01:01:00,680 --> 01:01:03,150
そして、のは、それが何をするか見てみましょう。

1346
01:01:03,150 --> 01:01:04,527
OK。

1347
01:01:04,527 --> 01:01:06,360
それは少しです
何私は期待していました。

1348
01:01:06,360 --> 01:01:11,290
私はそこに私のウサギの絵を持っています、
私は種類のそれ自体でそれをすべてを望んでいました。

1349
01:01:11,290 --> 01:01:13,186
私は何を欠場しましたか？

1350
01:01:13,186 --> 01:01:14,478
>> スピーカ21：LスラッシュまたはNを大幅に削減。

1351
01:01:14,478 --> 01:01:15,602
BRIAN SCASSELLATI：スラッシュnを。

1352
01:01:15,602 --> 01:01:16,580
OK。

1353
01:01:16,580 --> 01:01:18,800
それでは、ここに戻ってみましょう。

1354
01:01:18,800 --> 01:01:20,330
そして、私はそれから抜け出すだろう。

1355
01:01:20,330 --> 01:01:23,320
そして、私はこの1つに戻ります。

1356
01:01:23,320 --> 01:01:27,720
そして今度は、見てみましょう
ここで私の主な機能から。

1357
01:01:27,720 --> 01:01:29,280
>> だから私は何をすべきでしょうか？

1358
01:01:29,280 --> 01:01:30,465
私は、行を終了します。

1359
01:01:30,465 --> 01:01:34,020

1360
01:01:34,020 --> 01:01:35,800
だから私はコメントに入れましょう。

1361
01:01:35,800 --> 01:01:38,430
私は）（のprintfに入れましょう。

1362
01:01:38,430 --> 01:01:41,350
そして、私は中に入れるために何がありますか？

1363
01:01:41,350 --> 01:01:41,890
/ nです。

1364
01:01:41,890 --> 01:01:43,480
OK。

1365
01:01:43,480 --> 01:01:46,040
私はそれを終了するには何がありますか？

1366
01:01:46,040 --> 01:01:47,100
セミコロン。

1367
01:01:47,100 --> 01:01:48,730
大丈夫。

1368
01:01:48,730 --> 01:01:52,880
>> 今、の一つが本当に
重要なことは確認しています

1369
01:01:52,880 --> 01:01:56,720
変更を加えるたびに
あなたのコードでは、あなたはそれを保存すること。

1370
01:01:56,720 --> 01:02:01,380
あなたのコードを保存していない場合、あなたはしています
そこに小さな星のアップに気づくに行きます。

1371
01:02:01,380 --> 01:02:03,420
そして、その星があなたを言います
このコードを保存していません。

1372
01:02:03,420 --> 01:02:07,790
>> 私は今、それをコンパイルする場合、そうではありません
これらの変更のいずれかを反映するために行きます、

1373
01:02:07,790 --> 01:02:11,680
コンパイラは、ファイルを見ているので
それは、ディスク、では​​ありませんファイルにです

1374
01:02:11,680 --> 01:02:13,790
あなたのエディタで開きます。

1375
01:02:13,790 --> 01:02:14,290
大丈夫。

1376
01:02:14,290 --> 01:02:20,830
>> それでは、それを保存してみましょうし、我々は行きますよ
右のダウンここで、戻って出てきます。

1377
01:02:20,830 --> 01:02:24,670
私のターミナルに降りてきます。

1378
01:02:24,670 --> 01:02:27,193
そしてのは、再びスペースをクリアしてみましょう。

1379
01:02:27,193 --> 01:02:30,690

1380
01:02:30,690 --> 01:02:35,760
>> そして、我々は先に行くと、もう一つのことができます
時間は私たちのウサギのプログラムを作ります。

1381
01:02:35,760 --> 01:02:40,180
そしてバニーを実行します。

1382
01:02:40,180 --> 01:02:42,500
それはどちらか動作しませんでした。

1383
01:02:42,500 --> 01:02:43,950
間違ったスラッシュ。

1384
01:02:43,950 --> 01:02:52,280
あなたは私が持っているものを見ればそう、私は置きます
/ nはそこに、私は間違っているスラッシュを持っていました。

1385
01:02:52,280 --> 01:02:56,190
>> すべてのコンピュータ
ない非常に明示的です。

1386
01:02:56,190 --> 01:02:57,230
OK？

1387
01:02:57,230 --> 01:03:01,250
句読点の一つの小さなミス、および
突然あなたが欲しいものを得ることはありません。

1388
01:03:01,250 --> 01:03:01,750
大丈夫。

1389
01:03:01,750 --> 01:03:03,740
それでは、再びピンを見るにはズームインしてみましょう。

1390
01:03:03,740 --> 01:03:04,410
我々は戻って行きますよ。

1391
01:03:04,410 --> 01:03:07,930
まあ、非常に迅速な修理を行います。

1392
01:03:07,930 --> 01:03:09,270
私たちは右にスラッシュを入れます。

1393
01:03:09,270 --> 01:03:10,570
我々はそれを保存します。

1394
01:03:10,570 --> 01:03:13,410
私たちは、ピンを見るにはズームインします。

1395
01:03:13,410 --> 01:03:16,730
>> 何らかの理由で、それはありません
幸せであること、しかし、のは先に行ってみましょう

1396
01:03:16,730 --> 01:03:19,850
私たちはここに戻ってターミナルに行きますよ。

1397
01:03:19,850 --> 01:03:22,940
それをクリアします。

1398
01:03:22,940 --> 01:03:24,880
私たちはズームインます。

1399
01:03:24,880 --> 01:03:28,410
そして、もう一つのより多くの時間、私たちはウサギを作ってあげます。

1400
01:03:28,410 --> 01:03:32,360
そして今、確かに、それは動作します。

1401
01:03:32,360 --> 01:03:33,240
万歳。

1402
01:03:33,240 --> 01:03:34,300
OK。

1403
01:03:34,300 --> 01:03:39,580
>> それでは、これを行うために試してみましょう
もう少し一般的。

1404
01:03:39,580 --> 01:03:46,750
ちょうど場合の代わりに見てみましょう
一つの特定のフレームを印刷し、

1405
01:03:46,750 --> 01:03:49,610
我々はこれを行うことができるかどうかを見てみましょう
我々は、すべての10を得ることができるように、

1406
01:03:49,610 --> 01:03:52,960
これらのアニメーションのフレーム
我々が持っていると思っています。

1407
01:03:52,960 --> 01:03:56,550
そこで再び、のみましょう
この時点でステップ。

1408
01:03:56,550 --> 01:03:59,900
>> まずは、それを一般化してみましょう、ではありません
私はすべてのフレームを行うことを、

1409
01:03:59,900 --> 01:04:03,990
しかし、私はいずれかを実行します
私がお勧めしますフレーム。

1410
01:04:03,990 --> 01:04:05,920
だから、違いは何ですか
フレーム間の？

1411
01:04:05,920 --> 01:04:07,377
バニーは同じですか？

1412
01:04:07,377 --> 01:04:07,960
聴衆：はい。

1413
01:04:07,960 --> 01:04:08,390
BRIAN SCASSELLATI：うん。

1414
01:04:08,390 --> 01:04:09,370
違いは何？

1415
01:04:09,370 --> 01:04:10,246
>> 聴衆：位置。

1416
01:04:10,246 --> 01:04:11,870
BRIAN SCASSELLATI：その位置は、右？

1417
01:04:11,870 --> 01:04:15,590
そして、どのように私は、その位置を制御するには？

1418
01:04:15,590 --> 01:04:17,340
どのように多くのドット私は
先頭に置きます

1419
01:04:17,340 --> 01:04:19,048
そして、私はどのように多くのドット
最後に置きます。

1420
01:04:19,048 --> 01:04:21,970
だから私は、5を持っていました
最初と最後の5。

1421
01:04:21,970 --> 01:04:28,320
>> それでは、forループでその5を交換しましょう​​。

1422
01:04:28,320 --> 01:04:29,380
OK。

1423
01:04:29,380 --> 01:04:32,330
そして、私はのために作成するつもりです
ループは、今では言うために起こっています、

1424
01:04:32,330 --> 01:04:37,800
私はいくつかの番号を印刷するつもりです
先頭のドットの。

1425
01:04:37,800 --> 01:04:39,600
私は、変数を使用するつもりです。

1426
01:04:39,600 --> 01:04:44,150
どのように私が、のは言ってみましょう
私のループでカウンター。

1427
01:04:44,150 --> 01:04:47,200
そして、私はトップをそれを宣言するつもりです。

1428
01:04:47,200 --> 01:04:49,360
>> そして、forループで
私は3つのことを行う必要があります。

1429
01:04:49,360 --> 01:04:52,340
私がする必要がある最初の事
私は私を初期化する必要があります。

1430
01:04:52,340 --> 01:04:56,570
私は何を初期化する必要があります
それがあることをスタートさせるには？

1431
01:04:56,570 --> 01:04:57,160
0。

1432
01:04:57,160 --> 01:04:58,310
OK。

1433
01:04:58,310 --> 01:05:00,950
>> それから私は何、言う必要があります
終了条件？

1434
01:05:00,950 --> 01:05:03,020
とき、私は停止する必要がありますか？

1435
01:05:03,020 --> 01:05:05,983
さてどのように多くのドットがあなたを行います
これに印刷したいですか？

1436
01:05:05,983 --> 01:05:06,921
>> 聴衆：5。

1437
01:05:06,921 --> 01:05:08,170
BRIAN SCASSELLATI：5再び？

1438
01:05:08,170 --> 01:05:10,650
のは、何かをする方法についてましょう
異なる、我々は5をしました。

1439
01:05:10,650 --> 01:05:12,584
のは、それが違うことをお見せしましょう​​。

1440
01:05:12,584 --> 01:05:13,250
スピーカ22：二つ。

1441
01:05:13,250 --> 01:05:13,580
BRIAN SCASSELLATI：二つ。

1442
01:05:13,580 --> 01:05:14,080
OK。

1443
01:05:14,080 --> 01:05:17,760
だから私は2つのドットが必要な場合は、
私はここで何を置く必要がありますか？

1444
01:05:17,760 --> 01:05:19,140
>> 聴衆：三。

1445
01:05:19,140 --> 01:05:20,530
>> BRIAN SCASSELLATI：三。

1446
01:05:20,530 --> 01:05:21,400
OK。

1447
01:05:21,400 --> 01:05:24,220
何回ということです
経由行くつもり？

1448
01:05:24,220 --> 01:05:28,469
それは通過するだろう
三回、0、1、2、右？

1449
01:05:28,469 --> 01:05:30,010
すべての権利、の2にまで戻ってみましょう。

1450
01:05:30,010 --> 01:05:31,570
今、私たちは2つのドットを得るでしょう。

1451
01:05:31,570 --> 01:05:35,800
そして、私はそれぞれに何をすべきかをしたいです
私は、ループを通過する時間？

1452
01:05:35,800 --> 01:05:38,657
変更するには何を持っています
私が通過するたびに？

1453
01:05:38,657 --> 01:05:39,850
>> スピーカ23：ドットを追加します。

1454
01:05:39,850 --> 01:05:41,020
>> BRIAN SCASSELLATI：私は続ける必要があります。

1455
01:05:41,020 --> 01:05:41,978
私は、ドットを追加するつもりです。

1456
01:05:41,978 --> 01:05:45,310
私はドットを印刷するつもりです、
ループを通るたびに。

1457
01:05:45,310 --> 01:05:49,990
しかし、どのように私はどのようにの追跡しています
何回も私はループを進めてきましたか？

1458
01:05:49,990 --> 01:05:53,260
私は、私を使用しています
変数、そのカウンタ。

1459
01:05:53,260 --> 01:05:57,110
>> だからを通じてたびに、私は行きますよ
1、カウンタをインクリメントします。

1460
01:05:57,110 --> 01:06:00,670
今、それがために同じです
私は私が言うように=私は1 +。

1461
01:06:00,670 --> 01:06:01,210
それで大丈夫です。

1462
01:06:01,210 --> 01:06:04,653
私が好きなthat--私はそれを行うことができます
速記ので、私は私が++と言うつもりです。

1463
01:06:04,653 --> 01:06:07,190

1464
01:06:07,190 --> 01:06:08,370
OK。

1465
01:06:08,370 --> 01:06:10,680
>> のは、同じことをやってみましょう
ここで一番下にダウン。

1466
01:06:10,680 --> 01:06:11,846
私だけは、種類のいずれかを行いました。

1467
01:06:11,846 --> 01:06:13,990
私は君たちようにするつもりです
完全にこのいずれかの操作を行います。

1468
01:06:13,990 --> 01:06:14,260
大丈夫。

1469
01:06:14,260 --> 01:06:15,426
>> だから私はここで何を書くべきですか？

1470
01:06:15,426 --> 01:06:17,170
ここでは、ループのための私です。

1471
01:06:17,170 --> 01:06:23,162
私は（のprintfをするつもりです）、私は行きますよ
私は1つのドットを印刷するようにそれを作るために

1472
01:06:23,162 --> 01:06:25,740
その底に。

1473
01:06:25,740 --> 01:06:27,740
>> 私は何を書くべき
今このforループの内側？

1474
01:06:27,740 --> 01:06:30,897

1475
01:06:30,897 --> 01:06:33,948
まず、まあ何
私は、変数を使用する必要がありますか？

1476
01:06:33,948 --> 01:06:35,430
>> スピーカ24：J。

1477
01:06:35,430 --> 01:06:36,880
>> BRIAN SCASSELLATI：私はJを使用することができます。

1478
01:06:36,880 --> 01:06:38,040
私は同じものを使用することはできますか？

1479
01:06:38,040 --> 01:06:39,961
私は、私は再び使用することはできますか？

1480
01:06:39,961 --> 01:06:40,460
うん。

1481
01:06:40,460 --> 01:06:45,531
それは、大丈夫であるため、
私がここに使用していること、

1482
01:06:45,531 --> 01:06:47,780
私は再びときにそれらを必要としません
私はこの点に取り掛かります。

1483
01:06:47,780 --> 01:06:52,240

1484
01:06:52,240 --> 01:06:53,790
>> だから私は、私は何を初期化する必要がありますか？

1485
01:06:53,790 --> 01:06:56,675

1486
01:06:56,675 --> 01:06:57,300
スピーカ25：10。

1487
01:06:57,300 --> 01:06:58,567
BRIAN SCASSELLATI：0。

1488
01:06:58,567 --> 01:06:59,400
私は何を確認する必要がありますか？

1489
01:06:59,400 --> 01:07:02,960
私は最後になりましたどのように多くのドットが必要ですか
私は最初に2つのドットを持っている場合はどうなりますか？

1490
01:07:02,960 --> 01:07:05,820

1491
01:07:05,820 --> 01:07:09,165
私は最後に8が必要なので、どのような
私は私があまりthan--、チェックする必要があります

1492
01:07:09,165 --> 01:07:12,645
>> 聴衆：7個、8個、9。

1493
01:07:12,645 --> 01:07:14,020
BRIAN SCASSELLATI：私は7を聞きました。

1494
01:07:14,020 --> 01:07:14,810
私は8を聞きました。

1495
01:07:14,810 --> 01:07:15,970
そして、私は9を聞きました。

1496
01:07:15,970 --> 01:07:16,470
OK。

1497
01:07:16,470 --> 01:07:19,540
だから我々は、すべての権利にいます
ball--ジェイソンは10言います。

1498
01:07:19,540 --> 01:07:21,550
OK。

1499
01:07:21,550 --> 01:07:25,920
>> 私はのために2つのドットを必要に応じて
最初、何を行います

1500
01:07:25,920 --> 01:07:30,170
I--と私はのための8ドットが必要
最後選ぶ - 私は、上記の二つを設置

1501
01:07:30,170 --> 01:07:31,743
私は、以下のものを下に置く必要がありますか？

1502
01:07:31,743 --> 01:07:32,570
>> 聴衆：8。

1503
01:07:32,570 --> 01:07:33,611
>> BRIAN SCASSELLATI：8。

1504
01:07:33,611 --> 01:07:35,695
それがために起こっているので
7を通じてゼロをカウントします。

1505
01:07:35,695 --> 01:07:38,490
そして、それはループを8回です。

1506
01:07:38,490 --> 01:07:38,990
OK。

1507
01:07:38,990 --> 01:07:41,774
そして、私は最後に何をするかがありますか？

1508
01:07:41,774 --> 01:07:42,670
>> 聴衆：私は++。

1509
01:07:42,670 --> 01:07:44,400
>> BRIAN SCASSELLATI：私は++します。

1510
01:07:44,400 --> 01:07:45,440
大丈夫。

1511
01:07:45,440 --> 01:07:48,260
だから、そこにかなり良い見ています。

1512
01:07:48,260 --> 01:07:50,620
のは、それを試してみましょうとのは、それが何をするか見てみましょう。

1513
01:07:50,620 --> 01:07:51,450
OK。

1514
01:07:51,450 --> 01:07:53,770
だから我々はそれを保存しようとしています。

1515
01:07:53,770 --> 01:07:54,940
ニースと保存されました。

1516
01:07:54,940 --> 01:07:56,910
>> 私たちは、ズームアウトします。

1517
01:07:56,910 --> 01:07:58,220
我々は、端末にここにしようとするでしょう。

1518
01:07:58,220 --> 01:08:01,440

1519
01:08:01,440 --> 01:08:02,970
私たちはズームインます。

1520
01:08:02,970 --> 01:08:05,416
おっとっと。

1521
01:08:05,416 --> 01:08:09,990
私たちよ、もう一回、
私たちのウサギのプログラムを作ります。

1522
01:08:09,990 --> 01:08:14,460
そして、先に行くとウサギを実行します。

1523
01:08:14,460 --> 01:08:15,980
そして、そこにはあります。

1524
01:08:15,980 --> 01:08:17,710
>> だから、私たちのバニーがあります。

1525
01:08:17,710 --> 01:08:25,130
それは初めに2つのドットを有する場合
そして最後に8ドットアウト。

1526
01:08:25,130 --> 01:08:27,540
私と一緒にまだ誰？

1527
01:08:27,540 --> 01:08:28,770
OK。

1528
01:08:28,770 --> 01:08:29,580
>> だから我々はそれを構築しました。

1529
01:08:29,580 --> 01:08:33,000
私たちは、1バニーを構築し、
一つの特定のフレーム。

1530
01:08:33,000 --> 01:08:36,229
今、私たちはすることができました
構築することを一般化

1531
01:08:36,229 --> 01:08:38,390
フレームのより、異なる種類。

1532
01:08:38,390 --> 01:08:42,399
>> それでは、先に行くと、持ってみましょう
それだけではなく、1つのフレームを生成します

1533
01:08:42,399 --> 01:08:46,290
しかしそれでは、10を生成させます
我々ゆっくりとフレーム、

1534
01:08:46,290 --> 01:08:50,569
バニーは、すべての移動作ります
フィールド全体の方法。

1535
01:08:50,569 --> 01:08:51,430
大丈夫。

1536
01:08:51,430 --> 01:08:53,660
>> それでは、戻りましょう。

1537
01:08:53,660 --> 01:08:54,839
そして、我々は今、試してみます。

1538
01:08:54,839 --> 01:09:00,680

1539
01:09:00,680 --> 01:09:02,830
だから何私は本当にここで変更する必要がありますか？

1540
01:09:02,830 --> 01:09:06,139

1541
01:09:06,139 --> 01:09:07,180
私は何を変更する必要がありますか？

1542
01:09:07,180 --> 01:09:10,638
>> スピーカ26：あなたが最初に必要
最大ドット数を変更します

1543
01:09:10,638 --> 01:09:11,626
初めに。

1544
01:09:11,626 --> 01:09:16,850
私たちは10ドットをやっている場合ので、
それはスケールまでに必要になるだろう。

1545
01:09:16,850 --> 01:09:17,850
BRIAN SCASSELLATI：うん。

1546
01:09:17,850 --> 01:09:23,760
だから今、私はそれは一種のハードワイヤードています
常に先頭に2つのドットを行うには

1547
01:09:23,760 --> 01:09:27,890
そしていつも最後に8ドットを行います。

1548
01:09:27,890 --> 01:09:30,660
>> 私は右、別のループを構築したいですか？

1549
01:09:30,660 --> 01:09:33,290
私はしたくないので
ちょうど1ウサギの絵を構築し、

1550
01:09:33,290 --> 01:09:37,140
私は、10ウサギの絵を構築したいです。

1551
01:09:37,140 --> 01:09:41,500
だから私は別のループを構築する必要があり、
私はそのループを通過するように、

1552
01:09:41,500 --> 01:09:44,660
私はどのように多くの変更したいです
私が最初に印刷ドット

1553
01:09:44,660 --> 01:09:50,529
私は、最後にどのように多くのドットを印刷します
ループを通過する周期に基づいて

1554
01:09:50,529 --> 01:09:52,270
私の出番です

1555
01:09:52,270 --> 01:09:52,770
大丈夫。

1556
01:09:52,770 --> 01:09:54,430
>> それでは、別のカウンターを取得してみましょう。

1557
01:09:54,430 --> 01:09:58,142
誰かが前にJと述べています、
私たちは他のJを行います。

1558
01:09:58,142 --> 01:10:00,100
そして今、我々はするつもりです
ループのために別のものを構築します。

1559
01:10:00,100 --> 01:10:02,650

1560
01:10:02,650 --> 01:10:06,200
>> 何がそのループ内部に入りますか？

1561
01:10:06,200 --> 01:10:09,060
このようなものは、行かなければなりません
ループ内で、右？

1562
01:10:09,060 --> 01:10:11,190
バニーは持っています
ループ内で行きますか？

1563
01:10:11,190 --> 01:10:13,390
私はバニーが必要です
これらの10フレームの各？

1564
01:10:13,390 --> 01:10:14,099
>> 聴衆：うん。

1565
01:10:14,099 --> 01:10:15,098
BRIAN SCASSELLATI：うん。

1566
01:10:15,098 --> 01:10:17,250
私はそれぞれにバニーをしたいです
10フレームの、右？

1567
01:10:17,250 --> 01:10:20,531
どのようにドットについて
最後に、私はそれが必要なのでしょうか？

1568
01:10:20,531 --> 01:10:21,030
OK。

1569
01:10:21,030 --> 01:10:22,550
>> だから私はそれらのすべてをインデントするつもりです。

1570
01:10:22,550 --> 01:10:25,110
私はすべてを強調表示するつもりです
これは、私はタブをヒットするつもりです。

1571
01:10:25,110 --> 01:10:28,590
そして、それはすべての上にそれらをプッシュするつもりです
少し、それは私のために簡単ですように

1572
01:10:28,590 --> 01:10:32,010
ループの中で何を確認します。

1573
01:10:32,010 --> 01:10:33,710
そして、私はそれを終了します。

1574
01:10:33,710 --> 01:10:35,850
それでは、としましょう​​。

1575
01:10:35,850 --> 01:10:36,430
OK？

1576
01:10:36,430 --> 01:10:39,230
>> さて、このループ内のその
私はbuilding--おっとだけど、

1577
01:10:39,230 --> 01:10:43,810
あなたがsee--できることを確認
私は、カウンタjを持っています。

1578
01:10:43,810 --> 01:10:45,630
私は0でそれを開始します。

1579
01:10:45,630 --> 01:10:47,829
私は何回したいです
このループを通過するには？

1580
01:10:47,829 --> 01:10:48,620
聴衆：10回。

1581
01:10:48,620 --> 01:10:49,786
BRIAN SCASSELLATI：10回。

1582
01:10:49,786 --> 01:10:51,402
だから私はここで何番目に置く必要がありますか？

1583
01:10:51,402 --> 01:10:52,880
>> 対象：9、10。

1584
01:10:52,880 --> 01:10:55,600
>> BRIAN SCASSELLATI：9、10、
誰かが右、11と言うようになったのか？

1585
01:10:55,600 --> 01:10:58,190

1586
01:10:58,190 --> 01:11:01,585
私は前に2つのドットを望んでいました
iは2以上置きます。

1587
01:11:01,585 --> 01:11:03,810
私は、8ドットを望んでいました
私は8よりも少ない私を置きます。

1588
01:11:03,810 --> 01:11:06,950
今私は10を通って行きたいです
時間は、私はあまりthan-- Jを置きます

1589
01:11:06,950 --> 01:11:07,590
>> 聴衆：10。

1590
01:11:07,590 --> 01:11:08,610
>> BRIAN SCASSELLATI：10。

1591
01:11:08,610 --> 01:11:10,150
そうしよう。

1592
01:11:10,150 --> 01:11:13,360
そして、私はjへ最後に何をすればいいですか？

1593
01:11:13,360 --> 01:11:15,310
++、それをインクリメントします。

1594
01:11:15,310 --> 01:11:16,230
OK。

1595
01:11:16,230 --> 01:11:21,500
さて、ここでトリッキーな部分だ、何です
今、私はこれを行う場合に起こるだろうか？

1596
01:11:21,500 --> 01:11:24,537
私は10フレームを印刷しようとしていますか？

1597
01:11:24,537 --> 01:11:26,370
スピーカー27：私は思います
それらはすべて同じになるでしょう。

1598
01:11:26,370 --> 01:11:28,453
BRIAN SCASSELLATI：彼らはよ
すべては右、同じこと？

1599
01:11:28,453 --> 01:11:31,750
それらのすべてはまだ行っているため、
最初に2つのドットを配置します。

1600
01:11:31,750 --> 01:11:34,162
しかし、私はそれらをすべてしたくありません
2つのドット始まりを持っています。

1601
01:11:34,162 --> 01:11:35,870
私はどのように多くのドット行います
先頭にしたいですか？

1602
01:11:35,870 --> 01:11:39,097

1603
01:11:39,097 --> 01:11:40,020
>> 聴衆：変更。

1604
01:11:40,020 --> 01:11:42,840
>> BRIAN SCASSELLATI：私
それが正しい、変更したいですか？

1605
01:11:42,840 --> 01:11:46,588
だから私は変化だとここで何がありますか
ループが経由するたびに？

1606
01:11:46,588 --> 01:11:48,242
>> 聴衆：ドット数、J。

1607
01:11:48,242 --> 01:11:49,950
BRIAN SCASSELLATI：J、
ドット数。

1608
01:11:49,950 --> 01:11:54,782
だから私はJであることが、これを変更することができます。

1609
01:11:54,782 --> 01:11:59,190
初めて
ループは、どのようなことがあることになるだろうか？

1610
01:11:59,190 --> 01:12:01,700
私は最初ににjは何を設定しますか？

1611
01:12:01,700 --> 01:12:02,420
>> 聴衆：0。

1612
01:12:02,420 --> 01:12:05,700
>> BRIAN SCASSELLATI：だから、どのように多くの
時間は、私はこれをするつもりですか？

1613
01:12:05,700 --> 01:12:06,750
0。

1614
01:12:06,750 --> 01:12:11,750
ループ2回目、Jさん
私はそれを増加するので1になるだろう。

1615
01:12:11,750 --> 01:12:14,180
どのように多くの点私は印刷するつもり？

1616
01:12:14,180 --> 01:12:15,100
1。

1617
01:12:15,100 --> 01:12:19,904
ループを介して第3時間、
どのように多くの点私は印刷するつもり？

1618
01:12:19,904 --> 01:12:20,587
>> 聴衆：三。

1619
01:12:20,587 --> 01:12:22,170
BRIAN SCASSELLATI：jは3になるだろう。

1620
01:12:22,170 --> 01:12:24,890
どのように多くの点私は印刷するつもり？

1621
01:12:24,890 --> 01:12:26,817
ああ、申し訳ありませんが、jが2になるだろう。

1622
01:12:26,817 --> 01:12:28,233
どのように多くの点私は印刷するつもり？

1623
01:12:28,233 --> 01:12:28,980
>> 聴衆：2。

1624
01:12:28,980 --> 01:12:29,855
>> BRIAN SCASSELLATI：2。

1625
01:12:29,855 --> 01:12:32,460
[OK]をので、私は続けるつもりです
私たちが一緒に行くようにすることをインクリメントします。

1626
01:12:32,460 --> 01:12:33,460
どのように下方には？

1627
01:12:33,460 --> 01:12:34,310
ここで何がダウンしましたか？

1628
01:12:34,310 --> 01:12:38,080
私はいつも8をしたくありません
もう終わりに？

1629
01:12:38,080 --> 01:12:39,269
>> スピーカ28：10。

1630
01:12:39,269 --> 01:12:40,685
BRIAN SCASSELLATI：私は10ドットをしたいですか？

1631
01:12:40,685 --> 01:12:43,440

1632
01:12:43,440 --> 01:12:44,620
私も、それを変更したいです。

1633
01:12:44,620 --> 01:12:47,469
だから、どのように私はそれを変更したいのですか？

1634
01:12:47,469 --> 01:12:49,167
>> 聴衆：[聞こえません]。

1635
01:12:49,167 --> 01:12:51,750
BRIAN SCASSELLATI：まあ、私の場合
初めに5点を有しています、

1636
01:12:51,750 --> 01:12:53,293
私は最後にどのように多くのドットのを得るのですか？

1637
01:12:53,293 --> 01:12:54,020
>> 聴衆：5。

1638
01:12:54,020 --> 01:12:55,630
>> BRIAN SCASSELLATI：私が持っている場合
先頭の6ドット、

1639
01:12:55,630 --> 01:12:56,875
私は最後に何を得るのですか？

1640
01:12:56,875 --> 01:12:57,500
聴衆：四。

1641
01:12:57,500 --> 01:12:58,950
BRIAN SCASSELLATI：私が持っている場合
初めに7点、

1642
01:12:58,950 --> 01:13:00,204
私は最後に何を得るのですか？

1643
01:13:00,204 --> 01:13:00,870
聴衆：三。

1644
01:13:00,870 --> 01:13:03,161
BRIAN SCASSELLATI：私がしている場合
初めにj個の点を持って、

1645
01:13:03,161 --> 01:13:04,790
私は最後に何を得るのですか？

1646
01:13:04,790 --> 01:13:07,520
10-J。

1647
01:13:07,520 --> 01:13:08,650
OK。

1648
01:13:08,650 --> 01:13:10,390
それでは、これを試してみましょう。

1649
01:13:10,390 --> 01:13:13,180
>> だから私は、私たちのウサギのプログラムを保存するつもりです。

1650
01:13:13,180 --> 01:13:16,270
もう一度、我々はズームアウトします。

1651
01:13:16,270 --> 01:13:19,090
私たちは、端末に下るだろう。

1652
01:13:19,090 --> 01:13:20,180
我々はそれをクリアします。

1653
01:13:20,180 --> 01:13:23,410
そして、ズームイン。

1654
01:13:23,410 --> 01:13:26,410
私たちは再び、私たちのウサギのプログラムを作ります。

1655
01:13:26,410 --> 01:13:27,690
そして、我々はそれを実行します。

1656
01:13:27,690 --> 01:13:30,462

1657
01:13:30,462 --> 01:13:32,090
おっと。

1658
01:13:32,090 --> 01:13:34,580
>> それでは、ズームアウトさせて、上に保持します。

1659
01:13:34,580 --> 01:13:36,860
私は10フレームを取得しましたか？

1660
01:13:36,860 --> 01:13:38,970
さて、どのように多くのバニー
私はそこまで見ていますか？

1661
01:13:38,970 --> 01:13:43,330
1、2、3、4、5、6、7、8、9、10。

1662
01:13:43,330 --> 01:13:44,820
私は10フレームを得ました。

1663
01:13:44,820 --> 01:13:46,375
それらはすべて同じですか？

1664
01:13:46,375 --> 01:13:47,000
聴衆：うん。

1665
01:13:47,000 --> 01:13:48,740
いいえ。

1666
01:13:48,740 --> 01:13:50,000
>> BRIAN SCASSELLATI：いいえ

1667
01:13:50,000 --> 01:13:55,050
その最初のもの、
バニーは左端にあります。

1668
01:13:55,050 --> 01:13:57,541
そして、ここの上に、バニーは上遠いです

1669
01:13:57,541 --> 01:13:58,290
スピーカ29：右。

1670
01:13:58,290 --> 01:14:00,502
BRIAN SCASSELLATI：だから、
私は何をするのを忘れたのか？

1671
01:14:00,502 --> 01:14:01,750
スピーカ30：新しい行を開始します。

1672
01:14:01,750 --> 01:14:04,041
BRIAN SCASSELLATI：私は忘れてしまいました
再び、新しい行を開始します。

1673
01:14:04,041 --> 01:14:05,270
私は前に作られた同じ間違い。

1674
01:14:05,270 --> 01:14:07,120
すべての権利、のはそれを修正手放します。

1675
01:14:07,120 --> 01:14:11,690
今、私はまだコードを持っています
そこに新しい行を作成します。

1676
01:14:11,690 --> 01:14:13,899
なぜそれが動作しませんでしたか？

1677
01:14:13,899 --> 01:14:15,440
スピーカ31：それはループの中ではありません。

1678
01:14:15,440 --> 01:14:17,710
BRIAN SCASSELLATI：ああ、
それはループの中ではありません。

1679
01:14:17,710 --> 01:14:18,520
そのとおり。

1680
01:14:18,520 --> 01:14:20,150
ここは外に座っています。

1681
01:14:20,150 --> 01:14:23,470

1682
01:14:23,470 --> 01:14:29,050
また、ループのためのすべてがあります
それは、そのテキストの内部です。

1683
01:14:29,050 --> 01:14:35,500
>> だから私は移動するつもりです
この内側のforループ。

1684
01:14:35,500 --> 01:14:39,410
そして、私はそれの前にタブをよ
それが正しい場所にだことを示しています。

1685
01:14:39,410 --> 01:14:42,020
そして今、我々は再びそれを保存します。

1686
01:14:42,020 --> 01:14:44,350
私たちは、ズームアウトします。

1687
01:14:44,350 --> 01:14:45,770
私たちは、端末に切り替えます。

1688
01:14:45,770 --> 01:14:48,330

1689
01:14:48,330 --> 01:14:50,360
ズームイン。

1690
01:14:50,360 --> 01:14:54,050
私たちは、ウサギのプログラムを作り直します。

1691
01:14:54,050 --> 01:14:59,070
そして今、今、私たちは10フレームを持っています。

1692
01:14:59,070 --> 01:15:00,190
>> [拍手]

1693
01:15:00,190 --> 01:15:02,120
>> BRIAN SCASSELLATI：[OK]をクリックします。

1694
01:15:02,120 --> 01:15:04,080
Soが

1695
01:15:04,080 --> 01:15:08,370
ここに私たちのループの入れ子になっています。

1696
01:15:08,370 --> 01:15:13,140
我々は中に生成することができました
私が望んでいたどのように多くのドット内側のループ

1697
01:15:13,140 --> 01:15:15,320
最後に、最初に印刷します。

1698
01:15:15,320 --> 01:15:21,570
そして、外側のループを制御
どのように多くの私が構築したフレーム。

1699
01:15:21,570 --> 01:15:26,340
私たちは一つの小さなを開始
問題のカーネル、

1700
01:15:26,340 --> 01:15:30,320
私たちは、その時点から構築されました。

1701
01:15:30,320 --> 01:15:30,820
大丈夫。

1702
01:15:30,820 --> 01:15:33,500
>> それでは、もう一つの手順を実行してみましょう。

1703
01:15:33,500 --> 01:15:35,040
あなたは〜を用意する？

1704
01:15:35,040 --> 01:15:38,800
一つのことは、ここにどこにあります
私たちは実際に種類の持っています

1705
01:15:38,800 --> 01:15:42,180
我々が必要以上に複雑。

1706
01:15:42,180 --> 01:15:44,700
のは、見てみましょう。

1707
01:15:44,700 --> 01:15:52,050
だから、私たちのバニーのプログラムで、
私はここでズームアウトすると、

1708
01:15:52,050 --> 01:15:54,980
私は実際には同じのいくつかの操作を行います
事何度も繰り返し。

1709
01:15:54,980 --> 01:15:59,032
私は、並べ替えの何をしますか
同じことを二回繰り返し？

1710
01:15:59,032 --> 01:16:00,310
>> スピーカ32：ドットを印刷します。

1711
01:16:00,310 --> 01:16:03,526
>> BRIAN SCASSELLATI：うん
私は2倍のドットを印刷します。

1712
01:16:03,526 --> 01:16:05,710
本当に、私が持っている必要があります
ダウンここでこのコメント。

1713
01:16:05,710 --> 01:16:09,037
私はいくつかにドットを印刷します
右ここまで、始まります。

1714
01:16:09,037 --> 01:16:10,620
そして私は最後に、いくつかのドットを印刷します。

1715
01:16:10,620 --> 01:16:14,694
そして、私は一種の全く同じことを行います。

1716
01:16:14,694 --> 01:16:17,110
我々が開始するつもりです
今後数週間のうちに取り組んで

1717
01:16:17,110 --> 01:16:23,440
のそれらのブロックを取ることができることです
私たちは何度も使用したコード、

1718
01:16:23,440 --> 01:16:25,800
そして、プロセスを通じて
抽象化と呼ばれます

1719
01:16:25,800 --> 01:16:31,100
我々はそれらを引き出すつもりだと
かつて我々は、その後することができるようにそれらを書きます

1720
01:16:31,100 --> 01:16:35,130
何度も何度も再利用。

1721
01:16:35,130 --> 01:16:37,210
それでは、これを試してみましょう。

1722
01:16:37,210 --> 01:16:38,220
準備はできましたか？

1723
01:16:38,220 --> 01:16:42,200
>> 私たちは、コードブロックを取るつもりです。

1724
01:16:42,200 --> 01:16:45,280
そして、私はそこからそれを取るつもりです。

1725
01:16:45,280 --> 01:16:50,530
そして、私はdefine--するつもりです
下部の下に、

1726
01:16:50,530 --> 01:16:53,130
私は、新しい関数を記述するつもりです。

1727
01:16:53,130 --> 01:16:54,750
それは何かを返すことはないだろう。

1728
01:16:54,750 --> 01:16:58,550
そして、私はprintDotsそれを呼び出すつもりです。

1729
01:16:58,550 --> 01:17:01,530
>> これは、1を取るために起こっています
引数、整数

1730
01:17:01,530 --> 01:17:04,920
私は印刷する必要がありますhowManyDots氏は述べています。

1731
01:17:04,920 --> 01:17:09,310

1732
01:17:09,310 --> 01:17:17,720
代わりにj個のドットを印刷するそして今、私はよ
私は印刷する必要howManyDotsを教えて印刷します。

1733
01:17:17,720 --> 01:17:21,581
>> そして、もう一つの小さな問題がここにあります。

1734
01:17:21,581 --> 01:17:22,580
誰もがそれが何であるかを知っていますか？

1735
01:17:22,580 --> 01:17:27,270

1736
01:17:27,270 --> 01:17:31,505
私はそれが表示されて何がありますか
ここで定義されていないということ？

1737
01:17:31,505 --> 01:17:34,165

1738
01:17:34,165 --> 01:17:35,090
>> 聴衆：[聞こえません]

1739
01:17:35,090 --> 01:17:37,465
>> BRIAN SCASSELLATI：まあ方法
多くのドットが右に定義されています

1740
01:17:37,465 --> 01:17:40,584
ここで、私はその変数iを使用しています。

1741
01:17:40,584 --> 01:17:43,750
だから私は、その変数を取るつもりだ私
そして、私はここでそれを定義するつもりです

1742
01:17:43,750 --> 01:17:44,610
代わりに。

1743
01:17:44,610 --> 01:17:49,683
>> だから今、それはおっとstay--ために起こっています、
キャップはsomehow--私はロックオンました

1744
01:17:49,683 --> 01:17:52,060
ここで私をダウン維持するつもり。

1745
01:17:52,060 --> 01:17:57,050
>> だから今、ここで私の小さな機能です
またはサブルーチン、およびそれが言います、

1746
01:17:57,050 --> 01:18:00,640
どのように多くの点私は印刷するつもり？

1747
01:18:00,640 --> 01:18:05,300
そして、それはこのループを通過するだろうと
何度も何度もそれらを印刷します。

1748
01:18:05,300 --> 01:18:10,940
>> 私は、ここに私のプログラムを変更することができます。

1749
01:18:10,940 --> 01:18:12,540
そして、何私は、その関数を呼び出したのか？

1750
01:18:12,540 --> 01:18:13,960
printDots。

1751
01:18:13,960 --> 01:18:17,060
だから私はprintDotsと呼ぶことにします。

1752
01:18:17,060 --> 01:18:21,530
私は印刷するためにどのように多くのドットたいです
バニーの前に初めて？

1753
01:18:21,530 --> 01:18:22,030
者：J。

1754
01:18:22,030 --> 01:18:23,230
BRIAN SCASSELLATI：J。

1755
01:18:23,230 --> 01:18:27,110
私は印刷するためにどのように多くのドットたいです
最後に、バニーの後？

1756
01:18:27,110 --> 01:18:30,610

1757
01:18:30,610 --> 01:18:31,110
10-J。

1758
01:18:31,110 --> 01:18:35,020

1759
01:18:35,020 --> 01:18:38,010
>> そして、私が欠けている一つのことがあります。

1760
01:18:38,010 --> 01:18:43,740
あなたが今日の講義で見たように、
我々はprintDotsを宣言するつもりです

1761
01:18:43,740 --> 01:18:52,430
アップ上記のプロトタイプを得ました。

1762
01:18:52,430 --> 01:18:56,740

1763
01:18:56,740 --> 01:18:58,220
OK。

1764
01:18:58,220 --> 01:19:03,530
>> それでは、私がやったことは私がしようとしましたさ
コー​​ドの再利用部分を分離

1765
01:19:03,530 --> 01:19:06,430
私は何度も何度もやったこと。

1766
01:19:06,430 --> 01:19:11,120
そして、私はそのようにそれを引き出すために試してみました
そのすべてが一つの場所に含まれています。

1767
01:19:11,120 --> 01:19:16,810
そのように、私はどこかに間違いがある場合は、
私は一つの場所でそれを修正する必要があります。

1768
01:19:16,810 --> 01:19:17,310
大丈夫。

1769
01:19:17,310 --> 01:19:18,470
>> それでは、それを保存してみましょう。

1770
01:19:18,470 --> 01:19:20,950
そしてのは、それが動作することを確認してみましょう。

1771
01:19:20,950 --> 01:19:22,050
それでは、出て行きましょう。

1772
01:19:22,050 --> 01:19:25,200
私たちは、端末に再度行きますよ。

1773
01:19:25,200 --> 01:19:27,960
私たちはズームインます。

1774
01:19:27,960 --> 01:19:31,010
我々は、ウサギの処理を行います。

1775
01:19:31,010 --> 01:19:32,380
>> ああ。

1776
01:19:32,380 --> 01:19:34,800
そしてそれは、私に警告を与えています。

1777
01:19:34,800 --> 01:19:37,070
それは私に言っては何ですか？

1778
01:19:37,070 --> 01:19:39,870
さて、これらのいずれかで
時間は、あなたが常にたい

1779
01:19:39,870 --> 01:19:44,170
非常に最初のerror--までスクロールします
今、この1に、私は1つだけ持っています。

1780
01:19:44,170 --> 01:19:52,700
>> これはライン上に、bunny.cに私に語りました
8、9欄、問題があります。

1781
01:19:52,700 --> 01:19:58,650
それはあなたがこれを宣言した、と言います
変数iと、あなたはそれを使用していません。

1782
01:19:58,650 --> 01:20:02,230
>> 今、通常、それはです
ない最悪のエラー。

1783
01:20:02,230 --> 01:20:04,300
それは修正する簡単なものです。

1784
01:20:04,300 --> 01:20:07,550
そして実際に、私たちは後ろに行くことができます。

1785
01:20:07,550 --> 01:20:09,910
我々は戻ってバニーに行くことができます。

1786
01:20:09,910 --> 01:20:13,010
そして、この場合には、すべての私たち
私を取り除くされなければなりません、

1787
01:20:13,010 --> 01:20:16,630
私たちが使用していないため、
もはやメイン内のI。

1788
01:20:16,630 --> 01:20:19,860
私達はちょうどそれを使用しています
私たちのサブルーチン内で。

1789
01:20:19,860 --> 01:20:22,777
>> それでは、それを保存してみましょう。

1790
01:20:22,777 --> 01:20:23,360
我々は戻って行きますよ。

1791
01:20:23,360 --> 01:20:26,760

1792
01:20:26,760 --> 01:20:28,630
そして、ズームイン。

1793
01:20:28,630 --> 01:20:30,700
私たちは、1より多くの時間がバニーを行います。

1794
01:20:30,700 --> 01:20:33,810

1795
01:20:33,810 --> 01:20:36,530
そして再び私たちの10フレームがあります。

1796
01:20:36,530 --> 01:20:39,450

1797
01:20:39,450 --> 01:20:41,360
OK。

1798
01:20:41,360 --> 01:20:43,190
>> あなたが与えられているときはいつでも
procedure--うん。

1799
01:20:43,190 --> 01:20:44,690
スピーカー33：私は混乱しているA--私が持っています。

1800
01:20:44,690 --> 01:20:45,892
あなたが戻ってコードに行くことができますか？

1801
01:20:45,892 --> 01:20:46,850
BRIAN SCASSELLATI：うん。

1802
01:20:46,850 --> 01:20:50,730

1803
01:20:50,730 --> 01:20:54,367
>> あなたが書いたそう、：SPEAKER 33
プロトタイプ、引数ます

1804
01:20:54,367 --> 01:20:56,550
それはhowManyが呼ばれた名前のいましたか？

1805
01:20:56,550 --> 01:20:57,540
しかし、below--

1806
01:20:57,540 --> 01:20:57,640
>> BRIAN SCASSELLATI：そうそう。

1807
01:20:57,640 --> 01:20:59,140
>> スピーカー33は：彼らに何かを--called
異なる、私は理解していません。

1808
01:20:59,140 --> 01:21:00,240
>> BRIAN SCASSELLATI：なぜ
それらが異なっています。

1809
01:21:00,240 --> 01:21:01,780
だから、それは素晴らしい質問です。

1810
01:21:01,780 --> 01:21:08,250
そこで問題は、最大でした
ここで、私は、howManyが書きました

1811
01:21:08,250 --> 01:21:12,380
そして、下方に、私はhowManyDotsを書きました。

1812
01:21:12,380 --> 01:21:15,590
>> その理由は、あなたのプロトタイプであることをアップしています
それは実際に注意を払っていません

1813
01:21:15,590 --> 01:21:17,090
あなたが入れている名前に。

1814
01:21:17,090 --> 01:21:20,530
それは本当に気にすべての
それは整数であるということです。

1815
01:21:20,530 --> 01:21:23,080
これは、フォームを知りたいです
あなたが入れているものの。

1816
01:21:23,080 --> 01:21:31,560
>> 今stylistically-- oops--私がすべき
、私はこれらの試合をしたいとされます。

1817
01:21:31,560 --> 01:21:33,150
OK。

1818
01:21:33,150 --> 01:21:36,430
それはそれを維持することがありますので
私が覚えているため容易になります。

1819
01:21:36,430 --> 01:21:38,390
しかし、それはええ、私の間違いでした。

1820
01:21:38,390 --> 01:21:47,620
>> スピーカー34：そしてそうするため
プロトタイプはちょうど、動作するように

1821
01:21:47,620 --> 01:21:50,510
その行を書いて、
プロトタイプを書いて、

1822
01:21:50,510 --> 01:21:53,932
来るその機能を可能にします
右のそれより下の端に移動します

1823
01:21:53,932 --> 01:21:55,140
そしてそれが何を意味するのか取得しますか？

1824
01:21:55,140 --> 01:21:58,480
>> BRIAN SCASSELLATI：それが何を意味するのか
コンパイラが通過するときです、

1825
01:21:58,480 --> 01:22:01,930
の上から行きます
下にあなたのコード。

1826
01:22:01,930 --> 01:22:05,430
そして、このプロトタイプは、何ですか
それは基本的にはお約束だです。

1827
01:22:05,430 --> 01:22:09,570
>> それはがあるように起こっている、と言います
どこかで定義された関数。

1828
01:22:09,570 --> 01:22:11,880
それはprintDotsと呼ばれるようになるだろう。

1829
01:22:11,880 --> 01:22:15,110
そして、それは一つの引数を取るために起こっています
それは整数になるだろう

1830
01:22:15,110 --> 01:22:18,590
それは返すために起こっています
何もない、ボイド型。

1831
01:22:18,590 --> 01:22:19,310
OK。

1832
01:22:19,310 --> 01:22:22,950
私はそれがために起こっているあなたをお約束します
道の下のどこかで定義されました。

1833
01:22:22,950 --> 01:22:25,590
しかし、いつでもあなたが参照してください。
あなたがダウンして行くと、その

1834
01:22:25,590 --> 01:22:28,710
私の残りの部分を通って
主な機能、私が欲しいです

1835
01:22:28,710 --> 01:22:33,800
もし関数としてそれを治療します
それは1つの整数の入力を取ります。

1836
01:22:33,800 --> 01:22:37,970
>> だからコンパイラがダウンしたとき
このを通じて、その約束を見ています。

1837
01:22:37,970 --> 01:22:40,220
そして、それがダウンして取得したときに、
いって、いって、

1838
01:22:40,220 --> 01:22:43,060
それは最初に見つけました
printDotsは言及されています。

1839
01:22:43,060 --> 01:22:46,910
そして、それはああ、あなたが与えている、と言います
私、このJ。 jは整数です。

1840
01:22:46,910 --> 01:22:49,570
>> さてあなたは私にそれが約束しました
整数で、それはそうです。

1841
01:22:49,570 --> 01:22:51,370
それで大丈夫です。

1842
01:22:51,370 --> 01:22:53,880
そして最後に、ダウン
一番下に、

1843
01:22:53,880 --> 01:22:58,340
私は自分の終わりに到達する前に
ファイル、私は私の約束に良い作ります

1844
01:22:58,340 --> 01:22:59,896
私はそれを定義します。

1845
01:22:59,896 --> 01:23:01,868
OK？

1846
01:23:01,868 --> 01:23:06,320
>> スピーカー35：だから、それはsaves--
プログラムは、空白スペースを節約します

1847
01:23:06,320 --> 01:23:09,570
それが戻って最後に充填しますか？

1848
01:23:09,570 --> 01:23:12,140
>> BRIAN SCASSELLATI：それはありません
メモリ割り当てに関する。

1849
01:23:12,140 --> 01:23:16,800
それはちょうどについて、実際に何がありますか
タイプは、あなたが見ることを期待しています。

1850
01:23:16,800 --> 01:23:19,340
このことは、一つを持っている必要があります
引数、または5つの引数？

1851
01:23:19,340 --> 01:23:23,590
それは整数がありましたら
それ、または文字列に与えられましたか？

1852
01:23:23,590 --> 01:23:25,780
それはそれは見ているすべてです
行うにチェックすることです、

1853
01:23:25,780 --> 01:23:29,303
あなたは私に与えています
引数の正しい種類。

1854
01:23:29,303 --> 01:23:31,560
OK？

1855
01:23:31,560 --> 01:23:32,300
大丈夫。

1856
01:23:32,300 --> 01:23:38,570
>> 私はであなたを残してみよう
見て一つの他のビット。

1857
01:23:38,570 --> 01:23:44,850
ASCIIアートは素晴らしいモデルではありません
それが今日のようなアニメーションの。

1858
01:23:44,850 --> 01:23:50,850
しかし、当然のことながら、一部の人々は、物事を取ります
そして彼らは極端にそれを押してください。

1859
01:23:50,850 --> 01:23:56,790
>> ダビデが示されているように、これは、あります
講義では、コードの断片

1860
01:23:56,790 --> 01:24:02,150
あなたはどのような状況でなければならないこと
自分を複製してみてください。

1861
01:24:02,150 --> 01:24:05,260
それは文体ひどいですので。

1862
01:24:05,260 --> 01:24:11,180
実際に、それは次のようになるように設計されています
読みできるだけ難しいです。

1863
01:24:11,180 --> 01:24:11,680
OK。

1864
01:24:11,680 --> 01:24:16,210
>> だから、もう一度行うには、のは、ここにズームしてみましょう。

1865
01:24:16,210 --> 01:24:20,120
私は、今、変更ディレクトリを行くつもりです。

1866
01:24:20,120 --> 01:24:24,050
私は1つを行くつもりです
レベル、戻って私のワークスペースに。

1867
01:24:24,050 --> 01:24:29,760
私は、この中にディレクトリを変更します
私が作成した他のディレクトリ。

1868
01:24:29,760 --> 01:24:36,190
>> そして、これは国際的です
難読化のCプログラミングコンテスト。

1869
01:24:36,190 --> 01:24:40,650
ハードとしての難読化手段
可能性として理解します。

1870
01:24:40,650 --> 01:24:44,150
あなたが見ればそう、怖いことしないでください
この時と行く、私はそれを読み取ることができません。

1871
01:24:44,150 --> 01:24:46,350
それはそれのポイントです。

1872
01:24:46,350 --> 01:24:47,700
OK？

1873
01:24:47,700 --> 01:24:52,770
>> しかし、我々はこれを持っています
私は素晴らしいプログラム

1874
01:24:52,770 --> 01:24:57,180
ちょうどより多くを入力して見に行きます。

1875
01:24:57,180 --> 01:25:01,890
そして、私はズームアウトできるかどうかを見てみましょう
少しだけ、あなたはそれを見ることができます

1876
01:25:01,890 --> 01:25:03,940
>> そして、これはプログラムです。

1877
01:25:03,940 --> 01:25:08,080
それはendo.c.という名前です

1878
01:25:08,080 --> 01:25:14,850
そして、それはこのバケツのようになります。
その中に文字F-L-U-I-Dのようなもの。

1879
01:25:14,850 --> 01:25:16,440
>> これは実際にプログラムです。

1880
01:25:16,440 --> 01:25:20,260
これは、最もあいまいに書かれています
方法著者は、おそらくことができること

1881
01:25:20,260 --> 01:25:21,760
それを書きます。

1882
01:25:21,760 --> 01:25:29,210
しかし、それはその素晴らしい小さな作品です
流体力学のモデルを生成します。

1883
01:25:29,210 --> 01:25:34,870
>> そして、私たちは与えるつもりです
そのモデルは、入力こと

1884
01:25:34,870 --> 01:25:42,520
の、次のようになります
コンテナのセットstaired

1885
01:25:42,520 --> 01:25:45,820
いくつかの流体と、いくつかの
液体、アップトップに。

1886
01:25:45,820 --> 01:25:48,790
そして、我々はそれをシミュレートする必要があります
何がそれに起こっています。

1887
01:25:48,790 --> 01:25:52,415
>> だから私は遠藤、その関数を呼び出します。

1888
01:25:52,415 --> 01:25:59,000
そして、私はそれをあげること
私が持っていた入力ファイル。

1889
01:25:59,000 --> 01:26:02,830
そして、ASCIIアートの私たちの縮図があります。

1890
01:26:02,830 --> 01:26:08,960
完全流体力学シミュレータ
わずか数行のコードで実行されています。

1891
01:26:08,960 --> 01:26:13,750
>> 今は本当に実際に何
この小さなプログラムについての驚くべき

1892
01:26:13,750 --> 01:26:17,280
私は今、それを停止したいということです、
私はどのようなコマンドを使用するつもりですか？

1893
01:26:17,280 --> 01:26:18,660
>> 聴衆：Control-Cを。

1894
01:26:18,660 --> 01:26:20,390
>> BRIAN SCASSELLATI：Control-Cを。 OK。

1895
01:26:20,390 --> 01:26:22,960
だから私は、Control-Cを使用します。
それを停止しますC。

1896
01:26:22,960 --> 01:26:25,330
私は再びオフにします。

1897
01:26:25,330 --> 01:26:31,210
そして今、私が呼び出すつもりです
プログラムは、プログラムを実行し、

1898
01:26:31,210 --> 01:26:33,740
入力としての地位を使用して。

1899
01:26:33,740 --> 01:26:36,760

1900
01:26:36,760 --> 01:26:42,700
>> そして、我々は流体力学が表示されます
そのシミュレーションは融解します。

1901
01:26:42,700 --> 01:26:43,830
OK。

1902
01:26:43,830 --> 01:26:48,180
そのプログラムをさせないようにしてください
あなたが混乱ものになります。

1903
01:26:48,180 --> 01:26:52,220
私たちが終了することができ、ちょうどそのようなものです
クールで面白いこと。

1904
01:26:52,220 --> 01:26:53,930
OK。

1905
01:26:53,930 --> 01:26:56,330
>> あなたの問題セットと幸運を祈る。

1906
01:26:56,330 --> 01:26:59,030
我々はお答えさせていただきます
クラスの後に質問。

1907
01:26:59,030 --> 01:27:01,180
ありがとう、みんな。

1908
01:27:01,180 --> 01:27:02,793