Question

我有这个功能：

public void func1(int d, double delta, double min, double max ) 
{
    if( d == 1 )
    {
        for( double i=min ; i <= max ; i++ )
            System.out.println(i);

    }

    if(d == 2 )
    {
        for( double i=min ; i <= max ; i++ )
            for( int j = min ; j <= max ; j++ )
                System.out.println(i, j);

    }

    if(d == 3 )
    {
        for( double i=min ; i <= max ; i++ )
            for( int j = min ; j <= max ; j++ )
                for( int k=min ; k <= max ; k++ )
                    System.out.println(i, j, k );

    }
}

如何让它动态化？即，如何不使用if语句，以便该函数可以与任何给定的d一起使用？
目前，如果我希望函数使用d = 5，那么我必须编写五个嵌套for循环并添加if语句。

Answer 1

您可以使用Recursion的概念来解决此问题。关键的想法是，如果你想拥有d循环，你可以简单地使用一个for循环，并且在for循环中你将有一个循环d - 1次的函数：

loop(int d) {
    for (i = min : max) {
        loop(d - 1)
    }
}

您可以参考以下示例代码以供参考：

public class Main {

    public static void main(String[] args) {
        func1(3, 1.0, 3.0);
    }

    private static void func1(int d, double min, double max) {
        func1(d, min, max, "");
    }

    private static void func1(int d, double min, double max, String prefix) {
        if (d == 0) {
            System.out.println(prefix);
        } else {
            for (double i = min; i <= max; i++) {
                if (d == 1) {
                    func1(d - 1, min, max, prefix + i);
                } else {
                    func1(d - 1, min, max, prefix + i + ", ");
                }
            }
        }
    }
}

更新

我修改了代码以返回double值的数组而不是字符串：

public class Main {

    private static List<double[]> combination = new LinkedList<>();
    private static double[] tmpArray;

    public static void main(String[] args) {
        func1(3, 1.0, 3.0);

        for (double[] result : combination) {
            for (int i = 0; i < result.length; i++) {
                if (i != result.length - 1) {
                    System.out.print(result[i] + ", ");
                } else {
                    System.out.print(result[i]);
                }
            }
            System.out.println();
        }
    }

    private static void func1(int d, double min, double max) {
        tmpArray = new double[d];
        func2(d, min, max);
    }

    private static void func2(int d, double min, double max) {
        if (d == 0) {
            //System.out.println(prefix);
            double[] newArray = new double[tmpArray.length];
            System.arraycopy(tmpArray, 0, newArray, 0, tmpArray.length);
            combination.add(newArray);
        } else {
            for (double i = min; i <= max; i++) {
                tmpArray[d - 1] = i;
                func2(d - 1, min, max);
            }
        }
    }
}

Answer 2

感觉像是一个家庭作业问题，但我会咬人。

我的回答类似于汽车里程表。你有数字轮子。当每个轮子到达9时，下一个轮子会碰到一个槽，当前轮子返回0.它不使用递归并始终保持完整的数字数组。您可以将数组添加到数组列表以捕获所有排列，而不是println。（我最后一次触摸Java是在2004年，所以请原谅我，如果这看起来并不像现代＆＃34;）

import java.util.Arrays;

public class Main {

    public static void func1(int d, double delta, double min, double max ) {
        double[] arr = new double[d];
        int i,j;

        for (i = 0; i < d; i++) {
            arr[i] = min;
        }

        System.out.println(Arrays.toString(arr));
        while (true) {
            // increase the first slot
            while (arr[0] < max) {
                arr[0] += delta;
                System.out.println(Arrays.toString(arr));
            }

            // find the next slot to increase
            i = 1;
            while (i < d && arr[i] == max) {
                i++;
            }

            // test of all slots contain the max value
            Boolean allMax = true;
            for (j = 0; j < d; j++) {
                if (arr[j] != max) {
                    allMax = false;
                    break;
                }
            }

            if (allMax) {
                // if it does, quit the outer while loop
                break;
            } else if (i < d) {
                // if not, increase that next slot
                arr[i] += delta;
            }

            // reset all slots before it
            for (j = 0; j < i; j++) {
                arr[j] = min;
            }

            System.out.println(Arrays.toString(arr));
        }
    }


     public static void main(String []args) {
        func1(3, 1, 1, 3); // gives 3^3 = 27 permutations
     }
}

我做了几个假设：

min < max
delta完美地从min步入max。例如，delta = 1, min = 1, max = 10。我还没有测试delta = 2, min = 1, max = 2等案例。

如何动态生成任何大小的所有整数组合

2 个答案:

更新