Para este desafío, debe escribir un programa o función que genere las diagonales de una matriz cuadrada dada. Sin embargo, si transpone las filas y columnas del código fuente de su solución, debería convertirse en un programa o función que devuelva las antidiagonales de la matriz. Siga leyendo para obtener detalles ...

Reglas

• El código fuente de su solución se considera como una cuadrícula 2D de caracteres, separados por una nueva línea estándar de su elección (salto de línea, retorno de carro o una combinación de ambos).

• Ninguna línea en su código fuente puede ser más larga que la anterior. Aquí hay algunos ejemplos de diseños válidos:

  ###
  ###
  ###
  

  ########
  #######
  ###
  ###
  #
  

  Y aquí hay un ejemplo de un diseño no válido (ya que la tercera línea es más larga que la segunda):

  ######
  ####
  #####
  ###
  

• Sus dos soluciones deben ser transpuestas entre sí, es decir, debe obtener una de la otra intercambiando filas y columnas. Aquí hay dos pares válidos:

  abc
  def
  ghi
  

  adg
  beh
  cfi
  

  Y

  print 10
  (~^_^)~
  foo
  bar
  !
  

  p(fb!
  r~oa
  i^or
  n_
  t^
   )
  1~
  0
  

  Tenga en cuenta que los espacios se tratan como cualquier otro personaje. En particular, los espacios finales son significativos ya que podrían no ser espacios finales en la transposición.

• Cada solución debe ser un programa o función que tome como entrada una matriz cuadrada no vacía de enteros de un solo dígito. Una solución debe generar una lista de todas las diagonales de la matriz y la otra debe generar una lista de todas las antidiagoniales. Puede usar cualquier formato de entrada y salida razonable y sin ambigüedades, pero deben ser idénticos entre las dos soluciones (esto también significa que deben ser ambas funciones o ambos programas).

• Cada diagonal se extiende desde la parte superior izquierda a la parte inferior derecha, y deben ordenarse de arriba a abajo.
• Cada antidiagonal se extiende desde la parte inferior izquierda hasta la parte superior derecha, y deben ordenarse de arriba hacia abajo.

Tanteo

Para fomentar soluciones que sean tan "cuadradas" como sea posible, el puntaje principal es el número de filas o el número de columnas de su solución, lo que sea mayor . Menos es mejor. Los lazos se rompen por la cantidad de caracteres en la solución, sin contar las nuevas líneas. De nuevo, menos es mejor. Ejemplo:

abcd
efg
h

Esto y su transposición tendrían un puntaje primario de 4 (ya que hay 4 columnas) y un puntaje de desempate de 8 (ya que hay 8 caracteres que no son de nueva línea). Cite ambos valores en el encabezado de su respuesta.

Casos de prueba

La tarea real realizada por las dos soluciones no debería ser el desafío principal aquí, pero aquí hay dos ejemplos para ayudarlo a probar sus soluciones:

Input:
1 2 3
4 5 6
7 8 9
Diagonals:
3
2 6
1 5 9
4 8
7
Antidiagonals:
1
4 2
7 5 3
8 6
9

Input:
1 0 1 0
0 1 0 1
1 0 1 0
0 1 0 1
Diagonals:
0
1 1
0 0 0 
1 1 1 1
0 0 0
1 1
0
Antidiagonals:
1
0 0
1 1 1
0 0 0 0
1 1 1
0 0
1

Javascript, puntaje 20 14, ( 258 176 caracteres que no son de nueva línea)

///mmm()mu[=+r
///=.av=a,pr"=
///> p,>px=[ [
m=>//(yv()xp"]
m. ////.(=+]+)
map((////>y?u&
v,y)=>v//r]r:&
.map((u,x//[ur
)=>r[p=m.//p)
length-1-//],
x+y]=r[p]////
?r[p]+" "+u//
:u),r=[])&&r

y

