Dada uma lista de pelo menos duas palavras (feitas apenas com letras minúsculas), construa e exiba uma escada ASCII das palavras alternando a direção da escrita primeiro para a direita e depois para a esquerda, relativamente à direção inicial da esquerda para a direita .

Quando terminar de escrever uma palavra, mude a direção e só então comece a escrever a próxima palavra.

Se o seu idioma não suportar listas de palavras ou for mais conveniente para você, você pode inserir a entrada como uma sequência de palavras, separadas por um único espaço.

Espaços em branco à esquerda e à direita são permitidos.

["hello", "world"] ou "hello world"

hello
    w
    o
    r
    l 
    d

Aqui começamos escrevendo helloe quando chegamos à próxima palavra (ou no caso da entrada como uma string - é encontrado um espaço), alteramos a direção relativa para a direita e continuamos a escreverworld

Casos de teste:

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

Critérios de vencimento

O código mais curto em bytes em todos os idiomas vence. Não se deixe desencorajar pelas línguas do golfe!

Caixa de areia

Carvão , 9 bytes

Ｆ⮌Ａ«↑⮌ι‖↗

Experimente online! Link é a versão detalhada do código. Explicação: Funciona desenhando o texto para trás, transpondo a tela após cada palavra. 10 bytes para entrada de sequência:

Ｆ⮌Ｓ≡ι ‖↗←ι

Experimente online! Link é a versão detalhada do código. Explicação: Desenha o texto para trás, transpondo a tela para espaços.

C (gcc) , 94 78 74 bytes

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

Experimente online!

Imprime a escada, um caractere (da entrada) por vez. Usa uma sequência de palavras separada por espaço.

05AB1E , 19 16 bytes

€θ¨õšøíJD€gs24SΛ

-3 bytes graças a @Emigna .

Experimente online.

Explicação geral:

Assim como @Emigna resposta 05AB1E 's (certifique-se de upvote-lo btw !!), eu uso o builtin lonaΛ .

As opções que eu uso são diferentes (no entanto, é por isso que minha resposta é mais longa ..):

• b(as strings a serem impressas): deixo a primeira string da lista inalterada e adiciono o caractere final a cada próxima string da lista. Por exemplo, ["abc","def","ghi","jklmno"]se tornaria ["abc","cdef","fghi","ijklmno"].
• a(os tamanhos das linhas): isso seria igual a essas strings, [3,4,4,7]como no exemplo acima.
• c(a direção para imprimir):, [2,4]que mapearia para[→,↓,→,↓,→,↓,...]

Portanto, o exemplo acima faria o seguinte passo a passo:

1. Desenhe abcna direção 2/ →.
2. Desenhar cdefna direção 4/ ↓(onde o primeiro caractere se sobrepõe ao último caractere, e é por isso que tivemos que modificar a lista dessa maneira)
3. Desenhar fghina direção 2/ →novamente (também com sobreposição de caracteres iniciais / finais)
4. Desenhar ijklmnona direção 4/ ↓novamente (também com sobreposição)
5. Envie o resultado da tela desenhada imediatamente para STDOUT

Explicação do código:

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

Guardado 1 byte graças a Grimy

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

Experimente online!

Explicação

                 # 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

Tela , 17 12 11 10 bytes

ø⁸⇵｛⟳Ｋ└×∔⤢

Experimente aqui!

Explicação:

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

Recebe a entrada como uma matriz de palavras.

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

Experimente online!

Comentado

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

Experimente online!

cérebro , 57 bytes

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

Experimente online!

Recebe entrada como strings separadas por NUL. Observe que isso está usando EOF como 0 e parará de funcionar quando a escada exceder 256 espaços.

Explicação:

-           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=`
`)

Experimente online!

Obrigado Rick Hitchcock , 2 bytes salvos.

JavaScript, 65 bytes

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

Experimente online!

