¿Es un sustantivo o no?

22

Dada una cadena como entrada, determine si es un sustantivo o no.

Se te puntuará en las 1000 palabras más comunes en inglés, según la cantidad que etiquetes correctamente como sustantivo o no.

Ganará el programa o función que clasifique correctamente la mayoría de esas palabras en 50 bytes o menos.

Sustantivos

Un sustantivo es una palabra que representa una cosa, típicamente. Se vuelve más complejo, pero esa es la idea básica.

En los casos en que una palabra puede ser un sustantivo o alguna otra parte del discurso, la clasifiqué como un sustantivo, incluso si es un uso poco frecuente. O, de hecho, dejo que este sitio lo haga por mí.

Las palabras en las que se le calificará son estas 1000 palabras comunes , que son de Wikipedia simple , con "dos" y "una vez" agregados. De esos, estos son los 586 sustantivos , y estos son los 414 no sustantivos . Puedes encontrar las tres listas aquí . Tenga en cuenta que todas estas entradas están en minúsculas. Estas listas son finales; no intente discutir la gramática.

Su programa se considerará correcto si genera un resultado verdadero en una entrada que es un sustantivo, y un resultado falso en una entrada que no es un sustantivo.

Sutilezas:

Los programas deben tener una salida determinista. Si quieres usar la aleatoriedad, siembra. Los programas no pueden usar listas de nombres integradas u otras funciones integradas de parte del discurso.

Ejemplos:

a: noun
act: noun
active: noun
about: non-noun
above: non-noun
across: non-noun

Indique cuál es la tasa de éxito de su programa en su respuesta. El programa o función de como máximo 50 bytes con la mayor tasa de éxito gana. En caso de empate, el conteo de bytes más bajo determinará un ganador. ¡Buena suerte!

code-challenge decision-problem natural-language test-battery isaacg
fuente

Respuestas:

13

JavaScript (ES6), 43 bytes, 622 630 633

Solo para que la pelota ruede. Devuelve 1para sustantivos, 0para no sustantivos.

s=>2552>>s.length&/^[bcdf-mp-tvwy]/.test(s)

¿Cómo?

Apostamos por el sustantivo si se cumplen las dos condiciones siguientes:

  1. La longitud de la palabra es 3, 4, 5, 6, 7, 8 u 11. Esto se hace desplazando a la derecha el número binario 100111111000 (2552 como decimal).
  2. La palabra comienza con una de estas letras: bcdfghijklmpqrstvwy
Arnauld
fuente
Justo cuando estaba a punto de comentar, con JS específicamente en mente, que el límite de bytes era demasiado restrictivo, ¡publican esto! Estaba pensando, sin haber mirado la lista, que un puntaje mejor que 586 podría ser posible probando la primera letra o 2 en cada palabra. Bien hecho :)
Shaggy
Una explicación sería buena para personas menos familiarizadas con Javascript. Por lo que puedo decir, ¿esto verifica si la longitud de la palabra es 3, 4, 5, 6, 7, 8 u 11, y la palabra también comienza con una de un conjunto de letras?
isaacg
@isaacg Eso es correcto. Explicación agregada.
Arnauld
44
Tenga en cuenta que la clase de caracteres [bcdf-mp-tvwy]es equivalente a la clase [^aenouxz]. Un cambio ahorraría 4 bytes, que podrían capitalizarse.
fireflame241
@ fireflame241 Muy cierto. Y eso incluso se puede acortar [^aenouz]porque no tenemos ninguna palabra que comience con a x.
Arnauld
11

Gelatina , 48 bytes, puntaje 731

Esta es mi primera respuesta en Jelly y tuve muchos problemas para armar esto. Ah bueno ... eso fue divertido. :-)

O‘ḅ⁹%⁽€Oæ»4“Ạ$ⱮẊḲḲLÑMṆụ⁻ẉṂ`ŻvḤæɠ5ṭȯƁU*×TdƲḥ`’æ»Ḃ

1 byte guardado gracias a @JonathanAllan

Pruébalo en línea!

Desglose y suites de prueba

  • No sustantivos correctamente identificados como no sustantivos: 265/414 (64%)
  • Sustantivos correctamente identificados como sustantivos: 466/586 (79.5%)

¿Cómo?

Primero calculamos un hash de la cadena de entrada por:

  • convirtiéndolo en un entero interpretando cada punto de código como un dígito de base 256
  • aplicando el módulo 4080 (elegido como el valor más eficiente con no más de 12 bits)
  • manteniendo los 8 bits más significativos del resultado

Esto nos deja con un índice en [0 ... 255] y así divide todas las palabras en 256 grupos.

