Palabras amaderadas, palabras metálicas

35

Nota: Hay algunas palabras groseras en esta pregunta.

Hay un rompecabezas implícito planteado en este clásico boceto de Monty Python (también puede preparar el guión en línea).

Varias frases se describen como 'leñosas' o 'metálicas', y una se describe como 'PVC'.

Dada una frase, responda con su tipo de acuerdo con las siguientes listas:

woody:

gone
sausage
seemly
prodding
vacuum
bound
vole
caribou
intercourse
pert
thighs
botty
erogenous zone
ocelot
wasp
yowling

tinny:

litter bin
newspaper
antelope
recidivist
tit
simpkins

PVC:

leap

Reglas

  • Si la entrada pertenece a una de las listas anteriores, la salida debería ser woody, tinnyo PVC, en consecuencia.
  • Toda la entrada es minúscula.
  • Cualquier comportamiento es aceptable para frases que no se enumeran arriba.
  • La menor cantidad de bytes en la respuesta gana.
AJFaraday
fuente
@AJFaraday Recomiendo pasar un tiempo en el sitio y responder algunas preguntas antes de embarcarse en la difícil tarea de escribir desafíos. Cuando te sientas listo, usa el sandbox , al menos para tus primeros desafíos y también para cualquier desafío no trivial.
Adám
27
¡No me gusta esa recomendación en absoluto! Continúa publicando desafíos, incluso si no te gusta responder. Por supuesto, es bueno ver otros desafíos para tener una idea del sitio, y también recomiendo el Sandbox, ¡pero sigue escribiendo desafíos! :)
Stewie Griffin
55
Entonces, ¿debemos aplicar la lógica a un boceto de Monty Python? ...¡excelente!
BruceWayne
@BruceWayne eso es precisamente lo que estamos haciendo.
AJFaraday
You may choose how to deal (or ignore) with casing in input and output.Para aclarar, ¿significa esto que podemos esperar que las entradas estén en mayúsculas?
Marurous

Respuestas:

4

Stax , 30 25 bytes

ï═H♣║GÇX→ΩM+@╢^j╬♪►╨╝ô╤c\

Ejecutar y depurarlo

La representación ascii comentada es esta. No inventé este algoritmo. Está descaradamente arrancado de la solución de pitón de Jonathan Allen .

