Dada una entrada de una lista de palabras, envíe las palabras con sus letras dispuestas en diagonal:

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

(Lo anterior debe ser la salida para la entrada programming puzzles and code golf ).

Para ser precisos, cada palabra comienza en la primera columna y tres filas debajo de la palabra anterior, y cada letra sucesiva mueve una columna a la derecha y una fila hacia abajo.

La entrada puede proporcionarse como una sola cadena de palabras, separadas exactamente por un espacio, o como una lista / conjunto de palabras. Las palabras solo se compondrán de letras minúsculas a-zy siempre tendrán al menos un carácter.

La salida puede ser una sola cadena, una matriz de líneas o una matriz de matrices de caracteres. Los espacios en blanco iniciales o finales no están permitidos, excepto para una nueva línea final.

Otros casos de prueba:

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

Como se trata de code-golf , ¡el código más corto en bytes ganará!

Vim, 85, 76, 66 , 52 pulsaciones de teclas / bytes

Cuando vi por primera vez este desafío, pensé "¡Esto es perfecto para vim!" Y luego, cuando lo intenté, todo salió mal. Aquí está, en todo su desordenada gloria hacky:

:se ve=all|s/ /\r\r\r/g
qqGo<esc>?\<.\S
lDjP@qq@qG?.
jdG

Pruébelo en línea, gracias al intérprete de V (en su mayoría) compatible con versiones anteriores.

Explicación:

Al principio pensé que podía hacer esta versión bellamente simple de 37 bytes:

:se ve=all
qq:g/\S\S/norm ^lDjP
@qq@q

Lamentablemente, no es tan simple. Tomémoslo línea por línea:

:se ve=all

Esto habilita una característica llamada 'edición virtual'. Permite que el cursor se mueva a columnas que aún no existen. Esta respuesta sería básicamente imposible sin ella.

Ahora necesitamos separar las palabras en diferentes líneas. Entonces reemplazaremos cada espacio con 3 líneas nuevas. Como se trata de un comando ex, podemos ejecutarlo simultáneamente con nuestro último comando ex :se ve=allseparando los dos con una barra.

|s/ /\r\r\r/g

Ahora el búfer se ve así:

Programming


Puzzles


and


code-golf

Aquí es donde comienza la diversión. Configuramos la macro recursiva tradicional con:, qqy luego llamamos a esto:

G               " Move to the last line
 o<esc>         " Append an extra newline

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

Luego terminamos la macro recursiva con @qq@q. En este punto, tenemos todas las diagonales, solo necesitamos hacer un poco de limpieza.

G                   " Move to the last line
 ?.                 " Search backwards for any character
j                   " Move down one line
 dG                 " Delete until the end of the buffer

Turtlèd , 28 26 bytes

Oh, parece que estoy superando un lenguaje diseñado específicamente para el golf. Este es un gran día.

!_4[*.[ rd+.]ul[ ul]r;_+]_

Pruébalo en línea!

Explicación

(escribir significa escribir en la celda de la cuadrícula, char puntiagudo significa char en la entrada a la que apunta el puntero de cadena)

!                         Take string input into variable
 _                        Normally conditional, with >1 input (there will be), write ' '
  4                       set register to 4
   [*                   ] until the current cell is *
     .                    Write pointed char, initially first char
      [     ]             Until space is written on cell
        rd+.              move right, down, string pointer++, write pointed char
             ul[ ul]      Move back up to the top of the word
                    r;    Move right, down 4 (because this is register value)
                      _+  write * if end of input, else ' ', increment string pointer
                        _ will always write ' ', since it will always point at start char

tenga en cuenta el espacio final.

La entrada también necesita espacio final. ya que Python puede tomar una lista, esto es muy parecido a tomar una lista en Turtlèd

MATL , 28 bytes

