[Question]
  [
We often see music videos on Youtube. Many Youtube channels that host music videos are "powered by VEVO". Those can be easily identified by both embedding VEVO at their video thumbnails and appending VEVO to their channel name.
Now write some code to test whether a string given by user is a VEVO user account or not.
Requirements for valid VEVO user account strings:
* Must only contain uppercase, lowercase, and digit characters. (no whitespace or punctuation)
* Must not exceed 80 characters length.
* Must have "VEVO" substring at the end of string
Test cases:
Valid inputs:
```
AdeleVEVO
ConnieTalbotVEVO
SHMVEVO
justimberlakeVEVO
DJMartinJensenVEVO
test123VEVO
```
Invalid inputs:
```
syam kapuk
jypentertainment
Noche de Brujas
testVEVO123
```
Of course, because this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), I'm looking for the shortest code using any programming language.
  
[Answer]
# [Python 2](https://docs.python.org/2/), 45 bytes
*-3 bytes thanks to Rod. -2 bytes thanks to ovs.*
```
lambda s:len(s)<81*s.isalnum()<'VEVO'==s[-4:]
```
[Try it online!](https://tio.run/##VY89b4NADEB3foU3oGoqJelQoTAkbaUoUtqhVZYkgwlGObjzofMx8Osp0CJRT/bzx5Pr1t8tr7oivXQaTZYjSKKJI4k3L8sHeVKCmhsTxZvw9H76DNNUzovn5Np5Ei@QwjmAPkJp0UCFdVOFj7@kbGtiT86jYtNnE/@wtztBTrBzTYky4eHeYFiu1hPa5qRptP6BV8us6Bt1Zv2cf@2P87JsxCuTkdNY/dt/OxzRecUHYiGedwZ7bx5RcA2CwjpQoBjGN5NxqHaKPRSRirsf "Python 2 – Try It Online")
A regex solution turns out to be longer.
```
lambda s:re.match('^[^\W_]{0,76}VEVO$',s)
import re
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt/) v2.0a0, ~~20~~ 16 bytes
Returns `1` for valid or `0` for invalid. `[\l\d]` would also work in place of `[^\W_]` for the same byte count.
```
è/^\w{0,76}VEVO$
```
[Try it](https://ethproductions.github.io/japt/?v=2.0a0&code=6C9eXHd7MCw3Nn1WRVZPJA==&input=InRlc3QxMjNWRVZPIg==) | [Check all test cases](https://ethproductions.github.io/japt/?v=2.0a0&code=y+gvXlx3ezAsNzZ9VkVWTyQ=&input=WyJzeWFtIGthcHVrIiwianlwZW50ZXJ0YWlubWVudCIsIk5vY2hlIGRlIEJydWphcyIsInRlc3RWRVZPMTIzIiwiQWRlbGVWRVZPIiwiQ29ubmllVGFsYm90VkVWTyIsIlNITVZFVk8iLCJqdXN0aW1iZXJsYWtlVkVWTyIsIkRKTWFydGluSmVuc2VuVkVWTyIsInRlc3QxMjNWRVZPIl0KLVE=)
**Explanation**: `è` counts the number of matches of the RegEx in the input. In Japt, the `\w` RegEx class doesn't include underscore.
[Answer]
# JavaScript (ES6), ~~27~~ ~~36~~ ~~34~~ 31 bytes
*Saved 2 bytes thanks to @Neil and 3 bytes thanks to @Shaggy*
```
s=>/^[^\W_]{0,76}VEVO$/.test(s)
```
### Test cases
```
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)
```
[Answer]
# [PHP](https://php.net/), 51 bytes
-10 bytes thanks to @Ismael Miguel for using `<?=` instead of `<?php echo`! and removing the closing tag
```
<?=preg_match("/^[^\W_]{0,76}VEVO$/",fgets(STDIN));
```
[Try it online!](https://tio.run/##K8go@P/fxt62oCg1PT43sSQ5Q0NJPy46LiY8PrbaQMfcrDbMNcxfRV9JJy09taRYIzjExdNPU9P6///0NJAMAA "PHP – Try It Online")
Thanks for the other answers so I didn't have to write the regex!
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 25 bytes
```
≢'^[^_\W]{0,76}VEVO$'⎕S 3
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1HnIvW46Lj4mPDYagMdc7PaMNcwfxX1R31TgxWM//9Pe9Q2Aa8SrnSgimp1IHjUu@pR71YgCWRbKUC4U9OAQrVcXEC1QGXqnn5hjj6eLgolqcUlxeowUXUurnT14srEXIXsxILSbHUgL6uyIDWvJLWoJDEzLxfIAon55SdnpCqkpCo4FZVmJRaDhEDmgBxjaGSszoUwDspwTEnJLMnMz0vMUcBjMcgcA6ABJqZm5haWVGCBHITFNTgd4JiSmpMK0ZSu7pyfl5eZGpKYk5RfAhML9vCFMbNKi0syc5NSi3ISs@F6XLx8E4tKMvO8UvOKU/NgoiCbgA7C4RqksMHpMJhJ1AwdsJkA "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 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);}
```
[Try it online!](https://tio.run/##fY8/a8MwFMT3fApZUJBsB5q2Q0H10H9QAmmHhixtBkV@bp5tSUaSCyHks7tKh061t@Pux713av6l1DCoHEXF1F661PNjZR1TBRaXwn/gVqisSNDL1vSaRSPLtpyLmN/dLtJEpYkPTumO0c3z5o3mPsP5DRenAU0gWqJh3xZLTo4zQjoXzYrRi/LT0JxE5Q9Sk0Z2fUNj6b9IfejABHAhdumoRsFXq/ZASiAPrq@lH@UC@HD@dXF1Pcrcl9DC76Ax4tEag7CW7c6GSfD9ZTWZ170PqHfgWtlMn3xarqQLaJZgPJhJ9Lwx7vtjTrPhBw "C (gcc) – Try It Online")
[Answer]
# [Dyalog APL](https://www.dyalog.com/), 47 bytes
```
{0::0⋄(∧/(1(819⌶)t)∊⎕A,⎕D)∧77>≢t←,∘'VEVO'⍣¯1⊢⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24RqAysrg0fdLRqPOpbraxhqWBhaPurZplmi@aij61HfVEcdIOEC5Cw3N7d71LmoBKhF51HHDPUw1zB/9Ue9iw@tN3zUtehR79ZaoHnqaYnZqQpgKa409eLKxFyF7MSC0mwQLyM1Jyc/vjy/KCcFpiCrsiA1ryS1qCQxMy8XyAKJ@eUnZ6QqpKQqOBWVZiUWg4RKUotLQFoMjYxB3LLUsnxq4XyIU4B@BPrL0EBfXRdkg2NKak4qzJFgd8M4zvl5eZmpIYk5SfklMLFgD1@4h0qLSzJzk1KLcoDhABN08fJNLCrJzPNKzStOzYOJUtMXMDNBAQUMJDAXAA "APL (Dyalog Unicode) – Try It Online")
A pure regex solution is [32 bytes](https://tio.run/##SyzI0U2pTMzJT///P@1R2wR19UedCzXU4zQ07BXjNWPKNasNdMzNasNcw/xV1B/1TS1SV9cEqlRPS8xOVQCJqnOlqRdXJuYqZCcWlGaDeBmpOTn58eX5RTkpMAVZlQWpeSWpRSWJmXm5QBZIzC8/OSNVISVVwamoNCuxGCRUklpcAtJiaGQM4palluVTC@dDnAL0AdCThgb66rogGxxTUnNSYY4EuxvGcc7Py8tMDUnMScovgYkFe/jCPVRaXJKZm5RalAMMB5igi5dvYlFJZp5Xal5xah5MlJq@gJkJCihgIIG5AA), but also is much more boring than this approach.
```
{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
```
[Answer]
# [Grime](https://github.com/iatorm/grime), 13 bytes
```
e`n{-76"VEVO"
```
[Try it online!](https://tio.run/##Sy/KzE39/z81Ia9a19xMKcw1zF/p/38zE9OstKCwdA9vU5AIAA "Grime – Try It Online")
Nothing fancy here.
Match the `e`ntire input against the pattern: at most 76 alpha`n`umeric characters, followed by the string `VEVO`.
Prints `1` for match and `0` for no match.
I remembered that the last quote could be removed at end of line, but apparently it just causes a parse error.
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/learn/what-is-dotnet), 87 + 18 = 105 bytes
[Try it online!](https://tio.run/##lY/BTsMwDIbveYqoB5RILBI3pK67jCEhFQ0BWs9patrQNoHYRZvQnr2kG5M4TAJ8sn/7828bnBkfYBzQupo/7ZCgT9nPSuXWvaeMmU4j8gf2yXgMJE3W8A9vK36vrRPyIB@bU9wOzsyRQlx0yUvvuwV/iRLPOBt1ttCqaCCA2GYL0@ig7jAHIgjrcGNrS2IrpVr6wZGQWaZVDq6m5uKUzK@vYr5yFRaWGpFsVpt1Isd45cl@6R36DlQRLEH8AMTkLhLc6Z63@m1oEynTX8dfByTblxA63cLR5a/U7L9U1J2FZ92VniZomj0LPoKuDpz8fnjP9uMX)
```
a=>a.Where(x=>char.IsLetterOrDigit(x)).Count()==a.Length&a.Length<81&a.EndsWith("VEVO")
```
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~147~~ 125 bytes
```
!\i:0(?^1[::::::"/9@Z`z"!
;>{(?;{(?v{(?;{(?v{(?;{(?v
 ~l1-?!v >       > !|!: !<
;v    ]/~l99*-0(?!;4["OVEV"{-?;{-?;{-?;{-?;1n
```
[Try it online!](https://tio.run/##S8sszvj/XzEm08pAwz7OMNoKDJT0LR2iEqqUFLms7ao17K2BuAyd5lKoyzHUtVcsU7BTgAA7BcUaRSsFRRsu6zIQP1a/LsfSUksXaLKitUm0kn@Ya5hStS5QOxI2zPv/vyS1uMTQyBgo7Q8A "><> – Try It Online")
# [><>](https://esolangs.org/wiki/Fish), 147 bytes
[Try it online!](https://tio.run/##S8sszvj/XzEm08pAwz7OMFopMSk5JTUtPSMzKzsnNy@/oLCouKS0rLyissrRydnF1c3dw9PL28fXzz8gMCg4JDQsPCIyytDI2MTUzNzC0kBJkStH39621qraWtFe15Crzi7HUNdesYzLukwBBPSBApaWWrpAyxStTaKV/MNcw5Sqde2tkbFhHpdC7P//R1cfbTuy@kjv0d6UI5OB6vwB "><> – Try It Online")
This prints 1 if the input string is valid and nothing for an invalid input.
Edit 1: Changed the Alphanumeric checks to use ranges rather than comparing against every character. (saving 22 bytes)
[Answer]
# Bash, ~~53~~ ~~26~~ 30 bytes
```
[[ $1 =~ ^[^\W_]{0,76}VEVO$ ]]
```
Exit code 0 for VALID results and 1 for INVALID results.
~~Still working on 80 characters or less.~~
-27 bytes from removing output, thanks to @KeyWeeUsr
+4 bytes, fixed regex (same as everyone else)
[Try it online!](https://tio.run/##S0oszvivrKiflJmnnwRiR0crqBgq2NYpxEXHxYTHx1Yb6Jib1Ya5hvmrKMTG/v//vyS1uMTQyNgEJAQA "Try it online!")
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~101~~ ~~89~~ ~~83~~ ~~81~~ 94 bytes
Edit: ~~Switched to checking for non-alphanumeric characters rather than for alphanumeric.~~ Switched back cause I forget to check between Z and a. Thanks @Emigna. Rip those lost bytes though
Edit 2: Also, I can totally just get rid of those }}}}. Thanks [Teal pelican](https://codegolf.stackexchange.com/users/62009/teal-pelican) for that and finding the problem with TIO
Edit 3: replaced a ~~~ with a p
```
!\i::0(?v:::"/")$":"(*$:"`")$"{"(*+$:"@")$"["(*+?
0/?("S"l/
l/"VEVO"[4pn?$0(6
!\{-?vl?
1/;n0/n
```
~~I don't know why this won't work on TIO, but it works fine [here](https://fishlanguage.com/playground).~~ The problem was that the {} commands in TIO don't work for an empty list. [Try It Here](https://tio.run/##S8sszvj/XzEm08rKQMO@zMrKSklfSVNFyUpJQ0vFSikBxK4GsrWBHAcQJxrEsecy0LfXUApWytHnytFXCnMN81eKNinIs1cx0DDjUoyp1rUvy7HnMtS3zjPQz/v/vyS1uASkyNDIGAA)
### How It Works
```
!\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
```
For consistency, replacing the ; in the last line with an invalid instruction makes *every* output an error.
[Answer]
## C++, ~~129~~ ~~105~~ 102 bytes
Thanks to other answers that showed me that i can count the number of characters
  
 -2 bytes thanks to Zacharý
```
#include<regex>
int v(std::string s){return std::regex_match(s, std::regex("[a-zA-Z0-9]{0,76}VEVO"));}
```
[TIO LINK](https://tio.run/##TZBvS8MwEMZft5/iqCAtrDAVFNc6mTqR4RTc3Av/IFl3btnatCSX6Rz97DOJYn0T7nmS@12ey6oqnmfZbo@LLNczhJSXiiSyovvnpRLn@Nn1Fc06HVeDDINnFn/14qd2fPq6bbdOjutJf3IfRAkXBOvQvTUgLuagoq1E0lJAQ3grGGWLULVklNQ721MwLsIItr7HNJVAqAjOrPSC3gxzdPiWlZelEBzHLJ@W1Lijm2EjlloRL6Yoc7b613k1GDJJXAxQKBSNb4cdHB41htqwAlas0qtf3qZCQSjJfLIw1Y97V2YLBLO0C6mXTDUsCzK8wPfqxPe991JCaFPtM@i4ZC6n59aRlZogTSEY28QfnBYQWM2cCQBxbA6JSuekzEbcZbgOWQTnpunhsf8iAoMNrnu3I1tHiRnr17tv)
[Answer]
# [Stacked](https://github.com/ConorOBrien-Foxx/stacked), 21 bytes
```
['^\i{0,76}VEVO'-''=]
```
[Try it online!](https://tio.run/##Ky5JTM5OTfn/P1o9Liaz2kDH3Kw2zDXMX11XXd029r@DVRqXhnpJanEJWFABzDQCsY3BXKhoZX6pQnFBamK2Qk5marG6pkJ0mkJ@aUmsQm5iwX8A "Stacked – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 21 bytes
```
žKÃQsg81‹IR4£"OVEV"QP
```
[Try it online!](https://tio.run/##MzBNTDJM/f//6D7vw82BxekWho8adnoGmRxarOQf5hqmFBjw/39JanGJoZExkOsPAA "05AB1E – Try It Online")
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 37 36 bytes
Pretty simple answer using some lovely regex.  
Quite possibly the shortest Java answer I've ever done.  
-1 bytes thanks to Neil on the Javascript answer
```
w->w.matches("((?!_)\\w){0,76}VEVO")
```
[Try it online!](https://tio.run/##NYwxq8IwFIXn5Ffc55TAszjpUNTpjU8HwUVFbmusqWlSmluDlP72GEGnA@ec76vxgVPXKltf7rE06D38o7YDZ9qS6q5YKtgMHBgrnDMKLVRiR522FQSZczZyztq@MLoET0gpHk5foEmOz@9wApTJx74YLAEPs1P@rp6eVJO5nrI2jWSssFklgvyqP84N2ETFMF2FrEEqb8qLiRDrn7M8HoMcZr@L@bj/228nMrKcjzHWvSfdFKozeFfv5QU "Java (OpenJDK 8) – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina), 18 bytes
```
A`\W|_|.{81}
VEVO$
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7w3zEhJrwmvkav2sKwlivMNcxf5f//4srEXIXsxILSbK6syoLUvJLUopLEzLxcIIvLLz85I1UhJVXBqag0K7GYqyS1uASkzdDImMsxJTUnFcThcs7Py8tMDUnMScoHy3IFe/iC6azS4pLM3KTUopzEbIhSFy/fxCKge7xS84pT88BCIDOB5oHYAA "Retina – Try It Online")
or
```
^[^\W_]{0,76}VEVO$
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wPy46LiY8PrbaQMfcrDbMNcxf5f//4srEXIXsxILSbK6syoLUvJLUopLEzLxcIIvLLz85I1UhJVXBqag0K7GYqyS1uASkzdDImMsxJTUnFcThcs7Py8tMDUnMScoHy3IFe/iC6azS4pLM3KTUopzEbIhSFy/fxCKge7xS84pT88BCIDOB5oHYAA "Retina – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 75 bytes
*-2 bytes thanks to user28667.*
```
import Data.Char
f s|l<-length s=all isAlphaNum s&&l<81&&drop(l-4)s=="VEVO"
```
[Try it online!](https://tio.run/##VY69asNQDIX3PIXwYBJoAmk7dIiHNCmUgNOhJUvpoNRK77V1f7iSh0Df3XUMNVjT0XeQzjEoDTF3nXUxJIU9Kq52BtPsAvLLmyWT/1EDUiAzWNlyNHhsHUie8@ZpnedVCnHOy8eFFEV2ejm9ZZ1D66EAh7GEeUzWK6zgsphBP5@QyRUdNBjbJhvQHWT1NZJXStpful6NxjF8G4KK4Dm1NcrIlURvYev7h5FtK2IaGvyTXfDe0gfyOejEeH8tJ3vdilp3psTYTF/sDyUmtf5AXshPrFuHPn9g8NX9AQ "Haskell – Try It Online")
[Answer]
# [Deorst](https://github.com/cairdcoinheringaahing/Deorst), 22 bytes
```
'^[^\W_]{0,76}VEVO$'gm
```
[Try it online!](https://tio.run/##S0nNLyou@f9fPS46LiY8PrbaQMfcrDbMNcxfRT099////yWpxSWGRsYgEQA "Deorst – Try It Online")
Just uses the regex found by Shaggy
[Answer]
# [V](https://github.com/DJMcMayhem/V), 17 bytes
```
ø^¨áüä©û,76}VEVO$
```
[Try it online!](https://tio.run/##K/v///COuEMrDi88vOfwkkMrD@/WMTerDXMN81f5/985Py8vMzUkMScpvwQkBAA "V – Try It Online")
Hexdump:
```
00000000: f85e a8e1 fce4 a9fb 2c37 367d 5645 564f  .^......,76}VEVO
00000010: 24                                       $
```
Compressed regexes for the win!
```
ø                   " 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
```
[Answer]
# [Ruby](https://www.ruby-lang.org/) -n, 22+1 = 23 bytes
```
p~/^[^\W_]{0,76}VEVO$/
```
Output `0` if true, `nil` if false
[Try it online!](https://tio.run/##KypNqvz/v6BOPy46LiY8PrbaQMfcrDbMNcxfRf///8SkZEMjYxCPC8YsgzLj4aIKEAUVVAYYdv/LLyjJzM8r/q@bBwA "Ruby – Try It Online")
Using the same boring regex as everybody else.
[Answer]
# [Swift 4](https://developer.apple.com/swift/), 113 bytes
```
import Foundation;var f={(s:String)->Bool in s.range(of:"^[^\\W_]{0,76}VEVO$",options:.regularExpression) != nil}
```
[Try it online!](https://tio.run/##VdDdS8MwEADw9/4VZ/GhhTr8QmFSwelEBtOHyXzYh2T2Wm9LLyW56sbY317bjcLMU/LL5e5y7pdSua4qygtjBZ5NyYkSMnz3oyyk8TZw3ZFY4iw8u@8Zo4EYXMcqzjAwadefT@bT6cfnbHse3d7sxv3x26kfmaJJ4bodi1mple2vC4vO1RbCSQxMeldpFBB04iCGiQf18t1G5bBSRbnyo4MsNwWyoBVFnNe71l/N1zdCgtCz5VK5lpt8TQsXl1ctPSSosbEWHg0z4bvSCyPHPnoZHh@XpRPKF2i1Wv17/zQYKivEA2SHfHzTVK8r78mbeV5qLFAzr8M3t/uoop6lBGlAYejtqj8 "Swift 4 – Try It Online")
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 23 bytes
```
$0~/^[^\W_]{0,76}VEVO$/
```
[Try it online!](https://tio.run/##SyzP/v9fxaBOPy46LiY8PrbaQMfcrDbMNcxfRf///5LU4hJDI2MQFwA "AWK – Try It Online")
Outputs the account name if valid, and outputs nothing if it isn't valid
[Answer]
# [Clean](https://clean.cs.ru.nl), 61 bytes
```
import StdEnv
?['VEVO']=True
?[_:l]=length l<80&& ?l
?_=False
```
[Try it online!](https://tio.run/##JY2xCsIwFAD3fkWmZio4ihgyaAWh4NDSpZTy2sYaeHmRJhX8eZ9BxxvubkIDxM7PGxrhwBJb9/RrFHWcS3plupNt2d5kr5p1MwmHA/YKDS3xIfC43@W50JjpQV0Ag@E6QpKV0KKTJ09kTQM4@viP8Ge6IyyBi5GLa8XnN4GzU/hBOlZ2/AI "Clean – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), ~~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!](https://tio.run/##K0gtyjH9/7@gKDOvRD8uOi4mPD622kDH3Kw2zDXMX0Xf3tDK4P//kNTiEkMjY5DQv/yCksz8vOL/uokA "Perl 5 – Try It Online")
[Answer]
# 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
```
[Answer]
# [Clojure](https://clojure.org/), 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!](https://tio.run/##JY1NC4JQEEX/ymAEM4sKy0zBaFMbIdq5ERfyfNaEjPA@6Oe/Xra5HLiHe9U0v73RIeAore9w0q5VoGYvrsNeBqxQgaciJTyjwpEnpw2sFo@RxcGaOpwNVpCdgOFYUMQ8i1imPyzziOn@QESeaBmL@X/dWmdYnjstg9182L0u4JPm1jySaFMIIbnW9944llqL1bJUXw "Clojure – 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")))
```
]