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

2
00:00:09,572 --> 00:00:12,030
ROB Боудън: Здравейте, аз съм Роб Боудън,
и нека да говорим за quiz0.

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

4
00:00:13,280 --> 00:00:14,545
>> Така че, на първо място въпрос.

5
00:00:14,545 --> 00:00:17,750
Това е въпрос, по който
ви е необходимо, за да кодира броя

6
00:00:17,750 --> 00:00:21,270
127 в двоичен крушки.

7
00:00:21,270 --> 00:00:23,550
Ако искате, бихте могли да
направи редовен превръщането

8
00:00:23,550 --> 00:00:25,950
от bi-- или от десетична към двоична.

9
00:00:25,950 --> 00:00:28,300
Но това е най-вероятно ще
да отнеме много време.

10
00:00:28,300 --> 00:00:31,750
Искам да кажа, бихте могли да разберете, че
OK, един е в там, 2 е там,

11
00:00:31,750 --> 00:00:33,650
4 е там, 8 е там.

12
00:00:33,650 --> 00:00:39,280
По-лесен начин, 127 е 128 минус един.

13
00:00:39,280 --> 00:00:42,013
Това най-лявата крушка е на 128-бита.

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

15
00:00:43,490 --> 00:00:47,860
Така че 127 е наистина просто всички
от другите крушки,

16
00:00:47,860 --> 00:00:51,420
тъй като това е най-левият
крушка минус 1.

17
00:00:51,420 --> 00:00:52,800
Това е всичко за този въпрос.

18
00:00:52,800 --> 00:00:54,060
>> Въпрос един.

19
00:00:54,060 --> 00:00:56,710
Така с 3 бита можете
представляват 8 различни стойности.

20
00:00:56,710 --> 00:01:01,000
Защо, тогава, е 7, най-големият не-отрицателни
десетичната число може да представлява?

21
00:01:01,000 --> 00:01:04,050
Е, ако ние само може да
представляват 8 различни ценности,

22
00:01:04,050 --> 00:01:07,430
След това, което ще бъде
представлява 0 до 7.

23
00:01:07,430 --> 00:01:08,745
0 заема една от ценностите.

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

25
00:01:09,980 --> 00:01:11,190
>> Въпрос две.

26
00:01:11,190 --> 00:01:14,610
С п бита, колко важно
стойности може да ви представляват?

27
00:01:14,610 --> 00:01:19,080
Така че, с п бита, имате 2
възможните стойности за всеки бит.

28
00:01:19,080 --> 00:01:22,300
Така че ние имаме две възможни стойности за
Първият бит, два възможни стойности

29
00:01:22,300 --> 00:01:24,450
за втората, 2
възможно за трети.

30
00:01:24,450 --> 00:01:28,730
И така, това е два пъти по 2 пъти 2, и
в крайна сметка отговорът е 2 до п.

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

32
00:01:30,010 --> 00:01:31,100
>> Въпрос три.

33
00:01:31,100 --> 00:01:33,450
Какво е 0x50 в двоичен?

34
00:01:33,450 --> 00:01:39,490
Така че не забравяйте, че шестнадесетичен има много
ясно превръщане в двоичен.

35
00:01:39,490 --> 00:01:43,180
Така че тук, ние просто трябва да се търси в
5 и 0 самостоятелно.

36
00:01:43,180 --> 00:01:45,110
Така че това, което е 5 в двоичен?

37
00:01:45,110 --> 00:01:48,400
0101, че е бит 1 и 4 бита.

38
00:01:48,400 --> 00:01:49,900
Какво е 0 в двоичен?

39
00:01:49,900 --> 00:01:50,520
Не е трудно.

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

41
00:01:52,180 --> 00:01:54,970
Така че просто ги съберете заедно, и
това е пълният брой в двоичен.

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

43
00:01:57,640 --> 00:02:00,439
И ако искате бихте могли
излитане, че лявата нула.

44
00:02:00,439 --> 00:02:01,105
Това е без значение.

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

46
00:02:02,920 --> 00:02:05,733
>> Така че след като алтернатива,
какво е 0x50 в десетична?

47
00:02:05,733 --> 00:02:08,649
Ако искате, можете could-- ако сте
по-удобно с двоичен,

48
00:02:08,649 --> 00:02:11,340
можеш да вземеш, че двоичен отговор
и конвертирате, че в десетични.

49
00:02:11,340 --> 00:02:13,870
Или бихме могли просто да си спомня
че в шестнадесетичен вид.

50
00:02:13,870 --> 00:02:21,140
Така, че 0 е в 0-о място, и
5 е в 16 на първо място.

51
00:02:21,140 --> 00:02:25,990
Така че тук, ние имаме 5 пъти 16 към
Първо, плюс 0 пъти 16 към нула,

52
00:02:25,990 --> 00:02:27,520
е 80.

53
00:02:27,520 --> 00:02:29,710
И ако ви погледна
заглавие на въпроса,

54
00:02:29,710 --> 00:02:32,920
е CS 80, което е вид
намек за отговора на този проблем.

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

56
00:02:34,460 --> 00:02:35,420
>> Въпрос пет.

57
00:02:35,420 --> 00:02:40,320
Ние имаме този Scratch скрипт, който е
повтаря 4 пъти фъстъчено масло желе.

58
00:02:40,320 --> 00:02:42,800
И така, как ще правим сега код, че в C?

59
00:02:42,800 --> 00:02:47,730
Е, ние имаме here-- частта с удебелен шрифт
е само частта, която трябваше да изпълни.

60
00:02:47,730 --> 00:02:51,950
Така че ние имаме 4 линия, която е примка 4
пъти, ФОРМАТ-Ing фъстъчено масло желе,

61
00:02:51,950 --> 00:02:53,910
с нов ред, тъй като проблемът изисква.

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

63
00:02:55,250 --> 00:02:57,490
>> Въпрос шест, друг Scratch проблем.

64
00:02:57,490 --> 00:03:00,210
Ние виждаме, че ние сме в завинаги контур.

