1
00:00:08,280 --> 00:00:09,020
[Powered by Google Translate] सब ठीक है, हर कोई: ZAMYLA चान.

2
00:00:09,020 --> 00:00:11,130
1 Walkthrough के लिए आपका स्वागत है.

3
00:00:11,130 --> 00:00:13,950
इस walkthrough pset 1, जो है सी. मैं आशा है कि आप पर होगा

4
00:00:13,950 --> 00:00:16,540
सभी अपने स्क्रैच परियोजनाओं के साथ मज़ा था.

5
00:00:16,540 --> 00:00:18,430
तो अब इस walkthrough में, हम वास्तव में जा रहे हैं

6
00:00:18,430 --> 00:00:21,580
सी में प्राप्त करने में सक्षम है, कुछ मशीन कोड लिखने में मिलता है.

7
00:00:21,580 --> 00:00:24,750
तो अगर आप Walkthrough 0 पर, तो नहीं थे इन

8
00:00:24,750 --> 00:00:26,330
वास्तव में walkthroughs - हम के माध्यम से चलने के लिए जा रहा

9
00:00:26,330 --> 00:00:29,500
समस्या सेट, कुछ सामान्य टिप्स और तकनीकों के माध्यम से बात

10
00:00:29,500 --> 00:00:30,430
है कि आप उपयोग कर सकते हैं.

11
00:00:30,430 --> 00:00:32,960
हम असाइनमेंट प्रबंधनीय काटने में तोड़ने के लिए हूँ, इतना है कि

12
00:00:32,960 --> 00:00:35,500
तुम लोग और उम्मीद है कि शुरू कर सकते हैं

13
00:00:35,500 --> 00:00:37,470
हम समझते हैं कि यह कैसे करना है.

14
00:00:37,470 --> 00:00:38,050
>> ठीक है.

15
00:00:38,050 --> 00:00:42,280
Pset तो 1.

16
00:00:42,280 --> 00:00:46,200
psets इस साल जहां 1 संरचना होगा -

17
00:00:46,200 --> 00:00:48,930
वहाँ के लिए सवालों की एक खंड की एक श्रृंखला होने जा रहा है

18
00:00:48,930 --> 00:00:51,120
सवाल है कि वास्तव में भी मदद मिलेगी आप के साथ शुरू करने के लिए

19
00:00:51,120 --> 00:00:53,840
pset मदद, आप कुछ तकनीकों है कि आप की जरूरत अभ्यास.

20
00:00:53,840 --> 00:00:55,950
और इसलिए इन सवालों, मैं में कवर नहीं जा रहा हूँ

21
00:00:55,950 --> 00:00:59,630
walkthrough अपने अनुभाग में, अपने आवंटित शिक्षण क्योंकि

22
00:00:59,630 --> 00:01:01,630
साथी वास्तव में उन के माध्यम से चल रहा है

23
00:01:01,630 --> 00:01:02,620
आप के साथ सवाल.

24
00:01:02,620 --> 00:01:04,370
अपने अनुभाग के अंत में, तुम दूर के साथ चलना होगा

25
00:01:04,370 --> 00:01:07,200
उन सवालों के जवाब, लेकिन यह भी विश्वास है कि

26
00:01:07,200 --> 00:01:10,340
आप सुविधाओं है कि आप की आवश्यकता होगी की कुछ को लागू कर सकते हैं

27
00:01:10,340 --> 00:01:12,480
pset के उत्तरार्द्ध भागों के लिए.

28
00:01:12,480 --> 00:01:15,900
>> मारियो Pset 1 का गठन किया.

29
00:01:15,900 --> 00:01:19,000
और कहा कि एक मजाक सा कार्यक्रम है जहाँ हम मूलतः

30
00:01:19,000 --> 00:01:24,360
लिखने और प्रिंट ठेठ मारियो दृश्य में एक आधा पिरामिड.

31
00:01:24,360 --> 00:01:27,150
और फिर pset के दूसरे भाग लालची कहा जाता है.

32
00:01:27,150 --> 00:01:29,850
और इतना लालची में हम अनिवार्य रूप से एक लालची के रूप में कार्य

33
00:01:29,850 --> 00:01:32,780
खजांची, जहां अगर कोई हमें पैसे की राशि देता है

34
00:01:32,780 --> 00:01:38,730
कि हम चाहते हैं, हम सिक्कों कि की न्यूनतम राशि की गणना

35
00:01:38,730 --> 00:01:40,840
हम उन्हें वापस करने के लिए अभी भी उन्हें लगता है कि राशि देने के लिए कर सकते हैं.

36
00:01:44,080 --> 00:01:44,420
>> सही सभी.

37
00:01:44,420 --> 00:01:46,970
तो हर walkthrough एक Toolbox होगा.

38
00:01:46,970 --> 00:01:50,650
और फिर, तुम उपकरणों के सभी इस में उपयोग हो सकता है

39
00:01:50,650 --> 00:01:53,080
toolbox आप या उन सभी का उपयोग हो सकता है.

40
00:01:53,080 --> 00:01:54,550
किसी भी मामले में, यह पता करने के लिए वास्तव में अच्छा है क्या

41
00:01:54,550 --> 00:01:55,680
आप के साथ लैस कर रहे हैं.

42
00:01:55,680 --> 00:01:59,990
तो हम CS50 उपकरण, तुम लोग है जो मैं तुम्हें दिखाता हूँ और

43
00:01:59,990 --> 00:02:01,350
आपको लगता है कि करने के लिए परिचय.

44
00:02:01,350 --> 00:02:05,710
फिर भी सामान्य रूप में, अच्छा शैली निश्चित रूप से एक हमारे

45
00:02:05,710 --> 00:02:07,080
सबसे महत्वपूर्ण उपकरण है.

46
00:02:07,080 --> 00:02:10,759
शैली अनिवार्य रूप से कैसे अपने कोड पठनीय संबंधित?

47
00:02:10,759 --> 00:02:12,750
जब किसी और चला जाता है और अपने कोड पढ़ता है, वे है

48
00:02:12,750 --> 00:02:13,610
एक आसान समय?

49
00:02:13,610 --> 00:02:14,630
वे यह समझ सकते हैं?

50
00:02:14,630 --> 00:02:16,610
यह सुंदर है?

51
00:02:16,610 --> 00:02:21,750
फिर हम कैसे मान्य उपयोगकर्ता इनपुट प्राप्त करने के बारे में बात करेंगे

52
00:02:21,750 --> 00:02:26,430
कार्यक्रम क्योंकि दोनों मारियो और लालची में, आप की आवश्यकता होगी

53
00:02:26,430 --> 00:02:31,660
उपयोगकर्ता इनपुट के लिए पूछने के लिए और आप संख्या की किसी तरह दे.

54
00:02:31,660 --> 00:02:35,480
तो फिर हम यकीन है कि नंबर मान्य है बनाना चाहते हैं.

55
00:02:35,480 --> 00:02:39,010
तो खरोंच में याद है, हम ऐसे दोहराने के रूप में ब्लॉक था,

56
00:02:39,010 --> 00:02:42,300
तक दोहराएं रुको, हमेशा के लिए या.

57
00:02:42,300 --> 00:02:45,880
तो हम की तरह करने के लिए जा रहे हैं अनुवाद है कि अब सी में और

58
00:02:45,880 --> 00:02:49,750
लिए के रूप में loops पर देखो, जबकि, और करते हैं, जबकि.

59
00:02:49,750 --> 00:02:54,330
फिर भी हम भी मूल्यों पर प्रदर्शित करने के लिए की आवश्यकता होगी

60
00:02:54,330 --> 00:02:56,500
स्क्रीन, मारियो में या लालची में है कि क्या.

61
00:02:56,500 --> 00:03:01,150
और इसलिए हम कैसे हम तार से बातें करने के लिए प्रिंट के बारे में बात करेंगे

62
00:03:01,150 --> 00:03:03,070
integers और मंगाई.

63
00:03:03,070 --> 00:03:05,250
और फिर अंत में, हम pseudocode के बारे में बात करते हैं, एक सच

64
00:03:05,250 --> 00:03:07,550
इस पाठ्यक्रम भर में याद करने के लिए महत्वपूर्ण अवधारणा है.

65
00:03:07,550 --> 00:03:11,130
मुझे क्या पता मुझे समस्या सेट के साथ सबसे ज्यादा मदद करता है सोचने के लिए और

66
00:03:11,130 --> 00:03:14,260
किसी भी सी के बारे में सोच से पहले का वर्णन है कि मैं क्या करना चाहते हैं

67
00:03:14,260 --> 00:03:15,640
लेकिन सिर्फ कार्रवाई का वर्णन.

68
00:03:15,640 --> 00:03:19,100
तो pseudocode में अंग्रेजी और सी के बीच किस तरह का है, किस तरह का

69
00:03:19,100 --> 00:03:22,980
सही सिंटैक्स बिना प्रक्रियाओं का वर्णन है, लेकिन

70
00:03:22,980 --> 00:03:24,490
एक अच्छा पर्याप्त संरचना प्रदान करते हैं.

71
00:03:24,490 --> 00:03:27,460
और इसलिए मैं आप के लिए pseudocode के कुछ उदाहरण के रूप में अच्छी तरह से करना होगा

72
00:03:27,460 --> 00:03:28,710
इस walkthrough.

73
00:03:31,610 --> 00:03:31,940
>> ठीक है.

74
00:03:31,940 --> 00:03:35,620
तो क्या हम साथ काम करेंगे CS50 उपकरण है.

75
00:03:35,620 --> 00:03:38,840
यह अनिवार्य रूप से एक आभासी मशीन है कि की तरह चलाता है

76
00:03:38,840 --> 00:03:40,780
अपने स्वयं के कंप्यूटर के अंदर कंप्यूटर.

77
00:03:40,780 --> 00:03:42,080
और यह लाभ का एक बहुत है.

78
00:03:42,080 --> 00:03:44,780
एक यह है कि यह उपकरण है कि आप का एक बहुत कुछ के साथ पूर्व निर्धारित है

79
00:03:44,780 --> 00:03:45,980
CS50 के लिए जरूरत है.

80
00:03:45,980 --> 00:03:47,940
के रूप में अच्छी तरह से, इसका मतलब है कि हर कोई एक ही जमीन पर है,

81
00:03:47,940 --> 00:03:50,800
चाहे मैक या पीसी या अन्य ऑपरेटिंग सिस्टम.

82
00:03:50,800 --> 00:03:53,930
हम सभी आभासी मशीन चला सकते हैं.

83
00:03:53,930 --> 00:03:58,800
और इसलिए वहाँ manual.cs50.net/appliance में निर्देश दिए गए हैं.

84
00:03:58,800 --> 00:04:02,740
और यदि ऐसा है तो आप उस लिंक पर जाने के लिए और निर्देशों का पालन करें,

85
00:04:02,740 --> 00:04:07,820
तो उम्मीद है कि आप उपकरण को स्थापित करने में सक्षम हो जाएगा.

86
00:04:07,820 --> 00:04:11,390
>> तो पहले, आप एक आवेदन स्थापित करने की जरूरत है, एक हूँ

87
00:04:11,390 --> 00:04:13,760
वास्तविक आभासी मशीन को चलाने के लिए सक्षम होने के लिए आवेदन.

88
00:04:13,760 --> 00:04:15,270
और फिर आप उपकरण डाउनलोड.

89
00:04:15,270 --> 00:04:18,050
लेकिन फिर, वहाँ पर निर्देश दिए गए हैं

90
00:04:18,050 --> 00:04:21,459
manual.cs50.net/appliance.

91
00:04:21,459 --> 00:04:26,040
तो मैं पहले से ही मेरे उपकरण डाउनलोड किया है, और मैं स्थापित किया है

92
00:04:26,040 --> 00:04:28,060
यह VMware संलयन में.

93
00:04:28,060 --> 00:04:31,250
और इसलिए एक बार मैं उपकरण डाउनलोड, मैं फाइल करने के लिए चला गया.

94
00:04:31,250 --> 00:04:34,690
मैं खोलने के लिए चला गया और फिर पाया कि मैं जहां

95
00:04:34,690 --> 00:04:37,550
CS50 उपकरण संग्रहीत.

96
00:04:37,550 --> 00:04:39,310
और वहाँ से, मैं इसे यहाँ भाग गया.

97
00:04:39,310 --> 00:04:44,520
लेकिन मैं यह पहले से ही यहाँ, तो चलो एक करीब देखो ले.

98
00:04:44,520 --> 00:04:44,850
>> सही सभी.

99
00:04:44,850 --> 00:04:46,770
तो अब हम CS50 उपकरण के अंदर हो.

100
00:04:46,770 --> 00:04:47,890
मैं इसे पूर्ण स्क्रीन बनाया.

101
00:04:47,890 --> 00:04:51,130
आप करने के लिए कि अगर आप चाहते हैं या सिर्फ यह एक के रूप में चुन सकते हैं

102
00:04:51,130 --> 00:04:53,480
अपने डेस्कटॉप पर छोटी खिड़की.

103
00:04:53,480 --> 00:04:57,170
यहाँ हम बस के साथ एक सरल डेस्कटॉप

104
00:04:57,170 --> 00:04:58,220
एक घर और एक कचरा.

105
00:04:58,220 --> 00:05:05,070
लेकिन अगर आप मेनू में जाने और प्रोग्रामिंग के लिए तो, तो आप देखेंगे

106
00:05:05,070 --> 00:05:07,570
कि हम कुछ टर्मिनल बुलाया है.

107
00:05:07,570 --> 00:05:12,340
और इसलिए यहाँ में, हम अपने कंप्यूटर के आसपास नेविगेट कर सकते हैं.

108
00:05:12,340 --> 00:05:13,360
हम कोड लिख सकते हैं.

109
00:05:13,360 --> 00:05:17,240
लेकिन वास्तव में, हम एक जीएडिट कार्यक्रम बुलाया का उपयोग कर सकता हूँ, या "जी

110
00:05:17,240 --> 00:05:20,050
, जो भी एक है कि संपादित करें ".

111
00:05:20,050 --> 00:05:21,680
तो हम का उपयोग किया जा सकता है कि एक कोड लिखने के लिए हूँ.

112
00:05:21,680 --> 00:05:24,850
तो आप इन दो उपकरण है कि आप मुख्य रूप से उपयोग कर सकता हूँ

113
00:05:24,850 --> 00:05:27,590
कोड लिखें.

114
00:05:27,590 --> 00:05:31,240
फिर इसके अलावा में, यह सिर्फ एक नियमित रूप से कंप्यूटर की तरह है.

115
00:05:31,240 --> 00:05:32,890
हम एक ब्राउज़र है.

116
00:05:32,890 --> 00:05:34,400
हम गूगल क्रोम चुना.

117
00:05:34,400 --> 00:05:38,720
मैंने क्या किया है मैं एक ड्रॉपबॉक्स निर्धारित किया है की सभी शामिल

118
00:05:38,720 --> 00:05:39,340
दस्तावेजों.

119
00:05:39,340 --> 00:05:41,760
और इतना है कि कुछ है कि अत्यधिक प्रोत्साहित किया है.

120
00:05:41,760 --> 00:05:44,900
ड्रॉपबॉक्स का उपयोग करता है और यदि ऐसा है तो सिंक्रनाइज़ बादल -

