Lấy cảm hứng từ một trong những video của Vi Hart (là một kho báu chứa đầy những ý tưởng thách thức tiềm năng)

Một con rắn được tạo thành từ các đoạn có cùng độ dài và kết nối giữa mỗi đoạn có thể thẳng hoặc rẽ 90 °.
Chúng ta có thể mã hóa một con rắn như vậy (lên đến một vòng quay, phụ thuộc vào hướng ban đầu) bằng cách viết xuống một sườn , hướng quay (Thẳng / Trái / Phải). Cái này, bắt đầu ở trên cùng bên trái và chỉ về bên phải

-+    +--+    SR    RSSR
 |  +-+  |     S  RSL  S
 +--+  --+     LSSL  SSR

Sẽ được đại diện bởi slither SRSLSSLRLRSSRSRSS

Và dĩ nhiên, một con rắn phẳng không thể tự giao nhau (như trong SSSSLLLSS), điều đó sẽ dẫn đến một Game Over pixel khủng khiếp.

Nhiệm vụ của bạn là xác định xem một slither có hợp lệ hay không (kết quả là có ít nhất một giao điểm tự)

Đầu vào
Một chuỗi được tạo từ các chữ cái SLRvới 2 < length < 10000
Đầu ra
Một cái gì đó Chân lý nếu đó là một chuỗi hợp lệ và một thứ gì đó Falsey nếu không.

Các trường hợp thử nghiệm

__Valid__
SSLSLSRSRSSRSSSLLSSSRRLRSLRLLSSS
SRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLSSLLRSRRLLRRSRLLRSRRLSLLRRLLSLRR (A hilbert curve)
RLLRSRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLSSLLRSRRLLRRSRLLRSRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLSSLLRSRRLLRR
SRRSRSRSSRSSRSSSRSSSRSSSSRSSSSRSSSSSRSSSSSRSSSSSSRSSSSSSRSSSSSS (Spiral)
SSSSSSSSSSLSSSSSSSLSSSSSSSSLSSSSSLSSSSSSLSSSLLRRLLRRLLSLSSSRRSSSSRSSSRSSSSSSRSSSSSRSSSSSSSSRSSSSSSSRSSSSSSSSS (bigger, squigglier spiral)
LRSLLRLSRSLLSRLSLRSLSSSLRRSSLSRRLRSRLRLSLRLLRLRSSLSLRLRSRSSSSSLSRRLSLSSSRRLRLRLRLRRLLSSLSSSRRLRLRLRLRLSLSSSSSSSSSSSSSRLRLLRLRLRLRLRLRLRLSLSSSLSLSLL

__Invalid__
SRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLLLRSRRLLRRSRLLRSRRLSLLRRLLSLRR
SRRLSLLRRLLSLRRSRLLRSRRLLSRSSSRSSSSSSSRSRSSSSSSSRRLLRRSRLLRSRRLSLLRRLLSLRR
SRRSRSRSSRSSRSSSRSSSRSSSSSSSSSSRSSSSRSSSSSRSSSSSRSSSSSSRSSSSSSRSSSSSS
SSSSSSSSSSLSSSSSSSLSSSSSSSSLSSSSSLSSSSSSLSSSLLRRLRLRRLLSLSSSRRSSSSRSSSRSSSSSSRSSSSSRSSSSSSSSRSSSSSSSRSSSSSSSSS
LRSLLRLSRSLLSRLSLRSLSSSLRRSSLSRRLRSRLRLSLRLLRLRSSLSLRLRSRSSSSSLSRRLSLSSSRRLRLRLRLRRLLSSLSSSRRLRLRLRLRLSLSSSSSSSSSSSSSRLRLLRLRLRLRLRLRLRLSLSSSLSLSLLSLRLSLRSLRSLRSLSLSLRSRLSLRSLRLSRSLLLRLRLRRRRSLSLSSLLSLSLSLSSLLSLSLLRLRSLLRSRLSLSSLLLLSSSSSSSSSSSSSSSSSSSSRLRLLRRLRLRLLRLRLRLRLRLSSSSLSLRLLRLSLSSLSLSLSLSLRLLRLSLLLSRSSSSSSSSSSSSSSSRLRLRLLRLRLSLSRSRSSSLSRLRLRLRSLSLSLSRLLSRLSLSLSLSLSSLSLSLLSLSRLLRLRLRLRLRLRLRLRLRLRLSLSRLRLSLLRRLSLLSLSLSLSLSLLSLSLSLRLRLRLRLRLRLRLRLRLRRLRSLSLSLSLSLSLSLSSLSSSSSLSLSSSLSLSLSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS

Bạn có thể vẽ các thanh trượt ở đây (R và L được lật, nhưng nó không ảnh hưởng đến hiệu lực)

Bình thường, 22 20 byte

ql{m+=Z*=T^.j)hCdzlz

Thử nó cho mình hoặc chạy TestSuite .

Lưu ý các giá trị ASCII của SRL, tương ứng 83, 76, 82. Tôi lạm dụng thực tế rằng:

i ^{83 + 1} = 1
i ^{76 + 1} = i
i ^{82 + 1} = -i

Từ đây tôi chỉ giữ một biến cho vị trí hiện tại và hướng hiện tại. Với mỗi ký tự, tôi nhân hướng hiện tại với số phức ở trên, sau đó thêm nó vào vị trí hiện tại.

Cuối cùng, tôi kiểm tra xem tất cả các vị trí truy cập là duy nhất.

CJam, 30 byte

q{iF%U+:U[XWe4W1e4]=T+:T}%__&=

Giải thích để làm theo sớm.

Hãy thử trực tuyến tại đây hoặc chạy toàn bộ bộ .

JavaScript (ES6), 84 89

Chạy đoạn trích trong Firefox để kiểm tra.

Một số lưu ý:

• con rắn di chuyển bên trong mảng f. Các ô không mong muốn có giá trị undefined. Trong lần truy cập đầu tiên, toán tử dấu ngã thay đổi thành -1 đó là một sự thật. Cuối cùng, trong lần truy cập thứ hai, giá trị thay đổi thành 0 là sai và everyvòng lặp chấm dứt trả về sai.
• trong JS, các phần tử mảng có chỉ số không canonic (không phải số hoặc âm) bằng cách nào đó 'ẩn', nhưng chúng tồn tại. Ở đây tôi sử dụng các chỉ số tiêu cực không có vấn đề.

F=s=>[...s].every(c=>f[p+=[1,1e5,-1,-1e5][d=d+{R:1,L:3,S:0}[c]&3]]=~f[p],d=p=0,f=[])

//TEST
$('#S').on('keyup mouseup change', Draw);

function Draw(){
  var s = S.value.toUpperCase();
  if (!s) {
    C.width = C.height = 0;
    return
  }
  C.width = 600;
  C.height = 400;
  
  var ctx = C.getContext("2d");  
  var px, py, int=0;
  
  ctx.strokeStyle = '#008';
  ctx.lineWidth = 2;
  ctx.translate(300,200);
  ctx.beginPath();
  ctx.moveTo(0,0);
  
  [...s].forEach(c=>{
    (f[p+=[1,1e4,-1,-1e4][d=d+{R:1,L:3,S:0}[c]&3]]=~f[p])
    ? 1 
    : (++int)
    if (int==1) ctx.stroke(), ctx.strokeStyle = '#800', ctx.beginPath(), ctx.moveTo(10*px,10*py);
    
    py = (p / 1e4 | 0) - 5e3;
    px = (p % 1e4) -5e3
    ctx.lineTo(10*px, 10*py);
  }, d=0,p=50005000,f=[]);
  ctx.stroke();
  
}

valid=["SSLSLSRSRSSRSSSLLSSSRRLRSLRLLSSS",
"SRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLSSLLRSRRLLRRSRLLRSRRLSLLRRLLSLRR",
"RLLRSRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLSSLLRSRRLLRRSRLLRSRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLSSLLRSRRLLRR",
"SRRSRSRSSRSSRSSSRSSSRSSSSRSSSSRSSSSSRSSSSSRSSSSSSRSSSSSSRSSSSSS",
"SSSSSSSSSSLSSSSSSSLSSSSSSSSLSSSSSLSSSSSSLSSSLLRRLLRRLLSLSSSRRSSSSRSSSRSSSSSSRSSSSSRSSSSSSSSRSSSSSSSRSSSSSSSSS",
"LRSLLRLSRSLLSRLSLRSLSSSLRRSSLSRRLRSRLRLSLRLLRLRSSLSLRLRSRSSSSSLSRRLSLSSSRRLRLRLRLRRLLSSLSSSRRLRLRLRLRLSLSSSSSSSSSSSSSRLRLLRLRLRLRLRLRLRLSLSSSLSLSLL"];
invalid=["SRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLLLRSRRLLRRSRLLRSRRLSLLRRLLSLRR",
"SRRLSLLRRLLSLRRSRLLRSRRLLSRSSSRSSSSSSSRSRSSSSSSSRRLLRRSRLLRSRRLSLLRRLLSLRR",
"SRRSRSRSSRSSRSSSRSSSRSSSSSSSSSSRSSSSRSSSSSRSSSSSRSSSSSSRSSSSSSRSSSSSS",
"SSSSSSSSSSLSSSSSSSLSSSSSSSSLSSSSSLSSSSSSLSSSLLRRLRLRRLLSLSSSRRSSSSRSSSRSSSSSSRSSSSSRSSSSSSSSRSSSSSSSRSSSSSSSSS",
"LRSLLRLSRSLLSRLSLRSLSSSLRRSSLSRRLRSRLRLSLRLLRLRSSLSLRLRSRSSSSSLSRRLSLSSSRRLRLRLRLRRLLSSLSSSRRLRLRLRLRLSLSSSSSSSSSSSSSRLRLLRLRLRLRLRLRLRLSLSSSLSLSLLSLRLSLRSLRSLRSLSLSLRSRLSLRSLRLSRSLLLRLRLRRRRSLSLSSLLSLSLSLSSLLSLSLLRLRSLLRSRLSLSSLLLLSSSSSSSSSSSSSSSSSSSSRLRLLRRLRLRLLRLRLRLRLRLSSSSLSLRLLRLSLSSLSLSLSLSLRLLRLSLLLSRSSSSSSSSSSSSSSSRLRLRLLRLRLSLSRSRSSSLSRLRLRLRSLSLSLSRLLSRLSLSLSLSLSSLSLSLLSLSRLLRLRLRLRLRLRLRLRLRLRLSLSRLRLSLLRRLSLLSLSLSLSLSLLSLSLSLRLRLRLRLRLRLRLRLRLRRLRSLSLSLSLSLSLSLSSLSSSSSLSLSSSLSLSLSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS"];

V.innerHTML=valid.map(s=>F(s)+' '+s).join('\n')
I.innerHTML=invalid.map(s=>F(s)+' '+s).join('\n')

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
Type to check and draw <input id=S>
(better full page)<br>
<canvas id=C width=1 height=1 ></canvas><br>
Valid<pre id=V></pre>
Invalid<pre id=I></pre>

TI-BASIC, 49 56 53 51 byte

abs(e^(i)-cumSum(i^cumSum(seq(inString("SL",sub(Ans,X,1))-1,X,1,length(Ans→X
SortA(∟X
min(ΔList(∟X

Tương tự như phương pháp của orlp, điều này tạo ra một danh sách tất cả các điểm trong mặt phẳng phức được con rắn ghé thăm, bắt đầu từ điểm gốc. Nếu danh sách không có phần tử trùng lặp, mã sẽ trả về một số giá trị dương. Lưu ý rằng trên một chuỗi gồm hơn 999 phần tử, máy tính sẽ không thể tạo danh sách đủ dài và sẽ xảy ra lỗi.

EDIT: Đã lưu hai byte với chi phí xấu vì không có hai điểm mạng trên mặt phẳng phức có thể cách xa e ^ i.

TI-BASIC, 60 58 byte

Chỉnh sửa: Bỏ qua mọi thứ bên dưới: một giải pháp cơ bản đang hoạt động ở đây , bởi thomas-kwa. Đi lên mà!

⁻là [(-)]chìa khóa, và Ans là [2ND]->[(-)]. Chạy nó bằng cách kèm theo hướng dẫn của con rắn trong dấu ngoặc kép ( [ALPHA]->[+]) theo sau là dấu hai chấm sau đó là tên của chương trình. Chẳng hạn, nếu bạn đặt tên chương trình là "SNAKE", bạn sẽ chạy trường hợp thử nghiệm trong OP là "SRSLSSLRLRSSRSRSS":prgmSNAKE.

seq(inString("SRL",sub("0"+Ans,I,1)),I,1,length(Ans
Disp 0<sum(⁻1+2seq(Ans(I)≠(Ans(I-1),I,2,dim(Ans

Chỉnh sửa: Thất bại trên SRRLSLLRRRS. Tôi có một phiên bản sửa đổi ở 61 byte, nhưng nó không thành công trong trường hợp thử nghiệm không hợp lệ đầu tiên:

seq(inString("SRL",sub("0"+Ans,I,1)),I,1,length(Ans
cumSum(⁻1+2seq(Ans(I)≠(Ans(I-1),I,2,dim(Ans
Disp 0<Ans(dim(Ans

Tôi sẽ cố gắng khắc phục vào ngày mai.

Cập nhật: vì vậy vấn đề thực sự là thuật toán của tôi bị thiếu sót. Nếu tôi đã sử dụng một vòng lặp For (trái ngược với seq ((để đạt được điều tương tự) thì thực tế (cả hai thuật toán ở trên) có thể được mô tả như sau:

1. Khởi tạo biến đếm thành 1.
2. Đọc chuỗi. Nếu biểu tượng thay đổi, tăng biến đếm. Nếu biểu tượng lặp lại, giảm nó.
3. Nếu biến đếm lớn hơn 0, hiển thị 1 (hợp lệ). Nếu không, hiển thị 0 (không hợp lệ).

Tuy nhiên, điều này không thành công trên các slithers không hợp lệ như SRLRLRLRLRRRSS. Bây giờ tôi sẽ cố gắng đưa ra một thuật toán tốt hơn ... hoặc đánh cắp từ một câu trả lời khác.

Tôi chắc chắn 90% rằng điều này có thể được thay thế bằng một seq(lệnh duy nhất , nhưng thực tế bây giờ nó nhỏ như tôi có thể nhận được. Nếu bạn có ý định xây dựng này để một 8xp sử dụng Sourcecoder như trái ngược với thực tế gõ nó ra, lưu ý rằng ≠nên được thay thế bằng !=và các ⁻1+bit nên được thay thế bằng ~1+.

Ruby 87 89

F=->s{d=[1,w=1e4,-1,-w]
v=[w]+s.chars.map{|c|w+=d.rotate!(c<?R?-1:c>?R?0:1)[0]}
v==v&v}

Kiểm tra trực tuyến: http://ideone.com/pepeW2

Phiên bản bị đánh cắp:

F = -> input {
  # Coordinates are expressed using one number,
  # that is computed using the formula `y + x*max_x`.
  # Assume max horizontal field width (max_x) to be 10000,
  # since that's the max length of the input.
  position = max_x = 1e4

  # These are possible directions to move to (coordinate deltas).
  # The current direction is always the first in the array.
  directions = [1,max_x,-1,-max_x]

  visited = [position]

  visited += input.chars.map{|c|
    # adjust current direction...
    directions.rotate! case c
    when ?L
      -1
    when ?R
      1
    when ?S
      0
    end

    # ...and move there
    position += directions[0]
  }

  # Return `true` if `visited` only contains distinct elements, `false` otherwise
  visited == visited & visited
}

Golf 48 49 50

[10.4?:z-10z~)]z*z@{'R L S'?@>(@+.`n}%n/@;\;..&=

Yêu cầu chuỗi tồn tại trên ngăn xếp và trả về 0hoặc 1.

Bạn có thể dùng thử trực tuyến với các bài kiểm tra cho hợp lệ và không hợp lệ rắn.

Đây là ý tưởng cơ bản giống như trong câu trả lời Ruby của tôi . Chỉ là mảng hướng được xử lý khác nhau, bởi vì AFAIK Golfscript không có chức năng xoay arary. Trong trường hợp này, tôi xây dựng một mảng chỉ đường đủ lớn, bằng cách nhân nó 10000 lần và sau đó cắt từ phần tử 0, 1 hoặc 3 của nó, tùy thuộc vào lệnh hiện tại (S, R hoặc L). "Hướng" hiện tại để di chuyển đến luôn là mục đầu tiên trong mảng.

Đây là ý kiến:

# Build the direction array and set current position
[1 10000:z-1z~)]z*z

@{
  # For each character in the input:

  # set current direction by cutting 0, 1 or 3 elements 
  # from the beginning of the directions array
  'SR L'?
  @>

  # move to current direction
  .0=@+.

  # format as number and addd newline
  `n
}%

# split by newlines
n/

# cleanup
@;\;

# return 1 if array contains distinct elements, 0 otherwise
..&=

Chỉnh sửa:

Đã lưu 1 char bằng cách sửa đổi cách "mảng" được tiêu thụ.

Chỉnh sửa:

đã lưu 1 char bằng cách di chuyển số gia 10 thay vì 1 để sử dụng ?cú pháp (power).