Este es un desafío de encadenamiento de respuestas en el que cada respuesta se basa en la respuesta anterior. Recomiendo ordenar el hilo por "más antiguo" para estar seguro sobre el orden en que se realizan las publicaciones.

Nota : Esto se ha convertido en un desafío bastante duradero, y publicar nuevas respuestas es bastante difícil. Como tal, ahora hay una sala de chat disponible para este desafío, en caso de que desee asesoramiento sobre una parte particular de una posible respuesta, tenga ideas para los idiomas que podrían agregarse o similares. ¡No dude en venir si tiene algo que preguntar o decir!

La tarea

El n º programa que se presentará debe ejecutar en n diferentes idiomas; específicamente, todos los idiomas agregados en los programas anteriores que se enviarán, más uno más. El programa debe generar 1 cuando se ejecuta en el primer idioma utilizado en las respuestas a esta pregunta, 2 cuando se ejecuta en el segundo idioma, y ​​así sucesivamente. Por ejemplo, la primera respuesta podría imprimir 1 cuando se ejecuta en Python 3, y la segunda respuesta podría generar 1 cuando se ejecuta en Python 3 y 2 cuando se ejecuta en JavaScript; en este caso, la tercera respuesta tendría que generar 1 cuando se ejecuta en Python 3, 2 cuando se ejecuta en JavaScript y 3 cuando se ejecuta en algún otro idioma.

Reglas adicionales

• Su programa debe ejecutarse sin errores o fallas. Las advertencias (y otras salidas stderr) son aceptables, pero el programa debe salir normalmente (por ejemplo, ejecutando el final del programa o mediante un comando como el exitque realiza la finalización normal del programa).

• El resultado debe ser solo el entero, pero las líneas nuevas finales están bien. También se permite otra salida stdout inevitable. Ejemplos: nombre y versión del intérprete en Befunge-93, espacio después de la cadena impresa en Zephyr. Algunos idiomas proporcionan dos métodos de impresión: con y sin espacio final; en este caso se debe usar un método sin espacio final.

• Cada respuesta no debe tener más del 20% o 20 bytes (lo que sea mayor) más larga que la respuesta anterior. (Esto es para evitar el uso de idiomas como Lenguage, que genera spam en el hilo, y para fomentar al menos una pequeña cantidad de golf).

• Se permite el uso de diferentes versiones del mismo idioma (aunque obviamente tendrán que imprimir diferentes números, por lo que deberá ajustar una verificación de versión en el políglota). Sin embargo, no puede usar una función de idioma que devuelva el número de versión del idioma. Obviamente, repetir el mismo lenguaje es imposible (ya que el programa tendría que imprimir de manera determinista uno de dos números diferentes).
• Trucos como el abuso excesivo de comentarios, a pesar de estar prohibido en algunas competiciones políglotas, están bien aquí.
• No tiene que usar las respuestas anteriores como guía para escribir las suyas (puede reescribir todo el programa si lo desea, siempre que cumpla con las especificaciones); sin embargo, basar su respuesta principalmente en una respuesta previa está permitido y probablemente sea la forma más fácil de encontrar una solución.
• No puede enviar dos respuestas seguidas. Deje que alguien publique en el medio. Esta regla se aplica hasta que se cumpla la condición de victoria.
• Como este desafío requiere que otros competidores publiquen en los mismos idiomas que usted, solo puede usar idiomas con una implementación gratuita (como si fuera un concurso de policías y ladrones ).
• En el caso de que un idioma tenga más de un intérprete, puede elegir cualquier intérprete para cualquier idioma dado siempre que todos los programas que se ejecutan con éxito en ese idioma lo hagan en ese intérprete. (En otras palabras, si un programa funciona en más de un intérprete, las publicaciones futuras pueden elegir cualquiera de esos intérpretes, en lugar de una publicación que "bloquee" una elección particular de intérprete para un idioma).
• Este desafío ahora usa las nuevas reglas PPCG sobre la elección del idioma : puede usar un idioma o un intérprete de idiomas, incluso si es más nuevo que la pregunta. Sin embargo, no puede usar un idioma / intérprete que sea más nuevo que la pregunta si a) el idioma fue diseñado con el propósito de poliglotación ob) el idioma fue inspirado por esta pregunta. (Por lo tanto, es casi seguro que los lenguajes de programación prácticos de nuevo diseño estarán bien, al igual que esolangs no relacionados, pero están prohibidas cosas como A Pear Tree , que se inspiró en esta pregunta). Tenga en cuenta que esto no cambia la validez de los idiomas diseñados para poliglotaciones que son más antiguas que esta pregunta.
• Tenga en cuenta que la condición de victoria (ver más abajo) está diseñada de modo que romper la cadena (es decir, hacer que sea imposible que otra persona responda después de usted mediante el uso de un idioma que es difícil de poliglotar con otros idiomas) lo descalificará para ganar. El objetivo es continuar todo el tiempo que podamos, y si quieres ganar, tendrás que respetarlo.

Formato de respuesta

Como todas las respuestas dependen unas de otras, será útil tener un formato de respuesta consistente. Recomiendo formatear su respuesta de una manera similar a esta (este es un ejemplo para el segundo enlace de la cadena):

2. JavaScript, 40 bytes

(program goes here)

Este programa imprime 1 en Python 3 y 2 en JavaScript.

(si desea explicar el programa, las técnicas de poliglotación, etc., colóquelas aquí)

Condición de victoria

Una vez que no haya habido nuevas respuestas durante 14 días, el ganador será quien publique la segunda respuesta más reciente, es decir, el políglota más grande que se ha demostrado que no ha roto la cadena. Sin embargo, extender la cadena después de eso sigue siendo muy bienvenido.

El ganador es Chance , ver respuesta 194 (TemplAt) .

Lista de idiomas

// 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>

Nota: Si ve esto primero, es posible que desee ordenar por más antiguo

17. Julia (128 bytes)

#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

Hay dos ESC en la última línea, una antes de la primera gy otra después de la 2. Esto podría jugarse más, pero las cosas se complicaron, no gracias a V y Pyth.

Imprime 1 en Python 3, 2 en V, 3 en Minkolang, 4 en> <>, 5 en Python 2, 6 en SMBF, 7 en Japt, 8 en Retina, 9 en Perl, 10 en Befunge-93, 11 en Befunge -98, 12 en Fission, 13 en Ruby, 14 en Turtléd, 15 en Haystack, 16 en Pyth y 17 en Julia .

Consejos:

• El comienzo de la cuarta línea es Python 2/3, Perl, Ruby. El final es Julia, gracias a los #=comentarios multilínea (tenga en cuenta que Julia no tiene and/or).
• V es <ESC>gg99ddi2<ESC>, lo que definitivamente es golfable pero V es molesto para probarlo. ¡ Pruébelo en línea! ya que el intérprete es bastante lento.
• Minkolang y Haystack caen al principio v. Befunge-93 y -98 no lo hacen, y dependen de a b.
• Retina cuenta el número de espacios y 1s en la cuarta línea, y V se esconde en la configuración de Retina (es decir, antes del backtick).
• Según la sugerencia de @ ETHproduction, Japt usa backticks para ocultar la mayoría del código en una cadena.
• La fisión es R"12"*.
• SMBF ha sido jugado <.en la primera línea, más la final 6.

23. Hexagonía , 186 bytes

Lo siento si esto arruina los planes ...

#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

␛ se usa para representar un carácter ESC literal.

Huellas dactilares:

23 en Hexagony , 22 en Underload, 21 en Nim, 20 en Prelude, 19 en Reng (comprobable aquí ), 18 en Cardinal, 17 en Julia, 16 en Pyth, 15 en Haystack, 14 en Turtlèd, 13 en Ruby, 12 en Fisión, 11 en Befunge-98, 10 en Befunge-93, 9 en Perl, 8 en Retina, 7 en Japt , 6 en SMBF, 5 en Python 2, 4 en> <>, 3 en Minkolang, 2 en Vim / V , y 1 en Python 3.

Para acceder a los idiomas no vinculados, haga clic en el change languagebotón en la esquina superior derecha del enlace Hexagony.

La hexagonía no es legible (en absoluto) en este formato. Necesitamos mirarlo en forma hexagonal.
Tenga en cuenta que los 2 caracteres ESC se han reemplazado con ␛s para que pueda verlos; se ignoran, por lo que no hay otros en el programa:

        # 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

Para aquellos que no están familiarizados con Hexagony , hay 6 IP, que comienzan en las 6 esquinas. Solo 1 está activo a la vez, y se cambian mediante el uso #][. El modelo de memoria no es tan importante para este programa, pero podría ser necesario entenderlo en el futuro. Todo lo que necesita saber es que 1 int está almacenado en un "borde de memoria" (ME para abreviar) y '"}{cambia el ME que está activo.

\/|_>< son espejos que controlan el flujo del programa.

Así es como funciona:

Primera línea ejecutada:

#       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

La parte inferior (fragmento invertido verticalmente para que pueda leer de arriba a abajo):

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

El borde derecho:

        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 !

El último bit de código relevante:

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

Cosas a tener en cuenta:

• Hexagony elimina todos los sys `antes de ejecutar, por lo que cualquier cambio en ellos no afectará a Hexagony
• Necesitaba rellenar el código para que se interpretara como un hexágono de 9 longitudes, en lugar de un octavo: tenga cuidado al jugar golf por debajo de 169 o por encima de 217 caracteres relevantes
• Debido a esto, el ~~~y los 2 0s al final se pueden cambiar sin dañar el código
• El =""solo aleja al ME del anterior para que se pueda modificar un nuevo ME. Se pueden reemplazar con otros personajes que hacen lo mismo sin dañar el programa de hexagonía ( 's, por ejemplo)
• Esto técnicamente no es compatible con las especificaciones de Befunge 93, ya que limita el cuadro delimitador del código a 80 por 25 caracteres. Sin embargo, la mayoría de los intérpretes ignoran esta especificación (como TIO), por lo que personalmente no creo que sea tan importante. Si lo haces, no dudes en dejar un comentario. (Si lo suficiente realmente quiere que lo cambie, entonces lo intentaré)
• Espero que no sea demasiado difícil ahora.

50. bash, 1024 bytes

#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

¿Querer aprender más? ¡Prueba el chat de polygot !

¡Pruébalos en línea!

Como de costumbre, reemplacé las pestañas literales con ␉y los caracteres ESC literales con ␛, debido a las limitaciones de Stack Exchange. Puede obtener una versión del programa fácilmente copiable en el cuadro "entrada" del enlace TIO anterior.

Atropellar

Este programa imprime 50 en bash, 49 en Octave, 48 en Deadfish ~, 47 en Lily, 46 en Cubix, 45 en PicoLisp, 44 en alphuck, 43 en reticular, 42 en mal, 41 en brainf ***, 40 en Minimal -2D, 39 en CoffeeScript, 38 en C, 37 en C ++, 36 en Labyrinth, 35 en INTERCAL, 34 en Rail, 33 en Incidente, 32 en Whirl, 31 en SNUSP modular,30 en Whitespace, 29 en Trigger, 28 en Brain-Flak, 27 en Perl 6, 26 en 05AB1E, 25 en Pip, 24 en Thutu, 23 en Hexagony, 22 en Underload, 21 en Nim, 20 en Prelude, 19 en Reng , 18 en Cardinal, 17 en Julia, 16 en Pyth, 15 en Haystack, 14 en Turtlèd, 13 en Ruby, 12 en Fission, 11 en Befunge-98, 10 en Befunge-93,9 en Perl 5, 8 en Retina, 7 en Japt, 6 en SMBF, 5 en Python 2, 4 en> <>, 3 en Minkolang, 2 en V / Vim y 1 en Python 3.

Verificación

La mayoría de los idiomas son probados por el controlador de prueba anterior. Los cuatro culpables habituales necesitan pruebas por separado:

• El incidente se probó utilizando su intérprete oficial, sin conexión;

• Deadfish ~ también fue probado usando su intérprete oficial, fuera de línea;

• El SNUSP modular se probó en línea aquí ;

• Reng fue probado en línea aquí .

Explicación

Estaba buscando varios leads para idiomas para agregar. Una posibilidad era encontrar un lenguaje con #comentarios de línea que pudieran agregarse plausiblemente a la línea de "lenguaje de scripting" (que maneja Perl, Python 2 y 3, y Ruby). Sin embargo, me tomó un tiempo pensar en un lenguaje apropiado que pudiera ser compatible con la sintaxis con los que ya existen.

Resulta que la respuesta me había estado mirando a la cara durante años. Si hace clic en el enlace TIO anterior, se abrirá el controlador de prueba políglota, que está escrito en bash. Así que todo este tiempo, tuve una pestaña que decía "Bash - TIO Nexus". Hubieras pensado que sería una pista, pero aparentemente lo extrañé. Como beneficio adicional, bash también es un lenguaje de script, por lo que el término "línea de lenguaje de script" sigue siendo apropiado.

El programa bash comienza en el mismo lugar que los otros lenguajes de secuencias de comandos. Sin embargo, hay una forma bastante simple de separarlo de ellos; en cadenas entre comillas simples, \es un carácter de escape en la mayoría de los idiomas, pero no en bash. Entonces, podemos ocultar el código bash de los otros idiomas a través de '\'…';, que es una declaración degenerada (sin efecto) en Perl, Python y Ruby, pero ejecutada en bash. echo 50;exites una forma bastante simple de finalizar el programa bash. Bueno, casi.

El mayor problema aquí es que bash, al ejecutarse exit, continuará analizando hasta el final de la línea actual (aunque no ejecute el código en cuestión), por lo que debemos asegurarnos de que no haya errores de sintaxis en el resto de la línea. Tenemos un 'justo después exit;que no es (y no puede ser) inmediatamente igualado. Más adelante en la línea, '…'se usa para ocultar un código Brain-Flak de los lenguajes de script, pero eso lo ocultaría de bash. Como resultado, necesitamos cambiar qué tipo de literal de cadena estamos usando para ocultar el código, pasando de cadenas de comillas simples a comillas dobles. or"'"hace el truco sin molestar a Perl, Python o Ruby (ya que el argumento de la izquierda es verdadero en todos los casos).

Ahora tenemos una comilla doble sin igual que se extiende a una línea futura. Fue bastante difícil cerrarlo sin molestar al menos otro idioma; lo que realmente hacemos es cambiar la forma en que ocultamos el código de bash de una comilla doble a una comilla simple sin igual en un comentario de Python / Ruby en la línea siguiente, y finalmente cerrar la comilla simple al final de la línea después de eso.

Pyth y 05AB1E

Jugar con comillas dobles también perturba los idiomas que usaban cadenas de comillas dobles para ocultar el código, Pyth y 05AB1E. El truco principal que usamos aquí es asegurarnos de que cada comilla doble que agreguemos tenga otra comilla doble poco después para exponer la menor cantidad de código posible. (Esto explica la doble comilla extra en la __DATA__línea, que no es necesaria para bash). Pyth usa \como carácter de escape; El resultado principal de esto es que limitaba el alcance que tenía para jugar con las cadenas en los lenguajes de scripting, obligándome a usar el método bastante complicado anterior (ya que no podía usar fácilmente la diferencia de \comportamiento entre bash y todo más). En 05AB1E, 'actúa como un personaje de escape afueracuerdas, y hacer que se escape el líder "no funcionaría. Así que terminé necesitando colocar un carácter de relleno inútil (predeterminado a mi habitual x; ¡hace que las cosas sean más fáciles de leer!) Dentro de las "'"construcciones que se usan para cambiar entre los estilos de comillas bash.

Preludio

Con mucho, el idioma más difícil de arreglar aquí. El problema es que la línea de secuencias de comandos, con todos sus paréntesis, se movió hacia los lados y, por lo tanto, el flujo de control Prelude (que se preocupa mucho por la forma en que los paréntesis se alinean verticalmente) se destruyó por completo. Por lo tanto, tuve que intentar reconstruir algo que funciona.

Peor aún, la primera línea actual (que realmente no quería reescribir) coloca un límite difícil sobre dónde pueden aparecer los paréntesis. Comienza con un dígito distinto de cero (¡dos de ellos, de hecho!), Y pronto es seguido por un paréntesis de apertura. Eso es un bucle en Prelude, y los bucles al principio del flujo de control en Prelude causan una serie de problemas diferentes (principalmente porque hacen que se ejecute más código, en lugar de menos). Como tal, necesitaba abrir un ciclo de 0 iteraciones en alguna otra línea para omitir ese código. La mainlínea para el programa C es muy adecuada, pero debemos tener mucho cuidado con la ubicación del corchete de cierre correspondiente; demasiado a la derecha y el soporte incomparable en el#R+la línea causará problemas, demasiado a la izquierda y no comentará suficiente código. (Tenga en cuenta que un paréntesis de apertura en una línea puede coincidir con un paréntesis de cierre o una línea diferente).

Una vez hecho esto, tenemos el espacio suficiente para pegar en un paréntesis de apertura en la línea de Incidentes, y finalmente hemos superado con seguridad los primeros caracteres del programa. Sin embargo, la diferencia en las ubicaciones de paréntesis termina significando que parte del código de Incidente / Remolino realmente se ejecuta en Prelude, corrompiendo la pila. En lugar de tratar de evitar esto, moví algunos de los ceros de Whirl más hacia la derecha, lo que les permitió volver a darnos un programa Prelude en funcionamiento.

Otro pequeño cambio fue en la primera línea del programa; el paréntesis final de la línea estaba en una posición que era muy difícil de evitar. cAgregué un extra justo después del código Pyth para desplazarlo a la derecha. (¡Muchos idiomas están analizando ese punto del programa, por lo que tomó una cantidad sorprendente de prueba y error encontrar un carácter de relleno que no rompa al menos un idioma!)

Incidente

Prelude fue bastante difícil por sí solo, pero hacer que Prelude e Incidente funcionen al mismo tiempo fue una pesadilla. Prelude impuso muchas restricciones en el código que me impidieron mover cosas libremente y, por lo tanto, dificultó la construcción de fichas accidentalmente. Por ejemplo, Prelude solo necesita que uno se 0mueva hacia la derecha, pero eso se 00convirtió en un token fallido, rompiendo algunos de los tokens que queríamos como parte del programa de Incidentes (porque si dos tokens se superponen, ambos son rechazados, y el 00se solapan una ficha que queríamos, además de la superposición de sí mismo). Tuve que mover ambos para hacer una cuarta copia y evitar que se considerara como un token.

Más sutiles son las fichas ;'y ␠␠(es decir, dos caracteres de espacio). El problema es que ambos aparecen antes de lo kGque se está utilizando para saltar al inicio del programa y, por lo tanto, interrumpirán el flujo de control del incidente (además de romper el punto central del programa).

Eliminar una copia de ␠␠dividiéndolo no parece viable. Puede ser posible eliminarlo mediante la superposición ( ␠=es una superposición potencial prometedora), pero es casi seguro que sea menos detallado simplemente agregar una cuarta copia, que es lo que hice aquí.

Mientras tanto, podemos usar un truco diferente para ;'. Romperlo no es algo que quisiera probar, dado que se usa en situaciones bastante sensibles al espacio. Sin embargo, no es que cerca del comienzo del programa (a pesar de que aparece en la primera línea), por lo que es plausible que podríamos saltar sobre él (haciendo así que no afecta el flujo de control) en lugar de tener que no existe. Busqué un token adecuado para el salto que no arruinara ninguno de los otros idiomas. /vaparece un poco antes en la primera línea, y no rompe nada, y eso es lo que usé.

50 idiomas en 1 Kib de código

@MistahFiggins señaló que mi envío de 1025 bytes sería mucho más ordenado si tuviera 1024 bytes (especialmente porque el quincuagésimo idioma es un hito por derecho propio). Esto requería encontrar un byte de ahorro en alguna parte. En este caso, guardé tres bytes en el Deadfish ~, a costa de dos bytes adicionales utilizados para hacer que los tokens de Incidentes se alineen correctamente, y así el programa bajó a 1024 bytes exactamente.

Anteriormente, la fórmula que utilizaba el código Deadfish ~ era (2² + 2) ² + 10 × 1 + 2 = 48. La nueva fórmula es (3²-2) ²-1, que también produce 48. Sorprendentemente, no es eso mucho más corto de escribir en Deadfish ~, a pesar de ser considerablemente más simple.

Esto también nos da un puntaje VIP de .008192. Este no solo es un nuevo registro, sino que también es un número muy bien redondeado en sí mismo (lo cual es, obviamente, una consecuencia de tener buenos números redondos como entradas para la fórmula).

37. C ++ (gcc), 776 bytes

#  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

␉es una pestaña literal, ␛un carácter ESC literal; Stack Exchange destrozaría el programa de otra manera. Recomiendo copiar el programa desde el cuadro de "entrada" del enlace TIO a continuación, si desea trabajar en él.

¡Pruébalos en línea!

Atropellar

Este programa imprime 37 en C ++, 36 en Labyrinth, 35 en INTERCAL, 34 en Rail, 33 en Incidente, 32 en Whirl, 31 en SNUSP modular, 30 en Whitespace, 29 en Trigger, 28 en Brain-Flak, 27 en Perl 6 , 26 en 05AB1E, 25 en Pip, 24 en Thutu, 23 en Hexagony, 22 en Underload, 21 en Nim, 20 en Prelude, 19 en Reng, 18 en Cardinal,17 en Julia, 16 en Pyth, 15 en Haystack, 14 en Turtlèd, 13 en Ruby, 12 en Fisión, 11 en Befunge-98, 10 en Befunge-93, 9 en Perl 5, 8 en Retina, 7 en Japt, 6 en SMBF, 5 en Python 2, 4 en> <>, 3 en Minkolang, 2 en V / Vim y 1 en Python 3.

Verificación

La mayoría de los idiomas son probados por el controlador de prueba que se muestra arriba. Puede probar Reng aquí y Modular SNUSP aquí ; producen 19 y 31 respectivamente, según sea necesario.

Agregué otro formato a la salida del controlador de prueba que escapa a las comillas dobles, así como a hacer reemplazos de avance de línea. Esto es para que pueda alimentar la cadena de línea única al programa ac (gcc) que envolví alrededor de la función creada por @feersum aquí . Esperemos que otros puedan usarlo tal como está.

Aquí está el programa de token de incidentes . Idealmente, me gustaría delimitar los tokens, ya que son un poco difíciles de leer, indicar el token "central" e incluirlo en el controlador de prueba. Pero realmente no sé cómo hacer otra cosa que no sea hacer que varios programas impriman enteros secuenciales, así que esto es lo que he llegado.

Intenté resolver los problemas obvios del Incidente, como las fichas después del comienzo y las fichas de salto final y cualquier cosa que pareciera extraña, pero no he equilibrado las fichas para ponerlas 0oen el centro. No estoy realmente seguro de cuál es la lógica exacta para determinar el centro. Espero que @ ais523 ayude allí. Esta cadena cerca del final 7LEintndus({})!<>+serían tokens si no fuera por esta cuarta inclusión en el código. Todos estos se pueden eliminar (y reemplazar con una .alineación de Hexagony) para ajustar la ficha central.

Voy a actualizar esta publicación de vez en cuando durante el siguiente día o dos para recorrer el código (suponiendo que el Incidente se pueda verificar / corregir sin pasar por el conteo de bytes). Pero ahora es muy tarde, y sobre todo quería sacar esto a la luz antes de tener que resolver otro problema similar al Laberinto. :PAGS

Explicación

Cómo funciona el código C ++.

Creo que la mayoría de las personas están lo suficientemente familiarizadas con C ++, por lo que no entraré en demasiados detalles. Los comentarios de bloque vienen en forma de /* comment */. Los comentarios de línea vienen en forma de //comment. El código real utilizado por C ++ para producir la respuesta es int main() {std::cout<<37;}. Y esta biblioteca hace referencia a la biblioteca que se usa para interactuar con STDOUT #include<iostream>.

/ * Comentarios Abuso * /

Para mí, la historia de C ++ se remonta a mi respuesta Brain-Flak.

Después de finalmente encontrar el n. ° 28, me propuse estudiar algunos otros políglotas publicados en PPCG y todo ese estudio me llevó a algunas respuestas fáciles (la mayoría de estas aún están disponibles si alguien más está tan dispuesto). Pero lo más importante, llegué a una conclusión sobre los políglotas en general: los políglotas grandes tienden a caer en una de dos categorías amplias: #abuso de /*comentarios o abuso de comentarios.

Esto no es un hecho o una restricción de todos modos, sino un marco mental personal que guió mis próximas respuestas.

A partir de aquí, razoné que si se convirtiera en el políglota más grande del mundo, lo que supongo que es actualmente, sería mejor si pudiera aprovechar el abuso de comentarios de ambas familias de comentarios. Así que me propuse encontrar una manera de incorporar un /*lenguaje de comentarios y empujé hacia la familia C debido principalmente a una familiaridad personal.

Prueba inicial de C ++

Mi proceso de pensamiento inicial para esto fue usar C # principalmente debido a mi familiaridad y el primer obstáculo para C # fue llevar el políglota a un estado en el que pudiera aceptar una línea que no comenzara #sin ser tratado como código por los lenguajes de secuencias de comandos . La respuesta de Rail, junto con varias respuestas de inflado de bytes que conducen a ella, resolvió esta pieza.

Luego vino el problema de cómo iniciar el primer /*bloque de comentarios. Sabía que la línea tendría que comenzar con una línea #para permanecer invisible para Perl, Ruby y Python, pero lo que sucediera antes /*sería leído por C #. Al #regionprincipio intenté con una etiqueta C # , pero resultó ser demasiado complicada para los lenguajes 2D. Ingrese C ++.

C ++ tiene varias directivas de preprocesador con las que todos comienzan #, que brindan muchas opciones para que atraviesen los lenguajes 2D. Pero resultó que todos ellos eran incompatibles con al menos un lenguaje, y al estar en un espacio de código expuesto en C ++, tenía soluciones alternativas limitadas. Por frustración y desesperación, me topé con el hecho de que C ++ simplemente aceptaría solo uno #antes del bloque de comentarios. Bien, lo que sea, eso es viable. Así que seguí adelante con la presunción de que #/*podrían funcionar como los primeros tres caracteres en el políglota.

La segunda parte de la verificación básica fue garantizar que la declaración impresa real pudiera vivir felizmente con los otros códigos. Sabía por la respuesta de Brain-Flak que a Japt no le gustaban los que no se escaparon {y que era necesario que C ++ dijera int main() {std::cout<<37;}y C ++ no permitiría el carácter de escape de Japt en el medio de su código. Esta vez tuve la suerte de descubrir que si abandonaba la cadena literal de Japt solo por esta declaración, Japt seguiría felizmente produciendo el mismo resultado.

Mientras tanto, a Brain-Flak tampoco le gustó {}, pero nuevamente tuve la suerte de encontrar que C ++ estaba bien con un #entre int main()y sus {std::cout<<37;}declaraciones, lo que permite que las llaves se comenten desde la perspectiva de Brain-Flak.

Entonces, con los problemas principales de C ++ demostrados como teóricamente solucionables, comencé el arduo proceso de resolver todos los errores que había introducido.

Paisaje 2D

La parte más difícil de esta respuesta fue, con mucho, la reconfiguración de las dos líneas superiores del políglota. Y el problema más significativo fue el *. La carga insuficiente no permitirá a *antes de a (. Considera esto como una operación matemática en una pila vacía, que considera un error. Por lo tanto, el políglota requería un (previo /*pero el C ++ no podía permitir esto. Entonces, la solución fue para nosotros un comentario de línea C ++ //en la primera línea para ocultar ay (luego comenzar la segunda línea con a #/*.

A continuación, a Befunge realmente no le gustó la idea de un /sin algo dividido, pero después de estudiar la respuesta existente de Begunge, 16/"<"6/b.q@me topé con la idea de un número y una cadena se unió delante del //. Funcionó y no tengo idea de por qué C ++ está bien con esto, pero acepta # 1"16" 2como su declaración de apertura. No voy a cuestionarlo, pero sí sé que se requieren los espacios para que funcione.

Línea uno

Japt resultó ser bastante sensible al espacio y realmente no quería entrar en su cadena basada en backtick en la línea superior, por lo que él y el backtick de Pip se movieron a la segunda línea, lo que obligó a una gran cantidad de gimnasia lingüística en la línea 1.

• A Pip no le gustó la mayor parte de la línea 1, por lo que se colocó un segundo espacio después del primero #para indicar un comentario.
• El (para Underload tuvo que escapar de Japt con un precedente \.
• #es un terminador de salto en Turtlèd, por lo que fue necesario, pero Pyth considera que es un ciclo de terminación de error, por lo que Pyth necesitaba una división entre nulo / después del#
• Ya no estoy seguro de lo @que está haciendo en la primera línea, pero a Pyth y Japt parece gustarles más su presencia, aunque @no es un personaje significativo según la documentación de Pyth.
• Y parece que el primero ;se puede eliminar en este punto sin consecuencias, por lo que ya no estoy seguro de lo que se estaba resolviendo allí, aunque sospecho que estaba relacionado con Pyth. Pero parece que las soluciones futuras pueden salvar un byte al omitirlo.
• <> <y Turtlèd básicamente funcionan igual que antes con <> <reflexionando sobre el primero #y envolviendo al final de la línea uno. Y Turtlèd salta con lo #que mencioné y termina con el "14"hilo que imprime.

Enrutamiento 2D

Con estos problemas resueltos, la siguiente fase fue enrutar los lenguajes 2D. Anteriormente los vBefunges ignoraron la inicial debido a lo anterior #, pero enviaron a Haystack y Minkolang. Ahora, el espacio inicial intenta enviar Minkolang a lo largo de la tercera dimensión, a lo que su documentación se refiere como la dimensión del tiempo.

Rápidamente a un lado en la tercera dimensión de Minolang: para mí es una especie de nombre inapropiado llamar a esto una dimensión temporal, realmente me parece más espacial que temporal. Realmente no lo entendí hasta que encontré este enlace que ilustra el concepto, y parece más como las múltiples capas de un tablero de ajedrez 3D. Creo que así es como generalmente funcionan los lenguajes 3D. Pero como este era un concepto nuevo para mí, pensé en tirar esta información a otros.

Así múltiples capas de Minkolang están delimitados por líneas que terminan en $$$el que tiré en el extremo del carril código aquí: #-3o4o#$$$. Ahora, Minkolang golpea el espacio y cae al primer >lugar <>3N.<> ␉//y pasa a la salida correcta 3. #>no se puede permitir que comience esta línea porque intentaría terminar un bloque de comentarios Perl6, por lo que <se usa en lugar de #equilibrar SMBF y Brain -Reproches. Sin embargo, este es un procedimiento de intercambio de apilamiento de Brain-Flak, por lo que <>se utiliza un segundo conjunto después de que Minkolang termina para volver a la respuesta correcta de Brain-Flak.

De manera similar, Labrynth choca contra el espacio, pero hace que Labrynth se mueva hacia abajo en la columna 1. Luego baja la línea 2, donde viaja hasta llegar a 3otra pared, lo que hace que gire hacia el sur nuevamente y golpea una ;que hace que el 3 salte. . Luego, el programa continúa hacia la derecha donde 36 se almacena e imprime, antes de finalmente encontrar una @salida. Esta ruta es más larga de lo necesario, pero descubrí que Prelude generaría un byte nulo antes de su salida normal 20 si !estuviera más a la izquierda de lo que está ahora, independientemente de la línea que aparezca. Así que lo hice más correcto, porque tenía el espacio para hacerlo.

Luego, la ruta de Haystack cambió porque /ahora es anterior a la vlínea 1 y refleja su camino hacia arriba como Reng. Afortunadamente, Reng convive en paz. El único inconveniente fue que la aguja de Haystack |era un reflector en Reng, por lo que un Reng usa un salto como Befunge ( #) sobre la aguja para concluir Reng correctamente.

Los Befunges continúan a lo largo de la línea 1 hasta que vse dirigen hacia abajo y luego hacia la derecha en la segunda línea para concluir con el mismo código utilizado anteriormente. Mi sensación es que esta pieza se puede jugar un poco ahora que hay menos idiomas que intentan atravesar el código de manera significativa, pero no necesitaba más paredes para golpear mi cabeza, así que lo dejé como está.

Finalmente, el punto de partida de Cardinal es %que no tenía ninguna necesidad particular de agruparse en las dos líneas superiores ya densas. Así que lo bajé a la cuerda de Python. Sus múltiples rutas de código ahora también están delimitadas por x's, que finaliza el movimiento de su puntero.

Lineas 2 y 3

El único cambio significativo aquí es que todos :se jugaron por una razón u otra. Tal vez las (necesidades de Prelude o tal vez fueron simples problemas de conteo de bytes, probablemente ambos. La otra cosa es que el código de salto del disparador se movió hacia atrás y se renombró como auaaZ. Tenía espacio para llenar para encontrar la ruta del código de Befunge y esto parecía lo mejor. También lo <siguiente de esta pieza es para equilibrar los seguidores de SMBF >. Finalmente, el solitario ”cerca del final de la segunda línea debe mantener la cadena 05AB1E. Además, yyen la línea 3 hay solo caracteres de relleno para Labyrinth.

The Big String Esolangs

Con las dos primeras líneas resueltas, era hora de comenzar a profundizar en los esolangs de análisis más completo, y Pip resultó tener un problema. Si recuerdas, lidiamos con las llaves {std::cout<<37;}al salir de la cadena de Japt para dejar que Japt trate esto como un código. Bueno, Pip está usando la misma sintaxis de cadena y no le gustó esta línea como código y Pip tiene opciones de declaración de cadena muy similares a las de Japt. Ambos usan un solo 'para declarar una cadena de un carácter, ambos usan la misma declaración de escape \y ambos aceptarán "como identificadores de cadena. Así que fue difícil hacer que Pip creyera que esto era una cadena sin hacer que Japt creyera lo mismo.

Sin embargo, resultó que Japt tenía una diferencia explotable: #toma el valor ascii del siguiente personaje. Entonces, #"`terminará la cadena Japt / pip, luego le dirá a Japt que tome el valor asci de ", mientras le dice a Pip que comience una nueva cadena. El "probablemente podría haber sido un lugar de acento grave, y probablemente habría sido mejor, pero mi línea de pensamiento era utilizar un identificador de cadena diferente en el interior como otro punto de la manipulación de cadenas. Así que aquí hay otro lugar donde podría guardar algunos bytes más adelante.

Luego, tuve que iniciar la cadena Japt después de las llaves mientras permitía que Pip permaneciera en una cadena. Hice esto con '"`una comilla simple, una comilla doble y un backtick. Para Japt, el 'no está en una cadena y, por lo tanto, es un indicador para tomar el siguiente carácter como una sola cadena de caracteres. Pip ve el 'como parte de la cadena y termina su cadena con el ". Y finalmente, `indica a Pip y Japt que está comenzando otra cadena que continúa a lo largo del políglota hasta la última línea donde ambos idiomas se completan felizmente.

Ahora, tanto Japt como Pip funcionaron en este punto, pero 05AB1E falló debido a que el uso de "causó algún error al inducir la exposición del código. Afortunadamente, este fue lo suficientemente fácil de resolver colocando otro conjunto de "todo alrededor, dejando el conjunto de manipulaciones de cadena como "`#"\\'*/{std::cout<<37;}/*'"`".

Finalmente, con la línea que ahora se ve así, con la int main() #/*"`#"\'*/{std::cout<<37;}/*'"`"cual Underload tuvo un problema. Los consecutivos *, fueron otro error de sintaxis, así que arrojé uno ()en el medio *para apaciguarlo.

Los frágiles Esolangs

El gran obstáculo ahora era el espacio blanco. No entraré en un montón de detalles aquí porque la mayor parte de la solución de espacios en blanco está integrada en las explicaciones ya dadas, y acabo de pasar por alto los casos en los que los espacios en blanco obligaron a tomar algunas decisiones. Te estoy mirando Laberinto. Sin embargo, el gran cambio es que el código real para generar la respuesta de Whitespace está en la línea 2-4 en lugar de 1-3. Esto se debe en gran parte a la exposición del código de Japt en la línea 1.

