一门小语言值得一口小口译员

21

这是一个非常简单的语言定义：

A Variable is any string that does not contain ^, <, >, !, or ?
The empty string is a valid variable identifier
The value of every variable starts at 0.
A Statement is one of (var is a Variable, P is a Program):
    var^   -> changes var to be equal to 1 more than itself
    var<P> -> while var > 0, changes var to be equal to 1 less than itself, then runs P
    var! -> output value of var
    var? -> ask for non-negative integer as input, increase var by that value
A Program is a concatenation of Statements, running a Program means running each Statement in order

示例程序（请注意，空字符串是一个变量，但是为了清楚起见，我将谨慎使用它，并且某些变量在默认情况下通常为0时会在程序中清零）：

<>: sets the value of the empty string variable to 0
b<>b?b<a^>: asks for b, then adds the value stored in b to a, zeroing b in the process
b<>b?a<>b<a^>: asks for b, then sets a to the value of b, zeroing b in the process
a<>c<>b<a^c^>c<b^> : copies the value in b into a without zeroing it
b<>c<>a<c^c^c<b^>>b! : outputs a multiplied by 2
b^b<a<>a?a!b^> : outputs what you input, forever

您的目标是为此语言编写最小的解释器。

  1. 从理论上讲，变量的值可以任意大，并且仅受语言可以访问的总内存的限制，但是您仅需要处理最大2 ^ 256的值。

  2. 从理论上讲，您的程序应该能够处理任意长的程序，但是您只需要处理2 ^ 32个字符以下的程序即可。您还需要处理深度最大为2 ^ 32的嵌套循环。

  3. 您可以假定该程序是有效程序，并且要求输入时只会得到非负整数。您还可以假定输入字符串中仅包含ASCII可打印字符。

  4. 您解释的程序的速度无关紧要，对于诸如5位数乘法这样的简单事情，如果没有优化，它的速度已经非常缓慢。

  5. 如果您要使用一种无​​法合理接受输入或无法以该语言描述的方式产生输出的语言，请使用任何可能的解释。这适用于您的语言无法实现某些必需行为的任​​何原因。我希望所有语言都能竞争。

  6. 最短的程序获胜。有标准漏洞。

code-golf  interpreter 
— 磨碎的瓜
source
作为附带的挑战，我想看看我能写出输出数字2016的程序有多短，但是首先我需要等待编写解释器，以便测试我的代码。
— 尼尔
1
我在这里有Python 2.7的解释器。
— 摩擦瓜
2
这种语言叫什么？它值得在esolangs.org上占有一席之地
— wizzwizz4 '02
@Neil我成功地用72个字符做到了
— 摩擦瓜
@FricativeMelon 72？我可以43岁做到！
— 尼尔

Answers:

4

Ruby，182字节

$h=Hash.new 0
def r(c)c.scan(/(([^!?^<>]*)(<(\g<1>*)>|[!?^]))/){$4?($1=~/(.*?)<(.*)>/
($h[$1]-=1;r$2)while$h[$1]>0):$3<?"?p($h[$2]):$h[$2]+=$3<?@?STDIN.gets.to_i:
1}end
r IO.read *$*

像这样尝试：

$ cat code
a?b<>c<>a<c^c^c<b^>>b!

$ ruby lynn.rb code
3                           <-- input
6                           <-- output

怎么运行的

该r函数标记输入字符串并执行每个标记：

def r(c)
    c.scan(/(([^!?^<>]*)(<(\g<1>*)>|[!?^]))/){
        ...
    }
end

我们寻找一些变量名$2匹配[^!?^<>]*，然后是

  • <...>其中...零个或多个节目相匹配（\g是递归），在这种情况下$4是不nil
  • 甲!，?或^字符，通过捕获$3，在这种情况下$4是nil。

然后，在稍微缩进令牌时执行令牌的逻辑非常简单：

$4 ? (                                    # If it's a loop:
    $1 =~ /(.*?)<(.*)>/                   #   Re-match token*
    ($h[$1]-=1; r $2) while $h[$1] > 0    #   Recurse to run loop
) :                                       # Else:
    $3 < ?"                               #   If it's an !:
      ? p($h[$2])                         #     Print the var
      : $h[$2] +=                         #   Else, increment it by:
          $3 < ?@                         #     If it's a ?:
              ? STDIN.gets.to_i           #       User input
              : 1                         #     Else: 1

* There's an oniguruma bug, I think, that keeps me from simply using $3 here.
— 林恩
source
我真的很好奇这是如何工作的。
— 杰里·耶利米
1

JavaScript的（ES6）184 194 209

简化编辑（将功能参数用于输入和输出似乎是个不错的主意，但实际上并非如此），在@byteΛbyteΛПҒЦꝆ处又节省了1个字节

编辑2修改后的解析。增量/输入的逻辑是从@Lynn的答案中借用的

F=(p,i=0,v={},n='')=>eval("for(;c='>?^!<'.indexOf(q=p[i++]||'');n=~c?'':n+q)if(c>3){for(;v[n]--;)F(p,i,v);i=F(p,i,v[n]=0)}else~c&&v?c>2?alert(v[n]|0):v[n]=~~v[n]+(--c||+prompt()):0;i")

少打高尔夫球

