1
00:00:00,000 --> 00:00:03,353
>> [音乐播放]

2
00:00:03,353 --> 00:00:04,842

3
00:00:04,842 --> 00:00:06,050
DAVID马兰：大家好。

4
00:00:06,050 --> 00:00:07,777
这是CS50的超部分。

5
00:00:07,777 --> 00:00:09,860
分配的部分将不
开始一个星期。

6
00:00:09,860 --> 00:00:11,580
所以今天，我在这里with--

7
00:00:11,580 --> 00:00:12,122
>> 玛丽亚：玛丽亚。

8
00:00:12,122 --> 00:00:14,163
DAVID马兰：--to实际
看看问题

9
00:00:14,163 --> 00:00:16,110
设置之一，课程的
第一周的材料，

10
00:00:16,110 --> 00:00:19,780
让你用面向CS50 IDE，有点
的Linux，操作系统那的

11
00:00:19,780 --> 00:00:22,290
上IDE中运行，以及
看看一些过渡

12
00:00:22,290 --> 00:00:25,730
从零开始到C领先
长达问题集之一。

13
00:00:25,730 --> 00:00:28,340
>> 因此，事不宜迟，
在问题集中的一个，

14
00:00:28,340 --> 00:00:30,520
你会是
推出CS50 IDE，它

15
00:00:30,520 --> 00:00:33,230
这是基于网络的节目
我们为了使用环境而定

16
00:00:33,230 --> 00:00:34,280
写程序。

17
00:00:34,280 --> 00:00:37,280
它的设计看起来非常
让人联想到典型的计算机

18
00:00:37,280 --> 00:00:39,430
运行的操作系统
系统称为Linux。

19
00:00:39,430 --> 00:00:42,440
但是，它在所谓的云，
这意味着每个人都在类

20
00:00:42,440 --> 00:00:45,100
其实可以有他或她的
自己的帐户，并使用它，以及。

21
00:00:45,100 --> 00:00:48,950
>> 因此，大多数人可能从未使用过
之前或者Linux环境

22
00:00:48,950 --> 00:00:50,447
甚至一个命令行环境。

23
00:00:50,447 --> 00:00:52,280
和命令行
环境是不同的。

24
00:00:52,280 --> 00:00:53,200
它的所有文字。

25
00:00:53,200 --> 00:00:54,730
它的所有键盘命令。

26
00:00:54,730 --> 00:00:59,480
而且它没有鼠标移动，没有图标，
没有对话窗口，没有菜单。

27
00:00:59,480 --> 00:01:00,212
这是纯粹的文字。

28
00:01:00,212 --> 00:01:01,920
所以刚开始，它种
的感觉就像一个步

29
00:01:01,920 --> 00:01:04,434
向后复杂的条款。

30
00:01:04,434 --> 00:01:06,600
但它最终被很多
功能更强大，当然，

31
00:01:06,600 --> 00:01:08,510
对于计算机科学家，最终。

32
00:01:08,510 --> 00:01:09,540
>> 因此，让我们一起来看看。

33
00:01:09,540 --> 00:01:13,850
在这里，我在CS50.io，通过这
您可以登录到CS50 IDE。

34
00:01:13,850 --> 00:01:17,414
而就像在刮，有
三个主要方面来此屏幕。

35
00:01:17,414 --> 00:01:20,080
等的左手侧，我们有
会是怎样的文件浏览器。

36
00:01:20,080 --> 00:01:22,413
还有的这个文件夹中
顶，这是正确的，现在空

37
00:01:22,413 --> 00:01:24,690
因为我摆脱我所有的
超部分之前的文件。

38
00:01:24,690 --> 00:01:27,599
而这也正是我们将
保存我们写的C文件。

39
00:01:27,599 --> 00:01:30,890
在右上角，我们有一个地方，
我们所有的代码会得到写入。

40
00:01:30,890 --> 00:01:34,610
事实上，如果我点击这个加号，这
是打算让我选择新建文件。

41
00:01:34,610 --> 00:01:38,310
在这里，我可以开始写C代码，或者，
确实，任何数量的其他语言。

42
00:01:38,310 --> 00:01:42,670
>> 然后在底部的地方
说jharvard @ ide50--和你的将

43
00:01:42,670 --> 00:01:45,080
说的东西有点
different--什么这个叫什么？

44
00:01:45,080 --> 00:01:48,644

45
00:01:48,644 --> 00:01:49,310
终端窗口。

46
00:01:49,310 --> 00:01:49,570
是啊。

47
00:01:49,570 --> 00:01:51,810
因此，终端窗口
所谓的命令行

48
00:01:51,810 --> 00:01:55,540
接口，通过它，你可以进行交互
与底层操作系统。

49
00:01:55,540 --> 00:01:58,220
而现在，我们要
让很少使用this--的

50
00:01:58,220 --> 00:02:01,170
只是编译，看看
我们看到错误消息，

51
00:02:01,170 --> 00:02:02,347
并运行我们的程序。

52
00:02:02,347 --> 00:02:04,680
但最终，我们将
这样做的多，以及。

53
00:02:04,680 --> 00:02:07,490
你甚至可以安装软件
和管理您的工作空间

54
00:02:07,490 --> 00:02:09,066
CS50在IDE中，也是如此。

55
00:02:09,066 --> 00:02:10,440
但更多的是一些其他的时间。

56
00:02:10,440 --> 00:02:12,689
>> 因此，让我们继续前进，写
一个非常简单的程序只是

57
00:02:12,689 --> 00:02:15,064
经过一个热身
hello.c的，这也许就是

58
00:02:15,064 --> 00:02:16,480
我们可以写出简单的程序。

59
00:02:16,480 --> 00:02:18,330
我已经打开了一个新的标签。

60
00:02:18,330 --> 00:02:24,310
我要继续前进，
说包括标准io.h.

61
00:02:24,310 --> 00:02:25,325
然后，诠释的主要（无效）。

62
00:02:25,325 --> 00:02:28,930

63
00:02:28,930 --> 00:02:35,200
然后的printf（“你好，世界”
反斜杠N，密切报价，

64
00:02:35,200 --> 00:02:39,480
关闭括号和分号。

65
00:02:39,480 --> 00:02:39,990
>> 好吧。

66
00:02:39,990 --> 00:02:41,700
所以，现在发现我的窗口没有标题。

67
00:02:41,700 --> 00:02:44,840
所以，我很快会
上去文件，保存。

68
00:02:44,840 --> 00:02:46,910
而且它是非常重要的
我把这种不是“你好”。

69
00:02:46,910 --> 00:02:49,243
所以有一个非常常见的错误，
尤其是在问题的设置之一，

70
00:02:49,243 --> 00:02:52,530
是意外只是打电话给你
节目“水”和“贪婪”和“马里奥”

71
00:02:52,530 --> 00:02:53,890
或“信用”等。

72
00:02:53,890 --> 00:02:55,970
但是，你真的想使
确保您有文件扩展名

73
00:02:55,970 --> 00:02:58,928
因为这是唯一的方式，
编译器和还代码编辑器

74
00:02:58,928 --> 00:03:00,710
知道你
实际上编写C代码。

75
00:03:00,710 --> 00:03:02,280
因此，让我继续前进，然后点击保存。

76
00:03:02,280 --> 00:03:05,710
>> 现在也一样，什么CS50 IDE
已经为我们做的这也是

77
00:03:05,710 --> 00:03:07,120
语法高亮一切。

78
00:03:07,120 --> 00:03:08,822
因此，它是由一切非常丰富多彩。

79
00:03:08,822 --> 00:03:10,780
而整个目的
不能正常工作。

80
00:03:10,780 --> 00:03:14,290
这只是吸引我的目光投向
在概念上不同的部分

81
00:03:14,290 --> 00:03:15,310
这个方案的。

82
00:03:15,310 --> 00:03:17,570
因此，让我们继续前进，编译这个。

83
00:03:17,570 --> 00:03:19,490
我可以编译此
在几个方面。

84
00:03:19,490 --> 00:03:22,010
并且在一个星期的
老派的方式，我们做了

85
00:03:22,010 --> 00:03:26,250
这是字面上的
命令line--“铛hello.c的。”

86
00:03:26,250 --> 00:03:27,596
然后，我敲回车。

87
00:03:27,596 --> 00:03:29,720
而且似乎什么都没有发生
在终端窗口。

88
00:03:29,720 --> 00:03:32,654
但没有改变的IDE？

89
00:03:32,654 --> 00:03:35,320
其中，再次，IDE只是手段
集成开发环境。

90
00:03:35,320 --> 00:03:38,360
它是说一个奇特的方式
这个集成开发

91
00:03:38,360 --> 00:03:40,620
环境，用于开发软件。

92
00:03:40,620 --> 00:03:42,477
那么，在UI没有变化？

93
00:03:42,477 --> 00:03:44,310
你有没有注意到什么
这是不同的，玛丽亚？

94
00:03:44,310 --> 00:03:47,100
>> 玛丽亚：我发现了一些
在IDE50夹在这里。

95
00:03:47,100 --> 00:03:47,850
>> DAVID马兰：是的。

96
00:03:47,850 --> 00:03:50,230
所以在这里，不仅
我们是否有“hello.c的。”

97
00:03:50,230 --> 00:03:53,120
我们也有“的a.out”，这是
样一个程序一个愚蠢的名字。

98
00:03:53,120 --> 00:03:56,430
不过说实在的，这是一个默认的名字
当你只是编译代码的程序

99
00:03:56,430 --> 00:03:59,110
不要告诉编译器
什么样的文件输出。

100
00:03:59,110 --> 00:04:01,790
所以，如果我要运行这个，我
需要告诉compiler--

101
00:04:01,790 --> 00:04:05,340
或者说，我需要
告诉工作区，我

102
00:04:05,340 --> 00:04:09,780
要运行调用的程序“的a.out。”

103
00:04:09,780 --> 00:04:10,550
输入。

104
00:04:10,550 --> 00:04:12,474
还有的“你好，
世界“。现在的”./“。

105
00:04:12,474 --> 00:04:13,390
其实是很重要的。

106
00:04:13,390 --> 00:04:16,050
虽然通常我们只
写的命令的名称，

107
00:04:16,050 --> 00:04:19,060
当它是你已经计划
写的，你要说“./”

108
00:04:19,060 --> 00:04:22,460
因为这明确地告诉Linux
要运行一个名为程序

109
00:04:22,460 --> 00:04:26,930
“a.out的”这是在这一点，在那里点
意味着这个目录是我目前

