Linq список запросов содержит список с того же порядка

Question

Рассмотрим у нас есть эти три списка:

List<string> l1= new List<string>(){"A","B","C"}; 
    List<string> l2= new List<string>(){"A","C","B"}; 

    List<string> l3= new List<string>(){"B","C"}; 

Мне нужно LINQ запрос, который включает в себя сказать l1 l3, но l2 не делает.

Answer 1

К уважаем заказ и учитываем возможные повторяющиеся элементы, которые вы должны перечислять в последовательности, одним из способов сделать это было бы проверить каждую начальную позицию в нумерации источника, если другая последовательность начинается здесь, например. используя метод расширения:

public static bool ContainsSequence<T>(this IEnumerable<T> source, 
             IEnumerable<T> other) 
{ 
    int count = other.Count(); 

    while (source.Any()) 
    { 
     if (source.Take(count).SequenceEqual(other)) 
      return true; 
     source = source.Skip(1); 
    } 
    return false; 
} 

Обратите внимание, что это будет O (п), так худшем случае вы полностью перечислить other перечисления для каждого элемента в коллекции source.

Теперь вы можете сделать:

List<string> l1 = new List<string>() { "A", "B", "C" }; 
List<string> l2 = new List<string>() { "A", "C", "B" }; 
List<string> l3 = new List<string>() { "B", "C" }; 

bool l1ContainsL2 = l1.ContainsSequence(l2); //returns false 
bool l1ContainsL3 = l1.ContainsSequence(l3); //returns true 

Answer 2

должны быть просто:

l1.Intersect(l3).Except(l2); 

Примечания:
в зависимости от размеров L2 и L3 обратный порядок может быть более эффективным.
Учитывая ваши конкретные значения, ничего не будет возвращено, поскольку в l1 ничего нет, чего нет в l3.

Answer 3

Exclaimer: Как BrokenGlass указывает, что не ясно, что это означает, что список содержит другой. Здесь я допускаю, чтобы содержащая последовательность имела дополнительные элементы между элементами содержащейся последовательности.

Быстрый с точки зрения ввода, не слишком эффективно:

bool l1contains = l1.Where(x => l3.Contains(x)).ToList().SequenceEqual(l3); 
bool l2contains = l2.Where(x => l3.Contains(x)).ToList().SequenceEqual(l3); 

Более эффективно - так эффективно, как это может быть, работает в O (т + п), где т, п длины списков.

private static bool ContainsOrdered<T>(IEnumerable<T> containing, IEnumerable<T> contained) 
{ 
    var e1 = containing.GetEnumerator(); 
    var e2 = contained.GetEnumerator(); 
    bool hasmore1 = e1.MoveNext(); 
    bool hasmore2 = e2.MoveNext(); 

    while (hasmore1 && hasmore2) 
    { 
     while (hasmore1 && !e1.Current.Equals(e2.Current)) 
      hasmore1 = e1.MoveNext(); 
     if (hasmore1) // Currents are equal 
     { 
      hasmore1 = e1.MoveNext(); 
      hasmore2 = e2.MoveNext(); 
     } 
    } 

    return !hasmore2; 
} 

bool contains1 = ContainsOrdered(l1, l3); 
bool contains2 = ContainsOrdered(l2, l3);