क्या मेरा नाम आधिकारिक है?

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

लीडरबोर्ड

कोड स्निपेट दिखाएं

code-golf  string 
— अदनान
स्रोत
5
तो मेरा नाम आधिकारिक नहीं है? मैं इसे तब बेहतर करूँगा।
— ETHproductions
12
@ETHproductions यदि हम इस तर्क का उपयोग कर रहे हैं, Lolololololololololololतो एक आधिकारिक नाम है :)
— Adnan
1
यह वास्तव में सवाल का जवाब नहीं है। जो यह है: "आप मान सकते हैं कि नाम में उच्चारण अक्षर नहीं हैं", या "उच्चारण पत्रों के साथ नाम उपज चाहिए False"?
— लिन
1
एक छोटे से ऑफबीट कनाडाई विषयांतर के रूप में, मुझे पता है कि एक प्रोफेसर आपके "आधिकारिक" मानदंडों से खुश नहीं होगा: रॉबर्ट स्मिथ? । उनके नाम में वास्तव में वह प्रश्न चिन्ह है । इसके अलावा, Sahaiʔa ।
— इविलनोटिक्सिस्ट इडोनोटेक्सिस्ट
1
@ फरहानअम हां
— अदनान

जवाबों:

6

पायथ, 16 13 12 बाइट्स

टाइटलकेस के बारे में याद दिलाने के लिए @ थोमस क्वा को धन्यवाद।

&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मतलब है कोई भी तार मेल नहीं खाता, जो अपेक्षित है।)

जब रेटिना केवल कोड की एक पंक्ति के साथ प्रदान किया जाता है, तो यह इनपुट स्ट्रिंग से मेल खाने वाले अभिव्यक्ति की संख्या को आउटपुट करता है, इसलिए यह आउटपुट 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

टीस्क्रिप्ट, 12 बाइट्स

xO`A-Z][a-z`

Oफ़ंक्शन का दुरुपयोग करता है।

यह ऑनलाइन प्रयास करें

परीक्षण सूट

व्याख्या

Oसमारोह इस बनाता है:

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

फिर, ओ फ़ंक्शन चेक करता है कि रेगेक्स मैच करता है या नहीं x।

वैकल्पिक रूप से, 7 बाइट्स पर एक गैर-प्रतिस्पर्धी चायस्क्रिप्ट 3 उत्तर :

xO/\A\a
— Downgoat
स्रोत
आहाहा, अच्छा लगा। जब मैं जाप दुभाषिया पर काम कर रहा था, उस समय मैंने isCharआपके द्वारा जोड़े गए फ़ंक्शन के साथ इस ट्रिक का उपयोग किया था। लेकिन आप उन लोगों के लिए और अधिक विस्तार से बताना चाह सकते हैं जो नहीं जानते हैं।
— ETHproductions
Ooooooh, मुझे नए रेगेक्स फीचर्स पसंद हैं!
— ETHproductions
7

जावास्क्रिप्ट (ईएस 6), 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 बाइट्स से बढ़ा दिया है।
— सुपरजेडि २२२४
1
एक बाइट कम:n=>n.match`^[A-Z][a-z]+$`
— user81655
@ user81655 एक सत्य मान के रूप में एक सरणी बहुत मजबूर IMHO है
— edc65
@ edc65 हालांकि यह मान्य है।
— SuperJedi224
1
केवल 4 बाइट्स के लिए आपको ES5 अनुपालन मिलता है:/./.test.bind(/^[A-Z][a-z]+$/)
— CR Drost
7

पायथन, 59 58 बाइट्स

मुझे यकीन है कि रेटिना संस्करण को हरा देने का कोई वास्तविक तरीका नहीं है, क्योंकि यह मूल रूप से पायथन के भीतर है। लेकिन मुझे लगता है कि यह मेरा पहला सबमिशन है;)

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()केवल स्ट्रिंग की शुरुआत में मैच के रूप में की जरूरत नहीं है ।
— मैनटवर्क
1
@manatwork अच्छा! एक और बाइट मुंडा :) मैं पाइथन 2
— वेन वर्नर
1
@WayneWerner: यही कारण है कि आपको पायथन संस्करण देना चाहिए :) मुझे लगता है कि पायथन 2 और पायथन 3 अलग-अलग भाषाओं में हैं, कम से कम कोडगुल्फ़ के लिए।
— movatica
यदि आप एक पूरे कार्यक्रम के बजाय एक अनाम lambda s:re.match('[A-Z][a-z]+$',s) import re
— लंबोदा का
1
@movatica ओह, व्हाट्स!
— मिल्कीवेयज
4

