introduction

Comme le dit ToonAlfrink : "Je pense qu'il n'y a pas assez de questions faciles ici que les débutants peuvent essayer!". La tâche est donc très simple. Étant donné une chaîne, affichez une valeur véridique ou fausse, que le nom soit officiel ou non.

Un nom est "officiel" s'il s'agit d'un seul mot majuscule, c'est-à-dire:

• Si la première lettre est en majuscule (non officielle: adnan)
• Si les autres lettres sont pas capitalisées (non officielle: AdNaN)
• Si le nom ne contient pas de caractères non alphabétiques (non officielle: Adnan123, Adnan!)
• Si le nom se compose d'un seul mot (non officiel: Adn an, Adn An)
• Si le nom a plus d'un caractère (non officiel: A)

Règles

• Vous pouvez fournir une fonction ou un programme
• C'est du code-golf , donc la soumission avec le moins d'octets gagne!
• Remarque: Pour simplifier les choses, des noms comme Mary-Ann ne sont pas officiels dans ce défi .
• Supposons qu'il n'y ait pas d'espaces blancs principaux dans le nom.
• Supposons que seuls les caractères ASCII imprimables ( 32-126) sont utilisés dans les noms

Cas de test

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

Classement

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

Merci à @Thomas Kwa de m'avoir rappelé Titlecase.

&qzr@GrzZ3tz

Suite de tests .

&              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

Rétine, 13 octets

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

Essayez-le en ligne | Suite de tests (La sortie 0signifie qu'aucune des chaînes ne correspond, ce qui est attendu.)

Lorsque Retina n'est fourni qu'avec une seule ligne de code, il renvoie le nombre de fois où l'expression correspond à la chaîne d'entrée, donc il sortira 1(véridique) s'il correspond et est donc un nom officiel et 0(faux) si ce n'est pas le cas.

Panne

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

TeaScript, 12 octets

xO`A-Z][a-z`

Abuse la Ofonction.

Essayez ceci en ligne

Suite de tests

Explication

La Ofonction fait ceci:

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

Ensuite, la fonction O vérifie si l'expression régulière correspond x.

Alternativement, une réponse TeaScript 3 non concurrente à 7 octets :

xO/\A\a

JavaScript (ES6), 26

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

Par: 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 octets

Je suis sûr qu'il n'y a pas de véritable moyen de battre la version Retina, car il s'agit essentiellement de cela dans Python. Mais je pense que c'est ma première soumission;)

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

C'est une valeur véridique très étrange :

(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

(Et cela nécessite ""autour de chaînes avec des espaces, s'il est passé via le shell)

Java, 53 octets

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

Python, 50 45 43 41 octets

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

Renvoie Trues'il s'agit d'un nom officiel ou Falses'il ne l'est pas.

BotEngine , 203 180 29x6 = 174

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

Je devrais vraiment ajouter des fonctions intégrées pour identifier les lettres majuscules et minuscules. Ce serait beaucoup plus concis que de vérifier chaque lettre individuellement.

Traduction approximative:

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 121 111 octets

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

Essayez-le en ligne

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 octets

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

MATL , 18 octets

La version actuelle ( 4.0.0 ) de la langue est utilisée.

Cela applique la même expression régulière que la réponse de NinjaBearMonkey :

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

La sortie est la chaîne (qui est véridique ) si c'est un nom officiel, et rien (qui est faux ) si ce n'est pas le cas.

Exemples

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

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

Haskell, 61 octets

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

Gema, 17 personnages

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

Exemple d'exécution:

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

Rubis, 28 octets

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

-2 octets (grâce au manatwork)

Code machine IA-32, 19 octets

Une fonction qui reçoit le pointeur vers une chaîne se terminant par null ecxet renvoie 0 ou 1 dans eax(selon la fastcallconvention).

Hexdump du code:

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

En langage assembleur:

    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;

Le premier octet du nom d'entrée a son 5ème bit inversé ( xoravec 32) pour le convertir de la casse majuscule en petite casse. Cela charge 32 dans eax, en utilisant 3 octets de code:

    push 32;
    pop eax;

Pour vérifier si l'octet est une petite lettre:

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

Sinon, ce code échoue. Pour retourner 0 dans ce cas, il met 0 alavant de faire le saut conditionnel:

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

Le 0 dans alsert également de masque xor (ou d'absence) pour les octets suivants du nom d'entrée.

Une sortie réussie se produit lorsqu'elle rencontre un octet zéro, qui reste nul après xor:

    xor al, [ecx];
    jz yes;

Il suppose que le nom d'entrée n'est pas vide. Je suppose que c'est une hypothèse raisonnable sur un nom (pas une chaîne arbitraire)!

grep, 16 octets

Voici le schéma:

[A-Z][a-z]+

Si vous utilisez les commutateurs -Eet -xet imprimera un nombre de lignes d'entrée correspondantes. Donc, si vous lui donnez une ligne, vous obtenez un 1 ou un 0. Je pense que c'est ainsi que fonctionne cet endroit.-cgrep

Le modèle est de 11 caractères, toute la ligne de commande est de 23. J'ai vu des gens utiliser des sedscripts sans la commande, donc je ne sais pas quoi. Mais, il lit stdin, et vous pouvez donc simplement taper dessus. Voici 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 octets

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

Utilise un octet de moins que la solution d'expression régulière standard. Il fait trois vérifications. LetterQ@#garantit que la chaîne est entièrement composée de lettres et StringLength@#>1invalide les chaînes d'une seule lettre. #==ToCamelCase@#est cependant moins logique. ToCamelCaseest une fonction non documentée que j'ai trouvée qui prend une chaîne d'entrée AndOutputsItLikeThis. Puisqu'il n'y a qu'un seul mot, il mettra en majuscule la première lettre, donc nous vérifions si la chaîne est égale à cela.

bash / zsh / ksh, 25 octets

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

Pour réellement l'utiliser, créez un fichier avec lui comme seule ligne et rendez le fichier exécutable; les fichiers exécutables non reconnus comme un type binaire connu sont traités comme des scripts shell (pour /bin/shspécifiquement).

$ 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 octets

Ma première tentative au Code Golf. Ça vient:

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

Voyez-le en action sur Dot Net Fiddle .

Java, 28 octets

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

Utilise l'expression régulière pour s'assurer que la chaîne se compose d'un caractère majuscule suivi d'au moins un caractère minuscule.

-1 octets grâce à Benjamin Urquhart

k4, 39 octets

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

Le premier caractère est supérieur, tous les autres sont inférieurs, comptent plus d'un.

Par exemple:

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

Sérieusement, 16 octets

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

Vidage hexadécimal:

a3342c6e983d296c313c29972d592626

Essayez-le en ligne

Sérieusement n'a pas encore de support regex, donc le mieux que nous pouvons faire est:

 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 octets

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

Exemple d'utilisation:

# 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

Non golfé (avec de vrais noms de fonction):

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 octets

SpecBAS gère les expressions régulières via la MATCHcommande. La sortie est 0 pour faux et 1 si vrai.

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

Swift 2, 116 octets

Regex est tellement verbeux dans Swift que cela est beaucoup plus court

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}

Cela renverra 0ou -1(en cas d'absence de saisie) pour les noms non officiels, et un nombre> 0 (qui est égal à la longueur de la chaîne - 1) si le nom est officiel

Non golfé

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 octets

Les expressions régulières auraient été le bon moyen de résoudre ce problème, mais voici une tentative sans cela.

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

Écriture normale

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

J'adorerais avoir des conseils sur la façon de raccourcir la vérification des minuscules, peut-être sans la boucle. J'ai juste commencé à apprendre la langue et je l'ai utilisé comme pratique, j'ai pensé partager mon résultat de toute façon.

Perl 5 -p , 18 octets

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

Essayez-le en ligne!

PowerShell , 29 octets

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

Essayez-le en ligne!

Est-ce que le même regex trompe tout le monde utilise. Doit utiliser case-sensitive matchpour le faire correctement au prix d'un octet.

Japt , 9 octets

Renvoie 1ou 0.

è"^%A%a+$

Essayez-le

Perl 6 , 17 octets

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

Renvoie un Matchobjet s'il s'agit d'un nom officiel ou Nilautre.

Essayez-le en ligne!