यह संज्ञा है या नहीं?

22

इनपुट के रूप में एक स्ट्रिंग को देखते हुए, यह निर्धारित करें कि यह एक संज्ञा है या नहीं।

आपको 1000 सबसे आम अंग्रेजी शब्दों पर स्कोर किया जाएगा, कितने आप सही ढंग से संज्ञा के रूप में लेबल करते हैं या नहीं।

प्रोग्राम या फ़ंक्शन जो 50 बाइट्स या उससे कम में सबसे अधिक शब्दों को सही ढंग से वर्गीकृत करता है वह जीत जाएगा।

संज्ञा

संज्ञा एक शब्द है जो आम तौर पर एक चीज़ का प्रतिनिधित्व करता है। यह अधिक जटिल हो जाता है, लेकिन यह मूल विचार है।

उन मामलों में जहां एक शब्द या तो एक संज्ञा या भाषण के कुछ अन्य भाग हो सकता है, मैंने इसे एक संज्ञा के रूप में वर्गीकृत किया, भले ही वह एक दुर्लभ उपयोग हो। या वास्तव में, मैंने इस साइट को मेरे लिए करने दिया।

आपके द्वारा बनाए गए शब्द ये 1000 सामान्य शब्द हैं , जो "दो" और "एक बार" जोड़े जाने के साथ, साधारण विकिपीडिया से हैं । उनमें से, ये 586 संज्ञाएं हैं , और ये 414 संज्ञाएं हैं । आप तीनों सूची यहां पा सकते हैं । ध्यान दें कि ये सभी इनपुट निम्न स्थिति में हैं। ये सूचियां अंतिम हैं - व्याकरण पर बहस करने की कोशिश न करें।

आपका कार्यक्रम सही माना जाएगा अगर यह एक आउटपुट truthy एक इनपुट जो एक संज्ञा है, और एक इनपुट पर एक falsy परिणाम जो एक संज्ञा नहीं है पर परिणाम।

बारीकियों:

कार्यक्रम एक निर्धारक उत्पादन होना चाहिए। यदि आप यादृच्छिकता का उपयोग करना चाहते हैं, तो इसे बीज दें। प्रोग्राम में अंतर्निहित संज्ञा सूचियों या अन्य अंतर्निहित पार्ट-ऑफ़-स्पीच कार्यक्षमता का उपयोग करने की अनुमति नहीं है।

उदाहरण:

a: noun
act: noun
active: noun
about: non-noun
above: non-noun
across: non-noun

कृपया बताएं कि आपके कार्यक्रम की सफलता की दर आपके उत्तर में क्या है। उच्चतम सफलता दर जीत के साथ अधिकतम 50 बाइट्स का कार्यक्रम या कार्य। एक टाई के मामले में, सबसे कम बाइट गिनती एक विजेता का निर्धारण करेगी। सौभाग्य!

code-challenge  decision-problem  natural-language  test-battery 
— isaacg
स्रोत

जवाबों:

13

जावास्क्रिप्ट (ईएस 6), 43 बाइट्स, 622 630 633

बस गेंद लुढ़कने के लिए है। 1संज्ञा के लिए रिटर्न , 0गैर-संज्ञा के लिए।

s=>2552>>s.length&/^[bcdf-mp-tvwy]/.test(s)

कैसे?

हम संज्ञा पर शर्त लगाते हैं यदि दोनों निम्नलिखित शर्तें पूरी होती हैं:

  1. शब्द की लंबाई 3, 4, 5, 6, 7, 8 या 11. यह द्विआधारी संख्या 100111111000 (दशमलव के रूप में 2552) को राइट-शिफ्टिंग द्वारा किया जाता है।
  2. शब्द इन अक्षरों में से एक से शुरू होता है: bcdfghijklmpqrstvwy
