C రికార్షన్ (Recursion) & కాల్ స్టాక్ మెకానిక్స్

#include <stdio.h>

// రికర్సివ్ ఫ్యాక్టోరియల్ ఫంక్షన్
long long factorial(int n) {
    // 1. బేస్ కండిషన్ (ఆగే నియమం)
    if (n <= 1) {
        printf("  -> బేస్ కండిషన్ చేరుకుంది! factorial(%d) = 1 రిటర్న్ చేస్తున్నాం.\n", n);
        return 1;
    }

    // 2. రికర్సివ్ స్టెప్ (Winding Phase)
    printf("  [PUSH] factorial(%d) లెక్కించడానికి factorial(%d) ని పిలుస్తున్నాం...\n", n, n - 1);
    long long result = n * factorial(n - 1);

    // 3. అన్‌వైండింగ్ ఫేజ్ (Unwinding Phase)
    printf("  [POP] factorial(%d) పూర్తయింది = %lld\n", n, result);
    return result;
}

int main() {
    int num = 4;
    printf("=== 4 యొక్క ఫ్యాక్టోరియల్ గణన (Call Stack Lifecycle) ===\n");
    long long ans = factorial(num);
    printf("తుది ఫలితం: %d! = %lld\n", num, ans);
    return 0;
}

#include <stdio.h>

int fibonacci(int n) {
    if (n == 0) return 0; // బేస్ కండిషన్ 1
    if (n == 1) return 1; // బేస్ కండిషన్ 2

    return fibonacci(n - 1) + fibonacci(n - 2); // రెండు రికర్సివ్ కాల్స్!
}

int main() {
    int terms = 7;
    printf("మొదటి %d ఫిబోనాకి సంఖ్యలు:\n", terms);
    for (int i = 0; i < terms; i++) {
        printf("%d ", fibonacci(i));
    }
    printf("\n");
    return 0;
}

// ❌ ప్రమాదకరమైన కోడ్: బేస్ కండిషన్ లేదు!
void causeCrash(int count) {
    printf("కాల్ సంఖ్య: %d\n", count);
    causeCrash(count + 1); // ఎప్పటికీ ఆగదు! లక్షలాది ఫ్రేమ్స్ స్టాక్ ని నింపేస్తాయి.
}

int main() {
    // causeCrash(1); // ⚠️ ఇది రన్ చేస్తే సెగ్మెంటేషన్ ఫాల్ట్ తో ప్రోగ్రామ్ క్రాష్ అవుతుంది!
    return 0;
}

#include <stdio.h>

// Forward Prototypes
int isEven(int n);
int isOdd(int n);

int isEven(int n) {
    if (n == 0) return 1; // 0 అనేది సరి సంఖ్య
    return isOdd(n - 1);  // isOdd ని పిలుస్తుంది!
}

int isOdd(int n) {
    if (n == 0) return 0; // 0 బేసి సంఖ్య కాదు
    return isEven(n - 1); // isEven ని పిలుస్తుంది!
}

int main() {
    int num = 7;
    if (isEven(num)) {
        printf("%d అనేది సరి సంఖ్య (Even Number)\n", num);
    } else {
        printf("%d అనేది బేసి సంఖ్య (Odd Number)\n", num);
    }
    return 0;
}

// 1. నాన్-టెయిల్ రికార్షన్: గుణకారం (*) చివర మిగిలి ఉంది కాబట్టి కాల్ స్టాక్ అవసరం
long long nonTailFactorial(int n) {
    if (n <= 1) return 1;
    return n * nonTailFactorial(n - 1); // '*' ఆపరేషన్ పెండింగ్ లో ఉంది!
}

// 2. టెయిల్ రికార్షన్: చివరి స్టేట్‌మెంట్ కేవలం ఫంక్షన్ కాల్ మాత్రమే (అక్యుమ్యులేటర్ ద్వారా)
long long tailFactorialHelper(int n, long long accumulator) {
    if (n <= 1) return accumulator;
    return tailFactorialHelper(n - 1, n * accumulator); // ప్యూర్ టెయిల్ కాల్!
}

