Introducción

¡El velocímetro de mi auto fue pirateado! En lugar de mostrarme qué tan rápido estoy conduciendo, simplemente muestra: "¡Vroooom!" Por favor, ayúdame a saber qué tan rápido voy.

Desafío

Tome una cadena como entrada y verifique si coincide con la expresión regular /^[Vv]ro*m!$/m. En inglés, eso significa que cualquier línea de la cadena debe comenzar con mayúscula o minúscula v, luego minúscula r, luego cualquier cantidad (incluido cero) de la letra minúscula o, luego la cadena exacta m!. Puede haber otras líneas, pero la cadena de Vroom debe estar en su propia línea.

Si encuentra una coincidencia, debe contar la cantidad de o's en la cadena de Vroom y generarla. Sin embargo, si no encuentra una coincidencia, debe generar cualquier valor predeterminado que no se pueda generar de otra manera (como -1una cadena vacía)

Recordatorios

• I / O está en cualquier formato razonable
• Las lagunas estándar están prohibidas
• La presentación puede ser un programa o función completa
• Se garantiza que la entrada solo tenga 1 cadena Vroom

Puntuación

Este es el código golf , por lo que gana el código más corto en bytes. Sin embargo , no marcaré ninguna respuesta como aceptada.

Casos de prueba

Entrada

Vrom!

Salida 1

Entrada

vrooooooom!

Salida 7

Entrada

Hello, Vroom!

Salida (none)

Entrada

Foo bar boo baz
Vrooom!
hi

Salida 3

Entrada

Vrm!ooo

Salida (none)

Entrada

PPCG puzzlers pie

Salida (none)

Entrada

hallo
vROOOm!

Salida (none)

sed 4.2.2 , 20 bytes

-nr opciones requeridas en la línea de comandos.

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

Esto genera la velocidad en unario como el número de os.

Pruébalo en línea!

Python 2 , 56 53 bytes

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

Pruébalo en línea!

La expresión regular y la agrupación básicas utilizan el indicador re.MULTILINE (que tiene un valor de 8) y re.search para garantizar que funcione para entradas de varias líneas. Provoca una excepción cuando no se encuentra ninguna coincidencia. Gracias a @ovs por los -3 bytes de (re.M == 8)tip.

R , 62 60 58 44 bytes

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

Pruébalo en línea!

@Giuseppe con 14 bytes de golf.

Enfoque original con explicación:

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

Pruébalo en línea!

R tiene siete funciones de coincidencia de patrones. Los más comúnmente utilizados son grep, greply sub, pero aquí hay un uso agradable para regexec.

regexecle ofrece un montón de cosas, una de las cuales es la longitud de cualquier subcadena capturada, en este caso la (o*)parte de la expresión regular multilínea.

El attr(el .... "m")[2]material es una forma de golf para obtener el número deseado.

Devuelve NAsi no hay coincidencia.

JavaScript (Node.js) , 41 bytes

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

Pruébalo en línea!

Powershell, 62 58 53 48 bytes bytes

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

devuelve números de oen un primero Vroom!, o -4 si Vroom!no se encuentra.

Notas:

• sls es alias para Select-String ;
• (?m-i) regexp interior significa:
  • Utiliza el modo multilínea. ^y hacer $coincidir el principio y el final de una línea, en lugar del principio y el final de una cadena.
  • Usar coincidencia entre mayúsculas y minúsculas
• |% M*es un acceso directo para la propiedad Matches, que da una primera coincidencia porque no usamos-AllMatches parámetro.

Script de prueba:

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

Salida:

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

PowerShell , 83 bytes

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

Pruébalo en línea!

-splits la entrada $argsen `newlines, los canaliza en un bucle for. Cada iteración, verificamos si nuestro [regex]::Matches un .successo no. Si es así, dejamos $x(el objeto de resultados regex) en la tubería. Fuera del ciclo, tomamos la .lengthpropiedad: si es el objeto de resultados de expresiones regulares, esta es la duración de la coincidencia (por ejemplo, "¡Vroom!" Sería 6); Si no es un objeto de resultados de expresiones regulares, la longitud es cero. Luego restamos 4para eliminar los recuentos para el Vrm!y dejarlo en la tubería. La salida es implícita. Da como resultado -4si no se encuentra ninguna coincidencia.

Retina , 21 bytes

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

Pruébalo en línea! Explicación: Lenumera las coincidencias, por lo que si la expresión regular no coincide, la salida está vacía. $hace que el resultado sea la sustitución en lugar del partido. mlo convierte en una coincidencia multilínea (el equivalente al final mde la pregunta). El .en la sustitución hace que produzca la longitud de la captura en decimal.

SNOBOL4 (CSNOBOL4) , 99 82 bytes

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

Pruébalo en línea!

La traducción SNOBOL bastante directa de la especificación, lee cada línea hasta que encuentra una que coincida ^[Vv]ro*m!$, luego emite la longitud de la líneao* bit.

Entra en un bucle infinito si no Vroom!se puede encontrar.

Perl 6 , 26 bytes

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

Pruébalo en línea!

C (gcc) , 188 183 bytes

¿Por qué usar expresiones regulares cuando puedes usar una máquina de estado? :-)

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

Pruébalo en línea!

Stax , 16 bytes

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

Ejecutar y depurarlo

Haskell , 75 71 69 bytes

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

Pruébalo en línea!

Sin expresiones regulares. En su lugar, construye todas las Vrooom!cadenas válidas hasta una longitud suficiente y compara las líneas de la entrada con ellas, recogiendo el número de os en una lista. Por lo tanto, para entradas no válidas se devuelve una lista vacía.

C (gcc) , 104100 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;}

Pruébalo en línea!

Salida npara cada línea válida, exactamente en el requisito (nada si no hay una línea válida, nsi es exactamente una)

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

Pruébalo en línea!

Guardado un byte tomando la entrada como una matriz de líneas.

Incluye un carácter no imprimible entre ]y* .

Explicación:

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 bytes

Aquí está la forma aburrida de expresiones regulares.

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

Pruébalo en línea!

Pyth , 28 bytes

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

Pruébalo en línea!

Pyth, 20 bytes

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

Se muestra como una lista que contiene solo el número de 'o' o una lista vacía si no hay Vroom.
Pruébalo aquí

Explicación

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

Pipa , 21 bytes

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

Pruébalo en línea!

Match regex ^[Vv]r(o*)m!$en modo multilínea; longitud de salida del grupo de captura.

sfk , 94 bytes

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

Pruébalo en línea!

Da -1cuando no estás vrooming.

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

Pruébalo en línea!

Una solución sencilla. El rojo parsees genial y legible, pero demasiado largo en comparación con la expresión regular.

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

Devuelve 1 negativo si el patrón no coincide.

JavaScript, 90 73 61 bytes

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

Pruébalo en línea!

Reemplace los caracteres que no se capturan (o*)con una cadena vacía, el retorno lengthde la cadena que contiene solo "o"o -1si la cadena resultante está vacía.

Ruby, 32 bytes

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

Hace coincidir la cadena con la expresión regular, luego usa las variables de grupo de expresión mágica de Ruby para obtener el tamaño del primer grupo.

Llámalo así:

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

Pruébalo en línea!

Las cadenas de varias líneas requieren tres bytes más. No estoy seguro si ese es un requisito difícil. Si es así, actualizaré esto.

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

Pruébalo en línea!

Esta función anónima devuelve el número de "o" s en la cadena vroom, o -1 si no hay una cadena vroom válida.

Versión legible

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

Explicación

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

Utiliza el saludo esquimal ( }{) que abusa de un rápido sobre cómo -nPerl maneja la opción.

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

Pruébalo en línea.

Explicación:

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

Pruébalo en línea!

-12 bytes: movió el null cheque al for bucle y eliminó los corchetes

Sin 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 bytes

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

Aunque 05AB1E es un lenguaje de golf, los desafíos basados ​​en expresiones regulares definitivamente no son su paquete fuerte, ya que no tiene incorporados expresiones regulares.

Salidas [] si no se encontró coincidencia.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

|              # 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 gracias a Zacharý

Se compila incluso solo con el regexencabezado

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

Pruebas:

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