1
00:00:00,000 --> 00:00:00,500

2
00:00:00,500 --> 00:00:02,640
ZAMYLA चान: यह एक-मुझे, Zamyla है।

3
00:00:02,640 --> 00:00:06,950
आज, हम को लागू करने के लिए जा रहे हैं
मारियो, जहां हम मारियो आकर्षित

4
00:00:06,950 --> 00:00:10,730
उसके लिए एक पूर्ण पिरामिड के ऊपर कूद करने के लिए।

5
00:00:10,730 --> 00:00:14,430
के टूट
इस समस्या के लिए उप-कार्य।

6
00:00:14,430 --> 00:00:17,930
>> सबसे पहले, हम उपयोगकर्ता संकेत करना चाहते हैं
पिरामिड की ऊंचाई के लिए।

7
00:00:17,930 --> 00:00:20,510
और फिर हम सुनिश्चित करना चाहते हैं
वह यह है कि इनपुट वैध है।

8
00:00:20,510 --> 00:00:23,280
और फिर हम करने जा रहे हैं
पिरामिड आकर्षित करना चाहते हैं।

9
00:00:23,280 --> 00:00:26,850
>> तो चलो उत्साह के बारे में बात करते हैं
और उपयोगकर्ता इनपुट को मान्य।

10
00:00:26,850 --> 00:00:29,920
यह ऐसा कुछ लग सकता है
यही नहीं, एक है, जबकि पाश है कि

11
00:00:29,920 --> 00:00:33,250
एक के लिए उपयोगकर्ता संकेत देता है
पूर्णांक और उसके बाद ही दोहराता

12
00:00:33,250 --> 00:00:35,700
अगर है कि पूर्णांक अमान्य है।

13
00:00:35,700 --> 00:00:38,220
तो क्या यह शर्त होनी चाहिए?

14
00:00:38,220 --> 00:00:40,630
>> इस के लिए, चलो वापस जाना
विनिर्देश करने के लिए।

15
00:00:40,630 --> 00:00:46,240
खैर, कल्पना है कि किसी भी वैध हमें बताता है
ऊंचाई, 0 और 23 के बीच होने जा रहा है

16
00:00:46,240 --> 00:00:47,350
समावेशी।

17
00:00:47,350 --> 00:00:51,400
तो फिर इसका मतलब है कि किसी भी अवैध
ऊंचाई कम से कम 0 होने जा रहा है

18
00:00:51,400 --> 00:00:53,840
या अधिक से अधिक 23।

19
00:00:53,840 --> 00:00:57,220
>> तो अब है कि हम इस बारे में जानकारी है,
चलो हमारे हालत डिजाइन करते हैं।

20
00:00:57,220 --> 00:00:59,230
लेकिन हमें सावधान रहने की जरूरत है,
क्योंकि अब हम

21
00:00:59,230 --> 00:01:02,130
दो Booleans कि हम मूल्यांकन करने के लिए चाहते हैं।

22
00:01:02,130 --> 00:01:04,150
>> यहाँ मैं तुम्हें प्रदान की है
एक सच तालिका के साथ।

23
00:01:04,150 --> 00:01:07,520
यह हमें दो लेने के लिए अनुमति देता है
Booleans, बूलियन एक और दो।

24
00:01:07,520 --> 00:01:13,600
और हम या तो bool1 मूल्यांकन कर सकते हैं
और bool2 या bool1 या bool2।

25
00:01:13,600 --> 00:01:17,390
>> तो क्या फर्क है
के बीच और और या नहीं?

26
00:01:17,390 --> 00:01:21,810
खैर, bool1 और bool2 होगा
का मूल्यांकन अगर सही है और केवल

27
00:01:21,810 --> 00:01:25,680
दोनों Booleans सत्य हैं, तो
जबकि या ऑपरेशन

28
00:01:25,680 --> 00:01:30,190
सच हो जाएगा, तो या तो एक की
Booleans या दोनों सही हैं।

