Ini merupakan perpanjangan dari Simulasikan sebuah Minsky Register Machine (I) . Saya tidak akan mengulangi semua deskripsi di sana, jadi silakan baca deskripsi masalah itu terlebih dahulu.

Tata bahasanya sebagian (I) sesederhana mungkin, tetapi menghasilkan program yang agak panjang. Karena ini adalah situs kode golf, kami lebih suka memiliki tata bahasa golf, bukan?

Pada level tinggi, perubahan dari tata bahasa asli adalah sebagai berikut:

• Label pada baris pertama adalah opsional
• Spasi adalah opsional kecuali jika diperlukan untuk memisahkan dua pengidentifikasi yang berdekatan
• Negara dapat diuraikan. Untuk memastikan penguraian yang tidak ambigu, jika kondisi pertama dari operasi pengurangan adalah status inline, harus diapit dalam tanda kurung. Ini berarti bahwa setiap program dapat di-golf menjadi satu-liner.

Misalnya, dalam kasus uji asli kami memiliki:

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

Dalam tata bahasa golf ini dapat disingkat menjadi:

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

atau bahkan:

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

BNF baru untuk jalur "program" (sebagai lawan dari baris akhir, yaitu data) adalah:

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

Pengidentifikasi dan pesan bersifat fleksibel seperti pada tantangan sebelumnya.

Semua kasus uji dari tantangan sebelumnya masih berlaku. Selain itu, solusi Josephus golf berikut ini harus melatih sebagian besar tata bahasa:

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

Output yang diharapkan:

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

Dan saya pikir ini mencakup kasus yang tersisa:

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

Output yang diharapkan:

nop
k=3

Anda dapat mengasumsikan bahwa semua program memiliki semantik yang masuk akal. Secara khusus, mereka akan memiliki setidaknya satu negara dan tidak akan mendefinisikan kembali negara. Namun, seperti sebelumnya, suatu negara dapat digunakan sebelum didefinisikan.

Skor adalah varian pada kode-golf. Anda dapat menulis program mandiri dan akan mencetak sebagai panjang program dalam byte setelah pengkodean UTF-8. Atau, karena penggunaan kembali kode adalah Good Thing, jika Anda telah mengimplementasikan bagian (I) dalam n1byte, Anda dapat menulis program yang mengubah bagian (II) program menjadi bagian (I) program, siap untuk pemipaan ke aslinya. Skor Anda kemudian akan menjadi panjang dari program transformasi Anda plus ceil(n1 / 2).

NB Jika Anda memilih untuk transformasi, Anda harus membuat nama untuk status anonim sedemikian rupa sehingga Anda menjamin bahwa mereka tidak berbenturan dengan status yang disebutkan.

Haskell, 552 499 493 karakter

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

Apakah lebih atau kurang menulis ulang penuh. Mengganti CPS dengan monad RWS yang membaca outputnya sendiri untuk mencari status yang belum diuraikan (yay karena malas!), Ditambah beberapa penyesuaian lainnya.