क्या यह एक वैध चर नाम है?

Question

लक्ष्य

एक प्रोग्राम या फ़ंक्शन लिखें जो यह जांचता है कि एक चर नाम वैध और आउटपुट 1 है या Trueयदि यह वैध है, 0.5 यदि यह वैध है, लेकिन एक अंडरस्कोर (_) के साथ शुरू होता है, और 0 या Falseयदि यह मान्य नहीं है।

नियम

• अधिकांश भाषाओं में एक चर नाम मान्य है यदि यह एक अंडरस्कोर या अक्षर (az, AZ, _) से शुरू होता है और बाकी अक्षर या तो अंडरस्कोर, अक्षर, या संख्याएं हैं। (एज़, एज़, 0-9, _)
• आउटपुट 1 या Trueयदि चर नाम मान्य है और 0 या Falseयदि वैध नहीं है।
• हालांकि, अंडरस्कोर के साथ एक वैरिएबल को शुरू करना अच्छा नहीं है, इसलिए 0.5 को वापस लें यदि यह अंडरस्कोर से शुरू होता है और नाम मान्य है।

परीक्षण के मामलों

इनपुट

abcdefghijklmnop

उत्पादन

1

इनपुट

_test_

उत्पादन

0.5 (एक अंडरस्कोर के साथ शुरू होता है)

इनपुट

123abc

उत्पादन

0 (एक नंबर से शुरू होता है)

इनपुट

A_b1C_23

उत्पादन

1

इनपुट

_!

उत्पादन

0 (0.5 नहीं क्योंकि यह मान्य नहीं है)

इनपुट

magical pony1

उत्पादन

0 (जगह नहीं)

मानक खामियां लागू होती हैं।

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है।

बोनस: -10% अगर आपका प्रोग्राम / फंक्शन 0किसी खाली स्ट्रिंग ( "") के लिए आउटपुट करता है ।

Comments

क्या हम सच्चाई / झूठ / कुछ भी आउटपुट कर सकते हैं?

— कैलक्यूलेटरफलाइन

केवल नोटिंग, अजगर में, स्कोर के तहत अक्सर उपयोग किया जाता है। कक्षाओं को एक init फ़ंक्शन की आवश्यकता होती है , कक्षाओं में सहायक कार्यों को कभी-कभी अंडरस्कोर के साथ शुरू किया जाता है।

— R

@EasterlyIrk मिनी-मार्कडाउन से सावधान रहें; तुम्हारा मतलब था __init__; इसके अलावा, नहीं, वर्गों को जरूरत नहीं है , __init__लेकिन आम तौर

— बिल्ली

क्या हम यह मान सकते हैं कि इनपुट गैर-रिक्त होगा? (अधिकांश वर्तमान उत्तर खाली इनपुट के लिए विफल लगते हैं।)

— डेनिस

क्या वह बोनस राउंड अप या डाउन है? यदि ऊपर है, तो यह वास्तव में उत्तरों के वर्तमान सेट के लिए लायक नहीं है

— ब्लू

Answer 1

जावास्क्रिप्ट (ईएस 6), 37 - 10% = 33.3 बाइट्स

सहेजे गए 4 बाइट @ edc65 की बदौलत

@Mateon की बदौलत 5.6 बाइट बचा

s=>!/^\d|\W|^$/.test(s)/-~(s[0]=='_')

Comments

क्या आप पूरी तरह से आश्वस्त हैं कि यह खतरनाक नहीं है?

— seequ

Answer 2

05AB1E , 25 24 20 19 बाइट्स

कोड:

¬D'_Qsa·+¹žj-""Q*2/

स्पष्टीकरण:

¬                     # Push input and also push the first character.
 D                    # Duplicate the first character.
  '_Q                 # Check if it is equal to an underscore character.
     sa               # Swap and check the duplicate if it's an alphabetic character.
       ·              # Double the value.
        +             # Add both values up
         ¹            # Take the first input.
          žj-         # žj is short for [a-zA-Z0-9_]. This will be substracted from the
                        initial string. 
             ""Q      # Check if the string is empty.
                *     # Multiply this with the first value.
                 2/   # Halve it, resulting into 0.0, 0.5, or 1.0.

संक्षेप में, spseudocode में स्ट्रिंग के लिए सूत्र है:

((s[0] == '_' + s.isalpha() × 2) × (s.remove([a-zA-Z0-9_]) == "")) / 2

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

