रिकर्सिव फंक्शन

रिकर्शन

रिकर्शन फंक्शन ऐसे फंक्शन होते हैं जो खुद को कॉल करते हैं।

एक रिकर्शन फंक्शन में कम से कम एक बेस केस और कम से कम एक रिकर्शन केस होना ज़रूरी है।

बेस केस फंक्शन को दोबारा कॉल किए बिना एक वैल्यू लौटाता है। रिकर्शन केस फंक्शन को दोबारा कॉल करता है और इनपुट में ऐसा बदलाव करता है कि एक समय वह इनपुट बेस केस से मेल खाने लगे।

यहाँ एक उदाहरण है जो एक ऐरे के एलिमेंट गिनता है।

def count:
  if length == 0 then
    0                       # base case
  else
    1 + (.[1:] | count)     # recursive case
  end;

([] | count),           # => 0
([11, 22, 33] | count)  # => 3

एक रिकर्शन फंक्शन में कई बेस केस और/या कई रिकर्शन केस हो सकते हैं। उदाहरण के लिए, फिबोनाची अनुक्रम एक ऐसा रिकर्शन अनुक्रम है जिसमें दो बेस केस होते हैं।

def fibonacci:
  if . == 0 then
    0
  elif . == 1 then
    1
  else
    (. - 1 | fibonacci) + (. - 2 | fibonacci)
  end;

10 | fibonacci          # => 55

किसी दी गई वैल्यू x को किसी ऐरे में कितनी बार आती है, इसे गिनने के दो रिकर्शन केस होते हैं।

def count_occurrences(x):
  if length == 0 then
    0
  elif first == x then
    1 + (.[1:] | count_occurrences(x))
  else
    (.[1:] | count_occurrences(x))
  end;

[11, 22, 33, 22, 44] | count_occurrences(22)    # => 2

व्यवहार में, ऐरे और दूसरे ऐसे डेटा स्ट्रक्चर पर इटरेशन करने के लिए अक्सर बिल्ट-इन फंक्शन इस्तेमाल होते हैं, जैसे map और reduce, या फिर [.[] | select(...)] जैसी स्ट्रीम इस्तेमाल करके। भीतर से देखें तो कुछ बिल्ट-इन फंक्शन रिकर्शन से बनाए गए हैं।