Nous voyons souvent des clips vidéo sur Youtube. De nombreuses chaînes Youtube qui hébergent des clips vidéo sont "propulsées par VEVO". Ceux-ci peuvent être facilement identifiés en intégrant VEVO à leurs vignettes vidéo et en ajoutant VEVO à leur nom de chaîne.

Maintenant, écrivez du code pour tester si une chaîne donnée par l'utilisateur est un compte utilisateur VEVO ou non.

Conditions requises pour les chaînes de compte d'utilisateur VEVO valides:

• Ne doit contenir que des majuscules, des minuscules et des chiffres. (sans espace ni ponctuation)

• Ne doit pas dépasser 80 caractères.

• Doit avoir une sous-chaîne "VEVO" à la fin de la chaîne

Cas de test:

Entrées valides:

AdeleVEVO
ConnieTalbotVEVO
SHMVEVO
justimberlakeVEVO
DJMartinJensenVEVO
test123VEVO

Entrées non valides:

syam kapuk
jypentertainment
Noche de Brujas
testVEVO123

Bien sûr, comme il s'agit de code-golf , je recherche le code le plus court en utilisant n'importe quel langage de programmation.

Python 2 , 45 octets

-3 octets grâce à Rod. -2 octets grâce aux ovs.

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

Essayez-le en ligne!

Une solution regex s'avère plus longue.

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

Japt v2.0a0, 20 16 octets

Renvoie 1pour valide ou 0pour invalide. [\l\d]fonctionnerait également à la place du [^\W_]même nombre d'octets.

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

Essayez-le | Vérifier tous les cas de test

Explication : ècompte le nombre de correspondances du RegEx dans l'entrée. Dans Japt, la \wclasse RegEx n'inclut pas de soulignement.

JavaScript (ES6), 27 36 34 31 octets

Enregistré 2 octets grâce à @Neil et 3 octets grâce à @Shaggy

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

Cas de 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 octets

-10 octets grâce à @Ismael Miguel pour avoir utilisé <?=au lieu de <?php echo! et supprimer la balise de fermeture

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

Essayez-le en ligne!

Merci pour les autres réponses, donc je n'ai pas eu à écrire l'expression régulière!

APL (Dyalog) , 25 octets

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

Essayez-le en ligne!

C (gcc) , 83 octets

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

Essayez-le en ligne!

Dyalog APL , 47 octets

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

Essayez-le en ligne!

Une solution regex pure est de 32 octets , mais est également beaucoup plus ennuyeuse que cette approche.

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

e`n{-76"VEVO"

Essayez-le en ligne!

Rien d'extraordinaire ici. eFaites correspondre l' entrée ntire avec le modèle: au plus 76 ncaractères alphanumériques, suivis de la chaîne VEVO. Imprime 1pour correspondance et 0pour aucune correspondance. Je me suis souvenu que la dernière citation pouvait être supprimée à la fin de la ligne, mais apparemment, cela provoque juste une erreur d'analyse.

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

Essayez-le en ligne!

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

> <> , 147 125 octets

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

Essayez-le en ligne!

> <> , 147 octets

Essayez-le en ligne!

Cela affiche 1 si la chaîne d'entrée est valide et rien pour une entrée non valide.

Édition 1: modification des vérifications alphanumériques pour utiliser des plages plutôt que de comparer avec chaque personnage. (économie de 22 octets)

Bash, 53 26 30 octets

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

Quittez le code 0 pour les résultats VALIDES et 1 pour les résultats INVALIDES.

Travaille toujours sur 80 caractères ou moins.

-27 octets de suppression de sortie, grâce à @KeyWeeUsr

+4 octets, regex fixe (comme tout le monde)

Essayez-le en ligne!

> <> , 101 89 83 81 94 octets

Modifier: basculé vers la vérification des caractères non alphanumériques plutôt que des caractères alphanumériques. Je suis revenu car j'ai oublié de vérifier entre Z et a. Merci @Emigna. Rip ces octets perdus si

Edit 2: En outre, je peux tout simplement me débarrasser de ces}}}}. Merci Pélican sarcelle pour cela et trouver le problème avec TIO

Edit 3: remplacé un ~~~ par ap

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

Je ne sais pas pourquoi cela ne fonctionnera pas sur TIO, mais cela fonctionne bien ici . Le problème était que les commandes {} dans TIO ne fonctionnent pas pour une liste vide.Essayez-le ici

Comment ça marche

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

Par souci de cohérence, remplacer le; dans la dernière ligne avec une instruction invalide fait chaque sortie est une erreur.

C ++, 129 105 102 octets

Merci à d'autres réponses qui m'ont montré que je peux compter le nombre de caractères
-2 octets grâce à Zacharý

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

TIO LINK

Empilé , 21 octets

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

Essayez-le en ligne!

05AB1E , 21 octets

žKÃQsg81‹IR4£"OVEV"QP

Essayez-le en ligne!

Java (OpenJDK 8) , 37 36 octets

Réponse assez simple en utilisant une belle expression régulière.
Probablement la réponse Java la plus courte que j'aie jamais faite.
-1 octets grâce à Neil sur la réponse Javascript

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

Essayez-le en ligne!

Rétine , 18 octets

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

Essayez-le en ligne!

ou

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

Essayez-le en ligne!

Haskell , 75 octets

-2 octets grâce à user28667.

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

Essayez-le en ligne!

Deorst , 22 octets

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

Essayez-le en ligne!

Utilise simplement l'expression régulière trouvée par Shaggy

V , 17 octets

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

Essayez-le en ligne!

Hexdump:

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

Des regex compressés pour la victoire!

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

Output 0 if true, nil if false

Try it online!

Using the same boring regex as everybody else.

Swift 4, 113 bytes

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

Try it online!

AWK, 23 bytes

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

Try it online!

Outputs the account name if valid, and outputs nothing if it isn't valid

Clean, 61 bytes

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

Try it online!

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

-6 bytes thanks to ETHproductions

Added 4 bytes. Didn't see that underscore wasn't allowed.

This is my first golf, so here's hoping I did it right.

Returns 1 if valid, 0 if not.

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

Try it online!

Google Sheets, 33 Bytes

Anonymous worksheet function that takes input from range A1 and outputs to the calling cell

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

Try it online!

This would be much shorter using a regex, but I figured doing it manually would be more interesting.

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