121
00:05:44,900 --> 00:05:47,250
ऐसा करते हैं, उदाहरण के लिए, मौका द्वारा कुछ - चलो आशा है कि नहीं -

122
00:05:47,250 --> 00:05:50,100
अपने उपकरण के लिए होता है, तो यह सब होगा

123
00:05:50,100 --> 00:05:51,350
बादल पर synced.

124
00:05:54,716 --> 00:05:55,180
>> सही सभी.

125
00:05:55,180 --> 00:05:59,500
तो उन आवेदन कर रहे हैं कि आप में उपयोग कर सकता हूँ

126
00:05:59,500 --> 00:06:02,900
CS50 उपकरण.

127
00:06:02,900 --> 00:06:05,750
अब कमांड लाइन के आसपास नेविगेट करने के लिए.

128
00:06:05,750 --> 00:06:10,150
टर्मिनल वास्तव में वास्तव में एक तरह की तरह के रूप में कार्य कर सकते हैं

129
00:06:10,150 --> 00:06:12,040
में आदेश टाइप करें -

130
00:06:12,040 --> 00:06:13,650
करना चाहते हैं, यदि आप एक मैक, एक खोजक कर रहे हैं.

131
00:06:13,650 --> 00:06:17,010
या यदि आप Windows में कर रहे हैं, मुझे विश्वास है कि "मेरे लॉग्स

132
00:06:17,010 --> 00:06:19,070
"कंप्यूटर या ऐसा कुछ.

133
00:06:19,070 --> 00:06:23,160
तो अगर हम उपकरण को वापस जाने के लिए, चलो एक खुला

134
00:06:23,160 --> 00:06:25,710
टर्मिनल विंडो.

135
00:06:25,710 --> 00:06:27,720
तो यह इस prompt, jharvard उपकरण @ है.

136
00:06:27,720 --> 00:06:32,950
चलो बस यह बड़ा बना.

137
00:06:32,950 --> 00:06:33,790
ठीक है.

138
00:06:33,790 --> 00:06:40,400
तो अगर हम आदेश रास लिखें, तो है कि सूची के सभी

139
00:06:40,400 --> 00:06:45,440
हमारे कंप्यूटर में फाइलें, हमारे मौजूदा निर्देशिका में.

140
00:06:45,440 --> 00:06:46,720
निर्देशिकाएँ सिर्फ फ़ोल्डर्स की तरह हैं.

141
00:06:46,720 --> 00:06:49,310
हम उन शब्दों interchangeably उपयोग करें.

142
00:06:49,310 --> 00:06:52,480
ठीक है, तो हम फ़ाइलों को सूचीबद्ध किया है

143
00:06:52,480 --> 00:06:53,650
कि इस निर्देशिका में हैं.

144
00:06:53,650 --> 00:06:58,340
अब अगर हम का उपयोग करना चाहते हैं, कहते हैं, हमारे ड्रॉपबॉक्स, तो हम कर सकते हैं

145
00:06:58,340 --> 00:06:59,320
निर्देशिका बदल जाते हैं.

146
00:06:59,320 --> 00:07:04,230
सीडी और तो ड्रॉपबॉक्स तो.

147
00:07:04,230 --> 00:07:10,860
हम रास फिर, और फिर हम में हैं कि फ़ाइलों की सूची देखें

148
00:07:10,860 --> 00:07:11,790
इस फ़ोल्डर.

149
00:07:11,790 --> 00:07:15,590
यह मुझे अपने घर के लिए जा रहा अनुरूप है, तो क्लिक

150
00:07:15,590 --> 00:07:19,250
ड्रॉपबॉक्स, और तब सूची यहाँ देख.

151
00:07:19,250 --> 00:07:20,090
>> सही सभी.

152
00:07:20,090 --> 00:07:22,220
तो हम कहते हैं -

153
00:07:22,220 --> 00:07:25,640
जब आप लोगों के लिए अपने 1 pset बनाने जा रहे हैं, चलो एक बनाने के

154
00:07:25,640 --> 00:07:27,390
निर्देशिका pset1 बुलाया.

155
00:07:27,390 --> 00:07:32,170
तो हम ड्रॉपबॉक्स में सही अब कर रहे हैं, जैसा कि आप यह देख सकते हैं

156
00:07:32,170 --> 00:07:32,700
यहाँ शीघ्र.

157
00:07:32,700 --> 00:07:34,320
तो चलो एक निर्देशिका बनाने.

158
00:07:34,320 --> 00:07:37,940
Mkdir तो, चलो यह pset1 कहते हैं.

159
00:07:40,470 --> 00:07:43,500
और इसलिए अब फिर से अगर हम रास, हम तो

160
00:07:43,500 --> 00:07:45,390
देखना है कि pset1 प्रकट होता है.

161
00:07:45,390 --> 00:07:49,470
और यदि ऐसा है तो हम pset1 अंदर जाना चाहते हैं, तो हम अंदर जा सकते हैं

162
00:07:49,470 --> 00:07:54,230
कमांड सीडी के साथ कि फ़ोल्डर.

163
00:07:54,230 --> 00:07:54,610
सही सभी.

164
00:07:54,610 --> 00:07:59,040
तो फिर, चलो देखते हैं कि हम अगर -

165
00:07:59,040 --> 00:08:01,620
का कहना है कि इसे दूसरे तरीके से करते हैं.

166
00:08:01,620 --> 00:08:03,550
यह सिर्फ इतना कह "बनाएँ अनुरूप है

167
00:08:03,550 --> 00:08:05,330
एक नया फ़ोल्डर, pset1.

168
00:08:05,330 --> 00:08:08,530
लेकिन जैसा कि आप पाते हैं, तो आप के साथ बातचीत हो जाएगा

169
00:08:08,530 --> 00:08:09,310
टर्मिनल एक बहुत.

170
00:08:09,310 --> 00:08:11,900
कभी कभी तो यह एक बहुत आसान है, एक करने के लिए तेजी से खो दिया है बस

171
00:08:11,900 --> 00:08:15,900
चीजों के उन प्रकार के कर के लिए टर्मिनल में काम करते हैं.

172
00:08:15,900 --> 00:08:16,140
ठीक है.

173
00:08:16,140 --> 00:08:18,150
और फिर इन अन्य आज्ञाओं.

174
00:08:18,150 --> 00:08:20,410
वहाँ एक फाइल हटाने के लिए एक rm है.

175
00:08:20,410 --> 00:08:22,690
तो आप बस rm लिखें और फिर के नाम

176
00:08:22,690 --> 00:08:23,800
इसे नष्ट करने फ़ाइल.

177
00:08:23,800 --> 00:08:25,810
हम है कि बाद के कुछ उदाहरण में जाऊँगा.

178
00:08:25,810 --> 00:08:28,840
और फिर हम आदमी आदेश कुछ कहा जाता है, जो है

179
00:08:28,840 --> 00:08:31,850
समारोह के एक प्रकार के लिए एक मैनुअल लाता है.

180
00:08:31,850 --> 00:08:34,419
फिर, मैं बाद में उस के एक वास्तविक उदाहरण लाती हूँ.

181
00:08:37,360 --> 00:08:39,900
>> तो एक और बहुत महत्वपूर्ण उपकरण है, के रूप में मैं संक्षेप में उल्लेख किया

182
00:08:39,900 --> 00:08:41,280
पहले, शैली है.

183
00:08:41,280 --> 00:08:43,650
तो अनिवार्य रूप से, शैली पठनीयता के साथ क्या करना है.

184
00:08:43,650 --> 00:08:46,460
किसी और पढ़ने के लिए, का पालन करने में सक्षम हो जाएगा, और

185
00:08:46,460 --> 00:08:47,670
अपने कोड को समझते हैं?

186
00:08:47,670 --> 00:08:50,490
यह आप के लिए विशेष रूप से महत्वपूर्ण है, अपने आप को वास्तव में,.

187
00:08:50,490 --> 00:08:53,060
यदि आप देर कोडिंग रह रहे हैं, और फिर बाद में आप पर

188
00:08:53,060 --> 00:08:55,940
वापस जाने के लिए और आप की तरह कर रहे हैं, यह क्या चर क्या मतलब है?

189
00:08:55,940 --> 00:08:58,400
कहते हैं, आप किसी के साथ एक समूह की परियोजना पर काम कर रहे हैं, तो आप और

190
00:08:58,400 --> 00:09:00,130
दोनों एक दूसरे के कोड को देखने के लिए है.

191
00:09:00,130 --> 00:09:03,380
यह वास्तव में महत्वपूर्ण है कि आप अपने चर सही ढंग से नाम

192
00:09:03,380 --> 00:09:06,240
और यह अच्छी लग रही है कि क्योंकि सभी फर्क पड़ता है.

193
00:09:06,240 --> 00:09:08,270
लेकिन सब से ऊपर तो, हम एक कोर्स में अभी रहे हैं.

194
00:09:08,270 --> 00:09:10,660
तो CS50 के हित के लिए और विशेष रूप से आपके लिए

195
00:09:10,660 --> 00:09:13,010
शिक्षण साथियों और ग्रेडर जो अपने पर लग जाएगा

196
00:09:13,010 --> 00:09:15,455
psets, कृपया, सही शैली का उपयोग करें.

197
00:09:15,455 --> 00:09:18,980
और अपने शिक्षण साथियों काफी खुश हो जाएगा.

198
00:09:18,980 --> 00:09:22,890
तो फिर, शैली चीजों को सही ढंग से indenting भी शामिल है,

199
00:09:22,890 --> 00:09:26,380
विशेष रूप से अपने ब्रेसिज़ का उपयोग कर और उन indenting.

200
00:09:26,380 --> 00:09:29,910
चर कुछ समझ में आता है कि नामकरण.

201
00:09:29,910 --> 00:09:32,330
अभी हम परंपरा का पालन करें जब आप

202
00:09:32,330 --> 00:09:35,240
अपने चर नाम में कई शब्दों, आप तो

203
00:09:35,240 --> 00:09:37,480
उन्हें एक अधोडैस के साथ कनेक्ट करने के लिए, जैसा कि आप में देख

204
00:09:37,480 --> 00:09:39,660
उदाहरण के नाम है.

205
00:09:39,660 --> 00:09:41,740
>> फिर अंत में, कुछ जादुई संख्या कहा जाता है.

206
00:09:41,740 --> 00:09:48,030
मूलतः, जब आप कोड के माध्यम से पढ़ रहे हैं और कहते हैं

207
00:09:48,030 --> 00:09:51,570
आप एक चर है -

208
00:09:51,570 --> 00:09:56,680
कहते हैं, आप एक चर नहीं है, लेकिन बस ठीक कहना है, जब तक इस तरह के

209
00:09:56,680 --> 00:09:58,600
और इस तरह के कम से कम 10 है.

210
00:09:58,600 --> 00:10:00,210
फिर अपने ग्रेडर अच्छी तरह से जाना, प्रतीक्षा की जा रही है,

211
00:10:00,210 --> 00:10:01,320
जहां 10 से आया?

212
00:10:01,320 --> 00:10:05,040
तो सच में समझा अपने आप को एक बहुत मायने रखती है.

213
00:10:05,040 --> 00:10:06,740
टिप्पणी करने के लिए मदद से आप अपने आप को समझाने के लिए है.

214
00:10:06,740 --> 00:10:09,850
टिप्पणियां शायद सबसे महत्वपूर्ण बात कर रहे हैं में शामिल

215
00:10:09,850 --> 00:10:11,460
अपने कार्यक्रमों.

216
00:10:11,460 --> 00:10:15,440
और यह मदद करता है आप केवल वास्तव में समझाने के लिए नहीं -

217
00:10:15,440 --> 00:10:17,220
यह मदद करता है कि आप की तरह के रूप में अपने तर्क की व्याख्या

218
00:10:17,220 --> 00:10:17,870
आप के साथ जा रहे हैं.

219
00:10:17,870 --> 00:10:20,480
और इसलिए अगर आप ऐसा कर, फिर से, यह एक बहुत आसान हो जा रहा है

220
00:10:20,480 --> 00:10:23,370
अपने कोड और की तरह में वापस जाने समझते हैं कि आप क्या कर रहे हैं

221
00:10:23,370 --> 00:10:24,080
वहाँ कर रहे हैं.

222
00:10:24,080 --> 00:10:26,410
फिर, ग्रेडर वास्तव में टिप्पणी करना.

223
00:10:26,410 --> 00:10:28,940
तो आप अच्छी तरह से टिप्पणी करने के लिए और -

224
00:10:28,940 --> 00:10:29,970
मुफ्त अंक की तरह की तरह.

225
00:10:29,970 --> 00:10:32,340
और जो मुक्त अंक पसंद नहीं है?

226
00:10:32,340 --> 00:10:33,910
तुम भी बहु - रेखा टिप्पणियाँ हो सकता है.

227
00:10:33,910 --> 00:10:36,630
और इसलिए मैं ऊपर टेम्पलेट के एक प्रकार के शामिल हैं.

228
00:10:36,630 --> 00:10:38,580
मूलतः, आम तौर पर इन आपके के शीर्ष पर उपयोग किया जाता है

229
00:10:38,580 --> 00:10:40,950
कार्यक्रम की तरह सामान्य रूप में समझाने के लिए क्या

230
00:10:40,950 --> 00:10:43,220
अपनी समस्या सेट करता है.

231
00:10:43,220 --> 00:10:46,130
आपका नाम, तारीख, वगैरह शामिल करें.

232
00:10:46,130 --> 00:10:49,030
और ऐसा है, के रूप में मैं बहु - रेखा इस टिप्पणी में कहा,

233
00:10:49,030 --> 00:10:56,260
manual.cs50.net/style_guide अधिक सुझावों और नियमों के बारे में है

234
00:10:56,260 --> 00:10:59,310
loops, वगैरह के लिए शैली.

235
00:10:59,310 --> 00:10:59,740
>> ठीक है.

236
00:10:59,740 --> 00:11:03,600
तो अब है कि मैं तुम्हें बता दिया शैली के बारे में एक छोटे से, चलो देखते हैं

237
00:11:03,600 --> 00:11:07,390
इस में कार्रवाई.

238
00:11:07,390 --> 00:11:07,770
सही सभी.

239
00:11:07,770 --> 00:11:11,850
तो यहाँ, टॉमी हमें एक delightfully भयानक लिखा है

240
00:11:11,850 --> 00:11:15,440
शैली के एक कार्यक्रम में उदाहरण है.

241
00:11:15,440 --> 00:11:17,170
तो आप यहाँ देख कर, सब ठीक है.

242
00:11:17,170 --> 00:11:18,280
यह वास्तव में सब ठीक है.

243
00:11:18,280 --> 00:11:22,060
आप बहु - रेखा टिप्पणी यहाँ देखें.

244
00:11:22,060 --> 00:11:25,120
आप इसे एक आगे स्लेश और फिर दो तारक के साथ शुरू करते हैं.

245
00:11:25,120 --> 00:11:28,580
आप के साथ जारी रखने, रेखा के साथ तारांकनों aligning

246
00:11:28,580 --> 00:11:30,540
और फिर इसे एक तारांकन और एक स्लेश के साथ खत्म होता है.

