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

2
00:00:09,572 --> 00:00:12,030
რობ Bowden: Hi, მე ვარ Rob Bowden,
და მოდით ვისაუბროთ quiz0.

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

4
00:00:13,280 --> 00:00:14,545
>> ასე რომ, პირველი კითხვა.

5
00:00:14,545 --> 00:00:17,750
ეს არის საკითხი, სადაც
თქვენ საჭირო კოდექსის ნომერი

6
00:00:17,750 --> 00:00:21,270
127 წელს ორობითი ნათურებით.

7
00:00:21,270 --> 00:00:23,550
თუ უნდოდა, შეიძლება
გავაკეთოთ რეგულარული კონვერტაციის

8
00:00:23,550 --> 00:00:25,950
საწყისი bi-- ან, ეხლა ათობითი ორობითი.

9
00:00:25,950 --> 00:00:28,300
მაგრამ ეს, ალბათ,
მიიღოს ბევრი დრო.

10
00:00:28,300 --> 00:00:31,750
ვგულისხმობ, თქვენ ვერ გაერკვნენ, რომ
OK, 1 არის იქ, 2 არის იქ,

11
00:00:31,750 --> 00:00:33,650
4 იქ, 8 არის იქ.

12
00:00:33,650 --> 00:00:39,280
ადვილი გზა, 127 128 მინუს ერთი.

13
00:00:39,280 --> 00:00:42,013
რომ leftmost ნათურა არის 128-bit.

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
რადგან ეს არის ის leftmost
ნათურა მინუს 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
With n ბიტი, რამდენი განსხვავებული
ღირებულებები შეიძლება წარმოადგენს?

27
00:01:14,610 --> 00:01:19,080
ასე რომ, n ბიტი, თქვენ გაქვთ 2
შესაძლო მნიშვნელობებია თითოეული bit.

28
00:01:19,080 --> 00:01:22,300
ამიტომ ჩვენ გვაქვს 2 შესაძლო ღირებულებების
პირველი ცოტა, 2 შესაძლო მნიშვნელობებია

29
00:01:22,300 --> 00:01:24,450
მეორე, 2
შესაძლებელია მესამე.

30
00:01:24,450 --> 00:01:28,730
და ისე, რომ 2 ჯერ 2 ჯერ 2 და
საბოლოო ჯამში, პასუხი არის 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 bit და 4 bit.

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
და თუ უნდოდა, რომ თქვენ შეიძლება
მიიღოს off, რომ leftmost ნულოვანი.

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
თუ უნდოდა, რომ თქვენ შეიძლება, თუ თქვენ
უფრო კომფორტულად ორობითი,

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
ასევე, ჩვენ არ აქ ნაწილი თამამი
არის მხოლოდ ნაწილი თქვენ უნდა შეესრულებინა.

60
00:02:47,730 --> 00:02:51,950
ამიტომ ჩვენ გვაქვს 4 loop რომ looping 4
ჯერ, printf-Ing არაქისის კარაქი რძე,

61
00:02:51,950 --> 00:02:53,910
ახალი ხაზის პრობლემა ითხოვს.

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

63
00:02:55,250 --> 00:02:57,490
>> კითხვა ექვსი, ერთი Scratch პრობლემა.

64
00:02:57,490 --> 00:03:00,210
ჩვენ ვხედავთ, რომ ჩვენ ვართ სამუდამოდ loop.

65
00:03:00,210 --> 00:03:05,000
ჩვენ ვამბობთ, ცვლადი i
და შემდეგ დამატება i 1.

66
00:03:05,000 --> 00:03:09,580
ახლა ჩვენ გვინდა გავაკეთოთ, რომ C. არსებობს
სხვადასხვა გზები შეგვეძლო გავაკეთეთ ეს.

67
00:03:09,580 --> 00:03:12,840
აქ ჩვენ მოხდა კოდექსის
სამუდამოდ loop რადგან ხოლო (ნამდვილი).

68
00:03:12,840 --> 00:03:16,600
ამიტომ ვაცხადებთ ცვლადი i, უბრალოდ
როგორც ჩვენ გვქონდა ცვლადი i ნულიდან.

69
00:03:16,600 --> 00:03:21,950
განაცხადოს ცვლადი i და სამუდამოდ
ხოლო (ნამდვილი), ჩვენ ვამბობთ, ცვლადი მე.

