वुडी शब्द, टिनि शब्द

Question

नोट: इस प्रश्न में कुछ अशिष्ट शब्द हैं।

इस क्लासिक मोंटी पाइथन स्केच में एक अंतर्निहित पहेली है (आप ऑनलाइन स्क्रिप्ट भी तैयार कर सकते हैं )।

विभिन्न वाक्यांशों को 'वुडी' या 'टिन्नी' के रूप में वर्णित किया जाता है, और एक को 'पीवीसी' के रूप में वर्णित किया जाता है।

एक वाक्यांश को देखते हुए, निम्न सूचियों के अनुसार इसके प्रकार के साथ उत्तर दें:

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, तदनुसार होना चाहिए ।
• सभी इनपुट लोअर केस है।
• कोई भी व्यवहार उन वाक्यांशों के लिए स्वीकार्य है जो ऊपर सूचीबद्ध नहीं हैं।
• उत्तर में सबसे कम बाइट्स जीतता है।

Comments

@AJFaraday मैं साइट पर कुछ समय बिताने की सलाह दूंगा और चुनौतियों को लिखने के कठिन कार्य को शुरू करने से पहले कुछ सवालों के जवाब दूंगा। जब आप तैयार महसूस करते हैं , तो सैंडबॉक्स का उपयोग करें , कम से कम अपनी पहली कुछ चुनौतियों के लिए और किसी भी गैर-तुच्छ चुनौतियों के लिए भी।

— आदम

मुझे वह सिफारिश बिल्कुल पसंद नहीं है! कृपया चुनौतियां पोस्ट करना जारी रखें, भले ही आपको जवाब देना पसंद न हो। साइट को महसूस करने के लिए अन्य चुनौतियों को देखना निश्चित रूप से अच्छा है, और मैं सैंडबॉक्स को भी सुझाता हूं, लेकिन कृपया चुनौतियों को लिखना जारी रखें! :)

— स्टीवी ग्रिफिन

तो, हम एक मोंटी पायथन स्केच के लिए तर्क लागू कर रहे हैं? ...अति उत्कृष्ट!

— ब्रूसवेने

@ ब्रूसवेने ठीक वही है जो हम कर रहे हैं।

— AJFaraday

You may choose how to deal (or ignore) with casing in input and output.स्पष्ट करने के लिए, क्या इसका मतलब है कि हम इनपुट को अपरकेस में होने की उम्मीद कर सकते हैं?

— Οurous

Answer 1

स्टैक्स , 30 25 बाइट्स

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

इसे चलाएं और डीबग करें

यह टिप्पणी एससीआई का प्रतिनिधित्व करती है। मैंने इस एल्गोरिथ्म का आविष्कार नहीं किया। यह बेशर्मी से जोनाथन एलन के अजगर समाधान से फट गया है ।

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

इसको चलाओ

Comments

यह उत्तर ठीक है, लेकिन स्ट्रिंग शाब्दिक कंप्रेसर छोटी गाड़ी है, यह कभी-कभी 5-वर्ण लंबे परिणाम (यदि आप `, 7 को शामिल करते हैं) को 4-वर्ण लंबे तार के लिए उत्पन्न करते हैं।

— वीजुन झोउ

संपीड़न हमेशा एक छोटे परिणाम का उत्पादन करने की गारंटी नहीं है। बस आमतौर पर अंग्रेजी तार के लिए। वह बग नहीं है। यदि आपके पास एक मामला है जहां एक डबल उद्धृत स्ट्रिंग छोटा है, तो इसके बजाय बस का उपयोग करें।

— पुनरावर्ती

मुझे लगा कि यह जेली की तरह है जिसे हमेशा सबसे छोटा प्रतिनिधित्व मिलता है (शायद वर्णन फिर से होना चाहिए?)

— वीज़ुन झोउ

कोई बात नहीं। मुझे लगता है कि कहना can help youथोड़ा भ्रमित करने वाला है लेकिन तार्किक रूप से ठीक है।

— वीजुन झोउ

हम्म, हाँ, शब्दांकन भ्रामक है।

— पुनरावर्ती

Answer 2

पायथन 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]

Comments

एक अजगर अजगर चुनौती को हल करने के लिए अजगर का उपयोग करने के कारण अपवित्र।

— ब्रेन गाइडर

@AnderBiguri, कृपया उपयोग किए गए भाषा के बजाय समाधान के आधार पर अपना वोट डालें।

— शैगी

@ भाषा AFAIK भाषा का चुनाव PPCG के मज़ेदार हिस्सों में से एक है! मुझे समाधान पसंद है, क्योंकि अजगर में इसका । हमारे पास पहले से ही यह देखने के लिए बाइट्स हैं कि कौन एक "जीतता है"

— ब्रेन गाइडर

हां, कोडगोल्फ में वोट केवल सबसे अच्छे या सबसे रचनात्मक माने जाने वाले दृष्टिकोण के लिए होना चाहिए क्योंकि विजेता अन्यथा निर्धारित होता है। इसके अलावा यह उबाऊ हो जाएगा अगर हर कोई सिर्फ विशेष codegolf भाषाओं का उपयोग करने के बजाय अधिक आम लोगों के साथ रचनात्मक होने का

— Gimli

मैं मानता हूं, किसी विशेष उत्तर को पसंद करने के कई कारण हो सकते हैं। लेकिन भले ही लोग "अजगर के लिए मोंटी पायथन" की सजा से बहुत उत्साहित हों, यह देखकर अभी भी दुख होता है कि अपवित्र थोड़ा नीचे स्क्रॉल करने के लिए परेशान नहीं करते हैं, और एक और पायथन जवाब की सराहना करते हैं जो वास्तव में अधिक अपरंपरागत है और यहां तक ​​कि tad छोटा ...

— Kirill L

Answer 3

पायथन 2 , 62 बाइट्स

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

इसे ऑनलाइन आज़माएं!

कैसे?

यह सबमिशन इस तथ्य का उपयोग करता है कि hashपायथन 2 में तार के लिए फ़ंक्शन स्थिर है। प्रत्येक वैध इनपुट में एक वैध आउटपुट है। सभी टिन और पीवीसी शब्दों के लिए और वुडी शब्दों के लिए ब्रूट-मजबूर दोहराया मोडुलो %97%78%28%15%2रिटर्न । इसके मूल्य को जोड़कर , हम इनपुट 'लीप' के बदले प्राप्त करते हैं । यहां सभी मानों की तालिका दी गई है:10('ea' in n)21

+----------------+----------------------+----------------+-------------+-------+
| 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'परिकलित अनुक्रमणिका पर प्रारंभ करके वापसी का प्रकार अब प्रत्येक तीसरे वर्ण को लेते हुए स्ट्रिंग से निकाला जाता है ।

Answer 4

जावास्क्रिप्ट (ईएस 6), क्रोम / एज, 54 बाइट्स

क्योंकि parseInt()36 के मूलांक वाले बड़े इनपुट पर व्यवहार कार्यान्वयन-निर्भर है , इसलिए यह स्पाइडरमोंकी (फ़ायरफ़ॉक्स) के साथ काम नहीं करता है।

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

इसे ऑनलाइन आज़माएं!

कैसे?

हैश फंक्शन 3 शब्दों के लिए वापस आता है , 1 टिन के लिए और या तो 0 , 4 , 5 या 6 वुडी शब्दों के लिए। तारांकन चिह्न के साथ चिह्नित शब्दों को संक्षेप में काट दिया जाता है क्योंकि अंतरिक्ष को पार्सइंट () द्वारा अमान्य वर्ण माना जाता है ।

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]

इसे ऑनलाइन आज़माएं!

कैसे?

नीचे प्रत्येक इनपुट के लिए फ़ंक्शन के विभिन्न चरण हैं। पहले मोडुलो का परिणाम जेएस संख्या की सटीकता के भीतर एक अनुमान है और संभोग के लिए गणितीय रूप से अमान्य है ।

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

Answer 5

रेटिना , 39 38 36 बाइट्स

Adám के उत्तर में तीन प्रतिस्थापन जोड़े का उपयोग करके 1 बाइट को बचाया।

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

इसे ऑनलाइन आज़माएं!

मुझे पीटर नॉर्विग के रेगेक्स गोल्फर.p.|is*t से रेगेक्स मिला ।

Comments

उह ओह, सर्कुलर अटेंशन।

— आदम

Answer 6

जावा 8, 81 80 67 बाइट्स

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

Regex @MatrinEnder के रेटिना उत्तर से।

इसे ऑनलाइन आज़माएं।

मूल उत्तर: 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शब्द के ऊपर इस स्ट्रिंग में मौजूद हैं, और न ही है leसे leap।
2. किसी भी woodyशब्द के पास एक aतीसरा अक्षर नहीं है, इसलिए इसका उपयोग यह पाने के leapलिए किया जाता है कि PVCयह एक tinnyशब्द नहीं है ।
3. बाकी सब कुछ woodyसूची से एक शब्द है ।

Comments

यह इस समस्या को सुलझाने वाली सोच के माध्यम से पढ़ने में सक्षम होने के लिए बहुत अच्छा है :)

— AJFaraday

Answer 7

हास्केल , 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

लिन ने leapअपने पहले अक्षर से जाँच कर एक बाइट को बचाया ।

Comments

अच्छा! आप पता लगाने के द्वारा एक बाइट बचा सकता है "leap"के साथ |a=='l'="PVC"।

— लिन

Answer 8

क्वाड्स , 34 32 बाइट्स

बेशर्मी से मार्टिन एंडर के सिस्टम का उपयोग करता है , जिसमें पीटर नॉरविग के रेगेक्स गोल्फर से रेगेक्स भी शामिल है ।

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

इसे ऑनलाइन आज़माएं!

⊃⍵ की पहली घटना उठाओ

ea "ea"
.p.|is?t "p" अक्षर या "i" से घिरा हुआ है और
$ इनपुट के अंत में उनके बीच एक वैकल्पिक "s" है

... लेकिन निम्नलिखित में से किसी एक के साथ मिलानों को प्रतिस्थापित करना:

PVC
tinny
woody

---

बराबर 43-बाइट Dyalog APL फ़ंक्शन है:

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

ऑनलाइन सभी मामलों की कोशिश करो!

Answer 9

सी (जीसीसी) , 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 निश्चित रूप से वहाँ है इसे मुद्रण योग्य ASIIII स्तर तक लाने के लिए। इससे निम्नलिखित जानकारी उत्पन्न हुई (तालिकाओं को क्रमबद्ध किया गया, लेकिन परिणामी तार नहीं):

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

हैश टकराव कोई फर्क नहीं पड़ता, क्योंकि वे एक ही श्रेणी के लिए सीमित हैं। हमें केवल यह जांचना होगा कि क्या परिणामी हैश टिनि हैश स्ट्रिंग ("HzYfPW") में है, क्योंकि वुडी हैश सभी पीवीसी हैश (120) से नीचे हैं। यदि 120 या उच्चतर है, और टिनि शब्द नहीं है, तो उसे पीवीसी होना चाहिए। यदि टिनि शब्द नहीं है, और हैश 120 से नीचे है, तो यह एक अच्छा, वुडी प्रकार का शब्द होना चाहिए।

Answer 10

x86 32-बिट मशीन कोड, 39 बाइट्स

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

हैश फ़ंक्शन एक "जादू" संख्या से गुणा है 0x2c616f47। केवल 6 नंबर हैं जो इस कोड के साथ उपयोग किए जा सकते हैं।

सबसे पहले, यह 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;

Answer 11

जेली ,  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"

Answer 12

हास्केल , 75 बाइट्स

-2 बाइट्स लाईकोनी के लिए धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

RIP enklact।

Comments

f"leap"="PVC";f s|से छोटा है f s|s=="leap"="PVC"|।

— लैकोनी

Answer 13

डर्टी , 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)

अन्यथा, यह जाँचता है कि क्या स्ट्रिंग "नर" से शुरू होती है:

Ẃ           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

Answer 14

सी # 97 बाइट्स

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

मैं स्ट्रिंग्स की लंबाई में एक पैटर्न की तलाश में गया और पाया कि वे 4 और 8 की लंबाई को छोड़कर अद्वितीय हैं। इसलिए मैं पहले पात्रों को देखकर विशेष मामला करता हूं। ओह ठीक है, यह अभी भी कुछ जवाबों से छोटा है। :)

Comments

तुम्हें पता है, जब मार्टिन एंडर ने इन सूचियों के लिए एक सरल नियम पाया, बस हर उत्तर के बारे में उसी समाधान को लागू किया, एक ही रास्ता या कोई अन्य। यह एक मूल दृष्टिकोण देखने के लिए अच्छा है। :)

— AJFaraday

प्रतिक्रिया के लिए धन्यवाद। :) मैंने अपना प्रयास करने से पहले अन्य समाधान नहीं पढ़ा था .. शायद अभी भी एक और अधिक सुरुचिपूर्ण समाधान अभी तक खोजा जा रहा है .. मैं चाहता हूं कि वे सभी अद्वितीय लंबाई थे तो यह समाधान होगा।

— ली

string t(string w)=>बस हो सकता है w=>। 'p'मुझे लगता है कि आप अपने अंतर अभ्यावेदन के लिए अन्य पात्रों को परिवर्तित कर सकते हैं । आप पीछे चल रहे अर्ध

— उपनिवेश

Answer 15

पायथन , 59 बाइट्स

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

इसे ऑनलाइन आज़माएं!

ओव्स पाइथन उत्तर से अनुक्रमण का उपयोग करता है, लेकिन एक सरल और कम विकल्प फ़ंक्शन:

यदि शब्द का दसवां अक्षर w, रैपिंग के साथ ( (w*4)[9]- जहां चार बार w*4दोहराता wहै) शब्द टिन में एक अक्षर है ( in"tin") तो शब्द टिन् है , अन्यथा यदि तीसरा अक्षर ( w[2]) एक है ( <'b') तो शब्द पीवीसी है अन्यथा शब्द वुडी है ।

... यह 59 एक ही काम करता है:

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

Answer 16

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

इसे ऑनलाइन आज़माएं!

Answer 17

बैच, 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।

Answer 18

सीजेएम , 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.

Answer 19

एक्सेल, 81 बाइट्स

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

'एनेटिसिलर' पद्धति का उपयोग करना।

Answer 20

जाप , ३६ 34 बाइट्स

मार्टिन के रेटिना समाधान से एक RegEx का उपयोग करता है।

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

कोशिश करो | सभी परीक्षण मामलों की जाँच करें

Answer 21

जावास्क्रिप्ट, 60 , 50

EDIT मैंने अन्य सभी रेगेक्स उत्तर देखे। मुझे लगता है कि मैं सिर्फ अंधा हूं। वैसे भी, यहाँ एक ही regex का उपयोग कर रहा है

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

इसके अलावा, अब, यह अन्य जेएस जवाब धड़कता है

स्निपेट:

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 या अधिक के रूप में गिना जाता है क्योंकि मैंने रिटर्न स्टेटमेंट शामिल नहीं किया है। जब मैं अपने कंप्यूटर पर एक स्निपेट जोड़ूंगा

संपादित करें: स्निपेट

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