2

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



    }
}

}

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

4

4 回答 4

2

一个非常迭代的方法：

  • 循环遍历数组中的每个项目。
  • 如果当前项与前一项相同，则加currentSeriesLength1。
  • 如果不是，则对照longestSeriesLength. 如果它更大，则存储current indexinlongestSeriesEnd和current index - currentSeriesLengthin longestSeriesStart。
  • currentSeriesLength将值保存在longestSeriesLength.
  • 将你的currentSeriesLength背部设置为 1。
  • 您最长的系列将是 和 之间的longestSeriesStart系列longestSeriesEnd。

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

于 2012-08-16T09:32:38.930 回答
1

你基本上必须做的是检查以前的数字是否与当前的数字相同并相应地增加一个计数器。

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

希望这可以帮助

于 2012-08-16T09:24:06.327 回答
1

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

改变

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 的最后一部分检查两个列表中的哪个更长（好像最长的子集合是最后一个 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 long= new[] {1,2,2,3,4,4,4}.LongestSubList();

于 2012-08-16T09:42:20.473 回答
0

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

  1. 最简单的方法是

    • 查找列表中每个整数的所有出现
    • 选择出现次数最多的那个。

  2. 使用 a 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，在另一组中获得 s 2，......等等

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

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

于 2012-08-16T09:30:40.207 回答