a => a.replace (/./ g, c => (// para cada caractere c na string a
    1 - c? // se (c é espaço)
      (t =! t, // atualização t: valor booleano descreve o índice de palavras
                       // truthy: palavras indexadas ímpares;
                       // falsy: até palavras indexadas
        ''): // não gera nada por espaço
    t? // if (é um índice ímpar), o que significa que é vertical
      p + c: // adiciona '\ n', alguns espaços e um caractere de sigle
                       // outro
      (p + = p? '': '\ n', // prepare a sequência de prefixos para palavras verticais
         c) // adicione um único caractere
),
  t = p = '' // inicializa
)

Aheui (esótopo) , 490 458 455 bytes

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

Experimente online!

Golpeou ligeiramente usando caracteres de largura total (2 bytes) em vez de coreano (3 bytes).

Explicação

Aheui é esolang parecido com um befunge. Aqui está o código com a cor: 1 parte verifica se o caractere atual é espaço ou não.

2 partes verificam se as palavras foram escritas da direita para a esquerda ou de cima para baixo.

? 3 parte é a condição de quebra do loop que digita espaços.

? 4 partes verificam se o caractere atual é o fim da linha (-1).

A parte vermelha é a inicialização da pilha. Aheui usa pilhas (a partir Nothingde ㅎ: 28 pilhas) para armazenar o valor.

A parte laranja pega input ( 뱋) e verifica se é espaço, subtraindo com 32(código de espaço ascii).

Peça verde adicione 1 à pilha, que armazena o valor do espaço, se estiver escrevendo da direita para a esquerda.

A parte roxa é um loop para espaços de impressão, se for escrita de cima para baixo.

Peça cinza verifique se o caractere atual é -1, adicionando um ao caractere atual.

A parte azul imprime o caractere atual e se prepara para o próximo caractere.

Japonês -P , 15 bytes

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

Tente

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

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

Isso usa seqüências de controle ANSI para mover o cursor - aqui estou usando apenas salvar \e7e restaurar \e8; mas a restauração deve ser prefixada \npara rolar a saída, se ela já estiver na parte inferior do terminal. Por alguma razão, não funcionará se você ainda não estiver na parte inferior do terminal. * dar de ombros *

O caractere atual $cé isolado como uma substring de caractere único da sequência de entrada $w, usando o foríndice do loop $icomo o índice da sequência.

O único truque real que estou usando aqui é o [ -z $c ]que retornará true, ou seja, a cadeia está em branco, quando $cé um espaço, porque não está entre aspas. No uso correto do bash, você citaria a string que está sendo testada -zpara evitar exatamente essa situação. Isso nos permite alternar o sinalizador de direção $dentre 1e 0, que é usado como um índice na matriz de seqüência de controle ANSI, Xno próximo valor não espacial de $c.

Eu estaria interessado em ver algo que usa printf "%${x}s" $c.

Oh Deus, vamos adicionar um espaço em branco. Não consigo ver onde estou ...

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 bytes

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

Experimente online!

Bloco de código anônimo que pega uma lista de palavras e imprime diretamente no STDOUT.

Explicação

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

Carvão , 19 bytes

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

Entrada como uma lista de strings

Experimente online (detalhado) ou online (puro)

Explicação:

Loop no intervalo [0, input-length):

For(Length(q))
ＦＬθ

Se o índice for ímpar:

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

Imprima a sequência no índice iem uma direção descendente:

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

E então mova o cursor uma vez para o canto superior direito:

Move(:UpRight);
↗

Senão (o índice é par):

Else{...}
«...

Imprima a string no índice ina direção correta regular:

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

E então mova o cursor uma vez para o canto inferior esquerdo:

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

Experimente online!

C # (compilador interativo do Visual C #) , 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)));}

Experimente online!

J , ^{47 45} 43 bytes

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

Experimente online!

Eu encontrei uma abordagem divertida e diferente ...

Comecei a mexer com as almofadas esquerdas e zíperes com gerúndios cíclicos e assim por diante, mas então percebi que seria mais fácil calcular a posição de cada letra (isso se resume a uma soma de varredura da matriz escolhida corretamente) e aplicar alterar }em branco lona na entrada arrasada.

