介绍

我的汽车车速表被黑了！它没有显示我开车的速度，而是显示：“ Vroooom！” 请帮助我知道我要走多快。

挑战

接受一个字符串作为输入，并检查它是否与regex相匹配/^[Vv]ro*m!$/m。用英语表示字符串的任何行必须以大写字母或小写字母开头v，然后是小写字母r，然后是任意数量（包括零）的小写字母o，然后是确切的字符串m!。可能还有其他行，但是Vroom字符串必须在其自己的行上。

如果找到匹配项，则必须计算oVroom字符串中的数量并输出。但是，如果找不到匹配项，则应输出否则无法输出的任何默认值（例如-1或空字符串）

提醒事项

• I / O采用任何合理的格式
• 禁止标准漏洞
• 提交内容可能是完整的程序或功能
• 输入保证只有1个Vroom字符串

计分

这是code-golf，因此以字节为单位的最短代码获胜。但是，我不会将任何答案标记为已接受。

测试用例

输入项

Vrom!

输出量 1

输入项

vrooooooom!

输出量 7

输入项

Hello, Vroom!

输出量 (none)

输入项

Foo bar boo baz
Vrooom!
hi

输出量 3

输入项

Vrm!ooo

输出量 (none)

输入项

PPCG puzzlers pie

输出量 (none)

输入项

hallo
vROOOm!

输出量 (none)

sed 4.2.2，20字节

-nr 命令行中需要的选项。

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

这将单进制的速度输出为os数。

在线尝试！

Python 2中，56 53个字节

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

在线尝试！

基本的正则表达式和分组使用re.MULTILINE标志（其值为8）和re.search以确保它适用于多行输入。未找到匹配项时引发异常。感谢@ovs为(re.M == 8)小费提供的-3个字节。

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

在线尝试！

R具有七个模式匹配功能。更常用的是grep，grepl和sub，但这里有一个很好的使用了regexec。

regexec给您一堆东西，其中之一是任何捕获的子字符串的长度，在本例(o*)中为多行正则表达式的一部分。

这些attr(el .... "m")[2]东西是获得所需数量的高尔夫球方式。

NA如果没有匹配，则返回。

JavaScript（Node.js），41字节

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

在线尝试！

Powershell，62 58 53 48字节字节

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

返回o第一个的数字，Vroom!如果Vroom!找不到则返回-4 。

笔记：

• sls是Select-String的别名；
• (?m-i) 内部正则表达式意味着：
  • 使用多行模式。^并$匹配行的开头和结尾，而不是字符串的开头和结尾。
  • 使用区分大小写的匹配
• |% M*是property的快捷方式Matches，它给出了第一个匹配项，因为我们不使用-AllMatchesparameter。

测试脚本：

$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

PowerShell，83字节

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

在线尝试！

-split$args在`newlines 上输入，将它们通过管道传递给for循环。每次迭代时，我们都会检查我们是否[regex]::Match为a .success。如果是这样，我们将$x（正则表达式结果对象）留在管道上。在循环之外，我们使用.length属性-如果它是正则表达式结果对象，则为匹配的长度（例如，“ Vroom！”为6）；如果它不是正则表达式结果对象，则长度为零。然后4，我们减去以删除的计数，Vrm!并将其保留在管道中。输出是隐式的。-4如果找不到匹配项，则输出。

视网膜，21字节

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

在线尝试！说明：L列出匹配项，因此如果正则表达式匹配失败，则输出为空。$导致结果是替换而不是匹配。m使它成为多行匹配项（相当于问题中的结尾m）。的.在取代使得输出在十进制捕获的长度。

SNOBOL4（CSNOBOL4），99 82字节

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

在线尝试！

规范的SNOBOL转换非常直接，读取每一行，直到找到匹配的行^[Vv]ro*m!$，然后输出该o*位的长度。

如果找不到Vroom!则进入无限循环。

Perl 6、26个字节

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

在线尝试！

C（GCC） ，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;}

在线尝试！

Stax，16 个字节

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

运行并调试

Haskell，75 71 69字节

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

在线尝试！

没有正则表达式。而是构建所有有效的Vrooom!字符串，直到足够长的长度，然后将输入的行与它们进行比较，从而收集o列表中的s 数。因此，对于无效输入，将返回一个空列表。

C（gcc），104100字节

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

Japt，18个字节

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

在线尝试！

通过将输入作为行数组保存一个字节。

在]和之间包含不可打印的字符*。

说明：

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字节

这是无聊的正则表达式方式。

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

在线尝试！

Pyth，28个字节

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

在线尝试！

Pyth，20个字节

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

输出为仅包含数字“ o”的列表，如果没有Vroom，则输出为空列表。
在这里尝试

说明

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

点，21字节

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

在线尝试！

^[Vv]r(o*)m!$在多行模式下匹配正则表达式；捕获组的输出长度。

sfk，94个字节

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

在线尝试！

给人-1当你不vrooming。

红色，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 ]
]

J，35个字节

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

如果模式不匹配，则返回负1。

JavaScript，90 73 61字节

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

在线尝试！

替换未在捕获字符(o*)与空字符串，返回length仅包含字符串的"o"或-1如果生成的字符串是空的。

Ruby，32个字节

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

将字符串与正则表达式匹配，然后使用Ruby的魔术正则表达式组变量来获取第一个组的大小。

这样称呼它：

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

红宝石，28 29字节

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

在线尝试！

多行字符串还需要三个字节。我不确定这是否很困难。如果是这样，我将对其进行更新。

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

Clojure，90个字节

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

在线尝试！

此匿名函数返回vroom字符串中的“ o”数，如果没有有效的vroom字符串，则返回-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

perl -nE，35个字节

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

这使用了Eskimo问候语（}{），后者滥用了-nperl 如何处理该选项的快速方法。

Java 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

C＃（.NET Core），134122字节

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 循环中并除去了括号

取消高尔夫：

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 字节

|ʒć„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. []

C ++，MSVC，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';