Una vez tuve una hermosa matriz rectangular. Era muy simétrico, pero desafortunadamente se ha desmoronado y ahora solo tengo la esquina superior izquierda. Su tarea será reconstruir la matriz original.

Su programa recibirá una matriz bidimensional de enteros. Para facilitar el análisis, puede suponer que todos están entre 1 y 9. Su tarea es invertir las columnas de la matriz, sus filas y ambas, unir las esquinas resultantes y devolver la matriz resultante.

Puede suponer que las dimensiones de la matriz serán al menos 1x1.

Casos de prueba:

Input:
1 2 3
4 5 6

Output:
1 2 3 3 2 1
4 5 6 6 5 4
4 5 6 6 5 4
1 2 3 3 2 1

Input:
1

Output:
1 1
1 1

Input:
9
9
9

Output:
9 9
9 9
9 9
9 9
9 9
9 9

Este es el código de golf , ¡la menor cantidad de bytes gana!

Protón , 29 bytes

a=>[b+b[by-1]for b:a+a[by-1]]

Pruébalo en línea!

Sin embargo, hay algunos otros enfoques interesantes:

Protón , 29 bytes

a=>map(g,(g=x=>x+x[by-1])(a))

Pruébalo en línea!

Puede definir la subfunción espejo gen línea, porque Protón. Sin embargo, no es más corto.

Protón , 36 bytes

(a=>[x[0]for x:zip(*(a+a[by-1]))])*2

Pruébalo en línea!

Esto debería ser de (a=>zip(*(a+a[by-1])))*224 bytes, pero la función zip está completamente rota. Básicamente, lo refleja y comprime, y luego lo hace dos veces (puede multiplicar una función por un entero positivo para aplicar la función varias veces).

Lona , 1 byte

╬

Pruébalo aquí!

Salidas como una cadena multilínea

Haskell, 25 24 bytes

r=(++)<*>reverse
r.map r

Pruébalo en línea!

Python 3, 38 bytes

lambda a:[b+b[::-1]for b in a+a[::-1]]

Pruébalo en línea!

Toma una lista de listas y devuelve una lista de listas.

Explicación:

lambda a:                              # anonymous lambda function
                   for b in a+a[::-1]  # for each row in the array and the upside-down array
          b+b[::-1]                    # the row with its reverse appended
         [                           ] # return in a list

Casco ,  7  6 bytes

Casualmente, Erik había publicado exactamente el mismo código en la sala de chat de Husk aproximadamente un minuto antes de que publicara esto.

‼oTS+↔

Pruébalo en línea!

Versión anterior, 7 bytes :

mS+↔S+↔

Retina , 13 bytes

\%`$
$^$`
Vs`

Pruébalo en línea!

Explicación

\%`$
$^$`

En cada línea ( %), haga coincidir el final de la línea ( $) e inserte el reverso ( $^) de toda la línea ( $`) e imprima el resultado con un salto de línea final ( \). Esto hace la reflexión a lo largo del eje vertical e imprime la primera mitad de la salida.