— Arnauld
स्रोत
जैसा कि मैं जेएस के साथ विशेष रूप से ध्यान में रखते हुए टिप्पणी करने वाला था, कि बाइट सीमा बहुत अधिक प्रतिबंधात्मक थी, आप इसे पोस्ट करते हैं! मैं इस सूची को देखे बिना सोच रहा था, कि 586 से बेहतर स्कोर पहले अक्षर या प्रत्येक शब्द में 2 का परीक्षण करके संभव हो सकता है। अच्छी तरह से किया :)
— शैगी
जावास्क्रिप्ट के साथ कम परिचित लोगों के लिए एक स्पष्टीकरण अच्छा होगा। जहाँ तक मैं बता सकता हूँ, यह जाँचता है कि शब्द की लंबाई 3, 4, 5, 6, 7, 8 या 11 है, और शब्द भी अक्षरों के एक सेट से शुरू होता है?
— isaacg
@ आइसाकग यह सही है। स्पष्टीकरण जोड़ा गया।
— अरण्युलद
4
ध्यान दें कि वर्ण वर्ग वर्ग [bcdf-mp-tvwy]के बराबर है [^aenouxz]। एक परिवर्तन से 4 बाइट्स बचेंगे, जिन्हें पूंजीकरण किया जा सकता है।
— फायरफ्लेम २४१ १
@ fireflame241 बहुत सही है। और इसे छोटा भी किया जा सकता है [^aenouz]क्योंकि हमारे पास कोई भी शब्द नहीं है जो a से शुरू होता है x।
— अरण्युलड
11

जेली , 48 बाइट्स, स्कोर 731

यह जेली में मेरा पहला उत्तर है और मुझे इसे एक साथ रखने में बहुत परेशानी हुई। आह ठीक है ... यह मजेदार था। :-)

O‘ḅ⁹%⁽€Oæ»4“Ạ$ⱮẊḲḲLÑMṆụ⁻ẉṂ`ŻvḤæɠ5ṭȯƁU*×TdƲḥ`’æ»Ḃ

1 बाईट ने @JonathanAllan को धन्यवाद दिया

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

ब्रेकडाउन और टेस्ट सूट

  • गैर संज्ञा को गैर संज्ञा के रूप में सही ढंग से पहचाना गया: 265/414 (64%)
  • संज्ञा के रूप में सही ढंग से पहचाने जाने वाले संज्ञा: 466/586 (79.5%)

कैसे?

हम पहले इनपुट स्ट्रिंग के हैश की गणना करते हैं:

  • आधार-256 अंक के रूप में प्रत्येक कोड बिंदु की व्याख्या करके इसे एक पूर्णांक में परिवर्तित करना
  • मॉड्यूल 4080 लागू करना (12 से अधिक बिट्स के साथ सबसे कुशल मूल्य के रूप में चुना गया)
  • परिणाम के 8 सबसे महत्वपूर्ण बिट्स रखते हुए

यह हमें [0 ... 255] में एक इंडेक्स के साथ छोड़ देता है और इस तरह सभी शब्दों को 256 समूहों में विभाजित करता है।

शब्दों के प्रत्येक समूह के लिए, हम एक बाइनरी ध्वज की पूर्व-गणना करते हैं, जो 1कि समूह में गैर-संज्ञा की तुलना में अधिक संज्ञाएं हैं, और 0अन्यथा। यह एक 256-बिट नंबर N की ओर जाता है जिसे हम लुकअप-टेबल के रूप में उपयोग करने जा रहे हैं। हम इसे एक आधार -50 एनकोडेड स्ट्रिंग के रूप में संग्रहीत करते हैं।

नीचे N का बाइनरी प्रतिनिधित्व है ।

1000011000001011000101111011111001001101110010101101110010001101
0000010001101010010111110001110010010101110110110010111111010000
0001111010011110000110101011111000011110111011010011011110101100
1010010110101111000010101000101100000001110110100011111000101010

जिसे “Ạ$ⱮẊḲḲLÑMṆụ⁻ẉṂ`ŻvḤæɠ5ṭȯƁU*×TdƲḥ`’जेली के रूप में संग्रहित किया जा सकता है ।

इसलिए कोड:

O‘ḅ⁹%⁽€Oæ»4“Ạ$ⱮẊḲḲLÑMṆụ⁻ẉṂ`ŻvḤæɠ5ṭȯƁU*×TdƲḥ`’æ»Ḃ    main link

O                                                   convert the input string to a list of
                                                    code points
 ‘                                                  increment each of them
  ḅ⁹                                                convert from base 256 to an integer
    %⁽€O                                            modulo 4080
        æ»4                                         drop the 4 least significant bits
           “Ạ$ⱮẊḲḲLÑMṆụ⁻ẉṂ`ŻvḤæɠ5ṭȯƁU*×TdƲḥ`’æ»     right shift N by this amount
                                               Ḃ    test the least significant bit
— Arnauld
स्रोत
अच्छी नौकरी! के साथ बूट करने के लिए एक बाइट सहेजें O‘ḅ⁹%⁽€Oæ»4“Ạ$ⱮẊḲḲLÑMṆụ⁻ẉṂ`ŻvḤæɠ5ṭȯƁU*×TdƲḥ`’æ»Ḃ(यह भी ध्यान रखें कि आप टीआईओ पर पाद का उपयोग कर सकते हैं, मैं आपके दो टेस्ट सूट के लिए Ç€¬S,Lऔर साथ जाऊंगा Ç€S,L।
— जोनाथन एलन
@JonathanAllan सुझावों के लिए धन्यवाद!
— अरनौलड
10

जावास्क्रिप्ट (ईएस 6), 50 बाइट्स, स्कोर 693

s=>!/^([aouz]|th|..$)|e.+[ey]|[flo].r|a.p/.test(s)

बस किसी भी संभव पैटर्न की तलाश है जिसमें गैर-संज्ञाएं हैं जो संज्ञाएं नहीं हैं।

गैर-संज्ञा में अधिक बार शामिल होते हैं:

  1. पहला अक्षर के रूप में a, o, u, या z
  2. वें पहले दो अक्षरों के रूप में।
  3. केवल दो अक्षर। [सर्वनाम (मुझे, हम, हमें, वह, यह) और पूर्वसर्ग (के, से, पर, पर, पर, ऊपर, ...) के बारे में सोचो।
  4. ई , एक या एक से अधिक अक्षर, उसके बाद ई या वाई ।
  5. च, एल, या ओ , किसी भी पत्र के बाद, उसके बाद आर ।
  6. ए , किसी भी पत्र के बाद, पी के बाद ।

स्निपेट:

कोड स्निपेट दिखाएं

— रिक हिचकॉक
स्रोत
मेरा मानना है कि आप करने के लिए पहले regex बदलकर एक बाइट बचा सकता है /h|n/(या करने से /^.[hn]/.test(s)बदलकर), और एक अन्य s[2]>''के लिए या तो !!s[2]या 2 in s।
— ETHproductions
धन्यवाद, @ETHproductions मैं आपके सुझावों का उपयोग कर सकता हूं और बाइट्स का एक गुच्छा बचाने के लिए दो परीक्षणों को संयोजित कर सकता हूं , जिससे मुझे अपना स्कोर सुधारने के लिए कोड जोड़ने की अनुमति मिली।
— रिक हिचकॉक
क्या a.pआपके पास पहले से ही निरर्थक नहीं है [aouz]?
— AdmBorkBork
@AdmBorkBork, एक में [aouz]केवल जब स्ट्रिंग की शुरुआत में मिलान किया जाता है। जो भी कारण के लिए, स्ट्रिंग में a.p कहीं भी परीक्षण करने से स्कोर में सुधार होता है।
— रिक हिचकॉक
10

जेली , 50 बाइट्स , स्कोर 763

अब एक हैश का उपयोग करना ( अर्नुल्ड के जेली उत्तर की तरह )

OP%⁽Wpị“!ḋGẠ⁻Ṭȥʋt|Ḥ\⁾°½İ@G2ḂƑ½ịʂ¶ɦḲ⁷³Hz~⁵p9)⁹ƙ¿’B¤

यह ऑनलाइन की कोशिश करो!

250/414 के लिए गैर संज्ञा
513/586 के लिए संज्ञा
कुल = 250 + 513 = 763।

कैसे?

308 प्रविष्टियों के साथ एक तालिका बनाता है, या तो 1 (एक संज्ञा की पहचान) या 0 (एक गैर संज्ञा की पहचान) और एक हैश फ़ंक्शन द्वारा प्रदान की गई कुंजी का उपयोग करके अनुक्रमित करता है जो इनपुट शब्द के अध्यादेशों के उत्पाद का उपयोग करता है:

OP%⁽Wpị“!ḋGẠ⁻Ṭȥʋt|Ḥ\⁾°½İ@G2ḂƑ½ịʂ¶ɦḲ⁷³Hz~⁵p9)⁹ƙ¿’B¤ - Link: list of characters, word
O                                                  - convert to ordinals
 P                                                 - product
   ⁽Wp                                             - base 250 number = 22863
  %                                                - modulo (by 22863)
                                                 ¤ - nilad plus link(s) as a nilad:
       “!ḋGẠ⁻Ṭȥʋt|Ḥ\⁾°½İ@G2ḂƑ½ịʂ¶ɦḲ⁷³Hz~⁵p9)⁹ƙ¿’   -   base 250 number
                                                B  -   as a binary list (308 bits)
      ị                                            - index into (1-indexed and modular,
                                                  -   so adds another modulo by 308)

पिछला:  50  47 बाइट्स , स्कोर 684

ḣ3Ẇf“QṘ°ḂżÐŒ#ḍæ09»s2¤Ȧ¬ȧØY⁾niyṖf⁽ż2ị$
0,-2ịE¬ȧÇ

एक शब्द लेने और एक चरित्र (सत्य) की एक सूची को वापस लेने के लिए एक मोनोडिक लिंक यदि शब्द को एक संज्ञा के रूप में पहचाना जाता है, या एक खाली सूची या शून्य (दोनों गलत) अगर यह नहीं है।

इसे ऑनलाइन आज़माएं! (पाद लेख प्रिंटNounयाNon-Noun)के परिणाम पर एक और प्रदर्शन करता है
... या स्कोरिंग प्रोग्राम देखें (दो सूचियों में सत्य सूचकांक को गिनता है और फिर स्कोर की गणना करता है)।

स्कोर ब्रेकडाउन: 462/586 संज्ञाओं की सही पहचान (124 गलत), 222/414 गैर-संज्ञाएं सही ढंग से पहचान (192 गलत) - कुल सही = 684/1000।

कैसे?

अगर यह एक संज्ञा नहीं है लगता है ...

  • अंतिम वर्ण और वर्ण दो इससे पहले के बराबर हैं (मॉड्यूलर और 1-आधारित अनुक्रमण के साथ)
  • या तो पहली दो लम्बाई 2 सब्सट्रिंग्स में हैं:
    'be', 'th', 'le', 'he', 'm ', 'ev', 'et', 's ', 'fl', 'ax', 'en', 'fo', 'am', 'az' (ध्यान दें: 'm 'और 's 'केवल संपीड़न को कम करने के लिए यहाँ हैं, लेकिन वे कभी भी दिखाई नहीं देते हैं)
  • -299 वें सूचकांक (मॉड्यूलर और 1-आधारित इंडेक्सिंग के साथ) में से कोई भी है:
    aenouyz(हालांकि यह विपरीत और अतिरिक्त पूंजी अक्षरों के साथ लागू किया जाता है)
    ... क्योंकि सभी शब्दों में 1 और 11 के बीच की लंबाई -299 वें सूचकांक के बराबर है इंडेक्स मैपिंग में लंबाई का उपयोग करने के लिए:{7:2; 8:5; 9:7; 11:9; else 1}

