Girar los elementos de la matriz a la izquierda (mover el primer elemento al último y volver a indexar)

6 minutos de lectura

avatar de usuario
dylan

¿Es posible ‘rotar’ fácilmente una matriz en PHP?

Así: 1, 2, 3, 4 -> 2, 3 ,4 ,1

¿Hay algún tipo de función PHP incorporada para esto?

  $numbers = array(1,2,3,4);
  array_push($numbers, array_shift($numbers));
  print_r($numbers);

Producción

Array
(
    [0] => 2
    [1] => 3
    [2] => 4
    [3] => 1
)

  • Esto está bien si solo está usando su matriz como un vector, y los valores de índice no son importantes. Pero si tiene una matriz asociativa que está tratando de rotar, este método destruye las claves de su matriz. Vea mi respuesta para una manera que los preservará.

    –Cam Jackson

    26/10/2011 a las 22:47

  • @Cam, tienes toda la razón en eso, incluso OP no ha mencionado el índice de matriz, solo valores. Su respuesta es valiosa para las personas que buscan una solución para rotar ambas partes de los elementos de la matriz. (+1 por tu respuesta)

    – Wh1T3h4Ck5

    29 de octubre de 2011 a las 6:46


  • sí, claramente su método fue suficiente para el OP, ¡de lo contrario no lo habría aceptado! Pero sí, pensé en agregar mi respuesta en caso de que alguien tuviera el mismo problema que yo 🙂

    –Cam Jackson

    30 de octubre de 2011 a las 7:44

  • eso es lo que estaba buscando!

    – Peter Perhač

    8 oct 2013 a las 16:19

  • para girar a la derecha: array_unshift($numbers,array_pop($numbers));

    – Tito

    26 de septiembre de 2018 a las 11:56

avatar de usuario
cam jackson

La mayoría de las respuestas actuales son correctas, pero solo si no le importan sus índices:

$arr = array('foo' => 'bar', 'baz' => 'qux', 'wibble' => 'wobble');
array_push($arr, array_shift($arr));
print_r($arr);

Producción:

Array
(
    [baz] => qux
    [wibble] => wobble
    [0] => bar
)

Para preservar sus índices, puede hacer algo como:

$arr = array('foo' => 'bar', 'baz' => 'qux', 'wibble' => 'wobble');

$keys = array_keys($arr);
$val = $arr[$keys[0]];
unset($arr[$keys[0]]);
$arr[$keys[0]] = $val;

print_r($arr);

Producción:

Array
(
    [baz] => qux
    [wibble] => wobble
    [foo] => bar
)

Quizás alguien pueda hacer la rotación de manera más sucinta que mi método de cuatro líneas, pero esto funciona de todos modos.

  • golf: list($k,$v)=each($arr);unset($arr[$k]);$arr[$k]=$v;. Puede que tenga que anteponer reset($arr);.

    – Tito

    26 de septiembre de 2018 a las 11:54

Es muy sencillo y se puede hacer de muchas maneras. Ejemplo:

$array   = array( 'a', 'b', 'c' );
$array[] = array_shift( $array );

Un método para mantener claves y rotar. usando el mismo concepto que array_push(array, array_shift(array)), en su lugar usaremos array_merge de 2 array_slices

$x = array("a" => 1, "b" => 2, "c" => 3, 'd' => 4);

Para mover el primer elemento al final

