પુનરાવર્તન વિરુદ્ધ પુનરાવૃત્તિ — વ્યાપાર-બંધ કયા છે?

Question

Accepted Answer

**પુનરાવર્તન** લૂપનો ઉપયોગ કરે છે; **પુનરાવૃત્તિ** સ્વ-કૉલનો ઉપયોગ કરે છે. તેઓ સમાન શક્તિશાળી છે (તમે એક સાથે કર્યું તે બીજા સાથે કરી શકો છો), પરંતુ તેઓ સ્પષ્ટતા અને ખર્ચમાં અલગ છે.

## બાજુ તરફ બાજુ

```python
# Iterative sum: constant extra space
def sum_iter(n):
    total = 0
    for i in range(1, n + 1):
        total += i        # accumulate in a loop
    return total

# Recursive sum: uses the call stack
def sum_rec(n):
    if n == 0:
        return 0
    return n + sum_rec(n - 1)
```

## સરખામણી

| પાસું | પુનરાવર્તન | પુનરાવૃત્તિ |
|--------|-----------|----------|
| મેમોરી | O(1) વધારાનું | O(ગહનતા) સ્ટેક |
| વાચનીયતા | રેખીય કાર્ય માટે બહુત સારું | વૃક્ષ / વિભાજિત-અને-જીત માટે બહુત સારું |
| જોખમ | અનંત લૂપ | સ્ટેક ओभरફ્લો |
| ગતિ | સામાન્ય રીતે વધુ ઝડપી (કોઈ કૉલ ઓવરહેડ નથી) | પ્રતિ ફ્રેમ કૉલ ઓવરહેડ |

## કયું કયારે વાપરવું

- સરળ રેખીય ટ્રાવર્સલ્સ અને જ્યારે સ્ટેક ગહનતા મોટી હોઈ શકે ત્યારે **પુનરાવર્તન** વાપરો.
- જ્યારે સમસ્યા કુદરતી રીતે પુનરાવૃત્ત હોય (વૃક્ષ, આલેખ, બેકટ્રેકિંગ) અને ગહનતા બંધાયેલ હોય ત્યારે **પુનરાવૃત્તિ** વાપરો.

## નુકસાન

ગહન પુનરાવૃત્તિ સ્ટેક ઓવરફ્લોનું જોખમ ધરાવે છે; જ્યારે ગહનતા અનંત હોય ત્યારે ગરમ પુનરાવૃત્તિ કોડને પુનરાવર્તનમાં રૂપાંતરિત કરો (ઘણીવાર સ્પષ્ટ સ્ટેક સાથે).

## તે શા માટે મહત્વપૂર્ણ છે

યોગ્ય શૈલી પસંદ કરવી કોડને સાચું અને વાચનીય બંને રાખે છે.

પુનરાવૃત્તિ વૃક્ષ અને આલેખ કોડને સુંદર બનાવે છે, પરંતુ તેના મેમોરી ખર્ચ જાણવાથી તમે ગહન ઇનપુટ્સ પર ક્રેશ ટાળી શકો છો.

જ્યારે તેઓ તમને "આને પુનરાવર્તિત બનાવો" કહે ત્યારે આ વ્યાપાર-બંધ નિર્ણય તે જ છે જે ઇન્ટરવ્યુઅરો તપાસે છે.

પાસું	પુનરાવર્તન	પુનરાવૃત્તિ
મેમોરી	O(1) વધારાનું	O(ગહનતા) સ્ટેક
વાચનીયતા	રેખીય કાર્ય માટે બહુત સારું	વૃક્ષ / વિભાજિત-અને-જીત માટે બહુત સારું
જોખમ	અનંત લૂપ	સ્ટેક ओभरફ્લો
ગતિ	સામાન્ય રીતે વધુ ઝડપી (કોઈ કૉલ ઓવરહેડ નથી)	પ્રતિ ફ્રેમ કૉલ ઓવરહેડ