Spesso vediamo video musicali su Youtube. Molti canali Youtube che ospitano video musicali sono "powered by VEVO". Questi possono essere facilmente identificati sia incorporando VEVO nelle miniature dei video sia aggiungendo VEVO al nome del loro canale.

Ora scrivi un po 'di codice per verificare se una stringa fornita dall'utente è un account utente VEVO o meno.

Requisiti per le stringhe di account utente VEVO valide:

• Deve contenere solo caratteri maiuscoli, minuscoli e cifre. (nessuno spazio bianco o punteggiatura)

• Non deve superare 80 caratteri di lunghezza.

• Deve avere la sottostringa "VEVO" alla fine della stringa

Casi test:

Ingressi validi:

AdeleVEVO
ConnieTalbotVEVO
SHMVEVO
justimberlakeVEVO
DJMartinJensenVEVO
test123VEVO

Ingressi non validi:

syam kapuk
jypentertainment
Noche de Brujas
testVEVO123

Certo, dato che si tratta di code-golf , sto cercando il codice più breve usando qualsiasi linguaggio di programmazione.

Python 2 , 45 byte

-3 byte grazie a Rod. -2 byte grazie agli ovs.

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

Provalo online!

Una soluzione regex risulta essere più lunga.

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

Japt v2.0a0, 20 16 byte

Restituisce 1per valido o 0per non valido. [\l\d]funzionerebbe anche al posto di [^\W_]per lo stesso conteggio byte.

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

Provalo | Controlla tutti i casi di test

Spiegazione : èconta il numero di corrispondenze del RegEx nell'input. In Japt, la \wclasse RegEx non include il carattere di sottolineatura.

JavaScript (ES6), 27 36 34 31 byte

Salvato 2 byte grazie a @Neil e 3 byte grazie a @Shaggy

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

Casi test

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 byte

-10 byte grazie a @Ismael Miguel per l'utilizzo al <?=posto di <?php echo! e rimuovendo il tag di chiusura

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

Provalo online!

Grazie per le altre risposte, quindi non ho dovuto scrivere la regex!

APL (Dyalog) , 25 byte

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

Provalo online!

C (gcc) , 83 byte

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

Provalo online!

Dyalog APL , 47 byte

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

Provalo online!

Una soluzione regex pura è di 32 byte , ma è anche molto più noiosa di questo approccio.

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

e`n{-76"VEVO"

Provalo online!

Niente di speciale qui. Abbina l' einput ntire al modello: al massimo 76 ncaratteri alfanumerici, seguiti dalla stringa VEVO. Stampa 1per corrispondenza e 0per nessuna corrispondenza. Ho ricordato che l'ultima citazione potrebbe essere rimossa alla fine della riga, ma a quanto pare provoca solo un errore di analisi.

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

Provalo online!

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

> <> , 147 125 byte

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

Provalo online!

> <> , 147 byte

Provalo online!

Stampa 1 se la stringa di input è valida e nulla per un input non valido.

Modifica 1: Modificati i controlli alfanumerici per usare gli intervalli piuttosto che confrontarli con ogni personaggio. (risparmio di 22 byte)

Bash, 53 26 30 byte

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

Codice di uscita 0 per risultati VALIDI e 1 per risultati NON VALIDI.

Funziona ancora su 80 caratteri o meno.

-27 byte dalla rimozione dell'output, grazie a @KeyWeeUsr

+4 byte, regex fisso (uguale a tutti gli altri)

Provalo online!

> <> , 101 89 83 81 94 byte

Modifica: è passato al controllo dei caratteri non alfanumerici anziché alfanumerici. Passato indietro perché ho dimenticato di controllare tra Z e a. Grazie @Emigna. Strappa quei byte persi però

Modifica 2: Inoltre, posso semplicemente sbarazzarmi di quelli}}}}. Grazie pellicano Teal per questo e per aver trovato il problema con TIO

Modifica 3: sostituito a ~~~ con ap

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

Non so perché questo non funziona su TIO, ma funziona bene qui . Il problema era che i comandi {} in TIO non funzionano per un elenco vuoto.Provalo qui

Come funziona

!\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

Per coerenza, sostituendo il; nell'ultima riga con un'istruzione non valida rende ogni uscita un errore.

C ++, 129 105 102 byte

Grazie ad altre risposte che mi hanno mostrato che posso contare il numero di caratteri
-2 byte grazie 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

Impilato , 21 byte

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

Provalo online!

05AB1E , 21 byte

žKÃQsg81‹IR4£"OVEV"QP

Provalo online!

Java (OpenJDK 8) , 37 36 byte

Risposta piuttosto semplice usando un po 'di regex adorabile.
Probabilmente la risposta Java più breve che abbia mai fatto.
-1 byte grazie a Neil sulla risposta Javascript

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

Provalo online!

Retina , 18 byte

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

Provalo online!

o

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

Provalo online!

Haskell , 75 byte

-2 byte grazie a user28667.

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

Provalo online!

Deorst , 22 byte

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

Provalo online!

Usa solo la regex trovata da Shaggy

V , 17 byte

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

Provalo online!

hexdump:

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

Regex compressi per la vittoria!

ø                   " 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 byte

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

Uscita 0se vero, nilse falso

Provalo online!

Usando la stessa regex noiosa di tutti gli altri.

Swift 4 , 113 byte

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

Provalo online!

AWK , 23 byte

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

Provalo online!

Emette il nome dell'account se valido e non genera nulla se non è valido

Pulito , 61 byte

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

Provalo online!

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

-6 byte grazie a ETHproductions

Aggiunti 4 byte. Non ho visto che il carattere di sottolineatura non era permesso.

Questo è il mio primo golf, quindi spero di averlo fatto bene.

Restituisce 1 se valido, 0 in caso contrario.

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

Provalo online!

Fogli Google, 33 byte

Funzione del foglio di lavoro anonima che accetta input dall'intervallo A1e output nella cella chiamante

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

Clojure , 146 byte

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

Provalo online!

Questo sarebbe molto più breve usando un regex, ma ho pensato che farlo manualmente sarebbe stato più 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")))