वे कहते हैं कि hateएक मजबूत शब्द है। मैं यह पता लगाना चाहता था कि क्यों, इसलिए मुझे इस शब्द पर एक अच्छी नज़र थी।

मैंने देखा कि प्रत्येक व्यंजन के बाद एक स्वर था। इससे यह मुझे काफी मजबूत लग रहा था, इसलिए मैंने फैसला किया कि यही एक शब्द को मजबूत बनाता है।

मैं अधिक मजबूत शब्द ढूंढना चाहता हूं, इसलिए मुझे इसके लिए एक कार्यक्रम की आवश्यकता होगी!

मजबूत शब्द ढूंढना

मजबूत शब्द ऐसे शब्द हैं जहां हर व्यंजन (सेट में अक्षर BCDFGHJKLMNPQRSTVWXZ) एक स्वर (सेट में अक्षर) द्वारा पीछा किया जाता है AEIOUY। बस। और कुछ मायने नहीं रखता है।

यदि शब्द एक स्वर से शुरू होता है, तो आपको पहले व्यंजन से पहले किसी भी पत्र के बारे में चिंता करने की आवश्यकता नहीं है। यदि शब्द में कोई व्यंजन नहीं है, तो यह स्वचालित रूप से एक मजबूत शब्द है!

मजबूत शब्दों के कुछ उदाहरण हैं agate, hateऔर you। agateअभी भी एक मजबूत शब्द है क्योंकि यद्यपि यह एक स्वर से शुरू होता है, फिर भी प्रत्येक व्यंजन का स्वर के साथ पालन किया जाता है। youएक मजबूत शब्द है क्योंकि इसमें कोई व्यंजन नहीं है।

मजबूत शब्दों के लिए लंबाई पर कोई प्रतिबंध नहीं है।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो इनपुट के रूप में एक गैर-रिक्त स्ट्रिंग लेता है, और एक सत्य मान को आउटपुट करता है यदि यह एक मजबूत शब्द या गलत मूल्य है यदि यह नहीं है।

स्पष्टीकरण

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

परीक्षण के मामलों

Input      -> Output
hate       -> true
love       -> true
popularize -> true
academy    -> true
you        -> true
mouse      -> true
acorn      -> false
nut        -> false
ah         -> false
strong     -> false
false      -> false
parakeet   -> false

स्कोरिंग

चूंकि यह कोड-गोल्फ है , कम से कम बाइट्स जीत के साथ जवाब!

code-golf string decision-problem

— LyricLy
स्रोत

सैंडबॉक्स

— LyricLy

1

क्या खाली शब्द ""एक संभावित इनपुट है?

— सिल्वियो मायोलो

@SilvioMayolo यह नहीं है।

— लाइरिकली

@LyricLy यदि इनपुट "अकादमी" है, तो आउटपुट झूठा होना चाहिए, जिस तरह से मैं समस्या को समझता हूं। क्योंकि Because म ’एक व्यंजन है।

— सत्य-

1

एक "केला" नफरत से भरा है

— jstnthms

18

जावास्क्रिप्ट (ईएस 6), 36 28 27 बाइट्स

^{परिणाम को प्राप्त करके 1 बाइट की बचत की, जैसा कि LarsW द्वारा सुझाया गया है}

लोअरकेस में इनपुट लेता है। रिटर्न falseएक मजबूत शब्द के लिए और trueएक गैर मजबूत शब्द के लिए।

s=>/[^aeiouy]{2}/.test(s+0)

कैसे?

हम 0इनपुट स्ट्रिंग के अंत में एक (गैर-स्वर) जोड़ते हैं और दो लगातार गैर-स्वर वर्णों की तलाश करते हैं। इससे हम दोनों मामलों को कवर कर सकते हैं जो एक शब्द को मजबूत नहीं बनाते हैं :

इसमें दो लगातार व्यंजन शामिल हैं
या यह एक व्यंजन के साथ समाप्त होता है

परीक्षण के मामलों

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

let f =

s=>/[^aeiouy]{2}/.test(s+0)

;[
  "hate", "love", "popularize", "academy", "you", "mouse", "a", "euouae",
  "acorn", "nut", "ah", "strong", "false", "parakeet"
]
.forEach(s => console.log(s + ' --> ' + f(s)))

