将 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索引，然后从这个 1D 索引通过你的函数（"i*4000" 或任何你想要的），然后从这个新的 1D 索引到你的 5D 索引。

示例：

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

Postion/index 从二维到一维 [2][4] => [14]

索引转换14*4000 => 56.000

从 1D 到 5D 56.000 => [k,l,m,n,o] `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.

嗯，对于 "from 1-dimension to N-dimension" 算法，我不太确定，但我希望你能理解（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]

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

Mapping a N dimension array to a M dimension array where M > N

java

arrays

multidimensional-array

split

obfuscation