Giới thiệu

Như ToonAlfrink nói : "Tôi nghĩ rằng không có đủ câu hỏi dễ dàng ở đây mà người mới bắt đầu có thể thử!". Vì vậy, nhiệm vụ rất đơn giản. Đưa ra một chuỗi, xuất ra một giá trị trung thực hoặc giả cho dù tên đó là chính thức hay không.

Tên là "chính thức" nếu đó là một từ trường hợp tiêu đề duy nhất, đó là:

• Nếu chữ cái đầu tiên được viết hoa (không chính thức adnan:)
• Nếu các chữ cái khác không được viết hoa (không chính thức AdNaN:)
• Nếu tên không chứa bất kỳ ký tự không chữ nào (không chính thức : Adnan123, Adnan!)
• Nếu tên chỉ bao gồm một từ (không chính thức : Adn an, Adn An)
• Nếu tên có nhiều hơn một ký tự (không chính thức A:)

Quy tắc

• Bạn có thể cung cấp một chức năng hoặc một chương trình
• Đây là môn đánh gôn , vì vậy bài nộp có số byte ít nhất sẽ thắng!
• Lưu ý: Để đơn giản hóa mọi thứ, những cái tên như Mary-Ann nằm trong thử thách này không phải là chính thức.
• Giả sử rằng không có khoảng trắng hàng đầu trong tên.
• Giả sử rằng chỉ các ký tự ASCII có thể in ( 32-126) được sử dụng trong các tên

Các trường hợp thử nghiệm

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

Bảng xếp hạng

