Einführung

Wie ToonAlfrink sagt : "Ich denke, dass es hier nicht genug einfache Fragen gibt, die Anfänger versuchen können!". Die Aufgabe ist also sehr einfach. Geben Sie bei einer gegebenen Zeichenfolge einen wahrheitsgemäßen oder falschen Wert aus, unabhängig davon, ob der Name offiziell ist oder nicht.

Ein Name ist "offiziell", wenn es sich um ein einzelnes Wort in Groß- und Kleinschreibung handelt, dh:

• Wenn der erste Buchstabe groß geschrieben (nicht offiziell: adnan)
• Wenn die anderen Buchstaben sind nicht aktiviert (nicht offiziell: AdNaN)
• Wenn der Name nicht enthält keine nicht-alphabetischen Zeichen (nicht offiziell: Adnan123, Adnan!)
• Wenn der Name nur ein Wort besteht (nicht offiziell: Adn an, Adn An)
• Wenn der Name hat mehr als ein Zeichen (nicht offiziell: A)

Regeln

• Sie können eine Funktion oder ein Programm bereitstellen
• Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!
• Hinweis: Um die Sache zu vereinfachen, sind Namen wie Mary-Ann bei dieser Herausforderung nicht offiziell.
• Angenommen, der Name enthält keine führenden Leerzeichen.
• Angenommen, 32-126in den Namen werden nur die druckbaren ASCII-Zeichen ( ) verwendet

Testfälle

Input: Adnan
Output: True

Input: adnan
Output: False

Input: AdnaN
Output: False

Input: Adnan123
Output: False

Input: Adnan Adnan
Output: False

Input: A
Output: False

Input: Mary-Ann
Output: False

Bestenliste

/* Configuration */

var QUESTION_ID = 67554; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 34388; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "http://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "http://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    else console.log(body);
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery('<a>'+lang+'</a>').text();
    
    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="language-list">
  <h2>Shortest Solution by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Pyth, 16 13 12 Bytes

Vielen Dank an @Thomas Kwa, der mich an den Titel erinnert hat.

&qzr@GrzZ3tz

Test Suite .

&              Boolean and operator
 qz            Equality test on input
  r    3       Titlecase operator
   @G          Setwise intersection with the alphabet
    rzZ        Input to lowercase
 tz            All but the first character of the input

Retina, 13 Bytes

^[A-Z][a-z]+$

Versuchen Sie es online | Testsuite (Die Ausgabe 0bedeutet, dass keine der Zeichenfolgen übereinstimmt, was erwartet wird.)

Wenn Retina nur mit einer einzigen Codezeile versehen ist, gibt es die 1Häufigkeit aus, mit der der Ausdruck mit der Eingabezeichenfolge übereinstimmt, sodass er (wahr) ausgegeben wird, wenn er übereinstimmt und daher ein offizieller Name ist, und 0(falsch), wenn er nicht übereinstimmt.

Nervenzusammenbruch

^       The beginning of the string
[A-Z]   One uppercase letter
[a-z]+  One or more lowercase letters
$       The end of the string

TeaScript, 12 Bytes

xO`A-Z][a-z`

Missbraucht die OFunktion.

Versuchen Sie dies online

Test Suite

Erläuterung

Die OFunktion macht dies:

x O   `A-Z][a-z`
x.O(/^[A-Z][a-z]+$/)

Dann prüft die O-Funktion, ob der reguläre Ausdruck übereinstimmt x.

Alternativ kann eine nicht konkurrierende TeaScript 3-Antwort mit 7 Bytes erfolgen :

xO/\A\a

JavaScript (ES6), 26

n=>/^[A-Z][a-z]+$/.test(n)

Von: Edcsixtyfive

f=n=>/^[A-Z][a-z]+$/.test(n)

console.log=x=>O.textContent+=x+'\n'

;['Adnan','adnan','AdnaN','Adnan123','Adnan Adnan','A','Mary-Ann']
.forEach(t=>console.log(t+' '+f(t)))

<pre id=O></pre>

Python, 59-58 Bytes

Ich bin mir sicher, dass es keinen wirklichen Weg gibt, die Retina-Version zu schlagen, da dies im Grunde genommen genau das in Python ist. Aber ich denke das ist meine erste Vorlage;)

import re,sys;print(re.match('[A-Z][a-z]+$',sys.argv[1]))

Es ist ein sehr seltsamer Wahrheitswert:

(test2)wayne@arglefraster ~/programming/inactive/golf/67554
⚘ python golf.py AdNan                                                                                                 $? 148  %# 3  10:06:36
None
(test2)wayne@arglefraster ~/programming/inactive/golf/67554
⚘ python golf.py Adnan                                                                                                         %# 3  10:06:40
<_sre.SRE_Match object at 0x7feefea7f440>
(test2)wayne@arglefraster ~/programming/inactive/golf/67554
⚘ python golf.py "Adnan Banana"                                                                                                %# 3  10:06:47
None

(Und es erfordert ""um Zeichenfolgen mit Leerzeichen, wenn über die Shell übergeben)

Java, 53 Bytes

boolean b(String a){return a.matches("[A-Z][a-z]+");}

Python, 50 45 43 41 Bytes

lambda s:s.isalpha()*s.istitle()*len(s)>1

Gibt zurück, Trueob es ein offizieller Name ist oder Falsenicht.

BotEngine , 203 180 29 x 6 = 174

v ABCDEFGHIJKLMNOPQRSTUVWXYZ
>ISSSSSSSSSSSSSSSSSSSSSSSSSSF
v <<<<<<<<<<<<<<<<<<<<<<<<<<
 Tabcdefghijklmnopqrstuvwxyz
> SSSSSSSSSSSSSSSSSSSSSSSSSSF
^E<<<<<<<<<<<<<<<<<<<<<<<<<<

Ich sollte wirklich Builtins hinzufügen, um Groß- und Kleinbuchstaben zu identifizieren. Das wäre viel prägnanter, als jeden Brief einzeln zu prüfen.

Grobe Übersetzung:

for a of input enqueue a
if ABCDEFGHIJKLMNOPQRSTUVWXYZ contains first
 remove first
 while abcdefghijklmnopqrstuvwxyz contains first
  remove first
 if empty
  yield TRUE exit
 else
  yield FALSE exit
else
 yield FALSE exit

C, 129 122 121 111 Bytes

main(c,b,d){b=d=0;while((c=getchar())>13)b|=b|=!b&&c>90|c<65?1:2&&d++&&c<97|c>122?4:2;printf("%d\n",b<3&&d>1);}

Probieren Sie es online

main(c,b,d)
{
    b=d=0;
    while((c=getchar())>13)
    {
        // Twiddle bits, 1<<0 for first character and 1<<3 for subsequent
        b|=!b&&c>90|c<65?1:2; // check first character is valid
        b|=d++&&c<97|c>122?4:2; // check later characters are valid
    }
    // If all OK b == 2, if either of above are wrong, b >= 3 due to 
    // extra bits. Also, d should be > 1 for name length to be valid.
    printf("%d\n",b<3&&d>1);
}

VB6, 48 Bytes

Function f(i):f=i Like"[A-Z][a-z]+":End Function

MATL , 18 Bytes

Die aktuelle Version ( 4.0.0 ) der Sprache wird verwendet.

Dies gilt für den gleichen regulären Ausdruck wie für die Antwort von NinjaBearMonkey :

j'^[A-Z][a-z]+$'XX

Die Ausgabe ist die Zeichenfolge (die wahr ist ), wenn es ein offizieller Name ist, und nichts (was falsch ist ), wenn es nicht ist.

Beispiele

>> matl
 > j'^[A-Z][a-z]+$'XX
 > 
> December
December
>> 

>> matl
 > j'^[A-Z][a-z]+$'XX
 > 
> ASCII
>> 

Haskell, 61 Bytes

f(h:t@(_:_))=elem h['A'..'Z']&&all(`elem`['a'..'z'])t
f _=1<0

Gema, 17 Zeichen

\B<K1><J>\E=1
*=0

Probelauf:

bash-4.3$ echo -n 'Adnan' | gema '\B<K1><J>\E=1;*=0'
1

bash-4.3$ echo -n 'adnan' | gema '\B<K1><J>\E=1;*=0'
0

bash-4.3$ echo -n 'Adnan123' | gema '\B<K1><J>\E=1;*=0'
0

Ruby, 28 Bytes

p (gets=~/^[A-Z][a-z]+$/)!=p

-2 Bytes (dank Handarbeit)

IA-32 Maschinencode, 19 Bytes

Eine Funktion, die den Zeiger auf eine nullterminierende Zeichenfolge in empfängt ecxund 0 oder 1 in eax(gemäß der fastcallKonvention) zurückgibt .

Hexdump des Codes:

6a 20 58 32 01 74 0a 41 2c 61 3c 1a b0 00 72 f3 c3 40 c3

In Assemblersprache:

    push 32;
    pop eax;

myloop:
    xor al, [ecx];
    jz yes;
    inc ecx;
    sub al, 'a';
    cmp al, 26;
    mov al, 0;
    jb myloop;
    ret;

yes:
    inc eax;
    ret;