CP-1252 एन्कोडिंग का उपयोग करता है ।

Answer 3

PHP (50 - 10% = 45)

शुक्रिया के लिए धन्यवाद -2 :)

preg_match('/^[a-z_]\w*$/i',$s)?$s[0]=='_'?.5:1:0;

गोल्फलैंग के उत्तरों के साथ प्रतिस्पर्धा करने के लिए नहीं, लेकिन मैंने सोचा कि मैं इसे वैसे भी आजमाऊंगा।

preg_match('/^[a-z_]\w*$/i', $s) # Matches every a-zA-Z0-9_ string that doesnt start with a number
?   $s[0] == '_'                   # Then, if it starts with an _
    ?   .5                         # give 0.5 points
    :   1                          # If it doesn't, give 1
:   0;                             # If it didn't match the regex, give 0

ध्यान देने योग्य बात यह है कि PHP में, /uसंशोधक के बिना , \wकेवल ASCII अक्षरों का चयन करता है। कुछ अन्य भाषाओं / Regex जायके में, यह पैटर्न काम नहीं करेगा।

संपादित करें : मैं बहुत से लोगों को अपने उत्तर में \ w और \ d का उपयोग करते हुए देखता हूं, जब वे एक ऐसी भाषा का उपयोग करते हैं जिसमें गैर-एएससीआईआई अक्षर और अंक भी शामिल होते हैं। यह पहेली नहीं है। वे गलत हैं। (अभी तक / टिप्पणी नहीं कर सकता, खेद है कि इसे इस तरह से बताने की आवश्यकता है।)

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ स्टैक एक्सचेंज में आपका स्वागत है। यह एक महान जवाब है; अक्सर कोड-गोल्फ चुनौतियां भाषाओं के साथ-साथ उनके बीच भी होती हैं। मैं आपको इस समाधान के लिए +1 दे रहा हूं! बहुत बढ़िया।

— wizzwizz4

आप दो पात्रों के साथ दाढ़ी बना सकते हैं [a-z].../i।

— श्स्म

@ शचीवाद धन्यवाद। पता नहीं कैसे मैं यह भूल गया कि आमतौर पर, मैं इस तरह की

— रेगीज़

अपने संपादन के बारे में: क्या आप अधिक विशिष्ट हो सकते हैं - कौन सी भाषाएं? जावास्क्रिप्ट \dमें बिल्कुल वैसा ही है [0-9]। डेवलपर\w के समान ही है ।.mozilla.org[A-Za-z0-9_]

— en

भाषा का उपयोग करने वाला कोड पृष्ठ अप्रासंगिक है; जब तक रेगेक्स ठीक से ASCII को संभालता है, यह मान्य है। मेरे ज्ञान के लिए वर्तमान रेगेक्स-आधारित उत्तर सभी काम करते हैं। आप अपनी भाषा में एक चर नाम से मेल खाने की कोशिश नहीं कर रहे हैं; बल्कि, आप चुनौती में नियमों के आधार पर एक चर नाम से मिलान करने का प्रयास कर रहे हैं।

— मेगो

Answer 4

रेटिना, 30 - 10% = 27 28 - 10% = 25.2 29 - 10% = 26.1 बाइट्स

दोनों संस्करण बोनस के लिए योग्य हैं, क्योंकि वे खाली इनपुट को सही ढंग से संभालते हैं (आउटपुट 0)

मुझे .NET रेगेक्स विशेषताओं में से एक के कारण बग को ठीक करना था, जो कि कुछ (कई को पढ़ता है) यूनिकोड वर्णों को "शब्द" अक्षर के रूप में मानता है। सौभाग्य से, इसने मुझे दोनों संस्करणों में केवल एक ही बाइट का खर्च दिया। यह केवल ECMAScript मानकों के अनुरूप व्यवहार व्यवहार के अनुरूप बनाने के लिए एक संशोधक को जोड़ने के लिए नीचे आया था। इसके बारे में यहाँ और अधिक ।

@ मार्टिनबटनर द्वारा बनाया गया नया 28 29-बाइट संस्करण। धन्यवाद!

