1
00:00:00,000 --> 00:00:00,982

2
00:00:00,982 --> 00:00:11,293
>> [संगीत खेल]

3
00:00:11,293 --> 00:00:13,580
>> आरओबी BOWDEN: यह, रोब मुझे है.

4
00:00:13,580 --> 00:00:16,540
यह कैसे के माध्यम से चलते हैं
मारियो को लागू करने के लिए.

5
00:00:16,540 --> 00:00:21,040
तो हम क्या करने की जरूरत है पहली बात है
इनपुट के लिए उपयोगकर्ता prompt.

6
00:00:21,040 --> 00:00:24,440
>> हम वास्तव में कैसे उन्हें पूछने की जरूरत
लंबा पिरामिड होना चाहिए.

7
00:00:24,440 --> 00:00:27,110
यहाँ तो, हम हम क्या कर रहे हैं देखने
ऊंचाई = GetInt.

8
00:00:27,110 --> 00:00:32,479
एक और याद रखें कि GetInt समारोह
CS50 में कार्यान्वित किया जाता है

9
00:00:32,479 --> 00:00:38,060
पुस्तकालय, तो शीर्ष तक, हम करने की आवश्यकता
# को याद cs50.h. शामिल

10
00:00:38,060 --> 00:00:41,360
>> तो क्यों न हम इस लिपटे क्या ज़रूरत है
एक मत का समय पाश में?

11
00:00:41,360 --> 00:00:45,080
खैर, हम भी याद करने की जरूरत
उपयोगकर्ता के इनपुट वैध हो गया है.

12
00:00:45,080 --> 00:00:46,910
एक अमान्य इनपुट क्या है?

13
00:00:46,910 --> 00:00:51,460
खैर pset कल्पना विशेष रूप से कहते हैं
कि एक ऊंचाई कम से कम 0 या अधिक से अधिक

14
00:00:51,460 --> 00:00:54,530
23 अवैध है से.

15
00:00:54,530 --> 00:00:59,030
>> तो यहाँ, हम हम तय कर रहे हैं कि देखने
साथ MAX_HEIGHT नामक एक स्थिर

16
00:00:59,030 --> 00:01:00,750
23 की मूल्य.

17
00:01:00,750 --> 00:01:06,380
इस मत का समय पाश जबकि जारी रहेगा
ऊंचाई कम से कम 0 या MAX_HEIGHT है

18
00:01:06,380 --> 00:01:11,870
जिसका मतलब है कि ऊंचाई, से भी कम
23 ऊंचाई की तुलना में कम है.

19
00:01:11,870 --> 00:01:15,390
ऊंचाई 24 या अधिक से अधिक है, तो हम कर रहे हैं
पाशन जारी रखने के लिए जा रहा है.

20
00:01:15,390 --> 00:01:18,300
याद रखें कि ऐसा करते हुए छोरों सुंदर हैं
सहायक हम प्राप्त करना चाहते हैं जब भी

21
00:01:18,300 --> 00:01:22,070
उपयोगकर्ता इनपुट और तब से यह मान्य
हम निश्चित रूप से उपयोगकर्ता पूछने की जरूरत

22
00:01:22,070 --> 00:01:25,010
कम से कम एक बार वे चाहते हैं मूल्य के लिए.

23
00:01:25,010 --> 00:01:28,500
>> तो एक बार हम उनके इनपुट है, हम
अब पिरामिड का निर्माण कर सकते हैं.

24
00:01:28,500 --> 00:01:31,940
सेट इस समस्या की चालों में से एक है
हम में से शीर्ष पर शुरू करने के लिए है कि

25
00:01:31,940 --> 00:01:32,750
पिरामिड.

26
00:01:32,750 --> 00:01:36,800
आप के नीचे printf नहीं कर सकते
पिरामिड और फिर अपनी तरह का निर्माण.

27
00:01:36,800 --> 00:01:38,830
तो चलो उदाहरण को देखो
pset कल्पना से.

28
00:01:38,830 --> 00:01:41,530

29
00:01:41,530 --> 00:01:45,430
>> हम यहाँ देखते हैं कि हम एक ऊंचाई दर्ज करते समय
8 के, के बहुत नीचे

30
00:01:45,430 --> 00:01:48,660
पिरामिड नौ हैश को मुद्रित करता है.

31
00:01:48,660 --> 00:01:52,990
उस से एक स्तर ऊपर प्रिंट
एक अंतरिक्ष और आठ हैश को.

32
00:01:52,990 --> 00:01:58,250
उस से एक स्तर ऊपर दो स्थानों और है
सात हैश, सभी तरह जब तक हम

33
00:01:58,250 --> 00:02:03,050
जो पिरामिड के शीर्ष पर ले
सात मुद्रित करता है जो आठ स्तरों,

34
00:02:03,050 --> 00:02:06,000
रिक्त स्थान है और दो हैश को.

35
00:02:06,000 --> 00:02:08,810
तो हम करने के लिए है कि याद
पहली बार इस शीर्ष स्तर से करते हैं.

36
00:02:08,810 --> 00:02:11,620

