introduzione

Come dice ToonAlfrink : "Io penso che qui non ci siano abbastanza domande facili da provare per i principianti!". Quindi il compito è molto semplice. Data una stringa, genera un valore di verità o di falsità indipendentemente dal fatto che il nome sia ufficiale o meno.

Un nome è "ufficiale" se si tratta di una singola parola maiuscola, ovvero:

Se la prima lettera è in maiuscolo (non ufficiale adnan:)
Se le altre lettere non sono in maiuscolo (non ufficiali AdNaN:)
Se il nome non contenga caratteri non alfabetici (non ufficiale: Adnan123, Adnan!)
Se il nome è composto da una sola parola (non ufficiale: Adn an, Adn An)
Se il nome ha più di un personaggio (non ufficiale A:)

Regole

È possibile fornire una funzione o un programma
Questo è code-golf , quindi vince l'invio con il minor numero di byte!
Nota: per semplificare le cose, nomi come Mary-Ann non sono ufficiali in questa sfida .
Supponiamo che non ci siano spazi bianchi principali nel nome.
Supponiamo che 32-126nei nomi vengano usati solo i caratteri ASCII stampabili ( )

Casi 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

Classifica

Mostra snippet di codice

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

Espandi frammento

code-golf string

— Adnan
fonte

5

Quindi il mio nome non è ufficiale? Farei meglio a cambiarlo allora.

— Produzioni ETH il

12

@ETHproductions Se stiamo usando questa logica, Lolololololololololololè un nome ufficiale :)

— Adnan,

1

Questo non risponde davvero alla domanda. Che Falsecos'è : "puoi presumere che il nome non contenga lettere accentate" o "i nomi con lettere accentate dovrebbero dare "?

— Lynn il

1

Essendo una digressione canadese leggermente fuori dal comune, un professore che conosco non sarebbe contento dei tuoi criteri "ufficiali": Robert Smith? . Il suo nome in realtà ha quel punto interrogativo . Inoltre, Sahaiʔa .

— Iwillnotexist Idonotexist il

1

@FarhanAnam Sì

— Adnan il

6

Pyth, 16 13 12 byte

Grazie a @Thomas Kwa per avermi ricordato della 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

— Maltysen
fonte

21

Retina, 13 byte

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

Provalo online | Suite di test (L'output 0indica che nessuna stringa è abbinata, il che è previsto.)

Quando a Retina viene fornito solo una singola riga di codice, restituisce il numero di volte in cui l'espressione corrisponde alla stringa di input, quindi verrà emessa 1(in verità) se corrisponde e quindi è un nome ufficiale e 0(falsa) se non lo è.

Abbattersi

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

— NinjaBearMonkey
fonte

8

Sembra che abbiamo bisogno di classi di caratteri per le lettere. ;)

— Martin Ender il

10

TeaScript, 12 byte

xO`A-Z][a-z`

Abusa della Ofunzione.

Prova questo online

Test Suite

Spiegazione

La Ofunzione rende questo:

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

Quindi, la funzione O controlla se la regex corrisponde x.

In alternativa, una risposta TeaScript 3 non competitiva a 7 byte :

xO/\A\a

— Downgoat
fonte

Ahahaha, carino. Ad un certo punto mentre stavo lavorando sull'interprete Japt, ho usato questo trucco con la isCharfunzione che hai aggiunto. Ma potresti voler spiegare più in dettaglio per coloro che non sono a conoscenza.

— ETHproductions

Ooooooh, mi piacciono le nuove funzionalità di regex!

— Produzioni ETH il

7

JavaScript (ES6), 26

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

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

Espandi frammento

— edc65
fonte

Accidenti, mi hai battuto. Hai anche superato la mia versione di 5 byte.

— SuperJedi224,

1

Un byte in meno:n=>n.match`^[A-Z][a-z]+$`

— user81655

@ user81655 un array come valore di verità è troppo forzato IMHO

