สำหรับความท้าทายนี้คุณควรเขียนโปรแกรมหรือฟังก์ชั่นที่ส่งออกเส้นทแยงมุมของเมทริกซ์จตุรัสที่กำหนด อย่างไรก็ตามถ้าคุณแปลงแถวและคอลัมน์ของซอร์สโค้ดของโซลูชันมันควรจะกลายเป็นโปรแกรมหรือฟังก์ชั่นซึ่งจะคืนค่าแอนดิคาริกันของเมทริกซ์ อ่านต่อไปสำหรับเฉพาะ ...

กฎระเบียบ

• ซอร์สโค้ดของโซลูชันของคุณถือเป็นตารางอักขระ 2 ตัวคั่นด้วยบรรทัดใหม่มาตรฐานที่คุณเลือก (ตัวป้อนบรรทัดการขึ้นบรรทัดใหม่หรือการรวมกันของทั้งคู่)

• ไม่มีบรรทัดในซอร์สโค้ดของคุณอาจยาวกว่าบรรทัดก่อนหน้า นี่คือตัวอย่างของรูปแบบที่ถูกต้อง:

  ###
  ###
  ###
  

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

  และนี่คือตัวอย่างของรูปแบบที่ไม่ถูกต้อง (เนื่องจากบรรทัดที่สามยาวกว่าสอง):

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

• โซลูชันทั้งสองของคุณควรเป็นการแปลงข้อมูลของกันและกันนั่นคือคุณควรได้มาจากอีกวิธีหนึ่งโดยการสลับแถวและคอลัมน์ นี่คือคู่ที่ถูกต้องสองคู่:

  abc
  def
  ghi
  

  adg
  beh
  cfi
  

  และ

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

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

  โปรดทราบว่าช่องว่างได้รับการปฏิบัติเหมือนตัวละครอื่น ๆ โดยเฉพาะอย่างยิ่งช่องว่างต่อท้ายมีความสำคัญเนื่องจากอาจไม่มีช่องว่างต่อท้ายในการแปลง

• แต่ละโซลูชันควรเป็นโปรแกรมหรือฟังก์ชั่นซึ่งใช้เมทริกซ์จตุรัสที่ไม่ว่างของจำนวนเต็มหลักเดียวเป็นอินพุต ทางออกหนึ่งควรแสดงรายการของเส้นทแยงมุมทั้งหมดของเมทริกซ์และอีกวิธีหนึ่งควรแสดงรายการของตัวต้านทานทั้งหมด คุณอาจใช้รูปแบบอินพุตและเอาต์พุตที่สมเหตุสมผลไม่ต้องคลุมเครือ แต่ต้องมีรูปแบบที่เหมือนกันระหว่างสองโซลูชัน

• เส้นทแยงมุมแต่ละเส้นวิ่งจากซ้ายไปขวาล่างและควรสั่งจากบนลงล่าง
• เส้นทแยงมุมแต่ละเส้นวิ่งจากล่างซ้ายไปขวาบนและควรสั่งจากบนลงล่าง

เกณฑ์การให้คะแนน

เพื่อส่งเสริมให้มีการแก้ปัญหาที่เป็น "สแควร์" เป็นไปได้คะแนนหลักคือจำนวนของแถวหรือจำนวนคอลัมน์ของการแก้ปัญหาของคุณแล้วแต่จำนวนใดจะมีขนาดใหญ่ น้อยกว่าดีกว่า ความสัมพันธ์ถูกแบ่งตามจำนวนอักขระในโซลูชันไม่ใช่การนับบรรทัดใหม่ อีกครั้งน้อยกว่าดีกว่า ตัวอย่าง:

abcd
efg
h

สิ่งนี้และการถ่ายโอนของมันจะมีคะแนนหลัก4 (เนื่องจากมี 4 คอลัมน์) และคะแนนการแบ่งที่8 (เนื่องจากมี 8 อักขระที่ไม่ใช่บรรทัดใหม่) โปรดอ้างอิงค่าทั้งสองในส่วนหัวของคำตอบของคุณ

กรณีทดสอบ

