Meu nome é oficial?

25

Introdução

Como o ToonAlfrink diz : "Eu acho que aqui não há perguntas fáceis suficientes que os iniciantes possam tentar!". Portanto, a tarefa é muito simples. Dada uma string, produza um valor verdadeiro ou falso, independentemente de o nome ser oficial ou não.

Um nome é "oficial" se for uma única palavra em maiúscula, ou seja:

  • Se o primeira letra estiver em maiúscula (não oficial:adnan :)
  • Se as outras letras forem não maiúsculas (não oficiais:AdNaN :)
  • Se o nome não contém quaisquer caracteres não-alfabéticos (não oficial: Adnan123,Adnan! )
  • Se o nome consistir em apenas uma palavra (não oficial: Adn an ,Adn An )
  • Se o nome tiver mais de um caractere (não oficial: A :)

Regras

  • Você pode fornecer uma função ou um programa
  • Isso é código-golfe , então a submissão com a menor quantidade de bytes ganha!
  • Nota: Para simplificar, nomes como Mary-Ann não são oficiais neste desafio .
  • Suponha que não haja espaços em branco à esquerda no nome.
  • Suponha que apenas os caracteres ASCII imprimíveis ( 32-126) sejam usados ​​nos nomes

Casos de teste

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

Entre os melhores

Mostrar snippet de código

code-golf  string 
— Adnan
fonte
5
Então meu nome não é oficial? É melhor eu mudar isso então.
— ETHproductions
12
@ETHproductions Se estamos usando esta lógica, Lolololololololololololé um nome oficial :)
— Adnan
1
Isso realmente não responde à pergunta. Qual é: "você pode assumir que o nome não contém letras acentuadas" ou "nomes com letras acentuadas devem render False"?
— Lynn
1
Como uma digressão canadense um pouco excêntrica, um professor que eu conheço não ficaria satisfeito com seus critérios "oficiais": Robert Smith? . O nome dele, na verdade, tem esse ponto de interrogação . Além disso, Sahaiʔa .
— Iwillnotexist Idonotexist
1
@FarhanAnam Yes
— Adnan

Respostas:

6

Pitão, 16 13 12 bytes

Agradeço a @Thomas Kwa por me lembrar sobre o titlecase.

&qzr@GrzZ3tz

Conjunto de Teste .

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

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

Experimente online | Conjunto de teste (a saída0 significa que nenhuma das seqüências corresponde, o que é esperado.)

Quando o Retina é fornecido apenas com uma única linha de código, ele gera o número de vezes que a expressão correspondeu à sequência de entrada, para que ele produza (verdadeiramente) se 1corresponder e, portanto, for um nome oficial e 0(falso), se não for.

Demolir

^       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
Parece que precisamos de classes de caracteres para letras. ;)
— Martin Ender
10

TeaScript, 12 bytes

xO`A-Z][a-z`

Abusa da Ofunção.

Experimente online

Suíte de teste

Explicação

A Ofunção faz isso:

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

Em seguida, a função O verifica se o regex corresponde x.

Como alternativa, uma resposta não concorrente do TeaScript 3 com 7 bytes :

xO/\A\a
— Downgoat
fonte
Ahahaha, legal. Em algum momento, enquanto trabalhava no interpretador Japt, usei esse truque com a isCharfunção que você adicionou. Mas você pode explicar mais detalhadamente para quem não conhece.
— ETHproductions
Ooooooh, eu gosto dos novos recursos do regex!
— ETHproductions
7

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>
Expandir snippet

— edc65
fonte
Droga, você me venceu. Você também ultrapassou minha versão em 5 bytes.
— SuperJedi224
1
Um byte a menos:n=>n.match`^[A-Z][a-z]+$`
— user81655
IMHO @ user81655 uma matriz como um valor truthy é também forçado
— edc65
@ edc65 Embora seja válido.
— SuperJedi224
1
Por apenas 4 bytes a mais, você obtém a conformidade ES5:/./.test.bind(/^[A-Z][a-z]+$/)
— CR Drost
7

Python, 59 58 bytes

Tenho certeza de que não há uma maneira real de vencer a versão Retina, já que isso é basicamente o Python. Mas acho que esta é minha primeira submissão;)

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

É um valor de verdade muito estranho :

(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 requer ""strings com espaços, se passado pelo shell)

— Wayne Werner
fonte
1
^não é necessário, pois re.match()apenas corresponde ao início da string.
— Manatwork
1
@manatwork nice! Outro byte raspado :) Eu poderia salvar outro byte com o paren de fechamento, usando Python2
— Wayne Werner
1
@WayneWerner: é por isso que você deve fornecer a versão Python :) Acho que Python 2 e Python 3 são tipos de linguagens diferentes, pelo menos para codegolf.
— movatica
Se você usar um lambda anônimo em vez de um programa inteiro, obterá 45 bytes:lambda s:re.match('[A-Z][a-z]+$',s) import re
— movatica
1
@movatica Oh, gritos!
— MilkyWay90
4

