^{Więcej dobroci MtG: Magic: The Gathering Combat with Abilities}

Przesłanka:

W Magic: the Gathering rzucasz zaklęcia, płacąc koszt many, dotykając ziem o wymaganą ilość. Te ziemie mogą wytwarzać jeden z pięciu kolorów, które są:

• Biały (W)
• Niebieski (U)
• Czarny (B)
• Czerwony (R)
• Zielony (G)

Koszt składa się z dwóch części: liczby, która jest ogólnym zapotrzebowaniem na manę, oraz szeregu symboli reprezentujących kolorowe zapotrzebowanie na manę. Liczba jest ogólnym kosztem many i może go użyć w dowolnym kolorze many, np. (3)Można go zapłacić WGG. Symbole są wymaganiem 1: 1 określonego koloru. np. WWUBRwymagałoby 2 białej many, 1 niebieskiej, 1 czarnej i 1 czerwonej. Część ogólna zawsze pojawi się przed częścią kolorową. Przypominamy, że (0)jest to ważny koszt i należy się nim posługiwać.

Możesz mieć koszty, które są całkowicie ogólne, całkowicie kolorowe lub oba jednocześnie. Na przykład, następująca karta ma koszt 4BB i jest wypłacana za 4 dowolne kolorowe punkty many i 2 czarne punkty many:

Ziemie w tym wyzwaniu wytworzą po jednej many. Rozważymy jednak ziemie, które mogą wytwarzać wiele kolorów, ale nadal dają tylko 1 many. Np. GWytworzy zieloną manę, WGmoże wyprodukować 1 białą lub 1 zieloną.

Wejście:

Otrzymasz dwa wejścia, koszt karty i listę ziem.

Kosztem karty może być sznurek lub krotka zawierająca liczbę i sznurek dla kolorowej części. Jeśli nie ma części ogólnej, możesz uzupełnić ciąg / krotkę wartością 0.

Lista gruntów będzie listą ciągów, z których każdy jest tym, co może wyprodukować dany kraj. Ta lista może być pusta (nie masz ziem). Możesz również potraktować to jako listę ints za pomocą logiki bit-mask, ale jeśli to zrobisz, opublikuj swój schemat. Kolejność zależy również od Ciebie, jeśli ma to znaczenie, w przeciwnym razie zostanie przyjęta w WUBRGkolejności.

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

Wynik:

truthyJakość, jeśli można z powodzeniem pokryć koszty podane wasze ziemie i falseywartości, jeśli nie można.

Zasady:

• Będziesz mieć zagwarantowane prawidłowe dane wejściowe
• Zakłada się, że man będzie zawsze w kolejności „WUBRG”. Jeśli chcesz innego zamówienia, podaj to w swojej odpowiedzi.
• Kolory zawsze będą grupowane według kosztu, np. „WWUBBRG”
• Dane wejściowe będą używać wszystkich wielkich lub wszystkich małych liter do wyboru.
• Powinieneś być w stanie obsłużyć wyrażenia regularne 127[WUBRG]{127}i 254 ziem.
• Standardowe luki zabronione
• To jest golf-golfwygrywa najkrótsza odpowiedź na język

Przykłady:

"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 bajtów

Pobiera dane wejściowe jako (cost)(lands):

• $cost$ to lista znaków w BGRUWkolejności, poprzedzona częścią ogólną, nawet jeśli jest to$0$
• $lands$ to lista ciągów znaków.

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

Wypróbuj online!

Skomentował

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 bajtów

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*

Wypróbuj online!

Siatkówka , 60 bajtów

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

Wypróbuj online! Link zawiera przypadki testowe. Wyjaśnienie:

\d+
*

Przekształć ogólną manę w unary. Wykorzystuje to powtarzane _s.

1,L`.*

Dopasuj wszystkie linie po pierwszej, tj. Listę ziem. (Zwykle pasowałoby to ponownie na samym końcu danych wejściowych, ale lookbehind temu zapobiega).

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

Zrób 1-indeksowany numer linii w $#1.

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

Zastąp każdy kraj wyrażeniem regularnym, które rejestruje koszty odpowiadające temu gruntowi lub koszty ogólne, ale tylko raz.

|'|

Połącz powstałe wyrażenia regularne z |s.

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

Zawiń wyrażenie regularne ^(i )*\n(wydaje się, że nie mogę wstawić ¶tutaj).

~

Policz liczbę dopasowań tego wyrażenia regularnego na bieżącej wartości.

Przykład: w przypadku 1BB¶WB¶WB¶WGwygenerowanego wyrażenia regularnego jest:

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

który _BB¶WB¶WB¶WGpasuje zgodnie z wymaganiami.

Galaretka , 21 bajtów

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

Wypróbuj online!

Wyjścia

Format wejściowy jest tym, co naprawdę utrudnia Galaretkę. Ponieważ Ṫi Ḣmodyfikujemy tablicę, musimy użyć ©i ®dodatkowo. Przy 3 osobnych wejściach byłoby to 18 bajtów . (Chociaż jestem pewien, że około 14 bajtów czeka na przesłanie przez jednego z głównych mózgów galaretki).

Pyth , 25 bajtów

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

Wypróbuj online!

Gdyby Pyth miał funkcję „kartezjańskiego produktu tablicowego” taką jak Jelly Œp, to z łatwością pobiłoby moje rozwiązanie Jelly. Obecnie robi to usM*GHQ]k.

Perl 6 , 56 46 bajtów

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

Wypróbuj online!

Funkcja curry. Pobiera dane wejściowe jak (@lands)($generic_cost, $colored_costs)z jawnym 0 dla kosztów ogólnych. Podstawową ideą jest wprowadzenie nowego symbolu 1reprezentującego ogólną manę i użycie Perl 6 Torby (multisets), aby sprawdzić, czy możliwe jest uzyskanie wymaganej many z lądów.

Wyjaśnienie

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

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)

Wypróbuj online!

Polegamy na tym, że wszystkie kolory zostaną podane w tej samej kolejności w kosztach i na liście gruntów. Najpierw stukamy ziemie, dając wymaganą kolorową manę, a następnie sprawdzamy, czy nadal mamy wystarczająco dużo ziem, aby zapłacić bezbarwny koszt.