अद्वितीय युग्मों की संख्या (गिरफ्तारी [i], गिरफ्तारी [j]) जैसे कि i

हमें पूर्णांक तत्वों वाली एक सरणी दी गई है। लक्ष्य सरणी के तत्वों के अद्वितीय जोड़े को ढूंढना है जैसे कि प्रकार के जोड़े (arr[i],arr[j]) में इंडेक्स हैं जैसे कि i

आइए उदाहरणों के साथ समझते हैं

इनपुट - गिरफ्तारी [] ={1,2,3};

आउटपुट − अद्वितीय युग्मों की संख्या (arr[i], arr[j]) जैसे कि i

स्पष्टीकरण - चूंकि सभी तत्व अद्वितीय हैं। जोड़े होंगे -

(1,2) - ( arr[0],arr[1] ) 0<1
(1,3) - ( arr[0], arr[2] ) 0<2
(2,3) - ( arr[1],arr[2] ) 1<2

इनपुट - गिरफ्तारी [] ={ 4,4,3,2};

आउटपुट − अद्वितीय युग्मों की संख्या (arr[i], arr[j]) जैसे कि i

स्पष्टीकरण - चूंकि सभी तत्व अद्वितीय हैं। जोड़े होंगे -

(4,4) - ( arr[0],arr[1] ) 0<1
(4,3) - ( arr[0], arr[2] ) 0<2
(4,2) - ( arr[0],arr[3] ) 0<3
(3,2) - ( arr[2],arr[3] ) 2<3

नीचे दिए गए प्रोग्राम में इस्तेमाल किया गया तरीका इस प्रकार है

हम दो दृष्टिकोणों का उपयोग करेंगे। लूप के लिए उपयोग करके पहला अनुभवहीन दृष्टिकोण। लूप के लिए दो का उपयोग करके ट्रैवर्सिंग ऐरे एआर [] शुरू करें। i=0 से i<लंबाई-1 और j=i+1 से j<लंबाई तक। इस तरह हमेशा मैं> se; 'se' के अंत में i . के साथ अद्वितीय जोड़ियों की संख्या होगी

• पूर्णांक तत्वों और लंबाई के साथ पूर्णांक सरणियों को गिरफ्तार करें [] आकार के रूप में लें

• फ़ंक्शन unique_pair(int arr[], int size) सरणी और इसकी लंबाई लेता है और अद्वितीय जोड़े की संख्या देता है जैसे कि जोड़ी में (arr[i],arr[j]) अनुक्रमणिका i

• गिनती का प्रारंभिक मान 0 के रूप में लें।

• पूर्णांक युग्मों वाला एक समुच्चय 'se' लीजिए। (सेट<जोड़ी> se)

• लूप के लिए दो का उपयोग करके ट्रैवर्सिंग एआर [] शुरू करें। i=0 से i

• प्रत्येक जोड़ी के लिए हमेशा i का उपयोग करके जोड़ी (arr[i],arr[j]) को 'se' में जोड़ें।

• लूप के लिए दोनों के अंत में, count=se.size() अपडेट करें।

• काउंट में अब 'से' में कई जोड़े हैं। (सभी अद्वितीय हैं)।

• परिणाम के रूप में वापसी की गिनती।

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

इस दृष्टिकोण में, हम प्रत्येक तत्व के बाद अद्वितीय तत्व पाएंगे। arr[i] arr[i+1 to size-1] से विशिष्ट/अद्वितीय तत्वों के साथ जोड़ा जाएगा। तो अगर एआर [i] के बाद एक्स अद्वितीय तत्व हैं, तो एआर [i] एक्स जोड़े बनायेगा। इसलिए हम पहले इंडेक्स i के बाद अद्वितीय तत्वों को चिह्नित करने वाला एक सरणी बनाएंगे। फिर कुल अद्वितीय जोड़ियों के लिए ऐसी अलग-अलग संख्याएं जोड़ें।

• पूर्णांक तत्वों और लंबाई के साथ पूर्णांक सरणियों को गिरफ्तार करें [] आकार के रूप में लें