110
00:04:26,930 --> 00:04:31,600
中，这恰好是
所谓的工作空间，“a.out的。

111
00:04:31,600 --> 00:04:35,410
因为如果我只是说：“a.out中，”回车，
我要得到“a.out的命令不

112
00:04:35,410 --> 00:04:38,035
找到“因为computer--
因为我发明了“a.out的;”

113
00:04:38,035 --> 00:04:40,910
它没有附带computer--
不知道去哪里找它，

114
00:04:40,910 --> 00:04:43,590
即使它是正确的
在我的鼻子，可以这么说。

115
00:04:43,590 --> 00:04:44,090
好。

116
00:04:44,090 --> 00:04:49,910
所以，我们可以改变这
是“铛邻打招呼hello.c的。”

117
00:04:49,910 --> 00:04:53,030
如果我敲回车，什么程序
这是怎么回事输出给我吗？

118
00:04:53,030 --> 00:04:55,710
什么是文件的名称？

119
00:04:55,710 --> 00:04:57,500
是啊，在后面。

120
00:04:57,500 --> 00:04:58,479
那就对了。 “您好。”

121
00:04:58,479 --> 00:05:00,520
因此，“你好”将是
节目的名称

122
00:05:00,520 --> 00:05:04,610
因为我们使用了所谓的
命令行参数，这仅仅是

123
00:05:04,610 --> 00:05:08,120
改变的行为的一种方式
编译器实际输出

124
00:05:08,120 --> 00:05:09,450
特定的文件名。

125
00:05:09,450 --> 00:05:12,400
事实上，如果我放大
并寻找在这里，

126
00:05:12,400 --> 00:05:17,430
现在我不仅是“的a.out”和
“hello.c的”，而且“你好”，以及。

127
00:05:17,430 --> 00:05:22,410
所以，现在我可以做“./hello，”回车。

128
00:05:22,410 --> 00:05:23,640
还有的“你好，世界”。

129
00:05:23,640 --> 00:05:25,640
但lastly--这
现在将公约

130
00:05:25,640 --> 00:05:27,590
我们在整个​​使用
学期，typically--

131
00:05:27,590 --> 00:05:30,070
是你也可以只是说“让你好。”

132
00:05:30,070 --> 00:05:33,370
事实上，它说这完全取决于
迄今为止，因为它已经存在。

133
00:05:33,370 --> 00:05:37,860
让我继续前进，捞出，用
rm命令，这两个“的a.out” - 

134
00:05:37,860 --> 00:05:39,644
并说“删除普通文件a.out的？”

135
00:05:39,644 --> 00:05:41,810
这只是意味着，你
确定要删除吗？

136
00:05:41,810 --> 00:05:42,880
我会说是的。

137
00:05:42,880 --> 00:05:46,690
然后，我会删除
“你好”，而不是“hello.c的。”

138
00:05:46,690 --> 00:05:49,920
我会说“是”明确，
但“y”为足够，以及。

139
00:05:49,920 --> 00:05:52,140
>> 如果现在通知我
键入ls--其中，召回，

140
00:05:52,140 --> 00:05:55,540
意味着列表中 - 它列出了所有
在我的文件夹中的文件。

141
00:05:55,540 --> 00:05:57,850
事实上，如果我放大
出去看左上角，

142
00:05:57,850 --> 00:05:59,730
它证实了什么
此文件夹中，甚至

143
00:05:59,730 --> 00:06:04,990
虽然它在这里标注为IDE50
而不是工作空间，它只是“hello.c的。”

144
00:06:04,990 --> 00:06:09,152
所以，现在在这儿，如果我
执行“make你好”，回车，

145
00:06:09,152 --> 00:06:12,360
现在我看到一个更长的命令，但一
那将会更复杂的命令

146
00:06:12,360 --> 00:06:13,940
将在今后数周内有用。

147
00:06:13,940 --> 00:06:16,720
现在我可以说“./hello。”

148
00:06:16,720 --> 00:06:19,257
>> 因此，让我们快速浏览
一些其他的Linux命令。

149
00:06:19,257 --> 00:06:21,840
那么我们为什么不采取一步
回来居然看C的具体

150
00:06:21,840 --> 00:06:25,020
一般，从头开始转变
到C，然后总结了一下

151
00:06:25,020 --> 00:06:27,305
在第一个问题
在C设置的所有权利。

152
00:06:27,305 --> 00:06:30,430
所以我要继续前进，只是干净
我的工作区控制-L刚

153
00:06:30,430 --> 00:06:31,429
保持屏幕整洁。

154
00:06:31,429 --> 00:06:33,520
但是，没有功能
影响并非如此。

155
00:06:33,520 --> 00:06:35,820
>> 回想一下，我们已经看到
一些命令了。

156
00:06:35,820 --> 00:06:39,900
因此，我们已经看到了铿锵，通常你
不必手动执行了。

157
00:06:39,900 --> 00:06:41,650
我们将改用化妆。

158
00:06:41,650 --> 00:06:45,290
但是，我们也看到了LS，它显示了
在我的目录中的文件清单。

159
00:06:45,290 --> 00:06:48,750
现在为什么那里 - 有两家
现在的文件，“你好”和“hello.c的。”

160
00:06:48,750 --> 00:06:52,240
为什么会出现一个明星或
之后，“你好”星号？

161
00:06:52,240 --> 00:06:54,900
那是什么表示，基于
对我们在每周一看见？

162
00:06:54,900 --> 00:06:58,852

163
00:06:58,852 --> 00:07:00,400
你怎么看？

164
00:07:00,400 --> 00:07:02,742
什么是星意味着什么？

165
00:07:02,742 --> 00:07:04,614
>> 玛丽亚：For--节目“你好”？

166
00:07:04,614 --> 00:07:05,530
DAVID马兰：“你好*”。

167
00:07:05,530 --> 00:07:06,330
是啊。

168
00:07:06,330 --> 00:07:07,760
哦耶？

169
00:07:07,760 --> 00:07:08,639
哦，可执行。

170
00:07:08,639 --> 00:07:09,180
那就对了。

171
00:07:09,180 --> 00:07:10,890
这样就意味着
“你好”是可执行的。

172
00:07:10,890 --> 00:07:13,430
因此，我们确实，这就是为什么
我能做到“./hello。”

173
00:07:13,430 --> 00:07:13,930
好吧。

174
00:07:13,930 --> 00:07:15,179
所以，还有什么我可以做吗？

175
00:07:15,179 --> 00:07:17,290
嗯，事实证明，我可以
还创建目录。

176
00:07:17,290 --> 00:07:20,924
因此，让我继续前进，创造，
例如，一个“PSET1”目录中。

177
00:07:20,924 --> 00:07:23,590
而问题集规范
可以让你做的正是这一点，

178
00:07:23,590 --> 00:07:25,260
所以你不必今天记住。

179
00:07:25,260 --> 00:07:27,340
但“MKDIR PSET1”似乎
到没有影响。

180
00:07:27,340 --> 00:07:30,540
但同样，没有错误信息
通常是一件好事。

181
00:07:30,540 --> 00:07:34,060
所以，如果我输入“LS”now--啊，现在
我有一个名为可执行文件

182
00:07:34,060 --> 00:07:36,570
“你好，”一个C文件名为“hello.c的。”

183
00:07:36,570 --> 00:07:40,860
然后是斜线，所以
讲，意味着这是一个目录。

184
00:07:40,860 --> 00:07:42,510
>> 因此，我们确实，现在我要打开它。

185
00:07:42,510 --> 00:07:45,730
我不双击它像
在图形用户界面，图形环境。

186
00:07:45,730 --> 00:07:48,550
我不是说“CD PSET1。”

187
00:07:48,550 --> 00:07:49,640
输入。

188
00:07:49,640 --> 00:07:53,100
没有什么有趣的似乎有
除非发生了我的小提示

189
00:07:53,100 --> 00:07:57,300
这里 - 这是提醒Linux的方法
我我在哪里，所以哪个文件夹打开。

190
00:07:57,300 --> 00:08:00,080
这只是明确地告诉我，
相对于图形。

191
00:08:00,080 --> 00:08:05,100
如果我键入“ls”，为什么我看到另
立刻提示，你认为，

192
00:08:05,100 --> 00:08:07,269
当我列出PSET1的内容是什么？

193
00:08:07,269 --> 00:08:09,310
玛丽亚：你可能不
在有什么。

194
00:08:09,310 --> 00:08:09,630
DAVID马兰：是的。

195
00:08:09,630 --> 00:08:11,510
然后我们还没有明显
在那里创造了什么

196
00:08:11,510 --> 00:08:13,150
因为我刚刚创建的目录中。

197
00:08:13,150 --> 00:08:17,690
现在，如果我想创建一个file--为
例如，我可以创建一个新的文件。

198
00:08:17,690 --> 00:08:20,190
然后我会去
保存并保存为，

199
00:08:20,190 --> 00:08:23,090
像“mario.c”如果你正在做
PSET的一个标准版本。

200
00:08:23,090 --> 00:08:27,610
然后，像任何Mac或PC，只
选择文件夹“PSET1，保存。

201
00:08:27,610 --> 00:08:28,740
而现在的文件是空的。

202
00:08:28,740 --> 00:08:31,160
但是，让我们再次放大一秒钟。

203
00:08:31,160 --> 00:08:32,470
让我们在这里做的LS。

204
00:08:32,470 --> 00:08:34,470
现在我们看到的“mario.c”。

205
00:08:34,470 --> 00:08:37,850
>> 因此，有一些其他的命令
值得记住了时间 - 

206
00:08:37,850 --> 00:08:41,200
清除或控制-L是我所
被击中; MKDIR我们已经看到了;

207
00:08:41,200 --> 00:08:45,240
RM我们所看到的，还有，这是
去除或删除文件。

208
00:08:45,240 --> 00:08:49,310
当心你可以also--，如果你看看
在网上的教程，你将RM -rf

209
00:08:49,310 --> 00:08:52,630
是说一个很常见的方式
删除有东西在它的文件夹。

210
00:08:52,630 --> 00:08:54,280
只要是超级，超级小心。

211
00:08:54,280 --> 00:08:58,780
-rf意味着递归
删除不管它是什么

212
00:08:58,780 --> 00:09:01,150
你想删除
并强行将其删除。

213
00:09:01,150 --> 00:09:04,630
这样循环的手段，如果它是一个文件夹
与文件夹的文件夹的文件夹，

214
00:09:04,630 --> 00:09:05,690
删除所有的人。

215
00:09:05,690 --> 00:09:08,680
并强行手段甚至不
问我是或不是，我是肯定？

