Given a list of at least two words (made only of lowercase letters), construct and display an ASCII ladder of the words by alternating the direction of writing first to the right, then to the left, relatively to the initial direction from left to right.

When you finish writing a word, change the direction and only then start writing the next word.

If your language doesn't support lists of words, or it's more convenient for you, you can take the input as a string of words, separated by a single space.

Leading and trailing whitespaces are allowed.

["hello", "world"] or "hello world"

hello
w
o
r
l
d


Here we start by writing hello and when we come to the next word (or in the case of the input as a string - a space is found), we change the relative direction to the right and continue to write world

## Test cases:

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


## Wining criteria

The shortest code in bytes in every language wins. Don't let be discouraged by the golfing languages!

Sandbox

# Charcoal, 9 bytes

Ｆ⮌Ａ«↑⮌ι‖↗


Try it online! Link is to verbose version of code. Explanation: Works by drawing the text backwards, transposing the canvas after every word. 10 bytes for string input:

Ｆ⮌Ｓ≡ι ‖↗←ι


Try it online! Link is to verbose version of code. Explanation: Draws the text backwards, transposing the canvas for spaces.

# C (gcc), 9478 74 bytes

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


Try it online!

Prints the ladder, one character (of the input) at a time. Takes a space-separated string of words.

• Could change *s==32 into *s<33 to save a byte. – gastropner May 24 '19 at 11:03
• 74 Bytes – Johan du Toit May 25 '19 at 12:01

# 05AB1E, 19 16 bytes

€θ¨õšøíJD€gs24SΛ


-3 bytes thanks to @Emigna.

Try it online.

General explanation:

Just like @Emigna's 05AB1E answer (make sure to upvote him btw!!), I use the Canvas builtin Λ.

The options I use are different however (which is why my answer is longer..):

• b (the strings to print): I leave the first string in the list unchanged, and add the trailing character to each next string in the list. For example ["abc","def","ghi","jklmno"] would become ["abc","cdef","fghi","ijklmno"].
• a (the sizes of the lines): This would be equal to these strings, so [3,4,4,7] with the example above.
• c (the direction to print in): [2,4], which would map to [→,↓,→,↓,→,↓,...]

So the example above would step-by-step do the following:

1. Draw abc in direction 2/→.
2. Draw cdef in direction 4/↓ (where the first character overlaps with the last character, which is why we had to modify the list like this)
3. Draw fghi in direction 2/→ again (also with overlap of trailing/leading characters)
4. Draw ijklmno in direction 4/↓ again (also with overlap)
5. Output the result of the drawn Canvas immediately to STDOUT

Code explanation:

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

• Your versions 2/3/4 could save 3 bytes with €θ¨õšsøJ. – Emigna May 23 '19 at 9:45
• @Emigna Thanks! Now that I see it it looks so simple.. And here I had three alternative 19-byters instead.. – Kevin Cruijssen May 23 '19 at 10:15
• Some alternatives to €θ¨õšsøJ are õIvy«¤}), õUεXì¤U} and ε¯Jθì¤ˆ} (the last two require --no-lazy). Unfortunately, those are all the same length. This would be much easier if one of the variables defaulted to ""... – Grimmy May 23 '19 at 14:27
• @Grimy "This would be much easier if one of the variables defaulted to ""..." Are you looking for õ, or you mean if X/Y/® would have been ""? Btw, nice 13 byter in the comment of Emigna's answer. Quite different than both mine and his tbh, with the directions [→,↙,↓,↗] that you've used. – Kevin Cruijssen May 23 '19 at 14:30
• õ is not a variable. Yes, I mean a variable that defaults to "". I literally do õU at the start of one of the snippets, so if X (or any other variable) defaulted to "", it would trivially save two bytes. Thanks! Yeah, ↙↗ is a bit new, but I got the idea of interspersing the true writes with length 2 dummy writes from Emigna's answer. – Grimmy May 23 '19 at 14:36

# 05AB1E, 14 13 bytes

Saved 1 byte thanks to Grimy

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


Try it online!

Explanation

                 # 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

• Oh dang, nice approach! I will post my 19-byte versions in a moment, but very nice with the Bifurcate and drawing just two letters. – Kevin Cruijssen May 23 '19 at 7:50
• Btw, you know there is a builtin for interspersing, right? €Y¦ could be 2.ý (not that it would save any bytes here). And this is the first time where I've seen the new behavior of € in comparison to the regular map being useful. – Kevin Cruijssen May 23 '19 at 8:13
• @KevinCruijssen: I have seen .ý used before but I've never used myself so I didn't think of it. € is the regular map to me and I've often used it, the other one is the "new" map ;) – Emigna May 23 '19 at 9:29
• – Grimmy May 23 '19 at 11:49
• My bad, I failed to notice the even/odd difficulty! Here's a 13 that should actually work: €ðÀD€g>sŽ9÷SΛ – Grimmy May 23 '19 at 14:24