• फ़ंक्शन unique_pair(int arr[], int size) सरणी और इसकी लंबाई लेता है और अद्वितीय जोड़े की संख्या देता है जैसे कि जोड़ी में (arr[i],arr[j]) अनुक्रमणिका i

• गिनती का प्रारंभिक मान 0 के रूप में लें।

• अस्थायी चर लें और इसे 0 पर सेट करें।

• लंबाई आकार की arr_2[] सरणी लें और arr_2[size-1]=0 प्रारंभ करें, क्योंकि अंतिम तत्व में इसके बाद 0 अद्वितीय तत्व होते हैं।

• दो पूर्णांक सेट बनाएं चेक और अनचेक करें।

• अंतिम तत्व से प्रथम.i =आकार -1 से i> =0 तक ट्रैवर्स सरणी। गिरफ्तारी के लिए खोजें [i] सेट चेक में।

• नहीं मिला तो अनोखा है। वृद्धि अस्थायी (अस्थायी गिरफ्तारी के बाद अद्वितीय तत्वों की गिनती है [i])। arr_2[i]=temp.

  . सेट करें

• अन्य गिरफ्तारी_2[i]=अस्थायी। तापमान में वृद्धि के बिना।

• चेक सेट करने के लिए एआर [i] डालें। अब गिरफ्तारी की अगली घटना[i] पर विचार नहीं किया जाएगा।

• इसके अंत के बाद लूप के लिए। arr_2[] अपडेट किया गया है।

• अब ट्रैवर्स एआर [] इंडेक्स i=0 से i

• अचिह्नित करने के लिए गिरफ्तारी [i] जोड़ें। अब गिरफ्तारी की अगली घटना[i] पर विचार नहीं किया जाएगा।

• अंत में गिनती में अद्वितीय जोड़े होते हैं जैसे कि i

• परिणाम के रूप में वापसी की गिनती।

उदाहरण (बेवकूफ दृष्टिकोण)

#include<bits/stdc++.h>
using namespace std;
int unique_pair(int arr[], int size){
   int count = 0;
   set<pair<int, int>> se;
   for(int i = 0; i < (size - 1); i++){
      for (int j = i + 1; j < size; j++){
         se.insert(make_pair(arr[i], arr[j]));
      }
   }
   count = se.size();
   return count;
}
int main(){
   int arr[] = { 4, 3, 1, 6, 7 };
   int size = sizeof(arr) / sizeof(arr[0]);
   cout<<"Count of unique pairs (arr[i], arr[j]) such that i < j are: "<<unique_pair(arr, size);
return 0;
}

आउटपुट

यदि हम उपरोक्त कोड चलाते हैं तो यह निम्न आउटपुट उत्पन्न करेगा -

Count of unique pairs (arr[i], arr[j]) such that i & j are: 10

उदाहरण (कुशल दृष्टिकोण)

#include<bits/stdc++.h>
using namespace std;
int unique_pair(int arr[], int size){
   int count = 0, temp = 0;
   int arr_2[size];
   arr_2[size-1] = 0;
   set<int> check, uncheck;
   for (int i = size - 1; i > 0; i--){
      auto set = check.find(arr[i]);
      if (set != check.end()){
         arr_2[i - 1] = temp;
      }
      else{
         arr_2[i - 1] = ++temp;
      }
      check.insert(arr[i]);
   }
   for (int i = 0; i < size - 1; i++){
      auto set = uncheck.find(arr[i]);
      if (set != uncheck.end()){
         continue;
      }
      count += arr_2[i];
      uncheck.insert(arr[i]);
   }
   return count;
}
int main(){
   int arr[] = { 4, 3, 1, 6, 7 };
   int size = sizeof(arr)/sizeof(arr[0]);
   cout<<"Count of unique pairs (arr[i], arr[j]) such that i < j are: "<<unique_pair(arr, size);
   return 0;
}

आउटपुट

यदि हम उपरोक्त कोड चलाते हैं तो यह निम्न आउटपुट उत्पन्न करेगा -

Count of unique pairs (arr[i], arr[j]) such that i < j are: 10