65
00:03:00,210 --> 00:03:05,000
Ние казвате променливата I
и след това се увеличаване и с 1.

66
00:03:05,000 --> 00:03:09,580
Сега искаме да направим това в C. Има
множество начини, които биха могли да са направили това.

67
00:03:09,580 --> 00:03:12,840
Тук ще се случи с Кодекса на
завинаги контур като докато (вярно).

68
00:03:12,840 --> 00:03:16,600
Така че ние декларираме променливата аз, просто
като имахме променлива и в Scratch.

69
00:03:16,600 --> 00:03:21,950
Декларирайте променлива I, и завинаги
докато (вярно), ние казваме променливата аз.

70
00:03:21,950 --> 00:03:25,260
Така ФОРМАТ% i-- или бихте могли да сте използвали% г.

71
00:03:25,260 --> 00:03:27,985
Ние казваме, че променлива, и
след това нарастване, аз ++.

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

73
00:03:29,560 --> 00:03:30,830
>> Въпрос седем.

74
00:03:30,830 --> 00:03:35,560
Сега искаме да направим нещо много подобно
Марио точка в от проблем зададете една.

75
00:03:35,560 --> 00:03:39,110
Искаме да отпечатате тези Hashtags,
искаме да отпечатате пет

76
00:03:39,110 --> 00:03:40,700
от три правоъгълник от тези хешове.

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

78
00:03:41,770 --> 00:03:43,162
И така, как ние ще направим това?

79
00:03:43,162 --> 00:03:45,370
Е, ние ще ви даде цялата
куп код, а ти просто

80
00:03:45,370 --> 00:03:47,560
трябва да попълните във функцията за печат решетка.

81
00:03:47,560 --> 00:03:49,540
>> Така че това, което се PrintGrid изглежда?

82
00:03:49,540 --> 00:03:51,480
Ами вие сте миналото
ширина и височина.

83
00:03:51,480 --> 00:03:53,520
Така че ние имаме един външен 4
линия, която е примка

84
00:03:53,520 --> 00:03:57,650
над всички редове на това
мрежа, която ние искаме да разпечатате.

85
00:03:57,650 --> 00:04:01,250
Тогава ние имаме между вложени 4 цикъла,
това е печат върху всяка колона.

86
00:04:01,250 --> 00:04:06,210
Така че за всеки ред се печатат за
всяка колона, един хашиш.

87
00:04:06,210 --> 00:04:10,045
След това в края на редицата ние отпечатате
Един нов ред за да отидете на следващия ред.

88
00:04:10,045 --> 00:04:11,420
И това е за цялата мрежа.

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

90
00:04:12,810 --> 00:04:13,675
>> Въпрос осем.

91
00:04:13,675 --> 00:04:17,170
A функция като PrintGrid се казва, че
имат страничен ефект, но не и връщане

92
00:04:17,170 --> 00:04:17,670
стойност.

93
00:04:17,670 --> 00:04:19,209
Обяснете разликата.

94
00:04:19,209 --> 00:04:23,080
Така че това зависи от вас си спомни
това, което е страничен ефект е.

95
00:04:23,080 --> 00:04:25,180
Е, връщане value--
знаем PrintGrid не

96
00:04:25,180 --> 00:04:28,180
има връщане стойност, тъй като
точно тук се казва невалидни.

97
00:04:28,180 --> 00:04:31,150
Така че всичко, което се връща невалидни
наистина не върне нищо.

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

99
00:04:32,200 --> 00:04:33,620
Така че това, което е страничен ефект?

100
00:04:33,620 --> 00:04:36,620
Е, страничен ефект е
нищо, че нещо продължава

101
00:04:36,620 --> 00:04:39,500
след края на функционални
това не беше просто се върна,

102
00:04:39,500 --> 00:04:41,340
и това не е само от входовете.

103
00:04:41,340 --> 00:04:44,970
>> Така, например, бихме могли
промени глобална променлива.

104
00:04:44,970 --> 00:04:46,590
Това щеше да е страничен ефект.

105
00:04:46,590 --> 00:04:49,000
В този конкретен случай,
много важен страничен ефект

106
00:04:49,000 --> 00:04:51,070
отпечатва на екрана.

107
00:04:51,070 --> 00:04:53,110
Така че това е страничен ефект
че PrintGrid има.

108
00:04:53,110 --> 00:04:54,980
Ние отпечатайте тези неща на екрана.

109
00:04:54,980 --> 00:04:56,370
И можеш да се сетиш
че като страничен ефект,

110
00:04:56,370 --> 00:04:58,690
тъй като това е нещо, което
продължава след края на тази функция.

111
00:04:58,690 --> 00:05:01,481
Това е нещо, извън обхвата
на тази функция, която в крайна сметка

112
00:05:01,481 --> 00:05:03,380
се променила,
съдържанието на екрана.

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

114
00:05:05,200 --> 00:05:05,839
>> Въпрос девет.

115
00:05:05,839 --> 00:05:07,880
Помислете за програмата по-долу,
за кои договорени номера

116
00:05:07,880 --> 00:05:09,740
са добавени за
името на дискусия.

117
00:05:09,740 --> 00:05:13,480
Така че в тази програма, ние сме просто
призовава GetString, го приберете

118
00:05:13,480 --> 00:05:16,220
В тези променливи S, и след това
отпечатване на тази променлива и.

119
00:05:16,220 --> 00:05:16,720
OK.

120
00:05:16,720 --> 00:05:19,090
Така обясни защо първа линия е налице.

121
00:05:19,090 --> 00:05:20,920
#include cs50 точка ч.

122
00:05:20,920 --> 00:05:23,820
Защо ние трябва да #include cs50 точка з?

123
00:05:23,820 --> 00:05:26,180
Ами ние се обаждате на
GetString функция,

124
00:05:26,180 --> 00:05:28,840
и GetString се определя
в cs50 библиотеката.

125
00:05:28,840 --> 00:05:31,600
Така че, ако ние не разполагаме с
#include cs50 точка з,

