पास्कल का त्रिभुज

निर्देश

आपको पास्कल के त्रिभुज की पहली N पंक्तियाँ देनी हैं।

पास्कल का त्रिभुज धनात्मक पूर्णांकों का एक त्रिभुजाकार ऐरे है।

पास्कल के त्रिभुज में किसी पंक्ति में वैल्यू की संख्या उस पंक्ति के क्रमांक के बराबर होती है (जो एक से शुरू होता है)। इसलिए पहली पंक्ति में एक वैल्यू होती है, दूसरी पंक्ति में दो वैल्यू होती हैं, और इसी तरह आगे।

पहली (सबसे ऊपर की) पंक्ति में एक ही वैल्यू होती है: 1। आगे की पंक्तियों की वैल्यू पिछली पंक्ति में वर्तमान स्थान के ठीक दाएँ और ठीक बाएँ की संख्याओं को जोड़कर निकाली जाती हैं।

यदि पिछली पंक्ति में वर्तमान स्थान के बाएँ या दाएँ कोई वैल्यू नहीं होती (ऐसा केवल सबसे बाएँ और सबसे दाएँ स्थानों पर होता है), तो उस स्थान की वैल्यू को शून्य मानिए (यानी जोड़ते समय उसे "अनदेखा" करना)।

उदाहरण

आइए पास्कल के त्रिभुज की पहली 5 पंक्तियाँ देखते हैं:

    1
   1 1
  1 2 1
 1 3 3 1
1 4 6 4 1

सबसे ऊपर की पंक्ति में एक वैल्यू होती है, जो 1 है।

सबसे बाएँ और सबसे दाएँ वैल्यू के पास विचार करने के लिए केवल एक पिछला स्थान होता है। सबसे बाएँ वैल्यू के लिए वह उसके दाएँ वाला स्थान होता है, और सबसे दाएँ वैल्यू के लिए उसके बाएँ वाला स्थान।

चूँकि सबसे ऊपर की वैल्यू 1 है, इसलिए यह निकलता है कि सभी सबसे बाएँ और सबसे दाएँ वैल्यू भी 1 होती हैं।

बाकी सभी वैल्यू के लिए दो स्थान देखने होते हैं। उदाहरण के लिए, पाँचवीं पंक्ति (1 4 6 4 1) की बीच वाली वैल्यू 6 है, क्योंकि पिछली पंक्ति में उसके बाएँ और दाएँ की वैल्यू 3 और 3 हैं:

Python में यह अभ्यास कैसे लागू किया जाता है: रिकर्शन

यह अभ्यास लूप के बजाय recursion का उपयोग करके पूरा करने के लिए बनाया गया है। रिकर्सिव फंक्शन वह फंक्शन होता है जो खुद को कॉल करता है। ऐसा फंक्शन उन समस्याओं को हल करने में काम आता है जो खुद अपने ही रूप में परिभाषित होती हैं। अनंत रिकर्शन से बचने के लिए (या यूँ कहें कि स्टैक के ओवरफ्लो होने से बचने के लिए) "बेस केस" नाम की एक चीज़ इस्तेमाल की जाती है। जब बेस केस तक पहुँच जाते हैं, तो एक ऐसी वैल्यू लौटाई जाती है जो रिकर्सिव नहीं है। इससे पिछली फंक्शन कॉल पूरी होकर अपनी वैल्यू लौटा पाती है, और यह क्रम स्टैक में नीचे की ओर चलता रहता है, जब तक कि पहली फंक्शन कॉल अंतिम उत्तर न लौटा दे। 5! (यानी 5 * 4 * 3 * 2 * 1) का उत्तर निकालने के लिए हम एक रिकर्सिव फंक्शन ऐसे लिख सकते हैं:

def factorial(number):
  if number <= 1:  # base case
    return 1

  return number * factorial(number - 1) # recursive case

print(factorial(5)) # returns 120

अंत में यह ध्यान रखने की बात है कि Python रिकर्सिव कॉल की संख्या सीमित रखता है (डिफाल्ट रूप से 1000) और टेल रिकर्शन के लिए ऑप्टिमाइज़ नहीं करता।

एक्सेप्शन संदेश

कभी-कभी एक्सेप्शन उठाना ज़रूरी हो जाता है। ऐसा करते समय आपको हमेशा एक अर्थपूर्ण एरर संदेश शामिल करना चाहिए, जो बताए कि एरर का स्रोत क्या है। इससे आपका कोड पढ़ने में आसान हो जाता है और डीबग करने में काफी मदद मिलती है। जिन स्थितियों में आपको पता हो कि एरर का स्रोत एक खास टाइप का होगा, वहाँ आप बिल्ट-इन एरर टाइप में से कोई एक उठाना चुन सकते हैं, लेकिन फिर भी एक अर्थपूर्ण संदेश ज़रूर शामिल कीजिए।

इस खास अभ्यास में, अगर rows() फंक्शन को कोई ऋणात्मक संख्या दी जाए, तो आपको raise स्टेटमेंट का उपयोग करके कई ValueErrors "फेंकने" हैं। टेस्ट तभी पास होंगे जब आप exception को raise भी करें और उसके साथ एक संदेश भी शामिल करें।

किसी संदेश के साथ ValueError उठाने के लिए, संदेश को exception टाइप के आर्गुमेंट के रूप में लिखिए:

# if the rows function is passed a negative number.
raise ValueError("number of rows is negative")

---

स्रोत

Wolfram Math World पर Pascal's Triangle