Thutu originalmente tenían problemas con lo que había sido esta línea: int main() #/*()"`#"\'*/{std::cout<<37;}/*'"`". Entonces, agregué un salto de línea justo antes del primero #para ocultar todos los problemas detrás de un indicador de comentarios y luego envié un montón de trailers /en todas partes que estaban expuestos a código.

En este punto alineé Hexagony y encontré un nuevo problema. El código en el comienzo mismo, que comenzó su vida como # 1"16" 1hizo la +de /+23!@clara la pila más larga. Entonces, simplemente eliminé el +is y encontré que ahora sale 123. Esto fue bastante fácil de solucionar cambiando el gambito de apertura # 1"16" 2y jugando golf a la pieza de Hexagony /3!@.

Whirl tuvo algunos cambios, pero fue principalmente una cuestión de asegurarse de que apareciera el número correcto de 1 antes de la línea Whirl-Incident. Sin embargo, el incidente tuvo una ficha que fue particularmente difícil. Tenía exactamente 3 copias de /*y */.

Inicialmente quería simplemente tirar *//*cualquier lugar antiguo en el código para crear una cuarta copia de cada uno, pero Underload vio los consecutivos *nuevamente, lo cual fue imposible. Finalmente lancé un /al final de esta línea int main() /*para que terminara /*/, pensando que haría que los tokens se superpusieran, pero solo logré crear 4 copias de uno de los dos tokens. Bien bien. Así funciona eso. Oh bueno, simplemente lanzaré un similar /en la final */para hacer un cuarto allí. Después de esto, reemplacé un montón de no-operaciones hexagonales con una cuarta copia de varias fichas de incidentes en esta cadena en la línea final 7LEintndus({})!<>+.

Conclusión

Ok, ese es todo el detalle que tengo para este refactor masivo. Prometo no tener tanto de qué escribir la próxima vez. De hecho, no tengo idea de si C ++ es una buena o mala opción para este políglota, pero creo que abre algunas opciones. Esperemos que esto lleve a cosas buenas.

Feliz codificación

3. Minkolang v0.15 (26 bytes)

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

Este programa imprime 1 en Python 3, 2 en Vim y 3 en Minkolang v0.15

Espero no estropear las cosas introduciendo un lenguaje 2D

Pruébalo en línea!

Explicación

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

Vim de alguna manera ignora a Minkolang, así que eso es bueno

Y realmente no hubo ningún problema con Python ya que ignora los comentarios #

Próximo...

Para el siguiente idioma, sugiero algo como> <> ya que #actúa como un reflector (para que la dirección cambie a la izquierda y se ajuste completamente a la derecha) para que pueda agregar código que otros idiomas pueden ignorar

5. Python 2 (35 bytes)

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

Este programa imprime 1 en Python 3, 2 en Vim, 3 en Minkolang v0.15, 4 en> <> y 5 en Python 2.

¡Pruébelo en línea beta!

En Python 2, 1/2 es 0, que es un valor falso, lo que hace que Python imprima 5. En Python 3, 1/2 es 0.5, que es un valor verdadero, lo que hace que Python imprima 1.

4.> <> (29 bytes)

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

Este programa imprime 1 en Python 3, 2 en Vim, 3 en Minkolang v0.15 y 4 en> <>

Pruébalo en línea!

Código corrió

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

Otro lenguaje 2D más.

No tiene ningún efecto en Minkolang, ya que agrega caracteres después de que la dirección cambia, Vim lo ignora por alguna razón. #es un comentario en Python, así que tampoco cambien su.

28. Brain-Flak , 280 bytes

#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

␛ representa un carácter ESC literal, como de costumbre.

Este programa imprime 28 en Brain-Flak , 27 en Perl 6 , 26 en 05AB1E , 25 en Pip , 24 en Thutu , 23 en Hexagony , 22 en Underload , 21 en Nim , 20 en Prelude , 19 en Reng (probado aquí ), 18 en Cardinal , 17 en Julia , 16 en Pyth , 15 en Haystack , 14 en Turtlèd ,13 en Ruby , 12 en Fisión , 11 en Befunge-98 , 10 en Befunge-93 , 9 en Perl 5 , 8 en Retina , 7 en Japt , 6 en SMBF , 5 en Python 2 , 4 en> <> , 3 en Minkolang , 2 en Vim / V , 1 en Python 3

En primer lugar, quiero decir qué privilegio es poder contribuir a este desafío. Solo escuché sobre golf de código hace unas semanas y desde entonces he estado absolutamente enganchado. Lo primero que hice cuando encontré este desafío fue intentar ejecutar el código tal como está en varios idiomas solo para ver si podía encontrar algo con lo que pudiera trabajar. Esto fue cuando estábamos en el puesto # 6. Honestamente pensé que este desafío era una locura imposible, pero aquí estamos (# 28 ¡Guau!). Lo que encontré en ese momento fue que Brain-Flak generó el valor 2. Así que me dispuse a aprenderlo.

Brain-Flak resultó ser bastante bueno para este tipo de desafío porque es bastante fácil de aprender e ignora prácticamente cualquier personaje, excepto (){}[]<>. #También sucede comentar cualquier cosa después en la misma línea, por lo que la única parte de la última presentación que se consideró para Brain-Flak fue la print((eval("1\x2f2")and 9 or 13)-(0and 4)^1<<65>>62)que luego se combinó ((())()<<>>). Entonces, el plan comenzó a agregar paréntesis superfluos a lo que he llegado a pensar como el código de Python.

Modifiqué los bits de python para analizar en Brain-Flak, lo ((() () ())()()<<()>>)que equivale a 2 acumulaciones, la primera es 5 y la segunda es 3. Después de eso, cuadraré el 5 con ({({})({}[()])}{})y agregaré el resultado a 3 con ({}{}). Esta cuadratura y adición se realiza en una cadena desde la perspectiva de Python. No puedo decir que entiendo el razonamiento de Python aquí, pero estoy bastante seguro de que esta cadena no está siendo evaluada por otros idiomas de manera significativa, con solo un par de excepciones.

