Mots boisés, mots minuscules

35

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.
code-golf string classification AJFaraday
la source
@AJFaraday Je recommanderais de passer du temps sur le site et de répondre à certaines questions avant de nous lancer dans la difficile tâche de rédiger des défis. Lorsque vous vous sentez prêt, utilisez le bac à sable , au moins pour vos premiers défis et pour tous les défis non triviaux.
Adám
27
Je n'aime pas cette recommandation du tout! Continuez à poster des défis, même si vous n'aimez pas répondre. C'est bien sûr agréable de regarder d'autres défis pour avoir une idée du site, et je recommande également le bac à sable, mais s'il vous plaît continuez à écrire défis! :)
Stewie Griffin
5
Nous devons donc appliquer la logique à un croquis de Monty Python? ...excellent!
BruceWayne
@BruceWayne c'est précisément ce que nous faisons.
AJFaraday
You may choose how to deal (or ignore) with casing in input and output.Pour clarifier, cela signifie-t-il que nous pouvons nous attendre à ce que les entrées soient en majuscules?
ousurous

Réponses:

4

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

récursif
la source
Cette réponse est OK, mais le compresseur littéral de chaîne est bogué, il produit parfois un résultat long de 5 caractères (si vous incluez le `, 7) pour des chaînes longues de 4 caractères.
Weijun Zhou
La compression ne garantit pas toujours un résultat inférieur. Juste habituellement pour les chaînes anglaises. Ce n'est pas un bug. Si vous avez un cas où une chaîne à double guillemet est plus petite, utilisez-la à la place.
récursive
Je pensais que c'était comme celle de Jelly qui trouve toujours la représentation la plus courte (peut-être que la description devrait être reformulée alors?)
Weijun Zhou
Ça ne fait rien. Je pense que dire can help youest un peu déroutant mais est logiquement correct.
Weijun Zhou
Hm, oui, la formulation est un peu trompeuse.
récursive
35

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]
TFeld
la source
23
En raison de l’utilisation de python pour résoudre un problème de monty python.
Brain Guider
10
@AnderBiguri, exprimez votre vote en fonction de la solution elle-même plutôt que du langage utilisé.
Shaggy
24
@Shaggy AFAIK: le choix de la langue est l’un des aspects amusants de PPCG! J'aime la solution, car c'est en python . Nous avons déjà les octets pour savoir lequel "gagne"
Brain Guider
2
Oui, les votes dans CodeGolf devraient être simplement pour la méthode considérée comme la meilleure ou la plus créative, le gagnant étant déterminé autrement. En outre, il serait ennuyeux que tout le monde utilise simplement des langages spéciaux de code-golf au lieu de faire preuve de créativité avec des langages plus courants
Gimli
5
Je suis d’accord, il peut y avoir plusieurs raisons d’aimer une réponse particulière. Mais même si les gens sont si enthousiasmés par le jeu de mots "Python pour Monty Python", il est toujours triste de voir que les votants ne se donnent pas la peine de faire défiler l'écran vers le bas et qu'ils apprécient une autre réponse de Python qui est en fait plus non conventionnelle et même un peu plus court ...
Kirill L.
15

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

ovs
la source
10

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
Arnauld
la source
9

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 .

Martin Ender
la source
2
Euh oh, attributions circulaires.
Adám
9

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.
Kevin Cruijssen
la source
2
C'est vraiment cool de pouvoir lire à travers ce genre de réflexion de résolution de problèmes :)
AJFaraday
6

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.

Xnor
la source
1
Agréable! Vous pouvez enregistrer un octet en détectant "leap"avec |a=='l'="PVC".
Lynn
5

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!

Adam
la source
5

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

gastropner
la source
4

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;
anatolyg
la source
4

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"
Jonathan Allan
la source
3

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.

totalement humain
la source
f"leap"="PVC";f s|est plus court que f s|s=="leap"="PVC"|.
Laikoni
3

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
Οurous
la source
3

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

lee
la source
1
Vous savez, lorsque Martin Ender a trouvé une règle simple pour ces listes, toutes les réponses implémentaient la même solution, d'une manière ou d'une autre. C'est cool de voir une approche originale. :)
AJFaraday
Merci pour les commentaires. :) Je n'avais pas lu d'autres solutions avant de tenter la mienne. Peut-être y a-t-il encore une solution plus élégante à découvrir .. Je souhaite tellement qu'ils aient tous des longueurs uniques, alors ce serait la Solution.
lee
2
string t(string w)=>peut être juste w=>. Vous pouvez convertir 'p'et d'autres personnages à leurs représentations int, je pense. Vous pouvez supprimer le point-virgule
final
3

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]
Jonathan Allan
la source
2

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!

Steadybox
la source
2

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.

Neil
la source
2

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.
Martin Ender
la source
1

Excel, 81 octets

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

Utilisation de la méthode 'anetisilire'.

Wernisch
la source
1

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"));
Développer l'extrait

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"));
Développer l'extrait

vityavv
la source