大约一年前，2015年12月31日，我想到：

我们应该制作一个时间胶囊线。每个人都可以添加一个角色，接下来的新年中，我们将看到谁可以用当时存在的esolang在所有角色中做出最好的程序。

Doorknob亲切地从PPCG社区中收集了角色，并确保它们安全了一年。

多达74人参加了比赛，所以我们有74个 可打印的ASCII字符供您玩耍！

以下是2016年时间胶囊字符串的74个字符，按提交顺序排列：

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

以下是2016年时间胶囊字符串的74个字符，按ASCII顺序排列（注意前导空格）：

 !!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

协作并不是很多，但在这里，我们就像是一个挑战。

挑战

为了确定时间胶囊字符串哪种语言“最好”，我们将面临6个（对于201 6）挑战，难度增加，其中每个挑战都必须使用74个时间胶囊字符中的一个子集。

面临6个不同的挑战有助于确保更多的语言可以竞争，但是只有最好的语言才能回答所有这些问题并获得高分。

得分：

• 根据使用了多少个角色，每个挑战的得分从0到74。
• 分数越高越好。
• 如果您的语言无法完成一项挑战，那么您对该挑战的评分为0。
• 挑战的任何非空子集都可以完成。
• 您的最终分数是所有6个挑战的分数之和。
• 最好的最终分数是6×74或444。

挑战

1.运行

如果某种语言的代码不能在一开始就运行，那么它将根本无能为力。

编写可能运行时间最长的完整程序（记住，仅使用74个时间胶囊字符），而不会出现编译时或运行时错误。

程序做什么无关紧要，它是否有输入/输出或进入无限循环都无关紧要，只重要的是程序运行没有错误。（警告是可以的，由于用户输入错误而引起的错误也可以。）

允许注释，因此可以很简单

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

在Python中获得74分。

（如果这是您的语言可以完成的唯一挑战，请不要害怕回答，但是也不要期望获得很多选票。）

分数=程序长度（程序越长越好）

2.输入/输出

没有输入或输出形式的语言几乎和不能运行的语言一样没有用。

给定一个可打印的ASCII由字符!（0x33）至}（0x7D）包容，输出可打印的ASCII字符之前和之后。

输出可以是两个长度的字符串或列表，也可以是由空格或换行符分隔的字符。

例如，如果输入为}输出，则可能为|~或["|", "~"]或| ~或|\n~。

同样， "是的输出!，AC也是的输出B。

分数= 74-程序长度（程序越短越好）

3.可分支性

条件转换通常是图灵完整性的必要条件，而图灵完整性通常是一种有用的语言的要求。

给定一个正整数，如果以十进制数字结尾，16则将a更改6为a 7并输出结果；否则，输出不变。如果愿意，可以使用字符串作为输入/输出。

例子：

2016 -> 2017
16 -> 17
116 -> 117
1616 -> 1617
6 -> 6
15 -> 15
17 -> 17
106 -> 106
2106 -> 2106

分数= 74-程序长度（程序越短越好）

4.循环性

不能循环的语言会产生重复的代码，如此乏味，您需要花一段时间来暂停编程。

给定一个正整数，输出该边长的ASCII艺术方块，该方块填充有同心的较小方块的图案，该图案在任意两个不同的可打印ASCII字符之间交替。对于不同的输入，它们不必是相同的两个字符。

例如：

1    <- input
X    <- output

2
XX
XX

3
XXX
X-X
XXX

4
XXXX
X--X
X--X
XXXX

5
YYYYY
Y...Y
Y.Y.Y
Y...Y
YYYYY

6
XXXXXX
X----X
X-XX-X
X-XX-X
X----X
XXXXXX

7
ZZZZZZZ
Z-----Z
Z-ZZZ-Z
Z-Z-Z-Z
Z-ZZZ-Z
Z-----Z
ZZZZZZZ

分数= 74-程序长度（程序越短越好）

5.数学

对于数字和数学不好的语言可能也适合人文专业。

不输入任何内容，而是以任何顺序输出2016年的72个整数除数，即正数和负数。可以以合理的方式将输出格式化为字符串或列表。

例：

