Thư xúc xắc là phổ biến trong các trò chơi chữ. Chẳng hạn, có thể rất vui khi thử đánh vần những từ hài hước bằng xúc xắc boggle. Nếu bạn nắm được một ít xí ngầu, rất có thể bạn sẽ không thể đánh vần được một số từ nhất định. Thách thức này là một khái quát của ý tưởng đó.

Thử thách

Đưa ra một danh sách súc sắc mà mỗi con có ít nhất 1 mặt và một từ, nhiệm vụ của bạn là xác định xem có thể đánh vần từ đó bằng cách sử dụng xúc xắc đã cho hay không (trong trường hợp đó, nó sẽ trả về kết quả trung thực). Chỉ một chữ cái từ mỗi súc sắc có thể được sử dụng và một súc sắc chỉ có thể được sử dụng một lần. Bạn không cần phải sử dụng tất cả các viên xí ngầu nhất định.

Ví dụ

Trong một ví dụ tầm thường, với xúc xắc [[A], [C], [T]] và chuỗi CAT, kết quả là đúng. BAT, tất nhiên, sẽ trả về false vì không có xúc xắc với B trên chúng

Nếu được đặt [[A, E, I, O, U], [A, B, C, T], [N, P, R]] dưới dạng bộ xúc xắc, bạn sẽ trả về true cho ART, TON và CUR , nhưng sai cho CAT, ĂN và PAN vì các chuỗi đó yêu cầu tái sử dụng xúc xắc. Một điều khá rõ ràng là CRAB không thể được đánh vần bằng những con xúc xắc này vì không có đủ xúc xắc.

Nếu được [[A, B, C], [A, E, I], [E, O, U], [L, N, R, S, T]] là bộ xúc xắc, bạn sẽ có thể đánh vần CAT, BEE, BEAN, TEA, BEET và BAN, nhưng bạn sẽ không thể đánh vần Lone, CAB, BAIL, TAIL, BAA hoặc TON

Có thể có bội số của cùng một chết. Nếu được đưa ra [[A, B, C], [A, B, C], [A, B, C]], bạn sẽ có thể đánh vần CAB, BAA, AAA, v.v ... nhưng rõ ràng không có gì nếu không có A, B, hoặc C trong đó.

Quy tắc

• Không khai thác sơ hở tiêu chuẩn
• Đây là mã golf , vì vậy mã ngắn nhất sẽ thắng.
• Bạn có thể cho rằng cả từ và súc sắc sẽ chỉ được tạo thành từ chữ in hoa.
• Bạn có thể cho rằng từ đó sẽ luôn dài ít nhất 1 chữ cái và sẽ luôn có ít nhất 1 chữ cái chết.
• Bạn có thể cho rằng một người chết sẽ không bao giờ có nhiều hơn một chữ cái giống nhau.
• Đầu vào và đầu ra có thể ở bất kỳ định dạng thuận tiện.

Brachylog , 5 byte

∋ᵐ⊇pc

Hãy thử trực tuyến!

Chúng tôi sử dụng biến đầu vào cho súc sắc và biến đầu ra cho từ. Nó xuất ra true.khi có thể đánh vần từ này và mặt false.khác.

Giải trình

∋ᵐ        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 byte

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

Đây là một chức năng ẩn danh. Giới hạn cho một số định danh fnó có thể được sử dụng như f "ART" ["AEIOU", "ABCT", "NPR"], mang lại True. Hãy thử trực tuyến!

Tương đương không có điểm là

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

mapM idtrên một danh sách các danh sách sử dụng Monadthể hiện của danh sách và có thể được coi là sự lựa chọn không xác định . Như vậy, ví dụ mapM id ["AB","123"]năng suất ["A1","A2","A3","B1","B2","B3"].

Đối với mỗi kết hợp xúc xắc đó, chúng tôi kiểm tra xem sự khác biệt danh sách (\\)của từ đã cho và kết hợp có mang lại một danh sách trống không.

JavaScript (ES6), 68 byte

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 byte

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

Hãy thử trực tuyến!

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.

Chuỗi so sánh w[0]in x>0<f(...)tương đương với: w[0]in x và x>0 và 0<f(...) .

Thứ hai trong số đó luôn luôn đúng ( str> int) và thứ ba trong số đó là tương đương f(...), do đó toàn bộ là một cách viết ngắn hơnw[0]in x and f(...)

JavaScript (ES6), 74 byte

Đưa đầu vào theo cú pháp currying (w)(a), trong đó w là từ chúng ta đang tìm kiếm và a là danh sách các chuỗi mô tả xúc xắc. Trả về 0 hoặc 1 .

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

Hãy thử trực tuyến!

Đã bình luận

Chúng tôi biến mỗi tập hợp con hoán vị của con xúc xắc thành một mẫu biểu thức chính quy và kiểm tra chúng dựa vào từ đích.

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

Husk , 5 byte

~V`¦Π

Hãy thử trực tuyến!

Trả về giá trị khác không nếu có thể đánh vần từ đó, bằng không.

Giải trình

~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 byte

@DomHastings đã lưu 2 byte

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

Hãy thử trực tuyến!

Đầu vào:

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

Đầu ra:

0cho một từ không được xác nhận. Bất kỳ số nguyên dương nào cho một từ được xác thực

Làm sao?

Giải thích này xem xét mã theo thứ tự thực hiện, có hiệu quả từ phải sang trái cho lớp lót này.

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

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

Hãy thử trực tuyến!

Giả sử có đủ súc sắc

JavaScript (Node.js) , 100 byte

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

Hãy thử trực tuyến!

JavaScript (Node.js) , 99 byte

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

Hãy thử trực tuyến!

Thạch ,  10  9 byte

-1 nhờ Erik the Outgolfer (sử dụng wchứ không phải ẇ@>. <)

Œ!Œp€Ẏw€Ṁ

Một liên kết dyadic chấp nhận một danh sách các danh sách các ký tự ở bên trái (súc sắc) và một danh sách các ký tự ở bên phải (từ) trả về 1 nếu có thể và 0 nếu không.

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm .

Làm sao?

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

Thuật toán nhanh hơn (cũng 9 byte):

Một liên kết dyadic với cùng định dạng đầu vào sẽ trả về số nguyên dương (trung thực) khi có thể và 0 (falsey) nếu không.

Œ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 , 192 185 135 117 111 109 byte

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

Hãy thử trực tuyến!

-2 ký tự nhờ Giuseppe.

Bình thường , 21 byte

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

Bộ kiểm tra

.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