Das fünfte Bit des ersten Bytes des Eingabenamens wird umgedreht ( xormit 32), um es von Groß- und Kleinschreibung in Kleinschreibung umzuwandeln. Dies lädt 32 eaxmit 3 Byte Code:

    push 32;
    pop eax;

So überprüfen Sie, ob das Byte ein kleiner Buchstabe ist:

    sub al, 'a';
    cmp al, 26;
    jb myloop;

Wenn nicht, fällt dieser Code durch. Um in diesem Fall 0 zurückzugeben, wird 0 eingegeben, albevor der bedingte Sprung ausgeführt wird:

    sub al, 'a';
    cmp al, 26;
    mov al, 0;
    jb myloop;

Die 0 in aldient auch als XOR-Maske (oder Abwesenheit davon) für die folgenden Bytes des Eingabenamens.

Ein erfolgreicher Exit ist, wenn er auf ein Null-Byte stößt, das nach dem xorfolgenden Wert Null bleibt :

    xor al, [ecx];
    jz yes;

Es wird davon ausgegangen, dass der Eingabename nicht leer ist. Ich denke, es ist eine vernünftige Annahme über einen Namen (keine willkürliche Zeichenfolge)!

grep16 Bytes

Das ist das Muster:

[A-Z][a-z]+

Wenn Sie die Schalter -Eund -xund verwenden, werden die übereinstimmenden Eingabezeilen gezählt. Wenn Sie also eine Zeile eingeben, erhalten Sie eine 1 oder eine 0. Ich denke, so funktioniert dieser Ort.-cgrep

Das Muster ist 11 Zeichen, die gesamte Befehlszeile ist 23. Ich habe gesehen, dass Leute sedSkripte ohne den Befehl verwenden, also weiß ich nicht, was was ist. Aber es liest stdin, und so können Sie es einfach eingeben. Hier ist echo:

for a in Adnan adnan Ad\ nan
do  echo "$a" | grep -cxE \[A-Z]\[a-z]+
done

1
0
0

Mathematica 10.1, 46 Bytes

LetterQ@#&&#==ToCamelCase@#&&StringLength@#>1&

Verwendet ein Byte weniger als die Standard-Regex-Lösung. Es werden drei Prüfungen durchgeführt. LetterQ@#Stellt sicher, dass die Zeichenfolge vollständig aus Buchstaben besteht, und macht Zeichenfolgen mit nur einem Buchstaben StringLength@#>1ungültig. #==ToCamelCase@#macht aber weniger sinn. ToCamelCaseist eine undokumentierte Funktion, die ich gefunden habe und die eine Eingabezeichenfolge AndOutputsItLikeThis annimmt. Da es nur ein Wort gibt, wird der erste Buchstabe in Großbuchstaben geschrieben. Wir prüfen daher, ob die Zeichenfolge mit dieser übereinstimmt.

Bash / Zsh / Ksh, 25 Bytes

[[ $1 =~ ^[A-Z][a-z]+$ ]]

Um dies tatsächlich zu verwenden, erstellen Sie eine Datei mit dieser als einziger Zeile und machen Sie die Datei ausführbar. ausführbare Dateien, die nicht als bekannter Binärtyp erkannt wurden, werden ( /bin/shinsbesondere) als Shell-Skripte behandelt .

$ printf '[[ $1 =~ ^[A-Z][a-z]+$ ]]' >f
$ chmod +x f
$ wc -c f
25 f
$ for x in 'Adnan' 'adnan' 'AdnaN' 'Adnan123' 'Adnan Adnan' 'A' 'Mary-Ann'; do f "$x" && echo 1 || echo 0; done
1
0
0
0
0
0
0
$ 

C # 4, 89 Bytes

Mein erster Versuch bei Code Golf. Hier kommt es:

bool o(string i){return System.Text.RegularExpressions.Regex.IsMatch(i,"^[A-Z][a-z]+$");}

Sehen Sie es in Aktion bei Dot Net Fiddle .

Java, 28 Bytes

n->n.matches("[A-Z][a-z]+")

Verwendet Regex, um sicherzustellen, dass die Zeichenfolge aus einem Großbuchstaben und mindestens einem Kleinbuchstaben besteht.

-1 Bytes dank Benjamin Urquhart

k4, 39 Bytes

{((*x)in .Q.A)&(&/(1_,/x)in .Q.a)&1<#x}

Das erste Zeichen ist höher, alle anderen sind niedriger und zählen mehr als eins.

Z.B:

  {((*x)in .Q.A)&(&/(1_,/x)in .Q.a)&1<#x}'("Adnan";"adnan";"AdnaN";"Adnan123";"Adnan Adnan";"A";"Mary-Ann")
1000000b

Im Ernst, 16 Bytes

ú4,nÿ=)l1<)ù-Y&&