पायथन, 50 45 43 41 बाइट्स

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

रिटर्न Trueअगर यह एक आधिकारिक नाम है या Falseयदि यह नहीं है।

— Zenadix
स्रोत
कोडगॉल्फ राज्य के नियम, कि आपको f=दो बाइट की बचत करते हुए, खाते में लेने की आवश्यकता नहीं है । इसके अलावा, (len(s)>1)5 बाइट्स बचाता है s[1:].islower()। :)
— movatica
3

बॉटजाइन , 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

सी, 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

हास्केल, 61 बाइट्स

f(h:t@(_:_))=elem h['A'..'Z']&&all(`elem`['a'..'z'])t
f _=1<0
— लिन
स्रोत
— dfeuer
कई और नीचे । आप अन्य परीक्षण के लिए अधिक कुशल होने के लिए भी उस तकनीक का उपयोग कर सकते हैं, लेकिन यह बाइट्स की समान संख्या है।
— dfeuer
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
— आदमी काम पर है
स्रोत
2

रूबी, 28 बाइट्स

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

-2 बाइट्स (मैनटवर्क के लिए धन्यवाद)

— कोको का बीज
स्रोत
— मैनेटवर्क
सरल और छोटा: p !!gets[/^[A-Z][a-z]+$/]
— daniero
2

IA-32 मशीन कोड, 19 बाइट्स

एक फ़ंक्शन जो पॉइंटर को एक अशक्त-समाप्ति स्ट्रिंग में प्राप्त करता है ecxऔर eax(के अनुसार) में 0 या 1 देता है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) होता है, इसे कैपिटल केस से छोटे केस में बदलने के लिए। eaxकोड के 3 बाइट्स का उपयोग करके यह 32 में लोड होता है :

    push 32;
    pop eax;

यह जांचने के लिए कि क्या बाइट एक छोटा अक्षर है:

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

यदि नहीं, तो यह कोड आता है। इस स्थिति में 0 वापस करने के लिए, alसशर्त छलांग लगाने से पहले यह 0 डालता है :

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

0 में alइनपुट नाम के निम्नलिखित बाइट्स के लिए भी एक एक्सोर-मास्क (या इसका अभाव) के रूप कार्य करता है।

एक सफल निकास तब होता है जब उसका सामना एक शून्य बाइट से होता है, जो xorनिम्न के बाद शून्य रहता है :

    xor al, [ecx];
    jz yes;

यह मानता है कि इनपुट नाम खाली नहीं है। मुझे लगता है कि यह एक नाम (एक मनमाना स्ट्रिंग नहीं) के बारे में एक उचित धारणा है!

— anatolyg
स्रोत
2

grep, 16 बाइट्स

यह पैटर्न है:

[A-Z][a-z]+

आप का उपयोग करते हैं -Eऔर -xऔर -cस्विचgrep मिलान इनपुट लाइनों की गिनती प्रिंट होगा। इसलिए यदि आप इसे एक पंक्ति देते हैं तो आपको 1 या 0. मिलता है। मुझे लगता है कि यह जगह कैसे काम करती है।

पैटर्न 11 वर्ण है, पूरी कमांड लाइन 23 है। मैंने देखा है कि लोग sedबिना कमांड के स्क्रिप्ट का उपयोग करते हैं इसलिए मुझे नहीं पता कि क्या है। लेकिन, यह स्टड पढ़ता है, और इसलिए आप इसे टाइप कर सकते हैं। यहाँ है echo:

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

1
0
0
— mikeserv
स्रोत
@ डॉर्कनोब - मुझे काफी उचित लगता है। बहुत बहुत धन्यवाद। आपने किस टोपी का अनुमान लगाया?
— 15
1
मैंने हेयरबोट का बदला लिया। : पी
— दरवाज़े
मुझे रोकें यदि (जैसा कि काफी संभावित है) मैं गलत हूं, लेकिन आप उपयोग कर सकते हैं grep -Excइसलिए आपको स्विच के लिए कई बाइट्स गिनने की आवश्यकता नहीं है।
— नील
@Neil - यदि आप गलत हैं तो मुझे पता नहीं है। मुझे वास्तव में कोई पता नहीं है - संपादन इतिहास पर एक नज़र है।
— 20
2

