（関連：one、two、three）

アクロスティックは、各行の先頭の文字は、縦に読んだとき、また言葉やメッセージを生成どこ書き込み/詩のスタイルです。例えば、

Together
Everyone
Achieves
More

またTEAM、最初の列が垂直に読み取られたときに単語を綴ります。

アクロスティクスは、メソスティックのサブセットであり、垂直方向の単語は水平方向の単語のどこにでも配置できます。たとえば、TEAM上記の例は、次のように中間語としても記述できます。

   togeTher
everyonE
       Achieves
       More

他のいくつかのバリエーションとともに。

ここでの課題は、入力語の特定のリストからアクロスティックまたはメソティックを生成することです。

入力

• 任意の適切な形式の単語のリスト。
• リストには小文字で作成された単語のみが含まれます[a-z]。
• リストは、アクロスティックまたはメソスティックを形成することが保証されています（偽の入力を処理する必要はありません）。
• 入力内の単語の1つが垂直方向の単語を形成し、残りが水平方向の単語を作成します。ここでの課題の一部は、適切な垂直方向の単語を見つけることです。

出力

• 入力ワードから形成され、STDOUTに書き込まれた、または返された、妥当な形式のASCIIアートのアクロスティックまたはメソスティック。
• 対応する縦の単語は大文字にする必要があります（例のように）。
• 縦書きの単語を適切に並べるための先行スペースが必要です。末尾のスペース、および先頭/末尾の改行はオプションです。単語が正しく整列する限り、余分な先頭のスペースも問題ありません。
• アクロスティックとメソスティックの両方が可能な場合は、アクロスティックのみを出力します。
• 複数のアクロスティック/メソスティックが可能な場合、コードはそれらの一部またはすべてを出力できます。

ルール

• 完全なプログラムまたは機能のいずれかが受け入れられます。
• 標準的な抜け穴は禁止されています。
• これはコードゴルフなので、通常のゴルフルールがすべて適用され、最短のコード（バイト単位）が勝ちます。

例

['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バイト

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

オンラインでお試しください。

これはおそらく非常にゴルフに適しています。多数の先行スペースを印刷します。

Brachylog、145バイト

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

オンラインでお試しください！

（30分かかりますので、我慢してください。）

JavaScript（ES6）、255 263 269 286

任意の数の先行スペースとして保存された17バイトの編集が許可されます
Edit2いくつかのシャッフル、6バイトの保存
Edit3は、改行を含む単一の文字列ではなく文字列のリストを返します（feersumの回答へのOPコメント）、さらに8バイトが保存されました

入力リスト内の各単語について、再帰的なDFSを使用して、すべての可能性のあるメソスティクス/アクロスティクスを見つけます。それぞれは、単語と単語内のターゲット文字の位置を持つ配列として保存されます。見つかったすべての結果は、グローバル結果配列の位置1（アクロスティックの場合）または中規模の場合は0に保存されます。

すべての単語を完全にスキャンした後、配列の最後の位置で結果を取得し、そのアスキーアート表現を構築して返します。

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

少ないゴルフ

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

テスト

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バイト

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}

Mathematica 10.0、139バイト

行のリストを返す名前のない関数：

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

使用例：

In [144]：= f = Sort [{q = Max [p = Min / @ Position @@@（{z = {## 2}、＃}）]、Array [""＆、q-＃2 ] ToUpperCase〜MapAt〜##＆@@@（{z、p}）}＆@@@ Permutations @ Characters @＃] [[1,2]]＆;

In [145]：= f @ {"late"、 "ballroom"、 "anvil"、 "to"、 "head"} //列

 ...数ページの警告... 

Out [145] = baLlroom
            アンビル
            に
           頭

私は大文字化を行うより良い方法に関する提案を探しています。MapAt文字列の文字を大文字にするための非常に素晴らしい関数を見つけました。

ハスケル、214の 206 204 202バイト

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

スペースが埋め込まれた文字列のリストを返します。たとえば、f ["late","ballroom","anvil","to","head"]-> [" baLlroom"," Anvil"," To"," hEad"]以上の表示に適しています。

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

fオフセットのリストとともに水平に書かれた単語を選択します。h対応するオフセットに従って各単語を埋め込み、大文字を挿入します。詳細に：

                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バイト

おそらくまだ非常にゴルフ可能

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]

文字のリストのリストを取得して返します。
-例えば" bAllroom"です[' ',' ',' ','b','A','l','l','r','o','o','m']

最初の結果のみを返し、すべてのアクロスティックが最初にチェックされるような順序でチェックします。

ideoneで表示形式で印刷されたすべてのテストケースを見る

以下は同じことをするより読みやすい関数形式です（評価してから最初の結果を返すのではなく、すぐに最初の結果を返すことを除いて）：

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バイト

->\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}}

ブルートフォースソリューション。

使い方

-> \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.
    }
}

各候補者は次のようになります。

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

候補のリストのリストを転置することは、アクロスティックが存在する場合、メソティックよりも前に検出されるようにするために必要です。