Vs`

Esto simplemente invierte toda la cadena, que es equivalente a una rotación de 180 °, o en nuestro caso (debido a la simetría horizontal) una reflexión a lo largo del eje horizontal. De esta manera, esto funciona es que Vla expresión regular predeterminada (inversa) es (?m:^.*$), que normalmente coincide con cada línea de la cadena. Sin embargo, activamos la opción de línea única s, que también hace que los saltos de .línea coincidan y, por lo tanto, esta expresión regular predeterminada coincide realmente con toda la cadena.

El resultado de esto se imprime automáticamente al final del programa, dándonos la segunda mitad de la salida.

05AB1E , 2 bytes

∞∊

Pruébalo en línea!

   # Input:Array of String | ['12','34']
---#-----------------------+------------------------------------------
∞  # Mirror horizontally.  | [12,34]       -> [1221,3443]
 ∊ # Mirror vertically.    | [1221,3443]   -> [1221\n3443\n3443\n1221]

Crédito para el Sr. Xcoder señalando que las matrices de cadenas pueden contar como matrices 2D y Pavel por confirmarlo.

Jalea , 5 bytes

m€0m0

Pruébalo en línea!

MATL , 5 bytes

,tPv!

Pruébalo en línea!

Explicación:

(implicit input)
,               # do twice:
 t              # dup top of stack
 P              # flip vertically
 v              # vertically concatenate
 !              # transpose
(implicit output)

Octava ,  33  29 bytes

¡Gracias a @Giuseppe por jugar cuatro bytes!

@(A)[B=[A;flip(A)] fliplr(B)]

Pruébalo en línea!

JavaScript (Node.js) , 62 55 49 46 bytes

A=>(j=x=>[...x,...[...x].reverse()])(A).map(j)

Pruébalo en línea!

Como Array.prototype.reverse()invierte la matriz en su lugar, primero tengo que hacer una copia superficial en algún lugar. A=>(j=x=>[...x,...x.reverse()])(A).map(j)No funciona.

J , 12 bytes

(,|.)@,.|."1

Pruébalo en línea!

Explicación

         |."1 - reverse each row
       ,.     - and stitch them to the input
 (   )@       - and 
  ,|.         - append the rows in reversed order        

awk, 88 bytes

{s="";for(i=NF;i>0;i--)s=" "$i s" "$i;a[FNR]=s;print s}END{for(i=NR;i>0;i--)print a[i]}

Triangularidad , 31 bytes.

...)...
..IEM..
.DRs+}.
DRs+...

Pruébalo en línea!

Explicación

Al eliminar los caracteres que componen el relleno, esto es lo que hace el programa:

)IEMDRs+}DRs+ – Full program. Takes a matrix as a 2D list from STDIN.
)             – Push a 0 onto the stack.
 I            – Take the input at that index.
  E           – Evaluate it.
   M    }     – For each row...
    DR        – Duplicate and replace the second copy by its reverse.
      s+      – Swap and append.
         DR   – Duplicate the result and replace the second copy by its reverse.
           s+ – Swap and append.

R , 57 bytes

function(m)rbind(N<-cbind(m,m[,ncol(m):1]),N[nrow(N):1,])

Pruébalo en línea!

APL + WIN, 11 bytes

Solicita una matriz 2D de enteros.

m⍪⊖m←m,⌽m←⎕

Stax , 5 bytes

:mm:m

Ejecútelo y depúrelo en línea

:msignifica espejo, que es input.concat(reverse(input)). m, en este contexto significa salida de cada línea después de aplicar ...

Entonces, refleje la matriz de filas y luego refleje cada fila y salida.

Japt , 6 bytes

mê1 ê1

Pruébalo aquí

Explicación

           :Implicit input of 2D array
m          :Map
 ê1        :  Mirror sub array
    ê1     :Mirror main array

Mathematica , 29 bytes

(g=#~Join~Reverse@#&)@*Map[g]

Pruébalo en línea!

SOGL V0.12 , 2 bytes

-1 byte gracias a dzaima.

╬ø

Pruébalo aquí!

APL (Dyalog Classic) , 7 bytes

⍪∘⊖⍨⊢,⌽

Pruébalo en línea!

Ruby , 35 bytes

->a{r=->b{b+b.reverse}
r[a].map &r}

Pruébalo en línea!

Una lambda que acepta una matriz 2D y devuelve una matriz 2D. Es sencillo, pero de todos modos aquí está la versión sin golf:

->a{
  r=->b{ b+b.reverse } # r is a lambda that returns the argument and its reverse
  r[a].map &r          # Add the array's reverse, then add each row's reverse
}

Java 8, 140 131 bytes

m->{String r="";for(int a=m.length,b=m[0].length,i=a+a,j;i-->0;r+="\n")for(j=b+b;j-->0;)r+=m[i<a?i:a+a+~i][j<b?j:b+b+~j];return r;}

Explicación:

Pruébalo en línea.

m->{                      // Method with integer-matrix parameter and String return-type
  String r="";            //  Result-String, starting empty
  for(int a=m.length,     //  Amount of rows of the input-matrix
          b=m[0].length,  //  Amount of columns of the input-matrix
          i=a+a,j;        //  Index integers
      i-->0;              //  Loop over double the rows
      r+="\n")            //    After every iteration: append a new-line to the result
     for(j=b+b;j-->0;)    //   Inner loop over double the columns
       r+=                //    Append the result with:
          m[i<a?          //     If `i` is smaller than the amount of rows
             i            //      Use `i` as index in the input-matrix
            :             //     Else:
             a+a+~i]      //      Use `a+a+i-1` as index instead
           [j<b?          //     If `j` is smaller than the amount of columns
             j            //      Use `j` as index in the input-matrix
            :             //     Else:
             b+b+~j];     //      Use `b+b+j-1` as index instead
  return r;}              //  Return the result-String

J , 11 bytes

Función de prefijo tácito anónimo.

|:@(,|.)^:2

Pruébalo en línea!

|: transponer

@(…) el resultado de:

 , el argumento seguido por

 |. su reverso

^:2 y todo esto hecho dos veces

SNOBOL4 (CSNOBOL4) , 119 113 bytes

	T =TABLE()
I	X =X + 1
	I =INPUT	:F(D)
	OUTPUT =T<X> =I REVERSE(I)	:(I)
D	X =X - 1
	OUTPUT =GT(X) T<X>	:S(D)
END	

Pruébalo en línea!

Toma la entrada como cadenas en STDIN, sin espacios. Esto solo funciona porque los dígitos son 1-9y fallarían de lo contrario.

C (gcc) , 114 111 bytes

• Guardado tres bytes gracias a Kevin Cruijssen ; invirtiendo los bucles.

j,i;f(A,w,h)int*A;{for(i=h+h;i-->0;puts(""))for(j=w+w;j-->0;)printf("%d,",A[(i<h?i:h+h+~i)*w+(j<w?j:w+w+~j)]);}

Pruébalo en línea!

C (gcc) , 109 bytes (abusando de la facilidad de análisis)

• Gracias a Kevin Cruijssen por sugerir que solo se permitan enteros de entrada de un dígito; Guardado dos bytes.

j,i;f(A,w,h)int*A;{for(i=h+h;i-->0;puts(""))for(j=w+w;j-->0;)putchar(A[(i<h?i:h+h+~i)*w+(j<w?j:w+w+~j)]+48);}

Pruébalo en línea!

Carbón de leña , 5 bytes

θ‖Ｃ→↓

Pruébalo en línea!

Gracias a ASCII-only por un mejor formato de entrada.

Añadir ++ , 30 bytes

D,f,@,bU€{r}B]{r}
D,r,@,dbR+

Pruébalo en línea!

El pie de página simplemente transforma la matriz anidada en el formato de la pregunta. Define una función f, que espera una matriz (matriz anidada) como argumento.

Julia 0.6 , 55 49 bytes

~i=i:-1:1
!x=[x x[:,~end];x[~end,:] x[~end,~end]]

Pruébalo en línea!

~(i)es una función para crear un corte de iabajo a 1.
Asi que~end da la rebanadaend:-1:1

!(x) es la función para hacer la reconstrucción de la matriz.

V , 12 bytes

yGæGPÎy$æ_|P

Pruébalo en línea!

Explicación:

yG              " Yank every line
  æG            " Reverse the order of the lines
    P           " Paste what we yanked
     Î          " On every line:
      y$        "   Yank the whole line
        æ_      "   Reverse the whole line
          |     "   Move to the beginning of the line
           P    "   Paste what we yanked