Dada una lista de al menos dos palabras (hechas solo con letras minúsculas), construya y muestre una escalera ASCII de las palabras alternando la dirección de escritura primero a la derecha, luego a la izquierda, relativamente a la dirección inicial de izquierda a derecha .

Cuando termine de escribir una palabra, cambie la dirección y solo entonces comience a escribir la siguiente palabra.

Si su idioma no admite listas de palabras, o es más conveniente para usted, puede tomar la entrada como una cadena de palabras, separadas por un solo espacio.

Se permiten espacios en blanco iniciales y finales.

["hello", "world"] o "hello world"

hello
    w
    o
    r
    l 
    d

Aquí comenzamos escribiendo helloy cuando llegamos a la siguiente palabra (o en el caso de la entrada como una cadena, se encuentra un espacio), cambiamos la dirección relativa a la derecha y continuamos escribiendoworld

Casos de prueba:

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

Criterios de victoria

El código más corto en bytes en cada idioma gana. ¡No te dejes desanimar por los idiomas de golf!

Salvadera

Carbón de leña , 9 bytes

Ｆ⮌Ａ«↑⮌ι‖↗

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación: funciona dibujando el texto hacia atrás, transponiendo el lienzo después de cada palabra. 10 bytes para la entrada de cadena:

Ｆ⮌Ｓ≡ι ‖↗←ι

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación: Dibuja el texto hacia atrás, transponiendo el lienzo para espacios.

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

Pruébalo en línea!

Imprime la escalera, un carácter (de la entrada) a la vez. Toma una cadena de palabras separadas por espacios.

05AB1E , 19 16 bytes

€θ¨õšøíJD€gs24SΛ

-3 bytes gracias a @Emigna .

Pruébalo en línea.

Explicación general:

Al igual que @Emigna respuesta 05AB1E 's (asegúrese de que le upvote por cierto !!), utilizo la orden interna lienzoΛ .

Sin embargo, las opciones que uso son diferentes (por eso mi respuesta es más larga ...):

• b(las cadenas para imprimir): dejo la primera cadena en la lista sin cambios y agrego el carácter final a cada cadena siguiente en la lista. Por ejemplo ["abc","def","ghi","jklmno"]se convertiría ["abc","cdef","fghi","ijklmno"].
• a(los tamaños de las líneas): esto sería igual a estas cadenas, así que [3,4,4,7]con el ejemplo anterior.
• c(la dirección para imprimir): [2,4]que se asignaría a[→,↓,→,↓,→,↓,...]

Entonces, el ejemplo anterior haría paso a paso lo siguiente:

1. Dibujar abcen dirección 2/ →.
2. Dibujar cdefen dirección 4/ ↓(donde el primer carácter se superpone con el último carácter, por lo que tuvimos que modificar la lista así)
3. Dibujar fghien dirección 2/ →nuevamente (también con superposición de caracteres finales / iniciales)
4. Dibujar ijklmnoen dirección 4/↓ nuevamente (también con superposición)
5. Salida del resultado del lienzo dibujado inmediatamente a STDOUT

Explicación del 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 gracias a Grimy

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

Pruébalo en línea!

Explicación

                 # 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

Lienzo , 17 12 11 10 bytes

ø⁸⇵｛⟳Ｋ└×∔⤢

Pruébalo aquí!

Explicación:

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

Toma entrada como un conjunto de palabras.

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

Pruébalo en línea!

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

Pruébalo en línea!

brainfuck , 57 bytes

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

Pruébalo en línea!

Toma la entrada como cadenas separadas NUL. Tenga en cuenta que esto está utilizando EOF como 0 y dejará de funcionar cuando la escalera exceda los 256 espacios.

Explicación:

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

Pruébalo en línea!

Gracias Rick Hitchcock , 2 bytes guardados.

JavaScript, 65 bytes

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

Pruébalo en línea!

