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

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

3
00:00:04,000 --> 00:00:07,000
[यह CS50 है.] [CS50.TV]

4
00:00:07,000 --> 00:00:10,000
>> सब ठीक है, अनुभाग के लिए वापस स्वागत करते हैं.

5
00:00:10,000 --> 00:00:13,000
इस सप्ताह के अनुभाग में हम चीजों की एक जोड़ी करने के लिए जा रहे हैं.

6
00:00:13,000 --> 00:00:17,000
हम 1 पुनर्कथन समस्या 2 सेट के लिए जा रहे हैं,

7
00:00:17,000 --> 00:00:20,000
जो कैसर और Vigenère समस्या सेट है.

8
00:00:20,000 --> 00:00:23,000
और फिर हम क्विज 0 समीक्षा में गोता लगाने के लिए जा रहे हैं

9
00:00:23,000 --> 00:00:26,000
और समय का एक छोटा सा recapping क्या हम के बारे में बात की है खर्च

10
00:00:26,000 --> 00:00:30,000
व्याख्यान में से प्रत्येक में अब तक, और हम भी कुछ समस्याओं करूँगा

11
00:00:30,000 --> 00:00:32,000
पिछले वर्ष के quizzes से.

12
00:00:32,000 --> 00:00:36,000
कि जिस तरह से तुम लोगों को उस के लिए तैयार करने के लिए एक अच्छा तरीका है.

13
00:00:36,000 --> 00:00:40,000
>> शुरू करने के लिए, मैं अच्छा समाधान के एक जोड़े को हटा दिया गया है

14
00:00:40,000 --> 00:00:45,000
पिछले समस्या सेट के लिए, समस्या 2 इस अंतरिक्ष में सेट करें.

15
00:00:45,000 --> 00:00:48,000
यदि आप लोगों को यह सब कड़ी मारा,

16
00:00:48,000 --> 00:00:53,000
और अगर आप मेरे नाम पर क्लिक करें और अपने पहले संशोधन पर क्लिक करें

17
00:00:53,000 --> 00:00:56,000
आप देखेंगे caesar.c है, जो वास्तव में है क्या मैं देख रहा हूँ.

18
00:00:56,000 --> 00:01:00,000
चलो इस बारे में बात बहुत जल्दी.

19
00:01:00,000 --> 00:01:02,000
यह सिर्फ एक नमूना समाधान है.

20
00:01:02,000 --> 00:01:05,000
यह सही समाधान जरूरी नहीं है.

21
00:01:05,000 --> 00:01:08,000
यह लिखने के लिए कई अलग अलग तरीके हैं,

22
00:01:08,000 --> 00:01:10,000
लेकिन वहाँ कुछ चीजें हैं जो मैं उजागर करना चाहता था

23
00:01:10,000 --> 00:01:13,000
कि मैंने देखा है के रूप में मैं ग्रेडिंग था, आम गलतियों कि मुझे लगता है कि

24
00:01:13,000 --> 00:01:18,000
इस समाधान से निपटने का एक बहुत अच्छा काम करता है.

25
00:01:18,000 --> 00:01:22,000
>> पहली बार शीर्ष पर हेडर टिप्पणी के कुछ प्रकार हो रही है.

26
00:01:22,000 --> 00:01:25,000
1 तर्ज पर 7 के माध्यम से आप विवरण देखने के लिए,

27
00:01:25,000 --> 00:01:28,000
क्या वास्तव में इस कार्यक्रम कर रही है.

28
00:01:28,000 --> 00:01:32,000
जब आप सी कोड लिख रहे हैं एक अच्छा मानक अभ्यास

29
00:01:32,000 --> 00:01:35,000
चाहे तो अपने कार्यक्रम में एक एकल फाइल या भीतर निहित है

30
00:01:35,000 --> 00:01:38,000
चाहे वह कई फाइलों पर विभाजित करने के लिए किसी प्रकार का है

31
00:01:38,000 --> 00:01:40,000
शीर्ष पर टिप्पणी orienting.

32
00:01:40,000 --> 00:01:43,000
यह लोग हैं, जो बाहर जाने के लिए और वास्तविक दुनिया में कोड लिखने के लिए भी है.

33
00:01:43,000 --> 00:01:47,000
यह वह जगह है जहाँ वे कॉपीराइट जानकारी डाल देता हूँ.

34
00:01:47,000 --> 00:01:50,000
नीचे # शामिल हैं.

35
00:01:50,000 --> 00:01:55,000
16 लाइन पर यह परिभाषित # है, जो हम वापस करने के लिए सिर्फ एक बिट में आ जाएगा.

36
00:01:55,000 --> 00:01:59,000
और फिर एक बार समारोह शुरू होता है, एक बार मुख्य शुरू होता है,

37
00:01:59,000 --> 00:02:03,000
क्योंकि इस कार्यक्रम में सभी एक समारोह में शामिल किया गया है

38
00:02:03,000 --> 00:02:09,000
बहुत पहले की बात है कि होता है और यह बहुत मुहावरेदार और एक सी कार्यक्रम के विशिष्ट है

39
00:02:09,000 --> 00:02:14,000
कि कमांड लाइन में लेता है तर्क है कि इसे तुरंत जाँच करता है

40
00:02:14,000 --> 00:02:18,000
>> तर्क गिनती के लिए, argc.

41
00:02:18,000 --> 00:02:24,000
ठीक है यहाँ हम देखते हैं कि इस कार्यक्रम 2 तर्कों की उम्मीद है बिल्कुल.

42
00:02:24,000 --> 00:02:27,000
याद रखें कि 1 तर्क है कि विशेष एक है

43
00:02:27,000 --> 00:02:29,000
कि हमेशा कार्यक्रम चलाया जा रहा है कि नाम है,

44
00:02:29,000 --> 00:02:31,000
निष्पादन योग्य फ़ाइल के नाम.

45
00:02:31,000 --> 00:02:36,000
और इसलिए यह क्या करता है यह कार्यक्रम चल रहा से उपयोगकर्ता को रोकता है

46
00:02:36,000 --> 00:02:42,000
अधिक या कम तर्क के साथ.

47
00:02:42,000 --> 00:02:44,000
कारण है कि हम इस अधिकार के लिए दूर की जांच करना चाहते हैं क्योंकि है

48
00:02:44,000 --> 00:02:52,000
हम वास्तव में इस argv सरणी सही यहाँ मज़बूती से उपयोग नहीं कर सकते

49
00:02:52,000 --> 00:02:55,000
जब तक हम देखने के लिए कितना बड़ा है यह जाँच की है.

50
00:02:55,000 --> 00:02:58,000
>> एक आम त्रुटियों मैंने देखा था कि लोगों को तुरंत जाना होगा

51
00:02:58,000 --> 00:03:01,000
और हड़पने argv [1].

52
00:03:01,000 --> 00:03:06,000
वे सरणी के बाहर कुंजी तर्क हड़पने और एक मैं उस पर जांच करने के लिए चाहते हैं,

53
00:03:06,000 --> 00:03:11,000
और फिर वे argc के लिए परीक्षण के रूप में अगले टेस्ट के रूप में अच्छी तरह से करना चाहते हैं,

54
00:03:11,000 --> 00:03:16,000
चाहे या नहीं पहले तर्क वास्तव में एक ही समय में एक पूर्णांक था,

55
00:03:16,000 --> 00:03:20,000
और कहा कि क्योंकि इस मामले में काम नहीं करता है कि वहाँ कोई आपूर्ति की बहस कर रहे हैं

56
00:03:20,000 --> 00:03:26,000
आप एक तर्क है कि वहाँ नहीं है हथियाने हो जाएगा या एक है कि वहाँ नहीं है हड़पने के प्रयास में है.

57
00:03:26,000 --> 00:03:29,000
>> अन्य बड़ी बात है कि आप ध्यान देना चाहिए है कि

58
00:03:29,000 --> 00:03:32,000
आप हमेशा के लिए बाहर उपयोगी त्रुटि संदेश के कुछ प्रकार मुद्रित करना चाहते हैं

59
00:03:32,000 --> 00:03:34,000
उन्हें उन्मुख करने के लिए उपयोगकर्ता के लिए.

60
00:03:34,000 --> 00:03:37,000
मुझे यकीन है कि आप सभी कार्यक्रम चलाने, जहाँ अचानक यह दुर्घटनाओं लिया है हूँ,

61
00:03:37,000 --> 00:03:41,000
और आप यह हास्यास्पद सा संवाद है कि ऊपर चबूतरे और कहते हैं

62
00:03:41,000 --> 00:03:44,000
बुरी तरह से गुप्त है और शायद कुछ आप एक त्रुटि कोड या उस तरह कुछ देता है

63
00:03:44,000 --> 00:03:47,000
कि कोई मतलब नहीं है.

64
00:03:47,000 --> 00:03:50,000
यह वह जगह है जहाँ आप वास्तव में उपयोगी कुछ प्रदान करना चाहते हैं

65
00:03:50,000 --> 00:03:54,000
और उपयोगकर्ता के लिए लक्षित ताकि जब वे इसे चलाने के लिए वे "ओह," हथेली चेहरा जाना.

66
00:03:54,000 --> 00:03:58,000
"मैं जानता हूँ कि वास्तव में क्या करने के लिए मुझे पता है कि यह कैसे तय करने के लिए."

67
00:03:58,000 --> 00:04:01,000
>> यदि आप एक संदेश मुद्रित नहीं है, तो आप वास्तव में अंत

68
00:04:01,000 --> 00:04:04,000
उपयोगकर्ता जाने के लिए छोड़कर अपने स्रोत कोड की जांच

69
00:04:04,000 --> 00:04:07,000
पता लगाने की क्या गलत हो गया था.

70
00:04:07,000 --> 00:04:11,000
वहाँ भी कुछ समय है कि आप अलग त्रुटि कोड का उपयोग करेंगे.

71
00:04:11,000 --> 00:04:14,000
यहाँ हम सिर्फ एक का इस्तेमाल करने के लिए कहते हैं कि वहाँ एक त्रुटि थी,

72
00:04:14,000 --> 00:04:16,000
वहाँ एक त्रुटि थी, वहाँ एक त्रुटि थी.

73
00:04:16,000 --> 00:04:20,000
बड़ा कार्यक्रम, अक्सर प्रोग्राम है कि अन्य कार्यक्रमों के द्वारा कहा जाता है,

74
00:04:20,000 --> 00:04:25,000
विभिन्न परिदृश्यों में विशेष त्रुटि कोड के कुछ प्रकार वापस आ जाएगी

75
00:04:25,000 --> 00:04:28,000
प्रोग्राम संवाद आप अन्यथा होगा क्या

76
00:04:28,000 --> 00:04:32,000
बस के लिए एक अच्छा संदेश अंग्रेजी का उपयोग करें.

77
00:04:32,000 --> 00:04:35,000
कूल.

78
00:04:35,000 --> 00:04:37,000
जैसा कि हम नीचे काम करते हैं, तो आप देख सकते हैं कि हम कुंजी बाहर खींच.

79
00:04:37,000 --> 00:04:40,000
हम देखने के लिए अगर कुंजी फिट बैठता है का परीक्षण करें.

80
00:04:40,000 --> 00:04:42,000
हम उपयोगकर्ता से एक संदेश मिलता है.

81
00:04:42,000 --> 00:04:46,000
कारण है कि हम इसे इस में क्या करते हैं, जबकि पाश और यह कुछ है कि हम को कवर किया जाएगा

82
00:04:46,000 --> 00:04:50,000
एक छोटे सा है, लेकिन यह पता चला है कि अगर आप नियंत्रण डी प्रकार

83
00:04:50,000 --> 00:04:54,000
जब आप कि GetString टर्मिनल पर शीघ्र

84
00:04:54,000 --> 00:04:59,000
क्या है कि वास्तव में क्या करता है यह एक विशेष चरित्र भेजता

85
00:04:59,000 --> 00:05:01,000
कार्यक्रम के लिए.

86
00:05:01,000 --> 00:05:05,000
यह एल्फ या फ़ाइल चरित्र का अंत कहा जाता है.

87
00:05:05,000 --> 00:05:08,000
और उस मामले में, हमारे संदेश स्ट्रिंग रिक्त हो जाएगा,

88
00:05:08,000 --> 00:05:14,000
तो यह कुछ हम समस्या में ही स्थापित के लिए जाँच नहीं था.

89
00:05:14,000 --> 00:05:17,000
>> लेकिन के रूप में हम पर जाओ, अब है कि हम संकेत के बारे में बात करना शुरू कर दिया है

90
00:05:17,000 --> 00:05:21,000
और ढेर पर गतिशील स्मृति आवंटन,

91
00:05:21,000 --> 00:05:25,000
जब भी आप एक समारोह में कहा कि हो सकता है अशक्त के लिए जाँच

92
00:05:25,000 --> 00:05:30,000
अशक्त वापसी के रूप में एक मूल्य कुछ है कि आप करने की आदत में शामिल होने के लिए चाहता हूँ.

93
00:05:30,000 --> 00:05:33,000
यह स्पष्ट करने के लिए मुख्य रूप से यहाँ है.

94
00:05:33,000 --> 00:05:36,000
लेकिन जब आप भविष्य में GetString देखने के लिए करते हैं,

95
00:05:36,000 --> 00:05:41,000
पर 4 सेट समस्या से, आप को ध्यान में रखना चाहता हूँ.

96
00:05:41,000 --> 00:05:44,000
फिर, यह तो 3 सेट क्योंकि हम अभी तक यह नहीं शामिल किया था समस्या के लिए एक मुद्दा नहीं है.

97
00:05:44,000 --> 00:05:53,000
अंत में, हम इस भाग जहां हम मुख्य एन्क्रिप्शन पाश के लिए करने के लिए मिलता है,

98
00:05:53,000 --> 00:05:57,000
और यहाँ पर जा रहा चीजों के एक जोड़े हैं.

99
00:05:57,000 --> 00:06:02,000
सबसे पहले, हम पूरे संदेश स्ट्रिंग ही अधिक पुनरावृति.

100
00:06:02,000 --> 00:06:07,000
यहाँ हम हालत में strlen फोन रखा है,

101
00:06:07,000 --> 00:06:12,000
आप में से एक नंबर बाहर बताया है जो एक महान जाने के लिए रास्ता नहीं है.

102
00:06:12,000 --> 00:06:15,000
यह इस मामले में पता चला है यह भी महान नहीं है,

103
00:06:15,000 --> 00:06:20,000
आंशिक रूप से, क्योंकि हम ही संदेश की सामग्री को संशोधित कर रहे हैं

104
00:06:20,000 --> 00:06:27,000
अंदर पाश के लिए है, इसलिए यदि हम एक संदेश है कि 10 वर्णों तक लंबा है,

105
00:06:27,000 --> 00:06:32,000
पहली बार हम शुरू कि strlen पाश के लिए वापस आ जाएगी?

106
00:06:32,000 --> 00:06:35,000
10.

107
00:06:35,000 --> 00:06:40,000
>> लेकिन अगर हम तो संदेश संशोधित कहते हैं, हम अपने 5 चरित्र को संशोधित,

108
00:06:40,000 --> 00:06:46,000
और हम 5 की स्थिति में एक \ 0 चरित्र में फेंक,

109
00:06:46,000 --> 00:06:49,000
बाद में एक यात्रा पर strlen (संदेश) वापस नहीं होगा कि यह क्या किया

110
00:06:49,000 --> 00:06:52,000
बहुत पहली बार हम दोहराया,

111
00:06:52,000 --> 00:06:56,000
लेकिन यह बजाय 5 वापस क्योंकि हम कि अशक्त टर्मिनेटर में फेंक दिया जाएगा,

112
00:06:56,000 --> 00:06:59,000
और स्ट्रिंग की लंबाई में परिभाषित किया गया है

113
00:06:59,000 --> 00:07:03,000
कि \ 0 की स्थिति से.

114
00:07:03,000 --> 00:07:09,000
इस मामले में, यह एक शानदार तरीका है जाने के कारण हम यह जगह में संशोधित कर रहे हैं.

115
00:07:09,000 --> 00:07:13,000
लेकिन तुम नोटिस कि यह वास्तव में आश्चर्यजनक रूप से आसान है एन्क्रिप्ट करने के लिए

116
00:07:13,000 --> 00:07:16,000
अगर आप गणित सही हो सकता है.

117
00:07:16,000 --> 00:07:19,000
सभी आवश्यक है कि चाहे या नहीं पत्र की जाँच करें कि आप देख रहे हैं

118
00:07:19,000 --> 00:07:21,000
अपरकेस या लोअरकेस है.

119
00:07:21,000 --> 00:07:24,000
>> कारण है कि हम केवल उस के लिए जाँच करने के लिए किया है और हम के लिए जाँच करने के लिए नहीं है

120
00:07:24,000 --> 00:07:27,000
अल्फा मामला है क्योंकि

121
00:07:27,000 --> 00:07:30,000
अगर एक चरित्र अपरकेस या अगर यह लोअरकेस है

122
00:07:30,000 --> 00:07:33,000
तो यह निश्चित रूप से एक वर्णमाला चरित्र है,

123
00:07:33,000 --> 00:07:38,000
क्योंकि हम अपरकेस और लोअरकेस अंक नहीं है.

124
00:07:38,000 --> 00:07:41,000
दूसरी बात हम करते हैं और यह एक थोड़ा मुश्किल है

125
00:07:41,000 --> 00:07:45,000
हम मानक सीज़र बीजलेख सूत्र संशोधित किया है

126
00:07:45,000 --> 00:07:49,000
कि हम समस्या सेट विनिर्देश में दिया.

127
00:07:49,000 --> 00:07:52,000
यहाँ अलग है यह है कि हम subtracted

128
00:07:52,000 --> 00:07:58,000
अपरकेस मामले राजधानी में एक, और फिर हम एक राजधानी जोड़ा

129
00:07:58,000 --> 00:08:02,000
अंत में वापस.

130
00:08:02,000 --> 00:08:05,000
>> मैं जानता हूँ कि आप में से कुछ अपने कोड में इस किया है.

131
00:08:05,000 --> 00:08:09,000
क्या आप में से कोई भी अपनी प्रस्तुतियाँ में इस करते हैं?

132
00:08:09,000 --> 00:08:13,000
आप इस किया. तुम समझा क्या नहीं कर सकते हैं, Sahb?

133
00:08:13,000 --> 00:08:18,000
इसे घटाकर बाहर है, क्योंकि आप इसे सही होने के बाद एक आधुनिक किया,

134
00:08:18,000 --> 00:08:21,000
आप इसे बाहर ले, तो तरीका है कि आप [खाँसी] स्थिति है.

135
00:08:21,000 --> 00:08:25,000
और फिर इसे वापस जोड़ने के बाद आप एक है कि तुम चाहते थे पर स्थानांतरित कर दिया.