70
00:03:21,950 --> 00:03:25,260
ამიტომ printf% შევიდე ან შეიძლება უკვე გამოყენებული% d.

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
ახლა ჩვენ გვინდა, რომ რაღაც ძალიან ჰგავს
მარიო dot გ from პრობლემა მითითებული ერთი.

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
ასევე, ჩვენ მოგცემთ მთელი
bunch of კოდი და უბრალოდ

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
loop, რომ looping

84
00:03:53,520 --> 00:03:57,650
მეტი ყველა რიგები ამ
ქსელის, რომ ჩვენ გვინდა, რომ ამობეჭდოთ.

85
00:03:57,650 --> 00:04:01,250
მაშინ ჩვენ გვაქვს შიდა წყობილი 4 loop,
რომ არის ბეჭდვის მეტი თითოეული სვეტი.

86
00:04:01,250 --> 00:04:06,210
ასე რომ თითოეული მწკრივი, ჩვენ ბეჭდვა
ყოველი სვეტი, ერთი hash.

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
ფუნქცია, როგორიცაა 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
ასევე, დაბრუნების ღირებულება
ჩვენ ვიცით, 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, ხოლო შემდეგ
ბეჭდვის რომ ცვლადი 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
მოიცავს cs50 dot თ.

122
00:05:20,920 --> 00:05:23,820
რატომ ჩვენ უნდა შეიცავდეს # cs50 dot h?

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
ასე რომ, თუ ჩვენ არ გვაქვს
მოიცავს cs50 dot h,

126
00:05:31,600 --> 00:05:35,760
ჩვენ კიდევ, რომ დაფარული დეკლარაცია
საქართველოს GetString ფუნქცია შეცდომა

127
00:05:35,760 --> 00:05:36,840
საწყისი შემდგენელი.

128
00:05:36,840 --> 00:05:40,110
ასე რომ, ჩვენ უნდა შეიცავდეს ბიბლიოთეკა
ჩვენ უნდა შეიცავდეს header ფაილი,

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 dot თ.

133
00:05:47,890 --> 00:05:50,430
ეს არის ზუსტად იგივე
როგორც წინა პრობლემა,

134
00:05:50,430 --> 00:05:53,310
გარდა ნაცვლად საქმე
GetString, ჩვენ ვსაუბრობთ printf.

135
00:05:53,310 --> 00:05:56,654
ასე რომ, თუ ჩვენ არ ვამბობ, რომ ჩვენ უნდა
მოიცავს სტანდარტული io dot h,

136
00:05:56,654 --> 00:05:58,820
მაშინ ჩვენ ვერ შევძლებთ
გამოვიყენოთ printf ფუნქცია,

137
00:05:58,820 --> 00:06:00,653
რადგან შემდგენელი
არ ვიცი ამის შესახებ.

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

139
00:06:01,750 --> 00:06:05,260
>> Why-- რა მნიშვნელობა
ბათილად ხაზის ოთხი?

140
00:06:05,260 --> 00:06:08,010
ასე რომ აქ გვაქვს int ძირითადი (void).

141
00:06:08,010 --> 00:06:10,600
ეს მხოლოდ ამბობდა, რომ ჩვენ
ვერ ვიღებთ ნებისმიერი ბრძანების

142
00:06:10,600 --> 00:06:12,280
არგუმენტები ძირითადი.

143
00:06:12,280 --> 00:06:17,390
გახსოვდეთ, რომ ჩვენ შეგვიძლია ვთქვათ, int
მთავარი int argc სიმებიანი argv ფრჩხილებში.

144
00:06:17,390 --> 00:06:20,400
ასე რომ აქ ჩვენ უბრალოდ, ვამბობთ ბათილად, რომ ჩვენ
იგნორირება ბრძანება ხაზი არგუმენტები.

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

146
00:06:21,840 --> 00:06:25,225
>> ავუხსნათ, მიმართ მეხსიერება, ზუსტად
რა GetString ხაზი ექვსი ბრუნდება.

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

148
00:06:27,040 --> 00:06:31,640
GetString ბრუნდება ბლოკი
მეხსიერება, მასივი სიმბოლო.

149
00:06:31,640 --> 00:06:34,870
ეს მართლაც დაბრუნების
მაჩვენებელი პირველი ხასიათი.

150
00:06:34,870 --> 00:06:37,170
გახსოვდეთ, რომ სიმებიანი არის char ვარსკვლავი.

151
00:06:37,170 --> 00:06:41,360
ამიტომ, მომცეთ პირველი
ხასიათი რასაც სიმებიანი არის

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
ასე რომ ყველა ეს პროგრამა აკეთებს
არის printf-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
ასე 1 დაყოფილი 10, ყველაფერი
განიხილება, როგორც მთელი რიცხვები,