29
00:01:30,190 --> 00:01:33,110
इस के साथ दिमाग में तो,
देखते हैं अगर आप समझ सकते हैं

30
00:01:33,110 --> 00:01:37,460
क्या उचित हालत के लिए
गलत N के लिए अपने घर का है, जबकि पाश

31
00:01:37,460 --> 00:01:38,850
होने जा रहा है।

32
00:01:38,850 --> 00:01:43,540
>> उस के साथ, हम संकेत और मान्य किया है
पिरामिड की ऊंचाई के लिए उपयोगकर्ता

33
00:01:43,540 --> 00:01:44,550
वे चाहते हैं कि।

34
00:01:44,550 --> 00:01:47,740
तो अब, यह हम पर निर्भर है
पिरामिड आकर्षित करने के लिए।

35
00:01:47,740 --> 00:01:50,520
इस के लिए पूर्ण पिरामिड
इस समस्या का एक छोटा सा दिखेगा

36
00:01:50,520 --> 00:01:56,340
इस तरह से है, जहां हम एक बाएं पिरामिड है,
कुछ अंतर है, और फिर एक सही पिरामिड।

37
00:01:56,340 --> 00:01:58,630
तो चलो इस नीचे एक छोटा सा तोड़ देना।

38
00:01:58,630 --> 00:02:03,510
>> अगर मैं अपने पाठ संपादक के लिए जाना है, यहाँ मैं
हमें एक बाएं गठबंधन पिरामिड खींचा।

39
00:02:03,510 --> 00:02:05,160
लेकिन ऐसा नहीं होगा।

40
00:02:05,160 --> 00:02:10,139
क्या हम करना चाहते हैं कि हम चाहते है
पहली बार एक सही गठबंधन पिरामिड बनाते हैं।

41
00:02:10,139 --> 00:02:13,580
तो यह करने के लिए, बस पुश करने के लिए
पक्ष के साथ मेरी हैश,

42
00:02:13,580 --> 00:02:18,240
मैं बस कुछ पात्रों डाल करने के लिए जा रहा हूँ
के बीच, बस इन बिंदुओं में।

43
00:02:18,240 --> 00:02:22,560
तब मैं पर दो डाल करने के लिए जा रहा हूँ
अगली पंक्ति है, और उस लाइन पर एक।

44
00:02:22,560 --> 00:02:26,070
और तो यहाँ मैं एक है
सही गठबंधन पिरामिड।

45
00:02:26,070 --> 00:02:28,540
>> उसके बाद, मैं जा रहा हूँ
शीर्ष पंक्ति के लिए वापस जाओ

46
00:02:28,540 --> 00:02:33,930
और खाई में डाल दिया जो
कल्पना, दो रिक्त स्थान के प्रति है।

47
00:02:33,930 --> 00:02:37,680
तब मैं में भरने के लिए जा रहा हूँ
पिरामिड के दूसरी ओर।

48
00:02:37,680 --> 00:02:42,030
मैं दूसरी पंक्ति में जाने के लिए जा रहा हूँ, के बारे में
अंतर के लिए दो स्थानों और फिर दो

49
00:02:42,030 --> 00:02:42,920
hashes।

50
00:02:42,920 --> 00:02:47,020
वापस तीसरी पंक्ति के लिए, दो रिक्त स्थान
खाई और तीन हैश के लिए।

51
00:02:47,020 --> 00:02:51,480
और अंत में, दो रिक्त स्थान
खाई और चार हैश के लिए।

52
00:02:51,480 --> 00:02:54,400
तो यह है कि क्या एक पूर्ण
पिरामिड की तरह दिखेगा।

53
00:02:54,400 --> 00:02:57,260
>> बेशक, हम नहीं चाहते हैं
रास्ते में इन डॉट्स।

54
00:02:57,260 --> 00:03:01,220
इसलिए हम इन को बदलने के लिए जा रहे हैं
में कुछ रिक्त स्थान डाल द्वारा डॉट्स।

55
00:03:01,220 --> 00:03:03,720
एक, दो, तीन पहली पंक्ति पर।