136
00:08:25,000 --> 00:08:27,000
हाँ, बिल्कुल.

137
00:08:27,000 --> 00:08:32,000
Sahb क्या कहा था कि जब हम जोड़ने के लिए करना चाहते हैं

138
00:08:32,000 --> 00:08:36,000
हमारा संदेश और हमारे साथ कुंजी

139
00:08:36,000 --> 00:08:42,000
और फिर, आधुनिक आधुनिक कि NUM_LETTERS द्वारा,

140
00:08:42,000 --> 00:08:50,000
अगर हम उपयुक्त 0 से 25 श्रेणी में हमारे संदेश पैमाने पर नहीं 1,

141
00:08:50,000 --> 00:08:54,000
तो हम अंत में एक बहुत ही अजीब संख्या में हो रही हो सकता है

142
00:08:54,000 --> 00:08:59,000
क्योंकि मूल्यों है कि हम जब हम [i] संदेश में देखो में देख रहे हैं,

143
00:08:59,000 --> 00:09:03,000
, जब हम हमारे सादे पाठ संदेश के ith चरित्र पर देखो

144
00:09:03,000 --> 00:09:08,000
यह 65 से 122 रेंज में एक मूल्य कहीं है

145
00:09:08,000 --> 00:09:13,000
लोअरकेस z के माध्यम से एक अपरकेस के लिए ASCII मूल्यों पर आधारित है.

146
00:09:13,000 --> 00:09:18,000
और इसलिए जब हम इसे 26 या NUM_LETTERS द्वारा आधुनिक,

147
00:09:18,000 --> 00:09:23,000
के बाद से था कि हमारे # सही शीर्ष पर परिभाषित करने के लिए,

148
00:09:23,000 --> 00:09:28,000
कि हमें एक मूल्य है कि 0 से 25 रेंज में देने जा रही है,

149
00:09:28,000 --> 00:09:30,000
और हम तो पैमाने कि वापस ऊपर के लिए एक तरह की जरूरत है

150
00:09:30,000 --> 00:09:32,000
और यह उचित ASCII रेंज में मिलता है.

151
00:09:32,000 --> 00:09:36,000
सबसे आसान तरीका है कि अभी सब कुछ नीचे पैमाने

152
00:09:36,000 --> 00:09:39,000
के साथ शुरू करने के लिए 0 से 25 रेंज में,

153
00:09:39,000 --> 00:09:43,000
और फिर सब कुछ अंत में वापस पाली.

154
00:09:43,000 --> 00:09:46,000
>> एक अन्य आम त्रुटि है कि मैंने देखा कि लोगों में चलाने की है कि

155
00:09:46,000 --> 00:09:50,000
अगर आप वास्तव में इस स्केलिंग नहीं कर सही दूर

156
00:09:50,000 --> 00:09:53,000
और आप संदेश और चाबी के साथ जोड़ सकते हैं और आप उन्हें जोड़ने, कहते हैं,

157
00:09:53,000 --> 00:09:58,000
एक चार चर में, उस के साथ समस्या

158
00:09:58,000 --> 00:10:01,000
संदेश के बाद से मैं [] शुरू करने के लिए एक अपेक्षाकृत बड़ी संख्या है साथ

159
00:10:01,000 --> 00:10:05,000
याद है कि यह कम से कम 65 है अगर यह एक अपरकेस है चरित्र

160
00:10:05,000 --> 00:10:09,000
यदि आप एक बड़ी कुंजी है, कहते हैं, 100 की तरह कुछ है,

161
00:10:09,000 --> 00:10:13,000
और आप उन 2 को एक साथ जोड़ने में एक हस्ताक्षरित चार आप एक अतिप्रवाह पाने के लिए जा रहे हैं.

162
00:10:13,000 --> 00:10:17,000
आप के लिए एक मूल्य है कि 127 से भी बड़ा है पाने के लिए जा रहे हैं,

163
00:10:17,000 --> 00:10:22,000
जो सबसे बड़ा मूल्य है कि एक चार चर पकड़ सकता है.

164
00:10:22,000 --> 00:10:26,000
फिर, यही कारण है कि आप के साथ शुरू करने की बात की है कि तरह करना चाहता हूँ.

165
00:10:26,000 --> 00:10:29,000
कुछ लोगों को अगर एक और कर रही है और परीक्षण के द्वारा उस मामले के आसपास मिला

166
00:10:29,000 --> 00:10:33,000
अगर यह होगा अतिप्रवाह देखने से पहले कर रही है कि,

167
00:10:33,000 --> 00:10:36,000
लेकिन इस तरह से है कि चारों ओर हो जाता है.

168
00:10:36,000 --> 00:10:40,000
और फिर हम इस समाधान में बहुत अंत में पूरे स्ट्रिंग मुद्रित.

169
00:10:40,000 --> 00:10:45,000
अन्य लोगों को एक समय में एक चरित्र मुद्रित. दोनों कमाल कर रहे हैं.

170
00:10:45,000 --> 00:10:51,000
इस बिंदु पर करने के लिए, आप लोग किसी भी सवाल है, इस बारे में कोई टिप्पणी?

171
00:10:51,000 --> 00:10:56,000
चीजें आप चाहें, तो बातें आप पसंद नहीं करते?

172
00:10:56,000 --> 00:10:58,000
>> मैं एक सवाल था.

173
00:10:58,000 --> 00:11:01,000
शायद मैं इसे अपने विवरण के दौरान याद किया, लेकिन कैसे इस कार्यक्रम करता है

174
00:11:01,000 --> 00:11:07,000
पाठ की लंबाई के लिए कुंजी को जोड़ने के लिए रिक्त स्थान को छोड़?

175
00:11:07,000 --> 00:11:10,000
यह सिर्फ सीज़र बीजलेख. >> ओह, माफ करना, हाँ.

176
00:11:10,000 --> 00:11:13,000
हाँ, हम देखेंगे.

177
00:11:13,000 --> 00:11:16,000
सीज़र सिफर में हम है कि चारों ओर मिला है क्योंकि

178
00:11:16,000 --> 00:11:18,000
हम केवल वर्ण फ़्लिप किया.

179
00:11:18,000 --> 00:11:27,000
हम केवल उन्हें घुमाया अगर वे अपरकेस या लोअरकेस थे.

180
00:11:27,000 --> 00:11:32,000
तुम लोग इस बारे में बहुत अच्छा लग रहा है?

181
00:11:32,000 --> 00:11:34,000
इस घर की नकल करने के लिए स्वतंत्र लग रहा है, इसे ले लो,

182
00:11:34,000 --> 00:11:37,000
यह तुम लोगों को क्या लिखा तुलना.

183
00:11:37,000 --> 00:11:42,000
निश्चित रूप से इसके बारे में सवाल भी भेजने के लिए स्वतंत्र महसूस हो रहा है.

184
00:11:42,000 --> 00:11:46,000
और फिर एहसास है कि अपनी समस्या के साथ यहाँ लक्ष्य सेट

185
00:11:46,000 --> 00:11:50,000
के लिए नहीं मिल तुम लोगों को अपनी समस्या के सेट के लिए सही कोड लिखने के लिए है.

186
00:11:50,000 --> 00:11:57,000
यह एक सीखने का अनुभव है. हाँ.

187
00:11:57,000 --> 00:12:01,000
>> वापस करने के लिए, अगर यह बराबर होती है जबकि पाश अशक्त,

188
00:12:01,000 --> 00:12:06,000
इतना अशक्त सिर्फ कोई मतलब नहीं है, वे सिर्फ हिट दर्ज करें?

189
00:12:06,000 --> 00:12:12,000
अशक्त एक विशेष सूचक मान है,

190
00:12:12,000 --> 00:12:17,000
और हम अशक्त का उपयोग करें जब हम कहना चाहते हैं

191
00:12:17,000 --> 00:12:23,000
हम एक सूचक चर है कि कुछ भी नहीं करने के लिए इशारा कर रहा है.

192
00:12:23,000 --> 00:12:28,000
और इसलिए आम तौर पर इसका मतलब है कि इस चर, इस संदेश चर

193
00:12:28,000 --> 00:12:35,000
खाली है, और यहाँ है, क्योंकि हम CS50 विशेष स्ट्रिंग प्रकार का उपयोग कर रहे हैं,

194
00:12:35,000 --> 00:12:37,000
CS50 स्ट्रिंग प्रकार क्या है?

195
00:12:37,000 --> 00:12:42,000
क्या तुमने देखा है कि यह क्या है जब दाऊद व्याख्यान में हुड वापस खींच लिया?

196
00:12:42,000 --> 00:12:44,000
यह एक कायरता यह एक सूचक है, है ना?

197
00:12:44,000 --> 00:12:48,000
ठीक है, हाँ. >> यह एक चार * है.

198
00:12:48,000 --> 00:12:52,000
और तो वास्तव में हम इस जगह ले सकता है

199
00:12:52,000 --> 00:12:56,000
सही यहाँ चार * संदेश के साथ,

200
00:12:56,000 --> 00:13:04,000
और तो GetString समारोह, अगर यह सफलतापूर्वक उपयोगकर्ता से एक स्ट्रिंग नहीं मिलता है,

201
00:13:04,000 --> 00:13:08,000
यह एक स्ट्रिंग को पार्स नहीं कर सकता है, और जो एक मामले में यह एक स्ट्रिंग विश्लेषण नहीं कर सकता

202
00:13:08,000 --> 00:13:11,000
उपयोगकर्ता फ़ाइल चरित्र, नियंत्रण डी के अंत प्रकार अगर,

203
00:13:11,000 --> 00:13:17,000
जो कुछ आप आम तौर पर करते नहीं है, लेकिन अगर ऐसा होता है

204
00:13:17,000 --> 00:13:20,000
तो कहने का एक तरीका समारोह के रूप में इस अशक्त मूल्य वापसी करेंगे

205
00:13:20,000 --> 00:13:23,000
"अरे, मैं एक स्ट्रिंग नहीं मिला."

206
00:13:23,000 --> 00:13:27,000
क्या होगा अगर हम संदेश = अशक्त नहीं डाल दिया होगा,

207
00:13:27,000 --> 00:13:30,000
जो कुछ है कि हम अभी तक नहीं कर रही है?

208
00:13:30,000 --> 00:13:32,000
कि एक समस्या यहाँ क्यों होगा?

209
00:13:32,000 --> 00:13:38,000
क्योंकि मुझे पता है कि हम स्मृति लीक के बारे में व्याख्यान में एक छोटा सा बात.

210
00:13:38,000 --> 00:13:42,000
हाँ, चलो करते हैं कि, और देखते हैं क्या होता है.

211
00:13:42,000 --> 00:13:44,000
>> बासिल सवाल था कि क्या होता है अगर हम वास्तव में नहीं है

212
00:13:44,000 --> 00:13:48,000
इस संदेश = अशक्त परीक्षण?

213
00:13:48,000 --> 00:13:51,000
चलो शीर्ष करने के लिए स्क्रॉल.

214
00:13:51,000 --> 00:13:53,000
तुम लोग इस बाहर टिप्पणी कर सकते हैं.

215
00:13:53,000 --> 00:13:55,000
असल में, मैं इसे एक संशोधन में बचा लेंगे.

216
00:13:55,000 --> 00:13:58,000
यह 3 संशोधन किया जाएगा.

217
00:13:58,000 --> 00:14:02,000
क्या आप इस कार्यक्रम को चलाने के लिए करना होगा है कि आप इस गियर आइकन यहाँ क्लिक करें होगा,

218
00:14:02,000 --> 00:14:04,000
और आप इसे करने के लिए एक तर्क जोड़ना होगा.

219
00:14:04,000 --> 00:14:10,000
आप यह कुंजी तर्क दे सकते है, क्योंकि हम एक कमांड लाइन तर्क में पारित करना चाहते हैं.

220
00:14:10,000 --> 00:14:13,000
यहाँ मैं यह 3 संख्या देने के लिए जा रहा हूँ. मैं 3 पसंद है.

221
00:14:13,000 --> 00:14:19,000
अब वापस बाहर zooming, कार्यक्रम चल रहा है.

222
00:14:19,000 --> 00:14:24,000
यह चल रहा है, संकलन, निर्माण.

223
00:14:24,000 --> 00:14:27,000
यहाँ हम चले. यह करने के लिए प्रेरित किया जा इंतज़ार कर रही है.

224
00:14:27,000 --> 00:14:33,000
अगर मैं हैलो जहां की तरह कुछ में टाइप किया जाना है?

225
00:14:33,000 --> 00:14:38,000
ओह, मेरे कार्यक्रम को चलाने के लिए बहुत लंबा लिया. मैं भी लंबे समय के लिए jawing था.

226
00:14:38,000 --> 00:14:40,000
यहाँ यह जाता है.

227
00:14:40,000 --> 00:14:43,000
अब मैं हैलो में लिखें.

228
00:14:43,000 --> 00:14:46,000
हम देखते हैं कि यह उचित encrypts.

229
00:14:46,000 --> 00:14:52,000
अब क्या होता है अगर हम शीघ्र GetString करना अशक्त लौटने?

230
00:14:52,000 --> 00:14:57,000
याद है, मैंने कहा कि हम किया है कि एक ही समय में नियंत्रण डी दबाकर.

231
00:14:57,000 --> 00:14:59,000
मैं यहाँ स्क्रॉल जाएगा. हम इसे फिर से भाग लेंगे.

232
00:14:59,000 --> 00:15:01,000
बिल्डिंग. यह हो जाता है.

233
00:15:01,000 --> 00:15:04,000
अब जब मैं नियंत्रण डी मारा

234
00:15:04,000 --> 00:15:12,000
मैं इस लाइन है कि opt/sandbox50/bin/run.sh कहते हैं, विभाजन गलती है.

235
00:15:12,000 --> 00:15:15,000
क्या इससे पहले कि तुम लोगों को देखा है?

236
00:15:15,000 --> 00:15:17,000
>> [छात्र] क्यों वहाँ कोई >> माफ करना है?

237
00:15:17,000 --> 00:15:20,000
[छात्र] क्यों इस मामले में कोई कोर डंप है?

238
00:15:20,000 --> 00:15:26,000
कोर डंप सवाल कोई कोर डंप यहाँ क्यों है?

239
00:15:26,000 --> 00:15:29,000
सवाल यह है कि हो सकता है, लेकिन कोर डंप एक फाइल है

240
00:15:29,000 --> 00:15:31,000
कि हार्ड ड्राइव पर जमा हो जाता है.

241
00:15:31,000 --> 00:15:34,000
इस मामले में हम कोर डंप निष्क्रिय कर दिया है

242
00:15:34,000 --> 00:15:37,000
चलाने के सर्वर पर इतना है कि हम लोगों को नहीं है दोषयुक्त seg

243
00:15:37,000 --> 00:15:40,000
और कोर डंप के टन के निर्माण.

244
00:15:40,000 --> 00:15:46,000
लेकिन आप एक हो सकता है.

245
00:15:46,000 --> 00:15:48,000
कोर उदासीनता बात की तरह है कि आप अक्सर निष्क्रिय कर सकते हैं कर रहे हैं,

246
00:15:48,000 --> 00:15:52,000
और कभी कभी आप करते हैं.

247
00:15:52,000 --> 00:15:55,000
विभाजन गलती आपके सवाल का जवाब, तुलसी,

248
00:15:55,000 --> 00:16:00,000
कह रही है कि हम एक सूचक का उपयोग करने की कोशिश की

249
00:16:00,000 --> 00:16:05,000
है कि कुछ भी करने के लिए बात नहीं स्थापित किया गया था.

250
00:16:05,000 --> 00:16:09,000
वीडियो में Binky याद है जब Binky करने की कोशिश करता है

251
00:16:09,000 --> 00:16:12,000
एक सूचक है कि कुछ भी करने के लिए ओर इशारा करते हुए नहीं है पहुँच जाना?

252
00:16:12,000 --> 00:16:16,000
मैं इस मामले में लगता है कि तकनीकी सूचक कुछ करने के लिए इशारा कर रहा है.

253
00:16:16,000 --> 00:16:20,000
यह अशक्त, जो तकनीकी रूप से 0 की ओर इशारा करते है,

254
00:16:20,000 --> 00:16:25,000
लेकिन यह है कि एक खंड है कि सुलभ नहीं है में परिभाषित किया गया है

255
00:16:25,000 --> 00:16:28,000
अपने कार्यक्रम से है, तो आप एक विभाजन गलती

256
00:16:28,000 --> 00:16:31,000
क्योंकि तुम स्मृति अभिगम नहीं कर रहे है कि एक वैध खंड में है

257
00:16:31,000 --> 00:16:38,000
ढेर खंड या स्टैक खंड या डेटा खंड की तरह.

258
00:16:38,000 --> 00:16:40,000
कूल.

259
00:16:40,000 --> 00:16:48,000
सीज़र के बारे में कोई और सवाल?

260
00:16:48,000 --> 00:16:51,000
>> चलो पर स्थानांतरित. चलो 2 संशोधन पर वास्तव में जल्दी से देखो.

261
00:16:51,000 --> 00:17:00,000
वह Vigenère है.

262
00:17:00,000 --> 00:17:04,000
यहाँ Vigenère में

263
00:17:04,000 --> 00:17:06,000
हम इस एक के माध्यम से बहुत जल्दी करेंगे क्योंकि चलना फिर से,

264
00:17:06,000 --> 00:17:10,000
Vigenère और कैसर काफी समान हैं.

265
00:17:10,000 --> 00:17:12,000
हैडर से पहले टिप्पणी है,

266
00:17:12,000 --> 00:17:17,000
परिभाषित # से पहले इन जादुई संख्या का उपयोग कर से बचने के लिए है.

267
00:17:17,000 --> 00:17:21,000
अच्छी बात यह कहना है हम को स्थानांतरित करने के लिए करना चाहता था

268
00:17:21,000 --> 00:17:23,000
एक अलग या कुछ की तरह है कि वर्णमाला.

269
00:17:23,000 --> 00:17:26,000
मैन्युअल रूप से जाने के सभी 26 कोड में परिवर्तन के होने के बजाय

270
00:17:26,000 --> 00:17:30,000
हम इस 27 को बदलने के लिए या इसे नीचे छोड़ सकता

271
00:17:30,000 --> 00:17:34,000
अगर हम अलग अक्षर, विभिन्न भाषाओं का उपयोग कर रहे थे.

272
00:17:34,000 --> 00:17:38,000
फिर, हम तर्क गिनती के इस चेक मिल गया है,

273
00:17:38,000 --> 00:17:42,000
और वास्तव में आप लगभग एक टेम्पलेट के रूप में इस ले जा सकते हैं.

274
00:17:42,000 --> 00:17:46,000
बहुत ज्यादा हर कार्यक्रम आप लिखने होना चाहिए

275
00:17:46,000 --> 00:17:50,000
अगर यह कमांड लाइन लेता तर्क कुछ लाइनों के अनुक्रम

