Rotar las antiagoniales

32

Fondo

En los lenguajes de programación más razonables, es muy fácil rotar las filas o columnas de una matriz 2D. En este desafío, su tarea es rotar los antiagoniales en su lugar. Recuerde que las antiagoniales de una matriz 2D son sus cortes 1D tomados en la dirección noreste ↗.

Entrada

Una matriz 2D rectangular no vacía de números de un solo dígito en cualquier formato razonable. Tenga en cuenta que la matriz puede no ser un cuadrado.

Salida

La misma matriz, pero con cada anti-diagonal girado un paso hacia la derecha.

Ejemplo

Considere la 3x4matriz de entrada

0 1 2 3
4 5 6 7
8 9 0 1

Los anti-diagonales de esta matriz son

0
4 1
8 5 2
9 6 3
0 7
1

Sus versiones rotadas son

0
1 4
2 8 5
3 9 6
7 0
1

Por lo tanto, la salida correcta es

0 4 5 6
1 8 9 0
2 3 7 1

Reglas y puntaje

Puede escribir un programa completo o una función. También es aceptable escribir una función que modifique la matriz de entrada en su lugar, si su idioma lo permite. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten.

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos, o desea enumerar las penalizaciones de la bandera del intérprete por separado, o desea mostrar los puntajes antiguos que mejoró), asegúrese de que el puntaje real es el último número en el encabezado.

Mostrar fragmento de código

Casos de prueba adicionales

Input:
4
Output:
4

Input:
5 6 1
Output:
5 6 1

Input:
0 1
6 2
Output:
0 6
1 2

Input:
6 3 0 8
4 6 1 4
6 2 3 3
9 3 0 3
Output:
6 4 6 1
3 6 2 3
0 9 3 0
8 4 3 3

Input:
5 8 2
6 7 3
2 6 1
6 0 6
6 4 1
Output:
5 6 7
8 2 6
2 6 0
3 6 4
1 6 1

Input:
9 9 4 0 6 2
2 3 2 6 4 7
1 5 9 3 1 5
0 2 6 0 4 7
Output:
9 2 3 2 6 4
9 1 5 9 3 1
4 0 2 6 0 4
0 6 2 7 5 7
code-golf array-manipulation Zgarb
fuente

Respuestas:

20

CJam, 20

{z_)\zLa+(@+\.+s\,/}

Escrito como un bloque de funciones. Pruébalo en línea

Explicación:

La entrada se puede ver así:

diagrama de entrada

Es decir, separamos la fila superior y la columna derecha del resto de la matriz, y consideramos esos elementos en el orden que muestra la flecha.

Entonces la salida es así:

diagrama de salida

El bloque rectangular restante se mueve diagonalmente como un todo, y los elementos de borde se reordenan en el orden / posiciones que muestra la nueva flecha.

El código hace casi exactamente eso, excepto que la salida se genera primero con la flecha hacia abajo (por lo que la matriz tiene una cola, como la letra P), luego se corrige.

z      zip (transpose) the matrix
_      make a copy
)      take out the last row (right column before transposing)
\      swap with the rest of the matrix
z      transpose back
La+    append an empty row (needed for the single-column case,
        which leaves an empty matrix here)