216
00:09:08,680 --> 00:09:11,960
所以这是一个超级危险方法
删除很多东西很快。

217
00:09:11,960 --> 00:09:17,210
但beware--往往做一个勇敢的
学生意外删除，也就是说，PSET

218
00:09:17,210 --> 00:09:18,000
1，例如。

219
00:09:18,000 --> 00:09:19,833
>> 玛丽亚：如果他们只是
做-r，他们会

220
00:09:19,833 --> 00:09:21,870
问他们的每一个文件。

221
00:09:21,870 --> 00:09:22,790
>> DAVID马兰：这是
适度烦人。

222
00:09:22,790 --> 00:09:23,480
>> 玛丽亚：是的。

223
00:09:23,480 --> 00:09:25,813
>> DAVID马兰：所以这就是为什么
我们这么多人，自包含，

224
00:09:25,813 --> 00:09:27,070
我在使用-rf的习惯。

225
00:09:27,070 --> 00:09:27,861
但它是危险的。

226
00:09:27,861 --> 00:09:29,010
因此，买家当心。

227
00:09:29,010 --> 00:09:31,050
然后，MV是怎么样的
有趣的命名。

228
00:09:31,050 --> 00:09:33,600
因此，这是移动命令，
这感觉有点怪异

229
00:09:33,600 --> 00:09:37,260
因为你的确可以用它来
从一个地方移动到另一个文件。

230
00:09:37,260 --> 00:09:39,970
举例来说，假设我搞砸了。

231
00:09:39,970 --> 00:09:43,660
假设我创建
一个新的文件处理器集。

232
00:09:43,660 --> 00:09:46,320
我将它保存为“greedy.c。”

233
00:09:46,320 --> 00:09:49,970
但是假设我不小心将它保存
在IDE50--所以在我区本身

234
00:09:49,970 --> 00:09:51,580
而不是在PSET1。

235
00:09:51,580 --> 00:09:53,960
>> 你可以看到尽可能多的左上方。

236
00:09:53,960 --> 00:09:55,284
有“greedy.c。”

237
00:09:55,284 --> 00:09:56,450
还有的几个解决方案。

238
00:09:56,450 --> 00:09:58,324
所以一个，我可以使用
超级用户友好的方式

239
00:09:58,324 --> 00:09:59,740
只是拖放。

240
00:09:59,740 --> 00:10:01,910
而这实际上
解决这个问题。

241
00:10:01,910 --> 00:10:04,967
但是今天，我们想看看
更神秘而强大的方式

242
00:10:04,967 --> 00:10:05,550
对这样做。

243
00:10:05,550 --> 00:10:07,880
因此，让我走“LS”的PSET1。

244
00:10:07,880 --> 00:10:09,690
而我只看到“mario.c。”

245
00:10:09,690 --> 00:10:13,450
让我继续前进，做“CD ..”。

246
00:10:13,450 --> 00:10:15,320
所以CD再次改变目录。

247
00:10:15,320 --> 00:10:18,130
“”是指什么有关系吗？

248
00:10:18,130 --> 00:10:21,100
上次我说：“CD
PSET1“进入PSET1。

249
00:10:21,100 --> 00:10:24,360
所以当我说“CD ..”，我在做什么？

250
00:10:24,360 --> 00:10:24,910
向后。

251
00:10:24,910 --> 00:10:25,150
是啊。

252
00:10:25,150 --> 00:10:26,750
>> 因此，这将所谓的父母。

253
00:10:26,750 --> 00:10:29,730
进入上一层，像
退出了一个文件夹中。

254
00:10:29,730 --> 00:10:30,500
所以输入。

255
00:10:30,500 --> 00:10:31,900
事实上，看看它的所作所为。

256
00:10:31,900 --> 00:10:37,070
这让我感动刚刚进入工作区，而不是
成PSET1，这是在工作区中。

257
00:10:37,070 --> 00:10:39,710
而现在，如果我输入“LS”
有一大堆的东西。

258
00:10:39,710 --> 00:10:41,650
在有“greedy.c”。

259
00:10:41,650 --> 00:10:48,720
所以，现在让我用MV来字面上
移动“greedy.c”到PSET1。

260
00:10:48,720 --> 00:10:51,120
所以很多Li​​nux命令
工作完全是这样。

261
00:10:51,120 --> 00:10:54,470
他们没有参数或者他们需要一
参数或他们采取两个命令行

262
00:10:54,470 --> 00:10:55,449
参数等等。

263
00:10:55,449 --> 00:10:57,240
在这种情况下，它的
从字面上做什么

264
00:10:57,240 --> 00:11:01,670
它说，尽管succinctly--
移动greedy.c到PSET1。

265
00:11:01,670 --> 00:11:02,310
输入。

266
00:11:02,310 --> 00:11:03,310
好像没有什么改变。

267
00:11:03,310 --> 00:11:06,180
但是，如果我再次做了LS，贪走了。

268
00:11:06,180 --> 00:11:12,437
如果我做“CD PSET1”，回车，然后
LS再次，现在是在正确的地方。

269
00:11:12,437 --> 00:11:14,270
顺便说一句，如果
一些reason--特别是

270
00:11:14,270 --> 00:11:16,194
如果你有间歇性
网络连接

271
00:11:16,194 --> 00:11:18,360
或者你走动
校园里与你的笔记本电脑的盖子

272
00:11:18,360 --> 00:11:20,180
关闭，然后打开它
再次和您的工作空间

273
00:11:20,180 --> 00:11:21,730
似乎有点不同步，没有什么大不了的。

274
00:11:21,730 --> 00:11:23,646
只需重新加载浏览器
窗口，它应

275
00:11:23,646 --> 00:11:26,339
重新同步，以使左侧
文件浏览器看上去完全

276
00:11:26,339 --> 00:11:27,380
如终端窗口。

277
00:11:27,380 --> 00:11:27,921
不用担心。

278
00:11:27,921 --> 00:11:31,460
如果有疑问，重新载入页面，所以
只要你已经保存的文件。

279
00:11:31,460 --> 00:11:31,960
好。

280
00:11:31,960 --> 00:11:34,710
因此MV也可用于重命名文件。

281
00:11:34,710 --> 00:11:36,760
让我们来看看
在这份最后的命令。

282
00:11:36,760 --> 00:11:39,950
所以suppose--并且这是
超级常见的，也很早。

283
00:11:39,950 --> 00:11:46,400
有些学生偶尔创建一个文件
所谓的，让我们say--什么别的？

284
00:11:46,400 --> 00:11:47,730
像“WATER.C。”

285
00:11:47,730 --> 00:11:51,080
所以，我就吆喝，为
没有任何理由，全部大写。

286
00:11:51,080 --> 00:11:53,190
但是这不是
正确的文件名，

287
00:11:53,190 --> 00:11:56,660
如果仅仅是因为我们的问题集
规范没有告诉你

288
00:11:56,660 --> 00:11:59,430
将文件保存为全部大写“WATER.C。”

289
00:11:59,430 --> 00:12:01,320
相反，我们预计
小写的“water.c”。

290
00:12:01,320 --> 00:12:03,140
而且，事实上，这是
问题的，因为check50，

291
00:12:03,140 --> 00:12:04,370
你要去一个程序
在的问题，以满足

292
00:12:04,370 --> 00:12:07,350
设置一个自动测试
你的代码的正确性

293
00:12:07,350 --> 00:12:11,615
是要骂你，如果它不能
发现在所有的小写字母“water.c”。

294
00:12:11,615 --> 00:12:12,712
>> 所以我需要解决这个问题。

295
00:12:12,712 --> 00:12:14,920
因此，许多不同的方式来
做到这一点，其中第一个

296
00:12:14,920 --> 00:12:18,330
需要控制或右键单击
文件名，只需要改变重命名。

297
00:12:18,330 --> 00:12:19,740
完全好这样做。

298
00:12:19,740 --> 00:12:21,820
但同样，今天，让我们
做一个小票友。

299
00:12:21,820 --> 00:12:26,680
让我们用MV来改变
“WATER.C”到“water.c”。

300
00:12:26,680 --> 00:12:30,690
所以，你还可以用第一个参数
将其重命名为第二个参数

301
00:12:30,690 --> 00:12:34,455
如果第二个参数是不是在
事实上，文件夹或目录名。

302
00:12:34,455 --> 00:12:35,120
>> 好吧。

303
00:12:35,120 --> 00:12:39,560
最后，一​​点点trick--所以我在
此刻我的工作区目录。

304
00:12:39,560 --> 00:12:43,660
如果我想进入PSET之一，
我当然可以键入“cd PSET1。”

305
00:12:43,660 --> 00:12:47,260
但它是如此繁琐的输入“PSET1”或
长文件名或目录名

306
00:12:47,260 --> 00:12:47,980
仍然。

307
00:12:47,980 --> 00:12:51,960
所以，很多时候在Linux中，有什么
你能做的就是开始输入“PSE”

308
00:12:51,960 --> 00:12:56,100
和刚刚获得无聊，打标签，并让
计算机数字出来给你。

309
00:12:56,100 --> 00:12:58,190
超级有助于进入这个习惯。

310
00:12:58,190 --> 00:13:01,079
唯一的缺点是，如果你有
启动多个文件或文件夹

311
00:13:01,079 --> 00:13:02,870
以字母“P”或
“PS”，你可能有

312
00:13:02,870 --> 00:13:05,525
键入前几个
电脑知道该怎么做。

313
00:13:05,525 --> 00:13:06,820
>> 玛丽亚：我们喜欢的快捷键。

314
00:13:06,820 --> 00:13:08,695
>> DAVID马兰：这将
为您节省了很多时间。

315
00:13:08,695 --> 00:13:11,930
而且，正如我们所说的讲座，你
可以在历史上滚动，上下，

316
00:13:11,930 --> 00:13:15,461
找最近执行
命令，以及。

317
00:13:15,461 --> 00:13:15,960
好吧。

318
00:13:15,960 --> 00:13:20,904
所以，现在，让我们把注意力转回
以一个简单的程序，你好世界。

319
00:13:20,904 --> 00:13:22,195
因此，我们完全编译这一点。

320
00:13:22,195 --> 00:13:24,050
而现在，我们为什么不拿
看看数据类型

321
00:13:24,050 --> 00:13:26,776
然后从一些过渡
相应的划痕块C.

322
00:13:26,776 --> 00:13:27,400
玛丽亚：真棒。

323
00:13:27,400 --> 00:13:30,031
所以，现在你已经开始
C语言编写程序，

324
00:13:30,031 --> 00:13:32,530
我们将开始讨论
有关数据类型和变量。