งานจริงที่ดำเนินการโดยสองโซลูชันไม่ควรเป็นความท้าทายหลักที่นี่ แต่นี่เป็นสองตัวอย่างที่จะช่วยคุณทดสอบวิธีแก้ปัญหาของคุณ:

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, คะแนน20 14, ( 258 176 ตัวอักษรที่ไม่ใช่บรรทัดใหม่)

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

และ

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

ตัวอย่างข้อมูลโค้ด:

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

และ

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 , คะแนน 10 (100 ตัวอักษรที่ไม่ใช่บรรทัดใหม่)

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

มี 10 บรรทัด 10 ตัวอักษร (หมายเหตุช่องว่างต่อท้าย)

รหัสข้างต้นก่อให้เกิดเส้นทแยงมุม ลองออนไลน์!

รุ่น transposed ผลิตต่อต้านเส้นทแยงมุม ลองออนไลน์!

คำอธิบาย

สังเกตได้ว่า

• % เป็นสัญลักษณ์ความคิดเห็นซึ่งทำให้ส่วนที่เหลือของบรรทัดถูกละเว้น

• ฟังก์ชั่นสองอักขระเช่นXdไม่สามารถแยกออกเป็นXและdในลำดับต่อเนื่อง

รหัสเดิม

รหัสต้นฉบับเป็นเส้นตรงและไม่มีส่วนที่แสดงความคิดเห็นคือ

Q&TXd!P!"@Xzq!

ซึ่งทำงานดังนี้:

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

รหัส transposed

รหัส transposed เป็นเส้นตรงเป็น

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

ซึ่งมีสองข้อแตกต่างต่อไปนี้เมื่อเปรียบเทียบกับรหัสต้นฉบับ:

• Tและ&มีการแลกเปลี่ยน สิ่งนี้ไม่มีผลกระทบเพราะTเป็นตัวอักษรไม่ใช่ฟังก์ชั่นดังนั้นจึงไม่ขัดขวาง&ข้อมูลจำเพาะ
• P! เพิ่มที่จุดเริ่มต้น

รหัสเพิ่มแก้ไขเมทริกซ์การป้อนข้อมูลเพื่อให้ diagonals ของเมทริกซ์ที่แก้ไขเป็น anti-diagonals ของอินพุต:

P      % Implicit input. Flip vertically
!      % Transpose

เยลลี่ , คะแนน 7, 49 ไบต์ที่ไม่ใช่บรรทัดใหม่

โปรแกรมการพิมพ์แนวทแยง

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

ลองออนไลน์!

โปรแกรมต่อต้านการพิมพ์เส้นทแยงมุม

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

ลองออนไลน์!

คำตอบที่เก่ากว่า (เอาต์พุตที่ไม่เรียงลำดับ) คะแนน 3, 6 ไบต์ที่ไม่ใช่บรรทัดใหม่

โปรแกรมการพิมพ์ในแนวทแยง

UU
UŒ
ŒD

ลองออนไลน์!

โปรแกรมการพิมพ์แนวทแยง

UUŒ
UŒD

ลองออนไลน์!

เยลลี่ , คะแนน 4 (12 ตัวอักษร)

^{คะแนนก่อนหน้า: 5 (16 ตัวอักษร), 4 (16 ตัวอักษร)}

เป็นต้นฉบับ

ŒDṙṚ
D  ñ
ṙLñL

ลองออนไลน์!

ไขว้

ŒDṙ
D L
ṙ ñ
ṚñL

ลองออนไลน์!

พื้นหลัง

เส้นทแยงมุม

วิธีการได้รับ diagonals (จากบนลงล่างสุดถึงสุด) ของเมทริกซ์จตุรัสมีความตรงไปตรงมาดังนี้

ŒDṙLṚ

สำหรับอินพุตเมทริกซ์Mให้ŒDแสดงรายการMเส้นทแยงมุมของโดยเริ่มจากเส้นทแยงมุมหลักและเลื่อนขึ้นไปด้านบน

สำหรับการป้อนข้อมูล

1 2 3
4 5 6
7 8 9

อัตราผลตอบแทนนี้

1 5 9
2 6
3
7
4 8

ṙLจากนั้นคำนวณความยาวของMด้วยLและหมุนความยาวผลลัพธ์(M)ไปทางซ้าย

