बड़ी संख्या का फैक्टोरियल

परिचय

कंप्यूटर में, वेरिएबल्स मेमोरी स्थानों में संग्रहीत होते हैं। लेकिन मेमोरी स्थान का आकार निश्चित होता है, इसलिए जब हम 15! या 20! जैसे कुछ बड़े मान का फैक्टोरियल खोजने का प्रयास करते हैं, तो फैक्टोरियल मान मेमोरी रेंज को पार कर जाता है और गलत परिणाम देता है।

बड़ी संख्याओं की गणना के लिए, हमें परिणाम संग्रहीत करने के लिए एक सरणी का उपयोग करना होगा। सरणी के प्रत्येक तत्व में, परिणाम के विभिन्न अंक संग्रहीत होते हैं। लेकिन यहां हम सीधे सरणी के साथ कुछ संख्या को गुणा नहीं कर सकते, हमें परिणाम सरणी के सभी अंकों के लिए मैन्युअल गुणन प्रक्रिया करनी होगी।

इनपुट और आउटपुट

इनपुट: एक बड़ी संख्या: 50
आउटपुट: दी गई संख्या का फैक्टोरियल है: 30414093201713378043612608166064768844377641568960512000000000000

एल्गोरिदम

multiply(x, multiplicand)

इनपुट: संख्या x, और बड़ा गुणक एक सरणी के रूप में।

आउटपुट: गुणन के बाद परिणाम।

Begin
    carry := 0
    multiplicand के सभी अंकों i के लिए, करें
        prod := i*x + carry
        i := prod mod 10
        carry := prod / 10
    done
    जब तक carry ≠ 0, करें
        multiplicand सरणी के अंत में (carry mod 10) डालें
        carry := carry/10
    done
End

factorial(n)

इनपुट: संख्या n।

आउटपुट: n का फैक्टोरियल खोजें।

Begin
    परिणाम सरणी परिभाषित करें।
    परिणाम में 1 डालें
    i := 2 से n तक, करें
        multiply(i, result)
    done
    परिणाम को उल्टा करें
    परिणाम लौटाएं
End

उदाहरण (C++ कोड)

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

void multiply(int x, vector<int>& multiplicand) {
    // multiplicand को x से गुणा करें
    int carry = 0; // कैरी को 0 से आरंभ करें
    vector<int>::iterator i;
    for (i = multiplicand.begin(); i != multiplicand.end(); i++) {
        // multiplicand के सभी अंकों के साथ x को गुणा करें
        int prod = (*i) * x + carry;
        *i = prod % 10; // उत्पाद का केवल अंतिम अंक डालें
        carry = prod / 10; // शेष भाग को कैरी के साथ जोड़ें
    }
    while (carry) {
        // जब कैरी मौजूद हो
        multiplicand.push_back(carry % 10);
        carry = carry / 10;
    }
}

void factorial(int n) {
    vector<int> result;
    result.push_back(1); // पहले परिणाम के रूप में 1 संग्रहीत करें
    for (int i = 2; i <= n; i++)
        multiply(i, result); // संख्याओं को गुणा करें 1*2*3*......*n
    cout << "Factorial of given number is: " << endl;
    reverse(result.begin(), result.end()); // परिणाम के क्रम को उल्टा करें
    vector<int>::iterator it;
    for (it = result.begin(); it != result.end(); it++)
        cout << *it;
}

int main() {
    factorial(50);
}

आउटपुट

Factorial of given number is: 30414093201713378043612608166064768844377641568960512000000000000