C# 从问题、排列、组合生成不同路径的矩阵？

我需要一点正确方向的帮助来启动我的项目。 让我举一个小例子来解释这种情况：

例如，我有三个问题可以用真或假来回答。 我想了解所有可能的答案组合。
例如：

Question 1          Question 2          Question 3  
True                True                True  
True                False               True  
False               True                False  

等等……
有人知道我如何编写一个工具，最好是用C语言编写的，它可以生成一个如上所述的矩阵，包含所有可能的结果吗

非常感谢你们的反馈或想法
问候Tim

完全从头改写。假设您有

N

问题（演示中有3个）：

第一个答案可以是

真/假

，第二个答案可以是三个城市中的一个，等等。然后你可以用一个简单的例程列举所有可能的答案：

private static IEnumerable<string> Generator(string[][] answers) {
  int[] indexes = new int[answers.Length];

  while (true) {
    yield return string.Join("\t", answers
      .Select((answer, idx) => answer[indexes[idx]]));

    for (int i = 0; i < indexes.Length; ++i) {
      if (indexes[i] < answers[i].Length - 1) {
        indexes[i] += 1;

        break;
      }
      else {
        if (i == indexes.Length - 1)
          yield break;

        indexes[i] = 0;
      }
    }
  }
}

结果：

Question 1  Question 2  Question 3
true    Berlin  1
false   Berlin  1
true    Moscow  1
false   Moscow  1
true    London  1
false   London  1
true    Berlin  2
false   Berlin  2
true    Moscow  2
false   Moscow  2
true    London  2
false   London  2
true    Berlin  3
false   Berlin  3
true    Moscow  3
false   Moscow  3
true    London  3
false   London  3
true    Berlin  5
false   Berlin  5
true    Moscow  5 // <- The right answer
false   Moscow  5
true    London  5
false   London  5

问题1问题2问题3
真正的柏林1
假柏林1
真实莫斯科1
假莫斯科1
真实伦敦1
假伦敦1
真实柏林2
假柏林2
真实莫斯科2
假莫斯科2
真实伦敦2
假伦敦2
真实柏林3
假柏林3
真实莫斯科3
假莫斯科3
真实伦敦3
假伦敦3
真正的柏林5
假柏林5
真正的莫斯科5/完全从头重写。假设您有
N
问题（演示中有3个）：

第一个答案可以是
真/假
，第二个答案可以是三个城市中的一个，等等。然后你可以用一个简单的例程列举所有可能的答案：

private static IEnumerable<string> Generator(string[][] answers) {
  int[] indexes = new int[answers.Length];

  while (true) {
    yield return string.Join("\t", answers
      .Select((answer, idx) => answer[indexes[idx]]));

    for (int i = 0; i < indexes.Length; ++i) {
      if (indexes[i] < answers[i].Length - 1) {
        indexes[i] += 1;

        break;
      }
      else {
        if (i == indexes.Length - 1)
          yield break;

        indexes[i] = 0;
      }
    }
  }
}

结果：

Question 1  Question 2  Question 3
true    Berlin  1
false   Berlin  1
true    Moscow  1
false   Moscow  1
true    London  1
false   London  1
true    Berlin  2
false   Berlin  2
true    Moscow  2
false   Moscow  2
true    London  2
false   London  2
true    Berlin  3
false   Berlin  3
true    Moscow  3
false   Moscow  3
true    London  3
false   London  3
true    Berlin  5
false   Berlin  5
true    Moscow  5 // <- The right answer
false   Moscow  5
true    London  5
false   London  5

问题1问题2问题3
真正的柏林1
假柏林1
真实莫斯科1
假莫斯科1
真实伦敦1
假伦敦1
真实柏林2
假柏林2
真实莫斯科2
假莫斯科2
真实伦敦2
假伦敦2
真实柏林3
假柏林3
真实莫斯科3
假莫斯科3
真实伦敦3
假伦敦3
真正的柏林5
假柏林5
true Moscow 5/如果你真的喜欢丑陋的lambdas，这可以通过linq的一句话来实现：

var q1 = new string[] { "true", "false" };
var q2 = new string[] { "Berlin", "Moscow", "London" };
var q3 = new string[] { "1", "2", "3", "5" };

var combos = q1.Join(q2, _q1 => true, _q2 => true, (q11, q22) => new { q11, q22 }).Join(q3, _q3 => true, _q2 => true, (q11, q33) => new {q11.q11, q11.q22,q33});
combos.Dump();