สำหรับตัวอย่างของเราความยาวคือ3และเราได้

7
4 8
1 5 9
2 6
3

ในที่สุดṚฝืนคำสั่งของเส้นทแยงมุมกลับ

3
2 6
1 5 9
4 8
7

สำหรับอินพุตตัวอย่างของเรา

ป้องกันเส้นทแยงมุม

สามารถใช้ Building Block แบบเดียวกันเพื่อรับการลดทอนของเส้นทแยงมุม

ṚŒDṙL

สำหรับการป้อนข้อมูลเมทริกซ์M ,Ṛแรกฝืนคำสั่งของแถว

สำหรับการป้อนข้อมูล

1 2 3
4 5 6
7 8 9

อัตราผลตอบแทนนี้

7 8 9
4 5 6
1 2 3

ก่อนหน้านี้ŒDṙLสร้าง diagonals (ส่วนใหญ่ไปด้านบนสุด) ของผลลัพธ์

สำหรับตัวอย่างของเราผลตอบแทนนี้

1
4 2
7 5 3
8 6
9

ตามที่ต้องการ

มันทำงานอย่างไร

ใน Jelly แต่ละบรรทัดจะกำหนดลิงก์ (ฟังก์ชั่น) โดยเฉพาะอย่างยิ่งบรรทัดสุดท้ายจะกำหนดลิงก์หลักซึ่งจะถูกดำเนินการเมื่อโปรแกรมเริ่มทำงาน

ลิงค์อื่น ๆ จะต้องถูกเรียก คำตอบนี้ใช้ñซึ่งดำเนินการลิงค์ด้านล่างอย่างผิดเพี้ยน ñล้อมรอบดังนั้นเมื่อถูกเรียกจากลิงก์หลักจะเรียกใช้งานลิงก์ในบรรทัดแรก

เป็นต้นฉบับ

ลิงค์หลัก

ṙLñL

ใช้อินพุตเมทริกซ์MคำนวณความยาวของมันLจากนั้นหมุนหน่วยความยาวอินพุต(M)ไปทางซ้ายด้วยṙ(โปรดสังเกตว่าสิ่งนี้ไม่เปลี่ยนM ) และสุดท้ายเรียกลิงก์แรกที่มีผลลัพธ์ ( M ) และความยาว ( M)เป็นอาร์กิวเมนต์

ลิงค์แรก

ŒDṙṚ

คำนวณเส้นทแยงมุมของMด้วยŒD(เท่าที่เห็นในส่วนก่อนหน้า), หมุนผลยาว (M)หน่วยไปทางซ้ายด้วยแล้วฝืนคำสั่งของผลที่มีṙṚ

ลิงค์ที่สองจะไม่ถูกเรียก

ไขว้

ลิงค์หลัก

 ṚñL

ยิงใส่เมทริกซ์MṚและคำนวณย้อนกลับด้วย จากนั้นจะคำนวณความยาวของMด้วยLและเรียกร้องลิงค์แรกที่มีการขัดแย้งย้อนกลับ (M)และความยาว (M)

ลิงค์แรก

ŒDṙ

แล้วคำนวณเส้นทแยงมุมของย้อนกลับ (M)กับŒD(เท่าที่เห็นในส่วนก่อนหน้า) และในที่สุดก็หมุนผลยาว (M)ṙหน่วยไปทางซ้ายด้วย

ลิงค์ที่เหลือจะไม่ถูกเรียก

R, คะแนน14 13 11 ( 99 95 อักขระที่ไม่ใช่บรรทัดใหม่)

ขอบคุณ @Giuseppe สำหรับการปรับปรุงคะแนนโดย 1 กำจัดอักขระบางตัวโดยใช้ประโยชน์จากความซ้ำซ้อนในการเปลี่ยนถ่าย ปัจจุบันคะแนนที่ดีที่สุดสำหรับภาษาที่ไม่ใช่กอล์ฟ!

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

และขนย้าย:

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

ลองออนไลน์!

Husk , 7 9 4 ตัวอักษร, คะแนน4 3

∂T
m
↔

ลองออนไลน์!

-4 ขอบคุณตัวอักษรเพื่อBMO