Für die aktuelle Herausforderung, ein Wort zu "umreißen", bedeutet dies, es nacheinander mit eigenen Buchstaben zu umgeben, beginnend mit dem letzten, und schließlich das ursprüngliche Wort in der Mitte durch Leerzeichen zu ersetzen:

       oooooo 
       onnnno 
on ->  on  no 
       onnnno
       oooooo

Aufgabe:

Wenn Sie eine Liste von Wörtern erhalten, die nur aus englischen Klein- und / oder Großbuchstaben besteht, skizzieren Sie jedes Wort und zeigen Sie alle resultierenden Blöcke horizontal nebeneinander an, getrennt durch eine Spalte mit einem Leerzeichen, die vertikal in der Mitte der Blöcke ausgerichtet ist.

Sie können ein vollständiges Programm oder eine Funktion schreiben.

Eingang:

Eine Liste von Wörtern oder, wenn Sie möchten, eine durch Leerzeichen oder andere Symbole getrennte Zeichenfolge

Ausgabe:

Die ASCII-Darstellung der Blöcke für die umrissenen Wörter. Führende / nachfolgende Leerzeichen sind zulässig.

Testfälle:

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

Gewinnkriterien:

Der kürzeste Code in Bytes in jeder Sprache gewinnt. Ich würde mich sehr freuen, wenn Sie Ihren Code und Ihre Vorgehensweise kommentieren / erläutern.

Canvas , 22 bis 20 Byte

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

Probieren Sie es hier aus!

Erläuterung:

{                 ]    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)

Kohle , 35 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

ＦＡ«

Durchlaufen Sie die Eingabeliste.

≔Ｌιθ

Liefert die Länge des aktuellen Wortes.

Ｍθ↑

Bewegen Sie sich in die linke obere Ecke der resultierenden Kontur.

Ｆθ«

Schleife einmal für jedes Zeichen.

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

Zeichnen Sie eine Box mit der richtigen Höhe, Breite und dem richtigen Zeichen.

↘»

Bewegen Sie sich in die linke obere Ecke des nächsten Kästchens.

Ｍ⊕⊗θ→

Gehen Sie zur nächsten Gliederung.

Haskell , ^{188 183 174 171} 167 Bytes

-9 -13 Bytes dank 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

Probieren Sie es online!

Pyth, 34 33 Bytes

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

Probieren Sie es online aus.

Gibt eine ganze Reihe von zusätzlichen Leerzeichen aus, aber die Herausforderung lässt dies zu.

Erläuterung

• m… QMacht für jedes Wort din der Eingabe Folgendes Q:

  • m\ dOrdnet das Wort mit zu x => " ", wobei im Wesentlichen die Liste [" ", ..., " "]mit so vielen Elementen erstellt wird, wie das Wort Buchstaben enthält.
  • .iddverschachtelt das Wort mit sich selbst und wiederholt die Buchstaben des Wortes zweimal. _kehrt diese Zeichenfolge um. wordwird ddrrooww.
  • uBeginnt mit G= dem Array von Leerzeichen und wendet für jeden Buchstaben in der verschachtelten Zeichenfolge Folgendes an H:
    • *2H wiederholt den Charakter zweimal.
    • jR… GSetzt jede Zeichenfolge Gzwischen das Zeichenpaar.
    • Cvertauscht Zeilen und Spalten. Wenn diese drei Schritte zweimal mit demselben Zeichen ausgeführt werden H, werden die Zeilen Gmit diesem Zeichen umrissen .
  • Wir haben jetzt die Spalten für das umrissene Wort d. +;Stellt eine Leerzeichenspalte voran.
• sReduziert das Spaltenarray für jedes Wort und Jspeichert es in der Variablen J.
• m… JMacht für jede Spalte der Ausgabe Folgendes:
  • .[lJd;Füllt beide Seiten der Spalte mit Leerzeichen auf, sodass die Länge der Spalte der Anzahl der Spalten entspricht. Dies reicht immer aus, um die Spalten vertikal auszurichten.
• Cjwandelt die Spalten in Zeilen um und verbindet die Zeilen mit Zeilenumbrüchen.

Alternative Lösung, 33 Bytes

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

Probieren Sie es online aus.

Beachten Sie, dass ein Leerzeichen vorhanden ist. Meist derselbe Algorithmus, nur Spalten oben auffüllen und dann mit Leerraumfüllung transponieren.

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

Probieren Sie es online!

Eine Zusammenarbeit zwischen digEmAll und mir im 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/⍵}¨⍵}

Probieren Sie es online!

Stax , 26 25 Bytes

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

Führen Sie es aus und debuggen Sie es

05AB1E , 46 Bytes

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

Nicht sehr glücklich darüber, aber ich bin froh, dass es funktioniert.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

ε                             # 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)