Note: Il y a quelques mots grossiers dans cette question.

Ce croquis classique de Monty Python (vous pouvez également préparer le script en ligne) pose un casse-tête implicite .

Diverses phrases sont décrites comme étant "ligneuses" ou "minces", et l'une d'entre elles comme étant "PVC".

Étant donné une phrase, répondez avec son type en fonction des listes suivantes:

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

Règles

• Si l'entrée appartient à l'une des listes ci-dessus, la sortie doit être woody, tinnyou PVC, en conséquence.
• Toutes les entrées sont en minuscule.
• Tout comportement est acceptable pour les phrases non répertoriées ci-dessus.
• Le moins d'octets dans la réponse gagne.

Stax , 30 25 octets

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

Exécuter et déboguer

La représentation ascii commentée est la suivante. Je n'ai pas inventé cet algorithme. C'est une solution sans scrupule pour la solution python 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

Exécuter celui-ci

Python 2 , 99 73 65 64 63 octets

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

Essayez-le en ligne!

Alternatives aussi avec 63 octets:

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 octets

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

Essayez-le en ligne!

Comment?

Cette soumission utilise le fait que la hashfonction est stable pour les chaînes en Python 2. Chaque entrée valide a une sortie valide. Le modulo répété brusquement forcé %97%78%28%15%2revient 1pour tous les mots métalliques et PVC ainsi que 0pour les mots ligneux . En y ajoutant la valeur de ('ea' in n), nous obtenons à la 2place de 1«saut» d'entrée. Voici un tableau de toutes les valeurs:

+----------------+----------------------+----------------+-------------+-------+
| 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 |
+----------------+----------------------+----------------+-------------+-------+

Le type à renvoyer est maintenant extrait de la chaîne 'wtPoiVonCdn yy'en prenant tous les trois caractères, en commençant par l'index calculé.

JavaScript (ES6), Chrome / Edge, 54 octets

Étant donné que le comportement des parseInt()entrées importantes avec une base de 36 dépend de la mise en œuvre , celui-ci ne fonctionne pas avec SpiderMonkey (Firefox).

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

Essayez-le en ligne!

Comment?

La fonction de hachage renvoie 3 pour les mots minuscules, 1 pour le PVC et 0 , 4 , 5 ou 6 pour les mots de Woody. Les mots marqués d'un astérisque sont implicitement tronqués car l' espace est considéré comme un caractère non valide par parseInt () .

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

Version précédente, 59 57 octets

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

Essayez-le en ligne!

Comment?

Vous trouverez ci-dessous les différentes étapes de la fonction pour chaque entrée. Le résultat du premier modulo est une approximation dans la précision des nombres JS et est mathématiquement invalide pour les rapports sexuels .

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 octets

Enregistré 1 octet en utilisant trois paires de substitution comme dans la réponse d'Adam.

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

Essayez-le en ligne!

J'ai eu la .p.|is*tregex du golfeur de regex de Peter Norvig .

Java 8, 81 80 67 octets

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

Regex de la réponse Retina de @MatrinEnder .

Essayez-le en ligne.

Réponse originale: 81 80 octets

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

Essayez-le en ligne.

Explication:

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"

Explication supplémentaire:

litter bin:  anetisi(li)re
newspaper:   a(ne)tisilire
antelope:    (an)etisilire
recidivist:  anetisili(re)
tit:         ane(ti)silire
simpkins:    aneti(si)lire

1. Aucune des deux premières lettres des woodymots n'est présente dans cette chaîne ci-dessus, ni n'est lede leap.
2. Aucun des woodymots n’a ade troisième lettre, c’est donc utilisé pour arriver leapà PVCsi ce n’est pas un tinnymot.
3. Tout le reste est un mot de la woodyliste.

Haskell , 61 octets

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

Essayez-le en ligne!

Utilise cette logique trouvée à la main:

• Les mots avec la deuxième lettre iou première lettre r, aou nsonttinny
• Tout autre mot commençant par l( leap) estPVC
• Tout le reste est woody

Lynn a sauvegardé un octet en vérifiant leapsa première lettre.

QuadS , 34 32 octets

Utilise sans vergogne le système de Martin Ender , y compris la regex du regex golfer de Peter Norvig .

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

Essayez-le en ligne!

⊃⍵ choisir la première occurrence de

ea "ea"
.p.|is?t "p" entouré des lettres OU "i" et "t" avec un "s" optionnel entre eux
$ fin de saisie

… Mais en substituant les matchs à celui correspondant:

PVC
tinny
woody

La fonction APL Dyalog équivalente sur 43 octets est la suivante:

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