247
00:11:30,540 --> 00:11:30,810
सही सभी.

248
00:11:30,810 --> 00:11:32,800
तो यह है कि ठीक है.

249
00:11:32,800 --> 00:11:33,760
यहाँ यह ठीक है.

250
00:11:33,760 --> 00:11:35,110
वह अपने पुस्तकालयों सहित है.

251
00:11:35,110 --> 00:11:38,790
लेकिन फिर वह यहाँ कई लाइनों फैले टिप्पणी की है.

252
00:11:38,790 --> 00:11:40,390
इस के साथ गलत चीजों के बहुत सारे हैं.

253
00:11:40,390 --> 00:11:44,770
कई लाइनों फैले टिप्पणियां, यहीं वह इस्तेमाल कर रहा है

254
00:11:44,770 --> 00:11:47,230
बस एक लाइन टिप्पणी के लिए वाक्यविन्यास.

255
00:11:47,230 --> 00:11:53,140
उन्होंने यह भी एक ही टिप्पणी में सब कुछ melding.

256
00:11:53,140 --> 00:11:54,715
तो हम से बचने के लिए करना चाहते हैं.

257
00:11:57,710 --> 00:12:03,010
यहाँ तो हम देखते हैं कि इन ब्रेसिज़, उदाहरण के लिए, सभी कर रहे हैं

258
00:12:03,010 --> 00:12:03,730
जगह पर.

259
00:12:03,730 --> 00:12:06,950
खरोज गलत है.

260
00:12:06,950 --> 00:12:09,460
यह वास्तव में आप नहीं दिखा करता है निश्चित जहां कुछ

261
00:12:09,460 --> 00:12:12,850
शुरू होता है और समाप्त होता है एक और बात.

262
00:12:12,850 --> 00:12:16,510
तब के रूप में अच्छी तरह से, हम देखते हैं वह एक परिभाषित चर i = 5 यहाँ है.

263
00:12:16,510 --> 00:12:18,620
लेकिन फिर इस चार कहीं से भी बाहर आता है, और वहाँ कोई नहीं है

264
00:12:18,620 --> 00:12:21,520
टिप्पणी करने के लिए वास्तव में समझाने के लिए कहाँ से आता.

265
00:12:21,520 --> 00:12:22,130
>> ठीक है.

266
00:12:22,130 --> 00:12:28,760
तो अब चलो कुछ है कि वास्तव में सिर्फ एक ही है पर देखो

267
00:12:28,760 --> 00:12:30,250
बेहतर शैली के साथ छोड़कर कोड.

268
00:12:30,250 --> 00:12:32,485
तो फिर, यह अच्छा शैली का उदाहरण है,

269
00:12:32,485 --> 00:12:33,735
उदाहरण बहु - रेखा.

270
00:12:38,400 --> 00:12:39,735
और फिर यहाँ यह काफी साफ है.

271
00:12:39,735 --> 00:12:43,500
हम देखते हैं कि वह एक बयान अगर यहाँ शुरू होता है, एक नया प्रवेश करती है

272
00:12:43,500 --> 00:12:46,400
लाइन, एक खुले गले है.

273
00:12:46,400 --> 00:12:48,740
फिर वह एक खरोज है.

274
00:12:48,740 --> 00:12:50,970
वह इस खरोज रहता है -

275
00:12:50,970 --> 00:12:54,680
वह पूरी भर में इस संकेत वर्दी रहता है

276
00:12:54,680 --> 00:12:59,120
कार्यक्रम और वास्तव में पता चलता है जब कोड का एक ब्लॉक शुरू होता है, जब

277
00:12:59,120 --> 00:13:00,780
कोड का एक ब्लॉक समाप्त हो जाती है.

278
00:13:00,780 --> 00:13:04,410
यह हमारे हिस्से पर एक छोटे से nitpicky लग शुरू करने के लिए कर सकते हैं

279
00:13:04,410 --> 00:13:06,370
साथ है, लेकिन आप के रूप में आप अपने कोड लिख रहे हैं देखेंगे.

280
00:13:06,370 --> 00:13:09,400
यह वास्तव में उपयोगी है इस बाहर अलग करने में सक्षम हो.

281
00:13:09,400 --> 00:13:12,200
और फिर, अपने ग्रेडर वास्तव में यह पसंद है.

282
00:13:12,200 --> 00:13:14,360
और इसलिए तुम सिर्फ एक संख्या में डालने की बजाय देखते हैं,

283
00:13:14,360 --> 00:13:17,510
वहाँ, वह वास्तव में चर पुनरावृत्तियों का नाम.

284
00:13:17,510 --> 00:13:20,160
और इसलिए हम वास्तव में इस कोड में नहीं देख रहे हैं सही अब

285
00:13:20,160 --> 00:13:22,450
लेकिन बस का एक उदाहरण देखने की तरह

286
00:13:22,450 --> 00:13:23,780
अच्छा बनाम बुरा शैली.

287
00:13:23,780 --> 00:13:29,610
और यदि ऐसा है तो आप उन्हें कंधे से कंधा मिलाकर देखो, क्या तुम करोगी

288
00:13:29,610 --> 00:13:32,910
निश्चित रूप से करने के लिए सही पर एक पढ़ने के लिए पसंद करते हैं.

289
00:13:39,230 --> 00:13:40,100
>> सही सभी.

290
00:13:40,100 --> 00:13:42,710
पहले तो एक आखिरी बात हम के असली मांस में गोता

291
00:13:42,710 --> 00:13:46,260
pset कैसे संकलन और अपने कोड चलाने.

292
00:13:46,260 --> 00:13:50,320
और इसलिए अनिवार्य रूप से जब आप लिखने के सी, कि वास्तव में नहीं है

293
00:13:50,320 --> 00:13:52,480
वास्तविक मशीन कोड, zeroes और में अनुवाद

294
00:13:52,480 --> 00:13:56,000
लोगों को है कि मशीन वास्तव में पढ़ने और व्याख्या कर सकते हैं.

295
00:13:56,000 --> 00:13:57,170
इसलिए हम कुछ है -

296
00:13:57,170 --> 00:13:59,340
बजना एक संकलक कि हम सी. के लिए उपयोग है

297
00:13:59,340 --> 00:14:00,270
वहाँ कई compilers हैं.

298
00:14:00,270 --> 00:14:02,480
लेकिन CS50 में, हम बजना का उपयोग कर सकता हूँ.

299
00:14:02,480 --> 00:14:05,480
और इसलिए बजना मूल रूप से सी से मशीन अनुवाद

300
00:14:05,480 --> 00:14:07,380
आप के लिए कोड.

301
00:14:07,380 --> 00:14:10,170
तो चलो एक उदाहरण देखें - उपकरण में गोता.

302
00:14:14,550 --> 00:14:15,030
सही सभी.

303
00:14:15,030 --> 00:14:16,670
इसलिए अभी हम हमारे घर निर्देशिका में कर रहे हैं.

304
00:14:16,670 --> 00:14:18,680
हम वास्तव में नहीं कर रहे हैं, जहां किसी भी कोड है.

305
00:14:18,680 --> 00:14:24,740
तो चलो हमारी निर्देशिका Dropbox/walkthrough1 के लिए बदलने के लिए, जहां

306
00:14:24,740 --> 00:14:25,930
मैं कुछ कोड संग्रहित किया है.

307
00:14:25,930 --> 00:14:29,340
तो अगर हम रास प्रेस, तो हम देखते हैं कि मैं एक

308
00:14:29,340 --> 00:14:31,230
यहाँ में फ़ाइलों की जोड़ी.

309
00:14:31,230 --> 00:14:31,700
>> सही सभी.

310
00:14:31,700 --> 00:14:35,280
तो मैं पहले से ही hello.c लिखा है, तो हम यह संकलन

311
00:14:35,280 --> 00:14:36,670
और फिर देखते हैं कि यह क्या करता है.

312
00:14:36,670 --> 00:14:43,150
तो एक बुनियादी संकलन आदेश तो hello.c बजना होगा,

313
00:14:43,150 --> 00:14:46,910
ठीक कह रही है, अनिवार्य रूप से मेरे लिए hello.c संकलन.

314
00:14:46,910 --> 00:14:50,550
मैं दर्ज करें, सही चले गए हैं लगता है.

315
00:14:50,550 --> 00:14:52,590
चलो रास फिर क्लिक करें.

316
00:14:52,590 --> 00:14:55,230
इस a.out फ़ाइल अब पता चला है.

317
00:14:55,230 --> 00:14:57,430
और इसलिए a.out एक निष्पादन योग्य फ़ाइल है.

318
00:14:57,430 --> 00:15:05,330
तो इसे चलाने के लिए, आप एक / a.out करते हैं.

319
00:15:05,330 --> 00:15:07,650
और इसलिए हम उस इस hello.c जाहिरा तौर पर कार्यक्रम देखना

320
00:15:07,650 --> 00:15:10,400
हैलो पांच बार बाहर प्रिंट.

321
00:15:10,400 --> 00:15:10,990
सही सभी.

322
00:15:10,990 --> 00:15:14,250
लेकिन कहते हैं कि हम नाम a.out उपयोग नहीं करना चाहते.

323
00:15:18,140 --> 00:15:21,080
उदाहरण के लिए, हम हैलो कार्यक्रम चलाना चाहते हैं कि क्योंकि

324
00:15:21,080 --> 00:15:22,540
यह समझने के लिए आसान बनाता है.

325
00:15:22,540 --> 00:15:26,590
तो चलो बजना hello.c कहते हैं, और तो अनिवार्य रूप से आप की जरूरत

326
00:15:26,590 --> 00:15:29,030
लिए कुछ झंडे बुलाया बातों में से गुजरती हैं.

327
00:15:29,030 --> 00:15:31,600
तो ठीक कह रही है, मैं अच्छी तरह से करने के लिए यह कुछ और के नाम करना चाहते हैं.

328
00:15:31,600 --> 00:15:33,900
तुम भी विभिन्न झंडे का एक बहुत में पारित कर सकते हैं,

329
00:15:33,900 --> 00:15:34,620
जो आप देखेंगे.

330
00:15:34,620 --> 00:15:37,510
तो आपको लगता है कि एक कार्यक्रम कुछ नामकरण के लिए ध्वज

331
00:15:37,510 --> 00:15:39,780
है - ओ करना चाहते हैं.

332
00:15:39,780 --> 00:15:42,470
ओ के बाद, आप प्रोग्राम का नाम लिखें.

333
00:15:42,470 --> 00:15:44,090
चलो बस यह कॉल हैलो.

334
00:15:44,090 --> 00:15:49,050
>> तो अब हम देखते हैं कि हम वास्तव में एक नमस्ते निष्पादन योग्य फ़ाइल है.

335
00:15:49,050 --> 00:15:54,020
इसलिए हम इसे चलाने के लिए कर सकते हैं और यह पहले के रूप में एक ही बात करता है.

336
00:15:54,020 --> 00:15:56,210
तो अब है कि हम हैलो है, हम भी के लिए दूर कर सकते हैं,

337
00:15:56,210 --> 00:15:57,450
उदाहरण के लिए, हमारे a.out.

338
00:15:57,450 --> 00:16:03,880
तो हटायें, a.out के लिए rm, अपने टर्मिनल prompt जाएगा आप से पूछना,

339
00:16:03,880 --> 00:16:05,470
के लिए आप इस बात की पुष्टि करने के लिए कि क्या आप वास्तव में चाहते हैं

340
00:16:05,470 --> 00:16:06,370
इसे हटा दें या नहीं.

341
00:16:06,370 --> 00:16:10,000
हम हाँ के लिए y का कहना है.

342
00:16:10,000 --> 00:16:10,750
और हम वहाँ जाओ.

343
00:16:10,750 --> 00:16:12,220
A.out चला गया है.

344
00:16:12,220 --> 00:16:12,620
सही सभी.

345
00:16:12,620 --> 00:16:14,810
लेकिन कभी कभी यह सब याद भ्रमित हो जाता है

346
00:16:14,810 --> 00:16:17,160
झंडे कि हम शामिल करने के लिए और बाहर बजना टाइप करने की जरूरत है.

347
00:16:17,160 --> 00:16:20,410
और जैसा कि हम देखते हैं जब हम और अधिक जटिल प्रोग्राम का उपयोग कर रहे हैं, हम करेंगे

348
00:16:20,410 --> 00:16:22,450
विभिन्न पुस्तकालयों सहित.

349
00:16:22,450 --> 00:16:27,230
और इसलिए बजना के लिए हमारे कमांड अब और समय मिल जाएगा.

350
00:16:27,230 --> 00:16:30,660
तो CS50 उपकरण में शामिल है बनाने के आदेश.

351
00:16:30,660 --> 00:16:33,880
तो आप बस नमस्ते लिखें.

352
00:16:33,880 --> 00:16:35,130
उफ़!

353
00:16:36,860 --> 00:16:38,400
हम पहले से ही इस निष्पादन योग्य फ़ाइल बनाया है.

354
00:16:38,400 --> 00:16:39,650
तो मुझे सिर्फ यह जल्दी से हटा.

355
00:16:42,260 --> 00:16:44,830
अब चलो टाइप बनाने हैलो.

356
00:16:44,830 --> 00:16:49,470
और आप इस लाइन में देखना है कि अनिवार्य रूप से कह रही हैं

357
00:16:49,470 --> 00:16:54,760
हैलो इन आदेशों के सभी शामिल है कि

358
00:16:54,760 --> 00:16:55,580
आप के लिए इसे में जाओ.

359
00:16:55,580 --> 00:16:58,080
>> तो CS50 उपकरण में शामिल है बनाने फ़ाइल है.

360
00:16:58,080 --> 00:17:02,300
तो बस जब आप एक फ़ाइल name.c है, तो आप सब करते हैं

361
00:17:02,300 --> 00:17:03,680
फ़ाइल नाम कहते हैं.

362
00:17:03,680 --> 00:17:04,800
और फिर आप एक निष्पादन होगा

363
00:17:04,800 --> 00:17:06,200
उस नाम के साथ फ़ाइल.

364
00:17:06,200 --> 00:17:06,675
हाँ?

365
00:17:06,675 --> 00:17:09,525
>> 1 अध्यक्ष: अपने कंप्यूटर के लिए, बजना के बजाय यह जीसीसी कहते हैं.

366
00:17:09,525 --> 00:17:11,910
की तरह है कि -

367
00:17:11,910 --> 00:17:12,109
ZAMYLA चान: हाँ.

368
00:17:12,109 --> 00:17:15,700
तो अपने कंप्यूटर जीसीसी के रूप में विरोध बजना करने के लिए कह सकता है, क्योंकि

369
00:17:15,700 --> 00:17:18,180
जीसीसी संकलक का एक प्रकार है.

370
00:17:18,180 --> 00:17:20,460
यदि आप CS50 उपकरण में कर रहे हैं, हालांकि यह तो

371
00:17:20,460 --> 00:17:21,810
बजना का उपयोग किया जाना चाहिए.

372
00:17:24,619 --> 00:17:27,880
यदि ऐसा नहीं है, तो शायद मुझे बाद में बात आने या पोस्ट

373
00:17:27,880 --> 00:17:29,595
CS50 पर चर्चा और हम उस सुलझा सकते.

