Giriş

Benim araba hız göstergesi hacklendi! Bana ne kadar hızlı sürdüğümü göstermek yerine, sadece "Vroooom!" Lütfen ne kadar hızlı gittiğimi bilmeme yardım et.

Meydan okuma

Bir dizeyi girdi olarak alın ve dizinin normal ifadeyle eşleşip eşleşmediğini kontrol edin /^[Vv]ro*m!$/m. Bu, dizenin herhangi bir satırının büyük veya küçük harfle v, ardından küçük harfle r, sonra küçük harfin herhangi bir miktarının (sıfır dahil) o, ardından tam dizeyle başlaması gerektiği anlamına gelir m!. Başka satırlar da olabilir, ancak Vroom dizesi kendi satırında olmalıdır.

Bir eşleşme bulursanız o, Vroom dizesindeki 's miktarını saymanız ve çıktısını almanız gerekir . Bununla birlikte, bir eşleşme bulamazsanız, başka şekilde verilemeyen herhangi bir varsayılan değer ( -1boş veya boş bir dize gibi) çıkarmalısınız.

Hatırlatmalar

• G / Ç herhangi bir makul biçimde
• Standart boşluklar yasaklandı
• Gönderme tam bir program veya işlev olabilir
• Girişin yalnızca 1 Vroom dizesi olması garanti edilir

puanlama

Bu kod golf , bu yüzden bayttaki en kısa kod kazanır. Ancak hiçbir cevabı kabul edilmiş olarak işaretlemeyeceğim.

Test senaryoları

Giriş

Vrom!

Çıktı 1

Giriş

vrooooooom!

Çıktı 7

Giriş

Hello, Vroom!

Çıktı (none)

Giriş

Foo bar boo baz
Vrooom!
hi

Çıktı 3

Giriş

Vrm!ooo

Çıktı (none)

Giriş

PPCG puzzlers pie

Çıktı (none)

Giriş

hallo
vROOOm!

Çıktı (none)

sed 4.2.2 , 20 bayt

-nr komut satırında gereken seçenekler.

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

Bu, hızı s olarak tekli olarak verir o.

Çevrimiçi deneyin!

Python 2 , 56 53 bayt

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

Çevrimiçi deneyin!

Temel regex ve gruplama, çok satırlı girdilerde çalıştığından emin olmak için re.MULTILINE bayrağını (8 değerine sahip) ve re.search kullanır. Eşleşme bulunmadığında bir istisna oluşturur. Uçtan -3 bayt @ovs için teşekkürler (re.M == 8).

R , 62 60 58 44 bayt

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

Çevrimiçi deneyin!

@Giuseppe 14 byte ile golf oynadı.

Açıklama ile orijinal yaklaşım:

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

Çevrimiçi deneyin!

R, yedi desen eşleştirme fonksiyonuna sahiptir. Daha yaygın olarak kullanılan olanlardır grep, greplve sub, ama burada güzel bir faydası regexec.

regexecsize bir grup yakalanan alt dizenin uzunluğu, bu durumda (o*)çok satırlı regex'in parçası olan bir sürü şey verir .

attr(el .... "m")[2]Şeyler istenilen numarayı almak için Golfy yoldur.

Eşleşme NAyoksa döndürür .

JavaScript (Node.js) , 41 bayt

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

Çevrimiçi deneyin!

Powershell, 62 58 53 48 bayt bayt

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

getirileri sayılar obirinci yılında Vroom!, veya -4 eğer Vroom!bulunamadı.

Notlar:

• slsSelect-String için takma addır ;
• (?m-i) normal ifade içinde:
  • Çok satırlı mod kullanın. ^ve $bir dizenin başlangıcı ve bitişi yerine çizginin başlangıcı ve bitişi ile eşleşir.
  • Büyük / küçük harf duyarlı eşleme kullan
• |% M*olduğu kısayol özelliği için Matcheskullandığımız çünkü bir ilk maçı verir -AllMatchesparametre.

Test komut dosyası:

$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"
}

Çıktı:

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

PowerShell , 83 bayt

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

Çevrimiçi deneyin!

