Per questa sfida, dovresti scrivere un programma o una funzione che emetta le diagonali di una data matrice quadrata. Tuttavia, se trasponi le righe e le colonne del codice sorgente della tua soluzione, dovrebbe invece diventare un programma o una funzione che restituisce gli antidiagonali della matrice. Continua a leggere per dettagli ...

Regole

• Il codice sorgente della tua soluzione è considerato come una griglia 2D di caratteri, separati da una nuova riga standard di tua scelta (avanzamento riga, ritorno a capo o una combinazione di entrambi).

• Nessuna riga nel codice sorgente potrebbe essere più lunga della precedente. Ecco alcuni esempi di layout validi:

  ###
  ###
  ###
  

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

  Ed ecco un esempio di layout non valido (poiché la terza riga è più lunga della seconda):

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

• Le tue due soluzioni dovrebbero essere reciprocamente trasposte, ovvero dovresti ottenere l'una dall'altra scambiando righe e colonne. Ecco due coppie valide:

  abc
  def
  ghi
  

  adg
  beh
  cfi
  

  E

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

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

  Nota che gli spazi sono trattati come qualsiasi altro personaggio. In particolare, gli spazi finali sono significativi in ​​quanto potrebbero non essere spazi finali nella trasposizione.

• Ogni soluzione dovrebbe essere un programma o una funzione che accetta come input una matrice quadrata non vuota di numeri interi a una cifra. Una soluzione dovrebbe generare un elenco di tutte le diagonali della matrice e l'altra dovrebbe generare un elenco di tutti gli antidiagonali. È possibile utilizzare qualsiasi formato di input e output ragionevole e inequivocabile, ma devono essere identici tra le due soluzioni (ciò significa anche che devono essere entrambe le funzioni o entrambi i programmi).

• Ogni diagonale va dall'alto in alto a sinistra in basso a destra e dovrebbero essere ordinate dall'alto verso il basso.
• Ogni antidiagonale scorre dal basso a sinistra in alto a destra e dovrebbero essere ordinate dall'alto verso il basso.

punteggio

Per incoraggiare soluzioni il più "quadrate" possibile, il punteggio principale è il numero di righe o il numero di colonne della soluzione, a seconda di quale sia maggiore . Meno è meglio. I legami sono interrotti dal numero di caratteri nella soluzione, senza contare le nuove righe. Ancora una volta, meno è meglio. Esempio:

abcd
efg
h

Questa e la sua trasposizione avrebbero un punteggio primario di 4 (in quanto vi sono 4 colonne) e un punteggio di 8 (in quanto vi sono 8 caratteri non di nuova riga). Si prega di citare entrambi i valori nell'intestazione della risposta.

Casi test

Il vero compito svolto dalle due soluzioni non dovrebbe essere la sfida principale qui, ma qui ci sono due esempi per aiutarti a testare le tue soluzioni:

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, punteggio 20 14, ( 258 176 caratteri non di nuova riga)

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

Esempio di frammento di codice:

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 , punteggio 10 (100 caratteri non newline)

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

Ci sono 10 righe di 10 caratteri (notare gli spazi finali).

Il codice sopra produce le diagonali. Provalo online!

La versione trasposta produce anti-diagonali. Provalo online!

Spiegazione

Nota che

• % è un simbolo di commento, che fa ignorare il resto della riga.

• Le funzioni a due caratteri come Xdnon possono essere suddivise in una Xe una din righe consecutive.

Codice originale

Il codice originale, linearizzato e senza la parte commentata, è

Q&TXd!P!"@Xzq!

che funziona come segue:

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

Codice trasposto

Il codice trasposto, linearizzato, è

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

che presenta le seguenti due differenze rispetto al codice originale:

• Te &vengono scambiati. Questo non ha alcun effetto, perché Tè letterale, non una funzione, quindi non intercetta le &specifiche.
• P! viene aggiunto all'inizio.

Il codice aggiunto modifica la matrice di input in modo che le diagonali della matrice modificata siano le anti-diagonali dell'input:

P      % Implicit input. Flip vertically
!      % Transpose

Jelly , punteggio 7, 49 byte non newline

