Para os propósitos do desafio atual de "delinear" uma palavra significa cercá-la sucessivamente com suas próprias letras, começando pela última e, finalmente, substituir a palavra original no centro por espaços:

       oooooo 
       onnnno 
on ->  on  no 
       onnnno
       oooooo

Tarefa:

Dada uma lista de palavras, consistindo apenas de letras inglesas em minúsculas e / ou maiúsculas, delineie cada palavra e exiba todos os blocos resultantes próximos um do outro horizontalmente, separados por uma coluna de espaço único, alinhada verticalmente no centro dos blocos.

Você pode escrever um programa completo ou uma função.

Entrada:

Uma lista de palavras, ou se você preferir - uma sequência delimitada por espaço ou outro símbolo

Resultado:

A representação ASCII dos blocos para as palavras descritas. Espaços em branco à esquerda / à direita são permitidos.

Casos de teste:

Input 1: ["code", "golf"] (or "code golf")
Output 1:

    cccccccccccc gggggggggggg
    cooooooooooc goooooooooog
    coddddddddoc gollllllllog
    codeeeeeedoc golfffffflog
    code    edoc golf    flog
    codeeeeeedoc golfffffflog
    coddddddddoc gollllllllog
    cooooooooooc goooooooooog
    cccccccccccc gggggggggggg

Input 2: ["I", "am", "just", "a", "man"]  (or "I am just a man")
Output 2: 

           jjjjjjjjjjjj
           juuuuuuuuuuj     mmmmmmmmm
    aaaaaa jussssssssuj     maaaaaaam
III ammmma justtttttsuj aaa mannnnnam
I I am  ma just    tsuj a a man   nam  
III ammmma justtttttsuj aaa mannnnnam
    aaaaaa jussssssssuj     maaaaaaam 
           juuuuuuuuuuj     mmmmmmmmm 
           jjjjjjjjjjjj

Critérios de vitória:

O código mais curto em bytes em cada idioma vence. Eu aprecio muito se você comentar / explicar seu código e abordagem.

Tela , 22 20 bytes

ｌ ＊；±２１＊｛；ｌ└＊ｅ⟳｝ ］ｒ⤢

Experimente aqui!

Explicação:

{                 ]    map over the inputs
 l *                     array of length spaces - the canvas of the current word
    ;                    get the word back on top
     ±                   reverse it
      21*                repeat each character twice
         {      }        for each character
          ;l└              push the height of the item below (the canvas)
             *             repeat the character that many times vertically
              e            and encase the canvas in that char column
               ⟳           and rotate it clockwise for encasing the next time
                 ∙      push another space as the separator of words
                   r   center the words
                    ⤢  and transpose the final output (as everything was built vertically)

Carvão , 35 bytes

ＦＡ«≔ＬιθＭθ↑Ｆθ«Ｂ⁻׳θ⊗κ⊕⊗⁻θκ§ικ↘»Ｍ⊕⊗θ→

Experimente online!Link é a versão detalhada do código. Explicação:

ＦＡ«

Passe pela lista de entrada.

≔Ｌιθ

Obtenha o comprimento da palavra atual.

Ｍθ↑

Mova para o canto superior esquerdo do contorno resultante.

Ｆθ«

Faça um loop uma vez para cada personagem.

Ｂ⁻׳θ⊗κ⊕⊗⁻θκ§ικ

Desenhe uma caixa com a altura, largura e caracteres adequados.

↘»

Vá para o canto superior esquerdo da próxima caixa.

Ｍ⊕⊗θ→

Vá para o próximo esboço.

Haskell , ^{188 183 174 171} 167 bytes

-9 -13 bytes graças a Laikoni .

