Це виклик ланцюжка відповідей, в якому кожна відповідь спирається на попередню відповідь. Я рекомендую сортувати нитку за "найстарішим", щоб бути впевненим у тому, в якому порядку створюються пости.

Примітка . Це стало досить тривалим викликом, і опублікувати нові відповіді досить складно. Таким чином, зараз для цього виклику доступна кімната для чатів , якщо ви хочете отримати поради щодо певної частини потенційної відповіді, маєте ідеї для мов, які можна додати тощо. Не соромтеся зайти, якщо у вас є що запитати чи сказати!

Задача

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

Додаткові правила

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

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

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

• Допускається використання різних версій однієї мови (хоча, очевидно, їм доведеться друкувати різні номери, тому вам потрібно встановити перевірку версій у поліглот). Однак ви не можете використовувати мовну функцію, яка повертає номер версії мови. Повторення точно тієї ж мови, очевидно, неможливо (оскільки програмі доведеться детерміновано надрукувати одне з двох різних чисел).
• Трюки, як надмірне зловживання коментуваннями, незважаючи на те, що вони заборонені в деяких змаганнях з поліглоту, тут просто чудові.
• Ви не повинні використовувати попередні відповіді як посібник для написання своєї власної (ви можете переписати всю програму, якщо хочете, якщо вона відповідає специфікації); однак, базувати свою відповідь переважно на попередній відповіді дозволено і, мабуть, найпростіший спосіб прийняти рішення.
• Ви не можете подавати дві відповіді поспіль. Нехай хтось інший розмістить посеред. Це правило діє до тих пір, поки не буде виконано умову перемоги.
• Оскільки цей виклик вимагає від інших конкурентів публікувати на тих самих мовах, якими ви є, ви можете використовувати лише мови з вільною реалізацією (як би це був конкурс поліцейських і грабіжників ).
• У випадку, коли мова має більше одного перекладача, ви можете вибрати будь-якого перекладача для будь-якої мови, якщо всі програми, які призначені для успішної роботи на цій мові, роблять це в цьому інтерпретаторі. (Іншими словами, якщо програма працює в декількох перекладачах, майбутні повідомлення можуть вибрати будь-якого з цих перекладачів, а не посаду, що "замикається" на певний вибір перекладача для мови.)
• Зараз у цьому виклику використовуються нові правила PPCG щодо вибору мови : ви можете використовувати мову чи перекладача мови, навіть якщо це новіше питання. Однак ви не можете використовувати мову / перекладача, яка є новою, ніж питання, якщо а) мова була розроблена з метою поліглотування або б) мова надихнула цим питанням. (Отже, нещодавно розроблені мови практичного програмування майже напевно будуть нормальними, як і не пов'язані між собою езоланги, але такі речі, як 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 у Minkolang, 4 у> <>, 5 у Python 2, 6 у SMBF, 7 у Japt, 8 у Retina, 9 у Perl, 10 у Befunge-93, 11 у Befunge -98, 12 у Фіссі, 13 у Рубі, 14 у Туртледі, 15 у сіна, 16 у Піті та 17 у Джулії .

Підказки:

• Початок четвертого рядка - Python 2/3, Perl, Ruby. Кінець - Джулія, завдяки #=багатолінійним коментарям (зауважте, що у Юлії немає and/or).
• V - <ESC>gg99ddi2<ESC>це, безумовно, пограбує, але V дратує тестування на " Спробуйте в Інтернеті"! оскільки перекладач досить повільний.
• Міколанг та Стог сходять вниз першими v. Befunge-93 і -98 не роблять, і залежать від а b.
• Retina підраховує кількість пробілів і 1s у четвертому рядку, а 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 у Гексагоні , 22 у Андерлаузі, 21 у Німі, 20 у Прелюдії, 19 у Рензі ( тут можна перевірити ), 18 у Кардинала, 17 у Джулії, 16 у Піті, 15 у Сіннику, 14 у Туртледі, 13 у Рубі, 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.

Щоб дістатися до незв’язаних мов, натисніть change languageкнопку у верхньому правому куті посилання на шестикутник.

Шестикутник у такому форматі не читається (ВСЕ). Нам потрібно подивитися в шестикутній формі.
Зауважте, що два символи 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

Для незнайомих з Гексагоні є 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!

Що слід зазначити:

• Перед виконанням шестикутника скидаються всі s і `s, тому будь-які зміни на них не вплинуть на Hexagony
• Мені потрібно було прошивати код, щоб його інтерпретували як шестикутник 9 довжини, а не восьмий - будьте обережні при гольфі нижче 169 або вище 217 відповідних символів
• Через це, ~~~і 2 0s в кінці можна змінити без шкоди для коду
• =""Просто переміщує мене від попереднього , так що новий ME може бути змінений. Їх можна замінити іншими символами, які роблять те ж саме, не завдаючи шкоди програмі ( 'наприклад, шестикутникам )
• Це технічно не відповідає специфікаціям Befunge 93, оскільки це обмежує поле обмеження коду до 80 на 25 символів. Однак більшість перекладачів ігнорують цю специфіку (як TIO), тому я особисто не думаю, що це така велика угода. Якщо ви це зробите, не соромтесь залишити коментар. (Якщо достатньо дійсно хочу, щоб я його змінив, тоді я спробую)
• Сподіваюся, зараз не надто важко.

50. баш, 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

Хочете дізнатися більше? Спробуйте поліготик !

Спробуйте їх онлайн!

Як завжди, я замінив буквальні вкладки на ␉і буквальні символи ESC на ␛, через обмеження обміну стеками. Ви можете отримати легко скопійовану версію програми з поля "введення" посилання TIO вище.

Спуститися

Ця програма друкує 50 башів , 49 в Октаві, 48 у Мертвих риб ~, 47 у Лілі, 46 у Кубікса, 45 у ПікоЛісп, 44 у альфука, 43 у ретикулярних, 42 у злих, 41 у мозкових ***, 40 у мінімальних -2D, 39 в CoffeeScript, 38 в C, 37 в C ++, 36 в Лабіринті, 35 в INTERCAL, 34 в Rail, 33 в інциденті, 32 в вихорі, 31 в модульному SNUSP,30 у Whitespace, 29 у Trigger, 28 у Brain-Flak, 27 у Perl 6, 26 у 05AB1E, 25 у Pip, 24 у Thutu, 23 у шестикутнику, 22 у Underload, 21 у Nim, 20 у Prelude, 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 було протестовано онлайн тут ;

• Reng був протестований на сайті тут .

Пояснення

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

Виявляється, відповідь століттями дивилася мені в обличчя. Якщо натиснути посилання TIO вище, воно відкриє драйвер для тестування поліглоту, написаний в bash. Так що весь цей час у мене була вкладка з надписом "Bash - TIO Nexus". Ви могли б подумати, що це буде натяком, але, мабуть, я це пропустив. Як бонус, bash також є мовою сценаріїв, тому термін "лінійки мови сценаріїв" все ще підходить.

Програма bash починається там же, що й інші мови сценаріїв. Однак існує досить простий спосіб розділити їх від них; в рядках, що цитуються в одній цитаті, \є символом втечі в більшості мов, але не в bash. Таким чином, ми можемо приховати bash-код з інших мов через '\'…';, що є виродженим твердженням (без ефекту) в Perl, Python та Ruby, але виконаним у bash. echo 50;exitє досить простим способом завершити програму bash. Ну, майже.

Найбільшою проблемою тут є те, що bash після запуску exitпродовжить розбір до кінця поточного рядка (навіть якщо він не виконує відповідний код), тому нам потрібно переконатися, що немає синтаксичних помилок на решті лінія. У нас 'щойно після exit;цього не (і не може бути) відразу відповідність. Пізніше в рядку '…'використовується для приховування деякого коду Brain-Flak від мов сценаріїв, але це може сховати його від bash. Як результат, нам потрібно змінити тип рядкового літералу, який ми використовуємо, щоб приховати код, переходячи від одноцитуваних до рядків з подвійним цитуванням. or"'"робить фокус, не порушуючи Perl, Python чи Ruby (оскільки лівий аргумент є правдивим у кожному випадку).

Зараз у нас є неперевершена подвійна цитата, яка поширюється на майбутній рядок. Закрити його було досить важко, не порушуючи принаймні однієї іншої мови; що ми насправді робимо, це змінити спосіб приховування коду від bash від подвійної цитати до неперевершеної єдиної цитати в коментарі Python / Ruby на наступному рядку, і, нарешті, закрити єдину цитату в кінці рядка після цього.

Pyth і 05AB1E

Блукання з подвійними лапками також заважає мовам, які використовували рядки з подвійним цитуванням, щоб приховати код, Pyth та 05AB1E. Основна хитрість, яку ми тут використовуємо, - це забезпечити, щоб кожна подвійна цитата, яку ми додали, незабаром одержала ще одну подвійну цитату, щоб викрити якомога менше коду. (Це пояснює додаткову подвійну __DATA__лапочку на рядку, яка не потрібна для удару.) Pyth використовує \як символ втечі; головний підсумок цього полягає в тому, що це обмежило сферу, яку я мав возитися зі струнами на мовах сценаріїв, змусивши мене використовувати досить згорнутий метод вище (так як я не міг легко використати різницю в \поведінці між bash і всім інше). У 05AB1E 'виступає як символ втечі назовніструнних, і втекти його від ведучих "не зробило б. Отже, мені потрібно було розмістити непотрібний символ прокладки (дефолт за моїм звичним x; це полегшує читання!) Всередині "'"конструкцій, які використовуються для зміни між стилями цитування башів.

Прелюдія

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

Гірше, що перший перший рядок (який я дійсно не хотів переписувати) ставить щось жорстке обмеження на те, де можуть з’являтися круглі дужки. Він починається з ненульової цифри (насправді дві!), І незабаром слідує відкриваюча дужка. Це цикл у Prelude, і циклі на початку керуючого потоку в Prelude викликають ряд різних проблем (здебільшого тому, що вони викликають більше коду, ніж менше). Тому мені дуже потрібно було відкрити цикл 0-ітерацій в іншому рядку, щоб пропустити цей код. mainЛінія для програми C дуже підходить, але ми повинні бути дуже обережні з тим, де відповідність закриває дужка; занадто вправо і незрівняна дужка на#R+рядок спричинить неприємності, занадто далеко зліва, і він не коментує достатньо коду. (Майте на увазі, що дужки, що відкриваються в одному рядку, можуть відповідати дужкам, що закриваються, або іншим рядком.)

Як тільки це буде зроблено, у нас просто достатньо місця, щоб вписатися в дужки, що відкриваються, на лінії Incident, і ми нарешті благополучно пройшли повз перших кількох символів програми. Однак різниця в розміщенні дужок закінчується тим, що частина коду Incident / Whirl насправді працює у Prelude, пошкоджуючи стек. Замість того, щоб намагатися запобігти цьому, я перемістив кілька нулів Whirl далі вправо, дозволяючи їм знову надати нам працюючу програму Prelude.

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

Інцидент

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

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

Видалення копії ␠␠шляхом її розбиття не здається можливим. Видалити його через накладення можливо, це можливо ( ␠=є багатообіцяючим потенційним перекриттям), але майже напевно менш багатослівним є лише додавання четвертої копії, що я тут зробив.

Тим часом ми можемо використовувати інший трюк для ;'. Розбити його - це не те, що я хотів спробувати, враховуючи, що він використовується в досить чутливих до інтервалу ситуаціях. Однак справа не в тому, що перед початком програми (незважаючи на те, що вона з’являється на першому рядку), тому правдоподібно, що ми могли перестрибнути її (тим самим спричиняючи, що це не впливає на контрольний потік), а не потрібно, щоб вона не існувала. Я шукав підходящий маркер, який би використовував для стрибка, який би не накрутив жодну з інших мов. /vз'являється трохи раніше на першому рядку, і нічого не порушує, і, отже, це я використовував.

50 мов кодом 1 кіб

@MistahFiggins підкреслив, що моє подання на 1025 байт було б набагато акуратніше, якби це було 1024 байти (особливо, оскільки п'ятдесята мова сама по собі є віхою). Це вимагало пошуку байта економії десь. У цьому випадку я зберег три байти в Deadfish ~, ціною двох додаткових байтів, які використовуються для правильного складання токенів Incident, і таким чином збивши програму точно до 1024 байтів.

Раніше формула, що використовувався код «Мертва риба», була (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 у вихорі, 31 в Модульному SNUSP, 30 в Whitespace, 29 в Триггері, 28 в Мозговому Флаку, 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 тут і модульний SNUSP тут ; вони виводять відповідно 19 та 31 відповідно.

Я додав ще один формат до виходу тестового драйвера, який уникає подвійних лапок, а також робить заміну рядків каналу. Це так, що я можу подати однорядковий рядок до програми ac (gcc), яку я обернув навколо функції, створеної тут @feersum . Сподіваємось, інші можуть скористатися цим, як є.

Ось програма Incken token . В ідеалі я хотів би окреслити лексеми, оскільки їх важко читати, вказати маркер "центру" та включити його до драйвера тесту. Але я не знаю, як зробити щось, окрім як зробити різні програми друком послідовних цілих чисел, тому це, наскільки я отримав.

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

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

Пояснення

Як працює код C ++.

Я думаю, що більшість людей досить добре знайомі з C ++, тому я не буду надто детально описуватись. Коментарі до блоку надходять у формі /* comment */. Коментарі до рядків надходять у формі //comment. Фактичний код, який використовується С ++ для отримання відповіді, є int main() {std::cout<<37;}. І на цю бібліотеку посилається бібліотека, на яку використовується інтерфейс STDOUT #include<iostream>.

/ * Зловживання коментарями * /

Для мене історія C ++ повертається до моєї відповіді Brain-Flak.

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

Це не факт чи обмеження в будь-якому випадку, а особиста ментальна структура, яка керувалась моїми наступними кількома відповідями.

Звідси я міркував, що якби це став найбільшим у світі поліглотом, який, я вважаю, це є зараз, було б найкраще, якби він міг скористатися зловживаннями коментарями з обох сімей коментарів. Тому я вирішив знайти спосіб включення /*мови коментарів і підштовхнув до сім’ї С завдяки більшості особистого знайомства.

C ++ початковий тест

Моя початкова думка для цього полягала в тому, щоб використовувати C # здебільшого через моє знайомство, і першим перешкодою для C # було переведення поліглота в стан, коли він міг прийняти рядок, який не починався з того, #щоб інакше не трактуватись як код сценарійними мовами . Відповідь Rail разом із кількома байтовими роздутими відповідями, які ведуть до нього, вирішили цю частину.

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

C ++ має декілька директив препроцесора, які починаються з усіх #, що дають безліч варіантів переходу 2D мов. Але виявилося, що всі вони несумісні принаймні з однією мовою, і перебуваючи у відкритому кодовому просторі C ++, у мене були обмежені обхідні шляхи. З розчарування та відчаю я натрапив на те, що C ++ просто прийме лише один #блок перед блоком коментарів. Гаразд, що б там не було, це можливо. Тож я рухався вперед з припущенням, який #/*міг би працювати як перші три символи в поліглоті.

Другий фрагмент базової перевірки полягав у тому, щоб фактична заява на друк була щасливою для інших кодів. Я знав з відповіді Брейн-Флака, що Джапту не сподобалося не втечене, {і це було потрібно, щоб С ++ сказав, int main() {std::cout<<37;}а С ++ не дозволить уникнути символу втечі Япта посеред його коду. Цього разу мені пощастило виявити, що якби я випав з прямої рядки Джапта саме для цього твердження, Япт все одно із задоволенням дасть би такий же результат.

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

Отже, з основними проблемами C ++, які виявились теоретично вирішими, я розпочав важкий процес вирішення всіх введених нами помилок.

2D краєвид

Найважчою частиною цієї відповіді було, безумовно, переналаштування двох перших ліній поліглоту. І найбільш важливою проблемою була проблема *. Завантаження не буде дозволено до *початку (. Він вважає це математичною операцією на порожньому стеку, що, на її думку, є помилкою. Отже, поліглот вимагав (до, /*але C ++ не міг цього дозволити. Тож рішенням було для нас прокоментувати рядок C ++ //до першого рядка, щоб приховати a, (а потім почати другий рядок з а #/*.

Далі, Befunge дуже не сподобалася ідея /без чогось розділити, але після вивчення існуючої відповіді Бегунґе 16/"<"6/b.q@я натрапив на ідею числа і струна розтрощена разом перед //. Це спрацювало, і я поняття не маю, чому з C ++ це нормально, але він приймає # 1"16" 2його як вступне слово. Я не збираюся ставити під сумнів це, але я знаю, що для його роботи потрібні пробіли.

Рядок перший

Джапт виявився досить чутливим до простору і не дуже хотів входити в його рядок, що базується на зворотному боці, на верхній рядку, тож він і пітпік Піпа перейшли на другий рядок, змусивши багато лінгвістичної гімнастики на першій лінії.

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

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

Після вирішення цих питань наступним етапом було маршрутизація 2D мов. Раніше початковий vігнорувався Befunges через попередній #, але послав Haystack і Minkolang вниз. Тепер, початковий простір намагається надіслати Мінколанг уздовж 3-го виміру, який його документація називає часовим виміром.

Швидко відмовляємось від третього виміру Міноланга: для мене це щось неправильне, щоб називати це часовим виміром, воно мені справді здається більш просторовим, ніж часовим. Я дійсно не розумію , поки я не знайшов цю посилання , яка ілюструє концепцію, і це більше схоже на декількох шарів 3D шахівниці. Я переконаний, що таким чином тривають 3D мови. Але оскільки це була нова концепція для мене, я думав, що я викину цю інформацію для інших.

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

Лабрінт аналогічно наштовхується на простір, але це призводить до того, що Лабрінт рухається вниз у стовпці 1. Потім він повертає вниз по лінії 2, де рухається вниз до 3іншої стіни, внаслідок чого знову повертається на південь і потрапляє внаслідок ;чого 3 вибиваються . Потім програма продовжується праворуч, де зберігається та друкується 36, перш ніж нарешті знайти @вихід. Цей шлях довший, ніж він повинен бути, але я виявив, що Prelude виведе нуль-байт до того, як це буде нормальним 20 вихідним, якщо !ліворуч буде лівіше, ніж зараз, незалежно від рядка, який він з’являється. Тому я зробив це правильніше, бо мав місце для цього.

Далі, маршрутизація сіна Haystack змінилася, оскільки /тепер вона передує vлінії 1 і відображає її шлях вгору, як Reng. На щастя, Рен співіснує досить мирно. Одним з сутичок було те, що голка |Хейстака була відбивачем у Ренгу, тому Ренг використовує Бефундж як стрибок ( #) через голку, щоб правильно зробити Ренг.

Befunges продовжуються по рядку 1 до тих пір, поки ви не будете vспрямовані вниз, а потім праворуч на другому рядку, щоб завершити тим самим кодом, який використовувався раніше. Моє відчуття полягає в тому, що цей шматок можна трохи перемогти, коли менша кількість мов намагається осмислити код, але мені більше не потрібно було стін, щоб бити голову, тому я залишив його таким, як є.

Нарешті, відправним пунктом кардинала є те, %що не було особливої ​​необхідності втягуватися у вже щільні верхні дві лінії. Тому я перемістив її до рядка Python. Її численні кодові шляхи також тепер обмежені x's, що закінчує рух його вказівника.

Рядок 2 та 3

Єдина суттєва зміна тут полягає в тому, що всі :отримані гольфи з тих чи інших причин. Можливо, (потреби Прелюдії або, можливо, це були прості проблеми з кількістю байтів - можливо, і те, і інше. Інша справа, що код стрибка тригера перемістився назад і отримав ребрендинг як auaaZ. У мене було місце для заповнення, щоб зустріти шлях коду Befunge, і це здавалося найкращим. Крім того, <наступний цей фрагмент полягає в збалансуванні наступного SMBF >. Нарешті, одинокий ”кінець другого рядка повинен підтримувати рядок 05AB1E. Також yyна лінії 3 - лише символи заповнення для Лабіринту.

Великий струнний езоланг

Після вирішення двох верхніх рядків настав час почати копатись до більш повного розбору езолангсів, і у Піпа виявилася проблема. Якщо ви пам’ятаєте, ми мали справу з фігурними фігурними дужками {std::cout<<37;}, випадаючи з рядка Japt, щоб Japt міг ставитися до цього як до коду. Ну, Pip використовує той самий синтаксис рядків і йому не сподобався цей рядок як код, а Pip має дуже схожі параметри декларування рядків, як Japt. Обидва використовують один, 'щоб оголосити один рядок символів, обидва використовують одне і те ж оголошення дескрипції \і обидва приймуть "як ідентифікатори рядків. Тому важко було змусити Піпа повірити, що це стринг, не змусивши Джапта повірити в те саме.

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

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

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

Нарешті, тепер лінія виглядає так, з int main() #/*"`#"\'*/{std::cout<<37;}/*'"`"якою у Underload виникла проблема. У послідовних *помилках була ще одна синтаксична помилка, тож я кинув її ()в середині, *щоб заспокоїти її.

Крихкі езоланги

Зараз великою перешкодою став Білий Космос. Я не буду тут деталізувати багато деталей, тому що більшість рішень Whitespace вбудовані у вже дані пояснення, і я просто заглянув над випадками, коли пробіл примусив прийняти кілька рішень. Я дивлюся на тебе Лабіринт. Велика зміна, однак, полягає в тому, що фактичний код для виведення відповіді Whitespace знаходиться на рядку 2-4 замість 1-3. Багато в чому це пов’язано з впливом коду Джапта в рядку 1.

Thutu спочатку були проблеми з тим, що було цієї лінії: int main() #/*()"`#"\'*/{std::cout<<37;}/*'"`". Отже, я кинув на пряму стрічку прямо перед першим, #щоб приховати всі проблеми за індикатором коментарів, а потім розігнав кучу трейлінг /-файлів скрізь, де було викрито код.

У цей момент я вирівняв шестикутник і знайшов нову проблему. Код на самому початку, який почав свою життя як # 1"16" 1прийнято +в /+23!@не більше чіткого стека. Отже, я щойно зняв +це і виявив, що це зараз 123. Це було досить легко виправити, змінивши відкриваючий гамбіт на # 1"16" 2та погравши в шестигранну частину /3!@.

У "Вирлі" були деякі зміни, але це було головним чином, щоб переконатися, що потрібна кількість лідерів 1 з'явилася перед лінією "Вихр-інцидент". Незважаючи на інцидент, було особливо важко. У мене було рівно 3 примірники /*та */.

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

Висновок

Гаразд, це вся деталь, яку я маю для цього масового рефактора. Я обіцяю, що не буду так багато писати про наступний раз. Я фактично не маю уявлення, чи є C ++ хорошим чи поганим вибором для цього поліглоту, але я відчуваю, що це відкриває деякі варіанти. Сподіваємось, це призводить до хороших речей.

Щасливе кодування.

3. Minkolang v0.15 (26 байт)

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

Ця програма друкує 1 у Python 3, 2 у Vim та 3 у Minkolang v0.15

Я сподіваюся, що я не зіпсую речі, ввівши 2d мову

Спробуйте в Інтернеті!

Пояснення

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

Вім якось ігнорує Мінколанг, так що це добре

І справді не було проблеми з 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 print 5. У Python 3 1/2 є 0,5, що є правдоподібним значенням, завдяки чому Python print 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

Ще одна двовимірна мова.

Не впливає на Minkolang, оскільки він додає символи після зміни напрямку, чомусь Vim ігнорується. #є коментарем в Python, так що не змінюйте їх також.

28. Мозок-Флак , 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 у Гексагоні , 22 у Underload , 21 у Nim , 20 у Prelude , 19 у Reng (перевірена тут ), 18 в кардинал , 17 в Julia , 16 в Pyth , 15 в Хейстек , 14 в Turtlèd ,13 в Рубіні , 12 в діленні , 11 в Befunge-98 , 10 в Befunge-93 , 9 в Perl 5 , 8 в сітківці , 7 в Japt , 6 в SMBF , 5 в Python 2 , 4 в> <> , 3 в Minkolang , 2 у Vim / V , 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)що потім спарилося з ((())()<<>>). Тоді план став додавати зайві дужки до того, що я вважаю кодом пітона.

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

