Мое имя официально?

25

Введение

Как говорит ToonAlfrink : «Я думаю, что здесь недостаточно простых вопросов, которые могут попробовать новички!». Так что задача очень проста. Если задана строка, выведите истинное или ложное значение, является ли имя официальным или нет.

Имя является «официальным», если это одно слово в заглавном регистре, то есть:

  • Если первая буква капитализируются (не официально: adnan)
  • Если остальные буквы не капитализируются (не официально: AdNaN)
  • Если имя не содержит каких - либо не-буквенные символы (не официальный: Adnan123, Adnan!)
  • Если имя состоит из одного слова (не официально: Adn an, Adn An)
  • Если имя имеет более одного символа (не официально: A)

правила

  • Вы можете предоставить функцию или программу
  • Это код-гольф , поэтому выигрывает представление с наименьшим количеством байтов!
  • Примечание. Чтобы упростить задачу, такие имена, как Мэри-Энн, не являются официальными.
  • Предположим, что в имени нет начальных пробелов.
  • Предположим, что 32-126в именах используются только печатаемые символы ASCII ( )

Контрольные примеры

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

Leaderboard

Показать фрагмент кода

code-golf  string 
— Аднан
источник
5
Значит, мое имя не официально? Я бы лучше изменил это тогда.
— ETHproductions
12
@ETHproductions Если мы используем эту логику, Lolololololololololololэто официальное название :)
— Аднан
1
Это на самом деле не отвечает на вопрос. Что это: «вы можете предположить, что имя не содержит акцентированные буквы» или «имена с акцентированными буквами должны давать False»?
— Линн
1
Как немного странное канадское отступление, профессор, которого я знаю, не был бы доволен вашими «официальными» критериями: Роберт Смит? , На самом деле его имя имеет этот знак вопроса . Кроме того, Сахайна .
— Iwillnotexist Idonotexist
1
@FarhanAnam Да
— Аднан

Ответы:

6

Pyth, 16 13 12 байт

Спасибо @Thomas Kwa за напоминание о заглавной букве.

&qzr@GrzZ3tz

Тестовый пакет .

&              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
источник
21

Сетчатка, 13 байт

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

Попробуй это онлайн | Набор тестов (Вывод 0означает, что ни одна из строк не соответствует, что ожидается.)

Когда Retina предоставляется только с одной строкой кода, она выводит количество 1совпадений выражения с входной строкой, поэтому выводит (правда), если она совпадает, и, следовательно, является официальным именем и 0(ложно), если это не так.

Сломать

^       The beginning of the string
[A-Z]   One uppercase letter
[a-z]+  One or more lowercase letters
$       The end of the string
— NinjaBearMonkey
источник
8
Похоже, нам нужны классы символов для букв. ;)
— Мартин Эндер
10

TeaScript, 12 байт

xO`A-Z][a-z`

Злоупотребляет Oфункцией.

Попробуйте это онлайн

Тестирование

объяснение

OФункция делает это:

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

Затем функция O проверяет соответствие регулярного выражения x.

Альтернативно, не конкурирующий ответ TeaScript 3 в 7 байтах :

xO/\A\a
— Downgoat
источник
Ахахаха, милый. В какой-то момент, когда я работал над интерпретатором Japt, я использовал этот трюк с isCharдобавленной вами функцией. Но вы можете объяснить более подробно для тех, кто не в курсе.
— ETHproductions
Оооооо, мне нравятся новые возможности регулярных выражений!
— ETHproductions
7

JavaScript (ES6), 26

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

Автор: 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>
Развернуть фрагмент

— edc65
источник
Черт, ты побил меня к этому. Вы также превзошли мою версию на 5 байт.
— SuperJedi224
1
На один байт меньше:n=>n.match`^[A-Z][a-z]+$`
— user81655 24.12.15
@ user81655 массив как истинное значение слишком форсирован ИМХО
— edc65
@ edc65 Это правда, хотя.
— SuperJedi224
1
Только на 4 байта вы получаете соответствие ES5:/./.test.bind(/^[A-Z][a-z]+$/)
— CR Drost
7

Python, 59 58 байт

Я уверен, что нет никакого реального способа победить версию Retina, так как это в основном только в Python. Но я думаю, что это моя первая подача;)

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

Это очень странная истинная ценность:

(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

(И это действительно требует ""строк с пробелами, если они передаются через оболочку)

— Уэйн Вернер
источник
1
^не требуется, так как re.match()совпадает только в начале строки.
— manatwork
1
@ Manatwork хорошо! Еще один байт побрился :) Я мог сохранить еще один байт с закрывающим пареном, используя Python2
— Уэйн Вернер
1
@WayneWerner: вот почему вы должны дать версию Python :) Я думаю, что Python 2 и Python 3 - это разные языки, по крайней мере для codegolf.
— Моватика
Если вы используете анонимную лямбду вместо целой программы, вы получите 45 байтов:lambda s:re.match('[A-Z][a-z]+$',s) import re
— movatica
1
@ Movatica Ой, ой!
— MilkyWay90
4

Python, 50 45 43 41 байт

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

Возвращает, Trueесли это официальное имя или Falseнет.

— Zenadix
источник
Правила Codegolf гласят, что вам не нужно принимать f=во внимание, сохраняя два байта. Кроме того, (len(s)>1)экономит 5 байтов s[1:].islower(). :)
— моватика
3

BotEngine , 203 180 29x6 = 174

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

Я действительно должен добавить встроенные функции для определения прописных и строчных букв. Это было бы гораздо более кратким, чем проверка каждого письма в отдельности.

Грубый перевод:

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
источник
3

C 129 122 121 111 байт

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

Попробуйте онлайн

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);
}
— Джеймс
источник
2

MATL , 18 байт

Используется текущая версия ( 4.0.0 ) языка.

Это относится к тому же регулярному выражению, что и ответ NinjaBearMonkey :

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

Выводом является строка (которая является правдивой ), если это официальное имя, и ничего ( если это неверно ), если это не так.

Примеры

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

>> matl
 > j'^[A-Z][a-z]+$'XX
 > 
> ASCII
>>
— Луис Мендо
источник
2

Гема, 17 знаков

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

Образец прогона:

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
источник
2

Машинный код IA-32, 19 байтов

Функция, которая получает указатель на завершающуюся нулем строку в ecxи возвращает 0 или 1 вeax (в соответствии с fastcallсоглашением).

Hexdump кода:

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

На ассемблере:

    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;

Первый байт входного имени имеет свой 5-й бит, перевернутый ( xorс 32), чтобы преобразовать его из заглавных букв в малые. Это загружает 32 в eax, используя 3 байта кода:

    push 32;
    pop eax;

Чтобы проверить, является ли байт маленькой буквой:

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

Если нет, этот код проваливается. Чтобы вернуть 0 в этом случае, он помещает 0 alперед выполнением условного перехода:

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

0 alтакже служит xor-маской (или ее отсутствием) для следующих байтов входного имени.

Успешный выход - это когда встречается нулевой байт, который остается нулевым после xor:

    xor al, [ecx];
    jz yes;

Предполагается, что имя ввода не является пустым. Я предполагаю, что это разумное предположение об имени (не произвольная строка)!

— anatolyg
источник
2

grep16 байт

Это шаблон:

[A-Z][a-z]+

Если вы используете и -Eи -xи -cпереключателиgrep напечатает количество совпадающих строк ввода. Так что, если вы дадите ему одну строку, вы получите 1 или 0. Я думаю, именно так это место работает.

Шаблон - 11 символов, вся командная строка - 23. Я видел, как люди используют sedсценарии без команды, поэтому я не знаю, что к чему. Но он читает stdin, и вы можете просто набрать его. Вот echo:

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

1
0
0
— mikeserv
источник
@ Doorknob - кажется достаточно справедливым для меня. большое спасибо. о какой шляпе ты догадался?
— mikeserv
1
Я понял, Месть в Причал. : P
— Дверная ручка
Остановите меня, если (как это вполне вероятно), я ошибаюсь, но вы можете использовать, grep -Excчтобы вам не нужно было подсчитывать столько байтов для переключателей.
— Нил
@ Нил - я не знаю, если ты не прав. я действительно понятия не имею - взглянуть на историю редактирования.
— mikeserv
2

Mathematica 10,1, 46 байт

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

Использует на один байт меньше, чем стандартное решение регулярных выражений. Это делает три проверки. LetterQ@#гарантирует, что строка полностью состоит из букв, и StringLength@#>1делает недействительными однобуквенные строки. #==ToCamelCase@#имеет меньше смысла, однако. ToCamelCaseя обнаружил недокументированную функцию, которая принимает входную строку AndOutputsItLikeThis. Поскольку есть только одно слово, оно будет использовать заглавную первую букву, поэтому мы проверяем, равна ли строка этому.

— LegionMammal978
источник
Является ли ToCamelCaseновый 10.3? Кажется, не работает в 10.2.
— Мерфи
@murphy, у меня работает в 10.1. Что вы получаете с ToCamelCase["foo bar baz"]?
— LegionMammal978
Хорошо, я могу подтвердить, что это работает в 10.1. Однако в 8.0, 9.0, 10.0 и 10.2 функция не определена (ваш тестовый пример возвращается ToCamelCase[foo bar baz]). Странный! Может кто-нибудь может проверить 10.3?
— Мерфи
2

bash / zsh / ksh, 25 байтов

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

Чтобы фактически использовать это, создайте файл с единственной строкой и сделайте файл исполняемым; исполняемые файлы, не распознаваемые как известный двоичный тип, рассматриваются как сценарии оболочки (в /bin/shчастности).

$ 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
$
— Аарон Дэвис
источник
2
Это прекрасно работает в bash, kshи zsh, но не имеет шансов работать в стандартном POSIX shили совместимых dashи yash. Чтобы избежать путаницы, предлагаю изменить заголовок ответа.
— Манатворк
3
Используйте printfвместо того, echoчтобы создать файл, и вы получите 25 байтов.
— Сэм Хоцевар
Хорошие моменты, вы оба; оба применяются.
— Аарон Дэвис
2

C # 4, 89 байт

Моя первая попытка в Code Golf. Вот оно:

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

Посмотрите это в действии на Dot Net Fiddle .

— Фархан Анам
источник
Если вы используете C # 6, вы можете сделать его немного короче:bool o(string i)=>System.Text.RegularExpressions.Regex.IsMatch(i,"^[A-Z][a-z]+$");
— ProgramFOX
2

Java, 28 байт

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

Использует регулярное выражение, чтобы убедиться, что строка состоит из заглавных букв, за которыми следует хотя бы один строчный символ.

-1 байт благодаря Бенджамину Уркварту

— HyperNeutrino
источник
Вы можете оставить точку с запятой
— Бенджамин Уркхарт
@ BenjaminUrquhart, хорошо, спасибо
— HyperNeutrino
1

к4, 39 байт

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

Первый символ выше, все остальные ниже, считается больше единицы.

Например:

  {((*x)in .Q.A)&(&/(1_,/x)in .Q.a)&1<#x}'("Adnan";"adnan";"AdnaN";"Adnan123";"Adnan Adnan";"A";"Mary-Ann")
1000000b
— Аарон Дэвис
источник
1

Серьезно, 16 байт

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

Шестнадцатеричный дамп:

a3342c6e983d296c313c29972d592626

Попробуйте онлайн

Серьезно пока нет поддержки регулярных выражений, поэтому лучшее, что мы можем сделать, это:

 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
источник
1

Окамль, 231 216 197 166 байт

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

Пример использования:

# 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 (с реальными именами функций):

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;;
— Моше Кац
источник
На самом деле вы могли бы сэкономить около 10%, используя булевы значения вместо целых (блеф!) И заменяя их громоздкими if … then 0 else на … ||. И в этом отношении, используя логические операторы вместо matchи диапазонов, напримерn.[0]>'@'&n.[0]<'['&e(l-1)
— Жиль "ТАК - перестань быть злым"
1

SpecBAS - 39 байт

SpecBAS обрабатывает регулярные выражения с помощью MATCHкоманды. Выходное значение равно 0 для false и 1, если true.

1 input n$:  ?MATCH("^[A-Z][a-z]+$",n$)
— Брайан
источник
1

Swift 2, 116 байт

Regex настолько многословен в Swift, что выполнение этого намного короче

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}

Это вернет 0или -1(в случае отсутствия ввода) для неофициальных имен, и число > 0(которое равно длине строки - 1), если имя является официальным

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
источник
1

C #, 188 байт

Регулярные выражения были бы правильным способом решения этой проблемы, но вот попытка без этого.

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

обыкновенное письмо

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

Очень хотелось бы посоветовать, как сделать проверку строчных букв короче, возможно, без цикла. Я только начал изучать язык и использовал это как практику, решил, что все равно поделюсь своим результатом.

— Гусь
источник
1

PowerShell , 29 байт

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

Попробуйте онлайн!

Использует ли тот же трюк с регулярными выражениями все остальные? Должен использовать case-Sensible, matchчтобы правильно сделать это за счет байта.

— Veskah
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.