Expand snippet

— Arnauld
स्रोत

+0हालांकि, क्यों ? इसके बिना ठीक काम करने लगता है

— मैथ्यूस एवलर

1

@MatheusAvellar बिना +0, यह एक व्यंजन के साथ समाप्त होने वाले शब्दों पर गलत सकारात्मक लौटाएगा।

— अरनुलद

मैं देखता हूं, अगर यह शब्द का अंतिम अक्षर है, तो इसे लगातार 2 गैर-स्वर नहीं मिल सकते हैं। होशियार!

— मैथ्यूज़ एवलर

आपको !(दो अलग-अलग मूल्यों) को छोड़ना चाहिए

— LarsW

@ लार्स धन्यवाद! मुझे यह नियम नज़र नहीं आया।

— अरनुलद

10

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

lambda s:'se, F'in`[v in'aeiouy'for v in s+'b']`

अनाम फ़ंक्शन (लोअरकेस) स्ट्रिंग ले रहा है s, और Falseयदि मजबूत है या Trueनहीं तो वापस लौट रहा है ।

इसे ऑनलाइन आज़माएं! (ओपी से मिलान करने के परिणामों को सम्मिलित करता है)

कैसे?

गैर-मजबूत शब्दों में या तो एक व्यंजन होता है, जिसके बाद एक व्यंजन होता है या एक व्यंजन में अंत होता है।

कोड अंत में एक व्यंजन जोड़ता है ( s+'b') आवश्यक परीक्षण करने के लिए एक पंक्ति में सिर्फ दो व्यंजन के लिए होना चाहिए।

यह पता चलता है कि क्या बदला हुआ शब्द का प्रत्येक अक्षर सूची समझ के साथ एक स्वर है [v in'aeiouy'for v in s+'b']।

अब इसे Falseएक पंक्ति में दो परिणामों की जांच करने की आवश्यकता है (एक गैर-मजबूत शब्द को इंगित करना), यह ऐसा `...`इस सूची के एक स्ट्रिंग प्रतिनिधित्व (उपयोग ) को प्राप्त करने और के अस्तित्व की तलाश करने से होता है 'se, F'। यह सबसे छोटा स्ट्रिंग पाया जाता है 'False, False', लेकिन में से कोई भी: 'True, True'; 'False, True'; या 'True, False'।

एक उदाहरण के रूप पर विचार 'nut', सूची समझ प्रत्येक अक्षर का मूल्यांकन करता है, v, की 'nutb'में अस्तित्व के लिए 'aeiouy'सूची उपज [False, True, False, False], इस सूची की स्ट्रिंग प्रतिनिधित्व है '[False, True, False, False]'जिसमें 'e, F'यहाँ: '[False, True, Fals>>e, F<<alse]'इसलिए समारोह रिटर्न Trueकि अखरोट अर्थ है नहीं एक मजबूत शब्द।

— जोनाथन एलन
स्रोत

7

जेली , 10 9 बाइट्स

e€ØY;Ạ11ẇ

पात्रों की सूची लेने और लौटने के लिए एक विचित्र लिंक:

0 अगर मजबूत है
1 अगर नहीं

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।

कैसे?

e€ØY;Ạ11ẇ - Link: list of characters, s      e.g. "hate"  or  "you"  or  "not"
  ØY      - consonant yield                   "BCDFGHJKLMNPQRSTVWXZbcdfghjklmnpqrstvwxz"
e€        - exists in? for €ach letter            [1,0,1,0]   [0,0,0]    [1,0,1]
     Ạ    - all truthy? (1 for any valid input)   1           1          1
    ;     - concatenate                           [1,0,1,0,1] [0,0,0,1]  [1,0,1,1]
      11  - literal eleven
        ẇ - sublist exists?                       0           0          1
          -  N.B.: left of ẇ implicitly makes digits so it looks for the sublist [1,1]

नोट: उपयोग करने का कारण Ạसिर्फ एक बाइट को उपयोग करने से बचाना है 1(क्योंकि हम इसके बाद 11सीधे उपयोग करना चाहते हैं )।

— जोनाथन एलन
स्रोत

हम्म, सुसंगत मूल्य ...

— आउटगॉल्फ

आपका मतलब क्या है?

— जोनाथन एलन

