这是一个答案链挑战，其中每个答案都基于前一个答案。我建议按“最旧”的顺序对线程进行排序，以确保帖子的发布顺序。

注意：这已经成为一个长期的挑战，发布新答案非常困难。这样，如果您想对潜在答案的特定部分提出建议，对可以添加的语言有想法等，现在有一个聊天室可用于应对这一挑战。如果您有任何要问或说的话，请随时加入！

任务

要提交的第n个程序必须以n种不同的语言运行；具体来说，是要提交的先前程序中添加的所有语言，以及另外一种。程序在以用于该问题答案的第一种语言运行时必须输出1，以第二种语言运行时必须输出2，依此类推。例如，第一个答案在Python 3中运行时可以显示1，第二个答案在Python 3中运行时可以输出1，而在JavaScript中运行时可以输出2。在这种情况下，第三个答案在使用Python 3时必须输出1，在JavaScript中运行时必须输出2，而在其他语言下运行时则必须输出3。

附加规则

• 您的程序必须在运行时不会出错或崩溃。警告（和其他stderr输出）是可以接受的，但是程序必须正常退出（例如，通过运行程序结尾或通过诸如exit执行正常程序终止的命令）。

• 输出必须仅是整数，但结尾的换行符可以。还允许其他不可避免的标准输出。示例：Befunge-93中的 解释程序名称和版本，Zephyr中打印字符串后的空格。某些语言提供了两种打印方法–带和不带尾部空格；在这种情况下，必须使用没有尾随空格的方法。

• 每个答案的长度不得超过前一个答案的20％或20个字节（以较大者为准）。（这是为了防止使用诸如Lenguage之类的语言来增加垃圾邮件的数量，并鼓励至少进行少量打高尔夫球。）

• 允许使用相同语言的不同版本（尽管显然它们必须打印不同的数字，所以您需要在多语言版本中放入版本检查）。但是，您可能无法使用返回语言版本号的语言功能。显然，重复完全相同的语言是不可能的（因为程序必须确定性地打印两个不同的数字之一）。
• 尽管在某些多语言竞赛中被禁止，但是诸如过度评论滥用之类的技巧在这里还是不错的。
• 您不必将先前的答案用作编写自己的指南（只要符合规范，就可以重写整个程序）；但是，允许您的答案主要基于先前的答案，这可能是解决问题的最简单方法。
• 您不能连续提交两个答案。让其他人在两者之间发帖。该规则适用，直到满足胜利条件。
• 由于此挑战要求其他竞争对手以您使用的相同语言发布，因此您只能使用免费实施的语言（就像这是一场警察和强盗竞赛）。
• 在一种语言具有多个解释器的情况下，您可以为任何给定的语言选择任何解释器，只要要使用该语言成功运行的所有程序在该解释器中都可以。（换句话说，如果一个程序可以在多个口译员中工作，那么以后的职位可以选择其中一个口译员，而不是“锁定”特定语言翻译人员的职位。）
• 现在，此挑战使用了有关语言选择的新PPCG规则：即使语言比问题新，您也可以使用语言或语言解释器。但是，如果a）语言是为多语制而设计的，或者b）语言是受此问题启发的，则您不能使用比问题新的语言/解释器。（因此，新设计的实用编程语言几乎可以肯定会被接受，无关的esolangs也会被接受，但是像A Pear Tree这样的问题就被禁止了。）请注意，这不会改变所设计语言的有效性。比这个问题更古老的
• 请注意，胜利条件（请参阅下文）的设计是为了打破连锁关系（即，使其他人无法通过使用难以与其他语言混用的语言在您之后回答）将使您失去获胜的资格。我们的目标是继续努力，如果您想赢得胜利，就必须尊重这一点。

答案格式

由于所有答案彼此依赖，因此具有一致的答案格式将很有帮助。我建议格式化您的答案，如下所示（这是链中第二个链接的示例）：

2. JavaScript，40个字节

(program goes here)

该程序在Python 3中打印1，在JavaScript中打印2。

（如果您要解释程序，多色融合技术等，请在此处放置）

胜利条件

一旦有14天没有新的答案，获胜者将是发布第二新答案的人，即被证明没有破坏链条的最大的多语种。不过，仍然很欢迎在那之后延长连锁！

获胜者是机会，请参阅答案194（TemplAt）。

语言清单

// This snippet is based on the snippet from hello world thread https://codegolf.stackexchange.com/questions/55422/hello-world
// It was tested only in Google Chrome

// https://stackoverflow.com/a/4673436
if (!String.prototype.format) {
  String.prototype.format = function() {
    var args = arguments;
    return this.replace(/{(\d+)}/g, (match, number) => (typeof args[number] != 'undefined' ? args[number] : match) );
  };
}

var QUESTION_ID = 102370; // from the question url
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

var answers = [], answer_page = 1;

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      if (data.has_more) { $('#status').text($('#status').text() + '.'); getAnswers(); }
      else process();
    },
    // [Documentation](http://api.jquery.com/jquery.ajax/) states that `error` handler is not called for cross-domain JSONP requests, 
    // but it works here, probably because api.stackexchange.com and codegolf.stackexchange.com are on the same domain.
    error:  function (a,b,c) { 
      $('#status').text( "Failed to load answers: " + b + " " + c );
      console.log( b + " " + c );
    },
  });
}

getAnswers();

// https://stackoverflow.com/questions/6290442/html-input-type-text-onchange-event-not-working/39834997#39834997
// https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/input_event
const input = document.querySelector('input');
input.addEventListener('input', onSearchInput);

function onSearchInput(e)
{
    var table = document.getElementsByTagName("table")[0];
    var str = e.srcElement.value.toLowerCase();
    var num_results = 0;

    if(str == "") // optimization for empty input
    {
        // show all rows
        for(var i = 1, row; row = table.rows[i]; i++)
        {
            row.className = "";
            num_results++;
        }
    }
    else
    {
        for(var i = 1, row; row = table.rows[i]; i++)
        {
            var hidden = row.innerText.toLowerCase().indexOf(str) == -1;
            if(!hidden) num_results++;
            row.className = hidden ? "hidden" : "";
        }
    }
    document.getElementById("results").innerText = "Results: " + num_results;
}


/* Function ParseHeader() extracts answer number, language name and size of polyglot from answer header.
   Argument: `header` - answer header string without markup, eg. "1. Python 3 (8 bytes)" or "59. Tcl, 1324 bytes".
   Retval:  object, eg. {num: 1, language: "Python 3", size: 8} or 
            null if header has wrong format
  
   There are two formats of header, new one with comma and old one with parens.
   Parsing new format only with regexp is hard because:
   - language name may contain commas,                                 eg. "51. Assembly (x64, Linux, AS), 1086 bytes"
   - there may be several sizes, of which the last one should be used, eg. "210. Haskell without MonomorphismRestriction, 10035 9977 bytes"

   There are only several answers with old format header: 1-5, 7, 12-17, 21. All of them have single size and don't have parens in language name,
   so they can be parsed with simple regexp.
   
   Algorithm: Find commas. If there are no commas parse it as old format. Otherwise parse it as new format.
   New format parsing: Let everything after last comma be `sizes`. Check if `sizes` ends with the word "bytes". If not, set size to 0.
   Take the word before "bytes" and convert it to number. Parse the rest of the header (before last comma) with regexp.
*/
function ParseHeader(header)
{
  var a = header.split(',');
  if(a.length > 1) // current format: Number "." Language "," Size+ "bytes"
  {
    // filter(s=>s) removes empty strings from array (handle multiple consecutive spaces)
    var sizes = a[a.length-1].split(" ").filter(s=>s); // " 123 100  bytes " -> ["123", "100", "bytes"]
    var size;
    if(sizes.length < 2 || sizes[sizes.length-1] != "bytes") size = 0;
    else size = +sizes[sizes.length-2];

    a.splice(a.length-1,1); // remove last element
    var match = a.join(',').match(/(\d*)\.(.*)/);
    if (!match) return null;
    return{
            num: +match[1],
            language: match[2].trim(),
            size: size,
          };
  }
  else // old format: Number "." Language "(" Size "bytes" ")"
  {
    var format = /(\d*)\.([^(]*)\((\d*)\s*bytes\)/;
    var match = header.match(format);
    if (!match) return null;
    return{
            num: +match[1],
            language: match[2].trim(),
            size: +match[3]
          };
  }
}

// 1533246057 (number of seconds since UTC 00:00 1 Jan 1970) -> "Aug 2 '18"
// other useful Date functions: toUTCString, getUTCDate, getUTCMonth, getUTCFullYear
function FormatDate(n)
{
  var date = new Date(n*1000); // takes milliseconds
  var md = date.toLocaleDateString("en-US", {timeZone:"UTC", day:"numeric", month:"short"});
  var y  = date.toLocaleDateString("en-US", {timeZone:"UTC", year:"2-digit"});
  return md + " '" + y;
}


var processed = []; // processed answers, it's called `valid` in original snippet

function ProcessAnswer(a)
{
  var body = a.body, header;

  //
  // Extract header from answer body.
  // Try find <h1> header (markdown #). If not found try find <h2> (markdown ##).
  // Extracted header contains only text, all markup is stripped.
  // For 99 language markup is later readded to language name because markup is essential for it.
  //
  var el = document.createElement('html'); // dummy element used for finding header
  el.innerHTML = body;
  var headers = el.getElementsByTagName('h1');
  if(headers.length != 0) header = headers[0].innerText;
  else {
    headers = el.getElementsByTagName('h2');
    if(headers.length != 0) header = headers[0].innerText;
    else { console.log(body); return; } // error: <h1> and <h2> not found
  }

  var info = ParseHeader(header)
  if(!info) { console.log(body); return; } // error: unrecognised header format

  if(info.num == 99 && info.language == "99") info.language = "<i>99</i>";

  processed.push({
    num:         info.num,
    language:    info.language,
    size:        info.size,
    answer_link:   a.share_link,
    user:          a.owner.display_name,
    user_link:     a.owner.link,         // `undefined` if user was deleted
    creation_date: a.creation_date,      // unix epoch (number of seconds since UTC 00:00 1 Jan 1970)
  });
}

function process()
{
  $('#status').remove();

  answers.forEach(ProcessAnswer); // answers -> processed
  
  processed.sort( (a,b)=>(a.num-b.num) ); // sort by answer number, ascending

  processed.forEach(function (a) {
    
    var date = FormatDate(a.creation_date);

    var user = a.user_link ? ('<a href="'+a.user_link+'">'+a.user+'</a>') : a.user; // redundant code, currently the only deleted user is ais523
    if(user == "user62131") user = '<a href="https://chat.stackexchange.com/users/246227/ais523">ais523</a>';

    var style = (a.num == 194) ? "background: #ccf" : ""; // 194 is winner answer

    var row = "<tr style='{0}'><td>{1}</td> <td><a href='{2}'>{3}</a></td> <td>{4}</td> <td>{5}</td> <td>{6}</td></tr>"
              .format(style, a.num, a.answer_link, a.language, a.size, user, date);

    $('#answers').append( row );
  });
}

a {text-decoration:none}
a:visited {color:#00e}

table, td, th { border: 1px solid black; }
td, th { padding-left: 5px; padding-right: 5px; white-space: nowrap; }
tr:hover { background-color: #ff9; }
td:first-child  { text-align:center; } /* # */
td:nth-child(4) { font-style:italic; } /* author */
td:nth-child(5) { text-align:right;  } /* date */

p { margin: 8px 0px }
.hidden { display: none } /* search hides rows */

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<p>
  <span>Search: </span><input autofocus> &nbsp;<span id="results"></span>
</p>
<table class="answer-list">
  <thead>
    <tr><th>#</th> <th>Language</th> <th>Size (bytes)</th> <th>Author</th> <th>Date</th></tr>
  </thead>
  <tbody id="answers">
  
  </tbody>
</table>
<div id="status">Loading answers...</div>

注意：如果您首先看到此信息，则可能要按最早的排序

17.朱莉娅（128字节）

#v`16 "<" 6/b0\ .q@#;n4"14""
#>3N9@15o|R"12"*^
#=|
print((1/2and 9 or 13)-(0and+4)^1<<65>>62);# =#;print(17)
#gg99ddi2` |1|1+6

最后一行有两个ESC，一个在第一个之前，g后一个在后面2。可以打更多的球，但是得益于V和Pyth，事情变得混乱了。

在Python 3中打印1，在V中打印2，在Minkolang中打印3，在> <>中打印4，在Python 2中打印5，在SMBF中打印6，在Japt中打印7，在Retina中打印8，在Perl中显示9，在Perl中显示10，在Befunge-93中显示10，在Befunge中显示11 -98，裂变12，鲁比13，图尔特14，干草堆15，Pyth 16和茱莉亚17。

提示：

• 第四行的开头是Python 2/3，Perl，Ruby。最后是Julia，这要感谢#=多行注释（请注意，Julia没有and/or）。
• V is <ESC>gg99ddi2<ESC>，这绝对是可打高尔夫球的，但V讨厌在网上试用！因为翻译速度很慢。
• Minkolang和Haystack刚开始倒下v。Befunge-93和-98没有，并且依赖于b。
• 视网膜计数第四行中的空格和1的数量，并且V隐藏在视网膜的配置中（即在反引号之前）。
• 根据@ETHproduction的提示，Japt使用反引号将字符串中的大部分代码隐藏起来。
• 裂变是R"12"*。
• SMBF已打入<.第一线，进入决赛6。

23. 六边形，186字节

对不起，如果这弄乱了计划...

#v`16/"<"6/b.q@"(::):::  (22)S#;n4"14"
#>3N6@15o|> ^*ttt*~++~~~%
#=~nJ<R"12";
#[

print((1/2and 9 or 13)-(0and+4)^1<<65>>62)#46(89999+++++!)=#print(17)#0\32=""<0]#echo 21
#8␛dggi2␛` |1|6

␛用于表示文字ESC字符。

印刷品：

Hexagony中的 23，Unload中的22，Nim中的21，Prelude中的20 ，Reng中的 19（可在此处测试），Cardinal中的18，Julia中的17，Pyth中的15，Hystack中的15，Turtlèd中的14，Ruby中的13，Ruby中的12裂变，在Befunge-98中的11，在Befunge-93中的10，在Perl中的9，在Retina中的8，在Japt中的 7，在SMBF中的6，在Python 2中的5，在> <>中的4，在Minkolang中的3，在Vim / V中的2和Python 3中的1。

要获取未链接的语言，请单击change language“六角形”链接右上角的按钮。

六边形无法以这种格式读取（全部）。我们需要以六边形的形式查看它。
请注意，2个ESC字符已替换为␛s，因此您可以看到它们-它们被忽略，因此程序中没有其他字符：

        # v 1 6 / " < " 6
       / b . q @ " ( : : )      A lot more readable, right?? No?
      : : : ( 2 2 ) S # ; n
     4 " 1 4 " # > 3 N 6 @ 1
    5 o | > ^ * t t t * ~ + +
   ~ ~ ~ % # = ~ n J < R " 1 2
  " ; # [ p r i n t ( ( 1 / 2 a
 n d 9 o r 1 3 ) - ( 0 a n d + 4
) ^ 1 < < 6 5 > > 6 2 ) # 4 6 ( 8   | Note that the 0s below can be replaced
 9 9 9 9 + + + + + ! ) = # p r i    | With anything (except "`" or " "), 
  n t ( 1 7 ) # 0 \ 3 2 = " " <     V as far as Hexagony is concerned
   0 ] # e c h o 2 1 # 8 ␛ d g
    g i 2 ␛ | 1 | 6 . . . . .    <-- the ␛ represents an esc
     . . . . . . . . . . . .         character
      . . . . . . . . . . .
       . . . . . . . . . .       A "." is a no-op
        . . . . . . . . .
                ^
                | Mirror wraps to here, going NW

对于那些不熟悉Hexagony的人，有6个IP，从6个角开始。一次仅激活1，并使用进行切换#][。内存模型对该程序并不重要，但将来可能需要理解。您只需要知道1 int存储在“内存边缘”（简称ME）中，然后'"}{更改活动的ME。

\/|_>< 是控制程序流程的镜像。

它是这样工作的：

第一行执行：

#       A no-op (sets active IP to 0, the currently active one)
 v      letter chars set the ME to their ASCII value - so ME is now 118
  16    Like Labyrinth, 0-9 multiplies ME by 10 and is added - ME now 11816
    /   A mirror that sends IP going NW by wrapping to the bottom

底部（摘要垂直翻转，因此您可以上下阅读）：

    .   
   .    A series of no-ops. The IP is going NW now,
  .     because of the mirror on the top.
 .
|       Another mirror. This one sends the IP NE, into the h
 h      sets the ME to 104, the ASCII value for h
  #     104 % 6 == 2, so IP 2 is now active instead of 0

右边缘：

        8  IP #2 is moving SW, starting in the right corner 
       i   Sets the ME to 105
      <    Mirror. Sends the IP going due West
    ""     These change the Active ME - just know that the new edge is 0
   =       Changes the MP (more in specs) - effectively a no-op used to fill space
\32        pushes 23, and mirrors up NE to the !

相关代码的最后一部分：

