Diberikan daftar setidaknya dua kata (hanya terbuat dari huruf kecil), buat dan tampilkan tangga kata ASCII dengan bergantian arah menulis pertama ke kanan, lalu ke kiri, relatif ke arah awal dari kiri ke kanan .

Ketika Anda selesai menulis kata, ubah arah dan baru mulai menulis kata berikutnya.

Jika bahasa Anda tidak mendukung daftar kata, atau lebih nyaman bagi Anda, Anda dapat mengambil input sebagai serangkaian kata, dipisahkan oleh satu spasi.

Ruang putih terkemuka dan tertinggal diizinkan.

["hello", "world"] atau "hello world"

hello
    w
    o
    r
    l 
    d

Di sini kita mulai dengan menulis hellodan ketika kita sampai pada kata berikutnya (atau dalam kasus input sebagai string - spasi ditemukan), kita mengubah arah relatif ke kanan dan terus menulisworld

Kasus uji:

["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

Kriteria menang

Kode terpendek dalam byte di setiap bahasa menang. Jangan biarkan berkecil hati oleh bahasa golf!

Bak pasir

Arang , 9 byte

Ｆ⮌Ａ«↑⮌ι‖↗

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan: Bekerja dengan menggambar teks mundur, transposing kanvas setelah setiap kata. 10 byte untuk input string:

Ｆ⮌Ｓ≡ι ‖↗←ι

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan: Gambar teks mundur, transpos kanvas untuk spasi.

C (gcc) , 94 78 74 byte

-4 dari 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);}

Cobalah online!

Mencetak tangga, satu karakter (dari input) sekaligus. Mengambil serangkaian kata yang dipisahkan oleh ruang.

05AB1E , 19 16 byte

€θ¨õšøíJD€gs24SΛ

-3 byte terima kasih kepada @Emigna .

Cobalah online.

Penjelasan umum:

Sama seperti @Emigna 's jawaban 05AB1E (pastikan untuk upvote dia btw !!), saya menggunakan builtin kanvasΛ .

Namun opsi yang saya gunakan berbeda (itulah sebabnya jawaban saya lebih panjang ..):

• b(string untuk mencetak): Saya membiarkan string pertama dalam daftar tidak berubah, dan menambahkan karakter tambahan ke setiap string berikutnya dalam daftar. Misalnya ["abc","def","ghi","jklmno"]akan menjadi ["abc","cdef","fghi","ijklmno"].
• a(ukuran garis): Ini akan sama dengan string ini, jadi [3,4,4,7]dengan contoh di atas.
• c(arah untuk mencetak):, [2,4]yang akan dipetakan ke[→,↓,→,↓,→,↓,...]

Jadi contoh di atas akan langkah demi langkah melakukan hal berikut:

1. Menggambar abcarah 2/ →.
2. Gambarlah cdefarah 4/ ↓(di mana karakter pertama tumpang tindih dengan karakter terakhir, itulah sebabnya kami harus memodifikasi daftar seperti ini)
3. Menarik fghiarah 2/ →lagi (juga dengan karakter trailing / leading tumpang tindih)
4. Menggambar ijklmnoarah 4/ ↓lagi (juga dengan tumpang tindih)
5. Keluarkan hasil kanvas yang ditarik segera ke STDOUT

Penjelasan kode:

€θ                # 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 byte

Disimpan 1 byte berkat Grimy

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

Cobalah online!

Penjelasan

                 # 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

Kanvas , 17 12 11 10 byte

ø⁸⇵｛⟳Ｋ└×∔⤢

Coba di sini!

Penjelasan:

ø⁸⇵{⟳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 byte

Mengambil input sebagai array kata.

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

Cobalah online!

Berkomentar

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 byte

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

Cobalah online!

brainfuck , 57 byte

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

Cobalah online!

Mengambil input sebagai string yang dipisahkan NUL. Perhatikan bahwa ini menggunakan EOF sebagai 0, dan akan berhenti bekerja ketika tangga melebihi 256 spasi.

Penjelasan:

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

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

Cobalah online!

Terima kasih Rick Hitchcock , 2 byte disimpan.

JavaScript, 65 byte

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

Cobalah online!

a => a.replace (/./g, c => (// untuk setiap karakter c dalam string a
    1 - c? // jika (c adalah ruang)
      (t =! t, // perbarui t: nilai boolean menggambarkan indeks kata
                       // truthy: kata yang diindeks aneh;
                       // falsy: bahkan kata-kata yang diindeks
        ''): // Menghasilkan apa-apa untuk ruang
    t? // jika (indeks ganjil) yang artinya vertikal
      p + c: // tambahkan '\ n', beberapa spasi, dan karakter sigle
                       // lain
      (p + = p? '': '\ n', // siapkan string bergantungan untuk kata-kata vertikal
         c) // tambahkan satu karakter
),
  t = p = '' // menginisialisasi
)

Aheui (esotope) , 490 458 455 byte

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

Cobalah online!

Golf sedikit dengan menggunakan karakter lebar penuh (2 byte), bukan Korea (3 byte).

Penjelasan

Aheui adalah esolang yang seperti es. Berikut ini adalah kode dengan warna :? 1 bagian memeriksa apakah karakter saat ini adalah spasi atau tidak.

? 2 bagian memeriksa apakah kata-kata telah ditulis dari kanan ke kiri atau atas ke bawah.

? 3 bagian adalah kondisi break dari loop yang mengetik spasi.

? 4 bagian memeriksa apakah karakter saat ini adalah ujung garis (-1).

Bagian merah adalah inisialisasi tumpukan. Aheui menggunakan tumpukan (dari Nothingkeㅎ : 28 tumpukan) untuk menyimpan nilai.

Bagian oranye mengambil input ( 뱋) dan memeriksa apakah itu ruang, dengan mengurangi dengan 32(kode ruang ASCII).

Bagian hijau menambahkan 1 ke tumpukan yang menyimpan nilai panjang ruang, jika menulis kanan-ke-kiri.

Bagian ungu adalah lingkaran untuk mencetak ruang, jika menulis naik-turun.

Bagian abu-abu memeriksa apakah karakter saat ini -1, dengan menambahkan satu ke karakter saat ini.

Bagian biru mencetak karakter saat ini, dan mempersiapkan karakter berikutnya.

Japt -P , 15 byte

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

Cobalah

ò 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

bash, 119 karakter

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

Ini menggunakan urutan kontrol ANSI untuk memindahkan kursor - di sini saya hanya menggunakan save \e7and restore \e8; tetapi pemulihan harus diawali dengan \nuntuk menggulir output jika sudah di bagian bawah terminal. Untuk beberapa alasan itu tidak berfungsi jika Anda belum melakukannya di bagian bawah terminal. * mengangkat bahu *

Karakter saat $cini diisolasi sebagai substring karakter tunggal dari string input $w, menggunakan forindeks loop $isebagai indeks ke dalam string.

Satu-satunya trik nyata yang saya gunakan di sini adalah [ -z $c ]yang akan kembali true, yaitu string kosong, kapan $cspasi, karena tidak dikutip. Dalam penggunaan bash yang benar, Anda akan mengutip string yang sedang diuji -zuntuk menghindari situasi ini. Ini memungkinkan kita membalik bendera arah $dantara 1dan 0, yang kemudian digunakan sebagai indeks ke dalam susunan urutan kontrol ANSI, Xpada nilai non-spasi berikutnya $c.

Saya akan tertarik melihat sesuatu yang menggunakan printf "%${x}s" $c.

Astaga, mari kita tambahkan spasi. Saya tidak bisa melihat keberadaan saya ...

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 byte

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

Cobalah online!

Blok kode anonim yang mengambil daftar kata dan mencetak langsung ke STDOUT.

Penjelasan

{                           }  # 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

Arang , 19 byte

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

Masukan sebagai daftar string

Cobalah secara online (verbose) atau coba online (murni)

Penjelasan:

Lingkaran dalam rentang [0, input-length):

For(Length(q))
ＦＬθ

Jika indeksnya ganjil:

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

Cetak string pada indeks ike arah bawah:

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

Dan kemudian gerakkan kursor sekali ke kanan atas:

Move(:UpRight);
↗

Lain-lain (indeks genap):

Else{...}
«...

Cetak string pada indeks ike arah yang benar:

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

Dan kemudian gerakkan kursor sekali ke kiri bawah:

Move(:DownLeft);
↙

Python 2 , 89 88 byte

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

Cobalah online!

C # (Visual C # Interactive Compiler) , 122 byte

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)));}

Cobalah online!

J , ^{47 45} 43 byte

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

Cobalah online!

Saya menemukan pendekatan yang menyenangkan dan berbeda ...

Saya mulai bermain-main dengan pembalut kiri dan ritsleting dengan gerund siklik dan sebagainya, tetapi kemudian saya menyadari akan lebih mudah untuk hanya menghitung posisi setiap huruf (ini bermuara pada jumlah pemindaian dari array yang dipilih dengan benar) dan menerapkan perubahan } ke blank kanvas pada input yang diratakan.

Solusi ditangani hampir seluruhnya oleh Amend }:

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

