Welcome to the Lounge

Super Lloyd wrote:

Not as much as multiple exclamation points!!!!

Michael Martin wrote:

Say Forehead and Template.

Initialize list
Set index to 0
Iterate input values
  If test fails 
    Add a new List
    Increment index
  List [ index ].Add ( value )

private static System.Collections.Generic.List<System.Collections.Generic.List<int>>
Split
(
  System.Collections.Generic.IList<int> values
)
{
  System.Collections.Generic.List<System.Collections.Generic.List<int>> result =
    new System.Collections.Generic.List<System.Collections.Generic.List<int>>() ;

  if ( ( values != null ) && ( values.Count > 0 ) )
  {
    result.Add ( new System.Collections.Generic.List<int>() ) ;

    int l = 0 ;

    result [ l ].Add ( values [ 0 ] ) ;

    for ( int i = 1 ; i < values.Count ; i++ )
    {
      if ( values [ i ] - values [ i - 1 ] != 1 )
      {
        result.Add ( new System.Collections.Generic.List<int>() ) ;

        l++ ;
      }

      result [ l ].Add ( values [ i ] ) ;
    }
  }
      
  return ( result ) ;
}

function* consec(array) {
	let arr = array.splice(0);
	
	while (arr.length > 0) {
		let nextSeqIndex = arr.findIndex((v, i, a) => v != a[0] + i);
		
		if (nextSeqIndex === -1) return yield arr;
		
		yield arr.splice(0, nextSeqIndex);
	}
}

let array = [1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 22];

for (let sub of consec(array)) {
	console.log(sub);
}

using System;
using System.Collections.Generic;
using System.Linq;
					
public class Program
{
    public static void Main()
    {
        List<int> lstInput = new List<int>(){1,2,3,4,5,6,7,9,10,11,22};
		
        var aggResult = lstInput
	    .Aggregate(new 
            { 
                last = lstInput.First()-1, 
                result = new List<List<int>>(), 
                current = new List<int>()
            }, 
            (agg, n)=>
            {
                List<int> current = agg.current;

		if(n != agg.last + 1)
		{
		    agg.result.Add(current);
		    current = new List<int>();
		}

		current.Add(n);
				
                return new {last = n, result = agg.result, current};
	    });

        if(aggResult.current.Count > 0)
        {
            aggResult.result.Add(aggResult.current);
        }

        Console.Out.WriteLine(
            "{{{0}}}",
            string.Join(
                "},{", 
                aggResult.result.Select(o=>string.Join(",", o.Select(e=>e.ToString())))
            )
        );
    }
}

Staffan Bruun wrote:

Not sure it's any more elegant, though

private List<List<int>> GetList(List<int> Input)
{
    List<List<int>> Result = new List<List<int>>();
    List<int> CurrentList = new List<int>();

    CurrentList.Add(Input[0]);
    for (int i = 1; i < Input.Count; i++)
    {
        if (Input[i] == (Input[i - 1] + 1))
            CurrentList.Add(Input[i]);
        else
        {
            Result.Add(CurrentList);
            CurrentList = new List<int>();
            CurrentList.Add(Input[i]);
        }
    }

    if (CurrentList.Count != 0)
        Result.Add(CurrentList);

    return Result;
}

List<List<int>> GetSubLists(List<int> lstInput)
{
    List<List<int>> lstSubLists = new List<List<int>>();

    if (lstInput.Count == 0)
        return lstSubLists;

    int subListStartIndex = 0;
    for (int i = 1; i < lstInput.Count; ++i)
    {
        if (lstInput[i] - lstInput[i-1] != 1)
        {
            lstSubLists.Add(lstInput.GetRange(subListStartIndex, i - subListStartIndex));
            subListStartIndex = i;
        }
    }

    lstSubLists.Add(lstInput.GetRange(subListStartIndex, lstInput.Count - subListStartIndex));

    return lstSubLists;
}

typedef std::map<int*, int>::iterator it_type;
	int arrNum[] = { 1, 2, 6, 4, 5, 7, 8, 9, 2, 2, NULL };
	int* pBegin = (int*)&arrNum[0];
	int* pStart = pBegin;	int* pNext = pBegin +1;
	std::map<int*, int> _mapSeg;int nCounter = 0;
	_mapSeg[pBegin] = nCounter;

	while (NULL != *pBegin)
	{	_mapSeg[pStart] = nCounter++;
		if (*pBegin + 1 != *pNext && (*pBegin != *pNext))
		{   nCounter = 0;pStart = pNext;}
		++pBegin;++pNext;
	}

Ted,

I need a function that splits a list of integers into sublists, so that each sublist only contains runs of consecutive digits.

I know you're busy with all the extra items this week, but if you could get that for me today, that would be great.

TIA,
Mike

int
MapSubarrays
(
  int  Len
,
  int* Arr
,
  int* Map
)
{
  int result = 0 ;

  int i ;

  Map [ 0 ] = 1 ;

  for ( i = 1 ; i < Len ; i++ )
  {
    Map [ i ] = 0 ;

    if ( Arr [ i ] - Arr [ i - 1 ] != 1 )
    {
      result++ ;
    }

    Map [ result ]++ ;
  }

  return ( result ) ;
}

3 : { 1 , 2 , 3 }
3 : { 5 , 6 , 7 }
1 : { 22 }