^{Para obtener más bondad de MtG: Magic: The Gathering Combat with Habilities}

Premisa:

En Magic: the Gathering, lanzas hechizos pagando su costo de maná tocando tierras por la cantidad requerida. Estas tierras pueden producir uno de los cinco colores que son:

• Blanco (W)
• Azul (U)
• Negro (B)
• Rojo (R)
• Verde (G)

El costo se compone de dos partes: un número que es el requisito de maná genérico y una serie de símbolos que representan el requisito de maná de color. El número es el costo de maná genérico y puede usar cualquier color de maná para satisfacerlo, por ejemplo, (3)se puede pagar WGG. Los símbolos son un requisito 1: 1 de un color específico. por ejemplo WWUBR, requeriría 2 maná blanco, 1 azul, 1 negro y 1 rojo. La parte genérica siempre vendrá antes que la parte coloreada. Como recordatorio, (0)es un costo válido y debe ser manejado.

Puede tener costos que sean completamente genéricos, o completamente coloreados, o ambos. Por ejemplo, la siguiente carta tiene un costo de 4BB y se paga con 4 de cualquier maná de color y 2 de maná negro:

Las tierras en este desafío producirán cada una un maná. Sin embargo, consideraremos tierras que pueden producir múltiples colores pero que solo producen 1 maná. Por ejemplo G, producirá un maná verde, WGpuede producir 1 blanco o 1 verde.

Entrada:

Se le darán dos entradas, el costo de una tarjeta y una lista de tierras.

El costo de la tarjeta puede ser una cadena o una tupla que contiene un número y una cadena para la parte coloreada. Si no hay una parte genérica, puede rellenar la cadena / tupla con un 0.

La lista de tierras será una lista de cadenas donde cada una es lo que puede producir una tierra determinada. Esta lista puede estar vacía (no tienes tierras). También puede tomar esto como una lista de entradas usando la lógica de máscara de bits, pero publique su esquema si lo hace. El orden también depende de usted si es importante, de lo contrario se supondrá en WUBRGorden.

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

Salida:

Un truthyvalor si puede pagar con éxito el costo dado sus tierras y un falseyvalor si no puede.

Reglas:

• Se le garantizará una entrada válida
• Se supondrá que Mana siempre estará en el orden "WUBRG". Si desea un orden diferente, indíquelo en su respuesta.
• Los colores siempre se agruparán en el costo, por ejemplo, "WWUBBRG"
• La entrada utilizará todas las mayúsculas o todas las minúsculas, a su elección.
• Deberías poder manejar expresiones regulares 127[WUBRG]{127}y 254 tierras.
• Lagunas estándar prohibidas
• Este es el código de golf , la respuesta más corta por idioma gana

Ejemplos:

"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$BGRUW$0$
• $lands$

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

Pruébalo en línea!

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*

Pruébalo en línea!

Retina , 60 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

\d+
*

Convierte el maná genérico en unario. Esto utiliza repetidos _s.

1,L`.*

Haga coincidir todas las líneas después de la primera, es decir, la lista de tierras. (Esto normalmente volvería a coincidir al final de la entrada, pero el mirar hacia atrás lo impide).

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

Capture el número de línea indexada 1 en $#1.

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

Reemplace cada tierra con una expresión regular que capture los costos que coincidan con esa tierra o los costos genéricos, pero solo una vez.

|'|

Unir las expresiones regulares resultantes con |s.

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

Envuelva la expresión regular ^(y )*\n(parece que no puedo insertar un ¶aquí).

~

Cuente el número de coincidencias de esa expresión regular en el valor actual.

Ejemplo: para el caso de 1BB¶WB¶WB¶WGla expresión regular generada es:

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

que _BB¶WB¶WB¶WGcoincide según lo requerido.

Jalea , 21 bytes

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

Pruébalo en línea!

Salidas

El formato de entrada es lo que realmente hace que esto sea difícil para Jelly. Porque Ṫy Ḣmodificar la matriz, necesitamos usar ©y ®además. Con 3 entradas separadas esto sería 18 bytes . (Aunque estoy seguro de que hay una solución de aproximadamente 14 bytes esperando ser publicada por uno de los autores intelectuales de Jelly).

Pyth , 25 bytes

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

Pruébalo en línea!

Si Pyth tuviera una función de "producto cartesiano de matriz" como la de Jelly Œp, esto superaría fácilmente a mi solución Jelly. Actualmente eso lo hace usM*GHQ]k.

Perl 6 , 56 46 bytes

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

Pruébalo en línea!

Función curry Toma datos como (@lands)($generic_cost, $colored_costs)con un 0 explícito para el costo genérico. La idea básica es introducir un nuevo símbolo que 1represente el maná genérico y usar Perl 6 bolsas (multisets) para verificar si es posible obtener el maná requerido de las tierras.

Explicación

{ ... }  # 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)

Pruébalo en línea!

Confiamos en el hecho de que todos los colores se darán en el mismo orden en el costo y en la lista de terrenos. Primero tocamos las tierras dando el maná de color requerido y después de eso solo verificamos que todavía tenemos suficientes tierras para pagar el costo incoloro.