9@                  10th character, modularly indexed
`#!z"pi0$L+%v9`X    store "tinny pvc woody" in the x register
3(                  keep only the first 3 characters ("tin")
#                   how many times the 10th char occurs in tin? (a)
y.eaI               index of "ea" in the input or -1 (b)
+                   a + b (one of -1, 0, or 1)
xj@                 modularly indexed word in x

Ejecute este

recursivo
fuente
Esta respuesta está bien, pero el compresor literal de cadenas tiene errores, a veces produce un resultado de 5 caracteres (si incluye el ', 7) para cadenas de 4 caracteres.
Weijun Zhou
No siempre se garantiza que la compresión produzca un resultado más pequeño. Por lo general, para cadenas de inglés. Eso no es un error. Si tiene un caso en el que una cadena entre comillas dobles es más pequeña, simplemente úsela.
recursivo
Pensé que era como la de Jelly, que siempre encuentra la representación más corta (¿tal vez la descripción debería ser redactada entonces?)
Weijun Zhou
No importa. Creo que decir can help youes un poco confuso, pero lógicamente está bien.
Weijun Zhou
Hm, sí, la redacción es un poco engañosa.
recursivo el
35

Python 2 , 99 73 65 64 63 bytes

lambda s:'PVC'*('ea'in s)or'wtoiondnyy'[s[-2:]in'instperit'::2]

Pruébalo en línea!

Alternativas también con 63 bytes:

lambda s:'PVC'*('ea'in s)or'wtoiondnyy'[s[-6::5]in'dtenmsr'::2]
lambda s:'PVC'*('ea'in s)or'wtoiondnyy'[s[::5]in'lrinaosit'::2]
TFeld
fuente
23
Votaron por usar Python para resolver un desafío de Monty Python.
Brain Guider
10
@AnderBiguri, emita su voto en función de la solución en sí misma y no del lenguaje utilizado.
Shaggy
24
¡@Shaggy AFAIK, la elección del idioma es una de las partes divertidas de PPCG! Me gusta la solución, porque está en Python . Ya tenemos los bytes para ver cuál "gana"
Brain Guider
2
Sí, los votos en codegolf deberían ser simplemente para el enfoque considerado mejor o más creativo, ya que el ganador se determina de otra manera. También sería aburrido si todos usaran lenguajes especiales de codegolf en lugar de ser creativos con los más comunes
Gimli
55
Estoy de acuerdo, puede haber muchas razones para recibir una respuesta particular. Pero incluso si la gente está tan emocionada con el juego de palabras "Python for Monty Python", todavía es triste ver que los votantes no se molestan en desplazarse un poco hacia abajo, y muestran algo de aprecio por otra respuesta de Python que en realidad es menos convencional e incluso un un poco más corto ...
Kirill L.
15

Python 2 , 62 bytes

lambda n:'wtPoiVonCdn yy'[hash(n)%97%78%28%15%2+('ea'in n)::3]

Pruébalo en línea!

¿Cómo?

Este envío utiliza el hecho de que la hashfunción es estable para cadenas en Python 2. Cada entrada válida tiene una salida válida. El módulo repetido con fuerza bruta %97%78%28%15%2regresa 1para todas las palabras metálicas y de PVC y 0para las palabras amaderadas . Al agregarle el valor ('ea' in n), obtenemos en 2lugar de 1la entrada 'salto'. Aquí hay una tabla de todos los valores:

+----------------+----------------------+----------------+-------------+-------+
| word           | hash                 | %97%78%28%15%2 | +('ea'in n) | type  |
+----------------+----------------------+----------------+-------------+-------+
| leap           | 5971033325577305778  | 1              | 2           | PVC   |
+----------------+----------------------+----------------+-------------+-------+
| litter bin     | 2393495108601941061  | 1              | 1           | tinny |
| newspaper      | 1961680444266253688  | 1              | 1           | tinny |
| antelope       | -2930683648135325182 | 1              | 1           | tinny |
| recidivist     | -1480015990384891890 | 1              | 1           | tinny |
| tit            | -1495230934635649112 | 1              | 1           | tinny |
| simpkins       | 672871834662484926   | 1              | 1           | tinny |
+----------------+----------------------+----------------+-------------+-------+
| gone           | 3644900746337488769  | 0              | 0           | woody |
| sausage        | 4880706293475915938  | 0              | 0           | woody |
| seemly         | -8112698809316686755 | 0              | 0           | woody |
| prodding       | 7325980211772477495  | 0              | 0           | woody |
| vacuum         | -5283515051184812457 | 0              | 0           | woody |
| bound          | -6522768127315073267 | 0              | 0           | woody |
| vole           | -7823607590901614336 | 0              | 0           | woody |
| caribou        | -3644594841083815940 | 0              | 0           | woody |
| intercourse    | 2499732157679168166  | 0              | 0           | woody |
| pert           | 4142553773863848247  | 0              | 0           | woody |
| thighs         | -3490317966011085195 | 0              | 0           | woody |
| botty          | -6522767127163072681 | 0              | 0           | woody |
| erogenous zone | 7046120593231489339  | 0              | 0           | woody |
| ocelot         | -6961879712146820842 | 0              | 0           | woody |
| wasp           | -3668927459619339511 | 0              | 0           | woody |
| yowling        | 6823632481520320220  | 0              | 0           | woody |
+----------------+----------------------+----------------+-------------+-------+

El tipo a devolver ahora se extrae de la cadena 'wtPoiVonCdn yy'tomando cada tercer carácter, comenzando en el índice calculado.

ovs
fuente
10

JavaScript (ES6), Chrome / Edge, 54 bytes

Debido a que el comportamiento de parseInt()las entradas grandes con una raíz de 36 depende de la implementación , este no funciona con SpiderMonkey (Firefox).

s=>[,'PVC',,'Tinny'][parseInt(s+383,36)%69%7]||'Woody'

Pruébalo en línea!

¿Cómo?

La función hash devuelve 3 para palabras Tinny, 1 para PVC y 0 , 4 , 5 o 6 para palabras Woody. Las palabras marcadas con un asterisco se truncan implícitamente porque parseInt () considera el espacio como un carácter no válido .

word           | +383           | base 36 -> decimal    | mod 69 | mod 7
---------------+----------------+-----------------------+--------+------
gone           | gone383        |           36318994131 |   54   |   5
sausage        | sausage383     |      2874302392811475 |   42   |   0
seemly         | seemly383      |        80120017777107 |    6   |   6
prodding       | prodding383    |     94214834629477200 |   12   |   5
vacuum         | vacuum383      |        88266035564499 |   60   |   4
bound          | bound383       |          916101808275 |    6   |   6
vole           | vole383        |           68967369939 |   39   |   4
caribou        | caribou383     |      1249086300450771 |   63   |   0
intercourse    | intercourse383 | 3.183324871563264e+21 |   11   |   4
pert           | pert383        |           55312791699 |   21   |   0
thighs         | thighs383      |        83184557510739 |    6   |   6
botty          | botty383       |          916052399571 |   63   |   0
erogenous zone | erogenous (*)  |        41664605989780 |    7   |   0
ocelot         | ocelot383      |        68678794158483 |   39   |   4
wasp           | wasp383        |           70309896339 |   63   |   0
yowling        | yowling383     |      3523299657958227 |   39   |   4
---------------+----------------+-----------------------+--------+------
litter bin     | litter (*)     |            1301413923 |   24   |   3
newspaper      | newspaper383   |   3081816298632183000 |    3   |   3
antelope       | antelope383    |     38980419895881940 |   24   |   3
recidivist     | recidivist383  | 129824740122576960000 |    3   |   3
tit            | tit383         |            1785109395 |   45   |   3
simpkins       | simpkins383    |    104264583727840850 |   24   |   3
---------------+----------------+-----------------------+--------+------
leap           | leap383        |           46576922259 |   57   |   1

Versión anterior, 59 57 bytes

s=>['Woody','Tinny','PVC'][82178>>parseInt(s,35)%50%26&3]

Pruébalo en línea!

¿Cómo?

A continuación se muestran los diferentes pasos de la función para cada entrada. El resultado del primer módulo es una aproximación dentro de la precisión de los números JS y es matemáticamente inválido para el coito .

input          | base-35 -> dec.   | %50 | %26 | 00000000010100000100000010
---------------+-------------------+-----+-----+---------------------------
gone           |            716219 |  19 |  19 |      00------------------>
sausage        |       52042888324 |  24 |  24 | 00----------------------->
seemly         |        1492249219 |  19 |  19 |      00------------------>
prodding       |     1659396207121 |  21 |  21 |    00-------------------->
vacuum         |        1643736697 |  47 |  21 |    00-------------------->
bound          |          17573443 |  43 |  17 |        00---------------->
vole           |           1359274 |  24 |  24 | 00----------------------->
caribou        |       22625709220 |  20 |  20 |     00------------------->
intercourse    | 51532867489988450 |  48 |  22 |   00--------------------->
pert           |           1089999 |  49 |  23 |  00---------------------->
thighs         |        1549436973 |  23 |  23 |  00---------------------->
botty          |          17572449 |  49 |  23 |  00---------------------->
erogenous zone |    33308397234728 |  28 |   2 |                       00->
ocelot         |        1279159344 |  44 |  18 |       00----------------->
wasp           |           1385255 |   5 |   5 |                    00---->
yowling        |       63810499496 |  46 |  20 |     00------------------->
litter bin     |        1131250042 |  42 |  16 |         01--------------->
newspaper      |    52754217228642 |  42 |  16 |         01--------------->
antelope       |      687218151914 |  14 |  14 |           01------------->
recidivist     |  2160354371100934 |  34 |   8 |                 01------->
tit            |             36184 |  34 |   8 |                 01------->
simpkins       |     1835782971008 |   8 |   8 |                 01------->
leap           |            917900 |   0 |   0 |                         10
Arnauld
fuente
9

Java 8, 81 80 67 bytes

s->s.charAt(2)<98?"PVC":s.matches(".*(.p.|is?t).*")?"tinny":"woody"

Regex de la respuesta de Retina de @MatrinEnder .

Pruébalo en línea.

Respuesta original: 81 80 bytes

s->"anetisilire".contains(s.substring(0,2))?"tinny":s.charAt(2)<98?"PVC":"woody"

Pruébalo en línea.

Explicación:

s->                  // Method with String as both parameter and return-type
  "anetisilire".contains(s.substring(0,2))?
                     //  If the first two letters of the input are present in "anetisilire"
    "tinny"          //   Output "tinny"
   :s.charAt(2)<98?  //  Else-if the third character of the input is an 'a'
    "PVC"            //   Output "PVC"
   :                 //  Else:
    "woody"          //   Output "woody"

Explicación adicional:

litter bin:  anetisi(li)re
newspaper:   a(ne)tisilire
antelope:    (an)etisilire
recidivist:  anetisili(re)
tit:         ane(ti)silire
simpkins:    aneti(si)lire
  1. Ninguna de las dos primeras letras de las woodypalabras están presentes en esta Cadena anterior, ni es lede leap.
  2. Ninguna de las woodypalabras tiene una acomo tercera letra, por lo que se utiliza para llegar leapa PVCsi no es una tinnypalabra.
  3. Todo lo demás es una palabra de la woodylista.
Kevin Cruijssen
fuente
2
Es realmente genial poder leer este tipo de pensamiento para resolver problemas :)
AJFaraday
6

Haskell , 61 bytes

f(a:b:_)|b=='i'||elem a"ran"="tinny"|a=='l'="PVC"|1>0="woody"

Pruébalo en línea!

Utiliza esta lógica encontrada a mano:

  • Palabras con la segunda carta io primera letra r, aon sontinny
  • Cualquier otra palabra que comience con l(leap ) esPVC
  • Cualquier otra cosa es woody

Lynn guardó un byte revisando leapsu primera letra.

xnor
fuente
1
¡Agradable! Puede guardar un byte detectando "leap"con |a=='l'="PVC".
Lynn
5

QuadS , 34 32 bytes

Utiliza descaradamente el sistema de Martin Ender , incluida la expresión regular del golfista de expresiones regulares de Peter Norvig .

⊃⍵
ea
.p.|is?t
$
PVC
tinny
woody

Pruébalo en línea!

⊃⍵ elegir la primera aparición de

ea "ea"
.p.|is?t "p" rodeado de letras O "i" y "t" con una "s" opcional entre ellos al
$ final de la entrada

... pero sustituyendo los partidos con el correspondiente de los siguientes:

PVC
tinny
woody


La función APL Dyalog de 43 bytes equivalente es:

'ea' '.p.|is?t' '$'S'PVC' 'tinny' 'woody'

¡Pruebe todos los casos en línea!

Adán
fuente
5

C (gcc) , 81 bytes

h;f(char*s){puts(strchr("HzYfPW",h=*s^s[1]<<2&127)?"Tinny":h<120?"Woody":"PVC");}

Pruébalo en línea!

El primer orden del día fue encontrar alguna función hash que separara las palabras en sus categorías. Después de jugar un poco, tropecé (s[0] ^ (s[1] << 2)) & 0x7f, donde el 0x7f está allí para reducirlo a niveles ASCII imprimibles. Esto produjo la siguiente información (las tablas están ordenadas, pero no las cadenas resultantes):

Woody:
----
erogenous zone  - 45
prodding        8 56
yowling         E 69
vole            J 74
intercourse     Q 81
thighs          T 84
gone            [ 91
botty           ^ 94
bound           ^ 94
ocelot          c 99
pert            d 100
caribou         g 103
seemly          g 103
vacuum          r 114
wasp            s 115
sausage         w 119

[wg8r^JgQdT^-csE

Tinny:
----
litter bin      H 72
tit             P 80
simpkins        W 87
antelope        Y 89
recidivist      f 102
newspaper       z 122

HzYfPW

PVC:
----
leap            x 120

x

Las colisiones hash no importan, ya que se confían a la misma categoría. Solo tenemos que verificar si el hash resultante está en la cadena de hashes Tinny ("HzYfPW"), ya que los hash de Woody están por debajo del hash de PVC (120). Si tiene 120 o más, y no es una palabra metálica, debe ser de PVC. Si no es una palabra Tinny, y el hash está por debajo de 120, entonces debe ser una palabra buena y amaderada.

gastropner
fuente
4

Código de máquina x86 de 32 bits, 39 bytes

Hexdump:

69 01 47 6f 61 2c c7 02 50 56 43 00 3a c4 74 16
c7 02 77 6f 6f 64 85 c0 78 06 c7 02 74 69 6e 6e
66 c7 42 04 79 00 c3

La función hash es la multiplicación por un número "mágico" 0x2c616f47. Solo hay 6 números que se pueden usar con este código.

En primer lugar, escribe PVCen la salida. Esto se sobrescribirá, si es necesario.

Después del hashing, verifica la palabra PVC; la verificación es al = ah: lo elegí porque es una pequeña instrucción de 2 bytes. Luego, escribe cualquiera woodo tinn, dependiendo del signo del resultado hash. Entonces, escribey .

Código de montaje:

    imul eax, [ecx], 0x2c616f47;
    mov dword ptr [edx], 'CVP';
    cmp al, ah;
    je done;
    mov dword ptr [edx], 'doow';
    test eax, eax;
    js skip;
    mov dword ptr [edx], 'nnit';
skip:
    mov word ptr [edx + 4], 'y';
done:
    ret;
anatolyg
fuente
4

Jalea ,  27  26 bytes

⁵ịe“Ṗµ»_⁼“ḣG»$ị“©LẈḊ¶$Ḍ»Ḳ¤

Un enlace monádico que acepta y devuelve listas de caracteres.

Pruébalo en línea!

¿Cómo?

⁵ịe“Ṗµ»_⁼“ḣG»$ị“©LẈḊ¶$Ḍ»Ḳ¤ - Link: list of characters, W   e.g. "gone"  "leap"  "newspaper"
⁵                          - literal ten                  10
 ị                         - index into (1-based & modular)     'o'     'e'     'n'
   “Ṗµ»                    - compression of characters    "int"
  e                        - exists in?                          0       0       1
              $            - last two links as a monad
          “ḣG»             -   compression of characters  "leap"
         ⁼                 -   equal?                            0       1       0
        _                  - subtract                            0      -1       1
                         ¤ - nilad followed by link(s) as a nilad:
                “©LẈḊ¶$Ḍ»  -   compression of characters  "tinny PVC woody"
                         Ḳ -   split at spaces            ["tinny","PVC","woody"]
               ị           - index into (1-based & modular)     "woody" "PVC"   "tinny"
Jonathan Allan
fuente
3

Haskell , 75 bytes

-2 bytes gracias a Laikoni.

f"leap"="PVC"
f s|take 2s`elem`words"li ne ti si an re"="tinny"|1>0="woody"

Pruébalo en línea!

RIP enklact.

totalmente humano
fuente
f"leap"="PVC";f s|es más corto que f s|s=="leap"="PVC"|.
Laikoni
3

Sucio , 73 57 54 bytes

⇖'le'⇗≐∀⭦)Ẃ'nar'⇗{=]}⭨'i'=]'woody'‼␛['tinny'‼␛('PVC'‼␛

Pruébalo en línea!

Explicado:

Para una versión anterior similar (la actualizaré cuando deje de jugar golf)

␛‼'CVP'⇨⇖'leap'⇗≡⊭◌⬅Ẃ'nar'⇗{=]}1ẁ'i'=]'woody'‼␛['tinny'‼␛

El cuerpo de esto se compone de:

⇖            put the input into the left stack
 'leap'      push the string "leap"
       ⇗     put that string into the right stack
        ≡    are the left and right stacks equal
         ⊭   logically negate
          ◌  skip next instruction if true
           ⬅ change direction to leftwards

Si terminamos yendo a la izquierda, entonces tenemos:

       ⇨⇖'leap'⇗≡⊭◌ does stuff to the stacks, but isn't relevant
  'CVP'              push the string "PVC" (reversed, because we're going left)
 ‼                   print the string on the main stack
␛                    exit the program (this should wrap into the other exit, but that isn't working yet)

De lo contrario, esto verifica si la cadena comienza con cualquiera de "nar":

Ẃ           wipe the right stack
 'nar'      push the string "nar"
       ⇗    move string to right stack
        {
         =  compare the top of the left and right stacks
          ] goto matching bracket if true
        }   consuming loop while the right stack is true

Luego verificamos si la segunda letra es "i":

1        push the number 1
 ẁ       drop ^ number of elements off of the left stack
  'i'    push "i"
     =   are the top of the left and middle stacks equal
       ] goto matching bracket if true

Si todos fracasan, nos topamos con

'woody'   push the string "woody"
       ‼  print the string on the main stack
        ␛ exit the program

Si terminamos saltando, nos envolvemos para

[          matching bracket for the goto
 'tinny'   push the string "tinny"
        ‼  print the string on the main stack
         ␛ exit the program
Οurous
fuente
3

C # 97 bytes

string t(string w)=>w[0]!='p'&new[]{10,9,8,3}.Contains(w.Length)?"tinny":w[0]=='l'?"pvc":"woody";

Fui a buscar un patrón en la longitud de las cadenas y descubrí que son únicas, excepto las longitudes 4 y 8. Así que hago un caso especial al observar los primeros caracteres. Oh, bueno, todavía es más corto que algunas respuestas. :)

sotavento
fuente
1
Ya sabes, cuando Martin Ender encontró una regla simple para estas listas, casi todas las respuestas implementaron la misma solución, de una forma u otra. Es genial ver un enfoque original. :)
AJFaraday
Gracias por la respuesta. :) No leí otras soluciones antes de intentar la mía ... tal vez todavía hay una solución más elegante aún por descubrir ... Desearía que todos tuvieran longitudes únicas, entonces esta sería la solución.
lee
2
string t(string w)=>puede ser justo w=>. Puede convertir 'p'y otros personajes a sus representaciones int creo. Puede eliminar el punto y coma final
TheLethalCoder
3

Python , 59 bytes

lambda w:"wtPoiVonCdn yy"[(w*4)[9]in"tin"or(w[2]<"b")*2::3]

Pruébalo en línea!

Utiliza la indexación de la respuesta Python de ovs pero una función de elección más simple y más corta:

Si la décima letra de la palabra, wcon envoltura ( (w*4)[9]- donde se w*4repite wcuatro veces) es una letra en la palabra tin ( in"tin"), entonces la palabra es metálica , de lo contrario, si la tercera letra ( w[2]) es un a ( <'b'), entonces la palabra es PVC de lo contrario la palabra es leñosa .

... este 59 hace el mismo trabajo:

lambda w:"wtPoiVonCdn yy"[[(w*4)[9]in"tin",2][w[2]<"b"]::3]
Jonathan Allan
fuente
2

C, 107 bytes

k;f(char*s){for(k=0;*s;)k+=*s++;k%=100;puts(k-18?(k-5)*(k-81)*(k-56)*(k-78)*(k-37)?"woody":"tinny":"PVC");}

Pruébalo en línea!

Steadybox
fuente
2

Lote, 145 bytes

@set/ps=
@if %s%==leap echo PVC&exit/b
@for %%s in (a n r)do @if %s:~,1%==%%s echo tinny&exit/b
@if %s:~1,1%==i echo tinny&exit/b
@echo woody

