C# 表示数字序列的算法

我有一个数字序列要生成，我想使用某种算法（迭代或递归，无所谓）生成它

上下文化：这些数字是列表列表上迭代的索引。我需要做一个排列（组合，我不太清楚），但我需要生成列表中所有位置的所有组合

我试图获得的序列和输出是：

1 1
2 1
3 1
4 1
5 1

1 2
2 1
3 1
4 1
5 1

1 3
2 1
3 1
4 1
5 1

1 4
2 1
3 1
4 1
5 1

1 5
2 1
3 1
4 1
5 1

1 1
2 2
3 1
4 1
5 1

1 2
2 2
3 1
4 1
5 1

1 3
2 2
3 1
4 1
5 1

1 4
2 2
3 1
4 1
5 1

1 5
2 2
3 1
4 1
5 1

1 1
2 3
3 1
4 1
5 1

1 2
2 3
3 1
4 1
5 1

1 3
2 3
3 1
4 1
5 1

1 4
2 3
3 1
4 1
5 1

1 5
2 3
3 1
4 1
5 1

1 1
2 4
3 1
4 1
5 1

等等。。。最后一个州是：

1 5
2 5
3 5
4 5
5 5

请注意，在每个换行处都是迭代或递归的一个步骤。算法必须是泛型的。我写的这段代码可以帮上忙，但它不是我想要的(

List lstDays=新列表
{
新列表{1,2,3,4,5}，//第18天
新列表{1,2,3,4,5}，//第19天
新列表{1,2,3,4,5}，//第22天
新列表{1,2,3,4,5}，//第23天
新列表{1,2,3,4,5}，//第24天
};
对于（int i=0；i你可以这样做：

int[] second = new[] {0,0,0,0,0};
bool finish = false;
while (true) {
    for (int i = 0 ; i != 5 ; i++) {
        Console.WriteLine("{0} {1}", i+1, second[i]+1);
    }
    Console.WriteLine();
    int p = 0;
    do {
        second[p]++;
        if (second[p] == 5) {
            second[p] = 0;
            p++;
        } else {
            break;
        }
    } while (p != 5);
    if (p == 5) break;
}

第二个数字的序列被“创造性地”存储在名为
second
的数组中。
do
/
，而
循环“递增”这个数组，就好像它是一个以五个独立数字存储的基数为5的数字一样

这是一个。
您可以这样做：

int[] second = new[] {0,0,0,0,0};
bool finish = false;
while (true) {
    for (int i = 0 ; i != 5 ; i++) {
        Console.WriteLine("{0} {1}", i+1, second[i]+1);
    }
    Console.WriteLine();
    int p = 0;
    do {
        second[p]++;
        if (second[p] == 5) {
            second[p] = 0;
            p++;
        } else {
            break;
        }
    } while (p != 5);
    if (p == 5) break;
}

第二个数字的序列被“创造性地”存储在名为
second
的数组中。
do
/
，而
循环“递增”这个数组，就好像它是一个以五个独立数字存储的基数为5的数字一样

以下是一份基于尊敬的埃里克·利珀特（Eric Lippert）的评论的。
，为老年退休金计划的初衷编辑：

public void OutputSequence(int length){
    Recurse(length-1, Enumerable.Range(1, length).ToArray(), new int[length]);  
}

public void Recurse(int position, int[] arr, int[] state){  
    if (position == -1){
        PrintState(state);  
        return;
    }

    for (int i = 0; i < arr.Length; i++)
    {           
        state[position] = arr[i];
        Recurse(position-1, arr, state);
    }
}

public void PrintState(int[] state){
    for (int i = 0; i < state.Length; i++)
        Console.WriteLine ("{0} {1}",i+1, state[i]);        

        Console.WriteLine ();
}

编辑：只是为了好玩，这里有一种做N元笛卡尔积的方法

public IEnumerable<IEnumerable<int>> NAryCartesianProduct(int upper, int times){
    if (times == 0)
        return Enumerable.Empty<IEnumerable<int>>();

    var nums = Enumerable.Range(1, upper);          
    IEnumerable<IEnumerable<int>> products = nums.Select(i => new[]{i});

    for (int i = 1; i < times; i++)
    {
        products = from p in products
                   from n in nums
                   select p.Concat(new [] {n});                                     
    }       

    return products;
}

我相信有一种比一直创建新阵列更有效的方法，但我只是很快就搞定了：）

关于这一点，这里有一个信息更丰富的答案：

编辑2：很明显，原始链接是SO帖子答案的来源。我直到现在才读完。
根据尊敬的埃里克·利珀特（Eric Lippert）的以下评论，编辑OPs原始意图：

public void OutputSequence(int length){
    Recurse(length-1, Enumerable.Range(1, length).ToArray(), new int[length]);  
}

public void Recurse(int position, int[] arr, int[] state){  
    if (position == -1){
        PrintState(state);  
        return;
    }

    for (int i = 0; i < arr.Length; i++)
    {           
        state[position] = arr[i];
        Recurse(position-1, arr, state);
    }
}

public void PrintState(int[] state){
    for (int i = 0; i < state.Length; i++)
        Console.WriteLine ("{0} {1}",i+1, state[i]);        

        Console.WriteLine ();
}

编辑：只是为了好玩，这里有一种做N元笛卡尔积的方法

public IEnumerable<IEnumerable<int>> NAryCartesianProduct(int upper, int times){
    if (times == 0)
        return Enumerable.Empty<IEnumerable<int>>();

    var nums = Enumerable.Range(1, upper);          
    IEnumerable<IEnumerable<int>> products = nums.Select(i => new[]{i});

    for (int i = 1; i < times; i++)
    {
        products = from p in products
                   from n in nums
                   select p.Concat(new [] {n});                                     
    }       

    return products;
}

我相信有一种比一直创建新阵列更有效的方法，但我只是很快就搞定了：）

关于这一点，这里有一个信息更丰富的答案：

EDIT2：很明显，原始链接是那个SO帖子答案的来源。直到现在我才看完。
考虑对你的反对票发表评论。如果这段代码有效，你想要什么？你希望得到什么样的输出…代码必须按照这个顺序输出我显示的数字。如果在这里使用数组而不是列表，通常会更好。嗯。。。为什么？我想这是一样的。至少在C#上。但是我使用了列表列表，因为我有另一种对象在里面。我使用INT只是为了简单。请考虑一下你的下投票。如果这个代码有效，你想要什么？你希望得到什么样的输出…代码必须按照这个顺序输出我显示的数字。如果在这里使用数组而不是列表，通常会更好。嗯。。。为什么？我想这是一样的。至少在C#上。但是我使用了列表列表，因为我有另一种对象在里面。我在这里使用int只是为了简单。我看到（：我排除了我的旧注释我认为你的代码是我需要的（：我现在正在测试它！：DDI看到（：我排除了我的旧注释我认为你的代码是我需要的（：我现在正在测试它！：我喜欢你的LINQ用法和理论基础。我选择你的答案是最好的，因为你给了我​​笛卡尔积。虽然我已经将这个问题标记为C#，但我正在使用Python。所以，你帮了我很多忙（：tnx尽管原始海报似乎很喜欢，但所问的问题与笛卡尔积完全不匹配。@EricLippert我重新阅读了这个问题，以及dasblinkenlight的解决方案：他的预期产出为何不是{1,2,3,4,5}的笛卡尔积笛卡尔积本身是11、21、31、41、51、12、22、32、42、52、13、23、33、43、53、14、24、34、44、54、15、25、35、45、55。原始帖子中给出的顺序是11、21、31、41、51、12、21、31、41、51、13、21、31、51、14、21、41、51、15、21、41、41、51、12、22、31、41、51……这是一个完全不同的顺序ce.喜欢你的LINQ用法和理论基础。我选择你的答案是最好的，因为你给了我​​笛卡尔积。虽然我已经将这个问题标记为C#，但我正在使用Python。所以，你帮了我很多忙（：tnx尽管原始海报似乎很喜欢，但所问的问题与笛卡尔积完全不匹配。@EricLippert我重新阅读了这个问题，以及dasblinkenlight的解决方案：他的预期产出为何不是{1,2,3,4,5}的笛卡尔积笛卡尔积本身是11、21、31、41、51、12、22、32、42、52、13、23、33、43、53、14、24、34、44、54、15、25、35、45、55。原始帖子中给出的顺序是11、21、31、41、51、12、21、31、41、51、13、21、31、51、14、21、41、51、15、21、41、41、51、12、22、31、41、51……这是一个完全不同的顺序总工程师。