C++ में एक संख्या के चार कारकों के गुणनफल को अधिकतम करना

दिया गया कार्य एक दी गई संख्या N के चार कारकों A, B, C, D से प्राप्त होने वाले अधिकतम गुणनफल की गणना करना है, दी गई शर्त के साथ:

चार कारकों का योग संख्या N के बराबर होना चाहिए, यानी N = A + B + C + D।

इनपुट - N=10

आउटपुट - 20

व्याख्या - 10 के कारक हैं: 1, 2, 5, 10।

अधिकतम गुणनफल 5×2×2×1=20 से प्राप्त किया जा सकता है और यह दी गई शर्त को भी संतुष्ट करता है, यानी 5+2+2+1=10।

इनपुट - N=16

आउटपुट - 256

व्याख्या - 16 के कारक हैं: 1, 2, 4, 8, 16।

अधिकतम गुणनफल 4×4×4×4=256 से प्राप्त किया जा सकता है और यह दी गई शर्त को भी संतुष्ट करता है, यानी 4+4+4+4=16।

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

दिए गए नंबर के कारकों को संग्रहीत करने के लिए Factors[] नाम का एक इंट टाइप का ऐरे बनाएं और ऐरे के भरे हुए आकार को ट्रैक करने के लिए K=0 टाइप का एक इंट वेरिएबल बनाएं।
दिए गए नंबर के कारकों को खोजने के लिए FindFactors() फंक्शन बनाएं।
i=1 से i*i<=N तक लूप करें
लूप के अंदर if (N%i == 0) सेट करें ताकि जांचा जा सके कि i कारक है या नहीं।
यदि i कारक है, तो जांचें कि (N/i == i)। यदि हां तो i को Factors[] में डालें अन्यथा N/i और i दोनों को Factors[] में डालें।
कारकों में से अधिकतम गुणनफल खोजने के लिए Product() फंक्शन बनाएं।
इंट product=0 और size=K+1 इनिशियलाइज़ करें।
चार नेस्टेड लूप इनिशियलाइज़ करें और उन्हें 'size' तक चलाएं।
लूप के अंदर, इंट sum = Factors[i] + Factors[j] + Factors[k] + Factors[l] इनिशियलाइज़ करें।
जांचें कि (sum == N) और यदि हां तो pro = Factors[i] * Factors[j] * Factors[k] * Factors[l] इनिशियलाइज़ करें।
फिर जांचें कि (pro > product), यदि हां तो product = pro रखें।
product रिटर्न करें

उदाहरण

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

// कारकों को संग्रहीत करने के लिए ऐरे
int Factors[30];
int K = 0;

// दिए गए नंबर के कारकों को खोजने का फंक्शन
int FindFactors(int N) {
    // i के sqrt(N) तक पहुंचने तक लूप करना
    for (int i = 1; i * i <= N; i++) {
        if (N % i == 0) {
            /* यदि दोनों कारक समान हैं तो केवल एक डाला जाएगा */
            if ((N / i) == i) {
                Factors[K] = i;
                K++;
            } else {
                // ऐरे में पहला कारक डालना
                Factors[K] = N / i;
                K++;
                // ऐरे में दूसरा कारक डालना
                Factors[K] = i;
                K++;
            }
        }
    }
}

// अधिकतम गुणनफल खोजने का फंक्शन
int Product(int N) {
    int product = 0;
    int size = K;
    for (int i = 0; i < size; i++)
        for (int j = 0; j < size; j++)
            for (int k = 0; k < size; k++)
                for (int l = 0; l < size; l++) {
                    // कारकों के प्रत्येक सेट को जोड़ना
                    int sum = Factors[i] + Factors[j] + Factors[k] + Factors[l];
                    // जांचें कि क्या योग N के बराबर है
                    if (sum == N) {
                        // कारकों को गुणा करना
                        int pro = Factors[i] * Factors[j] * Factors[k] * Factors[l];
                        // यदि बड़ा मान मिलता है तो product का मान बदलना
                        if (pro > product)
                            product = pro;
                    }
                }
    return product;
}

// मुख्य फंक्शन
int main() {
    int N = 10;
    // N के कारकों को खोजने के लिए फंक्शन कॉल करना
    FindFactors(N);
    // अधिकतम गुणनफल खोजने के लिए फंक्शन कॉल करना
    cout << "Maximum product: " << Product(N);
    return 0;
}

आउटपुट

Maximum product: 20