c# - 返回重复成员C#的最长子数组

我正在学习C＃，并尝试解决以下问题：
返回重复成员的最长子数组，例如如果数组是{1,2,2,3,4,4,4}，我应该返回{4,4,4}。我试图这样做，但是它返回第一个子数组，而不是最长的。到目前为止，我对C＃的了解：


循环
有条件的
数组


有任何想法吗 ？

编辑：到目前为止我的代码
编辑：是的，我确实了解多维数组

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Sequence
{
class Sequence
{
    static void Main(string[] args)
    {
        Console.Write("Enter size:");
        int size1 = int.Parse(Console.ReadLine());
        int[] array1 = new int[size1];
        for (int i = 0; i <= size1-1; i++)
        {
            Console.Write ("Ënter Number:");
            array1[i]=Int32.Parse(Console.ReadLine());
        }
        int bestLenght = 0;
        int bestStart = 0;
        int lenght = 0;
        int start=0;
        for (int i = 0; i < size1 - 2; i++)
        {
            if (i == 0 && array1[i] == array1[i + 1])
            {
                start = 0;
                lenght = 2;
                if (bestLenght < lenght)
                {
                    bestLenght = lenght;
                    bestStart = 0;
                }
            }
            else if (i != 0 && lenght != 0 && array1[i] == array1[i - 1] && array1[i + 1]   ==              array1[i])
            {
                lenght++;
                if (bestLenght < lenght)
                {
                    bestLenght = lenght;
                    bestStart = start;
                }
            }
            else if (i != 0 && array1[i - 1] != array1[i] && array1[i] == array1[i + 1])
            {
                start = i;
                lenght = 2;
                if (bestLenght < lenght)
                {
                    bestLenght = lenght;
                    bestStart = start;
                }

            }
            else
            {
                lenght = 0;
            }


        }
        Console.WriteLine(bestLenght);



    }
}

}

我正在尝试仅返回最长数组的长度

最佳答案

编辑：您的代码的问题是最长的列表是最后一个子列表时，它不处理边缘情况

更改

Console.WriteLine(bestLenght);

阅读

if (lenght > bestLenght) {
  bestLenght=lenght;
  bestStart=start;
}
Console.WriteLine(bestLenght);

或者

您可以使用linq Agregate做到这一点

var x= new[] {1,2,2,3,4,4,4};
var y=x.Aggregate(Tuple.Create(new List<int>(),new List<int>()),
(a,b) =>{
   if (a.Item2.Count()>0 && a.Item2[0] != b) {
     if (a.Item2.Count>a.Item1.Count()) {
       a=Tuple.Create(a.Item2,new List<int>());
     }
     a.Item2.Clear();
   }
   a.Item2.Add(b);
   return a;
},a=>(a.Item2.Count() > a.Item1.Count()) ? a.Item2 : a.Item1);

这实际上是使用元组遍历集合以存储2个列表，Item1表示最长的先前序列，Item2表示当前序列。

对于每个项目，如果当前序列不为空并且第一项不同，那么我们在新的子列表中，因此请检查最后一个序列的长度，如果更长的时间超过了先前的最大值，我们将替换先前的最大值，否则只需清除列表即可。

聚合的最后一部分检查两个列表中哪个更长（好像最长子集合是最后一个Item1长度检查不会发生）。

可以将此代码转换为通用函数，以处理以下任何类型。

IEnumerable<T> LongestSublist<T>(IEnumerable<T> source) {
return source.Aggregate(Tuple.Create(new List<T>(),new List<T>()),
    (a,b) =>{
       if (a.Item2.Count()>0 && a.Item2[0] != b) {
         if (a.Item2.Count>a.Item1.Count()) {
           a=Tuple.Create(a.Item2,new List<T>());
         }
         a.Item2.Clear();
       }
       a.Item2.Add(b);
       return a;
    },a=>(a.Item2.Count() > a.Item1.Count()) ? a.Item2 : a.Item1);

甚至作为扩展功能

public static IEnumerable<T> LongestSublist<T>(this IEnumerable<T> source) {
return source.Aggregate(Tuple.Create(new List<T>(),new List<T>()),
    (a,b) =>{
       if (a.Item2.Count()>0 && a.Item2[0] != b) {
         if (a.Item2.Count>a.Item1.Count()) {
           a=Tuple.Create(a.Item2,new List<T>());
         }
         a.Item2.Clear();
       }
       a.Item2.Add(b);
       return a;
    },a=>(a.Item2.Count() > a.Item1.Count()) ? a.Item2 : a.Item1);

允许你做

var longest = new [] {1,2,2,3,4,4,4} .LongestSubList（）;