ರಿಕರ್ಷನ್ (Recursion)

ರಿಕರ್ಷನ್ (Recursion) ಎಂದರೆ ಒಂದು ಫಂಕ್ಷನ್ ತನ್ನನ್ನೇ ತಾನು ಕಾಲ್ ಮಾಡಿಕೊಳ್ಳುವ ಪ್ರಕ್ರಿಯೆ. ಈ ತಂತ್ರವನ್ನು ಬಳಸಿಕೊಂಡು, ಸಂಕೀರ್ಣ ಸಮಸ್ಯೆಗಳನ್ನು ಸಣ್ಣ, ಪುನರಾವರ್ತಿತ ಉಪ-ಸಮಸ್ಯೆಗಳಾಗಿ ವಿಭಜಿಸಿ ಪರಿಹರಿಸಬಹುದು.

ರಿಕರ್ಷನ್ ಸರಿಯಾಗಿ ಕೆಲಸ ಮಾಡಲು, ಎರಡು ಪ್ರಮುಖ ಅಂಶಗಳು ಬೇಕು:

1. ಬೇಸ್ ಕೇಸ್ (Base Case): ಇದು ರಿಕರ್ಷನ್ ಅನ್ನು ನಿಲ್ಲಿಸುವ ಷರತ್ತು. ಬೇಸ್ ಕೇಸ್ ಇಲ್ಲದಿದ್ದರೆ, ಫಂಕ್ಷನ್ ಅನಂತವಾಗಿ ತನ್ನನ್ನೇ ತಾನು ಕಾಲ್ ಮಾಡುತ್ತಾ RecursionError ಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
2. ರಿಕರ್ಸಿವ್ ಕೇಸ್ (Recursive Case): ಇಲ್ಲಿ ಫಂಕ್ಷನ್ ತನ್ನನ್ನೇ ತಾನು, ಆದರೆ ವಿಭಿನ್ನ (ಸಾಮಾನ್ಯವಾಗಿ ಸಣ್ಣ) ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳೊಂದಿಗೆ ಕಾಲ್ ಮಾಡುತ್ತದೆ, ಸಮಸ್ಯೆಯನ್ನು ಬೇಸ್ ಕೇಸ್‌ನತ್ತ ಸಾಗಿಸುತ್ತದೆ.

---

ಉದಾಹರಣೆ 1: ಫ್ಯಾಕ್ಟೋರಿಯಲ್ (Factorial)

ಒಂದು ಸಂಖ್ಯೆಯ ಫ್ಯಾಕ್ಟೋರಿಯಲ್ ಎಂದರೆ ಆ ಸಂಖ್ಯೆಯಿಂದ 1ರವರೆಗಿನ ಎಲ್ಲಾ ಪೂರ್ಣಾಂಕಗಳ ಗುಣಲಬ್ಧ. n! = n * (n-1) * (n-2) * ... * 1

ರಿಕರ್ಸಿವ್ ಪರಿಹಾರ:

• ಬೇಸ್ ಕೇಸ್: factorial(0) ಅಥವಾ factorial(1) ಯಾವಾಗಲೂ 1 ಆಗಿರುತ್ತದೆ.
• ರಿಕರ್ಸಿವ್ ಕೇಸ್: factorial(n) = n * factorial(n-1)

def factorial(n):
    """ರಿಕರ್ಷನ್ ಬಳಸಿ ಒಂದು ಸಂಖ್ಯೆಯ ಫ್ಯಾಕ್ಟೋರಿಯಲ್ ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ."""
    # ಬೇಸ್ ಕೇಸ್: n=0 ಅಥವಾ n=1 ಆದಾಗ, 1 ಅನ್ನು ಹಿಂತಿರುಗಿಸು
    if n == 0 or n == 1:
        return 1
    # ರಿಕರ್ಸಿವ್ ಕೇಸ್: n * factorial(n-1) ಅನ್ನು ಕಾಲ್ ಮಾಡು
    else:
        return n * factorial(n - 1)

num = 5
result = factorial(num)
print(f"{num}ರ ಫ್ಯಾಕ್ಟೋರಿಯಲ್: {result}") # Output: 120

ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ? factorial(4)

1. factorial(4) -> 4 * factorial(3)
2. factorial(3) -> 3 * factorial(2)
3. factorial(2) -> 2 * factorial(1)
4. factorial(1) -> 1 (ಬೇಸ್ ಕೇಸ್ ತಲುಪಿದೆ)
5. ಫಲಿತಾಂಶಗಳು ಹಿಂತಿರುಗುತ್ತವೆ: 2 * 1 = 2 -> 3 * 2 = 6 -> 4 * 6 = 24

---

ಉದಾಹರಣೆ 2: ಫಿಬೊನಾಕಿ ಸರಣಿ (Fibonacci Series)

