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.

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

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]

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.

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

Retina , 39 38 36 bytes

Se guardó 1 byte usando tres pares de sustitución como en la respuesta de Adám.

L#-3$0`ea
PVC
.p.|is?t
tinny
$
woody

Pruébalo en línea!

Tengo la .p.|is*texpresión regular del golfista de expresiones regulares de Peter Norvig .

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.

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.

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!

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.

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;

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"

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.

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

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

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]

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!

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.

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.

Excel, 81 bytes

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

Usando el método 'anetisilire'.

Japt , 36 34 bytes

Utiliza un RegEx de la solución Retina de Martin.

g2 ¶'a?"PVC":`wÅnyy`ë2Uè`?t|.pe

Pruébalo | Verifique todos los casos de prueba

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