276
00:17:50,000 --> 00:17:55,000
कि बहुत शुरुआत में इस तरह से पढ़ता है.

277
00:17:55,000 --> 00:17:59,000
यह 1 विवेक परीक्षण आप करना चाहते हैं में से एक है.

278
00:17:59,000 --> 00:18:03,000
>> यहाँ क्या हम हम किया गया था कि यकीन है कि बनाया

279
00:18:03,000 --> 00:18:06,000
कीवर्ड वैध था, और कहा कि 2 की जाँच करें कि हम किया था.

280
00:18:06,000 --> 00:18:11,000
फिर से सूचना है कि हम argc और 2 से अलग.

281
00:18:11,000 --> 00:18:14,000
ध्यान दें कि इस मामले में एक बात यह है कि हम करना पड़ा बजाय था

282
00:18:14,000 --> 00:18:18,000
मैं एक का उपयोग कर के हम पूरे स्ट्रिंग को मान्य करने के लिए चाहता था,

283
00:18:18,000 --> 00:18:21,000
और आदेश में करने के लिए कि आप वास्तव में चरित्र द्वारा चरित्र जाना है

284
00:18:21,000 --> 00:18:23,000
स्ट्रिंग अधिक है.

285
00:18:23,000 --> 00:18:29,000
उस पर कुछ कॉल के लिए कोई अच्छा तरीका है

286
00:18:29,000 --> 00:18:31,000
क्योंकि भी, उदाहरण के लिए, एक मैं 0 वापस आ जाएगी

287
00:18:31,000 --> 00:18:37,000
अगर यह एक पूर्णांक नहीं कर सकता है, तो, जो भी काम नहीं करता.

288
00:18:37,000 --> 00:18:42,000
फिर, अच्छा उपयोगकर्ता ठीक कह रही संदेश क्या हुआ.

289
00:18:42,000 --> 00:18:45,000
यहाँ तो फिर, हम भी मामले को संभाल जहां

290
00:18:45,000 --> 00:18:50,000
एक नियंत्रण डी यादृच्छिक चरित्र में उपयोगकर्ता प्रकार.

291
00:18:50,000 --> 00:18:54,000
>> और फिर Charlotte कैसे हम के लिए रिक्त स्थान को छोड़ प्रबंधन के बारे में एक प्रश्न के पहले था

292
00:18:54,000 --> 00:18:57,000
हमारे यहाँ स्ट्रिंग में.

293
00:18:57,000 --> 00:19:00,000
इस कि हम क्या माइस्पेस कार्यक्रम के साथ किया था के लिए इसी तरह की तरह था

294
00:19:00,000 --> 00:19:04,000
कि हम अनुभाग में किया था, और जिस तरह से इस काम

295
00:19:04,000 --> 00:19:08,000
यह है कि हमने देखा था कि हम पत्र की संख्या पर नज़र रखी.

296
00:19:08,000 --> 00:19:13,000
जैसा कि हम संदेश स्ट्रिंग पर चला गया है, के रूप में हम चरित्र द्वारा चरित्र पर चला गया,

297
00:19:13,000 --> 00:19:16,000
हम हमारे पाश के लिए भाग के रूप में सूचकांक पर नज़र रखी है, और फिर हम भी नज़र रखी

298
00:19:16,000 --> 00:19:21,000
अक्षरों की संख्या है, तो गैर - विशेष वर्ण, गैर अंक, गैर सफेद स्थान

299
00:19:21,000 --> 00:19:27,000
कि हम अलग चर में देखा था.

300
00:19:27,000 --> 00:19:33,000
और फिर इस समाधान कुंजी को संशोधित

301
00:19:33,000 --> 00:19:41,000
एक वास्तविक पूर्णांक कुंजी प्राप्त करने के लिए, और यह है कि मक्खी पर करता है,

302
00:19:41,000 --> 00:19:47,000
सही से पहले यह तो वास्तविक संदेश चरित्र एन्क्रिप्ट करने के लिए चला जाता है.

303
00:19:47,000 --> 00:19:50,000
वहाँ कुछ समाधान कि बिल्कुल भी महान थे

304
00:19:50,000 --> 00:19:58,000
कि कुंजी को संशोधित जब कुंजी वैधता के लिए परीक्षण होगा.

305
00:19:58,000 --> 00:20:01,000
सुनिश्चित करने के लिए इसके अलावा में है कि चरित्र और खोजशब्द

306
00:20:01,000 --> 00:20:05,000
अल्फाबेट यह भी है कि एक पूर्णांक में बदल गया

307
00:20:05,000 --> 00:20:13,000
0 से 25 रेंज में तो छोड़ करने के लिए है कि बाद में इस में पाश के लिए क्या कर रहे हैं.

308
00:20:13,000 --> 00:20:18,000
फिर, आप यहाँ देख यह वास्तव में सटीक एक ही कोड है

309
00:20:18,000 --> 00:20:22,000
कि हम इस बिंदु पर सीज़र में प्रयोग किया जाता है.

310
00:20:22,000 --> 00:20:25,000
आप सटीक एक ही बात कर रहे हैं तो, असली चाल पता लगाना है

311
00:20:25,000 --> 00:20:30,000
कैसे एक पूर्णांक में कीवर्ड की बारी है.

312
00:20:30,000 --> 00:20:35,000
>> एक बात है कि हम यहाँ किया है कि एक छोटे से घना है

313
00:20:35,000 --> 00:20:39,000
है हम इस वाक्यांश को दोहराया है, मुझे लगता है कि आप यह कह सकते हैं,

314
00:20:39,000 --> 00:20:45,000
लाइनों 58, 59, और 61 पर 3 अलग बार.

315
00:20:45,000 --> 00:20:52,000
किसी को समझा सकते हैं क्या वास्तव में इस वाक्यांश करता?

316
00:20:52,000 --> 00:20:55,000
यह एक चरित्र तक पहुँचने है, जैसे तुमने कहा था.

317
00:20:55,000 --> 00:20:59,000
हाँ, यह [अश्राव्य] कीवर्ड में एक चरित्र है,

318
00:20:59,000 --> 00:21:04,000
और इसलिए यह देखा पत्र की संख्या है क्योंकि आप ही के साथ आगे बढ़ रहे हैं

319
00:21:04,000 --> 00:21:06,000
कीवर्ड एक बार आप इस पत्र को देखा है,

320
00:21:06,000 --> 00:21:10,000
इतना है कि प्रभावी ढंग से रिक्त स्थान है और इस तरह से सामान छोड़ जा रहा है.

321
00:21:10,000 --> 00:21:12,000
हाँ, बिल्कुल.

322
00:21:12,000 --> 00:21:16,000
और फिर एक बार आप कीवर्ड रिक्त तुम सिर्फ आधुनिक देखा है तो तुम वापस चारों ओर कदम.

323
00:21:16,000 --> 00:21:18,000
बिल्कुल सही. यह एक सही व्याख्या है.

324
00:21:18,000 --> 00:21:23,000
केविन ने कहा है कि हम कीवर्ड में सूचकांक के लिए चाहते हैं.

325
00:21:23,000 --> 00:21:28,000
हम num_letters_seen चरित्र प्राप्त करना चाहते हैं, अगर तुम जाएगा,

326
00:21:28,000 --> 00:21:32,000
लेकिन अगर num_letters_seen कीवर्ड की लंबाई से अधिक है,

327
00:21:32,000 --> 00:21:37,000
जिस तरह से हम उचित सीमा में वापस पाने के लिए है कि हम माड आपरेटर के उपयोग

328
00:21:37,000 --> 00:21:40,000
को प्रभावी ढंग से आसपास लपेटो.

329
00:21:40,000 --> 00:21:43,000
उदाहरण के लिए, जैसे संक्षेप में, हमारे कीवर्ड बेकन है,

330
00:21:43,000 --> 00:21:46,000
और यह 5 अक्षर लंबा है.

331
00:21:46,000 --> 00:21:50,000
लेकिन हम इस बिंदु पर हमारे सादे पाठ में 6 पत्र देखा है

332
00:21:50,000 --> 00:21:52,000
और एन्क्रिप्टेड 6.

333
00:21:52,000 --> 00:21:57,000
हम अंत num_letters_seen तक पहुँचने होगा,

334
00:21:57,000 --> 00:22:00,000
जो 6 है, आधुनिक कीवर्ड की लंबाई, 5,

335
00:22:00,000 --> 00:22:04,000
और इसलिए हम 1 मिलता है, और हूँ तो क्या हम क्या करेंगे हम करेंगे

336
00:22:04,000 --> 00:22:14,000
उस बिंदु पर हमारे कीवर्ड का पहला वर्ण अंदर का उपयोग.

337
00:22:14,000 --> 00:22:21,000
>> सब ठीक है, Vigenère पर किसी भी सवाल

338
00:22:21,000 --> 00:22:26,000
इससे पहले कि हम पर स्थानांतरित?

339
00:22:26,000 --> 00:22:31,000
तुम लोग इस बारे में बहुत अच्छा लग रहा है?

340
00:22:31,000 --> 00:22:35,000
कूल, महान.

341
00:22:35,000 --> 00:22:38,000
मुझे यकीन है कि तुम लोगों को कोड को देखने का मौका मिल रहा है बनाना चाहते हैं

342
00:22:38,000 --> 00:22:48,000
है कि हमें लगता है कि अच्छा लग रहा है और इसे से सीखने का मौका है.

343
00:22:48,000 --> 00:22:53,000
यह करने के लिए पिछले हो सकता है हम कुछ समय के लिए रिक्त स्थान का उपयोग किया जाएगा जा रहा है,

344
00:22:53,000 --> 00:22:59,000
और संक्रमण के लिए हम जा रहे हैं अब, और मैं cs50.net/lectures करने के लिए जा रहा हूँ

345
00:22:59,000 --> 00:23:06,000
तो हम प्रश्नोत्तरी समीक्षा का एक छोटा सा कर सकते हैं.

346
00:23:06,000 --> 00:23:10,000
सबसे अच्छा तरीका मैं प्रश्नोत्तरी समीक्षा कर शुरू करने लगता है कि

347
00:23:10,000 --> 00:23:15,000
इस व्याख्यान पृष्ठ पर आ रहा है, cs50.net/lectures,

348
00:23:15,000 --> 00:23:20,000
और प्रत्येक सप्ताह के शीर्षकों के नीचे, यदि ऐसा है तो मैं 0 वीक में यहाँ देखो,

349
00:23:20,000 --> 00:23:27,000
मैं देख रहा हूँ कि हम विषयों की एक सूची कि हम 0 वीक में शामिल किया है.

350
00:23:27,000 --> 00:23:31,000
>> यदि इन विषयों में से किसी भी आप के लिए अपरिचित लगते हैं

351
00:23:31,000 --> 00:23:34,000
आप निश्चित रूप से वापस जाने के लिए और व्याख्यान नोटों और संभवतः परिमार्जन चाहता हूँ

352
00:23:34,000 --> 00:23:39,000
भी व्याख्यान के माध्यम से हवा में घूमना, उन्हें फिर से देखने के लिए यदि आप चाहते हैं

353
00:23:39,000 --> 00:23:44,000
पर उन विषयों में से प्रत्येक के साथ क्या हो रहा है के लिए एक महसूस पाने के लिए.

354
00:23:44,000 --> 00:23:49,000
मैं भी शांत हम संसाधनों मिल गया है की इस वर्ष एक कहेंगे

355
00:23:49,000 --> 00:23:55,000
इन शॉर्ट्स है कि हम बनाया है, और अगर आप 0 वीक में देखो,

356
00:23:55,000 --> 00:24:00,000
हम सभी विषयों को कवर नहीं है, लेकिन हम उनमें से काफी कुछ मिल गया है,

357
00:24:00,000 --> 00:24:03,000
पेचीदा मामला लोगों में से कुछ है, तो इन शॉर्ट्स फिर से देख

358
00:24:03,000 --> 00:24:08,000
तुम्हें पाने के लिए गति के लिए एक अच्छा तरीका है.

359
00:24:08,000 --> 00:24:15,000
विशेष रूप से, मैं 3 के लिए एक प्लग में डाल तल पर, के बाद से मैं उन किया जा रहा हूँ.

360
00:24:15,000 --> 00:24:20,000
लेकिन अगर आप द्विआधारी के साथ संघर्ष कर रहे हैं, बिट्स, हेक्स, सामान की तरह,

361
00:24:20,000 --> 00:24:22,000
बाइनरी एक महान शुरू करने के लिए जगह है.

362
00:24:22,000 --> 00:24:25,000
ASCII एक और एक है कि करने के लिए भी देखने के लिए अच्छा है.

363
00:24:25,000 --> 00:24:31,000
तुम भी मुझे 1.5x गति में देख सकते हैं अगर मैं भी आप के लिए धीमी गति से जा रहा हूँ.

364
00:24:31,000 --> 00:24:35,000
यह समीक्षा के बाद से, कि ऐसा करने के लिए स्वतंत्र महसूस हो रहा है.

365
00:24:35,000 --> 00:24:40,000
>> सिर्फ सच में जल्दी शुरू करने के लिए, हम इन प्रश्नोत्तरी समस्याओं के एक जोड़े के माध्यम से जाने के लिए जा रहे हैं

366
00:24:40,000 --> 00:24:44,000
बस जल्दी से इन के माध्यम से मंथन करने के लिए.

367
00:24:44,000 --> 00:24:50,000
उदाहरण के लिए, 16 समस्या पर लग रही है कि मैं सही यहाँ बोर्ड पर मिल गया है.

368
00:24:50,000 --> 00:24:54,000
हम बाइनरी में इस निम्नलिखित गणना मिल गया है,

369
00:24:54,000 --> 00:24:56,000
और हम किसी भी काम को दिखाने के लिए करना चाहते हैं.

370
00:24:56,000 --> 00:24:59,000
ठीक है, मैं इस एक शॉट देने के लिए जा रहा हूँ.

371
00:24:59,000 --> 00:25:01,000
तुम लोगों के साथ कागज के साथ पालन करना चाहिए,

372
00:25:01,000 --> 00:25:04,000
और हम इस सच में जल्दी करूँगा.

373
00:25:04,000 --> 00:25:06,000
हम द्विआधारी में निम्न परिकलन करना चाहते हैं.

374
00:25:06,000 --> 00:25:16,000
मैं 00110010 मिल गया है.

375
00:25:16,000 --> 00:25:27,000
और मैं यह 00110010 जोड़ने के लिए जा रहा हूँ.

376
00:25:27,000 --> 00:25:30,000
गणित के साथ घर पर पीछा कर प्रतिभाशाले

377
00:25:30,000 --> 00:25:35,000
यह प्रभावी रूप से 2 से गुणा है.

378
00:25:35,000 --> 00:25:37,000
शुरु करते हैं.

379
00:25:37,000 --> 00:25:39,000
हम एक ही इसके अलावा एल्गोरिथ्म है कि हम क्या कर का पालन करने के लिए जा रहे हैं

380
00:25:39,000 --> 00:25:43,000
जब हम दशमलव संख्या एक साथ जोड़ें.

381
00:25:43,000 --> 00:25:46,000
वास्तव में यहाँ अंतर केवल इतना है कि हम वापस आसपास पाश

382
00:25:46,000 --> 00:25:51,000
एक बार हम 1 + 1 के बजाय एक बार हम 10 से मिलता है.

383
00:25:51,000 --> 00:25:53,000
>> अगर हम सही से शुरू करते हैं, बहुत जल्दी, क्या पहले अंक है?

384
00:25:53,000 --> 00:25:55,000
[छात्र] 0 >> [नैट एच.] 0.

385
00:25:55,000 --> 00:25:58,000
बढ़िया है, दूसरा अंक?

386
00:25:58,000 --> 00:26:00,000
1 [] छात्र.

387
00:26:00,000 --> 00:26:02,000
[नैट एच.] यह एक 1 है? 1 + 1 है?

388
00:26:02,000 --> 00:26:04,000
10 [] छात्र.

389
00:26:04,000 --> 00:26:08,000
[नैट एच.] वास्तव में, तो क्या अंक है कि मैं एक साथ 2 जोडी लोगों के नीचे सही लिखने के?

390
00:26:08,000 --> 00:26:11,000
छात्र [1], 0, या 0 और फिर 1 ले.

391
00:26:11,000 --> 00:26:15,000
[नैट एच.] 0 और 1 का एक टुकड़ा ले, बिल्कुल.

392
00:26:15,000 --> 00:26:18,000
अगला एक अप तुलसी, आप कर रहे हैं.

393
00:26:18,000 --> 00:26:20,000
3 क्या है? >> [तुलसी] 1.

394
00:26:20,000 --> 00:26:23,000
[नैट एच. 1], एकदम सही है. केविन?

395
00:26:23,000 --> 00:26:27,000
[केविन 0] >> [नैट एच.] 0, Charlotte?

396
00:26:27,000 --> 00:26:30,000
[Charlotte 0] >> [नैट एच.] हाँ, और मैं क्या करूँ?

397
00:26:30,000 --> 00:26:32,000
[छात्र] 1.

398
00:26:32,000 --> 00:26:34,000
[नैट एच.] और मैं क्या करूँ? और फिर मैं 1 ले.

399
00:26:34,000 --> 00:26:36,000
बिल्कुल सही, Sahb >> [Sahb] अब आप 1 है.

400
00:26:36,000 --> 00:26:40,000
[नैट एच.] और मैं यहाँ कुछ भी करते हैं?

401
00:26:40,000 --> 00:26:43,000
[Sahb] तो अगले एक के लिए आप 1 है क्योंकि आप 1 से अधिक किया जाता है.

402
00:26:43,000 --> 00:26:49,000
[नैट एच.] महान, तो यहाँ हम इसे खत्म कर सकते हैं.

403
00:26:49,000 --> 00:26:51,000
कूल.

404
00:26:51,000 --> 00:26:54,000
[छात्र] 0 0 + = 0 करता है?

405
00:26:54,000 --> 00:26:56,000
0 + 0 = 0.

406
00:26:56,000 --> 00:27:01,000
1 + 1, जैसे तुमने कहा था, 10, या 1, 0, बल्कि.

407
00:27:01,000 --> 00:27:07,000
10 एक मिथ्या नाम है, क्योंकि मेरे लिए 10 10 संख्या का मतलब है,

408
00:27:07,000 --> 00:27:12,000
और यह कि हम इसे कैसे का प्रतिनिधित्व कर रहे हैं, जब हम यह लिख रहे हैं चतुरायी की बोली है.

409
00:27:12,000 --> 00:27:20,000
हम 0 1, 2 नंबर का प्रतिनिधित्व करते हैं, और संख्या 10 से थोड़ा अलग है.

410
00:27:20,000 --> 00:27:23,000
>> बाइनरी के बारे में अच्छी तरह क्या है यह है कि वहाँ सच है कि कई नहीं कर रहे हैं

