Draw diagonal lines of text Given an input of a list of words, output the words with their letters arranged
diagonally:

p
 r
  o
p  g
 u  r
  z  a
a  z  m
 n  l  m
  d  e  i
c     s  n
 o        g
  d
g  e
 o
  l
   f


(The above should be the output for the input programming puzzles and code golf.)

To be precise, each word starts on the first column and three rows below the
previous word, and each successive letter moves one column to the right and one
row down.

The input may be provided as either a single string of words, separated by
exactly one space, or a list/array of words. The words will only be composed of
lowercase letters, a-z, and will always be at least one character long.

The output may be a single string, an array of lines, or an array of arrays of
characters. Leading or trailing whitespace is not allowed, except for a single
trailing newline.

Further test cases:

a bcd efgh i j

a


b
 c
  d
e
 f
  g
i  h


j


x

x


verylongword short

v
 e
  r
s  y
 h  l
  o  o
   r  n
    t  g
        w
         o
          r
           d


Since this is code-golf, the shortest code in bytes will win!
Vim, 85, 76, 66, 52 keystrokes/bytes
When I first looked at this challenge, I thought &quot;This is perfect for vim!&quot; And then when I tried it everything went wrong. Here it is, in all of it's messy hacky glory:
:se ve=all|s/ /\r\r\r/g
qqGo&lt;esc&gt;?\&lt;.\S
lDjP@qq@qG?.
jdG

Try it online, thanks to the (mostly) backwards compatible V interpreter.
Explanation:
At first I thought I could do this beautifully simple 37 byte version:
:se ve=all
qq:g/\S\S/norm ^lDjP
@qq@q

Unfortunately, it's not that simple. Let's take it line by line:
:se ve=all

This enables a feature called 'virtual editing'. It allows the cursor to move to columns that don't exist yet. This answer would be basically impossible without it.
Now we need to separate out the words onto different lines. So we'll replace each space with 3 newlines. Since this is an ex command we can run it simultaneously with our last ex command :se ve=all by seperating the two with a bar.
|s/ /\r\r\r/g

Now the buffer looks like this:
Programming


Puzzles


and


code-golf

Here's where the fun begins. We set up the traditional recursive macro with: qq, and then call this:
G               &quot; Move to the last line
 o&lt;esc&gt;         &quot; Append an extra newline

?               &quot; Search backwards for
 \&lt;.            &quot; Any character at the beginning of a word
    \S          &quot; Followed by a non-space character
l               &quot; Move one character to the right
 D              &quot; Delete eveything until the end of this line
  j             &quot; Move down one line
   P            &quot; Paste what we just deleted

Then we finish the recursive macro with @qq@q. At this point, we have all of the diagonals, we just need to do a little clean up.
G                   &quot; Move to the last line
 ?.                 &quot; Search backwards for any character
j                   &quot; Move down one line
 dG                 &quot; Delete until the end of the buffer