Para esse desafio, você deve escrever um programa ou função que produza as diagonais de uma determinada matriz quadrada. No entanto, se você transpõe as linhas e colunas do código-fonte da sua solução, ele deve se tornar um programa ou função que retorna as antidiagonais da matriz. Leia para detalhes ...

Regras

• O código-fonte da sua solução é considerado como uma grade 2D de caracteres, separada por uma nova linha padrão de sua escolha (avanço de linha, retorno de carro ou uma combinação de ambos).

• Nenhuma linha no seu código-fonte pode ser maior que a anterior. Aqui estão alguns exemplos de layouts válidos:

  ###
  ###
  ###
  

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

  E aqui está um exemplo de um layout inválido (como a terceira linha é maior que a segunda):

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

• Suas duas soluções devem ser a transposição uma da outra, ou seja, você deve obter uma da outra trocando linhas e colunas. Aqui estão dois pares válidos:

  abc
  def
  ghi
  

  adg
  beh
  cfi
  

  E

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

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

  Observe que os espaços são tratados como qualquer outro caractere. Em particular, os espaços finais são significativos, pois podem não ser espaços finais na transposição.

• Cada solução deve ser um programa ou função que recebe como entrada uma matriz quadrada não vazia de números inteiros de um dígito. Uma solução deve exibir uma lista de todas as diagonais da matriz e a outra deve exibir uma lista de todas as antidiagonais. Você pode usar quaisquer formatos razoáveis ​​e inequívocos de entrada e saída, mas eles devem ser idênticos entre as duas soluções (isso também significa que eles precisam ser as duas funções ou os dois programas).

• Cada diagonal é executada da parte superior esquerda para a parte inferior direita e deve ser solicitada de cima para baixo.
• Cada antidiagonal é executado da parte inferior esquerda para a parte superior direita e deve ser pedido de cima para baixo.

Pontuação

Para incentivar soluções o mais "quadradas" possível, a pontuação principal é o número de linhas ou o número de colunas da sua solução, o que for maior . Menos é melhor. Os laços são quebrados pelo número de caracteres na solução, sem contar as novas linhas. Novamente, menos é melhor. Exemplo:

abcd
efg
h

Isso e sua transposição teriam uma pontuação primária de 4 (pois existem 4 colunas) e uma pontuação de desempate de 8 (pois existem 8 caracteres que não são de nova linha). Cite os dois valores no cabeçalho da sua resposta.

Casos de teste

A tarefa real realizada pelas duas soluções não deve ser o principal desafio aqui, mas aqui estão dois exemplos para ajudá-lo a testar suas soluções:

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, pontuação 20 14, ( 258 176 caracteres não-nova linha)

///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

e

///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

Exemplo de trecho de código:

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]
]))

e

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 , pontuação 10 (100 caracteres que não são de nova linha)

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

Existem 10 linhas de 10 caracteres (observe os espaços à direita).

O código acima produz as diagonais. Experimente online!

A versão transposta produz as antiagonais. Experimente online!

Explicação

Observe que

• % é um símbolo de comentário, que faz com que o restante da linha seja ignorado.

• Funções de dois caracteres, como Xdnão podem ser divididas em um Xe dem linhas consecutivas.

Código original

O código original, linearizado e sem a parte comentada, é

Q&TXd!P!"@Xzq!

que funciona da seguinte maneira:

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 transposto

O código transposto, linearizado, é

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

que possui as duas diferenças a seguir em relação ao código original:

• Te &são trocados. Isso não tem efeito, porque Té literal, não é uma função, portanto não intercepta a &especificação.
• P! é adicionado no início.

O código adicionado modifica a matriz de entrada para que as diagonais da matriz modificada sejam as antiagonais da entrada:

P      % Implicit input. Flip vertically
!      % Transpose

Geleia , pontuação 7, 49 bytes que não são de nova linha

Programa de impressão diagonal

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