///mmmv.)lx?:
///=.a,m=e+ru
///> pya>ny[)
m=>//()prg]p,
m. //(=([t=]r
map(//>(phr+=
(v,y//vu=-["[
)=>v.//,m1p ]
map((//x.-]")
u,x)=>r////+&
[p=x+y]////u&
=r[p]?r[p]//r
+" "+u:u),//
r=[])&&r

Fragmento de código de ejemplo:

f=

///mmm()mu[=+r
///=.av=a,pr"=
///> p,>px=[ [
m=>//(yv()xp"]
m. ////.(=+]+)
map((////>y?u&
v,y)=>v//r]r:&
.map((u,x//[ur
)=>r[p=m.//p)
length-1-//],
x+y]=r[p]////
?r[p]+" "+u//
:u),r=[])&&r

console.log(f([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]))

y

f=

///mmmv.)lx?:
///=.a,m=e+ru
///> pya>ny[)
m=>//()prg]p,
m. //(=([t=]r
map(//>(phr+=
(v,y//vu=-["[
)=>v.//,m1p ]
map((//x.-]")
u,x)=>r////+&
[p=x+y]////u&
=r[p]?r[p]//r
+" "+u:u),//
r=[])&&r

console.log(f([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]))

MATL , puntaje 10 (100 caracteres que no son de nueva línea)

%P!       
  Q&%     
  TXd!    
  %d      
     P!   
      "@% 
       Xz 
      %z  
         q
         !

Hay 10 líneas de 10 caracteres (tenga en cuenta los espacios finales).

El código anterior produce las diagonales. Pruébalo en línea!

La versión transpuesta produce los anti-diagonales. Pruébalo en línea!

Explicación

Tenga en cuenta que

• % es un símbolo de comentario que hace que se ignore el resto de la línea.

• Las funciones de dos caracteres como Xdno se pueden dividir en an Xy a den líneas consecutivas.

Código original

El código original, linealizado y sin la parte comentada, es

Q&TXd!P!"@Xzq!

que funciona de la siguiente manera:

Q      % Implicit input. Add 1 to each entry to make them positive
&      % This modifes default inputs/ouputs of next function, which is Xd
       % Specifically, it specifies 2 inputs and 1 ouput
T      % Push true
Xd     % Diagonals of matrix. With second input true, it gives all diagonals,
       % starting from below. The columns are arranged as columns of a matrix,
       % padding with zeros
!P!    % Flip horizontally. This is to produce the correct display order
"      % For each column
  @    %   Push current column
  Xz   %   Remove zeros
  q    %   Subtract 1
  !    %   Transpose into a row
       % Implicit end. Implicit display of stack contents

Código transpuesto

El código transpuesto, linealizado, es

P!QT&Xd!P!"@Xzq!

que tiene las siguientes dos diferencias en comparación con el código original:

• Ty &se intercambian Esto no tiene ningún efecto, porque Tes un literal, no una función, por lo que no intercepta la &especificación.
• P! se agrega al principio.

El código agregado modifica la matriz de entrada para que las diagonales de la matriz modificada sean las antiagoniales de la entrada:

P      % Implicit input. Flip vertically
!      % Transpose

Jelly , puntaje 7, 49 bytes que no son de nueva línea

Programa de impresión diagonal

......U
......Œ
......D
......ṙ
......L
......Ṛ
ŒDṙLṚUU

Pruébalo en línea!

Programa de impresión anti-diagonal

......Œ
......D
......ṙ
......L
......Ṛ
......U  
UŒDṙLṚU

Pruébalo en línea!

Respuesta anterior (salida desordenada), puntaje 3, 6 bytes que no son de nueva línea

Programa de impresión diagonal

UU
UŒ
ŒD

Pruébalo en línea!

Programa de impresión anti-diagonal

UUŒ
UŒD

Pruébalo en línea!

Jelly , puntuación 4 (12 caracteres)

^{puntuaciones anteriores: 5 (16 caracteres), 4 (16 caracteres)}

Original

