introduzione

Il mio tachimetro dell'auto è stato violato! Invece di mostrarmi quanto sto guidando veloce, mostra solo: "Vroooom!" Per favore, aiutami a sapere quanto sto andando veloce.

Sfida

Prendi una stringa come input e controlla se corrisponde alla regex /^[Vv]ro*m!$/m. In inglese ciò significa che qualsiasi riga della stringa deve iniziare con una maiuscola o minuscola v, quindi una minuscola r, quindi qualsiasi quantità (incluso zero) della lettera minuscola o, quindi la stringa esatta m!. Potrebbero esserci altre righe, ma la stringa di Vroom deve trovarsi sulla propria riga.

Se trovi una corrispondenza, devi contare la quantità di o"s" nella stringa di Vroom ed emetterla. Se tuttavia non trovi una corrispondenza, dovresti generare qualsiasi valore predefinito che non può essere emesso in altro modo (come -1o una stringa vuota)

promemoria

• L'I / O è in qualsiasi formato ragionevole
• Le scappatoie standard sono vietate
• L'invio può essere un programma o una funzione completi
• È garantito che l'input abbia solo 1 stringa Vroom

punteggio

Questo è code-golf , quindi vince il codice più breve in byte. Tuttavia , non segnerò alcuna risposta come accettata.

Casi test

Ingresso

Vrom!

Produzione 1

Ingresso

vrooooooom!

Produzione 7

Ingresso

Hello, Vroom!

Produzione (none)

Ingresso

Foo bar boo baz
Vrooom!
hi

Produzione 3

Ingresso

Vrm!ooo

Produzione (none)

Ingresso

PPCG puzzlers pie

Produzione (none)

Ingresso

hallo
vROOOm!

Produzione (none)

sed 4.2.2 , 20 byte

-nr opzioni richieste dalla riga di comando.

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

Questo genera la velocità in modo unario come il numero di os.

Provalo online!

Python 2 , 56 53 byte

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

Provalo online!

Regex e raggruppamento di base, utilizza il flag re.MULTILINE (che ha un valore di 8) e re.search per assicurarsi che funzioni per input multilinea. Solleva un'eccezione quando non viene trovata alcuna corrispondenza. Grazie a @ovs per i -3 byte dal (re.M == 8)suggerimento.

R , 62 60 58 44 byte

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

Provalo online!

@Giuseppe con 14 byte giocati a golf.

Approccio originale con spiegazione:

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

Provalo online!

R ha sette funzioni di corrispondenza dei motivi. Quelli più comunemente usati sono grep, greple sub, ma ecco un buon uso per regexec.

regexecti dà un sacco di cose, una delle quali è la lunghezza di qualsiasi sottostringa catturata, in questo caso la (o*)parte della regex multilinea.

Il attr(el .... "m")[2]materiale è un modo da golf per ottenere il numero desiderato.

Restituisce NAse non c'è corrispondenza.

JavaScript (Node.js) , 41 byte

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

Provalo online!

PowerShell 62 58 53 48 byte byte

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

restituisce i numeri di oin un primo Vroom!o -4 se Vroom!non trovato.

Appunti:

• slsè alias per Select-String ;
• (?m-i) dentro regexp significa:
  • Usa la modalità multilinea. ^e $abbina l'inizio e la fine di una riga, anziché l'inizio e la fine di una stringa.
  • Usa la corrispondenza sensibile al maiuscolo / minuscolo
• |% M*è una scorciatoia per la proprietàMatches , che fornisce una prima corrispondenza perché non utilizziamo il -AllMatchesparametro

Script di prova:

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

Produzione:

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

Provalo online!

-splits l'input $argssu `newlines, li convoglia in un ciclo for. Ad ogni iterazione, controlliamo se la nostra [regex]::Matchè .successo meno. In tal caso, lasciamo $x(l'oggetto dei risultati regex) sulla pipeline. Al di fuori del ciclo, prendiamo la .lengthproprietà: se si tratta dell'oggetto risultati regex, questa è la lunghezza della corrispondenza (ad esempio, "Vroom!" Sarebbe 6); se non è un oggetto risultati regex, la lunghezza è zero. Quindi sottraggiamo 4per rimuovere i conteggi per Vrm!e lasciarli sulla pipeline. L'output è implicito. Emette un -4se non viene trovata alcuna corrispondenza.

