表示数字序列的算法

本文关键字：算法 字序 数字 表示 | 更新日期: 2023-09-27 18:29:01

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

上下文化：这些数字是对列表列表进行迭代的索引。我需要做一个排列（组合，我不确切地知道），但我需要生成该列表的所有位置的所有组合。

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

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<List<int>> lstDays = new List<List<int>>
{
    new List<int>{1,2,3,4,5}, //day 18
    new List<int>{1,2,3,4,5}, //day 19
    new List<int>{1,2,3,4,5}, //day 22
    new List<int>{1,2,3,4,5}, //day 23
    new List<int>{1,2,3,4,5}, //day 24
};
for(int i=0;i<lstDays.Count;i++)
{
    for(int j=0;j<lstDays[i].Count;j++)
    {
        for(int k=0;k<lstDays.Count;k++)
        {
            Console.Write(k+1);
            //Console.Write(j+1);
            Console.Write(''n');
        }
        Console.Write(''n');
    }
}

我希望你能帮助我！（：

表示数字序列的算法

你可以这样做：

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/while循环"递增"这个数组，就好像它是一个以5为基数的数字，存储为五个独立的数字。

这是ideone上的演示。

根据尊敬的Eric Lippert在下面的评论，对OP的初衷进行了编辑：

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 ();
}

OutputSequence(5);将给出OP最初要求的输出。

旧答案

你要找的是笛卡尔乘积。LINQ是你的朋友：

var pairs = from i in Enumerable.Range(1, 5)
            from j in Enumerable.Range(1, 5)
            select new {i, j};
foreach(var p in pairs)
    Console.WriteLine ("{0} {1}", p.i, p.j);

编辑：只是为了好玩，这里有一种做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;
}

现在，您可以使用获得以前的功能

var p = NAryCartesianProduct(5, 2);
foreach(var i in p)
    Console.WriteLine (i);

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

这里有一个更具信息性的答案：生成所有可能的组合

第二版：显然，最初的链接是SO帖子中答案的来源。直到现在我才通读到底。

相关文章：