सी ++ में मूल सरणी के समान कुल अलग-अलग तत्वों वाले उप-सरणी की गणना करें

हमें एक सरणी दी गई है arr[] जिसमें पूर्णांक हैं। लक्ष्य गिरफ्तारी [] के सभी उप-सरणी को गिनना है जैसे कि प्रत्येक में अलग-अलग तत्वों की संख्या मूल सरणी में अलग-अलग तत्वों की संख्या के समान होती है। अगर मूल सरणी [1,1,2,3] है तो उप-सरणी [1,2,3] और [1,1,2,3] होंगी।

मूल सरणी में कुल विशिष्ट तत्व 3 हैं। दोनों उप-सरणी में कुल विशिष्ट तत्व भी 3 हैं

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

इनपुट - एआर [] ={1,2,1,2,3,4,2};

आउटपुट − मूल सरणी के समान कुल विशिष्ट तत्वों वाले उप-सरणी की संख्या है − 6

स्पष्टीकरण - एआर में विशिष्ट तत्व [] 4 (1,2,3,4) हैं। अलग-अलग तत्वों की समान संख्या वाली उप-सरणी हैं:(बाएं से दाएं की गणना अलग-अलग)

[1,2,1,2,3,4], [2,1,2,3,4], [1,2,3,4], [1,2,3,4,2], [2,1,2,3,4,2], [1,2,1,2,3,4,2 ]

इनपुट - गिरफ्तार [] ={8,7,5,6,10};

आउटपुट − मूल सरणी के समान कुल विशिष्ट तत्वों वाले उपसरणियों की संख्या है − 1

स्पष्टीकरण - एआर में विशिष्ट तत्व [] 5 (5,6,7,8,10) हैं। अलग-अलग तत्वों की समान संख्या वाले उप-सरणी हैं:(बाएं से दाएं की गणना करें) [8,7,6,5,10]। केवल 1

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

• पूर्णांक संख्याओं का एक सरणी arr[] लें और एक सरणी के आकार की गणना करें।

• फ़ंक्शन sub_ele_diff_one(int arr[], int size) सरणी लेता है और लगातार तत्वों के साथ उपसरणियों की गिनती देता है जो 1 से भिन्न होते हैं।

• एक अस्थायी चर गणना और चर को दाएं और बाएं लें।

• यादृच्छिक जोड़े बनाने के लिए unordered_map प्रकार का एक चर लें।

• 0 से एक सरणी के आकार तक के लिए लूप प्रारंभ करें और इसके अंदर unordered_map के अंदर arr[i] का मान सेट करें।

• अब, एक unordered_map के आकार की गणना करें और unordered_map को साफ़ करें।

• 0 से एक सरणी के आकार तक के लिए लूप प्रारंभ करें।

• लूप के अंदर, WHILE को दाएं <आकार और बाएं . तक प्रारंभ करें

• um[arr[right]]

  . का मान पहले से बढ़ाएं

• अब, जांचें कि क्या um[arr[right]] =1 है, तो पहले बाएं के मान को 1 से बढ़ा दें।

• WHILE के बाहर, अधिकार के मान को 1 से पहले बढ़ा दें।

• चेक करें IF बाएँ =एक unordered_map का आकार फिर गिनने के लिए सेट करें + आकार - दाएँ + 1

• um[arr[i]] को 1 से घटाएं

• IF um[arr[i]] =0 की जाँच करें और फिर बाईं ओर को 1

  . से घटाएँ

• गिनती वापस करें

• परिणाम प्रिंट करें।

उदाहरण

#include <bits/stdc++.h>
using namespace std;
int sub_distinct(int arr[], int size){
   int count = 0, right = 0, left = 0;
   unordered_map<int, int> um;
   for (int i = 0; i < size; ++i){
      um[arr[i]] = 1;
   }
   int um_size = um.size();
   um.clear();
   for(int i = 0; i < size; ++i){
      while (right < size && left < um_size){
         ++um[arr[right]];
         if (um[arr[right]] == 1){
            ++left;
         }
         ++right;
      }
      if (left == um_size){
         count = count + (size - right + 1);
      }
      --um[arr[i]];
      if (um[arr[i]] == 0){
         --left;
      }
   }
   return count;
}
int main(){
   int arr[] = {4, 3, 2, 5};
   int size = sizeof(arr) / sizeof(arr[0]);
   cout<<"Count of subarrays having total distinct elements same as original array are: "<<sub_distinct(arr, size);
   return 0;
}

आउटपुट

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

Count of subarrays having total distinct elements same as original array are: 1