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

我需要找出列表中是否有3个相同的项目

它应该使用重写的

.Equals（）

方法比较元素。我试过很多方法，但都失败了。 它是否返回布尔值或项目本身并不重要。 每次添加新项后都会调用该函数，所以只要它检测到列表中有3个相同项时的点，就无所谓了

这可能是一件小事，但我对Linq的了解非常薄弱。

试试看

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

试一试

static void Main（字符串[]args）
{
列表列=新列表（）；
第2栏添加（“a”）；
控制台写入线（Has_3（col））；
Console.ReadKey（）；
第2栏添加（“a”）；
控制台写入线（Has_3（col））；
Console.ReadKey（）；
第2栏添加（“a”）；
控制台写入线（Has_3（col））；
Console.ReadKey（）；
第2栏添加（“a”）；
控制台写入线（Has_3（col））；
Console.ReadKey（）；
}
静态布尔值有_3（列表列）
{
返回列计数（x=>x==“a”）。等于（3）；
}

静态void Main（字符串[]args）
{
列表列=新列表（）；
第2栏添加（“a”）；
控制台写入线（Has_3（col））；
Console.ReadKey（）；
第2栏添加（“a”）；
控制台写入线（Has_3（col））；
Console.ReadKey（）；
第2栏添加（“a”）；
控制台写入线（Has_3（col））；
Console.ReadKey（）；
第2栏添加（“a”）；
控制台写入线（Has_3（col））；
Console.ReadKey（）；
}
静态布尔值有_3（列表列）
{
返回列计数（x=>x==“a”）。等于（3）；
}

我的第一个想法是，这可能可以通过使用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);

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

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

var ints=新列表（新[]{1,2,3,4,5,6,2,2}）；
var first=ints.GroupBy（n=>n）
.Select（g=>new{g.Key，Count=g.Count（）}）
.第一（g=>g.计数>=3）；
WriteLine（“找到{1}的{0}个实例”，first.Count，first.Key）；

---

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

我的第一个想法是，这可能可以通过使用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);

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

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

var ints=新列表（新[]{1,2,3,4,5,6,2,2}）；
var first=ints.GroupBy（n=>n）
.Select（g=>new{g.Key，Count=g.Count（）}）
.第一（g=>g.计数>=3）；
WriteLine（“找到{1}的{0}个实例”，first.Count，first.Key）；

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

这里有一个扩展：

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

public static bool ContainsNTimes（这个IEnumerable序列，T元素，int duplicateCount）
{
if（元素==null）
抛出新的ArgumentNullException（“元素”）；
如果（！sequence.Any（））
抛出新ArgumentException（“序列必须包含元素”、“序列”）；
如果（重复计数<1）
抛出新ArgumentException（“DuplicateCount必须大于0”，“DuplicateCount”）；
bool containsNTimes=序列。其中（i=>i.Equals（元素））
.采取（重复计数）
.Count（）==重复计数；
返回次数；
}

用法：

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)

var list=newlist（）{1,2,2,3,4,3,3}；
//列表包含2个，共3次？
bool contains23次=list.ContainsNTimes（2,3）；
//列表中的任何元素包含3次（或更多）？
bool anyContains3Times=list.Any（i=>list.containsNTTimes（i，3））；
Console.WriteLine（“列表包含2，共3次？”+包含23次）；//假的
Console.WriteLine（“列表中的任何元素包含3次（或更多）？“+anycontains3次）；//正确（3）

演示：

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

这里是一个扩展：

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

public static bool ContainsNTimes（这个IEnumerable序列，T元素，int duplicateCount）
{
if（元素==null）
抛出新的ArgumentNullException（“元素”）；
如果（！sequence.Any（））
抛出新ArgumentException（“序列必须包含元素”、“序列”）；
如果（重复计数<1）
抛出新ArgumentException（“DuplicateCount必须大于0”，“DuplicateCount”）；
bool containsNTimes=序列。其中（i=>i.Equals（元素））
.采取（重复计数）
.Count（）==重复计数；
返回次数；
}

用法：

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)

var list=newlist（）{1,2,2,3,4,3,3}；
//列表包含2个，共3次？
bool contains23次=list.ContainsNTimes（2,3）；
//列表中的任何元素包含3次（或更多）？
bool anyContains3Times=list.Any（i=>list.containsNTTimes（i，3））；
Console.WriteLine（“列表包含2，共3次？”+包含23次）；//假的
Console.WriteLine（“列表中的任何元素包含3次（或更多）？“+anycontains3次）；//正确（3）

演示：

---

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

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

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

private bool ContainsTriple（IList项）{
return items.GroupBy（i=>i）.Any（l=>l.Count（）==3）；
}

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

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

private bool ContainsTriple（IList项）{
return items.GroupBy（i=>i）.Any（l=>l.Count（）==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;
        }
    }
}

静态类EnumerableExtensions
{
公共静态IEnumerable FirstRepeatedTimes（此IEnumerable序列，int阈值）
{
如果（！sequence.Any（））
抛出新的ArgumentException（“Sequ