374
00:17:34,510 --> 00:17:35,710
>> सही सभी.

375
00:17:35,710 --> 00:17:39,250
तो अब है कि हम बुनियादी उपकरण के नीचे हमारे तरह है, हम तो

376
00:17:39,250 --> 00:17:43,060
मारियो में गोता लगा सकता हूँ.

377
00:17:43,060 --> 00:17:43,550
ठीक है.

378
00:17:43,550 --> 00:17:47,360
तो मारियो अनिवार्य रूप से जहाँ हम को होने जा रहे एक कार्यक्रम है

379
00:17:47,360 --> 00:17:50,800
हमारे मारियो की आदिम संस्करण की ही तरह बनाने

380
00:17:50,800 --> 00:17:51,410
खेल पृष्ठभूमि.

381
00:17:51,410 --> 00:17:54,790
तुम्हें पता है, मारियो आमतौर पर एक पाइप और एक है

382
00:17:54,790 --> 00:17:55,670
पेड़ और कुछ ब्लॉकों.

383
00:17:55,670 --> 00:17:59,390
और फिर वहाँ आधे पिरामिड की तरह है.

384
00:17:59,390 --> 00:18:02,100
तो हम बस है कि आधे पिरामिड पर ध्यान केंद्रित किया जा रहे हैं,

385
00:18:02,100 --> 00:18:05,350
कोड है कि यह इस तरह के प्रकार के लिए hashes प्रिंट

386
00:18:05,350 --> 00:18:07,500
इस प्रारूप में ब्लॉक के.

387
00:18:07,500 --> 00:18:10,800
तो क्या होगा है एक निश्चित उपयोगकर्ता इनपुट

388
00:18:10,800 --> 00:18:13,130
पिरामिड की ऊंचाई, और फिर आपको लगता है कि मुद्रित करने के लिए बाहर हूँ

389
00:18:13,130 --> 00:18:17,410
ऐसी है कि नीचे हैश छोड़ दिया -

390
00:18:17,410 --> 00:18:21,270
यहाँ तो बहुत नीचे सही है कि एक पंक्ति में होगा

391
00:18:21,270 --> 00:18:23,820
अपने टर्मिनल के नीचे छोड़ दिया.

392
00:18:26,720 --> 00:18:27,360
ठीक है.

393
00:18:27,360 --> 00:18:29,860
>> तो पहली बात यह है कि आप की जरूरत है -

394
00:18:29,860 --> 00:18:33,120
पहली छोटी मिनी समस्या है कि हम से निपटने की जरूरत है

395
00:18:33,120 --> 00:18:34,640
उपयोगकर्ता इनपुट मिल.

396
00:18:34,640 --> 00:18:40,020
तो हम साथ काम किया जा उपयोगकर्ता जानकारी की जरूरत है और फिर

397
00:18:40,020 --> 00:18:41,060
उत्पादन वहाँ चीजों की तरह.

398
00:18:41,060 --> 00:18:47,630
तो चलो एक apples.c लिखा था कि मैं बुलाया फ़ाइल देखो देखो

399
00:18:47,630 --> 00:18:52,670
कि निविष्टियाँ और outputs के साथ संबंधित है.

400
00:18:52,670 --> 00:18:53,240
ठीक है.

401
00:18:53,240 --> 00:18:55,970
तो यहाँ शीर्ष पर, मैं पुस्तकालयों के कुछ शामिल है

402
00:18:55,970 --> 00:18:56,540
जरूरत है कि मैं.

403
00:18:56,540 --> 00:19:00,700
वास्तव में महत्वपूर्ण यहाँ एक stdio है (मानक आई / ओ). सौदों की है कि

404
00:19:00,700 --> 00:19:02,760
मानक निविष्टियाँ और outputs के साथ क्योंकि हम जा रहे हैं

405
00:19:02,760 --> 00:19:04,600
उपयोगकर्ता जानकारी के साथ काम कर रहे हैं.

406
00:19:04,600 --> 00:19:04,960
सही सभी.

407
00:19:04,960 --> 00:19:06,660
तो फिर मैं अपने मुख्य कार्य शुरू.

408
00:19:06,660 --> 00:19:11,310
और फिर मैं उपयोगकर्ता पूछने के लिए ठीक है, कितने सेब तुम्हें क्या ज़रूरत है?

409
00:19:11,310 --> 00:19:13,650
यहाँ तो सही है, इस लाइन क्या करता है -

410
00:19:13,650 --> 00:19:18,420
मैं GetInt के मूल्य के लिए मैं चर असाइन करें.

411
00:19:18,420 --> 00:19:22,890
>> तो GetInt एक समारोह में कहा कि stdio में शामिल है.

412
00:19:22,890 --> 00:19:26,090
और इसलिए अनिवार्य रूप से, कि आप के लिए इसके साथ सौदा होगा.

413
00:19:26,090 --> 00:19:27,900
यह एक int के लिए उपयोगकर्ता prompt जाएगा.

414
00:19:27,900 --> 00:19:30,600
जो कुछ भी वे लौटने के लिए, वह करने के लिए आवंटित किया जाएगा

415
00:19:30,600 --> 00:19:32,020
मैं चर.

416
00:19:32,020 --> 00:19:35,620
और इतना तो यह सिर्फ एक छोटा सा प्रोग्राम है कि कम हो जाती है

417
00:19:35,620 --> 00:19:39,160
मैं 1 से मूल्य और फिर बाहर नए मूल्य प्रिंट.

418
00:19:39,160 --> 00:19:42,420
वास्तव में जी - एडिट के बारे में एक अच्छी बात यह है कि वहाँ एक मिनी

419
00:19:42,420 --> 00:19:43,720
यहाँ में टर्मिनल सही.

420
00:19:43,720 --> 00:19:46,670
तो बजाय बीच आगे और पीछे स्विच करने

421
00:19:46,670 --> 00:19:48,120
जीएडिट और टर्मिनल, तुम वास्तव में कर सकते हैं

422
00:19:48,120 --> 00:19:49,100
बस इसे यहाँ से चला रहे हैं.

423
00:19:49,100 --> 00:19:52,070
तो पहले हम सही निर्देशिका में मिलता है.

424
00:19:52,070 --> 00:19:54,230
तो चलो हमारी निर्देशिका में परिवर्तन

425
00:19:54,230 --> 00:19:55,480
Dropbox/walkthrough1.

426
00:19:57,160 --> 00:19:57,840
सही सभी.

427
00:19:57,840 --> 00:20:03,400
इसलिये अब सेब बनाने, यह हमारे लिए compiles.

428
00:20:03,400 --> 00:20:06,640
और इसलिए अब हम सेब चलाने के.

429
00:20:06,640 --> 00:20:08,420
हम कितने सेब है?

430
00:20:08,420 --> 00:20:09,630
मैं कहना है कि मैं 3 है.

431
00:20:09,630 --> 00:20:12,060
और यह कहते हैं और कहते हैं, "मैं mwahaha उनमें से एक खाने के लिए जा रहा हूँ"

432
00:20:12,060 --> 00:20:13,610
"अब तुम 2 सेब है.

433
00:20:13,610 --> 00:20:14,220
>> सही सभी.

434
00:20:14,220 --> 00:20:16,390
तो चलो फिर से चलाने के.

435
00:20:16,390 --> 00:20:19,040
और हम कहते हैं कि मैं एक सेब है.

436
00:20:19,040 --> 00:20:19,940
अब मैं 0 सेब है.

437
00:20:19,940 --> 00:20:20,180
ठीक है.

438
00:20:20,180 --> 00:20:22,460
तो इस कार्यक्रम के रूप में काम करने की उम्मीद है.

439
00:20:22,460 --> 00:20:25,070
हम एक संख्या इनपुट, यह 1 से कम हो जाती है, और फिर

440
00:20:25,070 --> 00:20:27,290
इसे फिर से प्रिंट बाहर.

441
00:20:27,290 --> 00:20:31,950
लेकिन क्या अगर, उदाहरण के लिए, मैं -1 सेब है?

442
00:20:31,950 --> 00:20:33,440
यह काफी समझ नहीं पड़ता है.

443
00:20:33,440 --> 00:20:37,430
लेकिन यह अभी भी एक पूर्णांक है, तो प्रोग्राम यह स्वीकार करता है.

444
00:20:37,430 --> 00:20:41,090
और इसलिए यह आगे भी नकारात्मक संख्या देता है.

445
00:20:41,090 --> 00:20:44,700
तो यह है कि हमारे लिए एक सबक है कि भले ही GetInt

446
00:20:44,700 --> 00:20:46,700
समारोह और इस तरह के रूप में जुड़े अन्य लोगों

447
00:20:46,700 --> 00:20:48,260
GetFloat या GetString -

448
00:20:48,260 --> 00:20:51,490
भले ही उन हमें सही डेटा प्रकार मिल जाएगा,

449
00:20:51,490 --> 00:20:55,750
उदाहरण के लिए, अगर मैं सिर्फ इतना कहा था [टाइपिंग]

450
00:20:55,750 --> 00:20:57,380
तो यह मुझे बताओ पुनःप्रयास के लिए होगा.

451
00:20:57,380 --> 00:21:01,860
तो यह जो डेटा अपने इनपुट प्रकार के साथ सौदा होगा

452
00:21:01,860 --> 00:21:04,650
लेकिन जांचें वास्तव में नहीं होगा, ठीक है, यह वास्तव में का एक प्रकार है

453
00:21:04,650 --> 00:21:07,820
मूल्य है कि मैं चाहता हूँ?

454
00:21:07,820 --> 00:21:12,370
तो फिर मारियो का एक हिस्सा है कि उपयोगकर्ता इनपुट के लिए है

455
00:21:12,370 --> 00:21:15,400
संख्या है कि 1/2 पिरामिड की ऊंचाई का प्रतिनिधित्व करता है

456
00:21:15,400 --> 00:21:16,360
कि आप कर रहे हैं.

457
00:21:16,360 --> 00:21:21,000
और अगर ऐसा हो तो हम ऊंचाई के लिए इस उपयोगकर्ता उत्साह रहे हैं तो,

458
00:21:21,000 --> 00:21:25,480
इस पर दो सीमा होना चाहिए.

459
00:21:25,480 --> 00:21:28,040
सही है?

460
00:21:28,040 --> 00:21:31,150
कल्पना में, यह कहना है कि यह 23 से अधिक नहीं होना चाहिए

461
00:21:31,150 --> 00:21:32,630
वर्ण क्योंकि कि मानक की तरह है

462
00:21:32,630 --> 00:21:34,450
टर्मिनल की ऊंचाई.

463
00:21:34,450 --> 00:21:37,590
लेकिन फिर, क्या अन्य बाध्य, शायद एक कम बाध्य हो सकता है,

464
00:21:37,590 --> 00:21:38,840
हम शामिल करना चाहते हैं?

465
00:21:41,180 --> 00:21:44,350
>> यदि हम वास्तव में वापस सोच की एक पिरामिड की तरह, चित्रकारी कर रहे हैं

466
00:21:44,350 --> 00:21:48,460
कैसे एक पिरामिड उच्च हो सकता है, यह कभी एक की तुलना में कम हो सकता है

467
00:21:48,460 --> 00:21:49,132
निश्चित संख्या है?

468
00:21:49,132 --> 00:21:50,490
2 स्पीकर: तीन से बड़ा है.

469
00:21:50,490 --> 00:21:50,560
ZAMYLA चान: हम्म?

470
00:21:50,560 --> 00:21:52,630
2 स्पीकर: तीन से बड़ा है.

471
00:21:52,630 --> 00:21:54,850
ZAMYLA चान: यह एक अच्छी बात है.

472
00:21:54,850 --> 00:21:57,860
यह हो सकता है -

473
00:21:57,860 --> 00:22:00,700
हम इसे सिर्फ एक तीन स्तर पिरामिड के लिए विवश करना चाहते हो सकता है.

474
00:22:00,700 --> 00:22:02,120
लेकिन चलो लगता है -

475
00:22:02,120 --> 00:22:06,510
चलो एक एक पिरामिड के रूप में एक हैश तालिका की गिनती की तरह भी कहते हैं.

476
00:22:06,510 --> 00:22:09,031
तो फिर हमारे वास्तविक कम बाध्य क्या होना चाहिए?

477
00:22:12,260 --> 00:22:13,760
सेब के लिए वापस सोच, हम एक नहीं करना चाहती

478
00:22:13,760 --> 00:22:15,020
नकारात्मक ऊंचाई पिरामिड.

479
00:22:15,020 --> 00:22:15,460
सही है?

480
00:22:15,460 --> 00:22:15,720
ठीक है.

481
00:22:15,720 --> 00:22:19,060
तो जब आप उपयोगकर्ता इनपुट के लिए पूछना है, तो आप के लिए होगा

482
00:22:19,060 --> 00:22:21,980
कि पूर्णांक कि सुनिश्चित करने के कुछ तरह से शामिल

483
00:22:21,980 --> 00:22:24,970
वे आपको प्रदान करने के साथ नकारात्मक क्योंकि आप नहीं कर सकते हैं नहीं है

484
00:22:24,970 --> 00:22:28,180
एक नकारात्मक पिरामिड आकर्षित.

485
00:22:28,180 --> 00:22:28,410
>> ठीक है.

486
00:22:28,410 --> 00:22:30,190
तो वहाँ एक दो तरीके से ऐसा कर रहे हैं.

487
00:22:30,190 --> 00:22:34,420
मूलतः, एक बार आप उपयोगकर्ता इनपुट के लिए पूछते हैं, आप की मांग करने के लिए करना चाहते हैं

488
00:22:34,420 --> 00:22:37,080
कि वे आप सही इनपुट के साथ प्रदान करते हैं.

489
00:22:37,080 --> 00:22:40,120
तो आप की मांग है कि वे तुम्हें एक संख्या के साथ प्रदान करना चाहते हैं

490
00:22:40,120 --> 00:22:46,630
कि नकारात्मक, लेकिन यह भी 24 से कम नहीं है.

491
00:22:46,630 --> 00:22:49,510
तो हम समावेशी शून्य करने के लिए 23, के साथ काम कर रहे हैं.

492
00:22:49,510 --> 00:22:50,070
सही सभी.

493
00:22:50,070 --> 00:22:52,830
तो हम लगातार की मांग करना चाहते हैं -

494
00:22:52,830 --> 00:22:55,720
अगर वे हमें एक मान्य पूर्णांक नहीं दिया है, वे चाहते हैं

495
00:22:55,720 --> 00:22:57,350
लगातार नहीं की मांग.

496
00:22:57,350 --> 00:22:59,770
मुझे एक मान्य इनपुट दे.

497
00:22:59,770 --> 00:23:02,270
मुझे एक वैध ऊंचाई दे.

498
00:23:02,270 --> 00:23:06,970
तो खरोंच में वापस याद है, हम ब्लॉक तक दोहराएँ या था

499
00:23:06,970 --> 00:23:08,950
ब्लॉक यदि हमेशा के लिए.

500
00:23:08,950 --> 00:23:12,345
उन छोरों कि बहुत जबकि पाश के लिए इसी तरह की और कर रहे हैं

501
00:23:12,345 --> 00:23:14,960
करते हैं, जबकि पाश, जो हम में सिर्फ एक दूसरे में मिल जाएगा.

