(liên quan: một , hai , ba )

Một tên của bài thơ là một phong cách của bài thơ / văn bản mà nhân vật bắt đầu của mỗi dòng, khi đọc theo chiều dọc, cũng tạo ra một từ hoặc tin nhắn. Ví dụ,

Together
Everyone
Achieves
More

cũng đánh vần từ TEAMkhi cột đầu tiên được đọc theo chiều dọc.

Acrostics là một tập hợp con của mesory s, trong đó từ dọc có thể ở bất cứ đâu trong các từ ngang. Ví dụ, TEAMmột ở trên cũng có thể được viết như một mesory như sau

   togeTher
everyonE
       Achieves
       More

cùng với một số biến thể khác.

Thách thức ở đây sẽ là tạo ra một từ thông dụng hoặc mesory từ một danh sách các từ đầu vào nhất định.

Đầu vào

• Một danh sách các từ trong bất kỳ định dạng phù hợp .
• Danh sách sẽ chỉ chứa các từ được làm từ chữ thường [a-z].
• Danh sách này được đảm bảo để tạo thành một hình ảnh tĩnh hoặc một mesory (không cần xử lý đầu vào không có thật).
• Một trong những từ trong đầu vào sẽ tạo thành từ dọc, trong khi phần còn lại tạo từ ngang - một phần của thách thức ở đây là tìm từ dọc phù hợp, do đó không thể tách riêng từ này.

Đầu ra

• Chữ viết tắt hoặc thuật giả tưởng nghệ thuật ASCII được hình thành từ các từ đầu vào, được viết thành STDOUT hoặc được trả lại, ở bất kỳ định dạng hợp lý nào.
• Từ dọc tương ứng phải được viết hoa (như trong ví dụ).
• Không gian hàng đầu để có được các từ dọc để xếp hàng một cách thích hợp được yêu cầu . Không gian lưu trữ và dòng mới hàng đầu / dấu là tùy chọn. Không gian hàng đầu cũng tốt, miễn là các từ căn chỉnh chính xác.
• Nếu cả hai phương pháp acrostic và mesinto đều có thể, chỉ xuất ra hình ảnh tĩnh.
• Nếu có nhiều hơn một acrostic / mesellect, mã của bạn có thể xuất ra bất kỳ hoặc tất cả chúng.

Quy tắc

• Một chương trình đầy đủ hoặc một chức năng được chấp nhận.
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.

Ví dụ

['together', 'team', 'everyone', 'achieves', 'more']
Together
Everyone
Achieves
More

['aaa', 'aaa', 'aaa', 'aaa']
Aaa
Aaa
Aaa
# One output, or multiple (of the same) output is allowed

['aaa', 'aaa', 'aab', 'baa']
Aaa
Aaa
Baa
# This is the only allowed output, since others would be mesostic, which are lower priority

['live', 'every', 'love', 'very', 'ohio']
Live
Ohio
Very
Every
# Note that 'live' couldn't be the vertical word since then it would be a mesostic, which is lower priority output

['cow', 'of', 'fox']
cOw
 Fox
# A shorter mesostic test case

['late', 'ballroom', 'anvil', 'to', 'head']
anviL
   bAllroom
    To
   hEad

Pyth, 52 49 47 46 byte

jm++*;-lsQhAd<HGr>HG4hhMDfhhShMTm.b,xNYNtdhd.p

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

Điều này có lẽ là rất golf. Nó in một loạt các không gian hàng đầu.

Brachylog , 145 byte

p~c[A:B:C],Bl1,A:CcP@pz:cahgB,P:1a~@nw|lL,?:laot:" "rjg:Ljb:sa:?z:cap~c[A:B:C],Bl1,A:Cc@pz:caZ:LmgB,Zl-yM,Z:M:Lz:2az:ca~@nw
bB,?h@u:Bc
b#=,?h@u|h

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

(Mất nửa phút, vì vậy hãy kiên nhẫn.)

JavaScript (ES6), 255 263 269 286

Chỉnh sửa 17 byte lưu lại dưới dạng số tùy ý của không gian hàng đầu được phép
Edit2 một số xáo trộn, 6 byte lưu
Edit3 trả về một danh sách các chuỗi thay vì một chuỗi duy nhất với dòng mới (OP bình luận cho câu trả lời feersum của), 8 nhiều byte lưu

Đối với mỗi từ trong danh sách đầu vào, tôi sử dụng một DFS đệ quy để tìm tất cả các mesostics / acrostics sở hữu. Mỗi cái được lưu trữ dưới dạng một mảng với vị trí chữ và mục tiêu bên trong từ. Mọi kết quả tìm thấy được lưu trong mảng kết quả toàn cầu ở vị trí 1 (nếu đó là một hình chữ nhật) hoặc 0 nếu đó là một phép lạ.