56
00:03:03,720 --> 00:03:05,650
एक, दो दूसरे पर।

57
00:03:05,650 --> 00:03:08,200
और तीसरी पंक्ति पर एक।

58
00:03:08,200 --> 00:03:12,060
तो यह है कि हम अगर हम क्या करना होगा
सिर्फ एक पूर्ण पिरामिड बनाना चाहते थे,

59
00:03:12,060 --> 00:03:13,700
हमारे पाठ संपादक में कहते हैं,।

60
00:03:13,700 --> 00:03:15,860
>> तो चलो इस लेते हैं,
पैटर्न को समझने,

61
00:03:15,860 --> 00:03:19,870
और यह कुछ pseudocode खत्म करने के लिए परिवर्तित।

62
00:03:19,870 --> 00:03:24,500
पिरामिड के प्रत्येक पंक्ति के लिए, हम चाहते हैं
छोड़ दिया पिरामिड प्रिंट और फिर करने के लिए

63
00:03:24,500 --> 00:03:26,580
खाई और फिर सही पिरामिड।

64
00:03:26,580 --> 00:03:30,260
बाएं पिरामिड के लिए, हम प्रिंट
रिक्त स्थान की आवश्यक राशि,

65
00:03:30,260 --> 00:03:31,740
हैश द्वारा पीछा किया।

66
00:03:31,740 --> 00:03:35,030
तो फिर हम अंतर है, जो मुद्रित
हर बार सिर्फ दो रिक्त स्थान है।

67
00:03:35,030 --> 00:03:38,080
और सही पिरामिड में, हम प्रिंट
हैश की अपेक्षित संख्या।

68
00:03:38,080 --> 00:03:41,410
>> दूसरी पंक्ति के लिए, हम आयोजित
एक ही सटीक प्रक्रिया।

69
00:03:41,410 --> 00:03:44,510
हम छोड़ के लिए रिक्त स्थान के लिए प्रिंट
पिरामिड, आवश्यक राशि

70
00:03:44,510 --> 00:03:49,930
हैश, गैप, दो रिक्त स्थान है, और का
फिर सही पिरामिड के लिए हैश।

71
00:03:49,930 --> 00:03:52,490
>> के पैटर्न से निपटने के चलो
बाएं पिरामिड के लिए।

72
00:03:52,490 --> 00:03:55,660
अगर मैं था, उद्देश्यों के लिए
इस उदाहरण के लिए, एक ऊंचाई

73
00:03:55,660 --> 00:03:58,790
आठ साल की द्वारा अनुरोध
उपयोगकर्ता, तो मेरी पहली पंक्ति

74
00:03:58,790 --> 00:04:01,020
एक हैश और सात रिक्त स्थान होता है।

75
00:04:01,020 --> 00:04:03,860
मेरे दूसरी पंक्ति के लिए होता है
दो हैश, छह रिक्त स्थान।

76
00:04:03,860 --> 00:04:06,749
तीसरी पंक्ति, तीन हैश, पांच रिक्त स्थान।

77
00:04:06,749 --> 00:04:09,040
आपको शायद यह कर सकते हैं
खुद के आठ की ऊंचाई के लिए

78
00:04:09,040 --> 00:04:13,470
और प्रत्येक पंक्ति के लिए निर्धारित कितने
हैश और कितने रिक्त स्थान की जरूरत है।

79
00:04:13,470 --> 00:04:16,209
लेकिन क्या हम करना चाहते है
हम इसे अमूर्त करना चाहते हैं।

80
00:04:16,209 --> 00:04:22,660
इसलिए मुझे लगता है कि आप किसी भी पंक्ति वें, कितने के लिए पूछना
हैश और हम कितने रिक्त स्थान की जरूरत है?

81
00:04:22,660 --> 00:04:25,410
>> अब, आप यह निर्धारित के रूप में
कितने हैश के लिए पैटर्न

82
00:04:25,410 --> 00:04:29,920
और कितने रिक्त स्थान के लिए आप की जरूरत है
एक दिया ऊंचाई के लिए किसी भी nth पंक्ति,

