C/C++ में मॉड्यूलर समीकरणों के हल की संख्या के लिए प्रोग्राम

समस्या विवरण

यहां हम मॉड्यूलर समीकरणों से संबंधित एक दिलचस्प समस्या देखेंगे। मान लीजिए हमारे पास दो मान A और B हैं। हमें उन संभावित मानों की संख्या ढूंढनी है जो चर X ले सकता है, जैसे कि (A mod X) = B लागू होता है।

उदाहरण

मान लीजिए A = 26, B = 2 है। तो X के लिए पसंदीदा मान {3, 4, 6, 8, 12, 24} होंगे। तो गिनती 6 होगी। यही उत्तर है।

एल्गोरिदम

possibleWayCount(a, b)
शुरुआत
    यदि a = b, तो अनंत हल हैं
    यदि a < b, तो कोई हल नहीं है
    अन्यथा div_count := find_div(a, b)
    वापस div_count
अंत

find_div(a, b)
शुरुआत
    n := a - b
    div_count := 0
    i को 1 से n के वर्गमूल तक लूप
        यदि n mod i = 0, तो
            यदि i > b, तो
                div_count को 1 से बढ़ाएं
            अंत यदि
            यदि n/i, i के समान नहीं है और (n/i) > b, तो
                div_count को 1 से बढ़ाएं
            अंत यदि
        अंत यदि
    अंत लूप
    वापस div_count
अंत

C++ प्रोग्राम उदाहरण

#include <iostream>
#include <cmath>
using namespace std;

int findDivisors(int A, int B) {
    int N = (A - B);
    int div_count = 0;
    for (int i = 1; i <= sqrt(N); i++) {
        if ((N % i) == 0) {
            if (i > B)
                div_count++;
            if ((N / i) != i && (N / i) > B)
                div_count++;
        }
    }
    return div_count;
}

int possibleWayCount(int A, int B) {
    if (A == B)
        return -1;
    if (A < B)
        return 0;
    int div_count = findDivisors(A, B);
    return div_count;
}

void possibleWay(int A, int B) {
    int sol = possibleWayCount(A, B);
    if (sol == -1)
        cout << "A: " << A << " और B: " << B << " के लिए, X " << A << " से बड़े अनंत मान ले सकता है";
    else
        cout << "A: " << A << " और B: " << B << " के लिए, X " << sol << " मान ले सकता है";
}

int main() {
    int A = 26, B = 2;
    possibleWay(A, B);
}

आउटपुट

A: 26 और B: 2 के लिए, X 6 मान ले सकता है