Реализация LINQ «по предикату» с памятью O(1), сложностью выполнения O(n) и отсутствием двойного перечисления. ⇐ C#

[Anonymous]

Примеры: Предположим, предикат равен i == 0.

Тогда


[*][1] -> [(1)]
[0] -> []
[*][1, 0] -> [(1)]
[*] [0, 1] -> [(1)]
[*][0, 0] -> []
[*][1, 1, 0] -> [(1, 1)]
[*][1, 0, 1] -> [(1), (1)]
[*][ 1, 1, 0, 0, 1, 0, 1, 1, 1] -> [(1, 1), (1), (1, 1, 1)]


По сути, это возврат смежных подсегментов, в которых предикат является ложным.

Я думал, это сработает

Код: Выделить всё

internal static IEnumerable PartitionBy(this IEnumerable source, Func condition)
{
IEnumerator mover = source.GetEnumerator();

for (; mover.MoveNext() ; )
{
var chunk = mover.MoveUntil(condition);

if (chunk.Any())
{
yield return chunk;
}
}
}

private static IEnumerable MoveUntil(this IEnumerator mover, Func condition)
{
bool hitCondition = false;

do
{
if (condition(mover.Current))
{
hitCondition = true;
}
else
{
yield return mover.Current;
}
}
while (!hitCondition && mover.MoveNext());
}

но я видел, что, например, с [1, 1, 0] он вернет [(1), (1)]. Я не совсем понимаю, почему. Я смогу заставить это работать, если изменюсь

Код: Выделить всё

var chunk = mover.MoveUntil(condition);

чтобы иметь mover.MoveUntil(condition).ToList(); но если возможно, мне бы не хотелось хранить какие-либо подсегменты в памяти .

Подробнее здесь: https://stackoverflow.com/questions/566 ... e-complexi