Toma entrada en STDIN. Explicación: Después de comprobar leap, las palabras de hojalata o bien comenzar con una de las cartas a, no ro su segunda carta es i.

Neil
fuente
2

CJam , 35 bytes

1b_856%338<\418=-"woodytinnyPVC"5/=

Pruébalo en línea!

Olvidé por completo que había comenzado una búsqueda de la fuerza bruta en busca de expresiones cortas para dividir las cadenas leñosas y metálicas en dos clases. Acabo de encontrar la ventana de la consola donde se ejecutó la búsqueda y resulta que en realidad encontró algo ...

Explicación

1b     e# Sum the code points of the input string.
       e# The result is unique for each input, except "pert" and "wasp" which
       e# both sum to 443. But they're both woody, so that's fine.
_      e# Duplicate.
856%   e# Take the sum modulo 856.
338<   e# Check whether the result is less than 338. That's true for all
       e# tinny words.
\      e# Swap with the other copy of the sum.
418=   e# Check whether the sum is equal to 418, which identifies "leap".
-      e# Subtract. Gives -1 for "leap", 1 for tinny words and 0 for woody words.
"woodytinnyPVC"5/
       e# Create the list ["woody" "tinny" "PVC"].
       e# Select the correct string.
Martin Ender
fuente
1

