शब्द श्रृंखला खेलें

Question

जब मैं छोटा था, तो मैं एक शब्द का खेल खेलने के लिए उपयोग करता हूं जिसे वर्ड चेन कहा जाता है । यह बहुत सरल था। पहला खिलाड़ी एक शब्द चुनता है; अगला खिलाड़ी एक और शब्द कहता है जो उसी अक्षर से शुरू होता है जिसका पिछला शब्द समाप्त हुआ था। यह हमेशा के लिए चला जाता है जब तक कि कोई त्याग नहीं करता! ट्रिक यह है कि आप एक ही शब्द का दो बार उपयोग नहीं कर सकते (जब तक कि हर कोई उस शब्द का इस्तेमाल भूल न जाए!)। आमतौर पर हम इसे कठिन बनाने के लिए एक निश्चित विषय के साथ खेलते हैं। लेकिन अब, मैं चाहता हूं कि आप मेरे लिए ऐसा करने के लिए एक कार्यक्रम बनाएं।

चुनौती

शब्दों और दिए गए शब्दों के सेट का उपयोग करके सभी सबसे लंबे समय तक संभव शब्द श्रृंखलाओं को खोजने के लिए एक पूर्ण कार्यक्रम या फ़ंक्शन लिखें।

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है!

इनपुट

दो इनपुट हैं: एक सूची और एक शुरुआत शब्द। प्रारंभ शब्द सूची में नहीं होगा। इनपुट्स सभी लोअरकेस ASCII हैं, और सूची में डुप्लिकेट शब्द नहीं होंगे।

उत्पादन

सूची से शब्दों के सभी क्रम इस प्रकार हैं:

• प्रारंभ शब्द अनुक्रम में पहला शब्द है।

• प्रत्येक बाद का शब्द पिछले अक्षर के अंतिम अक्षर के समान अक्षर से शुरू होता है।

• अनुक्रम की लंबाई सबसे लंबे समय तक संभव है ।

यदि कई सबसे लंबे क्रम हैं, तो उन सभी को आउटपुट करें।

अनुक्रम को सूची के सभी शब्दों को शामिल करने की आवश्यकता नहीं है। कभी-कभी यह संभव नहीं होता है (देखें वृषण)। फिर, कोई भी शब्द दो बार इस्तेमाल नहीं किया जा सकता है!

परीक्षण के मामलों

