(powiązane: jeden , dwa , trzy )

Akrostych to styl poematu / pisanie gdzie początkowy znak każdej linii, kiedy czytać pionowo, produkuje również wyraz lub wiadomość. Na przykład,

Together
Everyone
Achieves
More

również przeliteruje słowo, TEAMgdy pierwsza kolumna jest czytana pionowo.

Akrostiki to podzbiór mezostycznych , w których pionowe słowo może znajdować się w dowolnym miejscu w słowach poziomych. Na przykład TEAMpowyższy można również zapisać jako mezostyczny w następujący sposób

   togeTher
everyonE
       Achieves
       More

wraz z kilkoma innymi odmianami.

Wyzwanie będzie polegało na wytworzeniu akrostyka lub mezostycy z podanej listy słów wejściowych.

Wkład

• Lista słów w dowolnym odpowiednim formacie .
• Lista będzie zawierać tylko słowa wykonane małymi literami [a-z].
• Lista ma gwarancję, że tworzy akrostyk lub mezostyk (nie trzeba obsługiwać fałszywych danych wejściowych).
• Jedno ze słów na wejściu utworzy słowo pionowe, a pozostałe słowa horyzontalne - w tym przypadku wyzwaniem jest znalezienie odpowiedniego słowa pionowego, więc nie można go traktować osobno.

Wydajność

• Akrostyk lub mezostyk ASCII-art utworzony ze słów wejściowych, zapisanych do STDOUT lub zwróconych, w dowolnym rozsądnym formacie.
• Odpowiednie słowo pionowe musi być pisane wielkimi literami (jak w przykładach).
• Wymagane są spacje wiodące, aby odpowiednio wyrównać pionowe słowo . Końcowe spacje i wiodące / końcowe znaki nowej linii są opcjonalne. Dodatkowe spacje wiodące są również w porządku, pod warunkiem, że słowa są wyrównane poprawnie.
• Jeśli możliwy jest zarówno akrostyk, jak i mezostyk, wyprowadzaj tylko akrostyk .
• Jeśli możliwy jest więcej niż jeden akrostyk / mezostyk, twój kod może wypisać jeden lub wszystkie z nich.

Zasady

• Dopuszczalny jest pełny program lub funkcja.
• Standardowe luki są zabronione.
• To jest golf golfowy, więc obowiązują wszystkie zwykłe zasady gry w golfa, a wygrywa najkrótszy kod (w bajtach).

Przykłady

['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 bajtów

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

Wypróbuj online.

Jest to prawdopodobnie bardzo gra w golfa. Drukuje kilka wiodących miejsc.

Brachylog , 145 bajtów

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

Wypróbuj online!

(Trwa to pół minuty, więc bądź cierpliwy.)

JavaScript (ES6), 255 263 269 286

Edytuj 17 bajtów zapisanych jako dowolną liczbę wiodących spacji jest dozwolona
Edytuj2 trochę tasowania, 6 bajtów zapisanych
Edytuj3 zwraca listę ciągów zamiast jednego ciągu z nowymi wierszami (komentarz OP do odpowiedzi feersum), zapisano 8 kolejnych bajtów

Dla każdego słowa na liście wejściowej używam rekurencyjnego DFS, aby znaleźć wszystkie możliwe mezostyki / akrostyki. Każdy z nich jest przechowywany jako tablica ze słowem i docelową pozycją litery wewnątrz słowa. Każdy znaleziony wynik jest zapisywany w globalnej tablicy wyników na pozycji 1 (jeśli jest akrostatyczny) lub 0, jeśli jest mezostyczny.

Po zakończeniu skanowania wszystkich słów uzyskuję wynik na ostatniej pozycji w tablicy i buduję i zwracam jego ascii art rapresentation.

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

Mniej golfa

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 ​​bajtów

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 bajtów

Nienazwana funkcja zwracająca listę linii:

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

Przykładowe użycie:

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

W [145]: = f @ {„późno”, „sala balowa”, „kowadło”, „do”, „głowa”} // kolumna

 ... kilka stron ostrzeżeń ... 

Out [145] = sala
            Kowadło
            Do
           głowa

Szukam sugestii na temat lepszych sposobów wykonywania wielkich liter. Znalazłem bardzo fajną funkcję MapAtdo pisania wielką literą w ciągu.

Haskell, 214 206 204 202 bajtów

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

Zwraca listę łańcuchów wypełnionych spacją, np. f ["late","ballroom","anvil","to","head"]-> [" baLlroom"," Anvil"," To"," hEad"]lub więcej przyjaznych dla wyświetlania:

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

fwybiera słowa pisane poziomo wraz z listą odsunięć. hwstawia każde słowo zgodnie z odpowiednim przesunięciem i wstawia wielką literę. Szczegółowo:

                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 bajtów

Prawdopodobnie nadal bardzo gra w golfa

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]

Pobiera i zwraca listę znaków.
- np. " bAllroom"jest[' ',' ',' ','b','A','l','l','r','o','o','m']

Zwraca tylko pierwszy wynik i sprawdza w takiej kolejności, aby wszystkie akrostyki były sprawdzane jako pierwsze.

Zobacz wszystkie przypadki testowe wydrukowane w formacie wyświetlania na ideone

Oto bardziej czytelna forma funkcjonalna, która robi to samo (z wyjątkiem tego, że natychmiast zwraca pierwszy wynik, a nie ocenia, a następnie zwraca pierwszy wynik):

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 bajtów

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

Rozwiązanie siłowe.

Jak to działa

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

Każdy kandydat wygląda następująco:

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

Transpozycja listy list kandydatów jest konieczna, aby upewnić się, że akrostyk, jeśli istnieje, zostanie znaleziony przed jakimkolwiek mezostykiem.