Question

I’m learning C# and trying to solve the following problem:
Return the longest subarray of repeating members e.g. if the array is {1,2,2,3,4,4,4} I should return {4,4,4}. I tried to do this but it returns the first subarray and not the longest. What I know about C# so far:

• Loops
• Conditionals
• Arrays

Any ideas ?

EDIT : My code so far
EDIT : Yes I do know something about multidemensional arrays

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 I’m trying just to return the lenght of the longest array

Answer 1

EDIT: The problem with your code is it doesn’t deal with the edge case when the longest list is the last sublist

Change

Console.WriteLine(bestLenght); 

To Read

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

Alternatively

You can do this with a 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);

What this essentially does is iterate over the collection using a Tuple to store 2 lists, Item1 represents the longest previous sequence, Item2 represents the current sequence.

For each item, if the current sequence is not empty and the first item is different then we are in a new sublist so check the length of last sequence, if longer that previous max we replace previous max otherwise just clear the list.

The final part of the agregate checks which of the two lists are longer (as if the longests subcollection is the last the Item1 length check won’t have happened.

This code could be turned into a generic function to handle any type as follows.

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

or even as an extension function

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

allowing you to do

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