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

ตัวอย่างเช่นถ้ากริดอินพุตของข้อความคือ

abcd
1234
WXYZ

แล้วคุณต้องการแถวเส้นทแยงมุมW, 1X, a2Y, b3z, c4และdในคอลัมน์ให้ผลลัพธ์นี้:

  ab
 123c
WXYZ4d

โปรดทราบว่าอักขระต่ำสุด - ขวาสุดของเส้นทแยงมุมทั้งหมดWXYZ4dอยู่ในระดับเดียวกัน

รายละเอียด

• ตารางอินพุตของข้อความจะมีขนาดอย่างน้อย 1 × 1 และทุกบรรทัดจะมีความยาวเท่ากัน

• คุณอาจใช้กริดอินพุตเป็นสตริงหลายบรรทัดหรือเป็นรายการของสตริงบรรทัดเดียว

• กริดอินพุตจะมีอักขระ ASCII ที่พิมพ์ได้เท่านั้น(รวมพื้นที่ว่าง)

• เอาต์พุตอาจมีทางเลือกขึ้นบรรทัดใหม่หนึ่งบรรทัด แต่ไม่ควรมีบรรทัดว่างอื่น ๆ

• บรรทัดของเอาต์พุตอาจเป็นทางเลือกที่มีช่องว่างต่อท้าย แต่ไม่ควรมีช่องว่างนำหน้าที่ไม่จำเป็น

ตัวอย่างอื่น ๆ

บรรทัดว่างแยกตัวอย่าง แต่ละอินพุตจะตามด้วยเอาต์พุตโดยตรง

123
456
789

  1
 452
78963

123.?!
456??!
789!!!

  123.
 456???
789!!!!!

**@
@  

 **
@  @


/\/\
\/ /
/ /\
\/\/

   /
  \/\
 / / /
\/\/\/\

12
34
56
78
90

 7531
908642

Code

Code

G
O
L
F

FLOG

~

~

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

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

J , 12 ไบต์

|./.&.|:&.|.

กำหนดคำกริยาที่ไม่ระบุชื่อ ลองออนไลน์!

คำอธิบาย

|./.&.|:&.|.
|.            Reversed
  /.          anti-diagonals
    &.        under
      |:      transpose
        &.    under
          |.  reversal

ในเจ u &. vหมายถึง(อ่าน: uใต้v) หมายถึง "v จากนั้นเป็น u จากนั้นจะกลับกันเป็น v" การกลับรายการและการสลับเป็นตัวผกผันดังนั้นโปรแกรมจึงมีความหมายว่า "การย้อนกลับการแปลงการแยกสารต่อต้านการย้อนกลับ

ด้วยอินพุตตัวอย่าง:

abcd
1234
WXYZ

ย้อนกลับ:

WXYZ
1234
abcd

ไขว้:

W1a
X2b
Y3c
Z4d

แยกสารต่อต้านกลับเส้นทแยงมุม (และแผ่นที่มีช่องว่าง):

W  
X1 
Y2a
Z3b
4c 
d  

ไขว้:

WXYZ4d
 123c 
  ab  

ย้อนกลับ:

  ab  
 123c 
WXYZ4d

เยลลี่ 11 หรือ 10 ไบต์

ZŒDṙLUz⁶ṚUY

ลองออนไลน์!

อัลกอริธึมที่ค่อนข้างแตกต่างจากโซลูชันอื่นของฉัน อันนี้ใช้ builtin เพื่อไปที่ diagonals แทนที่จะทำสิ่งต่าง ๆ ด้วยตนเอง

คำอธิบาย:

ZŒDṙLUz⁶ṚUY
Z           transpose
 ŒD         diagonals, main diagonal first
    L       number of lines in the original array
   ṙ        rotate list (i.e. placing the short diagonal first)
     U      reverse inside lines
      z⁶    transpose, padding with spaces
        ṚU  rotate matrix 180 degrees
          Y (possibly unnecessary) join on newlines

เส้นทแยงมุมออกมาในทิศทางที่แย่ที่สุดที่เป็นไปได้ (ต้องมีการสลับตำแหน่งซ้ำการพลิกกลับและการหมุน) และในลำดับที่ไม่ถูกต้อง (เยลลี่เอาท์พุทเส้นทแยงมุมหลักก่อนดังนั้นเราต้องย้ายแนวทแยงมุมจากจุดเริ่มต้น ตามลำดับ) อย่างไรก็ตามนี่ยังคงสั้นกว่าสารละลาย Jelly ตัวอื่นของฉัน

