将 N 维数组映射到 M 维数组，其中 M > N

Question

所以我想做的是将任意大小的多维数组随机折叠到更大的维度，例如：

String [][] myArray = new String[5][5]

将转换为：

String [][][][][] transformedArray = new String [10][10][10][10][10]

我将前一个数组中的数据输入到新数组中，然后用随机数据填充新数组，这些数据是虚假数据。我的问题是创建一个访问函数，允许我从新数组中获取正确的数据，谁能给我任何指示我将如何去做？

Answer 1

您需要将 N 维数组转换为一维数组。例如，如果您使用String [][] myArray = new String[5][5]、String[] oneDimArr[] = new String[5*5]，那么myArray[0][3] 将是oneDimArr[0*5+3]，而myArray[2][4] 将是oneDimArr[2*5+4]。

就像你把矩阵的每一行都粘在一个连续的大线上一样。

另一个例子：my3Darr[][][] = new String [7][7][7]; OneDimArr[] = new String[7*7*7] 所以，my3Darr[4][5][2] 将是 oneDimArr[4*7*7+5*7+2]。

你可以在myArray 和transformedArray 上使用它。您将拥有一个长度为 25 的数组和一个长度为 10000 的数组。然后根据需要传输数据。例如乘以 4000（即 10000/25）：1D_myArray[i] 将是 1D_transformedArray[i*4000]。现在你只需反转这个过程：将1D_transformedArray 设置为transformedArray。

您实际上不需要在最终代码中为两个数组都遍历一维数组，您只需要获取从 2D 到 5D 索引的方法，但是您将从 2D 索引转到 1D 索引，然后从这个一维索引到你的函数（“i * 4000”或任何你想要的），然后从这个新的一维索引到你的五维索引。

示例：

String [][] myArray = new String[5][5]
String [][][][][] transformedArray = new String [10][10][10][10][10]

从二维到一维的位置/索引[2][4] => [14]

索引转换14*4000 => 56.000

从 1D 到 5D 56.000 => [k,l,m,n,o] with `j=56.000, k = j/10^4, l=(j%10^4)/10^3, m=(j%10^3)​​/10^ 2、n=(j%10^2)/10^1, o=j%10^1/10^0。

对于“从 1 维到 N 维”算法，我不太确定，但我希望你能明白（Algorithm to convert a multi-dimensional array to a one-dimensional array 可能还有其他解释）

不确定，但您可能需要这个：Getting unknown number of dimensions from a multidimensional array in Java

还要注意溢出，int 可能不足以包含一维索引，请小心使用long。

编辑：必须尝试一下，所以就这样吧：

 public static void main(String[] args) {
        //Easy to calculate
        int[] coords = {4,5,2};
        System.out.println("out1:"+indexFromNDto1D(coords,7,3)); //233
        System.out.println("out2:"+Arrays.toString(indexFrom1DToND(233,7,3))); //{4,5,2}

        System.out.println("");
        //Just like the example
        int oldDimensionSize = 5;
        int newDimensionSize = 10;

        int oldNumberOfDimensions = 2;
        int newNumberOfDimensions = 5;

        int[] _2Dcoords = {2,4};
        int[] _5Dcoords = null;

        int idx = indexFromNDto1D(_2Dcoords,oldDimensionSize,oldNumberOfDimensions); //One dimension index
        System.out.println(idx);
        idx = transferFunction(idx); 
        System.out.println(idx);
        _5Dcoords = indexFrom1DToND(idx,newDimensionSize,newNumberOfDimensions); 
        System.out.println(Arrays.toString(_5Dcoords));

        System.out.println("Reversing");

        idx = indexFromNDto1D(_5Dcoords,newDimensionSize,newNumberOfDimensions);
        System.out.println(idx);
        idx = reverseTransfertFunction(idx);
        System.out.println(idx);
        _2Dcoords = indexFrom1DToND(idx,oldDimensionSize,oldNumberOfDimensions);
        System.out.println(Arrays.toString(_2Dcoords));
    }

    public static int indexFromNDto1D(int[] coords, int dimLength, int numberOfDimensions){
        //Could've use numberOfDimensions = coords.length but for symetry with the other method...
        int result = 0;

        for(int currDim = 0; currDim < numberOfDimensions; currDim++){
            int shift = (int) (Math.pow(dimLength, numberOfDimensions - currDim - 1) * coords[currDim]);
            result+= shift;
        }

        return result;
    }

    public static int[] indexFrom1DToND(int idx, int dimLength, int numberOfDimensions){
        int[] result = new int[numberOfDimensions];

        for(int currDim = 0; currDim < numberOfDimensions ; currDim++){
            int currentDimSize = (int) Math.pow(dimLength,numberOfDimensions-1-currDim);
            result[currDim] = idx / currentDimSize;
            idx = idx %  currentDimSize; 
        }

        return result;
    }

    static final int transfer = 4000;

    public static int transferFunction(int idx){
        return idx * transfer;
    }

    public static int reverseTransfertFunction(int idx){
        return idx / transfer;
}

这是输出：

out1:233
out2:[4, 5, 2]

14
56000
[5, 6, 0, 0, 0]
Reversing
56000
14
[2, 4]