A menudo vemos videos musicales en Youtube. Muchos canales de Youtube que alojan videos musicales están "impulsados ​​por VEVO". Esos pueden identificarse fácilmente incrustando VEVO en sus miniaturas de video y agregando VEVO al nombre de su canal.

Ahora escriba algún código para probar si una cadena dada por el usuario es una cuenta de usuario VEVO o no.

Requisitos para cadenas de cuenta de usuario VEVO válidas:

• Solo debe contener mayúsculas, minúsculas y caracteres de dígitos. (sin espacios en blanco o puntuación)

• No debe exceder los 80 caracteres de longitud.

• Debe tener una subcadena "VEVO" al final de la cadena

Casos de prueba:

Entradas válidas:

AdeleVEVO
ConnieTalbotVEVO
SHMVEVO
justimberlakeVEVO
DJMartinJensenVEVO
test123VEVO

Entradas inválidas:

syam kapuk
jypentertainment
Noche de Brujas
testVEVO123

Por supuesto, debido a que esto es código golf , estoy buscando el código más corto usando cualquier lenguaje de programación.

Python 2 , 45 bytes

-3 bytes gracias a Rod. -2 bytes gracias a los ovs.

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

Pruébalo en línea!

Una solución regex resulta ser más larga.

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

Japt v2.0a0, 20 16 bytes

Devoluciones 1válidas o 0inválidas. [\l\d]también funcionaría en lugar de[^\W_] para el mismo recuento de bytes.

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

Intentalo | Verifique todos los casos de prueba

Explicación : ècuenta el número de coincidencias del RegEx en la entrada. En Japt, la \wclase RegEx no incluye guión bajo.

JavaScript (ES6), 27 36 34 31 bytes

Guardado 2 bytes gracias a @Neil y 3 bytes gracias a @Shaggy

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

Casos de prueba

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 gracias a @Ismael Miguel por usar en <?=lugar de <?php echo! y quitando la etiqueta de cierre

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

Pruébalo en línea!

¡Gracias por las otras respuestas, así que no tuve que escribir la expresión regular!

APL (Dyalog) , 25 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Dyalog APL , 47 bytes

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

Pruébalo en línea!

Una solución regex pura tiene 32 bytes , pero también es mucho más aburrida que este enfoque.

{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"

Pruébalo en línea!

Nada lujoso aquí. eHaga coincidir la entrada ntire con el patrón: como máximo 76 ncaracteres alfanuméricos, seguidos de la cadena VEVO. Imprime 1por partido y 0sin partido. Recordé que la última cita podría eliminarse al final de la línea, pero aparentemente solo causa un error de análisis.

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

Pruébalo en línea!

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

> <> , 147125 bytes

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

Pruébalo en línea!

> <> , 147 bytes

Pruébalo en línea!

Esto imprime 1 si la cadena de entrada es válida y nada para una entrada no válida.

Edición 1: Cambió las comprobaciones alfanuméricas para usar rangos en lugar de comparar con cada personaje. (ahorro de 22 bytes)

Bash, 53 26 30 bytes

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

Código de salida 0 para resultados VÁLIDOS y 1 para resultados NO VÁLIDOS.

Aún trabajando en 80 caracteres o menos.

-27 bytes desde la eliminación de la salida, gracias a @KeyWeeUsr

+4 bytes, expresión regular fija (igual que todos los demás)

Pruébalo en línea!

> <> , 101 89 83 81 94 bytes

Editar: se cambió a la comprobación de caracteres no alfanuméricos en lugar de caracteres alfanuméricos.Cambié de nuevo porque olvidé comprobar entre Z y a. Gracias @Emigna. Aunque rasgue esos bytes perdidos

Edición 2: Además, puedo deshacerme de esos}}}}. Gracias a Teal pelican por eso y por encontrar el problema con TIO

Edición 3: reemplazó un ~~~ con ap

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

No sé por qué esto no funcionará en TIO, pero funciona bien aquí . El problema era que los comandos {} en TIO no funcionan para una lista vacía. Pruébalo aquí

Cómo 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 consistencia, reemplazando el; en la última línea con una instrucción no válida, cada salida es un error.

C ++, 129 105 102 bytes

Gracias a otras respuestas que me mostraron que puedo contar el número de caracteres
-2 bytes gracias 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

Apilado , 21 bytes

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

Pruébalo en línea!

05AB1E , 21 bytes

žKÃQsg81‹IR4£"OVEV"QP

Pruébalo en línea!

Java (OpenJDK 8) , 37 36 bytes

Respuesta bastante simple usando una hermosa expresión regular.
Posiblemente la respuesta Java más corta que haya hecho.
-1 bytes gracias a Neil en la respuesta Javascript

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

Pruébalo en línea!

Retina , 18 bytes

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

Pruébalo en línea!

o

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

Pruébalo en línea!

Haskell , 75 bytes

-2 bytes gracias al usuario28667.

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

Pruébalo en línea!

Deorst , 22 bytes

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

Pruébalo en línea!

Solo usa la expresión regular encontrada por Shaggy

V , 17 bytes

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

Pruébalo en línea!

Hexdump:

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

Regexes comprimidos para la victoria!

ø                   " 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$/

Salida 0si es verdad,nil si es falso

Pruébalo en línea!

Usando la misma expresión regular aburrida como todos los demás.

Swift 4 , 113 bytes

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

Pruébalo en línea!

AWK , 23 bytes

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

Pruébalo en línea!

Muestra el nombre de la cuenta si es válido y no muestra nada si no es válido

Limpio , 61 bytes

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

Pruébalo en línea!

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

-6 bytes gracias a ETHproductions

Se agregaron 4 bytes. No vi que el subrayado no estaba permitido.

Este es mi primer golf, así que espero que lo haya hecho bien.

Devuelve 1 si es válido, 0 si no.

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

Pruébalo en línea!

Hojas de cálculo de Google, 33 bytes

Función de hoja de trabajo anónima que toma entrada del rango A1y salidas a la celda que llama

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

Pruébalo en línea!

Esto sería mucho más corto usando una expresión regular, pero pensé que hacerlo manualmente sería más interesante.

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