c!t&n:q3_*ts_b+5M4$XdZ!cZ{Zv

La entrada es una matriz de celdas de cadenas, con comas como separadores opcionales:

{'programming' 'puzzles' 'and' 'code' 'golf'}

o

{'programming', 'puzzles', 'and', 'code', 'golf'}

Pruébalo en línea! O verifique todos los casos de prueba: 1 , 2 , 3 , 4 .

Explicación

Considere la siguiente entrada como ejemplo:

{'aaaa' 'bb' 'ccc'}

Puede ver los resultados parciales (contenido de la pila) insertando el símbolo de comentario %en cualquier punto del código. Por ejemplo, vea el contenido de la pila después de la cuarta función ( &n).

c        % Input cell array of strings implicitly. Convert to 2D char array,
         % right-padding with spaces
         % STACK: ['aaaa'; 'bb  '; 'ccc']
!        % Transpose
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  ']
t        % Duplicate
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '],
                  ['abc'
                   'abc'
                   'a c'
                   'a  '],
&n       % Number of rows and of columns
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, 3
:q       % Range, subtract 1
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 1 2]
3_*      % Multiply by -3
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 -3 -6]
ts_      % Duplicate, sum, negate
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 -3 -6], 9
b        % Bubble up in stack
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 9, 4
+        % Add
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 13
5M       % Push second input of last function again
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 13, 4
4$Xd     % Buld numerical sparse matrix from the above four arguments. The
         % columns of the first input argument will be the diagonals of the
         % result, with indices given bu the second input (negative is below
         % main diagonal). The matrix size is the third and fourth arguments
         % STACK: [97  0  0  0
                    0 97  0  0
                    0  0 97  0
                   98  0  0 97
                    0 98  0  0
                    0  0 32  0
                   99  0  0 32
                    0 99  0  0
                    0  0 99  0
                    0  0  0 32
                    0  0  0  0
                    0  0  0  0
                    0  0  0  0]
Z!c      % Convert from sparse to full, and then to char. Character 0 is
         % displayed as space
         % STACK: ['a   '
                   ' a  '
                   '  a '
                   'b  a'
                   ' b  '
                   '    '
                   'c   '
                   ' c  '
                   '  c '
                   '    '
                   '    '
                   '    '
                   '    ']