Ạअपने कोड में हैकी बात ... अन्यथा आप कर सकते थे e€ØY;1w11या कुछ और

— एरिक आउटग्राफर

ग्यारह क्यों? स्ट्रिंग शब्द किसी भी तरह से ग्यारह से बंधे नहीं लगते थे

— hyiltiz

@hyiltiz जब डाईएड ẇमें एक वाम तर्क होता है जो एक संख्या होती है, तो इसे अंकों की दशमलव सूची में बदल दिया जाता है, इसलिए ग्यारह बन जाता है [1,1]।

— जोनाथन एलन

5

05AB1E , 8 बाइट्स

कोड

žPS¡¦õÊP

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

व्याख्या

žPS¡         # Split the string on consonants (bcdfghjklmnpqrstvwxz)
    ¦        # Remove the first element of the array to handle cases when the
               string starts with a consonant
     õÊP     # Check if the empty string is not in the array

उदाहरण

             # "popularize"
žPS¡         # ['', 'o', 'u', 'a', 'i', 'e']
    ¦        # ['o', 'u', 'a', 'i', 'e']
     õÊ      # [1, 1, 1, 1, 1]
       P     # 1

— अदनान
स्रोत

शायद मुझे कुछ याद आ रहा है, लेकिन ऐसा लगता है कि हमेशा 1 वापसी? यह मेरे द्वारा आजमाए गए दोनों सत्य मामलों के लिए 1 रिटर्न देता है और झूठी गवाही देता है।

— सूंदर -

(ओह, मैंने अभी देखा कि यह उत्तर (और प्रश्न) कितना पुराना है। मुझे लगता है कि इस बीच भाषा में कुछ बदल गया है?)

— सूंदर - मोनिका

@ सुंदर हां अच्छा कैच! ऐसा लगता है कि मैंने कुछ बिंदु पर विभाजन समारोह को तोड़ दिया। मैं जल्द से जल्द इसे ठीक कर दूंगा।

— अदनान

5

आर , 43 बाइट्स

function(s)grep("[^aeiouy]{2}",paste(s,""))

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

अरनॉल्ड के जावास्क्रिप्ट उत्तर का एक बंदरगाह; कमजोर शब्दों के लिए और integer(0)मजबूत लोगों के लिए 1 रिटर्न ; यह स्ट्रिंग के अंत में एक (स्थान) जोड़ता है ।

यह वास्तव में सदिश है; स्ट्रिंग के वेक्टर के साथ, यह कमजोर शब्दों के सूचकांकों (1-आधारित) को वापस करता है।

— ग्यूसेप
स्रोत

यहाँ एक ही टिप्पणी, क्या आप एक स्थान जोड़ने के बजाय रेगेक्स में $ का उपयोग नहीं कर सकते हैं?

— चार्ली

@Charlie मुझे यकीन नहीं है कि आप कैसे उपयोग करने का इरादा रखते हैं $, यह समझाने के लिए परवाह है कि आगे?

— ग्यूसेप

इस समाधान की तरह। मुझे लगता है कि तर्क स्पष्ट है (और उसी के साथ बाइट करता है) paste0(s,0), लेकिन यह सिर्फ क्विबलिंग है। मुझे लगता है कि @ grep("[^aeiouy]([^aeiouy]|$)",s)

— चेरली

3

दिल्लोग एपीएल, 20 बाइट्स

⎕←∧/2∨/0,⍨⍞∊'aeiouy'

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

— ओबेरोन
स्रोत

3

मुझे नहीं लगता कि आपको जरूरत है ⎕←।

— ज़ाचारि

@ Zacharý मैं इसे नहीं डालता था, लेकिन मुझे बाद में कहा गया (डेनिस द्वारा, मेरा मानना है) कि एक कार्यक्रम को एक REPL में चलाने के लिए नहीं मान लेना चाहिए।

— ओबेरॉन

उसने आपको किस भाषा के बारे में बताया? क्या यह Dyalog APL के लिए था? मुझे पता है कि नीति निश्चित रूप से पायथन / जावास्क्रिप्ट / आदि के लिए लागू होती है।

— ज़ाचरी

3

हास्केल , 61 54 बाइट्स

f=and.(zipWith(||)=<<tail).(map(`elem`"aeiouy")).(++"z")

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

