从固定步骤递归生成数组答案

【问题标题】：Generate arrays from a fixed step recursively从固定步骤递归生成数组
【发布时间】：2015-08-22 14:53:01
【问题描述】：

我想根据两个输入递归生成数组：

1) 输入数组，例如double[] in={0.25, 0.25, 0.5};

2) 步长，例如double step = 0.25;

函数foo() 应该接受这两个输入并生成以下数组：

{0.5, 0.25, 0.5} (add step 0.25 to first element)

{0.0, 0.25, 0.5} (subtract 0.25 from first element)

...等等。

所有 2^d 组合（这里 d=3）。但我想在不指定维度 (d) 的情况下递归地执行此操作。

public void foo( double[] inatt, double[] outatt, double step, int d) 
{

   if( d = 0 )
   {
       // should print the array outatt:
   }
   else
   {
      outatt[d] = inatt[d]+step;
      foo( inatt, outatt, step, d-1);
   }

}

我不知道如何组织递归函数内部的调用.. 我猜如果事先不知道维数（d），那么它是我应该用来递归控制调用的变量吗？

【问题讨论】：

听起来好像要生成数组数组？
或者你想通过Consumer<double[]>来避免内存不足。
@OliverCharlesworth，他只想打印每个组合而不存储它们。

标签： java arrays recursion

【解决方案1】：

目前您的解释与您的示例相矛盾。如果d=3 有 8 种组合，我假设您想要组合 (add, add, add)、(add, add, subtract)、...、(subtract, subtract, add)、(subtract, subtract, subtract) 等操作。但是在您的示例中有(add, no-change, no-change) 和(subtract, no-change, no-change)。我认为这个例子是不正确的。

我建议添加d而不是减去，从0开始并在d == inatt.length时打印（为什么是inatt？inarr？）：

public void foo( double[] inatt, double[] outatt, double step, int d) 
{
   if( d == inatt.length )
   {
       System.out.println(Arrays.toString(outatt));
   }
   else
   {
      outatt[d] = inatt[d]+step;
      foo( inatt, outatt, step, d+1);
      outatt[d] = inatt[d]-step;
      foo( inatt, outatt, step, d+1);
   }
}

您输入 (foo(new double[] {0.25, 0.25, 0.5}, new double[3], 0.25, 0);) 的结果是：

[0.5, 0.5, 0.75]
[0.5, 0.5, 0.25]
[0.5, 0.0, 0.75]
[0.5, 0.0, 0.25]
[0.0, 0.5, 0.75]
[0.0, 0.5, 0.25]
[0.0, 0.0, 0.75]
[0.0, 0.0, 0.25]

如果您想要其他内容，请澄清问题（至少提供完整的预期输出）。

【讨论】：

对于数组中的每个元素，有 3 种情况：加法、减法、不变。
您从 d=0 开始然后添加直到 == inapt.length 的想法很棒！

【解决方案2】：

感谢 Tagir，我用他有用的代码找到了解决方案。对于数组中的每个元素，我有三种情况：加步、减步或不变。

递归调用从数组的第一个元素开始，然后一直持续到最后一个元素。

public static void foo( double[] inatt, double[] outatt, double step, int d) 
    {
        if( d == inatt.length )
        {
            System.out.println(Arrays.toString(outatt));
        }
        else
        {
           outatt[d] = inatt[d]+step;
           foo( inatt, outatt, step, d+1);
           outatt[d] = inatt[d]-step;
           foo( inatt, outatt, step, d+1);
           outatt[d] = inatt[d];
           foo( inatt, outatt, step, d+1);
        }
    }

对于输入数组：

        double[] att={0.25, 0.5};
        double step = 0.25;

这是输出：

foo(att, new double[d], delta, 0);
[0.5, 0.75]
[0.5, 0.25]
[0.5, 0.5]
[0.0, 0.75]
[0.0, 0.25]
[0.0, 0.5]
[0.25, 0.75]
[0.25, 0.25]
[0.25, 0.5]

【讨论】：