अधिकतम पदार्थ निर्माण

Question

इस चुनौती में, आपको दो चीजें दी जाती हैं:

1. एक स्ट्रिंग लंबाई, N
2. तार की एक सूची L, प्रत्येक, एक निर्दिष्ट बिंदु मान के साथ। कोई भी स्ट्रिंग जो पास नहीं है, उसका मान 0 अंक है

आपको लंबाई की एक स्ट्रिंग का निर्माण करने की आवश्यकता है Nजैसे कि सभी प्रतिस्थापन बिंदुओं का योग यथासंभव बड़ा है।

उदाहरण के लिए:

5 [("ABC", 3), ("DEF", 4), ("CDG", 2)]

आउटपुट चाहिए

ABCDG

क्योंकि अंक ( ABCऔर CDG) वाले दो पदार्थों में कुल 5 अंक हैं, और कोई अन्य संभावित निर्माण 5 या अधिक अंक नहीं दे सकता है।

सबस्ट्रिंग को एक स्ट्रिंग में कई बार इस्तेमाल किया जा सकता है, और ओवरलैप कर सकते हैं। आप मान सकते हैं कि अंक हमेशा सकारात्मक होंगे, सबस्ट्रिंग की लंबाई 1 से Nवर्णों की लंबाई के बीच होगी , और वह N > 0। यदि कई निर्माण अधिकतम हैं, तो उनमें से किसी एक को प्रिंट करें।

आपका कार्यक्रम उचित समय पर चलना चाहिए (प्रत्येक उदाहरण के लिए एक मिनट से अधिक नहीं):

1 [("A", 7), ("B", 4), ("C", 100)]     => C
2 [("A", 2), ("B", 3), ("AB", 2)]      => AB
2 [("A", 1), ("B", 2), ("CD", 3)]      => BB
2 [("AD", 1), ("B", 2), ("ZB", 3)]     => ZB
3 [("AB", 2), ("BC", 1), ("CA", 3)]    => CAB
3 [("ABC", 4), ("DEF", 4), ("E", 1)]   => DEF
4 [("A", 1), ("BAB", 2), ("ABCD", 3)]  => AAAA or ABAB or BABA or ABCD
5 [("A", 1), ("BAB", 2), ("ABCD", 3)]  => BABCD or BABAB
5 [("ABC", 3), ("DEF", 4), ("CDG", 2)] => ABCDG
5 [("AB", 10), ("BC", 2), ("CA", 2)]   => ABCAB
6 [("AB", 10), ("BC", 2), ("CA", 2)]   => ABABAB
8 [("AA", 3), ("BA", 5)]               => BAAAAAAA
10 [("ABCDE", 19), ("ACEBD",  18), ("ABEDC", 17), ("BCEDA", 16), ("EBDAC", 15), ("BACD", 14), ("CADB", 13), ("ABDC", 12), ("CABD", 11), ("EBDC", 10), ("ACE", 9), ("CBA", 8), ("AEC", 7), ("BE", 6), ("AE", 5), ("DC", 4), ("BA", 3), ("A", 2), ("D", 1)]
=> ACEBDACEBD

यह एक कोड-गोल्फ है , इसलिए अपनी पसंदीदा भाषा में अपना सबसे छोटा उत्तर तैयार करें!

Comments

क्या हमें आपके सटीक इनपुट प्रारूप का उपयोग करना है या क्या हम अपनी भाषा के लिए किसी सुविधाजनक इनपुट प्रारूप का उपयोग कर सकते हैं?

— दोष

@flawr इनपुट की कोई भी सुविधाजनक विधि ठीक है (शब्दकोश, स्टडिन, फंक्शन परम्स)

— नाथन मेरिल 14

DEFटपल एक अल्पविराम लापता

— isaacg

मेरे पास एक अच्छा समाधान है, लेकिन यह अंतिम परीक्षण के मामले में बहुत धीमा है।

— इसहाक