!          Prints the current value of the ME as an int. Success!
 20(R~     Does things to the ME - irrelevant now
      @    Ends the program!

注意事项：

• Hexagony 在执行之前将所有s和`s 丢弃，因此对它们的任何更改都不会影响Hexagony
• 我需要填充代码，以便将其解释为9个长度的六角形，而不是第8个六角形-注意打高尔夫低于169或高于217相关字符
• 因此，可以更改结尾的~~~和和2 0，而不会对代码造成损害
• 在=""刚刚从以前的一个，这样一个新的ME可以修改移动我走。可以将它们替换为对六边形程序无害的其他字符（'例如s）
• 从技术上讲，这与Befunge 93规范不兼容，因为它将代码的边界框限制为80 x 25字符。但是，大多数解释者都忽略了此规范（例如TIO），因此我个人认为这没什么大不了的。如果您这样做，请随时发表评论。（如果真的要我更改它，那么我会尝试）
• 希望现在不太困难。

50. bash，1024个字节

#16  "(}23!@)" 3//v\D(@;'[af2.qc]GkGGZ'#)"14";n4
#/*` "[!PPP(22)SP(>7 7*,;68*,@;'1,@ ␉␉␉␉ q
#>␉
# >36!@␉
#`<`
#<]+<[.>-]>[
#{
#z}
#
#=<xR+++++[D>+++++++L+++<-][pPLEASE,2<-#2DO,2SUB#1<-#52PLEASE,2SUB#2<-#32DOREADOUT,2DOGIVEUPDOiiipsddsdoh@O6O4/]>+.-- -. >][
#Rx%>~~~+ +~*ttt*.x
#D>xU/-<+++L
#R+.----\).>]|
#[#[/v/v(/0l0v01k1kx0l0ix0jor0h0h1d111x0eU0bx0b0o1d0b0e0e00m1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10vx0v0l111111^_)  0046(8+9+9+9+9+=!)
###|
'\';echo 50;exit;';print((eval("1\x2f2")and(9)or(13))-(0and 4)^1<<(65)>>(62))or"'x"or'({({1})({1}[(0)])}{1}\{1})'#}#(prin 45)(bye)|/=1/24=x<$+@+-@@@@=>+<@@@=>+<?#d>+.--./
__DATA__=1#"'x"//
#.\."12"__*'
###;console.log 39
""""#//
=begin //
#ssseemeePaeueewuuweeeeeeeeeeCisajjapppp/*/
#define z sizeof'c'-1?"38":"37"
#include<stdio.h>
main(  )/*/
#()`#`\'*/{puts(z );}/*'``
<>{# }//
#}
disp 49#//
#{
1}<>//
$'main'//
#-3o4o#$$$
#< >"3"O.
=end #//
"""#"#//
#}
#|o51~nJ;#:p'34'\
#ss8␛dggi2␛ `|1|6$//''25  =#print(17)#>27.say#]#print(47)#]#echo 21#ss*///nd^_^_Z222999"26

想了解更多？尝试polygot聊天！

在线尝试！

像往常一样，由于Stack Exchange的限制，我用代替了文字标签␉和ESC文字␛。您可以从上面的TIO链接的“输入”框中获得易于复制的程序版本。

撞倒

此程序将打印50在bash，49在八度，48在Deadfish〜，47百合，46在Cubix影院，45在PicoLisp，44在alphuck，43在网状，42在恶，41在brainf ***，40在最小-2D，39中的CoffeeScript，38在C，37在C ++，36在迷宫35中INTERCAL，34在轨，33在事件，32在涡动，31在模块化SNUSP，30在空白，29在触发器28在脑高射炮，27在Perl 6，26在05AB1E，25在匹，24在Thutu，23在Hexagony，22在欠载，21在稔，20在前奏，19在礽，18在基数，17在朱，16在Pyth，15在草堆，14在Turtlèd，13在红宝石，12在裂变，11在Befunge-98，10在Befunge-93，9在Perl 5，8在视网膜，7在Japt，6在SMBF，5在Python 2，4在> <>，3在Minkolang，2在V / Vim的，和1在Python 3。

验证

大多数语言都由上面的测试驱动程序进行了测试。通常的四名罪犯需要分别进行测试：

• 事件已使用其官方解释程序进行了离线测试。

• Deadfish〜也使用其官方解释程序进行了离线测试。

• 模块化SNUSP在这里在线测试;

• Reng在这里在线测试。

说明

我一直在寻找各种添加语言的线索。一种可能性是找到一种带有#行注释的语言，可以将其添加到“脚本语言”行中（处理Perl，Python 2和3，以及Ruby）。不过，我花了好一会儿才想到一种可以与现有语言在语法上兼容的合适语言。

事实证明，答案多年来一直盯着我。如果单击上面的TIO链接，它将打开以bash编写的多语言测试驱动程序。所以一直以来，我都有一个标签页，说“ Bash-TIO Nexus”。您可能以为这是一个提示，但显然我错过了。另外，bash还是一种脚本语言，因此术语“脚本语言行”仍然适用。

bash程序与其他脚本语言在同一位置启动。但是，有一种相当简单的方法可以将其与他们分开。用单引号引起来的字符串，\在大多数语言中是转义字符，但在bash中不是。因此，我们可以通过来隐藏其他语言的bash代码'\'…';，这是Perl，Python和Ruby中的简并语句（无效），但在bash中执行。echo 50;exit是结束bash程序的相当简单的方法。好吧，差不多。

这里最大的问题是，bash在运行时将exit继续解析直到当前行的末尾（即使它不执行所讨论的代码），因此我们需要确保其余部分没有语法错误。线。我们有一个'刚过exit;，是不是（也不可能是）立即匹配。在线的稍后'…'部分，它被用来从脚本语言中隐藏一些Brain-Flak代码，但这将使其从bash中取消隐藏。结果，我们需要更改用于隐藏代码的字符串文字类型，从单引号字符串更改为双引号字符串。or"'"做到这一点而不会打扰Perl，Python或Ruby（因为在每种情况下，左手参数都是正确的）。

现在，我们有一个无与伦比的双引号，延伸到以后的一行。在不干扰至少一种其他语言的情况下，关闭它相当困难。实际上，我们要做的是将bash中代码的隐藏方式从双引号更改回下一行的Python / Ruby注释中无与伦比的单引号，最后在此行的末尾关闭单引号。

Pyth和05AB1E

用双引号引起来的混乱还会干扰使用双引号字符串隐藏代码Pyth和05AB1E的语言。我们在这里使用的主要技巧是确保我们添加的每个双引号在不久之后都具有另一个双引号，以便公开尽可能少的代码。（这解释了该__DATA__行上多余的双引号，bash不需要此双引号。）Pyth \用作转义符；这主要是因为它限制了我在脚本语言中弄乱字符串的范围，迫使我使用上面相当复杂的方法（因为我无法轻易利用\bash和所有东西之间的行为差​​异其他）。在05AB1E，'作为一个转义字符外弦，让它逃脱领先者"是不会做的。因此，我最终需要在用于在bash引用样式之间进行更改x的"'"结构中放置一个无用的填充字符（默认为我的常用字符；它使内容更易于阅读！）。

序幕

迄今为止，最难解决的语言。问题在于脚本行及其所有括号都向侧面移动，因此Prelude控制流（非常在乎括号垂直对齐的方式）被完全破坏了。因此，我不得不尝试重建一些可行的方法。

更糟糕的是，当前的第一行（我真的不想重写）对括号的显示位置进行了严格限制。它以一个非零数字开头（实际上是两个！），然后很快就用括号括起来。那是Prelude中的一个循环，而Prelude中的控制流程中的早期循环会导致许多不同的问题（主要是因为它们导致运行更多的代码，而不是更少的代码）。这样，我非常需要在其他行上打开一个0迭代循环，以跳过该代码。在main对于C程序行是非常合适的，但我们需要非常小心，其中所述匹配闭合支架; 距离太远，支架上无与伦比的括号#R+该行会造成麻烦，但距离太远，不会注释掉足够的代码。（请记住，一行上的右括号可以与另一行上的右括号匹配。）

一旦完成，我们将有足够的空间插入事件行上的左括号，并且终于可以安全地跳过程序的前几个字符。但是，括号位置的不同最终导致某些事件/旋转代码实际上在Prelude中运行，从而破坏了堆栈。我没有试图阻止这种情况，而是将Whirl的一些零点向右移动了一些，使它们可以再次为我们提供有效的Prelude程序。

程序的第一行是另一个小的变化。该行的最后一个括号处于一个很难避免的位置。我c在Pyth代码之后添加了一个额外的代码，将其向右移动。（许多语言都在解析程序的这一点，因此，找到一个不会破坏至少一种语言的填充字符花了令人惊讶的反复试验。）

事件

Prelude本身就足够辛苦，但是同时使Prelude和Incident工作却是噩梦。Prelude对代码施加了很多约束，阻止了我自由移动东西，从而使意外的令牌构造更难以打出。例如，Prelude实际上只需0要向右移一个，但这会导致00成为失败的令牌，从而破坏了我们作为事件程序一部分所需的某些令牌（因为如果两个令牌重叠，则它们都会被拒绝，并且在00被重叠我们除了想与其自身重叠令牌）。我必须将两者都搬出去制作第四个副本，并防止它甚至被视为令牌。

标记;'和␠␠（即两个空格字符）更加微妙。问题是，这些都出现之前的kG正在使用跳转到程序的开始，从而将打破事件的控制流（除了打破节目的中心点）。

␠␠通过拆分来删除的副本似乎不可行。通过重叠将其删除是有可能的（这␠=是一个有希望的潜在重叠），但是几乎可以肯定的是，仅添加第四份副本就不那么冗长了，这就是我在这里所做的。

同时，我们可以对使用其他技巧;'。考虑到它是在间距敏感的情况下使用的，所以我不想尝试分解它。然而，这不是说程序附近开始（尽管出现在第一行），所以这是合理的，我们可以跳过去（从而导致它不会影响控制流），而不是需要它不存在。我正在寻找一个合适的令牌用于跳转，而不会弄乱任何其他语言。/v出现在第一行的前面，并且没有中断任何内容，因此这就是我所使用的。

1 Kib代码中的50种语言

@MistahFiggins指出，如果我的1025字节提交为1024字节，它将更加整洁（特别是因为第五十种语言本身就是一个里程碑）。这需要在某个地方找到节省的字节。在这种情况下，我在Deadfish〜中保存了三个字节，但要花两个额外的字节来使事件令牌正确对齐，从而使程序精确地减少到1024个字节。

以前，Deadfish〜代码使用的公式是（2²+ 2）²+ 10×1 + 2 =48。新公式是（3²-2）²-1，也产生48。令人惊讶的是，不是尽管要简单得多，但用Deadfish〜写的时间要短得多。

这也使我们的VIP得分为.008192。这不仅是一个新记录，它本身也是一个很好的舍入数字（很显然，这是因为拥有很好的舍入数字作为公式输入的结果）。

37. C ++（gcc），776字节

#  1"16" 2//v\(;@#/;n4"14"
#/*`3 auaaZ<>16/"<"6/b.q@")(22)S#  ␉␉␉␉ 
#yy␉;36!@
# ␉
#=␉>
#[#yy#yy0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#`<`␉|
print((eval("1\x2f2")and( 9 )or(13 ))-(0and 4)^1<<(65)>>(62))or'(\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"*␉
""""#//
=begin␉//
#*/
#include<iostream>␉
int main()  /*/
#()"`#"\'*/{std::cout<<37;}/*'"`"
$'main'␉//
#-3o4o#$$$
<>3N.<>␉//
#xx
#x%~~~+␉+~*ttt*.x
#xx
=end   #//
"""#"#//
#0]#echo 21#/(\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE)  ap
#_~nJ|#o51\   
#0␛dggi2␛`␉|1|6$//''25  >>>>>#>27.say# =#print(17)#^_^_7LEintndus({})!<>+]/*///Z222999/3!@"26

␉是文字标签，␛是文字ESC字符；Stack Exchange会破坏程序，否则。如果您要对其进行处理，建议从下面的TIO链接的“输入”框中复制该程序。

在线尝试！

撞倒

该程序在C ++中打印37，在迷宫中打印36，在INTERCAL中打印35，在Railal中打印34，在事件中打印33，在Whirl 中打印32，在模块化SNUSP中打印31，在Whitespace中打印30，在Trigger中打印29，在Brain-Flak中打印28，在Perl 6中打印27，26在05AB1E，25在匹，24在Thutu，23在Hexagony，22在欠载，21在稔，20在前奏，19在礽，18在基数，17在朱，16在Pyth，15在草堆，14在Turtlèd，13在红宝石，12在裂变，11在Befunge-98，10在Befunge-93，9在Perl 5，8在视网膜，7在Japt，6在SMBF中为5，在Python 2中为5，在<<>中为4，在Minkolang中为3，在V / Vim中为2，在Python 3中为1。

验证

大多数语言都由上面显示的测试驱动程序进行了测试。您可以测试礽在这里和模块化SNUSP 这里 ; 它们根据需要分别输出19和31。

我在测试驱动程序输出中添加了另一种格式，该格式转义了双引号以及换行符。这样一来，我就可以将单行字符串输入到ac（gcc）程序中，该程序围绕着@feersum 在此处创建的函数。希望其他人可以照常使用它。

这是事件令牌程序。理想情况下，我想清除令牌，因为它们有点难读，表示“中心”令牌，并将其包含在测试驱动程序中。但是我真的不知道如何做，除了使各种程序打印连续的整数外，就我所知。

我试图解决明显的事件问题，例如在开始和结束跳转令牌之后的令牌以及任何看起来无关紧要的事物，但是我没有平衡令牌放在0o中间。我不太确定确定中心的逻辑是什么。我希望@ ais523可以为您提供帮助。7LEintndus({})!<>+如果不是该代码中的第4个包含项，则结尾处的该字符串将全部为令牌。.为了调整中心标记，可以将它们全部删除（并用替换为“六边形”对齐）。

我将在第二天或之后一两天内更新这篇文章，以遍历代码（假设可以在不检查字节数的情况下验证/修复事件）。但是现在太晚了，我主要想在解决另一个迷宫般的问题之前就解决这个问题。：P

说明

C ++代码的工作方式。

我认为大多数人都对C ++足够熟悉，所以我不会赘述。块注释以的形式出现/* comment */。行注释以的形式出现//comment。C ++用来产生答案的实际代码是int main() {std::cout<<37;}。该语句引用了用于与STDOUT接口的库#include<iostream>。

/ *评论滥用* /

对我来说，C ++的故事可以追溯到我的Brain-Flak答案。

在最终找到＃28之后，我着手研究了PPCG中发布的其他多语种，所有这些研究使我得到了一些简单的答案（如果有其他人愿意的话，大多数仍然可以找到）。但更重要的是，我得出了关于一般多元论的结论：大型多元论倾向于分为两大类之一：#评论滥用或/*评论滥用。

无论如何，这不是事实，也不是限制，而是指导我下一个答案的个人心理框架。

从这里开始，我认为如果要成为目前世界上最大的多语种（我认为是现在），最好是可以利用两个评论族中的评论滥用。因此，我着手寻找一种合并/*注释语言的方法，并由于个人熟悉而将其推向C族。

C ++初始测试

我最初的思考过程是使用C＃，主要是因为我很熟悉，而C＃的第一个障碍是将多语种设置为一种状态，即它可以接受#没有以脚本语言作为代码的开头的行。Rail答案以及导致它的几个字节膨胀答案解决了这一问题。

接下来是如何启动第一个/*注释块的问题。我知道该行必须以a开头，以#使其对Perl，Ruby和Python不可见，但是/*C＃会读取该行之前的内容。我#region最初尝试使用C＃标签，但事实证明它对于2D语言来说过于复杂。输入C ++。

C ++有几个都以开头的预处理器指令，这些指令#为2D语言提供了很多遍历的选择。但是事实证明，它们都与至少一种语言不兼容，并且在C ++公开的代码空间中，我的解决方法有限。出于无奈和绝望，我偶然发现了一个事实，即C ++只会#在注释块之前只接受一个。好吧，那是可行的。因此，我提出了#/*可以作为多语言的前三个字符的假设。

第二步基本验证是确保实际的打印语句可以与其他代码一起愉快地使用。我从Brain-Flak的答案中知道Japt不喜欢未转义的{'s，这对于C ++来说是必须的，int main() {std::cout<<37;}并且C ++不允许Japt的转义字符出现在其代码中间。这次我很幸运地发现，如果仅出于该声明而放弃Japt的文字字符串，Japt仍然会很高兴产生相同的结果。

同时，Brain-Flak都不喜欢这{}两者，但是我再次很幸运地发现C ++可以#在int main()和 {std::cout<<37;}语句之间使用a ，可以使花括号从Brain-Flak的角度进行注释。

因此，随着C ++的主要问题在理论上可以解决，我开始了艰苦的过程来解决我所引入的所有错误。

2D风景

到目前为止，这个答案中最难的部分是重新配置了多语言的前两行。而最重要的问题是*。欠载不允许*之前的(。它认为这是对空堆栈的数学运算，感觉是一个错误。因此，polyglot要求在(之前，/*但是C ++不允许这样做。因此，解决方案是为我们//在第一行添加C ++行注释以隐藏a (，然后以a 开始第二行#/*。

接下来，Befunge确实不喜欢/不进行任何分割的a的想法，但是在研究了现有的Begunge答案之后，16/"<"6/b.q@我偶然发现了一个数字和一个字符串在之前捣烂在一起的想法//。它起作用了，我不知道为什么C ++可以解决这个问题，但是它接受# 1"16" 2了开头的声明。我不会对此提出质疑，但我知道要使它正常工作需要空格。

一号线

Japt原来对空间非常敏感，并且实际上并不想在第一行输入基于反引号的字符串，因此Japt和Pip的反引号移到了第二行，从而在第一行迫使了许多语言体操。

• Pip不喜欢第1行的大部分内容，因此在第一个行之后放置了第二个空格#以表示评论。
• 在(对欠不得不逃出Japt与前面\。
• #是Turtlèd中的跳转终止符，因此是必需的，但是Pyth认为这是一个错误终止循环，因此Pyth需要/ 在#
• 我不确定@第一行中的内容是否已完成，但是Pyth和Japt似乎更喜欢它的存在，尽管@根据Pyth的文档来说这并不是有意义的角色。
• 而且看起来第一个;可以在此时被移除而没有任何后果，所以我不确定那里已经解决了什么，尽管我怀疑这与Pyth有关。但是，看起来未来的解决方案可以通过省略一个字节来节省一个字节。
• <> <和Turtlèd基本上都和以前一样工作，其中<> <反映在第一#行上并包装到第一行的末尾。然后Turtlèd #像我提到的那样跳跃，并以"14"它打印的字符串结尾。

2D路由

解决了这些问题后，下一阶段是路由2D语言。之前，v由于前面的原因，首字母缩写被Befunges忽略#，但使Haystack和Minkolang失望。现在，初始空间尝试沿第3维发送Minkolang，其文档将其称为时间维。

暂时忽略Minolang的第3个维度：在我看来，将其称为时间维度有点不恰当，对我而言，它似乎比时间维度更具有空间性。我并没有真正得到它，直到我发现这个链接，说明了这一概念，它似乎更像是一个三维国际象棋棋盘的多层。我认为这就是3D语言的一般操作方式。但是由于这对我来说是个新概念，所以我认为我应该将此信息抛给其他人。

因此，Minkolang的多层由结束的行界定，在$$$这些行中，我将其拖放到Rail代码的末尾：#-3o4o#$$$。现在，Minkolang进入空白处，进入第一个>，<>3N.<> ␉//然后继续向右输出，#>因为它试图终止Perl6注释块，所以不允许它开始此行，因此它<被用来代替#SMBF和Brain -高射 但是，这是Brain-Flak堆栈交换过程，因此<>在Minkolang终止之后使用第二组交换以交换回Brain-Flak的正确答案。

Labrynth同样会撞到空间，但会导致Labrynth在第1列中向下移动。然后将第2行下移，然后向下移动到3撞到另一堵墙，使其再次向南旋转并撞到;导致第3撞开的位置。然后，该程序继续向右移动，在此位置存储并打印了36个字符，最后找到一个@出口。这条路径比它需要的路径更长，但是我发现，如果Prelude !比现在的位置更左，则Prelude将在正常输出20之前输出一个nul字节，而不管它出现的行是什么。所以我说得更对，因为我有足够的空间这样做。

接下来，Haystack的路线发生了变化，因为它/现在v位于第1行之前，并且像Reng一样反映了其路线。幸运的是，Reng相当和平地同居。一个问题是，干草堆的针|是Reng中的反射器，因此Reng #在针上使用Befunge像跳转（）一样正确地得出Reng。

Befunges沿第1行继续，直到v并指向下，然后在第二行向右，以使用之前使用的相同代码结束。我的感觉是，由于越来越少的语言试图有意义地遍历代码，因此可以放手一搏，但是我不需要再多费力气了，所以我将其保留了下来。

最后，红衣主教的出发点是%，不必特别将其混入已经密集的前两行。所以我将其移至Python的字符串。现在，它的多个代码路径也被所限制x，从而结束了其指针的移动。

2号线和3号线

唯一重要的变化是，所有:高尔夫球都出于一个或另一个原因。也许Prelude的(需求，或者可能只是简单的字节数问题-可能两者都有。另一件事是触发器的跳转代码被移回并更名为auaaZ。我有足够的空间来满足Befunge的代码路径，这似乎是最好的。此外，<以下是平衡SMBF的以下内容>。最后，”第二行结尾处的孤行将保持05AB1E的字符串。另外，yy第3行只是迷宫的填充字符。

大串雪兰莪

解决了前两行的问题之后，该开始研究更全面的esolang了，Pip出现了问题。如果您还记得，我们可以{std::cout<<37;}通过删除Japt字符串来处理花括号，让Japt将其视为代码。好吧，Pip使用相同的字符串语法，并且不喜欢此行作为代码，并且Pip具有与Japt非常相似的字符串声明选项。两者都使用一个'来声明一个字符串，都使用相同的转义声明，\并且都将接受"为字符串标识符。因此，如果不让Japt相信相同的话，就很难让Pip相信这是一个字符串。

事实证明，Japt确实有一个可利用的区别- #采用下一个字符的ascii值。因此，#"`将终止Japt / pip字符串，然后告诉Japt接受的asci值"，同时告诉Pip开始新的字符串。在"大概本来是反引号代替，而且可能会更好，但我的思路是使用一个不同的字符串标识符在内部字符串操作的另一点。因此，这是您可以节省一些字节的另一个地方。

接下来，我必须在花括号后启动Japt字符串，同时允许Pip保留在字符串中。我这样做'"`的时候是单引号，双引号和反引号。对于Japt，'它不在字符串中，因此是将下一个字符作为单个字符字符串的指示符。Pip将'视为字符串的一部分，并以终止其字符串"。最后，`向Pip和Japt都表明另一个字符串正在开始，该字符串在多语言中一直持续到两种语言都愉快地完成的最后一行。

现在，Japt和Pip都可以工作了，但是05AB1E失败了，因为使用"导致了一些导致代码暴露的错误。幸运的是，通过"在整个对象周围放置另一组，而将这组字符串操作保留为，很容易解决"`#"\\'*/{std::cout<<37;}/*'"`"。

最后，现在的行看起来像这样，int main() #/*"`#"\'*/{std::cout<<37;}/*'"`"这是Underload遇到的问题。连续*的，是另一个语法错误，因此我()在的中间加了*一个以安抚它。

脆弱的雪兰莪

现在最大的障碍是空白。在这里，我将不做过多介绍，因为大多数Whitespace解决方案都内置在已经给出的说明中，而我只是在空白中强制执行一些决定的情况上作了介绍。我在看着你迷宫。但是，最大的变化是，输出空白答案的实际代码在2-4行而不是1-3行。这很大程度上是由于Japt在第1行的代码公开。

Thutu最初对以下内容存在疑问：int main() #/*()"`#"\'*/{std::cout<<37;}/*'"`"。因此，我在第一个提示之前将换行符#隐藏在注释指示符后，然后/在所有其他代码暴露的地方都添加了换行符。

此时，我调整了六角形并发现了新问题。在最开始的代码，作为开始生活# 1"16" 1所作的+中/+23!@不再清晰堆栈。因此，我刚刚删除了+is，发现它现在输出123。通过将开头# 1"16" 2的gambit 更改为，然后将Hexagony片段打高尔夫球到，就很容易解决/3!@。

Whirl进行了一些更改，但主要是确保在Whirl-Incident行之前出现正确数量的前导1。事件虽然有一个特别困难的令牌。我正好3份/*和*/。

我最初只是想*//*在代码中放置任何旧位置以创建每个的第4个副本，但是Underload *再次看到了连续的，这是不可行的。最终，我/在此行的末尾添加了一个int main() /*以使其结尾/*/，以为我会让令牌重叠，但是我只成功创建了两个令牌之一的4个副本。是的是的。就是这样。哦，好吧，我会/在决赛中掷出一个类似的数字，使该队*/进入第四 之后，我用最后一行中此字符串中若干事件标记的第4个副本替换了一堆六角形的无操作项7LEintndus({})!<>+。

结论

好的，这就是我进行大规模重构的所有细节。我保证下次不会写太多。我实际上不知道C ++是此多语言的好选择，但我认为它提供了一些选择。希望这会带来美好的事物。

快乐的编码。

3. Minkolang v0.15（26个字节）

#>>>>>>>>v
print(1)#>3N.i2

此程序将打印1在Python 3，2 Vim中，和3在Minkolang v0.15

我希望我不会因为引入2D语言而搞砸了

在线尝试！

说明

#                     stops program from moving through time (really does nothing)
 >>>>>>>>             I can't use a space because then the program will move through time
         v            go down
         >            go right
          3N.         Outputs 3 and end program
                      Anything afterward is ignored since program has ended

Vim以某种方式忽略了Minkolang，所以很好

而且Python确实没有问题，因为它忽略了注释 #

下一个...

对于第二种语言，我建议使用> <>之类的东西，因为它#起着反射器的作用（因此方向将向左更改，并在右侧一直缠绕），因此您可以添加其他语言可以忽略的代码

5. Python 2（35字节）

#3N.;n4
print('1'if 1/2else'5')
#i2

这个程序打印1在Python 3，2 Vim中，3在Minkolang v0.15，4在> <>和5在Python 2。

在线试用Beta！

在Python 2中，1/2为0，这是一个虚假值，使Python打印5。在Python 3中，1/2为0.5，这是一个真实值，这使得Python打印1。

4.> <>（29个字节）

#>>>>>>>>v;n4
print(1)#>3N.i2

这个程序打印1在Python 3，2 Vim中，3在Minkolang v0.15和4中> <>

在线尝试！

代码已执行

#             - change direction to left
            4 - add 4 to stack
           n  - print as a number
          ;   - end the program

另一种2D语言。

对Minkolang无效，因为它会在方向改变后添加字符，但由于某种原因而被Vim忽略。#是Python中的注释，因此也不要更改它们。

28. Brain-Flak，280字节

#v`16/"<"6/b.q@"(::):::   (22)S#;n4"14"
#>3N6@15o|> ^*ttt*~++~~~%
#=~nJ<R"12";
#[
#`<`|
print((eval("1\x2f2")and (9) or (13))-(0and 4)^(1)<<(65)>>62)or'(\{(\{})(\{}\/^23!@[()])}\{})(\{}\{})'#@46(8+9+9+9+9+=!)=#print(17)#]#echo 21#|/=1/24=x=90/
#8␛dggi2␛` |1|6$//''25  #>say 27#"26

␛照常表示文字ESC字符。

此程序将打印28在脑高射炮，27在Perl 6，26在05AB1E，25在匹，24在Thutu，23在Hexagony，22在欠载，21在稔，20在前奏，19在礽（测试此处），18在基数，17在朱，16在Pyth，15在草堆，14在Turtlèd，13 Ruby中， 12在裂变， 11在Befunge-98， 10在Befunge-93， 9在Perl 5， 8在视网膜， 7在Japt， 6在SMBF， 5在Python 2， 4在> <> ， 3在Minkolang， 2 Vim中/ V， 1在Python 3

首先，我想说说能够为这一挑战做出贡献是什么特权。几周前我才听说过打码高尔夫，从那以后我就被迷住了。当我发现这个挑战时，我所做的第一件事就是尝试以各种语言运行代码，只是看我是否能找到可以使用的任何东西。当我们像＃6一样回到时。老实说，我认为这个挑战是不可能的，但是我们来了（＃28哇！）。当时我发现Brain-Flak输出值2。所以我着手学习。

事实证明Brain-Flak非常适合这种挑战，因为它非常容易学习，并且几乎忽略了所有字符(){}[]<>。#也会在同一行中发表评论，因此，Brain-Flak曾经考虑过的最后提交的唯一部分是print((eval("1\x2f2")and 9 or 13)-(0and 4)^1<<65>>62)然后配对为((())()<<>>)。因此，该计划就在我想到的python代码中增加了多余的括号。

我修改了python位以在Brain-Flak中解析((() () ())()()<<()>>)为2，第一个是5，第二个是3。此后，我对5进行平方，({({})({}[()])}{})并使用将结果添加到3 ({}{})。从Python的角度来看，这种平方和加法是在字符串中进行的。我不能在这里声称理解Python的推理，但是我非常有信心，其他语言不会以有意义的方式对字符串进行评估，只有几个例外。

事实证明，Japt会将字符串中的花括号解释为包含代码，但是这些花括号很容易逃脱，而不必在该字符串中的\每个花括号之前使用{。但这使字节数膨胀。这就是生活。

前奏带我的所有括号都相当宽容。较早的评论指出，Prelude可以与垂直对齐的Pparentheses配合使用，而我碰巧只创建了一个。甜！在(与和顶线一字排开(9的大线。因此，我必须(在顶行之前添加一个额外的空间。我在这里的假设是，双倍空格是某些内容的注释指示符，因此添加一个额外的空格似乎微不足道，并且可以正常工作。我应该指出，我尝试在其中添加一个额外的空格(9)，但是Cardinal没有合作。

05AB1E不喜欢我第一次尝试将Python字符串封装在双引号中，但是每个人似乎都同意使用单引号。那里没什么大不了的。

六边形是此时唯一剩下的语言，而且我显然已经超过了下一个十六进制大小阈值，因此该变得肮脏了。这/^23!@是Hexagony代码，对此我感到非常兴奋，因为我认为它将使将来的添加变得更加容易。这小块基本上可以移动到python字符串中的任何位置，而不会破坏任何代码。这是完整的字符串，因此我们都在同一页上'(\{(\{})(\{}\/^23!@[()])}\{})(\{}\{})'。在/这里，从SE设置Hexagony的路径- > NW到W->电子下来这个字符串，我们有很多有回旋余地。（前面\是逃避/对于图图图BTW）。我在这里的想法是，如果您进行更改，很有可能您将在某个点上遍历此字符串，并且可以在字符串内滑动Hexagony段以捕获代码路径并将其发送到正确的结论。请注意不要介于Japt \和Japt之间{。如果对此有问题@，则字符串的右侧仅是另一种Hexagony解决方案遗留的，可以删除而不会影响其他语言。当然，如果您碰巧发现Hexagony的代码路径是相反的，则可以使用@!32^\代替/^23!@。另外，您可能会注意到我的解决方案删除了===2从代码中将内容保持在字节数以下。有人在这里提到这是为了Hexagony的对齐，我不再需要它了。

最后，这是我在探索codegolf时发现的一小段代码，它将代码行转换为可读的Hexagony可读六边形，以便您进行调试。我敢肯定，很多人都知道这一点，但是我没有在这里看到它，因此它可能也会对其他人有所帮助。公平的警告，您必须更改输入以删除反引号和回车符，以及将字面量换码符换成占用正常空间的东西，以使代码将其排列在漂亮的Hexagon中。

PS：当我写这篇文章时，我意识到自己有一个错误。我曾经相信我会用来清除Hexagony的内存边缘^，但是显然我可以用no-op来代替它，而不会产生任何后果。这^或许应该是+，如果你试图操纵这个部分。我显然是+在此之前经历过的，但是未来的杂技演员可能并不那么幸运。

祝好运！

38. C，804字节

#  1"16" 3//v\(@#/;n4"14"
#/*`3 auaaZ<>16/"<"6/b.q@")(22)S#  ␉␉␉␉ 
#yy␉;36!@
# ␉
#=␉>
#[#yy#yy0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#`<`␉|
print((eval("1\x2f2")and( 9 )or(13 ))-(0and 4)^1<<(65)>>(62))or'(\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"*␉
""""#//
=begin␉//
#
#*/␉
#define␉z  sizeof 'c'-1?"38":"37"
#include␉<stdio.h>
int main()  /*/
#()`#`\'*/{puts(z);;}/*'``
$'main'␉//
#-3o4o#$$$
<>3N.<>␉//
#xx
#x%~~~+␉+~*ttt*.x
#xx
=end   #//
"""#"#//
#0]#echo 21#/(\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE)  ap
#_~nJ|#o51\   
#0␛dggi2␛`␉|1|6$//''25  >>>#>27.say# =#print(17)#^_^_7LEintndus({})!<>+]/*///Z222999/(3!@)"26

␉是文字标签，␛是文字ESC字符；Stack Exchange会破坏程序，否则。如果您要对其进行处理，建议从下面的TIO链接的“输入”框中复制该程序。

在线尝试！

撞倒

此程序在C中打印38，在C ++中打印37，在迷宫中打印36，在INTERCAL中打印35，在Rail中打印34，在事件中打印33，在Whirl 中打印32，在模块化SNUSP中打印31，在Whitespace中打印30，在Trigger中打印29，在Brain-Flak中打印28，27在Perl 6中，26在05AB1E，25在匹，24在Thutu，23在Hexagony，22在欠载，21在稔，20在前奏，19在礽，18在基数，17在朱，16在Pyth，15在草堆，14在Turtlèd，13在红宝石，12在裂变，11在Befunge-98，10在Befunge-93，9在Perl 5，8在视网膜，7在Japt，6在SMBF，5在Python 2，4在> <>，3在Minkolang，2在V / Vim的，和1在Python 3。

验证

大多数语言都由上面显示的测试驱动程序进行了测试。您可以测试礽在这里和模块化SNUSP 这里 ; 它们根据需要分别输出19和31。

这是我稍作调整后的Incident 标记器的版本，旨在减少打高尔夫球的次数，但更有用。

说明

我一直很喜欢制作小杂技，但从来没有像现在这样大。我以为我应该去试试看！

在@Chance出色的C ++答案之后，C似乎是下一个合理的选择，并且（相对于之前的一些答案）添加它相对容易，因此我决定在有机会的情况下选择它！

我使用了一个非常著名的技巧来告诉C和C ++之间的区别。字符常量的大小在C ++中为1个字节，但在C语言中为int的大小（保证至少为16位）。此代码应具有很高的可移植性（可能对于使用带足够位的字节来容纳一个int的字节的系统而言可能除外），除非我犯了一个愚蠢的错误。

我首先尝试对printf所有内联函数执行a操作，但是多个括号似乎对Japt造成了问题，因此我简化了该行，似乎可以解决此问题。

接下来，我猜Cardinal不喜欢它，因为%在printf中，所以我不得不通过切换到操作字符串来解决这个问题。

我的下一个尝试分配一个字符串，然后根据C的行为改变第二个字节，但结果却太长了，将把Hexagony推到下一个大小。我想避免重做，方法是将其保留在我必须玩的额外角色之内！我需要为此获取的每个字节，因此我实现了@Chance建议的节省字节的更改。

因此，我稍微研究了一下C代码，并提出了puts(sizeof'c'-1?"38":"37");几乎可以解决的问题，只是欠载是段错误的，大概是因为括号中的表达式很复杂。

即使删除了Perl6中>>用于匹配<<Perl6 所需的额外内容，我也无法获得足够简洁的方法来将其更复杂的部分拆分为char数组分配。因此，我最终转向使用预处理器。

经过大量的反复试验，我发现了Retina似乎喜欢的解决方案。一直困扰着我的前奏曲一直困扰着我，直到我四处寻找它破裂的原因之前（我猜这是括号还是!我在三元模型中处于一个阶段，先前的答案）。

一直以来，我都在修补空白以获取空白所需的东西。我发现这很容易。具体来说，这tab space space space是一个非常有用的组合（在堆栈中添加前两个项目的指令），因为这意味着我可以在没有其他空白的情况下向行添加空白，而不会导致所有内容不同步（我猜它在程序意味着它实际上从未执行过，因此我在这里不必担心堆栈下溢）。

我现在已经测试了事件，它可以工作！非常感谢@Chance和@LliwTelracs，我刚刚意识到这不是威尔士语的名称，因为它可以帮助我掌握它。请参见此语法突出显示。我删除了;令牌之前出现的#yy令牌。我通过;在gets语句后添加一个额外的s字符（我之前的尝试包括用a替换“ totokenising”字符串中的替换（现在在C程序中比在上一个程序中显示的更多）来完成此操作;，但事实证明我是实际上是Hexagony的缩写（感谢@Chance），因此在向最后一行添加额外字符的尝试失败后，我将其改回原处，并在其他地方添加了额外的分号。

我还对空白进行了一些微调，以更改其他一些标记以进行定心尝试，以重新标记制表符换行（通过将行末尾的制表符移动#include到中间，从而得到三个标记），并通过在行中移动一个空格来取消对三空格令牌的标记define。

最终，在初次提交后的第二天，我决定深入了解gcc产生的可怕的预处理程序警告（这使Clang失败了）。我确定第一行完全起作用的原因是因为预处理器的输出提供了调试信息，例如原始文件名和行号。他们不喜欢第一行中的第一个“ 2”，因为这意味着“从包含的文件返回到给定的文件”，显然，鉴于没有包含的文件，这是不可能的。将其更改为“ 1”（开始普通标头）使一些语言受阻后，我将其更改为“ 3”（开始内部组件标头），仅破坏了Hexagony，因为它现在依赖于2。因此，在六角代码的开头，我添加了一个开放式括号(将3递减为2，然后在六角形代码)的末尾（@）之后加上一个括号，以满足所有预期匹配括号的Retina，Prelude和Underload。重新测试Reng和Modular SNUSP不会产生任何问题，并且事件令牌看起来正确，因此我现在已将其修复！我已经在各种异国情调的架构上对其进行了测试，并且它似乎可以正常工作。我知道这对进行代码高尔夫并不重要，而且我不介意将来的提交者是否必须再次破坏密码以保持字节数之内（或其他任何理由）（或者是否有人已经基于此解决方案开始并且不想更改其密码了）太多），但是我这样做有一个很好的理由-TIO的Objective-C编译器仅支持Clang，因此如果有人要添加它，这将非常有用！

请记住，我从未使用过大多数这些语言，希望我的成功鼓励更多的新手来尝试一下！

65. ALGOL 68（Genie），1634字节

#16  "(}+?23!@)-("//*\Dv;'[af2.q]PkPPX'#CO)"14";n4
#/*0|7//```"`   [-'][!(>77*,;68*,@;'1,@10␉␉11)(22)S␉␉(1 P''53'S^'q
#>␉
# 36!@␉`
#
#_>++++.>.}+?
#`<`
#<]}} +<[<.>>-]>[
#{
#z}
#
#=x<R+++++[D>+++++++59L+++<-][pPLEASE,2<-#2DO,2SUB#1<-#52DO,2SUB#2<-#32DOREADOUT,2PLEASEGIVEUPFACiiipsddsd4O6O@oh]>@@+.---@.>][
#x%+>+=ttt Z_*.
#D>xU/-<+++L
#R+.----\).>]|
#[#[(?2?20l0v0x1k1kMoOMoOMoOMoOMOO0l0ix0jor0h0h1d111x0eU0yx0y0moO1d0y0e0e00m1d0i0fx0g0n0n11MoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOmOoMOo0moo0n0tx0t0moO0f0t0gOOM0g0f0h0j0j0i0001k1x0vx0v0l111111^_00)
[ "]56p26q[puts 59][exit]" ,'\[' ];#/s\\/;print"24";exit}}__DATA__/
#
###x<$+@+-@@@@=>+<@@@=>+<?#d>+.--.

#
'(((p\';a=a;case $argv[1]+${a:u} in *1*)echo 50;;*A)echo 54;;*)echo 58;;esac;exit;';print((eval("1\x2f2")and 9or 13)-(0and 4)^1<<(65)>>62)or"'x"or'{}{}{}{}({}<(((((()()())){}{})){}{})>){(<{}(({}){})>)}{}({}())wWWWwWWWWwvwWWwWWWwvwWWWwWWWWWWWWwWWWWwWWWWWWWwWWWWWWWW li ha '#}#(prin 45)(bye)46(8+9+9+9+9+=!)((("'3)3)3)"'
__DATA__=1#"'x"
#.;R"12"'
###;console.log 39
""""
=begin
<>{nd
#sseeeemPaeueewuuweeeeeeeeeeCis:ajjap*///;.int 2298589328,898451655,12,178790,1018168591,84934449,12597/*
#define p sizeof'p'-1?"38":"37"
#include<stdio.h>
main ( ){puts(p);}/*
print 61
#}
disp 49;
#{
}<>
$'main'3
#-3o4o#$$$
#<T>"3"O.s
=end
"""#"
#}
#s|o51~nJ;#:p'34'3\=#print (17)#>27.say#]#print(47)#]#echo 21# xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi ax fwwvwWWWwWWWWwvwWWwWWWwvwWWwWWWwvwWWwWWWwvwWWwwwwwwwwwwwWWWwWWWWWwWWWWWWWwWWWWWWWWWwWWWWWWWWWWWWWWWwWWWWWWWWWWWWwvm 
# sss8␛dggi2␛`|$// ''25  16*///~-<~-<~-<<<~-XCOprint("65")#s^_^_2229996#

VIP评分（多功能整数打印机）：. 005949（为提高此效果，下一个条目不得超过1710字节）

在线尝试！

撞倒

此程序将打印65在ALGOL 68，64中的痛苦，63在布赖恩＆夹头，62在草，61在筒仓，60在Moorhens 2.0，59在TCL，58在KSH，57在怀斯，56直流，55在脑-Flak经典，54在岩组，53押，52在COW，51组装时，50在击，49在八度，48在Deadfish〜，47百合，46在Cubix影院，45在PicoLisp，44在alphuck，43在网状，42在恶，41在brainfuck，40在最小-2D，39中的CoffeeScript，38在C，37在C ++，36在迷宫35中INTERCAL，34在轨，33在事件中，在Whirl中为32，在SNUSP中为31，在Whitespace中为30，在Trigger中为29，在Brain-Flak中为28，在Perl 6中为27，在05AB1E中为26，在Pip中为25，24在Thutu，23在Hexagony，22在欠载，21在稔，20在前奏，19在礽，18在基数，17在朱，16在Pyth，15在草堆，14在Turtlèd，13在红宝石，12中裂变，11在Befunge-98，10在Befunge-93，9在Perl 5，8在视网膜，7在Japt，6在SMBF，5在Python 2，4在> <>，3在Minkolang，2在V / Vim的，和1在Python 3。

验证

可以使用上述测试驱动程序来测试大多数语言，但是必须在本地测试6种语言。

• 可以测试Reng 在此处输出19 。

• 模块化SNUSP可以在此处测试输出31 。

• 通过手动平衡令牌验证了事件是否测试33。

• 使用此解释器，可以测试Deadfish〜在本地输出48个。请注意，Deadfish〜将多语言输入stdin，但是将许多>>提示打印到标准输出，这是运行任何Deadfish〜程序不可避免的结果。

• 使用该解释器可以测试Moorhens 2.0的输出为60 。

阿尔高68

在编程初期，ALGOL可能是四种高级编程语言中鲜为人知的-这种模糊区别的其余语言是COBOL，FORTRAN和Lisp。ALGOL在当时的学术和数学界广为人知，但今天以对现代语言的巨大影响而闻名。实际上，大多数现代实用语言都可以被描述为“类似Algol的语言”，其中不乏C，它当然具有自己的影响力和衍生性。

我很高兴加入ALGOL，因为它是计算机历史上另一个重要的踏脚石，我们可以添加到这个纪念碑上，我们称之为多语种。那是很酷的东西。

ALGOL68是三个主要ALGOL规范中的最新版本，其他两个均为ALGOL60和ALGOL58。有趣的是，该规范没有固定的语法，这意味着定义了标记，但没有定义拼写。例如，这使语言高度依赖于解释器，因为任何给定的解释器都可能使用其他符号来启动注释块。该规范将¢称为启动注释块。但是，由于¢不是127种基本的ASCII代码之一，因此可以理解的是，在可用的解释器中，该注释没有被用作注释指示符。事实证明，Genie解释器的拼写¢为#，这是我们经过字符1并制作多语种所需的所有开头。

实际上，Genie具有三个注释语法选项，另外两个为co和comment，这两个选项均指定为以粗体显示。是的，大胆。如果我们使用斜体，那是一个变量。精灵通过大写大写来再次为我们解决了这一问题。而且由于CO它不在多语言环境中，因此我们有一种简单的方法可将多语言环境从解析器中隐藏。如果CO某种语言需要深入研究，我们可以切换到更详细的COMMENT语法。

ALGOL中没有行注释-它们都是块样式，这意味着它们需要终止。给定多语的初始状态，我们的ALGOL块注释将立即打开并在第1行的结尾处终止，因为Turtlèd同样#用作跳转令牌。幸运的是，Turtlèd遍历Cand O字符没有问题，因此在第一行中，我们可以CO在第二行之后立即插入#以启动ALGOL68的胖块注释。

从这里我们只需要在COprint("65")某个地方放置即可。我选择了最后一行，因为我希望在行末添加另一个#注释，并且我不希望注释#在最后一行的开头终止。因此，我们遵循ALGOL打印语句，以#s和#作为多语言中的最后一个字符。该s中#s是alphuck，以平衡p打印。

感谢@ ais523用答案59打开多语言的结尾，并使所有这些成为可能。

高炉

我们在通配符的末尾添加了一个不同的字符以终止ALGOL的最终评论，而SMBF以前正在读取最后一个字符作为其答案。为了解决这个问题，我不得不改变SMBF通过改变在第8行的代码读取第二到最后一个字符[.>-]到这个[<.>>-]。这是一个SMBF专用代码块，因为启动循环时BF的MP为0。

触发

在这一点上，我注意到SMBF出现了一些怪异的行为，这与这些代码段之间以及多语种末尾的关系有关。

•事件的跳转目的地： ^_^_

•触发器的跳转目的地以及答案： X222999

•ALGOL68的答案： COprint("65")#s

ALGOL的答案在其代码段中标记了几个事件标记，因此ALGOL的代码必须先于事件的代码段。如果按顺序排在第一位，则ALGOL还会导致前奏对齐问题，因此必须排在第二或第三位。同时，当事件代码最后执行时，SMBF发生了莫名其妙的故障，因此事件必须首先执行。好吧，我意识到这是一个入门逻辑问题，似乎无法解决，因此我着手使无法解释的事物更加适用。

经过SMBF之后，我发现结尾处带有^ _ ^ _的问题是由于Wise造成的。~-<~-<~-<<<~-与大多数多语言系统不同，Wise的代码（）没有隐藏在非执行循环的后面。但是Wise的代码中没有SMBF打印代码。只是在更改内存值。似乎无害。那是什么问题呢？就是在高炉前的那个织补。

Wise的代码正在更改将要执行的代码中的字符，您能猜出它的ascii值邻居^是什么吗？是]。明智的做法是将SMBF循环终止符放在多语言的末尾，导致SMBF陷入无限循环。真不好意思。

经过深思熟虑，我采用了0字节的解决方案来解决问题，并将Trigger的跳转目标（X）与其答案（222999）分开，从而结束了多语种：~-<~-<~-<<<~-XCOprint("65")#s^_^_2229996#。这之所以有效，是因为没有字符连续触发而不是触发器的答案。

包起来

这是本轮的所有主要变化。我做了些小改动以减少讨论的内容c 1行中，但这仅是为了进行高尔夫更改。

祝好运！

事故报告

#<q>"3"O.s成为#<T>"3"O.s因为去令牌化T而不是q更有效地平衡

<>{变得通<>{nd证化 nd和{␊

把之间的空间}}，并+在#<]}} +<[<.>>-]>[以detokenize }}+更便宜。

2. V（11个字节）

print(1)#i2

该程序在Python 3中打印1，在V中打印2。

只是为了使事情顺利进行，并尽早将我最喜欢的语言投入使用。:)

这是一个非常简单的答案。

print(1)#

碰巧是V中的NOP。（对我来说是幸运的）然后i2进入插入模式并插入“ 2”。您可以在这里在线尝试V

当然，在python中

print(1)

打印'1'，并且

#i2

是一条评论。

20.前奏，167字节

#v`16 "<" 6/b0\ .q@#;n4"14""
#>3N9@15o|R"12"*^*ttt*~++%
#=|
print((1/2and 9 or 13)-(0and+4)^1<<65>>62);#35(99999+++++!) =#;print(17)
#       ~nJ<
#
#gg99ddi2` |1|1+6

在同一个地方文字ESC字符在先前提交（之间的#和g，和之间的2和`，在最后一行），因为你不能把Vim的出与可打印字符插入模式。

此程序将打印20在前奏，19在礽（可测试此处），18在基数，17在朱，16在Pyth，15在草堆，14在Turtlèd，13在红宝石，12在裂变，11在Befunge-98，10在Befunge-93，9在Perl，8在视网膜，7在Japt，6在SMBF， 5在Python 2中。，在4 <> 中处于4，在Minkolang中处于3，在Vim / V 中处于2，在Python 3中处于1和a partridge在梨树中

现有的代码在Prelude中几乎将其自身抵消掉了，仅由带有假参数的while循环和一些我们不关心的堆栈操作组成。更好的是，在代码中有一个地方，在使用它们的所有语言中（在先前提交的#和之间）都有注释=#。使Prelude适应这一难题的难点在于，仅使用一个堆栈就可以生成数字，而又不会增加字节数。该程序使用一个循环，该循环向每个堆栈元素添加45，并将其输出为ASCII，因此，通过在堆栈上的3上方放置5，可以得到20输出。（整整齐齐地，输出20比Prelude中的19更容易输出，因此发布答案19实际上对我有所帮助。）

30. 空白，296字节

#v`16/"<"6/b.q@"(: ::T):  ␉␉␉␉ :(22)S#;n4"14"
#>3N6@15o|>␉^*ttt*~++~~~%
#=~nJ<R"12"; ␉
#[␉
#`<`|
print((eval("1\x2f2")and (9)or(13))-(0and 4)^(1)<<(65)>>62)or'(\{(\{})(\{\/+23!@}[()])}\{})(\{}\{})'#46(8+9+9+9+9+=!)=#print(17)#]#echo 21#|/=1/24=x=90/
#8␛dggi2␛␉` |1|6$//''25  #>say␉␉ 27#T222999"26

␛代表字面转义。

␉代表文字标签。

此程序将打印30在空白，29在触发器，28在脑高射炮，27在Perl 6，26在05AB1E，25在匹，24在Thutu，23在Hexagony，22在欠载，21在稔，20在前奏，19在礽（测试此处），18在基数，17在朱，16在Pyth， 15在草堆， 14在Turtlèd， 13在红宝石， 12在裂变， 11在Befunge-98， 10在Befunge-93， 9在Perl 5， 8在视网膜， 7在Japt， 6在SMBF， 5在Python 2， 4在> <> ， 3在Minkolang， 2在V / Vim的，和 1在Python 3。

空格是另一个字符集有限的esolang。这只读取制表符，空格和换行符。

因此，一旦我们清除了Whitespace无法读取的所有内容，我们将得到以下代码：

[space][space][space][LF]
[space][LF]
[LF]
[LF]
[LF]
[space][space][space][space][space][LF]
[space][space][space][space]

输出30的代码是这样的：

[space][space][space][tab][tab][tab][tab][space][LF]
[tab][LF]
[space][tab]

因此，现有代码的前3行在行末提供了额外的空格以满足要求。请注意，第1行的制表符和尾随空格位于该行的中间，以适应> <>的需求。

第2行的空间在此处更改为选项卡。这似乎与2D语言的空间功能相同，但在视觉上不再对齐。¯\ _（ツ）_ /¯

在输出30的指令之后，游戏开始获取其余必要的空格和换行符，以进行毫无意义的工作并正确编译。

空格碰巧有一些指令，该指令使用允许任意数量的制表符和空格的标签来标记/转到代码位置，从而有助于收起长行的空格。它也以换行开始和结束，因此帮助我们提高了3-6行中的某些换行。

最后一行在不中断Retina的情况下无法换行，因此其指令是进行一些任意的数学运算和堆栈操作。

这是用空格，制表符和换行符替换为我们的符号的完整代码：

#v`16/"<"6/b.q@"(:[Space]::T):[Space][Space][Tab][Tab][Tab][Tab][Space]:(22)S#;n4"14"[LF]
#>3N6@15o|>[Tab]^*ttt*~++~~~%[LF]
#=~nJ<R"12";[Space][Tab][LF]
#[[Tab][LF]
#`<`|[LF]
print((eval("1\x2f2")and[Space](9)or(13))-(0and[Space]4)^(1)<<(65)>>62)or'(\{(\{})(\{\/+23!@}[()])}\{})(\{}\{})'#46(8+9+9+9+9+=!)=#print(17)#]#echo[Space]21#|/=1/24=x=90/[LF]
#8␛dggi2␛[Tab]`[Space]|1|6$//''25[Space][Space]#>say[Tab][Tab][Space]27#T222999"26[LF]

这里是空白的注释版本：

Push 30 onto the stack
[space][space][space][tab][tab][tab][tab][space][LF]

Output the number at the top of the stack
[tab][LF][space][tab] 

Jump to label null if the top of the stack is negative. (it's not)
[LF][Tab][LF]

Label this location as [Space]
[LF][Space][Space][Space][LF]

Add the top two items on the stack and replace them with the result. 
[Tab][Space][Space][Space]

Store the stack.
[Tab][Tab][Space]

编辑：六角形原来像空格一样跳过制表符，这与我之前的主张相反。@ ais523非常友善，可以更新@Kenney的Hexagonizer以解决字面转义和制表符。我必须对其进行修改，以更正先前关于将制表符读取为无操作的断言，并替换为文字转义符，.因为该␛字符比其他字符宽，从而使十六进制略有对齐。这里的链接。

这是我们更正后的当前十六进制：

          # v 1 6 / " < " 6 /
         b . q @ " ( : : : T )
        : : ( 2 2 ) S # ; n 4 "
       1 4 " # > 3 N 6 @ 1 5 o |
      > ^ * t t t * ~ + + ~ ~ ~ %
     # = ~ n J < R " 1 2 " ; # [ #
    < | p r i n t ( ( e v a l ( " 1
   \ x 2 f 2 " ) a n d ( 9 ) o r ( 1
  3 ) ) - ( 0 a n d 4 ) ^ ( 1 ) < < (
 6 5 ) > > 6 2 ) o r ' ( \ { ( \ { } )
  ( \ { \ / + 2 3 ! @ } [ ( ) ] ) } \
   { } ) ( \ { } \ { } ) ' # 4 6 ( 8
    + 9 + 9 + 9 + 9 + = ! ) = # p r
     i n t ( 1 7 ) # ] # e c h o 2
      1 # | / = 1 / 2 4 = x = 9 0
       / # 8 . d g g i 2 . | 1 |
        6 $ / / ' ' 2 5 # > s a
         y 2 7 # T 2 2 2 9 9 9
          " 2 6 . . . . . . .

最后，我打了一些不必要的字符，大多数是以前添加的，用于使Prelude括号和Hexagony六角形对齐。

Nim的代码是echo 21从echo 5+5+11

六角形#@46现在#46

六角的代码是/+23!@=从/+23!@

Prelude的括号对齐(9) or (13)变为(9)and(13)

好吧，这就是我所拥有的。祝大家好运！

100.brainbool，2953字节

#16  "?63(o?23!*# #@"/*\DZZCv;'[af2.q]PkPPX)\('#CO"14"; */
#/*0|7//```"`  [>.>.])[-'][(>77*;,68*,@,1',;# l1011)(22)S\4n;iiipsddpsdoh coding:utf8ââââ(1P''53'S^'????!?!??!??!!!!???!?!??!!?!?!!!!!?!!!!?????!????????????????????!) (qx
#>â
# 36!@â`  e++++++::@ 
#~
#y
#`<`
#<<<#>>]}}+-[.+..]+-+<[<<.>>x>-]>[
#{
#x}
#2""/*\*
#=x<R+++++[D>+++++++q   L+++<-][pPLEASE,2<-#2FAC,2SUB#1<-#52FAC,2SUB#2<-#32FACREADOUT,2PLEASEGIVEUPFACs]>@@+.---@.>][
#x%+>+=ttt Z_*.
#D>xU/-<+++L
#R+.----\   \).>]4O6O@|
#[#[(?2?20l0v01k1kMoOMoOMoOMoO MOO0l0ix0jor0h0h1d111x0eU0y0yx0moO1d0y0e0e00m1d0i0fx0g0n0n11MoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOmOoMOo0moo0n0tx0t0moO0f0t0gOOM0g0f0h0j0j0i0001k1x0vx0v0l111111^_0 )0\\
[  "]56p26q[puts 59][exit]" ,'\[999'];#/s\\/;print"24";exit}}__DATA__/
###x<$+@+-@@@@=>+<@@@=>+<?#d>+.--.<!\
'(wWWWwWWWWwvwWWwWWWwvwWWWw WWWWWWWWwWW/"78"oo@WWwWWWWWWWwWWWWWWWWwwwwvwWWWwWWWWwvwWWwWWWwvwWWwWWWwvwWWwWWWw              (([5]{})))â\';';print((eval("1\x2f 2")and 9or 13<< (65)>>65or 68)-(0and 4)^1<<(65)>>62)or"'x"or' {}{}{}{}({}<(((((()()())){}{})){}{})>)(({})5){}x{(x<(<()>)({})({}<{}>({}){})>){({}[()])}}({}){}({}()<()()()>)wWW no no no no no no no no no no no no no no no no no no no no no no no no no no no no no no os sp '#}#(prin 45)(bye)46(8+9+9+9+9+=!)((("3'3)))"'a'[[@*3*74[?]*]*(<*.*\>]xxxxxxxxxxxxx)'# \\
__DATA__=1#"'x"
#.;R"12"'
###;console.log 39;'(******* **********819+*+@[*99[?]*]***|!)'
#\\
""""#\
' ( <><        (          )>  ){ ({}[()]  )}{\';      a=$(printf \\x00    );b=${#a};#\\
" }"';           ((   ( (';case "{"$ar[1]"}"${b} in *1)echo 54;;*4)echo 78;; *1*)echo 50;;*)echo 58;;esac;exit;# (((('))))#\
=begin
#p             +555/2+55x%6E2x
;set print "-";print 89;exit#ss 9
utpb now 70 dollar off!
utpb has been selling out worldwide!
#9999 9 seeeemPaeueewuuweeeeeeeeeeCis:ajjappppppp😆😨😒😨💬95💬👥➡
👋🔢🌚🌝🌝🌚🌚🌚🌚🌚

set ! 57
set ! 51
More 91 of thiset of re9
How much is it*/
#if 0
.int 2298589328,898451655,12,178790,1018168591,84934449, 12597
#endif//*
#1"" //*
#include<stdio.h> 
#defineâ x(d)â#d
#define u8 "38\0 "
main ( ) {puts( sizeof (0,u8)-5?u8"67":*u8""?"37":     x( 0'0  "'\"")[9]?"75":'??-'&1? "79":"77");"eg5""6 27""e ' Zing  ";}//*/
#if 0
#endif//* --... ...--
/*/
p=sizeof("9( 999 99\"    ); print'(''72'')';end!"            );main( ){puts(  "92");return(9-9+9 -9);}
#if 0â
#endif//* rk:start | print: "69" rk:end<(9    >5b*:,1-,@
print 61
#}
disp 49 ;9;
#{
}{}<>
$'main'3
#-3o4o#$$$
#<T>"3"O.</+++++++>/+++<-\>+++.---.
#<<<#>>> /
reg end="";print(85);reg s#++++++++++++++++++++++++++++++++++++++++++++++++++++++++.-.
=end
;"""#"#xxxxxxxy"78"\++++>/<~#class P{        function:Main(a:String[] )~Nil{83->Print();} }
#}pS9^7^8^MUOUOF@:8:8\\
#s|)o51~nJ;#:p'34'3  \=#print(17)#>27.say#]# print(47) #]#echo 21#fwwwwwWWWwWWWWWwWWWWWWWwWWWWWWWWWwWWWWWWWWWWWWWWWwWWWWWWWWWWWWwvm>++++
#s8âdggi2âM`|$//''  1$6~-<~-<~-<<<~-COprint ("65")#asss^_^_#
#9 "25"  +/ *///X222999686#

VIP评分（多功能整数打印机）：. 002953（为提高此效果，下一个条目不得超过3042个字节）

撞倒

这个程序打印 1在Python 3， 2在V / Vim中， 3在Minkolang， 4在> <>， 5在Python 2， 6在SMBF， 7在Japt， 8在视网膜， 9在Perl 5， 10在Befunge- 93， 11在Befunge-98， 12在裂变， 13在红宝石， 14在Turtlèd， 15在草堆， 16在Pyth， 17在朱， 18在基数， 19在礽， 20在前奏， 21在稔， 22 41在brainfuck， 在欠载中， 23在Hexagony中， 24在Thutu中， 25在Pip中， 26在05AB1E中， 27在Perl 6中， 28在Brain-Flak中， 29在触发器中， 30在空白中， 31在模块化SNUSP中， 32在Whirl中， 在事件中33， 在Rail中为34， 在INTERCAL中为35， 在Labyrinth中为36， 在C ++ 03中为37， 在C99中为38， 在CoffeeScript中为39， 在Minimal-2D中为40， 在邪恶中为42， 在网状结构中为43， 44在alphuck， 45在PicoLisp， 46在Cubix影院， 47百合， 48在Deadfish〜， 49在八度， 50在击， 51组装时， 52在COW， 53押， 54在岩组， 55在脑高射炮经典， 56在直流， 57在怀斯， 58在KSH， 59在TCL， 60在Moorhens， 61在筒仓， 62在草， 63在布赖恩＆夹头， 64在痛苦， 65在ALGOL 68， 66在表面， 67在C11， 68在Python 1， 69在RK琅， 70在商业， 71在什么， 72中的Fortran， 73在莫尔斯， 74在Archway中， 在C ++ 11中为75， 在Trefunge-98中为76， 在C ++ 14中为77， 在破折号中为78， 在C ++ 17中为79， 在Klein 201中为80， 在Klein 100中为81， 在Brain-Flue中为82， 83在Objeck， 84在克莱恩001， 85在ZKL， 86在Miniflak， 87在爱丽丝 88中乒乓， 89中的gnuplot， 90中的RunR， 91在COOD， 92在C89， 93中设置， 94在Emotinomicon， 95在表情符号， 96在EmojiCoder中，在立方体中是 97，在Archway2中是 98，在 99中是99。 100在脑袋

验证

在线尝试！ TIO上不可用的语言：

• Japt，在线 7 。
• Reng，19 在线。
• Deadfish〜，本地 48个。
• Moorhens，当地 60岁。从v2.0-dev分支使用moorhens.py
• 莫尔斯，73 本地
• 牌坊，本地 74
• Trefunge-98，当地 76人。使用-d 3 -v 98了Trefunge-98。
• Objeck，83 本地
• zkl，85个本地
• 乒乓球，本地 88
• RunR，本地 90个
• Cood，91 在线
• 套装，93 在线
• Emotinomicon，94 在线
• EmojiCoder，96 在线
• Archway2，98个本地 我无法测试Archway2，因为我没有适当的C编译器，但是stasoid已经确认它可以在archway2中工作

说明

我不敢相信我们已经做到了100种语言。我想抽出时间感谢参与此过程的每个人。这是一个有趣的旅程，我希望能再增加100个。

Brainbool在我眼中已经有一段时间了。但是，由于brainbool只能输出两个数字，1而且0直到现在我都无法将其相加（我当时不在10和11之间）。

Brainbool就像Brainfuck一样，只不过它不是以256换行而是以2换行。Brainbool也没有，-因为它与一起多余+。我们的输出100的脑袋代码非常简单：

+.+..

为了掩盖brainfuck的输出，我们添加一个循环和一个负号：

+-[.+..]

现在，所需要做的就是找到放置代码的地方。我选择的位置是第+8行上Brainfuck代码的最高级别的第一个位置。为了替代plus，我们添加了我们的代码，而a则在Brainfuck中+-+起作用，+而在Brainbool中则是Noop。

+-[.+..]+-+

库比克斯

我将代码放在Cubix封装之前，导致镜像移动到指针的路径中。为了解决这个问题，我将胶囊移到了有问题的镜子前面几步，一切都很好。

令人惊讶的是，即使是臭名昭著的事件，也没有其他解决办法。

27. Perl 6，235字节

#v`16/"<"6/b.q@"(::):::  (22)S#;n4"14"
#>3N6@15o|> ^*ttt*~++~~~%
#=~nJ<R"12";
#[
#`<`|
print((eval("1\x2f2")and 9 or 13)-(0and 4)^1<<65>>62)#@46(8+9+9+9+9+=!)=#print(17)#3]#echo 21#===2|/=1/24=x=90/
#8␛dggi2␛` |1|6$//''25  #>say 27#"26

␛照常表示文字ESC字符。

此程序将打印27在Perl 6，26在05AB1E，25在匹，24在Thutu，23在Hexagony，22在欠载，21在稔，20在前奏，19在礽（测试此处），18在基数，17中朱，16在Pyth，15在草堆，14在Turtlèd，13在红宝石， 12在裂变，11在Befunge-98，10在Befunge-93，9在Perl 5，8在视网膜，7在Japt，6在SMBF，5在Python 2，4在> <> ，3在Minkolang， 2 Vim中/ V，Python 3中为1，圣诞节期间a partridge为A Pear Tree。

突出显示Stack Exchange为该答案生成的语法是完全错误的。#`<是Perl 6的许多多行注释标记之一，并以结尾#>，因此，在Perl 6中实际运行的唯一代码非常简单say 27。我之所以选择这个特殊的注释标记，<>是因为在大多数语言中都不是匹配对，因此不匹配的标记<不会破坏试图解析它的语言，例如Retina。

我不确定六角形的工作原理了。当它破裂时，我将其使用的一个字符从a +更改为a，0以查看是否被击中；事实证明如此，并最终解决了该问题，但是我不确定为什么（我知道它是由于#执行行中的问题而中断的，但尚不清楚为什么要删除此+修复问题）。（有问题的字符也由Thutu解析，但是幸运的是，这对Thutu程序的功能没有影响，因为在该程序中，任何不带a的字符都将被=字面复制到工作中请注意0and+4从前一行开始的0and 4，使其从六角形的角度缩短一个字符（六角形看不到空格）；这是为了补偿#|上一行的#`<`|，从Hexagony的角度来看，它变长了一个字符（因为它也看不到反引号）。请注意，该代码现在距离扩展Hexagony边长和破坏当前Hexagony代码的所有内容仅五个字节。我还是建议这样做，只是重做代码的Hexagony部分。在扩展后将所有内容放入其中可能会更容易而不是更难。

其他一些语言也进行了更改，主要是为了增加足够的健壮性，使我可以在最后一行插入任意代码。$//是Japt中的注释标记，它允许在行的后面加空格，从而使添加的程序在Japt中不那么脆弱（同时，//如果行的后面有任何右括号，则中断，空格是Japt中的一种右括号）。一对空格是Pip中的注释标记，这意味着此处的Pip代码可以大大简化。这也意味着我们可以将05AB1E简化为琐碎的事情"26。视网膜需要第五行成为能够匹配事物的合法正则表达式（尾随|因此是视网膜）；它与上一个条目中的相应行的解析方式有所不同，但是以同样合适的方式进行。该红衣主教比以前的文章中的要简单得多，但这与所有内容垂直排列的方式纯属巧合，而变化之处在于编写了无论如何都不会做的代码。

假设您重做了Hexagony（您可能必须这样做），那么在后三行的所有位置上都有添加代码的安全位置：3in #3]#仅用于Hexagony（并且易于更改）；绝大多数语言都忽略了#和之间的空格"。除了Retina之外，没有什么东西能真正解析出第五行的结尾。（在很多其他地方也可以添加代码，但这可能是最方便的。）

31. 模块化SNUSP，326个字节

程序

#v`16/"<"6/b.q@"(: ::T):  ␉␉␉␉ :(22)S#;n4"14"
#>3N6@15o|>␉^*ttt*~++~~~%
#=~nJ<R"12"; ␉
#[␉
#`<`|
print((eval("1\x2f2")and (9)or(13))-(0and 4)^(1)<<(65)>>62)or'(\{(\{})(\{}[()])}\{})(\{}\{})'#46(8+9+9+9+9+=!)=#print(17)#]#echo 21#|/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
#8␛dggi2␛␉` |1|6$//''25  #>say␉␉ 27#T222999+/+23!@"26

像往常一样，␛是一个文字ESC字符，␉也是一个文字标签。

撞倒

该程序在Modular SNUSP中打印31，在Whitespace中打印30，在Trigger中打印29，在Brain-Flak中打印28，在Perl 6 中打印27，在05AB1E中显示26，在Pip 中显示25，在Thutu 中显示24，在Hexagony中显示23，在Underload中显示22，在Nim中显示21，20在前奏，19在礽，18在基数，17在朱，16在Pyth，15在草堆，14在Turtlèd，13在红宝石，12在裂变，11在Befunge-98，10在Befunge-93，9在Perl 5，8在视网膜，7在Japt，6在SMBF，5在Python 2，4在> <>，3在Minkolang，2在V / Vim的和1在Python 3。

验证

为什么摘要中没有链接？因为我一直在努力使测试变得更加容易，所以测试驱动程序可以使用此处列出的大多数语言运行该程序并打印结果。希望这将使将来添加多种语言的语言变得更加容易。通过运行以下TIO链接（使用Bash，Perl和A Pear Tree的混合编写的测试驱动程序），可以获取31种语言中28种语言的程序结果：

在线尝试！

该链接还会生成上面所示的␛/ ␉格式的代码块，并将代码格式化为六边形：

          # v 1 6 / " < " 6 / b
         . q @ " ( : : : T ) : :
        ( 2 2 ) S # ; n 4 " 1 4 "
       # > 3 N 6 @ 1 5 o | > ^ * t
      t t * ~ + + ~ ~ ~ % # = ~ n J
     < R " 1 2 " ; # [ # < | p r i n
    t ( ( e v a l ( " 1 \ x 2 f 2 " )
   a n d ( 9 ) o r ( 1 3 ) ) - ( 0 a n
  d 4 ) ^ ( 1 ) < < ( 6 5 ) > > 6 2 ) o
 r ' ( \ { ( \ { } ) ( \ { } [ ( ) ] ) }
\ { } ) ( \ { } \ { } ) ' # 4 6 ( 8 + 9 +
 9 + 9 + 9 + = ! ) = # p r i n t ( 1 7 )
  # ] # e c h o 2 1 # | / = 1 / 2 4 = x
   = 9 [ < $ + @ + - @ @ @ @ = > + < @
    @ @ = > + < ? # > + . - - . ] / #
     8 . d g g i 2 . | 1 | 6 $ / / '
      ' 2 5 # > s a y 2 7 # T 2 2 2
       9 9 9 + / + 2 3 ! @ " 2 6 .
        . . . . . . . . . . . . .
         . . . . . . . . . . . .
          . . . . . . . . . . .

缺少三种语言：V太慢，并且TIO上未安装Reng和Modular SNUSP。幸运的是，这三个人都有在线口译员：

• 您可以在V测试程序/ Vim的（预期输出：2）这里对TIO。
• 这里有一个在线礽解释（预期输出：19）这里。
• 有一个在线的模块化SNUSP解释（预期输出：31）这里。（它只是作为SNUSP解释器进行广告宣传，但模块化SNUSP是它实际实现的方言，如@页面上的所有符号所示。）

所有这三个程序都会产生预期的输出，因此所有31个程序都经过了正确的测试。（我有点担心的是，空白程序是否正确终止；但是，此处的空白与以前的提交相同，因此它们都是对还是错。如果事实证明程序确实终止了，错误地认为，两个程序都可能以相同的方式可修复。）

说明

首先是六角形，似乎总是需要改变。实际上，它比以前简单得多。我将Hexagony代码移动到了Trigger代码之后，这意味着它已经接近程序的结尾，并且打印23并退出的Hexagony“胶囊”几乎立即运行。最后一行通常看起来像是放置胶囊的好地方，因为这意味着可能会破坏Hexagony的命令将减少。

所有其他更改与添加模块化SNUSP代码有关。首先要注意的是SNUSP $在程序的第一个字符处开始执行，并且是一种2D语言，它在离开程序边缘后退出，因此将SNUSP程序放置在长行的末尾（内部Thutu代码（此时Thutu几乎可以接受任何东西），我们可以确保SNUSP不会看到来自其他语言的任何代码，并且大多数其他语言都不会关心SNUSP。一个语言做护理是Perl 6的，这是解析尖括号; 我<在SNUSP代码之前紧跟着放置它，以保持它的快乐（因为括号自然很匹配）。关心的另一种语言是SMBF。.SMBF和SNUSP中的输出，我们不想创建额外的输出。幸运的是，如SMBF所见，该程序<.>>[…] 紧随其后的是SNUSP代码，即当前的磁带元素为0。因此从SMBF的角度将SNUSP代码括在方括号中可以“注释掉”。

至于代码本身，它使用一个著名的技巧在Modular SNUSP中编写常量，在该常量中，您连续编写了许多“启动过程”命令，并有效地创建了一种基本的斐波那契数。基本思想是+对数字1进行编码。@后面加上代码表示的数字，再加上后面减去第一个字符的代码表示的数字；并且=是空操作（因此@=，数字会在其右边翻倍）。在这个系统中，我选择@@@@=+@@@=+#48作为代表。

但是这里有一个问题。用SNUSP编写常量的标准方法使控制流程滞后于程序的开头，并且使用oneliner（出于明显的原因，我想在此处编写）无法将IP指向任何方向，只有正确的方法。这意味着我们必须以某种方式使IP传递整个常量定义并继续向右移动，而无需退出程序（#通常会这样做）。为了解决此问题，我仔细地使用了+始终以开头的数字的定义=。这意味着我可以编写代码以通过将第二个单元格设置为48 @@@@=>+<@@@=>+<#，这是安全的，前提是您不会通过>命令行跳过任何命令。@命令（因此，我们可以控制磁带指针）。另外，我们知道在最后#，第一个磁带单元仍将具有其初始值。因此，我们可以使用第一个磁带单元作为标记，以了解是从过程定义返回还是继续向右移动（这样做时，我们处于大量过程之内，但是通过退出边缘，因此无所谓）。

因此，最终的SNUSP代码为$+@+-@@@@=>+<@@@=>+<?#>+.--.。该$标记程序的开始。+@+-将第一个tape元素设置为1（++-，但是一旦过程以@return开头，它将开始从头开始运行代码-，因此将tape元素设置为0。?#仅当第一个tape元素为非零时才结束该过程；因此我们最终#将第二个tape元素设置为50（从常量定义中选择48，再从后面>+<转到右侧时遇到的两个中添加2），最后，我们要做的就是>+.--.输出ASCII代码51（3）和49（1），并脱离程序的边缘（]在SNUSP中是空操作，并且 /垂直反映控制流，使其从程序的顶部边缘运行）；这一点与Brainfuck的作用相同。

11. Befunge 98，102字节

#v;2^0;7||"<+0+0+0+<;n4
#v0#_q@
#>3N.
#|\w*
#8  ^1b0<
#|
#M`
print(None and 9or 1/2and 1or 5)
#jd5ki2

印刷品：

• Python 3中的 1
• Vim中的 2- 由于某种原因，这需要相当长的时间才能输出...
• Minkolang v0.15中的 3
• 4英寸> <>
• Python 2中的 5
• SMBF中的 6
• Japt中的 7
• 8在视网膜
• 9在Perl
• 10在Befunge 93
• 11在Befunge 98

老实说，我不知道为什么Vim代码需要1分钟才能输出。另外，不知道视网膜是如何工作的。

说明：

#v          Skips the v, which would send the IP down
  ;         Unlike '93, where ; is a no-op, '98 skips to the next ;
            and doesn't execute anything in between
   2^0;     Not executed, unlike Befunge 93
       7|   Pushes 7 onto the stack, and then sends the IP up, because 7 is not 0
n0b1        n clears the stack, and #s are pushed until the stack is [0, 11, 1
    *.      multiplies the top 2 values of the stack to give 11, and prints it (yay!)
      _     Sends the IP right, because the top value of the stack is 0
       q    Ends the program (no-op for '93, which continues to @)

注意事项：

• 在0旁b不在代码的当前状态绝对必要的，堆栈已被清除。如有必要，可以将其删除，但可以在将来可能的程序中预先进行其他堆栈操作。
• 在_q@那里是Retina的一部分（没有它就无法工作，不要问我为什么）。增加的q代码还可以使'98代码运行一个t操作，该操作拆分IP（以及使Retina程序打印8而不是7）。
• 这_不是简单>的事情，因为这会使SMBF部分混乱。

编辑：刚意识到_q@应该应该是@00（其中0可以是〜任何字符），以使程序在将来更加灵活。我太懒了（累了），现在无法更改所有链接。最终将解决它...

编辑2：我没想到很快会有另外6个答案。我想它保持原样。大家好！

35. INTERCAL（C-INTERCAL），631字节

#v`16/"<"6/b.q@"(: ::Q):  ␉␉␉␉ :(22)S#;n4"14"
#>3N6@15o|>␉^*ttt*~++~~~%
#= >␉1#v#v0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#[␉
#`<`|
print((eval(" 1\x2f2")and(9)or(13))-(0and 4)^1<<(65)>>(62))or' (\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1111|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"␉*
""""#//
=begin␉//
$'main'//
#-3o4o#␉
=end   #//
"""#"#//
#0]#echo 21#/ (\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE) a
#   +/Jn~
#8␛dggi2␛`␉|1|6$//''25  >>>#>27.say# =#print(17)#$nd^_^_.]Q222999/+23!@1#"26

␉是文字标签，␛是文字ESC字符；Stack Exchange会破坏程序，否则。如果您要对其进行处理，建议从下面的TIO链接的“输入”框中复制该程序。

在线尝试！

撞倒

此程序将打印35在INTERCAL，34在轨，33在事件，32在涡动，31在模块化SNUSP，30中的空白，29在触发器28在脑高射炮，27在Perl 6，26在05AB1E，25在匹，24在Thutu，23在Hexagony，22在欠载，21在稔，20在前奏，19在礽，18在基数，17在朱，16在Pyth，15在草堆，14在Turtlèd，13在红宝石，12在裂变，11在Befunge-98，10在Befunge-93，9在Perl 5，8在视网膜，7在Japt，6在SMBF，5在Python 2，4在> <>，3在Minkolang，2在V / Vim的，和1在Python 3。

验证

大多数语言都由上面显示的测试驱动程序进行了测试。您可以测试礽在这里和模块化SNUSP 这里 ; 它们根据需要分别输出19和31。我使用官方解释程序在自己的系统上本地测试了事件。

请注意，我对测试驱动程序进行了一些更改，以使其更容易发现隐藏的字符。各种语言的各种NUL字节已潜入程序的输出中。我已经决定这可能不是问题，因为a）各种各样的提交都在这样做，并且b）Befunge解释器似乎添加了额外的NUL字节，即使程序中没有任何暗示（除非我（已经错过了一些东西），因此它一定存在了很长时间，并且可能是解释器工作方式的一部分。（请注意，仍会输出NUL字节的语言-Befunges和Minkolang-尚未针对此提交更改其代码。）

先前的Rail提交是通过崩溃退出的，这是不允许的，但这很容易解决（通过#在Rail程序的末尾添加a 并调整Hexagony以使其匹配），因此我认为这不是主要问题。该解决方案中的Rail可以正确退出。

说明

INTERCAL代码的工作方式

INTERCAL解析整个程序。但是，语法错误是INTERCAL中的运行时事物，而不是编译时事物，通常用于创建注释。（如果尝试执行语法错误，则会使程序崩溃并显示错误ICL000I，这与Wikipedia的错误说法相反。但是，如果可以阻止它以某种方式执行-INTERCAL有很多方法可以阻止命令运行-它将很高兴在不引起问题的情况下不执行。）

这样，我们可以简单地通过首先显式退出程序来防止在文件末尾运行垃圾（无论如何，这是必需的，因为如果在没有显式退出命令的情况下到达程序末尾，INTERCAL会崩溃）。处理程序的启动更加有趣，并且利用了解析器错误。您可以编写类似DO %20 READ OUT #8以VIII20％的概率输出的内容（否则不执行任何操作）。据我所知，C-INTERCAL将第二行上的孤立％解析为表明第一个命令运行的可能性为0％，因此最终始终没有运行它。（我不确定为什么会这样解析，但是查看编译后的代码会显示它生成一个随机数并将其与0进行比较。）

这是将INTERCAL程序拟合到多语言的其余部分之前的样子：

DO,1<-#2
DO,1SUB#1<-#52
DO,1SUB#2<-#32
DOREADOUT,1
PLEASEGIVEUP

这非常简单：实例化2元素数组；将元素分别设置为52和32（十进制）（最好不要提及INTERCAL的字符串编码；我忘记了它是如何工作的，不得不做各种实验来弄清楚为什么这些数字编码35）。将其读出到标准输出；并退出程序。我在末尾添加了一个附加的PLEASE，以终止GIVE UP语句，在程序结束时为垃圾启动一个新的语句，同时保持礼貌对话的可接受范围。当然，INTERCAL在成品中看起来不太像。我会解释为什么。

埋在Ses 的负载下

INTERCAL程序最明显的问题是它包含字母S。这几乎是不可避免的，因为不使用相关字母就无法索引数组。但是，这S是Underload中的输出命令，无法阻止它解析整个程序。唯一的解决方案是将INTERCAL代码放在圆括号内，这是Underload等效于字符串文字的，因此它不会立即运行。

但是，我们^在程序末尾有两个字符，它们执行欠载代码。因此S，如果我们不对其进行处理，那么这些es无论如何都将被执行。我本可以将其更改为另一个字符，但决定保护代码更容易，以使其变得毫无意义。a在Underload中转义一个字符串（这意味着^在执行该字符串时，将仅再次取消转义而不产生有害的副作用）。我们已经有了一个a在say在Perl 6的代码（在代码的这种安排，实际上是足够的，由于不相关的更改）使用。但是，为了使人们不必依赖于此，我添加了另一个a在行的末尾（无论如何，我希望有一个字符使尾随的空格可见，并且因为Hexagony需要按原样填充；请注意，Hexagony在此程序中很容易修复，实际上并没有需要单独讨论）。因此，Underload代码的脆弱性要小得多。

许多工作和困惑的前奏

啊，序曲 通常这不是最困难的语言，但是肯定是这一次。真正的问题有两个：一是在很长的行上添加多余的括号会冒着扰乱Prelude程序的控制流的风险（因为它们创建了一个while循环的等效项），而一个简单的问题就是阻止它们的内联垂直向上（这是导致行上空白随机移动的主要原因）。请注意，空格也给我带来了一些麻烦，但是从空格的角度来看，该程序与上一个程序等效，因此，它几乎是“在不破坏空格的情况下修复前奏”的情况。

我不太确定Prelude目前的工作方式。有一些针对此的修复程序，例如左下角附近的0，但是它们显然不符合我的预期。（Julia代码也最终移到了该行的底部，因为其print语句中的括号确实很难处理。）也许我们只需要把它当作一个谜即可。

裂变反应堆的故障

尽管上面的更改针对的是相当细微的问题，这些问题很难解决，但是仍然存在一个更为明显的问题。DOREADOUT匹配正则表达式R...O，因此将导致Fission在第四个周期产生不想要的输出，该时间不足以输出的预期输出12。而且INTERCAL只有一条指令可以产生输出（除非您将崩溃视为输出）。一种解决方法是尝试在READ和之间添加空格OUT，让我们有时间截取输出，但这使空白很生气。所以有一段时间，我认为这个程序是不可能的。R，L，U，和D是所有入口点在裂变，所有能够潜在运行有问题的代码，并INTERCAL关键字必须是大写。

但是，有一个修复程序，并且是相当令人惊讶的。作为国际化工作的一部分，C-INTERCAL实际上接受多种语言的关键字，同时支持英语和拉丁语。我们无法躲避S这样的，但我们可以回避O; FAC是完美的替代品DO，同样的LEGERE EX意思与READ OUT。（因此，该程序最终以英语和拉丁语混合使用，但这没关系；它几乎不会使它的可读性降低。）因此，我们可以很高兴地让Fission在右下角发疯，而又不让它产生任何输出。我们可以将实际的 Fission代码更改为结尾*而不是;，它会退出整个程序，而不仅仅是一个线程。该代码运行非常快，因此在所有杂散入口点都没有时间造成任何损害之前，它会退出程序。

编织6，Perl 6

下一个问题：Perl 6注释通过匹配<和起作用>。INTERCAL的赋值运算符为<-。幸运的是，这增加了额外的左括号，因此我只需添加几个右括号即可在程序中未解析的位置将其取消（在这种情况下，仅在Pip代码之后）。

但是，我不想更改程序的空白预算，但是移动Julia代码（用于Prelude）最终在最后一行增加了额外的空间；我不得不从某个地方删除一个。双重空格是Pip中的注释标记，因此我几乎无法更改它们。剩下的唯一选择是中的空格say 27。Perl 5高尔夫球手会立即想到“ say+27那就做好了”（+令人惊讶的是，三元制常常派上用场！），但是不幸的是，这不是有效的Perl 6语法。

但是，我们可以做的是将say函数语法更改为方法语法。整数文字有很多方法，包括将它们打印出来的方法，所以27.say同样长度的完美有效程序也是这样。

是正方形吗？不要在那里

因此，下一个问题是我.在程序中添加了额外的内容。SMBF用户将知道这显然是该语言的问题，会产生杂散输出（在这种情况下为NUL字节）。有已经一个.产生杂散输出最后一个节目，但是，这并不意味着我不应该借此机会来修复它。

这里的基本思想是创建一个SMBF循环以注释掉有问题的指令。这意味着四处移动方括号。我从SNUSP代码中获取了它们（因为它们只是出于事件的考虑，而Incident不在乎它们在程序中的位置），并在INTERCAL代码的开头放置了左括号，并且在Trigger之前关闭括号（因此将两个.s 巧妙地隐藏了）。

不幸的是，方括号对Retina有意义。它会看到[…<-#…并说：“那没有道理，您无法创建该范围，因为<它不在之前#”。幸运的是，通过策略上的反斜杠可以轻松解决此问题。

程序中心事件

这是最后一个答案，从现在开始可能会重复发生。各种字符串偶然发生了3次，从事件的角度来看，它们绕程序的中心移动。

最紧急的令牌是1#，如果您天真地进行这些更改，它将出现3次：#= >␉1#在第三行的开头__DATA__=1#和echo 21#。为什么这是个问题？因为1#第三行的重叠在#v其后一行，并且两个重叠的标记导致两个都不被计数。这#v是我们在事件程序发布之前用来注释代码的令牌！我通过在1#程序末尾偷偷摸摸地解决了这个问题（仅跟随三个字符）；解析程序的那部分的语言都没有对它做任何事情。

还有其他各种有问题的令牌需要处理。一对是单字母，P和U；我通过将事件代码中的两个填充器无操作分别从x更改为P或进行处理U，给出了第四份副本。对裂变代码的更改*作为令牌保留，但值得注意的是，这与正常情况有所不同，在事件代码之前出现两次，在之后出现一次。因此，我没有删除它，而是使用它来部分平衡LE了INTERCAL代码中出现的新令牌。这足以将程序的中心移回0o令牌。当然，对程序的更改很可能会干扰这一点。（我尝试让入射到TIO失败，原因是libdivsufsort不是那里提供，所以看起来我们可以从一个新的解释中受益，尤其是在JavaScript，以便它可以在网上运行。如果你有兴趣，就来看看这个问题。）

1. Python 3（8字节）

print(1)

该程序在Python 3中打印1。

首先从Python 3开始，因为我知道它对多语种很有用，并且可以在许多不同的方向上使用（而且，我想确保第一个答案是使用相对正常的语言，而不是难以理解的荒谬的esolang与）。

10. Befunge，95个字节

#v02^0;7||"<+0+0+0+<;n4
#v0#@00
#>3N.
#|\w*
#8
#|
#M`
print(None and 9or 1/2and 1or 5)
#jd5ki2

在最后一行之间j和d最后一行（grr，@ ais523）都有一个文字ESC字符。它不包含在此代码中。要获取实际代码，请转到Try it online链接。

这将打印1在Python 3，2 Vim中，3在Minkolang，4在<> <，5在Python 2，6在SMBF，7在Japt，8在视网膜，9在Perl和10在Befunge。

此代码*与Retina以及.Minkolang和SMBF共享。

在线尝试

说明

实际程序

#v02^
    @
    .
    *



    t
    5
#v02^

最后一行是为了清楚起见而写的（Befunge操场是循环的。）

#

蹦床跳 v

02^

推动0然后2叠放并上升。

5t*.@

推送5，无操作，将堆栈中的两个元素（2和5）相乘，打印，结束程序。

21. Nim（161字节）

#v`16/"<"6/b.q@#;n4"14""
#>3N6@15o|> ^*ttt*~++ %
#=~nJ<R"12";
#[

print((1/2and 9 or 13)-(0and+4)^1<<65>>62)#46(89999+++++!)=#print(17)#]#echo 21
#8dggi2` |1|6

最后一行<ESC>之间8d和之间的2 s 2`。您可以说我以前的一个人赶时间打高尔夫球，因为我今天早上醒来，意识到我还可以再打一堆。我有152个字节，但是这似乎只在Perl 5.24.0中有效，因此为了与TIO兼容，我暂时保留了原始表达式。

在Python 3中打印1，在V中打印2，在Minkolang中打印3，在<<>中输出4，在Python 2中输出5，在SMBF中输出6，在Japt中输出7，在Retina中输出8，在Perl中输出9，在Perl中输出10，在Befunge-93中输出11，在Befunge中输出11 -98，在裂变中使用12，在红宝石中使用13，在图尔特使用14，在干草堆中使用15，在Pyth中使用16，在Julia中使用17，在Cardinal中使用18，在Reng中使用19，在Prelude中使用20，在Nim中使用21。

请注意，ideone.com上的Nim使用的是0.11.2版本，这有点太旧了，因为该程序依赖于#[ ... ]#2016年初添加的多行注释。

感谢Cardinal的Windows解释器，我的工作流程现在由两台笔记本电脑和http.server两者之间的Python组成。

编辑-更多提示：

• 在8最后一行的开头是视网膜的限制设置为第8场比赛，否则没有它的视网膜会输出2。请注意，这意味着最后一行正则表达式现在仅需要在倒数第二行中匹配至少8次，而不是精确地匹配8次-在我干预期间，我修改了Prelude以使Retina正确，但最后却没有必要。
• 第一行结尾的引号不匹配是为了使Pyth不会抱怨其余代码的语法无效。
• 如果您修改第二行，则可能必须更改 6@ Minkolang的，这会使指针跳6个空格以落在上^。
• 有一对 []现在，因此SMBF必须先位于0的单元格上，然后才能到达[，否则内部需要清除该单元格。

高尔夫可能还有更多（甚至现在我在%红衣主教之前看到一个迷路的地方），但是我应该在凌晨停止打高尔夫球。

51. 汇编（x64，Linux，AS），1086字节

#16  "(}23!@)(" 3//*v\D@;'[af2.qc]'#)"14";n4
#/*` PkPPZ (22)S"[!(>7 7*,;68*,@;'1,@␉␉␉␉ q
#>␉
# >36!@␉
#`<`
#<]+<[.>-]>[
#{
#z}
#
#=x<R+++++[D>+++++++EAL+++<-][pPLEASE,2<-#2DO,2SUB#1<-#52PLEASE,2SUB#2<-#32DOREADOUT,2DOGIVEUPDOiiipsddsdoh]>+.-- -. >][
#x%+>+=+~tt .
#D>xU/-<+++L
#R+.----\).>]|
#[#[(}2}20l0v01k1kx0l0ix0jor0h0h1d111x0eU0bx0b0o1d0b0e0e0@O6O4/0m1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10vx0v0l111111^_)  0046(8+9+9+9+9+=!)
###|
'\';echo 50;exit;';print((eval("1\x2f2")and(9)or(13))-(0and 4)^1<<(65)>>(62))or"'x"or'({({1})({1}[(0)])}{1}\{1})'#}#(prin 45)(bye)|/=1/24=x<$+@+-@@@@=>+<@@@=>+<?#d>+.--./
__DATA__=1#"'x"//
#.\."12"__*'
###;console.log 39
""""#//
=begin //
#sseemeePaeueewuuweeeeeeeeeeCisajjap*///;.int 2298589328,898451655,12,178790,1018168591,84934449,12597/*
#define p sizeof'p'-1?"38":"37"
#include<stdio.h>
main ( )/*/
#
#"`#"\'*/{puts (p);}/*'"`"
/*
<>{#65}//
#}
disp 49#//
#{
1}<>//
$'main'//
#-3o4o#$$$
#<R>"3"O.
=end #//
"""#"#//
#}
#s|o51~nJ;#:p'34'\=#print (17)#>27.say#]#print(47)#]#echo  21
#sss8␛dggi2␛ `|1|6$//''25  16*///89^_^_Z222999"26

␉是文字标签，␛是文字ESC字符；Stack Exchange会破坏程序，否则。如果您要对其进行处理，建议从下面的TIO链接的“输入”框中复制该程序。

想了解更多？尝试polygot聊天！

在线尝试！

VIP评分（多功能整数打印机）：. 008186（为提高此效果，下一个条目不得超过1151字节）

此程序将打印51组装时，50在击，49在八度，48在Deadfish〜，47百合，46在Cubix影院，45在PicoLisp，44在alphuck，43在网状，42在恶，41在brainf *** ，40在最小-2D，39中的CoffeeScript，38在C，37在C ++，36在迷宫35中INTERCAL，34在轨，33在事件，32在涡动， 31在模块化SNUSP，30在空白，29在触发器28在脑高射炮，27在Perl 6，26在05AB1E，25在匹，24在Thutu，23在Hexagony，22在欠载，21在稔，20在前奏，19在礽，18在基数，17在朱，16在Pyth，15在草堆，14在Turtlèd，13在红宝石，12在裂变，11在Befunge-98，10在Befunge-93，9在Perl 5，8在视网膜， 1在Python 3。在Japt中为7，在SMBF中为6，在Python 2中为5，在<<>中为4，在Minkolang中为3，在V / Vim中为2，以及

验证

大多数语言都由上面显示的测试驱动程序进行了测试。

• 可以测试Reng 在这里输出19。

• 模块化SNUSP可以在此处测试输出31。

• 在这里查看Cubix的立方体形状

• 如前面的答案所述，通过使令牌保持平衡来检查事件。

• 对于Deadfish〜，可以使用this测试输出48 。请注意，Deadfish〜会将多声源送入stdin，但会打印许多>>提示到标准输出，这是运行任何Deadfish〜程序不可避免的结果。

• 可以在此处测试组装以输出51

谢谢和祝贺

当两周前@ ais523的50合1 k答案下降时，我的脸颊上流下了一滴泪。太漂亮了。它在Bash中。太完美了。

我转向妻子，说：“我认为通晓多语了”，感到无比自豪。

她转过头看着我，停了一下，说：“好。现在把垃圾拿出来。”

她的意思是她为我和我的互联网朋友感到非常高兴。谢谢并祝贺大家。

组装说明

在随后的日子里，在发布Bash之前不久，我的头脑一直在回想着@ ais523在通俗易懂的聊天中所说的话。他指出，#基于汇编语言的行注释有一些汇编用法，/*块注释。好了，这足以让我在接下来的2周内逐渐失去理智。

多种语言中要包含合法语言存在一种隐含的挑战。我在这里非常宽松地使用合法一词，但是我认为我们都可以理解我的意思。包括Brainf ***是一回事，但是完全包括Mathlab或R等则是另一回事。Assembly当然属于后者，而我的想法无法接受。但是我对议会一无所知，所以这是一场艰苦的战斗。

在花了一段时间解决这个问题之后，寻找一种使Assembly和C / C ++共存的方法，我发现这是GNU汇编程序的文档：

为了与过去的汇编器兼容，以'＃'开头的行具有特殊的解释。在＃号之后应是一个绝对表达式（请参阅表达式）：下一行的逻辑行号。然后，允许使用字符串（请参见字符串）：如果存在，则为新的逻辑文件名。该行的其余部分（如有）应为空白。

我注意到这与多语言的第1行中的C / C ++预处理程序指令非常相似。经过反复试验，我发现#1 “bla” 1//*仅对Assembly输入了块注释。

这样就产生了一个多语种。

解决了最大的阻塞问题后，我着手研究了这个世界示例。

.intel_syntax noprefix
.section .data
     msg: .asciz "51"
.section .text
.global _start
_start:
    # write syscall
    mov     rax, 1
    # file descriptor, standard output
    mov     rdi, 1
    # message address
    mov     rsi, OFFSET FLAT:msg
    # length of message
    mov     rdx, 14
    # call write syscall
    syscall
    #End the Program
    mov    rax, 60
    mov    rdi, 0
    syscall

主要作者的信用

实际上，我在一分钟前撒了谎，我使用的汇编代码的第一个版本是AT＆T语法的，这是汇编的两个语法分支之一。AT＆T语法的主要元素之一是它的寄存器引用使用%前缀，这对于多语言是一个问题。红衣主教将其%用作指针的原点，因此，如果我们乱扔一堆%大约，它就像是第二次裂变反应。

另一个不用%作寄存器前缀的语法分支称为Intel语法。我们在多语言中使用的漏洞利用可以通过第一行并输入块注释，该漏洞利用在GNU汇编器（简称GAS或AS）中。AS具有允许两个语法分支的快乐功能。您只需要声明要使用Intel语法即可，这是在汇编代码的第1行上发生的。

程序集使用寄存器，这些寄存器实际上是位于CPU上的少数存储器位置，以提高访问速度。这不仅是Assembly独有的，而且它的用法并未从开发人员的关注中抽象出来。

存在用于不同目的的不同种类的寄存器。从维基百科：

•AX乘法/除法，字符串加载和存储

•字符串操作和移位的CX计数

•IN和OUT的DX端口地址

•MOVE的BX索引寄存器

•SP指向堆栈顶部

•BP指向堆栈框架的底部

•SI指向流操作中的源

•DI在流操作中指向目标

AX在_start函数在线使用这里：mov rax, 1。的r在rax表示存储器是64位的。如果我们将其交换为e，则表示32位内存，这对于使用64位处理器完全有效。我们只是不会使用可用内存的上半部分。要表示16位内存，您只需使用ax，这对我们来说很好，因为我们只是打印整数。因此，我们可以通过将所有寄存器引用更改为16位来获取几个字节。

好的，并不是所有的寄存器引用都可以删除r。mov rsi, OFFSET FLAT:msg。如果您熟悉Assembly，但不熟悉此声明，那是因为这对于AS是半唯一的。至少，这是我从收集这个，这让我黄金下跌的声明只是lea rsi,m。

此后，我有经验地发现，_start:只要发出警告，我就可以击倒正义_p并.global _start完全砍掉。第二，msg:简化为单个字符变量p:。我选择p了字符串变量和启动函数，以抵消s为Alphuck的利益而添加的一些Assembly。

然后，我放入;定界指令以将它们全部放在一行上。这主要是为了避免#//Thutu的利益而在每条线上出现过多的结尾。另外，我注意到汇编器似乎不区分大小写，因此我只对大小写不同的字符进行大写或小写以避免事件不平衡。

这次高尔夫使我们不得不：

.intel_syntax noprefix;.text;mov ax,1;mov di,1;lea rsi,m;mov dx,2;syscall;mov ax,60;mov di,0;syscall;m:.asciz "51"

毕竟，Japt和Underload是此答案中唯一的问题子级。Japt *在第1行中添加了一些牛肉，但似乎可以通过puts(p);从C ++答案恢复为该行来解决。我最终(也在该行中抛出一个a ，然后在Octive的行中将其关闭。这样一来，Underload就可以停止自我攻击。在第1行添加了类似的处理*。

这足以满足此挑战的字节要求。实际上，我通过生成此版本的多语言版本对此进行了验证。但是我也想尽可能地提高VIP分数。而且由于我已经满足了挑战的所有要求，因此我很乐意合作以简化代码。所以我停下来进行多语言聊天，以寻求高尔夫帮助。

我们必须更深入

@ ais523演示了使用此语句将指令作为机器代码传递给汇编器的技术。

.text;.long 2298589328,898451655,12,178790,1018168591,84934449,12597 机器代码是由CPU直接执行的一系列数字指令，可以用十进制，十六进制或八进制表示。就我们的目的而言，十进制是最短的，因为（十六进制以一个前导0x表示）。.long这里的声明是声明以下是一系列十进制机器代码指令。

好吧，我也仔细看了一下这个声明，以了解汇编程序允许的内容，并进行了一些更改。首先，我发现我可以.text;一起删除所有内容，并且只包含警告问题，这节省了相当多的字节。过了一会儿，我也发现了AS规范文档中的该语句

.long与.int相同

凉。因此，我们可以进行快速字节交换。现在我们的程序集（实际上是机器代码）被简化为：

.int 2298589328,898451655,12,178790,1018168591,84934449,12597。

尽管这一切都很好，但直接使用机器代码还是很困难的，我至少想知道如何进行所有翻译。因此，理想情况下，我们希望将机器代码分解回汇编。最简单的方法是进行对象转储，@ ais523通过此代码段向我演示了此操作。

这是代码片段。

这就是大会。

nop
mov    $0x1,%al
mov    %eax,%edi
lea    0xc(%rip),%rsi
mov    $0x2,%dx
syscall 
mov    $0x3c,%al
xor    %edi,%edi
syscall 
.byte 0x35
xor    %eax,(%rax)

该链接在每行汇编的旁边还显示了一些2个字符的十六进制数字。这些对应于十进制指令。例如，如果你把2298589328进入这个十进制到十六进制转换器，你8901B090回来了。如果仔细观察，这些是对象转储中的前4个十六进制指令（顺序相反）。

据我所知，总是使用4个十六进制数的集合来转换为十进制，这里使用的主要字节保存技巧是构造程序集，以便我们4个十六进制数中的最后几个十六进制数字为00。当我们将它们放入.int刚刚省略的语句中时，将其转换为前导零。

这就是12声明中发生的事情。在对象转储的十六进制部分中为0c 00 00 00。

据我对大会的理解仅用了两个星期。多么速成班！

事件

在较短的装配体实施中，事件是更难解决的问题，因为它使多语种代币的权重重于顶部。这是事件报告。

• ! 第2行中的令牌 !

• EAINTERCAL线路上的第一个会自行解密

• 在倒数第二行的最后一个空格对空格标记进行解密。

• 85 最后一行上的通证

• 将R在#<R>"3"O.detokenizesR

• 65在<>{#65 }//标记化65

• 16 在最后一行解毒

• 89 在最后一行标记自己

红衣主教

我只是意识到我对Cardinal进行了更改，但我没有记录在案。我花了一些时间在寻找节省字节的方法，然后决定学习Cardinal。经过一段时间的文档，我看到了这一行。

= 将指针的有效值复制到其无效值。

这不是在多种语言中使用的技巧。旧的解决方案包括以下指令：`++〜* t

++ 最多2次

~ 更改活动堆栈

* 添加堆栈。

我意识到~*仅用=指令即可实现，因此我对解决方案进行了重新设计，以消除一些无用的堆栈交换并添加了此小字节节省功能。

6. SMBF，45字节

#v<++++<;n4
#>3N.
print('1'if 1/2else'5')
#i2

在线尝试

这个程序打印1在Python 3，2在V，3在Minkolang v0.15，4在> <>，5在Python 2和6中SMBF。

SMBF（又名自我修改Brainfuck）使用<++++<>.。指针向左移动（移至源代码的最后一个字符），单元格增加四次，然后打印。

13. Ruby（129字节）

#v;2^0;7||"<+0+0+0+<*!2'!1'L;n4
#v0#_q@
#>3N.
#|\w*
#8  ^1b0<
#|
#M`
print ((0 and'13')or(None and 9 or 1/2 and 1 or 5))
#jd5ki2

请注意和Esc之间最后一行的文字字符jd，如ais523的Perl回答。

在线尝试！

这将打印1在Python 3，2 Vim中，3在Minkolang，4在<> <，5在Python 2，6在SMBF，7在Japt，8在视网膜，9在Perl，10在Befunge，11在Befunge- 98，12在与裂变 13在红宝石。

只需对现有print语句进行少量修改即可滥用0Ruby中的事实。我必须在其他语句中添加一些空格以使其正确解析。

15.干草堆（141字节）

#v;2^0;7||"<+0+0+0+<*!2'!1'L#'1r'4;n4
#v0#_q@
#>3N.15o|1
#|\w*
#8  ^1b0<
#|
#M`
print ((0 and'13')or(None and 9 or 1/2 and 1 or 5))
#jd5ki2

注意：第三行中有一个ESCafter o，j最后一行中有after

这将打印1在Python 3，2 Vim中，3在Minkolang，4在<> <，5在Python 2，6在SMBF，7在Japt，8在视网膜，9在Perl，10在Befunge，11在Befunge- 98，12在裂变，13在红宝石，14在turtlèd，和15在草堆。

在线尝试！

说明

#v                           go down
 v
 >                           go right
  3N.                        does nothing important
     15o|                    outputs 15 and ends program
                             there is an <ESC> after 'o' since 'o' in Vim enters insert mode
         1                   I added this to satisfy Retina

9. Perl，84个字节

#v;7||"<+0+0+0+<;n4
#>3N.
#|\w*
#8
#|

#M`
print(None and 9or 1/2and 1or 5)
#j␛d5ki2

j和之间的实际代码中有一个文字ESC字符d。为了便于查看，此处已用replaced代替。

这将打印1在Python 3，2 Vim中（本地测试，但这里是对非常相似的语言伏的链路），3在Minkolang，4在<> <，5在Python 2，6在SMBF，7在Japt，8在Retina中，在Perl中是9。

通过滥用在不同语言中工作方式不同的算法，让我们获得更多的外在语言。（None在Python中是错误的，在Perl中是正确的，和and/ or链在两种语言中的工作方式相同。）

除了Python，我还必须更改vim代码。我没有让它变成一系列无操作，而是让它插入垃圾，然后在最后再次删除垃圾。

36. 迷宫，647字节

#v`16/"<"6/b.q@"(: ::Q):  ␉␉␉␉ :(22)S#;n4"14"
#>3N36!@@15o|>␉^?.*ttt*~++~~~%
#= >␉1#v#v0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#[␉
#`<`|
print((eval(" 1\x2f2")and(9)or(13))-(0and 4)^1<<(65)>>(62))or' (\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1111|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"␉*
""""#//
=begin␉//
$'main'//
#-3o4o#␉
=end   #//
"""#"#//
#0]#echo 21#/ (\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE) a
#   +/Jn~
#0␛dggi2␛`␉|1|6$//''25  >>>#>27.say# =#print(17)#$nd^_^_.]Q2229991#;abcd!fghij/+23!@"26

␉ 是文字标签， ␛是文字ESC字符；Stack Exchange会破坏程序，否则。如果您要对其进行处理，建议从下面的TIO链接的“输入”框中复制该程序。

在线尝试！

撞倒

该程序在迷宫中打印36，在INTERCAL中打印35，在Rail中打印34，在事件中打印33，在Whirl中打印，在SNUSP模块化中打印31，在Whitespace中打印30，在Trigger中打印29，在Brain-Flak中打印28，在Perl中打印27，在05AB1E中打印26 ，25的Pip，24的Thutu，23的Hexagony，22的Underload，21的Nim，20的Prelude，19的Reng，18的Cardinal，17的Julia，Pyth的16，Haystack的15，Turtlèd的13在Ruby中，在裂变中12，在Befunge-98中11，在Befunge-93中10，在Perl 5中8，在Retina中7，在Japt中6，在SMBF中5，在Python 2中4，在<<>中3，在Minkolang中3 ，在V / Vim中为2，在Python 3中为1。

验证

大多数语言都由上面显示的测试驱动程序进行了测试。您可以测试礽在这里和模块化SNUSP 这里 ; 它们分别输出19和31。@ ais523帮助调试和修复了事件代码，该代码现在可以工作。

迷宫如何运作

迷宫开始将源中的某些列稍微移位一下，但是经过几步后，指针到达N了第二行的位置（最初，当指针到达那里时，它不再在N那里），向右移动，堆栈顶部为0。然后，它简单地推并打印一个36并终止于36!@

我做过的事

我知道我想添加迷宫，因为它是我所了解的为数不多的依兰。使用它的调试器，我发现通过将最后一行中的8更改为0，Labyrinth不会陷入无限循环，而且奇怪的是，似乎没有其他中断。从那里，我只是转储了我需要的原始命令36和输出命令，而这些命令很容易导致@终止。

然后，要修复我的坏东西：Minkolang，Cardinal和Hexagony。

这!使Minko跳过了需要终止的下一个字符，因此我只添加了一个额外的@。到现在为止还挺好。

第二行长度的变化使Cardinal错过了它的输出语句。尝试.在第一行中添加额外内容使Prelude失去了理智（坦白地说，为什么不知道），所以我采用了另一种方法，将其放在第二行中。那无意中产生了第三个红衣主教指针，所以我用?（不是必需的选择，只是我发现固定裂变和红衣主教的第一件事）填充东西。

幸运的是，Hexagony是一个相对简单的修复程序，我只是扔了几个字母，以便指针找到了代码。我认为字母表不应该出现过，也不会引起事件问题。也是在我意识到自己没有测试事件的时候。感谢@ ai523，我发现我只需要一个额外的感叹号，因此e字母字符串中的更改为!。

多功能整数打印机的得分

只是为了讨好@Stewie Griffin对这个问题的评论，以下是一个片段，显示了如果将每个答案输入“ Verstatile Integer Printer”，该答案将如何得分。

// This was stolen/sloppily hacked together from the snippet here: https://codegolf.stackexchange.com/questions/55422/hello-world. Feel free to clean it up if you'd like.
/* Configuration */

var QUESTION_ID = 102370; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8478; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "http://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=asc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "http://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*)[,\(].*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function getScore(langs, bytes) {
  var l = Math.pow(langs,3);
  return bytes/l;
}

function process() {
  var valid = [];
 
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
        score: getScore(match[1].split(".")[0],+match[2]).toFixed(5),
      });
    else console.log(body);
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery('<a>'+lang+'</a>').text();
    
    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link, score: a.score};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    return a.lang_raw.split(".")[0] - b.lang_raw.split(".")[0];
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.score)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#language-list {
  padding: 10px;
  width: 400px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="language-list">
  <h2>Scores from <a href="https://codegolf.stackexchange.com/questions/65641/the-versatile-integer-printer">The Versatile Integer Printer</a></h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

41. brainf ***，916字节

#  4"16" 3//v\(@#/;\D"14"<;n4
#/*`3 afaaZ">;[77*,68*,@;'1,'1,q)(22)S#   ␉␉␉␉ (
#yy␉;36!@
#`<` ␉
#=␉x
#<]+<[.>-]>[
#␉<
###xR+++++[D>+++++++L+++<-][<<<]>+.---.>][
#px%>~~~+␉+~*ttt*.x
#D>xU/-<+++L)
#R+.----.R␉>]|
#[#yy#yy0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#|␉
print((eval("1\x2f2")and(9)or(13   ) )-(0and 4)^1<<(65)>>(62))or'(\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1111|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"␉*
###; console.log  39
""""#//
=begin␉//
#*/
#define␉z  sizeof 'c'-1?"38":"37"
#include<stdio.h>
int main()  /*/
#()`#`\'*/{puts(z);}/*'``
$'main'␉//
#-3o4o#$$$
<>"3"O.<␉>//
#
=end   #//
"""#"#//
#0]#echo 21#/(\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE)  a>>>
#>27.say# /7Jn~15o|  
#8␛dggi2␛`␉|1|6$//''25  =#print(17) ###^_^_LEintnd"3"z!]/}23!@/*///Z222999"26

␉ 是文字标签， ␛是文字ESC字符；Stack Exchange会破坏程序，否则。如果您要对其进行处理，建议从下面的TIO链接的“输入”框中复制该程序。

在线尝试！

VIP评分（多功能整数打印机）：0.01329

撞倒

这个程序打印41在brainf ***，40在最小-2D，39中的CoffeeScript，38在C，37在C ++，36在迷宫35中INTERCAL，34在轨，33在事件，32在涡动，31中模块化SNUSP，30中的空白，29在触发器28在脑高射炮，27在Perl 6，26在05AB1E，25在匹，24在Thutu，23在Hexagony，22在欠载，21在稔，20在前奏，19在礽，18在基数，17在朱，16在Pyth，15在草堆，14在Turtlèd，13在红宝石，12在裂变，11在Befunge-98，10在Befunge-93 ，在Perl 5中为9，在Retina中为8，在Japt中为7，在SMBF中为6，在Python 2中为5，在Python 2中4，在Minkolang中为3，在Minkolang中为2，在V / Vim中为2，在Python 3中为1。

验证

大多数语言都由上面显示的测试驱动程序进行了测试。您可以测试礽在这里和模块化SNUSP 这里 ; 它们根据需要分别输出19和31。

最后，测试驱动程序已更新为包括Tokenizer。从Bash脚本的角度来看，所有C代码都作为参数存储。我还更改了输出，以在每个标记后用换行符水平包裹而不是垂直输出。这只是我的选择，以使其与空白输出匹配。但是其他任何人都可以更改它，如果他们觉得它太混乱了。

我还对“测试驱动程序”进行了调整，以在调试中处理Turtlèd的UFT8字符的列间距。那错位使我发疯！“修复程序”很容易破解，因为它只是查找è并更改该情况下的列宽，但是可以完成工作。

说明

首先，我想说一下上一篇文章中@SnoringFrog的Versatile Integer Printer Score Rundown代码片段多么出色 。在发布之前，我一直在计算答案，这再次激发了我将其缩小的可能性。我认为我们最终可以击败@ sp3000的答案。

因此，我开始尝试通过尽我所能打高尔夫球来解决这个问题，并且我相当成功。我什至用不同的语言回答了，总字节数小于＃40。但是，当我尝试击打Minimal-2D时，我必须学习BF，以便更好地使用其衍生产品，在此过程中，我发现@Primo的记录打破了Hello，World！。我爱上了优雅。

事实证明，最小2D效率不足以利用@Primo使用的磁带初始化技术，但是我现在认为无论如何它都可能太字节重。我们毕竟只是尝试打印一个整数。但是@Primo确实将我带到了学习如何使用BF的道路上，我将其带到了Minimal-2D的代码中。

然后，所有这些之后，我重新阅读了@SnoringFrog关于如何包括BF的评论，并意识到我不仅可以做到这一点，而且可以使用我在BF答案中打拼的许多Minimal-2D代码。所以我用BF回答了，现在就到了。

在详细介绍之前，还有一件事。我出于非高尔夫原因进行了几处更改。首先，我将添加的大部分代码@SnoringFrog移到了2D语言的最下面几行中。对我来说，这是一项长期的战略举措，它是防止2D语言越过多语言的中心，以尽可能地防止将来的bug。此举的字节命中率很低，所以我坚持下去。

其次，在各种重构过程中，我了解到Begunges和Minkolang在数字输出之后输出尾随空格，这是我们在测试驱动程序中针对这些语言看到的空字节的原因。我通过将堆栈的值输出为ascii代码（不包括尾随空格功能）而不是直接输出值来解决了这些问题。这项更改也带来了很小的损失，但是现在测试驱动程序的输出是如此统一。我怎么可能

SM /高炉

让我们快速介绍一下基础知识。这些是SMBF和BF的唯一有效命令：

>   Move the pointer to the right
<   Move the pointer to the left
+   Increment the memory cell under the pointer
-   Decrement the memory cell under the pointer
.   Output the character signified by the cell at the pointer
,   Input a character and store it in the cell at the pointer
[   Jump past the matching ] if the cell under the pointer is 0
]   Jump back to the matching [ if the cell under the pointer is nonzero

两种语言都有一个存储磁带，用于存储和更改值。SMBF的唯一区别是，无论执行什么代码，都将存储在起始点左侧的存储带中。正如@SnoringFrog指出的那样，使SMBF和BF产生不同的结果取决于将内存指针移至原点的左侧。在Tio的BF解释器中，内存指针能够从原点向左移动，并将找到0，而不是SMBF看到的Polyglot的ascii代码。这里是一个可以在SMBF和BF中运行的示例，以说明两者之间的差异。

在multiglot的开始处，Befunges要求>第二行上的to才能完成，而Perl6要求每>行前面都带有a <。因此，SM / BF首先<>将内存指针留在原点，然后单击a [，这会将两种语言的某些冒犯性字符跳到]第六行。

接下来，我们增加两种语言的原始存储单元，并使用将存储指针移到左侧+<。（按照对话惯例，我们将原始存储单元称为单元0，在原始1、2，...右侧的单元以及在-1，-2，...左侧的单元）。单元格-1在SMBF中包含多行中最后一个字符的ASCII码，在BF中包含0，因此当[遇到下一个字符时，只有BF跳到下一个字符]字符，而SMBF传递到代码中。

在遍历SMBF时，[.>-]它会打印在多声字末尾找到的6，然后将内存指针移回单元格0，将其值设置回零以退出]。回顾一下，这个品脱的磁带是：SMBF的负单元格保持多色，为0，正单元格为零。BF的正负单元格为零，而原始单元格为1。

接下来，>将SMBF移至单元格1，并将BF返回至单元格0，从而使BF进入其专用代码块：（[<+++++[>++++++++++<-][<<<]>+.---.>]我已从中删除了非BF字符）。在这里，我们返回到单元格-1，并将循环控制变量（单元格-1）初始化为值5。然后我们进入循环，在其中将10加到单元格0，然后将单元格-1减五次，然后退出循环。我们将指向值为0的单元格-1。

接下来，我们遇到的[<<<]时候指向零，因此BF不会通过该值。这里的目的是使多个>s与多个s 保持平衡，以<使Perl6不会出错。

此时，单元格0的值为51。ascii值4为52，因此我们将指针移至单元格0加1，然后打印该值。最后，我们将单元格0递减回ascii字符1并再次打印，然后再将内存指针设置为单元格1（值0）以退出]。

