木质词，小词

35

注意：这个问题有些粗鲁的话。

这个经典的Monty Python草图中有一个隐含的难题（您也可以在线准备脚本）。

各种短语被描述为“木质”或“小”，而一个短语被描述为“ PVC”。

给定一个短语，请根据以下列表使用其类型进行响应：

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

规则

  • 如果该输入属于上述列表中的一个，输出应该是woody，tinny或者PVC，相应地。
  • 所有输入均为小写。
  • 上面未列出的短语可以接受任何行为。
  • 答案中最少的字节将获胜。
code-golf  string  classification 
— 法拉第
source
@AJFaraday我建议您花一些时间在网站上并回答一些问题，然后再开始编写挑战性难题。当您准备就绪时，请至少将沙盒用于您的前几个挑战以及所有非平凡的挑战。
— 亚当
27
我一点都不喜欢这个建议！即使您不喜欢回答，也请继续发布挑战。查看其他挑战当然也很不错，以使您对网站有所了解，我也建议您使用Sandbox，但请继续编写挑战！:)
— Stewie Griffin
5
那么，我们要将逻辑应用于Monty Python草图吗？...优秀！
— BruceWayne
@BruceWayne正是我们正在做的事情。
— AJFaraday
You may choose how to deal (or ignore) with casing in input and output.要澄清，这是否意味着我们可以期望输入为大写？
— 世纪

Answers:

4

Stax，30 25 字节

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

运行并调试

评论的ascii表示法是这个。我没有发明这种算法。它毫不客气地从乔纳森·艾伦（Jonathan Allen）的python解决方案中删除了。

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

运行这个