126
00:05:31,600 --> 00:05:35,760
ние ще се получи, че имплицитно декларация
на грешка GetString функция

127
00:05:35,760 --> 00:05:36,840
от компилатора.

128
00:05:36,840 --> 00:05:40,110
Така че ние трябва да се включи library--
ние трябва да включва заглавната част на файла,

129
00:05:40,110 --> 00:05:42,870
или в противен случай компилаторът не ще
признае, че GetString съществува.

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

131
00:05:44,380 --> 00:05:46,140
>> Обяснете защо втора линия е налице.

132
00:05:46,140 --> 00:05:47,890
Така стандарт IO точка ч.

133
00:05:47,890 --> 00:05:50,430
Това е точно същото,
като предходната задача,

134
00:05:50,430 --> 00:05:53,310
с изключение вместо да се занимават с
GetString, ние не говорим за ФОРМАТ.

135
00:05:53,310 --> 00:05:56,654
Така че, ако ние не казваме, че трябва
да включват стандартни IO точка з,

136
00:05:56,654 --> 00:05:58,820
тогава ние не ще бъде в състояние
За да използвате функцията ФОРМАТ,

137
00:05:58,820 --> 00:06:00,653
защото компилаторът
няма да знаят за него.

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

139
00:06:01,750 --> 00:06:05,260
>> Why-- какво е значението
на анулира в съответствие с четири?

140
00:06:05,260 --> 00:06:08,010
Така че тук имаме INT главната (недействителни).

141
00:06:08,010 --> 00:06:10,600
Това е просто казвам, че ние
не се получава никакви командния ред

142
00:06:10,600 --> 00:06:12,280
аргументи на Майн.

143
00:06:12,280 --> 00:06:17,390
Не забравяйте, че ние може да се каже инт
Основните INT argc струнен argv скоби.

144
00:06:17,390 --> 00:06:20,400
Така че тук ние просто кажем нищожен да кажем,
пренебрегваме аргументи от командния ред.

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

146
00:06:21,840 --> 00:06:25,225
>> Обяснете, по отношение на паметта, точно
какво GetString в съответствие шест възвръщаемост.

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

148
00:06:27,040 --> 00:06:31,640
GetString се завръща блок
памет, набор от символи.

149
00:06:31,640 --> 00:06:34,870
Това е наистина връщане на
указател към първия символ.

150
00:06:34,870 --> 00:06:37,170
Не забравяйте, че низ е знак звезда.

151
00:06:37,170 --> 00:06:41,360
Така и е указател към първа
герой в каквато и да е низ е

152
00:06:41,360 --> 00:06:43,510
че потребителят влезе в клавиатурата.

153
00:06:43,510 --> 00:06:47,070
И този спомен се случва да бъде malloced,
така, че паметта е в купчината.

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

155
00:06:49,080 --> 00:06:50,450
>> Въпрос 13.

156
00:06:50,450 --> 00:06:51,960
Помислете за програмата по-долу.

157
00:06:51,960 --> 00:06:55,579
Така че всичко, тази програма се прави
е ФОРМАТ-Ing 1 делено на 10.

158
00:06:55,579 --> 00:06:57,370
Така че, когато се съставя и
изпълнява тази програма

159
00:06:57,370 --> 00:07:01,170
изходи 0.0, въпреки че
1 е разделена на 10 0.1.

160
00:07:01,170 --> 00:07:02,970
Така че, защо го е 0.0?

161
00:07:02,970 --> 00:07:05,510
Е, това е така, защото
от целочислено деление.

162
00:07:05,510 --> 00:07:08,580
Така 1 е цяло число, 10 е цяло число.

163
00:07:08,580 --> 00:07:11,980
Така че едно делено на 10, всичко
се третира като цели числа,

164
00:07:11,980 --> 00:07:16,380
и в C, когато правим целочислено деление,
ние съкращава всяка десетична точка.

165
00:07:16,380 --> 00:07:19,590
Така един разделен от 10 се
0, а след това ние се опитваме

166
00:07:19,590 --> 00:07:24,410
да отпечатате, че като плувка, така
нулева отпечатва като плувка е 0.0.

167
00:07:24,410 --> 00:07:27,400
И това е защо ние получаваме 0.0.

168
00:07:27,400 --> 00:07:28,940
>> Помислете за програмата по-долу.

169
00:07:28,940 --> 00:07:31,280
Сега ние сме печат 0.1.

170
00:07:31,280 --> 00:07:34,280
Така че не целочислено деление,
ние просто печат 0.1,

171
00:07:34,280 --> 00:07:37,100
но ние сме го печат
до 28 знака след десетичната запетая.

172
00:07:37,100 --> 00:07:41,810
И ние се получи това 0.1000, цял куп
нули, 5 5 5, бла бла бла.

173
00:07:41,810 --> 00:07:45,495
Така че въпросът тук е защо го прави
отпечатате, че вместо точно 0.1?

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

175
00:07:46,620 --> 00:07:49,640
>> Така че тук причината е сега
плаваща запетая неточности.

176
00:07:49,640 --> 00:07:53,410
Не забравяйте, че на плувка е само на 32 бита.

177
00:07:53,410 --> 00:07:57,540
Така че ние само може да представлява определен брой
на стойности с плаваща запетая с тези 32

178
00:07:57,540 --> 00:07:58,560
бита.

179
00:07:58,560 --> 00:08:01,760
Ами там е в крайна сметка безкрайно
много числа с плаваща запетая,

180
00:08:01,760 --> 00:08:04,940
и има безкрайно много плаващ
точка стойности между 0 и 1,

181
00:08:04,940 --> 00:08:07,860
и очевидно ние сме в състояние да
представляват още повече стойности от това.

182
00:08:07,860 --> 00:08:13,230
Така че ние трябва да се правят жертви, за да
да бъде в състояние да представлява най-много ценности.

183
00:08:13,230 --> 00:08:16,960
>> Така че една стойност, като 0.1, очевидно
ние не можем да декларирате, че точно.

184
00:08:16,960 --> 00:08:22,500
Така че, вместо да представлява 0.1 правим
най-добре можем да представим тази 0.100000 5 5

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