Z{       % Split into cell array, with each row in a cell
         % STACK: {'a   ', ' a  ', '  a ', 'b  a', ' b  ', '    ', 'c   ', ' c  ', '  c ', '   ', '   ', '   ', '   '}
Zv       % Deblank: remove trailing space from each string. Implicitly display,
         % each string on a different line. Empty strings do not generate
         % a newline
         % STACK: {'a   ', ' a', '  a', 'b  a', ' b', '', 'c', ' c', '  c', '', '', '', ''}

JavaScript (ES6), 118 109 84 bytes

Toma entrada como un conjunto de palabras. Devuelve una matriz de matrices de caracteres.

s=>s.map((w,y)=>[...w].map((c,x)=>(a[p=y*3+x]=a[p]||Array(x).fill(' '))[x]=c),a=[])&&a

Versión alternativa, 109 bytes.

Devuelve una cadena.

let f =

s=>s.map((w,y)=>[...w].map((c,x)=>(a[p=y*3+x]=a[p]||Array(x).fill` `)[x]=c),a=[])&&a.map(s=>s.join``).join`
`

console.log(f(["programming", "puzzles", "and", "code", "golf"]))

Lisp común, 673 668 597 bytes

Solución terrible, lo sé. Probablemente editaré esto más después de dormir un poco.

(defun f(&rest z)(let((l)(a 0)(s)(o)(b)(c 0))(loop(setf b(length l))(setf l"")(loop for w in z for i from 0 do(if(>(+(length w)(* i 3))c)(setf c(+(length w)(* i 3))))(setf s(+(* i -3)a))(when(and(>= s 0)(< s(length w)))(setf o(format nil"~v@{~a~:*~}"s" "))(if(and(>=(- s 3)0)(not(equal i(-(length z)1))))(setf o(subseq o(- s 2))))(setf l(concatenate'string o(string(char w s))l)))(when(>= s(length w))(setf l(concatenate'string"   "l))))(if(<=(length l)b)(setf l(concatenate'string(format nil"~v@{~a~:*~}"(- b(length l)-1)" ")l)))(print(string-right-trim" "l))(if(>= b c)(return))(setf a(1+ a)))))

Uso:

* (f "ppcg" "is" "pretty" "ok")

"p" 
" p" 
"  c" 
"i  g" 
" s" 
"" 
"p" 
" r" 
"  e" 
"o  t" 
" k  t" 
"     y" 
""
NIL

Esto recorre cada palabra en la lista provista y agrega los caracteres apropiados a la línea actual. El acolchado apropiado es proporcionado por mi uso mediocre de format.

Nota: Soy nuevo en Common Lisp, pero sé lo suficiente como para darme cuenta de que esto podría mejorar mucho.

C #, 336 bytes:

Golfizado:

string D(string[]s){int x=0,y=0,r=0,q=2*(s.Max().Length+s.Length)+1;var a=new char[q, q];for(int i=0;i<s.Length;i++){y=r;for(int j=0;j<s[i].Length;j++){a[y,x]=s[i][j];x+=1;y+=1;}x=0;r+=3;}var o="";for(x=0;x<q;x++){var t="";for(y=0;y<q;y++)t+=a[x,y];o+=t==string.Join("",Enumerable.Repeat('\0',q))?"":(t.TrimEnd('\0')+"\r\n");}return o;}

Sin golf:

public string D(string[] s)
{
  int x = 0, y = 0, r = 0, q = 2 * (s.Max().Length + s.Length) + 1;
  var a = new char[q, q];
  for (int i = 0; i < s.Length; i++)
  {
    y = r;
    for (int j = 0; j < s[i].Length; j++)
    {
      a[y, x] = s[i][j];
      x += 1;
      y += 1;
    }
    x = 0;
    r +=3;
  }
  var o = "";
  for (x = 0; x < q; x++)
  {
    var t = "";
    for (y = 0; y < q; y++)
      t += a[x, y];
    o += t == string.Join("", Enumerable.Repeat('\0', q)) ? "" : (t.TrimEnd('\0') + "\r\n");
  }
  return o;
}

Pruebas:

  var codeGolf = new DrawDiagonalLinesOfText();
  Console.WriteLine(codeGolf.E(new string[] { "programming", "puzzles", "and", "code", "golf" }));
  Console.WriteLine(codeGolf.E(new string[] { "a", "bcd", "efgh", "i", "j" }));
  Console.WriteLine(codeGolf.E(new string[] { "verylongword", "short" }));

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


a
b
 c
  d
e
 f
  g
i  h
j


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

Python 2, 146 bytes

s=input()
k=max(map(len,s))
a=[k*[' ']for x in range(k+len(s)*3+3)]
for x in range(len(s)):
 for y in range(len(s[x])):a[x*3+y][y]=s[x][y]
print a

Nota: las sangrías para las dos últimas líneas son <space>y <tab>, lo que ahorra un byte ya que no necesito doble sangría.

La entrada se debe ingresar como una matriz de cadenas como esta: ["hello", "world"]o ['hello', 'world']. La salida es una matriz de matrices de caracteres.

Probablemente haya una mejor manera de hacer esto ...

EDITAR Gracias a Doorknob por señalar un corchete cerrado que falta. Lo puse antes del *k...en la tercera línea.

Mathematica, 146 bytes

P=PadRight;T=Transpose;R=Riffle;Select[Rest@T@P@MapIndexed[""~Table~#2~Join~#1&,T@P@R[Characters/@#~R~{},{},3]]//.{0->"",{x__,""}->{x}},#!={""}&]&

Estoy decepcionado por este bytecount, pero bueno.

Define una función anónima que toma una lista de palabras (p {"this","that","these"}. Ej. ) Y devuelve una matriz bidimensional de caracteres. Para ver en forma de cuadrícula, agregue un //Gridal final.

Convierte las cadenas en una matriz, agrega líneas adicionales, transpone la matriz, antepone los cambios necesarios y luego vuelve a transponer.

Resultado de ejemplo (formateado como cuadrícula):

Jalea , 24 bytes

z⁶j€⁾  µJ’⁶ẋ;"z⁶œr€⁶Yœr⁷

Pruébalo en línea!

¿Cómo?

z⁶j€⁾  µJ’⁶ẋ;"z⁶œr€⁶Yœr⁷ - Main link: a list of strings
z                        - transpose with filler...
 ⁶                       -     space character
  j€                     - join €ach with
    ⁾                    -     two spaces
       µ                 - monadic chain separation, call the result x
        J                - range(length(x)) [1,2,...,x]
         ’               - decrement (vectorises) [0,1,...x-1]
           ẋ             - repeat (vectorises)
          ⁶              - a space ['', ' ',...,'x spaces']
             "           - zip with
            ;            - concatenation (prefixes with the space strings)
              z          - transpose with filler...
               ⁶         -     space character
                œr€⁶     - trim spaces from the right of €ach
                    Y    - join with line feeds
                     œr⁷ - trim line feeds from the right
                         - implicit print

Python 2, 182 bytes

def f(s):
 M=max(map(len,s));p=' '*M;L=[p]+s+M*[p];r='';k=0
 while k/M<len(s)*3+M:
  i=k%M;w=k/M-i+1;r+=(L[(w/3+1)*(w%3==1)]+p)[i];k+=1
  if i==M-1:r=r.rstrip()+'\n'
 return r.strip()

Un poco largo, pero en el lado positivo, devuelve una cadena sin espacios en blanco finales en cada línea, y sin espacios en blanco finales o retornos al final; restricciones que algunas otras entradas no obedecen.

Se pasa una lista de palabras a la función; algunos 'espacios en blanco' se agregan a esta lista y luego el algoritmo asigna una fila, un par de columnas a una palabraNumber, characterNumber en la lista expandida. (Esto es un poco inverso a la estrategia habitual vista en otras soluciones).

Si permitimos espacios en blanco al final de todas las líneas, excepto la última, podemos hacerlo un poco mejor (163 bytes):

def f(s):
 M=max(map(len,s));p=' '*M;L=[p]+s+M*[p];r='';k=0
 while k/M<len(s)*3+M:i=k%M;w=k/M-i+1;r+=(L[(w/3+1)*(w%3==1)]+p)[i]+'\n'*(i==M-1);k+=1
 return r.strip()

q / kdb +, 130 109 94 90 86 84 bytes

Solución:

f:{-1(+)a rtrim(til(#)E){raze(x#" "),y,\:"  "}'E:(+)(a:{(max(#:)each x)$x})" "vs x;}

Ejemplos:

q)f "programming puzzles and code golf"
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 
q)f "a bcd efgh i j"
a   


b   
 c  
  d 
e   
 f  
  g 
i  h


j  
q)f (),"x"
x
q)f "verylongword short"
v           
 e          
  r         
s  y        
 h  l       
  o  o      
   r  n     
    t  g    
        w   
         o  
          r 
           d

Explicación (sin golf):

La esencia básica es crear un grupo de cadenas de igual longitud a partir de la cadena de entrada, voltearlas (rotarlas) y luego agregar espacios en blanco apropiados para obtener algo similar a esto:

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

que se voltea de nuevo y se imprime en stdout.

Aquí hay un desglose línea por línea del concepto:

A:"programming puzzles and code golf"; // original input
B:" " vs A;                            // split on " "
C:max count each B;                    // find length of the longest string
D:C$B;                                 // pad each string to this length
E:flip D;                              // flip (rotate) string
F:{raze(x#" "),y,\:"  "};              // appends each char with "  " and prepends an increasing number of " "
G:(til count E)F'E;                    // execute function F with each pair of 0..n and item in list E
H:max count each rtrim G;              // find longest string (ignoring right whitespace)
I:H$G;                                 // pad each of the strings to this length
J:flip I;                              // flip to get result
-1 J;                                  // print to stdout, swallow return value

Notas:

Algunas formas de eliminar algunos (11) bytes fáciles si realmente quisiéramos :

• Podría guardar 2 bytes al soltar f:y salir como una función anónima
• Podría ahorrar 3 bytes al soltar -1y ;y devolver una lista de cadenas en lugar de imprimir en stdout
• Podría guardar 6 bytes si pasamos en una lista de cadenas en lugar de cadenas separadas por espacios

Ediciones:

• -11 bytes, se usa rtrimpara encontrar la longitud máxima para rellenar, se eliminó la necesidad de almacenarC variables
• -15 bytes, cambiando la función max count eachpara una función lambda aque se crea una vez y se usa dos veces
• -4 bytes, moviendo razea la función lambda para guardar unraze each
• -4 bytes, simplificó la función lambda central que agrega el espacio en blanco
• -2 bytes, use (+)como abreviatura paraflip

Carbón , 16 9 bytes

ＷＳ«Ｐ↘ιＭ³↓

Mi primera respuesta al carbón. Gracias a @DLosc por su sugerencia Ｐy en Ｍlugar de usar Ｓy Ｊ(Jump) para volver al inicio de la línea (y tres abajo).

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

Explicación:

Bucle mientras todavía hay una próxima cadena de entrada:

While(InputString()){ ... }
ＷＳ« ...

Imprima esta cadena sin mover el cursor en una dirección hacia abajo-derecha:

Multiprint(:DownRight, i);
Ｐ↘ι

Y luego mueva tres posiciones hacia abajo para la siguiente iteración:

Move(3, :Down);
Ｍ³↓

Japt -Rx, 17 16 13 bytes

Toma entrada como un conjunto de palabras. Si se permitieran espacios en blanco al final de cada línea, los últimos 4 caracteres podrían eliminarse para vincularlos con la solución de carbón.

yÈmú3)iYçÃmx1

Pruébalo o ejecuta todos los casos de prueba

Explicación

y                 :Transpose
 È                :Map each word at 0-based index Y
  m               :  Map each character
   ú3             :    Right pad with spaces to length 3
     )            :  End mapping
      i           :  Prepend
       Yç         :   Space repeated Y times
         Ã        :End mapping and transpose
          m       :Map
           x1     :  Trim right
                  :Implicitly join with newlines, trim and output

K4 , 58 bytes

Solución:

+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:

Ejemplos:

q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:("programming";"puzzles";"and";"code";"golf")
"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       "
q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:(,"a";"bcd";"efgh";,"i";,"j")
"a   "
"    "
"    "
"b   "
" c  "
"  d "
"e   "
" f  "
"  g "
"i  h"
"    "
"    "
"j   "
q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:("verylongword";"short")
"v           "
" e          "
"  r         "
"s  y        "
" h  l       "
"  o  o      "
"   r  n     "
"    t  g    "
"        w   "
"         o  "
"          r "
"           d"

Explicación:

Las cadenas de la almohadilla derecha son de la misma longitud, se transponen, se unen con " ", la almohadilla izquierda para generar diagonales, luego la almohadilla derecha para corregir las longitudes y transponer hacia atrás. Toma una lista de cadenas y devuelve una lista de cadenas. Probablemente golfable pero aún más corto que mi solución q / kdb +.

+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:
                                                        x:      / save as variable x
                                                       $        / pad
                                             (        )         / do this together
                                                  #:'x          / count (#:) each (') x
                                                |/              / max
                                              c:                / save as variable c
                                            +                   / flip / transpose
                                           $                    / string ($)
                                    "  "/:'                     / join each with "  "
                                   $                            / pad
                      (           )                             / do this together
                                #x                              / count (#) x
                              3*                                / multiply by 3
                             +                                  / add to
                         (  )                                   / do this together
                          !c                                    / range 0..c
                       2-                                       / subtract from 2
                    x:                                          / save as x:
                   $                                            / pad
 (                )                                             / do all this together
    {         }@'x                                              / apply (@) lambda {} to each x
            ^x                                                  / null (^) x (" " is considered null)
           ~                                                    / not
          |                                                     / reverse
        |\                                                      / max (|) scan (\), maxs
     0+/                                                        / sum (+) over (/) starting with 0
  |/                                                            / max (|) over (/), max
+                                                               / transpose

Perl 6 , 73 bytes

{my@t;for .kv ->\i,\w{for w.comb.kv {@t[3*i+$^a][$^a]=$^b}};@t »||»" "}

Pruébalo en línea!

El argumento de entrada es una lista de palabras. La salida es una matriz de matriz de caracteres.

PHP , 100 bytes

<?foreach($_GET as$k=>$v)for($x=0;$y=$v[$x];$t[$x++]=$y)($t=&$s[$k*3+$x])?:$t=" ";echo join("
",$s);

Pruébalo en línea!