如何使用 linq 按顺序计算每组中的项目数？

Question

例如，我有一个整数序列，

1122211121

我想要一些字典/匿名类显示：

item | count
1    | 2
2    | 3
1    | 3
2    | 1
1    | 1

Answer 1

        var test = new[] { 1, 2, 2, 2, 2, 1, 1, 3 };
        int previous = test.First();
        int idx = 0;
        test.Select(x =>
                x == previous ?
                new { orig = x, helper = idx } :
                new { orig = previous = x, helper = ++idx })
            .GroupBy(x => x.helper)
            .Select(group => new { number = group.First().orig, count = group.Count() });

如果您想更加 Linqy，可以在 let 子句中完成 previous 和 idx 的初始化。

       from whatever in new[] { "i want to use linq everywhere" }
       let previous = test.First()
       let idx = 0
       from x in test
       ...

函数式编程很好，但恕我直言，在这种情况下，在 C# 中我肯定会选择过程式方法。

Answer 2

您希望执行类似于 morelinq 项目中的“Batch”运算符的操作，然后输出组的计数。

不幸的是，morelinq 中的批处理运算符只接受一个大小并返回按该大小批处理的存储桶（或者在我查看 morelinq 时确实如此）。为了纠正这个缺陷，我必须编写自己的批处理实现。

private static IEnumerable<TResult> BatchImplementation<TSource, TResult>(
        this IEnumerable<TSource> source,
        Func<TSource, TSource, int, bool> breakCondition,
        Func<IEnumerable<TSource>, TResult> resultSelector
    )
{
    List<TSource> bucket = null;
    var lastItem = default(TSource);
    var count = 0;

    foreach (var item in source)
    {
        if (breakCondition(item, lastItem, count++))
        {
            if (bucket != null)
            {
                yield return resultSelector(bucket.Select(x => x));
            }

            bucket = new List<TSource>();
        }
        bucket.Add(item);
        lastItem = item;
    }

    // Return the last bucket with all remaining elements
    if (bucket.Count > 0)
    {
        yield return resultSelector(bucket.Select(x => x));
    }
}

这是我公开了验证输入参数的各种公共重载的私有版本。您希望您的breakCondition具有以下形式：

Func<int, int, int, bool> breakCondition = x, y, z => x != y;

对于您的示例序列，这应该为您提供： {1, 1}, {2, 2, 2}, {1, 1, 1}, {2} , {1}

从这里开始，抓取每个序列的第一项然后对序列进行计数就很简单了。

编辑：为了协助实施-

public static IEnumerable<IEnumerable<TSource>> Batch<TSource>(
        this IEnumerable<TSource> source,
        Func<TSource, TSource, int, bool> breakCondition
    )
{
    //Validate that source, breakCondition, and resultSelector are not null
    return BatchImplemenatation(source, breakCondition, x => x);
}

您的代码将是：

var sequence = {1, 1, 2, 2, 2, 1, 1, 1, 2, 1};
var batchedSequence = sequence.batch((x, y, z) => x != y);
//batchedSequence = {{1, 1}, {2, 2, 2}, {1, 1, 1}, {2}, {1}}
var counts = batchedSequence.Select(x => x.Count());
//counts = {2, 3, 3, 1, 1}
var items = batchedSequence.Select(x => x.First());
//items = {1, 2, 1, 2, 1}
var final = counts.Zip(items. (c, i) => {Item = i, Count = c});

除了我在自己的代码库中使用的私有方法及其重载之外，我还没有编译和测试任何这些，但这应该可以解决您的问题以及您遇到的任何类似问题。

Answer 3

嗯...稍微短一点（注意处理偶数/奇数出现计数的双重分离调用）：

    static void Main(string[] args)
    {
        string separatedDigits = Separate(Separate("1122211121"));

        foreach (var ano in separatedDigits.Split('|').Select(block => new { item = block.Substring(0, 1), count = block.Length }))
            Console.WriteLine(ano);

        Console.ReadKey();
    }

    static string Separate(string input)
    {
        return Regex.Replace(input, @"(\d)(?!\1)(\d)", "$1|$2");
    }
}