325
00:13:32,530 --> 00:13:37,570
因此，某些数据类型，你
想知道从现在开始

326
00:13:37,570 --> 00:13:39,400
是那些是
以蓝色突出显示。

327
00:13:39,400 --> 00:13:42,420
因此，我们有INT第一，
它代表的整数。

328
00:13:42,420 --> 00:13:46,075
而持有整数，因为你
可能具有guessed--所以1，2，3，

329
00:13:46,075 --> 00:13:47,950
和任何其它整数
你能想到的。

330
00:13:47,950 --> 00:13:48,730
>> DAVID马兰：而且也不利。

331
00:13:48,730 --> 00:13:50,220
>> 玛丽亚：而且还消极的，是的。

332
00:13:50,220 --> 00:13:51,450
和0。

333
00:13:51,450 --> 00:13:54,250
然后我们有花车，其中
是浮点数。

334
00:13:54,250 --> 00:13:58,360
所以这是所有的实数
有小数点。

335
00:13:58,360 --> 00:14:03,960
所以5.0，5.2，并且甚至更
小数点后的数字，

336
00:14:03,960 --> 00:14:05,620
同时，也是消极的。

337
00:14:05,620 --> 00:14:07,530
然后我们有焦炭这是一个字符。

338
00:14:07,530 --> 00:14:10,240
因此，我认为我们谈论
这在今天的讲座。

339
00:14:10,240 --> 00:14:15,682
但是，我们有字母，example-- A，
乙，C--可以存储作为char。

340
00:14:15,682 --> 00:14:18,390
但是，我们有更多的符号
可以存储为char。

341
00:14:18,390 --> 00:14:22,380
而这些被存储为ASCII。

342
00:14:22,380 --> 00:14:25,280
>> 然后我们有布尔，
这是布尔值。

343
00:14:25,280 --> 00:14:29,067
而那些评估为True或
假或1和0。

344
00:14:29,067 --> 00:14:31,650
DAVID马兰：重温使
布尔来自CS50库。

345
00:14:31,650 --> 00:14:33,300
所以，它没有内置到
C，但它的超级有用

346
00:14:33,300 --> 00:14:34,850
以具有真假的概念。

347
00:14:34,850 --> 00:14:36,990
而且即使你
可能think--有趣的事实。

348
00:14:36,990 --> 00:14:43,700
布尔技术上需要多少位，
确实，表示真与假？

349
00:14:43,700 --> 00:14:47,910
多少位，你认为
你需要，最大限度地？

350
00:14:47,910 --> 00:14:48,790
是啊，只有一个。

351
00:14:48,790 --> 00:14:52,077
所以，事实证明，Ç
不能给你只是一个位。

352
00:14:52,077 --> 00:14:54,160
度量的最小单位
你可以为8。

353
00:14:54,160 --> 00:14:57,090
所以这是一个有点浪费他们你
使用中的整个字节或八个比特，

354
00:14:57,090 --> 00:14:58,340
代表真或假。

355
00:14:58,340 --> 00:15:01,807
但是，这只是它的方式
由CS50库中实现C语言。

356
00:15:01,807 --> 00:15:04,890
玛丽亚：然后那些我们
不是要谈论的广泛

357
00:15:04,890 --> 00:15:08,060
右now--双，
这是更大的浮动。

358
00:15:08,060 --> 00:15:09,811
龙多空
还可用于整数。

359
00:15:09,811 --> 00:15:10,643
DAVID马兰：的确。

360
00:15:10,643 --> 00:15:13,190
在PSET一个黑客版，
我们实际使用很长很长。

361
00:15:13,190 --> 00:15:15,801
但对于标准版，
它不应该是必要的。

362
00:15:15,801 --> 00:15:16,300
玛丽亚：酷。

363
00:15:16,300 --> 00:15:17,361
好。

364
00:15:17,361 --> 00:15:20,110
所以operators--你应该
可能熟悉其中的大多数。

365
00:15:20,110 --> 00:15:22,620
此外，+;减法， - 。

366
00:15:22,620 --> 00:15:24,070
对于乘法，我们有*。

367
00:15:24,070 --> 00:15:25,900
所以不是在X，我们平时使用。

368
00:15:25,900 --> 00:15:27,840
事业部，我们有反斜杠。

369
00:15:27,840 --> 00:15:31,380
和模是我们最后的运算符
我们要谈论现在。

370
00:15:31,380 --> 00:15:35,610
这是一个运营商，使我们能够
拿一个除法的余数。

371
00:15:35,610 --> 00:15:40,630
因此，如果我们有4％2，4分
由图2是2用的0剩余部分。

372
00:15:40,630 --> 00:15:41,740
所以4％2为0。

373
00:15:41,740 --> 00:15:42,950
4％3是1。

374
00:15:42,950 --> 00:15:44,870
4％，5 4，你可能已经猜到了。

375
00:15:44,870 --> 00:15:48,860
请记住，当使用所有这些
经营者利用PEMDAS规则。

376
00:15:48,860 --> 00:15:54,060
>> DAVID马兰：所以要清楚，如果你
做4％2，为什么是0，到底是什么？

377
00:15:54,060 --> 00:15:57,480
>> 玛丽亚：因为4除以
图2是2用的0剩余部分。

378
00:15:57,480 --> 00:16:00,752
因此，模给我们，剩下的作为
反对分裂的结果。

379
00:16:00,752 --> 00:16:02,960
DAVID马兰：事实上，
我们会发现这是很有帮助的

380
00:16:02,960 --> 00:16:05,640
为是，在一些问题
这并不一定是，

381
00:16:05,640 --> 00:16:08,040
如果你想拥有
限制自己的作用

382
00:16:08,040 --> 00:16:10,720
一个数字范围
像0到的东西，

383
00:16:10,720 --> 00:16:13,904
您可以使用模环绕
早于像2十亿

384
00:16:13,904 --> 00:16:16,320
或四十亿值
我们已经谈到了讲座。

385
00:16:16,320 --> 00:16:16,870
>> 玛丽亚：是的。

386
00:16:16,870 --> 00:16:19,429
即使在“贪婪”我们可能。

387
00:16:19,429 --> 00:16:21,345
DAVID马兰：是的，在
问题集之一，也是如此。

388
00:16:21,345 --> 00:16:22,520
玛丽亚：是的，不错。

389
00:16:22,520 --> 00:16:24,340
DAVID马兰：好的暗示。

390
00:16:24,340 --> 00:16:25,750
玛丽亚：对不起。

391
00:16:25,750 --> 00:16:28,590
布尔expressions--所以
布尔型的操作，

392
00:16:28,590 --> 00:16:31,770
我们要谈的所有
这些是你在这里看到。

393
00:16:31,770 --> 00:16:35,310
所以现在，我们有两个
等号列出的平等。

394
00:16:35,310 --> 00:16:38,650
因此，这些都是进行比较。

395
00:16:38,650 --> 00:16:40,830
到目前为止，我们只看过一等号。

396
00:16:40,830 --> 00:16:44,870
这时候，我们分配
一个值的变量。

397
00:16:44,870 --> 00:16:50,160
因此，如果我们已经看到INT N = 5，则
我们给5到变量n。

398
00:16:50,160 --> 00:16:55,600
但是，如果我们想用==进行
相比之下，我们可以检查如果n == 5。

399
00:16:55,600 --> 00:16:58,310
而如果n == 5，那么这是真的。

400
00:16:58,310 --> 00:17:01,950
>> 所以布尔运算符
让我们，基本上，

401
00:17:01,950 --> 00:17:04,670
评估布尔
表达式为真或假。

402
00:17:04,670 --> 00:17:07,819
所以没有equals--我们有
感叹号和equals。

403
00:17:07,819 --> 00:17:14,240
因此，我们也可以查看如果n
不等于5--因此n！= 5。

404
00:17:14,240 --> 00:17:17,640
小于，小于或等于，
大于，大于或等于，

405
00:17:17,640 --> 00:17:20,720
然后我们有逻辑
与和逻辑或。

406
00:17:20,720 --> 00:17:24,060
而那些让我们能够评估
多个布尔表达式一起

407
00:17:24,060 --> 00:17:27,930
基本上走到一起
一个完整的布尔表达式。

408
00:17:27,930 --> 00:17:34,970
因此，如果我们想找到一个号码，说：
大于5但小于15

409
00:17:34,970 --> 00:17:39,810
与此同时，我们将使用
逻辑AND运算，以查看是否n是

410
00:17:39,810 --> 00:17:42,937
大于5 &&Ñ小于15。

411
00:17:42,937 --> 00:17:44,770
DAVID马兰：在这里，
同样，它真的很容易

412
00:17:44,770 --> 00:17:47,290
早早就意外
只使用一个单一的符号

413
00:17:47,290 --> 00:17:48,572
或单竖线。

414
00:17:48,572 --> 00:17:51,280
并希望编译器会
骂你，因为他们实际上

415
00:17:51,280 --> 00:17:52,530
具有非常不同的含义。

416
00:17:52,530 --> 00:17:55,660
对于那些好奇，他们是
用于位运算，

417
00:17:55,660 --> 00:17:57,197
操作上的各个位。

418
00:17:57,197 --> 00:17:58,780
但是，你想对他们在这里。

419
00:17:58,780 --> 00:18:01,560
和超级重要的是，
第一个，等号，

420
00:18:01,560 --> 00:18:05,270
这是运营商的平等作为
反对赋值运算符。

421
00:18:05,270 --> 00:18:08,552
>> 玛丽亚：与竖线
位于删除和收益之间。

422
00:18:08,552 --> 00:18:09,260
DAVID马兰：是的。

423
00:18:09,260 --> 00:18:11,420
在一个典型的美式键盘。

424
00:18:11,420 --> 00:18:13,190
>> 玛丽亚：是的。

425
00:18:13,190 --> 00:18:15,890
因此，让我们直接进入
条件语句。

426
00:18:15,890 --> 00:18:18,300
在刮，你
已经看到，大概，

427
00:18:18,300 --> 00:18:22,730
if语句，让您
检查如果事情是真的，那么

428
00:18:22,730 --> 00:18:23,660
做别的事情。

429
00:18:23,660 --> 00:18:28,410
所以，你可能会想
检查你的精灵是

430
00:18:28,410 --> 00:18:31,410
接触一些其他的精灵
或者你的屏幕边框。

431
00:18:31,410 --> 00:18:35,520
然后你可能会想
结束游戏或做其他事。

432
00:18:35,520 --> 00:18:40,000
这样的语法说
是“如果（条件）。”

