^{Для большего MtG-добра: Магия: Сражение со способностями}

Предпосылка:

В Magic: the Gathering вы разыгрываете заклинания, оплачивая их мановую стоимость, нажимая земли на требуемое количество. Эти земли могут производить один из пяти цветов:

• Белый (W)
• Синий (U)
• Черный (B)
• Красный (R)
• Зеленый (G)

Стоимость состоит из двух частей: числа, которое является общим требованием к мане, и серии символов, представляющих цветное требование к мане. Число представляет собой общую стоимость маны и может использовать любой цвет маны для ее удовлетворения, например, (3)может быть оплачено WGG. Символы являются требованием 1: 1 определенного цвета. Например WWUBR, потребуется 2 белых маны, 1 синий, 1 черный и 1 красный. Общая часть всегда будет стоять перед цветной частью. Как напоминание, (0)это действительная стоимость и должна быть обработана.

Вы можете иметь расходы, которые являются полностью общими, или полностью окрашенными, или и тем, и другим. Например, следующая карта стоит 4 ББ и оплачивается 4-мя цветными маны любого цвета и 2-мя черными маны:

Земли в этом испытании будут приносить одну ману. Тем не менее, мы рассмотрим земли, которые могут давать несколько цветов, но при этом приносить только 1 ману. Например, Gбудет производиться зеленая мана, WGможет быть 1 белый или 1 зеленый.

Входные данные:

Вам будет предоставлено два ввода, стоимость карты и список земель.

Стоимость карты может быть либо строкой, либо кортежем, содержащим число и строку для цветной части. Если нет общей части, вы можете дополнить строку / кортеж 0.

Список земель будет списком строк, каждая из которых - это то, что может произвести данная земля. Этот список может быть пустым (у вас нет земель). Вы также можете принять это как список целых, используя логику битовой маски, но опубликуйте свою схему, если вы это сделаете. Заказ также зависит от вас, если это имеет значение, в противном случае он будет принят в WUBRGпорядке.

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

Вывод:

truthyЗначение , если вы можете успешно оплатить стоимость данной ваши земель и falseyзначение , если вы не можете.

Правила:

• Вам будет гарантирован действительный ввод
• Предполагается, что мана всегда будет в порядке "WUBRG". Если вы хотите другой порядок, укажите это в своем ответе.
• Цвета всегда будут сгруппированы в стоимости, например, "WWUBBRG"
• Ввод будет использовать либо все заглавные или строчные, на ваш выбор.
• Вы должны быть в состоянии справиться с регулярным выражением 127[WUBRG]{127}и 254 землями.
• Стандартные лазейки запрещены
• Это Код-гольф, самый короткий ответ на язык выигрывает

Примеры:

"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 байт

Принимает вход как (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)))

Попробуйте онлайн!

комментарии

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 байт

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*

Попробуйте онлайн!

Сетчатка , 60 байт

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

Попробуйте онлайн! Ссылка включает в себя тестовые случаи. Объяснение:

\d+
*

Преобразовать общую ману в унарную. Это использует повторный _с.

1,L`.*

Сопоставьте все строки после первой, то есть список земель. (Обычно это снова совпадает в самом конце ввода, но заглядывание предотвращает это.)

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

Захватить номер строки с 1 индексом в $#1.

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

Замените каждую землю регулярным выражением, которое отражает стоимость, соответствующую этой земле или общей стоимости, но только один раз.

|'|

Соедините полученные регулярные выражения с |s.

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

Оберните регулярное выражение ^(и )*\n(я не могу вставить ¶здесь).

~

Посчитайте количество совпадений этого регулярного выражения на текущем значении.

Пример: для случая 1BB¶WB¶WB¶WGсгенерированного регулярного выражения:

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

который _BB¶WB¶WB¶WGсоответствует как требуется.

Желе , 21 байт

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

Попробуйте онлайн!

Выходы

Формат ввода - это то, что действительно усложняет Jelly. Потому что Ṫи Ḣмодифицировать массив нам нужно ©и ®в дополнение. С 3 отдельными входами это будет 18 байтов . (Хотя я уверен, что 14 или около того байтовое решение ожидает публикации одного из вдохновителей Jelly.)

Pyth , 25 байт

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

Попробуйте онлайн!

Если бы у Пайта была функция «декартово произведение массива», как у желе Œp, это легко превзошло бы мое решение с желе. В настоящее время это сделано usM*GHQ]k.

Perl 6 , 56 46 байт

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

Попробуйте онлайн!

Функция карри. Принимает ввод как (@lands)($generic_cost, $colored_costs)с явным 0 для общей стоимости. Основная идея состоит в том, чтобы ввести новый символ, 1представляющий общую ману, и использовать Perl 6 Bags (multisets), чтобы проверить, можно ли получить требуемую ману из земель.

объяснение

{ ... }  # 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 байта

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)

Попробуйте онлайн!

Мы рассчитываем на то, что все цвета будут приведены в одинаковом порядке в стоимости и в списке земель. Сначала мы стучим по землям, получая требуемую цветную ману, а после этого просто проверяем, что у нас еще есть достаточно земель для оплаты бесцветной стоимости.