(      take out the first row (top row without the corner)
@+     bring the right column to the top of the stack and concatenate
        obtaining an array of the edge elements (marked with the blue arrow)
\      swap with the remaining part (big white block in the diagrams)
.+     concatenate element by element
        each edge element is concatenated with a row of the white block
        after the white block runs out, the remaining elements form new rows
s      convert the whole thing to a string (concatenating all rows)
\      swap with the copy of the transposed matrix
,      get its length (number of original columns)
/      split the string into rows of that length
aditsu
fuente
La respuesta de Pyth también es de 20 bytes, pero la tuya fue anterior, así que la estoy aceptando.
Zgarb
9

CJam, 44 43 42 40 bytes

qN/:ReeSf.*:sz1fm<{Rz,{(S-(o\}*~]{},No}h

Pruébalo aquí.

Hmm, mucho mejor que mi primer intento, pero tengo la sensación de que Dennis resolverá esto en mucho menos de todos modos ...

La entrada y la salida son como cuadrículas ASCII:

0123
4567
8901

da

0456
1890
2371
Martin Ender
fuente
77
Tachado 44 sigue siendo regular 44; (
AdmBorkBork
3
@TimmyD Debería haber esperado hasta el final del período de gracia para editarlo desde 47 hasta 43.: P
Martin Ender
¡Sí! Se ha convertido en un meme .
intrepidcoder
1
FINALMENTE fui y aprendí un lenguaje de golf para poder jugar 4 bytes a 3 y unirme a la cadena de enlaces :)
Khuldraeseth na'Barya
6

J, 24 char

Función tomando un argumento.

$$<@(1&|.)/./:&;</.@i.@$

J tiene un operador /.llamado oblicuo . No puede invertirlo, por lo que la reconstrucción no es trivial, pero puede considerar "enumerar oblicuos" como una permutación de los elementos de la matriz. Así que invertido que permutación con /:(diádica Ordenar ), poniendo la permutación "oblicuos" para ese tamaño ( </.@i.@$) en el nuestros nuevos valores oblicuas derecha y, girar adecuadamente, a la izquierda. Luego volvemos a dar forma a esta lista en la antigua matriz rectangular utilizando la antigua $$.

   3 4$i.10
0 1 2 3
4 5 6 7
8 9 0 1
   ($$<@(1&|.)/./:&;</.@i.@$) 3 4$i.10
0 4 5 6
1 8 9 0
2 3 7 1

Pruébalo en línea.

Algoritmo de tiburón
fuente
Este es el pico J aquí mismo. Bien hecho.
Jonás
5

J, 38 30 bytes

8 bytes guardados gracias a @algorithmshark.

{./.((}.~#),~({.~#),.])}:"1@}.

La función recopila los bordes superior e izquierdo en una lista, corta la lista a dos piezas de tamaños suficientes y las une a la derecha y al final de la parte central.

Uso:

   ]input=.0 1 2 3, 4 5 6 7,: 8 9 0 1
0 1 2 3
4 5 6 7
8 9 0 1
   ({./.((}.~#),~({.~#),.])}:"1@}.) input
0 4 5 6
1 8 9 0
2 3 7 1

Pruébelo en línea aquí.

randomra
fuente
1
Hasta 30 Char: {./.sustituye }:@{.,{:"1, y se puede guardar dos tildes moviendo el tren por: {./.((}.~#),~({.~#),.])}:"1@}..
algoritmoshark
4

Julia, 153 149 139 bytes

A->(length(A)>1&&((m,n)=size(A);r(X)=for i=1:n X[:,i]=reverse(X[:,i])end;r(A);for i=-m:m A[diagind(A,i)]=circshift(diag(A,i),1)end;r(A));A)

Esto crea una función sin nombre que acepta una matriz y devuelve la matriz de entrada modificada en su lugar.

Sin golf:

# Create a function to reverse the columns of a matrix
function revcols!(X)
    for = 1:size(X, 2)
        X[:,i] = reverse(X[:,i])
    end
    return X
end

# Our main function
function zgarb!(A)
    # Only perform operations if the array isn't one element
    if length(A) > 1
        # Record the number of rows
        m = size(A, 1)

        # Reverse the columns in place
        revcols!(A)

        # Shift each diagonal
        for i = -m:m
            A[diagind(A, i)] = circshift(diag(A, i), 1)
        end

        # Reverse the columns back
        revcols!(A)
    end
    return A
end

¡Gracias a Martin Büttner por el asesoramiento algorítmico y por guardar 4 bytes!

Alex A.
fuente
3

ES6, 75 bytes

Esto acepta una matriz de matrices como parámetro y la modifica en su lugar.

a=>{t=a.shift();a.map(r=>{t.push(r.pop());r.unshift(t.shift())});a.push(t)}

Sin golf:

function anti_diagonal(array) {
    var temp = array.shift(); // strip off the first row
    array.forEach(row => temp.push(row.pop())); // strip off the last elements of each row
    array.forEach(row => row.unshift(temp.shift())); // distribute the elements to the beginning of each row
    array.push(temp); // the remaining elements become the last row
}

Consulte el diagrama de @aditsu para obtener más aclaraciones.

Neil
fuente
Puede guardar 2 bytes cambiando {t.push(r.pop());r.unshift(t.shift())}at.push(r.pop())+r.unshift(t.shift())
user81655
3

Pyth, 20 bytes

J+PhQ.)MQ++L.(J0tQ]J

Utiliza el enfoque de Adistu de eliminar la fila superior y la columna derecha, luego pegarlas en la izquierda y en la parte inferior. Pero con estructuras de datos mutables, no transposiciones.

isaacg
fuente
2

Octava, 85 bytes

@(a)[(b=[a(1,1:end),a(2:end,end)'])(1:(s=size(a)(1)))',[a(2:end,1:end-1);b(s+1:end)]]

Espero poder deshacerme del ends.

alephalpha
fuente
1

Python 2 , 113 104 94 bytes

f=lambda i,b=[]:i and[b and b[:1]+i[0][:-1]]+f(i[1:],b[1:]or i[0][:-1]+[l[-1]for l in i])or[b]

Pruébalo en línea!

Esta es una interpretación bastante literal del método de @ aditsu. La sintaxis de Python para tratar listas vacías como False ayudó a ahorrar 10 bytes adicionales.

SmileAndNod
fuente
ahorré 8 bytes al descartar filas a medida que
avanzo
Más casos de prueba
SmileAndNod
1
Es probable que no necesita el 0en[0:1]
Jo Rey