பாடம் 5 / 5 · Functions · படிக்க 2 min · புதுப்பிக்கப்பட்டது

Recursion

தன்னையே கூப்பிடுற function — அது எப்படி நிக்குது, எப்போ அது இயல்பான தீர்வு.

Recursive function ஒரு பிரச்சனையை, அதே பிரச்சனையோட சின்ன பகுதி மேல தன்னையே கூப்பிட்டு தீர்க்கும். அதுக்கு ஒரு base case வேணும் — திரும்ப தன்னை கூப்பிடாம நேரடியா பதில் சொல்ற இடம்.

python
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))
Output
120

Example

factorial(5) = 5 × factorial(4), அது 4 × factorial(3), இப்படியே factorial(1) வரைக்கும் — அது base case, 1-ஐ return பண்ணும். அப்புறம் பதில்கள் மேல பெருகி வரும்: 1 × 2 × 3 × 4 × 5 = 120.

Recursion எங்க பளிச்சிடுது

python
def total(items):
    result = 0
    for item in items:
        if isinstance(item, list):
            result += total(item)
        else:
            result += item
    return result

print(total([1, [2, 3], [4, [5, 6]]]))
Output
21

Factorial-ஐ loop வெச்சும் எளிதா எழுதலாம். தன்னோட சின்ன வடிவங்களை உள்ள வெச்சிருக்கிற data-க்கு தான் recursion சரியான இடம் — list-க்குள்ள list, folder-க்குள்ள folder — எவ்வளவு ஆழம் போகும்னு முன்னாடியே தெரியாதப்போ.

Warning

Base case-ஐ மறந்தா, இல்லன்னா அதை எப்பவுமே எட்டலன்னா, Python RecursionError: maximum recursion depth exceeded-ன்னு நிறுத்துற வரைக்கும் function தன்னையே கூப்பிட்டுட்டே இருக்கும் — default-ஆ சுமார் 1000 calls ஆழம்.

ஒவ்வொரு recursive function-லயும் என்ன கண்டிப்பா இருக்கணும்?

இப்போ இதை செஞ்சு பாருங்க

  1. n-ல இருந்து 1 வரைக்கும் print பண்ணி, அப்புறம் "Go!"-ன்னு சொல்ற recursive countdown(n) எழுதுங்க.
  2. String-ஐ தலைகீழா மாத்துற recursive function எழுதுங்க: கடைசி எழுத்து + மீதியோட reverse.
  3. Fibonacci எண்களுக்கு recursive-ஆ fib(n) எழுதி, fib(35) எவ்வளவு மெதுவா இருக்குன்னு பாருங்க — ஏன்னு யோசிங்க.

Create a free account to save your progress, or sign in.