¿Es oficial mi nombre?

25

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

Mostrar fragmento de código

code-golf  string 
— Adnan
fuente
55
¿Entonces mi nombre no es oficial? Será mejor que lo cambie entonces.
— ETHproductions
12
@ETHproductions Si estamos usando esta lógica, Lolololololololololololes un nombre oficial :)
— Adnan
1
Eso realmente no responde la pregunta. ¿Cuál es: "puede suponer que el nombre no contiene letras acentuadas" o "los nombres con letras acentuadas deberían ceder False"?
— Lynn
1
Como una digresión poco convencional en Canadá, un profesor que conozco no estaría contento con su criterio "oficial": ¿ Robert Smith? . Su nombre en realidad tiene ese signo de interrogación . Además, Sahaiʔa .
— Iwillnotexist Idonotexist
1
@FarhanAnam Sí
— Adnan

Respuestas:

6

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
— Maltysen
fuente
21

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
— NinjaOsoMono
fuente
8
Parece que necesitamos clases de caracteres para las letras. ;)
— Martin Ender
10

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
— Downgoat
fuente
Jajajaja, linda. En algún momento mientras trabajaba en el intérprete de Japt, usé este truco con la isCharfunción que agregaste. Pero es posible que desee explicar con más detalle para aquellos que no lo saben.
— ETHproductions
¡Ooooooh, me gustan las nuevas funciones de expresiones regulares!
— 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 fragmento

— edc65
fuente
Maldición, me ganaste. También superó mi versión en 5 bytes.
— SuperJedi224
1
Un byte menos:n=>n.match`^[A-Z][a-z]+$`
— user81655
@ user81655 una matriz como un valor verdadero es demasiado forzado en mi humilde opinión
— edc65
@ edc65 Sin embargo, es válido.
— SuperJedi224
1
Por solo 4 bytes más obtienes el cumplimiento de ES5:/./.test.bind(/^[A-Z][a-z]+$/)
— CR Drost
7

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)

— Wayne Werner
fuente
1
^no es necesario ya que re.match()solo coincide al principio de la cadena.
— manatwork
1
@manatwork agradable! Otro byte afeitado :) Podría guardar otro byte con el par de cierre, usando Python2
— Wayne Werner
1
@WayneWerner: por eso deberías darle la versión de Python :) Creo que Python 2 y Python 3 son tipos de lenguajes diferentes, al menos para codegolf.
— movatica
Si usa una lambda anónima en lugar de un programa completo, obtiene 45 bytes:lambda s:re.match('[A-Z][a-z]+$',s) import re
— movatica
1
@movatica ¡Vaya!
— MilkyWay90
4

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.

— Zenadix
fuente
Las reglas del estado de codegolf indican que no es necesario tener f=en cuenta el ahorro de dos bytes. Además, (len(s)>1)ahorra 5 bytes s[1:].islower(). :)
— movatica
3

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
— SuperJedi224
fuente
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);}

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

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
>>
— Luis Mendo
fuente
2

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
— hombre trabajando
fuente
2

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)!

— anatolyg
fuente
2

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
— mikeserv
fuente
@Doorknob: me parece bastante justo. muchas gracias. ¿Qué sombrero adivinaste?
— mikeserv
1
Descubrí la venganza de Hairboat. : P
— Pomo de la puerta
Deténgame si (como es bastante probable) estoy equivocado, pero puede usarlo grep -Excpara que no necesite contar tantos bytes para los conmutadores.
— Neil
@Neil - No sé si te equivocas. Realmente no tengo ni idea, mira el historial de edición.
— mikeserv
2

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.

— LegionMammal978
fuente
¿Es ToCamelCasenuevo en 10.3? No parece funcionar en 10.2.
— murphy
@murphy, me funciona en 10.1. ¿Con qué te llevas ToCamelCase["foo bar baz"]?
— LegionMammal978
Ok, puedo confirmar que funciona en 10.1. Sin embargo, en 8.0, 9.0, 10.0 y 10.2 la función no está definida (su caso de prueba regresa ToCamelCase[foo bar baz]). ¡Extraño! Tal vez alguien puede verificar 10.3?
— murphy
2

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
$
— Aaron Davies
fuente
2
Esto funciona bien en bash, kshy zsh, pero no tiene posibilidad de funcionar en POSIX estándar sho en el compatible dashy yash. Para evitar confusiones, sugiero cambiar el título de la respuesta.
— manatwork
3
Use en printflugar de echocrear el archivo y obtendrá 25 bytes.
— sam hocevar
Buenos puntos, los dos; ambos aplicados.
— Aaron Davies
2

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 .

— Farhan Anam
fuente
Si usa C # 6, puede hacerlo un poco más corto: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]+")

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

— Hiperneutrino
fuente
Puedes dejar el punto
— Benjamin Urquhart
@BenjaminUrquhart oh cierto, gracias
— HyperNeutrino
1

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

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
— quintapia
fuente
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;;

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;;
— Moshe Katz
fuente
En realidad, podría ahorrar aproximadamente un 10% utilizando booleanos en lugar de enteros (¡bleh!) Y reemplazando esos voluminosos if … then 0 else por … ||. Y para el caso, utilizando operadores booleanos en lugar de matchy rangos, por ejemplon.[0]>'@'&n.[0]<'['&e(l-1)
— Gilles 'SO- deja de ser malvado'
1

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

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

— ganso
fuente
1

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.

— Veskah
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.