^ _
$ _¶_
Mme` ^ (?! \ घ) \ w + $
2
0.5

व्याख्या

पहले, हम जांचते हैं कि इनपुट अंडरस्कोर से शुरू होता है या नहीं। यदि ऐसा होता है, तो इनपुट को डुप्लिकेट किया जाता है, बीच में एक नई रेखा के साथ। उदाहरण के लिए: _test_-> _test_\n_test_, \nनईलाइन कहां है फिर हम कुछ भी, कि एक संख्या के साथ शुरू नहीं करता है जैसा बनाने का प्रयास है, लेकिन "शब्द" वर्ण (के किसी भी संख्या के बाद आता है a-z, A-Z, अंक, और अंडरस्कोर) प्रत्येक पंक्ति पर । ध्यान दें कि यदि इनपुट अंडरस्कोर के साथ शुरू हुआ था और इसे दो लाइनों में बदल दिया गया था, तो यह दोनों लाइनों से मेल खाएगा। फिर हम जांचते हैं कि हमारे पास 2 मैच थे, और उनकी जगह ले लें 0.5। खाली या अमान्य रेखा हमेशा 0 मैचों का उत्पादन करेगी, और मान्य चर नाम हमेशा 1 मैच प्राप्त करते हैं।

---

मेरा अपना 30 31-बाइट संस्करण है

Ae` ^ \ घ | \ डब्ल्यू
^ _। *
0.5
^ \ डी *
1
^ $
0

व्याख्या

सबसे पहले, हम जाँच करता है, तो या अंक के साथ शुरू होता है इनपुट एक गैर शब्द चरित्र (अलावा अन्य कुछ भी होता है a-z, A-Z, अंक और अंडरस्कोर)। यदि ऐसा होता है, तो इसे खारिज कर दिया जाता है, क्योंकि यह अमान्य है। फिर हम जाँचते हैं कि क्या यह एक अंडरस्कोर से शुरू होता है। यदि ऐसा होता है, तो इसे बदल दिया जाता है 0.5। फिर हम जाँच करता है, तो यह एक गैर अंकों चरित्र के साथ शुरू होता है (इस बिंदु पहला वर्ण या तो है पर 0, a-zया A-Z। केवल a-zऔर A-Z, गैर अंक हैं जाहिर है)। यदि ऐसा होता है, यह एक के साथ बदल दिया है 1। फिर हम खाली स्ट्रिंग की जांच करते हैं और इसे बदलते हैं 0।

इसे ऑनलाइन आज़माएं!
इसे ऑनलाइन आज़माएं! पुराना संस्करण

Comments

रुको रुको रुको। पर ^\D.*मंच यह एक 0 के साथ शुरू कर सकते हैं? वह अजीब है।

— कैलकुलेटरफ्लीन

@CatsAreFluffy यह, अगर यह एक के साथ शुरू किया _गया था और के साथ प्रतिस्थापित किया जा सकता है 0.5। फिर यह

— डेवको

यह गलत तरीके से इनपुट के लिए 1 देता है Ψ।

— AdmBorkBork

@TimmyD दिलचस्प। मुझे समझ नहीं आता कि ऐसा क्यों होता है। त्वरित जांच इंगित करती है कि \wगैर-एएससीआईआई पात्रों से मेल खा रही है, जो यह नहीं करना चाहिए (मैंने इसे ƜƝƞƟƠऔर ᎳᎴᎵᎶᎷᎸᎹइनपुट के रूप में देने की कोशिश की है )। मैं बाद में इस पर गौर करूंगा। संभव समाधान के \wसाथ बदल रहा है [a-zA-Z\d_]।

— डेवको

Answer 5

MATL , 27 बाइट्स

1)95=2/8M3Y2m+G7M95h4Y2hmA*

यह भाषा के वर्तमान संस्करण (15.0.0) में काम करता है ।

इनपुट एकल उद्धरण के साथ एक स्ट्रिंग है।

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

व्याख्या

1)      % take input implicitly. Get its first element
95=     % true if it equals 95 (underscore)
2/      % divide by 2: gives 0.5 if underscore, 0 if not
8M      % push first element of input again
3Y2     % predefined literal: string with all letters
m       % true if it's a letter
+       % add. Gives 1 if letter, 0.5 if underscore
G       % push input again
7M      % push string with all letters again
95h     % concatenate underscore
4Y2h    % predefined literal: string with all digits. Concatenate
mA      % true if all input chars belong to that concatenated string
*       % multiply. Display implicitly

Answer 6

पाइके , 21 बाइट्स

