परिचय

मेरी कार का स्पीडोमीटर हैक हो गया था! मैं यह दिखाने की बजाय कि मैं कितनी तेज़ गाड़ी चला रहा हूँ, यह सिर्फ दिखाता है: "व्रूम!" कृपया मुझे यह जानने में मदद करें कि मैं कितनी तेजी से जा रहा हूं।

चुनौती

इनपुट के रूप में एक स्ट्रिंग लें, और जांचें कि क्या यह रेगेक्स से मेल खाता है /^[Vv]ro*m!$/m। अंग्रेजी में इसका मतलब है कि स्ट्रिंग की कोई भी रेखा एक पूंजी या लोअरकेस से शुरू होनी चाहिए v, फिर एक लोअरकेस r, फिर लोअरकेस अक्षर की कोई भी राशि (शून्य सहित) o, फिर सटीक स्ट्रिंग m!। अन्य पंक्तियाँ हो सकती हैं, लेकिन वरूम स्ट्रिंग को स्वयं की रेखा पर होना चाहिए।

यदि आप एक मैच पाते हैं, तो आपको oव्रूम स्ट्रिंग में इसकी मात्रा को गिनना होगा और इसे आउटपुट करना होगा। यदि आपको कोई मेल नहीं मिलता है, तो आपको किसी भी डिफ़ॉल्ट मान का उत्पादन करना चाहिए जिसे अन्यथा आउटपुट नहीं किया जा सकता है (जैसे -1या खाली स्ट्रिंग)

अनुस्मारक

I / O किसी भी उचित प्रारूप में है
मानक खामियों पर रोक लगाई जाती है
सबमिशन एक पूर्ण कार्यक्रम या फ़ंक्शन हो सकता है
इनपुट की गारंटी केवल 1 वरूम स्ट्रिंग है

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है। हालाँकि , मैं किसी भी उत्तर को स्वीकार नहीं करूंगा।

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

इनपुट

Vrom!

उत्पादन 1

इनपुट

vrooooooom!

उत्पादन 7

इनपुट

Hello, Vroom!

उत्पादन (none)

इनपुट

Foo bar boo baz
Vrooom!
hi

उत्पादन 3

इनपुट

Vrm!ooo

उत्पादन (none)

इनपुट

PPCG puzzlers pie

उत्पादन (none)

इनपुट

hallo
vROOOm!

उत्पादन (none)

— FireCubez
स्रोत

9

sed 4.2.2 , 20 बाइट्स

-nr कमांड-लाइन पर विकल्प आवश्यक हैं।

s/^[Vv]r(o*)m!$/\1/p

यह s की संख्या के रूप में unary में गति को आउटपुट करता है o।

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

— डिजिटल आघात
स्रोत

नहीं बता सकता Vrm!सेVram!

— l4m2

4

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

lambda x:len(re.search('^[Vv]r(o*)m!$',x,8).group(1))

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

बेसिक रेगेक्स और ग्रुपिंग, मल्टीलाइन फ्लैग (जिसमें 8 का मूल्य है) का उपयोग करता है और मल्टीलाइन इनपुट के लिए यह सुनिश्चित करने के लिए पुनः खोज करता है। कोई मैच नहीं मिलने पर एक अपवाद को उठाता है। (re.M == 8)टिप से -3 बाइट्स के लिए @ovs का धन्यवाद ।

— Shamtam
स्रोत

1

PPCG में आपका स्वागत है! मैंने आपके उत्तर को थोड़ा सा अच्छा बनाने के लिए आपका सुधार किया, यदि आप मेरे संपादन से नाखुश हैं तो आप हमेशा वापस आ सकते हैं। Btw। मैं tio.run जैसी किसी चीज़ से लिंक करने का सुझाव देता हूं ताकि लोग आपके उत्तर को आसानी से परख सकें।

— 20

re.Mमूल्य है 8, तो बस का उपयोग कर सकते हैंre.search(regex,x,8)

— ovs

4

आर , 62 60 58 44 बाइट्स

nchar(grep("^[Vv]ro*m!$",readLines(),v=T))-4

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

@Giuseppe के साथ 14 बाइट्स गॉकेटेड हैं।

स्पष्टीकरण के साथ मूल दृष्टिकोण:

function(x)attr(el(regexec("(?m)[Vv]r(o*)m!$",x,,T)),"m")[2]

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

आर में सात पैटर्न मिलान कार्य हैं। अधिक सामान्यतः उपयोग किए जाने वाले हैं grep, greplऔर sub, लेकिन यहां के लिए एक अच्छा उपयोग है regexec।

regexecआपको चीजों का एक गुच्छा देता है, जिनमें से एक किसी भी पकड़े गए विकल्प की लंबाई है, इस मामले (o*)में मल्टीलाइन रेगेक्स का हिस्सा है।

attr(el .... "m")[2]सामान वांछित संख्या पाने के लिए एक golfy तरीका है।

NAअगर कोई मैच न हो तो वापसी ।

— एन जी एम
स्रोत

एक अलग दृष्टिकोण के साथ 58 बाइट्स

— digEmAll

मेरे पास एक 44 बाइट है ... जब तक आप मुझे चाहते हैं, तब तक इसे पोस्ट न करें।

— Giuseppe

@Giuseppe नहीं यकीन है कि क्यों नहीं? खासकर अगर यह मौलिक रूप से अलग है।

— एनएमसी

3

जावास्क्रिप्ट (Node.js) , 41 बाइट्स

a=>(l=/[Vv]r(o*)m!/.exec(a))&&l[1].length

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत

इस के लिए विफल रहता हैvroooooooooooom!x\nvrom!

— ბიმო

1

यह देखने के बाद कि हमें किसी त्रुटि के साथ बाहर निकलने की अनुमति है यदि कोई मैच नहीं मिला है, तो आप -3 बाइट्स के लिए ऐसा कर सकते हैं, इस प्रक्रिया में ऊपर बताई गई समस्या @BMO को ठीक करता है।

— झबरा

अनसोल्ड-आउट 41 निश्चित रूप से अभी भी 41 है

— रेडवॉल्फ प्रोग्राम्स

@ शैगी किस स्थान के [1]. lengthलिए है?

— l4m2

@ l4m2, एक टाइपो! मैंने इसे अपने फोन पर स्पॉट नहीं किया, क्योंकि lengthवैसे भी एक नई लाइन के लिए टूट रहा था।

— झबरा

3

पॉवर्सशेल, 62 58 53 48 बाइट्स बाइट्स

"$($args|sls '(?m-i)^[Vv]ro*m!$'|% M*)".Length-4

oपहले नंबर की रिटर्न Vroom!, या -4 Vroom!नहीं मिलने पर।

टिप्पणियाँ:

slsचयन-स्ट्रिंग के लिए उपनाम है ;
(?m-i) रेगेक्सप के अंदर का अर्थ है:
- मल्टीलाइन मोड का उपयोग करें। ^और $एक स्ट्रिंग की शुरुआत और अंत के बजाय एक पंक्ति की शुरुआत और अंत से मेल खाते हैं।
- केस-संवेदी मिलान का उपयोग करें
|% M*है शॉर्टकट संपत्ति के लिए Matchesहै, जो एक पहला मैच देता है क्योंकि हम प्रयोग नहीं करते -AllMatchesपैरामीटर।

टेस्ट स्क्रिप्ट:

$f = {

"$($args|sls '(?m-i)^[Vv]ro*m!$'|% M*)".Length-4

}

