您的挑战很简单。您需要编写一个程序，该程序可以在发布所用语言的那年将其打印到STDOUT或文件中。因为这是一个简单的任务，所以它必须用尽可能多的不同语言编写。

您的分数是正确打印的不同年份的总数。

对于您使用的每种语言，您必须

• 指定您使用的语言版本。（如果有多个版本）

• 指定该版本首次发布的年份，以及

• 提供指向页面的链接，以证明您的版本/语言的日期。

只要指定了版本号（如果适用）和发布日期，上述任何一项都可以视为发布日期证明。

• 维基百科页面。

• 一个esolangs页。

• 语言的官方网站。只要有发布日期，一个github页面或类似页面就算在内。（最新提交不计算在内，除非代码中有版本号）

如果该语言没有多个版本或发行版本，请使用该语言的初始发行日期。

同日而语的次要版本都算作不同的语言，只要他们来自不同的年份，仍然产生正确的输出。您不得使用任何可为您提供有关所用语言当前版本的信息（包括发行日期）的内置程序。例如，这是无效的python提交：

import platform
i = platform.python_version()
if i == '3.5':
    print(2015)
if i == '3.4':
    print(2014)
if i == '3.3':
    print(2012)
...

无论哪种提交方式都能正确打印出最鲜明的年份获胜！

规则

• 每个程序都必须打印出语言年份，仅此而已。允许使用尾随换行符（Windows样式或* nix样式）。

• 没有程序可以接受任何输入。

• 如果出现平局，则以字节计的最短代码获胜。您可以为此使用任何编码，但是所有程序必须使用相同的编码。

• 只要仍将正确的输出打印到STDOUT或文件中，任何程序都可以打印到STDERR，或抛出运行时/编译时错误和警告。

• 不同的语言可能使用不同的IO方法，但它们大多数都是完整程序（此挑战所不允许的功能），并且遵循我们允许的默认IO方法之一。

高尔夫快乐多语！

2D编程语言简史：16（+2）年

