列表迭代列表（所有可能的单向组合）

Question

我有一个 List<List<string>> 代表行和列的网格（每个的计数是动态的）。

我需要遍历项目并在一个方向上显示所有可能的组合。

如果我有以下物品，例如：

var items = new List<List<string>>
{
    new List<string> {"A", "B", "C", "D"},
    new List<string> {"E", "F", "G", "H"},
    new List<string> {"I", "J", "K", "L"},
};

输出应该是：

---> *ABCD-ABCH-ABCL-ABGD-ABGH-ABGL-ABKD-ABKH-ABKL-........... IJKL*.

如何遍历列表以实现此结果？

Answer 1

你想要的是转置的笛卡尔积。所以分解它。首先让我们进行转置：

public static List<List<T>> Transpose(
  this List<List<T>> sequences)
{
  // TODO: throw if sequences is null
  // TODO: throw if sequences contains any null
  // TODO: throw if the sequences are not all the same length
  return Enumerable.Range(0, sequences[0].Count)
    .Select(i => 
      Enumerable.Range(0, sequences.Count)
      .Select(j => sequences[j][i])
      .ToList())
    .ToList();
  }

我们可以从我的回答中获取笛卡尔积：https://stackoverflow.com/a/3098381/88656

现在你的问题的答案很简单。

IEnumerable<string> combinations = items
  .Transpose()
  .CartesianProduct()
  .Select(sequence => string.Join("", sequence));

请记住，解决这些问题的方法是将问题分解为对序列进行更基本操作的工作流，然后将扩展方法组合到工作流中 .

Answer 2

解决这个问题的另一种方法是，如果您需要 N 个唯一元素的组合，则将矩阵展平：

var elementArray = items.SelectMany(x => x).ToList();

这会将{{'A', 'B', 'C'}, {'D', 'E', 'F'}} 变成{'A', 'B', 'C', 'D', 'E', 'F'}

然后使用取自 another question 的以下 LINQ 扩展（将其放在项目中的任何位置）：

public static class Ex
{
    public static IEnumerable<IEnumerable<T>> DifferentCombinations<T> (this IEnumerable<T> elements, int k)
    {
        return k == 0 ? new[] { new T[0] } :
          elements.SelectMany((e, i) =>
            elements.Skip(i + 1).DifferentCombinations(k - 1).Select(c => (new[] { e }).Concat(c)));
    }
}

用作：

var combinations = elementArray.DifferentCombinations(4)
    .Select(
        l => string.Join("", l.ToArray())
    ).ToList();

在这种情况下，它的组合长度最多为 4 (DifferentCombinations(4))。