-1, -2, -3, -4, -6, -7, -8, -9, -12, -14, -16, -18, -21, -24, -28, -32, -36, -42, -48, -56, -63, -72, -84, -96, -112, -126, -144, -168, -224, -252, -288, -336, -504, -672, -1008, -2016, 1, 2, 3, 4, 6, 7, 8, 9, 12, 14, 16, 18, 21, 24, 28, 32, 36, 42, 48, 56, 63, 72, 84, 96, 112, 126, 144, 168, 224, 252, 288, 336, 504, 672, 1008, 2016

分数= 74-程序长度（程序越短越好）

6.神秘主义

（不，不是那样。）我们在PPCG上喜欢我们神秘的东西，而奎因就是一个很好的例子。

根据通常的奎因规则，写下尽可能长的奎因。quine是一个不需输入即可输出的程序。

分数=程序长度（程序越长越好）

具体规则

• 在这6个挑战中的每一个中，您的程序都必须是按您喜欢的方式重新排列的74个时间胶囊字符的子集。它可能是一个空子集，也可能是一个不正确的子集，因此每个程序最多只能包含0个字符，最多可以包含74个字符。
• 输入/输出/代码末尾的单个尾随换行符在任何地方都可以，因为某些语言需要这样做，否则就很难避免。
• 除非另有说明，否则根据我们的默认设置，每个挑战都可以作为功能或完整程序来完成。
• 所有挑战都必须用相同的语言完成。
• 您必须使用地球上任何地方在 2017年之前制作的语言（或一种语言的版本）。
• 无论您是否在时间胶囊中添加了字符，欢迎任何人回答。

_{在您自己的挑战中随意使用2016年时间胶囊角色。}

草甘膦，74 +（74-36）= 112

1.运行（74字节）

!!#%QTQT@=A@$!!$)()*!&))+...1449:@HILOQZ\\^`````````eefmpx|||{~~~~~~y~|~ ~

2. IO（36字节）

!!!#!$!$4419TAHT\ee\OQQQ))*+)..)|~~~

说明

Glypho似乎是应对这一挑战的不错选择，因为它并不关心实际使用的字符。而是查看四个字符的组，并根据这四个字符中的重复模式选择命令。由于时间胶囊字符串之间有很多重复项，因此我们可以编写的程序相当灵活，除了我们限于18个命令的程序（在Glypho中不是很多）。虽然这可以让我很轻松地解决前两个问题，但我怀疑Glypho能否以很少的字符运行其他两个问题。

我已经使用从2006年6月23日在Wayback机器上检索到的Java解释器对它们进行了测试，该机器使用的命令映射略有不同：

0000 n
0001 i
0010 >
0011 \
0012 1
0100 <
0101 d
0102 [
0110 +
0111 o
0112 *
0120 -
0121 ]
0122 !
0123 e

该运行程序转换为：

1d-+[...]

...我没有打扰的垃圾在哪里？

1      Push 1.
d      Duplicate.
-      Turn into -1.
+      Add. Gives 0.
[...]  Skip the rest because the top of the stack is zero.

该IO程序转换为：

id1-+o1+o

这是做什么的：

i   Read a character.
d   Duplicate.
1   Push 1.
-   Turn into -1.
+   Add to character, i.e. decrement it.
o   Output it.
1   Push another 1.
+   Add to character, i.e. increment it.
o   Output it.

CJam，74 +（74-14）+（74-26）= 182分

1.运行（74字节）

e# !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````efmpxy{||||~~~~~~~~~

移动e#到最前面注释掉整行。

2. I / O（14字节）

9`)ZH*+~):Q(Q)

丹尼斯节省了8个字节。

说明：

9`                   Push "9".
  )                  Extract character '9'.
   ZH*               Push 3 * 17 = 51.
      +              Add to get character 'l'.
       ~             Eval as CJam code. Command l reads a line.
        )            Extract the only character from the input line
         :Q(         Assign to Q and decrement
            Q)       Push Q and increment

3.可分支性（26个字节）

