(verwandt: eins , zwei , drei )

Ein Akrostichon ist ein Gedicht- / Schreibstil, bei dem das Anfangszeichen jeder Zeile, wenn es vertikal gelesen wird, auch ein Wort oder eine Nachricht hervorbringt. Beispielsweise,

Together
Everyone
Achieves
More

buchstabiert das Wort auch, TEAMwenn die erste Spalte vertikal gelesen wird.

Akrostatik ist eine Teilmenge der Mesostik , wobei das vertikale Wort an einer beliebigen Stelle in den horizontalen Wörtern stehen kann. Zum Beispiel könnte die TEAMobige auch wie folgt als Mesostik geschrieben werden

   togeTher
everyonE
       Achieves
       More

zusammen mit mehreren anderen Variationen.

Die Herausforderung hierbei wird darin bestehen, aus einer gegebenen Liste von Eingabewörtern einen Akrostichon oder einen Mesostichon zu erzeugen.

Eingang

• Eine Liste von Wörtern in jedem geeigneten Format .
• Die Liste enthält nur Wörter, die aus Kleinbuchstaben bestehen [a-z].
• Es ist garantiert, dass die Liste einen Akrostichon oder einen Mesostichon bildet (keine falsche Eingabe erforderlich).
• Eines der Wörter in der Eingabe wird das vertikale Wort bilden, während der Rest die horizontalen Wörter ergibt. Ein Teil der Herausforderung besteht darin, das entsprechende vertikale Wort zu finden, sodass es nicht separat verwendet werden kann.

Ausgabe

• Das aus den in STDOUT geschriebenen oder zurückgegebenen Eingabewörtern gebildete ASCII-Akrostichon oder Mesostichon in einem beliebigen vernünftigen Format.
• Das entsprechende vertikale Wort muss (wie in den Beispielen) großgeschrieben werden.
• Es sind führende Leerzeichen erforderlich , um das vertikale Wort entsprechend auszurichten . Nachgestellte Leerzeichen und führende / nachfolgende Zeilenumbrüche sind optional. Zusätzliche führende Leerzeichen sind ebenfalls in Ordnung, solange die Wörter korrekt ausgerichtet sind.
• Wenn sowohl Akrostichon als auch Mesostik möglich sind, geben Sie nur den Akrostichon aus.
• Wenn mehr als ein Akrostichon / Mesostiker möglich ist, kann Ihr Code einen oder alle davon ausgeben.

Regeln

• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig.
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Beispiele

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

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

Probieren Sie es online aus.

Das ist wahrscheinlich sehr golfen. Es druckt eine Reihe von führenden Leerzeichen.

Brachylog , 145 Bytes

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

Probieren Sie es online!

(Dauert eine halbe Minute, also hab etwas Geduld.)

JavaScript (ES6), 255 263 269 286

Edit 17 Bytes, die als willkürliche Anzahl von führenden Leerzeichen gespeichert wurden, sind erlaubt.
Edit 2: Mischen, 6 Bytes, gespeichert.
Edit 3: Liefert eine Liste von Strings anstelle eines einzelnen Strings mit Zeilenumbrüchen (OP-Kommentar zu Feersums Antwort). 8 weitere Bytes werden gespeichert

Für jedes Wort in der Eingabeliste verwende ich eine rekursive DFS, um alle möglichen Mesostiken / Akrostiken zu finden. Jedes ist als Array mit Wort- und Zielbuchstabenposition innerhalb des Wortes gespeichert. Jedes gefundene Ergebnis wird im globalen Ergebnisfeld an Position 1 (wenn es ein Akrostichon ist) oder 0 (wenn es ein Mesostik ist) gespeichert.

Nach dem vollständigen Scan aller Wörter erhalte ich das Ergebnis an der letzten Position im Array und erstelle und sende seine ASCII-Kunst-Darstellung.

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

Weniger golfen

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

Prüfung

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

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 Bytes

Eine unbenannte Funktion, die eine Liste von Zeilen zurückgibt:

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

Anwendungsbeispiel:

In [144]: = f = Sortieren [{q = Max [p = Min / @ Position @@@ ({z = {## 2}, #} ​​)], Array ["" &, q- # 2 ] ToUpperCase ~ MapAt ~ ## & @@@ ({z, p} )} & @@@ Permutations @ Characters @ #] [[1,2]] &;

In [145]: = f @ {"spät", "Ballsaal", "Amboss", "bis", "Kopf"} // Spalte

 ... mehrere Seiten mit Warnungen ... 

Out [145] = Badezimmer
            Amboss
            Zu
           Kopf

Ich suche nach Vorschlägen für bessere Möglichkeiten zur Kapitalisierung. Ich habe eine sehr schöne Funktion gefunden, MapAtum den Buchstaben in der Zeichenkette groß zu schreiben.

Haskell, 214 206 204 202 Bytes

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

Gibt eine Liste mit mit Leerzeichen aufgefüllten Zeichenfolgen zurück, z. B. f ["late","ballroom","anvil","to","head"]-> [" baLlroom"," Anvil"," To"," hEad"]oder mehr anzeigefreundlich:

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

fWählt die horizontal geschriebenen Wörter zusammen mit einer Liste von Offsets aus. hFüllt jedes Wort entsprechend dem entsprechenden Versatz auf und fügt den Großbuchstaben ein. Im Detail:

                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 Bytes

Vermutlich noch sehr golfen

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]

Nimmt eine Liste von Zeichen auf und gibt sie zurück.
- zB " bAllroom"ist[' ',' ',' ','b','A','l','l','r','o','o','m']

Gibt immer nur das erste Ergebnis zurück und überprüft die Reihenfolge so, dass alle Akrostatiken zuerst überprüft werden.

Alle im Anzeigeformat auf ideone gedruckten Testfälle anzeigen

Hier ist eine besser lesbare funktionale Form, die dasselbe tut (außer dass sie das erste Ergebnis sofort zurückgibt, anstatt das erste Ergebnis auszuwerten und dann zurückzugeben):

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 Bytes

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

Brute-Force-Lösung.

Wie es funktioniert

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

Jeder Kandidat sieht aus wie:

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

Das Umsetzen der Liste der Kandidatenlisten ist erforderlich, um sicherzustellen, dass ein Akrostichon, falls vorhanden, vor einem Mesostikus gefunden wird.