ḣ3Ẇf“QṘ°ḂżÐŒ#ḍæ09»s2¤Ȧ¬ȧØY⁾niyṖf⁽ż2ị$ - Link 1: list of characters, word
ḣ3                                    - head to index 3 (1st 3 characters, like 'abc')
  Ẇ                                   - all sublists (['a','b','c','ab','bc','abc']
                    ¤                 - nilad followed by link(s) as a nilad:
    “QṘ°ḂżÐŒ#ḍæ09»                    - compression of "bethlehem evets flaxenfoamaz"
                  s2                  - split into chunks of 2:
                                      -   be,th,le,he,m ,ev,et,s ,fl,ax,en,fo,am,az
   f                                  - filter keep (can only match 'ab' or 'bc')
                     Ȧ                - any and all (0 if empty, 1 if not)
                      ¬               - logical not
                        ØY            - consonant -y yield = "BCD...WXZbcd...wxz"
                          ⁾ni         - character pair = "ni" (no shrubbery for you!)
                             y        - translate (exchange the n for an i)
                              Ṗ       - pop (remove the z)
                       ȧ              - logical and
                                    $ - last two links as a monad:
                                ⁽ż2   -   base 250 literal = -299
                                   ị  -   index into the word
                               f      - filter keep

0,-2ịE¬ȧÇ - Main link: list of characters, word
0,-2      - pair zero with -2 = [0,-2]
    ị     - index into the word (last character and the one before the one before that)
     E    - all (both) equal?
      ¬   - logical not
        Ç - call the last link (1) as a monad
       ȧ  - logical and

13 बाइट्स, स्कोर: 638

पहला त्वरित बैश (ऊपर दिया गया)

ØY⁾niyṖf⁽ż2ị$
— जोनाथन एलन
स्रोत
0,-2इसका मतलब pair zero with -2यह नहीं हैliteral [0, -2]
— एरिक आउटगोल्फर
लेकिन इसका बहुत ही प्रभाव है: पी
— जोनाथन एलन
नहीं, यह 0,-2एक निलाद नहीं है, अलग नहीं है (0)(,)(-2)... बेशक यह इस मामले में समान प्रभाव है लेकिन हमेशा नहीं। मुझे पता चला कि कठिन तरीका ... और जो भी मामला मैं वैसे भी समझाना पसंद करूंगा कि वास्तव में एक ही प्रभाव या कुछ के साथ कुछ नहीं होता है।
— एरिक आउटगोल्फर
अगर मैंने "जोड़ी" के बजाय "जॉइन" लिखा है तो क्या आपने "नो जॉइन है j" टिप्पणी की होगी ?
— जोनाथन एलन
मैं थोड़ा सा पांडित्यपूर्ण हो सकता हूं, pairया joinस्पष्ट रूप से इसे वाक्यांश के गलत तरीके हैं, क्योंकि 0,-2,-6उदाहरण के लिए इसका मतलब नहीं है pair 0 with -2 and then pair that with -6 = [[0, -2], -6], बल्कि इसका मतलब है literal [0, -2, -6]। मैं इसे प्राप्त करता हूं, , परमाणु और ...,...(,...(...)) शाब्दिक भ्रामक हैं ... लेकिन स्टिल 0,-2,-6काफी नहीं है 0,-2;-6क्योंकि पूर्व 1 लिंक है और बाद वाला 3 लिंक है।
— एरिक आउटगोल्फर
2

जूलिया 34bytes, 609

f(w)=hash(w)&0x0800000000004808>0

मैं इन-बिल्ट हैश का उपयोग करके पात्रों को सहेजना चाहता था। मुझे ऐसा लगता है कि इसे बेहतर करने का एक तरीका होना चाहिए। जूलिया केवल बिट-बैंगिंग ऑपरेशन के साथ पर्याप्त रूप से अनुकूल नहीं है, जिसका उपयोग मैं यह बेहतर करने के लिए करना चाहता हूं।

उन्हें अलग करने के लिए हैश के लिए उपयुक्त बिटमैक्स ढूंढना एक दिलचस्प खेल है।

— लिंडन व्हाइट
स्रोत
सबसे अच्छा समाधान;)
— तमसागल
2

पायथन 2 , 50 बाइट्स, सटीकता: 596

lambda x:2<len(x)<7 or x[0]in"abcgmprs"or"st" in x

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

बस पहले अक्षर, लंबाई की जाँच करता है, और क्या "सेंट" शब्द में है कोड मानता है कि शब्द को x के रूप में परिभाषित किया गया है (संपादित करें: स्निपेट से फ़ंक्शन तक कोड फिक्स करने के लिए issacg का धन्यवाद)

— हुसैन रज़ा
स्रोत
नमस्ते, साइट पर आपका स्वागत है। हालांकि यह दिलचस्प है, प्रस्तुतियाँ या तो नीलामी या पूर्ण कार्यक्रमों के लिए आवश्यक हैं। यह एक स्निपेट है, जिसकी अनुमति नहीं है। यह देखें इसे ऑनलाइन आज़माएं! उसी कोड को निष्पादित करते समय इस स्निपेट को फ़ंक्शन में बदलने के तरीके के लिए लिंक।
— isaacg
2

हास्केल, 36 बाइट्स, 626 631

f x=length x>2&&x!!0`notElem`"aenou"
— BlackCap
स्रोत
643 अगर किसी के पास एक छोटी भाषा है:length x>2&&(x!!0`notElem`"aenou"||x!!1`elem`"acqrsty")
— ब्लैककैप
2

