Construye una escalera de palabras

30

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

Galen Ivanov
fuente
1
Relacionado
Bassdrop Cumberwubwubwub
1
@Arnauld Sí, lo agregaré a la descripción.
Galen Ivanov

Respuestas:

12

Carbón de leña , 9 bytes

F⮌A«↑⮌ι‖↗

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:

F⮌S≡ι ‖↗←ι

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.

Neil
fuente
9

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.

attinat
fuente
1
Podría cambiar *s==32en *s<33para guardar un byte.
Gastropner
74 Bytes
Johan du Toit
6

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
        Dg       # 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)
Kevin Cruijssen
fuente
1
Sus versiones 2/3/4 podrían ahorrar 3 bytes con €θ¨õšsøJ.
Emigna
@ Emmigna Gracias! Ahora que lo veo parece tan simple ... Y aquí tuve tres alternativas de 19 bytes en su lugar ...
Kevin Cruijssen
Algunas alternativas a €θ¨õšsøJson õIvy«¤}), õUεXì¤U}y ε¯Jθ줈}(los dos últimos requieren --no-lazy). Desafortunadamente, todos tienen la misma longitud. Esto sería mucho más fácil si una de las variables por defecto fuera ""...
Grimmy
@Grimy " Esto sería mucho más fácil si una de las variables por defecto fuera ""... " ¿Está buscando õo quiere decir si X/ Y/ ®hubiera sido ""? Por cierto, agradable 13 byter en el comentario de la respuesta de Emigna. Muy diferente a la mía y su tbh, con las instrucciones [→,↙,↓,↗]que ha utilizado.
Kevin Cruijssen
õNo es una variable. Sí, me refiero a una variable por defecto "". Literalmente lo hago õUal comienzo de uno de los fragmentos, por lo que si X (o cualquier otra variable) se predetermina "", ahorrará trivialmente dos bytes. ¡Gracias! Sí, ↙↗ es un poco nuevo, pero tuve la idea de intercalar las escrituras verdaderas con escrituras ficticias de longitud 2 de la respuesta de Emigna.
Grimmy
6

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
Emigna
fuente
1
Oh dang, buen enfoque! Publicaré mis versiones de 19 bytes en un momento, pero muy agradable con el Bifurcado y dibujando solo dos letras.
Kevin Cruijssen
1
Por cierto, sabes que hay un lugar para intercalar, ¿verdad? €Y¦podría ser 2.ý(no es que guardaría ningún byte aquí). Y esta es la primera vez que veo que el nuevo comportamiento en comparación con el mapa regular es útil.
Kevin Cruijssen
@KevinCruijssen: Lo he visto antes pero nunca lo he usado, así que no pensé en ello. es el mapa regular para mí y lo he usado a menudo, el otro es el "nuevo" mapa;)
Emigna
13 , otros 13
Grimmy
2
¡Qué mal, no noté la dificultad par / impar! Aquí hay un 13 que debería funcionar: € ðÀD € g> sŽ9 ÷ SΛ
Grimmy
5

Lienzo , 17 12 11 10 bytes

ø⁸⇵{⟳K└×∔⤢

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"
dzaima
fuente
5

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
Arnauld
fuente
El uso de ppara realizar un seguimiento de los finales de línea es muy inteligente +1
Downgoat
5

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
]
Jo King
fuente
¿Puedo pedir una solución en Brain-Flak?
Galen Ivanov
Mi primer intento de entender BF. 2 preguntas: ¿Cómo se imprime la primera palabra cuando no hay caracteres .en la línea 3 (de la versión comentada)? Estaba tratando de jugar con la entrada en TIO. En Mac, cambié el teclado a la entrada de texto Unicode e intenté crear nuevos límites de palabras escribiendo, option+0000pero no funcionó. ¿Alguna idea de por qué no?
Jonás
1
@ Jonás Ah, buena captura, accidentalmente escribí en -lugar de .la explicación. Para agregar bytes NUL en TIO, recomiendo usar la consola y ejecutar un comando como $('#input').value = $('#input').value.replace(/\s/g,"\0");. No sé por qué tu camino no funcionó
Jo King
5

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
)
tsh
fuente
Creo que puede guardar 2 bytes reemplazando tcon a, luego eliminandot=
Rick Hitchcock
5

Aheui (esotope) , 490 458 455 bytes

삭뱃밸때샏배샐배새뱄밿때빠뱋빼쌘투@밧우
@두내백뱃빼선대내백뱃섣@여우샐처샐추
희차@@@뭏누번사@빼뭏오추뻐@@@배
By@@@새대백@@@우뻐색
Legen@@빼쵸누번@@빼
DUST@@@샌뽀터본섣숃멓
@@@@@@@오어아@먛요아@@샏매우
@@@@@아@@@@@@오@@@@@서어
@@@@@희차@@요

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: Código Aheui 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.

LegenDUST
fuente
¿Qué usaste para generar la imagen en esta publicación?
bb94
@ bb94 base es AheuiChem , un buen coreano Aheui coreano en línea (más o menos) IDE. Y usé Powerpoint para colorearlo.
LegenDUST
4

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
Shaggy
fuente
4

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
Rico
fuente
Ah, por cierto, no puedes probar este en ese sitio tio.run; como algunos otros, no hay un manejo de secuencia de control ANSI, por lo que simplemente irrita.
Rico
4

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
Jo King
fuente
Tengo curiosidad por saber cómo funciona, Jo, no sé Perl 6
Jonás
@ Jonás he añadido una explicación
Jo King
Gracias, buena solución.
Jonás
3

Carbón de leña , 19 bytes

FLθ¿﹪鲫↓§θι↗»«§θι↙

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))
FLθ

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);
↙
Kevin Cruijssen
fuente
3

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.
Jonás
fuente
3

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

t-clausen.dk
fuente
1
Uso muy inteligente de los valores BIT, los espacios delimitadores y el procesamiento de cadenas circulares. ¡Mucho mejor respuesta que la mía!
Muqo
2

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.

FryAmTheEggman
fuente
2

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.

Neil
fuente
2

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!

Andrei Odegov
fuente
bonito. usted puede: 1) eliminar la primera línea, 2) usar un splatting & $b @p(cada palabra como un argumento), 3) usar una forma más corta para la new lineconstante. ver línea 3,4 en este ejemplo
mazzy
@mazzy, con las salpicaduras me dan una respuesta incorrecta foo. Ver el código .
Andrei Odegov
oO! Las salpicaduras dividen una palabra en una matriz de caracteres. Interesante. ¡Gracias!
mazzy
1
@mazzy, no es mi culpa :)
Andrei Odegov
Creo que podemos usar la reglaGiven a list of at least two words...
mazzy
2

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
digEmAll
fuente
2

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.

Muqo
fuente
Hola @Mugo Parece que hay un problema técnico en tu secuencia de comandos cuando utilizas una entrada más larga. Si prueba con los datos de mi respuesta, verá que hay una curva involuntaria en la última palabra entre p y t
t-clausen.dk
@ t-clausen.dk Vaya, no manejé la última iteración correctamente. ¡Gracias!
Muqo
confirmó que funciona ahora
t-clausen.dk
1

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.
}
Shieru Asakoto
fuente
1

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

Nick Kennedy
fuente
1

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!

ErikF
fuente
87 bytes
gastropner
1

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.

Jo King
fuente
1
¡Gracias por esto!
Galen Ivanov
1

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.

b_jonas
fuente