字母骰子在文字游戏中很常见。例如，尝试用骰子拼写有趣的单词可能会很有趣。如果您抓一把骰子，则可能无法拼写某些单词。这个挑战是对这一想法的概括。

挑战

给定一个骰子列表，每个骰子至少具有一张面孔和一个单词，您的任务是确定是否可以使用给定的骰子对该单词进行拼写（在这种情况下，它应该返回真实的结果）。每个骰子只能使用一个字母，每个骰子只能使用一次。您不需要使用所有给定的骰子。

例子

在一个简单的示例中，使用骰子[[A]，[C]，[T]]和字符串CAT，结果为true。BAT当然会返回false，因为上面没有骰子

如果给定[[A，E，I，O，U]，[A，B，C，T]，[N，P，R]]作为骰子集合，则对于ART，TON和CUR将返回true ，但对于CAT，EAT和PAN则为false，因为这些字符串需要重用骰子。还应该很明显，因为没有足够的骰子，所以不能用这些骰子拼写CRAB。

如果给定[[A，B，C]，[A，E，I]，[E，O，U]，[L，N，R，S，T]]作为骰子集合，则可以拼写CAT，BEE，BEAN，TEA，BEET和BAN，但您将无法拼写LONE，CAB，BAIL，TAIL，BAA或TON

同一骰子可能有多个。如果给定[[A，B，C]，[A，B，C]，[A，B，C]]，您将可以拼写CAB，BAA，AAA等...但是显然没有A的话， B，或C在其中。

规则

• 没有利用标准漏洞
• 这是代码高尔夫，因此最短的代码获胜。
• 您可能会假设单词和骰子都只能由大写字母组成。
• 您可能会假设该单词的长度始终至少为1个字母，并且始终会有至少1个骰子。
• 您可能会认为骰子永远不会有多个相同的字母。
• 输入和输出可以采用任何方便的格式。

Brachylog，5个字节

∋ᵐ⊇pc

在线尝试！

我们将输入变量用于骰子，将输出变量用于单词。true.当可能拼写单词或false.其他单词时，它将输出。

说明

∋ᵐ        Map element: Take one side from each die
  ⊇       Subset
   p      Permute
    c     Concatenate into a string: will only succeed if it results in the output word

Haskell，48 44字节

import Data.List
(.mapM id).any.(null.).(\\)

这是一个匿名函数。绑定到某些标识符f可以用作f "ART" ["AEIOU", "ABCT", "NPR"]，从而产生True。在线尝试！

非点数等效为

f word dice = any(\s -> null $ word\\s) $ mapM id dice

mapM id列表的上方使用list的Monad实例，可以看作是不确定的选择。因此，例如mapM id ["AB","123"]产量["A1","A2","A3","B1","B2","B3"]。

对于每个骰子组合，我们检查(\\)给定单词和组合的列表差异是否产生空列表。

JavaScript（ES6），68个字节

f=([c,...w],a)=>!c||a.some((d,i)=>d.match(c)&&f(w,a.filter(_=>i--)))

<div oninput=o.textContent=f(i.value,d.value.split`\n`)>
<textarea id=d rows=9>
ABC
AEI
EOU
LNRST
</textarea>
<br>
<input id=i value=BEAN>
<pre id=o>true

Python 2，82字节

f=lambda d,w:w==''or any(w[0]in x>0<f(d[:i]+d[i+1:],w[1:])for i,x in enumerate(d))

在线尝试！

f=lambda d,w:w==''                                                                 # Base case: we can spell '' with any dice.
                  or any(                                 for i,x in enumerate(d)) # Otherwise, we check if there is some die x such that...
                         w[0]in x                                                  # the first letter is on this die,
                                 >0<                                               # and
                                    f(d[:i]+d[i+1:],w[1:])                         # we can spell the rest of the word with the rest of the dice.

比较链w[0]in x>0<f(...)等效于：w[0]in x 和 x>0 和 0<f(...)。

其中的第二个始终为true（str> int），其中的第三个等同于f(...)，因此整个事情是一种较短的编写方式w[0]in x and f(...)

JavaScript（ES6），74个字节

以currying语法输入(w)(a)，其中w是我们要寻找的词，a是描述骰子的字符串列表。返回0或1。

w=>P=(a,m='')=>w.match(m)==w|a.some((w,i)=>P(a.filter(_=>i--),m+`[${w}]`))

在线尝试！

已评论

我们将骰子的每个子集排列转换为正则表达式模式，并针对目标单词进行测试。

