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

2
00:00:00,500 --> 00:00:02,500
ZAMYLA चान: यह मेरे, Zamyla है।

3
00:00:02,500 --> 00:00:06,910
मारियो में आज, हम होने जा रहे हैं
मारियो के लिए आधा पिरामिड ड्राइंग

4
00:00:06,910 --> 00:00:08,290
चढ़ा जाने वाला।

5
00:00:08,290 --> 00:00:11,570
>> तो चलो बारे में बात करते हमारे
इस समस्या के लिए करने के लिए करते है।

6
00:00:11,570 --> 00:00:13,610
हम चाहते करने जा रहे हैं
संकेत और मान्य करने के लिए

7
00:00:13,610 --> 00:00:18,290
कैसे का एक मान्य इनपुट के लिए उपयोगकर्ता
उच्च वे मारियो के पिरामिड होना चाहते हैं।

8
00:00:18,290 --> 00:00:20,090
और फिर, हम इसे आकर्षित करने के लिए जा रहे हैं।

9
00:00:20,090 --> 00:00:24,870
तो चलो उत्साह के साथ शुरू हो जाओ और
अपने इनपुट के लिए उपयोगकर्ता को मान्य।

10
00:00:24,870 --> 00:00:27,640
>> हम का उपयोग कर सकते
CS50 पुस्तकालय समारोह

11
00:00:27,640 --> 00:00:31,160
int है कि यह सुनिश्चित करेंगे कि मिल
उपयोगकर्ता एक पूर्णांक आदानों।

12
00:00:31,160 --> 00:00:35,730
किसी भी सकारात्मक पूर्णांक, नकारात्मक
पूर्णांकों, संख्या 0 सभी उचित खेल रहे हैं।

13
00:00:35,730 --> 00:00:41,670
अन्यथा, उपयोगकर्ता के लिए प्रेरित किया जाएगा
वे इनपुट एक मान्य पूर्णांक तक पुन: प्रयास करें।

14
00:00:41,670 --> 00:00:44,210
अब हालांकि मिल int करता है
हमारे लिए बहुत काम की

15
00:00:44,210 --> 00:00:46,730
सुनिश्चित करने में है कि
उपयोगकर्ता हमें एक पूर्णांक देता है,

16
00:00:46,730 --> 00:00:50,760
हम अभी भी कुछ लागू करने की आवश्यकता
उस पर अतिरिक्त बाधाओं।

17
00:00:50,760 --> 00:00:56,420
आखिर, हम मारियो चढ़ाई नहीं हो सकता
ऊंचाई नकारात्मक 12 की एक आधा पिरामिड।

18
00:00:56,420 --> 00:00:59,040
>> इसके अलावा,
समस्या विनिर्देश

19
00:00:59,040 --> 00:01:02,490
कहते हैं कि हम केवल यह कर सकते हैं
मारियो चढ़ाई करने की अनुमति

20
00:01:02,490 --> 00:01:06,940
0 और 23 के बीच ऊंचाइयों की एक पिरामिड।

21
00:01:06,940 --> 00:01:11,120
ठीक है, तो इसका मतलब है कि हम की जरूरत है
लगातार उपयोगकर्ता संकेत करने के लिए

22
00:01:11,120 --> 00:01:14,320
हमें एक वैध देने के लिए
संख्या और केवल जारी रखने के लिए

23
00:01:14,320 --> 00:01:17,120
एक बार वे हमें एक वैध ऊंचाई दी है।

24
00:01:17,120 --> 00:01:18,720
हम इसे कैसे करते हैं?

25
00:01:18,720 --> 00:01:23,760
>> खैर, निरंतर प्रक्रियाओं हमें दे
loops-- कुछ करने का विचार

26
00:01:23,760 --> 00:01:24,720
repetitively।

27
00:01:24,720 --> 00:01:28,220
थोड़ी देर के रूप में सी में एक पाश
पाश है कि लगातार होगा

28
00:01:28,220 --> 00:01:33,480
के रूप में लंबे समय के रूप पाश के शरीर पर अमल
दी शर्त सही करने के लिए मूल्यांकन करता है।

