Với mục đích của thách thức hiện tại là "phác thảo" một từ có nghĩa là bao quanh nó liên tiếp bằng các chữ cái riêng của nó, bắt đầu bằng từ cuối cùng và cuối cùng là thay thế từ gốc ở giữa bằng khoảng trắng:

       oooooo 
       onnnno 
on ->  on  no 
       onnnno
       oooooo

Bài tập:

Đưa ra một danh sách các từ, chỉ bao gồm các chữ cái tiếng Anh viết thường và / hoặc chữ hoa, phác thảo từng từ và hiển thị tất cả các khối kết quả cạnh nhau theo chiều ngang, cách nhau bởi một cột của không gian duy nhất, được xếp theo chiều dọc ở giữa các khối.

Bạn có thể viết một chương trình đầy đủ, hoặc một chức năng.

Đầu vào:

Một danh sách các từ, hoặc nếu bạn thích - một chuỗi phân cách bằng dấu cách hoặc dấu cách khác

Đầu ra:

Biểu diễn ASCII của các khối cho các từ được phác thảo. Khoảng trắng hàng đầu / dấu được cho phép.

Các trường hợp thử nghiệm:

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

Tiêu chí chiến thắng:

Mã ngắn nhất tính theo byte trong mỗi ngôn ngữ sẽ thắng. Tôi sẽ đánh giá rất cao nếu bạn bình luận / giải thích mã và cách tiếp cận của bạn.

Canvas , 22 20 byte

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

Hãy thử nó ở đây!

Giải trình:

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

Than , 35 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

ＦＡ«

Lặp lại danh sách đầu vào.

≔Ｌιθ

Lấy độ dài của từ hiện tại.

Ｍθ↑

Di chuyển đến góc trên cùng bên trái của phác thảo kết quả.

Ｆθ«

Lặp lại một lần cho mỗi nhân vật.

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

Vẽ một hộp có chiều cao, chiều rộng và ký tự thích hợp.

↘»

Di chuyển đến góc trên cùng bên trái của hộp tiếp theo.

Ｍ⊕⊗θ→

Di chuyển đến phác thảo tiếp theo.

Haskell , ^{188 183 174 171} 167 byte

-9 -13 byte nhờ 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

Hãy thử trực tuyến!

Pyth, 34 33 byte

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

Hãy thử trực tuyến.

Loại bỏ một loạt các khoảng trắng thừa, nhưng điều đó được cho phép bởi thử thách.

Giải trình

• mKhoan Qlàm như sau cho mỗi từ dtrong đầu vào Q:

  • m\ dánh xạ từ với x => " ", về cơ bản tạo ra danh sách [" ", ..., " "]có nhiều mục như từ có chữ cái.
  • .iddxen kẽ các từ với chính nó, lặp lại các chữ cái của từ hai lần. _đảo ngược chuỗi này. wordtrở thành ddrrooww.
  • ubắt đầu bằng G= mảng khoảng trắng và áp dụng như sau với mỗi chữ cái trong chuỗi xen kẽ trong H:
    • *2H lặp lại nhân vật hai lần.
    • jR... Gđặt mỗi chuỗi trong Ggiữa cặp nhân vật.
    • Choán đổi hàng và cột. Khi ba bước này được thực hiện hai lần với cùng một ký tự H, điều này sẽ phác thảo các dòng Gvới ký tự đó.
  • Bây giờ chúng ta có các cột cho từ được phác thảo d. +;chuẩn bị một cột không gian.
• slàm phẳng mảng cột cho mỗi từ và Jlưu nó vào biến J.
• mKhoan Jlàm như sau cho mỗi cột của đầu ra:
  • .[lJd;đệm cả hai mặt của cột với khoảng trắng sao cho chiều dài của cột bằng với số cột. Điều này luôn luôn là đủ đệm để làm cho các cột thẳng hàng.
• Cbiến các cột thành hàng và jnối các hàng với dòng mới.

Giải pháp thay thế, 33 byte

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

Hãy thử trực tuyến.

Lưu ý rằng có một không gian dấu. Chủ yếu là cùng một thuật toán, ngoại trừ chỉ các cột đệm trên đầu và sau đó chuyển đổi với không gian điền.

R , 189 byte

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

Hãy thử trực tuyến!

Một sự hợp tác giữa digEmAll và bản thân tôi trong trò chuyện .

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 cổ điển) , 57 51 50 byte

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

Hãy thử trực tuyến!

Stax , 26 25 byte

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

Chạy và gỡ lỗi nó

05AB1E , 46 byte

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

Không quá vui về điều đó, nhưng tôi rất vui vì nó hoạt động.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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