introduction

Mon compteur de vitesse a été piraté! Au lieu de me montrer à quelle vitesse je conduis, cela montre simplement: "Vroooom!" S'il vous plaît, aidez-moi à savoir à quelle vitesse je vais.

Défi

Prenez une chaîne en entrée et vérifiez si elle correspond à l'expression régulière /^[Vv]ro*m!$/m. En anglais, cela signifie que toute ligne de la chaîne doit commencer par une majuscule ou une minuscule v, puis une minuscule r, puis n'importe quel montant (y compris zéro) de la lettre minuscule o, puis la chaîne exacte m!. Il peut y avoir d'autres lignes, mais la chaîne Vroom doit être sur sa propre ligne.

Si vous trouvez une correspondance, vous devez compter la quantité de o's dans la chaîne Vroom et la sortir. Si vous ne trouvez pas de correspondance cependant, vous devez sortir toute valeur par défaut qui ne peut pas être sortie autrement (comme -1ou une chaîne vide)

Rappels

• Les E / S sont dans un format raisonnable
• Les failles standard sont interdites
• La soumission peut être un programme ou une fonction complète
• L'entrée est garantie d'avoir seulement 1 chaîne Vroom

Notation

C'est le code-golf , donc le code le plus court en octets l'emporte. Cependant , je ne marquerai aucune réponse comme acceptée.

Cas de test

Contribution

Vrom!

Production 1

Contribution

vrooooooom!

Production 7

Contribution

Hello, Vroom!

Production (none)

Contribution

Foo bar boo baz
Vrooom!
hi

Production 3

Contribution

Vrm!ooo

Production (none)

Contribution

PPCG puzzlers pie

Production (none)

Contribution

hallo
vROOOm!

Production (none)

sed 4.2.2 , 20 octets

-nr options requises sur la ligne de commande.

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

Cela délivre la vitesse en unaire comme le nombre de os.

Essayez-le en ligne!

Python 2 , 56 53 octets

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

Essayez-le en ligne!

Regex et regroupement de base, utilise l'indicateur re.MULTILINE (qui a une valeur de 8) et re.search pour s'assurer qu'il fonctionne pour les entrées multilignes. Lève une exception lorsqu'aucune correspondance n'est trouvée. Merci à @ovs pour les -3 octets de (re.M == 8)tip.

R , 62 60 58 44 octets

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

Essayez-le en ligne!

@Giuseppe avec 14 octets de golf.

Approche originale avec explication:

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

Essayez-le en ligne!

R a sept fonctions d'appariement de motifs. Les plus couramment utilisés sont grep, greplet sub, mais voici une bonne utilisation pour regexec.

regexecvous donne un tas de choses, dont la longueur de toute sous-chaîne capturée, dans ce cas la (o*)partie de l'expression régulière multiligne.

Le attr(el .... "m")[2]truc est une façon golfique d'obtenir le nombre souhaité.

Renvoie NAs'il n'y a pas de correspondance.

JavaScript (Node.js) , 41 octets

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

Essayez-le en ligne!

Powershell, 62 58 53 48 octets octets

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

renvoie les nombres de odans un premier Vroom!, ou -4 s'il Vroom!n'est pas trouvé.

Remarques:

• slsest un alias pour Select-String ;
• (?m-i) dans regexp signifie:
  • Utilisez le mode multiligne. ^et faire $correspondre le début et la fin d'une ligne, au lieu du début et de la fin d'une chaîne.
  • Utiliser la correspondance sensible à la casse
• |% M*est un raccourci pour la propriété Matches, qui donne une première correspondance car nous n'utilisons pas de -AllMatchesparamètre.

Script de test:

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

Production:

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

PowerShell , 83 octets

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

Essayez-le en ligne!

-splits l'entrée $argssur`n ewlines, les conduit dans une boucle for. A chaque itération, nous vérifions si notre [regex]::Matchest .successou non. Si c'est le cas, nous laissons $x(l'objet de résultats d'expression régulière) sur le pipeline. En dehors de la boucle, nous prenons la .lengthpropriété - si c'est l'objet de résultats d'expression régulière, c'est la longueur de la correspondance (par exemple, "Vroom!" Serait 6); s'il ne s'agit pas d'un objet de résultat d'expression régulière, la longueur est nulle. Nous soustrayons ensuite 4pour supprimer les décomptes pour le Vrm!et laisser cela sur le pipeline. La sortie est implicite. Génère un -4si aucune correspondance n'est trouvée.