Виявляється, Japt інтерпретує фігурні фігурні дужки в рядку як містять код, але їх було досить просто, щоб вийти з \кожного перед {цим рядком. Але це підірвало кількість байтів. Таке життя.

Прелюдія досить прощала всі мої дужки. У попередньому коментарі вказувалося, що Прелюдія відповідатиме вертикально вирівняним папхесам, і я випадково створив лише один. Солодке! У (верхній лінії вишикувались (9великі та великі лінії. Тож мені довелося додати додаткове місце перед (верхньою лінією. Моє припущення тут полягає в тому, що подвійний пробіл був індикатором коментаря для чогось, тому додавання додаткового простору здавалося тривіальним, і воно спрацювало. Слід зазначити, що я намагався (9)замість цього додати додаткові пробіли , але кардинал не співпрацював.

05AB1E не сподобалась моя перша спроба, щоб струна Python була інкапсульована подвійними лапками, але всім здавалося, що вони згодні використовувати одиничні лапки. Там не велика справа.

Шестикутник був єдиною мовою, що залишилася на даний момент, і я, очевидно, переступив наступний поріг розміру шістнадцятки, тому настав час забруднитися. Це /^23!@шестигранний код, і я дуже схвильований з цього приводу, тому що я думаю, що це зробить майбутні доповнення набагато простішими. Цей маленький фрагмент можна перенести будь-де в рядку python, не перебираючи жодного коду. Це повна рядок, тому ми всі на одній сторінці '(\{(\{})(\{}\/^23!@[()])}\{})(\{}\{})'. /Тут задає шлях Hexagony від SE -> НХ W-> E вниз цей рядок, яка у нас є багато свободи с. (Попереднє \- втеча/для тути BTW). Моя ідея тут полягає в тому, що якщо ви внесете зміни, шанси полягають у тому, що ви в якийсь момент перейдете через цю рядок, і ви зможете просунути шістнадцяткову частину навколо рядка, щоб схопити шлях коду та надіслати його до належного висновку. Тільки подбайте про те, щоб не потрапити між Japt's \та the {. Якщо у вас виникли проблеми з цим, @праворуч від рядка просто залишилося від іншого рішення шестикутника, і його можна без наслідків видалити з інших мов. І, звичайно, якщо вам трапиться шлях коду Гексагонії, що йде в зворотному напрямку, ви, звичайно, можете використовувати @!32^\замість цього /^23!@. Також ви можете помітити, що моє рішення видалено===2з коду, щоб тримати речі під обмеженням байту. Хтось тут згадував, що це було для вирівнювання Гексагоні, і мені це вже не потрібно.

Нарешті, ось невеликий фрагмент коду, який я знайшов під час вивчення кодового гольфу, який перетворює рядок тексту в шестикутник, читабельний з шестикутника, щоб ви могли налагоджувати. Я впевнений, що про це знає багато людей, але я не бачив його тут, і це може допомогти комусь іншому. Справедливе попередження, вам доведеться змінити вхід, щоб зняти задні підказки та повернення каретки, а також замінити буквальний вихід на щось, що займає звичайну кількість місця, щоб отримати код для вирівнювання речей у досить шестикутнику.

PS Коли я це писав, я зрозумів, що помилився. Я повірив, що я очищаю край пам'яті Гексагоні з ^, але, мабуть, я можу замінити його без відключення без наслідків. Це, ^мабуть, має бути, +якщо ви спробуєте маніпулювати цим розділом. Я, мабуть, проходив +до цього, але майбутнім поліглоттерам, можливо, не так пощастить.

Щасти!

38. С, 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 в Інциденті, 32 в Whirl, 31 в Модульному SNUSP, 30 в Whitespace, 29 в Триггері, 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 тут і модульний SNUSP тут ; вони виводять відповідно 19 та 31 відповідно.

Ось моя трохи змінена версія маркера інцидентів , розробленого, щоб бути трохи менше гольфу, але трохи корисніше.

Пояснення

Я завжди любив робити маленькі поліглоти, але ніколи не такий великий, як це; Я подумав, що, мабуть, мушу дати йому піти!

Після чудової відповіді на C ++ @ Chance, C здавався наступним логічним вибором, і, враховуючи (порівняно з деякими попередніми відповідями) відносну легкість додавання його, я вирішив піти на це, коли мав можливість!

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

Я спершу намагався зробити printfвсе з вбудованим, але кілька дужок, здавалося, спричиняють проблеми для Japt, тому я зробив лінію простішою, і, здавалося, її виправити.

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

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

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

Навіть після вилучення додаткового, >>який раніше вимагався для відповідності <<в Perl6, я не міг отримати досить стислий спосіб розділити більш складну частину його на призначення масиву char. Тож я замість цього переглянув використання препроцесора.

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

Увесь час я латав пробіл, щоб отримати щось, що хотілося Whitespace; Я виявив, що це досить легко. Зокрема, це tab space space spaceбуло дуже корисною комбінацією (інструкція додавати два найпопулярніших пункти в стек), оскільки це означало, що я можу додати пробіл до рядків без інших пробілів, не маючи все, що синхронізується (я здогадуюсь, його позиція в програма означає, що вона ніколи насправді не виконується, тому я не турбуюся про підтоки стеків тут).

Зараз я тестував Incident, і він працює! Велике спасибі @Chance та @LliwTelracs, які я щойно зрозумів, що це НЕ валлійське ім'я, за те, що вони допомагають мені впоратися з цим. Дивіться це виділення синтаксису . Я видалив ;маркер, який з’явився перед #yyмаркером. Я зробив це, просто додавши додатковий ;після getsзаяви (моя попередня спроба передбачала заміну s(яка зараз виявляється набагато більше, ніж у програмі C, ніж це було в попередній) у рядок "детокенізації" на ;, але виявилося, що я насправді короткий символ для Hexagony (спасибі @Chance), тому після спроб додати додатковий символ до цього останнього рядка не вдалося, я просто змінив його назад і додав додаткову крапку з комою в іншому місці).

Я також трохи змінив пробіл, щоб змінити деякі інші маркери, щоб зробити спробу центрування, повторно маркірувати вкладку Linefeed (переміщуючи вкладку в кінці #includeрядка до середини, роблячи таким чином три лексеми), і де-маркіруйте маркер потрійного простору, перемістивши один пробіл у defineрядку.

Нарешті, через день після первинного подання я вирішив дійти до нижньої частини страшного попередження препроцесора, який виробляє gcc (і який змусив Clang вийти з ладу). Я визначив, що причина, по якій перший рядок взагалі працювала, полягає в тому, що це вихід з препроцесора, який забезпечує інформацію про налагодження, як оригінальні назви файлів і нумерацію рядків. Їм не сподобалося перше "2" в першому рядку, оскільки це означало "повернення із включеного файлу до заданого файлу", і очевидно, що це неможливо, оскільки там не було жодних включених файлів. Після зміни його на "1" (запуск звичайного заголовка) зробив кілька занадто багато мовних дроселів, я змінив його на "3" (запустити внутрішній заголовок компонента), який зламав лише шестикутник, оскільки тепер він покладався на 2. Тож на початку коду Гексагонії я додав відкриту дужку(декрементуйте 3 на 2, потім закрийте дужку )після закінчення ( @) шестикутного коду, щоб задовольнити Retina, Prelude та Underload, які всі очікували відповідних дужок. Повторне тестування Reng та Modular SNUSP не спричинило жодних проблем, і жетони Incident виглядали правильно, тому я зараз це виправив! Я перевірив це на різних екзотичних архітектурах, і, здається, він працює. Я знаю, що це не важливо для гольфу з кодом, і я не заперечую, якщо майбутнім представникам доведеться знову це порушити, щоб утримувати кількість байтів чи що завгодно (або якщо хтось уже почав базуватися на цьому рішенні і не хоче змінювати своє занадто багато), але є одна вагома причина, що я це зробив - компілятор TIO Objective-C підтримує лише Clang, тому це буде дуже корисно, якщо хтось хоче це додати!

Майте на увазі, що я ніколи не використовував більшість цих мов, сподіваюсь, що мій успіх спонукає більше новачків спробувати це!

65. ALGOL 68 (Genie) , 1634 байт

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

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

VIP-оцінка ( універсальний принтер цілочислення ): .005949 (для покращення, наступний запис повинен бути не більше 1710 байт)

Спробуйте в Інтернеті!

Спуститися

Ця програма друкує 65 в ALGOL 68, 64 в Агонії, 63 в 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 в Лілі, 46 в Cubix, 45у PicoLisp, 44 у альфуку, 43 у ретикулярному, 42 у злому, 41 у мозговому ебані, 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 в 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 ~ приймає поліглот для подачі на stdin, але друкує ряд >>підказок до стандартного виводу, які n неминучі наслідки запуску будь-якої програми Deadfish ~.

• Moorhens 2.0 може бути протестований для виведення 60 за допомогою цього інтерпретатора .

АЛГОЛ 68

ALGOL - це, мабуть, найменш відома з чотирьох мов програмування високого рівня з перших днів програмування - решта мов цього неясного розрізнення - COBOL, FORTRAN та Lisp. АЛГОЛ був відомий в академічних та математичних колах у той час, але сьогодні найвідоміший своїм величезним впливом на сучасні мови. Насправді більшість сучасних, практичних мов можна охарактеризувати як «подібні до алголю», не останньою з яких є 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 позначила пару маркерів інцидентів у своєму кодовому сегменті, тому код ALGOL повинен був пройти до кодового сегмента інциденту. ALGOL також викликав проблему вирівнювання прелюдії, якщо вона йшла першою в порядку, тому вона повинна була пройти другу або третю. Тим часом у SMBF стався незрозумілий збій, коли код інциденту минув останнім, тому інцидент повинен був пройти першим чи другим. Ну, я зрозумів, що це вступна логічна проблема, яка виявилася нерозв'язною, тому я поставив за мету зробити незрозуміле більш… придатним.

Пройшовши SMBF, я виявив, що проблема з наявністю ^ _ ^ _ в кінці була пов'язана з Мудрим. Код Wise ( ~-<~-<~-<<<~-) не прихований за циклом, який не виконується, на відміну від більшості поліглотів. Але в коді Wise не включені коди друку SMBF. Це була лише зміна значень пам'яті. Це здавалося невинним. То в чому тоді була проблема? Це був той чорт С.М. перед БФ.

Код Мудрого змінює символи в коді, який повинен бути виконаний, і ви можете здогадатися, що таке сусід значення 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)#

просто так буває НОП у В. (мені пощастило). Потім 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 у прелюдії , 19 у Ренґі (перевіряється тут ), 18 у Кардинала , 17 у Джулії , 16 у Піті , 15 у сіна , 14 у Туртледі , 13 у Рубі , 12 у Фіссі , 11 у Бефунге-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у грушевому дереві .

Існуючий код в значній мірі скасовує себе в Prelude, що складається лише з циклів, що містять аргументи фальси та деяких маніпуляцій стеками на стеках. Ще краще, якщо є місце в коді, це коментар на всіх мовах , які мають їх (між #і =#попереднє уявлення). Важка частина пристосування Прелюдії до цього - генерування чисел лише з одним стеком і без підриву кількості байтів. Ця програма використовує цикл, який додає 45 до кожного елемента стека і виводить його як ASCII, таким чином, розміщуючи 5 вище 3 на стеці, ми отримуємо 20як вихід. (Акуратно, 20 - це простіше число, ніж 19, - це прелюдія, тому відповідь 19, розміщена фактично, мені трохи допомогла.)

30. Пробіл , 296 байт

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

␛ являє собою буквальні втечі.

␉ представляє буквальні вкладки.

Ця програма друкує 30 у Whitespace , 29 у Trigger , 28 у Brain-Flak , 27 у Perl 6 , 26 у 05AB1E , 25 у Pip , 24 у Thutu , 23 у Гексагоні , 22 у Underload , 21 у Nim , 20 у Prelude , 19 у Ренгу (тестується тут ), 18 у Кардинала , 17 у Джулії , 16 у Піті , 15 в Хейстек , 14 в Turtlèd , 13 в Рубін , 12 в діленні , 11 в Befunge-98 , 10 в Befunge-93 , 9 в Perl 5 , 8 в сітківці , 7 в Japt , 6 в SMBF , 5 в Python 2 , 4 в> <> , 3 в Мінколанге , 2 в V / Vim і 1 в Python 3 .

Пробіл - ще один езоланг з обмеженим набором символів. Цей лише читає вкладки, пробіли та канали рядків.

Отже, як тільки ми виймаємо всі речі, які 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]

Ось коментована версія просто білого простору:

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 був досить люб'язним оновити @ Heneyagonizer Кенні для обліку буквальних втеч і вкладок. Мені довелося змінити його, щоб виправити моє попереднє твердження про те, що вкладки читаються як невідповідні та замінити буквальні втечі, .оскільки ␛персонаж ширший, ніж інші символи, завдяки чому шістнадцятковий вирівняний. Ось посилання .

І це наш виправлений поточний 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 та шестикутники шестикутників.

Код Nim є назад echo 21зecho 5+5+11

Hexagony - х #@46зараз#46

Код Hexagony є назад /+23!@=з/+23!@

Прелюдією вирівнювання (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 у Бефунге-98, 12 у Фіссі, 13 у Рубі, 14 у Туртледі, 15 у сіна, 16 у Піті, 17 у Джулії, 18 у Кардинала, 19 у Ренґ, 20 у Прелюдії, 21в Nim, 22 в недовантаження, 23 в Hexagony, 24 в Thutu, 25 в ПГИ 26 в 05AB1E, 27 в Perl 6, 28 в головному мозку-Flak, 29 в тригер, 30 в Whitespace, 31 в модульному SNUSP, 32 в Вихор , 33 в Інциденті, 34 в залізниці, 35 в INTERCAL, 36 в Лабіринті, 37 в C ++ 03, 38 в C99, 39 в CoffeeScript, 40 в Minimal-2D, 41 в brainfuck, 42 у злі, 43 у ретикулярному, 44 у альфука, 45 у ПікоЛісп, 46 у Кубікса, 47 у Лілі, 48 у Мертвих риб ~, 49 у Октаві, 50 у Баша, 51 у Асамблеї, 52 у КР, 53 у Шове, 54 в Zsh, 55 в Brain-Flak Classic, 56 в DC, 57 в Wise, 58 в Ksh, 59 в Tcl, 60 в Moorhens, 61 в SILOS, 62 в Grass, 63в Брайані і Чак, 64 в Агонії, 65 в АЛГОЛ 68, 66 в Поверхні, 67 в С11, 68 в Питоні 1, 69 в Рк-Ланге, 70 в комерційних, 71 в чому, 72 у Фортран, 73 в Морзе, 74 в Archway, 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:

• Japt, 7 онлайн .
• Reng, 19 онлайн .
• Мертва ~, 48 місцевих .
• Мурхена, 60 місцевих . використовуйте moorhens.py з гілки v2.0-dev
• Морзе, 73 місцеві
• Арка, 74 місцевих
• Trefunge-98, 76 місцевих . Використання -d 3 -v 98для Trefunge-98.
• Обєк, 83 місцевих
• зкл, 85 місцевих
• PingPong, 88 місцевих
• RunR, 90 місцевих
• Cood, 91 онлайн
• Комплект, 93 онлайн
• Emotinomicon, 94 онлайн
• EmojiCoder, 96 онлайн
• Archway2, 98 локальний Я не можу перевірити Archway2, оскільки у мене немає належного компілятора C, однак stasoid підтвердив, що він працює в archway2

Пояснення

Не можу повірити, що ми зробили це на 100 мовах. Я просто хотів би взяти час, щоб подякувати всім, хто був задіяний у цьому процесі. Це була весела їзда, і я сподіваюся додати ще 100 з вами, хлопці.

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

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

+.+..

Для того, щоб замаскувати вихідні дані для brainfuck, ми додаємо цикл і мінус:

+-[.+..]

Тепер все, що потрібно, - це знайти місце для коду. Моє місце вибору було першим +на найвищому рівні коду головного мозку в рядку 8. Для підстановки в плюс ми додали наш код і +-+котрий діє як +у мозговому ебанді, так і в плазмі.

+-[.+..]+-+

Cubix

Я ставлю свій код перед капсулою Cubix, внаслідок чого дзеркало рухається в шлях вказівника. Для того, щоб виправити це, я перемістив капсулу на кілька кроків вперед перед дзеркалом, яке кривдить, і все було добре.

Дивно нічого іншого не зламало навіть сумнозвісний випадок.

27. Перл 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 у Pip , 24 у Thutu , 23 у Гексагоні , 22 у Underload , 21 у Nim , 20 у Prelude , 19 у Reng (перевірена тут ), 18 у Cardinal , 17 у Julia , 16 в Pyth , 15 в Хейстек , 14 в Turtlèd , 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у груші .

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

Я не зовсім впевнений, як працює шестикутник. Коли він зламався, я змінив одного з персонажів, які він використовував, з a +на a, 0щоб побачити, чи його вдаряють; виявляється, це було, і виявляється, це виправлено програмою, але я не впевнений, чому (я знаю, що вона зламалася через #рядок виконання, але незрозуміло, чому видаляти +речі виправляє). (Розглянутий персонаж також розбирається Туту, але, на щастя, це не має значення для функціонування програми Туту, оскільки в цей момент програми все, що не передує, =копіюється буквально в робочий рядок.) Зауважте, що 0and+4з попереднього рядка став0and 4, щоб зробити його на один символ коротшим з точки зору Гексагоні (Гексагонія не бачить пробілів); це для компенсації переходу #|на попередній рядок #`<`|, який є одним символом довше з точки зору Гексагоні (тому що він також не бачить зворотних лапок). Зауважте, що код тепер лише на п'ять байтів від розширення довжини сторони шестикутників та розбиття всього про поточний код шестикутника. Я б рекомендував зробити це все одно і просто переробити розділ коду Гексагонії; це, мабуть, буде простіше, аніж важче, все підходити після розширення.

Деякі інші мови теж змінилися, в основному, щоб додати достатньо надійності, щоб я міг помістити довільний код у останньому рядку. $//є маркером коментарів у Japt, який дозволяє пробіли пізніше в рядку, роблячи додану програму менш крихкою в Japt (тим часом, //перерви, якщо в рядку є якісь закриті дужки, а простір - це свого роду дужки, що закриваються в Japt). Пара пробілів - це маркер коментарів у Pip, що означає, що код Pip тут може бути істотно спрощений. Це також означає, що ми можемо спростити 05AB1E до тривіального "26. Сітківці потрібен п’ятий рядок, щоб він був юридичним підсумком, який добре поєднує речі (трейлінг)|таким чином, для Retina); він аналізує інакше, ніж відповідний рядок у попередньому записі, але таким чином, як підходить. Кардинал також дуже простий, ніж у попередніх записах, але це просто чистий збіг з тим, як все вишикується вертикально, і зміна полягає в коді, який нічого не зробив.

Якщо припустити, що ви переробили "Гексагонію" (можливо, вам доведеться), у всіх останніх трьох рядках є безпечні місця для додавання коду: " 3in" #3]#призначений лише для Hexagony (і легко змінюється); пробіл між заключним рядком #та "на останньому рядку ігнорується переважною більшістю мов; і ніщо насправді не розбирає кінець п’ятого рядка, крім Retina. (Є багато інших місць, де також можна додати код, але це, мабуть, найзручніше.)

31. Модульний SNUSP , 326 байт

Програма

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

Як завжди, ␛це буквальний символ ESC і ␉є буквальною вкладкою.

Спуститися

Ця програма друкує 31 у модульному SNUSP, 30 у Whitespace, 29 у триггері, 28 у Brain-Flak, 27 у Perl 6, 26 у 05AB1E, 25 у Pip, 24 у Thutu, 23 у шестикутнику, 22 у Underload, 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 відразу після тригерного коду, це означає, що він майже в кінці програми, а шестигранна «капсула», яка друкує 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 у Minkolang v0.15
• 4 в > <>
• 5 в Python 2
• 6 в SMBF
• 7 в Япті
• 8 в Сітківці
• 9 в Perl
• 10 у Бефунге 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@є частиною сітківки (без неї не працює, не питайте мене чому). Додавання 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 у Інциденті, 32 у вихорі, 31 у модульному SNUSP, 30 у Whitespace, 29 у триггері, 28 у Brain-Flak, 27 у Perl 6, 26 у 05AB1E, 25 у Pip , 24 у Туту, 23 у Гексагоні, 22 у Андерлоу, 21 у Нім, 20 у Прелюді, 19 у Ренгу, 18 у Кардинала, 17 у Джулії, 16 у Піті,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 в Мінколанге, 2 в V / Vim і 1 в Python 3.

Перевірка

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

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

Попереднє подання Rail виходить із аварії, що заборонено, але це легко піддається фіксації (додавши в #кінці програми Rail і налаштувавши Шестикутнику на відповідність), тому я не вважав це основною проблемою. Рейка в цьому рішенні виходить правильно.

Пояснення

Як працює код INTERCAL

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); прочитати його до стандартного виводу; і вийти з програми. У кінці програми я додав додаткове ЗАМОВНЕННЯ, щоб припинити операцію GIVE UP, розпочавши нову заяву для сміття в кінці програми, зберігаючи при цьому прийнятні межі для ввічливої ​​розмови. Звичайно, INTERCAL виглядає не так, як у готовому продукті; Я поясню, чому ми йдемо.

Похований під вантажем Sес

Найбільш очевидною проблемою програми INTERCAL є те, що вона містить лист S. Це майже неминуче, оскільки немає можливості індексувати масив, не використовуючи відповідну букву. Однак Sце команда виводу в програмі Underload, і немає ніякого способу запобігти її розбору всієї програми. Єдине рішення - розмістити код INTERCAL всередині дужок, еквівалент Underload рядкового літералу, щоб він не запускався відразу.

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

Прелюдія до великої праці та розгубленості

Ах, прелюдія. Зазвичай це не найскладніша мова, але, безумовно, це було цього разу. Є дві реальні проблеми: одна полягає в тому, що додавання додаткових дужок в далеко довгий рядок ризикує порушити потік управління програми Prelude (оскільки вони створюють еквівалент whileциклу), а одна - просто проблема запобігання їх вишикуванню. вертикально вгору (що відповідає за більшість випадкових рухів навколо пробілів на лініях). Зауважте, що Whitespace теж створив мені певну проблему, але ця програма еквівалентна попередній з точки зору Whitespace, тому це був досить великий випадок "виправити прелюдію, не порушуючи пробіли".

Я не надто впевнений, як Прелюдія насправді працює в цей момент. Для цього призначено кілька виправлень, як-от 0 біля нижнього лівого кута, але вони явно не функціонують так, як я їх задумав. (Код Джулії також перейшов до нижньої частини рядка, оскільки круглі дужки в його printзаяві справді були важкі для вирішення.) Можливо, нам просто доведеться залишити це загадкою.

Поломка в реакторі Fission

Хоча зміни, зазначені вище, стосувалися досить тонких проблем, які важко виправити, є набагато більш очевидна проблема; DOREADOUTвідповідає регексу R...O, і, таким чином, призведе до того, що Fission видасть небажаний вихід на четвертому циклі, що не вистачає часу для виведення запланованого результату 12. І INTERCAL має лише одну інструкцію, яка виробляє вихід (якщо ви не рахуєте збоїв як вихід). Одне виправлення цього полягає в тому, щоб спробувати додати пробіл між READі OUT, щоб дати нам час на перехоплення результатів, але це злість Whitespace. Тому деякий час я вважав, що ця програма неможлива; R, L, U, І Dвсі крапки входу в розподілі, і всі здатні потенційно працюють проблемний код, і INTERCAL ключових слова повинні бути в верхньому регістрі.

Однак є і виправлення, і досить дивовижне. В рамках заходів з інтернаціоналізації C-INTERCAL фактично приймає ключові слова на декількох мовах, підтримуючи англійську та латинську мови. Ми не могли уникнути Sподібного, але можемо уникати O; FACє ідеально хорошою заміною DO, а також LEGERE EXозначає те саме, що і READ OUT. (Таким чином, програма закінчилася поєднанням англійської та латинської мов, але це нормально; це навряд чи робить його менш читабельним.) Як такий, ми можемо щасливо відпустити Fission з розуму в нижньому правому куті, і просто не дамо йому створювати жодних вихід. Ми можемо змінити фактичний код Fission на закінчення, *а не;, яка закриває всю програму, а не лише один потік; цей код запускається досить швидко, тому він виходить з програми, перш ніж усі вхідні точки входу встигнуть завдати шкоди.

В'язати 6, Perl 6

Наступна проблема: коментарі Perl 6 працюють шляхом узгодження <та >. Оператором призначення INTERCAL є <-. На щастя, це додає додаткові дужки, що відкриваються , тому я міг би просто додати кілька дужок, що закриваються, щоб скасувати їх у нерозбірливому місці в програмі (відразу після коду Pip, у цьому випадку).

Однак я не хотів змінювати бюджет програми пробілів програми, але переміщення коду Джулії (для Прелюдії) в кінцевому підсумку додало додатковий простір в останньому рядку; Мені довелося десь зняти його. Подвійний пробіл - це маркер коментарів у Піпі, тому я навряд чи міг їх змінити; єдиний варіант, що залишився - це місце в say 27. Гольфісти Perl 5 одразу подумають «добре просто роби say+27тоді» (Унарі +корисно напрочуд часто!), Але, на жаль, це не відповідає синтаксису Perl 6.

Однак ми можемо перейти sayвід синтаксису функції до синтаксису методу. Цілі літерали мають безліч методів, включаючи один для їх роздрукування, тому 27.sayідеально правильна програма однакової довжини.

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

Отже, наступне питання полягає в тому, що я додав додаткові .програми. Користувачі SMBF знають, що це явно проблема в цій мові, що створює бродячий вихід (NUL байт у цьому випадку). Був уже. виробництво паразитного виходу останньої програми, але це не означає , що я не повинен скористатися цією можливістю , щоб виправити це.

Основна ідея тут - створити цикл SMBF для коментування порушень. Це означає переміщення квадратних дужок навколо. Я взяв їх з коду SNUSP (тому що вони там були тільки заради Інциденту, і інцидент не байдуже, де в програмі вони є), і поставив відкривальну дужку на початок коду INTERCAL і замикаючи кронштейн безпосередньо перед спусковим гачком (таким чином акуратно ховаючи обидві .).

На жаль, квадратні дужки мають значення для сітківки; він бачить […<-#…і каже, "що не має сенсу, ви не можете створити цей діапазон, тому <що раніше не виходите #". На щастя, це легко виправити за допомогою стратегічно розміщеної косої риски.

Інцидент у центрі програми

Це сталося останньою відповіддю, і, мабуть, це відбуватиметься неодноразово; різні струни траплялися випадковим чином тричі і зміщувалися навколо центру програми з точки зору Інциденту.

Найактуальнішим жетоном, який потрібно обробити, було 1#, яке з’являється три рази, якщо ви зробите ці зміни наївно: #= >␉1#на початку третього рядка __DATA__=1#, і echo 21#. Чому це проблема? Оскільки 1#на третьому рядку перекривається #vбезпосередньо після нього, а два лексеми, що перекриваються, не спричиняють жодного з них. І #vце маркер, який ми використовували для коментування коду перед програмою Incident! Я це виправив, прокравшись у зайвій, 1#майже в кінці програми (лише три символи слідують за нею); жодна з мов, які розбирають цю частину програми, з цим нічого не роблять.

Існували різні інші проблемні лексеми, з якими можна було попрацювати. Пара була однією буквою, Pі U; Я мав справу з цим шляхом змін пари наповнювач не-OPS в коді інцидентів від xдо Pабо Uвідповідно, даючи четверту копію. Зміна коду Fission залишається *лексемою, але, зокрема, це розділено інакше від звичайного, з’являється двічі перед кодом інциденту і лише один раз після цього. Замість того, щоб видаляти його, тому я використовував його, щоб частково збалансувати новий 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*.@

Натисніть 5, без опції, помножте два елементи в стеку ( 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 у Minkolang, 4 у> <>, 5 у Python 2, 6 у SMBF, 7 у Japt, 8 у Retina, 9 у Perl, 10 у Befunge-93, 11 у Befunge -98, 12 у Фіссі, 13 у Рубі, 14 у Туртледі, 15 у сіні, 16 у Піті, 17 у Джулії, 18 у кардинала, 19 у Ренґ, 20 у прелюдії та 21 у Німі .

Зауважте, що Nim на ideone.com використовує версію 0.11.2, яка є надто застарілою, оскільки ця програма покладається на це #[ ... ]# багаторядкові коментарі, додані на початку 2016 року.

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

Редагувати - ще кілька підказок:

• The 8 початку останнього рядка слід встановити ліміт Retina на перші 8 матчів, інакше без нього Retina виведе 2. Зауважте, що це означає, що підсумковий виразний рядок повинен збігатися щонайменше 8 разів у другому останньому рядку зараз, на відміну від точно 8 - під час мого втручання я змінив Prelude, щоб отримати сітківку правильно, але виявилося, що це було непотрібне врешті-решт. .
• Невідповідна цитата в кінці першого рядка полягає в тому, що 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 в Асамблеї, 50 в Баші, 49 в Октаві, 48 в Мертвій рибі ~, 47 в Лілі, 46 в Кубіксі, 45 в ПікоЛісп, 44 в альфуку, 43 в ретикулярі, 42 в злі, 41 в моззі *** , 40 в Minimal-2D, 39 в CoffeeScript, 38 в C, 37 в C ++, 36 в Лабіринті, 35 в INTERCAL, 34 в Rail, 33 в Інциденті, 32 в Whirl, 31 в Модульному SNUSP,30 у Whitespace, 29 у Trigger, 28 у Brain-Flak, 27 у Perl 6, 26 у 05AB1E, 25 у Pip, 24 у Thutu, 23 у шестикутнику, 22 у Underload, 21 у Nim, 20 у Prelude, 19 у Reng , 18 в кардинал, 17 в Julia, 16 в Pyth, 15 в Хейстек, 14 в Turtlèd, 13 в Ruby, 12 в діленні, 11 в Befunge-98,10 у Befunge-93, 9 у Perl 5, у Python 3.8 у Retina, 7 у Japt, 6 у SMBF, 5 у Python 2, 4 у> <>, 3 у Minkolang, 2 у V / Vim та 1

Перевірка

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

• Reng може бути протестований, щоб отримати тут 19 .

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

• Форма кубика Cubix розглядається тут

• Інцидент перевіряється, зберігаючи жетони збалансованими, як описано в попередніх відповідях.

• Для Deadfish ~ може бути протестовано на вихід 48 із цим . Зауважте, що Deadfish ~ приймає поліглот для подачі на stdin, але друкує ряд >>підказок до стандартного виводу, які є неминучим наслідком запуску будь-якої програми Deadfish ~.

• Складання можна перевірити на вихід 51 тут

Дякую та вітаємо

Коли 2 тижні тому відповідь @ ais523 "50" на 1 "k" випала, сльоза котилася по моїй щоці. Це було занадто красиво. І це було в Баші. Це було занадто досконало.

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

Вона повернулася до мене в очі, зробила паузу на мить і сказала: «Добре. Тепер винесіть сміття ».

Що вона мала на увазі, це те, що вона відчувала глибоку радість для мене та моїх інтернет-друзів. Дякуємо та вітаємо всіх.

Пояснення складання

У наступні дні мій розум продовжував блукати назад до чогось, що @ ais523 сказав у поліглот-чаті незадовго до опублікування Баша. Він зазначив, що деякі аромати збірки використовують #коментарі на основі рядків та /*блокові коментарі. Добре, що мені було достатньо, щоб повільно втрачати розум протягом наступних 2 тижнів.

У поліглотах є своєрідна неявна задача включити законні мови. Я тут дуже вільно використовую легітимний термін, але я думаю, що ми всі зможемо пограбувати тим, на що потрапляю. Одне з них включати Brainf ***, але інша справа повністю - включити подібні Mathlab або R. Асамблея, безумовно, потрапляє в останню категорію, і мій розум не міг її відпустити. Але я нічого не знав про Асамблею, тому це був важкий бій.

Деякий час стукаючи головою про проблему, шукаючи спосіб співіснування асамблеї та 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 (коротко GAS або AS). AS має щасливу особливість дозволити обидві синтаксичні гілки. Вам просто потрібно заявити, що ви хочете використовувати синтаксис Intel, що відбувається в рядку 1 коду асамблеї.

Асамблея використовує регістри, які є невеликою кількістю місць пам'яті, буквально розташованих на процесорі для швидкості доступу. Це не тільки для Асамблеї, окрім того, що їх використання не абстрагується від занепокоєння розробника.

Існують різні види реєстрів, які використовуються для різних цілей. З Вікіпедії:

• AX множення / ділення, завантаження рядків і зберігання

• кількість CX для рядкових операцій та зрушень

• адреса порту DX для входу та виходу

• Реєстр індексу BX для MOVE

• SP вказує на верхню частину стека

• BP вказує на основу рамки стека

• SI вказує на джерело в потокових операціях

• DI вказує на місце призначення в потокових операціях

AX використовується в рядку _start функції тут: mov rax, 1. Вхідний сигнал вказує rна 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збірки, додану на користь Альфука.

Потім я вкладаю ;для розмежування інструкцій, щоб їх розмістити в одному рядку. Це в першу чергу для того, щоб уникнути зайвих #//відстань на кожному рядку на користь Туту. Крім того, я помітив, що наш Асемблер не виглядає чутливим до регістру, тому я просто верхній або нижній реєстрував різні символи, щоб уникнути порушення рівноваги.

Цей гольф нас звів до:

.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 ++. Я в кінцевому підсумку кинув (цей рядок, а потім закрив його на лінії Octive. Це було так, що "Underload" перестане зникати. Аналогічну обробку доводилося додавати на лінію 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)

Це посилання також показує деякі двозначні шістнадцяткові цифри поруч із кожним рядком складання. Вони відповідають десятковим інструкціям. Наприклад, якщо ви помістите цей перетворювач 2298589328у десятковий до шестигранний, ви повернетесь назад. Якщо ви уважно придивитеся, це перші 4 шістнадцяткові інструкції з дампу об'єкта (у зворотному порядку).8901B090

З того, що я можу сказати, набори з чотирьох шістнадцяткових чисел завжди використовуються для перетворення в десяткові, і головний фокус збереження байтів, який тут використовується, - це структурувати збірку так, щоб останні кілька шестинадцяткових чисел у наших 4 наборах були 00. Потім вони перетворяться до провідних нулів, коли ми вводимо їх у .intвисловлювання, яке щойно опущено.

Це те, що відбувається в 12заяві. У шістнадцятковій частині дамп об’єкта це 0c 00 00 00.

Це настільки, наскільки я зрозумів Асамблею за два тижні. Який курс краху!

Інцидент

Інцидент був складнішим у вирішенні коротшої реалізації монтажу, оскільки він зважив жетони поліглоту набагато важче до верху. Ось звіт про інциденти.

• ! у другому рядку детокенізується !

• Перший 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. Ruby (129 байт)

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

Будь ласка, зверніть увагу на буквальний Escсимвол в останньому рядку між 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 у Fission та 13 у Ruby.

Лише незначна модифікація існуючого printтвердження, щоб зловживати фактом, який 0є руті в Рубі. Мені довелося додати трохи пробілів до інших висловлювань, щоб правильно розібратися.

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 у Фіссі, 13 у Рубі, 14 у туртледі та 15 у стозі сіна.

Спробуйте в Інтернеті!

Пояснення

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

9. Perl, 84 байти

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

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

Існує буквальний символ ESC у фактичному коді між jі d; він був замінений на ␛ тут для наочності.

Це друкує 1 у Python 3 , 2 у Vim (перевірено локально, але ось посилання на дуже схожу мову V), 3 у Minkolang , 4 у <> < , 5 у Python 2 , 6 у SMBF , 7 у Japt , 8 в Сітці і 9 в Перлі .

Давайте отримаємо ще кілька екзотеричних мов, зловживаючи арифметикою, яка по-різному працює на різних мовах. ( Noneце фальси в Python, але truthy в Perl, і and/ orланцюги працюють однаково в обох мовах.)

Крім Python, мені довелося також змінити код vim. Замість того, щоб перетворювати його на серію без операцій, я просто дав їй вставити мотлох, після чого видалив мотлох знову в кінці.

36. Лабіринт , 647 байт

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

␉- буквальна вкладка, ␛буквальний символ ESC; В іншому випадку Stack Exchange маніпулює програмою. Рекомендую скопіювати програму з поля "введення" посилання TIO нижче, якщо ви хочете працювати над нею.

Спробуйте їх онлайн!

Спуститися

Ця програма друкує 36 у Лабіринті, 35 - INTERCAL, 34 - Rail, 33 - Інцидент, 32 - Whirl, 31 - Модульний SNUSP, 30 - Whitespace, 29 - Trigger, 28 - Brain-Flak, 27 - Perl 6, 26 - 05AB1E , 25 у Піпі, 24 у Туту, 23 у Гексагоні, 22 у Андерлоу, 21 у Нім, 20 у Прелюдії, 19 у Ренґ, 18 у кардинала, 17 у Джулії, 16 у Піті, 15 у Стойці, 14 у Туртледі, 13 у Рубі, 12 у Фісіоні, 11 у Бефунге-98, 10 у Бефунге-93, 9 у Перлі 5, 8 у Сітківці, 7 у Джапті, 6 у СМБФ, 5 у Пітоні 2, 4 у> <>, 3 у Мінколанге , 2 в V / Vim і 1 в Python 3.

Перевірка

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

Як працює Лабіринт

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

Те, що я зробив, зламав

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

Тоді було вирішено ремонтувати те, що я зламав: Мінколанг, Кардинал та Гексагонія.

!Робив Мінько пропустити наступний символ, який йому необхідно припинити, так що я просто додав додатковий @. Все йде нормально.

Зміна довжини 2-го рядка змусила Кардинала пропустити його висновок про вихід. Намагаючись додати додатковий .на першому рядку, змусив Prelude втратити розум (немає поняття чому, чесно кажучи), тому я пішов іншим методом і просто скинув його у другий рядок. Це ненароком породило 3-й кардинальний вказівник, тому я підбив речі ?(не необхідний вибір, саме перше, що я виявив, що виправляв і Фіссія, і Кардинала).

Шестикутник був, на щастя, відносно простим виправленням, я просто кинув рядок літер, щоб вказівник знайшов код. Я вважав, що алфавіт не повинен був з’являтися раніше і не спричинять проблем з Інцидентом. Це також, коли я зрозумів, що не перевіряв інцидент. Завдяки @ ai523 я дізнався, що мені просто потрібен додатковий знак оклику, тому eрядок в алфавіті було змінено на a !.

Оцінки від універсального цілого принтера

Тільки для ударів і відключення коментаря @Stewie Griffin до цього питання, ось фрагмент, який показує, як кожна відповідь набрала б, якби вона була введена в "The Verstatile Integer Printer".

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

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

/* App */

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

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

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

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

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

getAnswers();

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

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

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

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

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

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

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

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

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

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

}

body { text-align: left !important}

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

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

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

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

41. brainf *** , 916 байт

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

␉- буквальна вкладка, ␛буквальний символ ESC; В іншому випадку Stack Exchange маніпулює програмою. Рекомендую скопіювати програму з поля "введення" посилання TIO нижче, якщо ви хочете працювати над нею.

Спробуйте в Інтернеті!

VIP-оцінка (універсальний принтер цілочисел): 0,01329

Спуститися

Ця програма роздруковує 41 у brainf ***, 40 у Minimal-2D, 39 у CoffeeScript, 38 у C, 37 у C ++, 36 у Лабіринті, 35 у INTERCAL, 34 у Rail, 33 у Інциденті, 32 у вихорі, 31 у Модульний SNUSP, 30 у Whitespace, 29 у триггері, 28 у Brain-Flak, 27 у Perl 6, 26 у 05AB1E, 25 у Pip, 24 у Thutu, 23 у шестикутнику, 22 у Underload,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.

Перевірка

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

Тестовий драйвер було оновлено, щоб включити Tokenizer, нарешті. Весь код C зберігається як аргумент з точки зору Bash Script. Я також змінив вихід, щоб обернутись горизонтально з проміжком після кожного маркера, а не вертикально. Це було лише моїм уподобанням, щоб він відповідав виходу Whitespace. Але будь-хто інший може змінити це, якщо відчує, що це занадто заплутано.

Я також здійснив коригування тест-драйвера для обробки міжрядкових інтервалів для позначки UFT8 Turtlèd в переході. Та нерівність зводила мене з глузду! "Виправлення" є досить злому, оскільки воно просто шукає è та змінює ширину стовпця для цього випадку, але це робить роботу.

Пояснення

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

Тому я почав працювати над цією відповіддю, намагаючись розіграти те, що міг, і я був досить успішним. У мене навіть була відповідь іншою мовою, загальна кількість байтів менша за # 40. Але коли я намагався переграти Minimal-2D, мені довелося навчитися BF, щоб я міг краще працювати з його похідними, і в процесі я знайшов рекорд @ Примо, побивши привіт, світ! . Я закохався в елегантність.

Мінімальний-2D виявився недостатньо ефективним, щоб використовувати техніку ініціалізації стрічки, яку використовує @Primo, але я зараз вважаю, що це, мабуть, буде занадто важким байтом. Ми лише намагаємося надрукувати ціле число. Але @Primo все-таки направив мене на шлях до того, як навчитися розмножуватися в BF, і я привів код Minimal-2D.

Потім, після всього цього, я перечитав коментар @ SnoringFrog про те, як включити BF, і зрозумів, що не тільки я можу це зробити, але і міг би використовувати багато коду Minimal-2D, на який я відповів у відповідь BF. Тож я заглибився, щоб відповісти з BF, і ось ми.

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

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

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 Тіо вказівник пам'яті здатний рухатися ліворуч від початкового коду і знайде 0 замість кодів ascii Поліглота, які бачить SMBF. Ось приклад, який можна запустити як у SMBF, так і в BF для прикладу різниці.

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

Далі ми збільшуємо комірку пам’яті початків для обох мов і переміщуємо вказівник пам’яті вліво за допомогою +<. (Для розмовної конвенції ми будемо називати комір пам'яті початку як клітинку 0, комірки праворуч від джерела 1, 2, ... І комірки зліва -1, -2,…). В комірці -1 міститься код asci останнього символу в поліглоті в 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. Тож обидва стрибають повз залишився мінімальний 2D-код, поки не з'явиться ]рядок 11. Але це недовго, оскільки рядок 12 починається з іншої, [яка переносить обидві мови майже до кінця поліглоту, де подальших інструкцій не зустрічається.

Рефактори

Мінімальний-2D

Переписування Minimal-2D здебільшого полягало в тому, щоб зберегти кілька байтів таким чином, як трюк множення BF. Однак у Minimal-2D немає символів [та ]символів для керування циклом. Натомість у неї є такі команди:

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

Вони можуть бути використані для створення тієї ж логічної структури, хоча і в двовидовій садибі, як і 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 для комірки 0 дорівнює нулю. Якщо ні, ми додаємо ще 8 до комірки 1, а потім декремент і ще раз перевіряємо. Результатом цього циклу є значення клітинки 1, встановлене на 51 в кінці циклу (6 * 8 + 3).

Ми виходимо з циклу, перестрибуючи U, переміщуючи вказівник пам’яті на комірку 1 і спускаючись потім праворуч по лінії 11 поліглота. І нарешті, ми збільшуємо значення до значення ascii для 4, а потім зменшуємо до значення ascii для 0, перш ніж бігти праворуч, щоб закінчити програму.

Сітківка

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

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

Кардинал

Мені випадково подобалося розміщення @ SnoringFrog Minimal-2D щодо коду Кардинала. Це гарне місце, враховуючи, що Кардинал не засмучує Retina, і, здавалося, це дозволило переплестися з Minimal-2D. Тож коли я вирішив пересадити Minimal-2D на 2D землю, я привів кардинала на поїздку. У Кардинала було кілька косметичних змін. По-перше, я кинув >майже на початку своєї заяви #p x%>~~~+ +~*ttt*.xдля Minimal-2D, щоб змінити покажчики пам’яті в її циклі / По-друге, я перемістив все на один символ праворуч, щоб дати мінімальній 2D-кімнаті, щоб вийти з циклу витончено. У pцьому жалі для цього персонажа прокладка.

Befunge / 98

Справді, Befunges - це те, де я почав намагатися переграти поліглот, оскільки рефактор C ++ змінив усі інші 2D-язикові коди, крім цього. Намагаючись дізнатися, що WTF відбувається в цьому коді, я знайшов це в документації на Begunge:

.Команди з'явиться значення з стека і виводити їх у вигляді десяткового цілого числа, а потім пробіл , кілька як Форт. ,з'явиться значення, інтерпретує його як значення ASCII символу та виведе цей символ ( не супроводжується пробілом. )

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

Befunge-98 також мав команду ( ') взяти код ascii наступного символу. Отже, '1,бере код коду asci для символу 1, ставить його в стек і потім друкує символ ascii для найвищого значення на стеку з, . Просто потрібно зробити це двічі, щоб надрукувати 11 і випустити qграціозно, щоб вийти.

Налаштування Befunge трохи менш зручно, але тільки справедливо. Тут ми повинні виконати обчислення, щоб поставити потрібний код у стек. На щастя, наші коди були легко помножені з 7 * 7 і 6 * 8 перед тією ж командою виводу ,. Тоді ми виходимо з Бефунджа@ тим, щоб код його старшого брата забруднив вихід.

Мінколанг

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

> <>

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

Perl6

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

Виправлення помилок

05as1e

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

Вир

Зміни Befunge на лінії 2 додали додаткового 1поліглоту до лінії Incident / Whirl. Це додатково 1змусило Whirl почати вказувати на неправильні вказівки на колесі. Першою 1в директиві препроцесора C / C ++ була лише посилання на номер рядка в коді, і це могло так само легко бути будь-яким іншим номером рядка, тому я довільно змінив це, 4щоб задовольнити Whirl.

Інцидент

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

Інші

У шестикутниках, пробілах та прелюдіях всі мали звичайні незначні корективи, але нічого особливого не варто говорити.

Фінальні думки

Це все, що я маю за цю відповідь. Для тих, хто шукає вихідного пункту для наступної відповіді, я б запропонував зло. Це здається працездатним, хоча я не надто уважно придивився до цього, але я підозрюю, що інтегрувати його було б не надто важко. Я знаю, що в ньому є команда стрибка, яка повинна допомогти пропустити повз основну частину поліглоту. Удачі.

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
• Натисніть кнопку завантаження

Функція, яка друкує один char на консоль ( 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)даний момент ( звідси ). Спочатку я використовував це для позбавлення #, але зараз він використовується через коротший код. Раковини можуть містити, #тому що лусочки є перед снарядами.

Yash (166) використовує вбудовану команду echo, яка не підтримує параметри за замовчуванням, так що "-n" та linefeed в кінцевому підсумку є частиною виводу, що дає додаткові 4 байти. Якщо не встановлено ECHO_STYLEзначення за замовчуванням на SYSV( -nопція не приймається).

Це посилання TIO перевіряє код у всіх оболонках.

Додатково (((((до того, як снаряди зафіксують Underload та Retina. Ще одна пара паронів додається, щоб сховатися 58від Prelude (закрито #)після після exit). {раніше ((((((- для Джапта, без нього Джапт висить.

Пластівці

Завдяки переїзду Flaks стартовий код можна спростити - залишається лише ([]):

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

Це посилання TIO тестує код у всіх Flaks.

Fission & Cardinal

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

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

MarioLANG

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

Мінімальний-2D

Поліглот з MarioLANG:

Wierd & 1L_a

Wierd: використовуйте простір у рядку 10 рядка 10 для відображення 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]]]*****|!

Зрештою, стек множення містить один нуль, оскільки спливаючий з порожнього стека дає нуль. Цей нуль додається до основного числа з +наступним @. Раніше це було відкинуто ?, див. Відповідь Кляйна 001 .

Як працюють двері в Кляйн:

Вир

Код вир в основному той самий, лише зміна полягає в тому, що основний код передбачає, що поточна операція - ops.one (2), а не ops.load (4).

Ефективно Вир можна вважати виконанням 3 операцій:

• 1 обертати один крок
• 0 напрямок обертання перемикача
• 00 виконати поточну інструкцію та переключити кільце

Комбіновані операції для спрощення міркувань щодо програми:

• 0000 якщо поточний оп неактивного кільця є noop, просто виконайте поточний оп активного кільця без побічних ефектів
• 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 s
• додайте / видаліть достатньо 1s, поки Whirl знову не працює; додавання n 1s еквівалентно видаленню 12-n 1s і навпаки

Я несвідомо порушив перше правило, коли додав Ропі. При наявності непарного числа 0s основний код починає виконуватись з неправильним напрямком дзвінка ops, що порушує інструкцію виходу. Тож тепер є 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. Pyth (159 байт)

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

Примітка: після третього рядка та після останнього рядка є ESCбайт ( 0x1B) .oj

Це було досить веселе враження. Japt і Pyth - обидві мови, але Japt є інфіксом, Pyth - префіксом, і Pyth автоматично запитує введення та помилка, якщо аргументи відсутні.

Перед відповіддю #на стовп сіна у мене було майже працююче рішення , яке отримує char код у Japt та циклічно-до помилки в Pyth. Pyth, здається, дуже корисний у поліглотах, оскільки загальна характеристика коментарів# по суті працює як глушник помилок.

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

Це малоймовірно, що це буде оптимально, але поки що це досить добре. Я спробував перевірити їх усіх, але дуже вдячний, щоб хтось перевірив, чи відповідають результати.

Друкує 1 у Python 3 , 2 у V , 3 у Minkolang , 4 у> <> , 5 у Python 2 , 6 у Self- Modifying 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"

Перший цикл закінчується спробою оцінити, ;що не є дійсним виразом. Тоді Pyth просто друкує 16.