^{Para mais bondade no MtG: Magic: The Gathering Combat with Habilidades}

Premissa:

Em Magic: the Gathering, você lança feitiços pagando seu custo de mana tocando em terrenos pelo valor necessário. Essas terras podem produzir uma das cinco cores que são:

• Branco (W)
• Azul (U)
• Preto (B)
• Vermelho (R)
• Verde (G)

O custo é composto de duas partes: um número que é o requisito genérico de mana e uma série de símbolos que representam o requisito de mana colorido. O número é o custo genérico de mana e pode usar qualquer cor de mana para satisfazê-lo, por exemplo, (3)pode ser pago com ele WGG. Os símbolos são um requisito 1: 1 de uma cor específica. por exemplo WWUBR, exigiria 2 mana branco, 1 azul, 1 preto e 1 vermelho. A parte genérica sempre será anterior à parte colorida. Como lembrete, (0)é um custo válido e deve ser tratado.

Você pode ter custos que são totalmente genéricos, ou totalmente coloridos, ou ambos. Por exemplo, o cartão a seguir tem um custo de 4BB e é pago com 4 de qualquer mana colorido e 2 mana preto:

As terras deste desafio produzirão uma mana. No entanto, consideraremos terrenos que podem produzir várias cores, mas que ainda produzem apenas 1 mana. Por exemplo G, produzirá uma mana verde, WGpode produzir 1 branco ou 1 verde.

Entrada:

Você receberá duas entradas, o custo de um cartão e uma lista de terrenos.

O custo do cartão pode ser uma sequência ou uma tupla contendo um número e uma sequência para a parte colorida. Se não houver uma peça genérica, você pode preencher a string / tupla com um 0.

A lista de terrenos será uma lista de cadeias de caracteres onde cada um é o que um determinado terreno pode produzir. Esta lista pode estar vazia (você não tem terrenos). Você também pode considerar isso como uma lista de entradas usando a lógica de máscara de bits, mas postar seu esquema, se o fizer. O pedido também depende de você, se for importante, caso contrário, será assumido em WUBRGordem.

#Example input formats
"4BB", ("WG","B","B") #
(4,"BB"), (7,3,3)     #Both should return falsy

Resultado:

Um truthyvalor se você puder pagar com sucesso o custo dado suas terras e um falseyvalor se você não puder.

Regras:

• Você terá entrada válida garantida
• Presume-se que a mana esteja sempre na ordem "WUBRG". Se você deseja uma ordem diferente, informe-o na sua resposta.
• As cores sempre serão agrupadas no custo, por exemplo, "WWUBBRG"
• A entrada usará todas as maiúsculas ou minúsculas, sua escolha.
• Você deve ser capaz de lidar com regex 127[WUBRG]{127}e 254 terrenos.
• Lacunas padrão proibidas
• Isso é código-golfe , a resposta mais curta por idioma ganha

Exemplos:

"0", ("")                => 1
"1BB", ("WG","B","B")    => 1
"BB", ("WG","B","B")     => 1
"WB", ("WG","B","B")     => 1
"1UB", ("W","U","B")     => 1
"1BB", ("WB","WB","WG")  => 1
"1", ("WG","B","B")      => 1
"1BB", ("WGR","WB","WB") => 1
"WUBRG", ("W","U","B","R","G")  => 1
"1WWUBB", ("W","WG","U","B","B","R")  => 1
"10BB", ("WGR","WB","WB","B","B","B","B","B","B","B","B","B") => 1

"R", ("")                => 0
"4", ("WG","B","B")      => 0
"1BB", ("WG","WB")       => 0
"1UB", ("WG","W","UB")   => 0
"1UBR", ("W","WG","UBR") => 0
"WUBRG", ("WUBRG")       => 0
"1WWUBB", ("W","WG","U","B","B")  => 0
"10UU", ("WGR","WB","WB","B","B","B","B","B","B","B","B","B") => 0

JavaScript (ES6), 91 bytes

Toma entrada como (cost)(lands):

• $cost$ é uma lista de caracteres em ordem, prefixada com a parte genérica, mesmo quando é0BGRUW$0$
• $lands$ é uma lista de strings.

a=>g=([c,...r],n=0,s=e='')=>[...n+s].sort()+e==a|(c&&[e,e,...c].some((c,i)=>g(r,n+!i,s+c)))

Experimente online!

Comentado

