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

เมื่อคุณเขียนคำเสร็จให้เปลี่ยนทิศทางแล้วเริ่มเขียนคำถัดไปเท่านั้น

หากภาษาของคุณไม่รองรับรายการคำหรือสะดวกกว่าสำหรับคุณคุณสามารถป้อนข้อความเป็นสตริงคำโดยคั่นด้วยช่องว่างเดียว

อนุญาตช่องว่างนำหน้าและต่อท้าย

["hello", "world"] หรือ "hello world"

hello
    w
    o
    r
    l 
    d

ที่นี่เราเริ่มต้นด้วยการเขียนhelloและเมื่อเรามาถึงคำถัดไป (หรือในกรณีของอินพุตเป็นสตริง - พบช่องว่าง) เราเปลี่ยนทิศทางสัมพัทธ์ไปทางขวาและเขียนต่อไปworld

กรณีทดสอบ:

["another", "test", "string"] or "another test string" ->   

another
      t
      e
      s
      tstring


["programming", "puzzles", "and", "code", "golf"] or "programming puzzles and code golf" ->

programming
          p
          u
          z
          z
          l
          e
          sand
             c
             o
             d
             egolf

["a", "single", "a"] or "a single a" ->

a
s
i
n
g
l
ea

เกณฑ์การพิจารณาคดี

รหัสที่สั้นที่สุดเป็นไบต์ในทุกภาษาชนะ อย่าให้กำลังใจกับภาษากอล์ฟ!

Sandbox

ถ่าน 9 ไบต์

Ｆ⮌Ａ«↑⮌ι‖↗

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

Ｆ⮌Ｓ≡ι ‖↗←ι

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย: วาดข้อความไปข้างหลังโดยเลื่อนพื้นที่ว่างบนผืนผ้าใบ

C (gcc) , 94 78 74 ไบต์

-4 จากJohan du Toit

o,f;g(int*s){for(o=f=0;*s;s++)*s<33?f=!f:printf("\n%*c"+!f,f*(o+=!f),*s);}

ลองออนไลน์!

พิมพ์แลดเดอร์หนึ่งตัวอักษร (ของอินพุต) ในแต่ละครั้ง ใช้สตริงของคำที่คั่นด้วยช่องว่าง

05AB1E , 19 16 ไบต์

€θ¨õšøíJD€gs24SΛ

-3 ไบต์ขอบคุณที่@Emigna

ลองออนไลน์

คำอธิบายทั่วไป:

เช่นเดียวกับ@Emignaคำตอบ 05AB1E 's (ให้แน่ใจว่าจะ upvote เขาครับ !!) ผมใช้builtin ผ้าใบΛ

ตัวเลือกที่ฉันใช้นั้นแตกต่างกัน (ซึ่งเป็นสาเหตุที่คำตอบของฉันยาวกว่านี้):

• b(สตริงที่จะพิมพ์): ฉันปล่อยให้สตริงแรกในรายการไม่เปลี่ยนแปลงและเพิ่มตัวอักษรต่อท้ายในแต่ละสายถัดไปในรายการ ยกตัวอย่างเช่นจะกลายเป็น["abc","def","ghi","jklmno"]["abc","cdef","fghi","ijklmno"]
• a(ขนาดของเส้น): นี่จะเท่ากับสตริงเหล่านี้ดังนั้น[3,4,4,7]ด้วยตัวอย่างข้างต้น
• c(ทิศทางในการพิมพ์): [2,4]ซึ่งจะแมปกับ[→,↓,→,↓,→,↓,...]

ดังนั้นตัวอย่างข้างต้นจะทำตามขั้นตอนต่อไปนี้:

1. วาดabcในทิศทาง/2→
2. วาดcdefในทิศทาง4/ ↓(โดยที่อักขระตัวแรกทับซ้อนกับอักขระตัวสุดท้ายซึ่งเป็นสาเหตุที่เราต้องแก้ไขรายการเช่นนี้)
3. วาดfghiในทิศทาง2/ →อีกครั้ง (ด้วยการทับซ้อนของตัวอักษรต่อท้าย / นำ)
4. วาดijklmnoในทิศทาง4/ ↓อีกครั้ง (ด้วยการทับซ้อน)
5. เอาท์พุทผลลัพธ์ของ Canvas ที่วาดทันทีไปยัง STDOUT