它执行2个linq（交叉）联接，以将列表合并到所有可能组合的最终列表中

输出：

Question1 Question2 Question3    
true Berlin 1 
true Berlin 2 
true Berlin 3 
true Berlin 5 
true Moscow 1 
true Moscow 2 
true Moscow 3 
true Moscow 5 
true London 1 
true London 2 
true London 3 
true London 5 
false Berlin 1 
false Berlin 2 
false Berlin 3 
false Berlin 5 
false Moscow 1 
false Moscow 2 
false Moscow 3 
false Moscow 5 
false London 1 
false London 2 
false London 3 
false London 5 

如果您真的喜欢丑陋的Lambda，这可以通过一个linq语句实现：

var q1 = new string[] { "true", "false" };
var q2 = new string[] { "Berlin", "Moscow", "London" };
var q3 = new string[] { "1", "2", "3", "5" };

var combos = q1.Join(q2, _q1 => true, _q2 => true, (q11, q22) => new { q11, q22 }).Join(q3, _q3 => true, _q2 => true, (q11, q33) => new {q11.q11, q11.q22,q33});
combos.Dump();

它执行2个linq（交叉）联接，以将列表合并到所有可能组合的最终列表中

输出：

Question1 Question2 Question3    
true Berlin 1 
true Berlin 2 
true Berlin 3 
true Berlin 5 
true Moscow 1 
true Moscow 2 
true Moscow 3 
true Moscow 5 
true London 1 
true London 2 
true London 3 
true London 5 
false Berlin 1 
false Berlin 2 
false Berlin 3 
false Berlin 5 
false Moscow 1 
false Moscow 2 
false Moscow 3 
false Moscow 5 
false London 1 
false London 2 
false London 3 
false London 5 

提示：对于N个问题，这与一个具有N位的二进制数相同，最大值为（2^N）-1。因此，您可以使用int从0到（2^N）-1进行计数，并查看底部的N位。每个1位对应于
True
，每个0位对应于
False
。提示：对于N个问题，这与具有N位二进制数的a相同，最大值为（2^N）-1。因此，您可以使用int从0到（2^N）-1进行计数，并查看底部的N位。每个1位对应于
True
，每个0位对应于
False
。感谢您的输入！但我想知道有没有办法从循环中得到同样的结果？问题描述非常基本。情况是，我有一份调查问卷，其中一些问题可以用真或假来回答，一些是开放性问题，一些问题有多个答案。是否有可能创建类似上述矩阵的内容，但考虑到其他类型的问题？谢谢你能提供的任何帮助@蒂姆·奥奇潘蒂：当然你可以将
加入
变成一个循环，请看我的编辑。@蒂姆·奥奇潘蒂：如果你有不同类型的问题，请在帮助下指定它们，通过“不同类型”的问题说一个定制的类
QuestionKind
@TimOcchipinti，你是说可能有非“真”和“假”答案的问题吗，例如，“黑山的首都是什么？”@Dmitry Bychenko我不完全理解你这个问题的意思。。。？我想我一定是哑巴了：P而且不是一个非常熟练的程序员哈哈。但对于不同类型的问题，我的意思是，例如：问题1可以用是或否回答，问题2可以用个人电子邮件地址回答，问题3可以是多选题，个人可以回答，例如：伦敦、罗马或纽约。感谢您的输入！但我想知道有没有办法从循环中得到同样的结果？问题描述非常基本。情况是，我有一份调查问卷，其中一些问题可以用真或假来回答，一些是开放性问题，一些问题有多个答案。是否有可能创建类似上述矩阵的内容，但考虑到其他类型的问题？谢谢你能提供的任何帮助@蒂姆·奥奇潘蒂：当然你可以将
加入
变成一个循环，请看我的编辑。@蒂姆·奥奇潘蒂：如果你有不同类型的问题，请在帮助下指定它们，通过“不同类型”的问题说一个定制的类
QuestionKind
@TimOcchipinti，你是说可能有非“真”和“假”答案的问题吗，例如，“黑山的首都是什么？”@Dmitry Bychenko我不完全理解你这个问题的意思。。。？我想我一定是哑巴了：P而且不是一个非常熟练的程序员哈哈。但对于不同类型的问题，我的意思是，例如：问题1可以用是或否回答，问题2可以用个人电子邮件地址回答，问题3可以是多选题，个人可以回答，例如：伦敦、罗马或纽约。