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

2
00:00:09,250 --> 00:00:11,070
>> ZAMYLA चान: मारियो में कूद करते हैं.

3
00:00:11,070 --> 00:00:14,850
मारियो हम बना देंगे, जहां एक कार्यक्रम है हमारी
आदिम, संस्करण के यद्यपि, के मालिक हैं

4
00:00:14,850 --> 00:00:17,760
एक क्लासिक सुपर मारियो ब्रदर्स
खेल पृष्ठभूमि.

5
00:00:17,760 --> 00:00:21,100
इस समस्या सेट के लिए, हम जा रहे हैं
के लिए आधा पिरामिड विश्राम करने के लिए

6
00:00:21,100 --> 00:00:23,000
मारियो पर कूदने के लिए.

7
00:00:23,000 --> 00:00:27,330
हमारे कार्यक्रम सहभागी हो, तो यह
इनपुट एक निश्चित करने के लिए उपयोगकर्ता पूछेंगे

8
00:00:27,330 --> 00:00:28,660
पिरामिड के लिए ऊंचाई.

9
00:00:28,660 --> 00:00:32,920
और प्रोग्राम एक बाहर प्रिंट होगा
उस ऊंचाई का आधा पिरामिड, जहां

10
00:00:32,920 --> 00:00:37,390
नीचे बाएँ हैश नीचे के साथ संरेखित करता है
टर्मिनल के बाएँ कोने

11
00:00:37,390 --> 00:00:39,710
उत्पादन खिड़की.

12
00:00:39,710 --> 00:00:44,870
>> दो भागों में इस समस्या को तोड़ने,
एक, उपयोगकर्ता इनपुट, और दो पाने,

13
00:00:44,870 --> 00:00:47,040
पिरामिड बाहर प्रिंट.

14
00:00:47,040 --> 00:00:51,150
याद रखें कि हालांकि GetInt समारोह
यदि आप एक पूर्णांक प्राप्त होगा

15
00:00:51,150 --> 00:00:56,260
इस निवेश में आता है कि यह सुनिश्चित करना है
भावना अपने कार्यक्रम के लिए, में तो

16
00:00:56,260 --> 00:00:59,690
मारियो, यह नहीं चलेगा सिर्फ एक
एक पूर्णांक के लिए उत्पाद.

17
00:00:59,690 --> 00:01:03,440
तुम्हें यकीन है कि बनाने की आवश्यकता होगी उपयोगकर्ता
भीतर है कि एक पूर्णांक आदानों

18
00:01:03,440 --> 00:01:06,985
के निचले और ऊपरी सीमा
आप मुद्रित कर सकते हैं कि पिरामिड.

19
00:01:06,985 --> 00:01:12,300
इस कल्पना के अनुसार, यह है
0 और समावेशी 23.

20
00:01:12,300 --> 00:01:16,410
उपयोगकर्ता के बाहर एक पूर्णांक आदानों हैं
हमारे स्वीकार सीमा से, तो हम चाहते हैं

21
00:01:16,410 --> 00:01:20,840
जब तक उन्हें बार बार संकेत करने के लिए
वे हमें एक वैध पूर्णांक दे.

22
00:01:20,840 --> 00:01:25,990
>> सही उपयोगकर्ता इनपुट सुनिश्चित करने के लिए एक ही रास्ता है
है जो एक मत का समय पाश, का उपयोग करके

23
00:01:25,990 --> 00:01:28,100
एक समय पाश के समान है.

24
00:01:28,100 --> 00:01:32,580
मत का समय पाश कोड निष्पादित
एक बार, और तब चेक शरीर के अंदर

25
00:01:32,580 --> 00:01:35,270
शर्त पूरी है या नहीं.

26
00:01:35,270 --> 00:01:38,830
इस उपयोगकर्ता इनपुट प्राप्त करने के लिए उपयोगी है
आपको जरूरत है कि आप जानते हैं, क्योंकि

27
00:01:38,830 --> 00:01:41,805
कम से कम एक बार उन्हें संकेत करने के लिए.

28
00:01:41,805 --> 00:01:45,940
हालत, कार्यक्रम नहीं मिले है
बाद लाइन पर अमल करेंगे

29
00:01:45,940 --> 00:01:47,270
अपने मत का समय पाश.