a => a.replace (/./ g, c => (// para cada carácter c en la cadena a
    1 - c? // if (c es espacio)
      (t =! t, // actualizar t: valor booleano describir índice de palabras
                       // verdad: palabras indexadas impares;
                       // falsedad: incluso palabras indexadas
        ''): // no genera nada para el espacio
    t? // if (es un índice impar) lo que significa que es vertical
      p + c: // agrega '\ n', algunos espacios y un carácter sigle
                       // más
      (p + = p? '': '\ n', // prepara la cadena de antecedente para palabras verticales
         c) // agrega un solo carácter
),
  t = p = '' // inicializar
)

Aheui (esotope) , 490 458 455 bytes

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

Pruébalo en línea!

Ligeramente golfizado mediante el uso de caracteres de ancho completo (2 bytes) en lugar de coreano (3 bytes).

Explicación

Aheui es como esolang de befunge. Aquí hay un código con color: 1 parte verifica si el carácter actual es espacio o no.

2 partes verifican si las palabras se escribieron de derecha a izquierda o de arriba a abajo.

? 3 parte es la condición de ruptura del bucle que escribe espacios.

? 4 partes verifican si el carácter actual es el final de la línea (-1).

La parte roja es la inicialización de la pila. Aheui usa pilas (desde Nothinghastaㅎ : 28 pilas) para almacenar el valor.

La parte naranja toma input ( 뱋) y verifica si es espacio, restando con 32(código ASCII del espacio).

La parte verde agrega 1 a la pila que almacena el valor de la longitud del espacio, si se escribe de derecha a izquierda.

La parte morada es un bucle para imprimir espacios, si se escribe de arriba abajo.

La parte gris verifica si el carácter actual es -1, agregando uno al carácter actual.

La parte azul imprime el carácter actual y se prepara para el próximo carácter.

Japt -P , 15 bytes

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

Intentalo

ò 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

Esto usa secuencias de control ANSI para mover el cursor; aquí solo estoy usando guardar \e7y restaurar \e8; pero la restauración tiene que tener el prefijo\n para desplazar la salida si ya está en la parte inferior del terminal. Por alguna razón, no funciona si aún no está en la parte inferior de la terminal. * encogerse de hombros *

El carácter actual $cestá aislado como una subcadena de un solo carácter de la cadena de entrada.$w , utilizando el foríndice de bucle $icomo el índice en la cadena.

El único truco real que estoy usando aquí es el [ -z $c ]que volverá true, es decir, la cadena está en blanco, cuando $ces un espacio, porque no está entre comillas. En el uso correcto de bash, debe citar la cadena que se está probando -zpara evitar exactamente esta situación. Esto nos permite voltear el indicador de dirección $dentre 1y 0, que luego se utiliza como índice en la matriz de secuencia de control ANSI, Xen el siguiente valor no espacial de $c.

Me interesaría ver algo que use printf "%${x}s" $c.

Oh dios, agreguemos un poco de espacio en blanco. No puedo ver donde estoy ...

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

Pruébalo en línea!

Bloque de código anónimo que toma una lista de palabras e imprime directamente a STDOUT.

Explicación

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

Carbón de leña , 19 bytes

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

Entrada como una lista de cadenas

Pruébelo en línea (detallado) o pruébelo en línea (puro)

Explicación:

Lazo en el rango [0, input-length):

For(Length(q))
ＦＬθ

Si el índice es impar:

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

Imprima la cadena en el índice ien una dirección hacia abajo:

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

Y luego mueva el cursor una vez hacia la esquina superior derecha:

Move(:UpRight);
↗

De lo contrario (el índice es par):

Else{...}
«...

Imprima la cadena en el índice ien una dirección regular correcta:

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

Y luego mueva el cursor una vez hacia la esquina inferior izquierda:

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

Pruébalo en línea!

C # (compilador interactivo de 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)));}

Pruébalo en línea!

J , ^{47 45} 43 bytes

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

Pruébalo en línea!

Encontré un enfoque divertido y diferente ...

Comencé a jugar con las almohadillas izquierdas y las cremalleras con gerundios cíclicos, etc., pero luego me di cuenta de que sería más fácil calcular la posición de cada letra (esto se reduce a una suma de escaneo de la matriz elegida correctamente) y aplicar enmendar } a un espacio en blanco lienzo en la entrada arrasada.

La solución se maneja casi en su totalidad por enmendar }:

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