29
00:01:33,480 --> 00:01:36,200
जैसे ही यह है कि शर्त के रूप में
गलत का आकलन,

30
00:01:36,200 --> 00:01:39,770
कार्यक्रम के लिए आगे बढ़ना होगा
जो कुछ भी है कि उसके बाद आता है।

31
00:01:39,770 --> 00:01:43,180
तो, जबकि छोरों का एक तरीका है
कि हम लगातार यह सुनिश्चित करना

32
00:01:43,180 --> 00:01:45,320
एक वैध निवेश के लिए उपयोगकर्ता का संकेत।

33
00:01:45,320 --> 00:01:50,070
और एक बार वे हमें एक वैध इनपुट दे,
हम जो कुछ भी अगले आता है पर आगे बढ़ेंगे।

34
00:01:50,070 --> 00:01:54,380
हम जानते हैं कि हम पूछने के लिए जा रहे हैं
कम से कम एक बार इनपुट के लिए उपयोगकर्ता।

35
00:01:54,380 --> 00:01:59,200
तो अब हम की एक बहन के लिए आए
जबकि पाश, जो करते हैं, जबकि पाश है।

36
00:01:59,200 --> 00:02:02,650
>> जबकि छोरों पर अमल करेंगे करो
लूप के शरीर पर कम से कम एक बार।

37
00:02:02,650 --> 00:02:06,150
तो हालत की जाँच के बिना,
यह लूप के शरीर पर अमल करेंगे।

38
00:02:06,150 --> 00:02:09,750
और फिर स्थिति की जाँच देखने के लिए
चाहे वह खुद को दोहराने की जरूरत है।

39
00:02:09,750 --> 00:02:13,080
इस काम में आता है जब
हम उपयोगकर्ता इनपुट मान्य कर रहे हैं।

40
00:02:13,080 --> 00:02:15,830
हम जानते हैं कि हम जा रहे हैं
उन्हें कम से कम एक बार पूछने के लिए।

41
00:02:15,830 --> 00:02:18,780
तो एक करते हैं, जबकि पाश हो सकता है
कुछ इस तरह दिखेगा।

42
00:02:18,780 --> 00:02:20,090
हम एक पूर्णांक है।

43
00:02:20,090 --> 00:02:22,760
और करते हैं के अंदर
जबकि पाश, हम तुरंत

44
00:02:22,760 --> 00:02:24,750
एक पूर्णांक के लिए उपयोगकर्ता का संकेत।

45
00:02:24,750 --> 00:02:29,740
यदि n अमान्य है, तो हम उन्हें संकेत देंगे
फिर और फिर और फिर वे जब तक

46
00:02:29,740 --> 00:02:31,820
हमें जो मान्य पूर्णांक दे।

47
00:02:31,820 --> 00:02:37,440
अंत में, एक बार n एक मान्य इनपुट है, हम करेंगे
हमारे कार्यक्रम के आराम करने के लिए आगे बढ़ें।

48
00:02:37,440 --> 00:02:41,830
>> तो चलो कल्पना और जांच के लिए वापस जाओ
क्या एक वैध निवेश के लिए की स्थिति

49
00:02:41,830 --> 00:02:43,670
होने जा रहा है।

50
00:02:43,670 --> 00:02:48,090
वैध ऊंचाइयों तक जा रहे हैं
0 और 23 के बीच हो।

51
00:02:48,090 --> 00:02:53,350
इसलिए अवैध ऊंचाइयों तक जा रहे हैं
कम से कम 0 या 23 से अधिक हो।

52
00:02:53,350 --> 00:02:56,420
तो डिजाइन करने के लिए याद
अपनी हालत को ध्यान से,

53
00:02:56,420 --> 00:02:58,660
जानते हुए भी इस शर्त पर कि
करते हैं, जबकि पाश के लिए

54
00:02:58,660 --> 00:03:01,470
होना चाहिए, जबकि n अमान्य है।

55
00:03:01,470 --> 00:03:05,080
अब यह एक होने के लिए नहीं जा रहा है
सरल एकल बूलियन अभिव्यक्ति।