SMBF和BF都[位于第8行的最后一个，而它们都停留在0值上。因此，两者都跳过了剩余的Minimal-2D代码，直到]在第11行遇到。但这是短暂的，因为第12行从另一行开始，[这将两种语言都带到了多语言的结尾处，不再遇到任何指令。

重构

最小二维

最小2D的重写主要是为了以类似于BF乘法技巧的方式保存一些字节。但是，Minimal-2D没有用于循环控制的[和]字符。相反，它具有以下命令：

/   Skips next instruction if the data pointer is set to 0.
U   Tells the program to switch to the up direction of processing instructions.
D   Tells the program to switch to the down direction of processing instructions.
L   Tells the program to switch to the left direction of processing instructions.
R   Tells the program to switch to the right direction of processing instructions.

即使在2D庄园中，这些也可用于产生与BF相同的逻辑结构。例如，BF 在Minimal-2D中++++++[>++++++<-]>.等效于此。

这是多语言中Minimal-2D代码的简化版本，其中删除了所有无关的代码，并用替换了所有保留字符的位置#。

###################D
###R+++++[D>+++++++L
###>
D>#U/-<+++L)
R+.----.R

该D在第1行发送指令指针下降到L在发送所述指针左侧的多语种的第8行。在这里，我们将循环控制变量（单元0）设置为7，将内存指针移至单元1并进入循环。在循环中，我们向单元格1加3，然后递减单元格0，然后检查单元格0的值是否为零。如果不是，我们在单元格1中再加上8，然后递减并再次检查。该循环的结果是，在循环结束时将单元格1的值设置为51（6 * 8 + 3）。

我们通过跳出来退出循环U，将内存指针移至单元1，然后在多态的第11行向右下移。最后，我们先递增到4的ascii值，然后递减到0的ascii值，然后再执行右边的结束程序。

视网膜

视网膜有很多要求，而所有BF衍生物都难以满足。它不喜欢连续+的或不匹配的()或[]。但是这些实际上只是其他所有行的要求，因此BF，SMBF和Minimal-2D的许多工作都围绕着将大部分代码放在偶数行上。

但是，仅向Retina提交的一个字节是第|11行的末尾。引用@ ais523“大多数以|结尾的正则表达式。会匹配任何东西”。没有这个，Retina返回0。为什么不解决这个问题，我不知道。我不必过多地研究Retina，可能是因为我一直在避开冗长的路线。但是像Prelude一样，我发现我并不需要了解如何调试它，在这种情况下，它主要包括删除行（以2的倍数为单位），直到找到该行为止。导致它破裂。我基于@ ais523的评论猜中了此修复程序，并获得了回报。我猜我上学太酷了。

红衣主教

我碰巧喜欢@SnoringFrog相对于Cardinal的代码放置的Minimal-2D。考虑到Cardinal不会让Retina感到不适，这是一个不错的位置，并且似乎可以与Minimal-2D进行一些交织。因此，当我开始将Minimal-2D移植到2D土地时，我带着Cardinal一起骑行。不过，对Cardinal进行了一些外观更改。首先，我在Minimal-2D的>语句开头附近添加了一个#p x%>~~~+ +~*ttt*.x变量，以更改其循环内的内存指针/其次，我将所有字符向右移了一个字符，为Minimal-2D提供了退出该循环的空间。在p这一刺就是这个性格填充。

Befunge / 98

Befunges实际上是我开始尝试通俗易懂的地方，因为C ++重构更改了除此代码之外的所有其他2D lang代码。在尝试学习WTF的这段代码时，我在Begunge文档中找到了这一点：

该.命令将从堆栈中弹出一个值，并将其输出为十进制整数，后跟一个空格，有点像Forth。,将弹出的值，把它解释为一个字符的ASCII值，并输出该字符（未后跟一个空格。）

天哪！我们可以清理输出中的空字节。之后，只需要弄清楚如何输入较大的asci值并分离代码即可。Befunge-98有一个跳转代码，;告诉它跳过[77*,68*,@in ;[77*,68*,@;'1,'1,q，这给了我们隔离。

Befunge-98还具有一个命令（'）来获取下一个字符的ASCII码。因此，'1,将代码asci代码用作字符1，将其放在堆栈上，然后使用来打印堆栈顶部值的ascii字符,。只需两次执行此操作即可打印11，然后放一个q退出即可。

适当地设置Befunge不太方便，但仅仅是。在这里，我们必须执行计算以将所需的代码放入堆栈。幸运的是，在相同的输出命令之前，我们的代码很容易与7 * 7和6 * 8相乘,。然后，@在其哥哥的代码污染了输出之前，我们退出了Befunge 。

Minkolang

在找到了Befunge的尾随空格的修补程序之后，我也大肆宣传了寻找Minkolang修补程序的想法，Minkolang的文档说，直到这一点之前用完的输出命令的工作方式与Befunge解释器相同。O碰巧被记录为另一个输出命令，但没有被描述为具有这种Begunge-ness，所以我只是在黑暗中拍摄了一下，然后尝试输出字符串"3"。完美的胜利。

> <>

移动Minimal-2D代码时，我查看的第一件事是验证我是否可以同时移动> <>。如果我要处理2D多语言横向问题，那么我将要处理所有的违法行为。基本上我很幸运进入了将;n4 第1行的末尾移至第1行的解决方案的方式\D。顺便说一句，我不知道> <>能否在答案40之前下移，因为它包含得很好。我想认为以后可以使用它来将> <>与另一种类似的语言分开。

Perl6

<>在此答案中，我已经谈到了Perl6的一些平衡问题，因此我不再赘述。但我确实要指出，我移至#>27.say#倒数第二行。这个答案没有功能性的目的。实际上，我此举是为了满足另一个答案，我最终没有使用此回合。我决定只留下它，因为我计划在下一次机会发布该答案，并且我不想打扰并重新做它。

Bug修复

05as1e

05as1e肯定不像旧版本那样喜欢新的Begunge代码。我想这是,s，因为这是唯一的革命性人物。无论如何，我不得不"在第二行中进一步往后移动以隐藏攻击性命令，而且我知道"必须在Befunge代码路径之前执行，因为"两种语言都是“是”。（我可以像yes-op这样正确地称呼吗？）第2行的2维性很严格，但是我能够<用代替Begunge的代码路径"。在<不过是Perl6的要求。（它必须具有前置<所有的>s。）我能够将<行中的行放置在因本能和先知而解决05ab1e和Perl6的分歧的位置。

旋转

第2行上的Befunge更改在1事件/旋转行之前为多语种添加了额外的内容。这1导致Whirl开始指向方向盘上的错误指令。最先1在C / C ++的预处理指令只是在代码中的行号的参考，这可能很容易被任何其它的行数，所以我任意改变这对4满足涡动。

事件

多语言结尾处的去令牌字符串在这一点上是众所周知的，因此我不再赘述。我从字符串中删除了所能做的，并添加了所需的新令牌。尽管我应该指出，但此字符串中没有2个解令牌字符。首先，这里需要第二个R， #R+.----.R >]|因为它是Fusion的起点，并且在此行上比较安全，因为已经有一个Fusion起点朝相同的方向前进。其次，x在#= x是删除参与令牌␉␊#图案，这已变得更加普遍。

其他

Hexagony，Whitespace和Prelude都进行了通常的细微调整，但没有什么特别值得一提的。

最后的想法

这就是我为这个答案所需要的。对于那些寻找下一个答案的起点的人，我建议邪恶。似乎可行，尽管我没有仔细研究，但我认为集成起来并不难。我知道它有一个跳转命令，应该可以帮助跳过多语言的大部分。祝好运。

183. 英特尔8080引导映像（ZEMU），9870字节

#16  "?63(o+?50;+'51;'  # #@ " /*"r"{\D-v e-'[fa5.q]PkPPX)\( 9 '#CO"14"^ 92                                       7 222222222222222222222222                                                             ##*/
#/*1&7//```"`    [>.>.]       )[-'][(7  >77*,68*,@'_      7 )(22)S    / \iiipsddpsdoh#####(#######??   #### ##  ######     ####         ###### # ####  #######     ####         ###### # ####  #######  a5# \7aa*+42@n; 7 999993 1 7 3 1 8 1 1 55 EEEEEδΘΔΔΔΘΔΘλa k zzzzkf kf k zzzzzd kf k zzzzza kf bfz coding=utf8 p''53'S^'                                                                                                          ! 1>?7ДOq#t#>2/Wr#t#t#q#68#r#t#t#68#q#63#r#t#t#6v#>#</Wr#6}#y/===Wr#7ЯOq#>J7Д/Wr#y<Wr#>5/Wr#t#t#6y#>-=/Wr#6|#>6/Wr122! 1退
#>x#z#111#y#y#y#_#0111118&1& 1111/"78"oo@         xxxxxxxxxxx        /112\     ##### #######   # #    ##### h#115#  o#    ##### ####  ###   #### #  # #####  #    ##### ####  ###   #### #  # #####  #    #
# 36!@`D  e ++++++::@                 L               R.----._      x-----x ########8=,_## ### ###### ######## #### ##### ####### ##### ###    # # #### ### ##### ####### ##### ###    # # #### ### ##### #
#comment -[af] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # ##########  ### ## #####  ## #### ## # #####  ## ##### ####   ##### ## # ##  ## ####  ## ##### ####   ##### ## # ##  ## ####
#~==RtRtRtMbMbMbPSPSPS                                                       # ????!?!??!??!!!!???!?!??!!?!?!!!!!?!!!!?????!????????????????????!                                                           
#[#[]]QhQhQhQrQrQrHnHnHnbqbqbqLzLzLzQtQtQtTcTcTcRQRQRQ                       #
#<<<#++R++  ++++++++++++++++++++++++++++++++++++++++++U+++.._+++++++._       #
############################################################################## 4O6O@
 #-]+-}}[.^x+;;+;;+;;+<>;;+;;+;;+;;;;;;+;;+;;.._]}--<^>++[+++++[>+++++++<-]>._ ++++._+++._^<]+-+<[<<._>>>-]^>[<+++++[>++++++++++<-]>@@+.---@._+>][[
#{  
#=  
#*  
#cs  
#2""/*  
#9999 9 9
#9 999 99 9999 9
#9  
# 9 9999
#`<`(+?+?0l0v01k1kMoOMoOMoOMoOMOOx0l0ix0jor0h0h1d111 0eU0y0yx0moO1d0y0e0e00m1d0i0fx0g0n0n11yxMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOmOotMOo0moo0n0tx0t0moO0f0t0gOOM0g0f0h0j0j0i000x1k1x0vx0v0l11110000011100^_)\\
[ "`e```.1'.0'.6''i]56pq\{}26q[puts 59][exit]" ,'_\['];#/s\\/;print"24"; exit}}__DATA__/
###x<$+@+-@@@@=>+<@@@=>+<?#d>;?\:-._++._++++._#/<?\>3-++._6+---2._#</++++++++++++++++++++++++++++++++++++++++++++++++._++._++++++.>!\
' wWWWwWWWWwvwWWwWWWwvwWWWwWWWW\WWWWwWWWWwWWWWW/WW\wWWWWWWWWwwwwvwWW/WwWWWWwvwWWwWWWwvwWWwWWWwvwWWwWWW ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO MU ([])  ({}<(((((()()())){}{})){}{})>)(({})){}{(<(<()>)({})({}<{}>({}){})>){({}[()])}}({}){}({}()<()()()>)  (<><()>){({}[()])}{  # {((((((\';  a=$(printf \\x00);b=$(echo -n $a|wc -c);case $b[1] in 1*)echo 54;;4*)echo 78;;8*)echo 166;;*1*)echo 50;;*)echo 58;;esac;exit;#)';  print(( eval("1\x2f 2")and(9)or 13<< (65 )>>65or 68)-(0and eval("\"ppp\".bytes.class==Array and(4)or(95==\"ar_\"[2]and 5-96 or-93)"))^1<<(65)>>62) or"'x"or'wWW s'#}#(prin 45)(bye)46(8+9+9+9+9+=!)((("3'3)))"'a'[[@*3*74[?]* *]* * *(<\>]xxxxxxxxxxxxxxxxxxxxxxxx)'#\\
__DATA__=1  
#  
###;{a=1}={a:null};console.log a&&39||180
#  \\
""""  
#  
#  \
=begin  
#p :1*23!/5x%6E0 !|*****[[[828+*+@+*99]]]*****|!
;set print'-';print 89;exit#ss
[mxf]-main=-[165]- ###jxf*#p 173#*
p now 70 dollar off!
p has been selling out worldwide!
#PLACET,2<- #2FAC,2SUB#1<- #52FAC,2SUB#2<- #32FACREADOUT,2PLEASEGIVEUPFACs>>>
seeeemPaeue_ewuuweeee_eeeeeeCisajjapp_ppppxf⠆⠄⡒⡆⡘😆😨😒😨💬95💬👥➡😻😹😸🙀🙀😹😼😿🙀🙀😼😼😸🙀🙀🙀🙀  
👋🔢🌚🌝🌝🌚🌚🌚🌚🌚▲▲▲²²²²▲¡▼¡▲▲¡→  
밠밠따빠빠맣박다맣받다맣희맣희うんたんたんたんたんうんうんうんうんうんたんうんうんうんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんたんたんたんうんうんうんうんたんたんうんたんたんたんうんうんうんたんうんうんたんうんうんたんうんうんたんうんたんうんうんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんたんうんうん  
😊♈💖  
😇♈♈  
😊♉♈  
😇♈♈  
😇♈♉  
😇♈💜  
😊♉♈  
😊📢♈  
😈♈💜  
😊📢♈  
😇♉💞  
😊📢♉⠀⢃⠛⠋  
#-49,A,-1                              #
#-5,A,-1                               #
#6,A,-1                                #
1     ! !
2   !    !
1      !!
1  x*
53  ++-------+
1  x*|$0011 \|
51  +|/1000 /|
1  x*|\ 0011\|
34  +|/01 00/|
15  +|\ 0011\| R"12"R _* ?   ?@       _     !
1   *|@ 0110/| @  %"18" ?@    ?
1    |      +|            +   *
1   !+-------+---       ?  !  ?
1    !            <``=>  ? @ ?
<  <    <<   <  <
< B=  =====  =>8 =
, 8= > B    = =
=  ==  =    = >   8  =
D B+  +=   D  x   xxx x
` `    =   >  8  = >
 x ~   B  =   =  = = > ~
 B +   =  D+  ~ 8  = >x
x   x  x x      x  xx  x
x   x    x+   xx   x + +  +    +    +    <>
x    x xx     xx                +++   +   e$P+++++*D*+++1++1E!s
x+  +x +x     x + +      +  +
 8=+,  _         +    +   +         +
   +     +                +  +    +
 +             +  +  +      + + +    +
   +    +      +           +
   +    +      +          +    +      +
   +           +            +
   +      +  + +            +
   +       +   +            +
          +    +            +
# +   +                  +
#+     +     ++  +     +     +
#  +      +     +
+#
  *   +
  *+*

#  *************************************************+
# +  +
#          +                                       +
   +    + *
         *****+
# +       +
#   +        +
  * *
   +*****
#        +
 (printout t 164 )
(exit )  
#cepp  
MsgBox (0,"",169     )
#cs  
Yo::=~147
::=  
You can see an x here.<<<<
  
>{-<<<<<  
> 176
>> Output 1
>SET x TO 120. [0]{472454523665721469465830106052219449897}   @,-1,:*b5<>␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␌␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␌␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋
>X x. PPQ-}
>x--/2  
> =157;y=146--/2 
>main=print y{-ss s
  
\begin{code}  
{-x   ␉␉␉␉ 
␉
 ␉  



-}
open import IO;main = run(putStr"159" )
\end{code}
ppppppppppppp
out &49 &1
out &56 &1
out &50 &1

Take Northern Line to Tooting Bec
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Embankment
Take Bakerloo Line to Embankment
7 UP
Take Northern Line to Mornington Crescent
7 RIGHT
7 RIGHT
7 TEACH
6 BOND
6 BOND
6 BOND
5 RIGHT
5 LEFT
5 RIGHT
7 BOND
7 TEACH
5 TEACH
6 YELL
5 TEACH
6 YELL
6 YELL
set ! 57,,...,,.,,..,,,,,,..,,,.$^
set ! 51.                         #"60"e.0,1,_ye do{--}gibe16"124"#8+*sizeString tnd xfmain=los*81''cagem x=4721en nd ogola=1ay $0C0 00 3cod/|puts_e
More 91 of this
How much is it
red down one blue up red down one blue up red up one red right two blue up sss
baa baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bleeeeeeeeeeeeet bleeeeeeeeeeeeet bleeeeeeeeeet baaaa bleet bleeeeeeeeeet bleeet bleeeeeeeeeet
wwWWWwWWWWWwWWWWWWWwWWWWWWWWppppp
When this program starts:
There is a scribe called x
x is to write 179

*/
#if 0
.int 2298589328,898451655,12,178790,1018168591,84934449,12597
#endif//*
#1""//*
#include<stdio.h>
#define  x(d) #d
#define u8 "38\0 "//"
char*x="24 10 31 1"
"a c #FFC0FF""B c #0000C0""d c #58007B""e c #0C8302"
"h c #E60001""i c #CAFFFF""j c #280000""k c #CA0000""l c #CA007F""n c #330001 ""q c #E60000"
"o c #FF8000""t c #FF00BC""u c #008080"
"A c #0040C0""E c #808000""F c #00C040""G c #008000 ""R c #800000"
"H c #0000AA""I c #00AA00""J c #55FFFF""K c #AAAAAA"
"r c red""g c green""b c blue""c c cyan""m c magenta""y c #FFFF00""x c black""_ c #FFFFFF"
"HHHahtdegggggggyrggggggc"
"IHHaixuEFbGGbggbryAEGRgc"
"JJHajyurbgbgggggggb____o"
"IJHakmyyyyyyyyyyyyyyyyye"
"I__almyyyyyyyyyyyyyyyyye"
"K__anmyyyyyyyyyyyyyy_y_e"
"HH_aqggyyyyyyyyg____m_Je"
"JH_axxxxxxxxxxxxxxxxxxxx"
"K__aaaam___bbbbbBm_bbBab"
"K__________bbbbb___bbxbb";//"
int f(char*a,char*b ){puts(a?"124":sizeof(0,u8)-5?u8"67":*u8""?"37":x(0'0  "'\"")[9]?"75":'??-'&1? "79":"77");}main(){f(x,x=0);}//<*/
#1""/*/
 
>import Text.Heredoc--WWWWWWWWWWWWWW<<W
>instance Num B where fromInteger _=B 170;negate _=B$x#x
>data B=B{u::Integer};g=[here|here<-"W>W"] --WWWWWWWWWW570rt Unc27<<[w|]
>x=1;y#a=128;x#a=174
>main=print$last$172:[u$[-1]!!0|g<"Z>"] --}
 
 console.log 178;
 
#1""/*/
#if 0
#endif//* --... ...--
/*/
p=sizeof(" (\");print'(''72'')';end!");main(){puts('??-'&1?"101":"92" );return 0;}
#if 0
#endif//* rk:start | print: "69" rk:end
print 61
#}
disp 49
#{
}{}<>        K yya+-        &  g+$
$'main'3x             A=AgRA;       AC
#-3o4o#$$$
#<T>"3"O._</+++++++>/+++<-\>+++.---.\_<!+++++++++++++++++++++++++++++++++++++++++++++++++._++.-.>@
#<<<#>>>  /
reg end="";print(85);reg s#++++++++++++++++++++++++++++++++++++++++++++++++++++++++.-.
=end
;"""#"#xxxxclou"78"<\++++>/<~#class P{function:Main(a:String[])~Nil{83->Print();}}
#endcOmment
#nocOmment outtext("155")
#ce pS9^7^8^MUOUOF @0:8:8      \    @,,1'1'<> @125iRE
#p|o51~nJ;#:p'34'3             \=# print(size([[1] [3]][1,:]   )[1]==2?158+4:17)#>say 27#>>>say 170-3#]#print(47)#]#echo 21#>/#print(171)#s-#print 175#s
#8M`|   <esc>dggi2<esc>//      $}<}}<}>}[<< }<<<<<}<<}<<<<}<<<}}}<}}<}}<}     }<}}<}}<}}}<}}<<<<<<<<<<<}}}<}}<}}<}}<}}<}}<}}}<<<<<<<<<<}+++++++++++++++++++++++++++++++++++++++++++++++++._++.._#]~-<~-<~-<<<~-<COprint("65")#`=>ass^_^_#
#9 "25"   +/pppppppx     eeee*n*n*n*es*s*s*^ee*n*n*n*e*sss*e*n*n*n*ee*s<* 5>1  e*///\)Q222999686#

在线尝试！

说明

感谢Potato44提供添加机器代码的想法，做出这个答案非常有趣。

我没有做CP / M COM文件，因为它将多语言的大小限制为大约60KB，这是我想避免的。引导映像比COM更容易执行，因为ZEMU默认情况下从第6个扇区（基于1的128字节逻辑扇区）加载引导扇区，因此不需要执行多语言启动。引导代码必须在多语系中的偏移量为0x280（（6-1）* 128）。

我使用从此页面链接的ZEMU仿真器。要在ZEMU中运行多语言：

• 磁盘> A：选择多语言文件
• 选项>指令集I8080
• 按启动按钮

cns$ot从ZEMU发行版的BIOS22Dv221.ASM复制了将一个字符输出到控制台（）的功能。我做了两个更改：字符没有被屏蔽为7位ASCII，因为我们控制参数，并且jrz cns$ot被替换为（jz cns$ot因为jrz零，则跳转相对）是Intel 8080中不存在的Zilog Z80指令。

初始程序（英特尔语法，汇编器从此处链接）：

    org 3120h    ; chosen so that cns$ot == 0x3131, easier to generate
                 ; this program will be generated at this offset
                 ; to run it directly specify org 0100h

    mvi c,31h    ; '1'
    call cns$ot
    mvi c,38h    ; '8'
    call cns$ot
    db 38h       ; for answer 188, NOP in I8080
    mvi c,33h    ; '3'
    call cns$ot
    hlt          ; halt processor

;;;;;;;;; copied from BIOS22Dv221.ASM
cno$sp equ 7dh
cno$sb equ 01h
cno$si equ 00h
cno$dp equ 7ch

; print char to console, receives char in c register
cns$ot:
    in cno$sp    ; in status
    xri cno$si   ; adjust polarity
    ani cno$sb   ; mask status bit
    jz cns$ot    ; repeat until ready
    mov a,c      ; get character in a
    out cno$dp   ; out character
    ret

该程序包含不能在多语言中直接使用的字符。Simula中禁止使用大多数ASCII控制字符（代码<0x20），非ASCII字符（代码> = 0x80）不能单独出现，因为文件必须是有效的UTF-8。因此，上述程序是由另一个有效UTF-8程序生成的。

以下程序生成所需的代码并跳转至该代码。 ld (hl),a由于草（'w'==0x77）而无法使用。sub h（0x94）和xor a（0xAF）是UTF-8连续字节，必须在它们之前加上UTF-8前导字节。指令ret nc（= 0xD0，如果不进位则返回）用作UTF-8前导字节。为了使其不执行任何操作，它之前带有scf指令（设置进位标志）。对于DOBELA，也避免使用','（0x2C）和'.'（0x2E）。org 0100h不使用伪指令，因为用过的汇编器不理解伪指令（在GUI中设置了org）。该程序无论如何都与位置无关。我更喜欢Zilog助记符，因此我将它们用于更长的程序。

Zilog语法，汇编器从此处链接：

  ; generate: 0E 31 CD 31 31 0E 38 CD 31 31 38 0E 33 CD 31 31 76 DB 7D EE 00 E6 01 CA 31 31 79 D3 7C C9

  ld hl,3120h

  ld a,3Fh
  scf       ; set carry flag so that ret nc does nothing
  ret nc    ; utf8 lead byte for next insn
  sub h     ; a -= h; a = 0Eh;  utf8 cont byte (opcode 0x94)
  ld c,a

  ld (hl),c ; 0Eh    ; not using ld (hl),a because it is 'w'
  inc hl

  ld (hl),h ; 31h
  inc hl

  ld a,32h
  cpl       ; a = ~a; a = 0xCD
  ld d,a
  ld (hl),d ; CDh
  inc hl

  ld (hl),h ; 31h
  inc hl
  ld (hl),h ; 31h
  inc hl

  ld (hl),c ; 0Eh
  inc hl
  ld (hl),38h ; 38h
  inc hl

  ld (hl),d ; CDh
  inc hl
  ld (hl),h ; 31h
  inc hl
  ld (hl),h ; 31h
  inc hl

  ld (hl),38h ; 38h
  inc hl

  ld (hl),c ; 0Eh
  inc hl
  ld (hl),33h ; 33h
  inc hl

  ld (hl),d ; CDh
  inc hl
  ld (hl),h ; 31h
  inc hl
  ld (hl),h ; 31h
  inc hl

  ld (hl),76h ; 76h
  inc hl

  ld a,23h  ; not using ld a,24h because it has '$' (breaks SNUSP)
  inc a
  cpl       ; a = ~a; a = 0xDB
  ld d,a
  ld (hl),d ; DBh
  inc hl

  ld (hl),7Dh ; 7Dh
  inc hl

  ld a,c    ; a = 0Eh
  cpl       ; a = F1h
  dec a
  dec a
  dec a     ; a = EEh
  ld d,a
  ld (hl),d ; EEh
  inc hl

  scf
  ret nc
  xor a     ; a ^= a; a = 0; utf8 cont byte
  ld c,a
  ld (hl),c ; 00h
  inc hl

  ld a,4Ah
  scf
  ret nc
  sub h     ; a -= h; a = 0x19;  utf8 cont byte
  cpl       ; a = ~a; a = 0xE6
  ld d,a
  ld (hl),d ; E6h
  inc hl

  ld a,c
  inc a
  ld d,a
  ld (hl),d ; 01h
  inc hl

  ld a,35h
  cpl       ; a = 0xCA
  ld d,a
  ld (hl),d ; CAh
  inc hl
  ld (hl),h ; 31h
  inc hl
  ld (hl),h ; 31h
  inc hl

  ld (hl),79h ; 79h
  inc hl

  ld a,2Dh  ; not using ld a,2Ch because it has ','
  dec a
  cpl       ; a = 0xD3
  ld d,a
  ld (hl),d ; D3h
  inc hl

  ld (hl),7Ch ; 7Ch
  inc hl

  ld a,36h
  cpl       ; a = 0xC9
  ld d,a
  ld (hl),d ; C9h

  ld sp,3232h  ; set up stack for generated program

  ld hl,3120h  ; not using ld l,20h because it has '.'
  jp (hl)      ; go to generated program 
               ; confusing mnemonic - actually it is jp hl, ie. PC = HL
               ; opcode 0xE9, utf8 lead byte (0xE9 = 0b11101001), must be followed by 2 cont bytes
  db 80h,80h

该程序汇编为：

! 1>?7ДOq#t#>2/Wr#t#t#q#68#r#t#t#68#q#63#r#t#t#6v#>#</Wr#6}#y/===Wr#7ЯOq#>J7Д/Wr#y<Wr#>5/Wr#t#t#6y#>-=/Wr#6|#>6/Wr122! 1退

它必须在多音域中偏移0x280（请参见第2行）。测试驱动程序中的抽象测试对此进行检查。

重构

炮弹

将炮弹移回最长的线。我更喜欢这种布局，因为括号不会与其他语言对齐。先将Moorhenses和Flaks移动到炮弹之前，因此在更换炮弹时它们不会破裂。最长的行现在具有以下布局：

Grass  Moorhenses  Flaks  Shells  Rubies/Pythons/Perl5  PicoLisp  Prelude  Klein001

新的Shell代码：

a=$(printf \\x00)
b=$(echo -n $a | wc -c)
case $b[1] in 1*)echo 54;; 4*)echo 78;; 8*)echo 166;; *1*)echo 50;; *)echo 58;; esac
exit

旧壳代码：

a=$(printf \\x00)
b=${#a}
case "{"$ar[1]"}"${b} in *1)echo 54;; *4)echo $((19629227668178112600/ 118248359446856100));; *1*)echo 50;; *)echo 58;; esac
exit

的长度现在$a计算出来$(echo -n $a | wc -c)（从此处开始）。最初，我使用它来摆脱#，但是现在由于较短的代码而被使用。壳#之所以可以包含，是因为Flaks在壳之前。

Yash（166）使用内置的echo命令，该命令默认情况下不支持选项，因此“ -n”和换行符最终成为输出的一部分，这会额外提供4个字节。未设置时ECHO_STYLE默认为SYSV（-n不接受选项）。

该TIO链接在所有shell中测试代码。

(((((在Shell修复Underload和Retina之前的其他操作。再添加一对parens以隐藏58Prelude（以#)after结束exit）。 {以前((((((是为Japt设计的，没有它，Japt会挂起。

高射炮

由于Flaks的重定位，因此可以简化起始代码–仅([])保留以下内容：

     line 21      (Grass(([5]{})))    scripting langs                  clear stack     Flaks main code                                                                                      begin skip code      the rest of polyglot   end skip code   print(85)
old: []{}[][][]   ((([]{})))          ((()()<<()>>)((()([])))<<()>>)   {}{}{}{}{}{}{}  ({}<(((((()()())){}{})){}{})>)(({})){}{(<(<()>)({})({}<{}>({}){})>){({}[()])}}({}){}({}()<()()()>)   (<><()>){({}[()])}{           ...           }{}<>              ()
new: []{}[][][]     ([]  )                                                             ({}<(((((()()())){}{})){}{})>)(({})){}{(<(<()>)({})({}<{}>({}){})>){({}[()])}}({}){}({}()<()()()>)   (<><()>){({}[()])}{           ...           }{}<>              ()

此TIO链接测试所有Flaks中的代码。

裂变与红衣主教

Fission已移至LNUSP ：R"12"R _*。第二个指针用于尽快终止Fission –在第3步，有关更多信息，请参见答案54。

Cardinal被移至LNUSP ：@ %"18"。像在裂变中一样，第二个指针用于在第三步上尽快终止Cardinal。

马里奥·朗

使用####...而不是====...作为平台：

最小二维

与MarioLANG结合使用：

Wierd＆1L_a

奇怪：请在第10行第79栏使用空格来反映IP。
Wierd 1L_a：第9行第79列的空间很重要。

立体地

新代码： :1*23!/5x%6E0

:1*23!/5x%6E0
! - skip over / in Klein 201
x - destroy Cardinal pointer before it hits /

pure:
:1*23/5%6E0

faceval:
0 0
1 9
2 18
3 27
4 36
5 45

program:
:1   mem = 9
*23  mem *= 18; mem *= 27
/5   mem /= 45
%6   print mem
E0   exit

9*18*27/45 == 97 (integer division)

6 in %6 is used to print mem because 0-5 are used to print faceval (eg. %3 prints 27)
0 in E0 is not an exit code, it is present just to trigger E instruction

克莱因201/100

新代码： !|*****[[[828+*+@+*99]]]*****|!

毕竟，乘法堆栈包含一个零，因为从空堆栈弹出会产生零。该零与+旁边的一起添加到主号码中@。以前是用丢弃的?，请参阅Klein 001的答案。

门在克莱因是如何工作的：

旋转

旋转代码基本相同，唯一的变化是主代码假定当前操作为ops.one（2），而不是ops.load（4）。

实际上，可以将Whirl视为具有3种操作：

• 1 旋转一步
• 0 切换旋转方向
• 00 执行当前指令并切换振铃

组合操作简化了程序推理：

• 0000 如果非活动环的当前操作为noop，则只需执行活动环的当前操作即可，而不会产生任何副作用
• 11..11 旋转n步
• 011..11 切换方向并旋转n步

0000执行活动振铃的当前指令，但也执行无效振铃的当前指令。如果当前的非活动振铃指令是无害的，那么我们可以仅关注活动振铃上的操作，而无需考虑非活动振铃会发生什么情况。这对于该程序特别有用，因为它具有清晰的分隔：首先仅使用数学环创建数字32，然后切换到ops环并在其中执行2条指令（打印和退出）。

首先，我想在主代码开始执行时使ops环上的当前操作变为noop。它具有2个优点：1）可以独立执行主要的Whirl代码； 2）使用数学环创建数字32时，我们可以完全忘记操作环。但是，它使代码比原来更长，因此主代码假定当前操作为ops.one（2）。这意味着将ops.value设置为1作为数学运算的副作用，然后将其用于打印。旧代码使用ops.load指令达到了相同的效果，但是使用ops.one更清楚地表达了这一意图–将ops.value设置为非零。

at this point current ring is ops, dir = clockwise, cur op = ops.one
00    switch to math ring
011   rotate to math.not
0000  math.not (math.val = 1)
01111 rotate to math.store
0000  math.store (mem[0] = 1)
1     rotate to math.add
0000  math.add (math.val = 2)
01    rotate to math.store
0000  math.store (mem[0] = 2)
011   rotate to math.mult
0000  math.mult (math.val = 4)
0000  math.mult (math.val = 8)
0000  math.mult (math.val = 16)
0000  math.mult (math.val = 32)
011   rotate to math.store
00    math.store (mem[0] = 32), switch to ops ring
up to this point the program is the same as before

01111 rotate to ops.intio
0000  ops.intio - print mem[0] as number
0111  rotate to ops.exit
00    ops.exit

新代码较短，因为旧代码在程序的第二部分具有几个冗余的方向开关，而不是因为新的假设。

old: (1111) 00011000001111000010000010000011000000000000000001100 01111110000011100
new: (11)   00011000001111000010000010000011000000000000000001100   011110000011100

在事件/旋转行之前更改某些内容时，如何保持旋转正确：

• 确保0主Whirl代码之前的偶数个
• 确保没有两个连续的0s
• 添加/删除足够多的1s直到Whirl再次工作；加n 1s等于删除12-n 1s，反之亦然

添加Ropy时，我在不知不觉中违反了第一条规则。当0s的奇数个主代码开始以错误的ops振铃方向执行时，这会中断退出指令。因此，现在0在第3行上进行了补偿，0在第1 行上进行了补偿。

其他

CoffeeScript：（console.log a&&39||180从这里开始）

INTERCAL：移至第37行
Brainfuck，Agony：移至第10行的其他Brainfuck衍生产品

xEec：移入1L_a（h#115# o#）

CSL：移至80行
Trefunge：移至120
Gaot ++行，Stones：置于单独的行上

16. Pyth（159字节）

#v\;2^0\;7||"<+0+0+0+<*!2'!1'L#'1r'4;n4
#v0#_q@
#>3N.15o|1
#|\w*
#8  ^<1b0 <
#|
#M`
print ((0 and'13')or(None and 9 or 1/2 and 1 or 5))
#"07|5//00;16 "jd5ki2

注意：第三行中的，最后一行中的，后面有一个ESC字节（0x1B）。oj

这是一个非常有趣的经历。Japt和Pyth都是golfy语言，但是Japt是infix，Pyth是前缀，Pyth自动请求输入，如果缺少参数则失败。

在Haystack回答之前，我有一个使用的几乎#可行的解决方案，该解决方案在Japt中获得了char代码，在Pyth中获得了循环直到错误。在通用语言中，Pyth恰好非常有用，因为通用注释char #本质上充当了错误消音器。

当我回到家时，我设法找到了一段可以同时使用的代码，//在Japt中用作注释，在Pyth中用作两个部门。然后，这只是使Befunges正确路由的问题。

这不太可能是最优的，但到目前为止已经足够了。我尝试对它们全部进行测试，但是我非常感谢有人仔细检查输出是否匹配。

印刷品1在Python 3，2单位为V，3 Minkolang，4> <> ，在Python 2 5，6在自修改Brainfuck，在Japt 7，8在视网膜，9在Perl，10 Befunge（-93 ），11 Befunge-98，在裂变12，13在红宝石，在Turtléd14，15在草堆，和

Pyth中的16。

说明

Pyth在这里看到的是：

#v\;2^0\;7||"string
multiline
string"07|5//00;16 "string

这将转换为以下伪代码：

while no errors occur:
    evaluate ";"
    print 2
    print 0 to the power ";"
    print 7
    print "string\nmultiline\nstring" or 0 or 7
    print 5 or 0 divided by 0 divided by (missing)
print 16
do nothing with "string"

第一个循环在尝试评估;哪个不是有效表达式时退出。然后Pyth才打印16。