83
00:04:29,920 --> 00:04:32,910
सावधान रहने की याद
कैसे आप अनुक्रमण रहे हैं।

84
00:04:32,910 --> 00:04:37,160
मैं इस से क्या मतलब है हर रोज में वह यह है कि
जीवन हम में से ज्यादातर एक करके गिनती शुरू।

85
00:04:37,160 --> 00:04:39,680
तो पहली पंक्ति नंबर एक हो जाएगा।

86
00:04:39,680 --> 00:04:43,620
और दूसरी पंक्ति पंक्ति होगा
नंबर दो, इतने पर और आगे।

87
00:04:43,620 --> 00:04:47,620
>> लेकिन कंप्यूटर विज्ञान के क्षेत्र में और
CS50, हम शून्य अनुक्रमित रहे हैं।

88
00:04:47,620 --> 00:04:50,750
इसलिए हम वास्तव में शून्य पर गिनती शुरू।

89
00:04:50,750 --> 00:04:54,020
तो पहली पंक्ति होगा
पंक्ति संख्या शून्य हो।

90
00:04:54,020 --> 00:04:56,640
और दूसरी पंक्ति
पंक्ति नंबर एक हो जाएगा।

91
00:04:56,640 --> 00:05:02,510
तो अगर मैं के लिए आठ की ऊंचाई था
मेरे पिरामिड, तो n के अंतिम मान

92
00:05:02,510 --> 00:05:05,850
वास्तव में सात और आठ नहीं होगा।

93
00:05:05,850 --> 00:05:07,010
>> इसलिए इस बारे में सावधान रहना होगा।

94
00:05:07,010 --> 00:05:10,750
और पता है जब आप का निर्धारण कर रहे हो
अपने पैटर्न है कि क्या आपके शून्य अनुक्रमित

95
00:05:10,750 --> 00:05:12,360
या एक अनुक्रमित

96
00:05:12,360 --> 00:05:13,070
>> ठीक।

97
00:05:13,070 --> 00:05:15,380
तो अब है कि हम
बाएं पिरामिड के लिए पैटर्न,

98
00:05:15,380 --> 00:05:18,650
हम यह निर्धारित करने की जरूरत है
अंतर के लिए पैटर्न।

99
00:05:18,650 --> 00:05:20,480
सौभाग्य से, यह वास्तव में आसान है।

100
00:05:20,480 --> 00:05:22,690
यह सिर्फ हमेशा दो रिक्त स्थान है।

101
00:05:22,690 --> 00:05:25,240
>> तो अब हम सही पैटर्न के लिए आगे बढ़ें।

102
00:05:25,240 --> 00:05:27,220
पहली पंक्ति में एक हैश होगा।

103
00:05:27,220 --> 00:05:28,640
दूसरी पंक्ति, दो।

104
00:05:28,640 --> 00:05:29,530
तीसरी पंक्ति, तीन।

105
00:05:29,530 --> 00:05:30,790
इसी तरह आगे भी।

106
00:05:30,790 --> 00:05:35,540
तो फिर, किसी भी सार के लिए निर्धारित
n और किसी भी ऊंचाई कितने हैश

107
00:05:35,540 --> 00:05:38,810
और कितने रिक्त स्थान
प्रत्येक पंक्ति होनी चाहिए।

108
00:05:38,810 --> 00:05:39,700
>> ठीक।

109
00:05:39,700 --> 00:05:45,050
तो हम जानते हैं कि प्रत्येक पंक्ति के लिए हम
कुछ प्रक्रिया का संचालन करने की जरूरत है।

110
00:05:45,050 --> 00:05:46,600
हम इसे कैसे करते हैं?

111
00:05:46,600 --> 00:05:50,440
खैर, हम पाश निर्माण के लिए उपयोग करते हैं,
एक initialization के शामिल,

112
00:05:50,440 --> 00:05:52,310
एक शर्त है, और एक अद्यतन।

