Проверьте, имеет ли список все элементы в последовательном порядке [дублировать]

Если вы обрабатываете простые сериализуемые типы, вы можете сделать это довольно легко, если вы преобразуете массивы в строку:

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))
{
    ...
}

Этот метод найдет подпоследовательность в родительской последовательности любого типа, который можно сравнить с помощью 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})).

Вышеприведенный код работает очень хорошо для более общего определения подпоследовательности (т. е. смежность не требуется), но для обработки сброса (который большинство 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;
    }
}

Этот код не имеет ошибок, но не будет работать хорошо для больших (или бесконечных) последовательностей.

Вы можете попробовать что-то подобное, чтобы начать. После преобразования этого списка в строку вы можете найти последовательность, используя подстроку:

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

Это работает для меня

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)
);

Подобно @ 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;
}

Эта функция проверяет, содержит ли List parent Список target, используя некоторые LINQ:

    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;
    }