विपरीत () के विपरीत

Question

इंटर्सेक्ट का उपयोग दो संग्रह के बीच मैच खोजने के लिए किया जा सकता है, जैसे:

// Assign two arrays.
int[] array1 = { 1, 2, 3 };
int[] array2 = { 2, 3, 4 };
// Call Intersect extension method.
var intersect = array1.Intersect(array2);
// Write intersection to screen.
foreach (int value in intersect)
{
    Console.WriteLine(value); // Output: 2, 3
}

हालाँकि मैं जो हासिल करना चाहता हूं वह विपरीत है, मैं एक संग्रह की उन वस्तुओं को सूचीबद्ध करना चाहता हूं जो दूसरे से गायब हैं :

// Assign two arrays.
int[] array1 = { 1, 2, 3 };
int[] array2 = { 2, 3, 4 };
// Call "NonIntersect" extension method.
var intersect = array1.NonIntersect(array2); // I've made up the NonIntersect method
// Write intersection to screen.
foreach (int value in intersect)
{
    Console.WriteLine(value); // Output: 4
}

Comments

कृपया पुष्टि करें कि यदि आप आउटपुट के रूप में 4 चाहते हैं, या 1 और 4

— Bryvind Bråthen

@ ऑयविंड-नॉबलोच-ब्राथेन हां, मैं केवल 4 को पसंद करूंगा

— पीटर

एक साइड नोट के रूप में, इस प्रकार के सेट को एक सममित अंतर कहा जाता है ।

— माइक टी

तकनीकी रूप से, एक सममित अंतर के परिणामस्वरूप [1, 4] होगा। चूंकि पीटर array2 में ऐसे तत्वों को चाहते थे जो array1 (यानी, 4) में नहीं हैं,

— इसीलिए

Answer 1

जैसा कि कहा गया है, यदि आप परिणाम के रूप में 4 प्राप्त करना चाहते हैं, तो आप ऐसा कर सकते हैं:

var nonintersect = array2.Except(array1);

यदि आप वास्तविक गैर-चौराहे (भी 1 और 4 दोनों) चाहते हैं, तो यह चाल होनी चाहिए:

var nonintersect = array1.Except(array2).Union( array2.Except(array1));

यह सबसे अच्छा समाधान नहीं होगा, लेकिन छोटी सूचियों के लिए यह ठीक काम करना चाहिए।

Comments

एक बेहतर प्रदर्शन समाधान क्या होगा? धन्यवाद!

— शनाबुस

आप शायद इसे छोरों के लिए दो नेस्टेड का उपयोग करके तेजी से कर सकते हैं, लेकिन कोड इस तरह से अधिक गंदा होगा। इस में भी पठनीयता की गिनती करते हुए, मैं स्पष्ट रूप से इस संस्करण का उपयोग करूंगा क्योंकि यह पढ़ना बहुत आसान है।

— 12yvind Bråthen

जोड़ने के लिए एक साइडलाइन बिंदु, यदि आपके पास है: int [] इससे पहले = {1, 2, 3}; int [] के बाद = {2, 3, 3, 4}; और आप 'के बाद' से पहले 'के बाद' में जोड़ा गया है क्या खोजने के लिए छोड़कर का उपयोग करने की कोशिश: var diff = after.Except (इससे पहले); 'diff' में 4 होता है, न कि 3,4। यानी नकल करने वाले तत्वों के लिए आप अप्रत्याशित परिणाम दे रहे हैं

— पॉल राइलैंड

क्या यह बेहतर प्रदर्शन करेगा? array1.AddRange (array2.Except (array1));

— LBW

Answer 2

आप उपयोग कर सकते हैं

a.Except(b).Union(b.Except(a));

या आप उपयोग कर सकते हैं

var difference = new HashSet(a);
difference.SymmetricExceptWith(b);

Comments

दिलचस्प SymmetricExceptWith () का उपयोग, मुझे लगता है कि दृष्टिकोण के बारे में सोचा नहीं होगा

— पीटर ब्रिजर

SymmetricExceptWithशायद मेरी पसंदीदा विधि है।

— ऐश क्लार्क

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