411
00:27:23,000 --> 00:27:25,000
मामलों में आप जानने की जरूरत है.

412
00:27:25,000 --> 00:27:30,000
0 + 0 = 0, 1 + 1 = 0 है,

413
00:27:30,000 --> 00:27:34,000
1 + 1 0 है, और फिर 1 का एक टुकड़ा ले,

414
00:27:34,000 --> 00:27:37,000
और फिर तुम यहाँ सही से तीसरे स्तंभ पर देख सकते हैं

415
00:27:37,000 --> 00:27:40,000
हम इस 1, 1, और 1 था.

416
00:27:40,000 --> 00:27:43,000
और 1 1 + 1 + 1 एक है,

417
00:27:43,000 --> 00:27:45,000
और आप एक और 1 ले.

418
00:27:45,000 --> 00:27:48,000
जब आप बाइनरी अलावा कर रहे हैं, बहुत आसान है.

419
00:27:48,000 --> 00:27:51,000
मैं एक दो इनमें से अधिक करने के लिए विवेक अपने आप को जांच होगी

420
00:27:51,000 --> 00:27:54,000
इससे पहले कि आप क्योंकि यह जाना

421
00:27:54,000 --> 00:28:00,000
शायद कुछ है कि हम प्रश्नोत्तरी पर देखेंगे.

422
00:28:00,000 --> 00:28:03,000
अब यह अगले एक के रूप में अच्छी तरह से करते हैं.

423
00:28:03,000 --> 00:28:06,000
17 समस्या है.

424
00:28:06,000 --> 00:28:12,000
हम दशमलव के लिए निम्न द्विआधारी संख्या में परिवर्तित करने के लिए जा रहे हैं.

425
00:28:12,000 --> 00:28:28,000
मैं 10100111001 मिल गया है.

426
00:28:28,000 --> 00:28:33,000
बाइनरी वीडियो कि मैंने किया याद

427
00:28:33,000 --> 00:28:36,000
मैं उदाहरण के एक जोड़े के माध्यम से चला गया, और मैं कैसे पता चला है

428
00:28:36,000 --> 00:28:41,000
सब कुछ काम करता है जब आप इसे दशमलव में कर रहे हैं.

429
00:28:41,000 --> 00:28:45,000
जब आप दशमलव प्रतिनिधित्व में काम कर रहे हैं मुझे लगता है कि हम कर रहे हैं

430
00:28:45,000 --> 00:28:48,000
हमारे जीवन में इस बिंदु पर तो यह में धाराप्रवाह कि

431
00:28:48,000 --> 00:28:53,000
यह बहुत आसान है कि यह कैसे काम करता है वास्तव में यांत्रिकी हाशिये या पंक्तियों के बीच लिखा हुआ मूल पाठ का अर्थ या व्याख्या.

432
00:28:53,000 --> 00:28:59,000
>> लेकिन एक त्वरित पुनर्कथन करने के लिए, अगर मैं 137 नंबर है

433
00:28:59,000 --> 00:29:06,000
यह वास्तव में फिर से, इस दशमलव में और प्रतिनिधित्व का मतलब है -

434
00:29:06,000 --> 00:29:19,000
दशमलव में 137 नंबर का मतलब है कि मैं 1 x 100 10 + 3 x 7 + 1 x.

435
00:29:19,000 --> 00:29:22,000
यह सब स्क्रीन पर रह रही है.

436
00:29:22,000 --> 00:29:29,000
और फिर अगर आप इन नंबरों पर सही यहाँ देखो,

437
00:29:29,000 --> 00:29:34,000
10, 100, और 1, आप देखते हैं कि वे वास्तव में कर रहे हैं 10 के सभी अधिकार.

438
00:29:34,000 --> 00:29:43,000
मैं शून्य ² 10, 10 ¹, और 10 है.

439
00:29:43,000 --> 00:29:48,000
हम बाइनरी में बात की एक समान तरह है,

440
00:29:48,000 --> 00:29:55,000
सिवाय इसके कि हमारे आधार के रूप में हम यह कहते हैं, 10 के बजाय 2 है.

441
00:29:55,000 --> 00:29:58,000
ये 10s कि मैं नीचे तल पर यहाँ लिखा है,

442
00:29:58,000 --> 00:30:02,000
इस ² 10, 10 ¹, 10 शून्य 10, हमारे आधार है,

443
00:30:02,000 --> 00:30:08,000
और प्रतिपादक, 0, 1, या 2,

444
00:30:08,000 --> 00:30:14,000
कि हम लिखने संख्या में अंकों की स्थिति से गर्भित है.

445
00:30:14,000 --> 00:30:21,000
1, अगर हम इसे देखो, यह 1 2 की स्थिति में है.

446
00:30:21,000 --> 00:30:27,000
3 1 की स्थिति में है, और 7 0 की स्थिति में है.

447
00:30:27,000 --> 00:30:35,000
यही कारण है कि कैसे हम हमारे अड्डों के लिए विभिन्न exponents नीचे मिलता है.

448
00:30:35,000 --> 00:30:40,000
>> इस we'll वास्तव में सभी के बाद, आप जानते हो क्या?

449
00:30:40,000 --> 00:30:43,000
हम करते हैं जहाँ मेरे बटन किए हुए कार्य को भ्रष्ट कर देना जाऊँगा?

450
00:30:43,000 --> 00:30:45,000
यह हो जाता है.

451
00:30:45,000 --> 00:30:47,000
मैं प्यार इस बात किए हुए कार्य को भ्रष्ट कर देना.

452
00:30:47,000 --> 00:30:51,000
इस के बाद मैं कम से कम मेरे लिए लगता है

453
00:30:51,000 --> 00:30:54,000
एक द्विआधारी संख्या परिवर्तित शुरू के लिए सबसे आसान तरीका

454
00:30:54,000 --> 00:30:57,000
या एक हेक्साडेसिमल संख्या जहां आधार 16 है

455
00:30:57,000 --> 00:31:02,000
और 2 10 या नहीं आगे जाने के लिए और बाहर लिखने

456
00:31:02,000 --> 00:31:09,000
कुर्सियां ​​और exponents मेरे शीर्ष पर बाइनरी संख्या में संख्या में से सभी के लिए.

457
00:31:09,000 --> 00:31:14,000
अगर हम बाएं से दाएं फिर से शुरू,

458
00:31:14,000 --> 00:31:17,000
जो counterintuitive की तरह है,

459
00:31:17,000 --> 00:31:23,000
मैं वापस काला करने के लिए यहाँ बदल देंगे, हम 0 की स्थिति के लिए 2 है,

460
00:31:23,000 --> 00:31:27,000
और फिर हम 2 है ¹, 2 ²,

461
00:31:27,000 --> 00:31:33,000
और 3, 2 से 4 2, 5, 6 के लिए, तो 2

462
00:31:33,000 --> 00:31:39,000
7, 8, 9, और 10.

463
00:31:39,000 --> 00:31:41,000
इन नंबरों को मैं बाहर लिखा है exponents हैं.

464
00:31:41,000 --> 00:31:48,000
मैं केवल कुर्सियां ​​यहाँ अंतरिक्ष के लिए सिर्फ 1 3 में लिखा है.

465
00:31:48,000 --> 00:31:50,000
>> इस बिंदु पर मैं आगे जाने के लिए जा रहा हूँ और मैं वास्तव में मिटा के लिए जा रहा हूँ

466
00:31:50,000 --> 00:31:53,000
सामान है कि हम दशमलव में किया था, अगर वह ठीक है.

467
00:31:53,000 --> 00:31:57,000
तुम सब है कि मिल गया है.

468
00:31:57,000 --> 00:32:05,000
तुम में से जो ऑनलाइन देख मुझे यकीन है कि यदि आप चाहें तो मुझे उल्टा करने में सक्षम हो जाएगा.

469
00:32:05,000 --> 00:32:07,000
कलम करने के लिए वापस स्विचन.

470
00:32:07,000 --> 00:32:12,000
अब, क्या हम करते हैं, अगर तुम लोगों को पूरी तरह से 2 की अपनी शक्तियों पर गति नहीं कर रहे हैं,

471
00:32:12,000 --> 00:32:15,000
कि पूरी तरह से शांत है.

472
00:32:15,000 --> 00:32:18,000
ऐसा होता है. मैं समझ सकता हूँ.

473
00:32:18,000 --> 00:32:23,000
मैं एक बार में एक नौकरी के लिए इंटरव्यू था जहां मुझे बताया गया था मैं 2 के सभी शक्तियों को पता होना चाहिए

474
00:32:23,000 --> 00:32:26,000
के माध्यम से ऊपर 2 30.

475
00:32:26,000 --> 00:32:29,000
यह एक नौकरी मैं मिला नहीं था.

476
00:32:29,000 --> 00:32:32,000
वैसे भी, आप लोग आगे जाना है और गणित यहाँ करना कर सकते हैं,

477
00:32:32,000 --> 00:32:35,000
लेकिन द्विआधारी साथ यह सच में समझ में नहीं पड़ता है,

478
00:32:35,000 --> 00:32:38,000
और न ही यह दशमलव या षोडश आधारी साथ मतलब या तो बना,

479
00:32:38,000 --> 00:32:43,000
बाहर जहाँ आप शून्य है गणित है.

480
00:32:43,000 --> 00:32:49,000
आप देख सकते हैं मैं 0 यहाँ है, यहाँ एक 0, 0 यहाँ, 0 यहाँ, 0 यहाँ, 0 यहाँ.

481
00:32:49,000 --> 00:32:52,000
ऐसा क्यों कर वास्तविक गणित ऐसा नहीं हो सकता है भावना

482
00:32:52,000 --> 00:32:56,000
उस स्थिति के लिए 2 की उचित बिजली की गणना करने के लिए?

483
00:32:56,000 --> 00:32:59,000
वास्तव में, तरह Charlotte कहा, यह 0 हो जाएगा.

484
00:32:59,000 --> 00:33:05,000
के रूप में अच्छी तरह से अपने आप को समय बचाने के लिए हो सकता है अगर 2 की शक्तियों की गणना के अपने मजबूत सूट नहीं है.

485
00:33:05,000 --> 00:33:10,000
इस मामले में हम केवल 2 के लिए यह 0 जो की गणना करने की जरूरत है?

486
00:33:10,000 --> 00:33:12,000
1 [] छात्र.

487
00:33:12,000 --> 00:33:14,000
[नैट एच.] 1, 3 से 2 जो है?

488
00:33:14,000 --> 00:33:16,000
[छात्र] 8 >> [नैट एच.] 8.

489
00:33:16,000 --> 00:33:18,000
2 से 4?

490
00:33:18,000 --> 00:33:21,000
2 [] छात्र. मैं माफी चाहता हूँ, 1.

491
00:33:21,000 --> 00:33:26,000
[नैट एच. 16] 2 +४ करने के लिए ठीक है.

492
00:33:26,000 --> 00:33:28,000
2 5, केविन 32? >>

493
00:33:28,000 --> 00:33:32,000
[नैट एच.] 32, 8 से 2?

494
00:33:32,000 --> 00:33:38,000
[छात्र] 32 x 8, 256.

495
00:33:38,000 --> 00:33:41,000
[नैट एच.] बिल्कुल सही.

496
00:33:41,000 --> 00:33:43,000
और 2 10?

497
00:33:43,000 --> 00:33:45,000
[छात्र] 1024.

498
00:33:45,000 --> 00:33:49,000
[नैट एच.] हाँ, 1024.

499
00:33:49,000 --> 00:33:57,000
>> एक बार जब हम इन नंबरों हम उन सब को योग करने के लिए कर सकते हैं मिल गया है.

500
00:33:57,000 --> 00:34:01,000
और यह है जहाँ यह वास्तव में महत्वपूर्ण है चीजों की एक जोड़ी.

501
00:34:01,000 --> 00:34:07,000
एक धीमी गति से जाना जाता है और अपने काम की जांच.

502
00:34:07,000 --> 00:34:10,000
आपको लगता है कि वहाँ एक 1 इस संख्या के अंत में बता सकते हैं,

503
00:34:10,000 --> 00:34:15,000
तो मैं निश्चित रूप से मेरे परिणाम के रूप में एक विषम संख्या मिलना चाहिए,

504
00:34:15,000 --> 00:34:18,000
क्योंकि सभी अन्य लोगों के लिए भी हो सकता है संख्या जा रहे हैं

505
00:34:18,000 --> 00:34:21,000
यह देखते हुए कि यह एक बाइनरी संख्या है.

506
00:34:21,000 --> 00:34:24,000
अन्य बात करना है अगर आप परीक्षण पर इस बिंदु को मिलता

507
00:34:24,000 --> 00:34:27,000
और आप इसे लिखा है इस दूर

508
00:34:27,000 --> 00:34:30,000
और आप समय से बाहर चल रहे हैं

509
00:34:30,000 --> 00:34:33,000
अंकों की संख्या में लग रही है कि इस समस्या के लायक है.

510
00:34:33,000 --> 00:34:40,000
यह समस्या है, जल्दी के रूप में आप देखने के लिए अगर मैं अपने लैपटॉप के लिए वास्तव में फ्लिप कर सकते हैं

511
00:34:40,000 --> 00:34:44,000
इस समस्या को 2 अंक के लायक है, तो यह की तरह नहीं है

512
00:34:44,000 --> 00:34:47,000
आप के माध्यम से चल रहा होना चाहिए अगर आप वास्तव में समय के लिए दबा रहे हैं.

513
00:34:47,000 --> 00:34:52,000
लेकिन हम वापस iPad करने के लिए स्विच, और हम इसे माध्यम से बहुत जल्दी जाना होगा.

514
00:34:52,000 --> 00:34:54,000
>> मैं छोटे संख्या 1 कर की तरह

515
00:34:54,000 --> 00:34:56,000
क्योंकि मुझे लगता है कि आसान लगता है.

516
00:34:56,000 --> 00:35:00,000
मैं 32 और 8 की तरह है क्योंकि वे एक साथ बहुत आसानी से जाना, और हम 50 से मिलता है.

517
00:35:00,000 --> 00:35:03,000
16 और एक 17 हो जाता है.

518
00:35:03,000 --> 00:35:05,000
वहाँ हम 57 मिलता है,

519
00:35:05,000 --> 00:35:14,000
और फिर हम इस के बाकी है, तो हम 57 कर सकते हैं कर सकते हैं, 156.

520
00:35:14,000 --> 00:35:16,000
आओ.

521
00:35:16,000 --> 00:35:19,000
यार, ठीक है, चलो देखते हैं.

522
00:35:19,000 --> 00:35:27,000
हम 57, 256, और 1024 था.

523
00:35:27,000 --> 00:35:31,000
इस बिंदु पर, मैं नहीं बल्कि बस के माध्यम से जाना चाहते हैं.

524
00:35:31,000 --> 00:35:35,000
मैं कोई सुराग नहीं है. मैं स्पष्ट रूप से इस पर पढ़ने की जरूरत है.

525
00:35:35,000 --> 00:35:40,000
7, 6, 4, आप 17 मिलता है.

526
00:35:40,000 --> 00:35:42,000
1, 5, 5, 2, 13.

527
00:35:42,000 --> 00:35:45,000
फिर हम 3 हो, और फिर हम 1 मिल.

528
00:35:45,000 --> 00:35:52,000
1337.

529
00:35:52,000 --> 00:35:55,000
ईस्टर अंडे, कोई है?

530
00:35:55,000 --> 00:35:59,000
किसी को भी इस संख्या को पहचानते हैं?

531
00:35:59,000 --> 00:36:02,000
क्रिस संख्या पहचानता है. यह क्या करता है, क्रिस क्या मतलब है?

532
00:36:02,000 --> 00:36:04,000
[क्रिस] Leet.

533
00:36:04,000 --> 00:36:11,000
Leet, यदि ऐसा है तो आप इस पर देखो, यह leet की तरह लग रहा है.

534
00:36:11,000 --> 00:36:15,000
हैकर सामान. मध्यावधि या प्रश्नोत्तरी, बल्कि सामान के उस तरह के लिए बाहर देखो.

535
00:36:15,000 --> 00:36:19,000
यदि आप सामान की तरह देखते हैं और आप सोच रहे हैं "हं,"

536
00:36:19,000 --> 00:36:22,000
कि वास्तव में कुछ मतलब हो सकता है.

537
00:36:22,000 --> 00:36:24,000
मुझे नहीं मालूम. दाऊद ने उसके अंदर डाल पसंद करता है

538
00:36:24,000 --> 00:36:26,000
यह एक अच्छा तरीका है कि यह जाँच विवेक.

539
00:36:26,000 --> 00:36:30,000
ठीक तरह, मैं देख सकता हूँ कि क्या हो रहा है.

540
00:36:30,000 --> 00:36:34,000
>> यह 0/Week 1 सामान सप्ताह है.

541
00:36:34,000 --> 00:36:39,000
यदि हम अपने लैपटॉप के लिए अब वापस स्विच,

542
00:36:39,000 --> 00:36:46,000
बाहर ज़ूम, और अन्य चीजों के एक जोड़े.

543
00:36:46,000 --> 00:36:50,000
वहाँ ASCII है, जो हम समस्या के सेट के साथ किया गया है की एक बहुत कुछ कर रहे हैं.

544
00:36:50,000 --> 00:36:55,000
राजधानी ए की यह धारणा है कि वास्तव में क्या है?

545
00:36:55,000 --> 00:36:57,000
जानने दशमलव पूर्णांक है.

546
00:36:57,000 --> 00:37:00,000
65 है जो यह ASCII तालिका में मैप किया है,

547
00:37:00,000 --> 00:37:03,000
और इसलिए है कि कैसे कंप्यूटर यह लिखते हैं,

548
00:37:03,000 --> 00:37:06,000
और है कि कैसे हम वास्तव में लिखने के साथ किया गया है दूर हो रही है

549
00:37:06,000 --> 00:37:09,000
चरित्र राजधानी एक और चरित्र एक लोअरकेस

550
00:37:09,000 --> 00:37:14,000
इन समाधान और समस्या सेट है कि आप कर दिया गया है में से कुछ में.

551
00:37:14,000 --> 00:37:16,000
अन्य बातों के एक जोड़े.

552
00:37:16,000 --> 00:37:25,000
हम बयान, बूलियन अभिव्यक्ति, शर्तों, loops, चर और सूत्र मिल गया है.

553
00:37:25,000 --> 00:37:29,000
>> उन सभी के अधिकांश भाग के लिए समझ बनाने के लग रहे हो?

554
00:37:29,000 --> 00:37:35,000
इस शब्दावली का कुछ समय पर थोड़ा कायरता है.

555
00:37:35,000 --> 00:37:46,000
मैं सबसे अधिक भाग के कुछ है कि एक सेमीकोलन के साथ समाप्त होता है के लिए के रूप में एक बयान के बारे में सोचना अच्छा लगता है.

