जाँच करें कि क्या सूची <t> में कोई अन्य सूची है

Question

मेरे पास इस तरह के मापदंडों की एक सूची है:

public class parameter
{
    public string name {get; set;}
    public string paramtype {get; set;}
    public string source {get; set;}
}

IEnumerable<Parameter> parameters;

और तार की एक सरणी मैं इसके खिलाफ जांच करना चाहता हूं।

string[] myStrings = new string[] { "one", "two"};

मैं पैरामीटर सूची पर पुनरावृति करना चाहता हूं और जांचता हूं कि क्या स्रोत संपत्ति किसी भी मायस्ट्रीम सरणी के बराबर है। मैं नेस्टेड फॉर्च्यूनर के साथ ऐसा कर सकता हूं, लेकिन मैं यह सीखना चाहूंगा कि इसे अच्छे तरीके से कैसे किया जाए क्योंकि मैं लाइनक के साथ खेल रहा हूं और एनेमरेबल पर एक्सटेंशन के तरीकों को पसंद करता हूं जैसे कि आदि नेस्टेड नेचर्स को सिर्फ गलत लगता है। क्या ऐसा करने के लिए एक अधिक सुंदर पसंदीदा लाइनक / लैम्ब्डा / डेलेगेट तरीका है।

धन्यवाद

Answer 1

आप Any()इस चेक के लिए नेस्टेड का उपयोग कर सकते हैं जो किसी भी पर उपलब्ध है Enumerable:

bool hasMatch = myStrings.Any(x => parameters.Any(y => y.source == x));

बड़े संग्रह पर प्रदर्शन करने वाले तेज़ को प्रोजेक्ट parametersकरना होगा sourceऔर फिर उपयोग करना होगा Intersectजो HashSet<T>पहले दृष्टिकोण के लिए O (n ^ 2) के बजाय आंतरिक रूप से उपयोग करता है (आप दो नेस्टेड लूप के बराबर) आप O (n) में चेक कर सकते हैं:

bool hasMatch = parameters.Select(x => x.source)
                          .Intersect(myStrings)
                          .Any(); 

साइड कमेंट के रूप में भी आपको C # स्टाइल दिशा-निर्देशों के अनुरूप अपने क्लास के नाम और प्रॉपर्टी के नाम को बड़ा करना चाहिए।

Comments

धन्यवाद लगता है कि मैं क्या देख रहा हूँ इसे आज़माऊंगा। चीजों के कार्यात्मक पक्ष के साथ थोड़ा और अधिक खेलने की आवश्यकता है। वर्ग और गुणों को कैपिटलाइज़ करने के बारे में, मुझे लगता है कि ऊपर दिए गए उदाहरण को लिखने के समय मैं भूल गया था।

— gdp

O (n ^ 2) क्यों? क्या यह O (n * m) नहीं है क्योंकि हम दो वेरिएबल्स के बारे में बात कर रहे हैं और एक नहीं? चूंकि m (पैरामीटर्स) एक स्थिर हैं, यह O (n) के समान है। मैं यह नहीं देख सकता कि यहां कितना अंतरंग होना चाहिए? लेकिन सहमत, Intersect में तेज होने की क्षमता है, लेकिन गारंटी नहीं है।

— स्क्वाज़ 10

आप सही हैं कि यह O (n * m) होना चाहिए - m एक स्थिर नहीं है, हालांकि - यह सूचियों में से एक का आकार है, भले ही विशेष उदाहरण में यह "2" हो। यहां तक ​​कि निरंतर मान हालांकि अभ्यास में नगण्य नहीं हैं - सभी गैर-तुच्छ सूची की लंबाई के लिए Intersectइच्छाशक्ति तेज होगी - यदि सूची तुच्छ रूप से कम है, तो यह एक तरह से या किसी अन्य से कोई फर्क नहीं पड़ता है (उस स्थिति में प्रदर्शन शायद आपकी चिंता का सबब नहीं है) )

— BrokenGlass

आप उस सूची अनुक्रमणिका का पता कैसे लगा सकते हैं जहां स्थिति सही हो? मेरे पास वाक्यों के साथ एक सूची है। मेरे पास विशेष शब्दों के साथ एक सरणी है। मुझे सूची के अनुक्रमित चाहिए अगर वाक्य में सरणी से कम से कम एक शब्द है। @ ब्रोकनग्लास

— किरोशन

प्रदर्शन-वार, parameters.Any(x => myStrings.Contains(x.source));आपके पहले उदाहरण से बेहतर नहीं होगा ?

— Fluppe

Answer 2

यहां यह देखने के लिए एक नमूना है कि क्या किसी अन्य सूची में मिलान तत्व हैं

List<int> nums1 = new List<int> { 2, 4, 6, 8, 10 };
List<int> nums2 = new List<int> { 1, 3, 6, 9, 12};

if (nums1.Any(x => nums2.Any(y => y == x)))
{
    Console.WriteLine("There are equal elements");
}
else
{
    Console.WriteLine("No Match Found!");
}

Comments

ध्यान दें कि यदि शामिल सूचियाँ बड़ी हैं, तो यह Intersectदृष्टिकोण की तुलना में बहुत धीमी हो जाएगी , क्योंकि यह सूचियों के आकार में O (N * M) है। (हालांकि यह स्मृति में ओ (1) है।)

— जॉन स्कीट

Answer 3

यदि दोनों सूची बहुत बड़ी है और जब हम लैम्डा अभिव्यक्ति का उपयोग करते हैं तो इसे लाने में लंबा समय लगेगा। मापदंडों की सूची लाने के लिए इस मामले में लाइनक का उपयोग करना बेहतर है:

var items = (from x in parameters
                join y in myStrings on x.Source equals y
                select x)
            .ToList();