(ilgili: bir , iki , üç )

Bir akrostik , her satırın başlangıç ​​karakterinin dikey olarak okunduğunda da bir kelime veya mesaj ürettiği bir şiir / yazı tarzıdır. Örneğin,

Together
Everyone
Achieves
More

Ayrıca TEAM, ilk sütun dikey olarak okunduğunda sözcüğü de söyler .

Akrostics , dikey kelimenin yatay kelimelerdeki herhangi bir yerinde olabileceği bir mezostik alt kümesidir . Örneğin, TEAMyukarıdakilerden biri, aşağıdaki gibi bir mezostik olarak da yazılabilir.

   togeTher
everyonE
       Achieves
       More

diğer birkaç varyasyonla birlikte.

Buradaki zorluk, verilen bir giriş kelimesi listesinden bir akrostik veya mesostik üretmek olacaktır.

Giriş

• Herhangi bir uygun formatta kelimelerin bir listesi .
• Liste sadece küçük harflerden yapılan sözcükleri içerecektir [a-z].
• Listenin bir akrostik veya mesostik oluşturması garantilidir (sahte girişi kullanmaya gerek yoktur).
• Gerisi yatay kelimeleri yaparken, dikey kelime oluşturacak girdi sözcüklerden biri - bu yüzden burada meydan okuma parçası, uygun dikey sözcüğü bulmaktır olamaz ayrı ayrı alınacak.

Çıktı

• ASCII-art akrostik veya mezostik, STDOUT'a yazılan veya herhangi bir makul formatta girilen kelimelerden oluşur.
• İlgili dikey kelime büyük harfle yazılmalıdır (örneklerde olduğu gibi).
• Dikey kelimenin uygun şekilde sıralanabilmesi için ana boşluklar gerekir . Sondaki boşluklar ve sondaki / sondaki yeni çizgiler isteğe bağlıdır. Ekstra boş alanlar da, kelimeler doğru bir şekilde hizalandığı sürece iyidir.
• Eğer hem bir akrostiş ve mesostic mümkündür, çıkış sadece akrostiş.
• Birden fazla akrostik / mesostic mümkün ise, kodunuz bunların herhangi birini veya tümünü verebilir.

kurallar

• Tam bir program veya bir işlev kabul edilebilir.
• Standart boşluklar yasaktır.
• Bu kod-golf olduğundan, tüm normal golf kuralları geçerlidir ve en kısa kod (bayt cinsinden) kazanır.

Örnekler

['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 bayt

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

Çevrimiçi deneyin.

Bu muhtemelen çok golf oynamaktadır. Bir sürü öncü alanı basar.

Brachylog , 145 bayt

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

Çevrimiçi deneyin!

(Yarım dakika sürer, bu yüzden sabırlı olun.)

JavaScript (ES6), 255 263 269 286

Düzenleme lider alanların keyfi sayısı izin olarak 17 kaydedilen bayt
EDIT2 bazı üreticimizin, 6 bayt kurtardı
Edit3 8 tane daha kayıtlı bayt (feersum cevabı OP yorum) yenisatırlar ile tek dize yerine dize listesini döndürür

Giriş listesindeki her kelime için, tüm olası mezostikler / akrostikleri bulmak için özyinelemeli bir DFS kullanıyorum. Her biri, kelimenin içinde kelime ve hedef harf konumu olan bir dizi olarak saklanır. Bulunan her sonuç, genel sonuç dizisinde 1. konumda (eğer akrostikse) veya mezostik ise 0'a kaydedilir.

Tüm kelimeler için taramayı takiben sonucu dizideki son pozisyonda alıyorum ve ascii sanat raporsiyonunu oluşturup iade ediyorum.

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

Daha az golf oynadı

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

Ölçek

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 ​​bayt

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 bayt

Satır listesi döndüren adsız bir işlev:

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

Örnek kullanım:

[144] 'de: = f = Sırala [{q = Maks [p = Min / @ Konum @@@ ({z = {## 2}, #} ​​)], Dizi ["" &, q- # 2 ] toUpperCase ~ MapAt ~ ## ve @@@ ({z, s} )} # @ ve @@@ Permütasyon @ Özellikleri] [[1,2]];

[145] 'de: = f @ {"geç", "balo salonu", "örs", "den", "baş"} // sütun

 ... birkaç sayfa uyarı ... 

Dışarı [145] = baLlroom
            Örs
            için
           baş

Büyük harf yapmanın daha iyi yolları hakkında öneriler arıyorum. MapAtDizedeki harfi büyük harf yapmak için çok hoş bir işlev buldum .

Haskell, 214 206 204 202 bayt

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

Boşluklu dizgelerin bir listesini döndürür, örneğin f ["late","ballroom","anvil","to","head"]-> [" baLlroom"," Anvil"," To"," hEad"]veya daha fazla ekran dostu:

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

fOfsetlerin bir listesi ile birlikte yatay olarak yazılmış kelimeleri seçer. hher bir kelimeyi karşılık gelen ofsete göre tuşlar ve büyük harf ekler. Detayda:

                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 bayt

Muhtemelen hala çok golf oynamak

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]

Bir karakter listesi alır ve döndürür.
- örn " bAllroom"olduğunu[' ',' ',' ','b','A','l','l','r','o','o','m']

Sadece ilk sonucu döndürür ve tüm akrojeniklerin ilk önce kontrol edileceği şekilde kontrol eder.

İdeone üzerinde görüntü biçiminde yazdırılan tüm test durumlarına bakın

İşte aynı olan daha okunabilir bir işlevsel form (ilk sonucu hemen değerlendirmek ve sonra da ilk sonucu döndürmek yerine ilk sonucu döndürmesi dışında):

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 bayt

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

Kaba kuvvet çözümü.

Nasıl çalışır

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

Her aday şöyle görünür:

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

Adayların listesinin aktarılması, eğer varsa, herhangi bir mezostikten önce bir akrostik bulunmasını sağlamak için gereklidir.