ಫಿಬೊನಾಕಿ ಸರಣಿಯಲ್ಲಿ, ಪ್ರತಿ ಸಂಖ್ಯೆಯು ಹಿಂದಿನ ಎರಡು ಸಂಖ್ಯೆಗಳ ಮೊತ್ತವಾಗಿರುತ್ತದೆ: 0, 1, 1, 2, 3, 5, 8, ...

ರಿಕರ್ಸಿವ್ ಪರಿಹಾರ:

• ಬೇಸ್ ಕೇಸ್: fib(0) = 0, fib(1) = 1
• ರಿಕರ್ಸಿವ್ ಕೇಸ್: fib(n) = fib(n-1) + fib(n-2)

def fibonacci(n):
    """n-ನೇ ಫಿಬೊನಾಕಿ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ."""
    if n <= 1:
        return n
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

index = 7
print(f"{index}-ನೇ ಫಿಬೊನಾಕಿ ಸಂಖ್ಯೆ: {fibonacci(index)}") # Output: 13

ಗಮನಿಸಿ: ಫಿಬೊನಾಕಿಗಾಗಿ ಈ ರಿಕರ್ಸಿವ್ ಪರಿಹಾರವು ಸುಂದರವಾಗಿದ್ದರೂ, ಅತ್ಯಂತ ಅಸಮರ್ಥವಾಗಿದೆ (inefficient), ಏಕೆಂದರೆ ಇದು ಒಂದೇ ಲೆಕ್ಕಾಚಾರವನ್ನು ಅನೇಕ ಬಾರಿ ಮಾಡುತ್ತದೆ.

---

ರಿಕರ್ಷನ್ vs. ಇಟರೇಷನ್ (ಲೂಪ್‌ಗಳು)

ಗುಣಲಕ್ಷಣ	ರಿಕರ್ಷನ್ (Recursion)	ಇಟರೇಷನ್ (Iteration - for/while loops)
ತರ್ಕ	ಫಂಕ್ಷನ್ ತನ್ನನ್ನೇ ತಾನು ಕಾಲ್ ಮಾಡುತ್ತದೆ.	ಲೂಪ್ ಬಳಸಿ ಕೋಡ್ ಅನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತದೆ.
ಕೋಡ್	ಸಾಮಾನ್ಯವಾಗಿ ಚಿಕ್ಕದು ಮತ್ತು ಹೆಚ್ಚು ಓದಬಲ್ಲದು (ಕೆಲವು ಸಮಸ್ಯೆಗಳಿಗೆ).	ಉದ್ದವಾಗಿರಬಹುದು, ಆದರೆ ಕೆಲವೊಮ್ಮೆ ಹೆಚ್ಚು ಸ್ಪಷ್ಟ.
ಕಾರ್ಯಕ್ಷಮತೆ	ಫಂಕ್ಷನ್ ಕಾಲ್‌ಗಳಿಂದಾಗಿ ನಿಧಾನ ಮತ್ತು ಹೆಚ್ಚು ಮೆಮೊರಿ ಬಳಸುತ್ತದೆ.	ವೇಗ ಮತ್ತು ಕಡಿಮೆ ಮೆಮೊರಿ ಬಳಸುತ್ತದೆ.
ಮಿತಿ	ಪೈಥಾನ್‌ನಲ್ಲಿ ರಿಕರ್ಷನ್ ಆಳಕ್ಕೆ ಮಿತಿ ಇದೆ (ಸಾಮಾನ್ಯವಾಗಿ 1000).	ಅಂತಹ ಯಾವುದೇ ಅಂತರ್ಗತ ಮಿತಿ ಇಲ್ಲ.

ಯಾವಾಗ ರಿಕರ್ಷನ್ ಬಳಸಬೇಕು?

• ಸಮಸ್ಯೆಯು ಸ್ವಾಭಾವಿಕವಾಗಿ ರಿಕರ್ಸಿವ್ ಆಗಿದ್ದಾಗ (ಉದಾ: ಟ್ರೀ ಅಥವಾ ಗ್ರಾಫ್ ಟ್ರಾವರ್ಸಲ್, ಫೈಲ್ ಸಿಸ್ಟಮ್ ಸ್ಕ್ಯಾನಿಂಗ್).
• ಕೋಡ್‌ನ ಸ್ಪಷ್ಟತೆ ಮತ್ತು ಸರಳತೆ ಮುಖ್ಯವಾದಾಗ.

ಅತಿಯಾದ ರಿಕರ್ಷನ್ RecursionError: maximum recursion depth exceeded ಎಂಬ ಎರರ್‌ಗೆ ಕಾರಣವಾಗಬಹುದು. ಆದ್ದರಿಂದ, ಯಾವಾಗಲೂ ಒಂದು ದೃಢವಾದ ಬೇಸ್ ಕೇಸ್ ಅನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.