433
00:18:40,000 --> 00:18:46,820
所以，如果你的精灵是感人的东西，
然后要做的就是花括号内。

434
00:18:46,820 --> 00:18:48,980
>> 然后我们有if-else语句。

435
00:18:48,980 --> 00:18:54,080
否则让我们做一些事情
如果条件我们

436
00:18:54,080 --> 00:18:55,870
在开始时检查是不正确的。

437
00:18:55,870 --> 00:19:01,530
因此，如果精灵的触摸
边境做到这一点，否则做其他的事情。

438
00:19:01,530 --> 00:19:04,030
因此，否则做别的事情。

439
00:19:04,030 --> 00:19:07,530
然后我们有一个简单的例子这一点。

440
00:19:07,530 --> 00:19:11,551
因此，如果（military_time <12），我们
想给printf“早上好！”

441
00:19:11,551 --> 00:19:13,300
否则我们将
printf的“晚上好！”

442
00:19:13,300 --> 00:19:14,860
基本的例子。

443
00:19:14,860 --> 00:19:15,680
>> DAVID马兰：好。

444
00:19:15,680 --> 00:19:16,760
>> 玛丽亚：酷。

445
00:19:16,760 --> 00:19:18,560
所以现在我们有switch语句。

446
00:19:18,560 --> 00:19:21,960
交换机一般都能发言
让我们做了很多同样的事情

447
00:19:21,960 --> 00:19:25,070
我们刚才讲
有关使用if语句。

448
00:19:25,070 --> 00:19:29,440
例如，现在我们有
switch语句的一般形式

449
00:19:29,440 --> 00:19:33,870
这使我们能够
一个变量调用ñ

450
00:19:33,870 --> 00:19:37,670
并比较了很多
不同的值，在这里我们

451
00:19:37,670 --> 00:19:40,010
呼吁CONSTANT1，CONSTANT2。

452
00:19:40,010 --> 00:19:41,150
我们可能有更多的。

453
00:19:41,150 --> 00:19:42,930
而那些被称为案件。

454
00:19:42,930 --> 00:19:46,280
>> 因此，如果我们有一个开关
statement--这个作品

455
00:19:46,280 --> 00:19:50,580
仅用于integers--我们有一个
变量在这种情况下n值。

456
00:19:50,580 --> 00:19:53,840
如果变量n是
等于CONSTANT1，我们

457
00:19:53,840 --> 00:19:59,720
将执行一些代码段
或者说，我们想要做的事情。

458
00:19:59,720 --> 00:20:01,280
然后我们将打破。

459
00:20:01,280 --> 00:20:04,820
因此，突破意味着，
switch语句

460
00:20:04,820 --> 00:20:08,120
将停止，如果执行
n等于CONSTANT1，

461
00:20:08,120 --> 00:20:09,752
然后你的程序将继续进行。

462
00:20:09,752 --> 00:20:11,835
这将退出的出
switch语句，它会

463
00:20:11,835 --> 00:20:13,520
继续做别的事情。

464
00:20:13,520 --> 00:20:17,204
>> 然而，如果n不等于
CONSTANT1，然后案例CONSTANT2

465
00:20:17,204 --> 00:20:17,870
将被检查。

466
00:20:17,870 --> 00:20:21,750
因此，如果n等于CONSTANT2，其他
的代码段会被执行。

467
00:20:21,750 --> 00:20:23,850
然后它会打破
如果这是等于它。

468
00:20:23,850 --> 00:20:27,580
然后我们就可以有also--不
不一定，though--默认的情况下，

469
00:20:27,580 --> 00:20:32,290
如果n不等于将发生
任何你所列举的案例。

470
00:20:32,290 --> 00:20:35,400
与在默认的情况下，我们还
不需要休息不一定

471
00:20:35,400 --> 00:20:39,271
因为switch语句就知道了
它需要的默认后结束

472
00:20:39,271 --> 00:20:40,270
情况下，如果是这样的话。

473
00:20:40,270 --> 00:20:42,140
>> DAVID马兰：但在风格上，
我们始终把它放在那里。

474
00:20:42,140 --> 00:20:42,540
>> 玛丽亚：是的。

475
00:20:42,540 --> 00:20:42,710
>> DAVID马兰：是的。

476
00:20:42,710 --> 00:20:44,750
因此，特别是在开始的时候了，
尤其是在那些较少

477
00:20:44,750 --> 00:20:47,458
舒服，我会亲自
只是建议坚持与IFS

478
00:20:47,458 --> 00:20:51,564
和IFS-别人的和的if-else-IF-别人的
等等，如果仅

479
00:20:51,564 --> 00:20:53,480
因为他们是一个小
更直接。

480
00:20:53,480 --> 00:20:56,142
这是一个很好的优化，或者
有时甚至是美学上它

481
00:20:56,142 --> 00:20:57,350
使得代码更易读。

482
00:20:57,350 --> 00:20:59,599
而事实上，可能
期中，我们将看到一个问题

483
00:20:59,599 --> 00:21:02,504
设置它只是看起来更好
并且更容易阅读的人

484
00:21:02,504 --> 00:21:03,670
通过使用switch语句。

485
00:21:03,670 --> 00:21:05,460
不过不要担心
执着于这个为时尚早。

486
00:21:05,460 --> 00:21:05,680
>> 玛丽亚：是的。

487
00:21:05,680 --> 00:21:08,840
如果你有if语句很多，
它可能只是不是很可读。

488
00:21:08,840 --> 00:21:10,965
它可能不是非常快
让你通过它。

489
00:21:10,965 --> 00:21:13,230
所以，sw​​itch语句可以
是非常有用的，也是如此。

490
00:21:13,230 --> 00:21:17,900
而且，不要remember--不
忘了把休息时间在那里。

491
00:21:17,900 --> 00:21:20,330
>> DAVID马兰：不记得这一点。

492
00:21:20,330 --> 00:21:24,890
>> 玛丽亚：因为这样你可能会下降
通过从一个案件到另一个。

493
00:21:24,890 --> 00:21:27,930
所以我们可以说这种情况下CONSTANT1
没有一个break语句在里面。

494
00:21:27,930 --> 00:21:31,920
然后，我们可能告吹
里面的情况CONSTANT2。

495
00:21:31,920 --> 00:21:35,070
同时，我们也不想这样做，如果
我们已经达到的情况下CONSTANT1

496
00:21:35,070 --> 00:21:37,830
它是等于n。

497
00:21:37,830 --> 00:21:45,100
>> 因此，例如，如果我们有一个可变
n表示包含一个类号，

498
00:21:45,100 --> 00:21:48,990
我们希望看到什么
如果n等于50级的is--，

499
00:21:48,990 --> 00:21:51,957
我们要打印“CS50是
计算机科学导论一。“

500
00:21:51,957 --> 00:21:53,040
然后，我们要打破。

501
00:21:53,040 --> 00:21:53,920
就是这样。

502
00:21:53,920 --> 00:21:55,950
然而，如果n等于
51，我们将

503
00:21:55,950 --> 00:21:58,494
打印“CS51是介绍
计算机科学II“。

504
00:21:58,494 --> 00:21:59,910
然后，再次，我们要打破。

505
00:21:59,910 --> 00:22:05,080
但是，如果那么我们就把124，61，任何
你可能会想其他的号码，

506
00:22:05,080 --> 00:22:06,890
或程序是不会
认识到这一点。

507
00:22:06,890 --> 00:22:09,010
因此，它会说，“对不起，我
不熟悉的类。“

508
00:22:09,010 --> 00:22:10,009
而这将打破。

509
00:22:10,009 --> 00:22:12,847
DAVID马兰：所以你真的可以看到
中频，否则的话，其他人的想法在这里。

510
00:22:12,847 --> 00:22:15,430
这只是不同的语法
表达完全相同的想法。

511
00:22:15,430 --> 00:22:17,690
>> 玛丽亚：没错。

512
00:22:17,690 --> 00:22:19,480
现在，我们有我们的三元运营商。

513
00:22:19,480 --> 00:22:24,900
因此，三元运营商
3 parts--的条件，

514
00:22:24,900 --> 00:22:27,220
事做，如果
该条件是真的，

515
00:22:27,220 --> 00:22:29,730
然后事做
如果该条件为假。

516
00:22:29,730 --> 00:22:33,400
所以你看，基本上，
的是，这里的语法。

517
00:22:33,400 --> 00:22:37,792
我们有问号，
那么the--我们怎么叫呢？

518
00:22:37,792 --> 00:22:38,750
DAVID马兰：结肠。

519
00:22:38,750 --> 00:22:39,100
玛丽亚：结肠。

520
00:22:39,100 --> 00:22:39,599
谢谢。

521
00:22:39,599 --> 00:22:41,880
抱歉。

522
00:22:41,880 --> 00:22:45,800
因此，让我们来看看我们的榜样
看看我们是否可以this--感

523
00:22:45,800 --> 00:22:47,840
class_num == 50。

524
00:22:47,840 --> 00:22:52,580
所以在这里，我们看到我们的布尔运算符==
用于比较变量class_num

525
00:22:52,580 --> 00:22:53,100
50。

526
00:22:53,100 --> 00:22:55,150
所以class_num存储的整数。

527
00:22:55,150 --> 00:22:58,180
如果该整数
等于50，那么我们

528
00:22:58,180 --> 00:23:02,810
将存储“大卫·马兰”
里面的字符串教授。

529
00:23:02,810 --> 00:23:05,912
如果班级人数不
等于50，“不是大卫·马兰”

530
00:23:05,912 --> 00:23:07,120
将是教授。

531
00:23:07,120 --> 00:23:08,630
>> DAVID马兰：谢谢。

532
00:23:08,630 --> 00:23:12,110
因此这似乎相当于
什么，你会说，乍一看？

533
00:23:12,110 --> 00:23:17,930

534
00:23:17,930 --> 00:23:19,960
>> 玛丽亚：对我来说，似乎
像if-else语句。

535
00:23:19,960 --> 00:23:20,709
>> DAVID马兰：是的。

536
00:23:20,709 --> 00:23:24,020
而事实上，这是一种
一个漂亮的单行的，

537
00:23:24,020 --> 00:23:27,520
可以这么说，对于实施
究竟逻辑的if-else

538
00:23:27,520 --> 00:23:29,010
但这样做的一切一步到位。

539
00:23:29,010 --> 00:23:29,860
>> 玛丽亚：没错。

540
00:23:29,860 --> 00:23:30,360
是啊。

541
00:23:30,360 --> 00:23:33,520
所以if-else语句可能
占用了大量的空间。