164
00:07:11,980 --> 00:07:16,380
და C, როდესაც ჩვენ გავაკეთებთ მთელი განყოფილება,
ჩვენ შეკვეცავს ნებისმიერი ათობითი წერტილი.

165
00:07:16,380 --> 00:07:19,590
ასე რომ 1 დაყოფილი 10
0, და მაშინ ჩვენ ვცდილობთ

166
00:07:19,590 --> 00:07:24,410
ბეჭდვა float, ასე
ნულოვანი დაბეჭდილი როგორც float არის 0.0.

167
00:07:24,410 --> 00:07:27,400
და სწორედ ამიტომ, ჩვენ კიდევ 0.0.

168
00:07:27,400 --> 00:07:28,940
>> განვიხილოთ პროგრამა ქვემოთ.

169
00:07:28,940 --> 00:07:31,280
ამჟამად ჩვენ დაბეჭდვის 0.1.

170
00:07:31,280 --> 00:07:34,280
ასე რომ, არ მთელი განყოფილება,
ჩვენ უბრალოდ ბეჭდვის 0.1,

171
00:07:34,280 --> 00:07:37,100
მაგრამ ჩვენ ბეჭდვა ეს
28 ათობითი ადგილებში.

172
00:07:37,100 --> 00:07:41,810
და ჩვენ ამ 0,1000, მთელი bunch
of zeros, 5 5 5, blah blah blah.

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
გვახსოვდეს, რომ float მხოლოდ 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 plus 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 plus ხასიათი 1.

199
00:08:49,450 --> 00:08:52,110
ასე რატომ არა
ბეჭდვა იგივე?

200
00:08:52,110 --> 00:08:57,680
ისევე ხასიათი 1 plus ხასიათი
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 უცნაური და ცრუ თუ n კი.

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

208
00:09:16,710 --> 00:09:19,330
ეს არის დიდი მიზანი
რომ mod ოპერატორი.

209
00:09:19,330 --> 00:09:24,530
ამიტომ ჩვენ ჩვენი არგუმენტი n,
თუ n mod 2 უდრის 1, კარგად

210
00:09:24,530 --> 00:09:28,030
ეს ნიშნავს, რომ n იყოფა
2 ჰქონდა დარჩენილი.

211
00:09:28,030 --> 00:09:33,270
თუ n იყოფა 2 ჰქონდა დარჩენილი, რომ
იმას ნიშნავს, რომ n უცნაური, ასე რომ, ჩვენ დაუბრუნოს ჭეშმარიტი.

212
00:09:33,270 --> 00:09:34,910
სხვაგან ჩვენ დაბრუნების ცრუ.

213
00:09:34,910 --> 00:09:39,070
თქვენ ასევე შეიძლება გაკეთდეს n mod 2 ტოლობის
ნულოვანი, დაბრუნების ცრუ, სხვა TRUE.

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

215
00:09:41,600 --> 00:09:43,640
>> განვიხილოთ რეკურსიული ფუნქცია ქვემოთ.

216
00:09:43,640 --> 00:09:46,920
ასე რომ, თუ n ნაკლებია ან
უდრის 1, დაბრუნდებიან 1,

217
00:09:46,920 --> 00:09:50,430
სხვაგან დაბრუნების N ჯერ ვ ო მინუს 1.

218
00:09:50,430 --> 00:09:52,556
რა არის ეს ფუნქცია?

219
00:09:52,556 --> 00:09:54,305
ისე, ეს მხოლოდ
factorial ფუნქცია.

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

221
00:09:55,410 --> 00:09:57,405
ეს არის ლამაზად წარმოდგენილი
როგორც n factorial.

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

223
00:09:58,720 --> 00:10:02,310
>> ასე ეჭვქვეშ 19 ახლა, ჩვენ გვინდა
მიიღოს ამ რეკურსიული ფუნქცია.

224
00:10:02,310 --> 00:10:04,530
ჩვენ გვინდა, რომ მას განმეორებითი.

225
00:10:04,530 --> 00:10:05,874
ასე რომ, როგორ გავაკეთოთ ეს?

226
00:10:05,874 --> 00:10:07,790
ასევე თანამშრომლებისათვის
გამოსავალი, და ისევ იქ

227
00:10:07,790 --> 00:10:11,090
სხვადასხვა გზები შეიძლება გაკეთდეს
რომ, ჩვენ ვიწყებთ ამ int პროდუქტი

228
00:10:11,090 --> 00:10:11,812
უდრის 1.