गणितज्ञ 10.1, 46 बाइट्स

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

मानक रेगेक्स समाधान की तुलना में एक कम बाइट का उपयोग करता है। यह तीन जाँच करता है। LetterQ@#यह सुनिश्चित करता है कि स्ट्रिंग पूरी तरह से अक्षरों से बना है, और StringLength@#>1एकल-अक्षर स्ट्रिंग को अमान्य करता है। #==ToCamelCase@#हालांकि कम समझ में आता है। ToCamelCaseएक अविभाजित फ़ंक्शन है जो मैंने पाया कि एक इनपुट स्ट्रिंग AndOutputsItLikeThis लेता है। चूंकि केवल एक शब्द है, यह पहले अक्षर को बड़ा करेगा, इसलिए हम जांचते हैं कि क्या स्ट्रिंग उसी के बराबर है।

— LegionMammal978
स्रोत
है ToCamelCase10.3 में नया क्या है? 10.2 में काम नहीं करता है।
— मर्फी
@ मर्फी, यह मेरे लिए 10.1 में काम करता है। आपको क्या मिलता है ToCamelCase["foo bar baz"]?
— लेजियम मैमल 978
ठीक है, मैं पुष्टि कर सकता हूं कि यह 10.1 में काम करता है। हालाँकि, 8.0, 9.0, 10.0 और 10.2 फ़ंक्शन को परिभाषित नहीं किया गया है (आपका परीक्षण केस रिटर्न ToCamelCase[foo bar baz])। अजीब! शायद कोई 10.3 की जांच कर सकता है?
— मर्फी
2

बैश / 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

सी # 4, 89 बाइट्स

कोड गोल्फ में मेरा पहला प्रयास। यह आता है:

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

डॉट नेट फिडल में इसे एक्शन में देखें ।

— फरहान अनम
स्रोत
यदि आप C # 6 का उपयोग करते हैं, तो आप इसे थोड़ा छोटा कर सकते हैं:bool o(string i)=>System.Text.RegularExpressions.Regex.IsMatch(i,"^[A-Z][a-z]+$");
— ProgramFOX
2

जावा, 28 बाइट्स

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

यह सुनिश्चित करने के लिए regex का उपयोग करता है कि स्ट्रिंग में एक अपरकेस वर्ण होता है, जिसके बाद कम से कम एक लोअरकेस वर्ण होता है।

-1 बेंजामिन अर्कहार्ट के लिए धन्यवाद

— HyperNeutrino
स्रोत
आप अर्धविराम
— बेंजामिन यूरक्हार्ट
@BenjaminUrquhart ओह ठीक है, धन्यवाद
— हाइपरएनुट्रिनो
1

k4, 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

यह ऑनलाइन की कोशिश करो

गंभीरता से अभी तक regex समर्थन नहीं है, इसलिए हम जो सबसे अच्छा कर सकते हैं वह है:

 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

Ocaml, 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;;
— मोशे काट्ज़
स्रोत
आप वास्तव में पूर्णांक (bleh!) के बजाए बूलियन्स का उपयोग करके लगभग 10% बचा सकते हैं और उन भारी if … then 0 else को बदल सकते हैं … ||। और matchसीमा के बजाय बूलियन ऑपरेटरों का उपयोग करके उस मामले के लिए , उदाहरण के लिएn.[0]>'@'&n.[0]<'['&e(l-1)
— गिल्स 'एसओ- बुराई को रोकें'
1

SpecBAS - 39 बाइट्स

SpecBAS MATCHकमांड के माध्यम से नियमित अभिव्यक्ति को संभालता है । आउटपुट झूठे के लिए 0 और अगर सच है तो 1 है।

1 input n$:  ?MATCH("^[A-Z][a-z]+$",n$)
— ब्रायन
स्रोत
1

स्विफ्ट 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

सी #, 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

पॉवरशेल , 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

क्या वही रेगेक्स ट्रिक हर कोई इस्तेमाल कर रहा है। बाइट की कीमत पर इसे ठीक से करने के लिए cअस-संवेदी का उपयोग matchकरना पड़ता है।

— Veskah
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.