186
00:08:23,260 --> 00:08:26,306
И това е доста близо, но
за много приложения

187
00:08:26,306 --> 00:08:28,430
трябва да се тревожи за
плаваща запетая неточност

188
00:08:28,430 --> 00:08:30,930
защото ние просто не може да представлява
всички плаващи точки точно.

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

190
00:08:32,500 --> 00:08:33,380
>> Въпрос 15.

191
00:08:33,380 --> 00:08:34,679
Помислете кода по-долу.

192
00:08:34,679 --> 00:08:36,630
Ние просто печат 1 плюс 1.

193
00:08:36,630 --> 00:08:38,289
Така че няма трик тук.

194
00:08:38,289 --> 00:08:41,780
1 плюс 1 оценява на 2, и
тогава ние сме печат това.

195
00:08:41,780 --> 00:08:42,789
Това просто отпечатва 2.

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

197
00:08:43,850 --> 00:08:44,700
>> Въпрос 16.

198
00:08:44,700 --> 00:08:49,450
Сега ние сме печат характера
1 плюс 1 характер.

199
00:08:49,450 --> 00:08:52,110
Така че, защо това не е така
отпечатване на едно и също нещо?

200
00:08:52,110 --> 00:08:57,680
Ами характера 1 плюс характер
1, характерът 1 има стойност ASCII 49.

201
00:08:57,680 --> 00:09:04,840
Така че това е наистина каза 49 плюс 49, и
в крайна сметка това ще отпечата 98.

202
00:09:04,840 --> 00:09:06,130
Така че това не се отпечатва 2.

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

204
00:09:08,070 --> 00:09:09,271
>> Въпрос 17.

205
00:09:09,271 --> 00:09:11,520
Завършване на изпълнението
странно долу по такъв начин,

206
00:09:11,520 --> 00:09:14,615
че функцията връща истина, ако
п е странно и невярно, ако N е четно.

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

208
00:09:16,710 --> 00:09:19,330
Това е една велика цел
за Министерството на отбраната оператора.

209
00:09:19,330 --> 00:09:24,530
Така че ние се аргумент нашата п
ако п мод 2 е равно на 1, и

210
00:09:24,530 --> 00:09:28,030
това означава, че N разделен
от 2 има остатък.

211
00:09:28,030 --> 00:09:33,270
Ако п разделен от 2 има остатък, че
означава, че н е странно, така че ние се върнете вярно.

212
00:09:33,270 --> 00:09:34,910
Иначе ние се върне фалшиви.

213
00:09:34,910 --> 00:09:39,070
Вие също може да са направили н моден две равни
нула, връщане фалшиви, иначе се върне вярно.

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

215
00:09:41,600 --> 00:09:43,640
>> Помислете за рекурсивно функцията по-долу.

216
00:09:43,640 --> 00:09:46,920
Така че, ако п е по-малка или
равна на 1, върнете 1,

217
00:09:46,920 --> 00:09:50,430
друго връщане н пъти е на п минус 1.

218
00:09:50,430 --> 00:09:52,556
Така че каква е тази функция?

219
00:09:52,556 --> 00:09:54,305
Е, това е само
факторен функция.

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

221
00:09:55,410 --> 00:09:57,405
Това е добре представена
като п факторен.

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

223
00:09:58,720 --> 00:10:02,310
>> Така че въпрос 19 сега, ние искаме да
вземе това рекурсивни функции.

224
00:10:02,310 --> 00:10:04,530
Искаме да направим това повтарящ се.

225
00:10:04,530 --> 00:10:05,874
И така, как да го направим?

226
00:10:05,874 --> 00:10:07,790
Ами за персонала
решение, и отново има

227
00:10:07,790 --> 00:10:11,090
много начини може да са го направили
че, ние започваме с този инт продукт

228
00:10:11,090 --> 00:10:11,812
се равнява на 1.

229
00:10:11,812 --> 00:10:13,520
И през тази
за линия, отиваме

230
00:10:13,520 --> 00:10:17,590
да се умножи продукт в крайна сметка
свърши с пълната факториел.

231
00:10:17,590 --> 00:10:21,870
Така че за инт и е равно на 2, и е
по-малко от или равно на N, I ++.

232
00:10:21,870 --> 00:10:24,130
>> Може би се чудите защо аз се равнява на две.

233
00:10:24,130 --> 00:10:28,380
Е, не забравяйте, че тук трябва да се
уверете се, че нашата база случай е правилно.

234
00:10:28,380 --> 00:10:32,180
Така че, ако п е по-малко от или равно
1, ние сме просто връщане 1.

235
00:10:32,180 --> 00:10:34,830
Така че тук, ние започнем да се равнява на две.

236
00:10:34,830 --> 00:10:39,090
Ами ако аз бяха 1, след the-- или
ако п са 1, а след това в продължение на линия

237
00:10:39,090 --> 00:10:40,600
не изпълнява изобщо.

238
00:10:40,600 --> 00:10:43,190
И така, ние просто ще
връщане продукт, който е един.

239
00:10:43,190 --> 00:10:45,920
По същия начин, ако п са
нищо по-малко от 1--

240
00:10:45,920 --> 00:10:49,290
ако е 0, отрицателна 1, whatever--
ние пак ще се върне 1,

241
00:10:49,290 --> 00:10:52,260
което е точно това, което
рекурсивни версия се прави.

242
00:10:52,260 --> 00:10:54,660
>> Сега, ако п е по-голямо
от 1, след това отиваме

243
00:10:54,660 --> 00:10:56,550
да се направи най-малко един
повторение на този цикъл.

244
00:10:56,550 --> 00:11:00,630
Така че нека да кажем, че п е 5, а след това ние сме
ще направим пъти продукта е равно на 2.

245
00:11:00,630 --> 00:11:02,165
Така че сега продукт е 2.

246
00:11:02,165 --> 00:11:04,040
Сега отиваме да се направи
пъти продуктови равнява на три.

247
00:11:04,040 --> 00:11:04,690
Сега е шест.

