^{Per ulteriori qualità MTG: Magic: The Gathering Combat with Abilities}

Premessa:

In Magic: the Gathering, lanci incantesimi pagando il loro costo di mana toccando terre per l'importo richiesto. Queste terre possono produrre uno dei cinque colori che sono:

• Bianco (W)
• Blu (U)
• Nero (B)
• Rosso (R)
• Verde (G)

Il costo è composto da due parti: un numero che è il requisito di mana generico e una serie di simboli che rappresentano il requisito di mana colorato. Il numero è il costo di mana generico e può utilizzare qualsiasi colore di mana per soddisfarlo, ad esempio (3)può essere pagato con WGG. I simboli sono un requisito 1: 1 di un colore specifico. per esempio WWUBRrichiederebbe 2 mana bianchi, 1 blu, 1 nero e 1 rosso. La parte generica verrà sempre prima della parte colorata. Come promemoria, (0)è un costo valido e deve essere gestito.

Puoi avere costi del tutto generici, completamente colorati o entrambi. Ad esempio, la seguente carta ha un costo di 4BB e viene pagata con 4 di qualsiasi mana colorato e 2 di mana nero:

Le terre in questa sfida produrranno ognuna un mana. Tuttavia, considereremo le terre che possono produrre più colori ma che producono comunque solo 1 mana. Ad esempio Gprodurrà un mana verde, WGpuò produrre 1 bianco o 1 verde.

Ingresso:

Ti verranno dati due input, il costo di una carta e un elenco di terre.

Il costo della carta può essere una stringa o una tupla contenente un numero e una stringa per la parte colorata. Se non c'è una parte generica, puoi riempire la stringa / tupla con uno 0.

L'elenco delle terre sarà un elenco di stringhe in cui ognuna è ciò che una determinata terra può produrre. Questo elenco può essere vuoto (non hai terre). Puoi anche prenderlo come un elenco di ints usando la logica della maschera di bit ma, se lo fai, pubblica il tuo schema. L'ordine dipende anche da te se è importante, altrimenti verrà assunto in WUBRGordine.

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

Produzione:

Un truthyvalore se riesci a pagare con successo il costo dato alle tue terre e un falseyvalore se non puoi.

Regole:

• Ti verrà garantito un input valido
• Si presume che Mana sia sempre nell'ordine "WUBRG". Se vuoi un ordine diverso, dichiaralo nella tua risposta.
• I colori saranno sempre raggruppati nel costo, ad esempio "WWUBBRG"
• Input utilizzerà tutte le lettere maiuscole o tutte minuscole, a scelta.
• Dovresti essere in grado di gestire regex 127[WUBRG]{127}e 254 terre.
• Scappatoie standard vietate
• Questo è code-golf , la risposta più breve per lingua vince

Esempi:

"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 byte

Accetta input come (cost)(lands):

• $cost$ è un elenco di caratteri in BGRUWordine, preceduto dalla parte generica, anche quando è$0$
• $lands$ è un elenco di stringhe.

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

Provalo online!

Commentate

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 byte

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*

Provalo online!

Retina , 60 byte

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

Provalo online! Il link include casi di test. Spiegazione:

\d+
*

Converti il ​​mana generico in unario. Questo usa ripetute _s.

1,L`.*

Abbina tutte le righe dopo la prima, ovvero l'elenco delle terre. (Normalmente questo corrisponderebbe di nuovo alla fine dell'input, ma il lookbehind lo impedisce.)

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

Cattura il numero di riga con 1 indice in $#1.

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

Sostituisci ogni terra con una regex che cattura i costi corrispondenti a quella terra o ai costi generici, ma solo una volta.

|'|

Unisci le regex risultanti con |s.

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

Avvolgi la regex ^(e )*\n(non riesco a inserire un ¶qui).

~

Conta il numero di corrispondenze di quella regex sul valore corrente.

Esempio: nel caso del 1BB¶WB¶WB¶WGregex generato è:

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

che _BB¶WB¶WB¶WGcorrisponde come richiesto.

Gelatina , 21 byte

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

Provalo online!

Uscite

Il formato di input è ciò che rende davvero difficile questo per Jelly. Perché Ṫe Ḣmodificare l'array, dobbiamo usare ©e ®in aggiunta. Con 3 ingressi separati questo sarebbe 18 byte . (Anche se sono sicuro che ci sia una soluzione di circa 14 byte in attesa di essere pubblicata da una delle menti di Jelly.)

Pyth , 25 byte

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

Provalo online!

Se Pyth avesse una funzione "prodotto cartesiano dell'array" come quella di Jelly Œp, ciò batterebbe facilmente la mia soluzione Jelly. Attualmente è fatto da usM*GHQ]k.

Perl 6 , 56 46 byte

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

Provalo online!

Funzione al curry. Accetta input come (@lands)($generic_cost, $colored_costs)con uno 0 esplicito per il costo generico. L'idea di base è quella di introdurre un nuovo simbolo che 1rappresenta il mana generico e utilizzare Perl 6 Borse (multiset) per verificare se è possibile ottenere il mana richiesto dalle terre.

Spiegazione

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

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)

Provalo online!

Facciamo affidamento sul fatto che tutti i colori saranno indicati nello stesso ordine nel costo e nella lista dei terreni. Per prima cosa tocchiamo le terre dando il mana colorato richiesto e poi controlliamo che abbiamo ancora terre sufficienti per pagare il costo incolore.