30
00:01:47,270 --> 00:01:50,950
शर्त पूरी कर रहा है, हालांकि,
पाश दोहराना होगा.

31
00:01:50,950 --> 00:01:55,560
>> उपयोगकर्ता मान्य करने के लिए एक है, जबकि पाश
इनपुट कुछ इस तरह देखना होगा.

32
00:01:55,560 --> 00:02:02,920
मैं एक चर एन, GetInt घोषित
n मान्य है जब तक और दोहराएँ.

33
00:02:02,920 --> 00:02:06,270
आप की घोषणा जब याद रखें कि आपके
चर, यह उचित जरूरत

34
00:02:06,270 --> 00:02:08,449
सिर्फ खरोंच में जैसे गुंजाइश.

35
00:02:08,449 --> 00:02:12,510
मैं अपने मत का समय पाश अंदर n घोषित, तो
कार्यक्रम के बाकी नहीं होगा

36
00:02:12,510 --> 00:02:13,750
यह उपयोग करने में सक्षम.

37
00:02:13,750 --> 00:02:16,100
यह सीमीत तक ही सीमित है
घुंघराले ब्रेसिज़ की.

38
00:02:16,100 --> 00:02:19,010

39
00:02:19,010 --> 00:02:23,090
>> ठीक है, तो अब हम मान्य किया है कि
उपयोगकर्ता के इनपुट, हम वास्तव में करने की जरूरत है

40
00:02:23,090 --> 00:02:25,020
यह आधे पिरामिड आकर्षित.

41
00:02:25,020 --> 00:02:29,700
यह इसलिए, मुद्रित वर्णों से बना है
एक साधारण में एक आधा पिरामिड बनाते हैं

42
00:02:29,700 --> 00:02:31,480
पाठ संपादक.

43
00:02:31,480 --> 00:02:35,920
हम एक मारियो शैली पिरामिड बनाना चाहते हैं
गठबंधन है कि ऊंचाई तीन से

44
00:02:35,920 --> 00:02:41,370
हमारे विंडो के बाईं ओर, तब पर
हम दो हैश को टाइप करेंगे, क्लिक करें दर्ज करें,

45
00:02:41,370 --> 00:02:47,180
फिर तीन हैश को लिखें पर क्लिक करें
दर्ज करें, और उसके बाद चार लिखें.

46
00:02:47,180 --> 00:02:51,090
>> लेकिन इस समस्या में, सेट हमारी
आधा पिरामिड सही गठबंधन हो गया है.

47
00:02:51,090 --> 00:02:55,550
एक मानक कीबोर्ड का प्रयोग, कैसे हो सकता है
आप हैश को स्थानांतरित करने के लिए इस फ़ाइल को संशोधित

48
00:02:55,550 --> 00:02:57,210
दाएं खत्म करने के लिए?

49
00:02:57,210 --> 00:03:03,190
मैं पर रेखांकित, दो के लिए उपयोग हो सकता है
शीर्ष पंक्ति और दूसरे पर एक.

50
00:03:03,190 --> 00:03:07,690
यही तो है, हालांकि, के रूप में अच्छा नहीं लगता
के साथ रेखांकित की जगह

51
00:03:07,690 --> 00:03:12,450
रिक्त स्थान है, और वहाँ हम एक आधा पिरामिड है
ऊंचाई तीन की.

52
00:03:12,450 --> 00:03:16,330
>> इस पाठ संपादक की कोशिश करो और याद
उदाहरण आप को वापस सोच शुरू

53
00:03:16,330 --> 00:03:20,100
सी. की कोशिश करते हैं और कुछ बाहर आंकड़ा
पैटर्न की तरह है कि हम कर सकते हैं

54
00:03:20,100 --> 00:03:22,750
एक पाश निर्माण में डाल दिया.

55
00:03:22,750 --> 00:03:27,570
एक उदाहरण ऊंचाई लो, आठ, कहना
आप को शुरू कर सकते हैं और देखो अगर

56
00:03:27,570 --> 00:03:29,470
एक पैटर्न के साथ आते हैं.

57
00:03:29,470 --> 00:03:34,710
पहली पंक्ति में सात रिक्त स्थान होगा
दो हैश द्वारा पीछा किया.