248
00:11:04,690 --> 00:11:07,500
Пъти на продукта е равно на четири, сега е 24.

249
00:11:07,500 --> 00:11:10,420
Пъти на продукта е равно на 5, сега е 120.

250
00:11:10,420 --> 00:11:16,730
Така че след това в крайна сметка, ние сме връщане
120, който е правилно 5 факторен.

251
00:11:16,730 --> 00:11:17,510
>> Въпрос 20.

252
00:11:17,510 --> 00:11:22,480
Това е тази, в която трябва да попълните
в тази таблица с даден алгоритъм,

253
00:11:22,480 --> 00:11:25,735
всичко, което сме виждали, че
вписва тези алгоритмични серия

254
00:11:25,735 --> 00:11:28,060
пъти тези асимптотичната тичам пъти.

255
00:11:28,060 --> 00:11:33,270
И така, какво е алгоритъм, който
е омега 1, но голям О п?

256
00:11:33,270 --> 00:11:35,970
Така че може да има безкрайно
много отговори тук.

257
00:11:35,970 --> 00:11:39,790
Този, който сме виждали, вероятно най-
често е само линейно търсене.

258
00:11:39,790 --> 00:11:42,050
>> Така че в най-добрия случай
сценарий, елементът сме

259
00:11:42,050 --> 00:11:44,050
търсите е в
началото на списъка

260
00:11:44,050 --> 00:11:47,400
и така на омега на 1 стъпки,
първото нещо, което ние проверяваме,

261
00:11:47,400 --> 00:11:49,740
ние просто се връщат незабавно
че ние открихме елемента.

262
00:11:49,740 --> 00:11:52,189
В най-лошия случай,
елементът е в края,

263
00:11:52,189 --> 00:11:53,730
или елемент не е в списъка на всички.

264
00:11:53,730 --> 00:11:56,700
Така че ние трябва да се търси
целия списък, всички п

265
00:11:56,700 --> 00:11:58,480
елементи, и това е защо е о п.

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

267
00:11:59,670 --> 00:12:04,880
>> Така че сега това е нещо, което е едновременно
омега на п дневник п и големия О п дневник п.

268
00:12:04,880 --> 00:12:08,650
Ами най-подходящото нещо,
сме виждали тук е слеят вид.

269
00:12:08,650 --> 00:12:12,950
Така се сливат нещо, не забравяйте,
е в крайна сметка Theta

270
00:12:12,950 --> 00:12:16,920
п Вход N, където тета е определена
ако омега както и голям О са еднакви.

271
00:12:16,920 --> 00:12:17,580
Както п влезете п.

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

273
00:12:18,690 --> 00:12:21,970
>> Какво е нещо, което е омега
от N, О и п квадрат?

274
00:12:21,970 --> 00:12:23,990
Е, пак има
множество възможни отговори.

275
00:12:23,990 --> 00:12:26,440
Тук ние се случи да се каже балон вид.

276
00:12:26,440 --> 00:12:28,840
Сортиране чрез вмъкване също ще работи тук.

277
00:12:28,840 --> 00:12:31,400
Не забравяйте, че балон на сортиране
е, че оптимизация, където

278
00:12:31,400 --> 00:12:34,630
ако сте в състояние да получи
през целия списък

279
00:12:34,630 --> 00:12:37,402
без да е необходимо да се направи
всички суапове, след това, добре,

280
00:12:37,402 --> 00:12:40,110
ние може веднага да се върне, че
списъкът е сортирано да се започне.

281
00:12:40,110 --> 00:12:43,185
Така че в най-добрия случай,
това е просто омега на п.

282
00:12:43,185 --> 00:12:45,960
Ако това не е просто една добре
сортирано списък, за да започнем с това,

283
00:12:45,960 --> 00:12:48,270
тогава имаме O н квадрат суапове.

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

285
00:12:49,330 --> 00:12:55,610
И накрая, ние имаме избор сортиране
за п квадрат, както и омега голям O.

286
00:12:55,610 --> 00:12:56,850
>> Въпрос 21.

287
00:12:56,850 --> 00:12:58,870
Какво е цяло число преливник?

288
00:12:58,870 --> 00:13:02,160
Е отново, подобно на по-рано,
имаме само краен брой битове

289
00:13:02,160 --> 00:13:04,255
да представлява цяло число,
Така че може би 32 бита.

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

291
00:13:06,300 --> 00:13:09,180
Да кажем, че имаме подписан число.

292
00:13:09,180 --> 00:13:12,800
След това в края на краищата най-високата
положително число можем да представим

293
00:13:12,800 --> 00:13:15,910
е 2 до 31 минус 1.

294
00:13:15,910 --> 00:13:19,370
Така че това, което се случва, ако се опитаме да
след това нарастване, че число?

295
00:13:19,370 --> 00:13:25,320
Е, ние ще тръгнем от 2 до 31
минус 1, по целия път до отрицателен 2

296
00:13:25,320 --> 00:13:26,490
до 31.

297
00:13:26,490 --> 00:13:29,470
Така че това число е преливане
когато държите увеличаване,

298
00:13:29,470 --> 00:13:32,330
и в крайна сметка не можеш
получите по-висока и тя просто

299
00:13:32,330 --> 00:13:34,520
обгръща целия път обратно
около с отрицателна стойност.

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

301
00:13:35,850 --> 00:13:37,779
>> Какво ще кажете за препълване на буфера?

302
00:13:37,779 --> 00:13:39,820
Така буфер overflow--
помня какво буфер е.

303
00:13:39,820 --> 00:13:41,000
Това е просто парче от памет.

304
00:13:41,000 --> 00:13:43,350
Нещо като масив е буфер.

305
00:13:43,350 --> 00:13:46,120
Така препълване на буфера е, когато
когато се опитвате да получите достъп до паметта

306
00:13:46,120 --> 00:13:47,880
след края на този масив.

307
00:13:47,880 --> 00:13:50,410
Така че, ако имате
масив с размер 5 и