zअनुगामी व्यंजन के मामले को संभालने के लिए मुझे स्ट्रिंग के अंत में जोड़ना था ।

— jferard
स्रोत

2

जावा (ओपनजेडके 8) , 93 81 बाइट्स

s->{int w=0,p=w,l;for(char c:s)w|=p&(p=l="aeiouy".indexOf(c)>>31);return w+p>=0;}

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

— रॉबर्टो ग्राहम
स्रोत

मुझे डर है कि बूलियन इसका जवाब नहीं हैं s->{int w=0,p=w,l;for(char c:s){l="aeiouy".indexOf(c)>>31;w|=p&l;p=l;}return w+p>=0;}:।

— जैकब

1

या आप ऐसा भी कर सकते हैं:s->{int w=0,p=w,l;for(char c:s)w|=p&(p=l="aeiouy".indexOf(c)>>31);return w+p>=0;}

— जैकब

अच्छा जवाब, लेकिन इस चुनौती के साथ एक साधारण रेगेक्स-मिलान वास्तव में काफी छोटा है। फिर भी, मुझ से +1।

— केविन क्रूज़सेन

1

@ केविनक्रूजसेन मेरा रेगेक्स भयानक है, इसे काम करने के लिए नहीं मिला: डी। मैं दिखावा करूंगा कि मैं मूल बनना चाहता था

— रॉबर्टो ग्राहम

@ रॉबर्टो ग्राहम " मैं यह दिखावा करूंगा कि मैं मूल बनना चाहता था " खैर, यह निश्चित रूप से है। :) और मैं regex के रूप में अच्छी तरह से बहुत बुरा हुआ करता था, लेकिन पीपीसीजी पर यहाँ कुछ अन्य उत्तरों के बाद regex का उपयोग कर रहा हूँ, मुझे इसकी अधिक आदत है। और मुझे पहले से ही समझ में आ गया था कि [a-z&&[^aeiouy]] मेरा पिछले उत्तर में उपयोग करने वाले व्यंजन से कैसे मिलान किया जाए । ;)

— केविन क्रूज़सेन

2

भूसी , 12 बाइट्स

ΛΣX_2m€¨γaıu

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

-4 के साथ मदद के लिए H.PWiz को धन्यवाद । ~~असंगत लेकिन उचित रूप से सत्य या मिथ्या मूल्यों को लौटाता है।~~ -1
के लिए लियो के लिए धन्यवाद , अब लगातार सत्य / मिथ्या मूल्य देता है।

— आउटगोल्फर को एरिक करें
स्रोत

छोटा संकुचित तार । स्ट्रिंग संपीड़न अभी भी बहुत धीमा है, मुझे इस पर कुछ और काम करने की आवश्यकता है

— लियो

@ मुझे लगता है कि दुर्भाग्य से एक एनपी समस्या है।

— आउटगॉल्फ

2

पायथ , 18 बाइट्स

:+Q1."2}M>åYà

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

जेएस जवाब से रेगेक्स "उधार" । यह Falseमजबूत शब्दों के लिए लौटता है , Trueअन्यथा

— मिस्टर एक्सकोडर
स्रोत

@KevinCruijssen वास्तव में, Pyth ISO-8859-1 का उपयोग करता है। इसलिए मैं आश्वस्त नहीं हूं।

— मिस्टर एक्सकोडर

1

@ केविनक्रूजसेन डाउन्गोएट के यूजर्स ने मुझे बताया कि यह 13 बाइट्स है 13 ISO-8859-1 bytes, 13 chars:। मुझे लगता है कि ठीक होना चाहिए

— श्री एक्सकोडर

@ केविनक्रूजसेन को अब तय किया जाना चाहिए।

— श्री Xcoder

@ केविनक्रूजसेन मैं कोई अंतर नहीं देखता। मेरे उत्तर में आपको क्या कोड दिखाई देता है और आप मेरे परीक्षण लिंक में क्या कोड देखते हैं?

— श्री Xcoder

@ केविनक्रूजसेन लोल, यह आपके ब्राउज़र का फ़ॉन्ट है।

— श्री Xcoder

2

ब्रेकीलॉग , 18 11 10 बाइट्स

,Ḷs₂{¬∈Ẉ}ᵐ

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