Experimente online!

Programa de impressão anti-diagonal

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

Experimente online!

Resposta mais antiga (saída não ordenada), pontuação 3, 6 bytes que não são de nova linha

Programa de impressão diagonal

UU
UŒ
ŒD

Experimente online!

Programa de impressão anti-diagonal

UUŒ
UŒD

Experimente online!

Geléia , pontuação 4 (12 caracteres)

^{pontuações anteriores: 5 (16 caracteres), 4 (16 caracteres)}

Original

ŒDṙṚ
D  ñ
ṙLñL

Experimente online!

Transpor

ŒDṙ
D L
ṙ ñ
ṚñL

Experimente online!

fundo

Diagonais

A maneira direta de obter as diagonais (de cima para baixo) de uma matriz quadrada é a seguinte.

ŒDṙLṚ

Para uma matriz de entrada M , ŒDlista as diagonais de M , começando pela diagonal principal e movendo-se para cima.

Para a entrada

1 2 3
4 5 6
7 8 9

isso produz

1 5 9
2 6
3
7
4 8

ṙLentão calcula o comprimento de M com Le gira as unidades de comprimento de resultado (M) para a esquerda.

Para o nosso exemplo, o comprimento é 3 e obtemos

7
4 8
1 5 9
2 6
3

Finalmente, Ṛinverte a ordem das diagonais, retornando

3
2 6
1 5 9
4 8
7

para o nosso exemplo de entrada.

Anti-diagonais

Os mesmos blocos de construção podem ser usados ​​para obter as antiagonais (novamente, de cima para baixo) de uma matriz quadrada.

ṚŒDṙL

Para uma matriz de entrada M , Ṛprimeiro inverta a ordem das linhas.

Para a entrada

1 2 3
4 5 6
7 8 9

isso produz

7 8 9
4 5 6
1 2 3

Como antes, ŒDṙLgera as diagonais (de baixo para cima) do resultado.

Para o nosso exemplo, isso retorna

1
4 2
7 5 3
8 6
9

como desejado.

Como funciona

No Jelly, cada linha define um link (função). Em particular, a última linha define o link principal , que é executado quando o programa é iniciado.

Outros links devem ser chamados. Esta resposta usa ñ, que executa o link abaixo de forma diádica. ñenvolve, então, quando é chamado a partir do link principal, ele executa o link na primeira linha.

Original

O link principal

ṙLñL

pega uma matriz de entrada M , calcula seu comprimento com L, depois gira as unidades de comprimento de entrada (M) para a esquerda com ṙ(observe que isso não altera M ) e, finalmente, chama o primeiro link com o resultado ( M ) e comprimento ( M) como argumentos.

O primeiro link

ŒDṙṚ

calcula as diagonais de M com ŒD(como visto na seção anterior), gira as unidades de comprimento do resultado (M) para a esquerda com ṙe inverte a ordem do resultado com Ṛ.

O segundo link nunca é chamado.

Transpor

O link principal

 ṚñL

pega uma matriz de entrada M e calcula seu inverso com Ṛ. Ele calcula o comprimento de M com Le chama o primeiro link com argumentos reverso (M) e comprimento (M) .

O primeiro link

ŒDṙ

depois calcula as diagonais de reversão (M) com ŒD(como visto na seção anterior) e, finalmente, gira as unidades de comprimento do resultado (M) para a esquerda com ṙ.

Os links restantes nunca são chamados.

R, pontuação 14 13 11 ( 99 95 caracteres não-nova linha)

Obrigado a @ Giuseppe por melhorar a pontuação em 1. Retirei alguns caracteres usando redundâncias nas transposições. Atualmente, a melhor pontuação para um idioma não-golfe!

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

E transposto:

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

Experimente online!

Husk , 7 9 4 caracteres, pontuação 4 3

∂T
m
↔

Experimente online!

-4 caracteres graças ao BMO .