37
00:02:11,620 --> 00:02:18,500
>> यहाँ हम से पुनरावृति रहे
शीर्ष स्तर, पंक्ति 8, सतत

38
00:02:18,500 --> 00:02:22,150
पंक्ति 0 पहुंचता है जब तक.

39
00:02:22,150 --> 00:02:25,820
तो कितने रिक्त स्थान की जरूरत है हम था
कि शीर्ष पंक्ति में मुद्रित करने के लिए?

40
00:02:25,820 --> 00:02:29,310
हम सात रिक्त स्थान मुद्रित
और दो हैश को.

41
00:02:29,310 --> 00:02:34,450
इसलिए हम चाहते हैं कि रिक्त स्थान की संख्या है
शून्य से 1 पर थे कि पंक्ति.

42
00:02:34,450 --> 00:02:39,310
>> शीर्ष पंक्ति 8, 8 शून्य है तो
1 हमें सात रिक्त स्थान देता है.

43
00:02:39,310 --> 00:02:43,770
तो फिर हम मुद्रित होगा कि एक पाश है
एक बार में एक अंतरिक्ष एक बाहर.

44
00:02:43,770 --> 00:02:47,450
तो जब रिक्त स्थान इस लूप, 7
सात बार, मुद्रण

45
00:02:47,450 --> 00:02:50,300
सात व्यक्ति रिक्त स्थान.

46
00:02:50,300 --> 00:02:54,672
>> तो अब हम इन हैश को मुद्रित करने की आवश्यकता
पिरामिड के अंत में.

47
00:02:54,672 --> 00:02:57,930
तो यहाँ, हम गणना करने की जरूरत
हैश की संख्या.

48
00:02:57,930 --> 00:03:01,930
हम ऊंचाई कर रहे हैं कि देखने
शून्य से पंक्ति प्लस 2.

49
00:03:01,930 --> 00:03:04,170
तो हम कैसे मिला?

50
00:03:04,170 --> 00:03:08,630
>> याद रखें कि पिरामिड के शीर्ष
पंक्ति 8 है, और ऊंचाई 8 है.

51
00:03:08,630 --> 00:03:10,890
और हम अभी भी दो हैश को मुद्रित.

52
00:03:10,890 --> 00:03:15,420
तो बहुत कम से कम 8 माइनस 8 प्लस
2 हमें सही जवाब देता है.

53
00:03:15,420 --> 00:03:19,170
और फिर नीचे पर विचार
पिरामिड की, 1 पंक्ति.

54
00:03:19,170 --> 00:03:24,020
लंबाई शून्य से पंक्ति हमें 7 देना होगा, और
तब प्लस 2 हमें नौ हैश को देता है,

55
00:03:24,020 --> 00:03:26,620
वास्तव में जो संख्या है
हम मुद्रित कि hashes.

56
00:03:26,620 --> 00:03:29,880
तो यह है कि हम करना चाहते सूत्र है
संख्या की गणना करने के लिए उपयोग

57
00:03:29,880 --> 00:03:32,220
प्रत्येक पंक्ति में hashes.

58
00:03:32,220 --> 00:03:36,020
>> उस नंबर का उपयोग करना, हम तो एक और है
बहुत से इसी तरह पाश, के लिए

59
00:03:36,020 --> 00:03:41,270
हम रिक्त स्थान के लिए प्रयोग किया जाता है कि पाश के लिए,
कि हैश को कई बार दोहराता संख्या

60
00:03:41,270 --> 00:03:43,720
एक ही हैश हर समय मुद्रण.

61
00:03:43,720 --> 00:03:46,010
शीर्ष पंक्ति पर, कि हूँ
दो हैश को मुद्रित.

62
00:03:46,010 --> 00:03:48,390
नीचे पंक्ति पर, कि हूँ
नौ हैश को मुद्रित.

63
00:03:48,390 --> 00:03:52,610
और एक दूसरे पंक्ति हर प्रिंट होगा
बीच में hashes की संख्या.

64
00:03:52,610 --> 00:03:57,340
>> और फिर बहुत अंत में, हम करने की आवश्यकता
अगले करने के लिए जाने के लिए हमारी नई लाइन के लिए प्रिंट

65
00:03:57,340 --> 00:03:59,400
पिरामिड में पंक्ति.

66
00:03:59,400 --> 00:04:03,070
अंत में, हम नई लाइन मुद्रित करने की आवश्यकता
पंक्ति के अंत करने के क्रम में कम से

67
00:04:03,070 --> 00:04:06,260
अगले करने के लिए जारी
पिरामिड की पंक्ति.

68
00:04:06,260 --> 00:04:08,980
और हमारे कार्यक्रम के अंत में,
हम वापसी 0 है.

69
00:04:08,980 --> 00:04:12,770
>> Pset कल्पना, वापसी के अनुसार
0 सख्ती जरूरी नहीं है.

70
00:04:12,770 --> 00:04:15,710
लेकिन यह मुख्य किया जाता है कि दर्शाता है.

71
00:04:15,710 --> 00:04:17,610
मेरा नाम रोब है, और इस मारियो था.

72
00:04:17,610 --> 00:04:22,470
>> [संगीत खेल]

73
00:04:22,470 --> 00:04:25,558