Question

我需要查看列表中是否有3个相同的项目。

应使用重写.Equals()方法来比较元素。我尝试了很多方法但都失败了。如果它返回bool值或项本身并不重要。每次添加新项目后都会调用该函数，因此只要它检测到列表中有3个相同项目时的点就无关紧要。

这可能是微不足道的，但我对Linq的了解非常薄弱。

Answer 1

尝试

return
    collection.Any(any => collection.Count(item => item.Equals(any)) == 3);

Answer 2

通过单独对项目进行分组并评估是否有任何组正好包含三个项目，您将收到预期的结果。

private bool ContainsTriple<T>(IList<T> items){
    return items.GroupBy(i => i).Any(l => l.Count() == 3);
}

Answer 3

更好地表达我的理念：

static class EnumerableExtensions
{
    public static IEnumerable<T> FirstRepeatedTimes<T>(this IEnumerable<T> sequence, int threshold)
    {
        if (!sequence.Any())
            throw new ArgumentException("Sequence must contain elements", "sequence");
        if (threshold < 2)
            throw new ArgumentException("DuplicateCount must be greater than 1", "threshold");

        return FirstRepeatedTimesImpl(sequence, threshold);
    }

    static IEnumerable<T> FirstRepeatedTimesImpl<T>(this IEnumerable<T> sequence, int threshold)
    {
        var map = new Dictionary<T, int>();
        foreach(var e in sequence)
        {
            if (!map.ContainsKey(e))
                map.Add(e, 0);
            if (map[e] + 1 == threshold)
            {
                yield return e;
                yield break;
            }
            map[e] = map[e] + 1;
        }
    }
}

你会像这样使用它：

var list = new List<int>() { 1,2,2,3,4,3,3 };

// list contains anything for 3 times?
var found = list.FirstRepeatedTimes(3).Any();

它可能会消耗更多内存，但它最多只列举一次列表。这是Linq吗？我写它的方式，它只产生1个元素（第一个找到），或者没有元素，如果你愿意，你可以进一步构成它。您可以使用FirstOfDefault()代替Any()，然后使用找到的元素或0（如果我们处理引用类型，则为null）。这样你就有了选择。

这只是另一种看待它的方式。

Answer 4

    static void Main(string[] args)
    {
        List<string> col = new List<string>();

        col.Add("a");
        Console.WriteLine(Has_3(col));
        Console.ReadKey();
        col.Add("a");
        Console.WriteLine(Has_3(col));
        Console.ReadKey();
        col.Add("a");
        Console.WriteLine(Has_3(col));
        Console.ReadKey(); 
        col.Add("a");
        Console.WriteLine(Has_3(col));
        Console.ReadKey();
    }

    static bool Has_3(List<string> col)
    {
        return col.Count(x => x == "a").Equals(3);
    }

Answer 5

我的第一个想法是，这可能是通过使用Group（）方法完成的，如下所示：

var ints = new List<int>(new[] { 1, 2, 3, 4, 5, 6, 2, 2 });

var first = ints.GroupBy(n => n)
    .Select(g => new { g.Key, Count = g.Count() })
    .First(g => g.Count >= 3);

Console.WriteLine("Found {0} instances of {1}", first.Count, first.Key);

此代码段检查同一项目中的3个或更多项目，并选择符合条件的第一个项目，您可能需要更改此项目。并使其适应您的特定对象而不是整数。

Answer 6

这是一个扩展名：

public static bool ContainsNTimes<T>(this IEnumerable<T> sequence, T element, int duplicateCount)
{
    if (element == null)
        throw new ArgumentNullException("element");
    if (!sequence.Any())
        throw new ArgumentException("Sequence must contain elements", "sequence");
    if (duplicateCount < 1)
         throw new ArgumentException("DuplicateCount must be greater 0", "duplicateCount");

    bool containsNTimes = sequence.Where(i => i.Equals(element))
                            .Take(duplicateCount)
                            .Count() == duplicateCount;
    return containsNTimes;
}

用法：

var list = new List<int>() { 1,2,2,3,4,3,3 };

// list contains 2 for 3 times?
bool contains2ThreeTimes = list.ContainsNTimes(2, 3);

// any element in the list iscontained 3 times (or more)?
bool anyContains3Times = list.Any(i => list.ContainsNTimes(i, 3));

Console.WriteLine("List contains 2 for 3 times? " + contains2ThreeTimes); // false
Console.WriteLine("Any element in the list is contained 3 times (or more)? " + anyContains3Times); // true (3)

演示：http://ideone.com/Ozk9v

因为它使用延迟执行，所以应该非常有效。它列举了序列，直到找到n个项目。

从列表中选择3个相同的项目

6 个答案: