21

हम अक्सर Youtube पर म्यूजिक वीडियो देखते हैं। कई Youtube चैनल जो संगीत वीडियो की मेजबानी करते हैं, "वीईवीओ द्वारा संचालित" हैं। उन दोनों को आसानी से उनके वीडियो थंबनेल पर VEVO को एम्बेड करके और VEVO को उनके चैनल के नाम से जोड़कर पहचाना जा सकता है।

अब यह जांचने के लिए कुछ कोड लिखें कि उपयोगकर्ता द्वारा दिया गया स्ट्रिंग वीवो उपयोगकर्ता खाता है या नहीं।

वैध वीवो उपयोगकर्ता खाता तार के लिए आवश्यकताएं:

केवल अपरकेस, लोअरकेस और अंक वर्ण होना चाहिए। (कोई व्हाट्सएप या विराम चिह्न)
80 वर्ण की लंबाई से अधिक नहीं होनी चाहिए।
स्ट्रिंग के अंत में "वीवो" प्रतिस्थापित होना चाहिए

परीक्षण के मामलों:

मान्य इनपुट:

AdeleVEVO
ConnieTalbotVEVO
SHMVEVO
justimberlakeVEVO
DJMartinJensenVEVO
test123VEVO

अमान्य इनपुट:

syam kapuk
jypentertainment
Noche de Brujas
testVEVO123

बेशक, क्योंकि यह कोड-गोल्फ है , मैं किसी भी प्रोग्रामिंग भाषा का उपयोग करते हुए सबसे छोटा कोड ढूंढ रहा हूं।

code-golf string decision-problem

— बगस संजय
स्रोत

4

अच्छा पहला सवाल! +1

— लीफडेवेन

12

परीक्षण के मामले: VEVOऔरūņīčōdēVEVO

— dzaima

8

अन्य सुझाए गए परीक्षण मामले: test123VeVoऔर 80 से अधिक वर्णों वाले

— अरनौलड

6

आपको सबसे अच्छा जवाब स्वीकार करने से पहले बहुत लंबा इंतजार करना चाहिए; सवाल केवल एक घंटे के लिए है और बहुत अधिक भाषाएँ हैं जिनका लोग जवाब दे सकते हैं!

— ल्यूक स्टीवंस

5

"अपरकेस, लोअरकेस, और डिजिट कैरेक्टर्स" को परिभाषित करने की आवश्यकता होती है (मुझे लगता है (जैसा कि, मेरा मानना है, सभी पहले से ही कर चुके हैं) का मतलब है कि आपका मतलब ए-ज़-ज़0-9 है, लेकिन इसका मतलब कुछ भी हो सकता है जो अपरकेस या लोअरकेस हो सकता है, के लिए; उदाहरण ạऔर Ạअन्य वर्णमाला में अंक, उदाहरण के लिए 九(9)।

— जोनाथन एलन

9

पायथन 2 , 45 बाइट्स

-3 बाइट्स रॉड के लिए धन्यवाद। -2 बाइट्स ओव्स के लिए धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

एक रेगेक्स समाधान लंबे समय तक निकलता है।

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

— totallyhuman
स्रोत

6

जाप v2.0a0, 20 16 बाइट्स

1वैध या 0अमान्य के लिए रिटर्न । एक ही बाइट गिनती [\l\d]के [^\W_]लिए भी काम करेगा ।

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

कोशिश करो | सभी परीक्षण मामलों की जाँच करें

स्पष्टीकरण : èइनपुट में RegEx के मैचों की संख्या को गिना जाता है। Japt में, \wRegEx वर्ग में अंडरस्कोर शामिल नहीं है।

— झबरा
स्रोत

अच्छा है। सर्वश्रेष्ठ मैं regex के बिना कर सकता है;¥oB+mc)¯80 ©"VEVO"¥Ut4n

— ETHproductions

@ETHproductions, अच्छी चाल के साथ B+mc:), अगर Japt2 के लिए चरित्र वर्ग होता [A-Za-z0-9], तो हम यहाँ रेटिना को हरा सकते थे! यहां तक कि अधिभावी लायक हो सकता है \wऔर \W।

— झबरा