— दान

अच्छा होगा यदि BCL के पास इसके लिए Linq एक्सटेंशन विधि हो। यह एक चूक की तरह लगता है।

— ड्रू नॉक्स

किसी ने SymmetricExceptWith बेंचमार्क किया और इसे बहुत तेज़ पाया: skylark-software.com/2011/07/linq-and-set-notation.html

— कॉलिन

Answer 3

यह कोड प्रत्येक अनुक्रम को केवल एक बार एन्यूमरेट करता Select(x => x)है और परिणाम को छिपाने के लिए एक साफ लाइनक-स्टाइल एक्सटेंशन विधि प्राप्त करने के लिए उपयोग करता है। चूंकि यह HashSet<T>अपने रनटाइम का उपयोग करता है, O(n + m)अगर हैश अच्छी तरह से वितरित किया जाता है। किसी भी सूची में डुप्लिकेट तत्वों को छोड़ दिया जाता है।

public static IEnumerable<T> SymmetricExcept<T>(this IEnumerable<T> seq1,
    IEnumerable<T> seq2)
{
    HashSet<T> hashSet = new HashSet<T>(seq1);
    hashSet.SymmetricExceptWith(seq2);
    return hashSet.Select(x => x);
}

Answer 4

मुझे लगता है कि आप देख सकते हैं Except:

सिवाय ऑपरेटर के दो दृश्यों के बीच सेट अंतर पैदा करता है। यह केवल पहले अनुक्रम में तत्व लौटाएगा जो दूसरे में नहीं दिखाई देगा। आप वैकल्पिक रूप से अपनी समानता की तुलना समारोह प्रदान कर सकते हैं।

की जाँच करें इस लिंक , इस लिंक , या गूगल, अधिक जानकारी के लिए।

Answer 5

मुझे 100% यकीन नहीं है कि आपका नॉन इंसेक्ट विधि क्या करने वाला है (सेट थ्योरी के बारे में) - क्या यह
B \ A है (B का वह सब कुछ जो A में नहीं होता है)?
यदि हाँ, तो आपको अपवर्जन ऑपरेशन (B.Except (A)) का उपयोग करने में सक्षम होना चाहिए।

Comments

सेट का अंतर == A∪B \ A --B

— amuliar

Answer 6

/// <summary>
/// Given two list, compare and extract differences
/// http://stackoverflow.com/questions/5620266/the-opposite-of-intersect
/// </summary>
public class CompareList
{
    /// <summary>
    /// Returns list of items that are in initial but not in final list.
    /// </summary>
    /// <param name="listA"></param>
    /// <param name="listB"></param>
    /// <returns></returns>
    public static IEnumerable<string> NonIntersect(
        List<string> initial, List<string> final)
    {
        //subtracts the content of initial from final
        //assumes that final.length < initial.length
        return initial.Except(final);
    }

    /// <summary>
    /// Returns the symmetric difference between the two list.
    /// http://en.wikipedia.org/wiki/Symmetric_difference
    /// </summary>
    /// <param name="initial"></param>
    /// <param name="final"></param>
    /// <returns></returns>
    public static IEnumerable<string> SymmetricDifference(
        List<string> initial, List<string> final)
    {
        IEnumerable<string> setA = NonIntersect(final, initial);
        IEnumerable<string> setB = NonIntersect(initial, final);
        // sum and return the two set.
        return setA.Concat(setB);
    }
}

Answer 7

array1.NonIntersect (array2);

Nonintersect ऐसे ऑपरेटर Linq में मौजूद नहीं है जो आपको करना चाहिए

सिवाय -> संघ -> को छोड़कर

a.except(b).union(b.Except(a));

Answer 8

string left = "411329_SOFT_MAC_GREEN";
string right= "SOFT_MAC_GREEN";

string[] l = left.Split('_');
string[] r = right.Split('_');

string[] distinctLeft = l.Distinct().ToArray();
string[] distinctRight = r.Distinct().ToArray();

var commonWord = l.Except(r, StringComparer.OrdinalIgnoreCase)
string result = String.Join("_",commonWord);
result = "411329"