long long tailFactorial(int n) {
    return tailFactorialHelper(n, 1);
}

#include <stdio.h>

// Towers of Hanoi రికర్సివ్ సొల్యూషన్
void towerOfHanoi(int n, char fromRod, char toRod, char auxRod) {
    if (n == 1) {
        printf("-> డిస్క్ 1 ని %c నుండి %c కి మార్చు\n", fromRod, toRod);
        return;
    }

    // 1. (n-1) డిస్కులను Source నుండి Helper కి మార్చు
    towerOfHanoi(n - 1, fromRod, auxRod, toRod);

    // 2. అతిపెద్ద nవ డిస్కును Source నుండి Destination కి మార్చు
    printf("-> డిస్క్ %d ని %c నుండి %c కి మార్చు\n", n, fromRod, toRod);

    // 3. Helper లో ఉన్న (n-1) డిస్కులను Destination కి మార్చు
    towerOfHanoi(n - 1, auxRod, toRod, fromRod);
}

int main() {
    int totalDisks = 3; // 3 డిస్కులు = 2^3 - 1 = 7 మూవ్స్!
    printf("=== టవర్స్ ఆఫ్ హనోయి పరిష్కారం (%d డిస్కులు) ===\n", totalDisks);
    towerOfHanoi(totalDisks, 'A', 'C', 'B');
    return 0;
}

#include <stdio.h>

// డెప్త్ లెవల్ ఆధారంగా స్పేసెస్ ప్రింట్ చేసే హెల్పర్
void printIndent(int depth) {
    for (int i = 0; i < depth; i++) {
        printf("    ");
    }
}

// రికర్సివ్ ఫోల్డర్ సైజ్ కాలిక్యులేటర్ (సిమ్యులేషన్)
double calculateFolderSize(const char* folderName, int subFolderCount, double directFileSizeMB, int depth) {
    printIndent(depth);
    printf("📁 ఫోల్డర్ స్కాన్ చేయబడుతోంది: [%s] (డైరెక్ట్ ఫైల్స్: %.1f MB)\n", folderName, directFileSizeMB);

    // బేస్ కండిషన్: సబ్-ఫోల్డర్స్ ఏవీ లేకపోతే కేవలం డైరెక్ట్ సైజ్ రిటర్న్ చేయి
    if (subFolderCount == 0) {
        printIndent(depth);
        printf("  └── ఏ సబ్-ఫోల్డర్స్ లేవు. ముగింపు.\n");
        return directFileSizeMB;
    }

    double totalSize = directFileSizeMB;

    // ప్రతి సబ్-ఫోల్డర్ కోసం రికర్సివ్‌గా సైజ్ లెక్కించు
    for (int i = 1; i <= subFolderCount; i++) {
        char childName[32];
        sprintf(childName, "సబ్_ఫోల్డర్_%d", i);

        // రికర్సివ్ కాల్ (లోపలి లోతుకి వెళ్తోంది)
        double childSize = calculateFolderSize(childName, subFolderCount - 1, 15.0 * i, depth + 1);
        totalSize += childSize;
    }

    printIndent(depth);
    printf("✔️ [%s] మొత్తం సబ్-ట్రీ సైజు: %.1f MB\n", folderName, totalSize);
    return totalSize;
}

int main() {
    printf("====================================================\n");
    printf("    మనా ఫైల్ సిస్టమ్ రికర్సివ్ స్టోరేజ్ స్కానర్\n");
    printf("====================================================\n");

    double grandTotal = calculateFolderSize("రూట్_డ్రైవ్_C:", 2, 50.0, 0);

    printf("----------------------------------------------------\n");
    printf("📊 మొత్తం C: డ్రైవ్ ఉపయోగించిన స్పేస్: %.2f MB\n", grandTotal);
    printf("====================================================\n");

    return 0;
}