@(
,('Vrom!',1)
,('vrooooooom!',7)
,('Hello, Vroom!',-4)
,('Foo bar boo baz
Vrooom!
hi',3)
,('Vrm!ooo',-4)
,('PPCG puzzlers pie',-4)
,('hallo
vROOOm!',-4)
,('
Vrooom!
Vrooooom!
',3)        # undefined behavior.
,('vrm!',0) # :)
) | % {
    $n,$expected = $_
    $result = &$f $n
    "$($result-eq$expected): $result"
}

आउटपुट:

True: 1
True: 7
True: -4
True: 3
True: -4
True: -4
True: -4
True: 3
True: 0

— Mazzy
स्रोत

2

पॉवरशेल , 83 बाइट्स

($args-split"`n"|%{if(($x=[regex]::Match($_,"^[Vv]ro*m!$")).success){$x}}).length-4

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

-splitewlines $argsपर इनपुट है `n, उन लोगों के लिए लूप में पाइप करता है। प्रत्येक पुनरावृत्ति, हम जाँचते हैं कि हमारा [regex]::Matchहै .successया नहीं। यदि ऐसा है, तो हम $xपाइपलाइन पर (रेगेक्स परिणाम ऑब्जेक्ट) छोड़ देते हैं । लूप के बाहर, हम .lengthसंपत्ति लेते हैं - अगर यह रेगेक्स परिणाम ऑब्जेक्ट है, तो यह मैच की लंबाई है (उदाहरण के लिए, "वूमर!" 6 होगा); यदि यह रेगेक्स परिणाम ऑब्जेक्ट नहीं है, तो लंबाई शून्य है। हम तब पाइप लाइन पर और उस पाइप को छोड़ने के 4लिए मायने निकालते हैं Vrm!। आउटपुट निहित है। -4यदि कोई मेल नहीं मिलता है तो आउटपुट ।

— AdmBorkBork
स्रोत

sls "^[Vv]ro*m!$"?

— माज़ी

@mazzy मल्टीलाइन इनपुट के लिए यह कैसे काम करेगा? आपका एकमात्र इनपुट एक स्ट्रिंग है, और इसलिए उदाहरण के लिए slsवापस दे देंगे ('','Vroom!','')।

— AdmBorkBork

यह पूरा समाधान नहीं है। मेरा मतलब है, आप slsइसके बजाय की कोशिश कर सकते हैं[regex]::Match

— mazzy

@mazzy शायद आपको इसे एक अलग समाधान के रूप में पोस्ट करना चाहिए।

— AdmBorkBork

2

रेटिना , 21 बाइट्स

L$m`^[Vv]r(o*)m!$
$.1

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: Lमैचों को सूचीबद्ध करता है, इसलिए यदि रेग्क्स मिलान करने में विफल रहता है तो आउटपुट खाली है। $परिणाम मैच के बजाय प्रतिस्थापन होने का कारण बनता है। mयह एक बहुस्तरीय मिलान बनाता है ( mप्रश्न में अनुगामी के बराबर )। .प्रतिस्थापन में यह उत्पादन दशमलव में कब्जा की लंबाई में आता है।

— नील
स्रोत

2

SNOBOL4 (CSNOBOL4) , 99 82 बाइट्स

I	INPUT POS(0) ('V' | 'v') 'r' ARBNO('o') @X 'm!' RPOS(0)	:F(I)
	OUTPUT =X - 2
END

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

कल्पना का सीधा सीधा अनुवाद, प्रत्येक पंक्ति को तब तक पढ़ता है जब तक कि यह एक मेल नहीं खाता है ^[Vv]ro*m!$, तब तक o*बिट की लंबाई का आउटपुट होता है ।

कोई अनंत लूप मिलाता है यदि नहीं Vroom!मिल सकता है।

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

क्या वह सब व्हाट्सएप जरूरी है? वाह।

— फायरक्यूबज़

5

@FireCubez हाँ, यह वही है जो आपको 50+ साल पुरानी भाषा के साथ मिलता है: अजीब व्हाट्सएप आवश्यकताओं। यह स्थान / टैब का उपयोग संघनन के रूप में करता है और आपको ऑपरेटरों को व्हॉट्सएप के साथ घेरना चाहिए।

— Giuseppe

2

पर्ल 6 , 26 बाइट्स

{-!/^^[V|v]r(o)*m\!$$/+$0}

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

— nwellnhof
स्रोत

2

सी (जीसीसी) , 188 183 बाइट्स

जब आप एक राज्य मशीन का उपयोग कर सकते हैं तो रेगेक्स का उपयोग क्यों करें? :-)

a,b;f(char*s){for(a=b=0;a<5;s++){!a&*s==86|*s=='v'?a++:a==1&*s=='r'?a++:a==2?*s-'o'?*s-'m'?0:a++:b++:a==3&*s==33?a++:!*s&a==4?a++:*s-10?(a=-1):a-4?(a=0):a++;if(!*s)break;}s=a<5?-1:b;}

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

— ErikF
स्रोत

1

स्टैक्स , 16 बाइट्स

∞╠mQ╛3mQ->n▀÷↕┐ò

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

— पुनरावर्ती
स्रोत

1

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

f s=[length n-2|r<-lines s,n<-scanr(:)"m!"$'o'<$r,v<-"Vv",r==v:'r':n]

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

रेगेक्स नहीं। इसके बजाय सभी वैध- Vrooom!युक्तियों को एक पर्याप्त लंबाई तक बनाता है और उनके खिलाफ इनपुट की लाइनों की तुलना करता है, oएक सूची में एस की संख्या एकत्र करता है । इस प्रकार अमान्य इनपुट के लिए एक खाली सूची वापस कर दी जाती है।

— Laikoni
स्रोत

1

सी (जीसीसी) , 104 100 बाइट्स

s;main(c,n){for(;gets(&s);sscanf(&s,"v%*[o]%nm%c%c",&n,&c,&c)-1||c-33?:printf("%d",n-2))s=s-768|32;}

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

nप्रत्येक वैध लाइन के लिए आउटपुट , बिल्कुल आवश्यकता में (कुछ नहीं तो कोई वैध लाइन, nयदि बिल्कुल एक)

int s; // Use as a char[]
main(c){
  while(gets(&s)) {
    s=s-768|32; // byte 0: 'V'=>'v'; byte 1: 'r'=>'o', 'o'=>'l'
    if (sscanf(&s,"v%[o]m%c%c",&s,&c,&c)==2 && c=='!') {
    // The last '%c' get nothing if it's EndOfLine
      printf("%d",strlen(&s)-1))
    }
  }
}

— l4m2
स्रोत

यह इतना मज़ेदार है कि रेगेक्स का उत्तर इससे अधिक लंबा है

— विंडमिल कुकीज़

@IndmillCookies GCC

— बजे

हम्म। लगता है जैसे रेगेक्स से संबंधित नाम बहुत लंबे हैं

— विंडमिल कुकीज़

1

जाप , 18 बाइट्स

fè`^[Vv]*m!$` ®èo

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

लाइनों की एक सरणी के रूप में इनपुट लेकर एक बाइट को बचाया।

के बीच एक unprintable चरित्र शामिल है ]और *।