58
00:03:34,710 --> 00:03:40,090
दूसरी पंक्ति छह रिक्त स्थान है और होगा
इतने पर तीन हैश, और जब तक

59
00:03:40,090 --> 00:03:41,440
आठवीं पंक्ति.

60
00:03:41,440 --> 00:03:45,210
>> लेकिन यह कैसे आप का प्रतिनिधित्व करेंगे है
n वाँ पंक्ति?

61
00:03:45,210 --> 00:03:48,170
प्रोग्रामिंग है कि सम्मेलन याद रखें
शून्य अनुक्रमित है.

62
00:03:48,170 --> 00:03:51,870
यही कारण है कि आप कम से गिनती शुरू मतलब है कि
शून्य, तो पहली पंक्ति तकनीकी रूप से है

63
00:03:51,870 --> 00:03:57,110
दो hatches, पंक्ति के साथ पंक्ति संख्या शून्य
नंबर एक तीन हैश, पंक्ति होती है

64
00:03:57,110 --> 00:04:01,860
नंबर दो तो निम्न, चार हैश है
किसी भी पंक्ति के लिए इस पद्धति

65
00:04:01,860 --> 00:04:05,800
संख्या एन, एन प्लस 2 hashes कर रहे हैं.

66
00:04:05,800 --> 00:04:09,270
मैं लगता है, हालांकि, आप के लिए छोड़ दूँगा
रिक्त स्थान के लिए पैटर्न बाहर.

67
00:04:09,270 --> 00:04:12,240
अपने स्वरूप हो जाएगा याद
थोड़ा अलग यदि आप चुनते हैं

68
00:04:12,240 --> 00:04:16,649
से अपनी गिनती शुरू
एक और शून्य नहीं.

69
00:04:16,649 --> 00:04:19,560
>> अब, आप के लिए एक पैटर्न है
किसी भी सार पंक्ति एन.

70
00:04:19,560 --> 00:04:25,190
आप प्रिंट और कितने रिक्त स्थान पता
कितने हैश, ताकि प्रत्येक पंक्ति के लिए, कि

71
00:04:25,190 --> 00:04:26,270
नंबर बदल जाएगा.

72
00:04:26,270 --> 00:04:30,700
लेकिन मुद्रण एक की इसी प्रक्रिया
एक चरित्र, या तो एक अंतरिक्ष या एक

73
00:04:30,700 --> 00:04:33,200
हैश, दोहराया है.

74
00:04:33,200 --> 00:04:37,470
तो तुम सब करना है बार बार है
के रूप में कई बार के लिए कि चरित्र मुद्रित

75
00:04:37,470 --> 00:04:40,120
अपने स्वरूप को निर्धारित करता है.

76
00:04:40,120 --> 00:04:42,522
>> तो कैसे हम प्रक्रियाओं को दोहराने करते हैं?

77
00:04:42,522 --> 00:04:45,160
खरोंच में, हम दोहराने ब्लॉक का इस्तेमाल किया.

78
00:04:45,160 --> 00:04:48,580
सी में, हम एक पाश के लिए इस्तेमाल करेंगे.

79
00:04:48,580 --> 00:04:51,290
वाक्यविन्यास पर देखें
छोरों के लिए.

80
00:04:51,290 --> 00:04:57,140
>> पाश के लिए प्रत्येक तीन से बना है
भागों, एक initialization, एक शर्त है,

81
00:04:57,140 --> 00:04:58,592
और एक अद्यतन.

82
00:04:58,592 --> 00:05:01,550
आपके लिए लूप को प्रारंभ होगा
एक चर जब यह पहली बार

83
00:05:01,550 --> 00:05:02,960
के लिए लूप में प्रवेश करती है.

84
00:05:02,960 --> 00:05:07,100
शर्त पूरी होती है, शरीर
पाश की क्रियान्वित करेगा.

85
00:05:07,100 --> 00:05:10,070
बाद में, अद्यतन पर अमल करेंगे.

86
00:05:10,070 --> 00:05:13,630
>> हालत अभी भी पूरा किया जाता है,
पाश निष्पादित और अद्यतन और होगा

87
00:05:13,630 --> 00:05:18,580
अपनी शर्त के रूप में लंबे समय के रूप दोहराने
सही मूल्यांकन.

