^{Untuk kebaikan MtG lainnya: Sihir: The Gathering Combat with Abilities}

Tempat:

Di Magic: the Gathering, Anda menggunakan mantra dengan membayar biaya mana dengan mengetuk tanah untuk jumlah yang diperlukan. Tanah ini dapat menghasilkan salah satu dari lima warna yaitu:

• Putih (w)
• Biru (u)
• Hitam (B)
• Merah (r)
• Hijau (g)

Biaya terdiri dari dua bagian: angka yang merupakan persyaratan mana generik, dan serangkaian simbol yang mewakili persyaratan mana berwarna. Angka tersebut adalah biaya mana generik dan dapat menggunakan warna mana saja untuk memenuhinya, misalnya (3)dapat dibayar dengan WGG. Simbol adalah persyaratan 1: 1 untuk warna tertentu. misalnya WWUBRakan membutuhkan 2 mana putih, 1 biru, 1 hitam dan 1 merah. Bagian Generik akan selalu datang sebelum bagian Berwarna. Sebagai pengingat, (0)adalah biaya yang valid dan harus ditangani.

Anda dapat memiliki biaya yang sepenuhnya generik, atau sepenuhnya berwarna, atau keduanya. Sebagai contoh, kartu berikut memiliki biaya 4BB dan dibayar dengan 4 mana pun berwarna dan 2 mana hitam:

Tanah di tantangan ini masing-masing akan menghasilkan satu mana. Namun, kami akan mempertimbangkan lahan yang dapat menghasilkan banyak warna tetapi masih hanya menghasilkan 1 mana. Misal Gakan menghasilkan mana hijau, WGbisa menghasilkan 1 putih atau 1 hijau.

Memasukkan:

Anda akan diberikan dua input, biaya kartu dan daftar tanah.

Biaya kartu dapat berupa string, atau tuple yang berisi angka dan string untuk bagian berwarna. Jika tidak ada bagian generik, Anda dapat mengisi string / tuple dengan 0.

Daftar tanah akan menjadi daftar string di mana masing-masing adalah apa yang dapat dihasilkan oleh tanah tertentu. Daftar ini dapat kosong (Anda tidak memiliki tanah). Anda juga dapat menganggap ini sebagai daftar int menggunakan bit-mask logic tetapi memposting skema Anda jika Anda melakukannya. Pesanan juga terserah Anda jika itu penting, jika tidak maka akan dianggap sesuai WUBRGpesanan.

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

Keluaran:

Sebuah truthynilai jika Anda berhasil dapat membayar biaya diberikan tanah Anda dan falseynilai jika Anda tidak bisa.

Aturan:

• Anda akan dijamin input yang valid
• Mana akan dianggap selalu dalam urutan "WUBRG". Jika Anda menginginkan urutan yang berbeda, nyatakan demikian dalam jawaban Anda.
• Warna akan selalu dikelompokkan dalam biaya, mis. "WWUBBRG"
• Input akan menggunakan semua huruf besar atau semua huruf kecil, pilihan Anda.
• Anda harus dapat menangani regex 127[WUBRG]{127}dan 254 tanah.
• Celah standar dilarang
• Ini adalah kode-golf , jawaban terpendek per menang bahasa

Contoh:

"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

Mengambil input sebagai (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)))

Cobalah online!

Berkomentar

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*

Cobalah online!

Retina , 60 byte

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

Cobalah online! Tautan termasuk kasus uji. Penjelasan:

\d+
*

Ubah mana generik menjadi unary. Ini menggunakan _s berulang .

1,L`.*

Cocokkan semua baris setelah yang pertama, yaitu daftar tanah. (Ini biasanya akan cocok lagi di akhir input, tetapi tampilan di belakang mencegah hal itu.)

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

Tangkap nomor baris 1-diindeks di $#1.

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

Ganti setiap tanah dengan regex yang menangkap biaya yang cocok dengan tanah itu atau biaya generik, tetapi hanya sekali.

|'|

Bergabunglah dengan regex yang dihasilkan dengan |s.

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

Bungkus regex ^(dan )*\n(sepertinya saya tidak bisa memasukkan di ¶sini).

~

Hitung jumlah kecocokan dari regex itu pada nilai saat ini.

Contoh: Untuk kasus 1BB¶WB¶WB¶WGregex yang dihasilkan adalah:

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

yang _BB¶WB¶WB¶WGcocok seperti yang dipersyaratkan.

Jelly , 21 byte

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

Cobalah online!

Keluaran

Format input inilah yang benar-benar membuat ini sulit untuk Jelly. Karena Ṫdan Ḣmemodifikasi array, kita perlu menggunakan ©dan ®sebagai tambahan. Dengan 3 input terpisah ini akan menjadi 18 byte . (Meskipun saya yakin ada 14 atau lebih solusi byte menunggu untuk diposting oleh salah satu dalang Jelly.)

Pyth , 25 byte

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

Cobalah online!

Jika Pyth memiliki "Cartesian product of array" berfungsi seperti Jelly Œp, ini akan dengan mudah mengalahkan solusi Jelly saya. Saat ini yang dilakukan oleh usM*GHQ]k.

Perl 6 , 56 46 byte

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

Cobalah online!

Fungsi kari. Mengambil input seperti (@lands)($generic_cost, $colored_costs)dengan 0 eksplisit untuk biaya generik. Ide dasarnya adalah untuk memperkenalkan simbol baru yang 1mewakili mana generik dan menggunakan Perl 6 Bags (multiset) untuk memeriksa apakah mungkin untuk mendapatkan mana yang diperlukan dari tanah.

Penjelasan

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

Cobalah online!

Kami mengandalkan kenyataan bahwa semua warna akan diberikan dalam urutan yang sama dalam biaya dan dalam daftar tanah. Pertama-tama kita mengetuk tanah untuk memberikan mana berwarna yang diperlukan dan setelah itu hanya memeriksa bahwa kita masih memiliki cukup tanah untuk membayar biaya tidak berwarna.