556
00:37:46,000 --> 00:37:51,000
एक्स के रूप में इस तरह के बयानों = 7, जो एक चर सेट,

557
00:37:51,000 --> 00:37:54,000
संभाव्यतः x 7 = कहा जाता है.

558
00:37:54,000 --> 00:38:01,000
मुमकिन x भी एक प्रकार है कि 7 नंबर स्टोर कर सकते हैं,

559
00:38:01,000 --> 00:38:05,000
तो यह एक int या संभवतः एक नाव या एक छोटी या एक चार है,

560
00:38:05,000 --> 00:38:07,000
ऐसा ही कुछ है.

561
00:38:07,000 --> 00:38:12,000
एक बूलियन अभिव्यक्ति इन डबल का उपयोग कर रहा है के बराबर होती है

562
00:38:12,000 --> 00:38:17,000
और धमाके के बराबर या बराबर होती है नहीं, कम से कम, की तुलना में अधिक से अधिक,

563
00:38:17,000 --> 00:38:22,000
कम से कम या बराबर, सामान के सभी उस तरह.

564
00:38:22,000 --> 00:38:28,000
स्थितियां तो अगर किसी और बयान कर रहे हैं.

565
00:38:28,000 --> 00:38:32,000
मुझे याद है कि आप एक अगर इसी बिना एक और नहीं हो सकता.

566
00:38:32,000 --> 00:38:37,000
इसी तरह, आप एक अगर इसी बिना अगर किसी और नहीं हो सकता है.

567
00:38:37,000 --> 00:38:40,000
Loops, loops के 3 प्रकार हम आप में खटखटानेवाला है याद

568
00:38:40,000 --> 00:38:43,000
वर्गों और समस्या सेट के अंतिम जोड़ी के लिए.

569
00:38:43,000 --> 00:38:46,000
का प्रयोग करते समय है जब तुम उपयोगकर्ता इनपुट हो रही है,

570
00:38:46,000 --> 00:38:51,000
का उपयोग करते हुए एक विशेष स्थिति तक loops सच है,

571
00:38:51,000 --> 00:38:56,000
और फिर loops के लिए उन का उपयोग अगर आप की जरूरत

572
00:38:56,000 --> 00:39:01,000
पाश का चलना है जो आप पर वर्तमान में कर रहे हैं पता है कि मैं इसके बारे में सोचना है.

573
00:39:01,000 --> 00:39:07,000
या यदि आप एक स्ट्रिंग मैं कुछ करना चाहते हैं में हर किरदार के लिए कर रहे हैं,

574
00:39:07,000 --> 00:39:15,000
मैं उस तत्व के लिए कुछ करना चाहते हैं एक सरणी में प्रत्येक तत्व के लिए.

575
00:39:15,000 --> 00:39:18,000
>> धागे और घटनाओं.

576
00:39:18,000 --> 00:39:21,000
हम ये तो स्पष्ट रूप से सी में शामिल नहीं किया है,

577
00:39:21,000 --> 00:39:23,000
लेकिन स्क्रैच से यह याद रखना.

578
00:39:23,000 --> 00:39:26,000
यह विभिन्न लिपियों होने की धारणा है.

579
00:39:26,000 --> 00:39:32,000
यह भी एक घटना प्रसारण की इस धारणा है.

580
00:39:32,000 --> 00:39:37,000
कुछ लोगों का प्रसारण शुरू में अपनी परियोजनाओं में उपयोग नहीं किया,

581
00:39:37,000 --> 00:39:40,000
जो पूरी तरह से शांत है,

582
00:39:40,000 --> 00:39:46,000
लेकिन इन इस बड़े मुद्दे से निपटने के 2 अलग तरीकों संगामिति बुलाया हैं,

583
00:39:46,000 --> 00:39:49,000
जो आप कार्यक्रमों पर अमल करने के लिए कैसे मिलता है

584
00:39:49,000 --> 00:39:54,000
या उचित रूप में एक ही समय पर निष्पादित?

585
00:39:54,000 --> 00:39:59,000
विभिन्न कार्य चल रहा है जबकि अन्य कार्यों में भी चल रहे हैं.

586
00:39:59,000 --> 00:40:01,000
यह कैसे अपने ऑपरेटिंग सिस्टम के लिए काम करने लगता है.

587
00:40:01,000 --> 00:40:04,000
यह भी क्यों हालांकि, उदाहरण के लिए,

588
00:40:04,000 --> 00:40:10,000
मैं अपने ब्राउज़र चल रहा था, मैं भी Spotify पर बारी कर सकते हैं और एक गाना खेलने.

589
00:40:10,000 --> 00:40:14,000
कि एक वैचारिक बात समझने की अधिक है.

590
00:40:14,000 --> 00:40:17,000
मैं कम धागे पर एक नज़र रखना होगा

591
00:40:17,000 --> 00:40:21,000
अगर आप इस बारे में अधिक जानकारी चाहते हैं.

592
00:40:21,000 --> 00:40:26,000
>> चलो देखते हैं, मेरा मानना ​​है कि वहाँ किया गया है हो सकता है

593
00:40:26,000 --> 00:40:31,000
इन में से एक में इस पर एक समस्या है.

594
00:40:31,000 --> 00:40:35,000
फिर, मुझे लगता है कि धागे और घटनाओं के लिए कुछ नहीं कर रहे हैं कि हम सी में कवर किया जाएगा

595
00:40:35,000 --> 00:40:41,000
बस, क्योंकि यह काफी स्क्रैच की तुलना में और अधिक कठिन है.

596
00:40:41,000 --> 00:40:44,000
आप इसके बारे में चिंता करने की ज़रूरत नहीं है, लेकिन निश्चित रूप से अवधारणाओं को समझने चाहिए,

597
00:40:44,000 --> 00:40:47,000
समझ में क्या हो रहा है.

598
00:40:47,000 --> 00:40:52,000
इससे पहले कि हम आगे बढ़ना है, सप्ताह 0 सामग्री पर किसी भी सवाल?

599
00:40:52,000 --> 00:40:55,000
हर कोई बहुत अच्छा लग रहा है?

600
00:40:55,000 --> 00:41:03,000
समझ चर और क्या एक चर है?

601
00:41:03,000 --> 00:41:08,000
>> पर चल रहा है. 1 सप्ताह.

602
00:41:08,000 --> 00:41:12,000
यहाँ चीजों की एक जोड़ी है कि विशेष रूप से नहीं कवर किया गया

603
00:41:12,000 --> 00:41:21,000
जरूरी प्रश्नोत्तरी समीक्षा में और भी अधिक वैचारिक बातें करने के बारे में सोच रहे हैं.

604
00:41:21,000 --> 00:41:30,000
पहले स्रोत कोड compilers, और ऑब्जेक्ट कोड क्या कर रहे हैं इस धारणा है.

605
00:41:30,000 --> 00:41:32,000
कोई है? तुलसी.

606
00:41:32,000 --> 00:41:37,000
ऑब्जेक्ट कोड मैं स्रोत कोड का मतलब है आप क्या बजना में डाल,

607
00:41:37,000 --> 00:41:42,000
और ऑब्जेक्ट कोड है बजना क्या इतना कहते हैं कि आपके कंप्यूटर कार्यक्रम पढ़ सकते हैं.

608
00:41:42,000 --> 00:41:44,000
बिल्कुल सही.

609
00:41:44,000 --> 00:41:47,000
स्रोत कोड सी कोड है कि आप वास्तव में टाइप है.

610
00:41:47,000 --> 00:41:50,000
ऑब्जेक्ट कोड है तुम क्या बजना से बाहर निकलना है.

611
00:41:50,000 --> 00:41:54,000
यह 0s और कि बाइनरी स्वरूप में 1s है.

612
00:41:54,000 --> 00:41:59,000
फिर क्या होता है जब आप वस्तु फ़ाइलों का एक गुच्छा है,

613
00:41:59,000 --> 00:42:04,000
का कहना है कि आप एक परियोजना या एक प्रोग्राम है कि कई स्रोत कोड फ़ाइलों का उपयोग करता है संकलन कर रहे हैं,

614
00:42:04,000 --> 00:42:09,000
जो सम्मेलन द्वारा ग फ़ाइल एक्सटेंशन दिया जाता है.

615
00:42:09,000 --> 00:42:13,000
यही कारण है कि हम caesar.c vigenère.c,.

616
00:42:13,000 --> 00:42:18,000
यदि आप जावा प्रोग्राम लिख रहे हैं आप उन्हें विस्तार देना जावा.

617
00:42:18,000 --> 00:42:24,000
अजगर कार्यक्रमों एक्सटेंशन py अक्सर.

618
00:42:24,000 --> 00:42:26,000
>> एक बार जब आप कई ग फ़ाइलें है, तो आप उन्हें संकलन.

619
00:42:26,000 --> 00:42:29,000
बजना बाहर यह सब बाइनरी कबाड़ spits.

620
00:42:29,000 --> 00:42:33,000
क्योंकि तब आप केवल 1 कार्यक्रम चाहते हैं

621
00:42:33,000 --> 00:42:37,000
आप linker लिंक इन वस्तु के सभी एक साथ फ़ाइलें

622
00:42:37,000 --> 00:42:40,000
1 निष्पादन योग्य फ़ाइल में.

623
00:42:40,000 --> 00:42:45,000
यह भी है क्या जब आप CS50 पुस्तकालय का उपयोग होता है, उदाहरण के लिए.

624
00:42:45,000 --> 00:42:50,000
CS50 पुस्तकालय है कि दोनों घंटे हेडर फाइल है.

625
00:42:50,000 --> 00:42:53,000
है कि आप पढ़, # includecs50.h कि.

626
00:42:53,000 --> 00:42:58,000
और फिर यह भी एक विशेष बाइनरी पुस्तकालय फ़ाइल

627
00:42:58,000 --> 00:43:02,000
कि संकलित किया गया है कि 0s और 1s है,

628
00:43:02,000 --> 00:43:08,000
और झंडा कि-l, यदि ऐसा है तो हम हमारे रिक्त स्थान के लिए वापस जाना है और हम बहुत जल्दी देखो

629
00:43:08,000 --> 00:43:11,000
यहाँ क्या हो रहा है जब हम हमारे बजना आदेश में देखो,

630
00:43:11,000 --> 00:43:15,000
हमें मिल गया है क्या है यह हमारे स्रोत कोड फ़ाइल यहीं है.

631
00:43:15,000 --> 00:43:18,000
संकलक झंडे का एक गुच्छा रहे हैं.

632
00:43:18,000 --> 00:43:22,000
और फिर बहुत अंत में, इन एल झंडे लिंक

633
00:43:22,000 --> 00:43:30,000
इन 2 पुस्तकालयों के लिए वास्तविक द्विपदीय फाइल CS50 पुस्तकालय और फिर गणित पुस्तकालय.

634
00:43:30,000 --> 00:43:35,000
>> 'फ़ाइलों उद्देश्य के प्रत्येक प्रकार को समझना

635
00:43:35,000 --> 00:43:38,000
संकलन प्रक्रिया में आप कुछ करने में सक्षम होना चाहता हूँ

636
00:43:38,000 --> 00:43:43,000
कम से कम एक उच्च स्तर की सिंहावलोकन दे.

637
00:43:43,000 --> 00:43:46,000
स्रोत कोड अंदर आता वस्तु कोड बाहर आता है.

638
00:43:46,000 --> 00:43:53,000
ऑब्जेक्ट कोड फ़ाइलों को एक साथ जोड़ने के लिए, और आप एक सुंदर, निष्पादन योग्य फ़ाइल मिलता है.

639
00:43:53,000 --> 00:43:55,000
कूल.

640
00:43:55,000 --> 00:43:58,000
यह भी है जहां आप कई बिंदुओं पर त्रुटियों को प्राप्त कर सकते हैं

641
00:43:58,000 --> 00:44:00,000
संकलन की प्रक्रिया में है.

642
00:44:00,000 --> 00:44:04,000
यह वह जगह है जहाँ, उदाहरण के लिए, अगर आप इस जोड़ने झंडा ले,

643
00:44:04,000 --> 00:44:10,000
CS50 झंडा, और आप यह रिक्त स्थान में छोड़ या जब आप अपने कोड चला रहे हैं,

644
00:44:10,000 --> 00:44:13,000
यह वह जगह है जहाँ आप जोड़ने चरण में एक त्रुटि मिल जाएगा,

645
00:44:13,000 --> 00:44:18,000
और linker कहते हैं, "अरे, तुम एक समारोह GetString बुलाया

646
00:44:18,000 --> 00:44:20,000
कि CS50 पुस्तकालय में है. "

647
00:44:20,000 --> 00:44:25,000
"तुम मुझे बताया कि यह CS50 पुस्तकालय में किया गया था, और मैं इसके लिए कोड नहीं मिल सकता है."

648
00:44:25,000 --> 00:44:28,000
यह वह जगह है जहाँ आप इसे में जोड़ने के लिए है, और है कि अलग

649
00:44:28,000 --> 00:44:33,000
एक संकलक त्रुटि से क्योंकि संकलक वाक्यविन्यास और सामान की तरह लग रही है.

650
00:44:33,000 --> 00:44:38,000
यह अच्छा है पता है कि क्या हो रहा है जब.

651
00:44:38,000 --> 00:44:42,000
>> अन्य चीजों के बारे में पता करने के लिए.

652
00:44:42,000 --> 00:44:49,000
मैं कहूँगा कि आप निश्चित रूप से typecasting पर कम जॉर्डन के द्वारा किया पर एक नज़र रखना चाहते हैं

653
00:44:49,000 --> 00:44:55,000
समझ ints हुड के नीचे क्या कर रहे हैं,

654
00:44:55,000 --> 00:44:58,000
घर का काम क्या हुड के तहत कर रहे हैं.

655
00:44:58,000 --> 00:45:02,000
, जब हम ASCII के बारे में बात करते हैं और हम वास्तव में ASCII तालिका में देखो

656
00:45:02,000 --> 00:45:07,000
है कि वह क्या कर रहा है हमें दे रहा है हुड देखो के तहत एक

657
00:45:07,000 --> 00:45:13,000
कैसे कंप्यूटर वास्तव में राजधानी का प्रतिनिधित्व करता है और अंक 7

658
00:45:13,000 --> 00:45:17,000
और एक अल्पविराम और एक प्रश्न चिह्न है.

659
00:45:17,000 --> 00:45:20,000
कंप्यूटर भी विशेष का प्रतिनिधित्व करने के तरीके

660
00:45:20,000 --> 00:45:23,000
एक पूर्णांक के रूप में नंबर 7.

661
00:45:23,000 --> 00:45:27,000
यह एक विशेष तरीका है एक चल बिन्दु संख्या के रूप में 7 संख्या का प्रतिनिधित्व करते हैं,

662
00:45:27,000 --> 00:45:29,000
और उन बहुत अलग हैं.

663
00:45:29,000 --> 00:45:32,000
Typecasting है आप कैसे बता कंप्यूटर "अरे, मैं आप कन्वर्ट करने के लिए करना चाहते हैं

664
00:45:32,000 --> 00:45:37,000
एक प्रतिनिधित्व से दूसरे प्रतिनिधित्व करने के लिए. "

665
00:45:37,000 --> 00:45:40,000
हम उस पर एक नज़र क्यों नहीं ले जाते.

666
00:45:40,000 --> 00:45:44,000
>> मैं भी पुस्तकालयों पर कम और compilers पर कम पर एक नज़र रखना होगा.

667
00:45:44,000 --> 00:45:47,000
संकलन की प्रक्रिया के बारे में वे बात करते हैं,

668
00:45:47,000 --> 00:45:53,000
एक पुस्तकालय क्या है, और इनमें से कुछ सवाल है कि आप पूछा मिल सकता है पर चलते हैं.

669
00:45:53,000 --> 00:45:55,000
1 सप्ताह सामग्री पर कोई प्रश्न?

670
00:45:55,000 --> 00:46:03,000
यहाँ किसी भी विषय है कि आप को कवर करना चाहते हैं कठिन लग?

671
00:46:03,000 --> 00:46:07,000
मैं पहले इन विषयों के अधिकांश के माध्यम से उड़ाने की कोशिश कर रहा हूँ ताकि हम प्राप्त कर सकते हैं

672
00:46:07,000 --> 00:46:13,000
संकेत और recursion का एक छोटा सा.

673
00:46:13,000 --> 00:46:15,000
विचार?

674
00:46:15,000 --> 00:46:19,000
को कवर करने के लिए कुछ है?

675
00:46:19,000 --> 00:46:21,000
शायद कुछ चॉकलेट के लिए समय है?

676
00:46:21,000 --> 00:46:23,000
तुम लोगों के माध्यम से यह काम कर रहे हैं.

677
00:46:23,000 --> 00:46:26,000
मैं अपनी कॉफी पर बरतें रखने के लिए जा रहा हूँ.

678
00:46:26,000 --> 00:46:31,000
2 सप्ताह.

679
00:46:31,000 --> 00:46:34,000
फोन अच्छा है, अच्छा फोन है.

680
00:46:34,000 --> 00:46:38,000
सप्ताह में 2 हम कार्यों के बारे में थोड़ा और अधिक बात की थी.

681
00:46:38,000 --> 00:46:43,000
>> पहले कुछ समस्या सेट में हम वास्तव में सब पर किसी भी कार्य नहीं लिखा था

682
00:46:43,000 --> 00:46:45,000
अन्य समारोह जो की तुलना में?

683
00:46:45,000 --> 00:46:47,000
[छात्र] मुख्य >> वास्तव में मुख्य.

684
00:46:47,000 --> 00:46:51,000
और इसलिए हम विभिन्न वेशभूषा कि मुख्य पहनता है देखा है.

685
00:46:51,000 --> 00:46:54,000
वहाँ एक में यह कोई तर्क नहीं लेता है,

686
00:46:54,000 --> 00:46:58,000
और हम सिर्फ कोष्ठकों के बीच शून्य कहते हैं,

687
00:46:58,000 --> 00:47:01,000
और फिर वहाँ अन्य एक है जहां हम कमांड लाइन तर्क ले जाना चाहते हो,

688
00:47:01,000 --> 00:47:08,000
और जैसा कि हमने देखा, वह है जहाँ तुम int argc और स्ट्रिंग argv सरणी

689
00:47:08,000 --> 00:47:13,000
या अब है कि हम वास्तव में स्ट्रिंग उजागर किया चार * है कि यह है

690
00:47:13,000 --> 00:47:20,000
हम यह चार * argv और फिर कोष्ठक के रूप में लेखन शुरू करने के लिए जा रहे हैं.

691
00:47:20,000 --> 00:47:22,000
समस्या 3 सेट में, आप लोग कार्यों का एक गुच्छा देखा,

