Untuk tantangan ini, Anda harus menulis sebuah program atau fungsi yang menampilkan diagonal dari matriks kuadrat yang diberikan. Namun, jika Anda mengubah urutan baris dan kolom kode sumber solusi Anda, itu seharusnya menjadi program atau fungsi yang mengembalikan antidiagonal matriks. Baca terus untuk spesifik ...

Aturan

• Kode sumber solusi Anda dianggap sebagai grid karakter 2D, dipisahkan oleh baris baru standar pilihan Anda (linefeed, carriage return, atau kombinasi keduanya).

• Tidak ada baris dalam kode sumber Anda yang lebih panjang dari yang sebelumnya. Berikut adalah beberapa contoh tata letak yang valid:

  ###
  ###
  ###
  

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

  Dan berikut adalah contoh tata letak yang tidak valid (karena baris ketiga lebih panjang dari yang kedua):

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

• Dua solusi Anda harus saling transpos satu sama lain, yaitu Anda harus mendapatkan satu dari yang lain dengan menukar baris dan kolom. Berikut adalah dua pasangan yang valid:

  abc
  def
  ghi
  

  adg
  beh
  cfi
  

  Dan

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

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

  Perhatikan bahwa spasi diperlakukan seperti karakter lain. Secara khusus, spasi tambahan signifikan karena mereka mungkin bukan spasi tambahan dalam transpos.

• Setiap solusi harus berupa program atau fungsi yang menggunakan matriks kuadrat non-kosong dari bilangan bulat tunggal sebagai input. Satu solusi harus menampilkan daftar semua diagonal matriks dan solusi lainnya harus menampilkan daftar semua antidiagonal. Anda dapat menggunakan format input dan output yang masuk akal, tidak ambigu, tetapi keduanya harus identik antara kedua solusi (ini juga berarti keduanya harus merupakan fungsi atau kedua program).

• Setiap diagonal berjalan dari kiri atas ke kanan bawah, dan mereka harus dipesan dari atas ke bawah.
• Setiap antidiagonal berjalan dari kiri bawah ke kanan atas, dan mereka harus dipesan dari atas ke bawah.

Mencetak gol

Untuk mendorong solusi yang "kuadrat" mungkin, skor utama adalah jumlah baris atau jumlah kolom dari solusi Anda, mana yang lebih besar . Lebih sedikit lebih baik. Ikatan dipecah oleh jumlah karakter dalam solusi, tidak termasuk baris baru. Sekali lagi, lebih sedikit lebih baik. Contoh:

abcd
efg
h

Ini dan transposinya akan memiliki skor primer 4 (karena ada 4 kolom) dan skor tie-breaking 8 (karena ada 8 karakter non-baris baru). Harap kutip kedua nilai di tajuk jawaban Anda.

Uji Kasus

Tugas aktual yang dilakukan oleh dua solusi seharusnya tidak menjadi tantangan utama di sini, tetapi berikut adalah dua contoh untuk membantu Anda menguji solusi Anda:

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, skor 20 14, ( 258 176 karakter bukan baris baru)

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

dan

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

Cuplikan kode contoh:

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

dan

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 , skor 10 (100 karakter non-baris baru)

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

Ada 10 baris 10 karakter (perhatikan spasi tambahan).

Kode di atas menghasilkan diagonal. Cobalah online!

Versi yang dialihkan menghasilkan anti-diagonal. Cobalah online!

Penjelasan

Catat itu

• % adalah simbol komentar, yang menyebabkan sisa baris diabaikan.

• Fungsi dua karakter seperti Xdtidak dapat dibagi menjadi Xdan ddalam garis berturut-turut.

Kode asli

Kode asli, dilinearisasi dan tanpa bagian komentar, adalah

Q&TXd!P!"@Xzq!

yang berfungsi sebagai berikut:

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

Kode ditransposisikan

Kode yang ditransposisikan, dilinearisasi, adalah

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

yang memiliki dua perbedaan berikut dibandingkan dengan kode asli:

• Tdan &ditukar. Ini tidak memiliki efek, karena Tmerupakan fungsi literal, bukan fungsi, sehingga tidak memotong &spesifikasi.
• P! ditambahkan di awal.

Kode yang ditambahkan memodifikasi matriks input sehingga diagonal matriks yang dimodifikasi adalah anti-diagonal input:

P      % Implicit input. Flip vertically
!      % Transpose

Jelly , Skor 7, 49 byte bukan baris baru