113
00:05:52,310 --> 00:05:54,830
छोरों इस्तेमाल किया जा सकता है
प्रक्रियाओं को दोहराने के लिए।

114
00:05:54,830 --> 00:05:59,610
>> तो कहते हैं कि मैं यह हैलो कहने के लिए करना चाहते हैं,
दुनिया में 50 बार, तो मेरी पाश के लिए

115
00:05:59,610 --> 00:06:03,510
कुछ इस तरह लग रही होगी, जहां
मैं शून्य करने के लिए मेरे चर प्रारंभ।

116
00:06:03,510 --> 00:06:06,200
शर्त यह है कि मैं कम से कम 50 है।

117
00:06:06,200 --> 00:06:09,670
और उसके बाद अद्यतन यह है कि
एक हर समय से वेतन वृद्धि।

118
00:06:09,670 --> 00:06:14,700
तो यह क्या करना होगा करने के लिए होगा
एक पंक्ति में हैलो प्रिंट, दुनिया में 50 बार।

119
00:06:14,700 --> 00:06:18,080
>> अब, मैं पुनरावृति करना चाहता था कहना
पिरामिड की ऊंचाई पर।

120
00:06:18,080 --> 00:06:21,560
फिर मुश्किल कोडिंग के बजाय
हालत में कुछ मूल्य,

121
00:06:21,560 --> 00:06:23,280
मैं सिर्फ चर ऊंचाई का उपयोग करें।

122
00:06:23,280 --> 00:06:27,180
तो यह क्या करेंगे पुनरावृति है
ऊंचाई प्रत्येक पंक्ति पर।

123
00:06:27,180 --> 00:06:30,280
और मैं कुछ अंदर क्या कर सकते हैं
कि पाश के शरीर की।

124
00:06:30,280 --> 00:06:32,710
>> क्या हम क्या करना चाहते हैं
पाश के शरीर के अंदर?

125
00:06:32,710 --> 00:06:36,550
खैर, जैसा कि हम पहले संकेत दिया है, हम चाहते हैं
रिक्त स्थान है और हैश मुद्रित करने के लिए

126
00:06:36,550 --> 00:06:40,730
बाएं पिरामिड और फिर प्रिंट के लिए
दो स्थानों और फिर हैश प्रिंट।

127
00:06:40,730 --> 00:06:42,500
इसलिए हम पहले से ही है कि पता लगा लिया है।

128
00:06:42,500 --> 00:06:45,670
इसलिए हम को भरने के लिए शुरू कर सकते हैं
हमारे कार्यक्रम में एक बहुत अधिक।

129
00:06:45,670 --> 00:06:49,850
>> यहाँ मैं पाश के लिए एक बाहरी है
पिरामिड में हर पंक्ति पर दोहराता।

130
00:06:49,850 --> 00:06:53,340
और कहा कि शरीर के अंदर मैं जा रहा हूँ
बार बार रिक्त स्थान मुद्रित करने के लिए,

131
00:06:53,340 --> 00:06:56,860
बार बार हेश, और फिर अंतर है,
और फिर सही पिरामिड के लिए हेश,

132
00:06:56,860 --> 00:07:00,440
और फिर, अंत में, एक नया
लाइन अगली पंक्ति शुरू करने के लिए।

133
00:07:00,440 --> 00:07:02,860
>> उस के साथ, हम के लिए प्रेरित किया है
इनपुट के लिए उपयोगकर्ता।

134
00:07:02,860 --> 00:07:04,510
हमें यकीन है कि यह वैध है बनाया है।

135
00:07:04,510 --> 00:07:06,280
और फिर हम पिरामिड तैयार कर लिया है।

136
00:07:06,280 --> 00:07:09,540
तो मारियो कर सकते हैं सफलतापूर्वक
पिरामिड चढ़ाई।

137
00:07:09,540 --> 00:07:10,970
>> मेरा नाम Zamyla है।

138
00:07:10,970 --> 00:07:13,840
और इस CS50 है।

139
00:07:13,840 --> 00:07:15,419