क्या आप जादू कर सकते हैं?

Question

मैजिक में: द गैदरिंग, मैजेस (जिसे "प्लेनवॉल्कर्स" के रूप में जाना जाता है) एक दूसरे को मंत्र बजाकर लड़ाई करते हैं। मंत्रों की लागत मन। मन के पांच रंग मौजूद हैं: क्रमशः व्हाइट, ब्लू, ब्लैक, रेड और ग्रीन, को {W}, {U}, {B}, {R}, और {G} के रूप में दर्शाया गया है।

एक वर्तनी की लागत थोड़ी अधिक जटिल है। लागत निम्नलिखित में से किसी भी संयोजन हो सकती है:

• एक या एक से अधिक रंग
• एक या अधिक रंगहीन, को {X} के रूप में दर्शाया जाता है, जहां X एक धनात्मक पूर्णांक है
• एक या एक से अधिक संकर, {Y / Z} के रूप में दर्शाए जाते हैं, जहां Y और Z या तो एक रंग हैं (पांच अक्षरों में से एक द्वारा दर्शाया गया है) या बेरंग, एक सकारात्मक पूर्णांक द्वारा दर्शाया गया है

एक स्पेल डालने का प्रयास करते समय निम्नलिखित नियम लागू होते हैं:

• लागत में एक रंग को उस रंग के एक मान से संतुष्ट होना चाहिए
• एक बेरंग लागत {X} किसी भी रंग के X मान से संतुष्ट हो सकती है
• एक संकर लागत {Y / Z} या तो Y या Z से संतुष्ट होकर संतुष्ट हो सकती है
  • ध्यान दें कि ब्रेसिज़ नेस्टेड नहीं हैं
  • Y और Z हाइब्रिड नहीं हैं

एक कार्यक्रम या फ़ंक्शन लिखें, जो कि मान और लागत का एक पूल दिया गया है, प्रिंट या सही (या कुछ सत्य मान) और यदि केवल उस पूल में मान लागत को संतुष्ट कर सकता है, तो गलत (या कुछ गलत मूल्य)।

एक मान पूल प्रारूप का एक गैर-खाली स्ट्रिंग है:

Color1,Color2,Color3,...,Colorn-1,Colorn

लागत प्रारूप का एक गैर-रिक्त स्ट्रिंग है:

Cost1,Cost2,Cost3,...,Costn-1,Costn

उदाहरण

प्रारूप में Pool Cost -> ExpectedOutput(पूल और लागत के बीच की जगह के साथ):

{R},{R},{G},{B},{R} {4},{R} -> True
{G},{G},{G},{G},{W},{W},{W} {2/W},{2/U},{2/B},{2/R},{2/G} -> False
{G},{G},{R} {R/G},{G/B},{B/R} -> True
{R},{R},{R},{G} {1},{G},{2/G}-> True
{R} {R},{R},{R},{R},{R} -> False
{W},{R},{R} {2/W},{W/B} -> True
{U},{U} {1} -> True
{W},{R},{G} {1},{2} -> True

Comments

क्या पूल में रंगहीन मैना होना संभव है?

— nutki

@ कुटकी असली खेल में, हाँ। चुनौती में, नहीं। चुनौती में परिभाषित केवल पांच रंग चुनौती के उद्देश्यों के लिए मौजूद हैं।

— बारिश

मैं बहुत लंबे समय से जादू से दूर हूं। संकर लागत?!?

— Sparr

@Sparr उन्हें रवनीका में पेश किया गया, 2005 में वापस

— murgatroid99

@ murgatroid99 मैंने तब छोड़ा जब 6E बाहर आया। मेरे कोई भी मित्र नए नियमों के अनुकूल होने को तैयार नहीं थे :(

— 18

Answer 1

पायथ, 55 53 52 50 बाइट्स

FN*Fmsm?k}kG^Gvkcd\/ceKc-rz0`Hd\,#=sN)I!.-NhK1B)E0

इसे ऑनलाइन आज़माएं: प्रदर्शन या टेस्ट हार्नेस

ध्यान दें कि समय और स्मृति जटिलता वास्तव में खराब है। तो दूसरा उदाहरण काम नहीं करता है। अपनी मशीन पर क्रैश होने से पहले मैं लगभग 1.6 जीबी राम आवंटित करता हूं।

व्याख्या

स्पष्टीकरण 53 समाधान के लिए है। एकमात्र अंतर यह है, कि प्रारंभिक पार्सिंग शुरुआत के बजाय बीच में होता है।

Kc-rz0"{}"dFN*Fmsm?k}kG^Gvkcd\/ceKc-rz0`H\,#=sN)I!.-NhK1B)E0

तो यहाँ एक प्रारंभिक पार्सिंग है।