CJam , 29 ไบต์

qN/{)\z}h]2/{~W%+}%eeSf.*W%N*

ลองออนไลน์!

คำอธิบาย

แทนที่จะแยก diagonals เราลอกเลเยอร์ออกจากปลายสลับซ้ายและขวา พิจารณาอินพุตต่อไปนี้:

GFDB
EEDB
CCCB
AAAA

ถ้าเราเขียนเส้นทแยงมุมตามความท้าทายเราจะได้:

   G
  EEF
 CCCDD
AAAABBB

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

{      e# Run this loop while there are still lines left in the input.
  )    e#   Pull off the bottom-most row.
  \    e#   Swap with the remaining rows.
  z    e#   Transpose the grid so that the next iteration pulls off the last
       e#   column instead. However, it should be noted that transposing
       e#   effectively reverses the column, so the second half of each output
       e#   line will be the wrong way around. We'll fix that later.
}h     e# When the loop is done, we'll have all the individual layers on the
       e# stack from bottom to top, alternating between horizontal and vertical
       e# layers. There will be an empty string on top.
]      e# Wrap all those strings in a list.
2/     e# Split into pairs. There may or may not be a trailing single-element
       e# list with the empty string.
{      e# Map this block over each pair...
  ~    e#   Dump the pair on the stack.
  W%   e#   Reverse the second element.
  +    e#   Append to first element.
       e#   If there was a trailing single-element list, this will simply
       e#   add the empty string to the previous pair, which just removes
       e#   the empty string.
}%
ee     e# Enumerate the list, which pairs each string (now containing both halves)
       e# of an output line from bottom to top) with its index.
Sf.*   e# Turn those indices X into strings of X spaces, to get the correct
       e# indentation.
W%     e# Reverse the list of strings so the longest line ends up on the bottom.

JavaScript, 116 101 ไบต์

f=(s,r='$&',l='',z=s.replace(/.$|\n?(?!.*\n)..+/gm,x=>(l=x+l,'')))=>l?f(z,r+' ')+l.replace(/\n?/,r):l


G.onclick=()=>O.textContent=f(I.value);

<textarea id=I style=height:100px>/\/\
\/ /
/ /\
\/\/</textarea><button id=G>Go</button><pre id=O></pre>