Python, 50 45 43 41 bytes

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

Retorna Truese for um nome oficial ou Falsese não for.

— Zenadix
fonte
Regras do estado do codegolf, que você não precisa levar f=em consideração, economizando dois bytes. Além disso, (len(s)>1)economiza 5 bytes s[1:].islower(). :)
— movatica
3

BotEngine , 203 180 29x6 = 174

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

Eu realmente devo adicionar built-in para identificar letras maiúsculas e minúsculas. Isso seria muito mais conciso do que verificar cada letra individualmente.

Tradução 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
— SuperJedi224
fonte
3

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

Experimente 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);
}
— James
fonte
2

MATL , 18 bytes

The current version (4.0.0) of the language is used.

This applies the same regular expression as NinjaBearMonkey's answer:

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

The output is the string (which is truthy) if it's an official name, and nothing (which is falsy) if it's not.

Examples

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

>> matl
 > j'^[A-Z][a-z]+$'XX
 > 
> ASCII
>>
— Luis Mendo
fonte
2

Gema, 17 characters

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

Sample run:

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
— manatwork
fonte
2

IA-32 machine code, 19 bytes

A function that receives the pointer to a null-terminating string in ecx and returns 0 or 1 in eax (according to the fastcall convention).

Hexdump of the code:

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

In assembly language:

    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;

The first byte of the input name has its 5th bit flipped (xor with 32) to convert it from capital case to small case. This loads 32 into eax, using 3 bytes of code:

    push 32;
    pop eax;

To check whether the byte is a small letter:

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

If not, this code falls through. To return 0 in this case, it puts 0 in al before doing the conditional jump:

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

The 0 in al also serves as a xor-mask (or absence of it) for the following bytes of the input name.

A successful exit is when it encounters a zero byte, which stays zero after the xor:

    xor al, [ecx];
    jz yes;

It assumes that the input name is not empty. I guess it's a reasonable assumption about a name (not an arbitrary string)!

— anatolyg
fonte
2

grep, 16 bytes

This is the pattern:

[A-Z][a-z]+

If you use the -E and -x and -c switches grep will print a count of matching input lines. So if you give it one line you get a 1 or a 0. I think that's how this place works.

The pattern is 11 chars, the whole command line is 23. I've seen people use sed scripts without the command so I don't know what is what. But, it reads stdin, and so you can just type at it. Here's echo:

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

1
0
0
— mikeserv
fonte
@Doorknob - seems fair enough to me. thanks very much. which hat did you guess?
— mikeserv
1
I figured out Hairboat's Revenge. :P
— Doorknob
Stop me if (as is quite probable) I'm wrong but you can use grep -Exc so you don't need to count as many bytes for the switches.
— Neil
@Neil - i dunno if you're wrong. i have really no idea - have a look at the edit history.
— mikeserv
2

Mathematica 10.1, 46 bytes

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.

— LegionMammal978
fonte
Is ToCamelCase new in 10.3? Doesn't seem to work in 10.2.
— murphy
@murphy, it works for me in 10.1. What do you get with ToCamelCase["foo bar baz"]?
— LegionMammal978
Ok, I can confirm that it works in 10.1. However, in 8.0, 9.0, 10.0 and 10.2 the function is not defined (your test case returns ToCamelCase[foo bar baz]). Strange! Maybe someone can check 10.3?
— murphy
2

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
$
— Aaron Davies
fonte
2
This works fine in bash, ksh and zsh, but has no chance to work in standard POSIX sh or the compatible dash and yash. To avoid confusion, I suggest to change the answer's title.
— manatwork
3
Use printf instead of echo to create the file and you’ll get 25 bytes.
— sam hocevar
Good points, both of you; both applied.
— Aaron Davies
2

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.

— Farhan Anam
fonte
If you use C# 6, you can make it a bit shorter: bool o(string i)=>System.Text.RegularExpressions.Regex.IsMatch(i,"^[A-Z][a-z]+$");
— ProgramFOX
2

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

— HyperNeutrino
fonte
You can drop the semicolon
— Benjamin Urquhart
@BenjaminUrquhart oh right, thanks
— HyperNeutrino
1

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
— Aaron Davies
fonte
1

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
— quintopia
fonte
1

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;;
— Moshe Katz
fonte
You could actually save about 10% by using booleans instead of integers (bleh!) and replacing those bulky if … then 0 else by … ||. And for that matter by using boolean operators instead of match and ranges, e.g. n.[0]>'@'&n.[0]<'['&e(l-1)
— Gilles 'SO- stop being evil'
1

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$)
— Brian
fonte
1

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
}
— Jojodmo
fonte
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.

— Goose
fonte
1

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.

— Veskah
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.