542
00:23:33,520 --> 00:23:36,283
他们可能是太长时间
一些简单不过的了。

543
00:23:36,283 --> 00:23:38,350
因此，这可以是非常
简洁，非常漂亮。

544
00:23:38,350 --> 00:23:40,880

545
00:23:40,880 --> 00:23:46,820
所以，现在我们正在进入观察
一次又一次地执行一些东西，

546
00:23:46,820 --> 00:23:50,060
所以检查的
条件多次

547
00:23:50,060 --> 00:23:53,510
然后继续做一些事情
而条件为真。

548
00:23:53,510 --> 00:23:56,740
因此，这给我们带来了
很好地进入while循环。

549
00:23:56,740 --> 00:23:59,270
>> 到左侧，我们有
我们的第一个while循环。

550
00:23:59,270 --> 00:24:03,840
因此，虽然事情是真的，
一次又一次地做一些事情。

551
00:24:03,840 --> 00:24:08,850
所以一定要注意，我们的
条件这里在顶部验证。

552
00:24:08,850 --> 00:24:14,150
而我们的我们称之为第二loop--
这一个做，而loop--我们做一些事情，

553
00:24:14,150 --> 00:24:15,890
然后我们检查的条件。

554
00:24:15,890 --> 00:24:17,980
如果该条件
仍然是真实的，

555
00:24:17,980 --> 00:24:20,150
我们再回去做的事。

556
00:24:20,150 --> 00:24:23,360
这样的主要区别是，其中
该条件检查。

557
00:24:23,360 --> 00:24:29,260
以及码可能永远
执行如果条件不

558
00:24:29,260 --> 00:24:30,430
真正的while循环。

559
00:24:30,430 --> 00:24:33,050
而随做，而
循环，我们有码

560
00:24:33,050 --> 00:24:35,380
即至少要执行一次。

561
00:24:35,380 --> 00:24:37,470
然后，当条件
仍然是真实的，

562
00:24:37,470 --> 00:24:39,960
我们可以回去里面再次重复。

563
00:24:39,960 --> 00:24:43,625
那么，为什么你认为我们会用
一个do-whil​​e循环在while循环？

564
00:24:43,625 --> 00:24:48,221

565
00:24:48,221 --> 00:24:48,720
对。

566
00:24:48,720 --> 00:24:52,600
因此，如果我们想提示的
用户对某种类型的输入，

567
00:24:52,600 --> 00:24:55,400
如果我们要问他们
输入他们的姓名，

568
00:24:55,400 --> 00:24:57,342
我们希望至少让他们一次。

569
00:24:57,342 --> 00:24:59,050
如果他们确实进入
这个名字，我们不

570
00:24:59,050 --> 00:25:00,740
又要问他们
因为我们已经知道了。

571
00:25:00,740 --> 00:25:02,656
但是如果它们不进入
他们的姓名，或如果他们

572
00:25:02,656 --> 00:25:05,787
进入东西是
显然不是一个名字，

573
00:25:05,787 --> 00:25:08,120
我们还是要继续
要求他们对自己的名字。

574
00:25:08,120 --> 00:25:10,710
>> DAVID马兰：而在演讲中，我们有一个
像这样的得到正INT

575
00:25:10,710 --> 00:25:13,550
例如，那里什么也没有到
首先检查一下，因为你甚至还没有

576
00:25:13,550 --> 00:25:14,190
得到一个int。

577
00:25:14,190 --> 00:25:16,680
所以我们想要做的this--
您可以通过user--一个int

578
00:25:16,680 --> 00:25:18,860
然后检查一下，也许，
一遍又一遍又一遍。

579
00:25:18,860 --> 00:25:21,030
>> 玛丽亚：没错。

580
00:25:21,030 --> 00:25:22,060
对于loops--确定。

581
00:25:22,060 --> 00:25:25,842
For循环可以让我们做的差不多
同样的事情，也是如此。

582
00:25:25,842 --> 00:25:27,300
它实际上是完全一样的东西。

583
00:25:27,300 --> 00:25:30,190
因此，有没有什么
您可以为循环做

584
00:25:30,190 --> 00:25:32,840
你将无法
做while循环。

585
00:25:32,840 --> 00:25:36,900
但对于循环可能看起来有点
更多的复杂语法

586
00:25:36,900 --> 00:25:39,730
因为它们具有
三个部分里面有什么

587
00:25:39,730 --> 00:25:42,990
是以前只是
条件与while循环。

588
00:25:42,990 --> 00:25:48,260
因此，第一个部分，你的大海，
最左边的，我们有“INT矮人= 0”。

589
00:25:48,260 --> 00:25:51,490
因此，这是我们
初始化我们的变量。

590
00:25:51,490 --> 00:25:55,210
>> 然后我们有一个分号
和“矮人<7”。

591
00:25:55,210 --> 00:25:57,100
因此，这是出
条件实际上是。

592
00:25:57,100 --> 00:26:00,170
所以，这就是我们将有
把刚刚在同时loop--

593
00:26:00,170 --> 00:26:01,880
“而矮人<7”。

594
00:26:01,880 --> 00:26:05,380
这里，云在
中间我们的for循环。

595
00:26:05,380 --> 00:26:07,190
因此，“dwaves <7”。

596
00:26:07,190 --> 00:26:11,350
然后，我们的最后一部分是“矮人++”
这就是我们更新我们的变量。

597
00:26:11,350 --> 00:26:15,470
所以，最重要的事情
要知道的是，这

598
00:26:15,470 --> 00:26:22,010
是要通过这个循环
七次并执行七次。

599
00:26:22,010 --> 00:26:24,020
因此，我们有七个
矮人，和他们都

600
00:26:24,020 --> 00:26:26,020
会说，“我在这里
帮你，白雪公主“

601
00:26:26,020 --> 00:26:28,860
因为他们已经准备好
帮助白雪公主。

602
00:26:28,860 --> 00:26:33,600
>> 随着while循环，我们会做
初始化和更新

603
00:26:33,600 --> 00:26:37,490
满足条件内，再次，但
之前或while循环中

604
00:26:37,490 --> 00:26:40,210
确保we--因为
我们总是需要的部分。

605
00:26:40,210 --> 00:26:42,835
因此，为了确保我们有
他们，我们会一直还增加他们

606
00:26:42,835 --> 00:26:44,580
上，只是没有在括号内。

607
00:26:44,580 --> 00:26:47,288
>> DAVID马兰：所以它看起来like--
在讲座中，例如，

608
00:26:47,288 --> 00:26:50,250
我几乎总是使用一样，我和
n和很无聊的变量。

609
00:26:50,250 --> 00:26:53,050
它看起来像您可以使用更多
巧妙地命名变量了。

610
00:26:53,050 --> 00:26:56,300
>> 玛丽亚：是的，它实际上是非常好的
使用多一点的描述变量

611
00:26:56,300 --> 00:26:59,400
因为特别是如果别人是
读你的代码 - 也许你是平地机

612
00:26:59,400 --> 00:27:00,940
或者如果你合作
与somebody--

613
00:27:00,940 --> 00:27:03,481
你要确保他们
了解你在做什么。

614
00:27:03,481 --> 00:27:05,750

615
00:27:05,750 --> 00:27:06,400
>> 好。

616
00:27:06,400 --> 00:27:11,435
因此，这是一件很funky--
for循环内的for循环。

617
00:27:11,435 --> 00:27:13,060
我不知道，如果我们之前已经看到了这一点。

618
00:27:13,060 --> 00:27:13,830
可能不会。

619
00:27:13,830 --> 00:27:17,750
但是，我们其实可以有this--
如此循环，而不是循环。

620
00:27:17,750 --> 00:27:25,130
所以想也许走没有人
我穿过这是怎么回事吗？

621
00:27:25,130 --> 00:27:28,240

622
00:27:28,240 --> 00:27:29,490
DAVID马兰：我要一刺。

623
00:27:29,490 --> 00:27:29,970
玛丽亚：酷。

624
00:27:29,970 --> 00:27:30,636
DAVID马兰：OK。

625
00:27:30,636 --> 00:27:34,690
因此，spoiler--我们要打印的东西
这是在底部右下角

626
00:27:34,690 --> 00:27:35,190
那里。

627
00:27:35,190 --> 00:27:35,450
>> 玛丽亚：对。

628
00:27:35,450 --> 00:27:35,710
是啊。

629
00:27:35,710 --> 00:27:38,043
>> DAVID马兰：所以我们刚刚
把该样品的输出存在。

630
00:27:38,043 --> 00:27:42,590
因此，我可以从推断
你是最上面的循环

631
00:27:42,590 --> 00:27:45,680
迭代行
最外层循环，可以这么说。

632
00:27:45,680 --> 00:27:48,107
而你遍历
列与最内层的循环。

633
00:27:48,107 --> 00:27:50,190
直观地，这
应该有希望才有意义

634
00:27:50,190 --> 00:27:52,070
因为性质
每一个我们所看到的节目

635
00:27:52,070 --> 00:27:55,570
之前，printf的，这是
功能我们使用，最终，

636
00:27:55,570 --> 00:27:58,190
有打印的东西的能力
出基本上逐行。

637
00:27:58,190 --> 00:27:59,960
象，一旦你输
一个新的生产线，有

638
00:27:59,960 --> 00:28:02,876
没有加倍背部和打印的东西
在屏幕更高，至少

639
00:28:02,876 --> 00:28:04,530
不是用printf这样。

640
00:28:04,530 --> 00:28:07,750
>> 所以在这方面，它使
某种意义上说，最外层循环

641
00:28:07,750 --> 00:28:10,930
应该是指各行
因为对于每个给定行，

642
00:28:10,930 --> 00:28:13,650
你会想
打印出XXXXX，然后

643
00:28:13,650 --> 00:28:15,520
移动到下一行，XXXXX。

644
00:28:15,520 --> 00:28:17,317
因此，行是第一位的。

645
00:28:17,317 --> 00:28:19,150
然后在每个
行，你打印的列。

646
00:28:19,150 --> 00:28:21,160
如果你想做到这一点
相反，它可能不会

647
00:28:21,160 --> 00:28:21,690
出来，你打算。

648
00:28:21,690 --> 00:28:22,190
>> 玛丽亚：是的。

649
00:28:22,190 --> 00:28:24,950
我们只是不能回去
上一行用printf的。

650
00:28:24,950 --> 00:28:27,658
>> DAVID马兰：这有什么有趣
按今天的大约范围聊天，

651
00:28:27,658 --> 00:28:31,600
实际上，是该行是一个int
该公司在最上面的循环声明。