502
00:23:14,960 --> 00:23:19,790
तो, जबकि पाश अनिवार्य रूप से एक शर्त है कि आप की जाँच

503
00:23:19,790 --> 00:23:23,240
कि एक बूलियन मान कि तुम वहाँ अंदर डाल की तरह है,

504
00:23:23,240 --> 00:23:25,740
खरोंच में कोण के साथ ब्लॉक.

505
00:23:25,740 --> 00:23:29,550
यही कारण है कि क्या जबकि पाश के कोष्ठक के अंदर चला जाता है.

506
00:23:29,550 --> 00:23:31,830
तो आप स्थिति के कुछ प्रकार होगा.

507
00:23:31,830 --> 00:23:36,540
और जैसा कि हम सिर्फ पहले चर्चा की, उस हालत

508
00:23:36,540 --> 00:23:40,250
inputted किया गया था कि पूर्णांक की सीमा के साथ क्या करना है.

509
00:23:40,250 --> 00:23:44,040
तो हालत है कि क्या साथ क्या कुछ करना होगा

510
00:23:44,040 --> 00:23:48,600
पूर्णांक उचित सीमा के भीतर है.

511
00:23:48,600 --> 00:23:49,410
>> तो यह है कि एक समय पाश है.

512
00:23:49,410 --> 00:23:52,580
उदाहरण के लिए, आप पूर्णांक के लिए त्वरित और तो कर सकते हैं

513
00:23:52,580 --> 00:23:56,070
लगातार जांच करते समय इस इनपुट मान्य नहीं है.

514
00:23:56,070 --> 00:23:59,810
उदाहरण के लिए, फिर से उत्साह पर रखने के लिए, पूछने पर रखना

515
00:23:59,810 --> 00:24:01,600
एक पूर्णांक के लिए उपयोगकर्ता.

516
00:24:01,600 --> 00:24:03,780
तो यह है कि एक ही रास्ता हो सकता है.

517
00:24:03,780 --> 00:24:06,240
एक और तरीका एक है, हो सकता है जबकि पाश, जो बहुत सकता है

518
00:24:06,240 --> 00:24:10,130
एक क्या करते हैं, जबकि करता है के अलावा एक जबकि पाश के लिए इसी तरह की है -

519
00:24:10,130 --> 00:24:12,600
आप की तरह वाक्यविन्यास द्वारा देख सकते हैं -

520
00:24:12,600 --> 00:24:18,540
यह है कि यह पहले करते हैं और फिर वास्तविक पाश शरीर है.

521
00:24:18,540 --> 00:24:20,280
तब जबकि यह स्थिति है.

522
00:24:20,280 --> 00:24:22,060
तो क्या जबकि loops -

523
00:24:22,060 --> 00:24:25,470
वे के लिए उपयोगी हो क्या है कि वे वास्तव में निष्पादित

524
00:24:25,470 --> 00:24:29,130
कोड कम से कम और एक बार फिर से जाँच करें कि क्या हालत है

525
00:24:29,130 --> 00:24:30,030
या नहीं मिले.

526
00:24:30,030 --> 00:24:32,510
तो अगर आप एक है, जबकि पाश, तो अंदर कर रहे थे अपने

527
00:24:32,510 --> 00:24:35,210
बयान आप एक पूर्णांक के लिए संकेत है क्योंकि आप में हूँ कर सकते हैं

528
00:24:35,210 --> 00:24:37,180
कम से कम करने के लिए उपयोगकर्ता एक बार पूछना है.

529
00:24:37,180 --> 00:24:40,850
और फिर उसके बाद आप उन्हें तुरंत, तो तुम ठीक कह सकते हैं,

530
00:24:40,850 --> 00:24:43,110
अच्छी तरह से एक बार मैं इस किया है, यह वैध है?

531
00:24:43,110 --> 00:24:44,810
अगर ऐसा है, तो आप सिर्फ जा रहा पर रख सकते हैं.

532
00:24:44,810 --> 00:24:47,310
लेकिन अगर ऐसा नहीं है, तो यह सिर्फ एक जबकि नियमित रूप से की तरह कार्य करेंगे

533
00:24:47,310 --> 00:24:49,240
पाश और फिर पूछने पर रखना.

534
00:24:53,590 --> 00:24:54,670
>> ठीक है.

535
00:24:54,670 --> 00:24:57,120
तो हम मारियो करने के लिए वापस आ गए हैं.

536
00:24:57,120 --> 00:25:01,740
इसलिए हम जानते हैं कि कैसे सही उपयोगकर्ता इनपुट के लिए संकेत करने के लिए

537
00:25:01,740 --> 00:25:03,160
सही सीमा के भीतर.

538
00:25:03,160 --> 00:25:07,100
तो अब हम वास्तव में इस आधे पिरामिड आकर्षित करने की आवश्यकता है.

539
00:25:07,100 --> 00:25:08,730
यह सरल पाठ पात्रों की तरह लग रहा है.

540
00:25:08,730 --> 00:25:10,360
तो वास्तव में खुला -

541
00:25:14,280 --> 00:25:17,190
हम सिर्फ एक खिड़की खुली और कहना ठीक है, अच्छी तरह से क्या हुआ अगर मैं थे

542
00:25:17,190 --> 00:25:24,960
वास्तव में इसे स्वयं करने के लिए जा रहा है, एक अपने आप लिखें?

543
00:25:24,960 --> 00:25:25,780
ठीक है.

544
00:25:25,780 --> 00:25:26,910
तो देखते हैं.

545
00:25:26,910 --> 00:25:30,070
चलो उदाहरण के लिए कहते हैं, हम एक पिरामिड है कि बनाना चाहते हैं

546
00:25:30,070 --> 00:25:32,090
बाईं ओर के साथ गठबंधन किया है, तो बस करना होगा -

547
00:25:34,710 --> 00:25:37,750
मारियो में, शीर्ष स्तर एक के बजाय दो ब्लॉकों है.

548
00:25:37,750 --> 00:25:39,080
इसलिए हम दोनों के साथ शुरू करते हैं.

549
00:25:39,080 --> 00:25:40,700
हम क्लिक करें.

550
00:25:40,700 --> 00:25:45,670
हम तीन करते हैं, और फिर दर्ज, चार, पांच.

551
00:25:45,670 --> 00:25:45,980
ठीक है.

552
00:25:45,980 --> 00:25:46,790
तो यह है कि बहुत आसान है.

553
00:25:46,790 --> 00:25:50,210
सिवाय इस समस्या सेट में, हम वास्तव में चाहते हैं के साथ संरेखित

554
00:25:50,210 --> 00:25:52,250
हमारे स्क्रीन के दाईं ओर.

555
00:25:52,250 --> 00:25:52,630
सही सभी.

556
00:25:52,630 --> 00:25:58,870
तो, कैसे एक आप वास्तव में यह है कि इस तरह के टाइप हो सकता है

557
00:25:58,870 --> 00:26:01,810
यह सही साथ गठबंधन है?

558
00:26:01,810 --> 00:26:08,550
1 हैश डालने की बजाय, कैसे आप की तरह हो सकता है

559
00:26:08,550 --> 00:26:10,040
इसे ले जाने के साथ?

560
00:26:10,040 --> 00:26:11,360
3 अध्यक्ष: एक पंक्ति लिखें?

561
00:26:11,360 --> 00:26:11,800
ZAMYLA चान: हम्म?

562
00:26:11,800 --> 00:26:13,030
3 अध्यक्ष: एक पंक्ति लिखें?

563
00:26:13,030 --> 00:26:13,110
ZAMYLA चान: हाँ.

564
00:26:13,110 --> 00:26:13,390
हाँ.

565
00:26:13,390 --> 00:26:15,080
तुम एक तरह से लिखने अधोडैस सकता है या की तरह कुछ

566
00:26:15,080 --> 00:26:19,370
नहीं, लेकिन हम बस कहना है कि अंतरिक्ष का उपयोग कर सकते हैं.

567
00:26:19,370 --> 00:26:21,500
चलो तीन रिक्त स्थान की तरह यहाँ डाल.

568
00:26:21,500 --> 00:26:24,760
फिर अगली पंक्ति, ठीक है, हम दो रिक्त स्थान डाल करना होगा.

569
00:26:24,760 --> 00:26:26,500
अगली पंक्ति, हम सिर्फ एक अंतरिक्ष डाल दिया.

570
00:26:26,500 --> 00:26:30,340
और फिर हमारे अंतिम पंक्ति के लिए, हम किसी भी स्थान नहीं रखा जाएगा.

571
00:26:30,340 --> 00:26:32,210
और वहाँ हम हमारे पिरामिड है.

572
00:26:32,210 --> 00:26:33,170
>> तो उस तरह की है -

573
00:26:33,170 --> 00:26:37,290
तर्क के उस तरह याद है.

574
00:26:37,290 --> 00:26:39,340
और कोशिश करते हैं और पैटर्न के कुछ प्रकार है कि हम कर सकते हैं आंकड़ा

575
00:26:39,340 --> 00:26:43,690
तो सी अनुवाद और पाश के कुछ प्रकार में शामिल है.

576
00:26:43,690 --> 00:26:43,930
सही सभी.

577
00:26:43,930 --> 00:26:48,130
तो हम कहते हैं कि हम एक आठ ऊंचाई है, तो हमारी पहली पंक्ति है

578
00:26:48,130 --> 00:26:48,980
दो hashes.

579
00:26:48,980 --> 00:26:53,030
लेकिन उन hashes मिलता है, तो आप के लिए कुछ लिखना होगा

580
00:26:53,030 --> 00:26:54,000
पहले से रिक्त स्थान.

581
00:26:54,000 --> 00:26:55,840
सही है?

582
00:26:55,840 --> 00:26:57,340
क्या मैंने किया है मैं बस के माध्यम से चला गया.

583
00:26:57,340 --> 00:27:00,150
मैं इसे अपने आप को बाहर आकर्षित किया है, मेरे पाठ संपादक में एक पिरामिड, एक

584
00:27:00,150 --> 00:27:03,800
आठ साल की ऊंचाई के साथ पिरामिड और फिर गणना कितने

585
00:27:03,800 --> 00:27:05,180
रिक्त स्थान मैं बनाने की जरूरत है.

586
00:27:05,180 --> 00:27:07,350
तो मैंने कहा कि ठीक है, अच्छी तरह से पहली पंक्ति है

587
00:27:07,350 --> 00:27:08,260
दो hashes किया जा रहा.

588
00:27:08,260 --> 00:27:11,100
लेकिन इससे पहले कि मैं सात रिक्त स्थान इनपुट करने के लिए जरूरत है.

589
00:27:11,100 --> 00:27:13,420
अगले एक छह रिक्त स्थान है और फिर

590
00:27:13,420 --> 00:27:15,610
तीन hashes, वगैरह.

591
00:27:15,610 --> 00:27:20,520
>> तो फिर हम कोशिश करते हैं और लाने की एक और परत

592
00:27:20,520 --> 00:27:21,330
अमूर्त.

593
00:27:21,330 --> 00:27:26,680
क्या अगर हम nth पंक्ति के लिए किया था, कितने hashes और कैसे

594
00:27:26,680 --> 00:27:27,960
हम कई रिक्त स्थान की आवश्यकता होगी?

595
00:27:27,960 --> 00:27:30,750
क्या किसी को पैटर्न देख रहे हो?

596
00:27:35,200 --> 00:27:37,560
तो पहली पंक्ति में दो hashes है.

597
00:27:37,560 --> 00:27:39,720
2 एक तीन है.

598
00:27:39,720 --> 00:27:42,120
3 चार है.

599
00:27:42,120 --> 00:27:45,398
तो nth पंक्ति है -

600
00:27:45,398 --> 00:27:46,800
4 अध्यक्ष: एन प्लस 1?

601
00:27:46,800 --> 00:27:47,170
ZAMYLA चान: हाँ.

602
00:27:47,170 --> 00:27:47,780
एन प्लस 1.

603
00:27:47,780 --> 00:27:49,030
बिल्कुल सही.

604
00:27:52,810 --> 00:27:56,470
तो फिर हम देखेंगे है कि hashes की संख्या होने जा रहा है -

605
00:27:56,470 --> 00:27:59,510
अगर हम पहली पंक्ति की गिनती कर रहे हैं के लिए एक हो, तब संख्या

606
00:27:59,510 --> 00:28:03,850
hashes के सिर्फ एक है कि अधिक से अधिक होने जा रहा है.

607
00:28:03,850 --> 00:28:04,150
ठीक है.

608
00:28:04,150 --> 00:28:06,350
तो फिर रिक्त स्थान की संख्या के बारे में क्या?

609
00:28:06,350 --> 00:28:10,120
इसलिए हम कोशिश करते हैं और ऊंचाई के मामले में यह व्यक्त.

610
00:28:10,120 --> 00:28:12,570
अगर ऊंचाई आठ है, तो 1

611
00:28:12,570 --> 00:28:15,260
पंक्ति में सात रिक्त स्थान है.

612
00:28:15,260 --> 00:28:18,215
तो मेल खाती है उस तरह से 8 शून्य से 1.

613
00:28:18,215 --> 00:28:19,030
सही है?

614
00:28:19,030 --> 00:28:22,420
तो दूसरी पंक्ति के छह स्थानों के लिए जा रहा है,

615
00:28:22,420 --> 00:28:25,340
जो 8 शून्य से 2.

616
00:28:28,420 --> 00:28:31,450
तो फिर मैं आप के लिए यह आंकड़ा की तरह बाहर छोड़ने के लिए जा रहा हूँ

617
00:28:31,450 --> 00:28:33,610
इसके लिए पैटर्न.

618
00:28:33,610 --> 00:28:34,010
>> ठीक है.

619
00:28:34,010 --> 00:28:37,450
लेकिन प्रोग्रामिंग में, कभी कभी हम वास्तव में शून्य पर सूचकांक.

620
00:28:37,450 --> 00:28:39,680
इसलिए हम एक के बजाय शून्य पर शुरू.

621
00:28:39,680 --> 00:28:46,250
तो पहले पहली पंक्ति बुलाया पंक्ति के बजाय,

622
00:28:46,250 --> 00:28:48,930
हम यह पंक्ति शून्य वें बुला हो जा रहे हैं.

623
00:28:48,930 --> 00:28:51,360
तो तरीका है कि आप इसे लागू करने के लिए करना चाहते हैं पर निर्भर हो सकता है,

624
00:28:51,360 --> 00:28:55,120
बहुत सावधान रहना है कि क्या आप शून्य से शुरू करते हैं, कि क्या आप शुरू

625
00:28:55,120 --> 00:28:58,400
एक, अपने पैटर्न एक की भरपाई हो जा रहा है.

626
00:29:02,270 --> 00:29:02,880
ठीक है.

627
00:29:02,880 --> 00:29:05,460
तो अब है कि हम किस तरह के कार्यक्रम से बाहर लगा, हम

628
00:29:05,460 --> 00:29:06,310
ठीक कहना है.

629
00:29:06,310 --> 00:29:11,540
तो सीढ़ियों के स्तर के हर तरह के लिए, मैं मुद्रित करने के लिए जा रहा हूँ

