采用数组小于等于或大于 3x3 的二维数组构造函数

Question

从我的学位中得到一个项目，我被困在其中一个构造函数上。

构造函数名称需要像这样 Square3x3(int[][] array)。
它必须构造一个大小为 3x3 的二维数组，其值取自给定数组。
如果给定数组的大小大于 3x3，则仅采用前 3x3 个单元格。
如果给定数组较小，则其余单元格初始化为-1。

请注意，给定的数组可能是非对称的，甚至可能有不同长度的行。

当且仅当给定数组中的相应单元格不存在时，确保将单元格初始化为 -1。

您可以假设数组不为空。

当给定的数组大于 3x3 时，以下代码对我有效，但当它小于 3x3 时，我无法使其工作。

请注意，所有这些都需要位于与 main 不同的 class 中。

感谢您的帮助。

我得到以下代码：

public class Square3x3 {
        
    private int[][] Square3x3;
    
    public Square3x3(int[][]array) {
        Square3x3 = new int[3][3];
        int count =0;
        for (int i = 0; i < 3 && i < array.length; i++) {
            for (int j = 0; j < 3 && j < array[count].length; j++) {
                Square3x3[i][j] = array[i][j];
            }
            count++;
        }
    }
}

Answer 1

您必须更详细地查看初始化数组的逻辑。如果索引不存在则为-1；否则它将是 i-j 索引处的值。所以你必须看看数组是否至少有第 i 行。如果不是，你马上就会知道对于给定的 (i,j) 你有 -1。如果它至少有第 i 行，它是否有第 j 个元素？如果否，则再次-1。否则它是数组的第 i-j 个元素。

private int[][] square3x3;

public Square3x3(int[][] array) {
    final int dim = 3;
    final int defVal = -1;
    square3x3 = new int[dim][dim];
    for (int i = 0; i < dim; i++) {
        for (int j = 0; j < dim; j++) {
            final int val;
            if (array.length < (i + 1)) {
                val = defVal;
            } else {
                if (array[i].length < (j + 1)) {
                    val = defVal;
                } else {
                    val = array[i][j];
                }
            }
            square3x3[i][j] = val;
        }
    }
}

Answer 2

构造一个3x3大小的结果数组，并用-1填充。
根据需要从输入数组中复制值，选择输入数组的最小值 3 和 rows/columns。

private int[][] square3x3 = {
    {-1, -1, -1},
    {-1, -1, -1},
    {-1, -1, -1}
};

public Square3x3(int[][] array) {
    for (int i = 0, n = Math.min(3, array == null ? -1 : array.length); i < n; i++) {
        for(int j = 0, m = Math.min(3, array[i] == null ? -1 : array[i].length); j < m; j++) {
            square3x3[i][j] = array[i][j];
        }
    }
}

因此，如果输入的维度 array 小于 3x3，则在复制值时将使用预填充值 -1。

测试：

Square3x3 sq = new Square3x3(new int[3][2]); // input 2D arr initialized with 0
        
System.out.println(Arrays.deepToString(sq.square3x3));

// jagged input
sq = new Square3x3(new int[][]{{1, 2}, {3}, {4, 5, 6}});
System.out.println(Arrays.deepToString(sq.square3x3));
// input with nulls
mc = new MyClass(new int[][]{{1, 2}, null, {3}});
System.out.println(Arrays.deepToString(mc.square3x3));

输出：

[[0, 0, -1], [0, 0, -1], [0, 0, -1]]
[[1, 2, -1], [3, -1, -1], [4, 5, 6]]
[[1, 2, -1], [-1, -1, -1], [3, -1, -1]]

为了解决关于将单元格设置为 -1 的有点异想天开的要求 当且仅当给定数组中的相应单元格不存在时，可以提供以下实现：

private int[][] square3x3;
public Square3x3(int[][] array) {
    square3x3 = new int[3][3]; // anyway an array filled with 0 is created
        
    for (int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            square3x3[i][j] = null != array    && i < array.length 
                           && null != array[i] && j < array[i].length
                            ? array[i][j] : -1;
        }
    }
}

该要求试图以 convoluted/sophisticated 方式提供具体实现，但这与预期输出无关，实际上需要运行通过循环中的所有 3x3 单元格，同时可以实现完全相同的结果通过适当的初始化和不相关的 rows/cols 可能会被跳过。

Answer 3

public void whosThereRow (int row, boolean [] values)

该方法的工作原理：

该方法接收一个行号（来自值 2、1、0）和一个布尔数组尺码 10.

对于方法class中二维数组中相应行中出现的每个9-1之间的数字，将在值数组中的相应单元格中放置一个真值。

数组中的其余单元格将保持不变。

Answer 4

我用这种方式处理起来既不美观也不合逻辑。

我所做的是分别处理每个边缘情况...

 public Square3x3(int[][] array)
{
    int val;
    int vala;

    _square3x3 = new int[ROWS][COLS];
    if(_square3x3.length <= array.length ) // checking if given array length is bigger or equal
    {
        {
            for(int i = 0; i < ROWS; i++) // iterating over the first row
            {
                for(int j = 0; j < COLS; j++ ) // iterating over row indexes
                {
                    if(_square3x3[j].length > array[j].length) //if 3 is bigger the array row length
                    {
                        val = array[j].length; // saving the row length
                        vala = i; //saving row index
                        for(int k = val; k < COLS; k++ ) //loop between the array row length till k is 3
                            _square3x3[vala][k] = -1; // completing missing row cells with -1

                    }
                    else if(_square3x3[j].length <= array[j].length) //if given array row lenght is equal or bigger
                    {
                        for(int a = 0; a < ROWS; a++)
                        {
                            for(int b = 0; b < COLS; b++ )
                            {
                                _square3x3[a][b] = array[a][b]; //taking only first 3x3 cells
                            }
                        }
                    }

                }
            }
        }
    }
    else  // applied this condition only if array.length is smallar then square3x3.length
    {
        int rowNdxCounter = 0;

        for (int i = 0; i < array.length; i++)
        {
            for (int j =0; j < COLS; j++) //looping over all cells
            {
                rowNdxCounter++; // for each cell value is increasing by one
            }
            if (rowNdxCounter != 3) //if counter not equals to three then i need to fill in the row with value of -1
            {
                for (int c=rowNdxCounter; c < COLS; c++)
                    _square3x3[i][c] = -1;
            } 
            rowNdxCounter = 0;
        }
        for (int k = array.length; k < ROWS; k++) //looping over the missing row
            for(int j = 0; j < COLS; j++) //looping over cells in the missing rows
                _square3x3[k][j] = -1; // filling them with -1

    }

当然，所有的括号看起来确实很长而且很原始。但是在方法的第一部分，当给定数组大于或等于并且将其分为两种情况：

第一种情况： 如果行长度大于给定数组的行长度，并且给定数组行长度之一更小

保留行单元格索引并保留当前行索引。
然后在目标行上运行并用-1填充缺失的单元格如果给定数组的行长度之一大于或等于
运行在目标行上，并确保取前 3 个单元格

第二种情况

如果给定的数组长度更小。只有这样它才会进入第二种情况。

设置一个计数器供以后使用。
首先确保每行中包含三个单元格。为此，我在整个行中循环以获取我在行中有多少个单元格并使用计数器。

如果行没有三个单元格，（这就是为什么使用计数器），然后用 -1

填充缺失的单元格

确保行已填充后，我将循环遍历剩余的行并用 -1 填充它们。

采用数组小于等于或大于 3x3 的二维数组构造函数

2d array constructor that take array less equals or more than 3x3

java

arrays

constructor

initialization

multidimensional-array