1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [धारा 3] [कम आरामदायक]

2
00:00:03,000 --> 00:00:05,000
>> [नैट Hardison] [हार्वर्ड विश्वविद्यालय]

3
00:00:05,000 --> 00:00:08,000
>> [यह CS50 है.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> ठीक है, हम शुरू हो.

5
00:00:10,000 --> 00:00:13,000
CS50 के 4 सप्ताह के लिए आपका स्वागत है.

6
00:00:13,000 --> 00:00:19,000
यदि आप लोगों के लिए एक वेब ब्राउज़र खोलें और खोलने के 3 pset,

7
00:00:19,000 --> 00:00:23,000
CS50 के साथ हाथापाई, हम करने के लिए जा रहा शुरू करने के लिए जा रहे हैं

8
00:00:23,000 --> 00:00:26,000
वहाँ प्रश्न के अनुभाग के माध्यम से.

9
00:00:26,000 --> 00:00:32,000
पिछले सप्ताह की तरह, हम CS50 रिक्त स्थान में काम करेंगे,

10
00:00:32,000 --> 00:00:35,000
अगर आप यह भी है कि खींच कर के रूप में अच्छी तरह से,

11
00:00:35,000 --> 00:00:43,000
और यदि आप आगे जाना है और इस कड़ी है कि मैं शीर्ष पर यहाँ मिल गया है पर जाएँ.

12
00:00:43,000 --> 00:00:45,000
यह समय है शुरू करने के लिए.

13
00:00:45,000 --> 00:00:51,000
हम हमारी छोटी हाय यहाँ कार्यक्रम मिल गया है. पागल कुछ भी नहीं है.

14
00:00:51,000 --> 00:00:55,000
पहली बातें मैं आज आप लोगों के साथ करना चाहते हैं पर कुछ समाधान जाना है

15
00:00:55,000 --> 00:00:58,000
समस्या 1 सेट, उदाहरण के समाधान की तरह,

16
00:00:58,000 --> 00:01:03,000
सिर्फ इतना आप कोड कर्मचारियों के प्रकार क्या लिख ​​रही है के लिए एक महसूस हो सकता है,

17
00:01:03,000 --> 00:01:07,000
कोड अन्य छात्रों की तरह क्या लिख ​​रहे हैं,

18
00:01:07,000 --> 00:01:10,000
और आप इसे देख ले, क्योंकि मुझे पता है कि यह अजीब है

19
00:01:10,000 --> 00:01:14,000
जब आप एक समस्या सेट करने के लिए एक समाधान प्रस्तुत करते हैं और टिप्पणियां प्राप्त

20
00:01:14,000 --> 00:01:18,000
अपने संस्करण पर है, लेकिन कभी कभी यह उपयोगी है देखने के लिए कैसे अन्य लोगों को यह किया है,

21
00:01:18,000 --> 00:01:22,000
विशेष रूप से अच्छा कर रहे हैं कि लोगों को देख रहे हैं.

22
00:01:22,000 --> 00:01:27,000
अधिकांश भाग के लिए, मैं वास्तव में समाधान है कि आप लोगों का उत्पादन के साथ प्रभावित हुआ था.

23
00:01:27,000 --> 00:01:31,000
मैं अभी तक अपनी समस्या सेट 2s पर तलाश नहीं शुरू कर दिया है, लेकिन अगर वे पहले की तरह कुछ भी कर रहे हैं,

24
00:01:31,000 --> 00:01:34,000
यह कुछ भी नहीं है, लेकिन अच्छी बातें मतलब है.

25
00:01:34,000 --> 00:01:40,000
>> यदि आप अपने संशोधन में देखो, चलो 1 संशोधन में सभी तरह से नीचे शुरू,

26
00:01:40,000 --> 00:01:47,000
और हम एक मारियो समाधान में एक त्वरित देखो ले जा रहे हैं.

27
00:01:47,000 --> 00:01:54,000
यदि आप इस खींच, इन प्रोग्रामों को सही कर रहे हैं कि हम पेश करने के लिए जा रहे हैं.

28
00:01:54,000 --> 00:01:56,000
इन समस्याओं के साथ शुद्धता मुद्दों नहीं थे, बल्कि,

29
00:01:56,000 --> 00:01:59,000
हम विभिन्न डिजाइन मुद्दों के बारे में थोड़ा बात करना चाहता हूँ

30
00:01:59,000 --> 00:02:03,000
कि यहाँ इस्तेमाल किया गया जा रहा है.

31
00:02:03,000 --> 00:02:08,000
समाधान के बारे में बातें है कि दिलचस्प था

32
00:02:08,000 --> 00:02:11,000
यह है कि यह इस नए बुलाया पौंड को परिभाषित का निर्माण का इस्तेमाल किया है,

33
00:02:11,000 --> 00:02:15,000
कभी कभी भी एक हैश के रूप में परिभाषित करने के लिए भेजा है.

34
00:02:15,000 --> 00:02:18,000
मुझे यहाँ पर में ज़ूम.

35
00:02:18,000 --> 00:02:24,000
परिभाषित # एक नाम अपने कार्यक्रम में इन नंबरों के लिए देने के लिए आप की अनुमति देता है.

36
00:02:24,000 --> 00:02:28,000
इस मामले में, मारियो में एक पिरामिड की अधिकतम ऊंचाई

37
00:02:28,000 --> 00:02:34,000
23 किया गया था और के बजाय अपने में 23 डाल कोड

38
00:02:34,000 --> 00:02:37,000
हम कठिन कोडिंग के रूप में 23 के लिए उल्लेख होगा -

39
00:02:37,000 --> 00:02:43,000
बजाय इस कि संख्या नाम MAX_HEIGHT देता है,

40
00:02:43,000 --> 00:02:48,000
तो यहाँ नीचे है, जबकि मेरे पाश में

41
00:02:48,000 --> 00:02:51,000
आप वास्तव में MAX_HEIGHT के लिए उल्लेख कर सकते हैं

42
00:02:51,000 --> 00:02:55,000
के बजाय 23 नंबर डाल अंदर

43
00:02:55,000 --> 00:02:57,000
[छात्र] है कि कर का फायदा क्या है?

44
00:02:57,000 --> 00:02:59,000
यह एक बड़ा सवाल है.

45
00:02:59,000 --> 00:03:03,000
एक पठनीयता है.

46
00:03:03,000 --> 00:03:08,000
इस का उपयोग कर परिभाषित # का एक लाभ यह पठनीयता है.

47
00:03:08,000 --> 00:03:11,000
जब मैं इस कोड पढ़ रहा हूँ, मैं देख सकता हूँ कि क्या हो रहा है.

48
00:03:11,000 --> 00:03:15,000
>> मैं यहाँ इस हालत में देखते हैं कि हम परीक्षण कर रहे हैं, हो सकता है

49
00:03:15,000 --> 00:03:19,000
ऊंचाई के लिए <0, जो हम भी परिभाषित हो सकता है किया जा रहा है

50
00:03:19,000 --> 00:03:22,000
एक न्यूनतम ऊंचाई या एक मिनट ऊंचाई.

51
00:03:22,000 --> 00:03:25,000
अन्य लाभ यह है कि मैं तो लाइन के बाकी को पढ़ने के लिए देख सकते हैं

52
00:03:25,000 --> 00:03:30,000
कि हम भी लगता है कि ऊंचाई अधिकतम ऊंचाई से अधिक नहीं है की जाँच कर रहे हैं,

53
00:03:30,000 --> 00:03:35,000
क्योंकि हम जारी रखने के लिए जा रहे हैं जबकि ऊंचाई अधिकतम ऊंचाई से अधिक है.

54
00:03:35,000 --> 00:03:40,000
अन्य लाभ यह है कि अगर मैं एक छोटा सा ज़ूम

55
00:03:40,000 --> 00:03:49,000
अगर मैं इस कार्यक्रम को चलाने और मैं इसे चलाते हैं, कहते हैं, 23 के साथ अभी,

56
00:03:49,000 --> 00:03:52,000
यह ऐसे ही सभी 23 पंक्तियों प्रिंट होगा.

57
00:03:52,000 --> 00:03:54,000
कहते हैं लेकिन मैं अधिकतम ऊंचाई को बदलना चाहते थे,

58
00:03:54,000 --> 00:03:57,000
और अब मैं पिरामिड की अधिकतम ऊंचाई को सीमित करना चाहते हैं

59
00:03:57,000 --> 00:04:06,000
केवल इतना ही कह आदमी है, कि कायरता था.

60
00:04:06,000 --> 00:04:14,000
# शामिल <stdio.h> # MAX_HEIGHT को परिभाषित,

61
00:04:14,000 --> 00:04:18,000
और हम कहते हैं कि हम यह 10 के बराबर स्थापित करना चाहता था.

62
00:04:18,000 --> 00:04:22,000
अब इस बिंदु पर, सब मुझे करना पड़ा था यह इस एक स्थान में परिवर्तन कर सकते हैं.

63
00:04:22,000 --> 00:04:27,000
मैं कोड recompile कर सकते हैं, और अब अगर मैं कोशिश करते हैं और 12 में टाइप,

64
00:04:27,000 --> 00:04:30,000
यह मुझे फिर से संकेत जाएगा.

65
00:04:30,000 --> 00:04:33,000
इस मामले में, हम केवल MAX_HEIGHT रहे हैं एक बार प्रयोग.

66
00:04:33,000 --> 00:04:37,000
यह एक परेशानी का बड़ा नहीं है कि में जाना है

67
00:04:37,000 --> 00:04:40,000
और यह जबकि पाश में बदलने के लिए अगर आप की जरूरत है.

68
00:04:40,000 --> 00:04:44,000
लेकिन प्रोग्राम है जहाँ आप एक ही जादुई संख्या को संदर्भित कर रहे हैं

69
00:04:44,000 --> 00:04:47,000
पर और फिर से, इस तंत्र को परिभाषित वास्तव में आसान है

70
00:04:47,000 --> 00:04:52,000
क्योंकि तुम सिर्फ यह फ़ाइल यह आम तौर पर है, जहाँ आप उन्हें डाल के शीर्ष पर एक बार बदल

71
00:04:52,000 --> 00:04:57,000
और परिवर्तन फ़ाइल के बाकी के माध्यम से percolates.

72
00:04:57,000 --> 00:05:02,000
>> अन्य बातें मैं इस काम में ध्यान दें कि मैंने सोचा था वास्तव में अच्छा लग रहा है,

73
00:05:02,000 --> 00:05:05,000
एक चर का नामकरण था.

74
00:05:05,000 --> 00:05:14,000
आप यहाँ देख सकते हैं कि हम पूर्णांक चर पंक्ति और ऊंचाई बुलाया बुलाया मिल गया है.

75
00:05:14,000 --> 00:05:20,000
रिक्त स्थान, hashes, यह कोड एक छोटे से अधिक पठनीय बनाने में मदद करता है,

76
00:05:20,000 --> 00:05:25,000
बनाता है यह एक छोटे से अधिक समझ में आता है क्या वास्तव में पर जा रहा है.

77
00:05:25,000 --> 00:05:31,000
इस का उपयोग करने के लिए विपरीत है, कहते हैं, यादृच्छिक पत्र

78
00:05:31,000 --> 00:05:35,000
या बस पूरी तरह gobbledygook.

79
00:05:35,000 --> 00:05:39,000
एक अंतिम बात मैं बाहर बात करेंगे कि loops के लिए,

80
00:05:39,000 --> 00:05:45,000
अक्सर इन iterator चर, इन काउंटरों कि आप loops के लिए अपने उपयोग,

81
00:05:45,000 --> 00:05:51,000
यह मानक और उन्हें या तो मैं और फिर जम्मू के साथ शुरू करने के लिए पारंपरिक और फिर कश्मीर

82
00:05:51,000 --> 00:05:54,000
और वहाँ से चल रहा है अगर आप अधिक चर की जरूरत है,

83
00:05:54,000 --> 00:05:56,000
और यह सिर्फ एक परंपरा है.

84
00:05:56,000 --> 00:05:58,000
सम्मेलनों के बहुत सारे हैं.

85
00:05:58,000 --> 00:06:00,000
यह प्रोग्रामिंग भाषा का प्रयोग कर रहे हैं पर निर्भर करता है.

86
00:06:00,000 --> 00:06:04,000
लेकिन सी में, हम आम तौर पर मैं के साथ शुरू करते हैं.

87
00:06:04,000 --> 00:06:08,000
यह उपयोग करने के लिए समझ बनाने के लिए नहीं, कहते हैं, एक या ख

88
00:06:08,000 --> 00:06:13,000
स्थिति पर निर्भर करता है.

89
00:06:13,000 --> 00:06:15,000
कि यह इस एक के लिए है.

90
00:06:15,000 --> 00:06:25,000
यदि आप अब 2 संशोधन खींच, तुम एक और मारियो देखेंगे,

91
00:06:25,000 --> 00:06:29,000
और यह एक अन्य एक है कि हम सिर्फ देखा करने के लिए समान है,

92
00:06:29,000 --> 00:06:32,000
लेकिन यह कुछ की तरह शांत करता है.

93
00:06:32,000 --> 00:06:38,000
, अगर हम इस खंड में सही यहाँ पाश के लिए भीतरी अंदर देखो

94
00:06:38,000 --> 00:06:44,000
वे कुछ पागल लग वाक्यविन्यास का उपयोग कर रहे हैं यहाँ इस लाइन में सही.

95
00:06:44,000 --> 00:06:47,000
यह एक त्रिगुट ऑपरेटर कहा जाता है.

96
00:06:47,000 --> 00:06:53,000
यह एक अगर किसी और एक लाइन में सघन बयान है.

97
00:06:53,000 --> 00:06:57,000
हालत कोष्ठकों के भीतर यह हिस्सा है.

98
00:06:57,000 --> 00:07:05,000
यह कह के बराबर है j <ऊंचाई अगर मैं - 1.

99
00:07:05,000 --> 00:07:10,000
और फिर क्या की सामग्री है कि अगर ब्लॉक होगा अंतरिक्ष हैं

100
00:07:10,000 --> 00:07:16,000
और तो और क्या होगा की सामग्री #.

101
00:07:16,000 --> 00:07:20,000
यह अनिवार्य रूप से इस चर के लिए एक अंतरिक्ष बताए.

102
00:07:20,000 --> 00:07:24,000
यह ब्लॉक चर की सामग्री में एक जगह रख रहा है,

103
00:07:24,000 --> 00:07:29,000
अगर यह शर्त पूरी होती है, और अगर हालत नहीं मिले है,

104
00:07:29,000 --> 00:07:32,000
तो ब्लॉक चर # हो जाता है.

105
00:07:32,000 --> 00:07:37,000
और फिर, बेशक, बजाय एक पूरे स्ट्रिंग निर्माण

106
00:07:37,000 --> 00:07:43,000
और अंत में सब कुछ बाहर मुद्रण इस समाधान यह प्रिंट बाहर एक समय में एक चरित्र है.

107
00:07:43,000 --> 00:07:48,000
बहुत अच्छा.

108
00:07:48,000 --> 00:07:53,000
>> चीजों को देखने के की एक और जोड़ी. हम पर लालची के लिए कदम होगा.

109
00:07:53,000 --> 00:07:58,000
अब अगर हम लालची को देखो, यह पहली समाधान

110
00:07:58,000 --> 00:08:00,000
इन का उपयोग करता है # काफी एक बिट को परिभाषित करता है.

111
00:08:00,000 --> 00:08:06,000
हम इस कार्यक्रम में विभिन्न संख्या में से प्रत्येक के लिए एक निरंतर परिभाषित मिल गया है.

112
00:08:06,000 --> 00:08:12,000
हम डॉलर प्रति सेंट के लिए एक एक क्वार्टर, ऑफ डाइम्स, nickels, और पैसे के लिए मिल गया है,

113
00:08:12,000 --> 00:08:15,000
और अब अगर हम नीचे स्क्रॉल और कोड को पढ़ने,

114
00:08:15,000 --> 00:08:22,000
हम एक है, जबकि मानक पाश मुद्रण सब कुछ देख सकते हैं.

115
00:08:22,000 --> 00:08:25,000
इस समस्या की जड़ की तरह महसूस किया गया था कि

116
00:08:25,000 --> 00:08:29,000
एक पूर्णांक के लिए नाव है कि आप उपयोगकर्ता से पढ़ा बदलने की जरूरत

117
00:08:29,000 --> 00:08:32,000
करने के लिए सही गणित करते हैं, और इस वजह से है

118
00:08:32,000 --> 00:08:36,000
चल बिन्दु संख्या के साथ, जैसे हम व्याख्यान में के बारे में संक्षेप में बात की,

119
00:08:36,000 --> 00:08:41,000
यह संभव करने के लिए सही संख्या रेखा पर हर एक मूल्य का प्रतिनिधित्व नहीं है

120
00:08:41,000 --> 00:08:47,000
क्योंकि वहाँ के बीच 3 और कहते हैं, भी, 3,1 infinitely कई मान रहे हैं.

121
00:08:47,000 --> 00:08:54,000
आप 3.01 और 3.001 और 3.0001 सकते हैं, और आप जा रख सकते हैं.

122
00:08:54,000 --> 00:09:00,000
यह पता चला है जब भी आप पैसे के साथ काम कर रहे हैं, तो आप अक्सर इसे बदलने के लिए करना चाहते हैं

123
00:09:00,000 --> 00:09:05,000
पूर्णांक प्रारूप में इतनी है कि आप पैसे और सामान की तरह नहीं खो रहे हैं.

124
00:09:05,000 --> 00:09:09,000
कि और गोलाई कर चाबी थी.

125
00:09:09,000 --> 00:09:14,000
यह समाधान एक पूरी तरह से सरल, महान एल्गोरिथ्म का उपयोग किया है,

126
00:09:14,000 --> 00:09:17,000
जो तिमाहियों से 1 सेंट की शेष संख्या, decremented,

127
00:09:17,000 --> 00:09:19,000
फिर ऑफ डाइम्स द्वारा, तो nickels द्वारा, तो पैसे से,

128
00:09:19,000 --> 00:09:24,000
और हर बार के सिक्कों की संख्या जोड़ने.

129
00:09:24,000 --> 00:09:31,000
>> एक अन्य समाधान है कि हम देखते हैं, के रूप में मैं बाहर ज़ूम और 4 संशोधन के लिए जाना है,

130
00:09:31,000 --> 00:09:40,000
एक बहुत ही इसी तरह की शुरुआत है, लेकिन बजाय div और आधुनिक थी

131
00:09:40,000 --> 00:09:44,000
सही यहाँ पर सेंट की संख्या की गणना करने के लिए.

132
00:09:44,000 --> 00:09:50,000
यह तिमाहियों की संख्या 25 सेंट द्वारा विभाजित की संख्या के बराबर है,

133
00:09:50,000 --> 00:09:53,000
और कारण यह काम करता है, क्योंकि हम पूर्णांक विभाजन कर रहे हैं,

134
00:09:53,000 --> 00:09:58,000
तो यह किसी भी शेष discarding है.

135
00:09:58,000 --> 00:10:02,000
[छात्र] हम खोज टिप्पणी है?

136
00:10:02,000 --> 00:10:05,000
यह वास्तव में निर्भर करता है.

137
00:10:05,000 --> 00:10:08,000
[छात्र] आप कोड की तुलना में अधिक टिप्पणी कर रहे हैं ठीक है यहाँ.

138
00:10:08,000 --> 00:10:16,000
हाँ, और इसलिए इस पर अलग दर्शन का एक गुच्छा रहे हैं.

139
00:10:16,000 --> 00:10:21,000
मेरी निजी दर्शन यह है कि आपके कोड वास्तव में सच है,

140
00:10:21,000 --> 00:10:24,000
अपने कोड की तरह है कि क्या वास्तव में कंप्यूटर पर निष्पादित है,

141
00:10:24,000 --> 00:10:29,000
और तो आपके कोड के रूप में संभव के रूप में पठनीय कई टिप्पणी के रूप में की जरूरत के लिए नहीं होना चाहिए.

142
00:10:29,000 --> 00:10:33,000
उस ने कहा, जब आप मुश्किल की बातें कर रहे हैं कि तरह कर रहे हैं गणितीय

143
00:10:33,000 --> 00:10:38,000
या algorithmically, यह अच्छा है इतना है कि आप कर सकते हैं उन टिप्पणी

144
00:10:38,000 --> 00:10:43,000
जो कोई भी अपने कोड को पढ़ने के लिए एक अतिरिक्त आयाम, एक अतिरिक्त परत जोड़ने.

145
00:10:43,000 --> 00:10:49,000
इन समाधान में, वे अक्सर अधिक सिर्फ क्योंकि भारी टिप्पणी कर रहे हैं

146
00:10:49,000 --> 00:10:52,000
हम उन्हें वितरित करने में सक्षम होना चाहते हैं और लोग उन्हें लेने के लिए

147
00:10:52,000 --> 00:10:56,000
और उन्हें बहुत आसानी से पढ़ा.

148
00:10:56,000 --> 00:11:05,000
लेकिन निश्चित रूप से, मैं इस बात से सहमत है कि इस भारी है.

149
00:11:05,000 --> 00:11:07,000
[छात्र] लेकिन जब संदेह में, भारी जाना है?

150
00:11:07,000 --> 00:11:10,000
जब संदेह में, भारी जाना.

151
00:11:10,000 --> 00:11:17,000
कुछ लोगों को कभी कभी वापसी या उस तरह 0 कुछ नहीं कहेगा.

152
00:11:17,000 --> 00:11:20,000
मुझे लगता है कि एक हास्यास्पद टिप्पणी है.

153
00:11:20,000 --> 00:11:22,000
जाहिर है कि क्या हो रहा है.

154
00:11:22,000 --> 00:11:25,000
मैं अंग्रेजी की जरूरत नहीं है मुझे बताओ कि.

155
00:11:25,000 --> 00:11:28,000
कभी कभी लोगों की तरह सामान लिखना होगा "kthxbai!"

156
00:11:28,000 --> 00:11:32,000
यह प्यारा की तरह है, लेकिन यह भी नहीं

157
00:11:32,000 --> 00:11:35,000
कि टिप्पणी अंक या नहीं के बीच अंतर नहीं कर रही है.

158
00:11:35,000 --> 00:11:41,000
उन टिप्पणियों के प्रकार बस हा, हा.

159
00:11:41,000 --> 00:11:43,000
कूल.

160
00:11:43,000 --> 00:11:48,000
>> इस बिंदु पर, सवालों की धारा 3 सेट समस्या पर काम शुरू.

161
00:11:48,000 --> 00:11:52,000
यदि आप लोगों को यह फिर से खींच,

162
00:11:52,000 --> 00:11:55,000
के रूप में पिछले सप्ताह के साथ, हम इस खंड में शॉर्ट्स देखने के लिए नहीं जा रहे हैं.

163
00:11:55,000 --> 00:12:00,000
हम तुम लोगों को अपने समय पर करते हैं और सवालों के बारे में बात करेंगे.

164
00:12:00,000 --> 00:12:05,000
लेकिन अब इस खंड में हम थोड़ा और अधिक समय खर्च करने के लिए जा रहे हैं

165
00:12:05,000 --> 00:12:11,000
कोडन मूल के कम के बारे में बात कर रहे

166
00:12:11,000 --> 00:12:15,000
जैसे हम पिछले हफ्ते किया था, और बजाय, हम पर अधिक ध्यान केंद्रित करने जा रहे हैं

167
00:12:15,000 --> 00:12:22,000
एक छोटा सा सिद्धांत के अधिक है, तो द्विआधारी खोज के बारे में बात कर रहे हैं और फिर छँटाई.

168
00:12:22,000 --> 00:12:27,000
तुम में से जो व्याख्यान के साथ किया गया है साथ निम्नलिखित से,

169
00:12:27,000 --> 00:12:30,000
कोई मुझे क्या फर्क है एक संक्षिप्त दे सकते हैं

170
00:12:30,000 --> 00:12:35,000
द्विआधारी खोज और रैखिक खोज के बीच?

171
00:12:35,000 --> 00:12:37,000
क्या चल रहा है? यकीन है.

172
00:12:37,000 --> 00:12:42,000
सॉर्ट की गई सूची में प्रत्येक तत्व के माध्यम से रेखीय खोज खोजों

173
00:12:42,000 --> 00:12:45,000
एक एक एक एक एक करके,

174
00:12:45,000 --> 00:12:50,000
और द्विआधारी खोज 2 समूहों में सूची बांटता है,

175
00:12:50,000 --> 00:12:57,000
चाबियाँ मूल्य अगर चेक है कि आप के लिए खोज रहे हैं अधिक से अधिक या midpoint मूल्य से कम है

176
00:12:57,000 --> 00:13:00,000
कि आप बस में पाया गया है, और अगर यह तुलना में कम है, यह कम सूची के साथ चला जाता है

177
00:13:00,000 --> 00:13:03,000
और फिर है कि फिर से बांटता है, एक ही कार्य करता है

178
00:13:03,000 --> 00:13:07,000
सभी तरह से नीचे जब तक यह midpoint मूल्य और खुद के बराबर हो पाता है.

179
00:13:07,000 --> 00:13:10,000
सही है.

180
00:13:10,000 --> 00:13:12,000
>> हम क्यों परवाह करूँ?

181
00:13:12,000 --> 00:13:20,000
हम रैखिक खोज बनाम द्विआधारी खोज के बारे में बात क्यों करते हैं?

182
00:13:20,000 --> 00:13:22,000
हाँ.

183
00:13:22,000 --> 00:13:24,000
द्विचर एक बहुत तेजी से है, इसलिए अगर आप समस्या का आकार दोगुना

184
00:13:24,000 --> 00:13:27,000
यह एक के बजाय दो बार के रूप में कई और कदम लेता है.

185
00:13:27,000 --> 00:13:29,000
बिल्कुल सही.

186
00:13:29,000 --> 00:13:31,000
यह एक महान जवाब है.

187
00:13:31,000 --> 00:13:36,000
रैखिक खोज बहुत ज्यादा एक समय में एक तत्व की जाँच,

188
00:13:36,000 --> 00:13:39,000
और जैसा कि हम व्याख्यान के पहले ही दिन पर देखा

189
00:13:39,000 --> 00:13:42,000
जब दाऊद ने अपने फोन की किताब उदाहरण के माध्यम से चला गया

190
00:13:42,000 --> 00:13:45,000
और एक समय में फोन की किताब के एक पृष्ठ फट

191
00:13:45,000 --> 00:13:47,000
और और अधिक से अधिक और अधिक से अधिक है कि फिर से कर रखा है,

192
00:13:47,000 --> 00:13:51,000
यह करने के लिए उसे फोन बुक में किसी को खोजने के लिए एक बहुत लंबे समय ले जा रहा है,

193
00:13:51,000 --> 00:13:55,000
जब तक, ज़ाहिर है, वह किसी के लिए वर्णमाला के बहुत शुरुआत में लग रही थी.

194
00:13:55,000 --> 00:14:00,000
द्विआधारी खोज के साथ, आप एक बहुत तेजी से जा सकते हैं,

195
00:14:00,000 --> 00:14:05,000
और यह सिर्फ तेजी से या तेजी से या उपवास के रूप में 4 बार के रूप में 3 बार के रूप में दो बार नहीं है.

196
00:14:05,000 --> 00:14:13,000
लेकिन समस्या और छोटे छोटे और बहुत छोटे, तेज हो जाता है.

197
00:14:13,000 --> 00:14:17,000
इस वर्णन, क्या हो रहा है के बारे में हम बात कर शुरू करेंगे

198
00:14:17,000 --> 00:14:21,000
जब हम द्विआधारी खोज लिखें.

199
00:14:21,000 --> 00:14:27,000
हाथ में समस्या यह है कि अगर मैं संख्या की एक सरणी है,

200
00:14:27,000 --> 00:14:40,000
कहते हैं, 1, 2, 3, 5, 7, 23, 45, 78, 12323,

201
00:14:40,000 --> 00:14:47,000
और फिर इसे बाद 0s की एक टन के साथ 9,

202
00:14:47,000 --> 00:14:52,000
हम वास्तव में जल्दी से बाहर निकालने के लिए क्या में है सक्षम होना चाहते हैं

203
00:14:52,000 --> 00:14:57,000
संख्या के इस सरणी.

204
00:14:57,000 --> 00:15:00,000
मुझे पता है कि यह एक छोटे से पागल लगता है और एक छोटे से काल्पनिक,

205
00:15:00,000 --> 00:15:02,000
क्योंकि अभी यह है.

206
00:15:02,000 --> 00:15:05,000
हम एक सरणी में बहुत सारे तत्व नहीं है,

207
00:15:05,000 --> 00:15:08,000
और अगर मैं आप से पूछना बाहर निकालने के लिए है कि क्या है या नहीं

208
00:15:08,000 --> 00:15:11,000
23 सरणी में है, आपको लगता है कि बहुत जल्दी कर सकते हैं

209
00:15:11,000 --> 00:15:16,000
सिर्फ इस पर glancing और मुझे हाँ या कोई कह रहा है.

210
00:15:16,000 --> 00:15:20,000
पर विचार करने के लिए अनुरूप अगर यह थे कल्पना है, कहते हैं,

211
00:15:20,000 --> 00:15:27,000
10,000 पंक्तियाँ, 20,000 पंक्तियों के साथ एक एक्सेल स्प्रेडशीट.

212
00:15:27,000 --> 00:15:31,000
बेशक, आप आदेश एफ या नियंत्रण एफ करते हैं और कुछ देखने के लिए कर सकते हैं.

213
00:15:31,000 --> 00:15:33,000
तुम भी फिल्टर और सामान खोज का उपयोग कर सकते हैं,

214
00:15:33,000 --> 00:15:37,000
लेकिन अगर आप लाइन से लाइन के द्वारा उस फ़ाइल लाइन के माध्यम से देखने के लिए किया था,

215
00:15:37,000 --> 00:15:40,000
यह आप एक लंबे समय लेने के लिए यह मिल जाएगा.

216
00:15:40,000 --> 00:15:42,000
यह फोन की किताब उदाहरण में तरह तरह की है, भी, जहां

217
00:15:42,000 --> 00:15:44,000
कोई भी एक समय में एक फोन की किताब के एक पृष्ठ के माध्यम से लग रहा है.

218
00:15:44,000 --> 00:15:47,000
आमतौर पर, वे इसे बीच करने के लिए खुला नहीं है,

219
00:15:47,000 --> 00:15:50,000
या फोन किताबों और शब्दकोशों के एक बहुत कुछ के मामले में

220
00:15:50,000 --> 00:15:54,000
आप वास्तव में इसे पहले अक्षर पर बंद है,

221
00:15:54,000 --> 00:16:01,000
आप कि पहले अक्षर फ्लिप और खुला और वहाँ के माध्यम से जा रहा शुरू करते हैं.

222
00:16:01,000 --> 00:16:03,000
>> अपने नाम के मुझे फिर याद दिलाना >> सैम.

223
00:16:03,000 --> 00:16:05,000
सैम.

224
00:16:05,000 --> 00:16:11,000
जैसे सैम ने कहा, कि रैखिक खोज की प्रक्रिया वास्तव में धीमी गति से हो रहा है,

225
00:16:11,000 --> 00:16:15,000
और बजाय द्विआधारी खोज के साथ, जिस तरह से यह काम करता है कि

226
00:16:15,000 --> 00:16:21,000
हर समय हम हमारे खोज एल्गोरिथ्म के एक चलना के माध्यम से चलते हैं,

227
00:16:21,000 --> 00:16:27,000
हम में आधा सूची में विभाजित है, अनिवार्य रूप से जा रहे हैं,

228
00:16:27,000 --> 00:16:33,000
दो छोटे सूची में.

229
00:16:33,000 --> 00:16:39,000
और फिर पाश की अगली यात्रा पर, हम इसे फिर से विभाजित हूँ

230
00:16:39,000 --> 00:16:44,000
अन्य छोटे सूची में.

231
00:16:44,000 --> 00:16:48,000
जैसा कि आप देख सकते हैं, समस्या छोटी हो रही रखता है और छोटे

232
00:16:48,000 --> 00:16:55,000
क्योंकि हम हर बार सूची की discarding आधा रखने.

233
00:16:55,000 --> 00:16:59,000
यह कैसे त्यागें काम करता है?

234
00:16:59,000 --> 00:17:05,000
बस एक चेतावनी के रूप में, हम क्या करना जा रहे हैं अगर हम एक कंप्यूटर थे

235
00:17:05,000 --> 00:17:11,000
और हम कह रहे थे, इस सूची में नंबर 5 के लिए खोज

236
00:17:11,000 --> 00:17:15,000
यह है कि हम बीच में एक नंबर लेने होगा.

237
00:17:15,000 --> 00:17:26,000
इस सूची के बीच में है, क्योंकि वहाँ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 नंबर हैं,

238
00:17:26,000 --> 00:17:32,000
हम या तो 4 की स्थिति में या संख्या 5 की स्थिति में उठा था,

239
00:17:32,000 --> 00:17:38,000
और हम है कि हमारी सूची के बीच फोन था.

240
00:17:38,000 --> 00:17:42,000
बीच में संख्या उठाओ.

241
00:17:42,000 --> 00:17:51,000
तब, जैसे सैम ने कहा, हम देखना का परीक्षण है कि अगर संख्या बराबर है

242
00:17:51,000 --> 00:17:59,000
संख्या है कि हम प्राप्त करना चाहते हैं या हमारे वांछित संख्या.

243
00:17:59,000 --> 00:18:06,000
अगर यह बराबर है, तो हम इसे मिला है. हम जीतने के लिए.

244
00:18:06,000 --> 00:18:12,000
यदि यह नहीं के बराबर है, तो वहाँ के मामलों के एक जोड़े हैं.

245
00:18:12,000 --> 00:18:15,000
दो मामलों में या तो संख्या संख्या हम देख रहे हैं की तुलना में अधिक हो गया है,

246
00:18:15,000 --> 00:18:19,000
या यह की तुलना में कम है.

247
00:18:19,000 --> 00:18:25,000
यदि यह अधिक से अधिक है, हम सही करने के लिए कदम.

248
00:18:25,000 --> 00:18:33,000
और अगर यह कम है, हम करने के लिए कदम छोड़ दिया.

249
00:18:33,000 --> 00:18:41,000
और फिर हम पूरी प्रक्रिया को फिर से दोहराने

250
00:18:41,000 --> 00:18:48,000
या तो सही आधा या सूची के बाईं आधा.

251
00:18:48,000 --> 00:18:51,000
>> आज के अनुभाग में पहली समस्या के लिए बाहर आंकड़ा है

252
00:18:51,000 --> 00:18:55,000
हम वास्तव में कैसे सी कोड में इस व्यक्त शुरू कर सकते हैं.

253
00:18:55,000 --> 00:18:58,000
हम pseudocode यहाँ मिल गया है.

254
00:18:58,000 --> 00:19:04,000
हम क्या कर शुरू करने के लिए है मैं एक नया अंतरिक्ष खींच लेंगे,

255
00:19:04,000 --> 00:19:09,000
इस संशोधन को बचाने के लिए इतना है कि हम इन नोटों बाद,

256
00:19:09,000 --> 00:19:20,000
हम यह सब नष्ट कर देंगे, और फिर कॉपी और पेस्ट समस्या सेट से

257
00:19:20,000 --> 00:19:26,000
हमारे रिक्त स्थान में इस जानकारी है, और उम्मीद है कि यह नहीं तोड़ नहीं है.

258
00:19:26,000 --> 00:19:28,000
बिल्कुल सही.

259
00:19:28,000 --> 00:19:33,000
यदि आप लोग सब करते हैं कि कॉपी करने के लिए, और अपने नए अंतरिक्ष में इस कोड को पेस्ट करने के लिए,

260
00:19:33,000 --> 00:19:43,000
एक रिक्त एक में.

261
00:19:43,000 --> 00:19:47,000
डैनियल की कोशिश. यदि आप संकलन और इस कार्यक्रम को चलाने के लिए, यह काम करता है?

262
00:19:47,000 --> 00:19:49,000
सं >> यह क्या कह रहा है?

263
00:19:49,000 --> 00:19:53,000
इसे कहते हैं, नियंत्रण गैर शून्य समारोह के अंत तक पहुँचता है.

264
00:19:53,000 --> 00:19:55,000
हाँ, तो मुझे इसे चलाने की कोशिश करें.

265
00:19:55,000 --> 00:19:59,000
क्या आप लोग इस से पहले देखा है? क्या आप जानते हैं कि यह क्या मतलब है?

266
00:19:59,000 --> 00:20:01,000
ठीक है, चलो यह एक छोटा सा काटना.

267
00:20:01,000 --> 00:20:10,000
यह file.c में 9 लाइन पर कह रहा है, स्तंभ 1 हम एक त्रुटि है, जैसे तुम ने कहा,

268
00:20:10,000 --> 00:20:16,000
और यह कहते हैं कि यह त्रुटि चेतावनी और रिटर्न प्रकार चेतावनी से stemming है.

269
00:20:16,000 --> 00:20:18,000
ऐसा लगता है जैसे कुछ पर रिटर्न प्रकार है, जो समझ में आता है के साथ जा रहा है.

270
00:20:18,000 --> 00:20:21,000
हम एक गैर शून्य समारोह मिल गया है, जिसका अर्थ है कि हम एक समारोह मिल गया है

271
00:20:21,000 --> 00:20:24,000
उस शून्य को वापस नहीं करता है.

272
00:20:24,000 --> 00:20:27,000
एक शून्य समारोह एक है कि इस तरह दिखता है:

273
00:20:27,000 --> 00:20:35,000
शून्य foo (), और यह शून्य है क्योंकि रिटर्न प्रकार शून्य है,

274
00:20:35,000 --> 00:20:38,000
जिसका मतलब है कि अगर हम यहाँ में कुछ था

275
00:20:38,000 --> 00:20:45,000
1 वापसी की तरह, हम इस बात के लिए एक संकलक त्रुटि मिलता था.

276
00:20:45,000 --> 00:20:49,000
हालांकि, हम एक गैर शून्य समारोह है.

277
00:20:49,000 --> 00:20:51,000
इस मामले में हमारे गैर शून्य समारोह हमारे खोज समारोह है

278
00:20:51,000 --> 00:20:56,000
क्योंकि यह bool का एक रिटर्न प्रकार है.

279
00:20:56,000 --> 00:20:59,000
जब यह कह रहा है कि नियंत्रण एक गैर शून्य समारोह के अंत तक पहुँचता है

280
00:20:59,000 --> 00:21:02,000
यह इसलिए है क्योंकि खोज एक वापसी बयान नहीं है.

281
00:21:02,000 --> 00:21:04,000
यह bool प्रकार के कुछ भी नहीं लौट रहा है.

282
00:21:04,000 --> 00:21:09,000
>> हम जानते हैं कि ठीक कर सकते हैं, और तुम लोग क्या सोचते हैं

283
00:21:09,000 --> 00:21:13,000
खोज डिफ़ॉल्ट रूप से वापस आ जाना चाहिए?

284
00:21:13,000 --> 00:21:16,000
खोज के डिफ़ॉल्ट मान क्या होना चाहिए?

285
00:21:16,000 --> 00:21:19,000
क्योंकि है कि क्या हम अंत में डाल सकते हैं.

286
00:21:19,000 --> 00:21:21,000
Charlotte, आप किसी भी?

287
00:21:21,000 --> 00:21:23,000
यह सही है या गलत? >> यह सही है या गलत है.

288
00:21:23,000 --> 00:21:26,000
कौन सा?

289
00:21:26,000 --> 00:21:28,000
झूठी. मुझे नहीं मालूम.

290
00:21:28,000 --> 00:21:30,000
गलत? चलो इसे करने की कोशिश.

291
00:21:30,000 --> 00:21:32,000
आप वापसी झूठी क्यों कहेंगे? वह महान अंतर्ज्ञान है.

292
00:21:32,000 --> 00:21:35,000
[Charlotte] मुझे नहीं मालूम.

293
00:21:35,000 --> 00:21:39,000
हम इस मामले में झूठी वापस जा रहे हैं क्योंकि यह हमारे डिफ़ॉल्ट होगा

294
00:21:39,000 --> 00:21:44,000
अगर किसी कारण के लिए सूची खाली या सुई

295
00:21:44,000 --> 00:21:46,000
कि हम मौजूद नहीं है के लिए देख रहे हैं.

296
00:21:46,000 --> 00:21:50,000
तो बहुत अंत में, अगर हम सच्चे पहले इस समारोह में वापस नहीं करते हैं,

297
00:21:50,000 --> 00:21:55,000
हम हमेशा से जानते हैं कि इस समारोह कहेंगे नहीं, यह सरणी में नहीं है.

298
00:21:55,000 --> 00:21:58,000
यह घास के ढेर में नहीं है.

299
00:21:58,000 --> 00:22:03,000
अब अगर हम संकलन और इसे चलाने मुझे बचाने के लिए तो हम इसे खींच कर सकते हैं.

300
00:22:03,000 --> 00:22:08,000
अब अगर हम संकलन और हमारे कार्यक्रम चलाते हैं, यह बनाता है.

301
00:22:08,000 --> 00:22:12,000
हम अपने छोटे से संकेत मिलता है.

302
00:22:12,000 --> 00:22:20,000
अगर मैं मारा 4-उह, ओह.

303
00:22:20,000 --> 00:22:25,000
यह बाहर कुछ भी मुद्रित नहीं किया. ऐसा लगता है कि सब कुछ ठीक समाप्त हो गया.

304
00:22:25,000 --> 00:22:35,000
हम इस भरने के अंदर करने के लिए मिल गया है

305
00:22:35,000 --> 00:22:39,000
हम pseudocode में एल्गोरिथ्म के बारे में थोड़ा पहले बात की थी.

306
00:22:39,000 --> 00:22:44,000
मुझे देखने दो, इसे बचाने के लिए,

307
00:22:44,000 --> 00:22:49,000
और मुझे लगता है कि एल्गोरिथ्म वापस खींचने के ऊपर फिर से हूँ.

308
00:22:49,000 --> 00:22:51,000
चलो इस आदमी मारा. नहीं.

309
00:22:51,000 --> 00:22:58,000
वहाँ यह है.

310
00:22:58,000 --> 00:23:03,000
हम यह कैसे करते हो?

311
00:23:03,000 --> 00:23:11,000
इस कोड से शुरू करने के लिए एक अच्छी रणनीति क्या होगा?

312
00:23:11,000 --> 00:23:16,000
आप बीच में एक नंबर लेने है.

313
00:23:16,000 --> 00:23:23,000
हम कैसे एक सरणी के बीच में एक नंबर लेने?

314
00:23:23,000 --> 00:23:25,000
कोई सुझाव?

315
00:23:25,000 --> 00:23:27,000
Strlen [छात्र] 2 से विभाजित.

316
00:23:27,000 --> 00:23:32,000
Strlen 2 से विभाजित. यह एक महान एक है.

317
00:23:32,000 --> 00:23:35,000
Strlen arrays के विशेष प्रकार के साथ काम करता है.

318
00:23:35,000 --> 00:23:38,000
Arrays के किस प्रकार?

319
00:23:38,000 --> 00:23:44,000
स्ट्रिंग arrays, चरित्र arrays.

320
00:23:44,000 --> 00:23:48,000
यह अवधारणा की है कि एक ही तरह की है कि हम पर लागू करना चाहते हैं,

321
00:23:48,000 --> 00:23:52,000
लेकिन हम strlen उपयोग नहीं है क्योंकि हम वर्णों की एक सरणी नहीं कर सकता है.

322
00:23:52,000 --> 00:23:55,000
हम ints की एक सरणी है.

323
00:23:55,000 --> 00:23:58,000
लेकिन strlen हमारे लिए क्या मिलता है?

324
00:23:58,000 --> 00:24:01,000
क्या आप जानते हैं कि यह हमारे लिए क्या हो जाता है?

325
00:24:01,000 --> 00:24:03,000
Strlen [] छात्र हमें लंबाई हो जाता है.

326
00:24:03,000 --> 00:24:05,000
वास्तव में, यह हमें लंबाई हो जाता है.

327
00:24:05,000 --> 00:24:09,000
Strlen हमारे लिए सरणी की लंबाई हो जाता है.

328
00:24:09,000 --> 00:24:14,000
>> हम हमारे द्विआधारी खोज कार्यक्रम में कैसे मिलता है?

329
00:24:14,000 --> 00:24:18,000
आप एक सरणी की लंबाई कैसे मिलेगा?

330
00:24:18,000 --> 00:24:20,000
[छात्र] strlen?

331
00:24:20,000 --> 00:24:25,000
आप strlen के साथ एक ठीक से प्रारूपित सी स्ट्रिंग सरणी की लंबाई प्राप्त कर सकते हैं.

332
00:24:25,000 --> 00:24:31,000
समस्या है, हालांकि, कि हम एक स्ट्रिंग सरणी नहीं है.

333
00:24:31,000 --> 00:24:36,000
यदि हम इस कोड पर वापस देखो, हम इस पूर्णांक सरणी है.

334
00:24:36,000 --> 00:24:38,000
हमें कैसे पता चलेगा कितना समय है?

335
00:24:38,000 --> 00:24:44,000
[छात्र] वहाँ endpoint के लिए एक बराबर int एल या कुछ और की तरह, एक है?

336
00:24:44,000 --> 00:24:49,000
यह वहाँ बाहर वास्तव में नहीं है बदल जाता है, और इसलिए एक तरह से, यह है

337
00:24:49,000 --> 00:24:52,000
उन चीजें हैं जो सिर्फ सी के बारे में पता करने के लिए अच्छा है,

338
00:24:52,000 --> 00:24:57,000
कि वहाँ एक सरणी की लंबाई पाने के लिए कोई रास्ता है

339
00:24:57,000 --> 00:24:59,000
अगर मैं तुम्हें दे सरणी है.

340
00:24:59,000 --> 00:25:02,000
कारण यह तार के साथ काम करता है, strlen काम करता है कारण,

341
00:25:02,000 --> 00:25:06,000
अगर एक स्ट्रिंग ठीक से स्वरूपित है, क्योंकि

342
00:25:06,000 --> 00:25:12,000
यह बहुत अंत में है कि विशेष \ 0 चरित्र होगा.

343
00:25:12,000 --> 00:25:16,000
>> तुम भी कल्पना कर सकते हैं अगर आप एक अनुचित स्वरूपित स्ट्रिंग

344
00:25:16,000 --> 00:25:20,000
और वहाँ कोई \ 0 चरित्र वहाँ है, तो पूरी बात नहीं काम करता है.

345
00:25:20,000 --> 00:25:22,000
[छात्र] आप \ 0 जोड़ सकते हैं?

346
00:25:22,000 --> 00:25:24,000
हम इस मामले में हो सकता है.

347
00:25:24,000 --> 00:25:29,000
हम \ 0 के कुछ प्रकार जोड़ सकता

348
00:25:29,000 --> 00:25:33,000
या चरित्र वाचक और तब के कुछ प्रकार का उपयोग करें.

349
00:25:33,000 --> 00:25:36,000
लेकिन यह है कि काम करने के लिए काफी नहीं जा रहा है

350
00:25:36,000 --> 00:25:40,000
क्योंकि \ 0 चार प्रकार के लिए है,

351
00:25:40,000 --> 00:25:43,000
और यहाँ हम ints मिल गया है.

352
00:25:43,000 --> 00:25:46,000
दूसरी बात यह है कि अगर हम एक विशेष मूल्य का उपयोग करने के लिए गए थे

353
00:25:46,000 --> 00:25:49,000
-1 की तरह एक सरणी के अंत के निशान

354
00:25:49,000 --> 00:25:54,000
तो हम एक -1 हमारे पूर्णांक arrays में कभी नहीं की दुकान सकता है.

355
00:25:54,000 --> 00:25:56,000
हम अटक होगी.

356
00:25:56,000 --> 00:26:00,000
यह पता चला है कि लंबाई प्राप्त करने के लिए एक ही रास्ता

357
00:26:00,000 --> 00:26:03,000
सी में एक सरणी के लिए वास्तव में यह याद है

358
00:26:03,000 --> 00:26:08,000
जब आप इसे सेट अप और फिर इसे सरणी के साथ चारों ओर से गुजारें

359
00:26:08,000 --> 00:26:14,000
इतना है कि जब भी मैं एक समारोह में कहा कि कुछ काम करने के लिए जा रहा है

360
00:26:14,000 --> 00:26:18,000
integers या मंगाई की एक सरणी पर या युगल या तुम क्या है,

361
00:26:18,000 --> 00:26:22,000
मैं भी समारोह सरणी लंबाई देने की जरूरत है,

362
00:26:22,000 --> 00:26:26,000
और कहा कि वास्तव में हम क्या यहाँ खोज समारोह में किया है.

363
00:26:26,000 --> 00:26:30,000
अगर तुम देखो, क्या हम जब हम हमारे यहाँ सरणी में से गुजारें किया है,

364
00:26:30,000 --> 00:26:36,000
हम भी लंबाई, आकार में पारित.

365
00:26:36,000 --> 00:26:41,000
यह सिर्फ यह होता है कि हम इस चर यहाँ बुलाया है,

366
00:26:41,000 --> 00:26:43,000
इस पैरामीटर या तर्क.

367
00:26:43,000 --> 00:26:46,000
यह एक समारोह तर्क सूची या पैरामीटर सूची कहा जाता है,

368
00:26:46,000 --> 00:26:51,000
और ये भी तर्क या पैरामीटर कहा जाता है.

369
00:26:51,000 --> 00:26:53,000
लोग अलग अलग समय पर विभिन्न पदों का उपयोग करें.

370
00:26:53,000 --> 00:26:55,000
मैं कभी कभी उन्हें खुद विनिमय.

371
00:26:55,000 --> 00:27:00,000
यह सिर्फ इतना होता है कि यह यहाँ चर इसी नाम है

372
00:27:00,000 --> 00:27:03,000
# यहाँ परिभाषित करते हैं.

373
00:27:03,000 --> 00:27:06,000
लेकिन वे एक ही बात नहीं कर रहे हैं.

374
00:27:06,000 --> 00:27:11,000
पूंजीकरण बात करता है.

375
00:27:11,000 --> 00:27:14,000
>> यदि आप यहाँ क्या होता है पर देखो, हम घोषणा

376
00:27:14,000 --> 00:27:18,000
हमारे int सरणी, जो हम संख्या बुलाया है.

377
00:27:18,000 --> 00:27:23,000
हम यह हमारे आकार दिया है, जो हमारे शीर्ष पर # को परिभाषित करने के लिए मेल खाती है.

378
00:27:23,000 --> 00:27:27,000
यह 8 होने जा रहा है.

379
00:27:27,000 --> 00:27:35,000
और फिर जब हम तो नीचे हमारे खोज समारोह कॉल नीचे,

380
00:27:35,000 --> 00:27:40,000
हम संख्या में गुजरती हैं हम के लिए खोज करने के लिए करना चाहते हैं, जो हम लिए कहा जाए है,

381
00:27:40,000 --> 00:27:43,000
उपयोगकर्ता से मिल गया है.

382
00:27:43,000 --> 00:27:46,000
हम सरणी में पारित, इस संख्या,

383
00:27:46,000 --> 00:27:51,000
और फिर हम भी सरणी के आकार में पारित करने के लिए है,

384
00:27:51,000 --> 00:27:57,000
और फिर 8 आकार का मूल्य जमा हो जाता है

385
00:27:57,000 --> 00:28:01,000
या इस पूर्णांक चर बुलाया आकार को पारित कर दिया.

386
00:28:01,000 --> 00:28:08,000
हम सरणी के आकार की है.

387
00:28:08,000 --> 00:28:11,000
अब अगर हम क्या हम पहले के बारे में बात कर रहे थे करने के लिए वापस जाओ,

388
00:28:11,000 --> 00:28:14,000
मुझे लगता है कि Missy मुद्दा यह है कि हम क्या करने की जरूरत है सरणी की लंबाई मिल रहा है लाया

389
00:28:14,000 --> 00:28:20,000
और यह 2 से विभाजित है, और है कि हमें midpoint दे देंगे.

390
00:28:20,000 --> 00:28:22,000
चलो देखते हैं.

391
00:28:22,000 --> 00:28:25,000
मैं किसी को इस लिखने और उनके अंतरिक्ष में बचाने कर सकते हैं?

392
00:28:25,000 --> 00:28:27,000
लीला के बारे में कैसे?

393
00:28:27,000 --> 00:28:31,000
मैं तुम्हें इस में लिखने के लिए कर सकते हैं?

394
00:28:31,000 --> 00:28:35,000
पहली पंक्ति लिखें जहाँ आप सरणी की लंबाई ले और midpoint

395
00:28:35,000 --> 00:28:41,000
और यह एक नया चर में संग्रहीत हैं.

396
00:28:41,000 --> 00:28:44,000
मैं तुम्हें कुछ सेकंड दे देंगे. क्या आप तैयार हैं?

397
00:28:44,000 --> 00:28:46,000
[छात्र अश्राव्य]

398
00:28:46,000 --> 00:28:50,000
बेशक, मैं आप midpoint सकता है की गणना है

399
00:28:50,000 --> 00:28:55,000
सूखी घास का ढेर सरणी की खोज समारोह के अंदर

400
00:28:55,000 --> 00:29:03,000
टेबल सरणी की लंबाई का उपयोग, जो आकार चर रहा है?

401
00:29:03,000 --> 00:29:08,000
मुश्किल कुछ भी नहीं है यहाँ.

402
00:29:08,000 --> 00:29:12,000
लीला [] बस / 2 आकार और बस

403
00:29:12,000 --> 00:29:17,000
और इसे बचाने के लिए, और सहेजें बटन शीर्ष पर मारा,

404
00:29:17,000 --> 00:29:19,000
और हम इसे खींच देंगे.

405
00:29:19,000 --> 00:29:22,000
बिल्कुल सही.

406
00:29:22,000 --> 00:29:28,000
हम वहाँ जाते हैं. बहुत बढ़िया.

407
00:29:28,000 --> 00:29:30,000
>> के रूप में है, यह संकलन होगा?

408
00:29:30,000 --> 00:29:32,000
[लीला] नहीं, यह अधिक होने की जरूरत है.

409
00:29:32,000 --> 00:29:34,000
[नैट] हाँ, तो हम क्या करने की आवश्यकता है?

410
00:29:34,000 --> 00:29:36,000
[लीला] int midpoint या कुछ और की तरह.

411
00:29:36,000 --> 00:29:41,000
बहुत बढ़िया. हाँ, चलो करना है कि, मध्य int आकार =.

412
00:29:41,000 --> 00:29:44,000
इस संकलन होगा?

413
00:29:44,000 --> 00:29:47,000
चलो इस टिप्पणी को हटाना और यह रास्ते से हट जाओ.

414
00:29:47,000 --> 00:29:50,000
क्या इस बारे में संकलन नहीं होगा?

415
00:29:50,000 --> 00:29:52,000
हम पूर्णांक के साथ कुछ भी नहीं कर रहे हैं,

416
00:29:52,000 --> 00:29:55,000
तो हम इसे या कुछ की तरह है कि प्रिंट की जरूरत है.

417
00:29:55,000 --> 00:29:58,000
हाँ, बिल्कुल.

418
00:29:58,000 --> 00:30:00,000
हम एक अप्रयुक्त चर मिलेगा.

419
00:30:00,000 --> 00:30:02,000
और क्या इस बारे में काम करने के लिए नहीं जा रहा है?

420
00:30:02,000 --> 00:30:06,000
मुझे लगता है कि आप कुछ कहा, सैम. अर्धविरामों.

421
00:30:06,000 --> 00:30:08,000
हाँ, मैं उन अर्धविरामों याद आ रही है.

422
00:30:08,000 --> 00:30:14,000
यह कार्यकाल के दौरान के दौरान एक निरंतर बात होने जा रहा है.

423
00:30:14,000 --> 00:30:17,000
अंतिम बात मैं क्या हूँ मैं दोनों तरफ कुछ सफेद स्थान डाल देता हूँ

424
00:30:17,000 --> 00:30:23,000
यहाँ इस ऑपरेटर के बाद से है कि आम तौर पर हम इसे कैसे करते

425
00:30:23,000 --> 00:30:26,000
हमारे शैली गाइड के अनुसार.

426
00:30:26,000 --> 00:30:29,000
हम हमारे सरणी के midpoint मिल गया है.

427
00:30:29,000 --> 00:30:32,000
अब अगर हम अपने एल्गोरिथ्म वापस याद

428
00:30:32,000 --> 00:30:37,000
दूसरा कदम है कि हम ऐसा करने के लिए एक बार हम midpoint था क्या था?

429
00:30:37,000 --> 00:30:42,000
[छात्र] यदि यह अधिक से अधिक है [अश्राव्य]

430
00:30:42,000 --> 00:30:48,000
हाँ, तो हम तुलना के कुछ प्रकार करना है, और हम यहाँ क्या तुलना कर रहे हैं?

431
00:30:48,000 --> 00:30:53,000
तुमने कहा था कि अगर यह से अधिक होता है. यह कि वाक्य में जिक्र करने के लिए क्या है?

432
00:30:53,000 --> 00:30:57,000
संख्या है कि ऊपर आता है, कि अगर midpoint से अधिक है, तो सरणी के लिए ऊपर जाना है?

433
00:30:57,000 --> 00:31:05,000
वास्तव में, तो संख्या है कि ऊपर आता है जब हम

434
00:31:05,000 --> 00:31:10,000
सुई, तो हम सुई के लिए तुलना कर रहे हैं,

435
00:31:10,000 --> 00:31:12,000
और हम क्या सुई के खिलाफ तुलना कर रहे हैं?

436
00:31:12,000 --> 00:31:15,000
क्योंकि सुई है कि हम क्या देख रहे हैं.

437
00:31:15,000 --> 00:31:18,000
हम यह तुलना कर रहे हैं midpoint के लिए मिलता है.

438
00:31:18,000 --> 00:31:21,000
>> लेकिन यह समझ पड़ता है देखने के लिए जाँच

439
00:31:21,000 --> 00:31:27,000
अगर सुई = midpoint?

440
00:31:27,000 --> 00:31:32,000
क्या इसका यह मतलब है?

441
00:31:32,000 --> 00:31:35,000
क्या किसी को भी असहमत हैं?

442
00:31:35,000 --> 00:31:40,000
चलो यह एक कोशिश दे, अगर (सुई == मध्य).

443
00:31:40,000 --> 00:31:42,000
[छात्र] printf क्या आप यह पाया.

444
00:31:42,000 --> 00:31:51,000
[नैट] printf ("हम यह पाया \ n!");

445
00:31:51,000 --> 00:31:56,000
अन्यथा - मैं यहाँ कुछ अलग कर रही शुरू करने के लिए जा रहा है.

446
00:31:56,000 --> 00:32:00,000
मैं हर समय के आसपास बयान अगर ब्रेसिज़ डाल शुरू करने के लिए जा रहा हूँ

447
00:32:00,000 --> 00:32:05,000
सिर्फ इसलिए कि अगर हम और अधिक सामान है, तो जोड़ने

448
00:32:05,000 --> 00:32:07,000
हम compilers नहीं मिलता है.

449
00:32:07,000 --> 00:32:09,000
हाँ, सैम. तुम एक मुद्दा मिल गया है.

450
00:32:09,000 --> 00:32:12,000
समस्या यह है कि midpoint सरणी में एक स्थिति का प्रतिनिधित्व करता है,

451
00:32:12,000 --> 00:32:15,000
लेकिन आप यह सरणी की है कि स्थिति में मूल्य का प्रतिनिधित्व करने के लिए मिल सकता है.

452
00:32:15,000 --> 00:32:17,000
यह एक बड़ा मुद्दा है.

453
00:32:17,000 --> 00:32:19,000
क्या सबको सुना सैम ने क्या कहा?

454
00:32:19,000 --> 00:32:22,000
उन्होंने कहा कि midpoint के रूप में है

455
00:32:22,000 --> 00:32:28,000
सरणी में सिर्फ एक स्थिति का प्रतिनिधित्व करता है, लेकिन यह सरणी में वास्तविक तत्व नहीं है.

456
00:32:28,000 --> 00:32:30,000
यदि आप के रूप में लिखा कोड के बारे में सही लगता है कि अब,

457
00:32:30,000 --> 00:32:35,000
अगर हम इस सरणी में यहाँ नीचे देखो, जो उस में 8 तत्व है,

458
00:32:35,000 --> 00:32:39,000
midpoint इस समारोह में होने जा रहा है का मूल्य क्या है?

459
00:32:39,000 --> 00:32:41,000
[छात्र] 4.

460
00:32:41,000 --> 00:32:45,000
[नैट] 4.

461
00:32:45,000 --> 00:32:51,000
यदि हम संख्या 4 के लिए देखो -

462
00:32:51,000 --> 00:32:54,000
और हम सिर्फ इस कोड को चलाने कर सकते हैं और यहाँ एक थोड़ा उदास चेहरे डाल

463
00:32:54,000 --> 00:32:58,000
क्योंकि हम यह अगर हम इस कोड को चलाने नहीं मिला

464
00:32:58,000 --> 00:33:04,000
के रूप में अब ठीक है, इसे अपलोड, इमारत, मुझे नीचे स्क्रॉल,

465
00:33:04,000 --> 00:33:09,000
और अगर हम संख्या 4 के लिए देखो,

466
00:33:09,000 --> 00:33:18,000
हम यह पाया है, लेकिन हम इस printf हाँ के लिए नहीं मिला.

467
00:33:18,000 --> 00:33:23,000
एक कारण यह है कि हम सही वापस नहीं किया था,

468
00:33:23,000 --> 00:33:26,000
लेकिन हम वास्तव में संख्या 4?

469
00:33:26,000 --> 00:33:28,000
और सैम कोई कह रहा है.

470
00:33:28,000 --> 00:33:31,000
हम क्या मिला?

471
00:33:31,000 --> 00:33:35,000
हम वास्तव में midpoint की है, जो अगर हम सरणी में यहाँ नीचे देखो पाया,

472
00:33:35,000 --> 00:33:38,000
यह तत्व हो सूचकांक में 4 जा रहा है कि हम देख रहे हैं,

473
00:33:38,000 --> 00:33:42,000
जो 23 है.

474
00:33:42,000 --> 00:33:46,000
>> हम वास्तव में कैसे मध्य में उस तत्व प्राप्त

475
00:33:46,000 --> 00:33:48,000
और सिर्फ midpoint ही नहीं है?

476
00:33:48,000 --> 00:33:52,000
[छात्र] हम चार या कुछ दर्ज होगा?

477
00:33:52,000 --> 00:33:55,000
क्या है कि बस से बाहर जिज्ञासा का क्या होगा?

478
00:33:55,000 --> 00:33:57,000
आप एक छोटे से अधिक विस्तृत कर सकते हैं?

479
00:33:57,000 --> 00:34:02,000
आप संख्या में स्थिति को बदलने के लिए है,

480
00:34:02,000 --> 00:34:05,000
तो आप करना है कुछ कनेक्शन - मुझे लगता है कि यह चार है, लेकिन यह नहीं हो सकता.

481
00:34:05,000 --> 00:34:07,000
हाँ, यह एक अच्छी बात है.

482
00:34:07,000 --> 00:34:12,000
हम घर का काम, इन अक्षरों में किया गया है इस परिवर्तित पदों की एक बहुत कुछ कर रही है,

483
00:34:12,000 --> 00:34:14,000
पहले दो समस्या सेट में.

484
00:34:14,000 --> 00:34:18,000
यह पता चला है कि यहाँ है, यह लगभग समान है

485
00:34:18,000 --> 00:34:24,000
एक स्ट्रिंग के भीतर ith चरित्र तक पहुँचने, कि अगर समझ में आता है.

486
00:34:24,000 --> 00:34:30,000
यहाँ हम midpoint तत्व का उपयोग करना चाहते हैं.

487
00:34:30,000 --> 00:34:34,000
हम कि कैसे करते हो?

488
00:34:34,000 --> 00:34:39,000
केविन, तुम हम कैसे कर सकता है कि किसी भी सुझाव है?

489
00:34:39,000 --> 00:34:44,000
आप टेबल कर सकता है, खुले वर्ग, मध्य, ब्रैकेट बंद कर दिया.

490
00:34:44,000 --> 00:34:46,000
आप हमारे लिए लिख सकते हैं?

491
00:34:46,000 --> 00:34:51,000
इसे यहाँ में सहेजें, और हम है कि ऊपर खींच लेंगे.

492
00:34:51,000 --> 00:34:56,000
हम इस लाइन 9 पर देख रहे हैं,

493
00:34:56,000 --> 00:34:59,000
और हम को साकार कर रहे हैं कि हम midpoint सुई की तुलना नहीं करना चाहती,

494
00:34:59,000 --> 00:35:03,000
लेकिन इसके बजाय, हम करने के लिए सुई की तुलना करना चाहते हैं

495
00:35:03,000 --> 00:35:07,000
हमारे टेबल सरणी के भीतर स्थिति मध्य में तत्व.

496
00:35:07,000 --> 00:35:10,000
कूल.

497
00:35:10,000 --> 00:35:12,000
हम वहाँ जाते हैं.

498
00:35:12,000 --> 00:35:15,000
हाँ, यह बहुत अच्छा लग रहा है, अगर (सुई == टेबल [मध्य]).

499
00:35:15,000 --> 00:35:18,000
हमने यह पाया.

500
00:35:18,000 --> 00:35:22,000
अब अगर हम एक छोटा सा कोड we'll वापस ऊपर चलाने

501
00:35:22,000 --> 00:35:26,000
यह compiles और चलाता है, अब अगर हम 4 के लिए देखो,

502
00:35:26,000 --> 00:35:30,000
हम यह नहीं मिल रहा है क्योंकि अब हम वास्तव में संख्या 23 हो रही है.

503
00:35:30,000 --> 00:35:33,000
हम मूल्य 23 हो रही है, और है कि हम क्या हमारे सुई तुलना कर रहे हैं.

504
00:35:33,000 --> 00:35:35,000
लेकिन यह अच्छी बात है. यह सही दिशा में एक कदम है.

505
00:35:35,000 --> 00:35:37,000
>> यही कारण है कि हम क्या करने की कोशिश कर रहे हैं.

506
00:35:37,000 --> 00:35:40,000
हम सरणी में पदों के खिलाफ सुई की तुलना नहीं की कोशिश कर रहे हैं

507
00:35:40,000 --> 00:35:44,000
बल्कि सरणी में वास्तविक तत्वों के खिलाफ.

508
00:35:44,000 --> 00:35:49,000
अगर हम वापस फिर हमारे एल्गोरिथ्म में अगले कदम पर अब देखो

509
00:35:49,000 --> 00:35:51,000
अगला कदम क्या है?

510
00:35:51,000 --> 00:35:57,000
लीला पहले से ही इसे संक्षेप में उल्लेख किया है.

511
00:35:57,000 --> 00:36:00,000
[छात्र] देखने के लिए अगर यह अधिक से अधिक या कम से कम है और फिर जो रास्ता तय स्थानांतरित करने के लिए जाँच करें.

512
00:36:00,000 --> 00:36:03,000
[नैट] हाँ, तो हम कैसे है कि क्या करना होगा?

513
00:36:03,000 --> 00:36:07,000
आप कुछ - मैं में डाल सकते हैं इस संशोधन को बचाने के लिए,

514
00:36:07,000 --> 00:36:13,000
और फिर अगर आप कुछ लाइनों है कि कि क्या करेंगे में डाल दिया.

515
00:36:13,000 --> 00:36:15,000
हाँ, Charlotte >> मैं एक सवाल है.

516
00:36:15,000 --> 00:36:19,000
Midpoint नहीं होना चाहिए - 1 क्योंकि पहली बात है

517
00:36:19,000 --> 00:36:26,000
यह अनुक्रमित 0 है, इसलिए यदि हम 4 डाल दिया है, कि वास्तव में चरित्र के लिए हम देख रहे हैं नहीं है?

518
00:36:26,000 --> 00:36:30,000
हाँ, और अन्य के साथ समस्या यह है

519
00:36:30,000 --> 00:36:35,000
कि एक महान पकड़ है, क्योंकि अंत संभवतः हो रहा जा रहा है

520
00:36:35,000 --> 00:36:42,000
अगर हम चलते रहते हैं और हम कभी नहीं शुरू समायोजित?

521
00:36:42,000 --> 00:36:46,000
मुझे लगता है कि क्या हम अंत कर सकता का उपयोग करने की कोशिश कर रहा है

522
00:36:46,000 --> 00:36:49,000
तत्व सरणी के 8 स्थान पर,

523
00:36:49,000 --> 00:36:53,000
जो इस मामले में मौजूद नहीं है.

524
00:36:53,000 --> 00:36:56,000
हम इस तथ्य के लिए लेखांकन के कुछ प्रकार करना चाहते हो जाएगा

525
00:36:56,000 --> 00:36:59,000
कि हम कुछ शून्य अनुक्रमण है.

526
00:36:59,000 --> 00:37:05,000
[Charlotte] क्षमा करें, मैं midpoint मतलब वर्ग कोष्ठक में 1.

527
00:37:05,000 --> 00:37:08,000
हम जानते हैं कि क्या कर सकते हैं.

528
00:37:08,000 --> 00:37:10,000
हम इस मुद्दे पर सिर्फ एक बिट में वापस आया हूँ.

529
00:37:10,000 --> 00:37:13,000
एक बार जब हम वास्तविक पाशन करने के लिए शुरू,

530
00:37:13,000 --> 00:37:16,000
है कि जब हम वास्तव में देखने के लिए इस खेलने में आते हैं.

531
00:37:16,000 --> 00:37:21,000
कुछ समय के लिए, हम यह करते हैं, कर सकते हैं लेकिन आप पूरी तरह से सही हैं.

532
00:37:21,000 --> 00:37:28,000
यह शून्य अनुक्रमण एक प्रभाव है कि हम करने के लिए खाते की जरूरत है.

533
00:37:28,000 --> 00:37:30,000
चलो देखते हैं.

534
00:37:30,000 --> 00:37:34,000
>> कैसे अधिक से अधिक और कम से कम है?

535
00:37:34,000 --> 00:37:36,000
[छात्र] मैं कैसे अधिक से अधिक और हिस्से की तुलना में कम करने के लिए मिलता है.

536
00:37:36,000 --> 00:37:41,000
मैं सिर्फ यकीन है कि अगर आपको लगता है कि यह टेबल midpoint से कम या से अधिक होता है मुद्रित करने के लिए नहीं था.

537
00:37:41,000 --> 00:37:43,000
यहाँ मैं क्या बचा सकता है 've -

538
00:37:43,000 --> 00:37:47,000
[नैट] हाँ, अगर तुम बचाने के लिए तुम्हारे पास क्या है, और हम इसे खींच लेंगे.

539
00:37:47,000 --> 00:37:49,000
हम वहाँ जाते हैं.

540
00:37:49,000 --> 00:37:51,000
[छात्र] और मैं मैं क्या नहीं पता था के लिए प्रश्न चिह्न के डाल दिया.

541
00:37:51,000 --> 00:37:54,000
[नैट] यह बहुत अच्छा लग रहा है.

542
00:37:54,000 --> 00:37:58,000
यहाँ हम सवाल के निशान मिल गया है क्योंकि हम अभी भी पता नहीं

543
00:37:58,000 --> 00:38:06,000
क्या हम अभी तक करने के लिए जा रहे हैं.

544
00:38:06,000 --> 00:38:12,000
हम क्या करते हैं उफ़, हम कुछ हम पर सभी कायरता ब्रेसिज़ मिला है चाहते हो जाएगा.

545
00:38:12,000 --> 00:38:15,000
हम इन ब्रेसिज़ सही हूँ.

546
00:38:15,000 --> 00:38:19,000
हम वहाँ जाते हैं.

547
00:38:19,000 --> 00:38:22,000
और इसलिए हम क्या करना चाहते हैं कि हमारे एल्गोरिथ्म के अनुसार,

548
00:38:22,000 --> 00:38:27,000
अगर हम सुई नहीं मिल रहा है?

549
00:38:27,000 --> 00:38:32,000
मामले में कहना है कि सुई हम क्या देख रहे हैं की तुलना में कम है. केविन.

550
00:38:32,000 --> 00:38:34,000
केवल बाईं आधा देखो.

551
00:38:34,000 --> 00:38:40,000
ठीक है, तो हम यहाँ में एक टिप्पणी है कि कहते हैं डाल देता हूँ "बाईं आधा में देखो."

552
00:38:40,000 --> 00:38:46,000
और अगर सुई मध्य में टेबल की तुलना में अधिक है, हम क्या करना चाहते हो?

553
00:38:46,000 --> 00:38:48,000
[छात्र] तो फिर आप सही आधा देखो.

554
00:38:48,000 --> 00:38:53,000
सही आधा देखो, "सही आधा पर दिखेगा."

555
00:38:53,000 --> 00:38:58,000
नहीं भी जर्जर है.

556
00:38:58,000 --> 00:39:05,000
ठीक है, तो इस बिंदु पर, बातें बहुत अच्छा देख रहे हैं.

557
00:39:05,000 --> 00:39:13,000
कोड के रूप में लिखा है के साथ समस्या क्या है?

558
00:39:13,000 --> 00:39:15,000
[छात्र] आप endpoints halves के लिए नहीं है.

559
00:39:15,000 --> 00:39:18,000
ठीक है, हम endpoints halves के लिए नहीं है.

560
00:39:18,000 --> 00:39:20,000
हम भी केवल इस बार के माध्यम से जाने के लिए जा रहे हैं.

561
00:39:20,000 --> 00:39:23,000
हम केवल एक मध्य में लग जा रहे हैं.

562
00:39:23,000 --> 00:39:27,000
या तो तत्व वहाँ है, या यह नहीं है.

563
00:39:27,000 --> 00:39:34,000
आदेश में यह पूरा करने के लिए, हम पुनरावृत्ति के कुछ प्रकार की आवश्यकता होगी.

564
00:39:34,000 --> 00:39:39,000
हम दोहरा जब तक हम पाते हैं रखने की जरूरत है कि

565
00:39:39,000 --> 00:39:43,000
या तो तत्व वहाँ में है क्योंकि हम नीचे संकुचित है और अंत में इसे पाया,

566
00:39:43,000 --> 00:39:46,000
या यह वहाँ नहीं है क्योंकि हम चीजों की सभी के माध्यम से देखा है

567
00:39:46,000 --> 00:39:52,000
सरणी के उचित हिस्सों में और पाया कि वहाँ में कुछ भी नहीं है.

568
00:39:52,000 --> 00:39:56,000
>> जब भी हम इस पुनरावृत्ति मिला है पर जा रहा है, हम क्या उपयोग करने के लिए जा रहे हैं?

569
00:39:56,000 --> 00:39:58,000
[छात्र] एक पाश.

570
00:39:58,000 --> 00:40:00,000
लूप के कुछ प्रकार की. हां.

571
00:40:00,000 --> 00:40:03,000
[छात्र] हम करते हैं, जबकि एक पाश करते हैं और कर सकते हैं यह है कि और फिर जब

572
00:40:03,000 --> 00:40:10,000
सुई यकीन है कि जहां मैं उस के साथ जा रहा था बराबर नहीं है - मैं नहीं करता है.

573
00:40:10,000 --> 00:40:18,000
लेकिन तरह तरह की है कि लंबे समय के रूप के रूप में यह बराबर है कि उपयोगकर्ता इनपुट मूल्य नहीं है.

574
00:40:18,000 --> 00:40:21,000
हाँ, तो चलो देखते हैं, यह अपने आप कैसे लिख सकता है?

575
00:40:21,000 --> 00:40:23,000
तुमने कहा था कि चलो करते हैं, जबकि एक पाश का उपयोग करें.

576
00:40:23,000 --> 00:40:26,000
कहाँ शुरू करता है?

577
00:40:26,000 --> 00:40:33,000
[छात्र] / 2 आकार के बाद ही सही.

578
00:40:33,000 --> 00:40:42,000
[नैट] ठीक है, और हम क्या करने जा रहे हैं?

579
00:40:42,000 --> 00:40:44,000
हम समय में बाद में भर देंगे.

580
00:40:44,000 --> 00:40:46,000
हम क्या करने जा रहे हैं?

581
00:40:46,000 --> 00:40:49,000
[छात्र] क्या हम सब सामान करना चाहते हैं हम भाग अगर में नहीं है?

582
00:40:49,000 --> 00:40:52,000
[नैट] क्या यह सब सामान, महान.

583
00:40:52,000 --> 00:40:55,000
कॉपी और पेस्ट.

584
00:40:55,000 --> 00:40:59,000
ओह, यार.

585
00:40:59,000 --> 00:41:03,000
चलो देखते हैं अगर यह काम करता है, अगर हम कर सकते हैं इस पर टैब.

586
00:41:03,000 --> 00:41:08,000
सुंदर.

587
00:41:08,000 --> 00:41:16,000
ठीक है, और हम इस को बचाने के लिए तो तुम लोग यह है.

588
00:41:16,000 --> 00:41:21,000
सब ठीक है, और हम ऐसा करने जा रहे हैं जबकि

589
00:41:21,000 --> 00:41:25,000
जबकि हालत आप के बाद किया गया था?

590
00:41:25,000 --> 00:41:31,000
[छात्र] जबकि सुई बराबर नहीं है, तो विस्मयादिबोधक बिंदु की तरह.

591
00:41:31,000 --> 00:41:37,000
लेकिन मुझे यकीन है कि वास्तव में क्या है कि अभी तक नहीं कर रहा हूँ.

592
00:41:37,000 --> 00:41:39,000
[नैट] हाँ, यह एक तरीका यह करना है.

593
00:41:39,000 --> 00:41:41,000
सैम, आप एक टिप्पणी है?

594
00:41:41,000 --> 00:41:43,000
[सैम] मुझे याद है जब मैं वीडियो में देखा,

595
00:41:43,000 --> 00:41:48,000
मैं एक तरह की एक स्क्रीनशॉट ले लिया जब हम इसके लिए pseudocode किया,

596
00:41:48,000 --> 00:41:52,000
अधिकतम और न्यूनतम के बीच कुछ संबंध था.

597
00:41:52,000 --> 00:41:58,000
मुझे लगता है कि यह अगर अधिकतम कभी मिनट से भी कम समय है की तरह कुछ था.

598
00:41:58,000 --> 00:42:00,000
समझे.

599
00:42:00,000 --> 00:42:04,000
[सैम] या की तरह अगर अधिकतम मिनट या उस तरह की तुलना में कुछ कम नहीं है,

600
00:42:04,000 --> 00:42:06,000
क्योंकि इसका मतलब है कि आप सब कुछ खोज की है.

601
00:42:06,000 --> 00:42:13,000
>> हाँ, तो यह क्या अधिकतम और न्यूनतम करने के लिए बात कर रहे थे की तरह बात करता है?

602
00:42:13,000 --> 00:42:16,000
[सैम] कि integers मान को बदलने जा रहे

603
00:42:16,000 --> 00:42:18,000
जहां हम midpoint डाल रिश्तेदार.

604
00:42:18,000 --> 00:42:20,000
बिल्कुल सही.

605
00:42:20,000 --> 00:42:24,000
[सैम] उस बिंदु पर, यह [अश्राव्य] अधिकतम और न्यूनतम की गणना करने के लिए जा रहा है

606
00:42:24,000 --> 00:42:29,000
मध्यबिंदु इस अधिकतम और न्यूनतम विचार है.

607
00:42:29,000 --> 00:42:35,000
करता है कि लोगों को समझ बनाने के लिए?

608
00:42:35,000 --> 00:42:39,000
, अगर हम कैसे हम इस यात्रा करने के लिए जा रहे हैं पर तलाश शुरू करने के लिए गए थे

609
00:42:39,000 --> 00:42:43,000
आप पूरी तरह से सही कर रहे हैं कि हम करते हैं जबकि पाश के कुछ प्रकार का उपयोग करना चाहते हैं.

610
00:42:43,000 --> 00:42:49,000
लेकिन मुझे लगता है कि अगर हम याद क्या इस सरणी के स्थान पर जा रहा है

611
00:42:49,000 --> 00:42:53,000
और वास्तव में क्या हो रहा है - मैं करने के लिए लिखने जा रहा यहाँ

612
00:42:53,000 --> 00:42:58,000
द्विआधारी खोज के बहुत पहली यात्रा पर, हम

613
00:42:58,000 --> 00:43:05,000
मैं बी और ई का उपयोग करने के लिए शुरुआत निरूपित करने के लिए जा रहा हूँ.

614
00:43:05,000 --> 00:43:10,000
और फिर हमारी सरणी के अंत.

615
00:43:10,000 --> 00:43:14,000
हम जानते हैं कि यहाँ पर शुरुआत 4 सही पर है,

616
00:43:14,000 --> 00:43:18,000
और हम जानते हैं कि अंत में 108 पर है.

617
00:43:18,000 --> 00:43:23,000
कहते हैं कि हम 15 नंबर के लिए खोज कर रहे हैं.

618
00:43:23,000 --> 00:43:27,000
पहली बार हम यह करते हैं, जैसा कि हम पहले देखा था,

619
00:43:27,000 --> 00:43:30,000
midpoint या तो 16 या 23 होने जा रहा है

620
00:43:30,000 --> 00:43:34,000
कैसे हम बातें की गणना के आधार पर.

621
00:43:34,000 --> 00:43:37,000
के बाद से समान रूप से बीच में विभाजित हमें इस स्थान देना होगा

622
00:43:37,000 --> 00:43:42,000
16 और 23 के बीच में, हम समान रूप से यह नहीं विभाजित कर सकते हैं

623
00:43:42,000 --> 00:43:47,000
या यह विभाजन और एक सच्चे मध्य में मिलता है.

624
00:43:47,000 --> 00:43:49,000
हम 16 में देख लेंगे.

625
00:43:49,000 --> 00:43:55,000
हम एहसास होगा "अरे, 16 15> कि हम देख रहे हैं."

626
00:43:55,000 --> 00:43:59,000
तो सरणी के बाईं आधा देखो

627
00:43:59,000 --> 00:44:03,000
हम अंत में कर रहा हूँ discarding क्या है

628
00:44:03,000 --> 00:44:07,000
इस पूरे ऊपरी भाग

629
00:44:07,000 --> 00:44:16,000
और कहा, "ठीक है, अब हमारे endpoint के लिए यहाँ होने जा रहा है."

630
00:44:16,000 --> 00:44:22,000
हमारे पाश के अगले चलना, अब हम इस सरणी में देख रहे हैं,

631
00:44:22,000 --> 00:44:25,000
प्रभावी ढंग से इस हिस्से को खारिज कर दिया है क्योंकि अब

632
00:44:25,000 --> 00:44:30,000
अगर हम midpoint ले जा रहे हैं शुरुआत और अंत के बीच अंतर हो सकता है,

633
00:44:30,000 --> 00:44:34,000
हम हमारे midpoint 8 हो पाते हैं,

634
00:44:34,000 --> 00:44:40,000
जो हम तो 8 का परीक्षण करने के लिए देखने के लिए जहां यह संख्या के लिए हम देख रहे हैं के संबंध में है,

635
00:44:40,000 --> 00:44:44,000
15, कि 15 अधिक है,

636
00:44:44,000 --> 00:44:49,000
तो हम सूची के भाग के लिए स्थानांतरित करने के लिए किया है,

637
00:44:49,000 --> 00:44:51,000
जो हम जानते हैं क्योंकि हम मनुष्य हैं, और हम इसे देख सकते हैं.

638
00:44:51,000 --> 00:44:54,000
हम जानते हैं कि सही भाग होने जा रहा है जहाँ हम यह पता है,

639
00:44:54,000 --> 00:45:01,000
लेकिन कंप्यूटर नहीं पता नहीं है, तो क्या हम क्या करेंगे हम वास्तव में जाएगा

640
00:45:01,000 --> 00:45:04,000
है इस ऊपर जाना है, और अब शुरुआत और अंत

641
00:45:04,000 --> 00:45:11,000
एक ही स्थान हैं, इसलिए midpoint उस बिंदु पर सूची में केवल संख्या बन जाता है,

642
00:45:11,000 --> 00:45:16,000
जो 15 है, और हम यह पाया है.

643
00:45:16,000 --> 00:45:21,000
क्या है कि जहां इस पूरे अधिकतम और न्यूनतम अंकन जा रहा है पर कुछ प्रकाश डाला,

644
00:45:21,000 --> 00:45:24,000
सरणी के endpoints का ट्रैक रखने के क्रम में बाहर आंकड़ा

645
00:45:24,000 --> 00:45:35,000
कैसे चीजों को संकीर्ण करने के लिए नीचे?

646
00:45:35,000 --> 00:45:42,000
>> क्या हुआ अगर यह 15 के बराबर नहीं थे अब क्या होगा?

647
00:45:42,000 --> 00:45:52,000
क्या होगा अगर हम 15 और, बजाय के लिए देख रहे थे, यह संख्या 16 भी थे?

648
00:45:52,000 --> 00:45:54,000
हम कहते हैं, "ओह, यह अधिक से अधिक है.

649
00:45:54,000 --> 00:45:57,000
हम करने के लिए छोड़ दिया करने के लिए वापस जाना चाहता हूँ. "

650
00:45:57,000 --> 00:46:01,000
और हम सही करने के लिए हमारे ई कदम था,

651
00:46:01,000 --> 00:46:06,000
पर जो बात हम एक endpoint है कि परस्पर विरोधी होगा.

652
00:46:06,000 --> 00:46:09,000
यह किसी भी अधिक तत्वों के लिए खोज करने में सक्षम नहीं होगा

653
00:46:09,000 --> 00:46:13,000
क्योंकि अब हम हमारे endpoint और हमारी शुरुआत मुद्दा है,

654
00:46:13,000 --> 00:46:16,000
हमारे अधिकतम और हमारे मिनट, अब फ़्लिप हैं.

655
00:46:16,000 --> 00:46:23,000
हम पूरे सरणी के माध्यम से खोज. हम कुछ भी नहीं मिल सकता है.

656
00:46:23,000 --> 00:46:27,000
यही तो बात है, जिस पर हम कहते हैं, "ठीक है, हम इस एल्गोरिथ्म को रोकने के लिए जा रहे हैं चाहता था.

657
00:46:27,000 --> 00:46:34,000
हम कुछ भी नहीं मिला है. हम जानते हैं कि यह यहाँ नहीं है. "

658
00:46:34,000 --> 00:46:36,000
यह कैसे हो रहा है?

659
00:46:36,000 --> 00:46:40,000
[छात्र] कैसे ठीक कंप्यूटर अंत स्विच करता है?

660
00:46:40,000 --> 00:46:45,000
अंत में शुरुआत से पहले कैसे करता है अंत?

661
00:46:45,000 --> 00:46:48,000
अंत में शुरुआत से पहले समाप्त होता है

662
00:46:48,000 --> 00:46:54,000
गणित है कि हम हर समय हम यह करते हैं करने के लिए जा रहे हैं की वजह से.

663
00:46:54,000 --> 00:47:00,000
जिस तरह से हम स्वैप है अगर आप बहुत पहले समय पर देखो हम इस स्वैप करना

664
00:47:00,000 --> 00:47:03,000
जहां हम 4 में शुरुआत और अंत है

665
00:47:03,000 --> 00:47:13,000
108 में सभी तरह से नीचे और हमारे midpoint, 16 कहते हैं,

666
00:47:13,000 --> 00:47:20,000
मैं करने के लिए इस रीसेट वापस करने के लिए जा रहा हूँ 15-अगर हम 15 के लिए देख रहे हैं,

667
00:47:20,000 --> 00:47:25,000
हम जानते थे कि हम क्या किया है जब हम 16 की जाँच की और देखा कि यह अधिक से अधिक था

668
00:47:25,000 --> 00:47:28,000
और सूची के पूरे भाग छोड़ना चाहता था,

669
00:47:28,000 --> 00:47:36,000
हमने देखा है कि क्या हम करना चाहते थे इस ई कदम सही यहाँ.

670
00:47:36,000 --> 00:47:44,000
प्रभावी ढंग से, ई एक midpoint से पहले करने के लिए ले जाया गया.

671
00:47:44,000 --> 00:47:48,000
इसी तरह, जब हम एल्गोरिथ्म के इस चलना किया

672
00:47:48,000 --> 00:47:51,000
और midpoint 8 था,

673
00:47:51,000 --> 00:47:55,000
हमने पाया है कि 8 <15, इसलिए हम ख को स्थानांतरित करने के लिए चाहते थे

674
00:47:55,000 --> 00:48:00,000
एक midpoint पिछले.

675
00:48:00,000 --> 00:48:07,000
अब, शुरुआत और अंत दोनों एक साथ हैं 15 पर.

676
00:48:07,000 --> 00:48:10,000
>> अगर हम कुछ अन्य, 15 नहीं मूल्य के लिए देखने के लिए हो गया था,

677
00:48:10,000 --> 00:48:14,000
या अगर यह 15 के बजाय एक 16 किया गया था,

678
00:48:14,000 --> 00:48:20,000
हमने पाया है कि हम ई midpoint से पहले एक स्थानांतरित करना चाहते हैं.

679
00:48:20,000 --> 00:48:33,000
अब ई होगा वहाँ ख कम से कम रूप से फ़्लिप.

680
00:48:33,000 --> 00:48:39,000
चलो हम वास्तव में कैसे अंत में इस एल्गोरिथ्म कोडिंग के माध्यम से चलते हैं.

681
00:48:39,000 --> 00:48:44,000
हम जानते हैं कि हम इस midpoint गणना करना चाहते हैं.

682
00:48:44,000 --> 00:48:48,000
हम यह भी जानते हैं कि हम शुरुआत है और सरणी के अंत ट्रैक करना चाहते हैं

683
00:48:48,000 --> 00:48:51,000
हमारे मौजूदा सरणी के तो हम समझ सकते हैं

684
00:48:51,000 --> 00:48:56,000
जहां सूची के इस बाईं आधा है और जहां सूची की सही आधा है.

685
00:48:56,000 --> 00:49:03,000
हम या तो शुरू और अंत के साथ करते हैं,

686
00:49:03,000 --> 00:49:07,000
या हम उन्हें न्यूनतम और अधिकतम कॉल कर सकते हैं.

687
00:49:07,000 --> 00:49:10,000
मैं शुरू हो और इस बार अंत में इस्तेमाल करेंगे.

688
00:49:10,000 --> 00:49:15,000
जब हम शुरू अगर, हम वापस हमारे उदाहरण में यहाँ देखो,

689
00:49:15,000 --> 00:49:20,000
हमारी शुरुआत सरणी के बहुत शुरुआत में प्राकृतिक रूप में स्थापित किया गया था.

690
00:49:20,000 --> 00:49:25,000
यह सूचकांक क्या था? क्या हमारे शुरू किया जाना चाहिए?

691
00:49:25,000 --> 00:49:27,000
डैनियल.

692
00:49:27,000 --> 00:49:30,000
[डैनियल] टेबल [0].

693
00:49:30,000 --> 00:49:37,000
[नैट] हाँ, तो हम इसे सेट टेबल के बराबर [0].

694
00:49:37,000 --> 00:49:40,000
समस्या है, हालांकि यह है कि यह हमें पहला तत्व की स्थिति नहीं देता.

695
00:49:40,000 --> 00:49:45,000
यह हमें 1 या कि पहले की स्थिति में वास्तविक मूल्य तत्व के सूचकांक देता है.

696
00:49:45,000 --> 00:49:47,000
[छात्र] कि .20 के लिए बदल जाएगा?

697
00:49:47,000 --> 00:49:52,000
[नैट] क्या यह करना होगा अच्छी तरह से है, यह किसी भी परिवर्तित करना होगा नहीं.

698
00:49:52,000 --> 00:49:56,000
यह करना होगा क्या है यह शुरू में एक 4 की दुकान होगी,

699
00:49:56,000 --> 00:49:59,000
और फिर इसे करने के लिए शुरू के खिलाफ तुलना करने के लिए मुश्किल हो जाएगा

700
00:49:59,000 --> 00:50:03,000
क्योंकि शुरू 4 के मूल्य धारण किया जाएगा,

701
00:50:03,000 --> 00:50:06,000
जो हमारे सरणी की शुरुआत है,

702
00:50:06,000 --> 00:50:08,000
लेकिन हम सरणी में सूचकांक को ट्रैक करना चाहते हैं

703
00:50:08,000 --> 00:50:11,000
के रूप में मूल्यों के लिए विरोध किया.

704
00:50:11,000 --> 00:50:17,000
हम वास्तव में ऐसा एक 0 इस्तेमाल करेंगे.

705
00:50:17,000 --> 00:50:20,000
सरणी Charlotte के अंत के लिए एक छोटे से पहले ऊपर लाया.

706
00:50:20,000 --> 00:50:23,000
यह वह जगह है जहां हम खाते में शून्य अनुक्रमण पर ले जाऊँगा.

707
00:50:23,000 --> 00:50:25,000
>> Charlotte, सरणी के अंत क्या है?

708
00:50:25,000 --> 00:50:28,000
अंत के सूचकांक क्या है?

709
00:50:28,000 --> 00:50:30,000
[Charlotte] आकार - 1.

710
00:50:30,000 --> 00:50:32,000
हाँ, और हम जो आकार का उपयोग करना चाहिए?

711
00:50:32,000 --> 00:50:35,000
हम पूंजी आकार या छोटे आकार का उपयोग करना चाहिए?

712
00:50:35,000 --> 00:50:37,000
पूंजी आकार.

713
00:50:37,000 --> 00:50:42,000
इस मामले में, हम पूंजी आकार का उपयोग कर सकते हैं.

714
00:50:42,000 --> 00:50:45,000
यदि हम इस समारोह पोर्टेबल होना चाहता था

715
00:50:45,000 --> 00:50:48,000
और अन्य कार्यक्रमों में इस समारोह का उपयोग,

716
00:50:48,000 --> 00:50:50,000
हम वास्तव में लोअरकेस आकार का उपयोग कर सकते हैं.

717
00:50:50,000 --> 00:50:52,000
यह भी ठीक है.

718
00:50:52,000 --> 00:51:01,000
लेकिन Charlotte पूरी तरह से सही है कि हम आकार चाहते हैं - 1.

719
00:51:01,000 --> 00:51:03,000
इस बिंदु पर

720
00:51:03,000 --> 00:51:05,000
[छात्र] कैसे यह है कि आप अपरकेस आकार का उपयोग कर सकते हैं?

721
00:51:05,000 --> 00:51:07,000
कैसे यह है कि हम अपरकेस आकार का उपयोग कर सकते हैं?

722
00:51:07,000 --> 00:51:13,000
यह पता चला है कि इन # परिभाषित करता है वास्तव में कर रहे हैं,

723
00:51:13,000 --> 00:51:19,000
हुड के तहत, एक पाठ की तरह खोजने और बदलने के लिए, कि अगर समझ में आता है.

724
00:51:19,000 --> 00:51:24,000
जब आप अपने कोड संकलन, preprocessing चरण

725
00:51:24,000 --> 00:51:27,000
संकलक की फ़ाइल के माध्यम से चला जाता है,

726
00:51:27,000 --> 00:51:31,000
और इसके लिए हर जगह है कि आप पूंजी आकार लिखा है लग रहा है,

727
00:51:31,000 --> 00:51:39,000
और यह है कि पाठ सचमुच एक 8 के साथ ऐसे ही जगह.

728
00:51:39,000 --> 00:51:42,000
उस अर्थ में, यह एक चर से बहुत अलग है.

729
00:51:42,000 --> 00:51:45,000
यह स्मृति में किसी भी जगह नहीं ले करता है.

730
00:51:45,000 --> 00:51:52,000
यह एक साधारण पाठ की जगह चाल है.

731
00:51:52,000 --> 00:51:57,000
इस मामले में, हम आकार का उपयोग करने के लिए जा रहे हैं.

732
00:51:57,000 --> 00:52:01,000
यहाँ से हम पुनरावृत्ति के कुछ प्रकार करना चाहते हैं,

733
00:52:01,000 --> 00:52:03,000
और हम करते हैं, जबकि हमारे पाश के साथ सही रास्ते पर हैं.

734
00:52:03,000 --> 00:52:08,000
हमें कुछ करना चाहते हैं जब तक एक हालत अब पकड़ नहीं करता है,

735
00:52:08,000 --> 00:52:12,000
और जैसा कि हम पहले देखा था, हमने देखा है कि उस हालत

736
00:52:12,000 --> 00:52:19,000
वास्तव में था कि हम अंत नहीं करना चाहती

737
00:52:19,000 --> 00:52:24,000
कम से कम शुरू करते हैं.

738
00:52:24,000 --> 00:52:26,000
>> यह हमारे को रोकने के शर्त है.

739
00:52:26,000 --> 00:52:35,000
यदि ऐसा होता है, हम को रोकने के लिए और जैसे घोषित करना चाहते हैं "अरे, हम कुछ भी नहीं मिला है."

740
00:52:35,000 --> 00:52:43,000
इसे व्यक्त करने के लिए, हम लूप के कुछ प्रकार का उपयोग करना चाहते हैं.

741
00:52:43,000 --> 00:52:49,000
इस मामले में, यह है, जबकि एक पाश, पाश के लिए एक एक जबकि पाश?

742
00:52:49,000 --> 00:52:51,000
हम करते हैं, जबकि एक पाश यहाँ है.

743
00:52:51,000 --> 00:52:53,000
क्या आप उस दृष्टिकोण की तरह लोगों को?

744
00:52:53,000 --> 00:52:59,000
क्या आपको लगता है कि हम एक अलग दृष्टिकोण की कोशिश करनी चाहिए?

745
00:52:59,000 --> 00:53:01,000
केविन, किसी भी विचार?

746
00:53:01,000 --> 00:53:06,000
हम एक समय पाश है क्योंकि हम अधिकतम जानते हो सकता है

747
00:53:06,000 --> 00:53:11,000
वैसे भी शुरू में मिनट से अधिक होगा.

748
00:53:11,000 --> 00:53:14,000
हाँ तो, वहाँ कोई initialization है कि होने की जरूरत है.

749
00:53:14,000 --> 00:53:17,000
उन है, जबकि loops महान हैं जब आप कुछ इनिशियलाइज़ है

750
00:53:17,000 --> 00:53:21,000
पहले तो यहाँ जबकि परीक्षण,

751
00:53:21,000 --> 00:53:26,000
हम जानते हैं कि हम दोनों के शुरू और अंत reinitializing रखने के लिए नहीं जा रहे हैं

752
00:53:26,000 --> 00:53:28,000
पाश के हर दौर.

753
00:53:28,000 --> 00:53:32,000
हम जानते हैं कि हम उन्हें इनिशियलाइज़ चाहते हैं, तो हमारी स्थिति की जाँच करें.

754
00:53:32,000 --> 00:53:38,000
इस मामले में, मैं वास्तव में एक सरल जबकि पाश के साथ जाना होगा.

755
00:53:38,000 --> 00:53:44,000
यह पता चला है कि करते हैं जबकि loops काफी बार बार इस्तेमाल कर रहे हैं.

756
00:53:44,000 --> 00:53:49,000
स्थानों का एक बहुत भी नहीं सिखाते हैं जबकि loops.

757
00:53:49,000 --> 00:53:53,000
वे उपयोगकर्ता इनपुट से निपटने के लिए अच्छा कर रहे हैं, तो हम उनमें से एक बहुत कुछ देखा है इस प्रकार अब तक.

758
00:53:53,000 --> 00:53:59,000
लेकिन सामान्य के लिए और जबकि loops एक बहुत अधिक आम हैं.

759
00:53:59,000 --> 00:54:03,000
यह पता चला है कि इस शर्त के रूप में लिखा

760
00:54:03,000 --> 00:54:09,000
हमें नहीं करोगे वास्तव में बहुत अच्छा है, और क्यों है?

761
00:54:09,000 --> 00:54:11,000
मैं माफी चाहता हूँ, मैं अपना नाम पता नहीं है.

762
00:54:11,000 --> 00:54:13,000
मैं जैरी >> माफी चाहता हूँ.

763
00:54:13,000 --> 00:54:15,000
यह B-O-R-U मैं है.

764
00:54:15,000 --> 00:54:18,000
ओह, ठीक है.

765
00:54:18,000 --> 00:54:23,000
मैं तुम मेरी सूची में नहीं दिख रहा है.

766
00:54:23,000 --> 00:54:26,000
ओह, यह है क्योंकि ओह, यह समझ में आता है.

767
00:54:26,000 --> 00:54:31,000
क्या तुम क्यों इस जबकि पाश के रूप में इरादा काम नहीं हो सकता है की एक विचार है,

768
00:54:31,000 --> 00:54:38,000
के रूप में इस शर्त के साथ लिखा है?

769
00:54:38,000 --> 00:54:43,000
[जैरी] तुम्हारा मतलब है जैसे आप में के बाद यह सब सामान चाहते हैं?

770
00:54:43,000 --> 00:54:46,000
हाँ, इतना है कि एक है.

771
00:54:46,000 --> 00:54:49,000
हम जबकि पाश है, जो पूरी तरह से सच है में इस सामान के सभी डाल दिया हो सकता है.

772
00:54:49,000 --> 00:54:55,000
दूसरी बात यह है कि एक छोटे से अधिक समस्याग्रस्त है, हालांकि यह है कि इस हालत के काम नहीं करता है.

773
00:54:55,000 --> 00:54:57,000
[छात्र] आप इसे फ्लिप करने की जरूरत है.

774
00:54:57,000 --> 00:55:04,000
ठीक है, तो इस हालत कभी सच नहीं शुरू में जिस तरह से हम इस बारे में बात हो जाएगा.

775
00:55:04,000 --> 00:55:08,000
हमें कुछ करना चाहते हैं जब तक अंत <शुरू,

776
00:55:08,000 --> 00:55:13,000
लेकिन हम जबकि कुछ करना चाहते हैं

777
00:55:13,000 --> 00:55:21,000
≤ अंत शुरू करते हैं.

778
00:55:21,000 --> 00:55:24,000
>> कि तर्क के उलट है.

779
00:55:24,000 --> 00:55:27,000
मैं उन गलतियों को हर समय बनाने के दोषी हूँ.

780
00:55:27,000 --> 00:55:31,000
[छात्र] यह कम से कम या बराबर होना क्यों है?

781
00:55:31,000 --> 00:55:33,000
क्योंकि तुम मामला है कि हम याद करते हैं

782
00:55:33,000 --> 00:55:36,000
वहाँ केवल एक तत्व जहां था, और हम नीचे थे,

783
00:55:36,000 --> 00:55:43,000
और हम सिर्फ हमारे सरणी में 15 पर देख रहे थे?

784
00:55:43,000 --> 00:55:47,000
और हमारी शुरुआत और हमारे अंत एक ही तत्व थे.

785
00:55:47,000 --> 00:55:50,000
हमें यकीन है कि हम उस मामले को संभाल करने के लिए करना चाहते हैं.

786
00:55:50,000 --> 00:55:54,000
यदि हम एक सीधे कम से कम किया है,

787
00:55:54,000 --> 00:55:58,000
हम केवल 2-तत्व सरणी नीचे प्राप्त करने में सक्षम होगा.

788
00:55:58,000 --> 00:56:06,000
एक बार जब हम उस अंतिम तत्व के लिए नीचे मिला है, कि अगर हमारे तत्व थे, हम यह कभी नहीं मिल चाहते हैं.

789
00:56:06,000 --> 00:56:10,000
अब यहाँ से, हम वास्तव में कर सकते हैं जैसे आप कह रहे थे.

790
00:56:10,000 --> 00:56:15,000
हम हमारे जबकि पाश के बीच में सही सामान plopping शुरू कर सकते हैं.

791
00:56:15,000 --> 00:56:20,000
हम हमारे midpoint में खटखटाने से कर सकते हैं.

792
00:56:20,000 --> 00:56:24,000
हम इन सभी बयान अगर कर सकते हैं,

793
00:56:24,000 --> 00:56:30,000
उन्हें बाहर खींच है, जबकि इस लूप के

794
00:56:30,000 --> 00:56:34,000
उन में खटखटाने से,

795
00:56:34,000 --> 00:56:39,000
एक छोटा सा चीजों को साफ,

796
00:56:39,000 --> 00:56:48,000
और मैं आगे जाना है और इस संशोधन को बचा लेंगे.

797
00:56:48,000 --> 00:56:53,000
और इस बिंदु पर, हम बहुत करीब हो रहे हैं.

798
00:56:53,000 --> 00:56:55,000
सैम.

799
00:56:55,000 --> 00:56:58,000
मुझे लगता है कि आप भी int midpoint = आकार है - 1/2.

800
00:56:58,000 --> 00:57:01,000
1/2 - यह, आकार समझे.

801
00:57:01,000 --> 00:57:05,000
वहाँ कुछ और हम उस लाइन के बारे में बदलने की जरूरत है?

802
00:57:05,000 --> 00:57:10,000
यह एक अच्छी पकड़ थी.

803
00:57:10,000 --> 00:57:14,000
>> आकार क्या करता है? क्या हम कभी आकार बदल रहा है?

804
00:57:14,000 --> 00:57:17,000
आदेश में इस तरह लाइन में रखने के लिए, हम आकार बदलने के लिए है.

805
00:57:17,000 --> 00:57:21,000
हम आकार हर बार हम पाश के लिए चारों ओर जाने के बदलने के लिए है.

806
00:57:21,000 --> 00:57:25,000
लेकिन याद रखना जब हम हमारे उदाहरण के माध्यम से जा रहे थे पहले सिर्फ एक छोटा सा,

807
00:57:25,000 --> 00:57:30,000
और हम 4 पर शुरुआत की थी

808
00:57:30,000 --> 00:57:33,000
और अंत में 108 पर पर सभी तरह?

809
00:57:33,000 --> 00:57:35,000
हम midpoint की गणना कैसे किया?

810
00:57:35,000 --> 00:57:38,000
हम आकार का उपयोग कर रहे थे?

811
00:57:38,000 --> 00:57:40,000
या हम शुरू और बजाय अंत का उपयोग कर रहे थे?

812
00:57:40,000 --> 00:57:42,000
यह अंत और शुरुआत के बीच अंतर है.

813
00:57:42,000 --> 00:57:50,000
ठीक है, और वास्तव में मैं कैसे है कि लिखने चाहिए, Charlotte?

814
00:57:50,000 --> 00:57:52,000
बस अंत शुरू करते हैं.

815
00:57:52,000 --> 00:57:55,000
1 - तुम क्या करने की जरूरत नहीं होगी

816
00:57:55,000 --> 00:57:58,000
क्योंकि 1 - अंत में शामिल किया गया है और पहले से ही से शुरू.

817
00:57:58,000 --> 00:58:00,000
[नैट] महान, आप पूरी तरह से ठीक हो.

818
00:58:00,000 --> 00:58:03,000
क्योंकि 1 कि - हम ऐसा करने की नहीं है 1 शामिल किया गया है

819
00:58:03,000 --> 00:58:08,000
और जब हम अंत चर को प्रारंभ करने के लिए जिम्मेदार है.

820
00:58:08,000 --> 00:58:11,000
>> वहाँ कुछ और मैं वाक्य रचना करने की जरूरत है इस लाइन की भावना है?

821
00:58:11,000 --> 00:58:13,000
[छात्र] प्लस >> शुरू प्लस शुरू करते हैं?

822
00:58:13,000 --> 00:58:15,000
अंत में [छात्र].

823
00:58:15,000 --> 00:58:20,000
क्योंकि यह केवल आधी लंबाई की गणना है.

824
00:58:20,000 --> 00:58:26,000
आप शुरू करने के लिए जोड़ने की जरूरत है.

825
00:58:26,000 --> 00:58:31,000
[नैट] क्या यह हमारे लिए गणना चाहते हैं?

826
00:58:31,000 --> 00:58:35,000
, अगर हम पाश की इस पहली यात्रा के अंत के बारे में सोचते हैं

827
00:58:35,000 --> 00:58:40,000
अंत स्थिति सूचकांक 7 में होने जा रहा है.

828
00:58:40,000 --> 00:58:43,000
शुरू 0 की स्थिति में है.

829
00:58:43,000 --> 00:58:47,000
याद है, हम या तो के लिए देख रहे हैं

830
00:58:47,000 --> 00:58:52,000
स्थिति 3 या 4 स्थिति.

831
00:58:52,000 --> 00:58:56,000
यदि हम इस गणित पर देखो, यह थोड़ा और अधिक ठोस बनाने के लिए,

832
00:58:56,000 --> 00:59:02,000
कुछ संख्या यहाँ रखा है, हम 0 7,,

833
00:59:02,000 --> 00:59:10,000
तो 7 - 0, और फिर 2 /

834
00:59:10,000 --> 00:59:19,000
पूर्णांक प्रभाग में 3 है, कि है.

835
00:59:19,000 --> 00:59:26,000
तो हम फिर वापस जोड़ने की जरूरत नहीं है हमारे शुरू करते हैं?

836
00:59:26,000 --> 00:59:28,000
हम इस मामले में ऐसा नहीं है.

837
00:59:28,000 --> 00:59:31,000
बहुत पहली यात्रा पर, यह ठीक हो सकता है क्योंकि शुरू 0 है.

838
00:59:31,000 --> 00:59:36,000
लेकिन हम प्रगति के रूप में, हम वास्तव में सभी आवश्यक बस करो

839
00:59:36,000 --> 00:59:42,000
अंत / 2 शुरू करते हैं.

840
00:59:42,000 --> 00:59:46,000
एक अन्य चाल यहाँ है, और कहा कि अर्थात् एक पूर्वता.

841
00:59:46,000 --> 00:59:49,000
[छात्र] हम कोष्ठकों की जरूरत है?

842
00:59:49,000 --> 00:59:53,000
[नैट] ठीक है, और ऐसा इसलिए है क्योंकि अगर हम इन कोष्ठकों नहीं डाल,

843
00:59:53,000 --> 00:59:58,000
तो इस लाइन के बजाय व्याख्या की जाएगी

844
00:59:58,000 --> 01:00:09,000
(समाप्त) के रूप में (2 / शुरू), जो हम निश्चित रूप से नहीं करना चाहती.

845
01:00:09,000 --> 01:00:11,000
उन पूर्वता नियमों के लिए बाहर देखो.

846
01:00:11,000 --> 01:00:15,000
[छात्र] + क्यों नहीं अंत है शुरू?

847
01:00:15,000 --> 01:00:17,000
यह + क्यों अंत नहीं है शुरू?

848
01:00:17,000 --> 01:00:19,000
[छात्र] यह है कि क्यों नहीं है?

849
01:00:19,000 --> 01:00:24,000
यह + क्यों होगा?

850
01:00:24,000 --> 01:00:26,000
मुझे लगता है कि तुम ठीक कह रहे हैं.

851
01:00:26,000 --> 01:00:28,000
[छात्र] क्योंकि यह औसत है?

852
01:00:28,000 --> 01:00:31,000
[नैट] + End शुरू करने के लिए है, तो आप पूरी तरह से सही हो.

853
01:00:31,000 --> 01:00:34,000
वाह, मैं पूरी तरह goofed. आप ठीक कह रहे हैं.

854
01:00:34,000 --> 01:00:39,000
अगर हम शून्य से कर रहे थे, हम के अंदर वापस शुरू जोड़ना चाहते हैं जाएगा

855
01:00:39,000 --> 01:00:43,000
इस मामले में, तुम बहुत सही कर रहे हैं कि हम दो की औसत ले जाना चाहता हूँ,

856
01:00:43,000 --> 01:00:45,000
तो हम उन्हें जोड़ने के लिए, के रूप में विरोध उन्हें घटाना चाहते हो.

857
01:00:45,000 --> 01:00:49,000
[छात्र] यह भी अगर आप अंत किया काम करेगा / 2 शुरू करते हैं + शुरू करते हैं.

858
01:00:49,000 --> 01:00:55,000
यह होता है अगर हम करते हैं, मैं इतना विश्वास.

859
01:00:55,000 --> 01:01:00,000
>> उदाहरण के लिए, यदि हम शुरू में देख रहे थे,

860
01:01:00,000 --> 01:01:04,000
और हम इसे यहां स्थानांतरित कर दिया

861
01:01:04,000 --> 01:01:08,000
15.

862
01:01:08,000 --> 01:01:12,000
शुरू अब 2 की स्थिति में है.

863
01:01:12,000 --> 01:01:15,000
समाप्ति 7 की स्थिति में है.

864
01:01:15,000 --> 01:01:21,000
अगर हम उन्हें घटाना, हम 5 मिलता है.

865
01:01:21,000 --> 01:01:24,000
2 द्वारा कि फूट डालो, हम 2 मिलता है.

866
01:01:24,000 --> 01:01:27,000
और फिर हम 2 में वापस जोड़ने के लिए,

867
01:01:27,000 --> 01:01:30,000
और कहा कि हमें 4 की स्थिति के लिए हो जाता है,

868
01:01:30,000 --> 01:01:33,000
जो यहीं है, जो midpoint की है.

869
01:01:33,000 --> 01:01:36,000
[छात्र] हम लपेटकर की देखभाल की जरूरत है क्या?

870
01:01:36,000 --> 01:01:39,000
क्या अर्थ में हम लपेटकर का ख्याल रखना की जरूरत नहीं है?

871
01:01:39,000 --> 01:01:43,000
यदि राशि के बीच अंतर

872
01:01:43,000 --> 01:01:45,000
हम इसे कैसे करते हैं पर निर्भर करता है एक भी नंबर नहीं है.

873
01:01:45,000 --> 01:01:49,000
उसके बाद कंप्यूटर को जब यह 2.5 है कि क्या भ्रमित हो जाता है;

874
01:01:49,000 --> 01:01:52,000
आप बाईं या निर्धारित करने के लिए है जो है midpoint सही कदम है?

875
01:01:52,000 --> 01:01:54,000
समझे.

876
01:01:54,000 --> 01:01:56,000
यह पता चला है कि पूर्णांक विभाजन के साथ,

877
01:01:56,000 --> 01:01:59,000
हम कभी इन चल बिन्दु संख्या नहीं मिलता है.

878
01:01:59,000 --> 01:02:01,000
हम दशमलव कभी नहीं मिलता है.

879
01:02:01,000 --> 01:02:04,000
यह पूरी तरह से खारिज कर दिया है.

880
01:02:04,000 --> 01:02:08,000
यदि आप एक कंप्यूटर दो int चर विभाजित है,

881
01:02:08,000 --> 01:02:11,000
और एक 7 है, और अन्य 2 है,

882
01:02:11,000 --> 01:02:13,000
आप एक परिणाम के रूप में 3.5 नहीं मिलेगा.

883
01:02:13,000 --> 01:02:16,000
यह 3 मिल जाएगा.

884
01:02:16,000 --> 01:02:19,000
शेष खारिज कर दिया जाएगा, तो इसे प्रभावी ढंग से गोलाई -

885
01:02:19,000 --> 01:02:24,000
दौर नहीं है, लेकिन एक नहीं बल्कि एक मंजिल है, अगर तुम लोगों में है कि गणित के साथ परिचित हैं,

886
01:02:24,000 --> 01:02:27,000
आप पूरी तरह से जहां दशमलव त्यागें,

887
01:02:27,000 --> 01:02:31,000
और इसलिए आप अनिवार्य रूप से यह छोटा कर रहे हैं पास करने के लिए नीचे

888
01:02:31,000 --> 01:02:33,000
पूरी स्थिति को निकटतम पूर्ण संख्या,.

889
01:02:33,000 --> 01:02:38,000
[छात्र] लेकिन तब है कि समस्याग्रस्त है क्योंकि अगर आप 7 तत्वों की एक सरणी है

890
01:02:38,000 --> 01:02:43,000
तो है कि स्वचालित रूप से 4 के बजाय मध्य के 3 तत्व बाहर ले जाता है.

891
01:02:43,000 --> 01:02:46,000
हम उस के साथ सौदा करते हैं?

892
01:02:46,000 --> 01:02:49,000
यह समस्याग्रस्त है, क्योंकि अगर हम 7 की एक सरणी था

893
01:02:49,000 --> 01:02:54,000
यह 4 के बजाय 3 ले जाएगा.

894
01:02:54,000 --> 01:02:56,000
आप एक छोटे से अधिक समझा सकता है?

895
01:02:56,000 --> 01:02:59,000
[छात्र] क्योंकि अगर आप 7 तत्वों तो 4 तत्व है

896
01:02:59,000 --> 01:03:04,000
midpoint हो, है ना?

897
01:03:04,000 --> 01:03:07,000
शून्य अनुक्रमित किया जा रहा है के बारे में अपनी टिप्पणी को याद है, हालांकि.

898
01:03:07,000 --> 01:03:10,000
[छात्र] हाँ, तो 3 की स्थिति में. कि midpoint होगा.

899
01:03:10,000 --> 01:03:12,000
हाँ.

900
01:03:12,000 --> 01:03:16,000
ओह, ठीक है. मैं देख रहा हूँ कि तुम क्या मतलब है.

901
01:03:16,000 --> 01:03:19,000
यह अजीब तरह का है, के रूप में हम इस पूरी धारणा के लिए इस्तेमाल किया जाना

902
01:03:19,000 --> 01:03:22,000
दशमलव से छुटकारा मिल रहा है.

903
01:03:22,000 --> 01:03:26,000
यह एक बड़ा मुद्दा है.

904
01:03:26,000 --> 01:03:30,000
चलो इस खत्म करने के लिए.

905
01:03:30,000 --> 01:03:32,000
हम हमारे midpoint की गणना है.

906
01:03:32,000 --> 01:03:37,000
>> हम परीक्षण कर रहे हैं देखने के लिए अगर हमारे सुई मध्यम मूल्य के बराबर है.

907
01:03:37,000 --> 01:03:41,000
हम मुद्रण कर रहे हैं कि हम यह मिल गया है, लेकिन वास्तव में, हम इस स्थिति में क्या करना चाहते हैं?

908
01:03:41,000 --> 01:03:46,000
हम यह पाया है, तो हम फोन करने वाले जानते हैं कि हम यह पाया.

909
01:03:46,000 --> 01:03:49,000
हम एक समारोह में कहा कि एक बूलियन टाइप समारोह है मिल गया है.

910
01:03:49,000 --> 01:03:54,000
जिस तरह से हम हमारे समारोह के फोन करने के लिए संकेत है कि हम जाने के लिए तैयार कर रहे हैं

911
01:03:54,000 --> 01:03:58,000
हम कहते हैं कि, "अरे, यह सच है."

912
01:03:58,000 --> 01:04:00,000
हम कैसे करते हैं, चाहते केविन?

913
01:04:00,000 --> 01:04:02,000
तुम अपना सिर हिला रहे हैं सच >> [केविन] वापसी जोड़ें.

914
01:04:02,000 --> 01:04:06,000
वास्तव [नैट], सच वापसी.

915
01:04:06,000 --> 01:04:12,000
अब, अगर यह नहीं के बराबर है, कैसे हम बाईं आधे पर लग रही होगी?

916
01:04:12,000 --> 01:04:16,000
किसी भी विचार?

917
01:04:16,000 --> 01:04:18,000
स्टैला, किसी भी विचार?

918
01:04:18,000 --> 01:04:21,000
आप अंत के लिए एक नई स्थिति को निर्धारित करने की आवश्यकता है.

919
01:04:21,000 --> 01:04:23,000
हाँ.

920
01:04:23,000 --> 01:04:29,000
अंत तो हम midpoint की स्थिति है.

921
01:04:29,000 --> 01:04:33,000
बढ़िया है.

922
01:04:33,000 --> 01:04:36,000
हम अंत के लिए एक नई स्थिति को निर्धारित करने की आवश्यकता है

923
01:04:36,000 --> 01:04:38,000
बाईं आधे पर देखने.

924
01:04:38,000 --> 01:04:41,000
यह था कि हम क्या जहां से पहले के बारे में बात की

925
01:04:41,000 --> 01:04:44,000
मैं इस उदाहरण के लिए वापस जा रहा रखने.

926
01:04:44,000 --> 01:04:50,000
मैं यहाँ शुरू किया है, और फिर मैं अंत में यहाँ पर सभी तरह है.

927
01:04:50,000 --> 01:04:53,000
>> फिर, अगर हम 15 के लिए देख रहे हैं, और हमारे midpoint 16 है,

928
01:04:53,000 --> 01:04:56,000
और हमें पता है, "ओह, 16 अधिक है.

929
01:04:56,000 --> 01:04:59,000
हम बाईं आधा ले जाना चाहते हैं. "

930
01:04:59,000 --> 01:05:02,000
हम तो 15 के लिए अंत कदम होगा,

931
01:05:02,000 --> 01:05:06,000
और हम एक midpoint से दूर ले जा रही है कि

932
01:05:06,000 --> 01:05:09,000
और हमारे नए अंत के रूप में है कि सेटिंग.

933
01:05:09,000 --> 01:05:12,000
इसी तरह, अगर हम सही आधा पर देखना चाहता हूँ, कैसे हम कि क्या करना होगा?

934
01:05:12,000 --> 01:05:14,000
क्या आप एक विचार है?

935
01:05:14,000 --> 01:05:22,000
[छात्र] तुम सिर्फ सेट 1 + midpoint शुरू.

936
01:05:22,000 --> 01:05:24,000
[नैट] ग्रेट.

937
01:05:24,000 --> 01:05:29,000
और अब इस मामले में है कि हम कुछ भी नहीं मिल रहा है,

938
01:05:29,000 --> 01:05:32,000
यह नहीं है कि हमारे लिए का ध्यान रखा मिलता है?

939
01:05:32,000 --> 01:05:36,000
डैनियल, कि हमारे लिए की देखभाल ले लिया हो?

940
01:05:36,000 --> 01:05:38,000
[डैनियल] नहीं

941
01:05:38,000 --> 01:05:40,000
[नैट] अगर हम इसे पूरे सरणी के माध्यम से करते हैं और हम कुछ भी नहीं मिल रहा है,

942
01:05:40,000 --> 01:05:42,000
कि देखभाल जहां लिया जाएगा की, या हम यह ध्यान रखना चाहिए?

943
01:05:42,000 --> 01:05:44,000
[डैनियल] जबकि हालत.

944
01:05:44,000 --> 01:05:48,000
[नैट] हाँ, जबकि हालत, बिल्कुल.

945
01:05:48,000 --> 01:05:51,000
यह पूरे सरणी के माध्यम से जाने का ख्याल रखना अगर हम कुछ भी पता नहीं होगा.

946
01:05:51,000 --> 01:05:53,000
यह जबकि पाश खत्म हो जाएगा.

947
01:05:53,000 --> 01:05:56,000
हम इस हालत का सामना कभी नहीं जाएगा,

948
01:05:56,000 --> 01:06:03,000
और हम झूठे लौट सकते हैं.

949
01:06:03,000 --> 01:06:10,000
हम भी इस से निकलते हैं तो कर सकते हैं, इस तरह यहाँ

950
01:06:10,000 --> 01:06:14,000
क्योंकि अगर यह अगर बयान सही है,

951
01:06:14,000 --> 01:06:16,000
और हमारे समारोह में वापस आ जाएगी,

952
01:06:16,000 --> 01:06:21,000
और इसलिए हम अनिवार्य रूप से इस बिंदु पर इस समारोह में गर्भपात

953
01:06:21,000 --> 01:06:24,000
जब हम सच वापसी.

954
01:06:24,000 --> 01:06:28,000
लेकिन इस संरचना के साथ क्या होता है?

955
01:06:28,000 --> 01:06:34,000
यह पूरी तरह से काम करेंगे, या वहाँ में कुछ तार्किक दोष है?

956
01:06:34,000 --> 01:06:37,000
>> वहाँ में कुछ तार्किक दोष है, जिस तरह से इसे स्थापित किया है के साथ है.

957
01:06:37,000 --> 01:06:40,000
यह क्या हो सकता है?

958
01:06:40,000 --> 01:06:43,000
[छात्र] क्यों तुम्हें क्या ज़रूरत है - और 1s?

959
01:06:43,000 --> 01:06:47,000
वह हमारे सरणी सेट अप करने के लिए हमारे नए बाईं आधा और सही आधा हो.

960
01:06:47,000 --> 01:06:51,000
[छात्र] लेकिन आप इसे बिना क्यों नहीं कर सकता - 1s और 1s?

961
01:06:51,000 --> 01:06:53,000
[नैट] हम इसे सेट midpoint के बराबर हो सकता है?

962
01:06:53,000 --> 01:07:04,000
क्या उस के बारे में समस्याग्रस्त हो सकता है?

963
01:07:04,000 --> 01:07:08,000
[छात्र] मुझे लगता है कि यह अक्षम है क्योंकि आप एक मूल्य है कि पहले से ही जाँच की गई जाँच कर रहे हैं.

964
01:07:08,000 --> 01:07:11,000
[नैट] वास्तव में, तो सैम पूरी तरह से सही है.

965
01:07:11,000 --> 01:07:15,000
यदि आप अंत सेट और midpoint के बराबर शुरू करते हैं

966
01:07:15,000 --> 01:07:18,000
के बजाय 1 और संजीदगी से 1,

967
01:07:18,000 --> 01:07:22,000
भविष्य में कुछ बिंदु पर हम अंत midpoint फिर से जाँच करेंगे.

968
01:07:22,000 --> 01:07:26,000
[छात्र] मैं pset शुरू कर दिया है, और फिर मैं ऐसा कुछ था

969
01:07:26,000 --> 01:07:30,000
मैं + 1 जहां भूल गया, और यह एक अनंत लूप में फंस गया था.

970
01:07:30,000 --> 01:07:34,000
ठीक है, क्योंकि कुछ बिंदु पर आप के शुरू और अंत कभी नहीं जा रहे हैं

971
01:07:34,000 --> 01:07:39,000
वास्तव में ओवरलैप.

972
01:07:39,000 --> 01:07:41,000
कूल.

973
01:07:41,000 --> 01:07:44,000
एक अधिक तार्किक दोष है, और वह यह है कि यह निश्चित रूप से होना चाहिए

974
01:07:44,000 --> 01:07:48,000
एक और अगर.

975
01:07:48,000 --> 01:07:55,000
ऐसा क्यों हो सकता है?

976
01:07:55,000 --> 01:07:59,000
>> कारण यह है कि अगर यह एक और अगर आप इसे, केविन देख नहीं है?

977
01:07:59,000 --> 01:08:02,000
[केविन] हाँ, क्योंकि आप अंत बिंदु बदल रहे हैं.

978
01:08:02,000 --> 01:08:05,000
[नैट] बिल्कुल सही.

979
01:08:05,000 --> 01:08:07,000
हम endpoint बदल रहे हैं,

980
01:08:07,000 --> 01:08:12,000
और अगर यह इस we'll तरह लिखा है के बीच रिक्त स्थान बनाने

981
01:08:12,000 --> 01:08:14,000
यह इस मामले की जाँच करेगा.

982
01:08:14,000 --> 01:08:18,000
इस मामले में, अगर यह सफल होता है, समारोह के गर्भपात से बाहर होगी.

983
01:08:18,000 --> 01:08:21,000
तो यह इस मामले की जांच करेंगे,

984
01:08:21,000 --> 01:08:24,000
और अगर यह सफल होता है, यह endpoint समायोजित करेगा,

985
01:08:24,000 --> 01:08:28,000
और फिर इसे जारी रखने के लिए और इस मामले की जांच करेंगे.

986
01:08:28,000 --> 01:08:31,000
लेकिन इस बिंदु पर, हम यह जाँच जारी रखने के लिए नहीं करना चाहती.

987
01:08:31,000 --> 01:08:35,000
सौभाग्य से, हम यहाँ midpoint पुनर्स्थापित नहीं किया है,

988
01:08:35,000 --> 01:08:39,000
और हम जानते हैं कि इस मामले में सफल नहीं होगा.

989
01:08:39,000 --> 01:08:44,000
लेकिन हम निश्चित रूप से किसी और डाल करना चाहते हैं, अगर वहाँ में

990
01:08:44,000 --> 01:08:48,000
भले ही इस मामले में हो सकता है कि

991
01:08:48,000 --> 01:08:52,000
के बाद से हम midpoint समायोजन नहीं कर रहे हैं, कि एक फर्क होता है?

992
01:08:52,000 --> 01:08:54,000
नहीं, क्योंकि इन सभी मामलों विशेष कर रहे हैं.

993
01:08:54,000 --> 01:08:58,000
फिर, मेरा बुरा.

994
01:08:58,000 --> 01:09:01,000
हम मुझे लगता है, यह किसी और की जरूरत नहीं है.

995
01:09:01,000 --> 01:09:05,000
हम इसे एक कोशिश करते हैं और इसे चलाने के लिए दे सकते हैं और देखो क्या होता है.

996
01:09:05,000 --> 01:09:08,000
भवन, एक त्रुटि हुई.

997
01:09:08,000 --> 01:09:12,000
यह शायद इसलिए क्योंकि मैं यहाँ में इन ख और ई छोड़ दिया.

998
01:09:12,000 --> 01:09:14,000
मैं शीर्ष पर उन के किसी भी अधिक है?

999
01:09:14,000 --> 01:09:16,000
यह पसंद नहीं लगती है.

1000
01:09:16,000 --> 01:09:20,000
हम बाहर ज़ूम, निर्माण,

1001
01:09:20,000 --> 01:09:24,000
वहाँ यह हो जाता है, तो अब अगर हम 15 के लिए खोज करने के लिए,

1002
01:09:24,000 --> 01:09:28,000
हां.

1003
01:09:28,000 --> 01:09:30,000
मुझे अंदर ज़ूम

1004
01:09:30,000 --> 01:09:33,000
15, हाँ. हम इसे फिर से चला सकते हैं.

1005
01:09:33,000 --> 01:09:36,000
स्रोत कोड अपलोड, निर्माण, चल रहा है.

1006
01:09:36,000 --> 01:09:41,000
हम कुछ करने के लिए 13 तरह की खोज कर सकते हैं,

1007
01:09:41,000 --> 01:09:45,000
और हम मुद्रण बाहर कुछ भी नहीं मिलता है, तो यह नहीं लग रहा है कि हमारे लिए.

1008
01:09:45,000 --> 01:09:51,000
यह बहुत अच्छी बात है, क्योंकि यह हमारी सूची में नहीं है.

1009
01:09:51,000 --> 01:09:53,000
>> हम समय से बाहर अब कर रहे हैं.

1010
01:09:53,000 --> 01:09:55,000
कि यह हो सकता है इस सप्ताह के लिए जा रहा है.

1011
01:09:55,000 --> 01:10:00,000
शामिल होने, और बाद में मिलेंगे के लिए धन्यवाद.

1012
01:10:00,000 --> 01:10:02,000
>> [CS50.TV]