मेरे पास 3 सरणियाँ हैं

int a[] = {1,3,7,6};
int b[] = {2,5,0,4};
int c[] = {11,23,71,6};

मैं इन तीन सरणियों से सामान्य तत्वों को इष्टतम रूप से खोजना चाहता हूं। मैं सामान्य तत्वों को खोजने के लिए लूप के लिए 3 का उपयोग करने के बारे में सोच रहा हूं लेकिन यह इष्टतम नहीं है। तो क्या लूप के लिए नेस्टेड का उपयोग करने के बजाय इसे करने का कोई बेहतर तरीका है?

0
Ashutosh Mishra 14 जिंदा 2022, 18:02
2
एक "सामान्य तत्व" क्या है? क्या यह वह है जो तीनों सरणियों में प्रकट होता है? या यह एक है जो इनमें से किन्हीं दो सरणियों में प्रकट होता है? जब उत्तरार्द्ध, क्या आपको यह जानने की आवश्यकता है कि यह "सामान्य तत्व" किन दो सरणियों में होता है या क्या आपको केवल डुप्लिकेट जानने की आवश्यकता है?
 – 
Philipp
14 जिंदा 2022, 18:09
 – 
Sharon Ben Asher
14 जिंदा 2022, 18:11
यह संभवतः नहीं होगा, क्योंकि यहाँ प्रश्न लगभग 3 सरणियों का है। उस प्रश्न के उत्तरों को दो से अधिक सरणियों में अपनाना तुच्छ नहीं है।
 – 
Philipp
14 जिंदा 2022, 18:13

3 जवाब

आप तत्वों को स्टोर करने के लिए प्रत्येक सरणी के लिए एक सेट का उपयोग कर सकते हैं ताकि उन्हें ओ (1) समय में एक्सेस किया जा सके और फिर किसी भी सेट में तत्वों पर पुनरावृत्त किया जा सके और जांचें कि यह अन्य दो सेटों में भी मौजूद है या नहीं, क्योंकि सामान्य तत्वों के सेट की गारंटी है तीनों समुच्चयों का उपसमुच्चय हो।

    int a[] = {1,3,7,6};
    int b[] = {2,5,0,4};
    int c[] = {11,23,71,6};
    Set<Integer> set1 = new HashSet<>();
    Set<Integer> set2 = new HashSet<>();
    Set<Integer> set3 = new HashSet<>();
    for(int x: a)
        set1.add(x);
    for(int x: b)
        set2.add(x);
    for(int x: c)
        set3.add(x);
    List<Integer> res = new ArrayList<>();
    Iterator<Integer> itr = set1.iterator();
    while(itr.hasNext()){
        int ele = itr.next();
        if(set2.contains(ele) && set3.contains(ele)){
            res.add(ele);
        }
    }
    return res;

यह दृष्टिकोण उन मामलों में भी काम करना चाहिए जहां एक तत्व को एक सरणी में दोहराया जाता है और इस प्रकार यदि एकल हैशमैप आधारित दृष्टिकोण का उपयोग किया जाता है तो गिनती की आवृत्ति बढ़ सकती है।

0
Siddharth 14 जिंदा 2022, 18:25
ऐसा प्रतीत होता है कि आपका कोड केवल set1 के माध्यम से पुनरावृत्त होता है और उस विशेष संग्रह पर HashSet के किसी भी लाभ का उपयोग नहीं करता है। क्यों न केवल सरणी a का ही उपयोग किया जाए?
 – 
Philipp
14 जिंदा 2022, 18:27
किसी सरणी में किसी तत्व के अस्तित्व की जाँच करना O(n) ऑपरेशन होगा जबकि सेट/मानचित्र के लिए यह O(1) परिशोधित है।
 – 
Siddharth
14 जिंदा 2022, 18:39
यह सच है, लेकिन आपका कोड set1 में अस्तित्व की जांच नहीं करता है। आप इसे केवल set2 और set3 में करते हैं। आपका सभी कोड set1 के साथ करता है, इसे पुनरावृत्त करना है, जो कि डेटा संरचना में एक O(n) ऑपरेशन है (लेकिन शायद हैशसेट में अभी भी धीमा है)।
 – 
Philipp
14 जिंदा 2022, 18:45
हालाँकि मैं आपके कथन के पीछे का तर्क देख सकता हूँ और यह बिल्कुल सही है, हम ऐरे का उपयोग इस तरह कर सकते हैं। लेकिन कथन के लिए क्लीनर और संक्षिप्त कोड लिखने के लिए हम अनिवार्य रूप से तीन सरणियों का सेट बना रहे होंगे और तीन सेटों का प्रतिच्छेदन प्राप्त करने के लिए रिटेनऑल का उपयोग करेंगे। यह लंबा कोड हालांकि कामकाज की बेहतर व्याख्या करता है।
 – 
Siddharth
14 जिंदा 2022, 18:51
मैं यह नहीं देखता कि यह पूरी तरह से व्यर्थ रूपांतरण कदम कैसे कोड को समझना आसान बनाता है, लेकिन आप करते हैं।
 – 
Philipp
14 जिंदा 2022, 18:53

मान लें कि सरणियों में अपने आप में अद्वितीय तत्व हैं (किसी सरणी में कोई डुप्लिकेट नहीं)

आप कुछ डेटा संरचना जैसे HashMap का उपयोग सरणियों के सभी तत्वों को कुंजियों के रूप में पुश करने के लिए कर सकते हैं, और मानों को उनकी घटनाओं की संख्या के रूप में सामान्य तत्वों को खोजने के लिए उपयोग कर सकते हैं यदि मान 3 है:

private ArrayList<Integer> commonElements() {
        int a[] = {1,3,7,6};
        int b[] = {2,5,0,4};
        int c[] = {11,23,71,6};
        
        HashMap<Integer, Integer> elementCunt = new HashMap<>();
        
        for(int element: a) {
            if(elementCunt.containsKey(element)) {
                elementCunt.put(element, elementCunt.get(element) + 1);
            } else {
                elementCunt.put(element, 1);
            }
        }
        
        for(int element: b) {
            if(elementCunt.containsKey(element)) {
                elementCunt.put(element, elementCunt.get(element) + 1);
            } else {
                elementCunt.put(element, 1);
            }
        }
        
        for(int element: c) {
            if(elementCunt.containsKey(element)) {
                elementCunt.put(element, elementCunt.get(element) + 1);
            } else {
                elementCunt.put(element, 1);
            }
        }
        
        Iterator<Integer> itr = elementCunt.keySet().iterator();
        
        ArrayList<Integer> commonElements = new ArrayList<>();
        
        while(itr.hasNext()) {
            int key = itr.next();
            if(elementCunt.get(key) == 3) {
                commonElements.add(key);
            }
        }
        
        return commonElements;
    }
-1
Shridutt Kothari 14 जिंदा 2022, 18:24
यदि मान लें कि सरणियों में अद्वितीय तत्व हैं, तो उनके पास सामान्य कैसे हो सकते हैं?
 – 
Sharon Ben Asher
14 जिंदा 2022, 18:23
यह मानते हुए कि प्रत्येक सरणी में अद्वितीय तत्व हैं
 – 
Shridutt Kothari
14 जिंदा 2022, 18:23