हे, मुझे लगता है कि मैं वास्तव में मूल रूप से ऐसा करने की योजना बना रहा था ... मुझे सामान्य रूप से जाप पर काम करना चाहिए: P

— ETHproductions

4

जावास्क्रिप्ट (ईएस 6), 27 36 34 31 बाइट्स

2 बाइट्स @Neil की बदौलत और 3 बाइट @Shaggy की बदौलत बच गए

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

परीक्षण के मामलों

कोड स्निपेट दिखाएं

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)

Expand snippet

— Arnauld
स्रोत

2

क्या \wमेल नहीं खाता _?

— नील

मुझे लगता ((?!_)\w)है कि 2 बाइट्स बचाता है।

— नील

1

[^\W_]एक 3 बाइट की बचत के लिए काम करेंगे ?

— झबरा

@ शैगी हेक। किसी कारण से, मैं सोच रहा था कि ऐसे चरित्र वर्ग चरित्र सेट के भीतर काम नहीं कर रहे थे। धन्यवाद!

— अरनुलद

क्या जेएस के पास लंबोदर को छोड़ने का कोई तरीका नहीं है? पसंद है /^[^\W_]{0,76}VEVO$/.testया कुछ और?

— 18

4

PHP , 51 बाइट्स

-10 बाइट्स @Ismael मिगुएल के लिए धन्यवाद <?=इसके बजाय का उपयोग करने के लिए <?php echo! और समापन टैग को हटा रहा है

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

इसे ऑनलाइन आज़माएं!

अन्य उत्तरों के लिए धन्यवाद इसलिए मुझे रेगेक्स लिखना नहीं पड़ा!

— NK1406
स्रोत

1

इसके बजाय <?php echo, आप कर सकते हैं <?=preg_match("/^[^\W_]{0,76}VEVO$/",fgets(STDIN));।

— इस्माइल मिगुएल

आपका स्वागत है। आप समापन PHP टैग को छोड़ सकते हैं। प्रलेखन का हवाला देते हुए: "यदि कोई फ़ाइल शुद्ध PHP कोड है, तो फ़ाइल के अंत में PHP समापन टैग को छोड़ना बेहतर है।" ( php.net/manual/en/language.basic-syntax.phptags.php )। इससे आपको 2 और बाइट्स बचानी चाहिए। इसके अलावा, के बजाय [^\W_], बस का उपयोग करें \w, जो के रूप में ही है [a-zA-Z_]।

— इस्माइल मिगुएल

1

धन्यवाद के रूप में अच्छी तरह से, मैं अब अद्यतन करने के लिए कुछ जवाब है!

— NK1406

आपका स्वागत है। एक सलाह: प्रलेखन पढ़ने और इसके साथ परिचित होने से बहुत मदद मिलेगी।

— इस्माईल मिगुएल

3

एपीएल (डायलॉग) , 25 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— आउटगोल्फर को एरिक करें
स्रोत

3

सी (जीसीसी) , 83 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— scottinet
स्रोत

मैं कोई returnबयान नहीं देखता , यह कैसे वापसी करता है c? अपरिभाषित व्यवहार?

— एमडी एक्सएफ