88
00:05:18,580 --> 00:05:21,450
तुम हो हालत अंततः valuate चाहिए
ग़लत करने के लिए, हालांकि, क्योंकि

89
00:05:21,450 --> 00:05:24,490
स्क्रैच के विपरीत, हम नहीं
किसी भी हमेशा के छोरों है.

90
00:05:24,490 --> 00:05:28,270
आपका कार्यक्रम अंततः समाप्त होना चाहिए.

91
00:05:28,270 --> 00:05:32,330
>> यहाँ एक का एक उदाहरण पाश के लिए है कि
आप मारियो के लिए उपयोग करने के लिए चाहते हो सकता है.

92
00:05:32,330 --> 00:05:36,790
आरंभीकरण वाणी
मान 0 के साथ एक पूर्णांक मैं.

93
00:05:36,790 --> 00:05:40,750
जब तक मैं ऊंचाई से कम है, के रूप में
पाश के शरीर पर अमल करेंगे और

94
00:05:40,750 --> 00:05:44,980
एक और दोहराने से मैं वृद्धि
मैं से अधिक है या जब तक

95
00:05:44,980 --> 00:05:47,220
ऊंचाई के बराबर.

96
00:05:47,220 --> 00:05:49,140
>> अब, मेरे लिए लूप शून्य सूचकांक है.

97
00:05:49,140 --> 00:05:52,270
इंटरनैशनल मैं एक नहीं, शून्य में शुरू होता है.

98
00:05:52,270 --> 00:05:55,320
मैं एक चुना है, तो मेरी हालत होगा
यह भी के लिए अलग रहना होगा

99
00:05:55,320 --> 00:05:58,740
निष्पादित करने के लिए लूप
कई बार एक ही नंबर.

100
00:05:58,740 --> 00:06:03,490
जब आप ध्यान से यह याद रखें
आपके प्रारम्भ और चयन अपने

101
00:06:03,490 --> 00:06:08,660
हालत है, और इस से परामर्श
दोहरी जांच करने के लिए चार्ट.

102
00:06:08,660 --> 00:06:13,430
>> कंप्यूटर के बारे में महान चीज़ों में से एक
विज्ञान अभी तो कई है कि वहाँ है

103
00:06:13,430 --> 00:06:15,490
चीजों को निष्पादित करने के तरीके.

104
00:06:15,490 --> 00:06:19,450
आप चुन सकते हैं कि क्या आप
शून्य या एक पर शुरू करते हैं.

105
00:06:19,450 --> 00:06:22,380
आप पाश के लिए एक का उपयोग नहीं करना चाहते हैं,
आप भी एक जबकि पाश के लिए उपयोग कर सकते हैं

106
00:06:22,380 --> 00:06:26,530
आप लंबे समय के रूप में बयान दोहराने
एक के लिए लूप का सार रखना,

107
00:06:26,530 --> 00:06:31,430
आरंभीकरण, हालत, और अद्यतन.

108
00:06:31,430 --> 00:06:36,890
हम के लिए लूप समझ से बाहर है कि एक बार
हम साथ सबसे अधिक आरामदायक हो, तो हम

109
00:06:36,890 --> 00:06:38,450
मारियो पूरा कर सकते हैं.

110
00:06:38,450 --> 00:06:41,540
>> हम पहले उपयोगकर्ता इनपुट के लिए जाँच
और फिर एक पहचान

111
00:06:41,540 --> 00:06:43,580
किसी भी पंक्ति N के लिए पैटर्न.

112
00:06:43,580 --> 00:06:49,990
इसलिए प्रत्येक पंक्ति के लिए शून्य से n करने के लिए शून्य से 1
की उचित संख्या मुद्रित होगा

113
00:06:49,990 --> 00:06:55,340
रिक्त स्थान की तो उचित संख्या
हमारे पैटर्न के अनुसार hashes, और

114
00:06:55,340 --> 00:06:57,180
फिर एक नई लाइन.

115
00:06:57,180 --> 00:06:59,640
उस के साथ, आप अपने पिरामिड है.

116
00:06:59,640 --> 00:07:02,630
मेरा नाम Zamyla है, और इस मारियो था.

117
00:07:02,630 --> 00:07:11,765