A solução é tratada quase inteiramente pela Amend }:

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

• ; ( single verb that does all the work ) ] garfo geral
• ; A parte esquerda arrasa a entrada, ou seja, coloca todas as letras em uma sequência contígua
• ] parte certa é a própria entrada
• (stuff)}usamos a forma gerundial de alterar }, que consiste em três partes v0`v1`v2.
  • v0nos fornece os "novos valores", que são o raze (ou seja, todos os caracteres da entrada como uma string), então usamos [.
  • v2nos dá o valor inicial, que estamos transformando. simplesmente queremos uma tela em branco de espaços com as dimensões necessárias. ([ ' '"0/ [)nos dá um tamanho (all chars)x(all chars).
  • O verbo do meio v1seleciona em quais posições colocaremos nossos caracteres substitutos. Esse é o ponto crucial da lógica ...
• Começando na posição 0 0no canto superior esquerdo, notamos que cada novo personagem está 1 à direita da posição anterior (ou seja prev + 0 1) ou um abaixo (ou seja prev + 1 0). De fato, fazemos o primeiro "len da palavra 1" vezes, depois o último "len da palavra 2" vezes, e assim por diante, alternando. Então, apenas criaremos a sequência correta desses movimentos, depois digitalizaremos a soma deles, e teremos nossas posições, que serão colocadas em caixa, porque é assim que Amend funciona. O que segue é apenas a mecânica dessa idéia ...
• ([: <@(+/)\ #&> # # $ 1 - e.@0 1)
  • Primeiro #:@1 2cria a matriz constante 0 1;1 0.
  • # $depois o estende para que tenha tantas linhas quanto a entrada. por exemplo, se a entrada contiver 3 palavras, ela produzirá 0 1;1 0;0 1.
  • #&> #a parte esquerda é uma matriz dos comprimentos das palavras de entrada e #é copiada; portanto, copia 0 1"len da palavra 1" vezes, depois 1 0"len da palavra 2 vezes" etc.
  • [: <@(+/)\ faz a soma e a caixa da digitalização.

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

Experimente online

Retina , 51 bytes

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

Experimente online!

Uma abordagem bastante direta que marca todas as outras palavras e aplica a transformação diretamente.

Explicação

1,2,`\w+
;$&

Marcamos todas as outras palavras com ponto-e-vírgula, correspondendo a cada palavra, mas aplicando apenas a substituição às correspondências (que são zero indexadas) começando na correspondência 1 e depois 3 e assim por diante.

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

+(mdefine algumas propriedades para os seguintes estágios. O sinal de adição inicia um loop "enquanto este grupo de estágios muda alguma coisa" e o colchete aberto indica que o sinal de mais deve ser aplicado a todos os estágios seguintes até que haja um colchete próximo à frente de um backtick (que é todos os estágios em este caso). O mjust diz ao regex para tratar ^como também correspondente do início das linhas, em vez de apenas do início da string.

O regex real é bastante simples. Simplesmente combinamos a quantidade apropriada de material antes do primeiro ponto e vírgula e usamos a *sintaxe de substituição de Retina para inserir o número correto de espaços.

; |;$

Esta etapa é aplicada após a última para remover ponto e vírgula e espaços no final das palavras que mudamos para vertical.

Retina 0.8.2 , 58 bytes

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

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

Experimente online! O link inclui casos de teste. Solução alternativa, também 58 bytes:

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

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

Experimente online! O link inclui casos de teste.

Deliberadamente, não estou usando o Retina 1 aqui, para não obter operações com palavras alternativas de graça; em vez disso, tenho duas abordagens. A primeira abordagem divide todas as letras em palavras alternativas, contando os espaços anteriores, enquanto a segunda abordagem substitui espaços alternativos por novas linhas e, em seguida, usa os espaços restantes para ajudá-lo a dividir as palavras alternativas em letras. Cada abordagem deve então unir a última letra vertical à próxima palavra horizontal, embora o código seja diferente porque elas dividem as palavras de maneiras diferentes. O estágio final de ambas as abordagens preenche cada linha até que seu primeiro caractere não espacial seja alinhado sob o último caractere da linha anterior.

Note que não presumo que as palavras sejam apenas letras porque não preciso.

PowerShell , 101 89 83 bytes

-12 bytes graças ao mazzy .

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

Experimente online!

PowerShell , 74 65 bytes

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

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

Experimente online!

• -3 bytes graças a @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 @

Isso é executado no SQL Server 2016 e outras versões.

@ mantém a lista delimitada por espaço. @I rastreia a posição do índice na string. @S rastreia o número total de espaços a serem recuados a partir da esquerda. @B rastreia com qual eixo a corda está alinhada no ponto @I.

A contagem de bytes inclui a lista de exemplos mínimos. O script percorre a lista, caractere por caractere, e altera a cadeia de caracteres para que seja exibida de acordo com os requisitos. Quando o final da sequência é atingido, a sequência é impressa.

JavaScript (Node.js) , 75 bytes

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

Experimente online!

Explicação e 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

Execute e depure

Gelatina , 21 bytes

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

Experimente online!

Um programa completo que toma a entrada como uma lista de strings e gera implicitamente para stdout a palavra ladder.

C (gcc) , 93 87 bytes

Obrigado ao gastropner pelas sugestões.

Esta versão utiliza uma matriz de seqüências terminadas por um ponteiro 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++);}

Experimente online!

Brain-Flak , 152 bytes

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

Experimente online!

Eu suspeito que isso possa ser mais curto combinando os dois loops para palavras ímpares e pares.

J, 35 33 bytes

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

Este é um verbo que recebe a entrada como uma única sequência de caracteres com as palavras separadas por espaços. Por exemplo, você poderia chamar assim:

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

A saída é uma matriz de letras e espaços, que o intérprete gera com novas linhas, conforme necessário. Cada linha será preenchida com espaços para que eles tenham exatamente o mesmo comprimento.

Há um pequeno problema com o código: ele não funcionará se a entrada tiver mais de 98 palavras. Se você deseja permitir uma entrada mais longa, substitua o _98no código por _998para permitir até 998 palavras etc.

Deixe-me explicar como isso funciona através de alguns exemplos.

Suponha que tenhamos uma matriz de letras e espaços que imaginamos ser uma saída parcial para algumas palavras, começando com uma palavra horizontal.

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

Como poderíamos acrescentar uma nova palavra antes disso verticalmente? Não é difícil: basta transformar a nova palavra em uma matriz de letras de coluna única com o verbo ,.e anexar a saída à matriz de coluna única. (O verbo ,.é conveniente porque se comporta como uma função de identidade se você o aplicar a uma matriz, que usamos no golfe.)

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

Agora não podemos simplesmente iterar essa maneira de acrescentar uma palavra como está, porque só teríamos palavras verticais. Mas se transpormos a matriz de saída entre cada etapa, todas as outras palavras serão horizontais.

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

Portanto, nossa primeira tentativa de solução é colocar cada palavra em uma matriz de coluna única e depois dobrá-las anexando e transpondo entre elas.

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

Mas há um grande problema com isso. Isso coloca a primeira letra da próxima palavra antes de virar um ângulo reto, mas a especificação requer que seja girada antes de colocar a primeira letra, portanto a saída deve ser algo como isto:

c             
a             
rhouse        
     d        
     o        
     gchildren

A maneira como conseguimos isso é reverter toda a cadeia de entrada, como em

nerdlihc god esuoh rac

use o procedimento acima para criar o zig-zag, mas girando somente após a primeira letra de cada palavra:

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

Em seguida, vire a saída:

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

Mas agora temos outro problema. Se a entrada tiver um número ímpar de palavras, a saída terá a primeira palavra na vertical, enquanto a especificação diz que a primeira palavra deve ser horizontal. Para corrigir isso, minha solução preenche a lista de palavras com exatamente 98 palavras, acrescentando palavras vazias, pois isso não altera a saída.