w =>                        // w = target word
  P =                       // P = recursive function taking:
    (a,                     //   a[] = list of dice
        m = '') =>          //   m   = search pattern
    w.match(m) == w |       // force a truthy result if w matches m
    a.some((w, i) =>        // for each word w at position i in a[]:
      P(                    //   do a recursive call:
        a.filter(_ => i--), //     using a copy of a[] without the current element
        m + `[${w}]`        //     and adding '[w]' to the search pattern
      )                     //   end of recursive call
    )                       // end of some()

外壳，5个字节

~V`¦Π

在线尝试！

如果可以拼写单词，则返回非零值，否则返回零。

说明

~V`¦Π  Arguments: word [Char], dice [[Char]]
 V     Checks if any element of a list (2) satisfies a predicate (1)
~      Composes both arguments of the above function
  `¦     (1) Is the word a subset of the element?
    Π    (2) Cartesian product of the dice list

Perl 5中 -plF，48 46个字节

@DomHastings保存了2个字节

$_=grep/@{[sort@F]}/,map"@{[sort/./g]}",glob<>

在线尝试！

输入：

word               # The word to validate
{A,B,C}{D,E,F}     # Each die is surrounded by braces, commas between the letters

输出：

0对于未经验证的单词。已验证单词的任何正整数

怎么样？

该说明按执行顺序查看代码，对于该单行代码，从右到左有效。

-F             # The first line of input is automatically split by the -F command option into the @F array.
glob<>         # Read the rest of the input and enumerate all of the permutations of it
map"@{[sort/./g]}",  # Split the permutation into separate letters, sort them and put them back together
/@{[sort@F]}/, # use the sorted letters of the target to match against
$_=grep        # check all of those permutations to see if the desired word is in them
-p             # Command line option to output the contents of $_ at the end

JavaScript（Node.js），98字节

f=(s,d,u=[])=>d<1?s.every(t=>u.pop().match(t)):d.some((x,i)=>f(s,e=[...d],[...u,x],e.splice(i,1)))

在线尝试！

假设有足够的骰子

JavaScript（Node.js），100字节

f=(s,d,u=[''])=>d<1?s.every(t=>u.pop().match(t)):d.some((x,i)=>f(s,e=[...d],[...u,x],e.splice(i,1)))

在线尝试！

JavaScript（Node.js），99字节

s=>f=(d,u=[''])=>d<1?s.every(t=>u.pop().match(t)):d.some((x,i)=>f(e=[...d],[...u,x],e.splice(i,1)))

在线尝试！

果冻， 10  9 字节

-1感谢Outgolfer的Erik（使用w而不是ẇ@>。<）

Œ!Œp€Ẏw€Ṁ

双向链接，其左侧接受一个字符列表（骰子），右侧接受一个字符列表（单词），如果可能，则返回1，否则返回0。

在线尝试！或查看测试套件。

怎么样？

Œ!Œp€Ẏw€Ẹ - Link: list of lists of characters Dice, list of characters Word
Œ!        - all permutations of the dice (i.e. all ways to order the dice)
  Œp€     - Cartesian product of €ach (i.e. all ways to roll each ordering)
     Ẏ    - tighten (i.e. all ordered ways to roll the dice)
       €  - for each:
      w   -   first index (of sublist W) in the result (positive if there, 0 otherwise)
        Ẹ - any truthy? (1 if it is possible to roll the word, 0 otherwise)

更快的算法（也是9个字节）：

具有相同输入格式的二元链接，如果可能，则返回正整数（真），否则返回0（假）。

Œpf€Ṣ€ċṢ} - Link: list of lists of characters Dice, list of characters Word
Œp        - Cartesian product of the dice (all rolls of the dice)
  f€      - filter keep for €ach (keep the rolled letters if they are in the word)
    Ṣ€    - sort €ach result
       Ṣ} - sort Word
      ċ   - count occurrences

R，192185135117111109字节

function(x,...)s(x)%in%apply(expand.grid(lapply(list(...),c,"")),1,s)
s=function(x)paste(sort(x),collapse="")

在线尝试！

-2个字符，感谢Giuseppe。

Pyth，21个字节

.Em}eQdsm.ps.nd.U*bZh

测试套件

.Em}eQdsm.ps.nd.U*bZhQ # Code with implicit variables
.E                     # Print whether any of
       sm.ps  d        # all positive length permutations of each element in
        m   .nd.U*bZhQ # the Cartesian product of the list of dice
  m}eQd                # contain the target word