630
00:29:11,540 --> 00:29:14,390
इस तरह के और रिक्त स्थान की ऐसी संख्या है और फिर इस तरह के और

631
00:29:14,390 --> 00:29:16,550
hashes की ऐसी संख्या.

632
00:29:16,550 --> 00:29:19,550
उस पैटर्न पर निर्भर करता है कि हम पहले स्थापित.

633
00:29:19,550 --> 00:29:19,810
ठीक है.

634
00:29:19,810 --> 00:29:23,600
तो के माध्यम से iterating का एक तरीका है और जा रहा की तरह

635
00:29:23,600 --> 00:29:27,670
चीजों की एक निर्धारित संख्या के माध्यम से पाश, तरह की तरह के लिए एक है

636
00:29:27,670 --> 00:29:31,040
दोहराने 10 ब्लॉक या तरह दोहराने में प्रवेश किया और एक

637
00:29:31,040 --> 00:29:33,810
स्क्रैच के लिए संख्या.

638
00:29:33,810 --> 00:29:38,050
तो अनिवार्य रूप से, सीढ़ियों के हर स्तर के लिए, हम चाहता हूँ

639
00:29:38,050 --> 00:29:39,650
रिक्त स्थान को मुद्रित.

640
00:29:39,650 --> 00:29:43,020
फिर hashes के संख्या मुद्रित.

641
00:29:43,020 --> 00:29:46,480
और फिर हम एक नई लाइन में प्रवेश करने के लिए और फिर इसे दोहराने के लिए चाहता हूँ

642
00:29:46,480 --> 00:29:49,750
फिर अगले ब्लॉक के लिए.

643
00:29:49,750 --> 00:29:50,720
ठीक है.

644
00:29:50,720 --> 00:29:55,080
>> तो चलो एक सेकंड के लिए loops के लिए की तरह देखने के एक तरह से देखते हैं

645
00:29:55,080 --> 00:29:59,460
कि हम एक सेट की संख्या के माध्यम से जा सकते हैं, नंबर के माध्यम से जाना

646
00:29:59,460 --> 00:30:02,250
इस आधे पिरामिड में कदम.

647
00:30:02,250 --> 00:30:04,220
तो loops के लिए तीन भागों से बना रहे हैं.

648
00:30:04,220 --> 00:30:08,150
सबसे पहले, आप एक initialization है.

649
00:30:08,150 --> 00:30:13,220
तो यह है कि अनिवार्य रूप से एक चर सेट.

650
00:30:13,220 --> 00:30:15,130
यह है कि मूल्य के लिए हर समय सेट किया जा रहा है

651
00:30:15,130 --> 00:30:17,110
कि पाश शुरू करने के लिए.

652
00:30:17,110 --> 00:30:18,540
तो आप के लिए एक शर्त है करने के लिए जा रहे हैं.

653
00:30:18,540 --> 00:30:21,640
अपने पाश के लिए के रूप में ही है कि जब तक अमल करेंगे

654
00:30:21,640 --> 00:30:25,630
शर्त सही मूल्यांकन करता है.

655
00:30:25,630 --> 00:30:28,000
और फिर तुम एक अद्यतन हालत होगा.

656
00:30:28,000 --> 00:30:32,450
तो यह है कि चर है कि आप initialized के साथ क्या करना है.

657
00:30:32,450 --> 00:30:38,120
तो मूल रूप से यह सुनिश्चित करना है कि हम बाहर तोड़ कर सकते हैं के कुछ तरीका

658
00:30:38,120 --> 00:30:40,070
पाश की, कि हम क्रियान्वित करने पर नहीं रहते हो

659
00:30:40,070 --> 00:30:41,310
यह हमेशा के लिए और कभी.

660
00:30:41,310 --> 00:30:43,760
क्योंकि स्क्रैच के विपरीत, हम वास्तव में न सिर्फ एक है

661
00:30:43,760 --> 00:30:45,680
सादे हमेशा पाश.

662
00:30:45,680 --> 00:30:48,100
सी में कार्यक्रम के लिए अंत में खत्म कर दिया है.

663
00:30:48,100 --> 00:30:52,290
तो हमें यह सुनिश्चित करना है कि किसी तरह हम इसे रोकने के लिए किया है.

664
00:30:52,290 --> 00:30:52,830
>> ठीक है.

665
00:30:52,830 --> 00:30:56,260
तो पाश के लिए एक का एक उदाहरण है कि आप के लिए उपयोग करना चाहते हैं हो सकता है

666
00:30:56,260 --> 00:30:57,530
मारियो है.

667
00:30:57,530 --> 00:31:02,290
तो तुम एक पूर्णांक है मुझे लगता है कि आप 0 में शुरू.

668
00:31:02,290 --> 00:31:08,050
के रूप में लंबे समय के रूप में यह ऊंचाई की तुलना में कम है, तो आप शरीर निष्पादित करने के लिए

669
00:31:08,050 --> 00:31:11,140
यहाँ अंदर पाश की.

670
00:31:11,140 --> 00:31:13,820
पाश की है कि शरीर के बाद मार डाला गया है, तो आप

671
00:31:13,820 --> 00:31:15,290
मैं 1 से वृद्धि हुई है.

672
00:31:15,290 --> 00:31:18,510
तो अपने कार्यक्रम फिर से जाँच करेगा - ठीक है, ठीक है, मैं कम से कम है

673
00:31:18,510 --> 00:31:18,885
ऊंचाई?

674
00:31:18,885 --> 00:31:21,865
अगर ऐसा है, तो आप जारी रहेगा.

675
00:31:24,630 --> 00:31:27,790
तो यहाँ शून्य अनुक्रमण, जहां हम पर शुरू की एक उदाहरण है

676
00:31:27,790 --> 00:31:29,100
शून्य और फिर हम -

677
00:31:29,100 --> 00:31:30,970
सूचना है कि हमारी हालत ऊंचाई की तुलना में कम है.

678
00:31:30,970 --> 00:31:34,510
तो कहना है कि हमारे ऊंचाई चार, उदाहरण के लिए, मैं

679
00:31:34,510 --> 00:31:35,470
0 में शुरू होगा.

680
00:31:35,470 --> 00:31:36,180
यह 1 हो जाएगा.

681
00:31:36,180 --> 00:31:36,730
यह 2 हो जाएगा.

682
00:31:36,730 --> 00:31:37,940
यह 3 हो जाएगा.

683
00:31:37,940 --> 00:31:42,310
और फिर एक बार इसे अद्यतन, जब पाश अद्यतन के लिए, तो मैं लूंगा

684
00:31:42,310 --> 00:31:43,650
तो 4 से सेट किया जा.

685
00:31:43,650 --> 00:31:47,080
लेकिन कम से कम 4 4, नहीं है और यदि ऐसा है तो फिर हम करेंगे

686
00:31:47,080 --> 00:31:50,340
हमारे लूप के आराम करने के लिए जारी है.

687
00:31:50,340 --> 00:31:50,870
>> ठीक है.

688
00:31:50,870 --> 00:31:51,680
तो यह है कि शून्य से शुरू हो रहा है.

689
00:31:51,680 --> 00:31:53,470
लेकिन हम भी एक उदाहरण के लिए शुरू करने के लिए,.

690
00:31:53,470 --> 00:31:56,960
लेकिन जब से हम एक पर शुरू करते हैं, हम किस तरह का एक और जाना है

691
00:31:56,960 --> 00:31:57,920
अंत में समय.

692
00:31:57,920 --> 00:32:02,800
तो यही कारण है कि हम कम से कम या के बराबर जोड़ने.

693
00:32:02,800 --> 00:32:05,780
तो एक महान चीजें हैं जो मैं कंप्यूटर के बारे में की तरह

694
00:32:05,780 --> 00:32:06,930
प्रोग्रामिंग है कि वहाँ सिर्फ इतनी है

695
00:32:06,930 --> 00:32:08,370
बातें करने के लिए कई तरीके हैं.

696
00:32:08,370 --> 00:32:11,300
तो तुम कि क्या आप शुरू शून्य पर चुनते हैं, कि क्या आप कर सकते हैं

697
00:32:11,300 --> 00:32:12,330
एक पर शुरू.

698
00:32:12,330 --> 00:32:15,400
इसके अलावा, अगर तुम चाहते थे, तो आप सिर्फ एक का उपयोग कर सकते हैं

699
00:32:15,400 --> 00:32:16,600
जबकि पाश, उदाहरण के लिए.

700
00:32:16,600 --> 00:32:18,890
तो तुम सकता है -

701
00:32:18,890 --> 00:32:20,270
वास्तव में खुला hello.c चलो.

702
00:32:26,200 --> 00:32:28,600
तो हम यहाँ पाश के लिए एक है.

703
00:32:28,600 --> 00:32:31,330
यह i = 0, मैं <5 में शुरू होता है.

704
00:32:31,330 --> 00:32:33,550
मैं यहाँ एक टिप्पणी हमें बता रहा है यह क्या करता है.

705
00:32:33,550 --> 00:32:36,300
यह हैलो पाँच बार पाश के लिए एक का उपयोग प्रिंट.

706
00:32:36,300 --> 00:32:41,690
लेकिन हम यह भी है कि एक समय पाश का उपयोग कर के रूप में अच्छी तरह से कर सकता है.

707
00:32:41,690 --> 00:32:48,290
>> तो चलो हम कैसे कर सकता है कि देखो.

708
00:32:48,290 --> 00:32:51,010
तो अगर हम एक पाश के लिए नकल करने की जा रहे हैं, तो हम भी चाहते हैं

709
00:32:51,010 --> 00:32:54,870
initialization, हालत, और अद्यतन नकल.

710
00:32:54,870 --> 00:33:01,430
तो हालत बहुत आसान होना चाहिए क्योंकि

711
00:33:01,430 --> 00:33:04,350
वाक्यविन्यास जबकि, जब आप इसे देखो, इसे कहते हैं जबकि (शर्त).

712
00:33:04,350 --> 00:33:06,830
तो चलो बस हालत वहाँ इनपुट.

713
00:33:06,830 --> 00:33:09,700
मैं <5.

714
00:33:09,700 --> 00:33:10,590
ठीक है.

715
00:33:10,590 --> 00:33:18,900
तो हम जानते हैं कि हम अलविदा मुद्रित करना चाहते हैं.

716
00:33:18,900 --> 00:33:21,350
हम जानते हैं कि हमारे पाश के शरीर है.

717
00:33:21,350 --> 00:33:23,600
लेकिन हम initialization याद कर रहे हैं

718
00:33:23,600 --> 00:33:24,490
और अद्यतन, है ना?

719
00:33:24,490 --> 00:33:25,790
क्योंकि हम हमेशा के लिए लूप नहीं हो सकता.

720
00:33:25,790 --> 00:33:27,660
इसे समाप्त करने के लिए.

721
00:33:27,660 --> 00:33:35,300
तो चलो यहाँ initialization के कुछ प्रकार जोड़ने का उपयोग

722
00:33:35,300 --> 00:33:38,790
एक ही है कि हम हमारे लिए पाश में प्रयोग किया जाता है, int i = 0.

723
00:33:38,790 --> 00:33:39,110
ठीक है.

724
00:33:39,110 --> 00:33:40,630
तो हम एक int i के साथ शुरू करते हैं.

725
00:33:40,630 --> 00:33:43,640
हम इस जबकि पाश रूप में लंबे समय के रूप में मैं कम से कम 5 दोहराएँ.

726
00:33:43,640 --> 00:33:47,220
तो फिर हम एक बात याद आ रहे हैं, जो अद्यतन है.

727
00:33:47,220 --> 00:33:51,470
तो क्या हम अद्यतन का उपयोग करने की आवश्यकता होगी अगर हम मूलतः थे

728
00:33:51,470 --> 00:33:52,880
ऊपर पाश के लिए पुनः?

729
00:33:56,000 --> 00:33:59,880
हम initialization मैं 0 के बराबर है.

730
00:33:59,880 --> 00:34:03,610
हम हालत मैं 5 से कम है.

731
00:34:03,610 --> 00:34:06,300
और फिर यहाँ एक अद्यतन है, है ना?

732
00:34:06,300 --> 00:34:07,365
तो हम नकल है कि चाहते हैं.

733
00:34:07,365 --> 00:34:10,340
हम ठीक कहना चाहता हूँ, मैं + +.

734
00:34:10,340 --> 00:34:13,820
कि मैं मैं = 1 + कह के रूप में एक ही बात है.

735
00:34:13,820 --> 00:34:17,090
लेकिन क्योंकि यह तो अक्सर इस्तेमाल किया जाता है, आशुलिपि, कि बस के लिए है

736
00:34:17,090 --> 00:34:18,340
मैं कह + +.

737
00:34:20,800 --> 00:34:22,050
>> बढ़िया है.

738
00:34:25,230 --> 00:34:26,400
ठीक है.

739
00:34:26,400 --> 00:34:29,210
यहाँ मैं वास्तव में बाहर मेरी सेब कार्यक्रम की नहीं निकता.

740
00:34:29,210 --> 00:34:33,070
इसलिए मैं सिर्फ नियंत्रण सी और है कि तुरंत क्लिक करने के लिए जा रहा हूँ

741
00:34:33,070 --> 00:34:34,989
जूते अपने कार्यक्रम के बाहर मुझे लाता है और

742
00:34:34,989 --> 00:34:35,920
मुझे टर्मिनल वापस करने के लिए.

743
00:34:35,920 --> 00:34:38,320
तो, उदाहरण के लिए, कि अगर आप जहाँ आप एक बग में चलाने

744
00:34:38,320 --> 00:34:40,750
अपने समय ऐसी है कि यह होगा पाश को अद्यतन करने के लिए भूल गया

745
00:34:40,750 --> 00:34:43,150
समाप्त कर सकता है, और आप एक अनंत लूप में प्रवेश, तो आप कर सकते हैं

746
00:34:43,150 --> 00:34:46,400
नियंत्रण सी का उपयोग करने के लिए कि बाहर तोड़.

747
00:34:46,400 --> 00:34:46,639
सही सभी.

748
00:34:46,639 --> 00:34:47,960
तो हम सही निर्देशिका में कर रहे हैं.

749
00:34:47,960 --> 00:34:52,010
तो चलो हैलो बनाने.

750
00:34:52,010 --> 00:35:01,710
और फिर अगर हम हैलो चलाते हैं, हम देखते हैं है कि अलविदा पाश है

751
00:35:01,710 --> 00:35:03,350
हमारे पाश के लिए के रूप में सटीक एक ही बात करता है.

752
00:35:03,350 --> 00:35:05,060
तो यह है कि सिर्फ एक संकेत है.

753
00:35:05,060 --> 00:35:06,980
चाहे आप loops के लिए और अधिक के साथ सहज या कर रहे हैं

754
00:35:06,980 --> 00:35:09,850
जबकि loops के साथ, वे परस्पर विनिमय किया जा सकता है.

755
00:35:09,850 --> 00:35:15,130
तो जो भी आप करने के लिए के माध्यम से पुनरावृति करने के लिए उपयोग करना चाहते हैं -

756
00:35:15,130 --> 00:35:16,020
इस मामले में -

757
00:35:16,020 --> 00:35:19,410
मारियो पिरामिड की ऊंचाई.