(noncompeting, जोड़ा स्ट्रिंग घटाव, विभिन्न स्ट्रिंग स्थिरांक)

Qh~u{Q~J\_+-|!Qh\_qh/

स्पष्टीकरण:

Qh~u{                 - Check first char isn't a digit
     Q~J\_+-          - Is the input alphanumeric + "_"
            |!        - Combine
              Qh\_q   - Is the first char an "_"
                   h/ - Combine

Answer 7

पायथन 3, 36 बाइट्स

lambda s:s.isidentifier()/-~(s[:1]=='_')

कोड 40 बाइट लंबा है और -10% बोनस के लिए योग्य है ।

ध्यान दें कि यह केवल उन कोड पृष्ठों के लिए सही ढंग से काम करेगा जिनके पास गैर- ASCII अक्षर / अंक नहीं हैं।

Answer 8

पायथ, 27 बाइट्स

c!|-rz0++G\_JjkUT}hzJhqhz\_

परीक्षण सूट

Answer 9

गोग , 29 बाइट्स

÷"[^\W\d]\w*"g¦"_.*"g+÷2=0.5¿

रन का उपयोग करें:

$ ./gogh no '÷"[^\W\d]\w*"g¦"_.*"g+÷2=0.5¿' "_test"

---

व्याख्या

                   “ Implicit input                               ”
÷                  “ Duplicate the TOS                            ”
"[^\W\d]\w*"g      “ Fully match the STOS against the TOS (regex) ”
¦                  “ Swap the STOS and TOS                        ”
"_.*"g             “ Fully match the STOS against the TOS (regex) ”
+                  “ Add the TOS to the STOS                      ”
÷                  “ Duplicate the TOS                            ”
2=                 “ Determine if the TOS is equal to 2           ”
0.5¿               “ Leave the correct output on the stack        ”
                   “ Implicit output                              ”

Answer 10

पर्ल, 21 बाइट्स

$_=!/\W|^\d//2**/^_/

स्विच के लिए स्कोर में +1 बाइट शामिल है -p। Ideone पर इसे आज़माएं ।

Comments

क्या आपके पास, -$_||$_=...खाली उत्तर के लिए जवाब देने के लिए कहा जा सकता है ? ( -क्योंकि +पर्ल में एक noop है) का उपयोग करना

— वेन

नहीं, यह एक रनटाइम त्रुटि है। लेकिन अगर यह काम करता है, तो भी इससे मेरा स्कोर खराब होगा।

— डेनिस

मैंने केवल न्यूनतर परीक्षण किए, इसलिए मैं आप पर विश्वास करूंगा। 21 बाइट्स का 10% ज्यादा नहीं है ..

— वेन

Answer 11

पायथ, 19 बाइट्स

c!:z"\W|^\d"0h!xz\_

इसे Pyth Compiler के साथ आज़माएँ ।

ध्यान दें कि यह केवल उन कोड पृष्ठों के लिए सही ढंग से काम करेगा जिनके पास गैर- ASCII अक्षर / अंक नहीं हैं।

यह काम किस प्रकार करता है

c!:z"\W|^\d"0h!xz\_  (implicit) Save the input in z.

  :z        0        Test if z matches the following regex:
    "\W|^\d"           A non-word character or a digit at the beginning.
                     This returns True iff z is an invalid name.
 !                   Apply logical NOT to yield True iff z is a valid name.
               xz\_  Find the first index of the underscore in z.
                     This yields 0 iff z begins with an underscore.
             h!      Apply logical NOT and increment.
                     This yields 2 if z begins with an underscore, 1 otherwise.
c                    Divide the two results.

Answer 12

कारक , 84 * 0.9 = 76.5

USE: regexp
[ R/ [_a-zA-Z]\w*/ R/ _.*/ [ matches? 1 0 ? ] bi-curry@ bi 0 = 1 2 ? / ]

श्रोता (उत्तर) पर चलता है, एक उद्धरण (अनाम फ़ंक्शन) को परिभाषित करता है जो एक स्ट्रिंग लेता है और आउटपुट {0 | 1/2 | 1} है।

इसे एक शब्द के रूप में परिभाषित करना यह 97 वर्ण है:

USE: regexp
: v ( s -- n ) R/ [_a-zA-Z]\w*/ R/ _.*/ [ matches? 1 0 ? ] bi-curry@ bi 0 = 1 2 ? / ;

यह कैसे काम करता है:

R/ [_a-zA-Z]\w*/ R/ _.*/दो नियमित अभिव्यक्तियों को परिभाषित करता है। bi-curry@आंशिक रूप [ matches? 1 0 ? ]से प्रत्येक रेगेक्स पर कोटेशन को लागू करता है , जिससे स्टैक पर दो करीकृत कोटेशन निकल जाते हैं। biप्रत्येक स्ट्रिंग को तर्क स्ट्रिंग पर लागू करता है।

उनमें से प्रत्येक (क्युरेटेड कोट्स) 1 या 0 छोड़ते हैं, यदि वे मेल खाते हैं। अच्छी तरह से गठित नामों पर पहला मैच, दूसरा अंडरस्कोर से शुरू होने वाले नामों पर।

0 = 1 2 ? / अंतिम मान को 1 के साथ बदल दिया जाता है यदि यह 0 था, या 2 के साथ यदि यह 1 था। तो पहले (1 या 0, वैध या नहीं) को दूसरे (2 या 1) से विभाजित किया जाता है, अंडरस्कोर या नहीं से शुरू होता है) ।

