Uwaga: w tym pytaniu jest kilka niegrzecznych słów.

W tym klasycznym szkicu Monty Python jest ukryta zagadka (możesz również przygotować skrypt online).

Różne frazy są określane jako „drzewne” lub „tinny”, a jedno jest określane jako „PVC”.

Biorąc pod uwagę frazę, odpowiedz swoim typem zgodnie z następującymi listami:

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

Zasady

• Jeśli wejście należy do jednej z powyższych list, wyjście powinno być woody, tinnylub PVC, odpowiednio.
• Wszystkie dane są pisane małymi literami.
• Każde zachowanie jest dopuszczalne w przypadku zwrotów niewymienionych powyżej.
• Wygrywa najmniej bajtów w odpowiedzi.

Stax , 30 25 bajtów

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

Uruchom i debuguj

Komentowana reprezentacja ascii jest taka. Nie wymyśliłem tego algorytmu. Bezwstydnie oderwał rozwiązanie python Jonathana Allena .

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

Uruchom ten

Python 2 , 99 73 65 64 63 bajty

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

Wypróbuj online!

Alternatywy również z 63 bajtami:

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 bajty

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

Wypróbuj online!

W jaki sposób?

To przesłanie wykorzystuje fakt, że hashfunkcja jest stabilna dla ciągów znaków w Pythonie 2. Każde prawidłowe wejście ma prawidłowe wyjście. Brutalnie wymuszone powtarzanie modulo %97%78%28%15%2powraca 1dla wszystkich słów z cienkich i PCV oraz 0dla słów z drewna . Dodając do niego wartość ('ea' in n), otrzymujemy 2zamiast 1wejściowego „skoku”. Oto tabela wszystkich wartości:

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

Typ do zwrócenia jest teraz wyodrębniany z ciągu 'wtPoiVonCdn yy', biorąc co trzeci znak, zaczynając od obliczonego indeksu.

JavaScript (ES6), Chrome / Edge, 54 bajty

Ponieważ zachowanie parseInt()dużych danych wejściowych z podstawką 36 zależy od implementacji , to nie działa z SpiderMonkey (Firefox).

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

Wypróbuj online!

W jaki sposób?

Funkcja skrótu zwraca 3 dla słów Tinny, 1 dla PCV i 0 , 4 , 5 lub 6 dla słów Woody'ego. Słowa oznaczone gwiazdką są domyślnie obcięte, ponieważ spacja jest uważana za nieprawidłowy znak przez 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

Poprzednia wersja, 59 57 bajtów

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

Wypróbuj online!

W jaki sposób?

Poniżej znajdują się różne kroki funkcji dla każdego wejścia. Wynik pierwszego modułu jest przybliżeniem w zakresie dokładności liczb JS i jest matematycznie niepoprawny do stosunku .

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 bajtów

Zaoszczędzono 1 bajt, stosując trzy pary podstawień jak w odpowiedzi Adáma.

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

Wypróbuj online!

Mam .p.|is*tregex od golfisty regex Petera Norviga .

Java 8, 81 80 67 bajtów

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

Regex z odpowiedzi Retina @MatrinEnder .

Wypróbuj online.

Oryginalna odpowiedź: 81 80 bajtów

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

Wypróbuj online.

Wyjaśnienie:

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"

Dodatkowe wyjaśnienie:

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

1. Żadna z pierwszych dwóch liter woodysłów nie występuje w powyższym ciągu, ani nie pochodzi lez leap.
2. Żadna ze woodysłów ma aw trzeciej litery, tak że jest używany, aby dostać leapsię PVC, jeśli nie jest to tinnysłowo.
3. Cała reszta to słowo z woodylisty.

Haskell , 61 bajtów

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

Wypróbuj online!

Wykorzystuje tę ręcznie znalezioną logikę:

• Słowa z drugiego listu ilub pierwszej litery r, alub nsątinny
• Każde inne słowo zaczynające się od l( leap) toPVC
• Wszystko inne jest woody

Lynn uratowała bajt, sprawdzając leapjego pierwszą literę.

QuadS , 34 32 bajty

Bezwstydnie używa systemu Martina Endera , w tym wyrażenia regularnego z golfisty regularnego Petera Norviga .

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

Wypróbuj online!

⊃⍵ wybierz pierwsze wystąpienie

ea „ea”
.p.|is?t „p” otoczony literami LUB „i” i „t” z opcjonalnym „s” między nimi na
$ końcu wejścia

… Ale zastępując mecze odpowiadającym im jednym z poniższych:

PVC
tinny
woody

Równoważna 43-bajtowa funkcja Dyalog APL to:

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

Wypróbuj wszystkie skrzynki online!

C (gcc) , 81 bajtów

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

Wypróbuj online!

Pierwszym porządkiem biznesu było znalezienie funkcji haszującej, która podzieliłaby słowa na ich kategorie. Po kilku drobiazgach na temat natknąłem się na to (s[0] ^ (s[1] << 2)) & 0x7f, gdzie 0x7f jest oczywiście, aby sprowadzić go do poziomów ASCII do wydruku. To dało następujące informacje (tabele są posortowane, ale nie powstałe ciągi):

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

Zderzenia mieszające nie mają znaczenia, ponieważ są przypisywane do tej samej kategorii. Musimy tylko sprawdzić, czy wynikowy skrót znajduje się w ciągu skrótów Tinny („HzYfPW”), ponieważ wszystkie skróty Woody są poniżej skrótu PVC (120). Jeśli 120 lub więcej, a nie słowo Tinny, musi to być PVC. Jeśli nie jest to małe słowo, a wartość skrótu jest mniejsza niż 120, to musi to być dobre, drzewne słowo.

x86 32-bitowy kod maszynowy, 39 bajtów

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

Funkcja skrótu jest mnożona przez „magiczną” liczbę 0x2c616f47. Istnieje tylko 6 cyfr, których można użyć z tym kodem.

Przede wszystkim zapisuje PVCna wyjściu. W razie potrzeby zostanie to zastąpione.

Po haszowaniu sprawdza słowo PVC; czek jest al = ah- wybrałem go, ponieważ jest to mała instrukcja 2-bajtowa. Następnie zapisuje albo woodalbo tinn, w zależności od znaku wyniku mieszania. Potem pisze y.

Kod zestawu:

    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;

Galaretka ,  27  26 bajtów

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

Monadyczny link przyjmujący i zwracający listy znaków.

Wypróbuj online!

W jaki sposób?

⁵ị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 bajtów

-2 bajty dzięki Laikoni.

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

Wypróbuj online!

RIP enklact.

Brudny , 73 57 54 bajtów

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

Wypróbuj online!

Wyjaśnił:

Dla podobnej starszej wersji (zaktualizuję ją, gdy przestanę grać w golfa)

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

Ciało tego składa się z:

⇖            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

Jeśli skończymy w lewo, mamy:

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

W przeciwnym razie sprawdza, czy ciąg zaczyna się od któregokolwiek z „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

Następnie sprawdzamy, czy druga litera to „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

Jeśli wszystkie upadną, wpadniemy na

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

Jeśli skończyliśmy skakać, zawijamy się do

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

C # 97 bajtów

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

Poszukałem wzoru długości strun i stwierdziłem, że są one wyjątkowe, z wyjątkiem długości 4 i 8. Więc specjalnym przypadkiem są te, patrząc na pierwsze znaki. No cóż, wciąż jest krótszy niż niektóre odpowiedzi. :)

Python , 59 bajtów

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

Wypróbuj online!

Wykorzystuje indeksowanie z odpowiedzi Pythona w ovs, ale prostszą i krótszą funkcję wyboru:

Jeśli dziesiąta litera słowa, wz zawijaniem ( (w*4)[9]- gdzie to się w*4powtarza wcztery razy) to litera w słowie tin ( in"tin"), to słowo to tinny , w przeciwnym razie, jeśli trzecia litera ( w[2]) to a ( <'b'), to słowo to PVC w przeciwnym razie słowo jest zdrewniałe .

... ten 59 wykonuje tę samą pracę:

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

C, 107 bajtów

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

Wypróbuj online!

Partia, 145 bajtów

@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

Pobiera dane wejściowe na STDIN. Objaśnienie: Po sprawdzeniu leap, metaliczny słowa albo zacząć z jednego z listów a, nlub rczy jest ich drugi list i.

CJam , 35 bajtów

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

Wypróbuj online!

Zupełnie zapomniałem, że zacząłem brutalną poszukiwanie krótkich wyrażeń, aby zahaczyć zdrewniałe i drobne struny na dwie klasy. Właśnie znalazłem okno konsoli, w którym rozpoczęło się wyszukiwanie i okazało się, że faktycznie coś znalazło ...

Wyjaśnienie

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 bajtów

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

Korzystanie z metody „anetisilire”.

Japt , 36 34 bajtów

Wykorzystuje RegEx z rozwiązania Martin's Retina.

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

Wypróbuj | Sprawdź wszystkie przypadki testowe

JavaScript, 60 , 50

EDYCJA Widziałem wszystkie inne odpowiedzi wyrażenia regularnego. Chyba jestem ślepy. W każdym razie tutaj jest ten sam regex

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

Ponadto, teraz bije drugą odpowiedź JS

Skrawek:

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

Stara odpowiedź

Nie widziałem jeszcze żadnego wyrażenia regularnego, więc pomyślałem, że spróbuję

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

Nie jestem pewien, czy liczy się to jako 60 lub więcej, ponieważ nie uwzględniłem instrukcji return. Dodam fragment kodu, gdy wejdę na komputer

Edycja: Snippet

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