758
00:35:19,410 --> 00:35:23,020
तो फिर, यह सिर्फ एक चेतावनी है, यदि आप शून्य से शुरू

759
00:35:23,020 --> 00:35:25,430
अपने चर के लिए, तो आप एक अलग करना चाहता हूँ

760
00:35:25,430 --> 00:35:27,360
अगर आप एक बार में शुरू से हालत.

761
00:35:27,360 --> 00:35:29,620
तो इस तालिका बस की तरह आप एक चेतावनी से पता चलता है.

762
00:35:29,620 --> 00:35:33,660
यदि आप 10 बार दोहराने के लिए, उदाहरण के लिए, आप चाहते हैं तो

763
00:35:33,660 --> 00:35:36,030
या तो शून्य पर अपने चर शुरू कर सकते हैं.

764
00:35:36,030 --> 00:35:39,350
और अपनी हालत के 10 से भी कम हो सकता है.

765
00:35:39,350 --> 00:35:43,020
और इसलिए उस तरह आप उस के मैट्रिक्स से पता चलता है.

766
00:35:43,020 --> 00:35:43,360
>> ठीक है.

767
00:35:43,360 --> 00:35:45,790
तो हम मारियो के माध्यम से चला गया है.

768
00:35:45,790 --> 00:35:48,820
हम कहा है, ठीक है, हम सही इनपुट के लिए जांच की जरूरत है,

769
00:35:48,820 --> 00:35:50,800
शून्य और 23 समावेशी.

770
00:35:50,800 --> 00:35:53,370
हम पैटर्न की तरह है, जिस तरह के कुछ प्रकार खोजने के लिए जा रहे हैं

771
00:35:53,370 --> 00:35:57,920
nth पंक्ति या ith पंक्ति व्यक्त की.

772
00:35:57,920 --> 00:36:01,560
और हम तय करने के लिए जा रहे हैं, ठीक है, कि हम इस मुद्रित करने के लिए जा रहे हैं

773
00:36:01,560 --> 00:36:04,870
कई रिक्त स्थान है, यह कई hashes, नई लाइन.

774
00:36:04,870 --> 00:36:05,050
सही सभी.

775
00:36:05,050 --> 00:36:05,720
तो हम उस है.

776
00:36:05,720 --> 00:36:08,570
तो अब हम लालची पर स्थानांतरित कर सकते हैं.

777
00:36:08,570 --> 00:36:14,500
लालची एक कार्यक्रम है, जहां एक उपयोगकर्ता आप एक राशि देता है

778
00:36:14,500 --> 00:36:17,460
नकदी है कि अनिवार्य रूप से आप खजांची के रूप में वापसी की जरूरत है.

779
00:36:17,460 --> 00:36:21,530
लेकिन आप के लिए संभव के रूप में के रूप में छोटे सिक्के का उपयोग करना चाहते हैं.

780
00:36:21,530 --> 00:36:25,070
और तो यह है, जहां एक लालची एल्गोरिथ्म में आता है, जहां

781
00:36:25,070 --> 00:36:30,440
हम सिक्कों की न्यूनतम राशि संभव करने के लिए उपयोग करना चाहते हैं

782
00:36:30,440 --> 00:36:31,900
परिवर्तन की है कि राशि.

783
00:36:34,500 --> 00:36:34,990
>> ठीक है.

784
00:36:34,990 --> 00:36:40,480
तो अपने समाधान में इस का एक उदाहरण लग सकता है

785
00:36:40,480 --> 00:36:42,540
कुछ इस तरह.

786
00:36:42,540 --> 00:36:45,410
आप चलाते हैं. लालची /.

787
00:36:45,410 --> 00:36:47,920
आप के लिए ठीक कहने के लिए प्रेरित कर रहे हैं, अच्छी तरह से कितना परिवर्तन बकाया है?

788
00:36:47,920 --> 00:36:50,780
मूल्य है कि डॉलर में एक मूल्य होने जा रहा है.

789
00:36:50,780 --> 00:36:52,440
तो यह है कि एक नाव होने जा रहा है.

790
00:36:52,440 --> 00:36:55,630
आपका कार्यक्रम तो न्यूनतम राशि की गणना की जाएगी

791
00:36:55,630 --> 00:37:00,380
इस उदाहरण में, 0.32 डॉलर की आवश्यकता के सिक्कों की.

792
00:37:00,380 --> 00:37:04,550
और इसलिए न्यूनतम संख्या चार है.

793
00:37:04,550 --> 00:37:07,480
की पैदल दूरी पर तो इससे पहले कि हम यह पता लगाने क्या करना है, चलो तरह

794
00:37:07,480 --> 00:37:10,770
के माध्यम से प्रक्रिया है कि आप के बारे में जाना हो सकता है.

795
00:37:10,770 --> 00:37:16,480
तो अगर इनपुट 32 है, तो अनिवार्य रूप से मैं उपयोग करने के लिए जा रहा हूँ

796
00:37:16,480 --> 00:37:19,100
सिक्कों की कम से कम राशि है, अगर मैं कई के रूप में उपयोग

797
00:37:19,100 --> 00:37:20,460
संभव के रूप में बड़ा सिक्कों.

798
00:37:20,460 --> 00:37:20,870
सही है?

799
00:37:20,870 --> 00:37:25,420
तो यह एक बहुत आसान है के रूप में एक चौथाई का उपयोग

800
00:37:25,420 --> 00:37:27,070
पाँच nickels करने का विरोध किया है.

801
00:37:27,070 --> 00:37:31,740
तो हम कहते हैं, आप 0.32 $ वापसी की जरूरत है.

802
00:37:31,740 --> 00:37:36,660
खैर, मैं इस में एक चौथाई का उपयोग कर सकते हैं?

803
00:37:36,660 --> 00:37:37,480
हाँ, आप यह कर सकते हैं.

804
00:37:37,480 --> 00:37:41,970
और फिर आप $ 0.07 तक कम किया जाएगा.

805
00:37:41,970 --> 00:37:46,070
चलो देखते हैं अगर मैं एक और तिमाही का उपयोग करने के लिए आप भुगतान वापस कर सकते हैं.

806
00:37:46,070 --> 00:37:46,870
वैसे, नहीं.

807
00:37:46,870 --> 00:37:48,200
मुझे लगता है कि एक चौथाई फिट नहीं कर सकते.

808
00:37:48,200 --> 00:37:52,110
तो मैं अगले सबसे बड़ा सिक्का को स्थानांतरित करने के लिए जा रहा हूँ.

809
00:37:52,110 --> 00:37:53,250
मैं एक पैसा भी उपयोग कर सकते हैं?

810
00:37:53,250 --> 00:37:55,800
$ 0.07, नहीं, आप 0.07 डॉलर का भुगतान करने के लिए पैसा भी नहीं का उपयोग कर सकते हैं.

811
00:37:55,800 --> 00:37:56,840
तो आप नहीं कहना है.

812
00:37:56,840 --> 00:38:00,490
अगले एक है, जो एक निकेल में ले जाएँ.

813
00:38:00,490 --> 00:38:01,440
आप एक निकेल का उपयोग कर सकते हैं?

814
00:38:01,440 --> 00:38:02,930
हां.

815
00:38:02,930 --> 00:38:06,440
सात 0.05 डॉलर से भी बड़ा है, इसलिए हम एक निकेल का उपयोग कर सकते हैं.

816
00:38:06,440 --> 00:38:08,640
और फिर हम दो सेंट के ऊपर छोड़ दिया है.

817
00:38:08,640 --> 00:38:11,110
हम एक पैसा का उपयोग कर सकते हैं?

818
00:38:11,110 --> 00:38:12,180
हाँ, हम कर सकते हैं.

819
00:38:12,180 --> 00:38:13,070
हम एक पैसा का उपयोग कर सकते हैं?

820
00:38:13,070 --> 00:38:13,380
हां.

821
00:38:13,380 --> 00:38:14,710
हम एक पैसा का उपयोग कर सकते हैं?

822
00:38:14,710 --> 00:38:17,070
नहीं, क्योंकि अब हम सफलतापूर्वक

823
00:38:17,070 --> 00:38:19,400
उपयोगकर्ता वापस भुगतान किया.

824
00:38:19,400 --> 00:38:23,620
और इतना है कि चार इस्तेमाल सिक्के योग.

825
00:38:23,620 --> 00:38:26,370
>> तो उस प्रक्रिया के बारे में सोच रही है, हम हर

826
00:38:26,370 --> 00:38:29,080
समय ठीक निर्णय लेते हैं,

827
00:38:29,080 --> 00:38:31,050
सबसे बड़ा सिक्का है कि हम का उपयोग कर सकते हैं क्या है?

828
00:38:31,050 --> 00:38:37,240
एक बार जब हम उस का उपयोग करने के लिए, हम किस तरह का कितना की एक मानसिक नोट रखने

829
00:38:37,240 --> 00:38:39,650
अधिक पैसे हम उपयोगकर्ता के रूप में के रूप में अच्छी तरह से वापसी की जरूरत है कि कितने

830
00:38:39,650 --> 00:38:41,310
सिक्के हम का उपयोग किया गया है.

831
00:38:44,640 --> 00:38:45,200
ठीक है.

832
00:38:45,200 --> 00:38:48,930
लेकिन फिर तो, पहला कदम है - बस मारियो की तरह - शीघ्र है

833
00:38:48,930 --> 00:38:51,120
एक मौद्रिक राशि के लिए उपयोगकर्ता.

834
00:38:51,120 --> 00:38:53,920
और इसलिए इस राशि के लिए होने जा रहा है -

835
00:38:53,920 --> 00:38:56,040
यह एक दशमलव मान जा रहा है क्योंकि हम जा रहे हैं

836
00:38:56,040 --> 00:38:57,310
उन्हें डॉलर के लिए पूछना.

837
00:38:57,310 --> 00:39:00,550
तो उस डेटा प्रकार एक पूर्णांक नहीं जा रहा है.

838
00:39:00,550 --> 00:39:01,860
लेकिन यह एक होने जा रहा है -

839
00:39:04,960 --> 00:39:07,700
हाँ, एक नाव.

840
00:39:07,700 --> 00:39:10,780
लेकिन सिर्फ सेब की तरह तैरता सकारात्मक या नकारात्मक हो सकता है.

841
00:39:10,780 --> 00:39:13,390
तो जब आप मूल्यों के लिए जांच, आप चाहते जा रहे हैं

842
00:39:13,390 --> 00:39:15,380
कि अपनी नाव को सुनिश्चित

843
00:39:15,380 --> 00:39:19,710
उपयोगकर्ता इनपुट - गैर नकारात्मक है.

844
00:39:19,710 --> 00:39:20,960
ठीक है.

845
00:39:22,630 --> 00:39:26,720
हम हमारे पूरे कार्यक्रम में तैरता साथ सौदा कर सकता का प्रतिनिधित्व करते हैं,

846
00:39:26,720 --> 00:39:31,610
0.25 से क्वार्टर, 0.1 वगैरह, ऑफ डाइम्स.

847
00:39:31,610 --> 00:39:36,280
लेकिन मैं यह एक बहुत सिर्फ शुद्ध सेंट में सौदा करने के लिए आसान लगता है.

848
00:39:36,280 --> 00:39:36,910
इसके साथ -

849
00:39:36,910 --> 00:39:39,370
और हम इस एक बिट के बारे में बाद में बात करेंगे -

850
00:39:39,370 --> 00:39:43,610
सी में, अस्थायी अंक कुछ imprecision बुलाया है.

851
00:39:43,610 --> 00:39:48,660
तो जब आप 0.12 में दर्ज करते हैं, उदाहरण के लिए, कंप्यूटर

852
00:39:48,660 --> 00:39:53,010
0.1111119 तरह के रूप में वास्तव में स्टोर या

853
00:39:53,010 --> 00:39:54,350
ऐसा ही कुछ है.

854
00:39:54,350 --> 00:39:56,900
>> तो यह एक बहुत आसान सेंट कनवर्टर के लिए इस्तेमाल किया जा सकता है.

855
00:39:56,900 --> 00:40:02,190
तो हम सेंट करने के लिए एक डॉलर की कीमत कैसे परिवर्तित करते हैं?

856
00:40:02,190 --> 00:40:03,540
5 अध्यक्ष: यह 100 से टाइम्स?

857
00:40:03,540 --> 00:40:03,920
ZAMYLA चान: हाँ.

858
00:40:03,920 --> 00:40:04,110
हाँ.

859
00:40:04,110 --> 00:40:07,110
तो हम बार यह 100 से होगा.

860
00:40:07,110 --> 00:40:10,820
लेकिन एक अस्थायी अंक के बारे में मुश्किल बात यह है कि वहाँ

861
00:40:10,820 --> 00:40:11,790
कुछ अस्पष्टता है.

862
00:40:11,790 --> 00:40:16,090
तो चलो बस का एक उदाहरण देखो.

863
00:40:18,760 --> 00:40:21,360
तो मैं imprecision.c खोलने के लिए जा रहा हूँ.

864
00:40:21,360 --> 00:40:23,690
ठीक है.

865
00:40:23,690 --> 00:40:24,860
यह एक बहुत ही साधारण प्रोग्राम है.

866
00:40:24,860 --> 00:40:26,970
यह एक नाव के लिए पूछता है, और यह प्रिंट वापस.

867
00:40:35,950 --> 00:40:39,600
टर्मिनल में एक अच्छा संकेत है कि आप अभी स्पष्ट लिख सकते हैं, और

868
00:40:39,600 --> 00:40:41,180
तो आप एक स्पष्ट स्क्रीन है.

869
00:40:41,180 --> 00:40:45,270
और इसलिए आप किसी भी पिछले उत्पादन या किसी को देखने की जरूरत नहीं है

870
00:40:45,270 --> 00:40:47,490
त्रुटियों या रिपोर्ट बग, ऐसा कुछ.

871
00:40:47,490 --> 00:40:48,120
ठीक है.

872
00:40:48,120 --> 00:40:49,675
तो चलो imprecision बनाने.

873
00:40:53,250 --> 00:40:56,250
चलो इसे चलाने के लिए.

874
00:40:56,250 --> 00:40:57,890
इसलिए मैं नहीं -

875
00:40:57,890 --> 00:41:03,830
अपने कोड में, मैं किसी भी संकेत या कुछ भी की तरह है कि मुद्रित नहीं था.

876
00:41:03,830 --> 00:41:05,010
तो यह सिर्फ एक निमिष कर्सर है.

877
00:41:05,010 --> 00:41:07,390
तो यह सिर्फ मेरे लिए एक नाव के इनपुट के लिए इंतजार कर रहा है.

878
00:41:07,390 --> 00:41:08,640
तो let's

879
00:41:10,610 --> 00:41:11,280
एक यादृच्छिक नाव.

880
00:41:11,280 --> 00:41:15,080
और आप देखेंगे कि यह प्रिंट वापस लेकिन कुछ अतिरिक्त

881
00:41:15,080 --> 00:41:18,180
संख्या है कि हम निश्चित रूप से शामिल नहीं किया था.

882
00:41:18,180 --> 00:41:21,980
इसलिए हम यह सुनिश्चित करें कि नहीं करता है कि बनाना चाहते हैं