v19977/2{@{{4{\_______>/02&&&#????        *    P+++++1P1P-1P+1E     *                         *
\'\02'oo100@n590@n;                       *                         *                         *
>"8991",,,;5-;,@                          *                         *                         *
   *                                      *                         *                         *
  \ *              ++++++++++++++++++++++++  ++++++++++++++++++++++++  ++O--OO++++++++OX*******      *
     *   #2018O@       *                  *      *                  *      *                  *      *
      *                *                  *      *                  *      *                  *      *
       *               *                  *      *                  *      *                  *      *
        *           ****    ****          *   ****    ****          *   ****    ****          *   ****    *****
         *         *   *   *    *         *  *   *   *    *         *  *   *   *    *         *  *   *   *
          *        *   *  *      *        *  *   *  *      *        *  *   *  *      *        *  *   *  *
           *      *    * ****     *       * *    * ****     *       * *    * ****     *       * *    * ****
            *     *    *     *            * *    *     *            * *    *     *            * *    *     *
R"2014";     *****      *******       ******      *******       ******      *******       ******      *******

 x
x%"2010"x
 x

$'main'        \/\/\/\
 \-[2005]o-#   \++++++\
               /++++++/
               \++++++\
               /++++++/
               \/\/\/\++.--..+++.#

S1^2^2^6^8MAOUOAOOF

      /K:0:1:@

  >      "7102"4&o@

|        }+++++[>++++++++++<-]>.--..++++++.@

我是否提到我喜欢2D编程语言？

1993年：Befunge

一切（请参阅最后一节）所用的语言。在Befunge，您可以重定向与控制流<v>^，但现在无处不在的镜子\，并/没有一个东西呢。在无政府状态高尔夫上使用的Befunge解释程序将忽略未知命令。我们可以使用它来区分Befunge家族和> <>家族。因此，Befunge执行的代码是这样的：

v
\
>"8991",,,;5-;,@

压入"8991"将各个字符压入堆栈。,,,打印其中的前三个。然后;未知（我们将使用它来区别Befunge 98），5-将其8变成a 3并,在@终止程序之前将其打印出来。

1997年：维尔德

编写解决方案，这部分花了我大概只要写所有其他和他们配合在一起......

维尔德只知道两个符号：空间和其他所有东西。指令指针尝试遵循由非空格字符形成的路径，从左上角对角线开始，并始终尝试尽可能笔直。路径中的折弯形成实际的指令（转弯的程度确定要执行的指令）。因此，Wierd看到的代码是这样的：

v1997                                     *                         *                         *
 '                                        *                         *                         *
  8                                       *                         *                         *
   *                                      *                         *                         *
    *              ++++++++++++++++++++++++  ++++++++++++++++++++++++  ++O--OO++++++++OX*******      *
     *                 *                  *      *                  *      *                  *      *
      *                *                  *      *                  *      *                  *      *
       *               *                  *      *                  *      *                  *      *
        *           ****    ****          *   ****    ****          *   ****    ****          *   ****    *****
         *         *   *   *    *         *  *   *   *    *         *  *   *   *    *         *  *   *   *
          *        *   *  *      *        *  *   *  *      *        *  *   *  *      *        *  *   *  *
           *      *    * ****     *       * *    * ****     *       * *    * ****     *       * *    * ****
            *     *    *     *            * *    *     *            * *    *     *            * *    *     *
             *****      *******       ******      *******       ******      *******       ******      *******

该1997顶部并没有真正执行，但奇怪的让我们从源代码，这是一个阅读很多比试图构建四位数字本身的字符代码（即使它看起来并不像它短.. ）。我不想将整个过程分解，但是您可以清楚地看到四个重复的部分。这是因为我们首先存储1在堆栈上，然后这四个部分中的每一个都使this递增1，然后分支。底部分支推另一个1，在这些坐标处检索源字符并进行打印，而顶部分支将重定向到下一部分。您可能会奇怪，为什么路径的末端如此之长，所以这是因为，当Wierd到达路径的末端时，它会尝试跳至附近的路径，然后再决定终止当前分支。为避免这种情况，我们需要将这些末端与其他任何代码保持足够的距离。

1998年：Befunge 98

Befunge在1998年进行了相当著名的更新，它具有非常严格的规范，可以将其推广到任意尺寸（我也认为是任意拓扑）。不过，它在很大程度上与Befunge向后兼容，这使得将两者混音相当容易。该Befunge仍然没有任何镜像，因此执行的路径与Befunge 93相同：

v
\
>"8991",,,;5-;,@

不同之处在于Befunge 98不会忽略;。相反，它的行为有点像注释，因为所有命令，直到下一个命令;都将被忽略。通过这种方式，我们不认为递减8到3和打印1998原样。

2001年：太空奇兵... 乒乓球

2001年是Piet的一年，但我真的不希望将图像文件与所有其他程序混合使用，因此这是一种鲜为人知的2D语言。它似乎具有很多功能（我们将不使用）。感谢Sp3000 查找原始解释程序（这是官方网站的存档版本中唯一的死链接）。

乒乓球有点不寻常，因为它只有镜像，没有<v>^重定向器。因此v19977，它从头开始移动，然后撞到将其包裹到底部的镜子。然后，相关代码为：

v19977/

...

      /K:0:1:@

...

实际的代码非常简单：Kpushs 20，数字将自己推送，:打印整数并@终止程序。

2003年：SNUSP

这是第一语言，它使事情变得容易一些，因为SNUSP支持显式的入口点。该入口点用标记$。从一些关于esolangs的文章来看，这种语言启发了其他一些语言，但不幸的是，最终，它只是Brainfuck的派生词。也就是说，我认为将当前单元格设置为48的方式非常简洁（并且从esolangs文章中被盗）。这是代码的相关部分：

$'main'        \/\/\/\
               \++++++\
               /++++++/
               \++++++\
               /++++++/
               \/\/\/\++.--..+++.#

那是24 +秒，并且镜像通过每个IP发送IP两次。

2004年：Axo

无论出于何种原因，这种语言确实有<^>转向器但不是通常v它使用%。因此，这只是跨第一行。相关代码为：

v19977/2{@{{4{\

我们从几位开始，进行除法。然后2{打印2，@清除堆栈。{{打印两个（隐式）0。4{打印4并\终止程序。

2005年：铁路

2005年是艰难的选择。不为别的，今年我才找到尽可能多的2D语言，并有调整和拱门，两者开始以较低的左上角（这将使得他们很容易添加）。我虽然喜欢Rail，但由于它有一个明确的入口点，因此也不难添加。Rail寻找一条$'main'始于的线，并开始从向东南移动$。这意味着相关代码为：

$'main'
 \-[2005]o-#

该\和-只是跟踪（无操作）。的[2005]是一个字符串，其o打印之前#终止程序。

2006年：BestFriends.js

二维Brainfuck。今年还有另一种有趣的语言叫做Black，它从坐标(3,3)（从1 开始）开始，这在多语系中也很有趣。我找不到翻译。因此，我们将不得不使用另一种BF衍生物...

关于这一点的有趣之处在于，它不会像大多数其他2D语言一样将网格格式化为带有换行符的行。而是|用作行分隔符。由于我没有使用|任何其他语言，因此我可以简单地|在最后一行加上，就BF.js而言，这使得程序的其余部分仅占一行。然后相关代码如下（将|转换为实际的换行符）：

v19977/2{...
        }+++++[>++++++++++<-]>.--..++++++.@

BF.js 既不 使用<v>^也不使用镜像。重定向控制流的唯一方法是{}将IP方向旋转90°。因此，这些花括号将IP移至第二行。其余的是普通的Brainfuck解决方案（不是特别好打），它将一个单元格设置为50（代码点的2），然后2006通过将值偏移一点来进行打印。@终止程序。

2008年：BrainSpace 1.0

今年，我真的很想使用DOBELA，它使用多个入口点，看起来像Fission和Ziim的挚爱。不幸的是，我无法让翻译工作。因此，这是另一个BF导数（我保证是最后一个）。

与最后一个相对，这一个既 了解<v>^又镜像，因此相关代码为：

v
\'\
  8

  \ *              ++++++++++++++++++++++++  ++++++++++++++++++++++++  ++O--OO++++++++OX

这个没有通常的BF风格的[]循环（相反，您需要形成一个实际的2D循环），所以我决定50对它进行硬编码，因为无论如何我都从Wierd连续获得了很多字符。请注意，'和8是被忽略的，*是条件蹦床，我们可以忽略，O而是Brainfuck的.。该X终止程序。

2009：> <>

至少在这些部分附近，可能是最受欢迎的Fungeoid（Befunge本身除外）。> <>既有<v>^和镜像，也有字符串文字，所以执行的代码是这样的：

v
\'\02'oo100@n590@n;

字符串文字通常用于跳过\我们用于BrainSpace 1.0 的字符串，但是在使用它的同时，我们也可以推入前两个字符。oo打印它们。然后100推三位数字，@将前一位推到底部，然后n在0下面打印。我们再次执行相同的操作以590打印9。如果您想知道为什么我不只是2009按原样打印，请等待2015年。;终止程序。

2010年：红衣主教

这个很简单，因为它在处有一个明确的入口点%。但是，这个在所有方向上都会创建4个IP（因此，我想应该是语言名称），我们需要摆脱其中的3个。以下是相关代码：

 x
x%"2010"x
 x

好吧，是的 （在Cardinal中，字符串模式直接打印，而不是将字符压入堆栈。）

2011年：RunR

这是另一种带有显式入口点的语言（由David Catt创建了其他一些非常出色的esolang），这一次是在S。这使相关代码成为这一部分：

S1^2^2^6^8MAOUOAOOF

RunR有点有趣，因为大多数操作都使用某种寄存器，并且需要将值显式移动到堆栈以进行二进制操作。这些数字将寄存器值设置为自己，^并将当前寄存器压入堆栈。然后M是乘法（从堆栈弹出的寄存器时间值），U是减法，A是加法，O输出。F终止程序。

2012年：Ropy

像Wierd一样，Ropy尝试遵循非空格字符的部分，但是这里的折弯不能确定命令。实际上，事实证明Ropy与我自己的迷宫更相似，因为所选择的方向取决于堆栈的顶部。但是，我们实际上不必为此担心，因为Ropy只是沿着第一行移动：

v19977/2{@{{4{\_______>/02&&&#????

到目前为止，我们可以忽略很多东西>。我们需要知道的是，此时栈顶将是a，4而栈顶将在其2下方。

>复制4，/正在除法将其转换为1。然后我们推02。&&&以相反的顺序连接堆栈的前四个数字，即2012。#输出它。????只是清除堆栈，否则将同时输出堆栈的顶部。

感兴趣的一点是，第二7的19977是因为粘稠的补充。/Ropy中的除法top / second（与许多基于堆栈的语言的通常顺序相反）在哪里7 / 9给出0。如果堆栈顶部为零，Ropy会沿其移动方向做一些疯狂的事情，因此我们需要推动另一个7以确保堆栈顶部保持正数并且Ropy继续向东移动。

2014年：裂变

凭借其明确的入口点，这一点很容易。RDLU在相应的方向上创建原子（指令指针），因此相关的位就是这样：

R"2014";

请注意，U在源代码中也有一个，但是那个原子最终碰到了*Wierd中的一个，它终止了程序（并且这个原子比R打印需要的时间长得多2014）。

2015年：Gol> <>

Sp3000功能更强大的> <>派生类。它在很大程度上与> <>向后兼容，因此执行的代码仍然是：

v
\'\02'oo100@n590@n;

但是，@更改了的旋转方向，这是区分多面体中的<<>和Gol> <>的标准技巧，因此该图15代替09。因此，该程序的后半部分很奇怪。

2016年：CSL

CSL非常有趣，因为命令不会立即执行。相反，每个命令都被压入命令堆栈，e并且E可以用来从中执行命令。相关代码变为：

v19977/2{@{{4{\_______>/02&&&#????        *    P+++++1P1P-1P+1E

因此，E执行将执行整个命令堆栈，这意味着其前面的内容将反向执行。我们只需要查看*：

1+P1-P1P1+++++P*

的1蹬冰本身到数据堆栈中。+并且-是递减/递增。P打印堆栈的顶部。然后*尝试将堆栈的前两个值相乘。但是，堆栈为空，因此将终止程序。

在这一点上，我们使用的语言是在发布此挑战后发布的，因此，我并没有真正将它们计入分数，尤其是因为我自己创建了这些语言（不过考虑到了这一挑战）。但是，它们确实具有一些新颖的IP运动语义，这使它们很容易适应多种语言，同时也为2D语言展示添加了一些有趣的东西。

2017：爱丽丝

爱丽丝被设计为功能丰富的Fungeoid。与大多数（但不是全部）其他2D语言的一个有趣的区别是IP可以正交或对角移动。在这些命令之间进行切换还会更改该语言中几乎所有命令的语义。此外，Alice支持传统的<^>v方向设定器和\/镜像，但是镜像在Alice中具有非常独特的行为（这使得将Alice IP轻松引导到到目前为止尚未使用的代码部分）。

虽然大多数语言治疗\和/如同它们是在45°角度的反射镜，和IP作为光射线弹跳关闭它，爱丽丝将它们视为具有67.5°的角度（这是更接近实际的斜线字形的角） ，并且IP也通过镜像移动（因此使用了语言的名称）。由于该角度，镜子在沿正交或对角线方向的移动之间切换。此外，在序数模式下（即IP沿对角线移动），网格不会环绕，而是IP从边缘反弹（而在基数模式下，它会环绕）。

总而言之，爱丽丝执行的代码如下：

v19
\ \

...

  >      "7102"4&o@

...

IP照常从左上角开始，v向南发送。现在，会\反射IP向西北移动，并立即从网格的左边缘反弹（然后向东北移动）。1可以忽略不计，IP从最高边缘反弹到下一个东南方向。我们碰到了另一个\反映IP北部的情况。9也可以忽略该IP，然后将IP包装到网格底部。经过几行后，>为方便起见，我们将其向东重定向。然后"7102"按的代码点2017，4&o打印这四个字符并@终止程序。

2018：W

Wumpus是三角形网格上的第一种2D语言，它使代码移动完全不同（再次使我们可以轻松地到达代码的未使用部分）。因此，与其将网格中的每个字符视为一个小正方形，不如将它们视为向上和向下的三角形交替。左上角始终是一个向上的三角形。

Wumpus没有像这样的方向设定器<^>v，但是它有镜子\/。但是，由于使用了三角形网格，因此它们的工作方式不同于大多数其他语言。IP像往常一样照亮它们，但是您应该认为它们的角度为60°。因此，向东移动的IP最终将沿着网格的西北轴移动。

与大多数其他语言的另一个不同之处是，网格的边缘不环绕，而IP则从边缘反弹（好像这些边缘单元包含适当的镜像）。另一个有趣的小细节是，穿过三角形网格的对角线实际上看起来像源代码中的阶梯。

考虑到这一点，Wumpus执行的代码如下（.为了清楚起见，我在其中替换了空格：

v19977/
   02
  89
 ..
..
.....*...#2018O@

的v19977只是垃圾，我们可以忽略。/将IP发送到西北，在977从顶部边缘弹起的同时，它再次（从右侧）穿过IP 。然后，IP在到达2089左边缘再次向东反射之前，通过和一堆空间向西南移动。*也是垃圾 然后最后#2018推动2018，O打印它并@终止程序。

失踪的岁月

最后，一些关于我几年没有提到的笔记。

在研究2D语言以找到多年来可以用于多种语言的合适语言时，我发现与流行的看法相反，Befunge 不是第一种2D语言。该标题似乎由早在1991年创建的Biota拥有。遗憾的是，该语言没有任何输出，因此我无法使用它来应对这一挑战。

据我所知，1992年和1995年都没有创建2D语言。那几年我还没有涉及：

• 1994年：独立于Befunge创立了Orthagonal。这些语言实际上在语义上非常相似，但是Orthagonal实际上并未以2D布局源代码。相反，每一行都是一个(x, y, instruction)元组。我什至从创建者Jeff Epler那里获得了语言规范和原始解释器，但是最后，语法不是2D的事实使该语言不适合该多语言。
• 1996年：创建了Orthogonal，它是Orthagonal的继承人（由其他人创建），但是，出于这种目的，该多语言版本遇到了与Orthagonal相同的问题。
• 1999年：我能找到的唯一语言是克里斯· 普莱斯（Chris Pressey）的细胞自动机REDGREEN。不幸的是，与其前身RUBE相比，它似乎没有任何I / O语义。
• 2000年：克里斯· 普莱斯（Chris Pressey）的另一个蜂窝自动机称为noit o'mnain worb，但它也没有任何I / O。还有Numberix我没有试图让运行，我不知道它是否会在源代码中忽略非十六进制字符。
• 2002年：有弹响，没有I / O和ZT其语言规范让我惊恐万分。
• 2007：我在这里找到了三种语言。Zetaplex是基于图像的（因此不行），RubE on Conveyor Belts似乎要求标题的格式相当严格，这会与程序的第一行混淆。还有Quintopia的Cellbrain，但它似乎也需要特定的标头。
• 2013年：我再次发现了三种语言。进行大量的重组可能使钓鱼成为可能，但是这将要求程序以有效的码头开始。从内存来看，Quipu的语法过于严格，以至于无法进行多语种翻译。和箭鱼是> <>家族的另一成员，可惜我一直没能找到一个解释。否则，可能很容易添加它。

如果有人感兴趣，这是已实现的2D语言的完整列表，按我能找到的年份（在发布此答案时）按年份排序。如果此列表中缺少任何内容，请在聊天中让我知道，因为我对完整列表非常感兴趣。

15年，Python

版本： 0.9.1，2.0.0，2.2.0，2.2.2，2.5.0，2.5.1，3.0.0，3.1.0，3.1.3，3.2.1，3.3.0，3.3.3，3.4.0、3.5.0和3.6.0a4。未链接的版本可以在下载页面上找到。

可以在这里找到0.9.1的发布日期。不幸的是，由于计算机上缺少旧版本和编译问题，我不得不跳过很多年。代表年份为1991年，2000-2002年和2006-2016年。

使用gzip压缩版本在Arch Linux上进行了测试。

# Note: This file needs a trailing newline due to 0.9.1

# 0.9.1: No bitwise operators
# This one errors out by division by zero.
try:
    eval('1&2')
except:
    print(1991)
    1/0

import sys

# 2.0.0: repr('\n') gives "'\012'" instead of "'\n'"
# == doesn't exist until Python 0.9.3 and <> doesn't exist in Python 3, hence we
# use <. Also, 0.9.1 doesn't have double quoted strings.
if repr('\n') < '\'\\n\'':
    print(2000)
    sys.exit()

# 2.2.0: email module still has a _Parser class - module revamped in 2.2.2
# I would use whether or not True exists as a name here, but weirdly "True"
# worked in 2.2.2 even though the docs say it was introduced in 2.3...
try:
    import email
    email._Parser
    print(2001)
    sys.exit()
except AttributeError:
    pass

# 2.2.2: a in b only works for strings a of length 1.
try:
    eval('"art" in "Martin"')
except TypeError:
    print(2002)
    sys.exit()

# 2.5.0: int() allows null bytes in integer to convert when given an explicit
# base.
try:
    print(int('2006\x00Hello, World!', 10))
    exit()
except ValueError:
    pass

# 2.5.1: pow overflows
# Note that we can't use ** here since that doesn't exist in 0.9.1.
if pow(2, 100) < 1:
    print(2007)
    exit()

# 3.0.0: round returns a float rather than an int.
if str(round(1, 0)) > '1':
    print(2008)
    exit()

# 3.1.0: bug caused complex formatting to sometimes drop the real part.
if format(complex(-0.0, 2.0), '-') < '(-':
    print(2009)
    exit()

# 3.1.3: str of a float is shorter than the repr of the same float.
if str(1.0/7) < repr(1.0/7):
    print(2010)
    exit()

# 3.2.1: For some weird reason, u'...' Unicode strings were disabled then
# re-enabled later.
try:
    eval('u"abc"')
except:
    print(2011)
    exit()

# 3.3.0: int still works without a first argument.
try:
    int(base=10)
    print(2012)
    exit()
except TypeError:
    pass

# 3.3.3: no enum module :(
try:
    import enum
except ImportError:
    print(2013)
    exit()

# 3.4.0: PEP 448 (additional unpacking generalisations) not implemented yet
try:
    eval('[*[1], *[2], *[3]]')
except SyntaxError:
    print(2014)
    exit()

# 3.5.0: No f-strings
try:
    eval('f"abc"')
except SyntaxError:
    print(2015)
    exit()

print(2016)

简短而甜美；8 个字节中的三个APL（K，J201，Dyalog 7.1）

1993+1^2

1993年...

K：除{2}之外的前1个整数{0}，即{0}；1993年– 在线试用！

J：1 ²＝ 1；1994年– 在线试用！

APL：LCM（1,2）= 2; 1995年– 在线试用！

10年，12种语言，2430字节

这个答案是我和用户1000000000之间的协作。

简短的语言列表：

Brainfuck    1993
Befunge      1993
Piet         2001
Whitespace   2003
Braincopter  2005
Grass        2007
Starry       2008
Paintfuck    2008
Brainbool    2010 (11111011010)
Python 2.7.2 2011
Fission      2014
Brainflak    2016 

这是代码：

P3v="";print(sum([ord(x)for x in"~~~~~~~~~~~~~~~y"]));"""{}{}     + + +---[.     + +..  '.. +. +.. +. +. +.] + + + + + + +(((((()()()()){}){}){}){})({({} +-[<() + + + + + + +>-()])}{}<[. + + + + + + + +..-------  `             +.[-]]>)[< '
 17 12 
# > 7*::,8 +:,,2 +,@<>R"2014";]*ne*e*es*s*swWWW*swWWWW*sw*e*e*e*eeev*wn*n*n*n*ne*e*se*s*s*s*sWWwWWWw**e*eeee*vwn*n*n*n*ne*e*se*s*s*s*sWWWw*eeee*e*ne*n*nWWWWWw*ne*nWWWWWWw*w*sw*se*sWWWWWWWw*s*WWWWWWwwwWWWWWWWWWWwWWWWWWWWWWwvwWWWwWWWWwvwWWwWWWwvwWWwWWWwvwWWwWWWwvwWWwwwwwwwwwwwWWWwWWWWWwWWWWWWWwWWWWWWWWWwWWWWWWWWWWWWWWWwWWWWWWWWWWWWwv `
255 0 255 255   0   192 192 0   192 192 0 192 192   192 255
255 192
255 255 192
255
255
0 255 255 0 255 255 0 255 255 0 255 255 0 192 192 192 255 255 255 255 255 0 192 192 0 0 255 255 255
255 0 0 255 0 192 192 0 192 192 0 192 192 192 255 255 192 255 255 192 255 255 192 255 255 0 255 255 0 255 255 0 255 255 0 192 192 255 255 255 255 255 255 255 255 255 255 255 255 0 192
192 0 0 255 0 192 192 0 192 192 0 192 192 0 192 192 192 255 255 192 255 255 192 255 255 0 255 255 0 255 255 0 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 0 0
255 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 255 255
255 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 0 192
192 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 0 0
255 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 0 255 255 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 255 255
255 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 0 192
192 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 0 0
192 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 0 0 0 0 0 0 255 255
255 0 192 192 0 0 255 0 0 255 255 255 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 255 255 255 255 255 255 0 0 255 0 0 255 0 255 255 0 0 0 0 192 192 0 0
255 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 0 0 0 0 192 192 0 192 192
#   """

为了使它适合响应，我将放弃整个TIO链接，而只是将链接发布到有效的解释器，用户可以在其中输入代码。这是为此目的的Pastebin链接。

皮耶特

该PPM文件格式，即皮特解释，我们可以使用从读取图像格式中的一种，有明文ASCII版本。使用此工具，我们可以将其他语言的代码作为垃圾内容嵌入到Piet和Braincopter读取的图像文件中。

图像如下所示：

并非所有图像对Piet都很重要。这是一个带有一行的版本，突出显示了Piet通过代码所遵循的路径：

尽管创建程序的方法有些复杂，但程序本身却非常简单。沿着图像的顶部，它被推1 10 10 10 2入堆栈。沿着侧面，它乘以三次，然后相加一次。它在底角输出结果（2001），然后暂停。

脑直升机

Braincopter是另一种视觉语言。它还依赖于相同的ppm图像文件来运行。由于npiet中的严格限制，我们的Braincopter代码只能使用原始Braincopter操作的子集。我们仅限于使用Piet中有效的颜色。这会将-操作员从Braincopter中删除。

这是Braincopter代码找出的路径：

Braincopter程序由于缺少-操作员而有些奇怪。青色和深青色的壁用于重定向指针，但它与以下的fuckfuck相同：

++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++..+++++.

这印于2005年。

画操

Paintfuck是我们列表中的第三种可视化编程语言，但是Paintfuck不会接受图像并输出文本，而是接受文本并输出图像。

由于Paintfuck会忽略无关字符，因为无操作的大多数代码都是不重要的。该代码的相关部分是：

nsn**ne*e*es*s*sw*sw*sw*e*e*e*eee*wn*n*n*n*ne*e*se*s*s*s*sww**e*eeee*wn*n*n*n*ne*e*se*s*s*s*sw*eeee*e*ne*n*nw*ne*nw*w*sw*se*sw*s*wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwnsn**ne*e*es*s*sw*sw*sw*e*e*e*eee*wn*n*n*n*ne*e*se*s*s*s*sww**e*eeee*wn*n*n*n*ne*e*se*s*s*s*sw*eeee*e*ne*n*nw*ne*nw*w*sw*se*sw*s*wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww

尽管它们不是no-op w，但是在代码末尾的s却什么也没做。它们在那里是解决方案的草部分。 n，e，s，和w用于将图像左右移动并*用于绘制在某些位置的点。程序输出：

更大的版本：

脑干

就像Paintfuck一样Brainfuck会忽略大多数字符。这里再次是重要的：

 []+++---[.++....+.+..+.+.+.]++++++++-[<+++++++>-]<[.++++++++..-------+.[-]]>[<>,+,,+,<>]

大多数情况与情况无关，只是碰巧是某些其他语言需要的字符。此代码的精简版是：

+++++++[<+++++++>-]<[.++++++++..------.[-]]

这很简单地打印1993。

脑袋

Brainbool在角色选择方面与Brainfuck非常相似。可以将两者编织在一起的最大区别是-Brainbool中缺少一个。Brainbool的重要特征是：

[]+++[.++....+.+..+.+.+.]++++++++[<+++++++>]<[.++++++++..+.[]]>[<>,+,,+,<>]

Brainbool和Brainfuck的输出是互斥的。Brainbool将其输出隐藏在第二组中[]。Brainfuck +++---在到达[设置为零之前遇到它，导致它跳过输出，而Brainbool仅看到+++将其设置为1，导致它通过循环。同样，Brainbool在第四个循环中设置为零，导致它在Brainfuck进入值为49的循环时跳过。

由于Brainbool没有十进制输出，因此它以二进制输出2010：

11111011010

裂变

对于裂变而言，代码中唯一重要的部分是：

R"2014";

R原子向右移动的传票，"2014"打印2014和;暂停执行。

Befunge

Befunge仅通过以下字符：

P3v
  7
  > 7*::,8 +:,,2 +,@

在P3有必要进行有效的.ppm格式图像皮特和累计推3到堆栈中。将v其放置以将指针向下重定向。然后，它通过7中的17来表示.ppm图像的宽度。该>重定向指针向右。 7*将堆栈顶部乘以7，在堆栈顶部保留49（的ASCII值1）。::复制堆栈的顶部两次。由1输出,。 8 +在顶部添加8到ASCII递增9。 :,,输出9两次。 2 +递增ASCII 1到ASCII 3和,打印。最后@终止程序。

全部打印出来1993。

空格

顾名思义，空格仅在程序中使用空格。这是Whitespace解释器看到的内容：

[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][LF]
[Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Tab][Tab][Tab][Tab][Tab][Space][Tab][Space][Space][Tab][Tab][LF]
[Tab][LF]
[Space][Tab][LF]
[LF]
[LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][LF]

该代码所做的大部分操作与程序的执行无关紧要（所有仅包含空格的行仅将零压入堆栈）。重要部分：

[Space][Space][Space][Tab][Tab][Tab][Tab][Tab][Space][Tab][Space][Space][Tab][Tab][LF]
[Tab][LF]
[Space][Tab][LF]
[LF]
[LF]

第一行将2003压入堆栈。之后，以数字的形式[Tab][LF][Space][Tab]打印出堆栈的顶部（2003）。最后，最后三个换行符结束程序执行。

草

草忽略所有的字符，直到第一个w文件中，之后不是所有的字符w，W或v。草译员读到：

wWWWwWWWWwv
wWWwWWWwv
wWWWwWWWWWwWWWWWWwwwWWWWWWWwWWWWWWwwwWWWWWWWWWWwWWWWWWWWWWwv
wWWWwWWWWwv
wWWwWWWwv
wWWwWWWwv
wWWwWWWwv
wWWwwwwwwwwwwwWWWwWWWWWwWWWWWWWwWWWWWWWWWwWWWWWWWWWWWWWWWwWWWWWWWWWWWWwv

第一行定义了一个函数，该函数将传递的值加两个。第二行定义了一个函数，该函数将传递的值加四。第三个定义了一个函数，该函数打印两个加号的参数，打印两次参数，然后最后打印七个加号的参数（Grass根据ASCII值打印出字符）。第四行，第五行和第六行定义的函数分别为其参数加8，加16，加32和加64。最后一行定义了接受字符的主要函数w（Grass中唯一的预定义数字，ASCII值119），并使用程序中定义的添加函数以及内置的添加一个函数向其添加185。Grass将数字换行为256，因此结果为48（对应于字符0）。然后，该函数将此函数传递给第三行的函数，该函数打印出2007年。

星空

星夜忽略一切，除了空间，+，*，.，,，`，和'。因此，繁星点点的翻译只能看到：

       + + +.     + +..  '.. +. +.. +. +. +. + + + + + + + + + + + + + + +. + + + + + + + +..  `             +. '
     *, +,, +,************************************************* `

但是，标签和跳转指令用于跳过代码的某些部分，如果运行这些部分可能会导致问题，因此代码实际上是这样的：

       + + +.     + +..  '  `             +. ' `

此代码将两个压入堆栈，重复两次，然后弹出并打印其中一个为数字。然后推零，复制零并将两个零打印为数字。接下来，它弹出一个二进制数并跳转，然后将七个压入堆栈，并弹出并打印一个数字。最后，它将最后两个弹出到堆栈中，并跳到程序结尾。

Python 2.7.2

Python代码遵循以下格式：

P3v="";print(sum([ord(x)for x in"~~~~~~~~~~~~~~~y"]));"""..."""

在这里...代表所有其他垃圾。

第一行P3v=""是因为要存在一个有效.ppm文件，因此我们的代码必须以P3该文件开头通常会出错，但是如果我们告诉python这是一个变量声明，它将忽略它。

接下来我们要打印2011。但是，由于.ppm格式化a的方式，我们不能在此行中包含任何数字。为了解决这个问题，我们对字符串的所有ASCII值求和"~~~~~~~~~~~~~~~y"并打印结果。最后，我们使用多行注释的三引号，以便python忽略其他所有内容。

脑筋

我们把最好的留到了最后。

像其他人一样，Brainflak会忽略大多数角色。相关字符为：

(([()])){}{}[](((((()()()()){}){}){}){})({({}[<()>()])}{}<[[]]>)[<><>]

python代码(([()]))两次将-1压入堆栈，因此需要在程序开始处理之前将其删除。

之后，Brainbool使用了[]什么都不做的nilad，程序开始运行。

(((((()()()()){}){}){}){})({({}[<()>()])}{}<[[]]>)推动2016年。最后[<><>]是Befunge和Brainfuck的残余，但幸运的是什么也没做。

程序终止时，将打印堆栈的内容，即print 2016。

5年

#define q/*-[>+<-----]>--.++++++++..------.[-][
print('2010'if len(bin.__doc__)==86else'2015')
"""*/
main(c){c=-4.5//**/
-4.5;printf("19%d",90-c);}
#define w/*]
*/"""

1989：C89 ^[1]和1999：C99

//在C99中添加了单行注释，因此C89编译器将将该代码读取为c=-4.5 / /*comment*/ -4.5，与相同c=-4.5 / -4.5，而C99编译器将将该代码读取为c=-4.5 //comment/**/
- 4.5，与相同c=-4.5 - 4.5。
Python部分是C程序中的注释。

2010：Python 2.7和2015：Python 3.5

文档在Python 3和2之间有所不同，此程序使用文档的长度来检测Python版本。
C部分在Python程序中的字符串中。

1993 ^[2]：Brainfuck

它基本上会忽略所有不是的东西.,[]+-<>。由于C程序中有A ,，因此我必须让Brainfuck通过将当前字节设置为0来解散该部分。

1. C89规范于1990年发布。更多信息。
2. 我找不到官方发布日期，所以我相信Esolangs和Wikipedia。

15年，JavaScript

由于JavaScript的发布周期非常不同寻常且不一致，因此我将使用Firefox实现。如果不允许这样做，请告诉我。

版本： 菲尼克斯0.1，火鸟0.6，火狐1.0.0，1.5.0，2.0.0，3.0 Beta 1中，3.0.0，3.5.0，3.6.0，4.0.0，10.0.0，18.0.0，27.0 0.0，35.0.0，44.0.0（所有测试在Windows 7）

重要说明：安装并打开Firefox 1.0.0或任何更高版本可能会删除所有保存的Firefox数据，包括历史记录和书签。

同样，从1.0.0版本开始，一次只能打开一个版本。尝试打开另一个版本会在已经打开的版本的新窗口中显示。

使用说明

• 选项1：将以下代码作为HTML文档保存到您的计算机上，然后在每个浏览器中将其打开。
• 选项2：在每个浏览器中打开https://ethproductions.github.io/js-year-test.html。

码

<script onbeforeunload="123">
// This uses document.write because alert does nothing in Phoenix (Firefox) 0.1.
document.write((function () {
    function assert (code) {
        try {
            eval(code);
            return true;
        } catch (e) {
            return false;
        }
    }

    // Firefox 44 supports octal and binary literals in Number(); Firefox 35 does not.
    if (Number("0o1") === 1)
        return 2016;

    // Firefox 35 supports template strings; Firefox 27 does not.
    if (assert("`abc`"))
        return 2015;

    // Firefox 27 supports argument spreading; Firefox 18 does not.
    if (assert("Math.max(...[1, 2, 3])"))
        return 2014;

    // Firefox 18 supports default arguments; Firefox 10 does not.
    if (assert("function q(a = 1) { }"))
        return 2013;

    // Firefox 10 has basic WeakMap support; Firefox 4 does not.
    if (assert("WeakMap.a"))
        return 2012;

    // Firefox 4 has basic typed array support; Firefox 3.6 does not.
    if (assert("Int8Array.a"))
        return 2011;

    // Firefox 3.6 added the async attribute to script elements.
    if (assert("document.getElementsByTagName('script')[0].async.a"))
        return 2010;

    // Firefox 3.5 added the String.prototype.trim() method.
    if (assert("'abc'.trim()"))
        return 2009;

    // Firefox 3.0 added partial support for object destructuring.
    if (assert("var {c} = {c: 7}"))
        return 2008;

    // Firefox 3.0 beta 1 added the Array.prototype.reduce() and Array.prototype.reduceRight() methods.
    if (assert("[].reduce.a"))
        return 2007;

    // Firefox 2.0 added support for restricted words as properties.
    if (assert("({if:1}).if"))
        return 2006;

    // Firefox 1.5 added the Array.prototype.indexOf() methods, along with a couple other Array methods.
    if (assert("[1].indexOf(1)"))
        return 2005;

    // Practically the only JS difference between v0.6 and v1.0 is the addition of the onbeforeunload event.
    if (assert("document.getElementsByTagName('script')[0].onbeforeunload.a"))
        return 2004;

    // The Object.prototype.eval() method was removed in Firebird 0.6.
    if (!assert("'abc'.eval()"))
        return 2003;

    // We're all the way back to the good old Phoenix 0.1 browser...
    return 2002;
})());
</script>

6种语言，Turtlèd和brainfuck，Python 3.5，Python 2.7，> <>，裂变

Turtlèd在今年之前就不存在，因此即使github提交不计算在内，目标也很容易实现，并且BF具有1993年发布的esolang页面证据。Python3.5是2015，2.7是2010。> <>也具有esolang页面，说明2009年，表示裂变，2014年

#-[>+<-----]>--.++++++++..------#"2016"/
print(2015 if len(len.__doc__)==42 else 2010)
#;                           oooo"2009"/
#;"4102"L

我应该归功于esolangs上的bf常数页面... \ _（ツ）_ /¯

运作方式：

Turtlèd：

除了第一行，Turtlèd并没有做任何其他事情：

#-[>+<-----]>--.++++++++..------#"2016"/
  ^sets string variable to this   ^ prints 2016

/是点

脑干

Brainfuck忽略不在其命令中的字符

它看到-[>+<-----]>--.++++++++..------.（最后一个来自python部分）

它只是做Brainfuck的东西，它使用包装将255除以5，然后从结果中减去2，打印，增加8次，打印两次，减少6次，打印

Python 2和3

print(2015 if len(len.__doc__)==42 else 2010)

len的文档长度因版本而异，因此，如果长度合适，它将打印版本3的年份，否则打印版本2的年份。

> <>

＃向后反射指针，因此它命中了该行另一侧的/，穿过else和之间的空格2010，然后再次反射以达到“ 2009”，将9,0,0,2推入堆栈，然后打印出反转的内容。

裂变

裂变具有生成器，因此我们可以在底部单独执行一行：

#;"4102"L
        L spawn left moving atom
  "4102"  print this right to left
 ;        halt
# python comment

3年，提供3种语言：C，TeX，MIXAL

*main(){puts("1990");}/*\newwrite\O\openout\O=O\write\O{1982}\bye                                                                                                                              
START   ENTA    1997
        CHAR
        STX     6
        OUT     6(19)
        HLT
        END     START   */ 

命名文件date.mixal。

1. C（1990）-编译带有警告并打印1990到stdout。
2. TeX（1982）-编译为tex date.mixal; 打印1982到文件O.tex（忽略DVI输出）。
3. MIXAL（1997）-使用GNU Mix Development Kit进行编译，mixasm date.mixal并使用mixvm -r date.mix; 打印1997到电传打字设备（= stdout）。

TeX和MIXAL程序在C程序的注释中；MIXAL程序紧随其后，\bye因此TeX将其忽略。C和TeX程序是MIXAL程序中的注释。由于某种原因gcc愿意接受*main。

3年（GolfScript，CJam，MATL），24个 23字节

[A11]Wd%;200 1e2/0 8_+(

这个输出

• 2007 在GolfScript中。

• 2015 在CJam（版本0.6.5）中。

• 2016 在MATL（版本19.2.0）中。

说明

高尔夫脚本

未定义的标记是GolfScript中的noop。实际上，代码中唯一可以执行某些操作的部分是：

200      Push 200
           STACK: 200
1        Push 1
            STACK: 200, 1
/        Divide
           STACK: 200
0        Push 0
           STACK: 200, 0
8        Push 8
           STACK: 200, 0, 8
+        Add
           STACK: 200, 8
(        Subtract 1
           STACK: 200, 7
         Implicitly display 200, 7 as "2007"

贾姆

[A11]    Push array [10 11]
           STACK: [10 11]
W        Push -1
           STACK: [10 11], -1
d        Convert to double
           STACK: [10 11], -1.0
%        Select elements from array
           STACK: [11 10]
;        Pop
           STACK is empty
200      Push 200
           STACK: 200
1e2      Push 100
           STACK: 100
/        Divide
           STACK: 2
0        Push 0
           STACK: 2, 0 
8_       Push 8 and duplicate
           STACK: 2, 0, 8, 8
+        Add
           STACK: 2, 0, 16
(        Subtract 1
           STACK: 2, 0, 15
         Implicitly display 2, 0, 15 as "2015" 

玛特

从此一切都是%评论。

[A11]    Push array [5 11]
           STACK: [5 11]
W        2 raised to that
           STACK: [32 2048]
d        Compute increment
           STACK: 2016
         Implicitly display as "2016"

两种语言，Python 2.7和Python 3.5

Python 2.7于2010年发布。

Python 3.5于2015年发布。

print('2010'if 3/2==1else'2015')

这依赖于PEP 238，其中运算符/从Python 2中的整数除法更改为Python 3中的浮点除法。

8年，TI基础

Disp 1996           <-- TI-83
Text(-1,1,1,1
ClrHome
Disp 1999           <-- TI-83+ OS 1.03 (initial OS)
sub(1
ClrHome
Disp 2002           <-- TI-83+ OS 1.15
isClockOn
ClrHome
Disp 2004           <-- TI-84+ OS 2.21
invT(e,1
ClrHome
Disp 2005           <-- TI-84+ OS 2.40
CLASSIC
ClrHome
Disp 2009           <-- TI-84+ OS 2.53
BackgroundOn
ClrHome
Disp 2013           <-- TI-84+ Color Silver Edition
Send({1
ClrHome
2015                <-- TI-84+ Color Edition OS 5.1

“任何程序都可以打印到STDERR，或者抛出运行时/编译时错误和警告，只要仍然将正确的输出打印到STDOUT或文件中即可。” 当前，唯一的无错误显示是年份，因此我们遵守此规则。但是，如果您想写入内存，请替换Disp (date)为(date)->I。

参考文献：

1. 计算器发布日期-https: //epsstore.ti.com/OA_HTML/csksxvm.jsp?nSetId=74258
2. TI-83 + OS 1.15的发布日期- http://wikiti.brandonw.net/index.php?title=83Plus:OS:VersionDifferences#TIOS_1.15
3. 计算器兼容性-http://tibasicdev.wikidot.com/compatibility
4. TI-84 + CSE发布日期-https: //www.amazon.com/Texas-Instruments-Silver-Graphing-Calculator/dp/B00AWRQKDC
5. TI-84 + CE发布日期-http: //www.prnewswire.com/news-releases/texas-instruments-unveils-the-new-ti-84-plus-ce-300026266.html和https：// www。 cemetech.net/forum/viewtopic.php?t=8870

5年，转到1.0、1.1、1.4、1.5、1.6： 285 257字节

（1.2在2013年发布，如1.1，2014年发布1.3，如1.4，以及2016年发布1.7，如1.6。）

尚未在每个版本上进行测试，因为我只能访问1.6，但理论上应该可以使用！语言更改可能会导致程序无法编译，因此我依赖于标准库更改。

package main
import(."fmt"
."reflect"
."time")
func main(){s:="6"
if _,e:=Parse("2016-Sep-30","2016-Sep-31");e==nil{s="5"}
if Sprint(ValueOf(0))!="0"{s="4"}
if Sprint(&map[int]int{1:1})[0]!='&'{s="3"}
if string(0xd800)==string(0xfffd){s="2"}
Print("201"+s)}

取消评论并评论：

package main

import (
    "fmt"
    "reflect"
    "time"
)   package main

import (
    . "fmt"
    . "reflect"
    . "time"
)

func main() {
    s := "6"
    // 1.6: time.Parse rejects invalid days
    if _, e := Parse("2016-Sep-30", "2016-Sep-31"); e == nil {
        s = "5"
    }
    // 1.5: A reflect.Value now prints what it holds, rather than use
    // its String() method
    if Sprint(ValueOf(0)) != "0" {
        s = "4"
    }
    // 1.4: Printing pointers to maps gives the map instead of the address
    if Sprint(&map[int]int{1: 1})[0] != '&' {
        s = "3"
    }
    // 1.1: Unicode surrogate halves are no longer allowed
    if string(0xd800) == string(0xfffd) {
        s = "2"
    }
    Print("201" + s)
}

4年，99个字节/ 77个字符

v=1//1;"""
 1991/*"""
for i in[0]:print 2010#🔟😃😇🔟😗➕➕😨
"""
"
>9002nnnn;
"""#*/

注意：我不确定年份是否正确

• Python 2.7，2010年
• Javascript，1991年
• 表情学，2015
• ><>，2009

我花了一段时间才弄清楚如何使Python和JS一起工作。

说明

v=1//1;"""将变量设置v为在Python和Javascript中1除以（1在1Javascript中//开始注释），并;"""在Python中启动多行字符串。在;不能使用换行符被替换，因为这将使Java脚本停止工作。

1991/*"""是多行字符串的其余部分。需要空格，以便> <>不会压入1堆栈。由于多行字符串的开头是Javascript中注释的一部分，因此它会打印1991并启动多行注释。

for i in[0]:print 2010#🔟😃😇🔟😗➕➕😨在Python中，是一个for循环，用于迭代列表[0]并运行print 2010。注释只是Emotinomicon代码（它忽略了不是表情符号或字符串的所有内容）。在> <>中，它（f）压15 入堆栈。

无法删除for循环，因为在第1列中> <>的IP下降了，并且p在> <>中不是有效的命令。您也不能用if语句替换它，因为这i是在> <>中进行输入的命令。

""" 是多行字符串的开头。

" 是多行字符串的一部分，需要关闭我们在> <>中打开的字符串（上一行的第一个引号以> <>中的字符串开头）。

>9002nnnn;在> <>，改变IP方向向右推9，0，0和2，这些输出为数字并结束该程序。

"""#*/在Python中，结束多行字符串并开始注释。在Javascript中，*/使多行注释结束。

Gol> <>的奖励版本：

5种语言，4年，118114字节/ 96 92个字符

v=1//1;"""
 1991/*"""
for i in[0]:print 2010#🔟😃😇🔟😗➕➕😨
"""
`
"
>9002nnnn;
"
>5102nnnn;
"""#*/

• Golfish v0.4.2，2015年

说明²

IP从左上角开始，向右移动。将v使它下去。

f推15。

" 开始字符串。

` 用于转义字符，这是> <>所没有的。

"应该关闭字符串，但是我们使用了`，所以不会。

> 字符串的一部分。

" 结束字符串。

>5102nnnn;是实际的代码。>使得IP向右走，5102推5，1，0和2，并nnnn;打印数量和结束程序。

7年，有8种浏览器

语言发布日期不完全是因为CSS实际上没有发布，而是浏览器版本（可以认为是编译器版本吗？）

对于以下浏览器，这将打印浏览器名称，版本和发行日期，而不输出其他任何内容。在某些更高版本中，它确实会打印相同的内容（您会在屏幕截图中看到chrome是一个版本，因为很难通过版本号下载旧版本的chrome）

我可以打印我使用的版本号，但是我更愿意显示引入了所使用功能的第一个版本。

• IE6
• IE7
• IE8
• IE9（未经测试，没有IE9）
• Firefox 4
• Firefox 3.6
• 镀铬18
• 镀铬21
• 现代浏览器

index.html

<!DOCTYPE html>
 <html>
  <head>
     <meta http-equiv="X-UA-Compatible" content="IE=edge">
     <link rel=stylesheet href=style.css>
  </head>
  <body>
    <div class=borderbox>
      <div class="inlineblock">
        &nbsp;IE6-2001
      </div>

      <div class="white">
        <div class="outofbox">
          <a href="#">IE8-2009</a>
        </div>
        <div class="inherit">
          <a href="#">IE7-2006</a>
        </div>
      </div>
    </div>
    <div class="white">
      <header class="filter-quirk filter-blur filter-blur-url">
        IE9
      </header>
    </div>
    <div class="flex white">
      Modern Browsers - 2017
    </div>
    <div class="webkit-flex">
      <div class="">
        Chrome 21-2012
      </div>
    </div>
    <div class="webkit-invert white flexdisable">
      <div class="">
        Chrome 18-2012
      </div>
    </div>

    <svg style="position: absolute; top: -99999px" xmlns="http://www.w3.org/2000/svg">

    </svg>

    <div class="filter">
      <svg xmlns="http://www.w3.org/2000/svg" version="1.1">
        <g
           transform="scale(8)"
           aria-label="FF4"
           id="text8419">
           <rect
              style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.79374999;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker:none;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
              id="rect21965"
              width="17.005648"
              height="3.9855044"
              x="-0.16825682"
              y="-0.025296567" />
          <path
             d="m 1.0052634,1.5511362 v 0.7639843 h 0.4564063 q 0.092604,0 0.092604,0.066146 0,0.069453 -0.092604,0.069453 H 0.69107072 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 h 0.1785938 V 0.72431329 h -0.1785938 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 H 2.1793519 V 1.0484278 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 0.72431329 H 1.0052634 V 1.4155373 H 1.4848207 V 1.2667091 q 0,-0.089297 0.066146,-0.089297 0.069453,0 0.069453,0.089297 v 0.4332552 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 1.5511362 Z"
             style="fill:#000000;stroke-width:0.79374999"
             id="path8421" />
          <path
             d="m 2.9883464,1.5511362 v 0.7639843 h 0.4564063 q 0.092604,0 0.092604,0.066146 0,0.069453 -0.092604,0.069453 h -0.770599 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 H 2.8527475 V 0.72431329 H 2.6741537 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 H 4.1624349 V 1.0484278 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 0.72431329 H 2.9883464 V 1.4155373 H 3.4679037 V 1.2667091 q 0,-0.089297 0.066146,-0.089297 0.069453,0 0.069453,0.089297 v 0.4332552 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 1.5511362 Z"
             style="fill:#000000;stroke-width:0.79374999"
             id="path8423" />
          <path
             d="M 5.6692683,1.8917872 H 4.7729923 V 1.7363445 l 0.754062,-1.28322911 h 0.277813 V 1.7561883 h 0.112448 q 0.0893,0 0.0893,0.069453 0,0.066146 -0.0893,0.066146 h -0.112448 v 0.4233333 h 0.112448 q 0.0893,0 0.0893,0.066146 0,0.069453 -0.0893,0.069453 h -0.499402 q -0.0893,0 -0.0893,-0.069453 0,-0.066146 0.0893,-0.066146 h 0.251355 z m 0,-0.1355989 V 0.58871439 h -0.07938 L 4.9019713,1.7561883 Z"
             style="fill:#000000;stroke-width:0.79374999"
             id="path8425" />
          <path
             d="M 8.2881171,1.6077068 H 6.9585859 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 h 1.3295312 q 0.089297,0 0.089297,0.066146 0,0.069453 -0.089297,0.069453 z"
             style="stroke-width:0.79374999"
             id="path8422" />
          <path
             d="m 8.9582054,0.90656104 q 0,-0.14882812 0.1785937,-0.31749999 0.1819011,-0.17197916 0.4365625,-0.17197916 0.2414323,0 0.4233333,0.17197916 0.1852081,0.17197916 0.1852081,0.39687498 0,0.14882817 -0.0893,0.28111977 Q 10.006617,1.3960402 9.7056533,1.67716 L 9.0210439,2.3154672 v 0.00992 H 10.059533 V 2.2063266 q 0,-0.089297 0.06945,-0.089297 0.06614,0 0.06614,0.089297 V 2.460988 H 8.8920596 V 2.2625506 L 9.6725804,1.5283318 q 0.2315104,-0.2282031 0.3009635,-0.3307291 0.07276,-0.102526 0.07276,-0.21497396 0,-0.17197916 -0.1422132,-0.30096353 -0.1422136,-0.12898437 -0.3307292,-0.12898437 -0.1686718,0 -0.3075781,0.0992188 -0.1355989,0.0992188 -0.1752864,0.24804686 -0.019844,0.0661458 -0.069453,0.0661458 -0.023151,0 -0.042995,-0.0165365 -0.019844,-0.0198437 -0.019844,-0.0429948 z"
             style="stroke-width:0.79374999"
             id="path8424" />
          <path
             d="m 12.207981,1.3001287 v 0.3307292 q 0,0.3902604 -0.171979,0.6349999 -0.171979,0.2447396 -0.446484,0.2447396 -0.274506,0 -0.446485,-0.2447396 Q 10.971054,2.0211183 10.971054,1.6308579 V 1.3001287 q 0,-0.39356766 0.171979,-0.63830724 0.171979,-0.24473957 0.446485,-0.24473957 0.274505,0 0.446484,0.24473957 0.171979,0.24473958 0.171979,0.63830724 z M 11.589518,0.55268084 q -0.224896,0 -0.353881,0.22820312 -0.128984,0.22489584 -0.128984,0.53578124 v 0.2943489 q 0,0.3241146 0.132292,0.5457031 0.135599,0.2182813 0.350573,0.2182813 0.224895,0 0.35388,-0.2248959 0.128984,-0.2282031 0.128984,-0.5390885 V 1.3166652 q 0,-0.32411458 -0.135599,-0.54239582 -0.132292,-0.22158854 -0.347265,-0.22158854 z"
             style="stroke-width:0.79374999"
             id="path8426" />
          <path
             d="M 13.642054,0.43692564 V 2.3253891 h 0.459713 q 0.0893,0 0.0893,0.066146 0,0.069453 -0.0893,0.069453 h -1.055026 q -0.0926,0 -0.0926,-0.069453 0,-0.066146 0.0926,-0.066146 h 0.459714 V 0.61551938 l -0.373724,0.37372394 q -0.02646,0.0264584 -0.06945,0.0264584 -0.02646,0 -0.0463,-0.0198438 -0.01654,-0.023151 -0.01654,-0.056224 0,-0.0297656 0.03638,-0.0661458 l 0.436562,-0.43656248 z"
             style="stroke-width:0.79374999"
             id="path8428" />
          <path
             d="M 15.625137,0.43692564 V 2.3253891 h 0.459713 q 0.0893,0 0.0893,0.066146 0,0.069453 -0.0893,0.069453 h -1.055026 q -0.0926,0 -0.0926,-0.069453 0,-0.066146 0.0926,-0.066146 h 0.459714 V 0.61551938 l -0.373724,0.37372394 q -0.02646,0.0264584 -0.06945,0.0264584 -0.02646,0 -0.0463,-0.0198438 -0.01654,-0.023151 -0.01654,-0.056224 0,-0.0297656 0.03638,-0.0661458 l 0.436563,-0.43656248 z"
             style="stroke-width:0.79374999"
               id="path8430" />
          </g>
      </svg>
    </div>
    <div class="white gradient msfilter" style=color:white>
      FF3.6-2010
    </div>
  </body>
 </html>

style.css

.borderbox {
    height: 40px;
    overflow: hidden;
    padding-bottom: 100px;
}
.outofbox {
    background: blue none repeat scroll 0 0;
    margin-top: 20px;
    opacity: 0;
}
.white {
    color: white;
}
.outofbox a, .inherit a, .inherit a:visited, .outofbox a:visited {
    color: inherit;
}
.inlineblock {
    display: inline;
    width: 100%;
    zoom: 1;
    display: inline-block;
    margin-left: 100px;
    text-align: right;
}
.white header{
  color: black;
}
.absolute{
  position: absolute;
}
.flex{
  display: none;
  display: flex;
}
.flex.white{
  filter: invert(100%)
}
.webkit-flex{
  display: none;
  display: -webkit-flex;
  overflow: hidden;
  flex-flow: column;
  height: 3em;
  justify-content: flex-end;
}
.webkit-flex div{
  margin-bottom: -1.1em;
}
.flexdisable{
  display: -webkit-flex;
  overflow: hidden;
  -webkit-flex-flow: column;
  -webkit-justify-content: flex-end;
  height: 60px;
}
.flexdisable div{
  margin-bottom: -30px;
}
.filter-quirk{
  filter: url(#quirk);
}
.filter-blur{
  filter: blur(100px);
  -webkit-filter: blur(100px);
}
.webkit-blur{
  -webkit-filter: blur(100px);
}
.webkit-invert{
  -webkit-filter: invert(100%);
  filter: none;
}
.filter-url-dark{
  -webkit-filter: url(filter.svg#Invert);
  filter: url(filter.svg#Invert) invert(100%);
}
.filter-blur-url{
  filter: url(filter.svg#blur) url(filter.svg#brightness);
}
.filter{
  filter: invert(100%) brightness(100%);
  -webkit-filter: invert(100%) brightness(100%) blur(100px);
}
.filter svg{
  position: absolute;
}
.filter svg rect{
  filter: invert(100%);
  -webkit-filter: invert(100%);
}
.msfilter{
    /* IE 8 */
  -ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";
  /* IE 5-7 */
  filter: alpha(opacity=0);
}
.opacity{

}
.black{
  background: black;
}
.gradient{
  width: 100px;
  background: -moz-linear-gradient( 45deg, #000, #000 );
  font-weight: bold;
}

filter.svg

    <!DOCTYPE html>
 <html>
  <head>
     <meta http-equiv="X-UA-Compatible" content="IE=edge">
     <link rel=stylesheet href=style.css>
  </head>
  <body>
    <div class=borderbox>
      <div class="inlineblock">
        &nbsp;IE6-2001
      </div>

      <div class="white">
        <div class="outofbox">
          <a href="#">IE8-2009</a>
        </div>
        <div class="inherit">
          <a href="#">IE7-2006</a>
        </div>
      </div>
    </div>
    <div class="white">
      <header class="filter-quirk filter-blur filter-blur-url">
        IE9
      </header>
    </div>
    <div class="flex white">
      Modern Browsers - 2017
    </div>
    <div class="webkit-flex">
      <div class="">
        Chrome 21-2012
      </div>
    </div>
    <div class="webkit-invert white flexdisable">
      <div class="">
        Chrome 18-2012
      </div>
    </div>

    <svg style="position: absolute; top: -99999px" xmlns="http://www.w3.org/2000/svg">

    </svg>

    <div class="filter">
      <svg xmlns="http://www.w3.org/2000/svg" version="1.1">
        <g
           transform="scale(8)"
           aria-label="FF4"
           id="text8419">
           <rect
              style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.79374999;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker:none;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
              id="rect21965"
              width="17.005648"
              height="3.9855044"
              x="-0.16825682"
              y="-0.025296567" />
          <path
             d="m 1.0052634,1.5511362 v 0.7639843 h 0.4564063 q 0.092604,0 0.092604,0.066146 0,0.069453 -0.092604,0.069453 H 0.69107072 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 h 0.1785938 V 0.72431329 h -0.1785938 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 H 2.1793519 V 1.0484278 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 0.72431329 H 1.0052634 V 1.4155373 H 1.4848207 V 1.2667091 q 0,-0.089297 0.066146,-0.089297 0.069453,0 0.069453,0.089297 v 0.4332552 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 1.5511362 Z"
             style="fill:#000000;stroke-width:0.79374999"
             id="path8421" />
          <path
             d="m 2.9883464,1.5511362 v 0.7639843 h 0.4564063 q 0.092604,0 0.092604,0.066146 0,0.069453 -0.092604,0.069453 h -0.770599 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 H 2.8527475 V 0.72431329 H 2.6741537 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 H 4.1624349 V 1.0484278 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 0.72431329 H 2.9883464 V 1.4155373 H 3.4679037 V 1.2667091 q 0,-0.089297 0.066146,-0.089297 0.069453,0 0.069453,0.089297 v 0.4332552 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 1.5511362 Z"
             style="fill:#000000;stroke-width:0.79374999"
             id="path8423" />
          <path
             d="M 5.6692683,1.8917872 H 4.7729923 V 1.7363445 l 0.754062,-1.28322911 h 0.277813 V 1.7561883 h 0.112448 q 0.0893,0 0.0893,0.069453 0,0.066146 -0.0893,0.066146 h -0.112448 v 0.4233333 h 0.112448 q 0.0893,0 0.0893,0.066146 0,0.069453 -0.0893,0.069453 h -0.499402 q -0.0893,0 -0.0893,-0.069453 0,-0.066146 0.0893,-0.066146 h 0.251355 z m 0,-0.1355989 V 0.58871439 h -0.07938 L 4.9019713,1.7561883 Z"
             style="fill:#000000;stroke-width:0.79374999"
             id="path8425" />
          <path
             d="M 8.2881171,1.6077068 H 6.9585859 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 h 1.3295312 q 0.089297,0 0.089297,0.066146 0,0.069453 -0.089297,0.069453 z"
             style="stroke-width:0.79374999"
             id="path8422" />
          <path
             d="m 8.9582054,0.90656104 q 0,-0.14882812 0.1785937,-0.31749999 0.1819011,-0.17197916 0.4365625,-0.17197916 0.2414323,0 0.4233333,0.17197916 0.1852081,0.17197916 0.1852081,0.39687498 0,0.14882817 -0.0893,0.28111977 Q 10.006617,1.3960402 9.7056533,1.67716 L 9.0210439,2.3154672 v 0.00992 H 10.059533 V 2.2063266 q 0,-0.089297 0.06945,-0.089297 0.06614,0 0.06614,0.089297 V 2.460988 H 8.8920596 V 2.2625506 L 9.6725804,1.5283318 q 0.2315104,-0.2282031 0.3009635,-0.3307291 0.07276,-0.102526 0.07276,-0.21497396 0,-0.17197916 -0.1422132,-0.30096353 -0.1422136,-0.12898437 -0.3307292,-0.12898437 -0.1686718,0 -0.3075781,0.0992188 -0.1355989,0.0992188 -0.1752864,0.24804686 -0.019844,0.0661458 -0.069453,0.0661458 -0.023151,0 -0.042995,-0.0165365 -0.019844,-0.0198437 -0.019844,-0.0429948 z"
             style="stroke-width:0.79374999"
             id="path8424" />
          <path
             d="m 12.207981,1.3001287 v 0.3307292 q 0,0.3902604 -0.171979,0.6349999 -0.171979,0.2447396 -0.446484,0.2447396 -0.274506,0 -0.446485,-0.2447396 Q 10.971054,2.0211183 10.971054,1.6308579 V 1.3001287 q 0,-0.39356766 0.171979,-0.63830724 0.171979,-0.24473957 0.446485,-0.24473957 0.274505,0 0.446484,0.24473957 0.171979,0.24473958 0.171979,0.63830724 z M 11.589518,0.55268084 q -0.224896,0 -0.353881,0.22820312 -0.128984,0.22489584 -0.128984,0.53578124 v 0.2943489 q 0,0.3241146 0.132292,0.5457031 0.135599,0.2182813 0.350573,0.2182813 0.224895,0 0.35388,-0.2248959 0.128984,-0.2282031 0.128984,-0.5390885 V 1.3166652 q 0,-0.32411458 -0.135599,-0.54239582 -0.132292,-0.22158854 -0.347265,-0.22158854 z"
             style="stroke-width:0.79374999"
             id="path8426" />
          <path
             d="M 13.642054,0.43692564 V 2.3253891 h 0.459713 q 0.0893,0 0.0893,0.066146 0,0.069453 -0.0893,0.069453 h -1.055026 q -0.0926,0 -0.0926,-0.069453 0,-0.066146 0.0926,-0.066146 h 0.459714 V 0.61551938 l -0.373724,0.37372394 q -0.02646,0.0264584 -0.06945,0.0264584 -0.02646,0 -0.0463,-0.0198438 -0.01654,-0.023151 -0.01654,-0.056224 0,-0.0297656 0.03638,-0.0661458 l 0.436562,-0.43656248 z"
             style="stroke-width:0.79374999"
             id="path8428" />
          <path
             d="M 15.625137,0.43692564 V 2.3253891 h 0.459713 q 0.0893,0 0.0893,0.066146 0,0.069453 -0.0893,0.069453 h -1.055026 q -0.0926,0 -0.0926,-0.069453 0,-0.066146 0.0926,-0.066146 h 0.459714 V 0.61551938 l -0.373724,0.37372394 q -0.02646,0.0264584 -0.06945,0.0264584 -0.02646,0 -0.0463,-0.0198438 -0.01654,-0.023151 -0.01654,-0.056224 0,-0.0297656 0.03638,-0.0661458 l 0.436563,-0.43656248 z"
             style="stroke-width:0.79374999"
               id="path8430" />
          </g>
      </svg>
    </div>
    <div class="white gradient msfilter" style=color:white>
      FF3.6-2010
    </div>
  </body>
 </html>

3年，89字节

Python 2，JavaScript（ES6）和Perl

eval((["1","print=_=>console.log(1995)"])[+(2/3>0)]);print(eval(("1991",1987)["$$">"0"]))

第一个eval将1使用Python 2 print=_=>console.log(1995)的整数除法功能在Python 2以及JavaScript和Perl上运行。这将print在JavaScript中创建一个函数，Perl仅默默地关心语法错误并继续执行。

第二个eval依赖于Perl将变量$$（当前PID）内插到字符串中，与（使用>运算符）进行比较"0"（Python在该比较中需要一个字符串，而Perl隐式转换为整数）时将为true 。

我本可以用更多的语言来解决问题，但是想要一个不滥用注释而只能使用“常规”语言的解决方案。

我使用此Wikipedia页面检索了要使用的年份。

3种语言，3年

一个临时的有趣的答案。

2002!~+++++++[<+++++++>-]<[.++++++++..------.[-]] 2016 !.

• Mouse-2002：之后的所有内容~均为注释，第一部分也可以写成C0U!!!文字2002。

• Calc：的挑战前提交，这是我刚刚在C11中为Programming II设计的基于堆栈的计算器解释器，在第一个空格之前的程序部分将打印错误（根据Challenge规范允许）并2016 !.打印2016。

• Brainfuck：打印1993年，如其他答案所示。最后的无关项.被忽略beef。

请注意，Calc对< stack每条非空输入行的当前堆栈显示是提示的一部分>，而不是输出的一部分。

Microsoft Excel / Google表格，22字节

匿名工作表函数，1987在Microsoft Excel和2006Google表格中无需输入和输出

=IfError(M(2006),1987)

Perl 5和Perl 6（2年）

my $a=2015;my @a=1994;print $a[0],"\n"

Perl 5的第一版发布于1994年

Perl 6于2015年首次正式发布