소개

내 차 속도계가 해킹당했습니다! 내가 얼마나 빨리 운전하는지 보여주지 않고 "Vroooom!" 내가 얼마나 빨리 가고 있는지 알려주세요.

도전

문자열을 입력으로 받아서 정규식과 일치하는지 확인하십시오 /^[Vv]ro*m!$/m. 영어에서 문자열의 모든 행은 대문자 또는 소문자 v, 소문자 r, 소문자의 모든 양 (0 포함) o, 정확한 문자열로 시작해야 함을 의미 합니다 m!. 다른 줄이있을 수 있지만 Vroom 문자열은 자체 줄에 있어야합니다.

일치하는 것을 찾으면 oVroom 문자열에서의 수를 세어 출력해야합니다. 그러나 일치하는 항목을 찾지 못하면 달리 출력 할 수없는 기본값 (예 -1: 빈 문자열)을 출력해야합니다.

알림

• I / O는 합리적인 형식입니다
• 표준 허점 은 금지되어 있습니다
• 제출은 전체 프로그램 또는 기능 일 수 있습니다
• Vroom 문자열은 1 개만 입력해야합니다.

채점

이것은 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.

온라인으로 사용해보십시오!

파이썬 2 , 56 53 바이트

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

온라인으로 사용해보십시오!

기본 정규식 및 그룹화는 값이 8 인 re.MULTILINE 플래그와 re.search를 사용하여 여러 줄 입력에 작동하는지 확인합니다. 일치하는 것이 없으면 예외가 발생합니다. (re.M == 8)팁 에서 -3 바이트에 대한 @ovs 덕분 입니다.

R , 62 60 58 44 바이트

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

온라인으로 사용해보십시오!

14 바이트 골프와 @ 주세페.

설명이 포함 된 독창적 인 접근 방식 :

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

온라인으로 사용해보십시오!

R에는 7 가지 패턴 매칭 기능이 있습니다. 더 일반적으로 사용되는 것들이다 grep,grepl 그리고 sub, 그러나 여기에 대한 좋은 사용이다 regexec.

regexec 당신에게 많은 것들을 제공합니다. 그중 하나는 캡처 된 부분 문자열의 길이입니다.이 경우에는 (o*) 정규식 일부입니다.

그만큼 attr(el .... "m")[2]물건 원하는 번호를 얻을 수있는 golfy 방법입니다.

NA일치하지 않는 경우를 반환 합니다.

자바 스크립트 (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

노트:

• slsSelect-String의 별명입니다. .
• (?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

PowerShell , 83 바이트

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

온라인으로 사용해보십시오!

-split입력이야 $args에 `newlines 파이프 루프 (A) 내로 이들을. 반복 할 때마다 우리 [regex]::Match는 우리의 여부를 확인합니다 .success. 그렇다면 $x파이프 라인에 (정규 결과 개체)를 남겨 둡니다 . 루프 외부에서 .length속성 을 가져옵니다 . 정규식 결과 개체 인 경우 일치 길이입니다 (예 : "Vroom!"은 6). 정규식 결과 객체가 아닌 경우 길이는 0입니다. 그런 다음에 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!찾을 수 없는 경우 무한 루프를 시작합니다 .

펄 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▀÷↕┐ò

실행 및 디버깅

하스켈 , 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))
    }
  }
}

apt , 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당신이 빗자루하지 않을 때 제공합니다 .

빨강 , 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을 반환합니다.

자바 스크립트, 90 73 61 바이트

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

온라인으로 사용해보십시오!

캡처되지 않은 문자를 (o*)빈 문자열 length로 바꾸십시오. 포함 된 문자열 만 반환 "o"하거나 -1결과 문자열이 비어있는 경우.

루비, 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

온라인으로 사용해보십시오!

여러 줄 문자열에는 3 바이트가 더 필요합니다. 그것이 어려운 요구 사항인지 확실하지 않습니다. 그렇다면 업데이트하겠습니다.

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

클로저 , 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

펄 -nE, 35 바이트

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

이것은 에스키모 인사말 ( }{)을 -n사용하여 펄이 옵션을 처리 하는 방법에 대한 간단한 설명을 남용합니다 .

자바 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 코어) , 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 바이트

Zacharý 덕분에 -5 바이트

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