नीट एंड सिंपल (अंतिम व्यंजन के मामले को संभालने के लिए 2 अतिरिक्त प्रारंभिक बाइट्स को छोड़कर, शायद "पैराकेट" की तरह)।

मजबूत शब्दों के लिए गलत है और गैर-मजबूत शब्दों के लिए सत्य है।

,Ḷ               % append a newline (non-vowel) at the end of input, 
                 %   to catch final consonants
     s₂          % the result has some substring of length 2
       {¬∈Ẉ}ᵐ    % where neither of its elements belong to  
                 %   the set of alternate vowels (with "y")

— sundar - मोनिका को बहाल करना
स्रोत

1

अजगर २ , 58 बाइट्स

-30 बाइट्स यह महसूस करके कि यह अरनॉल्ड के जेएस जवाब के समान सरल हो सकता है ।

lambda s:re.search('[^aeiouy]([^aeiouy]|$)',s)<1
import re

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

— totallyhuman
स्रोत

6 बाइट्स को वास्तव में Arnauld

— L3viathan

क्या आपको लैम्ब्डा को सोमिंग को असाइन करने की आवश्यकता नहीं है? अर्थातf=lambda s...

— OldBunny2800

@ OldBunny2800 जब तक आप अपने कोड के भीतर संदर्भ का उपयोग नहीं कर रहे हैं (यह एक अनाम फ़ंक्शन बनाने के लिए स्वीकार्य है जो हेडर या पाद कोड के साथ पुन: उपयोग के लिए उपयोग कर सकता है - यहां f=\एक हेडर के साथ)।

— जोनाथन एलन

मुझे लगता है कि आप 3 बाइट्स को बचाने के लिए अपने पैटर्न स्ट्रिंग '[^aeiouy]([^aeiouy]|$)'(24 बाइट्स) "[^aeiouy]("*2+")|$)"(21 बाइट्स) को बदलने में सक्षम हो सकते हैं , क्योंकि खाली समूह, ()खोज व्यवहार ( TIO ) को नहीं बदलता है ।

— जोनाथन फ्रीच

@JonathanFrech यह और भी बेहतर

— श्री एक्सकोडर

1

पर्ल 5, 31 बाइट्स (30 + 1)

$_=''if/[^aeiouy](?![aeiouy])/

-pकमांड लाइन ध्वज के लिए +1 बाइट । शब्द को प्रिंट करता है अगर यह एक मजबूत शब्द है, या खाली स्ट्रिंग नहीं है।

— सिल्वियो मायोलो
स्रोत

"दो अलग और सुसंगत मूल्य"

— L3viathan

@ L3viathan खाली तार झूठे हैं और गैर-खाली तार सत्य हैं। यह मान्य है।

— LyricLy

@ L3viathan Perl की सत्यता के नियम वास्तव में इस तरह की चुनौतियों के लिए बहुत अनुकूल हैं। यह पहली बार नहीं है जब मैंने उस सटीक तथ्य का दोहन किया है।

— सिल्वियो मेयोलो

नए शब्दों को समाप्त करने के साथ, इसे छोटा किया जा सकता है $_=$/if/[^aeiouy]{2}/।

— nwellnhof

1

जेली , 11 बाइट्स

e€ØY;1a2\¬Ȧ

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

e€ØY;1a2\¬Ȧ  Main link
 €           For each letter
e            Is it an element of
  ØY         The consonants (excluding Yy)?
    ;1       Append 1 (true) (consonant) to make sure last letter isn't consonant
       2\    For all (overlapping) slices of length 2 (the <link><nilad>\ functionality)
      a      Logical AND of the two values; is it a consonant pair?
         ¬   Logical NOT vectorizing; for each (overlapping) pair, is it not a consonant pair?
          Ȧ  Any and all; make sure all pairs are not consonant pairs

हां मुझे पता है कि मुझे जोनाथन एलन ने बहुत पीटा है लेकिन मैं अपने दृष्टिकोण को वैसे भी साझा करना चाहता था: पी

जोनाथन एलन के जवाब का एक छोटा सा चोरी करके -4 बाइट्स (अंतिम-अक्षर किनारे के मामले की जांच के लिए एक व्यंजन को जोड़ने के बजाय, सिर्फ 1 संलग्न करें)
-1 मील की दूरी के लिए धन्यवाद