array_merge(array_slice($x, 1, NULL, true), array_slice($x, 0, 1, true)
//'b'=>2, 'c'=>3, 'd'=>4, 'a'=>1

Para mover el último elemento al frente

array_merge(array_slice($x, count($x) -1, 1, true), array_slice($x, 0,
//'d'=>4, 'a'=>1, 'b'=>2, 'c'=>3

avatar de usuario
Shaun Cockerill

Recorriendo la matriz, y shift-ing y push-ing, puede ser una forma común de rotar una matriz, sin embargo, a menudo puede estropear sus claves. Un método más robusto es el uso de una combinación de array_merge y array_splice.

/**
 * Rotates an array.
 * 
 * Numerical indexes will be renumbered automatically.
 * Associations will be kept for keys which are strings.
 * 
 * Rotations will always occur similar to shift and push,
 * where the number of items denoted by the distance are
 * removed from the start of the array and are appended.
 * 
 * Negative distances work in reverse, and are similar to
 * pop and unshift instead.
 * 
 * Distance magnitudes greater than the length of the array
 * can be interpreted as rotating an array more than a full
 * rotation. This will be reduced to calculate the remaining
 * rotation after all full rotations.
 * 
 * @param array $array The original array to rotate.
 * Passing a reference may cause the original array to be truncated.
 * @param int $distance The number of elements to move to the end.
 * Distance is automatically interpreted as an integer.
 * @return array The modified array.
 */
function array_rotate($array, $distance = 1) {
    settype($array, 'array');
    $distance %= count($array);
    return array_merge(
        array_splice($array, $distance), // Last elements  - moved to the start
        $array                          //  First elements - appended to the end
    );
}
// Example rotating an array 180°.
$rotated_180 = array_rotate($array, count($array) / 2);

Alternativamente, si también encuentra la necesidad de rotar las claves para que coincidan con diferentes valores, puede combinar array_keys, array_combine, array_rotatey array_values.

/**
 * Rotates the keys of an array while keeping values in the same order.
 * 
 * @see array_rotate(); for function arguments and output.
 */
function array_rotate_key($array, $distance = 1) {
    $keys = array_keys((array)$array);
    return array_combine(
        array_rotate($keys, $distance), // Rotated keys
        array_values((array)$array)    //  Values
    );
}

O, alternativamente, rotar los valores manteniendo las claves en el mismo orden (equivalente a llamar a la distancia negativa en el campo coincidente). array_rotate_key Llamada de función).

/**
 * Rotates the values of an array while keeping keys in the same order.
 * 
 * @see array_rotate(); for function arguments and output.
 */
function array_rotate_value($array, $distance = 1) {
    $values = array_values((array)$array);
    return array_combine(
        array_keys((array)$array),        // Keys
        array_rotate($values, $distance) //  Rotated values
    );
}

Y finalmente, si desea evitar la renumeración de índices numéricos.

/**
 * Rotates an array while keeping all key and value association.
 * 
 * @see array_rotate(); for function arguments and output.
 */
function array_rotate_assoc($array, $distance = 1) {
    $keys = array_keys((array)$array);
    $values = array_values((array)$array);
    return array_combine(
        array_rotate($keys, $distance),   // Rotated keys
        array_rotate($values, $distance) //  Rotated values
    );
}

Podría ser beneficioso realizar algunas pruebas comparativas, sin embargo, espero que un pequeño puñado de rotaciones por solicitud no afecte notablemente el rendimiento, independientemente del método que se utilice.

También debería ser posible rotar una matriz utilizando una función de clasificación personalizada, pero lo más probable es que sea demasiado complicado. es decir usort.

avatar de usuario
A1Gard

Puedes usar esta función:

    function arr_rotate(&$array,$rotate_count) {
        for ($i = 0; $i < $rotate_count; $i++) {
            array_push($array, array_shift($array));
        }
    }

uso:

    $xarr = array('1','2','3','4','5');
    arr_rotate($xarr, 2);
    print_r($xarr);

resultado:

 Array ( [0] => 3 [1] => 4 [2] => 5 [3] => 1 [4] => 2 )

avatar de usuario
Panel Gino

Hay una tarea sobre la rotación de matrices en Hackerrank: https://www.hackerrank.com/challenges/array-left-rotation/problem.

Y propuesta de solución con array_push y array_shift funcionará para todos los casos de prueba excepto el último, que falla debido al tiempo de espera. Asi que, array_push y array_shift no le dará la solución más rápida.

Aquí está el enfoque más rápido:

function leftRotation(array $array, $n) {
   for ($i = 0; $i < $n; $i++) {
       $value = array[$i]; unset(array[$i]); array[] = $value;
   }
   return array;
}

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad