目的

编写程序或函数，以检查变量名是否有效并输出1或True有效，如果变量有效但以下划线（_）开头则为0.5，然后为0或False无效。

规则

• 如果变量名以下划线或字母（az，AZ，_）开头，并且其余字符为下划线，字母或数字，则在大多数语言中均有效。（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 （没有空间）

有标准漏洞。

这是代码高尔夫球，因此最短的代码获胜。

奖励：如果您的程序/函数输出0一个空字符串（""），则为-10％。

JavaScript（ES6），37-10％= 33.3字节

@ edc65节省了4个字节

@Mateon节省了5.6个字节

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

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.

简而言之，s伪代码中的字符串的公式为：

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

在线尝试！

使用CP-1252编码。

PHP（50-10％= 45）

感谢Schism的-2 :)

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

不想与golflang的答案竞争，但我想还是应该尝试一下。

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字母。在某些其他语言/正则表达式中，此模式不起作用。

编辑：当他们使用的语言也包含非ASCII字母和数字时，我看到很多人在答案中使用\ w和\ d。那不是难题。他们错了。（尚不能投票/评论，很抱歉需要这样告知。）

视网膜，30-10 ％= 27 28-10％= 25.2 29-10％= 26.1字节

两种版本都有资格获得奖金，因为它们可以正确处理空输入（输出0）

我必须修复由.NET regex功能之一引起的错误，该功能将某些（读取的）Unicode字符视为“单词”字符。幸运的是，这两个版本只花了我一个字节。只能归结为添加修饰符以使正则表达式匹配行为符合ECMAScript标准。更多关于这里。

@MartinBüttner制作的新的28个 29字节版本。谢谢！

^ _
$_¶_
Mme` ^（？！\ d）\ w + $
2
0.5

说明

首先，我们检查输入是否以下划线开头。如果是这样，则输入是重复的，中间有换行符。例如：_test_-> _test_\n_test_，\n换行符在哪里。然后，我们尝试匹配任何东西，不以数字开头，但随之而来的任意数量的“字”字符（a-z，A-Z，数字和下划线）每行。请注意，如果输入以下划线开头并被替换为两行，则这将匹配两行。然后，我们检查是否有2个匹配项，并将其替换为0.5。空行或无效行将始终产生0个匹配项，而有效变量名总是产生1个匹配项。

我自己的30 31字节版本

Ae` ^ \ d | \ W
^ _。*
0.5
^ \ D. *
1个
^ $
0

说明

首先，我们检查，如果有数字输入开始或包含非字字符（比其他任何东西a-z，A-Z，数字和下划线）。如果是这样，则将其丢弃，因为它是无效的。然后我们检查它是否以下划线开头。如果是这样，则将其替换为0.5。然后我们检查是否有非数字字符开始（在这一点上的第一个字符或者是0，a-z或者A-Z，只有a-z和A-Z是非数字，很明显）。如果是这样，则将其替换为1。然后，我们检查是否为空字符串，并将其替换为0。

在线尝试！
在线尝试！旧版

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

派克（Pyke），21个字节

（非竞争，增加的字符串减法，各种字符串常量）

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

Python 3，36个字节

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

该代码的长度为40个字节，有资格获得-10％的红利。

请注意，这仅适用于没有非ASCII字母/数字的代码页。

Pyth，27个字节

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

测试套件

高，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                              ”

Perl，21个字节

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

分数包括+1字节的-p开关。在Ideone上尝试一下。

Pyth，19个字节

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

使用Pyth编译器尝试一下。

请注意，这仅适用于没有非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.

因子 84 * 0.9 = 76.5

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

在侦听器（repl）上运行，定义一个采用字符串并输出{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 ? / 如果最后一个值是0，则将其替换为1；如果是1，则将其替换为2。然后，将第一个值（1或0，有效或无效）除以第二个值（2或1，是否以下划线开头） 。

哎呀！任何缩小的指标都值得赞赏...

而且我讨厌正则表达式！

PS。

{ 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

所有测试通过;）

Dyalog APL，19个字节-10％= 17.1

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

{... ⍵... }其中右边的参数由下式表示匿名函数⍵
⊃⍵的第一个字符（如果给出空的空间）
'_'=，如果等于“下划线1，否则为0
1+的计算结果为2，如果初始下划线，否则为1
⎕NC⍵ 命名类 ; 如果名称无效，则返回-1；如果未定义（但有效名称），则返回0；如果已定义（因此有效），则返回2-9

Mathematica，93个字节

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

老实说，我不确定是否可以进一步打高尔夫球。

Perl，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

Python，84 -10％= 76字节

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

JavaScript ES7，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

@Dennis的Perl答案端口

Ruby，44个字节

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

Ruby，57-10％= 51.3字节

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

幼稚的方法

Lua，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

Lua 68 * .9 = 61.2字节

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

在命令行中接受参数