883
00:41:21,980 --> 00:41:23,300
हमारे कार्यक्रम में होता है.

884
00:41:23,300 --> 00:41:27,550
>> तो फिर हम क्या करना चाहते हैं कि हम वास्तव में सुनिश्चित बनाने के लिए है

885
00:41:27,550 --> 00:41:31,300
तरह के उचित मूल्य के लिए बंद गोल.

886
00:41:31,300 --> 00:41:31,850
सही है?

887
00:41:31,850 --> 00:41:37,820
और सौभाग्य से, हम एक समारोह दौर शामिल बुलाया है

888
00:41:37,820 --> 00:41:38,550
उपकरण में.

889
00:41:38,550 --> 00:41:41,390
यह गणित पुस्तकालय में है.

890
00:41:41,390 --> 00:41:44,710
यदि आप को पता कैसे दौर का उपयोग करना चाहते हैं, तो आप वास्तव में इस्तेमाल

891
00:41:44,710 --> 00:41:45,220
पुस्तिका.

892
00:41:45,220 --> 00:41:48,160
आप आदमी के दौर क्लिक कर सकते हैं.

893
00:41:48,160 --> 00:41:51,190
यहाँ तो यह ऊपर लाता है -

894
00:41:51,190 --> 00:41:53,220
समझने के लिए थोड़ा मुश्किल हो सकता है, लेकिन अंत में

895
00:41:53,220 --> 00:41:54,690
आप इसे भांप मिलेगा.

896
00:41:54,690 --> 00:42:00,060
यह एक तरह से पता चलता है कि समारोह में क्या करता है और फिर कुछ

897
00:42:00,060 --> 00:42:01,790
उस के संभव का उपयोग करता है.

898
00:42:01,790 --> 00:42:10,210
तो जब आप अंततः से एक उचित, वैध इनपुट मिल

899
00:42:10,210 --> 00:42:14,490
उपयोगकर्ता हैं, तो आप इसे सेंट करने के लिए परिवर्तित करना चाहते हैं.

900
00:42:14,490 --> 00:42:18,530
सुनिश्चित करें कि आप मूल्य दौर इतना करना है कि आप इस से बचने

901
00:42:18,530 --> 00:42:21,780
बिंदु imprecision तैर.

902
00:42:21,780 --> 00:42:22,340
>> ठीक है.

903
00:42:22,340 --> 00:42:26,190
तो हम एक मौद्रिक राशि के लिए उपयोगकर्ता प्रेरित है.

904
00:42:26,190 --> 00:42:31,460
अब हम क्या करना चाहते है, अनिवार्य रूप से सही की जांच?

905
00:42:31,460 --> 00:42:35,500
ठीक है, तो मैं सबसे बड़ी संभव सिक्के का उपयोग कर सकते हैं?

906
00:42:35,500 --> 00:42:37,040
यदि आप कर सकते हैं, तो आप इसे उपयोग.

907
00:42:37,040 --> 00:42:40,250
आप कितने सिक्के आप अब तक इस्तेमाल किया है का ट्रैक रखने और

908
00:42:40,250 --> 00:42:41,710
भी गिरावट राशि.

909
00:42:41,710 --> 00:42:42,240
सही है?

910
00:42:42,240 --> 00:42:44,880
और फिर आप की जाँच करने के लिए जा रहे हैं.

911
00:42:44,880 --> 00:42:47,940
एक बार जब आप तिमाहियों थक की तरह है, आप जाना चाहते हैं

912
00:42:47,940 --> 00:42:49,545
अगले संभव बात करने के लिए.

913
00:42:49,545 --> 00:42:59,380
>> तो पाश की संरचना की तरह क्या है या किस तरह हम हो सकता है

914
00:42:59,380 --> 00:43:03,850
करने के लिए लगातार जाँच करें कि क्या हम अभी भी उपयोग कर सकते हैं का उपयोग करना चाहते हैं

915
00:43:03,850 --> 00:43:05,100
एक चौथाई है, उदाहरण के लिए?

916
00:43:07,380 --> 00:43:09,280
6 SPEAKER: जब से अधिक मूल्य है?

917
00:43:09,280 --> 00:43:10,150
ZAMYLA चान: हाँ, एकदम सही है.

918
00:43:10,150 --> 00:43:10,590
बिल्कुल सही.

919
00:43:10,590 --> 00:43:12,630
तो, जबकि मूल्य से अधिक है.

920
00:43:12,630 --> 00:43:16,300
तो, जबकि मूल्य अभी भी है कि हम वापस देना है

921
00:43:16,300 --> 00:43:19,410
एक चौथाई से भी बड़ा है, जबकि हम अभी भी एक चौथाई का उपयोग कर सकते हैं,

922
00:43:19,410 --> 00:43:20,490
तिमाहियों का उपयोग करें.

923
00:43:20,490 --> 00:43:21,450
उस के ट्रैक रखें.

924
00:43:21,450 --> 00:43:22,610
और फिर जा रहा पर रखने.

925
00:43:22,610 --> 00:43:25,040
बिल्कुल सही.

926
00:43:25,040 --> 00:43:26,290
ठीक है.

927
00:43:28,190 --> 00:43:32,580
ओह, मैं यहाँ सिर्फ बस कैसे मुद्रित करने के लिए कुछ सुझाव भी शामिल है

928
00:43:32,580 --> 00:43:33,830
मूल्यों बाहर.

929
00:43:36,330 --> 00:43:38,810
तो अपने printf समारोह में, हम आम तौर पर किया गया है

930
00:43:38,810 --> 00:43:39,760
तार के साथ काम कर रहे हैं.

931
00:43:39,760 --> 00:43:43,290
लेकिन जब आप एक int या बस किसी भी प्रकार के मुद्रित करना चाहते हैं

932
00:43:43,290 --> 00:43:46,510
अंकों, आप जगह धारक की तरह लिखने की तरह है.

933
00:43:46,510 --> 00:43:50,840
तो यह है कि, पूर्णांकों के लिए% d प्रतिशत द्वारा प्रतिनिधित्व किया है.

934
00:43:50,840 --> 00:43:53,780
आपको लगता है कि लिखने के लिए है, तो बाद में आप वास्तव में हूँ -

935
00:43:53,780 --> 00:43:54,900
एक अल्पविराम के बाद -

936
00:43:54,900 --> 00:43:57,990
मूल्य क्या वास्तव में वहाँ में चला जाता है में डाल दिया.

937
00:43:57,990 --> 00:43:58,510
सही है.

938
00:43:58,510 --> 00:43:58,840
>> ठीक है.

939
00:43:58,840 --> 00:44:02,050
इसलिए हमने तय किया है कि हम करने के लिए कि क्या जाँच करना चाहते हैं -

940
00:44:02,050 --> 00:44:04,950
ऐसा करने का एक तरीका लगातार जांच होगी कि क्या

941
00:44:04,950 --> 00:44:08,640
हम अभी भी तिमाहियों का उपयोग कर सकते हैं और उसके बाद का उपयोग करें तिमाहियों रखने के लिए,

942
00:44:08,640 --> 00:44:11,460
ट्रैक करने के लिए, और फिर अगला सबसे बड़ा मूल्य पर चलते हैं.

943
00:44:11,460 --> 00:44:15,010
अब साफ तरह का एक और प्रकार है कि आप यह कर सकते है

944
00:44:15,010 --> 00:44:16,770
ऑपरेटर modulo का उपयोग कर.

945
00:44:16,770 --> 00:44:22,710
तो हम पहले से ही इसके अलावा, ऋण, गुणा विभाजित है, और है

946
00:44:22,710 --> 00:44:23,560
हमारे पास उपलब्ध है.

947
00:44:23,560 --> 00:44:25,600
लेकिन modulo ऑपरेटर की तरह साफ है.

948
00:44:25,600 --> 00:44:28,630
यह क्या करता है, यह वास्तव में आप के शेष देता है

949
00:44:28,630 --> 00:44:31,750
दो संख्याओं को विभाजित.

950
00:44:31,750 --> 00:44:34,680
तो अगर आप लंबे समय विभाजन में याद है जब आप कहते हैं,

951
00:44:34,680 --> 00:44:40,100
74 3 द्वारा विभाजित करते हैं, तो आप यह लिखना होगा, पर ले जाने के लिए,

952
00:44:40,100 --> 00:44:43,260
घटाना, और फिर अंत में नीचे कम संख्या में है

953
00:44:43,260 --> 00:44:44,050
शेष.

954
00:44:44,050 --> 00:44:47,120
खैर, modulo क्या करता है यह वास्तव में सिर्फ तुम देता है कि.

955
00:44:47,120 --> 00:44:51,290
74 तो 3 modulo आप 2 देना होगा.

956
00:44:51,290 --> 00:44:56,310
इसी तरह, 10 2 modulo आप 0 देता है क्योंकि वहाँ कोई नहीं है

957
00:44:56,310 --> 00:44:59,340
शेष जब आप 2 से 10 विभाजित करते हैं.

958
00:44:59,340 --> 00:45:03,940
6 5 modulo, अच्छी तरह से 5 6 एक बार में तो चला जाता है और

959
00:45:03,940 --> 00:45:05,900
यह 1 पर छोड़ दिया है.

960
00:45:05,900 --> 00:45:09,930
तो अगर आप 7 9 modulo है, अच्छी तरह से 9 7 से भी बड़ा है.

961
00:45:09,930 --> 00:45:11,830
तो यह किसी भी दूसरी बार नहीं जा सकते.

962
00:45:11,830 --> 00:45:15,560
तो यह समझ में आता है कि वापसी मान 7 है.

963
00:45:15,560 --> 00:45:21,590
तो अगर आप modulo के बारे में सोचते हैं, यह आप कैसे शेष देता है

964
00:45:21,590 --> 00:45:25,170
के बाद आप कुछ विभाजित है, तो आप किस तरह कर सकते हैं आप कैसे

965
00:45:25,170 --> 00:45:27,490
यह लालची सही, में उपयोग करने में सक्षम हो सकता है?

966
00:45:30,340 --> 00:45:34,170
तो अगर आप की तरह modulo शायद गठबंधन विभाजन के साथ

967
00:45:34,170 --> 00:45:36,410
ऑपरेटर, ऐसा कुछ है, तो आप एक अच्छा हो सकता है

968
00:45:36,410 --> 00:45:38,870
mathy समस्या सेट दृष्टिकोण की तरह.

969
00:45:44,010 --> 00:45:46,090
>> तो अब है कि हम जानते हैं कि अलग से एक जोड़ी है

970
00:45:46,090 --> 00:45:48,350
तरीके है कि हम यह कर सकता है - वहाँ निश्चित रूप से एक बहुत कुछ कर रहे हैं

971
00:45:48,350 --> 00:45:54,160
अलग अलग तरीकों से भी जबकि loops लिखने के लिए.

972
00:45:54,160 --> 00:45:57,020
तो मैं कुछ pseudocode यहाँ लिखा है.

973
00:45:57,020 --> 00:46:01,760
यह आपके के कंकाल की तरह करने के लिए समान नहीं हो सकता

974
00:46:01,760 --> 00:46:02,460
कोड है कि आप लिख.

975
00:46:02,460 --> 00:46:05,580
लेकिन अनिवार्य रूप से, और सोचने का तरीका प्रक्रिया है

976
00:46:05,580 --> 00:46:06,940
बस के रूप में हम पर चर्चा की.

977
00:46:06,940 --> 00:46:10,310
अब 1, पहली पंक्ति के लिए एक निश्चित राशि प्राप्त करने के लिए कह रहा है

978
00:46:10,310 --> 00:46:12,490
डॉलर में.

979
00:46:12,490 --> 00:46:16,960
और फिर निहित वहाँ यह सेंट करने के लिए कन्वर्ट करने के लिए है.

980
00:46:16,960 --> 00:46:20,540
तो, जबकि तिमाहियों के लिए इस्तेमाल किया जा सकता है, हम चाहते हैं

981
00:46:20,540 --> 00:46:21,750
गिनती बढ़ाने के लिए.

982
00:46:21,750 --> 00:46:24,360
और फिर हम राशि, मूल्य कि कमी चाहते हैं

983
00:46:24,360 --> 00:46:25,300
हम वापस लौट रहे हैं.

984
00:46:25,300 --> 00:46:28,170
जैसा कि आप यहाँ देख, यह काफी सी. लेकिन नहीं है कि मैं भी लिया है

985
00:46:28,170 --> 00:46:31,550
बातें दांतेदार बना, मैं के अंदर अपनी शर्तों डाल

986
00:46:31,550 --> 00:46:32,190
कोष्ठकों.

987
00:46:32,190 --> 00:46:34,370
>> तो फिर उस तरह मुझे शुरू हो जाता है.

988
00:46:34,370 --> 00:46:36,620
और फिर बाद में, मैं अभी तक वाक्यविन्यास देख सकते हैं.

989
00:46:36,620 --> 00:46:40,230
अक्सर एक समस्या के बारे में वास्तव में सबसे कठिन हिस्सा है

990
00:46:40,230 --> 00:46:41,860
समझते हैं कि क्या वास्तव में आप क्या करने की जरूरत है.

991
00:46:41,860 --> 00:46:44,610
तो एक बार आपको लगता है कि नीचे लिखते हैं, तो यह एक बहुत तो आसान है

992
00:46:44,610 --> 00:46:45,810
pseudocode करने के लिए अनुवाद.

993
00:46:45,810 --> 00:46:49,340
और फिर pseudocode से, वाक्यविन्यास बहुत आसान आता है.

994
00:46:49,340 --> 00:46:52,140
तो हम देखते हैं जबकि क्वार्टर, इस्तेमाल किया जा सकता है, गिनती बढ़ाने के लिए,

995
00:46:52,140 --> 00:46:53,220
मात्रा को कम.

996
00:46:53,220 --> 00:46:57,310
जबकि ऑफ डाइम्स इस्तेमाल किया जा सकता है, तो आप यह इतना इतने पर आचरण और

997
00:46:57,310 --> 00:47:00,670
आगे है, जब तक आप अपने पैसे के सभी को समाप्त किया है.

998
00:47:00,670 --> 00:47:03,410
तुम बाहर सिक्कों की संख्या का इस्तेमाल किया है, जो होगा मुद्रित

999
00:47:03,410 --> 00:47:06,620
न्यूनतम उपयोगकर्ता राशि मूल्य inputted.

1000
00:47:06,620 --> 00:47:09,370
और वहाँ आप अपने लालची एल्गोरिथ्म है.

1001
00:47:09,370 --> 00:47:13,960
और फिर एक बार आप है कि खत्म, आप भी pset 0 समाप्त कर दिया है.

1002
00:47:13,960 --> 00:47:16,155
>> क्या किसी को कुछ के बारे में किसी भी सवाल है?

1003
00:47:19,420 --> 00:47:19,780
सही सभी.

1004
00:47:19,780 --> 00:47:22,900
खैर, मैं चारों ओर एक छोटा सा के लिए यदि आप के बाद छड़ी होगी

1005
00:47:22,900 --> 00:47:23,970
किसी भी सवाल.

1006
00:47:23,970 --> 00:47:24,940
यह 1 walkthrough था.

1007
00:47:24,940 --> 00:47:26,190
आने के लिए धन्यवाद.