4

我在尝试更新嵌套的 for 循环以使用递归时遇到一些问题。使用递归时是否可以从早期的 for 循环中访问 a、b 和 c 变量？下面是我试图转换为递归调用的简单示例。

for(int a= 0; a < 10; a++)
{
    for(int b = 0; b < 20; b++)
    {
        for(int c = 0; c < 10; c++)
        {
            int[] indexes = new int[3]{a,b,c}
            collection.add(indexes);
        }
    }
}

编辑：解决方案需要能够在运行时进行调整，以便用户可以选择需要多少级别。

4

6 回答 6

9

这是一个递归解决方案（使用函数式编程风格）：

public static IEnumerable<IEnumerable<int>> GetCombinations(IEnumerable<int> limits)
{
    if (limits.Any() == false)
    {
        // Base case.
        yield return Enumerable.Empty<int>();
    }
    else
    {
        int first = limits.First();
        IEnumerable<int> remaining = limits.Skip(1);
        IEnumerable<IEnumerable<int>> tails = GetCombinations(remaining);

        for (int i = 0; i < first; ++i)
            foreach (IEnumerable<int> tail in tails)
                yield return Yield(i).Concat(tail);
    }
}

// Per http://stackoverflow.com/q/1577822
public static IEnumerable<T> Yield<T>(T item)
{
    yield return item;
}

样品用途：

var sequences = GetCombinations(new [] { 5, 3, 2, 4 /* ... */ });
foreach (var sequence in sequences)
    Console.WriteLine(string.Join(", ", sequence));

/* Output:
0, 0, 0, 0
0, 0, 0, 1
0, 0, 0, 2
0, 0, 0, 3
0, 0, 1, 0
0, 0, 1, 1
0, 0, 1, 2
0, 0, 1, 3
0, 1, 0, 0
0, 1, 0, 1
0, 1, 0, 2
... */

对于 OP 的特定场景（将数组添加到collection）：

var sequences = GetCombinations(new [] { 10, 20, 10 });
collection.AddRange(sequences.Select(s => s.ToArray()));
于 2013-09-20T10:45:26.197 回答
4

好的，试试这个

static void AddToCollectionRecursive(
    List<int[]> collection,
    params int[] counts)
{
    AddTo(collection, new List<int>(), counts, counts.Length - 1);
}

static void AddTo(
    List<int[]> collection,
    IEnumerable<int> value,
    IEnumerable<int> counts,
    int left)
{
    for (var i = 0; i < counts.First(); i++)
    {
        var list = value.ToList();

        list.Add(i);

        if (left == 0)
        {
            collection.Add(list.ToArray());
        }
        else
        {
            AddTo(collection, list, counts.Skip(1), left - 1);
        }
    }
}

用法是这样的AddToCollectionRecursive(collection, 10, 20, 10);。

于 2013-09-20T10:57:49.963 回答
2

像这样的东西会起作用：

public void CreateIndexes(int a, int b, int c, Collection collection)
{
    if(c == 10) {b++; c = 0;}
    if(b == 20) {a++; b = 0;}
    if(a == 10) return;

    int[] indexes = new int[3]{a,b,c}
    collection.add(indexes);
    c++;

    CreateIndexes(a, b, c, collection);
}
于 2013-09-20T10:34:39.897 回答
1

好吧，我认为如果你使用递归解决这个问题，它会消耗更多的内存和其他资源！

但有我的建议：

private void FunctionName(int a, int b, int c, List<int[]> list)
{
    if (a<10)
    { 
       if (b<20)
       {
           if (c<10)
           {
               list.Add(new[] { a, b, c });
               c++;
               FunctionName(a,b,c,list);
            }
            else
            {
                 c=0;
                 b++;
                 FunctionName(a,b,c,list);
            }
       }
       else
       {
          b=0;
          a++;
          FunctionName(a,b,c,list);
       }
    }
 }

你这样调用：FunctionName(0,0,0,list)。

希望它有效！^^

于 2013-09-20T10:39:23.097 回答
1

在我的脑海中，即未经测试，这样的事情可能会起作用：

    List<int[]> collection = new List<int[]>();
    private void AddValues(int a, int b, int c)
    {

        collection.Add(new[] { a, b, c });

        if (c < 10)
        {
            c++;
            AddValues(a, b, c);
        }

        if (b < 20)
        {
            b++;
            c = 0;
            AddValues(a, b, c);   
        }

        if (a < 10)
        {
            a++;
            b = 0;
            c = 0;
            AddValues(a, b, c);
        }
    }

通过调用来启动它：

AddValues(0, 0, 0);
于 2013-09-20T10:28:01.150 回答
0

这个解决方案需要一个动作来完成叶子上的工作：

void ForEachCombo(int from, int to, int nrLevels, Action<int[]> action)
{
    int[] d = new int[nrLevels];
    InnerFor(from, to, 0);
    void InnerFor(int from, int to, int level)
    {
        if (level == nrLevels)
            action(d);
        else
            for (d[level] = from; d[level] <= to - nrLevels + level + 1; d[level]++)
                InnerFor(d[level] + 1, to, level + 1);
    }
}

像这样使用：

ForEachCombo(0, 9, 3, (d) =>
{
    Console.WriteLine(string.Join(", ", d));
});

// Output
0, 1, 2
0, 1, 3
0, 1, 4
0, 1, 5
...
6, 7, 9
6, 8, 9
7, 8, 9
//

如果你愿意，你可以通过这样写来节省一个递归级别：

void ForEachCombo(int from, int to, int nrLevels, Action<int[]> action)
{
    int[] d = new int[nrLevels];
    InnerFor(from, to, 0);
    void InnerFor(int from, int to, int level)
    {
        if (level == nrLevels - 1)
            for (d[level] = from; d[level] <= to - nrLevels + level + 1; d[level]++)
                action(d);
        else
            for (d[level] = from; d[level] <= to - nrLevels + level + 1; d[level]++)
                InnerFor(d[level] + 1, to, level + 1);
    }
}
于 2021-10-14T06:02:57.023 回答