/* 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>

Bình thường, 16 13 12 byte

Cảm ơn @Thomas Kwa đã nhắc nhở tôi về Titlecase.

&qzr@GrzZ3tz

Phòng thử nghiệm .

&              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

Võng mạc, 13 byte

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

Dùng thử trực tuyến | Bộ kiểm tra (Đầu ra0 có nghĩa là không có chuỗi nào phù hợp, dự kiến.)

Khi Retina chỉ được cung cấp một dòng mã, nó sẽ xuất ra số lần biểu thức khớp với chuỗi đầu vào, do đó, nó sẽ xuất ra 1(trung thực) nếu nó khớp và do đó là tên chính thức và 0(giả) nếu không phải là tên chính thức .

Phá vỡ

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

TeaScript, 12 byte

xO`A-Z][a-z`

Lạm dụng Ochức năng.

Hãy thử trực tuyến

Phòng thử nghiệm

Giải trình

Các Ochức năng làm cho điều này:

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

Sau đó, hàm O kiểm tra xem regex có khớp không x.

Ngoài ra, một câu trả lời TeaScript 3 không cạnh tranh ở 7 byte :

xO/\A\a

JavaScript (ES6), 26

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

Bởi: 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>

Con trăn, 59 58 byte

Tôi chắc chắn không có cách nào thực sự để đánh bại phiên bản Retina, vì về cơ bản đây chỉ là trong Python. Nhưng tôi nghĩ rằng đây là lần gửi đầu tiên của tôi;)

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

Đó là một giá trị trung thực rất kỳ quặc :

(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

(Và nó yêu cầu ""xung quanh các chuỗi có khoảng trắng trong đó, nếu được truyền qua shell)

Java, 53 byte

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

Python, 50 45 43 41 byte

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

Trả về Truenếu đó là tên chính thức hoặc Falsenếu không.

BotEngine , 203 180 29x6 = 174

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

Tôi thực sự nên thêm nội dung để xác định chữ hoa và chữ thường. Điều đó sẽ ngắn gọn hơn nhiều so với việc kiểm tra từng chữ cái riêng lẻ.

Bản dịch thô:

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 byte

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

Dùng thử trực tuyến

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 byte

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

MATL , 18 byte

Phiên bản hiện tại ( 4.0.0 ) của ngôn ngữ được sử dụng.

Điều này áp dụng cùng một biểu thức chính quy như câu trả lời của NinjaBearMonkey :

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

Đầu ra là chuỗi ( là sự thật ) nếu đó là tên chính thức và không có gì (đó là giả ) nếu không phải là nó.

Ví dụ

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

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

Haskell, 61 byte

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

Gema, 17 ký tự

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

Chạy mẫu:

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 byte

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

-2 byte (nhờ thao tác)

Mã máy IA-32, 19 byte

Hàm nhận con trỏ tới chuỗi kết thúc null ecxvà trả về 0 hoặc 1 in eax(theofastcall quy ước).

Mã thập phân của mã:

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

Trong ngôn ngữ lắp ráp:

    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;

Byte đầu tiên của tên đầu vào có bit thứ 5 được lật ( xorvới 32) để chuyển đổi nó từ trường hợp viết hoa sang trường hợp nhỏ. Điều này tải 32 vào eax, sử dụng 3 byte mã:

    push 32;
    pop eax;

Để kiểm tra xem byte có phải là một chữ cái nhỏ hay không:

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

Nếu không, mã này rơi qua. Để trả về 0 trong trường hợp này, nó đặt 0 vào altrước khi thực hiện bước nhảy có điều kiện:

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

Số 0 trong alcũng đóng vai trò là mặt nạ xor (hoặc không có nó) cho các byte sau của tên đầu vào.

Một lối thoát thành công là khi nó gặp một byte số 0, giữ nguyên số 0 sau xor:

    xor al, [ecx];
    jz yes;

Nó giả định rằng tên đầu vào không trống. Tôi đoán đó là một giả định hợp lý về một cái tên (không phải là một chuỗi tùy ý)!

grep, 16 byte

Đây là mô hình:

[A-Z][a-z]+

Nếu bạn sử dụng -Evà -xvà -cchuyển đổigrep sẽ in một số dòng đầu vào phù hợp. Vì vậy, nếu bạn cung cấp cho nó một dòng, bạn nhận được 1 hoặc 0. Tôi nghĩ đó là cách nơi này hoạt động.

Mẫu có 11 ký tự, toàn bộ dòng lệnh là 23. Tôi đã thấy mọi người sử dụng sedcác tập lệnh mà không có lệnh nên tôi không biết đó là gì. Nhưng, nó đọc stdin, và vì vậy bạn chỉ cần gõ vào nó. Đây là echo:

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

1
0
0

Toán học 10.1, 46 byte

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

Uses one less byte than the standard regex solution. It does three checks. LetterQ@# ensures that the string is entirely composed of letters, and StringLength@#>1 invalidates single-letter strings. #==ToCamelCase@# makes less sense, however. ToCamelCase is an undocumented function I found that takes an input string AndOutputsItLikeThis. Since there is only one word, it will capitalize the first letter, so we check if the string is equal to that.

bash/zsh/ksh, 25 bytes

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

To actually use this, make a file with it as the only line and make the file executable; executable files not recognized as a known binary type are treated as shell scripts (for /bin/sh specifically).

$ 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

My first attempt at Code Golf. Here it comes:

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

See it in action at Dot Net Fiddle.

Java, 28 bytes

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

Uses regex to make sure the string consists of an uppercase character followed by at least one lowercase character.

-1 bytes thanks to Benjamin Urquhart

k4, 39 bytes

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

First char is upper, all others are lower, count greater than one.

E.g.:

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

Seriously, 16 bytes

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

Hex Dump:

a3342c6e983d296c313c29972d592626

Try It Online

Seriously does not have regex support yet, so the best we can do is:

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

Example usage:

# 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 (with real function names):

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 handles regular expressions through the MATCH command. Output is 0 for false and 1 if true.

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

Swift 2, 116 bytes

Regex is so verbose in Swift that doing this is much shorter

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}

This will return 0 or -1 (in the case of no input) for non-official names, and a number > 0 (which is equal to the length of the string - 1) if the name is official

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

Regular expressions would have been the right way to tackle this, but here's an attempt without it.

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

Longhand

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

Would love advice on how to make the lowercase check shorter, perhaps without the loop. I just started learning the language, and used this as practice, figured I'd share my result anyway.

Perl 5 -p, 18 bytes

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

Try it online!

PowerShell, 29 bytes

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

Try it online!

Does the same regex trick everyone else is using. Has to use case-sensitive match to properly do it at the cost of a byte.

Japt, 9 bytes

Returns 1 or 0.

è"^%A%a+$

Try it

Perl 6, 17 bytes

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

Returns a Match object if this is an official name and Nil otherwise.

Try it online!