308
00:13:50,410 --> 00:13:53,700
пробвате достъп до конзолата масив
5 или 6 или скоба скоба 7,

309
00:13:53,700 --> 00:13:56,610
или нещо повече за
край, или дори нещо

310
00:13:56,610 --> 00:14:00,790
below-- скоба масив отрицателен 1--
всички от тях са препълване на буфера.

311
00:14:00,790 --> 00:14:02,810
Вие докосвате памет в лоши отношения.

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

313
00:14:04,090 --> 00:14:04,730
>> Въпрос 23.

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

315
00:14:05,760 --> 00:14:09,100
Така че в това, което трябва
да приложат strlen.

316
00:14:09,100 --> 00:14:11,630
И ние ви кажа, че можете да
Предполагам, и няма да бъде нула,

317
00:14:11,630 --> 00:14:13,790
така че не е нужно да се
направя някоя проверка за нищожна.

318
00:14:13,790 --> 00:14:16,190
И има много начини
бихте могли да са направили това.

319
00:14:16,190 --> 00:14:18,440
Тук ние просто приемете ясно.

320
00:14:18,440 --> 00:14:21,780
Започваме с брояч, п. п е
брои колко символа са там.

321
00:14:21,780 --> 00:14:25,560
Така че ние започваме на 0, а след това
обхождане на целия списък.

322
00:14:25,560 --> 00:14:29,092
>> Има и скоба 0 равна на
нула терминатор характер?

323
00:14:29,092 --> 00:14:31,425
Не забравяйте, че търсим
нулевата терминатор характер

324
00:14:31,425 --> 00:14:33,360
за да се определи колко време ни е низ.

325
00:14:33,360 --> 00:14:35,890
Това ще прекрати
всяка съответна низ.

326
00:14:35,890 --> 00:14:39,400
Така е и конзола 0 равен
до нула терминатор?

327
00:14:39,400 --> 00:14:42,850
Ако не е, тогава ние ще
Посетете и скоба 1, а скоба 2.

328
00:14:42,850 --> 00:14:45,050
Ние не спирай, докато ние
намерите нула терминатор.

329
00:14:45,050 --> 00:14:48,580
След като сме го намерили, тогава п съдържа
общата дължина на низа,

330
00:14:48,580 --> 00:14:49,942
и само можем да се върнем това.

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

332
00:14:51,180 --> 00:14:51,865
>> Въпрос 24.

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

334
00:14:53,010 --> 00:14:56,050
Така че това е тази, в която
Трябва да се направи компромис.

335
00:14:56,050 --> 00:14:59,810
Така че едно нещо е добро в едно
начин, но по какъв начин това е лошо?

336
00:14:59,810 --> 00:15:02,980
Така че тук, се слеят вид тенденция да
да бъде по-бързо от балон вид.

337
00:15:02,980 --> 00:15:06,530
Като каза that-- добре, има
са няколко отговора тук.

338
00:15:06,530 --> 00:15:12,930
Но главното е, че балон сортиране
е омега на п за сортиран списък.

339
00:15:12,930 --> 00:15:14,950
>> Не забравяйте, че на маса ние просто видяхме по-рано.

340
00:15:14,950 --> 00:15:17,600
Така балон сортира омега на
п, в най-добрия случай

341
00:15:17,600 --> 00:15:20,010
е, че е в състояние само да отидем
списъка веднъж определи

342
00:15:20,010 --> 00:15:22,270
Ей това нещо е вече
сортирано и връщане.

343
00:15:22,270 --> 00:15:25,960
Сортиране чрез сливане, без значение какво
което правите, е омега на п дневник п.

344
00:15:25,960 --> 00:15:29,200
Така че за сортиран списък, балон
нещо ще бъде по-бързо.

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

346
00:15:30,870 --> 00:15:32,430
>> Сега какво ще кажеш за свързани списъци?

347
00:15:32,430 --> 00:15:36,070
Така свързан списък може да расте и да се намалят
за да се поберат най-много елементи, както е необходимо.

348
00:15:36,070 --> 00:15:38,489
Като каза that-- така
обикновено прякото сравнение

349
00:15:38,489 --> 00:15:40,280
ще бъде свързан
списък с масив.

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

351
00:15:41,600 --> 00:15:44,050
Така че, въпреки че масиви може
лесно да растат и да се свие

352
00:15:44,050 --> 00:15:47,130
за да се поберат най-много елементи
колкото е необходимо, списък свързан

353
00:15:47,130 --> 00:15:49,600
в сравнение с array-- на
масив има произволен достъп.

354
00:15:49,600 --> 00:15:52,960
Ние можем индекс във всеки
специално елемент на масива.

355
00:15:52,960 --> 00:15:56,430
>> Така че за свързан списък, не можем да
просто отидете на петия елемент,

356
00:15:56,430 --> 00:16:00,260
ние трябва да преминават от началото
докато стигнем до петия елемент.

357
00:16:00,260 --> 00:16:03,990
И това няма да ни попречи
правиш нещо като двоично търсене.

358
00:16:03,990 --> 00:16:08,150
Говорейки за двоично търсене, двоично търсене
има тенденция да бъде по-бързо, отколкото линейно търсене.

359
00:16:08,150 --> 00:16:11,120
Като каза that--
Така че, един възможен нещо

360
00:16:11,120 --> 00:16:13,380
е, че не можеш да направиш двоичен
търсене на свързани списъци,

361
00:16:13,380 --> 00:16:14,730
можете да го направите само за масиви.

362
00:16:14,730 --> 00:16:18,030
Но може би по-важното е,
не можеш да направиш двоично търсене

363
00:16:18,030 --> 00:16:20,690
на масив, който не е сортиран.

364
00:16:20,690 --> 00:16:23,990
Авансово може да се наложи да се справи
масива, и едва след това може да

365
00:16:23,990 --> 00:16:25,370
правиш двоично търсене.

366
00:16:25,370 --> 00:16:27,660
Така че, ако нещо не е
сортирани да започнем с това,

367
00:16:27,660 --> 00:16:29,250
след това линейно търсене може да бъде по-бързо.

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