2-स्तरीय तर्क गेट कार्यान्वयन, 50 बाइट्स नहीं, स्कोर 1000

  1. बस दिए गए शब्द के बाइनरी प्रतिनिधित्व को 88 इनपुट पर प्लग करें

    1. यदि शब्द की लंबाई 11 से कम है, तो रिक्त स्थान पर इनपुट शब्द को पूरा करें
    2. इनपुट शब्द के प्रत्येक अक्षर के लिए 8-बिट ASCII कोड

  2. यदि शब्द संज्ञा है, तो सर्किट 1 लौटता है और यदि नहीं तो 0 देता है

  3. नीले रंग की धराशायी लाइनें कभी भी उपयोग किए गए इनपुट के लिए नहीं होती हैं

इस कार्यान्वयन की जरूरत है

  1. सभी इनवर्टर फाटकों को एन्कोड करने के लिए 48 ट्रांजिस्टर
  2. 1100 ट्रांजिस्टर सभी और फाटकों को सांकेतिक शब्दों में बदलना
  3. OR गेट को एनकोड करने के लिए 154 ट्रांजिस्टर
  4. कुल 1302 ट्रांजिस्टर जो 28 बाइट्स से कम का प्रतिनिधित्व करते हैं।

कुछ माप

  1. एक इन्वर्टर गेट को 1 ट्रांजिस्टर की जरूरत होती है
  2. एक 2-इनपुट सरल या गेट को 2 ट्रांजिस्टर की आवश्यकता होती है
  3. एक 2-इनपुट सरल और गेट को 2 ट्रांजिस्टर की आवश्यकता होती है
  4. एक बिट 6 ट्रांजिस्टर की जरूरत है

यहां छवि विवरण दर्ज करें

पूर्ण रिज़ॉल्यूशन सर्किट। पीपीडी यहाँ

पूर्ण रिज़ॉल्यूशन सर्किट। यहाँ क्लिक करें

— mdahmoune
स्रोत
2
क्या आप वास्तव में बता सकते हैं कि इस सर्किट को बाइट्स में एन्कोडिंग के लिए आपका सिस्टम क्या है? मैं बहुत उलझन में हूँ कि आप प्रति ट्रांजिस्टर 28 * 8/1302 = 0.17 बिट्स का उपयोग करने का दावा कैसे करते हैं।
— isaacg
जैसा कि मेरा समाधान एक बहुत ही निम्न स्तर का कंप्यूटर समाधान है (सॉफ्टवेयर के बजाय हार्डवेयर) मैं ट्रांजिस्टर पर अपनी बाइट की गिनती के आधार पर। देखने का फ्रॉ हार्डवेयर बिंदु, एक बीआईटी 6 ट्रांजिस्टर द्वारा एन्कोड किया गया है, इसलिए हम मान सकते हैं कि एक ट्रांजिस्टर 1/6 बिट (लगभग 0.17) का प्रतिनिधित्व करता है।
— mdahmoune
1
मैं आपकी बात समझता हूं, हालांकि 50 बाइट्स कोड स्रोत को एक ठोस हार्डवेयर (ट्रांजिस्टर आमतौर पर) पर मौजूद होना चाहिए
— mdahmoune
1
यह केवल एक दृष्टिकोण नहीं है - यह चुनौती की आवश्यकता है। कृपया अपने जवाब को गैर-प्रतिस्पर्धी के रूप में चिह्नित करें, क्योंकि यह इस चुनौती पर प्रतिस्पर्धा करने के लिए आवश्यकताओं को पूरा नहीं करता है।
— isaacg
2
इस समाधान को फिर से बनाने के लिए आवश्यक जानकारी का एक सरल, असम्पीडित बाइनरी एन्कोडिंग प्रत्येक लॉजिक गेट के प्रकार के लिए 2 बिट्स (3 अलग-अलग गेट्स) का उपयोग कर सकता है और प्रत्येक लॉजिक गेट के इनपुट (ओं) और आउटपुट के प्रत्येक पते के लिए 10 बिट्स (675 गेट्स प्लस) इनपुट्स और आउटपुट)। 2 * (48 + 550 + 77) + 10 * (2 * 48 + 3 * (550 + 77)) = 21120 बिट्स = 2640 बाइट्स।
— नन्नेस
1

पायथन 3, 50 बाइट्स, स्कोर 602

पायथन सबसे क्रिया भाषा नहीं है, लेकिन 50 बाइट कठिन है।

lambda x:all(x.count(y)<1for y in["ful","y","er"])
— L3viathan
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.