स्पष्टीकरण:

fè                   Get the line(s) that match
  `^[Vv]*m!$`          The provided RegEx with a little compression
              ®èo    Count the number of "o" in that line if it exists

— कामिल दकरी
स्रोत

1

19 बाइट्स

— झबरा

इसके अलावा 19 बाइट्स

— झबरा

दरअसल, इनपुट के रूप में लाइनों की एक सरणी हो सकती है, आप मेरी पहली टिप्पणी के ऊपर पहली बाइट को मार सकते हैं।

— झबरा

@ शैगी मुझे उस प्रश्न में कहीं भी नहीं मिल रही है जो यह निर्दिष्ट करता है कि इनपुट लाइनों की एक सरणी हो सकती है, और यह डिफ़ॉल्ट I / O विधियों में सूचीबद्ध नहीं लगता है कि एक बहु स्ट्रिंग स्ट्रिंग लाइनों की एक सरणी के रूप में लिया जा सकता है । यह उचित होने की संभावना है, लेकिन मैं पहले पुष्टि की प्रतीक्षा करूंगा।

— कामिल दकरी

1

सी (जीसीसी) , 138 124 बाइट्स

यहाँ बोरिंग रेगेक्स तरीका है।

#include<regex.h>
f(char*s){regmatch_t m[9];regcomp(m+2,"^[Vv]r(o*)m!$",5);s=regexec(m+2,s,2,m,0)?-1:m[1].rm_eo-m[1].rm_so;}

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

— ErikF
स्रोत

0

Pyth , 28 बाइट्स

IJjb.nm:rd0"^vro*m!$"1.z/J\o

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

— Cowabunghole
स्रोत

0

अजगर, 20 बाइट्स

/R\o:#"^Vro*m!$"1cQb

यदि कोई वर नहीं है तो केवल 'ओ' की संख्या या खाली सूची वाली सूची के रूप में आउटपुट।
इसे यहाँ आज़माएँ

व्याख्या

/R\o:#"^Vro*m!$"1cQb
                 cQb  Split on newlines.
    :#"^Vro*m!$"1     Filter the ones that match the regex.
/R\o                  Count the `o`s in each remaining element.

0

रंज , 21 बाइट्स

a~,`^[Vv]r(o*)m!$`#$1

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