@MDXF यह वास्तव में अपरिभाषित व्यवहार है और एक दुरुपयोग है कि कैसे gcc चर असाइनमेंट और रिटर्न वैल्यू के लिए समान रजिस्टरों का उपयोग करता है ( सी में गोल्फिंग के लिए टिप्स देखें )। यह पोर्टेबल नहीं है और आवश्यक रूप से अन्य संकलक के साथ काम नहीं करता है (उदाहरण के लिए यह

— क्लैंग के

यह बहुत प्रभावशाली है। आपको यह कैसे पता चला?

— एमडी एक्सएफ

कभी-कभी f ("VO" भी सही हो सकता है, जब पहले "VI" संग्रहीत किया जाता है, या शायद गलती हो सकती है

— l4m2

3

दिल्लोग एपीएल , 47 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक शुद्ध रेगेक्स समाधान 32 बाइट्स है , लेकिन इस दृष्टिकोण की तुलना में बहुत अधिक उबाऊ है।

{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

— dzaima
स्रोत

डीएफएन गार्ड की ⍣¯1जांच VEVOऔर आवश्यकता के लिए उपयोग करने के बजाय , आप कर सकते हैं 'VEVO'≡¯4↑⍵। चीजों को थोड़ा {('VEVO'≡¯4↑⍵)∧∧/⍵∊⎕D,⎕A,(819⌶)⎕A}

— बढ़ाते हुए

@Cowsquack हाँ, मैं शायद भूल गया हूँ ↑.. इस चुनौती को करने के लिए अन्य बेहतर तरीके हैं (हालांकि एरिक उत्तर) और मुझे यह विचार पसंद है: p

— dzaima

3

पीस , 13 बाइट्स

e`n{-76"VEVO"

इसे ऑनलाइन आज़माएं!

यहां कुछ भी नहीं फैंसी। eपैटर्न के खिलाफ ntire इनपुट का मिलान करें : nस्ट्रिंग द्वारा पीछा किए जाने वाले अधिकांश 76 अल्फा umeric वर्णों पर VEVO। 1मैच के लिए और 0बिना किसी मैच के प्रिंट । मुझे याद आया कि अंतिम उद्धरण लाइन के अंत में हटाया जा सकता है, लेकिन जाहिर है कि यह सिर्फ एक पार्स त्रुटि का कारण बनता है।

— Zgarb
स्रोत

3

C # (.NET कोर) , 87 + 18 = 105 बाइट्स

इसे ऑनलाइन आज़माएं!

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

— LiefdeWen
स्रोत

यदि इनपुट में गैर-अल्फ़ान्यूमेरिक वर्ण हैं, तो क्या यह विफल नहीं होगा?

— झबरा

@ शागिर्द आप सही हैं, थोड़ा बाद में ठीक करेंगे।

— LiefdeWen

मैंने टीआईओ के साथ जाँच की है और पाया है कि इनपुट "कोनीटेलबोटवॉवो" (जो वैध इनपुट होना चाहिए) को झूठा करार दिया गया था।

— बगास संजया

@BagasSanjaya यह इसलिए है क्योंकि मैं परीक्षण के मामले में इसके बाद टैब डाल देता हूं, टैब निकाल लेता हूं और यह ऊपर दिए गए परीक्षण के मामले के समान होगा और काम करेगा।

— लाईफ़डेवेन

73 + 18: a=>a.All(x=>char.IsLetterOrDigit(x)&x<123)&a.Length<81&a.EndsWith("VEVO")केवल ASCII पत्र या 67 + 18: a=>a.All(x=>char.IsLetterOrDigit(x))&a.Length<81&a.EndsWith("VEVO")यूनिकोड समर्थन के साथ

— dg3

2

> <> , 147 125 बाइट्स

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

इसे ऑनलाइन आज़माएं!

> <> , 147 बाइट्स

इसे ऑनलाइन आज़माएं!

यह 1 प्रिंट करता है यदि इनपुट स्ट्रिंग वैध है और अमान्य इनपुट के लिए कुछ भी नहीं है।

संपादित 1: हर वर्ण के खिलाफ तुलना करने के बजाय रेंज का उपयोग करने के लिए अल्फ़ान्यूमेरिक चेक को बदल दिया। (22 बाइट्स की बचत)

— पेल पेलिकन
स्रोत

मेरे पास अभी इस गोल्फ के लिए समय नहीं है, लेकिन मुझे पूरा यकीन है कि आप चरित्र कोड की तुलना करके बाइट्स खो सकते हैं। इसका सार यह होगा कि '0' से कम की चीज़ों को 'z' से बड़ा और फिर '9' और 'A' के साथ-साथ 'Z' और 'a' के बीच की चीज़ों को अस्वीकार कर दिया जाए।

— कोल

@cole: - मैं पोस्ट के बाद कल इसे बदलने के लिए अपने पीसी पर नहीं था, लेकिन आप सही हैं, तुलना थोड़ा कट जाती है। मुझे यकीन है कि यदि आप कोड को स्कैन करते हैं तो आप कुछ अतिरिक्त बाइट्स को छोड़ने में सक्षम हो सकते हैं।

— टीले पेलिकन

2

बैश, 53 26 30 बाइट्स

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

VALID परिणामों के लिए कोड 0 और INVALID परिणामों के लिए 1 से बाहर निकलें।

~~अभी भी 80 अक्षर या उससे कम पर काम कर रहा है।~~

आउटपुट को हटाने से -27 बाइट्स, @KeyWeeUsr के लिए धन्यवाद

+4 बाइट्स, निश्चित रेगेक्स (बाकी सभी के समान)

इसे ऑनलाइन आज़माएं!

— शायद
स्रोत

आप केवल echo 1सच के लिए, या बिना किसी प्रतिध्वनि के जा सकते हैं। जैसा कि आप अभी भी एक एक्ज़िट कोड के साथ समाप्त करते हैं, जिसे आप वास्तव में जाँचते हैं &&और||

— KeyWeeUsr

ठीक है, निश्चित नहीं था कि किस प्रकार का आउटपुट (यदि कोई हो) आवश्यक था। सवाल वास्तव में नहीं कहा।

— संभवतः

'Truthy' है के विचार यहां समझाया codegolf.meta.stackexchange.com/q/2190/16658 और आम तौर पर सार्वभौमिक अर्थ निकलता है जब तक अन्यथा के रूप में निर्दिष्ट

— सायरन

यह TIO पर कुछ भी आउटपुट नहीं करता है। इसके अलावा, आपका RegEx अंडरस्कोर की अनुमति देता है, जिसे यह नहीं करना चाहिए। और आप लंबाई की जाँच नहीं कर रहे हैं। हमें यहां पूरी तरह कार्यात्मक होने के लिए समाधान की आवश्यकता है, प्रगति में काम पोस्ट नहीं किया जाना चाहिए। जब तक आप समस्याओं को ठीक नहीं कर सकते, मैं इसे हटाने की सलाह दूंगा। (संबंधित नोट पर, लोग समाधान क्यों नहीं निकालते हैं जो स्पष्ट रूप से काम नहीं करते हैं?)

— झबरा

@ झाग उत्पादन निर्गम कोड के माध्यम से होता है।

— पूरी तरह से

2

> <> , 101 89 83 81 94 बाइट्स

संपादित करें: अल्फ़ान्यूमेरिक के बजाय गैर-अल्फ़ान्यूमेरिक वर्णों की जाँच करने के लिए स्विच किया गया। Z और a के बीच जांच करने के कारण मैं वापस स्विच किया गया। साभार @Emigna हालांकि उन खो बाइट्स चीर

संपादित करें 2: इसके अलावा, मैं पूरी तरह से उन}}}} से छुटकारा पा सकता हूं। इसके लिए धन्यवाद चैती पेलिकन और टीआईओ के साथ समस्या का पता लगाना

संपादित करें 3: एपी के साथ एक ~~~ प्रतिस्थापित

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

~~मुझे नहीं पता कि यह TIO पर काम क्यों नहीं करेगा, लेकिन यह यहाँ ठीक काम करता है ।~~ समस्या यह थी कि TIO में {} कमांड खाली सूची के लिए काम नहीं करते हैं। यह यहाँ की कोशिश करो

यह काम किस प्रकार करता है

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

स्थिरता के लिए, की जगह; एक अवैध निर्देश के साथ अंतिम पंक्ति में हर आउटपुट को एक त्रुटि बनाता है ।

— मजाक कर रहा है
स्रोत

मेरा मानना है कि आपका TIO त्रुटि हो सकता है कि यह अंतिम स्टैक विभाजन पर ऑर्डर देने के साथ कैसे काम करता है। TIO LINK यहाँ TIO में गड़बड़ होने पर आप इसे इसमें बदल सकते हैं।

— चैले पेलिकन

साभार @Tealpelican तय किया है कि और कुछ और बाइट्स मारे

— जो राजा

आप "Z" और "a" के बीच के अक्षरों की जांच को याद कर रहे हैं।

— एमिग्ना

@Eigna ओह, धन्यवाद! फिक्स्ड!

— जो राजा

2

सी ++, 129 105 102 बाइट्स

अन्य उत्तरों के लिए धन्यवाद जिसने मुझे दिखाया कि मैं
Zacharý के लिए अक्षर -2 बाइट्स की संख्या गिन सकता हूं

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

TIO लिंक

— HatsuPointerKun
स्रोत

आपके जवाब में TIO लिंक कहां है? मैं आपके कोड का परीक्षण करना चाहूंगा ...

— बगस संजया

मुझे माफ कर दो अगर यह C ++ के ज्ञान की कमी है। क्या आप वैरिएबल को हटा सकते हैं r, और कॉल करने के लिए सिर्फ रेगेक्स है std::regex_match?

— जकार्इ

अल्पविराम के बाद एक अनावश्यक स्थान है

— जकार्ही

आप अल्पविराम के बाद अल्पविराम को हटा सकते हैं।

— Zacharý

2

ढेर , 21 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Rɪᴋᴇʀ
स्रोत

1

05AB1E , 21 बाइट्स

žKÃQsg81‹IR4£"OVEV"QP

इसे ऑनलाइन आज़माएं!

— Emigna
स्रोत

1

जावा (ओपनजेडके 8) , 37 36 बाइट्स

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!

— Luke Stevens
स्रोत

1

Retina, 18 bytes

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

Try it online!

or

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

Try it online!

— ovs
स्रोत

1

Haskell, 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!

— totallyhuman
स्रोत

1

-2 bytes if you use drop(length s-4) and extract length s

— user28667

1

Deorst, 22 bytes

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

Try it online!

Just uses the regex found by Shaggy

— caird coinheringaahing
स्रोत

1

V, 17 bytes

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

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

— DJMcMayhem
स्रोत

1

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.

— G B
स्रोत

1

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!

— Zeke Snider
स्रोत

1

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

— Noskcaj
स्रोत

1

Clean, 61 bytes

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

Try it online!

— Οurous
स्रोत

1

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!

— Geoffrey H.
स्रोत

1

Welcome to PPCG! You can remove extraneous whitespace to get down to 25 (+1) bytes: print/^\w{1,76}VEVO$/?1:0

— ETHproductions

+0 converts match bool into number, rather than ?1:0, saves 2 bytes. Calling with -ple prints $_ for you. So: perl -ple '$_=/^[^\W_]{0,76}VEVO$/+0'. 25 bytes. If you are happy to get blanks on non-matching lines, $_=/^[^\W_]{0,76}VEVO$/ is 23 bytes.

— Phil H

0

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

— Taylor Scott
स्रोत

Where's the closing bracket?

— Bagas Sanjaya

@BagasSanjaya that's one of the wonderful things about Google Sheets, it autocompletes unclosed strings and groups. So when this is pasted into a cell and you either click off the cell or press enter GS converts this to =RegexMatch(A1,"^[^\W_]{0,76}VEVO") without any feedback to the user and executes

— Taylor Scott

-1

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

— Carcigenicate
स्रोत

Any TIO link for testing?

— Bagas Sanjaya

@BagasSanjaya I can add one in a bit. It seems like adding TIO links are standard now. They were optional last time I used the site frequently, but now everyone's adding them.

— Carcigenicate

@BagasSanjaya I added a link. Unfortunately TIO seems broken. It can't find the ends-with? function, even though that's part of the standard library.

— Carcigenicate

VEVO उपयोगकर्ता खाता परीक्षक

पायथन 2 , 45 बाइट्स

जाप v2.0a0, 20 16 बाइट्स

जावास्क्रिप्ट (ईएस 6), 27 36 34 31 बाइट्स

परीक्षण के मामलों

PHP , 51 बाइट्स

एपीएल (डायलॉग) , 25 बाइट्स

सी (जीसीसी) , 83 बाइट्स

दिल्लोग एपीएल , 47 बाइट्स

पीस , 13 बाइट्स

C # (.NET कोर) , 87 + 18 = 105 बाइट्स

> <> , 147 125 बाइट्स

> <> , 147 बाइट्स

बैश, 53 26 30 बाइट्स

> <> , 101 89 83 81 94 बाइट्स

यह काम किस प्रकार करता है

सी ++, 129 105 102 बाइट्स

ढेर , 21 बाइट्स

05AB1E , 21 बाइट्स

जावा (ओपनजेडके 8) , 37 36 बाइट्स

Retina, 18 bytes

Haskell, 75 bytes

Deorst, 22 bytes

V, 17 bytes

Ruby -n, 22+1 = 23 bytes

Swift 4, 113 bytes

AWK, 23 bytes

Clean, 61 bytes

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

Google Sheets, 33 Bytes

Clojure, 146 bytes