Đây là phần mở rộng của Mô phỏng Máy đăng ký Minsky (I) . Tôi sẽ không lặp lại tất cả các mô tả ở đó, vì vậy xin vui lòng đọc mô tả vấn đề đó trước.

Ngữ pháp trong phần (I) đơn giản nhất có thể, nhưng kết quả là các chương trình khá dài. Vì đây là một trang web chơi mã, chúng tôi muốn có một ngữ pháp được đánh gôn, phải không?

Ở cấp độ cao, những thay đổi từ ngữ pháp gốc như sau:

• Nhãn trên dòng đầu tiên là tùy chọn
• Khoảng trắng là tùy chọn trừ khi được yêu cầu tách hai số nhận dạng liền kề
• Hoa có thể được nội tuyến. Để đảm bảo phân tích cú pháp không mơ hồ, nếu trạng thái đầu tiên của thao tác giảm là trạng thái nội tuyến, thì nó phải được đặt trong dấu ngoặc đơn. Điều này có nghĩa là bất kỳ chương trình nào cũng có thể được chơi thành một lớp lót.

Ví dụ: trong các trường hợp thử nghiệm ban đầu, chúng tôi đã có:

b + = a, t = 0

init : t - init d0
d0 : a - d1 a0
d1 : b + d2
d2 : t + d0
a0 : t - a1 "Ok"
a1 : a + a0
a=3 b=4

Trong ngữ pháp golf, điều này có thể được rút ngắn thành:

init:t-init d
d:a-(b+t+d)a
a:t-(a+a)"Ok"
a=3 b=4

hoặc thậm chí:

init:t-init d:a-(b+t+d)a:t-(a+a)"Ok"
a=3 b=4

BNF mới cho các dòng "chương trình" (trái ngược với dòng cuối cùng là dữ liệu) là:

program    ::= first_line (newline line)*
first_line ::= cmd
line       ::= named_cmd
state      ::= state_name
             | cmd
             | '"' message '"'
delim_state::= '(' cmd ')'
             | '"' message '"'
cmd        ::= raw_cmd
             | named_cmd
named_cmd  ::= state_name ' '* ':' ' '* raw_cmd
raw_cmd    ::= inc_cmd
             | dec_cmd
inc_cmd    ::= reg_name ' '* '+' ' '* state
dec_cmd    ::= reg_name ' '* '-' ' '* delim_state ' '* state
             | reg_name ' '* '-' ' '* state_name ' '* delim_state
             | reg_name ' '* '-' ' '* state_name ' '+ state
state_name ::= identifier
reg_name   ::= identifier

Định danh và tin nhắn là linh hoạt như trong thử thách trước.

Tất cả các trường hợp thử nghiệm từ thử thách trước vẫn được áp dụng. Ngoài ra, giải pháp Josephus được đánh gôn sau đây cần thực hiện hầu hết các ngữ pháp:

in:k-(r+t+in)in2:t-(k+in2)r-(i+n-0"ERROR n is 0")"ERROR k is 0"
0:n-(i+2:k-(r+t+2)5:t-(k+5)7:i-(r-(t+7)c:t-(i+r+c)i+0)a:t-(i+a)7)"Ok"
n=40 k=3

Sản lượng dự kiến:

Ok
i=40 k=3 n=0 r=27 t=0

Và tôi nghĩ rằng điều này bao gồm các trường hợp còn lại:

k+k-"nop""assert false"
k=3

Sản lượng dự kiến:

nop
k=3

Bạn có thể cho rằng tất cả các chương trình sẽ có ngữ nghĩa hợp lý. Cụ thể, họ sẽ có ít nhất một trạng thái và sẽ không xác định lại trạng thái. Tuy nhiên, như trước đây, một trạng thái có thể được sử dụng trước khi nó được xác định.

Điểm số là một biến thể của mã golf. Bạn có thể viết một chương trình độc lập và nó sẽ ghi điểm là độ dài của chương trình tính bằng byte sau khi mã hóa UTF-8. Ngoài ra, vì sử dụng lại mã là một điều tốt, nếu bạn đã triển khai phần (I) bằng n1byte, bạn có thể viết chương trình biến chương trình phần (II) thành chương trình phần (I), sẵn sàng chuyển sang bản gốc. Điểm của bạn sau đó sẽ là độ dài của chương trình chuyển đổi của bạn cộng ceil(n1 / 2).

NB Nếu bạn chọn chuyển đổi, bạn sẽ cần tạo tên cho các trạng thái ẩn danh theo cách bạn đảm bảo rằng chúng không xung đột với các trạng thái được đặt tên.

Haskell, 552 499 493 ký tự

import Control.Monad.RWS
import Data.Map
main=interact$z.lines
z x=let(s:_,w)=evalRWS(mapM(q.t)x)w[]in s.f.i.t$last x 
p=get>>=q
q(l:":":x)=x%do a<-p;tell$f[(l,a)];r a
q(v:"+":x)=x%fmap(.a v 1)p
q(v:"-":x)=x%liftM2(d v)p p
q(('"':s):x)=x%r(\w->unlines[init s,do(v,x)<-assocs w;v++'=':show x++" "])
q(n:x)|n<"*"=x%p|1<3=x%asks(!n)
d v p n w|member v w&&w!v>0=p$a v(-1)w|1<3=n w
t[]=[];t x=lex x>>= \(y,x)->y:t x
i(v:_:x:t)=(v,read x):i t;i[]=[]
x%m=put x>>m;r=return;a=insertWith(+);f=fromList

Đã ít nhiều viết lại đầy đủ. Đã thay thế CPS bằng một đơn vị RWS đọc đầu ra của chính nó để tra cứu trạng thái mà nó chưa được phân tích cú pháp (yay cho sự lười biếng!), Cùng với một số điều chỉnh khác.