692
00:47:22,000 --> 00:47:27,000
और आप कार्यों का एक गुच्छा लागू, आकर्षित, ऊपर देखो, हाथापाई.

693
00:47:27,000 --> 00:47:31,000
प्रोटोटाइप सब आप के लिए लिखा गया है.

694
00:47:31,000 --> 00:47:33,000
>> मैं क्या करने के कार्यों के साथ यहाँ के बारे में वास्तव में जल्दी से बात करना चाहता था

695
00:47:33,000 --> 00:47:38,000
यह है कि उन्हें 3 भागों हैं जब भी आप एक समारोह लिखने.

696
00:47:38,000 --> 00:47:43,000
आप करने के लिए समारोह का रिटर्न प्रकार निर्दिष्ट है.

697
00:47:43,000 --> 00:47:46,000
समारोह के लिए एक नाम निर्दिष्ट है, और फिर आप निर्दिष्ट

698
00:47:46,000 --> 00:47:51,000
तर्क सूची या पैरामीटर सूची.

699
00:47:51,000 --> 00:47:57,000
उदाहरण के लिए, अगर मैं एक समारोह लिखने के लिए पूर्णांकों का एक गुच्छा राशि

700
00:47:57,000 --> 00:48:03,000
और फिर मेरे लिए योग क्या मेरी वापसी प्रकार होगा वापस

701
00:48:03,000 --> 00:48:06,000
अगर मैं integers राशि और तब राशि लौटने के करना चाहते थे?

702
00:48:06,000 --> 00:48:12,000
तो समारोह के नाम.

703
00:48:12,000 --> 00:48:27,000
अगर मैं आगे जाने के लिए और हरे रंग में लिखने के लिए, इस भाग रिटर्न प्रकार है.

704
00:48:27,000 --> 00:48:34,000
इस भाग का नाम है.

705
00:48:34,000 --> 00:48:40,000
और फिर कोष्ठकों के बीच में

706
00:48:40,000 --> 00:48:46,000
है जहां मैं तर्क दे,

707
00:48:46,000 --> 00:48:56,000
अक्सर args, कभी कभी मानकों के लिए params बुलाया के रूप में संक्षिप्त.

708
00:48:56,000 --> 00:49:00,000
और यदि आप एक है, तो आप सिर्फ एक निर्दिष्ट.

709
00:49:00,000 --> 00:49:06,000
यदि आपके पास एकाधिक आप एक अल्पविराम के साथ प्रत्येक एक अलग.

710
00:49:06,000 --> 00:49:13,000
और प्रत्येक तर्क के लिए आप यह 2 बातें दे जो कर रहे हैं - केविन?

711
00:49:13,000 --> 00:49:18,000
[केविन] तुम और फिर नाम प्रकार देना है.

712
00:49:18,000 --> 00:49:21,000
और फिर, नाम और नाम का नाम है कि आप प्रयोग करने जा रहे हैं

713
00:49:21,000 --> 00:49:25,000
राशि समारोह के भीतर कि तर्क को देखें,

714
00:49:25,000 --> 00:49:27,000
समारोह है कि आप वर्तमान में लिख रहे हैं के भीतर.

715
00:49:27,000 --> 00:49:32,000
>> आप उदाहरण के लिए नहीं है, अगर मैं करने के लिए राशि के लिए जा रहा हूँ,

716
00:49:32,000 --> 00:49:41,000
, integers we'll की एक सरणी int सरणी करना,

717
00:49:41,000 --> 00:49:46,000
और मैं अपने आप को कुछ घुंघराले ब्रेसिज़ दे दूँगा

718
00:49:46,000 --> 00:49:51,000
फिर जब मैं योग समारोह के लिए एक सरणी के पास

719
00:49:51,000 --> 00:49:55,000
मैं यह तर्क सूची के पहले की स्थिति में गुजरती हैं.

720
00:49:55,000 --> 00:49:59,000
लेकिन सरणी कि मैं में पारित नाम आगमन नहीं है.

721
00:49:59,000 --> 00:50:07,000
आगमन कैसे मैं समारोह के शरीर के भीतर उस तर्क को देखें जा रहा है.

722
00:50:07,000 --> 00:50:10,000
दूसरी बात यह है कि हम खाते में लेने की जरूरत है,

723
00:50:10,000 --> 00:50:14,000
और इस कार्यों से थोड़ा अलग है, लेकिन मुझे लगता है कि यह एक महत्वपूर्ण बात है,

724
00:50:14,000 --> 00:50:20,000
यह है कि सी में जब मैं इस तरह एक समारोह लिख रहा हूँ

725
00:50:20,000 --> 00:50:29,000
मैं कैसे पता है कितने तत्वों इस सरणी में हैं?

726
00:50:29,000 --> 00:50:31,000
यह एक चाल सवाल के कुछ है.

727
00:50:31,000 --> 00:50:35,000
हम इस बारे में पिछले सप्ताह के अनुभाग में एक छोटा सा बात की थी.

728
00:50:35,000 --> 00:50:40,000
मैं सी में एक सरणी के अंदर तत्वों की संख्या कैसे जानते हो?

729
00:50:40,000 --> 00:50:44,000
वहाँ एक तरीका है?

730
00:50:44,000 --> 00:50:49,000
>> यह पता चला है कि वहाँ कोई रास्ता नहीं पता है.

731
00:50:49,000 --> 00:50:52,000
आप इसे पारित करने में अलग - अलग है.

732
00:50:52,000 --> 00:50:55,000
वहाँ एक चाल है जो आप कर सकते है

733
00:50:55,000 --> 00:51:00,000
अगर आप एक ही समारोह जो सरणी में घोषित किया गया है में हो,

734
00:51:00,000 --> 00:51:04,000
और आप एक ढेर सरणी के साथ काम कर रहे हैं.

735
00:51:04,000 --> 00:51:06,000
लेकिन यह केवल काम करता है अगर आप एक ही समारोह में कर रहे हैं.

736
00:51:06,000 --> 00:51:09,000
एक बार जब आप किसी अन्य समारोह के लिए एक सरणी के पास या यदि आप एक सरणी की घोषणा की है

737
00:51:09,000 --> 00:51:12,000
और आप ढेर पर है कि सरणी डाल, आप malloc का उपयोग किया है

738
00:51:12,000 --> 00:51:15,000
 और सामान की तरह है, तो सभी दांव बंद कर रहे हैं.

739
00:51:15,000 --> 00:51:18,000
तो फिर आप वास्तव में आसपास पारित किया है

740
00:51:18,000 --> 00:51:21,000
एक विशेष तर्क या अन्य पैरामीटर

741
00:51:21,000 --> 00:51:23,000
आपको बता कितना बड़ा सरणी है.

742
00:51:23,000 --> 00:51:28,000
इस मामले में, मैं एक अल्पविराम - मैं खेद है, यह स्क्रीन से जा रहा है का उपयोग करना चाहते चाहते हैं यहाँ

743
00:51:28,000 --> 00:51:32,000
और मैं एक और तर्क में पास था

744
00:51:32,000 --> 00:51:40,000
 और यह लंबाई के लिए int लेन कहते हैं.

745
00:51:40,000 --> 00:51:44,000
>> एक बात है कि प्रश्नोत्तरी पर आ सकता है

746
00:51:44,000 --> 00:51:49,000
आप पूछ लिखने के लिए या एक विशेष रूप से कुछ कहा जाता है समारोह को लागू करने.

747
00:51:49,000 --> 00:51:54,000
अगर हम आप प्रोटोटाइप देना नहीं है तो, यह पूरी यहाँ बात है,

748
00:51:54,000 --> 00:51:58,000
इस सारी गंदगी समारोह घोषणा या समारोह प्रोटोटाइप कहा जाता है,

749
00:51:58,000 --> 00:52:01,000
यह एक पहली चीजों की है कि आप नीचे कील चाहते अगर यह नहीं दिया है

750
00:52:01,000 --> 00:52:03,000
आप सही प्रश्नोत्तरी पर दूर करने के लिए.

751
00:52:03,000 --> 00:52:06,000
अन्य चाल मैंने सीखा है कि

752
00:52:06,000 --> 00:52:11,000
हम कहते हैं कि हम आप किसी समारोह में भाग लेने के लिए एक प्रोटोटाइप देने के लिए करते हैं, और हम कहते हैं, "अरे, आप इसे लिखने के लिए मिल गया है."

753
00:52:11,000 --> 00:52:16,000
घुंघराले ब्रेसिज़ है कि आप प्रश्नोत्तरी पर अंदर

754
00:52:16,000 --> 00:52:20,000
अगर आपको लगता है कि वहाँ एक वापसी प्रकार है और आप देखेंगे कि वापसी प्रकार

755
00:52:20,000 --> 00:52:25,000
शून्य है, जिसका अर्थ है कि समारोह कुछ भी वापस नहीं करता है के अलावा अन्य कुछ है,

756
00:52:25,000 --> 00:52:28,000
एक बात तो आप निश्चित रूप से करना चाहते है लिखने

757
00:52:28,000 --> 00:52:33,000
समारोह के अंत में वापसी के बयान के कुछ प्रकार है.

758
00:52:33,000 --> 00:52:40,000
वापसी, और इस मामले में हम एक रिक्त रखा है क्योंकि हम रिक्त को भरने में चाहते हूँ.

759
00:52:40,000 --> 00:52:44,000
लेकिन यह आप कैसे मैं इस समस्या के दृष्टिकोण के लिए जा रहा हूँ के बारे में सही तरीके से सोच हो जाता है?

760
00:52:44,000 --> 00:52:49,000
और यह आपको याद दिलाता है कि आप करने के लिए एक मूल्य वापसी के लिए जा रहे हैं

761
00:52:49,000 --> 00:52:51,000
समारोह के फोन करने के लिए.

762
00:52:51,000 --> 00:52:54,000
>> हाँ >> [छात्र] क्या शैली लागू होते हैं जब हम प्रश्नोत्तरी पर कोड लिख रहे हैं?

763
00:52:54,000 --> 00:52:58,000
खरोज और सामान की तरह के रूप में इस तरह के >> [छात्र] हाँ.

764
00:52:58,000 --> 00:53:00,000
नहीं, नहीं के रूप में ज्यादा.

765
00:53:00,000 --> 00:53:09,000
मुझे लगता है कि - इस का एक बहुत कुछ हम प्रश्नोत्तरी के दिन पर स्पष्ट है,

766
00:53:09,000 --> 00:53:15,000
लेकिन आम तौर पर के बारे में चिंता भी शामिल है और सामान की तरह, यह बाहर की तरह है.

767
00:53:15,000 --> 00:53:17,000
[छात्र] क्या आप अपने हस्तलिखित कोड टिप्पणी करने की आवश्यकता है?

768
00:53:17,000 --> 00:53:19,000
क्या आप अपने हस्तलिखित कोड टिप्पणी करने की आवश्यकता है?

769
00:53:19,000 --> 00:53:24,000
टिप्पणी हमेशा अच्छा है अगर आप आंशिक क्रेडिट के बारे में चिंतित हैं

770
00:53:24,000 --> 00:53:29,000
या आप ग्रेडर अपने इरादे बातचीत करना चाहते हैं.

771
00:53:29,000 --> 00:53:33,000
लेकिन मैं फिर से, प्रश्नोत्तरी पर ही और प्रश्नोत्तरी दिन स्पष्ट करना होगा,

772
00:53:33,000 --> 00:53:39,000
लेकिन मैं विश्वास नहीं है कि आप टिप्पणी लिखने के लिए, नहीं की आवश्यकता होगी.

773
00:53:39,000 --> 00:53:42,000
लेकिन आम तौर पर यह नहीं, निश्चित रूप से बात की तरह है, जहां

774
00:53:42,000 --> 00:53:45,000
आप अपने इरादे संवाद की तरह कर सकते हैं "अरे, यह वह जगह है जहाँ मैं इसके साथ जा रहा हूँ."

775
00:53:45,000 --> 00:53:49,000
और कभी कभी कि आंशिक क्रेडिट के साथ मदद कर सकते हैं.

776
00:53:49,000 --> 00:53:51,000
कूल.

777
00:53:51,000 --> 00:53:53,000
>> तुलसी.

778
00:53:53,000 --> 00:53:56,000
[तुलसी] का कहना है कि, int lang की घोषणा के बीच क्या अंतर है

779
00:53:56,000 --> 00:54:03,000
तर्क या समारोह के भीतर एक चर घोषित बनाम मानकों में?

780
00:54:03,000 --> 00:54:05,000
वाह, कॉफी सांस की नली से नीचे चला गया.

781
00:54:05,000 --> 00:54:07,000
[तुलसी] की तरह बातें हैं जो हम बहस में डाल करना चाहते हैं.

782
00:54:07,000 --> 00:54:09,000
हाँ, यह एक बड़ा सवाल है.

783
00:54:09,000 --> 00:54:11,000
आप कैसे चयन करते हैं क्या बातें आप बहस में डाल चाहते

784
00:54:11,000 --> 00:54:17,000
क्या बातें आप समारोह के अंदर करना चाहिए बनाम?

785
00:54:17,000 --> 00:54:24,000
इस मामले में हम तर्क के रूप में इन दोनों के शामिल

786
00:54:24,000 --> 00:54:29,000
क्योंकि वे कुछ है कि जो कोई भी योग समारोह का उपयोग करने के लिए जा रहा है कर रहे हैं

787
00:54:29,000 --> 00:54:32,000
लिए उन चीज़ों को निर्दिष्ट करने की जरूरत है.

788
00:54:32,000 --> 00:54:35,000
>> राशि समारोह, जैसे हम के बारे में बात की थी, यह जानने का कोई तरीका नहीं है

789
00:54:35,000 --> 00:54:40,000
कैसे बड़ा सरणी है यह अपने कॉलर या जो कोई भी हो जाता है योग समारोह का उपयोग कर रहा है.

790
00:54:40,000 --> 00:54:44,000
यह कितना बड़ा है कि सरणी है जानने का कोई तरीका नहीं है.

791
00:54:44,000 --> 00:54:48,000
कारण है कि हम इस लंबाई में एक तर्क के रूप में सही यहाँ गुजरती हैं

792
00:54:48,000 --> 00:54:51,000
कारण यह है कि कुछ है कि हम मूल रूप से समारोह के फोन करने वाले कह रहे हैं,

793
00:54:51,000 --> 00:54:55,000
जो भी राशि समारोह का उपयोग करने के लिए जा रहा है, "अरे, आप न केवल करने के लिए हमें एक सरणी देना है

794
00:54:55,000 --> 00:54:59,000
ints की, आप भी हमें बताओ कितना बड़ा सरणी है कि आप हमें दिया है. "

795
00:54:59,000 --> 00:55:03,000
[तुलसी] उन दोनों कमांड लाइन तर्क होगा?

796
00:55:03,000 --> 00:55:06,000
नहीं, इन वास्तविक बहस कर रहे हैं कि आप समारोह को पारित होगा.

797
00:55:06,000 --> 00:55:10,000
>> मुझे एक नया पृष्ठ यहाँ.

798
00:55:10,000 --> 00:55:13,000
[तुलसी] नाम की तरह पारित होगा

799
00:55:13,000 --> 00:55:24,000
[नैट एच.] यदि मैं int मुख्य (शून्य),

800
00:55:24,000 --> 00:55:27,000
और मैं मेरी वापसी 0 में डाल नीचे तल पर यहाँ जा रहा हूँ,

801
00:55:27,000 --> 00:55:31,000
और कहते हैं कि मैं योग समारोह कॉल करना चाहते हैं.

802
00:55:31,000 --> 00:55:42,000
मैं कहना चाहता हूँ int x = (राशि);

803
00:55:42,000 --> 00:55:46,000
योग समारोह का उपयोग करने के लिए मैं दोनों सरणी में पारित है कि मैं संपेक्षतः करना चाहते हैं

804
00:55:46,000 --> 00:55:51,000
और सरणी की लंबाई, तो यह कहाँ है

805
00:55:51,000 --> 00:55:54,000
मैं मान ints की एक सरणी था,

806
00:55:54,000 --> 00:56:12,000
कहते हैं कि मैं था int numbaz [] = 1, 2, 3,

807
00:56:12,000 --> 00:56:16,000
उपयोग की तरह काट दिया है कि वाक्यविन्यास सही,

808
00:56:16,000 --> 00:56:21,000
तो मुझे क्या करना होगा राशि में है कि मैं में पारित करना चाहते हैं

809
00:56:21,000 --> 00:56:27,000
दोनों numbaz और नंबर 3

810
00:56:27,000 --> 00:56:30,000
योग समारोह बता "ठीक है, यहाँ में सरणी मैं आप योग करने के लिए करना चाहते हैं."

811
00:56:30,000 --> 00:56:34,000
"यहाँ अपने आकार है."

812
00:56:34,000 --> 00:56:39,000
क्या इसका यह मतलब है? करता है कि आपके सवाल का जवाब?

813
00:56:39,000 --> 00:56:42,000
>> कई मायनों में यह समानांतर नहीं है कि हम क्या मुख्य के साथ कर रहे हैं

814
00:56:42,000 --> 00:56:44,000
जब हम कमांड लाइन तर्क है.

815
00:56:44,000 --> 00:56:47,000
सीज़र बीजलेख की तरह एक कार्यक्रम है, उदाहरण के लिए, की जरूरत है कि

816
00:56:47,000 --> 00:56:53,000
कमांड लाइन तर्क के लिए कुछ भी करने में सक्षम नहीं होगा.

817
00:56:53,000 --> 00:56:57,000
यह पता है कि कैसे एन्क्रिप्ट करने के लिए नहीं है, अगर आप यह क्या उपयोग करने के लिए महत्वपूर्ण बता नहीं किया जाएगा

818
00:56:57,000 --> 00:57:03,000
या यदि आप यह नहीं बता स्ट्रिंग क्या आप एन्क्रिप्ट चाहता था.

819
00:57:03,000 --> 00:57:08,000
इनपुट के लिए उत्साह, यह है, जहां हम 2 अलग तंत्र मिल गया है

820
00:57:08,000 --> 00:57:14,000
इनपुट में उपयोगकर्ता से उपयोगकर्ता से जानकारी लेने के लिए ले रही है, के लिए.

821
00:57:14,000 --> 00:57:19,000
के लिए समस्या 1 सेट हम इस GetInt, GetString, GetFloat जिस तरह से देखा

822
00:57:19,000 --> 00:57:26,000
इनपुट के लिए उत्साह की, और कहा कि मानक इनपुट स्ट्रीम का प्रयोग करके कहा जाता है.

823
00:57:26,000 --> 00:57:28,000
यह थोड़ा अलग है.

824
00:57:28,000 --> 00:57:31,000
यह कुछ ऐसा है कि आप एक समय में कर के रूप में करने का विरोध किया जा सकता है