Kc-rz0`Hd
   rz0     convert input() to lowercase
  -   `H   remove all curly brackets (`H = "{}")
 c      d  split at the space
K          assign to K

तो इनपुट में "{W},{R},{R} {2/W},{W/B}"परिवर्तित हो जाता है ['w,r,r', '2/w,w/b']।

m               ceK\,    map each cost d of the costs split by "," to:
 s                         the sum of
  m         cd\/           map each value k of cost split by "/" to:
    k                        k
   ? }kG                     if k in "abcdef...xyz" else
        ^Gvk                 Cartesian product with "abc...yz" of int(k) repeats

तो यह क्या करता है? लागत इनपुट में '2/w,w/b'परिवर्तित हो जाता है:

[['aa', 'ab', 'ac', ..., 'zx', 'zy', 'zz', 'w'], 'wb']

में हर स्ट्रिंग ['aa', 'ab', 'ac', ..., 'zx', 'zy', 'zz', 'w']को संतुष्ट करता है {2/W}और में हर चार 'wb'को संतुष्ट करता है {w/b}।

अब हम इन सूचियों (या तार) के कार्टेशियन उत्पाद को उत्पन्न करते हैं और देखते हैं, यदि कोई संयोजन मान-पूल के साथ निर्मित किया जा सकता है।

FN*F...              )      for N in Cartesian product of ...:
       #   )                   while 1:
        =sN                      N = sum(N)
                               this flattens N
            I!.-NhK            if not (subtract mana pool from N):
                   1             print 1 (True)
                    B            break
                      E      else:
                       0       print 0 (False)

Comments

सत्य और झूठे मूल्यों की अनुमति है, न कि केवल Trueऔर False।

— इसहाक

आप असाइनमेंट को टॉगल करके किसी कैरेक्टर को सेव कर सकते हैं K। Kc-rz0"{}")जहां Kपहली बार उपयोग किया गया है, वहां रखो और प्रारंभिक असाइनमेंट को हटा दें K।

— इसहाक

@ आइसाकग ओह, यह देखना चाहिए था। धन्यवाद।

— जकुबे

@Rainbolt आपने एक गैर-कार्यशील समाधान स्वीकार किया। जब मैंने इसे पोस्ट किया था तब यह काम किया था, लेकिन पाइथ ने बहुत कुछ बदल दिया। मैंने इसे अपडेट किया और 2 और बाइट्स भी बचाए।

— जकुबे

@Jakube धन्यवाद, लेकिन इस उत्तर को एक दुभाषिया का उपयोग करके काम करने की आवश्यकता है, जो उस समय उपलब्ध थी, जब कुछ नए अपडेट किए गए दुभाषिया को चुनौती नहीं दी गई थी।

— रेनबोल्ट

Answer 2

पायथन 2.7, 412 अक्षर

import re,collections as C
r,C=re.findall,C.Counter
def g(m,h,c,v):
 try:return t(m,h,c+int(v))
 except:
  if m[v]:return t(m-C({v:1}),h,c)
def t(m,h,c):return any(g(m,h[1:],c,v)for v in h[0].split('/'))if h else sum(m.values())>=c
def f(m,c):m=C(r(r'\w',m));c=[filter(None, x)for x in zip(*r(r'(\w+/\w+)|(\d+)|(\w)',c))];m.subtract(C(c[2]));print all(x>=0 for x in m.values())*t(m,c[0],sum(int(x)for x in c[1]))

फ़ंक्शन fवह है जो चेक करता है। यह मान पूल और लागत को तर्कों के रूप में लेता है, और 1जब मन लागत को संतुष्ट करता है और 0अन्यथा प्रिंट करता है । उदाहरण के लिए, f('{R},{R},{G},{B},{R}', '{4},{R}')प्रिंट 1।

अघोषित रूप से, यह मूल रूप से ऐसा दिखता है

import re
from collections import Counter
def helper(mana, hybrids, colorless, option):
  try:
    option = int(option) # See if option is an integer
    # For colorless hybrid, just add the value to the colorless amount
    # to check at the end.
    return check_hybrids(mana, hybrids, colorless + option)
  except ValueError: # Option is a mana letter
    # For colored hybrid costs, check if any of that color is
    # available, then try to pay the rest of the cost with 1 less
    # of that color.
    if mana[option] >= 0:
      return check_hybrids(mana - Counter({option: 1}), hybrids, colorless)
    else:
      return False
def check_hybrids(mana, hybrids, colorless):
  '''Check whether the given mana pool can pay the given hybrid costs and colorless costs'''
  if hybrids:
    # For each option in the first hybrid cost, check whether the
    # rest of the cost can be paid after paying that cost
    return any(helper(mana, hybrids[1:], colorless, option) for option in hybrids[0].split('/'))
  else:
    # When there are no remaining hybrid costs, if there is enough
    # remaining mana to pay the colorless costs, we have success
    return sum(m.values()) > colorless
def can_cast(mana_str, cost_str):
  mana = Counter(re.findall(r'\w', mana_str))
  # transpose to get separate lists of hybrid, colorless, and colored symbols
  cost = zip(*re.findall(r'(\w+/\w+)|(\d+)|(\w)',cost_str))
  cost = [filter(None, sublist) for sublist in cost] # Remove unfound symbols
  mana.subtract(Counter(cost[2]))
  # After subtracting the single-colored cost from the mana pool, if
  # anything in the mana pool is negative, we didn't have enough to
  # pay for that color.
  if any(x <=0 for x in mana.values()):
    return False
  return check_hybrids(mana, cost[0], sum(int(x)for x in cost[1]))