Hex Dump:

a3342c6e983d296c313c29972d592626

Probieren Sie es online

Im Ernst, es gibt noch keine Unterstützung für Regex. Das Beste, was wir tun können, ist:

 4,n                               Push 4 copies of input
    ÿ=                             Check that it's equal to itself converted to titlecase
      )                            Put the boolean on the bottom
       l1<                         Check that it's longer than 1 character
          )                        Put the boolean on the bottom
           ù                       Convert it to lowercase.
ú           -Y                     Check that removing the lowercase alphabet empties it
              &&                   And all the booleans together

Ocaml, 231 216 197 166 Bytes

let f n=let l=String.length n in if l=1 then 0 else let rec e=function 0->1|i->match n.[i] with('a'..'z')->e(i - 1)|_->0 in match n.[0]with('A'..'Z')->e(l - 1)|_->0;;

Anwendungsbeispiel:

# f "Adnan";;
- : int = 1

# f "adnan";;
- : int = 0

# f "AdnaN";;
- : int = 0

# f "Adnan123";;
- : int = 0

# f "Adnan Adnan";;
- : int = 0

# f "A";;
- : int = 0

# f "Mary-Ann";;
- : int = 0

Ungolfed (mit echten Funktionsnamen):

let is_name name =
  let len = String.length name
  in if len = 1 then 0 else
  let rec explode_lower = function
    | 0 -> 1
    | i ->
      match name.[i] with
      | ('a'..'z') -> explode_lower (i - 1)
      | _ -> 0
  in match name.[0] with
  | ('A'..'Z') -> explode_lower (len - 1)
  | _ -> 0;;

SpecBAS - 39 Bytes

SpecBAS behandelt reguläre Ausdrücke über den MATCHBefehl. Die Ausgabe ist 0 für false und 1 für true.

1 input n$:  ?MATCH("^[A-Z][a-z]+$",n$)

Swift 2, 116 Bytes

Regex ist in Swift so ausführlich, dass dies viel kürzer ist

func e(s:String)->Int{var c=0;for k in s.utf8{if(c==0 ?k<65||k>90:k<97||k>122){return 0};c++};return s.utf8.count-1}

Dies gibt 0oder -1(falls keine Eingabe erfolgt) für nicht offizielle Namen und eine Nummer zurück> 0 (die der Länge der Zeichenfolge entspricht - 1) zurück, wenn der Name offiziell ist

Ungolfed

func e(s: String) -> Int{
    var c = 0
    for k in s.utf8{
        if(c == 0 ? k < 65 || k > 90 : k < 97 || k > 122){
            return 0
        }
        c++
    }
    return s.utf8.count - 1
}

C #, 188 Bytes

Reguläre Ausdrücke wären der richtige Weg gewesen, dies in Angriff zu nehmen, aber hier ist ein Versuch ohne sie.

bool O(string s){for(int i=1;i<s.Length;i++){if(char.IsUpper(s[i])){return false;}}if(char.IsUpper(s[0])&&s.All(Char.IsLetter)&&!s.Contains(" ")&& s.Length > 1){return true;}return false;}

Langschrift

static bool O(string s)
{
    for (int i = 1; i < s.Length; i++)
    {
        if (char.IsUpper(s[i]) )
        {
            return false;
        }
    }
    if (char.IsUpper(s[0]) && s.All(Char.IsLetter) && !s.Contains(" ") && s.Length > 1)
    {
        return true;
    }
    return false;
}

Würde gerne Ratschläge dazu erhalten, wie der Kleinbuchstaben-Check kürzer gemacht werden kann, vielleicht ohne die Schleife. Ich habe gerade angefangen, die Sprache zu lernen, und habe dies als Übung verwendet. Ich dachte, ich würde trotzdem mein Ergebnis teilen.

Perl 5 -p , 18 Bytes

$_=/^[A-Z][a-z]+$/

Probieren Sie es online!

PowerShell , 29 Byte

"$args"-cmatch'^[A-Z][a-z]+$'

Probieren Sie es online!

Hat derselbe Regex-Trick, den alle anderen verwenden. Muss case-sensitive verwenden match, um es auf Kosten eines Bytes richtig zu machen.

Japt , 9 Bytes

Rückgabe 1oder 0.

è"^%A%a+$

Versuch es

Perl 6 , 17 Bytes

{/^<:Lu><:Ll>+$/}

Gibt ein MatchObjekt zurück, wenn dies ein offizieller Name ist Nil.

Probieren Sie es online!