-splitewlines giriş $args, `nbir for döngüsü içine boruları. Her yineleme, kendimizi kontrol [regex]::Matchbir olduğunu .successya da değil. Öyleyse, $x(normal ifade sonuçları nesnesi) boru hattında kalırız . Döngünün dışında, .lengthözelliği alırız - regex sonuçları nesnesi ise, bu maçın uzunluğudur (örneğin, "Vroom!" 6 olur); normal ifade sonuçları nesnesi değilse uzunluk sıfırdır. Daha sonra 4, için sayıları kaldırmak Vrm!ve bunu boru hattında bırakmak için çıkarırız . Çıktı örtük. Eşleşme -4bulunmazsa a sonucunu verir.

Retina , 21 bayt

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

Çevrimiçi deneyin! Açıklama: Leşleşmeleri listeler, böylece normal ifade eşleşmezse çıktı boş olur. $sonucun maçtan ziyade oyuncu değişikliği olmasına neden olur. mbunu çok satırlı bir eşleme yapar ( msorudaki izlemeye eşdeğerdir ). .Yerine olsun motor ondalık içinde yakalama uzunluğu yapar.

SNOBOL4 (CSNOBOL4) , 99 82 bayt

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

Çevrimiçi deneyin!

Spesifikasyonun oldukça doğrudan SNOBOL çevirisi, eşleşen bir tane bulana kadar her satırı okur ^[Vv]ro*m!$, sonra o*bitin uzunluğunu verir .

Bulunamıyorsa sonsuz bir döngüye girer Vroom!.

Perl 6 , 26 bayt

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

Çevrimiçi deneyin!

C (gcc) , 188183 bayt

Bunun yerine durum makinesi kullanabiliyorsanız neden normal ifadeler kullanıyorsunuz? :-)

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

Çevrimiçi deneyin!

Stax , 16 bayt

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

Çalıştır ve hata ayıkla

Haskell , 75 71 69 bayt

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

Çevrimiçi deneyin!

Normal ifade yok. Bunun yerine, tüm geçerli Vrooom!dizeleri yeterli uzunluğa kadar oluşturur ve giriş satırlarını bunlarla karşılaştırır, obir listedeki s sayısını toplar . Böylece geçersiz girişler için boş bir liste döndürülür.

C (GCC) , 104 , 100 bayt

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

Çevrimiçi deneyin!

Çıktı ntam gereksinimi içinde her geçerli hat için, (hiçbir geçerli hat ise hiçbir şey, neğer tam bir)

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

Japt , 18 bayt

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

Çevrimiçi deneyin!

Girdiyi satır dizisi olarak alarak kaydedilmiş bayt.

Arasında yazdırılamayan karakter içerir ]ve *.

Açıklama:

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

C (gcc) , 138124 bayt

İşte sıkıcı normal ifade yolu.

#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;}

Çevrimiçi deneyin!

Pyth , 28 bayt

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

Çevrimiçi deneyin!

Pyth, 20 bayt

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

Yalnızca 'o' sayısını içeren bir liste veya Vroom yoksa boş bir liste olarak çıktılar.
Burada deneyin

açıklama

/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.

Pip , 21 bayt

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

Çevrimiçi deneyin!

^[Vv]r(o*)m!$Çok satırlı modda normal ifadeyi eşleştirin ; yakalama grubunun çıktı uzunluğu.

sfk , 94 bayt

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

Çevrimiçi deneyin!

-1Vrooming yapmadığınızda verir .

Kırmızı , 104 bayt

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

Çevrimiçi deneyin!

Basit bir çözüm. Kırmızılar parseserin ve okunabilir, ancak regex'e kıyasla çok uzun

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

J, 35 bayt

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

Desen eşleşmezse negatif 1 değerini döndürür.

JavaScript, 90 73 61 bayt

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

Çevrimiçi deneyin!

Yakalanmayan karakterleri (o*)boş dize, lengthyalnızca içeren dize dönüşü "o"veya -1sonuçta ortaya çıkan dize boşsa değiştirin.

Ruby, 32 bayt

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

Dizeyi normal ifade ile eşleştirir, ardından ilk grubun boyutunu elde etmek için Ruby'nin sihirli normal ifade grubu değişkenlerini kullanır.

Şöyle deyin:

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

Yakut , 28 29 bayt

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

Çevrimiçi deneyin!

Çok satırlı dizeler üç bayt daha gerektirir. Bunun zor bir gereklilik olup olmadığından emin değilim. Eğer öyleyse, bunu güncelleyeceğim.

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

Clojure , 90 bayt

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

Çevrimiçi deneyin!

Bu anonim işlev, vroom dizesindeki "o" sayısını veya geçerli bir vroom dizesi yoksa -1 değerini döndürür.

Okunabilir versiyon

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

açıklama

#"(?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

perl -nE, 35 bayt

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

Bu , seçeneğin perl tarafından nasıl ele alındığını hızlı bir şekilde kötüye kullanan Eskimo karşılamasını ( }{) kullanır -n.

Java 8, 109 bayt

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

Çevrimiçi deneyin.

Açıklama:

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

C # (.NET Core) , 134122 bayt

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

Çevrimiçi deneyin!

-12 bayt: null denetimi döngüye taşıdı for ve parantezleri kaldırdı

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

05AB1E , 39 37 bayt

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

05AB1E bir golf dili olmasına rağmen, regex temelli zorluklar kesinlikle güçlü paketi değildir, çünkü regex yerleşikleri yoktur.

Eşleşme []bulunmazsa çıktılar .

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

|              # 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. []

C ++, msvc, 164 159 bayt

Zacharý sayesinde -5 bayt

Yalnızca regexbaşlık ile bile derlenir

#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;}

Testler:

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';