Rétine , 21 octets

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

Essayez-le en ligne! Explication: Lrépertorie les correspondances. Par conséquent, si l'expression régulière ne correspond pas, la sortie est vide. $fait que le résultat est la substitution plutôt que la correspondance. men fait une correspondance multiligne (l'équivalent de la fin mde la question). Le .dans la substitution lui fait sortir la longueur de la capture en décimal.

SNOBOL4 (CSNOBOL4) , 99 82 octets

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

Essayez-le en ligne!

Traduction SNOBOL assez directe de la spécification, lit chaque ligne jusqu'à ce qu'elle trouve celle qui correspond ^[Vv]ro*m!$ , puis sort la longueur du o*bit.

Entre dans une boucle infinie si aucune ne Vroom!peut être trouvée.

Perl 6 , 26 octets

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

Essayez-le en ligne!

C (gcc) , 188 183 bytes

Pourquoi utiliser des expressions régulières alors que vous pouvez utiliser une machine d'état à la place? :-)

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

Essayez-le en ligne!

Stax , 16 octets

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

Exécuter et déboguer

Haskell , 75 71 69 octets

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

Essayez-le en ligne!

Aucun regex. À la place, construit toutes les Vrooom!chaînes valides jusqu'à une longueur suffisante et compare les lignes de l'entrée avec elles, en collectant le nombre de os dans une liste. Ainsi, pour les entrées non valides, une liste vide est renvoyée.

C (gcc) , 104100 octets

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

Essayez-le en ligne!

Afficher le npour chaque ligne valide, exactement dans l'exigence (rien si aucune ligne valide, le nsi exactement une)

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 octets

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

Essayez-le en ligne!

Enregistré un octet en prenant l'entrée comme un tableau de lignes.

Comprend un caractère non imprimable entre ]et *.

Explication:

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 octets

Voici le moyen de regex ennuyeux.

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

Essayez-le en ligne!

Pyth , 28 octets

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

Essayez-le en ligne!

Pyth, 20 octets

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

Affiche une liste contenant uniquement le nombre de «o» ou une liste vide s'il n'y a pas de Vroom.
Essayez-le ici

Explication

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

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

Essayez-le en ligne!

Correspond à l'expression régulière ^[Vv]r(o*)m!$en mode multiligne; longueur de sortie du groupe de capture.

sfk , 94 octets

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

Essayez-le en ligne!

Donne -1quand vous n'êtes pas en train de nettoyer.

Rouge , 104 octets

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

Essayez-le en ligne!

Une solution simple. Le rouge parseest cool et lisible, mais trop long par rapport à l'expression régulière

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 octets

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

Renvoie 1 négatif si le motif ne correspond pas.

JavaScript, 90 73 61 octets

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

Essayez-le en ligne!

Remplacez les caractères qui ne sont pas capturés (o*)par une chaîne vide, retour lengthde chaîne contenant uniquement "o"ou -1si la chaîne résultante est vide.

Rubis, 32 octets

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

Correspond à la chaîne avec l'expression régulière, puis utilise les variables de groupe d'expression magique magique de Ruby pour obtenir la taille du premier groupe.

Appelez-le ainsi:

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

Rubis , 28 29 octets

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

Essayez-le en ligne!

Les chaînes multilignes nécessitent trois octets supplémentaires. Je ne sais pas si c'est une exigence difficile. Si oui, je mettrai à jour cela.

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

Clojure , 90 octets

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

Essayez-le en ligne!

Cette fonction anonyme renvoie le nombre de "o" dans la chaîne vroom, ou -1 s'il n'y a pas de chaîne vroom valide.

Version lisible

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

Explication

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

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

Cela utilise le message d'accueil esquimau ( }{) qui abuse rapidement de la façon dont l' -noption est traitée par perl.

Java 8, 109 octets

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

Essayez-le en ligne.

Explication:

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 octets

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

Essayez-le en ligne!

-12 octets: déplacement du null chèque dans la for boucle et suppression des crochets

Non golfé:

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 octets

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

Bien que 05AB1E soit un langage de golf, les défis basés sur les regex ne sont certainement pas sa suite forte, car il n'a pas de regex-builtins.

Affiche []si aucune correspondance n'a été trouvée.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

-5 octets grâce à Zacharý

Il compile même avec l'en- regextête uniquement

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