In: [hello, turtle, eat, cat, people] artistic
Out:  [artistic, cat, turtle, eat]
In: [lemonade, meatball, egg, grape] ham 
Out: [ham, meatball, lemonade, egg, grape]
In: [cat, cute, ewok] attic
Out: [attic, cute, ewok]
In:[cat, cute, ewok, kilo, to, otter] attic
Out: [attic, cute, ewok, kilo, otter]
In:[cat, today, yoda, attic] ferret
Out: [ferret, today, yoda, attic, cat]
In: [cancel, loitering, gnocchi, improv, vivic, child, despair, rat, tragic, chimney, rex, xylophone] attic
Out: [[attic, child, despair, rat, tragic, cancel, loitering, gnocchi, improv, vivic, chimney], [attic, cancel, loitering, gnocchi, improv, vivic, child, despair, ra', tragic, chimney]]
In: [cat, today, yoda, artistic, cute, ewok, kilo, to, otter] attic
Out: [attic, cat, today, yoda, artistic, cute, ewok, kilo, otter]

Comments

@downvoters क्या आप बता सकते हैं कि मैं अपने प्रश्न को कैसे सुधार सकता हूँ?

— तन्माथ

@ user81655 यकीन है

— TanMath

क्या आप कई आउटपुट अनुक्रमों के साथ एक परीक्षण मामला जोड़ सकते हैं?

— ईसैक

@ आइसाकग श्योर! इस पर काम कर रहे हैं

— तानमथ

@ आइसाकग जोड़ा! (15 कैरेक्टर लिमिट पूरी की ...)

— TanMath

Answer 1

पायथ, 25 23 बाइट्स

.MlZfqhMtTeMPT+Lzs.pMyQ

परीक्षण सूट

एक जानवर बल समाधान। कुछ बड़े परीक्षण मामलों के लिए बहुत धीमी गति से।

फार्म में इनपुट:

attic
["cat", "today", "yoda", "to", "otter"] 

फार्म में आउटपुट:

[['attic', 'cat', 'today', 'yoda'], ['attic', 'cat', 'to', 'otter']]

स्पष्टीकरण:

.MlZfqhMtTeMPT+Lzs.pMyQ
                           Q = eval(input()) (The list of words)
                           z = input()       (The starting word)
                     yQ    All subsets of the input.
                  .pM      All permutations of the subsets.
                 s         Flatten.
              +Lz          Add the starting word to the front of each list.
                           This is all possible sequences.
    f                      Filter on
     q                     The equality of
      hMtT                 The first character of each word but the first
          eMPT             The last character of each word but the last
.MlZ                       Take only the lists of maximal length.

Comments

क्या आप एक स्पष्टीकरण जोड़ सकते हैं?

— तन्मय

आपका कोड कई आउटपुट अनुक्रम उदाहरण के लिए हमेशा के लिए चलता है

— TanMath

@ तन्मात्रा नहीं, यह सिर्फ घातीय समय है, इसलिए यह बहुत धीमा है।

— ईसैक

कोड गोल्फ: एक तेज गति से चलने वाले कार्यक्रम को तेज गति से चलाने की कला बस कुछ बाइट्स बचाने के लिए: P

— आर्कटुरस

@RikerW मुझे लगता है कि मार्टिन के "कोड रिव्यू: कोड को थोड़ा कम गलत बनाना / कोड गोल्फ बनाना: कोड को थोड़ा कम लंबा बनाना" जैसी टिप्पणी यहाँ याद करने लायक है।

— आर्कटिकस

Answer 2

जावास्क्रिप्ट (ईएस 6), 164 बाइट्स

f=(l,s,r=[[]])=>l.map((w,i)=>w[0]==s.slice(-1)&&(x=l.slice(),x.splice(i,1),o=f(x,w),a=o[0].length,b=r[0].length,r=a>b?o:a<b?r:r.concat(o)))&&r.map(q=>[s].concat(q))

व्याख्या

एक पुनरावर्ती फ़ंक्शन जो यह जांचता है कि सभी संभावित विकल्पों के लिए आउटपुट सूची कितनी लंबी होगी।

शब्दों के सरणियों की एक सरणी देता है।

f=(l,s,r=[[]])=>            // l = list, s = starting word, r is not passed (it is
                            //     here so that it is not defined globally)
  l.map((w,i)=>             // for each word w at index i
    w[0]==s.slice(-1)&&(    // if the first letter is the same as the last letter:
      x=l.slice(),          // x = clone of the list of words
      x.splice(i,1),        // remove the current word
      o=f(x,w),             // get the list of words starting from the current word
      a=o[0].length,
      b=r[0].length,
      r=a>b?o:              // if o is longer, set r to o
        a<b?r:              // if o is shorter, keep r
        r.concat(o)         // if o is same, add it to r
    )
  )
  &&r.map(q=>[s].concat(q)) // return a list of longest lists with the starting word

परीक्षा

इसे और अधिक क्रॉस-ब्राउज़र संगत बनाने के लिए परीक्षण में डिफ़ॉल्ट पैरामीटर का उपयोग नहीं किया गया है।

f=(l,s,r)=>l.map((w,i)=>w[0]==s.slice(-1)&&(x=l.slice(),x.splice(i,1),o=f(x,w),a=o[0].length,b=r[0].length,r=a>b?o:a<b?r:r.concat(o)),r=[[]])&&r.map(q=>[s].concat(q))

Word list (space separated) = <input type="text" id="list" value="cancel loitering gnocchi improv vivic child despair rat tragic chimney rex xylophone" /><br />
Starting word = <input type="text" id="word" value="attic" /><br />
<button onclick="result.textContent=f(list.value.split(' '),word.value).join('\n')">Go</button>
<pre id="result"></pre>

Comments

मुझे लगता है कि आप विभाजन के बजाय पॉप का उपयोग कर सकते हैं और o[r.length]?इसके बजाय o.length>r.length?।

— grc

@grc धन्यवाद, मैं वास्तव में o[r.length]टिप पसंद करता हूं ! मैं नहीं जानता कि मैं कैसे उपयोग कर सकता हूं pop।

— user81655

आह एनवीएम - मुझे लगा कि पॉप अपने पहले तर्क के रूप में एक सूचकांक ले सकता है जैसे कि अजगर में।

— grc

यह समाधान कई आउटपुट अनुक्रमों के लिए अमान्य है

— TanMath

@ टैनमैथ फिक्स्ड, हालांकि यह परीक्षण के मामलों में से एक को तोड़ता है।

— user81655

Answer 3

अजगर, १०४

def f(d,w):
 a=[[w]]
 while a:b=a;a=[x+[y]for x in a for y in set(d)-set(x)if x[-1][-1]==y[0]]
 return b

मुझे लगता है कि अब इसे काम करना चाहिए ...

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

Answer 4

पर्ल 5, 275 बाइट्स

शायद उतना गोल्फ नहीं हुआ, जितना हो सकता है, लेकिन, अरे, यह तो वैसे भी नॉनविनिंग है, है ना?

use List::Util max;use List::MoreUtils uniq,before;use Algorithm::Permute permute;$i=pop;permute{push@c,[@ARGV]}@ARGV;for$c(@c){unshift@$c,$i;push @{$d{before{(substr$c->[$_],-1)ne(substr$c->[1+$_],0,1)}keys$c}},$c}for$m(max keys%d){say for uniq map{"@$_[0..$m+1]"}@{$d{$m}}}

इस प्रकार इसका उपयोग करें:

$ perl -M5.010 chain.pl cat tin cot arc
arc cat tin
arc cot tin

चेतावनी! एक लंबी सूची पर इस स्क्रिप्ट का उपयोग करने के लिए बहुत सारी मेमोरी की आवश्यकता होती है! इसने मेरे लिए सात (छह प्लस अतिरिक्त) पर शानदार काम किया लेकिन तेरह (बारह प्लस एक) पर नहीं।

यह अंतिम इनपुट को हटाता है, सरणी सरणी की एक सरणी उत्पन्न करता है, जहां सरणी सभी क्रमपरिवर्तन होते हैं, और आरंभ में वापस प्रारंभिक शब्द जोड़ता है। फिर यह प्रत्येक ऐसी क्रमपरिवर्तन को एक अन्य arrayref पर धकेलता है जो उस हैश का मान होता है जिसमें उस सरणी की मात्रा होती है, जिसमें चैनिंग प्रॉपर्टी वांछित होती है। यह तब अधिकतम ऐसी कुंजी पाता है और सभी सरणियों को प्रिंट करता है।

Answer 5

सी, 373 बाइट्स

g(char*y){printf("%s, ",y);}z(char*w){int i,k=-1,v=0,j=sizeof(c)/sizeof(c[0]);int m[j],b=0;for(i=0;i<j;i++){m[v++]=c[i][0]==w[strlen(w)-1]?2:1;if(u[i]==6)m[v-1]=1;if(strcmp(w,c[i]))k=i;}printf("%s",w);for(i=0;i<j;i++){if(m[i]!=1){if(v+i!=j){g(s);for(;b<j;b++){if(u[b]==6)g(c[b]);}}else printf(", ");u[i]=6;z(c[i]);u[i]=1;}else v+=-1;}if(k!=-1)u[k]=1;if(v==0)printf(" ; ");}

मेरा मानना ​​है कि शायद बहुत अधिक गोल्फिंग है जो मैं यहां कर सकता था इसलिए मैं शायद इसे अपडेट करूंगा।

डी-गोल्फ

char *c[9]={"cat","today","yoda","artistic","cute","ewok","kilo","to","otter"};
u[9]={-1};
char *s="attic";

g(char*y){printf("%s, ",y);}
z(char*w){
   int i,k=-1,v=0,j=sizeof(c)/sizeof(c[0]);
   int m[j],b=0;
   for(i=0;i<j;i++){
      m[v++]=c[i][0]==w[strlen(w)-1]?i:-1;
      if(u[i]==6)m[v-1]=-1;
      if(strcmp(w,c[i]))k=i;
   }
   printf("%s",w);
   for(i=0;i<j;i++){
      if(m[i]!=-1){
         if(v+i!=j){
            g(s);
            for(;b<j;b++){
                if(u[b]==6)g(c[b]);
             }
         }else printf(", ");
         u[i]=6;
         z(c[i]);
         u[i]=-1;
      } else v+=-1;
   }
   if(k!=-1)u[k]=-1;
   if(v==0)printf(" ; ");
}

main(){
   z(s);
   printf("\n");
   return 0;
}

Ideone लिंक - अगर मैंने यह अधिकार नहीं किया तो बस मुझे बताएं: D

Comments

क्या आप परीक्षण के लिए एक ideone लिंक जोड़ सकते हैं ?

— तनमठ Tan

हाँ, मैं इसके साथ अपने उत्तर को अपडेट करूंगा @TanMath

— Danwakeem

लिंक में गोल्फ कोड होना चाहिए, न कि अनगॉल्फड संस्करण। इस तरह, हम गोल्फ संस्करण की पुष्टि कर सकते हैं जिसे आप चुनौती कार्यों के लिए प्रस्तुत कर रहे हैं।

— तन्माथ