Java – matriz giratoria

Entonces, el objective es rotar los elementos en una matriz a vez. Como ejemplo; si a==2 , entonces array = {0,1,2,3,4} se convertiría en array = {3,4,0,1,2}

Esto es lo que tengo:

 for (int x = 0; x <= array.length-1; x++){ array[x+a] = array[x]; } 

Sin embargo, esto no tiene en cuenta cuando [x+a] es mayor que la longitud de la matriz. Leí que debería almacenar los que son más grandes en una matriz diferente, pero ver como a variable no estoy seguro de que sea la mejor solución. Gracias por adelantado.

Agregue una longitud de matriz de módulo a su código:

 // create a newArray before of the same size as array // copy for(int x = 0; x <= array.length-1; x++){ newArray[(x+a) % array.length ] = array[x]; } 

También debe crear una nueva Array para copiar, de modo que no sobrescriba los valores que necesitará más adelante.

En caso de que no desee reinventar la rueda (tal vez sea un ejercicio pero puede ser bueno saberlo), puede usar Collections.rotate .

Tenga en cuenta que requiere una matriz de objetos, no un tipo de datos primitivo (de lo contrario, cambiará las matrices en la lista).

 Integer[] arr = {0,1,2,3,4}; Collections.rotate(Arrays.asList(arr), 2); System.out.println(Arrays.toString(arr)); //[3, 4, 0, 1, 2] 

Arraycopy es una operación costosa, tanto en tiempo como en memoria. Esta sería una forma eficiente de girar la matriz sin usar espacio adicional como la respuesta aceptada.

 public void rotate(int[] nums, int k) { // k = 2 k %= nums.length; // {0,1,2,3,4} reverse(nums, 0, nums.length - 1); // Reverse the whole Array // {4,3,2,1,0} reverse(nums, 0, k - 1); // Reverse first part (4,3 -> 3,4) // {3,4,2,1,0} reverse(nums, k, nums.length - 1); //Reverse second part (2,1,0 -> 0,1,2) // {3,4,0,1,2} } public void reverse(int[] nums, int start, int end) { while (start < end) { int temp = nums[start]; nums[start] = nums[end]; nums[end] = temp; start++; end--; } } 

Otra forma es copiar con System.arraycopy .

  int[] temp = new int[array.length]; System.arraycopy(array, 0, temp, a, array.length - a); System.arraycopy(array, array.length-a, temp, 0, a); 

Creo que la forma más rápida sería usar System.arrayCopy (), que es el método nativo:

 int[] tmp = new int[a]; System.arraycopy(array, array.length - a, tmp, 0, a); System.arraycopy(array, 0, array, a, array.length - a); System.arraycopy(tmp, 0, array, 0, a); 

También reutiliza la matriz existente. Puede ser beneficioso en algunos casos. Y el último beneficio es que el tamaño de la matriz temporal es menor que la matriz original. Por lo tanto, puede reducir el uso de memoria cuando a es pequeño.

La solución Java está envuelta en un método:

 public static int[] rotate(final int[] array, final int rIndex) { if (array == null || array.length <= 1) { return new int[0]; } final int[] result = new int[array.length]; final int arrayLength = array.length; for (int i = 0; i < arrayLength; i++) { int nIndex = (i + rIndex) % arrayLength; result[nIndex] = array[i]; } return result; } 

Para Left Rotate es muy simple

Tome la diferencia entre la longitud de la matriz y el número de posición para cambiar.

Por ejemplo

 int k = 2; int n = 5; int diff = n - k; int[] array = {1, 2, 3, 4, 5}; int[] result = new int[array.length]; System.arraycopy(array, 0, result, diff, k); System.arraycopy(array, k, result, 0, diff); 

// imprime la salida

Pregunta: https://www.hackerrank.com/challenges/ctci-array-left-rotation
Solución: así es como probé el método arrayLeftRotation con complejidad o (n)

  • iterando una vez desde el índice k hasta (longitud-1)
  • 2ª vez para el índice 0 a kth

    public static int [] arrayLeftRotation (int [] a, int n, int k) {
    int [] resultArray = new int [n];
    int arrayIndex = 0;
    // primeros índices nk se llenarán en este ciclo
    for (int i = k; i resultArray [arrayIndex] = a [i];
    arrayIndex ++;
    }
    // 2dos k índices serán poblados en este ciclo
    for (int j = arrayIndex; j <(arrayIndex + k); j ++) {
    resultArray [j] = a [j- (nk)];
    }
    return resultArray;
    }

 package com.array.orderstatistics; import java.util.Scanner; public class ArrayRotation { public static void main(String[] args) { Scanner scan = new Scanner(System.in); int n = scan.nextInt(); int r = scan.nextInt(); int[] a = new int[n]; int[] b = new int[n]; for (int i = 0; i < n; i++) { a[i] = scan.nextInt(); } scan.close(); if (r % n == 0) { printOriginalArray(a); } else { r = r % n; for (int i = 0; i < n; i++) { b[i] = a[(i + r) < n ? (i + r) : ((i + r) - n)]; System.out.print(b[i] + " "); } } } private static void printOriginalArray(int[] a) { for (int i = 0; i < a.length; i++) { System.out.print(a[i] + " "); } } } 

En ruby rotation, una matriz puede ser posible en una línea.

 def array_rotate(arr) i, j = arr.length - 1, 0 arr[j],arr[i], i, j = arr[i], arr[j], i - 1, j + 1 while(j 

Pregunta: Rotar matriz dada una distancia específica. Método 1: Gire la matriz int a ArrayList. Luego use Collections.rotate (list, distance).

 class test1 { public static void main(String[] args) { int[] a = { 1, 2, 3, 4, 5, 6 }; List list = Arrays.stream(a).boxed().collect(Collectors.toList()); Collections.rotate(list, 3); System.out.println(list);//[4, 5, 6, 1, 2, 3] }// main }