4`)4Z|`I!`|~^~~T$AT$*%H(=+

说明：

4`)                            Push character '4'
   4Z|`                        Push 4 | 3 = 7, stringify
       I!`                     Push !18 = 0, stringify
          |~                   Setwise or and eval to get 70
            ^                  XOR to get 'r'
             ~                 Eval to read input
              ~                Eval the input as CJam code to turn
                               it into an integer
               T$              Duplicate it
                 A             Push 10
                  T$*          Duplicate that and multiply → 100
                     %         Mod the copy by 100
                      H(=      Compare to 17 - 1 = 16
                         +     Add the result (1 or 0) to the original

我待会再看。（编辑：我怀疑它们是否可能，没有块或字符串文字……也许是数学？）

J，得分71 +（74-19）= 126

任务1，长度71

AHILO=:( |T`T`Z`e`e`f`m`p`x`y|.~~%~@{|~^|Q@Q@Q+.*.449!~!~!~!!#$$&1\\~~)

这将动词定义为AHILO内部。没用过：

)))

我认为没有比这更长的时间了。

任务3，长度19

+($#~$~4)=1e4|&%:*~

无限制地执行此任务的方法是+16=100|]，其内容如下：

        ]  Input
    100|   mod 100
 16=       equals 16? (Evaluates to 1 or 0)
+          Add to input.

我们有+，=或几本|，也很容易处理]，但是数量更成问题。这是计算输入模100的第一部分：

1e4|&%:*~
       *~  Input squared (multiplied with itself).
1e4        The number 10000.
   |       Perform modulo
    &      on
     %:    their square roots.

完成后，让我们产生数字16。最简单的方法是with *~4（将4乘以自身），但是我们已经使用过，*所以这是被禁止的。相反，我们将进行一些数组操作。

($#~$~4)
    $~4   Reshape 4 to shape 4, resulting in the array 4 4 4 4.
  #~      Replicate wrt itself: replace each 4 by four 4s.
 $        Take length.

工作

2

这绝对是不可能的。操纵字符值的唯一方法是a.和u:，而我们都无法访问它们。

现在，如果我们可以使用a而不是A，那么这将是一个解决方案：

Q{~(*^.4%9 1)+I.~&Q=:a.

使这个工作最困难的部分是产生数字-1。

Q{~(*^.4%9 1)+I.~&Q=:a.
                     a.  The array of all bytes.
                  Q=:    Bind it to Q
              I.~&       and find the input's index in it.
   (        )+           Add the following array:
    *                    Signum of
     ^.                  logarithm of
       4%                4 divided by
         9 1             the array 9 1.
                         This evaluates to -1 1.
Q{~                      Index back into Q.

4

(*.1:"|~@+.)

这会生成外壳的形状，但是我似乎找不到找到生成字符的方法。唉。

5

诚然，这似乎是在J中最容易完成的任务。但是，如果没有i.，这将非常困难。

6

如果没有类似伪造的quine之类449的字符串，这可能是不可能的，因为胶囊字符串不包含引号或其他任何产生J字符串的方式。

PowerShell-总得分：74

1.跑步-得分：74

#~= `TeQ.)`~H|$QL4yA)\*`!^O$1)!Z`!`~|\`&T@!x+e(f|Q`.|!4%.{~`:~~)m@~`@p~I9~

由于在PowerShell中这非常困难（据我所知，使用给定的字符不可能获得输入的所有可能方法），因此我至少决定将第一个挑战随机化，因此我们并不都直接复制示例从职位。

因此，这是一个随机的挑战1答案生成器（对于#带有注释的语言）：

'#'+$(-join([char[]]' !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~'|Get-Random -Count 73))

在线尝试！

模因，得分（62 65 + 70）135

1：运行

我删除了所有反引号（`）和数学运算符。他们之所以冲突是因为没有足够的数字来满足每个一元和二进制运算符。我留了一些，导致+3个字节。结果程序：

 !!!!!#$$%&())))...+1^4*49:=@@@AHILOQQQTTZ\\eefmpxy{||||~~~~~~~~~

我不知道为什么以及如何运作。至少它不会引发任何C＃运行时异常，因此不会崩溃。

6：Quine

您知道，如果那74个字符中的某个位置存在-小写或小写字母q，这将太容易了。我为I操作员感到高兴，至少。

1/4I

这段代码不是很明显。这是一个解释：

1    Set object to 1 (1)
/4   Divide by 4     (0.25)
I    Set object to a fraction string. (1/4)

分数字符串（例如1/4）显示在末尾，以I表示。该I操作通常是没用的，我添加它用于其他的手段，但是，嘿，它的工作原理是这样！

以上代码无效。愚蠢的我没看到74个字符不包含单个除法运算符，即正斜杠（/）。我想出了一些其他东西：

True

说明：

T    Set object to "true" (bool value)
rue  None of these are valid tokens, so they don't get interpreted.

输出True（由于C＃处理Boolean.ToString()大写而不是小写的方式）。不知道这是不是一个合适的方法，与此同时，我仍在努力寻找一个有效，真正合适和直观的方法。

也许也可以解决I / O和数学难题，但我缺少74个字符中未包含的特定标记（字符）。

Brainfuck，74个字节

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

我只需要。

说明：

不是有效的Brainfuck字符的任何字符都将被视为注释。实际运行的唯一代码是：

.+..

这不会产生可打印的输出，因为ASCII中的0和1都不是可打印字符。但是，它不会导致错误，因此我们成功完成了第一个挑战。

Mathematica，得分62

如果有人可以在Mathematica中进行2-6的挑战，我会感到惊讶。这是我对挑战1所做的最大努力：

A:=1.`!#&@(4`+4.`*9.`^$$H~I~L~O~Q~Q~Q~T~T||Z||e@@efmpxy%)!!!!

A用一个常数值定义一个漂亮的愚蠢函数。12个未使用的字符是：

)))\\`````{~

八度，得分74

1.运行

x =@(AHILOQQQTTZeefmpy)+.1||!!!!!~~~~~~~~~4.^.4||9%#$$)))*@@\`````````{\&:

这些字符中的50个是函数的一部分，而其余24个则不是。

它能做什么：

x =@(AHILOQQQTTZeefmpy)创建一个x可以将变量AHILOQQQTTZeefmpy作为输入的函数。

要了解其余内容：

a||ball()在a和上调用函数b。如果其中一个或两个都返回true，则||运算符将返回true。

!a而~a在这里是指同样的事情，他们都not(a)。

a.^b 是元素的力量 (a(1)^b(1), a(2)^b(2) ...)

继续说明

我将逐步简化每个步骤：

4.^.4||9  % This is 4 raised to the power of .4||9
          % .4||9 is true, since both .4 and 9 are true
          % true is evaluated to 1 when used in an expression
...       % 4 raised to the power of 1 is simply 4.
4         % The above expression simplified

和：

!!!!!~~~~~~~~~4  % ! and ~ are the not() operator, so this is equivalent to:
not(not(not(not(not(not(not(not(not(not(not(not(not(not(4))))))))))))))

有偶数个not，所以这相当于not(not(4))是true或1。

+.1||1      % This is equivalent to all(+.1) | all(1), which returns true

其余的被注释掉。

*> <>，总分= 74

1.跑步，得分74

f:4%*e+e14=p!Q H@~^)$.`~A|Q)~`\ZI~O.~@``#|9@)T\T`(!``|`~!y!`)Q~$x.|m~~&!L{

在这里尝试！

没有;角色，这很难做到。我实际上以为有一会儿是不可能的，直到我看到%，我已经基本放弃了。

这也是有效的> <>程序。

解释（不相关的部分被省略）

f:4%*e+e14=p!Q 

f:               copy 15
  4%             pop 15, push 15%4 (3)
    *            pop 15 and 3, push 15*3 (45)
     e+          pop 45, push 45+14 (59, ascii ";")
       e         push 14
        14=      push 0
           p     replace coord (14, 0) with ";"
            !Q   skip Q (this is just filler)
              ;  end execution

面临的挑战

我可能会尝试其他挑战...它们将非常困难，并且可能会以怪异的方式弯曲规则，但是自由使用|镜子和!蹦床应该至少会带来另一个挑战。

这些挑战特别困难，因为我们不允许任何带有*> <>（o和n）的输出，甚至不允许使用函数调用（C），函数返回（R）或程序终止符（;）。即使我们也缺少i输入，我们仍然可以将输入放在堆栈上，这是一个加号。另一个p好处是，我们获得了一条指令，这使我们可以替换代码箱中的一条指令。这可能可以多次使用（尚未找到一种实用的方法），这将开始使其他程序看起来更有可能（因为我们能够生成两个或更多指令）。

Haskell，得分63

1.运行：

(!!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~)fmpxyAHILOQQQTTZ e=14`e`49

不使用的是)))```````{。Haskell中的注释是--或{- ... -}，因此没有简单的全部注释版本。

这段代码定义了一个!!!!!#$$%&*+...:@@@\^||||~~~~~~~~~带两个参数的中缀运算符：

1. fmpxyAHILOQQQTTZ 它被忽略，因此可以是任意类型
2. e，该函数必须是带有两个数字的函数

e然后在函数体中使用`-infix表示法将其应用到14和49 。

