Question

我正在学习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);



    }
}

}

当然我正在努力恢复最长阵列的长度

Answer 1

语言中非常迭代的方法：

遍历数组中的每个项目。
如果当前项目与上一项目相同，请将currentSeriesLength增加1。
如果没有，请与longestSeriesLength核对。如果它更大，则将current index存储在longestSeriesEnd中，将current index - currentSeriesLength存储在longestSeriesStart中。
将currentSeriesLength值保存在longestSeriesLength中。
将currentSeriesLength设置回1.
您最长的系列将是longestSeriesStart和longestSeriesEnd之间的系列。

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

Answer 2

您基本上必须检查先前的数字是否与当前数字相同并相应地增加计数器。

准确“循环遍历数组，将值复制到新数组”并且只有在计数器值更高时才循环复制“

希望这有帮助

Answer 3

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

更改

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表示当前序列。

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

agregate的最后一部分检查两个列表中的哪一个更长（好像longests子集是最后一次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（）;

Answer 4

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

最简单的是
- 查找列表中所有出现的整数
- 选择最多出现的那个。
使用Linq，如下所示：
```
var list = new List<int>{1,2,2,3,4,4,4} ;   
var result = list.GroupBy(r => r).OrderByDescending(grp => grp.Count()).First();
```
a）按数字分组（您将在一个组中获得al 1，在其他组中获得2，...等等

b）按降序顺序中每个元素的数量对组进行排序，因此我们案例中的4将是第一个作为组的4有3个元素（比任何其他元素更多）

c）获取第一个元素（列表）

返回重复成员C＃的最长子阵列

4 个答案: