C++ का उपयोग करके एरे में पॉजिटिव-नेगेटिव मानों के जोड़े खोजना

इस लेख में, हमारे पास एक एरे है जिसमें विशिष्ट तत्व हैं। हमें एरे में समान निरपेक्ष मान वाले पॉजिटिव-नेगेटिव मानों के जोड़े प्रिंट करने की आवश्यकता है और उन्हें सॉर्टेड क्रम में प्रिंट करना है। उदाहरण के लिए:

इनपुट: arr[] = {1, -1, 11, 12, 56, 77, -56, -12, -88}
आउटपुट: -1 1 -12 12 -56 56

इनपुट: arr[] = {30, 40, 50, 77, -51, -50, -40}
आउटपुट: -40 40 -50 50

समाधान का दृष्टिकोण

पहला दृष्टिकोण जो हमारे दिमाग में आता है वह ब्रूट फोर्स दृष्टिकोण है, और हम एक और बनाते हैं जिसे कुशल दृष्टिकोण कहते हैं। हम दोनों दृष्टिकोणों पर चर्चा करने जा रहे हैं।

ब्रूट फोर्स दृष्टिकोण

इस दृष्टिकोण में, हम एक इंडेक्स हाथ में लेकर एरे को ट्रैवर्स करेंगे और उसी निरपेक्ष मान को ढूंढेंगे लेकिन अलग इंडेक्स पर।

उदाहरण

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

int main() {
    int arr[] = {1, -1, 11, 12, 56, 77, -56, -12, -88};
    int n = sizeof(arr)/sizeof(int); // हमारे एरे का आकार।
    vector<int> nums; // मौजूद जोड़े।
    for(int i = 0; i < n; i++) {
        for(int j = i+1; j < n; j++) {
            if(abs(arr[j]) == abs(arr[i])) { // जोड़े ढूंढना।
                nums.push_back(abs(arr[i]));
                break;
                // यदि हमें जोड़ा मिल गया तो हम बस ब्रेक कर सकते हैं क्योंकि एरे में विशिष्ट तत्व हैं।
            }
        }
    }
    sort(nums.begin(), nums.end());
    for(auto x : nums) // जोड़े प्रिंट करना।
        cout << -x << " " << x << " ";
}

आउटपुट

-1 1 -12 12 -56 56

इस दृष्टिकोण में, हम एरे को ट्रैवर्स करने और दूसरे तत्व को खोजने के लिए दो लूप का उपयोग करते हैं; अब यदि हमें दूसरा तत्व मिल जाता है, तो हम कोड को तेजी से चलाने के लिए आंतरिक लूप से ब्रेक आउट करते हैं। अब चूंकि हम दो फॉर-लूप का उपयोग कर रहे हैं, हमारी समग्र समय जटिलता O(N*N) है। N दिए गए एरे का आकार है जो निचले प्रतिबंधों के लिए अच्छा है लेकिन उच्च प्रतिबंधों के लिए अच्छा नहीं है, इसलिए अब हम दूसरे दृष्टिकोण पर चर्चा करेंगे।

कुशल दृष्टिकोण

इस दृष्टिकोण में, हम एक हैशमैप का उपयोग करेंगे, जो हमारी समय जटिलता में काफी कमी लाने में मदद करेगा।

उदाहरण

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

int main() {
    int arr[] = {4, 8, 9, -4, 1, -1, -8, -9};
    int n = sizeof(arr)/sizeof(int); // हमारे एरे का आकार।
    map<int, int> found; // मिली संख्याओं की गिनती स्टोर करने जा रहा है।
    vector<int> nums; // मौजूद जोड़े।
    for(int i = 0; i < n; i++)
        found[abs(arr[i])]++; // abs(arr[i]) की आवृत्ति बढ़ाना।
    for(auto x : found) { // मैप को ट्रैवर्स करना।
        if(x.second == 2) // यदि किसी संख्या की आवृत्ति दो है तो इसे nums में पुश करें।
            nums.push_back(x.first);
    }
    for(auto x : nums) // जोड़े प्रिंट करना।
        cout << -x << " " << x << " ";
}

आउटपुट

-1 1 -4 4 -8 8 -9 9

उपरोक्त कोड की व्याख्या

इस दृष्टिकोण में, हम एक संख्या की आवृत्ति स्टोर करने के लिए हैशमैप का उपयोग कर रहे हैं; जैसे ही हम एरे के माध्यम से ट्रैवर्स करते हैं, हम वर्तमान तत्व के निरपेक्ष मान की आवृत्ति को अपडेट कर रहे हैं। अब जैसा कि आप जानते हैं कि सभी जोड़ों का मान दो होगा, इसलिए फिर हम मैप को ट्रैवर्स कर रहे हैं। यदि किसी संख्या की आवृत्ति 2 है, तो हम इसे nums में स्टोर कर रहे हैं, और अंत में, हम मानों को सॉर्टेड क्रम में प्रिंट कर रहे हैं। (चूंकि मैप में संख्या सॉर्टेड क्रम में होती है, हमें नंबर्स वेक्टर को सॉर्ट करने की आवश्यकता नहीं है)।

निष्कर्ष

इस लेख में, हम हैशिंग तकनीक का उपयोग करके एरे में पॉजिटिव-नेगेटिव मानों के जोड़े खोजने की समस्या को हल करते हैं। हमने इस समस्या के लिए C++ प्रोग्राम और इसे हल करने के पूर्ण दृष्टिकोण (सामान्य और कुशल) को भी सीखा। हम इसी प्रोग्राम को C, Java, Python और अन्य भाषाओं में लिख सकते हैं। आशा है कि आपको यह लेख मददगार लगा होगा।