¿Es un wordiniano?


20

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


@FryAmTheEggman No puedo poner un diccionario completo aquí. ¿Qué pasa si hay alguna palabra que existe?
Jacques Marais

66
Recomiendo pasar un diccionario como entrada. De esa manera, es fácil encontrar casos de prueba (ya que puedes hacer tu propio diccionario pequeño)
Nathan Merrill

2
¿Simplemente tiene que contener subpalabras de cada longitud, o tienen que ser una cadena donde cada subparta agrega una letra a la anterior?
xnor

@FryAmTheEggman Edité mi pregunta para proporcionar una lista de todas las palabras.
Jacques Marais

1
@JacquesMarais el concepto es tomar una palabra y un diccionario, y volver verdadero si la palabra es una palabra (según el diccionario)
Nathan Merrill

Respuestas:


4

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.


1
.Epuede ser reemplazado cons
Leaky Nun

1
m}kHpuede ser reemplazado con}RH
Leaky Nun

1
Solo te daría el código de golf
Leaky Nun

11

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.


Ugh, acabo de escribir exactamente lo mismo, excepto que tenía W en lugar de x y [en lugar de {. +1
Daniel

@Dopapp No funcionaría si lo usaras en [lugar de {. {...}es un conjunto de comprensión (igual que set([...])).
mbomb007

@ mbomb007, oh cierto, se necesitaría un set
Daniel

@xnor Perdón por no seleccionar esta respuesta, pero como es un código de golf, tengo que seleccionar el más corto ...
Jacques Marais

4

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


4

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.


1
Con el "operador de navegación segura" en Ruby 2.3 puede guardar un par de bytes: en w[x]&.size==ilugar de x.size==i&&w[x].
Jordania

Oh wow, gracias @ Jordan. No lo sabía, increíble :)
daniero

1
usted puede ahorrar unos pocos bytes en su función anónima (y tal vez el programa completo) por dejar caer la uniqy -[p], y utilizando el conjunto de la resta en su lugar:[*1..w.size]-d.map{...}==[]
No es que Charles

@NotthatCharles ¡Eso es genial! Gracias :)
daniero

3

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

2

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

2

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]]&

2

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

1

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;$_=!//

1

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

1

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)


0

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 - [""])
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.