Para cada grupo de palabras, precalculamos un indicador binario que es 1si el grupo contiene más sustantivos que no sustantivos, y de lo 0contrario. Esto conduce a un número N de 256 bits que vamos a utilizar como tabla de búsqueda. Lo almacenamos como una cadena codificada en base 250.

A continuación se muestra la representación binaria de N .

1000011000001011000101111011111001001101110010101101110010001101
0000010001101010010111110001110010010101110110110010111111010000
0001111010011110000110101011111000011110111011010011011110101100
1010010110101111000010101000101100000001110110100011111000101010

Que se puede almacenar como “Ạ$ⱮẊḲḲLÑMṆụ⁻ẉṂ`ŻvḤæɠ5ṭȯƁU*×TdƲḥ`’ en gelatina.

De ahí el código:

O‘ḅ⁹%⁽€Oæ»4“Ạ$ⱮẊḲḲLÑMṆụ⁻ẉṂ`ŻvḤæɠ5ṭȯƁU*×TdƲḥ`’æ»Ḃ    main link

O                                                   convert the input string to a list of
                                                    code points
 ‘                                                  increment each of them
  ḅ⁹                                                convert from base 256 to an integer
    %⁽€O                                            modulo 4080
        æ»4                                         drop the 4 least significant bits
           “Ạ$ⱮẊḲḲLÑMṆụ⁻ẉṂ`ŻvḤæɠ5ṭȯƁU*×TdƲḥ`’æ»     right shift N by this amount
                                               Ḃ    test the least significant bit
Arnauld
fuente
¡Buen trabajo! Guarde un byte para arrancar O‘ḅ⁹%⁽€Oæ»4“Ạ$ⱮẊḲḲLÑMṆụ⁻ẉṂ`ŻvḤæɠ5ṭȯƁU*×TdƲḥ`’æ»Ḃ(también tenga en cuenta que puede usar el pie de página en TIO, iría con Ç€¬S,Ly Ç€S,Lpara sus dos suites de prueba.
Jonathan Allan
@ JonathanAllan ¡Gracias por los consejos!
Arnauld
10

JavaScript (ES6), 50 bytes, puntuación 693

s=>!/^([aouz]|th|..$)|e.+[ey]|[flo].r|a.p/.test(s)

Simplemente buscando los posibles patrones que los no sustantivos tienen y los sustantivos no.

Los no sustantivos contienen más a menudo:

  1. a, o, u o z como la primera letra.
  2. th como las dos primeras letras.
  3. Solo dos letras. [Piense pronombres (yo, nosotros, nosotros, él, él) y preposiciones (de, a, en, en, por, en, arriba, ...).]
  4. e , seguido de una o más letras, seguido de e o y .
  5. f, l o o , seguido de cualquier letra, seguido de r .
  6. a , seguido de cualquier letra, seguido de p .

Retazo:

Mostrar fragmento de código

Rick Hitchcock
fuente
Creo que puede guardar un byte cambiando la primera expresión regular a /h|n/(o haciendo /^.[hn]/.test(s)), y otra cambiando s[2]>''a cualquiera !!s[2]o 2 in s.
ETHproductions
Gracias, @ETHproductions. Puedo usar sus sugerencias y combinar las dos pruebas para guardar un montón de bytes, lo que me permitió agregar código para mejorar mi puntaje.
Rick Hitchcock
¿No es a.predundante ya que ya lo tienes [aouz]?
AdmBorkBork
@AdmBorkBork, la a en [aouz]solo coincide cuando al principio de la cadena. Por alguna razón, las pruebas en a.p cualquier parte de la cadena mejoran la puntuación.
Rick Hitchcock
10

Gelatina , 50 bytes , puntaje 763

Usando un hash ahora (al igual que la respuesta de Arnauld's Jelly )

OP%⁽Wpị“!ḋGẠ⁻Ṭȥʋt|Ḥ\⁾°½İ@G2ḂƑ½ịʂ¶ɦḲ⁷³Hz~⁵p9)⁹ƙ¿’B¤

¡Pruébelo en línea!

250/414 para no sustantivos
513/586 para sustantivos
total = 250 + 513 = 763.

¿Cómo?

Crea una tabla con 308 entradas, ya sea 1 (que identifica un sustantivo) o 0 (que identifica un sustantivo) e indexa en ella utilizando una clave proporcionada por una función hash que utiliza el producto de los ordinales de la palabra de entrada:

OP%⁽Wpị“!ḋGẠ⁻Ṭȥʋt|Ḥ\⁾°½İ@G2ḂƑ½ịʂ¶ɦḲ⁷³Hz~⁵p9)⁹ƙ¿’B¤ - Link: list of characters, word
O                                                  - convert to ordinals
 P                                                 - product
   ⁽Wp                                             - base 250 number = 22863
  %                                                - modulo (by 22863)
                                                 ¤ - nilad plus link(s) as a nilad:
       “!ḋGẠ⁻Ṭȥʋt|Ḥ\⁾°½İ@G2ḂƑ½ịʂ¶ɦḲ⁷³Hz~⁵p9)⁹ƙ¿’   -   base 250 number
                                                B  -   as a binary list (308 bits)
      ị                                            - index into (1-indexed and modular,
                                                  -   so adds another modulo by 308)

Anterior:  50  47 bytes , puntuación 684

ḣ3Ẇf“QṘ°ḂżÐŒ#ḍæ09»s2¤Ȧ¬ȧØY⁾niyṖf⁽ż2ị$
0,-2ịE¬ȧÇ

Un enlace monádico que toma una palabra y devuelve una lista de un carácter (verdad) si la palabra se identifica como un sustantivo, o una lista vacía o cero (ambos falsey) si no lo es.

Pruébalo en línea! (el pie de página realiza un if if en el resultado para imprimirNounoNon-Noun)
... o ver el programa de puntuación (cuenta los índices de verdad en las dos listas y luego calcula la puntuación).

Desglose de la puntuación: 462/586 sustantivos identificados correctamente (124 incorrectos), 222/414 no sustantivos identificados correctamente (192 incorrectos) - total correcto = 684/1000.

¿Cómo?

Supongo que no es un sustantivo si ...

  • el último carácter y el carácter dos anteriores son iguales (con indexación modular y basada en 1)
  • cualquiera de las dos primeras subcadenas de longitud 2 están en:
    'be', 'th', 'le', 'he', 'm ', 'ev', 'et', 's ', 'fl', 'ax', 'en', 'fo', 'am', 'az' (nota: 'm 'y 's 'solo están aquí para facilitar la compresión, pero nunca aparecen de todos modos)
  • El -299 º índice (con 1 modular y basado en la indexación) es cualquiera de:
    aenouyz(aunque esto se implementa inversa y con letras mayúsculas en exceso)
    ... ya que las palabras tienen todas longitud entre 1 y 11 del -299 º índice es equivalente para usar la longitud para mapear el índice:{7:2; 8:5; 9:7; 11:9; else 1}

ḣ3Ẇf“QṘ°ḂżÐŒ#ḍæ09»s2¤Ȧ¬ȧØY⁾niyṖf⁽ż2ị$ - Link 1: list of characters, word
ḣ3                                    - head to index 3 (1st 3 characters, like 'abc')
  Ẇ                                   - all sublists (['a','b','c','ab','bc','abc']
                    ¤                 - nilad followed by link(s) as a nilad:
    “QṘ°ḂżÐŒ#ḍæ09»                    - compression of "bethlehem evets flaxenfoamaz"
                  s2                  - split into chunks of 2:
                                      -   be,th,le,he,m ,ev,et,s ,fl,ax,en,fo,am,az
   f                                  - filter keep (can only match 'ab' or 'bc')
                     Ȧ                - any and all (0 if empty, 1 if not)
                      ¬               - logical not
                        ØY            - consonant -y yield = "BCD...WXZbcd...wxz"
                          ⁾ni         - character pair = "ni" (no shrubbery for you!)
                             y        - translate (exchange the n for an i)
                              Ṗ       - pop (remove the z)
                       ȧ              - logical and
                                    $ - last two links as a monad:
                                ⁽ż2   -   base 250 literal = -299
                                   ị  -   index into the word
                               f      - filter keep

0,-2ịE¬ȧÇ - Main link: list of characters, word
0,-2      - pair zero with -2 = [0,-2]
    ị     - index into the word (last character and the one before the one before that)
     E    - all (both) equal?
      ¬   - logical not
        Ç - call the last link (1) as a monad
       ȧ  - logical and

13 bytes, puntuación: 638

Una primera fiesta rápida (extendida arriba)

ØY⁾niyṖf⁽ż2ị$
Jonathan Allan
fuente
0,-2no significa pair zero with -2que signifiqueliteral [0, -2]
Erik the Outgolfer
Pero es el mismo efecto: p
Jonathan Allan
no, no 0,-2es un nilad, no está separado (0)(,)(-2)... por supuesto, es el mismo efecto en este caso, pero no siempre. Aprendí eso de la manera difícil ... y cualquiera que sea el caso, preferiría explicar lo que realmente sucede en lugar de algo con el mismo efecto o algo.
Erik the Outgolfer
Si hubiera escrito "unirse" en lugar de "par", ¿habría comentado "ninguna unión es j"?
Jonathan Allan
Podría ser un poco pedante poco, pero pairo joinson obviamente maneras equivocadas a la frase, ya que 0,-2,-6, por ejemplo, no significa pair 0 with -2 and then pair that with -6 = [[0, -2], -6]sino que más bien medios literal [0, -2, -6]. Lo entiendo, el , átomo y el ...,...(,...(...)) literal son confusos ... pero aún así 0,-2,-6no es lo mismo 0,-2;-6ya que el primero es 1 enlace y el último es 3 enlaces.
Erik the Outgolfer
2

Julia 34bytes, 609

f(w)=hash(w)&0x0800000000004808>0

Quería ahorrar en caracteres usando el hash incorporado. Siento que debe haber una manera de hacerlo mejor. Julia simplemente no es lo suficientemente amigable con las operaciones de bit bitging que quiero usar para mejorar esto, creo.

Encontrar máscaras de bits adecuadas para que el hash las separe es un juego interesante.

Lyndon White
fuente
La mejor solución;)
tamasgal
2

