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



    }
}

}

---

目前，我只是想返回最长数组的长度，基本上你需要做的就是检查前一个数是否与当前数相同，并相应地增加一个计数器

精确地说，在数组中循环，将值复制到一个新数组，当它循环时，仅当计数器值较高时才复制

---

希望这有助于检查前一个数字是否与当前数字相同，并相应地增加一个计数器

精确地说，在数组中循环，将值复制到一个新数组，当它循环时，仅当计数器值较高时才复制

---

希望这有帮助

您可以选择以下几种方法：

最简单的就是

查找列表中每个整数的所有匹配项 选择出现次数最多的一个。 使用Linq，如下所示：

var list = new List<int>{1,2,2,3,4,4,4} ;   
var result = list.GroupBy(r => r).OrderByDescending(grp => grp.Count()).First();

按数字分组，一组中有1个，另一组中有2个，。。。等等

b按每个元素的数量降序排列组，因此在我们的例子中，4将是第一个，因为4的组比任何其他组多3个元素

c获取列表中的第一个元素

---

您可以执行以下几个选项：

最简单的就是

查找列表中每个整数的所有匹配项 选择出现次数最多的一个。 使用Linq，如下所示：

var list = new List<int>{1,2,2,3,4,4,4} ;   
var result = list.GroupBy(r => r).OrderByDescending(grp => grp.Count()).First();

按数字分组，一组中有1个，另一组中有2个，。。。等等

b按每个元素的数量降序排列组，因此在我们的例子中，4将是第一个，因为4的组比任何其他组多3个元素

c获取列表中的第一个元素

---

一种非常迭代的方法：

循环遍历数组中的每个项。 如果当前项与上一项相同，则将currentSeriesLength增加1。 如果没有，请对照longestSeriesLength检查。如果较大，则将当前索引存储在LongestSeriesSend中，并将当前索引-currentSeriesLength存储在longestSeriesStart中。 将currentSeriesLength值保存在longestSeriesLength中。 将currentSeriesLength设置回1。 最长的系列将是介于longestSeriesStart和LongestSeriesSend之间的系列。

---

将其转换为代码对您来说是一个很好的练习。

一种非常迭代的方法，用文字表示：

循环遍历数组中的每个项。 如果当前项与上一项相同，则将currentSeriesLength增加1。 如果没有，请对照longestSeriesLength检查。如果较大，则将当前索引存储在LongestSeriesSend中，并将当前索引-currentSeriesLength存储在longestSeriesStart中。 将currentSeriesLength值保存在longestSeriesLength中。 将currentSeriesLength设置回1。 最长的系列将是介于longestSeriesStart和LongestSeriesSend之间的系列。

---

将其转换为代码将是一个很好的练习。

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

改变

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

甚至作为一个扩展函数

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=新的[]{1,2,2,3,4,4}.最长子列表

EDIT：代码的问题在于，当最长列表是最后一个子列表时，它不处理边缘情况

改变

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

甚至作为一个扩展函数

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=新的[]{1,2,2,3,4,4}.最长子列表

所以，请展示一些您迄今为止尝试过的代码亲爱的回答者，作为一个初学者，请避免使用LINQ。您知道多维数组吗？如果我们给您一个解决方案，您将无法学习。如果你想让我们指出你的错误，就拿出你的代码。@BigYellowCactus:我知道，甚至我也可以给他，但我们的动机应该是增加他的逻辑性。阅读dystroy评论。所以请展示一些你迄今为止尝试过的代码亲爱的回答者，作为一个初学者，请避免使用LINQ。你知道多维数组吗？如果我们给你一个解决方案，你将无法学习。如果你想让我们指出你的错误，就拿出你的代码。@BigYellowCactus:我知道，甚至我也可以给他，但我们的动机应该是增加他的逻辑性。阅读Destroy注释。重复的数字可能相邻，也可能不相邻我们第一次只复制重复的数字重复的数字可能相邻，也可能不相邻我们第一次只复制重复的数字如果列表=新列表{1,2,2,1

---

，1,3,1,1,4,4}？@BobVale：它按数字分组，不关心列表中元素的顺序。OP说重复成员因此顺序很重要，你的代码将返回{1,1,1,1,1}而不是{4,4,4}@BobVale：理解你的观点，但我认为OP的意思是我回答的问题。只是用不太清楚的语言写了这个问题。。我考虑他所举的例子。实际上，我必须仔细阅读OP的代码，因为它看起来检查连续的序列…如果列表=新的列表{1，2，2，1，3，1，1，4，4，4 }？@ BobVale:它按数字分组，并且不关心List.OP中的元素顺序。{1,1,1,1,1}而不是{4,4,4}@ BobVale：你的观点，但我认为OP的意思是我回答的问题。只是用不太清楚的语言写这个问题。我认为他举的例子。真的，我一定是误读了OP的代码，因为它似乎检查了连续的序列……我学会了这样的方式…深端。人们应该学习LINQ尽快摆脱它。很多循环和嵌套的如果！对…必须…如果你觉得有任何有用的链接，请与我分享。我知道有很多链接suggestion@Peru尝试一下这是一个很好的开始，你甚至可以得到一个很好的简单IDE，我用它来编写大多数答案！我是这样学的…Deep end。人们应该尽快学习Linq，它可以摆脱如此多的循环和嵌套的ifs！Ri好的…如果你觉得有什么有用的链接，我必须…和我分享。我知道有很多链接suggestion@Peru尝试一下这是一个很好的开始，你甚至可以得到一个很好的简单IDE，我用它来编写大多数答案！