¿Cuál es la forma más corta de ver si una entrada es un wordiniano usando algún lenguaje de programación?

Un wordiniano es una palabra que contiene palabras de longitud 1 a la longitud de la palabra original. Por ejemplo,

compartimiento

'I' es una palabra
'en' es una palabra
'bin' es una palabra

O,

etapa

'a' es una palabra
'ta' es una palabra ( sí, lo es )
'edad' es una palabra
'ciervo' es una palabra
'etapa' es una palabra

Entrada

Su código debe tomar una palabra y un diccionario como entradas, en cualquier formato razonable.

Salida

La salida debe ser un valor para indicar verdadero o falso, para decirnos si la palabra es un wordiniano.

Para más información sobre wordinians haga clic aquí .

Aquí hay una lista de palabras que usaré como entradas y subpalabras. Además, en respuesta a @xnor, debe contener subpalabras de cada longitud, no una cadena de subpalabras. Tenga en cuenta que solo se utilizará una palabra como entrada.

Pyth, 20 16 15 13 11 bytes

¡Gracias a Leaky Nun por guardar 4 bytes! Desafortunadamente, cambié todo el método después, pero igual ayudó.

gl{lM}#zQlz

Espera entrada como diccionario seguido de palabra. Salidas Verdadero o Falso.

Pruébalo aquí!

Explicación:

        lz   Collects the length of the word  input
g             and compares it to:
 l             The length of the following:
     # Q        Select all words from the dictionary that
    } z         are contained within the input word.
  lM            Map them to their respective lengths, and
 {              then remove any duplicates.

Esto no funciona si la cadena vacía ""es una palabra válida.

Python, 52 bytes

lambda w,d:len({len(x)for x in d if x in w})==len(w)

Una función anónima que toma una palabra wy un diccionario d. Toma las palabras dque son subcadenas de w, hace un conjunto de sus longitudes y luego comprueba que haya tantas longitudes distintas como letras w.

Python 3, 108 bytes

lambda w,d,r=range:all(any(i in d for i in j)for j in[[w[i:i+s]for i in r(len(w)+1-s)]for s in r(1,len(w))])

Una función anónima que toma la entrada, a través del argumento, de una palabra wcomo una cadena y un diccionario dcomo una lista de cadenas y retornos Trueo False.

Cómo funciona

El primer paso es una comprensión de la lista que genera una lista de listas de todas las subcadenas wexcluyentes w, agrupadas por longitud. Por ejemplo, para 'stage', [['s', 't', 'a', 'g', 'e'], ['st', 'ta', 'ag', 'ge'], ['sta', 'tag', 'age'], ['stag', 'tage']]se genera la lista . Esto se logra haciendo un bucle sobre todos los índices de inicio válidos ipara cada longitud de subcadena s, y cortando cada subcadena de longitud susando w[i:i+s]. Para cada lista de esta lista, se verifica la presencia de cada subcadena en el diccionario; llamar anydevuelve un hit si se encuentra al menos una coincidencia para una longitud determinada. Finalmente, la llamada allverifica si se ha encontrado una coincidencia para todas las longitudes de las subcadenas y se devuelve el resultado.

Pruébalo en Ideone

Ruby, 44 bytes

• ¡7 bytes fuera gracias a @NotThatCharles y sus trucos de operador!
• 2 bytes de descuento gracias a @Jordan con el truco del operador de navegación segura Ruby 2.3 w[x]&.size:)

->w,d{[*1..w.size]-d.map{|x|w[x]&.size}==[]}

Es una función anónima que toma una palabra wy un diccionario (conjunto de palabras) d. Crea dos matrices: la primera que contiene los números 1 hasta e incluyendo la longitud de w; La segunda matriz es dcon cada palabra asignada a su tamaño si son una subcadena de w, de lo contrario nil. Luego establece la substracción para verificar si la segunda matriz contiene todos los elementos de la primera matriz.

PowerShell v3 + v2 +, 127 110 70 65 bytes

param($a,$d)($d|?{$a-match$_}|select length -U).count-eq$a.length

(Ahora veo que mi enfoque es similar al de @ xnor, aunque lo desarrollé independientemente)

Toma la palabra de entrada $ay el diccionario $d, esperando $dcomo una matriz (ver ejemplos a continuación). Recorre la totalidad $dy realiza una Where-Objectpara extraer las entradas donde la palabra actual $_es una expresión regular -matchcontra la palabra de entrada $a(es decir, es la palabra actual una subcadena de la palabra de entrada).

Recopilamos todas esas palabras de subcadena y las canalizamos Select-Objecten el lengthparámetro y la -Urestricción nique. Eso extraerá las longitudes únicas de cada subcadena. Por ejemplo, para la palabra de entrada comb, esta será una matriz de (4,2)for ('comb','om').

Tomamos la .countmatriz resultante y la comparamos con la palabra de entrada .length. Si es igual a, eso significa que cada longitud de subcadena está en el diccionario, entonces $TRUE, de lo contrario, nos falta al menos uno, entonces $FALSE. Ese valor booleano se deja en la tubería y la salida es implícita.

NB: esto debería funcionar en v2 +, ya que el -inoperador ya no está presente, pero no he probado esa versión.

Ejemplos

