我们很多人都熟悉Tron游戏。您可以控制放置在网格上的“ lightcycle”。灯光周期总是向前移动（尽管您可以控制方向），并在其后面留下永久的痕迹。如果碰到一条小路，就会崩溃！

此处的目标是确定给定路径是否为有效循环，也就是说，它返回到其起始点而不会“崩溃”。为此，我们假设我们从这一点开始(0,0)。输入形式为N2E1S2W1，具有一系列基本方向（Nis north，Eis east，依此类推），每个方向后跟移动该方向的距离。在此示例中，您将旅行

N2 : North 2 to (0,2)
E1 : East 1  to (1,2)
S2 : South 2 to (1,0)
W1 : West 1  to (0,0)

如果一条路径在(0,0)不重复访问任何其他坐标的情况下结束，则该路径被认为是有效的（它(0,0)精确地访问了两次，一次在起点，一次在终点）。请记住，与上例相比，从(0,0)到(0,2)，我们也必须访问(0,1)。

其他例子：

input        -> output
N1E1S1W1     -> true
N1E1N1E1S2W2 -> true
N1S1E1W1     -> false     // Visits (0,0) 3 times
N4E2S2W4S2E2 -> false     // Visits (0,2) twice
N3E2S3       -> false     // Does not return to (0,0)
N1S1         -> anything  //I don't care how you evaluate this case

您的输出可以是任何形式，只要它为任何真实或错误值提供相同的输出即可。

输入可以采取字符串或字符列表的形式，形式为S1N2E3...或SNNEEE...网格大小也没有硬性限制，但假定输入不会溢出任何内容。只要代码从根本上讲是合理的，处理诸如这样的情况就不是关键N99999999999999。

注意：您可以评估的情况下N1S1，E1W1，S1N1，和W1E1但是你想。它们在技术上是有效的路径，但它们违背了挑战的“特隆”精神。

计分

这是代码高尔夫球，所以最短的答案会成功！

Pyth，44 39字节

&!eJsM._smm^.j)x"NESW"hdstd:z".\d+"1{IJ

测试套件。

JavaScript，247200字节

n=s=>{r=s.match(/\w\d+/g)
x=y=z=0
e=""
for(d of r){a=d[0]
b=d.slice(1)
while(b--){
y+=a=="N"
y-=a=="S"
x+=a=="E"
x-=a=="W"
p=[x,y]+";"
if(~e.indexOf(p))if(!x&!y)z++
else return 0
e+=p}}return!x&!y&!z}

n是输入字符串的函数s，返回1true和0false

这是供参考/解释的非公开版本：

function n(s)
{
    var dir = s.match(/\w\d+/g);
    var x = y = z = 0;
    var been = "";
    for (d of dir)
    {
        var a = d[0];
        var b = 1*d.substring(1);
        while(b-- > 0)
        {
            if (a == "N") y++;
            if (a == "S") y--;
            if (a == "E") x++;
            if (a == "W") x--;
            var pt = [x,y] + ";";
            if (~been.indexOf(pt))
                if (x==0 && y==0)
                    z++;
                else
                    return false;
            been += pt;
        }
    }
    return (x == 0 && y==0 && z == 0);
}

n=s=>{r=s.match(/\w\d+/g)
x=y=z=0
e=""
for(d of r){a=d[0]
b=d.slice(1)
while(b--){
y+=a=="N"
y-=a=="S"
x+=a=="E"
x-=a=="W"
p=[x,y]+";"
if(~e.indexOf(p))if(!x&!y)z++
else return 0
e+=p}}return!x&!y&!z}

console.log(n("N1E1S1W1"))
console.log(n("N1E1N1E1S2W2"))
console.log(n("N1S1E1W1"))
console.log(n("N4E2S2W4S2E2"))
console.log(n("N3E2S3"))

Python 3中，236个 161 150字节

import re
p=0
a=[]
for i in''.join(s[0]*int(s[1:])for s in re.findall(r".\d+",input())):p+=1j**"NESW".find(i);a+=[p]
print(len({*a})-len(a)==0==a[-1])

在线尝试！

-75字节归因于Leaky Nun
-11字节归因于Leaky Nun或者，如果允许我们将输入作为游程长度解码的复数列表：

Python 2中，85 73个字节

c=0;k=[]
for i in input():c+=i;k+=[c]
print(k[-1]==0==len(set(k))-len(k))

在线尝试！

Xcoder先生为-12个字节/ Leaky Nun为-9个字节（合并为一个编辑）

这对我来说感觉太久了

果冻，14 12字节

Œṙ+\µQ⁼ȧṛ/¬$

这是我第一次在果冻打高尔夫球。欢迎提出建议。

输入是[direction, distance]成对的数组，方向是一个复数。

说明：

Œṙ+\µÇȧṛ/¬$   Main link. Argument: n     = [[i, 3], [1, 2], [-i, 3]]
Œṙ            Run-length decode          = [i, i, i, 1, 1, -i, -i, -i]
  +\          Cumulative sum             = [i, 2i, 3i, 3i+1, 3i+2, 2i+2, i+2, i]
    µ         Begin a new monadic chain
     Q        Remove duplicates          = [i, 2i, 3i, 3i+1, 3i+2, 2i+2, i+2]
      ⁼       Equal to original?         = 0
           $  Make a monadic link:
        ṛ/      Reduce by right argument   = i
                (Gets the last element)
          ¬     Logical NOT:               = 0
       ȧ      Logical AND the two values = 0

视网膜，86字节

\d+
$*
1(1*)
$1
+`(.)1
$1$1
.
 $`$&¶
%O`.
+`NS|E(.*)W
$1
M`\w$|(?m)(^.+$)(?s).+^\1$
^0

在线尝试！链接包括测试用例。说明：

\d+
$*

将数字转换为一元。

1(1*)
$1
+`(.)1
$1$1

游程长度解码字母。N111需要变成NNN，因此从每个一元数中减去一个，然后每个1都复制前一个字母。

.
 $`$&¶

将所有前缀（即路径上的点）生成为单独的行。为避免出现空行问题，请在前面加上空格。

%O`.
+`NS|E(.*)W
$1

将每一行中的所有字母按顺序排序，然后删除匹配对。最后，为网格上的任何给定点提供了唯一的代码。

M`\w$|(?m)(^.+$)(?s).+^\1$

检查以下两项之一：a）最后一点没有在空格中结束（即循环没有关闭），或者路径中有两个重复的点。如果路径有效，则所有检查均将失败，结果为零。

^0

反转结果。

佩尔（140）

与字符串输入一起使用。也许我可以用数组来缩短，但我对此表示怀疑。很高兴获得进一步的高尔夫帮助:)

sub w{$i=$_[0];%d=(E,[0],S,[1,-1],W,[0,-1]);$i=~s/(.)(.)/($d,$o)=(@{$d{$1}},1,1);for(1..$2){$s[$d]+=$o;$r+=$d{"@s"}++}/eg;!($s[0]+$s[1]+$r)}