— edc65

@ edc65 È valido però.

— SuperJedi224,

1

Per soli 4 byte in più ottieni la conformità ES5:/./.test.bind(/^[A-Z][a-z]+$/)

— CR Drost

7

Python, 59 58 byte

Sono sicuro che non esiste un modo reale per battere la versione Retina, dal momento che questo è fondamentalmente solo quello in Python. Ma penso che questa sia la mia prima presentazione;)

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

È un valore di verità molto strano :

(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

(E richiede ""intorno alle stringhe con spazi, se passato attraverso la shell)

— Wayne Werner
fonte

1

^non è necessario poiché re.match()corrisponde solo all'inizio della stringa.

— arte

1

@manatwork nice! Un altro byte rasato :) Potrei salvare un altro byte con il paren di chiusura, usando Python2

— Wayne Werner il

1

@WayneWerner: ecco perché dovresti dare la versione di Python :) Penso che Python 2 e Python 3 siano un po 'di lingue diverse, almeno per codegolf.

— movatica,

Se usi un lambda anonimo invece di un intero programma, otterrai 45 byte:lambda s:re.match('[A-Z][a-z]+$',s) import re

— movatica

1

@movatica Oh, whoops!

— MilkyWay90

4

Java, 53 byte

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

— SuperJedi224
fonte

Puoi usare una lambda:s->s.matches("[A-Z][a-z]+")

— Benjamin Urquhart

4

Python, 50 45 43 41 byte

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

Restituisce Truese è un nome ufficiale o Falsese non lo è.

— Zenadix
fonte

Le regole di codegolf indicano che non è necessario tenerne f=conto, salvando due byte. Inoltre, (len(s)>1)salva 5 byte oltre s[1:].islower(). :)

— movatica,

3

BotEngine , 203 180 29x6 = 174

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

Dovrei davvero aggiungere i builtin per identificare lettere maiuscole e minuscole. Sarebbe molto più conciso che controllare ogni lettera singolarmente.

Traduzione approssimativa:

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

— SuperJedi224
fonte

3

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

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

— Giacomo
fonte

3

VB6, 48 byte

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

— spazzolino da denti
fonte

2

MATL , 18 byte

Viene utilizzata la versione corrente ( 4.0.0 ) della lingua.

Questo applica la stessa espressione regolare della risposta di NinjaBearMonkey :

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

L'output è la stringa (che è veritiera ) se è un nome ufficiale, e niente (che è falsa ) se non lo è.

Esempi

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

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

— Luis Mendo
fonte

2

Haskell, 61 byte

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

— Lynn
fonte

Un byte in meno

— dfeuer

Molti altri in basso . È inoltre possibile utilizzare quella tecnica per rendere più efficiente l'altro test, ma è lo stesso numero di byte.

— dfeuer

2

Gema, 17 personaggi

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

Esecuzione di esempio:

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

— uomo al lavoro
fonte

2

Rubino, 28 byte

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

-2 byte (grazie a manatwork)

— Fava di cacao
fonte

Date un'occhiata a Fábio Perez 's psuggerimenti relativi a Consigli per giocare a golf in Ruby .

— arte

p !!gets[/^[A-Z][a-z]+$/]

— Più

2

Codice macchina IA-32, 19 byte

Una funzione che riceve il puntatore a una stringa che termina con null in ecxe restituisce 0 o 1 in eax(secondo la fastcallconvenzione).

Hexdump del codice:

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

Nel linguaggio assembly:

    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;

Il primo byte del nome di input ha il suo 5o bit capovolto ( xorcon 32) per convertirlo da maiuscolo a minuscolo. Questo carica 32 in eax, usando 3 byte di codice:

    push 32;
    pop eax;

Per verificare se il byte è una lettera minuscola:

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

In caso contrario, questo codice fallisce. Per restituire 0 in questo caso, inserisce 0 alprima di eseguire il salto condizionale:

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

