Wprowadzenie

Jak mówi ToonAlfrink : „ Uważam, że nie ma tutaj wystarczająco łatwych pytań, które mogliby podjąć początkujący!”. Zadanie jest więc bardzo proste. Biorąc pod uwagę ciąg, wypisz wartość prawdy lub fałszu, niezależnie od tego, czy nazwa jest oficjalna, czy nie.

Nazwa jest „oficjalna”, jeśli jest to pojedyncze słowo w tytule, to znaczy:

• Jeżeli pierwsza litera jest (nie oficjalne: adnan)
• Jeśli inne litery są nie aktywowane (nie oficjalne: AdNaN)
• Jeśli nazwa nie zawiera żadnych znaków spoza alfabetu (nie oficjalne: Adnan123, Adnan!)
• Jeśli nazwa składa się z jednego słowa (nie oficjalne: Adn an, Adn An)
• Jeśli nazwa zawiera więcej niż jeden znak (nie oficjalne: A)

Zasady

• Możesz podać funkcję lub program
• To jest golf golfowy , więc wygrywanie z najmniejszą ilością bajtów wygrywa!
• Uwaga: Aby uprościć rzeczy, imiona takie jak Mary-Ann są w tym wyzwaniu nieoficjalne.
• Załóżmy, że w nazwie nie ma wiodących białych znaków.
• Załóżmy, że 32-126w nazwach używane są tylko drukowalne znaki ASCII ( )

Przypadki testowe

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

Tabela liderów

/* 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 bajtów

Dzięki @Thomas Kwa za przypomnienie mi o titlecase.

&qzr@GrzZ3tz

Pakiet testowy .

&              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

Siatkówka, 13 bajtów

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

Wypróbuj online | Zestaw testowy (Dane wyjściowe 0oznaczają brak pasujących ciągów, co jest oczekiwane).

Gdy Retina jest dostarczana tylko z jednym wierszem kodu, wyświetla liczbę razy, gdy wyrażenie pasowało do ciągu wejściowego, więc wyświetli 1(prawda), jeśli pasuje, a zatem jest oficjalną nazwą i 0(fałsz), jeśli nie jest.

Awaria

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

TeaScript, 12 bajtów

xO`A-Z][a-z`

Nadużywa Ofunkcji.

Wypróbuj to online

Pakiet testowy

Wyjaśnienie

OFunkcja sprawia, że w ten sposób:

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

Następnie funkcja O sprawdza, czy wyrażenie regularne pasuje x.

Alternatywnie, niekonkurencyjna odpowiedź na TeaScript 3 o 7 bajtach :

xO/\A\a

JavaScript (ES6), 26

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

Przez: 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 bajtów

Jestem pewien, że nie ma prawdziwego sposobu na pokonanie wersji Retina, ponieważ jest to w zasadzie tylko ta wersja Pythona. Ale myślę, że to moje pierwsze zgłoszenie;)

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

Jest to bardzo dziwna prawdziwa wartość:

(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

(I to wymaga ""wokół ciągów ze spacjami, jeśli przechodzi przez powłokę)

Java, 53 bajty

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

Python, 50 45 43 41 bajtów

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

Zwraca, Truejeśli jest to oficjalna nazwa lub Falsejeśli nie jest.

BotEngine , 203 180 29x6 = 174

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

Powinienem naprawdę dodać wbudowane identyfikatory wielkich i małych liter. Byłoby to o wiele bardziej zwięzłe niż sprawdzanie każdej litery osobno.

Tłumaczenie z grubsza:

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 bajtów

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

Wypróbuj 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 bajtów

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

MATL , 18 bajtów

Używana jest aktualna wersja ( 4.0.0 ) języka.

Dotyczy to tego samego wyrażenia regularnego, co odpowiedź NinjaBearMonkey :

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

Dane wyjściowe to ciąg znaków (co jest zgodne z prawdą ), jeśli jest to oficjalna nazwa, i nic (co jest fałszem ), jeśli nie jest.

Przykłady

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

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

Haskell, 61 bajtów

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

Gema, 17 znaków

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

Przykładowy przebieg:

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

Rubinowy, 28 bajtów

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

-2 bajty (dzięki manatwork)

Kod maszynowy IA-32, 19 bajtów

Funkcja, która odbiera wskaźnik do łańcucha zakończonego znakiem null ecxi zwraca 0 lub 1 w eax(zgodnie zfastcall konwencją).

Hexdump kodu:

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

W języku asemblera:

    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;

Pierwszy bajt nazwy wejściowej ma swój 5. bit odwrócony (za xorpomocą 32), aby przekonwertować go z dużej na małą. To ładuje 32 eax, używając 3 bajtów kodu:

    push 32;
    pop eax;

Aby sprawdzić, czy bajt jest małą literą:

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

Jeśli nie, ten kod przechodzi. Aby zwrócić 0 w tym przypadku, wstawia 0 alprzed wykonaniem skoku warunkowego:

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

Wartość 0 w alsłuży również jako maska ​​xor (lub jej brak) dla następujących bajtów nazwy wejściowej.

Pomyślne wyjście następuje, gdy napotka on bajt zerowy, który pozostaje zerowy po xor:

    xor al, [ecx];
    jz yes;

Zakłada się, że nazwa wejściowa nie jest pusta. Wydaje mi się, że jest to rozsądne założenie dotyczące nazwy (a nie dowolnego ciągu)!

grep, 16 bajtów

Oto wzór:

[A-Z][a-z]+

Jeśli używasz -Ei -xi -cprzełącznikigrep wypisze liczbę pasujących linii wejściowych. Więc jeśli podasz jedną linię, otrzymasz 1 lub 0. Myślę, że tak to działa.

Wzór ma 11 znaków, cała linia poleceń to 23. Widziałem, jak ludzie używają sedskryptów bez polecenia, więc nie wiem, co jest. Ale odczytuje stdin, więc możesz po prostu pisać. Oto 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 bajtów

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

Wykorzystuje jeden bajt mniej niż standardowe rozwiązanie wyrażenia regularnego. Wykonuje trzy kontrole. LetterQ@#zapewnia, że ​​ciąg jest w całości złożony z liter i StringLength@#>1unieważnia ciągi jednoliterowe. #==ToCamelCase@#ma jednak mniej sensu. ToCamelCaseto nieudokumentowana funkcja, którą znalazłem, która pobiera ciąg wejściowy AndOutputsItLikeThis. Ponieważ jest tylko jedno słowo, pierwsza litera będzie pisana wielką literą, więc sprawdzamy, czy ciąg znaków jest taki sam.

bash / zsh / ksh, 25 bajtów

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

Aby faktycznie tego użyć, utwórz plik z jedyną linią i spraw, aby plik był wykonywalny; pliki wykonywalne nierozpoznane jako znany typ binarny są traktowane jak skrypty powłoki (w /bin/shszczególności).

$ 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 bajtów

Moja pierwsza próba w Code Golf. Oto nadchodzi:

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

Zobacz to w akcji na Dot Net Fiddle .

Java, 28 bajtów

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

Używa wyrażenia regularnego, aby upewnić się, że łańcuch składa się z wielkich liter, po których następuje co najmniej jeden mały znak.

-1 bajty dzięki Benjaminowi Urquhartowi

k4, 39 bajtów

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

Pierwszy znak jest wyższy, wszystkie pozostałe są niższe, liczą się więcej niż jeden.

Na przykład:

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

Poważnie, 16 bajtów

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

Hex Dump:

a3342c6e983d296c313c29972d592626

Wypróbuj online

Poważnie nie ma jeszcze obsługi wyrażeń regularnych, więc najlepsze, co możemy zrobić, to:

 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 bajtów

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

Przykładowe użycie:

# 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

Niegolfowane (z prawdziwymi nazwami funkcji):

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 bajtów

SpecBAS obsługuje wyrażenia regularne za pomocą MATCHpolecenia. Wyjście wynosi 0 dla fałszu i 1, jeśli prawda.

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

Swift 2, 116 bajtów

Regex jest tak gadatliwy w Swift, że robienie tego jest znacznie krótsze

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}

Zwróci to 0lub -1(w przypadku braku danych wejściowych) dla nieoficjalnych nazwisk i numeru> 0 (która jest równa długości łańcucha - 1), jeśli nazwa jest oficjalna

Nie golfił

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 bajtów

Wyrażenia regularne byłyby właściwym sposobem na rozwiązanie tego problemu, ale oto próba bez niego.

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

Pismo ręczne

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

Z przyjemnością poradzę, jak skrócić małe litery, być może bez pętli. Właśnie zacząłem uczyć się języka i wykorzystałem to jako praktykę, pomyślałem, że i tak podzielę się swoim wynikiem.

Perl 5 -p , 18 bajtów

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

Wypróbuj online!

PowerShell , 29 bajtów

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

Wypróbuj online!

Czy ta sama sztuczka regularna, której wszyscy inni używają. Musi używać funkcji cwrażliwych matchna ase, aby poprawnie to zrobić kosztem bajtu.

Japt , 9 bajtów

Zwraca 1lub 0.

è"^%A%a+$

Spróbuj

Perl 6 , 17 bajtów

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

Zwraca Matchobiekt, jeśli jest to oficjalna nazwa i Nilinaczej.

Wypróbuj online!