^[Vv]r(o*)m!$मल्टीलाइन मोड में मैच रेगेक्स ; कब्जा समूह की उत्पादन लंबाई।

— DLosc
स्रोत

0

sfk , 94 बाइट्स

xex -i -case "_[lstart][char of Vv]r[chars of o]m![lend]_[part 4]o_" +linelen +calc "#text-1"

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

-1जब आप तैयार नहीं कर रहे हैं देता है ।

— Οurous
स्रोत

0

लाल , 104 बाइट्स

func[s][n:""if parse/case s[opt[thru"^/"]["V"|"v"]"r"copy n any"o""m!"opt["^/"to end]][print length? n]]

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

एक सीधा समाधान। रेड्स parseशांत और पठनीय है, लेकिन रेगेक्स की तुलना में बहुत लंबा है

Red []
f: func [ s ] [
    n: ""
    if parse/case s [
             opt [ thru newline ]
             [ "V" | "v" ]
             "r"
             copy n any "o"
             "m!"
             opt [ newline to end ]
    ] [ print length? n ]
]

— गैलेन इवानोव
स्रोत

0

जे, 35 बाइट्स

(]{~0<{.)(1{'^[Vv]r(o*)m!'rxmatch])

यदि पैटर्न से मेल नहीं खाता है, तो ऋणात्मक 1 लौटाता है।

— hoosierEE
स्रोत

0

जावास्क्रिप्ट, 90 73 61 बाइट्स

_=>_.replace(/^[Vv]r(o*)m!$|[^\1]/mg,(m,a)=>a||'').length||-1

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

उन वर्णों को प्रतिस्थापित करें जिन्हें (o*)खाली स्ट्रिंग के साथ कैप्चर नहीं किया गया है , lengthकेवल स्ट्रिंग वाले रिटर्न "o"या -1यदि परिणामस्वरूप स्ट्रिंग खाली है।

— guest271314
स्रोत

0

रूबी, 32 बाइट्स

->n{n=~/^[Vv]r(o*)m!$/m;$1.size}

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

इसे ऐसे कॉल करें:

x=->n{n=~/^[Vv]r(o*)m!$/m;$1.size}
x["Vrooooooooooooooooooooom!"] # returns 21

— NO_BOOT_DEVICE
स्रोत

0

रूबी , 28 29 बाइट्स

p$_[/^[vV]r(o*)m!$/].count ?o

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

मल्टी-लाइन स्ट्रिंग्स को तीन और बाइट्स की आवश्यकता होती है। मुझे यकीन नहीं है कि अगर यह एक कठिन आवश्यकता है। यदि हां, तो मैं इसे अपडेट करूंगा।

->l{l[/^[Vv]r(o*)m!$/].count ?o}

— canhascodez
स्रोत

आप मल्टी-लाइन स्ट्रिंग्स का परीक्षण कैसे कर सकते हैं?

— लकोनी

1

फेल ऑनVROM!

— l4m2

0

क्लोजर , 90 बाइट्स

#(do(def a(clojure.string/replace % #"(?ms).*^[Vv]r(o*)m!$.*""$1"))(if(= a %)-1(count a)))

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

यह अनाम फ़ंक्शन दूल्हे के स्ट्रिंग में "o" s की संख्या देता है, या -1 यदि कोई मान्य वर स्ट्रिंग नहीं है।

पठनीय संस्करण

(fn [s]
  (def a (clojure.string/replace s #"(?ms).*^[Vv]r(o*)m!$.*" "$1"))
  (if (= a s) -1 (count a)))

व्याख्या

#"(?ms).*^[Vv]r(o*)m!$.*" ; This regex matches any string that contains a valid vroom string. The first capturing group contains only the "o"s in the vroom string
(clojure.string/replace s #"(?ms).*^[Vv]r(o*)m!$.*" "$1") ; Replaces a match of the above regex with its first capturing group. The resulting string is stored in the variable a
(if (= a s) -1 (count a))) ; a equals s if and only if there is no valid vroom string, so if a equal s we return -1. If there is a valid vroom string, a contains only the "o"s from the vroom string, so we return the length of a

— TheGreatGeek
स्रोत

0

perl -nE, 35 बाइट्स

$s=length$1if/^[Vv]r(o*)m!$/}{say$s

यह एस्किमो ग्रीटिंग ( }{) का उपयोग करता है जो एक त्वरित दुरुपयोग करता है कि कैसे -nपर्ल द्वारा विकल्प से निपटा जाता है।

0

जावा 8, 109 बाइट्स

s->{int r=-1;for(var l:s.split("\n"))r=l.matches("[Vv]ro*m\\!")?l.replaceAll("[^o]","").length():r;return r;}

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

स्पष्टीकरण:

s->{                             // Method with String parameter and integer return-type
  int r=-1;                      //  Result-integer, starting at -1
  for(var l:s.split("\n"))       //  Loop over the lines:
    r=l.matches("[Vv]ro*m\\!")?  //   If the current line matches the regex:
       l.replaceAll("[^o]","").length()
                                 //    Change `r` to the amount of "o"'s in it
      :                          //   Else:
       r;                        //    Leave the result `r` unchanged
  return r;}                     //  Return the result

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

0

सी # (.NET कोर) , 134 122 बाइट्स

for(var a="";a!=null;a=Console.ReadLine())if(new Regex(@"^[Vv]ro*m!$").Match(a).Success)Console.Write(a.Count(x=>x=='o'));

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

-12 बाइट्स: लूप null में चेक को for हटा दिया और कोष्ठक हटा दिया

Ungolfed:

for(var a = ""; a != null; a = Console.ReadLine())  // initialize a, and while a isn't null, set to new line from console
    if(new Regex(@"^[Vv]ro*m!$")                        // set regex
                        .Match(a).Success)              // check if the line from the console matches
        Console.Write(a.Count(x => x == 'o'));              // write the number of 'o's to the console

— Meerkat
स्रोत

-10 बाइट्स के साथ C # 6 के अशक्त-सशक्तीकरण और सशर्त संचालक, लूप {}में केवल एक स्टेटमेंट का उपयोग करने पर भी अनावश्यक for:

for(var a="";;a=Console.ReadLine())Console.WriteLine(new Regex(@"^[Vv]ro*m!$").Match(a??"").Success?a.Count(x =>x=='o'):-1);

— इवान गार्सिया टोपे

इसके अलावा, यह ज़रूरी using System.Linq; using System.Text.RegularExpressions;नहीं है कि यह महत्वपूर्ण है

— इवान गार्सिया टोपेटे नोवा

आपके द्वारा प्रदान किया गया कोड वास्तव में काम नहीं करता है, क्योंकि यह केवल -1हर लाइन के लिए आउटपुट नहीं करेगा जो इस पर काम नहीं करता है, लेकिन यह -1हमेशा के लिए आउटपुट होगा क्योंकि कोई चेक नहीं है null।

— मर्कट

नहीं, यह नहीं होगा। a = Console.ReadLine()लूप बनाता है, इसलिए हर बार जब आप लूप के लिए इनपुट का अनुरोध कर रहे हैं, अगर कोई इनपुट नहीं है, तो लूप बस इंतजार कर रहा है, -1हमेशा के लिए नहीं प्रिंट कर रहा है

— इवान गार्सिया टोपे

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

— मीरकैट

0

05AB1E , 39 37 बाइट्स

|ʒć„VvsåsÁÁD…m!rÅ?s¦¦¦Ù'oså)P}Dgi`'o¢

यद्यपि 05AB1E एक गोल्फ भाषा है, रेगेक्स-आधारित चुनौतियां निश्चित रूप से इसका मजबूत सूट नहीं हैं, क्योंकि इसमें कोई रेगेक्स-बिल्डिन नहीं हैं।

[]यदि कोई मिलान नहीं मिला तो आउटपुट ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

|              # Get the input split by newlines
 ʒ             # Filter it by:
  ć            #  Head extracted: Pop and push the remainder and head-character
               #   i.e. "vrm!" → "rm!" and "v"
               #   i.e. "Vroaom!" → "roaom!" and "V"
   „Vvså       #  Is this head character in the string "Vv"?
               #   i.e. "v" → 1 (truthy)
               #   i.e. "V" → 1 (truthy)
  s            #  Swap so the remainder is at the top of the stack again
   ÁÁ          #  Rotate it twice to the right
               #   i.e. "rm!" → "m!r"
               #   i.e. "roaom!" → "m!roao"
     D         #  Duplicate it
      …m!rÅ?   #  Does the rotated remainder start with "m!r"?
               #   i.e. "m!r" → 1 (truthy)
               #   i.e. "m!roao" → 1 (truthy)
  s¦¦¦         #  Remove the first three characters from the duplicated rotated remainder
               #   i.e. "m!r" → ""
               #   i.e. "m!roao" → "oao"
      Ù        #  Uniquify, leaving only distinct characters
               #   i.e. "" → ""
               #   i.e. "oao" → "oa"
       'oså   '#  Is this uniquified string in the string "o"?
               #   i.e. "" → 1 (truthy)
               #   i.e. "oa" → 0 (falsey)
  )P           #  Check if all three checks above are truthy
               #   i.e. [1,1,1] → 1 (truthy)
               #   i.e. [1,1,0] → 0 (falsey)
 }             # Close the filter
  D            # After the filter, duplicate the list
   gi          # If its length is 1:
               #   i.e. ["vrm!"] → 1 (truthy)
               #   i.e. [] → 0 (falsey)
     `         #  Push the value in this list to the stack
               #   i.e. ["vrm!"] → "vrm!"
      'o¢     '#  And count the amount of "o" in it (and output implicitly)
               #   i.e. "vrm!" → 0
               # (Implicit else:)
               #  (Implicitly output the duplicated empty list)
               #   i.e. []

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

0

सी ++, एमएसवीसी, 164 159 बाइट्स

-5 बाइट्स Zacharý के लिए धन्यवाद

यह regexकेवल हेडर के साथ भी संकलित करता है

#include<regex>
using namespace std;int f(vector<string>i){smatch m;for(auto&e:i)if(regex_match(e,m,regex("^[Vv]ro*m!$")))return m[0].str().size()-4;return-1;}

टेस्ट:

std::cout << "Vrom!" << " -> " << f({ "Vrom!" }) << '\n';
std::cout << "vrooooooom!" << " -> " << f({ "vrooooooom!" }) << '\n';
std::cout << "Hello, Vroom!" << " -> " << f({ "Hello, Vroom!" }) << '\n';
std::cout << "Foo bar boo baz \\n Vrooom! \\n hi" << " -> " << f({ "Foo bar boo baz", "Vrooom!", "hi" }) << '\n';
std::cout << "Vrm!ooo" << " -> " << f({ "Vrm!ooo" }) << '\n';
std::cout << "PPCG puzzlers pie" << " -> " << f({ "PPCG puzzlers pie" }) << '\n';
std::cout << "hallo \\n vROOOm!" << " -> " << f({ "hallo", "vROOOm!" }) << '\n';

— HatsuPointerKun
स्रोत

1

मुझे लगता है कि using namespace std;

— ज़ाचारि

मैं कितनी तेजी से व्रत कर रहा हूं?

परिचय

चुनौती

अनुस्मारक

स्कोरिंग

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

sed 4.2.2 , 20 बाइट्स

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

आर , 62 60 58 44 बाइट्स

जावास्क्रिप्ट (Node.js) , 41 बाइट्स

पॉवर्सशेल, 62 58 53 48 बाइट्स बाइट्स

पॉवरशेल , 83 बाइट्स

रेटिना , 21 बाइट्स

SNOBOL4 (CSNOBOL4) , 99 82 बाइट्स

पर्ल 6 , 26 बाइट्स

सी (जीसीसी) , 188 183 बाइट्स

स्टैक्स , 16 बाइट्स

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

सी (जीसीसी) , 104 100 बाइट्स

जाप , 18 बाइट्स

सी (जीसीसी) , 138 124 बाइट्स

Pyth , 28 बाइट्स

अजगर, 20 बाइट्स

व्याख्या

रंज , 21 बाइट्स

sfk , 94 बाइट्स

लाल , 104 बाइट्स

जे, 35 बाइट्स

जावास्क्रिप्ट, 90 73 61 बाइट्स

रूबी, 32 बाइट्स

रूबी , 28 29 बाइट्स

क्लोजर , 90 बाइट्स

पठनीय संस्करण

व्याख्या

perl -nE, 35 बाइट्स

जावा 8, 109 बाइट्स

सी # (.NET कोर) , 134 122 बाइट्स

05AB1E , 39 37 बाइट्स

सी ++, एमएसवीसी, 164 159 बाइट्स