คำอธิบายรหัส:

€θ                # Only leave the last characters in the (implicit) input-list
  ¨               # Remove the last one
   õš             # And prepend an empty string "" instead
     ø            # Create pairs with the (implicit) input-list
      í           # Reverse each pair
       J          # And then join each pair together to single strings
        D€g       # Get the length of each string (without popping by duplicating first)
           s      # Swap so the lengths are before the strings
            24S   # Push [2,4]
               Λ  # Use the Canvas builtin (which outputs immediately implicitly)

05AB1E , 14 13 ไบต์

บันทึก 1 ไบต์ขอบคุณGrimy

€ðÀD€g>sŽ9÷SΛ

ลองออนไลน์!

คำอธิบาย

                 # example input ["Hello", "World"]
€ðÀ              # push a space after each word
                 # STACK: ["Hello"," ","World"," "]
   D             # duplicate
    €g>          # get the length of each word in the copy and add 1
                 # these are the lengths to draw
                 # STACK: ["Hello"," ","World"," "], [6, 2, 6, 2]
       s         # swap the list of word to the top of the stack
        Ž9÷S     # push [2, 5, 4, 1]
                 # this is the list of directions to draw
                 # 1=northeast, 2=east, 4=south, 5=southwest
            Λ    # paint on canvas

Canvas , 17 12 11 10 ไบต์

ø⁸⇵｛⟳Ｋ└×∔⤢

ลองที่นี่!

คำอธิบาย:

ø⁸⇵{⟳K└×∔⤢  full program taking array as input (loaded with ⁸)

ø         push an empty canvas               ["test", "str"], ""
 ⁸⇵{      for each input word, in reverse:   "str", "test" (showing 2nd iter)
    ⟳       rotate the word vertically       "str", "t¶e¶s¶t"
     K      pop off the last letter          "str", "t¶e¶s", "t"
      └     swap the two items below top     "t¶e¶s", "str", "t"
       ×    prepend                          "t¶e¶s", "tstr"
        ∔   vertically append                "t¶e¶s¶tstr"
         ⤢  transpose the canvas             "test
                                                 s
                                                 t
                                                 r"

JavaScript (ES8),  91 79  77 ไบต์

รับอินพุตเป็นอาร์เรย์ของคำ

a=>a.map((s,i)=>i&1?[...s].join(p):s+=p+=''.padEnd(s.length-!i),p=`
`).join``

ลองออนไลน์!

แสดงความคิดเห็น

a =>                 // a[] = input array
  a.map((s, i) =>    // for each word s at position i in a[]:
    i & 1 ?          //   if this is a vertical word:
      [...s].join(p) //     split s and join it with p
    :                //   else:
      s +=           //     add to s:
        p +=         //       add to p:
          ''.padEnd( //         as many spaces
            s.length //         as there are letters in s
            - !i     //         minus 1 if this is the 1st word (because it's not connected
          ),         //         with the last letter of the previous vertical word)
    p = `\n`         //   start with p = linefeed
  ).join``           // end of map(); join everything

Python 2 , 82 ไบต์

b=p=0
r=''
for w in input():
 for c in w:r+='\n'.ljust(p)*b+c;p+=1-b
 b^=1
print r

ลองออนไลน์!

brainfuck , 57 ไบต์

->,[[.<+>,],[<<[-]++++++++++.--[-<++++>]>[-<+<.>>]>.<,],]

ลองออนไลน์!

รับอินพุตเป็นสตริงที่คั่นด้วย NUL โปรดทราบว่านี่คือการใช้ EOF เป็น 0 และจะหยุดทำงานเมื่อบันไดเกิน 256 ช่องว่าง

คำอธิบาย:

-           Initialise counter as -1
>,[         Start ladder
   [.<+>,]  Print the first word, adding the length of it to the counter
   ,[       Loop over each letter of the second word
      <<[-]++++++++++.    Print a newline
      --[-<++++>]         Create a space character
      >[-<+<.>>]          Print counter many spaces
      >.<,                Print the letter and move to the next letter
   ] 
   ,        Repeat until there are no more words
]

JavaScript, 62 ไบต์

a=>' '+a.replace(/./g,c=>1-c?(a=!a,''):a?(p+=' ',c):p+c,p=`
`)

ลองออนไลน์!

ขอบคุณRick Hitchcockบันทึก 2 ไบต์

JavaScript ขนาด 65 ไบต์

a=>a.replace(/./g,c=>1-c?(t=!t,''):t?p+c:(p+=p?' ':`
`,c),t=p='')

ลองออนไลน์!

a => a.replace (/./ g, c => (// สำหรับอักขระ c แต่ละตัวในสตริง a)
    1 - c? // ถ้า (c คือช่องว่าง)
      (t =! t, // อัปเดต t: ค่าบูลีนอธิบายดัชนีคำ
                       // ความจริง: คำที่จัดทำดัชนีแปลก ๆ
                       // falsy: แม้แต่คำที่จัดทำดัชนี
        ''): // ไม่สร้างพื้นที่ว่าง
    T? // ถ้า (เป็นดัชนีคี่) ซึ่งหมายถึงเป็นแนวตั้ง
      p + c: // เพิ่ม '\ n' ช่องว่างบางส่วนและตัวทาย sigle
                       // อื่น ๆ
      (p + = p? '': '\ n', // เตรียมสตริงเสริมสำหรับคำในแนวตั้ง
         c) // เพิ่มอักขระตัวเดียว
)
  t = p = '' // เริ่มต้น
)

Aheui (esotope) , 490 458 455 ไบต์

삭뱃밸때샏배샐배새뱄밿때빠뱋빼쌘투＠밧우
＠두내백뱃빼선대내백뱃섣＠여우샐처샐추
희차＠＠＠뭏누번사＠빼뭏오추뻐＠＠＠배
Ｂｙ＠＠＠새대백＠＠＠우뻐색
Ｌｅｇｅｎ＠＠빼쵸누번＠＠빼
ＤＵＳＴ＠＠＠샌뽀터본섣숃멓
＠＠＠＠＠＠＠오어아＠먛요아＠＠샏매우
＠＠＠＠＠아＠＠＠＠＠＠오＠＠＠＠＠서어
＠＠＠＠＠희차＠＠요

ลองออนไลน์!

golfed เล็กน้อยโดยใช้อักขระแบบเต็มความกว้าง (2 ไบต์) แทนภาษาเกาหลี (3 ไบต์)

คำอธิบาย

Aheui เป็นเหมือน esolang ที่มีความดุดัน นี่คือรหัสที่มีสี: ส่วนที่ 1 ตรวจสอบว่าอักขระปัจจุบันเป็นช่องว่างหรือไม่

2 ส่วนตรวจสอบว่าคำที่เขียนจากขวาไปซ้ายหรือจากบนลงล่าง

? 3 ส่วนคือเงื่อนไขการแบ่งของลูปซึ่งประเภทช่องว่าง

4 ส่วนตรวจสอบว่าตัวละครปัจจุบันเป็นจุดสิ้นสุดของบรรทัด (-1)

ส่วนสีแดงเป็นการเริ่มต้นสแต็ก Aheui ใช้สแต็ค (จากNothingถึงㅎ: 28 สแต็ค) เพื่อจัดเก็บค่า

ส่วนสีส้มรับอินพุต ( 뱋) และตรวจสอบว่าเป็นพื้นที่หรือไม่โดยการลบด้วย32(รหัส ascii ของช่องว่าง)

ส่วนสีเขียวบวก 1 เข้ากับสแต็กซึ่งเก็บค่าความยาวของพื้นที่ถ้าเขียนจากขวาไปซ้าย

ส่วนสีม่วงคือลูปสำหรับพื้นที่การพิมพ์ถ้าเขียนขึ้นจากบนลงล่าง

ส่วนสีเทาตรวจสอบว่าตัวละครปัจจุบันคือ-1โดยการเพิ่มหนึ่งตัวละครเพื่อปัจจุบัน

ส่วนสีน้ำเงินพิมพ์อักขระปัจจุบันและเตรียมพร้อมสำหรับอักขระถัดไป

Japt -P 15 ไบต์

ò mrÈ+R+YÕùT±Xl

ลองมัน

ò mrÈ+R+YÕùT±Xl     :Implicit input of string array
ò                   :Partition into 2s
  m                 :Map each pair
   r                :  Reduce by
    È               :  Passing through the following function as X & Y
     +              :    Append to X
      R             :    Newline
       +            :    Append
        YÕ          :    Transpose Y
          ù         :    Left pad each line with spaces to length
           T±       :      T (initially 0) incremented by
             Xl     :      Length of X
                    :Implicitly join and output

ทุบตี 119 ตัวอักษร

X=("\e7" "\n\e8")
w="$@"
l=${#w}
d=0
for((i=0;i<l;i++));do
c="${w:$i:1}"
[ -z $c ]&&d=$((1-d))||printf ${X[$d]}$c
done

ใช้ลำดับการควบคุม ANSI เพื่อเลื่อนเคอร์เซอร์ - ที่นี่ฉันแค่ใช้บันทึก\e7และกู้คืน\e8เท่านั้น แต่การคืนค่าจะต้องนำหน้าด้วย\nเพื่อเลื่อนเอาต์พุตถ้ามันอยู่ที่ด้านล่างของเทอร์มินัล ด้วยเหตุผลบางอย่างมันไม่ทำงานหากคุณยังไม่ได้อยู่ที่ด้านล่างของเครื่อง * ยัก *

อักขระปัจจุบัน$cถูกแยกออกเป็นสตริงย่อยอักขระเดี่ยวจากสตริงอินพุต$wโดยใช้forดัชนีลูป$iเป็นดัชนีในสตริง

เคล็ดลับที่แท้จริงที่ฉันใช้ที่นี่คือ[ -z $c ]สิ่งที่จะกลับมาtrueเช่นสตริงว่างเปล่าเมื่อ$cเป็นช่องว่างเพราะมันไม่ได้ยกมา ในการใช้งาน bash ที่ถูกต้องคุณจะต้องอ้างอิงสตริงที่จะทดสอบด้วย-zเพื่อหลีกเลี่ยงสถานการณ์นี้ นี้ช่วยให้เราพลิกธงทิศทาง$dระหว่าง1และ0ที่ใช้แล้วเป็น index เข้าไปในการควบคุมมาตรฐาน ANSI ลำดับอาร์เรย์ในค่าที่ไม่ใช่พื้นที่ต่อไปของX$c

printf "%${x}s" $cฉันจะสนใจที่จะเห็นบางสิ่งบางอย่างที่ใช้

โอ้โหเพิ่มช่องว่างบางส่วนแล้ว ฉันไม่เห็นว่าฉันอยู่ที่ไหน ...

X=("\e7" "\n\e8")
w="$@"
l=${#w}
d=0
for ((i=0;i<l;i++)); do
  c="${w:$i:1}"
  [ -z $c ] && d=$((1-d)) || printf ${X[$d]}$c
done

Perl 6 , 65 ไบต์

{$/=0;.map:{$/+=$++%2??!.comb.fmt("%$/s","
").print!!.say*.comb}}

ลองออนไลน์!

บล็อคโค้ดแบบไม่ระบุชื่อที่รับรายการคำและพิมพ์ตรงไปยัง STDOUT

คำอธิบาย

{                           }  # Anonymous code block
 $/=0;                         # Initialise $/ to 0
 .map:{                    }   # Map the list of words to
       $/+=                    # Increment $/ by
           $++%2??             # For even indexes
                   .comb       # Each letter of the word
                   .fmt(           ) # Formatted as
                        "%$/s"       # Padded with $/-1 spaces
                              ,"\n"  # Joined by newlines
                   .print            # And printed without a newline
                  !   # Boolean not this to add 0 to $/
                !!            # For odd indexes
                  .say        # Print with a newline
                      *.comb  # And add the length of the word

ถ่าน , 19ไบต์

ＦＬθ¿﹪鲫↓§θι↗»«§θι↙

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

ลองออนไลน์ (verbose)หรือลองออนไลน์ (บริสุทธิ์)

คำอธิบาย:

วนซ้ำในช่วง[0, input-length):

For(Length(q))
ＦＬθ

หากดัชนีเป็นเลขคี่:

If(Modulo(i,2)){...}
﹪鲫...»

พิมพ์สตริงที่ดัชนี iในทิศทางลง:

Print(:Down, AtIndex(q,i));
↓§θι

จากนั้นเลื่อนเคอร์เซอร์หนึ่งครั้งไปทางด้านขวาบน:

Move(:UpRight);
↗

อื่น (ดัชนียังเท่ากัน):

Else{...}
«...

พิมพ์สตริงที่ดัชนี iในทิศทางที่ถูกต้องปกติ:

Print(AtIndex(q,i));
§θι

จากนั้นเลื่อนเคอร์เซอร์ไปทางซ้ายล่าง:

Move(:DownLeft);
↙

Python 2 , 89 88 ไบต์

s=i=-1
r=''
for w in input():r+=[('\n'+' '*s).join(' '+w),w][i];s-=i*len(w);i=~i
print r

ลองออนไลน์!

C # (Visual C # Interactive Compiler) , 122 ไบต์

a=>{int i=0;var t="\n";foreach(var z in a)Write(i++%2<1?z+(t+="".PadRight(z.Length-(i<2?1:0))):string.Join(t,z.Skip(0)));}

ลองออนไลน์!

J , ^{47 45} 43 ไบต์

;[`(([:<@(+/)\#&>##$#:@1 2)@])`([' '"0/[)}]

ลองออนไลน์!

ฉันพบวิธีที่สนุกและแตกต่าง ...

ฉันเริ่มยุ่งกับแผ่นด้านซ้ายและรหัสไปรษณีย์ด้วย gerunds วนและอื่น ๆ แต่แล้วฉันก็รู้ว่ามันจะง่ายกว่าที่จะคำนวณตำแหน่งของตัวอักษรแต่ละตัว }เพื่อที่ว่างเปล่า แคนวาสบนอินพุตอาละวาด

โซลูชันได้รับการจัดการเกือบทั้งหมดโดย Amend }:

; [`(([: <@(+/)\ #&> # # $ #:@1 2)@])`([ ' '"0/ [)} ]

• ; ( single verb that does all the work ) ] ส้อมโดยรวม
• ; ส่วนที่เหลือทำให้อินพุตนั้นทำให้ตัวอักษรทั้งหมดเป็นสตริงที่ต่อเนื่องกัน
• ] ส่วนที่ถูกต้องคืออินพุต
• (stuff)}เราจะใช้รูปแบบของอาการนามแก้ไขซึ่งประกอบด้วยสามส่วน }v0`v1`v2
  • v0 ให้ "ค่าใหม่" แก่เราซึ่งก็คือ raze (เช่นตัวละครทั้งหมดของอินพุตเป็นหนึ่งสายอักขระ) ดังนั้นเราจึงใช้ [ดังนั้นเราจะใช้
  • v2ทำให้เรามีค่าเริ่มต้นซึ่งเราจะเปลี่ยน เราแค่ต้องการผืนผ้าใบว่างเปล่าของช่องว่างของมิติที่ต้องการ ([ ' '"0/ [)ให้หนึ่งขนาด(all chars)x(all chars)จะช่วยให้เราเป็นหนึ่งในขนาด
  • กริยาตรงกลางv1เลือกตำแหน่งที่เราจะใส่ตัวละครทดแทนของเรานี่คือปมของตรรกะ ...
• เริ่มต้นที่ตำแหน่ง0 0ในด้านซ้ายบนเราสังเกตเห็นว่าตัวละครใหม่แต่ละตัวมี 1 ทางด้านขวาของตำแหน่งก่อนหน้า (เช่น, prev + 0 1) หรืออีกหนึ่งลง (เช่น, prev + 1 0) อันที่จริงเราทำ "len ของคำ 1" ครั้งแล้วจากนั้น "len ของคำ 2" ครั้งและอื่น ๆ สลับกัน ดังนั้นเราจะสร้างลำดับที่ถูกต้องของการเคลื่อนไหวเหล่านี้จากนั้นสแกนผลรวมพวกเขาและเราจะมีตำแหน่งของเราซึ่งเราจะทำกล่องเพราะนั่นคือวิธีการแก้ไขการทำงาน สิ่งต่อไปนี้เป็นเพียงกลไกของความคิดนี้ ...
• ([: <@(+/)\ #&> # # $ 1 - e.@0 1)
  • แรกสร้างเมทริกซ์อย่างต่อเนื่อง #:@1 20 1;1 0
  • # $จากนั้นขยายมันเพื่อให้มีแถวได้มากเท่ากับอินพุต เช่นถ้าใส่มี 3 0 1;1 0;0 1คำที่จะผลิต
  • #&> #ส่วนด้านซ้ายของนั่นคืออาร์เรย์ของความยาวของคำที่ป้อนและ#คัดลอกดังนั้นจึงคัดลอก0 1"len ของคำ 1" ครั้งจากนั้น1 0"len ของคำ 2 ครั้ง" ฯลฯ
  • [: <@(+/)\ ผลรวมการสแกนและกล่องทำอะไร

T-SQL, 185 ไบต์

DECLARE @ varchar(max)='Thomas Clausen Codegolf Script'
,@b bit=0,@s INT=0SET @+=':'WHILE @ like'%_:%'SELECT
@b+=len(left(@,1))-1,@=stuff(@,1,1,'')+iif(left(@,@b)='','','
'+space(@s))+trim(left(@,1)),@s+=len(left(@,~@b))PRINT
stuff(@,1,1,'')

ลองออนไลน์

เรติน่า 51 ไบต์

1,2,`\w+
;$&
+(m`^(.(.*?)) ?;(.)
$1¶$.2* $3;
; |;$

ลองออนไลน์!

วิธีการที่ค่อนข้างตรงไปตรงมาที่ทำเครื่องหมายคำอื่น ๆ แล้วนำการเปลี่ยนแปลงมาใช้โดยตรง

คำอธิบาย

1,2,`\w+
;$&

เราทำเครื่องหมายทุกคำด้วยเครื่องหมายอัฒภาคโดยการจับคู่แต่ละคำ แต่ใช้การแทนที่กับการจับคู่เท่านั้น (ซึ่งจะถูกทำดัชนีเป็นศูนย์) เริ่มต้นจากการจับคู่ 1 และ 3

+(m`^(.(.*?)) ?;(.)
$1¶$.2* $3;

+(mตั้งค่าคุณสมบัติบางอย่างสำหรับขั้นตอนต่อไปนี้ เครื่องหมายบวกเริ่มต้น "ขณะที่กลุ่มขั้นตอนนี้เปลี่ยนแปลงบางอย่าง" วนรอบและวงเล็บเปิดเปิดแสดงว่าเครื่องหมายบวกควรนำไปใช้กับทุกขั้นตอนต่อไปนี้จนกว่าจะมีเครื่องหมายวงเล็บปิดอยู่หน้า backtick (ซึ่งเป็นขั้นตอนทั้งหมดใน กรณีนี้). mเพียงแค่บอก regex เพื่อรักษา^เป็นยังจับคู่จากจุดเริ่มต้นของเส้นแทนเพียงจุดเริ่มต้นของสตริง

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

; |;$

ขั้นตอนนี้จะใช้หลังจากช่วงสุดท้ายเพื่อลบเครื่องหมายอัฒภาคและช่องว่างท้ายคำที่เราเปลี่ยนเป็นแนวตั้ง

เรติน่า 0.8.2 , 58 ไบต์

(?<!^(\S* \S* )*\S*)
¶
¶? 

+`(..(.)*¶)((?<-2> )*\S)
$1 $3

ลองออนไลน์! ลิงค์มีกรณีทดสอบ ทางเลือกอื่นเช่น 58 ไบต์:

( \S*) 
$1¶
+` (.)
¶$1 
 ¶

+`(..(.)*¶)((?<-2> )*\S)
$1 $3

ลองออนไลน์! ลิงค์มีกรณีทดสอบ

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

โปรดทราบว่าฉันไม่คิดว่าคำเป็นเพียงตัวอักษรเพราะฉันไม่จำเป็นต้อง

PowerShell , 101 89 83 ไบต์

-12 ไบต์ขอบคุณที่Mazzy

$args|%{$l+=if(++$i%2){$_.length-1;$t+=$_}else{1;$_|% t*y|%{$t+='
'+' '*$l+$_}}};$t

ลองออนไลน์!

PowerShell , 74 65 ไบต์

-join($args|%{$_|% t*y|%{($p+=(' ','
')[!$p]*!$i)*$i;$_};$i=!$i})

ลองออนไลน์!

R , 126 ไบต์

function(x,`>`=strrep)for(i in seq(x)){H=i%%2;cat(paste0('
'>!H,' '>F*!H,e<-'if'(H,x,strsplit(x,''))[[i]]))
F=F+nchar(e[1])-H}

ลองออนไลน์!

• -3 ไบต์ขอบคุณ @Giuseppe

T-SQL ขนาด 289 ไบต์

DECLARE @ VARCHAR(MAX)='a a',@I INT=1,@S INT=0,@B INT=0WHILE @I<=LEN(@)IF SUBSTRING(@,@I,1)=''IF @B=0SELECT @S-=1,@=STUFF(@,@I,1,'
'+SPACE(@S)),@I+=@S+3,@B=1 ELSE SELECT @=STUFF(@,@I,1,''),@S+=1,@B=\ELSE IF @B=0SELECT @I+=1,@S+=1 ELSE SELECT @=STUFF(@,@I,0,'
'+SPACE(@S)),@I+=@S+3PRINT @

สิ่งนี้รันบน SQL Server 2016 และเวอร์ชันอื่น ๆ

@ เก็บรายการที่คั่นด้วยช่องว่าง @ ฉันติดตามตำแหน่งดัชนีในสตริง @S ติดตามจำนวนช่องว่างทั้งหมดเพื่อเยื้องจากทางซ้าย @B ติดตามว่าแกนของสตริงอยู่ในแนวใดที่ตำแหน่ง @I

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

JavaScript (Node.js) , 75 ไบต์

a=>a.map(x=>i++&1?[,...x].join(`
`.padEnd(n)):(n+=x.length,x),n=i=0).join``

ลองออนไลน์!

คำอธิบายและไม่ดี

function f(a) {                   // Main function:
 return a.map(                    //  Map through all words:
  function(x) {
   if (i++ & 1)                   //   If i % 2 == 1 (i.e. vertical):
    return [,...x].join(          //    Since the first one needs to have its own linefeed 
                                  //    and indentation, add a dummy item to the start.
     "\n".padEnd(n)               //    Join the array with the padded line feeds.
    );
   else {                         //   If i % 2 == 0 (i.e. horizontal):
    n += x.length;                //    Add the length of this string to the variable that
                                  //    counts how long the padded line feeds should be.
    return x;                     //    Append the string at the end without line feeds.
   }
  },
  n = i = 0                       //   Initialize variables.
                                  //   n: the length of the padded line feeds 
                                  //      (including the line feed)
                                  //   i: keeps track of the direction
 ).join("")                       //  Join all stuffs and return.
}

Stax , 12 ไบต์

ìZΣFτëWº═φ‼R

เรียกใช้และแก้ไขข้อบกพร่อง

เยลลี่ 21 ไบต์

Ẉm2Ä’x2Ż⁶xⱮṛ;⁷ɗ;ⱮY¥ƭ"

ลองออนไลน์!

โปรแกรมเต็มรูปแบบที่รับอินพุตเป็นรายการของสตริงและส่งออกโดยปริยายเพื่อ stdout คำ ladder

C (gcc) , 93 87 ไบต์

ขอบคุณ Gastropner สำหรับคำแนะนำ

รุ่นนี้ใช้อาร์เรย์ของสตริงที่สิ้นสุดโดยตัวชี้ NULL

c,d;f(s,t)char**s,*t;{for(c=d=0;t=*s++;d=!d)for(;*t;c+=!d)printf("\n%*c"+!d,d*c,*t++);}

ลองออนไลน์!

Brain-Flakขนาด 152 ไบต์

<>([()])<>{<>({}<>{()<({}<>)><>}<>)<>{}{<>({}<((()()()()()){})>)({<({}[()]<((((()()()()){}){}){})>)>()}{})<>(({}<>({}))[({}[{}])])<>}{}}<>{}{({}<>)<>}<>

ลองออนไลน์!

ฉันคิดว่ามันน่าจะสั้นกว่านี้ด้วยการรวมสองลูปเข้าด้วยกันกับคำที่แปลก

J, 35 33 ไบต์

3 :'[;.0>(,|:)&:,.&.>/_98{.;:|.y'

นี่คือคำกริยาที่รับอินพุตเป็นสตริงเดี่ยวที่มีคำคั่นด้วยช่องว่าง ตัวอย่างเช่นคุณสามารถเรียกมันว่า:

3 :'[;.0>(,|:)&:,.&.>/_98{.;:|.y' 'programming puzzles and code golf'

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

มีปัญหาเล็กน้อยเกี่ยวกับรหัส: มันจะไม่ทำงานหากอินพุตมีมากกว่า 98 คำ หากคุณต้องการอนุญาตให้ป้อนข้อมูลได้นานขึ้นให้แทนที่_98รหัสใน_998เพื่อให้มีคำไม่เกิน 998 คำและอื่น ๆ

ให้ฉันอธิบายวิธีการทำงานผ่านบางตัวอย่าง

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

   [m=: 3 3$'vwx  y  z'
vwx
  y
  z

เราจะเติมคำใหม่ก่อนหน้านี้ในแนวตั้งได้อย่างไร? ไม่ใช่เรื่องยาก: เพียงแค่เปลี่ยนคำใหม่เป็นเมทริกซ์คอลัมน์เดียวของตัวอักษรด้วยคำกริยา,.จากนั้นผนวกผลลัพธ์ไปยังเมทริกซ์คอลัมน์เดี่ยวนั้น (คำกริยา,.นั้นสะดวกเพราะมันทำหน้าที่เป็นฟังก์ชันเฉพาะถ้าคุณใช้กับเมทริกซ์ซึ่งเราใช้สำหรับการเล่นกอล์ฟ)

   (,.'cat') , m
c  
a  
t  
vwx
  y
  z

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

   (,.'dog') , |: (,.'cat') , m
d     
o     
g     
catv  
   w  
   xyz

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

   > (,|:)&.>/ ,.&.>;: 'car house dog children'
c            
a            
r            
housed       
     o       
     g       
     children

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

c             
a             
rhouse        
     d        
     o        
     gchildren

วิธีที่เราบรรลุผลนี้คือการย้อนกลับสตริงอินพุตทั้งหมดตามที่

nerdlihc god esuoh rac

จากนั้นใช้ขั้นตอนด้านบนเพื่อสร้างซิกแซก แต่เปลี่ยนหลังจากตัวอักษรตัวแรกของแต่ละคำเท่านั้น:

n     
e     
r     
d     
l     
i     
h     
c     
gode  
   s  
   u  
   o  
   h  
   rac

จากนั้นพลิกผลลัพธ์:

   [;.0> (,|:)&.>/ ,.&.>;:|. 'car house dog children'
car   
  h   
  o   
  u   
  s   
  edog
     c
     h
     i
     l
     d
     r
     e
     n

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