— HyperNeutrino
स्रोत

आप a2\Ȧ2Ƥṡ2Ȧ€

— मील

@JonathanAllan facepalm I ने जानबूझकर यह सुनिश्चित करने के लिए उपयोग ØCकरने के लिए सुनिश्चित किया Yyथा कि इसे एक व्यंजन के रूप में गिना जाए क्योंकि किसी तरह मुझे पीछे की तरफ याद था। धन्यवाद!

— हाइपरएनुट्रीनो 1

1

अवाक, 39 बाइट्स

/([^aeiouy]{2}|[^aeiouy]$)/{print "n"}

nगैर-मजबूत के लिए प्रिंट , मजबूत के लिए कुछ भी नहीं (या, सिर्फ एक नई रेखा)

पैक का पालन करें और लोअरकेस इनपुट पर लगातार दो गैर-स्वरों की खोज करें

परिक्षण

$ awk -f strongwork.awk
hate
love
popularize
academy
you
mouse
acorn
n
nut
n
ah
n
strong
n
false
n
parakeet
n

— JoshRagem
स्रोत

1

Kotlin , 49 बाइट्स

{Regex(".*[^aeiouy]([^aeiouy].*|$)").matches(it)}

सच और झूठ की अदला-बदली होती है

सजा हुआ

{
    Regex(".*[^aeiouy]([^aeiouy].*|$)").matches(it)
}

परीक्षा

var s:(String)->Boolean =
{Regex(".*[^aeiouy]([^aeiouy].*|$)").matches(it)}
data class TestData(val input: String, val output: Boolean)

fun main(args: Array<String>) {
    val items = listOf(
            TestData("hate", true),
            TestData("love", true),
            TestData("popularize", true),
            TestData("academy", true),
            TestData("you", true),
            TestData("mouse", true),
            TestData("acorn", false),
            TestData("nut", false),
            TestData("ah", false),
            TestData("strong", false),
            TestData("false", false),
            TestData("parakeet", false)
    )

    items
            .filter { s(it.input) == it.output }
            .forEach { throw AssertionError(it.toString()) }

    println("Test Passed")
}

TryItOnline

@ अरनौल्ड के उत्तर के आधार पर

— jrtapsell
स्रोत

1

रेटिना , 23 18 बाइट्स

