score:1

your example is complicated. i'll first state and solve a simpler problem, then use the same method to solve your original problem.

i want to split a list of numbers into contiguous groups of even and odd numbers. for example, given the list `2,2,4,3,6,2` i would split it into three groups `[2,2,4], [3], [6,2]`

this can be done concisely with a groupadjacentby method

``````> var numbers = new list<int>{2,2,4,3,6,2};
> numbers.groupadjacentby(x => x % 2)
[[2,2,4], [3], [6,2]]
``````

to solve your problem, simply replace the even-odd classifying function above with your classification function:

``````> var points = new list<int>{-180,180};
> var f = new func<int,int>(x => points.binarysearch(x));
> var numbers = new list<int>{6,-50,100,190,200,20};
[[6,-50,100], [190,200], [20]]
``````

score:0

if you need the collections to be updated as soon as the values change why don;t you use properties? something like

``````// your original collection
public ilist<double> originalvalues; //= new list<double> { -1000, 5, 7 1000 };

public ilist<double> belowminus180
{
get { return originalvalues.where(x => x < -180).tolist().asreadonly(); }
}

public ilist<double> betweenminus180and180
{
get { return originalvalues.where(x => x >= -180 && x <= 180).tolist().asreadonly(); }
}

public ilist<double> above180
{
get { return originalvalues.where(x => x > 180).tolist().asreadonly(); }
}
``````

score:0

``````public static list<list<t>> partitionby<t>(this ienumerable<t> seq, func<t, bool> predicate)
{
bool lastpass = true;
return seq.aggregate(new list<list<t>>(), (partitions, item) =>
{
bool inc = predicate(item);
if (inc == lastpass)
{
if (partitions.count == 0)
{
}
}
else
{
}
lastpass = inc;
return partitions;
});
}
``````

you can then use:

``````list<list<double>> segments = newdataset.partitionby(d => d > -180 && d < 180);
``````

score:0

how about this possible solution using two passes. in the first pass we find the indices were a change occurs, and in the second pass we do the actual partitioning. first an auxiliary method to determine the category:

``````    protected int determinecategory(double number)
{
if (number < 180 && number > -180)
return 0;
else if (number < -180)
return 1;
else
return 2;
}
``````

and then the actual algorithm:

``````    list<int> indices = new list<int>();
int currentcategory = -1;
for (int i = 0; i < numbers.count; i++)
{
int newcat = determinecategory(numbers[i]);
if (newcat != currentcategory)
{
currentcategory = newcat;
}
}
list<list<double>> collections = new list<list<double>>(indices.count);
for (int i = 1; i < indices.count; ++i)
numbers.skip(indices[i - 1]).take(indices[i] - indices[i - 1])));
``````

score:0

here is a new answer based on the new info you provided. i hope this time i will be closer to what you need

``````public ienumerable<ilist<double>> getcollectionofcollections(ilist<double> values, ilist<double> boundries)
{
var ordered = values.orderby(x => x).tolist();
for (int i = 0; i < boundries.count; i++)
{
var collection = ordered.where(x => x < boundries[i]).tolist();
if (collection.count > 0)
{
ordered = ordered.except(collection).tolist();
yield return collection.tolist();
}
}
if (ordered.count() > 0)
{
yield return ordered;
}
}
``````

score:0

one method with linq. untested but should work

``````var firstset = dataset.takewhile(x=>x>-180&&x<180);
var totalcount = firstset.count();
var secondset = dataset.skip(totalcount).takewhile(x=>x<-180);
totalcount+=secondset.count();
var thirdset = dataset.skip(totalcount).takewhile(x=>x>180);
totalcount += thirdset.count();
var fourthset = dataset.skip(totalcount);
``````