Это сложная цепочка ответов, в которой каждый ответ основывается на предыдущем ответе. Я рекомендую отсортировать ветку по «старейшим», чтобы быть уверенным в том, в каком порядке создаются сообщения.

Примечание : это стало довольно длительным испытанием, и опубликовать новые ответы довольно сложно. Таким образом, теперь есть чат для этой задачи, если вы хотите получить совет по конкретной части потенциального ответа, есть идеи для языков, которые можно добавить, или тому подобное. Не стесняйтесь заходить, если у вас есть что спросить или сказать!

Задание

П - й программы для представления должны выполняться в п разных языках; в частности, будут добавлены все языки, добавленные в предыдущих программах, плюс еще один. Программа должна выводить 1 при запуске на первом языке, используемом в ответах на этот вопрос, 2 при запуске на втором языке и так далее. Например, первый ответ может вывести 1 при запуске в Python 3, а второй ответ может вывести 1 при запуске в Python 3 и 2 при запуске в JavaScript; в этом случае третий ответ должен был бы вывести 1 при запуске в Python 3, 2 при запуске в JavaScript и 3 при запуске на каком-либо другом языке.

Дополнительные правила

• Ваша программа должна работать без ошибок или сбоев. Предупреждения (и другие выходные данные stderr) приемлемы, но программа должна завершиться нормально (например, запустив конец программы или выполнив такую ​​команду, exitкоторая выполняет нормальное завершение программы).

• Вывод должен быть только целым числом, но завершающие символы новой строки в порядке. Другие неизбежные выходные данные stdout также разрешены. Примеры: имя и версия переводчика в Befunge-93, пробел после напечатанной строки в Zephyr. Некоторые языки предоставляют два метода печати - с пробелом и без него; в этом случае должен использоваться метод без завершающего пробела.

• Каждый ответ должен быть не более чем на 20% или 20 байтов (в зависимости от того, что больше) длиннее предыдущего ответа. (Это сделано для того, чтобы не допустить использования таких языков, как Lenguage, спамить нить, и поощрить хотя бы небольшое количество игры в гольф.)

• Разрешается использовать разные версии одного и того же языка (хотя, очевидно, им придется печатать разные цифры, поэтому вам нужно вставить проверку версии в полиглот). Однако вы не можете использовать языковую функцию, которая возвращает номер версии языка. Повторение одного и того же языка, очевидно, невозможно (поскольку программе пришлось бы детерминистически печатать одно из двух разных чисел).
• Уловки, такие как чрезмерное злоупотребление комментариями, несмотря на то, что они запрещены на некоторых соревнованиях полиглотов, здесь просто хороши.
• Вам не нужно использовать предыдущие ответы в качестве руководства для написания своих собственных (вы можете переписать всю программу, если хотите, при условии, что она соответствует спецификации); однако разрешается основывать свой ответ в основном на предыдущем ответе и, возможно, это самый простой способ найти решение.
• Вы не можете отправить два ответа подряд. Пусть кто-то еще пост в промежутке. Это правило применяется до тех пор, пока не будет выполнено условие победы.
• Поскольку этот вызов требует, чтобы другие конкуренты размещали на тех же языках, что и вы, вы можете использовать языки только с бесплатной реализацией (как если бы это был конкурс копов и грабителей ).
• В случае, когда в языке имеется более одного переводчика, вы можете выбрать любой переводчик для любого данного языка, если в этом интерпретаторе все программы, которые должны успешно работать на этом языке, делают это. (Другими словами, если программа работает в более чем одном переводчике, будущие посты могут выбрать любой из этих интерпретаторов, а не пост, «фиксирующий» определенный выбор интерпретатора для языка.)
• В этом задании теперь используются новые правила PPCG о выборе языка : вы можете использовать язык или переводчик языка, даже если он новее, чем вопрос. Тем не менее, вы не можете использовать язык / переводчик, который является более новым, чем вопрос, если a) язык был разработан для полиглотирования или b) язык был вдохновлен этим вопросом. (Таким образом, недавно разработанные практические языки программирования почти наверняка будут в порядке, как и несвязанные esolangs, но такие вещи, как A Pear Tree , который был вдохновлен этим вопросом, запрещены.) Обратите внимание, что это не меняет валидность разработанных языков. для полиглотирования, которые старше этого вопроса.
• Обратите внимание, что условие победы (см. Ниже) составлено таким образом, что разрыв цепочки (то есть невозможность для кого-либо отвечать за вас с помощью языка, на котором сложно полиглотировать другие языки) лишает вас права на победу. Цель состоит в том, чтобы продолжать идти как можно дольше, и если вы хотите выиграть, вы должны уважать это.

Формат ответа

Поскольку все ответы зависят друг от друга, полезно иметь согласованный формат ответов. Я рекомендую отформатировать ваш ответ примерно так (это пример для второй ссылки в цепочке):

2. JavaScript, 40 байт

(program goes here)

Эта программа печатает 1 в Python 3 и 2 в JavaScript.

(если вы хотите объяснить программу, методы полиглотирования и т. д., разместите их здесь)

Состояние победы

Если в течение 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.

1 в Python 3, 2 в V, 3 в Минколанге, 4 в> <>, 5 в Python 2, 6 в SMBF, 7 в Japt, 8 в Retina, 9 в Perl, 10 в Befunge-93, 11 в Befunge -98, 12 в Fission, 13 в Ruby, 14 в Turtléd, 15 в Haystack, 16 в Pyth и 17 в Julia .

подсказки:

• Начало четвертой строки - Python 2/3, Perl, Ruby. Конец - Джулия, благодаря #=многострочным комментариям (обратите внимание, что Джулия не имеет and/or).
• V <ESC>gg99ddi2<ESC>, который определенно пригоден для игры в гольф, но V раздражает, чтобы проверить на Попробуйте онлайн! поскольку переводчик довольно медленный.
• Минколанг и Хейстек спускаются в первую очередь v. Befunge-93 и -98 нет, и зависят от b.
• Retina подсчитывает количество пробелов и 1 в четвертой строке, а V скрывается в конфигурации для Retina (то есть до обратного удара).
• Согласно подсказке @ 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.

Печать:

23 в Hexagony , 22 в Underload, 21 в Nim, 20 в Prelude, 19 в Reng ( здесь можно проверить ), 18 в Cardinal, 17 в Julia, 16 в Pyth, 15 в Haystack, 14 в Turtlèd, 13 в Ruby, 12 в Деление, 11 в Befunge-98, 10 в Befunge-93, 9 в Perl, 8 в Retina, 7 в Japt , 6 в SMBF, 5 в Python 2, 4 в> <>, 3 в Minkolang, 2 в Vim / V и 1 в Python 3.

Чтобы перейти на несвязанные языки, нажмите 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 вместо восьмого - будьте осторожны, играя в гольф ниже 169 или выше 217 соответствующих символов
• Из-за этого, ~~~и 2 0в конце могут быть изменены без вреда для кода
• Он =""просто отодвигает ME от предыдущего, так что новое ME можно изменить. Их можно заменить другими символами, которые делают то же самое без вреда для программы шестиугольника (например, 's)
• Это технически несовместимо со спецификациями Befunge 93, потому что ограничивает ограничивающую рамку кода до 80 на 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

Хотите узнать больше? Попробуйте чат с полиготами !

Попробуйте их онлайн!

Из-за ограничений Stack Exchange я, как обычно, заменил буквенные вкладки символами ␉ESC и буквенными символами ESC ␛. Вы можете получить легко копируемую версию программы из поля «ввода» ссылки TIO выше.

Наезжать

Эта программа печатает 50 в bash, 49 в Octave, 48 в Deadfish ~, 47 в Lily, 46 в Cubix, 45 в PicoLisp, 44 в alphuck, 43 в ретикулярной, 42 в злой, 41 в brainf ***, 40 в минимальной -2D, 39 в CoffeeScript, 38 в C, 37 в C ++, 36 в лабиринте, 35 в INTERCAL, 34 в Rail, 33 в инциденте, 32 в вихре, 31 в модульном SNUSP,30 в Whitespace, 29 в триггер, 28 в головном мозге-Flak, 27 в Perl 6, 26 в 05AB1E, 25 в Пип, 24 в Thutu, 23 в Hexagony, 22 в недогрузки, 21 в Nim, 20 в прелюдии, 19 в Reng , 18 в кардинал, 17 в Julia, 16 в Pyth, 15 в Хейстек, 14 в Turtlèd, 13 в Ruby, 12 в дЕЛЕНИИ, 11 в Befunge-98, 10 в Befunge-93,9 в Perl 5, 8 в Retina, 7 в Japt, 6 в SMBF, 5 в Python 2, 4 в> <>, 3 в Minkolang, 2 в V / Vim и 1 в Python 3.

верификация

Большинство языков проверены тестовым драйвером выше. Обычные четыре преступника нуждаются в тестировании отдельно:

• Инцидент был проверен с использованием его официального переводчика, в автономном режиме;

• Deadfish ~ также был протестирован с использованием его официального переводчика, офлайн;

• Модульный SNUSP был протестирован онлайн здесь ;

• Ренг был протестирован онлайн здесь .

объяснение

Я искал различные варианты добавления языков. Одна возможность заключалась в том, чтобы найти язык со #строковыми комментариями, который можно было бы добавить к строке «язык сценариев» (которая обрабатывает Perl, Python 2 и 3 и Ruby). Мне потребовалось некоторое время, чтобы подумать о подходящем языке, который мог бы быть синтаксически совместимым с уже существующим.

Оказывается, ответ давным-давно смотрел мне в лицо. Если вы щелкнете ссылку TIO выше, откроется тестовый драйвер полиглота, который написан на bash. Так что все это время у меня была вкладка с надписью "Bash - TIO Nexus". Вы бы подумали, что это будет намек, но, видимо, я пропустил это. В качестве бонуса, bash также является языком сценариев, поэтому термин «языковая линия сценариев» все еще уместен.

Программа bash запускается там же, где и другие языки сценариев. Однако есть довольно простой способ отделить его от них; в одиночных кавычках \является escape-символом в большинстве языков, но не в 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 использует \в качестве escape-символа; главный результат этого - то, что он ограничил область, которую я имел, чтобы возиться со строками в языках сценариев, вынуждая меня использовать довольно запутанный метод выше (поскольку я не мог легко использовать разницу в \поведении между bash и всем остальным). еще). В 05AB1E, 'действует как экранирующий символ за пределамиструны, и если он "уйдет от ведущего , не подойдет. Поэтому мне пришлось поместить бесполезный символ-заполнитель (по умолчанию мой обычный x; это облегчает чтение!) Внутри "'"конструкций, которые используются для переключения между стилями цитирования в bash.

прелюдия

Безусловно, самый сложный язык для исправления здесь. Проблема в том, что строка сценария со всеми круглыми скобками была перемещена вбок, и, таким образом, поток управления Prelude (который очень заботится о том, как круглые скобки выровнены по вертикали) был полностью уничтожен. Таким образом, я должен был попытаться восстановить то, что работает.

Хуже того, текущая первая строка (которую я действительно не хотел переписывать) накладывает жесткое ограничение на то, где могут появляться скобки. Он начинается с ненулевой цифры (две из них, на самом деле!) И вскоре сопровождается открывающей скобкой. Это цикл в Prelude, и циклы в начале потока управления в Prelude вызывают ряд различных проблем (в основном потому, что они вызывают выполнение большего количества кода, а не меньше). Поэтому мне крайне необходимо было открыть цикл с 0 итерациями на какой-то другой строке, чтобы пропустить этот код. mainЛиния для программы C очень подходит, но мы должны быть очень осторожны с тем, где соответствие закрывающая скобка; слишком далеко вправо и непревзойденный кронштейн на#R+Строка вызовет проблемы, слишком далеко слева и не закомментирует достаточно кода. (Помните, что открывающая скобка на одной строке может совпадать с закрывающей скобкой на другой строке.)

Как только это будет сделано, у нас будет достаточно места, чтобы вставить открывающую скобку в строку Инцидент, и мы, наконец, благополучно прошли первые несколько символов программы. Однако разница в размещении в скобках заканчивается тем, что часть кода Incident / Whirl фактически выполняется в Prelude, что приводит к повреждению стека. Вместо того, чтобы предотвратить это, я переместил некоторые нули Whirl дальше вправо, что позволило им снова дать нам рабочую программу Prelude.

Еще одно небольшое изменение было в первой строке программы; последняя скобка строки была в положении, которого было очень трудно избежать. Я добавил дополнительный cсразу после кода Pyth, чтобы сдвинуть его вправо. (Многие языки анализируют эту точку программы, поэтому потребовалось удивительное количество проб и ошибок, чтобы найти символ заполнения, который не сломал бы хотя бы один язык!)

инцидент

Прелюдия сама по себе была достаточно сложной, но заставить работать Прелюдию и Инцидент одновременно было кошмарно. Прелюдия накладывала много ограничений на код, который мешал мне свободно перемещать вещи и, таким образом, усложнял случайную конструкцию токенов для игры в гольф. Например, Prelude действительно нужен только один 0перемещенный вправо, но это привело 00к тому, что он стал неисправным токеном, сломав некоторые токены, которые мы хотели получить как часть программы Incident (потому что, если два токена перекрываются, они оба отклоняются, и 00было перекрытие фишки мы хотели в дополнении к перекрытию себя). Мне пришлось отодвинуть оба, чтобы сделать четвертую копию и не допустить, чтобы ее даже рассматривали как маркер.

Более тонкими являются токены ;'и ␠␠(то есть два пробела). Проблема заключается в том, что они оба появляются перед тем kG, который используется для перехода к началу программы, и, таким образом, нарушают поток управления инцидента (в дополнение к нарушению центральной точки программы).

Удаление копии ␠␠путем ее разрыва не представляется жизнеспособным. Удаление его с помощью наложения может быть возможным ( ␠=многообещающее потенциальное наложение), но почти наверняка менее многословно просто добавить четвертую копию, что я и сделал здесь.

Между тем, мы можем использовать другой трюк для ;'. Я не хотел разбивать его, учитывая, что он используется в довольно чувствительных к пробелам ситуациях. Тем не менее, это не что вблизи начала программы (несмотря на первой линии), так что это правдоподобно , что мы могли бы перепрыгнуть через него (таким образом , в результате чего он не влияет на поток управления) , а не нуждаясь его не существует. Я искал подходящий токен для прыжка, который не испортил бы ни один из других языков. /vпоявляется немного раньше в первой строке и ничего не ломает, и поэтому я это и использовал.

