移动数组中的元素，Java

Question

对于2d数组，具有相同偶数索引（例如[0] [0]）的值应移至下一个偶数索引（例如[2] [2]）。偶数索引中的最后一个元素应移至索引[0] [0]对于处于奇数位置的元素，应重复相同的操作。 （例如[1] [1]，[3] [3]，[5] [5]等）

这里怎么了？

int [][] matrix2= matrix;
    System.out.println(matrix2.length);
    for (int i= 0; i < matrix2.length; i++) {
        for (int j=0; j<matrix2[i].length; j++) {
            if (i==j && j == matrix2.length-1) {
                System.out.println(j);
                System.out.println(matrix[matrix.length-1][matrix.length-1]);
                matrix2[0][0]= matrix[i][j];
            }
            else if (i==j && j < matrix2.length-2) {
                matrix2[i+2][j+2]= matrix[i][j];
            }
        }
    }

Answer 1

尽管您没有为您的问题提供任何代码，但我仍将为您提供这段代码。注意，我没有考虑到如果两层数组的长度不均匀会发生什么。为此，有一种方法可以更改此代码，以便能够计算嵌套数组或长度不均匀的时间。

对于此代码，我将只解释偶数代码，也将解释奇数代码。对于偶数，将最后一个偶数索引值保存到临时变量。然后进入从最后一个偶数索引到索引0之前的循环。对于每个循环，将值从当前位置-2移到当前位置。循环结束时，为[0] [0]分配临时变量的值。

您应该很高兴，因为从一个问题中，您有4种方法，一种用于打印数组，一种用于测试奇数，另一种用于测试偶数，以及您问题的代码。

class Main {
  public static boolean isOdd(int input){
    return (input & 1) == 1;
  }

  public static boolean isEven(int input){
    return (input & 1) == 0;
  }

  public static void printArray(int [][] input){
    int lastFirstIndex = input.length - 1;
    for ( int i = 0; i < input.length; i++ ){
      int lastSecondIndex = input[i].length - 1;
      for ( int j = 0; j < input[i].length; j++ ){
        System.out.print(String.format("[%d][%d]:%d", i,j, input[i][j]));
        if ( j != lastSecondIndex ) System.out.print("\t");
      }
      if ( i != lastFirstIndex ) System.out.println();
    }
  }

  public static void main(String[] args) {
    int a[][] = new int[8][8];
    int temp;

    for ( int i = 0; i < a.length; i++ ){
      for ( int j = 0; j < a[i].length; j++ ){
        a[i][j] = (i * 10) + j;
      }
    }

    // Print before rearrange.
    System.out.println("Before Rearrange:");
    printArray(a);

    int lastOddIndex = isOdd(a.length - 1)? a.length - 1 : a.length - 2;
    int lastEvenIndex = isEven(a.length - 1)? a.length - 1 : a.length - 2;

    temp = a[lastEvenIndex][lastEvenIndex];
    for ( int i = lastEvenIndex; i > 0; i -= 2){
      a[i][i] = a[i - 2][i - 2];
    }
    a[0][0] = temp;

    temp = a[lastOddIndex][lastOddIndex];
    for ( int i = lastOddIndex; i > 1; i -= 2){
      a[i][i] = a[i - 2][i - 2];
    }
    a[1][1] = temp;

    // Print After rearrange
    System.out.println("\nAfter Rearrange:");
    printArray(a);
  } 
}

因此，在有人否决了我的答案后，我决定仅根据上面的示例将我的代码更改为更具动态性和效率的代码。这是在您不知道如何使用示例的情况下。下面是新代码。现在，数组的长度可以小于2。长度小于2。甚至不必相同。您可以使用8x7、8x8、8x4、4x8或其他格式。但是最小长度是2x2矩阵。

class Main {
  public static boolean isOdd(final int input){
    return (input & 1) == 1;
  }

  public static boolean isEven(final int input){
    return (input & 1) == 0;
  }

  public static void rotateBy2(int [][] input ){
    if ( input == null ) return;
    final int firstLVLength = input.length;
    if ( firstLVLength < 3 ) return;
    final int secondLVLength = input[0].length;
    if ( secondLVLength < 3 ) return;

    final int lastIndex = firstLVLength > secondLVLength? secondLVLength - 1 : firstLVLength - 1;
    final int lastOddIndex = isOdd(lastIndex)? lastIndex : lastIndex - 1;
    final int lastEvenIndex = isEven(lastIndex)? lastIndex : lastIndex - 1;

    final int tempOdd = input[lastOddIndex][lastOddIndex];
    final int tempEven = input[lastEvenIndex][lastEvenIndex];

    for ( int i = lastIndex; i > 1; i-- ) input[i][i] = input[i - 2][i - 2];

    input[0][0] = tempEven;
    input[1][1] = tempOdd;
  }

  public static void printArray(final int [][] input){
    final int lastFirstIndex = input.length - 1;
    for ( int i = 0; i < input.length; i++ ){
      final int lastSecondIndex = input[i].length - 1;
      for ( int j = 0; j < input[i].length; j++ ){
        System.out.print(String.format("[%d][%d]:%d", i,j, input[i][j]));
        if ( j != lastSecondIndex ) System.out.print("\t");
      }
      if ( i != lastFirstIndex )System.out.println();
    }
  }


  public static void main(String[] args) {
    int a[][] = new int[8][8];

    for ( int i = 0; i < a.length; i++ ){
      for ( int j = 0; j < a[i].length; j++ ){
        a[i][j] = (i * 10) + j;
      }
    }

    // Print before rearrange.
    System.out.println("Before Rearrange:");
    printArray(a);

    rotateBy2( a );

    // Print After rearrange
    System.out.println("\nAfter Rearrange:");
    printArray(a);
  } 
}