รับสแควร์สตริงผลิตผลลัพธ์ทั้งหมดสำหรับสายอักขระในทุกขั้นตอนของการคลาย

สตริงจะต้องคลี่ออกไปในทิศทางตามเข็มนาฬิกาหนึ่งครั้งในสี่รอบในแต่ละครั้ง

ตัวอย่าง

อินพุต :

A

ผลผลิต :

A

หมายเหตุ : ฉันจะยอมรับอินพุตที่ทำซ้ำสำหรับกรณีทดสอบนี้เฉพาะเมื่อสิ่งนี้ช่วยลดจำนวนไบต์ของคุณ

อินพุต :

DC
AB

ผลผลิต :

DC
AB

  D
ABC

ABCD

อินพุต :

GFE
HID
ABC

ผลผลิต :

GFE
HID
ABC

   HG
   IF
ABCDE

     IH
ABCDEFG

       I
ABCDEFGH

ABCDEFGHI

อินพุต :

JIHG
KPOF
LMNE
ABCD

ผลผลิต :

JIHG
KPOF
LMNE
ABCD

    LKJ
    MPI
    NOH
ABCDEFG

       NML
       OPK
ABCDEFGHIJ

          ON
          PM
ABCDEFGHIJKL

            PO
ABCDEFGHIJKLMN

              P
ABCDEFGHIJKLMNO

ABCDEFGHIJKLMNOP

กฎระเบียบ

นี่คือโค้ดกอล์ฟเพื่อให้โค้ดที่สั้นที่สุดเป็นไบต์ชนะ

• รูปแบบที่เหมาะสมใด ๆ สามารถใช้สำหรับ I / O สมมติว่ามันสอดคล้องกัน
• ต้องใช้ช่องว่างในการวางบรรทัดบนสุดของเอาต์พุต
• ต้องสามารถจัดการอินพุตของอักขระที่พิมพ์ได้ทั้งหมด (รวมถึงช่องว่าง: \x20- \x7e):

 !.? "# $% & '() * +, - / 0123456789:; @ ABCDEFGHIJKLMNOPQRSTUVWXYZ [\] ^ _` ABCDEFGHIJKLMNOPQRSTUVWXYZ {|} ~

• อนุญาตช่องว่างนำหน้า / ต่อท้าย
• คุณสามารถสันนิษฐานได้ว่าสตริงนั้นจะเป็นรูปสี่เหลี่ยมจัตุรัสเสมอ
• ช่องโหว่มาตรฐานทั้งหมดถูกห้าม

แรงบันดาลใจ: เขียนโปรแกรมตารางที่ผลจำนวนครั้งที่จะได้รับ“คลี่”

SOGL V0.12 , 21 20 19 18 17 ไบต์

