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

2
00:00:09,572 --> 00:00:12,030
आरओबी बोडेन: हाय, मैं, रोब बोडेन हूँ
और के quiz0 के बारे में बात करते हैं.

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

4
00:00:13,280 --> 00:00:14,545
>> तो, पहला सवाल.

5
00:00:14,545 --> 00:00:17,750
इस सवाल कहाँ है
आप नंबर कोड की जरूरत

6
00:00:17,750 --> 00:00:21,270
बाइनरी बल्ब में 127.

7
00:00:21,270 --> 00:00:23,550
अगर तुम चाहते थे, तुम सकता है
नियमित रूपांतरण करना

8
00:00:23,550 --> 00:00:25,950
दशमलव से द्विआधारी करने के लिए, bi-- या से.

9
00:00:25,950 --> 00:00:28,300
लेकिन वह शायद जा रहा है
समय की एक बहुत लेने के लिए.

10
00:00:28,300 --> 00:00:31,750
मैं आपको लगता है कि समझ सकता है, मतलब है,
ठीक है, 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
यही कारण है कि वाम-पंथी प्रकाश बल्ब 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
तो क्या हम हो जा रहे हैं
का प्रतिनिधित्व 7 के माध्यम से 0 है.

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
N बिट्स के साथ, कितने अलग
मानों आप का प्रतिनिधित्व कर सकते हैं?

27
00:01:14,610 --> 00:01:19,080
तो, एन बिट के साथ, आप 2
प्रत्येक बिट के लिए संभव मूल्यों.

28
00:01:19,080 --> 00:01:22,300
इसलिए हम 2 संभव मूल्यों के लिए है
पहले थोड़ा, 2 संभव मूल्यों

29
00:01:22,300 --> 00:01:24,450
दूसरे के लिए, 2
तीसरे के लिए संभव.

30
00:01:24,450 --> 00:01:28,730
और तो है कि 2 बार 2 बार 2, और
अंततः जवाब n करने के लिए 2 है.

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

32
00:01:30,010 --> 00:01:31,100
>> प्रश्न तीन.

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
यह एक की तरह था जो सीएस 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
हम है, जो इस स्क्रैच स्क्रिप्ट है
4 बार मूंगफली का मक्खन जेली दोहरा.

58
00:02:40,320 --> 00:02:42,800
तो कैसे हम सी में कोड कि अब क्या?

59
00:02:42,800 --> 00:02:47,730
खैर, हम here-- बोल्ड में हिस्सा है
आप को लागू करने के लिए था ही हिस्सा है.

60
00:02:47,730 --> 00:02:51,950
इसलिए हम 4 पाशन है कि एक 4 पाश है
टाइम्स, printf आईएनजी मूंगफली का मक्खन जेली,

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
>> प्रश्न छह, एक और स्क्रैच समस्या.

64
00:02:57,490 --> 00:03:00,210
हम एक हमेशा के पाश में देख रहे हैं.

65
00:03:00,210 --> 00:03:05,000
हम चर मैं कह रहे हैं
और फिर 1 से मैं incrementing.

66
00:03:05,000 --> 00:03:09,580
अब हम सी में कर रहे हैं कि क्या करना चाहते हैं
हम यह कर सकता था कई तरीके.

67
00:03:09,580 --> 00:03:12,840
यहाँ हम कोड का क्या हुआ
एक समय (सत्य) के रूप में हमेशा के पाश.

68
00:03:12,840 --> 00:03:16,600
तो हम बस, चर मैं घोषणा
जैसे हम खरोंच में चर मैं था.

69
00:03:16,600 --> 00:03:21,950
चर मैं घोषणा, और हमेशा के लिए
(सच) है, जबकि हम चर मैं कहता हूँ.

70
00:03:21,950 --> 00:03:25,260
Printf% i-- या आप% 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
अब हम बहुत कुछ ऐसा ही करना चाहते हैं
मारियो डॉट ग को समस्या से एक सेट.

75
00:03:35,560 --> 00:03:39,110
हम इन हैशटैग मुद्रित करना चाहते हैं,
हम एक पांच मुद्रित करना चाहते हैं

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
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
इस चर एस में, और उसके बाद
उस चर के मुद्रण.

119
00:05:16,220 --> 00:05:16,720
ठीक.

120
00:05:16,720 --> 00:05:19,090
रेखा एक वर्तमान है तो यही कारण समझा.

121
00:05:19,090 --> 00:05:20,920
# शामिल CS50 डॉट एच.

122
00:05:20,920 --> 00:05:23,820
क्यों हम 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
हम नहीं था तो अगर
# शामिल 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
तो मानक कब डॉट एच.

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
हम हम की जरूरत नहीं कहा तो अगर
मानक कब डॉट ज शामिल करने के लिए,

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 मुख्य (शून्य) है.

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
तो यह सब कार्यक्रम कर रही है
10 से विभाजित 1 printf हैैं है.