Excel, 81 bytes

=IF(ISNUMBER(FIND(LEFT(A1,2),"anetisilire")),"tinny",IF(A1="leap","PVC","woody"))

Usando el método 'anetisilire'.

Wernisch
fuente
1

JavaScript, 60 , 50

EDITAR Vi todas las otras respuestas de expresiones regulares. Supongo que solo estoy ciego. De todos modos, aquí hay uno que usa la misma expresión regular

i=="leap"?"PVC":/.p.|is*t/.test(i)?"tinny":"woody"

Además, ahora, supera a la otra respuesta JS

Retazo:

let test = i => i=="leap"?"PVC":/.p.|is*t/.test(i)?"tinny":"woody"

let woody = `gone
sausage
seemly
prodding
vacuum
bound
vole
caribou
intercourse
pert
thighs
botty
erogenous zone
ocelot
wasp
yowling`;
console.log("THESE SHOULD BE woody");
woody.split("\n").forEach(el => console.log(test(el)));
let tinny = `litter bin
newspaper
antelope
recidivist
tit
simpkins`;
console.log("THESE SHOULD BE tinny");
tinny.split("\n").forEach(el => console.log(test(el)));
console.log("THIS SHOULD BE PVC");
console.log(test("leap"));

Vieja respuesta

Todavía no vi ninguno con expresiones regulares, así que pensé en probarlo.

i=="leap"?"PVC":/[gyuz]|[or][tl]|as/.test(i)?"woody":"tinny"

No estoy seguro si esto cuenta como 60 o más porque no incluí una declaración de devolución. Agregaré un fragmento cuando me conecte a mi computadora

Editar: Fragmento

let test = i => i=="leap"?"PVC":/[gyuz]|[or][tl]|as/.test(i)?"woody":"tinny"

let woody = `gone
sausage
seemly
prodding
vacuum
bound
vole
caribou
intercourse
pert
thighs
botty
erogenous zone
ocelot
wasp
yowling`;
console.log("THESE SHOULD BE woody");
woody.split("\n").forEach(el => console.log(test(el)));
let tinny = `litter bin
newspaper
antelope
recidivist
tit
simpkins`;
console.log("THESE SHOULD BE tinny");
tinny.split("\n").forEach(el => console.log(test(el)));
console.log("THIS SHOULD BE PVC");
console.log(test("leap"));

vityavv
fuente