साथ - साथ हर कोई अधिक प्राप्त करता है

28

(संबंधित: एक , दो , तीन )

एक आक्रांता कविता / लेखन की एक शैली है जहाँ प्रत्येक पंक्ति का शुरुआती चरित्र, जब लंबवत पढ़ा जाता है, एक शब्द या संदेश भी उत्पन्न करता है। उदाहरण के लिए,

Together
Everyone
Achieves
More

TEAMजब पहला कॉलम लंबवत पढ़ा जाता है तब भी शब्द को मंत्र देता है ।

एक्रॉस्टिक्स मेसैटोलॉजिकल एस का एक सबसेट हैं , जहां ऊर्ध्वाधर शब्द क्षैतिज शब्दों में कहीं भी हो सकता है। उदाहरण के लिए, TEAMऊपर वाला भी इस प्रकार एक मंत्र के रूप में लिखा जा सकता है

   togeTher
everyonE
       Achieves
       More

कई अन्य विविधताओं के साथ।

यहाँ चुनौती इनपुट शब्दों की एक दी गई सूची से एक एक्रॉस्टिक या मेसिस्टिक्स का उत्पादन करना होगा।

इनपुट

  • किसी भी उपयुक्त प्रारूप में शब्दों की एक सूची ।
  • सूची में केवल लोअरकेस से बने शब्द होंगे [a-z]।
  • सूची को एक एक्रॉस्टिक या एक मेसेस्टिक (फर्जी इनपुट को संभालने की कोई आवश्यकता नहीं) बनाने की गारंटी है।
  • इनपुट में एक शब्द ऊर्ध्वाधर शब्द बनाएगा, जबकि बाकी क्षैतिज शब्द बनाते हैं - यहाँ चुनौती का हिस्सा उपयुक्त ऊर्ध्वाधर शब्द ढूंढना है, इसलिए इसे अलग से नहीं लिया जा सकता है।

उत्पादन

  • ASCII- कला एक्रॉस्टिक या मेसैस्टिक, इनपुट शब्दों से बना है, जो STDOUT को लिखा गया है या किसी भी उचित प्रारूप में दिया गया है।
  • संबंधित ऊर्ध्वाधर शब्द को कैपिटलाइज़ किया जाना चाहिए (उदाहरणों में)।
  • उपयुक्त शब्द को लाइन में लाने के लिए रिक्त स्थान की आवश्यकता होती है । अनुगामी रिक्त स्थान, और अग्रणी / अनुगामी newlines वैकल्पिक हैं। अतिरिक्त अग्रणी स्थान ठीक हैं, इसलिए जब तक शब्द सही ढंग से संरेखित नहीं हो जाता है।
  • यदि दोनों एक एक्रॉस्टिक और मेसैटॉनिक संभव हैं, तो आउटपुट केवल एक्रॉस्टिक।
  • यदि एक से अधिक एक्रॉस्टिक / मेसिटॉनिक संभव है, तो आपका कोड किसी भी या सभी को आउटपुट कर सकता है।

नियम

  • या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं।
  • मानक खामियों को मना किया जाता है।
  • यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

उदाहरण

['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
code-golf  string  ascii-art 
— AdmBorkBork
स्रोत
ऐसा लगता है कि जिन मामलों में एक एक्रॉस्टिक उत्पन्न होता है, सूची उस क्रम में होगी?
— लीक से हटकर नून
क्या आपके पास मेसोनिक टेस्टकेस हो सकता है?
— लीक नुन्
1
क्या अतिरिक्त प्रमुख स्थानों की अनुमति है?
— पुरकाकूदरी
यह नहीं कहता कि इनपुट को सही ढंग से क्रमबद्ध करने की गारंटी है, लेकिन परीक्षण के मामलों को देखते हुए, वे हैं। क्या वो?
— aross
2
@ Pietu1998 यकीन है, यह ठीक है - महत्वपूर्ण बात यह है कि शब्द पंक्तिबद्ध हैं। मैं उस स्पष्टीकरण में संपादित करूँगा।
— AdmBorkBork

जवाबों:

6

ब्रेकीलॉग , 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

इसे ऑनलाइन आज़माएं!

(आधा मिनट लगता है, इसलिए धैर्य रखें।)

— लीक नन
स्रोत
1
ऐसा लगता है कि कुछ लिखने का प्रयास किया गया :) बहुत अच्छा!
— एमिगा
@TimmyD फिक्स्ड, धन्यवाद।
— लीकेज नन
4

जावास्क्रिप्ट (ईएस 6), 255 263 269 286

संपादित के रूप में प्रमुख स्थानों में से मनमाना संख्या अनुमति दी है 17 बचाया बाइट
EDIT2 कुछ उथल, 6 बाइट बचाया
Edit3 (feersum के जवाब देने के लिए ओपी टिप्पणी) के बजाय स्ट्रिंग की एक सूची प्रदान नई-पंक्तियों के साथ एक एकल स्ट्रिंग की, 8 अधिक बचाया बाइट

इनपुट सूची में प्रत्येक शब्द के लिए, मैं सभी अधिभोग mesostics / acrostics को खोजने के लिए एक पुनरावर्ती 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>
स्निपेट का विस्तार करें

— edc65
स्रोत
3

पर्ल 6, 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}
— bb94
स्रोत
3

गणितज्ञ 10.0, 139 बाइट्स

एक अनाम फ़ंक्शन लाइनों की सूची लौटाता है:

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

उदाहरण का उपयोग:

[१४४] में: = f = सॉर्ट करें [{q = Max [p = Min / @ स्थिति @@@ ({z = {## २}}, #} ​​)], Array ["" &, q- # २ ] ToUpperCase ~ Mapat ~ ## और @@@ ({z, पी} )} और @@@ परम्युटेशन्स @ वर्ण @ #] [[1,2]] और;

[१४५] में: = f @ {"देर", "बॉलरूम", "आँवला", "से", "सिर"} // कॉलम

 ... चेतावनियों के कई पन्ने ... 

बाहर [145] = बालरूम
            निहाई
            सेवा मेरे
           सिर

मैं कैपिटलाइज़ेशन करने के लिए बेहतर तरीकों के सुझावों की तलाश कर रहा हूं। मुझे MapAtस्ट्रिंग में पत्र को कैपिटल करने के लिए एक बहुत अच्छा कार्य मिला ।

— feersum
स्रोत
ज़रूर, फ़ंक्शंस मल्टीलाइन स्ट्रिंग्स को स्ट्रींग की सूची के रूप में वापस कर सकते हैं।
— AdmBorkBork
2

हास्केल, 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
— nimi
स्रोत
2

पायथन, 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:]
                       ]
— जोनाथन एलन
स्रोत
1

पर्ल 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"))

उम्मीदवारों की सूचियों की सूची को स्थानांतरित करना यह सुनिश्चित करने के लिए आवश्यक है कि एक एक्रॉस्टिक, यदि यह मौजूद है, तो किसी भी मेसैटोलॉजिस्ट से पहले पाया जाता है।

— SMLS
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.