用法示例：

Prelude> () !!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~ (*)
686

将运算符应用于()，空元组和(*)乘法运算符，因此14*49 = 686计算得出。

在线尝试！

其他挑战

我怀疑是否还有其他挑战，尤其是因为缺少可能出现两次的变量名（只能是e（或类似eQT）），因为变量名不能以大写字母开头。当然，只有一个=也无济于事。

Pyth，目前为131（已完成2个挑战）

1.跑步74

# `````````!!!)!)!)*$AOeIefLmpxQ|Q|y|Q|~~~~~~~~~()${+%&\=@@@^\:.1.4.49TTZH

该程序不输入也不创建任何输出。

该程序使用$$，允许任意代码执行，因此被禁止在线运行，因此该程序在线运行。这是其编译输出，因此您可以看到实际运行的内容：

while True:
 try:
  (repr(repr(repr(repr(repr(repr(repr(repr(repr(Pnot(Pnot(Pnot()))))))))))))
  imp_print(Pnot())
  imp_print(Pnot())
  imp_print(times(AOeIefLmpxQ|Q|y|Q|~~~~~~~~~(),uniquify(plus(mod(("=" and lookup(lookup(lookup(Ppow(":",.1),.4),.49),T)),T),Z))))
  imp_print(H)
 except Exception:
  break