Retina , 21 byte

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

Provalo online! Spiegazione: Lelenca le corrispondenze, quindi se la regex non corrisponde, l'output è vuoto. $fa sì che il risultato sia la sostituzione anziché la corrispondenza. mlo rende una corrispondenza su più righe (l'equivalente del finale mnella domanda). La .sostituzione sostituisce in output la lunghezza della cattura in decimale.

SNOBOL4 (CSNOBOL4) , 99 82 byte

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

Provalo online!

Traduzione SNOBOL piuttosto diretta delle specifiche, legge ogni riga fino a quando non ne trova una corrispondente ^[Vv]ro*m!$, quindi restituisce la lunghezza dio* bit.

Inserisce un ciclo infinito se non è Vroom!possibile trovare nessuno .

Perl 6 , 26 byte

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

Provalo online!

C (gcc) , 188 183 byte

Perché usare regex quando invece puoi usare una macchina a stati? :-)

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

Provalo online!

Stax , 16 byte

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

Esegui ed esegui il debug

Haskell , 75 71 69 byte

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

Provalo online!

Nessuna regex. Costruisce invece tutte le Vrooom!stringhe valide fino a una lunghezza sufficiente e confronta le linee dell'input con esse, raccogliendo il numero di os in un elenco. Pertanto, per input non validi viene restituito un elenco vuoto.

C (gcc) , 104 100 byte

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

Provalo online!

Emette il nper ogni riga valida, esattamente nel requisito (niente se nessuna riga valida, nse esattamente 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 byte

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

Provalo online!

Ha salvato un byte prendendo l'input come una matrice di linee.

Include un carattere non stampabile tra ]e *.

Spiegazione:

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 byte

Ecco il modo noioso regex.

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

Provalo online!

Pyth , 28 byte

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

Provalo online!

Pyth, 20 byte

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

Emette come un elenco contenente solo il numero di 'o' o un elenco vuoto se non c'è Vroom.
Provalo qui

Spiegazione

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

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

Provalo online!

Abbina regex ^[Vv]r(o*)m!$in modalità multilinea; lunghezza di uscita del gruppo di acquisizione.

sfk , 94 byte

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

Provalo online!

Dà -1quando non stai curando.

Rosso , 104 byte

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

Provalo online!

Una soluzione semplice. Red's parseè bello e leggibile, ma troppo lungo rispetto a regex

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 byte

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

Restituisce 1 negativo se il modello non corrisponde.

JavaScript, 90 73 61 byte

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

Provalo online!

Sostituisci i caratteri che non sono stati catturati (o*)con una stringa vuota, il ritorno lengthdella stringa contenente solo "o"o -1se la stringa risultante è vuota.

Rubino, 32 byte

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

Abbina la stringa alla regex, quindi utilizza le variabili magiche del gruppo regex di Ruby per ottenere la dimensione del primo gruppo.

Chiamalo così:

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

Rubino , 28 29 byte

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

Provalo online!

Le stringhe multilinea richiedono altri tre byte. Non sono sicuro che sia un requisito difficile. In tal caso, lo aggiornerò.

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

Clojure , 90 byte

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

Provalo online!

Questa funzione anonima restituisce il numero di "o" s nella stringa di Vroom o -1 se non è presente una stringa di Vroom valida.

Versione leggibile

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

Spiegazione

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

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

Questo usa il saluto eschimese ( }{) che abusa della rapida su come l' -nopzione perl è gestita da perl.

Java 8, 109 byte

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

Provalo online.

Spiegazione:

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 byte

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

Provalo online!

-12 byte: spostato il null controllo nel for ciclo e rimosse le parentesi

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 byte

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

Sebbene 05AB1E sia un linguaggio di golf, le sfide basate sul regex non sono sicuramente la sua suite forte, dal momento che non ha built-in regex.

Emette []se non viene trovata alcuna corrispondenza.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

-5 byte grazie a Zacharý

Si compila anche solo con l' regexintestazione

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

Test:

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