$
$
1`[^aeiouy]{2}

इसे ऑनलाइन आज़माएं! आउटपुट 0 मजबूत के लिए, 1 यदि नहीं। मिश्रित मामले का समर्थन करने के लिए 1 बाइट जोड़ें। संपादित करें: @ovs के लिए 5 बाइट्स का धन्यवाद सहेजा गया।

— नील
स्रोत

अंत तक एक व्यंजन को जोड़कर 18 बाइट्स ।

— 11

1

जावा 8, 53 42 बाइट्स

s->s.matches(".*[^aeiouy]([^aeiouy].*|$)")

-11 बाइट्स उसी रेगेक्स के रूप में @jrtapsell के कोटलिन उत्तर का उपयोग करकेइसके बजाय ।

इसे यहाँ आज़माएँ। ( falseअगर मजबूत;true यदि नहीं)

स्पष्टीकरण:

s->               // Method with String parameter and boolean return-type
  s.matches(      //  Checks if the String matches the following regex:
    ".*           //   One or more characters
     [^aeiouy]    //   Followed by a consonant
     ([^aeiouy].* //   Followed by another consonant (+ any more characters)
      |$)")       //   Or the end of the String
                  // End of method (implicit / single-line return statement)

तो यह मूल रूप से जांचता है कि क्या हम दो आसन्न व्यंजन मिल सकते हैं, या यदि स्ट्रिंग एक व्यंजन के साथ समाप्त होती है।

पुराना उत्तर ( 53 बाइट्स ):

s->s.matches("[aeiouy]*([a-z&&[^aeiouy]][aeiouy]+)*")

इसे यहाँ आज़माएँ। ( trueयदि मजबूत है,false यदि नहीं)

यह देखने के लिए regex का उपयोग करता है कि इनपुट-स्ट्रिंग 'strong'-regex से मेल खाती है या नहीं। ध्यान दें किString#matches जावा स्वचालित रूप ^...$से यह जांचने के लिए जोड़ता है कि क्या स्ट्रिंग दिए गए रेगेक्स से पूरी तरह मेल खाता है।

स्पष्टीकरण ":

 s->                   // Method with String parameter and boolean return-type
  s.matches(           //  Checks if the String matches the following regex:
    "[aeiouy]*         //   0 or more vowels
    ([a-z&&[^aeiouy]]  //     { A consonant,
     [aeiouy]+)        //       plus one or more vowels }
    *")                //    Repeated 0 or more times
                       // End of method (implicit / single-line return statement)

मैचों के बजाय एक खोज (जैसे बहुत से अन्य उत्तर उपयोग) वास्तव में जावा में अधिक लंबा है:
70 बाइट्स :

s->java.util.regex.Pattern.compile("[^aeiouy]{2}").matcher(s+0).find()

इसे यहाँ आज़माएँ।( falseयदि मजबूत है,true यदि नहीं)

— केविन क्रूज़सेन
स्रोत

1

माणिक , 25 बाइट्स

->w{w+?t!~/[^aeiouy]{2}/}

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

हर कोई इसे कर रहा है, तो रूबी क्यों नहीं कर सकती है?

— जीबी
स्रोत

0

SOGL V0.12 , 19 18 बाइट्स

æ"[^ŗy]”ŗ(ŗ|$)”øβ=

यह कोशिश करो!

स्पष्टीकरण:

æ                   push "aeiou"
 "[^ŗy]”            push "[^ŗy]" with ŗ replaced with pop
        ŗ(ŗ|$)”     push `ŗ(ŗ|$)` with ŗ replaced with pop
               øβ   replace in the input that regex with nothing
                 =  check for equality with the original input

— dzaima
स्रोत

0

05AB1E , 11 बाइट्स

žP¹SåJ1«11å

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

जोनाथन के एल्गोरिथ्म का उपयोग करता है, 0सच के लिए और 1झूठ के लिए रिटर्न ।

— आउटगोल्फर को एरिक करें
स्रोत

0

स्विफ्ट 3.1 , 85 बाइट्स

import Foundation
{($0+"0").range(of:"[^aeiouy]{2}",options:.regularExpression)==nil}

यहाँ कोशिश करो!

यह अरनॉल्ड के रेगेक्स को उधार लेता है ।

— मिस्टर एक्सकोडर
स्रोत

0

लुआ, 41 बाइट्स

return#(io.read()..0):match"[^aeiouy]+"<2

मानक इनपुट से पढ़ता है

लुआ (लोडस्ट्रिंग'एड), 37 बाइट्स

return#((...)..0):match"[^aeiouy]+"<2

फ़ंक्शन पैरामीटर से पढ़ता है

इनपुट लोअरकेस है

अगर कोई लंबाई 2 या अधिक है, तो न केवल स्वर (व्यंजन) या यदि स्ट्रिंग एक गैर स्वर के साथ समाप्त होता है

सच्चा / झूठा लौटाता है

— brianush1
स्रोत

0

सी ++, 195 194 बाइट्स

-1 बाइट्स Zacharý की बदौलत

अपरकेस, वापसी सही है यदि इनपुट एक मजबूत शब्द है, तो झूठा अन्यथा (C ++ में निहित अंतर्निहित नियम, 0 => गलत, सत्य अन्यथा सरल है)

#include<string>
#define C(p)(v.find(e[p])==size_t(-1))
std::string v="AEIOUY";int s(std::string e){for(int i=0;i<e.size()-1;++i)if(e[i]>64&&e[i]<91&&C(i)&&C(i+1))return 0;return!C(e.size()-1);}

परीक्षण के लिए कोड:

auto t = {
    "HATE",
    "LOVE",
    "POPULARIZE",
    "ACADEMY",
    "YOU",
    "MOUSE",
    "ACORN",
    "NUT",
    "AH",
    "STRONG",
    "FALSE",
    "PARAKEET"
};

for (auto&a : t) {
    std::cout << (s(a) ? "true" : "false") << '\n';
}

— HatsuPointerKun
स्रोत

1

आप के बीच की जगह को हटा सकते हैं returnऔर !।

— ज़ाचरी

0

सी, 107 बाइट्स

i,v,w,r,t;a(char*s){w=0;for(r=1;*s;s++){v=1;for(i=6;v&&i;)v=*s^" aeiouy"[i--];r=w&&v?0:r;w=v;}return r&~v;}

मजबूत शब्द के लिए 1 और कमजोर शब्द के लिए 0 रिटर्न । मुख्य पोस्ट में दिए गए शब्दों के साथ परीक्षण किया गया।

— Helco
स्रोत

0

सी (जीसीसी) , 59 बाइट्स

f(char*s){return*s?strcspn(s,"aeiouy")+!s[1]<2?f(s+1):0:1;}

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

— nwellnhof
स्रोत

0

PHP, 69 बाइट्स

preg_match("/([^AEIOUY][^AEIOUY]+|[^AEIOUY]$)/",$_SERVER['argv'][1]);

रिटर्न 1 है शब्द मजबूत नहीं है।

— मतियास विलानुएवा
स्रोत

PPCG में आपका स्वागत है! मेरा मानना है कि आप विशेष रूप से /", str-> /",strऔर [1]))) return-> कुछ बाइट्स को काटने के लिए रिक्त स्थान निकाल सकते हैं, [1])))returnलेकिन मुझे PHP बहुत अच्छी तरह से पता नहीं है इसलिए मुझे यकीन नहीं हो रहा है।

— स्टीफन

हाँ बढ़िया विचार है! इसके अलावा यह मानते हुए कि इनपुट हमेशा अपरकेस में है बाइट्स को कम करना संभव है।

— मतियास विलानुएवा

ओह, और अगर regex एक मानक regex इंजन है, तो आप नहीं कर सकते [B-Z]?

— स्टीफन

@ स्टीफन [B-Z]में स्वर शामिल हैं। [^AEIOUY]हालांकि काम करता है।

— LyricLy

मुझे या तो PHP का पता नहीं है, लेकिन आप शायद एक ifबयान में लपेटने के बजाय, सीधे रेगेक्स मैच से परिणाम वापस करके अधिक बाइट्स बचा सकते हैं ।

— LyricLy

0

सीजेएम , 57 बाइट्स

q{"aeiouy"#W=}%_,:B{_A={_A_)\B(<{=!X&:X;}{0:X;;;}?}&}fA;X

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

इनपुट पढ़ता है, व्यंजन के लिए 1s में परिवर्तित होता है, स्वर के लिए 0s। प्रत्येक व्यंजन के लिए, और अगले वर्ण मान के साथ पूर्वनिर्धारित चर X (पूर्वनिर्धारित 1)। आउटपुट X

— lolad
स्रोत

क्या यह एक मजबूत शब्द है?

मजबूत शब्द ढूंढना

चुनौती

स्पष्टीकरण

परीक्षण के मामलों

स्कोरिंग

जावास्क्रिप्ट (ईएस 6), 36 28 27 बाइट्स

कैसे?

परीक्षण के मामलों

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

कैसे?

जेली , 10 9 बाइट्स

कैसे?

05AB1E , 8 बाइट्स

कोड

व्याख्या

उदाहरण

आर , 43 बाइट्स

दिल्लोग एपीएल, 20 बाइट्स

हास्केल , 61 54 बाइट्स

जावा (ओपनजेडके 8) , 93 81 बाइट्स

भूसी , 12 बाइट्स

पायथ , 18 बाइट्स

ब्रेकीलॉग , 18 11 10 बाइट्स

अजगर २ , 58 बाइट्स

पर्ल 5, 31 बाइट्स (30 + 1)

जेली , 11 बाइट्स

अवाक, 39 बाइट्स

Kotlin , 49 बाइट्स

सजा हुआ

परीक्षा

रेटिना , 23 18 बाइट्स

जावा 8, 53 42 बाइट्स

माणिक , 25 बाइट्स

SOGL V0.12 , 19 18 बाइट्स

05AB1E , 11 बाइट्स

स्विफ्ट 3.1 , 85 बाइट्स

लुआ, 41 बाइट्स

लुआ (लोडस्ट्रिंग'एड), 37 बाइट्स

सी ++, 195 194 बाइट्स

सी, 107 बाइट्स

सी (जीसीसी) , 59 बाइट्स

PHP, 69 बाइट्स

सीजेएम , 57 बाइट्स