Python 2 , 50 bytes, precisión: 596

lambda x:2<len(x)<7 or x[0]in"abcgmprs"or"st" in x

Pruébalo en línea!

Simplemente verifica la primera letra, la longitud y si "st" está en la palabra Code asume que la palabra se define como x (Editar: Gracias a issacg por arreglar el código del fragmento a la función)

Husnain Raza
fuente
Hola, bienvenido al sitio. Si bien esto es interesante, se requiere que las presentaciones sean funciones o programas completos. Este es un fragmento, que no está permitido. Ver esto ¡ Pruébelo en línea! enlace para una forma de convertir este fragmento en una función mientras se ejecuta el mismo código.
isaacg
2

Haskell, 36 bytes, 626 631

f x=length x>2&&x!!0`notElem`"aenou"
Alondra
fuente
643 si alguien tiene un idioma más corto:length x>2&&(x!!0`notElem`"aenou"||x!!1`elem`"acqrsty")
BlackCap
2

Implementación de puerta lógica de 2 niveles, no 50 bytes, puntaje 1000

  1. Simplemente conecte la representación binaria de la palabra dada a las 88 entradas

    1. complete la palabra de entrada por espacios a la derecha si la longitud de la palabra es menor que 11
    2. Código ASCII de 8 bits para cada letra de la palabra de entrada

  2. El circuito devuelve 1 si la palabra es un sustantivo y devuelve 0 si no

  3. Las líneas discontinuas azules son para entradas nunca utilizadas

Esta implementación necesita

  1. 48 transistores para codificar todas las puertas del inversor
  2. 1100 transistores para codificar todas las puertas AND
  3. 154 transistores para codificar la puerta OR
  4. Total de 1302 transistores que representan menos de 28 bytes.

Algunas medidas

  1. Un inversor puerta de necesita 1 transistor
  2. A 2 entradas simples O puerta necesita 2 transistores
  3. Un simple de 2 entradas Y compuerta necesita 2 transistores
  4. Un bit necesita 6 transistores

ingrese la descripción de la imagen aquí

Circuito de resolución completa.pdf aquí

Circuito de resolución completa.png aquí

mdahmoune
fuente
2
¿Podría explicar exactamente cuál es su sistema para codificar este circuito en bytes? Estoy muy confundido sobre cómo afirmas usar 28 * 8/1302 = 0.17 bits por transistor.
isaacg
Como mi solución es una solución informática de muy bajo nivel (hardware en lugar de software) basé mi byte contando con transistores. Desde el punto de vista del hardware, un BIT está codificado por 6 transistores, por lo que podemos suponer que un transistor representa 1/6 bit (alrededor de 0,17).
mdahmoune
1
Entiendo su punto de vista, sin embargo, el código fuente de 50 bytes debe existir en algún lugar en un hardware concreto (transistores en general)
mdahmoune
1
No es solo un punto de vista, es un requisito del desafío. Marque su respuesta como no competitiva, ya que no cumple con los requisitos para competir en este desafío.
isaacg
2
Una codificación binaria simple y sin comprimir de la información requerida para recrear esta solución podría usar 2 bits para el tipo de cada puerta lógica (3 puertas diferentes) y 10 bits para cada dirección de las entradas y salidas de cada puerta lógica (675 puertas más entradas y salidas). 2 * (48 + 550 + 77) + 10 * (2 * 48 + 3 * (550 + 77)) = 21120 bits = 2640 bytes.
Nnnes
1

Python 3, 50 bytes, puntaje 602

Python no es el lenguaje más detallado, pero 50 bytes es difícil.

lambda x:all(x.count(y)<1for y in["ful","y","er"])
L3viatán
fuente