652
00:28:31,600 --> 00:28:34,030
但是请注意，它仍然是
内部，可以这么说，

653
00:28:34,030 --> 00:28:35,982
大括号的
紧随其后，

654
00:28:35,982 --> 00:28:38,440
即使它不是技术上
在这些大括号内。

655
00:28:38,440 --> 00:28:41,750
因此，行范围为
代码片段的全部，

656
00:28:41,750 --> 00:28:44,690
两外循环内
与内循环的内部。

657
00:28:44,690 --> 00:28:48,050
但与此相反，在那里
是列在范围？

658
00:28:48,050 --> 00:28:49,810
可变列？

659
00:28:49,810 --> 00:28:51,310
是啊，只有在里面循环。

660
00:28:51,310 --> 00:28:54,280
这没关系，因为我们没有访问
它的花括号外面。

661
00:28:54,280 --> 00:28:57,280
我们所要做的就是打印出新
线在最后出现。

662
00:28:57,280 --> 00:28:58,670
所以，实际上是确定。

663
00:28:58,670 --> 00:29:03,740
>> 因此，这具有这样的效果，它看起来像，
的操作的三行和四列。

664
00:29:03,740 --> 00:29:04,370
>> 玛丽亚：对。

665
00:29:04,370 --> 00:29:06,270
所以首先我们通过我们的第一行。

666
00:29:06,270 --> 00:29:10,520
而就在我们的第一行，我们做的
四列的第一行内。

667
00:29:10,520 --> 00:29:11,980
因此，我们打印出四个X的。

668
00:29:11,980 --> 00:29:15,800
然后我们就可以退出循环，因为
我们已经印了四X的。

669
00:29:15,800 --> 00:29:17,100
我们打​​印新的生产线。

670
00:29:17,100 --> 00:29:19,920
然后我们经过
同样的过程两个行

671
00:29:19,920 --> 00:29:21,170
使一共有三个。

672
00:29:21,170 --> 00:29:23,530
>> DAVID马兰：而且值得注意的是
字体的只是一个假象，事实

673
00:29:23,530 --> 00:29:25,680
样品输出
似乎如此多高，

674
00:29:25,680 --> 00:29:27,520
好像还有更多
行比列。

675
00:29:27,520 --> 00:29:29,824
但它只是因为X
高度大于宽。

676
00:29:29,824 --> 00:29:32,740
这一切发生的事情有，
加上线之间的空白。

677
00:29:32,740 --> 00:29:33,281
>> 玛丽亚：对。

678
00:29:33,281 --> 00:29:34,792
凉。

679
00:29:34,792 --> 00:29:35,750
DAVID马兰：好的。

680
00:29:35,750 --> 00:29:39,830
因此，快速浏览一下问题集之一，
采取任何问题，然后宣布休会？

681
00:29:39,830 --> 00:29:40,330
好吧。

682
00:29:40,330 --> 00:29:43,164
因此，在问题设置一个，还有三个
主要挑战，大势所趋。

683
00:29:43,164 --> 00:29:44,955
但首先，你会发现
这个问题集

684
00:29:44,955 --> 00:29:47,900
说明书中，作为与许多
pset时，今年秋天，是要带你

685
00:29:47,900 --> 00:29:50,691
通过一些热身练习，
你指出了几个资源

686
00:29:50,691 --> 00:29:52,440
你可能会或可能
没见过了。

687
00:29:52,440 --> 00:29:54,440
例如，CS50
拥有一套短裤，

688
00:29:54,440 --> 00:29:56,481
这是短视频，
没有什么不同这一点，但该

689
00:29:56,481 --> 00:29:58,460
很话题specific--
也许五分钟，

690
00:29:58,460 --> 00:30:02,360
长度为10分钟的循环或
上条件或算法

691
00:30:02,360 --> 00:30:04,125
或更高版本的更多
先进的主题，也是如此。

692
00:30:04,125 --> 00:30:06,000
而我们一般嵌入
这些成难题

693
00:30:06,000 --> 00:30:07,950
集使学生
有哪些资源

694
00:30:07,950 --> 00:30:10,840
审查可能具有材料
已经来在演讲或部分。

695
00:30:10,840 --> 00:30:13,220
但是，这样一来它更集中
更在他们的指尖。

696
00:30:13,220 --> 00:30:15,928
>> 我们也往往在问题嵌入
集东西叫做演练。

697
00:30:15,928 --> 00:30:20,790
因此，几乎所有我做的例子
在讲座中，这里的舞台，我们也

698
00:30:20,790 --> 00:30:24,565
在已经拍摄的摄像头
推进更慢，

699
00:30:24,565 --> 00:30:28,760
更贴心的演练由我的
我的笔记本电脑的代码，一行行

700
00:30:28,760 --> 00:30:31,427
因此，在课堂上，我们经常会
脱脂通过某事或某人

701
00:30:31,427 --> 00:30:33,260
将与插
回答的一个问题。

702
00:30:33,260 --> 00:30:35,820
但它并不一定下沉
在每个人的观众。

703
00:30:35,820 --> 00:30:38,230
所以，你会发现代码走查
对于大部分的实施例

704
00:30:38,230 --> 00:30:40,950
我们在这里做演讲，让你
可以通过它按照自己的节奏走

705
00:30:40,950 --> 00:30:43,580
快退或快进或
完全跳过，如果你愿意的话。

706
00:30:43,580 --> 00:30:45,356
>> 经常会有一些
热身问题，这

707
00:30:45,356 --> 00:30:47,105
请你进行排序
强化这种材料

708
00:30:47,105 --> 00:30:50,250
并确保您舒适前
你继续处理器集的其余部分。

709
00:30:50,250 --> 00:30:51,700
然后，当然，
有处理器集本身。

710
00:30:51,700 --> 00:30:53,450
和的事情之一
我们很刻意

711
00:30:53,450 --> 00:30:57,202
做CS50是几乎每一个无趣
或智力无趣

712
00:30:57,202 --> 00:30:58,910
机械的步骤，
你可能需要做的

713
00:30:58,910 --> 00:31:00,519
几乎总是非常有据可查。

714
00:31:00,519 --> 00:31:03,560
在长期的过程中，我们将
开始提出更多的反问句

715
00:31:03,560 --> 00:31:06,187
像记得如何做这做那？

716
00:31:06,187 --> 00:31:08,520
但通常情况下，你会发现
该习题集给你

717
00:31:08,520 --> 00:31:10,269
通过力学
东西使

718
00:31:10,269 --> 00:31:14,160
有趣的，智力的挑战
最终都是留给你的学生。

719
00:31:14,160 --> 00:31:17,390
>> 随着中说，Zamyla，我们向他
不停地谈到今天的讲座，

720
00:31:17,390 --> 00:31:20,190
是我们长期的工作人员1
成员谁也持有演练

721
00:31:20,190 --> 00:31:24,520
像马里奥特定PSET问题
和贪婪，虽然不是水这一年。

722
00:31:24,520 --> 00:31:26,540
而且它是在那些
演练，她经常

723
00:31:26,540 --> 00:31:29,450
提供了一些提示和技巧
如何进行，从来没有告诉你

724
00:31:29,450 --> 00:31:31,810
到底该怎么做，但
rather--像的状态下，

725
00:31:31,810 --> 00:31:35,200
如果你will--给你至少一
几个想法，这样就看你的，

726
00:31:35,200 --> 00:31:37,830
最终，决定
如何接近他们。

727
00:31:37,830 --> 00:31:41,200
>> 玛丽亚：有点像一个高层次
逻辑的理解是什么

728
00:31:41,200 --> 00:31:42,220
我们要求你这样做。

729
00:31:42,220 --> 00:31:42,485
>> DAVID马兰：没错。

730
00:31:42,485 --> 00:31:44,190
而且，事实上，Zamyla的
演练旨在

731
00:31:44,190 --> 00:31:46,190
经常回答
在那里问到的问题

732
00:31:46,190 --> 00:31:48,610
我开始了，特别是当
这些长规格

733
00:31:48,610 --> 00:31:51,960
有点令人生畏给所有的文字
和图像，他们有他们。

734
00:31:51,960 --> 00:31:54,890
>> 所以water.c，你会发现
你已经完成后，

735
00:31:54,890 --> 00:31:56,920
实际上是相对简单的。

736
00:31:56,920 --> 00:31:58,882
绝对是一帮
你要一鼓作气

737
00:31:58,882 --> 00:32:01,840
靠在墙上你的头试图
弄清楚为什么它不编译

738
00:32:01,840 --> 00:32:03,450
或者为什么它没有运行正常。

739
00:32:03,450 --> 00:32:05,040
但是，一旦你完成
它，一旦你

740
00:32:05,040 --> 00:32:07,620
花一些时间与任何摔跤
那你可能有缺陷，

741
00:32:07,620 --> 00:32:09,490
你会发现，它的
在很短的程序。

742
00:32:09,490 --> 00:32:11,770
它可以在短短几分钟来完成
行代码，其中大部分

743
00:32:11,770 --> 00:32:15,030
我们在这里看到的讲座已经，如果
你组装正确的积木。

744
00:32:15,030 --> 00:32:16,810
>> 正如我们建议
在这里，它会问

745
00:32:16,810 --> 00:32:22,250
您可以指定多少分钟
有人走在校园里洗澡。

746
00:32:22,250 --> 00:32:24,779
我们在这个问题说明
设置流动水的速率

747
00:32:24,779 --> 00:32:27,320
在一样，低流量的淋浴
头，很像宋飞夹

748
00:32:27,320 --> 00:32:29,180
我们昨天看到或
相反物。

749
00:32:29,180 --> 00:32:30,971
然后你只需要
做数学了一下，

750
00:32:30,971 --> 00:32:34,710
用C来告诉really--算术
我们知道有多少，大概，瓶装水

751
00:32:34,710 --> 00:32:37,720
就是相当于，如果我们
采取一个n分钟的淋浴。

752
00:32:37,720 --> 00:32:41,389
>> 现在，在mario.c，这是去
要稍长程序。

753
00:32:41,389 --> 00:32:42,930
它仍然不会长期是这个。

754
00:32:42,930 --> 00:32:45,130
短短几行比water.c更长。

755
00:32:45,130 --> 00:32:48,230
但是，这将是机会
重现老同学马里奥

756
00:32:48,230 --> 00:32:50,670
从超级马里奥金字塔
兄弟或者一些后续。

757
00:32:50,670 --> 00:32:53,510
它不会看起来更漂亮
或者丰富多彩的作为一个人也没有。