56
00:03:05,080 --> 00:03:07,630
हम गठबंधन करने के लिए जा रहे हैं
दो अलग अलग भाव

57
00:03:07,630 --> 00:03:09,900
हमारे पूरे हालत बनाने के लिए।

58
00:03:09,900 --> 00:03:13,290
>> तो चलो बस एक सच तालिका रहा है पर देखो
पहले से ही आप संकेत हम कर रहे हैं कि दिया

59
00:03:13,290 --> 00:03:15,200
दो Booleans के साथ काम किया जा रहा है।

60
00:03:15,200 --> 00:03:19,620
तो यहाँ एक सच तालिका जहां मैं
दो Booleans-- बूलियन 1 और 2 लोगों की है।

61
00:03:19,620 --> 00:03:27,050
इसलिए हम मूल्यांकन करने के लिए यह विकल्प होता है
bool1 और bool2 या bool1 या bool2।

62
00:03:27,050 --> 00:03:31,980
और केवल दोनों अगर सच हो जाएगा
Booleans, सच का मूल्यांकन जबकि सभी

63
00:03:31,980 --> 00:03:37,280
या लंबे समय के रूप में सच हो जाएगा में से एक के रूप में
दो Booleans सच करने के लिए मूल्यांकन करता है।

64
00:03:37,280 --> 00:03:41,450
ठीक है, तो एक क्षण ले, इस ठहराव
वीडियो और इस सच्चाई को पचाने की मेज।

65
00:03:41,450 --> 00:03:42,930
मैं यहीं इंतज़ार कर रहा हूँ।

66
00:03:42,930 --> 00:03:45,760
जब आप वापस आ जाओ, देखना
आप एक साथ टुकड़ा कर सकते हैं, तो

67
00:03:45,760 --> 00:03:51,910
के लिए एक बूलियन अभिव्यक्ति अपने
n की हालत गलत इनपुट जा रहा है।

68
00:03:51,910 --> 00:03:54,420
>> तो अब है कि हम
वैध उपयोगकर्ता इनपुट, चलो

69
00:03:54,420 --> 00:03:58,710
आगे जाना है और कैसे हम इस बारे में बात
आधे पिरामिड आकर्षित हो सकता है।

70
00:03:58,710 --> 00:04:03,410
यहाँ इस सरल पाठ संपादक में,
मैं एक बाएं गठबंधन पिरामिड तैयार कर लिया है।

71
00:04:03,410 --> 00:04:07,050
लेकिन हम जानते हैं कि हम अपनी जरूरत
पिरामिड सही गठबंधन किया है।

72
00:04:07,050 --> 00:04:08,650
तो मैं ऐसा कैसे कर सकता है?

73
00:04:08,650 --> 00:04:11,440
खैर, मैं पुश करने की कोशिश हो सकती है
ओर करने के लिए सब कुछ

74
00:04:11,440 --> 00:04:14,880
सिर्फ एक छोटे से डाल द्वारा
बीच में चरित्र।

75
00:04:14,880 --> 00:04:16,779
और फिर, अगले के लिए
लाइन, मैं डाला जा रहा हूँ

76
00:04:16,779 --> 00:04:20,970
कुछ और पात्रों यह पुश करने के साथ-साथ,
और further-- इतने पर और forth--

77
00:04:20,970 --> 00:04:23,360
जब तक मैं सही गठबंधन पिरामिड है।

78
00:04:23,360 --> 00:04:27,780
तो हम एक सही संरेखित पिरामिड है, लेकिन
यह डॉट्स के साथ इतना महान नहीं लगती है।

79
00:04:27,780 --> 00:04:30,680
लेकिन हम अभी भी चाहते
अच्छा है कि रिक्ति बनाए रखें।

80
00:04:30,680 --> 00:04:35,260
इसलिए मैं सचमुच जा रहा हूँ
कुछ रिक्त स्थान डालें।

81
00:04:35,260 --> 00:04:39,420
>> इसके बजाय तीन डॉट्स की, मैं हूँ
एक, दो, तीन स्थान डाल दिया।

82
00:04:39,420 --> 00:04:40,370
दूसरी लाइन पर।