— 递归的
source
这个答案是可以的，但是字符串字面量压缩器有问题，有时会产生4个字符长字符串的5个字符长的结果（如果包括`，7）。
— 周
并非总是保证压缩会产生较小的结果。通常只是用于英语字符串。那不是错误。如果遇到双引号的字符串较小的情况，请改用它。
— 递归
我认为就像Jelly一样总是找到最短的表示形式（也许应该改写描述了吗？）
— Zhou Weijun
没关系。我认为can help you这有点令人困惑，但从逻辑上讲可以。
— 周
嗯，是的，措词有点误导。
— 递归
35

Python 2中，99个 73 65 64 63字节

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

在线尝试！

也有63个字节的替代项：

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]
— 场
source
23
由于使用python解决了monty python难题而被推荐。
— Brain Guided
10
@AnderBiguri，请根据解决方案本身而不是使用的语言来投票。
— 毛茸茸的
24
@Shaggy AFAIK语言的选择是PPCG的有趣部分之一！我喜欢这个解决方案，因为它在python中。我们已经有了字节来查看哪个“获胜”
— Brain Guider
2
是的，在代码高尔夫中的投票仅应被认为是最佳或最具创意的方法，否则将决定获胜者。如果每个人都只使用特殊的代码高尔夫球语言而不是使用更通用的语言进行创意，那也将很无聊
— Gimli
5
我同意，有很多理由喜欢特定的答案。但是，即使人被“巨蟒的巨蟒”太激动了双关语，但仍然悲伤地看到，upvoters也懒得向下滚动了一下，并表现出一定升值到另一个Python的答案其实非常规，甚至是短一点……
— Kirill L.
15

Python 2，62个字节

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

在线尝试！

怎么样？

此提交使用以下事实：该hash函数对于Python 2中的字符串稳定。每个有效输入都有一个有效输出。该蛮力强行重复模%97%78%28%15%2回报1所有尖细和PVC字和0用于木本话。通过添加它的值('ea' in n)，我们得到2而不是1输入“ leap”。这是所有值的表格：

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

现在，通过从'wtPoiVonCdn yy'计算得出的索引开始，每隔三个字符就从字符串中提取要返回的类型。

— ovs
source
10

JavaScript（ES6），Chrome / Edge，54字节

由于parseInt()基数为36的大型输入的行为取决于实现，因此该行为不适用于SpiderMonkey（Firefox）。

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

在线尝试！

怎么样？

散列函数返回3为尖细的话，1为PVC，要么0，4，5或6用于木本植物的话。标有星号的单词被隐式截断，因为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

以前的版本59 57字节

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

在线尝试！

怎么样？

以下是每个输入功能的不同步骤。第一个模的结果是JS数精度范围内的近似值，在数学上对于交往无效。

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

Java 8，81 80 67字节

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

来自@MatrinEnder的Retina答案的正则表达式。

在线尝试。

原始答案：81个 80字节

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

在线尝试。

说明：

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"

附加说明：

litter bin:  anetisi(li)re
newspaper:   a(ne)tisilire
antelope:    (an)etisilire
recidivist:  anetisili(re)
tit:         ane(ti)silire
simpkins:    aneti(si)lire
  1. woody单词的前两个字母都没有出现在上面的String中，也没有le来自leap。
  2. 的无woody字有a作为第三个字母，以便用于获取leap到PVC，如果它不是一个tinny字。
  3. 一切都是woody清单中的一个词。
— 凯文·克鲁伊森
source
2
能够读懂这种解决问题的想法真的很酷:)
— AJFaraday
6

Haskell，61个字节

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

在线尝试！

使用以下手动发现的逻辑：

  • 与第二个字母的单词i或首字母r，a或者n是tinny
  • 以l（leap）开头的其他任何单词都是PVC
  • 还有什么 woody

Lynn通过检查leap第一个字母来保存一个字节。

— 异或
source
1
真好！您可以通过检测来保存一个字节"leap"用|a=='l'="PVC"。
— 林恩
5

QuadS，34 32字节

无耻地使用Martin Ender的系统，包括Peter Norvig的regex高尔夫球手的regex。

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

在线尝试！

⊃⍵ 选择第一次出现

ea 输入结尾的  “ ea”，
.p.|is?t “ p”或字母“ i”和“ t”以及可选的“ s”
$

…，但将匹配项替换为以下对应项之一：

PVC
tinny
woody

等效的43字节Dyalog APL功能是：

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

在线尝试所有案例！

— 亚当
source
5

C（gcc），81个字节

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

在线尝试！

首先要做的是找到一些哈希函数，将这些单词分为不同的类别。经过一番摆弄之后，我偶然发现(s[0] ^ (s[1] << 2)) & 0x7f了0x7f，在那里它当然会降到可打印的ASCII级别。这产生了以下信息（表已排序，但未对结果字符串进行排序）：

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

哈希冲突无关紧要，因为它们属于同一类别。我们仅需检查生成的哈希是否在Tinny哈希字符串（“ HzYfPW”）中，因为Woody哈希都在PVC哈希之下（120）。如果为120或更高，并且不是一个小小的单词，则必须为PVC。如果不是Tinny单词，并且哈希值低于120，则它必须是一个很好的木质单词。

— 腹肌
source
4

x86 32位机器代码，39个字节

十六进制转储：

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

哈希函数是一个“魔术”数的乘积0x2c616f47。此代码只能使用6个数字。

首先，它写入PVC输出。如果需要，它将被覆盖。

散列后，它会检查PVC字；检查是al = ah-我选择它是因为它是一个2字节的小指令。然后，根据哈希结果的符号写入wood或tinn。然后，它写道y。

汇编代码：

    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;
— 阿纳托利格
source
4

果冻， 27  26 字节

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

接受和返回字符列表的单子链接。

在线尝试！

怎么样？

⁵ị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"
— 乔纳森·艾伦
source
3

脏，73 57 54字节

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

在线尝试！

解释：

对于类似的旧版本（停止打高尔夫球时会对其进行更新）

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

它的主体由以下组成：

⇖            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

如果我们最终向左走，那么我们有：

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

否则，这将检查字符串是否以“ 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

然后，我们检查第二个字母是否为“ 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

如果他们全部失败，我们就会遇到

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

如果我们最后跳了，我们会绕到

[          matching bracket for the goto
 'tinny'   push the string "tinny"
        ‼  print the string on the main stack
         ␛ exit the program
— 巨大
source
3

C＃97字节

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

我去寻找字符串长度的模式，发现除了长度4和8之外，它们都是唯一的。因此，我通过查看第一个字符来对它们进行特殊处理。噢，还比一些答案还短。:)

— 李
source
1
您知道，当马丁·恩德（Martin Ender）为这些列表找到一条简单的规则时，几乎每个答案都以一种或另一种方式实现了相同的解决方案。看到原始方法很酷。:)
— AJFaraday '18
感谢您的反馈。:)在尝试我的解决方案之前，我没有阅读其他解决方案。.也许还有一个更优雅的解决方案有待发现..我希望它们都具有独特的长度，然后才是The Solution。
— 李
2
string t(string w)=>可以公正w=>。我可以将'p'其他字符转换为它们的int表示形式。您可以删除尾随的半冒号
— TheLethalCoder
3

Python，59个字节

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

在线尝试！

使用ovs的Python答案中的索引，但选择函数更简单，更短：

如果单词的第十个字母（w带换行符（(w*4)[9]- w*4重复w四次））是单词tin（in"tin"）中的字母，则该单词为Tinny；否则，如果第三个字母（w[2]）是a（<'b'），则该单词为PVC否则这个词是木质的。

...这59做同样的工作：

lambda w:"wtPoiVonCdn yy"[[(w*4)[9]in"tin",2][w[2]<"b"]::3]
— 乔纳森·艾伦
source
2

C，107字节

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

在线尝试！

— 稳定箱
source
2

批处理，145字节

@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

在STDIN上输入。说明：检查后leap，细小的单词要么以字母之一开头a，n要么r是第二个字母为i。

— 尼尔
source
2

CJam，35个字节

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

在线尝试！

我完全忘记了我已经开始蛮力搜索短表达式以将木质和细小的字符串散列为两个类。我刚刚找到了运行搜索的控制台窗口，事实证明它实际上找到了一些东西...

说明

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.
— 马丁·恩德
source
1

Excel，81个字节

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

使用“厌倦”方法。

— 韦尼施
source
1

JavaScript中，60，50

编辑我看到了所有其他正则表达式的答案。我想我只是瞎子。无论如何，这是使用相同正则表达式的

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

而且，现在，它胜过了其他JS答案

片段：

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"));
展开摘要

旧答案

我还没有看到正则表达式，所以我想尝试一下

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

不知道这是否等于或大于60，因为我没有包括return语句。当我上电脑时会添加一个代码段

编辑：片段

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
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.