229
00:10:11,812 --> 00:10:13,520
და მთელი ამ
ამისთვის მარყუჟის, ჩვენ ვაპირებთ

230
00:10:13,520 --> 00:10:17,590
უნდა გამრავლებით პროდუქტის საბოლოო ჯამში,
დასრულდება up ერთად სრული factorial.

231
00:10:17,590 --> 00:10:21,870
ასე int i უდრის 2, მე
ნაკლები ან ტოლია n, i ++.

232
00:10:21,870 --> 00:10:24,130
>> თქვენ შეიძლება გაინტერესებთ, რატომ უდრის 2.

233
00:10:24,130 --> 00:10:28,380
გახსოვდეთ, რომ აქ გვაქვს
დარწმუნდით, ჩვენი ბაზის შემთხვევაში არის სწორი.

234
00:10:28,380 --> 00:10:32,180
ასე რომ, თუ n ნაკლებია ან ტოლი
1, ჩვენ უბრალოდ დაბრუნების 1.

235
00:10:32,180 --> 00:10:34,830
ასე რომ აქ, ჩვენ ვიწყებთ უდრის 2.

236
00:10:34,830 --> 00:10:39,090
ასევე, თუ მე 1, მაშინ the-- ან
თუ n, 1, მაშინ for loop

237
00:10:39,090 --> 00:10:40,600
არ შეასრულოს ყველა.

238
00:10:40,600 --> 00:10:43,190
ასე რომ, ჩვენ გვინდა მხოლოდ
დაბრუნების პროდუქტი, რომელიც არის 1.

239
00:10:43,190 --> 00:10:45,920
ანალოგიურად, თუ n იყვნენ
არაფერი ნაკლები 1--

240
00:10:45,920 --> 00:10:49,290
თუ ეს იყო 0, -1, whatever--
ჩვენ მაინც უნდა დაბრუნება 1,

241
00:10:49,290 --> 00:10:52,260
სწორედ იმას, რასაც
რეკურსიული ვერსია აკეთებს.

242
00:10:52,260 --> 00:10:54,660
>> ახლა, თუ N არის დიდი
1-ზე, მაშინ ჩვენ ვაპირებთ

243
00:10:54,660 --> 00:10:56,550
უნდა გავაკეთოთ მინიმუმ ერთი
iteration ამ loop.

244
00:10:56,550 --> 00:11:00,630
ასე ვთქვათ, n არის 5, მაშინ ჩვენ
ვაპირებთ, რომ გავაკეთოთ პროდუქტი ჯერ უდრის 2.

245
00:11:00,630 --> 00:11:02,165
ასე რომ, ახლა პროდუქტი 2.

246
00:11:02,165 --> 00:11:04,040
ახლა ჩვენ ვაპირებთ, რომ გავაკეთოთ
პროდუქტი ჯერ უდრის 3.

247
00:11:04,040 --> 00:11:04,690
ახლა ის 6.

248
00:11:04,690 --> 00:11:07,500
პროდუქტი ჯერ შეადგენს 4, ახლა ეს 24.

249
00:11:07,500 --> 00:11:10,420
პროდუქტი ჯერ შეადგენს 5, ახლა 120.

250
00:11:10,420 --> 00:11:16,730
ასე რომ, მაშინ, საბოლოო ჯამში, ჩვენ დაბრუნების
120, რომელიც სწორად 5 factorial.

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
ჯერ ეს asymptotic პერსპექტივაში ჯერ.

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
ამიტომ, ჩვენ უნდა ვეძებოთ
სრული სია, ყველა n

265
00:11:56,700 --> 00:11:58,480
ელემენტები, და ამიტომაც ეს O of n.

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

267
00:11:59,670 --> 00:12:04,880
>> ასე რომ, ახლა ეს არის ის, რომ ორივე
ომეგა N შესვლა N, და დიდი O of n შესვლა n.

268
00:12:04,880 --> 00:12:08,650
ასევე ყველაზე შესაბამისი,
ჩვენ ვნახეთ აქ არის შერწყმა ჯიშია.

269
00:12:08,650 --> 00:12:12,950
ასე რომ შერწყმა დალაგების, გახსოვდეთ,
საბოლოო ჯამში, თეტა

270
00:12:12,950 --> 00:12:16,920
of N შესვლა N, სადაც თეტა არის განსაზღვრული
თუ ორივე omega და დიდი O იგივეა.

271
00:12:16,920 --> 00:12:17,580
როგორც N შესვლა n.

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

273
00:12:18,690 --> 00:12:21,970
>> რა არის ის, რაც არის omega
ო, და O of n კვადრატში?