ø;[;ο⁴№č▓┼№TJι;jI

ลองที่นี่! ( →เพิ่มเนื่องจากสิ่งนี้คาดว่าอินพุตในสแต็ก)

คำอธิบาย:

ø;[;ο⁴№č▓┼№TJι;jI
ø;               push an empty string below the input           stack with the input GFE,HID,ABC
  [              while [ToS (the array) isn't empty] do       ["", [["G","F","E"],["H","I","D"],["A","B","C"]]]  
                                                                stack at the second time looping
   ;               duplicate 2nd from top                     [[[H,G], [I,F], [D,E]], "ABC"]
    ο              wrap it in an array                        [[[H,G], [I,F], [D,E]], ["ABC"]]
     ⁴             duplicate 2nd from top                     [[[H,G], [I,F], [D,E]], ["ABC"], [[H,G], [I,F], [D,E]]]
      №            reverse vertically                         [[[H,G], [I,F], [D,E]], ["ABC"], [[D,E], [I,F], [H,G]]]
       č▓          join the inner arrays (┼ fails otherwise)  [[[H,G], [I,F], [D,E]], ["ABC"], ["DE", "IF", "HG"]]
         ┼         add the 2 parts together                   [[[H,G], [I,F], [D,E]], ["ABCDE", "   IF", "   HG"]]
          №        reverse vertically again                   [[[H,G], [I,F], [D,E]], ["   HG", "   IF", "ABCDE"]]
           T       print that without popping                 [[[H,G], [I,F], [D,E]], ["   HG", "   IF", "ABCDE"]]
            J      take the last line off                     [[[H,G], [I,F], [D,E]], ["   HG", "   IF"], "ABCDE"]
             ι     remove the rest of the array               [[[H,G], [I,F], [D,E]], "ABCDE"]
              ;j   remove the last line of the original array ["ABCDE", [[H,G], [I,F]]]
                I  rotate it clockwise                        ["ABCDE", [[I,H], [F,G]]]

Python 2 , 209 207 205 203 202 201 200 196 ไบต์

-4 ไบต์ขอบคุณ@Quelklef !

s=input();l=len;k=''.join;exec"print s;s=[x for x in[' '*l(s[0])+k(x[:-1]for x in s[-2::-1])[t::l(s[0])-1]for t in range(l(s[0]))][:-1]+[s[-1]+k(x[-1]for x in s)[-2::-1]]if x.strip()];"*(2*l(s)-1)

ลองออนไลน์!

Python 2 , 219 217 215 213 212 211 207 ไบต์

s=input();l=len;k=''.join;exec"print'\\n'.join(s);s=[x for x in[' '*l(s[0])+k(x[:-1]for x in s[-2::-1])[t::l(s[0])-1]for t in range(l(s[0]))][:-1]+[s[-1]+k(x[-1]for x in s)[-2::-1]]if x.strip()];"*(2*l(s)-1)

ลองออนไลน์!

หนึ่งรายการแรกเป็นรายการของ Strings หนึ่งรายการที่สองเป็น ASCII-art

ถ่าน , 42 35 ไบต์

ＡＥθＳθＷ⊟θ«⪫θ¶ＡＥι⮌⪫Ｅθ§μλωθ⊞υι↙←⮌⪫υωＤ⎚

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด แก้ไข: บันทึก 7 ไบต์ส่วนใหญ่โดยการเปลี่ยนจากอาร์เรย์อักขระเป็นสตริง คำอธิบาย:

ＡＥθＳθ

qอ่านตารางการป้อนข้อมูลที่เป็นอาร์เรย์ของสตริงลงในตัวแปรที่

Ｗ⊟θ«

แม้ว่าสตริงสุดท้ายในอาร์เรย์จะไม่ว่างเปล่าให้ลบออก

⪫θ¶

พิมพ์ส่วนที่เหลือของอาร์เรย์

ＡＥι⮌⪫Ｅθ§μλωθ

หมุนส่วนที่เหลือของอาร์เรย์โดยวนลูปผ่านอักขระแต่ละตัวของสตริงสุดท้ายและรวมlอักขระ th ของสตริงที่เหลืออยู่ในอาร์เรย์กลับด้าน

⊞υι↙←⮌⪫υω

ผนวกสตริงสุดท้ายที่ถูกลบก่อนหน้านี้ไปuที่ซึ่งมีค่า unfurled และพิมพ์

Ｄ⎚

เอาท์พุทผลแล้วล้างผ้าใบพร้อมสำหรับการทำซ้ำครั้งต่อไป

โปรดทราบว่ารุ่นนี้จะแสดงผลออกมาเป็นเส้นสุดท้ายในบรรทัดแยกต่างหากหากไม่เป็นที่น่าพอใจสำหรับ 38 ไบต์:

ＡＥθＳθＷ⊟θ«⊞υι←Ｅ⁺⟦⪫υω⟧⮌θ⮌κＡＥι⮌⪫Ｅθ§μλωθＤ⎚

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย: ←Ｅ⁺⟦⪫υω⟧⮌θ⮌κย้อนกลับอาร์เรย์ปัจจุบันเตรียมเส้นที่แยกออกจากกันแล้วกลับอักขระในแต่ละบรรทัดจากนั้นพิมพ์ทุกอย่างกลับหัวลงดังนั้นจึงให้ผลลัพธ์ที่ต้องการ

Haskell , 127 120 bytes

e=[]:e
i#[x]=[]
i#s|t<-foldl(flip$zipWith(:))e$init s,j<-i++last s=(map((j>>" ")++)(init t)++[j++last t]):j#t
f s=s:""#s

ลองออนไลน์!

การป้อนข้อมูลเป็นรายการของสายเช่นกรณีการทดสอบที่สองเอาท์พุทคือรายการของรายการของเส้น:["DC","AB"] [["DC","AB"],[" D","ABC"],["ABCD"]]ใช้mapM (putStrLn . unlines)เพื่อพิมพ์ผลสวย

แก้ไข:บันทึกแล้ว 7 ไบต์โดยสังเกตว่ายิ่งฉันพบขนาดสั้นลงtransposeสักพักก็สามารถพกพาไปได้สะดวกเพราะมันสามารถปรับเปลี่ยนเพื่อย้อนกลับแต่ละรายการได้โดยตรง

05AB1E , 18 ไบต์

[Dí.Bí»,¤UR¦ζŽ`Xì)

ลองออนไลน์!

คำอธิบาย

[            Ž       # while stack is not empty, do:
 D                   # duplicate current list
  í                  # reverse each element
   .B                # pad with spaces to equal length
     í               # reverse each element again
      »,             # join with newlines and print
        ¤U           # store the last element in X
          R¦         # reverse the list and remove the first element
            ζ        # zip with spaces as filler
              `      # split elements separately to stack
               Xì    # prepend X to the last element
                 )   # join the stack to a list

J, 62 ไบต์

|."1@([:(#~[:-.[:*/"1' '=])|.@{:(}:@],{:@],[)|:@}:)^:(1<#)^:a:

ลองออนไลน์!

ฉันแน่ใจว่านี้สามารถเล่นกอล์ฟได้มาก สิ่งนี้พิมพ์พื้นที่ว่างพิเศษ แต่เนื่องจากวิธีที่ J จัดรูปแบบอาร์เรย์ที่มีอยู่ภายในอาร์เรย์เอาต์พุตที่มีรูปร่างเหมือนกัน

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

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

คำอธิบาย

ในการล้างโลกนี้ฉันจะแยกหน้าที่หลักออกเป็นสามส่วน

unfurl_reversed   =. |.@{: (}:@] , {:@] , [) |:@}:
whitespace_filter =. #~ [: -. [: */"1 ' ' = ]
unfurl            =. |."1@(whitespace_filter @: unfurl_reversed) ^: (1 < #) ^: a:

test_case         =. 3 3 $ 'GFEHIDABC'

เราจะทำงานกับกรณีทดสอบที่สอง

unfurl_reversed

|.@{: (}:@] , {:@] , [) |:@}:

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

|:@}: คือทรานสโพสต์ของการกำจัดของ

   |:@}: test_case
GH
FI
ED

|.@{: คือด้านหลังของหางของอินพุต

   |.@{: test_case
CBA

ฉันคิดว่าคุณสามารถเห็นสิ่งที่เราต้องการจะทำ: เราต้องการผนวกส่วนท้ายของหางไปยังส่วนสุดท้ายของขนย้ายหางม้า (นั่นคือคำหนึ่ง แต่โดยทั่วไปยึดติดCBAกับส่วนท้ายของED) สิ่งนี้จะทำให้เรามีหนึ่งขั้นตอนในการคลายตัวกลับด้าน

(}:@],{:@],[) ทำแค่นั้น

มันผนวกCBAกับED, จากนั้นเชื่อมต่อกับส่วนที่เหลือของอาร์เรย์ ผลลัพธ์ของเราคือ

   unfurl_reversed test_case
GH   
FI   
EDCBA

whitespace_filter

#~ [: -. [: */"1 ' ' = ]
                 ' ' = ]  Equate each element to space
            */"1          Product of each row (all true?)
      -.                  Negate
