(correlato: uno , due , tre )

Un acrostico è uno stile di poesia / scrittura in cui il carattere iniziale di ogni riga, se letto verticalmente, produce anche una parola o un messaggio. Per esempio,

Together
Everyone
Achieves
More

scrive anche la parola TEAMquando la prima colonna viene letta in verticale.

Gli acrostici sono un sottoinsieme di mesostici , dove la parola verticale può trovarsi ovunque nelle parole orizzontali. Ad esempio, TEAMquello sopra potrebbe anche essere scritto come mesostico come segue

   togeTher
everyonE
       Achieves
       More

insieme a diverse altre varianti.

La sfida qui sarà quella di produrre un acrostico o mesostico da un determinato elenco di parole di input.

Ingresso

• Un elenco di parole in qualsiasi formato adatto .
• L'elenco conterrà solo parole composte da lettere minuscole [a-z].
• L'elenco è garantito per formare un acrostico o un mesostico (non è necessario gestire input fasulli).
• Una delle parole nell'input formerà la parola verticale, mentre il resto creerà le parole orizzontali - una parte della sfida qui è trovare la parola verticale appropriata, quindi non può essere presa separatamente.

Produzione

• L'acrostico o mesostico di arte ASCII si è formato dalle parole di input, scritte su STDOUT o restituite, in qualsiasi formato ragionevole.
• La parola verticale corrispondente deve essere maiuscola (come negli esempi).
• Portando gli spazi per ottenere la parola verticale per allineare appropriatamente sono richiesti . Gli spazi finali e le nuove righe iniziali / finali sono facoltativi. Anche gli spazi iniziali extra vanno bene, purché le parole siano allineate correttamente.
• Se sono possibili sia un acrostico che un mesostico, emettere solo l'acrostico.
• Se è possibile più di un acrostico / mesostico, il codice può emetterne uno o tutti.

Regole

• È accettabile un programma completo o una funzione.
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Esempi

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

Provalo online.

Questo è probabilmente molto golfabile. Stampa un mucchio di spazi principali.

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

Provalo online!

(Richiede mezzo minuto, quindi sii paziente.)

JavaScript (ES6), 255 263 269 286

Modifica 17 byte salvati come numero arbitrario di spazi iniziali è consentito
iniziali Modifica2 Alcuni shuffle, 6 byte salvati
Modifica 3 restituiscono un elenco di stringhe anziché una singola stringa con nuove righe (commento OP alla risposta di feersum), 8 byte aggiuntivi salvati

Per ogni parola nell'elenco di input, utilizzo un DFS ricorsivo per trovare tutti i possibili mesostici / acrostici. Ognuno è memorizzato come un array con la parola e la posizione della lettera di destinazione all'interno della parola. Ogni risultato trovato viene salvato nella matrice di risultati globale nella posizione 1 (se è un acrostico) o 0 se è un mesostico.

Dopo la scansione completa di tutte le parole, ottengo il risultato nell'ultima posizione nella matrice e costruisco e restituisco la sua rappresentazione di arte ascii.

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

Meno golf

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

Test

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}

Mathematica 10.0, 139 byte

Una funzione senza nome che restituisce un elenco di righe:

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

Esempio di utilizzo:

In [144]: = f = Ordina [{q = Max [p = Min / @ Position @@@ ({z = {## 2}, #} ​​)], Array ["" &, q- # 2 ] toUpperCase ~ MapAt ~ ## & @@@ ({z, p} )} & @@@ permutazioni @ @ # I caratteri] [[1,2]] &;

In [145]: = f @ {"late", "ballroom", "anvil", "to", "head"} // Column

 ... diverse pagine di avvertenze ... 

Out [145] = baLlroom
            Incudine
            A
           testa

Sto cercando suggerimenti su modi migliori per fare la capitalizzazione. Ho trovato una funzione molto utile MapAtper scrivere in maiuscolo la lettera nella stringa.

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

Restituisce un elenco di stringhe riempite con spazio, ad es. f ["late","ballroom","anvil","to","head"]-> [" baLlroom"," Anvil"," To"," hEad"]o più display friendly:

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

fseleziona le parole scritte in orizzontale insieme a un elenco di offset. hsposta ogni parola in base all'offset corrispondente e inserisce la lettera maiuscola. In dettaglio:

                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

Probabilmente ancora molto golfabile

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]

Prende e restituisce un elenco di elenco di caratteri.
- ad esempio, " bAllroom"è[' ',' ',' ','b','A','l','l','r','o','o','m']

Restituisce sempre e solo il primo risultato e controlla in un ordine tale che tutti gli acrostici vengano controllati per primi.

Vedi tutti i casi di test stampati nel formato di visualizzazione su ideone

Ecco un modulo funzionale più leggibile che fa lo stesso (tranne per il fatto che restituisce immediatamente il primo risultato anziché valutare e quindi restituire il primo risultato):

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

Soluzione a forza bruta.

Come funziona

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

Ogni candidato assomiglia a:

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

Il recepimento dell'elenco delle liste di candidati è necessario per garantire che un acrostico, se esiste, sia trovato prima di qualsiasi mesostico.