50 языков в 1 Kib кода

@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 ниже, если вы хотите работать с ней.

Попробуйте их онлайн!

Наезжать

Эта программа печатает 37 в C ++, 36 в Лабиринте, 35 в INTERCAL, 34 в Rail, 33 в инциденте, 32 в Whirl, 31 в модульном SNUSP, 30 в пустом пространстве , 29 в Trigger, 28 в Brain-Flak, 27 в Perl 6 , 26 в 05AB1E, 25 в Пип, 24 в Thutu, 23 в Hexagony, 22 в недогрузки, 21 в Nim, 20 в прелюдии, 19 в Reng, 18 в кардинал,17 в Julia, 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 в V / Vim и 1 в Python 3.

верификация

Большинство языков протестировано тестовым драйвером, показанным выше. Вы можете проверить Reng здесь и Modular SNUSP здесь ; они выдают соответственно 19 и 31 соответственно.

Я добавил другой формат в вывод тестового драйвера, который экранирует двойные кавычки, а также заменяет перевод строки. Это позволяет мне передавать строку из одной строки в программу ac (gcc), которую я обернул вокруг функции, созданной здесь @feersum . Надеюсь, другие могут использовать его как есть.

Вот программа токенов Инцидента . В идеале я хотел бы разграничить токены, поскольку их немного сложно прочитать, указать «центральный» токен и включить его в тестовый драйвер. Но я действительно не знаю, как сделать что-либо, кроме как заставить различные программы печатать последовательные целые числа, так что это насколько я понял.

Я пытался решить очевидные проблемы происшествий, как лексемы после начала и конца прыжковых лексем и все , что выглядели посторонними, но я не сбалансирован лексемы поставить 0oв центре. Я не совсем уверен, что логика именно для определения центра. Я надеюсь, что @ ais523 поможет там. Эта строка ближе к концу 7LEintndus({})!<>+была бы токенами, если бы не это четвертое включение в код. Все они могут быть удалены (и заменены .на выравнивание по Hexagony) для настройки центрального жетона.

Я собираюсь обновлять этот пост время от времени в течение следующего дня или двух, чтобы пройтись по коду (при условии, что инцидент может быть проверен / исправлен без учета количества байтов). Но сейчас уже слишком поздно, и я, в основном, хотел выяснить это, прежде чем мне пришлось решать еще одну проблему, похожую на Лабиринт. :П

объяснение

Как работает код C ++.

Я думаю, что большинство людей достаточно знакомы с C ++, поэтому я не буду вдаваться в подробности. Блок комментариев приходит в виде /* comment */. Строка комментариев приходит в виде //comment. Реальный код используется на C ++ для получения ответа является int main() {std::cout<<37;}. На библиотеку, которая используется для взаимодействия с STDOUT, ссылается это утверждение #include<iostream>.

/ * Комментарии злоупотребляют * /

Для меня история C ++ восходит к моему ответу Brain-Flak.

Наконец, найдя № 28, я решил изучить некоторые другие полиглоты, опубликованные в PPCG, и все эти исследования привели меня к нескольким простым ответам (большинство из них все еще можно найти, если кто-то еще так склонен). Но что более важно, я пришел к выводу о полиглотах в целом: большие полиглоты, как правило, попадают в одну из двух широких категорий: #злоупотребление /*комментариями или злоупотребление комментариями.

В любом случае, это не факт или ограничение, а личная ментальная структура, которая направляла мои следующие несколько ответов.

Отсюда я пришел к выводу, что если это станет крупнейшим полиглотом в мире, который, как я полагаю, будет в настоящее время, было бы лучше, если бы он мог использовать злоупотребления комментариями из обеих семей комментариев. Поэтому я решил найти способ включить /*язык комментариев и подтолкнул к семье C в основном из-за личного знакомства.

C ++ Начальный тест

Мой первоначальный мыслительный процесс для этого состоял в том, чтобы использовать C # главным образом из-за моего знакомства, и первым препятствием для C # было приведение полиглота в состояние, в котором он мог бы принять строку, с которой не начинался, #без иного обращения с языками сценариев как кода , Ответ Rail вместе с несколькими ответами, приводящими к его накачке, решил эту часть.

Затем возникла проблема, как инициировать первый /*блок комментариев. Я знал, что строка должна начинаться со строки, #чтобы оставаться невидимой для Perl, Ruby и Python, но все, что было до /*, будет прочитано C #. #regionСначала я попробовал тег C # , но он оказался слишком сложным для языков 2D. Введите C ++.

C ++ имеет несколько директив препроцессора, с #которых все начинается , что дает множество возможностей для прохождения 2D-языков. Но оказалось, что все они несовместимы хотя бы с одним языком, и, находясь в открытом для C ++ пространстве кода, я имел ограниченные обходные пути. Из-за разочарования и отчаяния я наткнулся на тот факт, что C ++ просто примет только один #перед блоком комментариев. Хорошо, что угодно, это выполнимо. Поэтому я перешел к предположению, что #/*первые три символа в полиглоте могут сработать.

Второй элемент базовой проверки состоял в том, чтобы гарантировать, что фактическое выражение для печати могло бы счастливо жить с другими кодами. По ответу Brain-Flak я знал, что Japt не нравятся un-escaped, {и это было необходимо для C ++, чтобы сказать, int main() {std::cout<<37;}и C ++ не допустит escape-символа Japt в середине своего кода. На этот раз мне посчастливилось обнаружить, что, если я выпаду из буквальной строки Джапта только для этого утверждения, Джапт все равно с радостью даст тот же результат.

Тем временем Brain-Flak тоже не понравился {}, но мне снова повезло обнаружить, что C ++ был в порядке с оператором #между его оператором int main()и {std::cout<<37;}оператором, позволяя комментировать фигурные скобки с точки зрения Brain-Flak.

Итак, когда основные проблемы C ++ оказались теоретически решаемыми, я начал трудный процесс устранения всех ошибок, которые я внес.

2D Пейзаж

Самым сложным в этом ответе была реконфигурация двух верхних линий полиглота. И самая значительная проблема была *. Недостаточная нагрузка не позволит *до (. Он считает это математической операцией в пустом стеке, что, по его мнению, является ошибкой. Таким образом, полиглоту требовалось (до, /*но C ++ не мог этого допустить. Таким образом, решение было для нас комментарием строки C ++ //в первой строке, чтобы скрыть a, (а затем начать вторую строку с a #/*.

Далее, Befunge действительно не понравилась идея /без разделения чего-либо, но после изучения существующего ответа Бегунге 16/"<"6/b.q@я наткнулся на идею числа и последовательности, разбитой перед ними //. Это сработало, и я понятия не имею, почему C ++ с этим согласен, но принимает # 1"16" 2это как вступительное заявление. Я не собираюсь подвергать это сомнению, но я знаю, что для работы требуются места.

Первая линия

Джапт оказался довольно чувствительным к пространству и не хотел вводить строку, основанную на обратном токе, в верхней строке, поэтому он и обратный удар Пипа были перенесены на вторую строку, что вынудило много лингвистической гимнастики в строке 1.

• Пипу не понравилась большая часть строки 1, поэтому после первого был помещен второй пробел #для обозначения комментария.
• Для (недогрузки нужно было вырваться из Джапта с предшествующим \.
• #это терминатор перехода в Turtlèd, так что это было необходимо, но Pyth считает это циклом завершения ошибки, поэтому Pyth нужно было делить на ноль / после#
• Я не уверен, что @в первой строке делает больше, но Pyth и Japt, похоже, предпочитают его присутствие лучше, чем нет, хотя, @согласно документации Pyth, это не значимый персонаж.
• И похоже, что первый ;может быть удален на этом этапе без последствий, так что я не уверен, что там было решено, хотя я подозреваю, что это было связано с Питом. Но похоже, что будущие решения могут сохранить байт, пропустив этот.
• <> <и Turtlèd в основном работают так же, как и раньше, с <> <, отражающими первую #и переносящими в конец первой строки. И Turtlèd прыгает с, #как я упоминал, и заканчивается "14"строкой, которую он печатает.

2D маршрутизация

После устранения этих проблем следующим этапом стала маршрутизация 2D-языков. Ранее начальная vбуква была проигнорирована Befunges из-за предшествующего #, но послала Хейстек и Минколанг вниз. Теперь начальное пространство пытается отправить Минколанга по 3-му измерению, которое в его документации называется измерением времени.

Вкратце о 3-м измерении Миноланга: для меня было бы неправильно называть это временным измерением, оно действительно кажется мне более пространственным, чем временным. Я действительно не получил это, пока я не нашел эту ссылку, которая иллюстрирует концепцию, и это больше похоже на несколько слоев 3D шахматной доски. Я считаю, что именно так обычно работают 3D-языки. Но так как это была новая концепция для меня, я подумал, что выкину эту информацию для других.

Таким образом , несколько слоев Minkolang в разграничены линиями , заканчивающихся в $$$которых я бросил на конец кода Rail здесь: #-3o4o#$$$. Теперь, Minkolang попадает в пространство и падает на первый >в <>3N.<> ␉//и переходит к правому выводя 3. #>не может быть разрешено начать эту линию , поскольку она будет пытаться завершить блок комментария Perl6, поэтому <используется вместо #баланса для SMBF и мозга -Flak. Однако это процедура перестановки стека Brain-Flak, поэтому <>после завершения Minkolang используется второй набор , чтобы вернуться к правильному ответу Brain-Flak.

Лабринт аналогичным образом сталкивается с пространством, но это заставляет Лабринта двигаться вниз в столбце 1. Затем он поворачивает вниз по линии 2, где он спускается к 3другой стене, заставляя его снова повернуть на юг и ударив по точке ;3, в результате чего 3 выскочил , Затем программа продолжается вправо, где 36 сохраняется и распечатывается, прежде чем, наконец, найти @выход. Этот путь длиннее, чем он должен быть, но я обнаружил, что Prelude будет выводить нулевой байт до того, как он будет выведен в обычном режиме, если бы он !был чуть левее, чем сейчас, независимо от линии, в которой он появляется. Поэтому я сделал это более правильно, потому что у меня было достаточно места для этого.

Далее, маршрутизация Haystack была изменена, потому что /теперь предшествует vстроке 1 и отражает ее путь как Reng. К счастью, Ренг проживает довольно мирно. Единственное препятствие заключалось в том, что игла Хейстека |была отражателем в Ренге, поэтому Ренг использует Befunge, как jump ( #) над иглой, чтобы правильно заключить Ренг.

Befunges продолжаются вдоль линии 1 до тех пор, пока символы vи и не будут направлены вниз, а затем направо во второй строке, чтобы завершиться тем же кодом, который использовался ранее. Я чувствую, что эта часть может быть немного улучшена сейчас, когда меньшее количество языков пытаются осмысленно пройти через код, но мне не нужно было больше стен, чтобы биться головой, поэтому я оставил все как есть.

Наконец, отправной точкой кардинала является то, %что нет особой необходимости ввязываться в и без того плотные две верхние линии. Поэтому я переместил его в строку Python. Его множественные пути кода теперь также ограничены символом x's', что завершает движение его указателя.

Линия 2 и 3

Единственное существенное изменение здесь - это то, что все :вышли в гольф по той или иной причине. Может быть, (потребности Prelude или, возможно, это были простые проблемы с количеством байтов - возможно, оба. Другое дело, что код перехода триггера был перемещен назад и переименован как auaaZ. У меня было место для заполнения, чтобы соответствовать пути кода Befunge, и это казалось лучшим. Кроме того, <следующий этот кусок должен сбалансировать следующие SMBF >. В конце концов, одинокий ”конец второй строки должен поддерживать строку 05AB1E. Кроме того, yyв строке 3 просто символы-заполнители для Лабиринта.

Большие струнные эзоланги

Когда две верхние строки были решены, пришло время начать копаться в эзолангах с более полным анализом, и у Пипа возникла проблема. Если вы помните, мы имели дело с фигурными скобками {std::cout<<37;}, выпадающими из строки Japt, чтобы Japt воспринимал это как код. Что ж, Pip использует тот же строковый синтаксис, и ему не понравилась эта строка в коде, а Pip имеет очень похожие параметры объявления строк, как Japt. Оба используют один 'для объявления одной символьной строки, оба используют одно и то же escape-объявление \и оба будут принимать "строковые идентификаторы. Так что было трудно заставить Пип поверить, что это была строка, не заставив Джапта поверить в то же самое.

Оказалось, что у Джапта было одно эксплуатируемое отличие - он #принимает значение ascii следующего персонажа. Таким образом, #"`завершит строку Japt / pip, затем скажет Japt принять значение asci ", сообщив Pip начать новую строку. ", Вероятно , могло бы быть кавычка вместо этого, и , вероятно , было бы лучше, но мой образ мышления был использовать другой идентификатор строки на внутренней стороне в другой точке манипуляции со строками. Итак, вот еще одно место, где вы можете сэкономить несколько байтов в будущем.

Затем мне пришлось инициировать строку Japt после фигурных скобок, в то же время позволяя Пипу оставаться в строке. Я сделал это с '"`помощью одинарной кавычки, двойной кавычки и обратной черты. Для Japt значение 'не находится в строке и, следовательно, является индикатором для принятия следующего символа в качестве одной строки символов. Пип видит 'как часть строки и завершает свою строку с помощью ". И наконец, `это указывает Pip и Japt, что начинается другая строка, которая продолжается по всему полиглоту до последней строки, где оба языка завершаются счастливо.

Теперь и Japt, и Pip работали на этом этапе, но 05AB1E не удалось из-за использования "вызвало некоторые ошибки, вызывающие экспозицию кода. К счастью, это было достаточно легко решить, обернув "вокруг себя еще один набор , оставив набор манипуляций со строками как "`#"\\'*/{std::cout<<37;}/*'"`".

Наконец, с линией, теперь выглядящей так, с int main() #/*"`#"\'*/{std::cout<<37;}/*'"`"которой у Underload была проблема. Последовательные *, были еще одной синтаксической ошибкой, поэтому я бросил ()в середине, *чтобы успокоить ее.

Хрупкие эзоланги

Большим препятствием теперь стал White Space. Я не буду вдаваться в тонны деталей, потому что большая часть решения Whitespace встроена в уже приведенные объяснения, и я просто приукрашиваю случаи, когда пробел заставлял принимать несколько решений. Я смотрю на тебя, Лабиринт. Однако большое изменение заключается в том, что фактический код для вывода ответа в виде пробела находится в строке 2-4 вместо 1-3. Во многом это связано с экспозицией кода Japt в строке 1.

У Туту изначально были проблемы с тем, что было этой строкой int main() #/*()"`#"\'*/{std::cout<<37;}/*'"`". Итак, я добавлял перевод строки перед первым, #чтобы скрыть все проблемы за индикатором комментария, а затем рассылал спам по /всем остальным, которые были выставлены в коде.

В этот момент я выровнял Hexagony и обнаружил новую проблему. Код в самом начале, который начал свою жизнь как # 1"16" 1принято +в /+23!@не более четкого стека. Итак, я просто удалил +is и обнаружил, что теперь он выводит 123. Это было достаточно легко исправить, изменив начальный гамбит на # 1"16" 2и сыграв в игру Hexagony /3!@.

У Вихря были некоторые изменения, но в основном это был вопрос того, чтобы правильное количество ведущих 1 появилось перед линией Вихря-Инцидента. У инцидента был один жетон, который был особенно трудным. У меня было ровно 3 копии /*и */.

Сначала я хотел просто выбросить *//*любое старое место в коде, чтобы создать 4-ю копию каждого, но Underload снова увидел последовательные *, что было бесполезно. В конце концов я бросил /в конце этой строки, int main() /*чтобы закончить /*/, думая, что я сделаю так, чтобы токены перекрывались, но мне удалось создать только 4 копии одного из двух токенов. Верно-верно. Вот как это работает. О, хорошо, я просто брошу подобное /в финале, */чтобы сделать 4-е место. После этого я заменил группу шестигранных операций на 4-ую копию нескольких жетонов инцидентов в этой строке в последней строке 7LEintndus({})!<>+.

Заключение

Хорошо, это все, что у меня есть для этого массивного рефакторинга. Обещаю, что в следующий раз мне не о чем так много писать. На самом деле я понятия не имею, является ли C ++ хорошим или плохим выбором для этого полиглота, но, на мой взгляд, он открывает некоторые возможности. Надеюсь, это приведет к хорошим вещам.

Удачного кодирования.

3. Минколанг v0.15 (26 байт)

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

Эта программа печатает 1 в Python 3, 2 в Vim и 3 в Minkolang v0.15

Надеюсь, я ничего не испорчу, введя двумерный язык

Попробуйте онлайн!

объяснение

#                     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.

Попробуйте онлайн бета!

В 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 в Brain-Flak , 27 в Perl 6 , 26 в 05AB1E , 25 в Pip , 24 в Thutu , 23 в Hexagony , 22 в Underload , 21 в Nim , 20 в Prelude , 19 в Reng (проверено здесь ), 18 в кардинале , 17 в Юлии , 16 в Пите , 15 в стоге сена , 14 в Туртледе ,13 в Ruby , 12 в Fission , 11 в Befunge-98 , 10 в Befunge-93 , 9 в Perl 5 , 8 в Retina , 7 в Japt , 6 в SMBF , 5 в Python 2 , 4 в> <> , 3 в Минколанг , 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.

Я изменил биты питона для разбора в Brain-Flak, ((() () ())()()<<()>>)который равняется 2 стекам, первый - 5, а второй - 3. После этого я возводю в квадрат 5 с ({({})({}[()])}{})и добавляю результат к 3 с ({}{}). Это возведение в квадрат и добавление происходит в строке с точки зрения Python. Я не могу утверждать, что понимаю рассуждения Python здесь, но я вполне уверен, что эта строка не будет оценена другими языками иначе, за исключением пары исключений.