Program pencetakan diagonal

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

Cobalah online!

Program pencetakan anti-diagonal

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

Cobalah online!

Jawaban Lama (Output Tidak Berurutan), Skor 3, 6 byte bukan baris baru

Program pencetakan diagonal

UU
UŒ
ŒD

Cobalah online!

Program pencetakan anti-diagonal

UUŒ
UŒD

Cobalah online!

Jelly , skor 4 (12 karakter)

^{skor sebelumnya: 5 (16 karakter), 4 (16 karakter)}

Asli

ŒDṙṚ
D  ñ
ṙLñL

Cobalah online!

Mengubah urutan

ŒDṙ
D L
ṙ ñ
ṚñL

Cobalah online!

Latar Belakang

Diagonal

Cara langsung untuk mendapatkan diagonal (paling atas hingga paling bawah) dari matriks persegi adalah sebagai berikut.

ŒDṙLṚ

Untuk matriks input M , ŒDcantumkan diagonal M , dimulai dengan diagonal utama dan bergerak ke atas.

Untuk input

1 2 3
4 5 6
7 8 9

ini menghasilkan

1 5 9
2 6
3
7
4 8

ṙLkemudian menghitung panjang M dengan Ldan memutar satuan hasil panjang (M) ke kiri.

Sebagai contoh kita, panjangnya 3 dan kita dapatkan

7
4 8
1 5 9
2 6
3

Akhirnya, Ṛmembalikkan urutan diagonal, kembali

3
2 6
1 5 9
4 8
7

untuk input contoh kami.

Anti-diagonal

Blok bangunan yang sama dapat digunakan untuk mendapatkan anti-diagonal (sekali lagi, paling atas hingga paling bawah) dari matriks persegi.

ṚŒDṙL

Untuk matriks input M ,Ṛ pertama-tama membalik urutan baris.

Untuk input

1 2 3
4 5 6
7 8 9

ini menghasilkan

7 8 9
4 5 6
1 2 3

Seperti sebelumnya, ŒDṙLhasilkan diagonal (paling bawah hingga paling atas) dari hasilnya.

Sebagai contoh kita, ini kembali

1
4 2
7 5 3
8 6
9

seperti yang diinginkan.

Bagaimana itu bekerja

Dalam Jelly, setiap baris mendefinisikan tautan (fungsi). Secara khusus, baris terakhir mendefinisikan tautan utama , yang dieksekusi ketika program dimulai.

Tautan lain harus dipanggil. Jawaban ini menggunakan ñ, yang mengeksekusi tautan di bawah ini secara dyadically. ñmembungkus, jadi ketika dipanggil dari tautan utama, ia mengeksekusi tautan di baris pertama.

Asli

Tautan utama

ṙLñL

mengambil matriks input M , menghitung panjangnya L, kemudian memutar unit panjang input (M) ke kiri dengan ṙ(perhatikan bahwa ini tidak mengubah M ), dan akhirnya memanggil tautan pertama dengan hasil ( M ) dan panjang ( M) sebagai argumen.

Tautan pertama

ŒDṙṚ

menghitung diagonal M dengan ŒD(seperti yang terlihat di bagian sebelumnya), memutar panjang hasil (M) unit ke kiri dengan ṙ, kemudian membalik urutan hasil dengan Ṛ.

Tautan kedua tidak pernah dipanggil.

Mengubah urutan

Tautan utama

 ṚñL

mengambil matriks input M dan menghitung kebalikannya Ṛ. Ini kemudian menghitung panjang M dengan Ldan memanggil tautan pertama dengan argumen reverse (M) dan length (M) .

Tautan pertama

ŒDṙ

kemudian menghitung diagonal mundur (M) dengan ŒD(seperti yang terlihat di bagian sebelumnya), dan akhirnya memutar panjang hasil (M) unit ke kiri dengan ṙ.

Tautan yang tersisa tidak pernah dipanggil.

R, skor 14 13 11 ( 99 95 karakter non-baris baru)

Terima kasih kepada @Giuseppe untuk meningkatkan skor dengan 1. Mencukur beberapa karakter dengan memanfaatkan redudansi dalam transposisi. Saat ini skor terbaik untuk bahasa non-golf!

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

Dan ditransformasikan:

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

Cobalah online!

Sekam , 7 9 4 karakter, skor 4 3

∂T
m
↔

Cobalah online!

-4 karakter terima kasih kepada BMO .