ฉันแค่ต้องการใช้/.$|\n?(?!.*\n)..+/gmแนวคิดรูปแบบ regex นี้ ^{( https://regex101.com/r/mjMz9i/2 )}

JavaScript รสชาติ regex เป็นที่น่าผิดหวังผมต้องใช้(?!.*\n)เพราะมันไม่ได้มีการดำเนินการอย่างใดและฉันไม่ได้รับกับการใช้งาน\Z\0

• 15 ไบต์ปิดขอบคุณ @Neil

เยลลี่ 15 หรือ 14 ไบต์

L’⁶x;\Ṛ;"µZUZṚY

ลองออนไลน์!

นี่เป็นอัลกอริทึมที่ไม่ได้ใช้ตัวเยลลี่เพื่อเป็นแนวทแยงมุม การทำเช่นนั้นอาจทำให้สั้นลง ฉันอาจลองต่อไป

นี่คือวิธีการทำงานของอัลกอริทึม เริ่มจากอินพุตนี้:

["abc",
 "def",
 "ghi"]

L’⁶x;\เราเริ่มต้นด้วย L’ให้ความยาวของอินพุทลบ 1 (ในกรณีนี้ 2) จากนั้น⁶xให้เรามีช่องว่างของความยาวนั้น ( " "ในกรณีนี้); และ;\ให้ผลลัพธ์แบบสะสมกับเราเมื่อต่อมัน (สามเหลี่ยมของช่องว่าง) จากนั้นเรากลับสามเหลี่ยมและต่อมันไปทางด้านซ้ายของต้นฉบับ ( ;"เชื่อมองค์ประกอบที่สอดคล้องกันของรายการµทำให้เกิดการหยุดในการแยกวิเคราะห์และใช้อินพุตต้นฉบับเป็นรายการที่สองตามค่าเริ่มต้น) ทำให้เรา:

["  abc",
 " def",
 "ghi"]

นี่เกือบจะเป็นทางออกที่เราต้องการ แต่เราจำเป็นต้องย้ายองค์ประกอบลงไปเพื่อล้างข้อมูลด้วยสตริงสุดท้าย นั่นเป็นเรื่องของการเปลี่ยน ( Z) การย้อนกลับภายในแต่ละบรรทัด ( U) การเปลี่ยนอีกครั้ง ( Z) และการย้อนกลับบรรทัด ( Ṛ):

["  abc",
 " def",
 "ghi"]

transpose

["  g",
 " dh",
 "aei",
 "bf",
 "c"]

ย้อนกลับภายในแถว

["g  ",
 "hd ",
 "iea",
 "fb",
 "c"]

transpose

["ghifc",
 " deb",
 "  a"]

ย้อนกลับแถว

["  a",
 " deb",
 "ghifc"]

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

Pyth, 16 ไบต์

j_.t_M.Tm+*;l=tQ

บิ๊กพี ธ :

join-on-newline
reverse transpose-and-fill-with-spaces reverse func-map transpose-justified
map
  plus
    times innermost-var
      length assign tail input
    implicit-innermost-var
  implicit-input

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

ฉันต้องการดูว่ารูปแบบการอธิบายที่ยิ่งใหญ่ของ Big Pyth คืออะไรดังนั้นฉันจะไม่อธิบายอะไรเลย ถามฉันว่าคุณต้องการอธิบายอะไรไหม

JavaScript (ES6), 140 ไบต์

a=>[...Array(m=(h=a.length)<(w=a[0].length)?h:w)].map((_,i)=>[...Array(h+w-1)].map((_,j)=>(a[x=i+h-m-(++j>w&&j-w)]||``)[x+j-h]||` `).join``)

รับอินพุตและเอาต์พุตเป็นอาร์เรย์ของสตริง ยังรับอินพุตอาร์เรย์อักขระสองมิติและบันทึก 7 ไบต์หากเอาต์พุตอาร์เรย์อักขระสองมิติเป็นที่ยอมรับ คำอธิบาย: ความสูงของผลลัพธ์mคือความสูงhและความกว้างต่ำสุดของwอาร์เรย์ดั้งเดิมในขณะที่ความกว้างนั้นน้อยกว่าผลรวมของความสูงและความกว้างของอาร์เรย์ดั้งเดิม แถวแหล่งที่มาของอักขระในส่วนหลักของผลลัพธ์มาจากแถวที่เหมาะสมของอาร์เรย์เดิมนับจากด้านล่างในขณะที่ส่วนเพิ่มเติมของผลลัพธ์แถวต้นทางจะเลื่อนขึ้นหนึ่งแถวสำหรับแต่ละคอลัมน์เพิ่มเติม คอลัมน์แหล่งที่มาสำหรับทั้งสองส่วนของผลลัพธ์จะเท่ากับคอลัมน์ปลายทางที่ย้ายไปหนึ่งคอลัมน์ที่เหลือสำหรับแต่ละแถวของแหล่งที่มาด้านบนด้านล่าง

อ็อกเทฟ, 57 ไบต์

@(A){B=spdiags(A),C=B>0,D='  '(C+1),D(sort(C))=B(C),D}{5}

Python 3, 247 ไบต์

def a(s):
 s=s.split('\n')
 for i,l in enumerate(s):r=len(s)-i-1;s[i]=' '*r+l+' '*(len(s)-r-1)
 print(*[''.join(i) for i in list(zip(*[''.join(a).rstrip([::-1].ljust(min(len(s),len(s[0])))for a in zip(*[list(i)for i in s])]))[::-1]],sep='\n')`

Python 2, 150 ไบต์

def f(l):w=len(l[0]);h=len(l);J=''.join;R=range;print'\n'.join(map(J,zip(*['%%-%ds'%h%J(l[h+~i][j-i]for i in R(h)if-w<i-j<1)for j in R(h-~w)]))[::-1])

รับอินพุตเป็นรายการของสตริง

Clojure, 194 ไบต์

ใช้งานอย่างหนักโดยจัดกลุ่มอักขระเป็น Gจากนั้นสร้างบรรทัด

#(let[n(count %)m(count(% 0))G(group-by first(for[i(range n)j(range m)][(min(- n i)(- m j))((% i)j)]))](apply str(flatten(for[k(reverse(sort(keys G)))][(repeat(dec k)" ")(map last(G k))"\n"]))))

จะเข้าเป็นvecของเหมือนvec [[\a \b \c \d] [\1 \2 \3 \4] [\W \X \Y \Z]]ตัวอย่าง:

(def f #( ... ))
(print (str "\n" (f (mapv vec(re-seq #".+" "abcd\n1234\nWXYZ")))))

  ab
 c123
d4WXYZ