158
00:06:55,579 --> 00:06:57,370
तो संकलित जब और
मार डाला, इस कार्यक्रम

159
00:06:57,370 --> 00:07:01,170
outputs के 0.0, भले ही
10 से विभाजित 1 0.1 है.

160
00:07:01,170 --> 00:07:02,970
तो क्यों यह 0.0 है?

161
00:07:02,970 --> 00:07:05,510
खैर, इस वजह से है
पूर्णांक विभाजन की.

162
00:07:05,510 --> 00:07:08,580
तो 1 एक पूर्णांक 10 एक पूर्णांक है, है.

163
00:07:08,580 --> 00:07:11,980
तो 1 से 10, सब कुछ से विभाजित
पूर्णांक के रूप में व्यवहार किया जाता है,

164
00:07:11,980 --> 00:07:16,380
और सी में, हम पूर्णांक विभाजन करते हैं,
हम किसी भी दशमलव बिंदु काटना.

165
00:07:16,380 --> 00:07:19,590
तो 1 से 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
समारोह अगर सच है कि रिटर्न
एन भी अगर एन अजीब और झूठी है.

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
कि एन विभाजित मतलब है कि
2 द्वारा एक शेष था.

211
00:09:28,030 --> 00:09:33,270
2 n से विभाजित है, एक शेष था कि
एन अजीब है, तो हम वापसी सच है कि इसका मतलब है.

212
00:09:33,270 --> 00:09:34,910
वरना हम झूठी वापसी.

213
00:09:34,910 --> 00:09:39,070
तुम भी 2 बराबरी आधुनिक एन किया जा सकता है
शून्य, वरना, झूठी लौटने वापसी सच.

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
एन शून्य से 1 की एफ बाकी वापसी एन बार.

218
00:09:50,430 --> 00:09:52,556
इसलिए इस समारोह में क्या है?

219
00:09:52,556 --> 00:09:54,305
खैर, यह सिर्फ है
भाज्य समारोह.

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

221
00:09:55,410 --> 00:09:57,405
यह अच्छी तरह से प्रतिनिधित्व किया है
n भाज्य के रूप में.

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

223
00:09:58,720 --> 00:10:02,310
>> तो अब 19 सवाल है, हम करना चाहते हैं
इस पुनरावर्ती समारोह ले.

224
00:10:02,310 --> 00:10:04,530
हम यह चलने का बनाना चाहते हैं.

225
00:10:04,530 --> 00:10:05,874
तो हम कैसे करते हो?

226
00:10:05,874 --> 00:10:07,790
वैसे कर्मचारियों के लिए
समाधान, और फिर वहाँ

227
00:10:07,790 --> 00:10:11,090
आप कर सकते थे कई तरीके
, हम इस पूर्णांक उत्पाद के साथ शुरू

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 के बराबर होती है तो, मैं है
से भी कम या एन के बराबर, मैं ++.

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
एन से कम या बराबर है तो अगर
1 के लिए, हम सिर्फ 1 लौट रहे हैं.

235
00:10:32,180 --> 00:10:34,830
मैं 2 के बराबर होती है पर यहाँ तो, हम शुरू करते हैं.

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
और इसलिए हम सिर्फ होगा
1 है जो बदले उत्पाद,.

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
अब हम क्या करने जा रहे हैं
उत्पाद गुना 3 बराबर होती है.

247
00:11:04,040 --> 00:11:04,690
अब यह 6 है.

248
00:11:04,690 --> 00:11:07,500
उत्पाद टाइम्स अब यह 24 है, 4 के बराबर होती है.

249
00:11:07,500 --> 00:11:10,420
उत्पाद टाइम्स अब यह 120 है, 5 के बराबर होती है.

250
00:11:10,420 --> 00:11:16,730
तो फिर अंत में, हम लौट रहे हैं
सही ढंग से 5 भाज्य है जो 120,.

251
00:11:16,730 --> 00:11:17,510
>> प्रश्न 20.

252
00:11:17,510 --> 00:11:22,480
यह आपको भरना होगा जहां एक है
किसी भी एल्गोरिथ्म के साथ इस तालिका में,

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
तत्वों, और यह n के ओ है कि क्यों.

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

267
00:11:59,670 --> 00:12:04,880
>> तो अब यह है कि दोनों कुछ है
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
थीटा परिभाषित किया गया है, जहां एन लॉग एन, की
ओमेगा और बड़ी हे दोनों एक ही हैं.

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
, सबसे अच्छी स्थिति में तो
यह n की बस ओमेगा है.

