इस लेख में, हमारे पास एक सरणी है जिसमें अलग-अलग तत्व हैं। हमें सरणी में सकारात्मक-नकारात्मक मानों के जोड़े को समान निरपेक्ष मान के साथ प्रिंट करना होगा और उदाहरण के लिए उन्हें क्रमबद्ध क्रम में प्रिंट करना होगा -
Input : arr[] = { 1, -1, 11, 12, 56, 77, -56, -12, -88}
Output : -1 1 -12 12 -56 56
Input : arr[] = {30, 40, 50, 77, -51, -50, -40}
Output : -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); // size of our array.
vector<int> nums; // the present pairs.
for(int i = 0; i < n; i++) {
for(int j = i+1; j < n; j++) {
if(abs(arr[j]) == abs(arr[i])) { // finding the pairs.
nums.push_back(abs(arr[i]));
break;
// if we found the pair then we can just break as there are distinct elements in the array.
}
}
}
sort(nums.begin(), nums.end());
for(auto x : nums) // printing the pairs.
cout << -x << " " << x << " ";
} आउटपुट
-1 1 -12 12 -56 56
इस दृष्टिकोण में, हम सरणी को पार करने और अन्य तत्व को खोजने के लिए दो लूप का उपयोग करते हैं; यदि हम अन्य तत्व पाते हैं, तो हम कोड को तेजी से चलाने के लिए आंतरिक लूप से बाहर निकलते हैं। अब जब हम दो फॉर-लूप का उपयोग कर रहे हैं, तो हमारी समग्र समय जटिलता ओ (एन * एन) है। 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); // size of our array.
map<int, int> found; // going to store the count of numbers found.
vector<int> nums; // the present pairs.
for(int i = 0; i < n; i++)
found[abs(arr[i])]++; // increasing the frequency of abs(arr[i]).
for(auto x : found) { // traversing the map.
if(x.second == 2) // if any numbers frequency is two then push it to nums.
nums.push_back(x.first);
}
for(auto x : nums) // printing the pairs.
cout << -x << " " << x << " ";
} आउटपुट
-1 1 -4 4 -8 8 -9 9
उपरोक्त कोड की व्याख्या
इस दृष्टिकोण में, हम किसी संख्या की आवृत्ति को संग्रहीत करने के लिए हैशमैप का उपयोग कर रहे हैं; जैसा कि हम सरणी के माध्यम से पार करते हैं, हम वर्तमान तत्व के निरपेक्ष मान की आवृत्ति को अब अपडेट कर रहे हैं क्योंकि आप जानते हैं कि सभी जोड़े में दो का मान होगा इसलिए हम मानचित्र को पार कर रहे हैं।
यदि किसी संख्या की बारंबारता 2 है, तो हम इसे अंकों में संग्रहीत कर रहे हैं, और अंत में, हम क्रमबद्ध क्रम में मानों को प्रिंट कर रहे हैं। (चूंकि मानचित्र में क्रमित क्रम में संख्या होती है, हमें संख्या सदिश को क्रमबद्ध करने की आवश्यकता नहीं होती है)।
निष्कर्ष
इस लेख में, हम हैशिंग तकनीक का उपयोग करके एक सरणी में सकारात्मक नकारात्मक मूल्यों के जोड़े खोजने के लिए एक समस्या का समाधान करते हैं। हमने इस समस्या के लिए C++ प्रोग्राम और संपूर्ण दृष्टिकोण (सामान्य और कुशल) भी सीखा जिसके द्वारा हमने इस समस्या को हल किया। हम उसी प्रोग्राम को अन्य भाषाओं जैसे सी, जावा, पायथन और अन्य भाषाओं में लिख सकते हैं। हमें उम्मीद है कि आपको यह लेख मददगार लगा होगा।