I dadi con le lettere sono comuni nei giochi di parole. Ad esempio, può essere divertente provare a pronunciare parole divertenti con i dadi boggle. Se prendi una manciata di dadi, è probabile che non sarai in grado di scrivere alcune parole. Questa sfida è una generalizzazione di quell'idea.

Sfida

Dato un elenco di dadi che hanno almeno 1 faccia e una parola, il tuo compito è determinare se è possibile sillabare quella parola usando i dadi indicati (nel qual caso, dovrebbe restituire un risultato veritiero). È possibile utilizzare solo una lettera per ogni dado e un dado può essere utilizzato una sola volta. Non è necessario utilizzare tutti i dadi indicati.

Esempi

In un esempio banale, con i dadi [[A], [C], [T]] e la stringa CAT, il risultato è vero. Le BAT, ovviamente, restituirebbero false poiché non ci sono dadi con B su di esse

Se dato [[A, E, I, O, U], [A, B, C, T], [N, P, R]] come set di dadi, torneresti vero per ART, TON e CUR , ma falso per CAT, EAT e PAN perché quelle stringhe richiedono il riutilizzo dei dadi. Dovrebbe anche essere abbastanza ovvio che CRAB non può essere scritto con questi dadi poiché non ci sono abbastanza dadi.

Se viene dato [[A, B, C], [A, E, I], [E, O, U], [L, N, R, S, T]] come set di dadi, si sarebbe in grado di scrivi CAT, BEE, BEAN, TEA, BEET e BAN, ma non potresti scrivere LONE, CAB, BAIL, TAIL, BAA o TON

Potrebbero esserci multipli dello stesso dado. Se indicato [[A, B, C], [A, B, C], [A, B, C]], si sarebbe in grado di scrivere CAB, BAA, AAA, ecc ... ma ovviamente nulla senza A, B o C in esso.

Regole

• Nessuna lacuna standard di sfruttamento
• Questo è code-golf , quindi vince il codice più corto.
• Puoi presumere che parole e dadi saranno composti solo da lettere maiuscole.
• Puoi presumere che la parola sarà sempre lunga almeno 1 lettera e che ci sarà sempre almeno 1 dado.
• Puoi presumere che un dado non avrà mai più di una stessa lettera.
• L'input e l'output possono essere in qualsiasi formato conveniente.

Brachylog , 5 byte

∋ᵐ⊇pc

Provalo online!

Usiamo la variabile di input per i dadi e la variabile di output per la parola. Emette true.quando è possibile scrivere la parola e in false.altro modo.

Spiegazione

∋ᵐ        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.).(\\)

Questa è una funzione anonima. Legato a qualche identificatore fpuò essere usato come f "ART" ["AEIOU", "ABCT", "NPR"], che produce True. Provalo online!

L'equivalente non privo di punti è

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

mapM idsu un elenco di elenchi utilizza l' Monadistanza di elenco e può essere vista come una scelta non deterministica . Quindi ad es . mapM id ["AB","123"]Rese ["A1","A2","A3","B1","B2","B3"].

Per ciascuna di queste combinazioni di dadi, controlliamo se la differenza (\\)della lista della parola data e la combinazione produce una lista vuota.

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

Provalo online!

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.

La catena di confronto w[0]in x>0<f(...)è equivalente a: w[0]in x e x>0 e 0<f(...) .

Il secondo è sempre vero ( str> int) e il terzo è equivalente f(...), quindi l'intera cosa è un modo più breve di scriverew[0]in x and f(...)

JavaScript (ES6), 74 byte

Fornisce input nella sintassi del curry (w)(a), dove w è la parola che stiamo cercando e a è un elenco di stringhe che descrivono i dadi. Restituisce 0 o 1 .

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

Provalo online!

Commentate

Trasformiamo ogni sotto-permutazione dei dadi in un modello di espressione regolare e li testiamo contro la parola target.

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

Buccia , 5 byte

~V`¦Π

Provalo online!

Restituisce un valore diverso da zero se è possibile scrivere la parola, zero altrimenti.

Spiegazione

~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 ha salvato 2 byte

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

Provalo online!

Ingresso:

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

Produzione:

0per una parola non convalidata. Qualsiasi numero intero positivo per una parola convalidata

Come?

Questa spiegazione esamina il codice in ordine di esecuzione, effettivamente da destra a sinistra per questo one-liner.

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

Provalo online!

Supponendo che ci siano abbastanza dadi

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

Provalo online!

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

Provalo online!

Gelatina ,  10  9 byte

-1 grazie a Erik the Outgolfer (usa wpiuttosto che ẇ@>. <)

Œ!Œp€Ẏw€Ṁ

Un collegamento diadico che accetta un elenco di elenchi di caratteri a sinistra (i dadi) e un elenco di caratteri a destra (la parola) che restituisce 1 se possibile e 0 in caso contrario.

Provalo online! Oppure vedi la suite di test .

Come?

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

Algoritmo più veloce (anche 9 byte):

Un collegamento diadico con lo stesso formato di input che restituisce numeri interi positivi (verità) quando possibile e 0 (falsi) in caso contrario.

Œ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="")

Provalo online!

-2 caratteri grazie a Giuseppe.

Pyth , 21 byte

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

Suite di test

.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