a =>                        // main function taking the array a[] describing the cost
  g = (                     // g = recursive function taking:
    [c, ...r],              //   c = next land string; r[] = remaining land strings
    n = 0,                  //   n = generic mana, initialized to 0
    s = e = ''              //   s = generated cost string, initialized to e = empty string
  ) =>                      //
    [...n + s].sort() + e   // prepend n to s, split, sort and force coercion to a string
    == a | (                // if this is matching a[], the test is successful
      c &&                  // if c is defined:
      [                     //   try the following recursive calls:
        e,                  //     - increment n and append nothing to s
        e,                  //     - do nothing
        ...c                //     - leave n unchanged and append a character to s
      ].some((c, i) =>      //   for each c at position i in the above array:
        g(r, n + !i, s + c) //     process the recursive call
      )                     //   end of some()
    )                       // end of the recursive part

Python 2 , 131 129 bytes

lambda (g,c),m:any(all(c[i]in p[i]for i in range(l(c)))for p in permutations(m,l(c)))*(g<=l(m)-l(c))
l=len
from itertools import*

Experimente online!

Retina , 60 bytes

\d+
*
~["^("|'|]")*\n"1,L$`(?<=(^|.*¶)+).*
(?($#1)^|([_$&]))

Experimente online! O link inclui casos de teste. Explicação:

\d+
*

Converta o mana genérico em unário. Isso usa _s repetidos .

1,L`.*

Combine todas as linhas após a primeira, ou seja, a lista de terrenos. (Isso normalmente corresponderia novamente no final da entrada, mas a aparência por trás impede isso.)

(?<=(^|.*¶)+)

Capture o número da linha indexada em 1 $#1.

$
(?($#1)^|([_$&]))

Substitua cada terreno por um regex que captura os custos correspondentes a esse terreno ou custos genéricos, mas apenas uma vez.

|'|

Associe as expressões regulares resultantes com |s.

["^("]")*\n"

Envolva o regex ^(e )*\n(não consigo inserir um ¶aqui).

~

Conte o número de correspondências dessa regex no valor atual.

Exemplo: Para o caso do 1BB¶WB¶WB¶WGregex gerado, é:

^((?(2)^|([_WB]))|(?(3)^|([_WB]))|(?(4)^|([_WG])))*\n

que _BB¶WB¶WB¶WGcorresponde conforme necessário.

Geléia , 21 bytes

Œpµ®œ-)Ạ
L<⁴Ṫ©L+Ḣ¤ȯçṆ

Experimente online!

Saídas

O formato de entrada é o que realmente torna isso difícil para o Jelly. Porque Ṫe Ḣmodificar a matriz, precisamos usar ©e ®além disso. Com 3 entradas separadas, isso seria 18 bytes . (Embora eu tenha certeza de que há uma solução de 14 bytes aguardando para ser publicada por um dos mentores do Jelly.)

Pitão , 25 bytes

&glQ+hAElH}k.-LHusM*GHQ]k

Experimente online!

Se Pyth tivesse uma função "produto cartesiano de matriz" como a de Jelly Œp, isso facilmente venceria minha solução de Jelly. Atualmente isso é feito por usM*GHQ]k.

Perl 6 , 56 46 bytes

{(1 x*~*).comb.Bag⊆any [X] $(1 X~$_)>>.comb}

Experimente online!

Função ao curry. Recebe entrada como (@lands)($generic_cost, $colored_costs)um 0 explícito para custo genérico. A idéia básica é introduzir um novo símbolo 1representando mana genérico e usar Perl 6 Bags (multisets) para verificar se é possível obter o mana necessário das terras.

Explicação

{ ... }  # Anonymous block returning WhateverCode
  # Preprocess cost
  1 x*    # '1' for generic mana repeated times generic cost
      ~*  # Concat with colored costs
 (      ).comb  # Split into characters
              .Bag  # Convert to a Bag (multiset)
                             # Preprocess lands
                             1 X~$_   # Prepend '1' to each land
                           $(      )  # Itemize to make 1-element lists work
                                    >>.comb  # Split each into chars
                       [X]  # Cartesian product, yields all possible ways
                            # to select colors from lands
                  # Finally check if the cost Bag is a subset of any possible
                  # color selection (which are implicitly converted to Bags)
                  ⊆any

Haskell , 94 bytes

x#[]=[]
x#(s:t)|x`elem`s=t|0<1=s:x#t
(e,[])?s=length s>=e
(e,x:y)?s|x#s==s=0>1|0<1=(e,y)?(x#s)

Experimente online!

Contamos com o fato de que todas as cores serão fornecidas na mesma ordem no custo e na lista de terrenos. Primeiro, tocamos as terras dando a mana colorida necessária e depois verificamos se ainda temos terras suficientes para pagar o custo incolor.