274
00:12:21,970 --> 00:12:23,990
ასევე, კიდევ ერთხელ არ არის
მრავალი შესაძლო პასუხი.

275
00:12:23,990 --> 00:12:26,440
აქ ჩვენ არ უნდა ვთქვათ bubble sort.

276
00:12:26,440 --> 00:12:28,840
Insertion დალაგების ასევე იმუშავებს აქ.

277
00:12:28,840 --> 00:12:31,400
გვახსოვდეს, რომ bubble sort
აქვს ოპტიმიზაცია, სადაც,

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
ასე რომ, საუკეთესო შემთხვევაში,
ეს მხოლოდ omega of n.

282
00:12:43,185 --> 00:12:45,960
თუ ეს არ არის მხოლოდ ლამაზად
დახარისხებული სია, დაიწყოს,

283
00:12:45,960 --> 00:12:48,270
მაშინ ჩვენ გვაქვს O of n კვადრატში გაცვლებს.

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

285
00:12:49,330 --> 00:12:55,610
და ბოლოს, ჩვენ გვაქვს შერჩევის დალაგების
for n კვადრატში, როგორც omega და დიდი ო

286
00:12:55,610 --> 00:12:56,850
>> კითხვა 21.

287
00:12:56,850 --> 00:12:58,870
რა არის მთელი რიცხვი overflow?

288
00:12:58,870 --> 00:13:02,160
ასევე, კიდევ ერთხელ, მსგავსი ადრე,
ჩვენ მხოლოდ finitely ბევრი ბიტი

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
ასე რომ, ეს რიცხვი overflow არის
როდესაც თქვენ გაქვთ დამატება,

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
>> რაც შეეხება ბუფერული overflow?

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
ასე ბუფერული overflow არის, როდესაც
ცდილობენ ხელმისაწვდომობის მეხსიერება

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
ცდილობენ, რათა შეამოწმონ მასივი bracket
5 ან bracket 6 ან bracket 7

309
00:13:53,700 --> 00:13:56,610
ან არაფერი მიღმა
ბოლოს, ან კი არაფერი

310
00:13:56,610 --> 00:14:00,790
below-- მასივი bracket უარყოფითი 1--
ყველა იმ ბუფერული overflows.

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
და ჩვენ გეტყვით, რომ თქვენ შეგიძლიათ
ვივარაუდოთ s არ იქნება null,

317
00:14:11,630 --> 00:14:13,790
ასე რომ თქვენ არ უნდა
გავაკეთოთ ნებისმიერი გამშვები null.

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
ჩვენ დავიწყებთ counter, n. ო
დათვლის რამდენი გმირები არსებობს.

321
00:14:21,780 --> 00:14:25,560
ასე რომ, ჩვენ ვიწყებთ 0, და მაშინ ჩვენ
iterate მთელ სიაში.

322
00:14:25,560 --> 00:14:29,092
>> არის s bracket 0 ტოლი
null terminator ხასიათი?

323
00:14:29,092 --> 00:14:31,425
დამახსოვრება, ჩვენ ვეძებთ
null terminator ხასიათი

324
00:14:31,425 --> 00:14:33,360
განსაზღვროს რამდენ ხანს ჩვენი სტრიქონს.

325
00:14:33,360 --> 00:14:35,890
რომ წყვეტს
ნებისმიერი შესაბამისი სიმებიანი.

326
00:14:35,890 --> 00:14:39,400
ასე რომ, არის s bracket 0 თანაბარი
რომ null terminator?

327
00:14:39,400 --> 00:14:42,850
თუ ეს არ, მაშინ ჩვენ ვაპირებთ
შევხედოთ s bracket 1, s bracket 2.

328
00:14:42,850 --> 00:14:45,050
ჩვენ შენარჩუნება აპირებს, სანამ ჩვენ
მოვძებნოთ null terminator.

329
00:14:45,050 --> 00:14:48,580
მას შემდეგ, რაც ჩვენ ვერ, მაშინ n შეიცავს
საერთო სიგრძეზე სიმებიანი,

330
00:14:48,580 --> 00:14:49,942
და ჩვენ შეგვიძლია უბრალოდ დააბრუნოს, რომ.

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

332
00:14:51,180 --> 00:14:51,865
>> კითხვა 24.

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

334
00:14:53,010 --> 00:14:56,050
ასე რომ, ეს არის, სადაც თქვენ
უნდა მიიღოს სავაჭრო მოედანი.

335
00:14:56,050 --> 00:14:59,810
ასე რომ ერთი რამ არის კარგი ერთი
გზა, მაგრამ რა გზით არის ამაში ცუდი?

