Muitas vezes, vemos vídeos de música no Youtube. Muitos canais do YouTube que hospedam vídeos de música são "alimentados por VEVO". Eles podem ser facilmente identificados, incorporando o VEVO nas miniaturas de vídeo e anexando o VEVO ao nome do canal.

Agora, escreva algum código para testar se uma string fornecida pelo usuário é uma conta de usuário VEVO ou não.

Requisitos para cadeias de conta de usuário válidas do VEVO:

• Deve conter apenas caracteres maiúsculos, minúsculos e dígitos. (sem espaço em branco ou pontuação)

• Não deve exceder 80 caracteres.

• Deve ter substring "VEVO" no final da string

Casos de teste:

Entradas válidas:

AdeleVEVO
ConnieTalbotVEVO
SHMVEVO
justimberlakeVEVO
DJMartinJensenVEVO
test123VEVO

Entradas inválidas:

syam kapuk
jypentertainment
Noche de Brujas
testVEVO123

Obviamente, como se trata de código-golfe , estou procurando o código mais curto usando qualquer linguagem de programação.

Python 2 , 45 bytes

-3 bytes graças a Rod. -2 bytes graças a ovs.

lambda s:len(s)<81*s.isalnum()<'VEVO'==s[-4:]

Experimente online!

Uma solução regex acaba sendo mais longa.

lambda s:re.match('^[^\W_]{0,76}VEVO$',s)
import re

Japt v2.0a0, 20 16 bytes

Retorna 1para válido ou 0inválido. [\l\d]também funcionaria no lugar da [^\W_]mesma contagem de bytes.

è/^\w{0,76}VEVO$

Experimente | Verifique todos os casos de teste

Explicação : èconta o número de correspondências do RegEx na entrada. No Japt, a \wclasse RegEx não inclui sublinhado.

JavaScript (ES6), 27 36 34 31 bytes

Economizou 2 bytes graças a @Neil e 3 bytes graças a @Shaggy

s=>/^[^\W_]{0,76}VEVO$/.test(s)

Casos de teste

let f =

s=>/^[^\W_]{0,76}VEVO$/.test(s)

console.log(f('syam kapuk')) // (INVALID)
console.log(f('jypentertainment')) // (INVALID)
console.log(f('Noche de Brujas')) // (INVALID)
console.log(f('testVEVO123')) // (INVALID)
console.log(f('AdeleVEVO')) // (VALID)
console.log(f('ConnieTalbotVEVO')) // (VALID)
console.log(f('SHMVEVO')) // (VALID)
console.log(f('justimberlakeVEVO')) // (VALID)
console.log(f('DJMartinJensenVEVO')) // (VALID)

PHP , 51 bytes

-10 bytes graças a @Ismael Miguel por usar em <?=vez de <?php echo! e removendo a tag de fechamento

<?=preg_match("/^[^\W_]{0,76}VEVO$/",fgets(STDIN));

Experimente online!

Obrigado pelas outras respostas, para não precisar escrever o regex!

APL (Dyalog) , 25 bytes

≢'^[^_\W]{0,76}VEVO$'⎕S 3

Experimente online!

C (gcc) , 83 bytes

c,i;f(char*s){for(c=i=0;s[i];c+=!isalnum(s[i++]));c=i<81*!c*!strcmp("VEVO",s+i-4);}

Experimente online!

Dyalog APL , 47 bytes

{0::0⋄(∧/(1(819⌶)t)∊⎕A,⎕D)∧77>≢t←,∘'VEVO'⍣¯1⊢⍵}

Experimente online!

Uma solução de regex pura tem 32 bytes , mas também é muito mais chata do que essa abordagem.