83
00:04:40,370 --> 00:04:42,640
मैं एक, दो रिक्त स्थान डाल देता हूँ।

84
00:04:42,640 --> 00:04:45,370
और अंत से पहले पर
लाइन, बस एक अंतरिक्ष।

85
00:04:45,370 --> 00:04:48,290
और यहाँ मैं एक सही गठबंधन पिरामिड है।

86
00:04:48,290 --> 00:04:52,170
पाठ में उदाहरण करने से
संपादक, हम पैटर्न के लिए एक विचार है

87
00:04:52,170 --> 00:04:54,590
कि हम आधे पिरामिड आकर्षित करने के लिए इस्तेमाल करेंगे।

88
00:04:54,590 --> 00:04:58,080
हर पंक्ति के लिए, हम क्या किया
हम कुछ रिक्त स्थान प्रकार है,

89
00:04:58,080 --> 00:05:00,170
कुछ और फिर टाइप किया
हेश, और फिर टाइप किया

90
00:05:00,170 --> 00:05:03,020
दर्ज कुंजी है, जो
एक नई लाइन पैदा कर रही है।

91
00:05:03,020 --> 00:05:07,770
तो अब है कि है कि हम, चलो चलते हैं
एक कदम आगे और एक पैटर्न पाते हैं।

92
00:05:07,770 --> 00:05:10,170
>> तो मैं कहने जा रहा हूँ, के लिए
इस उदाहरण के हित,

93
00:05:10,170 --> 00:05:12,480
हम 8 की ऊंचाई के साथ काम कर रहे हैं।

94
00:05:12,480 --> 00:05:17,100
पहली पंक्ति में दो किया जा रहा है
हैश कि सात रिक्त स्थान इस प्रकार है।

95
00:05:17,100 --> 00:05:20,020
second-- तीन हैश, छह रिक्त स्थान।

96
00:05:20,020 --> 00:05:24,260
तीसरा row-- चार हैश, पाँच
spaces-- इतने पर और आगे

97
00:05:24,260 --> 00:05:26,350
जब तक हम NTH पंक्ति को मिलता है।

98
00:05:26,350 --> 00:05:31,540
तो फिर, मैं NTH पंक्ति के लिए आप से पूछना,
कितने हैश हम करने जा रहे हैं

99
00:05:31,540 --> 00:05:33,120
और कितने रिक्त स्थान?

100
00:05:33,120 --> 00:05:37,000
तो यह एक बाहर निकालने के लिए आप पर निर्भर है
सूत्र कितने हैश प्रतिनिधित्व करने के लिए

101
00:05:37,000 --> 00:05:42,020
और कितने रिक्त स्थान के लिए आवश्यक हैं
NTH पंक्ति आप कुछ ऊंचाई किया है।

102
00:05:42,020 --> 00:05:46,060
>> अब आप यह पता लगाना कर रहे हैं,
सावधान आप कैसे अनुक्रमण रहे हो।

103
00:05:46,060 --> 00:05:49,170
मैं इस से क्या मतलब है वह यह है कि
रोजमर्रा की जिंदगी हम सभी में

104
00:05:49,170 --> 00:05:51,540
1 से गिनती, आम तौर पर शुरू करते हैं।

105
00:05:51,540 --> 00:05:55,950
CS50 में और कंप्यूटर विज्ञान के क्षेत्र में लेकिन
सामान्य रूप में, हम 0 अनुक्रमित रहे हैं।

106
00:05:55,950 --> 00:06:00,620
तो पहली पंक्ति होगा
0 एन 1 के रूप में करने का विरोध किया।

107
00:06:00,620 --> 00:06:04,550
इस से सावधान रहो, जब आप कर रहे हैं
अपने पैटर्न पता लगाने की कोशिश कर रहा है।

108
00:06:04,550 --> 00:06:07,570
तो अब कैसे के लिए वापस जाओ
हम अपने पिरामिड आकर्षित करने के लिए जा रहे हैं।

109
00:06:07,570 --> 00:06:12,300
हर पंक्ति के लिए, हम चाहते करने के लिए जा रहे हैं
, रिक्त स्थान मुद्रित हैश प्रिंट,

