C++ में n^x में अंकों का पुनरावर्ती योग, जहां n और x बहुत बड़े हैं

हमें 'num' और 'x' के रूप में धनात्मक पूर्णांक वेरिएबल दिए गए हैं। कार्य पुनरावर्ती रूप से num^x की गणना करना है, फिर परिणामी संख्या के अंकों को तब तक जोड़ना है जब तक एकल अंक प्राप्त न हो जाए, और परिणामी एकल अंक आउटपुट होगा।

विभिन्न इनपुट-आउटपुट परिदृश्य देखते हैं:

इनपुट: int num = 2345, int x = 3

आउटपुट: n^x में अंकों का पुनरावर्ती योग, जहां n और x बहुत बड़े हैं: 8

व्याख्या: हमें num और x के रूप में धनात्मक पूर्णांक मान दिए गए हैं जिनके मान 2345 और घात 3 हैं। पहले, 2345^3 की गणना करें यानी 12,895,213,625। अब, हम इन अंकों को जोड़ेंगे: 1 + 2 + 8 + 9 + 5 + 2 + 1 + 3 + 6 + 2 + 5 = 44। अब हम 4 + 4 = 8 जोड़ेंगे। चूंकि हमने एकल अंक प्राप्त कर लिया है, इसलिए आउटपुट 8 है।

इनपुट: int num = 3, int x = 3

आउटपुट: n^x में अंकों का पुनरावर्ती योग, जहां n और x बहुत बड़े हैं: 9

व्याख्या: हमें num और x के रूप में धनात्मक पूर्णांक मान दिए गए हैं जिनके मान 3 और घात 3 हैं। पहले, 3^3 की गणना करें यानी 9। चूंकि हमने एकल अंक प्राप्त कर लिया है, इसलिए आउटपुट 9 है और आगे किसी गणना की आवश्यकता नहीं है।

नीचे दिए गए प्रोग्राम में उपयोग किया गया दृष्टिकोण:

• एक पूर्णांक वेरिएबल num और x इनपुट करें और डेटा को फंक्शन Recursive_Digit(num, x) में आगे की प्रोसेसिंग के लिए पास करें।
• फंक्शन Recursive_Digit(num, x) के अंदर:
  • 'total' वेरिएबल को long के रूप में घोषित करें और इसे फंक्शन total_digits(num) को कॉल करके सेट करें जो पास किए गए नंबर के अंकों का योग लौटाएगा।
  • temp वेरिएबल को long प्रकार का घोषित करें और इसे power % 6 पर सेट करें।
  • जांचें यदि total = 3 या total = 6 और power > 1 तो 9 लौटाएं।
  • अन्यथा यदि, power = 1 तो total लौटाएं।
  • अन्यथा यदि, power = 0 तो 1 लौटाएं।
  • अन्यथा यदि, temp == 0 तो total_digits((long)pow(total, 6)) को कॉल करके लौटाएं।
  • अन्यथा, total_digits((long)pow(total, temp)) को लौटाएं।
• फंक्शन long total_digits(long num) के अंदर:
  • जांचें यदि num = 0 तो 0 लौटाएं। जांचें यदि num % 9 = 0 तो 9 लौटाएं।
  • अन्यथा, num % 9 लौटाएं।

उदाहरण

#include <bits/stdc++.h>
using namespace std;

long total_digits(long num) {
    if(num == 0) {
        return 0;
    }
    if(num % 9 == 0) {
        return 9;
    } else {
        return num % 9;
    }
}

long Recursive_Digit(long num, long power) {
    long total = total_digits(num);
    long temp = power % 6;
    if((total == 3 || total == 6) && power > 1) {
        return 9;
    } else if (power == 1) {
        return total;
    } else if (power == 0) {
        return 1;
    } else if (temp == 0) {
        return total_digits((long)pow(total, 6));
    } else {
        return total_digits((long)pow(total, temp));
    }
}

int main() {
    int num = 2345;
    int x = 98754;
    cout << "Recursive sum of digit in n^x, where n and x are very large are: " << Recursive_Digit(num, x);
    return 0;
}

आउटपुट

यदि हम उपरोक्त कोड चलाते हैं तो यह निम्नलिखित आउटपुट उत्पन्न करेगा:

Recursive sum of digit in n^x, where n and x are very large are: 1