Introducción

Como dice ToonAlfrink : "¡ Creo que no hay suficientes preguntas fáciles aquí que los principiantes puedan intentar!". Entonces la tarea es muy simple. Dada una cadena, genera un valor verdadero o falso independientemente de si el nombre es oficial o no.

Un nombre es "oficial" si es una sola palabra de título de caso, es decir:

• Si el primero se escribe con mayúscula carta (no oficial: adnan)
• Si las otras letras son no capitalizan (no oficial: AdNaN)
• Si el nombre no contiene ningún carácter no alfabéticos (no oficial: Adnan123, Adnan!)
• Si el nombre consta de una sola palabra (no oficial: Adn an, Adn An)
• Si el nombre tiene más de un carácter (no oficial: A)

Reglas

• Puede proporcionar una función o un programa
• Este es el código de golf , por lo que gana el envío con la menor cantidad de bytes.
• Nota: Para simplificar las cosas, nombres como Mary-Ann no son oficiales en este desafío .
• Suponga que no hay espacios en blanco iniciales en el nombre.
• Suponga que solo 32-126se usan los caracteres ASCII imprimibles ( ) en los nombres

Casos de prueba

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

Tabla de clasificación

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

Gracias a @Thomas Kwa por recordarme sobre titlecase.

&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]+$

Pruébalo en línea | Conjunto de pruebas (el resultado 0significa que ninguna de las cadenas coincide, lo que se espera).

Cuando Retina solo se proporciona con una sola línea de código, genera la cantidad de veces que la expresión coincide con la cadena de entrada, por lo que generará 1(verdadero) si coincide y, por lo tanto, es un nombre oficial y 0(falso) si no lo es.

Descompostura

^       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`

Abusa de la Ofunción.

Prueba esto en línea

Banco de pruebas

Explicación

La Ofunción hace esto:

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

Luego, la función O verifica si la expresión regular coincide x.

Alternativamente, una respuesta de TeaScript 3 no competitiva a 7 bytes :

xO/\A\a

JavaScript (ES6), 26

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

Por: 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

Estoy seguro de que no hay una forma real de vencer a la versión Retina, ya que esto es básicamente eso dentro de Python. Pero creo que esta es mi primera presentación;)

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

Es muy extraño valor de verdad :

(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

(Y requiere ""alrededor de cadenas con espacios, si se pasa a través del shell)

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

Devuelve Truesi es un nombre oficial o Falsesi no lo es.

BotEngine , 203 180 29x6 = 174

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

Realmente debería agregar builtins para identificar letras mayúsculas y minúsculas. Eso sería mucho más conciso que verificar cada letra individualmente.

Traducción aproximada:

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

Pruébalo en línea

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

Se utiliza la versión actual ( 4.0.0 ) del idioma.

Esto aplica la misma expresión regular que la respuesta de NinjaBearMonkey :

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

La salida es la cadena (que es verdadera ) si es un nombre oficial, y nada (que es falso ) si no lo es.

Ejemplos

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

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

Ejecución de muestra:

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

Rubí, 28 bytes.

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

-2 bytes (gracias a manatwork)

Código de máquina IA-32, 19 bytes

Una función que recibe el puntero a una cadena de terminación nula ecxy devuelve 0 o 1 pulg eax(de acuerdo confastcall convención).

Hexdump del código:

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

En lenguaje ensamblador:

    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;

El primer byte del nombre de entrada tiene su quinto bit invertido ( xorcon 32) para convertirlo de mayúscula a minúscula. Esto carga 32 en eax, usando 3 bytes de código:

    push 32;
    pop eax;

Para verificar si el byte es una letra minúscula:

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

Si no, este código falla. Para devolver 0 en este caso, pone 0 alantes de hacer el salto condicional:

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

El 0 in altambién sirve como una máscara xor (o ausencia de ella) para los siguientes bytes del nombre de entrada.

Una salida exitosa es cuando encuentra un byte cero, que permanece cero después de xor:

    xor al, [ecx];
    jz yes;

Se supone que el nombre de entrada no está vacío. ¡Supongo que es una suposición razonable sobre un nombre (no una cadena arbitraria)!

grep, 16 bytes

Este es el patrón:

[A-Z][a-z]+

Si usa el -Ey-x e -cinterruptoresgrep se imprimirán un recuento de las líneas de entrada coincidentes. Entonces, si le das una línea, obtienes un 1 o un 0. Creo que así es como funciona este lugar.

El patrón es de 11 caracteres, la línea de comando completa es 23. He visto a personas usar sedscripts sin el comando, así que no sé qué es qué. Pero, lee stdin, por lo que puede escribirlo. Aquí está 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&

Utiliza un byte menos que la solución estándar de expresiones regulares. Hace tres verificaciones. LetterQ@#garantiza que la cadena esté completamente compuesta de letras e StringLength@#>1invalida las cadenas de una letra. #==ToCamelCase@#Sin embargo, tiene menos sentido. ToCamelCasees una función no documentada que encontré que toma una cadena de entrada AndOutputsItLikeThis. Dado que solo hay una palabra, capitalizará la primera letra, por lo que verificaremos si la cadena es igual a esa.

bash / zsh / ksh, 25 bytes

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

Para usar esto realmente, cree un archivo con él como la única línea y haga que el archivo sea ejecutable; Los archivos ejecutables que no se reconocen como un tipo binario conocido se tratan como scripts de shell ( /bin/shespecíficamente).

$ 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

Mi primer intento en Code Golf. Aquí viene:

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

Véalo en acción en Dot Net Fiddle .

Java, 28 bytes

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

Utiliza expresiones regulares para asegurarse de que la cadena consta de un carácter en mayúscula seguido de al menos un carácter en minúscula.

-1 bytes gracias a Benjamin Urquhart

k4, 39 bytes

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

El primer carácter es superior, todos los demás son inferiores, cuentan más de uno.

P.ej:

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

En serio, 16 bytes

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

Hex Dump:

a3342c6e983d296c313c29972d592626

Pruébalo en línea

En serio, todavía no tiene soporte para expresiones regulares, por lo que lo mejor que podemos hacer es:

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

Ejemplo de uso:

# 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

Sin golf (con nombres de funciones reales):

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 maneja expresiones regulares a través del MATCHcomando. La salida es 0 para falso y 1 si es verdadero.

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

Swift 2, 116 bytes

Regex es tan detallado en Swift que hacer esto es mucho más corto

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}

Esto regresará 0o-1 (en el caso de no entrada) para nombres no oficiales, y un número> 0 (que es igual a la longitud de la cadena - 1) si el nombre es oficial

Sin 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 bytes

Las expresiones regulares habrían sido la forma correcta de abordar esto, pero aquí hay un intento sin él.

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

Escritura común a mano

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

Me encantaría recibir consejos sobre cómo hacer que la verificación en minúsculas sea más corta, quizás sin el bucle. Recién comencé a aprender el idioma, y ​​usé esto como práctica, pensé que compartiría mi resultado de todos modos.

Perl 5 -p , 18 bytes

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

Pruébalo en línea!

PowerShell , 29 bytes

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

Pruébalo en línea!

¿Tiene el mismo truco regex que todos los demás están usando? Tiene que usar case-sensitive matchpara hacerlo correctamente a costa de un byte.

Japt , 9 bytes

Devoluciones 1o 0.

è"^%A%a+$

Intentalo

Perl 6 , 17 bytes

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

Devuelve un Matchobjeto si este es un nombre oficial y de lo Nilcontrario.

Pruébalo en línea!