c# - 计算一组串联的 n 组集合

Question

好吧 - 我什至不确定这个词是否正确 - 我确定 一定会 成为这个词 - 但我会尽力解释。这不是一个叉积，结果的顺序是绝对重要的。

给定:

IEnumerable<IEnumerable<string>> sets = 
      new[] { 
              /* a */ new[] { "a", "b", "c" },
              /* b */ new[] { "1", "2", "3" },
              /* c */ new[] { "x", "y", "z" }
            };

其中每个内部可枚举表示生成一组串联的指令，如下所示(此处的顺序很重要):

set a* = new string[] { "abc", "ab", "a" };
set b* = new string[] { "123", "12", "1" };
set c* = new string[] { "xyz", "xy", "x" };

我想按如下方式生成一组有序的串联:

set final = new string { a*[0] + b*[0] + c*[0], /* abc123xyz */
                         a*[0] + b*[0] + c*[1], /* abc123xy  */
                         a*[0] + b*[0] + c*[2], /* abc123x   */
                         a*[0] + b*[0],         /* abc123    */
                         a*[0] + b*[1] + c*[0], /* abc12xyz  */
                         a*[0] + b*[1] + c*[1], /* abc12xy   */
                         a*[0] + b*[1] + c*[2], /* abc12x    */
                         a*[0] + b*[1],         /* abc12     */
                         a*[0] + b*[2] + c*[0], /* abc1xyz   */
                         a*[0] + b*[2] + c*[1], /* abc1xy    */
                         a*[0] + b*[2] + c*[2], /* abc1x     */
                         a*[0] + b*[2],         /* abc1      */
                         a*[0],                 /* abc       */
                         a*[1] + b*[0] + c*[0], /* ab123xyz  */

                         /* and so on for a*[1] */
                         /* ... */

                         a*[2] + b*[0] + c*[0], /* a123xyz   */

                         /* and so on for a*[2] */
                         /* ... */

                         /* now lop off a[*] and start with b + c */

                         b*[0] + c*[0],         /* 123xyz    */

                         /* rest of the combinations of b + c
                            with b on its own as well */

                         /* then finally */
                         c[0],
                         c[1],
                         c[2]};

很明显，会有很多组合!

我可以看到与数字基数的相似之处(因为顺序也很重要)，而且我确信这里也潜伏着排列/组合。

问题是 - 如何编写这样的算法来处理任意数量的字符串集？ Linq，非 Linq；我不生气。

我为什么要这样做？

确实，为什么!？

在 Asp.Net MVC 中——我想要部分 View 可以针对后端/前端文化和语言的给定组合重新定义。其中最基本的是，对于给定的基本 View View，我们可以有 View-en-GB、View-en、View-GB 和 View，按照优先顺序(当然要认识到语言/文化代码可能相同，所以一些组合可能 相同 - Distinct() 将解决这个问题)。

但我也有其他观点，就其本身而言，在考虑文化之前还有其他可能的组合(讨论时间太长 - 但事实是，这个算法将启用一大堆真的 很酷，我想为我的开发人员提供!)。

我想生成一个包含所有可接受的 View 名称的搜索列表，遍历整个批处理，直到找到最具体的匹配项(受此算法生成这些串联的顺序控制)然后提供已解析的局部 View 。

稍后可以缓存搜索结果，以避免一直运行算法的开销。

我已经有了这个工作的一个非常基本的版本，它只有一个可枚举的字符串。但这是一锅完全不同的海鲜!

非常感谢任何帮助。

Answer 1

这是我的尝试:

void Main()
{
    IEnumerable<IEnumerable<string>> sets = 
          new[] { 
                  /* a */ new[] { "a", "b", "c" },
                  /* b */ new[] { "1", "2", "3" },
                  /* c */ new[] { "x", "y", "z" }
                };

    var setCombinations = from set in sets
                          select (from itemLength in Enumerable.Range(1, set.Count()).Reverse()
                                  select string.Concat(set.Take(itemLength).ToArray()));

    IEnumerable<string> result = new[] { string.Empty };

    foreach (var list in setCombinations) {
        result = GetCombinations(result, list);
    }
    // do something with the result
}

IEnumerable<string> GetCombinations(IEnumerable<string> root, IEnumerable<string> append) {
    return from baseString in root
           from combination in ((from str in append select baseString + str).Concat(new [] { baseString }))
           select combination;
}