यह loooong है! किसी भी संकेत को थोड़ा और कम करने की सराहना की ...

और मुझे regexps से नफरत है!

पुनश्च।

{ 0 } [ "" v ] unit-test
{ 0 } [ "" v ] unit-test
{ 0 } [ "1" v ] unit-test
{ 0 } [ "1var" v ] unit-test
{ 0 } [ "var$" v ] unit-test
{ 0 } [ "foo var" v ] unit-test
{ 1 } [ "v" v ] unit-test
{ 1 } [ "var" v ] unit-test
{ 1 } [ "var_i_able" v ] unit-test
{ 1 } [ "v4r14bl3" v ] unit-test
{ 1/2 } [ "_" v ] unit-test
{ 1/2 } [ "_v" v ] unit-test
{ 1/2 } [ "_var" v ] unit-test
{ 1/2 } [ "_var_i_able" v ] unit-test
{ 1/2 } [ "_v4r14bl3" v ] unit-test

सभी परीक्षा पास;)

Comments

बस सोच रहा था, क्या व्हाट्सएप वास्तव में आवश्यक है? जब से मैं भाषा नहीं जानता या दुभाषिया नहीं है मैं निश्चित रूप से नहीं कह सकता।

— मामा फन रोल

@MamaFunRoll हाँ, सर्वश्रेष्ठ गोल्फिंग भाषा नहीं! फोर्थ परंपरा में, केवल सीमांकक व्हॉट्सएप चार्ट हैं।

— फेड एस।

ओह मैं समझा। यहाँ, एक उत्थान है।

— मामा फन रोल

याय, ती! अब मेरी टिप्पणी के साथ तबाही मचाने के लिए-हर जगह निजी!

— फेड एस।

Answer 13

डायलॉग एपीएल , 19 बाइट्स - 10% = 17.1

{(0≤⎕NC⍵)÷1+'_'=⊃⍵}

{... ⍵... }अनाम फ़ंक्शन जहां सही तर्क का प्रतिनिधित्व करती है ⍵
⊃⍵पहले वर्ण (अंतरिक्ष खाली अगर देता है)
'_'=1 अगर 'underbar के बराबर है, अन्यथा 0
1+2 का मूल्यांकन करता है, तो प्रारंभिक underbar, 1 अन्यथा
⎕NC⍵ वर्ग के नाम ; -1 यदि अमान्य नाम, 0 यदि अपरिभाषित (लेकिन मान्य नाम), 2-9 यदि परिभाषित है (और इस प्रकार वैध है)

Answer 14

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