e=[]:e
c#a=k c<$>k(c<$a!!0)a
k c s=c:s++[c]
f w=foldr(#)[p w]w
p=(' '<$)
s w=unlines.map unwords.foldr(zipWith(:))e$until(\a->all((p a>=).p)$f<$>w)(k=<<p.head)<$>f<$>w

Experimente online!

Pitão, 34 33 bytes

Jsm+;uCjR*2HG_.iddm\ dQjCm.[lJd;J

Experimente online.

Despeja um monte de espaço em branco extra, mas isso é permitido pelo desafio.

Explicação

• m… QFaz o seguinte para cada palavra dna entrada Q:

  • m\ dmapeia a palavra com x => " ", essencialmente criando a lista [" ", ..., " "]com tantos itens quanto a palavra tem letras.
  • .iddintercala a palavra consigo mesma, repetindo as letras da palavra duas vezes. _inverte essa sequência. wordtorna-se ddrrooww.
  • ucomeça com G= a matriz de espaços e aplica o seguinte a cada letra na sequência intercalada em H:
    • *2H repete o personagem duas vezes.
    • jR… GColoca cada string Gentre o par de caracteres.
    • Ctroca linhas e colunas. Quando essas três etapas são executadas duas vezes com o mesmo caractere H, isso descreve as linhas Gdesse caractere.
  • Agora temos as colunas para a palavra descrita d. +;precede uma coluna de espaço.
• sachata a matriz de colunas para cada palavra, e Jarmazena-o na variável J.
• m...J Faz o seguinte para cada coluna da saída:
  • .[lJd;preenche os dois lados da coluna com espaços para que o comprimento da coluna seja igual ao número de colunas. Isso sempre é preenchimento suficiente para alinhar as colunas verticalmente.
• Ctransforma as colunas em linhas e june as linhas com novas linhas.

Solução alternativa, 33 bytes

j.tsm.[L\ l+dsQ+;uCjR*2HG_.iddm\ 

Experimente online.

Observe que há um espaço à direita. Principalmente o mesmo algoritmo, exceto apenas as colunas na parte superior e depois transpõe com preenchimento de espaço.

R , 189 bytes

function(x,S=32,`+`=rbind,`*`=cbind)cat(intToUtf8(Reduce(`+`,Map(function(s,K=utf8ToInt(s),o=S-!K){for(i in rev(K))o=i+i*o*i+i
for(j in(0:(max(nchar(x))-nchar(s)))[-1])o=S*o*S
o+S},x))+10))

Experimente online!

Uma colaboração entre digEmAll e eu no chat .

function(x){
 S <- 32			# space
 `+` <- rbind			# alias for rbind
 `*` <- cbind			# alias for cbind
 outlineWord <- function(s){	# function to construct the outline for each word
  chars <- utf8ToInt(s)		# convert to code points
  output <- S - !chars		# replace each char with 32 (space)
  for(i in rev(chars))
   o <- i + i * o * i + i	# o <- rbind(i,cbind(i,o,i),i)
  for(j in(0:(max(nchar(x))-nchar(s)))[-1])
   o <- S * o * S		# pad with spaces
   o + S}			# return with an additional row of spaces between words
 outlines <- Map(outlineWord,x)	# apply outlineWord to each element of x
 outlines <- Reduce(`+`,outlines)# reduce by rbind
 outlines <- outlines+10	# add row of newlines
 cat(intToUtf8(outlines))	# convert back to strings and print
}

APL (Dyalog Classic) , 57 51 50 bytes

{⍉⊃⍪/,/((⊢-⌈/)≢¨⍵)⌽↑{⍪¨↓0 1↓⍕,∘⍉∘⌽⍣4/⍵,⊂⍉⍪¯1/⍵}¨⍵}

Experimente online!

Stax , 26 25 bytes

¢π‼○MªΘ└ƒ∩┘?◙↕)fY╨nu⌂E┴6X

Execute e depure

05AB1E , 46 bytes

εg©;ò<Uyη央∍«®>∍}y𫩪®Xиª˜».º.∊}¶«».C.B€SζJ»

Não estou muito feliz com isso, mas estou feliz que esteja funcionando.

Experimente online ou verifique todos os casos de teste .

Explicação:

ε                             # Map `y` over the (implicit) input-list
 g                            #  Take the length of the current item
  ©                           #  Store it in the register (without popping)
   ;                          #  Halve it
    ò                         #  Ceil and cast to integer at the same time
     <                        #  Decrease it by 1
      U                       #  Pop and store it in variable `X`
 yη                           #  Take the prefixes of the current string `y`
   ε       }                  #  Map over these prefixes:
    ¤                         #   Take the last character of the string
     ®×                       #   Increase it to a size equal to the length from the register
       «                      #   Append it to the current prefix
        ®>                    #   Take the length from the register, and add 1
          ∍                   #   Shorten the string to that size
 y                            #  Push the string `y` again
  ð«                          #  Append a space
    ©                         #  Store it in the register (without popping)
     ª                        #  Append it at the end of the list of modified prefixes
      ®                       #  Push the string with space from the register again
       Xи                     #  Repeat it `X` amount of times
         ª                    #  Append them to the list
          ˜                   #  Flatten to remove the empty appended list if `X` was 0
           »                  #  Join by newlines
            .º.∊              #  Intersect mirror both horizontally and vertically
                }             # Close outer map
                 ¶«           # Append a newline after each (for the space delimiters)
                   »          # Join everything by newlines
                    .C        # Centralize it horizontally
                              # (too bad a centralize vertically isn't available..)
                      .B      # Split on newlines again
                        €S    # Convert each line to a list of characters
                          ζ   # Zip, swapping rows/columns (with space filler by default)
                           J  # Join the loose characters of every line to a string again
                            » # Join the lines by newlines (and output implicitly)