369
00:16:30,620 --> 00:16:31,740
>> Въпрос 27.

370
00:16:31,740 --> 00:16:34,770
Така че помислете програмата по-долу,
който ще бъде в следващия слайд.

371
00:16:34,770 --> 00:16:37,790
И това е тази, в която ние сме
ще искате да посочва изрично

372
00:16:37,790 --> 00:16:39,980
стойностите за различните променливи.

373
00:16:39,980 --> 00:16:41,990
Така че нека да погледнем това.

374
00:16:41,990 --> 00:16:43,160
>> Така се подредят един.

375
00:16:43,160 --> 00:16:45,457
Имаме INT х е равен на 1.

376
00:16:45,457 --> 00:16:47,040
Това е единственото нещо, което се е случило.

377
00:16:47,040 --> 00:16:50,440
Така че в един ред, ние виждаме в нашия
маса, че Y, А, В, и TMP всички

378
00:16:50,440 --> 00:16:51,540
затъмнен вън.

379
00:16:51,540 --> 00:16:52,280
Така че това, което е х?

380
00:16:52,280 --> 00:16:53,860
Ами ние просто го определя като равна на 1.

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

382
00:16:55,020 --> 00:16:58,770
И след това втора линия, добре,
ние виждаме, че у е до 2,

383
00:16:58,770 --> 00:17:00,550
и таблицата е вече
попълва за нас.

384
00:17:00,550 --> 00:17:03,040
Така че х е 1 и Y е 2.

385
00:17:03,040 --> 00:17:05,890
>> Сега, третия ред, ние сме сега
вътре функция суап.

386
00:17:05,890 --> 00:17:07,560
Какво можем да премине, за да сменяте?

387
00:17:07,560 --> 00:17:11,609
Минахме амперсанд х за
А, и амперсанд у за б.

388
00:17:11,609 --> 00:17:15,160
Когато проблема по-рано
посочва, че адресът на х

389
00:17:15,160 --> 00:17:17,520
е 0x10, както и адреса на у е 0x14.

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

391
00:17:18,970 --> 00:17:21,909
Така че А и Б са равни
0x10 и 0x14, съответно.

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

393
00:17:23,670 --> 00:17:26,250
>> Сега в третия ред, какви са х и у?

394
00:17:26,250 --> 00:17:28,554
Е, нищо не се е променило
за х и у в този момент.

395
00:17:28,554 --> 00:17:30,470
Въпреки че те са
във вътрешността на главен стека рамка,

396
00:17:30,470 --> 00:17:32,469
те все още имат едни и същи
стойности са направили преди.

397
00:17:32,469 --> 00:17:34,030
Ние не са променени всяка памет.

398
00:17:34,030 --> 00:17:35,710
Така че х е 1, Y е 2.

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

400
00:17:36,550 --> 00:17:37,050
Добре.

401
00:17:37,050 --> 00:17:40,300
Така че сега ние казахме инт ПТУ равна на звезда а.

402
00:17:40,300 --> 00:17:44,410
Така че в четвърти ред, всичко
е същата, с изключение на ТМР.

403
00:17:44,410 --> 00:17:47,130
Ние не са се променили всички ценности
от нищо друго, освен за ПТУ.

404
00:17:47,130 --> 00:17:49,230
Ние сме за създаване ПТУ равна на звезда а.

405
00:17:49,230 --> 00:17:50,620
Какво е звезда?

406
00:17:50,620 --> 00:17:56,240
Е, на пункта до х, така звезда
ще се равнява х, което е едно.

407
00:17:56,240 --> 00:18:00,080
Така че всичко се копира
надолу и ПТУ е 1.

408
00:18:00,080 --> 00:18:01,110
>> Сега на следващия ред.

409
00:18:01,110 --> 00:18:03,380
Star един равнява звезда б.

410
00:18:03,380 --> 00:18:10,000
Така по ред five-- и отново, всичко
е една и съща независимо освен звезда е.

411
00:18:10,000 --> 00:18:10,830
Какво е звезда?

412
00:18:10,830 --> 00:18:13,720
Е, ние току-що каза звезда е х.

413
00:18:13,720 --> 00:18:16,400
Така че ние променяме х на равно звезда б.

414
00:18:16,400 --> 00:18:18,960
Какво е звезда б? у. б точки на ш.

415
00:18:18,960 --> 00:18:21,030
Така звезда б е ш.

416
00:18:21,030 --> 00:18:25,140
Така че ние сме за създаване х равно на х,
и всичко останало е същото.

417
00:18:25,140 --> 00:18:29,130
Така ние виждаме в следващия ред, че х е сега
2, а останалите са просто копира надолу.

418
00:18:29,130 --> 00:18:31,120
>> А в следващия ред, звезда б равнява ПТУ.

419
00:18:31,120 --> 00:18:34,740
Е, ние току-що каза звездата б е ш,
така че ние сме за създаване у равна на ПТУ.

420
00:18:34,740 --> 00:18:37,450
Всичко останало е същото,
така че всичко бива копиран надолу.

421
00:18:37,450 --> 00:18:42,050
Ние сме за създаване у равна на TMP, което е
един, и всичко останало е същото.

422
00:18:42,050 --> 00:18:43,210
>> Сега най-накрая, линия седем.

423
00:18:43,210 --> 00:18:44,700
Ние сме обратно в основната функция.

424
00:18:44,700 --> 00:18:46,350
Ние сме след суап е завършен.

425
00:18:46,350 --> 00:18:48,972
Ние загубихме а, б, и
ПТУ, но в крайна сметка ние

426
00:18:48,972 --> 00:18:51,180
не се променят всички стойности
от нищо в този момент,

427
00:18:51,180 --> 00:18:52,800
ние просто копирайте х и у надолу.

428
00:18:52,800 --> 00:18:56,490
И ние виждаме, че X и Y са
сега 2 и 1 вместо 1 и 2.

429
00:18:56,490 --> 00:18:58,160
Размяната е изпълнена успешно.

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