用Pyth不会出错的任意字符编写程序是相当棘手的。我给自己设定了另一个挑战，那就是要求该程序无需用户输入即可运行。

第一步是使用#所有错误。接下来，我们需要避免因错误的~，I并且L，每个都有自己的详细信息。这是通过将它们放在内实现的，将它们$$嵌入到输出编译中，从而使它们服从Python的编译规则，而不是Pyth的规则。最后，为了避免接受用户输入，将各种arity 0令牌（变量和类似变量）放在末尾，并将Qs移入该$$块内。

2. IO

如果可能的话，这将是非常困难的。除之外.f，不存在任何创建任意字符串或字符的Pyth函数，并且创建任意字符的工作效果很差。

3.分支能力：74-17 = 57

|&x%Q*TTye|LZ9Q+1

在线尝试

等效的Pyth程序为：

?n%Q100 16Q+1

该代码将输入mod 100进行比较，将其与16进行比较，然后使用三进制在输入和输入加一之间进行选择。由于字符限制，我做了一些替换：

• ?我使用|&，orthen 而不是三元组，and它具有相同的功能，除了在输入为零时会中断的情况之外，但是由于我们保证输入为正整数，所以很好。（可以解决此问题，而无需添加其他字符，但是这种方式更简单。）

• 与其直接比较两个数字x，不如将它们的XOR与进行比较，当且仅当它们相等时，它才为零。

• 由于已初始化为100，因此我没有用它直接编写。*TTT10

• 16我没有直接编写，而是使用生成了它ye|LZ9。|LZ本质上起范围函数的作用，因此|LZ9给出[0, 1, 2, 3, 4, 5, 6, 7, 8]。e接受列表的最后一个元素，给8。y将其加倍，16根据需要提供。有了一个+或多个附加项，*我可以保存一个角色，但是它们在其他地方都更有用。

还有更多！

Ruby-得分：74

1.运行

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

迎接挑战。

JavaScript（ES6），得分= 74

1.运行，74字节

Z=` !!!!!#$$%())))...1449:@@@\AHILOQQQTT^\`eefmpxy{||||~~~~~~~~~`*``+``&``

6.神秘主义（无效）