282
00:12:43,185 --> 00:12:45,960
यह सिर्फ एक अच्छी तरह से नहीं है
के साथ शुरू करने के लिए सूची हल

283
00:12:45,960 --> 00:12:48,270
तो हम n हे स्वैप चुकता है.

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

285
00:12:49,330 --> 00:12:55,610
और अंत में, हम चयन प्रकार है
एन चुकता लिए, ओमेगा और बड़ा ओ दोनों

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
खैर, फिर से पहले की तरह,
हम केवल 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
तो इस पूर्णांक अतिप्रवाह है
आप incrementing रखने के लिए,

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--
उन सभी के बफर 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
और हम आप कर सकते हैं कि आपको बता
एस शून्य नहीं होगा मान,

317
00:14:11,630 --> 00:14:13,790
तो आप के लिए नहीं है
अशक्त के लिए किसी भी जांच करते हैं.

318
00:14:13,790 --> 00:14:16,190
और कई तरीके हैं
आप यह कर सकता था.

319
00:14:16,190 --> 00:14:18,440
यहाँ हम सिर्फ सीधा ले.

320
00:14:18,440 --> 00:14:21,780
हम n, एक काउंटर के साथ शुरू करते हैं. n है
वहाँ कितने वर्ण गिनती.

321
00:14:21,780 --> 00:14:25,560
तो हम हम तो 0 में शुरू, और
पूरी सूची से पुनरावृति.

322
00:14:25,560 --> 00:14:29,092
>> के बराबर है ब्रैकेट 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
तो लाइन से एक में, हम में देखना हमारे
मेज, कि वाई, ए, बी, और 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 और वाई 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
हम के लिए एम्परसेंड एक्स पारित किया
ख के लिए एक, और एम्परसेंड Y.

388
00:17:11,609 --> 00:17:15,160
जहां समस्या पहले
कहा गया है कि एक्स के पते

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
>> अब लाइन तीन पर, एक्स और वाई में क्या कर रहे हैं?

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 है, वाई 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
तो अब हम एक स्टार के बराबर पूर्णांक 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
खैर, एक अंक एक्स के लिए, तो एक स्टार
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
स्टार एक सितारा बी के बराबर होती है.

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
स्टार ख क्या है? Y. Y ख अंक.

415
00:18:18,960 --> 00:18:21,030
तो स्टार ख y है.

416
00:18:21,030 --> 00:18:25,140
तो हम, वाई के लिए एक्स बराबर स्थापित कर रहे हैं
और बाकी सब वही है.

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 है ने कहा,
इसलिए हम tmp वाई बराबर स्थापित कर रहे हैं.

420
00:18:34,740 --> 00:18:37,450
बाकी सब कुछ एक ही है,
इतना सब कुछ नीचे की नकल की जाती है.

421
00:18:37,450 --> 00:18:42,050
हम है, जो tmp के बराबर Y स्थापित कर रहे हैं
वरना एक, और सब कुछ वैसा ही है.

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
हम एक, ख खो दिया है, और है
tmp, लेकिन हम अंततः

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
और हम एक्स और वाई देखते हैं कि
अब 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
कार्यालय समय के दौरान नीचे
एक सीए या 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
वैसे इन प्रतिशत याद है कि
वे printf के लिए प्रासंगिक हो कैसे signs--.

459
00:20:06,470 --> 00:20:08,890
तो printf में हम percent-- सकता है
हम कुछ प्रिंट हो सकता है

460
00:20:08,890 --> 00:20:11,380
प्रतिशत की तरह मैं n बैकस्लैश.

461
00:20:11,380 --> 00:20:15,310
या फिर हम, प्रतिशत मैं जैसे प्रिंट हो सकता है
अंतरिक्ष, प्रतिशत मैं, अंतरिक्ष, प्रतिशत मैं.

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 कोष्ठक प्रतिशत
मैं, एन करीब कोष्ठक बैकस्लैश

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
यही है कि हम कह रहा है
percents की एक पूरी गुच्छा,

469
00:20:39,390 --> 00:20:42,445
और हम काफी चर नहीं है
वास्तव में उन percents में भरने के लिए.

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
तो यह एक वेलग्रिंड त्रुटि है.

473
00:20:52,350 --> 00:20:54,720
यह कह रहा है कि
कहीं अपने कोड में,

474
00:20:54,720 --> 00:20:59,010
आप 40 है कि एक आवंटन है
बाइट्स बड़े तो आप 40 बाइट्स malloced

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
फिर यह एक वेलग्रिंड त्रुटि है.

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
वेलग्रिंड आप कर रहे हैं पहचान करने के लिए जा रहा है
अनुपयुक्त स्मृति को छूने की कोशिश कर रहा.

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