825
00:57:31,000 --> 00:57:35,000
जब आप प्रोग्राम आह्वान जब आप कार्यक्रम चल रहा शुरू.

826
00:57:35,000 --> 00:57:41,000
कमांड लाइन तर्क सब जब आप कार्यक्रम चल रहा है शुरू करने के लिए निर्दिष्ट कर रहे हैं.

827
00:57:41,000 --> 00:57:47,000
हम उन लोगों में से दो का मिश्रण है.

828
00:57:47,000 --> 00:57:52,000
जब हम एक समारोह के लिए तर्क का उपयोग करते हैं, यह आदेश मुख्य लाइन तर्क बहुत पसंद है.

829
00:57:52,000 --> 00:57:56,000
यह है जब आप समारोह तुम्हें यह बताने की जरूरत आह्वान

830
00:57:56,000 --> 00:58:05,000
वास्तव में यह क्या जरूरत है, ताकि अपने कार्य करने के लिए.

831
00:58:05,000 --> 00:58:08,000
एक और अच्छी बात करने के लिए और देखो मैं तुम्हें बता दूँगा अपने खाली समय में इसे देखो,

832
00:58:08,000 --> 00:58:11,000
और उस में शामिल किया गया था गुंजाइश की इस धारणा प्रश्नोत्तरी

833
00:58:11,000 --> 00:58:15,000
और वैश्विक चर बनाम स्थानीय चर.

834
00:58:15,000 --> 00:58:18,000
क्या उस पर ध्यान देना.

835
00:58:18,000 --> 00:58:23,000
>> अब है कि हम इस अन्य सामान के लिए हो रही है,

836
00:58:23,000 --> 00:58:27,000
3 सप्ताह में हम खोज और छँटाई के बारे में बात करना शुरू कर दिया.

837
00:58:27,000 --> 00:58:32,000
खोज और छँटाई CS50 में, कम से कम,

838
00:58:32,000 --> 00:58:39,000
बहुत बहुत अधिक कंप्यूटर विज्ञान के सैद्धांतिक भागों में से कुछ के लिए एक परिचय है.

839
00:58:39,000 --> 00:58:42,000
खोज की समस्या, छँटाई की समस्या

840
00:58:42,000 --> 00:58:46,000
बड़ा, विहित समस्याएं हैं.

841
00:58:46,000 --> 00:58:52,000
आप पूर्णांकों की अरबों की एक सरणी में एक विशेष नंबर कैसे मिल रहा है?

842
00:58:52,000 --> 00:58:55,000
आप कैसे एक फोन की किताब के अंदर एक खास नाम

843
00:58:55,000 --> 00:58:59,000
कि अपने लैपटॉप पर संग्रहीत किया जाता है?

844
00:58:59,000 --> 00:59:04,000
और इसलिए हम asymptotic रन बार की इस धारणा का परिचय

845
00:59:04,000 --> 00:59:11,000
वास्तव में अंदाजा कितनी देर तक, कितना मुश्किल ये समस्या है,

846
00:59:11,000 --> 00:59:14,000
कितनी देर तक वे हल करने के लिए ले.

847
00:59:14,000 --> 00:59:20,000
मुझे विश्वास है, 2011 की प्रश्नोत्तरी में वहाँ एक समस्या यह है कि मुझे लगता है कि गुण है

848
00:59:20,000 --> 00:59:27,000
बहुत जल्दी कवर, जो इस एक, 12 समस्या है.

849
00:59:27,000 --> 00:59:32,000
हे नहीं, यह ओमेगा है.

850
00:59:32,000 --> 00:59:41,000
>> यहाँ हम तेजी से संभव चलाने के समय के बारे में बात कर रहे हैं

851
00:59:41,000 --> 00:59:46,000
एक विशेष एल्गोरिथ्म के लिए और फिर धीमी संभव चलाते समय.

852
00:59:46,000 --> 00:59:52,000
यह ओमेगा और हे वास्तव में कर रहे हैं बस शॉर्टकट.

853
00:59:52,000 --> 00:59:55,000
वे कह के लिए notational शॉर्टकट हो

854
00:59:55,000 --> 00:59:59,000
बेहतरीन मामले में कितनी तेजी से हमारे एल्गोरिथ्म चलाने,

855
00:59:59,000 --> 01:00:06,000
और कैसे सबसे खराब संभव मामले में धीमी गति से हमारे एल्गोरिथ्म चलेगा?

856
01:00:06,000 --> 01:00:10,000
इनमें से कुछ करते हैं, और ये भी कवर किया गया

857
01:00:10,000 --> 01:00:13,000
उपगामी संकेतन है, जो मैं अत्यधिक की सिफारिश पर संक्षेप में.

858
01:00:13,000 --> 01:00:17,000
जैक्सन के एक बहुत अच्छा काम किया.

859
01:00:17,000 --> 01:00:23,000
द्विआधारी खोज के साथ, हम एक एल्गोरिथ्म के रूप में किया जा रहा द्विआधारी खोज के बारे में बात करते हैं,

860
01:00:23,000 --> 01:00:28,000
और हम आम तौर पर अपने बड़े ओ के मामले में इसके बारे में बात करते हैं

861
01:00:28,000 --> 01:00:30,000
बड़ी हे क्या है?

862
01:00:30,000 --> 01:00:34,000
संभव द्विआधारी खोज की धीमी चलाते समय क्या है?

863
01:00:34,000 --> 01:00:36,000
[छात्र] एन ²?

864
01:00:36,000 --> 01:00:41,000
बंद, मुझे लगता है कि इसी तरह के हैं.

865
01:00:41,000 --> 01:00:43,000
यह एक बहुत है कि तेजी से है.

866
01:00:43,000 --> 01:00:45,000
छात्र [] द्विआधारी? >> हाँ, द्विआधारी खोज.

867
01:00:45,000 --> 01:00:47,000
[छात्र] यह लॉग एन.

868
01:00:47,000 --> 01:00:49,000
N प्रवेश करें, तो क्या लॉग एन क्या मतलब है?

869
01:00:49,000 --> 01:00:51,000
यह यह प्रत्येक चलना आधा.

870
01:00:51,000 --> 01:00:56,000
वास्तव में, तो धीमी संभव मामले में,

871
01:00:56,000 --> 01:01:00,000
कहते हैं कि अगर आप एक हल सरणी

872
01:01:00,000 --> 01:01:08,000
एक लाख integers और संख्या के लिए आप देख रहे

873
01:01:08,000 --> 01:01:14,000
या तो बहुत या बहुत अंतिम तत्व सरणी में सरणी में पहला तत्व है.

874
01:01:14,000 --> 01:01:18,000
याद रखें, द्विआधारी खोज एल्गोरिथ्म मध्यम तत्व पर देखकर काम करता है,

875
01:01:18,000 --> 01:01:21,000
देख रहा है है कि अगर मैच है कि आप के लिए देख रहे हैं.

876
01:01:21,000 --> 01:01:23,000
अगर ऐसा है, तो महान, तुम्हें मिल गया.

877
01:01:23,000 --> 01:01:27,000
>> बेहतरीन मामले में, कितनी तेजी द्विआधारी खोज रन करता है?

878
01:01:27,000 --> 01:01:29,000
1 [छात्र].

879
01:01:29,000 --> 01:01:32,000
1, यह लगातार समय है, 1 बड़ा हे. हाँ.

880
01:01:32,000 --> 01:01:36,000
[छात्र] मैं एक सवाल है. जब आप कहते हैं n के लॉग इन करने के लिए, आप 2 आधार के लिए सम्मान के साथ मतलब है, है ना?

881
01:01:36,000 --> 01:01:40,000
हाँ, इतना है कि दूसरी बात है.

882
01:01:40,000 --> 01:01:44,000
हम लॉग एन का कहना है, और मुझे लगता है कि जब मैं हाई स्कूल में था

883
01:01:44,000 --> 01:01:48,000
मैंने हमेशा माना है कि लॉग आधार 10 था.

884
01:01:48,000 --> 01:01:57,000
हाँ, तो हाँ, लॉग आधार आम तौर पर 2 हम क्या उपयोग है.

885
01:01:57,000 --> 01:02:02,000
फिर, द्विआधारी खोज करने के लिए वापस जा रहे हैं, अगर आप या तो के लिए खोज रहे हैं

886
01:02:02,000 --> 01:02:05,000
बहुत अंत में तत्व या बहुत शुरुआत में तत्व,

887
01:02:05,000 --> 01:02:08,000
क्योंकि तुम बीच में शुरू और फिर तुम त्यागें

888
01:02:08,000 --> 01:02:13,000
1/2 जो भी मानदंडों को पूरा नहीं करता है कि आप के लिए देख रहे हैं,

889
01:02:13,000 --> 01:02:15,000
और आप अगले आधे और अगले आधे और अगले आधे जाओ.

890
01:02:15,000 --> 01:02:19,000
यदि मैं मिलियन पूर्णांक सरणी में सबसे बड़ा तत्व के लिए खोज कर रहा हूँ

891
01:02:19,000 --> 01:02:25,000
मैं जा रहा हूँ यह 1 लाख बार के सबसे लॉग आधा करना

892
01:02:25,000 --> 01:02:28,000
इससे पहले कि मैं अंत में परीक्षण करने के लिए और देखने के लिए कि तत्व मैं देख रहा हूँ

893
01:02:28,000 --> 01:02:33,000
सबसे बड़ी में या सरणी के उच्चतम सूचकांक में है,

894
01:02:33,000 --> 01:02:38,000
और कि लॉग n के लेने के लिए, 1 लाख बार का प्रवेश होगा.

895
01:02:38,000 --> 01:02:40,000
>> बुलबुला तरह.

896
01:02:40,000 --> 01:02:43,000
क्या तुम लोगों को बुलबुला तरह एल्गोरिथ्म याद है?

897
01:02:43,000 --> 01:02:47,000
केविन, तुम मुझे के एक त्वरित पुनर्कथन क्या बुलबुला तरह एल्गोरिथ्म में हुआ दे सकता है?

898
01:02:47,000 --> 01:02:50,000
[केविन] असल में यह सूची में सब कुछ के माध्यम से चला जाता है.

899
01:02:50,000 --> 01:02:52,000
यह पहले दो पर लग रहा है.

900
01:02:52,000 --> 01:02:55,000
अगर पहले एक 2 एक यह उन्हें स्वैप की तुलना में बड़ा है.

901
01:02:55,000 --> 01:02:58,000
तो यह तुलना दूसरे और तीसरे, एक ही बात है, स्वैप,

902
01:02:58,000 --> 01:03:00,000
तीसरे और चौथे, सभी तरह से नीचे.

903
01:03:00,000 --> 01:03:03,000
बड़ी संख्या को समाप्त करने के लिए का पालन करेंगे.

904
01:03:03,000 --> 01:03:07,000
और आप लेकिन कई loops के बाद कर रहे हैं.

905
01:03:07,000 --> 01:03:11,000
वास्तव में, तो क्या केविन ने कहा है कि हम बड़ी संख्या देखेंगे

906
01:03:11,000 --> 01:03:15,000
सरणी के अंत बुलबुला.

907
01:03:15,000 --> 01:03:19,000
उदाहरण के लिए, आप हमें इस उदाहरण के माध्यम से चलने आपत्ति नहीं है अगर यह हमारे सरणी है?

908
01:03:19,000 --> 01:03:21,000
[केविन] आप 2 लेने के लिए और 3 हूँ.

909
01:03:21,000 --> 01:03:23,000
3 2 से भी बड़ा है, तो आप उन्हें स्वैप.

910
01:03:23,000 --> 01:03:29,000
[नैट एच.] ठीक है, तो हम इन स्वैप, और तो हम मिल 2, 3, 6, 4, और 9.

911
01:03:29,000 --> 01:03:31,000
[केविन] तो आप 3 और 6 की तुलना.

912
01:03:31,000 --> 01:03:33,000
3 6 से छोटा है, तो आप उन्हें छोड़,

913
01:03:33,000 --> 01:03:37,000
और 6 और 4, आप उन्हें स्वैप क्योंकि 4 6 की तुलना में छोटे है.

914
01:03:37,000 --> 01:03:42,000
[नैट एच.] ठीक है, तो मैं 2, 3, 4, 6, 9 मिलता है.

915
01:03:42,000 --> 01:03:46,000
[केविन] 9 और 6 से भी बड़ा है, तो आप इसे छोड़ दें.

916
01:03:46,000 --> 01:03:48,000
और तुम वापस इसे माध्यम से फिर से जाना चाहते हैं.

917
01:03:48,000 --> 01:03:50,000
>> [नैट एच.] मैं इस बिंदु पर काम कर रहा हूँ >> [केविन] नहीं?

918
01:03:50,000 --> 01:03:52,000
और मैं इस बिंदु पर किया क्यों नहीं कर रहा हूँ?

919
01:03:52,000 --> 01:03:54,000
क्योंकि ऐसा लगता है जैसे मेरी सरणी हल है. मैं इसे देख रहा हूँ.

920
01:03:54,000 --> 01:03:57,000
[केविन] के माध्यम से फिर से जाओ और यकीन है कि वहाँ कोई और अधिक स्वैप कर रहे हैं

921
01:03:57,000 --> 01:04:00,000
इससे पहले कि आप पूरी तरह से रोक सकता है.

922
01:04:00,000 --> 01:04:04,000
वास्तव में, ताकि आप के माध्यम से जा रही है और यकीन है कि वहाँ कोई स्वैप कर रहे हैं की जरूरत है

923
01:04:04,000 --> 01:04:06,000
कि आप इस बिंदु पर कर सकते हैं.

924
01:04:06,000 --> 01:04:08,000
यह वास्तव में सिर्फ भाग्यशाली था, जैसे तुमने कहा, कि हम समाप्त

925
01:04:08,000 --> 01:04:12,000
केवल के माध्यम से 1 पारित कर रहा है और हम हल कर रहे हैं.

926
01:04:12,000 --> 01:04:16,000
लेकिन सामान्य मामले में ऐसा करने के हम वास्तव में इस पर और फिर से यह करना होगा.

927
01:04:16,000 --> 01:04:20,000
और वास्तव में, यह सबसे अच्छा संभव मामले का एक उदाहरण था,

928
01:04:20,000 --> 01:04:24,000
जैसे हम समस्या में देखा था.

929
01:04:24,000 --> 01:04:28,000
हमने देखा है कि सबसे अच्छा संभव मामले n था.

930
01:04:28,000 --> 01:04:32,000
हम सरणी समय 1 के माध्यम से चला गया.

931
01:04:32,000 --> 01:04:35,000
इस एल्गोरिथ्म के लिए सबसे ज्यादा संभव मामला क्या है?

932
01:04:35,000 --> 01:04:37,000
[केविन] एन ².

933
01:04:37,000 --> 01:04:41,000
और कहा कि देखो क्या पसंद करता है? एक सरणी देखो क्या ऐसा n ² समय ले जाएगा?

934
01:04:41,000 --> 01:04:43,000
[केविन] [अश्राव्य क्रमबद्ध].

935
01:04:43,000 --> 01:04:51,000
वास्तव में, यदि ऐसा है तो मैं सरणी 9, 7, 6, 5, 2,

936
01:04:51,000 --> 01:04:54,000
1 9 सभी तरह बुलबुला होगा.

937
01:04:54,000 --> 01:04:59,000
1 चलना के बाद हम 7, 6, 5, 2, 9.

938
01:04:59,000 --> 01:05:07,000
फिर 7 बुलबुला, 6, 5, 2, 7, 9, और इतने पर और आगे.

939
01:05:07,000 --> 01:05:13,000
>> हम पूरे सरणी n बार के माध्यम से जाना होगा,

940
01:05:13,000 --> 01:05:16,000
और आप वास्तव में थोड़ा अधिक इस से सटीक प्राप्त कर सकते हैं

941
01:05:16,000 --> 01:05:23,000
क्योंकि एक बार हम अपनी अंतिम संभव स्थिति में 9 सभी तरह ले जाया गया है

942
01:05:23,000 --> 01:05:26,000
हम जानते हैं कि हम उस तत्व के खिलाफ फिर से तुलना नहीं.

943
01:05:26,000 --> 01:05:29,000
एक बार जब हम 7 बुदबुदाती ऊपर शुरू

944
01:05:29,000 --> 01:05:35,000
हम जानते हैं कि हम एक बार में 7 9 से पहले सही है रोक सकता है

945
01:05:35,000 --> 01:05:37,000
क्योंकि हम पहले से ही यह करने के लिए 9 की तुलना में.

946
01:05:37,000 --> 01:05:46,000
यदि आप एक चालाक रास्ता में इस करते हैं यह वास्तव में मुझे लगता है, कि इतना समय नहीं है.

947
01:05:46,000 --> 01:05:49,000
आप के लिए सभी संभव [अश्राव्य] संयोजन की तुलना करने के लिए नहीं जा रहे हैं

948
01:05:49,000 --> 01:05:55,000
हर बार जब आप प्रत्येक यात्रा के माध्यम से जाना.

949
01:05:55,000 --> 01:05:59,000
लेकिन फिर भी, जब हम यह ऊपरी सीमा के बारे में बात करते हैं, हम कहते हैं कि

950
01:05:59,000 --> 01:06:04,000
आप n पर देख रहे हैं ² तुलना सभी तरह के माध्यम से.

951
01:06:04,000 --> 01:06:12,000
>> चलो वापस जाओ, और जब से हम एक छोटे से समय पर कम पाने के लिए शुरू कर रहे हैं

952
01:06:12,000 --> 01:06:15,000
मैं कहूँगा कि आप निश्चित रूप से इस तालिका के बाकी के माध्यम से जाना चाहिए,

953
01:06:15,000 --> 01:06:17,000
यह सभी भरने के बाहर.

954
01:06:17,000 --> 01:06:20,000
उदाहरण के बारे में सोचो. ठोस उदाहरण के बारे में सोचो.

955
01:06:20,000 --> 01:06:22,000
यह वास्तव में आसान और उपयोगी है.

956
01:06:22,000 --> 01:06:25,000
यह ड्रा.

957
01:06:25,000 --> 01:06:28,000
इस तालिका की तरह है कि आप कंप्यूटर विज्ञान में के माध्यम से जाना

958
01:06:28,000 --> 01:06:32,000
आप वास्तव में इन के द्वारा हृदय जानना शुरू कर देना चाहिए.

959
01:06:32,000 --> 01:06:34,000
सवाल आप साक्षात्कार में मिल के प्रकार हैं.

960
01:06:34,000 --> 01:06:36,000
इन चीजों की तरह है कि पता करने के लिए अच्छा कर रहे हैं,

961
01:06:36,000 --> 01:06:41,000
और उन बढ़त मामले के बारे में लगता है, वास्तव में पता लगाना कैसे के बारे में सोचने के लिए

962
01:06:41,000 --> 01:06:45,000
जानते हुए भी कि बुलबुला के लिए सबसे खराब संभव सरणी प्रकार