# Canvas, 171211 10 bytes

ø⁸⇵｛⟳Ｋ└×∔⤢


Try it here!

Explanation:

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

Takes input as an array of words.

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


Try it online!

### Commented

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

• Use of p for keeping track of line endings is very smart +1 – Downgoat May 30 '19 at 23:04

# Python 2, 82 bytes

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


Try it online!

# brainfuck, 57 bytes

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


Try it online!

Takes input as NUL separated strings. Note that this is using EOF as 0, and will stop working when the ladder exceeds 256 spaces.

### Explanation:

-           Initialise counter as -1
[.<+>,]  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
]

• May I ask for solution in Brain-Flak? – Galen Ivanov May 24 '19 at 17:44
• My first attempt to understand BF. 2 questions: How is the first word being printed when there is no . char in line 3 (of the commented version)? I was trying to play with the input on TIO. On Mac, I switched keyboard to Unicode text input and tried creating new word boundaries by typing option+0000 but it didn't work. Any idea why not? – Jonah May 25 '19 at 18:52
• @Jonah Ah good catch, I accidentally typed - instead of . for the explanation. For adding NUL bytes in TIO, I recommend using the console and running a command like $('#input').value =$('#input').value.replace(/\s/g,"\0");. I don't know why your way didn't work – Jo King May 26 '19 at 4:15

# JavaScript, 62 bytes

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


Try it online!

Thanks Rick Hitchcock, 2 bytes saved.

# JavaScript, 65 bytes

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


Try it online!

a=>a.replace(/./g,c=>( // for each character c in string a
1 - c ?            //   if (c is space)
(t = !t,         //     update t: boolean value describe word index
//       truthy: odd indexed words;
//       falsy: even indexed words
'') :          //     generate nothing for space
t?                 //   if (is odd index) which means is vertical
p+c :            //     add '\n', some spaces, and a sigle charater
//   else
(p+=p?' ':'\n',  //     prepare the prepend string for vertical words
c)            //     add a single character
),
t=p=''               //   initialize
)

• I think you can save 2 bytes by replacing t with a, then removing t= – Rick Hitchcock May 24 '19 at 21:43

# Aheui (esotope), 490458 455 bytes

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


Try it online!

Slightly golfed by using full-width characters(2 bytes) instead Korean(3 bytes).

# Explanation

Aheui is befunge-like esolang. Here is code with color: ?1 part checks if current character is space or not.

?2 parts check whether words had written right-to-left or top-to-down.

?3 part is break condition of loop which types spaces.

?4 parts check if current character is end of line(-1).

Red part is stack initialization. Aheui uses stacks (from Nothing to ㅎ : 28 stacks) to store value.

Orange part takes input(뱋) and check if it is space, by subtracting with 32(ascii code of space).

Green part add 1 to stack which stores value of length of space, if writing right-to-left.

Purple part is loop for printing spaces, if writing up-to-down.

Grey part check if current character is -1, by adding one to current character.

Blue part prints current character, and prepare for next character.

• What did you use to generate the image in this post? – bb94 Jun 10 '19 at 9:13
• @bb94 base is AheuiChem, nice built Korean Aheui online (sort of) IDE. And I used Powerpoint to color it. – LegenDUST Jun 10 '19 at 9:14

# Japt-P, 15 bytes

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


Try it

ò 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 chars

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  This uses ANSI control sequences to move the cursor - here I'm only using save \e7 and restore \e8; but the restore has to be prefixed with \n to scroll the output if it's already at the bottom of the terminal. For some reason it doesn't work if you're not already at the bottom of the terminal. * shrug * The current character $c is isolated as a single-character substring from the input string $w, using the for loop index $i as the index into the string.

The only real trick I'm using here is [ -z $c ] which will return true, i.e. the string is blank, when $c is a space, because it's unquoted. In correct usage of bash, you would quote the string being tested with -z to avoid exactly this situation. This allows us flip the direction flag $d between 1 and 0, which is then used as an index into the ANSI control sequence array, X on the next non-space value of $c.

I'd be interested to see something that uses printf "%${x}s"$c.