Оказывается, Japt интерпретирует фигурные скобки в строке как содержащие код, но их было достаточно просто убрать, \прежде чем использовать каждую {в этой строке. Но это раздуло количество байтов. Такова жизнь.

Прелюдия была довольно прощающей со всеми моими скобками. В более раннем комментарии указывалось, что Prelude соответствовал бы вертикально выровненным скобкам, и я случайно создал только один из них. Сладкий! В (верхней строке выровнены с и (9в большой строке. Поэтому мне пришлось добавить дополнительное место перед (верхней строкой. Мое предположение здесь состоит в том, что двойной пробел был индикатором комментария для чего-то, поэтому добавление дополнительного пробела казалось тривиальным, и это работало. Я должен указать, что я попытался добавить дополнительные пробелы (9)вместо этого, но Кардинал не сотрудничал.

05AB1E не понравилась моя первая попытка инкапсулирования строки Python в двойные кавычки, но все, похоже, согласились использовать одинарные кавычки. Ничего страшного там нет.

Гексагония была единственным языком, оставшимся на данный момент, и я, очевидно, был далеко за порогом следующего размера гексагона, поэтому пришло время испачкаться. Это /^23!@код Hexagony, и я очень взволнован этим, потому что я думаю, что это сделает будущие добавления намного проще. Этот маленький кусочек может быть перемещен куда угодно в строке Python без какого-либо нарушения кода. Это полная строка, поэтому мы все на одной странице '(\{(\{})(\{}\/^23!@[()])}\{})(\{}\{})'. /Здесь задает путь Hexagony от SE -> НХ W-> E вниз эта строка, которая у нас есть много свободы с. (Предыдущее \, чтобы избежать/для паутины) Моя идея здесь заключается в том, что если вы вносите изменения, то есть вероятность, что в какой-то момент вы будете проходить через эту строку, и вы можете перемещать фрагмент гексагонии вокруг строки, чтобы поймать путь к коду и отправить его к правильному выводу. Только позаботься о том, чтобы не оказаться между Джаптом \и {. Если у вас возникли проблемы с этим, то @правее строки просто осталось от другого решения Hexagony, и его можно удалить без последствий для других языков. И, конечно, если вам случится поймать путь кода Hexagony в противоположном направлении, вы, конечно, можете использовать @!32^\вместо /^23!@. Кроме того, вы можете заметить, что мое решение удалило===2из кода, чтобы держать вещи под байтовым пределом. Кто-то упомянул здесь, что это для выравнивания Гексагонии, и мне это больше не нужно.

И наконец, вот небольшой фрагмент кода, который я нашел при изучении Codegolf, который преобразует строку текста в читаемый шестиугольник шестиугольника, так что вы можете отлаживать. Я уверен, что многие люди знают об этом, но я не видел его здесь, так что это может помочь кому-то еще. Честное предупреждение, вы должны изменить входные данные, чтобы убрать обратные метки и возврат каретки, а также поменять местами экранирование для чего-то, что занимает нормальное количество места, чтобы код выстроил строки в красивый шестиугольник.

PS Пока я писал это, я понял, что допустил ошибку. Я полагал, что очищаю край памяти Гексагонии для с ^, но, очевидно, я могу заменить его без операции без каких-либо последствий. Это ^должно быть, +если вы попытаетесь манипулировать этим разделом. Я, видимо, проходил через это +до этого, но будущим полиглоттерам, возможно, не так повезло.

Удачи!

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 ниже, если вы хотите работать с ней.

Попробуйте их онлайн!

Наезжать

Эта программа печатает 38 в C, 37 в C ++, 36 в Лабиринте, 35 в INTERCAL, 34 в Rail, 33 в Incident, 32 в Whirl, 31 в модульном SNUSP, 30 в Whitespace, 29 в Trigger, 28 в Brain-Flak, 27 в Perl 6, 26 в 05AB1E, 25 в Пип, 24 в Thutu, 23 в Hexagony, 22 в недогрузки, 21 в Nim, 20 в прелюдии, 19 в Reng, 18в кардинале, 17 в юлии, 16 в пифе, 15 в стоге сена, 14 в туртлэде, 13 в рубине, 12 в делении, 11 в Befunge-98, 10 в Befunge-93, 9 в Perl 5, 8 в Retina, 7 в Japt, 6 в SMBF, 5 в Python 2, 4 в> <>, 3 в Minkolang, 2 в V / Vim и 1 в Python 3.

верификация

Большинство языков протестировано тестовым драйвером, показанным выше. Вы можете проверить Reng здесь и Modular SNUSP здесь ; они выдают соответственно 19 и 31 соответственно.

Вот моя слегка подправленная версия токенизатора Incident , разработанная для того, чтобы быть немного менее игрой в гольф, но немного более полезной.

объяснение

Я всегда любил делать маленькие полиглоты, но никогда такой большой, как этот; Я подумал, что, наверное, стоит попробовать!

После замечательного ответа C ++ от @ Chance, C казался следующим логичным выбором, и, учитывая, по сравнению с некоторыми предыдущими ответами, добавив его относительно легко, я решил пойти на это, когда у меня будет такая возможность!

Я использовал очень известный трюк, чтобы определить разницу между C и C ++; размер символьной константы составляет 1 байт в C ++, но размер int (гарантированно не менее 16 бит) в C. Этот код должен быть очень переносимым (за исключением, может быть, систем, которые используют байты с достаточным количеством битов, чтобы соответствовать int), если только Я сделал глупую ошибку.

Сначала я попытался сделать что-то printfсо всем встроенным, но несколько скобок, казалось, вызывали проблемы для Japt, поэтому я упростил строку, которая, казалось, исправила это.

Далее, Кардиналу это не понравилось, как я догадался из-за наличия %в printf, поэтому мне пришлось решить эту проблему, переключившись на манипулирование строками.

Моя следующая попытка, пытаясь назначить строку и затем изменить второй байт, зависящий от поведения C, закончилась слишком долго и привела бы к вытеснению Hexagony на следующий размер; Я хотел избежать повторения этого, сохранив его в дополнительных персонажах, с которыми мне пришлось играть! Мне понадобился каждый байт, который я мог получить для этого, поэтому я реализовал изменения сохранения байтов, предложенные @Chance.

Таким образом, я немного проиграл этот код на C и придумал, puts(sizeof'c'-1?"38":"37");что почти сработало, за исключением того, что Underload был ошибочным, предположительно из-за сложного выражения в скобках.

Даже после удаления дополнительного, >>который требовался для соответствия <<в Perl6, я не смог найти достаточно краткий способ разбить более сложную часть на присвоение массива символов. В итоге я решил использовать препроцессор.

После долгих проб и ошибок я нашел решение, которое, похоже, нравилось Retina. Прелюдия, которая вызывала у меня проблемы время от времени, заканчивала тем, что исправляла себя, прежде чем я удосужился посмотреть, почему она сломалась (я думаю, либо скобки, либо !я имел в троице на одном этапе, глядя на предыдущие ответы).

Все это время я исправлял пустые места, чтобы получить то, что им хотелось бы; Я обнаружил, что это довольно легко. В частности, это tab space space spaceбыла очень полезная комбинация (инструкция по добавлению двух верхних элементов в стек), так как это означало, что я мог добавить пробел к строкам без других пробелов без того, чтобы все не синхронизировалось (я предполагаю его положение в Программа означает, что она никогда не выполняется, поэтому я не беспокоюсь о переполнении стека здесь).

Я сейчас проверил инцидент, и он работает! Большое спасибо @Chance и @LliwTelracs, которые, как я только что понял, НЕ Уэльское имя, за то, что они помогли мне разобраться с этим. Смотрите эту подсветку синтаксиса . Я удалил ;токен, который появлялся перед #yyтокеном. Я сделал это, просто добавив дополнительные ;после getsоператора (моя предыдущая попытка состояла в замене s(которая теперь выглядит намного больше в программе на С, чем в предыдущем)) в строку «детокенизация» с помощью ;, но оказалось, что я был на самом деле символ сокращен от Hexagony (спасибо @Chance), поэтому после попытки добавить дополнительный символ к этой последней строке не удалось, я просто изменил его обратно и добавил дополнительную точку с запятой в другом месте).

Я также немного подправил пробел, чтобы поменять некоторые другие токены, чтобы попытаться отцентрировать, повторно токенизировать перевод строки табуляции (переместив вкладку в конце #includeстроки в середину, создав таким образом три токена), и снять токен с тройного пробела, переместив один пробел в defineстроке.

Наконец, через день после первоначального представления я решил докопаться до страшного предупреждения препроцессора, которое выдал gcc (и которое заставило Кланга выйти из строя). Я определил, что причина, по которой первая строка сработала, заключается в том, что именно выход препроцессора предоставляет отладочную информацию, такую ​​как исходные имена файлов и нумерация строк. Им не нравились первые «2» в первой строке, потому что это означало «возврат из включенного файла в данный файл», и, очевидно, это невозможно, поскольку не было никаких включенных файлов. Изменив его на «1» (начальный нормальный заголовок), задушив несколько слишком много языков, я изменил его на «3» (начальный внутренний заголовок компонента), который сломал только гексагонию, поскольку теперь он полагался на 2. Итак, в начале кода Hexagony я добавил открытую скобку(чтобы уменьшить 3 на 2, затем заключить в квадратную скобку )после end ( @) кода шестиугольника, чтобы удовлетворить Retina, Prelude и Underload, которые ожидали совпадения в скобках. Повторное тестирование Reng и Modular SNUSP не вызвало проблем, и токены Incident выглядели правильно, так что теперь я исправил это! Я проверил это на множестве экзотических архитектур, и это, кажется, работает. Я знаю, что это не важно для гольф-кода, и я не буду возражать, если будущие авторы должны будут нарушить это снова, чтобы сохранить счетчик байтов или что-то еще (или если кто-то уже начал использовать это решение и не хочет менять свое слишком много), но есть одна веская причина, по которой я это сделал - компилятор TIO Objective-C поддерживает только Clang, так что это будет очень полезно, если кто-то захочет добавить это!

Имейте в виду, что я никогда не использовал большинство этих языков, я надеюсь, что мой успех побудит больше новичков попробовать!

65. АЛГОЛ 68 (Джинн) , 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 в Agony, 63 в Brian & Chuck, 62 в Grass, 61 в SILOS, 60 в Moorhens 2.0, 59 в Tcl, 58 в Ksh, 57 в Wise, 56 в dc, 55 в Brain -Flak Classic, 54 в Zsh, 53 в Shove, 52 в COW, 51 в Ассамблее, 50 в Bash, 49 в Octave, 48 в Deadfish ~, 47 в Lily, 46 в Cubix, 45в PicoLisp, 44 в alphuck, 43 в ретикулярной, 42 в злой, 41 в brainfuck, 40 в Minimal-2D, 39 в CoffeeScript, 38 в C, 37 в C ++, 36 в лабиринте, 35 в INTERCAL, 34 в Rail, 33 в Инциденте, 32 в Вихре, 31 в Модульной SNUSP, 30 в Пустом пространстве, 29 в Триггере, 28 в Мозговом Flak, 27 в Perl 6, 26 в 05AB1E, 25 в Пипсе ,24 в Thutu, 23 в Hexagony, 22 в Underload, 21 в Nim, 20 в Prelude, 19 в Reng, 18 в Cardinal, 17 в Julia, 16 в Pyth, 15 в Haystack, 14 в Turtlèd, 13 в Ruby, 12 в Fission, 11 в Befunge-98, 10 в Befunge-93, 9 в Perl 5, 8 в Retina, 7 в Japt, 6 в SMBF, 5 в Python 2, 4 в> <>, 3в Минколанге, 2 в V / Vim и 1 в Python 3.

верификация

Большинство языков можно протестировать с помощью тестового драйвера выше, но 6 языков должны быть протестированы локально.

• Reng может быть проверен для вывода 19 здесь .

• Модульный SNUSP можно протестировать для вывода 31 здесь .

• Инцидент был проверен для проверки 33 с помощью ручной балансировки токенов.

• Deadfish ~ можно протестировать для вывода 48 локально, используя этот интерпретатор . Обратите внимание, что Deadfish ~ принимает полиглот для подачи на стандартный ввод, но выводит несколько >>запросов на стандартный вывод, что является неизбежным следствием запуска любой программы Deadfish ~.

• Moorhens 2.0 может быть протестирован для вывода 60 с помощью этого интерпретатора .

Алгол 68

ALGOL, вероятно, наименее известен из четырех языков программирования высокого уровня с первых дней программирования - остальные языки этого туманного различия - это COBOL, FORTRAN и Lisp. В то время ALGOL был более известен в академических и математических кругах, но сегодня наиболее известен своим огромным влиянием на современные языки. Фактически, большинство современных практических языков можно описать как «подобные Алголу», не последним из которых является C, который, конечно, имеет свою собственную линию влияний и производных.

Я очень рад включить ALGOL, потому что это еще один важный шаг в компьютерной истории, который мы добавим к этому памятнику, который мы называем полиглотом. Это круто.

ALGOL68 - это последняя из трех основных спецификаций ALGOL, остальные - ALGOL60 и ALGOL58. Интересно, что в спецификации нет фиксированного синтаксиса, что означает, что токены определены, но не написаны. Это делает язык сильно зависимым от интерпретатора, потому что любой данный интерпретатор может использовать другой символ, например, для инициирования блока комментария. Спецификация описывает ¢как инициирующий блок комментария. Но поскольку ¢он не входит в число базовых 127 кодов ascii, он, по понятным причинам, не видит особого смысла в качестве индикатора комментариев среди доступных интерпретаторов. Что ж, получается, что интерпретатор Genie записывает ¢как #, то есть все, что нам нужно, чтобы пройти символ 1 и сделать полиглот.

Genie на самом деле есть три варианта комментарии синтаксиса, два других coи comment, оба из которых определены как написано жирного шрифта. Да, смелый Если мы используем курсив, это переменная. Джин снова решил это для нас, написав жирным шрифтом все заглавные буквы. И поскольку COнигде нет в полиглоте, у нас есть простой способ скрыть полиглот от парсера. Если в будущем COпотребуется язык, мы можем перейти к более подробному COMMENTсинтаксису.

В ALGOL нет строковых комментариев - все они в блочном стиле, что означает, что их необходимо завершить. Учитывая начальное состояние полиглота, наш комментарий блока ALGOL открывается немедленно и заканчивается в конце строки 1, потому что Turtlèd аналогичным образом используется #в качестве маркера перехода. Turtlèd очень , к счастью , нет проблем ходить через Cи Oсимволы так , в строке 1 , мы можем просто вставить COсразу после того , как второй , #чтобы инициировать жир блок комментарий для ALGOL68.

Отсюда мы просто должны COprint("65")где-то разместить . Я выбрал последнюю строку, потому что предпочел завершить строку другим #комментарием, и я не хотел, чтобы комментарий заканчивался #в начале последней строки. Таким образом, мы следим за нашим оператором печати ALGOL #sи #последним символом в полиглоте. sВ #sдля alphuck , чтобы сбалансировать pв печати.

Спасибо @ ais523 за то, что открыли конец полиглота с ответом 59 и сделали все это возможным.

SMBF

Мы добавили другой символ в конец полиглота, чтобы завершить последний комментарий ALGOL, и SMBF ранее считывал последний символ для своего ответа. Чтобы исправить это, я должен был изменить SMBF, чтобы прочитать второй до последнего символа, изменив этот код в строке 8 [.>-]на этот [<.>>-]. Это блок частного кода SMBF, поскольку MP BF равен 0, когда цикл инициируется.

Спусковой крючок

В этот момент я заметил странное поведение с SMBF, и это было связано с отношениями между этими сегментами кода и концом полиглота.

• пункт назначения инцидента: ^_^_

• Триггер Прыжок назначения плюс ответ: X222999

• Ответ ALGOL68: COprint("65")#s

Ответ ALGOL маркировал пару токенов Incident в пределах его сегмента кода, поэтому код ALGOL должен был предшествовать сегменту кода Incident. АЛГОЛ также вызвал проблему выравнивания прелюдии, если он шел первым в порядке, поэтому он должен был идти вторым или третьим. Тем временем SMBF имел необъяснимый сбой, когда код Инцидента шел последним, поэтому Инцидент должен был идти первым или вторым. Ну, я понял, что это была вводная логическая проблема, которая казалась неразрешимой, поэтому я решил сделать необъяснимое более… податливым.

Пройдя через SMBF, я обнаружил, что проблема с ^ _ ^ _ в конце была из-за Мудрого. Код Wise ( ~-<~-<~-<<<~-) не скрывается за неисполняющимся циклом, в отличие от большинства полиглотов. Но в коде Wise нет кодов печати SMBF. Это было просто изменение значений памяти. Это казалось безобидным. Так в чем же тогда была проблема? Это было чертовски SM перед BF.

Код Wise изменяет символы в коде, который должен быть выполнен, и можете ли вы догадаться, что является соседом значения ascii ^? Это ]. Мудрый помещал терминатор петли SMBF в конец полиглота, заставляя SMBF падать в бесконечный цикл. Это плохо, моджо.

После того, как некоторые думали , что я принял решение 0 байт проблемы и отделенной цель перехода триггера ( X) от его ответа ( 222999) и закончил полиглот таким образом: ~-<~-<~-<<<~-XCOprint("65")#s^_^_2229996#. Это работает только потому, что ни один символ не появляется последовательно после скачка Триггера, который не является ответом Триггера.

Завершение

Это все основные изменения в этом раунде. Я сделал небольшое изменение, чтобы сократить многое из обсуждаемого cв строке 1, но только для изменений в гольфе.

Удачи!

Отчет об инциденте

#<q>"3"O.sстало #<T>"3"O.sпотому, что детокенизация Tвместо того, чтобы быть qболее эффективным в балансировании

<>{стал <>{ndдетокенизировать ndи{␊

Поместите пробел между }}и +внутри, #<]}} +<[<.>>-]>[чтобы детоксифицировать }}+дешевле.

2. V (11 байт)

print(1)#i2

Эта программа печатает 1 в Python 3 и 2 в V.

Просто для того, чтобы начать играть, и с самого начала добавить свой любимый язык. :)

Это очень простой ответ.

print(1)#

просто так получается NOP в V. (к счастью для меня) Затем i2переходит в режим вставки и вставляет '2'. Вы можете попробовать V онлайн здесь

Конечно, в питоне

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 в Prelude , 19 в Reng (можно проверить здесь ), 18 в Cardinal , 17 в Julia , 16 в Pyth , 15 в Haystack , 14 в Turtlèd , 13 в Ruby , 12 в Fission , 11 в Befunge-98 , 10 в Befunge-93 , 9 в Perl , 8 в Retina , 7 в Japt , 6 в SMBF ,5 в Python 2 , 4 в> <> , 3 в Minkolang , 2 в Vim / V , 1 в Python 3 иa partridgeв A Pear Tree .

Существующий код в значительной степени отменяет себя в Prelude, состоящем только из циклов while с аргументами Falsey и некоторого манипулирования стеками в стеках, которые нас не интересуют. Более того, в коде есть место, которое является комментарием на всех языках, где они есть (между #и =#предыдущим представлением). Сложной частью встраивания Prelude в это было генерирование чисел только с одним стеком без увеличения количества байтов. Эта программа использует цикл, который добавляет 45 к каждому элементу стека и выводит его как ASCII, таким образом, помещая 5 над 3 в стеке, мы получаем в 20качестве вывода. (Точно, 20 - это более простое число для вывода, чем 19 в Prelude, поэтому опубликованный ответ 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 в Trigger , 28 в Brain-Flak , 27 в Perl 6 , 26 в 05AB1E , 25 в Pip , 24 в Thutu , 23 в Hexagony , 22 в недогрузке , 21 в Nim , 20 в Prelude , 19 в Ренге (проверено здесь ), 18 в кардинале , 17 в Юлии , 16 в Пите , 15 в стоге сена , 14 в Turtlèd , 13 в Ruby , 12 в Fission , 11 в Befunge-98 , 10 в Befunge-93 , 9 в Perl 5 , 8 в Retina , 7 в Japt , 6 в SMBF , 5 в Python 2 , 4 в> <> , 3 в Минколанге , 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 была заменена на вкладку. Похоже, что это идентично пространству для двумерных языков, но визуально оно больше не совпадает. ¯ \ _ (ツ) _ / ¯

После инструкций для вывода 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]

И вот прокомментированная версия только Whitespace:

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 был достаточно любезен, чтобы обновить @ Hexagonizer Кенни для учета буквальных переходов и вкладок. Мне пришлось изменить его, чтобы исправить мое предыдущее утверждение о том, что вкладки читаются как no-ops, и заменить буквенные экранированные символы, .потому что ␛символ шире, чем другие символы, что делает гекс слегка смещенным. Здесь ссылка .

И это наш исправленный текущий Hex:

          # 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.

Код Нима вернулся echo 21изecho 5+5+11

Гексагонии #@46сейчас#46

Код Hexagony вернулся к /+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 в Retina, 9 в Perl 5, 10 в Befunge- 93, 11 в Befunge-98, 12 в Fission, 13 в Ruby, 14 в Turtlèd, 15 в Haystack, 16 в Pyth, 17 в Julia, 18 в Cardinal, 19 в Reng, 20 в Prelude, 21в Nim, 22 в Underload, 23 в Hexagony, 24 в Thutu, 25 в Pip, 26 в 05AB1E, 27 в Perl 6, 28 в Brain-Flak, 29 в Trigger, 30 в Whitespace, 31 в модульном SNUSP, 32 в Whirl , 33 в Инциденте, 34 в Rail, 35 в INTERCAL, 36 в Лабиринте, 37 в C ++ 03, 38 в C99, 39 в CoffeeScript, 40 в Minimal-2D, 41 в brainfuck, 42 зла, 43 в сетке, 44 в альфаке, 45 в PicoLisp, 46 в Cubix, 47 в Lily, 48 в Deadfish ~, 49 в Octave, 50 в Bash, 51 в Ассамблее, 52 в COW, 53 в Shove, 54 в Zsh, 55 в Brain-Flak Classic, 56 в DC, 57 в Wise, 58 в Ksh, 59 в Tcl, 60 в Moorhens, 61 в SILOS, 62 в Grass, 63в Brian & Chuck, 64 в Agony, 65 в ALGOL 68, 66 в Surface, 67 в C11, 68 в Python 1, 69 в rk-lang, 70 в Commercial, 71 в чем, 72 в Fortran, 73 в Morse, 74 в арке, 75 в C ++ 11, 76 в Trefunge-98, 77 в C ++ 14, 78 в тире, 79 в C ++ 17, 80 в Klein 201, 81 в Klein 100, 82 в Brain-Flueue, 83 в Обеке, 84 в Klein 001, 85 в zkl, 86 в Miniflak, 87 в Alice, 88 в PingPong, 89 в gnuplot, 90 в RunR, 91 в Cood, 92 в C89, 93 в Set, 94 в Emotinomicon, 95 в Emoji, 96 в EmojiCoder, 97 в Кубе, 98 в Archway2, 99 в 99 . 100 в мозговом шуме

верификация

Попробуйте онлайн! Языки, недоступные на TIO:

• Джапт, 7 онлайн .
• Ренг, 19 онлайн .
• Deadfish ~, 48 местный .
• Moorhens, 60 местных . используйте moorhens.py из ветки v2.0-dev
• Морзе, 73 местный
• Арка, 74 местная
• Trefunge-98, 76 местный . Используйте -d 3 -v 98для Trefunge-98.
• Обецк, 83 местный
• Зкл, 85 местный
• Пинг-понг, 88 местный
• RunR, 90 местный
• Куд, 91 онлайн
• Комплект, 93 онлайн
• Эмотиномикон, 94 онлайн
• EmojiCoder, 96 онлайн
• Archway2, 98 local Я не могу проверить Archway2, потому что у меня нет подходящего компилятора C, однако stasoid подтвердил, что он работает в archway2

объяснение

Я не могу поверить, что мы сделали это на 100 языках. Я просто хотел бы поблагодарить всех, кто был вовлечен в этот процесс. Это была забавная поездка, и я надеюсь добавить еще 100 с вами, ребята.

Brainbool был в моем глазу некоторое время. Однако, поскольку brainbool может выводить только два числа, 1и 0я не смог добавить его до сих пор (меня не было около 10 и 11).

Brainbool - это то же самое, что и brainfuck, за исключением того, что вместо 256 он переносится в 2. Brainbool также не имеет аргумента, -потому что он избыточен с +. Наш мозговой код для вывода 100 довольно прост:

+.+..

Чтобы замаскировать вывод для brainfuck, мы добавляем цикл и минус:

+-[.+..]

Теперь все, что нужно, - это найти место для кода. Я выбрал первое место +на верхнем уровне кода для мозгового удара в строке 8. Чтобы заменить его плюсом, мы добавили наш код, +-+который действует как +мозговой мозг и как тупик в мозговой игре.

+-[.+..]+-+

Cubix

Я помещаю свой код перед капсулой 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 в Nim , 20 в прелюдии , 19 в Reng (проверено здесь ), 18 в Кардинал , 17 в Джулия , 16 в Пиф , 15 в Хейстек , 14 в Туртлед , 13 в Руби ,12 в Fission , 11 в Befunge-98 , 10 в Befunge-93 , 9 в Perl 5 , 8 в Retina , 7 в Japt , 6 в SMBF , 5 в Python 2 , 4 в> <> , 3 в Minkolang , 2 в Vim / V , 1 в Python 3 и (как сейчас Рождество)a partridgeв A Pear Tree .

Подсветка синтаксиса, которую Stack Exchange производит для этого ответа, совершенно неверна. #`<это один из многих многострочных маркеров комментариев в Perl 6, оканчивающийся на #>, таким образом, единственный код, который на самом деле выполняется в Perl 6, является очень простым say 27. Я выбрал именно этот маркер комментария, потому что <>в большинстве языков нет подходящей пары, и, таким образом, непревзойденная пара <не сломает языки, такие как Retina, которые пытаются ее проанализировать.

Я не совсем уверен, как работает Hexagony. Когда он сломался, я изменил один из символов, который он использовал, с a +на a, 0чтобы посмотреть, не попал ли в него удар; Оказывается, это было, и оказывается, что это исправило программу, но я не уверен почему (я знаю, что это сломалось из-за #в строке выполнения, но неясно, почему удаление +исправлений). (Рассматриваемый персонаж также анализируется Thutu, но, к счастью, это не влияет на функционирование программы Thutu, так как в этот момент в программе все, чему не предшествует символ, =копируется буквально в рабочий string.) Обратите внимание, что0and+4 из предыдущей строки стало0and 4, чтобы сделать его на один символ короче с точки зрения Гексагонии (Гексагония не видит пробелов); это должно компенсировать #|превращение в предыдущей строке #`<`|, которая на один символ длиннее с точки зрения Гексагонии (потому что она также не видит обратных кавычек). Обратите внимание, что теперь в коде всего пять байтов от расширения длины стороны гексагонии и нарушения всего, что касается текущего кода гексагонии. Я бы порекомендовал сделать это в любом случае и просто переделать секцию гексагонии кода; вероятно, будет легче, чем труднее, вписать все после расширения.

Также изменились некоторые другие языки, в основном, чтобы добавить достаточную надежность, чтобы я мог поместить произвольный код в последнюю строку. $//это маркер комментария в Japt, который позволяет пробелы позже в строке, что делает добавленную программу менее хрупкой в ​​Japt (между тем, //разрывается, если в строке есть закрывающие скобки, а пробел является своего рода закрывающей скобкой в ​​Japt). Пара пробелов - это маркер комментария в Pip, означающий, что здесь можно существенно упростить код Pip. Это также означает, что мы можем упростить 05AB1E до тривиального "26. Retina нуждается в пятой строке, чтобы быть законным регулярным выражением, которое хорошо сочетается (конечный|таким образом для сетчатки); он анализируется не так, как соответствующая строка в предыдущей записи, но таким же образом, как это подходит. Кардинал также немного проще, чем в предыдущих статьях, но это просто чистое совпадение с тем, как все выстраивается вертикально, и изменение заключается в коде, который ничего не делал в любом случае.

Предполагая , что вы заново Hexagony (вы , вероятно , придется), есть безопасные места , чтобы добавить код на всех последних трех линий: 3в #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 и ␉буквальная вкладка.

Наезжать

Эта программа печатает 31 в модульном SNUSP, 30 в Whitespace, 29 в триггер, 28 в головном мозге-Flak, 27 в Perl 6, 26 в 05AB1E, 25 в Пип, 24 в Thutu, 23 в Hexagony, 22 в недогрузки, 21 в Nim , 20 в прелюдии, 19 в Reng, 18 в кардинал, 17 в Julia, 16 в Pyth, 15 в Хейстек, 14 в Turtlèd, 13 в Ruby, 12 в дЕЛЕНИИ,11 в Befunge-98, 10 в Befunge-93, 9 в Perl 5, 8 в Retina, 7 в Japt, 6 в SMBF, 5 в Python 2, 4 в> <>, 3 в Minkolang, 2 в V / Vim, и 1 в Python 3.

верификация

Почему нет ссылок в кратком изложении? Поскольку я работал над тем, чтобы сделать тестирование намного проще, тестовым драйвером, который запускает программу на большинстве языков, перечисленных здесь, и печатает результат. Надеемся, что это значительно упростит добавление будущих языков в полиглот. Вы можете получить результаты этой программы для 28 из 31 языка, запустив следующую ссылку TIO (тестовый драйвер, написанный на смеси Bash, Perl и A Pear Tree):

Попробуйте их онлайн!

Ссылка также создает блок кода, отформатированный в ␛/, ␉как показано выше, и форматирует код в шестиугольник для вас:

          # 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 слишком медленный, а Reng и Modular SNUSP не установлены на TIO. К счастью, у всех трех есть онлайн-переводчики:

• Вы можете протестировать программу в V / Vim (предполагаемый вывод: 2) здесь, на TIO.
• Там в онлайн Reng переводчик (предназначен выход: 19) здесь .
• Там в онлайн Modular SNUSP переводчик (предназначен выход: 31) здесь . (Он рекламируется как просто интерпретатор SNUSP, но модульный SNUSP - это диалект, который он на самом деле реализует, как видно по @знакам по всей странице.)

Все три выдают намеченный результат, поэтому все 31 программы проходят надлежащую проверку. (Одна вещь, которая меня немного беспокоит, связана с тем, правильно ли завершается программа Whitespace; однако, пробелы здесь идентичны предыдущим представлениям, поэтому они оба правильные или оба неправильные. Если окажется, что программа действительно завершается неверно, обе программы могут быть исправлены одинаково.)

объяснение

Во-первых, Гексагония, которая, кажется, всегда нуждается в изменении. На самом деле это намного проще, чем раньше; Я переместил код Hexagony сразу после кода Trigger, это означает, что он очень близок к концу программы, и «капсула» Hexagony, которая печатает 23 и выходит, запускается практически сразу. Последняя строка обычно выглядит как хорошее место для размещения капсулы, так как это означает, что будет выполняться меньше команд, которые могут потенциально нарушить гексагонию.

Все остальные изменения связаны с добавлением модульного кода SNUSP. Первое, на что следует обратить внимание, это то, что SNUSP начинает выполняться с первого $символа в программе и является двумерным языком, который выходит после выхода за границу программы и, таким образом, помещает программу SNUSP в конце длинной строки (внутри код Thutu, в момент, когда Thutu будет принимать почти все), мы можем быть уверены, что SNUSP не увидит код из других языков, и большинство других языков не будут заботиться о SNUSP. Один язык, который действительно заботился, был Perl 6, который разбирает угловые скобки; Я поместил <непосредственно перед кодом SNUSP, чтобы он оставался счастливым (так как скобки, естественно, почти совпадали). Другой язык, который заботится, является SMBF;.выводит как SMBF, так и SNUSP, и мы не хотим создавать дополнительный вывод. К счастью, как видно из SMBF, за этой программой <.>>[…]следует код SNUSP, то есть текущий элемент ленты равен 0. Таким образом, заключив код SNUSP в квадратные скобки, «закомментируйте» его с точки зрения SMBF.

Что касается самого кода, он использует известный трюк для записи констант в модульном SNUSP, в котором вы пишете много команд «запуска процедуры» подряд и эффективно создаете своего рода число Фибоначчи. Основная идея заключается в том, что +кодирует число 1; @складывает число, представленное кодом после него, и число, представленное кодом после него, минус его первый символ; и не =является опцией (таким образом @=, удвоит число справа). В этой системе я выбрал @@@@=+@@@=+#в качестве представления число 48.

Здесь есть проблема; стандартный метод записи констант в SNUSP оставляет поток управления позади запуска программы, и с помощью oneliner (который я хотел написать здесь по понятным причинам) нет способа изменить IP, чтобы он указывал в каком-либо направлении, кроме правильного. Это означает, что нам как-то #понадобится заставить IP пройти полное определение константы и продолжить вправо, без выхода из программы (что обычно происходит). Чтобы решить эту проблему, я тщательно использовал определение числа, которому +всегда предшествовал =. Это означает, что я могу написать код для установки второй ячейки на 48 через @@@@=>+<@@@=>+<#, безопасно, зная, что ни одна из >команд не будет пропущена@команда (и таким образом мы сохраняем контроль над указателем ленты). Кроме того, мы знаем, что в конечном #итоге первая ячейка ленты все еще будет иметь свое начальное значение. Таким образом, мы можем использовать первую ячейку ленты в качестве маркера, чтобы узнать, следует ли вернуться из определения процедуры или продолжить вправо (при этом мы находимся внутри множества процедур, но мы выходим из программы, упав с край, так что это не имеет значения).

Окончательный код SNUSP, следовательно, таков $+@+-@@@@=>+<@@@=>+<?#>+.--.. В $отмечает начало программы. +@+-устанавливает первый ленточный элемент на 1 ( ++-но, как только процедура, запущенная с @возвратами, запускает код начиная с нуля, таким образом, -возвращая ленточному элементу значение 0, ?#завершает процедуру, только если первый ленточный элемент не равен нулю; мы в конечном итоге получим после того, #как второй ленточный элемент будет установлен в 50 (48 из определения константы, плюс 2 из двух, >+<встречающихся при переходе вправо впоследствии). Затем все, что нам нужно сделать, это >+.--.вывести коды ASCII 51 ( 3) и 49 ( 1), и падают с края программы ( ]в SNUSP это не работает, и /отражает поток управления по вертикали так, что он выходит за верхний край программы); этот бит работает как мозговой трах.

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

Печать:

• 1 в Python 3
• 2 в Vim - По какой-то причине вывод занимает довольно много времени ...
• 3 в Минколанге v0.15
• 4 в > <>
• 5 в Python 2
• 6 в SMBF
• 7 в японии
• 8 в сетчатке
• 9 в Perl
• 10 в Befunge 93
• 11 в Befunge 98

Честно говоря, я понятия не имею, почему вывод кода Vim занимает 1 минуту. Кроме того, понятия не имею, как работает Retina.

Объяснение:

#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 в Rail, 33 в Incident, 32 в Whirl, 31 в модульном SNUSP, 30 в Whitespace, 29 в Trigger, 28 в Brain-Flak, 27 в Perl 6, 26 в 05AB1E, 25 в Pip , 24 в Thutu, 23 в Hexagony, 22 в недогрузки, 21 в Nim, 20 в прелюдии, 19 в Reng, 18 в кардинал, 17 в Julia, 16 в Pyth,15 в стоге сена, 14 в Turtlèd, 13 в Ruby, 12 в Fission, 11 в Befunge-98, 10 в Befunge-93, 9 в Perl 5, 8 в Retina, 7 в Japt, 6 в SMBF, 5 в Python 2, 4 в> <>, 3 в Минколанге, 2 в V / Vim и 1 в Python 3.

верификация

Большинство языков протестированы тестовым драйвером, показанным выше. Вы можете проверить Reng здесь и Modular SNUSP здесь ; они выдают соответственно 19 и 31 соответственно. Я проверил инцидент локально на моей собственной системе, используя официальный переводчик.

Обратите внимание, что я добавил несколько изменений в тестовый драйвер, чтобы было легче обнаружить скрытые символы; различные NUL-байты попали в вывод программы на определенных языках. Я решил, что это, вероятно, не проблема, потому что: а) это делали самые разные материалы, и б) интерпретаторы Befunge, кажется, добавляют дополнительные байты NUL, хотя ничто в программе не подразумевает этого (если я что-то пропустил), так что это должно было происходить целую вечность и, вероятно, является частью того, как работает переводчик. (Обратите внимание, что языки, которые все еще выводят байты NUL - Befunges и Minkolang - не изменили свой код для этого представления.)

Предыдущая отправка Rail завершается через crash, что запрещено, но это легко исправить (добавив a #в конце программы Rail и настроив Hexagony так, чтобы он соответствовал), и поэтому я не считал это серьезной проблемой. Рельс в этом решении выходит правильно.

объяснение

Как работает ИНТЕРКАЛЬНЫЙ код

INTERCAL разбирает всю программу. Тем не менее, синтаксические ошибки - это вещь времени выполнения в INTERCAL, а не во время компиляции, и это часто используется для создания комментариев. (Если попытается выполнить синтаксическую ошибку, она вылетит из программы с ошибкой ICL000I, вопреки ошибочным утверждениям Википедии. Но если вы можете помешать ее выполнению каким-либо образом - и у INTERCAL есть много способов предотвратить запуск команд - это вполне довольны, не выполнить, не вызывая проблемы.)

Таким образом, мы можем предотвратить мусор в конце запуска файла, просто выйдя из программы в первую очередь явным образом (что в любом случае требуется, потому что INTERCAL падает, если конец программы достигнут без явной команды выхода). Обработка запуска программы более интересна и использует ошибку парсера. Вы можете написать что-то вроде DO %20 READ OUT #8вывода VIIIс вероятностью 20% (а иначе ничего не делать). Насколько я могу судить, 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 выглядит не совсем так в готовом продукте; Я объясню почему, как мы идем.

Похоронен под грузом Sэс

Наиболее очевидная проблема с программой INTERCAL заключается в том, что она содержит письмо S. Это в значительной степени неизбежно, поскольку нет способа индексировать массив без использования соответствующей буквы. Тем не менее, Sэто выходная команда в Underload, и нет способа предотвратить ее разбор всей программы. Единственное решение - поместить код INTERCAL в круглые скобки, эквивалентный строковому литералу в Underload, чтобы он не запускался сразу.

Тем не менее, у нас есть два ^символа в конце программы, которые выполняют код недогрузки; так что эти Sэсеры все равно будут казнены, если мы ничего не сделаем. Я мог бы изменить его на другой символ, но решил, что легче защитить код, чтобы он стал бессмысленным. aэкранирует строку в Underload (это означает, что ^после выполнения строки она просто снова будет удалена, а не вызовет вредных побочных эффектов). У нас уже есть один aв sayиспользуемом в Perl 6 коде (которого при таком расположении кода на самом деле достаточно из-за несвязанных изменений). Тем не менее, чтобы люди не должны полагаться на это, я добавил ещеaв конце строки (я в любом случае хотел, чтобы там был символ, чтобы сделать видимыми конечные пробелы, и потому что гексагония нуждалась в заполнении как есть; обратите внимание, что гексагонию было довольно легко исправить в этой программе, и на самом деле это не так нужно отдельное обсуждение). Так что код Underload немного менее хрупок, чем мог бы быть.

Прелюдия к большому количеству работы и растерянности

Ах, прелюдия. Обычно это не самый сложный язык, но это определенно было на этот раз. Есть две настоящие проблемы: одна заключается в том, что добавление дополнительных скобок в слишком длинную строку рискует нарушить поток управления программы Prelude (поскольку они создают эквивалент whileцикла), а другая - просто проблему предотвращения их выравнивания. вверх по вертикали (что отвечает за большую часть случайного перемещения по пустому пространству на линиях). Обратите внимание, что Whitespace также доставил мне некоторые неприятности, но эта программа эквивалентна предыдущей с точки зрения Whitespace, так что это был в значительной степени случай «исправить Prelude без разрушения Whitespace».

Я не слишком уверен, как на самом деле работает Prelude на данный момент. Для этого есть несколько исправлений, например, 0 рядом с левым нижним углом, но они явно не работают так, как я хотел. (Код Джулии также в конечном итоге переместился в конец строки, потому что с скобками в его 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 сойти с ума в правом нижнем углу и просто не позволить ей производить какие-либо выход. Мы можем изменить фактический код деления, чтобы закончить, *а не;, которая выходит из всей программы, а не из одного потока; этот код выполняется довольно быстро, поэтому он выходит из программы до того, как все случайные точки входа успеют нанести какой-либо ущерб.

Вяжем 6, Perl 6

Следующая проблема: комментарии Perl 6 работают путем сопоставления <и >. Оператор присваивания INTERCAL является <-. К счастью, это добавляет дополнительные открывающие скобки, поэтому я мог бы просто добавить несколько закрывающих скобок, чтобы отменить их в неразобранном месте в программе (в данном случае сразу после кода Pip).

Однако я не хотел изменять бюджет пробелов в программе, но перемещение кода Джулии (для Prelude) привело к добавлению дополнительного пробела в последнюю строку; Я должен был удалить один откуда-то. Двойной пробел - это маркер комментария в Pip, так что я вряд ли смогу его изменить; единственный оставшийся вариант - это пробел в say 27. Игроки в Perl 5 сразу же подумают: «Ну, просто делай say+27тогда» (унарное +очень часто пригодится!), Но, к сожалению, это неверный синтаксис Perl 6.

Однако мы можем перейти sayот синтаксиса функции к синтаксису метода. Целочисленные литералы имеют множество методов, в том числе один для их распечатки, так 27.sayчто это совершенно корректная программа такой же длины.

Быть квадратным? Не будь там

Итак, следующая проблема заключается в том, что я добавил в программу дополнительные .функции. Пользователи SMBF будут знать, что это явно проблема на этом языке, создавая случайный вывод (в данном случае NUL-байтов). В прошлой программе уже создавался .случайный вывод, но это не значит, что я не должен воспользоваться возможностью, чтобы это исправить.

Основная идея здесь - создать цикл SMBF для закомментирования оскорбительных инструкций. Это означает перемещение квадратных скобок. Я взял их со всего кода SNUSP (потому что они все равно были только ради Инцидента, и Инциденту все равно, где они находятся в программе), и поставил открывающую скобку в начале кода ИНТЕРКАЛ, и закрывающая скобка непосредственно перед триггером (таким образом, аккуратно скрывая оба .s).

К сожалению, квадратные скобки имеют значение для Retina; он видит […<-#…и говорит: «Это не имеет смысла, вы не можете создать этот диапазон, потому <что раньше этого не было #». К счастью, это легко исправить с помощью стратегически расположенной обратной косой черты.

Инцидент в центре программы

Это произошло в прошлом ответе, и, вероятно, это будет происходить неоднократно с этого момента; разные строки случайно встречались трижды и смещались вокруг центра программы с точки зрения инцидента.

Самый срочный токен, который нужно обработать 1#, появляется три раза, если вы вносите эти изменения наивно: #= >␉1#в начале третьей строки __DATA__=1#и echo 21#. Почему это проблема? Поскольку 1#третья строка перекрывает #vсразу после нее, и два перекрывающихся токена не учитывают ни один из них. И #vэто токен, который мы использовали для комментирования кода перед выходом программы Incident! Я исправил это, пробравшись в дополнительный 1#очень близко к концу программы (за ним следуют только три символа); ни один из языков, анализирующих эту часть программы, ничего с этим не делает.

Существовали различные другие проблемные токены, с которыми нужно иметь дело. У пары были отдельные буквы, Pа U; Я имел дело с этим путем изменений пары наполнителя не-OPS в коде инцидентов от xдо Pили Uсоответственно, давая четвертую копию. Изменение в коде деления *остается в качестве маркера, но, в частности, оно отличается от обычного и появляется дважды перед кодом инцидента и только один раз после. Поэтому вместо удаления я использовал его, чтобы частично сбалансировать новый LEтокен, который появился в коде INTERCAL. Этого достаточно, чтобы вернуть центр программы назад0oмаркер. Конечно, изменения в программе вполне могут помешать этому. (Мои попытки перенести инцидент на TIO не увенчались успехом из-за того, что там нет libdivsufsort, поэтому похоже, что нам может пригодиться новый интерпретатор, особенно в JavaScript, чтобы он мог работать в режиме онлайн. Если вам интересно, посмотрите на это вопрос .)

1. Python 3 (8 байт)

print(1)

Эта программа печатает 1 в Python 3.

Начиная это с 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в последней строке есть буквенный символ ESC (grr, @ ais523). Он не включен в этот код. Чтобы получить актуальный код, перейдите по Try it onlineссылке.

Это печатает 1 в Python 3, 2 в Vim, 3 в Minkolang, 4 в <> <, 5 в Python 2, 6 в SMBF, 7 в Japt, 8 в Retina, 9 в Perl и 10 в Befunge.

Этот код делится *с Retina, .Minkolang и SMBF.

Попробуйте онлайн

объяснение

Актуальная программа

#v02^
    @
    .
    *



    t
    5
#v02^

Последняя строка была написана для ясности ( детская площадка Befunge циклична.)

#

Батут, скипы v

02^

Нажмите 0и затем 2в стек и поднимитесь.

5t*.@

Push 5, no-op, умножение двух элементов в стеке ( 2и 5), печать, завершение программы.

21. Ним (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`на последней строке. Вы можете сказать, что мой предыдущий играл в гольф в спешке, потому что я проснулся этим утром и понял, что могу взять еще немного. У меня было 152 байта, но, похоже, это работает только в Perl 5.24.0, поэтому в интересах совместимости с TIO я пока сохранил оригинальное выражение.

1 в Python 3, 2 в V, 3 в Минколанге, 4 в> <>, 5 в Python 2, 6 в SMBF, 7 в Japt, 8 в Retina, 9 в Perl, 10 в Befunge-93, 11 в Befunge -98, 12 в Fission, 13 в Ruby, 14 в Turtléd, 15 в Haystack, 16 в Pyth, 17 в Julia, 18 в Cardinal, 19 в Reng, 20 в Prelude и 21 в Nim .

Обратите внимание, что Nim на ideone.com использует версию 0.11.2, которая немного устарела, поскольку эта программа использует #[ ... ]#многострочные комментарии, добавленные в начале 2016 года.

Благодаря интерпретатору Cardinal для Windows мой рабочий процесс теперь состоит из двух ноутбуков и http.serverпромежуточного Python .

Изменить - еще несколько подсказок:

• В 8начале последней строки устанавливается ограничение Retina на первые 8 совпадений, иначе без него Retina будет выводить 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 ниже, если вы хотите работать с ней.

Хотите узнать больше? Попробуйте чат с полиготами !

Попробуйте онлайн!

VIP оценка ( универсальный целочисленный принтер ): .008186 (для улучшения следующая запись должна быть не более 1151 байта)

Эта программа печатает 51 в Assembly, 50 в Bash, 49 в Octave, 48 в Deadfish ~, 47 в Lily, 46 в Cubix, 45 в PicoLisp, 44 в alphuck, 43 в ретикулярной, 42 в злой, 41 в brainf *** , 40 в Minimal-2D, 39 в CoffeeScript, 38 в C, 37 в C ++, 36 в Лабиринте, 35 в INTERCAL, 34 в Rail, 33 в Incident, 32 в Whirl, 31 в модульном SNUSP, 30в пробелах, 29 в Trigger, 28 в Brain-Flak, 27 в Perl 6, 26 в 05AB1E, 25 в Pip, 24 в Thutu, 23 в Hexagony, 22 в Underload, 21 в Nim, 20 в Prelude, 19 в Reng, 18 в кардинале, 17 в Юлии, 16 в Пите, 15 в стоге сена, 14 в Turtlèd, 13 в Ruby, 12 в Fission, 11 в Befunge-98,10 в Befunge-93, 9 в Perl 5, 8 в Retina, 1 в Python 3.7 в Japt, 6 в SMBF, 5 в Python 2, 4 в> <>, 3 в Minkolang, 2 в V / Vim и

верификация

Большинство языков протестированы тестовым драйвером, показанным выше.

• Reng может быть проверен для вывода 19 здесь .

• Модульный SNUSP может быть протестирован для вывода 31 здесь .

• Кубик формы куба рассматривается здесь

• Инцидент проверяется путем поддержания баланса токенов, как описано в предыдущих ответах.

• Для Deadfish ~, можно проверить вывод 48 с этим . Обратите внимание, что Deadfish ~ принимает полиглот для питания на стандартном вводе, но выводит несколько>> запросов на стандартный вывод, что является неизбежным следствием запуска любой программы Deadfish ~.

• Сборка может быть проверена для вывода 51 здесь

Спасибо и поздравления

Когда 2 недели назад ответ @ ais523 на 50-в-1-k упал, по моей щеке скатилась слеза. Это было слишком красиво. И это было в Баше. Это было слишком прекрасно.

Я повернулся к своей жене и сказал: «Я думаю, что полиглот готов», чувствуя огромную гордость.

Она повернулась, чтобы посмотреть мне в глаза, на мгновение остановилась и сказала: «Хорошо. А теперь убери мусор ».

Однако она имела в виду, что она испытывала глубокую радость от меня и моих интернет-друзей. Спасибо и поздравляю всех.

Сборка Объяснение

В последующие дни мой ум продолжал возвращаться к тому, что сказал @ ais523 в чате polyglot незадолго до публикации Bash. Он указал, что некоторые разновидности сборки используют #строчные комментарии и/* блочные комментарии. Ну, этого было достаточно, чтобы я медленно сошел с ума в течение следующих 2 недель.

В полиглотах существует некая неявная задача включить законные языки. Я использую термин «законный» здесь очень свободно, но я думаю, что мы все можем понять, к чему я клоню. Одно дело включить Brainf ***, но другое - полностью включить такие, как Mathlab или R. Assembly, безусловно, относится к последней категории, и мой разум не мог ее отпустить. Но я ничего не знал о Ассамблее, так что это была тяжелая битва.

Поработав некоторое время над проблемой, ища способ сосуществования Assembly и C / C ++, я обнаружил, что это документация для ассемблера GNU:

Чтобы быть совместимыми с предыдущими ассемблерами, строки, начинающиеся с «#», имеют специальную интерпретацию. После «#» должно быть абсолютное выражение (см. «Выражения»): номер логической строки следующей строки. Затем допускается строка (см. Строки): если она присутствует, это новое логическое имя файла. Остальная часть строки, если таковая имеется, должна быть пробелом.

Я заметил, что это очень похоже на нашу директиву препроцессора для C / C ++ в строке 1 полиглота. После некоторых проб и ошибок я обнаружил, #1 “bla” 1//*что ввод блочного комментария возможен только для сборки.

И так был сделан полиглот.

Решив самые большие проблемы с блокировками, я решил поиграть в гольф на этом примере «Привет, мир!».

.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 Assembler (GAS или AS для краткости). У AS есть счастливая особенность, позволяющая использовать обе синтаксические ветви. Вам просто нужно объявить, что вы хотите использовать синтаксис Intel, что происходит в строке 1 кода сборки.

Сборка использует регистры, которые представляют собой небольшое количество ячеек памяти, буквально расположенных на ЦП для скорости доступа. Это не уникально для Assembly, кроме того факта, что их использование не отвлечено от забот разработчика.

Существуют разные виды регистров, которые используются для разных целей. Из Википедии:

• AX умножение / деление, загрузка строки и сохранение

• Счет CX для строковых операций и смен

• Адрес порта DX для IN и OUT

• Регистр индекса BX для MOVE

• SP указывает на вершину стека

• BP указывает на основание кадра стека

• SI указывает на источник в потоковых операциях

• DI указывает на пункт назначения в потоковых операциях

AX используется в строке _start функции здесь: mov rax, 1. Значение rin raxуказывает, что память является 64-битной. Если мы поменяем это на e, то это будет означать 32-битную память, что полностью подходит для 64-битного процессора. Мы просто не будем использовать верхнюю половину доступной памяти. Чтобы указать 16-битную память, вы просто используете ax, что хорошо для нас, потому что мы просто печатаем целые числа. Таким образом, мы можем сыграть несколько байтов, изменив все ссылки на регистры на 16-битные.

Хорошо, не все ссылки на регистры могут отбрасывать r. mov rsi, OFFSET FLAT:msg, Если вы знакомы с ассемблером, но не с этим утверждением, это потому, что это было полу-уникально для AS. По крайней мере, это то, что я почерпнул из этого , что помогло мне упростить заявление до справедливости lea rsi,m.

После этого я на опыте обнаружил, что могу _start:опровергнуть до цели _pи урезать .global _startцеликом только с вынесенным предупреждением. Во-вторых, msg:была уменьшена только до одной символьной переменной p:. Я выбрал pкак sстроковую переменную, так и начальную функцию, чтобы компенсировать некоторые ассемблеры, добавленные в пользу Alphuck.

Затем я вставил, ;чтобы разграничить инструкции, чтобы поместить их все в одну строку. Это в первую очередь для того, чтобы избежать чрезмерного трейлинга #//на каждой строке в пользу Туту. Кроме того, я заметил, что наш Ассемблер не чувствителен к регистру, поэтому я использовал верхний или нижний регистр различных символов, чтобы избежать дисбаланса Инцидента.

Этот гольф позволил нам:

.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 ++. Я также бросил (в этой строке и затем закрыл ее в строке Октива. Это было так, что Underload остановит sefaulting. Подобное лечение было проведено в строке 1, чтобы добавить *туда.

Этого было достаточно для удовлетворения байтовых требований этой задачи. Фактически я проверил это, выпустив эту версию полиглота. Но я хотел попытаться улучшить рейтинг VIP, если это возможно. И так как я выполнил все требования задачи, я чувствовал себя хорошо, сотрудничая, чтобы поиграть в код. Поэтому я остановился в чате на полиглоте, чтобы найти какую-нибудь помощь в игре в гольф.

Мы должны идти глубже

@ ais523 продемонстрировал технику передачи инструкций ассемблеру в виде машинного кода с этим оператором.

.text;.long 2298589328,898451655,12,178790,1018168591,84934449,12597 Машинный код - это серия числовых инструкций, выполняемых непосредственно процессором, которые могут быть представлены в десятичном, шестнадцатеричном или восьмеричном виде. Для наших целей десятичная дробь является самой короткой, поскольку ( 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заявлении. В шестнадцатеричной части объекта dump это 0c 00 00 00.

Это насколько мое понимание Ассамблеи получилось за 2 недели. Какой ускоренный курс!

инцидент

Инцидент был более трудным решением в более короткой сборочной реализации, потому что он весил жетоны полиглота намного тяжелее к вершине. Вот отчет об инциденте.

• ! в строке 2 детоксицируется !

• Первый EAна линии INTERCAL детоксицирует себя

• Последний пробел от второй до последней строки детонизирует маркер пробела.

• 85 на последней строке детоксицирует

• RВ #<R>"3"O.detokenizesR

• 65в <>{#65 }//жетонах65

• 16 на последней строке детоксицирует себя

• 89 на последней строке токенизирует себя

кардинальный

Я только что понял, что внес в кардинал изменение, которое я забыл задокументировать. Я потратил некоторое время на поиски путей сохранения байтов и решил изучить кардинал. Спустя немного времени с документацией я увидел эту строчку.

= копирует активное значение указателя в его неактивное значение.

Это был не трюк, использованный в полиглоте. Старое решение включало в себя следующие инструкции: `++ ~ * 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. Рубин (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символ в последней строке между jи dсогласно ответу Perl ais523 .

Попробуйте онлайн!

Это печатает 1 в Python 3, 2 в Vim, 3 в Minkolang, 4 в <> <, 5 в Python 2, 6 в SMBF, 7 в Japt, 8 в Retina, 9 в Perl, 10 в Befunge, 11 в Befunge- 98, 12 в делении и 13 в рубине.

Просто небольшая модификация существующего printутверждения, чтобы злоупотреблять тем, что 0верно в Ruby. Мне пришлось добавить несколько пробелов в другие операторы, чтобы сделать его правильно.

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

Примечание: ESCпосле oв третьей строке и после jв последней строке

Это печатает 1 в Python 3 , 2 в Vim, 3 в Minkolang, 4 в <> <, 5 в Python 2 , 6 в SMBF, 7 в Japt, 8 в Retina, 9 в Perl, 10 в Befunge, 11 в Befunge- 98 , 12 в Fission, 13 в Ruby, 14 в turtlèd и 15 в Haystack.

Попробуйте онлайн!

объяснение

#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; он был заменен на ␛ здесь для наглядности.

Это печатает 1 в Python 3 , 2 в Vim (проверено локально, но вот ссылка на очень похожий язык V), 3 в Minkolang , 4 в <> < , 5 в Python 2 , 6 в SMBF , 7 в Japt , 8 в Retina и 9 в Perl .

Давайте добавим еще несколько экзотерических языков, злоупотребляя арифметикой, которая по-разному работает на разных языках. ( Noneэто ложь в Python, но правда в Perl, и and/ orchain работает одинаково на обоих языках.)

Помимо 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 в Лабиринте, 35 в INTERCAL, 34 в Железной дороге, 33 в Инциденте, 32 в Вихре, 31 в Модульном SNUSP, 30 в Пустом пространстве, 29 в Триггере, 28 в Brain-Flak, 27 в Perl 6, 26 в 05AB1E 25 в Пипе, 24 в Туту, 23 в Гексагонии, 22 в Недогрузке, 21 в Ниме, 20 в Прелюдии, 19 в Ренге, 18 в Кардинале, 17 в Джулии, 16 в Пите, 15 в Хейстеке, 14 в Туртледе, 13 в Ruby, 12 в Fission, 11 в Befunge-98, 10 в Befunge-93, 9 в Perl 5, 8 в Retina, 7 в Japt, 6 в SMBF, 5 в Python 2, 4 в> <>, 3 в Минколанге 2 в V / Vim и 1 в Python 3.

верификация

Большинство языков протестировано тестовым драйвером, показанным выше. Вы можете проверить Reng здесь и Modular SNUSP здесь ; они выводят 19 и 31 соответственно. @ ais523 помог отладить и исправить код инцидента, который теперь работает.

Как работает Лабиринт

Лабиринт начинает с того, что немного смещает некоторые столбцы в источнике, но через несколько шагов указатель попадает туда, где Nнаходится во 2-й строке (первоначально, к тому времени, когда указатель туда попадает, его уже Nнет), двигаясь вправо с 0 в верхней части стека. Затем он просто нажимает и печатает 36 и заканчивается36!@

То, что я сделал, сломалось

Я знал, что хочу добавить Лабиринт, так как это один из немногих эсолангов, о которых я немного знаю. С его отладчиком я обнаружил, что, изменив 8 в последней строке на 0, Лабиринт не застрял в бесконечном цикле и, как ни странно, больше ничего не сломалось. Оттуда я просто добавил необработанные 36 и нужную мне команду вывода, и это удобно привело @к завершению вещей.

Затем дело дошло до того, что я сломал: Минколанг, Кардинал и Гексагония.

Он !заставлял Минько пропустить следующий символ, который нужно было завершить, поэтому я просто добавил дополнительный @. Все идет нормально.

Изменение длины второй строки заставило Кардинала пропустить вывод заявления. Попытка добавить лишние слова .в первую строку привела к тому, что Prelude сошел с ума (честно, понятия не имею, почему), поэтому я выбрал другой метод и просто отбросил его во второй строке. Это непреднамеренно породило указатель 3-го кардинала, поэтому я добавил к нему ?(необязательный выбор, только первое, что я нашел, что исправило и деление, и кардинала).

К счастью, шестиугольник был относительно простым исправлением, я просто добавил строку букв, чтобы указатель нашел код. Я полагал, что алфавит не должен был появиться раньше и не вызовет проблем с Инцидентом. Это также когда я понял, что не проверял Инцидент. Благодаря @ ai523 я обнаружил, что мне просто нужен дополнительный восклицательный знак, поэтому eстрока в алфавите была изменена на a !.

Результаты от универсального целочисленного принтера

Просто для того, чтобы пнуть и уйти от комментария @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. брейнф *** , 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 Score (универсальный целочисленный принтер): 0,01329

Наезжать

Эта программа печатает 41 в brainf ***, 40 в Minimal-2D, 39 в CoffeeScript, 38 в C, 37 в C ++, 36 в Лабиринте, 35 в INTERCAL, 34 в Rail, 33 в Incident, 32 в Whirl, 31 в Модульный SNUSP, 30 в пустом пространстве, 29 в Trigger, 28 в Brain-Flak, 27 в Perl 6, 26 в 05AB1E, 25 в Pip, 24 в Thutu, 23 в Hexagony, 22 в недогрузке,21 в Ниме, 20 в Прелюдии, 19 в Ренге, 18 в Кардинале, 17 в Юлии, 16 в Пите, 15 в Хейстеке, 14 в Туртледе, 13 в Рубине, 12 в Делении, 11 в Бефунге-98, 10 в Бефунге- 93, 9 в Perl 5, 8 в Retina, 7 в Japt, 6 в SMBF, 5 в Python 2, 4 в> <>, 3 в Minkolang, 2 в V / Vim и 1 в Python 3.

верификация

Большинство языков протестировано тестовым драйвером, показанным выше. Вы можете проверить Reng здесь и Modular SNUSP здесь ; они выдают соответственно 19 и 31 соответственно.

Наконец, тестовый драйвер был обновлен и теперь включает токенизатор. Весь код C хранится в качестве аргумента с точки зрения Bash Script. Я также изменил вывод для горизонтальной переноса с завершающим пробелом после каждого токена вместо вывода по вертикали. Это было только мое предпочтение, чтобы оно соответствовало выводу пробелов. Но любой может изменить это, если почувствует, что это слишком запутанно.

Я также выполнил настройку Test Driver, чтобы обрабатывать интервалы между столбцами для символа UFT8 Turtlèd в кратком изложении. Это смещение сводило меня с ума! «Исправление» довольно хакерское, так как оно просто ищет è и изменяет ширину столбца для этого случая, но выполняет свою работу.

объяснение

Прежде всего, я хочу сказать, каким был потрясающий фрагмент кода из универсального целочисленного принтера SnoringFrog @ Score из последнего поста. Я подсчитывал ответы, прежде чем публиковать сообщения некоторое время, и это вдохновило меня на то, чтобы они оставались маленькими. Я думаю, что мы можем победить ответ @ sp3000 в конце концов.

Таким образом, я начал работать над этим ответом, пытаясь найти лучшее, что мог, и я был довольно успешным. У меня даже был ответ на другом языке с общим числом байтов меньше, чем # 40. Но когда я попытался играть в Minimal-2D, мне пришлось изучать BF, чтобы я мог лучше работать с его производными, и в процессе я обнаружил рекорд @ Primo - Hello, World!, Я влюбился в элегантность.

Оказалось, что Minimal-2D не был достаточно эффективным, чтобы использовать технику инициализации ленты, используемую @Primo, но сейчас я придерживаюсь мнения, что в любом случае он будет слишком тяжелым. Мы только пытаемся напечатать целое число в конце концов. Но @Primo действительно отправил меня на путь обучения умножению в BF, который я привел в код Minimal-2D.

Затем, после всего этого, я перечитал комментарий @ SnoringFrog о том, как включить BF, и понял, что я не только могу это сделать, но и могу использовать большую часть кода Minimal-2D, который я использовал в ответе BF. Так что я закопался, чтобы ответить с BF, и вот мы здесь.

Еще одна вещь, прежде чем я углублюсь в детали. Было несколько изменений, которые я сделал по причинам, не связанным с гольфом. Во-первых, я переместил большую часть кода @SnoringFrog, добавленного чуть ниже 2D-языков, в верхние несколько строк. Для меня это долгосрочный стратегический шаг, направленный на предотвращение пересечения 2D-языков по центру полиглота с целью предотвращения возможных ошибок в будущем. Хит байта был низким для этого хода, поэтому я пошел на это.

Во-вторых, во время различных повторных факторов я узнал, что Begunges и Minkolang выводят завершающий пробел после числовых выводов и что это было причиной нулевых байтов, которые мы видели в тестовом драйвере для этих языков. Я исправил их, выведя значение стека в виде кода ascii (который не включал функцию конечного пробела) вместо значения напрямую. Для этого изменения также был небольшой удар по байту, но теперь вывод Test Driver стал настолько равномерным. Как я мог не?

SM / BF

Давайте быстро пройдемся по основам. Это единственные допустимые команды для 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 для получения разных результатов зависит от перемещения указателя памяти слева от начала координат. В BF-интерпретаторе Tio указатель памяти способен перемещаться влево от начала координат и найдет 0 вместо кодов ascii Полиглота, которые видит SMBF. Вот пример, который может быть запущен как в SMBF, так и в BF, чтобы проиллюстрировать разницу.

В начале полиглота, Befunges требуют, чтобы >второй ряд работал до завершения, а Perl6 требует, чтобы каждому >предшествовал a <. Таким образом, SM / BF начинают с того, <>что оставляют указатель памяти в начале координат, затем нажимают a, [который перебрасывает некоторые оскорбительные символы для обоих языков в ]шестую строку.

Затем мы увеличиваем ячейку памяти источника для обоих языков и перемещаем указатель памяти влево с помощью +<. (Для разговорного соглашения мы будем называть ячейку памяти источника ячейкой 0, ячейки справа от источника 1, 2, ... И ячейки слева -1, -2,…). Ячейка -1 содержит код Аски последнего символа в полиглоте в SMBF и 0 в BF, поэтому, когда [встречается следующее , только BF переходит к следующему] пока SMBF переходит в код.

Когда SMBF проходит, [.>-]он печатает 6, найденный в конце полиглота, а затем перемещает указатель памяти обратно в ячейку 0, устанавливая его значение обратно в ноль, чтобы выйти из ]. Чтобы рассмотреть, ленты в этой пинте: отрицательные ячейки SMBF содержат полиглот, и это 0, и положительные ячейки содержат ноль. Отрицательные и положительные ячейки BF содержат ноль, а его исходная ячейка - 1.

Затем >перемещаем SMBF в ячейку 1, а BF обратно в ячейку 0, позволяя BF ввести свой блок частного кода: [<+++++[>++++++++++<-][<<<]>+.---.>](я удалил не-BF символы из этого). Здесь мы возвращаемся к ячейке -1 и инициализируем нашу переменную управления цикла (ячейка -1) значением 5. Затем мы входим в цикл, где мы добавляем 10 к ячейке 0 и уменьшаем ячейку -1 пять раз перед выходом из цикла, где мы будем указывать на ячейку -1 со значением 0.

Далее мы сталкиваемся [<<<], указывая на ноль, поэтому BF не проходит через это. Цель здесь - сбалансировать число >с предыдущими <, чтобы Perl6 не ошибался.

В этот момент ячейка 0 имеет значение 51. Значение ascii для 4 равно 52, поэтому мы перемещаем указатель в ячейку 0, добавляем 1, а затем печатаем значение. И, наконец, мы уменьшаем ячейку 0 обратно до символа ascii 1 и печатаем снова перед установкой указателя памяти на ячейку 1 (значение 0) для выхода после ].

SMBF и BF оба попадают последними [в строку 8 рядом, в то время как оба покоятся на значении 0. Таким образом, оба переходят мимо оставшегося минимально-двумерного кода, пока ]не встретятся в строке 11. Но это недолговечно, потому что строка 12 начинается с другого, [который переносит оба языка почти до конца полиглота, где не встречаются дальнейшие инструкции.

Refactors

Минимально-2D

Перезапись в Minimal-2D была в основном для сохранения некоторых байтов способом, аналогичным трюку умножения BF. Минимально-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 и вводим цикл. В цикле мы добавляем 3 к ячейке 1, уменьшаем ячейку 0, затем проверяем, равно ли значение ячейки 0 нулю. Если нет, мы добавляем еще 8 к ячейке 1, затем уменьшаем и проверяем снова. Результатом этого цикла является значение ячейки 1, равное 51 в конце цикла (6 * 8 + 3).

Мы выходим из цикла, прыгая U, перемещая указатель памяти в ячейку 1 и спускаясь затем вправо в строке 11 полиглота. И, наконец, мы увеличиваем до значения ascii для 4, затем уменьшаем до значения ascii для 0 перед тем, как убежать вправо, чтобы завершить программу.

Сетчатка

У Retina было много требований, с которыми было трудно работать для всех производных BF. Он не любит последовательных +или несовпадающих ()или []. Но на самом деле это просто требования для каждой другой строки, поэтому большая часть работы для BF, SMBF и Minimal-2D была сосредоточена на том, чтобы поместить большую часть кода в четные строки.

Один байт, переданный только Retina, находится |в конце строки 11. Цитируя @ ais523 «большинство регулярных выражений заканчивается на | будет соответствовать чему угодно ». Без этого Retina возвращает 0. Почему это не исправить, я не знаю. Мне не пришлось слишком много копаться в сетчатке, вероятно, потому что я избегал длинной очереди. Но, как и в случае с Prelude, я обнаружил, что мне не нужно понимать это так сильно, как мне нужно понимать, как отлаживать его, что в данном случае в основном состояло из удаления строк (кратных 2), пока я не нашел строку это заставляет это сломаться. Я догадался об этом исправлении, основываясь на комментарии @ ais523, и был вознагражден. Я просто слишком крут для школы, я думаю.

кардинальный

Мне так понравилось расположение @ SnoringFrog Minimal-2D относительно кода Кардинала. Это хорошее место, учитывая, что Кардинал не расстраивает Retina, и, кажется, оно позволяет немного переплетаться с Minimal-2D. Поэтому, когда я решил пересадить Minimal-2D на 2D, я взял с собой Кардинала для поездки. Было несколько косметических изменений в Кардинале. Во-первых, я бросил >в начале своего утверждения #p x%>~~~+ +~*ttt*.xдля Minimal-2D, чтобы изменить указатели памяти в его цикле. Во-вторых, я сдвинул все на один символ вправо, чтобы дать Minimal-2D пространство для изящного выхода из цикла. В pэтом укусе для этого заполнения символов.

Befunge / 98

На самом деле Befunges были тем местом, где я начал пытаться играть в полиглот, так как рефактор C ++ изменил весь другой двумерный код языка, кроме этого. Пытаясь понять, что в этом коде происходит WTF, я нашел это в документации по Begunge:

Команда .извлекает значение из стека и выводит его в виде десятичного целого числа, за которым следует пробел , похожий на Forth. ,отобразит значение, интерпретирует его как значение ASCII символа и выведет этот символ ( без пробела ).

Святой молей! Мы можем очистить нулевые байты на выходе. После этого все было лишь вопросом выяснения того, как вводить большие значения аски, и разделения кода. Befunge-98 был прыжок код , ;говоря его пропустить через [77*,68*,@ин ;[77*,68*,@;'1,'1,q, который дал нам сегрегацию.

В Befunge-98 также была команда ( ') для получения кода ascii следующего символа. Итак, '1,берет код asci-кода для символа 1, помещает его в стек и затем печатает символ ascii для верхнего значения в стеке с помощью ,. Просто нужно сделать это дважды, чтобы напечатать 11 и бросить, qчтобы выйти изящно.

Собственно, это немного менее удобно, но только справедливо. Здесь мы должны выполнить расчет, чтобы поместить нужный код в стек. К счастью, наши коды были легко умножены на 7 * 7 и 6 * 8 перед той же командой вывода ,. Затем мы вышли из Befunge, @пока код его старшего брата не испортил вывод.

Minkolang

После того, как я нашел исправление для пробелов в Befunge, я довольно увлекся идеей найти исправление Minkolang, и в документации Minkolang сказано, что выходная команда, которая использовалась до этого момента, работала так же, как и интерпретатор Befunge. Oслучилось, что была задокументирована как другая выходная команда, которая не описывалась как разделение этого Begunge-ness, поэтому я просто сделал снимок в темноте и попытался вывести строку "3". Безупречная Победа.

> <>

Одной из первых вещей, на которые я обратил внимание при перемещении кода Minimal-2D, была проверка того, что я могу перемещаться> <> вместе с ним. Если я собирался иметь дело с трансверсализмом 2D-полиглота, я собирался иметь дело со всеми нарушениями. По сути, мне повезло, что я нашел путь ;n4 к концу строки 1 и переместился \Dдальше назад в строке 1. Кстати, я не знал, что> <> можно было бы направить вниз до ответа 40, поскольку он так хорошо сдерживался. , Я хотел бы думать, что это может быть использовано позже, чтобы отличаться от> <> от другого подобного языка.

Perl6

Я говорил о некоторых проблемах <>балансировки в Perl6 в другом месте этого ответа, поэтому я не собираюсь останавливаться на этом снова. Но я хочу отметить, что перешел #>27.say#со второй на последнюю строчку. Это не имеет функциональной цели в этом ответе. Я действительно сделал этот шаг, чтобы удовлетворить другой ответ, который я не использовал в этом раунде. Я решил просто оставить его, так как планирую опубликовать этот ответ при моей следующей возможности, и я не хотел беспокоиться об отмене и повторном выполнении этого.

Исправление ошибок

05as1e

05as1e определенно не понравился новый код Begunge так же сильно, как старая версия. Я предполагаю, что это ,s, так как это единственный революционный персонаж. В любом случае мне пришлось переместиться "еще дальше во второй строке, чтобы скрыть наступательные команды, и я знал, что они "должны были идти до пути к коду Befunge, так как это "было да-оп на обоих языках. (Я могу просто придумать такие термины, как да-да, верно?) <Двухмерность строки 2 довольно жесткая, но я смог сместить предшествующий пути кода Бегунге с ". <Однако было требование Perl6. (У него должен быть <предшествующий всем >s.) Я был в состоянии бросить <в первой строке в месте, предугаданном инстинктом и предвидением, решающим 05ab1e и разногласия Perl6.

завихрение

Изменения в Befunge в строке 2 добавили дополнительный 1в полиглот до линии Incident / Whirl. Этот дополнительный 1побудил Вихря начать указывать на неправильные инструкции на колесе. Самой первой 1в директиве препроцессора C / C ++ была только ссылка на номер строки в коде, и это может быть просто любой другой номер строки, поэтому я произвольно изменил его, 4чтобы удовлетворить Whirl.

инцидент

На этом этапе строка детокенизации в конце полиглота хорошо известна, поэтому я не буду вдаваться в подробности. Я удалил из строки все, что мог, и добавил новые токены, которые требовались. Есть 2 символа детоксикации, которых нет в этой строке, хотя я должен отметить. Во- первых, второй Rв #R+.----.R >]|необходимости здесь , потому что это Fusion отправной точкой, и это было безопаснее на этой линии , потому что уже была точка заголовка Fusion отправным в том же направлении. Во- вторых, xв #= xэто удалить маркер , участвующих в ␉␊#шаблоне, который стал более распространенным.

другие

У Hexagony, Whitespace и Prelude были обычные незначительные изменения, но ничего особенного не стоило говорить.

Последние мысли

Это все, что у меня есть для этого ответа. Для тех, кто ищет отправную точку в следующем ответе, я бы предложил зло. Это кажется работоспособным, хотя я не смотрел на это слишком внимательно, но я подозреваю, что это не будет слишком сложно интегрировать. Я знаю, что у него есть команда перехода, которая должна помочь пропустить большую часть полиглота. Удачи.

183. Загрузочный образ Intel 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-файл, потому что он ограничивает размер полиглота до 60 КБ, чего я хочу избежать. Загрузочный образ оказалось даже проще, чем COM, потому что ZEMU по умолчанию загружает загрузочный сектор из 6-го сектора (основанный на 1, 128-байтовые логические сектора), поэтому запуск полиглота выполнять не нужно. Загрузочный код должен быть со смещением 0x280 ((6-1) * 128) в полиглоте.

Я использую эмулятор ZEMU, который связан с этой страницей . Чтобы запустить полиглот в ZEMU:

• Диски> A: выбрать файл полиглота
• Функции> Набор инструкций I8080
• Нажмите кнопку загрузки

Функция, которая печатает один символ в console ( cns$ot), была скопирована из BIOS22Dv221.ASM из дистрибутива ZEMU. Я сделал два изменения: символ не маскируется для 7-битного ASCII, потому что мы контролируем параметры, и jrz cns$otзаменяется на jz cns$otпотому, что jrz(относительный переход, если ноль) - это инструкция Zilog Z80, отсутствующая в Intel 8080.

Начальная программа ( синтаксис Intel , ассемблер связан здесь ):

    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

Эта программа содержит символы, которые нельзя использовать непосредственно в полиглоте. Большинство контрольных символов ASCII (код <0x20) запрещены в Simula, символы не-ASCII (код> = 0x80) не могут отображаться отдельно, поскольку файл должен быть действительным UTF-8. Таким образом, вышеупомянутая программа генерируется другой программой, которая является действующей UTF-8.

Следующая программа генерирует необходимый код и переходит к нему. ld (hl),aнельзя использовать из-за Grass ( 'w'==0x77). sub h(0x94) и xor a(0xAF) являются байтами продолжения UTF-8, они должны начинаться с ведущего байта UTF-8. Инструкция ret nc(= 0xD0, возврат, если не перенос) используется как ведущий байт UTF-8. Чтобы ничего не делать, ему предшествует scfинструкция (установить флаг переноса). Также избегается ','(0x2C) и '.'(0x2E) для DOBELA. org 0100hдиректива не используется, потому что используемый ассемблер не понимает ее (org установлен в GUI). Эта программа в любом случае не зависит от позиции. Мне больше нравятся мнемоники 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). Тест абстракции в тестовом драйвере проверяет это.

Рефакторинг

ракушки

Перемещены снаряды обратно на самую длинную линию. Мне больше нравится этот макет, потому что парены не совпадают с другими языками. Перед раковинами перемещены мавританы и флаконы, чтобы они не ломались при смене снарядов. Самая длинная строка теперь имеет такой макет:

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

Новый код снарядов:

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 проверяет код во всех оболочках.

Дополнительные (((((перед снарядами исправляют недогрузку и сетчатку. Еще одна пара паренов добавлена, чтобы скрыться 58от прелюдии (закрыта #)после 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.

Деление и кардинал

Деление было перемещено в LNUSP: R"12"R _*. Второй указатель используется для прекращения деления как можно скорее - на 3-м шаге см. Ответ 54 для получения дополнительной информации.

Кардинал был перемещен в LNUSP: @ %"18". Как и в Fission, второй указатель используется, чтобы завершить кардинал как можно скорее - на 3-м шаге.

MarioLANG

Используйте ####...вместо ====...как платформу:

Минимально-2D

Полиглот с MarioLANG:

Wierd & 1L_a

Wierd: используйте пробел в строке 10 столбца 79 для отражения IP.
1L_a, Wierd: пробел в строке 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 если текущая операция неактивного звонка не выполняется, просто выполните текущую операцию активного звонка без каких-либо побочных эффектов
• 11..11 поверните n шагов
• 011..11 переключить направление и повернуть на n шагов

0000выполняет текущую инструкцию активного вызова, но также выполняет текущую инструкцию неактивного вызова в качестве побочного эффекта. Если текущая инструкция по неактивному звонку безвредна, мы можем просто сосредоточиться на операциях с активным звонком, не думая о том, что происходит с неактивным звонком. Это особенно полезно с этой программой, потому что она имеет четкое разделение: сначала число 32 создается с использованием только математического кольца, а затем мы переключаемся на ops ring и выполняем там 2 инструкции (печать и выход).

Сначала я хотел, чтобы текущая операция на ops ring была noop, когда основной код начинает выполняться. У этого есть 2 преимущества: 1) основной код Whirl может быть выполнен автономно и 2) мы можем полностью забыть об ops ring при создании числа 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

Как правильно поддерживать Whirl при изменении чего-либо до линии Incident / Whirl:

• убедитесь, что 0перед основным кодом Whirl есть четное число s
• убедитесь, что нет двух последовательных 0с
• добавить / удалить достаточно 1s, пока Whirl не сработает снова; добавление n 1s эквивалентно удалению 12-n 1s и наоборот

Я неосознанно нарушил первое правило, когда добавил Ropy. При наличии нечетного числа 0s основной код начинает выполняться с неправильным направлением ops ring, что нарушает инструкцию выхода. Так что теперь есть 0в строке 3, которая компенсирует 0в строке 1.

другие

CoffeeScript : console.log a&&39||180( отсюда )

INTERCAL : перемещен в строку 37
Brainfuck , Agony : перемещен в другие производные мозга Brainfuck в строке 10

xEec : перемещено в 1L_a ( h#115# o#)

CSL : перемещено в строку 80
Trefunge : перемещено в строку 120
Gaot ++ , камни : размещены на отдельных строках

16. Пит (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

Примечание: после третьей в и после последней в есть ESCbyte ( 0x1B) .oj

Это был довольно забавный опыт. Japt и Pyth оба являются языками гольфа, но Japt - это инфикс, а Pyth - префикс, а Pyth автоматически запрашивает ввод и завершается неудачей, если отсутствуют аргументы.

Перед ответом на Haystack у меня было почти работающее решение #, которое получает код символа в Japt и loop-till-error в Pyth. Pyth оказывается очень полезным в полиглотах, так как обычный комментарий char# существу работает как глушитель ошибок.

Когда я вернулся домой, мне удалось найти этот кусок кода, который работал в обоих с использованием // , и работал как комментарий в Japt и двух подразделениях в Pyth. Тогда это было просто вопросом правильной маршрутизации Befunges.

Это вряд ли будет оптимальным, но пока этого достаточно. Я попытался протестировать их все, но я был бы очень признателен, если бы кто-нибудь дважды проверил, совпадают ли результаты.

Отпечатки 1 в Python 3 , 2 в V , 3 в Minkolang , 4 в> <> , 5 в Python 2 , 6 в самоизменяющемся Brainfuck , 7 в Japt , 8 в Retina , 9 в Perl , 10 в Befunge (-93 ) , 11 в Befunge-98 , 12 в Fission , 13 в Ruby , 14 в Turtléd , 15 в Haystack , и

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"

Первый цикл завершается при попытке оценить, ;какое выражение не является допустимым. Тогда Пиф просто печатает 16.