{0::0⋄(∧/(1(819⌶)t)∊⎕A,⎕D)∧77>≢t←,∘'VEVO'⍣¯1⊢⍵} a dfn with right arg '⍵'
 0::0⋄                                          on error, return 0
                                 ,∘'VEVO'       a train that appends VEVO
                                         ⍣¯1    apply it -1 times
                                             ⍵  on '⍵'
                                                and error if impossible (which returns 0)
                               t←               save on variable 't'
                              ≢                 get the length of that
                           77>                  if that's smaller than 77
                          ∧                     and
         (1(819I)t)                              [for each of] 't' uppercased
                   ∊⎕A,⎕D                        is it in the uppercase alphabet concatenated with the digits
       ∧/                                        reduced by and

Grime , 13 bytes

e`n{-76"VEVO"

Experimente online!

Nada extravagante aqui. Combine a eentrada ntire com o padrão: no máximo 76 ncaracteres alfa uméricos, seguidos pela sequência VEVO. Imprime 1para correspondência e 0sem correspondência. Lembrei-me de que a última cotação poderia ser removida no final da linha, mas aparentemente apenas causa um erro de análise.

C # (.NET Core) , 87 + 18 = 105 bytes

Experimente online!

a=>a.Where(x=>char.IsLetterOrDigit(x)).Count()==a.Length&a.Length<81&a.EndsWith("VEVO")

> <> , 147 125 bytes

!\i:0(?^1[::::::"/9@Z`z"!
;>{(?;{(?v{(?;{(?v{(?;{(?v
 ~l1-?!v >       > !|!: !<
;v    ]/~l99*-0(?!;4["OVEV"{-?;{-?;{-?;{-?;1n

Experimente online!

> <> , 147 bytes

Experimente online!

Isso imprime 1 se a sequência de entrada for válida e nada para uma entrada inválida.

Editar 1: Alteradas as verificações alfanuméricas para usar intervalos em vez de comparar com cada caractere. (economizando 22 bytes)

Bash, 53 26 30 bytes

[[ $1 =~ ^[^\W_]{0,76}VEVO$ ]]

Código de saída 0 para resultados VALID e 1 para resultados INVALID.

Ainda trabalhando com 80 caracteres ou menos.

-27 bytes de remoção de saída, graças a @KeyWeeUsr

+4 bytes, regex fixo (igual a todos os outros)

Experimente online!

> <> , 101 89 83 81 94 bytes

Editar: Alterado para a verificação de caracteres não alfanuméricos em vez de alfanuméricos. Voltei porque esqueci de verificar entre Z e a. Obrigado @Emigna. Rasgue esses bytes perdidos

Edit 2: Além disso, eu posso simplesmente me livrar daqueles}}}}. Obrigado Teal pelican por isso e encontrando o problema com o TIO

Editar 3: substituiu um ~~~ por ap

!\i::0(?v:::"/")$":"(*$:"`")$"{"(*+$:"@")$"["(*+?
0/?("S"l/
l/"VEVO"[4pn?$0(6
!\{-?vl?
1/;n0/n

Não sei por que isso não funcionará no TIO, mas funciona bem aqui . O problema era que os comandos {} no TIO não funcionam para uma lista vazia. Experimente aqui

Como funciona

!\i::0(?v:::"/")$":"(*$:"`")$"{"(*+$:"@")$"["(*+?
0/....../
......... Checks each input is alphanumeric
...       If any isn't, print 0 and exit with an error
...

...
0/?("S"l/ Checks if there are more than 80 characters
...       If so, print 0 and exit with an error
...
...

...
...
l/"VEVO"[4pn?$0(6 Check if the input is less than 4 characters
...               If so, print 0 and exit with an error
...

...
...
./"VEVO"[4pn?$0(6 Take the last 4 characters of the input into a new stack (first time I've actually used [)
...               Add "VEVO" to the stack to compare
...

...
0/....../n
........V
!\{-?vl?  Check if the last 4 characters are VEVO
1/;n0/n   Print 1 and exit with an error if so, else print 0 and exit

Por consistência, substituindo o; na última linha com uma instrução inválida, torna todas as saídas um erro.

C ++, 129 105 102 bytes

Graças a outras respostas que me mostraram que posso contar o número de caracteres
-2 bytes graças a Zacharý

#include<regex>
int v(std::string s){return std::regex_match(s, std::regex("[a-zA-Z0-9]{0,76}VEVO"));}

TIO LINK

Empilhados , 21 bytes

['^\i{0,76}VEVO'-''=]

Experimente online!

05AB1E , 21 bytes

žKÃQsg81‹IR4£"OVEV"QP

Experimente online!

Java (OpenJDK 8) , 37 36 bytes

Resposta bastante simples usando alguns regex adorável.
Possivelmente, a resposta Java mais curta que eu já fiz.
-1 bytes graças a Neil na resposta Javascript

w->w.matches("((?!_)\\w){0,76}VEVO")

Experimente online!

Retina , 18 bytes

A`\W|_|.{81}
VEVO$

Experimente online!

ou

^[^\W_]{0,76}VEVO$

Experimente online!

Haskell , 75 bytes

-2 bytes graças a user28667.

import Data.Char
f s|l<-length s=all isAlphaNum s&&l<81&&drop(l-4)s=="VEVO"

Experimente online!

Deorst , 22 bytes

'^[^\W_]{0,76}VEVO$'gm

Experimente online!

Apenas usa o regex encontrado por Shaggy

V , 17 bytes

ø^¨áüä©û,76}VEVO$

Experimente online!

Hexdump:

00000000: f85e a8e1 fce4 a9fb 2c37 367d 5645 564f  .^......,76}VEVO
00000010: 24                                       $

Regexes compactadas para a vitória!

ø                   " Count the number of matches of
 ^                  "   The beginning of the line
  ¨áüä©             "   A letter or number...
       û,76}        "   From 0 to 76 times...
            VEVO    "   Followed by "VEVO"
                $   "   At the end of the line

Ruby -n, 22 + 1 = 23 bytes

p~/^[^\W_]{0,76}VEVO$/

Saída 0se verdadeira, nilse falsa

Experimente online!

Usando o mesmo regex chato que todo mundo.

Swift 4 , 113 bytes

import Foundation;var f={(s:String)->Bool in s.range(of:"^[^\\W_]{0,76}VEVO$",options:.regularExpression) != nil}

Experimente online!

AWK , 23 bytes

$0~/^[^\W_]{0,76}VEVO$/

Experimente online!

Emite o nome da conta se válido e nada emite se não for válido

Limpo , 61 bytes

import StdEnv
?['VEVO']=True
?[_:l]=length l<80&& ?l
?_=False

Experimente online!

Perl 5 , 35 29 + 1 (-a) = 30 bytes

-6 bytes graças a ETHproductions

Adicionado 4 bytes. Não viu que o sublinhado não era permitido.

Este é o meu primeiro golfe, então espero que eu tenha feito certo.

Retorna 1 se válido, 0 se não.

print/^[^\W_]{0,76}VEVO$/?1:0

Experimente online!

Planilhas Google, 33 bytes

Função de planilha anônima que leva entrada do intervalo A1e saídas para a célula chamadora

=RegexMatch(A1,"^[^\W_]{0,76}VEVO

Clojure , 146 bytes

(fn[u](let[c count](and(<(c u)81)(=(c(filter #(let[i(int %)](or(< 47 i 58)(< 64 i 91)(< 96 i 123)))u))(c u))(clojure.string/ends-with? u"VEVO"))))

Experimente online!

Isso seria muito mais curto usando um regex, mas achei que fazê-lo manualmente seria mais interessante.

(defn vevo? [username]
  (and (< (count username) 81)

       ; Filter out the illegal characters, then check if the length is the same as the original string
       (= (count (filter #(let [i (int %)]
                            ; Make sure the char code is in the valid ranges
                            (or (< 47 i 58) (< 64 i 91) (< 96 i 123)))
                         username))
          (count username))

       (clojure.string/ends-with? username "VEVO")))