क्या कोई मुझे बता सकता है कि रिकर्सिव कोड का यह टुकड़ा कैसे काम कर रहा है? क्योंकि केवल एक if स्टेटमेंट है जो यह जांचता है कि क्या वेरिएबल x शून्य के बराबर है और यदि मान शून्य के बराबर है तो सही है। और दूसरा हिस्सा सिर्फ एक दूसरे को बुलाने पर है।

def is_even(x):
  if x == 0:
    return True
  else:
    return is_odd(x-1)

def is_odd(x):
  return not is_even(x)

print(is_odd(17))  # outputs true
print(is_even(23))  # outputs false
-4
user10214519 30 सितंबर 2019, 19:24

2 जवाब

सबसे बढ़िया उत्तर

परस्पर पुनरावर्ती फ़ंक्शन की यह जोड़ी तीन तथ्यों का उपयोग करती है:

  1. 0 सम है
  2. x, भले ही x - 1 विषम हो।
  3. x विषम है यदि x - 1 सम है।

1 विषम है क्योंकि 1 - 1 == 0 सम है।

2 सम है क्योंकि 2 - 1 == 1 विषम है।

और इसी तरह।

यह निर्धारित करने का कुशल तरीका नहीं है कि एक मनमाना मान n सम या विषम है, लेकिन यह तार्किक रूप से सही तरीका है। (मान लें कि तर्क हमेशा एक प्राकृतिक संख्या है, वैसे भी। एक नकारात्मक पूर्णांक को तर्क के रूप में पारित करने के परिणामस्वरूप अनंत रिकर्सन होता है, क्योंकि मूल मामला कभी नहीं पहुंचेगा।)

2
chepner 30 सितंबर 2019, 19:40

मैं अनुसरण करने के लिए एक सरल उत्तर देना चाहता हूं। स्टैक ट्रेस के बारे में सोचो। मैं is_even और is_odd को क्रमशः IE और IO के रूप में संक्षिप्त करूंगा।

IO(17)
NOT[IE(17)]
NOT[IO(16)]
NOT[NOT[IE(16)] = IE[16]
IO(15)
...

यह मूल रूप से जाँच कर रहा है कि क्या इनपुट मान से शुरू होने वाली बारी-बारी से अवरोही संख्याएँ सम और विषम हैं और नीचे 0 तक हैं। ध्यान दें कि यदि हम एक सच्चे कथन से शुरू करते हैं (जैसे IO(17)) तो प्रत्येक पंक्ति में एक सत्य कथन होता है - यदि हमने एक झूठे बयान के साथ शुरुआत की, हर पंक्ति एक झूठे बयान के साथ समाप्त होती है। हम यहां जो पैटर्न देखते हैं, उसके बाद हम देखते हैं कि अंतिम स्थिति इस प्रकार समाप्त हो सकती है

IE(1) -> IO(0) -> NOT[IE(0)] = NOT[True] = False # as expected!

या

IO(1) -> NOT[IE[1]] = NOT[IO[0]] = NOT[NOT[IE(0)] = NOT[NOT[True]] = True # likewise!
0
rvd 30 सितंबर 2019, 19:40