Programma di stampa diagonale

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

Provalo online!

Programma di stampa anti-diagonale

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

Provalo online!

Risposta precedente (output non ordinato), punteggio 3, 6 byte non newline

Programma di stampa diagonale

UU
UŒ
ŒD

Provalo online!

Programma di stampa anti-diagonale

UUŒ
UŒD

Provalo online!

Jelly , punteggio 4 (12 caratteri)

^{punteggi precedenti: 5 (16 caratteri), 4 (16 caratteri)}

Originale

ŒDṙṚ
D  ñ
ṙLñL

Provalo online!

Trasporre

ŒDṙ
D L
ṙ ñ
ṚñL

Provalo online!

sfondo

diagonali

Il modo più semplice per ottenere le diagonali (dalla più alta alla più bassa) di una matrice quadrata è il seguente.

ŒDṙLṚ

Per una matrice di input M , ŒDelenca le diagonali di M , che iniziano con la diagonale principale e si spostano verso l'alto.

Per l'input

1 2 3
4 5 6
7 8 9

questo cede

1 5 9
2 6
3
7
4 8

ṙLquindi calcola la lunghezza di M con Le ruota le unità di lunghezza del risultato (M) a sinistra.

Per il nostro esempio, la lunghezza è 3 e otteniamo

7
4 8
1 5 9
2 6
3

Infine, Ṛinverte l'ordine delle diagonali, ritornando

3
2 6
1 5 9
4 8
7

per il nostro esempio di input.

Anti-diagonali

Gli stessi elementi costitutivi possono essere utilizzati per ottenere le anti-diagonali (di nuovo, dall'alto verso il basso) di una matrice quadrata.

ṚŒDṙL

Per una matrice di input M , per Ṛprima cosa inverte l'ordine delle righe.

Per l'input

1 2 3
4 5 6
7 8 9

questo cede

7 8 9
4 5 6
1 2 3

Come prima, ŒDṙLgenera le diagonali (dal basso verso l'alto) del risultato.

Per il nostro esempio, questo ritorna

1
4 2
7 5 3
8 6
9

come desiderato.

Come funziona

In Jelly, ogni riga definisce un collegamento (funzione). In particolare, l'ultima riga definisce il collegamento principale , che viene eseguito all'avvio del programma.

È necessario chiamare altri collegamenti. Questa risposta utilizza ñ, che esegue il collegamento in basso in modo dinamico. ñsi avvolge, quindi quando viene chiamato dal collegamento principale, esegue il collegamento sulla prima riga.

Originale

Il collegamento principale

ṙLñL

prende una matrice di input M , calcola la sua lunghezza con L, quindi ruota le unità di lunghezza di input (M) a sinistra con ṙ(nota che questo non altera M ) e infine chiama il primo link con il risultato ( M ) e la lunghezza ( M) come argomenti.

Il primo link

ŒDṙṚ

calcola le diagonali di M con ŒD(come visto nella sezione precedente), ruota le unità di lunghezza del risultato (M) a sinistra con ṙ, quindi inverte l'ordine del risultato con Ṛ.

Il secondo collegamento non viene mai chiamato.

Trasporre

Il collegamento principale

 ṚñL

prende una matrice di input M e calcola il suo contrario con Ṛ. Calcola quindi la lunghezza di M con Le chiama il primo collegamento con argomenti reverse (M) e length (M) .

Il primo link

ŒDṙ

calcola quindi le diagonali di reverse (M) con ŒD(come visto nella sezione precedente) e infine ruota le unità di lunghezza del risultato (M) a sinistra con ṙ.

I collegamenti rimanenti non vengono mai chiamati.

R, punteggio 14 13 11 ( 99 95 caratteri non newline)

Grazie a @Giuseppe per aver migliorato il punteggio di 1. Rasato alcuni personaggi facendo uso di ridondanze nelle trasposizioni. Attualmente il miglior punteggio per una lingua non golf!

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

E trasposto:

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

Provalo online!

Husk , 7 9 4 personaggi, punteggio 4 3

∂T
m
↔

Provalo online!

-4 personaggi grazie a BMO .