336
00:14:59,810 --> 00:15:02,980
ასე რომ, აქ, შერწყმა დალაგების ტენდენცია
უფრო სწრაფად, ვიდრე bubble sort.

337
00:15:02,980 --> 00:15:06,530
მას შემდეგ განაცხადა, that--, ისევე,
რამდენიმე პასუხი აქ.

338
00:15:06,530 --> 00:15:12,930
მაგრამ მთავარი ის არის, რომ ბუშტი დალაგების
არის ომეგა n for დახარისხებული სია.

339
00:15:12,930 --> 00:15:14,950
>> გვახსოვდეს, რომ მაგიდასთან ჩვენ ვნახეთ ადრე.

340
00:15:14,950 --> 00:15:17,600
ამიტომ ბუშტი ჯიშები ომეგა
n, საუკეთესო შემთხვევაში სცენარი

341
00:15:17,600 --> 00:15:20,010
არის ის საშუალება, უბრალოდ მეტი
სიაში ერთხელ, განსაზღვრავს

342
00:15:20,010 --> 00:15:22,270
hey ეს ის არის უკვე
დახარისხებული და სანაცვლოდ.

343
00:15:22,270 --> 00:15:25,960
შერწყმა დალაგების, არ აქვს მნიშვნელობა რა
თქვენ აკეთებთ, არის ომეგა N შესვლა n.

344
00:15:25,960 --> 00:15:29,200
ასე დახარისხებული სია, bubble
სახის იქნება უფრო სწრაფად.

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
შედარებით მასივი
მასივი აქვს წვდომის.

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
ჩვენ უნდა traverse თავიდანვე
სანამ არ მივიღებთ მეხუთე ელემენტს.

357
00:16:00,260 --> 00:16:03,990
და რომ აპირებს გვიშლის
ამით რაღაც ორობითი ძებნა.

358
00:16:03,990 --> 00:16:08,150
ვსაუბრობ ორობითი ძებნა, ორობითი ძებნა
tends უნდა იყოს უფრო სწრაფად, ვიდრე წრფივი ძებნა.

359
00:16:08,150 --> 00:16:11,120
მას შემდეგ განაცხადა, that--
ასე რომ, ერთ-ერთი შესაძლო რამ

360
00:16:11,120 --> 00:16:13,380
არის, რომ თქვენ ამის გაკეთება არ შეუძლიათ ორობითი
ძიება უკავშირდება სიები

361
00:16:13,380 --> 00:16:14,730
თქვენ შეგიძლიათ მხოლოდ ამის გაკეთება მასივები.

362
00:16:14,730 --> 00:16:18,030
მაგრამ, ალბათ, უფრო მნიშვნელოვანია,
თქვენ არ შეუძლია ორობითი ძებნა

363
00:16:18,030 --> 00:16:20,690
მასივი, რომელიც არ არის დახარისხებული.

364
00:16:20,690 --> 00:16:23,990
Upfront თქვენ უნდა დასალაგებლად
მასივი, და მხოლოდ ამის შემდეგ შეიძლება

365
00:16:23,990 --> 00:16:25,370
თქვენ აკეთებთ ორობითი ძებნა.

366
00:16:25,370 --> 00:16:27,660
ასე რომ, თუ თქვენი რამ არ არის
დახარისხებული უნდა დაიწყოს,

367
00:16:27,660 --> 00:16:29,250
მაშინ ხაზოვანი ძებნა შეიძლება სწრაფად.

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

369
00:16:30,620 --> 00:16:31,740
>> კითხვა 27.

370
00:16:31,740 --> 00:16:34,770
ამიტომ მიგვაჩნია, რომ პროგრამა ქვემოთ,
რომელიც იქნება მომდევნო slide.

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 x უდრის 1.

376
00:16:45,457 --> 00:16:47,040
ეს არის ერთადერთი რამ, რაც მოხდა.

377
00:16:47,040 --> 00:16:50,440
ასე ერთი ხაზი, ერთი, ჩვენ ვხედავთ, ჩვენს
მაგიდა, რომელიც y, a, b, და tmp ყველა

378
00:16:50,440 --> 00:16:51,540
ჩაბნელებულ.

379
00:16:51,540 --> 00:16:52,280
რა არის x?

380
00:16:52,280 --> 00:16:53,860
ასევე, ჩვენ უბრალოდ ვაყენებთ მას ტოლი 1.

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

382
00:16:55,020 --> 00:16:58,770
და შემდეგ ხაზი ორი, ასევე,
ჩვენ ვხედავთ, რომ y არის მითითებული 2,