ŒDṙṚ
D  ñ
ṙLñL

Pruébalo en línea!

Transponer

ŒDṙ
D L
ṙ ñ
ṚñL

Pruébalo en línea!

Fondo

Diagonales

La forma directa de obtener las diagonales (de arriba a abajo) de una matriz cuadrada es la siguiente.

ŒDṙLṚ

Para una matriz de entrada M , ŒDenumera las diagonales de M , comenzando con la diagonal principal y avanzando hacia arriba.

Para la entrada

1 2 3
4 5 6
7 8 9

esto produce

1 5 9
2 6
3
7
4 8

ṙLluego calcula la longitud de M con Ly rota las unidades de longitud del resultado (M) a la izquierda.

Para nuestro ejemplo, la longitud es 3 y obtenemos

7
4 8
1 5 9
2 6
3

Finalmente, Ṛinvierte el orden de las diagonales, regresando

3
2 6
1 5 9
4 8
7

para nuestro ejemplo de entrada.

Anti-diagonales

Se pueden usar los mismos bloques de construcción para obtener los antiagoniales (de nuevo, de arriba a abajo) de una matriz cuadrada.

ṚŒDṙL

Para una matriz de entrada M , Ṛprimero invierte el orden de las filas.

Para la entrada

1 2 3
4 5 6
7 8 9

esto produce

7 8 9
4 5 6
1 2 3

Como antes, ŒDṙLgenera las diagonales (de abajo a arriba) del resultado.

Para nuestro ejemplo, esto devuelve

1
4 2
7 5 3
8 6
9

como se desee.

Cómo funciona

En Jelly, cada línea define un enlace (función). En particular, la última línea define el enlace principal , que se ejecuta cuando se inicia el programa.

Se deben llamar otros enlaces. Esta respuesta utiliza ñ, que ejecuta el siguiente enlace de forma periódica. ñse ajusta, por lo que cuando se llama desde el enlace principal, ejecuta el enlace en la primera línea.

Original

El enlace principal

ṙLñL

toma una matriz de entrada M , calcula su longitud con L, luego gira las unidades de longitud de entrada (M) a la izquierda con ṙ(tenga en cuenta que esto no altera M ), y finalmente llama al primer enlace con el resultado ( M ) y la longitud ( M) como argumentos.

El primer enlace

ŒDṙṚ

calcula las diagonales de M con ŒD(como se ve en la sección anterior), gira las unidades de longitud del resultado (M) a la izquierda con ṙ, y luego invierte el orden del resultado con Ṛ.

El segundo enlace nunca se llama.

Transponer

El enlace principal

 ṚñL

toma una matriz de entrada M y calcula su reversa con Ṛ. Luego calcula la longitud de M con Ly llama al primer enlace con argumentos inverso (M) y longitud (M) .

El primer enlace

ŒDṙ

luego calcula las diagonales del reverso (M) conŒD (como se vio en la sección anterior), y finalmente gira las unidades de longitud del resultado (M) a la izquierda con ṙ.

Los enlaces restantes nunca se llaman.

R, puntaje 14 13 11 ( 99 95 caracteres no de línea nueva)

Gracias a @Giuseppe por mejorar la puntuación en 1. Eliminó algunos caracteres al hacer uso de redundancias en las transposiciones. ¡Actualmente el mejor puntaje para un idioma que no es de golf!

######`,scr
`::`(#:fpoo
pryr,#:)llw
f)(###`(i((
split (#tmm
p,col(p#())
)+row#r#m-)
(p)))#y#,#)
######r

Y transpuesto:

#`pfsp)(#
#:r)p,+p#
#:y(lcr)#
#`r#ioo)#
#(,#tlw)#
#### (###
`::`(pryr
,f)(####
split(m,
col(m)-#
row(m)))

Pruébalo en línea!

Casco , 7 9 4 caracteres, puntaje 4 3

∂T
m
↔

Pruébalo en línea!

-4 caracteres gracias a BMO .