Você pode soletrar esta palavra com esses dados?

20

Dados de letras são comuns em jogos de palavras. Pode ser divertido tentar soletrar palavras engraçadas com dados espantosos, por exemplo. Se você pegar um punhado de dados, é provável que não consiga soletrar certas palavras. Esse desafio é uma generalização dessa ideia.

Desafio

Dada uma lista de dados em que cada um tem pelo menos 1 face e uma palavra, sua tarefa é determinar se é possível soletrar essa palavra usando os dados fornecidos (nesse caso, ele deve retornar um resultado verdadeiro). Apenas uma letra de cada dado pode ser usada e um dado pode ser usado apenas uma vez. Você não precisa usar todos os dados dados.

Exemplos

Em um exemplo trivial, com os dados [[A], [C], [T]] e a string CAT, o resultado é verdadeiro. É claro que o BAT retornaria falso, pois não há dados com B neles

Se dado [[A, E, I, O, U], [A, B, C, T], [N, P, R]] como o conjunto de dados, você retornaria verdadeiro para ART, TON e CUR , mas falso para CAT, EAT e PAN, porque essas cadeias requerem reutilização de dados. Também deve ser bastante óbvio que o CRAB não pode ser escrito com esses dados, pois não há dados suficientes.

Se dado [[A, B, C], [A, E, I], [E, O, U], [L, N, R, S, T]] como o conjunto de dados, você poderá soletrar CAT, ABELHA, FEIJÃO, CHÁ, BETERRABA e BAN, mas você não seria capaz de soletrar LONE, CAB, BAIL, TAIL, BAA ou TON

Pode haver múltiplos do mesmo dado. Se dado [[A, B, C], [A, B, C], [A, B, C]], você seria capaz de escrever CAB, BAA, AAA, etc ... mas obviamente nada sem A, B ou C nele.

Regras

  • Nenhuma exploração de brechas padrão
  • Isso é , então o código mais curto vence.
  • Você pode assumir que palavras e dados serão compostos apenas por letras maiúsculas.
  • Você pode assumir que a palavra sempre terá pelo menos uma letra e que sempre haverá pelo menos 1 dado.
  • Você pode assumir que um dado nunca terá mais do que uma da mesma letra.
  • A entrada e a saída podem estar em qualquer formato conveniente.
Beefster
fonte
Por que fazer novas tags?
User202729
Pode-se pegar uma lista (vetor) de caracteres como entrada (formato semelhante a um dado)? Pedindo um amigo que gostaria de salvar 27 bytes.
JayCe
1
@JayCe "A entrada e a saída podem estar em qualquer formato conveniente", então sim.
Beefster

Respostas:

12

Braquilog , 5 bytes

∋ᵐ⊇pc

Experimente online!

Usamos a variável de entrada para os dados e a variável de saída para a palavra. É emitido true.quando é possível soletrar a palavra e de false.outra forma.

Explicação

∋ᵐ        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
Fatalizar
fonte
8

Haskell , 48 44 bytes

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

Esta é uma função anônima. Vinculado a algum identificador, fele pode ser usado como f "ART" ["AEIOU", "ABCT", "NPR"], o que produz True. Experimente online!

O equivalente não isento de pontos é

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

mapM idsobre uma lista de listas usa a Monadinstância da lista e pode ser visto como uma escolha não determinística . Assim, por exemplo, mapM id ["AB","123"]produz ["A1","A2","A3","B1","B2","B3"].

Para cada uma dessas combinações de dados, verificamos se a diferença (\\)de lista da palavra especificada e a combinação produz uma lista vazia.

Laikoni
fonte
@LuisMendo Obrigado por apontar! Corrigido alternando para outro método que acabava salvando 4 bytes.
Laikoni
6

JavaScript (ES6), 68 bytes

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

Neil
fonte
1
@RickHitchcock Falha em EEE.
Neil
6

Python 2 , 82 bytes

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

Experimente 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.

A cadeia de comparação w[0]in x>0<f(...)é equivalente a: w[0]in x e x>0 e 0<f(...) .

O segundo deles é sempre verdadeiro ( str> int) e o terceiro deles é equivalente a f(...), de modo que a coisa toda é uma maneira mais curta de escreverw[0]in x and f(...)

Lynn
fonte
5

JavaScript (ES6), 74 bytes

É introduzido na sintaxe de curry (w)(a), onde w é a palavra que procuramos e a é uma lista de strings que descrevem os dados. Retorna 0 ou 1 .

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

Experimente online!

Comentado

Transformamos cada subconjunto de permutação dos dados em um padrão de expressão regular e os testamos contra a palavra-alvo.

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()
Arnauld
fonte
3

Casca , 5 bytes

~V`¦Π

Experimente online!

Retorna um valor diferente de zero se for possível soletrar a palavra; caso contrário, zero.

Explicação

~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
Fyr
fonte
2

Perl 5 -plF , 48 46 bytes

@DomHastings salvou 2 bytes

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

Experimente online!

Entrada:

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

Saída:

0para uma palavra que não é validada. Qualquer número inteiro positivo para uma palavra que é validada

Quão?

Esta explicação analisa o código na ordem de execução, efetivamente da direita para a esquerda para esse 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
Xcali
fonte
1

JavaScript (Node.js) , 98 bytes

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

Experimente online!

Supondo que haja dados suficientes

JavaScript (Node.js) , 100 bytes

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

Experimente online!

JavaScript (Node.js) , 99 bytes

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

Experimente online!

l4m2
fonte
1

Geléia ,  10  9 bytes

-1 graças a Erik the Outgolfer (use em wvez de ẇ@>. <)

Œ!Œp€Ẏw€Ṁ

Um link diádico que aceita uma lista de listas de caracteres à esquerda (os dados) e uma lista de caracteres à direita (a palavra) que retorna 1, se possível, e 0, se não.

Experimente online! Ou veja a suíte de testes .

Quão?

Œ!Œ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 mais rápido (também 9 bytes):

Um link diádico com o mesmo formato de entrada que retorna inteiro positivo (verdade) quando possível e 0 (falsey) caso contrário.

Œ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
Jonathan Allan
fonte
1

R , 192 185 135 117 111 109 bytes

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

Experimente online!

-2 caracteres graças a Giuseppe.

JayCe
fonte
Isso falhará se uma palavra tiver menos letras do que você possui dados.
Giuseppe
Eu acho que você pode salvá-lo com o custo de 21 bytes, experimentá-lo aqui
Giuseppe
@ Giuseppe Você salvou o dia!
JayCe
você não precisa doF=
Giuseppe
0

Pitão , 21 bytes

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

Suíte de teste

Explicação:
.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
hakr14
fonte