• ; ( single verb that does all the work ) ] garpu keseluruhan
• ; bagian kiri meratakan input, yaitu, menempatkan semua huruf ke dalam string yang berdekatan
• ] Bagian kanan adalah input itu sendiri
• (stuff)}kami menggunakan bentuk amandemen gerund }, yang terdiri dari tiga bagian v0`v1`v2.
  • v0memberi kita "nilai baru", yang merupakan raze (yaitu, semua karakter input sebagai satu string), jadi kami gunakan [.
  • v2memberi kami nilai awal, yang kami transformasikan. kami hanya ingin kanvas kosong dari ruang dimensi yang dibutuhkan. ([ ' '"0/ [)memberi kita satu ukuran(all chars)x(all chars) .
  • Kata kerja tengah v1memilih posisi mana yang akan kita masukkan karakter pengganti kita. Ini adalah inti dari logika ...
• Mulai dari posisi 0 0di kiri atas, kita perhatikan bahwa setiap karakter baru adalah 1 di sebelah kanan posisi sebelumnya (yaitu, prev + 0 1) atau satu ke bawah (yaitu, prev + 1 0). Memang kita melakukan "len kata 1" kali, lalu "len kata 2" kali, dan seterusnya, secara bergantian. Jadi kita hanya akan membuat urutan yang benar dari gerakan-gerakan ini, kemudian memindai jumlahnya, dan kita akan memiliki posisi kita, yang kemudian kita kotak karena itulah cara Amend bekerja. Berikut ini hanyalah mekanisme dari ide ini ...
• ([: <@(+/)\ #&> # # $ 1 - e.@0 1)
  • Pertama #:@1 2menciptakan matriks konstan 0 1;1 0.
  • # $kemudian memanjang sehingga memiliki baris sebanyak input. misal, jika input mengandung 3 kata maka akan dihasilkan 0 1;1 0;0 1.
  • #&> #bagian kiri itu adalah larik panjang kata-kata yang dimasukkan dan #disalin, sehingga menyalin 0 1"len kata 1" kali, lalu 1 0"len kata 2 kali", dll.
  • [: <@(+/)\ apakah jumlah dan kotak pindai.

T-SQL, 185 byte

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,'')

Cobalah online

Retina , 51 byte

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

Cobalah online!

Pendekatan yang agak langsung yang menandai setiap kata lain dan kemudian menerapkan transformasi secara langsung.

Penjelasan

1,2,`\w+
;$&

Kami menandai setiap kata lain dengan tanda titik koma dengan mencocokkan setiap kata, tetapi hanya menerapkan penggantian pada kecocokan (yang tidak diindeks nol) mulai dari kecocokan 1 lalu 3 dan seterusnya.

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

+(mset beberapa properti untuk tahapan berikut. Nilai tambah memulai loop "sementara kelompok tahap ini mengubah sesuatu", dan tanda kurung buka menunjukkan bahwa tanda plus harus berlaku untuk semua tahap berikut sampai ada tanda kurung di depan backtick (yang merupakan semua tahap dalam kasus ini). The mhanya memberitahu regex untuk memperlakukan ^sebagai juga cocok dari awal garis bukan hanya awal dari string.

Regex yang sebenarnya cukup mudah. Kami cukup mencocokkan jumlah barang yang sesuai sebelum titik koma pertama dan kemudian menggunakan *sintaks pengganti Retina untuk memasukkan jumlah ruang yang benar.

; |;$

Tahap ini diterapkan setelah yang terakhir untuk menghapus titik koma dan spasi di akhir kata yang kami ubah menjadi vertikal.

Retina 0.8.2 , 58 byte

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

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

Cobalah online! Tautan termasuk kasus uji. Solusi alternatif, juga 58 byte:

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

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

Cobalah online! Tautan termasuk kasus uji.

Saya sengaja tidak menggunakan Retina 1 di sini, jadi saya tidak mendapatkan operasi kata-kata alternatif secara gratis; sebaliknya saya punya dua pendekatan. Pendekatan pertama membagi semua huruf dalam kata-kata alternatif dengan menghitung spasi sebelumnya, sedangkan pendekatan kedua menggantikan spasi alternatif dengan baris baru dan kemudian menggunakan spasi yang tersisa untuk membantunya membagi kata-kata alternatif menjadi huruf. Setiap pendekatan kemudian harus menggabungkan huruf vertikal terakhir dengan kata horizontal berikutnya, walaupun kodenya berbeda karena mereka membagi kata dengan cara yang berbeda. Tahap terakhir dari kedua pendekatan kemudian mengisi setiap baris sampai karakter non-spasi pertamanya disejajarkan di bawah karakter terakhir dari baris sebelumnya.

Perhatikan bahwa saya tidak menganggap bahwa kata-kata hanyalah huruf karena saya tidak harus.

PowerShell , 101 89 83 byte

-12 byte berkat mazzy .

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

Cobalah online!

PowerShell , 74 65 byte

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

Cobalah online!

R , 126 byte

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}

Cobalah online!

• -3 byte terima kasih kepada @Giuseppe

T-SQL, 289 byte

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 @

Ini berjalan pada SQL Server 2016 dan versi lainnya.

@ memegang daftar yang dibatasi ruang. @ Saya melacak posisi indeks dalam string. @ S melacak jumlah total ruang yang diindentasi dari kiri. @B melacak sumbu yang disejajarkan dengan string pada titik @I.

Hitungan byte menyertakan daftar contoh minimal. Script menelusuri daftar, karakter demi karakter, dan mengubah string sehingga akan ditampilkan sesuai dengan persyaratan. Ketika akhir string tercapai, string tersebut DICETAK.

JavaScript (Node.js) , 75 byte

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

Cobalah online!

Penjelasan dan ungolfed

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 byte

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

Jalankan dan debug itu

Jelly , 21 byte

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

Cobalah online!

Sebuah program lengkap mengambil input sebagai daftar string dan secara implisit mengeluarkan untuk stdout kata tangga.

C (gcc) , 93 87 byte

Terima kasih kepada gastropner untuk sarannya.

Versi ini mengambil array string yang diakhiri oleh pointer 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++);}

Cobalah online!

Brain-Flak , 152 byte

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

Cobalah online!

Saya menduga ini bisa lebih pendek dengan menggabungkan dua loop untuk kata-kata aneh dan genap.

J, 35 33 byte

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

Ini adalah kata kerja yang mengambil input sebagai string tunggal dengan kata-kata yang dipisahkan oleh spasi. Misalnya, Anda bisa menyebutnya seperti ini:

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

Outputnya adalah matriks huruf dan spasi, yang mana interpreter menampilkan dengan baris baru sesuai kebutuhan. Setiap baris akan diisi dengan spasi sehingga mereka memiliki panjang yang sama persis.

Ada sedikit masalah dengan kode: kode tidak akan berfungsi jika input memiliki lebih dari 98 kata. Jika Anda ingin memperbolehkan input yang lebih panjang, gantilah _98kode itu dengan _998mengizinkan hingga 998 kata, dll.

Izinkan saya menjelaskan bagaimana ini bekerja melalui beberapa contoh.

Misalkan kita memiliki matriks huruf dan spasi yang kita bayangkan adalah output parsial untuk beberapa kata, dimulai dengan kata horizontal.

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

Bagaimana kita bisa menambahkan kata baru sebelum ini, secara vertikal? Ini tidak sulit: cukup ubah kata baru menjadi matriks kolom tunggal huruf dengan kata kerja ,., lalu tambahkan output ke matriks kolom tunggal itu. (Kata kerja,. mudah digunakan karena berfungsi sebagai fungsi identitas jika Anda menerapkannya pada matriks, yang kami gunakan untuk bermain golf.)

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

Sekarang kita tidak bisa hanya mengulangi cara menambahkan kata seperti apa adanya, karena dengan begitu kita hanya akan mendapatkan kata-kata vertikal. Tetapi jika kita memindahkan matriks output di antara setiap langkah, maka setiap kata lainnya akan horisontal.

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

Jadi upaya pertama kita untuk solusi adalah memasukkan setiap kata ke dalam matriks satu kolom, kemudian lipat dengan menambahkan dan mentransposisi di antara mereka.

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

Tapi ada masalah besar dengan ini. Ini menempatkan huruf pertama dari kata berikutnya sebelum berbelok ke kanan, tetapi spesifikasinya membutuhkan pengubahan sebelum meletakkan huruf pertama, jadi hasilnya harus seperti ini:

c             
a             
rhouse        
     d        
     o        
     gchildren

Cara kami mencapai ini adalah membalikkan seluruh string input, seperti pada

nerdlihc god esuoh rac

kemudian gunakan prosedur di atas untuk membangun zig-zag tetapi berputar hanya setelah huruf pertama dari setiap kata:

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

Kemudian balikkan hasilnya:

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

Tapi sekarang kita punya masalah lain. Jika input memiliki jumlah kata ganjil, maka output akan memiliki kata vertikal pertama, sedangkan spesifikasi mengatakan bahwa kata pertama harus horisontal. Untuk memperbaikinya, solusi saya membuat daftar kata-kata persis 98 kata, menambahkan kata-kata kosong, karena itu tidak mengubah output.