#~                        Filter rows that are true

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

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

คลี่

|."1@(whitespace_filter @: unfurl_reversed) ^: (1 < #) ^: a:

Unfurl โดยทั่วไปจะทำให้ฟังก์ชั่นอื่น ๆ เข้าด้วยกันและกรณีพิเศษอินพุตอักขระเดี่ยว

เมื่อพลังของคำกริยา ( ^:) ได้รับกล่องว่างเปล่า ( a:) มันจะใช้ฟังก์ชั่นในการป้อนข้อมูลจนกว่ามันจะมาบรรจบกันและรวบรวมผลลัพธ์ในอาร์เรย์

(1 < #) ตรวจสอบว่าแถวนั้นมากกว่า 1 เสมอ (ถึงอินพุทแถว 1 กรณีพิเศษ)

|."1whitespace_filter @: unfurlฝืนแต่ละแถวจึงตีความผลของการ

Python 2 , 143 132 ไบต์

a=input()
while 1:print'\n'.join(a);b=map(''.join,zip(*map(str.strip,a[-2::-1])));a[-1]+=b.pop();a[:-1]=[len(a[0])*' '+x for x in b]

ลองออนไลน์!

ในแต่ละย้ำbเป็น“หัว” ของสตริง (n แรก-1 แถว), หมุน 90 องศาถ้าaเป็น[" NML", " OPK", "ABCDEFGHIJ"]แล้วคือb["ON", "PM", "KL"]

คลี่สตริงครั้งเดียวเราผนวกบรรทัดสุดท้ายของbการa[-1](ให้"ABCDEFGHIJKL") แล้ว recompute โดยการเพิ่มช่องว่างที่เหลือของสายในa[:-1]b

เรายุติโดยพยายามป๊อปอัปbเมื่อว่างเปล่า

Python 2 , 132 ไบต์

a=input()
while 1:s=str.strip;print'\n'.join(a);a[:-1]=[len(a[0])*' '+''.join(x)for x in zip(*map(s,a[-2::-1]))];a[-1]+=s(a.pop(-2))

ลองออนไลน์!

ความคิดเดียวกันเขียนแตกต่างกัน เรายุติโดยพยายามa.pop(-2)เมื่อaมีองค์ประกอบเดียวเท่านั้น

Perl 5 , 155 ไบต์

$"=$,;@a=map[/./g],<>;while(@a){say' 'x(length$s)."@$_"for@a[0..@a-2];say$s.="@{pop@a}";say@b=();for$i(0..$#a){$q=0;$b[$q++][$#a-$i]=$_ for@{$a[$i]}}@a=@b}

ลองออนไลน์!

บันทึกสองสามไบต์โดยไม่ต้องแก้ไขตรรกะจริงๆ การไหลด้านล่างยังคงถูกต้องโดยทั่วไป

# Perl 5 , 163 ไบต์

$"=$,;@a=map[/./g],<>;while(@a){say' 'x(length$s)."@{$a[$_]}"for 0..@a-2;say$s.="@{pop@a}";say@b=();for$i(0..$#a){$b[$_][$#a-$i]=$a[$i][$_]for 0..$#{$a[$i]}}@a=@b}

ลองออนไลน์!

อย่างไร?

$"=$,; #set the array output separator to null
@a=map[/./g],<>;   # take the input as a 2-D array @a
while(@a){         # repeat while there are still things to unfurl
  say' 'x(length$s)."@{$a[$_]}"for 0..@a-2; # output all but last
                                            # line of the remaining
                                            # square
  say$s.="@{pop@a}";  # remove bottom row, add it to the unfurled string $s
                      # and output it
  say@b=();           # clear temporary array; output empty array, causing
                      # a newline to output

                      # rotate remaining shape 90 degrees:
  for$i(0..$#a){$b[$_][$#a-$i]=$a[$i][$_]for 0..$#{$a[$i]}}
  @a=@b               # replace input with rotated array
}