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), 94 78 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.

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)

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

Canvas, 17 12 11 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:

          ''.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 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

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

)

Aheui (esotope), 490 458 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.

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" "ne8")

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" "ne8")

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

Charcoal, 19 bytes

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

Input as a list of strings

Try it online (verbose) or try it online (pure)

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 v0`v1`v2.
  
  
  
  
  • 
    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

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.

; |;$

This stage is applied after the last one to remove semicolons and spaces at the end of words that we changed to vertical.

Retina 0.8.2, 58 bytes

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

¶

¶? 



+`(..(.)*¶)((?<-2> )*S)

$1 $3

Try it online! Link includes test cases. Alternative solution, also 58 bytes:

( S*) 

$1¶

+` (.)

¶$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!

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.

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.

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

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.