Question

我有这个数组：

 int[][] multi = new int[][]{
              { 3, 4, 2},
              { 2, 2, 5 },
              { 1, 2 }
            };

我想打印每个单元的产品。很难解释，所以让我们看一些例子：对于我的桌子，我需要打印：

        6 //(3*2*1)
        12 //(3*2*2)
        6 //(3*2*1)
        12 //(3*2*2)
        15 //(3*5*1)
        30 //(3*5*2)
        8 //(4*2*1)
        16 //(4*2*2)
        8 //(4*2*1)
        16 //(4*2*2)
        20 //(4*5*1)
        40 //(4*5*2)

...

表的大小可以更改，我需要一个通用的东西。

这是我的开始，但没有满足我的需要。这是逐行循环...

   for (int i = 0; i<multi[0].length; i++) {
           for (int k = 0; k < multi.length; k++) {
                for (int l = 0; l < multi[k].length; l++ ) {
                    System.err.println(multi[k][l]);
                }    
           }   
    }

Answer 1

如果您的数组尺寸不固定，我必须recursively来做。我提出了2D array

动态尺寸的代码

public class HelloWorld{
    static int[][] multi = new int[][]{
              { 3, 4, 2},
              { 2, 2, 5 },
              { 1, 2 }
    };
    static public void pattern(int row,int multip) {
        if(row >= multi.length) {
            System.out.println(multip);
            return ;
        }
        for(int i = 0; i<multi[row].length;i++) {
            multip*=multi[row][i];
            row+=1;
            pattern(row,multip);
            row-=1;
            multip/=multi[row][i];
        }
    }
    public static void main(String []args){
        pattern(0,1);
    }
}

如果您的尺寸是固定的，那么您也可以使用上面的逻辑进行操作，但是如果您要迭代，则必须重复在循环内部创建循环。

Answer 2

不难解释您是否使用数学术语，而您所需要的只是二维数组中一组Cartesian product的集合（即每一行）。在这里解释笛卡尔乘积（X是运算符）的理论可能要花点时间，但实际上您必须计算以下结果：

((multi[0] X multi[1]) X ...) X multi[n]

然后以一个二维数组结尾，该数组具有许多行，这是每个集合的所有基数的乘积，并且每一行都有许多元素，这是集合的数目（因为每个tupla都有来自每个集合的一个元素设置）。

另一件事是元组是有序的，即集合的元素在所有元组中的位置相同，例如位置0的每个tupla都有一个multi [0]元素。

知道这些属性后，就可以使用构造算法创建产品，该算法将第一个集合的元素放入结果集的第一列中，重复它们所需的时间，然后继续下一个集合/下一个列

最后，当您拥有笛卡尔积时，您可以做任何您想做的事，例如计算每一行元素的乘积。

public class CartesianProductProduct {

    public int[][] product(int[][] sets) {
        int cardinality = 1;
        for (int is = 0; is < sets.length; is++) cardinality *= sets[is].length;
        int[][] cartesianProduct = new int[cardinality][sets.length];
        int curCardinality = 1;
        for (int is = 0; is < sets.length; is++) {
            curCardinality *= sets[is].length;
            int repetition = cardinality / curCardinality;
            int ie = 0;
            for (int ic = 0; ic < cardinality; ic++) {
                cartesianProduct[ic][is] = sets[is][ie];
                if (repetition == 1) {
                    ie++;
                } else if ((ic + 1) % repetition == 0) {
                    ie++;
                }
                ie = ie == sets[is].length ? 0 : ie;
            }
        }
        return cartesianProduct;
    }

    public static void main(String[] args) {
        int[][] multi = new int[][]{
                {3, 4, 2},
                {2, 2, 5},
                {1, 2}
        };

        int[][] cartesianProduct = new CartesianProductProduct().product(multi);

        for (int i = 0; i < cartesianProduct.length; i++) {
            int prod = 1;
            String s = "";
            String sep = "";
            for (int k = 0; k < cartesianProduct[i].length; k++) {
                prod *= cartesianProduct[i][k];
                s = s + sep + cartesianProduct[i][k];
                sep = "*";
            }
            System.out.printf("%s //(%s)\n", prod, s);
        }
    }

}

JAVA特定于Array 2D的循环

2 个答案: