LINQ：按索引和值分组

Question

假设我有一个具有以下值的字符串列表：

["a","a","b","a","a","a","c","c"]

我想执行一个将分为 4 组的 linq 查询：

Group 1: ["a","a"] Group 2: ["b"] Group 3: ["a","a","a"] Group 4: ["c","c"]

基本上我想为值 "a" 创建 2 个不同的组，因为它们不是来自同一个 "index sequence"。

有人对此有 LINQ 解决方案吗？

Answer 1

先计算"index sequence"，然后做你的组。

private class IndexedData
{
    public int Sequence;
    public string Text;
} 

string[] data = [ "a", "a", "b" ... ]

// Calculate "index sequence" for each data element.
List<IndexedData> indexes = new List<IndexedData>();

foreach (string s in data)
{
    IndexedData last = indexes.LastOrDefault() ?? new IndexedData();

    indexes.Add(new IndexedData
    {
        Text = s,
        Sequence = (last.Text == s
                      ? last.Sequence 
                      : last.Sequence + 1)
    });
}

// Group by "index sequence"
var grouped = indexes.GroupBy(i => i.Sequence)
                     .Select(g => g.Select(i => i.Text));

Answer 2

这是一个天真的 foreach 实现，其中整个数据集最终都在内存中（可能对你来说不是问题，因为你 GroupBy）：

public static IEnumerable<List<string>> Split(IEnumerable<string> values)
{
    var result = new List<List<string>>();
    foreach (var value in values)
    {
        var currentGroup = result.LastOrDefault();
        if (currentGroup?.FirstOrDefault()?.Equals(value) == true)
        {
            currentGroup.Add(value);
        }
        else
        {
            result.Add(new List<string> { value });
        }
    }

    return result;
}

这里有一个稍微复杂的实现 foreach 和 yield return 枚举器状态机，它只在内存中保留当前组 - 这可能是在框架级别实现的方式：

编辑：这显然也是 MoreLINQ 的做法。

public static IEnumerable<List<string>> Split(IEnumerable<string> values)
{
    var currentValue = default(string);
    var group = (List<string>)null;

    foreach (var value in values)
    {
        if (group == null)
        {
            currentValue = value;
            group = new List<string> { value };
        }
        else if (currentValue.Equals(value))
        {
            group.Add(value);
        }
        else
        {
            yield return group;
            currentValue = value;
            group = new List<string> { value };
        }
    }

    if (group != null)
    {
        yield return group;
    }
}

这是一个只使用LINQ的笑话版本，它与第一个基本相同但稍微难理解（特别是因为Aggregate不是最常用的LINQ方法）：

public static IEnumerable<List<string>> Split(IEnumerable<string> values)
{
    return values.Aggregate(
        new List<List<string>>(),
        (lists, str) =>
        {
            var currentGroup = lists.LastOrDefault();
            if (currentGroup?.FirstOrDefault()?.Equals(str) == true)
            {
                currentGroup.Add(str);
            }
            else
            {
                lists.Add(new List<string> { str });
            }

            return lists;
        },
        lists => lists);
}

Answer 3

使用基于 APL 扫描运算符的扩展方法，类似于 Aggregate 但 returns 中间结果与源值配对：

public static IEnumerable<KeyValuePair<TKey, T>> ScanPair<T, TKey>(this IEnumerable<T> src, TKey seedKey, Func<KeyValuePair<TKey, T>, T, TKey> combine) {
    using (var srce = src.GetEnumerator()) {
        if (srce.MoveNext()) {
            var prevkv = new KeyValuePair<TKey, T>(seedKey, srce.Current);

            while (srce.MoveNext()) {
                yield return prevkv;
                prevkv = new KeyValuePair<TKey, T>(combine(prevkv, srce.Current), srce.Current);
            }
            yield return prevkv;
        }
    }
}

您可以创建扩展方法以按一致的运行进行分组：

public static IEnumerable<IGrouping<int, TResult>> GroupByRuns<TElement, TKey, TResult>(this IEnumerable<TElement> src, Func<TElement, TKey> key, Func<TElement, TResult> result, IEqualityComparer<TKey> cmp = null) {
    cmp = cmp ?? EqualityComparer<TKey>.Default;
    return src.ScanPair(0,
                        (kvp, cur) => cmp.Equals(key(kvp.Value), key(cur)) ? kvp.Key : kvp.Key + 1)
              .GroupBy(kvp => kvp.Key, kvp => result(kvp.Value));
}

public static IEnumerable<IGrouping<int, TElement>> GroupByRuns<TElement, TKey>(this IEnumerable<TElement> src, Func<TElement, TKey> key) => src.GroupByRuns(key, e => e);
public static IEnumerable<IGrouping<int, TElement>> GroupByRuns<TElement>(this IEnumerable<TElement> src) => src.GroupByRuns(e => e, e => e);

public static IEnumerable<IEnumerable<TResult>> Runs<TElement, TKey, TResult>(this IEnumerable<TElement> src, Func<TElement, TKey> key, Func<TElement, TResult> result, IEqualityComparer<TKey> cmp = null) =>
    src.GroupByRuns(key, result).Select(g => g.Select(s => s));
public static IEnumerable<IEnumerable<TElement>> Runs<TElement, TKey>(this IEnumerable<TElement> src, Func<TElement, TKey> key) => src.Runs(key, e => e);
public static IEnumerable<IEnumerable<TElement>> Runs<TElement>(this IEnumerable<TElement> src) => src.Runs(e => e, e => e);

使用最简单的版本，您可以获得 IEnumerable<IGrouping>>:

var ans1 = src.GroupByRuns();

或者为 IEnumerable 转储 IGrouping（及其 Key）的版本：

var ans2 = src.Runs();

Answer 4

你只需要数组项以外的键

var x = new string[] { "a", "a", "a", "b", "a", "a", "c" };


int groupId = -1;
var result = x.Select((s, i) => new
{
    value = s,
    groupId = (i > 0 && x[i - 1] == s) ? groupId : ++groupId
}).GroupBy(u => new { groupId });


foreach (var item in result)
{
    Console.WriteLine(item.Key);
    foreach (var inner in item)
    {
        Console.WriteLine(" => " + inner.value);
    }
}

结果如下：Link

LINQ：按索引和值分组

LINQ: Group by index and value

c#

linq

c#-7.2