383
00:16:58,770 --> 00:17:00,550
და მაგიდაზე უკვე
შევსებული us.

384
00:17:00,550 --> 00:17:03,040
ასე რომ, x არის 1 და y 2.

385
00:17:03,040 --> 00:17:05,890
>> ახლა, ხაზი სამი, ჩვენ ახლა
შიგნით swap ფუნქცია.

386
00:17:05,890 --> 00:17:07,560
რა მივიღეთ გაივლის სვოპ?

387
00:17:07,560 --> 00:17:11,609
ჩვენ გავიდა ampersand x for
და ampersand y ბ.

388
00:17:11,609 --> 00:17:15,160
სადაც პრობლემა ადრე
განაცხადა, რომ მისამართი x

389
00:17:15,160 --> 00:17:17,520
არის 0x10 და მისამართი Y არის 0x14.

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

391
00:17:18,970 --> 00:17:21,909
ასე და ბ არის ტოლი
0x10 და 0x14, შესაბამისად.

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

393
00:17:23,670 --> 00:17:26,250
>> ახლა ხაზი სამი, რა არის x და y?

394
00:17:26,250 --> 00:17:28,554
ისე, არაფერი შეცვლილა
შესახებ x და y ამ ეტაპზე.

395
00:17:28,554 --> 00:17:30,470
მიუხედავად იმისა, რომ ისინი
შიგნით ძირითადი დასტის ჩარჩო,

396
00:17:30,470 --> 00:17:32,469
მათ ჯერ კიდევ აქვთ იგივე
ღირებულებები ადრე.

397
00:17:32,469 --> 00:17:34,030
ჩვენ არ შეცვლილია ნებისმიერი მეხსიერება.

398
00:17:34,030 --> 00:17:35,710
ასე რომ, x 1, y 2.

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

400
00:17:36,550 --> 00:17:37,050
ყველა უფლება.

401
00:17:37,050 --> 00:17:40,300
ასე რომ, ახლა ჩვენ განაცხადა int tmp ტოლი ვარსკვლავი.

402
00:17:40,300 --> 00:17:44,410
ისე ხაზი ოთხი, ყველაფერი
არის იგივე გარდა tmp.

403
00:17:44,410 --> 00:17:47,130
ჩვენ არ შეიცვალა ღირებულებები
არაფერი გარდა tmp.

404
00:17:47,130 --> 00:17:49,230
ჩვენ ვქმნით tmp ტოლი ვარსკვლავი.

405
00:17:49,230 --> 00:17:50,620
რა არის ვარსკვლავი?

406
00:17:50,620 --> 00:17:56,240
ასევე, მიუთითებს x, ასე რომ ვარსკვლავი
აპირებს თანაბარი x, რომელიც 1.

407
00:17:56,240 --> 00:18:00,080
ასე რომ, ყველაფერი დაკოპირებული
ქვემოთ, და tmp არის 1.

408
00:18:00,080 --> 00:18:01,110
>> ახლა მომდევნო ხაზი.

409
00:18:01,110 --> 00:18:03,380
Star შეადგენს ვარსკვლავი ბ.

410
00:18:03,380 --> 00:18:10,000
ასე რომ, ონლაინ ხუთ კარგად ერთხელ, ყველაფერი
არის იგივე, გარდა რასაც ვარსკვლავი არის.

411
00:18:10,000 --> 00:18:10,830
რა არის ვარსკვლავი?

412
00:18:10,830 --> 00:18:13,720
ასევე, ჩვენ უბრალოდ განაცხადა ვარსკვლავი არის x.

413
00:18:13,720 --> 00:18:16,400
ასე რომ, ჩვენ შეცვლის x თანაბარი ვარსკვლავი ბ.

414
00:18:16,400 --> 00:18:18,960
რა არის ვარსკვლავი b? y. b რაოდენობა წ.

415
00:18:18,960 --> 00:18:21,030
ასე ვარსკვლავი ბ შ.

416
00:18:21,030 --> 00:18:25,140
ასე რომ, ჩვენ შექმნის x უდრის y,
და ყველაფერი იგივე.

417
00:18:25,140 --> 00:18:29,130
ასე რომ, ჩვენ ვხედავთ, რომ მომდევნო გრაფაში, რომ x არის
2, ხოლო დანარჩენი უბრალოდ აკოპირებთ ქვემოთ.

418
00:18:29,130 --> 00:18:31,120
>> ახლა, მომდევნო ხაზი, ვარსკვლავი ბ უდრის tmp.

