C++ में ऐरे में सभी अभाज्य संख्याओं का गुणनफल

कुछ एलिमेंट्स के साथ एक इंटीजर ऐरे arr[] दिया गया है, कार्य उस ऐरे की सभी अभाज्य संख्याओं का गुणनफल निकालना है।

अभाज्य संख्याएं वे संख्याएं होती हैं जो या तो 1 से विभाज्य होती हैं या स्वयं संख्या से, या एक अभाज्य संख्या वह संख्या है जो 1 और स्वयं संख्या को छोड़कर किसी अन्य संख्या से विभाज्य नहीं होती। जैसे 2, 3, 5, 7, 11, आदि। (नोट: 1 अभाज्य संख्या नहीं है)

हमें दिए गए ऐरे के लिए समाधान ढूंढना है:

इनपुट - arr[] = {11, 20, 31, 4, 5, 6, 70}

आउटपुट - 1705

व्याख्या - ऐरे में अभाज्य संख्याएं हैं: 11, 31, 5 उनका गुणनफल 1705 है

इनपुट - arr[] = {1, 2, 3, 4, 5, 6, 7}

आउटपुट - 210

व्याख्या - ऐरे में अभाज्य संख्याएं हैं: 2, 3, 5, 7 उनका गुणनफल 210 है (नोट: 1 अभाज्य नहीं है)

समस्या को हल करने के लिए नीचे दिया गया दृष्टिकोण

इनपुट ऐरे arr[] लें।
प्रत्येक एलिमेंट को लूप करें और जांचें कि यह अभाज्य है या नहीं।
ऐरे में मौजूद सभी अभाज्य संख्याओं का गुणनफल करें।
गुणनफल रिटर्न करें।

एल्गोरिदम

Start
In function int prodprimearr(int arr[], int n)
    Step 1→ ऐरे के अधिकतम मान को max_val के रूप में घोषित और इनिशियलाइज़ करें
    Step 2→ max_val + 1 आकार का vector isprime घोषित करें, सभी true से इनिशियलाइज़
    Step 3→ isprime[0] और isprime[1] को false सेट करें
    Step 4→ p = 2 से p*p <= max_val तक लूप, p++
        यदि isprime[p] == true तो,
            i = p*2 से i <= max_val तक लूप, i += p
                isprime[i] को false सेट करें
    Step 5→ prod को 1 सेट करें
    Step 6→ i = 0 से i < n तक लूप, i++
        यदि isprime[arr[i]] तो
            prod = prod * arr[i]
    Step 7→ prod रिटर्न करें

In function int main()
    Step 1→ arr[] = {11, 20, 31, 4, 5, 6, 70} घोषित और इनिशियलाइज़ करें
    Step 2→ n = sizeof(arr)/sizeof(arr[0]) घोषित और इनिशियलाइज़ करें
    Step 3→ prodprimearr(arr, n) के परिणाम प्रिंट करें
Stop

उदाहरण

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

int prodprimearr(int arr[], int n) {
    // ऐरे के अधिकतम मान को खोजने के लिए
    int max_val = *max_element(arr, arr + n);
    
    // SIEVE का उपयोग करके max_val से कम या बराबर सभी अभाज्य संख्याएं खोजें
    vector<bool> isprime(max_val + 1, true);
    isprime[0] = false;
    isprime[1] = false;
    
    for (int p = 2; p * p <= max_val; p++) {
        // यदि isprime[p] बदला नहीं गया, तो यह एक अभाज्य संख्या है
        if (isprime[p] == true) {
            // p के सभी गुणकों को अपडेट करें
            for (int i = p * 2; i <= max_val; i += p)
                isprime[i] = false;
        }
    }
    
    // arr[] में सभी अभाज्य संख्याओं का गुणनफल
    int prod = 1;
    for (int i = 0; i < n; i++)
        if (isprime[arr[i]])
            prod *= arr[i];
    
    return prod;
}

int main() {
    int arr[] = {11, 20, 31, 4, 5, 6, 70};
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << prodprimearr(arr, n);
    return 0;
}