Lo 0 in alfunge anche da maschera xor (o assenza) per i seguenti byte del nome di input.

Un'uscita corretta si verifica quando incontra un byte zero, che rimane zero dopo il xor:

    xor al, [ecx];
    jz yes;

Presuppone che il nome di input non sia vuoto. Immagino sia ragionevole supporre un nome (non una stringa arbitraria)!

— anatolyg
fonte

2

`grep`, 16 byte

Questo è lo schema:

[A-Z][a-z]+

Se si utilizza -Ee -xe-c interruttori grepstamperanno un conteggio delle linee di ingresso corrispondenti. Quindi se gli dai una riga ottieni 1 o 0. Credo che sia così che funziona questo posto.

Il modello è di 11 caratteri, l'intera riga di comando è 23. Ho visto persone usare sedscript senza il comando, quindi non so cosa sia cosa. Ma legge lo stdin e quindi puoi semplicemente digitarlo. Ecco echo:

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

1
0
0

— mikeserv
fonte

@Doorknob - mi sembra abbastanza giusto. grazie mille. quale cappello hai indovinato?

— Mikeserv,

1

Ho capito Hairboat's Revenge. : P

— Maniglia della porta

Fermami se (come è abbastanza probabile) sbaglio, ma puoi usarlo in grep -Excmodo da non dover contare tanti byte per gli switch.

— Neil,

@Neil - non so se sbagli. non ne ho davvero idea - dai un'occhiata alla cronologia delle modifiche.

— Mikeserv,

2

Mathematica 10.1, 46 byte

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

Utilizza un byte in meno rispetto alla soluzione regex standard. Fa tre controlli. LetterQ@#assicura che la stringa sia interamente composta da lettere e StringLength@#>1invalida stringhe a lettera singola. #==ToCamelCase@#ha meno senso, tuttavia. ToCamelCaseè una funzione non documentata che ho trovato che accetta una stringa di input AndOutputsItLikeThis. Poiché esiste una sola parola, la prima lettera verrà maiuscola, quindi controlliamo se la stringa è uguale a quella.

— LegionMammal978
fonte

È ToCamelCasenuovo in 10.3? Non sembra funzionare in 10.2.

— Murphy

@murphy, funziona per me in 10.1. Con cosa ottieni ToCamelCase["foo bar baz"]?

— LegionMammal978,

Ok, posso confermare che funziona in 10.1. Tuttavia, in 8.0, 9.0, 10.0 e 10.2 la funzione non è definita (viene restituito il test case ToCamelCase[foo bar baz]). Strano! Forse qualcuno può controllare 10.3?

— Murphy

2

bash / zsh / ksh, 25 byte

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

Per usarlo effettivamente, creaci un file come unica riga e rendi il file eseguibile; i file eseguibili non riconosciuti come tipo binario noto vengono trattati come script di shell (in /bin/shparticolare).

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

— Aaron Davies
fonte

2

Funziona bene in bash, kshe zsh, ma non ha alcuna possibilità di lavorare in POSIX standard sho compatibile dashe yash. Per evitare confusione, suggerisco di cambiare il titolo della risposta.

— arte

3

Usa printfinvece di echocreare il file e otterrai 25 byte.

— Sam Hocevar,

Aspetti positivi, entrambi; entrambi applicati.

— Aaron Davies,

2

C # 4, 89 byte

Il mio primo tentativo di Code Golf. Ecco che arriva:

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

Guardalo in azione su Dot Net Fiddle .

— Farhan Anam
fonte

Se usi C # 6, puoi renderlo un po 'più breve:bool o(string i)=>System.Text.RegularExpressions.Regex.IsMatch(i,"^[A-Z][a-z]+$");

— ProgramFOX il

2

Java, 28 byte

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

Utilizza regex per assicurarsi che la stringa sia composta da un carattere maiuscolo seguito da almeno un carattere minuscolo.

