Büyüde: Toplanma, büyücüler ("uçak yürüyüşçüleri" olarak bilinir) büyü yaparak birbirleriyle savaşırlar. Büyüler manaya maloluyor. Beş renk manası vardır: Sırasıyla {W}, {U}, {B}, {R} ve {G} olarak temsil edilen Beyaz, Mavi, Siyah, Kırmızı ve Yeşil.

Bir büyünün maliyeti biraz daha karmaşıktır. Maliyet, aşağıdakilerin herhangi bir kombinasyonu olabilir:

• Bir veya daha fazla renk
• Bir veya daha fazla renksiz, {X} olarak temsil edilir, ki burada X pozitif bir tamsayıdır.
• {Y / Z} olarak gösterilen, Y ve Z'nin bir renk (beş harften biriyle temsil edilir) veya renksiz, pozitif bir tamsayı ile temsil edilen bir veya daha fazla melez

Bir büyü yapmaya çalışırken aşağıdaki kurallar geçerlidir:

• Maliyetindeki bir renk, o rengin bir manası tarafından karşılanmalıdır.
• Renksiz bir maliyet {X}, herhangi bir rengin X manası tarafından karşılanabilir
• Bir hibrit maliyet {Y / Z}, Y veya Z'nin sağlanmasıyla sağlanabilir
  • Diş tellerinin yuvalanmadığını unutmayın.
  • Y ve Z melez değil

Bir mana havuzu ve bir maliyet verildiğinde, yalnızca o havuzdaki mana maliyeti karşılayabiliyorsa, aksi takdirde yanlış (veya bazı sahte değer) varsa, yazdırır veya gerçek (veya bazı truthy değeri) döndüren bir program veya işlev yazın.

Mana havuzu, biçiminin boş olmayan bir dizesidir:

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

Maliyet, biçimin boş olmayan bir dizesidir:

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

Örnekler

Formatında Pool Cost -> ExpectedOutput(Havuz ve Maliyet arasındaki boşlukla):

{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

Pyth, 55 53 52 50 bayt

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

Çevrimiçi deneyin: Gösteri veya Test koşum

Zaman ve hafıza karmaşıklığının gerçekten kötü olduğuna dikkat edin. Yani ikinci örnek işe yaramıyor. Makineme çarpmadan önce yaklaşık 1.6 GB RAM tahsis ettim.

açıklama

Açıklama 53 çözüm içindir. Tek fark, ilk ayrıştırmanın başlangıç ​​yerine ortada gerçekleşmesidir.

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

İşte ilk ayrıştırma.

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

Böylece giriş "{W},{R},{R} {2/W},{W/B}"dönüştürülür ['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

Peki bu ne işe yarıyor? Maliyet girişi şu şekilde '2/w,w/b'dönüştürülür:

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

Her dize ['aa', 'ab', 'ac', ..., 'zx', 'zy', 'zz', 'w']tatmin eder {2/W}ve her char 'wb'tatmin eder {w/b}.

Şimdi bu listelerin (veya karakter dizilerinin) Kartezyen ürününü üretiyoruz ve mana havuzu ile herhangi bir kombinasyon üretilip üretilemediğini görüyoruz.

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)

Python 2.7, 412 karakter

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

İşlev fkontrolü yapan işlevdir . Bu mana havuzunu alır ve maliyeti string argümanları olarak alır ve mananın maliyeti 1ne zaman karşıladığını ve 0başka türlü ne zaman yazdırır . Örneğin, f('{R},{R},{G},{B},{R}', '{4},{R}')yazdırır 1.

Ungolfed, temelde böyle görünüyor

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