Harf zarları kelime oyunlarında yaygındır. Örneğin, boggle zarları ile komik kelimeler yazmayı denemek eğlenceli olabilir. Bir avuç zar alırsan, bazı kelimeleri heceleyemezsin. Bu zorluk, bu fikrin genelleştirilmesidir.

Meydan okuma

Her birinin en az 1 yüzü ve bir kelimesi olan bir zar listesi göz önüne alındığında, göreviniz verilen kelimeyi kullanarak bu kelimeyi hecelemenin mümkün olup olmadığını belirlemektir (bu durumda, doğru bir sonuç döndürmelidir). Her kalıptan yalnızca bir harf kullanılabilir ve bir kalıp yalnızca bir kez kullanılabilir. Verilen zarların hepsini kullanmanıza gerek yoktur.

Örnekler

Önemsiz bir örnekte, zar [[A], [C], [T]] ve CAT dizgisi ile sonuç doğrudur. BAT, elbette, B ile zar olmadığından yanlış dönecekti

Zar seti olarak [[A, E, I, O, U], [A, B, C, T], [N, P, R]] verilirse ART, TON ve CUR için true değerini döndürürsünüz , ancak CAT, EAT ve PAN için yanlıştır, çünkü bu dizeler zarın yeniden kullanılmasını gerektirir. Yeterince zar olmadığı için CRAB'nin bu zarlarla hecelenemeyeceği de oldukça açık olmalıdır.

Zar seti olarak [[A, B, C], [A, E, I], [E, O, U], [L, N, R, S, T]] verilirse, CAT, BEE, BEAN, BEA, BEET ve BAN'ı büyü, ancak LONE, CAB, BAIL, TAIL, BAA veya TON'u heceleyemezsin

Aynı kalıbın katları olabilir. [[A, B, C], [A, B, C], [A, B, C]] verilirse, CAB, BAA, AAA, vb. B veya C içinde.

kurallar

• Standart boşluklardan yararlanma yok
• Bu kod golf , bu yüzden en kısa kod kazanır.
• Hem kelimelerin hem de zarların sadece büyük harflerden oluşacağını varsayabilirsiniz.
• Sözcüğün her zaman en az 1 harf uzunluğunda ve her zaman en az 1 ölüme sahip olacağını varsayabilirsiniz.
• Bir kalıbın asla aynı mektubun birden fazlasına sahip olmayacağını varsayabilirsiniz.
• Giriş ve çıkış herhangi bir uygun biçimde olabilir.

Brachylog , 5 bayt

∋ᵐ⊇pc

Çevrimiçi deneyin!

Zar için girdi değişkenini ve kelime için çıktı değişkenini kullanıyoruz. true.Kelimeyi hecelemek mümkün olduğunda çıktı ve false.başka türlü.

açıklama

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

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

Bu anonim bir işlevdir. Bazı tanımlayıcılara fbağlı olarak kullanılabilir f "ART" ["AEIOU", "ABCT", "NPR"], bu da verir True. Çevrimiçi deneyin!

Noktasız olmayan eşdeğer

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

mapM idbir liste üzerinde liste Monadörneğini kullanır ve deterministik olmayan bir seçenek olarak görülebilir . Böylece örneğin mapM id ["AB","123"]verim ["A1","A2","A3","B1","B2","B3"].

Bu zar kombinasyonlarının her biri için (\\), verilen kelimenin ve kombinasyonun liste farkının boş bir liste verip vermediğini kontrol ederiz .

JavaScript (ES6), 68 bayt

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 bayt

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

Çevrimiçi deneyin!

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.

Karşılaştırma zinciri w[0]in x>0<f(...)şuna eşittir: w[0]in x ve x>0 ve 0<f(...) .

Bunların ikincisi her zaman doğrudur ( str> int) ve bunların üçüncüsü eşdeğerdir f(...), böylece her şey yazmak için daha kısa bir yoldurw[0]in x and f(...)

JavaScript (ES6), 74 bayt

Curry sözdiziminde girdi alır (w)(a), burada w aradığımız kelimedir ve a zarları tanımlayan dizelerin bir listesidir. 0 veya 1 değerini döndürür .

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

Çevrimiçi deneyin!

Yorumlananlar

Zarların her bir alt küme permütasyonunu düzenli bir ifade modeline dönüştürüyor ve hedef kelimeye karşı test ediyoruz.

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

Kabuk , 5 bayt

~V`¦Π

Çevrimiçi deneyin!

Kelimeyi hecelemek mümkünse sıfırdan farklı bir değer, aksi halde sıfır değerini döndürür.

açıklama

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

@DomHastings 2 bayt kurtardı

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

Çevrimiçi deneyin!

Giriş:

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

Çıktı:

0doğrulanmamış bir kelime için. Doğrulanmış bir kelime için herhangi bir pozitif tam sayı

Nasıl?

Bu açıklama, koda, bu tek astar için etkili bir şekilde sağdan sola yürütme sırasına bakar.

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

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

Çevrimiçi deneyin!

Yeterli zar olduğunu varsayarsak

JavaScript (Node.js) , 100 bayt

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

Çevrimiçi deneyin!

JavaScript (Node.js) , 99 bayt

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

Çevrimiçi deneyin!

Jöle ,  10  9 bayt

-1 Outgolfer Erik sayesinde ( > wyerine ẇ@< kullanın . <)

Œ!Œp€Ẏw€Ṁ

Soldaki karakterlerin listesini (zar) ve sağdaki karakterlerin listesini (kelime), mümkünse 1, değilse 0 döndüren ikili bir bağlantı.

Çevrimiçi deneyin! Veya test takımına bakın .

Nasıl?

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

Daha hızlı algoritma (ayrıca 9 bayt):

Mümkün olduğunda pozitif tamsayı (doğruluk) ve aksi halde 0 (falsey) döndüren aynı giriş biçimine sahip ikili bir bağlantı.

Œ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 , 19218513517110116 bayt

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

Çevrimiçi deneyin!

Giuseppe sayesinde -2 karakter.

Pyth , 21 bayt

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

Test odası

.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