记录下来，我建议的提法是：

1.4e+49

如下面的评论所述，它被证明是无效的。

视网膜得分74

1.跑步，得分74

)))` !!!!!#$$%&()*.+..1449:=@@@AHILOQQQTTZ\\^````````eefmpxy{||||~~~~~~~~~

我将多余的括号移动到配置中，以使它们在正则表达式中保持平衡。在此`之后，我也向右移动，并更改+.为.+。

在线尝试

其他的可能是不可能的，因为没有换行符。也没有-音译或d数字字符类。

点子得分74 +（74-19）= 129

这么多带有nary的反引号都可以看到，单引号或双引号！

任务1，得分74

`` `\``!!!!!`#$$%&())))*+...1449:=@@@ILOQQQTTZ\^efmpx{|||~~~~~~~~~`|`yeAH`

基本上只是反引号中的一系列模式（regex）文字，最后一个被打印出来。由于反引号的数量奇多，因此我们必须对其中一个（`\``）进行反斜杠转义。在线尝试，-w添加标志以证明没有警告生成。

任务3，得分55（长度19）

e+!!e%(1.#x.!9)=4*4

使用一个比较奇怪的输入法-第五个命令行参数-这是可能的。在线尝试！

                     e is 5th cmdline arg; x is empty string
       1.#x.!9       Concatenate 1, 0 (length of x), and 0 (not 9)
    e%(       )      e mod 100...
               =4*4  ... equals 16?
  !!                 Logically negate twice
e+                   Add to e (+1 if number mod 100 is 16, +0 otherwise)
                     Expression is autoprinted

其他任务

可以通过与上述任务3相同的方法来获取任务2的输入。问题出在将其转换为ASCII码并转换回一个字符。前者可以用完成A，而后者需要C，或者可以索引到PA变量中。没有的话，构造和评估代码是不可能完成的V。我认为这项任务是不可能的。

即使没有受限的字符集，任务4也具有挑战性。猜测是，将需要列表（不使用[]定界符或RL（重复列表），并且只有一次使用AL（附加列表）的可能性-不太可能）或可能具有CG（坐标网格）或MC（地图坐标）的东西。

任务5处于可能性边缘。循环将很困难，因为不可能使用Fand和Map，并且不能使用构造范围,。可能有些事要解决T。增量可能是x:x+1多种多样的（x尽管显然有，而不是）。可以使用除数检查%。不过，我认为没有足够的字符（尤其是重复的字母）来完成所有需要发生的事情。

任务6看起来完全不可能。所有已知的Pip quines都有"。他们还使用R（替换），RP（repr）或V（eval），但均不可用。

实际上，得分（74 + 0 + 0 + 0 + 0 + 0）= 74

是的，胶囊字符串将按实际运行方式运行，因为实际消除任何错误，并且每个错误都变为NOP。

H@~*^)$.~+1A|Q)p~\Z!IQ~e:O.~@#|9@)Tf\eT`=(!|~!y!) Q~$x.4|m4~~&!L{%（在线尝试！）

但是，它将输出一团糟的东西（但也将输出其来源：3）。

但是，我将致力于其他挑战。

05AB1E-总得分：74

1.运行，74字节

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

导致错误的所有内容均被05AB1E跳过。整个代码行都是NOP。

在线尝试！

（滥用）PHP，74 + 74 = 148

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

PHP解释器只是简单地转储源代码，直到找到一个为止，<?因为我们缺少<那些字符的所有排列都是运行中的。我猜这并不比使用内置的quine命令还差：P

Mathematica，得分68

A：= .1％*。44y＃+。9 ^`H @`$ I @`L @（`$ O〜`Q〜`Q〜`Q〜`T〜T〜Z〜e〜e | f | m | p | x）!!!!!＆\

注意尾随换行符。我不相信Mathematica可以解决任何其他挑战。

迷宫，得分74