Sau khi quét hoàn toàn tất cả các từ, tôi nhận được kết quả ở vị trí cuối cùng trong mảng và xây dựng và trả lại sự hiện diện nghệ thuật ascii của nó.

l=>(l.map((w,i)=>(r=(p,v,i,a)=>(l[i]='.',w[p]?l.map((v,i)=>~(j=v.search(w[p]))&&r(p+1,v,i,a|j,m[p]=[j,v])):l[p+1]?0:s[+!a]=[...m],l[i]=v))(0,w,i,m=[]),s=[]),m=s.pop(),m.map(([j,v])=>' '.repeat((l+0).length-j)+v.slice(0,j)+v[j].toUpperCase()+v.slice(j+1)))

Ít chơi gôn

f=l=>(
  l.map((w,i)=>
    // r: recursive DFS function
    // defined here as it uses local w variable
    (r = (p,v,i,a) => (
     l[i] = '.'
     , w[p] 
     ? l.map(
       (v,i) => ~(j=v.search(w[p])) && 
                r(p+1, v, i, a|j, m[p] = [j,v])

     )
     : l[p+1] ? 0 // invalid if there are still unused words
              : s[+!a]=[...m] // a is 0 if acrostic
     , l[i] = v) 
    )(0, w, i, m=[])
  , s=[]),
  m = s.pop(), // get last result
  // m.map(([j]) => o = o<j ? j : o, o=0), // find offset for alignment
  // no need to find the optimal offset as leading blanks are allowed
  m.map(([j,v]) => ' '.repeat((l+0).length-j) 
                   + v.slice(0,j) 
                   + v[j].toUpperCase()
                   + v.slice(j+1)
  )
)

Kiểm tra

f=l=>(l.map((w,i)=>(r=(p,v,i,a)=>(l[i]='.',w[p]?l.map((v,i)=>~(j=v.search(w[p]))&&r(p+1,v,i,a|j,m[p]=[j,v])):l[p+1]?0:s[+!a]=[...m],l[i]=v))(0,w,i,m=[]),s=[]),m=s.pop(),m.map(([j,v])=>' '.repeat((l+0).length-j)+v.slice(0,j)+v[j].toUpperCase()+v.slice(j+1)))

console.log=x=>O.textContent+=x+'\n\n'

;[
 ['together', 'team', 'everyone', 'achieves', 'more']
,['aaa', 'aaa', 'aaa', 'aaa']
,['aaa', 'aaa', 'aab', 'baa']
,['live', 'every', 'love', 'very', 'ohio']
,['cow', 'of', 'fox']
,['late', 'ballroom', 'anvil', 'to', 'head']
].forEach(l=>console.log(f(l).join`\n`))

<pre id=O></pre>

Perl6, 287 277 269 ​​byte

my @w=$*IN.words;my ($q,$r)=gather for ^@w {my @v=@w.rotate($_);my \d=@v.shift;for @v.permutations {my @o=flat($_ Z d.comb).map:{$^a.index: $^b};take $_,@o if @o>>.defined.all}}.sort(*[1].sum)[0];for @$q Z @$r ->(\a,\b){say " "x($r.max -b)~a.substr(0,b)~a.substr(b).tc}

Toán học 10.0, 139 byte

Một hàm không tên trả về một danh sách các dòng:

Sort[{q=Max[p=Min/@Position@@@({z={##2},#})],Array[" "&,q-#2]<>ToUpperCase~MapAt~##&@@@({z,p})}&@@@Permutations@Characters@#][[1,2]]&

Ví dụ sử dụng:

Trong [144]: = f = Sắp xếp [{q = Max [p = Min / @ Position @@@ ({z = {## 2}, #} ​​)], Mảng ["" &, q- # 2 ] ToUpperCase ~ MapAt ~ ## & @@@ ({z, p} )} & @@@ Hoán vị @ Nhân vật @ #] [[1,2]] &;

Trong [145]: = f @ {"late", "ballroom", "anvil", "to", "head"} // Cột

 ... vài trang cảnh báo ... 

Ra [145] = baLlroom
            Đe đe
            Đến
           cái đầu

Tôi đang tìm kiếm gợi ý về những cách tốt hơn để viết hoa. Tôi tìm thấy một chức năng rất hay MapAtđể viết hoa chữ cái trong chuỗi.

Haskell, 214 206 204 202 byte

import Data.List
z=zipWith
h i j t|(u,v:w)<-splitAt j t=([1..sum i-j]>>" ")++u++toEnum(fromEnum v-32):w
f x=uncurry(z=<<h)$sort[(head<$>z elemIndices w l,l)|w:l<-permutations x,(True<$w)==z elem w l]!!0

Trả về danh sách các chuỗi đệm không gian, ví dụ f ["late","ballroom","anvil","to","head"]-> [" baLlroom"," Anvil"," To"," hEad"]hoặc hiển thị thân thiện hơn:

*Main> mapM_ putStrLn $ f ["late", "ballroom", "anvil", "to", "head"]
 baLlroom
   Anvil
   To
  hEad

fchọn các từ được viết theo chiều ngang cùng với một danh sách các độ lệch. hđệm từng từ theo phần bù tương ứng và chèn chữ hoa. Chi tiết:

                permutations x       -- for each permutation of the input list x
         w:l<-                       -- bind w to the first word and l to the rest
             (True<$w)==z elem w l   -- keep it if the list of other words
                                     -- containing the next letter of w
                                     -- equals (length w) times True, i.e. we have
                                     -- as many matching letters as letters in w.
                                     -- This rules out combinations shortcut by zipWith

                                     -- for all the remaining w and l make a pair
         head<$>z elemIndices w l    -- the first element of the list of list of
                                     -- indices where the letter appears in the word 
                                l    -- and l itself
   sort                              -- sort the pairs (all 0 indices, i.e. acrostics
                                     -- go first)
                               !!0   -- pick the first
                                     -- now we have a pair like
                                     -- ([2,0,0,1],["ballroom","anvil","to","head"])
 uncurry(z=<<h)                      -- loop over (index,word) and 
                                     -- provide the third parameter for h 



 h i j t                             -- h takes the list of indices and
                                     -- an index j and a word t
       (u,v:w)<-splitAt j t          -- split the word at the index and bind
                                     --   u: part before the split
                                     --   v: letter at the split
                                     --   w: part after the split
         [1..sum i-j]>>" "           -- the spaces to pad
           ++ u                      -- followed by u
           ++ toEnum(fromEnum v-32)  -- and uppercase v
           :                         -- and w 

Python, 249 byte

Có lẽ vẫn còn rất golf

from itertools import*;e=enumerate;lambda l:[[[' ']*(max(j for k,(j,c)in o[1:])-i)+l[k][:i]+[c.upper()]+l[k][i+1:]for k,(i,c)in o[1:]]for p in product(*[list(e(w))for w in l])for o in permutations(list(e(p)))if[c for k,(i,c)in o[1:]]==l[o[0][0]]][0]

Đưa và trả về một danh sách các danh sách các nhân vật.
- vd " bAllroom"là[' ',' ',' ','b','A','l','l','r','o','o','m']

Chỉ bao giờ trả về kết quả đầu tiên và kiểm tra theo thứ tự sao cho tất cả các động tác được kiểm tra trước.

Xem tất cả các trường hợp thử nghiệm được in ở định dạng hiển thị trên ideone

Đây là một dạng chức năng dễ đọc hơn, thực hiện tương tự (ngoại trừ nó trả về kết quả đầu tiên ngay lập tức thay vì đánh giá và sau đó trả về kết quả đầu tiên):

from itertools import*
def f(l):
    for p in product(*[list(enumerate(w)) for w in l]):
        for o in permutations(list(enumerate(p))):
            if [c for k,(i,c) in o[1:]] == l[o[0][0]]:
                return [ [' '] * (max(j for k,(j,c) in o[1:]) - i)
                       + l[k][:i]
                       + [c.upper()]
                       + l[k][i+1:]
                       for k, (i, c) in o[1:]
                       ]

Perl 6, 177 byte

->\a{for first({.[0] eq[~] .[1]»[1]},map |*,[Z] map {.[0]X [X] map {.comb[(^$_,$_,$_^..* for ^.chars)]},.[1..*]},a.permutations)[1] ->$/ {say [~] " "x a.comb-$0,|$0,$1.uc,|$2}}

Giải pháp vũ lực.

Làm thế nào nó hoạt động

-> \a {
    for first({.[0] eq[~] .[1]»[1]},          # For the first valid candidate
            map |*, [Z]                       # among the transposed
            map {                             # lists of candidates
                .[0] X [X] map {
                    .comb[(^$_,$_,$_^..* for ^.chars)]
                }, .[1..*]
            },
            a.permutations                    # for all permutations of the input:
        )[1] ->$/ {
        say [~] " "x a.comb-$0,|$0,$1.uc,|$2  # Print the candidate as ASCII art.
    }
}

Mỗi ứng viên trông giống như:

"of", (("c"),"o",("w")), ((),"f",("o","x"))

Việc hoán đổi danh sách các danh sách các ứng cử viên là cần thiết để đảm bảo rằng một hình ảnh tĩnh, nếu nó tồn tại, được tìm thấy trước bất kỳ thông điệp nào.