F=(p,      // program 
   i = 0,  // initial instruction pointer  
   v = {}, // variables (default to empty) or if 0, flag of dummy execution
   n = ''    // name of current variable (has to be local for recursive calls)
{
  for(; c='>?^!<'.indexOf(q=p[i++]||''); )
  // q = current character
  // c = current command (int 0..4 or -1 id not recognized)
  //     note 0 end of subprogram or end of program
  {
    if(c>3) // 4='<' call subprogram - recursive
    {
      for(;v[n]--;)
        F(p,i,v); // conditional call, repeated - using real environment
      v[n] = 0; // Reset variable at loop end
      i=F(p,i,0) // one more unconditional dummy call, just to advance i
    }
    else
      ~c&&v? // if valid command (1..3) and not dummy
      c>2?
        alert(v[n]|0) // output, undefined becomes 0
        :v[n]=~~v[n]+(--c||+prompt()) // inc with 1 or user input
      :0     // not valid command or dummy, do nothing
    n=~c?'':n+q // reset or update current variable name
  }
  return i // return current istruction pointer (for recursive calls)
}

测试代码段开始使用@Neil发布的程序评估2016年。耐心一点...

F=(p,i=0,v={},n='')=>eval("for(;c='>?^!<'.indexOf(q=p[i++]||'');n=~c?'':n+q)if(c>3){for(;v[n]--;)F(p,i,v);i=F(p,i,v[n]=0)}else~c&&v?c>2?alert(v[n]|0):v[n]=~~v[n]+(--c||+prompt()):0;i")

// TEST
function definput(){  I.disabled = KI.checked; }
function defoutput(){  O.disabled = KO.checked; }

function run()
{
  var prog=P.value, irows = I.value.split('\n'), pi=0;
  var fout=x=>O.value+=x+'\n';
  var fin=x=>irows[pi++];
  var saveAlert=alert, savePrompt=prompt
  if (!KO.checked) alert=fout,O.value=''
  if (!KI.checked) prompt=fin
  
  F(prog);
  
  alert=saveAlert
  prompt=savePrompt
}

P.value="^^^^<a^a^>a<^^^^><a^b^>a<c<b^^>b<c^^>>!"

run()
Program <button onclick="run()">RUN</button><br>
<textarea id=P></textarea><br>
Input (or <input type=checkbox id=KI onclick="definput()"> interactive prompt)<br>
<textarea id=I>5</textarea><br>
Output (or <input type=checkbox id=KO onclick="defoutput()"> popup)<br>
<textarea id=O readonly></textarea><br>
展开摘要

— edc65
source
使用eval避免return不是一种选择？
— Mama Fun Roll
@ӍѲꝆΛҐӍΛПҒЦꝆ是，eval保存1个字节。我仍在寻找更重要的内容
— edc65 '16
0

Perl，251个字节

@p=split/([<>!?^])/,<>;for$c(0..$#p){$_=$p[$c];/</&&push@j,$c;if(/>/){$a=pop@j;$p[$c]=">$a";$p[$a]="<$c";}}while($c<$#p){$_=$p[$c];/\^/&&$v{$l}++;/!/&&print$v{$l};/\?/&&($v{$l}=<>);/<(\d+)/&&($v{$l}?$v{$l}--:($c=$1));/>(\d+)/&&($c=$1-2);$l=$_;$c++;}

易于阅读的版本：

# treat the first line of input as a program

# split on punctuation keywords; @p will contain the program as a list
# of tokens (including whitespace between adjacent punctuation)
@p = split /([<>!?^])/, <>;

# rewrite jump addresses

# the interpreter could scan backwards to avoid this, but that idea
# makes me feel dirty
for $c (0..$#p) {
    $_ = $p[$c];
    # save loop-start address on stack
    /</ && push @j, $c;
    if (/>/) {
        # if we encounter a loop-end instruction, rewrite it and the
        # corresponding loop-start to include the address (of the
        # instruction---jumps have to offset from this)
        $a = pop @j;
        $p[$c] = ">$a";
        $p[$a] = "<$c";
    }
}

# execute the program

# our program is already in @p

# $c will contain our program counter

# $l will contain the name of the last-referenced variable

while ($c < $#p) {
    # move current instruction into $_ for shorter matching
    $_ = $p[$c];

    # increment instruction
    /\^/ && $v{$l}++;

    # output instruction
    /!/ && print $v{$l};

    # input instruction
    /\?/ && ($v{$l} = <>);

    # loop start, including address
    /<(\d+)/ && ($v{$l} ? $v{$l}-- : ($c = $1));

    # loop end, including address
    />(\d+)/ && ($c = $1-2);

    # copy current instruction into "last variable name"---this will
    # sometimes contain operators, but we have null-string
    # instructions between adjacent operators, so it'll be fine
    $l = $_;

    # advance the program counter
    $c++;
}

这浪费了一堆字节，将循环固定为直接跳转，但向后扫描循环开始却违反了我的审美观念。

— 大卫·莫里斯
source
0

标准C ++，400字节

这与 g++ -g test.cpp -Wall -Wextra -pedantic -std=gnu++11 

#include<map>
#include<cstring>
#define b ;break;case
#define u unsigned long long
std::map<std::string,u>V;void r(char*s){char*p,*q,*e;for(u c;*s;s=p){p=strpbrk(s,"^<?!");c=*p;*p++=0;switch(c){b'^':V[s]++b'<':for(e=p,c=0;*e!='>'||c;e++)c+=(*e=='<')-(*e=='>');*e++=0;while(V[s]>0){V[s]--;r(q=strdup(p));free(q);}p=e;b'?':scanf("%llu",&V[s])b'!':printf("%llu",V[s]);}}}int main(int,char*v[]){r(v[1]);}

我也许可以再缩短一点。如果您有任何建议，请发表评论。

— 杰里·耶利米
source
— ceilingcat
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.