AH)
IL)
OQ:
`=!)~`{+4.@ !!!$$%&(*..149@@TTZ\\^```eefmpxy||||~~~~~~~~
`Q#
`Q)
``!

我很确定这些字符的任何组合都会产生一个有效的迷宫程序，但是为了使它至少更有趣一点，它会2016逐位打印出来。（总之：将2推入2堆栈，弹出/打印一个，将另一个移至辅助堆栈，打印0，将2推入1堆栈，弹出/打印1，递增，按位取反，取反（最后1此时为a 3），将其2与辅助堆栈中的总和5 * 10 + 4 = 54，以ascii值打印，终止）

由于@终止程序，大多数长行都将被忽略。

挑战2、3和4是不可能的，因为Labyrinth的输入命令都不可用（,或?），并且5或6我什么都没想。

SmileBASIC，48分

挑战1：

@LOQQQTTZ A$=H$+@efmy+@9414*!exp(!!.||!!.#||I%):

说明：

@LOQQTTZ 'label
A$= 'set value of A$ (string)
H$ 'string
+@efmy 'adds label, interpreted as string literal
+@9414 'adds label, interpreted as string literal
*!exp( 'multiplies by logical not e^x (= 0)
!!. 'not not 0.0 (= 0)
||!!.# 'or not not 0.0 converted to a float (= 0)
||I% 'or I% (integer variable)
: 'equivalent to a line break, does nothing here

其他：

没有可用的输入/输出命令，因此其余命令是不可能的。

不过，对于不使用注释的真实语言来说也不错。

MATL，总分74

1.跑步，得分74

`4.e4 1.$!!!!!T+Zyf9.)AH^ILx@Q@Q@Qm||||~~~~~~~~~:=Tp*O%#$&()))\\````````e{

一切%都是实际的代码。%是注释符号，因此将忽略其右侧的字符。

程序输出1无错误。

在线尝试！

bash，得分74

1：运行。我们可以全部跑74

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

6：神秘主义：

空程序是bash中的一个quine。

没有任何空格字符，列表上的其他内容将无法完成。嗯，我有bash参赛作品。

Perl 6，总分74

1.跑步，得分74

my @TOTAL=$!||(e*4...9^e)Z+1~4||!!Q`{fp)))\#\&`~Q!```HI````!~Q:x~~~$~@~@~%

没意见。
（只需将放在#最前面即可对所有内容进行评论，但这很有趣。）

工作

这是Perl 6语言的子集，仅使用允许的字符：

常数：e

类型名称：IO

功能：exp

方法：
    在IO类型上：.e .f .x
    （...可能更多。）

运营商：中缀：字首：
    ----------- + ----------------------- + ---------
    数字：| + * + ^ + | +＆％| + + ^
    字符串：| 〜x〜^〜| 〜＆| 〜
    布尔值：| || ~~ | ！
    路口：| ＆^ |  
    其他：| =：= Z .. ... |  

句法：
    数字文字：1 4 9
    字符串文字：Q` Q！！等等
    shell命令：Q：x``Q：x！！等等
    无论是什么明星：*
    变量：我的\ $ @＆
    分组：（）
    注释：＃＃`（）
    空格：

阻止挑战2-6的直接障碍是似乎没有办法进行I / O：

• 如果我们假设有一个名为的文件f，我们可以使用Q`f`.IO.e它来检查它是否存在或Q`f`.IO.x检查它是否可执行。但是我们无法读取或写入。

• 我们可以使用Q:x` `运行shell命令（假设我们找到一个字符）。但是我们不能将任何内容插值到其中，因此它只对阅读有益，对写作不利。

• 由于没有右括号，因此我们无法创建{1 + $_}自动返回其最后一条语句值的块lambda（例如）。

• 我们可以使用星号来表示表达式lambda（例如1+*），但是我们只能接受一个参数，仅引用一次该参数，并且在可使用的语法/运算符中受到更大的限制。

卢阿，得分31

1.跑（74分中的31分）

AHILOQQQTTZeefmpxy=1.%4+(4.*9.)

果冻 74分

1. 跑步，74

 ||||!!!!!$$~~~~~~~~^@=@~%449:`e@`e`QAHILOQQTTZ{\\f`m`p`x`y`&`*.#1+.()))).

不确定如何执行其他任何操作。

///，得分：146

1.跑步，得分：74

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

6. Quine，得分：72

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ^`````````eefmpxy{||||~~~~~~~~~

是的，当代码中没有任何正斜杠或反斜杠时，它只会打印自己。