ZAMYLA चान: यह मेरे, Zamyla है।
मारियो में आज, हम होने जा रहे हैं मारियो के लिए आधा पिरामिड ड्राइंग
चढ़ा जाने वाला।
>> तो चलो बारे में बात करते हमारे इस समस्या के लिए करने के लिए करते है।
हम चाहते करने जा रहे हैं संकेत और मान्य करने के लिए
कैसे का एक मान्य इनपुट के लिए उपयोगकर्ता उच्च वे मारियो के पिरामिड होना चाहते हैं।
और फिर, हम इसे आकर्षित करने के लिए जा रहे हैं।
तो चलो उत्साह के साथ शुरू हो जाओ और अपने इनपुट के लिए उपयोगकर्ता को मान्य।
>> हम का उपयोग कर सकते CS50 पुस्तकालय समारोह
int है कि यह सुनिश्चित करेंगे कि मिल उपयोगकर्ता एक पूर्णांक आदानों।
किसी भी सकारात्मक पूर्णांक, नकारात्मक पूर्णांकों, संख्या 0 सभी उचित खेल रहे हैं।
अन्यथा, उपयोगकर्ता के लिए प्रेरित किया जाएगा वे इनपुट एक मान्य पूर्णांक तक पुन: प्रयास करें।
अब हालांकि मिल int करता है हमारे लिए बहुत काम की
सुनिश्चित करने में है कि उपयोगकर्ता हमें एक पूर्णांक देता है,
हम अभी भी कुछ लागू करने की आवश्यकता उस पर अतिरिक्त बाधाओं।
आखिर, हम मारियो चढ़ाई नहीं हो सकता ऊंचाई नकारात्मक 12 की एक आधा पिरामिड।
>> इसके अलावा, समस्या विनिर्देश
कहते हैं कि हम केवल यह कर सकते हैं मारियो चढ़ाई करने की अनुमति
0 और 23 के बीच ऊंचाइयों की एक पिरामिड।
ठीक है, तो इसका मतलब है कि हम की जरूरत है लगातार उपयोगकर्ता संकेत करने के लिए
हमें एक वैध देने के लिए संख्या और केवल जारी रखने के लिए
एक बार वे हमें एक वैध ऊंचाई दी है।
हम इसे कैसे करते हैं?
>> खैर, निरंतर प्रक्रियाओं हमें दे loops-- कुछ करने का विचार
repetitively।
थोड़ी देर के रूप में सी में एक पाश पाश है कि लगातार होगा
के रूप में लंबे समय के रूप पाश के शरीर पर अमल दी शर्त सही करने के लिए मूल्यांकन करता है।
जैसे ही यह है कि शर्त के रूप में गलत का आकलन,
कार्यक्रम के लिए आगे बढ़ना होगा जो कुछ भी है कि उसके बाद आता है।
तो, जबकि छोरों का एक तरीका है कि हम लगातार यह सुनिश्चित करना
एक वैध निवेश के लिए उपयोगकर्ता का संकेत।
और एक बार वे हमें एक वैध इनपुट दे, हम जो कुछ भी अगले आता है पर आगे बढ़ेंगे।
हम जानते हैं कि हम पूछने के लिए जा रहे हैं कम से कम एक बार इनपुट के लिए उपयोगकर्ता।
तो अब हम की एक बहन के लिए आए जबकि पाश, जो करते हैं, जबकि पाश है।
>> जबकि छोरों पर अमल करेंगे करो लूप के शरीर पर कम से कम एक बार।
तो हालत की जाँच के बिना, यह लूप के शरीर पर अमल करेंगे।
और फिर स्थिति की जाँच देखने के लिए चाहे वह खुद को दोहराने की जरूरत है।
इस काम में आता है जब हम उपयोगकर्ता इनपुट मान्य कर रहे हैं।
हम जानते हैं कि हम जा रहे हैं उन्हें कम से कम एक बार पूछने के लिए।
तो एक करते हैं, जबकि पाश हो सकता है कुछ इस तरह दिखेगा।
हम एक पूर्णांक है।
और करते हैं के अंदर जबकि पाश, हम तुरंत
एक पूर्णांक के लिए उपयोगकर्ता का संकेत।
यदि n अमान्य है, तो हम उन्हें संकेत देंगे फिर और फिर और फिर वे जब तक
हमें जो मान्य पूर्णांक दे।
अंत में, एक बार n एक मान्य इनपुट है, हम करेंगे हमारे कार्यक्रम के आराम करने के लिए आगे बढ़ें।
>> तो चलो कल्पना और जांच के लिए वापस जाओ क्या एक वैध निवेश के लिए की स्थिति
होने जा रहा है।
वैध ऊंचाइयों तक जा रहे हैं 0 और 23 के बीच हो।
इसलिए अवैध ऊंचाइयों तक जा रहे हैं कम से कम 0 या 23 से अधिक हो।
तो डिजाइन करने के लिए याद अपनी हालत को ध्यान से,
जानते हुए भी इस शर्त पर कि करते हैं, जबकि पाश के लिए
होना चाहिए, जबकि n अमान्य है।
अब यह एक होने के लिए नहीं जा रहा है सरल एकल बूलियन अभिव्यक्ति।
हम गठबंधन करने के लिए जा रहे हैं दो अलग अलग भाव
हमारे पूरे हालत बनाने के लिए।
>> तो चलो बस एक सच तालिका रहा है पर देखो पहले से ही आप संकेत हम कर रहे हैं कि दिया
दो Booleans के साथ काम किया जा रहा है।
तो यहाँ एक सच तालिका जहां मैं दो Booleans-- बूलियन 1 और 2 लोगों की है।
इसलिए हम मूल्यांकन करने के लिए यह विकल्प होता है bool1 और bool2 या bool1 या bool2।
और केवल दोनों अगर सच हो जाएगा Booleans, सच का मूल्यांकन जबकि सभी
या लंबे समय के रूप में सच हो जाएगा में से एक के रूप में दो Booleans सच करने के लिए मूल्यांकन करता है।
ठीक है, तो एक क्षण ले, इस ठहराव वीडियो और इस सच्चाई को पचाने की मेज।
मैं यहीं इंतज़ार कर रहा हूँ।
जब आप वापस आ जाओ, देखना आप एक साथ टुकड़ा कर सकते हैं, तो
के लिए एक बूलियन अभिव्यक्ति अपने n की हालत गलत इनपुट जा रहा है।
>> तो अब है कि हम वैध उपयोगकर्ता इनपुट, चलो
आगे जाना है और कैसे हम इस बारे में बात आधे पिरामिड आकर्षित हो सकता है।
यहाँ इस सरल पाठ संपादक में, मैं एक बाएं गठबंधन पिरामिड तैयार कर लिया है।
लेकिन हम जानते हैं कि हम अपनी जरूरत पिरामिड सही गठबंधन किया है।
तो मैं ऐसा कैसे कर सकता है?
खैर, मैं पुश करने की कोशिश हो सकती है ओर करने के लिए सब कुछ
सिर्फ एक छोटे से डाल द्वारा बीच में चरित्र।
और फिर, अगले के लिए लाइन, मैं डाला जा रहा हूँ
कुछ और पात्रों यह पुश करने के साथ-साथ, और further-- इतने पर और forth--
जब तक मैं सही गठबंधन पिरामिड है।
तो हम एक सही संरेखित पिरामिड है, लेकिन यह डॉट्स के साथ इतना महान नहीं लगती है।
लेकिन हम अभी भी चाहते अच्छा है कि रिक्ति बनाए रखें।
इसलिए मैं सचमुच जा रहा हूँ कुछ रिक्त स्थान डालें।
>> इसके बजाय तीन डॉट्स की, मैं हूँ एक, दो, तीन स्थान डाल दिया।
दूसरी लाइन पर।
मैं एक, दो रिक्त स्थान डाल देता हूँ।
और अंत से पहले पर लाइन, बस एक अंतरिक्ष।
और यहाँ मैं एक सही गठबंधन पिरामिड है।
पाठ में उदाहरण करने से संपादक, हम पैटर्न के लिए एक विचार है
कि हम आधे पिरामिड आकर्षित करने के लिए इस्तेमाल करेंगे।
हर पंक्ति के लिए, हम क्या किया हम कुछ रिक्त स्थान प्रकार है,
कुछ और फिर टाइप किया हेश, और फिर टाइप किया
दर्ज कुंजी है, जो एक नई लाइन पैदा कर रही है।
तो अब है कि है कि हम, चलो चलते हैं एक कदम आगे और एक पैटर्न पाते हैं।
>> तो मैं कहने जा रहा हूँ, के लिए इस उदाहरण के हित,
हम 8 की ऊंचाई के साथ काम कर रहे हैं।
पहली पंक्ति में दो किया जा रहा है हैश कि सात रिक्त स्थान इस प्रकार है।
second-- तीन हैश, छह रिक्त स्थान।
तीसरा row-- चार हैश, पाँच spaces-- इतने पर और आगे
जब तक हम NTH पंक्ति को मिलता है।
तो फिर, मैं NTH पंक्ति के लिए आप से पूछना, कितने हैश हम करने जा रहे हैं
और कितने रिक्त स्थान?
तो यह एक बाहर निकालने के लिए आप पर निर्भर है सूत्र कितने हैश प्रतिनिधित्व करने के लिए
और कितने रिक्त स्थान के लिए आवश्यक हैं NTH पंक्ति आप कुछ ऊंचाई किया है।
>> अब आप यह पता लगाना कर रहे हैं, सावधान आप कैसे अनुक्रमण रहे हो।
मैं इस से क्या मतलब है वह यह है कि रोजमर्रा की जिंदगी हम सभी में
1 से गिनती, आम तौर पर शुरू करते हैं।
CS50 में और कंप्यूटर विज्ञान के क्षेत्र में लेकिन सामान्य रूप में, हम 0 अनुक्रमित रहे हैं।
तो पहली पंक्ति होगा 0 एन 1 के रूप में करने का विरोध किया।
इस से सावधान रहो, जब आप कर रहे हैं अपने पैटर्न पता लगाने की कोशिश कर रहा है।
तो अब कैसे के लिए वापस जाओ हम अपने पिरामिड आकर्षित करने के लिए जा रहे हैं।
हर पंक्ति के लिए, हम चाहते करने के लिए जा रहे हैं , रिक्त स्थान मुद्रित हैश प्रिंट,
और फिर एक नई लाइन प्रिंट।
संकेत यहाँ है हर पंक्ति "के लिए" शब्द।
सी में, हम एक निर्माण किया है पाश के लिए एक कहा जाता है,
एक के शामिल है जो आरंभीकरण, एक शर्त है, एक अद्यतन,
और लूप के शरीर।
>> मैं हैलो कहने के लिए करना चाहता था, का कहना है दुनिया, 50 बार, मेरे पाश के लिए
कुछ इस तरह लग रही होगी।
मैं 0 करने के लिए मेरे पूर्णांक प्रारंभ।
शर्त यह है कि मैं कम से कम 50 है।
और फिर मेरी अद्यतन बस है हर बार मैं incrementing।
हम यह भी छोरों के लिए उपयोग कर सकते हैं बातों पर पुनरावृति करने के लिए।
यहां सूचना कैसे हम नहीं मुश्किल से एक नंबर कोडित,
बल्कि चर रखा बजाय हालत में ऊंचाई।
तो क्या मैं यहाँ क्या कर रहा हूँ मैं कर रहा हूँ पुनरावृति है पिरामिड के हर पंक्ति पर।
मैं प्रत्येक के लिए कुछ कर सकते हैं अपने पाश के शरीर के अंदर पंक्ति।
>> हम अंदर क्या कर रहे हो लूप के शरीर?
खैर, जैसा कि हम पहले से ही कहा, हम मुद्रण कर रहे हैं रिक्त स्थान है और हम हैश मुद्रण कर रहे हैं
और हम एक नई लाइन मुद्रण कर रहे हैं।
तो पाश के लिए मेरे बाहरी इस तरह दिखेगा।
मैं हर पंक्ति पर पुनरावृति पिरामिड के उपयोग करते हुए,
इस मामले में, चर के रूप में ऊंचाई कि पिरामिड की ऊंचाई भंडार।
कि पाश के शरीर के अंदर, मैं हूँ बार बार रिक्त स्थान मुद्रित करने के लिए जा रहा है, प्रिंट
बार बार हैश, और फिर एक नई लाइन प्रिंट।
>> तो अब, अवधारणाओं के सभी का उपयोग कर कि मैं इस चलने के माध्यम से के बारे में बात की है
आप संकेत करने के लिए सक्षम होना चाहिए उपयोगकर्ता इनपुट के लिए, कि इनपुट को मान्य,
और फिर आधे पिरामिड आकर्षित।
>> मेरा नाम Zamyla है, और इस CS50 है।