If[#~StringMatchQ~RegularExpression@"[A-Za-z_][0-9A-Za-z_]*",If[#~StringTake~1=="_",.5,1],0]&

मुझे पूरी तरह से यकीन नहीं है कि इसे आगे बढ़ाया जा सकता है।

Answer 15

पर्ल, 34 + 1 = 35 बाइट्स

$_=/^([^\W\d])\w*$//(($1 eq"_")+1)

-pझंडे का उपयोग करता है ।

व्याख्या

$_=/^([^\W\d])\w*$//(($1 eq"_")+1)
   /^([^\W\d])\w*$/                 matches any string that starts with an underscore or a letter of the alphabet followed by 0 or more alphanumeric + underscore characters. The first character is stored in a capture group
                   /                divide result by
                    (($1 eq"_")+1)  (capture == "_") + 1. This is 1 if the first character was not an underscore and 2 if it was.
$_=                                 assign to $_ and implicitly print

Comments

[_a-zA-Z]-> [^\W\d]अगर पर्ल जावास्क्रिप्ट के समान काम करता है, तो मुझे लगता है कि आपको भी करना होगा\w*

— डाउनगेट

@Downgoat के साथ ठीक काम करने लगता है \w+।

— एक स्पेगेटो

के लिए झूठे मैचa

— 1926 में डाउनगेट

@Downgoat आह, ठीक है। समझा।

— एक स्पेगेटो

Answer 16

पायथन, 84 -10% = 76 बाइट्स

lambda x:[0,[[.5,1][x[0]>'z'],0][x[0]<'A']][x.replace('_','a').isalnum()]if x else 0

Answer 17

जावास्क्रिप्ट ईएस 7, 37 बाइट्स

x=>!x.match(/\W|^\d/)/2**/^_/.test(x)

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

यह काम किस प्रकार करता है:

x=>                                   // Fat arrow function
   !x.match(/\W|^\d/)                 // Gives false if contains non word or starting 
                                      //   with a digit. Booleans in numeric context will 
                                      //   be 0 or 1
                      2**             // 2 to the power of...
                         /^_/.test(x) // gives true if starting with '_'. 
                                      //   true -> 1 -> 2**1 -> 2
                                      //   false -> 0 -> 2**0 -> 1
                     /                // Devide the lValue boolean with the numeric rValue:
                                      // lValue = 0 or 1
                                      // rValue = 2 or 1

पोर्ट ऑफ @ डेनिस पर्ल का जवाब

Answer 18

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

->(s){s=~/^(_|\d)?\w*$/?$1?$1==?_?0.5:0:1:0}

Comments

आपको स्टैम्बी लैम्ब्डा के मापदंडों की आवश्यकता

— नहीं है

इसके अलावा अगर आप उस अतिरिक्त टर्नरी को छोड़ने का तरीका जान सकते हैं तो आप शायद कुछ बाइट्स बचा सकते हैं। शायद /^([a-z_]).../iइसके बजाय/^(_|\d)?.../

— नहीं कि चार्ल्स

@NotthatCharles D'oh ... आप सही कह रहे हैं। जब मैं मौका

— पाऊंगा

Answer 19

रूबी, 57 - 10% = 51.3 बाइट्स

->(s){case s
when'',/^\d/,/\W/
0
when/^_/
0.5
else
1
end}

एक सुंदर भोला दृष्टिकोण

Comments

51.3 बाइट्स, माइंड यू। :)

— Xesau

@Xesau वूप्स - शर्मनाक। अब निश्चित है :)

— फ्लैम्बिनो

यदि आप टर्नरी चेनिंग का उपयोग करते हैं तो आप बाइट की एक बड़ी राशि बचाते हैं:->(s){s=~/^$|^\d|\W/?0:s=~/^_/?0.5:1}

— वैल्यू इंक

@ केविनलाऊ ट्रू - मैंने उस नस में पहले से ही एक और रूबी जवाब जोड़ दिया (हालाँकि यह या तो महान नहीं है)

— फ्लैबिनो

Answer 20

लुआ, 82 - 10% = 73.8

v=function(s)return(s:match("^[_%a]+[_%w]*$")and 1or 0)*(s:match("_")and.5or 1)end

परीक्षण के मामलों:

print(v("a") == 1) -- true
print(v("1") == 0) -- true
print(v("_") == 0.5) -- true
print(v("") == 0) -- true
print(v("1a") == 0) -- true
print(v("a1") == 1) -- true
print(v("_1") == 0.5) -- true
print(v("_a") == 0.5) -- true
print(v("1_") == 0) -- true
print(v("a_") == 0.5) -- true

Comments

मुझे लगता है कि आप कम से कम 10 बाइट खाने के लिए STDIN का उपयोग कर सकते हैं।

— लीक नून

Answer 21

लुआ, 68 * .9 = 61.2 बाइट्स

s=arg[1]print(s:find("^[%a_][%w_]*$")and(s:find("^_")and.5or 1)or 0)

कमांड लाइन पर तर्क देता है