110
00:06:12,300 --> 00:06:14,050
और फिर एक नई लाइन प्रिंट।

111
00:06:14,050 --> 00:06:19,160
संकेत यहाँ है
हर पंक्ति "के लिए" शब्द।

112
00:06:19,160 --> 00:06:21,470
सी में, हम एक निर्माण किया है
पाश के लिए एक कहा जाता है,

113
00:06:21,470 --> 00:06:25,250
एक के शामिल है जो
आरंभीकरण, एक शर्त है, एक अद्यतन,

114
00:06:25,250 --> 00:06:26,790
और लूप के शरीर।

115
00:06:26,790 --> 00:06:31,360
>> मैं हैलो कहने के लिए करना चाहता था, का कहना है
दुनिया, 50 बार, मेरे पाश के लिए

116
00:06:31,360 --> 00:06:32,880
कुछ इस तरह लग रही होगी।

117
00:06:32,880 --> 00:06:35,480
मैं 0 करने के लिए मेरे पूर्णांक प्रारंभ।

118
00:06:35,480 --> 00:06:38,230
शर्त यह है कि मैं कम से कम 50 है।

119
00:06:38,230 --> 00:06:42,350
और फिर मेरी अद्यतन बस है
हर बार मैं incrementing।

120
00:06:42,350 --> 00:06:45,140
हम यह भी छोरों के लिए उपयोग कर सकते हैं
बातों पर पुनरावृति करने के लिए।

121
00:06:45,140 --> 00:06:47,820
यहां सूचना कैसे हम नहीं
मुश्किल से एक नंबर कोडित,

122
00:06:47,820 --> 00:06:51,820
बल्कि चर रखा
बजाय हालत में ऊंचाई।

123
00:06:51,820 --> 00:06:56,420
तो क्या मैं यहाँ क्या कर रहा हूँ मैं कर रहा हूँ पुनरावृति है
पिरामिड के हर पंक्ति पर।

124
00:06:56,420 --> 00:07:00,160
मैं प्रत्येक के लिए कुछ कर सकते हैं
अपने पाश के शरीर के अंदर पंक्ति।

125
00:07:00,160 --> 00:07:02,350
>> हम अंदर क्या कर रहे हो
लूप के शरीर?

126
00:07:02,350 --> 00:07:07,120
खैर, जैसा कि हम पहले से ही कहा, हम मुद्रण कर रहे हैं
रिक्त स्थान है और हम हैश मुद्रण कर रहे हैं

127
00:07:07,120 --> 00:07:09,480
और हम एक नई लाइन मुद्रण कर रहे हैं।

128
00:07:09,480 --> 00:07:11,950
तो पाश के लिए मेरे बाहरी
इस तरह दिखेगा।

129
00:07:11,950 --> 00:07:15,070
मैं हर पंक्ति पर पुनरावृति
पिरामिड के उपयोग करते हुए,

130
00:07:15,070 --> 00:07:18,890
इस मामले में, चर के रूप में ऊंचाई
कि पिरामिड की ऊंचाई भंडार।

131
00:07:18,890 --> 00:07:22,870
कि पाश के शरीर के अंदर, मैं हूँ
बार बार रिक्त स्थान मुद्रित करने के लिए जा रहा है, प्रिंट

132
00:07:22,870 --> 00:07:26,730
बार बार हैश,
और फिर एक नई लाइन प्रिंट।

133
00:07:26,730 --> 00:07:31,010
>> तो अब, अवधारणाओं के सभी का उपयोग कर कि
मैं इस चलने के माध्यम से के बारे में बात की है

134
00:07:31,010 --> 00:07:35,210
आप संकेत करने के लिए सक्षम होना चाहिए
उपयोगकर्ता इनपुट के लिए, कि इनपुट को मान्य,

135
00:07:35,210 --> 00:07:37,370
और फिर आधे पिरामिड आकर्षित।

136
00:07:37,370 --> 00:07:41,510
>> मेरा नाम Zamyla है, और इस CS50 है।

137
00:07:41,510 --> 00:07:43,167