-1 byte grazie a Benjamin Urquhart

— HyperNeutrino
fonte

Puoi eliminare il punto

— Benjamin Urquhart

@BenjaminUrquhart oh, grazie

— HyperNeutrino

1

k4, 39 byte

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

Il primo carattere è superiore, tutti gli altri sono inferiori, contano più di uno.

Per esempio:

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

— Aaron Davies
fonte

1

Scherzi a parte, 16 byte

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

Dump esadecimale:

a3342c6e983d296c313c29972d592626

Provalo online

Seriamente non ha ancora il supporto regex, quindi il meglio che possiamo fare è:

 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

— quintopia
fonte

1

Ocaml, 231 216 197 166 byte

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

Esempio di utilizzo:

# 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 (con nomi di funzioni reali):

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

— Moshe Katz
fonte

Potresti effettivamente risparmiare circa il 10% usando i valori booleani anziché interi (bleh!) E sostituendo quelli voluminosi if … then 0 else con … ||. E del resto usando operatori booleani anziché matche intervalli, ad esempion.[0]>'@'&n.[0]<'['&e(l-1)

— Gilles 'SO- smetti di essere malvagio' il

1

SpecBAS - 39 byte

SpecBAS gestisce le espressioni regolari tramite il MATCHcomando. L'output è 0 per falso e 1 se vero.

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

— Brian
fonte

1

Swift 2, 116 byte

Regex è così prolisso in Swift che farlo è molto più breve

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}

Questo restituirà 0o -1(nel caso di nessun input) per nomi non ufficiali, e un numero > 0(che è uguale alla lunghezza della stringa - 1) se il nome è ufficiale

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
}

— Jojodmo
fonte

1

C #, 188 byte

Le espressioni regolari sarebbero state il modo giusto per affrontarlo, ma ecco un tentativo senza di essa.

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

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

Mi piacerebbe un consiglio su come rendere più breve il controllo in minuscolo, forse senza il loop. Ho appena iniziato a studiare la lingua e l'ho usato come pratica, ho pensato di condividere comunque il mio risultato.

— Oca
fonte

1

Perl 5 `-p` , 18 byte

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

Provalo online!

— Xcali
fonte

1

PowerShell , 29 byte

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

Provalo online!

Fa lo stesso trucco regex che tutti gli altri usano. cDeve usare la sensibilità ase matchper farlo correttamente al costo di un byte.

— Veskah
fonte

1

Japt , 9 byte

Restituisce 1o 0.

è"^%A%a+$

Provalo

— ispido
fonte

1

Perl 6 , 17 byte

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

Restituisce un Matchoggetto se questo è un nome ufficiale e in caso Nilcontrario.

Provalo online!

— bb94
fonte

Non è necessario ilm

— Jo King

Il mio nome è ufficiale?

introduzione

Regole

Casi test

Classifica

Pyth, 16 13 12 byte

Retina, 13 byte

Abbattersi

TeaScript, 12 byte

Spiegazione

JavaScript (ES6), 26

Python, 59 58 byte

Java, 53 byte

Python, 50 45 43 41 byte

BotEngine , 203 180 29x6 = 174

C, 129 122 121 111 byte

VB6, 48 byte

MATL , 18 byte

Esempi

Haskell, 61 byte

Gema, 17 personaggi

Rubino, 28 byte

Codice macchina IA-32, 19 byte

grep, 16 byte

Mathematica 10.1, 46 byte

bash / zsh / ksh, 25 byte

C # 4, 89 byte

Java, 28 byte

k4, 39 byte

Scherzi a parte, 16 byte

Ocaml, 231 216 197 166 byte

SpecBAS - 39 byte

Swift 2, 116 byte

Ungolfed

C #, 188 byte

Perl 5 -p , 18 byte

PowerShell , 29 byte

Japt , 9 byte

Perl 6 , 17 byte

`grep`, 16 byte

Perl 5 `-p` , 18 byte