Essayez tous les cas en ligne!

C (gcc) , 81 octets

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

Essayez-le en ligne!

La première chose à faire était de trouver une fonction de hachage permettant de séparer les mots dans leurs catégories. Après quelques manipulations à propos de moi, je suis tombé sur (s[0] ^ (s[1] << 2)) & 0x7f, où le 0x7f est bien sûr là pour le ramener à des niveaux imprimables ASCII. Cela a généré les informations suivantes (les tables sont triées, mais pas les chaînes résultantes):

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

Les collisions de hachage importent peu, puisqu'elles sont confiées à la même catégorie. Il suffit de vérifier si le hachage résultant se trouve dans la chaîne de hachages Tinny ("HzYfPW"), car les hachages de Woody sont tous situés sous le hachage PVC (120). Si 120 ou plus, et pas un mot Tinny, ce doit être PVC. Si ce n'est pas un mot Tinny et que le hachage est inférieur à 120, alors ce doit être un bon mot, boisé.

Code machine x86 32 bits, 39 octets

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 fonction de hachage est multipliée par un nombre "magique" 0x2c616f47. Il n'y a que 6 chiffres pouvant être utilisés avec ce code.

Tout d'abord, il écrit PVCdans la sortie. Ce sera écrasé, si nécessaire.

Après hachage, il vérifie le mot PVC; le chèque est al = ah- je l'ai choisi parce que c'est une petite instruction de 2 octets. Ensuite, il écrit soit woodou tinn, en fonction du signe du résultat haché. Ensuite, il écrit y.

Code d'assemblage:

    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;

Gelée ,  27 à  26 octets

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

Un lien monadique acceptant et renvoyant des listes de caractères.

Essayez-le en ligne!

Comment?

⁵ị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 octets

-2 octets grâce à Laikoni.

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

Essayez-le en ligne!

RIP enklact.

Sale , 73 57 54 octets

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

Essayez-le en ligne!

A expliqué:

Pour une version plus ancienne similaire (je la mettrai à jour quand j'arrête de jouer au golf)

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

Le corps de celui-ci est composé 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 nous finissons par aller à gauche, alors nous avons:

       ⇨⇖'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)

Sinon, cela vérifie si la chaîne commence par l'un des "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

Nous vérifions ensuite si la deuxième lettre est "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 tous tombent à travers, nous nous heurtons à

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

Si nous finissons par sauter, nous nous retournons à

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

C # 97 octets

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

Je suis allé chercher un motif dans la longueur des cordes et ai constaté qu'elles sont uniques, à l'exception des longueurs 4 et 8. Donc, je les cas particuliers en regardant les premiers caractères. Oh bien, c'est toujours plus court que certaines réponses. :)

Python , 59 octets

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

Essayez-le en ligne!

Utilise la réponse Python de l'indexation à partir d' ovs, mais une fonction de choix plus simple et plus courte:

Si la dixième lettre du mot, wavec emballage ( (w*4)[9]- où se w*4répète wquatre fois) est une lettre dans le mot d' étain ( in"tin"), le mot est grêles , sinon , si la troisième lettre ( w[2]) est un ( <'b'), le mot est PVC sinon le mot est boisé .

... ce 59 fait le même travail:

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

C, 107 octets

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

Essayez-le en ligne!

Lot, 145 octets

@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

Prend une entrée sur STDIN. Explication: Après avoir vérifié leap, les mots de grêles commencent soit par l' une des lettres a, nou rou leur deuxième lettre i.

CJam , 35 octets

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

Essayez-le en ligne!

J'ai complètement oublié que j'avais entamé une recherche brutale d'efforts pour hacher les cordes ligneuses et minces en deux classes. Je viens de trouver la fenêtre de la console où la recherche a été exécutée et il s'avère qu'elle a effectivement trouvé quelque chose ...

Explication

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 octets

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

Utilisation de la méthode 'anetisilire'.

Japt , 36 34 octets

Utilise un RegEx de la solution Martin's Retina.

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

Essayez | Vérifier tous les cas de test

JavaScript, 60 , 50

EDIT j'ai vu toutes les autres réponses regex. Je suppose que je suis juste aveugle. Quoi qu’il en soit, en voici un qui utilise la même expression rationnelle

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

En outre, maintenant, il bat l'autre réponse JS

Fragment:

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

Ancienne réponse

Je n'en ai pas encore vu avec regex, alors j'ai décidé d'essayer

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

Je ne sais pas si cela compte au moins 60 parce que je n’ai pas inclus de déclaration de retour. Ajoutera un extrait lorsque je serai sur mon ordinateur

Edit: extrait

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