Oh gosh let's add some whitespace. I can't see where I am...

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  • Oh by the way, you can't try this one on that tio.run site - like a few others, there's no ANSI control sequence handling so it just barfs. – Rich May 24 '19 at 2:17 # Perl 6, 65 bytes {$/=0;.map:{$/+=$++%2??!.comb.fmt("%$/s"," ").print!!.say*.comb}}  Try it online! Anonymous code block that takes a list of words and prints straight to STDOUT. ### Explanation { } # 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  • I'm curious how this one works Jo, I don't know Perl 6 – Jonah May 24 '19 at 2:23 • @Jonah I've added an explanation – Jo King May 24 '19 at 2:49 • Thanks, nice solution. – Jonah May 24 '19 at 3:17 # Charcoal, 19 bytes ＦＬθ¿﹪ι²«↓§θι↗»«§θι↙  Input as a list of strings Explanation: Loop in the range [0, input-length): For(Length(q)) ＦＬθ  If the index is odd: If(Modulo(i,2)){...} ﹪ι²«...»  Print the string at index i in a downward direction: Print(:Down, AtIndex(q,i)); ↓§θι  And then move the cursor once towards the top-right: Move(:UpRight); ↗  Else (the index is even): Else{...} «...  Print the string at index i in a regular right direction: Print(AtIndex(q,i)); §θι  And then move the cursor once towards the bottom-left: Move(:DownLeft); ↙  # Python 2, 89 88 bytes s=i=-1 r='' for w in input():r+=[('\n'+' '*s).join(' '+w),w][i];s-=i*len(w);i=~i print r  Try it online! # C# (Visual C# Interactive Compiler), 122 bytes 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)));}  Try it online! # J, 47 45 43 bytes ;[(([:<@(+/)\#&>##$#:@1 2)@])([' '"0/[)}]


Try it online!

I found a fun, different approach...

I started messing around with left pads and zips with cyclic gerunds and so on, but then I realized it would be easier to just calculate each letter's position (this boils down to a scan sum of the correctly chosen array) and apply amend } to a blank canvas on the razed input.

The solution is handled almost entirely by Amend }:

; [(([: <@(+/)\ #&> # # $#:@1 2)@])([ ' '"0/ [)} ]  • ; ( single verb that does all the work ) ] overall fork • ; left part razes the input, ie, puts all the letters into a contiguous string • ] right part is the input itself • (stuff)} we use the gerund form of amend }, which consists of three parts v0v1v2. • v0 gives us the "new values", which is the raze (ie, all the characters of the input as one string), so we use [. • v2 gives us the starting value, which we are transforming. we simply want a blank canvas of spaces of the needed dimensions. ([ ' '"0/ [) gives us one of size (all chars)x(all chars). • The middle verb v1 selects which positions we will put our replacement characters in. This is the crux of the logic... • Starting at position 0 0 in the upper left, we notice that each new character is either 1 to the right of the previous position (ie, prev + 0 1) or one down (ie, prev + 1 0). Indeed we do the former "len of word 1" times, then the latter "len of word 2" times, and so on, alternating. So we'll just create the correct sequence of these movements, then scan sum them, and we'll have our positions, which we then box because that's how Amend works. What follows is just the mechanics of this idea... • ([: <@(+/)\ #&> # #$ 1 - e.@0 1)
• First #:@1 2 creates the constant matrix 0 1;1 0.
• # $ then extends it so it has as many rows as the input. eg, if the input contains 3 words it will produce 0 1;1 0;0 1. • #&> # the left part of that is an array of the lengths of the input words and # is copy, so it copies 0 1 "len of word 1" times, then 1 0 "len of word 2 times", etc. • [: <@(+/)\ does the scan sum and box. # T-SQL, 185 bytes 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,'')  Try it online • Very clever use of BIT values, the delimiter spaces, and circular string processing. Much better answer than mine! – Muqo May 24 '19 at 12:13 # Retina, 51 bytes 1,2,\w+ ;$&
+(m^(.(.*?)) ?;(.)
$1¶$.2* $3; ; |;$



Try it online!

A rather straightforward approach that marks every other word and then applies the transformation directly.

### Explanation

1,2,\w+
;$&  We mark every other word with a semicolon by matching each word, but only applying the replacement to the matches (which are zero indexed) starting from match 1 and then 3 and so on. +(m^(.(.*?)) ?;(.)$1¶$.2*$3;


+(m sets some properties for the following stages. The plus begins a "while this group of stages changes something" loop, and the open bracket denotes that the plus should apply to all of the following stages until there is a close bracket in front of a backtick (which is all of the stages in this case). The m just tells the regex to treat ^ as also matching from the beginning of lines instead of just the beginning of the string.

The actual regex is pretty straightforward. We simply match the appropriate amount of stuff before the first semicolon and then use Retina's * replacement syntax to put in the correct number of spaces.

+ (.)
¶$1 ¶ +(..(.)*¶)((?<-2> )*\S)$1 3  Try it online! Link includes test cases. I'm deliberately not using Retina 1 here, so I don't get operations on alternate words for free; instead I have two approaches. The first approach splits on all letters in alternate words by counting preceding spaces, while the second approach replaces alternate spaces with newlines and then uses the remaining spaces to help it split alternate words into letters. Each approach has to then join the last vertical letter with the next horizontal word, although the code is different because they split the words in different ways. The final stage of both approaches then pads each line until its first non-space character is aligned under the last character of the previous line. Note that I don't assume that words are just letters because I don't have to. # PowerShell, 101 89 83 bytes -12 bytes thanks to mazzy. args|%{$l+=if(++$i%2){$_.length-1;$t+=$_}else{1;$_|% t*y|%{$t+=' '+' '*$l+$_}}};$t


Try it online!

• nice. you can: 1) remove first line, 2) use a splatting & $b @p (each word as one argument), 3) use shorter form for new line constant. see 3,4 line at this example – mazzy May 25 '19 at 14:37 • @mazzy, with the splatting i get wrong answer for foo. see the code. – Andrei Odegov May 25 '19 at 15:25 • oO! The splatting splits one word to a char array. Interesting. Thanks! – mazzy May 25 '19 at 17:01 • @mazzy, it's not my fault :) – Andrei Odegov May 25 '19 at 17:54 • I think we can use the rule Given a list of at least two words... – mazzy May 25 '19 at 18:03 # PowerShell, 74 65 bytes -join($args|%{$_|% t*y|%{($p+=(' ','
')[!$p]*!$i)*$i;$_};$i=!$i})


Try it online!

# R, 126 bytes

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}


Try it online!

• -3 bytes thanks to @Giuseppe

## T-SQL, 289 bytes

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 @


This runs on SQL Server 2016 and other versions.

@ holds the space-delimited list. @I tracks the index position in the string. @S tracks the total number of spaces to indent from the left. @B tracks which axis the string is aligned with at point @I.

The byte count includes the minimal example list. The script goes through the list, character by character, and changes the string so that it will display according to the requirements. When the end of the string is reached, the string is PRINTed.

• Hi @Mugo It seems there is a glitch in your script when using longer input. If you test with the data from my answer, you will see there is a unintended bend in the last word between p and t – t-clausen.dk May 24 '19 at 10:29
• @t-clausen.dk Oops, I didn't handle the last iteration properly. Thanks! – Muqo May 24 '19 at 10:55
• confirmed it works now – t-clausen.dk May 24 '19 at 11:08

# JavaScript (Node.js), 75 bytes

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


Try it online!

### Explanation and 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.
);
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 bytes

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


Run and debug it

# Jelly, 21 bytes

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


Try it online!

A full program taking the input as a list of strings and implicitly outputting to stdout the word ladder.

# C (gcc), 93 87 bytes

Thanks to gastropner for the suggestions.

This version takes an array of strings terminated by a NULL pointer.

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


Try it online!

# Brain-Flak, 152 bytes

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


Try it online!

I suspect this can be shorter by combining the two loops for odd and even words.

• Thank you for this! – Galen Ivanov May 25 '19 at 6:23

## J, 35 33 bytes

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


This is a verb that takes the input as a single string with the words separated by spaces. For example, you could call it like this:

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


The output is a matrix of letters and spaces, which the interpreter outputs with newlines as required. Each line will be padded with spaces so they have the exact same length.

There's one slight problem with the code: it won't work if the input has more than 98 words. If you want to allow a longer input, replace the _98 in the code by _998 to allow up to 998 words, etc.

Let me explain how this works through some examples.

Suppose we have a matrix of letters and spaces that we imagine is a partial output for some words, starting with a horizontal word.

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


How could we prepend a new word before this, vertically? It's not hard: just turn the new word to a single-column matrix of letters with the verb ,., then append the output to that single-column matrix. (The verb ,. is convenient because it behaves as an identity function if you apply it to a matrix, which we use for golfing.)

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


Now we can't just iterate this way of prepending a word as is, because then we'd only get vertical words. But if we transpose the output matrix between each step, then every other word will be horizontal.

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


So our first attempt for a solution is to put each word into a single-column matrix, then fold these by appending and transposing between them.

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


But there's a big problem with this. This puts the first letter of the next word before turning a right angle, but the specification requires turning before putting the first letter, so the output should be something like this instead:

c
a
rhouse
d
o
gchildren


The way we achieve this is to reverse the entire input string, as in

nerdlihc god esuoh rac


then use the above procedure to build the zig-zag but turning only after the first letter of each word:

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


Then flip the output:

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

But now we have yet another problem. If the input has an odd number of words, then the output will have the first word vertical, whereas the specification says that the first word must be horizontal. To fix this, my solution pads the list of words to exactly 98 words, appending empty words, since that doesn't change the output.