Il s'agit d'une extension de Simulate a Minsky Register Machine (I) . Je ne vais pas répéter toute la description ici, alors veuillez d'abord lire cette description du problème.

La grammaire de la partie (I) était aussi simple que possible, mais aboutit à des programmes assez longs. Puisqu'il s'agit d'un site de golf à code, nous préférons avoir une grammaire de golf, n'est-ce pas?

À un niveau élevé, les changements par rapport à la grammaire d'origine sont les suivants:

• L'étiquette sur la première ligne est facultative
• L'espace est facultatif sauf s'il est nécessaire de séparer deux identifiants adjacents
• Les États peuvent être alignés. Pour garantir une analyse non ambiguë, si le premier état d'une opération de décrémentation est un état en ligne, il doit être placé entre parenthèses. Cela signifie que tout programme peut être joué dans un seul revêtement.

Par exemple, dans les cas de test d'origine, nous avions:

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

Dans la grammaire du golf, cela pourrait être raccourci comme suit:

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

ou même:

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

Le nouveau BNF pour les lignes "programme" (par opposition à la ligne finale, qui est des données) est:

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

Les identifiants et les messages sont flexibles comme dans le défi précédent.

Tous les cas de test du défi précédent sont toujours applicables. De plus, la solution Josephus golfée suivante devrait exercer la majeure partie de la grammaire:

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

Production attendue:

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

Et je pense que cela couvre le cas restant:

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

Production attendue:

nop
k=3

Vous pouvez supposer que tous les programmes auront une sémantique sensée. En particulier, ils auront au moins un état et ne redéfiniront pas un état. Cependant, comme précédemment, un état peut être utilisé avant d'être défini.

La notation est une variante du code-golf. Vous pouvez écrire un programme autonome et il marquera la longueur du programme en octets après le codage UTF-8. Alternativement, parce que la réutilisation du code est une bonne chose, si vous avez implémenté la partie (I) en n1octets, vous pouvez écrire un programme qui transforme un programme partie (II) en programme partie (I), prêt à être acheminé vers l'original. Votre score sera alors la durée de votre programme de transformation plus ceil(n1 / 2).

NB Si vous optez pour la transformation, vous devrez générer des noms pour les états anonymes de manière à garantir qu'ils ne se heurtent pas aux états nommés.

Haskell, 552 499 493 caractères

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

A fait plus ou moins une réécriture complète. CPS remplacé par une monade RWS qui lit sa propre sortie pour rechercher les états qu'il n'a pas encore analysés (ouais pour la paresse!), Plus quelques autres ajustements.