문자 주사위는 단어 게임에서 일반적입니다. 예를 들어, boggle 주사위로 재미있는 단어를 철자하는 것이 재미있을 수 있습니다. 소수의 주사위를 잡으면 특정 단어의 철자를 쓸 수 없을 가능성이 있습니다. 이 도전은 그 아이디어의 일반화입니다.

도전

얼굴과 단어가 각각 1 개 이상인 주사위 목록이 주어지면 주어진 주사위를 사용하여 해당 단어의 철자를 사용할 수 있는지 여부를 결정해야합니다 (이 경우 진실한 결과를 반환해야 함). 각 주사위에서 한 글자 만 사용할 수 있으며 주사위는 한 번만 사용할 수 있습니다. 주어진 주사위를 모두 사용할 필요는 없습니다.

예

간단한 예에서, 주사위 [[A], [C], [T]]와 문자열 CAT를 사용하면 결과는 참입니다. 물론 BAT는 B와 주사위가 없기 때문에 거짓을 반환합니다.

주사위 세트로 [[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.

규칙

• 악용 표준 허점 없음
• 이것은 code-golf 이므로 가장 짧은 코드가 승리합니다.
• 단어와 주사위 모두 대문자로만 구성되어 있다고 가정 할 수 있습니다.
• 단어의 길이는 항상 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

하스켈 , 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"].

각 주사위 조합 (\\)에 대해 주어진 단어와 조합 의 목록 차이 가 빈 목록을 생성 하는지 확인 합니다.

자바 스크립트 (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

파이썬 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(...)

자바 스크립트 (ES6), 74 바이트

카레 구문으로 입력을받습니다 (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`¦Π

온라인으로 사용해보십시오!

단어의 철자를 입력 할 수 있으면 0이 아닌 값을 반환하고, 그렇지 않으면 0을 반환합니다.

설명

~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

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

온라인으로 사용해보십시오!

주사위가 충분하다고 가정하면

자바 스크립트 (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 바이트

Outgolfer Erik 덕분에 -1 ( >. < 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 (거짓)을 반환하는 동일한 입력 형식을 가진 2 진 링크.

Œ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 , 119285135117111109 바이트

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

온라인으로 사용해보십시오!

주세페 덕분에 -2 문자.

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