लंबे अनुक्रम में एक अनुक्रम ढूँढना

Question

मुझे अन्य बड़े अनुक्रम में अनुक्रम खोजने की आवश्यकता है, उदाहरण के लिए, {1,3,2,3}{1,3,2,3,4,3} और {5,1,3,2,3} में मौजूद है। क्या IEnumerable या कुछ और के साथ इसे जल्दी करने का कोई तरीका है?

Answer 1

आप शुरू करने के लिए इस तरह कुछ कोशिश कर सकते हैं। ,

if (String.Join(",", numericList.ConvertAll<string>(x => x.ToString()).ToArray()) 
{ 
    //get sequence 
} 

Answer 2

इस विधि एक माता पिता के अनुक्रम में किसी परिणाम मिलेगा किसी भी प्रकार Equals() के माध्यम से तुलना की जा सकती है कि: एक बार जब आप एक स्ट्रिंग के लिए इस सूची परिवर्तित कर दिया है, तो आप में प्रयोग करने से अनुक्रम पा सकते हैं

public static bool ContainsSubequence<T>(this IEnumerable<T> parent, IEnumerable<T> target) 
{ 
    bool foundOneMatch = false; 
    using (IEnumerator<T> parentEnum = parent.GetEnumerator()) 
    { 
     using (IEnumerator<T> targetEnum = target.GetEnumerator()) 
     { 
      // Get the first target instance; empty sequences are trivially contained 
      if (!targetEnum.MoveNext()) 
       return true; 

      while (parentEnum.MoveNext()) 
      { 
       if (targetEnum.Current.Equals(parentEnum.Current)) 
       { 
        // Match, so move the target enum forward 
        foundOneMatch = true; 
        if (!targetEnum.MoveNext()) 
        { 
         // We went through the entire target, so we have a match 
         return true; 
        } 
       } 
       else if (foundOneMatch) 
       { 
        return false; 
       } 
      } 

      return false; 
     } 
    } 
} 

आप इस तरह इसका इस्तेमाल कर सकते हैं: यह मान लिया गया है

bool match = new[] {1, 2, 3}.ContainsSubsequence(new[] {1, 2}); // match == true 
match = new[] {1, 2, 3}.ContainsSubsequence(new[] {1, 3}); // match == false 

ध्यान दें कि लक्ष्य अनुक्रम कोई null तत्व है।

अद्यतन: upvotes, हर किसी के लिए धन्यवाद, लेकिन इसके बाद के संस्करण कोड में वास्तव में है एक बग! यदि कोई आंशिक मिलान मिलता है, लेकिन फिर पूर्ण मिलान में नहीं आता है, तो प्रक्रिया रीसेट करने के बजाय समाप्त हो गई है (जिसे {1, 2, 1, 2, 3}.ContainsSubsequence({1, 2, 3}) जैसे किसी पर लागू होने पर स्पष्ट रूप से गलत किया गया है)।

ऊपर कोड परिणाम को के अधिक सामान्य परिभाषा के लिए वास्तव में अच्छी तरह से काम करता है (अर्थात contiguousness की आवश्यकता नहीं है), लेकिन आदेश को रीसेट को संभालने के लिए (जो सबसे IEnumerators का समर्थन नहीं करते) लक्ष्य अनुक्रम सामने प्रगणित किए जाने की आवश्यकता है। यही कारण है कि निम्नलिखित कोड की ओर जाता है:

public static bool ContainsSubequence<T>(this IEnumerable<T> parent, IEnumerable<T> target) 
{ 
    bool foundOneMatch = false; 
    var enumeratedTarget = target.ToList(); 
    int enumPos = 0; 

    using (IEnumerator<T> parentEnum = parent.GetEnumerator()) 
    { 
     while (parentEnum.MoveNext()) 
     { 
      if (enumeratedTarget[enumPos].Equals(parentEnum.Current)) 
      { 
       // Match, so move the target enum forward 
       foundOneMatch = true; 
       if (enumPos == enumeratedTarget.Count - 1) 
       { 
        // We went through the entire target, so we have a match 
        return true; 
       } 

       enumPos++; 
      } 
      else if (foundOneMatch) 
      { 
       foundOneMatch = false; 
       enumPos = 0; 

       if (enumeratedTarget[enumPos].Equals(parentEnum.Current)) 
       { 
        foundOneMatch = true; 
        enumPos++; 
       } 
      } 
     } 

     return false; 
    } 
} 

इस कोड को किसी भी कीड़े नहीं है, लेकिन बड़े (या अनंत) दृश्यों के लिए अच्छी तरह से काम नहीं करेगा।

Answer 3

@ dlev के लिए इसी तरह की है, लेकिन यह भी संभालती {1,1,1,2}.ContainsSubsequence({1,1,2})

public static bool ContainsSubsequence<T>(this IEnumerable<T> parent, IEnumerable<T> target) 
{ 
    var pattern = target.ToArray(); 
    var source = new LinkedList<T>(); 
    foreach (var element in parent) 
    { 
     source.AddLast(element); 
     if(source.Count == pattern.Length) 
     { 
      if(source.SequenceEqual(pattern)) 
       return true; 
      source.RemoveFirst(); 
     } 
    } 
    return false; 
} 

Answer 4

यह मैं

var a1 = new List<int> { 1, 2, 3, 4, 5 }; 
var a2 = new List<int> { 2, 3, 4 }; 

int index = -1; 
bool res = a2.All(
    x => index != -1 ? (++index == a1.IndexOf(x)) : ((index = a1.IndexOf(x)) != -1) 
); 

Answer 5

यह फ़ंक्शन जांच के लिए काम करता है कि क्या सूची parent कुछ LINQ का उपयोग कर सूची target शामिल हैं:

public static bool ContainsSequence<T>(this List<T> parent, List<T> target) 
    { 
     for (int fromElement = parent.IndexOf(target.First()); 
      (fromElement != -1) && (fromElement <= parent.Count - target.Count); 
      fromElement = parent.FindIndex(fromElement + 1, p => p.Equals(target.First()))) 
     { 
      var comparedSequence = parent.Skip(fromElement).Take(target.Count); 
      if (comparedSequence.SequenceEqual(target)) return true; 
     } 
     return false; 
    }  

Answer 6

यदि आप सरल serializable हैंडलिंग कर रहे हैं प्रकार, आपको लगता है कि काफी आसानी से कर अगर आप स्ट्रिंग के लिए सरणियों में बदल सकते हैं:

public static bool ContainsList<T>(this List<T> containingList, List<T> containedList) 
{ 
    string strContaining = "," + string.Join(",", containingList) + ","; 
    string strContained = "," + string.Join(",", containedList) + ","; 
    return strContaining.Contains(strContained); 
} 

नोट एक विस्तार विधि है कि, तो आप इसे पसंद कॉल करने के लिए सक्षम हो जाएगा:

if (bigList.ContainsList(smallList)) 
{ 
    ... 
}