Cómo rotar un Arreglo

    
En esta entrada de blog, aprenderemos a resolver el ejercicio Rotate Array, uno de los ejercicios más famosos de la plataforma LeetCode. Este ejercicio es un inicio para aprender a resolver problemas de programación, ya que requiere un pensamiento lógico utilizando arrays como estructura de datos.

En este artículo, cubriremos los siguientes temas:

✅ Una explicación del problema
✅ Una solución eficiente
✅ Implementaciones en Java, Python, PHP, C++ y JavaScript

Este ejercicio se encuentra en la plataforma de LeetCode como "Rotate Array".


Problema
El ejercicio consiste en rotar un array hacia la derecha un número determinado de veces

Por ejemplo, si tenemos el array nums = [1,2,3,4,5,6,7] y queremos rotarlo k veces, como por ejemplo, 3, el nuevo array se llenará de la siguiente manera: el elemento en la posición 0 (valor 1) se moverá a la posición 3, el elemento en la posición 1 (valor 2) se moverá a la posición 4, y así sucesivamente. Una vez que se llega a la posición 4, se sobrepasa del tamaño final del array y se empieza desde el principio. Es decir, el elemento en la posición 4 (valor 5) se moverá a la posición  0, y así sucesivamente hasta llegar al final del nuevo array [5,6,7,1,2,3,4].
        

Pasos para realizar el algoritmo:

1.- Inicializar un nuevo array auxiliar con la misma longitud que el array original nums. Este array será utilizado para guardar los elementos en las posiciones rotadas.

2.- Realizar un ciclo que recorra el array , y en cada iteración, calcular la posición actual en el array auxiliar utilizando la fórmula:

✅(i+k)%size, donde 

✅*i es la posición actual en el array nums.
✅*k es la cantidad de posiciones a rotar
✅*size es el tamaño del array nums.

NOTA: La función % (módulo) se utiliza para obtener el resto de una división entre dos números. Por ejemplo, si tenemos la operación 7 % 3, el resultado sería 1 ya que 3 cabe en 7 dos veces y sobra 1

3.- Guardar en el array auxiliar, en la posición rotada calculada en el paso anterior, el valor de la posición actual del array original nums.

4.- Asignar el array auxiliar al array original nums. En PHP, es necesario ordenar el array auxiliar por clave antes de asignarlo al array nums utilizando la función ksort.
            

Código en Java

public class Solution {
 
    public static void rotate(int[] nums, int k) {
        // step #1
        int size = nums.length;
        int[] aux = new int[size];
 
        // step #2
        for (int i = 0; i < size; i++) {
            int position = (i + k) % size;
 
            // step #3
            aux[position] = nums[i];
        }
 
        // step #4
        System.arraycopy(aux, 0, nums, 0, size);
    }
}

Código en php

class Solution {
 
    /**
     * @param Integer[] $nums
     * @param Integer $k
     * @return NULL
     */
    function rotate(&$nums, $k) {
        //paso #1
        $size=count($nums);
        $aux = array_fill(0, $size, 0);
 
        for ($i = 0; $i < $size; $i++) {
            //paso #2
            $position=($i+$k)%$size;
            //paso#3
            $aux[$position]=$nums[$i];
        }
 
        //paso#4
        $nums=$aux;  
    }
}

Código en Python

class Solution:
    def rotate(self, nums, k):
        #paso1
        size = len(nums)
        aux = [0] * size
 
        #paso2
        for i in range(size):
            position = (i + k) % size
 
            #paso3
            aux[position] = nums[i]
 
        #paso4
        nums[:] = aux

Código en C++

class Solution {
public:
  /**
   * Rota un array de números en una cantidad determinada de posiciones.
 
   * Args:
   *   nums: El array de números a rotar.
   *   k: La cantidad de posiciones a rotar.
 
   * Returns:
   *   NULL.
   */
  void rotate(vector<int>& nums, int k) {
    // Paso #1
    int size = nums.size();
    vector<int> aux(size, 0);
 
    // Paso #2
    for (int i = 0; i < size; i++) {
      // Paso #3
      int position = (i + k) % size;
      aux[position] = nums[i];
    }
 
    // Paso #4
    nums = aux;
  }
};

Código en JavaScript

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var rotate = function(nums, k) {
  // Paso #1
    const size = nums.length;
    const aux = new Array(size);
 
    // Paso #2
    for (let i = 0; i < size; i++) {
      // Paso #3
      const position = (i + k) % size;
      aux[position] = nums[i];
    }
 
    // Paso #4
    for (let i = 0; i < size; i++) {
      nums[i] = aux[i];
    }
}

        
    
Conclusión
En esta entrada de blog, hemos aprendido a resolver el ejercicio Como rotar un arreglo, uno de los ejercicios más famosos de la plataforma LeetCode. Hemos presentado dos soluciones al ejercicio, una solución simple y una