431
00:18:59,500 --> 00:19:00,105
>> Въпрос 28.

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

433
00:19:01,226 --> 00:19:03,100
Да предположим, че се натъкнете
съобщения за грешки

434
00:19:03,100 --> 00:19:06,790
долу в работно време
през следващата година като CA или TF.

435
00:19:06,790 --> 00:19:08,930
Съветва как да се определи всеки един от тези грешки.

436
00:19:08,930 --> 00:19:11,160
Така неопределено позоваване на GetString.

437
00:19:11,160 --> 00:19:12,540
Защо може да видите това?

438
00:19:12,540 --> 00:19:15,380
Е, ако студентът е с помощта
GetString в кода си,

439
00:19:15,380 --> 00:19:20,310
те са правилно с # включени cs50
точка Н за включване на cs50 библиотеката.

440
00:19:20,310 --> 00:19:22,380
>> Е, това, което правят
трябва да се определи тази грешка?

441
00:19:22,380 --> 00:19:26,810
Те трябва да се направи пробив lcs50 в
командния ред, когато компилирате.

442
00:19:26,810 --> 00:19:29,501
Така че, ако те не преминават
трясък тире lcs50, те са

443
00:19:29,501 --> 00:19:32,000
няма да имат реален
код, който реализира GetString.

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

445
00:19:33,190 --> 00:19:34,170
>> Въпрос 29.

446
00:19:34,170 --> 00:19:36,190
Мълчаливо се обявява
библиотека функция strlen.

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

448
00:19:37,550 --> 00:19:40,360
Е това сега, те не са
направи правилното хеш включва.

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

450
00:19:41,440 --> 00:19:45,410
В този конкретен случай, заглавната част на файла
те трябва да се включат е низ точка з,

451
00:19:45,410 --> 00:19:48,710
включително низ точка ч, сега
на student-- сега компилатор

452
00:19:48,710 --> 00:19:51,750
има достъп до
декларации за strlen,

453
00:19:51,750 --> 00:19:54,120
и тя знае, че вашият код
използва strlen правилно.

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

455
00:19:55,380 --> 00:19:56,580
>> Въпрос 30.

456
00:19:56,580 --> 00:20:00,240
Повече процента реализации
от аргументи данни.

457
00:20:00,240 --> 00:20:01,540
И така, какво е това?

458
00:20:01,540 --> 00:20:06,470
Добре си спомням, че те процента
signs-- как те са свързани с ФОРМАТ.

459
00:20:06,470 --> 00:20:08,890
Така че в ФОРМАТ можем да percent--
можем да отпечатате нещо

460
00:20:08,890 --> 00:20:11,380
като процент и обратно наклонена черта п.

461
00:20:11,380 --> 00:20:15,310
Или можем да отпечатате като процента аз,
пространство, на сто и, пространство, процента аз.

462
00:20:15,310 --> 00:20:18,950
Така за всяка от тези
процента признаци, от които се нуждаем

463
00:20:18,950 --> 00:20:21,560
да премине променлива в края на ФОРМАТ.

464
00:20:21,560 --> 00:20:26,980
>> Така че, ако ние кажем ФОРМАТ скоба процента
и обратно наклонена черта н близки скоба,

465
00:20:26,980 --> 00:20:30,270
добре, да кажем, че ние сме
щеше да отпечатате цяло число,

466
00:20:30,270 --> 00:20:33,970
но след това не преминават ФОРМАТ
цяло число действително да отпечатате.

467
00:20:33,970 --> 00:20:37,182
Така че тук повече процента
реализации, отколкото аргументи данни?

468
00:20:37,182 --> 00:20:39,390
Това се казва, че ние имаме
цял куп процента,

469
00:20:39,390 --> 00:20:42,445
и ние не разполагат с достатъчно променливи
действително да запълни в тези проценти.

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

471
00:20:44,850 --> 00:20:50,010
>> И тогава определено, за въпрос 31,
определено губи 40 байта в един блок.

472
00:20:50,010 --> 00:20:52,350
Така че това е грешка Valgrind.

473
00:20:52,350 --> 00:20:54,720
Това се казва, че
някъде в кода си,

474
00:20:54,720 --> 00:20:59,010
имате разпределение, което е 40
байта голям, така че можете malloced 40 байта,

475
00:20:59,010 --> 00:21:00,515
и никога няма да го остави.

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

477
00:21:02,480 --> 00:21:05,140
Най-вероятно просто трябва
да намери някаква памет течове,

478
00:21:05,140 --> 00:21:07,650
и да намерят мястото, където трябва да се
освободи този блок памет.

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

480
00:21:08,780 --> 00:21:11,910
>> И въпрос на 32 г.
невалиден запис с размер 4.

481
00:21:11,910 --> 00:21:13,250
Отново това е грешка Valgrind.

482
00:21:13,250 --> 00:21:15,440
Това не трябва да направите,
с изтичане на памет предприятието.

483
00:21:15,440 --> 00:21:20,750
Това е най-likely-- Искам да кажа, това е
някаква невалидни права памет.

484
00:21:20,750 --> 00:21:23,270
И най-вероятно това е някакъв
сортиране на препълване на буфера.

485
00:21:23,270 --> 00:21:26,560
Когато имате един масив, може би
цяло число масив, и нека

486
00:21:26,560 --> 00:21:30,115
казват, че е на площ 5, и
се опитват да се докоснат масив конзола 5.

487
00:21:30,115 --> 00:21:34,150
Така че, ако се опитате да пише, че
стойност, която не е част от паметта

488
00:21:34,150 --> 00:21:37,440
които всъщност имат достъп до тях, и
така че започваш да се получи тази грешка,

489
00:21:37,440 --> 00:21:39,272
казва невалиден запис с размер 4.

490
00:21:39,272 --> 00:21:42,480
Valgrind ще признае, че сте
се опитва да се докоснат памет неподходящо.

491
00:21:42,480 --> 00:21:43,980
>> И това е всичко за quiz0.

492
00:21:43,980 --> 00:21:47,065
Аз съм Роб Боудън, а това е CS50.

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