Einführung

Mein Autotacho wurde gehackt! Anstatt mir zu zeigen, wie schnell ich fahre, zeigt es nur: "Vroooom!" Bitte hilf mir zu wissen, wie schnell ich gehe.

Herausforderung

Nehmen Sie eine Zeichenfolge als Eingabe und prüfen Sie, ob sie mit der regulären Ausdrucksweise übereinstimmt /^[Vv]ro*m!$/m. Auf Englisch bedeutet dies, dass jede Zeile der Zeichenfolge mit einem Groß- oder Kleinbuchstaben v, einem Kleinbuchstaben r, einem beliebigen Betrag (einschließlich Null) des Kleinbuchstabens ound der genauen Zeichenfolge beginnen muss m!. Möglicherweise gibt es andere Zeilen, aber die Vroom-Zeichenfolge muss in einer eigenen Zeile stehen.

Wenn Sie eine Übereinstimmung finden, müssen Sie die Anzahl der oEinträge in der Vroom-Zeichenfolge zählen und ausgeben. Wenn Sie jedoch keine Übereinstimmung finden, sollten Sie einen Standardwert ausgeben, der ansonsten nicht ausgegeben werden kann (wie -1oder eine leere Zeichenfolge).

Erinnerungen

• I / O hat ein beliebiges vernünftiges Format
• Standardlücken sind verboten
• Die Einreichung kann ein vollständiges Programm oder eine Funktion sein
• Der Eingang hat garantiert nur eine Vroom-Zeichenfolge

Wertung

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes. Allerdings werde ich keine Antwort markieren als angenommen.

Testfälle

Eingang

Vrom!

Ausgabe 1

Eingang

vrooooooom!

Ausgabe 7

Eingang

Hello, Vroom!

Ausgabe (none)

Eingang

Foo bar boo baz
Vrooom!
hi

Ausgabe 3

Eingang

Vrm!ooo

Ausgabe (none)

Eingang

PPCG puzzlers pie

Ausgabe (none)

Eingang

hallo
vROOOm!

Ausgabe (none)

sed 4.2.2 , 20 Bytes

-nr Erforderliche Optionen in der Befehlszeile.

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

Dies gibt die Geschwindigkeit unär als die Anzahl von os aus.

Probieren Sie es online!

Python 2 , 56 53 Bytes

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

Probieren Sie es online!

Grundlegende reguläre Ausdrücke und Gruppierungen verwenden das Flag re.MULTILINE (mit dem Wert 8) und re.search, um sicherzustellen, dass es für mehrzeilige Eingaben funktioniert. Löst eine Ausnahme aus, wenn keine Übereinstimmung gefunden wird. Danke an @ovs für die -3 Bytes von (re.M == 8)tip.

R , 62 60 58 44 Byte

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

Probieren Sie es online!

@ Giuseppe mit 14 Bytes Golf.

Ursprünglicher Ansatz mit Erklärung:

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

Probieren Sie es online!

R hat sieben Mustervergleichsfunktionen. Die am häufigsten verwendeten sind grep, greplund sub, aber hier ist eine gute Verwendung für regexec.

regexecgibt Ihnen eine Reihe von Dingen, von denen eine die Länge einer erfassten Teilzeichenfolge ist, in diesem Fall der (o*)Teil der mehrzeiligen Regex.

Das attr(el .... "m")[2]Zeug ist ein golferischer Weg, um die gewünschte Anzahl zu bekommen.

Gibt zurück, NAwenn keine Übereinstimmung vorliegt.

JavaScript (Node.js) , 41 Byte

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

Probieren Sie es online!

Powershell, 62 58 53 48 Bytes Bytes

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

Gibt die Anzahl von oin einem ersten Vroom!oder -4 zurück, wenn Vroom!nicht gefunden.

Anmerkungen:

• slsist ein Alias ​​für Select-String ;
• (?m-i) inside regexp bedeutet:
  • Verwenden Sie den mehrzeiligen Modus. ^und $passen Sie den Anfang und das Ende einer Zeile an, anstatt den Anfang und das Ende einer Zeichenfolge.
  • Verwenden Sie die Suche nach Groß- und Kleinschreibung
• |% M*ist eine Abkürzung für die Eigenschaft Matches, die eine erste Übereinstimmung ergibt, da wir keine -AllMatchesParameter verwenden.

Testskript:

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

Ausgabe:

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

PowerShell , 83 Byte

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

Probieren Sie es online!

-splits die Eingabe $argsin `newlines, leitet diese in eine for-Schleife. Bei jeder Iteration prüfen wir, ob unsere [regex]::Matcheine ist .successoder nicht. In $xdiesem Fall belassen wir das Regex-Ergebnisobjekt in der Pipeline. Außerhalb der Schleife nehmen wir die .lengthEigenschaft - wenn es sich um das Regex-Ergebnisobjekt handelt, ist dies die Länge der Übereinstimmung (z. B. "Vroom!" Wäre 6); Wenn es sich nicht um ein reguläres Ergebnisobjekt handelt, ist die Länge Null. Wir subtrahieren dann 4, um die Zählungen für die zu entfernen, Vrm!und belassen diese in der Pipeline. Die Ausgabe ist implizit. Gibt a aus, -4wenn keine Übereinstimmung gefunden wird.

Netzhaut , 21 Bytes

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

Probieren Sie es online! Erläuterung: LListet Übereinstimmungen auf. Wenn die Regex nicht übereinstimmt, ist die Ausgabe leer. $bewirkt, dass das Ergebnis eher die Substitution als das Match ist. mmacht es zu einem mehrzeiligen Match (das Äquivalent zum Trailing min der Frage). Mit .der Option in der Ersetzung wird die Länge der Erfassung in Dezimalzahl ausgegeben.

SNOBOL4 (CSNOBOL4) , 99 82 Bytes

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

Probieren Sie es online!

Ziemlich direkte SNOBOL-Übersetzung der Spezifikation, liest jede Zeile, bis eine übereinstimmende gefunden wird ^[Vv]ro*m!$, und gibt dann die Länge des o*Bits aus.

Gibt eine Endlosschleife ein, wenn keine gefunden werden Vroom!kann.

Perl 6 , 26 Bytes

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

Probieren Sie es online!

C (GCC) , 188 183 Bytes

Warum Regexes verwenden, wenn Sie stattdessen eine Zustandsmaschine verwenden können? :-)

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

Probieren Sie es online!

Stax , 16 Bytes

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

Führen Sie es aus und debuggen Sie es

Haskell , 75 71 69 Bytes

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

Probieren Sie es online!

Kein Regex. Vrooom!Baut stattdessen alle gültigen -strings bis zu einer ausreichenden Länge auf und vergleicht die Zeilen der Eingabe mit ihnen, wobei die Anzahl der os in einer Liste erfasst wird . Bei ungültigen Eingaben wird daher eine leere Liste zurückgegeben.

C (GCC) , 104 100 Bytes

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

Probieren Sie es online!

Geben Sie die nfür jede gültige Zeile genau in der Anforderung aus (nichts, wenn keine gültige Zeile, nwenn genau eine).

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 Bytes

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

Probieren Sie es online!

Ein Byte wurde gespeichert, indem Eingaben als Array von Zeilen übernommen wurden.

Enthält ein nicht druckbares Zeichen zwischen ]und *.

Erläuterung:

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) , 138–124 Bytes

Hier ist der langweilige Regex-Weg.

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

Probieren Sie es online!

Pyth , 28 Bytes

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

Probieren Sie es online!

Pyth, 20 Bytes

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

Wird als Liste ausgegeben, die nur die Anzahl der O enthält, oder als leere Liste, wenn kein Vroom vorhanden ist.
Probieren Sie es hier aus

Erläuterung

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

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

Probieren Sie es online!

Regex ^[Vv]r(o*)m!$im mehrzeiligen Modus anpassen ; Ausgabelänge der Erfassungsgruppe.

sfk , 94 bytes

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

Probieren Sie es online!

Gibt, -1wenn Sie nicht vrooming sind.

Rot , 104 Bytes

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

Probieren Sie es online!

Eine einfache Lösung. Rot parseist cool und lesbar, aber im Vergleich zu Regex zu lang

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 Bytes

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

Gibt eine negative 1 zurück, wenn das Muster nicht übereinstimmt.

JavaScript, 90 73 61 Bytes

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

Probieren Sie es online!

Ersetzen Sie nicht erfasste Zeichen (o*)durch leere Zeichenfolgen, geben Sie lengthnur Zeichenfolgen zurück, die diese enthalten, "o"oder geben Sie an, -1dass die resultierende Zeichenfolge leer ist.

Ruby, 32 Bytes

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

Ordnet die Zeichenfolge dem regulären Ausdruck zu und verwendet dann Rubys magische reguläre Gruppenvariablen, um die Größe der ersten Gruppe zu ermitteln.

Nenne es so:

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

Ruby , 28 29 Bytes

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

Probieren Sie es online!

Mehrzeilige Zeichenfolgen erfordern drei weitere Bytes. Ich bin mir nicht sicher, ob das eine harte Anforderung ist. Wenn ja, werde ich dies aktualisieren.

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

Clojure , 90 Bytes

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

Probieren Sie es online!

Diese anonyme Funktion gibt die Anzahl der "0" in der Vroom-Zeichenfolge zurück oder -1, wenn keine gültige Vroom-Zeichenfolge vorhanden ist.

Lesbare Version

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

Erläuterung

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

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

Dies verwendet die Eskimo-Begrüßung ( }{), die einen kurzen Einblick in den Umgang mit der -nOption durch Perl gibt.

Java 8, 109 Bytes

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

Probieren Sie es online aus.

Erläuterung:

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) , 134 122 Bytes

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

Probieren Sie es online!

-12 Bytes: null Check in Loop verschoben for und Klammern entfernt

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 Bytes

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

Obwohl 05AB1E eine Golf-Sprache ist, sind Regex-basierte Herausforderungen definitiv nicht ihre starke Suite, da es keine Regex-eingebauten hat.

[]Wird ausgegeben, wenn keine Übereinstimmung gefunden wurde.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

|              # 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 Bytes

-5 Bytes dank Zacharý

Es wird auch nur mit dem regexHeader kompiliert

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

Tests:

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