ลูกเต๋าตัวอักษรเป็นเรื่องธรรมดาในเกมคำศัพท์ มันเป็นเรื่องสนุกที่จะลองสะกดคำตลกด้วยลูกเต๋าเกรงกลัว หากคุณหยิบลูกเต๋าสักหนึ่งโอกาสคุณจะไม่สามารถสะกดคำบางคำได้ ความท้าทายนี้เป็นภาพรวมของแนวคิดนั้น

ท้าทาย

เมื่อระบุรายชื่อของลูกเต๋าที่แต่ละคนมีอย่างน้อย 1 หน้าและหนึ่งคำงานของคุณคือการพิจารณาว่าเป็นไปได้หรือไม่ที่จะสะกดคำนั้นโดยใช้ลูกเต๋าที่ระบุ (ในกรณีนี้ควรส่งคืนผลลัพธ์จริง) สามารถใช้ตัวอักษรจากแต่ละตัวได้เพียงตัวเดียวและสามารถใช้ตัวอักษรได้เพียงครั้งเดียวเท่านั้น คุณไม่จำเป็นต้องใช้ลูกเต๋าที่ให้มาทั้งหมด

ตัวอย่าง

ในตัวอย่างเล็ก ๆ น้อย ๆ กับลูกเต๋า [[A], [C], [T]] และสตริง CAT ผลลัพธ์จะเป็นจริง แน่นอนว่าค้างคาวจะกลับมาผิดเนื่องจากไม่มีลูกเต๋าในตัว B

หากได้รับ [[A, E, I, O, U], [A, B, C, T], [N, P, R]] เป็นชุดของลูกเต๋าคุณจะกลับมาจริงสำหรับ ART, TON และ CUR แต่เป็นเท็จสำหรับ CAT, EAT และ PAN เนื่องจากสตริงเหล่านั้นจำเป็นต้องใช้ลูกเต๋าซ้ำ มันควรจะค่อนข้างชัดเจนว่า 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, BIL หรือ 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เหนือรายการลิสต์จะใช้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(...)

ที่สองของเหล่านั้นเป็นจริงเสมอ ( 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()

Husk , 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 ต้องขอบคุณ Erik the Outgolfer (ใช้งานwมากกว่าẇ@>. <)

Œ!Œp€Ẏw€Ṁ

ลิงก์ dyadic ยอมรับรายการของอักขระทางด้านซ้าย (ลูกเต๋า) และรายการอักขระทางด้านขวา (คำ) ที่ส่งคืน 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 ไบต์):

ลิงก์ dyadic ที่มีรูปแบบอินพุตเดียวกันซึ่งส่งคืนจำนวนเต็มบวก (ความจริง) เมื่อเป็นไปได้และ 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 , 192 185 135 117 111 109 ไบต์

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

ลองออนไลน์!

-2 chars ขอบคุณ 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