419
00:18:31,120 --> 00:18:34,740
ასევე, ჩვენ უბრალოდ განაცხადა, რომ ვარსკვლავი ბ არის y,
ასე რომ, ჩვენ შექმნის y ტოლია tmp.

420
00:18:34,740 --> 00:18:37,450
ყველაფერი არის იგივე,
ასე რომ ყველაფერი იღებს გადაწერა ქვემოთ.

421
00:18:37,450 --> 00:18:42,050
ჩვენ შექმნის y ტოლია 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
ჩვენ შემდეგ swap დასრულდა.

425
00:18:46,350 --> 00:18:48,972
დავკარგეთ, b, და
tmp, მაგრამ საბოლოო ჯამში ჩვენ

426
00:18:48,972 --> 00:18:51,180
არ იცვლება ღირებულებები
არაფერი ამ ეტაპზე,

427
00:18:51,180 --> 00:18:52,800
ჩვენ უბრალოდ ასლი x და y ქვემოთ.

428
00:18:52,800 --> 00:18:56,490
და ჩვენ ვხედავთ, რომ x და y
ახლა 2 და 1 ნაცვლად 1 და 2.

429
00:18:56,490 --> 00:18:58,160
Swap წარმატებით შესრულებული.

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
მათ სათანადოდ hash შედის cs50
dot h მოიცავს CS50 ბიბლიოთეკაში.

440
00:19:20,310 --> 00:19:22,380
>> ისე, რა ისინი
ეს უნდა გამოვასწოროთ შეცდომა?

441
00:19:22,380 --> 00:19:26,810
მათ უნდა გავაკეთოთ dash lcs50 ზე
ბრძანების ხაზი, როდესაც ისინი შედგენა.

442
00:19:26,810 --> 00:19:29,501
ასე რომ, თუ არ გაივლის
clang dash 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
კარგად, ახლა, მათ არ აქვთ
კეთდება სათანადო hash მოიცავს.

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

450
00:19:41,440 --> 00:19:45,410
ამ კონკრეტულ შემთხვევაში, header ფაილი
ისინი უნდა შეიცავდეს სიმებიანი dot h,

451
00:19:45,410 --> 00:19:48,710
და მათ შორის string dot h, ახლა
სტუდენტი ახლა შემდგენელი

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-- როგორ ისინი შესაბამისი printf.

459
00:20:06,470 --> 00:20:08,890
ასე რომ, printf ჩვენ შეიძლება percent--
ჩვენ შეიძლება ბეჭდვა რაღაც

460
00:20:08,890 --> 00:20:11,380
როგორიცაა პროცენტი i წარმატებული ო.

461
00:20:11,380 --> 00:20:15,310
ან შეიძლება ბეჭდვა, როგორიცაა პროცენტი i,
სივრცეში, პროცენტი i, სივრცე, პროცენტი i.

462
00:20:15,310 --> 00:20:18,950
ასე რომ, თითოეული მათგანი
პროცენტი ნიშნები, ჩვენ გვჭირდება

463
00:20:18,950 --> 00:20:21,560
გაიაროს ცვლადი ბოლოს printf.

464
00:20:21,560 --> 00:20:26,980
>> ასე რომ, თუ ჩვენ ვამბობთ, printf paren პროცენტი
i წარმატებული ო ახლო paren,

465
00:20:26,980 --> 00:20:30,270
ასევე, ჩვენ ვამბობთ, რომ ჩვენ ვართ
აპირებს ბეჭდვა რიცხვი,

466
00:20:30,270 --> 00:20:33,970
მაგრამ მაშინ ჩვენ არ გაივლის printf
რიცხვი რეალურად ბეჭდვა.

467
00:20:33,970 --> 00:20:37,182
ასე რომ, აქ უფრო პროცენტი
კონვერტაციის ვიდრე მონაცემები არგუმენტები?

468
00:20:37,182 --> 00:20:39,390
რომ ვამბობ, რომ ჩვენ გვაქვს
მთელი bunch of პროცენტით,

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
bytes დიდი, ასე რომ თქვენ 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
და, სავარაუდოდ, ეს არის გარკვეული
ერთგვარი ბუფერული overflow.

485
00:21:23,270 --> 00:21:26,560
სადაც თქვენ გაქვთ მასივი, შესაძლოა,
მთელი მასივი, და მოდით

486
00:21:26,560 --> 00:21:30,115
ამბობენ, რომ ეს ზომა 5 და
ცდილობენ შეეხოთ მასივი bracket 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
მე Rob Bowden, და ეს არის CS50.

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