758
00:32:53,510 --> 00:32:56,468
我们只是用很少的＃标签
像我们这里在屏幕上

759
00:32:56,468 --> 00:32:58,120
使用ASCII文本。

760
00:32:58,120 --> 00:33:00,362
但是，这将接近同样的想法。

761
00:33:00,362 --> 00:33:02,570
而且这将是一个
锻炼第一眼

762
00:33:02,570 --> 00:33:04,720
似乎只是很simple--
打印一个简单的金字塔。

763
00:33:04,720 --> 00:33:07,345
但是，有一对夫妇的特点
在这里，很有意思。

764
00:33:07,345 --> 00:33:12,400
请注意，最右边边缘
金字塔实际上有宽度两种。

765
00:33:12,400 --> 00:33:14,570
因此，有两个相等
身高列，这

766
00:33:14,570 --> 00:33:16,804
使得它需要一点点
思想位，使

767
00:33:16,804 --> 00:33:19,720
确保你得到了完全正确的，因为
而不仅仅是一个完美的角度的

768
00:33:19,720 --> 00:33:20,220
线。

769
00:33:20,220 --> 00:33:23,340
所以这是一个有点角落案件
但比赛的实际比赛。

770
00:33:23,340 --> 00:33:27,610
>> 而且，这也是非显而易见的，在第一
一目了然如何打印空白。

771
00:33:27,610 --> 00:33:29,430
所以，当我看
示例输出这里 - 

772
00:33:29,430 --> 00:33:32,440
而且它也是在spec--它
那种看起来像一个矩形，

773
00:33:32,440 --> 00:33:35,120
但一个对角线的
矩形已经砍掉了，

774
00:33:35,120 --> 00:33:37,320
它只是空格，可以这么说。

775
00:33:37,320 --> 00:33:40,100
所以，一个经常被问到的
这里的问题是一如既往的好，

776
00:33:40,100 --> 00:33:43,302
我怎么动的＃标签
到正确的？

777
00:33:43,302 --> 00:33:44,760
或者，我怎么打印空白？

778
00:33:44,760 --> 00:33:46,860
它实际上更容易
比大多数学生认为。

779
00:33:46,860 --> 00:33:47,360
对？

780
00:33:47,360 --> 00:33:51,620
你可以通过可视化地接近它
按下空格键一次或两次

781
00:33:51,620 --> 00:33:52,700
或三次。

782
00:33:52,700 --> 00:33:56,260
>> 因此，即使与我们的printf几乎
总是打印出一个字符串或一个int

783
00:33:56,260 --> 00:33:59,950
或者像“你好一句话，
世界“或一系列字的，

784
00:33:59,950 --> 00:34:03,560
你也可以只打印
报价，空间，引文结束。

785
00:34:03,560 --> 00:34:06,320
这实际上给
你一个空格那里。

786
00:34:06,320 --> 00:34:08,330
所以记住这一点，并
不overthink这一点。

787
00:34:08,330 --> 00:34:10,570
你真的要
决定逐行逐行，

788
00:34:10,570 --> 00:34:14,280
没有什么不同的例子
刚才，有多少的

789
00:34:14,280 --> 00:34:18,420
列应该是白色的空间和
有多少人应该是井号标签。

790
00:34:18,420 --> 00:34:21,560
这将需要一些时间，但它的
各种各样最终逻辑谜题。

791
00:34:21,560 --> 00:34:22,060
>> 玛丽亚：是的。

792
00:34:22,060 --> 00:34:25,060
但再逐行逻辑
是要在这里是非常有用的。

793
00:34:25,060 --> 00:34:25,810
DAVID马兰：是的。

794
00:34:25,810 --> 00:34:28,976
我想示例代码，你gave--甚至
虽然这不是一个完整的程序。

795
00:34:28,976 --> 00:34:34,247
您还需要int和主
和无效的和的#include stdio.h中，

796
00:34:34,247 --> 00:34:35,580
很多从演讲的东西。

797
00:34:35,580 --> 00:34:37,629
但积木
似乎是在那里。

798
00:34:37,629 --> 00:34:39,920
然后最后是什么
多一点的算法。

799
00:34:39,920 --> 00:34:43,210
所以，事实证明，任何时候你
进入CVS或便利店

800
00:34:43,210 --> 00:34:47,810
有人递给你的
出纳票据或硬币的变化，

801
00:34:47,810 --> 00:34:50,620
事实证明，他们，人类，
不管他们是否意识到这一点，

802
00:34:50,620 --> 00:34:53,300
可能正在使用什么
所谓的贪婪算法，

803
00:34:53,300 --> 00:34:58,170
因此，如果你欠，说，$ 21日
在变化，因为出于某种原因

804
00:34:58,170 --> 00:35:01,580
你买东西很便宜
与CVS的一个非常大的法案，

805
00:35:01,580 --> 00:35:05,910
这将是非常烦人，如果
收银员给你21单曲，更有甚者

806
00:35:05,910 --> 00:35:07,629
然而，一大堆硬币。

807
00:35:07,629 --> 00:35:10,670
相反，什么是合理的人
可能要做的是他们要去

808
00:35:10,670 --> 00:35:14,224
抢$ 20，然后$ 1钞票，和
交给你只有两个法案在这种情况下。

809
00:35:14,224 --> 00:35:17,390
玛丽亚：所以他们正在寻求减少
他们给回你的变化。

810
00:35:17,390 --> 00:35:17,850
DAVID马兰：没错。

811
00:35:17,850 --> 00:35:19,540
而同样的处理硬币，以及。

812
00:35:19,540 --> 00:35:23,040
如果你欠，说，$ 0.50，
希望你不想要50便士。

813
00:35:23,040 --> 00:35:25,500
你不是想要两个
宿舍，例如。

814
00:35:25,500 --> 00:35:27,540
现在，这确实承担
该出纳员具有

815
00:35:27,540 --> 00:35:29,940
足够的每一个教派的
他或她可能想给你。

816
00:35:29,940 --> 00:35:32,148
但是，我们让你承担
尽可能多的问题。

817
00:35:32,148 --> 00:35:35,590
和目标，最终是
在C代码实现贪心算法。

818
00:35:35,590 --> 00:35:37,344
因此用户被允许
在键入多少

819
00:35:37,344 --> 00:35:40,510
改变他或她是欠与美元
而仙，某种浮点

820
00:35:40,510 --> 00:35:41,590
值可能。

821
00:35:41,590 --> 00:35:45,530
然后你需要做的数学和
弄清楚算法，好了，

822
00:35:45,530 --> 00:35:49,020
有多少硬币，我可以给
你最少给你

823
00:35:49,020 --> 00:35:50,270
正是这样的变化量。

824
00:35:50,270 --> 00:35:53,470
但是，将是一个
这里几个棘手的部分，对吧？

825
00:35:53,470 --> 00:35:56,236
像有全
不准确的问题。

826
00:35:56,236 --> 00:35:56,860
玛丽亚：没错。

827
00:35:56,860 --> 00:35:59,114
因此，浮点
值具有不精确。

828
00:35:59,114 --> 00:36:00,780
难道我们谈论这个讲座的今天？

829
00:36:00,780 --> 00:36:02,340
>> DAVID马兰：我们做了
最后一次演讲。

830
00:36:02,340 --> 00:36:03,506
我们谈论的不精确性。

831
00:36:03,506 --> 00:36:08,840
而你不想欺骗用户
多少变化，他或她是欠。

832
00:36:08,840 --> 00:36:11,290
这样一来，演练，在
问题设置规范，

833
00:36:11,290 --> 00:36:15,990
想一想，最终以
你如何减轻这些不精确

834
00:36:15,990 --> 00:36:17,280
错误，有可能。

835
00:36:17,280 --> 00:36:21,050
这是可以避免的，当然，对于
我们谈论的投入。

836
00:36:21,050 --> 00:36:23,590
而且，事实上，pennies--
也许我们会推迟到Zamyla，

837
00:36:23,590 --> 00:36:25,136
我想，对于花样那里。

838
00:36:25,136 --> 00:36:27,760
所以，最后，你会发现一个
问题的进展，本周，

839
00:36:27,760 --> 00:36:30,700
其中第一个是非常小的，
然后介质，然后一点点大。

840
00:36:30,700 --> 00:36:33,200
但是，所有的人都使用的建筑
从过去的这个星期块，

841
00:36:33,200 --> 00:36:35,280
从这个超部分，
问题设置规范

842
00:36:35,280 --> 00:36:36,710
让你在无数的资源。

843
00:36:36,710 --> 00:36:41,000
但尽管如此，如果在所有挣扎，
尤其是那些不舒服

844
00:36:41,000 --> 00:36:42,917
没有事先的背景下，
来到办公时间

845
00:36:42,917 --> 00:36:44,958
在周一和周二和
周三和周四。

846
00:36:44,958 --> 00:36:46,950
进入CS50通过讨论
课程的网站，

847
00:36:46,950 --> 00:36:49,080
通过它，你可以聊天
与工作人员和同学们。

848
00:36:49,080 --> 00:36:51,670
>> 但最终，我认为，
最好的建议是刚刚起步早。

849
00:36:51,670 --> 00:36:54,711
它不是那种类的，你
要在周三开始的pset

850
00:36:54,711 --> 00:36:56,640
晚上，或者更糟糕的周四晚上。

851
00:36:56,640 --> 00:36:59,067
>> 玛丽亚：我最好的建议是
已经开始在星期一。

852
00:36:59,067 --> 00:36:59,900
DAVID马兰：周一。

853
00:36:59,900 --> 00:37:02,490
所以，如果你还没有开始already--没有。

854
00:37:02,490 --> 00:37:04,732
但是，即使没有星期一，然后周二。

855
00:37:04,732 --> 00:37:05,690
越早越好。

856
00:37:05,690 --> 00:37:08,605
而这就是原因
当然，有这么多晚天

857
00:37:08,605 --> 00:37:10,535
给你一个有点
心理压力

858
00:37:10,535 --> 00:37:13,684
应尽早开始，但仍让
事情滑，当事情需要更长的时间

859
00:37:13,684 --> 00:37:14,350
比您预期的。

860
00:37:14,350 --> 00:37:17,950
>> 玛丽亚：你想利用
办公时间尽量您也可以做到。

861
00:37:17,950 --> 00:37:20,291
>> DAVID马兰：有什么问题？

862
00:37:20,291 --> 00:37:20,790
好吧。

863
00:37:20,790 --> 00:37:22,930
那么，我们为什么不这里休会？

864
00:37:22,930 --> 00:37:23,487