• ; ( single verb that does all the work ) ] tenedor general
• ; la parte izquierda elimina la entrada, es decir, pone todas las letras en una cadena contigua
• ] parte correcta es la entrada en sí
• (stuff)}Utilizamos la forma gerundia de enmendar }, que consta de tres partesv0`v1`v2 .
  • v0 nos da los "nuevos valores", que es el raze (es decir, todos los caracteres de la entrada como una cadena), por lo que usamos [ .
  • v2nos da el valor inicial, que estamos transformando. simplemente queremos un lienzo en blanco de espacios de las dimensiones necesarias. ([ ' '"0/ [)nos da uno de tamaño(all chars)x(all chars) .
  • El verbo del medio v1selecciona en qué posiciones colocaremos nuestros caracteres de reemplazo. Este es el quid de la lógica ...
• Comenzando en la posición 0 0en la esquina superior izquierda, notamos que cada nuevo personaje está 1 a la derecha de la posición anterior (es decir, prev + 0 1) o uno hacia abajo (es decir, prev + 1 0). De hecho, hacemos el primer "len de la palabra 1" veces, luego el último "len de la palabra 2" veces, y así sucesivamente, alternando. Entonces crearemos la secuencia correcta de estos movimientos, luego escanearemos y sumaremos nuestras posiciones, que luego encajonaremos porque así es como funciona Modificar. Lo que sigue es solo la mecánica de esta idea ...
• ([: <@(+/)\ #&> # # $ 1 - e.@0 1)
  • Primero #:@1 2crea la matriz constante 0 1;1 0.
  • # $luego lo extiende para que tenga tantas filas como la entrada. por ejemplo, si la entrada contiene 3 palabras, producirá 0 1;1 0;0 1.
  • #&> #la parte izquierda de eso es una matriz de las longitudes de las palabras de entrada y #es copia, por lo que copia 0 1"len of word 1" veces, luego1 0 "len de palabra 2 veces", etc.
  • [: <@(+/)\ hace la suma de escaneo y el cuadro.

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

Pruébalo en línea

Retina , 51 bytes

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

Pruébalo en línea!

Un enfoque bastante sencillo que marca cualquier otra palabra y luego aplica la transformación directamente.

Explicación

1,2,`\w+
;$&

Marcamos cualquier otra palabra con un punto y coma haciendo coincidir cada palabra, pero solo aplicando el reemplazo a las coincidencias (que están indexadas a cero) a partir de la coincidencia 1 y luego 3 y así sucesivamente.

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

+(mestablece algunas propiedades para las siguientes etapas. El signo más comienza un bucle "mientras este grupo de etapas cambia algo", y el corchete abierto indica que el signo más debe aplicarse a todas las etapas siguientes hasta que haya un corchete cerrado frente a una tecla de retroceso (que es todas las etapas en este caso). El mjusto le dice a la expresión regular que trate^ como también a juego desde el comienzo de líneas en lugar de sólo el comienzo de la cadena.

La expresión regular real es bastante sencilla. Simplemente igualamos la cantidad apropiada de cosas antes del primer punto y coma y luego usamos la *sintaxis de reemplazo de Retina para colocar el número correcto de espacios.

; |;$

Esta etapa se aplica después de la última para eliminar puntos y comas y espacios al final de las palabras que cambiamos a vertical.

Retina 0.8.2 , 58 bytes

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

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

Pruébalo en línea! El enlace incluye casos de prueba. Solución alternativa, también 58 bytes:

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

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

Pruébalo en línea! El enlace incluye casos de prueba.

No estoy usando deliberadamente Retina 1 aquí, así que no obtengo operaciones con palabras alternativas de forma gratuita; en cambio tengo dos enfoques. El primer enfoque se divide en todas las letras en palabras alternativas contando los espacios anteriores, mientras que el segundo enfoque reemplaza los espacios alternativos con líneas nuevas y luego usa los espacios restantes para ayudarlo a dividir palabras alternativas en letras. Cada enfoque debe unir la última letra vertical con la siguiente palabra horizontal, aunque el código es diferente porque dividen las palabras de diferentes maneras. La etapa final de ambos enfoques luego rellena cada línea hasta que su primer carácter no espacial se alinee debajo del último carácter de la línea anterior.

Tenga en cuenta que no asumo que las palabras son solo letras porque no tengo que hacerlo.

PowerShell , 101 89 83 bytes

-12 bytes gracias a mazzy .

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

Pruébalo en línea!

PowerShell , 74 65 bytes

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

Pruébalo en línea!

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}

Pruébalo en línea!

• -3 bytes gracias 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 @

Esto se ejecuta en SQL Server 2016 y otras versiones.

@ contiene la lista delimitada por espacios. @I rastrea la posición del índice en la cadena. @S rastrea el número total de espacios para sangrar desde la izquierda. @B rastrea con qué eje se alinea la cadena en el punto @I.

El recuento de bytes incluye la lista mínima de ejemplos. El script recorre la lista, carácter por carácter, y cambia la cadena para que se muestre de acuerdo con los requisitos. Cuando se alcanza el final de la cadena, la cadena se imprime.

JavaScript (Node.js) , 75 bytes

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

Pruébalo en línea!

Explicación y sin golf

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

Ejecutar y depurarlo

Jalea , 21 bytes

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

Pruébalo en línea!

Un programa completo que toma la entrada como una lista de cadenas y que sale implícitamente a la palabra escalera

C (gcc) , 93 87 bytes

Gracias a gastropner por las sugerencias.

Esta versión toma una matriz de cadenas terminadas por un puntero 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++);}

Pruébalo en línea!

Brain-Flak , 152 bytes

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

Pruébalo en línea!

Sospecho que esto puede ser más corto combinando los dos bucles para palabras pares e impares.

J, 35 33 bytes

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

Este es un verbo que toma la entrada como una sola cadena con las palabras separadas por espacios. Por ejemplo, podría llamarlo así:

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

La salida es una matriz de letras y espacios, que el intérprete genera con nuevas líneas según sea necesario. Cada línea se rellenará con espacios para que tengan exactamente la misma longitud.

Hay un pequeño problema con el código: no funcionará si la entrada tiene más de 98 palabras. Si desea permitir una entrada más larga, reemplace la _98en el código _998para permitir hasta 998 palabras, etc.

Permítanme explicar cómo funciona esto a través de algunos ejemplos.

Supongamos que tenemos una matriz de letras y espacios que imaginamos que es una salida parcial para algunas palabras, comenzando con una palabra horizontal.

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

¿Cómo podríamos anteponer una nueva palabra antes de esto, verticalmente? No es difícil: simplemente convierta la nueva palabra en una matriz de letras de una sola columna con el verbo ,., luego agregue la salida a esa matriz de una sola columna. (El verbo ,.es conveniente porque se comporta como una función de identidad si lo aplica a una matriz, que usamos para jugar al golf).

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

Ahora no podemos simplemente repetir esta forma de anteponer una palabra como está, porque entonces solo obtendríamos palabras verticales. Pero si transponemos la matriz de salida entre cada paso, entonces cualquier otra palabra será horizontal.

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

Entonces, nuestro primer intento de solución es colocar cada palabra en una matriz de una sola columna, luego doblarlas agregando y transponiendo entre ellas.

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

Pero hay un gran problema con esto. Esto pone la primera letra de la siguiente palabra antes de girar un ángulo recto, pero la especificación requiere girar antes de poner la primera letra, por lo que la salida debería ser algo como esto:

c             
a             
rhouse        
     d        
     o        
     gchildren

La forma en que logramos esto es revertir toda la cadena de entrada, como en

nerdlihc god esuoh rac

luego use el procedimiento anterior para construir el zig-zag pero girando solo después de la primera letra de cada palabra:

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

Luego voltee la salida:

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

Pero ahora tenemos otro problema más. Si la entrada tiene un número impar de palabras, entonces la salida tendrá la primera palabra vertical, mientras que la especificación dice que la primera palabra debe ser horizontal. Para solucionar esto, mi solución agrega la lista de palabras a exactamente 98 palabras, agregando palabras vacías, ya que eso no cambia la salida.