Wir sehen oft Musikvideos auf Youtube. Viele Youtube-Kanäle, die Musikvideos hosten, sind "powered by VEVO". Diese können leicht identifiziert werden, indem Sie VEVO in ihre Video-Thumbnails einbetten und VEVO an ihren Kanalnamen anhängen.

Schreiben Sie nun einen Code, um zu testen, ob eine vom Benutzer angegebene Zeichenfolge ein VEVO-Benutzerkonto ist oder nicht.

Voraussetzungen für gültige VEVO-Benutzerkonto-Zeichenfolgen:

• Darf nur Großbuchstaben, Kleinbuchstaben und Ziffern enthalten. (kein Leerzeichen oder Interpunktion)

• Darf nicht länger als 80 Zeichen sein.

• Am Ende der Zeichenfolge muss der Teilstring "VEVO" stehen

Testfälle:

Gültige Eingaben:

AdeleVEVO
ConnieTalbotVEVO
SHMVEVO
justimberlakeVEVO
DJMartinJensenVEVO
test123VEVO

Ungültige Eingaben:

syam kapuk
jypentertainment
Noche de Brujas
testVEVO123

Da es sich um Code-Golf handelt , suche ich natürlich mit jeder Programmiersprache nach dem kürzesten Code.

Python 2 , 45 Bytes

-3 Bytes dank Rod. -2 Bytes dank ovs.

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

Probieren Sie es online!

Eine Regex-Lösung ist länger.

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

Japt v2.0a0, 20 16 Bytes

Rückgabe 1für gültig oder 0ungültig. [\l\d]würde auch anstelle von [^\W_]für die gleiche Byteanzahl arbeiten.

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

Versuchen Sie es | Überprüfen Sie alle Testfälle

Erläuterung : èZählt die Anzahl der Übereinstimmungen des RegEx in der Eingabe. In Japt enthält die \wRegEx-Klasse keinen Unterstrich.

JavaScript (ES6), 27 36 34 31 Byte

2 Bytes dank @Neil und 3 Bytes dank @Shaggy gespeichert

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

Testfälle

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 Dank an @Ismael Miguel für die Verwendung <?=anstelle von <?php echo! und Entfernen des schließenden Tags

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

Probieren Sie es online!

Vielen Dank für die anderen Antworten, damit ich den Regex nicht schreiben musste!

APL (Dyalog) , 25 Bytes

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

Probieren Sie es online!

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

Probieren Sie es online!

Dyalog APL , 47 Bytes

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

Probieren Sie es online!

Eine reine Regex-Lösung hat 32 Bytes , ist aber auch viel langweiliger als dieser Ansatz.

{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

Schmutz , 13 Bytes

e`n{-76"VEVO"

Probieren Sie es online!

Hier ist nichts Besonderes. Entspricht den entire Eingang mit dem Muster: höchstens 76 alpha numeric Zeichen, gefolgt von der Zeichenfolge VEVO. Druckt 1für Übereinstimmung und 0für keine Übereinstimmung. Ich erinnerte mich, dass das letzte Zitat am Ende der Zeile entfernt werden konnte, aber anscheinend nur einen Analysefehler verursacht.

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

Probieren Sie es online!

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

> <> , 147 125 Bytes

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

Probieren Sie es online!

> <> 147 Bytes

Probieren Sie es online!

Dies gibt 1 aus, wenn die Eingabezeichenfolge gültig ist und nichts für eine ungültige Eingabe.

Bearbeiten 1: Die alphanumerischen Prüfungen wurden geändert, um Bereiche zu verwenden, anstatt sie mit jedem Zeichen zu vergleichen. (22 Bytes sparen)

Bash, 53 26 30 Bytes

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

Beenden Sie den Code 0 für GÜLTIGE Ergebnisse und 1 für UNGÜLTIGE Ergebnisse.

Arbeitet immer noch an 80 Zeichen oder weniger.

-27 Bytes beim Entfernen der Ausgabe dank @KeyWeeUsr

+4 Bytes, fester regulärer Ausdruck (wie alle anderen auch)

Probieren Sie es online!

> <> , 101 89 83 81 94 Bytes

Bearbeiten: Suche nach nicht-alphanumerischen Zeichen anstatt nach alphanumerischen Zeichen umgestellt. Zurückgeschaltet, weil ich vergessen habe, zwischen Z und a zu prüfen. Vielen Dank @Emigna. Rippen Sie diese verlorenen Bytes

Edit 2: Außerdem kann ich die total einfach loswerden. Vielen Dank, Teal Pelican dafür und finde das Problem mit TIO

Edit 3: ~~~ durch ap ersetzt

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

Ich weiß nicht, warum dies bei TIO nicht funktioniert, aber hier funktioniert es einwandfrei . Das Problem war, dass die {} Befehle in TIO für eine leere Liste nicht funktionieren. Probieren Sie es hier

Wie es funktioniert

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

Aus Gründen der Konsistenz ersetzen Sie die; In der letzten Zeile mit einem ungültigen Befehl wird jede Ausgabe zu einem Fehler.

C ++, 129 105 102 Bytes

Dank anderer Antworten, die mir gezeigt haben, dass ich
dank Zacharý die Anzahl der Zeichen -2 Bytes zählen kann

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

TIO LINK

Gestapelt , 21 Bytes

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

Probieren Sie es online!

05AB1E , 21 Bytes

žKÃQsg81‹IR4£"OVEV"QP

Probieren Sie es online!

Java (OpenJDK 8) , 37 36 Bytes

Ziemlich einfache Antwort mit ein paar schönen Regex.
Wahrscheinlich die kürzeste Java-Antwort, die ich je gemacht habe.
-1 Bytes dank Neil in der Javascript-Antwort

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

Probieren Sie es online!

Retina , 18 Bytes

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

Probieren Sie es online!

oder

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

Probieren Sie es online!

Haskell , 75 Bytes

-2 Bytes dank user28667.

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

Probieren Sie es online!

Deorst , 22 Bytes

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

Probieren Sie es online!

Benutzt einfach den von Shaggy gefundenen Regex

V , 17 Bytes

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

Probieren Sie es online!

Hexdump:

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

Komprimierte Regeln für den Sieg!

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

Ausgabe 0wenn wahr,nil wenn falsch

Probieren Sie es online!

Mit dem gleichen langweiligen Regex wie alle anderen.

Swift 4 , 113 Bytes

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

Probieren Sie es online!

AWK , 23 Bytes

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

Probieren Sie es online!

Gibt den Kontonamen aus, wenn er gültig ist, und gibt nichts aus, wenn er ungültig ist

Sauber , 61 Bytes

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

Probieren Sie es online!

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

-6 Bytes dank ETHproductions

4 Bytes hinzugefügt. Ich habe nicht gesehen, dass ein Unterstrich nicht erlaubt ist.

Dies ist mein erstes Golf, also hoffe ich, dass ich es richtig gemacht habe.

Gibt 1 zurück, wenn dies gültig ist, und 0, wenn dies nicht der Fall ist.

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

Probieren Sie es online!

Google Sheets, 33 Bytes

Anonyme Arbeitsblattfunktion, die Eingaben aus dem Bereich A1und Ausgaben in die aufrufende Zelle übernimmt

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

Probieren Sie es online!

Mit einer Regex wäre das viel kürzer, aber ich dachte, es wäre interessanter, es manuell zu machen.

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