PS C:\Tools\Scripts\golfing> .\is-it-a-wordinian.ps1 'stage' (gc .\words.txt)
True

PS C:\Tools\Scripts\golfing> .\is-it-a-wordinian.ps1 'metal' (gc .\words.txt)
True

PS C:\Tools\Scripts\golfing> .\is-it-a-wordinian.ps1 'comb' (gc .\words.txt)
False

Perl, 86 bytes

Requiere -Esin costo adicional.

chop(($s,@d)=<>);for$=(1..($x=length$s)){$-+=!!grep$s=~/$_/,grep$===y///c,@d}say$-==$x

Acepta todas las entradas a través de STDIN. La primera entrada es la palabra objetivo, el resto de la entrada es el diccionario. Huellas dactilares1 en caso de éxito, cadena vacía en caso de error.

Uso

perl -E 'chomp(($s,@d)=<>);for$=(1..($x=length$s)){$-+=!!grep$s=~/$_/,grep$===y///c,@d}say$-==$x' <<< 'stage
a
ta
age
stag
stage'
1
perl -E 'chomp(($s,@d)=<>);for$=(1..($x=length$s)){$-+=!!grep$s=~/$_/,grep$===y///c,@d}say$-==$x' <<< 'stage
a
at
age
stag
stage'

perl -E 'chomp(($s,@d)=<>);for$=(1..($x=length$s)){$-+=!!grep$s=~/$_/,grep$===y///c,@d}say$-==$x' <<< 'bin
i
in
bin'
1

Mathematica, 90 bytes

Sort[MemberQ[DictionaryWordQ/@StringPartition[#,t,1],True]~Table~{t,StringLength@#}][[1]]&

Utiliza los componentes incorporados de MathematicaDictionaryWordQ .

Tomar la entrada dcomo diccionario es 5 bytes más corto, pero mucho más lento para listas largas:

m=MemberQ;Sort[m[d~m~#&/@StringPartition[#,t,1],True]~Table~{t,StringLength@#}][[1]]&

MATL , 15 bytes

1 byte guardado usando una idea de la respuesta de @ xnor .

XXgc32>!suz1Gn=

Salidas 1o 0para veracidad o falsedad.

Pruébalo en línea!

XX      % Take the two inputs implicitly. Apply the second as a regex into the
        % first. Since the second input is a cell array, each of its contents is
        % applied separately as a regex. So for each dictionary word ("sub-word") 
        % this outputs the sub-word if found in the original word, or else an 
        % empty array. Gives a cell array of cells of strings
g       % Remove one level of nestedness
c       % Convert to char. This concatenates all found sub-words as rows of a 2D 
        % char array, padding with spaces as needed
32>!s   % For each row, count how many non-space characters there are. This is 
        % the length of each sub-word
uz      % Number of distinct non-zero elements
1Gn     % Push length of the original word
=       % Are they equal? Implicitly display

Perl, 42 41 bytes

Incluye +2 para -p0

Dar palabra seguida por el diccionario en STDIN:

(echo stage; cat dictionary.txt) | ./wordinian.pl

(Cuando pruebe en Unix, asegúrese de que dictionary.txt use \ncomo terminador de línea, no\r\n )

wordinian.pl:

#!/usr/bin/perl -p0
s%\G.%!/^.*(.{$+[0]})\H*
\1
/%eg;$_=!//

JavaScript (Firefox 30-57), 68 bytes

(w,a)=>new Set((for(x of a)if(~w.search(x))x.length)).size==w.length

El uso de un generador de comprensión evita crear una matriz intermedia. Versión de 73 bytes ES6:

(w,a)=>new Set(a.filter(x=>~w.search(x)).map(x=>x.length)).size==w.length

05AB1E , 8 bytes

ŒÃ€gZLåP

Word como primera entrada, lista de diccionario como segunda entrada.

Pruébelo en línea o verifique algunos casos de prueba más .

Explicación:

Π        # Get all possible substrings of the (implicit) input-string
 Ã        # Only keep the ones which are also in the (implicit) dictionary-list
  €g      # Get the length of each remaining string
    Z     # Push the maximum length (without popping the list)
     L    # Pop and push a list in the range [1, maximum-length]
      å   # Check for each value if it's in the list of lengths
       P  # And check if this is truthy for all
          # (then output the result implicitly as result)

Kotlin , 51 bytes

{w,d->w.indices.all{w.windowed(it+1).any{it in d}}}

Pruébalo en línea!

SQF , 147 bytes

Usando el formato de función como archivo:

params["w","d"];a=[];c=count w;for"i"from 1 to c do{a=a+[""];for"j"from 0 to c-i do{q=w select[j,i];if(q in d)then{a set[i-1,q]}}};c==count(a-[""])

Llamar como: ["WORD", DICTIONARY] call NAME_OF_COMPILED_FUNCTION

Sin golf:

//name parameters
params["w", "d"];
a = []; c = count w;
//for each length of subword
for "i" from 1 to c do {
    //add entry to the `a`
    a = a + [""];
    //for each starting position for that length
    for "j" from 0 to c - i do {
        //get subword
        q = w select [j, i];
        //check if in dictionary
        if(q in d) then {
            //set the entry to the wubword
            a set [i - 1, q]
        }
    }
};
//check if length of word is equal to number of subwords
c == count (a - [""])