Nhiều người trong chúng ta đã quen thuộc với trò chơi Tron. Bạn điều khiển một "light Motorcycle" được đặt trên lưới. Light Light luôn di chuyển về phía trước (mặc dù bạn điều khiển hướng) và để lại dấu vết vĩnh viễn phía sau nó. Nếu bạn chạy vào một con đường mòn, bạn gặp nạn!

Mục tiêu ở đây là để xác định xem một đường dẫn cụ thể có phải là một vòng lặp hợp lệ hay không, nghĩa là nó sẽ trở về điểm bắt đầu mà không bị "sập". Để làm điều này, chúng tôi giả sử chúng tôi bắt đầu tại điểm (0,0). Một đầu vào được đưa ra trong biểu mẫu N2E1S2W1, với một loạt các hướng chính ( Nis north, Eis east, v.v.), mỗi đầu theo sau là khoảng cách để di chuyển theo hướng đó. Trong ví dụ này, bạn sẽ đi du lịch

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

Một đường dẫn được coi là hợp lệ nếu nó kết thúc tại (0,0)mà không truy cập bất kỳ tọa độ nào khác nhiều lần (nó truy cập (0,0)chính xác hai lần. Một lần khi bắt đầu và một lần ở cuối). Hãy ghi nhớ hơn trong ví dụ trên, để đi từ (0,0)đến (0,2), chúng tôi nhất thiết phải ghé thăm (0,1).

Những ví dụ khác:

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

Đầu ra của bạn có thể ở bất kỳ dạng nào miễn là nó cho cùng một đầu ra cho bất kỳ giá trị trung thực hoặc falsey nào.

Đầu vào có thể được lấy dưới dạng chuỗi hoặc dưới dạng danh sách các ký tự, ở dạng S1N2E3... hoặc SNNEEE... Cũng không có giới hạn cứng đối với kích thước lưới, nhưng giả sử đầu vào sẽ không tràn ra bất cứ thứ gì. Miễn là mã cơ bản là đúng, thì việc xử lý các trường hợp như thế là không quan trọng N99999999999999.

Chú ý: Bạn có thể đánh giá các trường hợp N1S1, E1W1, S1N1, và W1E1tuy nhiên bạn muốn. Chúng là những con đường hợp lệ về mặt kỹ thuật, nhưng chúng đi ngược lại tinh thần "Tron" của thử thách.

Chấm điểm

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất sẽ thắng!

Bình thường , 44 39 byte

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

Bộ thử nghiệm .

JavaScript, 247 200 byte

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}

nlà một hàm của chuỗi đầu vào strả về 1true và 0false

Đây là một phiên bản chưa được chỉnh sửa để tham khảo / giải thích:

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 byte

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])

Hãy thử trực tuyến!

-75 byte nhờ Leaky Nun
-11 byte nhờ Leaky Nun Hoặc, nếu chúng ta được phép lấy đầu vào dưới dạng danh sách các số phức giải mã độ dài chạy:

Python 2 , 85 73 byte

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

Hãy thử trực tuyến!

-12 byte nhờ Mr. Xcoder / -9 byte nhờ Leaky Nun (hợp nhất thành một chỉnh sửa)

Điều này cảm thấy quá dài đối với tôi lol

Thạch , 14 12 byte

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

Đây là lần đầu tiên tôi chơi golf ở Jelly. Đề nghị được chào đón.

Đầu vào là một mảng các [direction, distance]cặp, trong đó hướng được đưa ra dưới dạng một số phức.

Giải trình:

Œṙ+\µÇȧṛ/¬$   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

Võng mạc , 86 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

\d+
$*

Chuyển đổi số thành unary.

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

Run-length giải mã các chữ cái. N111cần phải biến thành NNN, do đó, một số được trừ từ mỗi số đơn vị và sau đó mỗi số 1 trùng lặp với chữ cái trước đó.

.
 $`$&¶

Tạo tất cả các tiền tố (tức là các điểm trên đường dẫn) dưới dạng các dòng riêng biệt. Một không gian được tiền tố để tránh các vấn đề với các dòng trống.

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

Sắp xếp tất cả các chữ cái trong mỗi dòng theo thứ tự và sau đó xóa các cặp phù hợp. Chúng tôi kết thúc với một mã duy nhất cho bất kỳ điểm nào trên lưới.

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

Kiểm tra một trong hai điều sau: a) điểm cuối cùng không kết thúc trong một khoảng trắng (nghĩa là vòng lặp không đóng) hoặc hai điểm trùng lặp trong đường dẫn. Nếu đường dẫn hợp lệ, tất cả các kiểm tra đều thất bại và kết quả bằng không.

^0

Đảo ngược kết quả.

Perl, 140

Hoạt động với đầu vào chuỗi. Có lẽ tôi có thể rút ngắn với mảng, nhưng tôi nghi ngờ nó. Chúc mừng cho bất kỳ trợ giúp chơi gôn nào :)

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