^{Pour plus de bonté MtG: Magic: The Gathering Combat with Abilities}

Prémisse:

Dans Magic: the Gathering, vous lancez des sorts en payant leur coût de mana en engageant des terrains pour le montant requis. Ces terres peuvent produire l'une des cinq couleurs qui sont:

• Blanc (W)
• Bleu (U)
• Noir (B)
• Rouge (R)
• Vert (G)

Le coût est composé de deux parties: un nombre qui correspond à l'exigence de mana générique et une série de symboles représentant l'exigence de mana coloré. Le nombre est le coût de mana générique et peut utiliser n'importe quelle couleur de mana pour le satisfaire, par exemple (3)peut être payé avec WGG. Les symboles sont une exigence 1: 1 d'une couleur spécifique. Par exemple, WWUBRil faudrait 2 manas blancs, 1 bleu, 1 noir et 1 rouge. La partie générique précédera toujours la partie colorée. Pour rappel, (0)est un coût valable et doit être traité.

Vous pouvez avoir des coûts entièrement génériques, entièrement colorés ou les deux. Par exemple, la carte suivante a un coût de 4BB et est payée avec 4 mana de n'importe quelle couleur et 2 mana noir:

Les terrains de ce défi produiront chacun un mana. Cependant, nous considérerons les terrains qui peuvent produire plusieurs couleurs mais qui ne donnent toujours qu'un mana. Par exemple G, produira un mana vert, WGpeut produire 1 blanc ou 1 vert.

Contribution:

Vous recevrez deux entrées, le coût d'une carte et une liste de terrains.

Le coût de la carte peut être soit une chaîne, soit un tuple contenant un nombre et une chaîne pour la partie colorée. S'il n'y a pas de partie générique, vous pouvez remplir la chaîne / tuple avec un 0.

La liste des terres sera une liste de chaînes où chacune correspond à ce qu'une terre donnée peut produire. Cette liste peut être vide (vous n'avez pas de terrain). Vous pouvez également prendre cela comme une liste d'entiers utilisant une logique de masque de bits, mais publier votre schéma si vous le faites. L'ordre dépend également de vous si cela est important, sinon il sera supposé dans l' WUBRGordre.

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

Production:

Une truthyvaleur si vous pouvez payer avec succès le coût étant donné vos terres et une falseyvaleur si vous ne le pouvez pas.

Règles:

• Vous aurez la garantie d'une entrée valide
• Le mana sera supposé être toujours dans l'ordre "WUBRG". Si vous souhaitez un ordre différent, indiquez-le dans votre réponse.
• Les couleurs seront toujours regroupées dans le coût, par exemple "WWUBBRG"
• L'entrée utilisera tout en majuscules ou en minuscules, selon votre choix.
• Vous devriez être capable de gérer des regex 127[WUBRG]{127}et 254 terrains.
• Failles standard interdites
• Ceci est le code-golf , la réponse la plus courte par langue gagne

Exemples:

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

Prend l'entrée comme (cost)(lands):

• $cost$ est une liste de caractères dans l' ordre, précédée de la partie générique, même lorsqu'elle est0BGRUW$0$
• $lands$ est une liste de chaînes.

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

Essayez-le en ligne!

Commenté

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 octets

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*

Essayez-le en ligne!

Rétine , 60 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

\d+
*

Convertissez le mana générique en unaire. Cela utilise l' _art.

1,L`.*

Faites correspondre toutes les lignes après la première, c'est-à-dire la liste des terrains. (Cela correspondrait normalement à la toute fin de l'entrée, mais le lookbehind empêche cela.)

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

Capturez le numéro de ligne indexé 1 dans $#1.

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

Remplacez chaque terrain par une expression régulière qui capture les coûts correspondant à ce terrain ou aux coûts génériques, mais une seule fois.

|'|

Joignez les expressions rationnelles résultantes avec |s.

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

Enveloppez le regex ^(et )*\n(je n'arrive pas à insérer un ¶ici).

~

Comptez le nombre de correspondances de cette expression régulière sur la valeur actuelle.

Exemple: Pour le cas de 1BB¶WB¶WB¶WGl'expression régulière générée est:

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

qui _BB¶WB¶WB¶WGcorrespond au besoin.

Gelée , 21 octets

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

Essayez-le en ligne!

Les sorties

Le format d'entrée est ce qui rend vraiment cela difficile pour Jelly. Parce que Ṫet Ḣmodifier le tableau, nous devons utiliser ©et ®en plus. Avec 3 entrées séparées, ce serait 18 octets . (Bien que je suis sûr qu'il y a une solution d'environ 14 octets qui attend d'être publiée par l'un des cerveaux de Jelly.)

Pyth , 25 octets

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

Essayez-le en ligne!

Si Pyth avait une fonction "produit cartésien de tableau" comme celle de Jelly Œp, cela battrait facilement ma solution Jelly. Actuellement, cela se fait par usM*GHQ]k.

Perl 6 , 56 46 octets

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

Essayez-le en ligne!

Fonction curry. Prend l'entrée comme (@lands)($generic_cost, $colored_costs)avec un 0 explicite pour le coût générique. L'idée de base est d'introduire un nouveau symbole 1représentant le mana générique et d'utiliser des sacs Perl 6 (multisets) pour vérifier s'il est possible d'obtenir le mana requis des terrains.

Explication

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

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)

Essayez-le en ligne!

Nous comptons sur le fait que toutes les couleurs seront données dans le même ordre dans le coût et dans la liste foncière. D'abord, nous exploitons les terrains donnant le mana coloré requis et après cela vérifions simplement que nous avons encore suffisamment de terrains pour payer le coût incolore.