C प्रोग्राम: दी गई संख्या की घात (Power) की गणना करना

समस्या

उपयोगकर्ता से आधार (base) और घातांक (exponent) के रूप में दो पूर्णांक लें और घात की गणना करें।

उदाहरण

• आधार = 3
• घातांक = 4
• घात = 3 × 3 × 3 × 3 = 81

एल्गोरिदम

चरण 1: int और long चर घोषित करें
चरण 2: कंसोल से आधार मान पढ़ें
चरण 3: कंसोल से घातांक मान पढ़ें
चरण 4: while लूप: जब तक घातांक != 0
    i. मान *= आधार
    ii. घातांक--
चरण 5: परिणाम प्रिंट करें

प्रोग्राम 1: पूर्णांक घात (लूप का उपयोग करके)

#include <stdio.h>

int main() {
    int base, exponent;
    long result = 1;
    
    printf("आधार मान दर्ज करें: ");
    scanf("%d", &base);
    
    printf("घातांक मान दर्ज करें: ");
    scanf("%d", &exponent);
    
    while (exponent != 0) {
        result *= base;
        --exponent;
    }
    
    printf("परिणाम = %ld\n", result);
    
    return 0;
}

आउटपुट

रन 1:
आधार मान दर्ज करें: 5
घातांक मान दर्ज करें: 4
परिणाम = 625

रन 2:
आधार मान दर्ज करें: 8
घातांक मान दर्ज करें: 3
परिणाम = 512

प्रोग्राम 2: वास्तविक संख्याओं के लिए pow() फ़ंक्शन

यदि हम वास्तविक संख्याओं की घात खोजना चाहते हैं, तो हम math.h में पूर्वनिर्धारित pow फ़ंक्शन का उपयोग कर सकते हैं।

#include <stdio.h>
#include <math.h>

int main() {
    double base, exponent, result;
    
    printf("आधार मान दर्ज करें: ");
    scanf("%lf", &base);
    
    printf("घातांक मान दर्ज करें: ");
    scanf("%lf", &exponent);
    
    // घात की गणना
    result = pow(base, exponent);
    
    printf("%.1lf^%.1lf = %.2lf\n", base, exponent, result);
    
    return 0;
}

आउटपुट

आधार मान दर्ज करें: 3.4
घातांक मान दर्ज करें: 2.3
3.4^2.3 = 16.69

अनुकूलित संस्करण: फास्ट एक्सपोनेंशिएशन (O(log n))

बड़े घातांक के लिए, लूप O(n) होता है। बाइनरी एक्सपोनेंशिएशन O(log n) में करता है:

long fastPower(long base, int exponent) {
    long result = 1;
    
    while (exponent > 0) {
        if (exponent % 2 == 1) {  // यदि घातांक विषम
            result *= base;
        }
        base *= base;     // आधार वर्ग करें
        exponent /= 2;    // घातांक आधा करें
    }
    
    return result;
}

// उदाहरण: 2^10
// चरण: base=2, exp=10, res=1
// exp सम: base=4, exp=5
// exp विषम: res=4, base=16, exp=2
// exp सम: base=256, exp=1
// exp विषम: res=1024, base=65536, exp=0
// परिणाम: 1024

ऋणात्मक घातांक संभालना

double power(double base, int exponent) {
    if (exponent < 0) {
        base = 1.0 / base;
        exponent = -exponent;
    }
    
    double result = 1.0;
    while (exponent > 0) {
        if (exponent & 1) result *= base;
        base *= base;
        exponent >>= 1;
    }
    return result;
}

कंपाइलेशन नोट

pow() का उपयोग करते समय math लाइब्रेरी लिंक करें:

gcc power.c -o power -lm

सारांश