Resulta que Japt interpreta que los corchetes dentro de una cadena contienen código, pero estos fueron lo suficientemente fáciles de escapar \antes de cada uno {en esta cadena. Pero esto aumentó el número de bytes. Así es la vida.

Prelude fue bastante indulgente con todos mis paréntesis. Un comentario anterior señaló que Prelude encajaría con Pparentheses alineadas verticalmente y resultó que solo creé una. ¡Dulce! El (en la línea superior se alineó con el y (9en la línea grande. Así que tuve que agregar un espacio adicional antes (de la línea superior. Mi suposición aquí es que el doble espacio era un indicador de comentario para algo, por lo que agregar un espacio adicional parecía trivial, y funcionó. Debo señalar que intenté agregar espacios adicionales en el (9)lugar, pero Cardinal no cooperó.

A 05AB1E no le gustó mi primer intento de encapsular la cadena de Python entre comillas dobles, pero todos parecían estar de acuerdo en usar comillas simples. No es gran cosa allí.

La hexagonía era el único idioma que quedaba en este punto, y obviamente superaba el siguiente umbral del tamaño del hex, así que era hora de ensuciarme. El /^23!@es el código de Hexagony y estoy muy emocionado porque creo que facilitará futuras adiciones. Básicamente, esta pequeña pieza se puede mover a cualquier parte de la cadena de Python sin reventar ningún código. Esta es la cadena completa solo para que todos estemos en la misma página '(\{(\{})(\{}\/^23!@[()])}\{})(\{}\{})'. El /aquí establece la ruta de Hexagony de SE -> NW a W-> E por esta cadena, que tenemos mucho margen de maniobra con. (Lo anterior \es escapar/para thutu BTW). Mi idea aquí es que si haces cambios, lo más probable es que termines pasando por esta cadena en algún momento y puedas deslizar la pieza de Hexagony dentro de la cadena para atrapar la ruta del código y enviarla a la conclusión correcta. Solo tenga cuidado de no interponerse entre Japt \y el {. Si tiene problemas con esto, el que está @a la derecha de la cadena queda de otra solución de Hexagony y puede eliminarse sin consecuencias para los otros idiomas. Y, por supuesto, si detecta que la ruta del código de Hexagony va en la dirección opuesta, puede usarla en @!32^\lugar de hacerlo /^23!@. Además, puede notar que mi solución eliminó el===2del código para mantener las cosas por debajo del límite de bytes. Alguien mencionó aquí que esto era para la alineación de Hexagony y que ya no lo necesitaba.

Finalmente, aquí hay un pequeño fragmento de código que encontré mientras exploraba codegolf que convierte una línea de texto en un hexágono legible de Hexagony para que pueda depurar. Estoy seguro de que mucha gente lo sabe, pero no lo había visto publicado aquí, por lo que podría ayudar a alguien más también. Advertencia justa, debe modificar la entrada para eliminar los backticks y los retornos de carro, así como cambiar el escape literal por algo que ocupa la cantidad normal de espacio para que el código alinee las cosas en un bonito hexágono.

PD: Mientras escribía esto, me di cuenta de que tenía un error. Había creído que estaba limpiando el borde de la memoria de Hexagony con el ^, pero aparentemente puedo reemplazarlo con un no-op o ninguna consecuencia. Que ^probablemente debería haber una +si se intenta manipular esta sección. Aparentemente estaba pasando por un +antes de esto, pero los futuros políglotters pueden no ser tan afortunados.

¡Buena suerte!

38. C, 804 bytes

#  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

␉es una pestaña literal, ␛un carácter ESC literal; Stack Exchange destrozaría el programa de otra manera. Recomiendo copiar el programa desde el cuadro de "entrada" del enlace TIO a continuación, si desea trabajar en él.

¡Pruébalos en línea!

Atropellar

Este programa imprime 38 en C, 37 en C ++, 36 en Labyrinth, 35 en INTERCAL, 34 en Rail, 33 en Incidente, 32 en Whirl, 31 en Modular SNUSP, 30 en Whitespace, 29 en Trigger, 28 en Brain-Flak, 27 en Perl 6, 26 en 05AB1E, 25 en Pip, 24 en Thutu, 23 en Hexagony, 22 en Underload, 21 en Nim, 20 en Prelude, 19 en Reng, 18en Cardinal, 17 en Julia, 16 en Pyth, 15 en Haystack, 14 en Turtlèd, 13 en Ruby, 12 en Fisión, 11 en Befunge-98, 10 en Befunge-93, 9 en Perl 5, 8 en Retina, 7 en Japt, 6 en SMBF, 5 en Python 2, 4 en> <>, 3 en Minkolang, 2 en V / Vim y 1 en Python 3.

Verificación

La mayoría de los idiomas son probados por el controlador de prueba que se muestra arriba. Puede probar Reng aquí y Modular SNUSP aquí ; producen 19 y 31 respectivamente, según sea necesario.

Aquí está mi versión ligeramente modificada del tokeniser Incident , diseñado para ser un poco menos golfista pero un poco más útil.

Explicación

Siempre me ha encantado hacer pequeños políglotas, pero nunca uno tan grande como este; ¡Pensé que probablemente debería intentarlo!

Después de la maravillosa respuesta C ++ de @ Chance, C parecía la siguiente opción lógica, y dada (en comparación con algunas respuestas anteriores) la relativa facilidad de agregarla, ¡decidí hacerlo cuando tuve la oportunidad!

Utilicé un truco muy conocido para diferenciar entre C y C ++; el tamaño de una constante de caracteres es de 1 byte en C ++ pero el tamaño de un int (garantizado de al menos 16 bits) en C. Este código debería ser muy portátil (excepto tal vez para sistemas que usan bytes con suficientes bits para un int) a menos que He cometido un estúpido error.

Primero traté de hacer un printftodo en línea, pero los múltiples corchetes parecían estar causando problemas a Japt, así que simplifiqué la línea, lo que pareció solucionarlo.

Luego, al Cardenal no le gustó, supuse que debido %a la impresión, así que tuve que resolverlo cambiando a cadenas de manipulación.

Mi siguiente intento, tratando de asignar una cadena y luego cambiar el segundo byte contingente en el comportamiento C, terminó demasiado tiempo y habría empujado a Hexagony al siguiente tamaño; ¡Quería evitar rehacer eso manteniéndolo dentro de los personajes adicionales con los que tenía que jugar! Necesitaba todos los bytes que pude obtener para esto, así que implementé los cambios de ahorro de bytes sugeridos por @Chance.

Así que jugué un poco ese código C y se me ocurrió puts(sizeof'c'-1?"38":"37");que casi funcionaba, excepto que Underload estaba segfaulándose, presumiblemente debido a la compleja expresión entre paréntesis.

Incluso después de eliminar el extra >>que solía ser necesario para que coincida <<con Perl6, no pude encontrar una manera lo suficientemente concisa de dividir la parte más compleja en una asignación de matriz de caracteres. Así que terminé buscando usar el preprocesador en su lugar.

Después de muchas pruebas y errores, encontré una solución que a Retina parecía gustarle. Preludio que me estaba causando problemas de vez en cuando, terminó arreglándose antes de darme la vuelta para ver por qué se estaba rompiendo (supongo que los soportes o los !que tenía en el ternario en una etapa, mirando respuestas anteriores).

Todo el tiempo estaba reparando el espacio en blanco para obtener algo que a él le gustaría; Encontré que eso es bastante fácil. Específicamente, tab space space spacefue una combinación muy útil (la instrucción para agregar los dos primeros elementos en la pila), ya que significaba que podía agregar espacios en blanco a las líneas sin ningún otro espacio en blanco sin que todo se desincronizara (supongo que su posición en el el programa significa que en realidad nunca se ejecuta, así que no me preocupan los desbordamientos de la pila aquí).

Ahora he probado Incidente, ¡y funciona! Muchas gracias a @Chance y @LliwTelracs, que acabo de darme cuenta que NO es un nombre galés, por ayudarme a entenderlo. Vea este resaltado de sintaxis . He eliminado el ;token que aparecía antes del #yytoken. Hice esto simplemente agregando un extra ;después de la getsdeclaración (mi intento anterior implicó reemplazar s(que ahora aparece mucho más en el programa C que en el anterior) en la cadena de "destokenización" con un ;, pero resultó que estaba en realidad un carácter corto para Hexagony (gracias @Chance), así que después de que fallaron los intentos de agregar un personaje adicional a esta última línea, simplemente lo cambié y agregué el punto y coma adicional en otro lugar).

También he ajustado un poco el espacio en blanco para cambiar algunas otras fichas para intentar centrarme, volver a tokenizar la alimentación de línea de pestañas (moviendo la pestaña al final de la #includelínea en el medio, haciendo así tres fichas), y para des-tokenice la ficha de triple espacio moviendo un espacio en la definelínea.

Finalmente, un día después de la presentación inicial, decidí llegar al final del aterrador preprocesador que advierte que gcc produjo (y que hizo que Clang fallara). Determiné que la razón por la que la primera línea funcionó es porque es la salida del preprocesador la que proporciona información de depuración como nombres de archivos originales y numeración de líneas. No les gustó el primer "2" en la primera línea, porque esto significaba "regresar de un archivo incluido al archivo dado", y obviamente eso es imposible dado que no ha habido ningún archivo incluido. Después de cambiarlo a "1" (iniciar el encabezado normal) hizo que se estrangularan demasiados idiomas, lo cambié a un "3" (iniciar el encabezado del componente interno), que rompió solo Hexagony, ya que ahora dependía del 2. Así que al comienzo del código de Hexagony agregué un paréntesis abierto(para disminuir el 3 a 2, luego un paréntesis cerrado )después del final ( @) del código de hexagonía para satisfacer Retina, Preludio y Subcarga que todos esperaban paréntesis coincidentes. Volver a probar Reng y SNUSP modular no produjo problemas, y los tokens de Incidente se veían bien, ¡así que ya lo había solucionado! Lo probé en una variedad de arquitecturas exóticas y parece funcionar. Sé que no es importante para un código de golf, y no me importará si los remitentes futuros tienen que romper esto nuevamente para mantenerse dentro de un conteo de bytes o lo que sea (o si alguien ya ha comenzado basado en esta solución y no quiere cambiar el suyo) demasiado), pero hay una buena razón por la que he hecho esto: el compilador Objective-C de TIO solo es compatible con Clang, ¡así que esto será muy útil si alguien quiere agregar eso!

Tenga en cuenta que nunca he usado la mayoría de estos idiomas, ¡espero que mi éxito aliente a más recién llegados a probarlo!

65. ALGOL 68 (Genie) , 1634 bytes

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

Puntaje VIP ( Impresora entera versátil ): .005949 (para mejorar, la siguiente entrada no debe tener más de 1710 bytes)

Pruébalo en línea!

Atropellar

Este programa imprime 65 en ALGOL 68, 64 en Agony, 63 en Brian & Chuck, 62 en Grass, 61 en SILOS, 60 en Moorhens 2.0, 59 en Tcl, 58 en Ksh, 57 en Wise, 56 en dc, 55 en Brain -Flak Classic, 54 en Zsh, 53 en Shove, 52 en COW, 51 en Asamblea, 50 en Bash, 49 en Octave, 48 en Deadfish ~, 47 en Lily, 46 en Cubix, 45en PicoLisp, 44 en alphuck, 43 en reticular, 42 en mal, 41 en brainfuck, 40 en Minimal-2D, 39 en CoffeeScript, 38 en C, 37 en C ++, 36 en Labyrinth, 35 en INTERCAL, 34 en Rail, 33 en Incidente, 32 en Whirl, 31 en Modular SNUSP, 30 en Whitespace, 29 en Trigger, 28 en Brain-Flak, 27 en Perl 6, 26 en 05AB1E, 25 en Pip,24 en Thutu, 23 en Hexagony, 22 en Underload, 21 en Nim, 20 en Prelude, 19 en Reng, 18 en Cardinal, 17 en Julia, 16 en Pyth, 15 en Haystack, 14 en Turtlèd, 13 en Ruby, 12 en Fisión, 11 en Befunge-98, 10 en Befunge-93, 9 en Perl 5, 8 en Retina, 7 en Japt, 6 en SMBF, 5 en Python 2, 4 en> <>, 3en Minkolang, 2 en V / Vim y 1 en Python 3.

Verificación

La mayoría de los idiomas se pueden probar con el controlador de prueba anterior, pero 6 idiomas deben probarse localmente.

• Reng se puede probar hasta la salida 19 aquí .

• SNUSP modular puede probarse para la salida 31 aquí .

• Se verificó el incidente para probar 33 a través del equilibrio manual de tokens.

• Deadfish ~ puede probarse para generar 48 localmente, utilizando este intérprete . Tenga en cuenta que Deadfish ~ toma el políglota para que se alimente con stdin, pero imprime una serie de >>indicaciones en la salida estándar, que no son consecuencia inevitable de ejecutar cualquier programa Deadfish ~.

• Moorhens 2.0 se puede probar con la salida 60 utilizando este intérprete .

ALGOL 68

ALGOL es probablemente el menos conocido de los cuatro lenguajes de programación de alto nivel de los primeros días de programación; los idiomas restantes de esta distinción nebulosa son COBOL, FORTRAN y Lisp. ALGOL era más conocido en los círculos académicos y matemáticos de la época, pero hoy es más conocido por su gran influencia en los idiomas modernos. De hecho, la mayoría de los lenguajes prácticos y modernos se pueden describir como "similares a Algol", entre los cuales el C es, que por supuesto tiene su propio linaje de influencias y derivados.

Estoy bastante emocionado de incluir ALGOL porque es otro gran paso en la historia de la computadora que podemos agregar a este monumento que llamamos políglota. Eso es genial.

ALGOL68 es la última de las tres especificaciones principales de ALGOL, las otras son ALGOL60 y ALGOL58. Curiosamente, la especificación no tiene una sintaxis fija, lo que significa que los tokens están definidos, pero no la ortografía. Esto hace que el lenguaje sea altamente dependiente del intérprete porque cualquier intérprete puede usar un símbolo diferente para iniciar un bloque de comentarios, por ejemplo. La especificación describe el ¢inicio de un bloque de comentarios. Pero debido a ¢que no se encuentra entre los códigos ascii de base 127, es comprensible que no vea mucho uso como indicador de comentarios entre los intérpretes disponibles. Bueno, resulta que el intérprete Genie se deletrea ¢como #, que es toda la apertura que necesitamos para pasar el personaje 1 y hacer un políglota.

Genie, de hecho, tiene tres opciones de sintaxis de comentarios, las otras dos son coy comment, ambas se especifican como escritas en negrita. Sí, audaz Si usamos cursiva, bueno, esa es una variable. Genie lo resolvió nuevamente para nosotros deletreando negrita en mayúsculas. Y como COno está en el políglota en ninguna parte, tenemos un método fácil para ocultar el políglota del analizador. Si en el futuro COse necesita un idioma, podemos cambiar a la COMMENTsintaxis más detallada .

No hay comentarios de línea en ALGOL: todos son estilo de bloque, lo que significa que deben terminarse. Dado el estado inicial del políglota, nuestro comentario de bloque ALGOL se abre de inmediato y finaliza cerca del final de la línea 1 porque Turtlèd se usa de manera similar #como un token de salto. Afortunadamente, Turtlèd no tiene problemas para recorrer los caracteres Cy O, por lo que en la línea 1 podemos insertar COinmediatamente después del segundo #para iniciar un comentario de bloque gordo para ALGOL68.

Desde aquí solo tenemos que colocarlo en COprint("65")algún lugar . Elegí la última línea porque prefería terminar la línea con otro #comentario y no quería que el comentario terminara al #principio de la última línea. Entonces seguimos nuestra declaración de impresión ALGOL con #sy a #como el último carácter en el políglota. El sde #ses para alphuck para equilibrar la pimpresa.

Gracias a @ ais523 por abrir el final del políglota con la respuesta 59 y hacer posible todo esto.

SMBF

Agregamos un carácter diferente al final del políglota para terminar el comentario final de ALGOL, y SMBF estaba leyendo previamente el último carácter para su respuesta. Para remediar esto, tuve que cambiar SMBF para leer el penúltimo carácter cambiando este código en la línea 8 [.>-]a esto [<.>>-]. Este es un bloque de código privado SMBF ya que el MP de BF está en 0 cuando se inicia el bucle.

Desencadenar

En este punto, noté un comportamiento extraño con SMBF y tenía que ver con las relaciones entre estos segmentos de código hasta el final del políglota.

• Destino del salto del incidente: ^_^_

• Destino de Trigger's Jump más respuesta: X222999

• La respuesta de ALGOL68: COprint("65")#s

La respuesta de ALGOL tokenizó un par de fichas de Incidente dentro de su segmento de código, por lo que el código de ALGOL tuvo que ir antes del segmento de código del Incidente. ALGOL también causó un problema de alineación del preludio si fue primero en el orden, por lo que tuvo que ir en segundo o tercer lugar. Mientras tanto, SMBF tuvo una falla inexplicable cuando el código del Incidente fue el último, por lo que el Incidente tuvo que ir primero o segundo. Bueno, me di cuenta de que este era un problema de lógica introductoria que parecía irresoluble, así que me propuse hacer que lo inexplicable fuera más ... plicable.

Después de recorrer SMBF, descubrí que el problema de tener ^ _ ^ _ al final se debía a Wise. El código de Wise ( ~-<~-<~-<<<~-) no está oculto detrás de un bucle que no se ejecuta, a diferencia de la mayoría de los políglotas. Pero no hay códigos de impresión SMBF involucrados en el código de Wise. Solo estaba cambiando los valores de la memoria. Parecía inocuo. Entonces, ¿cuál era el problema? Era ese maldito SM frente al BF.

El código de Wise está cambiando los caracteres en el código que se va a ejecutar, y ¿puedes adivinar cuál es el valor ascii vecino ^? Es ]. Wise estaba poniendo un terminador de bucle SMBF al final del políglota, haciendo que SMBF cayera en un bucle infinito. Eso es mal mojo.

Después de algunos pensaron que tomé la solución 0 bytes al problema y se separa de la meta del salto de disparo ( X) de su respuesta ( 222999) y terminó la políglota de esta manera: ~-<~-<~-<<<~-XCOprint("65")#s^_^_2229996#. Esto solo funciona porque ningún personaje aparece consecutivamente después del salto de Trigger que no es la respuesta de Trigger.

Terminando

Esos son los principales cambios de esta ronda. Realicé un cambio menor para cortar lo que se discutió cen la línea 1, pero eso es solo para los cambios de golf.

¡Buena suerte!

Reporte de incidente

#<q>"3"O.sse hizo #<T>"3"O.sporque destokenizar en Tlugar de qera más eficiente en el equilibrio

<>{se convirtió <>{nden destokenizar ndy{␊

Pon un espacio entre }}y +adentro #<]}} +<[<.>>-]>[para destokenizar }}+más barato.

2. V (11 bytes)

print(1)#i2

Este programa imprime 1 en Python 3 y 2 en V.

Solo para poner en marcha la pelota y lanzar mi idioma favorito desde el principio. :)

Es una respuesta muy directa.

print(1)#

resulta ser un NOP en V. (por suerte para mí) Luego i2ingresa al modo de inserción e inserta un '2'. Puedes probar V en línea aquí

Por supuesto, en python

print(1)

imprime '1' y

#i2

es un comentario

20. Preludio, 167 bytes

#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

Caracteres literales ESC en el mismo lugar que en los envíos anteriores (entre #y g, y entre 2y `, en la última línea), porque no puede sacar a Vim del modo de inserción con caracteres imprimibles.

Este programa imprime 20 en Prelude , 19 en Reng (comprobable aquí ), 18 en Cardinal , 17 en Julia , 16 en Pyth , 15 en Haystack , 14 en Turtlèd , 13 en Ruby , 12 en Fission , 11 en Befunge-98 , 10 en Befunge-93 , 9 en Perl , 8 en Retina , 7 en Japt , 6 en SMBF ,5 en Python 2 , 4 en> <> , 3 en Minkolang , 2 en Vim / V , 1 en Python 3 ya partridgeen A Pear Tree .

El código existente prácticamente se cancela en Prelude, que consiste solo en bucles while con argumentos falsey y alguna manipulación de pila en pilas que no nos importan. Aún mejor, hay un punto en el código que es un comentario en todos los idiomas que los tienen (entre el #y =#del envío anterior). La parte difícil de encajar Prelude en esto fue generar números con una sola pila y sin explotar el recuento de bytes. Este programa usa un bucle que agrega 45 a cada elemento de la pila y lo genera como ASCII, por lo que al colocar un 5 sobre un 3 en la pila, obtenemos 20como salida. (Claramente, 20 es un número más fácil de generar que 19 en Prelude, por lo que la respuesta 19 publicada realmente me ayudó un poco).

30. Espacio en blanco , 296 bytes

#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

␛ representa escapes literales.

␉ representa pestañas literales.

Este programa imprime 30 en Whitespace , 29 en Trigger , 28 en Brain-Flak , 27 en Perl 6 , 26 en 05AB1E , 25 en Pip , 24 en Thutu , 23 en Hexagony , 22 en Underload , 21 en Nim , 20 en Prelude , 19 en Reng (probado aquí ), 18 en Cardinal , 17 en Julia , 16 en Pyth , 15 en Haystack , 14 en Turtlèd , 13 en Ruby , 12 en Fisión , 11 en Befunge-98 , 10 en Befunge-93 , 9 en Perl 5 , 8 en Retina , 7 en Japt , 6 en SMBF , 5 en Python 2 , 4 en> <> , 3 en Minkolang , 2 en V / Vim y 1 en Python 3 .

El espacio en blanco es otro esolang con un conjunto de caracteres limitado. Este solo lee pestañas, espacios y saltos de línea.

Entonces, una vez que sacamos todo lo que Whitespace no lee, nos queda el siguiente código:

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

Y el código para la salida 30 es este:

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

Por lo tanto, las 3 primeras líneas del código existente recibieron espacios adicionales al final de las líneas para cumplir con los requisitos. Tenga en cuenta que las pestañas de la línea 1 y el espacio final están en el medio de la línea para acomodar las necesidades de> <>.

El espacio de la línea 2 se cambió a una pestaña aquí. Esto parece funcionar de manera idéntica a un espacio para los lenguajes 2D, pero visualmente ya no se alinea. ¯ \ _ (ツ) _ / ¯

Después de las instrucciones para la salida 30, el juego se convirtió en el resto de los espacios necesarios y los avances de línea para hacer cosas sin sentido y compilar correctamente.

El espacio en blanco tiene instrucciones que marcan / van a una ubicación de código con una etiqueta que permite un número arbitrario de pestañas y espacios, por lo que ayudó a alinear los espacios de la línea larga. También comienza y termina con un avance de línea, por lo que nos ayudó a subir algunos de los avances de línea en las líneas 3-6.

La línea final no podría tener un salto de línea sin romper Retina, por lo que sus instrucciones son hacer algunas operaciones arbitrarias de matemática y manipulación de la pila.

Aquí está el código completo con espacios, pestañas y saltos de línea reemplazados por nuestra notación:

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

Y aquí hay una versión comentada de solo el espacio en blanco:

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]

Ediciones: Hexagony resulta omitir las pestañas al igual que los espacios, en contra de mi afirmación anterior. @ ais523 tuvo la amabilidad de actualizar el Hexagonizador de @ Kenney para dar cuenta de escapes y pestañas literales. Tuve que modificarlo para corregir mi afirmación anterior sobre las pestañas que se leen como no-ops y para reemplazar escapes literales .porque el ␛carácter es más ancho que otros caracteres, lo que hace que el hexadecimal esté ligeramente desalineado. Aquí el enlace .

Y este es nuestro Hex actual corregido:

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

Finalmente, descubrí algunos personajes innecesarios, en su mayoría agregados previamente para alinear los paréntesis Preludio y los hexágonos de Hexagonía.

El código de Nim regresa a echo 21desdeecho 5+5+11

Hexagony's #@46es ahora#46

El código de Hexagony regresa a /+23!@=desde/+23!@

La alineación entre paréntesis de Prelude se (9) or (13)convirtió en(9)and(13)

Bueno, eso es todo lo que tengo. ¡Buena suerte a todos!

100. brainbool, 2953 bytes

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

Puntaje VIP ( Impresora entera versátil ): .002953 (para mejorar, la siguiente entrada no debe tener más de 3042 bytes)

Atropellar

Este programa imprime 1 en Python 3, 2 en V / Vim, 3 en Minkolang, 4 en> <>, 5 en Python 2, 6 en SMBF, 7 en Japt, 8 en Retina, 9 en Perl 5, 10 en Befunge- 93, 11 en Befunge-98, 12 en Fission, 13 en Ruby, 14 en Turtlèd, 15 en Haystack, 16 en Pyth, 17 en Julia, 18 en Cardinal, 19 en Reng, 20 en Prelude, 21en Nim, 22 en Underload, 23 en Hexagony, 24 en Thutu, 25 en Pip, 26 en 05AB1E, 27 en Perl 6, 28 en Brain-Flak, 29 en Trigger, 30 en Whitespace, 31 en Modular SNUSP, 32 en Whirl , 33 en Incidente, 34 en Rail, 35 en INTERCAL, 36 en Labyrinth, 37 en C ++ 03, 38 en C99, 39 en CoffeeScript, 40 en Minimal-2D, 41 en brainfuck, 42 en mal, 43 en reticular, 44 en alphuck, 45 en PicoLisp, 46 en Cubix, 47 en Lily, 48 en Deadfish ~, 49 en Octave, 50 en Bash, 51 en Assembly, 52 en COW, 53 en COV, 54 en Shove, 54 en Zsh, 55 en Brain-Flak Classic, 56 en cc, 57 en Wise, 58 en Ksh, 59 en Tcl, 60 en Moorhens, 61 en SILOS, 62 en Grass, 63en Brian & Chuck, 64 en Agony, 65 en ALGOL 68, 66 en Surface, 67 en C11, 68 en Python 1, 69 en rk-lang, 70 en Commercial, 71 en qué, 72 en Fortran, 73 en Morse, 74 en Archway, 75 en C ++ 11, 76 en Trefunge-98, 77 en C ++ 14, 78 en el tablero, 79 en C ++ 17, 80 en Klein 201, 81 en Klein 100, 82 en Brain-Flueue, 83 en Objeck, 84 en Klein 001, 85 en zkl, 86 en Miniflak, 87 en Alice, 88 en PingPong, 89 en gnuplot, 90 en RunR, 91 en Cood, 92 en C89, 93 en Set, 94 en Emotinomicon, 95 en Emoji, 96 en EmojiCoder, 97 en Cubically, 98 en Archway2, 99 en 99 . 100 en brainbool

Verificación

Pruébalo en línea! Idiomas no disponibles en TIO:

• Japt, 7 en línea .
• Reng, 19 en línea .
• Deadfish ~, 48 locales .
• Polluelos, 60 locales . use moorhens.py de la rama v2.0-dev
• Morse, 73 locales
• Archway, 74 locales
• Trefunge-98, 76 locales . Uso -d 3 -v 98para Trefunge-98.
• Objeck, 83 locales
• zkl, 85 locales
• PingPong, 88 locales
• RunR, 90 locales
• Cood, 91 en línea
• Set, 93 en línea
• Emotinomicon, 94 en línea
• EmojiCoder, 96 en línea
• Archway2, 98 local No puedo probar Archway2 porque no tengo el compilador de C adecuado, sin embargo, Stasoid ha confirmado que funciona en Archway2

Explicación

No puedo creer que hayamos llegado a 100 idiomas. Solo me gustaría tomar el tiempo para agradecer a todos los que han estado involucrados en este proceso. Ha sido un viaje divertido y espero agregar 100 más con ustedes.

Brainbool ha estado en mi ojo por un tiempo. Sin embargo, ya que brainbool solo puede generar dos números, 1y 0no he podido agregarlo hasta ahora (no estaba disponible para 10 y 11).

Brainbool es como un brainfuck, excepto que en lugar de envolver a 256 se ajusta a 2. Brainbool tampoco tiene un -porque es redundante con el +. Nuestro código brainbool para generar 100 es bastante simple:

+.+..

Para enmascarar las salidas para brainfuck, agregamos un bucle y un menos:

+-[.+..]

Ahora todo lo que se necesita es encontrar un lugar para el código. Mi lugar de elección fue el primero +en el nivel superior del código brainfuck en la línea 8. Para sustituir el plus, agregamos nuestro código y un +-+que actúa como un +brainfuck y un noop en brainbool.

+-[.+..]+-+

Cubix

Puse mi código antes de la cápsula Cubix haciendo que un espejo se mueva en la ruta del puntero. Para arreglar esto, moví la cápsula un par de pasos hacia adelante frente al espejo ofensor y todo estuvo bien.

Sorprendentemente, nada más rompió ni siquiera el notorio incidente.

27. Perl 6 , 235 bytes

#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

␛ representa un carácter ESC literal, como de costumbre.

Este programa imprime 27 en Perl 6 , 26 en 05AB1E , 25 en Pip , 24 en Thutu , 23 en Hexagony , 22 en Underload , 21 en Nim , 20 en Prelude , 19 en Reng (probado aquí ), 18 en Cardinal , 17 en Julia , 16 en Pyth , 15 en Haystack , 14 en Turtlèd , 13 en Ruby ,12 en Fisión , 11 en Befunge-98 , 10 en Befunge-93 , 9 en Perl 5 , 8 en Retina , 7 en Japt , 6 en SMBF , 5 en Python 2 , 4 en> <> , 3 en Minkolang , 2 en Vim / V , 1 en Python 3 y (como es Navidad)a partridgeen A Pear Tree .

El resaltado de sintaxis que produce Stack Exchange para esta respuesta es completamente incorrecto. #`<es uno de los muchos marcadores de comentarios multilínea de Perl 6 y termina en #>, por lo tanto, el único código que realmente se ejecuta en Perl 6 es el muy simple say 27. Elegí este marcador de comentarios en particular porque <>no son un par coincidente en la mayoría de los idiomas, y por lo tanto, los inigualables <no romperán los idiomas, como Retina, que intentan analizarlo.

Ya no estoy completamente seguro de cómo funciona la Hexagonía. Cuando se rompió, cambié uno de los personajes que estaba usando de a +a a 0para ver si estaba siendo golpeado; Resulta que sí, y resulta que esto solucionó el programa, pero no estoy seguro de por qué (sé que se rompió debido a una #línea de ejecución, pero no está claro por qué eliminar las +cosas arregladas). (El personaje en cuestión también es analizado por Thutu, pero afortunadamente esto no hace una diferencia en el funcionamiento del programa Thutu, ya que en ese punto del programa, cualquier cosa que no esté precedida por una =se copia literalmente en el trabajo cadena.) Tenga en cuenta que el 0and+4de una línea anterior se convirtió0and 4, para que sea un personaje más corto desde el punto de vista de Hexagony (Hexagony no ve espacios); esto es para compensar el #|devenir de una línea anterior #`<`|, que es un carácter más largo desde el punto de vista de Hexagony (porque tampoco ve comillas inversas). Tenga en cuenta que el código ahora está a solo cinco bytes de expandir la longitud del lado de Hexagony y romper todo sobre el código de Hexagony actual. Recomiendo hacer esto de todos modos y simplemente rehacer la sección de Hexagony del código; probablemente será más fácil, en lugar de más difícil, adaptar todo después de una expansión.

Algunos otros lenguajes también cambiaron, principalmente para agregar la robustez suficiente para que pudiera incluir un código arbitrario en la última línea. $//es un marcador de comentario en Japt que permite espacios más adelante en la línea, lo que hace que el programa agregado sea menos frágil en Japt (mientras tanto, se //rompe si hay paréntesis de cierre más adelante en la línea, y el espacio es una especie de paréntesis de cierre en Japt). Un par de espacios es un marcador de comentario en Pip, lo que significa que el código Pip se puede simplificar sustancialmente aquí. Esto también significa que podemos simplificar el 05AB1E a un trivial "26. La retina necesita que la quinta línea sea una expresión regular legal que sea buena para combinar cosas (el final|es así para Retina); se analiza de manera diferente a la línea correspondiente en la entrada anterior, pero de una manera que es igual de adecuada. El Cardinal también es un poco más simple que en las entradas anteriores, pero esto es pura coincidencia con la forma en que todo se alinea verticalmente, y el cambio es un código que no hizo nada de todos modos.

Asumiendo que rehacer la Hexagony (probablemente tiene que hacerlo), hay lugares seguros para añadir código en todas las tres últimas líneas: la 3de #3]#es sólo para Hexagony (y cambiar fácilmente); la gran mayoría de los idiomas ignora el espacio entre #y "en la línea final; y nada realmente analiza el final de la quinta línea que no sea Retina. (También hay muchos otros lugares donde se puede agregar código, pero estos son probablemente los más convenientes).

31. SNUSP modular , 326 bytes

Programa

#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

Como de costumbre, ␛es un carácter ESC literal y ␉es una pestaña literal.

Atropellar

Este programa imprime 31 en SNUSP modular, 30 en espacio en blanco, 29 en disparador, 28 en Brain-Flak, 27 en Perl 6, 26 en 05AB1E, 25 en Pip, 24 en Thutu, 23 en Hexagony, 22 en Underload, 21 en Nim , 20 en Prelude, 19 en Reng, 18 en Cardinal, 17 en Julia, 16 en Pyth, 15 en Haystack, 14 en Turtlèd, 13 en Ruby, 12 en Fission,11 en Befunge-98, 10 en Befunge-93, 9 en Perl 5, 8 en Retina, 7 en Japt, 6 en SMBF, 5 en Python 2, 4 en> <>, 3 en Minkolang, 2 en V / Vim, y 1 en Python 3.

Verificación

¿Por qué no hay enlaces en el resumen? Debido a que he estado trabajando en algo para facilitar las pruebas, un controlador de prueba que ejecuta el programa en la mayoría de los idiomas enumerados aquí e imprime el resultado. Con suerte, esto debería facilitar la adición de futuros idiomas al políglota. Puede obtener los resultados de este programa para 28 de los 31 idiomas ejecutando el siguiente enlace TIO (que es un controlador de prueba escrito en una combinación de Bash, Perl y A Pear Tree):

¡Pruébalos en línea!

El enlace también produce el bloque de código con formato ␛/ ␉visto anteriormente, y formatea el código en un hexágono para usted:

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

Faltan tres idiomas: V es demasiado lento y Reng y SNUSP modular no están instalados en TIO. Afortunadamente, los tres tienen intérpretes en línea:

• Puede probar el programa en V / Vim (salida prevista: 2) aquí en TIO.
• Hay un intérprete de Reng en línea (salida prevista: 19) aquí .
• Hay un intérprete SNUSP modular en línea (salida prevista: 31) aquí . (Se anuncia solo como un intérprete de SNUSP, pero Modular SNUSP es el dialecto que realmente implementa, como se ve por los @signos en toda la página).

Los tres producen el resultado deseado, por lo que los 31 programas se prueban correctamente. (Una cosa que me preocupa un poco es si el programa de espacios en blanco está finalizando correctamente; sin embargo, el espacio en blanco aquí es idéntico al envío anterior, por lo que ambos tienen razón o ambos están equivocados. Si resulta que el programa está realmente terminando incorrectamente, es probable que ambos programas sean reparables de la misma manera).

Explicación

En primer lugar, la Hexagonía, que siempre parece necesitar un cambio. En realidad es mucho más simple que antes; Moví el código de Hexagony justo después del código Trigger, lo que significa que está muy cerca del final del programa, y ​​la "cápsula" de Hexagony que imprime 23 y sale funciona casi de inmediato. La última línea generalmente parece un buen lugar para colocar la cápsula, ya que significa que se ejecutarán menos comandos que podrían interrumpir la Hexagonía.

Todos los demás cambios tienen que ver con la adición del código SNUSP modular. Lo primero a tener en cuenta es que SNUSP comienza a ejecutarse en el primer $carácter del programa, y ​​es un lenguaje 2D que sale después de salir del borde del programa y, por lo tanto, colocando el programa SNUSP al final de la línea larga (dentro el código Thutu, en un punto donde Thutu aceptará casi cualquier cosa), podemos asegurarnos de que SNUSP no vea ningún código de otros idiomas, y la mayoría de los otros idiomas no se preocuparán por el SNUSP. Un idioma que sí le importaba era Perl 6, que analiza los corchetes angulares; Puse un <inmediatamente antes del código SNUSP para mantenerlo feliz (ya que los corchetes naturalmente casi coincidían de todos modos). El otro idioma que le importa es SMBF;.salidas en SMBF y SNUSP, y no queremos crear salidas adicionales. Afortunadamente, como lo ve SMBF, este programa es <.>>[…]seguido por el código SNUSP, es decir, el elemento de cinta actual es 0. Por lo tanto, encerrar el código SNUSP entre corchetes "lo comenta" desde el punto de vista de SMBF.

En cuanto al código en sí, utiliza un truco bien conocido para escribir constantes en SNUSP modular en el que escribe muchos comandos de "procedimiento de inicio" en una fila y crea efectivamente una especie de número de base de Fibonacci. La idea básica es que +codifica el número 1; @suma el número representado por el código después de él y el número representado por el código después de él menos su primer carácter; y =es un no-op (por @=lo tanto , duplicará el número a su derecha). En este sistema, elegí @@@@=+@@@=+#como una representación del número 48.

Sin embargo, hay un problema aquí; El método estándar de escribir constantes en SNUSP deja el flujo de control detrás del inicio del programa, y ​​con un oneliner (que quería escribir aquí por razones obvias), no hay forma de cambiar la IP para apuntar en cualquier dirección que no sea la correcta. Esto significa que de alguna manera tendremos que hacer que la IP pase toda la definición constante y continúe hacia la derecha, sin que el programa salga (lo #que normalmente haría). Para resolver esto, utilicé cuidadosamente una definición del número para el que +siempre estaba precedido =. Esto significa que puedo escribir código para establecer la segunda celda en 48 a través @@@@=>+<@@@=>+<#, seguro sabiendo que ninguno de los >comandos será omitido por un@comando (y así mantenemos el control del puntero de la cinta). Además, sabemos que al final #, la primera celda de la cinta seguirá teniendo su valor inicial. Por lo tanto, podemos usar la primera celda de cinta como marcador para saber si se debe regresar de la definición del procedimiento o si se debe continuar hacia la derecha (estamos dentro de un montón de procedimientos al hacerlo, pero salimos del programa al caernos del borde para que no importe).

El código final de SNUSP, por lo tanto, es $+@+-@@@@=>+<@@@=>+<?#>+.--.. El $marca el inicio del programa. +@+-establece el primer elemento de cinta en 1 ( ++-pero una vez que el procedimiento se inicia con @retornos, comenzará a ejecutar el código de ahí en -adelante, configurando el elemento de cinta nuevamente en 0. ?#finaliza el procedimiento solo si el primer elemento de cinta no es cero; por lo tanto finalmente terminamos #con el segundo elemento de cinta configurado en 50 (48 de la definición constante, más 2 de los dos >+<encontrados al ir a la derecha después). Entonces todo lo que tenemos que hacer es >+.--.generar los códigos ASCII 51 ( 3) y 49 ( 1), y caerse del borde del programa ( ]es un no-op en SNUSP, y /refleja el flujo de control verticalmente para que se ejecute desde el borde superior del programa); este bit funciona de manera idéntica para hacer una buena idea

11. Befunge 98 , 102 bytes

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

Huellas dactilares:

• 1 en Python 3
• 2 en Vim : esto lleva bastante tiempo salir por alguna razón ...
• 3 en Minkolang v0.15
• 4 en > <>
• 5 en Python 2
• 6 en SMBF
• 7 en Japt
• 8 en retina
• 9 en Perl
• 10 en Befunge 93
• 11 en Befunge 98

Para ser sincero, no tengo idea de por qué el código de Vim tarda 1 minuto en salir. Además, no tengo idea de cómo funciona la retina.

Explicación:

#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 @)

Cosas a tener en cuenta:

• El 0siguiente bno es estrictamente necesario en el estado actual del código, y la pila se ha borrado. Se puede eliminar si es necesario, pero permite otra manipulación de la pila de antemano como parte de un posible programa futuro.
• El _q@está allí como parte de Retina (no funciona sin él, no me preguntes por qué). La adición de qtambién permite que el código '98 ejecute una toperación, que divide la IP (junto con hacer que el programa Retina imprima 8 en lugar de 7)
• El _no es un simple >porque eso estropearía la parte SMBF.

Editar: Acabo de darme cuenta de que _q@probablemente debería ser @00(Donde los 0 pueden ser ~ cualquier carácter) para que el programa sea más flexible en el futuro. Sin embargo, soy demasiado vago (y cansado) para cambiar todos los enlaces en este momento. Lo conseguiré eventualmente ...

Edición 2: No esperaba 6 respuestas más tan rápido. Supongo que se queda como está. ¡Buen trabajo a todos!

35. INTERCAL (C-INTERCAL), 631 bytes

#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

␉es una pestaña literal, ␛un carácter ESC literal; Stack Exchange destrozaría el programa de otra manera. Recomiendo copiar el programa desde el cuadro de "entrada" del enlace TIO a continuación, si desea trabajar en él.

¡Pruébalos en línea!

Atropellar

Este programa imprime 35 en INTERCAL, 34 en Rail, 33 en Incidente, 32 en Whirl, 31 en Modular SNUSP, 30 en Whitespace, 29 en Trigger, 28 en Brain-Flak, 27 en Perl 6, 26 en 05AB1E, 25 en Pip , 24 en Thutu, 23 en Hexagony, 22 en Underload, 21 en Nim, 20 en Prelude, 19 en Reng, 18 en Cardinal, 17 en Julia, 16 en Pyth,15 en Haystack, 14 en Turtlèd, 13 en Ruby, 12 en Fisión, 11 en Befunge-98, 10 en Befunge-93, 9 en Perl 5, 8 en Retina, 7 en Japt, 6 en SMBF, 5 en Python 2, 4 en> <>, 3 en Minkolang, 2 en V / Vim y 1 en Python 3.

Verificación

La mayoría de los idiomas son probados por el controlador de prueba que se muestra arriba. Puede probar Reng aquí y SNUSP modular aquí ; producen 19 y 31 respectivamente, según sea necesario. Probé el incidente localmente en mi propio sistema, utilizando el intérprete oficial.

Tenga en cuenta que agregué algunos cambios al controlador de prueba para facilitar la detección de caracteres ocultos; Varios bytes NUL se habían infiltrado en la salida del programa en ciertos idiomas. He decidido que esto probablemente no sea un problema, porque a) una amplia gama de presentaciones lo han estado haciendo, yb) los intérpretes de Befunge parecen estar agregando bytes NUL adicionales a pesar de que nada en el programa implica eso (a menos que yo he perdido algo), por lo que debe haber estado sucediendo durante siglos y probablemente sea parte de cómo funciona el intérprete. (Tenga en cuenta que a los idiomas que aún generan bytes NUL, Befunges y Minkolang, no se les ha cambiado el código para este envío).

La presentación previa de Rail se cierra por bloqueo, lo que no se permite, pero esto se puede solucionar fácilmente (agregando un #al final del programa Rail y ajustando la Hexagonía para que coincida), por lo que no lo consideré un problema importante. El riel en esta solución sale correctamente.

Explicación

Cómo funciona el código INTERCAL

INTERCAL analiza todo el programa. Sin embargo, los errores de sintaxis son una cosa de tiempo de ejecución en INTERCAL, no en tiempo de compilación, y esto a menudo se usa para crear comentarios. (Si un error de sintaxis intenta ejecutarse, bloqueará el programa con el error ICL000I, al contrario de lo que Wikipedia afirma incorrectamente. Pero si puede evitar que se ejecute de alguna manera, e INTERCAL tiene muchas maneras de evitar que se ejecuten comandos, lo hará felizmente no ejecutar sin causar un problema.)

Como tal, podemos evitar que la basura al final del archivo se ejecute simplemente saliendo primero del programa explícitamente (algo que se requiere de todos modos, porque INTERCAL se bloquea si se llega al final del programa sin un comando de salida explícito). Manejar el inicio del programa es más interesante y explota un error del analizador. Puede escribir algo como DO %20 READ OUT #8salida VIIIcon una probabilidad del 20% (y de lo contrario no hacer nada). Por lo que puedo decir, C-INTERCAL analiza el% solitario en la segunda línea, lo que indica una probabilidad de 0% para que se ejecute el primer comando y, por lo tanto, termina constantemente no ejecutándolo todo el tiempo. (No estoy seguro de por qué lo analiza así, pero mirar el código compilado muestra que genera un número aleatorio y lo compara con 0).

Así es como se veía el programa INTERCAL antes de ajustarlo al resto del políglota:

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

Esto es bastante simple: crear una instancia de una matriz de 2 elementos; establezca los elementos en 52 y 32 (decimal) respectivamente (la codificación de cadenas de INTERCAL es mejor no mencionarla; he olvidado cómo funciona y tuve que hacer varios experimentos para descubrir por qué codifican estos números 35); léelo a la salida estándar; y salga del programa. Agregué un POR FAVOR adicional al final para terminar la declaración GIVE UP, comenzando una nueva declaración para la basura al final del programa, manteniendo los límites aceptables para una conversación educada. Por supuesto, el INTERCAL no se parece mucho a eso en el producto terminado; Explicaré por qué a medida que avanzamos.

Enterrado bajo una carga de Ses

El problema más obvio con el programa INTERCAL es que contiene la carta S. Esto es casi inevitable, ya que no hay forma de indexar una matriz sin usar la letra en cuestión. Sin embargo, Ses un comando de salida en Underload, y no hay forma de evitar que analice todo el programa. La única solución es colocar el código INTERCAL entre paréntesis, el equivalente de Underload de un literal de cadena, para que no se ejecute de inmediato.

Sin embargo, tenemos dos ^caracteres al final del programa, que ejecutan el código de Subcarga; entonces esos Seses se ejecutarán de todos modos si no hacemos algo al respecto. Podría haberlo cambiado a otro personaje, pero decidí que era más fácil proteger el código para que no tenga sentido. aescapa de una cadena en Underload (lo que significa que ^, al ejecutar la cadena, simplemente no volverá a escapar en lugar de producir efectos secundarios dañinos). Ya tenemos uno aen el sayutilizado en el código Perl 6 (que en esta disposición del código, es en realidad lo suficiente debido a los cambios no relacionados). Sin embargo, para que la gente no tenga que depender de eso, agregué otroaal final de la línea (quería un personaje allí de todos modos para hacer visible lo que de otro modo serían espacios finales, y porque Hexagony necesitaba relleno como está; tenga en cuenta que Hexagony fue bastante fácil de arreglar en este programa, y ​​realmente no necesita una discusión por separado). Entonces, el código Underload es un poco menos frágil de lo que podría haber sido.

Preludio de mucho trabajo y confusión.

Ah, preludio. Normalmente no es el idioma más difícil, pero definitivamente fue esta vez. Hay dos problemas reales: uno es que agregar paréntesis adicionales en una línea muy larga corre el riesgo de perturbar el flujo de control del programa Prelude (ya que crean el equivalente de un whilebucle), y otro es simplemente el problema de evitar que forren hacia arriba verticalmente (que es responsable de la mayor parte del movimiento aleatorio del espacio en blanco en las líneas). Tenga en cuenta que el espacio en blanco también me dio algunos problemas, pero este programa es equivalente al anterior desde el punto de vista del espacio en blanco, por lo que se trataba básicamente de "arreglar el preludio sin romper el espacio en blanco".

No estoy muy seguro de cómo funciona el Preludio en este momento. Hay varias soluciones destinadas a ello, como el 0 cerca de la esquina inferior izquierda, pero claramente no funcionan de la manera que yo pretendía. (El código de Julia también terminó moviéndose al final de la línea porque los paréntesis en su printdeclaración eran realmente difíciles de tratar). Quizás solo tengamos que dejarlo en secreto.

Desglose en un reactor de fisión

Aunque los cambios anteriores fueron para problemas bastante sutiles que son difíciles de solucionar, hay un problema mucho más obvio; DOREADOUTcoincide con la expresión regular R...Oy, por lo tanto, hará que Fission produzca una salida no deseada en el cuarto ciclo, que no es tiempo suficiente para generar la salida deseada 12. E INTERCAL solo tiene una instrucción que produce salida (a menos que cuente el bloqueo como salida). Una solución a esto es tratar de agregar espacios en blanco entre READy OUT, para darnos tiempo para interceptar la salida, pero eso enoja a Whitespace. Entonces, por un tiempo, pensé que este programa era imposible; R, L, U, Y Dson todos los puntos de entrada en la fisión, y todos capaces de ejecutar código potencialmente problemático, y las palabras clave INTERCAL deben estar en mayúsculas.

Sin embargo, hay una solución, y una bastante sorprendente. Como parte de un esfuerzo de internacionalización, C-INTERCAL en realidad acepta palabras clave en varios idiomas, con soporte para inglés y latín. No pudimos evitar Sde esta manera, pero podemos evitar O; FACes un sustituto perfectamente bueno DOe igualmente LEGERE EXsignifica lo mismo que READ OUT. (Por lo tanto, el programa terminó en una mezcla de inglés y latín, pero está bien; difícilmente lo hace menos legible). Como tal, podemos dejar que Fission se vuelva loco en la esquina inferior derecha, y no dejar que produzca salida. Podemos cambiar el código de Fisión real para que termine en *lugar de;, que cierra todo el programa en lugar de solo un subproceso; Este código se ejecuta con bastante rapidez, por lo que sale del programa antes de que todos los puntos de entrada extraviados tengan tiempo de hacer algún daño.

Tejer 6, Perl 6

El siguiente problema: los comentarios de Perl 6 funcionan haciendo coincidir <y >. El operador de asignación de INTERCAL es <-. Afortunadamente, eso agrega corchetes de apertura adicionales , por lo que podría agregar algunos corchetes de cierre para cancelarlos en una ubicación no analizada en el programa (justo después del código Pip, en este caso).

Sin embargo, no quería cambiar el presupuesto de espacios en blanco del programa, pero al mover el código de Julia (para Prelude) terminé agregando un espacio adicional a la última línea; Tuve que quitar uno de algún lado. El doble espacio es un marcador de comentario en Pip, por lo que difícilmente podría cambiarlos; la única opción restante es el espacio en say 27. Los golfistas de Perl 5 inmediatamente pensarían "bueno, simplemente hazlo say+27" (¡unario +es útil sorprendentemente a menudo!), Pero desafortunadamente esta no es una sintaxis válida de Perl 6.

Sin embargo, lo que podemos hacer es cambiar sayde la sintaxis de la función a la sintaxis del método. Los literales enteros tienen varios métodos, incluido uno para imprimirlos, por lo que 27.sayes un programa perfectamente válido de la misma longitud.

¿Ser cuadrado? No estar ahi

Entonces, el siguiente problema es que he agregado un extra .al programa. Los usuarios de SMBF sabrán que eso es claramente un problema en ese idioma, produciendo salida perdida (bytes NUL en este caso). Había ya una .salida parásita producir último programa, pero eso no significa que no debería tener la oportunidad de solucionarlo.

La idea básica aquí es crear un bucle SMBF para comentar las instrucciones ofensivas. Esto significa mover los corchetes. Los tomé de todo el código SNUSP (porque estaban allí sólo por el bien del incidente de todos modos, y incidente no importa donde en el programa que son), y se coloca el soporte de apertura al inicio del código INTERCAL, y el cerrando el corchete justo antes del Disparador (ocultando perfectamente ambos .s).

Desafortunadamente, los corchetes son significativos para Retina; ve […<-#…y dice "eso no tiene sentido, no puedes crear ese rango porque <no viene antes #". Afortunadamente, esto se puede solucionar fácilmente con una barra diagonal inversa colocada estratégicamente.

El incidente del centro del programa

Esto sucedió la última respuesta, y probablemente va a suceder repetidamente a partir de ahora; varias cadenas ocurrieron aleatoriamente tres veces, y se movieron alrededor del centro del programa desde el punto de vista del Incidente.

El token más urgente para manejar fue 1#, que aparece tres veces si realiza estos cambios ingenuamente: #= >␉1#al comienzo de la tercera línea __DATA__=1#, y echo 21#. ¿Por qué es esto un problema? Debido a que 1#en la tercera línea se superpone #vjusto después de ella, y dos tokens superpuestos hacen que ninguno de ellos se cuente. ¡Y #ves el token que usamos para comentar el código antes de que salga el programa de Incidentes! Lo arreglé introduciendo un extra 1#muy cerca del final del programa (solo tres caracteres lo siguen); ninguno de los idiomas que analiza esa parte del programa hace nada con él.

Había varios otros tokens problemáticos con los que lidiar. Una pareja eran letras sueltas, Py U; Que se ocupó de éstos a través de cambiar un par de relleno no-ops en el código de incidentes de xa P, o U, respectivamente, dando una cuarta copia. El cambio en el código de Fisión sale *como un token, pero en particular, se divide de manera diferente a lo normal, aparece dos veces antes del código de Incidente y solo una vez después. En lugar de eliminarlo, por lo tanto, lo usé para equilibrar parcialmente el nuevo LEtoken que apareció en el código INTERCAL. Eso es suficiente para conducir el centro del programa de regreso sobre un0osimbólico. Por supuesto, es muy probable que los cambios en el programa perturben esto. (Mis intentos de obtener Incidente en TIO fallaron debido a que libdivsufsort no está disponible allí, por lo que parece que podríamos beneficiarnos de un nuevo intérprete, especialmente en JavaScript para que pueda ejecutarse en línea. Si está interesado, eche un vistazo a esto pregunta )

1. Python 3 (8 bytes)

print(1)

Este programa imprime 1 en Python 3.

Comenzando esto con Python 3 porque sé que es bueno para los políglotas y se puede tomar en varias direcciones diferentes (también, quería asegurarme de que la primera respuesta estuviera en un lenguaje relativamente normal, en lugar de un absurdo esolang que es difícil de poliglotar) con).

10. Befunge , 95 bytes

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

Hay un carácter ESC literal entre jy den la última línea (grr, @ ais523). No está incluido en este código. Para obtener el código real, vaya al Try it onlineenlace.

Imprime 1 en Python 3, 2 en Vim, 3 en Minkolang, 4 en <> <, 5 en Python 2, 6 en SMBF, 7 en Japt, 8 en Retina, 9 en Perl y 10 en Befunge.

Este código se comparte *con Retina y .con Minkolang y SMBF.

Pruébalo en línea

Explicación

Programa real

#v02^
    @
    .
    *



    t
    5
#v02^

La última línea fue escrita para mayor claridad ( Befunge playground es cíclico).

#

Trampolín, salta v

02^

Empuje 0y luego 2en la pila y suba.

5t*.@

Empuje 5, sin operación, multiplique dos elementos en la pila ( 2y 5), imprima, finalice el programa.

21. Nim (161 bytes)

#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

Dos <ESC>s, entre 8dy 2`en la última línea. Se puede decir que mi anterior fue golf a toda prisa, porque me desperté esta mañana y me di cuenta de que podía tomar un montón más. Tenía 152 bytes, pero parece que solo funciona en Perl 5.24.0, por lo que, en aras de la compatibilidad con TIO, he mantenido la expresión original por ahora.

Imprime 1 en Python 3, 2 en V, 3 en Minkolang, 4 en> <>, 5 en Python 2, 6 en SMBF, 7 en Japt, 8 en Retina, 9 en Perl, 10 en Befunge-93, 11 en Befunge -98, 12 en Fission, 13 en Ruby, 14 en Turtléd, 15 en Haystack, 16 en Pyth, 17 en Julia, 18 en Cardinal, 19 en Reng, 20 en Prelude y 21 en Nim .

Tenga en cuenta que Nim en ideone.com usa la versión 0.11.2, que es un poco demasiado antigua, ya que este programa se basa en #[ ... ]#comentarios de varias líneas agregados a principios de 2016.

Gracias al intérprete de Windows de Cardinal, mi flujo de trabajo ahora consta de dos computadoras portátiles y una Python http.serveren el medio.

Editar - algunas sugerencias más:

• El 8comienzo de la última línea es establecer el límite de Retina en los primeros 8 partidos, de lo contrario, sin Retina se generaría 2. Tenga en cuenta que esto significa que la expresión regular de la línea final solo debe coincidir al menos 8 veces en la segunda última línea ahora, en lugar de exactamente 8: durante mi intromisión modifiqué Prelude para que Retina fuera correcta, pero resultó que al final no era necesario. .
• La cita no coincidente al final de la primera línea es para que Pyth no se queje de una sintaxis no válida para el resto del código.
• Si modifica la segunda línea, es posible que 6@deba cambiar el Minkolang, lo que hace que el puntero salte 6 espacios para aterrizar en el ^.
• Hay un par de []ahora, por lo que SMBF debe estar en una celda 0 antes de que golpee [o, como alternativa, el interior necesita limpiar la celda.

Probablemente haya más en el golf (incluso ahora veo un espacio perdido antes del %Cardinal), pero realmente debería dejar de jugar golf en las primeras horas de la mañana.

51. Ensamblaje (x64, Linux, AS) , 1086 bytes

#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

␉es una pestaña literal, ␛un carácter ESC literal; Stack Exchange destrozaría el programa de otra manera. Recomiendo copiar el programa desde el cuadro de "entrada" del enlace TIO a continuación, si desea trabajar en él.

¿Querer aprender más? ¡Prueba el chat de polygot !

Pruébalo en línea!

Puntaje VIP ( Impresora entera versátil ): .008186 (para mejorar, la siguiente entrada no debe tener más de 1151 bytes)

Este programa imprime 51 en Asamblea, 50 en Bash, 49 en Octave, 48 en Deadfish ~, 47 en Lily, 46 en Cubix, 45 en PicoLisp, 44 en alphuck, 43 en reticular, 42 en mal, 41 en brainf *** , 40 en Minimal-2D, 39 en CoffeeScript, 38 en C, 37 en C ++, 36 en Labyrinth, 35 en INTERCAL, 34 en Rail, 33 en Incidente, 32 en Whirl,31 en SNUSP modular, 30 en espacio en blanco , 29 en disparador, 28 en Brain-Flak, 27 en Perl 6, 26 en 05AB1E, 25 en Pip, 24 en Thutu, 23 en Hexagony, 22 en Underload, 21 en Nim, 20 en Preludio, 19 en Reng, 18 en Cardinal, 17 en Julia, 16 en Pyth, 15 en Haystack, 14 en Turtlèd, 13 en Ruby, 12 en Fisión, 11 en Befunge-98,10 en Befunge-93, 9 en Perl 5, 8 en Retina, 7 en Japt, 6 en SMBF, 5 en Python 2, 4 en> <>, 3 en Minkolang, 2 en V / Vim y 1 en Python 3.

Verificación

La mayoría de los idiomas son probados por el controlador de prueba que se muestra arriba.

• Reng se puede probar hasta la salida 19 aquí .

• SNUSP modular se puede probar hasta la salida 31 aquí .

• Se ve la forma del cubo de Cubix aquí

• El incidente se verifica manteniendo los tokens equilibrados como se describe en las respuestas anteriores.

• Para Deadfish ~, se puede probar con salida 48 con esto . Tenga en cuenta que Deadfish ~ toma el políglota para que se alimente con stdin, pero imprime una serie de >>indicaciones en la salida estándar, que son una consecuencia inevitable de ejecutar cualquier programa Deadfish ~.

• El ensamblaje se puede probar hasta la salida 51 aquí

Gracias y felicidades

Cuando la respuesta 50-en-1-k de @ ais523 cayó hace 2 semanas, una lágrima rodó por mi mejilla. Era muy hermoso Y fue en Bash. Fue demasiado perfecto.

Me volví hacia mi esposa y le dije: "Creo que el políglota está hecho", sintiendo un orgullo inmenso.

Se giró para mirarme a los ojos, se detuvo un momento y dijo: “Bien. Ahora saca la basura.

Sin embargo, lo que ella quiso decir fue que sintió una profunda alegría por mí y mis amigos de Internet. Gracias y felicidades a todos.

Explicación de montaje

En los días que siguieron, mi mente siguió vagando de regreso a algo que @ ais523 dijo en el chat políglota poco antes de publicar Bash. Señaló que algunos sabores de montaje utilizan #comentarios de línea basados ​​y/* comentarios de bloque. Bueno, eso fue suficiente para que perdiera la cabeza lentamente durante las próximas 2 semanas.

Existe una especie de desafío implícito en los políglotas para incluir lenguajes legítimos. Estoy usando el término legítimo aquí muy libremente, pero creo que todos podemos entender lo que quiero decir. Una cosa es incluir Brainf ***, pero otra cosa es incluir a personas como Mathlab o R. Assembly ciertamente cae en la última categoría, y mi mente no podía dejarlo ir. Pero no sabía nada de la Asamblea, así que esta fue una batalla cuesta arriba.

Después de golpearme la cabeza contra el problema por un tiempo, buscando una forma para que coexistan Ensamblado y C / C ++, encontré que esta es la documentación para el ensamblador GNU:

Para ser compatible con ensambladores anteriores, las líneas que comienzan con '#' tienen una interpretación especial. Seguir el '#' debería ser una expresión absoluta (ver Expresiones): el número de línea lógica de la siguiente línea. Entonces se permite una cadena (ver Cadenas): si está presente, es un nuevo nombre de archivo lógico. El resto de la línea, si corresponde, debe ser un espacio en blanco.

Me di cuenta de que esto era bastante similar a nuestra directiva de preprocesador para C / C ++ en la línea 1 del políglota. Después de una prueba y error, encontré que #1 “bla” 1//*ingresaría un comentario de bloque solo para la Asamblea.

Y así se hizo un políglota.

Con los mayores problemas de bloqueo resueltos, me propuse jugar al golf en este ejemplo de hola mundo.

.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

Crédito del autor principal

En realidad, mentí hace un minuto, la primera versión del código de la Asamblea que utilicé estaba en la sintaxis de AT&T, que es una de las dos ramas sintácticas de la Asamblea. Uno de los elementos principales de la sintaxis de AT&T es que sus referencias de registro usan un %prefijo y esto es un problema para el políglota. Cardinal lo usa %como un origen de puntero, por lo que si ensuciamos un montón de %cosas, sería como una segunda reacción de fisión.

La otra rama sintáctica, que no usa % como prefijo de registro, se llama sintaxis Intel. El exploit que estamos usando en el políglota para pasar la primera línea e ingresar un comentario de bloque está en GNU Assembler (GAS o AS para abreviar). AS tiene la característica feliz de permitir ambas ramas sintácticas. Solo tiene que declarar que desea utilizar la sintaxis de Intel, que está sucediendo en la línea 1 del código de ensamblaje.

El ensamblaje utiliza registros, que son un pequeño número de ubicaciones de memoria ubicadas literalmente en la CPU para la velocidad de acceso. Esto no es exclusivo de Assembly aparte del hecho de que su uso no se abstrae de la preocupación del desarrollador.

Existen diferentes tipos de registros que se utilizan para diferentes propósitos. De Wikipedia:

• AX multiplicar / dividir, cargar cadenas y almacenar

• Recuento de CX para operaciones de cadena y turnos

• Dirección del puerto DX para IN y OUT

• Registro de índice BX para MOVE

• SP apunta a la parte superior de la pila

• BP apunta a la base del marco de la pila

• SI apunta a una fuente en las operaciones de flujo

• DI apunta a un destino en las operaciones de flujo

AX se utiliza en la línea de la función _start aquí: mov rax, 1. El ren raxindica que la memoria es de 64 bits. Si cambiamos esto por un e, eso indicaría una memoria de 32 bits, que es totalmente válida para hacer con un procesador de 64 bits. Simplemente no usaríamos la mitad superior de la memoria disponible. Para indicar memoria de 16 bits, simplemente usa ax, lo cual está bien para nosotros porque solo estamos imprimiendo enteros. Entonces podemos jugar unos pocos bytes cambiando todas las referencias de registro a 16 bits.

De acuerdo, no todas las referencias de registro podrían descartar el r. mov rsi, OFFSET FLAT:msg. Si está familiarizado con Assembly, pero no con esta declaración, es porque esto era semi exclusivo de AS. Al menos, eso es lo que deduje de esto , lo que me ayudó a reducir la declaración a solo lea rsi,m.

Después de esto, experimentalmente descubrí que podía derribar _start:a solo _py cortar .global _startcompletamente con solo una advertencia emitida. En segundo lugar, msg:se redujo a una sola variable de carácter p:. Elegí ptanto la variable de cadena como la función de inicio para compensar parte del sensamblaje agregado para beneficio de Alphuck.

Luego, puse ;para delimitar las instrucciones para ponerlos a todos en una línea. Esto es principalmente para evitar un seguimiento excesivo #//en cada línea para beneficio de Thutu. Además, me di cuenta de que nuestro ensamblador no parecía distinguir entre mayúsculas y minúsculas, por lo que solo escribí varios caracteres en mayúscula o minúscula para evitar el desequilibrio del incidente.

Este golf nos llevó a:

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

Después de todo esto, Japt y Underload fueron los únicos niños problemáticos en esta respuesta. Japt tenía algo de carne con el *agregado en la línea 1, pero parecía solucionarse volviendo a la puts(p);línea desde la respuesta de C ++. Terminé tirando un (en esta línea también y luego cerrándolo en la línea de Octive. Esto fue para que Underload dejara de fallar. Se tuvo un tratamiento similar en la línea 1 para agregar *allí.

Esto fue suficiente para cumplir con los requisitos de bytes de este desafío. De hecho, verifiqué esto produciendo esta versión del políglota. Pero quería intentar mejorar la puntuación VIP también si es posible. Y como cumplí con todos los requisitos del desafío, me sentí bien al colaborar para jugar golf en el código. Así que me detuve en el chat políglota para buscar ayuda de golf.

Debemos ir más profundo

@ ais523 demostró una técnica de pasar las instrucciones al ensamblador como código de máquina con esta declaración.

.text;.long 2298589328,898451655,12,178790,1018168591,84934449,12597 El código de máquina es una serie de instrucciones numéricas ejecutadas directamente por la CPU que se pueden representar en decimal, hexadecimal u octal. Para nuestros propósitos, el decimal es el más corto desde que (el hexadecimal toma una ventaja 0xpara representar). La .longdeclaración aquí es hacer la declaración de que lo que sigue es una serie de instrucciones de código de máquina decimal.

Bueno, también examiné esta declaración un poco para ver qué permitiría el ensamblador, e hice un par de cambios. Primero, descubrí que puedo eliminar .text;todo junto, con solo problemas de advertencia, que fue un ahorro de bytes bastante vendido. Luego, un poco más tarde, también encontré esta declaración en la documentación de especificaciones AS

.long es lo mismo que .int

Bueno. Entonces, podemos hacer ese intercambio por un byte rápido. Ahora nuestro ensamblaje, pero realmente código de máquina, se redujo a esto:

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

Si bien todo esto está muy bien, es bastante difícil trabajar directamente con el código de máquina y al menos quería ver cómo hacer todas las traducciones. Entonces, idealmente, nos gustaría desglosar el código de la máquina de nuevo al ensamblaje. La forma más fácil de hacerlo es tomar un volcado de objetos, que @ ais523 me demostró con este fragmento de código.

Aquí está el fragmento de código.

Y aquí está solo la Asamblea.

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)

Ese enlace también muestra algunos números hexadecimales de 2 caracteres junto a cada línea de ensamblaje. Esos corresponden a las instrucciones decimales. Por ejemplo, si pones 2298589328en este convertidor decimal a hexadecimal, 8901B090regresas. Y si te fijas bien, esas son las primeras 4 instrucciones hexadecimales del volcado de objetos (en orden inverso).

Por lo que puedo decir, los conjuntos de 4 números hexadecimales siempre se usan para convertir a decimal y el truco principal para guardar el byte que se usa aquí es estructurar el ensamblado de modo que los últimos varios números hexadecimales en nuestros 4 conjuntos sean 00. Estos luego se transformarán a ceros a la izquierda cuando los ponemos en la .intdeclaración que simplemente se omiten.

Esto es lo que está sucediendo en la 12declaración. En la parte hexadecimal del objeto volcado esto es 0c 00 00 00.

Esto es hasta donde tengo entendido de la Asamblea en 2 semanas. ¡Qué curso acelerado!

Incidente

El incidente fue una solución más difícil en la implementación de ensamblaje más corto porque ponderó las fichas políglotas mucho más pesadas en la parte superior. Aquí está el informe del incidente.

• ! en la línea 2 se destokeniza !

• El primero EAen la línea INTERCAL se destokeniza

• El último espacio en la penúltima línea destokeniza una ficha espacio-espacio.

• 85 en la última línea se destokeniza

• El Ren #<R>"3"O.destokenizaR

• 65en <>{#65 }//tokenizes65

• 16 en la última línea se destokeniza

• 89 en la última línea se tokeniza

Cardenal

Me acabo de dar cuenta de que hice un cambio en Cardinal que olvidé documentar. Pasé algún tiempo buscando formas de ahorrar bytes, y decidí aprender Cardinal. Después de un poco de tiempo con la documentación, vi esta línea.

= copia el valor activo del puntero en su valor inactivo.

Este no fue un truco utilizado en el políglota. La solución anterior incluía estas instrucciones: `++ ~ * t

++ incritaciones hasta 2.

~ cambia la pila activa

* agrega las pilas.

Me di cuenta de que se ~*podía lograr solo con las =instrucciones, así que reelaboré la solución para eliminar algunos intercambios de pila inútiles y agregar este pequeño ahorro de bytes.

6. SMBF , 45 bytes

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

Pruébalo en línea

Este programa imprime 1 en Python 3, 2 en V, 3 en Minkolang v0.15, 4 en> <>, 5 en Python 2 y 6 en SMBF.

Utiliza SMBF (también conocido como Brainfuck auto modificable) <++++<>.. El puntero se mueve hacia la izquierda (hasta el último carácter del código fuente) y la celda se incrementa cuatro veces y luego se imprime.

13. Ruby (129 bytes)

#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

Tenga en cuenta el Esccarácter literal en la última línea entre el jy d, según la respuesta Perl de ais523 .

Pruébalo en línea!

Imprime 1 en Python 3, 2 en Vim, 3 en Minkolang, 4 en <> <, 5 en Python 2, 6 en SMBF, 7 en Japt, 8 en Retina, 9 en Perl, 10 en Befunge, 11 en Befunge- 98, 12 en fisión y 13 en rubí.

Solo una modificación menor a la printdeclaración existente para abusar del hecho de que 0es verdad en Ruby. Tuve que agregar algunos espacios a las otras declaraciones para que se analizara correctamente.

15. Pajar (141 bytes)

#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

Nota: hay un ESCafter oen la tercera línea y after jen la última línea

Imprime 1 en Python 3 , 2 en Vim, 3 en Minkolang, 4 en <> <, 5 en Python 2 , 6 en SMBF, 7 en Japt, 8 en Retina, 9 en Perl, 10 en Befunge, 11 en Befunge- 98 , 12 en Fission, 13 en Ruby, 14 en tortuga y 15 en Haystack.

Pruébalo en línea!

Explicación

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

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

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

Hay un carácter ESC literal en el código real entre el jy d; se ha reemplazado con un ␛ aquí para mayor visibilidad.

Esto imprime 1 en Python 3 , 2 en Vim (probado localmente, pero aquí hay un enlace para el lenguaje muy similar V), 3 en Minkolang , 4 en <> < , 5 en Python 2 , 6 en SMBF , 7 en Japt , 8 en Retina y 9 en Perl .

Consigamos algunos lenguajes exotéricos más, abusando de la aritmética que funciona de manera diferente en diferentes idiomas. ( NoneEs Falsey- en Python, pero Truthy en Perl, y and/ orcadenas funcionan de la misma manera en los dos idiomas.)

Además de Python, también tuve que cambiar el código vim. En lugar de convertirlo en una serie de no-ops, simplemente dejé que inserte basura, luego eliminé la basura nuevamente al final.

36. Laberinto , 647 bytes

#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

␉es una pestaña literal, ␛un carácter ESC literal; Stack Exchange destrozaría el programa de otra manera. Recomiendo copiar el programa desde el cuadro de "entrada" del enlace TIO a continuación, si desea trabajar en él.

¡Pruébalos en línea!

Atropellar

Este programa imprime 36 en Labyrinth, 35 en INTERCAL, 34 en Rail, 33 en Incidente, 32 en Whirl, 31 en Modular SNUSP, 30 en Whitespace, 29 en Trigger, 28 en Brain-Flak, 27 en Perl 6, 26 en 05AB1E , 25 en Pip, 24 en Thutu, 23 en Hexagony, 22 en Underload, 21 en Nim, 20 en Prelude, 19 en Reng, 18 en Cardinal, 17 en Julia, 16 en Pyth, 15 en Haystack, 14 en Turtlèd, 13 en Ruby, 12 en Fisión, 11 en Befunge-98, 10 en Befunge-93, 9 en Perl 5, 8 en Retina, 7 en Japt, 6 en SMBF, 5 en Python 2, 4 en> <>, 3 en Minkolang , 2 en V / Vim y 1 en Python 3.

Verificación

La mayoría de los idiomas son probados por el controlador de prueba que se muestra arriba. Puede probar Reng aquí y Modular SNUSP aquí ; producen 19 y 31 respectivamente. @ ais523 ayudó a depurar y corregir el código de Incidente, que ahora funciona.

Cómo funciona el laberinto

Labyrinth comienza a desplazar un poco algunas de las columnas en la fuente, pero después de unos pocos pasos, el puntero llega a donde Nestá en la segunda línea (inicialmente, cuando llega el puntero ya no está Nallí), moviéndose hacia la derecha , con un 0 en la parte superior de la pila. Luego, simplemente empuja e imprime un 36 y termina con36!@

Las cosas que hice se rompieron

Sabía que quería agregar Labyrinth, ya que es uno de los pocos esolangs que conozco un poco. Con su depurador, descubrí que al cambiar el 8 en la última línea a 0, Labyrinth no se atascó en un bucle infinito y, curiosamente, nada más pareció romperse. A partir de ahí, simplemente agregué el comando raw 36 y output que necesitaba, y esos convenientemente me llevaron @a terminar las cosas.

Luego, fue a reparar lo que rompí: Minkolang, Cardinal y Hexagony.

El !estaba haciendo Minko omitir el siguiente carácter, que es necesaria para dar por terminado, por lo que sólo añade un extra @. Hasta aquí todo bien.

El cambio en la longitud de la segunda línea hizo que Cardinal se perdiera su declaración de salida. Intentar agregar un extra .en la primera línea hizo que Prelude se volviera loco (no tengo idea de por qué, sinceramente), así que elegí un método diferente y lo dejé caer en la segunda línea. Eso inadvertidamente generó un tercer puntero Cardinal, por lo que rellené las cosas con un ?(no es una elección necesaria, solo lo primero que encontré que solucionó tanto a Fission como a Cardinal).

La hexagonía fue, afortunadamente, una solución relativamente simple, simplemente tiré una cadena de letras para que el puntero encontrara el código. Pensé que el alfabeto no debería haber aparecido antes y que no causaría problemas con el Incidente. Esto también es cuando me di cuenta de que no había probado el incidente. Gracias a @ ai523, descubrí que solo necesitaba un signo de exclamación adicional, por lo que ela cadena del alfabeto se cambió a a !.

Puntajes de la impresora entera versátil

Solo por diversión y comentarios de @Stewie Griffin sobre la pregunta, aquí hay un fragmento que muestra cómo cada respuesta habría obtenido si se hubiera ingresado en "La Impresora de Verstatile Integer".

// 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 bytes

#  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

␉es una pestaña literal, ␛un carácter ESC literal; Stack Exchange destrozaría el programa de otra manera. Recomiendo copiar el programa desde el cuadro de "entrada" del enlace TIO a continuación, si desea trabajar en él.

Pruébalo en línea!

Puntuación VIP (Impresora entera versátil): 0.01329

Atropellar

Este programa imprime 41 en brainf ***, 40 en Minimal-2D, 39 en CoffeeScript, 38 en C, 37 en C ++, 36 en Labyrinth, 35 en INTERCAL, 34 en Rail, 33 en Incidente, 32 en Whirl, 31 en SNUSP modular, 30 en espacios en blanco, 29 en disparador, 28 en Brain-Flak, 27 en Perl 6, 26 en 05AB1E, 25 en Pip, 24 en Thutu, 23 en Hexagony, 22 en baja carga,21en Nim, 20 en Prelude, 19 en Reng, 18 en Cardinal, 17 en Julia, 16 en Pyth, 15 en Haystack, 14 en Turtlèd, 13 en Ruby, 12 en Fisión, 11 en Befunge-98, 10 en Befunge-93 , 9 en Perl 5, 8 en Retina, 7 en Japt, 6 en SMBF, 5 en Python 2, 4 en> <>, 3 en Minkolang, 2 en V / Vim y 1 en Python 3.

Verificación

La mayoría de los idiomas son probados por el controlador de prueba que se muestra arriba. Puede probar Reng aquí y Modular SNUSP aquí ; producen 19 y 31 respectivamente, según sea necesario.

El controlador de prueba se ha actualizado para incluir el Tokenizer, finalmente. Todo el código C se almacena como argumento desde la perspectiva de Bash Script. También cambié la salida para ajustar horizontalmente con un espacio final después de cada token en lugar de generar verticalmente. Esta fue solo mi preferencia, para que coincida con la salida de espacios en blanco. Pero cualquier otra persona puede cambiarlo si siente que es demasiado confuso.

También realicé un ajuste de Test Driver para manejar el espacio entre columnas para el carbón UFT8 de Turtlèd en el resumen. ¡Esa desalineación me estaba volviendo loco! El "arreglo" es bastante hack-ish ya que solo busca un è y cambia el ancho de columna para ese caso, pero hace el trabajo.

Explicación

En primer lugar, quiero decir cuán impresionante fue el fragmento de código de resumen de puntuación de la impresora de versátil entero de @ SnoringFrog de la última publicación. He estado calculando respuestas antes de publicar por un tiempo, y esto me ha inspirado a mantenerlo pequeño. Creo que con el tiempo podremos superar la respuesta de @ sp3000.

Así que comencé a trabajar en esta respuesta intentando descifrar lo que pude y tuve bastante éxito. Incluso tuve una respuesta en un idioma diferente con un recuento total de bytes menor que # 40. Pero cuando intenté jugar Minimal-2D, tuve que aprender BF para poder trabajar mejor con sus derivados y en el proceso encontré el récord de @ Primo ¡Hola, Mundo! . Me enamoré de la elegancia.

Resultó que Minimal-2D no era lo suficientemente eficiente como para utilizar la técnica de inicialización de cinta utilizada por @Primo, pero ahora creo que, de todos modos, probablemente sería demasiado pesado. Solo estamos tratando de imprimir un número entero después de todo. Pero @Primo me envió por el camino para aprender a multiplicar en BF, que traje al código Minimal-2D.

Luego de todo esto, volví a leer el comentario de @ SnoringFrog sobre cómo incluir BF y me di cuenta de que no solo podía hacerlo, sino que podía usar gran parte del código Minimal-2D que había escrito en la respuesta BF. Así que busqué para responder con BF, y aquí estamos.

Una cosa más antes de entrar en detalles. Hubo un par de cambios que hice por razones ajenas al golf. Primero, moví la mayor parte del código que @SnoringFrog agregó a justo debajo de los idiomas 2D en las varias filas superiores. Para mí, es un movimiento estratégico a largo plazo para evitar que los lenguajes 2D atraviesen el centro del políglota con el fin de evitar futuros errores cuando sea posible. El golpe de byte fue bajo para este movimiento, así que lo hice.

En segundo lugar, durante los diversos factores, aprendí que Begunges y Minkolang generan un espacio final después de las salidas numéricas y que esta fue la causa de los bytes nulos que hemos estado viendo en el controlador de prueba para estos idiomas. Lo arreglé enviando el valor de la pila como un código ascii (que no incluía la función de espacio final), en lugar del valor directamente. También hubo un pequeño byte para este cambio, pero ahora la salida del Test Driver es tan uniforme. ¿Cómo no iba a hacerlo?

SM / BF

Repasemos rápidamente lo básico. Estos son los únicos comandos válidos para SMBF y 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

Ambos idiomas tienen una cinta de memoria donde los valores se almacenan y cambian. La única diferencia de SMBF es que cualquier código que se esté ejecutando también se almacena en la cinta de memoria a la izquierda del punto de partida. Como señaló @SnoringFrog, lograr que SMBF y BF produzcan resultados diferentes depende de mover el puntero de memoria a la izquierda del origen. En el intérprete BF de Tio, el puntero de memoria es capaz de moverse hacia la izquierda del origen y encontrará ceros en lugar de los códigos ascii de Polyglot que ve SMBF. Aquí hay un ejemplo que se puede ejecutar tanto en SMBF como en BF para ejemplificar la diferencia.

Al comienzo del políglota, los Befunges requieren que la >segunda fila se ejecute hasta su finalización y Perl6 requiere que cada uno >sea ​​precedido por a <. Entonces, SM / BF comienza con <>dejar el puntero de memoria en el origen, luego golpea uno [que salta algunos caracteres ofensivos para ambos idiomas a ]la 6ta fila.

A continuación, incrementamos la celda de memoria de origen para ambos idiomas y movemos el puntero de memoria hacia la izquierda con +<. (Para la convención conversacional, llamaremos a la celda de memoria de origen como celda 0, celdas a la derecha del origen 1, 2, ... Y celdas a la izquierda -1, -2, ...). La celda -1 contiene el código asci del último carácter en el políglota en SMBF y 0 en BF, por lo que cuando [se encuentra el siguiente , solo BF salta al siguiente ]mientras SMBF pasa al código.

A medida que SMBF atraviesa [.>-], imprime los 6 que se encuentran al final del políglota y luego mueve el puntero de memoria nuevamente a la celda 0, estableciendo su valor nuevamente en cero para salir del ]. Para revisar, las cintas en esta pinta son: las celdas negativas de SMBF contienen el políglota, y es 0 y las celdas positivas tienen cero. Las celdas negativas y positivas de BF tienen cero mientras que su celda de origen tiene 1.

A continuación, >mueve SMBF a la celda 1 y BF a la celda 0, lo que permite que BF ingrese su bloque de código privado: [<+++++[>++++++++++<-][<<<]>+.---.>](he eliminado los caracteres que no son BF de esto). Aquí, volvemos a la celda -1 e inicializamos nuestra variable de control de ciclo (celda -1) a un valor de 5. Luego ingresamos al ciclo donde agregamos 10 a la celda 0 y disminuimos la celda -1 cinco veces antes de salir del ciclo donde estaremos apuntando a la celda -1 con un valor de 0.

Luego nos encontramos [<<<]mientras apuntamos a un cero, por lo que BF no pasa por esto. El propósito aquí es equilibrar un número de >'s con los anteriores <para que Perl6 no se equivoque.

En este punto, la celda 0 tiene un valor de 51. El valor ascii de 4 es 52, por lo que movemos el puntero a la celda 0 y agregamos 1, luego imprimimos el valor. Y finalmente, disminuimos la celda 0 al carácter ascii 1 e imprimimos nuevamente antes de configurar el puntero de memoria en la celda 1 (valor 0) para salir más allá del ].

SMBF y BF ambos golpearon el último [en la línea 8 siguiente mientras ambos descansan en un valor 0. Por lo tanto, ambos saltan el código Minimal-2D restante hasta que ]se encuentra en la línea 11. Pero esto es de corta duración porque la línea 12 comienza con otra [que lleva a ambos idiomas casi al final del políglota, donde no se encuentran más instrucciones.

Refactores

Minimal-2D

La reescritura de Minimal-2D fue principalmente para guardar algunos bytes de una manera similar al truco de multiplicación de BF. Sin embargo, Minimal-2D no tiene los caracteres [y ]para el control de bucle. En cambio, tiene estos comandos:

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

Estos pueden usarse para producir la misma estructura lógica, aunque en una mansión 2D, como la de BF. Por ejemplo, BF ++++++[>++++++<-]>.es equivalente a esto en Minimal-2D.

Aquí hay una versión simplificada del código de Minimal-2D en el políglota, con todo el código extraño eliminado y todos los lugares que contienen caracteres reemplazados #.

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

La Dlínea 1 envía el puntero de instrucciones a la Llínea 8 de la poliglota que envía el puntero a la izquierda. Aquí establecemos la variable de control de bucle (celda 0) en 7, movemos el puntero de memoria a la celda 1 e ingresamos un bucle. En el bucle, agregamos 3 a la celda 1, disminuimos la celda 0 y luego verificamos si el valor de la celda 0 todavía es cero. Si no, agregamos otros 8 a la celda 1, luego disminuimos y verificamos nuevamente. El resultado de este ciclo es que el valor de la celda 1 se establece en 51 al final del ciclo (6 * 8 + 3).

Salimos del bucle saltando U, moviendo el puntero de memoria a la celda 1 y bajando hacia la derecha en la línea 11 del políglota. Y finalmente, incrementamos hasta el valor ascii para 4 y luego disminuimos hasta el valor ascii para 0 antes de correr hacia la derecha para finalizar el programa.

Retina

La retina tenía muchos requisitos con los que era difícil trabajar para todos los derivados de BF. No le gustan los consecutivos +o no coincidentes ()o []. Pero estos son realmente requisitos para cualquier otra línea, por lo que gran parte del trabajo para BF, SMBF y Minimal-2D giraba en torno a poner la mayor parte del código en líneas pares.

Sin embargo, el único byte comprometido únicamente con Retina es |al final de la línea 11. Para citar @ ais523 “la mayoría de las expresiones regulares que terminan en | coincidirá con cualquier cosa ". Sin esto, Retina devuelve 0. Por qué esto lo soluciona, no lo sé. No he tenido que profundizar demasiado en Retina, probablemente porque he estado evitando la larga cola. Pero al igual que Prelude, descubrí que no necesito entenderlo tanto como necesito entender cómo depurarlo, que en este caso consistió principalmente en eliminar líneas (en múltiplos de 2) hasta que encontré la línea eso hace que se rompa. Adiviné esta solución basada en el comentario de @ ais523, y fui recompensado. Soy demasiado genial para la escuela, supongo.

Cardenal

Me gustó la ubicación de @ SnoringFrog de Minimal-2D en relación con el código de Cardinal. Es una buena ubicación teniendo en cuenta que Cardinal no molesta a Retina, y parecía permitir entretejer con Minimal-2D. Entonces, cuando me propuse trasplantar tierra Minimal-2D a 2D, traje a Cardinal para el viaje. Sin embargo, hubo un par de cambios cosméticos en Cardinal. Primero, lancé >casi al comienzo de su declaración #p x%>~~~+ +~*ttt*.xpara Minimal-2D para cambiar los punteros de memoria dentro de su ciclo / Segundo, moví todo un carácter a la derecha para dar espacio Minimal-2D para salir de su ciclo con gracia. En peste aguijón es para este relleno de caracteres.

Befunge / 98

Los Befunges son en realidad donde comencé a intentar jugar golf en el políglota, ya que el refactor de C ++ cambió todos los demás códigos de lenguaje 2D, excepto este. Al tratar de saber que WTF estaba sucediendo en este código, encontré esto en la documentación de Begunge:

El .comando sacará un valor de la pila y lo mostrará como un entero decimal, seguido de un espacio , algo así como Forth. ,mostrará un valor, lo interpretará como el valor ASCII de un carácter y generará ese carácter ( no seguido de un espacio ) .

¡Santos humos! Podemos limpiar los bytes nulos en la salida. Después de esto, todo fue solo cuestión de descubrir cómo ingresar los valores asci más grandes y segregar el código. Befunge-98 tenía un código de salto ;contando para saltarse la [77*,68*,@de ;[77*,68*,@;'1,'1,q, que nos dio la segregación.

Befunge-98 también tenía un comando ( ') para tomar el código ASCII del siguiente personaje. Entonces, '1,toma el código asci para el carácter 1, lo coloca en la pila y luego imprime el carácter ascii para el valor superior en la pila con ,. Solo tengo que hacer esto dos veces para imprimir 11 y soltar una qpara salir con gracia.

Befunge propiamente dicho es un poco menos conveniente, pero solo justo. Aquí tenemos que realizar un cálculo para poner el código deseado en la pila. Afortunadamente, nuestros códigos se multiplicaron fácilmente con 7 * 7 y 6 * 8 antes del mismo comando de salida ,. Luego salimos de Befunge @antes de que el código de su hermano mayor contaminara la salida.

Minkolang

Después de encontrar una solución para los espacios finales de Befunge, me entusiasmó la idea de encontrar una solución de Minkolang también y la documentación de Minkolang decía que el comando de salida que se había utilizado hasta este punto funcionaba de la misma manera que el Intérprete de Befunge. Oresultó estar documentado como otro comando de salida, que no se describió como compartir este Begunge-ness, así que solo tomé una foto en la oscuridad e intenté sacar la cadena "3". Victoria impecable.

> <>

Una de las primeras cosas que miré al mover el código Minimal-2D fue verificar que podía mover> <> junto con él. Si iba a tratar con el transversalismo políglota 2D, iba a tratar con todas las transgresiones. Básicamente, la suerte me abrió paso en la solución de poner ;n4 al final de la línea 1 y avanzar \Dmás atrás en la línea 1. Por cierto, no sabía que> <> podría dirigirse hacia abajo antes de la respuesta 40, ya que está tan bien contenido . Me gustaría pensar que esto podría usarse más tarde para divergir> <> de otro lenguaje similar.

Perl6

He hablado sobre algunos de los problemas de <>equilibrio de Perl6 en otra parte de esta respuesta, por lo que no volveré a analizarlo nuevamente. Pero sí quiero señalar que me mudé #>27.say#a la penúltima línea. Esto no tiene un propósito funcional en esta respuesta. Realmente hice este movimiento para satisfacer una respuesta diferente que terminé no usando esta ronda. Decidí dejarlo ya que planeo publicar esa respuesta en mi próxima oportunidad y no quería molestarme en deshacerlo y volver a hacerlo.

Corrección de errores

05as1e

A 05as1e definitivamente no le gustó tanto el nuevo código de Begunge como la versión anterior. Supongo que es el ,s ya que ese es el único personaje revolucionario. En cualquier caso, tuve que "retroceder más en la línea dos para ocultar los comandos ofensivos, y sabía que "tenía que ir antes de la ruta del código Befunge ya que "era un sí en ambos idiomas. (Puedo inventar términos como yes-op ¿verdad?) La 2-dimensionalidad de Line 2 es bastante rígida, pero pude desplazar el <camino anterior del código de Begunge con el ". Sin <embargo, era un requisito de Perl6. (Tiene que tener un s <anterior >.) Pude dejar la <línea uno en un lugar adivinado por el instinto y la presciencia resolviendo 05ab1e y el desacuerdo de Perl6.

Giro

Los cambios de Befunge en la línea 2 agregaron un extra 1al políglota antes de la línea Incidente / Torbellino. Este extra 1hizo que Whirl comenzara a señalar las instrucciones incorrectas en la rueda. La primera 1en la directiva de preprocesador de C / C ++ fue solo una referencia de número de línea en el código, y esto podría ser fácilmente cualquier otro número de línea, por lo que lo cambié arbitrariamente 4para satisfacer Whirl.

Incidente

La cadena de destokenización al final del políglota es bien conocida en este punto, por lo que no voy a entrar en ella. Quité de la cadena lo que pude y agregué los nuevos tokens que se requerían. Hay 2 caracteres de destokenización que no están en esta cadena, aunque debo señalar. En primer lugar, el segundo Ren el #R+.----.R >]|que se necesita aquí porque es un punto de fusión de partida, y que era más seguro en esta línea porque ya existía un encabezado punto de fusión de partida en la misma dirección. En segundo lugar, el xde #= xes eliminar una ficha involucrado en un ␉␊#patrón, que se ha vuelto más común.

Otros

Hexagony, Whitespace y Prelude tuvieron todos los ajustes menores habituales, pero nada especial de lo que valga la pena hablar.

Pensamientos finales

Eso es todo lo que tengo para esta respuesta. Para aquellos que buscan un punto de partida en la próxima respuesta, sugeriría el mal. Parece viable, aunque no lo he mirado demasiado de cerca, pero sospecho que no sería demasiado difícil de integrar. Sé que tiene un comando de salto que debería ayudar a saltar la mayor parte del políglota. Buena suerte.

183. Imagen de arranque Intel 8080 (ZEMU), 9870 bytes

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

Pruébalo en línea!

Explicación

Gracias a Potato44 por la idea de agregar código de máquina, fue muy divertido hacer esta respuesta.

No hice el archivo CP / M COM porque restringe el tamaño del políglota a unos 60 KB, lo que quiero evitar. La imagen de arranque resultó aún más fácil de hacer que COM porque ZEMU carga el sector de arranque desde el sexto sector por defecto (basado en 1, sectores lógicos de 128 bytes), por lo que no es necesario ejecutar el inicio de Polyglot. El código de arranque debe estar en el desplazamiento 0x280 ((6-1) * 128) en el políglota.

Yo uso el emulador ZEMU que está vinculado desde esta página . Para ejecutar polyglot en ZEMU:

• Discos> A: seleccionar archivo políglota
• Opciones> Conjunto de instrucciones I8080
• Presione el botón de arranque

La función que imprime un carácter en la consola ( cns$ot) se copió de BIOS22Dv221.ASM de la distribución de ZEMU. Hice dos cambios: el carácter no está enmascarado en ASCII de 7 bits porque controlamos los parámetros y jrz cns$otse reemplaza por jz cns$otporque jrz(salto relativo si es cero) es la instrucción Zilog Z80 no presente en Intel 8080.

Programa inicial ( sintaxis Intel , ensamblador vinculado desde aquí ):

    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

Este programa contiene caracteres que no se pueden usar directamente en polyglot. La mayoría de los caracteres de control ASCII (código <0x20) están prohibidos en Simula, los caracteres no ASCII (código> = 0x80) no pueden aparecer solos porque el archivo debe ser UTF-8 válido. Entonces, el programa anterior es generado por otro programa que es válido UTF-8.

El siguiente programa genera el código necesario y salta a él. ld (hl),ano se puede usar debido a Grass ( 'w'==0x77). sub h(0x94) y xor a(0xAF) son bytes de continuación UTF-8, deben anteponerse con el byte inicial UTF-8. La instrucción ret nc(= 0xD0, retorno si no se lleva) se utiliza como byte de plomo UTF-8. Para que no haga nada, va precedido de scfinstrucciones (establezca el indicador de acarreo). También evitado ','(0x2C) y '.'(0x2E) para DOBELA. org 0100hLa directiva no se utiliza porque el ensamblador utilizado no la comprende (la organización se establece en la GUI). Este programa es independiente de la posición de todos modos. Me gustan más los mnemónicos de Zilog, así que los usé para un programa más largo.

Sintaxis de Zilog , ensamblador vinculado desde aquí :

  ; 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

Este programa se ensambla en:

! 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退

Debe estar en el desplazamiento 0x280 en el políglota (ver línea 2). La prueba de abstracción en el controlador de prueba verifica eso.

Refactorizaciones

Conchas

Se movieron las conchas a la línea más larga. Me gusta más este diseño porque los parens no se alinean con otros langs. Moorhenses y Flaks movidos antes de las conchas, para que no se rompan cuando se cambian las conchas. La línea más larga tiene este diseño ahora:

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

Nuevo código de conchas:

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

Código de conchas antiguas:

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

La longitud de $ase calcula por $(echo -n $a | wc -c)ahora (desde aquí ). Inicialmente usé esto para deshacerme #, pero ahora se usa debido a un código más corto. Las conchas pueden contener #porque los Flaks están antes que las conchas.

Yash (166) utiliza el comando echo incorporado que no admite opciones por defecto, por lo que "-n" y el salto de línea terminan siendo parte de la salida, lo que proporciona 4 bytes adicionales. Cuando no se establece, el valor ECHO_STYLEpredeterminado es SYSV(la -nopción no se acepta).

Este enlace TIO prueba el código en todos los shells.

Adicionales (((((antes de que los shells arreglen Underload y Retina Se agrega un par más de parens para esconderse 58de Prelude (cerrado con #)after exit). {antes ((((((es para Japt, sin él Japt cuelga.

Flaks

Debido a la reubicación de Flaks, el código de inicio se puede simplificar, solo ([])queda:

     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: []{}[][][]     ([]  )                                                             ({}<(((((()()())){}{})){}{})>)(({})){}{(<(<()>)({})({}<{}>({}){})>){({}[()])}}({}){}({}()<()()()>)   (<><()>){({}[()])}{           ...           }{}<>              ()

Este enlace TIO prueba el código en todos los Flaks.

Fisión y Cardenal

La fisión se trasladó a LNUSP: R"12"R _*. El segundo puntero se usa para terminar la fisión lo antes posible: en el tercer paso, consulte la respuesta 54 para obtener más información.

El cardenal fue trasladado a LNUSP: @ %"18". Como en Fission, el segundo puntero se usa para terminar Cardinal lo antes posible, en el tercer paso.

MarioLANG

Usar en ####...lugar de ====...como plataforma:

Minimal-2D

Polyglot con MarioLANG:

Wierd y 1L_a

Extraño: use el espacio en la línea 10 columna 79 para reflejar IP.
1L_a, Wierd: el espacio en la línea 9 columna 79 es importante.

Cúbicamente

Nuevo código: :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

Klein 201/100

Nuevo código: !|*****[[[828+*+@+*99]]]*****|!

Después de todo, la pila de multiplicaciones contiene un solo cero porque saltar de la pila vacía da cero. Este cero se agrega al número principal +junto a @. Anteriormente se descartaba con ?, vea la respuesta de Klein 001 .

Cómo funcionan las puertas en Klein:

Giro

El código Whirl es básicamente el mismo, el único cambio es que el código principal supone que la operación actual es ops.one (2), no ops.load (4).

Efectivamente, se puede pensar que Whirl tiene 3 operaciones:

• 1 rotar un paso
• 0 cambiar la dirección de rotación
• 00 ejecutar la instrucción actual y cambiar el anillo

Operaciones combinadas para simplificar el razonamiento sobre el programa:

• 0000 si la operación actual del anillo inactivo es noop, simplemente ejecute la operación actual del anillo activo sin ningún efecto secundario
• 11..11 rotar n pasos
• 011..11 cambiar de dirección y girar n pasos

0000ejecuta la instrucción actual del anillo activo, pero también ejecuta la instrucción actual del anillo inactivo como efecto secundario. Si la instrucción actual del anillo inactivo es inofensiva, entonces podemos centrarnos en las operaciones del anillo activo sin pensar qué está sucediendo con el anillo inactivo. Esto es especialmente útil con este programa porque tiene una separación clara: primero se crea el número 32 usando solo el anillo matemático y luego cambiamos al anillo de operaciones y ejecutamos 2 instrucciones allí (imprimir y salir).

Primero, quería que la operación actual en el anillo de operaciones no sea noop cuando el código principal comienza a ejecutarse. Tiene 2 ventajas: 1) el código principal de Whirl se puede ejecutar de forma independiente y 2) podemos olvidarnos por completo del anillo de operaciones al crear el número 32 con el anillo de matemáticas. Sin embargo, hace que el código sea más largo de lo que era, por lo que el código principal supone que la operación actual es ops.one (2). Significa que ops.value se establece en 1 como efecto secundario de las operaciones matemáticas, que luego se utilizan para imprimir. El código antiguo logró el mismo efecto con la instrucción ops.load, pero el uso de ops.one expresa más claramente la intención: establecer ops.value en distinto de cero.

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

El código nuevo es más corto porque el código antiguo tiene un par de interruptores de dirección redundantes en la segunda parte del programa, no por una nueva suposición.

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

Cómo mantener Whirl correcto al cambiar algo antes de la línea Incident / Whirl:

• asegúrese de que haya un número par de 0s antes del código Whirl principal
• asegúrese de que no haya dos 0s consecutivos
• agregue / elimine suficientes 1s hasta que Whirl vuelva a funcionar; agregar n 1s es equivalente a eliminar 12-n 1sy viceversa

Sin saberlo, rompí la primera regla cuando agregué Ropy. Cuando hay un número impar de 0s, el código principal comienza a ejecutarse con una dirección incorrecta del anillo de operaciones que rompe la instrucción de salida. Entonces ahora hay 0en la línea 3 que compensa 0en la línea 1.

Otros

CoffeeScript : console.log a&&39||180(desde aquí )

INTERCAL : movido a la línea 37
Brainfuck , Agony : movido a otros derivados de brainfuck en la línea 10

xEec : movido a 1L_a ( h#115# o#)

CSL : movido a la línea 80
Trefunge : movido a la línea 120
Gaot ++ , Stones : colocado en líneas separadas

16. Pyth (159 bytes)

#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

Nota: hay un ESCbyte ( 0x1B) después de oen la tercera línea y después de jen la última línea.

Esta fue una experiencia bastante divertida. Japt y Pyth son lenguajes de golf, pero Japt es infijo y Pyth es prefijo, y Pyth solicita automáticamente la entrada y falla si faltan argumentos.

Antes de la respuesta de Haystack, tenía una solución casi funcional que usaba #, que obtiene un código char en Japt y un bucle hasta error en Pyth. Pyth resulta ser muy útil en políglotas, ya que el comentario común char #esencialmente funciona como un silenciador de errores.

Cuando llegué a casa logré encontrar un código que funcionaba tanto en el uso //, que funciona como un comentario en Japt y dos divisiones en Pyth. Entonces solo era cuestión de hacer que los Befunges se enrutaran correctamente.

Es muy poco probable que esto sea óptimo, pero es lo suficientemente bueno por ahora. Traté de probarlos todos, pero agradecería mucho que alguien verificara dos veces que las salidas coincidan.

Imprime 1 en Python 3 , 2 en V , 3 en Minkolang , 4 en> <> , 5 en Python 2 , 6 en Brainfuck auto modificable , 7 en Japt , 8 en Retina , 9 en Perl , 10 en Befunge (-93 ) , 11 en Befunge-98 , 12 en Fission , 13 en Ruby , 14 en Turtléd , 15 en Haystack y

16 en Pyth .

Explicación

Lo que Pyth ve aquí es:

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

Esto se traduce en el siguiente pseudocódigo:

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"

El primer ciclo finaliza al intentar evaluar ;cuál no es una expresión válida. Entonces Pyth solo imprime 16.