963
01:06:45,000 --> 01:06:52,000
उस के साथ सुलझाने की है कि रिवर्स क्रम में है.

964
01:06:52,000 --> 01:06:58,000
>> सूचक. चलो संकेत के बारे में थोड़ा बहुत बात करते हैं.

965
01:06:58,000 --> 01:07:03,000
पिछले कुछ ही मिनटों में हम यहाँ है

966
01:07:03,000 --> 01:07:11,000
मैं जानता हूँ कि यह मैं / हे बल्कि नया है कि फाइल के साथ साथ कुछ है.

967
01:07:11,000 --> 01:07:19,000
जब हम संकेत कारण है कि हम संकेत के बारे में बात करना चाहते हैं के बारे में बात करते हैं

968
01:07:19,000 --> 01:07:24,000
क्योंकि, एक, जब हम सी में काम कर रहे हैं

969
01:07:24,000 --> 01:07:33,000
हम वास्तव में एक काफी कम स्तर पर सबसे आधुनिक प्रोग्रामिंग भाषाओं की तुलना में कर रहे हैं.

970
01:07:33,000 --> 01:07:38,000
हम वास्तव में कर रहे हैं स्मृति में चर में हेरफेर करने में सक्षम है,

971
01:07:38,000 --> 01:07:43,000
बाहर आंकड़ा जहां वे वास्तव में हमारे रैम के भीतर स्थित हैं.

972
01:07:43,000 --> 01:07:46,000
एक बार जब आप पर चले गए ऑपरेटिंग सिस्टम वर्गों आप देखेंगे ले

973
01:07:46,000 --> 01:07:48,000
है कि वह है, फिर, एक अमूर्त की तरह.

974
01:07:48,000 --> 01:07:50,000
यह वास्तव में मामला नहीं है.

975
01:07:50,000 --> 01:07:52,000
हम आभासी स्मृति है कि हम में से उन विवरण छुपा रहा है मिल गया है.

976
01:07:52,000 --> 01:07:58,000
>> लेकिन अब के लिए आप को लगता है कि जब आप एक कार्यक्रम कर सकते हैं,

977
01:07:58,000 --> 01:08:02,000
उदाहरण के लिए, जब आप शुरू अपने सीज़र बीजलेख कार्यक्रम चल रहा है

978
01:08:02,000 --> 01:08:06,000
मैं वापस मेरी iPad सच में जल्दी स्विच

979
01:08:06,000 --> 01:08:12,000
कि शुरुआत से ही अपने कार्यक्रम में, यदि आप कहते हैं,

980
01:08:12,000 --> 01:08:15,000
अपने लैपटॉप पर 4 रैम की गीगाबाइट,

981
01:08:15,000 --> 01:08:21,000
आप यह हिस्सा अलग हो, और हम इस रैम फोन करता हूँ.

982
01:08:21,000 --> 01:08:25,000
और यह हम 0 कॉल करने के लिए जा रहे हैं एक जगह में शुरू होता है,

983
01:08:25,000 --> 01:08:30,000
और यह एक जगह पर समाप्त होता है कि हम 4 गीगाबाइट फोन करता हूँ.

984
01:08:30,000 --> 01:08:37,000
मैं वास्तव में नहीं लिख सकते हैं. यार, कि काट दिया है.

985
01:08:37,000 --> 01:08:40,000
जब अपने कार्यक्रम कार्यान्वित

986
01:08:40,000 --> 01:08:44,000
ऑपरेटिंग सिस्टम रैम carves,

987
01:08:44,000 --> 01:08:51,000
और यह अपने अंदर रहना कार्यक्रम के विभिन्न भागों के लिए अलग खंडों को निर्दिष्ट

988
01:08:51,000 --> 01:08:58,000
यहाँ नीचे इस क्षेत्र में कोई आदमी की भूमि की तरह है.

989
01:08:58,000 --> 01:09:02,000
जब आप एक छोटे से दूर यहाँ जाना

990
01:09:02,000 --> 01:09:05,000
आप वास्तव में जगह मिल गया है, जहां

991
01:09:05,000 --> 01:09:09,000
कोड अपने कार्यक्रम जीवन के लिए.

992
01:09:09,000 --> 01:09:13,000
यही वास्तविक बाइनरी कोड, कि निष्पादन योग्य फ़ाइल वास्तव में स्मृति में लोड हो जाता है

993
01:09:13,000 --> 01:09:17,000
जब आप एक प्रोग्राम चलाने के लिए, और यह कोड खंड में रहती है.

994
01:09:17,000 --> 01:09:22,000
और के रूप में अपने कार्यक्रम कार्यान्वित प्रोसेसर इस कोड खंड पर लग रहा है

995
01:09:22,000 --> 01:09:24,000
के लिए बाहर आंकड़ा अगले अनुदेश क्या है?

996
01:09:24,000 --> 01:09:27,000
कोड की अगली पंक्ति मैं निष्पादित करने की जरूरत क्या है?

997
01:09:27,000 --> 01:09:31,000
>> वहाँ भी एक डेटा खंड है, और यह वह जगह है जहाँ उन स्ट्रिंग स्थिरांक

998
01:09:31,000 --> 01:09:34,000
संग्रहीत कि आप का उपयोग किया गया है.

999
01:09:34,000 --> 01:09:42,000
और फिर आगे इस जगह ढेर कहा जाता है.

1000
01:09:42,000 --> 01:09:46,000
हम malloc का उपयोग करके वहाँ में स्मृति का उपयोग करने के लिए,

1001
01:09:46,000 --> 01:09:49,000
और फिर अपने कार्यक्रम के शीर्ष की ओर

1002
01:09:49,000 --> 01:09:52,000
वहाँ ढेर है,

1003
01:09:52,000 --> 01:09:57,000
और कहा कि जहां हम शुरुआत के अधिकांश के लिए खेल रहा हूँ.

1004
01:09:57,000 --> 01:09:59,000
इस पैमाने या कुछ भी करने के लिए नहीं है.

1005
01:09:59,000 --> 01:10:03,000
यह एक बहुत बहुत मशीन निर्भर है,

1006
01:10:03,000 --> 01:10:10,000
प्रणाली निर्भर कार्य कर रहा है, लेकिन यह है कि अपेक्षाकृत कैसे चीजों को chunked मिलता है.

1007
01:10:10,000 --> 01:10:17,000
जब आप एक प्रोग्राम चलाने के लिए और आप एक-x बुलाया चर घोषणा

1008
01:10:17,000 --> 01:10:27,000
मैं नीचे एक बॉक्स आकर्षित करने के लिए जा रहा हूँ, और यह करने के लिए राम के रूप में अच्छी तरह से होने जा रहा है.

1009
01:10:27,000 --> 01:10:29,000
और मैं देखने के लिए जा रहा हूँ.

1010
01:10:29,000 --> 01:10:34,000
हम दांतेदार लाइनों आकर्षित करने के लिए संकेत मिलता है यह सिर्फ राम का एक छोटा सा वर्ग है

1011
01:10:34,000 --> 01:10:38,000
और जैसा कि हम यह सब नहीं शीर्ष पर आकर्षित.

1012
01:10:38,000 --> 01:10:43,000
>> अगर मैं एक पूर्णांक x नामक चर घोषित

1013
01:10:43,000 --> 01:10:49,000
तो क्या मैं वास्तव में एक मानचित्रण

1014
01:10:49,000 --> 01:10:54,000
कि अपने कार्यक्रम के प्रतीक तालिका में संग्रहीत किया जाता है

1015
01:10:54,000 --> 01:11:00,000
है कि स्मृति के इस क्षेत्र के लिए नाम x जोड़ता है कि मैं तैयार किया है

1016
01:11:00,000 --> 01:11:03,000
सही यहाँ ऊर्ध्वाधर सलाखों के बीच.

1017
01:11:03,000 --> 01:11:08,000
अगर मैं अपने प्रोग्राम है कि x 7 = कहना में कोड की एक पंक्ति है

1018
01:11:08,000 --> 01:11:15,000
प्रोसेसर जानता है, "ओह, ठीक है, मुझे पता है कि x स्मृति में इस स्थान पर रहता है."

1019
01:11:15,000 --> 01:11:25,000
"मुझे आगे जाना है और वहाँ एक 7 लिखने जा रहा हूँ."

1020
01:11:25,000 --> 01:11:28,000
यह कैसे जानते हैं कि किस स्थान की स्मृति में है?

1021
01:11:28,000 --> 01:11:30,000
वैसे, यह सब समय संकलन में किया है.

1022
01:11:30,000 --> 01:11:34,000
संकलक आवंटन की देखभाल लेता है, जहां चर में से प्रत्येक के लिए जा रहे हैं

1023
01:11:34,000 --> 01:11:40,000
और एक विशेष मानचित्रण बनाने या बल्कि डॉट्स जोड़ने

1024
01:11:40,000 --> 01:11:43,000
एक प्रतीक है और कहाँ जा रहा है, एक चर नाम के बीच

1025
01:11:43,000 --> 01:11:46,000
और जहां यह स्मृति में रहने के लिए जा रहा है.

1026
01:11:46,000 --> 01:11:50,000
लेकिन यह पता चला है कि हम वास्तव में यह हमारे कार्यक्रमों में उपयोग के रूप में अच्छी तरह से कर सकते हैं.

1027
01:11:50,000 --> 01:11:55,000
यह महत्वपूर्ण हो जाता है जब हम डेटा संरचनाओं में से कुछ के बारे में बात शुरू करते हैं,

1028
01:11:55,000 --> 01:11:58,000
जो एक अवधारणा है कि हम बाद में शुरू करने जा रहे हैं.

1029
01:11:58,000 --> 01:12:09,000
>> लेकिन अब के लिए, क्या तुम जानते हो सकता है कि मैं इस स्थान के लिए एक सूचक बनाने के लिए, x कर सकते हैं.

1030
01:12:09,000 --> 01:12:12,000
उदाहरण के लिए, मैं एक सूचक चर बना सकते हैं.

1031
01:12:12,000 --> 01:12:16,000
जब हम एक सूचक चर बनाते हम सितारा संकेतन का उपयोग करें.

1032
01:12:16,000 --> 01:12:21,000
इस मामले में, यह कहना है कि मैं एक int के लिए एक सूचक बनाने जा रहा हूँ.

1033
01:12:21,000 --> 01:12:24,000
यह किसी भी अन्य की तरह एक प्रकार है.

1034
01:12:24,000 --> 01:12:27,000
हम इसे एक चर y तरह देते हैं,

1035
01:12:27,000 --> 01:12:32,000
और फिर हम यह पता करने के लिए बराबर है, एक पते पर निर्धारित किया है.

1036
01:12:32,000 --> 01:12:38,000
इस मामले में, हम y एक्स के लिए बात कर सकते हैं

1037
01:12:38,000 --> 01:12:43,000
इस एम्परसेंड साथ एक्स के पते, जो हम करते हैं लेने के द्वारा,

1038
01:12:43,000 --> 01:12:55,000
और फिर हम y सेट करने के लिए यह करने के लिए बिंदु.

1039
01:12:55,000 --> 01:12:59,000
यह क्या अनिवार्य रूप से अगर हम अपने रैम को देखो करता है

1040
01:12:59,000 --> 01:13:02,000
यह एक अलग चर बनाता है.

1041
01:13:02,000 --> 01:13:04,000
यह करने के लिए यह y कॉल करने के लिए जा रहा है,

1042
01:13:04,000 --> 01:13:06,000
और जब कोड की इस पंक्ति निष्पादित

1043
01:13:06,000 --> 01:13:13,000
यह वास्तव में एक छोटे से सूचक है जो हम आम तौर पर एक तीर के रूप में आकर्षित बनाने के लिए जा रहा है,

1044
01:13:13,000 --> 01:13:15,000
और यह करने के लिए एक्स के लिए इंगित y सेट.

1045
01:13:15,000 --> 01:13:17,000
हां.

1046
01:13:17,000 --> 01:13:19,000
[छात्र] यदि x पहले से ही एक सूचक है, तुम सिर्फ करना होगा

1047
01:13:19,000 --> 01:13:22,000
int * y = x बजाय एम्परसेंड होने की?

1048
01:13:22,000 --> 01:13:24,000
हां.

1049
01:13:24,000 --> 01:13:27,000
यदि x पहले से ही एक सूचक है, तो आप 2 एक दूसरे के बराबर संकेत सेट कर सकते हैं,

1050
01:13:27,000 --> 01:13:30,000
जो मामले में y एक्स के लिए नहीं बात करेंगे,

1051
01:13:30,000 --> 01:13:34,000
लेकिन यह एक्स जो कुछ भी इशारा कर रहा है के लिए बात करेंगे.

1052
01:13:34,000 --> 01:13:37,000
दुर्भाग्य से, हम समय से बाहर रहे.

1053
01:13:37,000 --> 01:13:44,000
>> क्या मैं इस बिंदु पर कहना होगा, हम इस ऑफ़लाइन के बारे में बात कर सकते हैं,

1054
01:13:44,000 --> 01:13:49,000
लेकिन मैं कहूंगा कि इस समस्या के माध्यम से काम कर रहा है, # 14 शुरू.

1055
01:13:49,000 --> 01:13:53,000
आप देख सकते हैं कि वहाँ पहले से ही आप के लिए एक छोटे से भरा सा है यहाँ.

1056
01:13:53,000 --> 01:13:57,000
आपको लगता है कि जब हम 2 संकेत घोषणा कर सकते हैं, int * x और y,

1057
01:13:57,000 --> 01:14:01,000
और ध्यान दें कि चर के लिए अगले * की ओर इशारा करते हुए कुछ है कि पिछले साल किया गया था.

1058
01:14:01,000 --> 01:14:05,000
यह पता चला है कि हम क्या कर रहे हैं इस साल के लिए इसी तरह की है.

1059
01:14:05,000 --> 01:14:11,000
यह वह जगह है जहाँ आप लिखने * जब आप सूचक की घोषणा कर रहे हैं कोई फर्क नहीं पड़ता.

1060
01:14:11,000 --> 01:14:17,000
लेकिन हम * टाइप करने के लिए बगल में लिखा है

1061
01:14:17,000 --> 01:14:24,000
क्योंकि कि यह बहुत स्पष्ट है कि आप एक सूचक चर की घोषणा कर रहे हैं कि बनाता है.

1062
01:14:24,000 --> 01:14:27,000
आप देख सकते हैं कि 2 संकेत की घोषणा हमें 2 बक्से देता.

1063
01:14:27,000 --> 01:14:31,000
जब हम यहाँ malloc के बराबर एक्स सेट

1064
01:14:31,000 --> 01:14:34,000
यह क्या कह रहा है निवारक ढेर में स्मृति.

1065
01:14:34,000 --> 01:14:41,000
इस छोटे से बॉक्स में, इस चक्र, ढेर पर स्थित है.

1066
01:14:41,000 --> 01:14:43,000
एक्स यह इशारा कर रहा है.

1067
01:14:43,000 --> 01:14:46,000
ध्यान दें कि y अभी भी कुछ भी करने के लिए नहीं इशारा कर रहा है.

1068
01:14:46,000 --> 01:14:50,000
स्मृति x में 42 नंबर की दुकान

1069
01:14:50,000 --> 01:14:55,000
हम क्या संकेतन का उपयोग होगा?

1070
01:14:55,000 --> 01:14:59,000
[छात्र] * x 42 =.

1071
01:14:59,000 --> 01:15:01,000
वास्तव में, * x 42 =.

1072
01:15:01,000 --> 01:15:06,000
इसका मतलब है कि तीर का पालन करें और वहाँ में 42 फेंक.

1073
01:15:06,000 --> 01:15:09,000
यहाँ है जहाँ हम वाई और एक्स सेट हम y x ओर इशारा करते हैं.

1074
01:15:09,000 --> 01:15:13,000
फिर, यह बस की तरह है क्या केविन ने कहा कि जहां हम y एक्स के लिए बराबर सेट.

1075
01:15:13,000 --> 01:15:15,000
वाई एक्स के लिए नहीं इशारा कर रहा है.

1076
01:15:15,000 --> 01:15:19,000
बल्कि, यह एक्स के रूप में अच्छी तरह से करने के लिए क्या इशारा कर रहा है की ओर इशारा करते है.

1077
01:15:19,000 --> 01:15:24,000
>> और फिर अंत में यह पिछले बॉक्स में 2 संभव चीजें हैं जो हम कर सकते हैं.

1078
01:15:24,000 --> 01:15:28,000
एक यह है कि हम कह सकते हैं * x = 13.

1079
01:15:28,000 --> 01:15:33,000
दूसरी बात यह है कि हम कहना एलेक्स, आप करते हैं जानते हो सकता है कि हम यहाँ क्या कर सकता है?

1080
01:15:33,000 --> 01:15:37,000
आप कह सकते हैं * x 13 =

1081
01:15:37,000 --> 01:15:41,000
[छात्र] आप int जो कुछ भी कह सकता है.

1082
01:15:41,000 --> 01:15:45,000
[नैट एच.] यदि यह एक int चर के रूप में भेजा जाता था कि हम कर सकते थे.

1083
01:15:45,000 --> 01:15:49,000
हम भी * y = 13 क्योंकि वे दोनों एक ही जगह पर इशारा कर रहे हैं, कह सकते हैं

1084
01:15:49,000 --> 01:15:51,000
तो हम या तो चर का उपयोग करने के लिए मिल सकता है.

1085
01:15:51,000 --> 01:15:56,000
हाँ >> [छात्र] क्या यह की तरह अगर हम सिर्फ कहते int x 13 है लग रही होगी?

1086
01:15:56,000 --> 01:16:00,000
कि एक नई एक्स नामक चर, जो काम नहीं करेगा घोषित किया जाएगा.

1087
01:16:00,000 --> 01:16:04,000
हम एक टकराव है क्योंकि हम x एक सूचक होने के लिए यहाँ की घोषणा करता हूं.

1088
01:16:04,000 --> 01:16:10,000
[छात्र] यदि हम अभी से ही है कि बयान था कि यह क्या चक्र के मामले में की तरह लग रही होगी?

1089
01:16:10,000 --> 01:16:14,000
यदि हम x 13 = तो हम एक बॉक्स है, और चाहते हैं एक तीर होने के बजाय

1090
01:16:14,000 --> 01:16:16,000
बॉक्स से बाहर आ रहा है हम यह सिर्फ एक 13 के रूप में आकर्षित होता.

1091
01:16:16,000 --> 01:16:19,000
बॉक्स में [छात्र]. ठीक है.

1092
01:16:19,000 --> 01:16:24,000
>> आप देख के लिए धन्यवाद, और 0 प्रश्नोत्तरी पर अच्छी किस्मत.

1093
01:16:24,000 --> 01:16:28,000
[CS50.TV]