@ आइसाकग मेरे पास एक सुंदर समाधान है, दुख की बात यह है कि यह टिप्पणी बहुत छोटी है। (मैं नहीं जानता, सिर्फ

— फरमैट

Answer 1

पायथन 2.7, 503 बाइट्स

यह विशेष रूप से गोल्फ नहीं है, न ही यह विशेष रूप से कुशल है; यह सिर्फ एक उल्लेखनीय संघनित संकेंद्रित तार है जो पाशविक-मजबूर हैं। मुझे नहीं लगता कि ए * के साथ उपयोग करने के लिए एक स्वीकार्य अनुमानक बनाना बहुत कठिन होगा, जो शायद थोड़ा तेज होगा। हालांकि, मैंने ऐसा करने की जहमत नहीं उठाई, क्योंकि यह विधि मेरे लैपटॉप पर लगभग 47 सेकंड में सभी उदाहरणों को हल करती है।

import re
v=lambda l,s:sum([len([m.start() for m in re.finditer('(?=%s)'%u,s)])*v for u,v in l])
def m(n,l,e):
 if len(e)==n:
  yield e
 else:
  u=1
  for s,v in sorted(l,key=lambda j:j[1],reverse=True):
   for i in range(len(s)-1,0,-1):
    if len(e)+len(s)-i <= n and e.endswith(s[:i]):
     for r in m(n,l,e+s[i:]):
      u=0;yield r
   if len(e)+len(s)<=n:
    for r in m(n,l,e+s):
     u=0;yield r
  if u:
   yield e
def p(n,l):
 b,r=-1,0
 for s in m(n,l,''):
  a=v(l,s)
  if a>b:b,r=a,s
 return r

इसका परीक्षण करने के लिए:

if __name__ == "__main__":
    for n, l in [
            (1, [("A", 7), ("B", 4), ("C", 100)]),     # => C
            (2, [("A", 2), ("B", 3), ("AB", 2)]),      # => AB
            (2, [("A", 1), ("B", 2), ("CD", 3)]),      # => BB
            (2, [("AD", 1), ("B", 2), ("ZB", 3)]),     # => ZB
            (3, [("AB", 2), ("BC", 1), ("CA", 3)]),    # => CAB
            (3, [("ABC", 4), ("DEF", 4), ("E", 1)]),   # => DEF
            (4, [("A", 1), ("BAB", 2), ("ABCD", 3)]),  # => AAAA or ABAB or BABA or ABCD
            (5, [("A", 1), ("BAB", 2), ("ABCD", 3)]),  # => BABCD or BABAB
            (5, [("ABC", 3), ("DEF", 4), ("CDG", 2)]), # => ABCDG
            (5, [("AB", 10), ("BC", 2), ("CA", 2)]),   # => ABCAB
            (6, [("AB", 10), ("BC", 2), ("CA", 2)]),   # => ABABAB
            (8, [("AA", 3), ("BA", 5)]),               # => BAAAAAAA
            (10, [("ABCDE", 19), ("ACEBD",  18), ("ABEDC", 17), ("BCEDA", 16), ("EBDAC", 15), ("BACD", 14), ("CADB", 13), ("ABDC", 12), ("CABD", 11), ("EBDC", 10), ("ACE", 9), ("CBA", 8), ("AEC", 7), ("BE", 6), ("AE", 5), ("DC", 4), ("BA", 3), ("A", 2), ("D", 1)]) # => ACEBDACEBD
    ]:
        print p(n, l)

व्याख्या

vसमारोह बस सबस्ट्रिंग एल में की सभी घटनाओं की खोज करके एक दिया स्ट्रिंग का मूल्यांकन mसमारोह लंबाई के सभी तार विश्लेषण करता nउपसर्ग के साथ eमें सबस्ट्रिंग से उत्पन्न किया जा सकता है कि l। mखुद को पुन: बुलाता है; पहली कॉल के ''लिए पास होना चाहिए e। उदाहरण के लिए:

>>> for s in m(4, [("A", 1), ("BAB", 2), ("ABCD", 3)], ''):print s
ABCD
BABA
ABCD
ABAB
AAAA

p(के रूप में द्वारा प्रगणित समारोह बस हर संभव तार के माध्यम से लूप m) और उच्चतम मूल्य के साथ एक (के रूप में द्वारा निर्धारित रिटर्न v)।

ध्यान दें कि mफ़ंक्शन वास्तव में सबस्ट्रिंग के मूल्यों के आधार पर छँटाई द्वारा गणना को प्राथमिकता देता है। यह इष्टतमता सुनिश्चित करने के लिए अनावश्यक हो जाता है, और यह वास्तव में दक्षता में थोड़ी बाधा डालता है; मैं इसे हटाकर ~ 20 या इतने बाइट्स बचा सकता था।